#define NANOPB_INTERNALS
#include "pb.h"
#include "pb_decode.h"
-#include <string.h>
typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;
/* Iterator for pb_field_t list */
typedef struct {
const pb_field_t *start; /* Start of the pb_field_t array */
- const pb_field_t *current; /* Current position of the iterator */
+ const pb_field_t *pos; /* 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 */
static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct)
{
- iter->start = iter->current = fields;
+ iter->start = iter->pos = fields;
iter->field_index = 0;
iter->required_field_index = 0;
- iter->pData = (char*)dest_struct + iter->current->data_offset;
- iter->pSize = (char*)iter->pData + iter->current->size_offset;
+ iter->pData = (char*)dest_struct + iter->pos->data_offset;
+ iter->pSize = (char*)iter->pData + iter->pos->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;
+ size_t prev_size = iter->pos->data_size;
- if (PB_HTYPE(iter->current->type) == PB_HTYPE_ARRAY)
- prev_size *= iter->current->array_size;
+ if (PB_ATYPE(iter->pos->type) == PB_ATYPE_STATIC &&
+ PB_HTYPE(iter->pos->type) == PB_HTYPE_REPEATED)
+ {
+ prev_size *= iter->pos->array_size;
+ }
- if (PB_HTYPE(iter->current->type) == PB_HTYPE_REQUIRED)
+ if (PB_HTYPE(iter->pos->type) == PB_HTYPE_REQUIRED)
iter->required_field_index++;
- iter->current++;
+ if (iter->pos->tag == 0)
+ return false; /* Only happens with empty message types */
+
+ iter->pos++;
iter->field_index++;
- if (iter->current->tag == 0)
+ if (iter->pos->tag == 0)
{
- iter->current = iter->start;
+ iter->pos = iter->start;
iter->field_index = 0;
iter->required_field_index = 0;
iter->pData = iter->dest_struct;
notwrapped = false;
}
- iter->pData = (char*)iter->pData + prev_size + iter->current->data_offset;
- iter->pSize = (char*)iter->pData + iter->current->size_offset;
+ iter->pData = (char*)iter->pData + prev_size + iter->pos->data_offset;
+ iter->pSize = (char*)iter->pData + iter->pos->size_offset;
return notwrapped;
}
unsigned start = iter->field_index;
do {
- if (iter->current->tag == tag)
+ if (iter->pos->tag == tag)
return true;
pb_field_next(iter);
} while (iter->field_index != start);
* Decode a single field *
*************************/
-static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t 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->pos->type;
+ func = PB_DECODERS[PB_LTYPE(type)];
+
+ switch (PB_HTYPE(type))
{
case PB_HTYPE_REQUIRED:
- return func(stream, iter->current, iter->pData);
+ return func(stream, iter->pos, iter->pData);
case PB_HTYPE_OPTIONAL:
*(bool*)iter->pSize = true;
- return func(stream, iter->current, iter->pData);
+ return func(stream, iter->pos, 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;
+ bool status = true;
size_t *size = (size_t*)iter->pSize;
pb_istream_t substream;
if (!pb_make_string_substream(stream, &substream))
return false;
- while (substream.bytes_left && *size < iter->current->array_size)
+ while (substream.bytes_left && *size < iter->pos->array_size)
{
- void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
- if (!func(&substream, iter->current, pItem))
- return false;
+ void *pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size);
+ if (!func(&substream, iter->pos, pItem))
+ {
+ status = false;
+ break;
+ }
(*size)++;
}
- status = (substream.bytes_left == 0);
pb_close_string_substream(stream, &substream);
+
+ if (substream.bytes_left != 0)
+ PB_RETURN_ERROR(stream, "array overflow");
+
return status;
}
else
{
/* 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)
+ void *pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size);
+ if (*size >= iter->pos->array_size)
PB_RETURN_ERROR(stream, "array overflow");
(*size)++;
- return func(stream, iter->current, pItem);
+ return func(stream, iter->pos, pItem);
}
+
+ default:
+ PB_RETURN_ERROR(stream, "invalid field type");
+ }
+}
+
+static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
+{
+ pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
+
+#ifdef PB_OLD_CALLBACK_STYLE
+ void *arg = pCallback->arg;
+#else
+ void **arg = &(pCallback->arg);
+#endif
+
+ if (pCallback->funcs.decode == NULL)
+ return pb_skip_field(stream, wire_type);
+
+ if (wire_type == PB_WT_STRING)
+ {
+ pb_istream_t substream;
+
+ if (!pb_make_string_substream(stream, &substream))
+ return false;
- case PB_HTYPE_CALLBACK:
+ do
{
- 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_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);
- }
- }
+ if (!pCallback->funcs.decode(&substream, iter->pos, arg))
+ PB_RETURN_ERROR(stream, "callback failed");
+ } while (substream.bytes_left);
+
+ 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->pos, 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->pos->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 size/has fields and apply default values */
do
{
- if (iter.current->tag == 0)
+ pb_type_t type;
+ type = iter.pos->type;
+
+ if (iter.pos->tag == 0)
continue;
- /* Initialize the size field for optional/repeated fields to 0. */
- if (PB_HTYPE(iter.current->type) == PB_HTYPE_OPTIONAL)
+ if (PB_ATYPE(type) == PB_ATYPE_STATIC)
{
- *(bool*)iter.pSize = false;
- }
- else if (PB_HTYPE(iter.current->type) == PB_HTYPE_ARRAY)
- {
- *(size_t*)iter.pSize = 0;
- continue; /* Array is empty, no need to initialize contents */
+ /* 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 field contents to default value */
+ if (PB_LTYPE(iter.pos->type) == PB_LTYPE_SUBMESSAGE)
+ {
+ pb_message_set_to_defaults((const pb_field_t *) iter.pos->ptr, iter.pData);
+ }
+ else if (iter.pos->ptr != NULL)
+ {
+ memcpy(iter.pData, iter.pos->ptr, iter.pos->data_size);
+ }
+ else
+ {
+ memset(iter.pData, 0, iter.pos->data_size);
+ }
}
-
- /* Initialize field contents to default value */
- if (PB_HTYPE(iter.current->type) == PB_HTYPE_CALLBACK)
+ else if (PB_ATYPE(type) == PB_ATYPE_CALLBACK)
{
continue; /* Don't overwrite callback */
}
- else 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);
- }
} while (pb_field_next(&iter));
}
continue;
}
- if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED
+ if (PB_HTYPE(iter.pos->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));
unsigned i;
do {
req_field_count = iter.required_field_index;
- last_type = iter.current->type;
+ last_type = iter.pos->type;
} while (pb_field_next(&iter));
/* Fixup if last field was also required. */
- if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED)
+ if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED && iter.pos->tag)
req_field_count++;
/* Check the whole bytes */
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);
+ if (!pb_decode_varint(stream, &value))
+ return false;
switch (field->data_size)
{
default: PB_RETURN_ERROR(stream, "invalid data_size");
}
- return status;
+ return true;
}
bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
{
int64_t value;
- bool status = pb_decode_svarint(stream, &value);
+ if (!pb_decode_svarint(stream, &value))
+ return false;
switch (field->data_size)
{
default: PB_RETURN_ERROR(stream, "invalid data_size");
}
- return status;
+ return true;
}
bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *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)
+ if (PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
status = pb_decode(&substream, submsg_fields, dest);
else
status = pb_decode_noinit(&substream, submsg_fields, dest);
Code Review / apps / agl-service-can-low-level.git / blobdiff