X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=pb_decode.c;h=bc6df7b978a138cd8026ba30fb5338bb5d71df63;hb=5442e690f65fd09e7a44437da02fb7e14af6fe8f;hp=df053314cf4bd45c5daab760f807ad4151e05c6f;hpb=a8d0172507d59b73b95f766aa7644147fd060f20;p=apps%2Fagl-service-can-low-level.git diff --git a/pb_decode.c b/pb_decode.c index df053314..bc6df7b9 100644 --- a/pb_decode.c +++ b/pb_decode.c @@ -3,11 +3,20 @@ * 2011 Petteri Aimonen */ +/* 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 + +#define NANOPB_INTERNALS #include "pb.h" #include "pb_decode.h" #include -typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest); +typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn; /* --- Function pointers to field decoders --- * Order in the array must match pb_action_t LTYPE numbering. @@ -15,7 +24,8 @@ typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = { &pb_dec_varint, &pb_dec_svarint, - &pb_dec_fixed, + &pb_dec_fixed32, + &pb_dec_fixed64, &pb_dec_bytes, &pb_dec_string, @@ -26,35 +36,67 @@ static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = { * pb_istream * **************/ -bool pb_read(pb_istream_t *stream, uint8_t *buf, size_t count) +static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count) { - if (stream->bytes_left < count) - return false; + uint8_t *source = (uint8_t*)stream->state; + stream->state = source + count; - if (!stream->callback(stream, buf, count)) - return false; + if (buf != NULL) + { + while (count--) + *buf++ = *source++; + } - stream->bytes_left -= count; return true; } -static bool buf_read(pb_istream_t *stream, uint8_t *buf, size_t count) +bool checkreturn pb_read(pb_istream_t *stream, uint8_t *buf, size_t count) { - uint8_t *source = (uint8_t*)stream->state; +#ifndef PB_BUFFER_ONLY + if (buf == NULL && stream->callback != buf_read) + { + /* Skip input bytes */ + uint8_t tmp[16]; + while (count > 16) + { + if (!pb_read(stream, tmp, 16)) + return false; + + count -= 16; + } + + return pb_read(stream, tmp, count); + } +#endif + + if (stream->bytes_left < count) + PB_RETURN_ERROR(stream, "end-of-stream"); - if (buf != NULL) - memcpy(buf, source, count); +#ifndef PB_BUFFER_ONLY + if (!stream->callback(stream, buf, count)) + PB_RETURN_ERROR(stream, "io error"); +#else + if (!buf_read(stream, buf, count)) + return false; +#endif - stream->state = source + count; + stream->bytes_left -= count; return true; } pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize) { pb_istream_t stream; +#ifdef PB_BUFFER_ONLY + stream.callback = NULL; +#else stream.callback = &buf_read; +#endif stream.state = buf; stream.bytes_left = bufsize; +#ifndef PB_NO_ERRMSG + stream.errmsg = NULL; +#endif return stream; } @@ -62,33 +104,65 @@ pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize) * Helper functions * ********************/ -bool pb_decode_varint32(pb_istream_t *stream, uint32_t *dest) +static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest) { - uint64_t temp; - bool status = pb_decode_varint64(stream, &temp); - *dest = temp; - return status; + uint8_t byte; + uint32_t result; + + if (!pb_read(stream, &byte, 1)) + return false; + + if (!(byte & 0x80)) + { + /* Quick case, 1 byte value */ + result = byte; + } + else + { + /* Multibyte case */ + uint8_t bitpos = 7; + result = byte & 0x7F; + + do + { + if (bitpos >= 32) + PB_RETURN_ERROR(stream, "varint overflow"); + + if (!pb_read(stream, &byte, 1)) + return false; + + result |= (uint32_t)(byte & 0x7F) << bitpos; + bitpos = (uint8_t)(bitpos + 7); + } while (byte & 0x80); + } + + *dest = result; + return true; } -bool pb_decode_varint64(pb_istream_t *stream, uint64_t *dest) +bool checkreturn pb_decode_varint(pb_istream_t *stream, uint64_t *dest) { uint8_t byte; - int bitpos = 0; - *dest = 0; + uint8_t bitpos = 0; + uint64_t result = 0; - while (bitpos < 64 && pb_read(stream, &byte, 1)) + do { - *dest |= (uint64_t)(byte & 0x7F) << bitpos; - bitpos += 7; + if (bitpos >= 64) + PB_RETURN_ERROR(stream, "varint overflow"); - if (!(byte & 0x80)) - return true; - } + if (!pb_read(stream, &byte, 1)) + return false; + + result |= (uint64_t)(byte & 0x7F) << bitpos; + bitpos = (uint8_t)(bitpos + 7); + } while (byte & 0x80); - return false; + *dest = result; + return true; } -bool pb_skip_varint(pb_istream_t *stream) +bool checkreturn pb_skip_varint(pb_istream_t *stream) { uint8_t byte; do @@ -99,7 +173,7 @@ bool pb_skip_varint(pb_istream_t *stream) return true; } -bool pb_skip_string(pb_istream_t *stream) +bool checkreturn pb_skip_string(pb_istream_t *stream) { uint32_t length; if (!pb_decode_varint32(stream, &length)) @@ -108,12 +182,33 @@ bool pb_skip_string(pb_istream_t *stream) return pb_read(stream, NULL, length); } -/* Currently all wire type related stuff is kept hidden from - * callbacks. They shouldn't need it. It's better for performance - * to just assume the correct type and fail safely on corrupt message. - */ +bool checkreturn pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof) +{ + uint32_t temp; + *eof = false; + *wire_type = (pb_wire_type_t) 0; + *tag = 0; + + if (!pb_decode_varint32(stream, &temp)) + { + if (stream->bytes_left == 0) + *eof = true; -static bool skip(pb_istream_t *stream, int wire_type) + return false; + } + + if (temp == 0) + { + *eof = true; /* Special feature: allow 0-terminated messages. */ + return false; + } + + *tag = temp >> 3; + *wire_type = (pb_wire_type_t)(temp & 7); + return true; +} + +bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type) { switch (wire_type) { @@ -121,14 +216,14 @@ static bool skip(pb_istream_t *stream, int wire_type) case PB_WT_64BIT: return pb_read(stream, NULL, 8); case PB_WT_STRING: return pb_skip_string(stream); case PB_WT_32BIT: return pb_read(stream, NULL, 4); - default: return false; + default: PB_RETURN_ERROR(stream, "invalid wire_type"); } } /* Read a raw value to buffer, for the purpose of passing it to callback as * a substream. Size is maximum size on call, and actual size on return. */ -static bool read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size) +static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size) { size_t max_size = *size; switch (wire_type) @@ -151,12 +246,14 @@ static bool read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8 *size = 4; return pb_read(stream, buf, 4); - default: return false; + default: PB_RETURN_ERROR(stream, "invalid wire_type"); } } -/* Decode string length from stream and return a substream with limited length */ -static bool make_string_substream(pb_istream_t *stream, pb_istream_t *substream) +/* Decode string length from stream and return a substream with limited length. + * Remember to close the substream using pb_close_string_substream(). + */ +bool checkreturn pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream) { uint32_t size; if (!pb_decode_varint32(stream, &size)) @@ -164,52 +261,77 @@ static bool make_string_substream(pb_istream_t *stream, pb_istream_t *substream) *substream = *stream; if (substream->bytes_left < size) - return false; + PB_RETURN_ERROR(stream, "parent stream too short"); substream->bytes_left = size; stream->bytes_left -= size; return true; } +void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream) +{ + stream->state = substream->state; + +#ifndef PB_NO_ERRMSG + stream->errmsg = substream->errmsg; +#endif +} + /* Iterator for pb_field_t list */ typedef struct { - const pb_field_t *start; - const pb_field_t *current; - int field_index; - void *dest_struct; - void *pData; - void *pSize; + const pb_field_t *start; /* Start of the pb_field_t array */ + const pb_field_t *current; /* Current position of the iterator */ + unsigned field_index; /* Zero-based index of the field. */ + unsigned required_field_index; /* Zero-based index that counts only the required fields */ + void *dest_struct; /* Pointer to the destination structure to decode to */ + void *pData; /* Pointer where to store current field value */ + void *pSize; /* Pointer where to store the size of current array field */ } pb_field_iterator_t; static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct) { iter->start = iter->current = fields; iter->field_index = 0; - iter->pData = dest_struct; + iter->required_field_index = 0; + iter->pData = (char*)dest_struct + iter->current->data_offset; + iter->pSize = (char*)iter->pData + iter->current->size_offset; iter->dest_struct = dest_struct; } static bool pb_field_next(pb_field_iterator_t *iter) { bool notwrapped = true; + size_t prev_size = iter->current->data_size; + + if (PB_ATYPE(iter->current->type) == PB_ATYPE_STATIC && + PB_HTYPE(iter->current->type) == PB_HTYPE_REPEATED) + { + prev_size *= iter->current->array_size; + } + + if (PB_HTYPE(iter->current->type) == PB_HTYPE_REQUIRED) + iter->required_field_index++; + iter->current++; iter->field_index++; if (iter->current->tag == 0) { iter->current = iter->start; iter->field_index = 0; + iter->required_field_index = 0; iter->pData = iter->dest_struct; + prev_size = 0; notwrapped = false; } - iter->pData = (char*)iter->pData + iter->current->data_offset; + iter->pData = (char*)iter->pData + prev_size + iter->current->data_offset; iter->pSize = (char*)iter->pData + iter->current->size_offset; return notwrapped; } -static bool pb_field_find(pb_field_iterator_t *iter, int tag) +static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag) { - int start = iter->field_index; + unsigned start = iter->field_index; do { if (iter->current->tag == tag) @@ -224,11 +346,15 @@ static bool pb_field_find(pb_field_iterator_t *iter, int tag) * Decode a single field * *************************/ -bool decode_field(pb_istream_t *stream, int wire_type, pb_field_iterator_t *iter) +static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter) { - pb_decoder_t func = PB_DECODERS[PB_LTYPE(iter->current->type)]; + pb_type_t type; + pb_decoder_t func; - switch (PB_HTYPE(iter->current->type)) + type = iter->current->type; + func = PB_DECODERS[PB_LTYPE(type)]; + + switch (PB_HTYPE(type)) { case PB_HTYPE_REQUIRED: return func(stream, iter->current, iter->pData); @@ -237,24 +363,33 @@ bool decode_field(pb_istream_t *stream, int wire_type, pb_field_iterator_t *iter *(bool*)iter->pSize = true; return func(stream, iter->current, iter->pData); - case PB_HTYPE_ARRAY: + case PB_HTYPE_REPEATED: if (wire_type == PB_WT_STRING - && PB_LTYPE(iter->current->type) <= PB_LTYPE_LAST_PACKABLE) + && PB_LTYPE(type) <= PB_LTYPE_LAST_PACKABLE) { /* Packed array */ + bool status = true; size_t *size = (size_t*)iter->pSize; pb_istream_t substream; - if (!make_string_substream(stream, &substream)) + if (!pb_make_string_substream(stream, &substream)) return false; while (substream.bytes_left && *size < iter->current->array_size) { void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size); - if (!func(stream, iter->current, pItem)) - return false; + if (!func(&substream, iter->current, pItem)) + { + status = false; + break; + } (*size)++; } - return (substream.bytes_left == 0); + pb_close_string_substream(stream, &substream); + + if (substream.bytes_left != 0) + PB_RETURN_ERROR(stream, "array overflow"); + + return status; } else { @@ -262,172 +397,307 @@ bool decode_field(pb_istream_t *stream, int wire_type, pb_field_iterator_t *iter size_t *size = (size_t*)iter->pSize; void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size); if (*size >= iter->current->array_size) - return false; + PB_RETURN_ERROR(stream, "array overflow"); (*size)++; return func(stream, iter->current, pItem); } - - case PB_HTYPE_CALLBACK: - if (wire_type == PB_WT_STRING) - { - pb_callback_t *pCallback = (pb_callback_t*)iter->pData; - pb_istream_t substream; - - if (!make_string_substream(stream, &substream)) - return false; - - while (substream.bytes_left) - { - if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg)) - return false; - } - return true; - } - else - { - /* Copy the single scalar value to stack. - * This is required so that we can limit the stream length, - * which in turn allows to use same callback for packed and - * not-packed fields. */ - pb_istream_t substream; - pb_callback_t *pCallback = (pb_callback_t*)iter->pData; - uint8_t buffer[10]; - size_t size = sizeof(buffer); - - if (!read_raw_value(stream, wire_type, buffer, &size)) - return false; - substream = pb_istream_from_buffer(buffer, size); - - return pCallback->funcs.decode(&substream, iter->current, pCallback->arg); - } - + default: - return false; + PB_RETURN_ERROR(stream, "invalid field type"); } } -/********************* - * Decode all fields * - *********************/ - -bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct) +static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter) { - uint32_t fields_seen = 0; /* Used to check for required fields */ - pb_field_iterator_t iter; - int i; + pb_callback_t *pCallback = (pb_callback_t*)iter->pData; + + if (pCallback->funcs.decode == NULL) + return pb_skip_field(stream, wire_type); - if (fields[0].tag == 0) + if (wire_type == PB_WT_STRING) { - /* No fields -> nothing to do */ - return pb_read(stream, NULL, stream->bytes_left); + pb_istream_t substream; + + if (!pb_make_string_substream(stream, &substream)) + return false; + + while (substream.bytes_left) + { + if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg)) + PB_RETURN_ERROR(stream, "callback failed"); + } + + pb_close_string_substream(stream, &substream); + return true; } - + else + { + /* Copy the single scalar value to stack. + * This is required so that we can limit the stream length, + * which in turn allows to use same callback for packed and + * not-packed fields. */ + pb_istream_t substream; + uint8_t buffer[10]; + size_t size = sizeof(buffer); + + if (!read_raw_value(stream, wire_type, buffer, &size)) + return false; + substream = pb_istream_from_buffer(buffer, size); + + return pCallback->funcs.decode(&substream, iter->current, pCallback->arg); + } +} + +static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter) +{ + switch (PB_ATYPE(iter->current->type)) + { + case PB_ATYPE_STATIC: + return decode_static_field(stream, wire_type, iter); + + case PB_ATYPE_CALLBACK: + return decode_callback_field(stream, wire_type, iter); + + default: + PB_RETURN_ERROR(stream, "invalid field type"); + } +} + +/* Initialize message fields to default values, recursively */ +static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct) +{ + pb_field_iterator_t iter; pb_field_init(&iter, fields, dest_struct); /* Initialize size/has fields and apply default values */ do { - if (PB_HTYPE(iter.current->type) == PB_HTYPE_OPTIONAL) + pb_type_t type; + type = iter.current->type; + + if (iter.current->tag == 0) + continue; + + if (PB_ATYPE(type) == PB_ATYPE_STATIC) { - *(bool*)iter.pSize = false; + /* Initialize the size field for optional/repeated fields to 0. */ + if (PB_HTYPE(type) == PB_HTYPE_OPTIONAL) + { + *(bool*)iter.pSize = false; + } + else if (PB_HTYPE(type) == PB_HTYPE_REPEATED) + { + *(size_t*)iter.pSize = 0; + continue; /* Array is empty, no need to initialize contents */ + } - /* Initialize to default value */ - if (iter.current->ptr != NULL) + /* Initialize field contents to default value */ + if (PB_LTYPE(iter.current->type) == PB_LTYPE_SUBMESSAGE) + { + pb_message_set_to_defaults((const pb_field_t *) iter.current->ptr, iter.pData); + } + else if (iter.current->ptr != NULL) + { memcpy(iter.pData, iter.current->ptr, iter.current->data_size); + } else + { memset(iter.pData, 0, iter.current->data_size); + } } - else if (PB_HTYPE(iter.current->type) == PB_HTYPE_ARRAY) + else if (PB_ATYPE(type) == PB_ATYPE_CALLBACK) { - *(size_t*)iter.pSize = 0; + continue; /* Don't overwrite callback */ } } while (pb_field_next(&iter)); +} + +/********************* + * Decode all fields * + *********************/ + +bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct) +{ + uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0}; /* Used to check for required fields */ + pb_field_iterator_t iter; + + pb_field_init(&iter, fields, dest_struct); while (stream->bytes_left) { - uint32_t temp; - int tag, wire_type; - if (!pb_decode_varint32(stream, &temp)) - return false; + uint32_t tag; + pb_wire_type_t wire_type; + bool eof; - tag = temp >> 3; - wire_type = temp & 7; + if (!pb_decode_tag(stream, &wire_type, &tag, &eof)) + { + if (eof) + break; + else + return false; + } if (!pb_field_find(&iter, tag)) { /* No match found, skip data */ - skip(stream, wire_type); + if (!pb_skip_field(stream, wire_type)) + return false; continue; } - fields_seen |= 1 << (iter.field_index & 31); + if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED + && iter.required_field_index < PB_MAX_REQUIRED_FIELDS) + { + fields_seen[iter.required_field_index >> 3] |= (uint8_t)(1 << (iter.required_field_index & 7)); + } if (!decode_field(stream, wire_type, &iter)) return false; } - /* Check that all required fields (mod 31) were present. */ - for (i = 0; fields[i].tag != 0; i++) + /* Check that all required fields were present. */ { - if (PB_HTYPE(fields[i].type) == PB_HTYPE_REQUIRED && - !(fields_seen & (1 << (i & 31)))) + /* First figure out the number of required fields by + * seeking to the end of the field array. Usually we + * are already close to end after decoding. + */ + unsigned req_field_count; + pb_type_t last_type; + unsigned i; + do { + req_field_count = iter.required_field_index; + last_type = iter.current->type; + } while (pb_field_next(&iter)); + + /* Fixup if last field was also required. */ + if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED) + req_field_count++; + + /* Check the whole bytes */ + for (i = 0; i < (req_field_count >> 3); i++) { - return false; + if (fields_seen[i] != 0xFF) + PB_RETURN_ERROR(stream, "missing required field"); } + + /* Check the remaining bits */ + if (fields_seen[req_field_count >> 3] != (0xFF >> (8 - (req_field_count & 7)))) + PB_RETURN_ERROR(stream, "missing required field"); } return true; } +bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct) +{ + pb_message_set_to_defaults(fields, dest_struct); + return pb_decode_noinit(stream, fields, dest_struct); +} + /* Field decoders */ -/* Copy destsize bytes from src so that values are casted properly. - * On little endian machine, copy first n bytes of src - * On big endian machine, copy last n bytes of src - * srcsize must always be larger than destsize - */ -static void endian_copy(void *dest, void *src, size_t destsize, size_t srcsize) +bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest) { -#ifdef __BIG_ENDIAN__ - memcpy(dest, (char*)src + (srcsize - destsize), destsize); -#else - memcpy(dest, src, destsize); -#endif + uint64_t value; + if (!pb_decode_varint(stream, &value)) + return false; + + if (value & 1) + *dest = (int64_t)(~(value >> 1)); + else + *dest = (int64_t)(value >> 1); + + return true; } -bool pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest) +bool pb_decode_fixed32(pb_istream_t *stream, void *dest) { - uint64_t temp; - bool status = pb_decode_varint64(stream, &temp); - endian_copy(dest, &temp, field->data_size, sizeof(temp)); - return status; + #ifdef __BIG_ENDIAN__ + uint8_t *bytes = (uint8_t*)dest; + uint8_t lebytes[4]; + + if (!pb_read(stream, lebytes, 4)) + return false; + + bytes[0] = lebytes[3]; + bytes[1] = lebytes[2]; + bytes[2] = lebytes[1]; + bytes[3] = lebytes[0]; + return true; + #else + return pb_read(stream, (uint8_t*)dest, 4); + #endif } -bool pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest) +bool pb_decode_fixed64(pb_istream_t *stream, void *dest) { - uint64_t temp; - bool status = pb_decode_varint64(stream, &temp); - temp = (temp >> 1) ^ -(int64_t)(temp & 1); - endian_copy(dest, &temp, field->data_size, sizeof(temp)); + #ifdef __BIG_ENDIAN__ + uint8_t *bytes = (uint8_t*)dest; + uint8_t lebytes[8]; + + if (!pb_read(stream, lebytes, 8)) + return false; + + bytes[0] = lebytes[7]; + bytes[1] = lebytes[6]; + bytes[2] = lebytes[5]; + bytes[3] = lebytes[4]; + bytes[4] = lebytes[3]; + bytes[5] = lebytes[2]; + bytes[6] = lebytes[1]; + bytes[7] = lebytes[0]; + return true; + #else + return pb_read(stream, (uint8_t*)dest, 8); + #endif +} + +bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest) +{ + uint64_t value; + bool status = pb_decode_varint(stream, &value); + + switch (field->data_size) + { + case 1: *(uint8_t*)dest = (uint8_t)value; break; + case 2: *(uint16_t*)dest = (uint16_t)value; break; + case 4: *(uint32_t*)dest = (uint32_t)value; break; + case 8: *(uint64_t*)dest = value; break; + default: PB_RETURN_ERROR(stream, "invalid data_size"); + } + return status; } -bool pb_dec_fixed(pb_istream_t *stream, const pb_field_t *field, void *dest) +bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest) { -#ifdef __BIG_ENDIAN__ - uint8_t bytes[8] = {0}; - bool status = pb_read(stream, bytes, field->data_size); - uint8_t bebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4], - bytes[3], bytes[2], bytes[1], bytes[0]}; - endian_copy(dest, lebytes, field->data_size, 8); + int64_t value; + bool status = pb_decode_svarint(stream, &value); + + switch (field->data_size) + { + case 4: *(int32_t*)dest = (int32_t)value; break; + case 8: *(int64_t*)dest = value; break; + default: PB_RETURN_ERROR(stream, "invalid data_size"); + } + return status; -#else - return pb_read(stream, (uint8_t*)dest, field->data_size); -#endif } -bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest) +bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest) +{ + UNUSED(field); + return pb_decode_fixed32(stream, dest); +} + +bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest) +{ + UNUSED(field); + return pb_decode_fixed64(stream, dest); +} + +bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest) { pb_bytes_array_t *x = (pb_bytes_array_t*)dest; @@ -436,38 +706,48 @@ bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest) return false; x->size = temp; - /* Note: data_size includes the size of the x.size field, too. - * Calculate actual size starting from offset. */ + /* Check length, noting the space taken by the size_t header. */ if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes)) - return false; + PB_RETURN_ERROR(stream, "bytes overflow"); return pb_read(stream, x->bytes, x->size); } -bool pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest) +bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest) { uint32_t size; bool status; if (!pb_decode_varint32(stream, &size)) return false; - if (size > field->data_size - 1) - return false; + /* Check length, noting the null terminator */ + if (size + 1 > field->data_size) + PB_RETURN_ERROR(stream, "string overflow"); status = pb_read(stream, (uint8_t*)dest, size); *((uint8_t*)dest + size) = 0; return status; } -bool pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest) +bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest) { + bool status; pb_istream_t substream; + const pb_field_t* submsg_fields = (const pb_field_t*)field->ptr; - if (!make_string_substream(stream, &substream)) + if (!pb_make_string_substream(stream, &substream)) return false; if (field->ptr == NULL) - return false; + PB_RETURN_ERROR(stream, "invalid field descriptor"); + + /* New array entries need to be initialized, while required and optional + * submessages have already been initialized in the top-level pb_decode. */ + if (PB_HTYPE(field->type) == PB_HTYPE_REPEATED) + status = pb_decode(&substream, submsg_fields, dest); + else + status = pb_decode_noinit(&substream, submsg_fields, dest); - return pb_decode(&substream, (pb_field_t*)field->ptr, dest); + pb_close_string_substream(stream, &substream); + return status; }