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     iter->current++;
 316     iter->field_index++;
 317     if (iter->current->tag == 0)
 318     {
 319         iter->current = iter->start;
 320         iter->field_index = 0;
 321         iter->required_field_index = 0;
 322         iter->pData = iter->dest_struct;
 323         prev_size = 0;
 324         notwrapped = false;
 325     }
 326
 327     iter->pData = (char*)iter->pData + prev_size + iter->current->data_offset;
 328     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 329     return notwrapped;
 330 }
 331
 332 static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag)
 333 {
 334     unsigned start = iter->field_index;
 335
 336     do {
 337         if (iter->current->tag == tag)
 338             return true;
 339         pb_field_next(iter);
 340     } while (iter->field_index != start);
 341
 342     return false;
 343 }
 344
 345 /*************************
 346  * Decode a single field *
 347  *************************/
 348
 349 static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 350 {
 351     pb_type_t type;
 352     pb_decoder_t func;
 353
 354     type = iter->current->type;
 355     func = PB_DECODERS[PB_LTYPE(type)];
 356
 357     switch (PB_HTYPE(type))
 358     {
 359         case PB_HTYPE_REQUIRED:
 360             return func(stream, iter->current, iter->pData);
 361
 362         case PB_HTYPE_OPTIONAL:
 363             *(bool*)iter->pSize = true;
 364             return func(stream, iter->current, iter->pData);
 365
 366         case PB_HTYPE_REPEATED:
 367             if (wire_type == PB_WT_STRING
 368                 && PB_LTYPE(type) <= PB_LTYPE_LAST_PACKABLE)
 369             {
 370                 /* Packed array */
 371                 bool status = true;
 372                 size_t *size = (size_t*)iter->pSize;
 373                 pb_istream_t substream;
 374                 if (!pb_make_string_substream(stream, &substream))
 375                     return false;
 376
 377                 while (substream.bytes_left && *size < iter->current->array_size)
 378                 {
 379                     void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 380                     if (!func(&substream, iter->current, pItem))
 381                     {
 382                         status = false;
 383                         break;
 384                     }
 385                     (*size)++;
 386                 }
 387                 pb_close_string_substream(stream, &substream);
 388
 389                 if (substream.bytes_left != 0)
 390                     PB_RETURN_ERROR(stream, "array overflow");
 391
 392                 return status;
 393             }
 394             else
 395             {
 396                 /* Repeated field */
 397                 size_t *size = (size_t*)iter->pSize;
 398                 void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 399                 if (*size >= iter->current->array_size)
 400                     PB_RETURN_ERROR(stream, "array overflow");
 401
 402                 (*size)++;
 403                 return func(stream, iter->current, pItem);
 404             }
 405
 406         default:
 407             PB_RETURN_ERROR(stream, "invalid field type");
 408     }
 409 }
 410
 411 static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 412 {
 413     pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
 414
 415     if (pCallback->funcs.decode == NULL)
 416         return pb_skip_field(stream, wire_type);
 417
 418     if (wire_type == PB_WT_STRING)
 419     {
 420         pb_istream_t substream;
 421
 422         if (!pb_make_string_substream(stream, &substream))
 423             return false;
 424
 425         while (substream.bytes_left)
 426         {
 427             if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg))
 428                 PB_RETURN_ERROR(stream, "callback failed");
 429         }
 430
 431         pb_close_string_substream(stream, &substream);
 432         return true;
 433     }
 434     else
 435     {
 436         /* Copy the single scalar value to stack.
 437          * This is required so that we can limit the stream length,
 438          * which in turn allows to use same callback for packed and
 439          * not-packed fields. */
 440         pb_istream_t substream;
 441         uint8_t buffer[10];
 442         size_t size = sizeof(buffer);
 443
 444         if (!read_raw_value(stream, wire_type, buffer, &size))
 445             return false;
 446         substream = pb_istream_from_buffer(buffer, size);
 447
 448         return pCallback->funcs.decode(&substream, iter->current, pCallback->arg);
 449     }
 450 }
 451
 452 static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 453 {
 454     switch (PB_ATYPE(iter->current->type))
 455     {
 456         case PB_ATYPE_STATIC:
 457             return decode_static_field(stream, wire_type, iter);
 458
 459         case PB_ATYPE_CALLBACK:
 460             return decode_callback_field(stream, wire_type, iter);
 461
 462         default:
 463             PB_RETURN_ERROR(stream, "invalid field type");
 464     }
 465 }
 466
 467 /* Initialize message fields to default values, recursively */
 468 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
 469 {
 470     pb_field_iterator_t iter;
 471     pb_field_init(&iter, fields, dest_struct);
 472
 473     /* Initialize size/has fields and apply default values */
 474     do
 475     {
 476         pb_type_t type;
 477         type = iter.current->type;
 478
 479         if (iter.current->tag == 0)
 480             continue;
 481
 482         if (PB_ATYPE(type) == PB_ATYPE_STATIC)
 483         {
 484             /* Initialize the size field for optional/repeated fields to 0. */
 485             if (PB_HTYPE(type) == PB_HTYPE_OPTIONAL)
 486             {
 487                 *(bool*)iter.pSize = false;
 488             }
 489             else if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
 490             {
 491                 *(size_t*)iter.pSize = 0;
 492                 continue; /* Array is empty, no need to initialize contents */
 493             }
 494
 495             /* Initialize field contents to default value */
 496             if (PB_LTYPE(iter.current->type) == PB_LTYPE_SUBMESSAGE)
 497             {
 498                 pb_message_set_to_defaults((const pb_field_t *) iter.current->ptr, iter.pData);
 499             }
 500             else if (iter.current->ptr != NULL)
 501             {
 502                 memcpy(iter.pData, iter.current->ptr, iter.current->data_size);
 503             }
 504             else
 505             {
 506                 memset(iter.pData, 0, iter.current->data_size);
 507             }
 508         }
 509         else if (PB_ATYPE(type) == PB_ATYPE_CALLBACK)
 510         {
 511             continue; /* Don't overwrite callback */
 512         }
 513     } while (pb_field_next(&iter));
 514 }
 515
 516 /*********************
 517  * Decode all fields *
 518  *********************/
 519
 520 bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 521 {
 522     uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0}; /* Used to check for required fields */
 523     pb_field_iterator_t iter;
 524
 525     pb_field_init(&iter, fields, dest_struct);
 526
 527     while (stream->bytes_left)
 528     {
 529         uint32_t tag;
 530         pb_wire_type_t wire_type;
 531         bool eof;
 532
 533         if (!pb_decode_tag(stream, &wire_type, &tag, &eof))
 534         {
 535             if (eof)
 536                 break;
 537             else
 538                 return false;
 539         }
 540
 541         if (!pb_field_find(&iter, tag))
 542         {
 543             /* No match found, skip data */
 544             if (!pb_skip_field(stream, wire_type))
 545                 return false;
 546             continue;
 547         }
 548
 549         if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED
 550             && iter.required_field_index < PB_MAX_REQUIRED_FIELDS)
 551         {
 552             fields_seen[iter.required_field_index >> 3] |= (uint8_t)(1 << (iter.required_field_index & 7));
 553         }
 554
 555         if (!decode_field(stream, wire_type, &iter))
 556             return false;
 557     }
 558
 559     /* Check that all required fields were present. */
 560     {
 561         /* First figure out the number of required fields by
 562          * seeking to the end of the field array. Usually we
 563          * are already close to end after decoding.
 564          */
 565         unsigned req_field_count;
 566         pb_type_t last_type;
 567         unsigned i;
 568         do {
 569             req_field_count = iter.required_field_index;
 570             last_type = iter.current->type;
 571         } while (pb_field_next(&iter));
 572
 573         /* Fixup if last field was also required. */
 574         if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED && iter.current->tag)
 575             req_field_count++;
 576
 577         /* Check the whole bytes */
 578         for (i = 0; i < (req_field_count >> 3); i++)
 579         {
 580             if (fields_seen[i] != 0xFF)
 581                 PB_RETURN_ERROR(stream, "missing required field");
 582         }
 583
 584         /* Check the remaining bits */
 585         if (fields_seen[req_field_count >> 3] != (0xFF >> (8 - (req_field_count & 7))))
 586             PB_RETURN_ERROR(stream, "missing required field");
 587     }
 588
 589     return true;
 590 }
 591
 592 bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 593 {
 594     pb_message_set_to_defaults(fields, dest_struct);
 595     return pb_decode_noinit(stream, fields, dest_struct);
 596 }
 597
 598 /* Field decoders */
 599
 600 bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest)
 601 {
 602     uint64_t value;
 603     if (!pb_decode_varint(stream, &value))
 604         return false;
 605
 606     if (value & 1)
 607         *dest = (int64_t)(~(value >> 1));
 608     else
 609         *dest = (int64_t)(value >> 1);
 610
 611     return true;
 612 }
 613
 614 bool pb_decode_fixed32(pb_istream_t *stream, void *dest)
 615 {
 616     #ifdef __BIG_ENDIAN__
 617     uint8_t *bytes = (uint8_t*)dest;
 618     uint8_t lebytes[4];
 619
 620     if (!pb_read(stream, lebytes, 4))
 621         return false;
 622
 623     bytes[0] = lebytes[3];
 624     bytes[1] = lebytes[2];
 625     bytes[2] = lebytes[1];
 626     bytes[3] = lebytes[0];
 627     return true;
 628     #else
 629     return pb_read(stream, (uint8_t*)dest, 4);
 630     #endif
 631 }
 632
 633 bool pb_decode_fixed64(pb_istream_t *stream, void *dest)
 634 {
 635     #ifdef __BIG_ENDIAN__
 636     uint8_t *bytes = (uint8_t*)dest;
 637     uint8_t lebytes[8];
 638
 639     if (!pb_read(stream, lebytes, 8))
 640         return false;
 641
 642     bytes[0] = lebytes[7];
 643     bytes[1] = lebytes[6];
 644     bytes[2] = lebytes[5];
 645     bytes[3] = lebytes[4];
 646     bytes[4] = lebytes[3];
 647     bytes[5] = lebytes[2];
 648     bytes[6] = lebytes[1];
 649     bytes[7] = lebytes[0];
 650     return true;
 651     #else
 652     return pb_read(stream, (uint8_t*)dest, 8);
 653     #endif
 654 }
 655
 656 bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 657 {
 658     uint64_t value;
 659     bool status = pb_decode_varint(stream, &value);
 660
 661     switch (field->data_size)
 662     {
 663         case 1: *(uint8_t*)dest = (uint8_t)value; break;
 664         case 2: *(uint16_t*)dest = (uint16_t)value; break;
 665         case 4: *(uint32_t*)dest = (uint32_t)value; break;
 666         case 8: *(uint64_t*)dest = value; break;
 667         default: PB_RETURN_ERROR(stream, "invalid data_size");
 668     }
 669
 670     return status;
 671 }
 672
 673 bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 674 {
 675     int64_t value;
 676     bool status = pb_decode_svarint(stream, &value);
 677
 678     switch (field->data_size)
 679     {
 680         case 4: *(int32_t*)dest = (int32_t)value; break;
 681         case 8: *(int64_t*)dest = value; break;
 682         default: PB_RETURN_ERROR(stream, "invalid data_size");
 683     }
 684
 685     return status;
 686 }
 687
 688 bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
 689 {
 690     UNUSED(field);
 691     return pb_decode_fixed32(stream, dest);
 692 }
 693
 694 bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
 695 {
 696     UNUSED(field);
 697     return pb_decode_fixed64(stream, dest);
 698 }
 699
 700 bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
 701 {
 702     pb_bytes_array_t *x = (pb_bytes_array_t*)dest;
 703
 704     uint32_t temp;
 705     if (!pb_decode_varint32(stream, &temp))
 706         return false;
 707     x->size = temp;
 708
 709     /* Check length, noting the space taken by the size_t header. */
 710     if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes))
 711         PB_RETURN_ERROR(stream, "bytes overflow");
 712
 713     return pb_read(stream, x->bytes, x->size);
 714 }
 715
 716 bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
 717 {
 718     uint32_t size;
 719     bool status;
 720     if (!pb_decode_varint32(stream, &size))
 721         return false;
 722
 723     /* Check length, noting the null terminator */
 724     if (size + 1 > field->data_size)
 725         PB_RETURN_ERROR(stream, "string overflow");
 726
 727     status = pb_read(stream, (uint8_t*)dest, size);
 728     *((uint8_t*)dest + size) = 0;
 729     return status;
 730 }
 731
 732 bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
 733 {
 734     bool status;
 735     pb_istream_t substream;
 736     const pb_field_t* submsg_fields = (const pb_field_t*)field->ptr;
 737
 738     if (!pb_make_string_substream(stream, &substream))
 739         return false;
 740
 741     if (field->ptr == NULL)
 742         PB_RETURN_ERROR(stream, "invalid field descriptor");
 743
 744     /* New array entries need to be initialized, while required and optional
 745      * submessages have already been initialized in the top-level pb_decode. */
 746     if (PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
 747         status = pb_decode(&substream, submsg_fields, dest);
 748     else
 749         status = pb_decode_noinit(&substream, submsg_fields, dest);
 750
 751     pb_close_string_substream(stream, &substream);
 752     return status;
 753 }