Add ndpi_serialize_start_of_list/ndpi_serialize_end_of_list to serialize simple lists in JSON

4 files changed, 317 insertions, 112 deletions

diff --git a/example/ndpiReader.c b/example/ndpiReader.c
index 15f5d6f9a..e5dc807b5 100644
--- a/example/ndpiReader.c
+++ b/example/ndpiReader.c
@@ -3079,86 +3079,108 @@ void serializerUnitTest() {
   ndpi_serializer serializer, deserializer;
   int i;
   u_int8_t trace = 0;
+  u_int8_t use_json = 0;
 
-  assert(ndpi_init_serializer(&serializer, ndpi_serialization_format_tlv) != -1);
+  assert(ndpi_init_serializer(&serializer, use_json ? ndpi_serialization_format_json : ndpi_serialization_format_tlv) != -1);
 
   for(i=0; i<16; i++) {
     char kbuf[32], vbuf[32];
-    assert(ndpi_serialize_uint32_uint32(&serializer, i, i*i) != -1);
-
     snprintf(kbuf, sizeof(kbuf), "Hello %d", i);
     snprintf(vbuf, sizeof(vbuf), "World %d", i);
+    assert(ndpi_serialize_uint32_uint32(&serializer, i, i*i) != -1);
     assert(ndpi_serialize_uint32_string(&serializer, i, "Hello") != -1);
     assert(ndpi_serialize_string_string(&serializer, kbuf, vbuf) != -1);
     assert(ndpi_serialize_string_uint32(&serializer, kbuf, i*i) != -1);
     assert(ndpi_serialize_string_float(&serializer,  kbuf, (float)(i*i), "%f") != -1);
   }
 
-  if(trace)
-    printf("Serialization size: %u\n", ndpi_serializer_get_buffer_len(&serializer));
+  if (use_json) {
 
-  assert(ndpi_init_deserializer(&deserializer, &serializer) != -1);
+    assert(ndpi_serialize_start_of_list(&serializer, "List") != -1);
 
-  while(1) {
-    ndpi_serialization_type kt, et;
-    et = ndpi_deserialize_get_item_type(&deserializer, &kt);
+    for(i=0; i<4; i++) {
+      char kbuf[32], vbuf[32];
+      snprintf(kbuf, sizeof(kbuf), "Ignored");
+      snprintf(vbuf, sizeof(vbuf), "Item %d", i);
+      assert(ndpi_serialize_uint32_uint32(&serializer, i, i*i) != -1);
+      assert(ndpi_serialize_string_string(&serializer, kbuf, vbuf) != -1);
+      assert(ndpi_serialize_string_float(&serializer,  kbuf, (float)(i*i), "%f") != -1);
+    }
+    assert(ndpi_serialize_end_of_list(&serializer) != -1);
+    assert(ndpi_serialize_string_string(&serializer, "Last", "Ok") != -1);
 
-    if(et == ndpi_serialization_unknown)
-      break;
-    else {
-      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);
+    if(trace) {
+      u_int32_t buffer_len = 0;
+      char *buffer = ndpi_serializer_get_buffer(&serializer, &buffer_len);
+      printf("%s\n", buffer);
+    }
+
+  } else {
+    if(trace)
+      printf("Serialization size: %u\n", ndpi_serializer_get_buffer_len(&serializer));
+
+    assert(ndpi_init_deserializer(&deserializer, &serializer) != -1);
+
+    while(1) {
+      ndpi_serialization_type kt, et;
+      et = ndpi_deserialize_get_item_type(&deserializer, &kt);
+
+      if(et == ndpi_serialization_unknown)
+        break;
+      else {
+        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;
-          }
+          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);
+          default:
+            printf("Unsupported TLV key type %u\n", kt);
           return;
-      }
-
-      switch(et) {
-      case ndpi_serialization_uint32:
-	assert(ndpi_deserialize_value_uint32(&deserializer, &v32) != -1);
-	if(trace) printf("%u\n", v32);
-	break;
+        }
 
-      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("%s\n", vs.str);
-	  vs.str[vs.str_len] = bkp;
-	}
-	break;
+        switch(et) {
+          case ndpi_serialization_uint32:
+	    assert(ndpi_deserialize_value_uint32(&deserializer, &v32) != -1);
+	    if(trace) printf("%u\n", v32);
+	  break;
+
+          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("%s\n", vs.str);
+	      vs.str[vs.str_len] = bkp;
+	    }
+	  break;
 
-      case ndpi_serialization_float:
-	assert(ndpi_deserialize_value_float(&deserializer, &vf) != -1);
-	if(trace) printf("%f\n", vf);
-	break;
+          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;
+          default:
+	    if (trace) printf("\n");
+            printf("serializerUnitTest: unsupported type %u detected!\n", et);
+          return;
+        }
       }
-    }
 
-    ndpi_deserialize_next(&deserializer);
+      ndpi_deserialize_next(&deserializer);
+    }
   }
 
   ndpi_term_serializer(&serializer);
diff --git a/src/include/ndpi_api.h.in b/src/include/ndpi_api.h.in
index c906968a9..e230f0ce6 100644
--- a/src/include/ndpi_api.h.in
+++ b/src/include/ndpi_api.h.in
@@ -973,6 +973,9 @@ extern "C" {
   int ndpi_serialize_raw_record(ndpi_serializer *_serializer,
 				u_char *record, u_int32_t record_len);
   int ndpi_serialize_end_of_record(ndpi_serializer *serializer);
+  int ndpi_serialize_start_of_list(ndpi_serializer *serializer,
+				   const char *key);
+  int ndpi_serialize_end_of_list(ndpi_serializer *serializer);
   int ndpi_serialize_start_of_block(ndpi_serializer *serializer,
 				    const char *key);
   int ndpi_serialize_end_of_block(ndpi_serializer *serializer);
diff --git a/src/include/ndpi_typedefs.h b/src/include/ndpi_typedefs.h
index 64fd1fc9b..e2b453344 100644
--- a/src/include/ndpi_typedefs.h
+++ b/src/include/ndpi_typedefs.h
@@ -1438,6 +1438,8 @@ typedef enum {
 #define NDPI_SERIALIZER_STATUS_EOR       (1 << 2)
 #define NDPI_SERIALIZER_STATUS_SOB       (1 << 3)
 #define NDPI_SERIALIZER_STATUS_NOT_EMPTY (1 << 4)
+#define NDPI_SERIALIZER_STATUS_LIST      (1 << 5)
+#define NDPI_SERIALIZER_STATUS_SOL       (1 << 6)
 
 typedef struct {
   u_int32_t flags;
diff --git a/src/lib/ndpi_serializer.c b/src/lib/ndpi_serializer.c
index d8a0d13fc..5c4807eb6 100644
--- a/src/lib/ndpi_serializer.c
+++ b/src/lib/ndpi_serializer.c
@@ -522,13 +522,22 @@ static inline void ndpi_serialize_json_pre(ndpi_serializer *_serializer) {
     serializer->buffer[serializer->status.size_used++] = '{';
   } else {
     if(serializer->status.flags & NDPI_SERIALIZER_STATUS_ARRAY)
-      serializer->status.size_used--; /* Remove ']'*/
-    serializer->status.size_used--; /* Remove '}'*/
+      serializer->status.size_used--; /* Remove ']' */
 
-    if(serializer->status.flags & NDPI_SERIALIZER_STATUS_SOB)
-      serializer->status.flags &= ~NDPI_SERIALIZER_STATUS_SOB;
-    else if(serializer->status.flags & NDPI_SERIALIZER_STATUS_COMMA)
-      serializer->buffer[serializer->status.size_used++] = ',';
+    serializer->status.size_used--; /* Remove '}' */
+
+    if(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST) {
+      serializer->status.size_used--; /* Remove ']' */
+      if(serializer->status.flags & NDPI_SERIALIZER_STATUS_SOL)
+        serializer->status.flags &= ~NDPI_SERIALIZER_STATUS_SOL;
+      else 
+        serializer->buffer[serializer->status.size_used++] = ',';
+    } else {
+      if(serializer->status.flags & NDPI_SERIALIZER_STATUS_SOB)
+        serializer->status.flags &= ~NDPI_SERIALIZER_STATUS_SOB;
+      else if(serializer->status.flags & NDPI_SERIALIZER_STATUS_COMMA)
+        serializer->buffer[serializer->status.size_used++] = ',';
+    }
   }
 }
 
@@ -537,7 +546,11 @@ static inline void ndpi_serialize_json_pre(ndpi_serializer *_serializer) {
 static inline void ndpi_serialize_json_post(ndpi_serializer *_serializer) {
   ndpi_private_serializer *serializer = (ndpi_private_serializer*)_serializer;
 
+  if(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)
+    serializer->buffer[serializer->status.size_used++] = ']';
+
   serializer->buffer[serializer->status.size_used++] = '}';
+
   if(serializer->status.flags & NDPI_SERIALIZER_STATUS_ARRAY)
     serializer->buffer[serializer->status.size_used++] = ']';
 
@@ -585,8 +598,18 @@ int ndpi_serialize_uint32_uint32(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      "\"%u\":%u", key, value);
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += snprintf((char *)
+        &serializer->buffer[serializer->status.size_used], 
+        buff_diff, "\"%u\":", key);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *)
+      &serializer->buffer[serializer->status.size_used], 
+      buff_diff, "%u", value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -639,8 +662,18 @@ int ndpi_serialize_uint32_uint64(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      "\"%u\":%llu", key, (unsigned long long)value);
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += snprintf((char *) 
+        &serializer->buffer[serializer->status.size_used], buff_diff,
+        "\"%u\":", key);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *) 
+      &serializer->buffer[serializer->status.size_used], buff_diff,
+      "%llu", (unsigned long long)value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -691,8 +724,18 @@ int ndpi_serialize_uint32_int32(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      "\"%u\":%d", key, value);
+    
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += snprintf((char *)
+        &serializer->buffer[serializer->status.size_used], 
+        buff_diff, "\"%u\":", key);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *)
+      &serializer->buffer[serializer->status.size_used], 
+      buff_diff, "%d", value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -745,8 +788,18 @@ int ndpi_serialize_uint32_int64(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      "\"%u\":%lld", key, (long long int)value);
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += snprintf((char *) 
+        &serializer->buffer[serializer->status.size_used], 
+        buff_diff, "\"%u\":", key);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *) 
+      &serializer->buffer[serializer->status.size_used], 
+      buff_diff, "%lld", (long long int)value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -800,8 +853,14 @@ int ndpi_serialize_uint32_float(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, "\"%u\":", key);
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, "\"%u\":", key);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, format, value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, "%s",
@@ -849,9 +908,12 @@ static int ndpi_serialize_uint32_binary(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      "\"%u\":", key);
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], 
+        buff_diff, "\"%u\":", key);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
     serializer->status.size_used += ndpi_json_string_escape(value, slen,
 						     (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
     buff_diff = serializer->buffer_size - serializer->status.size_used;
@@ -905,8 +967,18 @@ int ndpi_serialize_uint32_boolean(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      "\"%u\":%s", key, value ? "true" : "false");
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += snprintf((char *) 
+        &serializer->buffer[serializer->status.size_used], 
+        buff_diff, "\"%u\":", key);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *) 
+      &serializer->buffer[serializer->status.size_used], 
+      buff_diff, "%s", value ? "true" : "false");
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -947,11 +1019,19 @@ static int ndpi_serialize_binary_int32(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += ndpi_json_string_escape(key, klen,
-						     (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      ":%d", value);
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += ndpi_json_string_escape(key, klen,
+        (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+      serializer->status.size_used += snprintf((char *) 
+        &serializer->buffer[serializer->status.size_used], buff_diff, ":");
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+    
+    serializer->status.size_used += snprintf((char *) 
+      &serializer->buffer[serializer->status.size_used], buff_diff, "%d", value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -1013,11 +1093,21 @@ int ndpi_serialize_binary_int64(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += ndpi_json_string_escape(key, klen,
-						     (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      ":%lld", (long long int)value);
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += ndpi_json_string_escape(key, klen,
+        (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+      serializer->status.size_used += snprintf((char *) 
+        &serializer->buffer[serializer->status.size_used], buff_diff,
+        ":");
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *) 
+      &serializer->buffer[serializer->status.size_used], buff_diff,
+      "%lld", (long long int)value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -1072,11 +1162,22 @@ static int ndpi_serialize_binary_uint32(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += ndpi_json_string_escape(key, klen,
-						     (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      ":%u", value);
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += ndpi_json_string_escape(key, klen,
+      (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+
+      serializer->status.size_used += snprintf((char *) 
+        &serializer->buffer[serializer->status.size_used],
+        buff_diff, ":");
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *) 
+      &serializer->buffer[serializer->status.size_used],
+      buff_diff, "%u", value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -1159,11 +1260,21 @@ static int ndpi_serialize_binary_uint64(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += ndpi_json_string_escape(key, klen,
-						     (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
-				      ":%llu", (unsigned long long)value);
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += ndpi_json_string_escape(key, klen,
+        (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+      serializer->status.size_used += snprintf((char *) 
+        &serializer->buffer[serializer->status.size_used], buff_diff,
+        ":");
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *) 
+      &serializer->buffer[serializer->status.size_used], buff_diff,
+      "%llu", (unsigned long long)value);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -1221,12 +1332,14 @@ static int ndpi_serialize_binary_float(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += ndpi_json_string_escape(key, klen,
-						     (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
 
-    serializer->buffer[serializer->status.size_used] = ':';
-    serializer->status.size_used++;
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += ndpi_json_string_escape(key, klen,
+        (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+      serializer->buffer[serializer->status.size_used] = ':';
+      serializer->status.size_used++;
+    }
 
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, format, value);
 
@@ -1287,11 +1400,14 @@ static int ndpi_serialize_binary_raw(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += ndpi_json_string_escape(key, klen,
-						     (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, ":");
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += ndpi_json_string_escape(key, klen,
+        (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+      serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, ":");
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
 
     if (escape)
       serializer->status.size_used += ndpi_json_string_escape(value, vlen,
@@ -1299,6 +1415,7 @@ static int ndpi_serialize_binary_raw(ndpi_serializer *_serializer,
     else
       serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
         value, vlen);
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -1383,11 +1500,20 @@ int ndpi_serialize_string_boolean(ndpi_serializer *_serializer,
 
   if(serializer->fmt == ndpi_serialization_format_json) {
     ndpi_serialize_json_pre(_serializer);
-    serializer->status.size_used += ndpi_json_string_escape(key, klen,
-						     (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
-    buff_diff = serializer->buffer_size - serializer->status.size_used;
-    serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, ":%s",
+
+    if (!(serializer->status.flags & NDPI_SERIALIZER_STATUS_LIST)) {
+      serializer->status.size_used += ndpi_json_string_escape(key, klen,
+        (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+      serializer->status.size_used += snprintf((char *)
+        &serializer->buffer[serializer->status.size_used], buff_diff, ":");
+      buff_diff = serializer->buffer_size - serializer->status.size_used;
+    }
+
+    serializer->status.size_used += snprintf((char *)
+      &serializer->buffer[serializer->status.size_used], buff_diff, "%s",
       value ? "true" : "false");
+
     ndpi_serialize_json_post(_serializer);
   } else if(serializer->fmt == ndpi_serialization_format_csv) {
     serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff,
@@ -1401,6 +1527,58 @@ int ndpi_serialize_string_boolean(ndpi_serializer *_serializer,
 
 /* ********************************** */
 
+/* Serialize start of simple list (JSON only)*/
+int ndpi_serialize_start_of_list(ndpi_serializer *_serializer,
+				  const char *key) {
+  ndpi_private_serializer *serializer = (ndpi_private_serializer*)_serializer;
+  u_int32_t buff_diff = serializer->buffer_size - serializer->status.size_used;
+  u_int32_t needed, klen = strlen(key);
+
+  if(serializer->fmt != ndpi_serialization_format_json)
+    return(-1);
+
+  needed = 16 + klen;
+
+  if(buff_diff < needed) {
+    if(ndpi_extend_serializer_buffer(_serializer, needed - buff_diff) < 0)
+      return(-1);
+    buff_diff = serializer->buffer_size - serializer->status.size_used;
+  }
+
+  ndpi_serialize_json_pre(_serializer);
+
+  serializer->status.size_used += ndpi_json_string_escape(key, klen,
+    (char *) &serializer->buffer[serializer->status.size_used], buff_diff);
+  buff_diff = serializer->buffer_size - serializer->status.size_used;
+
+  serializer->status.size_used += snprintf((char *) &serializer->buffer[serializer->status.size_used], buff_diff, ": [");
+
+  serializer->status.flags |= NDPI_SERIALIZER_STATUS_LIST | NDPI_SERIALIZER_STATUS_SOL;
+
+  ndpi_serialize_json_post(_serializer);
+
+  return(0);
+}
+
+/* ********************************** */
+
+/* Serialize start of simple list (JSON only)*/
+int ndpi_serialize_end_of_list(ndpi_serializer *_serializer) {
+  ndpi_private_serializer *serializer = (ndpi_private_serializer*)_serializer;
+
+  if(serializer->fmt != ndpi_serialization_format_json)
+    return(-1);
+
+  if(serializer->status.flags & NDPI_SERIALIZER_STATUS_SOL) /* Empty list */
+    serializer->status.flags &= ~NDPI_SERIALIZER_STATUS_SOL;
+
+  serializer->status.flags &= ~NDPI_SERIALIZER_STATUS_LIST;
+
+  return(0);
+}
+
+/* ********************************** */
+
 /* Serialize start of nested block (JSON only)*/
 int ndpi_serialize_start_of_block(ndpi_serializer *_serializer,
 				  const char *key) {
@@ -1434,7 +1612,7 @@ int ndpi_serialize_start_of_block(ndpi_serializer *_serializer,
 
 /* ********************************** */
 
-/* Serialize start of nested block (JSON only)*/
+/* Serialize end of nested block (JSON only)*/
 int ndpi_serialize_end_of_block(ndpi_serializer *_serializer) {
   ndpi_private_serializer *serializer = (ndpi_private_serializer*)_serializer;
   u_int32_t buff_diff = serializer->buffer_size - serializer->status.size_used;