pb_encode.c

   1 /* pb_encode.c -- encode a protobuf using minimal resources
   2  *
   3  * 2011 Petteri Aimonen <jpa@kapsi.fi>
   4  */
   5
   6 #define NANOPB_INTERNALS
   7 #include "pb.h"
   8 #include "pb_encode.h"
   9
  10 /* The warn_unused_result attribute appeared first in gcc-3.4.0 */
  11 #if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
  12     #define checkreturn
  13 #else
  14     /* Verify that we remember to check all return values for proper error propagation */
  15     #define checkreturn __attribute__((warn_unused_result))
  16 #endif
  17
  18 typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src) checkreturn;
  19
  20 /* --- Function pointers to field encoders ---
  21  * Order in the array must match pb_action_t LTYPE numbering.
  22  */
  23 static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
  24     &pb_enc_varint,
  25     &pb_enc_svarint,
  26     &pb_enc_fixed32,
  27     &pb_enc_fixed64,
  28
  29     &pb_enc_bytes,
  30     &pb_enc_string,
  31     &pb_enc_submessage,
  32     NULL /* extensions */
  33 };
  34
  35 /* pb_ostream_t implementation */
  36
  37 static bool checkreturn buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
  38 {
  39     uint8_t *dest = (uint8_t*)stream->state;
  40     stream->state = dest + count;
  41
  42     while (count--)
  43         *dest++ = *buf++;
  44
  45     return true;
  46 }
  47
  48 pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize)
  49 {
  50     pb_ostream_t stream;
  51 #ifdef PB_BUFFER_ONLY
  52     stream.callback = (void*)1; /* Just some marker value */
  53 #else
  54     stream.callback = &buf_write;
  55 #endif
  56     stream.state = buf;
  57     stream.max_size = bufsize;
  58     stream.bytes_written = 0;
  59 #ifndef PB_NO_ERRMSG
  60     stream.errmsg = NULL;
  61 #endif
  62     return stream;
  63 }
  64
  65 bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
  66 {
  67     if (stream->callback != NULL)
  68     {
  69         if (stream->bytes_written + count > stream->max_size)
  70             PB_RETURN_ERROR(stream, "stream full");
  71
  72 #ifdef PB_BUFFER_ONLY
  73         if (!buf_write(stream, buf, count))
  74             PB_RETURN_ERROR(stream, "io error");
  75 #else
  76         if (!stream->callback(stream, buf, count))
  77             PB_RETURN_ERROR(stream, "io error");
  78 #endif
  79     }
  80
  81     stream->bytes_written += count;
  82     return true;
  83 }
  84
  85 /* Main encoding stuff */
  86
  87 /* Encode a static array. Handles the size calculations and possible packing. */
  88 static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field,
  89                          const void *pData, size_t count, pb_encoder_t func)
  90 {
  91     size_t i;
  92     const void *p;
  93     size_t size;
  94
  95     if (count == 0)
  96         return true;
  97
  98     /* We always pack arrays if the datatype allows it. */
  99     if (PB_LTYPE(field->type) <= PB_LTYPE_LAST_PACKABLE)
 100     {
 101         if (!pb_encode_tag(stream, PB_WT_STRING, field->tag))
 102             return false;
 103
 104         /* Determine the total size of packed array. */
 105         if (PB_LTYPE(field->type) == PB_LTYPE_FIXED32)
 106         {
 107             size = 4 * count;
 108         }
 109         else if (PB_LTYPE(field->type) == PB_LTYPE_FIXED64)
 110         {
 111             size = 8 * count;
 112         }
 113         else
 114         {
 115             pb_ostream_t sizestream = PB_OSTREAM_SIZING;
 116             p = pData;
 117             for (i = 0; i < count; i++)
 118             {
 119                 if (!func(&sizestream, field, p))
 120                     return false;
 121                 p = (const char*)p + field->data_size;
 122             }
 123             size = sizestream.bytes_written;
 124         }
 125
 126         if (!pb_encode_varint(stream, (uint64_t)size))
 127             return false;
 128
 129         if (stream->callback == NULL)
 130             return pb_write(stream, NULL, size); /* Just sizing.. */
 131
 132         /* Write the data */
 133         p = pData;
 134         for (i = 0; i < count; i++)
 135         {
 136             if (!func(stream, field, p))
 137                 return false;
 138             p = (const char*)p + field->data_size;
 139         }
 140     }
 141     else
 142     {
 143         p = pData;
 144         for (i = 0; i < count; i++)
 145         {
 146             if (!pb_encode_tag_for_field(stream, field))
 147                 return false;
 148             if (!func(stream, field, p))
 149                 return false;
 150             p = (const char*)p + field->data_size;
 151         }
 152     }
 153
 154     return true;
 155 }
 156
 157 /* Encode a field with static allocation, i.e. one whose data is stored
 158  * in the structure itself. */
 159 static bool checkreturn encode_static_field(pb_ostream_t *stream,
 160     const pb_field_t *field, const void *pData)
 161 {
 162     pb_encoder_t func;
 163     const void *pSize;
 164
 165     func = PB_ENCODERS[PB_LTYPE(field->type)];
 166     pSize = (const char*)pData + field->size_offset;
 167
 168     switch (PB_HTYPE(field->type))
 169     {
 170         case PB_HTYPE_REQUIRED:
 171             if (!pb_encode_tag_for_field(stream, field))
 172                 return false;
 173             if (!func(stream, field, pData))
 174                 return false;
 175             break;
 176
 177         case PB_HTYPE_OPTIONAL:
 178             if (*(const bool*)pSize)
 179             {
 180                 if (!pb_encode_tag_for_field(stream, field))
 181                     return false;
 182
 183                 if (!func(stream, field, pData))
 184                     return false;
 185             }
 186             break;
 187
 188         case PB_HTYPE_REPEATED:
 189             if (!encode_array(stream, field, pData, *(const size_t*)pSize, func))
 190                 return false;
 191             break;
 192
 193         default:
 194             PB_RETURN_ERROR(stream, "invalid field type");
 195     }
 196
 197     return true;
 198 }
 199
 200 /* Encode a field with callback semantics. This means that a user function is
 201  * called to provide and encode the actual data. */
 202 static bool checkreturn encode_callback_field(pb_ostream_t *stream,
 203     const pb_field_t *field, const void *pData)
 204 {
 205     const pb_callback_t *callback = (const pb_callback_t*)pData;
 206
 207 #ifdef PB_OLD_CALLBACK_STYLE
 208     const void *arg = callback->arg;
 209 #else
 210     void * const *arg = &(callback->arg);
 211 #endif
 212
 213     if (callback->funcs.encode != NULL)
 214     {
 215         if (!callback->funcs.encode(stream, field, arg))
 216             PB_RETURN_ERROR(stream, "callback error");
 217     }
 218     return true;
 219 }
 220
 221 /* Encode a single field of any callback or static type. */
 222 static bool checkreturn encode_field(pb_ostream_t *stream,
 223     const pb_field_t *field, const void *pData)
 224 {
 225     switch (PB_ATYPE(field->type))
 226     {
 227         case PB_ATYPE_STATIC:
 228             return encode_static_field(stream, field, pData);
 229
 230         case PB_ATYPE_CALLBACK:
 231             return encode_callback_field(stream, field, pData);
 232
 233         default:
 234             PB_RETURN_ERROR(stream, "invalid field type");
 235     }
 236 }
 237
 238 /* Default handler for extension fields. Expects to have a pb_field_t
 239  * pointer in the extension->type->arg field. */
 240 static bool checkreturn default_extension_handler(pb_ostream_t *stream,
 241     const pb_extension_t *extension)
 242 {
 243     const pb_field_t *field = (const pb_field_t*)extension->type->arg;
 244     return encode_field(stream, field, extension->dest);
 245 }
 246
 247 /* Walk through all the registered extensions and give them a chance
 248  * to encode themselves. */
 249 static bool checkreturn encode_extension_field(pb_ostream_t *stream,
 250     const pb_field_t *field, const void *pData)
 251 {
 252     const pb_extension_t *extension = *(const pb_extension_t* const *)pData;
 253     UNUSED(field);
 254
 255     while (extension)
 256     {
 257         bool status;
 258         if (extension->type->encode)
 259             status = extension->type->encode(stream, extension);
 260         else
 261             status = default_extension_handler(stream, extension);
 262
 263         if (!status)
 264             return false;
 265
 266         extension = extension->next;
 267     }
 268
 269     return true;
 270 }
 271
 272 bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 273 {
 274     const pb_field_t *field = fields;
 275     const void *pData = src_struct;
 276     size_t prev_size = 0;
 277
 278     while (field->tag != 0)
 279     {
 280         pData = (const char*)pData + prev_size + field->data_offset;
 281         prev_size = field->data_size;
 282
 283         /* Special case for static arrays */
 284         if (PB_ATYPE(field->type) == PB_ATYPE_STATIC &&
 285             PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
 286         {
 287             prev_size *= field->array_size;
 288         }
 289
 290         if (PB_LTYPE(field->type) == PB_LTYPE_EXTENSION)
 291         {
 292             /* Special case for the extension field placeholder */
 293             if (!encode_extension_field(stream, field, pData))
 294                 return false;
 295         }
 296         else
 297         {
 298             /* Regular field */
 299             if (!encode_field(stream, field, pData))
 300                 return false;
 301         }
 302
 303         field++;
 304     }
 305
 306     return true;
 307 }
 308
 309 bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 310 {
 311     return pb_encode_submessage(stream, fields, src_struct);
 312 }
 313
 314 /* Helper functions */
 315 bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value)
 316 {
 317     uint8_t buffer[10];
 318     size_t i = 0;
 319
 320     if (value == 0)
 321         return pb_write(stream, (uint8_t*)&value, 1);
 322
 323     while (value)
 324     {
 325         buffer[i] = (uint8_t)((value & 0x7F) | 0x80);
 326         value >>= 7;
 327         i++;
 328     }
 329     buffer[i-1] &= 0x7F; /* Unset top bit on last byte */
 330
 331     return pb_write(stream, buffer, i);
 332 }
 333
 334 bool checkreturn pb_encode_svarint(pb_ostream_t *stream, int64_t value)
 335 {
 336     uint64_t zigzagged;
 337     if (value < 0)
 338         zigzagged = (uint64_t)(~(value << 1));
 339     else
 340         zigzagged = (uint64_t)(value << 1);
 341
 342     return pb_encode_varint(stream, zigzagged);
 343 }
 344
 345 bool checkreturn pb_encode_fixed32(pb_ostream_t *stream, const void *value)
 346 {
 347     #ifdef __BIG_ENDIAN__
 348     const uint8_t *bytes = value;
 349     uint8_t lebytes[4];
 350     lebytes[0] = bytes[3];
 351     lebytes[1] = bytes[2];
 352     lebytes[2] = bytes[1];
 353     lebytes[3] = bytes[0];
 354     return pb_write(stream, lebytes, 4);
 355     #else
 356     return pb_write(stream, (const uint8_t*)value, 4);
 357     #endif
 358 }
 359
 360 bool checkreturn pb_encode_fixed64(pb_ostream_t *stream, const void *value)
 361 {
 362     #ifdef __BIG_ENDIAN__
 363     const uint8_t *bytes = value;
 364     uint8_t lebytes[8];
 365     lebytes[0] = bytes[7];
 366     lebytes[1] = bytes[6];
 367     lebytes[2] = bytes[5];
 368     lebytes[3] = bytes[4];
 369     lebytes[4] = bytes[3];
 370     lebytes[5] = bytes[2];
 371     lebytes[6] = bytes[1];
 372     lebytes[7] = bytes[0];
 373     return pb_write(stream, lebytes, 8);
 374     #else
 375     return pb_write(stream, (const uint8_t*)value, 8);
 376     #endif
 377 }
 378
 379 bool checkreturn pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number)
 380 {
 381     uint64_t tag = wiretype | (field_number << 3);
 382     return pb_encode_varint(stream, tag);
 383 }
 384
 385 bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field)
 386 {
 387     pb_wire_type_t wiretype;
 388     switch (PB_LTYPE(field->type))
 389     {
 390         case PB_LTYPE_VARINT:
 391         case PB_LTYPE_SVARINT:
 392             wiretype = PB_WT_VARINT;
 393             break;
 394
 395         case PB_LTYPE_FIXED32:
 396             wiretype = PB_WT_32BIT;
 397             break;
 398
 399         case PB_LTYPE_FIXED64:
 400             wiretype = PB_WT_64BIT;
 401             break;
 402
 403         case PB_LTYPE_BYTES:
 404         case PB_LTYPE_STRING:
 405         case PB_LTYPE_SUBMESSAGE:
 406             wiretype = PB_WT_STRING;
 407             break;
 408
 409         default:
 410             PB_RETURN_ERROR(stream, "invalid field type");
 411     }
 412
 413     return pb_encode_tag(stream, wiretype, field->tag);
 414 }
 415
 416 bool checkreturn pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size)
 417 {
 418     if (!pb_encode_varint(stream, (uint64_t)size))
 419         return false;
 420
 421     return pb_write(stream, buffer, size);
 422 }
 423
 424 bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 425 {
 426     /* First calculate the message size using a non-writing substream. */
 427     pb_ostream_t substream = PB_OSTREAM_SIZING;
 428     size_t size;
 429     bool status;
 430
 431     if (!pb_encode(&substream, fields, src_struct))
 432         return false;
 433
 434     size = substream.bytes_written;
 435
 436     if (!pb_encode_varint(stream, (uint64_t)size))
 437         return false;
 438
 439     if (stream->callback == NULL)
 440         return pb_write(stream, NULL, size); /* Just sizing */
 441
 442     if (stream->bytes_written + size > stream->max_size)
 443         PB_RETURN_ERROR(stream, "stream full");
 444
 445     /* Use a substream to verify that a callback doesn't write more than
 446      * what it did the first time. */
 447     substream.callback = stream->callback;
 448     substream.state = stream->state;
 449     substream.max_size = size;
 450     substream.bytes_written = 0;
 451 #ifndef PB_NO_ERRMSG
 452     substream.errmsg = NULL;
 453 #endif
 454
 455     status = pb_encode(&substream, fields, src_struct);
 456
 457     stream->bytes_written += substream.bytes_written;
 458     stream->state = substream.state;
 459 #ifndef PB_NO_ERRMSG
 460     stream->errmsg = substream.errmsg;
 461 #endif
 462
 463     if (substream.bytes_written != size)
 464         PB_RETURN_ERROR(stream, "submsg size changed");
 465
 466     return status;
 467 }
 468
 469 /* Field encoders */
 470
 471 bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 472 {
 473     uint64_t value = 0;
 474
 475     switch (field->data_size)
 476     {
 477         case 1: value = *(const uint8_t*)src; break;
 478         case 2: value = *(const uint16_t*)src; break;
 479         case 4: value = *(const uint32_t*)src; break;
 480         case 8: value = *(const uint64_t*)src; break;
 481         default: PB_RETURN_ERROR(stream, "invalid data_size");
 482     }
 483
 484     return pb_encode_varint(stream, value);
 485 }
 486
 487 bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 488 {
 489     int64_t value = 0;
 490
 491     switch (field->data_size)
 492     {
 493         case 4: value = *(const int32_t*)src; break;
 494         case 8: value = *(const int64_t*)src; break;
 495         default: PB_RETURN_ERROR(stream, "invalid data_size");
 496     }
 497
 498     return pb_encode_svarint(stream, value);
 499 }
 500
 501 bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 502 {
 503     UNUSED(field);
 504     return pb_encode_fixed64(stream, src);
 505 }
 506
 507 bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 508 {
 509     UNUSED(field);
 510     return pb_encode_fixed32(stream, src);
 511 }
 512
 513 bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 514 {
 515     const pb_bytes_array_t *bytes = (const pb_bytes_array_t*)src;
 516     UNUSED(field);
 517     return pb_encode_string(stream, bytes->bytes, bytes->size);
 518 }
 519
 520 bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 521 {
 522     /* strnlen() is not always available, so just use a for-loop */
 523     size_t size = 0;
 524     const char *p = (const char*)src;
 525     while (size < field->data_size && *p != '\0')
 526     {
 527         size++;
 528         p++;
 529     }
 530
 531     return pb_encode_string(stream, (const uint8_t*)src, size);
 532 }
 533
 534 bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 535 {
 536     if (field->ptr == NULL)
 537         PB_RETURN_ERROR(stream, "invalid field descriptor");
 538
 539     return pb_encode_submessage(stream, (const pb_field_t*)field->ptr, src);
 540 }
 541