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