X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=pb_decode.c;h=50a11c40c3f43c38fcc86487d27046ede6894b1e;hb=e18352d50678005c9dbb3ac76913555f5317c81c;hp=acd9b204349c5a20a3a511a8173e1251d5c512d3;hpb=84304b343a4b06a7918bc80ab45f08d1cae0b9cb;p=apps%2Fagl-service-can-low-level.git diff --git a/pb_decode.c b/pb_decode.c index acd9b204..50a11c40 100644 --- a/pb_decode.c +++ b/pb_decode.c @@ -3,33 +3,51 @@ * 2011 Petteri Aimonen */ + +#ifdef __GNUC__ +/* Verify that we remember to check all return values for proper error propagation */ +#define checkreturn __attribute__((warn_unused_result)) +#else +#define checkreturn +#endif + #include "pb.h" #include "pb_decode.h" #include -const pb_decoder_t PB_DECODERS[16] = { - &pb_dec_uint32, - &pb_dec_sint32, +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. + */ +static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = { + &pb_dec_varint, + &pb_dec_svarint, &pb_dec_fixed32, - &pb_dec_uint64, - &pb_dec_sint64, &pb_dec_fixed64, - &pb_dec_bool, - &pb_dec_enum, - - &pb_dec_float, - &pb_dec_double, &pb_dec_bytes, &pb_dec_string, &pb_dec_submessage }; -//////////////////////// -// Helper functions -//////////////////////// +/************** + * pb_istream * + **************/ -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) +{ + if (stream->bytes_left < count) + return false; + + if (!stream->callback(stream, buf, count)) + return false; + + stream->bytes_left -= count; + return true; +} + +static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count) { uint8_t *source = (uint8_t*)stream->state; @@ -42,28 +60,34 @@ static bool buf_read(pb_istream_t *stream, uint8_t *buf, size_t count) pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize) { - pb_istream_t stream = {&buf_read, buf, bufsize}; + pb_istream_t stream; + stream.callback = &buf_read; + stream.state = buf; + stream.bytes_left = bufsize; return stream; } -bool pb_decode_varint32(pb_istream_t *stream, uint32_t *dest) +/******************** + * Helper functions * + ********************/ + +static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest) { uint64_t temp; - if (!pb_decode_varint64(stream, &temp)) - return false; - *dest = temp; - return true; + bool status = pb_decode_varint(stream, &temp); + *dest = (uint32_t)temp; + return status; } -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; + uint8_t bitpos = 0; *dest = 0; while (bitpos < 64 && pb_read(stream, &byte, 1)) { - *dest |= (byte & 0x7F) << bitpos; + *dest |= (uint64_t)(byte & 0x7F) << bitpos; bitpos += 7; if (!(byte & 0x80)) @@ -73,7 +97,7 @@ bool pb_decode_varint64(pb_istream_t *stream, uint64_t *dest) return false; } -bool pb_skip_varint(pb_istream_t *stream) +bool checkreturn pb_skip_varint(pb_istream_t *stream) { uint8_t byte; do @@ -84,7 +108,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)) @@ -93,52 +117,67 @@ 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, int *tag, bool *eof) +{ + uint32_t temp; + *eof = false; + *wire_type = 0; + *tag = 0; + + if (!pb_decode_varint32(stream, &temp)) + { + if (stream->bytes_left == 0) + *eof = true; -enum wire_type_t { - WT_VARINT = 0, - WT_64BIT = 1, - WT_STRING = 2, - WT_32BIT = 5 -}; + 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; +} -static bool skip(pb_istream_t *stream, int wire_type) +bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type) { switch (wire_type) { - case WT_VARINT: return pb_skip_varint(stream); - case WT_64BIT: return pb_read(stream, NULL, 8); - case WT_STRING: return pb_skip_string(stream); - case WT_32BIT: return pb_read(stream, NULL, 4); + case PB_WT_VARINT: return pb_skip_varint(stream); + 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; } } -// Read a raw value to buffer, for the purpose of passing it to callback. -// Size is maximum size on call, and actual size on return. -static bool read_raw_value(pb_istream_t *stream, int wire_type, uint8_t *buf, size_t *size) +/* 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 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) { - case WT_VARINT: + case PB_WT_VARINT: *size = 0; do { (*size)++; if (*size > max_size) return false; - if (!pb_read(stream, buf++, 1)) return false; - } while (*buf & 0x80); + if (!pb_read(stream, buf, 1)) return false; + } while (*buf++ & 0x80); return true; - case WT_64BIT: + case PB_WT_64BIT: *size = 8; return pb_read(stream, buf, 8); - case WT_32BIT: + case PB_WT_32BIT: *size = 4; return pb_read(stream, buf, 4); @@ -146,8 +185,11 @@ static bool read_raw_value(pb_istream_t *stream, int wire_type, uint8_t *buf, si } } -// 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. + * Before disposing the substream, remember to copy the substream->state back + * to stream->state. + */ +static bool checkreturn make_string_substream(pb_istream_t *stream, pb_istream_t *substream) { uint32_t size; if (!pb_decode_varint32(stream, &size)) @@ -162,37 +204,93 @@ static bool make_string_substream(pb_istream_t *stream, pb_istream_t *substream) return true; } -bool decode_field(pb_istream_t *stream, int wire_type, const pb_field_t *field, void *dest_struct) +/* 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; +} pb_field_iterator_t; + +static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct) { - pb_decoder_t func = PB_DECODERS[PB_LTYPE(field->type)]; - void *pData = (char*)dest_struct + field->data_offset; - void *pSize = (char*)dest_struct + field->size_offset; + iter->start = iter->current = fields; + iter->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; - switch (PB_HTYPE(field->type)) + if (PB_HTYPE(iter->current->type) == PB_HTYPE_ARRAY) + prev_size *= iter->current->array_size; + + iter->current++; + iter->field_index++; + if (iter->current->tag == 0) + { + iter->current = iter->start; + iter->field_index = 0; + iter->pData = iter->dest_struct; + prev_size = 0; + notwrapped = false; + } + + iter->pData = (char*)iter->pData + prev_size + iter->current->data_offset; + iter->pSize = (char*)iter->pData + iter->current->size_offset; + return notwrapped; +} + +static bool checkreturn pb_field_find(pb_field_iterator_t *iter, int tag) +{ + int start = iter->field_index; + + do { + if (iter->current->tag == tag) + return true; + pb_field_next(iter); + } while (iter->field_index != start); + + return false; +} + +/************************* + * Decode a single field * + *************************/ + +static bool checkreturn decode_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)]; + + switch (PB_HTYPE(iter->current->type)) { case PB_HTYPE_REQUIRED: - return func(stream, field, pData); + return func(stream, iter->current, iter->pData); case PB_HTYPE_OPTIONAL: - *(bool*)pSize = true; - return func(stream, field, pData); + *(bool*)iter->pSize = true; + return func(stream, iter->current, iter->pData); case PB_HTYPE_ARRAY: - if (wire_type == WT_STRING - && PB_LTYPE(field->type) != PB_LTYPE_BYTES - && PB_LTYPE(field->type) != PB_LTYPE_STRING - && PB_LTYPE(field->type) != PB_LTYPE_SUBMESSAGE) + if (wire_type == PB_WT_STRING + && PB_LTYPE(iter->current->type) <= PB_LTYPE_LAST_PACKABLE) { - // Packed array - size_t *size = (size_t*)pSize; + /* Packed array */ + size_t *size = (size_t*)iter->pSize; pb_istream_t substream; if (!make_string_substream(stream, &substream)) return false; - while (substream.bytes_left && *size < field->array_size) + while (substream.bytes_left && *size < iter->current->array_size) { - void *pItem = pData + field->data_size * (*size); - if (!func(stream, field, pItem)) + void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size); + if (!func(&substream, iter->current, pItem)) return false; (*size)++; } @@ -200,20 +298,25 @@ bool decode_field(pb_istream_t *stream, int wire_type, const pb_field_t *field, } else { - // Repeated field - size_t *size = (size_t*)pSize; - if (*size >= field->array_size) + /* Repeated field */ + 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; - void *pItem = pData + field->data_size * (*size); (*size)++; - return func(stream, field, pItem); + return func(stream, iter->current, pItem); } case PB_HTYPE_CALLBACK: - if (wire_type == WT_STRING) + { + pb_callback_t *pCallback = (pb_callback_t*)iter->pData; + + if (pCallback->funcs.decode == NULL) + return pb_skip_field(stream, wire_type); + + if (wire_type == PB_WT_STRING) { - pb_callback_t *pCallback = (pb_callback_t*)pData; pb_istream_t substream; if (!make_string_substream(stream, &substream)) @@ -221,93 +324,122 @@ bool decode_field(pb_istream_t *stream, int wire_type, const pb_field_t *field, while (substream.bytes_left) { - if (!pCallback->funcs.decode(&substream, field, pCallback->arg)) + if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg)) return false; } + + stream->state = substream.state; + 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. + /* 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; - pb_istream_t substream = pb_istream_from_buffer(buffer, size); + substream = pb_istream_from_buffer(buffer, size); - pb_callback_t *pCallback = (pb_callback_t*)pData; - return pCallback->funcs.decode(&substream, field, pCallback->arg); + return pCallback->funcs.decode(&substream, iter->current, pCallback->arg); } - + } + default: return false; } } -bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct) +/* Initialize message fields to default values, recursively */ +static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct) { - // Used to check for required fields - uint32_t fields_seen = 0; - int i; + pb_field_iterator_t iter; + pb_field_init(&iter, fields, dest_struct); - // Initialize size/has fields and apply default values - for (i = 0; fields[i].tag != 0; i++) + /* Initialize size/has fields and apply default values */ + do { - void *pData = (char*)dest_struct + fields[i].data_offset; - void *pSize = (char*)dest_struct + fields[i].size_offset; - if (PB_HTYPE(fields[i].type) == PB_HTYPE_OPTIONAL) + if (iter.current->tag == 0) + continue; + + /* Initialize the size field for optional/repeated fields to 0. */ + if (PB_HTYPE(iter.current->type) == PB_HTYPE_OPTIONAL) { - *(bool*)pSize = false; + *(bool*)iter.pSize = false; } - else if (PB_HTYPE(fields[i].type) == PB_HTYPE_ARRAY) + else if (PB_HTYPE(iter.current->type) == PB_HTYPE_ARRAY) { - *(size_t*)pSize = 0; + *(size_t*)iter.pSize = 0; + continue; /* Array is empty, no need to initialize contents */ } - if (PB_HTYPE(fields[i].type) != PB_HTYPE_ARRAY && - PB_HTYPE(fields[i].type) != PB_HTYPE_CALLBACK) + /* Initialize field contents to default value */ + if (PB_HTYPE(iter.current->type) == PB_HTYPE_CALLBACK) { - if (fields[i].ptr != NULL) - { - memcpy(pData, fields[i].ptr, fields[i].data_size); - } - else - { - memset(pData, 0, fields[i].data_size); - } + continue; /* Don't overwrite callback */ } - } + else if (PB_LTYPE(iter.current->type) == PB_LTYPE_SUBMESSAGE) + { + pb_message_set_to_defaults(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); + } + } while (pb_field_next(&iter)); +} + +/********************* + * Decode all fields * + *********************/ + +bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct) +{ + uint32_t fields_seen = 0; /* Used to check for required fields */ + pb_field_iterator_t iter; + int i; + + pb_message_set_to_defaults(fields, dest_struct); + + pb_field_init(&iter, fields, dest_struct); while (stream->bytes_left) { - uint32_t temp; - if (!pb_decode_varint32(stream, &temp)) - return false; - - int tag = temp >> 3; - int wire_type = temp & 7; + int tag; + pb_wire_type_t wire_type; + bool eof; - i = 0; - while (fields[i].tag != 0 && fields[i].tag != tag) + if (!pb_decode_tag(stream, &wire_type, &tag, &eof)) { - i++; + if (eof) + break; + else + return false; } - if (fields[i].tag == 0) // No match found, skip data + if (!pb_field_find(&iter, tag)) { - skip(stream, wire_type); + /* No match found, skip data */ + if (!pb_skip_field(stream, wire_type)) + return false; continue; } - fields_seen |= 1 << (i & 31); + fields_seen |= 1 << (iter.field_index & 31); - if (!decode_field(stream, wire_type, &fields[i], dest_struct)) + if (!decode_field(stream, wire_type, &iter)) return false; } - // Check that all required fields (mod 31) were present. + /* Check that all required fields (mod 31) were present. */ for (i = 0; fields[i].tag != 0; i++) { if (PB_HTYPE(fields[i].type) == PB_HTYPE_REQUIRED && @@ -322,89 +454,81 @@ bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struc /* Field decoders */ -bool pb_dec_uint32(pb_istream_t *stream, const pb_field_t *field, void *dest) -{ - return pb_decode_varint32(stream, (uint32_t*)dest); -} - -bool pb_dec_sint32(pb_istream_t *stream, const pb_field_t *field, void *dest) -{ - uint32_t *x = (uint32_t*)dest; - bool status = pb_decode_varint32(stream, x); - *x = (*x >> 1) ^ -(int32_t)(*x & 1); - return status; -} - -bool pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest) +/* 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) { - uint8_t bytes[4] = {0}; - bool status = pb_read(stream, bytes, 4); - #ifdef __BIG_ENDIAN__ - uint8_t lebytes[4] = {bytes[3], bytes[2], bytes[1], bytes[0]}; - memcpy(dest, lebytes, 4); + memcpy(dest, (char*)src + (srcsize - destsize), destsize); #else - memcpy(dest, bytes, 4); + UNUSED(srcsize); + memcpy(dest, src, destsize); #endif - return status; } -bool pb_dec_uint64(pb_istream_t *stream, const pb_field_t *field, void *dest) +bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest) { - return pb_decode_varint64(stream, (uint64_t*)dest); + uint64_t temp; + bool status = pb_decode_varint(stream, &temp); + endian_copy(dest, &temp, field->data_size, sizeof(temp)); + return status; } -bool pb_dec_sint64(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) { - uint64_t *x = (uint64_t*)dest; - bool status = pb_decode_varint64(stream, x); - *x = (*x >> 1) ^ -(int64_t)(*x & 1); + uint64_t temp; + bool status = pb_decode_varint(stream, &temp); + temp = (temp >> 1) ^ -(int64_t)(temp & 1); + endian_copy(dest, &temp, field->data_size, sizeof(temp)); return status; } -bool pb_dec_fixed64(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) { - uint8_t bytes[8] = {0}; - bool status = pb_read(stream, bytes, 8); - #ifdef __BIG_ENDIAN__ - uint8_t lebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4], - bytes[3], bytes[2], bytes[1], bytes[0]}; - memcpy(dest, lebytes, 4); + uint8_t bytes[4] = {0}; + bool status = pb_read(stream, bytes, 4); + if (status) { + uint8_t *d = (uint8_t*)dest; + d[0] = bytes[3]; + d[1] = bytes[2]; + d[2] = bytes[1]; + d[3] = bytes[0]; + } + return status; #else - memcpy(dest, bytes, 4); + UNUSED(field); + return pb_read(stream, (uint8_t*)dest, 4); #endif - return status; } -bool pb_dec_bool(pb_istream_t *stream, const pb_field_t *field, void *dest) +bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest) { - uint32_t temp = 0; - bool status = pb_decode_varint32(stream, &temp); - *(bool*)dest = !!temp; - return status; -} - -bool pb_dec_enum(pb_istream_t *stream, const pb_field_t *field, void *dest) -{ - // Enum sizes can vary, copy only data_size amount of bytes. - uint32_t temp = 0; - bool status = pb_decode_varint32(stream, &temp); - memcpy(dest, &temp, field->data_size); +#ifdef __BIG_ENDIAN__ + uint8_t bytes[8] = {0}; + bool status = pb_read(stream, bytes, 8); + if (status) { + uint8_t *d = (uint8_t*)dest; + d[0] = bytes[7]; + d[1] = bytes[6]; + d[2] = bytes[5]; + d[3] = bytes[4]; + d[4] = bytes[3]; + d[5] = bytes[2]; + d[6] = bytes[1]; + d[7] = bytes[0]; + } return status; +#else + UNUSED(field); + return pb_read(stream, (uint8_t*)dest, 8); +#endif } -bool pb_dec_float(pb_istream_t *stream, const pb_field_t *field, void *dest) -{ - return pb_read(stream, (uint8_t*)dest, sizeof(float)); -} - -bool pb_dec_double(pb_istream_t *stream, const pb_field_t *field, void *dest) -{ - return pb_read(stream, (uint8_t*)dest, sizeof(double)); -} - -bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *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; @@ -413,30 +537,32 @@ 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; 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) + /* Check length, noting the null terminator */ + if (size + 1 > field->data_size) return false; - bool status = pb_read(stream, (uint8_t*)dest, size); + 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; if (!make_string_substream(stream, &substream)) @@ -445,5 +571,7 @@ bool pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest if (field->ptr == NULL) return false; - return pb_decode(&substream, (pb_field_t*)field->ptr, dest); + status = pb_decode(&substream, (pb_field_t*)field->ptr, dest); + stream->state = substream.state; + return status; }