iOS/Pods/nanopb/pb_encode.c

   1 /* pb_encode.c -- encode a protobuf using minimal resources
   2  *
   3  * 2011 Petteri Aimonen <jpa@kapsi.fi>
   4  */
   5
   6 #include "pb.h"
   7 #include "pb_encode.h"
   8 #include "pb_common.h"
   9
  10 /* Use the GCC warn_unused_result attribute to check that all return values
  11  * are propagated correctly. On other compilers and gcc before 3.4.0 just
  12  * ignore the annotation.
  13  */
  14 #if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
  15     #define checkreturn
  16 #else
  17     #define checkreturn __attribute__((warn_unused_result))
  18 #endif
  19
  20 /**************************************
  21  * Declarations internal to this file *
  22  **************************************/
  23 typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src) checkreturn;
  24
  25 static bool checkreturn buf_write(pb_ostream_t *stream, const pb_byte_t *buf, size_t count);
  26 static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field, const void *pData, size_t count, pb_encoder_t func);
  27 static bool checkreturn encode_field(pb_ostream_t *stream, const pb_field_t *field, const void *pData);
  28 static bool checkreturn default_extension_encoder(pb_ostream_t *stream, const pb_extension_t *extension);
  29 static bool checkreturn encode_extension_field(pb_ostream_t *stream, const pb_field_t *field, const void *pData);
  30 static void *pb_const_cast(const void *p);
  31 static bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  32 static bool checkreturn pb_enc_uvarint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  33 static bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  34 static bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  35 static bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  36 static bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  37 static bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  38 static bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  39 static bool checkreturn pb_enc_fixed_length_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  40
  41 /* --- Function pointers to field encoders ---
  42  * Order in the array must match pb_action_t LTYPE numbering.
  43  */
  44 static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
  45     &pb_enc_varint,
  46     &pb_enc_uvarint,
  47     &pb_enc_svarint,
  48     &pb_enc_fixed32,
  49     &pb_enc_fixed64,
  50
  51     &pb_enc_bytes,
  52     &pb_enc_string,
  53     &pb_enc_submessage,
  54     NULL, /* extensions */
  55     &pb_enc_fixed_length_bytes
  56 };
  57
  58 /*******************************
  59  * pb_ostream_t implementation *
  60  *******************************/
  61
  62 static bool checkreturn buf_write(pb_ostream_t *stream, const pb_byte_t *buf, size_t count)
  63 {
  64     size_t i;
  65     pb_byte_t *dest = (pb_byte_t*)stream->state;
  66     stream->state = dest + count;
  67
  68     for (i = 0; i < count; i++)
  69         dest[i] = buf[i];
  70
  71     return true;
  72 }
  73
  74 pb_ostream_t pb_ostream_from_buffer(pb_byte_t *buf, size_t bufsize)
  75 {
  76     pb_ostream_t stream;
  77 #ifdef PB_BUFFER_ONLY
  78     stream.callback = (void*)1; /* Just a marker value */
  79 #else
  80     stream.callback = &buf_write;
  81 #endif
  82     stream.state = buf;
  83     stream.max_size = bufsize;
  84     stream.bytes_written = 0;
  85 #ifndef PB_NO_ERRMSG
  86     stream.errmsg = NULL;
  87 #endif
  88     return stream;
  89 }
  90
  91 bool checkreturn pb_write(pb_ostream_t *stream, const pb_byte_t *buf, size_t count)
  92 {
  93     if (stream->callback != NULL)
  94     {
  95         if (stream->bytes_written + count > stream->max_size)
  96             PB_RETURN_ERROR(stream, "stream full");
  97
  98 #ifdef PB_BUFFER_ONLY
  99         if (!buf_write(stream, buf, count))
 100             PB_RETURN_ERROR(stream, "io error");
 101 #else
 102         if (!stream->callback(stream, buf, count))
 103             PB_RETURN_ERROR(stream, "io error");
 104 #endif
 105     }
 106
 107     stream->bytes_written += count;
 108     return true;
 109 }
 110
 111 /*************************
 112  * Encode a single field *
 113  *************************/
 114
 115 /* Encode a static array. Handles the size calculations and possible packing. */
 116 static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field,
 117                          const void *pData, size_t count, pb_encoder_t func)
 118 {
 119     size_t i;
 120     const void *p;
 121     size_t size;
 122
 123     if (count == 0)
 124         return true;
 125
 126     if (PB_ATYPE(field->type) != PB_ATYPE_POINTER && count > field->array_size)
 127         PB_RETURN_ERROR(stream, "array max size exceeded");
 128
 129     /* We always pack arrays if the datatype allows it. */
 130     if (PB_LTYPE(field->type) <= PB_LTYPE_LAST_PACKABLE)
 131     {
 132         if (!pb_encode_tag(stream, PB_WT_STRING, field->tag))
 133             return false;
 134
 135         /* Determine the total size of packed array. */
 136         if (PB_LTYPE(field->type) == PB_LTYPE_FIXED32)
 137         {
 138             size = 4 * count;
 139         }
 140         else if (PB_LTYPE(field->type) == PB_LTYPE_FIXED64)
 141         {
 142             size = 8 * count;
 143         }
 144         else
 145         {
 146             pb_ostream_t sizestream = PB_OSTREAM_SIZING;
 147             p = pData;
 148             for (i = 0; i < count; i++)
 149             {
 150                 if (!func(&sizestream, field, p))
 151                     return false;
 152                 p = (const char*)p + field->data_size;
 153             }
 154             size = sizestream.bytes_written;
 155         }
 156
 157         if (!pb_encode_varint(stream, (uint64_t)size))
 158             return false;
 159
 160         if (stream->callback == NULL)
 161             return pb_write(stream, NULL, size); /* Just sizing.. */
 162
 163         /* Write the data */
 164         p = pData;
 165         for (i = 0; i < count; i++)
 166         {
 167             if (!func(stream, field, p))
 168                 return false;
 169             p = (const char*)p + field->data_size;
 170         }
 171     }
 172     else
 173     {
 174         p = pData;
 175         for (i = 0; i < count; i++)
 176         {
 177             if (!pb_encode_tag_for_field(stream, field))
 178                 return false;
 179
 180             /* Normally the data is stored directly in the array entries, but
 181              * for pointer-type string and bytes fields, the array entries are
 182              * actually pointers themselves also. So we have to dereference once
 183              * more to get to the actual data. */
 184             if (PB_ATYPE(field->type) == PB_ATYPE_POINTER &&
 185                 (PB_LTYPE(field->type) == PB_LTYPE_STRING ||
 186                  PB_LTYPE(field->type) == PB_LTYPE_BYTES))
 187             {
 188                 if (!func(stream, field, *(const void* const*)p))
 189                     return false;
 190             }
 191             else
 192             {
 193                 if (!func(stream, field, p))
 194                     return false;
 195             }
 196             p = (const char*)p + field->data_size;
 197         }
 198     }
 199
 200     return true;
 201 }
 202
 203 /* In proto3, all fields are optional and are only encoded if their value is "non-zero".
 204  * This function implements the check for the zero value. */
 205 static bool pb_check_proto3_default_value(const pb_field_t *field, const void *pData)
 206 {
 207     if (PB_ATYPE(field->type) == PB_ATYPE_STATIC)
 208     {
 209         if (PB_LTYPE(field->type) == PB_LTYPE_BYTES)
 210         {
 211             const pb_bytes_array_t *bytes = (const pb_bytes_array_t*)pData;
 212             return bytes->size == 0;
 213         }
 214         else if (PB_LTYPE(field->type) == PB_LTYPE_STRING)
 215         {
 216             return *(const char*)pData == '\0';
 217         }
 218         else if (PB_LTYPE(field->type) == PB_LTYPE_FIXED_LENGTH_BYTES)
 219         {
 220             /* Fixed length bytes is only empty if its length is fixed
 221              * as 0. Which would be pretty strange, but we can check
 222              * it anyway. */
 223             return field->data_size == 0;
 224         }
 225         else if (PB_LTYPE(field->type) == PB_LTYPE_SUBMESSAGE)
 226         {
 227             /* Check all fields in the submessage to find if any of them
 228              * are non-zero. The comparison cannot be done byte-per-byte
 229              * because the C struct may contain padding bytes that must
 230              * be skipped.
 231              */
 232             pb_field_iter_t iter;
 233             if (pb_field_iter_begin(&iter, (const pb_field_t*)field->ptr, pb_const_cast(pData)))
 234             {
 235                 do
 236                 {
 237                     if (!pb_check_proto3_default_value(iter.pos, iter.pData))
 238                     {
 239                         return false;
 240                     }
 241                 } while (pb_field_iter_next(&iter));
 242             }
 243             return true;
 244         }
 245     }
 246
 247         {
 248             /* Catch-all branch that does byte-per-byte comparison for zero value.
 249              *
 250              * This is for all pointer fields, and for static PB_LTYPE_VARINT,
 251              * UVARINT, SVARINT, FIXED32, FIXED64, EXTENSION fields, and also
 252              * callback fields. These all have integer or pointer value which
 253              * can be compared with 0.
 254              */
 255             pb_size_t i;
 256             const char *p = (const char*)pData;
 257             for (i = 0; i < field->data_size; i++)
 258             {
 259                 if (p[i] != 0)
 260                 {
 261                     return false;
 262                 }
 263             }
 264
 265             return true;
 266         }
 267 }
 268
 269 /* Encode a field with static or pointer allocation, i.e. one whose data
 270  * is available to the encoder directly. */
 271 static bool checkreturn encode_basic_field(pb_ostream_t *stream,
 272     const pb_field_t *field, const void *pData)
 273 {
 274     pb_encoder_t func;
 275     bool implicit_has;
 276     const void *pSize = &implicit_has;
 277
 278     func = PB_ENCODERS[PB_LTYPE(field->type)];
 279
 280     if (field->size_offset)
 281     {
 282         /* Static optional, repeated or oneof field */
 283         pSize = (const char*)pData + field->size_offset;
 284     }
 285     else if (PB_HTYPE(field->type) == PB_HTYPE_OPTIONAL)
 286     {
 287         /* Proto3 style field, optional but without explicit has_ field. */
 288         implicit_has = !pb_check_proto3_default_value(field, pData);
 289     }
 290     else
 291     {
 292         /* Required field, always present */
 293         implicit_has = true;
 294     }
 295
 296     if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
 297     {
 298         /* pData is a pointer to the field, which contains pointer to
 299          * the data. If the 2nd pointer is NULL, it is interpreted as if
 300          * the has_field was false.
 301          */
 302         pData = *(const void* const*)pData;
 303         implicit_has = (pData != NULL);
 304     }
 305
 306     switch (PB_HTYPE(field->type))
 307     {
 308         case PB_HTYPE_REQUIRED:
 309             if (!pData)
 310                 PB_RETURN_ERROR(stream, "missing required field");
 311             if (!pb_encode_tag_for_field(stream, field))
 312                 return false;
 313             if (!func(stream, field, pData))
 314                 return false;
 315             break;
 316
 317         case PB_HTYPE_OPTIONAL:
 318             if (*(const bool*)pSize)
 319             {
 320                 if (!pb_encode_tag_for_field(stream, field))
 321                     return false;
 322
 323                 if (!func(stream, field, pData))
 324                     return false;
 325             }
 326             break;
 327
 328         case PB_HTYPE_REPEATED:
 329             if (!encode_array(stream, field, pData, *(const pb_size_t*)pSize, func))
 330                 return false;
 331             break;
 332
 333         case PB_HTYPE_ONEOF:
 334             if (*(const pb_size_t*)pSize == field->tag)
 335             {
 336                 if (!pb_encode_tag_for_field(stream, field))
 337                     return false;
 338
 339                 if (!func(stream, field, pData))
 340                     return false;
 341             }
 342             break;
 343
 344         default:
 345             PB_RETURN_ERROR(stream, "invalid field type");
 346     }
 347
 348     return true;
 349 }
 350
 351 /* Encode a field with callback semantics. This means that a user function is
 352  * called to provide and encode the actual data. */
 353 static bool checkreturn encode_callback_field(pb_ostream_t *stream,
 354     const pb_field_t *field, const void *pData)
 355 {
 356     const pb_callback_t *callback = (const pb_callback_t*)pData;
 357
 358 #ifdef PB_OLD_CALLBACK_STYLE
 359     const void *arg = callback->arg;
 360 #else
 361     void * const *arg = &(callback->arg);
 362 #endif
 363
 364     if (callback->funcs.encode != NULL)
 365     {
 366         if (!callback->funcs.encode(stream, field, arg))
 367             PB_RETURN_ERROR(stream, "callback error");
 368     }
 369     return true;
 370 }
 371
 372 /* Encode a single field of any callback or static type. */
 373 static bool checkreturn encode_field(pb_ostream_t *stream,
 374     const pb_field_t *field, const void *pData)
 375 {
 376     switch (PB_ATYPE(field->type))
 377     {
 378         case PB_ATYPE_STATIC:
 379         case PB_ATYPE_POINTER:
 380             return encode_basic_field(stream, field, pData);
 381
 382         case PB_ATYPE_CALLBACK:
 383             return encode_callback_field(stream, field, pData);
 384
 385         default:
 386             PB_RETURN_ERROR(stream, "invalid field type");
 387     }
 388 }
 389
 390 /* Default handler for extension fields. Expects to have a pb_field_t
 391  * pointer in the extension->type->arg field. */
 392 static bool checkreturn default_extension_encoder(pb_ostream_t *stream,
 393     const pb_extension_t *extension)
 394 {
 395     const pb_field_t *field = (const pb_field_t*)extension->type->arg;
 396
 397     if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
 398     {
 399         /* For pointer extensions, the pointer is stored directly
 400          * in the extension structure. This avoids having an extra
 401          * indirection. */
 402         return encode_field(stream, field, &extension->dest);
 403     }
 404     else
 405     {
 406         return encode_field(stream, field, extension->dest);
 407     }
 408 }
 409
 410 /* Walk through all the registered extensions and give them a chance
 411  * to encode themselves. */
 412 static bool checkreturn encode_extension_field(pb_ostream_t *stream,
 413     const pb_field_t *field, const void *pData)
 414 {
 415     const pb_extension_t *extension = *(const pb_extension_t* const *)pData;
 416     PB_UNUSED(field);
 417
 418     while (extension)
 419     {
 420         bool status;
 421         if (extension->type->encode)
 422             status = extension->type->encode(stream, extension);
 423         else
 424             status = default_extension_encoder(stream, extension);
 425
 426         if (!status)
 427             return false;
 428
 429         extension = extension->next;
 430     }
 431
 432     return true;
 433 }
 434
 435 /*********************
 436  * Encode all fields *
 437  *********************/
 438
 439 static void *pb_const_cast(const void *p)
 440 {
 441     /* Note: this casts away const, in order to use the common field iterator
 442      * logic for both encoding and decoding. */
 443     union {
 444         void *p1;
 445         const void *p2;
 446     } t;
 447     t.p2 = p;
 448     return t.p1;
 449 }
 450
 451 bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 452 {
 453     pb_field_iter_t iter;
 454     if (!pb_field_iter_begin(&iter, fields, pb_const_cast(src_struct)))
 455         return true; /* Empty message type */
 456
 457     do {
 458         if (PB_LTYPE(iter.pos->type) == PB_LTYPE_EXTENSION)
 459         {
 460             /* Special case for the extension field placeholder */
 461             if (!encode_extension_field(stream, iter.pos, iter.pData))
 462                 return false;
 463         }
 464         else
 465         {
 466             /* Regular field */
 467             if (!encode_field(stream, iter.pos, iter.pData))
 468                 return false;
 469         }
 470     } while (pb_field_iter_next(&iter));
 471
 472     return true;
 473 }
 474
 475 bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 476 {
 477     return pb_encode_submessage(stream, fields, src_struct);
 478 }
 479
 480 bool pb_get_encoded_size(size_t *size, const pb_field_t fields[], const void *src_struct)
 481 {
 482     pb_ostream_t stream = PB_OSTREAM_SIZING;
 483
 484     if (!pb_encode(&stream, fields, src_struct))
 485         return false;
 486
 487     *size = stream.bytes_written;
 488     return true;
 489 }
 490
 491 /********************
 492  * Helper functions *
 493  ********************/
 494 bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value)
 495 {
 496     pb_byte_t buffer[10];
 497     size_t i = 0;
 498
 499     if (value <= 0x7F)
 500     {
 501         pb_byte_t v = (pb_byte_t)value;
 502         return pb_write(stream, &v, 1);
 503     }
 504
 505     while (value)
 506     {
 507         buffer[i] = (pb_byte_t)((value & 0x7F) | 0x80);
 508         value >>= 7;
 509         i++;
 510     }
 511     buffer[i-1] &= 0x7F; /* Unset top bit on last byte */
 512
 513     return pb_write(stream, buffer, i);
 514 }
 515
 516 bool checkreturn pb_encode_svarint(pb_ostream_t *stream, int64_t value)
 517 {
 518     uint64_t zigzagged;
 519     if (value < 0)
 520         zigzagged = ~((uint64_t)value << 1);
 521     else
 522         zigzagged = (uint64_t)value << 1;
 523
 524     return pb_encode_varint(stream, zigzagged);
 525 }
 526
 527 bool checkreturn pb_encode_fixed32(pb_ostream_t *stream, const void *value)
 528 {
 529     uint32_t val = *(const uint32_t*)value;
 530     pb_byte_t bytes[4];
 531     bytes[0] = (pb_byte_t)(val & 0xFF);
 532     bytes[1] = (pb_byte_t)((val >> 8) & 0xFF);
 533     bytes[2] = (pb_byte_t)((val >> 16) & 0xFF);
 534     bytes[3] = (pb_byte_t)((val >> 24) & 0xFF);
 535     return pb_write(stream, bytes, 4);
 536 }
 537
 538 bool checkreturn pb_encode_fixed64(pb_ostream_t *stream, const void *value)
 539 {
 540     uint64_t val = *(const uint64_t*)value;
 541     pb_byte_t bytes[8];
 542     bytes[0] = (pb_byte_t)(val & 0xFF);
 543     bytes[1] = (pb_byte_t)((val >> 8) & 0xFF);
 544     bytes[2] = (pb_byte_t)((val >> 16) & 0xFF);
 545     bytes[3] = (pb_byte_t)((val >> 24) & 0xFF);
 546     bytes[4] = (pb_byte_t)((val >> 32) & 0xFF);
 547     bytes[5] = (pb_byte_t)((val >> 40) & 0xFF);
 548     bytes[6] = (pb_byte_t)((val >> 48) & 0xFF);
 549     bytes[7] = (pb_byte_t)((val >> 56) & 0xFF);
 550     return pb_write(stream, bytes, 8);
 551 }
 552
 553 bool checkreturn pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number)
 554 {
 555     uint64_t tag = ((uint64_t)field_number << 3) | wiretype;
 556     return pb_encode_varint(stream, tag);
 557 }
 558
 559 bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field)
 560 {
 561     pb_wire_type_t wiretype;
 562     switch (PB_LTYPE(field->type))
 563     {
 564         case PB_LTYPE_VARINT:
 565         case PB_LTYPE_UVARINT:
 566         case PB_LTYPE_SVARINT:
 567             wiretype = PB_WT_VARINT;
 568             break;
 569
 570         case PB_LTYPE_FIXED32:
 571             wiretype = PB_WT_32BIT;
 572             break;
 573
 574         case PB_LTYPE_FIXED64:
 575             wiretype = PB_WT_64BIT;
 576             break;
 577
 578         case PB_LTYPE_BYTES:
 579         case PB_LTYPE_STRING:
 580         case PB_LTYPE_SUBMESSAGE:
 581         case PB_LTYPE_FIXED_LENGTH_BYTES:
 582             wiretype = PB_WT_STRING;
 583             break;
 584
 585         default:
 586             PB_RETURN_ERROR(stream, "invalid field type");
 587     }
 588
 589     return pb_encode_tag(stream, wiretype, field->tag);
 590 }
 591
 592 bool checkreturn pb_encode_string(pb_ostream_t *stream, const pb_byte_t *buffer, size_t size)
 593 {
 594     if (!pb_encode_varint(stream, (uint64_t)size))
 595         return false;
 596
 597     return pb_write(stream, buffer, size);
 598 }
 599
 600 bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 601 {
 602     /* First calculate the message size using a non-writing substream. */
 603     pb_ostream_t substream = PB_OSTREAM_SIZING;
 604     size_t size;
 605     bool status;
 606
 607     if (!pb_encode(&substream, fields, src_struct))
 608     {
 609 #ifndef PB_NO_ERRMSG
 610         stream->errmsg = substream.errmsg;
 611 #endif
 612         return false;
 613     }
 614
 615     size = substream.bytes_written;
 616
 617     if (!pb_encode_varint(stream, (uint64_t)size))
 618         return false;
 619
 620     if (stream->callback == NULL)
 621         return pb_write(stream, NULL, size); /* Just sizing */
 622
 623     if (stream->bytes_written + size > stream->max_size)
 624         PB_RETURN_ERROR(stream, "stream full");
 625
 626     /* Use a substream to verify that a callback doesn't write more than
 627      * what it did the first time. */
 628     substream.callback = stream->callback;
 629     substream.state = stream->state;
 630     substream.max_size = size;
 631     substream.bytes_written = 0;
 632 #ifndef PB_NO_ERRMSG
 633     substream.errmsg = NULL;
 634 #endif
 635
 636     status = pb_encode(&substream, fields, src_struct);
 637
 638     stream->bytes_written += substream.bytes_written;
 639     stream->state = substream.state;
 640 #ifndef PB_NO_ERRMSG
 641     stream->errmsg = substream.errmsg;
 642 #endif
 643
 644     if (substream.bytes_written != size)
 645         PB_RETURN_ERROR(stream, "submsg size changed");
 646
 647     return status;
 648 }
 649
 650 /* Field encoders */
 651
 652 static bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 653 {
 654     int64_t value = 0;
 655
 656     if (field->data_size == sizeof(int_least8_t))
 657         value = *(const int_least8_t*)src;
 658     else if (field->data_size == sizeof(int_least16_t))
 659         value = *(const int_least16_t*)src;
 660     else if (field->data_size == sizeof(int32_t))
 661         value = *(const int32_t*)src;
 662     else if (field->data_size == sizeof(int64_t))
 663         value = *(const int64_t*)src;
 664     else
 665         PB_RETURN_ERROR(stream, "invalid data_size");
 666
 667     return pb_encode_varint(stream, (uint64_t)value);
 668 }
 669
 670 static bool checkreturn pb_enc_uvarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 671 {
 672     uint64_t value = 0;
 673
 674     if (field->data_size == sizeof(uint_least8_t))
 675         value = *(const uint_least8_t*)src;
 676     else if (field->data_size == sizeof(uint_least16_t))
 677         value = *(const uint_least16_t*)src;
 678     else if (field->data_size == sizeof(uint32_t))
 679         value = *(const uint32_t*)src;
 680     else if (field->data_size == sizeof(uint64_t))
 681         value = *(const uint64_t*)src;
 682     else
 683         PB_RETURN_ERROR(stream, "invalid data_size");
 684
 685     return pb_encode_varint(stream, value);
 686 }
 687
 688 static bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 689 {
 690     int64_t value = 0;
 691
 692     if (field->data_size == sizeof(int_least8_t))
 693         value = *(const int_least8_t*)src;
 694     else if (field->data_size == sizeof(int_least16_t))
 695         value = *(const int_least16_t*)src;
 696     else if (field->data_size == sizeof(int32_t))
 697         value = *(const int32_t*)src;
 698     else if (field->data_size == sizeof(int64_t))
 699         value = *(const int64_t*)src;
 700     else
 701         PB_RETURN_ERROR(stream, "invalid data_size");
 702
 703     return pb_encode_svarint(stream, value);
 704 }
 705
 706 static bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 707 {
 708     PB_UNUSED(field);
 709     return pb_encode_fixed64(stream, src);
 710 }
 711
 712 static bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 713 {
 714     PB_UNUSED(field);
 715     return pb_encode_fixed32(stream, src);
 716 }
 717
 718 static bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 719 {
 720     const pb_bytes_array_t *bytes = NULL;
 721
 722     bytes = (const pb_bytes_array_t*)src;
 723
 724     if (src == NULL)
 725     {
 726         /* Treat null pointer as an empty bytes field */
 727         return pb_encode_string(stream, NULL, 0);
 728     }
 729
 730     if (PB_ATYPE(field->type) == PB_ATYPE_STATIC &&
 731         PB_BYTES_ARRAY_T_ALLOCSIZE(bytes->size) > field->data_size)
 732     {
 733         PB_RETURN_ERROR(stream, "bytes size exceeded");
 734     }
 735
 736     return pb_encode_string(stream, bytes->bytes, bytes->size);
 737 }
 738
 739 static bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 740 {
 741     size_t size = 0;
 742     size_t max_size = field->data_size;
 743     const char *p = (const char*)src;
 744
 745     if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
 746         max_size = (size_t)-1;
 747
 748     if (src == NULL)
 749     {
 750         size = 0; /* Treat null pointer as an empty string */
 751     }
 752     else
 753     {
 754         /* strnlen() is not always available, so just use a loop */
 755         while (size < max_size && *p != '\0')
 756         {
 757             size++;
 758             p++;
 759         }
 760     }
 761
 762     return pb_encode_string(stream, (const pb_byte_t*)src, size);
 763 }
 764
 765 static bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 766 {
 767     if (field->ptr == NULL)
 768         PB_RETURN_ERROR(stream, "invalid field descriptor");
 769
 770     return pb_encode_submessage(stream, (const pb_field_t*)field->ptr, src);
 771 }
 772
 773 static bool checkreturn pb_enc_fixed_length_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 774 {
 775     return pb_encode_string(stream, (const pb_byte_t*)src, field->data_size);
 776 }
 777