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 bool pb_decode_varint32(pb_istream_t *stream, uint32_t *dest)
  66 {
  67     uint64_t temp;
  68     bool status = pb_decode_varint64(stream, &temp);
  69     *dest = temp;
  70     return status;
  71 }
  72
  73 bool pb_decode_varint64(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 all 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;
 189     iter->dest_struct = dest_struct;
 190 }
 191
 192 static bool pb_field_next(pb_field_iterator_t *iter)
 193 {
 194     bool notwrapped = true;
 195     iter->current++;
 196     iter->field_index++;
 197     if (iter->current->tag == 0)
 198     {
 199         iter->current = iter->start;
 200         iter->field_index = 0;
 201         iter->pData = iter->dest_struct;
 202         notwrapped = false;
 203     }
 204
 205     iter->pData = (char*)iter->pData + iter->current->data_offset;
 206     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 207     return notwrapped;
 208 }
 209
 210 static bool pb_field_find(pb_field_iterator_t *iter, int tag)
 211 {
 212     int start = iter->field_index;
 213
 214     do {
 215         if (iter->current->tag == tag)
 216             return true;
 217         pb_field_next(iter);
 218     } while (iter->field_index != start);
 219
 220     return false;
 221 }
 222
 223 /*************************
 224  * Decode a single field *
 225  *************************/
 226
 227 bool decode_field(pb_istream_t *stream, int wire_type, pb_field_iterator_t *iter)
 228 {
 229     pb_decoder_t func = PB_DECODERS[PB_LTYPE(iter->current->type)];
 230
 231     switch (PB_HTYPE(iter->current->type))
 232     {
 233         case PB_HTYPE_REQUIRED:
 234             return func(stream, iter->current, iter->pData);
 235
 236         case PB_HTYPE_OPTIONAL:
 237             *(bool*)iter->pSize = true;
 238             return func(stream, iter->current, iter->pData);
 239
 240         case PB_HTYPE_ARRAY:
 241             if (wire_type == PB_WT_STRING
 242                 && PB_LTYPE(iter->current->type) <= PB_LTYPE_LAST_PACKABLE)
 243             {
 244                 /* Packed array */
 245                 size_t *size = (size_t*)iter->pSize;
 246                 pb_istream_t substream;
 247                 if (!make_string_substream(stream, &substream))
 248                     return false;
 249
 250                 while (substream.bytes_left && *size < iter->current->array_size)
 251                 {
 252                     void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 253                     if (!func(stream, iter->current, pItem))
 254                         return false;
 255                     (*size)++;
 256                 }
 257                 return (substream.bytes_left == 0);
 258             }
 259             else
 260             {
 261                 /* Repeated field */
 262                 size_t *size = (size_t*)iter->pSize;
 263                 void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 264                 if (*size >= iter->current->array_size)
 265                     return false;
 266
 267                 (*size)++;
 268                 return func(stream, iter->current, pItem);
 269             }
 270
 271         case PB_HTYPE_CALLBACK:
 272             if (wire_type == PB_WT_STRING)
 273             {
 274                 pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
 275                 pb_istream_t substream;
 276
 277                 if (!make_string_substream(stream, &substream))
 278                     return false;
 279
 280                 while (substream.bytes_left)
 281                 {
 282                     if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg))
 283                         return false;
 284                 }
 285                 return true;
 286             }
 287             else
 288             {
 289                 /* Copy the single scalar value to stack.
 290                  * This is required so that we can limit the stream length,
 291                  * which in turn allows to use same callback for packed and
 292                  * not-packed fields. */
 293                 pb_istream_t substream;
 294                 pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
 295                 uint8_t buffer[10];
 296                 size_t size = sizeof(buffer);
 297
 298                 if (!read_raw_value(stream, wire_type, buffer, &size))
 299                     return false;
 300                 substream = pb_istream_from_buffer(buffer, size);
 301
 302                 return pCallback->funcs.decode(&substream, iter->current, pCallback->arg);
 303             }
 304
 305         default:
 306             return false;
 307     }
 308 }
 309
 310 /*********************
 311  * Decode all fields *
 312  *********************/
 313
 314 bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 315 {
 316     uint32_t fields_seen = 0; /* Used to check for required fields */
 317     pb_field_iterator_t iter;
 318     int i;
 319
 320     if (fields[0].tag == 0)
 321     {
 322         /* No fields -> nothing to do */
 323         return pb_read(stream, NULL, stream->bytes_left);
 324     }
 325
 326     pb_field_init(&iter, fields, dest_struct);
 327
 328     /* Initialize size/has fields and apply default values */
 329     do
 330     {
 331         if (PB_HTYPE(iter.current->type) == PB_HTYPE_OPTIONAL)
 332         {
 333             *(bool*)iter.pSize = false;
 334
 335             /* Initialize to default value */
 336             if (iter.current->ptr != NULL)
 337                 memcpy(iter.pData, iter.current->ptr, iter.current->data_size);
 338             else
 339                 memset(iter.pData, 0, iter.current->data_size);
 340         }
 341         else if (PB_HTYPE(iter.current->type) == PB_HTYPE_ARRAY)
 342         {
 343             *(size_t*)iter.pSize = 0;
 344         }
 345     } while (pb_field_next(&iter));
 346
 347     while (stream->bytes_left)
 348     {
 349         uint32_t temp;
 350         int tag, wire_type;
 351         if (!pb_decode_varint32(stream, &temp))
 352             return false;
 353
 354         tag = temp >> 3;
 355         wire_type = temp & 7;
 356
 357         if (!pb_field_find(&iter, tag))
 358         {
 359             /* No match found, skip data */
 360             skip(stream, wire_type);
 361             continue;
 362         }
 363
 364         fields_seen |= 1 << (iter.field_index & 31);
 365
 366         if (!decode_field(stream, wire_type, &iter))
 367             return false;
 368     }
 369
 370     /* Check that all required fields (mod 31) were present. */
 371     for (i = 0; fields[i].tag != 0; i++)
 372     {
 373         if (PB_HTYPE(fields[i].type) == PB_HTYPE_REQUIRED &&
 374             !(fields_seen & (1 << (i & 31))))
 375         {
 376             return false;
 377         }
 378     }
 379
 380     return true;
 381 }
 382
 383 /* Field decoders */
 384
 385 /* Copy destsize bytes from src so that values are casted properly.
 386  * On little endian machine, copy first n bytes of src
 387  * On big endian machine, copy last n bytes of src
 388  * srcsize must always be larger than destsize
 389  */
 390 static void endian_copy(void *dest, void *src, size_t destsize, size_t srcsize)
 391 {
 392 #ifdef __BIG_ENDIAN__
 393     memcpy(dest, (char*)src + (srcsize - destsize), destsize);
 394 #else
 395     memcpy(dest, src, destsize);
 396 #endif
 397 }
 398
 399 bool pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 400 {
 401     uint64_t temp;
 402     bool status = pb_decode_varint64(stream, &temp);
 403     endian_copy(dest, &temp, field->data_size, sizeof(temp));
 404     return status;
 405 }
 406
 407 bool pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 408 {
 409     uint64_t temp;
 410     bool status = pb_decode_varint64(stream, &temp);
 411     temp = (temp >> 1) ^ -(int64_t)(temp & 1);
 412     endian_copy(dest, &temp, field->data_size, sizeof(temp));
 413     return status;
 414 }
 415
 416 bool pb_dec_fixed(pb_istream_t *stream, const pb_field_t *field, void *dest)
 417 {
 418 #ifdef __BIG_ENDIAN__
 419     uint8_t bytes[8] = {0};
 420     bool status = pb_read(stream, bytes, field->data_size);
 421     uint8_t bebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4],
 422                           bytes[3], bytes[2], bytes[1], bytes[0]};
 423     endian_copy(dest, lebytes, field->data_size, 8);
 424     return status;
 425 #else
 426     return pb_read(stream, (uint8_t*)dest, field->data_size);
 427 #endif
 428 }
 429
 430 bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
 431 {
 432     pb_bytes_array_t *x = (pb_bytes_array_t*)dest;
 433
 434     uint32_t temp;
 435     if (!pb_decode_varint32(stream, &temp))
 436         return false;
 437     x->size = temp;
 438
 439     /* Note: data_size includes the size of the x.size field, too.
 440      * Calculate actual size starting from offset. */
 441     if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes))
 442         return false;
 443
 444     return pb_read(stream, x->bytes, x->size);
 445 }
 446
 447 bool pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
 448 {
 449     uint32_t size;
 450     bool status;
 451     if (!pb_decode_varint32(stream, &size))
 452         return false;
 453
 454     if (size > field->data_size - 1)
 455         return false;
 456
 457     status = pb_read(stream, (uint8_t*)dest, size);
 458     *((uint8_t*)dest + size) = 0;
 459     return status;
 460 }
 461
 462 bool pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
 463 {
 464     pb_istream_t substream;
 465
 466     if (!make_string_substream(stream, &substream))
 467         return false;
 468
 469     if (field->ptr == NULL)
 470         return false;
 471
 472     return pb_decode(&substream, (pb_field_t*)field->ptr, dest);
 473 }