40 files changed, 2421 insertions, 3082 deletions

diff --git a/.github/monitoring-plugins.spec b/.github/monitoring-plugins.spec
index 64ee34f2..10799128 100644
--- a/.github/monitoring-plugins.spec
+++ b/.github/monitoring-plugins.spec
@@ -191,7 +191,6 @@ Requires: %{name}-nt
 Requires: %{name}-ntp
 Requires: %{name}-ntp_peer
 Requires: %{name}-ntp_time
-Requires: %{name}-nwstat
 Requires: %{name}-oracle
 Requires: %{name}-pgsql
 Requires: %{name}-ping
@@ -702,19 +701,6 @@ Provides check_ntp_time of the Monitoring Plugins.
 
 
 
-# check_nwstat
-%package nwstat
-Summary:  Monitoring Plugins - check_nwstat
-Requires: %{name} = %{version}-%{release}
-
-%description nwstat
-Provides check_nwstat of the Monitoring Plugins.
-
-%files nwstat
-%{plugindir}/check_nwstat
-
-
-
 # check_oracle
 %package oracle
 Summary:  Monitoring Plugins - check_oracle
diff --git a/.github/os_detect.sh b/.github/os_detect.sh
index ee9c145d..47c762d3 100644
--- a/.github/os_detect.sh
+++ b/.github/os_detect.sh
@@ -1,10 +1,17 @@
 #!/bin/sh -e
+
+. /etc/os-release
+
 # workaround for really bare-bones Archlinux containers:
 if [ -x "$(command -v pacman)" ]; then
     pacman --noconfirm -Sy
     pacman --noconfirm -S grep gawk sed
 fi
 
+if [ ${ID} == "fedora" -a ${VERSION_ID} -gt 41 ]; then
+    dnf install -y gawk
+fi
+
 os_release_file=
 if [ -s "/etc/os-release" ]; then
   os_release_file="/etc/os-release"
diff --git a/.gitignore b/.gitignore
index f9cb37e4..8b14f429 100644
--- a/.gitignore
+++ b/.gitignore
@@ -114,7 +114,6 @@ NP-VERSION-FILE
 /lib/tests/Makefile.in
 /lib/tests/test_base64
 /lib/tests/test_cmd
-/lib/tests/test_disk
 /lib/tests/test_tcp
 /lib/tests/test_utils
 /lib/tests/utils_base.Po
@@ -153,6 +152,8 @@ NP-VERSION-FILE
 /plugins/check_dbi
 /plugins/check_dig
 /plugins/check_disk
+plugins/check_disk.d/.deps/
+plugins/check_disk.d/.dirstamp
 /plugins/check_dns
 /plugins/check_dummy
 /plugins/check_fping
@@ -177,7 +178,6 @@ NP-VERSION-FILE
 /plugins/check_ntp
 /plugins/check_ntp_peer
 /plugins/check_ntp_time
-/plugins/check_nwstat
 /plugins/check_pgsql
 /plugins/check_ping
 /plugins/check_pop
@@ -222,7 +222,7 @@ NP-VERSION-FILE
 /plugins/tests/Makefile
 /plugins/tests/Makefile.in
 /plugins/tests/test_utils
-/plugins/tests/test_disk
+/plugins/tests/test_check_disk
 /plugins/tests/test_check_swap
 /plugins/tests/.deps
 /plugins/tests/.dirstamp
diff --git a/REQUIREMENTS b/REQUIREMENTS
index f3b1c01d..551fdb1a 100644
--- a/REQUIREMENTS
+++ b/REQUIREMENTS
@@ -87,10 +87,6 @@ check_ifstatus/check_ifoperstatus
         - Requires Net::SNMP perl module
           http://www.perl.com/CPAN/modules/by-authors/id/D/DT/DTOWN/
 
-check_nwstat:
-        - Requires MRTGEXT NLM for Novell Servers
-          http://forge.novell.com/modules/xfmod/project/?mrtgext
-
 check_nt:
         - Requires NSClient to run on the NT server to monitor
           http://nsclient.ready2run.nl/
diff --git a/configure.ac b/configure.ac
index 204fc6e3..fdc9b699 100644
--- a/configure.ac
+++ b/configure.ac
@@ -181,10 +181,10 @@ fi
 
 # Finally, define tests if we use libtap
 if test "$enable_libtap" = "yes" ; then
-        EXTRA_TEST="test_utils test_disk test_tcp test_cmd test_base64"
+        EXTRA_TEST="test_utils test_tcp test_cmd test_base64"
         AC_SUBST(EXTRA_TEST)
 
-        EXTRA_PLUGIN_TESTS="tests/test_check_swap"
+        EXTRA_PLUGIN_TESTS="tests/test_check_swap tests/test_check_disk"
         AC_SUBST(EXTRA_PLUGIN_TESTS)
 fi
 
diff --git a/lib/Makefile.am b/lib/Makefile.am
index e41201c4..a9f3ff40 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -7,10 +7,9 @@ noinst_LIBRARIES = libmonitoringplug.a
 AM_CPPFLAGS = -DNP_STATE_DIR_PREFIX=\"$(localstatedir)\" \
         -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 output.c perfdata.c output.c thresholds.c vendor/cJSON/cJSON.c
+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_disk.h \
         utils_tcp.h \
         utils_cmd.h \
         parse_ini.h \
diff --git a/lib/output.c b/lib/output.c
index 61fbf832..c408a2f5 100644
--- a/lib/output.c
+++ b/lib/output.c
@@ -13,6 +13,7 @@
 
 // == 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);
@@ -202,7 +203,12 @@ mp_state_enum mp_compute_subcheck_state(const mp_subcheck check) {
         }
 
         mp_subcheck_list *scl = check.subchecks;
-        mp_state_enum result = check.default_state;
+
+        if (scl == NULL) {
+                return check.default_state;
+        }
+
+        mp_state_enum result = STATE_OK;
 
         while (scl != NULL) {
                 result = max_state_alt(result, mp_compute_subcheck_state(scl->subcheck));
@@ -247,7 +253,9 @@ char *mp_fmt_output(mp_check check) {
                 mp_subcheck_list *subchecks = check.subchecks;
 
                 while (subchecks != NULL) {
-                        asprintf(&result, "%s\n%s", result, fmt_subcheck_output(MP_FORMAT_MULTI_LINE, subchecks->subcheck, 1));
+                        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;
                 }
 
@@ -539,3 +547,7 @@ parsed_output_format mp_parse_output_format(char *format_string) {
 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; }
diff --git a/lib/output.h b/lib/output.h
index 2bdfa074..3bd91f90 100644
--- a/lib/output.h
+++ b/lib/output.h
@@ -38,8 +38,18 @@ typedef enum output_format {
 /*
  * Format related functions
  */
- void mp_set_format(mp_output_format format);
- mp_output_format mp_get_format(void);
+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.
@@ -48,7 +58,7 @@ typedef enum output_format {
  * in the first layer of subchecks
  */
 typedef struct {
-        char *summary;           // Overall summary, if not set a summary will be automatically generated
+        char *summary; // Overall summary, if not set a summary will be automatically generated
         mp_subcheck_list *subchecks;
 } mp_check;
 
diff --git a/lib/perfdata.c b/lib/perfdata.c
index 661756c5..f425ffcf 100644
--- a/lib/perfdata.c
+++ b/lib/perfdata.c
@@ -33,7 +33,7 @@ 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);
+        asprintf(&result, "'%s'=", pd.label);
 
         asprintf(&result, "%s%s", result, pd_value_to_string(pd.value));
 
@@ -514,3 +514,84 @@ perfdata_value_parser_wrapper parse_pd_value(const char *input) {
         }
         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
index 74583ee5..cb552678 100644
--- a/lib/perfdata.h
+++ b/lib/perfdata.h
@@ -171,6 +171,11 @@ 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
  */
@@ -178,6 +183,13 @@ 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
 // =================
diff --git a/lib/tests/Makefile.am b/lib/tests/Makefile.am
index 9be94f6d..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 test_generic_output
+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 test_generic_output.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 test_generic_output.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_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/thresholds.c b/lib/thresholds.c
index ddefae37..de2b9315 100644
--- a/lib/thresholds.c
+++ b/lib/thresholds.c
@@ -51,9 +51,21 @@ mp_state_enum mp_get_pd_status(mp_perfdata perfdata) {
         }
         if (perfdata.warn_present) {
                 if (mp_check_range(perfdata.value, perfdata.warn)) {
-                        return STATE_CRITICAL;
+                        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
index 4e7defee..5f9f9247 100644
--- a/lib/thresholds.h
+++ b/lib/thresholds.h
@@ -24,5 +24,8 @@ 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 ff9540c7..c49a473f 100644
--- a/lib/utils_base.c
+++ b/lib/utils_base.c
@@ -225,27 +225,15 @@ bool mp_check_range(const mp_perfdata_value value, const mp_range my_range) {
         if (my_range.end_infinity == false && my_range.start_infinity == false) {
                 // range:  .........|---inside---|...........
                 // value
-                if ((cmp_perfdata_value(my_range.start, value) < 1) && (cmp_perfdata_value(value, my_range.end) <= 0)) {
-                        is_inside = true;
-                } else {
-                        is_inside = false;
-                }
+                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) {
                 // range:  .........|---inside---------
                 // value
-                if (cmp_perfdata_value(my_range.start, value) < 0) {
-                        is_inside = true;
-                } else {
-                        is_inside = false;
-                }
+                is_inside = (cmp_perfdata_value(my_range.start, value) < 0);
         } else if (my_range.start_infinity == true && my_range.end_infinity == false) {
                 // range:  -inside--------|....................
                 // value
-                if (cmp_perfdata_value(value, my_range.end) == -1) {
-                        is_inside = true;
-                } else {
-                        is_inside = false;
-                }
+                is_inside = (cmp_perfdata_value(value, my_range.end) == -1);
         } else {
                 // range from -inf to inf, so always inside
                 is_inside = true;
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.h b/lib/utils_tcp.h
index d5999e9b..a7d83c59 100644
--- a/lib/utils_tcp.h
+++ b/lib/utils_tcp.h
@@ -11,6 +11,7 @@
  * server.
  */
 enum np_match_result {
+        NP_MATCH_NONE,
         NP_MATCH_FAILURE,
         NP_MATCH_SUCCESS,
         NP_MATCH_RETRY
diff --git a/plugins/Makefile.am b/plugins/Makefile.am
index 9e4924c3..04fb7ed2 100644
--- a/plugins/Makefile.am
+++ b/plugins/Makefile.am
@@ -27,7 +27,7 @@ MATHLIBS = @MATHLIBS@
 #AM_CFLAGS = -Wall
 
 libexec_PROGRAMS = check_apt check_cluster check_disk check_dummy check_http check_load \
-        check_mrtg check_mrtgtraf check_ntp check_ntp_peer check_nwstat check_ping \
+        check_mrtg check_mrtgtraf check_ntp check_ntp_peer check_ping \
         check_real check_smtp check_ssh check_tcp check_time check_ntp_time \
         check_ups check_users negate \
         urlize @EXTRAS@
@@ -40,11 +40,13 @@ EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_snmp check_hpjd \
         check_nagios check_by_ssh check_dns check_nt check_ide_smart    \
         check_procs check_mysql_query check_apt check_dbi check_curl \
         \
-        tests/test_check_swap
+        tests/test_check_swap \
+        tests/test_check_disk
 
 SUBDIRS = picohttpparser
 
-np_test_scripts = tests/test_check_swap.t
+np_test_scripts = tests/test_check_swap.t \
+                                  tests/test_check_disk.t
 
 EXTRA_DIST = t \
                          tests \
@@ -55,9 +57,11 @@ EXTRA_DIST = t \
                          check_hpjd.d \
                          check_game.d \
                          check_radius.d \
+                         check_disk.d \
                          check_time.d \
                          check_nagios.d \
                          check_dbi.d \
+                         check_tcp.d \
                          check_real.d \
                          check_ssh.d \
                          check_nt.d \
@@ -118,6 +122,7 @@ check_curl_LDADD = $(NETLIBS) $(LIBCURLLIBS) $(SSLOBJS) $(URIPARSERLIBS) picohtt
 check_dbi_LDADD = $(NETLIBS) $(DBILIBS)
 check_dig_LDADD = $(NETLIBS)
 check_disk_LDADD = $(BASEOBJS)
+check_disk_SOURCES = check_disk.c check_disk.d/utils_disk.c
 check_dns_LDADD = $(NETLIBS)
 check_dummy_LDADD = $(BASEOBJS)
 check_fping_LDADD = $(NETLIBS)
@@ -138,7 +143,6 @@ check_nagios_LDADD = $(BASEOBJS)
 check_nt_LDADD = $(NETLIBS)
 check_ntp_LDADD = $(NETLIBS) $(MATHLIBS)
 check_ntp_peer_LDADD = $(NETLIBS) $(MATHLIBS)
-check_nwstat_LDADD = $(NETLIBS)
 check_pgsql_LDADD = $(NETLIBS) $(PGLIBS)
 check_ping_LDADD = $(NETLIBS)
 check_procs_LDADD = $(BASEOBJS)
@@ -165,6 +169,8 @@ endif
 
 tests_test_check_swap_LDADD = $(BASEOBJS) $(tap_ldflags) -ltap
 tests_test_check_swap_SOURCES = tests/test_check_swap.c check_swap.d/swap.c
+tests_test_check_disk_LDADD = $(BASEOBJS) $(tap_ldflags) check_disk.d/utils_disk.c -ltap
+tests_test_check_disk_SOURCES = tests/test_check_disk.c
 
 ##############################################################################
 # secondary dependencies
diff --git a/plugins/check_disk.c b/plugins/check_disk.c
index 037a6f7a..515ddff0 100644
--- a/plugins/check_disk.c
+++ b/plugins/check_disk.c
@@ -31,24 +31,35 @@ const char *program_name = "check_disk"; /* Required for coreutils libs */
 const char *copyright = "1999-2024";
 const char *email = "devel@monitoring-plugins.org";
 
+#include "states.h"
 #include "common.h"
+#include "output.h"
+#include "perfdata.h"
+#include "utils_base.h"
+#include "lib/thresholds.h"
+
 #ifdef HAVE_SYS_STAT_H
 #       include <sys/stat.h>
 #endif
+
 #if HAVE_INTTYPES_H
 #       include <inttypes.h>
 #endif
+
 #include <assert.h>
-#include "popen.h"
-#include "utils.h"
-#include "utils_disk.h"
 #include <stdarg.h>
-#include "fsusage.h"
-#include "mountlist.h"
+#include <stdint.h>
 #include <float.h>
+#include "./popen.h"
+#include "./utils.h"
+#include "../gl/fsusage.h"
+#include "../gl/mountlist.h"
+#include "./check_disk.d/utils_disk.h"
+
 #if HAVE_LIMITS_H
 #       include <limits.h>
 #endif
+
 #include "regex.h"
 
 #ifdef __CYGWIN__
@@ -57,424 +68,310 @@ const char *email = "devel@monitoring-plugins.org";
 #       define ERROR -1
 #endif
 
-/* If nonzero, show even filesystems with zero size or
-   uninteresting types. */
-static int show_all_fs = 1;
-
-/* If nonzero, show only local filesystems.  */
-static int show_local_fs = 0;
-
-/* If nonzero, show only local filesystems but call stat() on remote ones. */
-static int stat_remote_fs = 0;
-
-/* If positive, the units to use when printing sizes;
-   if negative, the human-readable base.  */
-/* static int output_block_size; */
-
-/* If nonzero, invoke the `sync' system call before getting any usage data.
-   Using this option can make df very slow, especially with many or very
-   busy disks.  Note that this may make a difference on some systems --
-   SunOs4.1.3, for one.  It is *not* necessary on Linux.  */
-/* static int require_sync = 0; */
-
-/* Linked list of filesystem types to display.
-   If `fs_select_list' is NULL, list all types.
-   This table is generated dynamically from command-line options,
-   rather than hardcoding into the program what it thinks are the
-   valid filesystem types; let the user specify any filesystem type
-   they want to, and if there are any filesystems of that type, they
-   will be shown.
-
-   Some filesystem types:
-   4.2 4.3 ufs nfs swap ignore io vm efs dbg */
-
-/* static struct parameter_list *fs_select_list; */
-
-/* Linked list of filesystem types to omit.
-   If the list is empty, don't exclude any types.  */
-static struct regex_list *fs_exclude_list = NULL;
-
-/* Linked list of filesystem types to check.
-   If the list is empty, include all types.  */
-static struct regex_list *fs_include_list;
-
-static struct name_list *dp_exclude_list;
-
-static struct parameter_list *path_select_list = NULL;
-
-/* Linked list of mounted filesystems. */
-static struct mount_entry *mount_list;
-
-/* For long options that have no equivalent short option, use a
-   non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
-enum {
-        SYNC_OPTION = CHAR_MAX + 1,
-        NO_SYNC_OPTION,
-        BLOCK_SIZE_OPTION
-};
-
 #ifdef _AIX
 #       pragma alloca
 #endif
 
-static int process_arguments(int /*argc*/, char ** /*argv*/);
-static void set_all_thresholds(struct parameter_list *path);
-static void print_help(void);
+typedef struct {
+        int errorcode;
+        check_disk_config config;
+} check_disk_config_wrapper;
+static check_disk_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
+
+static void set_all_thresholds(parameter_list_elem *path, char *warn_freespace_units, char *crit_freespace_units,
+                                                           char *warn_freespace_percent, char *crit_freespace_percent, char *warn_freeinodes_percent,
+                                                           char *crit_freeinodes_percent);
+static double calculate_percent(uintmax_t /*value*/, uintmax_t /*total*/);
+static bool stat_path(parameter_list_elem * /*parameters*/, bool /*ignore_missing*/);
+
+/*
+ * Puts the values from a struct fs_usage into a parameter_list with an additional flag to control how reserved
+ * and inodes should be judged (ignored or not)
+ */
+static parameter_list_elem get_path_stats(parameter_list_elem parameters, struct fs_usage fsp, bool freespace_ignore_reserved);
+static mp_subcheck evaluate_filesystem(measurement_unit measurement_unit, bool display_inodes_perfdata, byte_unit unit);
+
 void print_usage(void);
-static double calculate_percent(uintmax_t, uintmax_t);
-static bool stat_path(struct parameter_list *p);
-static void get_stats(struct parameter_list *p, struct fs_usage *fsp);
-static void get_path_stats(struct parameter_list *p, struct fs_usage *fsp);
+static void print_help(void);
 
-static char *units;
-static uintmax_t mult = 1024 * 1024;
 static int verbose = 0;
-static bool erronly = false;
-static bool display_mntp = false;
-static bool exact_match = false;
-static bool ignore_missing = false;
-static bool freespace_ignore_reserved = false;
-static bool display_inodes_perfdata = false;
-static char *warn_freespace_units = NULL;
-static char *crit_freespace_units = NULL;
-static char *warn_freespace_percent = NULL;
-static char *crit_freespace_percent = NULL;
-static char *warn_usedspace_units = NULL;
-static char *crit_usedspace_units = NULL;
-static char *warn_usedspace_percent = NULL;
-static char *crit_usedspace_percent = NULL;
-static char *warn_usedinodes_percent = NULL;
-static char *crit_usedinodes_percent = NULL;
-static char *warn_freeinodes_percent = NULL;
-static char *crit_freeinodes_percent = NULL;
-static bool path_selected = false;
-static bool path_ignored = false;
-static char *group = NULL;
-static struct stat *stat_buf;
-static struct name_list *seen = NULL;
 
-int main(int argc, char **argv) {
-        int result = STATE_UNKNOWN;
-        int disk_result = STATE_UNKNOWN;
-        char *output = NULL;
-        char *ignored = NULL;
-        char *details = NULL;
-        char *perf = NULL;
-        char *perf_ilabel = NULL;
-        char *preamble = " - free space:";
-        char *ignored_preamble = " - ignored paths:";
-        char *flag_header = NULL;
-        int temp_result = STATE_UNKNOWN;
-
-        struct mount_entry *me = NULL;
-        struct fs_usage fsp = {0};
-        struct parameter_list *temp_list = NULL;
-        struct parameter_list *path = NULL;
-
-#ifdef __CYGWIN__
-        char mountdir[32];
-#endif
+// This would not be necessary in C23!!
+const byte_unit Bytes_Factor = 1;
+const byte_unit KibiBytes_factor = 1024;
+const byte_unit MebiBytes_factor = 1048576;
+const byte_unit GibiBytes_factor = 1073741824;
+const byte_unit TebiBytes_factor = 1099511627776;
+const byte_unit PebiBytes_factor = 1125899906842624;
+const byte_unit ExbiBytes_factor = 1152921504606846976;
+const byte_unit KiloBytes_factor = 1000;
+const byte_unit MegaBytes_factor = 1000000;
+const byte_unit GigaBytes_factor = 1000000000;
+const byte_unit TeraBytes_factor = 1000000000000;
+const byte_unit PetaBytes_factor = 1000000000000000;
+const byte_unit ExaBytes_factor = 1000000000000000000;
 
-        output = strdup("");
-        ignored = strdup("");
-        details = strdup("");
-        perf = strdup("");
-        perf_ilabel = strdup("");
-        stat_buf = malloc(sizeof *stat_buf);
 
+int main(int argc, char **argv) {
         setlocale(LC_ALL, "");
         bindtextdomain(PACKAGE, LOCALEDIR);
         textdomain(PACKAGE);
 
-        mount_list = read_file_system_list(0);
+#ifdef __CYGWIN__
+        char mountdir[32];
+#endif
 
-        /* Parse extra opts if any */
+        // Parse extra opts if any
         argv = np_extra_opts(&argc, argv, progname);
 
-        if (process_arguments(argc, argv) == ERROR)
+        check_disk_config_wrapper tmp_config = process_arguments(argc, argv);
+        if (tmp_config.errorcode == ERROR) {
                 usage4(_("Could not parse arguments"));
+        }
 
-        /* If a list of paths has not been selected, find entire
-           mount list and create list of paths
-         */
-        if (path_selected == false && path_ignored == false) {
-                for (me = mount_list; me; me = me->me_next) {
-                        if (!(path = np_find_parameter(path_select_list, me->me_mountdir))) {
-                                path = np_add_parameter(&path_select_list, me->me_mountdir);
-                        }
-                        path->best_match = me;
-                        path->group = group;
-                        set_all_thresholds(path);
-                }
+        check_disk_config config = tmp_config.config;
+
+        if (config.output_format_is_set) {
+                mp_set_format(config.output_format);
         }
 
-        if (path_ignored == false) {
-                np_set_best_match(path_select_list, mount_list, exact_match);
+        if (config.erronly) {
+                mp_set_level_of_detail(MP_DETAIL_NON_OK_ONLY);
         }
 
-        /* Error if no match found for specified paths */
-        temp_list = path_select_list;
+        if (!config.path_ignored) {
+                mp_int_fs_list_set_best_match(config.path_select_list, config.mount_list, config.exact_match);
+        }
 
-        while (path_select_list) {
-                if (!path_select_list->best_match && ignore_missing == true) {
-                        /* If the first element will be deleted, the temp_list must be updated with the new start address as well */
-                        if (path_select_list == temp_list) {
-                                temp_list = path_select_list->name_next;
-                        }
-                        /* Add path argument to list of ignored paths to inform about missing paths being ignored and not alerted */
-                        xasprintf(&ignored, "%s %s;", ignored, path_select_list->name);
+        // Error if no match found for specified paths
+        for (parameter_list_elem *elem = config.path_select_list.first; elem;) {
+                if (!elem->best_match && config.ignore_missing) {
                         /* Delete the path from the list so that it is not stat-checked later in the code. */
-                        path_select_list = np_del_parameter(path_select_list, path_select_list->name_prev);
-                } else if (!path_select_list->best_match) {
+                        elem = mp_int_fs_list_del(&config.path_select_list, elem);
+                        continue;
+                }
+                if (!elem->best_match) {
                         /* Without --ignore-missing option, exit with Critical state. */
-                        die(STATE_CRITICAL, _("DISK %s: %s not found\n"), _("CRITICAL"), path_select_list->name);
-                } else {
-                        /* Continue jumping through the list */
-                        path_select_list = path_select_list->name_next;
+                        die(STATE_CRITICAL, _("DISK %s: %s not found\n"), _("CRITICAL"), elem->name);
                 }
-        }
 
-        path_select_list = temp_list;
+                elem = mp_int_fs_list_get_next(elem);
+        }
 
-        if (!path_select_list && ignore_missing == true) {
-                result = STATE_OK;
-                if (verbose >= 2) {
-                        printf("None of the provided paths were found\n");
+        mp_check overall = mp_check_init();
+        if (config.path_select_list.length == 0) {
+                mp_subcheck none_sc = mp_subcheck_init();
+                xasprintf(&none_sc.output, "No filesystems were found for the provided parameters");
+                if (config.ignore_missing) {
+                        none_sc = mp_set_subcheck_state(none_sc, STATE_OK);
+                } else {
+                        none_sc = mp_set_subcheck_state(none_sc, STATE_UNKNOWN);
+                        if (verbose >= 2) {
+                                printf("None of the provided paths were found\n");
+                        }
                 }
+                mp_add_subcheck_to_check(&overall, none_sc);
+                mp_exit(overall);
         }
 
-        /* Process for every path in list */
-        for (path = path_select_list; path; path = path->name_next) {
-                if (verbose >= 3 && path->freespace_percent->warning != NULL && path->freespace_percent->critical != NULL)
-                        printf("Thresholds(pct) for %s warn: %f crit %f\n", path->name, path->freespace_percent->warning->end,
-                                   path->freespace_percent->critical->end);
-
-                if (verbose >= 3 && path->group != NULL)
-                        printf("Group of %s: %s\n", path->name, path->group);
-
-                /* reset disk result */
-                disk_result = STATE_UNKNOWN;
-
-                me = path->best_match;
-
-                if (!me) {
+        // Filter list first
+        for (parameter_list_elem *path = config.path_select_list.first; path;) {
+                if (!path->best_match) {
+                        path = mp_int_fs_list_del(&config.path_select_list, path);
                         continue;
                 }
 
+                struct mount_entry *mount_entry = path->best_match;
+
 #ifdef __CYGWIN__
-                if (strncmp(path->name, "/cygdrive/", 10) != 0 || strlen(path->name) > 11)
+                if (strncmp(path->name, "/cygdrive/", 10) != 0 || strlen(path->name) > 11) {
+                        path = mp_int_fs_list_del(&config.path_select_list, path);
                         continue;
+                }
+
+                char *mountdir = NULL;
                 snprintf(mountdir, sizeof(mountdir), "%s:\\", me->me_mountdir + 10);
-                if (GetDriveType(mountdir) != DRIVE_FIXED)
-                        me->me_remote = 1;
+                if (GetDriveType(mountdir) != DRIVE_FIXED) {
+                        mount_entry->me_remote = 1;
+                }
 #endif
-                /* Filters */
 
                 /* Remove filesystems already seen */
-                if (np_seen_name(seen, me->me_mountdir)) {
+                if (np_seen_name(config.seen, mount_entry->me_mountdir)) {
+                        path = mp_int_fs_list_del(&config.path_select_list, path);
                         continue;
                 }
-                np_add_name(&seen, me->me_mountdir);
 
                 if (path->group == NULL) {
-                        /* Skip remote filesystems if we're not interested in them */
-                        if (me->me_remote && show_local_fs) {
-                                if (stat_remote_fs) {
-                                        if (!stat_path(path) && ignore_missing == true) {
-                                                result = STATE_OK;
-                                                xasprintf(&ignored, "%s %s;", ignored, path->name);
-                                        }
-                                }
-                                continue;
-                                /* Skip pseudo fs's if we haven't asked for all fs's */
-                        }
-                        if (me->me_dummy && !show_all_fs) {
+                        if (config.fs_exclude_list && np_find_regmatch(config.fs_exclude_list, mount_entry->me_type)) {
+                                // Skip excluded fs's
+                                path = mp_int_fs_list_del(&config.path_select_list, path);
                                 continue;
-                                /* Skip excluded fstypes */
                         }
-                        if (fs_exclude_list && np_find_regmatch(fs_exclude_list, me->me_type)) {
+
+                        if (config.device_path_exclude_list && (np_find_name(config.device_path_exclude_list, mount_entry->me_devname) ||
+                                                                                                        np_find_name(config.device_path_exclude_list, mount_entry->me_mountdir))) {
+                                // Skip excluded device or mount paths
+                                path = mp_int_fs_list_del(&config.path_select_list, path);
                                 continue;
-                                /* Skip excluded fs's */
                         }
-                        if (dp_exclude_list && (np_find_name(dp_exclude_list, me->me_devname) || np_find_name(dp_exclude_list, me->me_mountdir))) {
+
+                        if (config.fs_include_list && !np_find_regmatch(config.fs_include_list, mount_entry->me_type)) {
+                                // Skip not included fstypes
+                                path = mp_int_fs_list_del(&config.path_select_list, path);
                                 continue;
-                                /* Skip not included fstypes */
                         }
-                        if (fs_include_list && !np_find_regmatch(fs_include_list, me->me_type)) {
+
+                        /* Skip remote filesystems if we're not interested in them */
+                        if (mount_entry->me_remote && config.show_local_fs) {
+                                if (config.stat_remote_fs) {
+                                        // TODO Stat here
+                                        if (!stat_path(path, config.ignore_missing) && config.ignore_missing) {
+                                        }
+                                }
                                 continue;
                         }
-                }
 
-                if (!stat_path(path)) {
-                        if (ignore_missing == true) {
-                                result = STATE_OK;
-                                xasprintf(&ignored, "%s %s;", ignored, path->name);
+                        // TODO why stat here? remove unstatable fs?
+                        if (!stat_path(path, config.ignore_missing)) {
+                                // if (config.ignore_missing) {
+                                // xasprintf(&ignored, "%s %s;", ignored, path->name);
+                                // }
+                                // not accessible, remove from list
+                                path = mp_int_fs_list_del(&config.path_select_list, path);
+                                continue;
                         }
-                        continue;
                 }
-                get_fs_usage(me->me_mountdir, me->me_devname, &fsp);
 
-                if (fsp.fsu_blocks && strcmp("none", me->me_mountdir)) {
-                        get_stats(path, &fsp);
-
-                        if (verbose >= 3) {
-                                printf("For %s, used_pct=%f free_pct=%f used_units=%lu free_units=%lu total_units=%lu used_inodes_pct=%f "
-                                           "free_inodes_pct=%f fsp.fsu_blocksize=%lu mult=%lu\n",
-                                           me->me_mountdir, path->dused_pct, path->dfree_pct, path->dused_units, path->dfree_units, path->dtotal_units,
-                                           path->dused_inodes_percent, path->dfree_inodes_percent, fsp.fsu_blocksize, mult);
-                        }
-
-                        /* Threshold comparisons */
-
-                        temp_result = get_status(path->dfree_units, path->freespace_units);
-                        if (verbose >= 3)
-                                printf("Freespace_units result=%d\n", temp_result);
-                        disk_result = max_state(disk_result, temp_result);
-
-                        temp_result = get_status(path->dfree_pct, path->freespace_percent);
-                        if (verbose >= 3)
-                                printf("Freespace%% result=%d\n", temp_result);
-                        disk_result = max_state(disk_result, temp_result);
-
-                        temp_result = get_status(path->dused_units, path->usedspace_units);
-                        if (verbose >= 3)
-                                printf("Usedspace_units result=%d\n", temp_result);
-                        disk_result = max_state(disk_result, temp_result);
-
-                        temp_result = get_status(path->dused_pct, path->usedspace_percent);
-                        if (verbose >= 3)
-                                printf("Usedspace_percent result=%d\n", temp_result);
-                        disk_result = max_state(disk_result, temp_result);
-
-                        temp_result = get_status(path->dused_inodes_percent, path->usedinodes_percent);
-                        if (verbose >= 3)
-                                printf("Usedinodes_percent result=%d\n", temp_result);
-                        disk_result = max_state(disk_result, temp_result);
-
-                        temp_result = get_status(path->dfree_inodes_percent, path->freeinodes_percent);
-                        if (verbose >= 3)
-                                printf("Freeinodes_percent result=%d\n", temp_result);
-                        disk_result = max_state(disk_result, temp_result);
-
-                        result = max_state(result, disk_result);
+                path = mp_int_fs_list_get_next(path);
+        }
 
-                        /* What a mess of units. The output shows free space, the perf data shows used space. Yikes!
-                           Hack here. Trying to get warn/crit levels from freespace_(units|percent) for perf
-                           data. Assumption that start=0. Roll on new syntax...
-                        */
+        // now get the actual measurements
+        for (parameter_list_elem *filesystem = config.path_select_list.first; filesystem;) {
+                // Get actual metrics here
+                struct mount_entry *mount_entry = filesystem->best_match;
+                struct fs_usage fsp = {0};
+                get_fs_usage(mount_entry->me_mountdir, mount_entry->me_devname, &fsp);
 
-                        /* *_high_tide must be reinitialized at each run */
-                        uint64_t warning_high_tide = UINT64_MAX;
+                if (fsp.fsu_blocks != 0 && strcmp("none", mount_entry->me_mountdir) != 0) {
+                        *filesystem = get_path_stats(*filesystem, fsp, config.freespace_ignore_reserved);
 
-                        if (path->freespace_units->warning != NULL) {
-                                warning_high_tide = (path->dtotal_units - path->freespace_units->warning->end) * mult;
-                        }
-                        if (path->freespace_percent->warning != NULL) {
-                                warning_high_tide =
-                                        min(warning_high_tide, (uint64_t)((1.0 - path->freespace_percent->warning->end / 100) * (path->dtotal_units * mult)));
-                        }
-
-                        uint64_t critical_high_tide = UINT64_MAX;
-
-                        if (path->freespace_units->critical != NULL) {
-                                critical_high_tide = (path->dtotal_units - path->freespace_units->critical->end) * mult;
-                        }
-                        if (path->freespace_percent->critical != NULL) {
-                                critical_high_tide =
-                                        min(critical_high_tide, (uint64_t)((1.0 - path->freespace_percent->critical->end / 100) * (path->dtotal_units * mult)));
+                        if (verbose >= 3) {
+                                printf("For %s, used_units=%lu free_units=%lu total_units=%lu "
+                                           "fsp.fsu_blocksize=%lu\n",
+                                           mount_entry->me_mountdir, filesystem->used_bytes, filesystem->free_bytes, filesystem->total_bytes,
+                                           fsp.fsu_blocksize);
                         }
+                } else {
+                        // failed to retrieve file system data or not mounted?
+                        filesystem = mp_int_fs_list_del(&config.path_select_list, filesystem);
+                        continue;
+                }
+                filesystem = mp_int_fs_list_get_next(filesystem);
+        }
 
-                        /* Nb: *_high_tide are unset when == UINT64_MAX */
-                        xasprintf(&perf, "%s %s", perf,
-                                          perfdata_uint64((!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir,
-                                                                          path->dused_units * mult, "B", (warning_high_tide == UINT64_MAX ? false : true), warning_high_tide,
-                                                                          (critical_high_tide == UINT64_MAX ? false : true), critical_high_tide, true, 0, true,
-                                                                          path->dtotal_units * mult));
-
-                        if (display_inodes_perfdata) {
-                                /* *_high_tide must be reinitialized at each run */
-                                warning_high_tide = UINT64_MAX;
-                                critical_high_tide = UINT64_MAX;
-
-                                if (path->freeinodes_percent->warning != NULL) {
-                                        warning_high_tide = (uint64_t)fabs(
-                                                min((double)warning_high_tide, (double)(1.0 - path->freeinodes_percent->warning->end / 100) * path->inodes_total));
-                                }
-                                if (path->freeinodes_percent->critical != NULL) {
-                                        critical_high_tide = (uint64_t)fabs(min(
-                                                (double)critical_high_tide, (double)(1.0 - path->freeinodes_percent->critical->end / 100) * path->inodes_total));
-                                }
-
-                                xasprintf(&perf_ilabel, "%s (inodes)",
-                                                  (!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir);
-                                /* Nb: *_high_tide are unset when == UINT64_MAX */
-                                xasprintf(&perf, "%s %s", perf,
-                                                  perfdata_uint64(perf_ilabel, path->inodes_used, "", (warning_high_tide != UINT64_MAX ? true : false),
-                                                                                  warning_high_tide, (critical_high_tide != UINT64_MAX ? true : false), critical_high_tide, true, 0,
-                                                                                  true, path->inodes_total));
+        if (verbose > 2) {
+                for (parameter_list_elem *filesystem = config.path_select_list.first; filesystem;
+                         filesystem = mp_int_fs_list_get_next(filesystem)) {
+                        assert(filesystem->best_match != NULL);
+                        if (filesystem->best_match == NULL) {
+                                printf("Filesystem path %s has no mount_entry!\n", filesystem->name);
+                        } else {
+                                // printf("Filesystem path %s has a mount_entry!\n", filesystem->name);
                         }
+                }
+        }
 
-                        if (disk_result == STATE_OK && erronly && !verbose)
-                                continue;
-
-                        if (disk_result && verbose >= 1) {
-                                xasprintf(&flag_header, " %s [", state_text(disk_result));
+        measurement_unit_list *measurements = NULL;
+        measurement_unit_list *current = NULL;
+        // create measuring units, because of groups
+        for (parameter_list_elem *filesystem = config.path_select_list.first; filesystem; filesystem = mp_int_fs_list_get_next(filesystem)) {
+                assert(filesystem->best_match != NULL);
+
+                if (filesystem->group == NULL) {
+                        // create a measurement unit for the fs
+                        measurement_unit unit = create_measurement_unit_from_filesystem(*filesystem, config.display_mntp);
+                        if (measurements == NULL) {
+                                measurements = current = add_measurement_list(NULL, unit);
                         } else {
-                                xasprintf(&flag_header, "");
+                                current = add_measurement_list(measurements, unit);
                         }
-                        xasprintf(&output, "%s%s %s %llu%s (%.1f%%", output, flag_header,
-                                          (!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir, path->dfree_units, units,
-                                          path->dfree_pct);
-                        if (path->dused_inodes_percent < 0) {
-                                xasprintf(&output, "%s inode=-)%s;", output, (disk_result ? "]" : ""));
+                } else {
+                        // Grouped elements are consecutive
+                        if (measurements == NULL) {
+                                // first entry
+                                measurement_unit unit = create_measurement_unit_from_filesystem(*filesystem, config.display_mntp);
+                                unit.name = strdup(filesystem->group);
+                                measurements = current = add_measurement_list(NULL, unit);
                         } else {
-                                xasprintf(&output, "%s inode=%.0f%%)%s;", output, path->dfree_inodes_percent, ((disk_result && verbose >= 1) ? "]" : ""));
+                                // if this is the first element of a group, the name of the previous entry is different
+                                if (strcmp(filesystem->group, current->unit.name) != 0) {
+                                        // so, this must be the first element of a group
+                                        measurement_unit unit = create_measurement_unit_from_filesystem(*filesystem, config.display_mntp);
+                                        unit.name = filesystem->group;
+                                        current = add_measurement_list(measurements, unit);
+
+                                } else {
+                                        // NOT the first entry of a group, add info to the other one
+                                        current->unit = add_filesystem_to_measurement_unit(current->unit, *filesystem);
+                                }
                         }
-                        free(flag_header);
                 }
         }
 
-        if (verbose >= 2)
-                xasprintf(&output, "%s%s", output, details);
+        /* Process for every path in list */
+        if (measurements != NULL) {
+                for (measurement_unit_list *unit = measurements; unit; unit = unit->next) {
+                        mp_subcheck unit_sc = evaluate_filesystem(unit->unit, config.display_inodes_perfdata, config.display_unit);
+                        mp_add_subcheck_to_check(&overall, unit_sc);
+                }
+        } else {
+                // Apparently no machting fs found
+                mp_subcheck none_sc = mp_subcheck_init();
+                xasprintf(&none_sc.output, "No filesystems were found for the provided parameters");
 
-        if (strcmp(output, "") == 0 && !erronly) {
-                preamble = "";
-                xasprintf(&output, " - No disks were found for provided parameters");
+                if (config.ignore_missing) {
+                        none_sc = mp_set_subcheck_state(none_sc, STATE_OK);
+                } else {
+                        none_sc = mp_set_subcheck_state(none_sc, STATE_UNKNOWN);
+                }
+                mp_add_subcheck_to_check(&overall, none_sc);
         }
 
-        printf("DISK %s%s%s%s%s|%s\n", state_text(result), ((erronly && result == STATE_OK)) ? "" : preamble, output,
-                   (strcmp(ignored, "") == 0) ? "" : ignored_preamble, ignored, perf);
-        return result;
+        mp_exit(overall);
 }
 
 double calculate_percent(uintmax_t value, uintmax_t total) {
         double pct = -1;
         if (value <= DBL_MAX && total != 0) {
-                pct = (double)value / total * 100.0;
+                pct = (double)value / (double)total * 100.0;
         }
+
         return pct;
 }
 
 /* process command-line arguments */
-int process_arguments(int argc, char **argv) {
-        int c;
-        int err;
-        struct parameter_list *se;
-        struct parameter_list *temp_list = NULL;
-        struct parameter_list *previous = NULL;
-        struct mount_entry *me;
-        regex_t re;
-        int cflags = REG_NOSUB | REG_EXTENDED;
-        int default_cflags = cflags;
-        char errbuf[MAX_INPUT_BUFFER];
-        int fnd = 0;
+check_disk_config_wrapper process_arguments(int argc, char **argv) {
+
+        check_disk_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_disk_config_init(),
+        };
+
+        if (argc < 2) {
+                result.errorcode = ERROR;
+                return result;
+        }
+
+        enum {
+                output_format_index = CHAR_MAX + 1,
+                display_unit_index,
+        };
 
-        int option = 0;
         static struct option longopts[] = {{"timeout", required_argument, 0, 't'},
                                                                            {"warning", required_argument, 0, 'w'},
                                                                            {"critical", required_argument, 0, 'c'},
                                                                            {"iwarning", required_argument, 0, 'W'},
-                                                                           /* Dang, -C is taken. We might want to reshuffle this. */
                                                                            {"icritical", required_argument, 0, 'K'},
                                                                            {"kilobytes", no_argument, 0, 'k'},
                                                                            {"megabytes", no_argument, 0, 'm'},
@@ -507,24 +404,42 @@ int process_arguments(int argc, char **argv) {
                                                                            {"clear", no_argument, 0, 'C'},
                                                                            {"version", no_argument, 0, 'V'},
                                                                            {"help", no_argument, 0, 'h'},
+                                                                           {"output-format", required_argument, 0, output_format_index},
+                                                                           {"display-unit", required_argument, 0, display_unit_index},
                                                                            {0, 0, 0, 0}};
 
-        if (argc < 2)
-                return ERROR;
+        for (int index = 1; index < argc; index++) {
+                if (strcmp("-to", argv[index]) == 0) {
+                        strcpy(argv[index], "-t");
+                }
+        }
+
+        int cflags = REG_NOSUB | REG_EXTENDED;
+        int default_cflags = cflags;
+        char *warn_freespace_units = NULL;
+        char *crit_freespace_units = NULL;
+        char *warn_freespace_percent = NULL;
+        char *crit_freespace_percent = NULL;
+        char *warn_freeinodes_percent = NULL;
+        char *crit_freeinodes_percent = NULL;
+
+        bool path_selected = false;
+        char *group = NULL;
+        byte_unit unit = MebiBytes_factor;
 
-        np_add_regex(&fs_exclude_list, "iso9660", REG_EXTENDED);
+        result.config.mount_list = read_file_system_list(false);
 
-        for (c = 1; c < argc; c++)
-                if (strcmp("-to", argv[c]) == 0)
-                        strcpy(argv[c], "-t");
+        np_add_regex(&result.config.fs_exclude_list, "iso9660", REG_EXTENDED);
 
-        while (1) {
-                c = getopt_long(argc, argv, "+?VqhvefCt:c:w:K:W:u:p:x:X:N:mklLPg:R:r:i:I:MEAn", longopts, &option);
+        while (true) {
+                int option = 0;
+                int option_index = getopt_long(argc, argv, "+?VqhvefCt:c:w:K:W:u:p:x:X:N:mklLPg:R:r:i:I:MEAn", longopts, &option);
 
-                if (c == -1 || c == EOF)
+                if (option_index == -1 || option_index == EOF) {
                         break;
+                }
 
-                switch (c) {
+                switch (option_index) {
                 case 't': /* timeout period */
                         if (is_integer(optarg)) {
                                 timeout_interval = atoi(optarg);
@@ -555,10 +470,10 @@ int process_arguments(int argc, char **argv) {
                         break;
 
                 /* Awful mistake where the range values do not make sense. Normally,
-                   you alert if the value is within the range, but since we are using
-                   freespace, we have to alert if outside the range. Thus we artificially
-                   force @ at the beginning of the range, so that it is backwards compatible
-                */
+                 * you alert if the value is within the range, but since we are using
+                 * freespace, we have to alert if outside the range. Thus we artificially
+                 * force @ at the beginning of the range, so that it is backwards compatible
+                 */
                 case 'c': /* critical threshold */
                         if (!is_percentage_expression(optarg) && !is_numeric(optarg)) {
                                 die(STATE_UNKNOWN, "Argument for --critical invalid or missing: %s\n", optarg);
@@ -594,181 +509,184 @@ int process_arguments(int argc, char **argv) {
                         }
                         break;
                 case 'u':
-                        if (units)
-                                free(units);
                         if (!strcasecmp(optarg, "bytes")) {
-                                mult = (uintmax_t)1;
-                                units = strdup("B");
+                                unit = Bytes_Factor;
                         } else if (!strcmp(optarg, "KiB")) {
-                                mult = (uintmax_t)1024;
-                                units = strdup("KiB");
+                                unit = KibiBytes_factor;
                         } else if (!strcmp(optarg, "kB")) {
-                                mult = (uintmax_t)1000;
-                                units = strdup("kB");
+                                unit = KiloBytes_factor;
                         } else if (!strcmp(optarg, "MiB")) {
-                                mult = (uintmax_t)1024 * 1024;
-                                units = strdup("MiB");
+                                unit = MebiBytes_factor;
                         } else if (!strcmp(optarg, "MB")) {
-                                mult = (uintmax_t)1000 * 1000;
-                                units = strdup("MB");
+                                unit = MegaBytes_factor;
                         } else if (!strcmp(optarg, "GiB")) {
-                                mult = (uintmax_t)1024 * 1024 * 1024;
-                                units = strdup("GiB");
+                                unit = GibiBytes_factor;
                         } else if (!strcmp(optarg, "GB")) {
-                                mult = (uintmax_t)1000 * 1000 * 1000;
-                                units = strdup("GB");
+                                unit = GigaBytes_factor;
                         } else if (!strcmp(optarg, "TiB")) {
-                                mult = (uintmax_t)1024 * 1024 * 1024 * 1024;
-                                units = strdup("TiB");
+                                unit = TebiBytes_factor;
                         } else if (!strcmp(optarg, "TB")) {
-                                mult = (uintmax_t)1000 * 1000 * 1000 * 1000;
-                                units = strdup("TB");
+                                unit = TeraBytes_factor;
                         } else if (!strcmp(optarg, "PiB")) {
-                                mult = (uintmax_t)1024 * 1024 * 1024 * 1024 * 1024;
-                                units = strdup("PiB");
+                                unit = PebiBytes_factor;
                         } else if (!strcmp(optarg, "PB")) {
-                                mult = (uintmax_t)1000 * 1000 * 1000 * 1000 * 1000;
-                                units = strdup("PB");
+                                unit = PetaBytes_factor;
                         } else {
                                 die(STATE_UNKNOWN, _("unit type %s not known\n"), optarg);
                         }
-                        if (units == NULL)
-                                die(STATE_UNKNOWN, _("failed allocating storage for '%s'\n"), "units");
                         break;
-                case 'k': /* display mountpoint */
-                        mult = 1024;
-                        if (units)
-                                free(units);
-                        units = strdup("kiB");
+                case 'k':
+                        unit = KibiBytes_factor;
+                        break;
+                case 'm':
+                        unit = MebiBytes_factor;
                         break;
-                case 'm': /* display mountpoint */
-                        mult = 1024 * 1024;
-                        if (units)
-                                free(units);
-                        units = strdup("MiB");
+                case display_unit_index:
+                        if (!strcasecmp(optarg, "bytes")) {
+                                result.config.display_unit = Bytes;
+                        } else if (!strcmp(optarg, "KiB")) {
+                                result.config.display_unit = KibiBytes;
+                        } else if (!strcmp(optarg, "kB")) {
+                                result.config.display_unit = KiloBytes;
+                        } else if (!strcmp(optarg, "MiB")) {
+                                result.config.display_unit = MebiBytes;
+                        } else if (!strcmp(optarg, "MB")) {
+                                result.config.display_unit = MegaBytes;
+                        } else if (!strcmp(optarg, "GiB")) {
+                                result.config.display_unit = GibiBytes;
+                        } else if (!strcmp(optarg, "GB")) {
+                                result.config.display_unit = GigaBytes;
+                        } else if (!strcmp(optarg, "TiB")) {
+                                result.config.display_unit = TebiBytes;
+                        } else if (!strcmp(optarg, "TB")) {
+                                result.config.display_unit = TeraBytes;
+                        } else if (!strcmp(optarg, "PiB")) {
+                                result.config.display_unit = PebiBytes;
+                        } else if (!strcmp(optarg, "PB")) {
+                                result.config.display_unit = PetaBytes;
+                        } else {
+                                die(STATE_UNKNOWN, _("unit type %s not known\n"), optarg);
+                        }
                         break;
                 case 'L':
-                        stat_remote_fs = 1;
+                        result.config.stat_remote_fs = true;
                         /* fallthrough */
                 case 'l':
-                        show_local_fs = 1;
+                        result.config.show_local_fs = true;
                         break;
                 case 'P':
-                        display_inodes_perfdata = 1;
+                        result.config.display_inodes_perfdata = true;
                         break;
-                case 'p': /* select path */
+                case 'p': /* select path */ {
                         if (!(warn_freespace_units || crit_freespace_units || warn_freespace_percent || crit_freespace_percent ||
-                                  warn_usedspace_units || crit_usedspace_units || warn_usedspace_percent || crit_usedspace_percent ||
-                                  warn_usedinodes_percent || crit_usedinodes_percent || warn_freeinodes_percent || crit_freeinodes_percent)) {
+                                  warn_freeinodes_percent || crit_freeinodes_percent)) {
                                 die(STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set a threshold value before using -p\n"));
                         }
 
                         /* add parameter if not found. overwrite thresholds if path has already been added  */
-                        if (!(se = np_find_parameter(path_select_list, optarg))) {
-                                se = np_add_parameter(&path_select_list, optarg);
-
-                                if (stat(optarg, &stat_buf[0]) && ignore_missing == true) {
-                                        path_ignored = true;
-                                        break;
-                                }
+                        parameter_list_elem *search_entry;
+                        if (!(search_entry = mp_int_fs_list_find(result.config.path_select_list, optarg))) {
+                                search_entry = mp_int_fs_list_append(&result.config.path_select_list, optarg);
+
+                                // struct stat stat_buf = {};
+                                // if (stat(optarg, &stat_buf) && result.config.ignore_missing) {
+                                // result.config.path_ignored = true;
+                                // break;
+                                // }
                         }
-                        se->group = group;
-                        set_all_thresholds(se);
+                        search_entry->group = group;
+                        set_all_thresholds(search_entry, warn_freespace_units, crit_freespace_units, warn_freespace_percent, crit_freespace_percent,
+
+                                                           warn_freeinodes_percent, crit_freeinodes_percent);
 
                         /* With autofs, it is required to stat() the path before re-populating the mount_list */
-                        if (!stat_path(se)) {
-                                break;
-                        }
-                        /* NB: We can't free the old mount_list "just like that": both list pointers and struct
-                         * pointers are copied around. One of the reason it wasn't done yet is that other parts
-                         * of check_disk need the same kind of cleanup so it'd better be done as a whole */
-                        mount_list = read_file_system_list(0);
-                        np_set_best_match(se, mount_list, exact_match);
+                        // if (!stat_path(se, result.config.ignore_missing)) {
+                        // break;
+                        // }
+                        mp_int_fs_list_set_best_match(result.config.path_select_list, result.config.mount_list, result.config.exact_match);
 
                         path_selected = true;
-                        break;
+                } break;
                 case 'x': /* exclude path or partition */
-                        np_add_name(&dp_exclude_list, optarg);
+                        np_add_name(&result.config.device_path_exclude_list, optarg);
                         break;
-                case 'X': /* exclude file system type */
-                        err = np_add_regex(&fs_exclude_list, optarg, REG_EXTENDED);
+                case 'X': /* exclude file system type */ {
+                        int err = np_add_regex(&result.config.fs_exclude_list, optarg, REG_EXTENDED);
                         if (err != 0) {
-                                regerror(err, &fs_exclude_list->regex, errbuf, MAX_INPUT_BUFFER);
+                                char errbuf[MAX_INPUT_BUFFER];
+                                regerror(err, &result.config.fs_exclude_list->regex, errbuf, MAX_INPUT_BUFFER);
                                 die(STATE_UNKNOWN, "DISK %s: %s - %s\n", _("UNKNOWN"), _("Could not compile regular expression"), errbuf);
                         }
                         break;
                 case 'N': /* include file system type */
-                        err = np_add_regex(&fs_include_list, optarg, REG_EXTENDED);
+                        err = np_add_regex(&result.config.fs_include_list, optarg, REG_EXTENDED);
                         if (err != 0) {
-                                regerror(err, &fs_exclude_list->regex, errbuf, MAX_INPUT_BUFFER);
+                                char errbuf[MAX_INPUT_BUFFER];
+                                regerror(err, &result.config.fs_exclude_list->regex, errbuf, MAX_INPUT_BUFFER);
                                 die(STATE_UNKNOWN, "DISK %s: %s - %s\n", _("UNKNOWN"), _("Could not compile regular expression"), errbuf);
                         }
-                        break;
+                } break;
                 case 'v': /* verbose */
                         verbose++;
                         break;
                 case 'q': /* TODO: this function should eventually go away (removed 2007-09-20) */
                         /* verbose--; **replaced by line below**. -q was only a broken way of implementing -e */
-                        erronly = true;
+                        result.config.erronly = true;
                         break;
                 case 'e':
-                        erronly = true;
+                        result.config.erronly = true;
                         break;
                 case 'E':
-                        if (path_selected)
+                        if (path_selected) {
                                 die(STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set -E before selecting paths\n"));
-                        exact_match = true;
+                        }
+                        result.config.exact_match = true;
                         break;
                 case 'f':
-                        freespace_ignore_reserved = true;
+                        result.config.freespace_ignore_reserved = true;
                         break;
                 case 'g':
-                        if (path_selected)
+                        if (path_selected) {
                                 die(STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set group value before selecting paths\n"));
+                        }
                         group = optarg;
                         break;
                 case 'I':
                         cflags |= REG_ICASE;
                         // Intentional fallthrough
-                case 'i':
-                        if (!path_selected)
+                case 'i': {
+                        if (!path_selected) {
                                 die(STATE_UNKNOWN, "DISK %s: %s\n", _("UNKNOWN"),
                                         _("Paths need to be selected before using -i/-I. Use -A to select all paths explicitly"));
-                        err = regcomp(&re, optarg, cflags);
+                        }
+                        regex_t regex;
+                        int err = regcomp(&regex, optarg, cflags);
                         if (err != 0) {
-                                regerror(err, &re, errbuf, MAX_INPUT_BUFFER);
+                                char errbuf[MAX_INPUT_BUFFER];
+                                regerror(err, &regex, errbuf, MAX_INPUT_BUFFER);
                                 die(STATE_UNKNOWN, "DISK %s: %s - %s\n", _("UNKNOWN"), _("Could not compile regular expression"), errbuf);
                         }
 
-                        temp_list = path_select_list;
-
-                        previous = NULL;
-                        while (temp_list) {
-                                if (temp_list->best_match) {
-                                        if (np_regex_match_mount_entry(temp_list->best_match, &re)) {
+                        for (parameter_list_elem *elem = result.config.path_select_list.first; elem;) {
+                                if (elem->best_match) {
+                                        if (np_regex_match_mount_entry(elem->best_match, &regex)) {
 
-                                                if (verbose >= 3)
-                                                        printf("ignoring %s matching regex\n", temp_list->name);
+                                                if (verbose >= 3) {
+                                                        printf("ignoring %s matching regex\n", elem->name);
+                                                }
 
-                                                temp_list = np_del_parameter(temp_list, previous);
-                                                /* pointer to first element needs to be updated if first item gets deleted */
-                                                if (previous == NULL)
-                                                        path_select_list = temp_list;
-                                        } else {
-                                                previous = temp_list;
-                                                temp_list = temp_list->name_next;
+                                                elem = mp_int_fs_list_del(&result.config.path_select_list, elem);
+                                                continue;
                                         }
-                                } else {
-                                        previous = temp_list;
-                                        temp_list = temp_list->name_next;
                                 }
+
+                                elem = mp_int_fs_list_get_next(elem);
                         }
 
                         cflags = default_cflags;
-                        break;
-
+                } break;
                 case 'n':
-                        ignore_missing = true;
+                        result.config.ignore_missing = true;
                         break;
                 case 'A':
                         optarg = strdup(".*");
@@ -776,80 +694,83 @@ int process_arguments(int argc, char **argv) {
                 case 'R':
                         cflags |= REG_ICASE;
                         // Intentional fallthrough
-                case 'r':
+                case 'r': {
                         if (!(warn_freespace_units || crit_freespace_units || warn_freespace_percent || crit_freespace_percent ||
-                                  warn_usedspace_units || crit_usedspace_units || warn_usedspace_percent || crit_usedspace_percent ||
-                                  warn_usedinodes_percent || crit_usedinodes_percent || warn_freeinodes_percent || crit_freeinodes_percent)) {
+                                  warn_freeinodes_percent || crit_freeinodes_percent)) {
                                 die(STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"),
                                         _("Must set a threshold value before using -r/-R/-A (--ereg-path/--eregi-path/--all)\n"));
                         }
 
-                        err = regcomp(&re, optarg, cflags);
+                        regex_t regex;
+                        int err = regcomp(&regex, optarg, cflags);
                         if (err != 0) {
-                                regerror(err, &re, errbuf, MAX_INPUT_BUFFER);
+                                char errbuf[MAX_INPUT_BUFFER];
+                                regerror(err, &regex, errbuf, MAX_INPUT_BUFFER);
                                 die(STATE_UNKNOWN, "DISK %s: %s - %s\n", _("UNKNOWN"), _("Could not compile regular expression"), errbuf);
                         }
 
-                        for (me = mount_list; me; me = me->me_next) {
-                                if (np_regex_match_mount_entry(me, &re)) {
-                                        fnd = true;
-                                        if (verbose >= 3)
+                        bool found = false;
+                        for (struct mount_entry *me = result.config.mount_list; me; me = me->me_next) {
+                                if (np_regex_match_mount_entry(me, &regex)) {
+                                        found = true;
+                                        if (verbose >= 3) {
                                                 printf("%s %s matching expression %s\n", me->me_devname, me->me_mountdir, optarg);
+                                        }
 
                                         /* add parameter if not found. overwrite thresholds if path has already been added  */
-                                        if (!(se = np_find_parameter(path_select_list, me->me_mountdir))) {
-                                                se = np_add_parameter(&path_select_list, me->me_mountdir);
+                                        parameter_list_elem *se = NULL;
+                                        if (!(se = mp_int_fs_list_find(result.config.path_select_list, me->me_mountdir))) {
+                                                se = mp_int_fs_list_append(&result.config.path_select_list, me->me_mountdir);
                                         }
                                         se->group = group;
-                                        set_all_thresholds(se);
+                                        set_all_thresholds(se, warn_freespace_units, crit_freespace_units, warn_freespace_percent, crit_freespace_percent,
+                                                                           warn_freeinodes_percent, crit_freeinodes_percent);
                                 }
                         }
 
-                        if (!fnd && ignore_missing == true) {
-                                path_ignored = true;
-                                path_selected = true;
-                                break;
-                        }
-                        if (!fnd)
+                        if (!found) {
+                                if (result.config.ignore_missing) {
+                                        result.config.path_ignored = true;
+                                        path_selected = true;
+                                        break;
+                                }
+
                                 die(STATE_UNKNOWN, "DISK %s: %s - %s\n", _("UNKNOWN"), _("Regular expression did not match any path or disk"), optarg);
+                        }
 
-                        fnd = false;
                         path_selected = true;
-                        np_set_best_match(path_select_list, mount_list, exact_match);
+                        mp_int_fs_list_set_best_match(result.config.path_select_list, result.config.mount_list, result.config.exact_match);
                         cflags = default_cflags;
 
-                        break;
+                } break;
                 case 'M': /* display mountpoint */
-                        display_mntp = true;
+                        result.config.display_mntp = true;
                         break;
-                case 'C':
+                case 'C': {
                         /* add all mount entries to path_select list if no partitions have been explicitly defined using -p */
-                        if (path_selected == false) {
-                                struct parameter_list *path;
-                                for (me = mount_list; me; me = me->me_next) {
-                                        if (!(path = np_find_parameter(path_select_list, me->me_mountdir)))
-                                                path = np_add_parameter(&path_select_list, me->me_mountdir);
+                        if (!path_selected) {
+                                parameter_list_elem *path;
+                                for (struct mount_entry *me = result.config.mount_list; me; me = me->me_next) {
+                                        if (!(path = mp_int_fs_list_find(result.config.path_select_list, me->me_mountdir))) {
+                                                path = mp_int_fs_list_append(&result.config.path_select_list, me->me_mountdir);
+                                        }
                                         path->best_match = me;
                                         path->group = group;
-                                        set_all_thresholds(path);
+                                        set_all_thresholds(path, warn_freespace_units, crit_freespace_units, warn_freespace_percent, crit_freespace_percent,
+                                                                           warn_freeinodes_percent, crit_freeinodes_percent);
                                 }
                         }
+
                         warn_freespace_units = NULL;
                         crit_freespace_units = NULL;
-                        warn_usedspace_units = NULL;
-                        crit_usedspace_units = NULL;
                         warn_freespace_percent = NULL;
                         crit_freespace_percent = NULL;
-                        warn_usedspace_percent = NULL;
-                        crit_usedspace_percent = NULL;
-                        warn_usedinodes_percent = NULL;
-                        crit_usedinodes_percent = NULL;
                         warn_freeinodes_percent = NULL;
                         crit_freeinodes_percent = NULL;
 
                         path_selected = false;
                         group = NULL;
-                        break;
+                } break;
                 case 'V': /* version */
                         print_revision(progname, NP_VERSION);
                         exit(STATE_UNKNOWN);
@@ -858,50 +779,145 @@ int process_arguments(int argc, char **argv) {
                         exit(STATE_UNKNOWN);
                 case '?': /* help */
                         usage(_("Unknown argument"));
+                case output_format_index: {
+                        parsed_output_format parser = mp_parse_output_format(optarg);
+                        if (!parser.parsing_success) {
+                                // TODO List all available formats here, maybe add anothoer usage function
+                                printf("Invalid output format: %s\n", optarg);
+                                exit(STATE_UNKNOWN);
+                        }
+
+                        result.config.output_format_is_set = true;
+                        result.config.output_format = parser.output_format;
+                        break;
+                }
                 }
         }
 
         /* Support for "check_disk warn crit [fs]" with thresholds at used% level */
-        c = optind;
-        if (warn_usedspace_percent == NULL && argc > c && is_intnonneg(argv[c]))
-                warn_usedspace_percent = argv[c++];
+        int index = optind;
+
+        if (argc > index && is_intnonneg(argv[index])) {
+                if (verbose > 0) {
+                        printf("Got an positional warn threshold: %s\n", argv[index]);
+                }
+                char *range = argv[index++];
+                mp_range_parsed tmp = mp_parse_range_string(range);
+                if (tmp.error != MP_PARSING_SUCCES) {
+                        die(STATE_UNKNOWN, "failed to parse warning threshold");
+                }
+
+                mp_range tmp_range = tmp.range;
+                // Invert range to use it for free instead of used
+                // tmp_range.alert_on_inside_range = !tmp_range.alert_on_inside_range;
 
-        if (crit_usedspace_percent == NULL && argc > c && is_intnonneg(argv[c]))
-                crit_usedspace_percent = argv[c++];
+                warn_freespace_percent = mp_range_to_string(tmp_range);
 
-        if (argc > c) {
-                se = np_add_parameter(&path_select_list, strdup(argv[c++]));
+                if (verbose > 0) {
+                        printf("Positional warning threshold transformed to: %s\n", warn_freespace_percent);
+                }
+        }
+
+        if (argc > index && is_intnonneg(argv[index])) {
+                if (verbose > 0) {
+                        printf("Got an positional crit threshold: %s\n", argv[index]);
+                }
+                char *range = argv[index++];
+                mp_range_parsed tmp = mp_parse_range_string(range);
+                if (tmp.error != MP_PARSING_SUCCES) {
+                        die(STATE_UNKNOWN, "failed to parse warning threshold");
+                }
+
+                mp_range tmp_range = tmp.range;
+                // Invert range to use it for free instead of used
+                // tmp_range.alert_on_inside_range = !tmp_range.alert_on_inside_range;
+
+                crit_freespace_percent = mp_range_to_string(tmp_range);
+
+                if (verbose > 0) {
+                        printf("Positional critical threshold transformed to: %s\n", crit_freespace_percent);
+                }
+        }
+
+        if (argc > index) {
+                if (verbose > 0) {
+                        printf("Got an positional filesystem: %s\n", argv[index]);
+                }
+                struct parameter_list *se = mp_int_fs_list_append(&result.config.path_select_list, strdup(argv[index++]));
                 path_selected = true;
-                set_all_thresholds(se);
+                set_all_thresholds(se, warn_freespace_units, crit_freespace_units, warn_freespace_percent, crit_freespace_percent,
+                                                   warn_freeinodes_percent, crit_freeinodes_percent);
+        }
+
+        // If a list of paths has not been explicitly selected, find entire
+        // mount list and create list of paths
+        if (!path_selected && !result.config.path_ignored) {
+                for (struct mount_entry *me = result.config.mount_list; me; me = me->me_next) {
+                        if (me->me_dummy != 0) {
+                                // just do not add dummy filesystems
+                                continue;
+                        }
+
+                        parameter_list_elem *path = NULL;
+                        if (!(path = mp_int_fs_list_find(result.config.path_select_list, me->me_mountdir))) {
+                                path = mp_int_fs_list_append(&result.config.path_select_list, me->me_mountdir);
+                        }
+                        path->best_match = me;
+                        path->group = group;
+                        set_all_thresholds(path, warn_freespace_units, crit_freespace_units, warn_freespace_percent, crit_freespace_percent,
+                                                           warn_freeinodes_percent, crit_freeinodes_percent);
+                }
         }
 
-        if (units == NULL) {
-                units = strdup("MiB");
-                mult = (uintmax_t)1024 * 1024;
+        // Set thresholds to the appropriate unit
+        for (parameter_list_elem *tmp = result.config.path_select_list.first; tmp; tmp = mp_int_fs_list_get_next(tmp)) {
+
+                mp_perfdata_value factor = mp_create_pd_value(unit);
+
+                if (tmp->freespace_units.critical_is_set) {
+                        tmp->freespace_units.critical = mp_range_multiply(tmp->freespace_units.critical, factor);
+                }
+                if (tmp->freespace_units.warning_is_set) {
+                        tmp->freespace_units.warning = mp_range_multiply(tmp->freespace_units.warning, factor);
+                }
         }
 
-        return true;
+        return result;
 }
 
-void set_all_thresholds(struct parameter_list *path) {
-        if (path->freespace_units != NULL)
-                free(path->freespace_units);
-        set_thresholds(&path->freespace_units, warn_freespace_units, crit_freespace_units);
-        if (path->freespace_percent != NULL)
-                free(path->freespace_percent);
-        set_thresholds(&path->freespace_percent, warn_freespace_percent, crit_freespace_percent);
-        if (path->usedspace_units != NULL)
-                free(path->usedspace_units);
-        set_thresholds(&path->usedspace_units, warn_usedspace_units, crit_usedspace_units);
-        if (path->usedspace_percent != NULL)
-                free(path->usedspace_percent);
-        set_thresholds(&path->usedspace_percent, warn_usedspace_percent, crit_usedspace_percent);
-        if (path->usedinodes_percent != NULL)
-                free(path->usedinodes_percent);
-        set_thresholds(&path->usedinodes_percent, warn_usedinodes_percent, crit_usedinodes_percent);
-        if (path->freeinodes_percent != NULL)
-                free(path->freeinodes_percent);
-        set_thresholds(&path->freeinodes_percent, warn_freeinodes_percent, crit_freeinodes_percent);
+void set_all_thresholds(parameter_list_elem *path, char *warn_freespace_units, char *crit_freespace_units, char *warn_freespace_percent,
+                                                char *crit_freespace_percent, char *warn_freeinodes_percent, char *crit_freeinodes_percent) {
+        mp_range_parsed tmp;
+
+        if (warn_freespace_units) {
+                tmp = mp_parse_range_string(warn_freespace_units);
+                path->freespace_units = mp_thresholds_set_warn(path->freespace_units, tmp.range);
+        }
+
+        if (crit_freespace_units) {
+                tmp = mp_parse_range_string(crit_freespace_units);
+                path->freespace_units = mp_thresholds_set_crit(path->freespace_units, tmp.range);
+        }
+
+        if (warn_freespace_percent) {
+                tmp = mp_parse_range_string(warn_freespace_percent);
+                path->freespace_percent = mp_thresholds_set_warn(path->freespace_percent, tmp.range);
+        }
+
+        if (crit_freespace_percent) {
+                tmp = mp_parse_range_string(crit_freespace_percent);
+                path->freespace_percent = mp_thresholds_set_crit(path->freespace_percent, tmp.range);
+        }
+
+        if (warn_freeinodes_percent) {
+                tmp = mp_parse_range_string(warn_freeinodes_percent);
+                path->freeinodes_percent = mp_thresholds_set_warn(path->freeinodes_percent, tmp.range);
+        }
+
+        if (crit_freeinodes_percent) {
+                tmp = mp_parse_range_string(crit_freeinodes_percent);
+                path->freeinodes_percent = mp_thresholds_set_crit(path->freeinodes_percent, tmp.range);
+        }
 }
 
 void print_help(void) {
@@ -948,8 +964,6 @@ void print_help(void) {
         printf("    %s\n", _("Display inode usage in perfdata"));
         printf(" %s\n", "-g, --group=NAME");
         printf("    %s\n", _("Group paths. Thresholds apply to (free-)space of all partitions together"));
-        printf(" %s\n", "-k, --kilobytes");
-        printf("    %s\n", _("Same as '--units kB'"));
         printf(" %s\n", "-l, --local");
         printf("    %s\n", _("Only check local filesystems"));
         printf(" %s\n", "-L, --stat-remote-fs");
@@ -957,8 +971,6 @@ void print_help(void) {
         printf("    %s\n", _("to test if they are accessible (e.g. to detect Stale NFS Handles)"));
         printf(" %s\n", "-M, --mountpoint");
         printf("    %s\n", _("Display the (block) device instead of the mount point"));
-        printf(" %s\n", "-m, --megabytes");
-        printf("    %s\n", _("Same as '--units MB'"));
         printf(" %s\n", "-A, --all");
         printf("    %s\n", _("Explicitly select all paths. This is equivalent to -R '.*'"));
         printf(" %s\n", "-R, --eregi-path=PATH, --eregi-partition=PARTITION");
@@ -974,12 +986,25 @@ void print_help(void) {
         printf("    %s\n", _("(Provide this option before -p / -r / --ereg-path if used)"));
         printf(UT_PLUG_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
         printf(" %s\n", "-u, --units=STRING");
-        printf("    %s\n", _("Choose bytes, kB, MB, GB, TB (default: MB)"));
+        printf("    %s\n", _("Select the unit used for the absolute value thresholds"));
+        printf(
+                "    %s\n",
+                _("Choose one of \"bytes\", \"KiB\", \"kB\", \"MiB\", \"MB\", \"GiB\", \"GB\", \"TiB\", \"TB\", \"PiB\", \"PB\" (default: MiB)"));
+        printf(" %s\n", "-k, --kilobytes");
+        printf("    %s\n", _("Same as '--units kB'"));
+        printf(" %s\n", "--display-unit");
+        printf("    %s\n", _("Select the unit used for in the output"));
+        printf(
+                "    %s\n",
+                _("Choose one of \"bytes\", \"KiB\", \"kB\", \"MiB\", \"MB\", \"GiB\", \"GB\", \"TiB\", \"TB\", \"PiB\", \"PB\" (default: MiB)"));
+        printf(" %s\n", "-m, --megabytes");
+        printf("    %s\n", _("Same as '--units MB'"));
         printf(UT_VERBOSE);
         printf(" %s\n", "-X, --exclude-type=TYPE_REGEX");
         printf("    %s\n", _("Ignore all filesystems of types matching given regex(7) (may be repeated)"));
         printf(" %s\n", "-N, --include-type=TYPE_REGEX");
         printf("    %s\n", _("Check only filesystems where the type matches this given regex(7) (may be repeated)"));
+        printf(UT_OUTPUT_FORMAT);
 
         printf("\n");
         printf("%s\n", _("General usage hints:"));
@@ -1009,105 +1034,187 @@ void print_usage(void) {
         printf("[-t timeout] [-u unit] [-v] [-X type_regex] [-N type]\n");
 }
 
-bool stat_path(struct parameter_list *p) {
+bool stat_path(parameter_list_elem *parameters, bool ignore_missing) {
         /* Stat entry to check that dir exists and is accessible */
-        if (verbose >= 3)
-                printf("calling stat on %s\n", p->name);
-        if (stat(p->name, &stat_buf[0])) {
-                if (verbose >= 3)
-                        printf("stat failed on %s\n", p->name);
-                if (ignore_missing == true) {
+        if (verbose >= 3) {
+                printf("calling stat on %s\n", parameters->name);
+        }
+
+        struct stat stat_buf = {0};
+        if (stat(parameters->name, &stat_buf)) {
+                if (verbose >= 3) {
+                        printf("stat failed on %s\n", parameters->name);
+                }
+                if (ignore_missing) {
                         return false;
                 }
                 printf("DISK %s - ", _("CRITICAL"));
-                die(STATE_CRITICAL, _("%s %s: %s\n"), p->name, _("is not accessible"), strerror(errno));
+                die(STATE_CRITICAL, _("%s %s: %s\n"), parameters->name, _("is not accessible"), strerror(errno));
         }
+
         return true;
 }
 
-void get_stats(struct parameter_list *p, struct fs_usage *fsp) {
-        struct parameter_list *p_list;
-        struct fs_usage tmpfsp;
-        int first = 1;
+static parameter_list_elem get_path_stats(parameter_list_elem parameters, const struct fs_usage fsp, bool freespace_ignore_reserved) {
+        uintmax_t available = fsp.fsu_bavail;
+        uintmax_t available_to_root = fsp.fsu_bfree;
+        uintmax_t used = fsp.fsu_blocks - fsp.fsu_bfree;
+        uintmax_t total;
 
-        if (p->group == NULL) {
-                get_path_stats(p, fsp);
-        } else {
-                /* find all group members */
-                for (p_list = path_select_list; p_list; p_list = p_list->name_next) {
-#ifdef __CYGWIN__
-                        if (strncmp(p_list->name, "/cygdrive/", 10) != 0)
-                                continue;
-#endif
-                        if (p_list->group && !(strcmp(p_list->group, p->group))) {
-                                if (!stat_path(p_list))
-                                        continue;
-                                get_fs_usage(p_list->best_match->me_mountdir, p_list->best_match->me_devname, &tmpfsp);
-                                get_path_stats(p_list, &tmpfsp);
-                                if (verbose >= 3)
-                                        printf("Group %s: adding %lu blocks sized %lu, (%s) used_units=%lu free_units=%lu total_units=%lu mult=%lu\n",
-                                                   p_list->group, tmpfsp.fsu_blocks, tmpfsp.fsu_blocksize, p_list->best_match->me_mountdir, p_list->dused_units,
-                                                   p_list->dfree_units, p_list->dtotal_units, mult);
-
-                                /* prevent counting the first FS of a group twice since its parameter_list entry
-                                 * is used to carry the information of all file systems of the entire group */
-                                if (!first) {
-                                        p->total += p_list->total;
-                                        p->available += p_list->available;
-                                        p->available_to_root += p_list->available_to_root;
-                                        p->used += p_list->used;
-
-                                        p->dused_units += p_list->dused_units;
-                                        p->dfree_units += p_list->dfree_units;
-                                        p->dtotal_units += p_list->dtotal_units;
-                                        p->inodes_total += p_list->inodes_total;
-                                        p->inodes_free += p_list->inodes_free;
-                                        p->inodes_free_to_root += p_list->inodes_free_to_root;
-                                        p->inodes_used += p_list->inodes_used;
-                                }
-                                first = 0;
-                        }
-                        if (verbose >= 3)
-                                printf("Group %s now has: used_units=%lu free_units=%lu total_units=%lu fsu_blocksize=%lu mult=%lu\n", p->group,
-                                           p->dused_units, p->dfree_units, p->dtotal_units, tmpfsp.fsu_blocksize, mult);
-                }
-                /* modify devname and mountdir for output */
-                p->best_match->me_mountdir = p->best_match->me_devname = p->group;
-        }
-        /* finally calculate percentages for either plain FS or summed up group */
-        p->dused_pct = calculate_percent(p->used, p->used + p->available); /* used + available can never be > uintmax */
-        p->dfree_pct = 100.0 - p->dused_pct;
-        p->dused_inodes_percent = calculate_percent(p->inodes_total - p->inodes_free, p->inodes_total);
-        p->dfree_inodes_percent = 100 - p->dused_inodes_percent;
-}
-
-void get_path_stats(struct parameter_list *p, struct fs_usage *fsp) {
-        p->available = fsp->fsu_bavail;
-        p->available_to_root = fsp->fsu_bfree;
-        p->used = fsp->fsu_blocks - fsp->fsu_bfree;
         if (freespace_ignore_reserved) {
                 /* option activated : we subtract the root-reserved space from the total */
-                p->total = fsp->fsu_blocks - p->available_to_root + p->available;
+                total = fsp.fsu_blocks - available_to_root + available;
         } else {
                 /* default behaviour : take all the blocks into account */
-                p->total = fsp->fsu_blocks;
+                total = fsp.fsu_blocks;
         }
 
-        p->dused_units = p->used * fsp->fsu_blocksize / mult;
-        p->dfree_units = p->available * fsp->fsu_blocksize / mult;
-        p->dtotal_units = p->total * fsp->fsu_blocksize / mult;
+        parameters.used_bytes = used * fsp.fsu_blocksize;
+        parameters.free_bytes = available * fsp.fsu_blocksize;
+        parameters.total_bytes = total * fsp.fsu_blocksize;
+
         /* Free file nodes. Not sure the workaround is required, but in case...*/
-        p->inodes_free = fsp->fsu_ffree;
-        p->inodes_free_to_root = fsp->fsu_ffree; /* Free file nodes for root. */
-        p->inodes_used = fsp->fsu_files - fsp->fsu_ffree;
+        parameters.inodes_free = fsp.fsu_ffree;
+        parameters.inodes_free_to_root = fsp.fsu_ffree; /* Free file nodes for root. */
+        parameters.inodes_used = fsp.fsu_files - fsp.fsu_ffree;
+
         if (freespace_ignore_reserved) {
                 /* option activated : we subtract the root-reserved inodes from the total */
                 /* not all OS report fsp->fsu_favail, only the ones with statvfs syscall */
                 /* for others, fsp->fsu_ffree == fsp->fsu_favail */
-                p->inodes_total = fsp->fsu_files - p->inodes_free_to_root + p->inodes_free;
+                parameters.inodes_total = fsp.fsu_files - parameters.inodes_free_to_root + parameters.inodes_free;
         } else {
                 /* default behaviour : take all the inodes into account */
-                p->inodes_total = fsp->fsu_files;
+                parameters.inodes_total = fsp.fsu_files;
+        }
+
+        return parameters;
+}
+
+mp_subcheck evaluate_filesystem(measurement_unit measurement_unit, bool display_inodes_perfdata, byte_unit unit) {
+        mp_subcheck result = mp_subcheck_init();
+        result = mp_set_subcheck_default_state(result, STATE_UNKNOWN);
+        xasprintf(&result.output, "%s", measurement_unit.name);
+
+        if (!measurement_unit.is_group && measurement_unit.filesystem_type) {
+                xasprintf(&result.output, "%s (%s)", result.output, measurement_unit.filesystem_type);
         }
-        np_add_name(&seen, p->best_match->me_mountdir);
+
+        /* Threshold comparisons */
+
+        // ===============================
+        // Free space absolute values test
+        mp_subcheck freespace_bytes_sc = mp_subcheck_init();
+        freespace_bytes_sc = mp_set_subcheck_default_state(freespace_bytes_sc, STATE_OK);
+
+        if (unit != Humanized) {
+                xasprintf(&freespace_bytes_sc.output, "Free space absolute: %ju%s (of %ju%s)", (uintmax_t)(measurement_unit.free_bytes / unit),
+                                  get_unit_string(unit), (uintmax_t)(measurement_unit.total_bytes / unit), get_unit_string(unit));
+        } else {
+                xasprintf(&freespace_bytes_sc.output, "Free space absolute: %s (of %s)", humanize_byte_value(measurement_unit.free_bytes, false),
+                                  humanize_byte_value((unsigned long long)measurement_unit.total_bytes, false));
+        }
+
+        mp_perfdata used_space = perfdata_init();
+        used_space.label = measurement_unit.name;
+        used_space.value = mp_create_pd_value(measurement_unit.free_bytes);
+        used_space = mp_set_pd_max_value(used_space, mp_create_pd_value(measurement_unit.total_bytes));
+        used_space = mp_set_pd_min_value(used_space, mp_create_pd_value(0));
+        used_space.uom = "B";
+        used_space = mp_pd_set_thresholds(used_space, measurement_unit.freespace_bytes_thresholds);
+        freespace_bytes_sc = mp_set_subcheck_state(freespace_bytes_sc, mp_get_pd_status(used_space));
+
+        // special case for absolute space thresholds here:
+        // if absolute values are not set, compute the thresholds from percentage thresholds
+        mp_thresholds temp_thlds = measurement_unit.freespace_bytes_thresholds;
+        if (!temp_thlds.critical_is_set && measurement_unit.freespace_percent_thresholds.critical_is_set) {
+                mp_range tmp_range = measurement_unit.freespace_percent_thresholds.critical;
+
+                if (!tmp_range.end_infinity) {
+                        tmp_range.end = mp_create_pd_value(mp_get_pd_value(tmp_range.end) / 100 * measurement_unit.total_bytes);
+                }
+
+                if (!tmp_range.start_infinity) {
+                        tmp_range.start = mp_create_pd_value(mp_get_pd_value(tmp_range.start) / 100 * measurement_unit.total_bytes);
+                }
+                measurement_unit.freespace_bytes_thresholds = mp_thresholds_set_crit(measurement_unit.freespace_bytes_thresholds, tmp_range);
+                used_space = mp_pd_set_thresholds(used_space, measurement_unit.freespace_bytes_thresholds);
+        }
+
+        if (!temp_thlds.warning_is_set && measurement_unit.freespace_percent_thresholds.warning_is_set) {
+                mp_range tmp_range = measurement_unit.freespace_percent_thresholds.warning;
+                if (!tmp_range.end_infinity) {
+                        tmp_range.end = mp_create_pd_value(mp_get_pd_value(tmp_range.end) / 100 * measurement_unit.total_bytes);
+                }
+                if (!tmp_range.start_infinity) {
+                        tmp_range.start = mp_create_pd_value(mp_get_pd_value(tmp_range.start) / 100 * measurement_unit.total_bytes);
+                }
+                measurement_unit.freespace_bytes_thresholds = mp_thresholds_set_warn(measurement_unit.freespace_bytes_thresholds, tmp_range);
+                used_space = mp_pd_set_thresholds(used_space, measurement_unit.freespace_bytes_thresholds);
+        }
+
+        mp_add_perfdata_to_subcheck(&freespace_bytes_sc, used_space);
+        mp_add_subcheck_to_subcheck(&result, freespace_bytes_sc);
+
+        // ==========================
+        // Free space percentage test
+        mp_subcheck freespace_percent_sc = mp_subcheck_init();
+        freespace_percent_sc = mp_set_subcheck_default_state(freespace_percent_sc, STATE_OK);
+
+        double free_percentage = calculate_percent(measurement_unit.free_bytes, measurement_unit.total_bytes);
+        xasprintf(&freespace_percent_sc.output, "Free space percentage: %g%%", free_percentage);
+
+        // Using perfdata here just to get to the test result
+        mp_perfdata free_space_percent_pd = perfdata_init();
+        free_space_percent_pd.value = mp_create_pd_value(free_percentage);
+        free_space_percent_pd = mp_pd_set_thresholds(free_space_percent_pd, measurement_unit.freespace_percent_thresholds);
+
+        freespace_percent_sc = mp_set_subcheck_state(freespace_percent_sc, mp_get_pd_status(free_space_percent_pd));
+        mp_add_subcheck_to_subcheck(&result, freespace_percent_sc);
+
+        // ================
+        // Free inodes test
+        // Only ever useful if the number of inodes is static (e.g. ext4),
+        // not when it is dynamic (e.g btrfs)
+        // Assumption: if the total number of inodes == 0, we have such a case and just skip the test
+        if (measurement_unit.inodes_total > 0) {
+                mp_subcheck freeindodes_percent_sc = mp_subcheck_init();
+                freeindodes_percent_sc = mp_set_subcheck_default_state(freeindodes_percent_sc, STATE_OK);
+
+                double free_inode_percentage = calculate_percent(measurement_unit.inodes_free, measurement_unit.inodes_total);
+
+                if (verbose > 0) {
+                        printf("free inode percentage computed: %g\n", free_inode_percentage);
+                }
+
+                xasprintf(&freeindodes_percent_sc.output, "Inodes free: %g%% (%ju of %ju)", free_inode_percentage, measurement_unit.inodes_free,
+                                  measurement_unit.inodes_total);
+
+                mp_perfdata inodes_pd = perfdata_init();
+                xasprintf(&inodes_pd.label, "%s (inodes)", measurement_unit.name);
+                inodes_pd = mp_set_pd_value(inodes_pd, measurement_unit.inodes_used);
+                inodes_pd = mp_set_pd_max_value(inodes_pd, mp_create_pd_value(measurement_unit.inodes_total));
+                inodes_pd = mp_set_pd_min_value(inodes_pd, mp_create_pd_value(0));
+
+                mp_thresholds absolut_inode_thresholds = measurement_unit.freeinodes_percent_thresholds;
+
+                if (absolut_inode_thresholds.critical_is_set) {
+                        absolut_inode_thresholds.critical =
+                                mp_range_multiply(absolut_inode_thresholds.critical, mp_create_pd_value(measurement_unit.inodes_total / 100));
+                }
+                if (absolut_inode_thresholds.warning_is_set) {
+                        absolut_inode_thresholds.warning =
+                                mp_range_multiply(absolut_inode_thresholds.warning, mp_create_pd_value(measurement_unit.inodes_total / 100));
+                }
+
+                inodes_pd = mp_pd_set_thresholds(inodes_pd, absolut_inode_thresholds);
+
+                freeindodes_percent_sc = mp_set_subcheck_state(freeindodes_percent_sc, mp_get_pd_status(inodes_pd));
+                if (display_inodes_perfdata) {
+                        mp_add_perfdata_to_subcheck(&freeindodes_percent_sc, inodes_pd);
+                }
+                mp_add_subcheck_to_subcheck(&result, freeindodes_percent_sc);
+        }
+
+        return result;
 }
diff --git a/plugins/check_disk.d/utils_disk.c b/plugins/check_disk.d/utils_disk.c
new file mode 100644
index 00000000..eec1282b
--- /dev/null
+++ b/plugins/check_disk.d/utils_disk.c
@@ -0,0 +1,517 @@
+/*****************************************************************************
+ *
+ * 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 "../../lib/thresholds.h"
+#include "../../lib/states.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.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;
+        }
+        // regcomp failed
+        free(new_entry);
+
+        return regcomp_result;
+}
+
+parameter_list_elem parameter_list_init(const char *name) {
+        parameter_list_elem result = {
+                .name = strdup(name),
+                .best_match = NULL,
+
+                .freespace_units = mp_thresholds_init(),
+                .freespace_percent = mp_thresholds_init(),
+                .freeinodes_percent = mp_thresholds_init(),
+
+                .group = NULL,
+
+                .inodes_total = 0,
+                .inodes_free = 0,
+                .inodes_free_to_root = 0,
+                .inodes_used = 0,
+
+                .used_bytes = 0,
+                .free_bytes = 0,
+                .total_bytes = 0,
+
+                .next = NULL,
+                .prev = NULL,
+        };
+        return result;
+}
+
+/* Returns true if name is in list */
+bool np_find_name(struct name_list *list, const char *name) {
+        if (list == NULL || name == NULL) {
+                return false;
+        }
+        for (struct name_list *iterator = list; iterator; iterator = iterator->next) {
+                if (!strcmp(name, iterator->name)) {
+                        return true;
+                }
+        }
+        return false;
+}
+
+/* Returns true if name is in list */
+bool np_find_regmatch(struct regex_list *list, const char *name) {
+        if (name == NULL) {
+                return false;
+        }
+
+        size_t 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 */
+                regmatch_t dummy_match;
+                if (!regexec(&list->regex, name, 1, &dummy_match, 0) && dummy_match.rm_so == 0 && dummy_match.rm_eo == len) {
+                        return true;
+                }
+        }
+
+        return false;
+}
+
+bool np_seen_name(struct name_list *list, const char *name) {
+        for (struct name_list *iterator = list; iterator; iterator = iterator->next) {
+                if (!strcmp(iterator->name, name)) {
+                        return true;
+                }
+        }
+        return false;
+}
+
+bool np_regex_match_mount_entry(struct mount_entry *me, regex_t *re) {
+        return ((regexec(re, me->me_devname, (size_t)0, NULL, 0) == 0) || (regexec(re, me->me_mountdir, (size_t)0, NULL, 0) == 0));
+}
+
+check_disk_config check_disk_config_init() {
+        check_disk_config tmp = {
+                .erronly = false,
+                .display_mntp = false,
+                .show_local_fs = false,
+                .stat_remote_fs = false,
+                .display_inodes_perfdata = false,
+
+                .exact_match = false,
+                .freespace_ignore_reserved = false,
+
+                .ignore_missing = false,
+                .path_ignored = false,
+
+                // FS Filters
+                .fs_exclude_list = NULL,
+                .fs_include_list = NULL,
+                .device_path_exclude_list = NULL,
+
+                // Actual filesystems paths to investigate
+                .path_select_list = filesystem_list_init(),
+
+                .mount_list = NULL,
+                .seen = NULL,
+
+                .display_unit = Humanized,
+                // .unit = MebiBytes,
+
+                .output_format_is_set = false,
+        };
+        return tmp;
+}
+
+char *get_unit_string(byte_unit_enum unit) {
+        switch (unit) {
+        case Bytes:
+                return "Bytes";
+        case KibiBytes:
+                return "KiB";
+        case MebiBytes:
+                return "MiB";
+        case GibiBytes:
+                return "GiB";
+        case TebiBytes:
+                return "TiB";
+        case PebiBytes:
+                return "PiB";
+        case ExbiBytes:
+                return "EiB";
+        case KiloBytes:
+                return "KB";
+        case MegaBytes:
+                return "MB";
+        case GigaBytes:
+                return "GB";
+        case TeraBytes:
+                return "TB";
+        case PetaBytes:
+                return "PB";
+        case ExaBytes:
+                return "EB";
+        default:
+                assert(false);
+        }
+}
+
+measurement_unit measurement_unit_init() {
+        measurement_unit tmp = {
+                .name = NULL,
+                .filesystem_type = NULL,
+                .is_group = false,
+
+                .freeinodes_percent_thresholds = mp_thresholds_init(),
+                .freespace_percent_thresholds = mp_thresholds_init(),
+                .freespace_bytes_thresholds = mp_thresholds_init(),
+
+                .free_bytes = 0,
+                .used_bytes = 0,
+                .total_bytes = 0,
+
+                .inodes_total = 0,
+                .inodes_free = 0,
+                .inodes_free_to_root = 0,
+                .inodes_used = 0,
+        };
+        return tmp;
+}
+
+// Add a given element to the list, memory for the new element is freshly allocated
+// Returns a pointer to new element
+measurement_unit_list *add_measurement_list(measurement_unit_list *list, measurement_unit elem) {
+        // find last element
+        measurement_unit_list *new = NULL;
+        if (list == NULL) {
+                new = calloc(1, sizeof(measurement_unit_list));
+                if (new == NULL) {
+                        die(STATE_UNKNOWN, _("allocation failed"));
+                }
+        } else {
+                measurement_unit_list *list_elem = list;
+                while (list_elem->next != NULL) {
+                        list_elem = list_elem->next;
+                }
+
+                new = calloc(1, sizeof(measurement_unit_list));
+                if (new == NULL) {
+                        die(STATE_UNKNOWN, _("allocation failed"));
+                }
+
+                list_elem->next = new;
+        }
+
+        new->unit = elem;
+        new->next = NULL;
+        return new;
+}
+
+measurement_unit add_filesystem_to_measurement_unit(measurement_unit unit, parameter_list_elem filesystem) {
+
+        unit.free_bytes += filesystem.free_bytes;
+        unit.used_bytes += filesystem.used_bytes;
+        unit.total_bytes += filesystem.total_bytes;
+
+        unit.inodes_total += filesystem.inodes_total;
+        unit.inodes_free += filesystem.inodes_free;
+        unit.inodes_free_to_root += filesystem.inodes_free_to_root;
+        unit.inodes_used += filesystem.inodes_used;
+        return unit;
+}
+
+measurement_unit create_measurement_unit_from_filesystem(parameter_list_elem filesystem, bool display_mntp) {
+        measurement_unit result = measurement_unit_init();
+        if (!display_mntp) {
+                result.name = strdup(filesystem.best_match->me_mountdir);
+        } else {
+                result.name = strdup(filesystem.best_match->me_devname);
+        }
+
+        if (filesystem.group) {
+                result.is_group = true;
+        } else {
+                result.is_group = false;
+                if (filesystem.best_match) {
+                        result.filesystem_type = filesystem.best_match->me_type;
+                }
+        }
+
+        result.freeinodes_percent_thresholds = filesystem.freeinodes_percent;
+        result.freespace_percent_thresholds = filesystem.freespace_percent;
+        result.freespace_bytes_thresholds = filesystem.freespace_units;
+        result.free_bytes = filesystem.free_bytes;
+        result.total_bytes = filesystem.total_bytes;
+        result.used_bytes = filesystem.used_bytes;
+        result.inodes_total = filesystem.inodes_total;
+        result.inodes_used = filesystem.inodes_used;
+        result.inodes_free = filesystem.inodes_free;
+        result.inodes_free_to_root = filesystem.inodes_free_to_root;
+        return result;
+}
+
+#define RANDOM_STRING_LENGTH 64
+
+char *humanize_byte_value(unsigned long long value, bool use_si_units) {
+        // Idea: A reasonable output should have at most 3 orders of magnitude
+        // before the decimal separator
+        // 353GiB is ok, 2444 GiB should be 2.386 TiB
+        char *result = calloc(RANDOM_STRING_LENGTH, sizeof(char));
+        if (result == NULL) {
+                die(STATE_UNKNOWN, _("allocation failed"));
+        }
+        const byte_unit KibiBytes_factor = 1024;
+        const byte_unit MebiBytes_factor = 1048576;
+        const byte_unit GibiBytes_factor = 1073741824;
+        const byte_unit TebiBytes_factor = 1099511627776;
+        const byte_unit PebiBytes_factor = 1125899906842624;
+        const byte_unit ExbiBytes_factor = 1152921504606846976;
+        const byte_unit KiloBytes_factor = 1000;
+        const byte_unit MegaBytes_factor = 1000000;
+        const byte_unit GigaBytes_factor = 1000000000;
+        const byte_unit TeraBytes_factor = 1000000000000;
+        const byte_unit PetaBytes_factor = 1000000000000000;
+        const byte_unit ExaBytes_factor = 1000000000000000000;
+
+        if (use_si_units) {
+                // SI units, powers of 10
+                if (value < KiloBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu B", value);
+                } else if (value < MegaBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu KB", value / KiloBytes_factor);
+                } else if (value < GigaBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu MB", value / MegaBytes_factor);
+                } else if (value < TeraBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu GB", value / GigaBytes_factor);
+                } else if (value < PetaBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu TB", value / TeraBytes_factor);
+                } else if (value < ExaBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu PB", value / PetaBytes_factor);
+                } else {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu EB", value / ExaBytes_factor);
+                }
+        } else {
+                // IEC units, powers of 2 ^ 10
+                if (value < KibiBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu B", value);
+                } else if (value < MebiBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu KiB", value / KibiBytes_factor);
+                } else if (value < GibiBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu MiB", value / MebiBytes_factor);
+                } else if (value < TebiBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu GiB", value / GibiBytes_factor);
+                } else if (value < PebiBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu TiB", value / TebiBytes_factor);
+                } else if (value < ExbiBytes_factor) {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu PiB", value / PebiBytes_factor);
+                } else {
+                        snprintf(result, RANDOM_STRING_LENGTH, "%llu EiB", value / ExbiBytes_factor);
+                }
+        }
+
+        return result;
+}
+
+filesystem_list filesystem_list_init() {
+        filesystem_list tmp = {
+                .length = 0,
+                .first = NULL,
+        };
+        return tmp;
+}
+
+parameter_list_elem *mp_int_fs_list_append(filesystem_list *list, const char *name) {
+        parameter_list_elem *current = list->first;
+        parameter_list_elem *new_path = (struct parameter_list *)malloc(sizeof *new_path);
+        *new_path = parameter_list_init(name);
+
+        if (current == NULL) {
+                list->first = new_path;
+                new_path->prev = NULL;
+                list->length = 1;
+        } else {
+                while (current->next) {
+                        current = current->next;
+                }
+                current->next = new_path;
+                new_path->prev = current;
+                list->length++;
+        }
+        return new_path;
+}
+
+parameter_list_elem *mp_int_fs_list_find(filesystem_list list, const char *name) {
+        if (list.length == 0) {
+                return NULL;
+        }
+
+        for (parameter_list_elem *temp_list = list.first; temp_list; temp_list = temp_list->next) {
+                if (!strcmp(temp_list->name, name)) {
+                        return temp_list;
+                }
+        }
+
+        return NULL;
+}
+
+parameter_list_elem *mp_int_fs_list_del(filesystem_list *list, parameter_list_elem *item) {
+        if (list->length == 0) {
+                return NULL;
+        }
+
+        if (item == NULL) {
+                // Got NULL for item, interpret this as "delete first element"
+                // as a kind of compatibility to the old function
+                item = list->first;
+        }
+
+        if (list->first == item) {
+                list->length--;
+
+                list->first = item->next;
+                if (list->first) {
+                        list->first->prev = NULL;
+                }
+                return list->first;
+        }
+
+        // Was not the first element, continue
+        parameter_list_elem *prev = list->first;
+        parameter_list_elem *current = list->first->next;
+
+        while (current != item && current != NULL) {
+                prev = current;
+                current = current->next;
+        }
+
+        if (current == NULL) {
+                // didn't find that element ....
+                return NULL;
+        }
+
+        // remove the element
+        parameter_list_elem *next = current->next;
+        prev->next = next;
+        list->length--;
+        if (next) {
+                next->prev = prev;
+        }
+
+        if (item->name) {
+                free(item->name);
+        }
+        free(item);
+
+        return next;
+}
+
+parameter_list_elem *mp_int_fs_list_get_next(parameter_list_elem *current) {
+        if (!current) {
+                return NULL;
+        }
+        return current->next;
+}
+
+void mp_int_fs_list_set_best_match(filesystem_list list, struct mount_entry *mount_list, bool exact) {
+        for (parameter_list_elem *elem = list.first; elem; elem = mp_int_fs_list_get_next(elem)) {
+                if (!elem->best_match) {
+                        size_t name_len = strlen(elem->name);
+                        struct mount_entry *best_match = NULL;
+
+                        /* set best match if path name exactly matches a mounted device name */
+                        for (struct mount_entry *mount_entry = mount_list; mount_entry; mount_entry = mount_entry->me_next) {
+                                if (strcmp(mount_entry->me_devname, elem->name) == 0) {
+                                        struct fs_usage fsp;
+                                        if (get_fs_usage(mount_entry->me_mountdir, mount_entry->me_devname, &fsp) >= 0) {
+                                                best_match = mount_entry;
+                                        }
+                                }
+                        }
+
+                        /* set best match by directory name if no match was found by devname */
+                        if (!best_match) {
+                                size_t best_match_len = 0;
+                                for (struct mount_entry *mount_entry = mount_list; mount_entry; mount_entry = mount_entry->me_next) {
+                                        size_t len = strlen(mount_entry->me_mountdir);
+
+                                        if ((!exact && (best_match_len <= len && len <= name_len &&
+                                                                        (len == 1 || strncmp(mount_entry->me_mountdir, elem->name, len) == 0))) ||
+                                                (exact && strcmp(mount_entry->me_mountdir, elem->name) == 0)) {
+                                                struct fs_usage fsp;
+
+                                                if (get_fs_usage(mount_entry->me_mountdir, mount_entry->me_devname, &fsp) >= 0) {
+                                                        best_match = mount_entry;
+                                                        best_match_len = len;
+                                                }
+                                        }
+                                }
+                        }
+
+                        if (best_match) {
+                                elem->best_match = best_match;
+                        } else {
+                                elem->best_match = NULL; /* Not sure why this is needed as it should be null on initialisation */
+                        }
+
+                        // No filesystem without a mount_entry!
+                        // assert(elem->best_match != NULL);
+                }
+        }
+}
diff --git a/plugins/check_disk.d/utils_disk.h b/plugins/check_disk.d/utils_disk.h
new file mode 100644
index 00000000..6831d1fd
--- /dev/null
+++ b/plugins/check_disk.d/utils_disk.h
@@ -0,0 +1,157 @@
+#pragma once
+/* Header file for utils_disk */
+
+#include "../../config.h"
+#include "../../gl/mountlist.h"
+#include "../../lib/utils_base.h"
+#include "../../lib/output.h"
+#include "regex.h"
+#include <stdint.h>
+
+typedef unsigned long long byte_unit;
+
+typedef enum {
+        Humanized,
+        Bytes,
+        KibiBytes,
+        MebiBytes,
+        GibiBytes,
+        TebiBytes,
+        PebiBytes,
+        ExbiBytes,
+        KiloBytes,
+        MegaBytes,
+        GigaBytes,
+        TeraBytes,
+        PetaBytes,
+        ExaBytes,
+} byte_unit_enum;
+
+typedef struct name_list string_list;
+struct name_list {
+        char *name;
+        string_list *next;
+};
+
+struct regex_list {
+        regex_t regex;
+        struct regex_list *next;
+};
+
+typedef struct parameter_list parameter_list_elem;
+struct parameter_list {
+        char *name;
+        char *group;
+
+        mp_thresholds freespace_units;
+        mp_thresholds freespace_percent;
+        mp_thresholds freeinodes_percent;
+
+        struct mount_entry *best_match;
+
+        uintmax_t inodes_free_to_root;
+        uintmax_t inodes_free;
+        uintmax_t inodes_used;
+        uintmax_t inodes_total;
+
+        uint64_t used_bytes;
+        uint64_t free_bytes;
+        uint64_t total_bytes;
+
+        parameter_list_elem *next;
+        parameter_list_elem *prev;
+};
+
+typedef struct {
+        size_t length;
+        parameter_list_elem *first;
+} filesystem_list;
+
+filesystem_list filesystem_list_init();
+
+typedef struct {
+        char *name;
+        char *filesystem_type;
+        bool is_group;
+
+        mp_thresholds freespace_bytes_thresholds;
+        mp_thresholds freespace_percent_thresholds;
+        mp_thresholds freeinodes_percent_thresholds;
+
+        uintmax_t inodes_free_to_root;
+        uintmax_t inodes_free;
+        uintmax_t inodes_used;
+        uintmax_t inodes_total;
+
+        uintmax_t used_bytes;
+        uintmax_t free_bytes;
+        uintmax_t total_bytes;
+} measurement_unit;
+
+typedef struct measurement_unit_list measurement_unit_list;
+struct measurement_unit_list {
+        measurement_unit unit;
+        measurement_unit_list *next;
+};
+
+typedef struct {
+        // Output options
+        bool erronly;
+        bool display_mntp;
+        /* show only local filesystems.  */
+        bool show_local_fs;
+        /* show only local filesystems but call stat() on remote ones. */
+        bool stat_remote_fs;
+        bool display_inodes_perfdata;
+
+        bool exact_match;
+        bool freespace_ignore_reserved;
+
+        bool ignore_missing;
+        bool path_ignored;
+
+        /* Linked list of filesystem types to omit.
+           If the list is empty, don't exclude any types.  */
+        struct regex_list *fs_exclude_list;
+        /* Linked list of filesystem types to check.
+           If the list is empty, include all types.  */
+        struct regex_list *fs_include_list;
+        struct name_list *device_path_exclude_list;
+        filesystem_list path_select_list;
+        /* Linked list of mounted filesystems. */
+        struct mount_entry *mount_list;
+        struct name_list *seen;
+
+        byte_unit_enum display_unit;
+        // byte_unit unit;
+
+        bool output_format_is_set;
+        mp_output_format output_format;
+} check_disk_config;
+
+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);
+
+parameter_list_elem parameter_list_init(const char *);
+
+parameter_list_elem *mp_int_fs_list_append(filesystem_list *list, const char *name);
+parameter_list_elem *mp_int_fs_list_find(filesystem_list list, const char *name);
+parameter_list_elem *mp_int_fs_list_del(filesystem_list *list, parameter_list_elem *item);
+parameter_list_elem *mp_int_fs_list_get_next(parameter_list_elem *current);
+void mp_int_fs_list_set_best_match(filesystem_list list, struct mount_entry *mount_list, bool exact);
+
+measurement_unit measurement_unit_init();
+measurement_unit_list *add_measurement_list(measurement_unit_list *list, measurement_unit elem);
+measurement_unit add_filesystem_to_measurement_unit(measurement_unit unit, parameter_list_elem filesystem);
+measurement_unit create_measurement_unit_from_filesystem(parameter_list_elem filesystem, bool display_mntp);
+
+int search_parameter_list(parameter_list_elem *list, const char *name);
+bool np_regex_match_mount_entry(struct mount_entry *, regex_t *);
+
+char *get_unit_string(byte_unit_enum);
+check_disk_config check_disk_config_init();
+
+char *humanize_byte_value(unsigned long long value, bool use_si_units);
diff --git a/plugins/check_http.c b/plugins/check_http.c
index baff682a..8e0c15ec 100644
--- a/plugins/check_http.c
+++ b/plugins/check_http.c
@@ -1724,6 +1724,16 @@ print_help (void)
   printf ("%s\n", _("strings and regular expressions, check connection times, and report on"));
   printf ("%s\n", _("certificate expiration times."));
 
+  printf ("\n");
+  printf ("%s\n", _("ATTENTION!"));
+  printf ("\n");
+  printf ("%s\n", _("THIS PLUGIN IS DEPRECATED. The functionality was reimplemented by the"));
+  printf ("%s\n", _("check_curl plugin, which can be used as a drop-in replacement. You should"));
+  printf ("%s\n", _("migrate your checks over to check_curl, because check_http is going to be"));
+  printf ("%s\n", _("removed sooner than later. Just replace check_http with check_curl in your"));
+  printf ("%s\n", _("check command definitions."));
+  printf ("%s\n", _("Report issues to: https://github.com/monitoring-plugins/monitoring-plugins/issues"));
+
   printf ("\n\n");
 
   print_usage ();
diff --git a/plugins/check_ide_smart.c b/plugins/check_ide_smart.c
index 9640ef70..16fe3d01 100644
--- a/plugins/check_ide_smart.c
+++ b/plugins/check_ide_smart.c
@@ -56,7 +56,6 @@ void print_usage(void);
 #       include <sys/device.h>
 #       include <sys/param.h>
 #       include <sys/sysctl.h>
-#       include <sys/videoio.h> /* for __u8 and friends */
 #       include <sys/scsiio.h>
 #       include <sys/ataio.h>
 #       include <dev/ata/atareg.h>
@@ -79,48 +78,47 @@ void print_usage(void);
 #define UNKNOWN     -1
 
 typedef struct threshold_s {
-        __u8 id;
-        __u8 threshold;
-        __u8 reserved[10];
+        uint8_t id;
+        uint8_t threshold;
+        uint8_t reserved[10];
 } __attribute__((packed)) threshold_t;
 
 typedef struct thresholds_s {
-        __u16 revision;
+        uint16_t revision;
         threshold_t thresholds[NR_ATTRIBUTES];
-        __u8 reserved[18];
-        __u8 vendor[131];
-        __u8 checksum;
+        uint8_t reserved[18];
+        uint8_t vendor[131];
+        uint8_t checksum;
 } __attribute__((packed)) thresholds_t;
 
 typedef struct value_s {
-        __u8 id;
-        __u16 status;
-        __u8 value;
-        __u8 vendor[8];
+        uint8_t id;
+        uint16_t status;
+        uint8_t value;
+        uint8_t vendor[8];
 } __attribute__((packed)) value_t;
 
 typedef struct values_s {
-        __u16 revision;
+        uint16_t revision;
         value_t values[NR_ATTRIBUTES];
-        __u8 offline_status;
-        __u8 vendor1;
-        __u16 offline_timeout;
-        __u8 vendor2;
-        __u8 offline_capability;
-        __u16 smart_capability;
-        __u8 reserved[16];
-        __u8 vendor[125];
-        __u8 checksum;
+        uint8_t offline_status;
+        uint8_t vendor1;
+        uint16_t offline_timeout;
+        uint8_t vendor2;
+        uint8_t offline_capability;
+        uint16_t smart_capability;
+        uint8_t reserved[16];
+        uint8_t vendor[125];
+        uint8_t checksum;
 } __attribute__((packed)) values_t;
 
 static struct {
-        __u8 value;
+        uint8_t value;
         char *text;
-} offline_status_text[] = {{0x00, "NeverStarted"}, {0x02, "Completed"}, {0x04, "Suspended"},
-                                                                {0x05, "Aborted"},      {0x06, "Failed"},    {0, 0}};
+} offline_status_text[] = {{0x00, "NeverStarted"}, {0x02, "Completed"}, {0x04, "Suspended"}, {0x05, "Aborted"}, {0x06, "Failed"}, {0, 0}};
 
 static struct {
-        __u8 value;
+        uint8_t value;
         char *text;
 } smart_command[] = {{SMART_ENABLE, "SMART_ENABLE"},
                                          {SMART_DISABLE, "SMART_DISABLE"},
@@ -140,7 +138,7 @@ static int smart_read_values(int, values_t *);
 static int nagios(values_t *, thresholds_t *);
 static void print_value(value_t *, threshold_t *);
 static void print_values(values_t *, thresholds_t *);
-static int smart_cmd_simple(int, enum SmartCommand, __u8, bool);
+static int smart_cmd_simple(int, enum SmartCommand, uint8_t, bool);
 static int smart_read_thresholds(int, thresholds_t *);
 static bool verbose = false;
 
@@ -175,8 +173,9 @@ int main(int argc, char *argv[]) {
 
                 o = getopt_long(argc, argv, "+d:iq10nhVv", longopts, &longindex);
 
-                if (o == -1 || o == EOF || o == 1)
+                if (o == -1 || o == EOF || o == 1) {
                         break;
+                }
 
                 switch (o) {
                 case 'd':
@@ -234,8 +233,9 @@ int main(int argc, char *argv[]) {
         smart_read_values(fd, &values);
         smart_read_thresholds(fd, &thresholds);
         retval = nagios(&values, &thresholds);
-        if (verbose)
+        if (verbose) {
                 print_values(&values, &thresholds);
+        }
 
         close(fd);
         return retval;
@@ -254,7 +254,7 @@ char *get_offline_text(int status) {
 int smart_read_values(int fd, values_t *values) {
 #ifdef __linux__
         int e;
-        __u8 args[4 + 512];
+        uint8_t args[4 + 512];
         args[0] = WIN_SMART;
         args[1] = 0;
         args[2] = SMART_READ_VALUES;
@@ -282,8 +282,9 @@ int smart_read_values(int fd, values_t *values) {
         req.cylinder = WDSMART_CYL;
 
         if (ioctl(fd, ATAIOCCOMMAND, &req) == 0) {
-                if (req.retsts != ATACMD_OK)
+                if (req.retsts != ATACMD_OK) {
                         errno = ENODEV;
+                }
         }
 
         if (errno != 0) {
@@ -370,22 +371,24 @@ void print_values(values_t *p, thresholds_t *t) {
                    p->smart_capability & 1 ? "SaveOnStandBy" : "", p->smart_capability & 2 ? "AutoSave" : "");
 }
 
-int smart_cmd_simple(int fd, enum SmartCommand command, __u8 val0, bool show_error) {
+int smart_cmd_simple(int fd, enum SmartCommand command, uint8_t val0, bool show_error) {
         int e = STATE_UNKNOWN;
 #ifdef __linux__
-        __u8 args[4];
+        uint8_t args[4];
         args[0] = WIN_SMART;
         args[1] = val0;
         args[2] = smart_command[command].value;
         args[3] = 0;
         if (ioctl(fd, HDIO_DRIVE_CMD, &args)) {
                 e = STATE_CRITICAL;
-                if (show_error)
+                if (show_error) {
                         printf(_("CRITICAL - %s: %s\n"), smart_command[command].text, strerror(errno));
+                }
         } else {
                 e = STATE_OK;
-                if (show_error)
+                if (show_error) {
                         printf(_("OK - Command sent (%s)\n"), smart_command[command].text);
+                }
         }
 
 #endif /* __linux__ */
@@ -401,20 +404,24 @@ int smart_cmd_simple(int fd, enum SmartCommand command, __u8 val0, bool show_err
         req.sec_count = val0;
 
         if (ioctl(fd, ATAIOCCOMMAND, &req) == 0) {
-                if (req.retsts != ATACMD_OK)
+                if (req.retsts != ATACMD_OK) {
                         errno = ENODEV;
-                if (req.cylinder != WDSMART_CYL)
+                }
+                if (req.cylinder != WDSMART_CYL) {
                         errno = ENODEV;
+                }
         }
 
         if (errno != 0) {
                 e = STATE_CRITICAL;
-                if (show_error)
+                if (show_error) {
                         printf(_("CRITICAL - %s: %s\n"), smart_command[command].text, strerror(errno));
+                }
         } else {
                 e = STATE_OK;
-                if (show_error)
+                if (show_error) {
                         printf(_("OK - Command sent (%s)\n"), smart_command[command].text);
+                }
         }
 
 #endif /* __NetBSD__ */
@@ -424,7 +431,7 @@ int smart_cmd_simple(int fd, enum SmartCommand command, __u8 val0, bool show_err
 int smart_read_thresholds(int fd, thresholds_t *thresholds) {
 #ifdef __linux__
         int e;
-        __u8 args[4 + 512];
+        uint8_t args[4 + 512];
         args[0] = WIN_SMART;
         args[1] = 0;
         args[2] = SMART_READ_THRESHOLDS;
@@ -452,8 +459,9 @@ int smart_read_thresholds(int fd, thresholds_t *thresholds) {
         req.cylinder = WDSMART_CYL;
 
         if (ioctl(fd, ATAIOCCOMMAND, &req) == 0) {
-                if (req.retsts != ATACMD_OK)
+                if (req.retsts != ATACMD_OK) {
                         errno = ENODEV;
+                }
         }
 
         if (errno != 0) {
diff --git a/plugins/check_nwstat.c b/plugins/check_nwstat.c
deleted file mode 100644
index 176dfbc8..00000000
--- a/plugins/check_nwstat.c
+++ /dev/null
@@ -1,1527 +0,0 @@
-/*****************************************************************************
- *
- * Monitoring check_nwstat plugin
- *
- * License: GPL
- * Copyright (c) 2000-2024 Monitoring Plugins Development Team
- *
- * Description:
- *
- * This file contains the check_nwstat plugin
- *
- * This plugin attempts to contact the MRTGEXT NLM running on a
- * Novell server to gather the requested system information.
- *
- *
- * 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/>.
- *
- *
- *****************************************************************************/
-
-const char *progname = "check_nwstat";
-const char *copyright = "2000-2024";
-const char *email = "devel@monitoring-plugins.org";
-
-#include "common.h"
-#include "netutils.h"
-#include "utils.h"
-
-enum checkvar {
-        NONE,
-        LOAD1,      /* check 1 minute CPU load */
-        LOAD5,      /* check 5 minute CPU load */
-        LOAD15,     /* check 15 minute CPU load */
-        CONNS,      /* check number of connections */
-        VPF,        /* check % free space on volume */
-        VMF,        /* check MB free space on volume */
-        VMU,        /* check MB used space on volume */
-        VPU,        /* check % used space on volume */
-        VMP,        /* check MB purgeable space on volume */
-        VKF,        /* check KB free space on volume */
-        LTCH,       /* check long-term cache hit percentage */
-        CBUFF,      /* check total cache buffers */
-        CDBUFF,     /* check dirty cache buffers */
-        LRUM,       /* check LRU sitting time in minutes */
-        DSDB,       /* check to see if DS Database is open */
-        LOGINS,     /* check to see if logins are enabled */
-        NRMH,       /* check to see NRM Health Status */
-        PUPRB,      /* check % of used packet receive buffers */
-        UPRB,       /* check used packet receive buffers */
-        SAPENTRIES, /* check SAP entries */
-        OFILES,     /* check number of open files */
-        VKP,        /* check KB purgeable space on volume */
-        VPP,        /* check % purgeable space on volume */
-        VKNP,       /* check KB not yet purgeable space on volume */
-        VPNP,       /* check % not yet purgeable space on volume */
-        ABENDS,     /* check abended thread count */
-        CSPROCS,    /* check number of current service processes */
-        TSYNC,      /* check timesync status 0=no 1=yes in sync to the network */
-        LRUS,       /* check LRU sitting time in seconds */
-        DCB,        /* check dirty cache buffers as a percentage of the total */
-        TCB,        /* check total cache buffers as a percentage of the original */
-        DSVER,      /* check NDS version */
-        UPTIME,     /* check server uptime */
-        NLM,        /* check NLM loaded */
-        NRMP,       /* check NRM Process Values */
-        NRMM,       /* check NRM Memory Values */
-        NRMS,       /* check NRM Values */
-        NSS1,       /* check Statistics from _Admin:Manage_NSS\GeneralStats.xml */
-        NSS2,       /* check Statistics from _Admin:Manage_NSS\BufferCache.xml */
-        NSS3,       /* check statistics from _Admin:Manage_NSS\NameCache.xml */
-        NSS4,       /* check statistics from _Admin:Manage_NSS\FileStats.xml */
-        NSS5,       /* check statistics from _Admin:Manage_NSS\ObjectCache.xml */
-        NSS6,       /* check statistics from _Admin:Manage_NSS\Thread.xml */
-        NSS7        /* check statistics from _Admin:Manage_NSS\AuthorizationCache.xml */
-};
-
-enum {
-        PORT = 9999
-};
-
-static char *server_address = NULL;
-static char *volume_name = NULL;
-static char *nlm_name = NULL;
-static char *nrmp_name = NULL;
-static char *nrmm_name = NULL;
-static char *nrms_name = NULL;
-static char *nss1_name = NULL;
-static char *nss2_name = NULL;
-static char *nss3_name = NULL;
-static char *nss4_name = NULL;
-static char *nss5_name = NULL;
-static char *nss6_name = NULL;
-static char *nss7_name = NULL;
-static int server_port = PORT;
-static unsigned long warning_value = 0L;
-static unsigned long critical_value = 0L;
-static bool check_warning_value = false;
-static bool check_critical_value = false;
-static bool check_netware_version = false;
-static enum checkvar vars_to_check = NONE;
-static int sap_number = -1;
-
-static int process_arguments(int /*argc*/, char ** /*argv*/);
-static void print_help(void);
-void print_usage(void);
-
-int main(int argc, char **argv) {
-        int result = STATE_UNKNOWN;
-        int sd;
-        char *send_buffer = NULL;
-        char recv_buffer[MAX_INPUT_BUFFER];
-        char *output_message = NULL;
-        char *temp_buffer = NULL;
-        char *netware_version = NULL;
-
-        int time_sync_status = 0;
-        int nrm_health_status = 0;
-        unsigned long total_cache_buffers = 0;
-        unsigned long dirty_cache_buffers = 0;
-        unsigned long open_files = 0;
-        unsigned long abended_threads = 0;
-        unsigned long max_service_processes = 0;
-        unsigned long current_service_processes = 0;
-        unsigned long free_disk_space = 0L;
-        unsigned long nrmp_value = 0L;
-        unsigned long nrmm_value = 0L;
-        unsigned long nrms_value = 0L;
-        unsigned long nss1_value = 0L;
-        unsigned long nss2_value = 0L;
-        unsigned long nss3_value = 0L;
-        unsigned long nss4_value = 0L;
-        unsigned long nss5_value = 0L;
-        unsigned long nss6_value = 0L;
-        unsigned long nss7_value = 0L;
-        unsigned long total_disk_space = 0L;
-        unsigned long used_disk_space = 0L;
-        unsigned long percent_used_disk_space = 0L;
-        unsigned long purgeable_disk_space = 0L;
-        unsigned long non_purgeable_disk_space = 0L;
-        unsigned long percent_free_space = 0;
-        unsigned long percent_purgeable_space = 0;
-        unsigned long percent_non_purgeable_space = 0;
-        unsigned long current_connections = 0L;
-        unsigned long utilization = 0L;
-        unsigned long cache_hits = 0;
-        unsigned long cache_buffers = 0L;
-        unsigned long lru_time = 0L;
-        unsigned long max_packet_receive_buffers = 0;
-        unsigned long used_packet_receive_buffers = 0;
-        unsigned long percent_used_packet_receive_buffers = 0L;
-        unsigned long sap_entries = 0;
-        char uptime[MAX_INPUT_BUFFER];
-
-        setlocale(LC_ALL, "");
-        bindtextdomain(PACKAGE, LOCALEDIR);
-        textdomain(PACKAGE);
-
-        /* Parse extra opts if any */
-        argv = np_extra_opts(&argc, argv, progname);
-
-        if (process_arguments(argc, argv) == ERROR)
-                usage4(_("Could not parse arguments"));
-
-        /* initialize alarm signal handling */
-        signal(SIGALRM, socket_timeout_alarm_handler);
-
-        /* set socket timeout */
-        alarm(socket_timeout);
-
-        /* open connection */
-        my_tcp_connect(server_address, server_port, &sd);
-
-        /* get OS version string */
-        if (check_netware_version) {
-                send_buffer = strdup("S19\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                if (!strcmp(recv_buffer, "-1\n"))
-                        netware_version = strdup("");
-                else {
-                        recv_buffer[strlen(recv_buffer) - 1] = 0;
-                        xasprintf(&netware_version, _("NetWare %s: "), recv_buffer);
-                }
-        } else
-                netware_version = strdup("");
-
-        /* check CPU load */
-        if (vars_to_check == LOAD1 || vars_to_check == LOAD5 || vars_to_check == LOAD15) {
-
-                switch (vars_to_check) {
-                case LOAD1:
-                        temp_buffer = strdup("1");
-                        break;
-                case LOAD5:
-                        temp_buffer = strdup("5");
-                        break;
-                default:
-                        temp_buffer = strdup("15");
-                        break;
-                }
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "UTIL%s\r\n", temp_buffer);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                utilization = strtoul(recv_buffer, NULL, 10);
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("UPTIME\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                recv_buffer[strlen(recv_buffer) - 1] = 0;
-                sprintf(uptime, _("Up %s,"), recv_buffer);
-
-                if (check_critical_value && utilization >= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && utilization >= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("Load %s - %s %s-min load average = %lu%%|load%s=%lu;%lu;%lu;0;100"), state_text(result), uptime,
-                                  temp_buffer, utilization, temp_buffer, utilization, warning_value, critical_value);
-
-                /* check number of user connections */
-        } else if (vars_to_check == CONNS) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("CONNECT\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                current_connections = strtoul(recv_buffer, NULL, 10);
-
-                if (check_critical_value && current_connections >= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && current_connections >= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("Conns %s - %lu current connections|Conns=%lu;%lu;%lu;;"), state_text(result), current_connections,
-                                  current_connections, warning_value, critical_value);
-
-                /* check % long term cache hits */
-        } else if (vars_to_check == LTCH) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S1\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                cache_hits = atoi(recv_buffer);
-
-                if (check_critical_value && cache_hits <= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && cache_hits <= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("%s: Long term cache hits = %lu%%"), state_text(result), cache_hits);
-
-                /* check cache buffers */
-        } else if (vars_to_check == CBUFF) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S2\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                cache_buffers = strtoul(recv_buffer, NULL, 10);
-
-                if (check_critical_value && cache_buffers <= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && cache_buffers <= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("%s: Total cache buffers = %lu|Cachebuffers=%lu;%lu;%lu;;"), state_text(result), cache_buffers,
-                                  cache_buffers, warning_value, critical_value);
-
-                /* check dirty cache buffers */
-        } else if (vars_to_check == CDBUFF) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S3\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                cache_buffers = strtoul(recv_buffer, NULL, 10);
-
-                if (check_critical_value && cache_buffers >= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && cache_buffers >= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("%s: Dirty cache buffers = %lu|Dirty-Cache-Buffers=%lu;%lu;%lu;;"), state_text(result), cache_buffers,
-                                  cache_buffers, warning_value, critical_value);
-
-                /* check LRU sitting time in minutes */
-        } else if (vars_to_check == LRUM) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S5\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                lru_time = strtoul(recv_buffer, NULL, 10);
-
-                if (check_critical_value && lru_time <= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && lru_time <= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("%s: LRU sitting time = %lu minutes"), state_text(result), lru_time);
-
-                /* check KB free space on volume */
-        } else if (vars_to_check == VKF) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "VKF%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        free_disk_space = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && free_disk_space <= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && free_disk_space <= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s%lu KB free on volume %s|KBFree%s=%lu;%lu;%lu;;"), (result == STATE_OK) ? "" : _("Only "),
-                                          free_disk_space, volume_name, volume_name, free_disk_space, warning_value, critical_value);
-                }
-
-                /* check MB free space on volume */
-        } else if (vars_to_check == VMF) {
-
-                xasprintf(&send_buffer, "VMF%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        free_disk_space = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && free_disk_space <= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && free_disk_space <= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s%lu MB free on volume %s|MBFree%s=%lu;%lu;%lu;;"), (result == STATE_OK) ? "" : _("Only "),
-                                          free_disk_space, volume_name, volume_name, free_disk_space, warning_value, critical_value);
-                }
-                /* check MB used space on volume */
-        } else if (vars_to_check == VMU) {
-
-                xasprintf(&send_buffer, "VMU%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        free_disk_space = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && free_disk_space <= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && free_disk_space <= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s%lu MB used on volume %s|MBUsed%s=%lu;%lu;%lu;;"), (result == STATE_OK) ? "" : _("Only "),
-                                          free_disk_space, volume_name, volume_name, free_disk_space, warning_value, critical_value);
-                }
-                /* check % used space on volume */
-        } else if (vars_to_check == VPU) {
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                asprintf(&send_buffer, "VMU%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        asprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-
-                } else {
-                        used_disk_space = strtoul(recv_buffer, NULL, 10);
-                        close(sd);
-                        my_tcp_connect(server_address, server_port, &sd);
-                        /* get total volume in MB */
-                        asprintf(&send_buffer, "VMS%s\r\n", volume_name);
-                        result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                        if (result != STATE_OK)
-                                return result;
-                        total_disk_space = strtoul(recv_buffer, NULL, 10);
-                        /* calculate percent used on volume */
-                        percent_used_disk_space = (unsigned long)(((double)used_disk_space / (double)total_disk_space) * 100.0);
-
-                        if (check_critical_value && percent_used_disk_space >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && percent_used_disk_space >= warning_value)
-                                result = STATE_WARNING;
-
-                        asprintf(&output_message, _("%lu MB (%lu%%) used on volume %s - total %lu MB|Used space in percent on %s=%lu;%lu;%lu;0;100"),
-                                         used_disk_space, percent_used_disk_space, volume_name, total_disk_space, volume_name, percent_used_disk_space,
-                                         warning_value, critical_value);
-                }
-
-                /* check % free space on volume */
-        } else if (vars_to_check == VPF) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "VKF%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-
-                } else {
-
-                        free_disk_space = strtoul(recv_buffer, NULL, 10);
-
-                        close(sd);
-                        my_tcp_connect(server_address, server_port, &sd);
-
-                        xasprintf(&send_buffer, "VKS%s\r\n", volume_name);
-                        result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                        if (result != STATE_OK)
-                                return result;
-                        total_disk_space = strtoul(recv_buffer, NULL, 10);
-
-                        percent_free_space = (unsigned long)(((double)free_disk_space / (double)total_disk_space) * 100.0);
-
-                        if (check_critical_value && percent_free_space <= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && percent_free_space <= warning_value)
-                                result = STATE_WARNING;
-                        free_disk_space /= 1024;
-                        total_disk_space /= 1024;
-                        xasprintf(&output_message, _("%lu MB (%lu%%) free on volume %s - total %lu MB|FreeMB%s=%lu;%lu;%lu;0;100"), free_disk_space,
-                                          percent_free_space, volume_name, total_disk_space, volume_name, percent_free_space, warning_value, critical_value);
-                }
-
-                /* check to see if DS Database is open or closed */
-        } else if (vars_to_check == DSDB) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S11\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                if (atoi(recv_buffer) == 1)
-                        result = STATE_OK;
-                else
-                        result = STATE_WARNING;
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S13\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                temp_buffer = strtok(recv_buffer, "\r\n");
-
-                xasprintf(&output_message, _("Directory Services Database is %s (DS version %s)"), (result == STATE_OK) ? "open" : "closed",
-                                  temp_buffer);
-
-                /* check to see if logins are enabled */
-        } else if (vars_to_check == LOGINS) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S12\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                if (atoi(recv_buffer) == 1)
-                        result = STATE_OK;
-                else
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("Logins are %s"), (result == STATE_OK) ? _("enabled") : _("disabled"));
-
-                /* check NRM Health Status Summary*/
-        } else if (vars_to_check == NRMH) {
-
-                xasprintf(&send_buffer, "NRMH\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                nrm_health_status = atoi(recv_buffer);
-
-                if (nrm_health_status == 2) {
-                        result = STATE_OK;
-                        xasprintf(&output_message, _("CRITICAL - NRM Status is bad!"));
-                } else {
-                        if (nrm_health_status == 1) {
-                                result = STATE_WARNING;
-                                xasprintf(&output_message, _("Warning - NRM Status is suspect!"));
-                        }
-
-                        xasprintf(&output_message, _("OK - NRM Status is good!"));
-                }
-
-                /* check packet receive buffers */
-        } else if (vars_to_check == UPRB || vars_to_check == PUPRB) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S15\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                used_packet_receive_buffers = atoi(recv_buffer);
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S16\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                max_packet_receive_buffers = atoi(recv_buffer);
-
-                percent_used_packet_receive_buffers =
-                        (unsigned long)(((double)used_packet_receive_buffers / (double)max_packet_receive_buffers) * 100.0);
-
-                if (vars_to_check == UPRB) {
-                        if (check_critical_value && used_packet_receive_buffers >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && used_packet_receive_buffers >= warning_value)
-                                result = STATE_WARNING;
-                } else {
-                        if (check_critical_value && percent_used_packet_receive_buffers >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && percent_used_packet_receive_buffers >= warning_value)
-                                result = STATE_WARNING;
-                }
-
-                xasprintf(&output_message, _("%lu of %lu (%lu%%) packet receive buffers used"), used_packet_receive_buffers,
-                                  max_packet_receive_buffers, percent_used_packet_receive_buffers);
-
-                /* check SAP table entries */
-        } else if (vars_to_check == SAPENTRIES) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                if (sap_number == -1)
-                        xasprintf(&send_buffer, "S9\r\n");
-                else
-                        xasprintf(&send_buffer, "S9.%d\r\n", sap_number);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                sap_entries = atoi(recv_buffer);
-
-                if (check_critical_value && sap_entries >= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && sap_entries >= warning_value)
-                        result = STATE_WARNING;
-
-                if (sap_number == -1)
-                        xasprintf(&output_message, _("%lu entries in SAP table"), sap_entries);
-                else
-                        xasprintf(&output_message, _("%lu entries in SAP table for SAP type %d"), sap_entries, sap_number);
-
-                /* check KB purgeable space on volume */
-        } else if (vars_to_check == VKP) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "VKP%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        purgeable_disk_space = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && purgeable_disk_space >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && purgeable_disk_space >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s%lu KB purgeable on volume %s|Purge%s=%lu;%lu;%lu;;"), (result == STATE_OK) ? "" : _("Only "),
-                                          purgeable_disk_space, volume_name, volume_name, purgeable_disk_space, warning_value, critical_value);
-                }
-                /* check MB purgeable space on volume */
-        } else if (vars_to_check == VMP) {
-
-                xasprintf(&send_buffer, "VMP%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        purgeable_disk_space = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && purgeable_disk_space >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && purgeable_disk_space >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s%lu MB purgeable on volume %s|Purge%s=%lu;%lu;%lu;;"), (result == STATE_OK) ? "" : _("Only "),
-                                          purgeable_disk_space, volume_name, volume_name, purgeable_disk_space, warning_value, critical_value);
-                }
-
-                /* check % purgeable space on volume */
-        } else if (vars_to_check == VPP) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "VKP%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-
-                } else {
-
-                        purgeable_disk_space = strtoul(recv_buffer, NULL, 10);
-
-                        close(sd);
-                        my_tcp_connect(server_address, server_port, &sd);
-
-                        xasprintf(&send_buffer, "VKS%s\r\n", volume_name);
-                        result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                        if (result != STATE_OK)
-                                return result;
-                        total_disk_space = strtoul(recv_buffer, NULL, 10);
-
-                        percent_purgeable_space = (unsigned long)(((double)purgeable_disk_space / (double)total_disk_space) * 100.0);
-
-                        if (check_critical_value && percent_purgeable_space >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && percent_purgeable_space >= warning_value)
-                                result = STATE_WARNING;
-                        purgeable_disk_space /= 1024;
-                        xasprintf(&output_message, _("%lu MB (%lu%%) purgeable on volume %s|Purgeable%s=%lu;%lu;%lu;0;100"), purgeable_disk_space,
-                                          percent_purgeable_space, volume_name, volume_name, percent_purgeable_space, warning_value, critical_value);
-                }
-
-                /* check KB not yet purgeable space on volume */
-        } else if (vars_to_check == VKNP) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "VKNP%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        non_purgeable_disk_space = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && non_purgeable_disk_space >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && non_purgeable_disk_space >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s%lu KB not yet purgeable on volume %s"), (result == STATE_OK) ? "" : _("Only "),
-                                          non_purgeable_disk_space, volume_name);
-                }
-
-                /* check % not yet purgeable space on volume */
-        } else if (vars_to_check == VPNP) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "VKNP%s\r\n", volume_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-
-                        xasprintf(&output_message, _("CRITICAL - Volume '%s' does not exist!"), volume_name);
-                        result = STATE_CRITICAL;
-
-                } else {
-
-                        non_purgeable_disk_space = strtoul(recv_buffer, NULL, 10);
-
-                        close(sd);
-                        my_tcp_connect(server_address, server_port, &sd);
-
-                        xasprintf(&send_buffer, "VKS%s\r\n", volume_name);
-                        result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                        if (result != STATE_OK)
-                                return result;
-                        total_disk_space = strtoul(recv_buffer, NULL, 10);
-
-                        percent_non_purgeable_space = (unsigned long)(((double)non_purgeable_disk_space / (double)total_disk_space) * 100.0);
-
-                        if (check_critical_value && percent_non_purgeable_space >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && percent_non_purgeable_space >= warning_value)
-                                result = STATE_WARNING;
-                        purgeable_disk_space /= 1024;
-                        xasprintf(&output_message, _("%lu MB (%lu%%) not yet purgeable on volume %s"), non_purgeable_disk_space,
-                                          percent_non_purgeable_space, volume_name);
-                }
-
-                /* check # of open files */
-        } else if (vars_to_check == OFILES) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S18\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                open_files = atoi(recv_buffer);
-
-                if (check_critical_value && open_files >= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && open_files >= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("%lu open files|Openfiles=%lu;%lu;%lu;0,0"), open_files, open_files, warning_value, critical_value);
-
-                /* check # of abended threads (Netware > 5.x only) */
-        } else if (vars_to_check == ABENDS) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S17\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                abended_threads = atoi(recv_buffer);
-
-                if (check_critical_value && abended_threads >= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && abended_threads >= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("%lu abended threads|Abends=%lu;%lu;%lu;;"), abended_threads, abended_threads, warning_value,
-                                  critical_value);
-
-                /* check # of current service processes (Netware 5.x only) */
-        } else if (vars_to_check == CSPROCS) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S20\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                max_service_processes = atoi(recv_buffer);
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S21\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                current_service_processes = atoi(recv_buffer);
-
-                if (check_critical_value && current_service_processes >= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && current_service_processes >= warning_value)
-                        result = STATE_WARNING;
-
-                xasprintf(&output_message, _("%lu current service processes (%lu max)|Processes=%lu;%lu;%lu;0;%lu"), current_service_processes,
-                                  max_service_processes, current_service_processes, warning_value, critical_value, max_service_processes);
-
-                /* check # Timesync Status */
-        } else if (vars_to_check == TSYNC) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S22\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                time_sync_status = atoi(recv_buffer);
-
-                if (time_sync_status == 0) {
-                        result = STATE_CRITICAL;
-                        xasprintf(&output_message, _("CRITICAL - Time not in sync with network!"));
-                } else {
-                        xasprintf(&output_message, _("OK - Time in sync with network!"));
-                }
-
-                /* check LRU sitting time in secondss */
-        } else if (vars_to_check == LRUS) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S4\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                lru_time = strtoul(recv_buffer, NULL, 10);
-
-                if (check_critical_value && lru_time <= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && lru_time <= warning_value)
-                        result = STATE_WARNING;
-                xasprintf(&output_message, _("LRU sitting time = %lu seconds"), lru_time);
-
-                /* check % dirty cacheobuffers as a percentage of the total*/
-        } else if (vars_to_check == DCB) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S6\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                dirty_cache_buffers = atoi(recv_buffer);
-
-                if (check_critical_value && dirty_cache_buffers <= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && dirty_cache_buffers <= warning_value)
-                        result = STATE_WARNING;
-                xasprintf(&output_message, _("Dirty cache buffers = %lu%% of the total|DCB=%lu;%lu;%lu;0;100"), dirty_cache_buffers,
-                                  dirty_cache_buffers, warning_value, critical_value);
-
-                /* check % total cache buffers as a percentage of the original*/
-        } else if (vars_to_check == TCB) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                send_buffer = strdup("S7\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-                total_cache_buffers = atoi(recv_buffer);
-
-                if (check_critical_value && total_cache_buffers <= critical_value)
-                        result = STATE_CRITICAL;
-                else if (check_warning_value && total_cache_buffers <= warning_value)
-                        result = STATE_WARNING;
-                xasprintf(&output_message, _("Total cache buffers = %lu%% of the original|TCB=%lu;%lu;%lu;0;100"), total_cache_buffers,
-                                  total_cache_buffers, warning_value, critical_value);
-
-        } else if (vars_to_check == DSVER) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S13\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                recv_buffer[strlen(recv_buffer) - 1] = 0;
-
-                xasprintf(&output_message, _("NDS Version %s"), recv_buffer);
-
-        } else if (vars_to_check == UPTIME) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "UPTIME\r\n");
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                recv_buffer[sizeof(recv_buffer) - 1] = 0;
-                recv_buffer[strlen(recv_buffer) - 1] = 0;
-
-                xasprintf(&output_message, _("Up %s"), recv_buffer);
-
-        } else if (vars_to_check == NLM) {
-
-                close(sd);
-                my_tcp_connect(server_address, server_port, &sd);
-
-                xasprintf(&send_buffer, "S24:%s\r\n", nlm_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                recv_buffer[strlen(recv_buffer) - 1] = 0;
-                if (strcmp(recv_buffer, "-1")) {
-                        xasprintf(&output_message, _("Module %s version %s is loaded"), nlm_name, recv_buffer);
-                } else {
-                        result = STATE_CRITICAL;
-                        xasprintf(&output_message, _("Module %s is not loaded"), nlm_name);
-                }
-        } else if (vars_to_check == NRMP) {
-
-                xasprintf(&send_buffer, "NRMP:%s\r\n", nrmp_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nrmp_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nrmp_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nrmp_value <= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nrmp_value <= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nrmp_name, nrmp_value, nrmp_name, nrmp_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NRMM) {
-
-                xasprintf(&send_buffer, "NRMM:%s\r\n", nrmm_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nrmm_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nrmm_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nrmm_value <= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nrmm_value <= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nrmm_name, nrmm_value, nrmm_name, nrmm_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NRMS) {
-
-                xasprintf(&send_buffer, "NRMS:%s\r\n", nrms_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nrms_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nrms_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nrms_value >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nrms_value >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nrms_name, nrms_value, nrms_name, nrms_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NSS1) {
-
-                xasprintf(&send_buffer, "NSS1:%s\r\n", nss1_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nss1_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nss1_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nss1_value >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nss1_value >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nss1_name, nss1_value, nss1_name, nss1_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NSS2) {
-
-                xasprintf(&send_buffer, "NSS2:%s\r\n", nss2_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nss2_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nss2_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nss2_value >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nss2_value >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nss2_name, nss2_value, nss2_name, nss2_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NSS3) {
-
-                xasprintf(&send_buffer, "NSS3:%s\r\n", nss3_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nss3_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nss3_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nss3_value >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nss3_value >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nss3_name, nss3_value, nss3_name, nss3_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NSS4) {
-
-                xasprintf(&send_buffer, "NSS4:%s\r\n", nss4_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nss4_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nss4_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nss4_value >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nss4_value >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nss4_name, nss4_value, nss4_name, nss4_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NSS5) {
-
-                xasprintf(&send_buffer, "NSS5:%s\r\n", nss5_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nss5_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nss5_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nss5_value >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nss5_value >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nss5_name, nss5_value, nss5_name, nss5_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NSS6) {
-
-                xasprintf(&send_buffer, "NSS6:%s\r\n", nss6_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nss6_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nss6_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nss6_value >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nss6_value >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nss6_name, nss6_value, nss6_name, nss6_value, warning_value,
-                                          critical_value);
-                }
-
-        } else if (vars_to_check == NSS7) {
-
-                xasprintf(&send_buffer, "NSS7:%s\r\n", nss7_name);
-                result = send_tcp_request(sd, send_buffer, recv_buffer, sizeof(recv_buffer));
-                if (result != STATE_OK)
-                        return result;
-
-                if (!strcmp(recv_buffer, "-1\n")) {
-                        xasprintf(&output_message, _("CRITICAL - Value '%s' does not exist!"), nss7_name);
-                        result = STATE_CRITICAL;
-                } else {
-                        nss7_value = strtoul(recv_buffer, NULL, 10);
-                        if (check_critical_value && nss7_value >= critical_value)
-                                result = STATE_CRITICAL;
-                        else if (check_warning_value && nss7_value >= warning_value)
-                                result = STATE_WARNING;
-                        xasprintf(&output_message, _("%s is  %lu|%s=%lu;%lu;%lu;;"), nss7_name, nss7_value, nss7_name, nss7_value, warning_value,
-                                          critical_value);
-                }
-
-        } else {
-
-                output_message = strdup(_("Nothing to check!\n"));
-                result = STATE_UNKNOWN;
-        }
-
-        close(sd);
-
-        /* reset timeout */
-        alarm(0);
-
-        printf("%s%s\n", netware_version, output_message);
-
-        return result;
-}
-
-/* process command-line arguments */
-int process_arguments(int argc, char **argv) {
-        int c;
-
-        int option = 0;
-        static struct option longopts[] = {{"port", required_argument, 0, 'p'},     {"timeout", required_argument, 0, 't'},
-                                                                           {"critical", required_argument, 0, 'c'}, {"warning", required_argument, 0, 'w'},
-                                                                           {"variable", required_argument, 0, 'v'}, {"hostname", required_argument, 0, 'H'},
-                                                                           {"osversion", no_argument, 0, 'o'},      {"version", no_argument, 0, 'V'},
-                                                                           {"help", no_argument, 0, 'h'},           {0, 0, 0, 0}};
-
-        /* no options were supplied */
-        if (argc < 2)
-                return ERROR;
-
-        /* backwards compatibility */
-        if (!is_option(argv[1])) {
-                server_address = argv[1];
-                argv[1] = argv[0];
-                argv = &argv[1];
-                argc--;
-        }
-
-        for (c = 1; c < argc; c++) {
-                if (strcmp("-to", argv[c]) == 0)
-                        strcpy(argv[c], "-t");
-                else if (strcmp("-wv", argv[c]) == 0)
-                        strcpy(argv[c], "-w");
-                else if (strcmp("-cv", argv[c]) == 0)
-                        strcpy(argv[c], "-c");
-        }
-
-        while (1) {
-                c = getopt_long(argc, argv, "+hoVH:t:c:w:p:v:", longopts, &option);
-
-                if (c == -1 || c == EOF || c == 1)
-                        break;
-
-                switch (c) {
-                case '?': /* print short usage statement if args not parsable */
-                        usage5();
-                case 'h': /* help */
-                        print_help();
-                        exit(STATE_UNKNOWN);
-                case 'V': /* version */
-                        print_revision(progname, NP_VERSION);
-                        exit(STATE_UNKNOWN);
-                case 'H': /* hostname */
-                        server_address = optarg;
-                        break;
-                case 'o': /* display nos version */
-                        check_netware_version = true;
-                        break;
-                case 'p': /* port */
-                        if (is_intnonneg(optarg))
-                                server_port = atoi(optarg);
-                        else
-                                die(STATE_UNKNOWN, _("Server port an integer\n"));
-                        break;
-                case 'v':
-                        if (strlen(optarg) < 3)
-                                return ERROR;
-                        if (!strcmp(optarg, "LOAD1"))
-                                vars_to_check = LOAD1;
-                        else if (!strcmp(optarg, "LOAD5"))
-                                vars_to_check = LOAD5;
-                        else if (!strcmp(optarg, "LOAD15"))
-                                vars_to_check = LOAD15;
-                        else if (!strcmp(optarg, "CONNS"))
-                                vars_to_check = CONNS;
-                        else if (!strcmp(optarg, "LTCH"))
-                                vars_to_check = LTCH;
-                        else if (!strcmp(optarg, "DCB"))
-                                vars_to_check = DCB;
-                        else if (!strcmp(optarg, "TCB"))
-                                vars_to_check = TCB;
-                        else if (!strcmp(optarg, "CBUFF"))
-                                vars_to_check = CBUFF;
-                        else if (!strcmp(optarg, "CDBUFF"))
-                                vars_to_check = CDBUFF;
-                        else if (!strcmp(optarg, "LRUM"))
-                                vars_to_check = LRUM;
-                        else if (!strcmp(optarg, "LRUS"))
-                                vars_to_check = LRUS;
-                        else if (strncmp(optarg, "VPF", 3) == 0) {
-                                vars_to_check = VPF;
-                                volume_name = strdup(optarg + 3);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (strncmp(optarg, "VKF", 3) == 0) {
-                                vars_to_check = VKF;
-                                volume_name = strdup(optarg + 3);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (strncmp(optarg, "VMF", 3) == 0) {
-                                vars_to_check = VMF;
-                                volume_name = strdup(optarg + 3);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (!strcmp(optarg, "DSDB"))
-                                vars_to_check = DSDB;
-                        else if (!strcmp(optarg, "LOGINS"))
-                                vars_to_check = LOGINS;
-                        else if (!strcmp(optarg, "NRMH"))
-                                vars_to_check = NRMH;
-                        else if (!strcmp(optarg, "UPRB"))
-                                vars_to_check = UPRB;
-                        else if (!strcmp(optarg, "PUPRB"))
-                                vars_to_check = PUPRB;
-                        else if (!strncmp(optarg, "SAPENTRIES", 10)) {
-                                vars_to_check = SAPENTRIES;
-                                if (strlen(optarg) > 10)
-                                        sap_number = atoi(optarg + 10);
-                                else
-                                        sap_number = -1;
-                        } else if (!strcmp(optarg, "OFILES"))
-                                vars_to_check = OFILES;
-                        else if (strncmp(optarg, "VKP", 3) == 0) {
-                                vars_to_check = VKP;
-                                volume_name = strdup(optarg + 3);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (strncmp(optarg, "VMP", 3) == 0) {
-                                vars_to_check = VMP;
-                                volume_name = strdup(optarg + 3);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (strncmp(optarg, "VMU", 3) == 0) {
-                                vars_to_check = VMU;
-                                volume_name = strdup(optarg + 3);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (strncmp(optarg, "VPU", 3) == 0) {
-                                vars_to_check = VPU;
-                                volume_name = strdup(optarg + 3);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (strncmp(optarg, "VPP", 3) == 0) {
-                                vars_to_check = VPP;
-                                volume_name = strdup(optarg + 3);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (strncmp(optarg, "VKNP", 4) == 0) {
-                                vars_to_check = VKNP;
-                                volume_name = strdup(optarg + 4);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (strncmp(optarg, "VPNP", 4) == 0) {
-                                vars_to_check = VPNP;
-                                volume_name = strdup(optarg + 4);
-                                if (!strcmp(volume_name, ""))
-                                        volume_name = strdup("SYS");
-                        } else if (!strcmp(optarg, "ABENDS"))
-                                vars_to_check = ABENDS;
-                        else if (!strcmp(optarg, "CSPROCS"))
-                                vars_to_check = CSPROCS;
-                        else if (!strcmp(optarg, "TSYNC"))
-                                vars_to_check = TSYNC;
-                        else if (!strcmp(optarg, "DSVER"))
-                                vars_to_check = DSVER;
-                        else if (!strcmp(optarg, "UPTIME")) {
-                                vars_to_check = UPTIME;
-                        } else if (strncmp(optarg, "NLM:", 4) == 0) {
-                                vars_to_check = NLM;
-                                nlm_name = strdup(optarg + 4);
-                        } else if (strncmp(optarg, "NRMP", 4) == 0) {
-                                vars_to_check = NRMP;
-                                nrmp_name = strdup(optarg + 4);
-                                if (!strcmp(nrmp_name, ""))
-                                        nrmp_name = strdup("AVAILABLE_MEMORY");
-                        } else if (strncmp(optarg, "NRMM", 4) == 0) {
-                                vars_to_check = NRMM;
-                                nrmm_name = strdup(optarg + 4);
-                                if (!strcmp(nrmm_name, ""))
-                                        nrmm_name = strdup("AVAILABLE_CACHE_MEMORY");
-
-                        }
-
-                        else if (strncmp(optarg, "NRMS", 4) == 0) {
-                                vars_to_check = NRMS;
-                                nrms_name = strdup(optarg + 4);
-                                if (!strcmp(nrms_name, ""))
-                                        nrms_name = strdup("USED_SWAP_SPACE");
-
-                        }
-
-                        else if (strncmp(optarg, "NSS1", 4) == 0) {
-                                vars_to_check = NSS1;
-                                nss1_name = strdup(optarg + 4);
-                                if (!strcmp(nss1_name, ""))
-                                        nss1_name = strdup("CURRENTBUFFERCACHESIZE");
-
-                        }
-
-                        else if (strncmp(optarg, "NSS2", 4) == 0) {
-                                vars_to_check = NSS2;
-                                nss2_name = strdup(optarg + 4);
-                                if (!strcmp(nss2_name, ""))
-                                        nss2_name = strdup("CACHEHITS");
-
-                        }
-
-                        else if (strncmp(optarg, "NSS3", 4) == 0) {
-                                vars_to_check = NSS3;
-                                nss3_name = strdup(optarg + 4);
-                                if (!strcmp(nss3_name, ""))
-                                        nss3_name = strdup("CACHEGITPERCENT");
-
-                        }
-
-                        else if (strncmp(optarg, "NSS4", 4) == 0) {
-                                vars_to_check = NSS4;
-                                nss4_name = strdup(optarg + 4);
-                                if (!strcmp(nss4_name, ""))
-                                        nss4_name = strdup("CURRENTOPENCOUNT");
-
-                        }
-
-                        else if (strncmp(optarg, "NSS5", 4) == 0) {
-                                vars_to_check = NSS5;
-                                nss5_name = strdup(optarg + 4);
-                                if (!strcmp(nss5_name, ""))
-                                        nss5_name = strdup("CACHEMISSES");
-
-                        }
-
-                        else if (strncmp(optarg, "NSS6", 4) == 0) {
-                                vars_to_check = NSS6;
-                                nss6_name = strdup(optarg + 4);
-                                if (!strcmp(nss6_name, ""))
-                                        nss6_name = strdup("PENDINGWORKSCOUNT");
-
-                        }
-
-                        else if (strncmp(optarg, "NSS7", 4) == 0) {
-                                vars_to_check = NSS7;
-                                nss7_name = strdup(optarg + 4);
-                                if (!strcmp(nss7_name, ""))
-                                        nss7_name = strdup("CACHESIZE");
-
-                        }
-
-                        else
-                                return ERROR;
-                        break;
-                case 'w': /* warning threshold */
-                        warning_value = strtoul(optarg, NULL, 10);
-                        check_warning_value = true;
-                        break;
-                case 'c': /* critical threshold */
-                        critical_value = strtoul(optarg, NULL, 10);
-                        check_critical_value = true;
-                        break;
-                case 't': /* timeout */
-                        socket_timeout = atoi(optarg);
-                        if (socket_timeout <= 0)
-                                return ERROR;
-                }
-        }
-
-        return OK;
-}
-
-void print_help(void) {
-        char *myport;
-        xasprintf(&myport, "%d", PORT);
-
-        print_revision(progname, NP_VERSION);
-
-        printf("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
-        printf(COPYRIGHT, copyright, email);
-
-        printf("%s\n", _("This plugin attempts to contact the MRTGEXT NLM running on a"));
-        printf("%s\n", _("Novell server to gather the requested system information."));
-
-        printf("\n\n");
-
-        print_usage();
-
-        printf(UT_HELP_VRSN);
-        printf(UT_EXTRA_OPTS);
-
-        printf(UT_HOST_PORT, 'p', myport);
-
-        printf(" %s\n", "-v, --variable=STRING");
-        printf("   %s\n", _("Variable to check.  Valid variables include:"));
-        printf("    %s\n", _("LOAD1     = 1 minute average CPU load"));
-        printf("    %s\n", _("LOAD5     = 5 minute average CPU load"));
-        printf("    %s\n", _("LOAD15    = 15 minute average CPU load"));
-        printf("    %s\n", _("CSPROCS   = number of current service processes (NW 5.x only)"));
-        printf("    %s\n", _("ABENDS    = number of abended threads (NW 5.x only)"));
-        printf("    %s\n", _("UPTIME    = server uptime"));
-        printf("    %s\n", _("LTCH      = percent long term cache hits"));
-        printf("    %s\n", _("CBUFF     = current number of cache buffers"));
-        printf("    %s\n", _("CDBUFF    = current number of dirty cache buffers"));
-        printf("    %s\n", _("DCB       = dirty cache buffers as a percentage of the total"));
-        printf("    %s\n", _("TCB       = dirty cache buffers as a percentage of the original"));
-        printf("    %s\n", _("OFILES    = number of open files"));
-        printf("    %s\n", _("    VMF<vol>  = MB of free space on Volume <vol>"));
-        printf("    %s\n", _("    VMU<vol>  = MB used space on Volume <vol>"));
-        printf("    %s\n", _("    VPU<vol>  = percent used space on Volume <vol>"));
-        printf("    %s\n", _("    VMP<vol>  = MB of purgeable space on Volume <vol>"));
-        printf("    %s\n", _("    VPF<vol>  = percent free space on volume <vol>"));
-        printf("    %s\n", _("    VKF<vol>  = KB of free space on volume <vol>"));
-        printf("    %s\n", _("    VPP<vol>  = percent purgeable space on volume <vol>"));
-        printf("    %s\n", _("    VKP<vol>  = KB of purgeable space on volume <vol>"));
-        printf("    %s\n", _("    VPNP<vol> = percent not yet purgeable space on volume <vol>"));
-        printf("    %s\n", _("    VKNP<vol> = KB of not yet purgeable space on volume <vol>"));
-        printf("    %s\n", _("    LRUM      = LRU sitting time in minutes"));
-        printf("    %s\n", _("    LRUS      = LRU sitting time in seconds"));
-        printf("    %s\n", _("    DSDB      = check to see if DS Database is open"));
-        printf("    %s\n", _("    DSVER     = NDS version"));
-        printf("    %s\n", _("    UPRB      = used packet receive buffers"));
-        printf("    %s\n", _("    PUPRB     = percent (of max) used packet receive buffers"));
-        printf("    %s\n", _("    SAPENTRIES = number of entries in the SAP table"));
-        printf("    %s\n", _("    SAPENTRIES<n> = number of entries in the SAP table for SAP type <n>"));
-        printf("    %s\n", _("    TSYNC     = timesync status"));
-        printf("    %s\n", _("    LOGINS    = check to see if logins are enabled"));
-        printf("    %s\n", _("    CONNS     = number of currently licensed connections"));
-        printf("    %s\n", _("    NRMH  = NRM Summary Status"));
-        printf("    %s\n", _("    NRMP<stat> = Returns the current value for a NRM health item"));
-        printf("    %s\n", _("    NRMM<stat> = Returns the current memory stats from NRM"));
-        printf("    %s\n", _("    NRMS<stat> = Returns the current Swapfile stats from NRM"));
-        printf("    %s\n", _("    NSS1<stat> = Statistics from _Admin:Manage_NSS\\GeneralStats.xml"));
-        printf("    %s\n", _("    NSS3<stat> = Statistics from _Admin:Manage_NSS\\NameCache.xml"));
-        printf("    %s\n", _("    NSS4<stat> = Statistics from _Admin:Manage_NSS\\FileStats.xml"));
-        printf("    %s\n", _("    NSS5<stat> = Statistics from _Admin:Manage_NSS\\ObjectCache.xml"));
-        printf("    %s\n", _("    NSS6<stat> = Statistics from _Admin:Manage_NSS\\Thread.xml"));
-        printf("    %s\n", _("    NSS7<stat> = Statistics from _Admin:Manage_NSS\\AuthorizationCache.xml"));
-        printf("    %s\n", _("    NLM:<nlm> = check if NLM is loaded and report version"));
-        printf("    %s\n", _("                (e.g. NLM:TSANDS.NLM)"));
-        printf("\n");
-        printf(" %s\n", "-w, --warning=INTEGER");
-        printf("    %s\n", _("Threshold which will result in a warning status"));
-        printf(" %s\n", "-c, --critical=INTEGER");
-        printf("    %s\n", _("Threshold which will result in a critical status"));
-        printf(" %s\n", "-o, --osversion");
-        printf("    %s\n", _("Include server version string in results"));
-
-        printf(UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
-
-        printf("\n");
-        printf("%s\n", _("Notes:"));
-        printf(" %s\n", _("- This plugin requires that the MRTGEXT.NLM file from James Drews' MRTG"));
-        printf(" %s\n", _("  extension for NetWare be loaded on the Novell servers you wish to check."));
-        printf(" %s\n", _("  (available from http://www.engr.wisc.edu/~drews/mrtg/)"));
-        printf(" %s\n", _("- Values for critical thresholds should be lower than warning thresholds"));
-        printf(" %s\n", _("  when the following variables are checked: VPF, VKF, LTCH, CBUFF, DCB, "));
-        printf(" %s\n", _("  TCB, LRUS and LRUM."));
-
-        printf(UT_SUPPORT);
-}
-
-void print_usage(void) {
-        printf("%s\n", _("Usage:"));
-        printf("%s -H host [-p port] [-v variable] [-w warning] [-c critical] [-t timeout]\n", progname);
-}
diff --git a/plugins/check_ping.c b/plugins/check_ping.c
index 940b9475..6bcdeaad 100644
--- a/plugins/check_ping.c
+++ b/plugins/check_ping.c
@@ -116,10 +116,10 @@ int main(int argc, char **argv) {
 #       ifdef PING_HAS_TIMEOUT
                 xasprintf(&cmd, rawcmd, timeout_interval, config.max_packets, config.addresses[i]);
 #       else
-                xasprintf(&cmd, rawcmd, config.max_packets, addresses[i]);
+                xasprintf(&cmd, rawcmd, config.max_packets, config.addresses[i]);
 #       endif
 #else
-                xasprintf(&cmd, rawcmd, addresses[i], config.max_packets);
+                xasprintf(&cmd, rawcmd, config.addresses[i], config.max_packets);
 #endif
 
                 if (verbose >= 2) {
diff --git a/plugins/check_swap.c b/plugins/check_swap.c
index cb95949a..435a104e 100644
--- a/plugins/check_swap.c
+++ b/plugins/check_swap.c
@@ -90,6 +90,14 @@ int main(int argc, char **argv) {
                 exit(STATE_UNKNOWN);
         }
 
+        if (verbose) {
+                printf("Swap retrieval result:\n"
+                           "\tFree: %llu\n"
+                           "\tUsed: %llu\n"
+                           "\tTotal: %llu\n",
+                           data.metrics.free, data.metrics.used, data.metrics.total);
+        }
+
         double percent_used;
         mp_check overall = mp_check_init();
         if (config.output_format_is_set) {
diff --git a/plugins/check_swap.d/check_swap.h b/plugins/check_swap.d/check_swap.h
index 1000fc9e..da08d65a 100644
--- a/plugins/check_swap.d/check_swap.h
+++ b/plugins/check_swap.d/check_swap.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #include "../common.h"
-#include "output.h"
+#include "../../lib/output.h"
+#include "../../lib/states.h"
 
 #ifndef SWAP_CONVERSION
 #       define SWAP_CONVERSION 1
@@ -26,7 +27,7 @@ typedef struct {
 
 typedef struct {
         bool allswaps;
-        int no_swap_state;
+        mp_state_enum no_swap_state;
         bool warn_is_set;
         check_swap_threshold warn;
         bool crit_is_set;
diff --git a/plugins/check_swap.d/swap.c b/plugins/check_swap.d/swap.c
index 180d5037..634f80d9 100644
--- a/plugins/check_swap.d/swap.c
+++ b/plugins/check_swap.d/swap.c
@@ -68,7 +68,7 @@ swap_result getSwapFromProcMeminfo(char proc_meminfo[]) {
         FILE *meminfo_file_ptr;
         meminfo_file_ptr = fopen(proc_meminfo, "r");
 
-        swap_result result = {0};
+        swap_result result = {};
         result.errorcode = STATE_UNKNOWN;
 
         if (meminfo_file_ptr == NULL) {
@@ -78,83 +78,71 @@ swap_result getSwapFromProcMeminfo(char proc_meminfo[]) {
                 return result;
         }
 
-        uint64_t swap_total = 0;
-        uint64_t swap_used = 0;
-        uint64_t swap_free = 0;
+        unsigned long swap_total = 0;
+        unsigned long swap_used = 0;
+        unsigned long swap_free = 0;
 
         bool found_total = false;
-        bool found_used = false;
         bool found_free = false;
 
         char input_buffer[MAX_INPUT_BUFFER];
         char str[32];
 
         while (fgets(input_buffer, MAX_INPUT_BUFFER - 1, meminfo_file_ptr)) {
-                uint64_t tmp_KB = 0;
 
                 /*
                  * The following sscanf call looks for a line looking like: "Swap: 123
-                 * 123 123" On which kind of system this format exists, I can not say,
-                 * but I wanted to document this for people who are not adapt with
-                 * sscanf anymore, like me
-                 * Also the units used here are unclear and probably wrong
+                 * 123 123" which exists on NetBSD (at least),
+                 * The unit should be Bytes
                  */
                 if (sscanf(input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %lu %lu %lu", &swap_total, &swap_used, &swap_free) == 3) {
-
-                        result.metrics.total += swap_total;
-                        result.metrics.used += swap_used;
-                        result.metrics.free += swap_free;
-
                         found_total = true;
                         found_free = true;
-                        found_used = true;
-
                         // Set error
                         result.errorcode = STATE_OK;
+                        // Break out of fgets here, since both scanf expressions might match (NetBSD for example)
+                        break;
+                }
+
+                /*
+                 * The following sscanf call looks for lines looking like:
+                 * "SwapTotal: 123" and "SwapFree: 123" This format exists at least
+                 * on Debian Linux with a 5.* kernel
+                 */
+                unsigned long tmp_KB = 0;
+                int sscanf_result = sscanf(input_buffer,
+                                                                   "%*[S]%*[w]%*[a]%*[p]%[TotalFreCchd]%*[:] %lu "
+                                                                   "%*[k]%*[B]",
+                                                                   str, &tmp_KB);
+
+                if (sscanf_result == 2) {
+
+                        if (verbose >= 3) {
+                                printf("Got %s with %lu\n", str, tmp_KB);
+                        }
 
-                        /*
-                         * The following sscanf call looks for lines looking like:
-                         * "SwapTotal: 123" and "SwapFree: 123" This format exists at least
-                         * on Debian Linux with a 5.* kernel
-                         */
-                } else {
-                        int sscanf_result = sscanf(input_buffer,
-                                                                           "%*[S]%*[w]%*[a]%*[p]%[TotalFreCchd]%*[:] %lu "
-                                                                           "%*[k]%*[B]",
-                                                                           str, &tmp_KB);
-
-                        if (sscanf_result == 2) {
-
-                                if (verbose >= 3) {
-                                        printf("Got %s with %lu\n", str, tmp_KB);
-                                }
-
-                                /* I think this part is always in Kb, so convert to bytes */
-                                if (strcmp("Total", str) == 0) {
-                                        swap_total = tmp_KB * 1000;
-                                        found_total = true;
-                                } else if (strcmp("Free", str) == 0) {
-                                        swap_free = swap_free + tmp_KB * 1000;
-                                        found_free = true;
-                                        found_used = true; // No explicit used metric available
-                                } else if (strcmp("Cached", str) == 0) {
-                                        swap_free = swap_free + tmp_KB * 1000;
-                                        found_free = true;
-                                        found_used = true; // No explicit used metric available
-                                }
-
-                                result.errorcode = STATE_OK;
+                        /* I think this part is always in Kb, so convert to bytes */
+                        if (strcmp("Total", str) == 0) {
+                                swap_total = tmp_KB * 1000;
+                                found_total = true;
+                        } else if (strcmp("Free", str) == 0) {
+                                swap_free += tmp_KB * 1000;
+                                found_free = true;
+                        } else if (strcmp("Cached", str) == 0) {
+                                swap_free += tmp_KB * 1000;
                         }
+
+                        result.errorcode = STATE_OK;
                 }
         }
 
         fclose(meminfo_file_ptr);
 
         result.metrics.total = swap_total;
-        result.metrics.used = swap_total - swap_free;
         result.metrics.free = swap_free;
+        result.metrics.used = swap_total - swap_free;
 
-        if (!found_free || !found_total || !found_used) {
+        if (!found_free || !found_total) {
                 result.errorcode = STATE_UNKNOWN;
         }
 
@@ -297,8 +285,14 @@ struct swapent {
 };
 
 #else
+
+// Includes for NetBSD
+#       include <unistd.h>
+#       include <sys/swap.h>
+
 #       define bsd_swapctl swapctl
-#endif
+
+#endif // CHECK_SWAP_SWAPCTL_BSD
 
 swap_result getSwapFromSwapctl_BSD(swap_config config) {
         /* get the number of active swap devices */
@@ -322,8 +316,8 @@ swap_result getSwapFromSwapctl_BSD(swap_config config) {
         unsigned long long used_swap_mb = 0;
 
         for (int i = 0; i < nswaps; i++) {
-                dsktotal_mb = (float)ent[i].se_nblks / (float)config.conversion_factor;
-                dskused_mb = (float)ent[i].se_inuse / (float)config.conversion_factor;
+                dsktotal_mb = (double)ent[i].se_nblks / (double)config.conversion_factor;
+                dskused_mb = (double)ent[i].se_inuse / (double)config.conversion_factor;
                 dskfree_mb = (dsktotal_mb - dskused_mb);
 
                 if (config.allswaps && dsktotal_mb > 0) {
diff --git a/plugins/check_tcp.c b/plugins/check_tcp.c
index 49ad096c..22dcc74e 100644
--- a/plugins/check_tcp.c
+++ b/plugins/check_tcp.c
@@ -3,7 +3,7 @@
  * Monitoring check_tcp plugin
  *
  * License: GPL
- * Copyright (c) 1999-2024 Monitoring Plugins Development Team
+ * Copyright (c) 1999-2025 Monitoring Plugins Development Team
  *
  * Description:
  *
@@ -29,74 +29,63 @@
 
 /* progname "check_tcp" changes depending on symlink called */
 char *progname;
-const char *copyright = "1999-2024";
+const char *copyright = "1999-2025";
 const char *email = "devel@monitoring-plugins.org";
 
-#include "common.h"
-#include "netutils.h"
-#include "utils.h"
-#include "utils_tcp.h"
+#include "./common.h"
+#include "./netutils.h"
+#include "./utils.h"
+#include "./check_tcp.d/config.h"
+#include "output.h"
+#include "states.h"
 
+#include <sys/types.h>
 #include <ctype.h>
 #include <sys/select.h>
 
+ssize_t my_recv(int socket_descriptor, char *buf, size_t len, bool use_tls) {
 #ifdef HAVE_SSL
-static bool check_cert = false;
-static int days_till_exp_warn, days_till_exp_crit;
-#       define my_recv(buf, len) ((flags & FLAG_SSL) ? np_net_ssl_read(buf, len) : read(sd, buf, len))
-#       define my_send(buf, len) ((flags & FLAG_SSL) ? np_net_ssl_write(buf, len) : send(sd, buf, len, 0))
-#else
-#       define my_recv(buf, len) read(sd, buf, len)
-#       define my_send(buf, len) send(sd, buf, len, 0)
+        if (use_tls) {
+                return np_net_ssl_read(buf, (int)len);
+        }
 #endif
+        return read(socket_descriptor, buf, len);
+}
 
-/* int my_recv(char *, size_t); */
-static int process_arguments(int /*argc*/, char ** /*argv*/);
-static void print_help(void);
+ssize_t my_send(int socket_descriptor, char *buf, size_t len, bool use_tls) {
+#ifdef HAVE_SSL
+        if (use_tls) {
+                return np_net_ssl_write(buf, (int)len);
+        }
+#endif
+        return write(socket_descriptor, buf, len);
+}
+
+typedef struct {
+        int errorcode;
+        check_tcp_config config;
+} check_tcp_config_wrapper;
+static check_tcp_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/, check_tcp_config /*config*/);
+void print_help(const char *service);
 void print_usage(void);
 
-#define EXPECT server_expect[0]
-static char *SERVICE = "TCP";
-static char *SEND = NULL;
-static char *QUIT = NULL;
-static int PROTOCOL = IPPROTO_TCP; /* most common is default */
-static int PORT = 0;
-static int READ_TIMEOUT = 2;
-
-static int server_port = 0;
-static char *server_address = NULL;
-static bool host_specified = false;
-static char *server_send = NULL;
-static char *server_quit = NULL;
-static char **server_expect;
-static size_t server_expect_count = 0;
-static ssize_t maxbytes = 0;
-static char **warn_codes = NULL;
-static size_t warn_codes_count = 0;
-static char **crit_codes = NULL;
-static size_t crit_codes_count = 0;
-static unsigned int delay = 0;
-static double warning_time = 0;
-static double critical_time = 0;
-static double elapsed_time = 0;
-static long microsec;
-static int sd = 0;
-#define MAXBUF 1024
-static char buffer[MAXBUF];
-static int expect_mismatch_state = STATE_WARNING;
-static int match_flags = NP_MATCH_EXACT;
+int verbosity = 0;
 
-#ifdef HAVE_SSL
-static char *sni = NULL;
-static bool sni_specified = false;
-#endif
+static const int READ_TIMEOUT = 2;
 
-#define FLAG_SSL         0x01
-#define FLAG_VERBOSE     0x02
-#define FLAG_TIME_WARN   0x04
-#define FLAG_TIME_CRIT   0x08
-#define FLAG_HIDE_OUTPUT 0x10
-static size_t flags;
+const int MAXBUF = 1024;
+
+const int DEFAULT_FTP_PORT = 21;
+const int DEFAULT_POP_PORT = 110;
+const int DEFAULT_SPOP_PORT = 995;
+const int DEFAULT_SMTP_PORT = 25;
+const int DEFAULT_SSMTP_PORT = 465;
+const int DEFAULT_IMAP_PORT = 143;
+const int DEFAULT_SIMAP_PORT = 993;
+const int DEFAULT_XMPP_C2S_PORT = 5222;
+const int DEFAULT_NNTP_PORT = 119;
+const int DEFAULT_NNTPS_PORT = 563;
+const int DEFAULT_CLAMD_PORT = 3310;
 
 int main(int argc, char **argv) {
         setlocale(LC_ALL, "");
@@ -105,277 +94,377 @@ int main(int argc, char **argv) {
 
         /* determine program- and service-name quickly */
         progname = strrchr(argv[0], '/');
-        if (progname != NULL)
+        if (progname != NULL) {
                 progname++;
-        else
+        } else {
                 progname = argv[0];
+        }
+
+        // Initialize config here with values from above,
+        // might be changed by on disk config or cli commands
+        check_tcp_config config = check_tcp_config_init();
 
         size_t prog_name_len = strlen(progname);
-        if (prog_name_len > 6 && !memcmp(progname, "check_", 6)) {
-                SERVICE = strdup(progname + 6);
-                for (size_t i = 0; i < prog_name_len - 6; i++)
-                        SERVICE[i] = toupper(SERVICE[i]);
+        const size_t prefix_length = strlen("check_");
+
+        if (prog_name_len <= prefix_length) {
+                die(STATE_UNKNOWN, _("Weird progname"));
+        }
+
+        if (!memcmp(progname, "check_", prefix_length)) {
+                config.service = strdup(progname + prefix_length);
+                if (config.service == NULL) {
+                        die(STATE_UNKNOWN, _("Allocation failed"));
+                }
+
+                for (size_t i = 0; i < prog_name_len - prefix_length; i++) {
+                        config.service[i] = toupper(config.service[i]);
+                }
         }
 
         /* set up a reasonable buffer at first (will be realloc()'ed if
          * user specifies other options) */
-        server_expect = calloc(2, sizeof(char *));
+        config.server_expect = calloc(2, sizeof(char *));
+
+        if (config.server_expect == NULL) {
+                die(STATE_UNKNOWN, _("Allocation failed"));
+        }
 
         /* determine defaults for this service's protocol */
-        if (!strncmp(SERVICE, "UDP", 3)) {
-                PROTOCOL = IPPROTO_UDP;
-        } else if (!strncmp(SERVICE, "FTP", 3)) {
-                EXPECT = "220";
-                QUIT = "QUIT\r\n";
-                PORT = 21;
-        } else if (!strncmp(SERVICE, "POP", 3) || !strncmp(SERVICE, "POP3", 4)) {
-                EXPECT = "+OK";
-                QUIT = "QUIT\r\n";
-                PORT = 110;
-        } else if (!strncmp(SERVICE, "SMTP", 4)) {
-                EXPECT = "220";
-                QUIT = "QUIT\r\n";
-                PORT = 25;
-        } else if (!strncmp(SERVICE, "IMAP", 4)) {
-                EXPECT = "* OK";
-                QUIT = "a1 LOGOUT\r\n";
-                PORT = 143;
+        if (!strncmp(config.service, "UDP", strlen("UDP"))) {
+                config.protocol = IPPROTO_UDP;
+        } else if (!strncmp(config.service, "FTP", strlen("FTP"))) {
+                config.server_expect[0] = "220";
+                config.quit = "QUIT\r\n";
+                config.server_port = DEFAULT_FTP_PORT;
+        } else if (!strncmp(config.service, "POP", strlen("POP")) || !strncmp(config.service, "POP3", strlen("POP3"))) {
+                config.server_expect[0] = "+OK";
+                config.quit = "QUIT\r\n";
+                config.server_port = DEFAULT_POP_PORT;
+        } else if (!strncmp(config.service, "SMTP", strlen("SMTP"))) {
+                config.server_expect[0] = "220";
+                config.quit = "QUIT\r\n";
+                config.server_port = DEFAULT_SMTP_PORT;
+        } else if (!strncmp(config.service, "IMAP", strlen("IMAP"))) {
+                config.server_expect[0] = "* OK";
+                config.quit = "a1 LOGOUT\r\n";
+                config.server_port = DEFAULT_IMAP_PORT;
         }
 #ifdef HAVE_SSL
-        else if (!strncmp(SERVICE, "SIMAP", 5)) {
-                EXPECT = "* OK";
-                QUIT = "a1 LOGOUT\r\n";
-                flags |= FLAG_SSL;
-                PORT = 993;
-        } else if (!strncmp(SERVICE, "SPOP", 4)) {
-                EXPECT = "+OK";
-                QUIT = "QUIT\r\n";
-                flags |= FLAG_SSL;
-                PORT = 995;
-        } else if (!strncmp(SERVICE, "SSMTP", 5)) {
-                EXPECT = "220";
-                QUIT = "QUIT\r\n";
-                flags |= FLAG_SSL;
-                PORT = 465;
-        } else if (!strncmp(SERVICE, "JABBER", 6)) {
-                SEND = "<stream:stream to=\'host\' xmlns=\'jabber:client\' xmlns:stream=\'http://etherx.jabber.org/streams\'>\n";
-                EXPECT = "<?xml version=\'1.0\'";
-                QUIT = "</stream:stream>\n";
-                flags |= FLAG_HIDE_OUTPUT;
-                PORT = 5222;
-        } else if (!strncmp(SERVICE, "NNTPS", 5)) {
-                server_expect_count = 2;
-                server_expect[0] = "200";
-                server_expect[1] = "201";
-                QUIT = "QUIT\r\n";
-                flags |= FLAG_SSL;
-                PORT = 563;
+        else if (!strncmp(config.service, "SIMAP", strlen("SIMAP"))) {
+                config.server_expect[0] = "* OK";
+                config.quit = "a1 LOGOUT\r\n";
+                config.use_tls = true;
+                config.server_port = DEFAULT_SIMAP_PORT;
+        } else if (!strncmp(config.service, "SPOP", strlen("SPOP"))) {
+                config.server_expect[0] = "+OK";
+                config.quit = "QUIT\r\n";
+                config.use_tls = true;
+                config.server_port = DEFAULT_SPOP_PORT;
+        } else if (!strncmp(config.service, "SSMTP", strlen("SSMTP"))) {
+                config.server_expect[0] = "220";
+                config.quit = "QUIT\r\n";
+                config.use_tls = true;
+                config.server_port = DEFAULT_SSMTP_PORT;
+        } else if (!strncmp(config.service, "JABBER", strlen("JABBER"))) {
+                config.send = "<stream:stream to=\'host\' xmlns=\'jabber:client\' xmlns:stream=\'http://etherx.jabber.org/streams\'>\n";
+                config.server_expect[0] = "<?xml version=\'1.0\'";
+                config.quit = "</stream:stream>\n";
+                config.hide_output = true;
+                config.server_port = DEFAULT_XMPP_C2S_PORT;
+        } else if (!strncmp(config.service, "NNTPS", strlen("NNTPS"))) {
+                config.server_expect_count = 2;
+                config.server_expect[0] = "200";
+                config.server_expect[1] = "201";
+                config.quit = "QUIT\r\n";
+                config.use_tls = true;
+                config.server_port = DEFAULT_NNTPS_PORT;
         }
 #endif
-        else if (!strncmp(SERVICE, "NNTP", 4)) {
-                server_expect_count = 2;
-                server_expect = malloc(sizeof(char *) * server_expect_count);
-                server_expect[0] = strdup("200");
-                server_expect[1] = strdup("201");
-                QUIT = "QUIT\r\n";
-                PORT = 119;
-        } else if (!strncmp(SERVICE, "CLAMD", 5)) {
-                SEND = "PING";
-                EXPECT = "PONG";
-                QUIT = NULL;
-                PORT = 3310;
+        else if (!strncmp(config.service, "NNTP", strlen("NNTP"))) {
+                config.server_expect_count = 2;
+                char **tmp = realloc(config.server_expect, config.server_expect_count * sizeof(char *));
+                if (tmp == NULL) {
+                        free(config.server_expect);
+                        die(STATE_UNKNOWN, _("Allocation failed"));
+                }
+                config.server_expect = tmp;
+
+                config.server_expect[0] = strdup("200");
+                config.server_expect[1] = strdup("201");
+                config.quit = "QUIT\r\n";
+                config.server_port = DEFAULT_NNTP_PORT;
+        } else if (!strncmp(config.service, "CLAMD", strlen("CLAMD"))) {
+                config.send = "PING";
+                config.server_expect[0] = "PONG";
+                config.quit = NULL;
+                config.server_port = DEFAULT_CLAMD_PORT;
         }
         /* fallthrough check, so it's supposed to use reverse matching */
-        else if (strcmp(SERVICE, "TCP"))
+        else if (strcmp(config.service, "TCP")) {
                 usage(_("CRITICAL - Generic check_tcp called with unknown service\n"));
-
-        server_address = "127.0.0.1";
-        server_port = PORT;
-        server_send = SEND;
-        server_quit = QUIT;
-        char *status = NULL;
+        }
 
         /* Parse extra opts if any */
         argv = np_extra_opts(&argc, argv, progname);
 
-        if (process_arguments(argc, argv) == ERROR)
+        check_tcp_config_wrapper paw = process_arguments(argc, argv, config);
+        if (paw.errorcode == ERROR) {
                 usage4(_("Could not parse arguments"));
+        }
 
-        if (flags & FLAG_VERBOSE) {
-                printf("Using service %s\n", SERVICE);
-                printf("Port: %d\n", server_port);
-                printf("flags: 0x%x\n", (int)flags);
+        config = paw.config;
+
+        if (verbosity > 0) {
+                printf("Using service %s\n", config.service);
+                printf("Port: %d\n", config.server_port);
         }
 
-        if (EXPECT && !server_expect_count)
-                server_expect_count++;
+        if ((config.server_expect_count == 0) && config.server_expect[0]) {
+                config.server_expect_count++;
+        }
 
-        if (PROTOCOL == IPPROTO_UDP && !(server_expect_count && server_send)) {
+        if (config.protocol == IPPROTO_UDP && !(config.server_expect_count && config.send)) {
                 usage(_("With UDP checks, a send/expect string must be specified."));
         }
 
+        // Initialize check stuff before setting timers
+        mp_check overall = mp_check_init();
+        if (config.output_format_set) {
+                mp_set_format(config.output_format);
+        }
+
         /* set up the timer */
         signal(SIGALRM, socket_timeout_alarm_handler);
         alarm(socket_timeout);
 
         /* try to connect to the host at the given port number */
-        struct timeval tv;
-        gettimeofday(&tv, NULL);
-
-        int result = STATE_UNKNOWN;
-        result = np_net_connect(server_address, server_port, &sd, PROTOCOL);
-        if (result == STATE_CRITICAL)
-                return econn_refuse_state;
+        struct timeval start_time;
+        gettimeofday(&start_time, NULL);
+
+        int socket_descriptor = 0;
+        mp_subcheck inital_connect_result = mp_subcheck_init();
+
+        // Try initial connection
+        if (np_net_connect(config.server_address, config.server_port, &socket_descriptor, config.protocol) == STATE_CRITICAL) {
+                // Early exit here, we got connection refused
+                inital_connect_result = mp_set_subcheck_state(inital_connect_result, config.econn_refuse_state);
+                xasprintf(&inital_connect_result.output, "Connection to %s on port %i was REFUSED", config.server_address, config.server_port);
+                mp_add_subcheck_to_check(&overall, inital_connect_result);
+                mp_exit(overall);
+        } else {
+                inital_connect_result = mp_set_subcheck_state(inital_connect_result, STATE_OK);
+                xasprintf(&inital_connect_result.output, "Connection to %s on port %i was a SUCCESS", config.server_address, config.server_port);
+                mp_add_subcheck_to_check(&overall, inital_connect_result);
+        }
 
 #ifdef HAVE_SSL
-        if (flags & FLAG_SSL) {
-                result = np_net_ssl_init_with_hostname(sd, (sni_specified ? sni : NULL));
-                if (result == STATE_OK && check_cert) {
-                        result = np_net_ssl_check_cert(days_till_exp_warn, days_till_exp_crit);
+        if (config.use_tls) {
+                mp_subcheck tls_connection_result = mp_subcheck_init();
+                mp_state_enum result = np_net_ssl_init_with_hostname(socket_descriptor, (config.sni_specified ? config.sni : NULL));
+                tls_connection_result = mp_set_subcheck_default_state(tls_connection_result, result);
+
+                if (result == STATE_OK) {
+                        xasprintf(&tls_connection_result.output, "TLS connection succeeded");
+
+                        if (config.check_cert) {
+                                result = np_net_ssl_check_cert(config.days_till_exp_warn, config.days_till_exp_crit);
+
+                                mp_subcheck tls_certificate_lifetime_result = mp_subcheck_init();
+                                tls_certificate_lifetime_result = mp_set_subcheck_state(tls_certificate_lifetime_result, result);
+
+                                if (result == STATE_OK) {
+                                        xasprintf(&tls_certificate_lifetime_result.output, "Certificate lifetime is within thresholds");
+                                } else if (result == STATE_WARNING) {
+                                        xasprintf(&tls_certificate_lifetime_result.output, "Certificate lifetime is violating warning threshold (%i)",
+                                                          config.days_till_exp_warn);
+                                } else if (result == STATE_CRITICAL) {
+                                        xasprintf(&tls_certificate_lifetime_result.output, "Certificate lifetime is violating critical threshold (%i)",
+                                                          config.days_till_exp_crit);
+                                } else {
+                                        xasprintf(&tls_certificate_lifetime_result.output, "Certificate lifetime is somehow unknown");
+                                }
+
+                                mp_add_subcheck_to_subcheck(&tls_connection_result, tls_certificate_lifetime_result);
+                        }
+
+                        mp_add_subcheck_to_check(&overall, tls_connection_result);
+                } else {
+                        xasprintf(&tls_connection_result.output, "TLS connection failed");
+                        mp_add_subcheck_to_check(&overall, tls_connection_result);
+
+                        if (socket_descriptor) {
+                                close(socket_descriptor);
+                        }
+                        np_net_ssl_cleanup();
+
+                        mp_exit(overall);
                 }
         }
-        if (result != STATE_OK) {
-                if (sd)
-                        close(sd);
-                np_net_ssl_cleanup();
-                return result;
-        }
 #endif /* HAVE_SSL */
 
-        if (server_send != NULL) { /* Something to send? */
-                my_send(server_send, strlen(server_send));
+        if (config.send != NULL) { /* Something to send? */
+                my_send(socket_descriptor, config.send, strlen(config.send), config.use_tls);
         }
 
-        if (delay > 0) {
-                tv.tv_sec += delay;
-                sleep(delay);
+        if (config.delay > 0) {
+                start_time.tv_sec += config.delay;
+                sleep(config.delay);
         }
 
-        if (flags & FLAG_VERBOSE) {
-                if (server_send) {
-                        printf("Send string: %s\n", server_send);
+        if (verbosity > 0) {
+                if (config.send) {
+                        printf("Send string: %s\n", config.send);
+                }
+                if (config.quit) {
+                        printf("Quit string: %s\n", config.quit);
                 }
-                if (server_quit) {
-                        printf("Quit string: %s\n", server_quit);
+                printf("server_expect_count: %d\n", (int)config.server_expect_count);
+                for (size_t i = 0; i < config.server_expect_count; i++) {
+                        printf("\t%zd: %s\n", i, config.server_expect[i]);
                 }
-                printf("server_expect_count: %d\n", (int)server_expect_count);
-                for (size_t i = 0; i < server_expect_count; i++)
-                        printf("\t%zd: %s\n", i, server_expect[i]);
         }
 
         /* if(len) later on, we know we have a non-NULL response */
         ssize_t len = 0;
+        char *received_buffer = NULL;
+        enum np_match_result match = NP_MATCH_NONE;
+        mp_subcheck expected_data_result = mp_subcheck_init();
 
-        int match = -1;
-        struct timeval timeout;
-        fd_set rfds;
-        FD_ZERO(&rfds);
-        if (server_expect_count) {
+        if (config.server_expect_count) {
                 ssize_t received = 0;
+                char buffer[MAXBUF];
 
                 /* watch for the expect string */
-                while ((received = my_recv(buffer, sizeof(buffer))) > 0) {
-                        status = realloc(status, len + received + 1);
-                        memcpy(&status[len], buffer, received);
+                while ((received = my_recv(socket_descriptor, buffer, sizeof(buffer), config.use_tls)) > 0) {
+                        received_buffer = realloc(received_buffer, len + received + 1);
+
+                        if (received_buffer == NULL) {
+                                die(STATE_UNKNOWN, _("Allocation failed"));
+                        }
+
+                        memcpy(&received_buffer[len], buffer, received);
                         len += received;
-                        status[len] = '\0';
+                        received_buffer[len] = '\0';
 
                         /* stop reading if user-forced */
-                        if (maxbytes && len >= maxbytes)
+                        if (config.maxbytes && len >= config.maxbytes) {
                                 break;
+                        }
 
-                        if ((match = np_expect_match(status, server_expect, server_expect_count, match_flags)) != NP_MATCH_RETRY)
+                        if ((match = np_expect_match(received_buffer, config.server_expect, config.server_expect_count, config.match_flags)) !=
+                                NP_MATCH_RETRY) {
                                 break;
+                        }
+
+                        fd_set rfds;
+                        FD_ZERO(&rfds);
+                        FD_SET(socket_descriptor, &rfds);
 
                         /* some protocols wait for further input, so make sure we don't wait forever */
-                        FD_SET(sd, &rfds);
+                        struct timeval timeout;
                         timeout.tv_sec = READ_TIMEOUT;
                         timeout.tv_usec = 0;
-                        if (select(sd + 1, &rfds, NULL, NULL, &timeout) <= 0)
+
+                        if (select(socket_descriptor + 1, &rfds, NULL, NULL, &timeout) <= 0) {
                                 break;
+                        }
                 }
 
-                if (match == NP_MATCH_RETRY)
+                if (match == NP_MATCH_RETRY) {
                         match = NP_MATCH_FAILURE;
+                }
 
                 /* no data when expected, so return critical */
-                if (len == 0)
-                        die(STATE_CRITICAL, _("No data received from host\n"));
+                if (len == 0) {
+                        xasprintf(&expected_data_result.output, "Received no data when some was expected");
+                        expected_data_result = mp_set_subcheck_state(expected_data_result, STATE_CRITICAL);
+                        mp_add_subcheck_to_check(&overall, expected_data_result);
+                        mp_exit(overall);
+                }
 
                 /* print raw output if we're debugging */
-                if (flags & FLAG_VERBOSE)
-                        printf("received %d bytes from host\n#-raw-recv-------#\n%s\n#-raw-recv-------#\n", (int)len + 1, status);
+                if (verbosity > 0) {
+                        printf("received %d bytes from host\n#-raw-recv-------#\n%s\n#-raw-recv-------#\n", (int)len + 1, received_buffer);
+                }
                 /* strip whitespace from end of output */
-                while (--len > 0 && isspace(status[len]))
-                        status[len] = '\0';
+                while (--len > 0 && isspace(received_buffer[len])) {
+                        received_buffer[len] = '\0';
+                }
         }
 
-        if (server_quit != NULL) {
-                my_send(server_quit, strlen(server_quit));
+        if (config.quit != NULL) {
+                my_send(socket_descriptor, config.quit, strlen(config.quit), config.use_tls);
+        }
+
+        if (socket_descriptor) {
+                close(socket_descriptor);
         }
-        if (sd)
-                close(sd);
 #ifdef HAVE_SSL
         np_net_ssl_cleanup();
 #endif
 
-        microsec = deltime(tv);
-        elapsed_time = (double)microsec / 1.0e6;
+        long microsec = deltime(start_time);
+        double elapsed_time = (double)microsec / 1.0e6;
 
-        if (flags & FLAG_TIME_CRIT && elapsed_time > critical_time)
-                result = STATE_CRITICAL;
-        else if (flags & FLAG_TIME_WARN && elapsed_time > warning_time)
-                result = STATE_WARNING;
+        mp_subcheck elapsed_time_result = mp_subcheck_init();
 
-        /* did we get the response we hoped? */
-        if (match == NP_MATCH_FAILURE && result != STATE_CRITICAL)
-                result = expect_mismatch_state;
+        mp_perfdata time_pd = perfdata_init();
+        time_pd = mp_set_pd_value(time_pd, elapsed_time);
+        time_pd.label = "time";
+        time_pd.uom = "s";
 
-        /* reset the alarm */
-        alarm(0);
+        if (config.critical_time_set && elapsed_time > config.critical_time) {
+                xasprintf(&elapsed_time_result.output, "Connection time %fs exceeded critical threshold (%f)", elapsed_time, config.critical_time);
+
+                elapsed_time_result = mp_set_subcheck_state(elapsed_time_result, STATE_CRITICAL);
+                time_pd.crit_present = true;
+                mp_range crit_val = mp_range_init();
+
+                crit_val.end = mp_create_pd_value(config.critical_time);
+                crit_val.end_infinity = false;
 
-        /* this is a bit stupid, because we don't want to print the
-         * response time (which can look ok to the user) if we didn't get
-         * the response we were looking for. if-else */
-        printf("%s %s - ", SERVICE, state_text(result));
-
-        if (match == NP_MATCH_FAILURE && len && !(flags & FLAG_HIDE_OUTPUT))
-                printf("Unexpected response from host/socket: %s", status);
-        else {
-                if (match == NP_MATCH_FAILURE)
-                        printf("Unexpected response from host/socket on ");
-                else
-                        printf("%.3f second response time on ", elapsed_time);
-                if (server_address[0] != '/') {
-                        if (host_specified)
-                                printf("%s port %d", server_address, server_port);
-                        else
-                                printf("port %d", server_port);
-                } else
-                        printf("socket %s", server_address);
+                time_pd.crit = crit_val;
+        } else if (config.warning_time_set && elapsed_time > config.warning_time) {
+                xasprintf(&elapsed_time_result.output, "Connection time %fs exceeded warning threshold (%f)", elapsed_time, config.critical_time);
+
+                elapsed_time_result = mp_set_subcheck_state(elapsed_time_result, STATE_WARNING);
+                time_pd.warn_present = true;
+                mp_range warn_val = mp_range_init();
+                warn_val.end = mp_create_pd_value(config.critical_time);
+                warn_val.end_infinity = false;
+
+                time_pd.warn = warn_val;
+        } else {
+                elapsed_time_result = mp_set_subcheck_state(elapsed_time_result, STATE_OK);
+                xasprintf(&elapsed_time_result.output, "Connection time %fs is within thresholds", elapsed_time);
         }
 
-        if (match != NP_MATCH_FAILURE && !(flags & FLAG_HIDE_OUTPUT) && len)
-                printf(" [%s]", status);
+        mp_add_perfdata_to_subcheck(&elapsed_time_result, time_pd);
+        mp_add_subcheck_to_check(&overall, elapsed_time_result);
 
-        /* perf-data doesn't apply when server doesn't talk properly,
-         * so print all zeroes on warn and crit. Use fperfdata since
-         * localisation settings can make different outputs */
-        if (match == NP_MATCH_FAILURE)
-                printf("|%s", fperfdata("time", elapsed_time, "s", (flags & FLAG_TIME_WARN ? true : false), 0,
-                                                                (flags & FLAG_TIME_CRIT ? true : false), 0, true, 0, true, socket_timeout));
-        else
-                printf("|%s", fperfdata("time", elapsed_time, "s", (flags & FLAG_TIME_WARN ? true : false), warning_time,
-                                                                (flags & FLAG_TIME_CRIT ? true : false), critical_time, true, 0, true, socket_timeout));
+        /* did we get the response we hoped? */
+        if (match == NP_MATCH_FAILURE) {
+                expected_data_result = mp_set_subcheck_state(expected_data_result, config.expect_mismatch_state);
+                xasprintf(&expected_data_result.output, "Answer failed to match expectation");
+                mp_add_subcheck_to_check(&overall, expected_data_result);
+        } else if (match == NP_MATCH_SUCCESS) {
+                expected_data_result = mp_set_subcheck_state(expected_data_result, STATE_OK);
+                xasprintf(&expected_data_result.output, "The answer of the server matched the expectation");
+                mp_add_subcheck_to_check(&overall, expected_data_result);
+        }
 
-        putchar('\n');
-        return result;
+        /* reset the alarm */
+        alarm(0);
+
+        mp_exit(overall);
 }
 
 /* process command-line arguments */
-static int process_arguments(int argc, char **argv) {
+static check_tcp_config_wrapper process_arguments(int argc, char **argv, check_tcp_config config) {
         enum {
-                SNI_OPTION = CHAR_MAX + 1
+                SNI_OPTION = CHAR_MAX + 1,
+                output_format_index,
         };
 
         static struct option longopts[] = {{"hostname", required_argument, 0, 'H'},
@@ -404,54 +493,58 @@ static int process_arguments(int argc, char **argv) {
                                                                            {"ssl", no_argument, 0, 'S'},
                                                                            {"sni", required_argument, 0, SNI_OPTION},
                                                                            {"certificate", required_argument, 0, 'D'},
+                                                                           {"output-format", required_argument, 0, output_format_index},
                                                                            {0, 0, 0, 0}};
 
-        if (argc < 2)
+        if (argc < 2) {
                 usage4(_("No arguments found"));
+        }
 
         /* backwards compatibility */
         for (int i = 1; i < argc; i++) {
-                if (strcmp("-to", argv[i]) == 0)
+                if (strcmp("-to", argv[i]) == 0) {
                         strcpy(argv[i], "-t");
-                else if (strcmp("-wt", argv[i]) == 0)
+                } else if (strcmp("-wt", argv[i]) == 0) {
                         strcpy(argv[i], "-w");
-                else if (strcmp("-ct", argv[i]) == 0)
+                } else if (strcmp("-ct", argv[i]) == 0) {
                         strcpy(argv[i], "-c");
+                }
         }
 
         if (!is_option(argv[1])) {
-                server_address = argv[1];
+                config.server_address = argv[1];
                 argv[1] = argv[0];
                 argv = &argv[1];
                 argc--;
         }
 
-        int option_char;
         bool escape = false;
+
         while (true) {
                 int option = 0;
-                option_char = getopt_long(argc, argv, "+hVv46EAH:s:e:q:m:c:w:t:p:C:W:d:Sr:jD:M:", longopts, &option);
+                int option_index = getopt_long(argc, argv, "+hVv46EAH:s:e:q:m:c:w:t:p:C:W:d:Sr:jD:M:", longopts, &option);
 
-                if (option_char == -1 || option_char == EOF || option_char == 1)
+                if (option_index == -1 || option_index == EOF || option_index == 1) {
                         break;
+                }
 
-                switch (option_char) {
+                switch (option_index) {
                 case '?': /* print short usage statement if args not parsable */
                         usage5();
                 case 'h': /* help */
-                        print_help();
+                        print_help(config.service);
                         exit(STATE_UNKNOWN);
                 case 'V': /* version */
                         print_revision(progname, NP_VERSION);
                         exit(STATE_UNKNOWN);
                 case 'v': /* verbose mode */
-                        flags |= FLAG_VERBOSE;
-                        match_flags |= NP_MATCH_VERBOSE;
+                        verbosity++;
+                        config.match_flags |= NP_MATCH_VERBOSE;
                         break;
-                case '4':
+                case '4': // Apparently unused TODO
                         address_family = AF_INET;
                         break;
-                case '6':
+                case '6': // Apparently unused TODO
 #ifdef USE_IPV6
                         address_family = AF_INET6;
 #else
@@ -459,163 +552,190 @@ static int process_arguments(int argc, char **argv) {
 #endif
                         break;
                 case 'H': /* hostname */
-                        host_specified = true;
-                        server_address = optarg;
+                        config.host_specified = true;
+                        config.server_address = optarg;
                         break;
                 case 'c': /* critical */
-                        critical_time = strtod(optarg, NULL);
-                        flags |= FLAG_TIME_CRIT;
+                        config.critical_time = strtod(optarg, NULL);
+                        config.critical_time_set = true;
                         break;
                 case 'j': /* hide output */
-                        flags |= FLAG_HIDE_OUTPUT;
+                        config.hide_output = true;
                         break;
                 case 'w': /* warning */
-                        warning_time = strtod(optarg, NULL);
-                        flags |= FLAG_TIME_WARN;
-                        break;
-                case 'C':
-                        crit_codes = realloc(crit_codes, ++crit_codes_count);
-                        crit_codes[crit_codes_count - 1] = optarg;
-                        break;
-                case 'W':
-                        warn_codes = realloc(warn_codes, ++warn_codes_count);
-                        warn_codes[warn_codes_count - 1] = optarg;
+                        config.warning_time = strtod(optarg, NULL);
+                        config.warning_time_set = true;
                         break;
                 case 't': /* timeout */
-                        if (!is_intpos(optarg))
+                        if (!is_intpos(optarg)) {
                                 usage4(_("Timeout interval must be a positive integer"));
-                        else
+                        } else {
                                 socket_timeout = atoi(optarg);
+                        }
                         break;
                 case 'p': /* port */
-                        if (!is_intpos(optarg))
+                        if (!is_intpos(optarg)) {
                                 usage4(_("Port must be a positive integer"));
-                        else
-                                server_port = atoi(optarg);
+                        } else {
+                                config.server_port = atoi(optarg);
+                        }
                         break;
                 case 'E':
                         escape = true;
                         break;
                 case 's':
-                        if (escape)
-                                server_send = np_escaped_string(optarg);
-                        else
-                                xasprintf(&server_send, "%s", optarg);
+                        if (escape) {
+                                config.send = np_escaped_string(optarg);
+                        } else {
+                                xasprintf(&config.send, "%s", optarg);
+                        }
                         break;
                 case 'e': /* expect string (may be repeated) */
-                        match_flags &= ~NP_MATCH_EXACT;
-                        if (server_expect_count == 0)
-                                server_expect = malloc(sizeof(char *) * (++server_expect_count));
-                        else
-                                server_expect = realloc(server_expect, sizeof(char *) * (++server_expect_count));
-                        server_expect[server_expect_count - 1] = optarg;
+                        config.match_flags &= ~NP_MATCH_EXACT;
+                        if (config.server_expect_count == 0) {
+                                config.server_expect = malloc(sizeof(char *) * (++config.server_expect_count));
+                        } else {
+                                config.server_expect = realloc(config.server_expect, sizeof(char *) * (++config.server_expect_count));
+                        }
+
+                        if (config.server_expect == NULL) {
+                                die(STATE_UNKNOWN, _("Allocation failed"));
+                        }
+                        config.server_expect[config.server_expect_count - 1] = optarg;
                         break;
                 case 'm':
-                        if (!is_intpos(optarg))
+                        if (!is_intpos(optarg)) {
                                 usage4(_("Maxbytes must be a positive integer"));
-                        else
-                                maxbytes = strtol(optarg, NULL, 0);
+                        } else {
+                                config.maxbytes = strtol(optarg, NULL, 0);
+                        }
                         break;
                 case 'q':
-                        if (escape)
-                                server_quit = np_escaped_string(optarg);
-                        else
-                                xasprintf(&server_quit, "%s\r\n", optarg);
+                        if (escape) {
+                                config.quit = np_escaped_string(optarg);
+                        } else {
+                                xasprintf(&config.quit, "%s\r\n", optarg);
+                        }
                         break;
                 case 'r':
-                        if (!strncmp(optarg, "ok", 2))
-                                econn_refuse_state = STATE_OK;
-                        else if (!strncmp(optarg, "warn", 4))
-                                econn_refuse_state = STATE_WARNING;
-                        else if (!strncmp(optarg, "crit", 4))
-                                econn_refuse_state = STATE_CRITICAL;
-                        else
+                        if (!strncmp(optarg, "ok", 2)) {
+                                config.econn_refuse_state = STATE_OK;
+                        } else if (!strncmp(optarg, "warn", 4)) {
+                                config.econn_refuse_state = STATE_WARNING;
+                        } else if (!strncmp(optarg, "crit", 4)) {
+                                config.econn_refuse_state = STATE_CRITICAL;
+                        } else {
                                 usage4(_("Refuse must be one of ok, warn, crit"));
+                        }
                         break;
                 case 'M':
-                        if (!strncmp(optarg, "ok", 2))
-                                expect_mismatch_state = STATE_OK;
-                        else if (!strncmp(optarg, "warn", 4))
-                                expect_mismatch_state = STATE_WARNING;
-                        else if (!strncmp(optarg, "crit", 4))
-                                expect_mismatch_state = STATE_CRITICAL;
-                        else
+                        if (!strncmp(optarg, "ok", 2)) {
+                                config.expect_mismatch_state = STATE_OK;
+                        } else if (!strncmp(optarg, "warn", 4)) {
+                                config.expect_mismatch_state = STATE_WARNING;
+                        } else if (!strncmp(optarg, "crit", 4)) {
+                                config.expect_mismatch_state = STATE_CRITICAL;
+                        } else {
                                 usage4(_("Mismatch must be one of ok, warn, crit"));
+                        }
                         break;
                 case 'd':
-                        if (is_intpos(optarg))
-                                delay = atoi(optarg);
-                        else
+                        if (is_intpos(optarg)) {
+                                config.delay = atoi(optarg);
+                        } else {
                                 usage4(_("Delay must be a positive integer"));
+                        }
                         break;
-                case 'D': { /* Check SSL cert validity - days 'til certificate expiration */
+                case 'D': /* Check SSL cert validity - days 'til certificate expiration */
 #ifdef HAVE_SSL
 #       ifdef USE_OPENSSL /* XXX */
+                {
                         char *temp;
                         if ((temp = strchr(optarg, ',')) != NULL) {
                                 *temp = '\0';
-                                if (!is_intnonneg(optarg))
+                                if (!is_intnonneg(optarg)) {
                                         usage2(_("Invalid certificate expiration period"), optarg);
-                                days_till_exp_warn = atoi(optarg);
+                                }
+                                config.days_till_exp_warn = atoi(optarg);
                                 *temp = ',';
                                 temp++;
-                                if (!is_intnonneg(temp))
+                                if (!is_intnonneg(temp)) {
                                         usage2(_("Invalid certificate expiration period"), temp);
-                                days_till_exp_crit = atoi(temp);
+                                }
+                                config.days_till_exp_crit = atoi(temp);
                         } else {
-                                days_till_exp_crit = 0;
-                                if (!is_intnonneg(optarg))
+                                config.days_till_exp_crit = 0;
+                                if (!is_intnonneg(optarg)) {
                                         usage2(_("Invalid certificate expiration period"), optarg);
-                                days_till_exp_warn = atoi(optarg);
+                                }
+                                config.days_till_exp_warn = atoi(optarg);
                         }
-                        check_cert = true;
-                        flags |= FLAG_SSL;
+                        config.check_cert = true;
+                        config.use_tls = true;
                 } break;
 #       endif /* USE_OPENSSL */
 #endif
                         /* fallthrough if we don't have ssl */
                 case 'S':
 #ifdef HAVE_SSL
-                        flags |= FLAG_SSL;
+                        config.use_tls = true;
 #else
                         die(STATE_UNKNOWN, _("Invalid option - SSL is not available"));
 #endif
                         break;
                 case SNI_OPTION:
 #ifdef HAVE_SSL
-                        flags |= FLAG_SSL;
-                        sni_specified = true;
-                        sni = optarg;
+                        config.use_tls = true;
+                        config.sni_specified = true;
+                        config.sni = optarg;
 #else
                         die(STATE_UNKNOWN, _("Invalid option - SSL is not available"));
 #endif
                         break;
                 case 'A':
-                        match_flags |= NP_MATCH_ALL;
+                        config.match_flags |= NP_MATCH_ALL;
+                        break;
+                case output_format_index: {
+                        parsed_output_format parser = mp_parse_output_format(optarg);
+                        if (!parser.parsing_success) {
+                                // TODO List all available formats here, maybe add anothoer usage function
+                                printf("Invalid output format: %s\n", optarg);
+                                exit(STATE_UNKNOWN);
+                        }
+
+                        config.output_format_set = true;
+                        config.output_format = parser.output_format;
                         break;
                 }
+                }
         }
 
-        option_char = optind;
-        if (!host_specified && option_char < argc)
-                server_address = strdup(argv[option_char++]);
+        int index = optind;
+        if (!config.host_specified && index < argc) {
+                config.server_address = strdup(argv[index++]);
+        }
 
-        if (server_address == NULL)
+        if (config.server_address == NULL) {
                 usage4(_("You must provide a server address"));
-        else if (server_address[0] != '/' && !is_host(server_address))
-                die(STATE_CRITICAL, "%s %s - %s: %s\n", SERVICE, state_text(STATE_CRITICAL), _("Invalid hostname, address or socket"),
-                        server_address);
+        } else if (config.server_address[0] != '/' && !is_host(config.server_address)) {
+                die(STATE_CRITICAL, "%s %s - %s: %s\n", config.service, state_text(STATE_CRITICAL), _("Invalid hostname, address or socket"),
+                        config.server_address);
+        }
 
-        return OK;
+        check_tcp_config_wrapper result = {
+                .config = config,
+                .errorcode = OK,
+        };
+        return result;
 }
 
-void print_help(void) {
+void print_help(const char *service) {
         print_revision(progname, NP_VERSION);
 
         printf("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
         printf(COPYRIGHT, copyright, email);
 
-        printf(_("This plugin tests %s connections with the specified host (or unix socket).\n\n"), SERVICE);
+        printf(_("This plugin tests %s connections with the specified host (or unix socket).\n\n"), service);
 
         print_usage();
 
@@ -662,6 +782,7 @@ void print_help(void) {
 
         printf(UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
 
+        printf(UT_OUTPUT_FORMAT);
         printf(UT_VERBOSE);
 
         printf(UT_SUPPORT);
diff --git a/plugins/check_tcp.d/config.h b/plugins/check_tcp.d/config.h
new file mode 100644
index 00000000..dc25d79e
--- /dev/null
+++ b/plugins/check_tcp.d/config.h
@@ -0,0 +1,84 @@
+#pragma once
+
+#include "../../lib/utils_tcp.h"
+#include "output.h"
+#include "states.h"
+#include <netinet/in.h>
+
+typedef struct {
+        char *server_address;
+        bool host_specified;
+        int server_port; // TODO can this be a uint16?
+
+        int protocol; /* most common is default */
+        char *service;
+        char *send;
+        char *quit;
+        char **server_expect;
+        size_t server_expect_count;
+        bool use_tls;
+#ifdef HAVE_SSL
+        char *sni;
+        bool sni_specified;
+        bool check_cert;
+        int days_till_exp_warn;
+        int days_till_exp_crit;
+#endif // HAVE_SSL
+        int match_flags;
+        mp_state_enum expect_mismatch_state;
+        unsigned int delay;
+
+        bool warning_time_set;
+        double warning_time;
+        bool critical_time_set;
+        double critical_time;
+
+        mp_state_enum econn_refuse_state;
+
+        ssize_t maxbytes;
+
+        bool hide_output;
+
+        bool output_format_set;
+        mp_output_format output_format;
+} check_tcp_config;
+
+check_tcp_config check_tcp_config_init() {
+        check_tcp_config result = {
+                .server_address = "127.0.0.1",
+                .host_specified = false,
+                .server_port = 0,
+
+                .protocol = IPPROTO_TCP,
+                .service = "TCP",
+                .send = NULL,
+                .quit = NULL,
+                .server_expect = NULL,
+                .server_expect_count = 0,
+                .use_tls = false,
+#ifdef HAVE_SSL
+                .sni = NULL,
+                .sni_specified = false,
+                .check_cert = false,
+                .days_till_exp_warn = 0,
+                .days_till_exp_crit = 0,
+#endif // HAVE_SSL
+                .match_flags = NP_MATCH_EXACT,
+                .expect_mismatch_state = STATE_WARNING,
+                .delay = 0,
+
+                .warning_time_set = false,
+                .warning_time = 0,
+                .critical_time_set = false,
+                .critical_time = 0,
+
+                .econn_refuse_state = STATE_CRITICAL,
+
+                .maxbytes = 0,
+
+                .hide_output = false,
+
+                .output_format_set = false,
+        };
+        return result;
+}
diff --git a/plugins/common.h b/plugins/common.h
index 603bae55..35d1e549 100644
--- a/plugins/common.h
+++ b/plugins/common.h
@@ -31,7 +31,7 @@
 #ifndef _COMMON_H_
 #define _COMMON_H_
 
-#include "config.h"
+#include "../config.h"
 #include "../lib/monitoringplug.h"
 
 #ifdef HAVE_FEATURES_H
@@ -110,7 +110,7 @@
 
 /* GNU Libraries */
 #include <getopt.h>
-#include "dirname.h"
+#include "../gl/dirname.h"
 
 #include <locale.h>
 
@@ -190,7 +190,7 @@ enum {
  * Internationalization
  *
  */
-#include "gettext.h"
+#include "../gl/gettext.h"
 #define _(String) gettext (String)
 #if ! ENABLE_NLS
 # undef textdomain
diff --git a/plugins/sslutils.c b/plugins/sslutils.c
index 719de575..96740b3a 100644
--- a/plugins/sslutils.c
+++ b/plugins/sslutils.c
@@ -201,7 +201,7 @@ int np_net_ssl_check_certificate(X509 *certificate, int days_till_exp_warn, int
         time_t tm_t;
 
         if (!certificate) {
-                printf("%s\n", _("CRITICAL - Cannot retrieve server certificate."));
+                printf("%s\n", _("CRITICAL - No server certificate present to inspect."));
                 return STATE_CRITICAL;
         }
 
diff --git a/plugins/t/check_disk.t b/plugins/t/check_disk.t
index 9eb77ce4..0f62fb2b 100644
--- a/plugins/t/check_disk.t
+++ b/plugins/t/check_disk.t
@@ -10,6 +10,7 @@ use strict;
 use Test::More;
 use NPTest;
 use POSIX qw(ceil floor);
+use Data::Dumper;
 
 my $successOutput = '/^DISK OK/';
 my $failureOutput = '/^DISK CRITICAL/';
@@ -20,173 +21,216 @@ my $result;
 my $mountpoint_valid  = getTestParameter( "NP_MOUNTPOINT_VALID", "Path to valid mountpoint",  "/");
 my $mountpoint2_valid = getTestParameter( "NP_MOUNTPOINT2_VALID", "Path to another valid mountpoint. Must be different from 1st one", "/var");
 
+my $output_format = "--output-format mp-test-json";
+
 if ($mountpoint_valid eq "" or $mountpoint2_valid eq "") {
         plan skip_all => "Need 2 mountpoints to test";
 } else {
-        plan tests => 94;
+        plan tests => 97;
 }
 
 $result = NPTest->testCmd(
-        "./check_disk -w 1% -c 1% -p $mountpoint_valid -w 1% -c 1% -p $mountpoint2_valid"
+        "./check_disk -w 1% -c 1% -p $mountpoint_valid -w 1% -c 1% -P -p $mountpoint2_valid $output_format"
         );
 cmp_ok( $result->return_code, "==", 0, "Checking two mountpoints (must have at least 1% free in space and inodes)");
-my $c = 0;
-$_ = $result->output;
-$c++ while /\(/g;       # counts number of "(" - should be two
-cmp_ok( $c, '==', 2, "Got two mountpoints in output");
 
+like($result->{'mp_test_result'}->{'state'}, "/OK/", "Main result is OK");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'state'}, "/OK/", "First sub result is OK");
+like($result->{'mp_test_result'}->{'checks'}->[1]->{'state'}, "/OK/", "Second sub result is OK");
+
+my $absolut_space_mp1 = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0]->{'max'}->{'value'};
+# print("absolute space on mp1: ". $absolut_space_mp1 . "\n");
+
+my $free_percent_on_mp1 = ($result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0]->{'value'}->{'value'} / ($absolut_space_mp1/100));
+print("free percent on mp1: ". $free_percent_on_mp1 . "\n");
+
+my $absolut_space_mp2 = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0]->{'max'}->{'value'};
+# print("absolute space on mp2: ". $absolut_space_mp2 . "\n");
+
+my $free_percent_on_mp2 = ($result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0]->{'value'}->{'value'}/ ($absolut_space_mp2/100));
+print("free percent on mp2: ". $free_percent_on_mp2 . "\n");
 
-# Get perf data
-# Should use Monitoring::Plugin
-my @perf_data = sort(split(/ /, $result->perf_output));
+my @perfdata;
+@perfdata[0] = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0];
+@perfdata[1] = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0];
 
+# Decrease precision of numbers since the the fs might be modified between the two runs
+$perfdata[0]->{'value'}->{'value'} = int($perfdata[0]->{'value'}->{'value'} / 1000000);
+$perfdata[1]->{'value'}->{'value'} = int($perfdata[1]->{'value'}->{'value'} / 1000000);
 
 # Calculate avg_free free on mountpoint1 and mountpoint2
 # because if you check in the middle, you should get different errors
-$_ = $result->output;
-my ($free_on_mp1, $free_on_mp2) = (m/\((\d+\.\d+)%.*\((\d+\.\d+)%/);
-die "Cannot parse output: $_" unless ($free_on_mp1 && $free_on_mp2);
-my $avg_free = ceil(($free_on_mp1+$free_on_mp2)/2);
+my $avg_free_percent = ceil(($free_percent_on_mp1+$free_percent_on_mp2)/2);
+# print("avg_free: " . $avg_free_percent . "\n");
 my ($more_free, $less_free);
-if ($free_on_mp1 > $free_on_mp2) {
+if ($free_percent_on_mp1 > $free_percent_on_mp2) {
         $more_free = $mountpoint_valid;
         $less_free = $mountpoint2_valid;
-} elsif ($free_on_mp1 < $free_on_mp2) {
+} elsif ($free_percent_on_mp1 < $free_percent_on_mp2) {
         $more_free = $mountpoint2_valid;
         $less_free = $mountpoint_valid;
 } else {
         die "Two mountpoints are the same - cannot do rest of test";
 }
-if($free_on_mp1 == $avg_free || $free_on_mp2 == $avg_free) {
+
+print("less free: " . $less_free . "\n");
+print("more free: " . $more_free . "\n");
+
+if($free_percent_on_mp1 == $avg_free_percent || $free_percent_on_mp2 == $avg_free_percent) {
         die "One mountpoints has average space free - cannot do rest of test";
 }
 
+my $free_inodes_on_mp1 = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}[2]->{'perfdata'}->[0]->{'value'}->{'value'};
+my $total_inodes_on_mp1 = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}[2]->{'perfdata'}->[0]->{'max'}->{'value'};
+my $free_inode_percentage_on_mp1 = $free_inodes_on_mp1 / ($total_inodes_on_mp1 / 100);
 
-# Do same for inodes
-$_ = $result->output;
-my ($free_inode_on_mp1, $free_inode_on_mp2) = (m/inode=(\d+)%.*inode=(\d+)%/);
-die "Cannot parse free inodes: $_" unless ($free_inode_on_mp1 && $free_inode_on_mp2);
-my $avg_inode_free = ceil(($free_inode_on_mp1 + $free_inode_on_mp2)/2);
+my $free_inodes_on_mp2 = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[2]->{'perfdata'}->[0]->{'value'}->{'value'};
+my $total_inodes_on_mp2 = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[2]->{'perfdata'}->[0]->{'max'}->{'value'};
+my $free_inode_percentage_on_mp2 = $free_inodes_on_mp2 / ($total_inodes_on_mp2 / 100);
+
+my $avg_inode_free_percentage = ceil(($free_inode_percentage_on_mp1 + $free_inode_percentage_on_mp2)/2);
 my ($more_inode_free, $less_inode_free);
-if ($free_inode_on_mp1 > $free_inode_on_mp2) {
+if ($free_inode_percentage_on_mp1 > $free_inode_percentage_on_mp2) {
         $more_inode_free = $mountpoint_valid;
         $less_inode_free = $mountpoint2_valid;
-} elsif ($free_inode_on_mp1 < $free_inode_on_mp2) {
+} elsif ($free_inode_percentage_on_mp1 < $free_inode_percentage_on_mp2) {
         $more_inode_free = $mountpoint2_valid;
         $less_inode_free = $mountpoint_valid;
 } else {
         die "Two mountpoints with same inodes free - cannot do rest of test";
 }
-if($free_inode_on_mp1 == $avg_inode_free || $free_inode_on_mp2 == $avg_inode_free) {
+if($free_inode_percentage_on_mp1 == $avg_inode_free_percentage || $free_inode_percentage_on_mp2 == $avg_inode_free_percentage) {
         die "One mountpoints has average inodes free - cannot do rest of test";
 }
 
 # Verify performance data
 # First check absolute thresholds...
 $result = NPTest->testCmd(
-        "./check_disk -w 20 -c 10 -p $mountpoint_valid"
+        "./check_disk -w 20 -c 10 -p $mountpoint_valid $output_format"
         );
-$_ = $result->perf_output;
-my ($warn_absth_data, $crit_absth_data, $total_absth_data) = (m/=.[^;]*;(\d+);(\d+);\d+;(\d+)/);
-# default unit is MiB, but perfdata is always bytes
-is ($warn_absth_data, $total_absth_data - (20 * (2 ** 20)), "Wrong warning in perf data using absolute thresholds");
-is ($crit_absth_data, $total_absth_data - (10 * (2 ** 20)), "Wrong critical in perf data using absolute thresholds");
+
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+
+my $warn_absth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'warn'}->{'end'}->{'value'};
+my $crit_absth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'crit'}->{'end'}->{'value'};
+my $total_absth_data= $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'max'}->{'value'};
+
+# print("warn: " .$warn_absth_data . "\n");
+# print("crit: " .$crit_absth_data . "\n");
+# print("total: " .$total_absth_data . "\n");
+
+is ($warn_absth_data <=>  (20 * (2 ** 20)), 0, "Wrong warning in perf data using absolute thresholds");
+is ($crit_absth_data <=>  (10 * (2 ** 20)), 0, "Wrong critical in perf data using absolute thresholds");
 
 # Then check percent thresholds.
 $result = NPTest->testCmd(
-        "./check_disk -w 20% -c 10% -p $mountpoint_valid"
+        "./check_disk -w 20% -c 10% -p $mountpoint_valid $output_format"
         );
-$_ = $result->perf_output;
-my ($warn_percth_data, $crit_percth_data, $total_percth_data) = (m/=.[^;]*;(\d+);(\d+);\d+;(\d+)/);
-is ($warn_percth_data, int((1-20/100)*$total_percth_data), "Wrong warning in perf data using percent thresholds");
-is ($crit_percth_data, int((1-10/100)*$total_percth_data), "Wrong critical in perf data using percent thresholds");
+
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+
+my $warn_percth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'warn'}->{'end'}->{'value'};
+my $crit_percth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'crit'}->{'end'}->{'value'};
+my $total_percth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'max'}->{'value'};
+
+print("warn_percth_data: " . $warn_percth_data . "\n");
+print("crit_percth_data: " . $crit_percth_data . "\n");
+
+is (int($warn_percth_data), int((20/100)*$total_percth_data), "Wrong warning in perf data using percent thresholds. Got " . $warn_percth_data . " with total " . $total_percth_data);
+is (int($crit_percth_data), int((10/100)*$total_percth_data), "Wrong critical in perf data using percent thresholds. Got " . $crit_percth_data . " with total " . $total_percth_data);
 
 
 # Check when order of mount points are reversed, that perf data remains same
 $result = NPTest->testCmd(
-        "./check_disk -w 1% -c 1% -p $mountpoint2_valid -w 1% -c 1% -p $mountpoint_valid"
+        "./check_disk -w 1% -c 1% -p $mountpoint2_valid -w 1% -c 1% -p $mountpoint_valid $output_format"
         );
-@_ = sort(split(/ /, $result->perf_output));
-is_deeply( \@perf_data, \@_, "perf data for both filesystems same when reversed");
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
 
+# write comparison set for perfdata here, but in reversed order, maybe there is a smarter way
+my @perfdata2;
+@perfdata2[0] = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0];
+@perfdata2[1] = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0];
+# Decrease precision of numbers since the the fs might be modified between the two runs
+$perfdata2[0]->{'value'}->{'value'} = int($perfdata2[0]->{'value'}->{'value'} / 1000000);
+$perfdata2[1]->{'value'}->{'value'} = int($perfdata2[1]->{'value'}->{'value'} / 1000000);
+is_deeply(\@perfdata, \@perfdata2, "perf data for both filesystems same when reversed");
 
 # Basic filesystem checks for sizes
-$result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free" );
-cmp_ok( $result->return_code, '==', 0, "At least 1 MB available on $more_free");
-like  ( $result->output, $successOutput, "OK output" );
-like  ( $result->only_output, qr/free space/, "Have free space text");
-like  ( $result->only_output, qr/$more_free/, "Have disk name in text");
+$result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free $output_format");
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+like($result->{'mp_test_result'}->{'state'}, "/OK/", "At least 1 MB available on $more_free");
 
-$result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free -p $less_free" );
-cmp_ok( $result->return_code, '==', 0, "At least 1 MB available on $more_free and $less_free");
+$result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free -p $less_free $output_format" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+like($result->{'mp_test_result'}->{'state'}, "/OK/", "At least 1 MB available on $more_free and $less_free");
 
-$_ = $result->output;
-
-my ($free_mb_on_mp1, $free_mb_on_mp2) = (m/(\d+)MiB .* (\d+)MiB /g);
+my $free_mb_on_mp1 =$result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0]->{'value'}->{'value'} / (1024 * 1024);
+my $free_mb_on_mp2 = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0]->{'value'}->{'value'}/ (1024 * 1024);
 die "Cannot parse output: $_" unless ($free_mb_on_mp1 && $free_mb_on_mp2);
 
 my $free_mb_on_all = $free_mb_on_mp1 + $free_mb_on_mp2;
 
 
+$result = NPTest->testCmd( "./check_disk -e -w 1 -c 1 -p $more_free $output_format" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
 
-$result = NPTest->testCmd( "./check_disk -e -w 1 -c 1 -p $more_free" );
-is( $result->only_output, "DISK OK", "No print out of disks with -e for OKs");
-
-$result = NPTest->testCmd( "./check_disk 100 100 $more_free" );
-cmp_ok( $result->return_code, '==', 0, "Old syntax okay" );
+$result = NPTest->testCmd( "./check_disk 101 101 $more_free" );
+like($result->output, "/OK/", "OK in Output");
+cmp_ok( $result->return_code, '==', 0, "Old syntax okay, output was: ". $result->output . "\n" );
 
 $result = NPTest->testCmd( "./check_disk -w 1% -c 1% -p $more_free" );
 cmp_ok( $result->return_code, "==", 0, "At least 1% free" );
 
 $result = NPTest->testCmd(
-        "./check_disk -w 1% -c 1% -p $more_free -w 100% -c 100% -p $less_free"
+        "./check_disk -w 1% -c 1% -p $more_free -w 100% -c 100% -p $less_free $output_format"
         );
-cmp_ok( $result->return_code, "==", 2, "Get critical on less_free mountpoint $less_free" );
-like( $result->output, $failureOutput, "Right output" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+like($result->{'mp_test_result'}->{'state'}, "/CRITICAL/", "Get critical on less_free mountpoint $less_free");
 
 
 $result = NPTest->testCmd(
-        "./check_disk -w $avg_free% -c 0% -p $less_free"
+        "./check_disk -w $avg_free_percent% -c 0% -p $less_free $output_format"
         );
-cmp_ok( $result->return_code, '==', 1, "Get warning on less_free mountpoint, when checking avg_free");
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+like($result->{'mp_test_result'}->{'state'}, "/WARNING/", "Get warning on less_free mountpoint, when checking avg_free");
 
 $result = NPTest->testCmd(
-        "./check_disk -w $avg_free% -c $avg_free% -p $more_free"
+        "./check_disk -w $avg_free_percent% -c $avg_free_percent% -p $more_free"
         );
 cmp_ok( $result->return_code, '==', 0, "Get ok on more_free mountpoint, when checking avg_free");
 
 $result = NPTest->testCmd(
-        "./check_disk -w $avg_free% -c 0% -p $less_free -w $avg_free% -c $avg_free% -p $more_free"
+        "./check_disk -w $avg_free_percent% -c 0% -p $less_free -w $avg_free_percent% -c $avg_free_percent% -p $more_free"
         );
 cmp_ok( $result->return_code, "==", 1, "Combining above two tests, get warning");
 my $all_disks = $result->output;
 
 $result = NPTest->testCmd(
-        "./check_disk -e -w $avg_free% -c 0% -p $less_free -w $avg_free% -c $avg_free% -p $more_free"
+        "./check_disk -e -w $avg_free_percent% -c 0% -p $less_free -w $avg_free_percent% -c $avg_free_percent% -p $more_free"
         );
 isnt( $result->output, $all_disks, "-e gives different output");
 
 # Need spaces around filesystem name in case less_free and more_free are nested
 like( $result->output, qr/ $less_free /, "Found problem $less_free");
 unlike( $result->only_output, qr/ $more_free /, "Has ignored $more_free as not a problem");
-like( $result->perf_output, qr/ $more_free=/, "But $more_free is still in perf data");
+like( $result->perf_output, qr/'$more_free'=/, "But $more_free is still in perf data");
 
 $result = NPTest->testCmd(
-        "./check_disk -w $avg_free% -c 0% -p $more_free"
+        "./check_disk -w $avg_free_percent% -c 0% -p $more_free"
         );
 cmp_ok( $result->return_code, '==', 0, "Get ok on more_free mountpoint, checking avg_free");
 
 $result = NPTest->testCmd(
-        "./check_disk -w $avg_free% -c $avg_free% -p $less_free"
+        "./check_disk -w $avg_free_percent% -c $avg_free_percent% -p $less_free"
         );
 cmp_ok( $result->return_code, '==', 2, "Get critical on less_free, checking avg_free");
 $result = NPTest->testCmd(
-        "./check_disk -w $avg_free% -c 0% -p $more_free -w $avg_free% -c $avg_free% -p $less_free"
+        "./check_disk -w $avg_free_percent% -c 0% -p $more_free -w $avg_free_percent% -c $avg_free_percent% -p $less_free"
         );
 cmp_ok( $result->return_code, '==', 2, "Combining above two tests, get critical");
 
 $result = NPTest->testCmd(
-        "./check_disk -w $avg_free% -c $avg_free% -p $less_free -w $avg_free% -c 0% -p $more_free"
+        "./check_disk -w $avg_free_percent% -c $avg_free_percent% -p $less_free -w $avg_free_percent% -c 0% -p $more_free"
         );
 cmp_ok( $result->return_code, '==', 2, "And reversing arguments should not make a difference");
 
@@ -203,32 +247,32 @@ is( $result->return_code, 2, "Critical requesting 100% free inodes for both moun
 $result = NPTest->testCmd( "./check_disk --iwarning 1% --icritical 1% -p $more_inode_free -K 100% -W 100% -p $less_inode_free" );
 is( $result->return_code, 2, "Get critical on less_inode_free mountpoint $less_inode_free");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K 0% -p $less_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K 0% -p $less_inode_free" );
 is( $result->return_code, 1, "Get warning on less_inode_free, when checking average");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K $avg_inode_free% -p $more_inode_free ");
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $more_inode_free ");
 is( $result->return_code, 0, "Get ok on more_inode_free when checking average");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K 0% -p $less_inode_free -W $avg_inode_free% -K $avg_inode_free% -p $more_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K 0% -p $less_inode_free -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $more_inode_free" );
 is ($result->return_code, 1, "Combine above two tests, get warning");
 $all_disks = $result->output;
 
-$result = NPTest->testCmd( "./check_disk -e -W $avg_inode_free% -K 0% -p $less_inode_free -W $avg_inode_free% -K $avg_inode_free% -p $more_inode_free" );
+$result = NPTest->testCmd( "./check_disk -e -W $avg_inode_free_percentage% -K 0% -p $less_inode_free -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $more_inode_free" );
 isnt( $result->output, $all_disks, "-e gives different output");
 like( $result->output, qr/$less_inode_free/, "Found problem $less_inode_free");
 unlike( $result->only_output, qr/$more_inode_free\s/, "Has ignored $more_inode_free as not a problem");
 like( $result->perf_output, qr/$more_inode_free/, "But $more_inode_free is still in perf data");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K 0% -p $more_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K 0% -p $more_inode_free" );
 is( $result->return_code, 0, "Get ok on more_inode_free mountpoint, checking average");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K $avg_inode_free% -p $less_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $less_inode_free" );
 is( $result->return_code, 2, "Get critical on less_inode_free, checking average");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K 0% -p $more_inode_free -W $avg_inode_free% -K $avg_inode_free% -p $less_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K 0% -p $more_inode_free -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $less_inode_free" );
 is( $result->return_code, 2, "Combining above two tests, get critical");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K $avg_inode_free% -p $less_inode_free -W $avg_inode_free% -K 0% -p $more_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $less_inode_free -W $avg_inode_free_percentage% -K 0% -p $more_inode_free" );
 cmp_ok( $result->return_code, '==', 2, "And reversing arguments should not make a difference");
 
 
@@ -249,9 +293,9 @@ $result = NPTest->testCmd(
         );
 cmp_ok( $result->return_code, "==", 3, "Invalid options: -p must come after thresholds" );
 
-$result = NPTest->testCmd( "./check_disk -w 100% -c 100% ".${mountpoint_valid} );      # 100% empty
-cmp_ok( $result->return_code, "==", 2, "100% empty" );
-like( $result->output, $failureOutput, "Right output" );
+$result = NPTest->testCmd( "./check_disk -w 100% -c 100% $output_format ".${mountpoint_valid} );      # 100% empty
+cmp_ok( $result->return_code, "==", 0, "100% empty" );
+like($result->{'mp_test_result'}->{'state'}, "/CRITICAL/", "100% empty");
 
 $result = NPTest->testCmd( "./check_disk -w 100000000 -c 100000000 $mountpoint_valid" );
 cmp_ok( $result->return_code, '==', 2, "Check for 100TB free" );
@@ -263,7 +307,8 @@ cmp_ok( $result->return_code, "==", 2, "100 TB empty" );
 # Checking old syntax of check_disk warn crit [fs], with warn/crit at USED% thresholds
 $result = NPTest->testCmd( "./check_disk 0 0 ".${mountpoint_valid} );
 cmp_ok( $result->return_code, "==", 2, "Old syntax: 0% used");
-like ( $result->only_output, qr(^[^;]*;[^;]*$), "Select only one path with positional arguments");
+# like ( $result->only_output, qr(^[^;]*;[^;]*$), "Select only one path with positional arguments");
+# TODO not sure what the above should test, taking it out
 
 $result = NPTest->testCmd( "./check_disk 100 100 $mountpoint_valid" );
 cmp_ok( $result->return_code, '==', 0, "Old syntax: 100% used" );
@@ -311,8 +356,9 @@ $result = NPTest->testCmd( "./check_disk -w 0% -c 0% -p / -p /" );
 unlike( $result->output, '/ \/ .* \/ /', "Should not show same filesystem twice");
 
 # are partitions added if -C is given without path selection -p ?
-$result = NPTest->testCmd( "./check_disk -w 0% -c 0% -C -w 0% -c 0% -p $mountpoint_valid" );
-like( $result->output, '/;.*;\|/', "-C selects partitions if -p is not given");
+$result = NPTest->testCmd( "./check_disk -w 0% -c 0% -C -w 0% -c 0% -p $mountpoint_valid $output_format" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+cmp_ok(scalar $result->{'mp_test_result'}->{'checks'}, '>', 1, "-C invokes matchall logic again");
 
 # grouping: exit crit if the sum of free megs on mp1+mp2 is less than warn/crit
 $result = NPTest->testCmd( "./check_disk -w ". ($free_mb_on_all + 1) ." -c ". ($free_mb_on_all + 1) ." -g group -p $mountpoint_valid -p $mountpoint2_valid" );
@@ -359,39 +405,37 @@ like( $result->output, qr/$mountpoint2_valid/,"ignore: output data does have $mo
 # ignore-missing: exit okay, when fs is not accessible
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -p /bob");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for not existing filesystem /bob");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters - ignored paths: /bob;.*$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when regex does not match
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -r /bob");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters.*$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when fs with exact match (-E) is not found
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -E -p /etc");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay when exact match does not find fs");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters - ignored paths: /etc;.*$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when checking one existing fs and one non-existing fs (regex)
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -r '/bob' -r '^/\$'");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - free space: \/ .*$/', 'Output OK');
 
 # ignore-missing: exit okay, when checking one existing fs and one non-existing fs (path)
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -p '/bob' -p '/'");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - free space: / .*; - ignored paths: /bob;.*$/', 'Output OK');
+# like( $result->output, '/^DISK OK - free space: / .*; - ignored paths: /bob;.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when checking one non-existing fs (path) and one ignored
 $result = NPTest->testCmd( "./check_disk -n -w 0% -c 0% -r /dummy -i /dummy2");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters\|$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when regex match does not find anything
 $result = NPTest->testCmd( "./check_disk -n -e -l -w 10% -c 5% -W 10% -K 5% -r /dummy");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK\|$/', 'Output OK');
 
 # ignore-missing: exit okay, when regex match does not find anything
 $result = NPTest->testCmd( "./check_disk -n -l -w 10% -c 5% -W 10% -K 5% -r /dummy");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters\|$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
diff --git a/plugins/t/check_ftp.t b/plugins/t/check_ftp.t
index 93a7d7c3..a2f79dca 100644
--- a/plugins/t/check_ftp.t
+++ b/plugins/t/check_ftp.t
@@ -15,7 +15,7 @@ my $host_tcp_ftp       = getTestParameter("NP_HOST_TCP_FTP", "A host providing t
 my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
 my $hostname_invalid   = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
 
-my $successOutput = '/FTP OK -\s+[0-9]?\.?[0-9]+ second response time/';
+my $successOutput = '/Connection time\s+[0-9]?\.?[0-9]+/';
 
 my $t;
 
diff --git a/plugins/t/check_jabber.t b/plugins/t/check_jabber.t
index 08cadcbd..dc46f4c3 100644
--- a/plugins/t/check_jabber.t
+++ b/plugins/t/check_jabber.t
@@ -15,11 +15,11 @@ my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname
 my $hostname_invalid   = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
 
 
-my $jabberOK = '/JABBER OK\s-\s\d+\.\d+\ssecond response time on '.$host_tcp_jabber.' port 5222/';
+my $jabberOK = '/Connection to '.$host_tcp_jabber.' on port 5222/';
 
 my $jabberUnresponsive = '/Socket timeout after\s\d+\sseconds/';
 
-my $jabberInvalid = '/JABBER CRITICAL - Invalid hostname, address or socket:\s.+/';
+my $jabberInvalid = '/Invalid hostname, address or socket:\s.+/';
 
 my $r;
 
diff --git a/plugins/t/check_tcp.t b/plugins/t/check_tcp.t
index cb4de53d..5c8fd0be 100644
--- a/plugins/t/check_tcp.t
+++ b/plugins/t/check_tcp.t
@@ -21,19 +21,19 @@ my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname
 my $hostname_invalid   = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
 my $internet_access    = getTestParameter("NP_INTERNET_ACCESS", "Is this system directly connected to the internet?", "yes");
 
-my $successOutput = '/^TCP OK\s-\s+[0-9]?\.?[0-9]+ second response time on port [0-9]+/';
+my $successOutput = '/Connection time\s+[0-9]?\.?[0-9]+s is within thresholds+/';
 
-my $failedExpect = '/^TCP WARNING\s-\sUnexpected response from host/socket on port [0-9]+/';
+my $failedExpect = '/Answer failed to match/';
 
 my $t;
 
 $tests = $tests - 4 if $internet_access eq "no";
 plan tests => $tests;
 
-$t += checkCmd( "./check_tcp $host_tcp_http      -p 80 -wt 300 -ct 600",       0, $successOutput );
-$t += checkCmd( "./check_tcp $host_tcp_http      -p 81 -wt   0 -ct   0 -to 1", 2 ); # use invalid port for this test
-$t += checkCmd( "./check_tcp $host_nonresponsive -p 80 -wt   0 -ct   0 -to 1", 2 );
-$t += checkCmd( "./check_tcp $hostname_invalid   -p 80 -wt   0 -ct   0 -to 1", 2 );
+$t += checkCmd( "./check_tcp $host_tcp_http      -p 80 -w 300 -c 600",       0, $successOutput );
+$t += checkCmd( "./check_tcp $host_tcp_http      -p 81 -w   0 -c   0 -t 1", 2 ); # use invalid port for this test
+$t += checkCmd( "./check_tcp $host_nonresponsive -p 80 -w   0 -c   0 -t 1", 2 );
+$t += checkCmd( "./check_tcp $hostname_invalid   -p 80 -w   0 -c   0 -t 1", 2 );
 if($internet_access ne "no") {
     $t += checkCmd( "./check_tcp -S -D 1 -H $host_tls_http -p 443",              0 );
     $t += checkCmd( "./check_tcp -S -D 9000,1    -H $host_tls_http -p 443",      1 );
diff --git a/plugins/t/check_udp.t b/plugins/t/check_udp.t
index 6c47d095..5cb9e6dc 100644
--- a/plugins/t/check_udp.t
+++ b/plugins/t/check_udp.t
@@ -28,7 +28,7 @@ like  ( $res->output, '/With UDP checks, a send/expect string must be specified.
 
 $res = NPTest->testCmd( "./check_udp -H localhost -p 3333 -s foo -e bar" );
 cmp_ok( $res->return_code, '==', 2, "Errors correctly because no udp service running" );
-like  ( $res->output, '/No data received from host/', "Output OK");
+like  ( $res->output, '/Received no data /', "Output OK");
 
 my $nc;
 if(system("which nc.traditional >/dev/null 2>&1") == 0) {
@@ -48,7 +48,7 @@ SKIP: {
         sleep 1;
         $res = NPTest->testCmd( "./check_udp -H localhost -p 3333 -s '' -e barbar -4" );
         cmp_ok( $res->return_code, '==', 0, "Got barbar response back" );
-        like  ( $res->output, '/\[barbar\]/', "Output OK");
+        like  ( $res->output, '/answer of the server matched/', "Output OK");
         close NC;
 
         # Start up a udp server listening on port 3333, quit after 3 seconds
diff --git a/lib/tests/test_disk.c b/plugins/tests/test_check_disk.c
index c18db7a4..35c57bce 100644
--- a/lib/tests/test_disk.c
+++ b/plugins/tests/test_check_disk.c
@@ -17,28 +17,16 @@
  *****************************************************************************/
 
 #include "common.h"
-#include "utils_disk.h"
-#include "tap.h"
+#include "../check_disk.d/utils_disk.h"
+#include "../../tap/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);
+        plan_tests(35);
 
+        struct name_list *exclude_filesystem = NULL;
         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");
@@ -47,6 +35,7 @@ int main(int argc, char **argv) {
         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");
 
+        struct name_list *exclude_fstype = NULL;
         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");
@@ -59,7 +48,9 @@ int main(int argc, char **argv) {
         }
         */
 
-        me = (struct mount_entry *)malloc(sizeof *me);
+        struct mount_entry *dummy_mount_list;
+        struct mount_entry **mtail = &dummy_mount_list;
+        struct mount_entry *me = (struct mount_entry *)malloc(sizeof *me);
         me->me_devname = strdup("/dev/c0t0d0s0");
         me->me_mountdir = strdup("/");
         *mtail = me;
@@ -77,6 +68,7 @@ int main(int argc, char **argv) {
         *mtail = me;
         mtail = &me->me_next;
 
+        int cflags = REG_NOSUB | REG_EXTENDED;
         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:"));
@@ -89,14 +81,16 @@ int main(int argc, char **argv) {
         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");
+        filesystem_list test_paths = filesystem_list_init();
+        mp_int_fs_list_append(&test_paths, "/home/groups");
+        mp_int_fs_list_append(&test_paths, "/var");
+        mp_int_fs_list_append(&test_paths, "/tmp");
+        mp_int_fs_list_append(&test_paths, "/home/tonvoon");
+        mp_int_fs_list_append(&test_paths, "/dev/c2t0d0s0");
+        ok(test_paths.length == 5, "List counter works correctly with appends");
 
-        np_set_best_match(paths, dummy_mount_list, false);
-        for (p = paths; p; p = p->name_next) {
+        mp_int_fs_list_set_best_match(test_paths, dummy_mount_list, false);
+        for (parameter_list_elem *p = test_paths.first; p; p = mp_int_fs_list_get_next(p)) {
                 struct mount_entry *temp_me;
                 temp_me = p->best_match;
                 if (!strcmp(p->name, "/home/groups")) {
@@ -112,15 +106,19 @@ int main(int argc, char **argv) {
                 }
         }
 
-        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");
+        for (parameter_list_elem *p = test_paths.first; p; p = mp_int_fs_list_get_next(p)) {
+                mp_int_fs_list_del(&test_paths, p);
+        }
+        ok(test_paths.length == 0, "List delete sets counter properly");
 
-        np_set_best_match(paths, dummy_mount_list, true);
-        for (p = paths; p; p = p->name_next) {
+        mp_int_fs_list_append(&test_paths, "/home/groups");
+        mp_int_fs_list_append(&test_paths, "/var");
+        mp_int_fs_list_append(&test_paths, "/tmp");
+        mp_int_fs_list_append(&test_paths, "/home/tonvoon");
+        mp_int_fs_list_append(&test_paths, "/home");
+
+        mp_int_fs_list_set_best_match(test_paths, dummy_mount_list, true);
+        for (parameter_list_elem *p = test_paths.first; p; p = mp_int_fs_list_get_next(p)) {
                 if (!strcmp(p->name, "/home/groups")) {
                         ok(!p->best_match, "/home/groups correctly not found");
                 } else if (!strcmp(p->name, "/var")) {
@@ -134,59 +132,66 @@ int main(int argc, char **argv) {
                 }
         }
 
+        bool found = false;
         /* 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;
+        mp_int_fs_list_del(&test_paths, NULL);
+        for (parameter_list_elem *p = test_paths.first; p; p = mp_int_fs_list_get_next(p)) {
+                if (!strcmp(p->name, "/home/groups")) {
+                        found = true;
+                }
         }
-        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;
+        ok(!found, "first element successfully deleted");
+        found = false;
+
+        parameter_list_elem *prev = NULL;
+        parameter_list_elem *p = NULL;
+        for (parameter_list_elem *path = test_paths.first; path; path = mp_int_fs_list_get_next(path)) {
+                if (!strcmp(path->name, "/tmp")) {
+                        mp_int_fs_list_del(&test_paths, path);
                 }
+                p = path;
         }
 
-        for (p = paths; p; p = p->name_next) {
-                if (!strcmp(p->name, "/tmp"))
-                        found = 1;
-                if (p->name_next)
-                        prev = p;
-                else
-                        last = p;
+        parameter_list_elem *last = NULL;
+        for (parameter_list_elem *path = test_paths.first; path; path = mp_int_fs_list_get_next(path)) {
+                if (!strcmp(path->name, "/tmp")) {
+                        found = true;
+                }
+                if (path->next) {
+                        prev = path;
+                } else {
+                        last = path;
+                }
         }
-        ok(found == 0, "/tmp element successfully deleted");
+        ok(!found, "/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;
+        int count = 0;
+        mp_int_fs_list_del(&test_paths, p);
+        for (p = test_paths.first; p; p = p->next) {
+                if (!strcmp(p->name, "/home")) {
+                        found = true;
+                }
                 last = p;
                 count++;
         }
-        ok(found == 0, "last (/home) element successfully deleted");
+        ok(!found, "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))
+        regex_t regex;
+        if (regcomp(&regex, regstr, cflags) == 0) {
+                int matches = 0;
+                for (struct mount_entry *me = dummy_mount_list; me; me = me->me_next) {
+                        if (np_regex_match_mount_entry(me, &regex)) {
                                 matches++;
+                        }
                 }
                 ok(matches == expect, "%s '%s' matched %i/3 entries. ok: %i/3", desc, regstr, expect, matches);
 
-        } else
+        } else {
                 ok(false, "regex '%s' not compilable", regstr);
+        }
 }
diff --git a/plugins/tests/test_check_disk.t b/plugins/tests/test_check_disk.t
new file mode 100755
index 00000000..56354650
--- /dev/null
+++ b/plugins/tests/test_check_disk.t
@@ -0,0 +1,6 @@
+#!/usr/bin/perl
+use Test::More;
+if (! -e "./test_check_disk") {
+        plan skip_all => "./test_check_disk not compiled - please enable libtap library to test";
+}
+exec "./test_check_disk";