pb_decode.c

   1 /* pb_decode.c -- decode a protobuf using minimal resources
   2  *
   3  * 2011 Petteri Aimonen <jpa@kapsi.fi>
   4  */
   5
   6 /* The warn_unused_result attribute appeared first in gcc-3.4.0 */
   7 #if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
   8     #define checkreturn
   9 #else
  10     /* Verify that we remember to check all return values for proper error propagation */
  11     #define checkreturn __attribute__((warn_unused_result))
  12 #endif
  13
  14 #define NANOPB_INTERNALS
  15 #include "pb.h"
  16 #include "pb_decode.h"
  17 #include <string.h>
  18
  19 typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;
  20
  21 /* --- Function pointers to field decoders ---
  22  * Order in the array must match pb_action_t LTYPE numbering.
  23  */
  24 static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = {
  25     &pb_dec_varint,
  26     &pb_dec_svarint,
  27     &pb_dec_fixed32,
  28     &pb_dec_fixed64,
  29
  30     &pb_dec_bytes,
  31     &pb_dec_string,
  32     &pb_dec_submessage
  33 };
  34
  35 /**************
  36  * pb_istream *
  37  **************/
  38
  39 static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count)
  40 {
  41     uint8_t *source = (uint8_t*)stream->state;
  42     stream->state = source + count;
  43
  44     if (buf != NULL)
  45     {
  46         while (count--)
  47             *buf++ = *source++;
  48     }
  49
  50     return true;
  51 }
  52
  53 bool checkreturn pb_read(pb_istream_t *stream, uint8_t *buf, size_t count)
  54 {
  55         if (buf == NULL && stream->callback != buf_read)
  56         {
  57                 /* Skip input bytes */
  58                 uint8_t tmp[16];
  59                 while (count > 16)
  60                 {
  61                         if (!pb_read(stream, tmp, 16))
  62                                 return false;
  63
  64                         count -= 16;
  65                 }
  66
  67                 return pb_read(stream, tmp, count);
  68         }
  69
  70     if (stream->bytes_left < count)
  71         PB_RETURN_ERROR(stream, "end-of-stream");
  72
  73     if (!stream->callback(stream, buf, count))
  74         PB_RETURN_ERROR(stream, "io error");
  75
  76     stream->bytes_left -= count;
  77     return true;
  78 }
  79
  80 pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize)
  81 {
  82     pb_istream_t stream;
  83     stream.callback = &buf_read;
  84     stream.state = buf;
  85     stream.bytes_left = bufsize;
  86 #ifndef PB_NO_ERRMSG
  87     stream.errmsg = NULL;
  88 #endif
  89     return stream;
  90 }
  91
  92 /********************
  93  * Helper functions *
  94  ********************/
  95
  96 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest)
  97 {
  98     uint64_t temp;
  99     bool status = pb_decode_varint(stream, &temp);
 100     *dest = (uint32_t)temp;
 101     return status;
 102 }
 103
 104 bool checkreturn pb_decode_varint(pb_istream_t *stream, uint64_t *dest)
 105 {
 106     uint8_t byte;
 107     int bitpos = 0;
 108     *dest = 0;
 109
 110     while (bitpos < 64 && pb_read(stream, &byte, 1))
 111     {
 112         *dest |= (uint64_t)(byte & 0x7F) << bitpos;
 113         bitpos += 7;
 114
 115         if (!(byte & 0x80))
 116             return true;
 117     }
 118
 119     PB_RETURN_ERROR(stream, "varint overflow");
 120 }
 121
 122 bool checkreturn pb_skip_varint(pb_istream_t *stream)
 123 {
 124     uint8_t byte;
 125     do
 126     {
 127         if (!pb_read(stream, &byte, 1))
 128             return false;
 129     } while (byte & 0x80);
 130     return true;
 131 }
 132
 133 bool checkreturn pb_skip_string(pb_istream_t *stream)
 134 {
 135     uint32_t length;
 136     if (!pb_decode_varint32(stream, &length))
 137         return false;
 138
 139     return pb_read(stream, NULL, length);
 140 }
 141
 142 bool checkreturn pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof)
 143 {
 144     uint32_t temp;
 145     *eof = false;
 146     *wire_type = (pb_wire_type_t) 0;
 147     *tag = 0;
 148
 149     if (!pb_decode_varint32(stream, &temp))
 150     {
 151         if (stream->bytes_left == 0)
 152             *eof = true;
 153
 154         return false;
 155     }
 156
 157     if (temp == 0)
 158     {
 159         *eof = true; /* Special feature: allow 0-terminated messages. */
 160         return false;
 161     }
 162
 163     *tag = temp >> 3;
 164     *wire_type = (pb_wire_type_t)(temp & 7);
 165     return true;
 166 }
 167
 168 bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type)
 169 {
 170     switch (wire_type)
 171     {
 172         case PB_WT_VARINT: return pb_skip_varint(stream);
 173         case PB_WT_64BIT: return pb_read(stream, NULL, 8);
 174         case PB_WT_STRING: return pb_skip_string(stream);
 175         case PB_WT_32BIT: return pb_read(stream, NULL, 4);
 176         default: PB_RETURN_ERROR(stream, "invalid wire_type");
 177     }
 178 }
 179
 180 /* Read a raw value to buffer, for the purpose of passing it to callback as
 181  * a substream. Size is maximum size on call, and actual size on return.
 182  */
 183 static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size)
 184 {
 185     size_t max_size = *size;
 186     switch (wire_type)
 187     {
 188         case PB_WT_VARINT:
 189             *size = 0;
 190             do
 191             {
 192                 (*size)++;
 193                 if (*size > max_size) return false;
 194                 if (!pb_read(stream, buf, 1)) return false;
 195             } while (*buf++ & 0x80);
 196             return true;
 197
 198         case PB_WT_64BIT:
 199             *size = 8;
 200             return pb_read(stream, buf, 8);
 201
 202         case PB_WT_32BIT:
 203             *size = 4;
 204             return pb_read(stream, buf, 4);
 205
 206         default: PB_RETURN_ERROR(stream, "invalid wire_type");
 207     }
 208 }
 209
 210 /* Decode string length from stream and return a substream with limited length.
 211  * Remember to close the substream using pb_close_string_substream().
 212  */
 213 bool checkreturn pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 214 {
 215     uint32_t size;
 216     if (!pb_decode_varint32(stream, &size))
 217         return false;
 218
 219     *substream = *stream;
 220     if (substream->bytes_left < size)
 221         PB_RETURN_ERROR(stream, "parent stream too short");
 222
 223     substream->bytes_left = size;
 224     stream->bytes_left -= size;
 225     return true;
 226 }
 227
 228 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 229 {
 230     stream->state = substream->state;
 231
 232 #ifndef PB_NO_ERRMSG
 233     stream->errmsg = substream->errmsg;
 234 #endif
 235 }
 236
 237 /* Iterator for pb_field_t list */
 238 typedef struct {
 239     const pb_field_t *start; /* Start of the pb_field_t array */
 240     const pb_field_t *current; /* Current position of the iterator */
 241     int field_index; /* Zero-based index of the field. */
 242     int required_field_index; /* Zero-based index that counts only the required fields */
 243     void *dest_struct; /* Pointer to the destination structure to decode to */
 244     void *pData; /* Pointer where to store current field value */
 245     void *pSize; /* Pointer where to store the size of current array field */
 246 } pb_field_iterator_t;
 247
 248 static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct)
 249 {
 250     iter->start = iter->current = fields;
 251     iter->field_index = 0;
 252     iter->required_field_index = 0;
 253     iter->pData = (char*)dest_struct + iter->current->data_offset;
 254     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 255     iter->dest_struct = dest_struct;
 256 }
 257
 258 static bool pb_field_next(pb_field_iterator_t *iter)
 259 {
 260     bool notwrapped = true;
 261     size_t prev_size = iter->current->data_size;
 262
 263     if (PB_HTYPE(iter->current->type) == PB_HTYPE_ARRAY)
 264         prev_size *= iter->current->array_size;
 265
 266     if (PB_HTYPE(iter->current->type) == PB_HTYPE_REQUIRED)
 267         iter->required_field_index++;
 268
 269     iter->current++;
 270     iter->field_index++;
 271     if (iter->current->tag == 0)
 272     {
 273         iter->current = iter->start;
 274         iter->field_index = 0;
 275         iter->required_field_index = 0;
 276         iter->pData = iter->dest_struct;
 277         prev_size = 0;
 278         notwrapped = false;
 279     }
 280
 281     iter->pData = (char*)iter->pData + prev_size + iter->current->data_offset;
 282     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 283     return notwrapped;
 284 }
 285
 286 static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag)
 287 {
 288     int start = iter->field_index;
 289
 290     do {
 291         if (iter->current->tag == tag)
 292             return true;
 293         pb_field_next(iter);
 294     } while (iter->field_index != start);
 295
 296     return false;
 297 }
 298
 299 /*************************
 300  * Decode a single field *
 301  *************************/
 302
 303 static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 304 {
 305     pb_decoder_t func = PB_DECODERS[PB_LTYPE(iter->current->type)];
 306
 307     switch (PB_HTYPE(iter->current->type))
 308     {
 309         case PB_HTYPE_REQUIRED:
 310             return func(stream, iter->current, iter->pData);
 311
 312         case PB_HTYPE_OPTIONAL:
 313             *(bool*)iter->pSize = true;
 314             return func(stream, iter->current, iter->pData);
 315
 316         case PB_HTYPE_ARRAY:
 317             if (wire_type == PB_WT_STRING
 318                 && PB_LTYPE(iter->current->type) <= PB_LTYPE_LAST_PACKABLE)
 319             {
 320                 /* Packed array */
 321                 bool status;
 322                 size_t *size = (size_t*)iter->pSize;
 323                 pb_istream_t substream;
 324                 if (!pb_make_string_substream(stream, &substream))
 325                     return false;
 326
 327                 while (substream.bytes_left && *size < iter->current->array_size)
 328                 {
 329                     void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 330                     if (!func(&substream, iter->current, pItem))
 331                         return false;
 332                     (*size)++;
 333                 }
 334                 status = (substream.bytes_left == 0);
 335                 pb_close_string_substream(stream, &substream);
 336                 return status;
 337             }
 338             else
 339             {
 340                 /* Repeated field */
 341                 size_t *size = (size_t*)iter->pSize;
 342                 void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 343                 if (*size >= iter->current->array_size)
 344                     PB_RETURN_ERROR(stream, "array overflow");
 345
 346                 (*size)++;
 347                 return func(stream, iter->current, pItem);
 348             }
 349
 350         case PB_HTYPE_CALLBACK:
 351         {
 352             pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
 353
 354             if (pCallback->funcs.decode == NULL)
 355                 return pb_skip_field(stream, wire_type);
 356
 357             if (wire_type == PB_WT_STRING)
 358             {
 359                 pb_istream_t substream;
 360
 361                 if (!pb_make_string_substream(stream, &substream))
 362                     return false;
 363
 364                 while (substream.bytes_left)
 365                 {
 366                     if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg))
 367                         PB_RETURN_ERROR(stream, "callback failed");
 368                 }
 369
 370                 pb_close_string_substream(stream, &substream);
 371                 return true;
 372             }
 373             else
 374             {
 375                 /* Copy the single scalar value to stack.
 376                  * This is required so that we can limit the stream length,
 377                  * which in turn allows to use same callback for packed and
 378                  * not-packed fields. */
 379                 pb_istream_t substream;
 380                 uint8_t buffer[10];
 381                 size_t size = sizeof(buffer);
 382
 383                 if (!read_raw_value(stream, wire_type, buffer, &size))
 384                     return false;
 385                 substream = pb_istream_from_buffer(buffer, size);
 386
 387                 return pCallback->funcs.decode(&substream, iter->current, pCallback->arg);
 388             }
 389         }
 390
 391         default:
 392             PB_RETURN_ERROR(stream, "invalid field type");
 393     }
 394 }
 395
 396 /* Initialize message fields to default values, recursively */
 397 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
 398 {
 399     pb_field_iterator_t iter;
 400     pb_field_init(&iter, fields, dest_struct);
 401
 402     /* Initialize size/has fields and apply default values */
 403     do
 404     {
 405         if (iter.current->tag == 0)
 406             continue;
 407
 408         /* Initialize the size field for optional/repeated fields to 0. */
 409         if (PB_HTYPE(iter.current->type) == PB_HTYPE_OPTIONAL)
 410         {
 411             *(bool*)iter.pSize = false;
 412         }
 413         else if (PB_HTYPE(iter.current->type) == PB_HTYPE_ARRAY)
 414         {
 415             *(size_t*)iter.pSize = 0;
 416             continue; /* Array is empty, no need to initialize contents */
 417         }
 418
 419         /* Initialize field contents to default value */
 420         if (PB_HTYPE(iter.current->type) == PB_HTYPE_CALLBACK)
 421         {
 422             continue; /* Don't overwrite callback */
 423         }
 424         else if (PB_LTYPE(iter.current->type) == PB_LTYPE_SUBMESSAGE)
 425         {
 426             pb_message_set_to_defaults((const pb_field_t *) iter.current->ptr, iter.pData);
 427         }
 428         else if (iter.current->ptr != NULL)
 429         {
 430             memcpy(iter.pData, iter.current->ptr, iter.current->data_size);
 431         }
 432         else
 433         {
 434             memset(iter.pData, 0, iter.current->data_size);
 435         }
 436     } while (pb_field_next(&iter));
 437 }
 438
 439 /*********************
 440  * Decode all fields *
 441  *********************/
 442
 443 bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 444 {
 445     uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0}; /* Used to check for required fields */
 446     pb_field_iterator_t iter;
 447
 448     pb_field_init(&iter, fields, dest_struct);
 449
 450     while (stream->bytes_left)
 451     {
 452         uint32_t tag;
 453         pb_wire_type_t wire_type;
 454         bool eof;
 455
 456         if (!pb_decode_tag(stream, &wire_type, &tag, &eof))
 457         {
 458             if (eof)
 459                 break;
 460             else
 461                 return false;
 462         }
 463
 464         if (!pb_field_find(&iter, tag))
 465         {
 466             /* No match found, skip data */
 467             if (!pb_skip_field(stream, wire_type))
 468                 return false;
 469             continue;
 470         }
 471
 472         if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED
 473             && iter.required_field_index < PB_MAX_REQUIRED_FIELDS)
 474         {
 475             fields_seen[iter.required_field_index >> 3] |= (uint8_t)(1 << (iter.required_field_index & 7));
 476         }
 477
 478         if (!decode_field(stream, wire_type, &iter))
 479             return false;
 480     }
 481
 482     /* Check that all required fields were present. */
 483     pb_field_init(&iter, fields, dest_struct);
 484     do {
 485         if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED &&
 486             iter.required_field_index < PB_MAX_REQUIRED_FIELDS &&
 487             !(fields_seen[iter.required_field_index >> 3] & (1 << (iter.required_field_index & 7))))
 488         {
 489             PB_RETURN_ERROR(stream, "missing required field");
 490         }
 491     } while (pb_field_next(&iter));
 492
 493     return true;
 494 }
 495
 496 bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 497 {
 498     pb_message_set_to_defaults(fields, dest_struct);
 499     return pb_decode_noinit(stream, fields, dest_struct);
 500 }
 501
 502 /* Field decoders */
 503
 504 bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest)
 505 {
 506     uint64_t value;
 507     if (!pb_decode_varint(stream, &value))
 508         return false;
 509
 510     if (value & 1)
 511         *dest = (int64_t)(~(value >> 1));
 512     else
 513         *dest = (int64_t)(value >> 1);
 514
 515     return true;
 516 }
 517
 518 bool pb_decode_fixed32(pb_istream_t *stream, void *dest)
 519 {
 520     #ifdef __BIG_ENDIAN__
 521     uint8_t *bytes = (uint8_t*)dest;
 522     uint8_t lebytes[4];
 523
 524     if (!pb_read(stream, lebytes, 4))
 525         return false;
 526
 527     bytes[0] = lebytes[3];
 528     bytes[1] = lebytes[2];
 529     bytes[2] = lebytes[1];
 530     bytes[3] = lebytes[0];
 531     return true;
 532     #else
 533     return pb_read(stream, (uint8_t*)dest, 4);
 534     #endif
 535 }
 536
 537 bool pb_decode_fixed64(pb_istream_t *stream, void *dest)
 538 {
 539     #ifdef __BIG_ENDIAN__
 540     uint8_t *bytes = (uint8_t*)dest;
 541     uint8_t lebytes[8];
 542
 543     if (!pb_read(stream, lebytes, 8))
 544         return false;
 545
 546     bytes[0] = lebytes[7];
 547     bytes[1] = lebytes[6];
 548     bytes[2] = lebytes[5];
 549     bytes[3] = lebytes[4];
 550     bytes[4] = lebytes[3];
 551     bytes[5] = lebytes[2];
 552     bytes[6] = lebytes[1];
 553     bytes[7] = lebytes[0];
 554     return true;
 555     #else
 556     return pb_read(stream, (uint8_t*)dest, 8);
 557     #endif
 558 }
 559
 560 bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 561 {
 562     uint64_t value;
 563     bool status = pb_decode_varint(stream, &value);
 564
 565     switch (field->data_size)
 566     {
 567         case 1: *(uint8_t*)dest = (uint8_t)value; break;
 568         case 2: *(uint16_t*)dest = (uint16_t)value; break;
 569         case 4: *(uint32_t*)dest = (uint32_t)value; break;
 570         case 8: *(uint64_t*)dest = value; break;
 571         default: PB_RETURN_ERROR(stream, "invalid data_size");
 572     }
 573
 574     return status;
 575 }
 576
 577 bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 578 {
 579     int64_t value;
 580     bool status = pb_decode_svarint(stream, &value);
 581
 582     switch (field->data_size)
 583     {
 584         case 4: *(int32_t*)dest = (int32_t)value; break;
 585         case 8: *(int64_t*)dest = value; break;
 586         default: PB_RETURN_ERROR(stream, "invalid data_size");
 587     }
 588
 589     return status;
 590 }
 591
 592 bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
 593 {
 594     UNUSED(field);
 595     return pb_decode_fixed32(stream, dest);
 596 }
 597
 598 bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
 599 {
 600     UNUSED(field);
 601     return pb_decode_fixed64(stream, dest);
 602 }
 603
 604 bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
 605 {
 606     pb_bytes_array_t *x = (pb_bytes_array_t*)dest;
 607
 608     uint32_t temp;
 609     if (!pb_decode_varint32(stream, &temp))
 610         return false;
 611     x->size = temp;
 612
 613     /* Check length, noting the space taken by the size_t header. */
 614     if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes))
 615         PB_RETURN_ERROR(stream, "bytes overflow");
 616
 617     return pb_read(stream, x->bytes, x->size);
 618 }
 619
 620 bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
 621 {
 622     uint32_t size;
 623     bool status;
 624     if (!pb_decode_varint32(stream, &size))
 625         return false;
 626
 627     /* Check length, noting the null terminator */
 628     if (size + 1 > field->data_size)
 629         PB_RETURN_ERROR(stream, "string overflow");
 630
 631     status = pb_read(stream, (uint8_t*)dest, size);
 632     *((uint8_t*)dest + size) = 0;
 633     return status;
 634 }
 635
 636 bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
 637 {
 638     bool status;
 639     pb_istream_t substream;
 640     const pb_field_t* submsg_fields = (const pb_field_t*)field->ptr;
 641
 642     if (!pb_make_string_substream(stream, &substream))
 643         return false;
 644
 645     if (field->ptr == NULL)
 646         PB_RETURN_ERROR(stream, "invalid field descriptor");
 647
 648     /* New array entries need to be initialized, while required and optional
 649      * submessages have already been initialized in the top-level pb_decode. */
 650     if (PB_HTYPE(field->type) == PB_HTYPE_ARRAY)
 651         status = pb_decode(&substream, submsg_fields, dest);
 652     else
 653         status = pb_decode_noinit(&substream, submsg_fields, dest);
 654
 655     pb_close_string_substream(stream, &substream);
 656     return status;
 657 }