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