pb_decode.c

   1 /* pb_decode.c -- decode a protobuf using minimal resources
   2  *
   3  * 2011 Petteri Aimonen <jpa@kapsi.fi>
   4  */
   5
   6 /* The warn_unused_result attribute appeared first in gcc-3.4.0 */
   7 #if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
   8     #define checkreturn
   9 #else
  10     /* Verify that we remember to check all return values for proper error propagation */
  11     #define checkreturn __attribute__((warn_unused_result))
  12 #endif
  13
  14 #define NANOPB_INTERNALS
  15 #include "pb.h"
  16 #include "pb_decode.h"
  17 #include <string.h>
  18
  19 typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;
  20
  21 /* --- Function pointers to field decoders ---
  22  * Order in the array must match pb_action_t LTYPE numbering.
  23  */
  24 static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = {
  25     &pb_dec_varint,
  26     &pb_dec_svarint,
  27     &pb_dec_fixed32,
  28     &pb_dec_fixed64,
  29
  30     &pb_dec_bytes,
  31     &pb_dec_string,
  32     &pb_dec_submessage
  33 };
  34
  35 /**************
  36  * pb_istream *
  37  **************/
  38
  39 static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count)
  40 {
  41     uint8_t *source = (uint8_t*)stream->state;
  42
  43     if (buf != NULL)
  44         memcpy(buf, source, count);
  45
  46     stream->state = source + count;
  47     return true;
  48 }
  49
  50 bool checkreturn pb_read(pb_istream_t *stream, uint8_t *buf, size_t count)
  51 {
  52         if (buf == NULL && stream->callback != buf_read)
  53         {
  54                 /* Skip input bytes */
  55                 uint8_t tmp[16];
  56                 while (count > 16)
  57                 {
  58                         if (!pb_read(stream, tmp, 16))
  59                                 return false;
  60
  61                         count -= 16;
  62                 }
  63
  64                 return pb_read(stream, tmp, count);
  65         }
  66
  67     if (stream->bytes_left < count)
  68         PB_RETURN_ERROR(stream, "end-of-stream");
  69
  70     if (!stream->callback(stream, buf, count))
  71         PB_RETURN_ERROR(stream, "io error");
  72
  73     stream->bytes_left -= count;
  74     return true;
  75 }
  76
  77 pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize)
  78 {
  79     pb_istream_t stream;
  80     stream.callback = &buf_read;
  81     stream.state = buf;
  82     stream.bytes_left = bufsize;
  83 #ifndef PB_NO_ERRMSG
  84     stream.errmsg = NULL;
  85 #endif
  86     return stream;
  87 }
  88
  89 /********************
  90  * Helper functions *
  91  ********************/
  92
  93 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest)
  94 {
  95     uint64_t temp;
  96     bool status = pb_decode_varint(stream, &temp);
  97     *dest = (uint32_t)temp;
  98     return status;
  99 }
 100
 101 bool checkreturn pb_decode_varint(pb_istream_t *stream, uint64_t *dest)
 102 {
 103     uint8_t byte;
 104     int bitpos = 0;
 105     *dest = 0;
 106
 107     while (bitpos < 64 && pb_read(stream, &byte, 1))
 108     {
 109         *dest |= (uint64_t)(byte & 0x7F) << bitpos;
 110         bitpos += 7;
 111
 112         if (!(byte & 0x80))
 113             return true;
 114     }
 115
 116     PB_RETURN_ERROR(stream, "varint overflow");
 117 }
 118
 119 bool checkreturn pb_skip_varint(pb_istream_t *stream)
 120 {
 121     uint8_t byte;
 122     do
 123     {
 124         if (!pb_read(stream, &byte, 1))
 125             return false;
 126     } while (byte & 0x80);
 127     return true;
 128 }
 129
 130 bool checkreturn pb_skip_string(pb_istream_t *stream)
 131 {
 132     uint32_t length;
 133     if (!pb_decode_varint32(stream, &length))
 134         return false;
 135
 136     return pb_read(stream, NULL, length);
 137 }
 138
 139 bool checkreturn pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof)
 140 {
 141     uint32_t temp;
 142     *eof = false;
 143     *wire_type = (pb_wire_type_t) 0;
 144     *tag = 0;
 145
 146     if (!pb_decode_varint32(stream, &temp))
 147     {
 148         if (stream->bytes_left == 0)
 149             *eof = true;
 150
 151         return false;
 152     }
 153
 154     if (temp == 0)
 155     {
 156         *eof = true; /* Special feature: allow 0-terminated messages. */
 157         return false;
 158     }
 159
 160     *tag = temp >> 3;
 161     *wire_type = (pb_wire_type_t)(temp & 7);
 162     return true;
 163 }
 164
 165 bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type)
 166 {
 167     switch (wire_type)
 168     {
 169         case PB_WT_VARINT: return pb_skip_varint(stream);
 170         case PB_WT_64BIT: return pb_read(stream, NULL, 8);
 171         case PB_WT_STRING: return pb_skip_string(stream);
 172         case PB_WT_32BIT: return pb_read(stream, NULL, 4);
 173         default: PB_RETURN_ERROR(stream, "invalid wire_type");
 174     }
 175 }
 176
 177 /* Read a raw value to buffer, for the purpose of passing it to callback as
 178  * a substream. Size is maximum size on call, and actual size on return.
 179  */
 180 static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size)
 181 {
 182     size_t max_size = *size;
 183     switch (wire_type)
 184     {
 185         case PB_WT_VARINT:
 186             *size = 0;
 187             do
 188             {
 189                 (*size)++;
 190                 if (*size > max_size) return false;
 191                 if (!pb_read(stream, buf, 1)) return false;
 192             } while (*buf++ & 0x80);
 193             return true;
 194
 195         case PB_WT_64BIT:
 196             *size = 8;
 197             return pb_read(stream, buf, 8);
 198
 199         case PB_WT_32BIT:
 200             *size = 4;
 201             return pb_read(stream, buf, 4);
 202
 203         default: PB_RETURN_ERROR(stream, "invalid wire_type");
 204     }
 205 }
 206
 207 /* Decode string length from stream and return a substream with limited length.
 208  * Remember to close the substream using pb_close_string_substream().
 209  */
 210 bool checkreturn pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 211 {
 212     uint32_t size;
 213     if (!pb_decode_varint32(stream, &size))
 214         return false;
 215
 216     *substream = *stream;
 217     if (substream->bytes_left < size)
 218         PB_RETURN_ERROR(stream, "parent stream too short");
 219
 220     substream->bytes_left = size;
 221     stream->bytes_left -= size;
 222     return true;
 223 }
 224
 225 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 226 {
 227     stream->state = substream->state;
 228
 229 #ifndef PB_NO_ERRMSG
 230     stream->errmsg = substream->errmsg;
 231 #endif
 232 }
 233
 234 /* Iterator for pb_field_t list */
 235 typedef struct {
 236     const pb_field_t *start; /* Start of the pb_field_t array */
 237     const pb_field_t *current; /* Current position of the iterator */
 238     int field_index; /* Zero-based index of the field. */
 239     int required_field_index; /* Zero-based index that counts only the required fields */
 240     void *dest_struct; /* Pointer to the destination structure to decode to */
 241     void *pData; /* Pointer where to store current field value */
 242     void *pSize; /* Pointer where to store the size of current array field */
 243 } pb_field_iterator_t;
 244
 245 static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct)
 246 {
 247     iter->start = iter->current = fields;
 248     iter->field_index = 0;
 249     iter->required_field_index = 0;
 250     iter->pData = (char*)dest_struct + iter->current->data_offset;
 251     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 252     iter->dest_struct = dest_struct;
 253 }
 254
 255 static bool pb_field_next(pb_field_iterator_t *iter)
 256 {
 257     bool notwrapped = true;
 258     size_t prev_size = iter->current->data_size;
 259
 260     if (PB_HTYPE(iter->current->type) == PB_HTYPE_ARRAY)
 261         prev_size *= iter->current->array_size;
 262
 263     if (PB_HTYPE(iter->current->type) == PB_HTYPE_REQUIRED)
 264         iter->required_field_index++;
 265
 266     iter->current++;
 267     iter->field_index++;
 268     if (iter->current->tag == 0)
 269     {
 270         iter->current = iter->start;
 271         iter->field_index = 0;
 272         iter->required_field_index = 0;
 273         iter->pData = iter->dest_struct;
 274         prev_size = 0;
 275         notwrapped = false;
 276     }
 277
 278     iter->pData = (char*)iter->pData + prev_size + iter->current->data_offset;
 279     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 280     return notwrapped;
 281 }
 282
 283 static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag)
 284 {
 285     int start = iter->field_index;
 286
 287     do {
 288         if (iter->current->tag == tag)
 289             return true;
 290         pb_field_next(iter);
 291     } while (iter->field_index != start);
 292
 293     return false;
 294 }
 295
 296 /*************************
 297  * Decode a single field *
 298  *************************/
 299
 300 static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 301 {
 302     pb_decoder_t func = PB_DECODERS[PB_LTYPE(iter->current->type)];
 303
 304     switch (PB_HTYPE(iter->current->type))
 305     {
 306         case PB_HTYPE_REQUIRED:
 307             return func(stream, iter->current, iter->pData);
 308
 309         case PB_HTYPE_OPTIONAL:
 310             *(bool*)iter->pSize = true;
 311             return func(stream, iter->current, iter->pData);
 312
 313         case PB_HTYPE_ARRAY:
 314             if (wire_type == PB_WT_STRING
 315                 && PB_LTYPE(iter->current->type) <= PB_LTYPE_LAST_PACKABLE)
 316             {
 317                 /* Packed array */
 318                 bool status;
 319                 size_t *size = (size_t*)iter->pSize;
 320                 pb_istream_t substream;
 321                 if (!pb_make_string_substream(stream, &substream))
 322                     return false;
 323
 324                 while (substream.bytes_left && *size < iter->current->array_size)
 325                 {
 326                     void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 327                     if (!func(&substream, iter->current, pItem))
 328                         return false;
 329                     (*size)++;
 330                 }
 331                 status = (substream.bytes_left == 0);
 332                 pb_close_string_substream(stream, &substream);
 333                 return status;
 334             }
 335             else
 336             {
 337                 /* Repeated field */
 338                 size_t *size = (size_t*)iter->pSize;
 339                 void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 340                 if (*size >= iter->current->array_size)
 341                     PB_RETURN_ERROR(stream, "array overflow");
 342
 343                 (*size)++;
 344                 return func(stream, iter->current, pItem);
 345             }
 346
 347         case PB_HTYPE_CALLBACK:
 348         {
 349             pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
 350
 351             if (pCallback->funcs.decode == NULL)
 352                 return pb_skip_field(stream, wire_type);
 353
 354             if (wire_type == PB_WT_STRING)
 355             {
 356                 pb_istream_t substream;
 357
 358                 if (!pb_make_string_substream(stream, &substream))
 359                     return false;
 360
 361                 while (substream.bytes_left)
 362                 {
 363                     if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg))
 364                         PB_RETURN_ERROR(stream, "callback failed");
 365                 }
 366
 367                 pb_close_string_substream(stream, &substream);
 368                 return true;
 369             }
 370             else
 371             {
 372                 /* Copy the single scalar value to stack.
 373                  * This is required so that we can limit the stream length,
 374                  * which in turn allows to use same callback for packed and
 375                  * not-packed fields. */
 376                 pb_istream_t substream;
 377                 uint8_t buffer[10];
 378                 size_t size = sizeof(buffer);
 379
 380                 if (!read_raw_value(stream, wire_type, buffer, &size))
 381                     return false;
 382                 substream = pb_istream_from_buffer(buffer, size);
 383
 384                 return pCallback->funcs.decode(&substream, iter->current, pCallback->arg);
 385             }
 386         }
 387
 388         default:
 389             PB_RETURN_ERROR(stream, "invalid field type");
 390     }
 391 }
 392
 393 /* Initialize message fields to default values, recursively */
 394 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
 395 {
 396     pb_field_iterator_t iter;
 397     pb_field_init(&iter, fields, dest_struct);
 398
 399     /* Initialize size/has fields and apply default values */
 400     do
 401     {
 402         if (iter.current->tag == 0)
 403             continue;
 404
 405         /* Initialize the size field for optional/repeated fields to 0. */
 406         if (PB_HTYPE(iter.current->type) == PB_HTYPE_OPTIONAL)
 407         {
 408             *(bool*)iter.pSize = false;
 409         }
 410         else if (PB_HTYPE(iter.current->type) == PB_HTYPE_ARRAY)
 411         {
 412             *(size_t*)iter.pSize = 0;
 413             continue; /* Array is empty, no need to initialize contents */
 414         }
 415
 416         /* Initialize field contents to default value */
 417         if (PB_HTYPE(iter.current->type) == PB_HTYPE_CALLBACK)
 418         {
 419             continue; /* Don't overwrite callback */
 420         }
 421         else if (PB_LTYPE(iter.current->type) == PB_LTYPE_SUBMESSAGE)
 422         {
 423             pb_message_set_to_defaults((const pb_field_t *) iter.current->ptr, iter.pData);
 424         }
 425         else if (iter.current->ptr != NULL)
 426         {
 427             memcpy(iter.pData, iter.current->ptr, iter.current->data_size);
 428         }
 429         else
 430         {
 431             memset(iter.pData, 0, iter.current->data_size);
 432         }
 433     } while (pb_field_next(&iter));
 434 }
 435
 436 /*********************
 437  * Decode all fields *
 438  *********************/
 439
 440 bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 441 {
 442     uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0}; /* Used to check for required fields */
 443     pb_field_iterator_t iter;
 444
 445     pb_field_init(&iter, fields, dest_struct);
 446
 447     while (stream->bytes_left)
 448     {
 449         uint32_t tag;
 450         pb_wire_type_t wire_type;
 451         bool eof;
 452
 453         if (!pb_decode_tag(stream, &wire_type, &tag, &eof))
 454         {
 455             if (eof)
 456                 break;
 457             else
 458                 return false;
 459         }
 460
 461         if (!pb_field_find(&iter, tag))
 462         {
 463             /* No match found, skip data */
 464             if (!pb_skip_field(stream, wire_type))
 465                 return false;
 466             continue;
 467         }
 468
 469         if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED
 470             && iter.required_field_index < PB_MAX_REQUIRED_FIELDS)
 471         {
 472             fields_seen[iter.required_field_index >> 3] |= (uint8_t)(1 << (iter.required_field_index & 7));
 473         }
 474
 475         if (!decode_field(stream, wire_type, &iter))
 476             return false;
 477     }
 478
 479     /* Check that all required fields were present. */
 480     pb_field_init(&iter, fields, dest_struct);
 481     do {
 482         if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED &&
 483             iter.required_field_index < PB_MAX_REQUIRED_FIELDS &&
 484             !(fields_seen[iter.required_field_index >> 3] & (1 << (iter.required_field_index & 7))))
 485         {
 486             PB_RETURN_ERROR(stream, "missing required field");
 487         }
 488     } while (pb_field_next(&iter));
 489
 490     return true;
 491 }
 492
 493 bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 494 {
 495     pb_message_set_to_defaults(fields, dest_struct);
 496     return pb_decode_noinit(stream, fields, dest_struct);
 497 }
 498
 499 /* Field decoders */
 500
 501 bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest)
 502 {
 503     uint64_t value;
 504     if (!pb_decode_varint(stream, &value))
 505         return false;
 506
 507     if (value & 1)
 508         *dest = (int64_t)(~(value >> 1));
 509     else
 510         *dest = (int64_t)(value >> 1);
 511
 512     return true;
 513 }
 514
 515 bool pb_decode_fixed32(pb_istream_t *stream, void *dest)
 516 {
 517     #ifdef __BIG_ENDIAN__
 518     uint8_t *bytes = (uint8_t*)dest;
 519     uint8_t lebytes[4];
 520
 521     if (!pb_read(stream, lebytes, 4))
 522         return false;
 523
 524     bytes[0] = lebytes[3];
 525     bytes[1] = lebytes[2];
 526     bytes[2] = lebytes[1];
 527     bytes[3] = lebytes[0];
 528     return true;
 529     #else
 530     return pb_read(stream, (uint8_t*)dest, 4);
 531     #endif
 532 }
 533
 534 bool pb_decode_fixed64(pb_istream_t *stream, void *dest)
 535 {
 536     #ifdef __BIG_ENDIAN__
 537     uint8_t *bytes = (uint8_t*)dest;
 538     uint8_t lebytes[8];
 539
 540     if (!pb_read(stream, lebytes, 8))
 541         return false;
 542
 543     bytes[0] = lebytes[7];
 544     bytes[1] = lebytes[6];
 545     bytes[2] = lebytes[5];
 546     bytes[3] = lebytes[4];
 547     bytes[4] = lebytes[3];
 548     bytes[5] = lebytes[2];
 549     bytes[6] = lebytes[1];
 550     bytes[7] = lebytes[0];
 551     return true;
 552     #else
 553     return pb_read(stream, (uint8_t*)dest, 8);
 554     #endif
 555 }
 556
 557 bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 558 {
 559     uint64_t value;
 560     bool status = pb_decode_varint(stream, &value);
 561
 562     switch (field->data_size)
 563     {
 564         case 1: *(uint8_t*)dest = (uint8_t)value; break;
 565         case 2: *(uint16_t*)dest = (uint16_t)value; break;
 566         case 4: *(uint32_t*)dest = (uint32_t)value; break;
 567         case 8: *(uint64_t*)dest = value; break;
 568         default: PB_RETURN_ERROR(stream, "invalid data_size");
 569     }
 570
 571     return status;
 572 }
 573
 574 bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 575 {
 576     int64_t value;
 577     bool status = pb_decode_svarint(stream, &value);
 578
 579     switch (field->data_size)
 580     {
 581         case 4: *(int32_t*)dest = (int32_t)value; break;
 582         case 8: *(int64_t*)dest = value; break;
 583         default: PB_RETURN_ERROR(stream, "invalid data_size");
 584     }
 585
 586     return status;
 587 }
 588
 589 bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
 590 {
 591     UNUSED(field);
 592     return pb_decode_fixed32(stream, dest);
 593 }
 594
 595 bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
 596 {
 597     UNUSED(field);
 598     return pb_decode_fixed64(stream, dest);
 599 }
 600
 601 bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
 602 {
 603     pb_bytes_array_t *x = (pb_bytes_array_t*)dest;
 604
 605     uint32_t temp;
 606     if (!pb_decode_varint32(stream, &temp))
 607         return false;
 608     x->size = temp;
 609
 610     /* Check length, noting the space taken by the size_t header. */
 611     if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes))
 612         PB_RETURN_ERROR(stream, "bytes overflow");
 613
 614     return pb_read(stream, x->bytes, x->size);
 615 }
 616
 617 bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
 618 {
 619     uint32_t size;
 620     bool status;
 621     if (!pb_decode_varint32(stream, &size))
 622         return false;
 623
 624     /* Check length, noting the null terminator */
 625     if (size + 1 > field->data_size)
 626         PB_RETURN_ERROR(stream, "string overflow");
 627
 628     status = pb_read(stream, (uint8_t*)dest, size);
 629     *((uint8_t*)dest + size) = 0;
 630     return status;
 631 }
 632
 633 bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
 634 {
 635     bool status;
 636     pb_istream_t substream;
 637     const pb_field_t* submsg_fields = (const pb_field_t*)field->ptr;
 638
 639     if (!pb_make_string_substream(stream, &substream))
 640         return false;
 641
 642     if (field->ptr == NULL)
 643         PB_RETURN_ERROR(stream, "invalid field descriptor");
 644
 645     /* New array entries need to be initialized, while required and optional
 646      * submessages have already been initialized in the top-level pb_decode. */
 647     if (PB_HTYPE(field->type) == PB_HTYPE_ARRAY)
 648         status = pb_decode(&substream, submsg_fields, dest);
 649     else
 650         status = pb_decode_noinit(&substream, submsg_fields, dest);
 651
 652     pb_close_string_substream(stream, &substream);
 653     return status;
 654 }