X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=pb_encode.c;h=a887382865ab5cbf61a857fe22c36aa504b111a9;hb=07d44cf632bb3d1a4fb87c44e422ab9af42f2717;hp=2e740347f0b155556fc1fe25b24e698081f071c9;hpb=7f53c3f7484679c1e38607f59542d43be1387650;p=apps%2Fagl-service-can-low-level.git diff --git a/pb_encode.c b/pb_encode.c index 2e740347..a8873828 100644 --- a/pb_encode.c +++ b/pb_encode.c @@ -3,11 +3,20 @@ * 2011 Petteri Aimonen */ +#define NANOPB_INTERNALS #include "pb.h" #include "pb_encode.h" #include -typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src); +/* The warn_unused_result attribute appeared first in gcc-3.4.0 */ +#if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4) + #define checkreturn +#else + /* Verify that we remember to check all return values for proper error propagation */ + #define checkreturn __attribute__((warn_unused_result)) +#endif + +typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src) checkreturn; /* --- Function pointers to field encoders --- * Order in the array must match pb_action_t LTYPE numbering. @@ -15,7 +24,8 @@ typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, cons static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = { &pb_enc_varint, &pb_enc_svarint, - &pb_enc_fixed, + &pb_enc_fixed32, + &pb_enc_fixed64, &pb_enc_bytes, &pb_enc_string, @@ -24,7 +34,7 @@ static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = { /* pb_ostream_t implementation */ -static bool buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count) +static bool checkreturn buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count) { uint8_t *dest = (uint8_t*)stream->state; memcpy(dest, buf, count); @@ -42,7 +52,7 @@ pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize) return stream; } -bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count) +bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count) { if (stream->callback != NULL) { @@ -59,26 +69,37 @@ bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count) /* Main encoding stuff */ -static bool encode_array(pb_ostream_t *stream, const pb_field_t *field, +/* Callbacks don't need this function because they usually know the data type + * without examining the field structure. + * Therefore it is static for now. + */ +static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field, const void *pData, size_t count, pb_encoder_t func) { - int i; + size_t i; const void *p; size_t size; - if (PB_LTYPE(field->type) < PB_LTYPE_LAST_PACKABLE) + if (count == 0) + return true; + + if (PB_LTYPE(field->type) <= PB_LTYPE_LAST_PACKABLE) { if (!pb_encode_tag(stream, PB_WT_STRING, field->tag)) return false; /* Determine the total size of packed array. */ - if (PB_LTYPE(field->type) == PB_LTYPE_FIXED) + if (PB_LTYPE(field->type) == PB_LTYPE_FIXED32) + { + size = 4 * count; + } + else if (PB_LTYPE(field->type) == PB_LTYPE_FIXED64) { - size = field->data_size * count; + size = 8 * count; } else { - pb_ostream_t sizestream = {0}; + pb_ostream_t sizestream = {0,0,0,0}; p = pData; for (i = 0; i < count; i++) { @@ -89,7 +110,8 @@ static bool encode_array(pb_ostream_t *stream, const pb_field_t *field, size = sizestream.bytes_written; } - pb_encode_varint(stream, size); + if (!pb_encode_varint(stream, (uint64_t)size)) + return false; if (stream->callback == NULL) return pb_write(stream, NULL, size); /* Just sizing.. */ @@ -119,7 +141,7 @@ static bool encode_array(pb_ostream_t *stream, const pb_field_t *field, return true; } -bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct) +bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct) { const pb_field_t *field = fields; const void *pData = src_struct; @@ -128,15 +150,14 @@ bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_ while (field->tag != 0) { + pb_encoder_t func = PB_ENCODERS[PB_LTYPE(field->type)]; pData = (const char*)pData + prev_size + field->data_offset; pSize = (const char*)pData + field->size_offset; prev_size = field->data_size; if (PB_HTYPE(field->type) == PB_HTYPE_ARRAY) prev_size *= field->array_size; - - pb_encoder_t func = PB_ENCODERS[PB_LTYPE(field->type)]; - + switch (PB_HTYPE(field->type)) { case PB_HTYPE_REQUIRED: @@ -147,7 +168,7 @@ bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_ break; case PB_HTYPE_OPTIONAL: - if (*(bool*)pSize) + if (*(const bool*)pSize) { if (!pb_encode_tag_for_field(stream, field)) return false; @@ -158,13 +179,13 @@ bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_ break; case PB_HTYPE_ARRAY: - if (!encode_array(stream, field, pData, *(size_t*)pSize, func)) + if (!encode_array(stream, field, pData, *(const size_t*)pSize, func)) return false; break; case PB_HTYPE_CALLBACK: { - pb_callback_t *callback = (pb_callback_t*)pData; + const pb_callback_t *callback = (const pb_callback_t*)pData; if (callback->funcs.encode != NULL) { if (!callback->funcs.encode(stream, field, callback->arg)) @@ -181,7 +202,7 @@ bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_ } /* Helper functions */ -bool pb_encode_varint(pb_ostream_t *stream, uint64_t value) +bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value) { uint8_t buffer[10]; int i = 0; @@ -191,7 +212,7 @@ bool pb_encode_varint(pb_ostream_t *stream, uint64_t value) while (value) { - buffer[i] = (value & 0x7F) | 0x80; + buffer[i] = (uint8_t)((value & 0x7F) | 0x80); value >>= 7; i++; } @@ -200,13 +221,58 @@ bool pb_encode_varint(pb_ostream_t *stream, uint64_t value) return pb_write(stream, buffer, i); } -bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, int field_number) +bool checkreturn pb_encode_svarint(pb_ostream_t *stream, int64_t value) { - int tag = wiretype | (field_number << 3); + uint64_t zigzagged; + if (value < 0) + zigzagged = ~(value << 1); + else + zigzagged = value << 1; + + return pb_encode_varint(stream, zigzagged); +} + +bool checkreturn pb_encode_fixed32(pb_ostream_t *stream, const void *value) +{ + #ifdef __BIG_ENDIAN__ + const uint8_t *bytes = value; + uint8_t lebytes[4]; + lebytes[0] = bytes[3]; + lebytes[1] = bytes[2]; + lebytes[2] = bytes[1]; + lebytes[3] = bytes[0]; + return pb_write(stream, lebytes, 4); + #else + return pb_write(stream, (const uint8_t*)value, 4); + #endif +} + +bool checkreturn pb_encode_fixed64(pb_ostream_t *stream, const void *value) +{ + #ifdef __BIG_ENDIAN__ + const uint8_t *bytes = value; + uint8_t lebytes[8]; + lebytes[0] = bytes[7]; + lebytes[1] = bytes[6]; + lebytes[2] = bytes[5]; + lebytes[3] = bytes[4]; + lebytes[4] = bytes[3]; + lebytes[5] = bytes[2]; + lebytes[6] = bytes[1]; + lebytes[7] = bytes[0]; + return pb_write(stream, lebytes, 8); + #else + return pb_write(stream, (const uint8_t*)value, 8); + #endif +} + +bool checkreturn pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, int field_number) +{ + uint64_t tag = wiretype | (field_number << 3); return pb_encode_varint(stream, tag); } -bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field) +bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field) { pb_wire_type_t wiretype; switch (PB_LTYPE(field->type)) @@ -216,13 +282,12 @@ bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field) wiretype = PB_WT_VARINT; break; - case PB_LTYPE_FIXED: - if (field->data_size == 4) - wiretype = PB_WT_32BIT; - else if (field->data_size == 8) - wiretype = PB_WT_64BIT; - else - return false; + case PB_LTYPE_FIXED32: + wiretype = PB_WT_32BIT; + break; + + case PB_LTYPE_FIXED64: + wiretype = PB_WT_64BIT; break; case PB_LTYPE_BYTES: @@ -238,95 +303,27 @@ bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field) return pb_encode_tag(stream, wiretype, field->tag); } -bool pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size) +bool checkreturn pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size) { - if (!pb_encode_varint(stream, size)) + if (!pb_encode_varint(stream, (uint64_t)size)) return false; return pb_write(stream, buffer, size); } -/* Field encoders */ - -/* Copy srcsize bytes from src so that values are casted properly. - * On little endian machine, copy to start of dest - * On big endian machine, copy to end of dest - * destsize must always be larger than srcsize - * - * Note: This is the reverse of the endian_copy in pb_decode.c. - */ -static void endian_copy(void *dest, const void *src, size_t destsize, size_t srcsize) -{ -#ifdef __BIG_ENDIAN__ - memcpy((char*)dest + (destsize - srcsize), src, srcsize); -#else - memcpy(dest, src, srcsize); -#endif -} - -bool pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src) +bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct) { - uint64_t value = 0; - endian_copy(&value, src, sizeof(value), field->data_size); - return pb_encode_varint(stream, value); -} - -bool pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src) -{ - uint64_t value = 0; - uint64_t zigzagged; - uint64_t signbitmask, xormask; - endian_copy(&value, src, sizeof(value), field->data_size); - - signbitmask = (uint64_t)0x80 << (field->data_size * 8 - 8); - xormask = ((uint64_t)-1) >> (64 - field->data_size * 8); - if (value & signbitmask) - zigzagged = ((value ^ xormask) << 1) | 1; - else - zigzagged = value << 1; - - return pb_encode_varint(stream, zigzagged); -} - -bool pb_enc_fixed(pb_ostream_t *stream, const pb_field_t *field, const void *src) -{ - #ifdef __BIG_ENDIAN__ - uint8_t bytes[8] = {0}; - endian_copy(bytes, src, sizeof(bytes), field->data_size); - uint8_t lebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4], - bytes[3], bytes[2], bytes[1], bytes[0]}; - return pb_write(stream, lebytes, field->data_size); - #else - return pb_write(stream, (uint8_t*)src, field->data_size); - #endif -} - -bool pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src) -{ - pb_bytes_array_t *bytes = (pb_bytes_array_t*)src; - return pb_encode_string(stream, bytes->bytes, bytes->size); -} - -bool pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src) -{ - return pb_encode_string(stream, (uint8_t*)src, strlen((char*)src)); -} - -bool pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src) -{ - pb_ostream_t substream = {0}; + /* First calculate the message size using a non-writing substream. */ + pb_ostream_t substream = {0,0,0,0}; size_t size; bool status; - if (field->ptr == NULL) - return false; - - if (!pb_encode(&substream, (pb_field_t*)field->ptr, src)) + if (!pb_encode(&substream, fields, src_struct)) return false; size = substream.bytes_written; - if (!pb_encode_varint(stream, size)) + if (!pb_encode_varint(stream, (uint64_t)size)) return false; if (stream->callback == NULL) @@ -342,9 +339,10 @@ bool pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void substream.max_size = size; substream.bytes_written = 0; - status = pb_encode(&substream, (pb_field_t*)field->ptr, src); + status = pb_encode(&substream, fields, src_struct); stream->bytes_written += substream.bytes_written; + stream->state = substream.state; if (substream.bytes_written != size) return false; @@ -352,3 +350,68 @@ bool pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void return status; } +/* Field encoders */ + +bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src) +{ + uint64_t value = 0; + + switch (field->data_size) + { + case 1: value = *(const uint8_t*)src; break; + case 2: value = *(const uint16_t*)src; break; + case 4: value = *(const uint32_t*)src; break; + case 8: value = *(const uint64_t*)src; break; + default: return false; + } + + return pb_encode_varint(stream, value); +} + +bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src) +{ + uint64_t value = 0; + + switch (field->data_size) + { + case 4: value = *(const int32_t*)src; break; + case 8: value = *(const int64_t*)src; break; + default: return false; + } + + return pb_encode_svarint(stream, value); +} + +bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src) +{ + UNUSED(field); + return pb_encode_fixed64(stream, src); +} + +bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src) +{ + UNUSED(field); + return pb_encode_fixed32(stream, src); +} + +bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src) +{ + const pb_bytes_array_t *bytes = (const pb_bytes_array_t*)src; + UNUSED(field); + return pb_encode_string(stream, bytes->bytes, bytes->size); +} + +bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src) +{ + UNUSED(field); + return pb_encode_string(stream, (const uint8_t*)src, strlen((const char*)src)); +} + +bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src) +{ + if (field->ptr == NULL) + return false; + + return pb_encode_submessage(stream, (const pb_field_t*)field->ptr, src); +} +