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