aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--example/ndpiReader.c74
-rw-r--r--src/include/ndpi_api.h39
-rw-r--r--src/include/ndpi_typedefs.h34
-rw-r--r--src/lib/ndpi_serializer.c787
4 files changed, 449 insertions, 485 deletions
diff --git a/example/ndpiReader.c b/example/ndpiReader.c
index 5998a37b5..479586369 100644
--- a/example/ndpiReader.c
+++ b/example/ndpiReader.c
@@ -3418,7 +3418,8 @@ void serializerUnitTest() {
assert(ndpi_init_deserializer(&deserializer, &serializer) != -1);
while(1) {
- ndpi_serialization_element_type et = ndpi_deserialize_get_nextitem_type(&deserializer);
+ ndpi_serialization_type kt, et;
+ et = ndpi_deserialize_get_item_type(&deserializer, &kt);
if(et == ndpi_serialization_unknown)
break;
@@ -3426,63 +3427,56 @@ void serializerUnitTest() {
u_int32_t k32, v32;
ndpi_string ks, vs;
float vf;
-
+
+ switch(kt) {
+ case ndpi_serialization_uint32:
+ ndpi_deserialize_key_uint32(&deserializer, &k32);
+ if(trace) printf("%u=", k32);
+ break;
+ case ndpi_serialization_string:
+ ndpi_deserialize_key_string(&deserializer, &ks);
+ if (trace) {
+ u_int8_t bkp = ks.str[ks.str_len];
+ ks.str[ks.str_len] = '\0';
+ printf("%s=", ks.str);
+ ks.str[ks.str_len] = bkp;
+ }
+ break;
+ default:
+ printf("Unsupported TLV key type %u\n", kt);
+ return;
+ }
+
switch(et) {
- case ndpi_serialization_uint32_uint32:
- assert(ndpi_deserialize_uint32_uint32(&deserializer, &k32, &v32) != -1);
- if(trace) printf("%u=%u\n", k32, v32);
+ case ndpi_serialization_uint32:
+ assert(ndpi_deserialize_value_uint32(&deserializer, &v32) != -1);
+ if(trace) printf("%u\n", v32);
break;
- case ndpi_serialization_uint32_string:
- assert(ndpi_deserialize_uint32_string(&deserializer, &k32, &vs) != -1);
+ case ndpi_serialization_string:
+ assert(ndpi_deserialize_value_string(&deserializer, &vs) != -1);
if(trace) {
u_int8_t bkp = vs.str[vs.str_len];
-
vs.str[vs.str_len] = '\0';
- printf("%u=%s\n", k32, vs.str);
+ printf("%s\n", vs.str);
vs.str[vs.str_len] = bkp;
}
break;
- case ndpi_serialization_string_string:
- assert(ndpi_deserialize_string_string(&deserializer, &ks, &vs) != -1);
- if(trace) {
- u_int8_t bkpk = ks.str[ks.str_len], bkp = vs.str[vs.str_len];
-
- ks.str[ks.str_len] = vs.str[vs.str_len] = '\0';
- printf("%s=%s\n", ks.str, vs.str);
- ks.str[ks.str_len] = bkpk, vs.str[vs.str_len] = bkp;
- }
- break;
-
- case ndpi_serialization_string_uint32:
- assert(ndpi_deserialize_string_uint32(&deserializer, &ks, &v32) != -1);
- if(trace) {
- u_int8_t bkpk = ks.str[ks.str_len];
-
- ks.str[ks.str_len] = '\0';
- printf("%s=%u\n", ks.str, v32);
- ks.str[ks.str_len] = bkpk;
- }
- break;
-
- case ndpi_serialization_string_float:
- assert(ndpi_deserialize_string_float(&deserializer, &ks, &vf) != -1);
- if(trace) {
- u_int8_t bkpk = ks.str[ks.str_len];
-
- ks.str[ks.str_len] = '\0';
- printf("%s=%f\n", ks.str, vf);
- ks.str[ks.str_len] = bkpk;
- }
+ case ndpi_serialization_float:
+ assert(ndpi_deserialize_value_float(&deserializer, &vf) != -1);
+ if(trace) printf("%f\n", vf);
break;
default:
+ if (trace) printf("\n");
printf("serializerUnitTest: unsupported type %u detected!\n", et);
return;
break;
}
}
+
+ ndpi_deserialize_next(&deserializer);
}
ndpi_term_serializer(&serializer);
diff --git a/src/include/ndpi_api.h b/src/include/ndpi_api.h
index 03b26e808..b9252fcca 100644
--- a/src/include/ndpi_api.h
+++ b/src/include/ndpi_api.h
@@ -867,33 +867,18 @@ extern "C" {
u_int8_t *serialized_buffer,
u_int32_t serialized_buffer_len);
- ndpi_serialization_element_type ndpi_deserialize_get_nextitem_type(ndpi_deserializer *deserializer);
-
- int ndpi_deserialize_uint32_uint32(ndpi_deserializer *deserializer,
- u_int32_t *key, u_int32_t *value);
- int ndpi_deserialize_uint32_uint64(ndpi_deserializer *deserializer,
- u_int32_t *key, u_int64_t *value);
- int ndpi_deserialize_uint32_int32(ndpi_deserializer *deserializer,
- u_int32_t *key, int32_t *value);
- int ndpi_deserialize_uint32_int64(ndpi_deserializer *deserializer,
- u_int32_t *key, int64_t *value);
- int ndpi_deserialize_uint32_float(ndpi_deserializer *deserializer,
- u_int32_t *key, float *value);
- int ndpi_deserialize_uint32_string(ndpi_deserializer *deserializer,
- u_int32_t *key, ndpi_string *value);
- int ndpi_deserialize_string_int32(ndpi_deserializer *deserializer,
- ndpi_string *key, int32_t *value);
- int ndpi_deserialize_string_int64(ndpi_deserializer *deserializer,
- ndpi_string *key, int64_t *value);
- int ndpi_deserialize_string_uint32(ndpi_deserializer *deserializer,
- ndpi_string *key, u_int32_t *value);
- int ndpi_deserialize_string_uint64(ndpi_deserializer *deserializer,
- ndpi_string *key, u_int64_t *value);
- int ndpi_deserialize_string_string(ndpi_deserializer *deserializer,
- ndpi_string *key, ndpi_string *value);
- int ndpi_deserialize_string_float(ndpi_deserializer *deserializer,
- ndpi_string *key, float *value);
- int ndpi_deserialize_end_of_record(ndpi_deserializer *deserializer);
+ ndpi_serialization_type ndpi_deserialize_get_item_type(ndpi_deserializer *deserializer, ndpi_serialization_type *key_type);
+ int ndpi_deserialize_next(ndpi_deserializer *deserializer);
+
+ int ndpi_deserialize_key_uint32(ndpi_deserializer *deserializer, u_int32_t *key);
+ int ndpi_deserialize_key_string(ndpi_deserializer *deserializer, ndpi_string *key);
+
+ int ndpi_deserialize_value_uint32(ndpi_deserializer *deserializer, u_int32_t *value);
+ int ndpi_deserialize_value_uint64(ndpi_deserializer *deserializer, u_int64_t *value);
+ int ndpi_deserialize_value_int32(ndpi_deserializer *deserializer, int32_t *value);
+ int ndpi_deserialize_value_int64(ndpi_deserializer *deserializer, int64_t *value);
+ int ndpi_deserialize_value_float(ndpi_deserializer *deserializer, float *value);
+ int ndpi_deserialize_value_string(ndpi_deserializer *deserializer, ndpi_string *value);
/* Data analysis */
struct ndpi_analyze_struct* ndpi_alloc_data_analysis(u_int16_t _max_series_len);
diff --git a/src/include/ndpi_typedefs.h b/src/include/ndpi_typedefs.h
index 163bdd053..57d985ebf 100644
--- a/src/include/ndpi_typedefs.h
+++ b/src/include/ndpi_typedefs.h
@@ -1343,29 +1343,17 @@ typedef enum {
typedef enum {
ndpi_serialization_unknown = 0,
ndpi_serialization_end_of_record,
- ndpi_serialization_uint32_uint32,
- ndpi_serialization_uint32_uint64,
- ndpi_serialization_uint32_string,
- ndpi_serialization_string_int32,
- ndpi_serialization_string_int64,
- ndpi_serialization_string_uint32,
- ndpi_serialization_string_uint64,
- ndpi_serialization_string_float,
- ndpi_serialization_string_string,
- ndpi_serialization_uint32_int32,
- ndpi_serialization_uint32_int64,
- ndpi_serialization_uint32_float,
-
- /* 32/64 bit types are automatically encoded/decoded as 8/16 bit */
- ndpi_serialization_uint32_uint16,
- ndpi_serialization_uint32_uint8,
- ndpi_serialization_uint32_int16,
- ndpi_serialization_uint32_int8,
- ndpi_serialization_string_uint16,
- ndpi_serialization_string_uint8,
- ndpi_serialization_string_int16,
- ndpi_serialization_string_int8
-} ndpi_serialization_element_type;
+ ndpi_serialization_uint8,
+ ndpi_serialization_uint16,
+ ndpi_serialization_uint32,
+ ndpi_serialization_uint64,
+ ndpi_serialization_int8,
+ ndpi_serialization_int16,
+ ndpi_serialization_int32,
+ ndpi_serialization_int64,
+ ndpi_serialization_float,
+ ndpi_serialization_string
+} ndpi_serialization_type;
#define NDPI_SERIALIZER_STATUS_COMMA (1 << 0)
#define NDPI_SERIALIZER_STATUS_ARRAY (1 << 1)
diff --git a/src/lib/ndpi_serializer.c b/src/lib/ndpi_serializer.c
index 7dad241ec..8f9278410 100644
--- a/src/lib/ndpi_serializer.c
+++ b/src/lib/ndpi_serializer.c
@@ -309,85 +309,73 @@ static void ndpi_serialize_single_string(ndpi_private_serializer *serializer,
/* ********************************** */
static void ndpi_deserialize_single_uint8(ndpi_private_deserializer *deserializer,
- u_int8_t *s) {
- *s = (*((u_int8_t *) &deserializer->buffer[deserializer->size_used]));
- deserializer->size_used += sizeof(u_int8_t);
+ u_int32_t offset, u_int8_t *s) {
+ *s = (*((u_int8_t *) &deserializer->buffer[offset]));
}
/* ********************************** */
static void ndpi_deserialize_single_uint16(ndpi_private_deserializer *deserializer,
- u_int16_t *s) {
- *s = ntohs(*((u_int16_t *) &deserializer->buffer[deserializer->size_used]));
- deserializer->size_used += sizeof(u_int16_t);
+ u_int32_t offset, u_int16_t *s) {
+ *s = ntohs(*((u_int16_t *) &deserializer->buffer[offset]));
}
/* ********************************** */
static void ndpi_deserialize_single_uint32(ndpi_private_deserializer *deserializer,
- u_int32_t *s) {
- *s = ntohl(*((u_int32_t *) &deserializer->buffer[deserializer->size_used]));
- deserializer->size_used += sizeof(u_int32_t);
+ u_int32_t offset, u_int32_t *s) {
+ *s = ntohl(*((u_int32_t *) &deserializer->buffer[offset]));
}
/* ********************************** */
static void ndpi_deserialize_single_int8(ndpi_private_deserializer *deserializer,
- int8_t *s) {
- *s = (*((int8_t *) &deserializer->buffer[deserializer->size_used]));
- deserializer->size_used += sizeof(int8_t);
+ u_int32_t offset, int8_t *s) {
+ *s = (*((int8_t *) &deserializer->buffer[offset]));
}
/* ********************************** */
static void ndpi_deserialize_single_int16(ndpi_private_deserializer *deserializer,
- int16_t *s) {
- *s = ntohs(*((int16_t *) &deserializer->buffer[deserializer->size_used]));
- deserializer->size_used += sizeof(int16_t);
+ u_int32_t offset, int16_t *s) {
+ *s = ntohs(*((int16_t *) &deserializer->buffer[offset]));
}
/* ********************************** */
static void ndpi_deserialize_single_int32(ndpi_private_deserializer *deserializer,
- int32_t *s) {
- *s = ntohl(*((int32_t *) &deserializer->buffer[deserializer->size_used]));
- deserializer->size_used += sizeof(int32_t);
+ u_int32_t offset, int32_t *s) {
+ *s = ntohl(*((int32_t *) &deserializer->buffer[offset]));
}
/* ********************************** */
static void ndpi_deserialize_single_uint64(ndpi_private_deserializer *deserializer,
- u_int64_t *s) {
- *s = ndpi_ntohll(*(u_int64_t*)&deserializer->buffer[deserializer->size_used]);
- deserializer->size_used += sizeof(u_int64_t);
+ u_int32_t offset, u_int64_t *s) {
+ *s = ndpi_ntohll(*(u_int64_t*)&deserializer->buffer[offset]);
}
/* ********************************** */
static void ndpi_deserialize_single_int64(ndpi_private_deserializer *deserializer,
- int64_t *s) {
- *s = ndpi_ntohll(*(int64_t*)&deserializer->buffer[deserializer->size_used]);
- deserializer->size_used += sizeof(int64_t);
+ u_int32_t offset, int64_t *s) {
+ *s = ndpi_ntohll(*(int64_t*)&deserializer->buffer[offset]);
}
/* ********************************** */
/* TODO: fix portability across platforms */
static void ndpi_deserialize_single_float(ndpi_private_deserializer *deserializer,
- float *s) {
- *s = *(float*)&deserializer->buffer[deserializer->size_used];
- deserializer->size_used += sizeof(float);
+ u_int32_t offset, float *s) {
+ *s = *(float*)&deserializer->buffer[offset];
}
/* ********************************** */
-static void ndpi_deserialize_single_string(ndpi_private_deserializer *deserializer,
- ndpi_string *v) {
- v->str_len = ntohs(*((u_int16_t *) &deserializer->buffer[deserializer->size_used]));
- deserializer->size_used += sizeof(u_int16_t);
-
- v->str = (char *) &deserializer->buffer[deserializer->size_used];
- deserializer->size_used += v->str_len;
+static inline void ndpi_deserialize_single_string(ndpi_private_deserializer *deserializer,
+ u_int32_t offset, ndpi_string *v) {
+ v->str_len = ntohs(*((u_int16_t *) &deserializer->buffer[offset]));
+ v->str = (char *) &deserializer->buffer[offset + sizeof(u_int16_t)];
}
/* ********************************** */
@@ -455,6 +443,25 @@ static void ndpi_serialize_json_post(ndpi_serializer *_serializer) {
/* ********************************** */
+static inline ndpi_serialization_type ndpi_serialize_key_uint32(ndpi_private_serializer *serializer, u_int32_t key) {
+ ndpi_serialization_type kt;
+
+ if (key <= 0xff) {
+ ndpi_serialize_single_uint8(serializer, key);
+ kt = ndpi_serialization_uint8;
+ } else if (key <= 0xffff) {
+ ndpi_serialize_single_uint16(serializer, key);
+ kt = ndpi_serialization_uint16;
+ } else {
+ ndpi_serialize_single_uint32(serializer, key);
+ kt = ndpi_serialization_uint32;
+ }
+
+ return kt;
+}
+
+/* ********************************** */
+
int ndpi_serialize_uint32_uint32(ndpi_serializer *_serializer,
u_int32_t key, u_int32_t value) {
ndpi_private_serializer *serializer = (ndpi_private_serializer*)_serializer;
@@ -482,19 +489,25 @@ int ndpi_serialize_uint32_uint32(ndpi_serializer *_serializer,
serializer->size_used += snprintf((char *) &serializer->buffer[serializer->size_used], buff_diff,
"%s%u", (serializer->size_used > 0) ? serializer->csv_separator : "", value);
} else {
+ ndpi_serialization_type kt;
+ u_int8_t type = 0;
+ u_int32_t type_offset = serializer->size_used++;
+
+ kt = ndpi_serialize_key_uint32(serializer, key);
+ type = (kt << 4);
+
if (value <= 0xff) {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_uint8;
- ndpi_serialize_single_uint32(serializer, key);
ndpi_serialize_single_uint8(serializer, value);
+ type |= ndpi_serialization_uint8;
} else if (value <= 0xffff) {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_uint16;
- ndpi_serialize_single_uint32(serializer, key);
ndpi_serialize_single_uint16(serializer, value);
+ type |= ndpi_serialization_uint16;
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_uint32;
- ndpi_serialize_single_uint32(serializer, key);
ndpi_serialize_single_uint32(serializer, value);
+ type |= ndpi_serialization_uint32;
}
+
+ serializer->buffer[type_offset] = type;
}
return(0);
@@ -534,9 +547,17 @@ int ndpi_serialize_uint32_uint64(ndpi_serializer *_serializer,
if (value <= 0xffffffff) {
return(ndpi_serialize_uint32_uint32(_serializer, key, value));
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_uint64;
- ndpi_serialize_single_uint32(serializer, key);
+ ndpi_serialization_type kt;
+ u_int8_t type = 0;
+ u_int32_t type_offset = serializer->size_used++;
+
+ kt = ndpi_serialize_key_uint32(serializer, key);
+ type = (kt << 4);
+
ndpi_serialize_single_uint64(serializer, value);
+ type |= ndpi_serialization_uint64;
+
+ serializer->buffer[type_offset] = type;
}
}
@@ -572,19 +593,25 @@ int ndpi_serialize_uint32_int32(ndpi_serializer *_serializer,
serializer->size_used += snprintf((char *) &serializer->buffer[serializer->size_used], buff_diff,
"%s%d", (serializer->size_used > 0) ? serializer->csv_separator : "", value);
} else {
+ ndpi_serialization_type kt;
+ u_int8_t type = 0;
+ u_int32_t type_offset = serializer->size_used++;
+
+ kt = ndpi_serialize_key_uint32(serializer, key);
+ type = (kt << 4);
+
if (value <= 127 && value >= -128) {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_int8;
- ndpi_serialize_single_uint32(serializer, key);
ndpi_serialize_single_uint8(serializer, value);
+ type |= ndpi_serialization_int8;
} else if (value <= 32767 && value >= -32768) {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_int16;
- ndpi_serialize_single_uint32(serializer, key);
ndpi_serialize_single_uint16(serializer, value);
+ type |= ndpi_serialization_int16;
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_int32;
- ndpi_serialize_single_uint32(serializer, key);
ndpi_serialize_single_uint32(serializer, value);
+ type |= ndpi_serialization_int32;
}
+
+ serializer->buffer[type_offset] = type;
}
return(0);
@@ -625,9 +652,17 @@ int ndpi_serialize_uint32_int64(ndpi_serializer *_serializer,
if (value <= 2147483647 && value >= -2147483648) {
return(ndpi_serialize_uint32_int32(_serializer, key, value));
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_int64;
- ndpi_serialize_single_uint32(serializer, key);
+ ndpi_serialization_type kt;
+ u_int8_t type = 0;
+ u_int32_t type_offset = serializer->size_used++;
+
+ kt = ndpi_serialize_key_uint32(serializer, key);
+ type = (kt << 4);
+
ndpi_serialize_single_uint64(serializer, value);
+ type |= ndpi_serialization_int64;
+
+ serializer->buffer[type_offset] = type;
}
}
@@ -666,10 +701,17 @@ int ndpi_serialize_uint32_float(ndpi_serializer *_serializer,
serializer->size_used += snprintf((char *) &serializer->buffer[serializer->size_used], buff_diff, format, value);
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_float;
+ ndpi_serialization_type kt;
+ u_int8_t type = 0;
+ u_int32_t type_offset = serializer->size_used++;
+
+ kt = ndpi_serialize_key_uint32(serializer, key);
+ type = (kt << 4);
- ndpi_serialize_single_uint32(serializer, key);
ndpi_serialize_single_float(serializer, value);
+ type |= ndpi_serialization_float;
+
+ serializer->buffer[type_offset] = type;
}
return(0);
@@ -711,10 +753,17 @@ int ndpi_serialize_uint32_string(ndpi_serializer *_serializer,
serializer->size_used += snprintf((char *) &serializer->buffer[serializer->size_used], buff_diff,
"%s%s", (serializer->size_used > 0) ? serializer->csv_separator : "", value);
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_uint32_string;
+ ndpi_serialization_type kt;
+ u_int8_t type = 0;
+ u_int32_t type_offset = serializer->size_used++;
+
+ kt = ndpi_serialize_key_uint32(serializer, key);
+ type = (kt << 4);
- ndpi_serialize_single_uint32(serializer, key);
ndpi_serialize_single_string(serializer, value, slen);
+ type |= ndpi_serialization_string;
+
+ serializer->buffer[type_offset] = type;
}
return(0);
@@ -760,15 +809,15 @@ int ndpi_serialize_string_int32(ndpi_serializer *_serializer,
"%s%d", (serializer->size_used > 0) ? serializer->csv_separator : "", value);
} else {
if (value <= 127 && value >= -128) {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_int8;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_int8;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_uint8(serializer, value);
} else if (value <= 32767 && value >= -32768) {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_int16;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_int16;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_uint16(serializer, value);
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_int32;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_int32;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_uint32(serializer, value);
}
@@ -820,7 +869,7 @@ int ndpi_serialize_string_int64(ndpi_serializer *_serializer,
if (value <= 2147483647 && value >= -2147483648) {
return(ndpi_serialize_string_int32(_serializer, key, value));
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_int64;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_int64;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_uint32(serializer, value);
}
@@ -869,15 +918,15 @@ int ndpi_serialize_string_uint32(ndpi_serializer *_serializer,
"%s%u", (serializer->size_used > 0) ? serializer->csv_separator : "", value);
} else {
if (value <= 0xff) {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_uint8;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_uint8;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_uint8(serializer, value);
} else if (value <= 0xffff) {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_uint16;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_uint16;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_uint16(serializer, value);
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_uint32;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_uint32;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_uint32(serializer, value);
}
@@ -947,7 +996,7 @@ int ndpi_serialize_string_uint64(ndpi_serializer *_serializer,
if (value <= 0xffffffff) {
return(ndpi_serialize_string_uint32(_serializer, key, value));
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_uint64;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_uint64;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_uint64(serializer, value);
}
@@ -1002,7 +1051,7 @@ int ndpi_serialize_string_float(ndpi_serializer *_serializer,
serializer->size_used += snprintf((char *) &serializer->buffer[serializer->size_used], buff_diff, format, value);
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_float;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_float;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_float(serializer, value);
@@ -1057,7 +1106,7 @@ int ndpi_serialize_string_binary(ndpi_serializer *_serializer,
"%s%s", (serializer->size_used > 0) ? serializer->csv_separator : "",
value);
} else {
- serializer->buffer[serializer->size_used++] = ndpi_serialization_string_string;
+ serializer->buffer[serializer->size_used++] = (ndpi_serialization_string << 4) | ndpi_serialization_string;
ndpi_serialize_single_string(serializer, key, klen);
ndpi_serialize_single_string(serializer, value, vlen);
@@ -1109,196 +1158,189 @@ int ndpi_init_deserializer(ndpi_deserializer *deserializer,
/* ********************************** */
-static inline ndpi_serialization_element_type ndpi_deserialize_get_nextitem_subtype(ndpi_private_deserializer *deserializer) {
- ndpi_serialization_element_type et;
-
- if(deserializer->size_used >= deserializer->buffer_size)
+static inline ndpi_serialization_type ndpi_deserialize_get_key_subtype(ndpi_private_deserializer *deserializer) {
+ u_int8_t type;
+
+ if (deserializer->size_used >= deserializer->buffer_size)
+ return ndpi_serialization_unknown;
+
+ type = deserializer->buffer[deserializer->size_used];
+
+ return (ndpi_serialization_type) (type >> 4);
+}
+
+/* ********************************** */
+
+static inline ndpi_serialization_type ndpi_deserialize_get_value_subtype(ndpi_private_deserializer *deserializer) {
+ u_int8_t type;
+
+ if (deserializer->size_used >= deserializer->buffer_size)
return(ndpi_serialization_unknown);
- et = (ndpi_serialization_element_type) deserializer->buffer[deserializer->size_used];
+ type = deserializer->buffer[deserializer->size_used];
- return et;
+ return (ndpi_serialization_type) (type & 0xf);
}
/* ********************************** */
-ndpi_serialization_element_type ndpi_deserialize_get_nextitem_type(ndpi_deserializer *_deserializer) {
+ndpi_serialization_type ndpi_deserialize_get_item_type(ndpi_deserializer *_deserializer, ndpi_serialization_type *key_type) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- ndpi_serialization_element_type et = ndpi_deserialize_get_nextitem_subtype(deserializer);
-
- switch(et) {
- case ndpi_serialization_uint32_uint16:
- case ndpi_serialization_uint32_uint8:
- et = ndpi_serialization_uint32_uint32;
+ ndpi_serialization_type kt, et;
+
+ /* Note: 32/64 bit types are automatically encoded/decoded as 8/16 bit */
+
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
+
+ switch(kt) {
+ case ndpi_serialization_uint8:
+ case ndpi_serialization_uint16:
+ kt = ndpi_serialization_uint32;
break;
- case ndpi_serialization_string_uint16:
- case ndpi_serialization_string_uint8:
- et = ndpi_serialization_string_uint32;
+ default:
break;
- case ndpi_serialization_uint32_int16:
- case ndpi_serialization_uint32_int8:
- et = ndpi_serialization_uint32_int32;
+ }
+
+ et = ndpi_deserialize_get_value_subtype(deserializer);
+
+ switch(et) {
+ case ndpi_serialization_uint8:
+ case ndpi_serialization_uint16:
+ et = ndpi_serialization_uint32;
break;
- case ndpi_serialization_string_int16:
- case ndpi_serialization_string_int8:
- et = ndpi_serialization_string_int32;
+ case ndpi_serialization_int8:
+ case ndpi_serialization_int16:
+ et = ndpi_serialization_int32;
break;
default:
break;
}
+ *key_type = kt;
return et;
}
/* ********************************** */
-int ndpi_deserialize_end_of_record(ndpi_deserializer *_deserializer) {
- ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
-
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) == ndpi_serialization_end_of_record) {
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- u_int16_t expected =
- sizeof(u_int8_t) /* type */;
+static inline int ndpi_deserialize_get_single_string_size(ndpi_private_deserializer *deserializer, u_int32_t offset) {
+ u_int32_t buff_diff = deserializer->buffer_size - offset;
+ u_int16_t expected, str_len;
- if(buff_diff < expected) return(-2);
+ expected = sizeof(u_int16_t) /* len */;
+ if (buff_diff < expected) return -2;
- deserializer->size_used++; /* Skip element type */
+ str_len = ntohs(*((u_int16_t *) &deserializer->buffer[offset]));
- return(0);
- } else
- return(-1);
+ expected += str_len;
+ if (buff_diff < expected) return -2;
+
+ return expected;
}
/* ********************************** */
-int ndpi_deserialize_uint32_uint32(ndpi_deserializer *_deserializer,
- u_int32_t *key, u_int32_t *value) {
- ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- ndpi_serialization_element_type et = ndpi_deserialize_get_nextitem_subtype(deserializer);
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- u_int16_t v16;
- u_int8_t v8;
- u_int16_t expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int32_t) /* key */;
+static inline int ndpi_deserialize_get_single_size(ndpi_private_deserializer *deserializer, ndpi_serialization_type type, u_int32_t offset) {
+ u_int16_t size;
- switch(et) {
- case ndpi_serialization_uint32_uint32:
- expected += sizeof(u_int32_t);
- break;
- case ndpi_serialization_uint32_uint16:
- expected += sizeof(u_int16_t);
+ switch(type) {
+ case ndpi_serialization_uint8:
+ case ndpi_serialization_int8:
+ size = sizeof(u_int8_t);
break;
- case ndpi_serialization_uint32_uint8:
- expected += sizeof(u_int8_t);
+ case ndpi_serialization_uint16:
+ case ndpi_serialization_int16:
+ size = sizeof(u_int16_t);
break;
- default:
- return -1;
+ case ndpi_serialization_uint32:
+ case ndpi_serialization_int32:
+ size = sizeof(u_int32_t);
break;
- }
-
- if(buff_diff < expected) return(-2);
-
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_uint32(deserializer, key);
-
- switch(et) {
- case ndpi_serialization_uint32_uint32:
- ndpi_deserialize_single_uint32(deserializer, value);
+ case ndpi_serialization_uint64:
+ case ndpi_serialization_int64:
+ size = sizeof(u_int64_t);
break;
- case ndpi_serialization_uint32_uint16:
- ndpi_deserialize_single_uint16(deserializer, &v16);
- *value = v16;
+ case ndpi_serialization_float:
+ size = sizeof(float);
break;
- case ndpi_serialization_uint32_uint8:
- ndpi_deserialize_single_uint8(deserializer, &v8);
- *value = v8;
+ case ndpi_serialization_string:
+ size = ndpi_deserialize_get_single_string_size(deserializer, offset);
break;
default:
+ return -2;
break;
}
- return 0;
+ return size;
}
/* ********************************** */
-int ndpi_deserialize_uint32_uint64(ndpi_deserializer *_deserializer,
- u_int32_t *key, u_int64_t *value) {
- ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- u_int32_t buff_diff;
+int ndpi_deserialize_next(ndpi_deserializer *_deserializer) {
+ ndpi_private_deserializer *deserializer = (ndpi_private_deserializer *) _deserializer;
+ u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
+ ndpi_serialization_type kt, et;
u_int16_t expected;
- u_int32_t v32;
- int rc;
+ int size;
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) != ndpi_serialization_uint32_uint64) {
- /* Try with smaller uint types */
- rc = ndpi_deserialize_uint32_uint32(_deserializer, key, &v32);
- *value = v32;
- return rc;
- }
+ expected = sizeof(u_int8_t) /* type */;
- buff_diff = deserializer->buffer_size - deserializer->size_used;
- expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int32_t) /* key */ +
- sizeof(u_int64_t);
+ if (buff_diff < expected) return -2;
- if(buff_diff < expected) return(-2);
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_uint32(deserializer, key);
- ndpi_deserialize_single_uint64(deserializer, value);
+ if (size < 0) return -2;
- return(0);
+ expected += size;
+
+ et = ndpi_deserialize_get_value_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, et, deserializer->size_used + expected);
+
+ if (size < 0) return -2;
+
+ expected += size;
+
+ deserializer->size_used += expected;
+
+ return 0;
}
/* ********************************** */
-int ndpi_deserialize_uint32_int32(ndpi_deserializer *_deserializer,
- u_int32_t *key, int32_t *value) {
+int ndpi_deserialize_key_uint32(ndpi_deserializer *_deserializer,
+ u_int32_t *key) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- ndpi_serialization_element_type et = ndpi_deserialize_get_nextitem_subtype(deserializer);
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- int16_t v16;
- int8_t v8;
- u_int16_t expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int32_t) /* key */;
+ u_int32_t offset, buff_diff = deserializer->buffer_size - deserializer->size_used;
+ ndpi_serialization_type kt;
+ u_int16_t expected;
+ u_int16_t v16;
+ u_int8_t v8;
+ int size;
- switch(et) {
- case ndpi_serialization_uint32_int32:
- expected += sizeof(int32_t);
- break;
- case ndpi_serialization_uint32_int16:
- expected += sizeof(int16_t);
- break;
- case ndpi_serialization_uint32_int8:
- expected += sizeof(int8_t);
- break;
- default:
- return -1;
- break;
- }
+ expected = sizeof(u_int8_t) /* type */;
+ if (buff_diff < expected) return -2;
- if(buff_diff < expected) return(-2);
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_uint32(deserializer, key);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
+ if (size < 0) return -2;
- switch(et) {
- case ndpi_serialization_uint32_int32:
- ndpi_deserialize_single_int32(deserializer, value);
+ offset = deserializer->size_used + expected;
+
+ switch(kt) {
+ case ndpi_serialization_uint32:
+ ndpi_deserialize_single_uint32(deserializer, offset, key);
break;
- case ndpi_serialization_uint32_int16:
- ndpi_deserialize_single_int16(deserializer, &v16);
- *value = v16;
+ case ndpi_serialization_uint16:
+ ndpi_deserialize_single_uint16(deserializer, offset, &v16);
+ *key = v16;
break;
- case ndpi_serialization_uint32_int8:
- ndpi_deserialize_single_int8(deserializer, &v8);
- *value = v8;
+ case ndpi_serialization_uint8:
+ ndpi_deserialize_single_uint8(deserializer, offset, &v8);
+ *key = v8;
break;
default:
+ return -1;
break;
}
@@ -1307,127 +1349,64 @@ int ndpi_deserialize_uint32_int32(ndpi_deserializer *_deserializer,
/* ********************************** */
-int ndpi_deserialize_uint32_int64(ndpi_deserializer *_deserializer,
- u_int32_t *key, int64_t *value) {
+int ndpi_deserialize_key_string(ndpi_deserializer *_deserializer,
+ ndpi_string *key) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- u_int32_t buff_diff;
+ ndpi_serialization_type kt;
+ u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
u_int16_t expected;
- int32_t v32;
- int rc;
-
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) != ndpi_serialization_uint32_int64) {
- /* Try with smaller int types */
- rc = ndpi_deserialize_uint32_int32(_deserializer, key, &v32);
- *value = v32;
- return rc;
- }
-
- buff_diff = deserializer->buffer_size - deserializer->size_used;
- expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int32_t) /* key */ +
- sizeof(int64_t);
-
- if(buff_diff < expected) return(-2);
+ int size;
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_uint32(deserializer, key);
- ndpi_deserialize_single_int64(deserializer, value);
+ expected = sizeof(u_int8_t) /* type */;
+ if (buff_diff < expected) return -2;
- return(0);
-}
-
-/* ********************************** */
-
-int ndpi_deserialize_uint32_float(ndpi_deserializer *_deserializer,
- u_int32_t *key, float *value) {
- ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
-
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) == ndpi_serialization_uint32_float) {
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- u_int16_t expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int32_t) /* key */ +
- sizeof(float);
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
- if(buff_diff < expected) return(-2);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
+ if (size < 0) return -2;
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_uint32(deserializer, key);
- ndpi_deserialize_single_float(deserializer, value);
+ ndpi_deserialize_single_string(deserializer, deserializer->size_used + expected, key);
- return(0);
- } else
- return(-1);
+ return 0;
}
/* ********************************** */
-int ndpi_deserialize_uint32_string(ndpi_deserializer *_deserializer,
- u_int32_t *key, ndpi_string *value) {
+int ndpi_deserialize_value_uint32(ndpi_deserializer *_deserializer,
+ u_int32_t *value) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
-
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) == ndpi_serialization_uint32_string) {
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- u_int32_t expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int32_t) /* key */ +
- sizeof(u_int16_t) /* len */;
+ ndpi_serialization_type kt, et;
+ u_int32_t offset, buff_diff = deserializer->buffer_size - deserializer->size_used;
+ u_int16_t v16;
+ u_int8_t v8;
+ u_int16_t expected;
+ int size;
- if(buff_diff < expected) return(-2);
+ expected = sizeof(u_int8_t) /* type */;
+ if (buff_diff < expected) return -2;
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_uint32(deserializer, key);
- ndpi_deserialize_single_string(deserializer, value);
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
+ if (size < 0) return -2;
- return(0);
- } else
- return(-1);
-}
+ expected += size;
-/* ********************************** */
+ et = ndpi_deserialize_get_value_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, et, deserializer->size_used + expected);
+ if (size < 0) return -2;
-int ndpi_deserialize_string_int32(ndpi_deserializer *_deserializer,
- ndpi_string *key, int32_t *value) {
- ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- ndpi_serialization_element_type et = ndpi_deserialize_get_nextitem_subtype(deserializer);
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- int16_t v16;
- int8_t v8;
- u_int16_t expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int32_t) /* key */;
-
- switch(et) {
- case ndpi_serialization_string_int32:
- expected += sizeof(int32_t);
- break;
- case ndpi_serialization_string_int16:
- expected += sizeof(int16_t);
- break;
- case ndpi_serialization_string_int8:
- expected += sizeof(int8_t);
- break;
- default:
- return -1;
- break;
- }
-
- if(buff_diff < expected) return(-2);
-
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_string(deserializer, key);
+ offset = deserializer->size_used + expected;
switch(et) {
- case ndpi_serialization_string_int32:
- ndpi_deserialize_single_int32(deserializer, value);
+ case ndpi_serialization_uint32:
+ ndpi_deserialize_single_uint32(deserializer, offset, value);
break;
- case ndpi_serialization_string_int16:
- ndpi_deserialize_single_int16(deserializer, &v16);
+ case ndpi_serialization_uint16:
+ ndpi_deserialize_single_uint16(deserializer, offset, &v16);
*value = v16;
break;
- case ndpi_serialization_string_int8:
- ndpi_deserialize_single_int8(deserializer, &v8);
+ case ndpi_serialization_uint8:
+ ndpi_deserialize_single_uint8(deserializer, offset, &v8);
*value = v8;
break;
default:
@@ -1439,79 +1418,78 @@ int ndpi_deserialize_string_int32(ndpi_deserializer *_deserializer,
/* ********************************** */
-int ndpi_deserialize_string_int64(ndpi_deserializer *_deserializer,
- ndpi_string *key, int64_t *value) {
+int ndpi_deserialize_value_uint64(ndpi_deserializer *_deserializer,
+ u_int64_t *value) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- u_int32_t buff_diff;
+ ndpi_serialization_type kt, et;
+ u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
+ u_int32_t v32;
u_int16_t expected;
- int32_t v32;
- int rc;
+ int size;
+ int rc;
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) != ndpi_serialization_string_int64) {
- /* Try with smaller int types */
- rc = ndpi_deserialize_string_int32(_deserializer, key, &v32);
+ expected = sizeof(u_int8_t) /* type */;
+ if (buff_diff < expected) return -2;
+
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
+ if (size < 0) return -2;
+
+ expected += size;
+
+ et = ndpi_deserialize_get_value_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, et, deserializer->size_used + expected);
+ if (size < 0) return -2;
+
+ if(et != ndpi_serialization_uint64) {
+ /* Try with smaller uint types */
+ rc = ndpi_deserialize_value_uint32(_deserializer, &v32);
*value = v32;
return rc;
}
- buff_diff = deserializer->buffer_size - deserializer->size_used;
- expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int16_t) /* key len */ +
- sizeof(int64_t);
-
- if(buff_diff < expected) return(-2);
-
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_string(deserializer, key);
- ndpi_deserialize_single_int64(deserializer, value);
+ ndpi_deserialize_single_uint64(deserializer, deserializer->size_used + expected, value);
- return(0);
+ return 0;
}
/* ********************************** */
-int ndpi_deserialize_string_uint32(ndpi_deserializer *_deserializer,
- ndpi_string *key, u_int32_t *value) {
+int ndpi_deserialize_value_int32(ndpi_deserializer *_deserializer,
+ int32_t *value) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- ndpi_serialization_element_type et = ndpi_deserialize_get_nextitem_subtype(deserializer);
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- u_int16_t v16;
- u_int8_t v8;
- u_int16_t expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int32_t) /* key */;
+ ndpi_serialization_type kt, et;
+ u_int32_t offset, buff_diff = deserializer->buffer_size - deserializer->size_used;
+ int16_t v16;
+ int8_t v8;
+ u_int16_t expected;
+ int size;
- switch(et) {
- case ndpi_serialization_string_uint32:
- expected += sizeof(u_int32_t);
- break;
- case ndpi_serialization_string_uint16:
- expected += sizeof(u_int16_t);
- break;
- case ndpi_serialization_string_uint8:
- expected += sizeof(u_int8_t);
- break;
- default:
- return -1;
- break;
- }
+ expected = sizeof(u_int8_t) /* type */;
+ if (buff_diff < expected) return -2;
+
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
+ if (size < 0) return -2;
+
+ expected += size;
- if(buff_diff < expected) return(-2);
+ et = ndpi_deserialize_get_value_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, et, deserializer->size_used + expected);
+ if (size < 0) return -2;
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_string(deserializer, key);
+ offset = deserializer->size_used + expected;
switch(et) {
- case ndpi_serialization_string_uint32:
- ndpi_deserialize_single_uint32(deserializer, value);
+ case ndpi_serialization_int32:
+ ndpi_deserialize_single_int32(deserializer, offset, value);
break;
- case ndpi_serialization_string_uint16:
- ndpi_deserialize_single_uint16(deserializer, &v16);
+ case ndpi_serialization_int16:
+ ndpi_deserialize_single_int16(deserializer, offset, &v16);
*value = v16;
break;
- case ndpi_serialization_string_uint8:
- ndpi_deserialize_single_uint8(deserializer, &v8);
+ case ndpi_serialization_int8:
+ ndpi_deserialize_single_int8(deserializer, offset, &v8);
*value = v8;
break;
default:
@@ -1523,82 +1501,101 @@ int ndpi_deserialize_string_uint32(ndpi_deserializer *_deserializer,
/* ********************************** */
-int ndpi_deserialize_string_uint64(ndpi_deserializer *_deserializer,
- ndpi_string *key, u_int64_t *value) {
+int ndpi_deserialize_value_int64(ndpi_deserializer *_deserializer,
+ int64_t *value) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
- u_int32_t buff_diff;
+ ndpi_serialization_type kt, et;
+ u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
+ int32_t v32;
u_int16_t expected;
- u_int32_t v32;
- int rc;
+ int size;
+ int rc;
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) != ndpi_serialization_string_uint64) {
- /* Try with smaller uint types */
- rc = ndpi_deserialize_string_uint32(_deserializer, key, &v32);
+ expected = sizeof(u_int8_t) /* type */;
+ if (buff_diff < expected) return(-2);
+
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
+ if (size < 0) return -2;
+
+ expected += size;
+
+ et = ndpi_deserialize_get_value_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, et, deserializer->size_used + expected);
+ if (size < 0) return -2;
+
+ if(et != ndpi_serialization_int64) {
+ /* Try with smaller int types */
+ rc = ndpi_deserialize_value_int32(_deserializer, &v32);
*value = v32;
return rc;
}
- buff_diff = deserializer->buffer_size - deserializer->size_used;
- expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int16_t) /* key len */ +
- sizeof(u_int64_t);
-
- if(buff_diff < expected) return(-2);
+ ndpi_deserialize_single_int64(deserializer, deserializer->size_used + expected, value);
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_string(deserializer, key);
- ndpi_deserialize_single_uint64(deserializer, value);
-
- return(0);
+ return 0;
}
/* ********************************** */
-int ndpi_deserialize_string_float(ndpi_deserializer *_deserializer,
- ndpi_string *key, float *value) {
+int ndpi_deserialize_value_float(ndpi_deserializer *_deserializer,
+ float *value) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
-
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) == ndpi_serialization_string_float) {
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- u_int32_t expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int16_t) /* key len */ +
- sizeof(float);
+ ndpi_serialization_type kt, et;
+ u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
+ u_int16_t expected;
+ int size;
- if(buff_diff < expected) return(-2);
+ expected = sizeof(u_int8_t) /* type */;
+ if (buff_diff < expected) return(-2);
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_string(deserializer, key);
- ndpi_deserialize_single_float(deserializer, value);
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
+ if (size < 0) return -2;
- return(0);
- } else
- return(-1);
+ expected += size;
+
+ et = ndpi_deserialize_get_value_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, et, deserializer->size_used + expected);
+ if (size < 0) return -2;
+
+ if(et != ndpi_serialization_float)
+ return -1;
+
+ ndpi_deserialize_single_float(deserializer, deserializer->size_used + expected, value);
+
+ return 0;
}
/* ********************************** */
-int ndpi_deserialize_string_string(ndpi_deserializer *_deserializer,
- ndpi_string *key, ndpi_string *value) {
+int ndpi_deserialize_value_string(ndpi_deserializer *_deserializer,
+ ndpi_string *value) {
ndpi_private_deserializer *deserializer = (ndpi_private_deserializer*)_deserializer;
-
- if(ndpi_deserialize_get_nextitem_subtype(deserializer) == ndpi_serialization_string_string) {
- u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
- u_int32_t expected =
- sizeof(u_int8_t) /* type */ +
- sizeof(u_int16_t) /* key len */ +
- sizeof(u_int16_t) /* len */;
+ ndpi_serialization_type kt, et;
+ u_int32_t buff_diff = deserializer->buffer_size - deserializer->size_used;
+ u_int16_t expected;
+ int size;
- if(buff_diff < expected) return(-2);
+ expected = sizeof(u_int8_t) /* type */;
+ if (buff_diff < expected) return(-2);
- deserializer->size_used++; /* Skip element type */
- ndpi_deserialize_single_string(deserializer, key);
- ndpi_deserialize_single_string(deserializer, value);
+ kt = ndpi_deserialize_get_key_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, kt, deserializer->size_used + expected);
+ if (size < 0) return -2;
- return(0);
- } else
- return(-1);
+ expected += size;
+
+ et = ndpi_deserialize_get_value_subtype(deserializer);
+ size = ndpi_deserialize_get_single_size(deserializer, et, deserializer->size_used + expected);
+ if (size < 0) return -2;
+
+ if(et != ndpi_serialization_string)
+ return -1;
+
+ ndpi_deserialize_single_string(deserializer, deserializer->size_used + expected, value);
+
+ return 0;
}
/* ********************************** */
Powered by cgit, Themed by Ted Yin.