/* Find type, and use decode function according to type */
type = keyval_get_type_from_encoded_byte(p_r);
- if (keyval_type_is_array(type))
+ if (keyval_type_is_array(type)) {
bytes_read = keyval_array_decode(p_r,
- (keyval_array_t **) &kv);
- else
- bytes_read = keyval_decode(p_r, &kv);
+ (keyval_array_t **)&kv,
+ d_r + d_len - 1 - p_r);
+ } else {
+ bytes_read = keyval_decode(p_r, &kv,
+ d_r + d_len - 1 - p_r);
+ }
if (kv)
_bundle_append_kv(b, kv);
/* Find type, and use decode function according to type */
type = keyval_get_type_from_encoded_byte(p_r);
- if (keyval_type_is_array(type))
+ if (keyval_type_is_array(type)) {
bytes_read = keyval_array_decode(p_r,
- (keyval_array_t **) &kv);
- else
- bytes_read = keyval_decode(p_r, &kv);
+ (keyval_array_t **)&kv,
+ d_r + d_len - 1 - p_r);
+ } else {
+ bytes_read = keyval_decode(p_r, &kv,
+ d_r + d_len - 1 - p_r);
+ }
if (kv)
_bundle_append_kv(b, kv);
type = keyval_get_type_from_encoded_byte(byte);
if (keyval_type_is_array(type)) {
- if (keyval_array_decode(byte, &kva) == 0) /* TODO: error! */
+ if (keyval_array_decode(byte, &kva, byte_size) == 0) /* TODO: error! */
BUNDLE_EXCEPTION_PRINT("Unable to Decode array\n");
kv = (keyval_t *)kva;
} else {
- if (keyval_decode(byte, &kv) == 0) /* TODO: error! */
+ if (keyval_decode(byte, &kv, byte_size) == 0) /* TODO: error! */
BUNDLE_EXCEPTION_PRINT("Unable to Decode\n");
}
_bundle_append_kv(b, kv);
* If kv is not NULL, given kv is used. (No new kv is created.)
* @return Number of bytes read from byte.
*/
-size_t keyval_decode(unsigned char *byte, keyval_t **kv)
+size_t keyval_decode(unsigned char *byte, keyval_t **kv, size_t byte_size)
{
static const size_t sz_byte_len = sizeof(size_t);
static const size_t sz_type = sizeof(int);
unsigned char *p = byte;
byte_len = *((size_t *)p);
+
+ if (byte_size < sz_byte_len)
+ return 0;
+
+ byte_size -= sz_byte_len;
p += sz_byte_len;
type = *((int *)p);
+
+ if (byte_size < sz_type)
+ return 0;
+
+ byte_size -= sz_type;
p += sz_type;
keysize = *((size_t *)p);
+
+ if (byte_size < sz_keysize)
+ return 0;
+
+ byte_size -= sz_keysize;
p += sz_keysize;
key = (char *)p;
+
+ if (byte_size < keysize)
+ return 0;
+
+ byte_size -= keysize;
p += keysize;
size = *((size_t *)p);
+
+ if (byte_size < sz_size)
+ return 0;
+
+ byte_size -= sz_size;
p += sz_size;
val = (void *)p;
p += size;
int keyval_compare(keyval_t *kv1, keyval_t *kv2);
size_t keyval_get_encoded_size(keyval_t *kv);
size_t keyval_encode(keyval_t *kv, unsigned char **byte, size_t *byte_len);
-size_t keyval_decode(unsigned char *byte, keyval_t **kv);
+size_t keyval_decode(unsigned char *byte, keyval_t **kv, size_t byte_size);
int keyval_get_data(keyval_t *kv, int *type, void **val, size_t *size);
int keyval_get_type_from_encoded_byte(unsigned char *byte);
return *byte_len;
}
-size_t keyval_array_decode(void *byte, keyval_array_t **kva)
+size_t keyval_array_decode(void *byte, keyval_array_t **kva, size_t byte_size)
{
static const size_t sz_byte_len = sizeof(size_t);
static const size_t sz_type = sizeof(int);
/* Get data */
byte_len = *((size_t *)p);
+
+ if (byte_size < sz_byte_len)
+ return 0;
+
+ byte_size -= sz_byte_len;
p += sz_byte_len;
type = *((int *)p);
+
+ if (byte_size < sz_type)
+ return 0;
+
+ byte_size -= sz_type;
p += sz_type;
keysize = *((size_t *)p);
+
+ if (byte_size < sz_keysize)
+ return 0;
+
+ byte_size -= sz_keysize;
p += sz_keysize;
key = (char *)p;
+
+ if (byte_size < keysize)
+ return 0;
+
+ byte_size -= keysize;
p += keysize;
len = *((unsigned int *)p);
+
+ if (byte_size < sz_len)
+ return 0;
+
+ byte_size -= sz_len;
p += sz_len;
array_element_size = (size_t *)p;
+
+ if (byte_size < (sizeof(size_t) * len))
+ return 0;
+
p += sizeof(size_t) * len;
array_val = (void *)p;
int keyval_array_compare(keyval_array_t *kva1, keyval_array_t *kva2);
size_t keyval_array_get_encoded_size(keyval_array_t *kva);
size_t keyval_array_encode(keyval_array_t *kva, void **byte, size_t *byte_len);
-size_t keyval_array_decode(void *byte, keyval_array_t **kva);
+size_t keyval_array_decode(void *byte, keyval_array_t **kva, size_t byte_size);
int keyval_array_copy_array(keyval_array_t *kva, void **array_val,
unsigned int array_len, size_t (*measure_val_len)(void * val));
int keyval_array_get_data(keyval_array_t *kva, int *type, void ***array_val,