34 files changed, 6395 insertions, 1547 deletions

diff --git a/lib/Makefile.am b/lib/Makefile.am
index dc3ee893..27a08278 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -4,11 +4,23 @@ SUBDIRS = . tests
 
 noinst_LIBRARIES = libmonitoringplug.a
 
-AM_CPPFLAGS = -DNP_STATE_DIR_PREFIX=\"$(localstatedir)\" \
+AM_CPPFLAGS =  \
         -I$(srcdir) -I$(top_srcdir)/gl -I$(top_srcdir)/intl -I$(top_srcdir)/plugins
 
-libmonitoringplug_a_SOURCES = utils_base.c utils_disk.c utils_tcp.c utils_cmd.c maxfd.c
-EXTRA_DIST = utils_base.h utils_disk.h utils_tcp.h utils_cmd.h parse_ini.h extra_opts.h maxfd.h
+libmonitoringplug_a_SOURCES = utils_base.c utils_tcp.c utils_cmd.c maxfd.c output.c perfdata.c output.c thresholds.c vendor/cJSON/cJSON.c
+
+EXTRA_DIST = utils_base.h \
+        utils_tcp.h \
+        utils_cmd.h \
+        parse_ini.h \
+        extra_opts.h \
+        maxfd.h \
+        perfdata.h \
+        output.h \
+        thresholds.h \
+        states.h \
+        vendor/cJSON/cJSON.h \
+        monitoringplug.h
 
 if USE_PARSE_INI
 libmonitoringplug_a_SOURCES += parse_ini.c extra_opts.c
@@ -16,4 +28,3 @@ endif USE_PARSE_INI
 
 test test-debug:
         cd tests && make $@
-
diff --git a/lib/extra_opts.c b/lib/extra_opts.c
index 88787336..3fe69014 100644
--- a/lib/extra_opts.c
+++ b/lib/extra_opts.c
@@ -27,27 +27,32 @@
 
 /* FIXME: copied from utils.h; we should move a bunch of libs! */
 bool is_option2(char *str) {
-        if (!str)
+        if (!str) {
                 return false;
-        else if (strspn(str, "-") == 1 || strspn(str, "-") == 2)
+        }
+
+        if (strspn(str, "-") == 1 || strspn(str, "-") == 2) {
                 return true;
-        else
-                return false;
+        }
+
+        return false;
 }
 
 /* this is the externally visible function used by plugins */
 char **np_extra_opts(int *argc, char **argv, const char *plugin_name) {
-        np_arg_list *extra_args = NULL, *ea1 = NULL, *ea_tmp = NULL;
-        char **argv_new = NULL;
-        char *argptr = NULL;
-        int i, j, optfound, argc_new, ea_num = *argc;
-
         if (*argc < 2) {
                 /* No arguments provided */
                 return argv;
         }
 
-        for (i = 1; i < *argc; i++) {
+        np_arg_list *extra_args = NULL;
+        np_arg_list *ea1 = NULL;
+        np_arg_list *ea_tmp = NULL;
+        char *argptr = NULL;
+        int optfound;
+        size_t ea_num = (size_t)*argc;
+
+        for (int i = 1; i < *argc; i++) {
                 argptr = NULL;
                 optfound = 0;
 
@@ -56,8 +61,10 @@ char **np_extra_opts(int *argc, char **argv, const char *plugin_name) {
                         /* It is a single argument with value */
                         argptr = argv[i] + 13;
                         /* Delete the extra opts argument */
-                        for (j = i; j < *argc; j++)
+                        for (int j = i; j < *argc; j++) {
                                 argv[j] = argv[j + 1];
+                        }
+
                         i--;
                         *argc -= 1;
                 } else if (strcmp(argv[i], "--extra-opts") == 0) {
@@ -65,8 +72,10 @@ char **np_extra_opts(int *argc, char **argv, const char *plugin_name) {
                                 /* It is a argument with separate value */
                                 argptr = argv[i + 1];
                                 /* Delete the extra-opts argument/value */
-                                for (j = i; j < *argc - 1; j++)
+                                for (int j = i; j < *argc - 1; j++) {
                                         argv[j] = argv[j + 2];
+                                }
+
                                 i -= 2;
                                 *argc -= 2;
                                 ea_num--;
@@ -74,8 +83,10 @@ char **np_extra_opts(int *argc, char **argv, const char *plugin_name) {
                                 /* It has no value */
                                 optfound = 1;
                                 /* Delete the extra opts argument */
-                                for (j = i; j < *argc; j++)
+                                for (int j = i; j < *argc; j++) {
                                         argv[j] = argv[j + 1];
+                                }
+
                                 i--;
                                 *argc -= 1;
                         }
@@ -94,34 +105,37 @@ char **np_extra_opts(int *argc, char **argv, const char *plugin_name) {
                         /* append the list to extra_args */
                         if (extra_args == NULL) {
                                 extra_args = ea1;
-                                while ((ea1 = ea1->next))
+                                while ((ea1 = ea1->next)) {
                                         ea_num++;
+                                }
                         } else {
                                 ea_tmp = extra_args;
                                 while (ea_tmp->next) {
                                         ea_tmp = ea_tmp->next;
                                 }
                                 ea_tmp->next = ea1;
-                                while ((ea1 = ea1->next))
+                                while ((ea1 = ea1->next)) {
                                         ea_num++;
+                                }
                         }
                         ea1 = ea_tmp = NULL;
                 }
         } /* lather, rince, repeat */
 
-        if (ea_num == *argc && extra_args == NULL) {
+        if (ea_num == (size_t)*argc && extra_args == NULL) {
                 /* No extra-opts */
                 return argv;
         }
 
         /* done processing arguments. now create a new argv array... */
-        argv_new = (char **)malloc((ea_num + 1) * sizeof(char **));
-        if (argv_new == NULL)
+        char **argv_new = (char **)malloc((ea_num + 1) * sizeof(char **));
+        if (argv_new == NULL) {
                 die(STATE_UNKNOWN, _("malloc() failed!\n"));
+        }
 
         /* starting with program name */
         argv_new[0] = argv[0];
-        argc_new = 1;
+        int argc_new = 1;
         /* then parsed ini opts (frying them up in the same run) */
         while (extra_args) {
                 argv_new[argc_new++] = extra_args->arg;
@@ -130,8 +144,9 @@ char **np_extra_opts(int *argc, char **argv, const char *plugin_name) {
                 free(ea1);
         }
         /* finally the rest of the argv array */
-        for (i = 1; i < *argc; i++)
+        for (int i = 1; i < *argc; i++) {
                 argv_new[argc_new++] = argv[i];
+        }
         *argc = argc_new;
         /* and terminate. */
         argv_new[argc_new] = NULL;
diff --git a/lib/maxfd.c b/lib/maxfd.c
index ca5b6e54..a0f79949 100644
--- a/lib/maxfd.c
+++ b/lib/maxfd.c
@@ -19,7 +19,6 @@
  *****************************************************************************/
 
 #include "./maxfd.h"
-#include <errno.h>
 
 long mp_open_max(void) {
         long maxfd = 0L;
@@ -31,10 +30,11 @@ long mp_open_max(void) {
 #ifdef _SC_OPEN_MAX
         errno = 0;
         if ((maxfd = sysconf(_SC_OPEN_MAX)) < 0) {
-                if (errno == 0)
+                if (errno == 0) {
                         maxfd = DEFAULT_MAXFD; /* it's indeterminate */
-                else
+                } else {
                         die(STATE_UNKNOWN, _("sysconf error for _SC_OPEN_MAX\n"));
+                }
         }
 #elif defined(OPEN_MAX)
         return OPEN_MAX
diff --git a/lib/monitoringplug.h b/lib/monitoringplug.h
new file mode 100644
index 00000000..a555d736
--- /dev/null
+++ b/lib/monitoringplug.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include "./states.h"
+#include "./utils_base.h"
+#include "./thresholds.h"
+#include "./maxfd.h"
+#include "./output.h"
diff --git a/lib/output.c b/lib/output.c
new file mode 100644
index 00000000..f283969f
--- /dev/null
+++ b/lib/output.c
@@ -0,0 +1,636 @@
+#include "./output.h"
+#include "./utils_base.h"
+#include "../plugins/utils.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+// #include <cjson/cJSON.h>
+#include "./vendor/cJSON/cJSON.h"
+#include "perfdata.h"
+#include "states.h"
+
+// == Global variables
+static mp_output_format output_format = MP_FORMAT_DEFAULT;
+static mp_output_detail_level level_of_detail = MP_DETAIL_ALL;
+
+// == Prototypes ==
+static char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check,
+                                                                 unsigned int indentation);
+static inline cJSON *json_serialize_subcheck(mp_subcheck subcheck);
+
+// == Implementation ==
+
+/*
+ * Generate output string for a mp_subcheck object
+ */
+static inline char *fmt_subcheck_perfdata(mp_subcheck check) {
+        char *result = strdup("");
+        int added = 0;
+
+        if (check.perfdata != NULL) {
+                added = asprintf(&result, "%s", pd_list_to_string(*check.perfdata));
+        }
+
+        if (check.subchecks == NULL) {
+                // No subchecks, return here
+                return result;
+        }
+
+        mp_subcheck_list *subchecks = check.subchecks;
+
+        while (subchecks != NULL) {
+                if (added > 0) {
+                        added = asprintf(&result, "%s%s", result, fmt_subcheck_perfdata(subchecks->subcheck));
+                } else {
+                        // TODO free previous result here?
+                        added = asprintf(&result, "%s", fmt_subcheck_perfdata(subchecks->subcheck));
+                }
+
+                subchecks = subchecks->next;
+        }
+
+        return result;
+}
+
+/*
+ * Initialiser for a mp_check object. Always use this to get a new one!
+ * It sets useful defaults
+ */
+mp_check mp_check_init(void) {
+        mp_check check = {
+                .evaluation_function = &mp_eval_check_default,
+        };
+        return check;
+}
+
+/*
+ * Initialiser for a mp_subcheck object. Always use this to get a new one!
+ * It sets useful defaults
+ */
+mp_subcheck mp_subcheck_init(void) {
+        mp_subcheck tmp = {0};
+        tmp.default_state = STATE_UNKNOWN; // Default state is unknown
+        tmp.state_set_explicitly = false;
+        return tmp;
+}
+
+/*
+ * Add a subcheck to a (the one and only) check object
+ */
+int mp_add_subcheck_to_check(mp_check check[static 1], mp_subcheck subcheck) {
+        assert(subcheck.output != NULL); // There must be output in a subcheck
+
+        mp_subcheck_list *tmp = NULL;
+
+        if (check->subchecks == NULL) {
+                check->subchecks = (mp_subcheck_list *)calloc(1, sizeof(mp_subcheck_list));
+                if (check->subchecks == NULL) {
+                        die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__, "malloc failed");
+                }
+
+                check->subchecks->subcheck = subcheck;
+                check->subchecks->next = NULL;
+        } else {
+                // Search for the end
+                tmp = (mp_subcheck_list *)calloc(1, sizeof(mp_subcheck_list));
+                if (tmp == NULL) {
+                        die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__, "malloc failed");
+                }
+
+                tmp->subcheck = subcheck;
+                tmp->next = check->subchecks;
+
+                check->subchecks = tmp;
+        }
+
+        return 0;
+}
+
+/*
+ * Add a mp_perfdata data point to a mp_subcheck object
+ */
+void mp_add_perfdata_to_subcheck(mp_subcheck check[static 1], const mp_perfdata perfData) {
+        if (check->perfdata == NULL) {
+                check->perfdata = pd_list_init();
+        }
+        pd_list_append(check->perfdata, perfData);
+}
+
+/*
+ * Add a mp_subcheck object to another one. The seconde mp_subcheck (argument) is the lower in the
+ * hierarchy
+ */
+int mp_add_subcheck_to_subcheck(mp_subcheck check[static 1], mp_subcheck subcheck) {
+        if (subcheck.output == NULL) {
+                die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__,
+                        "Sub check output is NULL");
+        }
+
+        mp_subcheck_list *tmp = NULL;
+
+        if (check->subchecks == NULL) {
+                check->subchecks = (mp_subcheck_list *)calloc(1, sizeof(mp_subcheck_list));
+                if (check->subchecks == NULL) {
+                        die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__, "malloc failed");
+                }
+
+                tmp = check->subchecks;
+        } else {
+                // Search for the end
+                tmp = check->subchecks;
+
+                while (tmp->next != NULL) {
+                        tmp = tmp->next;
+                }
+
+                tmp->next = (mp_subcheck_list *)calloc(1, sizeof(mp_subcheck_list));
+                if (tmp->next == NULL) {
+                        die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__, "malloc failed");
+                }
+
+                tmp = tmp->next;
+        }
+
+        tmp->subcheck = subcheck;
+
+        return 0;
+}
+
+/*
+ * Add a manual summary to a mp_check object, effectively replacing
+ * the autogenerated one
+ */
+void mp_add_summary(mp_check check[static 1], char *summary) { check->summary = summary; }
+
+/*
+ * Generate the summary string of a mp_check object based on it's subchecks
+ */
+char *get_subcheck_summary(mp_check check) {
+        mp_subcheck_list *subchecks = check.subchecks;
+
+        unsigned int ok = 0;
+        unsigned int warning = 0;
+        unsigned int critical = 0;
+        unsigned int unknown = 0;
+        while (subchecks != NULL) {
+                switch (subchecks->subcheck.state) {
+                case STATE_OK:
+                        ok++;
+                        break;
+                case STATE_WARNING:
+                        warning++;
+                        break;
+                case STATE_CRITICAL:
+                        critical++;
+                        break;
+                case STATE_UNKNOWN:
+                        unknown++;
+                        break;
+                default:
+                        die(STATE_UNKNOWN, "Unknown state in get_subcheck_summary");
+                }
+                subchecks = subchecks->next;
+        }
+        char *result = NULL;
+        asprintf(&result, "ok=%d, warning=%d, critical=%d, unknown=%d", ok, warning, critical, unknown);
+        return result;
+}
+
+mp_state_enum mp_compute_subcheck_state(const mp_subcheck subcheck) {
+        if (subcheck.evaluation_function == NULL) {
+                return mp_eval_subcheck_default(subcheck);
+        }
+        return subcheck.evaluation_function(subcheck);
+}
+
+/*
+ * Generate the result state of a mp_subcheck object based on its own state and its subchecks
+ * states
+ */
+mp_state_enum mp_eval_subcheck_default(mp_subcheck subcheck) {
+        if (subcheck.evaluation_function != NULL) {
+                return subcheck.evaluation_function(subcheck);
+        }
+
+        if (subcheck.state_set_explicitly) {
+                return subcheck.state;
+        }
+
+        mp_subcheck_list *scl = subcheck.subchecks;
+
+        if (scl == NULL) {
+                return subcheck.default_state;
+        }
+
+        mp_state_enum result = STATE_OK;
+
+        while (scl != NULL) {
+                result = max_state_alt(result, mp_compute_subcheck_state(scl->subcheck));
+                scl = scl->next;
+        }
+
+        return result;
+}
+
+mp_state_enum mp_compute_check_state(const mp_check check) {
+        // just a safety check
+        if (check.evaluation_function == NULL) {
+                return mp_eval_check_default(check);
+        }
+        return check.evaluation_function(check);
+}
+
+/*
+ * Generate the result state of a mp_check object based on it's own state and it's subchecks states
+ */
+mp_state_enum mp_eval_check_default(const mp_check check) {
+        assert(check.subchecks != NULL); // a mp_check without subchecks is invalid, die here
+
+        mp_subcheck_list *scl = check.subchecks;
+        mp_state_enum result = STATE_OK;
+
+        while (scl != NULL) {
+                result = max_state_alt(result, mp_compute_subcheck_state(scl->subcheck));
+                scl = scl->next;
+        }
+
+        return result;
+}
+
+/*
+ * Generate output string for a mp_check object
+ * Non static to be available for testing functions
+ */
+char *mp_fmt_output(mp_check check) {
+        char *result = NULL;
+
+        switch (output_format) {
+        case MP_FORMAT_MULTI_LINE: {
+                if (check.summary == NULL) {
+                        check.summary = get_subcheck_summary(check);
+                }
+
+                asprintf(&result, "[%s] - %s", state_text(mp_compute_check_state(check)), check.summary);
+
+                mp_subcheck_list *subchecks = check.subchecks;
+
+                while (subchecks != NULL) {
+                        if (level_of_detail == MP_DETAIL_ALL ||
+                                mp_compute_subcheck_state(subchecks->subcheck) != STATE_OK) {
+                                asprintf(&result, "%s\n%s", result,
+                                                 fmt_subcheck_output(MP_FORMAT_MULTI_LINE, subchecks->subcheck, 1));
+                        }
+                        subchecks = subchecks->next;
+                }
+
+                char *pd_string = NULL;
+                subchecks = check.subchecks;
+
+                while (subchecks != NULL) {
+                        if (pd_string == NULL) {
+                                asprintf(&pd_string, "%s", fmt_subcheck_perfdata(subchecks->subcheck));
+                        } else {
+                                asprintf(&pd_string, "%s %s", pd_string,
+                                                 fmt_subcheck_perfdata(subchecks->subcheck));
+                        }
+
+                        subchecks = subchecks->next;
+                }
+
+                if (pd_string != NULL && strlen(pd_string) > 0) {
+                        asprintf(&result, "%s|%s", result, pd_string);
+                }
+
+                break;
+        }
+        case MP_FORMAT_TEST_JSON: {
+                cJSON *resultObject = cJSON_CreateObject();
+                if (resultObject == NULL) {
+                        die(STATE_UNKNOWN, "cJSON_CreateObject failed");
+                }
+
+                cJSON *resultState = cJSON_CreateString(state_text(mp_compute_check_state(check)));
+                cJSON_AddItemToObject(resultObject, "state", resultState);
+
+                if (check.summary == NULL) {
+                        check.summary = get_subcheck_summary(check);
+                }
+
+                cJSON *summary = cJSON_CreateString(check.summary);
+                cJSON_AddItemToObject(resultObject, "summary", summary);
+
+                if (check.subchecks != NULL) {
+                        cJSON *subchecks = cJSON_CreateArray();
+
+                        mp_subcheck_list *sc = check.subchecks;
+
+                        while (sc != NULL) {
+                                cJSON *sc_json = json_serialize_subcheck(sc->subcheck);
+                                cJSON_AddItemToArray(subchecks, sc_json);
+                                sc = sc->next;
+                        }
+
+                        cJSON_AddItemToObject(resultObject, "checks", subchecks);
+                }
+
+                result = cJSON_PrintUnformatted(resultObject);
+                break;
+        }
+        default:
+                die(STATE_UNKNOWN, "Invalid format");
+        }
+
+        return result;
+}
+
+/*
+ * Helper function to properly indent the output lines when using multiline
+ * formats
+ */
+static char *generate_indentation_string(unsigned int indentation) {
+        char *result = calloc(indentation + 1, sizeof(char));
+
+        for (unsigned int i = 0; i < indentation; i++) {
+                result[i] = '\t';
+        }
+
+        return result;
+}
+
+/*
+ * Helper function to generate the output string of mp_subcheck
+ */
+static inline char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check,
+                                                                                unsigned int indentation) {
+        char *result = NULL;
+        mp_subcheck_list *subchecks = NULL;
+
+        switch (output_format) {
+        case MP_FORMAT_MULTI_LINE: {
+                char *tmp_string = NULL;
+                if ((tmp_string = strchr(check.output, '\n')) != NULL) {
+                        // This is a multiline string, put the correct indentation in before proceeding
+                        char *intermediate_string = "";
+                        bool have_residual_chars = false;
+
+                        while (tmp_string != NULL) {
+                                *tmp_string = '\0';
+                                asprintf(&intermediate_string, "%s%s\n%s", intermediate_string, check.output,
+                                                 generate_indentation_string(
+                                                         indentation + 1)); // one more indentation to make it look better
+
+                                if (*(tmp_string + 1) != '\0') {
+                                        check.output = tmp_string + 1;
+                                        have_residual_chars = true;
+                                } else {
+                                        // Null after the \n, so this is the end
+                                        have_residual_chars = false;
+                                        break;
+                                }
+
+                                tmp_string = strchr(check.output, '\n');
+                        }
+
+                        // add the rest (if any)
+                        if (have_residual_chars) {
+                                char *tmp = check.output;
+                                xasprintf(&check.output, "%s\n%s%s", intermediate_string,
+                                                  generate_indentation_string(indentation + 1), tmp);
+                        } else {
+                                check.output = intermediate_string;
+                        }
+                }
+                asprintf(&result, "%s\\_[%s] - %s", generate_indentation_string(indentation),
+                                 state_text(mp_compute_subcheck_state(check)), check.output);
+
+                subchecks = check.subchecks;
+
+                while (subchecks != NULL) {
+                        asprintf(&result, "%s\n%s", result,
+                                         fmt_subcheck_output(output_format, subchecks->subcheck, indentation + 1));
+                        subchecks = subchecks->next;
+                }
+                return result;
+        }
+        default:
+                die(STATE_UNKNOWN, "Invalid format");
+        }
+}
+
+static inline cJSON *json_serialise_pd_value(mp_perfdata_value value) {
+        cJSON *result = cJSON_CreateObject();
+
+        switch (value.type) {
+        case PD_TYPE_DOUBLE:
+                cJSON_AddStringToObject(result, "type", "double");
+                break;
+        case PD_TYPE_INT:
+                cJSON_AddStringToObject(result, "type", "int");
+                break;
+        case PD_TYPE_UINT:
+                cJSON_AddStringToObject(result, "type", "uint");
+                break;
+        case PD_TYPE_NONE:
+                die(STATE_UNKNOWN, "Perfdata type was None in json_serialise_pd_value");
+        }
+        cJSON_AddStringToObject(result, "value", pd_value_to_string(value));
+
+        return result;
+}
+
+static inline cJSON *json_serialise_range(mp_range range) {
+        cJSON *result = cJSON_CreateObject();
+
+        if (range.alert_on_inside_range) {
+                cJSON_AddBoolToObject(result, "alert_on_inside", true);
+        } else {
+                cJSON_AddBoolToObject(result, "alert_on_inside", false);
+        }
+
+        if (range.end_infinity) {
+                cJSON_AddStringToObject(result, "end", "inf");
+        } else {
+                cJSON_AddItemToObject(result, "end", json_serialise_pd_value(range.end));
+        }
+
+        if (range.start_infinity) {
+                cJSON_AddStringToObject(result, "start", "inf");
+        } else {
+                cJSON_AddItemToObject(result, "start", json_serialise_pd_value(range.end));
+        }
+
+        return result;
+}
+
+static inline cJSON *json_serialise_pd(mp_perfdata pd_val) {
+        cJSON *result = cJSON_CreateObject();
+
+        // Label
+        cJSON_AddStringToObject(result, "label", pd_val.label);
+
+        // Value
+        cJSON_AddItemToObject(result, "value", json_serialise_pd_value(pd_val.value));
+
+        // Uom
+        cJSON_AddStringToObject(result, "uom", pd_val.uom);
+
+        // Warn/Crit
+        if (pd_val.warn_present) {
+                cJSON *warn = json_serialise_range(pd_val.warn);
+                cJSON_AddItemToObject(result, "warn", warn);
+        }
+        if (pd_val.crit_present) {
+                cJSON *crit = json_serialise_range(pd_val.crit);
+                cJSON_AddItemToObject(result, "crit", crit);
+        }
+
+        if (pd_val.min_present) {
+                cJSON_AddItemToObject(result, "min", json_serialise_pd_value(pd_val.min));
+        }
+        if (pd_val.max_present) {
+                cJSON_AddItemToObject(result, "max", json_serialise_pd_value(pd_val.max));
+        }
+
+        return result;
+}
+
+static inline cJSON *json_serialise_pd_list(pd_list *list) {
+        cJSON *result = cJSON_CreateArray();
+
+        do {
+                cJSON *pd_value = json_serialise_pd(list->data);
+                cJSON_AddItemToArray(result, pd_value);
+                list = list->next;
+        } while (list != NULL);
+
+        return result;
+}
+
+static inline cJSON *json_serialize_subcheck(mp_subcheck subcheck) {
+        cJSON *result = cJSON_CreateObject();
+
+        // Human readable output
+        cJSON *output = cJSON_CreateString(subcheck.output);
+        cJSON_AddItemToObject(result, "output", output);
+
+        // Test state (aka Exit Code)
+        cJSON *state = cJSON_CreateString(state_text(mp_compute_subcheck_state(subcheck)));
+        cJSON_AddItemToObject(result, "state", state);
+
+        // Perfdata
+        if (subcheck.perfdata != NULL) {
+                cJSON *perfdata = json_serialise_pd_list(subcheck.perfdata);
+                cJSON_AddItemToObject(result, "perfdata", perfdata);
+        }
+
+        if (subcheck.subchecks != NULL) {
+                cJSON *subchecks = cJSON_CreateArray();
+
+                mp_subcheck_list *sc = subcheck.subchecks;
+
+                while (sc != NULL) {
+                        cJSON *sc_json = json_serialize_subcheck(sc->subcheck);
+                        cJSON_AddItemToArray(subchecks, sc_json);
+                        sc = sc->next;
+                }
+
+                cJSON_AddItemToObject(result, "checks", subchecks);
+        }
+
+        return result;
+}
+
+/*
+ * Wrapper function to print the output string of a mp_check object
+ * Use this in concrete plugins.
+ */
+void mp_print_output(mp_check check) { puts(mp_fmt_output(check)); }
+
+/*
+ * Convenience function to print the output string of a mp_check object and exit
+ * the program with the resulting state.
+ * Intended to be used to exit a monitoring plugin.
+ */
+void mp_exit(mp_check check) {
+        mp_print_output(check);
+        if (output_format == MP_FORMAT_TEST_JSON) {
+                exit(0);
+        }
+
+        exit(mp_compute_check_state(check));
+}
+
+/*
+ * Function to set the result state of a mp_subcheck object explicitly.
+ * This will overwrite the default state AND states derived from it's subchecks
+ */
+mp_subcheck mp_set_subcheck_state(mp_subcheck check, mp_state_enum state) {
+        check.state = state;
+        check.state_set_explicitly = true;
+        return check;
+}
+
+/*
+ * Function to set the default result state of a mp_subcheck object. This state
+ * will be used if neither an explicit state is set (see *mp_set_subcheck_state*)
+ * nor does it include other subchecks
+ */
+mp_subcheck mp_set_subcheck_default_state(mp_subcheck check, mp_state_enum state) {
+        check.default_state = state;
+        return check;
+}
+
+char *mp_output_format_map[] = {
+        [MP_FORMAT_MULTI_LINE] = "multi-line",
+        [MP_FORMAT_TEST_JSON] = "mp-test-json",
+};
+
+/*
+ * Function to parse the output from a string
+ */
+parsed_output_format mp_parse_output_format(char *format_string) {
+        parsed_output_format result = {
+                .parsing_success = false,
+                .output_format = MP_FORMAT_DEFAULT,
+        };
+
+        for (mp_output_format i = 0; i < (sizeof(mp_output_format_map) / sizeof(char *)); i++) {
+                if (strcasecmp(mp_output_format_map[i], format_string) == 0) {
+                        result.parsing_success = true;
+                        result.output_format = i;
+                        break;
+                }
+        }
+
+        return result;
+}
+
+void mp_set_format(mp_output_format format) { output_format = format; }
+
+mp_output_format mp_get_format(void) { return output_format; }
+
+void mp_set_level_of_detail(mp_output_detail_level level) { level_of_detail = level; }
+
+mp_output_detail_level mp_get_level_of_detail(void) { return level_of_detail; }
+
+mp_state_enum mp_eval_ok(mp_check overall) {
+        (void)overall;
+        return STATE_OK;
+}
+
+mp_state_enum mp_eval_warning(mp_check overall) {
+        (void)overall;
+        return STATE_WARNING;
+}
+
+mp_state_enum mp_eval_critical(mp_check overall) {
+        (void)overall;
+        return STATE_CRITICAL;
+}
+
+mp_state_enum mp_eval_unknown(mp_check overall) {
+        (void)overall;
+        return STATE_UNKNOWN;
+}
diff --git a/lib/output.h b/lib/output.h
new file mode 100644
index 00000000..c63c8e3f
--- /dev/null
+++ b/lib/output.h
@@ -0,0 +1,117 @@
+#pragma once
+
+#include "../config.h"
+#include "./perfdata.h"
+#include "./states.h"
+
+/*
+ * A partial check result
+ */
+typedef struct mp_subcheck mp_subcheck;
+struct mp_subcheck {
+        mp_state_enum state;         // OK, Warning, Critical ... set explicitly
+        mp_state_enum default_state; // OK, Warning, Critical .. if not set explicitly
+        bool state_set_explicitly;   // was the state set explicitly (or should it be derived from
+                                                                 // subchecks)
+
+        char *output;      // Text output for humans ("Filesystem xyz is fine", "Could not create TCP
+                                           // connection to..")
+        pd_list *perfdata; // Performance data for this check
+        struct subcheck_list *subchecks; // subchecks deeper in the hierarchy
+
+        // the evaluation_functions computes the state of subcheck
+        mp_state_enum (*evaluation_function)(mp_subcheck);
+};
+
+/*
+ * A list of subchecks, used in subchecks and the main check
+ */
+typedef struct subcheck_list {
+        mp_subcheck subcheck;
+        struct subcheck_list *next;
+} mp_subcheck_list;
+
+/*
+ * Possible output formats
+ */
+typedef enum output_format {
+        MP_FORMAT_MULTI_LINE,
+        MP_FORMAT_TEST_JSON,
+} mp_output_format;
+
+#define MP_FORMAT_DEFAULT MP_FORMAT_MULTI_LINE
+
+/*
+ * Format related functions
+ */
+void mp_set_format(mp_output_format format);
+mp_output_format mp_get_format(void);
+
+// Output detail level
+
+typedef enum output_detail_level {
+        MP_DETAIL_ALL,
+        MP_DETAIL_NON_OK_ONLY,
+} mp_output_detail_level;
+
+void mp_set_level_of_detail(mp_output_detail_level level);
+mp_output_detail_level mp_get_level_of_detail(void);
+
+/*
+ * The main state object of a plugin. Exists only ONCE per plugin.
+ * This is the "root" of a tree of singular checks.
+ * The final result is always derived from the children and the "worst" state
+ * in the first layer of subchecks
+ */
+typedef struct mp_check mp_check;
+struct mp_check {
+        char *summary; // Overall summary, if not set a summary will be automatically generated
+        mp_subcheck_list *subchecks;
+
+        // the evaluation_functions computes the state of check
+        mp_state_enum (*evaluation_function)(mp_check);
+};
+
+mp_check mp_check_init(void);
+mp_subcheck mp_subcheck_init(void);
+
+mp_subcheck mp_set_subcheck_state(mp_subcheck, mp_state_enum);
+mp_subcheck mp_set_subcheck_default_state(mp_subcheck, mp_state_enum);
+
+int mp_add_subcheck_to_check(mp_check check[static 1], mp_subcheck);
+int mp_add_subcheck_to_subcheck(mp_subcheck check[static 1], mp_subcheck);
+
+void mp_add_perfdata_to_subcheck(mp_subcheck check[static 1], mp_perfdata);
+
+void mp_add_summary(mp_check check[static 1], char *summary);
+
+mp_state_enum mp_compute_check_state(mp_check);
+mp_state_enum mp_compute_subcheck_state(mp_subcheck);
+
+mp_state_enum mp_eval_ok(mp_check overall);
+mp_state_enum mp_eval_warning(mp_check overall);
+mp_state_enum mp_eval_critical(mp_check overall);
+mp_state_enum mp_eval_unknown(mp_check overall);
+mp_state_enum mp_eval_check_default(mp_check check);
+mp_state_enum mp_eval_subcheck_default(mp_subcheck subcheck);
+
+typedef struct {
+        bool parsing_success;
+        mp_output_format output_format;
+} parsed_output_format;
+parsed_output_format mp_parse_output_format(char *format_string);
+
+// TODO free and stuff
+// void mp_cleanup_check(mp_check check[static 1]);
+
+char *mp_fmt_output(mp_check);
+
+void mp_print_output(mp_check);
+
+/*
+ * ==================
+ * Exit functionality
+ * ==================
+ */
+
+void mp_exit(mp_check) __attribute__((noreturn));
diff --git a/lib/parse_ini.c b/lib/parse_ini.c
index 1289aae2..db337622 100644
--- a/lib/parse_ini.c
+++ b/lib/parse_ini.c
@@ -40,26 +40,29 @@ typedef struct {
         char *stanza;
 } np_ini_info;
 
-static char *default_ini_file_names[] = {"monitoring-plugins.ini", "plugins.ini", "nagios-plugins.ini", NULL};
+static char *default_ini_file_names[] = {"monitoring-plugins.ini", "plugins.ini",
+                                                                                 "nagios-plugins.ini", NULL};
 
 static char *default_ini_path_names[] = {
-        "/usr/local/etc/monitoring-plugins/monitoring-plugins.ini", "/usr/local/etc/monitoring-plugins.ini",
-        "/etc/monitoring-plugins/monitoring-plugins.ini", "/etc/monitoring-plugins.ini",
+        "/usr/local/etc/monitoring-plugins/monitoring-plugins.ini",
+        "/usr/local/etc/monitoring-plugins.ini", "/etc/monitoring-plugins/monitoring-plugins.ini",
+        "/etc/monitoring-plugins.ini",
         /* deprecated path names (for backward compatibility): */
-        "/etc/nagios/plugins.ini", "/usr/local/nagios/etc/plugins.ini", "/usr/local/etc/nagios/plugins.ini", "/etc/opt/nagios/plugins.ini",
-        "/etc/nagios-plugins.ini", "/usr/local/etc/nagios-plugins.ini", "/etc/opt/nagios-plugins.ini", NULL};
+        "/etc/nagios/plugins.ini", "/usr/local/nagios/etc/plugins.ini",
+        "/usr/local/etc/nagios/plugins.ini", "/etc/opt/nagios/plugins.ini", "/etc/nagios-plugins.ini",
+        "/usr/local/etc/nagios-plugins.ini", "/etc/opt/nagios-plugins.ini", NULL};
 
 /* eat all characters from a FILE pointer until n is encountered */
-#define GOBBLE_TO(f, c, n)                                                                                                                 \
-        do {                                                                                                                                   \
-                (c) = fgetc((f));                                                                                                                  \
+#define GOBBLE_TO(f, c, n)                                                                         \
+        do {                                                                                           \
+                (c) = fgetc((f));                                                                          \
         } while ((c) != EOF && (c) != (n))
 
 /* internal function that returns the constructed defaults options */
-static int read_defaults(FILE *f, const char *stanza, np_arg_list **opts);
+static bool read_defaults(FILE *defaults_file, const char *stanza, np_arg_list **opts);
 
 /* internal function that converts a single line into options format */
-static int add_option(FILE *f, np_arg_list **optlst);
+static int add_option(FILE *filePointer, np_arg_list **optlst);
 
 /* internal functions to find default file */
 static char *default_file(void);
@@ -71,7 +74,8 @@ static char *default_file_in_path(void);
  * into its separate parts.
  */
 static void parse_locator(const char *locator, const char *def_stanza, np_ini_info *i) {
-        size_t locator_len = 0, stanza_len = 0;
+        size_t locator_len = 0;
+        size_t stanza_len = 0;
 
         /* if locator is NULL we'll use default values */
         if (locator != NULL) {
@@ -87,8 +91,9 @@ static void parse_locator(const char *locator, const char *def_stanza, np_ini_in
                 i->stanza = strdup(def_stanza);
         }
 
-        if (i->stanza == NULL)
+        if (i->stanza == NULL) {
                 die(STATE_UNKNOWN, _("malloc() failed!\n"));
+        }
 
         /* check whether there's an @file part */
         if (stanza_len == locator_len) {
@@ -99,39 +104,46 @@ static void parse_locator(const char *locator, const char *def_stanza, np_ini_in
                 i->file_string_on_heap = true;
         }
 
-        if (i->file == NULL || i->file[0] == '\0')
+        if (i->file == NULL || i->file[0] == '\0') {
                 die(STATE_UNKNOWN, _("Cannot find config file in any standard location.\n"));
+        }
 }
 
 /*
  * This is the externally visible function used by extra_opts.
  */
 np_arg_list *np_get_defaults(const char *locator, const char *default_section) {
-        FILE *inifile = NULL;
-        np_arg_list *defaults = NULL;
-        np_ini_info i;
         int is_suid_plugin = mp_suid();
 
-        if (is_suid_plugin && idpriv_temp_drop() == -1)
+        if (is_suid_plugin && idpriv_temp_drop() == -1) {
                 die(STATE_UNKNOWN, _("Cannot drop privileges: %s\n"), strerror(errno));
+        }
 
-        parse_locator(locator, default_section, &i);
-        inifile = strcmp(i.file, "-") == 0 ? stdin : fopen(i.file, "r");
+        FILE *inifile = NULL;
+        np_ini_info ini_info;
+        parse_locator(locator, default_section, &ini_info);
+        inifile = strcmp(ini_info.file, "-") == 0 ? stdin : fopen(ini_info.file, "r");
 
-        if (inifile == NULL)
+        if (inifile == NULL) {
                 die(STATE_UNKNOWN, _("Can't read config file: %s\n"), strerror(errno));
-        if (!read_defaults(inifile, i.stanza, &defaults))
-                die(STATE_UNKNOWN, _("Invalid section '%s' in config file '%s'\n"), i.stanza, i.file);
+        }
 
-        if (i.file_string_on_heap) {
-                free(i.file);
+        np_arg_list *defaults = NULL;
+        if (!read_defaults(inifile, ini_info.stanza, &defaults)) {
+                die(STATE_UNKNOWN, _("Invalid section '%s' in config file '%s'\n"), ini_info.stanza, ini_info.file);
+        }
+
+        if (ini_info.file_string_on_heap) {
+                free(ini_info.file);
         }
 
-        if (inifile != stdin)
+        if (inifile != stdin) {
                 fclose(inifile);
-        free(i.stanza);
-        if (is_suid_plugin && idpriv_temp_restore() == -1)
+        }
+        free(ini_info.stanza);
+        if (is_suid_plugin && idpriv_temp_restore() == -1) {
                 die(STATE_UNKNOWN, _("Cannot restore privileges: %s\n"), strerror(errno));
+        }
 
         return defaults;
 }
@@ -143,54 +155,58 @@ np_arg_list *np_get_defaults(const char *locator, const char *default_section) {
  * be extra careful about user-supplied input (i.e. avoiding possible
  * format string vulnerabilities, etc).
  */
-static int read_defaults(FILE *f, const char *stanza, np_arg_list **opts) {
-        int c = 0;
+static bool read_defaults(FILE *defaults_file, const char *stanza, np_arg_list **opts) {
         bool status = false;
-        size_t i, stanza_len;
         enum {
                 NOSTANZA,
                 WRONGSTANZA,
                 RIGHTSTANZA
         } stanzastate = NOSTANZA;
 
-        stanza_len = strlen(stanza);
+        size_t stanza_len = strlen(stanza);
 
         /* our little stanza-parsing state machine */
-        while ((c = fgetc(f)) != EOF) {
+        int current_char = 0;
+        while ((current_char = fgetc(defaults_file)) != EOF) {
                 /* gobble up leading whitespace */
-                if (isspace(c))
+                if (isspace(current_char)) {
                         continue;
-                switch (c) {
+                }
+                switch (current_char) {
                         /* globble up comment lines */
                 case ';':
                 case '#':
-                        GOBBLE_TO(f, c, '\n');
+                        GOBBLE_TO(defaults_file, current_char, '\n');
                         break;
                         /* start of a stanza, check to see if it matches */
-                case '[':
+                case '[': {
                         stanzastate = WRONGSTANZA;
+                        size_t i;
                         for (i = 0; i < stanza_len; i++) {
-                                c = fgetc(f);
+                                current_char = fgetc(defaults_file);
                                 /* strip leading whitespace */
-                                if (i == 0)
-                                        for (; isspace(c); c = fgetc(f))
-                                                continue;
+                                if (i == 0) {
+                                        for (; isspace(current_char); current_char = fgetc(defaults_file)) {
+                                        }
+                                }
                                 /* nope, read to the end of the line */
-                                if (c != stanza[i]) {
-                                        GOBBLE_TO(f, c, '\n');
+                                if (current_char != stanza[i]) {
+                                        GOBBLE_TO(defaults_file, current_char, '\n');
                                         break;
                                 }
                         }
+
                         /* if it matched up to here and the next char is ']'... */
                         if (i == stanza_len) {
-                                c = fgetc(f);
+                                current_char = fgetc(defaults_file);
                                 /* strip trailing whitespace */
-                                for (; isspace(c); c = fgetc(f))
-                                        continue;
-                                if (c == ']')
+                                for (; isspace(current_char); current_char = fgetc(defaults_file)) {
+                                }
+                                if (current_char == ']') {
                                         stanzastate = RIGHTSTANZA;
+                                }
                         }
-                        break;
+                } break;
                         /* otherwise, we're in the body of a stanza or a parse error */
                 default:
                         switch (stanzastate) {
@@ -201,12 +217,12 @@ static int read_defaults(FILE *f, const char *stanza, np_arg_list **opts) {
                                 die(STATE_UNKNOWN, "%s\n", _("Config file error"));
                                 /* we're in a stanza, but for a different plugin */
                         case WRONGSTANZA:
-                                GOBBLE_TO(f, c, '\n');
+                                GOBBLE_TO(defaults_file, current_char, '\n');
                                 break;
                                 /* okay, this is where we start taking the config */
                         case RIGHTSTANZA:
-                                ungetc(c, f);
-                                if (add_option(f, opts)) {
+                                ungetc(current_char, defaults_file);
+                                if (add_option(defaults_file, opts)) {
                                         die(STATE_UNKNOWN, "%s\n", _("Config file error"));
                                 }
                                 status = true;
@@ -225,13 +241,12 @@ static int read_defaults(FILE *f, const char *stanza, np_arg_list **opts) {
  *      --option[=value]
  * appending it to the linked list optbuf.
  */
-static int add_option(FILE *f, np_arg_list **optlst) {
-        np_arg_list *opttmp = *optlst, *optnew;
-        char *linebuf = NULL, *lineend = NULL, *optptr = NULL, *optend = NULL;
-        char *eqptr = NULL, *valptr = NULL, *valend = NULL;
-        short done_reading = 0, equals = 0, value = 0;
-        size_t cfg_len = 0, read_sz = 8, linebuf_sz = 0, read_pos = 0;
-        size_t opt_len = 0, val_len = 0;
+static int add_option(FILE *filePointer, np_arg_list **optlst) {
+        char *linebuf = NULL;
+        bool done_reading = false;
+        const size_t read_sz = 8;
+        size_t linebuf_sz = 0;
+        size_t read_pos = 0;
 
         /* read one line from the file */
         while (!done_reading) {
@@ -239,74 +254,101 @@ static int add_option(FILE *f, np_arg_list **optlst) {
                 if (linebuf == NULL || read_pos + read_sz >= linebuf_sz) {
                         linebuf_sz = linebuf_sz > 0 ? linebuf_sz << 1 : read_sz;
                         linebuf = realloc(linebuf, linebuf_sz);
-                        if (linebuf == NULL)
+                        if (linebuf == NULL) {
                                 die(STATE_UNKNOWN, _("malloc() failed!\n"));
+                        }
                 }
-                if (fgets(&linebuf[read_pos], (int)read_sz, f) == NULL)
-                        done_reading = 1;
-                else {
+
+                if (fgets(&linebuf[read_pos], (int)read_sz, filePointer) == NULL) {
+                        done_reading = true;
+                } else {
                         read_pos = strlen(linebuf);
                         if (linebuf[read_pos - 1] == '\n') {
                                 linebuf[--read_pos] = '\0';
-                                done_reading = 1;
+                                done_reading = true;
                         }
                 }
         }
-        lineend = &linebuf[read_pos];
+
+        char *lineend = &linebuf[read_pos];
         /* all that to read one line, isn't C fun? :) now comes the parsing :/ */
 
         /* skip leading whitespace */
-        for (optptr = linebuf; optptr < lineend && isspace(*optptr); optptr++)
-                continue;
+        char *optptr = NULL;
+        for (optptr = linebuf; optptr < lineend && isspace(*optptr); optptr++) {
+        }
+
         /* continue to '=' or EOL, watching for spaces that might precede it */
+        char *eqptr = NULL;
+        char *optend = NULL;
         for (eqptr = optptr; eqptr < lineend && *eqptr != '='; eqptr++) {
-                if (isspace(*eqptr) && optend == NULL)
+                if (isspace(*eqptr) && optend == NULL) {
                         optend = eqptr;
-                else
+                } else {
                         optend = NULL;
+                }
         }
-        if (optend == NULL)
+
+        if (optend == NULL) {
                 optend = eqptr;
+        }
+
         --optend;
+
         /* ^[[:space:]]*=foo is a syntax error */
-        if (optptr == eqptr)
+        if (optptr == eqptr) {
                 die(STATE_UNKNOWN, "%s\n", _("Config file error"));
+        }
+
         /* continue from '=' to start of value or EOL */
-        for (valptr = eqptr + 1; valptr < lineend && isspace(*valptr); valptr++)
-                continue;
+        char *valptr = NULL;
+        for (valptr = eqptr + 1; valptr < lineend && isspace(*valptr); valptr++) {
+        }
+
         /* continue to the end of value */
-        for (valend = valptr; valend < lineend; valend++)
-                continue;
+        char *valend = NULL;
+        for (valend = valptr; valend < lineend; valend++) {
+        }
+
         --valend;
+
         /* finally trim off trailing spaces */
-        for (; isspace(*valend); valend--)
-                continue;
+        for (; isspace(*valend); valend--) {
+        }
+
         /* calculate the length of "--foo" */
-        opt_len = (size_t)(1 + optend - optptr);
+        size_t opt_len = (size_t)(1 + optend - optptr);
         /* 1-character params needs only one dash */
-        if (opt_len == 1)
+        size_t cfg_len = 0;
+        if (opt_len == 1) {
                 cfg_len = 1 + (opt_len);
-        else
+        } else {
                 cfg_len = 2 + (opt_len);
+        }
+
+        size_t val_len = 0;
+        bool equals = false;
+        bool value = false;
         /* if valptr<lineend then we have to also allocate space for "=bar" */
         if (valptr < lineend) {
-                equals = value = 1;
+                equals = value = true;
                 val_len = (size_t)(1 + valend - valptr);
                 cfg_len += 1 + val_len;
-        }
-        /* if valptr==valend then we have "=" but no "bar" */
-        else if (valptr == lineend) {
-                equals = 1;
+        } else if (valptr == lineend) {
+                /* if valptr==valend then we have "=" but no "bar" */
+                equals = true;
                 cfg_len += 1;
         }
+
         /* a line with no equal sign isn't valid */
-        if (equals == 0)
+        if (!equals) {
                 die(STATE_UNKNOWN, "%s\n", _("Config file error"));
+        }
 
         /* okay, now we have all the info we need, so we create a new np_arg_list
          * element and set the argument...
          */
-        optnew = malloc(sizeof(np_arg_list));
+        np_arg_list *optnew = malloc(sizeof(np_arg_list));
         optnew->next = NULL;
 
         read_pos = 0;
@@ -329,11 +371,13 @@ static int add_option(FILE *f, np_arg_list **optlst) {
         optnew->arg[read_pos] = '\0';
 
         /* ...and put that to the end of the list */
-        if (*optlst == NULL)
+        if (*optlst == NULL) {
                 *optlst = optnew;
-        else {
-                while (opttmp->next != NULL)
+        } else {
+                np_arg_list *opttmp = *optlst;
+                while (opttmp->next != NULL) {
                         opttmp = opttmp->next;
+                }
                 opttmp->next = optnew;
         }
 
@@ -344,7 +388,8 @@ static int add_option(FILE *f, np_arg_list **optlst) {
 static char *default_file(void) {
         char *ini_file;
 
-        if ((ini_file = getenv("MP_CONFIG_FILE")) != NULL || (ini_file = default_file_in_path()) != NULL) {
+        if ((ini_file = getenv("MP_CONFIG_FILE")) != NULL ||
+                (ini_file = default_file_in_path()) != NULL) {
                 return ini_file;
         }
 
@@ -357,19 +402,25 @@ static char *default_file(void) {
 }
 
 static char *default_file_in_path(void) {
-        char *config_path, **file;
-        char *dir, *ini_file, *tokens;
+        char *config_path;
+        char **file;
+        char *dir;
+        char *ini_file;
+        char *tokens;
 
-        if ((config_path = getenv("NAGIOS_CONFIG_PATH")) == NULL)
+        if ((config_path = getenv("NAGIOS_CONFIG_PATH")) == NULL) {
                 return NULL;
+        }
         /* shall we spit out a warning that NAGIOS_CONFIG_PATH is deprecated? */
 
-        if ((tokens = strdup(config_path)) == NULL)
+        if ((tokens = strdup(config_path)) == NULL) {
                 die(STATE_UNKNOWN, "%s\n", _("Insufficient Memory"));
+        }
         for (dir = strtok(tokens, ":"); dir != NULL; dir = strtok(NULL, ":")) {
                 for (file = default_ini_file_names; *file != NULL; file++) {
-                        if ((asprintf(&ini_file, "%s/%s", dir, *file)) < 0)
+                        if ((asprintf(&ini_file, "%s/%s", dir, *file)) < 0) {
                                 die(STATE_UNKNOWN, "%s\n", _("Insufficient Memory"));
+                        }
                         if (access(ini_file, F_OK) == 0) {
                                 free(tokens);
                                 return ini_file;
diff --git a/lib/perfdata.c b/lib/perfdata.c
new file mode 100644
index 00000000..2930a8bc
--- /dev/null
+++ b/lib/perfdata.c
@@ -0,0 +1,649 @@
+#include "./perfdata.h"
+#include "../plugins/common.h"
+#include "../plugins/utils.h"
+#include "utils_base.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <stdlib.h>
+
+char *pd_value_to_string(const mp_perfdata_value pd) {
+        char *result = NULL;
+
+        assert(pd.type != PD_TYPE_NONE);
+
+        switch (pd.type) {
+        case PD_TYPE_INT:
+                asprintf(&result, "%lli", pd.pd_int);
+                break;
+        case PD_TYPE_UINT:
+                asprintf(&result, "%llu", pd.pd_int);
+                break;
+        case PD_TYPE_DOUBLE:
+                asprintf(&result, "%f", pd.pd_double);
+                break;
+        default:
+                // die here
+                die(STATE_UNKNOWN, "Invalid mp_perfdata mode\n");
+        }
+
+        return result;
+}
+
+char *pd_to_string(mp_perfdata pd) {
+        assert(pd.label != NULL);
+        char *result = NULL;
+
+        if (strchr(pd.label, '\'') == NULL) {
+                asprintf(&result, "'%s'=", pd.label);
+        } else {
+                // we have a illegal single quote in the string
+                // replace it silently instead of complaining
+                for (char *ptr = pd.label; *ptr == '\0'; ptr++) {
+                        if (*ptr == '\'') {
+                                *ptr = '_';
+                        }
+                }
+        }
+
+        asprintf(&result, "%s%s", result, pd_value_to_string(pd.value));
+
+        if (pd.uom != NULL) {
+                asprintf(&result, "%s%s", result, pd.uom);
+        }
+
+        if (pd.warn_present) {
+                asprintf(&result, "%s;%s", result, mp_range_to_string(pd.warn));
+        } else {
+                asprintf(&result, "%s;", result);
+        }
+
+        if (pd.crit_present) {
+                asprintf(&result, "%s;%s", result, mp_range_to_string(pd.crit));
+        } else {
+                asprintf(&result, "%s;", result);
+        }
+        if (pd.min_present) {
+                asprintf(&result, "%s;%s", result, pd_value_to_string(pd.min));
+        } else {
+                asprintf(&result, "%s;", result);
+        }
+
+        if (pd.max_present) {
+                asprintf(&result, "%s;%s", result, pd_value_to_string(pd.max));
+        }
+
+        /*printf("pd_to_string: %s\n", result); */
+
+        return result;
+}
+
+char *pd_list_to_string(const pd_list pd) {
+        char *result = pd_to_string(pd.data);
+
+        for (pd_list *elem = pd.next; elem != NULL; elem = elem->next) {
+                asprintf(&result, "%s %s", result, pd_to_string(elem->data));
+        }
+
+        return result;
+}
+
+mp_perfdata perfdata_init() {
+        mp_perfdata pd = {};
+        return pd;
+}
+
+pd_list *pd_list_init() {
+        pd_list *tmp = (pd_list *)calloc(1, sizeof(pd_list));
+        if (tmp == NULL) {
+                die(STATE_UNKNOWN, "calloc failed\n");
+        }
+        tmp->next = NULL;
+        return tmp;
+}
+
+mp_range mp_range_init() {
+        mp_range result = {
+                .alert_on_inside_range = OUTSIDE,
+                .start = {},
+                .start_infinity = true,
+                .end = {},
+                .end_infinity = true,
+        };
+
+        return result;
+}
+
+mp_range mp_range_set_start(mp_range input, mp_perfdata_value perf_val) {
+        input.start = perf_val;
+        input.start_infinity = false;
+        return input;
+}
+
+mp_range mp_range_set_end(mp_range input, mp_perfdata_value perf_val) {
+        input.end = perf_val;
+        input.end_infinity = false;
+        return input;
+}
+
+void pd_list_append(pd_list pdl[1], const mp_perfdata pd) {
+        assert(pdl != NULL);
+
+        if (pdl->data.value.type == PD_TYPE_NONE) {
+                // first entry is still empty
+                pdl->data = pd;
+        } else {
+                // find last element in the list
+                pd_list *curr = pdl;
+                pd_list *next = pdl->next;
+
+                while (next != NULL) {
+                        curr = next;
+                        next = next->next;
+                }
+
+                if (curr->data.value.type == PD_TYPE_NONE) {
+                        // still empty
+                        curr->data = pd;
+                } else {
+                        // new a new one
+                        curr->next = pd_list_init();
+                        curr->next->data = pd;
+                }
+        }
+}
+
+void pd_list_free(pd_list pdl[1]) {
+        while (pdl != NULL) {
+                pd_list *old = pdl;
+                pdl = pdl->next;
+                free(old);
+        }
+}
+
+/*
+ * returns -1 if a < b, 0 if a == b, 1 if a > b
+ */
+int cmp_perfdata_value(const mp_perfdata_value a, const mp_perfdata_value b) {
+        // Test if types are different
+        if (a.type == b.type) {
+
+                switch (a.type) {
+                case PD_TYPE_UINT:
+                        if (a.pd_uint < b.pd_uint) {
+                                return -1;
+                        } else if (a.pd_uint == b.pd_uint) {
+                                return 0;
+                        } else {
+                                return 1;
+                        }
+                        break;
+                case PD_TYPE_INT:
+                        if (a.pd_int < b.pd_int) {
+                                return -1;
+                        } else if (a.pd_int == b.pd_int) {
+                                return 0;
+                        } else {
+                                return 1;
+                        }
+                        break;
+                case PD_TYPE_DOUBLE:
+                        if (a.pd_int < b.pd_int) {
+                                return -1;
+                        } else if (a.pd_int == b.pd_int) {
+                                return 0;
+                        } else {
+                                return 1;
+                        }
+                        break;
+                default:
+                        die(STATE_UNKNOWN, "Error in %s line: %d!", __FILE__, __LINE__);
+                }
+        }
+
+        // Get dirty here
+        long double floating_a = 0;
+
+        switch (a.type) {
+        case PD_TYPE_UINT:
+                floating_a = a.pd_uint;
+                break;
+        case PD_TYPE_INT:
+                floating_a = a.pd_int;
+                break;
+        case PD_TYPE_DOUBLE:
+                floating_a = a.pd_double;
+                break;
+        default:
+                die(STATE_UNKNOWN, "Error in %s line: %d!", __FILE__, __LINE__);
+        }
+
+        long double floating_b = 0;
+        switch (b.type) {
+        case PD_TYPE_UINT:
+                floating_b = b.pd_uint;
+                break;
+        case PD_TYPE_INT:
+                floating_b = b.pd_int;
+                break;
+        case PD_TYPE_DOUBLE:
+                floating_b = b.pd_double;
+                break;
+        default:
+                die(STATE_UNKNOWN, "Error in %s line: %d!", __FILE__, __LINE__);
+        }
+
+        if (floating_a < floating_b) {
+                return -1;
+        }
+        if (floating_a == floating_b) {
+                return 0;
+        }
+        return 1;
+}
+
+char *mp_range_to_string(const mp_range input) {
+        char *result = "";
+        if (input.alert_on_inside_range == INSIDE) {
+                asprintf(&result, "@");
+        }
+
+        if (input.start_infinity) {
+                asprintf(&result, "%s~:", result);
+        } else {
+                asprintf(&result, "%s%s:", result, pd_value_to_string(input.start));
+        }
+
+        if (!input.end_infinity) {
+                asprintf(&result, "%s%s", result, pd_value_to_string(input.end));
+        }
+        return result;
+}
+
+mp_perfdata mp_set_pd_value_float(mp_perfdata pd, float value) {
+        return mp_set_pd_value_double(pd, value);
+}
+
+mp_perfdata mp_set_pd_value_double(mp_perfdata pd, double value) {
+        pd.value.pd_double = value;
+        pd.value.type = PD_TYPE_DOUBLE;
+        return pd;
+}
+
+mp_perfdata mp_set_pd_value_char(mp_perfdata pd, char value) {
+        return mp_set_pd_value_long_long(pd, (long long)value);
+}
+
+mp_perfdata mp_set_pd_value_u_char(mp_perfdata pd, unsigned char value) {
+        return mp_set_pd_value_u_long_long(pd, (unsigned long long)value);
+}
+
+mp_perfdata mp_set_pd_value_int(mp_perfdata pd, int value) {
+        return mp_set_pd_value_long_long(pd, (long long)value);
+}
+
+mp_perfdata mp_set_pd_value_u_int(mp_perfdata pd, unsigned int value) {
+        return mp_set_pd_value_u_long_long(pd, (unsigned long long)value);
+}
+
+mp_perfdata mp_set_pd_value_long(mp_perfdata pd, long value) {
+        return mp_set_pd_value_long_long(pd, (long long)value);
+}
+
+mp_perfdata mp_set_pd_value_u_long(mp_perfdata pd, unsigned long value) {
+        return mp_set_pd_value_u_long_long(pd, (unsigned long long)value);
+}
+
+mp_perfdata mp_set_pd_value_long_long(mp_perfdata pd, long long value) {
+        pd.value.pd_int = value;
+        pd.value.type = PD_TYPE_INT;
+        return pd;
+}
+
+mp_perfdata mp_set_pd_value_u_long_long(mp_perfdata pd, unsigned long long value) {
+        pd.value.pd_uint = value;
+        pd.value.type = PD_TYPE_UINT;
+        return pd;
+}
+
+mp_perfdata_value mp_create_pd_value_double(double value) {
+        mp_perfdata_value res = {0};
+        res.type = PD_TYPE_DOUBLE;
+        res.pd_double = value;
+        return res;
+}
+
+mp_perfdata_value mp_create_pd_value_float(float value) {
+        return mp_create_pd_value_double((double)value);
+}
+
+mp_perfdata_value mp_create_pd_value_char(char value) {
+        return mp_create_pd_value_long_long((long long)value);
+}
+
+mp_perfdata_value mp_create_pd_value_u_char(unsigned char value) {
+        return mp_create_pd_value_u_long_long((unsigned long long)value);
+}
+
+mp_perfdata_value mp_create_pd_value_int(int value) {
+        return mp_create_pd_value_long_long((long long)value);
+}
+
+mp_perfdata_value mp_create_pd_value_u_int(unsigned int value) {
+        return mp_create_pd_value_u_long_long((unsigned long long)value);
+}
+
+mp_perfdata_value mp_create_pd_value_long(long value) {
+        return mp_create_pd_value_long_long((long long)value);
+}
+
+mp_perfdata_value mp_create_pd_value_u_long(unsigned long value) {
+        return mp_create_pd_value_u_long_long((unsigned long long)value);
+}
+
+mp_perfdata_value mp_create_pd_value_long_long(long long value) {
+        mp_perfdata_value res = {0};
+        res.type = PD_TYPE_INT;
+        res.pd_int = value;
+        return res;
+}
+
+mp_perfdata_value mp_create_pd_value_u_long_long(unsigned long long value) {
+        mp_perfdata_value res = {0};
+        res.type = PD_TYPE_UINT;
+        res.pd_uint = value;
+        return res;
+}
+
+char *fmt_range(range foo) { return foo.text; }
+
+typedef struct integer_parser_wrapper {
+        int error;
+        mp_perfdata_value value;
+} integer_parser_wrapper;
+
+typedef struct double_parser_wrapper {
+        int error;
+        mp_perfdata_value value;
+} double_parser_wrapper;
+
+typedef struct perfdata_value_parser_wrapper {
+        int error;
+        mp_perfdata_value value;
+} perfdata_value_parser_wrapper;
+
+double_parser_wrapper parse_double(const char *input);
+integer_parser_wrapper parse_integer(const char *input);
+perfdata_value_parser_wrapper parse_pd_value(const char *input);
+
+mp_range_parsed mp_parse_range_string(const char *input) {
+        if (input == NULL) {
+                mp_range_parsed result = {
+                        .error = MP_RANGE_PARSING_FAILURE,
+                };
+                return result;
+        }
+
+        if (strlen(input) == 0) {
+                mp_range_parsed result = {
+                        .error = MP_RANGE_PARSING_FAILURE,
+                };
+                return result;
+        }
+
+        mp_range_parsed result = {
+                .range = mp_range_init(),
+                .error = MP_PARSING_SUCCES,
+        };
+
+        if (input[0] == '@') {
+                // found an '@' at beginning, so invert the range logic
+                result.range.alert_on_inside_range = INSIDE;
+
+                // advance the pointer one symbol
+                input++;
+        }
+
+        char *working_copy = strdup(input);
+        if (working_copy == NULL) {
+                // strdup error, probably
+                mp_range_parsed result = {
+                        .error = MP_RANGE_PARSING_FAILURE,
+                };
+                return result;
+        }
+        input = working_copy;
+
+        char *separator = index(working_copy, ':');
+        if (separator != NULL) {
+                // Found a separator
+                // set the separator to 0, so we have two different strings
+                *separator = '\0';
+
+                if (input[0] == '~') {
+                        // the beginning starts with '~', so it might be infinity
+                        if (&input[1] != separator) {
+                                // the next symbol after '~' is not the separator!
+                                // so input is probably wrong
+                                result.error = MP_RANGE_PARSING_FAILURE;
+                                free(working_copy);
+                                return result;
+                        }
+
+                        result.range.start_infinity = true;
+                } else {
+                        // No '~' at the beginning, so this should be a number
+                        result.range.start_infinity = false;
+                        perfdata_value_parser_wrapper parsed_pd = parse_pd_value(input);
+
+                        if (parsed_pd.error != MP_PARSING_SUCCES) {
+                                result.error = parsed_pd.error;
+                                free(working_copy);
+                                return result;
+                        }
+
+                        result.range.start = parsed_pd.value;
+                        result.range.start_infinity = false;
+                }
+                // got the first part now
+                // advance the pointer
+                input = separator + 1;
+        }
+
+        // End part or no separator
+        if (input[0] == '\0') {
+                // the end is infinite
+                result.range.end_infinity = true;
+        } else {
+                perfdata_value_parser_wrapper parsed_pd = parse_pd_value(input);
+
+                if (parsed_pd.error != MP_PARSING_SUCCES) {
+                        result.error = parsed_pd.error;
+                        return result;
+                }
+                result.range.end = parsed_pd.value;
+                result.range.end_infinity = false;
+        }
+        free(working_copy);
+        return result;
+}
+
+double_parser_wrapper parse_double(const char *input) {
+        double_parser_wrapper result = {
+                .error = MP_PARSING_SUCCES,
+        };
+
+        if (input == NULL) {
+                result.error = MP_PARSING_FAILURE;
+                return result;
+        }
+
+        char *endptr = NULL;
+        errno = 0;
+        double tmp = strtod(input, &endptr);
+
+        if (input == endptr) {
+                // man 3 strtod says, no conversion performed
+                result.error = MP_PARSING_FAILURE;
+                return result;
+        }
+
+        if (errno) {
+                // some other error
+                // TODO maybe differentiate a little bit
+                result.error = MP_PARSING_FAILURE;
+                return result;
+        }
+
+        result.value = mp_create_pd_value(tmp);
+        return result;
+}
+
+integer_parser_wrapper parse_integer(const char *input) {
+        integer_parser_wrapper result = {
+                .error = MP_PARSING_SUCCES,
+        };
+
+        if (input == NULL) {
+                result.error = MP_PARSING_FAILURE;
+                return result;
+        }
+
+        char *endptr = NULL;
+        errno = 0;
+        long long tmp = strtoll(input, &endptr, 0);
+
+        // validating *sigh*
+        if (*endptr != '\0') {
+                // something went wrong in strtoll
+                if (tmp == LLONG_MIN) {
+                        // underflow
+                        result.error = MP_RANGE_PARSING_UNDERFLOW;
+                        return result;
+                }
+
+                if (tmp == LLONG_MAX) {
+                        // overflow
+                        result.error = MP_RANGE_PARSING_OVERFLOW;
+                        return result;
+                }
+
+                // still wrong, but not sure why, probably invalid characters
+                if (errno == EINVAL) {
+                        result.error = MP_RANGE_PARSING_INVALID_CHAR;
+                        return result;
+                }
+
+                // some other error, do catch all here
+                result.error = MP_RANGE_PARSING_FAILURE;
+                return result;
+        }
+
+        // no error, should be fine
+        result.value = mp_create_pd_value(tmp);
+        return result;
+}
+
+perfdata_value_parser_wrapper parse_pd_value(const char *input) {
+        // try integer first
+        integer_parser_wrapper tmp_int = parse_integer(input);
+
+        if (tmp_int.error == MP_PARSING_SUCCES) {
+                perfdata_value_parser_wrapper result = {
+                        .error = tmp_int.error,
+                        .value = tmp_int.value,
+                };
+                return result;
+        }
+
+        double_parser_wrapper tmp_double = parse_double(input);
+        perfdata_value_parser_wrapper result = {};
+        if (tmp_double.error == MP_PARSING_SUCCES) {
+                result.error = tmp_double.error;
+                result.value = tmp_double.value;
+        } else {
+                result.error = tmp_double.error;
+        }
+        return result;
+}
+
+mp_perfdata mp_set_pd_max_value(mp_perfdata perfdata, mp_perfdata_value value) {
+        perfdata.max = value;
+        perfdata.max_present = true;
+        return perfdata;
+}
+
+mp_perfdata mp_set_pd_min_value(mp_perfdata perfdata, mp_perfdata_value value) {
+        perfdata.min = value;
+        perfdata.min_present = true;
+        return perfdata;
+}
+
+double mp_get_pd_value(mp_perfdata_value value) {
+        assert(value.type != PD_TYPE_NONE);
+        switch (value.type) {
+        case PD_TYPE_DOUBLE:
+                return value.pd_double;
+        case PD_TYPE_INT:
+                return (double)value.pd_int;
+        case PD_TYPE_UINT:
+                return (double)value.pd_uint;
+        default:
+                return 0; // just to make the compiler happy
+        }
+}
+
+mp_perfdata_value mp_pd_value_multiply(mp_perfdata_value left, mp_perfdata_value right) {
+        if (left.type == right.type) {
+                switch (left.type) {
+                case PD_TYPE_DOUBLE:
+                        left.pd_double *= right.pd_double;
+                        return left;
+                case PD_TYPE_INT:
+                        left.pd_int *= right.pd_int;
+                        return left;
+                case PD_TYPE_UINT:
+                        left.pd_uint *= right.pd_uint;
+                        return left;
+                default:
+                        // what to here?
+                        return left;
+                }
+        }
+
+        // Different types, oh boy, just do the lazy thing for now and switch to double
+        switch (left.type) {
+        case PD_TYPE_INT:
+                left.pd_double = (double)left.pd_int;
+                left.type = PD_TYPE_DOUBLE;
+                break;
+        case PD_TYPE_UINT:
+                left.pd_double = (double)left.pd_uint;
+                left.type = PD_TYPE_DOUBLE;
+                break;
+        }
+
+        switch (right.type) {
+        case PD_TYPE_INT:
+                right.pd_double = (double)right.pd_int;
+                right.type = PD_TYPE_DOUBLE;
+                break;
+        case PD_TYPE_UINT:
+                right.pd_double = (double)right.pd_uint;
+                right.type = PD_TYPE_DOUBLE;
+                break;
+        }
+
+        left.pd_double *= right.pd_double;
+        return left;
+}
+
+mp_range mp_range_multiply(mp_range range, mp_perfdata_value factor) {
+        if (!range.end_infinity) {
+                range.end = mp_pd_value_multiply(range.end, factor);
+        }
+        if (!range.start_infinity) {
+                range.start = mp_pd_value_multiply(range.start, factor);
+        }
+        return range;
+}
diff --git a/lib/perfdata.h b/lib/perfdata.h
new file mode 100644
index 00000000..e51ef5fd
--- /dev/null
+++ b/lib/perfdata.h
@@ -0,0 +1,219 @@
+#pragma once
+
+#include "../config.h"
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+// Enum for the specific type of a perfdata_value
+typedef enum pd_value_type {
+        PD_TYPE_NONE = 0,
+        PD_TYPE_INT,
+        PD_TYPE_UINT,
+        PD_TYPE_DOUBLE
+} pd_value_type;
+
+typedef struct {
+        enum pd_value_type type;
+        union {
+                long long pd_int;
+                unsigned long long pd_uint;
+                double pd_double;
+        };
+} mp_perfdata_value;
+
+#define MP_OUTSIDE false
+#define MP_INSIDE  true
+
+/*
+ * New range type with generic numerical values
+ */
+typedef struct {
+        mp_perfdata_value start;
+        bool start_infinity; /* false (default) or true */
+
+        mp_perfdata_value end;
+        bool end_infinity;
+
+        bool alert_on_inside_range; /* OUTSIDE (default) or INSIDE */
+} mp_range;
+
+/*
+ * Old range type with floating point values
+ */
+typedef struct {
+        double start;
+        bool start_infinity;
+        double end;
+        bool end_infinity;
+        int alert_on; /* OUTSIDE (default) or INSIDE */
+        char *text;   /* original unparsed text input */
+} range;
+
+/*
+ * Perfdata type for storing perfdata output
+ */
+typedef struct {
+        char *label;
+        char *uom;
+        mp_perfdata_value value;
+
+        bool warn_present;
+        mp_range warn;
+
+        bool crit_present;
+        mp_range crit;
+
+        bool min_present;
+        mp_perfdata_value min;
+
+        bool max_present;
+        mp_perfdata_value max;
+} mp_perfdata;
+
+/*
+ * List of mp_perfdata values
+ */
+typedef struct pd_list_struct {
+        mp_perfdata data;
+        struct pd_list_struct *next;
+} pd_list;
+
+/*
+ * ============
+ * Initializers
+ * ============
+ */
+/*
+ * Initialize mp_perfdata value. Always use this to generate a new one
+ */
+mp_perfdata perfdata_init(void);
+
+/*
+ * Initialize pd_list value. Always use this to generate a new one
+ */
+pd_list *pd_list_init(void);
+
+/*
+ * Initialize a new mp_range value, with unset values (start and end are infinite
+ */
+mp_range mp_range_init(void);
+
+/*
+ * Worker functions
+ */
+
+mp_range mp_range_set_start(mp_range, mp_perfdata_value);
+mp_range mp_range_set_end(mp_range, mp_perfdata_value);
+
+/*
+ * Parsing a range from a string
+ */
+
+typedef enum {
+        MP_PARSING_SUCCES = 0,
+        MP_PARSING_FAILURE,
+        MP_RANGE_PARSING_FAILURE,
+        MP_RANGE_PARSING_UNDERFLOW,
+        MP_RANGE_PARSING_OVERFLOW,
+        MP_RANGE_PARSING_INVALID_CHAR,
+} mp_range_parser_error;
+
+typedef struct mp_range_parsed {
+        mp_range_parser_error error;
+        mp_range range;
+} mp_range_parsed;
+
+mp_range_parsed mp_parse_range_string(const char * /*input*/);
+
+/*
+ * Appends a mp_perfdata value to a pd_list
+ */
+void pd_list_append(pd_list[1], mp_perfdata);
+
+#define mp_set_pd_value(P, V)                                                                      \
+        _Generic((V),                                                                                  \
+                float: mp_set_pd_value_float,                                                              \
+                double: mp_set_pd_value_double,                                                            \
+                int: mp_set_pd_value_int,                                                                  \
+                unsigned int: mp_set_pd_value_u_int,                                                       \
+                long: mp_set_pd_value_long,                                                                \
+                unsigned long: mp_set_pd_value_u_long,                                                     \
+                long long: mp_set_pd_value_long_long,                                                      \
+                unsigned long long: mp_set_pd_value_u_long_long)(P, V)
+
+mp_perfdata mp_set_pd_value_float(mp_perfdata, float);
+mp_perfdata mp_set_pd_value_double(mp_perfdata, double);
+mp_perfdata mp_set_pd_value_int(mp_perfdata, int);
+mp_perfdata mp_set_pd_value_u_int(mp_perfdata, unsigned int);
+mp_perfdata mp_set_pd_value_long(mp_perfdata, long);
+mp_perfdata mp_set_pd_value_u_long(mp_perfdata, unsigned long);
+mp_perfdata mp_set_pd_value_long_long(mp_perfdata, long long);
+mp_perfdata mp_set_pd_value_u_long_long(mp_perfdata, unsigned long long);
+
+#define mp_create_pd_value(V)                                                                      \
+        _Generic((V),                                                                                  \
+                float: mp_create_pd_value_float,                                                           \
+                double: mp_create_pd_value_double,                                                         \
+                char: mp_create_pd_value_char,                                                             \
+                unsigned char: mp_create_pd_value_u_char,                                                  \
+                int: mp_create_pd_value_int,                                                               \
+                unsigned int: mp_create_pd_value_u_int,                                                    \
+                long: mp_create_pd_value_long,                                                             \
+                unsigned long: mp_create_pd_value_u_long,                                                  \
+                long long: mp_create_pd_value_long_long,                                                   \
+                unsigned long long: mp_create_pd_value_u_long_long)(V)
+
+mp_perfdata_value mp_create_pd_value_float(float);
+mp_perfdata_value mp_create_pd_value_double(double);
+mp_perfdata_value mp_create_pd_value_char(char);
+mp_perfdata_value mp_create_pd_value_u_char(unsigned char);
+mp_perfdata_value mp_create_pd_value_int(int);
+mp_perfdata_value mp_create_pd_value_u_int(unsigned int);
+mp_perfdata_value mp_create_pd_value_long(long);
+mp_perfdata_value mp_create_pd_value_u_long(unsigned long);
+mp_perfdata_value mp_create_pd_value_long_long(long long);
+mp_perfdata_value mp_create_pd_value_u_long_long(unsigned long long);
+
+mp_perfdata mp_set_pd_max_value(mp_perfdata perfdata, mp_perfdata_value value);
+mp_perfdata mp_set_pd_min_value(mp_perfdata perfdata, mp_perfdata_value value);
+
+double mp_get_pd_value(mp_perfdata_value value);
+
+/*
+ * Free the memory used by a pd_list
+ */
+void pd_list_free(pd_list[1]);
+
+int cmp_perfdata_value(mp_perfdata_value, mp_perfdata_value);
+
+// ================
+// Helper functions
+// ================
+
+mp_perfdata_value mp_pd_value_multiply(mp_perfdata_value left, mp_perfdata_value right);
+mp_range mp_range_multiply(mp_range range, mp_perfdata_value factor);
+
+// =================
+// String formatters
+// =================
+/*
+ * Generate string from mp_perfdata value
+ */
+char *pd_to_string(mp_perfdata);
+
+/*
+ * Generate string from perfdata_value value
+ */
+char *pd_value_to_string(mp_perfdata_value);
+
+/*
+ * Generate string from pd_list value for the final output
+ */
+char *pd_list_to_string(pd_list);
+
+/*
+ * Generate string from a mp_range value
+ */
+char *mp_range_to_string(mp_range);
+char *fmt_range(range);
diff --git a/lib/states.h b/lib/states.h
new file mode 100644
index 00000000..4a170caa
--- /dev/null
+++ b/lib/states.h
@@ -0,0 +1,71 @@
+#ifndef _MP_STATES_
+#define _MP_STATES_
+
+#include "../config.h"
+#include <sys/param.h>
+
+typedef enum state_enum {
+        STATE_OK,
+        STATE_WARNING,
+        STATE_CRITICAL,
+        STATE_UNKNOWN,
+        STATE_DEPENDENT
+} mp_state_enum;
+
+/* **************************************************************************
+ * max_state(STATE_x, STATE_y)
+ * compares STATE_x to  STATE_y and returns result based on the following
+ * STATE_UNKNOWN < STATE_OK < STATE_WARNING < STATE_CRITICAL
+ *
+ * Note that numerically the above does not hold
+ ****************************************************************************/
+
+static inline mp_state_enum max_state(mp_state_enum a, mp_state_enum b) {
+        if (a == STATE_CRITICAL || b == STATE_CRITICAL) {
+                return STATE_CRITICAL;
+        }
+        if (a == STATE_WARNING || b == STATE_WARNING) {
+                return STATE_WARNING;
+        }
+        if (a == STATE_OK || b == STATE_OK) {
+                return STATE_OK;
+        }
+        if (a == STATE_UNKNOWN || b == STATE_UNKNOWN) {
+                return STATE_UNKNOWN;
+        }
+        if (a == STATE_DEPENDENT || b == STATE_DEPENDENT) {
+                return STATE_DEPENDENT;
+        }
+        return MAX(a, b);
+}
+
+/* **************************************************************************
+ * max_state_alt(STATE_x, STATE_y)
+ * compares STATE_x to  STATE_y and returns result based on the following
+ * STATE_OK < STATE_DEPENDENT < STATE_UNKNOWN < STATE_WARNING < STATE_CRITICAL
+ *
+ * The main difference between max_state_alt and max_state it that it doesn't
+ * allow setting a default to UNKNOWN. It will instead prioritixe any valid
+ * non-OK state.
+ ****************************************************************************/
+
+static inline mp_state_enum max_state_alt(mp_state_enum a, mp_state_enum b) {
+        if (a == STATE_CRITICAL || b == STATE_CRITICAL) {
+                return STATE_CRITICAL;
+        }
+        if (a == STATE_WARNING || b == STATE_WARNING) {
+                return STATE_WARNING;
+        }
+        if (a == STATE_UNKNOWN || b == STATE_UNKNOWN) {
+                return STATE_UNKNOWN;
+        }
+        if (a == STATE_DEPENDENT || b == STATE_DEPENDENT) {
+                return STATE_DEPENDENT;
+        }
+        if (a == STATE_OK || b == STATE_OK) {
+                return STATE_OK;
+        }
+        return MAX(a, b);
+}
+
+#endif
diff --git a/lib/tests/Makefile.am b/lib/tests/Makefile.am
index 31d79df6..7798a72e 100644
--- a/lib/tests/Makefile.am
+++ b/lib/tests/Makefile.am
@@ -8,9 +8,9 @@ check_PROGRAMS = @EXTRA_TEST@
 AM_CPPFLAGS = -DNP_STATE_DIR_PREFIX=\"$(localstatedir)\" \
         -I$(top_srcdir)/lib -I$(top_srcdir)/gl -I$(top_srcdir)/intl -I$(top_srcdir)/plugins
 
-EXTRA_PROGRAMS = test_utils test_disk test_tcp test_cmd test_base64 test_ini1 test_ini3 test_opts1 test_opts2 test_opts3
+EXTRA_PROGRAMS = test_utils test_tcp test_cmd test_base64 test_ini1 test_ini3 test_opts1 test_opts2 test_opts3 test_generic_output
 
-np_test_scripts = test_base64.t test_cmd.t test_disk.t test_ini1.t test_ini3.t test_opts1.t test_opts2.t test_opts3.t test_tcp.t test_utils.t
+np_test_scripts = test_base64.t test_cmd.t test_ini1.t test_ini3.t test_opts1.t test_opts2.t test_opts3.t test_tcp.t test_utils.t test_generic_output.t
 np_test_files = config-dos.ini config-opts.ini config-tiny.ini plugin.ini plugins.ini
 EXTRA_DIST = $(np_test_scripts) $(np_test_files) var
 
@@ -29,7 +29,7 @@ AM_CFLAGS = -g -I$(top_srcdir)/lib -I$(top_srcdir)/gl $(tap_cflags)
 AM_LDFLAGS = $(tap_ldflags) -ltap
 LDADD = $(top_srcdir)/lib/libmonitoringplug.a $(top_srcdir)/gl/libgnu.a $(LIB_CRYPTO)
 
-SOURCES = test_utils.c test_disk.c test_tcp.c test_cmd.c test_base64.c test_ini1.c test_ini3.c test_opts1.c test_opts2.c test_opts3.c
+SOURCES = test_utils.c test_tcp.c test_cmd.c test_base64.c test_ini1.c test_ini3.c test_opts1.c test_opts2.c test_opts3.c test_generic_output.c
 
 test: ${noinst_PROGRAMS}
         perl -MTest::Harness -e '$$Test::Harness::switches=""; runtests(map {$$_ .= ".t"} @ARGV)' $(EXTRA_PROGRAMS)
diff --git a/lib/tests/test_base64.c b/lib/tests/test_base64.c
index 94cb5aa9..798244da 100644
--- a/lib/tests/test_base64.c
+++ b/lib/tests/test_base64.c
@@ -180,117 +180,168 @@ int main(int argc, char **argv) {
 #endif
 
         char random[1024] = {
-                0x0b, 0x30, 0x44, 0x62, 0x7c, 0x22, 0x1f, 0x0d, 0x05, 0x67, 0x2c, 0x2a, 0x39, 0x21, 0x46, 0x08, 0x50, 0x66, 0x34, 0x37, 0x0b, 0x45,
-                0x4b, 0x38, 0x32, 0x06, 0x7a, 0x3e, 0x7f, 0x0c, 0x40, 0x18, 0x6b, 0x2d, 0x60, 0x4c, 0x60, 0x0c, 0x23, 0x43, 0x3b, 0x3e, 0x1b, 0x16,
-                0x04, 0x46, 0x58, 0x3f, 0x40, 0x6a, 0x11, 0x05, 0x63, 0x71, 0x14, 0x35, 0x47, 0x79, 0x13, 0x6f, 0x6b, 0x27, 0x18, 0x5b, 0x48, 0x27,
-                0x3e, 0x6f, 0x15, 0x33, 0x4f, 0x3e, 0x5e, 0x51, 0x73, 0x68, 0x25, 0x0f, 0x06, 0x5b, 0x7c, 0x72, 0x75, 0x3e, 0x3f, 0x1b, 0x5c, 0x6d,
-                0x6a, 0x39, 0x7c, 0x63, 0x63, 0x60, 0x6c, 0x7a, 0x33, 0x76, 0x52, 0x13, 0x25, 0x33, 0x7d, 0x65, 0x23, 0x27, 0x11, 0x06, 0x06, 0x47,
-                0x71, 0x1e, 0x14, 0x74, 0x63, 0x70, 0x2d, 0x15, 0x27, 0x18, 0x51, 0x06, 0x05, 0x33, 0x11, 0x2c, 0x6b, 0x00, 0x2d, 0x77, 0x20, 0x48,
-                0x0d, 0x73, 0x51, 0x45, 0x25, 0x7f, 0x7f, 0x35, 0x26, 0x2e, 0x26, 0x53, 0x24, 0x68, 0x1e, 0x0e, 0x58, 0x3a, 0x59, 0x50, 0x56, 0x37,
-                0x5f, 0x66, 0x01, 0x4c, 0x5a, 0x64, 0x32, 0x50, 0x7b, 0x6a, 0x20, 0x72, 0x2b, 0x1d, 0x7e, 0x43, 0x7b, 0x61, 0x42, 0x0b, 0x61, 0x73,
-                0x24, 0x79, 0x3a, 0x6b, 0x4a, 0x79, 0x6e, 0x09, 0x0f, 0x27, 0x2d, 0x0c, 0x5e, 0x32, 0x4b, 0x0d, 0x79, 0x46, 0x39, 0x21, 0x0a, 0x26,
-                0x5f, 0x3a, 0x00, 0x26, 0x3f, 0x13, 0x2e, 0x7e, 0x50, 0x2b, 0x67, 0x46, 0x72, 0x3f, 0x3b, 0x01, 0x46, 0x1b, 0x0b, 0x35, 0x49, 0x39,
-                0x19, 0x70, 0x3d, 0x02, 0x41, 0x0e, 0x38, 0x05, 0x76, 0x65, 0x4f, 0x31, 0x6c, 0x5e, 0x17, 0x04, 0x15, 0x36, 0x26, 0x64, 0x34, 0x14,
-                0x17, 0x7c, 0x0e, 0x0b, 0x5b, 0x55, 0x53, 0x6b, 0x00, 0x42, 0x41, 0x4f, 0x02, 0x5c, 0x13, 0x0a, 0x2c, 0x2c, 0x3e, 0x10, 0x14, 0x33,
-                0x45, 0x7c, 0x7a, 0x5a, 0x31, 0x61, 0x39, 0x08, 0x22, 0x6a, 0x1e, 0x0f, 0x6f, 0x1b, 0x6c, 0x13, 0x5e, 0x79, 0x20, 0x79, 0x50, 0x62,
-                0x06, 0x2c, 0x76, 0x17, 0x04, 0x2b, 0x2a, 0x75, 0x1f, 0x0c, 0x37, 0x4e, 0x0f, 0x7b, 0x2d, 0x34, 0x75, 0x60, 0x31, 0x74, 0x2e, 0x0a,
-                0x4a, 0x11, 0x6c, 0x49, 0x25, 0x01, 0x3a, 0x3d, 0x22, 0x1e, 0x6d, 0x18, 0x51, 0x78, 0x2d, 0x62, 0x31, 0x4c, 0x50, 0x40, 0x17, 0x4b,
-                0x6f, 0x22, 0x00, 0x7f, 0x61, 0x2a, 0x34, 0x3e, 0x00, 0x5f, 0x2f, 0x5f, 0x2f, 0x14, 0x2a, 0x55, 0x27, 0x1f, 0x46, 0x1f, 0x12, 0x46,
-                0x5e, 0x1e, 0x0c, 0x7c, 0x38, 0x01, 0x61, 0x64, 0x76, 0x22, 0x6e, 0x08, 0x20, 0x38, 0x4f, 0x73, 0x72, 0x55, 0x12, 0x42, 0x19, 0x50,
-                0x61, 0x43, 0x77, 0x7d, 0x41, 0x2e, 0x35, 0x4f, 0x3d, 0x31, 0x28, 0x58, 0x67, 0x1b, 0x03, 0x51, 0x20, 0x32, 0x1c, 0x08, 0x6e, 0x37,
-                0x75, 0x37, 0x44, 0x4f, 0x68, 0x19, 0x07, 0x64, 0x14, 0x28, 0x25, 0x2b, 0x69, 0x35, 0x18, 0x27, 0x26, 0x14, 0x13, 0x70, 0x42, 0x19,
-                0x12, 0x75, 0x3e, 0x02, 0x5d, 0x7c, 0x13, 0x1f, 0x16, 0x53, 0x3b, 0x74, 0x48, 0x3c, 0x5e, 0x39, 0x6c, 0x1c, 0x1c, 0x74, 0x39, 0x1f,
-                0x00, 0x1b, 0x06, 0x0a, 0x68, 0x3b, 0x52, 0x4f, 0x1e, 0x6e, 0x3c, 0x35, 0x0c, 0x38, 0x0e, 0x0b, 0x3b, 0x1a, 0x76, 0x23, 0x29, 0x53,
-                0x1e, 0x5f, 0x41, 0x0c, 0x4b, 0x0a, 0x65, 0x28, 0x78, 0x67, 0x48, 0x59, 0x26, 0x6d, 0x31, 0x76, 0x23, 0x70, 0x61, 0x64, 0x3b, 0x38,
-                0x79, 0x66, 0x74, 0x53, 0x2c, 0x64, 0x64, 0x54, 0x03, 0x54, 0x65, 0x44, 0x4c, 0x18, 0x4f, 0x48, 0x20, 0x4f, 0x72, 0x10, 0x3f, 0x0c,
-                0x52, 0x2d, 0x03, 0x14, 0x03, 0x51, 0x42, 0x10, 0x77, 0x6a, 0x34, 0x06, 0x32, 0x03, 0x72, 0x14, 0x7c, 0x08, 0x5d, 0x52, 0x1a, 0x62,
-                0x7c, 0x3e, 0x30, 0x7e, 0x5f, 0x7f, 0x54, 0x0f, 0x44, 0x49, 0x5d, 0x5e, 0x10, 0x6a, 0x06, 0x2b, 0x06, 0x53, 0x10, 0x39, 0x37, 0x32,
-                0x4a, 0x4e, 0x3d, 0x2b, 0x65, 0x38, 0x39, 0x07, 0x72, 0x54, 0x64, 0x4d, 0x56, 0x6a, 0x03, 0x22, 0x70, 0x7b, 0x5f, 0x60, 0x0b, 0x2a,
-                0x0b, 0x6b, 0x10, 0x64, 0x14, 0x05, 0x22, 0x00, 0x73, 0x40, 0x23, 0x5b, 0x51, 0x1f, 0x2b, 0x1a, 0x5d, 0x69, 0x7a, 0x46, 0x0c, 0x5f,
-                0x32, 0x4b, 0x4a, 0x28, 0x52, 0x79, 0x5b, 0x12, 0x42, 0x18, 0x00, 0x5d, 0x27, 0x31, 0x53, 0x3c, 0x4c, 0x36, 0x4e, 0x38, 0x3f, 0x72,
-                0x03, 0x71, 0x02, 0x5b, 0x36, 0x59, 0x7f, 0x75, 0x6e, 0x08, 0x54, 0x0d, 0x34, 0x1c, 0x34, 0x57, 0x5d, 0x69, 0x48, 0x00, 0x3b, 0x05,
-                0x07, 0x6e, 0x27, 0x65, 0x6e, 0x40, 0x3d, 0x3a, 0x4f, 0x72, 0x5d, 0x39, 0x16, 0x0f, 0x63, 0x12, 0x12, 0x15, 0x3a, 0x70, 0x0d, 0x57,
-                0x18, 0x0d, 0x5e, 0x3d, 0x22, 0x68, 0x68, 0x7c, 0x6d, 0x4f, 0x0c, 0x7b, 0x09, 0x2d, 0x4a, 0x73, 0x20, 0x47, 0x07, 0x57, 0x75, 0x5d,
-                0x53, 0x70, 0x34, 0x21, 0x40, 0x57, 0x51, 0x5e, 0x49, 0x44, 0x00, 0x54, 0x27, 0x04, 0x68, 0x7e, 0x59, 0x56, 0x58, 0x74, 0x14, 0x3c,
-                0x16, 0x33, 0x41, 0x16, 0x4b, 0x2f, 0x49, 0x37, 0x0a, 0x54, 0x08, 0x08, 0x1f, 0x39, 0x67, 0x76, 0x28, 0x28, 0x07, 0x1d, 0x61, 0x47,
-                0x51, 0x4d, 0x75, 0x26, 0x52, 0x47, 0x47, 0x0c, 0x57, 0x58, 0x74, 0x3e, 0x62, 0x6c, 0x58, 0x3a, 0x44, 0x1e, 0x16, 0x2e, 0x21, 0x1c,
-                0x73, 0x45, 0x67, 0x74, 0x4f, 0x33, 0x66, 0x0e, 0x74, 0x66, 0x26, 0x1f, 0x2e, 0x38, 0x44, 0x40, 0x7e, 0x2a, 0x50, 0x52, 0x5e, 0x43,
-                0x01, 0x7a, 0x38, 0x49, 0x3c, 0x55, 0x4d, 0x5a, 0x44, 0x08, 0x26, 0x59, 0x4d, 0x45, 0x0b, 0x48, 0x0a, 0x33, 0x5e, 0x4a, 0x4d, 0x75,
-                0x16, 0x17, 0x63, 0x46, 0x01, 0x2a, 0x55, 0x7b, 0x0f, 0x02, 0x73, 0x6a, 0x4b, 0x7f, 0x75, 0x65, 0x3c, 0x4c, 0x33, 0x39, 0x6c, 0x74,
-                0x05, 0x60, 0x0f, 0x7f, 0x2d, 0x41, 0x4d, 0x4d, 0x46, 0x71, 0x09, 0x6f, 0x4f, 0x60, 0x15, 0x0f, 0x46, 0x73, 0x63, 0x4c, 0x5e, 0x74,
-                0x30, 0x0d, 0x28, 0x43, 0x08, 0x72, 0x32, 0x04, 0x2e, 0x31, 0x29, 0x27, 0x44, 0x6d, 0x13, 0x17, 0x48, 0x0f, 0x49, 0x52, 0x10, 0x13,
-                0x7f, 0x17, 0x16, 0x62, 0x79, 0x35, 0x78, 0x3e, 0x01, 0x7c, 0x2e, 0x0f, 0x76, 0x3e, 0x5e, 0x53, 0x6c, 0x5b, 0x5f, 0x7c, 0x19, 0x41,
-                0x02, 0x2f, 0x17, 0x64, 0x41, 0x75, 0x10, 0x04, 0x47, 0x7c, 0x3d, 0x4b, 0x52, 0x00, 0x10, 0x5d, 0x51, 0x4e, 0x7a, 0x27, 0x25, 0x55,
-                0x40, 0x12, 0x35, 0x60, 0x05, 0x1b, 0x34, 0x2d, 0x04, 0x7a, 0x6a, 0x69, 0x02, 0x79, 0x03, 0x3a, 0x2f, 0x06, 0x0a, 0x79, 0x7b, 0x12,
-                0x5d, 0x7c, 0x52, 0x29, 0x47, 0x58, 0x12, 0x73, 0x3f, 0x27, 0x56, 0x05, 0x0c, 0x48, 0x32, 0x58, 0x6b, 0x57, 0x5c, 0x03, 0x64, 0x56,
-                0x11, 0x52, 0x7a, 0x30, 0x36, 0x29, 0x17, 0x3b, 0x68, 0x7a, 0x7c, 0x05, 0x6b, 0x6b, 0x13, 0x6a, 0x24, 0x5c, 0x68, 0x42, 0x18, 0x32,
-                0x03, 0x73, 0x6e, 0x04, 0x21, 0x2e, 0x01, 0x04, 0x63, 0x7d, 0x44, 0x41, 0x12, 0x31, 0x0b, 0x15, 0x1f, 0x70, 0x00, 0x2e, 0x66, 0x14,
-                0x3c, 0x7f, 0x2b, 0x00, 0x1f, 0x0c, 0x28, 0x59, 0x0a, 0x16, 0x49, 0x5a, 0x5c, 0x64, 0x65, 0x4b, 0x11, 0x29, 0x15, 0x36, 0x5a, 0x65,
-                0x19, 0x4f, 0x60, 0x23, 0x3a, 0x3a, 0x13, 0x25, 0x02, 0x78, 0x4c, 0x54};
+                0x0b, 0x30, 0x44, 0x62, 0x7c, 0x22, 0x1f, 0x0d, 0x05, 0x67, 0x2c, 0x2a, 0x39, 0x21, 0x46,
+                0x08, 0x50, 0x66, 0x34, 0x37, 0x0b, 0x45, 0x4b, 0x38, 0x32, 0x06, 0x7a, 0x3e, 0x7f, 0x0c,
+                0x40, 0x18, 0x6b, 0x2d, 0x60, 0x4c, 0x60, 0x0c, 0x23, 0x43, 0x3b, 0x3e, 0x1b, 0x16, 0x04,
+                0x46, 0x58, 0x3f, 0x40, 0x6a, 0x11, 0x05, 0x63, 0x71, 0x14, 0x35, 0x47, 0x79, 0x13, 0x6f,
+                0x6b, 0x27, 0x18, 0x5b, 0x48, 0x27, 0x3e, 0x6f, 0x15, 0x33, 0x4f, 0x3e, 0x5e, 0x51, 0x73,
+                0x68, 0x25, 0x0f, 0x06, 0x5b, 0x7c, 0x72, 0x75, 0x3e, 0x3f, 0x1b, 0x5c, 0x6d, 0x6a, 0x39,
+                0x7c, 0x63, 0x63, 0x60, 0x6c, 0x7a, 0x33, 0x76, 0x52, 0x13, 0x25, 0x33, 0x7d, 0x65, 0x23,
+                0x27, 0x11, 0x06, 0x06, 0x47, 0x71, 0x1e, 0x14, 0x74, 0x63, 0x70, 0x2d, 0x15, 0x27, 0x18,
+                0x51, 0x06, 0x05, 0x33, 0x11, 0x2c, 0x6b, 0x00, 0x2d, 0x77, 0x20, 0x48, 0x0d, 0x73, 0x51,
+                0x45, 0x25, 0x7f, 0x7f, 0x35, 0x26, 0x2e, 0x26, 0x53, 0x24, 0x68, 0x1e, 0x0e, 0x58, 0x3a,
+                0x59, 0x50, 0x56, 0x37, 0x5f, 0x66, 0x01, 0x4c, 0x5a, 0x64, 0x32, 0x50, 0x7b, 0x6a, 0x20,
+                0x72, 0x2b, 0x1d, 0x7e, 0x43, 0x7b, 0x61, 0x42, 0x0b, 0x61, 0x73, 0x24, 0x79, 0x3a, 0x6b,
+                0x4a, 0x79, 0x6e, 0x09, 0x0f, 0x27, 0x2d, 0x0c, 0x5e, 0x32, 0x4b, 0x0d, 0x79, 0x46, 0x39,
+                0x21, 0x0a, 0x26, 0x5f, 0x3a, 0x00, 0x26, 0x3f, 0x13, 0x2e, 0x7e, 0x50, 0x2b, 0x67, 0x46,
+                0x72, 0x3f, 0x3b, 0x01, 0x46, 0x1b, 0x0b, 0x35, 0x49, 0x39, 0x19, 0x70, 0x3d, 0x02, 0x41,
+                0x0e, 0x38, 0x05, 0x76, 0x65, 0x4f, 0x31, 0x6c, 0x5e, 0x17, 0x04, 0x15, 0x36, 0x26, 0x64,
+                0x34, 0x14, 0x17, 0x7c, 0x0e, 0x0b, 0x5b, 0x55, 0x53, 0x6b, 0x00, 0x42, 0x41, 0x4f, 0x02,
+                0x5c, 0x13, 0x0a, 0x2c, 0x2c, 0x3e, 0x10, 0x14, 0x33, 0x45, 0x7c, 0x7a, 0x5a, 0x31, 0x61,
+                0x39, 0x08, 0x22, 0x6a, 0x1e, 0x0f, 0x6f, 0x1b, 0x6c, 0x13, 0x5e, 0x79, 0x20, 0x79, 0x50,
+                0x62, 0x06, 0x2c, 0x76, 0x17, 0x04, 0x2b, 0x2a, 0x75, 0x1f, 0x0c, 0x37, 0x4e, 0x0f, 0x7b,
+                0x2d, 0x34, 0x75, 0x60, 0x31, 0x74, 0x2e, 0x0a, 0x4a, 0x11, 0x6c, 0x49, 0x25, 0x01, 0x3a,
+                0x3d, 0x22, 0x1e, 0x6d, 0x18, 0x51, 0x78, 0x2d, 0x62, 0x31, 0x4c, 0x50, 0x40, 0x17, 0x4b,
+                0x6f, 0x22, 0x00, 0x7f, 0x61, 0x2a, 0x34, 0x3e, 0x00, 0x5f, 0x2f, 0x5f, 0x2f, 0x14, 0x2a,
+                0x55, 0x27, 0x1f, 0x46, 0x1f, 0x12, 0x46, 0x5e, 0x1e, 0x0c, 0x7c, 0x38, 0x01, 0x61, 0x64,
+                0x76, 0x22, 0x6e, 0x08, 0x20, 0x38, 0x4f, 0x73, 0x72, 0x55, 0x12, 0x42, 0x19, 0x50, 0x61,
+                0x43, 0x77, 0x7d, 0x41, 0x2e, 0x35, 0x4f, 0x3d, 0x31, 0x28, 0x58, 0x67, 0x1b, 0x03, 0x51,
+                0x20, 0x32, 0x1c, 0x08, 0x6e, 0x37, 0x75, 0x37, 0x44, 0x4f, 0x68, 0x19, 0x07, 0x64, 0x14,
+                0x28, 0x25, 0x2b, 0x69, 0x35, 0x18, 0x27, 0x26, 0x14, 0x13, 0x70, 0x42, 0x19, 0x12, 0x75,
+                0x3e, 0x02, 0x5d, 0x7c, 0x13, 0x1f, 0x16, 0x53, 0x3b, 0x74, 0x48, 0x3c, 0x5e, 0x39, 0x6c,
+                0x1c, 0x1c, 0x74, 0x39, 0x1f, 0x00, 0x1b, 0x06, 0x0a, 0x68, 0x3b, 0x52, 0x4f, 0x1e, 0x6e,
+                0x3c, 0x35, 0x0c, 0x38, 0x0e, 0x0b, 0x3b, 0x1a, 0x76, 0x23, 0x29, 0x53, 0x1e, 0x5f, 0x41,
+                0x0c, 0x4b, 0x0a, 0x65, 0x28, 0x78, 0x67, 0x48, 0x59, 0x26, 0x6d, 0x31, 0x76, 0x23, 0x70,
+                0x61, 0x64, 0x3b, 0x38, 0x79, 0x66, 0x74, 0x53, 0x2c, 0x64, 0x64, 0x54, 0x03, 0x54, 0x65,
+                0x44, 0x4c, 0x18, 0x4f, 0x48, 0x20, 0x4f, 0x72, 0x10, 0x3f, 0x0c, 0x52, 0x2d, 0x03, 0x14,
+                0x03, 0x51, 0x42, 0x10, 0x77, 0x6a, 0x34, 0x06, 0x32, 0x03, 0x72, 0x14, 0x7c, 0x08, 0x5d,
+                0x52, 0x1a, 0x62, 0x7c, 0x3e, 0x30, 0x7e, 0x5f, 0x7f, 0x54, 0x0f, 0x44, 0x49, 0x5d, 0x5e,
+                0x10, 0x6a, 0x06, 0x2b, 0x06, 0x53, 0x10, 0x39, 0x37, 0x32, 0x4a, 0x4e, 0x3d, 0x2b, 0x65,
+                0x38, 0x39, 0x07, 0x72, 0x54, 0x64, 0x4d, 0x56, 0x6a, 0x03, 0x22, 0x70, 0x7b, 0x5f, 0x60,
+                0x0b, 0x2a, 0x0b, 0x6b, 0x10, 0x64, 0x14, 0x05, 0x22, 0x00, 0x73, 0x40, 0x23, 0x5b, 0x51,
+                0x1f, 0x2b, 0x1a, 0x5d, 0x69, 0x7a, 0x46, 0x0c, 0x5f, 0x32, 0x4b, 0x4a, 0x28, 0x52, 0x79,
+                0x5b, 0x12, 0x42, 0x18, 0x00, 0x5d, 0x27, 0x31, 0x53, 0x3c, 0x4c, 0x36, 0x4e, 0x38, 0x3f,
+                0x72, 0x03, 0x71, 0x02, 0x5b, 0x36, 0x59, 0x7f, 0x75, 0x6e, 0x08, 0x54, 0x0d, 0x34, 0x1c,
+                0x34, 0x57, 0x5d, 0x69, 0x48, 0x00, 0x3b, 0x05, 0x07, 0x6e, 0x27, 0x65, 0x6e, 0x40, 0x3d,
+                0x3a, 0x4f, 0x72, 0x5d, 0x39, 0x16, 0x0f, 0x63, 0x12, 0x12, 0x15, 0x3a, 0x70, 0x0d, 0x57,
+                0x18, 0x0d, 0x5e, 0x3d, 0x22, 0x68, 0x68, 0x7c, 0x6d, 0x4f, 0x0c, 0x7b, 0x09, 0x2d, 0x4a,
+                0x73, 0x20, 0x47, 0x07, 0x57, 0x75, 0x5d, 0x53, 0x70, 0x34, 0x21, 0x40, 0x57, 0x51, 0x5e,
+                0x49, 0x44, 0x00, 0x54, 0x27, 0x04, 0x68, 0x7e, 0x59, 0x56, 0x58, 0x74, 0x14, 0x3c, 0x16,
+                0x33, 0x41, 0x16, 0x4b, 0x2f, 0x49, 0x37, 0x0a, 0x54, 0x08, 0x08, 0x1f, 0x39, 0x67, 0x76,
+                0x28, 0x28, 0x07, 0x1d, 0x61, 0x47, 0x51, 0x4d, 0x75, 0x26, 0x52, 0x47, 0x47, 0x0c, 0x57,
+                0x58, 0x74, 0x3e, 0x62, 0x6c, 0x58, 0x3a, 0x44, 0x1e, 0x16, 0x2e, 0x21, 0x1c, 0x73, 0x45,
+                0x67, 0x74, 0x4f, 0x33, 0x66, 0x0e, 0x74, 0x66, 0x26, 0x1f, 0x2e, 0x38, 0x44, 0x40, 0x7e,
+                0x2a, 0x50, 0x52, 0x5e, 0x43, 0x01, 0x7a, 0x38, 0x49, 0x3c, 0x55, 0x4d, 0x5a, 0x44, 0x08,
+                0x26, 0x59, 0x4d, 0x45, 0x0b, 0x48, 0x0a, 0x33, 0x5e, 0x4a, 0x4d, 0x75, 0x16, 0x17, 0x63,
+                0x46, 0x01, 0x2a, 0x55, 0x7b, 0x0f, 0x02, 0x73, 0x6a, 0x4b, 0x7f, 0x75, 0x65, 0x3c, 0x4c,
+                0x33, 0x39, 0x6c, 0x74, 0x05, 0x60, 0x0f, 0x7f, 0x2d, 0x41, 0x4d, 0x4d, 0x46, 0x71, 0x09,
+                0x6f, 0x4f, 0x60, 0x15, 0x0f, 0x46, 0x73, 0x63, 0x4c, 0x5e, 0x74, 0x30, 0x0d, 0x28, 0x43,
+                0x08, 0x72, 0x32, 0x04, 0x2e, 0x31, 0x29, 0x27, 0x44, 0x6d, 0x13, 0x17, 0x48, 0x0f, 0x49,
+                0x52, 0x10, 0x13, 0x7f, 0x17, 0x16, 0x62, 0x79, 0x35, 0x78, 0x3e, 0x01, 0x7c, 0x2e, 0x0f,
+                0x76, 0x3e, 0x5e, 0x53, 0x6c, 0x5b, 0x5f, 0x7c, 0x19, 0x41, 0x02, 0x2f, 0x17, 0x64, 0x41,
+                0x75, 0x10, 0x04, 0x47, 0x7c, 0x3d, 0x4b, 0x52, 0x00, 0x10, 0x5d, 0x51, 0x4e, 0x7a, 0x27,
+                0x25, 0x55, 0x40, 0x12, 0x35, 0x60, 0x05, 0x1b, 0x34, 0x2d, 0x04, 0x7a, 0x6a, 0x69, 0x02,
+                0x79, 0x03, 0x3a, 0x2f, 0x06, 0x0a, 0x79, 0x7b, 0x12, 0x5d, 0x7c, 0x52, 0x29, 0x47, 0x58,
+                0x12, 0x73, 0x3f, 0x27, 0x56, 0x05, 0x0c, 0x48, 0x32, 0x58, 0x6b, 0x57, 0x5c, 0x03, 0x64,
+                0x56, 0x11, 0x52, 0x7a, 0x30, 0x36, 0x29, 0x17, 0x3b, 0x68, 0x7a, 0x7c, 0x05, 0x6b, 0x6b,
+                0x13, 0x6a, 0x24, 0x5c, 0x68, 0x42, 0x18, 0x32, 0x03, 0x73, 0x6e, 0x04, 0x21, 0x2e, 0x01,
+                0x04, 0x63, 0x7d, 0x44, 0x41, 0x12, 0x31, 0x0b, 0x15, 0x1f, 0x70, 0x00, 0x2e, 0x66, 0x14,
+                0x3c, 0x7f, 0x2b, 0x00, 0x1f, 0x0c, 0x28, 0x59, 0x0a, 0x16, 0x49, 0x5a, 0x5c, 0x64, 0x65,
+                0x4b, 0x11, 0x29, 0x15, 0x36, 0x5a, 0x65, 0x19, 0x4f, 0x60, 0x23, 0x3a, 0x3a, 0x13, 0x25,
+                0x02, 0x78, 0x4c, 0x54};
         char b64_known[1369] = {
-                0x43, 0x7a, 0x42, 0x45, 0x59, 0x6e, 0x77, 0x69, 0x48, 0x77, 0x30, 0x46, 0x5a, 0x79, 0x77, 0x71, 0x4f, 0x53, 0x46, 0x47, 0x43, 0x46,
-                0x42, 0x6d, 0x4e, 0x44, 0x63, 0x4c, 0x52, 0x55, 0x73, 0x34, 0x4d, 0x67, 0x5a, 0x36, 0x50, 0x6e, 0x38, 0x4d, 0x51, 0x42, 0x68, 0x72,
-                0x4c, 0x57, 0x42, 0x4d, 0x59, 0x41, 0x77, 0x6a, 0x51, 0x7a, 0x73, 0x2b, 0x47, 0x78, 0x59, 0x45, 0x52, 0x6c, 0x67, 0x2f, 0x51, 0x47,
-                0x6f, 0x52, 0x42, 0x57, 0x4e, 0x78, 0x46, 0x44, 0x56, 0x48, 0x65, 0x52, 0x4e, 0x76, 0x61, 0x79, 0x63, 0x59, 0x57, 0x30, 0x67, 0x6e,
-                0x50, 0x6d, 0x38, 0x56, 0x4d, 0x30, 0x38, 0x2b, 0x58, 0x6c, 0x46, 0x7a, 0x61, 0x43, 0x55, 0x50, 0x42, 0x6c, 0x74, 0x38, 0x63, 0x6e,
-                0x55, 0x2b, 0x50, 0x78, 0x74, 0x63, 0x62, 0x57, 0x6f, 0x35, 0x66, 0x47, 0x4e, 0x6a, 0x59, 0x47, 0x78, 0x36, 0x4d, 0x33, 0x5a, 0x53,
-                0x45, 0x79, 0x55, 0x7a, 0x66, 0x57, 0x55, 0x6a, 0x4a, 0x78, 0x45, 0x47, 0x42, 0x6b, 0x64, 0x78, 0x48, 0x68, 0x52, 0x30, 0x59, 0x33,
-                0x41, 0x74, 0x46, 0x53, 0x63, 0x59, 0x55, 0x51, 0x59, 0x46, 0x4d, 0x78, 0x45, 0x73, 0x61, 0x77, 0x41, 0x74, 0x64, 0x79, 0x42, 0x49,
-                0x44, 0x58, 0x4e, 0x52, 0x52, 0x53, 0x56, 0x2f, 0x66, 0x7a, 0x55, 0x6d, 0x4c, 0x69, 0x5a, 0x54, 0x4a, 0x47, 0x67, 0x65, 0x44, 0x6c,
-                0x67, 0x36, 0x57, 0x56, 0x42, 0x57, 0x4e, 0x31, 0x39, 0x6d, 0x41, 0x55, 0x78, 0x61, 0x5a, 0x44, 0x4a, 0x51, 0x65, 0x32, 0x6f, 0x67,
-                0x63, 0x69, 0x73, 0x64, 0x66, 0x6b, 0x4e, 0x37, 0x59, 0x55, 0x49, 0x4c, 0x59, 0x58, 0x4d, 0x6b, 0x65, 0x54, 0x70, 0x72, 0x53, 0x6e,
-                0x6c, 0x75, 0x43, 0x51, 0x38, 0x6e, 0x4c, 0x51, 0x78, 0x65, 0x4d, 0x6b, 0x73, 0x4e, 0x65, 0x55, 0x59, 0x35, 0x49, 0x51, 0x6f, 0x6d,
-                0x58, 0x7a, 0x6f, 0x41, 0x4a, 0x6a, 0x38, 0x54, 0x4c, 0x6e, 0x35, 0x51, 0x4b, 0x32, 0x64, 0x47, 0x63, 0x6a, 0x38, 0x37, 0x41, 0x55,
-                0x59, 0x62, 0x43, 0x7a, 0x56, 0x4a, 0x4f, 0x52, 0x6c, 0x77, 0x50, 0x51, 0x4a, 0x42, 0x44, 0x6a, 0x67, 0x46, 0x64, 0x6d, 0x56, 0x50,
-                0x4d, 0x57, 0x78, 0x65, 0x46, 0x77, 0x51, 0x56, 0x4e, 0x69, 0x5a, 0x6b, 0x4e, 0x42, 0x51, 0x58, 0x66, 0x41, 0x34, 0x4c, 0x57, 0x31,
-                0x56, 0x54, 0x61, 0x77, 0x42, 0x43, 0x51, 0x55, 0x38, 0x43, 0x58, 0x42, 0x4d, 0x4b, 0x4c, 0x43, 0x77, 0x2b, 0x45, 0x42, 0x51, 0x7a,
-                0x52, 0x58, 0x78, 0x36, 0x57, 0x6a, 0x46, 0x68, 0x4f, 0x51, 0x67, 0x69, 0x61, 0x68, 0x34, 0x50, 0x62, 0x78, 0x74, 0x73, 0x45, 0x31,
-                0x35, 0x35, 0x49, 0x48, 0x6c, 0x51, 0x59, 0x67, 0x59, 0x73, 0x64, 0x68, 0x63, 0x45, 0x4b, 0x79, 0x70, 0x31, 0x48, 0x77, 0x77, 0x33,
-                0x54, 0x67, 0x39, 0x37, 0x4c, 0x54, 0x52, 0x31, 0x59, 0x44, 0x46, 0x30, 0x4c, 0x67, 0x70, 0x4b, 0x45, 0x57, 0x78, 0x4a, 0x4a, 0x51,
-                0x45, 0x36, 0x50, 0x53, 0x49, 0x65, 0x62, 0x52, 0x68, 0x52, 0x65, 0x43, 0x31, 0x69, 0x4d, 0x55, 0x78, 0x51, 0x51, 0x42, 0x64, 0x4c,
-                0x62, 0x79, 0x49, 0x41, 0x66, 0x32, 0x45, 0x71, 0x4e, 0x44, 0x34, 0x41, 0x58, 0x79, 0x39, 0x66, 0x4c, 0x78, 0x51, 0x71, 0x56, 0x53,
-                0x63, 0x66, 0x52, 0x68, 0x38, 0x53, 0x52, 0x6c, 0x34, 0x65, 0x44, 0x48, 0x77, 0x34, 0x41, 0x57, 0x46, 0x6b, 0x64, 0x69, 0x4a, 0x75,
-                0x43, 0x43, 0x41, 0x34, 0x54, 0x33, 0x4e, 0x79, 0x56, 0x52, 0x4a, 0x43, 0x47, 0x56, 0x42, 0x68, 0x51, 0x33, 0x64, 0x39, 0x51, 0x53,
-                0x34, 0x31, 0x54, 0x7a, 0x30, 0x78, 0x4b, 0x46, 0x68, 0x6e, 0x47, 0x77, 0x4e, 0x52, 0x49, 0x44, 0x49, 0x63, 0x43, 0x47, 0x34, 0x33,
-                0x64, 0x54, 0x64, 0x45, 0x54, 0x32, 0x67, 0x5a, 0x42, 0x32, 0x51, 0x55, 0x4b, 0x43, 0x55, 0x72, 0x61, 0x54, 0x55, 0x59, 0x4a, 0x79,
-                0x59, 0x55, 0x45, 0x33, 0x42, 0x43, 0x47, 0x52, 0x4a, 0x31, 0x50, 0x67, 0x4a, 0x64, 0x66, 0x42, 0x4d, 0x66, 0x46, 0x6c, 0x4d, 0x37,
-                0x64, 0x45, 0x67, 0x38, 0x58, 0x6a, 0x6c, 0x73, 0x48, 0x42, 0x78, 0x30, 0x4f, 0x52, 0x38, 0x41, 0x47, 0x77, 0x59, 0x4b, 0x61, 0x44,
-                0x74, 0x53, 0x54, 0x78, 0x35, 0x75, 0x50, 0x44, 0x55, 0x4d, 0x4f, 0x41, 0x34, 0x4c, 0x4f, 0x78, 0x70, 0x32, 0x49, 0x79, 0x6c, 0x54,
-                0x48, 0x6c, 0x39, 0x42, 0x44, 0x45, 0x73, 0x4b, 0x5a, 0x53, 0x68, 0x34, 0x5a, 0x30, 0x68, 0x5a, 0x4a, 0x6d, 0x30, 0x78, 0x64, 0x69,
-                0x4e, 0x77, 0x59, 0x57, 0x51, 0x37, 0x4f, 0x48, 0x6c, 0x6d, 0x64, 0x46, 0x4d, 0x73, 0x5a, 0x47, 0x52, 0x55, 0x41, 0x31, 0x52, 0x6c,
-                0x52, 0x45, 0x77, 0x59, 0x54, 0x30, 0x67, 0x67, 0x54, 0x33, 0x49, 0x51, 0x50, 0x77, 0x78, 0x53, 0x4c, 0x51, 0x4d, 0x55, 0x41, 0x31,
-                0x46, 0x43, 0x45, 0x48, 0x64, 0x71, 0x4e, 0x41, 0x59, 0x79, 0x41, 0x33, 0x49, 0x55, 0x66, 0x41, 0x68, 0x64, 0x55, 0x68, 0x70, 0x69,
-                0x66, 0x44, 0x34, 0x77, 0x66, 0x6c, 0x39, 0x2f, 0x56, 0x41, 0x39, 0x45, 0x53, 0x56, 0x31, 0x65, 0x45, 0x47, 0x6f, 0x47, 0x4b, 0x77,
-                0x5a, 0x54, 0x45, 0x44, 0x6b, 0x33, 0x4d, 0x6b, 0x70, 0x4f, 0x50, 0x53, 0x74, 0x6c, 0x4f, 0x44, 0x6b, 0x48, 0x63, 0x6c, 0x52, 0x6b,
-                0x54, 0x56, 0x5a, 0x71, 0x41, 0x79, 0x4a, 0x77, 0x65, 0x31, 0x39, 0x67, 0x43, 0x79, 0x6f, 0x4c, 0x61, 0x78, 0x42, 0x6b, 0x46, 0x41,
-                0x55, 0x69, 0x41, 0x48, 0x4e, 0x41, 0x49, 0x31, 0x74, 0x52, 0x48, 0x79, 0x73, 0x61, 0x58, 0x57, 0x6c, 0x36, 0x52, 0x67, 0x78, 0x66,
-                0x4d, 0x6b, 0x74, 0x4b, 0x4b, 0x46, 0x4a, 0x35, 0x57, 0x78, 0x4a, 0x43, 0x47, 0x41, 0x42, 0x64, 0x4a, 0x7a, 0x46, 0x54, 0x50, 0x45,
-                0x77, 0x32, 0x54, 0x6a, 0x67, 0x2f, 0x63, 0x67, 0x4e, 0x78, 0x41, 0x6c, 0x73, 0x32, 0x57, 0x58, 0x39, 0x31, 0x62, 0x67, 0x68, 0x55,
-                0x44, 0x54, 0x51, 0x63, 0x4e, 0x46, 0x64, 0x64, 0x61, 0x55, 0x67, 0x41, 0x4f, 0x77, 0x55, 0x48, 0x62, 0x69, 0x64, 0x6c, 0x62, 0x6b,
-                0x41, 0x39, 0x4f, 0x6b, 0x39, 0x79, 0x58, 0x54, 0x6b, 0x57, 0x44, 0x32, 0x4d, 0x53, 0x45, 0x68, 0x55, 0x36, 0x63, 0x41, 0x31, 0x58,
-                0x47, 0x41, 0x31, 0x65, 0x50, 0x53, 0x4a, 0x6f, 0x61, 0x48, 0x78, 0x74, 0x54, 0x77, 0x78, 0x37, 0x43, 0x53, 0x31, 0x4b, 0x63, 0x79,
-                0x42, 0x48, 0x42, 0x31, 0x64, 0x31, 0x58, 0x56, 0x4e, 0x77, 0x4e, 0x43, 0x46, 0x41, 0x56, 0x31, 0x46, 0x65, 0x53, 0x55, 0x51, 0x41,
-                0x56, 0x43, 0x63, 0x45, 0x61, 0x48, 0x35, 0x5a, 0x56, 0x6c, 0x68, 0x30, 0x46, 0x44, 0x77, 0x57, 0x4d, 0x30, 0x45, 0x57, 0x53, 0x79,
-                0x39, 0x4a, 0x4e, 0x77, 0x70, 0x55, 0x43, 0x41, 0x67, 0x66, 0x4f, 0x57, 0x64, 0x32, 0x4b, 0x43, 0x67, 0x48, 0x48, 0x57, 0x46, 0x48,
-                0x55, 0x55, 0x31, 0x31, 0x4a, 0x6c, 0x4a, 0x48, 0x52, 0x77, 0x78, 0x58, 0x57, 0x48, 0x51, 0x2b, 0x59, 0x6d, 0x78, 0x59, 0x4f, 0x6b,
-                0x51, 0x65, 0x46, 0x69, 0x34, 0x68, 0x48, 0x48, 0x4e, 0x46, 0x5a, 0x33, 0x52, 0x50, 0x4d, 0x32, 0x59, 0x4f, 0x64, 0x47, 0x59, 0x6d,
-                0x48, 0x79, 0x34, 0x34, 0x52, 0x45, 0x42, 0x2b, 0x4b, 0x6c, 0x42, 0x53, 0x58, 0x6b, 0x4d, 0x42, 0x65, 0x6a, 0x68, 0x4a, 0x50, 0x46,
-                0x56, 0x4e, 0x57, 0x6b, 0x51, 0x49, 0x4a, 0x6c, 0x6c, 0x4e, 0x52, 0x51, 0x74, 0x49, 0x43, 0x6a, 0x4e, 0x65, 0x53, 0x6b, 0x31, 0x31,
-                0x46, 0x68, 0x64, 0x6a, 0x52, 0x67, 0x45, 0x71, 0x56, 0x58, 0x73, 0x50, 0x41, 0x6e, 0x4e, 0x71, 0x53, 0x33, 0x39, 0x31, 0x5a, 0x54,
-                0x78, 0x4d, 0x4d, 0x7a, 0x6c, 0x73, 0x64, 0x41, 0x56, 0x67, 0x44, 0x33, 0x38, 0x74, 0x51, 0x55, 0x31, 0x4e, 0x52, 0x6e, 0x45, 0x4a,
-                0x62, 0x30, 0x39, 0x67, 0x46, 0x51, 0x39, 0x47, 0x63, 0x32, 0x4e, 0x4d, 0x58, 0x6e, 0x51, 0x77, 0x44, 0x53, 0x68, 0x44, 0x43, 0x48,
-                0x49, 0x79, 0x42, 0x43, 0x34, 0x78, 0x4b, 0x53, 0x64, 0x45, 0x62, 0x52, 0x4d, 0x58, 0x53, 0x41, 0x39, 0x4a, 0x55, 0x68, 0x41, 0x54,
-                0x66, 0x78, 0x63, 0x57, 0x59, 0x6e, 0x6b, 0x31, 0x65, 0x44, 0x34, 0x42, 0x66, 0x43, 0x34, 0x50, 0x64, 0x6a, 0x35, 0x65, 0x55, 0x32,
-                0x78, 0x62, 0x58, 0x33, 0x77, 0x5a, 0x51, 0x51, 0x49, 0x76, 0x46, 0x32, 0x52, 0x42, 0x64, 0x52, 0x41, 0x45, 0x52, 0x33, 0x77, 0x39,
-                0x53, 0x31, 0x49, 0x41, 0x45, 0x46, 0x31, 0x52, 0x54, 0x6e, 0x6f, 0x6e, 0x4a, 0x56, 0x56, 0x41, 0x45, 0x6a, 0x56, 0x67, 0x42, 0x52,
-                0x73, 0x30, 0x4c, 0x51, 0x52, 0x36, 0x61, 0x6d, 0x6b, 0x43, 0x65, 0x51, 0x4d, 0x36, 0x4c, 0x77, 0x59, 0x4b, 0x65, 0x58, 0x73, 0x53,
-                0x58, 0x58, 0x78, 0x53, 0x4b, 0x55, 0x64, 0x59, 0x45, 0x6e, 0x4d, 0x2f, 0x4a, 0x31, 0x59, 0x46, 0x44, 0x45, 0x67, 0x79, 0x57, 0x47,
-                0x74, 0x58, 0x58, 0x41, 0x4e, 0x6b, 0x56, 0x68, 0x46, 0x53, 0x65, 0x6a, 0x41, 0x32, 0x4b, 0x52, 0x63, 0x37, 0x61, 0x48, 0x70, 0x38,
-                0x42, 0x57, 0x74, 0x72, 0x45, 0x32, 0x6f, 0x6b, 0x58, 0x47, 0x68, 0x43, 0x47, 0x44, 0x49, 0x44, 0x63, 0x32, 0x34, 0x45, 0x49, 0x53,
-                0x34, 0x42, 0x42, 0x47, 0x4e, 0x39, 0x52, 0x45, 0x45, 0x53, 0x4d, 0x51, 0x73, 0x56, 0x48, 0x33, 0x41, 0x41, 0x4c, 0x6d, 0x59, 0x55,
-                0x50, 0x48, 0x38, 0x72, 0x41, 0x42, 0x38, 0x4d, 0x4b, 0x46, 0x6b, 0x4b, 0x46, 0x6b, 0x6c, 0x61, 0x58, 0x47, 0x52, 0x6c, 0x53, 0x78,
-                0x45, 0x70, 0x46, 0x54, 0x5a, 0x61, 0x5a, 0x52, 0x6c, 0x50, 0x59, 0x43, 0x4d, 0x36, 0x4f, 0x68, 0x4d, 0x6c, 0x41, 0x6e, 0x68, 0x4d,
-                0x56, 0x41, 0x3d, 0x3d, 0x00};
+                0x43, 0x7a, 0x42, 0x45, 0x59, 0x6e, 0x77, 0x69, 0x48, 0x77, 0x30, 0x46, 0x5a, 0x79, 0x77,
+                0x71, 0x4f, 0x53, 0x46, 0x47, 0x43, 0x46, 0x42, 0x6d, 0x4e, 0x44, 0x63, 0x4c, 0x52, 0x55,
+                0x73, 0x34, 0x4d, 0x67, 0x5a, 0x36, 0x50, 0x6e, 0x38, 0x4d, 0x51, 0x42, 0x68, 0x72, 0x4c,
+                0x57, 0x42, 0x4d, 0x59, 0x41, 0x77, 0x6a, 0x51, 0x7a, 0x73, 0x2b, 0x47, 0x78, 0x59, 0x45,
+                0x52, 0x6c, 0x67, 0x2f, 0x51, 0x47, 0x6f, 0x52, 0x42, 0x57, 0x4e, 0x78, 0x46, 0x44, 0x56,
+                0x48, 0x65, 0x52, 0x4e, 0x76, 0x61, 0x79, 0x63, 0x59, 0x57, 0x30, 0x67, 0x6e, 0x50, 0x6d,
+                0x38, 0x56, 0x4d, 0x30, 0x38, 0x2b, 0x58, 0x6c, 0x46, 0x7a, 0x61, 0x43, 0x55, 0x50, 0x42,
+                0x6c, 0x74, 0x38, 0x63, 0x6e, 0x55, 0x2b, 0x50, 0x78, 0x74, 0x63, 0x62, 0x57, 0x6f, 0x35,
+                0x66, 0x47, 0x4e, 0x6a, 0x59, 0x47, 0x78, 0x36, 0x4d, 0x33, 0x5a, 0x53, 0x45, 0x79, 0x55,
+                0x7a, 0x66, 0x57, 0x55, 0x6a, 0x4a, 0x78, 0x45, 0x47, 0x42, 0x6b, 0x64, 0x78, 0x48, 0x68,
+                0x52, 0x30, 0x59, 0x33, 0x41, 0x74, 0x46, 0x53, 0x63, 0x59, 0x55, 0x51, 0x59, 0x46, 0x4d,
+                0x78, 0x45, 0x73, 0x61, 0x77, 0x41, 0x74, 0x64, 0x79, 0x42, 0x49, 0x44, 0x58, 0x4e, 0x52,
+                0x52, 0x53, 0x56, 0x2f, 0x66, 0x7a, 0x55, 0x6d, 0x4c, 0x69, 0x5a, 0x54, 0x4a, 0x47, 0x67,
+                0x65, 0x44, 0x6c, 0x67, 0x36, 0x57, 0x56, 0x42, 0x57, 0x4e, 0x31, 0x39, 0x6d, 0x41, 0x55,
+                0x78, 0x61, 0x5a, 0x44, 0x4a, 0x51, 0x65, 0x32, 0x6f, 0x67, 0x63, 0x69, 0x73, 0x64, 0x66,
+                0x6b, 0x4e, 0x37, 0x59, 0x55, 0x49, 0x4c, 0x59, 0x58, 0x4d, 0x6b, 0x65, 0x54, 0x70, 0x72,
+                0x53, 0x6e, 0x6c, 0x75, 0x43, 0x51, 0x38, 0x6e, 0x4c, 0x51, 0x78, 0x65, 0x4d, 0x6b, 0x73,
+                0x4e, 0x65, 0x55, 0x59, 0x35, 0x49, 0x51, 0x6f, 0x6d, 0x58, 0x7a, 0x6f, 0x41, 0x4a, 0x6a,
+                0x38, 0x54, 0x4c, 0x6e, 0x35, 0x51, 0x4b, 0x32, 0x64, 0x47, 0x63, 0x6a, 0x38, 0x37, 0x41,
+                0x55, 0x59, 0x62, 0x43, 0x7a, 0x56, 0x4a, 0x4f, 0x52, 0x6c, 0x77, 0x50, 0x51, 0x4a, 0x42,
+                0x44, 0x6a, 0x67, 0x46, 0x64, 0x6d, 0x56, 0x50, 0x4d, 0x57, 0x78, 0x65, 0x46, 0x77, 0x51,
+                0x56, 0x4e, 0x69, 0x5a, 0x6b, 0x4e, 0x42, 0x51, 0x58, 0x66, 0x41, 0x34, 0x4c, 0x57, 0x31,
+                0x56, 0x54, 0x61, 0x77, 0x42, 0x43, 0x51, 0x55, 0x38, 0x43, 0x58, 0x42, 0x4d, 0x4b, 0x4c,
+                0x43, 0x77, 0x2b, 0x45, 0x42, 0x51, 0x7a, 0x52, 0x58, 0x78, 0x36, 0x57, 0x6a, 0x46, 0x68,
+                0x4f, 0x51, 0x67, 0x69, 0x61, 0x68, 0x34, 0x50, 0x62, 0x78, 0x74, 0x73, 0x45, 0x31, 0x35,
+                0x35, 0x49, 0x48, 0x6c, 0x51, 0x59, 0x67, 0x59, 0x73, 0x64, 0x68, 0x63, 0x45, 0x4b, 0x79,
+                0x70, 0x31, 0x48, 0x77, 0x77, 0x33, 0x54, 0x67, 0x39, 0x37, 0x4c, 0x54, 0x52, 0x31, 0x59,
+                0x44, 0x46, 0x30, 0x4c, 0x67, 0x70, 0x4b, 0x45, 0x57, 0x78, 0x4a, 0x4a, 0x51, 0x45, 0x36,
+                0x50, 0x53, 0x49, 0x65, 0x62, 0x52, 0x68, 0x52, 0x65, 0x43, 0x31, 0x69, 0x4d, 0x55, 0x78,
+                0x51, 0x51, 0x42, 0x64, 0x4c, 0x62, 0x79, 0x49, 0x41, 0x66, 0x32, 0x45, 0x71, 0x4e, 0x44,
+                0x34, 0x41, 0x58, 0x79, 0x39, 0x66, 0x4c, 0x78, 0x51, 0x71, 0x56, 0x53, 0x63, 0x66, 0x52,
+                0x68, 0x38, 0x53, 0x52, 0x6c, 0x34, 0x65, 0x44, 0x48, 0x77, 0x34, 0x41, 0x57, 0x46, 0x6b,
+                0x64, 0x69, 0x4a, 0x75, 0x43, 0x43, 0x41, 0x34, 0x54, 0x33, 0x4e, 0x79, 0x56, 0x52, 0x4a,
+                0x43, 0x47, 0x56, 0x42, 0x68, 0x51, 0x33, 0x64, 0x39, 0x51, 0x53, 0x34, 0x31, 0x54, 0x7a,
+                0x30, 0x78, 0x4b, 0x46, 0x68, 0x6e, 0x47, 0x77, 0x4e, 0x52, 0x49, 0x44, 0x49, 0x63, 0x43,
+                0x47, 0x34, 0x33, 0x64, 0x54, 0x64, 0x45, 0x54, 0x32, 0x67, 0x5a, 0x42, 0x32, 0x51, 0x55,
+                0x4b, 0x43, 0x55, 0x72, 0x61, 0x54, 0x55, 0x59, 0x4a, 0x79, 0x59, 0x55, 0x45, 0x33, 0x42,
+                0x43, 0x47, 0x52, 0x4a, 0x31, 0x50, 0x67, 0x4a, 0x64, 0x66, 0x42, 0x4d, 0x66, 0x46, 0x6c,
+                0x4d, 0x37, 0x64, 0x45, 0x67, 0x38, 0x58, 0x6a, 0x6c, 0x73, 0x48, 0x42, 0x78, 0x30, 0x4f,
+                0x52, 0x38, 0x41, 0x47, 0x77, 0x59, 0x4b, 0x61, 0x44, 0x74, 0x53, 0x54, 0x78, 0x35, 0x75,
+                0x50, 0x44, 0x55, 0x4d, 0x4f, 0x41, 0x34, 0x4c, 0x4f, 0x78, 0x70, 0x32, 0x49, 0x79, 0x6c,
+                0x54, 0x48, 0x6c, 0x39, 0x42, 0x44, 0x45, 0x73, 0x4b, 0x5a, 0x53, 0x68, 0x34, 0x5a, 0x30,
+                0x68, 0x5a, 0x4a, 0x6d, 0x30, 0x78, 0x64, 0x69, 0x4e, 0x77, 0x59, 0x57, 0x51, 0x37, 0x4f,
+                0x48, 0x6c, 0x6d, 0x64, 0x46, 0x4d, 0x73, 0x5a, 0x47, 0x52, 0x55, 0x41, 0x31, 0x52, 0x6c,
+                0x52, 0x45, 0x77, 0x59, 0x54, 0x30, 0x67, 0x67, 0x54, 0x33, 0x49, 0x51, 0x50, 0x77, 0x78,
+                0x53, 0x4c, 0x51, 0x4d, 0x55, 0x41, 0x31, 0x46, 0x43, 0x45, 0x48, 0x64, 0x71, 0x4e, 0x41,
+                0x59, 0x79, 0x41, 0x33, 0x49, 0x55, 0x66, 0x41, 0x68, 0x64, 0x55, 0x68, 0x70, 0x69, 0x66,
+                0x44, 0x34, 0x77, 0x66, 0x6c, 0x39, 0x2f, 0x56, 0x41, 0x39, 0x45, 0x53, 0x56, 0x31, 0x65,
+                0x45, 0x47, 0x6f, 0x47, 0x4b, 0x77, 0x5a, 0x54, 0x45, 0x44, 0x6b, 0x33, 0x4d, 0x6b, 0x70,
+                0x4f, 0x50, 0x53, 0x74, 0x6c, 0x4f, 0x44, 0x6b, 0x48, 0x63, 0x6c, 0x52, 0x6b, 0x54, 0x56,
+                0x5a, 0x71, 0x41, 0x79, 0x4a, 0x77, 0x65, 0x31, 0x39, 0x67, 0x43, 0x79, 0x6f, 0x4c, 0x61,
+                0x78, 0x42, 0x6b, 0x46, 0x41, 0x55, 0x69, 0x41, 0x48, 0x4e, 0x41, 0x49, 0x31, 0x74, 0x52,
+                0x48, 0x79, 0x73, 0x61, 0x58, 0x57, 0x6c, 0x36, 0x52, 0x67, 0x78, 0x66, 0x4d, 0x6b, 0x74,
+                0x4b, 0x4b, 0x46, 0x4a, 0x35, 0x57, 0x78, 0x4a, 0x43, 0x47, 0x41, 0x42, 0x64, 0x4a, 0x7a,
+                0x46, 0x54, 0x50, 0x45, 0x77, 0x32, 0x54, 0x6a, 0x67, 0x2f, 0x63, 0x67, 0x4e, 0x78, 0x41,
+                0x6c, 0x73, 0x32, 0x57, 0x58, 0x39, 0x31, 0x62, 0x67, 0x68, 0x55, 0x44, 0x54, 0x51, 0x63,
+                0x4e, 0x46, 0x64, 0x64, 0x61, 0x55, 0x67, 0x41, 0x4f, 0x77, 0x55, 0x48, 0x62, 0x69, 0x64,
+                0x6c, 0x62, 0x6b, 0x41, 0x39, 0x4f, 0x6b, 0x39, 0x79, 0x58, 0x54, 0x6b, 0x57, 0x44, 0x32,
+                0x4d, 0x53, 0x45, 0x68, 0x55, 0x36, 0x63, 0x41, 0x31, 0x58, 0x47, 0x41, 0x31, 0x65, 0x50,
+                0x53, 0x4a, 0x6f, 0x61, 0x48, 0x78, 0x74, 0x54, 0x77, 0x78, 0x37, 0x43, 0x53, 0x31, 0x4b,
+                0x63, 0x79, 0x42, 0x48, 0x42, 0x31, 0x64, 0x31, 0x58, 0x56, 0x4e, 0x77, 0x4e, 0x43, 0x46,
+                0x41, 0x56, 0x31, 0x46, 0x65, 0x53, 0x55, 0x51, 0x41, 0x56, 0x43, 0x63, 0x45, 0x61, 0x48,
+                0x35, 0x5a, 0x56, 0x6c, 0x68, 0x30, 0x46, 0x44, 0x77, 0x57, 0x4d, 0x30, 0x45, 0x57, 0x53,
+                0x79, 0x39, 0x4a, 0x4e, 0x77, 0x70, 0x55, 0x43, 0x41, 0x67, 0x66, 0x4f, 0x57, 0x64, 0x32,
+                0x4b, 0x43, 0x67, 0x48, 0x48, 0x57, 0x46, 0x48, 0x55, 0x55, 0x31, 0x31, 0x4a, 0x6c, 0x4a,
+                0x48, 0x52, 0x77, 0x78, 0x58, 0x57, 0x48, 0x51, 0x2b, 0x59, 0x6d, 0x78, 0x59, 0x4f, 0x6b,
+                0x51, 0x65, 0x46, 0x69, 0x34, 0x68, 0x48, 0x48, 0x4e, 0x46, 0x5a, 0x33, 0x52, 0x50, 0x4d,
+                0x32, 0x59, 0x4f, 0x64, 0x47, 0x59, 0x6d, 0x48, 0x79, 0x34, 0x34, 0x52, 0x45, 0x42, 0x2b,
+                0x4b, 0x6c, 0x42, 0x53, 0x58, 0x6b, 0x4d, 0x42, 0x65, 0x6a, 0x68, 0x4a, 0x50, 0x46, 0x56,
+                0x4e, 0x57, 0x6b, 0x51, 0x49, 0x4a, 0x6c, 0x6c, 0x4e, 0x52, 0x51, 0x74, 0x49, 0x43, 0x6a,
+                0x4e, 0x65, 0x53, 0x6b, 0x31, 0x31, 0x46, 0x68, 0x64, 0x6a, 0x52, 0x67, 0x45, 0x71, 0x56,
+                0x58, 0x73, 0x50, 0x41, 0x6e, 0x4e, 0x71, 0x53, 0x33, 0x39, 0x31, 0x5a, 0x54, 0x78, 0x4d,
+                0x4d, 0x7a, 0x6c, 0x73, 0x64, 0x41, 0x56, 0x67, 0x44, 0x33, 0x38, 0x74, 0x51, 0x55, 0x31,
+                0x4e, 0x52, 0x6e, 0x45, 0x4a, 0x62, 0x30, 0x39, 0x67, 0x46, 0x51, 0x39, 0x47, 0x63, 0x32,
+                0x4e, 0x4d, 0x58, 0x6e, 0x51, 0x77, 0x44, 0x53, 0x68, 0x44, 0x43, 0x48, 0x49, 0x79, 0x42,
+                0x43, 0x34, 0x78, 0x4b, 0x53, 0x64, 0x45, 0x62, 0x52, 0x4d, 0x58, 0x53, 0x41, 0x39, 0x4a,
+                0x55, 0x68, 0x41, 0x54, 0x66, 0x78, 0x63, 0x57, 0x59, 0x6e, 0x6b, 0x31, 0x65, 0x44, 0x34,
+                0x42, 0x66, 0x43, 0x34, 0x50, 0x64, 0x6a, 0x35, 0x65, 0x55, 0x32, 0x78, 0x62, 0x58, 0x33,
+                0x77, 0x5a, 0x51, 0x51, 0x49, 0x76, 0x46, 0x32, 0x52, 0x42, 0x64, 0x52, 0x41, 0x45, 0x52,
+                0x33, 0x77, 0x39, 0x53, 0x31, 0x49, 0x41, 0x45, 0x46, 0x31, 0x52, 0x54, 0x6e, 0x6f, 0x6e,
+                0x4a, 0x56, 0x56, 0x41, 0x45, 0x6a, 0x56, 0x67, 0x42, 0x52, 0x73, 0x30, 0x4c, 0x51, 0x52,
+                0x36, 0x61, 0x6d, 0x6b, 0x43, 0x65, 0x51, 0x4d, 0x36, 0x4c, 0x77, 0x59, 0x4b, 0x65, 0x58,
+                0x73, 0x53, 0x58, 0x58, 0x78, 0x53, 0x4b, 0x55, 0x64, 0x59, 0x45, 0x6e, 0x4d, 0x2f, 0x4a,
+                0x31, 0x59, 0x46, 0x44, 0x45, 0x67, 0x79, 0x57, 0x47, 0x74, 0x58, 0x58, 0x41, 0x4e, 0x6b,
+                0x56, 0x68, 0x46, 0x53, 0x65, 0x6a, 0x41, 0x32, 0x4b, 0x52, 0x63, 0x37, 0x61, 0x48, 0x70,
+                0x38, 0x42, 0x57, 0x74, 0x72, 0x45, 0x32, 0x6f, 0x6b, 0x58, 0x47, 0x68, 0x43, 0x47, 0x44,
+                0x49, 0x44, 0x63, 0x32, 0x34, 0x45, 0x49, 0x53, 0x34, 0x42, 0x42, 0x47, 0x4e, 0x39, 0x52,
+                0x45, 0x45, 0x53, 0x4d, 0x51, 0x73, 0x56, 0x48, 0x33, 0x41, 0x41, 0x4c, 0x6d, 0x59, 0x55,
+                0x50, 0x48, 0x38, 0x72, 0x41, 0x42, 0x38, 0x4d, 0x4b, 0x46, 0x6b, 0x4b, 0x46, 0x6b, 0x6c,
+                0x61, 0x58, 0x47, 0x52, 0x6c, 0x53, 0x78, 0x45, 0x70, 0x46, 0x54, 0x5a, 0x61, 0x5a, 0x52,
+                0x6c, 0x50, 0x59, 0x43, 0x4d, 0x36, 0x4f, 0x68, 0x4d, 0x6c, 0x41, 0x6e, 0x68, 0x4d, 0x56,
+                0x41, 0x3d, 0x3d, 0x00};
         char *b64_test;
 
         plan_tests(1);
diff --git a/lib/tests/test_cmd.c b/lib/tests/test_cmd.c
index c8867dfb..d51016cc 100644
--- a/lib/tests/test_cmd.c
+++ b/lib/tests/test_cmd.c
@@ -38,36 +38,35 @@ char *get_command(char *const *line) {
 }
 
 int main(int argc, char **argv) {
-        char **command_line = malloc(sizeof(char *) * COMMAND_LINE);
-        char *command = NULL;
-        char *perl;
-        output chld_out, chld_err;
-        int c;
-        int result = UNSET;
-
         plan_tests(51);
 
         diag("Running plain echo command, set one");
 
         /* ensure everything is empty before we begin */
+
+        output chld_out;
         memset(&chld_out, 0, sizeof(output));
+        output chld_err;
         memset(&chld_err, 0, sizeof(output));
         ok(chld_out.lines == 0, "(initialised) Checking stdout is reset");
         ok(chld_err.lines == 0, "(initialised) Checking stderr is reset");
+        int result = UNSET;
         ok(result == UNSET, "(initialised) Checking exit code is reset");
 
+        char **command_line = malloc(sizeof(char *) * COMMAND_LINE);
         command_line[0] = strdup("/bin/echo");
         command_line[1] = strdup("this");
         command_line[2] = strdup("is");
         command_line[3] = strdup("test");
         command_line[4] = strdup("one");
 
-        command = get_command(command_line);
+        char *command = get_command(command_line);
 
         result = cmd_run_array(command_line, &chld_out, &chld_err, 0);
         ok(chld_out.lines == 1, "(array) Check for expected number of stdout lines");
         ok(chld_err.lines == 0, "(array) Check for expected number of stderr lines");
-        ok(strcmp(chld_out.line[0], "this is test one") == 0, "(array) Check for expected stdout output");
+        ok(strcmp(chld_out.line[0], "this is test one") == 0,
+           "(array) Check for expected stdout output");
         ok(result == 0, "(array) Checking exit code");
 
         /* ensure everything is empty again */
@@ -82,7 +81,8 @@ int main(int argc, char **argv) {
 
         ok(chld_out.lines == 1, "(string) Check for expected number of stdout lines");
         ok(chld_err.lines == 0, "(string) Check for expected number of stderr lines");
-        ok(strcmp(chld_out.line[0], "this is test one") == 0, "(string) Check for expected stdout output");
+        ok(strcmp(chld_out.line[0], "this is test one") == 0,
+           "(string) Check for expected stdout output");
         ok(result == 0, "(string) Checking exit code");
 
         diag("Running plain echo command, set two");
@@ -104,7 +104,8 @@ int main(int argc, char **argv) {
         result = cmd_run_array(command_line, &chld_out, &chld_err, 0);
         ok(chld_out.lines == 1, "(array) Check for expected number of stdout lines");
         ok(chld_err.lines == 0, "(array) Check for expected number of stderr lines");
-        ok(strcmp(chld_out.line[0], "this is test two") == 0, "(array) Check for expected stdout output");
+        ok(strcmp(chld_out.line[0], "this is test two") == 0,
+           "(array) Check for expected stdout output");
         ok(result == 0, "(array) Checking exit code");
 
         /* ensure everything is empty again */
@@ -119,7 +120,8 @@ int main(int argc, char **argv) {
 
         ok(chld_out.lines == 1, "(string) Check for expected number of stdout lines");
         ok(chld_err.lines == 0, "(string) Check for expected number of stderr lines");
-        ok(strcmp(chld_out.line[0], "this is test one") == 0, "(string) Check for expected stdout output");
+        ok(strcmp(chld_out.line[0], "this is test one") == 0,
+           "(string) Check for expected stdout output");
         ok(result == 0, "(string) Checking exit code");
 
         /* ensure everything is empty again */
@@ -130,7 +132,8 @@ int main(int argc, char **argv) {
         ok(chld_err.lines == 0, "(initialised) Checking stderr is reset");
         ok(result == UNSET, "(initialised) Checking exit code is reset");
 
-        /* Pass linefeeds via parameters through - those should be evaluated by echo to give multi line output */
+        /* Pass linefeeds via parameters through - those should be evaluated by echo to give multi line
+         * output */
         command_line[0] = strdup("/bin/echo");
         command_line[1] = strdup("this is a test via echo\nline two\nit's line 3");
         command_line[2] = strdup("and (note space between '3' and 'and') $$ will not get evaluated");
@@ -138,9 +141,12 @@ int main(int argc, char **argv) {
         result = cmd_run_array(command_line, &chld_out, &chld_err, 0);
         ok(chld_out.lines == 3, "(array) Check for expected number of stdout lines");
         ok(chld_err.lines == 0, "(array) Check for expected number of stderr lines");
-        ok(strcmp(chld_out.line[0], "this is a test via echo") == 0, "(array) Check line 1 for expected stdout output");
-        ok(strcmp(chld_out.line[1], "line two") == 0, "(array) Check line 2 for expected stdout output");
-        ok(strcmp(chld_out.line[2], "it's line 3 and (note space between '3' and 'and') $$ will not get evaluated") == 0,
+        ok(strcmp(chld_out.line[0], "this is a test via echo") == 0,
+           "(array) Check line 1 for expected stdout output");
+        ok(strcmp(chld_out.line[1], "line two") == 0,
+           "(array) Check line 2 for expected stdout output");
+        ok(strcmp(chld_out.line[2],
+                          "it's line 3 and (note space between '3' and 'and') $$ will not get evaluated") == 0,
            "(array) Check line 3 for expected stdout output");
         ok(result == 0, "(array) Checking exit code");
 
@@ -171,7 +177,8 @@ int main(int argc, char **argv) {
 
         ok(chld_out.lines == 0, "/bin/sh returns no stdout when file is missing...");
         ok(chld_err.lines == 1, "...but does give an error line");
-        ok(strstr(chld_err.line[0], "non-existent-file") != NULL, "And missing filename is in error message");
+        ok(strstr(chld_err.line[0], "non-existent-file") != NULL,
+           "And missing filename is in error message");
         ok(result != 0, "Get non-zero return code from /bin/sh");
 
         /* ensure everything is empty again */
diff --git a/lib/tests/test_disk.c b/lib/tests/test_disk.c
deleted file mode 100644
index c18db7a4..00000000
--- a/lib/tests/test_disk.c
+++ /dev/null
@@ -1,192 +0,0 @@
-/*****************************************************************************
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- *
- *****************************************************************************/
-
-#include "common.h"
-#include "utils_disk.h"
-#include "tap.h"
-#include "regex.h"
-
-void np_test_mount_entry_regex(struct mount_entry *dummy_mount_list, char *regstr, int cflags, int expect, char *desc);
-
-int main(int argc, char **argv) {
-        struct name_list *exclude_filesystem = NULL;
-        struct name_list *exclude_fstype = NULL;
-        struct name_list *dummy_mountlist = NULL;
-        struct name_list *temp_name;
-        struct parameter_list *paths = NULL;
-        struct parameter_list *p, *prev = NULL, *last = NULL;
-
-        struct mount_entry *dummy_mount_list;
-        struct mount_entry *me;
-        struct mount_entry **mtail = &dummy_mount_list;
-        int cflags = REG_NOSUB | REG_EXTENDED;
-        int found = 0, count = 0;
-
-        plan_tests(33);
-
-        ok(np_find_name(exclude_filesystem, "/var/log") == false, "/var/log not in list");
-        np_add_name(&exclude_filesystem, "/var/log");
-        ok(np_find_name(exclude_filesystem, "/var/log") == true, "is in list now");
-        ok(np_find_name(exclude_filesystem, "/home") == false, "/home not in list");
-        np_add_name(&exclude_filesystem, "/home");
-        ok(np_find_name(exclude_filesystem, "/home") == true, "is in list now");
-        ok(np_find_name(exclude_filesystem, "/var/log") == true, "/var/log still in list");
-
-        ok(np_find_name(exclude_fstype, "iso9660") == false, "iso9660 not in list");
-        np_add_name(&exclude_fstype, "iso9660");
-        ok(np_find_name(exclude_fstype, "iso9660") == true, "is in list now");
-
-        ok(np_find_name(exclude_filesystem, "iso9660") == false, "Make sure no clashing in variables");
-
-        /*
-        for (temp_name = exclude_filesystem; temp_name; temp_name = temp_name->next) {
-                printf("Name: %s\n", temp_name->name);
-        }
-        */
-
-        me = (struct mount_entry *)malloc(sizeof *me);
-        me->me_devname = strdup("/dev/c0t0d0s0");
-        me->me_mountdir = strdup("/");
-        *mtail = me;
-        mtail = &me->me_next;
-
-        me = (struct mount_entry *)malloc(sizeof *me);
-        me->me_devname = strdup("/dev/c1t0d1s0");
-        me->me_mountdir = strdup("/var");
-        *mtail = me;
-        mtail = &me->me_next;
-
-        me = (struct mount_entry *)malloc(sizeof *me);
-        me->me_devname = strdup("/dev/c2t0d0s0");
-        me->me_mountdir = strdup("/home");
-        *mtail = me;
-        mtail = &me->me_next;
-
-        np_test_mount_entry_regex(dummy_mount_list, strdup("/"), cflags, 3, strdup("a"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("/dev"), cflags, 3, strdup("regex on dev names:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("/foo"), cflags, 0, strdup("regex on non existent dev/path:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("/Foo"), cflags | REG_ICASE, 0, strdup("regi on non existent dev/path:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("/c.t0"), cflags, 3, strdup("partial devname regex match:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("c0t0"), cflags, 1, strdup("partial devname regex match:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("C0t0"), cflags | REG_ICASE, 1, strdup("partial devname regi match:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("home"), cflags, 1, strdup("partial pathname regex match:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("hOme"), cflags | REG_ICASE, 1, strdup("partial pathname regi match:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("(/home)|(/var)"), cflags, 2, strdup("grouped regex pathname match:"));
-        np_test_mount_entry_regex(dummy_mount_list, strdup("(/homE)|(/Var)"), cflags | REG_ICASE, 2, strdup("grouped regi pathname match:"));
-
-        np_add_parameter(&paths, "/home/groups");
-        np_add_parameter(&paths, "/var");
-        np_add_parameter(&paths, "/tmp");
-        np_add_parameter(&paths, "/home/tonvoon");
-        np_add_parameter(&paths, "/dev/c2t0d0s0");
-
-        np_set_best_match(paths, dummy_mount_list, false);
-        for (p = paths; p; p = p->name_next) {
-                struct mount_entry *temp_me;
-                temp_me = p->best_match;
-                if (!strcmp(p->name, "/home/groups")) {
-                        ok(temp_me && !strcmp(temp_me->me_mountdir, "/home"), "/home/groups got right best match: /home");
-                } else if (!strcmp(p->name, "/var")) {
-                        ok(temp_me && !strcmp(temp_me->me_mountdir, "/var"), "/var got right best match: /var");
-                } else if (!strcmp(p->name, "/tmp")) {
-                        ok(temp_me && !strcmp(temp_me->me_mountdir, "/"), "/tmp got right best match: /");
-                } else if (!strcmp(p->name, "/home/tonvoon")) {
-                        ok(temp_me && !strcmp(temp_me->me_mountdir, "/home"), "/home/tonvoon got right best match: /home");
-                } else if (!strcmp(p->name, "/dev/c2t0d0s0")) {
-                        ok(temp_me && !strcmp(temp_me->me_devname, "/dev/c2t0d0s0"), "/dev/c2t0d0s0 got right best match: /dev/c2t0d0s0");
-                }
-        }
-
-        paths = NULL; /* Bad boy - should free, but this is a test suite */
-        np_add_parameter(&paths, "/home/groups");
-        np_add_parameter(&paths, "/var");
-        np_add_parameter(&paths, "/tmp");
-        np_add_parameter(&paths, "/home/tonvoon");
-        np_add_parameter(&paths, "/home");
-
-        np_set_best_match(paths, dummy_mount_list, true);
-        for (p = paths; p; p = p->name_next) {
-                if (!strcmp(p->name, "/home/groups")) {
-                        ok(!p->best_match, "/home/groups correctly not found");
-                } else if (!strcmp(p->name, "/var")) {
-                        ok(p->best_match, "/var found");
-                } else if (!strcmp(p->name, "/tmp")) {
-                        ok(!p->best_match, "/tmp correctly not found");
-                } else if (!strcmp(p->name, "/home/tonvoon")) {
-                        ok(!p->best_match, "/home/tonvoon not found");
-                } else if (!strcmp(p->name, "/home")) {
-                        ok(p->best_match, "/home found");
-                }
-        }
-
-        /* test deleting first element in paths */
-        paths = np_del_parameter(paths, NULL);
-        for (p = paths; p; p = p->name_next) {
-                if (!strcmp(p->name, "/home/groups"))
-                        found = 1;
-        }
-        ok(found == 0, "first element successfully deleted");
-        found = 0;
-
-        p = paths;
-        while (p) {
-                if (!strcmp(p->name, "/tmp"))
-                        p = np_del_parameter(p, prev);
-                else {
-                        prev = p;
-                        p = p->name_next;
-                }
-        }
-
-        for (p = paths; p; p = p->name_next) {
-                if (!strcmp(p->name, "/tmp"))
-                        found = 1;
-                if (p->name_next)
-                        prev = p;
-                else
-                        last = p;
-        }
-        ok(found == 0, "/tmp element successfully deleted");
-
-        p = np_del_parameter(last, prev);
-        for (p = paths; p; p = p->name_next) {
-                if (!strcmp(p->name, "/home"))
-                        found = 1;
-                last = p;
-                count++;
-        }
-        ok(found == 0, "last (/home) element successfully deleted");
-        ok(count == 2, "two elements remaining");
-
-        return exit_status();
-}
-
-void np_test_mount_entry_regex(struct mount_entry *dummy_mount_list, char *regstr, int cflags, int expect, char *desc) {
-        int matches = 0;
-        regex_t re;
-        struct mount_entry *me;
-        if (regcomp(&re, regstr, cflags) == 0) {
-                for (me = dummy_mount_list; me; me = me->me_next) {
-                        if (np_regex_match_mount_entry(me, &re))
-                                matches++;
-                }
-                ok(matches == expect, "%s '%s' matched %i/3 entries. ok: %i/3", desc, regstr, expect, matches);
-
-        } else
-                ok(false, "regex '%s' not compilable", regstr);
-}
diff --git a/lib/tests/test_disk.t b/lib/tests/test_disk.t
deleted file mode 100755
index da84dfdf..00000000
--- a/lib/tests/test_disk.t
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/usr/bin/perl
-use Test::More;
-if (! -e "./test_disk") {
-        plan skip_all => "./test_disk not compiled - please enable libtap library to test";
-}
-exec "./test_disk";
diff --git a/lib/tests/test_generic_output.c b/lib/tests/test_generic_output.c
new file mode 100644
index 00000000..e4a78bcd
--- /dev/null
+++ b/lib/tests/test_generic_output.c
@@ -0,0 +1,317 @@
+#include "../lib/output.h"
+#include "../../tap/tap.h"
+#include "./states.h"
+
+#include <string.h>
+
+void test_one_subcheck(void);
+void test_two_subchecks(void);
+
+void test_perfdata_formatting(void);
+void test_perfdata_formatting2(void);
+
+void test_deep_check_hierarchy(void);
+void test_deep_check_hierarchy2(void);
+
+void test_default_states1(void);
+void test_default_states2(void);
+
+int main(void) {
+        plan_tests(19);
+
+        diag("Simple test with one subcheck");
+        test_one_subcheck();
+
+        diag("Test with two subchecks");
+        test_two_subchecks();
+
+        diag("Test for performance data formatting");
+        test_perfdata_formatting();
+
+        diag("Another test for performance data formatting");
+        test_perfdata_formatting2();
+
+        diag("Test for deeper hierarchies");
+        test_deep_check_hierarchy();
+
+        diag("Another test for deeper hierarchies");
+        test_deep_check_hierarchy2();
+
+        diag("Testing the default state logic");
+        test_default_states1();
+
+        diag("Testing the default state logic #2");
+        test_default_states2();
+
+        return exit_status();
+}
+
+void test_one_subcheck(void) {
+        mp_subcheck sc1 = mp_subcheck_init();
+
+        sc1.output = "foobar";
+        sc1 = mp_set_subcheck_state(sc1, STATE_WARNING);
+
+        mp_check check = mp_check_init();
+        mp_add_subcheck_to_check(&check, sc1);
+
+        ok(mp_compute_check_state(check) == STATE_WARNING, "Main state should be warning");
+
+        char *output = mp_fmt_output(check);
+
+        // diag("Formatted output");
+        // diag(output);
+
+        char expected[] = "[WARNING] - ok=0, warning=1, critical=0, unknown=0\n"
+                                          "\t\\_[WARNING] - foobar\n";
+
+        // diag("Expected output");
+        // diag(expected);
+
+        ok(strcmp(output, expected) == 0, "Simple output test");
+}
+
+void test_perfdata_formatting2(void) {
+        mp_perfdata pd1 = perfdata_init();
+        mp_perfdata pd2 = perfdata_init();
+
+        pd1.label = "foo";
+        pd2.label = "bar";
+
+        pd1 = mp_set_pd_value(pd1, 23);
+        pd2 = mp_set_pd_value(pd2, 1LL);
+
+        pd_list *tmp = pd_list_init();
+
+        pd_list_append(tmp, pd1);
+        pd_list_append(tmp, pd2);
+
+        char *result = pd_list_to_string(*tmp);
+
+        ok(strcmp(result, "foo=23;;; bar=1;;;") == 0, "Perfdata string formatting");
+}
+
+void test_perfdata_formatting(void) {
+        mp_perfdata pd1 = perfdata_init();
+
+        pd1.uom = "s";
+        pd1.label = "foo";
+
+        pd1 = mp_set_pd_value(pd1, 23);
+
+        char *pd_string = pd_to_string(pd1);
+
+        ok(strcmp(pd_string, "foo=23s;;;") == 0, "Perfdata string formatting");
+}
+
+void test_two_subchecks(void) {
+        mp_subcheck sc1 = mp_subcheck_init();
+
+        sc1.output = "foobar";
+        sc1 = mp_set_subcheck_state(sc1, STATE_WARNING);
+
+        ok(mp_compute_subcheck_state(sc1) == STATE_WARNING,
+           "Test subcheck state directly after setting it");
+
+        mp_perfdata pd1 = perfdata_init();
+
+        pd1 = mp_set_pd_value(pd1, 23);
+
+        pd1.uom = "s";
+        pd1.label = "foo";
+
+        mp_add_perfdata_to_subcheck(&sc1, pd1);
+
+        mp_subcheck sc2 = mp_subcheck_init();
+        sc2.output = "baz";
+        sc2 = mp_set_subcheck_state(sc2, STATE_OK);
+
+        ok(mp_compute_subcheck_state(sc2) == STATE_OK, "Test subcheck 2 state after setting it");
+
+        mp_add_subcheck_to_subcheck(&sc1, sc2);
+
+        ok(mp_compute_subcheck_state(sc1) == STATE_WARNING,
+           "Test subcheck state after adding a subcheck");
+
+        mp_check check = mp_check_init();
+        mp_add_subcheck_to_check(&check, sc1);
+
+        ok(mp_compute_check_state(check) == STATE_WARNING, "Test main check result");
+
+        char *output = mp_fmt_output(check);
+
+        // diag("Formatted output. Length: %u", strlen(output));
+        // diag(output);
+
+        ok(output != NULL, "Output should not be NULL");
+
+        char expected[] = "[WARNING] - ok=0, warning=1, critical=0, unknown=0\n"
+                                          "\t\\_[WARNING] - foobar\n"
+                                          "\t\t\\_[OK] - baz\n"
+                                          "|foo=23s;;; \n";
+
+        // diag("Expected output. Length: %u", strlen(expected));
+        // diag(expected);
+
+        ok(strcmp(output, expected) == 0, "Output is as expected");
+}
+
+void test_deep_check_hierarchy(void) {
+        // level 4
+        mp_subcheck sc4 = mp_subcheck_init();
+        sc4.output = "level4";
+        sc4 = mp_set_subcheck_state(sc4, STATE_OK);
+
+        // level 3
+        mp_subcheck sc3 = mp_subcheck_init();
+        sc3.output = "level3";
+        sc3 = mp_set_subcheck_state(sc3, STATE_OK);
+
+        // level 2
+        mp_subcheck sc2 = mp_subcheck_init();
+        sc2.output = "baz";
+        sc2 = mp_set_subcheck_state(sc2, STATE_OK);
+
+        // level 1
+        mp_subcheck sc1 = mp_subcheck_init();
+
+        sc1.output = "foobar";
+        sc1 = mp_set_subcheck_state(sc1, STATE_WARNING);
+
+        mp_perfdata pd1 = perfdata_init();
+
+        pd1.uom = "s";
+        pd1.label = "foo";
+        pd1 = mp_set_pd_value(pd1, 23);
+
+        mp_add_perfdata_to_subcheck(&sc1, pd1);
+
+        // main check
+        mp_check check = mp_check_init();
+
+        mp_add_subcheck_to_subcheck(&sc3, sc4);
+        mp_add_subcheck_to_subcheck(&sc2, sc3);
+        mp_add_subcheck_to_subcheck(&sc1, sc2);
+        mp_add_subcheck_to_check(&check, sc1);
+
+        char *output = mp_fmt_output(check);
+
+        size_t output_length = strlen(output);
+
+        // diag("Formatted output of length %i", output_length);
+        // diag(output);
+
+        ok(output != NULL, "Output should not be NULL");
+
+        char expected[] = "[WARNING] - ok=0, warning=1, critical=0, unknown=0\n"
+                                          "\t\\_[WARNING] - foobar\n"
+                                          "\t\t\\_[OK] - baz\n"
+                                          "\t\t\t\\_[OK] - level3\n"
+                                          "\t\t\t\t\\_[OK] - level4\n"
+                                          "|foo=23s;;; \n";
+
+        size_t expected_length = strlen(expected);
+
+        // diag("Expected output of length: %i", expected_length);
+        // diag(expected);
+
+        ok(output_length == expected_length, "Outputs are of equal length");
+        ok(strcmp(output, expected) == 0, "Output is as expected");
+}
+
+void test_deep_check_hierarchy2(void) {
+        // level 1
+        mp_subcheck sc1 = mp_subcheck_init();
+
+        sc1.output = "foobar";
+        sc1 = mp_set_subcheck_state(sc1, STATE_WARNING);
+
+        mp_perfdata pd1 = perfdata_init();
+        pd1.uom = "s";
+        pd1.label = "foo";
+        pd1 = mp_set_pd_value(pd1, 23);
+
+        mp_add_perfdata_to_subcheck(&sc1, pd1);
+
+        // level 2
+        mp_subcheck sc2 = mp_subcheck_init();
+        sc2.output = "baz";
+        sc2 = mp_set_subcheck_state(sc2, STATE_OK);
+
+        mp_perfdata pd2 = perfdata_init();
+        pd2.uom = "B";
+        pd2.label = "baz";
+        pd2 = mp_set_pd_value(pd2, 1024);
+        mp_add_perfdata_to_subcheck(&sc2, pd2);
+
+        // level 3
+        mp_subcheck sc3 = mp_subcheck_init();
+        sc3.output = "level3";
+        sc3 = mp_set_subcheck_state(sc3, STATE_OK);
+
+        mp_perfdata pd3 = perfdata_init();
+        pd3.label = "floatMe";
+        pd3 = mp_set_pd_value(pd3, 1024.1024);
+        mp_add_perfdata_to_subcheck(&sc3, pd3);
+
+        // level 4
+        mp_subcheck sc4 = mp_subcheck_init();
+        sc4.output = "level4";
+        sc4 = mp_set_subcheck_state(sc4, STATE_OK);
+
+        mp_check check = mp_check_init();
+
+        mp_add_subcheck_to_subcheck(&sc3, sc4);
+        mp_add_subcheck_to_subcheck(&sc2, sc3);
+        mp_add_subcheck_to_subcheck(&sc1, sc2);
+        mp_add_subcheck_to_check(&check, sc1);
+
+        char *output = mp_fmt_output(check);
+
+        // diag("Formatted output of length: %i", strlen(output));
+        // diag(output);
+
+        ok(output != NULL, "Output should not be NULL");
+
+        char expected[] = "[WARNING] - ok=0, warning=1, critical=0, unknown=0\n"
+                                          "\t\\_[WARNING] - foobar\n"
+                                          "\t\t\\_[OK] - baz\n"
+                                          "\t\t\t\\_[OK] - level3\n"
+                                          "\t\t\t\t\\_[OK] - level4\n"
+                                          "|foo=23s;;; baz=1024B;;; floatMe=1024.102400;;; \n";
+
+        // diag("Expected output of length: %i", strlen(expected));
+        // diag(expected);
+
+        ok(strcmp(output, expected) == 0, "Output is as expected");
+}
+
+void test_default_states1(void) {
+        mp_subcheck sc = mp_subcheck_init();
+
+        mp_state_enum state1 = mp_compute_subcheck_state(sc);
+        ok(state1 == STATE_UNKNOWN, "Default default state is Unknown");
+
+        sc = mp_set_subcheck_default_state(sc, STATE_CRITICAL);
+
+        mp_state_enum state2 = mp_compute_subcheck_state(sc);
+        ok(state2 == STATE_CRITICAL, "Default state is Critical");
+
+        sc = mp_set_subcheck_state(sc, STATE_OK);
+
+        mp_state_enum state3 = mp_compute_subcheck_state(sc);
+        ok(state3 == STATE_OK, "Default state is Critical");
+}
+
+void test_default_states2(void) {
+        mp_check check = mp_check_init();
+
+        mp_subcheck sc = mp_subcheck_init();
+        sc.output = "placeholder";
+        sc = mp_set_subcheck_default_state(sc, STATE_CRITICAL);
+
+        mp_add_subcheck_to_check(&check, sc);
+
+        mp_state_enum result_state = mp_compute_check_state(check);
+        ok(result_state == STATE_CRITICAL, "Derived state is the proper default state");
+}
diff --git a/lib/tests/test_generic_output.t b/lib/tests/test_generic_output.t
new file mode 100644
index 00000000..48c2ddf4
--- /dev/null
+++ b/lib/tests/test_generic_output.t
@@ -0,0 +1,6 @@
+#!/usr/bin/perl
+use Test::More;
+if (! -e "./test_generic_output") {
+        plan skip_all => "./test_generic_output not compiled - please enable libtap library to test";
+}
+exec "./test_generic_output";
diff --git a/lib/tests/test_ini1.c b/lib/tests/test_ini1.c
index 246c1250..de983764 100644
--- a/lib/tests/test_ini1.c
+++ b/lib/tests/test_ini1.c
@@ -42,27 +42,30 @@ char *list2str(np_arg_list *optlst) {
                 free(optltmp);
         }
         /* Strip last whitespace */
-        if (strlen(optstr) > 1)
+        if (strlen(optstr) > 1) {
                 optstr[strlen(optstr) - 1] = '\0';
+        }
 
         return optstr;
 }
 
 int main(int argc, char **argv) {
-        char *optstr = NULL;
 
         plan_tests(12);
 
-        optstr = list2str(np_get_defaults("section@./config-tiny.ini", "check_disk"));
-        ok(!strcmp(optstr, "--one=two --Foo=Bar --this=Your Mother! --blank"), "config-tiny.ini's section as expected");
+        char *optstr = list2str(np_get_defaults("section@./config-tiny.ini", "check_disk"));
+        ok(!strcmp(optstr, "--one=two --Foo=Bar --this=Your Mother! --blank"),
+           "config-tiny.ini's section as expected");
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("@./config-tiny.ini", "section"));
-        ok(!strcmp(optstr, "--one=two --Foo=Bar --this=Your Mother! --blank"), "Used default section name, without specific");
+        ok(!strcmp(optstr, "--one=two --Foo=Bar --this=Your Mother! --blank"),
+           "Used default section name, without specific");
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("Section Two@./config-tiny.ini", "check_disk"));
-        ok(!strcmp(optstr, "--something else=blah --remove=whitespace"), "config-tiny.ini's Section Two as expected");
+        ok(!strcmp(optstr, "--something else=blah --remove=whitespace"),
+           "config-tiny.ini's Section Two as expected");
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("/path/to/file.txt@./config-tiny.ini", "check_disk"));
@@ -70,15 +73,18 @@ int main(int argc, char **argv) {
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("section2@./config-tiny.ini", "check_disk"));
-        ok(!strcmp(optstr, "--this=that"), "config-tiny.ini's section2 with whitespace before section name");
+        ok(!strcmp(optstr, "--this=that"),
+           "config-tiny.ini's section2 with whitespace before section name");
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("section3@./config-tiny.ini", "check_disk"));
-        ok(!strcmp(optstr, "--this=that"), "config-tiny.ini's section3 with whitespace after section name");
+        ok(!strcmp(optstr, "--this=that"),
+           "config-tiny.ini's section3 with whitespace after section name");
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("check_mysql@./plugin.ini", "check_disk"));
-        ok(!strcmp(optstr, "--username=operator --password=secret"), "plugin.ini's check_mysql as expected");
+        ok(!strcmp(optstr, "--username=operator --password=secret"),
+           "plugin.ini's check_mysql as expected");
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("check_mysql2@./plugin.ini", "check_disk"));
@@ -90,29 +96,39 @@ int main(int argc, char **argv) {
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("Section Two@./config-dos.ini", "check_disk"));
-        ok(!strcmp(optstr, "--something else=blah --remove=whitespace"), "config-dos.ini's Section Two as expected");
+        ok(!strcmp(optstr, "--something else=blah --remove=whitespace"),
+           "config-dos.ini's Section Two as expected");
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("section_twice@./plugin.ini", "check_disk"));
-        ok(!strcmp(optstr, "--foo=bar --bar=foo"), "plugin.ini's section_twice defined twice in the file");
+        ok(!strcmp(optstr, "--foo=bar --bar=foo"),
+           "plugin.ini's section_twice defined twice in the file");
         my_free(optstr);
 
         optstr = list2str(np_get_defaults("tcp_long_lines@plugins.ini", "check_tcp"));
-        ok(!strcmp(optstr, "--escape --send=Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar "
+        ok(!strcmp(optstr, "--escape --send=Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                           "yadda Foo bar BAZ yadda yadda yadda Foo bar "
                                            "BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
-                                           "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
+                                           "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar "
+                                           "BAZ yadda yadda yadda Foo bar BAZ yadda "
                                            "yadda yadda Foo bar BAZ yadda yadda yadda Foo "
-                                           "bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                           "bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
+                                           "yadda yadda Foo bar BAZ yadda yadda "
                                            "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ "
-                                           "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda --expect=Foo bar BAZ yadda yadda "
+                                           "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                           "yadda --expect=Foo bar BAZ yadda yadda "
                                            "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ "
-                                           "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo "
+                                           "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                           "yadda Foo bar BAZ yadda yadda yadda Foo "
                                            "bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
-                                           "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
+                                           "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar "
+                                           "BAZ yadda yadda yadda Foo bar BAZ yadda "
                                            "yadda yadda Foo bar BAZ yadda yadda yadda Foo "
-                                           "bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                           "bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
+                                           "yadda yadda Foo bar BAZ yadda yadda "
                                            "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ "
-                                           "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo "
+                                           "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                           "yadda Foo bar BAZ yadda yadda yadda Foo "
                                            "bar BAZ yadda yadda yadda --jail"),
            "Long options");
         my_free(optstr);
diff --git a/lib/tests/test_opts1.c b/lib/tests/test_opts1.c
index 984183d3..fa95c4d4 100644
--- a/lib/tests/test_opts1.c
+++ b/lib/tests/test_opts1.c
@@ -40,37 +40,40 @@ void my_free(int *argc, char **newargv, char **argv) {
 #else
 void my_free(int *argc, char **newargv, char **argv) {
         /* Free stuff (and print while we're at it) */
-        int i, freeflag = 1;
+        bool freeflag = true;
         printf("    Arg(%i): ", *argc + 1);
         printf("'%s' ", newargv[0]);
-        for (i = 1; i < *argc; i++) {
+
+        for (int i = 1; i < *argc; i++) {
                 printf("'%s' ", newargv[i]);
                 /* Stop freeing when we get to the start of the original array */
                 if (freeflag) {
-                        if (newargv[i] == argv[1])
-                                freeflag = 0;
-                        else
+                        if (newargv[i] == argv[1]) {
+                                freeflag = false;
+                        } else {
                                 free(newargv[i]);
+                        }
                 }
         }
         printf("\n");
         /* Free only if it's a different array */
-        if (newargv != argv)
+        if (newargv != argv) {
                 free(newargv);
+        }
         *argc = 0;
 }
 #endif
 
 int array_diff(int i1, char **a1, int i2, char **a2) {
-        int i;
-
         if (i1 != i2) {
                 printf("    Argument count doesn't match!\n");
                 return 0;
         }
-        for (i = 0; i <= i1; i++) {
-                if (a1[i] == NULL && a2[i] == NULL)
+
+        for (int i = 0; i <= i1; i++) {
+                if (a1[i] == NULL && a2[i] == NULL) {
                         continue;
+                }
                 if (a1[i] == NULL || a2[i] == NULL) {
                         printf("    Argument # %i null in one array!\n", i);
                         return 0;
@@ -84,11 +87,10 @@ int array_diff(int i1, char **a1, int i2, char **a2) {
 }
 
 int main(int argc, char **argv) {
-        char **argv_new = NULL;
-        int i, argc_test;
-
         plan_tests(5);
 
+        char **argv_new = NULL;
+        int argc_test;
         {
                 char *argv_test[] = {"prog_name", (char *)NULL};
                 argc_test = 1;
@@ -110,27 +112,36 @@ int main(int argc, char **argv) {
         {
                 char *argv_test[] = {"prog_name", "--extra-opts=@./config-opts.ini", (char *)NULL};
                 argc_test = 2;
-                char *argv_known[] = {"prog_name", "--foo=Bar", "--this=Your Mother!", "--blank", (char *)NULL};
+                char *argv_known[] = {"prog_name", "--foo=Bar", "--this=Your Mother!", "--blank",
+                                                          (char *)NULL};
                 argv_new = np_extra_opts(&argc_test, argv_test, "check_disk");
                 ok(array_diff(argc_test, argv_new, 4, argv_known), "Only extra opts using default section");
                 my_free(&argc_test, argv_new, argv_test);
         }
 
         {
-                char *argv_test[] = {"prog_name", "--extra-opts=sect1@./config-opts.ini", "--extra-opts", "sect2@./config-opts.ini", (char *)NULL};
+                char *argv_test[] = {"prog_name", "--extra-opts=sect1@./config-opts.ini", "--extra-opts",
+                                                         "sect2@./config-opts.ini", (char *)NULL};
                 argc_test = 4;
-                char *argv_known[] = {"prog_name", "--one=two", "--something else=oops", "--this=that", (char *)NULL};
+                char *argv_known[] = {"prog_name", "--one=two", "--something else=oops", "--this=that",
+                                                          (char *)NULL};
                 argv_new = np_extra_opts(&argc_test, argv_test, "check_disk");
                 ok(array_diff(argc_test, argv_new, 4, argv_known), "Only extra opts specified twice");
                 my_free(&argc_test, argv_new, argv_test);
         }
 
         {
-                char *argv_test[] = {"prog_name", "--arg1=val1", "--extra-opts=@./config-opts.ini", "--extra-opts", "sect1@./config-opts.ini",
-                                                         "--arg2",    (char *)NULL};
+                char *argv_test[] = {"prog_name",
+                                                         "--arg1=val1",
+                                                         "--extra-opts=@./config-opts.ini",
+                                                         "--extra-opts",
+                                                         "sect1@./config-opts.ini",
+                                                         "--arg2",
+                                                         (char *)NULL};
                 argc_test = 6;
-                char *argv_known[] = {"prog_name",   "--foo=Bar", "--this=Your Mother!", "--blank", "--one=two",
-                                                          "--arg1=val1", "--arg2",    (char *)NULL};
+                char *argv_known[] = {"prog_name", "--foo=Bar", "--this=Your Mother!",
+                                                          "--blank",   "--one=two", "--arg1=val1",
+                                                          "--arg2",    (char *)NULL};
                 argv_new = np_extra_opts(&argc_test, argv_test, "check_disk");
                 ok(array_diff(argc_test, argv_new, 7, argv_known), "twice extra opts using two sections");
                 my_free(&argc_test, argv_new, argv_test);
diff --git a/lib/tests/test_opts2.c b/lib/tests/test_opts2.c
index 23496617..3dd1b039 100644
--- a/lib/tests/test_opts2.c
+++ b/lib/tests/test_opts2.c
@@ -23,36 +23,39 @@
 
 void my_free(int *argc, char **newargv, char **argv) {
         /* Free stuff (and print while we're at it) */
-        int i, freeflag = 1;
+        bool freeflag = true;
+
         printf("    Arg(%i): ", *argc + 1);
         printf("'%s' ", newargv[0]);
-        for (i = 1; i < *argc; i++) {
+        for (int i = 1; i < *argc; i++) {
                 printf("'%s' ", newargv[i]);
                 /* Stop freeing when we get to the start of the original array */
                 if (freeflag) {
-                        if (newargv[i] == argv[1])
-                                freeflag = 0;
-                        else
+                        if (newargv[i] == argv[1]) {
+                                freeflag = false;
+                        } else {
                                 free(newargv[i]);
+                        }
                 }
         }
         printf("\n");
         /* Free only if it's a different array */
-        if (newargv != argv)
+        if (newargv != argv) {
                 free(newargv);
+        }
         *argc = 0;
 }
 
 int array_diff(int i1, char **a1, int i2, char **a2) {
-        int i;
-
         if (i1 != i2) {
                 printf("    Argument count doesn't match!\n");
                 return 0;
         }
-        for (i = 0; i <= i1; i++) {
-                if (a1[i] == NULL && a2[i] == NULL)
+
+        for (int i = 0; i <= i1; i++) {
+                if (a1[i] == NULL && a2[i] == NULL) {
                         continue;
+                }
                 if (a1[i] == NULL || a2[i] == NULL) {
                         printf("    Argument # %i null in one array!\n", i);
                         return 0;
@@ -66,11 +69,10 @@ int array_diff(int i1, char **a1, int i2, char **a2) {
 }
 
 int main(int argc, char **argv) {
-        char **argv_new = NULL;
-        int i, argc_test;
-
         plan_tests(5);
 
+        char **argv_new = NULL;
+        int argc_test;
         {
                 char *argv_test[] = {"prog_name", "arg1", "--extra-opts", "--arg3", "val2", (char *)NULL};
                 argc_test = 5;
@@ -90,7 +92,8 @@ int main(int argc, char **argv) {
         }
 
         {
-                char *argv_test[] = {"prog_name", "arg1", "--extra-opts=section1", "--arg3", "val2", (char *)NULL};
+                char *argv_test[] = {"prog_name", "arg1", "--extra-opts=section1",
+                                                         "--arg3",    "val2", (char *)NULL};
                 argc_test = 5;
                 char *argv_known[] = {"prog_name", "--foobar=baz", "arg1", "--arg3", "val2", (char *)NULL};
                 argv_new = np_extra_opts(&argc_test, argv_test, "check_disk");
@@ -108,30 +111,39 @@ int main(int argc, char **argv) {
         }
 
         {
-                char *argv_test[] = {"check_tcp", "--extra-opts", "--extra-opts=tcp_long_lines", (char *)NULL};
+                char *argv_test[] = {"check_tcp", "--extra-opts", "--extra-opts=tcp_long_lines",
+                                                         (char *)NULL};
                 argc_test = 3;
-                char *argv_known[] = {
-                        "check_tcp",
-                        "--timeout=10",
-                        "--escape",
-                        "--send=Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
-                        "yadda Foo bar BAZ yadda "
-                        "yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
-                        "yadda Foo bar BAZ "
-                        "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
-                        "yadda yadda Foo bar "
-                        "BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda",
-                        "--expect=Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
-                        "yadda Foo bar BAZ yadda "
-                        "yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
-                        "yadda Foo bar BAZ "
-                        "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
-                        "yadda yadda Foo bar "
-                        "BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ "
-                        "yadda yadda yadda Foo "
-                        "bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda",
-                        "--jail",
-                        (char *)NULL};
+                char *argv_known[] = {"check_tcp",
+                                                          "--timeout=10",
+                                                          "--escape",
+                                                          "--send=Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda "
+                                                          "Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                                          "yadda Foo bar BAZ yadda "
+                                                          "yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                                          "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                                          "yadda Foo bar BAZ "
+                                                          "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
+                                                          "yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
+                                                          "yadda yadda Foo bar "
+                                                          "BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ "
+                                                          "yadda yadda yadda Foo bar BAZ yadda yadda yadda",
+                                                          "--expect=Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                                          "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                                          "yadda Foo bar BAZ yadda "
+                                                          "yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                                          "yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda "
+                                                          "yadda Foo bar BAZ "
+                                                          "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
+                                                          "yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ yadda "
+                                                          "yadda yadda Foo bar "
+                                                          "BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ "
+                                                          "yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ "
+                                                          "yadda yadda yadda Foo "
+                                                          "bar BAZ yadda yadda yadda Foo bar BAZ yadda yadda yadda Foo bar BAZ "
+                                                          "yadda yadda yadda Foo bar BAZ yadda yadda yadda",
+                                                          "--jail",
+                                                          (char *)NULL};
                 argv_new = np_extra_opts(&argc_test, argv_test, "check_tcp");
                 ok(array_diff(argc_test, argv_new, 6, argv_known), "Long lines test");
                 my_free(&argc_test, argv_new, argv_test);
diff --git a/lib/tests/test_tcp.c b/lib/tests/test_tcp.c
index 1b3003e9..37c818c9 100644
--- a/lib/tests/test_tcp.c
+++ b/lib/tests/test_tcp.c
@@ -21,30 +21,38 @@
 #include "tap.h"
 
 int main(void) {
-        char **server_expect;
-        int server_expect_count = 3;
-
         plan_tests(9);
 
+        char **server_expect;
+        const int server_expect_count = 3;
         server_expect = malloc(sizeof(char *) * server_expect_count);
 
         server_expect[0] = strdup("AA");
         server_expect[1] = strdup("bb");
         server_expect[2] = strdup("CC");
 
-        ok(np_expect_match("AA bb CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) == NP_MATCH_SUCCESS,
+        ok(np_expect_match("AA bb CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) ==
+                   NP_MATCH_SUCCESS,
            "Test matching any string at the beginning (first expect string)");
-        ok(np_expect_match("bb AA CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) == NP_MATCH_SUCCESS,
+        ok(np_expect_match("bb AA CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) ==
+                   NP_MATCH_SUCCESS,
            "Test matching any string at the beginning (second expect string)");
         ok(np_expect_match("b", server_expect, server_expect_count, NP_MATCH_EXACT) == NP_MATCH_RETRY,
            "Test matching any string at the beginning (substring match)");
-        ok(np_expect_match("XX bb AA CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) == NP_MATCH_FAILURE,
+        ok(np_expect_match("XX bb AA CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) ==
+                   NP_MATCH_FAILURE,
            "Test with strings not matching at the beginning");
-        ok(np_expect_match("XX CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) == NP_MATCH_FAILURE, "Test matching any string");
-        ok(np_expect_match("XX", server_expect, server_expect_count, 0) == NP_MATCH_RETRY, "Test not matching any string");
-        ok(np_expect_match("XX AA bb CC XX", server_expect, server_expect_count, NP_MATCH_ALL) == NP_MATCH_SUCCESS,
+        ok(np_expect_match("XX CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) ==
+                   NP_MATCH_FAILURE,
+           "Test matching any string");
+        ok(np_expect_match("XX", server_expect, server_expect_count, 0) == NP_MATCH_RETRY,
+           "Test not matching any string");
+        ok(np_expect_match("XX AA bb CC XX", server_expect, server_expect_count, NP_MATCH_ALL) ==
+                   NP_MATCH_SUCCESS,
            "Test matching all strings");
-        ok(np_expect_match("XX bb CC XX", server_expect, server_expect_count, NP_MATCH_ALL) == NP_MATCH_RETRY, "Test not matching all strings");
+        ok(np_expect_match("XX bb CC XX", server_expect, server_expect_count, NP_MATCH_ALL) ==
+                   NP_MATCH_RETRY,
+           "Test not matching all strings");
         ok(np_expect_match("XX XX", server_expect, server_expect_count, NP_MATCH_ALL) == NP_MATCH_RETRY,
            "Test not matching any string (testing all)");
 
diff --git a/lib/tests/test_utils.c b/lib/tests/test_utils.c
index c3150f00..8040dec8 100644
--- a/lib/tests/test_utils.c
+++ b/lib/tests/test_utils.c
@@ -28,17 +28,7 @@
 #include "utils_base.c"
 
 int main(int argc, char **argv) {
-        char state_path[1024];
-        range *range;
-        double temp;
-        thresholds *thresholds = NULL;
-        int i, rc;
-        char *temp_string;
-        state_key *temp_state_key = NULL;
-        state_data *temp_state_data;
-        time_t current_time;
-
-        plan_tests(185);
+        plan_tests(155);
 
         ok(this_monitoring_plugin == NULL, "monitoring_plugin not initialised");
 
@@ -57,7 +47,7 @@ int main(int argc, char **argv) {
 
         np_set_args(argc, argv);
 
-        range = parse_range_string("6");
+        range *range = parse_range_string("6");
         ok(range != NULL, "'6' is valid range");
         ok(range->start == 0, "Start correct");
         ok(range->start_infinity == false, "Not using negative infinity");
@@ -97,7 +87,7 @@ int main(int argc, char **argv) {
         free(range);
 
         range = parse_range_string("12345678901234567890:");
-        temp = atof("12345678901234567890"); /* Can't just use this because number too large */
+        double temp = atof("12345678901234567890"); /* Can't just use this because number too large */
         ok(range != NULL, "'12345678901234567890:' is valid range");
         ok(range->start == temp, "Start correct");
         ok(range->start_infinity == false, "Not using negative infinity");
@@ -158,32 +148,34 @@ int main(int argc, char **argv) {
         range = parse_range_string("2:1");
         ok(range == NULL, "'2:1' rejected");
 
-        rc = _set_thresholds(&thresholds, NULL, NULL);
-        ok(rc == 0, "Thresholds (NULL, NULL) set");
+        thresholds *thresholds = NULL;
+        int returnCode;
+        returnCode = _set_thresholds(&thresholds, NULL, NULL);
+        ok(returnCode == 0, "Thresholds (NULL, NULL) set");
         ok(thresholds->warning == NULL, "Warning not set");
         ok(thresholds->critical == NULL, "Critical not set");
 
-        rc = _set_thresholds(&thresholds, NULL, "80");
-        ok(rc == 0, "Thresholds (NULL, '80') set");
+        returnCode = _set_thresholds(&thresholds, NULL, "80");
+        ok(returnCode == 0, "Thresholds (NULL, '80') set");
         ok(thresholds->warning == NULL, "Warning not set");
         ok(thresholds->critical->end == 80, "Critical set correctly");
 
-        rc = _set_thresholds(&thresholds, "5:33", NULL);
-        ok(rc == 0, "Thresholds ('5:33', NULL) set");
+        returnCode = _set_thresholds(&thresholds, "5:33", NULL);
+        ok(returnCode == 0, "Thresholds ('5:33', NULL) set");
         ok(thresholds->warning->start == 5, "Warning start set");
         ok(thresholds->warning->end == 33, "Warning end set");
         ok(thresholds->critical == NULL, "Critical not set");
 
-        rc = _set_thresholds(&thresholds, "30", "60");
-        ok(rc == 0, "Thresholds ('30', '60') set");
+        returnCode = _set_thresholds(&thresholds, "30", "60");
+        ok(returnCode == 0, "Thresholds ('30', '60') set");
         ok(thresholds->warning->end == 30, "Warning set correctly");
         ok(thresholds->critical->end == 60, "Critical set correctly");
         ok(get_status(15.3, thresholds) == STATE_OK, "15.3 - ok");
         ok(get_status(30.0001, thresholds) == STATE_WARNING, "30.0001 - warning");
         ok(get_status(69, thresholds) == STATE_CRITICAL, "69 - critical");
 
-        rc = _set_thresholds(&thresholds, "-10:-2", "-30:20");
-        ok(rc == 0, "Thresholds ('-30:20', '-10:-2') set");
+        returnCode = _set_thresholds(&thresholds, "-10:-2", "-30:20");
+        ok(returnCode == 0, "Thresholds ('-30:20', '-10:-2') set");
         ok(thresholds->warning->start == -10, "Warning start set correctly");
         ok(thresholds->warning->end == -2, "Warning end set correctly");
         ok(thresholds->critical->start == -30, "Critical start set correctly");
@@ -304,164 +296,28 @@ int main(int argc, char **argv) {
         test = np_extract_ntpvar("", "foo");
         ok(!test, "Empty string return NULL");
 
-        /* This is the result of running ./test_utils */
-        temp_string = (char *)_np_state_generate_key();
-        ok(!strcmp(temp_string, "e2d17f995fd4c020411b85e3e3d0ff7306d4147e"), "Got hash with exe and no parameters") ||
-                diag("You are probably running in wrong directory. Must run as ./test_utils");
-
-        this_monitoring_plugin->argc = 4;
-        this_monitoring_plugin->argv[0] = "./test_utils";
-        this_monitoring_plugin->argv[1] = "here";
-        this_monitoring_plugin->argv[2] = "--and";
-        this_monitoring_plugin->argv[3] = "now";
-        temp_string = (char *)_np_state_generate_key();
-        ok(!strcmp(temp_string, "bd72da9f78ff1419fad921ea5e43ce56508aef6c"), "Got based on expected argv");
-
-        unsetenv("MP_STATE_PATH");
-        temp_string = (char *)_np_state_calculate_location_prefix();
-        ok(!strcmp(temp_string, NP_STATE_DIR_PREFIX), "Got default directory");
-
-        setenv("MP_STATE_PATH", "", 1);
-        temp_string = (char *)_np_state_calculate_location_prefix();
-        ok(!strcmp(temp_string, NP_STATE_DIR_PREFIX), "Got default directory even with empty string");
-
-        setenv("MP_STATE_PATH", "/usr/local/nagios/var", 1);
-        temp_string = (char *)_np_state_calculate_location_prefix();
-        ok(!strcmp(temp_string, "/usr/local/nagios/var"), "Got default directory");
-
-        ok(temp_state_key == NULL, "temp_state_key initially empty");
-
-        this_monitoring_plugin->argc = 1;
-        this_monitoring_plugin->argv[0] = "./test_utils";
-        np_enable_state(NULL, 51);
-        temp_state_key = this_monitoring_plugin->state;
-        ok(!strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name");
-        ok(!strcmp(temp_state_key->name, "e2d17f995fd4c020411b85e3e3d0ff7306d4147e"), "Got generated filename");
-
-        np_enable_state("allowedchars_in_keyname", 77);
-        temp_state_key = this_monitoring_plugin->state;
-        sprintf(state_path, "/usr/local/nagios/var/%lu/check_test/allowedchars_in_keyname", (unsigned long)geteuid());
-        ok(!strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name");
-        ok(!strcmp(temp_state_key->name, "allowedchars_in_keyname"), "Got key name with valid chars");
-        ok(!strcmp(temp_state_key->_filename, state_path), "Got internal filename");
-
-        /* Don't do this test just yet. Will die */
-        /*
-        np_enable_state("bad^chars$in@here", 77);
-        temp_state_key = this_monitoring_plugin->state;
-        ok( !strcmp(temp_state_key->name, "bad_chars_in_here"), "Got key name with bad chars replaced" );
-        */
-
-        np_enable_state("funnykeyname", 54);
-        temp_state_key = this_monitoring_plugin->state;
-        sprintf(state_path, "/usr/local/nagios/var/%lu/check_test/funnykeyname", (unsigned long)geteuid());
-        ok(!strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name");
-        ok(!strcmp(temp_state_key->name, "funnykeyname"), "Got key name");
-
-        ok(!strcmp(temp_state_key->_filename, state_path), "Got internal filename");
-        ok(temp_state_key->data_version == 54, "Version set");
-
-        temp_state_data = np_state_read();
-        ok(temp_state_data == NULL, "Got no state data as file does not exist");
-
-        /*
-                temp_fp = fopen("var/statefile", "r");
-                if (temp_fp==NULL)
-                        printf("Error opening. errno=%d\n", errno);
-                printf("temp_fp=%s\n", temp_fp);
-                ok( _np_state_read_file(temp_fp) == true, "Can read state file" );
-                fclose(temp_fp);
-        */
-
-        temp_state_key->_filename = "var/statefile";
-        temp_state_data = np_state_read();
-        ok(this_monitoring_plugin->state->state_data != NULL, "Got state data now") ||
-                diag("Are you running in right directory? Will get coredump next if not");
-        ok(this_monitoring_plugin->state->state_data->time == 1234567890, "Got time");
-        ok(!strcmp((char *)this_monitoring_plugin->state->state_data->data, "String to read"), "Data as expected");
-
-        temp_state_key->data_version = 53;
-        temp_state_data = np_state_read();
-        ok(temp_state_data == NULL, "Older data version gives NULL");
-        temp_state_key->data_version = 54;
-
-        temp_state_key->_filename = "var/nonexistent";
-        temp_state_data = np_state_read();
-        ok(temp_state_data == NULL, "Missing file gives NULL");
-        ok(this_monitoring_plugin->state->state_data == NULL, "No state information");
-
-        temp_state_key->_filename = "var/oldformat";
-        temp_state_data = np_state_read();
-        ok(temp_state_data == NULL, "Old file format gives NULL");
-
-        temp_state_key->_filename = "var/baddate";
-        temp_state_data = np_state_read();
-        ok(temp_state_data == NULL, "Bad date gives NULL");
-
-        temp_state_key->_filename = "var/missingdataline";
-        temp_state_data = np_state_read();
-        ok(temp_state_data == NULL, "Missing data line gives NULL");
-
-        unlink("var/generated");
-        temp_state_key->_filename = "var/generated";
-        current_time = 1234567890;
-        np_state_write_string(current_time, "String to read");
-        ok(system("cmp var/generated var/statefile") == 0, "Generated file same as expected");
-
-        unlink("var/generated_directory/statefile");
-        unlink("var/generated_directory");
-        temp_state_key->_filename = "var/generated_directory/statefile";
-        current_time = 1234567890;
-        np_state_write_string(current_time, "String to read");
-        ok(system("cmp var/generated_directory/statefile var/statefile") == 0, "Have created directory");
-
-        /* This test to check cannot write to dir - can't automate yet */
-        /*
-        unlink("var/generated_bad_dir");
-        mkdir("var/generated_bad_dir", S_IRUSR);
-        np_state_write_string(current_time, "String to read");
-        */
-
-        temp_state_key->_filename = "var/generated";
-        time(&current_time);
-        np_state_write_string(0, "String to read");
-        temp_state_data = np_state_read();
-        /* Check time is set to current_time */
-        ok(system("cmp var/generated var/statefile > /dev/null") != 0, "Generated file should be different this time");
-        ok(this_monitoring_plugin->state->state_data->time - current_time <= 1, "Has time generated from current time");
-
-        /* Don't know how to automatically test this. Need to be able to redefine die and catch the error */
-        /*
-        temp_state_key->_filename="/dev/do/not/expect/to/be/able/to/write";
-        np_state_write_string(0, "Bad file");
-        */
-
-        np_cleanup();
-
-        ok(this_monitoring_plugin == NULL, "Free'd this_monitoring_plugin");
-
         ok(mp_suid() == false, "Test aren't suid");
 
         /* base states with random case */
         char *states[] = {"Ok", "wArnINg", "cRiTIcaL", "UnKNoWN", NULL};
 
-        for (i = 0; states[i] != NULL; i++) {
-                /* out of the random case states, create the lower and upper versions + numeric string one */
+        for (int i = 0; states[i] != NULL; i++) {
+                /* out of the random case states, create the lower and upper versions + numeric string one
+                 */
                 char *statelower = strdup(states[i]);
                 char *stateupper = strdup(states[i]);
                 char statenum[2];
-                char *temp_ptr;
-                for (temp_ptr = statelower; *temp_ptr; temp_ptr++) {
-                        *temp_ptr = tolower(*temp_ptr);
+                for (char *temp_ptr = statelower; *temp_ptr; temp_ptr++) {
+                        *temp_ptr = (char)tolower(*temp_ptr);
                 }
-                for (temp_ptr = stateupper; *temp_ptr; temp_ptr++) {
-                        *temp_ptr = toupper(*temp_ptr);
+                for (char *temp_ptr = stateupper; *temp_ptr; temp_ptr++) {
+                        *temp_ptr = (char)toupper(*temp_ptr);
                 }
                 snprintf(statenum, 2, "%i", i);
 
                 /* Base test names, we'll append the state string */
                 char testname[64] = "Translate state string: ";
-                int tlen = strlen(testname);
+                size_t tlen = strlen(testname);
 
                 strcpy(testname + tlen, states[i]);
                 ok(i == mp_translate_state(states[i]), testname);
diff --git a/lib/thresholds.c b/lib/thresholds.c
new file mode 100644
index 00000000..de2b9315
--- /dev/null
+++ b/lib/thresholds.c
@@ -0,0 +1,71 @@
+#include "./thresholds.h"
+#include "./utils_base.h"
+#include "perfdata.h"
+
+#include <stddef.h>
+
+mp_thresholds mp_thresholds_init() {
+        mp_thresholds tmp = {
+                .critical = {},
+                .critical_is_set = false,
+                .warning = {},
+                .warning_is_set = false,
+        };
+        return tmp;
+}
+
+char *fmt_threshold_warning(const thresholds th) {
+        if (th.warning == NULL) {
+                return "";
+        }
+
+        return fmt_range(*th.warning);
+}
+
+char *fmt_threshold_critical(const thresholds th) {
+        if (th.critical == NULL) {
+                return "";
+        }
+        return fmt_range(*th.critical);
+}
+
+mp_perfdata mp_pd_set_thresholds(mp_perfdata perfdata, mp_thresholds threshold) {
+        if (threshold.critical_is_set) {
+                perfdata.crit = threshold.critical;
+                perfdata.crit_present = true;
+        }
+
+        if (threshold.warning_is_set) {
+                perfdata.warn = threshold.warning;
+                perfdata.warn_present = true;
+        }
+
+        return perfdata;
+}
+
+mp_state_enum mp_get_pd_status(mp_perfdata perfdata) {
+        if (perfdata.crit_present) {
+                if (mp_check_range(perfdata.value, perfdata.crit)) {
+                        return STATE_CRITICAL;
+                }
+        }
+        if (perfdata.warn_present) {
+                if (mp_check_range(perfdata.value, perfdata.warn)) {
+                        return STATE_WARNING;
+                }
+        }
+
+        return STATE_OK;
+}
+
+mp_thresholds mp_thresholds_set_warn(mp_thresholds thlds, mp_range warn) {
+        thlds.warning = warn;
+        thlds.warning_is_set = true;
+        return thlds;
+}
+
+mp_thresholds mp_thresholds_set_crit(mp_thresholds thlds, mp_range crit) {
+        thlds.critical = crit;
+        thlds.critical_is_set = true;
+        return thlds;
+}
diff --git a/lib/thresholds.h b/lib/thresholds.h
new file mode 100644
index 00000000..f8647681
--- /dev/null
+++ b/lib/thresholds.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "./perfdata.h"
+#include "states.h"
+
+/*
+ * Old threshold type using the old range type
+ */
+typedef struct {
+        range *warning;
+        range *critical;
+} thresholds;
+
+typedef struct {
+        bool warning_is_set;
+        mp_range warning;
+        bool critical_is_set;
+        mp_range critical;
+} mp_thresholds;
+
+mp_thresholds mp_thresholds_init(void);
+
+mp_perfdata mp_pd_set_thresholds(mp_perfdata /* pd */, mp_thresholds /* th */);
+
+mp_state_enum mp_get_pd_status(mp_perfdata /* pd */);
+
+mp_thresholds mp_thresholds_set_warn(mp_thresholds thlds, mp_range warn);
+mp_thresholds mp_thresholds_set_crit(mp_thresholds thlds, mp_range crit);
+
+char *fmt_threshold_warning(thresholds th);
+char *fmt_threshold_critical(thresholds th);
diff --git a/lib/utils_base.c b/lib/utils_base.c
index 90a4aaa5..28e6dc47 100644
--- a/lib/utils_base.c
+++ b/lib/utils_base.c
@@ -25,6 +25,7 @@
  *****************************************************************************/
 
 #include "../plugins/common.h"
+#include "states.h"
 #include <stdarg.h>
 #include "utils_base.h"
 #include <ctype.h>
@@ -33,20 +34,20 @@
 #include <unistd.h>
 #include <sys/types.h>
 
-#define np_free(ptr)                                                                                                                       \
-        {                                                                                                                                      \
-                if (ptr) {                                                                                                                         \
-                        free(ptr);                                                                                                                     \
-                        ptr = NULL;                                                                                                                    \
-                }                                                                                                                                  \
+#define np_free(ptr)                                                                               \
+        {                                                                                              \
+                if (ptr) {                                                                                 \
+                        free(ptr);                                                                             \
+                        ptr = NULL;                                                                            \
+                }                                                                                          \
         }
 
 monitoring_plugin *this_monitoring_plugin = NULL;
 
-int timeout_state = STATE_CRITICAL;
+mp_state_enum timeout_state = STATE_CRITICAL;
 unsigned int timeout_interval = DEFAULT_SOCKET_TIMEOUT;
 
-bool _np_state_read_file(FILE *);
+bool _np_state_read_file(FILE *state_file);
 
 void np_init(char *plugin_name, int argc, char **argv) {
         if (this_monitoring_plugin == NULL) {
@@ -55,31 +56,25 @@ void np_init(char *plugin_name, int argc, char **argv) {
                         die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
                 }
                 this_monitoring_plugin->plugin_name = strdup(plugin_name);
-                if (this_monitoring_plugin->plugin_name == NULL)
+                if (this_monitoring_plugin->plugin_name == NULL) {
                         die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
+                }
                 this_monitoring_plugin->argc = argc;
                 this_monitoring_plugin->argv = argv;
         }
 }
 
 void np_set_args(int argc, char **argv) {
-        if (this_monitoring_plugin == NULL)
+        if (this_monitoring_plugin == NULL) {
                 die(STATE_UNKNOWN, _("This requires np_init to be called"));
+        }
 
         this_monitoring_plugin->argc = argc;
         this_monitoring_plugin->argv = argv;
 }
 
-void np_cleanup() {
+void np_cleanup(void) {
         if (this_monitoring_plugin != NULL) {
-                if (this_monitoring_plugin->state != NULL) {
-                        if (this_monitoring_plugin->state->state_data) {
-                                np_free(this_monitoring_plugin->state->state_data->data);
-                                np_free(this_monitoring_plugin->state->state_data);
-                        }
-                        np_free(this_monitoring_plugin->state->name);
-                        np_free(this_monitoring_plugin->state);
-                }
                 np_free(this_monitoring_plugin->plugin_name);
                 np_free(this_monitoring_plugin);
         }
@@ -151,7 +146,8 @@ range *parse_range_string(char *str) {
                 set_range_end(temp_range, end);
         }
 
-        if (temp_range->start_infinity == true || temp_range->end_infinity == true || temp_range->start <= temp_range->end) {
+        if (temp_range->start_infinity || temp_range->end_infinity ||
+                temp_range->start <= temp_range->end) {
                 return temp_range;
         }
         free(temp_range);
@@ -162,8 +158,9 @@ range *parse_range_string(char *str) {
 int _set_thresholds(thresholds **my_thresholds, char *warn_string, char *critical_string) {
         thresholds *temp_thresholds = NULL;
 
-        if ((temp_thresholds = calloc(1, sizeof(thresholds))) == NULL)
+        if ((temp_thresholds = calloc(1, sizeof(thresholds))) == NULL) {
                 die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
+        }
 
         temp_thresholds->warning = NULL;
         temp_thresholds->critical = NULL;
@@ -202,12 +199,14 @@ void print_thresholds(const char *threshold_name, thresholds *my_threshold) {
                 printf("Threshold not set");
         } else {
                 if (my_threshold->warning) {
-                        printf("Warning: start=%g end=%g; ", my_threshold->warning->start, my_threshold->warning->end);
+                        printf("Warning: start=%g end=%g; ", my_threshold->warning->start,
+                                   my_threshold->warning->end);
                 } else {
                         printf("Warning not set; ");
                 }
                 if (my_threshold->critical) {
-                        printf("Critical: start=%g end=%g", my_threshold->critical->start, my_threshold->critical->end);
+                        printf("Critical: start=%g end=%g", my_threshold->critical->start,
+                                   my_threshold->critical->end);
                 } else {
                         printf("Critical not set");
                 }
@@ -215,6 +214,36 @@ void print_thresholds(const char *threshold_name, thresholds *my_threshold) {
         printf("\n");
 }
 
+/* Returns true if alert should be raised based on the range, false otherwise */
+bool mp_check_range(const mp_perfdata_value value, const mp_range my_range) {
+        bool is_inside = false;
+
+        if (!my_range.end_infinity && !my_range.start_infinity) {
+                // range:  .........|---inside---|...........
+                // value
+                is_inside = ((cmp_perfdata_value(value, my_range.start) >= 0) &&
+                                         (cmp_perfdata_value(value, my_range.end) <= 0));
+        } else if (!my_range.start_infinity && my_range.end_infinity) {
+                // range:  .........|---inside---------
+                // value
+                is_inside = (cmp_perfdata_value(value, my_range.start) >= 0);
+        } else if (my_range.start_infinity && !my_range.end_infinity) {
+                // range:  -inside--------|....................
+                // value
+                is_inside = (cmp_perfdata_value(value, my_range.end) == -1);
+        } else {
+                // range from -inf to inf, so always inside
+                is_inside = true;
+        }
+
+        if ((is_inside && my_range.alert_on_inside_range == INSIDE) ||
+                (!is_inside && my_range.alert_on_inside_range == OUTSIDE)) {
+                return true;
+        }
+
+        return false;
+}
+
 /* Returns true if alert should be raised based on the range */
 bool check_range(double value, range *my_range) {
         bool no = false;
@@ -225,38 +254,38 @@ bool check_range(double value, range *my_range) {
                 yes = false;
         }
 
-        if (my_range->end_infinity == false && my_range->start_infinity == false) {
+        if (!my_range->end_infinity && !my_range->start_infinity) {
                 if ((my_range->start <= value) && (value <= my_range->end)) {
                         return no;
-                } else {
-                        return yes;
                 }
-        } else if (my_range->start_infinity == false && my_range->end_infinity == true) {
+                return yes;
+        }
+
+        if (!my_range->start_infinity && my_range->end_infinity) {
                 if (my_range->start <= value) {
                         return no;
-                } else {
-                        return yes;
                 }
-        } else if (my_range->start_infinity == true && my_range->end_infinity == false) {
+                return yes;
+        }
+
+        if (my_range->start_infinity && !my_range->end_infinity) {
                 if (value <= my_range->end) {
                         return no;
-                } else {
-                        return yes;
                 }
-        } else {
-                return no;
+                return yes;
         }
+        return no;
 }
 
 /* Returns status */
-int get_status(double value, thresholds *my_thresholds) {
+mp_state_enum get_status(double value, thresholds *my_thresholds) {
         if (my_thresholds->critical != NULL) {
-                if (check_range(value, my_thresholds->critical) == true) {
+                if (check_range(value, my_thresholds->critical)) {
                         return STATE_CRITICAL;
                 }
         }
         if (my_thresholds->warning != NULL) {
-                if (check_range(value, my_thresholds->warning) == true) {
+                if (check_range(value, my_thresholds->warning)) {
                         return STATE_WARNING;
                 }
         }
@@ -265,31 +294,31 @@ int get_status(double value, thresholds *my_thresholds) {
 
 char *np_escaped_string(const char *string) {
         char *data;
-        int i, j = 0;
+        int write_index = 0;
         data = strdup(string);
-        for (i = 0; data[i]; i++) {
+        for (int i = 0; data[i]; i++) {
                 if (data[i] == '\\') {
                         switch (data[++i]) {
                         case 'n':
-                                data[j++] = '\n';
+                                data[write_index++] = '\n';
                                 break;
                         case 'r':
-                                data[j++] = '\r';
+                                data[write_index++] = '\r';
                                 break;
                         case 't':
-                                data[j++] = '\t';
+                                data[write_index++] = '\t';
                                 break;
                         case '\\':
-                                data[j++] = '\\';
+                                data[write_index++] = '\\';
                                 break;
                         default:
-                                data[j++] = data[i];
+                                data[write_index++] = data[i];
                         }
                 } else {
-                        data[j++] = data[i];
+                        data[write_index++] = data[i];
                 }
         }
-        data[j] = '\0';
+        data[write_index] = '\0';
         return data;
 }
 
@@ -302,38 +331,43 @@ int np_check_if_root(void) { return (geteuid() == 0); }
  * data strings.
  */
 char *np_extract_value(const char *varlist, const char *name, char sep) {
-        char *tmp = NULL, *value = NULL;
-        int i;
+        char *tmp = NULL;
+        char *value = NULL;
 
-        while (1) {
+        while (true) {
                 /* Strip any leading space */
-                for (; isspace(varlist[0]); varlist++)
+                for (; isspace(varlist[0]); varlist++) {
                         ;
+                }
 
                 if (strncmp(name, varlist, strlen(name)) == 0) {
                         varlist += strlen(name);
                         /* strip trailing spaces */
-                        for (; isspace(varlist[0]); varlist++)
+                        for (; isspace(varlist[0]); varlist++) {
                                 ;
+                        }
 
                         if (varlist[0] == '=') {
                                 /* We matched the key, go past the = sign */
                                 varlist++;
                                 /* strip leading spaces */
-                                for (; isspace(varlist[0]); varlist++)
+                                for (; isspace(varlist[0]); varlist++) {
                                         ;
+                                }
 
                                 if ((tmp = index(varlist, sep))) {
                                         /* Value is delimited by a comma */
-                                        if (tmp - varlist == 0)
+                                        if (tmp - varlist == 0) {
                                                 continue;
-                                        value = (char *)calloc(1, tmp - varlist + 1);
-                                        strncpy(value, varlist, tmp - varlist);
+                                        }
+                                        value = (char *)calloc(1, (unsigned long)(tmp - varlist + 1));
+                                        strncpy(value, varlist, (unsigned long)(tmp - varlist));
                                         value[tmp - varlist] = '\0';
                                 } else {
                                         /* Value is delimited by a \0 */
-                                        if (strlen(varlist) == 0)
+                                        if (strlen(varlist) == 0) {
                                                 continue;
+                                        }
                                         value = (char *)calloc(1, strlen(varlist) + 1);
                                         strncpy(value, varlist, strlen(varlist));
                                         value[strlen(varlist)] = '\0';
@@ -351,14 +385,16 @@ char *np_extract_value(const char *varlist, const char *name, char sep) {
         }
 
         /* Clean-up trailing spaces/newlines */
-        if (value)
-                for (i = strlen(value) - 1; isspace(value[i]); i--)
+        if (value) {
+                for (unsigned long i = strlen(value) - 1; isspace(value[i]); i--) {
                         value[i] = '\0';
+                }
+        }
 
         return value;
 }
 
-const char *state_text(int result) {
+const char *state_text(mp_state_enum result) {
         switch (result) {
         case STATE_OK:
                 return "OK";
@@ -378,343 +414,17 @@ const char *state_text(int result) {
  * return the corresponding STATE_ value or ERROR)
  */
 int mp_translate_state(char *state_text) {
-        if (!strcasecmp(state_text, "OK") || !strcmp(state_text, "0"))
+        if (!strcasecmp(state_text, "OK") || !strcmp(state_text, "0")) {
                 return STATE_OK;
-        if (!strcasecmp(state_text, "WARNING") || !strcmp(state_text, "1"))
-                return STATE_WARNING;
-        if (!strcasecmp(state_text, "CRITICAL") || !strcmp(state_text, "2"))
-                return STATE_CRITICAL;
-        if (!strcasecmp(state_text, "UNKNOWN") || !strcmp(state_text, "3"))
-                return STATE_UNKNOWN;
-        return ERROR;
-}
-
-/*
- * Returns a string to use as a keyname, based on an md5 hash of argv, thus
- * hopefully a unique key per service/plugin invocation. Use the extra-opts
- * parse of argv, so that uniqueness in parameters are reflected there.
- */
-char *_np_state_generate_key() {
-        int i;
-        char **argv = this_monitoring_plugin->argv;
-        char keyname[41];
-        char *p = NULL;
-
-        unsigned char result[256];
-
-#ifdef USE_OPENSSL
-        /*
-         * This code path is chosen if openssl is available (which should be the most common
-         * scenario). Alternatively, the gnulib implementation/
-         *
-         */
-        EVP_MD_CTX *ctx = EVP_MD_CTX_new();
-
-        EVP_DigestInit(ctx, EVP_sha256());
-
-        for (i = 0; i < this_monitoring_plugin->argc; i++) {
-                EVP_DigestUpdate(ctx, argv[i], strlen(argv[i]));
-        }
-
-        EVP_DigestFinal(ctx, result, NULL);
-#else
-
-        struct sha256_ctx ctx;
-
-        for (i = 0; i < this_monitoring_plugin->argc; i++) {
-                sha256_process_bytes(argv[i], strlen(argv[i]), &ctx);
-        }
-
-        sha256_finish_ctx(&ctx, result);
-#endif // FOUNDOPENSSL
-
-        for (i = 0; i < 20; ++i) {
-                sprintf(&keyname[2 * i], "%02x", result[i]);
-        }
-
-        keyname[40] = '\0';
-
-        p = strdup(keyname);
-        if (p == NULL) {
-                die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
-        }
-        return p;
-}
-
-void _cleanup_state_data() {
-        if (this_monitoring_plugin->state->state_data != NULL) {
-                np_free(this_monitoring_plugin->state->state_data->data);
-                np_free(this_monitoring_plugin->state->state_data);
-        }
-}
-
-/*
- * Internal function. Returns either:
- *   envvar NAGIOS_PLUGIN_STATE_DIRECTORY
- *   statically compiled shared state directory
- */
-char *_np_state_calculate_location_prefix() {
-        char *env_dir;
-
-        /* Do not allow passing MP_STATE_PATH in setuid plugins
-         * for security reasons */
-        if (!mp_suid()) {
-                env_dir = getenv("MP_STATE_PATH");
-                if (env_dir && env_dir[0] != '\0')
-                        return env_dir;
-                /* This is the former ENV, for backward-compatibility */
-                env_dir = getenv("NAGIOS_PLUGIN_STATE_DIRECTORY");
-                if (env_dir && env_dir[0] != '\0')
-                        return env_dir;
-        }
-
-        return NP_STATE_DIR_PREFIX;
-}
-
-/*
- * Initiatializer for state routines.
- * Sets variables. Generates filename. Returns np_state_key. die with
- * UNKNOWN if exception
- */
-void np_enable_state(char *keyname, int expected_data_version) {
-        state_key *this_state = NULL;
-        char *temp_filename = NULL;
-        char *temp_keyname = NULL;
-        char *p = NULL;
-        int ret;
-
-        if (this_monitoring_plugin == NULL)
-                die(STATE_UNKNOWN, _("This requires np_init to be called"));
-
-        this_state = (state_key *)calloc(1, sizeof(state_key));
-        if (this_state == NULL)
-                die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
-
-        if (keyname == NULL) {
-                temp_keyname = _np_state_generate_key();
-        } else {
-                temp_keyname = strdup(keyname);
-                if (temp_keyname == NULL)
-                        die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
         }
-        /* Die if invalid characters used for keyname */
-        p = temp_keyname;
-        while (*p != '\0') {
-                if (!(isalnum(*p) || *p == '_')) {
-                        die(STATE_UNKNOWN, _("Invalid character for keyname - only alphanumerics or '_'"));
-                }
-                p++;
-        }
-        this_state->name = temp_keyname;
-        this_state->plugin_name = this_monitoring_plugin->plugin_name;
-        this_state->data_version = expected_data_version;
-        this_state->state_data = NULL;
-
-        /* Calculate filename */
-        ret = asprintf(&temp_filename, "%s/%lu/%s/%s", _np_state_calculate_location_prefix(), (unsigned long)geteuid(),
-                                   this_monitoring_plugin->plugin_name, this_state->name);
-        if (ret < 0)
-                die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
-
-        this_state->_filename = temp_filename;
-
-        this_monitoring_plugin->state = this_state;
-}
-
-/*
- * Will return NULL if no data is available (first run). If key currently
- * exists, read data. If state file format version is not expected, return
- * as if no data. Get state data version number and compares to expected.
- * If numerically lower, then return as no previous state. die with UNKNOWN
- * if exceptional error.
- */
-state_data *np_state_read() {
-        state_data *this_state_data = NULL;
-        FILE *statefile;
-        bool rc = false;
-
-        if (this_monitoring_plugin == NULL)
-                die(STATE_UNKNOWN, _("This requires np_init to be called"));
-
-        /* Open file. If this fails, no previous state found */
-        statefile = fopen(this_monitoring_plugin->state->_filename, "r");
-        if (statefile != NULL) {
-
-                this_state_data = (state_data *)calloc(1, sizeof(state_data));
-                if (this_state_data == NULL)
-                        die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
-
-                this_state_data->data = NULL;
-                this_monitoring_plugin->state->state_data = this_state_data;
-
-                rc = _np_state_read_file(statefile);
-
-                fclose(statefile);
-        }
-
-        if (!rc) {
-                _cleanup_state_data();
-        }
-
-        return this_monitoring_plugin->state->state_data;
-}
-
-/*
- * Read the state file
- */
-bool _np_state_read_file(FILE *f) {
-        bool status = false;
-        size_t pos;
-        char *line;
-        int i;
-        int failure = 0;
-        time_t current_time, data_time;
-        enum {
-                STATE_FILE_VERSION,
-                STATE_DATA_VERSION,
-                STATE_DATA_TIME,
-                STATE_DATA_TEXT,
-                STATE_DATA_END
-        } expected = STATE_FILE_VERSION;
-
-        time(&current_time);
-
-        /* Note: This introduces a limit of 1024 bytes in the string data */
-        line = (char *)calloc(1, 1024);
-        if (line == NULL)
-                die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
-
-        while (!failure && (fgets(line, 1024, f)) != NULL) {
-                pos = strlen(line);
-                if (line[pos - 1] == '\n') {
-                        line[pos - 1] = '\0';
-                }
-
-                if (line[0] == '#')
-                        continue;
-
-                switch (expected) {
-                case STATE_FILE_VERSION:
-                        i = atoi(line);
-                        if (i != NP_STATE_FORMAT_VERSION)
-                                failure++;
-                        else
-                                expected = STATE_DATA_VERSION;
-                        break;
-                case STATE_DATA_VERSION:
-                        i = atoi(line);
-                        if (i != this_monitoring_plugin->state->data_version)
-                                failure++;
-                        else
-                                expected = STATE_DATA_TIME;
-                        break;
-                case STATE_DATA_TIME:
-                        /* If time > now, error */
-                        data_time = strtoul(line, NULL, 10);
-                        if (data_time > current_time)
-                                failure++;
-                        else {
-                                this_monitoring_plugin->state->state_data->time = data_time;
-                                expected = STATE_DATA_TEXT;
-                        }
-                        break;
-                case STATE_DATA_TEXT:
-                        this_monitoring_plugin->state->state_data->data = strdup(line);
-                        if (this_monitoring_plugin->state->state_data->data == NULL)
-                                die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
-                        expected = STATE_DATA_END;
-                        status = true;
-                        break;
-                case STATE_DATA_END:;
-                }
-        }
-
-        np_free(line);
-        return status;
-}
-
-/*
- * If time=NULL, use current time. Create state file, with state format
- * version, default text. Writes version, time, and data. Avoid locking
- * problems - use mv to write and then swap. Possible loss of state data if
- * two things writing to same key at same time.
- * Will die with UNKNOWN if errors
- */
-void np_state_write_string(time_t data_time, char *data_string) {
-        FILE *fp;
-        char *temp_file = NULL;
-        int fd = 0, result = 0;
-        time_t current_time;
-        char *directories = NULL;
-        char *p = NULL;
-
-        if (data_time == 0)
-                time(&current_time);
-        else
-                current_time = data_time;
-
-        /* If file doesn't currently exist, create directories */
-        if (access(this_monitoring_plugin->state->_filename, F_OK) != 0) {
-                result = asprintf(&directories, "%s", this_monitoring_plugin->state->_filename);
-                if (result < 0)
-                        die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
-
-                for (p = directories + 1; *p; p++) {
-                        if (*p == '/') {
-                                *p = '\0';
-                                if ((access(directories, F_OK) != 0) && (mkdir(directories, S_IRWXU) != 0)) {
-                                        /* Can't free this! Otherwise error message is wrong! */
-                                        /* np_free(directories); */
-                                        die(STATE_UNKNOWN, _("Cannot create directory: %s"), directories);
-                                }
-                                *p = '/';
-                        }
-                }
-                np_free(directories);
-        }
-
-        result = asprintf(&temp_file, "%s.XXXXXX", this_monitoring_plugin->state->_filename);
-        if (result < 0)
-                die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
-
-        if ((fd = mkstemp(temp_file)) == -1) {
-                np_free(temp_file);
-                die(STATE_UNKNOWN, _("Cannot create temporary filename"));
-        }
-
-        fp = (FILE *)fdopen(fd, "w");
-        if (fp == NULL) {
-                close(fd);
-                unlink(temp_file);
-                np_free(temp_file);
-                die(STATE_UNKNOWN, _("Unable to open temporary state file"));
+        if (!strcasecmp(state_text, "WARNING") || !strcmp(state_text, "1")) {
+                return STATE_WARNING;
         }
-
-        fprintf(fp, "# NP State file\n");
-        fprintf(fp, "%d\n", NP_STATE_FORMAT_VERSION);
-        fprintf(fp, "%d\n", this_monitoring_plugin->state->data_version);
-        fprintf(fp, "%lu\n", current_time);
-        fprintf(fp, "%s\n", data_string);
-
-        fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP);
-
-        fflush(fp);
-
-        result = fclose(fp);
-
-        fsync(fd);
-
-        if (result != 0) {
-                unlink(temp_file);
-                np_free(temp_file);
-                die(STATE_UNKNOWN, _("Error writing temp file"));
+        if (!strcasecmp(state_text, "CRITICAL") || !strcmp(state_text, "2")) {
+                return STATE_CRITICAL;
         }
-
-        if (rename(temp_file, this_monitoring_plugin->state->_filename) != 0) {
-                unlink(temp_file);
-                np_free(temp_file);
-                die(STATE_UNKNOWN, _("Cannot rename state temp file"));
+        if (!strcasecmp(state_text, "UNKNOWN") || !strcmp(state_text, "3")) {
+                return STATE_UNKNOWN;
         }
-
-        np_free(temp_file);
+        return ERROR;
 }
diff --git a/lib/utils_base.h b/lib/utils_base.h
index a209cb6d..27884bf0 100644
--- a/lib/utils_base.h
+++ b/lib/utils_base.h
@@ -2,6 +2,13 @@
 #define _UTILS_BASE_
 /* Header file for Monitoring Plugins utils_base.c */
 
+#include "../config.h"
+#include <time.h>
+
+#include "./perfdata.h"
+#include "./thresholds.h"
+#include "states.h"
+
 #ifndef USE_OPENSSL
 #       include "sha256.h"
 #endif
@@ -19,39 +26,8 @@
 #define OUTSIDE 0
 #define INSIDE  1
 
-typedef struct range_struct {
-        double start;
-        bool start_infinity;
-        double end;
-        int end_infinity;
-        int alert_on; /* OUTSIDE (default) or INSIDE */
-        char *text;   /* original unparsed text input */
-} range;
-
-typedef struct thresholds_struct {
-        range *warning;
-        range *critical;
-} thresholds;
-
-#define NP_STATE_FORMAT_VERSION 1
-
-typedef struct state_data_struct {
-        time_t time;
-        void *data;
-        int length; /* Of binary data */
-} state_data;
-
-typedef struct state_key_struct {
-        char *name;
-        char *plugin_name;
-        int data_version;
-        char *_filename;
-        state_data *state_data;
-} state_key;
-
 typedef struct np_struct {
         char *plugin_name;
-        state_key *state;
         int argc;
         char **argv;
 } monitoring_plugin;
@@ -61,10 +37,11 @@ int _set_thresholds(thresholds **, char *, char *);
 void set_thresholds(thresholds **, char *, char *);
 void print_thresholds(const char *, thresholds *);
 bool check_range(double, range *);
-int get_status(double, thresholds *);
+bool mp_check_range(mp_perfdata_value, mp_range);
+mp_state_enum get_status(double, thresholds *);
 
 /* Handle timeouts */
-extern int timeout_state;
+extern mp_state_enum timeout_state;
 extern unsigned int timeout_interval;
 
 /* All possible characters in a threshold range */
@@ -106,13 +83,9 @@ char *np_extract_value(const char *, const char *, char);
  */
 int mp_translate_state(char *);
 
-void np_enable_state(char *, int);
-state_data *np_state_read();
-void np_state_write_string(time_t, char *);
-
 void np_init(char *, int argc, char **argv);
 void np_set_args(int argc, char **argv);
-void np_cleanup();
-const char *state_text(int);
+void np_cleanup(void);
+const char *state_text(mp_state_enum);
 
 #endif /* _UTILS_BASE_ */
diff --git a/lib/utils_cmd.c b/lib/utils_cmd.c
index 18350ac0..35b83297 100644
--- a/lib/utils_cmd.c
+++ b/lib/utils_cmd.c
@@ -40,7 +40,6 @@
 
 /** includes **/
 #include "common.h"
-#include "utils.h"
 #include "utils_cmd.h"
 /* This variable must be global, since there's no way the caller
  * can forcibly slay a dead or ungainly running program otherwise.
@@ -62,16 +61,13 @@ static pid_t *_cmd_pids = NULL;
 #       include <sys/wait.h>
 #endif
 
-/* used in _cmd_open to pass the environment to commands */
-extern char **environ;
-
 /** macros **/
 #ifndef WEXITSTATUS
 #       define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
 #endif
 
 #ifndef WIFEXITED
-#       define WIFEXITED(stat_val) (((stat_val)&255) == 0)
+#       define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
 #endif
 
 /* 4.3BSD Reno <signal.h> doesn't define SIG_ERR */
@@ -80,14 +76,12 @@ extern char **environ;
 #endif
 
 /** prototypes **/
-static int _cmd_open(char *const *, int *, int *) __attribute__((__nonnull__(1, 2, 3)));
-
-static int _cmd_fetch_output(int, output *, int) __attribute__((__nonnull__(2)));
+static int _cmd_open(char *const *argv, int *pfd, int *pfderr)
+        __attribute__((__nonnull__(1, 2, 3)));
 
-static int _cmd_close(int);
+static int _cmd_fetch_output(int fileDescriptor, output *cmd_output, int flags) __attribute__((__nonnull__(2)));
 
-/* prototype imported from utils.h */
-extern void die(int, const char *, ...) __attribute__((__noreturn__, __format__(__printf__, 2, 3)));
+static int _cmd_close(int fileDescriptor);
 
 /* this function is NOT async-safe. It is exported so multithreaded
  * plugins (or other apps) can call it prior to running any commands
@@ -103,26 +97,29 @@ void cmd_init(void) {
                 maxfd = MAXFD_LIMIT;
         }
 
-        if (!_cmd_pids)
+        if (!_cmd_pids) {
                 _cmd_pids = calloc(maxfd, sizeof(pid_t));
+        }
 }
 
 /* Start running a command, array style */
 static int _cmd_open(char *const *argv, int *pfd, int *pfderr) {
-        pid_t pid;
 #ifdef RLIMIT_CORE
         struct rlimit limit;
 #endif
 
         int i = 0;
 
-        if (!_cmd_pids)
+        if (!_cmd_pids) {
                 CMD_INIT;
+        }
 
         setenv("LC_ALL", "C", 1);
 
-        if (pipe(pfd) < 0 || pipe(pfderr) < 0 || (pid = fork()) < 0)
+        pid_t pid;
+        if (pipe(pfd) < 0 || pipe(pfderr) < 0 || (pid = fork()) < 0) {
                 return -1; /* errno set by the failing function */
+        }
 
         /* child runs exceve() and _exit. */
         if (pid == 0) {
@@ -147,9 +144,11 @@ static int _cmd_open(char *const *argv, int *pfd, int *pfderr) {
                  * This is executed in a separate address space (pure child),
                  * so we don't have to worry about async safety */
                 long maxfd = mp_open_max();
-                for (i = 0; i < maxfd; i++)
-                        if (_cmd_pids[i] > 0)
+                for (i = 0; i < maxfd; i++) {
+                        if (_cmd_pids[i] > 0) {
                                 close(i);
+                        }
+                }
 
                 execve(argv[0], argv, environ);
                 _exit(STATE_UNKNOWN);
@@ -166,87 +165,94 @@ static int _cmd_open(char *const *argv, int *pfd, int *pfderr) {
         return pfd[0];
 }
 
-static int _cmd_close(int fd) {
-        int status;
+static int _cmd_close(int fileDescriptor) {
         pid_t pid;
 
         /* make sure the provided fd was opened */
         long maxfd = mp_open_max();
-        if (fd < 0 || fd > maxfd || !_cmd_pids || (pid = _cmd_pids[fd]) == 0)
+        if (fileDescriptor < 0 || fileDescriptor > maxfd || !_cmd_pids ||
+                (pid = _cmd_pids[fileDescriptor]) == 0) {
                 return -1;
+        }
 
-        _cmd_pids[fd] = 0;
-        if (close(fd) == -1)
+        _cmd_pids[fileDescriptor] = 0;
+        if (close(fileDescriptor) == -1) {
                 return -1;
+        }
 
         /* EINTR is ok (sort of), everything else is bad */
-        while (waitpid(pid, &status, 0) < 0)
-                if (errno != EINTR)
+        int status;
+        while (waitpid(pid, &status, 0) < 0) {
+                if (errno != EINTR) {
                         return -1;
+                }
+        }
 
         /* return child's termination status */
         return (WIFEXITED(status)) ? WEXITSTATUS(status) : -1;
 }
 
-static int _cmd_fetch_output(int fd, output *op, int flags) {
-        size_t len = 0, i = 0, lineno = 0;
-        size_t rsf = 6, ary_size = 0; /* rsf = right shift factor, dec'ed uncond once */
-        char *buf = NULL;
-        int ret;
+static int _cmd_fetch_output(int fileDescriptor, output *cmd_output, int flags) {
         char tmpbuf[4096];
-
-        op->buf = NULL;
-        op->buflen = 0;
-        while ((ret = read(fd, tmpbuf, sizeof(tmpbuf))) > 0) {
-                len = (size_t)ret;
-                op->buf = realloc(op->buf, op->buflen + len + 1);
-                memcpy(op->buf + op->buflen, tmpbuf, len);
-                op->buflen += len;
-                i++;
+        cmd_output->buf = NULL;
+        cmd_output->buflen = 0;
+        ssize_t ret;
+        while ((ret = read(fileDescriptor, tmpbuf, sizeof(tmpbuf))) > 0) {
+                size_t len = (size_t)ret;
+                cmd_output->buf = realloc(cmd_output->buf, cmd_output->buflen + len + 1);
+                memcpy(cmd_output->buf + cmd_output->buflen, tmpbuf, len);
+                cmd_output->buflen += len;
         }
 
         if (ret < 0) {
-                printf("read() returned %d: %s\n", ret, strerror(errno));
+                printf("read() returned %zd: %s\n", ret, strerror(errno));
                 return ret;
         }
 
         /* some plugins may want to keep output unbroken, and some commands
          * will yield no output, so return here for those */
-        if (flags & CMD_NO_ARRAYS || !op->buf || !op->buflen)
-                return op->buflen;
+        if (flags & CMD_NO_ARRAYS || !cmd_output->buf || !cmd_output->buflen) {
+                return cmd_output->buflen;
+        }
 
         /* and some may want both */
+        char *buf = NULL;
         if (flags & CMD_NO_ASSOC) {
-                buf = malloc(op->buflen);
-                memcpy(buf, op->buf, op->buflen);
-        } else
-                buf = op->buf;
-
-        op->line = NULL;
-        op->lens = NULL;
-        i = 0;
-        while (i < op->buflen) {
+                buf = malloc(cmd_output->buflen);
+                memcpy(buf, cmd_output->buf, cmd_output->buflen);
+        } else {
+                buf = cmd_output->buf;
+        }
+
+        cmd_output->line = NULL;
+        cmd_output->lens = NULL;
+        size_t i = 0;
+        size_t ary_size = 0; /* rsf = right shift factor, dec'ed uncond once */
+        size_t rsf = 6;
+        size_t lineno = 0;
+        while (i < cmd_output->buflen) {
                 /* make sure we have enough memory */
                 if (lineno >= ary_size) {
                         /* ary_size must never be zero */
                         do {
-                                ary_size = op->buflen >> --rsf;
+                                ary_size = cmd_output->buflen >> --rsf;
                         } while (!ary_size);
 
-                        op->line = realloc(op->line, ary_size * sizeof(char *));
-                        op->lens = realloc(op->lens, ary_size * sizeof(size_t));
+                        cmd_output->line = realloc(cmd_output->line, ary_size * sizeof(char *));
+                        cmd_output->lens = realloc(cmd_output->lens, ary_size * sizeof(size_t));
                 }
 
                 /* set the pointer to the string */
-                op->line[lineno] = &buf[i];
+                cmd_output->line[lineno] = &buf[i];
 
                 /* hop to next newline or end of buffer */
-                while (buf[i] != '\n' && i < op->buflen)
+                while (buf[i] != '\n' && i < cmd_output->buflen) {
                         i++;
+                }
                 buf[i] = '\0';
 
                 /* calculate the string length using pointer difference */
-                op->lens[lineno] = (size_t)&buf[i] - (size_t)op->line[lineno];
+                cmd_output->lens[lineno] = (size_t)&buf[i] - (size_t)cmd_output->line[lineno];
 
                 lineno++;
                 i++;
@@ -256,41 +262,42 @@ static int _cmd_fetch_output(int fd, output *op, int flags) {
 }
 
 int cmd_run(const char *cmdstring, output *out, output *err, int flags) {
-        int i = 0, argc;
-        size_t cmdlen;
-        char **argv = NULL;
-        char *cmd = NULL;
-        char *str = NULL;
-
-        if (cmdstring == NULL)
+        if (cmdstring == NULL) {
                 return -1;
+        }
 
         /* initialize the structs */
-        if (out)
+        if (out) {
                 memset(out, 0, sizeof(output));
-        if (err)
+        }
+        if (err) {
                 memset(err, 0, sizeof(output));
+        }
 
         /* make copy of command string so strtok() doesn't silently modify it */
         /* (the calling program may want to access it later) */
-        cmdlen = strlen(cmdstring);
-        if ((cmd = malloc(cmdlen + 1)) == NULL)
+        size_t cmdlen = strlen(cmdstring);
+        char *cmd = NULL;
+        if ((cmd = malloc(cmdlen + 1)) == NULL) {
                 return -1;
+        }
         memcpy(cmd, cmdstring, cmdlen);
         cmd[cmdlen] = '\0';
 
         /* This is not a shell, so we don't handle "???" */
-        if (strstr(cmdstring, "\""))
+        if (strstr(cmdstring, "\"")) {
                 return -1;
+        }
 
         /* allow single quotes, but only if non-whitesapce doesn't occur on both sides */
-        if (strstr(cmdstring, " ' ") || strstr(cmdstring, "'''"))
+        if (strstr(cmdstring, " ' ") || strstr(cmdstring, "'''")) {
                 return -1;
+        }
 
         /* each arg must be whitespace-separated, so args can be a maximum
          * of (len / 2) + 1. We add 1 extra to the mix for NULL termination */
-        argc = (cmdlen >> 1) + 2;
-        argv = calloc((size_t)argc, sizeof(char *));
+        int argc = (cmdlen >> 1) + 2;
+        char **argv = calloc((size_t)argc, sizeof(char *));
 
         if (argv == NULL) {
                 printf("%s\n", _("Could not malloc argv array in popen()"));
@@ -298,14 +305,16 @@ int cmd_run(const char *cmdstring, output *out, output *err, int flags) {
         }
 
         /* get command arguments (stupidly, but fairly quickly) */
+        int i = 0;
         while (cmd) {
-                str = cmd;
+                char *str = cmd;
                 str += strspn(str, " \t\r\n"); /* trim any leading whitespace */
 
                 if (strstr(str, "'") == str) { /* handle SIMPLE quoted strings */
                         str++;
-                        if (!strstr(str, "'"))
+                        if (!strstr(str, "'")) {
                                 return -1; /* balanced? */
+                        }
                         cmd = 1 + strstr(str, "'");
                         str[strcspn(str, "'")] = 0;
                 } else {
@@ -317,8 +326,9 @@ int cmd_run(const char *cmdstring, output *out, output *err, int flags) {
                         }
                 }
 
-                if (cmd && strlen(cmd) == strspn(cmd, " \t\r\n"))
+                if (cmd && strlen(cmd) == strspn(cmd, " \t\r\n")) {
                         cmd = NULL;
+                }
 
                 argv[i++] = str;
         }
@@ -327,53 +337,65 @@ int cmd_run(const char *cmdstring, output *out, output *err, int flags) {
 }
 
 int cmd_run_array(char *const *argv, output *out, output *err, int flags) {
-        int fd, pfd_out[2], pfd_err[2];
-
         /* initialize the structs */
-        if (out)
+        if (out) {
                 memset(out, 0, sizeof(output));
-        if (err)
+        }
+        if (err) {
                 memset(err, 0, sizeof(output));
+        }
 
-        if ((fd = _cmd_open(argv, pfd_out, pfd_err)) == -1)
+        int fd;
+        int pfd_out[2];
+        int pfd_err[2];
+        if ((fd = _cmd_open(argv, pfd_out, pfd_err)) == -1) {
                 die(STATE_UNKNOWN, _("Could not open pipe: %s\n"), argv[0]);
+        }
 
-        if (out)
+        if (out) {
                 out->lines = _cmd_fetch_output(pfd_out[0], out, flags);
-        if (err)
+        }
+        if (err) {
                 err->lines = _cmd_fetch_output(pfd_err[0], err, flags);
+        }
 
         return _cmd_close(fd);
 }
 
-int cmd_file_read(char *filename, output *out, int flags) {
+int cmd_file_read(const char *filename, output *out, int flags) {
         int fd;
-        if (out)
+        if (out) {
                 memset(out, 0, sizeof(output));
+        }
 
         if ((fd = open(filename, O_RDONLY)) == -1) {
                 die(STATE_UNKNOWN, _("Error opening %s: %s"), filename, strerror(errno));
         }
 
-        if (out)
+        if (out) {
                 out->lines = _cmd_fetch_output(fd, out, flags);
+        }
 
-        if (close(fd) == -1)
+        if (close(fd) == -1) {
                 die(STATE_UNKNOWN, _("Error closing %s: %s"), filename, strerror(errno));
+        }
 
         return 0;
 }
 
 void timeout_alarm_handler(int signo) {
         if (signo == SIGALRM) {
-                printf(_("%s - Plugin timed out after %d seconds\n"), state_text(timeout_state), timeout_interval);
+                printf(_("%s - Plugin timed out after %d seconds\n"), state_text(timeout_state),
+                           timeout_interval);
 
                 long maxfd = mp_open_max();
-                if (_cmd_pids)
+                if (_cmd_pids) {
                         for (long int i = 0; i < maxfd; i++) {
-                                if (_cmd_pids[i] != 0)
+                                if (_cmd_pids[i] != 0) {
                                         kill(_cmd_pids[i], SIGKILL);
+                                }
                         }
+                }
 
                 exit(timeout_state);
         }
diff --git a/lib/utils_cmd.h b/lib/utils_cmd.h
index d00069c9..3672cdc9 100644
--- a/lib/utils_cmd.h
+++ b/lib/utils_cmd.h
@@ -5,22 +5,22 @@
  * Header file for Monitoring Plugins utils_cmd.c
  *
  */
+#include "../config.h"
+#include <stddef.h>
 
 /** types **/
-struct output {
+typedef struct {
         char *buf;     /* output buffer */
         size_t buflen; /* output buffer content length */
         char **line;   /* array of lines (points to buf) */
         size_t *lens;  /* string lengths */
         size_t lines;  /* lines of output */
-};
-
-typedef struct output output;
+} output;
 
 /** prototypes **/
 int cmd_run(const char *, output *, output *, int);
 int cmd_run_array(char *const *, output *, output *, int);
-int cmd_file_read(char *, output *, int);
+int cmd_file_read(const char *, output *, int);
 
 /* only multi-threaded plugins need to bother with this */
 void cmd_init(void);
diff --git a/lib/utils_disk.c b/lib/utils_disk.c
deleted file mode 100644
index 2b761f5e..00000000
--- a/lib/utils_disk.c
+++ /dev/null
@@ -1,255 +0,0 @@
-/*****************************************************************************
- *
- * Library for check_disk
- *
- * License: GPL
- * Copyright (c) 1999-2024 Monitoring Plugins Development Team
- *
- * Description:
- *
- * This file contains utilities for check_disk. These are tested by libtap
- *
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- *
- *****************************************************************************/
-
-#include "common.h"
-#include "utils_disk.h"
-#include "gl/fsusage.h"
-#include <string.h>
-
-void np_add_name(struct name_list **list, const char *name) {
-        struct name_list *new_entry;
-        new_entry = (struct name_list *)malloc(sizeof *new_entry);
-        new_entry->name = (char *)name;
-        new_entry->next = *list;
-        *list = new_entry;
-}
-
-/* @brief Initialises a new regex at the begin of list via regcomp(3)
- *
- * @details if the regex fails to compile the error code of regcomp(3) is returned
- *                                      and list is not modified, otherwise list is modified to point to the new
- *                                      element
- * @param list Pointer to a linked list of regex_list elements
- * @param regex the string containing the regex which should be inserted into the list
- * @param clags the cflags parameter for regcomp(3)
- */
-int np_add_regex(struct regex_list **list, const char *regex, int cflags) {
-        struct regex_list *new_entry = (struct regex_list *)malloc(sizeof *new_entry);
-
-        if (new_entry == NULL) {
-                die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
-        }
-
-        int regcomp_result = regcomp(&new_entry->regex, regex, cflags);
-
-        if (!regcomp_result) {
-                // regcomp succeeded
-                new_entry->next = *list;
-                *list = new_entry;
-
-                return 0;
-        } else {
-                // regcomp failed
-                free(new_entry);
-
-                return regcomp_result;
-        }
-}
-
-/* Initialises a new parameter at the end of list */
-struct parameter_list *np_add_parameter(struct parameter_list **list, const char *name) {
-        struct parameter_list *current = *list;
-        struct parameter_list *new_path;
-        new_path = (struct parameter_list *)malloc(sizeof *new_path);
-        new_path->name = (char *)malloc(strlen(name) + 1);
-        new_path->best_match = NULL;
-        new_path->name_next = NULL;
-        new_path->name_prev = NULL;
-        new_path->freespace_bytes = NULL;
-        new_path->freespace_units = NULL;
-        new_path->freespace_percent = NULL;
-        new_path->usedspace_bytes = NULL;
-        new_path->usedspace_units = NULL;
-        new_path->usedspace_percent = NULL;
-        new_path->usedinodes_percent = NULL;
-        new_path->freeinodes_percent = NULL;
-        new_path->group = NULL;
-        new_path->dfree_pct = -1;
-        new_path->dused_pct = -1;
-        new_path->total = 0;
-        new_path->available = 0;
-        new_path->available_to_root = 0;
-        new_path->used = 0;
-        new_path->dused_units = 0;
-        new_path->dfree_units = 0;
-        new_path->dtotal_units = 0;
-        new_path->inodes_total = 0;
-        new_path->inodes_free = 0;
-        new_path->inodes_free_to_root = 0;
-        new_path->inodes_used = 0;
-        new_path->dused_inodes_percent = 0;
-        new_path->dfree_inodes_percent = 0;
-
-        strcpy(new_path->name, name);
-
-        if (current == NULL) {
-                *list = new_path;
-                new_path->name_prev = NULL;
-        } else {
-                while (current->name_next) {
-                        current = current->name_next;
-                }
-                current->name_next = new_path;
-                new_path->name_prev = current;
-        }
-        return new_path;
-}
-
-/* Delete a given parameter from list and return pointer to next element*/
-struct parameter_list *np_del_parameter(struct parameter_list *item, struct parameter_list *prev) {
-        if (item == NULL) {
-                return NULL;
-        }
-        struct parameter_list *next;
-
-        if (item->name_next)
-                next = item->name_next;
-        else
-                next = NULL;
-
-        if (next)
-                next->name_prev = prev;
-
-        if (prev)
-                prev->name_next = next;
-
-        if (item->name) {
-                free(item->name);
-        }
-        free(item);
-
-        return next;
-}
-
-/* returns a pointer to the struct found in the list */
-struct parameter_list *np_find_parameter(struct parameter_list *list, const char *name) {
-        struct parameter_list *temp_list;
-        for (temp_list = list; temp_list; temp_list = temp_list->name_next) {
-                if (!strcmp(temp_list->name, name))
-                        return temp_list;
-        }
-
-        return NULL;
-}
-
-void np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list, bool exact) {
-        struct parameter_list *d;
-        for (d = desired; d; d = d->name_next) {
-                if (!d->best_match) {
-                        struct mount_entry *me;
-                        size_t name_len = strlen(d->name);
-                        size_t best_match_len = 0;
-                        struct mount_entry *best_match = NULL;
-                        struct fs_usage fsp;
-
-                        /* set best match if path name exactly matches a mounted device name */
-                        for (me = mount_list; me; me = me->me_next) {
-                                if (strcmp(me->me_devname, d->name) == 0) {
-                                        if (get_fs_usage(me->me_mountdir, me->me_devname, &fsp) >= 0) {
-                                                best_match = me;
-                                        }
-                                }
-                        }
-
-                        /* set best match by directory name if no match was found by devname */
-                        if (!best_match) {
-                                for (me = mount_list; me; me = me->me_next) {
-                                        size_t len = strlen(me->me_mountdir);
-                                        if ((!exact &&
-                                                 (best_match_len <= len && len <= name_len && (len == 1 || strncmp(me->me_mountdir, d->name, len) == 0))) ||
-                                                (exact && strcmp(me->me_mountdir, d->name) == 0)) {
-                                                if (get_fs_usage(me->me_mountdir, me->me_devname, &fsp) >= 0) {
-                                                        best_match = me;
-                                                        best_match_len = len;
-                                                }
-                                        }
-                                }
-                        }
-
-                        if (best_match) {
-                                d->best_match = best_match;
-                        } else {
-                                d->best_match = NULL; /* Not sure why this is needed as it should be null on initialisation */
-                        }
-                }
-        }
-}
-
-/* Returns true if name is in list */
-bool np_find_name(struct name_list *list, const char *name) {
-        const struct name_list *n;
-
-        if (list == NULL || name == NULL) {
-                return false;
-        }
-        for (n = list; n; n = n->next) {
-                if (!strcmp(name, n->name)) {
-                        return true;
-                }
-        }
-        return false;
-}
-
-/* Returns true if name is in list */
-bool np_find_regmatch(struct regex_list *list, const char *name) {
-        int len;
-        regmatch_t m;
-
-        if (name == NULL) {
-                return false;
-        }
-
-        len = strlen(name);
-
-        for (; list; list = list->next) {
-                /* Emulate a full match as if surrounded with ^( )$
-                   by checking whether the match spans the whole name */
-                if (!regexec(&list->regex, name, 1, &m, 0) && m.rm_so == 0 && m.rm_eo == len) {
-                        return true;
-                }
-        }
-
-        return false;
-}
-
-bool np_seen_name(struct name_list *list, const char *name) {
-        const struct name_list *s;
-        for (s = list; s; s = s->next) {
-                if (!strcmp(s->name, name)) {
-                        return true;
-                }
-        }
-        return false;
-}
-
-bool np_regex_match_mount_entry(struct mount_entry *me, regex_t *re) {
-        if (regexec(re, me->me_devname, (size_t)0, NULL, 0) == 0 || regexec(re, me->me_mountdir, (size_t)0, NULL, 0) == 0) {
-                return true;
-        }
-        return false;
-}
diff --git a/lib/utils_disk.h b/lib/utils_disk.h
deleted file mode 100644
index c5e81dc1..00000000
--- a/lib/utils_disk.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Header file for utils_disk */
-
-#include "mountlist.h"
-#include "utils_base.h"
-#include "regex.h"
-
-struct name_list {
-        char *name;
-        struct name_list *next;
-};
-
-struct regex_list {
-        regex_t regex;
-        struct regex_list *next;
-};
-
-struct parameter_list {
-        char *name;
-        thresholds *freespace_bytes;
-        thresholds *freespace_units;
-        thresholds *freespace_percent;
-        thresholds *usedspace_bytes;
-        thresholds *usedspace_units;
-        thresholds *usedspace_percent;
-        thresholds *usedinodes_percent;
-        thresholds *freeinodes_percent;
-        char *group;
-        struct mount_entry *best_match;
-        struct parameter_list *name_next;
-        struct parameter_list *name_prev;
-        uintmax_t total, available, available_to_root, used, inodes_free, inodes_free_to_root, inodes_used, inodes_total;
-        double dfree_pct, dused_pct;
-        uint64_t dused_units, dfree_units, dtotal_units;
-        double dused_inodes_percent, dfree_inodes_percent;
-};
-
-void np_add_name(struct name_list **list, const char *name);
-bool np_find_name(struct name_list *list, const char *name);
-bool np_seen_name(struct name_list *list, const char *name);
-int np_add_regex(struct regex_list **list, const char *regex, int cflags);
-bool np_find_regmatch(struct regex_list *list, const char *name);
-struct parameter_list *np_add_parameter(struct parameter_list **list, const char *name);
-struct parameter_list *np_find_parameter(struct parameter_list *list, const char *name);
-struct parameter_list *np_del_parameter(struct parameter_list *item, struct parameter_list *prev);
-
-int search_parameter_list(struct parameter_list *list, const char *name);
-void np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list, bool exact);
-bool np_regex_match_mount_entry(struct mount_entry *me, regex_t *re);
diff --git a/lib/utils_tcp.c b/lib/utils_tcp.c
index daae1d54..a82d5a3f 100644
--- a/lib/utils_tcp.c
+++ b/lib/utils_tcp.c
@@ -26,28 +26,35 @@
  *
  *****************************************************************************/
 
-#include "common.h"
+#include "../config.h"
 #include "utils_tcp.h"
+#include <stdio.h>
+#include <string.h>
 
-#define VERBOSE(message)                                                                                                                   \
-        do {                                                                                                                                   \
-                if (flags & NP_MATCH_VERBOSE)                                                                                                      \
-                        puts(message);                                                                                                                 \
+#define VERBOSE(message)                                                                           \
+        do {                                                                                           \
+                if (flags & NP_MATCH_VERBOSE)                                                              \
+                        puts(message);                                                                         \
         } while (0)
 
-enum np_match_result np_expect_match(char *status, char **server_expect, int expect_count, int flags) {
-        int i, match = 0, partial = 0;
-
-        for (i = 0; i < expect_count; i++) {
-                if (flags & NP_MATCH_VERBOSE)
-                        printf("looking for [%s] %s [%s]\n", server_expect[i], (flags & NP_MATCH_EXACT) ? "in beginning of" : "anywhere in", status);
+enum np_match_result np_expect_match(char *status, char **server_expect, int expect_count,
+                                                                         int flags) {
+        int match = 0;
+        int partial = 0;
+        for (int i = 0; i < expect_count; i++) {
+                if (flags & NP_MATCH_VERBOSE) {
+                        printf("looking for [%s] %s [%s]\n", server_expect[i],
+                                   (flags & NP_MATCH_EXACT) ? "in beginning of" : "anywhere in", status);
+                }
 
                 if (flags & NP_MATCH_EXACT) {
                         if (strncmp(status, server_expect[i], strlen(server_expect[i])) == 0) {
                                 VERBOSE("found it");
                                 match++;
                                 continue;
-                        } else if (strncmp(status, server_expect[i], strlen(status)) == 0) {
+                        }
+
+                        if (strncmp(status, server_expect[i], strlen(status)) == 0) {
                                 VERBOSE("found a substring");
                                 partial++;
                                 continue;
@@ -60,10 +67,12 @@ enum np_match_result np_expect_match(char *status, char **server_expect, int exp
                 VERBOSE("couldn't find it");
         }
 
-        if ((flags & NP_MATCH_ALL && match == expect_count) || (!(flags & NP_MATCH_ALL) && match >= 1))
+        if ((flags & NP_MATCH_ALL && match == expect_count) ||
+                (!(flags & NP_MATCH_ALL) && match >= 1)) {
                 return NP_MATCH_SUCCESS;
-        else if (partial > 0 || !(flags & NP_MATCH_EXACT))
+        }
+        if (partial > 0 || !(flags & NP_MATCH_EXACT)) {
                 return NP_MATCH_RETRY;
-        else
-                return NP_MATCH_FAILURE;
+        }
+        return NP_MATCH_FAILURE;
 }
diff --git a/lib/utils_tcp.h b/lib/utils_tcp.h
index d5999e9b..e5cdbb82 100644
--- a/lib/utils_tcp.h
+++ b/lib/utils_tcp.h
@@ -11,9 +11,11 @@
  * server.
  */
 enum np_match_result {
+        NP_MATCH_NONE,
         NP_MATCH_FAILURE,
         NP_MATCH_SUCCESS,
         NP_MATCH_RETRY
 };
 
-enum np_match_result np_expect_match(char *status, char **server_expect, int server_expect_count, int flags);
+enum np_match_result np_expect_match(char *status, char **server_expect, int server_expect_count,
+                                                                         int flags);
diff --git a/lib/vendor/cJSON/cJSON.c b/lib/vendor/cJSON/cJSON.c
new file mode 100644
index 00000000..12076e92
--- /dev/null
+++ b/lib/vendor/cJSON/cJSON.c
@@ -0,0 +1,3165 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+/* cJSON */
+/* JSON parser in C. */
+
+/* disable warnings about old C89 functions in MSVC */
+#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#ifdef __GNUC__
+#pragma GCC visibility push(default)
+#endif
+#if defined(_MSC_VER)
+#pragma warning (push)
+/* disable warning about single line comments in system headers */
+#pragma warning (disable : 4001)
+#endif
+
+#include "../../../config.h"
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <ctype.h>
+#include <float.h>
+
+#ifdef ENABLE_LOCALES
+#include <locale.h>
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning (pop)
+#endif
+#ifdef __GNUC__
+#pragma GCC visibility pop
+#endif
+
+#include "cJSON.h"
+
+/* define our own boolean type */
+#ifdef true
+#undef true
+#endif
+#define true ((cJSON_bool)1)
+
+#ifdef false
+#undef false
+#endif
+#define false ((cJSON_bool)0)
+
+/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */
+#ifndef isinf
+#define isinf(d) (isnan((d - d)) && !isnan(d))
+#endif
+#ifndef isnan
+#define isnan(d) (d != d)
+#endif
+
+#ifndef NAN
+#ifdef _WIN32
+#define NAN sqrt(-1.0)
+#else
+#define NAN 0.0/0.0
+#endif
+#endif
+
+typedef struct {
+    const unsigned char *json;
+    size_t position;
+} error;
+static error global_error = { NULL, 0 };
+
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)
+{
+    return (const char*) (global_error.json + global_error.position);
+}
+
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item)
+{
+    if (!cJSON_IsString(item))
+    {
+        return NULL;
+    }
+
+    return item->valuestring;
+}
+
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item)
+{
+    if (!cJSON_IsNumber(item))
+    {
+        return (double) NAN;
+    }
+
+    return item->valuedouble;
+}
+
+/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */
+#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 18)
+    #error cJSON.h and cJSON.c have different versions. Make sure that both have the same.
+#endif
+
+CJSON_PUBLIC(const char*) cJSON_Version(void)
+{
+    static char version[15];
+    sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);
+
+    return version;
+}
+
+/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */
+static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)
+{
+    if ((string1 == NULL) || (string2 == NULL))
+    {
+        return 1;
+    }
+
+    if (string1 == string2)
+    {
+        return 0;
+    }
+
+    for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)
+    {
+        if (*string1 == '\0')
+        {
+            return 0;
+        }
+    }
+
+    return tolower(*string1) - tolower(*string2);
+}
+
+typedef struct internal_hooks
+{
+    void *(CJSON_CDECL *allocate)(size_t size);
+    void (CJSON_CDECL *deallocate)(void *pointer);
+    void *(CJSON_CDECL *reallocate)(void *pointer, size_t size);
+} internal_hooks;
+
+#if defined(_MSC_VER)
+/* work around MSVC error C2322: '...' address of dllimport '...' is not static */
+static void * CJSON_CDECL internal_malloc(size_t size)
+{
+    return malloc(size);
+}
+static void CJSON_CDECL internal_free(void *pointer)
+{
+    free(pointer);
+}
+static void * CJSON_CDECL internal_realloc(void *pointer, size_t size)
+{
+    return realloc(pointer, size);
+}
+#else
+#define internal_malloc malloc
+#define internal_free free
+#define internal_realloc realloc
+#endif
+
+/* strlen of character literals resolved at compile time */
+#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
+
+static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };
+
+static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
+{
+    size_t length = 0;
+    unsigned char *copy = NULL;
+
+    if (string == NULL)
+    {
+        return NULL;
+    }
+
+    length = strlen((const char*)string) + sizeof("");
+    copy = (unsigned char*)hooks->allocate(length);
+    if (copy == NULL)
+    {
+        return NULL;
+    }
+    memcpy(copy, string, length);
+
+    return copy;
+}
+
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
+{
+    if (hooks == NULL)
+    {
+        /* Reset hooks */
+        global_hooks.allocate = malloc;
+        global_hooks.deallocate = free;
+        global_hooks.reallocate = realloc;
+        return;
+    }
+
+    global_hooks.allocate = malloc;
+    if (hooks->malloc_fn != NULL)
+    {
+        global_hooks.allocate = hooks->malloc_fn;
+    }
+
+    global_hooks.deallocate = free;
+    if (hooks->free_fn != NULL)
+    {
+        global_hooks.deallocate = hooks->free_fn;
+    }
+
+    /* use realloc only if both free and malloc are used */
+    global_hooks.reallocate = NULL;
+    if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))
+    {
+        global_hooks.reallocate = realloc;
+    }
+}
+
+/* Internal constructor. */
+static cJSON *cJSON_New_Item(const internal_hooks * const hooks)
+{
+    cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));
+    if (node)
+    {
+        memset(node, '\0', sizeof(cJSON));
+    }
+
+    return node;
+}
+
+/* Delete a cJSON structure. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
+{
+    cJSON *next = NULL;
+    while (item != NULL)
+    {
+        next = item->next;
+        if (!(item->type & cJSON_IsReference) && (item->child != NULL))
+        {
+            cJSON_Delete(item->child);
+        }
+        if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
+        {
+            global_hooks.deallocate(item->valuestring);
+            item->valuestring = NULL;
+        }
+        if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
+        {
+            global_hooks.deallocate(item->string);
+            item->string = NULL;
+        }
+        global_hooks.deallocate(item);
+        item = next;
+    }
+}
+
+/* get the decimal point character of the current locale */
+static unsigned char get_decimal_point(void)
+{
+#ifdef ENABLE_LOCALES
+    struct lconv *lconv = localeconv();
+    return (unsigned char) lconv->decimal_point[0];
+#else
+    return '.';
+#endif
+}
+
+typedef struct
+{
+    const unsigned char *content;
+    size_t length;
+    size_t offset;
+    size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */
+    internal_hooks hooks;
+} parse_buffer;
+
+/* check if the given size is left to read in a given parse buffer (starting with 1) */
+#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
+/* check if the buffer can be accessed at the given index (starting with 0) */
+#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
+#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
+/* get a pointer to the buffer at the position */
+#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
+
+/* Parse the input text to generate a number, and populate the result into item. */
+static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)
+{
+    double number = 0;
+    unsigned char *after_end = NULL;
+    unsigned char number_c_string[64];
+    unsigned char decimal_point = get_decimal_point();
+    size_t i = 0;
+
+    if ((input_buffer == NULL) || (input_buffer->content == NULL))
+    {
+        return false;
+    }
+
+    /* copy the number into a temporary buffer and replace '.' with the decimal point
+     * of the current locale (for strtod)
+     * This also takes care of '\0' not necessarily being available for marking the end of the input */
+    for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++)
+    {
+        switch (buffer_at_offset(input_buffer)[i])
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            case '+':
+            case '-':
+            case 'e':
+            case 'E':
+                number_c_string[i] = buffer_at_offset(input_buffer)[i];
+                break;
+
+            case '.':
+                number_c_string[i] = decimal_point;
+                break;
+
+            default:
+                goto loop_end;
+        }
+    }
+loop_end:
+    number_c_string[i] = '\0';
+
+    number = strtod((const char*)number_c_string, (char**)&after_end);
+    if (number_c_string == after_end)
+    {
+        return false; /* parse_error */
+    }
+
+    item->valuedouble = number;
+
+    /* use saturation in case of overflow */
+    if (number >= INT_MAX)
+    {
+        item->valueint = INT_MAX;
+    }
+    else if (number <= (double)INT_MIN)
+    {
+        item->valueint = INT_MIN;
+    }
+    else
+    {
+        item->valueint = (int)number;
+    }
+
+    item->type = cJSON_Number;
+
+    input_buffer->offset += (size_t)(after_end - number_c_string);
+    return true;
+}
+
+/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)
+{
+    if (number >= INT_MAX)
+    {
+        object->valueint = INT_MAX;
+    }
+    else if (number <= (double)INT_MIN)
+    {
+        object->valueint = INT_MIN;
+    }
+    else
+    {
+        object->valueint = (int)number;
+    }
+
+    return object->valuedouble = number;
+}
+
+/* Note: when passing a NULL valuestring, cJSON_SetValuestring treats this as an error and return NULL */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)
+{
+    char *copy = NULL;
+    size_t v1_len;
+    size_t v2_len;
+    /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */
+    if ((object == NULL) || !(object->type & cJSON_String) || (object->type & cJSON_IsReference))
+    {
+        return NULL;
+    }
+    /* return NULL if the object is corrupted or valuestring is NULL */
+    if (object->valuestring == NULL || valuestring == NULL)
+    {
+        return NULL;
+    }
+
+    v1_len = strlen(valuestring);
+    v2_len = strlen(object->valuestring);
+
+    if (v1_len <= v2_len)
+    {
+        /* strcpy does not handle overlapping string: [X1, X2] [Y1, Y2] => X2 < Y1 or Y2 < X1 */
+        if (!( valuestring + v1_len < object->valuestring || object->valuestring + v2_len < valuestring ))
+        {
+            return NULL;
+        }
+        strcpy(object->valuestring, valuestring);
+        return object->valuestring;
+    }
+    copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks);
+    if (copy == NULL)
+    {
+        return NULL;
+    }
+    if (object->valuestring != NULL)
+    {
+        cJSON_free(object->valuestring);
+    }
+    object->valuestring = copy;
+
+    return copy;
+}
+
+typedef struct
+{
+    unsigned char *buffer;
+    size_t length;
+    size_t offset;
+    size_t depth; /* current nesting depth (for formatted printing) */
+    cJSON_bool noalloc;
+    cJSON_bool format; /* is this print a formatted print */
+    internal_hooks hooks;
+} printbuffer;
+
+/* realloc printbuffer if necessary to have at least "needed" bytes more */
+static unsigned char* ensure(printbuffer * const p, size_t needed)
+{
+    unsigned char *newbuffer = NULL;
+    size_t newsize = 0;
+
+    if ((p == NULL) || (p->buffer == NULL))
+    {
+        return NULL;
+    }
+
+    if ((p->length > 0) && (p->offset >= p->length))
+    {
+        /* make sure that offset is valid */
+        return NULL;
+    }
+
+    if (needed > INT_MAX)
+    {
+        /* sizes bigger than INT_MAX are currently not supported */
+        return NULL;
+    }
+
+    needed += p->offset + 1;
+    if (needed <= p->length)
+    {
+        return p->buffer + p->offset;
+    }
+
+    if (p->noalloc) {
+        return NULL;
+    }
+
+    /* calculate new buffer size */
+    if (needed > (INT_MAX / 2))
+    {
+        /* overflow of int, use INT_MAX if possible */
+        if (needed <= INT_MAX)
+        {
+            newsize = INT_MAX;
+        }
+        else
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        newsize = needed * 2;
+    }
+
+    if (p->hooks.reallocate != NULL)
+    {
+        /* reallocate with realloc if available */
+        newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize);
+        if (newbuffer == NULL)
+        {
+            p->hooks.deallocate(p->buffer);
+            p->length = 0;
+            p->buffer = NULL;
+
+            return NULL;
+        }
+    }
+    else
+    {
+        /* otherwise reallocate manually */
+        newbuffer = (unsigned char*)p->hooks.allocate(newsize);
+        if (!newbuffer)
+        {
+            p->hooks.deallocate(p->buffer);
+            p->length = 0;
+            p->buffer = NULL;
+
+            return NULL;
+        }
+
+        memcpy(newbuffer, p->buffer, p->offset + 1);
+        p->hooks.deallocate(p->buffer);
+    }
+    p->length = newsize;
+    p->buffer = newbuffer;
+
+    return newbuffer + p->offset;
+}
+
+/* calculate the new length of the string in a printbuffer and update the offset */
+static void update_offset(printbuffer * const buffer)
+{
+    const unsigned char *buffer_pointer = NULL;
+    if ((buffer == NULL) || (buffer->buffer == NULL))
+    {
+        return;
+    }
+    buffer_pointer = buffer->buffer + buffer->offset;
+
+    buffer->offset += strlen((const char*)buffer_pointer);
+}
+
+/* securely comparison of floating-point variables */
+static cJSON_bool compare_double(double a, double b)
+{
+    double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b);
+    return (fabs(a - b) <= maxVal * DBL_EPSILON);
+}
+
+/* Render the number nicely from the given item into a string. */
+static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    double d = item->valuedouble;
+    int length = 0;
+    size_t i = 0;
+    unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */
+    unsigned char decimal_point = get_decimal_point();
+    double test = 0.0;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* This checks for NaN and Infinity */
+    if (isnan(d) || isinf(d))
+    {
+        length = sprintf((char*)number_buffer, "null");
+    }
+    else if(d == (double)item->valueint)
+    {
+        length = sprintf((char*)number_buffer, "%d", item->valueint);
+    }
+    else
+    {
+        /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */
+        length = sprintf((char*)number_buffer, "%1.15g", d);
+
+        /* Check whether the original double can be recovered */
+        if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d))
+        {
+            /* If not, print with 17 decimal places of precision */
+            length = sprintf((char*)number_buffer, "%1.17g", d);
+        }
+    }
+
+    /* sprintf failed or buffer overrun occurred */
+    if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1)))
+    {
+        return false;
+    }
+
+    /* reserve appropriate space in the output */
+    output_pointer = ensure(output_buffer, (size_t)length + sizeof(""));
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    /* copy the printed number to the output and replace locale
+     * dependent decimal point with '.' */
+    for (i = 0; i < ((size_t)length); i++)
+    {
+        if (number_buffer[i] == decimal_point)
+        {
+            output_pointer[i] = '.';
+            continue;
+        }
+
+        output_pointer[i] = number_buffer[i];
+    }
+    output_pointer[i] = '\0';
+
+    output_buffer->offset += (size_t)length;
+
+    return true;
+}
+
+/* parse 4 digit hexadecimal number */
+static unsigned parse_hex4(const unsigned char * const input)
+{
+    unsigned int h = 0;
+    size_t i = 0;
+
+    for (i = 0; i < 4; i++)
+    {
+        /* parse digit */
+        if ((input[i] >= '0') && (input[i] <= '9'))
+        {
+            h += (unsigned int) input[i] - '0';
+        }
+        else if ((input[i] >= 'A') && (input[i] <= 'F'))
+        {
+            h += (unsigned int) 10 + input[i] - 'A';
+        }
+        else if ((input[i] >= 'a') && (input[i] <= 'f'))
+        {
+            h += (unsigned int) 10 + input[i] - 'a';
+        }
+        else /* invalid */
+        {
+            return 0;
+        }
+
+        if (i < 3)
+        {
+            /* shift left to make place for the next nibble */
+            h = h << 4;
+        }
+    }
+
+    return h;
+}
+
+/* converts a UTF-16 literal to UTF-8
+ * A literal can be one or two sequences of the form \uXXXX */
+static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)
+{
+    long unsigned int codepoint = 0;
+    unsigned int first_code = 0;
+    const unsigned char *first_sequence = input_pointer;
+    unsigned char utf8_length = 0;
+    unsigned char utf8_position = 0;
+    unsigned char sequence_length = 0;
+    unsigned char first_byte_mark = 0;
+
+    if ((input_end - first_sequence) < 6)
+    {
+        /* input ends unexpectedly */
+        goto fail;
+    }
+
+    /* get the first utf16 sequence */
+    first_code = parse_hex4(first_sequence + 2);
+
+    /* check that the code is valid */
+    if (((first_code >= 0xDC00) && (first_code <= 0xDFFF)))
+    {
+        goto fail;
+    }
+
+    /* UTF16 surrogate pair */
+    if ((first_code >= 0xD800) && (first_code <= 0xDBFF))
+    {
+        const unsigned char *second_sequence = first_sequence + 6;
+        unsigned int second_code = 0;
+        sequence_length = 12; /* \uXXXX\uXXXX */
+
+        if ((input_end - second_sequence) < 6)
+        {
+            /* input ends unexpectedly */
+            goto fail;
+        }
+
+        if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))
+        {
+            /* missing second half of the surrogate pair */
+            goto fail;
+        }
+
+        /* get the second utf16 sequence */
+        second_code = parse_hex4(second_sequence + 2);
+        /* check that the code is valid */
+        if ((second_code < 0xDC00) || (second_code > 0xDFFF))
+        {
+            /* invalid second half of the surrogate pair */
+            goto fail;
+        }
+
+
+        /* calculate the unicode codepoint from the surrogate pair */
+        codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
+    }
+    else
+    {
+        sequence_length = 6; /* \uXXXX */
+        codepoint = first_code;
+    }
+
+    /* encode as UTF-8
+     * takes at maximum 4 bytes to encode:
+     * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+    if (codepoint < 0x80)
+    {
+        /* normal ascii, encoding 0xxxxxxx */
+        utf8_length = 1;
+    }
+    else if (codepoint < 0x800)
+    {
+        /* two bytes, encoding 110xxxxx 10xxxxxx */
+        utf8_length = 2;
+        first_byte_mark = 0xC0; /* 11000000 */
+    }
+    else if (codepoint < 0x10000)
+    {
+        /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */
+        utf8_length = 3;
+        first_byte_mark = 0xE0; /* 11100000 */
+    }
+    else if (codepoint <= 0x10FFFF)
+    {
+        /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+        utf8_length = 4;
+        first_byte_mark = 0xF0; /* 11110000 */
+    }
+    else
+    {
+        /* invalid unicode codepoint */
+        goto fail;
+    }
+
+    /* encode as utf8 */
+    for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--)
+    {
+        /* 10xxxxxx */
+        (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);
+        codepoint >>= 6;
+    }
+    /* encode first byte */
+    if (utf8_length > 1)
+    {
+        (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);
+    }
+    else
+    {
+        (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);
+    }
+
+    *output_pointer += utf8_length;
+
+    return sequence_length;
+
+fail:
+    return 0;
+}
+
+/* Parse the input text into an unescaped cinput, and populate item. */
+static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)
+{
+    const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1;
+    const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;
+    unsigned char *output_pointer = NULL;
+    unsigned char *output = NULL;
+
+    /* not a string */
+    if (buffer_at_offset(input_buffer)[0] != '\"')
+    {
+        goto fail;
+    }
+
+    {
+        /* calculate approximate size of the output (overestimate) */
+        size_t allocation_length = 0;
+        size_t skipped_bytes = 0;
+        while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))
+        {
+            /* is escape sequence */
+            if (input_end[0] == '\\')
+            {
+                if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length)
+                {
+                    /* prevent buffer overflow when last input character is a backslash */
+                    goto fail;
+                }
+                skipped_bytes++;
+                input_end++;
+            }
+            input_end++;
+        }
+        if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"'))
+        {
+            goto fail; /* string ended unexpectedly */
+        }
+
+        /* This is at most how much we need for the output */
+        allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
+        output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));
+        if (output == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+    }
+
+    output_pointer = output;
+    /* loop through the string literal */
+    while (input_pointer < input_end)
+    {
+        if (*input_pointer != '\\')
+        {
+            *output_pointer++ = *input_pointer++;
+        }
+        /* escape sequence */
+        else
+        {
+            unsigned char sequence_length = 2;
+            if ((input_end - input_pointer) < 1)
+            {
+                goto fail;
+            }
+
+            switch (input_pointer[1])
+            {
+                case 'b':
+                    *output_pointer++ = '\b';
+                    break;
+                case 'f':
+                    *output_pointer++ = '\f';
+                    break;
+                case 'n':
+                    *output_pointer++ = '\n';
+                    break;
+                case 'r':
+                    *output_pointer++ = '\r';
+                    break;
+                case 't':
+                    *output_pointer++ = '\t';
+                    break;
+                case '\"':
+                case '\\':
+                case '/':
+                    *output_pointer++ = input_pointer[1];
+                    break;
+
+                /* UTF-16 literal */
+                case 'u':
+                    sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
+                    if (sequence_length == 0)
+                    {
+                        /* failed to convert UTF16-literal to UTF-8 */
+                        goto fail;
+                    }
+                    break;
+
+                default:
+                    goto fail;
+            }
+            input_pointer += sequence_length;
+        }
+    }
+
+    /* zero terminate the output */
+    *output_pointer = '\0';
+
+    item->type = cJSON_String;
+    item->valuestring = (char*)output;
+
+    input_buffer->offset = (size_t) (input_end - input_buffer->content);
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (output != NULL)
+    {
+        input_buffer->hooks.deallocate(output);
+        output = NULL;
+    }
+
+    if (input_pointer != NULL)
+    {
+        input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
+    }
+
+    return false;
+}
+
+/* Render the cstring provided to an escaped version that can be printed. */
+static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)
+{
+    const unsigned char *input_pointer = NULL;
+    unsigned char *output = NULL;
+    unsigned char *output_pointer = NULL;
+    size_t output_length = 0;
+    /* numbers of additional characters needed for escaping */
+    size_t escape_characters = 0;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* empty string */
+    if (input == NULL)
+    {
+        output = ensure(output_buffer, sizeof("\"\""));
+        if (output == NULL)
+        {
+            return false;
+        }
+        strcpy((char*)output, "\"\"");
+
+        return true;
+    }
+
+    /* set "flag" to 1 if something needs to be escaped */
+    for (input_pointer = input; *input_pointer; input_pointer++)
+    {
+        switch (*input_pointer)
+        {
+            case '\"':
+            case '\\':
+            case '\b':
+            case '\f':
+            case '\n':
+            case '\r':
+            case '\t':
+                /* one character escape sequence */
+                escape_characters++;
+                break;
+            default:
+                if (*input_pointer < 32)
+                {
+                    /* UTF-16 escape sequence uXXXX */
+                    escape_characters += 5;
+                }
+                break;
+        }
+    }
+    output_length = (size_t)(input_pointer - input) + escape_characters;
+
+    output = ensure(output_buffer, output_length + sizeof("\"\""));
+    if (output == NULL)
+    {
+        return false;
+    }
+
+    /* no characters have to be escaped */
+    if (escape_characters == 0)
+    {
+        output[0] = '\"';
+        memcpy(output + 1, input, output_length);
+        output[output_length + 1] = '\"';
+        output[output_length + 2] = '\0';
+
+        return true;
+    }
+
+    output[0] = '\"';
+    output_pointer = output + 1;
+    /* copy the string */
+    for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
+    {
+        if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
+        {
+            /* normal character, copy */
+            *output_pointer = *input_pointer;
+        }
+        else
+        {
+            /* character needs to be escaped */
+            *output_pointer++ = '\\';
+            switch (*input_pointer)
+            {
+                case '\\':
+                    *output_pointer = '\\';
+                    break;
+                case '\"':
+                    *output_pointer = '\"';
+                    break;
+                case '\b':
+                    *output_pointer = 'b';
+                    break;
+                case '\f':
+                    *output_pointer = 'f';
+                    break;
+                case '\n':
+                    *output_pointer = 'n';
+                    break;
+                case '\r':
+                    *output_pointer = 'r';
+                    break;
+                case '\t':
+                    *output_pointer = 't';
+                    break;
+                default:
+                    /* escape and print as unicode codepoint */
+                    sprintf((char*)output_pointer, "u%04x", *input_pointer);
+                    output_pointer += 4;
+                    break;
+            }
+        }
+    }
+    output[output_length + 1] = '\"';
+    output[output_length + 2] = '\0';
+
+    return true;
+}
+
+/* Invoke print_string_ptr (which is useful) on an item. */
+static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)
+{
+    return print_string_ptr((unsigned char*)item->valuestring, p);
+}
+
+/* Predeclare these prototypes. */
+static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer);
+static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer);
+static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer);
+
+/* Utility to jump whitespace and cr/lf */
+static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
+{
+    if ((buffer == NULL) || (buffer->content == NULL))
+    {
+        return NULL;
+    }
+
+    if (cannot_access_at_index(buffer, 0))
+    {
+        return buffer;
+    }
+
+    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
+    {
+       buffer->offset++;
+    }
+
+    if (buffer->offset == buffer->length)
+    {
+        buffer->offset--;
+    }
+
+    return buffer;
+}
+
+/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */
+static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
+{
+    if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
+    {
+        return NULL;
+    }
+
+    if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
+    {
+        buffer->offset += 3;
+    }
+
+    return buffer;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
+{
+    size_t buffer_length;
+
+    if (NULL == value)
+    {
+        return NULL;
+    }
+
+    /* Adding null character size due to require_null_terminated. */
+    buffer_length = strlen(value) + sizeof("");
+
+    return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
+}
+
+/* Parse an object - create a new root, and populate. */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated)
+{
+    parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
+    cJSON *item = NULL;
+
+    /* reset error position */
+    global_error.json = NULL;
+    global_error.position = 0;
+
+    if (value == NULL || 0 == buffer_length)
+    {
+        goto fail;
+    }
+
+    buffer.content = (const unsigned char*)value;
+    buffer.length = buffer_length;
+    buffer.offset = 0;
+    buffer.hooks = global_hooks;
+
+    item = cJSON_New_Item(&global_hooks);
+    if (item == NULL) /* memory fail */
+    {
+        goto fail;
+    }
+
+    if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer))))
+    {
+        /* parse failure. ep is set. */
+        goto fail;
+    }
+
+    /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
+    if (require_null_terminated)
+    {
+        buffer_skip_whitespace(&buffer);
+        if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0')
+        {
+            goto fail;
+        }
+    }
+    if (return_parse_end)
+    {
+        *return_parse_end = (const char*)buffer_at_offset(&buffer);
+    }
+
+    return item;
+
+fail:
+    if (item != NULL)
+    {
+        cJSON_Delete(item);
+    }
+
+    if (value != NULL)
+    {
+        error local_error;
+        local_error.json = (const unsigned char*)value;
+        local_error.position = 0;
+
+        if (buffer.offset < buffer.length)
+        {
+            local_error.position = buffer.offset;
+        }
+        else if (buffer.length > 0)
+        {
+            local_error.position = buffer.length - 1;
+        }
+
+        if (return_parse_end != NULL)
+        {
+            *return_parse_end = (const char*)local_error.json + local_error.position;
+        }
+
+        global_error = local_error;
+    }
+
+    return NULL;
+}
+
+/* Default options for cJSON_Parse */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)
+{
+    return cJSON_ParseWithOpts(value, 0, 0);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length)
+{
+    return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0);
+}
+
+#define cjson_min(a, b) (((a) < (b)) ? (a) : (b))
+
+static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
+{
+    static const size_t default_buffer_size = 256;
+    printbuffer buffer[1];
+    unsigned char *printed = NULL;
+
+    memset(buffer, 0, sizeof(buffer));
+
+    /* create buffer */
+    buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
+    buffer->length = default_buffer_size;
+    buffer->format = format;
+    buffer->hooks = *hooks;
+    if (buffer->buffer == NULL)
+    {
+        goto fail;
+    }
+
+    /* print the value */
+    if (!print_value(item, buffer))
+    {
+        goto fail;
+    }
+    update_offset(buffer);
+
+    /* check if reallocate is available */
+    if (hooks->reallocate != NULL)
+    {
+        printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
+        if (printed == NULL) {
+            goto fail;
+        }
+        buffer->buffer = NULL;
+    }
+    else /* otherwise copy the JSON over to a new buffer */
+    {
+        printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
+        if (printed == NULL)
+        {
+            goto fail;
+        }
+        memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
+        printed[buffer->offset] = '\0'; /* just to be sure */
+
+        /* free the buffer */
+        hooks->deallocate(buffer->buffer);
+        buffer->buffer = NULL;
+    }
+
+    return printed;
+
+fail:
+    if (buffer->buffer != NULL)
+    {
+        hooks->deallocate(buffer->buffer);
+        buffer->buffer = NULL;
+    }
+
+    if (printed != NULL)
+    {
+        hooks->deallocate(printed);
+        printed = NULL;
+    }
+
+    return NULL;
+}
+
+/* Render a cJSON item/entity/structure to text. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item)
+{
+    return (char*)print(item, true, &global_hooks);
+}
+
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item)
+{
+    return (char*)print(item, false, &global_hooks);
+}
+
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
+{
+    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
+
+    if (prebuffer < 0)
+    {
+        return NULL;
+    }
+
+    p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
+    if (!p.buffer)
+    {
+        return NULL;
+    }
+
+    p.length = (size_t)prebuffer;
+    p.offset = 0;
+    p.noalloc = false;
+    p.format = fmt;
+    p.hooks = global_hooks;
+
+    if (!print_value(item, &p))
+    {
+        global_hooks.deallocate(p.buffer);
+        p.buffer = NULL;
+        return NULL;
+    }
+
+    return (char*)p.buffer;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)
+{
+    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
+
+    if ((length < 0) || (buffer == NULL))
+    {
+        return false;
+    }
+
+    p.buffer = (unsigned char*)buffer;
+    p.length = (size_t)length;
+    p.offset = 0;
+    p.noalloc = true;
+    p.format = format;
+    p.hooks = global_hooks;
+
+    return print_value(item, &p);
+}
+
+/* Parser core - when encountering text, process appropriately. */
+static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)
+{
+    if ((input_buffer == NULL) || (input_buffer->content == NULL))
+    {
+        return false; /* no input */
+    }
+
+    /* parse the different types of values */
+    /* null */
+    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
+    {
+        item->type = cJSON_NULL;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* false */
+    if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0))
+    {
+        item->type = cJSON_False;
+        input_buffer->offset += 5;
+        return true;
+    }
+    /* true */
+    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0))
+    {
+        item->type = cJSON_True;
+        item->valueint = 1;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* string */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"'))
+    {
+        return parse_string(item, input_buffer);
+    }
+    /* number */
+    if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
+    {
+        return parse_number(item, input_buffer);
+    }
+    /* array */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '['))
+    {
+        return parse_array(item, input_buffer);
+    }
+    /* object */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{'))
+    {
+        return parse_object(item, input_buffer);
+    }
+
+    return false;
+}
+
+/* Render a value to text. */
+static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output = NULL;
+
+    if ((item == NULL) || (output_buffer == NULL))
+    {
+        return false;
+    }
+
+    switch ((item->type) & 0xFF)
+    {
+        case cJSON_NULL:
+            output = ensure(output_buffer, 5);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "null");
+            return true;
+
+        case cJSON_False:
+            output = ensure(output_buffer, 6);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "false");
+            return true;
+
+        case cJSON_True:
+            output = ensure(output_buffer, 5);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "true");
+            return true;
+
+        case cJSON_Number:
+            return print_number(item, output_buffer);
+
+        case cJSON_Raw:
+        {
+            size_t raw_length = 0;
+            if (item->valuestring == NULL)
+            {
+                return false;
+            }
+
+            raw_length = strlen(item->valuestring) + sizeof("");
+            output = ensure(output_buffer, raw_length);
+            if (output == NULL)
+            {
+                return false;
+            }
+            memcpy(output, item->valuestring, raw_length);
+            return true;
+        }
+
+        case cJSON_String:
+            return print_string(item, output_buffer);
+
+        case cJSON_Array:
+            return print_array(item, output_buffer);
+
+        case cJSON_Object:
+            return print_object(item, output_buffer);
+
+        default:
+            return false;
+    }
+}
+
+/* Build an array from input text. */
+static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)
+{
+    cJSON *head = NULL; /* head of the linked list */
+    cJSON *current_item = NULL;
+
+    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
+    {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if (buffer_at_offset(input_buffer)[0] != '[')
+    {
+        /* not an array */
+        goto fail;
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']'))
+    {
+        /* empty array */
+        goto success;
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if (cannot_access_at_index(input_buffer, 0))
+    {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do
+    {
+        /* allocate next item */
+        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
+        if (new_item == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if (head == NULL)
+        {
+            /* start the linked list */
+            current_item = head = new_item;
+        }
+        else
+        {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev = current_item;
+            current_item = new_item;
+        }
+
+        /* parse next value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_value(current_item, input_buffer))
+        {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    }
+    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']')
+    {
+        goto fail; /* expected end of array */
+    }
+
+success:
+    input_buffer->depth--;
+
+    if (head != NULL) {
+        head->prev = current_item;
+    }
+
+    item->type = cJSON_Array;
+    item->child = head;
+
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (head != NULL)
+    {
+        cJSON_Delete(head);
+    }
+
+    return false;
+}
+
+/* Render an array to text */
+static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    size_t length = 0;
+    cJSON *current_element = item->child;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* Compose the output array. */
+    /* opening square bracket */
+    output_pointer = ensure(output_buffer, 1);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    *output_pointer = '[';
+    output_buffer->offset++;
+    output_buffer->depth++;
+
+    while (current_element != NULL)
+    {
+        if (!print_value(current_element, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+        if (current_element->next)
+        {
+            length = (size_t) (output_buffer->format ? 2 : 1);
+            output_pointer = ensure(output_buffer, length + 1);
+            if (output_pointer == NULL)
+            {
+                return false;
+            }
+            *output_pointer++ = ',';
+            if(output_buffer->format)
+            {
+                *output_pointer++ = ' ';
+            }
+            *output_pointer = '\0';
+            output_buffer->offset += length;
+        }
+        current_element = current_element->next;
+    }
+
+    output_pointer = ensure(output_buffer, 2);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+    *output_pointer++ = ']';
+    *output_pointer = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Build an object from the text. */
+static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)
+{
+    cJSON *head = NULL; /* linked list head */
+    cJSON *current_item = NULL;
+
+    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
+    {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{'))
+    {
+        goto fail; /* not an object */
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}'))
+    {
+        goto success; /* empty object */
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if (cannot_access_at_index(input_buffer, 0))
+    {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do
+    {
+        /* allocate next item */
+        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
+        if (new_item == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if (head == NULL)
+        {
+            /* start the linked list */
+            current_item = head = new_item;
+        }
+        else
+        {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev = current_item;
+            current_item = new_item;
+        }
+
+        if (cannot_access_at_index(input_buffer, 1))
+        {
+            goto fail; /* nothing comes after the comma */
+        }
+
+        /* parse the name of the child */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_string(current_item, input_buffer))
+        {
+            goto fail; /* failed to parse name */
+        }
+        buffer_skip_whitespace(input_buffer);
+
+        /* swap valuestring and string, because we parsed the name */
+        current_item->string = current_item->valuestring;
+        current_item->valuestring = NULL;
+
+        if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':'))
+        {
+            goto fail; /* invalid object */
+        }
+
+        /* parse the value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_value(current_item, input_buffer))
+        {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    }
+    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}'))
+    {
+        goto fail; /* expected end of object */
+    }
+
+success:
+    input_buffer->depth--;
+
+    if (head != NULL) {
+        head->prev = current_item;
+    }
+
+    item->type = cJSON_Object;
+    item->child = head;
+
+    input_buffer->offset++;
+    return true;
+
+fail:
+    if (head != NULL)
+    {
+        cJSON_Delete(head);
+    }
+
+    return false;
+}
+
+/* Render an object to text. */
+static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    size_t length = 0;
+    cJSON *current_item = item->child;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* Compose the output: */
+    length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */
+    output_pointer = ensure(output_buffer, length + 1);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    *output_pointer++ = '{';
+    output_buffer->depth++;
+    if (output_buffer->format)
+    {
+        *output_pointer++ = '\n';
+    }
+    output_buffer->offset += length;
+
+    while (current_item)
+    {
+        if (output_buffer->format)
+        {
+            size_t i;
+            output_pointer = ensure(output_buffer, output_buffer->depth);
+            if (output_pointer == NULL)
+            {
+                return false;
+            }
+            for (i = 0; i < output_buffer->depth; i++)
+            {
+                *output_pointer++ = '\t';
+            }
+            output_buffer->offset += output_buffer->depth;
+        }
+
+        /* print key */
+        if (!print_string_ptr((unsigned char*)current_item->string, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+
+        length = (size_t) (output_buffer->format ? 2 : 1);
+        output_pointer = ensure(output_buffer, length);
+        if (output_pointer == NULL)
+        {
+            return false;
+        }
+        *output_pointer++ = ':';
+        if (output_buffer->format)
+        {
+            *output_pointer++ = '\t';
+        }
+        output_buffer->offset += length;
+
+        /* print value */
+        if (!print_value(current_item, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+
+        /* print comma if not last */
+        length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0));
+        output_pointer = ensure(output_buffer, length + 1);
+        if (output_pointer == NULL)
+        {
+            return false;
+        }
+        if (current_item->next)
+        {
+            *output_pointer++ = ',';
+        }
+
+        if (output_buffer->format)
+        {
+            *output_pointer++ = '\n';
+        }
+        *output_pointer = '\0';
+        output_buffer->offset += length;
+
+        current_item = current_item->next;
+    }
+
+    output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+    if (output_buffer->format)
+    {
+        size_t i;
+        for (i = 0; i < (output_buffer->depth - 1); i++)
+        {
+            *output_pointer++ = '\t';
+        }
+    }
+    *output_pointer++ = '}';
+    *output_pointer = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Get Array size/item / object item. */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
+{
+    cJSON *child = NULL;
+    size_t size = 0;
+
+    if (array == NULL)
+    {
+        return 0;
+    }
+
+    child = array->child;
+
+    while(child != NULL)
+    {
+        size++;
+        child = child->next;
+    }
+
+    /* FIXME: Can overflow here. Cannot be fixed without breaking the API */
+
+    return (int)size;
+}
+
+static cJSON* get_array_item(const cJSON *array, size_t index)
+{
+    cJSON *current_child = NULL;
+
+    if (array == NULL)
+    {
+        return NULL;
+    }
+
+    current_child = array->child;
+    while ((current_child != NULL) && (index > 0))
+    {
+        index--;
+        current_child = current_child->next;
+    }
+
+    return current_child;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index)
+{
+    if (index < 0)
+    {
+        return NULL;
+    }
+
+    return get_array_item(array, (size_t)index);
+}
+
+static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
+{
+    cJSON *current_element = NULL;
+
+    if ((object == NULL) || (name == NULL))
+    {
+        return NULL;
+    }
+
+    current_element = object->child;
+    if (case_sensitive)
+    {
+        while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0))
+        {
+            current_element = current_element->next;
+        }
+    }
+    else
+    {
+        while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0))
+        {
+            current_element = current_element->next;
+        }
+    }
+
+    if ((current_element == NULL) || (current_element->string == NULL)) {
+        return NULL;
+    }
+
+    return current_element;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string)
+{
+    return get_object_item(object, string, false);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string)
+{
+    return get_object_item(object, string, true);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string)
+{
+    return cJSON_GetObjectItem(object, string) ? 1 : 0;
+}
+
+/* Utility for array list handling. */
+static void suffix_object(cJSON *prev, cJSON *item)
+{
+    prev->next = item;
+    item->prev = prev;
+}
+
+/* Utility for handling references. */
+static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)
+{
+    cJSON *reference = NULL;
+    if (item == NULL)
+    {
+        return NULL;
+    }
+
+    reference = cJSON_New_Item(hooks);
+    if (reference == NULL)
+    {
+        return NULL;
+    }
+
+    memcpy(reference, item, sizeof(cJSON));
+    reference->string = NULL;
+    reference->type |= cJSON_IsReference;
+    reference->next = reference->prev = NULL;
+    return reference;
+}
+
+static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)
+{
+    cJSON *child = NULL;
+
+    if ((item == NULL) || (array == NULL) || (array == item))
+    {
+        return false;
+    }
+
+    child = array->child;
+    /*
+     * To find the last item in array quickly, we use prev in array
+     */
+    if (child == NULL)
+    {
+        /* list is empty, start new one */
+        array->child = item;
+        item->prev = item;
+        item->next = NULL;
+    }
+    else
+    {
+        /* append to the end */
+        if (child->prev)
+        {
+            suffix_object(child->prev, item);
+            array->child->prev = item;
+        }
+    }
+
+    return true;
+}
+
+/* Add item to array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item)
+{
+    return add_item_to_array(array, item);
+}
+
+#if defined(__clang__) || (defined(__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+    #pragma GCC diagnostic push
+#endif
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+/* helper function to cast away const */
+static void* cast_away_const(const void* string)
+{
+    return (void*)string;
+}
+#if defined(__clang__) || (defined(__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+    #pragma GCC diagnostic pop
+#endif
+
+
+static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)
+{
+    char *new_key = NULL;
+    int new_type = cJSON_Invalid;
+
+    if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item))
+    {
+        return false;
+    }
+
+    if (constant_key)
+    {
+        new_key = (char*)cast_away_const(string);
+        new_type = item->type | cJSON_StringIsConst;
+    }
+    else
+    {
+        new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks);
+        if (new_key == NULL)
+        {
+            return false;
+        }
+
+        new_type = item->type & ~cJSON_StringIsConst;
+    }
+
+    if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
+    {
+        hooks->deallocate(item->string);
+    }
+
+    item->string = new_key;
+    item->type = new_type;
+
+    return add_item_to_array(object, item);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
+{
+    return add_item_to_object(object, string, item, &global_hooks, false);
+}
+
+/* Add an item to an object with constant string as key */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)
+{
+    return add_item_to_object(object, string, item, &global_hooks, true);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
+{
+    if (array == NULL)
+    {
+        return false;
+    }
+
+    return add_item_to_array(array, create_reference(item, &global_hooks));
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)
+{
+    if ((object == NULL) || (string == NULL))
+    {
+        return false;
+    }
+
+    return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false);
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name)
+{
+    cJSON *null = cJSON_CreateNull();
+    if (add_item_to_object(object, name, null, &global_hooks, false))
+    {
+        return null;
+    }
+
+    cJSON_Delete(null);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name)
+{
+    cJSON *true_item = cJSON_CreateTrue();
+    if (add_item_to_object(object, name, true_item, &global_hooks, false))
+    {
+        return true_item;
+    }
+
+    cJSON_Delete(true_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)
+{
+    cJSON *false_item = cJSON_CreateFalse();
+    if (add_item_to_object(object, name, false_item, &global_hooks, false))
+    {
+        return false_item;
+    }
+
+    cJSON_Delete(false_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean)
+{
+    cJSON *bool_item = cJSON_CreateBool(boolean);
+    if (add_item_to_object(object, name, bool_item, &global_hooks, false))
+    {
+        return bool_item;
+    }
+
+    cJSON_Delete(bool_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)
+{
+    cJSON *number_item = cJSON_CreateNumber(number);
+    if (add_item_to_object(object, name, number_item, &global_hooks, false))
+    {
+        return number_item;
+    }
+
+    cJSON_Delete(number_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string)
+{
+    cJSON *string_item = cJSON_CreateString(string);
+    if (add_item_to_object(object, name, string_item, &global_hooks, false))
+    {
+        return string_item;
+    }
+
+    cJSON_Delete(string_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw)
+{
+    cJSON *raw_item = cJSON_CreateRaw(raw);
+    if (add_item_to_object(object, name, raw_item, &global_hooks, false))
+    {
+        return raw_item;
+    }
+
+    cJSON_Delete(raw_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name)
+{
+    cJSON *object_item = cJSON_CreateObject();
+    if (add_item_to_object(object, name, object_item, &global_hooks, false))
+    {
+        return object_item;
+    }
+
+    cJSON_Delete(object_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name)
+{
+    cJSON *array = cJSON_CreateArray();
+    if (add_item_to_object(object, name, array, &global_hooks, false))
+    {
+        return array;
+    }
+
+    cJSON_Delete(array);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)
+{
+    if ((parent == NULL) || (item == NULL) || (item != parent->child && item->prev == NULL))
+    {
+        return NULL;
+    }
+
+    if (item != parent->child)
+    {
+        /* not the first element */
+        item->prev->next = item->next;
+    }
+    if (item->next != NULL)
+    {
+        /* not the last element */
+        item->next->prev = item->prev;
+    }
+
+    if (item == parent->child)
+    {
+        /* first element */
+        parent->child = item->next;
+    }
+    else if (item->next == NULL)
+    {
+        /* last element */
+        parent->child->prev = item->prev;
+    }
+
+    /* make sure the detached item doesn't point anywhere anymore */
+    item->prev = NULL;
+    item->next = NULL;
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which)
+{
+    if (which < 0)
+    {
+        return NULL;
+    }
+
+    return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which));
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which)
+{
+    cJSON_Delete(cJSON_DetachItemFromArray(array, which));
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)
+{
+    cJSON *to_detach = cJSON_GetObjectItem(object, string);
+
+    return cJSON_DetachItemViaPointer(object, to_detach);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string)
+{
+    cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string);
+
+    return cJSON_DetachItemViaPointer(object, to_detach);
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string)
+{
+    cJSON_Delete(cJSON_DetachItemFromObject(object, string));
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)
+{
+    cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string));
+}
+
+/* Replace array/object items with new ones. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
+{
+    cJSON *after_inserted = NULL;
+
+    if (which < 0 || newitem == NULL)
+    {
+        return false;
+    }
+
+    after_inserted = get_array_item(array, (size_t)which);
+    if (after_inserted == NULL)
+    {
+        return add_item_to_array(array, newitem);
+    }
+
+    if (after_inserted != array->child && after_inserted->prev == NULL) {
+        /* return false if after_inserted is a corrupted array item */
+        return false;
+    }
+
+    newitem->next = after_inserted;
+    newitem->prev = after_inserted->prev;
+    after_inserted->prev = newitem;
+    if (after_inserted == array->child)
+    {
+        array->child = newitem;
+    }
+    else
+    {
+        newitem->prev->next = newitem;
+    }
+    return true;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)
+{
+    if ((parent == NULL) || (parent->child == NULL) || (replacement == NULL) || (item == NULL))
+    {
+        return false;
+    }
+
+    if (replacement == item)
+    {
+        return true;
+    }
+
+    replacement->next = item->next;
+    replacement->prev = item->prev;
+
+    if (replacement->next != NULL)
+    {
+        replacement->next->prev = replacement;
+    }
+    if (parent->child == item)
+    {
+        if (parent->child->prev == parent->child)
+        {
+            replacement->prev = replacement;
+        }
+        parent->child = replacement;
+    }
+    else
+    {   /*
+         * To find the last item in array quickly, we use prev in array.
+         * We can't modify the last item's next pointer where this item was the parent's child
+         */
+        if (replacement->prev != NULL)
+        {
+            replacement->prev->next = replacement;
+        }
+        if (replacement->next == NULL)
+        {
+            parent->child->prev = replacement;
+        }
+    }
+
+    item->next = NULL;
+    item->prev = NULL;
+    cJSON_Delete(item);
+
+    return true;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)
+{
+    if (which < 0)
+    {
+        return false;
+    }
+
+    return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem);
+}
+
+static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)
+{
+    if ((replacement == NULL) || (string == NULL))
+    {
+        return false;
+    }
+
+    /* replace the name in the replacement */
+    if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL))
+    {
+        cJSON_free(replacement->string);
+    }
+    replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
+    if (replacement->string == NULL)
+    {
+        return false;
+    }
+
+    replacement->type &= ~cJSON_StringIsConst;
+
+    return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)
+{
+    return replace_item_in_object(object, string, newitem, false);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)
+{
+    return replace_item_in_object(object, string, newitem, true);
+}
+
+/* Create basic types: */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_NULL;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_True;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_False;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = boolean ? cJSON_True : cJSON_False;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_Number;
+        item->valuedouble = num;
+
+        /* use saturation in case of overflow */
+        if (num >= INT_MAX)
+        {
+            item->valueint = INT_MAX;
+        }
+        else if (num <= (double)INT_MIN)
+        {
+            item->valueint = INT_MIN;
+        }
+        else
+        {
+            item->valueint = (int)num;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_String;
+        item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
+        if(!item->valuestring)
+        {
+            cJSON_Delete(item);
+            return NULL;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if (item != NULL)
+    {
+        item->type = cJSON_String | cJSON_IsReference;
+        item->valuestring = (char*)cast_away_const(string);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if (item != NULL) {
+        item->type = cJSON_Object | cJSON_IsReference;
+        item->child = (cJSON*)cast_away_const(child);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if (item != NULL) {
+        item->type = cJSON_Array | cJSON_IsReference;
+        item->child = (cJSON*)cast_away_const(child);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_Raw;
+        item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks);
+        if(!item->valuestring)
+        {
+            cJSON_Delete(item);
+            return NULL;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type=cJSON_Array;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if (item)
+    {
+        item->type = cJSON_Object;
+    }
+
+    return item;
+}
+
+/* Create Arrays: */
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber(numbers[i]);
+        if (!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if (a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber((double)numbers[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if (a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber(numbers[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if (a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (strings == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for (i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateString(strings[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p,n);
+        }
+        p = n;
+    }
+
+    if (a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+/* Duplication */
+cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse);
+
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)
+{
+    return cJSON_Duplicate_rec(item, 0, recurse );
+}
+
+cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse)
+{
+    cJSON *newitem = NULL;
+    cJSON *child = NULL;
+    cJSON *next = NULL;
+    cJSON *newchild = NULL;
+
+    /* Bail on bad ptr */
+    if (!item)
+    {
+        goto fail;
+    }
+    /* Create new item */
+    newitem = cJSON_New_Item(&global_hooks);
+    if (!newitem)
+    {
+        goto fail;
+    }
+    /* Copy over all vars */
+    newitem->type = item->type & (~cJSON_IsReference);
+    newitem->valueint = item->valueint;
+    newitem->valuedouble = item->valuedouble;
+    if (item->valuestring)
+    {
+        newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks);
+        if (!newitem->valuestring)
+        {
+            goto fail;
+        }
+    }
+    if (item->string)
+    {
+        newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks);
+        if (!newitem->string)
+        {
+            goto fail;
+        }
+    }
+    /* If non-recursive, then we're done! */
+    if (!recurse)
+    {
+        return newitem;
+    }
+    /* Walk the ->next chain for the child. */
+    child = item->child;
+    while (child != NULL)
+    {
+        if(depth >= CJSON_CIRCULAR_LIMIT) {
+            goto fail;
+        }
+        newchild = cJSON_Duplicate_rec(child, depth + 1, true); /* Duplicate (with recurse) each item in the ->next chain */
+        if (!newchild)
+        {
+            goto fail;
+        }
+        if (next != NULL)
+        {
+            /* If newitem->child already set, then crosswire ->prev and ->next and move on */
+            next->next = newchild;
+            newchild->prev = next;
+            next = newchild;
+        }
+        else
+        {
+            /* Set newitem->child and move to it */
+            newitem->child = newchild;
+            next = newchild;
+        }
+        child = child->next;
+    }
+    if (newitem && newitem->child)
+    {
+        newitem->child->prev = newchild;
+    }
+
+    return newitem;
+
+fail:
+    if (newitem != NULL)
+    {
+        cJSON_Delete(newitem);
+    }
+
+    return NULL;
+}
+
+static void skip_oneline_comment(char **input)
+{
+    *input += static_strlen("//");
+
+    for (; (*input)[0] != '\0'; ++(*input))
+    {
+        if ((*input)[0] == '\n') {
+            *input += static_strlen("\n");
+            return;
+        }
+    }
+}
+
+static void skip_multiline_comment(char **input)
+{
+    *input += static_strlen("/*");
+
+    for (; (*input)[0] != '\0'; ++(*input))
+    {
+        if (((*input)[0] == '*') && ((*input)[1] == '/'))
+        {
+            *input += static_strlen("*/");
+            return;
+        }
+    }
+}
+
+static void minify_string(char **input, char **output) {
+    (*output)[0] = (*input)[0];
+    *input += static_strlen("\"");
+    *output += static_strlen("\"");
+
+
+    for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) {
+        (*output)[0] = (*input)[0];
+
+        if ((*input)[0] == '\"') {
+            (*output)[0] = '\"';
+            *input += static_strlen("\"");
+            *output += static_strlen("\"");
+            return;
+        } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) {
+            (*output)[1] = (*input)[1];
+            *input += static_strlen("\"");
+            *output += static_strlen("\"");
+        }
+    }
+}
+
+CJSON_PUBLIC(void) cJSON_Minify(char *json)
+{
+    char *into = json;
+
+    if (json == NULL)
+    {
+        return;
+    }
+
+    while (json[0] != '\0')
+    {
+        switch (json[0])
+        {
+            case ' ':
+            case '\t':
+            case '\r':
+            case '\n':
+                json++;
+                break;
+
+            case '/':
+                if (json[1] == '/')
+                {
+                    skip_oneline_comment(&json);
+                }
+                else if (json[1] == '*')
+                {
+                    skip_multiline_comment(&json);
+                } else {
+                    json++;
+                }
+                break;
+
+            case '\"':
+                minify_string(&json, (char**)&into);
+                break;
+
+            default:
+                into[0] = json[0];
+                json++;
+                into++;
+        }
+    }
+
+    /* and null-terminate. */
+    *into = '\0';
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Invalid;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_False;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xff) == cJSON_True;
+}
+
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & (cJSON_True | cJSON_False)) != 0;
+}
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_NULL;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Number;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_String;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Array;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Object;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Raw;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)
+{
+    if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)))
+    {
+        return false;
+    }
+
+    /* check if type is valid */
+    switch (a->type & 0xFF)
+    {
+        case cJSON_False:
+        case cJSON_True:
+        case cJSON_NULL:
+        case cJSON_Number:
+        case cJSON_String:
+        case cJSON_Raw:
+        case cJSON_Array:
+        case cJSON_Object:
+            break;
+
+        default:
+            return false;
+    }
+
+    /* identical objects are equal */
+    if (a == b)
+    {
+        return true;
+    }
+
+    switch (a->type & 0xFF)
+    {
+        /* in these cases and equal type is enough */
+        case cJSON_False:
+        case cJSON_True:
+        case cJSON_NULL:
+            return true;
+
+        case cJSON_Number:
+            if (compare_double(a->valuedouble, b->valuedouble))
+            {
+                return true;
+            }
+            return false;
+
+        case cJSON_String:
+        case cJSON_Raw:
+            if ((a->valuestring == NULL) || (b->valuestring == NULL))
+            {
+                return false;
+            }
+            if (strcmp(a->valuestring, b->valuestring) == 0)
+            {
+                return true;
+            }
+
+            return false;
+
+        case cJSON_Array:
+        {
+            cJSON *a_element = a->child;
+            cJSON *b_element = b->child;
+
+            for (; (a_element != NULL) && (b_element != NULL);)
+            {
+                if (!cJSON_Compare(a_element, b_element, case_sensitive))
+                {
+                    return false;
+                }
+
+                a_element = a_element->next;
+                b_element = b_element->next;
+            }
+
+            /* one of the arrays is longer than the other */
+            if (a_element != b_element) {
+                return false;
+            }
+
+            return true;
+        }
+
+        case cJSON_Object:
+        {
+            cJSON *a_element = NULL;
+            cJSON *b_element = NULL;
+            cJSON_ArrayForEach(a_element, a)
+            {
+                /* TODO This has O(n^2) runtime, which is horrible! */
+                b_element = get_object_item(b, a_element->string, case_sensitive);
+                if (b_element == NULL)
+                {
+                    return false;
+                }
+
+                if (!cJSON_Compare(a_element, b_element, case_sensitive))
+                {
+                    return false;
+                }
+            }
+
+            /* doing this twice, once on a and b to prevent true comparison if a subset of b
+             * TODO: Do this the proper way, this is just a fix for now */
+            cJSON_ArrayForEach(b_element, b)
+            {
+                a_element = get_object_item(a, b_element->string, case_sensitive);
+                if (a_element == NULL)
+                {
+                    return false;
+                }
+
+                if (!cJSON_Compare(b_element, a_element, case_sensitive))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        default:
+            return false;
+    }
+}
+
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size)
+{
+    return global_hooks.allocate(size);
+}
+
+CJSON_PUBLIC(void) cJSON_free(void *object)
+{
+    global_hooks.deallocate(object);
+    object = NULL;
+}
diff --git a/lib/vendor/cJSON/cJSON.h b/lib/vendor/cJSON/cJSON.h
new file mode 100644
index 00000000..37520bbc
--- /dev/null
+++ b/lib/vendor/cJSON/cJSON.h
@@ -0,0 +1,306 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 18
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* Limits the length of circular references can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_CIRCULAR_LIMIT
+#define CJSON_CIRCULAR_LIMIT 10000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant, 
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif