rik/nanopb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More fixes for dynamic allocation

Browse Source
This commit is contained in:
Petteri Aimonen
2014-03-10 18:19:38 +02:00
parent 48ac461372
commit bf61d2337b
3 changed files with 99 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
pb_decode.c
View File

@@ -472,29 +472,19 @@ static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t
#ifdef PB_ENABLE_MALLOC #ifdef PB_ENABLE_MALLOC
/* Allocate storage for the field and store the pointer at iter->pData. /* Allocate storage for the field and store the pointer at iter->pData.
* array_size is the number of entries to reserve in an array. */ * array_size is the number of entries to reserve in an array. */
static bool checkreturn allocate_field(pb_istream_t *stream, pb_field_iterator_t *iter, size_t array_size) static bool checkreturn allocate_field(pb_istream_t *stream, void *pData, size_t data_size, size_t array_size)
{ {
void *ptr = *(void**)iter->pData; void *ptr = *(void**)pData;
size_t size = array_size * iter->pos->data_size; size_t size = array_size * data_size;
if (ptr == NULL) /* Allocate new or expand previous allocation */
{
/* First allocation */
ptr = malloc(size);
if (ptr == NULL)
PB_RETURN_ERROR(stream, "malloc failed");
}
else
{
/* Expand previous allocation */
/* Note: on failure the old pointer will remain in the structure, /* Note: on failure the old pointer will remain in the structure,
* the message must be freed by caller also on error return. */ * the message must be freed by caller also on error return. */
ptr = realloc(ptr, size); ptr = realloc(ptr, size);
if (ptr == NULL) if (ptr == NULL)
PB_RETURN_ERROR(stream, "realloc failed"); PB_RETURN_ERROR(stream, "realloc failed");
}
*(void**)iter->pData = ptr; *(void**)pData = ptr;
return true; return true;
} }
#endif #endif
@@ -522,7 +512,7 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
} }
else else
{ {
if (!allocate_field(stream, iter, 1)) if (!allocate_field(stream, iter->pData, iter->pos->data_size, 1))
return false; return false;
return func(stream, iter->pos, *(void**)iter->pData); return func(stream, iter->pos, *(void**)iter->pData);
@@ -547,12 +537,11 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
if (*size + 1 > allocated_size) if (*size + 1 > allocated_size)
{ {
/* Allocate more storage. This tries to guess the /* Allocate more storage. This tries to guess the
* number of remaining entries. */ * number of remaining entries. Round the division
allocated_size += substream.bytes_left / iter->pos->data_size; * upwards. */
if (*size + 1 > allocated_size) allocated_size += (substream.bytes_left - 1) / iter->pos->data_size + 1;
allocated_size++; /* Division gave zero. */
if (!allocate_field(&substream, iter, allocated_size)) if (!allocate_field(&substream, iter->pData, iter->pos->data_size, allocated_size))
{ {
status = false; status = false;
break; break;
@@ -560,7 +549,7 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
} }
/* Decode the array entry */ /* Decode the array entry */
pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size); pItem = *(uint8_t**)iter->pData + iter->pos->data_size * (*size);
if (!func(&substream, iter->pos, pItem)) if (!func(&substream, iter->pos, pItem))
{ {
status = false; status = false;
@@ -576,11 +565,26 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
{ {
/* Normal repeated field, i.e. only one item at a time. */ /* Normal repeated field, i.e. only one item at a time. */
size_t *size = (size_t*)iter->pSize; size_t *size = (size_t*)iter->pSize;
void *pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size); void *pItem;
if (!allocate_field(stream, iter, *size + 1)) if (!allocate_field(stream, iter->pData, iter->pos->data_size, *size + 1))
return false; return false;
pItem = *(uint8_t**)iter->pData + iter->pos->data_size * (*size);
/* Clear the new item in case it contains a pointer, or is a submessage. */
if (PB_LTYPE(type) == PB_LTYPE_STRING)
{
*(char**)pItem = NULL;
}
else if (PB_LTYPE(type) == PB_LTYPE_BYTES)
{
memset(pItem, 0, iter->pos->data_size);
}
else if (PB_LTYPE(type) == PB_LTYPE_SUBMESSAGE)
{
pb_message_set_to_defaults((const pb_field_t *) iter->pos->ptr, pItem);
}
(*size)++; (*size)++;
return func(stream, iter->pos, pItem); return func(stream, iter->pos, pItem);
@@ -1025,43 +1029,63 @@ bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, v
} }
bool checkreturn 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;
uint32_t temp;
if (!pb_decode_varint32(stream, &temp))
return false;
x->size = temp;
/* Check length, noting the space taken by the size_t header. */
if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes))
PB_RETURN_ERROR(stream, "bytes overflow");
return pb_read(stream, x->bytes, x->size);
}
bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
{ {
uint32_t size; uint32_t size;
bool status; size_t alloc_size;
if (!pb_decode_varint32(stream, &size)) if (!pb_decode_varint32(stream, &size))
return false; return false;
/* Check length, noting the null terminator */ /* Space for the size_t header */
alloc_size = size + offsetof(pb_bytes_array_t, bytes);
if (PB_ATYPE(field->type) == PB_ATYPE_POINTER) if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
{ {
#ifndef PB_ENABLE_MALLOC #ifndef PB_ENABLE_MALLOC
PB_RETURN_ERROR(stream, "no malloc support"); PB_RETURN_ERROR(stream, "no malloc support");
#else #else
*(void**)dest = realloc(*(void**)dest, size + 1); pb_bytes_ptr_t *bdest = (pb_bytes_ptr_t*)dest;
if (*(void**)dest == NULL) if (!allocate_field(stream, &bdest->bytes, alloc_size, 1))
PB_RETURN_ERROR(stream, "out of memory"); return false;
bdest->size = size;
return pb_read(stream, bdest->bytes, size);
#endif
}
else
{
pb_bytes_array_t* bdest = (pb_bytes_array_t*)dest;
if (alloc_size > field->data_size)
PB_RETURN_ERROR(stream, "bytes overflow");
bdest->size = size;
return pb_read(stream, bdest->bytes, size);
}
}
bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
{
uint32_t size;
size_t alloc_size;
bool status;
if (!pb_decode_varint32(stream, &size))
return false;
/* Space for null terminator */
alloc_size = size + 1;
if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
{
#ifndef PB_ENABLE_MALLOC
PB_RETURN_ERROR(stream, "no malloc support");
#else
if (!allocate_field(stream, dest, alloc_size, 1))
return false;
dest = *(void**)dest; dest = *(void**)dest;
#endif #endif
} }
else else
{ {
if (size + 1 > field->data_size) if (alloc_size > field->data_size)
PB_RETURN_ERROR(stream, "string overflow"); PB_RETURN_ERROR(stream, "string overflow");
} }

1
tests/alltypes_pointer/SConscript
View File

@@ -23,7 +23,6 @@ env.RunTest(enc)
env.RunTest("decode_alltypes.output", [dec, "encode_alltypes_pointer.output"]) env.RunTest("decode_alltypes.output", [dec, "encode_alltypes_pointer.output"])
env.RunTest("decode_alltypes_ref.output", [refdec, "encode_alltypes_pointer.output"]) env.RunTest("decode_alltypes_ref.output", [refdec, "encode_alltypes_pointer.output"])
env.Compare(["encode_alltypes_pointer.output", "$BUILD/alltypes/encode_alltypes.output"]) env.Compare(["encode_alltypes_pointer.output", "$BUILD/alltypes/encode_alltypes.output"])
env.Compare(["encode_alltypes_pointer_ref.output", "$BUILD/alltypes/encode_alltypes.output"])
# Do the same thing with the optional fields present # Do the same thing with the optional fields present
env.RunTest("optionals.output", enc, ARGS = ['1']) env.RunTest("optionals.output", enc, ARGS = ['1'])

46
tests/alltypes_pointer/decode_alltypes_pointer.c
View File

@@ -7,13 +7,14 @@
#define TEST(x) if (!(x)) { \ #define TEST(x) if (!(x)) { \
printf("Test " #x " failed.\n"); \ printf("Test " #x " failed.\n"); \
return false; \ status = false; \
} }
/* This function is called once from main(), it handles /* This function is called once from main(), it handles
the decoding and checks the fields. */ the decoding and checks the fields. */
bool check_alltypes(pb_istream_t *stream, int mode) bool check_alltypes(pb_istream_t *stream, int mode)
{ {
bool status = true;
AllTypes alltypes; AllTypes alltypes;
/* Fill with garbage to better detect initialization errors */ /* Fill with garbage to better detect initialization errors */
@@ -22,28 +23,31 @@ bool check_alltypes(pb_istream_t *stream, int mode)
if (!pb_decode(stream, AllTypes_fields, &alltypes)) if (!pb_decode(stream, AllTypes_fields, &alltypes))
return false; return false;
TEST(*alltypes.req_int32 == -1001); TEST(alltypes.req_int32 && *alltypes.req_int32 == -1001);
TEST(*alltypes.req_int64 == -1002); TEST(alltypes.req_int64 && *alltypes.req_int64 == -1002);
TEST(*alltypes.req_uint32 == 1003); TEST(alltypes.req_uint32 && *alltypes.req_uint32 == 1003);
TEST(*alltypes.req_uint64 == 1004); TEST(alltypes.req_uint64 && *alltypes.req_uint64 == 1004);
TEST(*alltypes.req_sint32 == -1005); TEST(alltypes.req_sint32 && *alltypes.req_sint32 == -1005);
TEST(*alltypes.req_sint64 == -1006); TEST(alltypes.req_sint64 && *alltypes.req_sint64 == -1006);
TEST(*alltypes.req_bool == true); TEST(alltypes.req_bool && *alltypes.req_bool == true);
TEST(*alltypes.req_fixed32 == 1008); TEST(alltypes.req_fixed32 && *alltypes.req_fixed32 == 1008);
TEST(*alltypes.req_sfixed32 == -1009); TEST(alltypes.req_sfixed32 && *alltypes.req_sfixed32 == -1009);
TEST(*alltypes.req_float == 1010.0f); TEST(alltypes.req_float && *alltypes.req_float == 1010.0f);
TEST(*alltypes.req_fixed64 == 1011); TEST(alltypes.req_fixed64 && *alltypes.req_fixed64 == 1011);
TEST(*alltypes.req_sfixed64 == -1012); TEST(alltypes.req_sfixed64 && *alltypes.req_sfixed64 == -1012);
TEST(*alltypes.req_double == 1013.0f); TEST(alltypes.req_double && *alltypes.req_double == 1013.0f);
TEST(strcmp(alltypes.req_string, "1014") == 0); TEST(alltypes.req_string && strcmp(alltypes.req_string, "1014") == 0);
TEST(alltypes.req_bytes->size == 4); TEST(alltypes.req_bytes && alltypes.req_bytes->size == 4);
TEST(memcmp(alltypes.req_bytes->bytes, "1015", 4) == 0); TEST(alltypes.req_bytes && alltypes.req_bytes->bytes
TEST(strcmp(alltypes.req_submsg->substuff1, "1016") == 0); && memcmp(alltypes.req_bytes->bytes, "1015", 4) == 0);
TEST(*alltypes.req_submsg->substuff2 == 1016); TEST(alltypes.req_submsg && alltypes.req_submsg->substuff1
TEST(*alltypes.req_submsg->substuff3 == 3); && strcmp(alltypes.req_submsg->substuff1, "1016") == 0);
TEST(alltypes.req_submsg && alltypes.req_submsg->substuff2
&& *alltypes.req_submsg->substuff2 == 1016);
/* TEST(*alltypes.req_submsg->substuff3 == 3); Default values are not currently supported for pointer fields */
TEST(*alltypes.req_enum == MyEnum_Truth); TEST(*alltypes.req_enum == MyEnum_Truth);
#if 0 #if 0
@@ -180,7 +184,7 @@ bool check_alltypes(pb_istream_t *stream, int mode)
TEST(alltypes.end == 1099); TEST(alltypes.end == 1099);
#endif #endif
return true; return status;
} }
int main(int argc, char **argv) int main(int argc, char **argv)