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 19/************************************** 20 * Declarations internal to this file * 21 **************************************/ 22 23/* Iterator for pb_field_t list */ 24typedef 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 34typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn; 35 36static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count); 37static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest); 38static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size); 39static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct); 40static bool pb_field_next(pb_field_iterator_t *iter); 41static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag); 42static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter); 43static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter); 44static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter); 45static bool checkreturn default_extension_decoder(pb_istream_t *stream, pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type); 46static bool checkreturn decode_extension(pb_istream_t *stream, uint32_t tag, pb_wire_type_t wire_type, pb_field_iterator_t *iter); 47static bool checkreturn find_extension_field(pb_field_iterator_t *iter); 48static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct); 49static bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest); 50static bool checkreturn pb_dec_uvarint(pb_istream_t *stream, const pb_field_t *field, void *dest); 51static bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest); 52static bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest); 53static bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest); 54static bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest); 55static bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest); 56static bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest); 57static bool checkreturn pb_skip_varint(pb_istream_t *stream); 58static 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 */ 63static 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 80static 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 94bool 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. */ 130static 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 148pb_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 168static 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 204bool 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 226bool 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 237bool 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 246bool 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 272bool 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 */ 287static 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 */ 317bool 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 332void 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 341static 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 351static 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 389static 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 409static 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. */ 474static 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. */ 491static 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 505static 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 601static 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 648static 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. */ 668static 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. */ 690static 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. */ 716static 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 */ 730static 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 797bool 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 893bool 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 907bool 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 921void 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 978bool 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 992bool 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 1011bool 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 1034static 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 1052static 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 1068static 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 1084static 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 1090static 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 1096static 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 1125static 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 1157static 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