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 <string.h>
   9
  10 typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src);
  11
  12 /* --- Function pointers to field encoders ---
  13  * Order in the array must match pb_action_t LTYPE numbering.
  14  */
  15 static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
  16     &pb_enc_varint,
  17     &pb_enc_svarint,
  18     &pb_enc_fixed,
  19
  20     &pb_enc_bytes,
  21     &pb_enc_string,
  22     &pb_enc_submessage
  23 };
  24
  25 /* pb_ostream_t implementation */
  26
  27 static bool buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
  28 {
  29     uint8_t *dest = (uint8_t*)stream->state;
  30     memcpy(dest, buf, count);
  31     stream->state = dest + count;
  32     return true;
  33 }
  34
  35 pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize)
  36 {
  37     pb_ostream_t stream;
  38     stream.callback = &buf_write;
  39     stream.state = buf;
  40     stream.max_size = bufsize;
  41     stream.bytes_written = 0;
  42     return stream;
  43 }
  44
  45 bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
  46 {
  47     if (stream->callback != NULL)
  48     {
  49         if (stream->bytes_written + count > stream->max_size)
  50             return false;
  51
  52         if (!stream->callback(stream, buf, count))
  53             return false;
  54     }
  55
  56     stream->bytes_written += count;
  57     return true;
  58 }
  59
  60 /* Main encoding stuff */
  61
  62 static bool encode_array(pb_ostream_t *stream, const pb_field_t *field,
  63                          const void *pData, size_t count, pb_encoder_t func)
  64 {
  65     int i;
  66     const void *p;
  67     size_t size;
  68
  69     if (PB_LTYPE(field->type) < PB_LTYPE_LAST_PACKABLE)
  70     {
  71         if (!pb_encode_tag(stream, PB_WT_STRING, field->tag))
  72             return false;
  73
  74         /* Determine the total size of packed array. */
  75         if (PB_LTYPE(field->type) == PB_LTYPE_FIXED)
  76         {
  77             size = field->data_size * count;
  78         }
  79         else
  80         {
  81             pb_ostream_t sizestream = {0};
  82             p = pData;
  83             for (i = 0; i < count; i++)
  84             {
  85                 if (!func(&sizestream, field, p))
  86                     return false;
  87                 p = (const char*)p + field->data_size;
  88             }
  89             size = sizestream.bytes_written;
  90         }
  91
  92         pb_encode_varint(stream, size);
  93
  94         if (stream->callback == NULL)
  95             return pb_write(stream, NULL, size); /* Just sizing.. */
  96
  97         /* Write the data */
  98         p = pData;
  99         for (i = 0; i < count; i++)
 100         {
 101             if (!func(stream, field, p))
 102                 return false;
 103             p = (const char*)p + field->data_size;
 104         }
 105     }
 106     else
 107     {
 108         p = pData;
 109         for (i = 0; i < count; i++)
 110         {
 111             if (!pb_encode_tag_for_field(stream, field))
 112                 return false;
 113             if (!func(stream, field, p))
 114                 return false;
 115             p = (const char*)p + field->data_size;
 116         }
 117     }
 118
 119     return true;
 120 }
 121
 122 bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 123 {
 124     const pb_field_t *field = fields;
 125     const void *pData = src_struct;
 126     const void *pSize;
 127     size_t prev_size = 0;
 128
 129     while (field->tag != 0)
 130     {
 131         pData = (const char*)pData + prev_size + field->data_offset;
 132         pSize = (const char*)pData + field->size_offset;
 133
 134         prev_size = field->data_size;
 135         if (PB_HTYPE(field->type) == PB_HTYPE_ARRAY)
 136             prev_size *= field->array_size;
 137
 138         pb_encoder_t func = PB_ENCODERS[PB_LTYPE(field->type)];
 139
 140         switch (PB_HTYPE(field->type))
 141         {
 142             case PB_HTYPE_REQUIRED:
 143                 if (!pb_encode_tag_for_field(stream, field))
 144                     return false;
 145                 if (!func(stream, field, pData))
 146                     return false;
 147                 break;
 148
 149             case PB_HTYPE_OPTIONAL:
 150                 if (*(bool*)pSize)
 151                 {
 152                     if (!pb_encode_tag_for_field(stream, field))
 153                         return false;
 154
 155                     if (!func(stream, field, pData))
 156                         return false;
 157                 }
 158                 break;
 159
 160             case PB_HTYPE_ARRAY:
 161                 if (!encode_array(stream, field, pData, *(size_t*)pSize, func))
 162                     return false;
 163                 break;
 164
 165             case PB_HTYPE_CALLBACK:
 166             {
 167                 pb_callback_t *callback = (pb_callback_t*)pData;
 168                 if (callback->funcs.encode != NULL)
 169                 {
 170                     if (!callback->funcs.encode(stream, field, callback->arg))
 171                         return false;
 172                 }
 173                 break;
 174             }
 175         }
 176
 177         field++;
 178     }
 179
 180     return true;
 181 }
 182
 183 /* Helper functions */
 184 bool pb_encode_varint(pb_ostream_t *stream, uint64_t value)
 185 {
 186     uint8_t buffer[10];
 187     int i = 0;
 188
 189     if (value == 0)
 190         return pb_write(stream, (uint8_t*)&value, 1);
 191
 192     while (value)
 193     {
 194         buffer[i] = (value & 0x7F) | 0x80;
 195         value >>= 7;
 196         i++;
 197     }
 198     buffer[i-1] &= 0x7F; /* Unset top bit on last byte */
 199
 200     return pb_write(stream, buffer, i);
 201 }
 202
 203 bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, int field_number)
 204 {
 205     int tag = wiretype | (field_number << 3);
 206     return pb_encode_varint(stream, tag);
 207 }
 208
 209 bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field)
 210 {
 211     pb_wire_type_t wiretype;
 212     switch (PB_LTYPE(field->type))
 213     {
 214         case PB_LTYPE_VARINT:
 215         case PB_LTYPE_SVARINT:
 216             wiretype = PB_WT_VARINT;
 217             break;
 218
 219         case PB_LTYPE_FIXED:
 220             if (field->data_size == 4)
 221                 wiretype = PB_WT_32BIT;
 222             else if (field->data_size == 8)
 223                 wiretype = PB_WT_64BIT;
 224             else
 225                 return false;
 226             break;
 227
 228         case PB_LTYPE_BYTES:
 229         case PB_LTYPE_STRING:
 230         case PB_LTYPE_SUBMESSAGE:
 231             wiretype = PB_WT_STRING;
 232             break;
 233
 234         default:
 235             return false;
 236     }
 237
 238     return pb_encode_tag(stream, wiretype, field->tag);
 239 }
 240
 241 bool pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size)
 242 {
 243     if (!pb_encode_varint(stream, size))
 244         return false;
 245
 246     return pb_write(stream, buffer, size);
 247 }
 248
 249 /* Field encoders */
 250
 251 /* Copy srcsize bytes from src so that values are casted properly.
 252  * On little endian machine, copy to start of dest
 253  * On big endian machine, copy to end of dest
 254  * destsize must always be larger than srcsize
 255  *
 256  * Note: This is the reverse of the endian_copy in pb_decode.c.
 257  */
 258 static void endian_copy(void *dest, const void *src, size_t destsize, size_t srcsize)
 259 {
 260 #ifdef __BIG_ENDIAN__
 261     memcpy((char*)dest + (destsize - srcsize), src, srcsize);
 262 #else
 263     memcpy(dest, src, srcsize);
 264 #endif
 265 }
 266
 267 bool pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 268 {
 269     uint64_t value = 0;
 270     endian_copy(&value, src, sizeof(value), field->data_size);
 271     return pb_encode_varint(stream, value);
 272 }
 273
 274 bool pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 275 {
 276     uint64_t value = 0;
 277     uint64_t zigzagged;
 278     uint64_t signbitmask, xormask;
 279     endian_copy(&value, src, sizeof(value), field->data_size);
 280
 281     signbitmask = (uint64_t)0x80 << (field->data_size * 8 - 8);
 282     xormask = ((uint64_t)-1) >> (64 - field->data_size * 8);
 283     if (value & signbitmask)
 284         zigzagged = ((value ^ xormask) << 1) | 1;
 285     else
 286         zigzagged = value << 1;
 287
 288     return pb_encode_varint(stream, zigzagged);
 289 }
 290
 291 bool pb_enc_fixed(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 292 {
 293     #ifdef __BIG_ENDIAN__
 294     uint8_t bytes[8] = {0};
 295     endian_copy(bytes, src, sizeof(bytes), field->data_size);
 296     uint8_t lebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4],
 297                           bytes[3], bytes[2], bytes[1], bytes[0]};
 298     return pb_write(stream, lebytes, field->data_size);
 299     #else
 300     return pb_write(stream, (uint8_t*)src, field->data_size);
 301     #endif
 302 }
 303
 304 bool pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 305 {
 306     pb_bytes_array_t *bytes = (pb_bytes_array_t*)src;
 307     return pb_encode_string(stream, bytes->bytes, bytes->size);
 308 }
 309
 310 bool pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 311 {
 312     return pb_encode_string(stream, (uint8_t*)src, strlen((char*)src));
 313 }
 314
 315 bool pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 316 {
 317     pb_ostream_t substream = {0};
 318     size_t size;
 319     bool status;
 320
 321     if (field->ptr == NULL)
 322         return false;
 323
 324     if (!pb_encode(&substream, (pb_field_t*)field->ptr, src))
 325         return false;
 326
 327     size = substream.bytes_written;
 328
 329     if (!pb_encode_varint(stream, size))
 330         return false;
 331
 332     if (stream->callback == NULL)
 333         return pb_write(stream, NULL, size); /* Just sizing */
 334
 335     if (stream->bytes_written + size > stream->max_size)
 336         return false;
 337
 338     /* Use a substream to verify that a callback doesn't write more than
 339      * what it did the first time. */
 340     substream.callback = stream->callback;
 341     substream.state = stream->state;
 342     substream.max_size = size;
 343     substream.bytes_written = 0;
 344
 345     status = pb_encode(&substream, (pb_field_t*)field->ptr, src);
 346
 347     stream->bytes_written += substream.bytes_written;
 348
 349     if (substream.bytes_written != size)
 350         return false;
 351
 352     return status;
 353 }
 354