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