X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=pb_decode.c;h=7c68b5a2e7dbebf2205b903a8e031f60c4c21ba9;hb=eab4151a99f0c2fc2f41c51356d04898255ccbfe;hp=59efb3d67b8291f128e1db6fb4fe3c449234c69b;hpb=2941e90e041b0d7872a4ea458e77dcc787ca6ff2;p=apps%2Fagl-service-can-low-level.git diff --git a/pb_decode.c b/pb_decode.c index 59efb3d6..7c68b5a2 100644 --- a/pb_decode.c +++ b/pb_decode.c @@ -36,26 +36,41 @@ static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = { * pb_istream * **************/ -bool checkreturn 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; - if (!stream->callback(stream, buf, count)) - return false; + if (buf != NULL) + memcpy(buf, source, count); - stream->bytes_left -= count; + stream->state = source + count; return true; } -static bool checkreturn 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; + 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); + } + + if (stream->bytes_left < count) + PB_RETURN_ERROR(stream, "end-of-stream"); - if (buf != NULL) - memcpy(buf, source, count); + if (!stream->callback(stream, buf, count)) + PB_RETURN_ERROR(stream, "io error"); - stream->state = source + count; + stream->bytes_left -= count; return true; } @@ -65,6 +80,9 @@ pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize) stream.callback = &buf_read; stream.state = buf; stream.bytes_left = bufsize; +#ifndef PB_NO_ERRMSG + stream.errmsg = NULL; +#endif return stream; } @@ -83,7 +101,7 @@ static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest) bool checkreturn pb_decode_varint(pb_istream_t *stream, uint64_t *dest) { uint8_t byte; - uint8_t bitpos = 0; + int bitpos = 0; *dest = 0; while (bitpos < 64 && pb_read(stream, &byte, 1)) @@ -95,7 +113,7 @@ bool checkreturn pb_decode_varint(pb_istream_t *stream, uint64_t *dest) return true; } - return false; + PB_RETURN_ERROR(stream, "varint overflow"); } bool checkreturn pb_skip_varint(pb_istream_t *stream) @@ -152,7 +170,7 @@ bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t 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"); } } @@ -182,33 +200,37 @@ static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire *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 substream_callback(pb_istream_t *stream, uint8_t *buf, size_t count) -{ - pb_istream_t *parent = (pb_istream_t*)stream->state; - return pb_read(parent, buf, count); -} - +/* 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)) return false; - if (stream->bytes_left < size) - return false; + *substream = *stream; + if (substream->bytes_left < size) + PB_RETURN_ERROR(stream, "parent stream too short"); - substream->callback = &substream_callback; - substream->state = stream; 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; /* Start of the pb_field_t array */ @@ -293,6 +315,7 @@ static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_t && PB_LTYPE(iter->current->type) <= PB_LTYPE_LAST_PACKABLE) { /* Packed array */ + bool status; size_t *size = (size_t*)iter->pSize; pb_istream_t substream; if (!pb_make_string_substream(stream, &substream)) @@ -305,7 +328,9 @@ static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_t return false; (*size)++; } - return (substream.bytes_left == 0); + status = (substream.bytes_left == 0); + pb_close_string_substream(stream, &substream); + return status; } else { @@ -313,7 +338,7 @@ static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_t 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); @@ -336,9 +361,10 @@ static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_t while (substream.bytes_left) { if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg)) - return false; + PB_RETURN_ERROR(stream, "callback failed"); } + pb_close_string_substream(stream, &substream); return true; } else @@ -360,7 +386,7 @@ static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_t } default: - return false; + PB_RETURN_ERROR(stream, "invalid field type"); } } @@ -411,13 +437,11 @@ static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_str * Decode all fields * *********************/ -bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct) +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_message_set_to_defaults(fields, dest_struct); - pb_field_init(&iter, fields, dest_struct); while (stream->bytes_left) @@ -445,7 +469,7 @@ bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED && iter.required_field_index < PB_MAX_REQUIRED_FIELDS) { - fields_seen[iter.required_field_index >> 3] |= 1 << (iter.required_field_index & 7); + fields_seen[iter.required_field_index >> 3] |= (uint8_t)(1 << (iter.required_field_index & 7)); } if (!decode_field(stream, wire_type, &iter)) @@ -459,13 +483,19 @@ bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void iter.required_field_index < PB_MAX_REQUIRED_FIELDS && !(fields_seen[iter.required_field_index >> 3] & (1 << (iter.required_field_index & 7)))) { - return false; + PB_RETURN_ERROR(stream, "missing required field"); } } while (pb_field_next(&iter)); 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 */ bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest) @@ -475,9 +505,9 @@ bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest) return false; if (value & 1) - *dest = ~(value >> 1); + *dest = (int64_t)(~(value >> 1)); else - *dest = value >> 1; + *dest = (int64_t)(value >> 1); return true; } @@ -531,11 +561,11 @@ bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, vo switch (field->data_size) { - case 1: *(uint8_t*)dest = value; break; - case 2: *(uint16_t*)dest = value; break; - case 4: *(uint32_t*)dest = value; break; + 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: return false; + default: PB_RETURN_ERROR(stream, "invalid data_size"); } return status; @@ -548,9 +578,9 @@ bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, v switch (field->data_size) { - case 4: *(int32_t*)dest = value; break; + case 4: *(int32_t*)dest = (int32_t)value; break; case 8: *(int64_t*)dest = value; break; - default: return false; + default: PB_RETURN_ERROR(stream, "invalid data_size"); } return status; @@ -579,7 +609,7 @@ bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, voi /* 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); } @@ -593,7 +623,7 @@ bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, vo /* Check length, noting the null terminator */ if (size + 1 > field->data_size) - return false; + PB_RETURN_ERROR(stream, "string overflow"); status = pb_read(stream, (uint8_t*)dest, size); *((uint8_t*)dest + size) = 0; @@ -602,13 +632,23 @@ bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, vo 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 (!pb_make_string_substream(stream, &substream)) return false; if (field->ptr == NULL) - return false; + PB_RETURN_ERROR(stream, "invalid field descriptor"); - return pb_decode(&substream, (pb_field_t*)field->ptr, dest); + /* 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_ARRAY) + status = pb_decode(&substream, submsg_fields, dest); + else + status = pb_decode_noinit(&substream, submsg_fields, dest); + + pb_close_string_substream(stream, &substream); + return status; }