pb_decode.c

   1 /* pb_decode.c -- decode a protobuf using minimal resources
   2  *
   3  * 2011 Petteri Aimonen <jpa@kapsi.fi>
   4  */
   5
   6 /* Use the GCC warn_unused_result attribute to check that all return values
   7  * are propagated correctly. On other compilers and gcc before 3.4.0 just
   8  * ignore the annotation.
   9  */
  10 #if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
  11     #define checkreturn
  12 #else
  13     #define checkreturn __attribute__((warn_unused_result))
  14 #endif
  15
  16 #include "pb.h"
  17 #include "pb_decode.h"
  18 #include "pb_common.h"
  19
  20 /**************************************
  21  * Declarations internal to this file *
  22  **************************************/
  23
  24 typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;
  25
  26 static bool checkreturn buf_read(pb_istream_t *stream, pb_byte_t *buf, size_t count);
  27 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest);
  28 static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, pb_byte_t *buf, size_t *size);
  29 static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
  30 static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
  31 static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
  32 static void iter_from_extension(pb_field_iter_t *iter, pb_extension_t *extension);
  33 static bool checkreturn default_extension_decoder(pb_istream_t *stream, pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type);
  34 static bool checkreturn decode_extension(pb_istream_t *stream, uint32_t tag, pb_wire_type_t wire_type, pb_field_iter_t *iter);
  35 static bool checkreturn find_extension_field(pb_field_iter_t *iter);
  36 static void pb_field_set_to_default(pb_field_iter_t *iter);
  37 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct);
  38 static bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest);
  39 static bool checkreturn pb_dec_uvarint(pb_istream_t *stream, const pb_field_t *field, void *dest);
  40 static bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest);
  41 static bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest);
  42 static bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest);
  43 static bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest);
  44 static bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest);
  45 static bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest);
  46 static bool checkreturn pb_skip_varint(pb_istream_t *stream);
  47 static bool checkreturn pb_skip_string(pb_istream_t *stream);
  48
  49 #ifdef PB_ENABLE_MALLOC
  50 static bool checkreturn allocate_field(pb_istream_t *stream, void *pData, size_t data_size, size_t array_size);
  51 static bool checkreturn pb_release_union_field(pb_istream_t *stream, pb_field_iter_t *iter);
  52 static void pb_release_single_field(const pb_field_iter_t *iter);
  53 #endif
  54
  55 /* --- Function pointers to field decoders ---
  56  * Order in the array must match pb_action_t LTYPE numbering.
  57  */
  58 static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = {
  59     &pb_dec_varint,
  60     &pb_dec_uvarint,
  61     &pb_dec_svarint,
  62     &pb_dec_fixed32,
  63     &pb_dec_fixed64,
  64
  65     &pb_dec_bytes,
  66     &pb_dec_string,
  67     &pb_dec_submessage,
  68     NULL, /* extensions */
  69     &pb_dec_bytes /* PB_LTYPE_FIXED_LENGTH_BYTES */
  70 };
  71
  72 /*******************************
  73  * pb_istream_t implementation *
  74  *******************************/
  75
  76 static bool checkreturn buf_read(pb_istream_t *stream, pb_byte_t *buf, size_t count)
  77 {
  78     const pb_byte_t *source = (const pb_byte_t*)stream->state;
  79     stream->state = (pb_byte_t*)stream->state + count;
  80
  81     if (buf != NULL)
  82     {
  83         while (count--)
  84             *buf++ = *source++;
  85     }
  86
  87     return true;
  88 }
  89
  90 bool checkreturn pb_read(pb_istream_t *stream, pb_byte_t *buf, size_t count)
  91 {
  92 #ifndef PB_BUFFER_ONLY
  93         if (buf == NULL && stream->callback != buf_read)
  94         {
  95                 /* Skip input bytes */
  96                 pb_byte_t tmp[16];
  97                 while (count > 16)
  98                 {
  99                         if (!pb_read(stream, tmp, 16))
 100                                 return false;
 101
 102                         count -= 16;
 103                 }
 104
 105                 return pb_read(stream, tmp, count);
 106         }
 107 #endif
 108
 109     if (stream->bytes_left < count)
 110         PB_RETURN_ERROR(stream, "end-of-stream");
 111
 112 #ifndef PB_BUFFER_ONLY
 113     if (!stream->callback(stream, buf, count))
 114         PB_RETURN_ERROR(stream, "io error");
 115 #else
 116     if (!buf_read(stream, buf, count))
 117         return false;
 118 #endif
 119
 120     stream->bytes_left -= count;
 121     return true;
 122 }
 123
 124 /* Read a single byte from input stream. buf may not be NULL.
 125  * This is an optimization for the varint decoding. */
 126 static bool checkreturn pb_readbyte(pb_istream_t *stream, pb_byte_t *buf)
 127 {
 128     if (stream->bytes_left == 0)
 129         PB_RETURN_ERROR(stream, "end-of-stream");
 130
 131 #ifndef PB_BUFFER_ONLY
 132     if (!stream->callback(stream, buf, 1))
 133         PB_RETURN_ERROR(stream, "io error");
 134 #else
 135     *buf = *(const pb_byte_t*)stream->state;
 136     stream->state = (pb_byte_t*)stream->state + 1;
 137 #endif
 138
 139     stream->bytes_left--;
 140
 141     return true;
 142 }
 143
 144 pb_istream_t pb_istream_from_buffer(const pb_byte_t *buf, size_t bufsize)
 145 {
 146     pb_istream_t stream;
 147     /* Cast away the const from buf without a compiler error.  We are
 148      * careful to use it only in a const manner in the callbacks.
 149      */
 150     union {
 151         void *state;
 152         const void *c_state;
 153     } state;
 154 #ifdef PB_BUFFER_ONLY
 155     stream.callback = NULL;
 156 #else
 157     stream.callback = &buf_read;
 158 #endif
 159     state.c_state = buf;
 160     stream.state = state.state;
 161     stream.bytes_left = bufsize;
 162 #ifndef PB_NO_ERRMSG
 163     stream.errmsg = NULL;
 164 #endif
 165     return stream;
 166 }
 167
 168 /********************
 169  * Helper functions *
 170  ********************/
 171
 172 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest)
 173 {
 174     pb_byte_t byte;
 175     uint32_t result;
 176
 177     if (!pb_readbyte(stream, &byte))
 178         return false;
 179
 180     if ((byte & 0x80) == 0)
 181     {
 182         /* Quick case, 1 byte value */
 183         result = byte;
 184     }
 185     else
 186     {
 187         /* Multibyte case */
 188         uint_fast8_t bitpos = 7;
 189         result = byte & 0x7F;
 190
 191         do
 192         {
 193             if (bitpos >= 32)
 194                 PB_RETURN_ERROR(stream, "varint overflow");
 195
 196             if (!pb_readbyte(stream, &byte))
 197                 return false;
 198
 199             result |= (uint32_t)(byte & 0x7F) << bitpos;
 200             bitpos = (uint_fast8_t)(bitpos + 7);
 201         } while (byte & 0x80);
 202    }
 203
 204    *dest = result;
 205    return true;
 206 }
 207
 208 bool checkreturn pb_decode_varint(pb_istream_t *stream, uint64_t *dest)
 209 {
 210     pb_byte_t byte;
 211     uint_fast8_t bitpos = 0;
 212     uint64_t result = 0;
 213
 214     do
 215     {
 216         if (bitpos >= 64)
 217             PB_RETURN_ERROR(stream, "varint overflow");
 218
 219         if (!pb_readbyte(stream, &byte))
 220             return false;
 221
 222         result |= (uint64_t)(byte & 0x7F) << bitpos;
 223         bitpos = (uint_fast8_t)(bitpos + 7);
 224     } while (byte & 0x80);
 225
 226     *dest = result;
 227     return true;
 228 }
 229
 230 bool checkreturn pb_skip_varint(pb_istream_t *stream)
 231 {
 232     pb_byte_t byte;
 233     do
 234     {
 235         if (!pb_read(stream, &byte, 1))
 236             return false;
 237     } while (byte & 0x80);
 238     return true;
 239 }
 240
 241 bool checkreturn pb_skip_string(pb_istream_t *stream)
 242 {
 243     uint32_t length;
 244     if (!pb_decode_varint32(stream, &length))
 245         return false;
 246
 247     return pb_read(stream, NULL, length);
 248 }
 249
 250 bool checkreturn pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof)
 251 {
 252     uint32_t temp;
 253     *eof = false;
 254     *wire_type = (pb_wire_type_t) 0;
 255     *tag = 0;
 256
 257     if (!pb_decode_varint32(stream, &temp))
 258     {
 259         if (stream->bytes_left == 0)
 260             *eof = true;
 261
 262         return false;
 263     }
 264
 265     if (temp == 0)
 266     {
 267         *eof = true; /* Special feature: allow 0-terminated messages. */
 268         return false;
 269     }
 270
 271     *tag = temp >> 3;
 272     *wire_type = (pb_wire_type_t)(temp & 7);
 273     return true;
 274 }
 275
 276 bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type)
 277 {
 278     switch (wire_type)
 279     {
 280         case PB_WT_VARINT: return pb_skip_varint(stream);
 281         case PB_WT_64BIT: return pb_read(stream, NULL, 8);
 282         case PB_WT_STRING: return pb_skip_string(stream);
 283         case PB_WT_32BIT: return pb_read(stream, NULL, 4);
 284         default: PB_RETURN_ERROR(stream, "invalid wire_type");
 285     }
 286 }
 287
 288 /* Read a raw value to buffer, for the purpose of passing it to callback as
 289  * a substream. Size is maximum size on call, and actual size on return.
 290  */
 291 static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, pb_byte_t *buf, size_t *size)
 292 {
 293     size_t max_size = *size;
 294     switch (wire_type)
 295     {
 296         case PB_WT_VARINT:
 297             *size = 0;
 298             do
 299             {
 300                 (*size)++;
 301                 if (*size > max_size) return false;
 302                 if (!pb_read(stream, buf, 1)) return false;
 303             } while (*buf++ & 0x80);
 304             return true;
 305
 306         case PB_WT_64BIT:
 307             *size = 8;
 308             return pb_read(stream, buf, 8);
 309
 310         case PB_WT_32BIT:
 311             *size = 4;
 312             return pb_read(stream, buf, 4);
 313
 314         default: PB_RETURN_ERROR(stream, "invalid wire_type");
 315     }
 316 }
 317
 318 /* Decode string length from stream and return a substream with limited length.
 319  * Remember to close the substream using pb_close_string_substream().
 320  */
 321 bool checkreturn pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 322 {
 323     uint32_t size;
 324     if (!pb_decode_varint32(stream, &size))
 325         return false;
 326
 327     *substream = *stream;
 328     if (substream->bytes_left < size)
 329         PB_RETURN_ERROR(stream, "parent stream too short");
 330
 331     substream->bytes_left = size;
 332     stream->bytes_left -= size;
 333     return true;
 334 }
 335
 336 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 337 {
 338     stream->state = substream->state;
 339
 340 #ifndef PB_NO_ERRMSG
 341     stream->errmsg = substream->errmsg;
 342 #endif
 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_iter_t *iter)
 350 {
 351     pb_type_t type;
 352     pb_decoder_t func;
 353
 354     type = iter->pos->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->pos, iter->pData);
 361
 362         case PB_HTYPE_OPTIONAL:
 363             if (iter->pSize != iter->pData)
 364                 *(bool*)iter->pSize = true;
 365             return func(stream, iter->pos, iter->pData);
 366
 367         case PB_HTYPE_REPEATED:
 368             if (wire_type == PB_WT_STRING
 369                 && PB_LTYPE(type) <= PB_LTYPE_LAST_PACKABLE)
 370             {
 371                 /* Packed array */
 372                 bool status = true;
 373                 pb_size_t *size = (pb_size_t*)iter->pSize;
 374                 pb_istream_t substream;
 375                 if (!pb_make_string_substream(stream, &substream))
 376                     return false;
 377
 378                 while (substream.bytes_left > 0 && *size < iter->pos->array_size)
 379                 {
 380                     void *pItem = (char*)iter->pData + iter->pos->data_size * (*size);
 381                     if (!func(&substream, iter->pos, pItem))
 382                     {
 383                         status = false;
 384                         break;
 385                     }
 386                     (*size)++;
 387                 }
 388                 pb_close_string_substream(stream, &substream);
 389
 390                 if (substream.bytes_left != 0)
 391                     PB_RETURN_ERROR(stream, "array overflow");
 392
 393                 return status;
 394             }
 395             else
 396             {
 397                 /* Repeated field */
 398                 pb_size_t *size = (pb_size_t*)iter->pSize;
 399                 void *pItem = (char*)iter->pData + iter->pos->data_size * (*size);
 400                 if (*size >= iter->pos->array_size)
 401                     PB_RETURN_ERROR(stream, "array overflow");
 402
 403                 (*size)++;
 404                 return func(stream, iter->pos, pItem);
 405             }
 406
 407         case PB_HTYPE_ONEOF:
 408             *(pb_size_t*)iter->pSize = iter->pos->tag;
 409             if (PB_LTYPE(type) == PB_LTYPE_SUBMESSAGE)
 410             {
 411                 /* We memset to zero so that any callbacks are set to NULL.
 412                  * Then set any default values. */
 413                 memset(iter->pData, 0, iter->pos->data_size);
 414                 pb_message_set_to_defaults((const pb_field_t*)iter->pos->ptr, iter->pData);
 415             }
 416             return func(stream, iter->pos, iter->pData);
 417
 418         default:
 419             PB_RETURN_ERROR(stream, "invalid field type");
 420     }
 421 }
 422
 423 #ifdef PB_ENABLE_MALLOC
 424 /* Allocate storage for the field and store the pointer at iter->pData.
 425  * array_size is the number of entries to reserve in an array.
 426  * Zero size is not allowed, use pb_free() for releasing.
 427  */
 428 static bool checkreturn allocate_field(pb_istream_t *stream, void *pData, size_t data_size, size_t array_size)
 429 {
 430     void *ptr = *(void**)pData;
 431
 432     if (data_size == 0 || array_size == 0)
 433         PB_RETURN_ERROR(stream, "invalid size");
 434
 435     /* Check for multiplication overflows.
 436      * This code avoids the costly division if the sizes are small enough.
 437      * Multiplication is safe as long as only half of bits are set
 438      * in either multiplicand.
 439      */
 440     {
 441         const size_t check_limit = (size_t)1 << (sizeof(size_t) * 4);
 442         if (data_size >= check_limit || array_size >= check_limit)
 443         {
 444             const size_t size_max = (size_t)-1;
 445             if (size_max / array_size < data_size)
 446             {
 447                 PB_RETURN_ERROR(stream, "size too large");
 448             }
 449         }
 450     }
 451
 452     /* Allocate new or expand previous allocation */
 453     /* Note: on failure the old pointer will remain in the structure,
 454      * the message must be freed by caller also on error return. */
 455     ptr = pb_realloc(ptr, array_size * data_size);
 456     if (ptr == NULL)
 457         PB_RETURN_ERROR(stream, "realloc failed");
 458
 459     *(void**)pData = ptr;
 460     return true;
 461 }
 462
 463 /* Clear a newly allocated item in case it contains a pointer, or is a submessage. */
 464 static void initialize_pointer_field(void *pItem, pb_field_iter_t *iter)
 465 {
 466     if (PB_LTYPE(iter->pos->type) == PB_LTYPE_STRING ||
 467         PB_LTYPE(iter->pos->type) == PB_LTYPE_BYTES)
 468     {
 469         *(void**)pItem = NULL;
 470     }
 471     else if (PB_LTYPE(iter->pos->type) == PB_LTYPE_SUBMESSAGE)
 472     {
 473         pb_message_set_to_defaults((const pb_field_t *) iter->pos->ptr, pItem);
 474     }
 475 }
 476 #endif
 477
 478 static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
 479 {
 480 #ifndef PB_ENABLE_MALLOC
 481     PB_UNUSED(wire_type);
 482     PB_UNUSED(iter);
 483     PB_RETURN_ERROR(stream, "no malloc support");
 484 #else
 485     pb_type_t type;
 486     pb_decoder_t func;
 487
 488     type = iter->pos->type;
 489     func = PB_DECODERS[PB_LTYPE(type)];
 490
 491     switch (PB_HTYPE(type))
 492     {
 493         case PB_HTYPE_REQUIRED:
 494         case PB_HTYPE_OPTIONAL:
 495         case PB_HTYPE_ONEOF:
 496             if (PB_LTYPE(type) == PB_LTYPE_SUBMESSAGE &&
 497                 *(void**)iter->pData != NULL)
 498             {
 499                 /* Duplicate field, have to release the old allocation first. */
 500                 pb_release_single_field(iter);
 501             }
 502
 503             if (PB_HTYPE(type) == PB_HTYPE_ONEOF)
 504             {
 505                 *(pb_size_t*)iter->pSize = iter->pos->tag;
 506             }
 507
 508             if (PB_LTYPE(type) == PB_LTYPE_STRING ||
 509                 PB_LTYPE(type) == PB_LTYPE_BYTES)
 510             {
 511                 return func(stream, iter->pos, iter->pData);
 512             }
 513             else
 514             {
 515                 if (!allocate_field(stream, iter->pData, iter->pos->data_size, 1))
 516                     return false;
 517
 518                 initialize_pointer_field(*(void**)iter->pData, iter);
 519                 return func(stream, iter->pos, *(void**)iter->pData);
 520             }
 521
 522         case PB_HTYPE_REPEATED:
 523             if (wire_type == PB_WT_STRING
 524                 && PB_LTYPE(type) <= PB_LTYPE_LAST_PACKABLE)
 525             {
 526                 /* Packed array, multiple items come in at once. */
 527                 bool status = true;
 528                 pb_size_t *size = (pb_size_t*)iter->pSize;
 529                 size_t allocated_size = *size;
 530                 void *pItem;
 531                 pb_istream_t substream;
 532
 533                 if (!pb_make_string_substream(stream, &substream))
 534                     return false;
 535
 536                 while (substream.bytes_left)
 537                 {
 538                     if ((size_t)*size + 1 > allocated_size)
 539                     {
 540                         /* Allocate more storage. This tries to guess the
 541                          * number of remaining entries. Round the division
 542                          * upwards. */
 543                         allocated_size += (substream.bytes_left - 1) / iter->pos->data_size + 1;
 544
 545                         if (!allocate_field(&substream, iter->pData, iter->pos->data_size, allocated_size))
 546                         {
 547                             status = false;
 548                             break;
 549                         }
 550                     }
 551
 552                     /* Decode the array entry */
 553                     pItem = *(char**)iter->pData + iter->pos->data_size * (*size);
 554                     initialize_pointer_field(pItem, iter);
 555                     if (!func(&substream, iter->pos, pItem))
 556                     {
 557                         status = false;
 558                         break;
 559                     }
 560
 561                     if (*size == PB_SIZE_MAX)
 562                     {
 563 #ifndef PB_NO_ERRMSG
 564                         stream->errmsg = "too many array entries";
 565 #endif
 566                         status = false;
 567                         break;
 568                     }
 569
 570                     (*size)++;
 571                 }
 572                 pb_close_string_substream(stream, &substream);
 573
 574                 return status;
 575             }
 576             else
 577             {
 578                 /* Normal repeated field, i.e. only one item at a time. */
 579                 pb_size_t *size = (pb_size_t*)iter->pSize;
 580                 void *pItem;
 581
 582                 if (*size == PB_SIZE_MAX)
 583                     PB_RETURN_ERROR(stream, "too many array entries");
 584
 585                 (*size)++;
 586                 if (!allocate_field(stream, iter->pData, iter->pos->data_size, *size))
 587                     return false;
 588
 589                 pItem = *(char**)iter->pData + iter->pos->data_size * (*size - 1);
 590                 initialize_pointer_field(pItem, iter);
 591                 return func(stream, iter->pos, pItem);
 592             }
 593
 594         default:
 595             PB_RETURN_ERROR(stream, "invalid field type");
 596     }
 597 #endif
 598 }
 599
 600 static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
 601 {
 602     pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
 603
 604 #ifdef PB_OLD_CALLBACK_STYLE
 605     void *arg = pCallback->arg;
 606 #else
 607     void **arg = &(pCallback->arg);
 608 #endif
 609
 610     if (pCallback->funcs.decode == NULL)
 611         return pb_skip_field(stream, wire_type);
 612
 613     if (wire_type == PB_WT_STRING)
 614     {
 615         pb_istream_t substream;
 616
 617         if (!pb_make_string_substream(stream, &substream))
 618             return false;
 619
 620         do
 621         {
 622             if (!pCallback->funcs.decode(&substream, iter->pos, arg))
 623                 PB_RETURN_ERROR(stream, "callback failed");
 624         } while (substream.bytes_left);
 625
 626         pb_close_string_substream(stream, &substream);
 627         return true;
 628     }
 629     else
 630     {
 631         /* Copy the single scalar value to stack.
 632          * This is required so that we can limit the stream length,
 633          * which in turn allows to use same callback for packed and
 634          * not-packed fields. */
 635         pb_istream_t substream;
 636         pb_byte_t buffer[10];
 637         size_t size = sizeof(buffer);
 638
 639         if (!read_raw_value(stream, wire_type, buffer, &size))
 640             return false;
 641         substream = pb_istream_from_buffer(buffer, size);
 642
 643         return pCallback->funcs.decode(&substream, iter->pos, arg);
 644     }
 645 }
 646
 647 static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
 648 {
 649 #ifdef PB_ENABLE_MALLOC
 650     /* When decoding an oneof field, check if there is old data that must be
 651      * released first. */
 652     if (PB_HTYPE(iter->pos->type) == PB_HTYPE_ONEOF)
 653     {
 654         if (!pb_release_union_field(stream, iter))
 655             return false;
 656     }
 657 #endif
 658
 659     switch (PB_ATYPE(iter->pos->type))
 660     {
 661         case PB_ATYPE_STATIC:
 662             return decode_static_field(stream, wire_type, iter);
 663
 664         case PB_ATYPE_POINTER:
 665             return decode_pointer_field(stream, wire_type, iter);
 666
 667         case PB_ATYPE_CALLBACK:
 668             return decode_callback_field(stream, wire_type, iter);
 669
 670         default:
 671             PB_RETURN_ERROR(stream, "invalid field type");
 672     }
 673 }
 674
 675 static void iter_from_extension(pb_field_iter_t *iter, pb_extension_t *extension)
 676 {
 677     /* Fake a field iterator for the extension field.
 678      * It is not actually safe to advance this iterator, but decode_field
 679      * will not even try to. */
 680     const pb_field_t *field = (const pb_field_t*)extension->type->arg;
 681     (void)pb_field_iter_begin(iter, field, extension->dest);
 682     iter->pData = extension->dest;
 683     iter->pSize = &extension->found;
 684
 685     if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
 686     {
 687         /* For pointer extensions, the pointer is stored directly
 688          * in the extension structure. This avoids having an extra
 689          * indirection. */
 690         iter->pData = &extension->dest;
 691     }
 692 }
 693
 694 /* Default handler for extension fields. Expects a pb_field_t structure
 695  * in extension->type->arg. */
 696 static bool checkreturn default_extension_decoder(pb_istream_t *stream,
 697     pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type)
 698 {
 699     const pb_field_t *field = (const pb_field_t*)extension->type->arg;
 700     pb_field_iter_t iter;
 701
 702     if (field->tag != tag)
 703         return true;
 704
 705     iter_from_extension(&iter, extension);
 706     extension->found = true;
 707     return decode_field(stream, wire_type, &iter);
 708 }
 709
 710 /* Try to decode an unknown field as an extension field. Tries each extension
 711  * decoder in turn, until one of them handles the field or loop ends. */
 712 static bool checkreturn decode_extension(pb_istream_t *stream,
 713     uint32_t tag, pb_wire_type_t wire_type, pb_field_iter_t *iter)
 714 {
 715     pb_extension_t *extension = *(pb_extension_t* const *)iter->pData;
 716     size_t pos = stream->bytes_left;
 717
 718     while (extension != NULL && pos == stream->bytes_left)
 719     {
 720         bool status;
 721         if (extension->type->decode)
 722             status = extension->type->decode(stream, extension, tag, wire_type);
 723         else
 724             status = default_extension_decoder(stream, extension, tag, wire_type);
 725
 726         if (!status)
 727             return false;
 728
 729         extension = extension->next;
 730     }
 731
 732     return true;
 733 }
 734
 735 /* Step through the iterator until an extension field is found or until all
 736  * entries have been checked. There can be only one extension field per
 737  * message. Returns false if no extension field is found. */
 738 static bool checkreturn find_extension_field(pb_field_iter_t *iter)
 739 {
 740     const pb_field_t *start = iter->pos;
 741
 742     do {
 743         if (PB_LTYPE(iter->pos->type) == PB_LTYPE_EXTENSION)
 744             return true;
 745         (void)pb_field_iter_next(iter);
 746     } while (iter->pos != start);
 747
 748     return false;
 749 }
 750
 751 /* Initialize message fields to default values, recursively */
 752 static void pb_field_set_to_default(pb_field_iter_t *iter)
 753 {
 754     pb_type_t type;
 755     type = iter->pos->type;
 756
 757     if (PB_LTYPE(type) == PB_LTYPE_EXTENSION)
 758     {
 759         pb_extension_t *ext = *(pb_extension_t* const *)iter->pData;
 760         while (ext != NULL)
 761         {
 762             pb_field_iter_t ext_iter;
 763             ext->found = false;
 764             iter_from_extension(&ext_iter, ext);
 765             pb_field_set_to_default(&ext_iter);
 766             ext = ext->next;
 767         }
 768     }
 769     else if (PB_ATYPE(type) == PB_ATYPE_STATIC)
 770     {
 771         bool init_data = true;
 772         if (PB_HTYPE(type) == PB_HTYPE_OPTIONAL)
 773         {
 774             /* Set has_field to false. Still initialize the optional field
 775              * itself also. */
 776             *(bool*)iter->pSize = false;
 777         }
 778         else if (PB_HTYPE(type) == PB_HTYPE_REPEATED ||
 779                  PB_HTYPE(type) == PB_HTYPE_ONEOF)
 780         {
 781             /* REPEATED: Set array count to 0, no need to initialize contents.
 782                ONEOF: Set which_field to 0. */
 783             *(pb_size_t*)iter->pSize = 0;
 784             init_data = false;
 785         }
 786
 787         if (init_data)
 788         {
 789             if (PB_LTYPE(iter->pos->type) == PB_LTYPE_SUBMESSAGE)
 790             {
 791                 /* Initialize submessage to defaults */
 792                 pb_message_set_to_defaults((const pb_field_t *) iter->pos->ptr, iter->pData);
 793             }
 794             else if (iter->pos->ptr != NULL)
 795             {
 796                 /* Initialize to default value */
 797                 memcpy(iter->pData, iter->pos->ptr, iter->pos->data_size);
 798             }
 799             else
 800             {
 801                 /* Initialize to zeros */
 802                 memset(iter->pData, 0, iter->pos->data_size);
 803             }
 804         }
 805     }
 806     else if (PB_ATYPE(type) == PB_ATYPE_POINTER)
 807     {
 808         /* Initialize the pointer to NULL. */
 809         *(void**)iter->pData = NULL;
 810
 811         /* Initialize array count to 0. */
 812         if (PB_HTYPE(type) == PB_HTYPE_REPEATED ||
 813             PB_HTYPE(type) == PB_HTYPE_ONEOF)
 814         {
 815             *(pb_size_t*)iter->pSize = 0;
 816         }
 817     }
 818     else if (PB_ATYPE(type) == PB_ATYPE_CALLBACK)
 819     {
 820         /* Don't overwrite callback */
 821     }
 822 }
 823
 824 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
 825 {
 826     pb_field_iter_t iter;
 827
 828     if (!pb_field_iter_begin(&iter, fields, dest_struct))
 829         return; /* Empty message type */
 830
 831     do
 832     {
 833         pb_field_set_to_default(&iter);
 834     } while (pb_field_iter_next(&iter));
 835 }
 836
 837 /*********************
 838  * Decode all fields *
 839  *********************/
 840
 841 bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 842 {
 843     uint32_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 31) / 32] = {0, 0};
 844     const uint32_t allbits = ~(uint32_t)0;
 845     uint32_t extension_range_start = 0;
 846     pb_field_iter_t iter;
 847
 848     /* Return value ignored, as empty message types will be correctly handled by
 849      * pb_field_iter_find() anyway. */
 850     (void)pb_field_iter_begin(&iter, fields, dest_struct);
 851
 852     while (stream->bytes_left)
 853     {
 854         uint32_t tag;
 855         pb_wire_type_t wire_type;
 856         bool eof;
 857
 858         if (!pb_decode_tag(stream, &wire_type, &tag, &eof))
 859         {
 860             if (eof)
 861                 break;
 862             else
 863                 return false;
 864         }
 865
 866         if (!pb_field_iter_find(&iter, tag))
 867         {
 868             /* No match found, check if it matches an extension. */
 869             if (tag >= extension_range_start)
 870             {
 871                 if (!find_extension_field(&iter))
 872                     extension_range_start = (uint32_t)-1;
 873                 else
 874                     extension_range_start = iter.pos->tag;
 875
 876                 if (tag >= extension_range_start)
 877                 {
 878                     size_t pos = stream->bytes_left;
 879
 880                     if (!decode_extension(stream, tag, wire_type, &iter))
 881                         return false;
 882
 883                     if (pos != stream->bytes_left)
 884                     {
 885                         /* The field was handled */
 886                         continue;
 887                     }
 888                 }
 889             }
 890
 891             /* No match found, skip data */
 892             if (!pb_skip_field(stream, wire_type))
 893                 return false;
 894             continue;
 895         }
 896
 897         if (PB_HTYPE(iter.pos->type) == PB_HTYPE_REQUIRED
 898             && iter.required_field_index < PB_MAX_REQUIRED_FIELDS)
 899         {
 900             uint32_t tmp = ((uint32_t)1 << (iter.required_field_index & 31));
 901             fields_seen[iter.required_field_index >> 5] |= tmp;
 902         }
 903
 904         if (!decode_field(stream, wire_type, &iter))
 905             return false;
 906     }
 907
 908     /* Check that all required fields were present. */
 909     {
 910         /* First figure out the number of required fields by
 911          * seeking to the end of the field array. Usually we
 912          * are already close to end after decoding.
 913          */
 914         unsigned req_field_count;
 915         pb_type_t last_type;
 916         unsigned i;
 917         do {
 918             req_field_count = iter.required_field_index;
 919             last_type = iter.pos->type;
 920         } while (pb_field_iter_next(&iter));
 921
 922         /* Fixup if last field was also required. */
 923         if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED && iter.pos->tag != 0)
 924             req_field_count++;
 925
 926         if (req_field_count > 0)
 927         {
 928             /* Check the whole words */
 929             for (i = 0; i < (req_field_count >> 5); i++)
 930             {
 931                 if (fields_seen[i] != allbits)
 932                     PB_RETURN_ERROR(stream, "missing required field");
 933             }
 934
 935             /* Check the remaining bits */
 936             if (fields_seen[req_field_count >> 5] != (allbits >> (32 - (req_field_count & 31))))
 937                 PB_RETURN_ERROR(stream, "missing required field");
 938         }
 939     }
 940
 941     return true;
 942 }
 943
 944 bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 945 {
 946     bool status;
 947     pb_message_set_to_defaults(fields, dest_struct);
 948     status = pb_decode_noinit(stream, fields, dest_struct);
 949
 950 #ifdef PB_ENABLE_MALLOC
 951     if (!status)
 952         pb_release(fields, dest_struct);
 953 #endif
 954
 955     return status;
 956 }
 957
 958 bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 959 {
 960     pb_istream_t substream;
 961     bool status;
 962
 963     if (!pb_make_string_substream(stream, &substream))
 964         return false;
 965
 966     status = pb_decode(&substream, fields, dest_struct);
 967     pb_close_string_substream(stream, &substream);
 968     return status;
 969 }
 970
 971 #ifdef PB_ENABLE_MALLOC
 972 /* Given an oneof field, if there has already been a field inside this oneof,
 973  * release it before overwriting with a different one. */
 974 static bool pb_release_union_field(pb_istream_t *stream, pb_field_iter_t *iter)
 975 {
 976     pb_size_t old_tag = *(pb_size_t*)iter->pSize; /* Previous which_ value */
 977     pb_size_t new_tag = iter->pos->tag; /* New which_ value */
 978
 979     if (old_tag == 0)
 980         return true; /* Ok, no old data in union */
 981
 982     if (old_tag == new_tag)
 983         return true; /* Ok, old data is of same type => merge */
 984
 985     /* Release old data. The find can fail if the message struct contains
 986      * invalid data. */
 987     if (!pb_field_iter_find(iter, old_tag))
 988         PB_RETURN_ERROR(stream, "invalid union tag");
 989
 990     pb_release_single_field(iter);
 991
 992     /* Restore iterator to where it should be.
 993      * This shouldn't fail unless the pb_field_t structure is corrupted. */
 994     if (!pb_field_iter_find(iter, new_tag))
 995         PB_RETURN_ERROR(stream, "iterator error");
 996
 997     return true;
 998 }
 999
1000 static void pb_release_single_field(const pb_field_iter_t *iter)
1001 {
1002     pb_type_t type;
1003     type = iter->pos->type;
1004
1005     if (PB_HTYPE(type) == PB_HTYPE_ONEOF)
1006     {
1007         if (*(pb_size_t*)iter->pSize != iter->pos->tag)
1008             return; /* This is not the current field in the union */
1009     }
1010
1011     /* Release anything contained inside an extension or submsg.
1012      * This has to be done even if the submsg itself is statically
1013      * allocated. */
1014     if (PB_LTYPE(type) == PB_LTYPE_EXTENSION)
1015     {
1016         /* Release fields from all extensions in the linked list */
1017         pb_extension_t *ext = *(pb_extension_t**)iter->pData;
1018         while (ext != NULL)
1019         {
1020             pb_field_iter_t ext_iter;
1021             iter_from_extension(&ext_iter, ext);
1022             pb_release_single_field(&ext_iter);
1023             ext = ext->next;
1024         }
1025     }
1026     else if (PB_LTYPE(type) == PB_LTYPE_SUBMESSAGE)
1027     {
1028         /* Release fields in submessage or submsg array */
1029         void *pItem = iter->pData;
1030         pb_size_t count = 1;
1031
1032         if (PB_ATYPE(type) == PB_ATYPE_POINTER)
1033         {
1034             pItem = *(void**)iter->pData;
1035         }
1036
1037         if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
1038         {
1039             count = *(pb_size_t*)iter->pSize;
1040
1041             if (PB_ATYPE(type) == PB_ATYPE_STATIC && count > iter->pos->array_size)
1042             {
1043                 /* Protect against corrupted _count fields */
1044                 count = iter->pos->array_size;
1045             }
1046         }
1047
1048         if (pItem)
1049         {
1050             while (count--)
1051             {
1052                 pb_release((const pb_field_t*)iter->pos->ptr, pItem);
1053                 pItem = (char*)pItem + iter->pos->data_size;
1054             }
1055         }
1056     }
1057
1058     if (PB_ATYPE(type) == PB_ATYPE_POINTER)
1059     {
1060         if (PB_HTYPE(type) == PB_HTYPE_REPEATED &&
1061             (PB_LTYPE(type) == PB_LTYPE_STRING ||
1062              PB_LTYPE(type) == PB_LTYPE_BYTES))
1063         {
1064             /* Release entries in repeated string or bytes array */
1065             void **pItem = *(void***)iter->pData;
1066             pb_size_t count = *(pb_size_t*)iter->pSize;
1067             while (count--)
1068             {
1069                 pb_free(*pItem);
1070                 *pItem++ = NULL;
1071             }
1072         }
1073
1074         if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
1075         {
1076             /* We are going to release the array, so set the size to 0 */
1077             *(pb_size_t*)iter->pSize = 0;
1078         }
1079
1080         /* Release main item */
1081         pb_free(*(void**)iter->pData);
1082         *(void**)iter->pData = NULL;
1083     }
1084 }
1085
1086 void pb_release(const pb_field_t fields[], void *dest_struct)
1087 {
1088     pb_field_iter_t iter;
1089
1090     if (!dest_struct)
1091         return; /* Ignore NULL pointers, similar to free() */
1092
1093     if (!pb_field_iter_begin(&iter, fields, dest_struct))
1094         return; /* Empty message type */
1095
1096     do
1097     {
1098         pb_release_single_field(&iter);
1099     } while (pb_field_iter_next(&iter));
1100 }
1101 #endif
1102
1103 /* Field decoders */
1104
1105 bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest)
1106 {
1107     uint64_t value;
1108     if (!pb_decode_varint(stream, &value))
1109         return false;
1110
1111     if (value & 1)
1112         *dest = (int64_t)(~(value >> 1));
1113     else
1114         *dest = (int64_t)(value >> 1);
1115
1116     return true;
1117 }
1118
1119 bool pb_decode_fixed32(pb_istream_t *stream, void *dest)
1120 {
1121     pb_byte_t bytes[4];
1122
1123     if (!pb_read(stream, bytes, 4))
1124         return false;
1125
1126     *(uint32_t*)dest = ((uint32_t)bytes[0] << 0) |
1127                        ((uint32_t)bytes[1] << 8) |
1128                        ((uint32_t)bytes[2] << 16) |
1129                        ((uint32_t)bytes[3] << 24);
1130     return true;
1131 }
1132
1133 bool pb_decode_fixed64(pb_istream_t *stream, void *dest)
1134 {
1135     pb_byte_t bytes[8];
1136
1137     if (!pb_read(stream, bytes, 8))
1138         return false;
1139
1140     *(uint64_t*)dest = ((uint64_t)bytes[0] << 0) |
1141                        ((uint64_t)bytes[1] << 8) |
1142                        ((uint64_t)bytes[2] << 16) |
1143                        ((uint64_t)bytes[3] << 24) |
1144                        ((uint64_t)bytes[4] << 32) |
1145                        ((uint64_t)bytes[5] << 40) |
1146                        ((uint64_t)bytes[6] << 48) |
1147                        ((uint64_t)bytes[7] << 56);
1148
1149     return true;
1150 }
1151
1152 static bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
1153 {
1154     uint64_t value;
1155     int64_t svalue;
1156     int64_t clamped;
1157     if (!pb_decode_varint(stream, &value))
1158         return false;
1159
1160     /* See issue 97: Google's C++ protobuf allows negative varint values to
1161      * be cast as int32_t, instead of the int64_t that should be used when
1162      * encoding. Previous nanopb versions had a bug in encoding. In order to
1163      * not break decoding of such messages, we cast <=32 bit fields to
1164      * int32_t first to get the sign correct.
1165      */
1166     if (field->data_size == sizeof(int64_t))
1167         svalue = (int64_t)value;
1168     else
1169         svalue = (int32_t)value;
1170
1171     /* Cast to the proper field size, while checking for overflows */
1172     if (field->data_size == sizeof(int64_t))
1173         clamped = *(int64_t*)dest = svalue;
1174     else if (field->data_size == sizeof(int32_t))
1175         clamped = *(int32_t*)dest = (int32_t)svalue;
1176     else if (field->data_size == sizeof(int_least16_t))
1177         clamped = *(int_least16_t*)dest = (int_least16_t)svalue;
1178     else if (field->data_size == sizeof(int_least8_t))
1179         clamped = *(int_least8_t*)dest = (int_least8_t)svalue;
1180     else
1181         PB_RETURN_ERROR(stream, "invalid data_size");
1182
1183     if (clamped != svalue)
1184         PB_RETURN_ERROR(stream, "integer too large");
1185
1186     return true;
1187 }
1188
1189 static bool checkreturn pb_dec_uvarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
1190 {
1191     uint64_t value, clamped;
1192     if (!pb_decode_varint(stream, &value))
1193         return false;
1194
1195     /* Cast to the proper field size, while checking for overflows */
1196     if (field->data_size == sizeof(uint64_t))
1197         clamped = *(uint64_t*)dest = value;
1198     else if (field->data_size == sizeof(uint32_t))
1199         clamped = *(uint32_t*)dest = (uint32_t)value;
1200     else if (field->data_size == sizeof(uint_least16_t))
1201         clamped = *(uint_least16_t*)dest = (uint_least16_t)value;
1202     else if (field->data_size == sizeof(uint_least8_t))
1203         clamped = *(uint_least8_t*)dest = (uint_least8_t)value;
1204     else
1205         PB_RETURN_ERROR(stream, "invalid data_size");
1206
1207     if (clamped != value)
1208         PB_RETURN_ERROR(stream, "integer too large");
1209
1210     return true;
1211 }
1212
1213 static bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
1214 {
1215     int64_t value, clamped;
1216     if (!pb_decode_svarint(stream, &value))
1217         return false;
1218
1219     /* Cast to the proper field size, while checking for overflows */
1220     if (field->data_size == sizeof(int64_t))
1221         clamped = *(int64_t*)dest = value;
1222     else if (field->data_size == sizeof(int32_t))
1223         clamped = *(int32_t*)dest = (int32_t)value;
1224     else if (field->data_size == sizeof(int_least16_t))
1225         clamped = *(int_least16_t*)dest = (int_least16_t)value;
1226     else if (field->data_size == sizeof(int_least8_t))
1227         clamped = *(int_least8_t*)dest = (int_least8_t)value;
1228     else
1229         PB_RETURN_ERROR(stream, "invalid data_size");
1230
1231     if (clamped != value)
1232         PB_RETURN_ERROR(stream, "integer too large");
1233
1234     return true;
1235 }
1236
1237 static bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
1238 {
1239     PB_UNUSED(field);
1240     return pb_decode_fixed32(stream, dest);
1241 }
1242
1243 static bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
1244 {
1245     PB_UNUSED(field);
1246     return pb_decode_fixed64(stream, dest);
1247 }
1248
1249 static bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
1250 {
1251     uint32_t size;
1252     size_t alloc_size;
1253     pb_bytes_array_t *bdest;
1254
1255     if (!pb_decode_varint32(stream, &size))
1256         return false;
1257
1258     if (size > PB_SIZE_MAX)
1259         PB_RETURN_ERROR(stream, "bytes overflow");
1260
1261     alloc_size = PB_BYTES_ARRAY_T_ALLOCSIZE(size);
1262     if (size > alloc_size)
1263         PB_RETURN_ERROR(stream, "size too large");
1264
1265     if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
1266     {
1267 #ifndef PB_ENABLE_MALLOC
1268         PB_RETURN_ERROR(stream, "no malloc support");
1269 #else
1270         if (!allocate_field(stream, dest, alloc_size, 1))
1271             return false;
1272         bdest = *(pb_bytes_array_t**)dest;
1273 #endif
1274     }
1275     else
1276     {
1277         if (PB_LTYPE(field->type) == PB_LTYPE_FIXED_LENGTH_BYTES) {
1278             if (size != field->data_size)
1279                 PB_RETURN_ERROR(stream, "incorrect inline bytes size");
1280             return pb_read(stream, (pb_byte_t*)dest, field->data_size);
1281         }
1282
1283         if (alloc_size > field->data_size)
1284             PB_RETURN_ERROR(stream, "bytes overflow");
1285         bdest = (pb_bytes_array_t*)dest;
1286     }
1287
1288     bdest->size = (pb_size_t)size;
1289     return pb_read(stream, bdest->bytes, size);
1290 }
1291
1292 static bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
1293 {
1294     uint32_t size;
1295     size_t alloc_size;
1296     bool status;
1297     if (!pb_decode_varint32(stream, &size))
1298         return false;
1299
1300     /* Space for null terminator */
1301     alloc_size = size + 1;
1302
1303     if (alloc_size < size)
1304         PB_RETURN_ERROR(stream, "size too large");
1305
1306     if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
1307     {
1308 #ifndef PB_ENABLE_MALLOC
1309         PB_RETURN_ERROR(stream, "no malloc support");
1310 #else
1311         if (!allocate_field(stream, dest, alloc_size, 1))
1312             return false;
1313         dest = *(void**)dest;
1314 #endif
1315     }
1316     else
1317     {
1318         if (alloc_size > field->data_size)
1319             PB_RETURN_ERROR(stream, "string overflow");
1320     }
1321
1322     status = pb_read(stream, (pb_byte_t*)dest, size);
1323     *((pb_byte_t*)dest + size) = 0;
1324     return status;
1325 }
1326
1327 static bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
1328 {
1329     bool status;
1330     pb_istream_t substream;
1331     const pb_field_t* submsg_fields = (const pb_field_t*)field->ptr;
1332
1333     if (!pb_make_string_substream(stream, &substream))
1334         return false;
1335
1336     if (field->ptr == NULL)
1337         PB_RETURN_ERROR(stream, "invalid field descriptor");
1338
1339     /* New array entries need to be initialized, while required and optional
1340      * submessages have already been initialized in the top-level pb_decode. */
1341     if (PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
1342         status = pb_decode(&substream, submsg_fields, dest);
1343     else
1344         status = pb_decode_noinit(&substream, submsg_fields, dest);
1345
1346     pb_close_string_substream(stream, &substream);
1347     return status;
1348 }