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