size_t cbor_serialize_alloc(const cbor_item_t * item,
unsigned char ** buffer,
size_t * buffer_size)
{
size_t bfr_size = 32;
unsigned char * bfr = _CBOR_MALLOC(bfr_size), * tmp_bfr;
if (bfr == NULL) {
return 0;
}
size_t written;
/* This is waaay too optimistic - figure out something smarter (eventually) */
while ((written = cbor_serialize(item, bfr, bfr_size)) == 0) {
if (!_cbor_safe_to_multiply(CBOR_BUFFER_GROWTH, bfr_size)) {
_CBOR_FREE(bfr);
return 0;
}
tmp_bfr = _CBOR_REALLOC(bfr, bfr_size *= 2);
if (tmp_bfr == NULL) {
_CBOR_FREE(bfr);
return 0;
}
bfr = tmp_bfr;
}
*buffer = bfr;
*buffer_size = bfr_size;
return written;
}
size_t cbor_serialize_array(const cbor_item_t *item, unsigned char *buffer, size_t buffer_size)
{
assert(cbor_isa_array(item));
size_t size = cbor_array_size(item),
written = 0;
cbor_item_t **handle = cbor_array_handle(item);
if (cbor_array_is_definite(item)) {
written = cbor_encode_array_start(size, buffer, buffer_size);
} else {
assert(cbor_array_is_indefinite(item));
written = cbor_encode_indef_array_start(buffer, buffer_size);
}
if (written == 0)
return 0;
size_t item_written;
for (size_t i = 0; i < size; i++) {
item_written = cbor_serialize(*(handle++), buffer + written, buffer_size - written);
if (item_written == 0)
return 0;
else
written += item_written;
}
if (cbor_array_is_definite(item)) {
return written;
} else {
assert(cbor_array_is_indefinite(item));
item_written = cbor_encode_break(buffer + written, buffer_size - written);
if (item_written == 0)
return 0;
else
return written + 1;
}
}
size_t cbor_serialize_map(const cbor_item_t *item, unsigned char *buffer, size_t buffer_size)
{
assert(cbor_isa_map(item));
size_t size = cbor_map_size(item),
written = 0;
struct cbor_pair * handle = cbor_map_handle(item);
if (cbor_map_is_definite(item)) {
written = cbor_encode_map_start(size, buffer, buffer_size);
} else {
assert(cbor_map_is_indefinite(item));
written = cbor_encode_indef_map_start(buffer, buffer_size);
}
if (written == 0)
return 0;
size_t item_written;
for (size_t i = 0; i < size; i++) {
item_written = cbor_serialize(handle->key, buffer + written, buffer_size - written);
if (item_written == 0)
return 0;
else
written += item_written;
item_written = cbor_serialize((handle++)->value, buffer + written, buffer_size - written);
if (item_written == 0)
return 0;
else
written += item_written;
}
if (cbor_map_is_definite(item)) {
return written;
} else {
assert(cbor_map_is_indefinite(item));
item_written = cbor_encode_break(buffer + written, buffer_size - written);
if (item_written == 0)
return 0;
else
return written + 1;
}
}
size_t cbor_serialize_tag(const cbor_item_t *item, unsigned char *buffer, size_t buffer_size)
{
assert(cbor_isa_tag(item));
size_t written = cbor_encode_tag(cbor_tag_value(item), buffer, buffer_size);
if (written == 0)
return 0;
size_t item_written = cbor_serialize(cbor_tag_item(item), buffer + written, buffer_size - written);
if (item_written == 0)
return 0;
else
return written + item_written;
}
static void test_serialize_uint8(void **state)
{
cbor_item_t *item = cbor_new_int8();
cbor_set_uint8(item, 0);
assert_int_equal(1, cbor_serialize(item, buffer, 512));
assert_memory_equal(buffer, (unsigned char[]) {0x00}, 1);
