Adding upstream version 1.16.0.upstream/1.16.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 1033 insertions, 0 deletions

diff --git a/libnetdata/json/Makefile.am b/libnetdata/json/Makefile.am
new file mode 100644
index 000000000..1cb69ed99
--- /dev/null
+++ b/libnetdata/json/Makefile.am
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+AUTOMAKE_OPTIONS = subdir-objects
+MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
+
+
+dist_noinst_DATA = \
+	README.md \
+	$(NULL)
diff --git a/libnetdata/json/README.md b/libnetdata/json/README.md
new file mode 100644
index 000000000..fd6cb0f31
--- /dev/null
+++ b/libnetdata/json/README.md
@@ -0,0 +1,5 @@
+# json
+
+`json` contains a parser for json strings, based on `jsmn` (https://github.com/zserge/jsmn), but case you have installed the JSON-C library, the installation script will prefer it, you can also force its use with `--enable-jsonc` in the compilation time.
+
+[![analytics](https://www.google-analytics.com/collect?v=1&aip=1&t=pageview&_s=1&ds=github&dr=https%3A%2F%2Fgithub.com%2Fnetdata%2Fnetdata&dl=https%3A%2F%2Fmy-netdata.io%2Fgithub%2Flibnetdata%2Fjson%2FREADME&_u=MAC~&cid=5792dfd7-8dc4-476b-af31-da2fdb9f93d2&tid=UA-64295674-3)]()
diff --git a/libnetdata/json/jsmn.c b/libnetdata/json/jsmn.c
new file mode 100644
index 000000000..c8d9e73db
--- /dev/null
+++ b/libnetdata/json/jsmn.c
@@ -0,0 +1,326 @@
+#include <stdlib.h>
+
+#include "jsmn.h"
+
+/**
+ * Alloc token
+ *
+ * Allocates a fresh unused token from the token pull.
+ *
+ * @param parser the controller
+ * @param tokens the tokens I am working
+ * @param num_tokens the number total of tokens.
+ *
+ * @return it returns the next token to work.
+ */
+static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
+                                   jsmntok_t *tokens, size_t num_tokens) {
+    jsmntok_t *tok;
+    if (parser->toknext >= num_tokens) {
+        return NULL;
+    }
+    tok = &tokens[parser->toknext++];
+    tok->start = tok->end = -1;
+    tok->size = 0;
+#ifdef JSMN_PARENT_LINKS
+    tok->parent = -1;
+#endif
+    return tok;
+}
+
+/**
+ * Fill Token
+ *
+ * Fills token type and boundaries.
+ *
+ * @param token the structure to set the values
+ * @param type is the token type
+ * @param start is the first position of the value
+ * @param end is the end of the value
+ */
+static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
+                            int start, int end) {
+    token->type = type;
+    token->start = start;
+    token->end = end;
+    token->size = 0;
+}
+
+/**
+ * Parse primitive
+ *
+ * Fills next available token with JSON primitive.
+ *
+ * @param parser is the control structure
+ * @param js is the json string
+ * @param type is the token type
+ */
+static jsmnerr_t jsmn_parse_primitive(jsmn_parser *parser, const char *js,
+                                      size_t len, jsmntok_t *tokens, size_t num_tokens) {
+    jsmntok_t *token;
+    int start;
+
+    start = parser->pos;
+
+    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+        switch (js[parser->pos]) {
+#ifndef JSMN_STRICT
+            /* In strict mode primitive must be followed by "," or "}" or "]" */
+            case ':':
+#endif
+            case '\t' : case '\r' : case '\n' : case ' ' :
+            case ','  : case ']'  : case '}' :
+                goto found;
+        }
+        if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
+            parser->pos = start;
+            return JSMN_ERROR_INVAL;
+        }
+    }
+#ifdef JSMN_STRICT
+    /* In strict mode primitive must be followed by a comma/object/array */
+	parser->pos = start;
+	return JSMN_ERROR_PART;
+#endif
+
+    found:
+    if (tokens == NULL) {
+        parser->pos--;
+        return 0;
+    }
+    token = jsmn_alloc_token(parser, tokens, num_tokens);
+    if (token == NULL) {
+        parser->pos = start;
+        return JSMN_ERROR_NOMEM;
+    }
+    jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
+#ifdef JSMN_PARENT_LINKS
+    token->parent = parser->toksuper;
+#endif
+    parser->pos--;
+    return 0;
+}
+
+/**
+ * Parse string
+ *
+ * Fills next token with JSON string.
+ *
+ * @param parser is the control structure
+ * @param js is the json string
+ * @param len is the js length
+ * @param tokens is structure with the tokens mapped.
+ * @param num_tokens is the total number of tokens
+ *
+ * @return It returns 0 on success and another integer otherwise
+ */
+static jsmnerr_t jsmn_parse_string(jsmn_parser *parser, const char *js,
+                                   size_t len, jsmntok_t *tokens, size_t num_tokens) {
+    jsmntok_t *token;
+
+    int start = parser->pos;
+
+    parser->pos++;
+
+    /* Skip starting quote */
+    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+        char c = js[parser->pos];
+
+        /* Quote: end of string */
+        if (c == '\"') {
+            if (tokens == NULL) {
+                return 0;
+            }
+            token = jsmn_alloc_token(parser, tokens, num_tokens);
+            if (token == NULL) {
+                parser->pos = start;
+                return JSMN_ERROR_NOMEM;
+            }
+            jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
+#ifdef JSMN_PARENT_LINKS
+            token->parent = parser->toksuper;
+#endif
+            return 0;
+        }
+
+        /* Backslash: Quoted symbol expected */
+        if (c == '\\') {
+            parser->pos++;
+            switch (js[parser->pos]) {
+                /* Allowed escaped symbols */
+                case '\"': case '/' : case '\\' : case 'b' :
+                case 'f' : case 'r' : case 'n'  : case 't' :
+                    break;
+                    /* Allows escaped symbol \uXXXX */
+                case 'u':
+                    parser->pos++;
+                    int i = 0;
+                    for(; i < 4 && js[parser->pos] != '\0'; i++) {
+                        /* If it isn't a hex character we have an error */
+                        if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
+                             (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
+                             (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
+                            parser->pos = start;
+                            return JSMN_ERROR_INVAL;
+                        }
+                        parser->pos++;
+                    }
+                    parser->pos--;
+                    break;
+                    /* Unexpected symbol */
+                default:
+                    parser->pos = start;
+                    return JSMN_ERROR_INVAL;
+            }
+        }
+    }
+    parser->pos = start;
+    return JSMN_ERROR_PART;
+}
+
+/**
+ * JSMN Parse
+ *
+ * Parse JSON string and fill tokens.
+ *
+ * @param parser the auxiliar vector used to parser
+ * @param js the string to parse
+ * @param len the string length
+ * @param tokens the place to map the tokens
+ * @param num_tokens the number of tokens present in the tokens structure.
+ *
+ * @return It returns the number of tokens present in the string on success or a negative number otherwise
+ */
+jsmnerr_t jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
+                     jsmntok_t *tokens, unsigned int num_tokens) {
+    jsmnerr_t r;
+    int i;
+    jsmntok_t *token;
+    int count = 0;
+
+    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+        char c;
+        jsmntype_t type;
+
+        c = js[parser->pos];
+        switch (c) {
+            case '{': case '[':
+                count++;
+                if (tokens == NULL) {
+                    break;
+                }
+                token = jsmn_alloc_token(parser, tokens, num_tokens);
+                if (token == NULL)
+                    return JSMN_ERROR_NOMEM;
+                if (parser->toksuper != -1) {
+                    tokens[parser->toksuper].size++;
+#ifdef JSMN_PARENT_LINKS
+                    token->parent = parser->toksuper;
+#endif
+                }
+                token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
+                token->start = parser->pos;
+                parser->toksuper = parser->toknext - 1;
+                break;
+            case '}': case ']':
+                if (tokens == NULL)
+                    break;
+                type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
+#ifdef JSMN_PARENT_LINKS
+            if (parser->toknext < 1) {
+					return JSMN_ERROR_INVAL;
+				}
+				token = &tokens[parser->toknext - 1];
+				for (;;) {
+					if (token->start != -1 && token->end == -1) {
+						if (token->type != type) {
+							return JSMN_ERROR_INVAL;
+						}
+						token->end = parser->pos + 1;
+						parser->toksuper = token->parent;
+						break;
+					}
+					if (token->parent == -1) {
+						break;
+					}
+					token = &tokens[token->parent];
+				}
+#else
+                for (i = parser->toknext - 1; i >= 0; i--) {
+                    token = &tokens[i];
+                    if (token->start != -1 && token->end == -1) {
+                        if (token->type != type) {
+                            return JSMN_ERROR_INVAL;
+                        }
+                        parser->toksuper = -1;
+                        token->end = parser->pos + 1;
+                        break;
+                    }
+                }
+                /* Error if unmatched closing bracket */
+                if (i == -1) return JSMN_ERROR_INVAL;
+                for (; i >= 0; i--) {
+                    token = &tokens[i];
+                    if (token->start != -1 && token->end == -1) {
+                        parser->toksuper = i;
+                        break;
+                    }
+                }
+#endif
+                break;
+            case '\"':
+                r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
+                if (r < 0) return r;
+                count++;
+                if (parser->toksuper != -1 && tokens != NULL)
+                    tokens[parser->toksuper].size++;
+                break;
+            case '\t' : case '\r' : case '\n' : case ':' : case ',': case ' ':
+                break;
+#ifdef JSMN_STRICT
+            /* In strict mode primitives are: numbers and booleans */
+			case '-': case '0': case '1' : case '2': case '3' : case '4':
+			case '5': case '6': case '7' : case '8': case '9':
+			case 't': case 'f': case 'n' :
+#else
+                /* In non-strict mode every unquoted value is a primitive */
+            default:
+#endif
+                r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
+                if (r < 0) return r;
+                count++;
+                if (parser->toksuper != -1 && tokens != NULL)
+                    tokens[parser->toksuper].size++;
+                break;
+
+#ifdef JSMN_STRICT
+            /* Unexpected char in strict mode */
+			default:
+				return JSMN_ERROR_INVAL;
+#endif
+        }
+    }
+
+    for (i = parser->toknext - 1; i >= 0; i--) {
+        /* Unmatched opened object or array */
+        if (tokens[i].start != -1 && tokens[i].end == -1) {
+            return JSMN_ERROR_PART;
+        }
+    }
+
+    return count;
+}
+
+/**
+ * JSMN Init
+ *
+ * Creates a new parser based over a given  buffer with an array of tokens
+ * available.
+ *
+ * @param parser is the structure with values to reset
+ */
+void jsmn_init(jsmn_parser *parser) {
+    parser->pos = 0;
+    parser->toknext = 0;
+    parser->toksuper = -1;
+}
\ No newline at end of file
diff --git a/libnetdata/json/jsmn.h b/libnetdata/json/jsmn.h
new file mode 100644
index 000000000..beff586c6
--- /dev/null
+++ b/libnetdata/json/jsmn.h
@@ -0,0 +1,75 @@
+#ifndef __JSMN_H_
+#define __JSMN_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+/**
+ * JSON type identifier. Basic types are:
+ * 	o Object
+ * 	o Array
+ * 	o String
+ * 	o Other primitive: number, boolean (true/false) or null
+ */
+typedef enum {
+    JSMN_PRIMITIVE = 0,
+    JSMN_OBJECT = 1,
+    JSMN_ARRAY = 2,
+    JSMN_STRING = 3
+} jsmntype_t;
+
+typedef enum {
+    /* Not enough tokens were provided */
+            JSMN_ERROR_NOMEM = -1,
+    /* Invalid character inside JSON string */
+            JSMN_ERROR_INVAL = -2,
+    /* The string is not a full JSON packet, more bytes expected */
+            JSMN_ERROR_PART = -3,
+} jsmnerr_t;
+
+/**
+ * JSON token description.
+ *
+ * @param		type	type (object, array, string etc.)
+ * @param		start	start position in JSON data string
+ * @param		end		end position in JSON data string
+ */
+typedef struct {
+    jsmntype_t type;
+    int start;
+    int end;
+    int size;
+#ifdef JSMN_PARENT_LINKS
+    int parent;
+#endif
+} jsmntok_t;
+
+/**
+ * JSON parser. Contains an array of token blocks available. Also stores
+ * the string being parsed now and current position in that string
+ */
+typedef struct {
+    unsigned int pos; /* offset in the JSON string */
+    unsigned int toknext; /* next token to allocate */
+    int toksuper; /* superior token node, e.g parent object or array */
+} jsmn_parser;
+
+/**
+ * Create JSON parser over an array of tokens
+ */
+void jsmn_init(jsmn_parser *parser);
+
+/**
+ * Run JSON parser. It parses a JSON data string into and array of tokens, each describing
+ * a single JSON object.
+ */
+jsmnerr_t jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
+                     jsmntok_t *tokens, unsigned int num_tokens);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __JSMN_H_ */
\ No newline at end of file
diff --git a/libnetdata/json/json.c b/libnetdata/json/json.c
new file mode 100644
index 000000000..c9ff39b05
--- /dev/null
+++ b/libnetdata/json/json.c
@@ -0,0 +1,546 @@
+#include "jsmn.h"
+#include "../libnetdata.h"
+#include "json.h"
+#include "libnetdata/libnetdata.h"
+#include "../../health/health.h"
+
+#define JSON_TOKENS 1024
+
+int json_tokens = JSON_TOKENS;
+
+/**
+ * Json Tokenise
+ *
+ * Map the string given inside tokens.
+ *
+ * @param js is the string used to create the tokens
+ * @param len is the string length
+ * @param count the number of tokens present in the string
+ *
+ * @return it returns the json parsed in tokens
+ */
+#ifdef ENABLE_JSONC
+json_object *json_tokenise(char *js) {
+    if(!js) {
+        error("JSON: json string is empty.");
+        return NULL;
+    }
+
+    json_object *token = json_tokener_parse(js);
+    if(!token) {
+        error("JSON: Invalid json string.");
+        return NULL;
+    }
+
+    return token;
+}
+#else
+jsmntok_t *json_tokenise(char *js, size_t len, size_t *count)
+{
+    int n = json_tokens;
+    if(!js || !len) {
+        error("JSON: json string is empty.");
+        return NULL;
+    }
+
+    jsmn_parser parser;
+    jsmn_init(&parser);
+
+    jsmntok_t *tokens = mallocz(sizeof(jsmntok_t) * n);
+    if(!tokens) return NULL;
+
+    int ret = jsmn_parse(&parser, js, len, tokens, n);
+    while (ret == JSMN_ERROR_NOMEM) {
+        n *= 2;
+        jsmntok_t *new = reallocz(tokens, sizeof(jsmntok_t) * n);
+        if(!new) {
+            freez(tokens);
+            return NULL;
+        }
+        tokens = new;
+        ret = jsmn_parse(&parser, js, len, tokens, n);
+    }
+
+    if (ret == JSMN_ERROR_INVAL) {
+        error("JSON: Invalid json string.");
+        freez(tokens);
+        return NULL;
+    }
+    else if (ret == JSMN_ERROR_PART) {
+        error("JSON: Truncated JSON string.");
+        freez(tokens);
+        return NULL;
+    }
+
+    if(count) *count = (size_t)ret;
+
+    if(json_tokens < n) json_tokens = n;
+    return tokens;
+}
+#endif
+
+/**
+ * Callback Print
+ *
+ * Set callback print case necesary and wrinte an information inside a buffer to write in the log.
+ *
+ * @param e a pointer for a structure that has the complete information about json structure.
+ *
+ * @return It always return 0
+ */
+int json_callback_print(JSON_ENTRY *e)
+{
+    BUFFER *wb=buffer_create(300);
+
+    buffer_sprintf(wb,"%s = ", e->name);
+    char txt[50];
+    switch(e->type) {
+        case JSON_OBJECT:
+            e->callback_function = json_callback_print;
+            buffer_strcat(wb,"OBJECT");
+            break;
+
+        case JSON_ARRAY:
+            e->callback_function = json_callback_print;
+            sprintf(txt,"ARRAY[%lu]", e->data.items);
+            buffer_strcat(wb, txt);
+            break;
+
+        case JSON_STRING:
+            buffer_strcat(wb, e->data.string);
+            break;
+
+        case JSON_NUMBER:
+            sprintf(txt,"%Lf", e->data.number);
+            buffer_strcat(wb,txt);
+
+            break;
+
+        case JSON_BOOLEAN:
+            buffer_strcat(wb, e->data.boolean?"TRUE":"FALSE");
+            break;
+
+        case JSON_NULL:
+            buffer_strcat(wb,"NULL");
+            break;
+    }
+    info("JSON: %s", buffer_tostring(wb));
+    buffer_free(wb);
+    return 0;
+}
+
+/**
+ * JSONC Set String
+ *
+ * Set the string value of the structure JSON_ENTRY.
+ *
+ * @param e the output structure
+ */
+static inline void json_jsonc_set_string(JSON_ENTRY *e,char *key,const char *value) {
+    size_t length = strlen(key);
+    e->type = JSON_STRING;
+    memcpy(e->name,key,length);
+    e->name[length] = 0x00;
+    e->data.string = (char *) value;
+}
+
+
+#ifdef ENABLE_JSONC
+/**
+ * JSONC set Boolean
+ *
+ * Set the boolean value of the structure JSON_ENTRY
+ *
+ * @param e the output structure
+ * @param value the input value
+ */
+static inline void json_jsonc_set_boolean(JSON_ENTRY *e,int value) {
+    e->type = JSON_BOOLEAN;
+    e->data.boolean = value;
+}
+
+/**
+ * Parse Array
+ *
+ * Parse the array object.
+ *
+ * @param ptr the pointer for the object that we will parse.
+ * @param callback_data additional data to be used together the callback function
+ * @param callback_function function used to create a silencer.
+ */
+static inline void json_jsonc_parse_array(json_object *ptr, void *callback_data,int (*callback_function)(struct json_entry *)) {
+    int end = json_object_array_length(ptr);
+    JSON_ENTRY e;
+
+    if(end) {
+        int i;
+        i = 0;
+
+        enum json_type type;
+        do {
+            json_object *jvalue =  json_object_array_get_idx(ptr, i);
+            if(jvalue) {
+                e.callback_data = callback_data;
+                e.type = JSON_OBJECT;
+                callback_function(&e);
+                json_object_object_foreach(jvalue, key, val) {
+                    type = json_object_get_type(val);
+                    if (type == json_type_array) {
+                        e.type = JSON_ARRAY;
+                        json_jsonc_parse_array(val, callback_data, callback_function);
+                    } else if (type == json_type_object) {
+                        json_walk(val,callback_data,callback_function);
+                    } else if (type == json_type_string) {
+                        json_jsonc_set_string(&e,key,json_object_get_string(val));
+                        callback_function(&e);
+                    } else if (type == json_type_boolean) {
+                        json_jsonc_set_boolean(&e,json_object_get_boolean(val));
+                        callback_function(&e);
+                    }
+                }
+            }
+
+        } while (++i < end);
+    }
+}
+#else
+
+/**
+ * Walk string
+ *
+ * Set JSON_ENTRY to string and map the values from jsmntok_t.
+ *
+ * @param js the original string
+ * @param t the tokens
+ * @param start the first position
+ * @param e the output structure.
+ *
+ * @return It always return 1
+ */
+size_t json_walk_string(char *js, jsmntok_t *t, size_t start, JSON_ENTRY *e)
+{
+    char old = js[t[start].end];
+    js[t[start].end] = '\0';
+    e->original_string = &js[t[start].start];
+
+    e->type = JSON_STRING;
+    e->data.string = e->original_string;
+    if(e->callback_function) e->callback_function(e);
+    js[t[start].end] = old;
+    return 1;
+}
+
+/**
+ * Walk Primitive
+ *
+ * Define the data type of the string
+ *
+ * @param js the original string
+ * @param t the tokens
+ * @param start the first position
+ * @param e the output structure.
+ *
+ * @return It always return 1
+ */
+size_t json_walk_primitive(char *js, jsmntok_t *t, size_t start, JSON_ENTRY *e)
+{
+    char old = js[t[start].end];
+    js[t[start].end] = '\0';
+    e->original_string = &js[t[start].start];
+
+    switch(e->original_string[0]) {
+        case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
+        case '8': case '9': case '-': case '.':
+            e->type = JSON_NUMBER;
+            e->data.number = strtold(e->original_string, NULL);
+            break;
+
+        case 't': case 'T':
+            e->type = JSON_BOOLEAN;
+            e->data.boolean = 1;
+            break;
+
+        case 'f': case 'F':
+            e->type = JSON_BOOLEAN;
+            e->data.boolean = 0;
+            break;
+
+        case 'n': case 'N':
+        default:
+            e->type = JSON_NULL;
+            break;
+    }
+    if(e->callback_function) e->callback_function(e);
+    js[t[start].end] = old;
+    return 1;
+}
+
+/**
+ * Array
+ *
+ * Measure the array length
+ *
+ * @param js the original string
+ * @param t the tokens
+ * @param nest the length of structure t
+ * @param start the first position
+ * @param e the output structure.
+ *
+ * @return It returns the array length
+ */
+size_t json_walk_array(char *js, jsmntok_t *t, size_t nest, size_t start, JSON_ENTRY *e)
+{
+    JSON_ENTRY ne = {
+            .name = "",
+            .fullname = "",
+            .callback_data = NULL,
+            .callback_function = NULL
+    };
+
+    char old = js[t[start].end];
+    js[t[start].end] = '\0';
+    ne.original_string = &js[t[start].start];
+
+    memcpy(&ne, e, sizeof(JSON_ENTRY));
+    ne.type = JSON_ARRAY;
+    ne.data.items = t[start].size;
+    ne.callback_function = NULL;
+    ne.name[0]='\0';
+    ne.fullname[0]='\0';
+    if(e->callback_function) e->callback_function(&ne);
+    js[t[start].end] = old;
+
+    size_t i, init = start, size = t[start].size;
+
+    start++;
+    for(i = 0; i < size ; i++) {
+        ne.pos = i;
+        if (!e->name || !e->fullname || strlen(e->name) > JSON_NAME_LEN  - 24 || strlen(e->fullname) > JSON_FULLNAME_LEN -24) {
+            info("JSON: JSON walk_array ignoring element with name:%s fullname:%s",e->name, e->fullname);
+            continue;
+        }
+        sprintf(ne.name, "%s[%lu]", e->name, i);
+        sprintf(ne.fullname, "%s[%lu]", e->fullname, i);
+
+        switch(t[start].type) {
+            case JSMN_PRIMITIVE:
+                start += json_walk_primitive(js, t, start, &ne);
+                break;
+
+            case JSMN_OBJECT:
+                start += json_walk_object(js, t, nest + 1, start, &ne);
+                break;
+
+            case JSMN_ARRAY:
+                start += json_walk_array(js, t, nest + 1, start, &ne);
+                break;
+
+            case JSMN_STRING:
+                start += json_walk_string(js, t, start, &ne);
+                break;
+        }
+    }
+    return start - init;
+}
+
+/**
+ * Object
+ *
+ * Measure the Object length
+ *
+ * @param js the original string
+ * @param t the tokens
+ * @param nest the length of structure t
+ * @param start the first position
+ * @param e the output structure.
+ *
+ * @return It returns the Object length
+ */
+size_t json_walk_object(char *js, jsmntok_t *t, size_t nest, size_t start, JSON_ENTRY *e)
+{
+    JSON_ENTRY ne = {
+            .name = "",
+            .fullname = "",
+            .callback_data = NULL,
+            .callback_function = NULL
+    };
+
+    char old = js[t[start].end];
+    js[t[start].end] = '\0';
+    ne.original_string = &js[t[start].start];
+    memcpy(&ne, e, sizeof(JSON_ENTRY));
+    ne.type = JSON_OBJECT;
+    ne.callback_function = NULL;
+    if(e->callback_function) e->callback_function(&ne);
+    js[t[start].end] = old;
+
+    int key = 1;
+    size_t i, init = start, size = t[start].size;
+
+    start++;
+    for(i = 0; i < size ; i++) {
+        switch(t[start].type) {
+            case JSMN_PRIMITIVE:
+                start += json_walk_primitive(js, t, start, &ne);
+                key = 1;
+                break;
+
+            case JSMN_OBJECT:
+                start += json_walk_object(js, t, nest + 1, start, &ne);
+                key = 1;
+                break;
+
+            case JSMN_ARRAY:
+                start += json_walk_array(js, t, nest + 1, start, &ne);
+                key = 1;
+                break;
+
+            case JSMN_STRING:
+            default:
+                if(key) {
+                    int len = t[start].end - t[start].start;
+                    if (unlikely(len>JSON_NAME_LEN)) len=JSON_NAME_LEN;
+                    strncpy(ne.name, &js[t[start].start], len);
+                    ne.name[len] = '\0';
+                    len=strlen(e->fullname) + strlen(e->fullname[0]?".":"") + strlen(ne.name);
+                    char *c = mallocz((len+1)*sizeof(char));
+                    sprintf(c,"%s%s%s", e->fullname, e->fullname[0]?".":"", ne.name);
+                    if (unlikely(len>JSON_FULLNAME_LEN)) len=JSON_FULLNAME_LEN;
+                    strncpy(ne.fullname, c, len);
+                    freez(c);
+                    start++;
+                    key = 0;
+                }
+                else {
+                    start += json_walk_string(js, t, start, &ne);
+                    key = 1;
+                }
+                break;
+        }
+    }
+    return start - init;
+}
+#endif
+
+/**
+ * Tree
+ *
+ * Call the correct walk function according its type.
+ *
+ * @param t the json object to work
+ * @param callback_data additional data to be used together the callback function
+ * @param callback_function function used to create a silencer.
+ *
+ * @return It always return 1
+ */
+#ifdef ENABLE_JSONC
+size_t json_walk(json_object *t, void *callback_data, int (*callback_function)(struct json_entry *)) {
+    JSON_ENTRY e;
+
+    e.callback_data = callback_data;
+    enum json_type type;
+    json_object_object_foreach(t, key, val) {
+        type = json_object_get_type(val);
+        if (type == json_type_array) {
+            e.type = JSON_ARRAY;
+            json_jsonc_parse_array(val,NULL,health_silencers_json_read_callback);
+        } else if (type == json_type_object) {
+            e.type = JSON_OBJECT;
+        } else if (type == json_type_string) {
+            json_jsonc_set_string(&e,key,json_object_get_string(val));
+            callback_function(&e);
+        } else if (type == json_type_boolean) {
+            json_jsonc_set_boolean(&e,json_object_get_boolean(val));
+            callback_function(&e);
+        }
+    }
+
+    return 1;
+}
+#else
+/**
+ * Tree
+ *
+ * Call the correct walk function according its type.
+ *
+ * @param js the original string
+ * @param t the tokens
+ * @param callback_data additional data to be used together the callback function
+ * @param callback_function function used to create a silencer.
+ *
+ * @return It always return 1
+ */
+size_t json_walk_tree(char *js, jsmntok_t *t, void *callback_data, int (*callback_function)(struct json_entry *))
+{
+    JSON_ENTRY e = {
+            .name = "",
+            .fullname = "",
+            .callback_data = callback_data,
+            .callback_function = callback_function
+    };
+
+    switch (t[0].type) {
+        case JSMN_OBJECT:
+            e.type = JSON_OBJECT;
+            json_walk_object(js, t, 0, 0, &e);
+            break;
+
+        case JSMN_ARRAY:
+            e.type = JSON_ARRAY;
+            json_walk_array(js, t, 0, 0, &e);
+            break;
+
+        case JSMN_PRIMITIVE:
+        case JSMN_STRING:
+            break;
+    }
+
+    return 1;
+}
+#endif
+
+/**
+ * JSON Parse
+ *
+ * Parse the json message with the callback function
+ *
+ * @param js the string that the callback function will parse
+ * @param callback_data additional data to be used together the callback function
+ * @param callback_function function used to create a silencer.
+ *
+ * @return JSON_OK  case everything happend as expected, JSON_CANNOT_PARSE case there were errors in the
+ * parsing procces and JSON_CANNOT_DOWNLOAD case the string given(js) is NULL.
+ */
+int json_parse(char *js, void *callback_data, int (*callback_function)(JSON_ENTRY *))
+{
+    if(js) {
+#ifdef ENABLE_JSONC
+        json_object *tokens = json_tokenise(js);
+#else
+        size_t count;
+        jsmntok_t *tokens = json_tokenise(js, strlen(js), &count);
+#endif
+
+        if(tokens) {
+#ifdef ENABLE_JSONC
+            json_walk(tokens, callback_data, callback_function);
+            json_object_put(tokens);
+#else
+            json_walk_tree(js, tokens, callback_data, callback_function);
+            freez(tokens);
+#endif
+            return JSON_OK;
+        }
+
+        return JSON_CANNOT_PARSE;
+    }
+
+    return JSON_CANNOT_DOWNLOAD;
+}
+
+/*
+int json_test(char *str)
+{
+    return json_parse(str, NULL, json_callback_print);
+}
+ */
\ No newline at end of file
diff --git a/libnetdata/json/json.h b/libnetdata/json/json.h
new file mode 100644
index 000000000..79b58b170
--- /dev/null
+++ b/libnetdata/json/json.h
@@ -0,0 +1,72 @@
+#ifndef CHECKIN_JSON_H
+#define CHECKIN_JSON_H 1
+
+
+#if ENABLE_JSONC
+# include <json-c/json.h>
+#endif
+
+#include "jsmn.h"
+
+//https://www.ibm.com/support/knowledgecenter/en/SS9H2Y_7.6.0/com.ibm.dp.doc/json_parserlimits.html
+#define JSON_NAME_LEN 256
+#define JSON_FULLNAME_LEN 1024
+
+typedef enum {
+    JSON_OBJECT = 0,
+    JSON_ARRAY = 1,
+    JSON_STRING = 2,
+    JSON_NUMBER = 3,
+    JSON_BOOLEAN = 4,
+    JSON_NULL = 5,
+} JSON_ENTRY_TYPE;
+
+typedef struct json_entry {
+    JSON_ENTRY_TYPE type;
+    char name[JSON_NAME_LEN + 1];
+    char fullname[JSON_FULLNAME_LEN + 1];
+    union {
+        char *string;			// type == JSON_STRING
+        long double number;		// type == JSON_NUMBER
+        int boolean;			// type == JSON_BOOLEAN
+        size_t items;			// type == JSON_ARRAY
+    } data;
+    size_t pos;					// the position of this item in its parent
+
+    char *original_string;
+
+    void *callback_data;
+    int (*callback_function)(struct json_entry *);
+} JSON_ENTRY;
+
+// ----------------------------------------------------------------------------
+// public functions
+
+#define JSON_OK 				0
+#define JSON_CANNOT_DOWNLOAD 	1
+#define JSON_CANNOT_PARSE		2
+
+int json_parse(char *js, void *callback_data, int (*callback_function)(JSON_ENTRY *));
+
+
+// ----------------------------------------------------------------------------
+// private functions
+
+#ifdef ENABLE_JSONC
+json_object *json_tokenise(char *js);
+size_t json_walk(json_object *t, void *callback_data, int (*callback_function)(struct json_entry *));
+#else
+jsmntok_t *json_tokenise(char *js, size_t len, size_t *count);
+size_t json_walk_tree(char *js, jsmntok_t *t, void *callback_data, int (*callback_function)(struct json_entry *));
+#endif
+
+size_t json_walk_object(char *js, jsmntok_t *t, size_t nest, size_t start, JSON_ENTRY *e);
+size_t json_walk_array(char *js, jsmntok_t *t, size_t nest, size_t start, JSON_ENTRY *e);
+size_t json_walk_string(char *js, jsmntok_t *t, size_t start, JSON_ENTRY *e);
+size_t json_walk_primitive(char *js, jsmntok_t *t, size_t start, JSON_ENTRY *e);
+
+int json_callback_print(JSON_ENTRY *e);
+
+
+
+#endif
\ No newline at end of file