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