Merge pull request #2144 from RincewindsHat/refactor/check_snmp

Refactor check snmp:
 - Switch from executing `snmpget`/`snmpgetnext` to linking directly agains net-snmp
 - Refactor to use test abstraction -> allows for JSON output

6 files changed, 128 insertions, 598 deletions

diff --git a/lib/Makefile.am b/lib/Makefile.am
index a9f3ff40..27a08278 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -4,7 +4,7 @@ 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_tcp.c utils_cmd.c maxfd.c output.c perfdata.c output.c thresholds.c vendor/cJSON/cJSON.c
diff --git a/lib/perfdata.c b/lib/perfdata.c
index b87de7e0..2930a8bc 100644
--- a/lib/perfdata.c
+++ b/lib/perfdata.c
@@ -33,7 +33,18 @@ char *pd_value_to_string(const mp_perfdata_value pd) {
 char *pd_to_string(mp_perfdata pd) {
         assert(pd.label != NULL);
         char *result = NULL;
-        asprintf(&result, "'%s'=", pd.label);
+
+        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));
 
@@ -249,7 +260,9 @@ char *mp_range_to_string(const mp_range input) {
         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_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;
@@ -257,15 +270,25 @@ mp_perfdata mp_set_pd_value_double(mp_perfdata pd, double value) {
         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_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_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_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_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_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);
@@ -290,19 +313,33 @@ mp_perfdata_value mp_create_pd_value_double(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_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_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_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_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_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_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_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};
@@ -368,6 +405,13 @@ mp_range_parsed mp_parse_range_string(const char *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, ':');
diff --git a/lib/perfdata.h b/lib/perfdata.h
index 7fd908a9..c5d4a61d 100644
--- a/lib/perfdata.h
+++ b/lib/perfdata.h
@@ -45,7 +45,7 @@ typedef struct range_struct {
         double start;
         bool start_infinity;
         double end;
-        int end_infinity;
+        bool end_infinity;
         int alert_on; /* OUTSIDE (default) or INSIDE */
         char *text;   /* original unparsed text input */
 } range;
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/utils_base.c b/lib/utils_base.c
index c49a473f..29b393d0 100644
--- a/lib/utils_base.c
+++ b/lib/utils_base.c
@@ -33,12 +33,12 @@
 #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;
@@ -46,7 +46,7 @@ monitoring_plugin *this_monitoring_plugin = NULL;
 int 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) {
@@ -74,14 +74,6 @@ void np_set_args(int argc, char **argv) {
 
 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);
         }
@@ -153,7 +145,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);
@@ -205,12 +198,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");
                 }
@@ -222,15 +217,16 @@ void print_thresholds(const char *threshold_name, thresholds *my_threshold) {
 bool mp_check_range(const mp_perfdata_value value, const mp_range my_range) {
         bool is_inside = false;
 
-        if (my_range.end_infinity == false && my_range.start_infinity == false) {
+        if (!my_range.end_infinity && !my_range.start_infinity) {
                 // range:  .........|---inside---|...........
                 // value
-                is_inside = ((cmp_perfdata_value(my_range.start, value) < 1) && (cmp_perfdata_value(value, my_range.end) <= 0));
-        } else if (my_range.start_infinity == false && my_range.end_infinity == true) {
+                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(my_range.start, value) < 0);
-        } else if (my_range.start_infinity == true && my_range.end_infinity == false) {
+                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);
@@ -239,7 +235,8 @@ bool mp_check_range(const mp_perfdata_value value, const mp_range my_range) {
                 is_inside = true;
         }
 
-        if ((is_inside && my_range.alert_on_inside_range == INSIDE) || (!is_inside && my_range.alert_on_inside_range == OUTSIDE)) {
+        if ((is_inside && my_range.alert_on_inside_range == INSIDE) ||
+                (!is_inside && my_range.alert_on_inside_range == OUTSIDE)) {
                 return true;
         }
 
@@ -256,21 +253,21 @@ 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;
                 }
                 return yes;
         }
 
-        if (my_range->start_infinity == false && my_range->end_infinity == true) {
+        if (!my_range->start_infinity && my_range->end_infinity) {
                 if (my_range->start <= value) {
                         return no;
                 }
                 return yes;
         }
 
-        if (my_range->start_infinity == true && my_range->end_infinity == false) {
+        if (my_range->start_infinity && !my_range->end_infinity) {
                 if (value <= my_range->end) {
                         return no;
                 }
@@ -282,12 +279,12 @@ bool check_range(double value, range *my_range) {
 /* Returns status */
 int 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;
                 }
         }
@@ -296,32 +293,31 @@ int get_status(double value, thresholds *my_thresholds) {
 
 char *np_escaped_string(const char *string) {
         char *data;
-        int i;
-        int 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;
 }
 
@@ -336,33 +332,35 @@ int np_check_if_root(void) { return (geteuid() == 0); }
 char *np_extract_value(const char *varlist, const char *name, char sep) {
         char *tmp = NULL;
         char *value = NULL;
-        int i;
 
-        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) {
                                                 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 */
@@ -387,7 +385,7 @@ 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--) {
+                for (unsigned long i = strlen(value) - 1; isspace(value[i]); i--) {
                         value[i] = '\0';
                 }
         }
@@ -429,349 +427,3 @@ int mp_translate_state(char *state_text) {
         }
         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(void) {
-        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(void) {
-        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(void) {
-        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(void) {
-        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"));
-        }
-
-        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 (rename(temp_file, this_monitoring_plugin->state->_filename) != 0) {
-                unlink(temp_file);
-                np_free(temp_file);
-                die(STATE_UNKNOWN, _("Cannot rename state temp file"));
-        }
-
-        np_free(temp_file);
-}
diff --git a/lib/utils_base.h b/lib/utils_base.h
index 123066f8..f1c99a54 100644
--- a/lib/utils_base.h
+++ b/lib/utils_base.h
@@ -8,7 +8,6 @@
 #include "./perfdata.h"
 #include "./thresholds.h"
 
-
 #ifndef USE_OPENSSL
 #       include "sha256.h"
 #endif
@@ -26,25 +25,8 @@
 #define OUTSIDE 0
 #define INSIDE  1
 
-#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;
@@ -100,10 +82,6 @@ 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);
-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(void);