pb_decode.c

   1 /* pb_decode.c -- decode a protobuf using minimal resources
   2  *
   3  * 2011 Petteri Aimonen <jpa@kapsi.fi>
   4  */
   5
   6 #include "pb.h"
   7 #include "pb_decode.h"
   8 #include <string.h>
   9
  10 typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest);
  11
  12 /* --- Function pointers to field decoders ---
  13  * Order in the array must match pb_action_t LTYPE numbering.
  14  */
  15 static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = {
  16     &pb_dec_varint,
  17     &pb_dec_svarint,
  18     &pb_dec_fixed,
  19
  20     &pb_dec_bytes,
  21     &pb_dec_string,
  22     &pb_dec_submessage
  23 };
  24
  25 /**************
  26  * pb_istream *
  27  **************/
  28
  29 bool pb_read(pb_istream_t *stream, uint8_t *buf, size_t count)
  30 {
  31     if (stream->bytes_left < count)
  32         return false;
  33
  34     if (!stream->callback(stream, buf, count))
  35         return false;
  36
  37     stream->bytes_left -= count;
  38     return true;
  39 }
  40
  41 static bool buf_read(pb_istream_t *stream, uint8_t *buf, size_t count)
  42 {
  43     uint8_t *source = (uint8_t*)stream->state;
  44
  45     if (buf != NULL)
  46         memcpy(buf, source, count);
  47
  48     stream->state = source + count;
  49     return true;
  50 }
  51
  52 pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize)
  53 {
  54     pb_istream_t stream;
  55     stream.callback = &buf_read;
  56     stream.state = buf;
  57     stream.bytes_left = bufsize;
  58     return stream;
  59 }
  60
  61 /********************
  62  * Helper functions *
  63  ********************/
  64
  65 static bool pb_decode_varint32(pb_istream_t *stream, uint32_t *dest)
  66 {
  67     uint64_t temp;
  68     bool status = pb_decode_varint(stream, &temp);
  69     *dest = temp;
  70     return status;
  71 }
  72
  73 bool pb_decode_varint(pb_istream_t *stream, uint64_t *dest)
  74 {
  75     uint8_t byte;
  76     int bitpos = 0;
  77     *dest = 0;
  78
  79     while (bitpos < 64 && pb_read(stream, &byte, 1))
  80     {
  81         *dest |= (uint64_t)(byte & 0x7F) << bitpos;
  82         bitpos += 7;
  83
  84         if (!(byte & 0x80))
  85             return true;
  86     }
  87
  88     return false;
  89 }
  90
  91 bool pb_skip_varint(pb_istream_t *stream)
  92 {
  93     uint8_t byte;
  94     do
  95     {
  96         if (!pb_read(stream, &byte, 1))
  97             return false;
  98     } while (byte & 0x80);
  99     return true;
 100 }
 101
 102 bool pb_skip_string(pb_istream_t *stream)
 103 {
 104     uint32_t length;
 105     if (!pb_decode_varint32(stream, &length))
 106         return false;
 107
 108     return pb_read(stream, NULL, length);
 109 }
 110
 111 /* Currently the wire type related stuff is kept hidden from
 112  * callbacks. They shouldn't need it. It's better for performance
 113  * to just assume the correct type and fail safely on corrupt message.
 114  */
 115
 116 static bool skip(pb_istream_t *stream, int wire_type)
 117 {
 118     switch (wire_type)
 119     {
 120         case PB_WT_VARINT: return pb_skip_varint(stream);
 121         case PB_WT_64BIT: return pb_read(stream, NULL, 8);
 122         case PB_WT_STRING: return pb_skip_string(stream);
 123         case PB_WT_32BIT: return pb_read(stream, NULL, 4);
 124         default: return false;
 125     }
 126 }
 127
 128 /* Read a raw value to buffer, for the purpose of passing it to callback as
 129  * a substream. Size is maximum size on call, and actual size on return.
 130  */
 131 static bool read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size)
 132 {
 133     size_t max_size = *size;
 134     switch (wire_type)
 135     {
 136         case PB_WT_VARINT:
 137             *size = 0;
 138             do
 139             {
 140                 (*size)++;
 141                 if (*size > max_size) return false;
 142                 if (!pb_read(stream, buf, 1)) return false;
 143             } while (*buf++ & 0x80);
 144             return true;
 145
 146         case PB_WT_64BIT:
 147             *size = 8;
 148             return pb_read(stream, buf, 8);
 149
 150         case PB_WT_32BIT:
 151             *size = 4;
 152             return pb_read(stream, buf, 4);
 153
 154         default: return false;
 155     }
 156 }
 157
 158 /* Decode string length from stream and return a substream with limited length */
 159 static bool make_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 160 {
 161     uint32_t size;
 162     if (!pb_decode_varint32(stream, &size))
 163         return false;
 164
 165     *substream = *stream;
 166     if (substream->bytes_left < size)
 167         return false;
 168
 169     substream->bytes_left = size;
 170     stream->bytes_left -= size;
 171     return true;
 172 }
 173
 174 /* Iterator for pb_field_t list */
 175 typedef struct {
 176     const pb_field_t *start;
 177     const pb_field_t *current;
 178     int field_index;
 179     void *dest_struct;
 180     void *pData;
 181     void *pSize;
 182 } pb_field_iterator_t;
 183
 184 static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct)
 185 {
 186     iter->start = iter->current = fields;
 187     iter->field_index = 0;
 188     iter->pData = dest_struct + iter->current->data_offset;
 189     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 190     iter->dest_struct = dest_struct;
 191 }
 192
 193 static bool pb_field_next(pb_field_iterator_t *iter)
 194 {
 195     bool notwrapped = true;
 196     size_t prev_size = iter->current->data_size;
 197
 198     if (PB_HTYPE(iter->current->type) == PB_HTYPE_ARRAY)
 199         prev_size *= iter->current->array_size;
 200
 201     iter->current++;
 202     iter->field_index++;
 203     if (iter->current->tag == 0)
 204     {
 205         iter->current = iter->start;
 206         iter->field_index = 0;
 207         iter->pData = iter->dest_struct;
 208         prev_size = 0;
 209         notwrapped = false;
 210     }
 211
 212     iter->pData = (char*)iter->pData + prev_size + iter->current->data_offset;
 213     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 214     return notwrapped;
 215 }
 216
 217 static bool pb_field_find(pb_field_iterator_t *iter, int tag)
 218 {
 219     int start = iter->field_index;
 220
 221     do {
 222         if (iter->current->tag == tag)
 223             return true;
 224         pb_field_next(iter);
 225     } while (iter->field_index != start);
 226
 227     return false;
 228 }
 229
 230 /*************************
 231  * Decode a single field *
 232  *************************/
 233
 234 static bool decode_field(pb_istream_t *stream, int wire_type, pb_field_iterator_t *iter)
 235 {
 236     pb_decoder_t func = PB_DECODERS[PB_LTYPE(iter->current->type)];
 237
 238     switch (PB_HTYPE(iter->current->type))
 239     {
 240         case PB_HTYPE_REQUIRED:
 241             return func(stream, iter->current, iter->pData);
 242
 243         case PB_HTYPE_OPTIONAL:
 244             *(bool*)iter->pSize = true;
 245             return func(stream, iter->current, iter->pData);
 246
 247         case PB_HTYPE_ARRAY:
 248             if (wire_type == PB_WT_STRING
 249                 && PB_LTYPE(iter->current->type) <= PB_LTYPE_LAST_PACKABLE)
 250             {
 251                 /* Packed array */
 252                 size_t *size = (size_t*)iter->pSize;
 253                 pb_istream_t substream;
 254                 if (!make_string_substream(stream, &substream))
 255                     return false;
 256
 257                 while (substream.bytes_left && *size < iter->current->array_size)
 258                 {
 259                     void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 260                     if (!func(stream, iter->current, pItem))
 261                         return false;
 262                     (*size)++;
 263                 }
 264                 return (substream.bytes_left == 0);
 265             }
 266             else
 267             {
 268                 /* Repeated field */
 269                 size_t *size = (size_t*)iter->pSize;
 270                 void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 271                 if (*size >= iter->current->array_size)
 272                     return false;
 273
 274                 (*size)++;
 275                 return func(stream, iter->current, pItem);
 276             }
 277
 278         case PB_HTYPE_CALLBACK:
 279         {
 280             pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
 281
 282             if (pCallback->funcs.decode == NULL)
 283                 return skip(stream, wire_type);
 284
 285             if (wire_type == PB_WT_STRING)
 286             {
 287                 pb_istream_t substream;
 288
 289                 if (!make_string_substream(stream, &substream))
 290                     return false;
 291
 292                 while (substream.bytes_left)
 293                 {
 294                     if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg))
 295                         return false;
 296                 }
 297                 return true;
 298             }
 299             else
 300             {
 301                 /* Copy the single scalar value to stack.
 302                  * This is required so that we can limit the stream length,
 303                  * which in turn allows to use same callback for packed and
 304                  * not-packed fields. */
 305                 pb_istream_t substream;
 306                 uint8_t buffer[10];
 307                 size_t size = sizeof(buffer);
 308
 309                 if (!read_raw_value(stream, wire_type, buffer, &size))
 310                     return false;
 311                 substream = pb_istream_from_buffer(buffer, size);
 312
 313                 return pCallback->funcs.decode(&substream, iter->current, pCallback->arg);
 314             }
 315         }
 316
 317         default:
 318             return false;
 319     }
 320 }
 321
 322 /*********************
 323  * Decode all fields *
 324  *********************/
 325
 326 bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 327 {
 328     uint32_t fields_seen = 0; /* Used to check for required fields */
 329     pb_field_iterator_t iter;
 330     int i;
 331
 332     if (fields[0].tag == 0)
 333     {
 334         /* No fields -> nothing to do */
 335         return pb_read(stream, NULL, stream->bytes_left);
 336     }
 337
 338     pb_field_init(&iter, fields, dest_struct);
 339
 340     /* Initialize size/has fields and apply default values */
 341     do
 342     {
 343         if (PB_HTYPE(iter.current->type) == PB_HTYPE_OPTIONAL)
 344         {
 345             *(bool*)iter.pSize = false;
 346
 347             /* Initialize to default value */
 348             if (iter.current->ptr != NULL)
 349                 memcpy(iter.pData, iter.current->ptr, iter.current->data_size);
 350             else
 351                 memset(iter.pData, 0, iter.current->data_size);
 352         }
 353         else if (PB_HTYPE(iter.current->type) == PB_HTYPE_ARRAY)
 354         {
 355             *(size_t*)iter.pSize = 0;
 356         }
 357         else if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED)
 358         {
 359             memset(iter.pData, 0, iter.current->data_size);
 360         }
 361     } while (pb_field_next(&iter));
 362
 363     while (stream->bytes_left)
 364     {
 365         uint32_t temp;
 366         int tag, wire_type;
 367         if (!pb_decode_varint32(stream, &temp))
 368         {
 369             if (stream->bytes_left == 0)
 370                 break; /* It was EOF */
 371             else
 372                 return false; /* It was error */
 373         }
 374
 375         if (temp == 0)
 376             break; /* Special feature: allow 0-terminated messages. */
 377
 378         tag = temp >> 3;
 379         wire_type = temp & 7;
 380
 381         if (!pb_field_find(&iter, tag))
 382         {
 383             /* No match found, skip data */
 384             skip(stream, wire_type);
 385             continue;
 386         }
 387
 388         fields_seen |= 1 << (iter.field_index & 31);
 389
 390         if (!decode_field(stream, wire_type, &iter))
 391             return false;
 392     }
 393
 394     /* Check that all required fields (mod 31) were present. */
 395     for (i = 0; fields[i].tag != 0; i++)
 396     {
 397         if (PB_HTYPE(fields[i].type) == PB_HTYPE_REQUIRED &&
 398             !(fields_seen & (1 << (i & 31))))
 399         {
 400             return false;
 401         }
 402     }
 403
 404     return true;
 405 }
 406
 407 /* Field decoders */
 408
 409 /* Copy destsize bytes from src so that values are casted properly.
 410  * On little endian machine, copy first n bytes of src
 411  * On big endian machine, copy last n bytes of src
 412  * srcsize must always be larger than destsize
 413  */
 414 static void endian_copy(void *dest, void *src, size_t destsize, size_t srcsize)
 415 {
 416 #ifdef __BIG_ENDIAN__
 417     memcpy(dest, (char*)src + (srcsize - destsize), destsize);
 418 #else
 419     memcpy(dest, src, destsize);
 420 #endif
 421 }
 422
 423 bool pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 424 {
 425     uint64_t temp;
 426     bool status = pb_decode_varint(stream, &temp);
 427     endian_copy(dest, &temp, field->data_size, sizeof(temp));
 428     return status;
 429 }
 430
 431 bool pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 432 {
 433     uint64_t temp;
 434     bool status = pb_decode_varint(stream, &temp);
 435     temp = (temp >> 1) ^ -(int64_t)(temp & 1);
 436     endian_copy(dest, &temp, field->data_size, sizeof(temp));
 437     return status;
 438 }
 439
 440 bool pb_dec_fixed(pb_istream_t *stream, const pb_field_t *field, void *dest)
 441 {
 442 #ifdef __BIG_ENDIAN__
 443     uint8_t bytes[8] = {0};
 444     bool status = pb_read(stream, bytes, field->data_size);
 445     uint8_t bebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4],
 446                           bytes[3], bytes[2], bytes[1], bytes[0]};
 447     endian_copy(dest, lebytes, field->data_size, 8);
 448     return status;
 449 #else
 450     return pb_read(stream, (uint8_t*)dest, field->data_size);
 451 #endif
 452 }
 453
 454 bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
 455 {
 456     pb_bytes_array_t *x = (pb_bytes_array_t*)dest;
 457
 458     uint32_t temp;
 459     if (!pb_decode_varint32(stream, &temp))
 460         return false;
 461     x->size = temp;
 462
 463     /* Note: data_size includes the size of the x.size field, too.
 464      * Calculate actual size starting from offset. */
 465     if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes))
 466         return false;
 467
 468     return pb_read(stream, x->bytes, x->size);
 469 }
 470
 471 bool pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
 472 {
 473     uint32_t size;
 474     bool status;
 475     if (!pb_decode_varint32(stream, &size))
 476         return false;
 477
 478     if (size > field->data_size - 1)
 479         return false;
 480
 481     status = pb_read(stream, (uint8_t*)dest, size);
 482     *((uint8_t*)dest + size) = 0;
 483     return status;
 484 }
 485
 486 bool pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
 487 {
 488     pb_istream_t substream;
 489
 490     if (!make_string_substream(stream, &substream))
 491         return false;
 492
 493     if (field->ptr == NULL)
 494         return false;
 495
 496     return pb_decode(&substream, (pb_field_t*)field->ptr, dest);
 497 }