70 files changed, 6694 insertions, 5945 deletions

diff --git a/.clang-format b/.clang-format
index ca411edd..0ff68114 100644
--- a/.clang-format
+++ b/.clang-format
@@ -4,7 +4,7 @@ TabWidth: 4
 AllowShortIfStatementsOnASingleLine: false
 BreakBeforeBraces: Attach
 AlignConsecutiveMacros: true
-ColumnLimit: 140
+ColumnLimit: 100
 IndentPPDirectives: AfterHash
 SortIncludes: Never
 AllowShortEnumsOnASingleLine: false
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/.github/workflows/test-next.yml b/.github/workflows/test-next.yml
index 81240759..fd59e85d 100644
--- a/.github/workflows/test-next.yml
+++ b/.github/workflows/test-next.yml
@@ -38,7 +38,7 @@ jobs:
               ${{ matrix.distro }} \
               /bin/sh -c '${{ matrix.prepare }} && \
                 tools/setup && \
-                ./configure --enable-libtap  --with-ipv6=no && \
+                ./configure --enable-libtap && \
                 make && \
                 make test && \
                 make dist && \
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 77ca6585..ce0ec547 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -35,7 +35,7 @@ jobs:
               ${{ matrix.distro }} \
               /bin/sh -c '${{ matrix.prepare }} && \
                 tools/setup && \
-                ./configure --enable-libtap  --with-ipv6=no && \
+                ./configure --enable-libtap && \
                 make && \
                 make test && \
                 make dist && \
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 c66f9b2f..ce140218 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
 
@@ -1519,21 +1519,47 @@ then
 fi
 
 AC_PATH_PROG(PATH_TO_FPING,fping)
-AC_PATH_PROG(PATH_TO_FPING6,fping6)
 
 AC_ARG_WITH(fping_command,
             ACX_HELP_STRING([--with-fping-command=PATH],
                             [Path to fping command]), PATH_TO_FPING=$withval)
-AC_ARG_WITH(fping6_command,
-            ACX_HELP_STRING([--with-fping6-command=PATH],
-                            [Path to fping6 command]), PATH_TO_FPING6=$withval)
-
-if test -n "$PATH_TO_FPING"
-then
+if test -n "$PATH_TO_FPING"; then
         AC_DEFINE_UNQUOTED(PATH_TO_FPING,"$PATH_TO_FPING",[path to fping])
         EXTRAS="$EXTRAS check_fping\$(EXEEXT)"
-        if test x"$with_ipv6" != xno && test -n "$PATH_TO_FPING6"; then
-                AC_DEFINE_UNQUOTED(PATH_TO_FPING6,"$PATH_TO_FPING6",[path to fping6])
+
+        if test -z "$($PATH_TO_FPING --version)"  ; then
+                AC_MSG_NOTICE([failed to get version of fping])
+        else
+                FPING_MAJOR_VERSION="$($PATH_TO_FPING --version | sed 's/.*fping: Version //' | sed 's/\..*//')"
+                FPING_MINOR_VERSION="$($PATH_TO_FPING --version | sed 's/.*fping: Version //' | sed 's/.*\.//')"
+
+                if test $FPING_MAJOR_VERSION -eq 5 ; then
+                        if test $FPING_MINOR_VERSION -ge 3 ; then
+                                AC_DEFINE(FPING_VERSION_5_3_OR_HIGHER, "true", [fping is of version 5.3 or higher])
+                                AC_MSG_NOTICE([fping is of version 5.3 or higher])
+                                AC_DEFINE(FPING_VERSION_5_2_OR_HIGHER, "true", [fping is of version 5.2 or higher])
+                                AC_MSG_NOTICE([fping is of version 5.2 or higher])
+                        elif test $FPING_MINOR_VERSION -ge 2 ; then
+                                AC_DEFINE(FPING_VERSION_5_2_OR_HIGHER, "true", [fping is of version 5.2 or higher])
+                                AC_MSG_NOTICE([fping is of version 5.2 or higher])
+                        else
+                                AC_MSG_NOTICE([fping is of a version lower then 5.2])
+                        fi
+
+                elif $FPING_MAJOR_VERSION > 5 ; then
+                        AC_DEFINE(FPING_VERSION_5_2_OR_HIGHER, "true", [fping is of version 5.2 or higher])
+                        AC_MSG_NOTICE([fping is of version 5.2 or higher])
+                        AC_DEFINE(FPING_VERSION_5_3_OR_HIGHER, "true", [fping is of version 5.2 or higher])
+                        AC_MSG_NOTICE([fping is of version 5.3 or higher])
+                fi
+
+                if test "`fping --version | sed 's/.*fping: Version //'`" =  "5.2" ; then
+                        AC_DEFINE(FPING_VERSION, "5.2", [the version of fping available])
+                        AC_MSG_NOTICE([fping version: 5.2])
+                elif test "`fping --version | sed 's/.*fping: Version //'`" =  "5.3"; then
+                        AC_DEFINE(FPING_VERSION, "5.3", [the version of fping available])
+                        AC_MSG_NOTICE([fping version: 5.3])
+                fi
         fi
 else
         AC_MSG_WARN([Get fping from http://www.fping.com in order to make check_fping plugin])
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..b398c2ad 100644
--- a/lib/output.c
+++ b/lib/output.c
@@ -13,9 +13,11 @@
 
 // == Global variables
 static mp_output_format output_format = MP_FORMAT_DEFAULT;
+static mp_output_detail_level level_of_detail = MP_DETAIL_ALL;
 
 // == Prototypes ==
-static char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check, unsigned int indentation);
+static char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check,
+                                                                 unsigned int indentation);
 static inline cJSON *json_serialize_subcheck(mp_subcheck subcheck);
 
 // == Implementation ==
@@ -57,7 +59,9 @@ static inline char *fmt_subcheck_perfdata(mp_subcheck check) {
  * It sets useful defaults
  */
 mp_check mp_check_init(void) {
-        mp_check check = {0};
+        mp_check check = {
+                .evaluation_function = &mp_eval_check_default,
+        };
         return check;
 }
 
@@ -120,7 +124,8 @@ void mp_add_perfdata_to_subcheck(mp_subcheck check[static 1], const mp_perfdata
  */
 int mp_add_subcheck_to_subcheck(mp_subcheck check[static 1], mp_subcheck subcheck) {
         if (subcheck.output == NULL) {
-                die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__, "Sub check output is NULL");
+                die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__,
+                        "Sub check output is NULL");
         }
 
         mp_subcheck_list *tmp = NULL;
@@ -193,16 +198,33 @@ char *get_subcheck_summary(mp_check check) {
         return result;
 }
 
+mp_state_enum mp_compute_subcheck_state(const mp_subcheck subcheck) {
+        if (subcheck.evaluation_function == NULL) {
+                return mp_eval_subcheck_default(subcheck);
+        }
+        return subcheck.evaluation_function(subcheck);
+}
+
 /*
- * Generate the result state of a mp_subcheck object based on it's own state and it's subchecks states
+ * Generate the result state of a mp_subcheck object based on its own state and its subchecks
+ * states
  */
-mp_state_enum mp_compute_subcheck_state(const mp_subcheck check) {
-        if (check.state_set_explicitly) {
-                return check.state;
+mp_state_enum mp_eval_subcheck_default(mp_subcheck subcheck) {
+        if (subcheck.evaluation_function != NULL) {
+                return subcheck.evaluation_function(subcheck);
         }
 
-        mp_subcheck_list *scl = check.subchecks;
-        mp_state_enum result = check.default_state;
+        if (subcheck.state_set_explicitly) {
+                return subcheck.state;
+        }
+
+        mp_subcheck_list *scl = subcheck.subchecks;
+
+        if (scl == NULL) {
+                return subcheck.default_state;
+        }
+
+        mp_state_enum result = STATE_OK;
 
         while (scl != NULL) {
                 result = max_state_alt(result, mp_compute_subcheck_state(scl->subcheck));
@@ -212,10 +234,18 @@ mp_state_enum mp_compute_subcheck_state(const mp_subcheck check) {
         return result;
 }
 
+mp_state_enum mp_compute_check_state(const mp_check check) {
+        // just a safety check
+        if (check.evaluation_function == NULL) {
+                return mp_eval_check_default(check);
+        }
+        return check.evaluation_function(check);
+}
+
 /*
  * Generate the result state of a mp_check object based on it's own state and it's subchecks states
  */
-mp_state_enum mp_compute_check_state(const mp_check check) {
+mp_state_enum mp_eval_check_default(const mp_check check) {
         assert(check.subchecks != NULL); // a mp_check without subchecks is invalid, die here
 
         mp_subcheck_list *scl = check.subchecks;
@@ -247,7 +277,11 @@ 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;
                 }
 
@@ -258,7 +292,8 @@ char *mp_fmt_output(mp_check check) {
                         if (pd_string == NULL) {
                                 asprintf(&pd_string, "%s", fmt_subcheck_perfdata(subchecks->subcheck));
                         } else {
-                                asprintf(&pd_string, "%s %s", pd_string, fmt_subcheck_perfdata(subchecks->subcheck));
+                                asprintf(&pd_string, "%s %s", pd_string,
+                                                 fmt_subcheck_perfdata(subchecks->subcheck));
                         }
 
                         subchecks = subchecks->next;
@@ -327,19 +362,21 @@ static char *generate_indentation_string(unsigned int indentation) {
 /*
  * Helper function to generate the output string of mp_subcheck
  */
-static inline char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check, unsigned int indentation) {
+static inline char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check,
+                                                                                unsigned int indentation) {
         char *result = NULL;
         mp_subcheck_list *subchecks = NULL;
 
         switch (output_format) {
         case MP_FORMAT_MULTI_LINE:
-                asprintf(&result, "%s\\_[%s] - %s", generate_indentation_string(indentation), state_text(mp_compute_subcheck_state(check)),
-                                 check.output);
+                asprintf(&result, "%s\\_[%s] - %s", generate_indentation_string(indentation),
+                                 state_text(mp_compute_subcheck_state(check)), check.output);
 
                 subchecks = check.subchecks;
 
                 while (subchecks != NULL) {
-                        asprintf(&result, "%s\n%s", result, fmt_subcheck_output(output_format, subchecks->subcheck, indentation + 1));
+                        asprintf(&result, "%s\n%s", result,
+                                         fmt_subcheck_output(output_format, subchecks->subcheck, indentation + 1));
                         subchecks = subchecks->next;
                 }
                 return result;
@@ -539,3 +576,27 @@ 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; }
+
+mp_state_enum mp_eval_ok(mp_check overall) {
+        (void)overall;
+        return STATE_OK;
+}
+
+mp_state_enum mp_eval_warning(mp_check overall) {
+        (void)overall;
+        return STATE_WARNING;
+}
+
+mp_state_enum mp_eval_critical(mp_check overall) {
+        (void)overall;
+        return STATE_CRITICAL;
+}
+
+mp_state_enum mp_eval_unknown(mp_check overall) {
+        (void)overall;
+        return STATE_UNKNOWN;
+}
diff --git a/lib/output.h b/lib/output.h
index 2bdfa074..c63c8e3f 100644
--- a/lib/output.h
+++ b/lib/output.h
@@ -7,15 +7,21 @@
 /*
  * A partial check result
  */
-typedef struct {
+typedef struct mp_subcheck mp_subcheck;
+struct mp_subcheck {
         mp_state_enum state;         // OK, Warning, Critical ... set explicitly
         mp_state_enum default_state; // OK, Warning, Critical .. if not set explicitly
-        bool state_set_explicitly;   // was the state set explicitly (or should it be derived from subchecks)
+        bool state_set_explicitly;   // was the state set explicitly (or should it be derived from
+                                                                 // subchecks)
 
-        char *output;                    // Text output for humans ("Filesystem xyz is fine", "Could not create TCP connection to..")
-        pd_list *perfdata;               // Performance data for this check
+        char *output;      // Text output for humans ("Filesystem xyz is fine", "Could not create TCP
+                                           // connection to..")
+        pd_list *perfdata; // Performance data for this check
         struct subcheck_list *subchecks; // subchecks deeper in the hierarchy
-} mp_subcheck;
+
+        // the evaluation_functions computes the state of subcheck
+        mp_state_enum (*evaluation_function)(mp_subcheck);
+};
 
 /*
  * A list of subchecks, used in subchecks and the main check
@@ -38,8 +44,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.
@@ -47,10 +63,14 @@ typedef enum output_format {
  * The final result is always derived from the children and the "worst" state
  * in the first layer of subchecks
  */
-typedef struct {
-        char *summary;           // Overall summary, if not set a summary will be automatically generated
+typedef struct mp_check mp_check;
+struct mp_check {
+        char *summary; // Overall summary, if not set a summary will be automatically generated
         mp_subcheck_list *subchecks;
-} mp_check;
+
+        // the evaluation_functions computes the state of check
+        mp_state_enum (*evaluation_function)(mp_check);
+};
 
 mp_check mp_check_init(void);
 mp_subcheck mp_subcheck_init(void);
@@ -68,6 +88,13 @@ void mp_add_summary(mp_check check[static 1], char *summary);
 mp_state_enum mp_compute_check_state(mp_check);
 mp_state_enum mp_compute_subcheck_state(mp_subcheck);
 
+mp_state_enum mp_eval_ok(mp_check overall);
+mp_state_enum mp_eval_warning(mp_check overall);
+mp_state_enum mp_eval_critical(mp_check overall);
+mp_state_enum mp_eval_unknown(mp_check overall);
+mp_state_enum mp_eval_check_default(mp_check check);
+mp_state_enum mp_eval_subcheck_default(mp_subcheck subcheck);
+
 typedef struct {
         bool parsing_success;
         mp_output_format output_format;
diff --git a/lib/perfdata.c b/lib/perfdata.c
index 661756c5..b87de7e0 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));
 
@@ -257,6 +257,10 @@ mp_perfdata mp_set_pd_value_double(mp_perfdata pd, double value) {
         return pd;
 }
 
+mp_perfdata mp_set_pd_value_char(mp_perfdata pd, char value) { return mp_set_pd_value_long_long(pd, (long long)value); }
+
+mp_perfdata mp_set_pd_value_u_char(mp_perfdata pd, unsigned char value) { return mp_set_pd_value_u_long_long(pd, (unsigned long long)value); }
+
 mp_perfdata mp_set_pd_value_int(mp_perfdata pd, int value) { return mp_set_pd_value_long_long(pd, (long long)value); }
 
 mp_perfdata mp_set_pd_value_u_int(mp_perfdata pd, unsigned int value) { return mp_set_pd_value_u_long_long(pd, (unsigned long long)value); }
@@ -288,6 +292,10 @@ mp_perfdata_value mp_create_pd_value_double(double value) {
 
 mp_perfdata_value mp_create_pd_value_float(float value) { return mp_create_pd_value_double((double)value); }
 
+mp_perfdata_value mp_create_pd_value_char(char value) { return mp_create_pd_value_long_long((long long)value); }
+
+mp_perfdata_value mp_create_pd_value_u_char(unsigned char value) { return mp_create_pd_value_u_long_long((unsigned long long)value); }
+
 mp_perfdata_value mp_create_pd_value_int(int value) { return mp_create_pd_value_long_long((long long)value); }
 
 mp_perfdata_value mp_create_pd_value_u_int(unsigned int value) { return mp_create_pd_value_u_long_long((unsigned long long)value); }
@@ -514,3 +522,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..7fd908a9 100644
--- a/lib/perfdata.h
+++ b/lib/perfdata.h
@@ -155,6 +155,8 @@ mp_perfdata mp_set_pd_value_u_long_long(mp_perfdata, unsigned long long);
         _Generic((V),                                                                                                                          \
                 float: mp_create_pd_value_float,                                                                                                   \
                 double: mp_create_pd_value_double,                                                                                                 \
+                char: mp_create_pd_value_char,                                                                                                     \
+                unsigned char: mp_create_pd_value_u_char,                                                                                          \
                 int: mp_create_pd_value_int,                                                                                                       \
                 unsigned int: mp_create_pd_value_u_int,                                                                                            \
                 long: mp_create_pd_value_long,                                                                                                     \
@@ -164,6 +166,8 @@ mp_perfdata mp_set_pd_value_u_long_long(mp_perfdata, unsigned long long);
 
 mp_perfdata_value mp_create_pd_value_float(float);
 mp_perfdata_value mp_create_pd_value_double(double);
+mp_perfdata_value mp_create_pd_value_char(char);
+mp_perfdata_value mp_create_pd_value_u_char(unsigned char);
 mp_perfdata_value mp_create_pd_value_int(int);
 mp_perfdata_value mp_create_pd_value_u_int(unsigned int);
 mp_perfdata_value mp_create_pd_value_long(long);
@@ -171,6 +175,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 +187,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_cmd.c b/lib/utils_cmd.c
index 18350ac0..9b222409 100644
--- a/lib/utils_cmd.c
+++ b/lib/utils_cmd.c
@@ -346,7 +346,7 @@ int cmd_run_array(char *const *argv, output *out, output *err, int flags) {
         return _cmd_close(fd);
 }
 
-int cmd_file_read(char *filename, output *out, int flags) {
+int cmd_file_read(const char *filename, output *out, int flags) {
         int fd;
         if (out)
                 memset(out, 0, sizeof(output));
diff --git a/lib/utils_cmd.h b/lib/utils_cmd.h
index d00069c9..728ece23 100644
--- a/lib/utils_cmd.h
+++ b/lib/utils_cmd.h
@@ -20,7 +20,7 @@ typedef struct output output;
 /** prototypes **/
 int cmd_run(const char *, output *, output *, int);
 int cmd_run_array(char *const *, output *, output *, int);
-int cmd_file_read(char *, output *, int);
+int cmd_file_read(const char *, output *, int);
 
 /* only multi-threaded plugins need to bother with this */
 void cmd_init(void);
diff --git a/lib/utils_disk.c b/lib/utils_disk.c
deleted file mode 100644
index 2b761f5e..00000000
--- a/lib/utils_disk.c
+++ /dev/null
@@ -1,255 +0,0 @@
-/*****************************************************************************
- *
- * Library for check_disk
- *
- * License: GPL
- * Copyright (c) 1999-2024 Monitoring Plugins Development Team
- *
- * Description:
- *
- * This file contains utilities for check_disk. These are tested by libtap
- *
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- *
- *****************************************************************************/
-
-#include "common.h"
-#include "utils_disk.h"
-#include "gl/fsusage.h"
-#include <string.h>
-
-void np_add_name(struct name_list **list, const char *name) {
-        struct name_list *new_entry;
-        new_entry = (struct name_list *)malloc(sizeof *new_entry);
-        new_entry->name = (char *)name;
-        new_entry->next = *list;
-        *list = new_entry;
-}
-
-/* @brief Initialises a new regex at the begin of list via regcomp(3)
- *
- * @details if the regex fails to compile the error code of regcomp(3) is returned
- *                                      and list is not modified, otherwise list is modified to point to the new
- *                                      element
- * @param list Pointer to a linked list of regex_list elements
- * @param regex the string containing the regex which should be inserted into the list
- * @param clags the cflags parameter for regcomp(3)
- */
-int np_add_regex(struct regex_list **list, const char *regex, int cflags) {
-        struct regex_list *new_entry = (struct regex_list *)malloc(sizeof *new_entry);
-
-        if (new_entry == NULL) {
-                die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
-        }
-
-        int regcomp_result = regcomp(&new_entry->regex, regex, cflags);
-
-        if (!regcomp_result) {
-                // regcomp succeeded
-                new_entry->next = *list;
-                *list = new_entry;
-
-                return 0;
-        } else {
-                // regcomp failed
-                free(new_entry);
-
-                return regcomp_result;
-        }
-}
-
-/* Initialises a new parameter at the end of list */
-struct parameter_list *np_add_parameter(struct parameter_list **list, const char *name) {
-        struct parameter_list *current = *list;
-        struct parameter_list *new_path;
-        new_path = (struct parameter_list *)malloc(sizeof *new_path);
-        new_path->name = (char *)malloc(strlen(name) + 1);
-        new_path->best_match = NULL;
-        new_path->name_next = NULL;
-        new_path->name_prev = NULL;
-        new_path->freespace_bytes = NULL;
-        new_path->freespace_units = NULL;
-        new_path->freespace_percent = NULL;
-        new_path->usedspace_bytes = NULL;
-        new_path->usedspace_units = NULL;
-        new_path->usedspace_percent = NULL;
-        new_path->usedinodes_percent = NULL;
-        new_path->freeinodes_percent = NULL;
-        new_path->group = NULL;
-        new_path->dfree_pct = -1;
-        new_path->dused_pct = -1;
-        new_path->total = 0;
-        new_path->available = 0;
-        new_path->available_to_root = 0;
-        new_path->used = 0;
-        new_path->dused_units = 0;
-        new_path->dfree_units = 0;
-        new_path->dtotal_units = 0;
-        new_path->inodes_total = 0;
-        new_path->inodes_free = 0;
-        new_path->inodes_free_to_root = 0;
-        new_path->inodes_used = 0;
-        new_path->dused_inodes_percent = 0;
-        new_path->dfree_inodes_percent = 0;
-
-        strcpy(new_path->name, name);
-
-        if (current == NULL) {
-                *list = new_path;
-                new_path->name_prev = NULL;
-        } else {
-                while (current->name_next) {
-                        current = current->name_next;
-                }
-                current->name_next = new_path;
-                new_path->name_prev = current;
-        }
-        return new_path;
-}
-
-/* Delete a given parameter from list and return pointer to next element*/
-struct parameter_list *np_del_parameter(struct parameter_list *item, struct parameter_list *prev) {
-        if (item == NULL) {
-                return NULL;
-        }
-        struct parameter_list *next;
-
-        if (item->name_next)
-                next = item->name_next;
-        else
-                next = NULL;
-
-        if (next)
-                next->name_prev = prev;
-
-        if (prev)
-                prev->name_next = next;
-
-        if (item->name) {
-                free(item->name);
-        }
-        free(item);
-
-        return next;
-}
-
-/* returns a pointer to the struct found in the list */
-struct parameter_list *np_find_parameter(struct parameter_list *list, const char *name) {
-        struct parameter_list *temp_list;
-        for (temp_list = list; temp_list; temp_list = temp_list->name_next) {
-                if (!strcmp(temp_list->name, name))
-                        return temp_list;
-        }
-
-        return NULL;
-}
-
-void np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list, bool exact) {
-        struct parameter_list *d;
-        for (d = desired; d; d = d->name_next) {
-                if (!d->best_match) {
-                        struct mount_entry *me;
-                        size_t name_len = strlen(d->name);
-                        size_t best_match_len = 0;
-                        struct mount_entry *best_match = NULL;
-                        struct fs_usage fsp;
-
-                        /* set best match if path name exactly matches a mounted device name */
-                        for (me = mount_list; me; me = me->me_next) {
-                                if (strcmp(me->me_devname, d->name) == 0) {
-                                        if (get_fs_usage(me->me_mountdir, me->me_devname, &fsp) >= 0) {
-                                                best_match = me;
-                                        }
-                                }
-                        }
-
-                        /* set best match by directory name if no match was found by devname */
-                        if (!best_match) {
-                                for (me = mount_list; me; me = me->me_next) {
-                                        size_t len = strlen(me->me_mountdir);
-                                        if ((!exact &&
-                                                 (best_match_len <= len && len <= name_len && (len == 1 || strncmp(me->me_mountdir, d->name, len) == 0))) ||
-                                                (exact && strcmp(me->me_mountdir, d->name) == 0)) {
-                                                if (get_fs_usage(me->me_mountdir, me->me_devname, &fsp) >= 0) {
-                                                        best_match = me;
-                                                        best_match_len = len;
-                                                }
-                                        }
-                                }
-                        }
-
-                        if (best_match) {
-                                d->best_match = best_match;
-                        } else {
-                                d->best_match = NULL; /* Not sure why this is needed as it should be null on initialisation */
-                        }
-                }
-        }
-}
-
-/* Returns true if name is in list */
-bool np_find_name(struct name_list *list, const char *name) {
-        const struct name_list *n;
-
-        if (list == NULL || name == NULL) {
-                return false;
-        }
-        for (n = list; n; n = n->next) {
-                if (!strcmp(name, n->name)) {
-                        return true;
-                }
-        }
-        return false;
-}
-
-/* Returns true if name is in list */
-bool np_find_regmatch(struct regex_list *list, const char *name) {
-        int len;
-        regmatch_t m;
-
-        if (name == NULL) {
-                return false;
-        }
-
-        len = strlen(name);
-
-        for (; list; list = list->next) {
-                /* Emulate a full match as if surrounded with ^( )$
-                   by checking whether the match spans the whole name */
-                if (!regexec(&list->regex, name, 1, &m, 0) && m.rm_so == 0 && m.rm_eo == len) {
-                        return true;
-                }
-        }
-
-        return false;
-}
-
-bool np_seen_name(struct name_list *list, const char *name) {
-        const struct name_list *s;
-        for (s = list; s; s = s->next) {
-                if (!strcmp(s->name, name)) {
-                        return true;
-                }
-        }
-        return false;
-}
-
-bool np_regex_match_mount_entry(struct mount_entry *me, regex_t *re) {
-        if (regexec(re, me->me_devname, (size_t)0, NULL, 0) == 0 || regexec(re, me->me_mountdir, (size_t)0, NULL, 0) == 0) {
-                return true;
-        }
-        return false;
-}
diff --git a/lib/utils_disk.h b/lib/utils_disk.h
deleted file mode 100644
index c5e81dc1..00000000
--- a/lib/utils_disk.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Header file for utils_disk */
-
-#include "mountlist.h"
-#include "utils_base.h"
-#include "regex.h"
-
-struct name_list {
-        char *name;
-        struct name_list *next;
-};
-
-struct regex_list {
-        regex_t regex;
-        struct regex_list *next;
-};
-
-struct parameter_list {
-        char *name;
-        thresholds *freespace_bytes;
-        thresholds *freespace_units;
-        thresholds *freespace_percent;
-        thresholds *usedspace_bytes;
-        thresholds *usedspace_units;
-        thresholds *usedspace_percent;
-        thresholds *usedinodes_percent;
-        thresholds *freeinodes_percent;
-        char *group;
-        struct mount_entry *best_match;
-        struct parameter_list *name_next;
-        struct parameter_list *name_prev;
-        uintmax_t total, available, available_to_root, used, inodes_free, inodes_free_to_root, inodes_used, inodes_total;
-        double dfree_pct, dused_pct;
-        uint64_t dused_units, dfree_units, dtotal_units;
-        double dused_inodes_percent, dfree_inodes_percent;
-};
-
-void np_add_name(struct name_list **list, const char *name);
-bool np_find_name(struct name_list *list, const char *name);
-bool np_seen_name(struct name_list *list, const char *name);
-int np_add_regex(struct regex_list **list, const char *regex, int cflags);
-bool np_find_regmatch(struct regex_list *list, const char *name);
-struct parameter_list *np_add_parameter(struct parameter_list **list, const char *name);
-struct parameter_list *np_find_parameter(struct parameter_list *list, const char *name);
-struct parameter_list *np_del_parameter(struct parameter_list *item, struct parameter_list *prev);
-
-int search_parameter_list(struct parameter_list *list, const char *name);
-void np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list, bool exact);
-bool np_regex_match_mount_entry(struct mount_entry *me, regex_t *re);
diff --git a/lib/utils_tcp.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-root/Makefile.am b/plugins-root/Makefile.am
index a80229e2..b6342909 100644
--- a/plugins-root/Makefile.am
+++ b/plugins-root/Makefile.am
@@ -24,7 +24,9 @@ noinst_PROGRAMS = check_dhcp check_icmp @EXTRAS_ROOT@
 
 EXTRA_PROGRAMS = pst3
 
-EXTRA_DIST = t pst3.c
+EXTRA_DIST = t pst3.c \
+                         check_icmp.d \
+                         check_dhcp.d
 
 BASEOBJS = ../plugins/utils.o ../lib/libmonitoringplug.a ../gl/libgnu.a
 NETOBJS = ../plugins/netutils.o $(BASEOBJS) $(EXTRA_NETOBJS)
@@ -82,6 +84,7 @@ install-exec-local: $(noinst_PROGRAMS)
 # the actual targets
 check_dhcp_LDADD = @LTLIBINTL@ $(NETLIBS) $(LIB_CRYPTO)
 check_icmp_LDADD = @LTLIBINTL@ $(NETLIBS) $(SOCKETLIBS) $(LIB_CRYPTO)
+check_icmp_SOURCES = check_icmp.c check_icmp.d/check_icmp_helpers.c
 
 # -m64 needed at compiler and linker phase
 pst3_CFLAGS = @PST3CFLAGS@
@@ -89,7 +92,7 @@ pst3_LDFLAGS = @PST3CFLAGS@
 # pst3 must not use monitoringplug/gnulib includes!
 pst3_CPPFLAGS =
 
-check_dhcp_DEPENDENCIES = check_dhcp.c $(NETOBJS) $(DEPLIBS) 
+check_dhcp_DEPENDENCIES = check_dhcp.c $(NETOBJS) $(DEPLIBS)
 check_icmp_DEPENDENCIES = check_icmp.c $(NETOBJS)
 
 clean-local:
diff --git a/plugins-root/check_dhcp.c b/plugins-root/check_dhcp.c
index 6802232e..daed9cb0 100644
--- a/plugins-root/check_dhcp.c
+++ b/plugins-root/check_dhcp.c
@@ -4,7 +4,7 @@
  *
  * License: GPL
  * Copyright (c) 2001-2004 Ethan Galstad (nagios@nagios.org)
- * Copyright (c) 2001-2023 Monitoring Plugins Development Team
+ * Copyright (c) 2001-2025 Monitoring Plugins Development Team
  *
  * Description:
  *
@@ -34,13 +34,17 @@
  *****************************************************************************/
 
 const char *progname = "check_dhcp";
-const char *copyright = "2001-2024";
+const char *copyright = "2001-2025";
 const char *email = "devel@monitoring-plugins.org";
 
-#include "common.h"
-#include "netutils.h"
-#include "utils.h"
+#include "../plugins/common.h"
+#include "../plugins/utils.h"
+#include "./check_dhcp.d/config.h"
+#include "../lib/output.h"
+#include "../lib/utils_base.h"
 
+#include "states.h"
+#include <stdint.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -111,8 +115,9 @@ static long mac_addr_dlpi(const char *, int, u_char *);
 
 /**** Common definitions ****/
 
-#define OK    0
-#define ERROR -1
+#define OK           0
+#define ERROR        -1
+#define MAC_ADDR_LEN 6
 
 /**** DHCP definitions ****/
 
@@ -149,12 +154,6 @@ typedef struct dhcp_offer_struct {
         struct dhcp_offer_struct *next;
 } dhcp_offer;
 
-typedef struct requested_server_struct {
-        struct in_addr server_address;
-        bool answered;
-        struct requested_server_struct *next;
-} requested_server;
-
 #define BOOTREQUEST 1
 #define BOOTREPLY   2
 
@@ -186,65 +185,60 @@ typedef struct requested_server_struct {
 #define ETHERNET_HARDWARE_ADDRESS        1 /* used in htype field of dhcp packet */
 #define ETHERNET_HARDWARE_ADDRESS_LENGTH 6 /* length of Ethernet hardware addresses */
 
-static bool unicast = false;   /* unicast mode: mimic a DHCP relay */
-static bool exclusive = false; /* exclusive mode aka "rogue DHCP server detection" */
-static struct in_addr my_ip;   /* our address (required for relay) */
-static struct in_addr dhcp_ip; /* server to query (if in unicast mode) */
-static unsigned char client_hardware_address[MAX_DHCP_CHADDR_LENGTH] = "";
-static unsigned char *user_specified_mac = NULL;
-
-static char network_interface_name[IFNAMSIZ] = "eth0";
-
-static uint32_t packet_xid = 0;
-
-static uint32_t dhcp_lease_time = 0;
-static uint32_t dhcp_renewal_time = 0;
-static uint32_t dhcp_rebinding_time = 0;
-
-static int dhcpoffer_timeout = 2;
-
-static dhcp_offer *dhcp_offer_list = NULL;
-static requested_server *requested_server_list = NULL;
-
-static int valid_responses = 0; /* number of valid DHCPOFFERs we received */
-static int requested_servers = 0;
-static int requested_responses = 0;
-
-static bool request_specific_address = false;
-static bool received_requested_address = false;
 static int verbose = 0;
-static struct in_addr requested_address;
 
-static int process_arguments(int, char **);
-static int call_getopt(int, char **);
-static int validate_arguments(int);
+typedef struct process_arguments_wrapper {
+        int error;
+        check_dhcp_config config;
+} process_arguments_wrapper;
+
+static process_arguments_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
 void print_usage(void);
 static void print_help(void);
 
-static void resolve_host(const char *in, struct in_addr *out);
-static unsigned char *mac_aton(const char *);
-static void print_hardware_address(const unsigned char *);
-static int get_hardware_address(int, char *);
-static int get_ip_address(int, char *);
-
-static int send_dhcp_discover(int);
-static int get_dhcp_offer(int);
-
-static int get_results(void);
-
-static int add_dhcp_offer(struct in_addr, dhcp_packet *);
-static int free_dhcp_offer_list(void);
-static int free_requested_server_list(void);
-
-static int create_dhcp_socket(void);
-static int close_dhcp_socket(int);
-static int send_dhcp_packet(void *, int, int, struct sockaddr_in *);
-static int receive_dhcp_packet(void *, int, int, int, struct sockaddr_in *);
+static void resolve_host(const char * /*in*/, struct in_addr * /*out*/);
+static unsigned char *mac_aton(const char * /*string*/);
+static void print_hardware_address(const unsigned char * /*address*/);
+static int get_hardware_address(int /*sock*/, char * /*interface_name*/, unsigned char *client_hardware_address);
+
+typedef struct get_ip_address_wrapper {
+        int error;
+        struct in_addr my_ip;
+} get_ip_address_wrapper;
+static get_ip_address_wrapper get_ip_address(int /*sock*/, char * /*interface_name*/);
+
+typedef struct send_dhcp_discover_wrapper {
+        int error;
+        uint32_t packet_xid;
+} send_dhcp_discover_wrapper;
+static send_dhcp_discover_wrapper send_dhcp_discover(int socket, bool unicast, struct in_addr dhcp_ip, struct in_addr requested_address,
+                                                                                                         bool request_specific_address, struct in_addr my_ip,
+                                                                                                         unsigned char *client_hardware_address);
+typedef struct get_dhcp_offer_wrapper {
+        int error;
+        int valid_responses;
+        dhcp_offer *dhcp_offer_list;
+} get_dhcp_offer_wrapper;
+static get_dhcp_offer_wrapper get_dhcp_offer(int /*sock*/, int dhcpoffer_timeout, uint32_t packet_xid, dhcp_offer *dhcp_offer_list,
+                                                                                         const unsigned char *client_hardware_address);
+
+static mp_subcheck get_results(bool exclusive, int requested_servers, struct in_addr requested_address, bool request_specific_address,
+                                                           requested_server *requested_server_list, int valid_responses, dhcp_offer *dhcp_offer_list);
+
+typedef struct add_dhcp_offer_wrapper {
+        int error;
+        dhcp_offer *dhcp_offer_list;
+} add_dhcp_offer_wrapper;
+static add_dhcp_offer_wrapper add_dhcp_offer(struct in_addr /*source*/, dhcp_packet * /*offer_packet*/, dhcp_offer *dhcp_offer_list);
+static int free_dhcp_offer_list(dhcp_offer *dhcp_offer_list);
+static int free_requested_server_list(requested_server *requested_server_list);
+
+static int create_dhcp_socket(bool /*unicast*/, char *network_interface_name);
+static int close_dhcp_socket(int /*sock*/);
+static int send_dhcp_packet(void * /*buffer*/, int /*buffer_size*/, int /*sock*/, struct sockaddr_in * /*dest*/);
+static int receive_dhcp_packet(void * /*buffer*/, int /*buffer_size*/, int /*sock*/, int /*timeout*/, struct sockaddr_in * /*address*/);
 
 int main(int argc, char **argv) {
-        int dhcp_socket;
-        int result = STATE_UNKNOWN;
-
         setlocale(LC_ALL, "");
         bindtextdomain(PACKAGE, LOCALEDIR);
         textdomain(PACKAGE);
@@ -252,43 +246,80 @@ int main(int argc, char **argv) {
         /* Parse extra opts if any */
         argv = np_extra_opts(&argc, argv, progname);
 
-        if (process_arguments(argc, argv) != OK) {
+        process_arguments_wrapper tmp = process_arguments(argc, argv);
+
+        if (tmp.error != OK) {
                 usage4(_("Could not parse arguments"));
         }
 
+        check_dhcp_config config = tmp.config;
+        if (config.output_format_is_set) {
+                mp_set_format(config.output_format);
+        }
+
         /* create socket for DHCP communications */
-        dhcp_socket = create_dhcp_socket();
+        int dhcp_socket = create_dhcp_socket(config.unicast_mode, config.network_interface_name);
 
         /* get hardware address of client machine */
-        if (user_specified_mac != NULL)
-                memcpy(client_hardware_address, user_specified_mac, 6);
-        else
-                get_hardware_address(dhcp_socket, network_interface_name);
+        unsigned char client_hardware_address[MAX_DHCP_CHADDR_LENGTH] = "";
+        if (config.user_specified_mac != NULL) {
+                memcpy(client_hardware_address, config.user_specified_mac, MAC_ADDR_LEN);
+        } else {
+                get_hardware_address(dhcp_socket, config.network_interface_name, client_hardware_address);
+        }
 
-        if (unicast) /* get IP address of client machine */
-                get_ip_address(dhcp_socket, network_interface_name);
+        struct in_addr my_ip = {0};
+
+        if (config.unicast_mode) { /* get IP address of client machine */
+                get_ip_address_wrapper tmp_get_ip = get_ip_address(dhcp_socket, config.network_interface_name);
+                if (tmp_get_ip.error == OK) {
+                        my_ip = tmp_get_ip.my_ip;
+                } else {
+                        // TODO failed to get own IP
+                        die(STATE_UNKNOWN, "Failed to retrieve my own IP address in unicast mode");
+                }
+        }
 
         /* send DHCPDISCOVER packet */
-        send_dhcp_discover(dhcp_socket);
+        send_dhcp_discover_wrapper disco_res = send_dhcp_discover(dhcp_socket, config.unicast_mode, config.dhcp_ip, config.requested_address,
+                                                                                                                          config.request_specific_address, my_ip, client_hardware_address);
+
+        if (disco_res.error != OK) {
+                // DO something?
+                die(STATE_UNKNOWN, "Failed to send DHCP discover");
+        }
 
         /* wait for a DHCPOFFER packet */
-        get_dhcp_offer(dhcp_socket);
+        get_dhcp_offer_wrapper offer_res =
+                get_dhcp_offer(dhcp_socket, config.dhcpoffer_timeout, disco_res.packet_xid, NULL, client_hardware_address);
+
+        int valid_responses = 0;
+        dhcp_offer *dhcp_offer_list = NULL;
+        if (offer_res.error == OK) {
+                valid_responses = offer_res.valid_responses;
+                dhcp_offer_list = offer_res.dhcp_offer_list;
+        } else {
+                die(STATE_UNKNOWN, "Failed to get DHCP offers");
+        }
 
         /* close socket we created */
         close_dhcp_socket(dhcp_socket);
 
-        /* determine state/plugin output to return */
-        result = get_results();
+        mp_check overall = mp_check_init();
 
+        /* determine state/plugin output to return */
+        mp_subcheck sc_res = get_results(config.exclusive_mode, config.num_of_requested_servers, config.requested_address,
+                                                                         config.request_specific_address, config.requested_server_list, valid_responses, dhcp_offer_list);
+        mp_add_subcheck_to_check(&overall, sc_res);
         /* free allocated memory */
-        free_dhcp_offer_list();
-        free_requested_server_list();
+        free_dhcp_offer_list(dhcp_offer_list);
+        free_requested_server_list(config.requested_server_list);
 
-        return result;
+        mp_exit(overall);
 }
 
 /* determines hardware address on client machine */
-static int get_hardware_address(int sock, char *interface_name) {
+int get_hardware_address(int sock, char *interface_name, unsigned char *client_hardware_address) {
 
 #if defined(__linux__)
         struct ifreq ifr;
@@ -302,7 +333,7 @@ static int get_hardware_address(int sock, char *interface_name) {
                 exit(STATE_UNKNOWN);
         }
 
-        memcpy(&client_hardware_address[0], &ifr.ifr_hwaddr.sa_data, 6);
+        memcpy(&client_hardware_address[0], &ifr.ifr_hwaddr.sa_data, MAC_ADDR_LEN);
 
 #elif defined(__bsd__)
         /* King 2004    see ACKNOWLEDGEMENTS */
@@ -358,8 +389,9 @@ static int get_hardware_address(int sock, char *interface_name) {
         int i;
         p = interface_name + strlen(interface_name) - 1;
         for (i = strlen(interface_name) - 1; i > 0; p--) {
-                if (isalpha(*p))
+                if (isalpha(*p)) {
                         break;
+                }
         }
         p++;
         if (p != interface_name) {
@@ -393,14 +425,15 @@ static int get_hardware_address(int sock, char *interface_name) {
         exit(STATE_UNKNOWN);
 #endif
 
-        if (verbose)
+        if (verbose) {
                 print_hardware_address(client_hardware_address);
+        }
 
         return OK;
 }
 
 /* determines IP address of the client interface */
-static int get_ip_address(int sock, char *interface_name) {
+get_ip_address_wrapper get_ip_address(int sock, char *interface_name) {
 #if defined(SIOCGIFADDR)
         struct ifreq ifr;
 
@@ -412,28 +445,28 @@ static int get_ip_address(int sock, char *interface_name) {
                 exit(STATE_UNKNOWN);
         }
 
-        my_ip = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
-
 #else
         printf(_("Error: Cannot get interface IP address on this platform.\n"));
         exit(STATE_UNKNOWN);
 #endif
 
-        if (verbose)
-                printf(_("Pretending to be relay client %s\n"), inet_ntoa(my_ip));
+        get_ip_address_wrapper result = {
+                .error = OK,
+                .my_ip = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr,
+        };
 
-        return OK;
+        if (verbose) {
+                printf(_("Pretending to be relay client %s\n"), inet_ntoa(result.my_ip));
+        }
+
+        return result;
 }
 
 /* sends a DHCPDISCOVER broadcast message in an attempt to find DHCP servers */
-static int send_dhcp_discover(int sock) {
-        dhcp_packet discover_packet;
-        struct sockaddr_in sockaddr_broadcast;
-        unsigned short opts;
-
-        /* clear the packet data structure */
-        bzero(&discover_packet, sizeof(discover_packet));
-
+static send_dhcp_discover_wrapper send_dhcp_discover(int sock, bool unicast, struct in_addr dhcp_ip, struct in_addr requested_address,
+                                                                                                         bool request_specific_address, struct in_addr my_ip,
+                                                                                                         unsigned char *client_hardware_address) {
+        dhcp_packet discover_packet = {0};
         /* boot request flag (backward compatible with BOOTP servers) */
         discover_packet.op = BOOTREQUEST;
 
@@ -443,12 +476,15 @@ static int send_dhcp_discover(int sock) {
         /* length of our hardware address */
         discover_packet.hlen = ETHERNET_HARDWARE_ADDRESS_LENGTH;
 
+        send_dhcp_discover_wrapper result = {
+                .error = OK,
+        };
         /*
          * transaction ID is supposed to be random.
          */
         srand(time(NULL) ^ getpid());
-        packet_xid = random();
-        discover_packet.xid = htonl(packet_xid);
+        result.packet_xid = random();
+        discover_packet.xid = htonl(result.packet_xid);
 
         /*discover_packet.secs=htons(65535);*/
         discover_packet.secs = 0xFF;
@@ -468,7 +504,7 @@ static int send_dhcp_discover(int sock) {
         discover_packet.options[2] = '\x53';
         discover_packet.options[3] = '\x63';
 
-        opts = 4;
+        unsigned short opts = 4;
         /* DHCP message type is embedded in options field */
         discover_packet.options[opts++] = DHCP_OPTION_MESSAGE_TYPE; /* DHCP message type option identifier */
         discover_packet.options[opts++] = '\x01';                   /* DHCP message option length in bytes */
@@ -484,17 +520,19 @@ static int send_dhcp_discover(int sock) {
         discover_packet.options[opts++] = (char)DHCP_OPTION_END;
 
         /* unicast fields */
-        if (unicast)
+        if (unicast) {
                 discover_packet.giaddr.s_addr = my_ip.s_addr;
+        }
 
         /* see RFC 1542, 4.1.1 */
         discover_packet.hops = unicast ? 1 : 0;
 
         /* send the DHCPDISCOVER packet to broadcast address */
-        sockaddr_broadcast.sin_family = AF_INET;
-        sockaddr_broadcast.sin_port = htons(DHCP_SERVER_PORT);
-        sockaddr_broadcast.sin_addr.s_addr = unicast ? dhcp_ip.s_addr : INADDR_BROADCAST;
-        bzero(&sockaddr_broadcast.sin_zero, sizeof(sockaddr_broadcast.sin_zero));
+        struct sockaddr_in sockaddr_broadcast = {
+                .sin_family = AF_INET,
+                .sin_port = htons(DHCP_SERVER_PORT),
+                .sin_addr.s_addr = unicast ? dhcp_ip.s_addr : INADDR_BROADCAST,
+        };
 
         if (verbose) {
                 printf(_("DHCPDISCOVER to %s port %d\n"), inet_ntoa(sockaddr_broadcast.sin_addr), ntohs(sockaddr_broadcast.sin_port));
@@ -508,56 +546,56 @@ static int send_dhcp_discover(int sock) {
         /* send the DHCPDISCOVER packet out */
         send_dhcp_packet(&discover_packet, sizeof(discover_packet), sock, &sockaddr_broadcast);
 
-        if (verbose)
+        if (verbose) {
                 printf("\n\n");
+        }
 
-        return OK;
+        return result;
 }
 
 /* waits for a DHCPOFFER message from one or more DHCP servers */
-static int get_dhcp_offer(int sock) {
-        dhcp_packet offer_packet;
-        struct sockaddr_in source;
-        struct sockaddr_in via;
-        int result = OK;
-        int responses = 0;
-        int x;
+get_dhcp_offer_wrapper get_dhcp_offer(int sock, int dhcpoffer_timeout, uint32_t packet_xid, dhcp_offer *dhcp_offer_list,
+                                                                          const unsigned char *client_hardware_address) {
         time_t start_time;
-        time_t current_time;
-
         time(&start_time);
 
+        int result = OK;
+        int responses = 0;
+        int valid_responses = 0;
         /* receive as many responses as we can */
-        for (responses = 0, valid_responses = 0;;) {
-
+        for (;;) {
+                time_t current_time;
                 time(&current_time);
-                if ((current_time - start_time) >= dhcpoffer_timeout)
+                if ((current_time - start_time) >= dhcpoffer_timeout) {
                         break;
+                }
 
-                if (verbose)
+                if (verbose) {
                         printf("\n\n");
+                }
 
-                bzero(&source, sizeof(source));
-                bzero(&via, sizeof(via));
-                bzero(&offer_packet, sizeof(offer_packet));
+                struct sockaddr_in source = {0};
+                dhcp_packet offer_packet = {0};
 
                 result = OK;
                 result = receive_dhcp_packet(&offer_packet, sizeof(offer_packet), sock, dhcpoffer_timeout, &source);
 
                 if (result != OK) {
-                        if (verbose)
+                        if (verbose) {
                                 printf(_("Result=ERROR\n"));
+                        }
 
                         continue;
-                } else {
-                        if (verbose)
-                                printf(_("Result=OK\n"));
-
-                        responses++;
+                }
+                if (verbose) {
+                        printf(_("Result=OK\n"));
                 }
 
+                responses++;
+
                 /* The "source" is either a server or a relay. */
                 /* Save a copy of "source" into "via" even if it's via itself */
+                struct sockaddr_in via = {0};
                 memcpy(&via, &source, sizeof(source));
 
                 if (verbose) {
@@ -568,30 +606,37 @@ static int get_dhcp_offer(int sock) {
 
                 /* check packet xid to see if its the same as the one we used in the discover packet */
                 if (ntohl(offer_packet.xid) != packet_xid) {
-                        if (verbose)
-                                printf(_("DHCPOFFER XID (%u) did not match DHCPDISCOVER XID (%u) - ignoring packet\n"), ntohl(offer_packet.xid), packet_xid);
+                        if (verbose) {
+                                printf(_("DHCPOFFER XID (%u) did not match DHCPDISCOVER XID (%u) - ignoring packet\n"), ntohl(offer_packet.xid),
+                                           packet_xid);
+                        }
 
                         continue;
                 }
 
                 /* check hardware address */
                 result = OK;
-                if (verbose)
+                if (verbose) {
                         printf("DHCPOFFER chaddr: ");
+                }
 
-                for (x = 0; x < ETHERNET_HARDWARE_ADDRESS_LENGTH; x++) {
-                        if (verbose)
-                                printf("%02X", (unsigned char)offer_packet.chaddr[x]);
+                for (int i = 0; i < ETHERNET_HARDWARE_ADDRESS_LENGTH; i++) {
+                        if (verbose) {
+                                printf("%02X", offer_packet.chaddr[i]);
+                        }
 
-                        if (offer_packet.chaddr[x] != client_hardware_address[x])
+                        if (offer_packet.chaddr[i] != client_hardware_address[i]) {
                                 result = ERROR;
+                        }
                 }
-                if (verbose)
+                if (verbose) {
                         printf("\n");
+                }
 
                 if (result == ERROR) {
-                        if (verbose)
+                        if (verbose) {
                                 printf(_("DHCPOFFER hardware address did not match our own - ignoring packet\n"));
+                        }
 
                         continue;
                 }
@@ -603,7 +648,12 @@ static int get_dhcp_offer(int sock) {
                         printf("DHCPOFFER giaddr: %s\n", inet_ntoa(offer_packet.giaddr));
                 }
 
-                add_dhcp_offer(source.sin_addr, &offer_packet);
+                add_dhcp_offer_wrapper add_res = add_dhcp_offer(source.sin_addr, &offer_packet, dhcp_offer_list);
+                if (add_res.error != OK) {
+                        // TODO
+                } else {
+                        dhcp_offer_list = add_res.dhcp_offer_list;
+                }
 
                 valid_responses++;
         }
@@ -613,104 +663,101 @@ static int get_dhcp_offer(int sock) {
                 printf(_("Valid responses for this machine: %d\n"), valid_responses);
         }
 
-        return OK;
+        get_dhcp_offer_wrapper ret_val = {
+                .error = OK,
+                .valid_responses = valid_responses,
+                .dhcp_offer_list = dhcp_offer_list,
+        };
+        return ret_val;
 }
 
 /* sends a DHCP packet */
-static int send_dhcp_packet(void *buffer, int buffer_size, int sock, struct sockaddr_in *dest) {
-        int result;
-
-        result = sendto(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)dest, sizeof(*dest));
+int send_dhcp_packet(void *buffer, int buffer_size, int sock, struct sockaddr_in *dest) {
+        int result = sendto(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)dest, sizeof(*dest));
 
-        if (verbose)
+        if (verbose) {
                 printf(_("send_dhcp_packet result: %d\n"), result);
+        }
 
-        if (result < 0)
+        if (result < 0) {
                 return ERROR;
+        }
 
         return OK;
 }
 
 /* receives a DHCP packet */
-static int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int timeout, struct sockaddr_in *address) {
-        struct timeval tv;
-        fd_set readfds;
-        fd_set oobfds;
-        int recv_result;
-        socklen_t address_size;
-        struct sockaddr_in source_address;
-        int nfound;
-
+int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int timeout, struct sockaddr_in *address) {
         /* wait for data to arrive (up time timeout) */
-        tv.tv_sec = timeout;
-        tv.tv_usec = 0;
+        struct timeval timeout_val = {
+                .tv_sec = timeout,
+                .tv_usec = 0,
+        };
+        fd_set readfds;
         FD_ZERO(&readfds);
+        fd_set oobfds;
         FD_ZERO(&oobfds);
         FD_SET(sock, &readfds);
         FD_SET(sock, &oobfds);
-        nfound = select(sock + 1, &readfds, NULL, &oobfds, &tv);
+        int nfound = select(sock + 1, &readfds, NULL, &oobfds, &timeout_val);
 
         /* make sure some data has arrived */
         if (!FD_ISSET(sock, &readfds)) {
-                if (verbose)
+                if (verbose) {
                         printf(_("No (more) data received (nfound: %d)\n"), nfound);
+                }
                 return ERROR;
         }
 
-        else {
-                bzero(&source_address, sizeof(source_address));
-                address_size = sizeof(source_address);
-                recv_result = recvfrom(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)&source_address, &address_size);
-                if (verbose)
-                        printf("recv_result: %d\n", recv_result);
-
-                if (recv_result == -1) {
-                        if (verbose) {
-                                printf(_("recvfrom() failed, "));
-                                printf("errno: (%d) -> %s\n", errno, strerror(errno));
-                        }
-                        return ERROR;
-                } else {
-                        if (verbose) {
-                                printf(_("receive_dhcp_packet() result: %d\n"), recv_result);
-                                printf(_("receive_dhcp_packet() source: %s\n"), inet_ntoa(source_address.sin_addr));
-                        }
+        struct sockaddr_in source_address = {0};
+        socklen_t address_size = sizeof(source_address);
+        int recv_result = recvfrom(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)&source_address, &address_size);
+        if (verbose) {
+                printf("recv_result: %d\n", recv_result);
+        }
 
-                        memcpy(address, &source_address, sizeof(source_address));
-                        return OK;
+        if (recv_result == -1) {
+                if (verbose) {
+                        printf(_("recvfrom() failed, "));
+                        printf("errno: (%d) -> %s\n", errno, strerror(errno));
                 }
+                return ERROR;
+        }
+        if (verbose) {
+                printf(_("receive_dhcp_packet() result: %d\n"), recv_result);
+                printf(_("receive_dhcp_packet() source: %s\n"), inet_ntoa(source_address.sin_addr));
         }
 
+        memcpy(address, &source_address, sizeof(source_address));
         return OK;
 }
 
 /* creates a socket for DHCP communication */
-static int create_dhcp_socket(void) {
-        struct sockaddr_in myname;
-        struct ifreq interface;
-        int sock;
-        int flag = 1;
-
+int create_dhcp_socket(bool unicast, char *network_interface_name) {
         /* Set up the address we're going to bind to. */
-        bzero(&myname, sizeof(myname));
-        myname.sin_family = AF_INET;
         /* listen to DHCP server port if we're in unicast mode */
-        myname.sin_port = htons(unicast ? DHCP_SERVER_PORT : DHCP_CLIENT_PORT);
-        myname.sin_addr.s_addr = unicast ? my_ip.s_addr : INADDR_ANY;
-        bzero(&myname.sin_zero, sizeof(myname.sin_zero));
+        struct sockaddr_in myname = {
+                .sin_family = AF_INET,
+                .sin_port = htons(unicast ? DHCP_SERVER_PORT : DHCP_CLIENT_PORT),
+                // TODO previously the next line was trying to use our own IP, we was not set
+                // until some point later, so it was removed. Recheck whether it is actually
+                // necessary/useful
+                .sin_addr.s_addr = INADDR_ANY,
+        };
 
         /* create a socket for DHCP communications */
-        sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+        int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
         if (sock < 0) {
                 printf(_("Error: Could not create socket!\n"));
                 exit(STATE_UNKNOWN);
         }
 
-        if (verbose)
+        if (verbose) {
                 printf("DHCP socket: %d\n", sock);
+        }
 
         /* set the reuse address flag so we don't get errors when restarting */
-        flag = 1;
+        int flag = 1;
         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&flag, sizeof(flag)) < 0) {
                 printf(_("Error: Could not set reuse address option on DHCP socket!\n"));
                 exit(STATE_UNKNOWN);
@@ -722,6 +769,7 @@ static int create_dhcp_socket(void) {
                 exit(STATE_UNKNOWN);
         }
 
+        struct ifreq interface;
         /* bind socket to interface */
 #if defined(__linux__)
         strncpy(interface.ifr_ifrn.ifrn_name, network_interface_name, IFNAMSIZ - 1);
@@ -746,105 +794,116 @@ static int create_dhcp_socket(void) {
 }
 
 /* closes DHCP socket */
-static int close_dhcp_socket(int sock) {
-
+int close_dhcp_socket(int sock) {
         close(sock);
-
         return OK;
 }
 
 /* adds a requested server address to list in memory */
-static int add_requested_server(struct in_addr server_address) {
-        requested_server *new_server;
-
-        new_server = (requested_server *)malloc(sizeof(requested_server));
-        if (new_server == NULL)
+int add_requested_server(struct in_addr server_address, int *requested_servers, requested_server **requested_server_list) {
+        requested_server *new_server = (requested_server *)malloc(sizeof(requested_server));
+        if (new_server == NULL) {
                 return ERROR;
+        }
 
         new_server->server_address = server_address;
         new_server->answered = false;
 
-        new_server->next = requested_server_list;
-        requested_server_list = new_server;
+        new_server->next = *requested_server_list;
+        *requested_server_list = new_server;
 
-        requested_servers++;
+        *requested_servers += 1;
 
-        if (verbose)
+        if (verbose) {
                 printf(_("Requested server address: %s\n"), inet_ntoa(new_server->server_address));
+        }
 
         return OK;
 }
 
 /* adds a DHCP OFFER to list in memory */
-static int add_dhcp_offer(struct in_addr source, dhcp_packet *offer_packet) {
+add_dhcp_offer_wrapper add_dhcp_offer(struct in_addr source, dhcp_packet *offer_packet, dhcp_offer *dhcp_offer_list) {
+        if (offer_packet == NULL) {
+                add_dhcp_offer_wrapper tmp = {
+                        .error = ERROR,
+                };
+                return tmp;
+        }
+
+        uint32_t dhcp_lease_time = 0;
+        uint32_t dhcp_renewal_time = 0;
+        uint32_t dhcp_rebinding_time = 0;
         dhcp_offer *new_offer;
-        int x;
-        unsigned option_type;
-        unsigned option_length;
         struct in_addr serv_ident = {0};
-
-        if (offer_packet == NULL)
-                return ERROR;
-
         /* process all DHCP options present in the packet */
-        for (x = 4; x < MAX_DHCP_OPTIONS_LENGTH - 1;) {
+        for (int dchp_opt_idx = 4; dchp_opt_idx < MAX_DHCP_OPTIONS_LENGTH - 1;) {
 
-                if ((int)offer_packet->options[x] == -1)
+                if ((int)offer_packet->options[dchp_opt_idx] == -1) {
                         break;
+                }
 
                 /* get option type */
-                option_type = offer_packet->options[x++];
+                unsigned option_type = offer_packet->options[dchp_opt_idx++];
 
                 /* get option length */
-                option_length = offer_packet->options[x++];
+                unsigned option_length = offer_packet->options[dchp_opt_idx++];
 
-                if (verbose)
+                if (verbose) {
                         printf("Option: %d (0x%02X)\n", option_type, option_length);
+                }
 
                 /* get option data */
                 switch (option_type) {
                 case DHCP_OPTION_LEASE_TIME:
-                        memcpy(&dhcp_lease_time, &offer_packet->options[x], sizeof(dhcp_lease_time));
+                        memcpy(&dhcp_lease_time, &offer_packet->options[dchp_opt_idx], sizeof(dhcp_lease_time));
                         dhcp_lease_time = ntohl(dhcp_lease_time);
                         break;
                 case DHCP_OPTION_RENEWAL_TIME:
-                        memcpy(&dhcp_renewal_time, &offer_packet->options[x], sizeof(dhcp_renewal_time));
+                        memcpy(&dhcp_renewal_time, &offer_packet->options[dchp_opt_idx], sizeof(dhcp_renewal_time));
                         dhcp_renewal_time = ntohl(dhcp_renewal_time);
                         break;
                 case DHCP_OPTION_REBINDING_TIME:
-                        memcpy(&dhcp_rebinding_time, &offer_packet->options[x], sizeof(dhcp_rebinding_time));
+                        memcpy(&dhcp_rebinding_time, &offer_packet->options[dchp_opt_idx], sizeof(dhcp_rebinding_time));
                         dhcp_rebinding_time = ntohl(dhcp_rebinding_time);
                         break;
                 case DHCP_OPTION_SERVER_IDENTIFIER:
-                        memcpy(&serv_ident.s_addr, &offer_packet->options[x], sizeof(serv_ident.s_addr));
+                        memcpy(&serv_ident.s_addr, &offer_packet->options[dchp_opt_idx], sizeof(serv_ident.s_addr));
                         break;
                 }
 
                 /* skip option data we're ignoring */
-                if (option_type == 0) /* "pad" option, see RFC 2132 (3.1) */
-                        x += 1;
-                else
-                        x += option_length;
+                if (option_type == 0) { /* "pad" option, see RFC 2132 (3.1) */
+                        dchp_opt_idx += 1;
+                } else {
+                        dchp_opt_idx += option_length;
+                }
         }
 
         if (verbose) {
-                if (dhcp_lease_time == DHCP_INFINITE_TIME)
+                if (dhcp_lease_time == DHCP_INFINITE_TIME) {
                         printf(_("Lease Time: Infinite\n"));
-                else
+                } else {
                         printf(_("Lease Time: %lu seconds\n"), (unsigned long)dhcp_lease_time);
-                if (dhcp_renewal_time == DHCP_INFINITE_TIME)
+                }
+                if (dhcp_renewal_time == DHCP_INFINITE_TIME) {
                         printf(_("Renewal Time: Infinite\n"));
-                else
+                } else {
                         printf(_("Renewal Time: %lu seconds\n"), (unsigned long)dhcp_renewal_time);
-                if (dhcp_rebinding_time == DHCP_INFINITE_TIME)
+                }
+                if (dhcp_rebinding_time == DHCP_INFINITE_TIME) {
                         printf(_("Rebinding Time: Infinite\n"));
+                }
                 printf(_("Rebinding Time: %lu seconds\n"), (unsigned long)dhcp_rebinding_time);
         }
 
         new_offer = (dhcp_offer *)malloc(sizeof(dhcp_offer));
 
-        if (new_offer == NULL)
-                return ERROR;
+        if (new_offer == NULL) {
+                add_dhcp_offer_wrapper tmp = {
+                        .error = ERROR,
+                };
+                return tmp;
+        }
 
         /*
          * RFC 2131 (2.) says: "DHCP clarifies the interpretation of the
@@ -874,15 +933,18 @@ static int add_dhcp_offer(struct in_addr source, dhcp_packet *offer_packet) {
         new_offer->next = dhcp_offer_list;
         dhcp_offer_list = new_offer;
 
-        return OK;
+        add_dhcp_offer_wrapper result = {
+                .error = OK,
+                .dhcp_offer_list = dhcp_offer_list,
+        };
+
+        return result;
 }
 
 /* frees memory allocated to DHCP OFFER list */
-static int free_dhcp_offer_list(void) {
-        dhcp_offer *this_offer;
+int free_dhcp_offer_list(dhcp_offer *dhcp_offer_list) {
         dhcp_offer *next_offer;
-
-        for (this_offer = dhcp_offer_list; this_offer != NULL; this_offer = next_offer) {
+        for (dhcp_offer *this_offer = dhcp_offer_list; this_offer != NULL; this_offer = next_offer) {
                 next_offer = this_offer->next;
                 free(this_offer);
         }
@@ -891,11 +953,9 @@ static int free_dhcp_offer_list(void) {
 }
 
 /* frees memory allocated to requested server list */
-static int free_requested_server_list(void) {
-        requested_server *this_server;
+int free_requested_server_list(requested_server *requested_server_list) {
         requested_server *next_server;
-
-        for (this_server = requested_server_list; this_server != NULL; this_server = next_server) {
+        for (requested_server *this_server = requested_server_list; this_server != NULL; this_server = next_server) {
                 next_server = this_server->next;
                 free(this_server);
         }
@@ -904,39 +964,60 @@ static int free_requested_server_list(void) {
 }
 
 /* gets state and plugin output to return */
-static int get_results(void) {
-        dhcp_offer *temp_offer, *undesired_offer = NULL;
-        requested_server *temp_server;
-        int result;
-        uint32_t max_lease_time = 0;
+mp_subcheck get_results(bool exclusive, const int requested_servers, const struct in_addr requested_address, bool request_specific_address,
+                                                requested_server *requested_server_list, int valid_responses, dhcp_offer *dhcp_offer_list) {
+        mp_subcheck sc_dhcp_results = mp_subcheck_init();
+        sc_dhcp_results = mp_set_subcheck_default_state(sc_dhcp_results, STATE_OK);
 
-        received_requested_address = false;
-
-        /* checks responses from requested servers */
-        requested_responses = 0;
-        if (requested_servers > 0) {
+        /* we didn't receive any DHCPOFFERs */
+        if (dhcp_offer_list == NULL) {
+                sc_dhcp_results = mp_set_subcheck_state(sc_dhcp_results, STATE_CRITICAL);
+                xasprintf(&sc_dhcp_results.output, "%s", "No DHCPOFFERs were received");
+                return sc_dhcp_results;
+        }
 
-                for (temp_server = requested_server_list; temp_server != NULL; temp_server = temp_server->next) {
+        if (valid_responses == 0) {
+                // No valid responses at all, so early exit here
+                sc_dhcp_results = mp_set_subcheck_state(sc_dhcp_results, STATE_CRITICAL);
+                xasprintf(&sc_dhcp_results.output, "No valid responses received");
+                return sc_dhcp_results;
+        }
 
-                        for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
+        if (valid_responses == 1) {
+                xasprintf(&sc_dhcp_results.output, "Received %d DHCPOFFER", valid_responses);
+        } else {
+                xasprintf(&sc_dhcp_results.output, "Received %d DHCPOFFERs", valid_responses);
+        }
 
+        bool received_requested_address = false;
+        dhcp_offer *undesired_offer = NULL;
+        uint32_t max_lease_time = 0;
+        /* checks responses from requested servers */
+        int requested_responses = 0;
+        if (requested_servers > 0) {
+                for (requested_server *temp_server = requested_server_list; temp_server != NULL; temp_server = temp_server->next) {
+                        for (dhcp_offer *temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
                                 /* get max lease time we were offered */
-                                if (temp_offer->lease_time > max_lease_time || temp_offer->lease_time == DHCP_INFINITE_TIME)
+                                if (temp_offer->lease_time > max_lease_time || temp_offer->lease_time == DHCP_INFINITE_TIME) {
                                         max_lease_time = temp_offer->lease_time;
+                                }
 
                                 /* see if we got the address we requested */
-                                if (!memcmp(&requested_address, &temp_offer->offered_address, sizeof(requested_address)))
+                                if (!memcmp(&requested_address, &temp_offer->offered_address, sizeof(requested_address))) {
                                         received_requested_address = true;
+                                }
 
-                                /* see if the servers we wanted a response from talked to us or not */
+                                /* see if the servers we wanted a response from, talked to us or not */
                                 if (!memcmp(&temp_offer->server_address, &temp_server->server_address, sizeof(temp_server->server_address))) {
                                         if (verbose) {
                                                 printf(_("DHCP Server Match: Offerer=%s"), inet_ntoa(temp_offer->server_address));
                                                 printf(_(" Requested=%s"), inet_ntoa(temp_server->server_address));
-                                                if (temp_server->answered)
+                                                if (temp_server->answered) {
                                                         printf(_(" (duplicate)"));
+                                                }
                                                 printf(_("\n"));
                                         }
+
                                         if (!temp_server->answered) {
                                                 requested_responses++;
                                                 temp_server->answered = true;
@@ -947,94 +1028,115 @@ static int get_results(void) {
                 }
 
                 /* exclusive mode: check for undesired offers */
-                for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
+                for (dhcp_offer *temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
                         if (!temp_offer->desired) {
                                 undesired_offer = temp_offer; /* Checks only for the first undesired offer */
                                 break;                        /* no further checks needed */
                         }
                 }
-        }
 
-        /* else check and see if we got our requested address from any server */
-        else {
+                mp_subcheck sc_rqust_srvs = mp_subcheck_init();
+                xasprintf(&sc_rqust_srvs.output, "%d of %d requested servers responded", requested_responses, requested_servers);
 
-                for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
+                if (requested_responses == requested_servers) {
+                        sc_rqust_srvs = mp_set_subcheck_state(sc_rqust_srvs, STATE_OK);
+                } else if (requested_responses == 0) {
+                        sc_rqust_srvs = mp_set_subcheck_state(sc_rqust_srvs, STATE_CRITICAL);
+                } else if (requested_responses < requested_servers) {
+                        sc_rqust_srvs = mp_set_subcheck_state(sc_rqust_srvs, STATE_WARNING);
+                } else {
+                        // We received more(!) responses than we asked for?
+                        // This case shouldn't happen, but is here for completion
+                        sc_rqust_srvs = mp_set_subcheck_state(sc_rqust_srvs, STATE_WARNING);
+                }
+                mp_add_subcheck_to_subcheck(&sc_dhcp_results, sc_rqust_srvs);
 
+        } else {
+                /* else check and see if we got our requested address from any server */
+                for (dhcp_offer *temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
                         /* get max lease time we were offered */
-                        if (temp_offer->lease_time > max_lease_time || temp_offer->lease_time == DHCP_INFINITE_TIME)
+                        if (temp_offer->lease_time > max_lease_time || temp_offer->lease_time == DHCP_INFINITE_TIME) {
                                 max_lease_time = temp_offer->lease_time;
+                        }
 
                         /* see if we got the address we requested */
-                        if (!memcmp(&requested_address, &temp_offer->offered_address, sizeof(requested_address)))
+                        if (!memcmp(&requested_address, &temp_offer->offered_address, sizeof(requested_address))) {
                                 received_requested_address = true;
+                        }
                 }
         }
 
-        result = STATE_OK;
-        if (valid_responses == 0)
-                result = STATE_CRITICAL;
-        else if (requested_servers > 0 && requested_responses == 0)
-                result = STATE_CRITICAL;
-        else if (requested_responses < requested_servers)
-                result = STATE_WARNING;
-        else if (request_specific_address && !received_requested_address)
-                result = STATE_WARNING;
-
-        if (exclusive && undesired_offer)
-                result = STATE_CRITICAL;
-
-        if (result == 0) /* garrett honeycutt 2005 */
-                printf("OK: ");
-        else if (result == 1)
-                printf("WARNING: ");
-        else if (result == 2)
-                printf("CRITICAL: ");
-        else if (result == 3)
-                printf("UNKNOWN: ");
-
-        /* we didn't receive any DHCPOFFERs */
-        if (dhcp_offer_list == NULL) {
-                printf(_("No DHCPOFFERs were received.\n"));
-                return result;
+        if (max_lease_time == DHCP_INFINITE_TIME) {
+                xasprintf(&sc_dhcp_results.output, "%s, max lease time = Infinity", sc_dhcp_results.output);
+        } else {
+                xasprintf(&sc_dhcp_results.output, "%s, max lease time = %" PRIu32 " seconds", sc_dhcp_results.output, max_lease_time);
         }
 
-        printf(_("Received %d DHCPOFFER(s)"), valid_responses);
+        if (exclusive) {
+                mp_subcheck sc_rogue_server = mp_subcheck_init();
 
-        if (exclusive && undesired_offer) {
-                printf(_(", Rogue DHCP Server detected! Server %s"), inet_ntoa(undesired_offer->server_address));
-                printf(_(" offered %s \n"), inet_ntoa(undesired_offer->offered_address));
-                return result;
-        }
+                if (undesired_offer != NULL) {
+                        // We wanted to get a DHCPOFFER exclusively from one machine, but another one
+                        // sent one (too)
+                        sc_rogue_server = mp_set_subcheck_state(sc_rogue_server, STATE_CRITICAL);
 
-        if (requested_servers > 0)
-                printf(_(", %s%d of %d requested servers responded"), ((requested_responses < requested_servers) && requested_responses > 0) ? "only " : "", requested_responses,
-                           requested_servers);
+                        // Get the addresses for printout
+                        // 1.address of the sending server
+                        char server_address[INET_ADDRSTRLEN];
+                        const char *server_address_transformed =
+                                inet_ntop(AF_INET, &undesired_offer->server_address, server_address, sizeof(server_address));
 
-        if (request_specific_address)
-                printf(_(", requested address (%s) was %soffered"), inet_ntoa(requested_address), (received_requested_address) ? "" : _("not "));
+                        if (server_address != server_address_transformed) {
+                                die(STATE_UNKNOWN, "inet_ntop failed");
+                        }
 
-        printf(_(", max lease time = "));
-        if (max_lease_time == DHCP_INFINITE_TIME)
-                printf(_("Infinity"));
-        else
-                printf("%lu sec", (unsigned long)max_lease_time);
+                        // 2.address offered
+                        char offered_address[INET_ADDRSTRLEN];
+                        const char *offered_address_transformed =
+                                inet_ntop(AF_INET, &undesired_offer->offered_address, offered_address, sizeof(offered_address));
 
-        printf(".\n");
+                        if (offered_address != offered_address_transformed) {
+                                die(STATE_UNKNOWN, "inet_ntop failed");
+                        }
 
-        return result;
+                        xasprintf(&sc_rogue_server.output, "Rogue DHCP Server detected! Server %s offered %s", server_address, offered_address);
+                } else {
+                        sc_rogue_server = mp_set_subcheck_state(sc_rogue_server, STATE_OK);
+                        xasprintf(&sc_rogue_server.output, "No Rogue DHCP Server detected");
+                }
+                mp_add_subcheck_to_subcheck(&sc_dhcp_results, sc_rogue_server);
+        }
+
+        if (request_specific_address) {
+                mp_subcheck sc_rqustd_addr = mp_subcheck_init();
+
+                if (received_requested_address) {
+                        sc_rqustd_addr = mp_set_subcheck_state(sc_rqustd_addr, STATE_OK);
+                        xasprintf(&sc_rqustd_addr.output, "Requested address (%s) was offered", inet_ntoa(requested_address));
+                } else {
+                        sc_rqustd_addr = mp_set_subcheck_state(sc_rqustd_addr, STATE_WARNING);
+                        xasprintf(&sc_rqustd_addr.output, "Requested address (%s) was NOT offered", inet_ntoa(requested_address));
+                }
+
+                mp_add_subcheck_to_subcheck(&sc_dhcp_results, sc_rqustd_addr);
+        }
+
+        return sc_dhcp_results;
 }
 
 /* process command-line arguments */
-static int process_arguments(int argc, char **argv) {
-        if (argc < 1)
-                return ERROR;
+process_arguments_wrapper process_arguments(int argc, char **argv) {
+        if (argc < 1) {
+                process_arguments_wrapper tmp = {
+                        .error = ERROR,
+                };
+                return tmp;
+        }
 
-        call_getopt(argc, argv);
-        return validate_arguments(argc);
-}
+        enum {
+                output_format_index = CHAR_MAX + 1,
+        };
 
-static int call_getopt(int argc, char **argv) {
-        extern int optind;
         int option_index = 0;
         static struct option long_options[] = {{"serverip", required_argument, 0, 's'},
                                                                                    {"requestedip", required_argument, 0, 'r'},
@@ -1046,61 +1148,55 @@ static int call_getopt(int argc, char **argv) {
                                                                                    {"verbose", no_argument, 0, 'v'},
                                                                                    {"version", no_argument, 0, 'V'},
                                                                                    {"help", no_argument, 0, 'h'},
+                                                                                   {"output-format", required_argument, 0, output_format_index},
                                                                                    {0, 0, 0, 0}};
 
-        int c = 0;
+        check_dhcp_config config = check_dhcp_config_init();
+        int option_char = 0;
         while (true) {
-                c = getopt_long(argc, argv, "+hVvxt:s:r:t:i:m:u", long_options, &option_index);
+                option_char = getopt_long(argc, argv, "+hVvxt:s:r:t:i:m:u", long_options, &option_index);
 
-                if (c == -1 || c == EOF || c == 1)
+                if (option_char == -1 || option_char == EOF || option_char == 1) {
                         break;
+                }
 
-                switch (c) {
-
+                switch (option_char) {
                 case 's': /* DHCP server address */
-                        resolve_host(optarg, &dhcp_ip);
-                        add_requested_server(dhcp_ip);
+                        resolve_host(optarg, &config.dhcp_ip);
+                        add_requested_server(config.dhcp_ip, &config.num_of_requested_servers, &config.requested_server_list);
                         break;
 
                 case 'r': /* address we are requested from DHCP servers */
-                        resolve_host(optarg, &requested_address);
-                        request_specific_address = true;
+                        resolve_host(optarg, &config.requested_address);
+                        config.request_specific_address = true;
                         break;
 
                 case 't': /* timeout */
-
-                        /*
-                                 if(is_intnonneg(optarg))
-                                 */
-                        if (atoi(optarg) > 0)
-                                dhcpoffer_timeout = atoi(optarg);
-                        /*
-                                 else
-                                 usage("Time interval must be a nonnegative integer\n");
-                                 */
+                        if (atoi(optarg) > 0) {
+                                config.dhcpoffer_timeout = atoi(optarg);
+                        }
                         break;
 
                 case 'm': /* MAC address */
-
-                        if ((user_specified_mac = mac_aton(optarg)) == NULL)
+                        if ((config.user_specified_mac = mac_aton(optarg)) == NULL) {
                                 usage("Cannot parse MAC address.\n");
-                        if (verbose)
-                                print_hardware_address(user_specified_mac);
-
+                        }
+                        if (verbose) {
+                                print_hardware_address(config.user_specified_mac);
+                        }
                         break;
 
                 case 'i': /* interface name */
-
-                        strncpy(network_interface_name, optarg, sizeof(network_interface_name) - 1);
-                        network_interface_name[sizeof(network_interface_name) - 1] = '\x0';
-
+                        strncpy(config.network_interface_name, optarg, sizeof(config.network_interface_name) - 1);
+                        config.network_interface_name[sizeof(config.network_interface_name) - 1] = '\x0';
                         break;
 
                 case 'u': /* unicast testing */
-                        unicast = true;
+                        config.unicast_mode = true;
                         break;
+
                 case 'x': /* exclusive testing aka "rogue DHCP server detection" */
-                        exclusive = true;
+                        config.exclusive_mode = true;
                         break;
 
                 case 'V': /* version */
@@ -1114,6 +1210,18 @@ static int call_getopt(int argc, char **argv) {
                 case 'v': /* verbose */
                         verbose = 1;
                         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_is_set = true;
+                        config.output_format = parser.output_format;
+                        break;
+                }
                 case '?': /* help */
                         usage5();
                         break;
@@ -1122,15 +1230,16 @@ static int call_getopt(int argc, char **argv) {
                         break;
                 }
         }
-        return optind;
-}
 
-static int validate_arguments(int argc) {
-
-        if (argc - optind > 0)
+        if (argc - optind > 0) {
                 usage(_("Got unexpected non-option argument"));
+        }
 
-        return OK;
+        process_arguments_wrapper result = {
+                .config = config,
+                .error = OK,
+        };
+        return result;
 }
 
 #if defined(__sun__) || defined(__solaris__) || defined(__hpux__)
@@ -1249,7 +1358,7 @@ static int dl_bind(int fd, int sap, u_char *addr) {
  *
  ***********************************************************************/
 
-static long mac_addr_dlpi(const char *dev, int unit, u_char *addr) {
+long mac_addr_dlpi(const char *dev, int unit, u_char *addr) {
         int fd;
         u_char mac_addr[25];
 
@@ -1268,51 +1377,53 @@ static long mac_addr_dlpi(const char *dev, int unit, u_char *addr) {
 #endif
 
 /* resolve host name or die (TODO: move this to netutils.c!) */
-static void resolve_host(const char *in, struct in_addr *out) {
-        struct addrinfo hints, *ai;
+void resolve_host(const char *name, struct in_addr *out) {
+        struct addrinfo hints = {
+                .ai_family = PF_INET,
+        };
+        struct addrinfo *addr_info;
 
-        memset(&hints, 0, sizeof(hints));
-        hints.ai_family = PF_INET;
-        if (getaddrinfo(in, NULL, &hints, &ai) != 0)
+        if (getaddrinfo(name, NULL, &hints, &addr_info) != 0) {
                 usage_va(_("Invalid hostname/address - %s"), optarg);
+        }
 
-        memcpy(out, &((struct sockaddr_in *)ai->ai_addr)->sin_addr, sizeof(*out));
-        freeaddrinfo(ai);
+        memcpy(out, &((struct sockaddr_in *)addr_info->ai_addr)->sin_addr, sizeof(*out));
+        freeaddrinfo(addr_info);
 }
 
 /* parse MAC address string, return 6 bytes (unterminated) or NULL */
-static unsigned char *mac_aton(const char *string) {
-        static unsigned char result[6];
+unsigned char *mac_aton(const char *string) {
+        static unsigned char result[MAC_ADDR_LEN];
         char tmp[3];
-        unsigned i, j;
+        unsigned byte_counter = 0;
 
-        for (i = 0, j = 0; string[i] != '\0' && j < sizeof(result); i++) {
+        for (int i = 0; string[i] != '\0' && byte_counter < sizeof(result); i++) {
                 /* ignore ':' and any other non-hex character */
-                if (!isxdigit(string[i]) || !isxdigit(string[i + 1]))
+                if (!isxdigit(string[i]) || !isxdigit(string[i + 1])) {
                         continue;
+                }
                 tmp[0] = string[i];
                 tmp[1] = string[i + 1];
                 tmp[2] = '\0';
-                result[j] = strtol(tmp, (char **)NULL, 16);
+                result[byte_counter] = strtol(tmp, (char **)NULL, 16);
                 i++;
-                j++;
+                byte_counter++;
         }
 
-        return (j == 6) ? result : NULL;
+        return (byte_counter == MAC_ADDR_LEN) ? result : NULL;
 }
 
-static void print_hardware_address(const unsigned char *address) {
-        int i;
+void print_hardware_address(const unsigned char *address) {
 
         printf(_("Hardware address: "));
-        for (i = 0; i < 5; i++)
-                printf("%2.2x:", address[i]);
-        printf("%2.2x", address[i]);
+        for (int addr_idx = 0; addr_idx < MAC_ADDR_LEN; addr_idx++) {
+                printf("%2.2x:", address[addr_idx]);
+        }
         putchar('\n');
 }
 
 /* print usage help */
-static void print_help(void) {
+void print_help(void) {
 
         print_revision(progname, NP_VERSION);
 
@@ -1328,6 +1439,7 @@ static void print_help(void) {
         printf(UT_HELP_VRSN);
         printf(UT_EXTRA_OPTS);
 
+        printf(UT_OUTPUT_FORMAT);
         printf(UT_VERBOSE);
 
         printf(" %s\n", "-s, --serverip=IPADDRESS");
@@ -1346,7 +1458,6 @@ static void print_help(void) {
         printf("    %s\n", _("Only requested DHCP server may response (rogue DHCP server detection), requires -s"));
 
         printf(UT_SUPPORT);
-        return;
 }
 
 void print_usage(void) {
@@ -1354,6 +1465,4 @@ void print_usage(void) {
         printf("%s\n", _("Usage:"));
         printf(" %s [-v] [-u] [-x] [-s serverip] [-r requestedip] [-t timeout]\n", progname);
         printf("                  [-i interface] [-m mac]\n");
-
-        return;
 }
diff --git a/plugins-root/check_dhcp.d/config.h b/plugins-root/check_dhcp.d/config.h
new file mode 100644
index 00000000..f189068b
--- /dev/null
+++ b/plugins-root/check_dhcp.d/config.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "../../config.h"
+#include "../lib/states.h"
+#include <stdbool.h>
+#include <netinet/in.h>
+#include "net/if.h"
+#include "output.h"
+
+typedef struct requested_server_struct {
+        struct in_addr server_address;
+        bool answered;
+        struct requested_server_struct *next;
+} requested_server;
+
+typedef struct check_dhcp_config {
+        bool unicast_mode;   /* unicast mode: mimic a DHCP relay */
+        bool exclusive_mode; /* exclusive mode aka "rogue DHCP server detection" */
+        int num_of_requested_servers;
+        struct in_addr dhcp_ip; /* server to query (if in unicast mode) */
+        struct in_addr requested_address;
+        bool request_specific_address;
+
+        int dhcpoffer_timeout;
+        unsigned char *user_specified_mac;
+        char network_interface_name[IFNAMSIZ];
+        requested_server *requested_server_list;
+
+        mp_output_format output_format;
+        bool output_format_is_set;
+} check_dhcp_config;
+
+check_dhcp_config check_dhcp_config_init(void) {
+        check_dhcp_config tmp = {
+                .unicast_mode = false,
+                .exclusive_mode = false,
+                .num_of_requested_servers = 0,
+                .dhcp_ip = {0},
+                .requested_address = {0},
+                .request_specific_address = false,
+
+                .dhcpoffer_timeout = 2,
+                .user_specified_mac = NULL,
+                .network_interface_name = "eth0",
+                .requested_server_list = NULL,
+
+                .output_format_is_set = false,
+        };
+        return tmp;
+}
diff --git a/plugins-root/check_icmp.c b/plugins-root/check_icmp.c
index dcaceddb..d46d2ccc 100644
--- a/plugins-root/check_icmp.c
+++ b/plugins-root/check_icmp.c
@@ -46,6 +46,8 @@ const char *email = "devel@monitoring-plugins.org";
 #include "../plugins/common.h"
 #include "netutils.h"
 #include "utils.h"
+#include "output.h"
+#include "perfdata.h"
 
 #if HAVE_SYS_SOCKIO_H
 #       include <sys/sockio.h>
@@ -65,6 +67,17 @@ const char *email = "devel@monitoring-plugins.org";
 #include <netinet/icmp6.h>
 #include <arpa/inet.h>
 #include <math.h>
+#include <netdb.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/socket.h>
+#include <assert.h>
+#include <sys/select.h>
+
+#include "../lib/states.h"
+#include "./check_icmp.d/config.h"
+#include "./check_icmp.d/check_icmp_helpers.h"
 
 /** sometimes undefined system macros (quite a few, actually) **/
 #ifndef MAXTTL
@@ -96,56 +109,8 @@ const char *email = "devel@monitoring-plugins.org";
 #       define ICMP_UNREACH_PRECEDENCE_CUTOFF 15
 #endif
 
-typedef unsigned short range_t; /* type for get_range() -- unimplemented */
-
-typedef struct rta_host {
-        unsigned short id;                            /* id in **table, and icmp pkts */
-        char *name;                                   /* arg used for adding this host */
-        char *msg;                                    /* icmp error message, if any */
-        struct sockaddr_storage saddr_in;             /* the address of this host */
-        struct sockaddr_storage error_addr;           /* stores address of error replies */
-        unsigned long long time_waited;               /* total time waited, in usecs */
-        unsigned int icmp_sent, icmp_recv, icmp_lost; /* counters */
-        unsigned char icmp_type, icmp_code;           /* type and code from errors */
-        unsigned short flags;                         /* control/status flags */
-        double rta;                                   /* measured RTA */
-        int rta_status;                               // check result for RTA checks
-        double rtmax;                                 /* max rtt */
-        double rtmin;                                 /* min rtt */
-        double jitter;                                /* measured jitter */
-        int jitter_status;                            // check result for Jitter checks
-        double jitter_max;                            /* jitter rtt maximum */
-        double jitter_min;                            /* jitter rtt minimum */
-        double EffectiveLatency;
-        double mos;       /* Mean opnion score */
-        int mos_status;   // check result for MOS checks
-        double score;     /* score */
-        int score_status; // check result for score checks
-        u_int last_tdiff;
-        u_int last_icmp_seq;   /* Last ICMP_SEQ to check out of order pkts */
-        unsigned char pl;      /* measured packet loss */
-        int pl_status;         // check result for packet loss checks
-        struct rta_host *next; /* linked list */
-        int order_status;      // check result for packet order checks
-} rta_host;
-
 #define FLAG_LOST_CAUSE 0x01 /* decidedly dead target. */
 
-/* threshold structure. all values are maximum allowed, exclusive */
-typedef struct threshold {
-        unsigned char pl; /* max allowed packet loss in percent */
-        unsigned int rta; /* roundtrip time average, microseconds */
-        double jitter;    /* jitter time average, microseconds */
-        double mos;       /* MOS */
-        double score;     /* Score */
-} threshold;
-
-/* the data structure */
-typedef struct icmp_ping_data {
-        struct timeval stime; /* timestamp (saved in protocol struct as well) */
-        unsigned short ping_id;
-} icmp_ping_data;
-
 typedef union ip_hdr {
         struct ip ip;
         struct ip6_hdr ip6;
@@ -158,24 +123,6 @@ typedef union icmp_packet {
         u_short *cksum_in;
 } icmp_packet;
 
-/* the different modes of this program are as follows:
- * MODE_RTA: send all packets no matter what (mimic check_icmp and check_ping)
- * MODE_HOSTCHECK: Return immediately upon any sign of life
- *                 In addition, sends packets to ALL addresses assigned
- *                 to this host (as returned by gethostbyname() or
- *                 gethostbyaddr() and expects one host only to be checked at
- *                 a time.  Therefore, any packet response what so ever will
- *                 count as a sign of life, even when received outside
- *                 crit.rta limit. Do not misspell any additional IP's.
- * MODE_ALL:  Requires packets from ALL requested IP to return OK (default).
- * MODE_ICMP: implement something similar to check_icmp (MODE_RTA without
- *            tcp and udp args does this)
- */
-#define MODE_RTA       0
-#define MODE_HOSTCHECK 1
-#define MODE_ALL       2
-#define MODE_ICMP      3
-
 enum enum_threshold_mode {
         const_rta_mode,
         const_packet_loss_mode,
@@ -186,89 +133,487 @@ enum enum_threshold_mode {
 
 typedef enum enum_threshold_mode threshold_mode;
 
-/* the different ping types we can do
- * TODO: investigate ARP ping as well */
-#define HAVE_ICMP 1
-#define HAVE_UDP  2
-#define HAVE_TCP  4
-#define HAVE_ARP  8
-
-#define MIN_PING_DATA_SIZE     sizeof(struct icmp_ping_data)
-#define MAX_IP_PKT_SIZE        65536 /* (theoretical) max IP packet size */
-#define IP_HDR_SIZE            20
-#define MAX_PING_DATA          (MAX_IP_PKT_SIZE - IP_HDR_SIZE - ICMP_MINLEN)
-#define DEFAULT_PING_DATA_SIZE (MIN_PING_DATA_SIZE + 44)
-
-/* various target states */
-#define TSTATE_INACTIVE 0x01 /* don't ping this host anymore */
-#define TSTATE_WAITING  0x02 /* unanswered packets on the wire */
-#define TSTATE_ALIVE    0x04 /* target is alive (has answered something) */
-#define TSTATE_UNREACH  0x08
-
 /** prototypes **/
-void print_help(void);
+void print_help();
 void print_usage(void);
-static u_int get_timevar(const char *);
-static u_int get_timevaldiff(struct timeval *, struct timeval *);
-static in_addr_t get_ip_address(const char *);
-static int wait_for_reply(int, u_int);
-static int recvfrom_wto(int, void *, unsigned int, struct sockaddr *, u_int *, struct timeval *);
-static int send_icmp_ping(int, struct rta_host *);
-static int get_threshold(char *str, threshold *th);
-static bool get_threshold2(char *str, size_t length, threshold *, threshold *, threshold_mode mode);
-static bool parse_threshold2_helper(char *s, size_t length, threshold *thr, threshold_mode mode);
-static void run_checks(void);
-static void set_source_ip(char *);
-static int add_target(char *);
-static int add_target_ip(char *, struct sockaddr_storage *);
-static int handle_random_icmp(unsigned char *, struct sockaddr_storage *);
-static void parse_address(struct sockaddr_storage *, char *, int);
-static unsigned short icmp_checksum(uint16_t *, size_t);
-static void finish(int);
-static void crash(const char *, ...);
-
-/** external **/
-extern int optind;
-extern char *optarg;
-extern char **environ;
+
+/* Time related */
+typedef struct {
+        int error_code;
+        time_t time_range;
+} get_timevar_wrapper;
+static get_timevar_wrapper get_timevar(const char *str);
+static time_t get_timevaldiff(struct timeval earlier, struct timeval later);
+static time_t get_timevaldiff_to_now(struct timeval earlier);
+
+static in_addr_t get_ip_address(const char *ifname);
+static void set_source_ip(char *arg, int icmp_sock, sa_family_t addr_family);
+
+/* Receiving data */
+static int wait_for_reply(check_icmp_socket_set sockset, time_t time_interval,
+                                                  unsigned short icmp_pkt_size, time_t *target_interval, uint16_t sender_id,
+                                                  ping_target **table, unsigned short packets,
+                                                  unsigned short number_of_targets, check_icmp_state *program_state);
+
+typedef struct {
+        sa_family_t recv_proto;
+        ssize_t received;
+} recvfrom_wto_wrapper;
+static recvfrom_wto_wrapper recvfrom_wto(check_icmp_socket_set sockset, void *buf, unsigned int len,
+                                                                                 struct sockaddr *saddr, time_t *timeout,
+                                                                                 struct timeval *received_timestamp);
+static int handle_random_icmp(unsigned char *packet, struct sockaddr_storage *addr,
+                                                          time_t *target_interval, uint16_t sender_id, ping_target **table,
+                                                          unsigned short packets, unsigned short number_of_targets,
+                                                          check_icmp_state *program_state);
+
+/* Sending data */
+static int send_icmp_ping(check_icmp_socket_set sockset, ping_target *host,
+                                                  unsigned short icmp_pkt_size, uint16_t sender_id,
+                                                  check_icmp_state *program_state);
+
+/* Threshold related */
+typedef struct {
+        int errorcode;
+        check_icmp_threshold threshold;
+} get_threshold_wrapper;
+static get_threshold_wrapper get_threshold(char *str, check_icmp_threshold threshold);
+
+typedef struct {
+        int errorcode;
+        check_icmp_threshold warn;
+        check_icmp_threshold crit;
+} get_threshold2_wrapper;
+static get_threshold2_wrapper get_threshold2(char *str, size_t length, check_icmp_threshold warn,
+                                                                                         check_icmp_threshold crit, threshold_mode mode);
+
+typedef struct {
+        int errorcode;
+        check_icmp_threshold result;
+} parse_threshold2_helper_wrapper;
+static parse_threshold2_helper_wrapper parse_threshold2_helper(char *threshold_string,
+                                                                                                                           size_t length,
+                                                                                                                           check_icmp_threshold thr,
+                                                                                                                           threshold_mode mode);
+
+/* main test function */
+static void run_checks(unsigned short icmp_pkt_size, time_t *target_interval, uint16_t sender_id,
+                                           check_icmp_execution_mode mode, time_t max_completion_time,
+                                           struct timeval prog_start, ping_target **table, unsigned short packets,
+                                           check_icmp_socket_set sockset, unsigned short number_of_targets,
+                                           check_icmp_state *program_state);
+mp_subcheck evaluate_target(ping_target target, check_icmp_mode_switches modes,
+                                                        check_icmp_threshold warn, check_icmp_threshold crit);
+
+typedef struct {
+        int targets_ok;
+        int targets_warn;
+        mp_subcheck sc_host;
+} evaluate_host_wrapper;
+evaluate_host_wrapper evaluate_host(check_icmp_target_container host,
+                                                                        check_icmp_mode_switches modes, check_icmp_threshold warn,
+                                                                        check_icmp_threshold crit);
+
+/* Target acquisition */
+typedef struct {
+        int error_code;
+        check_icmp_target_container host;
+        bool has_v4;
+        bool has_v6;
+} add_host_wrapper;
+static add_host_wrapper add_host(char *arg, check_icmp_execution_mode mode,
+                                                                 sa_family_t enforced_proto);
+
+typedef struct {
+        int error_code;
+        ping_target *targets;
+        unsigned int number_of_targets;
+        bool has_v4;
+        bool has_v6;
+} add_target_wrapper;
+static add_target_wrapper add_target(char *arg, check_icmp_execution_mode mode,
+                                                                         sa_family_t enforced_proto);
+
+typedef struct {
+        int error_code;
+        ping_target *target;
+} add_target_ip_wrapper;
+static add_target_ip_wrapper add_target_ip(struct sockaddr_storage address);
+
+static void parse_address(const struct sockaddr_storage *addr, char *dst, socklen_t size);
+
+static unsigned short icmp_checksum(uint16_t *packet, size_t packet_size);
+
+/* End of run function */
+static void finish(int sign, check_icmp_mode_switches modes, int min_hosts_alive,
+                                   check_icmp_threshold warn, check_icmp_threshold crit,
+                                   unsigned short number_of_targets, check_icmp_state *program_state,
+                                   check_icmp_target_container host_list[], unsigned short number_of_hosts,
+                                   mp_check overall[static 1]);
+
+/* Error exit */
+static void crash(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 
 /** global variables **/
-static struct rta_host **table, *cursor, *list;
-
-static threshold crit = {.pl = 80, .rta = 500000, .jitter = 0.0, .mos = 0.0, .score = 0.0};
-static threshold warn = {.pl = 40, .rta = 200000, .jitter = 0.0, .mos = 0.0, .score = 0.0};
-
-static int mode, protocols, sockets, debug = 0, timeout = 10;
-static unsigned short icmp_data_size = DEFAULT_PING_DATA_SIZE;
-static unsigned short icmp_pkt_size = DEFAULT_PING_DATA_SIZE + ICMP_MINLEN;
-
-static unsigned int icmp_sent = 0, icmp_recv = 0, icmp_lost = 0, ttl = 0;
-#define icmp_pkts_en_route (icmp_sent - (icmp_recv + icmp_lost))
-static unsigned short targets_down = 0, targets = 0, packets = 0;
-#define targets_alive (targets - targets_down)
-static unsigned int retry_interval, pkt_interval, target_interval;
-static int icmp_sock, tcp_sock, udp_sock, status = STATE_OK;
-static pid_t pid;
-static struct timezone tz;
-static struct timeval prog_start;
-static unsigned long long max_completion_time = 0;
-static unsigned int warn_down = 1, crit_down = 1; /* host down threshold values */
-static int min_hosts_alive = -1;
-static float pkt_backoff_factor = 1.5;
-static float target_backoff_factor = 1.5;
-static bool rta_mode = false;
-static bool pl_mode = false;
-static bool jitter_mode = false;
-static bool score_mode = false;
-static bool mos_mode = false;
-static bool order_mode = false;
+static int debug = 0;
+
+extern unsigned int timeout;
+
+/** the working code **/
+static inline unsigned short targets_alive(unsigned short targets, unsigned short targets_down) {
+        return targets - targets_down;
+}
+static inline unsigned int icmp_pkts_en_route(unsigned int icmp_sent, unsigned int icmp_recv,
+                                                                                          unsigned int icmp_lost) {
+        return icmp_sent - (icmp_recv + icmp_lost);
+}
+
+// Create configuration from cli parameters
+typedef struct {
+        int errorcode;
+        check_icmp_config config;
+} check_icmp_config_wrapper;
+check_icmp_config_wrapper process_arguments(int argc, char **argv) {
+        /* get calling name the old-fashioned way for portability instead
+         * of relying on the glibc-ism __progname */
+        char *ptr = strrchr(argv[0], '/');
+        if (ptr) {
+                progname = &ptr[1];
+        } else {
+                progname = argv[0];
+        }
+
+        check_icmp_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_icmp_config_init(),
+        };
+
+        /* use the pid to mark packets as ours */
+        /* Some systems have 32-bit pid_t so mask off only 16 bits */
+        result.config.sender_id = getpid() & 0xffff;
+
+        if (!strcmp(progname, "check_icmp") || !strcmp(progname, "check_ping")) {
+                result.config.mode = MODE_ICMP;
+        } else if (!strcmp(progname, "check_host")) {
+                result.config.mode = MODE_HOSTCHECK;
+                result.config.number_of_packets = 5;
+                result.config.crit.rta = result.config.warn.rta = 1000000;
+                result.config.crit.pl = result.config.warn.pl = 100;
+        } else if (!strcmp(progname, "check_rta_multi")) {
+                result.config.mode = MODE_ALL;
+                result.config.target_interval = 0;
+                result.config.number_of_packets = 5;
+        }
+        /* support "--help" and "--version" */
+        if (argc == 2) {
+                if (!strcmp(argv[1], "--help")) {
+                        strcpy(argv[1], "-h");
+                }
+                if (!strcmp(argv[1], "--version")) {
+                        strcpy(argv[1], "-V");
+                }
+        }
+
+        sa_family_t enforced_ai_family = AF_UNSPEC;
+
+        enum {
+                output_format_index = CHAR_MAX + 1,
+        };
+
+        struct option longopts[] = {
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {"verbose", no_argument, 0, 'v'},
+                {"Host", required_argument, 0, 'H'},
+                {"ipv4-only", no_argument, 0, '4'},
+                {"ipv6-only", no_argument, 0, '6'},
+                {"warning", required_argument, 0, 'w'},
+                {"critical", required_argument, 0, 'c'},
+                {"rta-mode-thresholds", required_argument, 0, 'R'},
+                {"packet-loss-mode-thresholds", required_argument, 0, 'P'},
+                {"jitter-mode-thresholds", required_argument, 0, 'J'},
+                {"mos-mode-thresholds", required_argument, 0, 'M'},
+                {"score-mode-thresholds", required_argument, 0, 'S'},
+                {"out-of-order-packets", no_argument, 0, 'O'},
+                {"number-of-packets", required_argument, 0, 'n'},
+                {"number-of-packets", required_argument, 0, 'p'},
+                {"packet-interval", required_argument, 0, 'i'},
+                {"target-interval", required_argument, 0, 'I'},
+                {"minimal-host-alive", required_argument, 0, 'm'},
+                {"outgoing-ttl", required_argument, 0, 'l'},
+                {"size", required_argument, 0, 'b'},
+                {"output-format", required_argument, 0, output_format_index},
+                {},
+        };
+
+        // Parse protocol arguments first
+        // and count hosts here
+        char *opts_str = "vhVw:c:n:p:t:H:s:i:b:I:l:m:P:R:J:S:M:O64";
+        for (int i = 1; i < argc; i++) {
+                long int arg;
+                while ((arg = getopt_long(argc, argv, opts_str, longopts, NULL)) != EOF) {
+                        switch (arg) {
+
+                        case '4':
+                                if (enforced_ai_family != AF_UNSPEC) {
+                                        crash("Multiple protocol versions not supported");
+                                }
+                                enforced_ai_family = AF_INET;
+                                break;
+                        case '6':
+                                if (enforced_ai_family != AF_UNSPEC) {
+                                        crash("Multiple protocol versions not supported");
+                                }
+                                enforced_ai_family = AF_INET6;
+                                break;
+                        case 'H': {
+                                result.config.number_of_hosts++;
+                                break;
+                        }
+                        case 'h': /* help */
+                                // Trigger help here to avoid adding hosts before that (and doing DNS queries)
+                                print_help();
+                                exit(STATE_UNKNOWN);
+                                break;
+                        case 'v':
+                                debug++;
+                                break;
+                        }
+                }
+        }
+
+        char **tmp = &argv[optind];
+        while (*tmp) {
+                result.config.number_of_hosts++;
+                tmp++;
+        }
+
+        // Sanity check: if hostmode is selected,only a single host is allowed
+        if (result.config.mode == MODE_HOSTCHECK && result.config.number_of_hosts > 1) {
+                usage("check_host only allows a single host");
+        }
+
+        // Allocate hosts
+        result.config.hosts =
+                calloc(result.config.number_of_hosts, sizeof(check_icmp_target_container));
+        if (result.config.hosts == NULL) {
+                crash("failed to allocate memory");
+        }
+
+        /* Reset argument scanning */
+        optind = 1;
+
+        int host_counter = 0;
+        /* parse the arguments */
+        for (int i = 1; i < argc; i++) {
+                long int arg;
+                while ((arg = getopt_long(argc, argv, opts_str, longopts, NULL)) != EOF) {
+                        switch (arg) {
+                        case 'b': {
+                                long size = strtol(optarg, NULL, 0);
+                                if ((unsigned long)size >= (sizeof(struct icmp) + sizeof(struct icmp_ping_data)) &&
+                                        size < MAX_PING_DATA) {
+                                        result.config.icmp_data_size = (unsigned short)size;
+                                } else {
+                                        usage_va("ICMP data length must be between: %lu and %lu",
+                                                         sizeof(struct icmp) + sizeof(struct icmp_ping_data),
+                                                         MAX_PING_DATA - 1);
+                                }
+                        } break;
+                        case 'i': {
+                                // packet_interval was unused and is now removed
+                        } break;
+                        case 'I': {
+                                get_timevar_wrapper parsed_time = get_timevar(optarg);
+
+                                if (parsed_time.error_code == OK) {
+                                        result.config.target_interval = parsed_time.time_range;
+                                } else {
+                                        crash("failed to parse target interval");
+                                }
+                        } break;
+                        case 'w': {
+                                get_threshold_wrapper warn = get_threshold(optarg, result.config.warn);
+                                if (warn.errorcode == OK) {
+                                        result.config.warn = warn.threshold;
+                                } else {
+                                        crash("failed to parse warning threshold");
+                                }
+                        } break;
+                        case 'c': {
+                                get_threshold_wrapper crit = get_threshold(optarg, result.config.crit);
+                                if (crit.errorcode == OK) {
+                                        result.config.crit = crit.threshold;
+                                } else {
+                                        crash("failed to parse critical threshold");
+                                }
+                        } break;
+                        case 'n':
+                        case 'p':
+                                result.config.number_of_packets = (unsigned short)strtoul(optarg, NULL, 0);
+                                if (result.config.number_of_packets > 20) {
+                                        errno = 0;
+                                        crash("packets is > 20 (%d)", result.config.number_of_packets);
+                                }
+                                break;
+                        case 't':
+                                // WARNING Deprecated since execution time is determined by the other factors
+                                break;
+                        case 'H': {
+                                add_host_wrapper host_add_result =
+                                        add_host(optarg, result.config.mode, enforced_ai_family);
+                                if (host_add_result.error_code == OK) {
+                                        result.config.hosts[host_counter] = host_add_result.host;
+                                        host_counter++;
+
+                                        if (result.config.targets != NULL) {
+                                                result.config.number_of_targets += ping_target_list_append(
+                                                        result.config.targets, host_add_result.host.target_list);
+                                        } else {
+                                                result.config.targets = host_add_result.host.target_list;
+                                                result.config.number_of_targets += host_add_result.host.number_of_targets;
+                                        }
+
+                                        if (host_add_result.has_v4) {
+                                                result.config.need_v4 = true;
+                                        }
+                                        if (host_add_result.has_v6) {
+                                                result.config.need_v6 = true;
+                                        }
+                                } else {
+                                        crash("Failed to add host, unable to parse it correctly");
+                                }
+                        } break;
+                        case 'l':
+                                result.config.ttl = strtoul(optarg, NULL, 0);
+                                break;
+                        case 'm':
+                                result.config.min_hosts_alive = (int)strtoul(optarg, NULL, 0);
+                                break;
+                        case 's': /* specify source IP address */
+                                result.config.source_ip = optarg;
+                                break;
+                        case 'V': /* version */
+                                print_revision(progname, NP_VERSION);
+                                exit(STATE_UNKNOWN);
+                        case 'R': /* RTA mode */ {
+                                get_threshold2_wrapper rta_th = get_threshold2(
+                                        optarg, strlen(optarg), result.config.warn, result.config.crit, const_rta_mode);
+
+                                if (rta_th.errorcode != OK) {
+                                        crash("Failed to parse RTA threshold");
+                                }
+
+                                result.config.warn = rta_th.warn;
+                                result.config.crit = rta_th.crit;
+                                result.config.modes.rta_mode = true;
+                        } break;
+                        case 'P': /* packet loss mode */ {
+                                get_threshold2_wrapper pl_th =
+                                        get_threshold2(optarg, strlen(optarg), result.config.warn, result.config.crit,
+                                                                   const_packet_loss_mode);
+                                if (pl_th.errorcode != OK) {
+                                        crash("Failed to parse packet loss threshold");
+                                }
+
+                                result.config.warn = pl_th.warn;
+                                result.config.crit = pl_th.crit;
+                                result.config.modes.pl_mode = true;
+                        } break;
+                        case 'J': /* jitter mode */ {
+                                get_threshold2_wrapper jitter_th =
+                                        get_threshold2(optarg, strlen(optarg), result.config.warn, result.config.crit,
+                                                                   const_jitter_mode);
+                                if (jitter_th.errorcode != OK) {
+                                        crash("Failed to parse jitter threshold");
+                                }
+
+                                result.config.warn = jitter_th.warn;
+                                result.config.crit = jitter_th.crit;
+                                result.config.modes.jitter_mode = true;
+                        } break;
+                        case 'M': /* MOS mode */ {
+                                get_threshold2_wrapper mos_th = get_threshold2(
+                                        optarg, strlen(optarg), result.config.warn, result.config.crit, const_mos_mode);
+                                if (mos_th.errorcode != OK) {
+                                        crash("Failed to parse MOS threshold");
+                                }
+
+                                result.config.warn = mos_th.warn;
+                                result.config.crit = mos_th.crit;
+                                result.config.modes.mos_mode = true;
+                        } break;
+                        case 'S': /* score mode */ {
+                                get_threshold2_wrapper score_th =
+                                        get_threshold2(optarg, strlen(optarg), result.config.warn, result.config.crit,
+                                                                   const_score_mode);
+                                if (score_th.errorcode != OK) {
+                                        crash("Failed to parse score threshold");
+                                }
+
+                                result.config.warn = score_th.warn;
+                                result.config.crit = score_th.crit;
+                                result.config.modes.score_mode = true;
+                        } break;
+                        case 'O': /* out of order mode */
+                                result.config.modes.order_mode = true;
+                                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);
+                                }
+
+                                result.config.output_format_is_set = true;
+                                result.config.output_format = parser.output_format;
+                                break;
+                        }
+                        }
+                }
+        }
+
+        argv = &argv[optind];
+        while (*argv) {
+                add_target(*argv, result.config.mode, enforced_ai_family);
+                argv++;
+        }
+
+        if (!result.config.number_of_targets) {
+                errno = 0;
+                crash("No hosts to check");
+        }
+
+        /* stupid users should be able to give whatever thresholds they want
+         * (nothing will break if they do), but some anal plugin maintainer
+         * will probably add some printf() thing here later, so it might be
+         * best to at least show them where to do it. ;) */
+        if (result.config.warn.pl > result.config.crit.pl) {
+                result.config.warn.pl = result.config.crit.pl;
+        }
+        if (result.config.warn.rta > result.config.crit.rta) {
+                result.config.warn.rta = result.config.crit.rta;
+        }
+        if (result.config.warn.jitter > result.config.crit.jitter) {
+                result.config.crit.jitter = result.config.warn.jitter;
+        }
+        if (result.config.warn.mos < result.config.crit.mos) {
+                result.config.warn.mos = result.config.crit.mos;
+        }
+        if (result.config.warn.score < result.config.crit.score) {
+                result.config.warn.score = result.config.crit.score;
+        }
+
+        return result;
+}
 
 /** code start **/
 static void crash(const char *fmt, ...) {
-        va_list ap;
 
         printf("%s: ", progname);
 
+        va_list ap;
         va_start(ap, fmt);
         vprintf(fmt, ap);
         va_end(ap);
@@ -385,18 +730,20 @@ static const char *get_icmp_error_msg(unsigned char icmp_type, unsigned char icm
         return msg;
 }
 
-static int handle_random_icmp(unsigned char *packet, struct sockaddr_storage *addr) {
-        struct icmp p, sent_icmp;
-        struct rta_host *host = NULL;
-
-        memcpy(&p, packet, sizeof(p));
-        if (p.icmp_type == ICMP_ECHO && ntohs(p.icmp_id) == pid) {
+static int handle_random_icmp(unsigned char *packet, struct sockaddr_storage *addr,
+                                                          time_t *target_interval, const uint16_t sender_id,
+                                                          ping_target **table, unsigned short packets,
+                                                          const unsigned short number_of_targets,
+                                                          check_icmp_state *program_state) {
+        struct icmp icmp_packet;
+        memcpy(&icmp_packet, packet, sizeof(icmp_packet));
+        if (icmp_packet.icmp_type == ICMP_ECHO && ntohs(icmp_packet.icmp_id) == sender_id) {
                 /* echo request from us to us (pinging localhost) */
                 return 0;
         }
 
         if (debug) {
-                printf("handle_random_icmp(%p, %p)\n", (void *)&p, (void *)addr);
+                printf("handle_random_icmp(%p, %p)\n", (void *)&icmp_packet, (void *)addr);
         }
 
         /* only handle a few types, since others can't possibly be replies to
@@ -409,14 +756,17 @@ static int handle_random_icmp(unsigned char *packet, struct sockaddr_storage *ad
          * TIMXCEED actually sends a proper icmp response we will have passed
          * too many hops to have a hope of reaching it later, in which case it
          * indicates overconfidence in the network, poor routing or both. */
-        if (p.icmp_type != ICMP_UNREACH && p.icmp_type != ICMP_TIMXCEED && p.icmp_type != ICMP_SOURCEQUENCH && p.icmp_type != ICMP_PARAMPROB) {
+        if (icmp_packet.icmp_type != ICMP_UNREACH && icmp_packet.icmp_type != ICMP_TIMXCEED &&
+                icmp_packet.icmp_type != ICMP_SOURCEQUENCH && icmp_packet.icmp_type != ICMP_PARAMPROB) {
                 return 0;
         }
 
         /* might be for us. At least it holds the original package (according
          * to RFC 792). If it isn't, just ignore it */
+        struct icmp sent_icmp;
         memcpy(&sent_icmp, packet + 28, sizeof(sent_icmp));
-        if (sent_icmp.icmp_type != ICMP_ECHO || ntohs(sent_icmp.icmp_id) != pid || ntohs(sent_icmp.icmp_seq) >= targets * packets) {
+        if (sent_icmp.icmp_type != ICMP_ECHO || ntohs(sent_icmp.icmp_id) != sender_id ||
+                ntohs(sent_icmp.icmp_seq) >= number_of_targets * packets) {
                 if (debug) {
                         printf("Packet is no response to a packet we sent\n");
                 }
@@ -424,14 +774,15 @@ static int handle_random_icmp(unsigned char *packet, struct sockaddr_storage *ad
         }
 
         /* it is indeed a response for us */
-        host = table[ntohs(sent_icmp.icmp_seq) / packets];
+        ping_target *host = table[ntohs(sent_icmp.icmp_seq) / packets];
         if (debug) {
                 char address[INET6_ADDRSTRLEN];
                 parse_address(addr, address, sizeof(address));
-                printf("Received \"%s\" from %s for ICMP ECHO sent to %s.\n", get_icmp_error_msg(p.icmp_type, p.icmp_code), address, host->name);
+                printf("Received \"%s\" from %s for ICMP ECHO sent.\n",
+                           get_icmp_error_msg(icmp_packet.icmp_type, icmp_packet.icmp_code), address);
         }
 
-        icmp_lost++;
+        program_state->icmp_lost++;
         host->icmp_lost++;
         /* don't spend time on lost hosts any more */
         if (host->flags & FLAG_LOST_CAUSE) {
@@ -440,305 +791,104 @@ static int handle_random_icmp(unsigned char *packet, struct sockaddr_storage *ad
 
         /* source quench means we're sending too fast, so increase the
          * interval and mark this packet lost */
-        if (p.icmp_type == ICMP_SOURCEQUENCH) {
-                pkt_interval *= pkt_backoff_factor;
-                target_interval *= target_backoff_factor;
+        if (icmp_packet.icmp_type == ICMP_SOURCEQUENCH) {
+                *target_interval = (unsigned int)((double)*target_interval * TARGET_BACKOFF_FACTOR);
         } else {
-                targets_down++;
+                program_state->targets_down++;
                 host->flags |= FLAG_LOST_CAUSE;
         }
-        host->icmp_type = p.icmp_type;
-        host->icmp_code = p.icmp_code;
+        host->icmp_type = icmp_packet.icmp_type;
+        host->icmp_code = icmp_packet.icmp_code;
         host->error_addr = *addr;
 
         return 0;
 }
 
-void parse_address(struct sockaddr_storage *addr, char *address, int size) {
-        switch (address_family) {
+void parse_address(const struct sockaddr_storage *addr, char *dst, socklen_t size) {
+        switch (addr->ss_family) {
         case AF_INET:
-                inet_ntop(address_family, &((struct sockaddr_in *)addr)->sin_addr, address, size);
+                inet_ntop(AF_INET, &((struct sockaddr_in *)addr)->sin_addr, dst, size);
                 break;
         case AF_INET6:
-                inet_ntop(address_family, &((struct sockaddr_in6 *)addr)->sin6_addr, address, size);
+                inet_ntop(AF_INET6, &((struct sockaddr_in6 *)addr)->sin6_addr, dst, size);
                 break;
+        default:
+                assert(false);
         }
 }
 
 int main(int argc, char **argv) {
-        int i;
-        char *ptr;
-        long int arg;
-        int icmp_sockerrno, udp_sockerrno, tcp_sockerrno;
-        int result;
-        struct rta_host *host;
-#ifdef HAVE_SIGACTION
-        struct sigaction sig_action;
-#endif
-#ifdef SO_TIMESTAMP
-        int on = 1;
-#endif
-        char *source_ip = NULL;
-        char *opts_str = "vhVw:c:n:p:t:H:s:i:b:I:l:m:P:R:J:S:M:O64";
         setlocale(LC_ALL, "");
         bindtextdomain(PACKAGE, LOCALEDIR);
         textdomain(PACKAGE);
 
-        /* we only need to be setsuid when we get the sockets, so do
-         * that before pointer magic (esp. on network data) */
-        icmp_sockerrno = udp_sockerrno = tcp_sockerrno = sockets = 0;
-
-        address_family = -1;
-        int icmp_proto = IPPROTO_ICMP;
+        /* POSIXLY_CORRECT might break things, so unset it (the portable way) */
+        environ = NULL;
 
-        /* get calling name the old-fashioned way for portability instead
-         * of relying on the glibc-ism __progname */
-        ptr = strrchr(argv[0], '/');
-        if (ptr) {
-                progname = &ptr[1];
-        } else {
-                progname = argv[0];
-        }
+        /* Parse extra opts if any */
+        argv = np_extra_opts(&argc, argv, progname);
 
-        /* now set defaults. Use progname to set them initially (allows for
-         * superfast check_host program when target host is up */
-        cursor = list = NULL;
-        table = NULL;
-
-        mode = MODE_RTA;
-        /* Default critical thresholds */
-        crit.rta = 500000;
-        crit.pl = 80;
-        crit.jitter = 50;
-        crit.mos = 3;
-        crit.score = 70;
-        /* Default warning thresholds */
-        warn.rta = 200000;
-        warn.pl = 40;
-        warn.jitter = 40;
-        warn.mos = 3.5;
-        warn.score = 80;
-
-        protocols = HAVE_ICMP | HAVE_UDP | HAVE_TCP;
-        pkt_interval = 80000; /* 80 msec packet interval by default */
-        packets = 5;
+        check_icmp_config_wrapper tmp_config = process_arguments(argc, argv);
 
-        if (!strcmp(progname, "check_icmp") || !strcmp(progname, "check_ping")) {
-                mode = MODE_ICMP;
-                protocols = HAVE_ICMP;
-        } else if (!strcmp(progname, "check_host")) {
-                mode = MODE_HOSTCHECK;
-                pkt_interval = 1000000;
-                packets = 5;
-                crit.rta = warn.rta = 1000000;
-                crit.pl = warn.pl = 100;
-        } else if (!strcmp(progname, "check_rta_multi")) {
-                mode = MODE_ALL;
-                target_interval = 0;
-                pkt_interval = 50000;
-                packets = 5;
+        if (tmp_config.errorcode != OK) {
+                crash("failed to parse config");
         }
 
-        /* support "--help" and "--version" */
-        if (argc == 2) {
-                if (!strcmp(argv[1], "--help")) {
-                        strcpy(argv[1], "-h");
-                }
-                if (!strcmp(argv[1], "--version")) {
-                        strcpy(argv[1], "-V");
-                }
-        }
+        const check_icmp_config config = tmp_config.config;
 
-        /* Parse protocol arguments first */
-        for (i = 1; i < argc; i++) {
-                while ((arg = getopt(argc, argv, opts_str)) != EOF) {
-                        switch (arg) {
-                        case '4':
-                                if (address_family != -1) {
-                                        crash("Multiple protocol versions not supported");
-                                }
-                                address_family = AF_INET;
-                                break;
-                        case '6':
-#ifdef USE_IPV6
-                                if (address_family != -1) {
-                                        crash("Multiple protocol versions not supported");
-                                }
-                                address_family = AF_INET6;
-#else
-                                usage(_("IPv6 support not available\n"));
-#endif
-                                break;
-                        }
-                }
+        if (config.output_format_is_set) {
+                mp_set_format(config.output_format);
         }
 
-        /* Reset argument scanning */
-        optind = 1;
+        check_icmp_socket_set sockset = {
+                .socket4 = -1,
+                .socket6 = -1,
+        };
 
-        unsigned long size;
-        bool err;
-        /* parse the arguments */
-        for (i = 1; i < argc; i++) {
-                while ((arg = getopt(argc, argv, opts_str)) != EOF) {
-                        switch (arg) {
-                        case 'v':
-                                debug++;
-                                break;
-                        case 'b':
-                                size = strtol(optarg, NULL, 0);
-                                if (size >= (sizeof(struct icmp) + sizeof(struct icmp_ping_data)) && size < MAX_PING_DATA) {
-                                        icmp_data_size = size;
-                                        icmp_pkt_size = size + ICMP_MINLEN;
-                                } else {
-                                        usage_va("ICMP data length must be between: %lu and %lu", sizeof(struct icmp) + sizeof(struct icmp_ping_data),
-                                                         MAX_PING_DATA - 1);
-                                }
-                                break;
-                        case 'i':
-                                pkt_interval = get_timevar(optarg);
-                                break;
-                        case 'I':
-                                target_interval = get_timevar(optarg);
-                                break;
-                        case 'w':
-                                get_threshold(optarg, &warn);
-                                break;
-                        case 'c':
-                                get_threshold(optarg, &crit);
-                                break;
-                        case 'n':
-                        case 'p':
-                                packets = strtoul(optarg, NULL, 0);
-                                break;
-                        case 't':
-                                timeout = strtoul(optarg, NULL, 0);
-                                if (!timeout) {
-                                        timeout = 10;
-                                }
-                                break;
-                        case 'H':
-                                add_target(optarg);
-                                break;
-                        case 'l':
-                                ttl = (int)strtoul(optarg, NULL, 0);
-                                break;
-                        case 'm':
-                                min_hosts_alive = (int)strtoul(optarg, NULL, 0);
-                                break;
-                        case 'd': /* implement later, for cluster checks */
-                                warn_down = (unsigned char)strtoul(optarg, &ptr, 0);
-                                if (ptr) {
-                                        crit_down = (unsigned char)strtoul(ptr + 1, NULL, 0);
-                                }
-                                break;
-                        case 's': /* specify source IP address */
-                                source_ip = optarg;
-                                break;
-                        case 'V': /* version */
-                                print_revision(progname, NP_VERSION);
-                                exit(STATE_UNKNOWN);
-                        case 'h': /* help */
-                                print_help();
-                                exit(STATE_UNKNOWN);
-                                break;
-                        case 'R': /* RTA mode */
-                                err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_rta_mode);
-                                if (!err) {
-                                        crash("Failed to parse RTA threshold");
-                                }
+        if (config.need_v4) {
+                sockset.socket4 = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
+                if (sockset.socket4 == -1) {
+                        crash("Failed to obtain ICMP v4 socket");
+                }
 
-                                rta_mode = true;
-                                break;
-                        case 'P': /* packet loss mode */
-                                err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_packet_loss_mode);
-                                if (!err) {
-                                        crash("Failed to parse packet loss threshold");
-                                }
+                if (config.source_ip) {
 
-                                pl_mode = true;
-                                break;
-                        case 'J': /* jitter mode */
-                                err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_jitter_mode);
-                                if (!err) {
-                                        crash("Failed to parse jitter threshold");
-                                }
+                        struct in_addr tmp = {};
+                        int error_code = inet_pton(AF_INET, config.source_ip, &tmp);
+                        if (error_code == 1) {
+                                set_source_ip(config.source_ip, sockset.socket4, AF_INET);
+                        } else {
+                                // just try this mindlessly if it's not a v4 address
+                                set_source_ip(config.source_ip, sockset.socket6, AF_INET6);
+                        }
+                }
 
-                                jitter_mode = true;
-                                break;
-                        case 'M': /* MOS mode */
-                                err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_mos_mode);
-                                if (!err) {
-                                        crash("Failed to parse MOS threshold");
+#ifdef SO_TIMESTAMP
+                if (sockset.socket4 != -1) {
+                        int on = 1;
+                        if (setsockopt(sockset.socket4, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on))) {
+                                if (debug) {
+                                        printf("Warning: no SO_TIMESTAMP support\n");
                                 }
-
-                                mos_mode = true;
-                                break;
-                        case 'S': /* score mode */
-                                err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_score_mode);
-                                if (!err) {
-                                        crash("Failed to parse score threshold");
+                        }
+                }
+                if (sockset.socket6 != -1) {
+                        int on = 1;
+                        if (setsockopt(sockset.socket6, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on))) {
+                                if (debug) {
+                                        printf("Warning: no SO_TIMESTAMP support\n");
                                 }
-
-                                score_mode = true;
-                                break;
-                        case 'O': /* out of order mode */
-                                order_mode = true;
-                                break;
                         }
                 }
+#endif // SO_TIMESTAMP
         }
 
-        /* POSIXLY_CORRECT might break things, so unset it (the portable way) */
-        environ = NULL;
-
-        /* use the pid to mark packets as ours */
-        /* Some systems have 32-bit pid_t so mask off only 16 bits */
-        pid = getpid() & 0xffff;
-        /* printf("pid = %u\n", pid); */
-
-        /* Parse extra opts if any */
-        argv = np_extra_opts(&argc, argv, progname);
-
-        argv = &argv[optind];
-        while (*argv) {
-                add_target(*argv);
-                argv++;
-        }
-
-        if (!targets) {
-                errno = 0;
-                crash("No hosts to check");
-        }
-
-        // add_target might change address_family
-        switch (address_family) {
-        case AF_INET:
-                icmp_proto = IPPROTO_ICMP;
-                break;
-        case AF_INET6:
-                icmp_proto = IPPROTO_ICMPV6;
-                break;
-        default:
-                crash("Address family not supported");
-        }
-        if ((icmp_sock = socket(address_family, SOCK_RAW, icmp_proto)) != -1) {
-                sockets |= HAVE_ICMP;
-        } else {
-                icmp_sockerrno = errno;
-        }
-
-        if (source_ip) {
-                set_source_ip(source_ip);
-        }
-
-#ifdef SO_TIMESTAMP
-        if (setsockopt(icmp_sock, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on))) {
-                if (debug) {
-                        printf("Warning: no SO_TIMESTAMP support\n");
+        if (config.need_v6) {
+                sockset.socket6 = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
+                if (sockset.socket6 == -1) {
+                        crash("Failed to obtain ICMP v6 socket");
                 }
         }
-#endif // SO_TIMESTAMP
 
         /* now drop privileges (no effect if not setsuid or geteuid() == 0) */
         if (setuid(getuid()) == -1) {
@@ -746,186 +896,179 @@ int main(int argc, char **argv) {
                 return 1;
         }
 
-        if (!sockets) {
-                if (icmp_sock == -1) {
-                        errno = icmp_sockerrno;
-                        crash("Failed to obtain ICMP socket");
-                        return -1;
-                }
-                /* if(udp_sock == -1) { */
-                /*      errno = icmp_sockerrno; */
-                /*      crash("Failed to obtain UDP socket"); */
-                /*      return -1; */
-                /* } */
-                /* if(tcp_sock == -1) { */
-                /*      errno = icmp_sockerrno; */
-                /*      crash("Failed to obtain TCP socker"); */
-                /*      return -1; */
-                /* } */
-        }
-        if (!ttl) {
-                ttl = 64;
-        }
-
-        if (icmp_sock) {
-                result = setsockopt(icmp_sock, SOL_IP, IP_TTL, &ttl, sizeof(ttl));
+        if (sockset.socket4) {
+                int result = setsockopt(sockset.socket4, SOL_IP, IP_TTL, &config.ttl, sizeof(config.ttl));
                 if (debug) {
                         if (result == -1) {
                                 printf("setsockopt failed\n");
                         } else {
-                                printf("ttl set to %u\n", ttl);
+                                printf("ttl set to %lu\n", config.ttl);
                         }
                 }
         }
 
-        /* stupid users should be able to give whatever thresholds they want
-         * (nothing will break if they do), but some anal plugin maintainer
-         * will probably add some printf() thing here later, so it might be
-         * best to at least show them where to do it. ;) */
-        if (warn.pl > crit.pl) {
-                warn.pl = crit.pl;
-        }
-        if (warn.rta > crit.rta) {
-                warn.rta = crit.rta;
-        }
-        if (warn_down > crit_down) {
-                crit_down = warn_down;
-        }
-        if (warn.jitter > crit.jitter) {
-                crit.jitter = warn.jitter;
-        }
-        if (warn.mos < crit.mos) {
-                warn.mos = crit.mos;
-        }
-        if (warn.score < crit.score) {
-                warn.score = crit.score;
-        }
-
-#ifdef HAVE_SIGACTION
-        sig_action.sa_sigaction = NULL;
-        sig_action.sa_handler = finish;
-        sigfillset(&sig_action.sa_mask);
-        sig_action.sa_flags = SA_NODEFER | SA_RESTART;
-        sigaction(SIGINT, &sig_action, NULL);
-        sigaction(SIGHUP, &sig_action, NULL);
-        sigaction(SIGTERM, &sig_action, NULL);
-        sigaction(SIGALRM, &sig_action, NULL);
-#else  /* HAVE_SIGACTION */
-        signal(SIGINT, finish);
-        signal(SIGHUP, finish);
-        signal(SIGTERM, finish);
-        signal(SIGALRM, finish);
-#endif /* HAVE_SIGACTION */
-        if (debug) {
-                printf("Setting alarm timeout to %u seconds\n", timeout);
+        if (sockset.socket6) {
+                int result = setsockopt(sockset.socket6, SOL_IP, IP_TTL, &config.ttl, sizeof(config.ttl));
+                if (debug) {
+                        if (result == -1) {
+                                printf("setsockopt failed\n");
+                        } else {
+                                printf("ttl set to %lu\n", config.ttl);
+                        }
+                }
         }
-        alarm(timeout);
 
         /* make sure we don't wait any longer than necessary */
-        gettimeofday(&prog_start, &tz);
-        max_completion_time = ((targets * packets * pkt_interval) + (targets * target_interval)) + (targets * packets * crit.rta) + crit.rta;
+        struct timeval prog_start;
+        gettimeofday(&prog_start, NULL);
+
+        time_t max_completion_time =
+                (config.target_interval * config.number_of_targets) +
+                (config.crit.rta * config.number_of_targets * config.number_of_packets) + config.crit.rta;
 
         if (debug) {
                 printf("packets: %u, targets: %u\n"
-                           "target_interval: %0.3f, pkt_interval %0.3f\n"
+                           "target_interval: %0.3f\n"
                            "crit.rta: %0.3f\n"
                            "max_completion_time: %0.3f\n",
-                           packets, targets, (float)target_interval / 1000, (float)pkt_interval / 1000, (float)crit.rta / 1000,
+                           config.number_of_packets, config.number_of_targets,
+                           (float)config.target_interval / 1000, (float)config.crit.rta / 1000,
                            (float)max_completion_time / 1000);
         }
 
         if (debug) {
-                if (max_completion_time > (u_int)timeout * 1000000) {
-                        printf("max_completion_time: %llu  timeout: %u\n", max_completion_time, timeout);
-                        printf("Timeout must be at least %llu\n", max_completion_time / 1000000 + 1);
+                if (max_completion_time > (timeout * 1000000)) {
+                        printf("max_completion_time: %ld  timeout: %u\n", max_completion_time, timeout);
+                        printf("Timeout must be at least %ld\n", (max_completion_time / 1000000) + 1);
                 }
         }
 
         if (debug) {
-                printf("crit = {%u, %u%%}, warn = {%u, %u%%}\n", crit.rta, crit.pl, warn.rta, warn.pl);
-                printf("pkt_interval: %u  target_interval: %u  retry_interval: %u\n", pkt_interval, target_interval, retry_interval);
-                printf("icmp_pkt_size: %u  timeout: %u\n", icmp_pkt_size, timeout);
+                printf("crit = {%ld, %u%%}, warn = {%ld, %u%%}\n", config.crit.rta, config.crit.pl,
+                           config.warn.rta, config.warn.pl);
+                printf("target_interval: %ld\n", config.target_interval);
+                printf("icmp_pkt_size: %u  timeout: %u\n", config.icmp_data_size + ICMP_MINLEN, timeout);
         }
 
-        if (packets > 20) {
+        if (config.min_hosts_alive < -1) {
                 errno = 0;
-                crash("packets is > 20 (%d)", packets);
+                crash("minimum alive hosts is negative (%i)", config.min_hosts_alive);
         }
 
-        if (min_hosts_alive < -1) {
-                errno = 0;
-                crash("minimum alive hosts is negative (%i)", min_hosts_alive);
-        }
-
-        host = list;
-        table = malloc(sizeof(struct rta_host *) * targets);
+        // Build an index table of all targets
+        ping_target *host = config.targets;
+        ping_target **table = malloc(sizeof(ping_target *) * config.number_of_targets);
         if (!table) {
                 crash("main(): malloc failed for host table");
         }
 
-        i = 0;
+        unsigned short target_index = 0;
         while (host) {
-                host->id = i * packets;
-                table[i] = host;
+                host->id = target_index * config.number_of_packets;
+                table[target_index] = host;
                 host = host->next;
-                i++;
+                target_index++;
         }
 
-        run_checks();
+        time_t target_interval = config.target_interval;
+
+        check_icmp_state program_state = check_icmp_state_init();
+
+        run_checks(config.icmp_data_size, &target_interval, config.sender_id, config.mode,
+                           max_completion_time, prog_start, table, config.number_of_packets, sockset,
+                           config.number_of_targets, &program_state);
 
         errno = 0;
-        finish(0);
 
-        return (0);
-}
+        mp_check overall = mp_check_init();
+        finish(0, config.modes, config.min_hosts_alive, config.warn, config.crit,
+                   config.number_of_targets, &program_state, config.hosts, config.number_of_hosts,
+                   &overall);
 
-static void run_checks(void) {
-        u_int i, t;
-        u_int final_wait, time_passed;
+        if (sockset.socket4) {
+                close(sockset.socket4);
+        }
+        if (sockset.socket6) {
+                close(sockset.socket6);
+        }
+
+        mp_exit(overall);
+}
 
+static void run_checks(unsigned short icmp_pkt_size, time_t *target_interval,
+                                           const uint16_t sender_id, const check_icmp_execution_mode mode,
+                                           const time_t max_completion_time, const struct timeval prog_start,
+                                           ping_target **table, const unsigned short packets,
+                                           const check_icmp_socket_set sockset, const unsigned short number_of_targets,
+                                           check_icmp_state *program_state) {
         /* this loop might actually violate the pkt_interval or target_interval
          * settings, but only if there aren't any packets on the wire which
          * indicates that the target can handle an increased packet rate */
-        for (i = 0; i < packets; i++) {
-                for (t = 0; t < targets; t++) {
+        for (unsigned int packet_index = 0; packet_index < packets; packet_index++) {
+                for (unsigned int target_index = 0; target_index < number_of_targets; target_index++) {
                         /* don't send useless packets */
-                        if (!targets_alive) {
-                                finish(0);
+                        if (!targets_alive(number_of_targets, program_state->targets_down)) {
+                                return;
                         }
-                        if (table[t]->flags & FLAG_LOST_CAUSE) {
+                        if (table[target_index]->flags & FLAG_LOST_CAUSE) {
                                 if (debug) {
-                                        printf("%s is a lost cause. not sending any more\n", table[t]->name);
+
+                                        char address[INET6_ADDRSTRLEN];
+                                        parse_address(&table[target_index]->address, address, sizeof(address));
+                                        printf("%s is a lost cause. not sending any more\n", address);
                                 }
                                 continue;
                         }
 
                         /* we're still in the game, so send next packet */
-                        (void)send_icmp_ping(icmp_sock, table[t]);
-                        wait_for_reply(icmp_sock, target_interval);
+                        (void)send_icmp_ping(sockset, table[target_index], icmp_pkt_size, sender_id,
+                                                                 program_state);
+
+                        /* wrap up if all targets are declared dead */
+                        if (targets_alive(number_of_targets, program_state->targets_down) ||
+                                get_timevaldiff(prog_start, prog_start) < max_completion_time ||
+                                !(mode == MODE_HOSTCHECK && program_state->targets_down)) {
+                                wait_for_reply(sockset, *target_interval, icmp_pkt_size, target_interval, sender_id,
+                                                           table, packets, number_of_targets, program_state);
+                        }
+                }
+                if (targets_alive(number_of_targets, program_state->targets_down) ||
+                        get_timevaldiff_to_now(prog_start) < max_completion_time ||
+                        !(mode == MODE_HOSTCHECK && program_state->targets_down)) {
+                        wait_for_reply(sockset, number_of_targets, icmp_pkt_size, target_interval, sender_id,
+                                                   table, packets, number_of_targets, program_state);
                 }
-                wait_for_reply(icmp_sock, pkt_interval * targets);
         }
 
-        if (icmp_pkts_en_route && targets_alive) {
-                time_passed = get_timevaldiff(NULL, NULL);
-                final_wait = max_completion_time - time_passed;
+        if (icmp_pkts_en_route(program_state->icmp_sent, program_state->icmp_recv,
+                                                   program_state->icmp_lost) &&
+                targets_alive(number_of_targets, program_state->targets_down)) {
+                time_t time_passed = get_timevaldiff_to_now(prog_start);
+                time_t final_wait = max_completion_time - time_passed;
 
                 if (debug) {
-                        printf("time_passed: %u  final_wait: %u  max_completion_time: %llu\n", time_passed, final_wait, max_completion_time);
+                        printf("time_passed: %ld  final_wait: %ld  max_completion_time: %ld\n", time_passed,
+                                   final_wait, max_completion_time);
                 }
                 if (time_passed > max_completion_time) {
                         if (debug) {
                                 printf("Time passed. Finishing up\n");
                         }
-                        finish(0);
+                        return;
                 }
 
                 /* catch the packets that might come in within the timeframe, but
                  * haven't yet */
                 if (debug) {
-                        printf("Waiting for %u micro-seconds (%0.3f msecs)\n", final_wait, (float)final_wait / 1000);
+                        printf("Waiting for %ld micro-seconds (%0.3f msecs)\n", final_wait,
+                                   (float)final_wait / 1000);
+                }
+                if (targets_alive(number_of_targets, program_state->targets_down) ||
+                        get_timevaldiff_to_now(prog_start) < max_completion_time ||
+                        !(mode == MODE_HOSTCHECK && program_state->targets_down)) {
+                        wait_for_reply(sockset, final_wait, icmp_pkt_size, target_interval, sender_id, table,
+                                                   packets, number_of_targets, program_state);
                 }
-                wait_for_reply(icmp_sock, final_wait);
         }
 }
 
@@ -939,18 +1082,11 @@ static void run_checks(void) {
  * both:
  * icmp echo reply : the rest
  */
-static int wait_for_reply(int sock, u_int t) {
-        int n, hlen;
-        static unsigned char buf[65536];
-        struct sockaddr_storage resp_addr;
-        union ip_hdr *ip;
+static int wait_for_reply(check_icmp_socket_set sockset, const time_t time_interval,
+                                                  unsigned short icmp_pkt_size, time_t *target_interval, uint16_t sender_id,
+                                                  ping_target **table, const unsigned short packets,
+                                                  const unsigned short number_of_targets, check_icmp_state *program_state) {
         union icmp_packet packet;
-        struct rta_host *host;
-        struct icmp_ping_data data;
-        struct timeval wait_start, now;
-        u_int tdiff, i, per_pkt_wait;
-        double jitter_tmp;
-
         if (!(packet.buf = malloc(icmp_pkt_size))) {
                 crash("send_icmp_ping(): failed to malloc %d bytes for send buffer", icmp_pkt_size);
                 return -1; /* might be reached if we're in debug mode */
@@ -959,177 +1095,174 @@ static int wait_for_reply(int sock, u_int t) {
         memset(packet.buf, 0, icmp_pkt_size);
 
         /* if we can't listen or don't have anything to listen to, just return */
-        if (!t || !icmp_pkts_en_route) {
+        if (!time_interval || !icmp_pkts_en_route(program_state->icmp_sent, program_state->icmp_recv,
+                                                                                          program_state->icmp_lost)) {
                 free(packet.buf);
                 return 0;
         }
 
-        gettimeofday(&wait_start, &tz);
+        // Get current time stamp
+        struct timeval wait_start;
+        gettimeofday(&wait_start, NULL);
 
-        i = t;
-        per_pkt_wait = t / icmp_pkts_en_route;
-        while (icmp_pkts_en_route && get_timevaldiff(&wait_start, NULL) < i) {
-                t = per_pkt_wait;
-
-                /* wrap up if all targets are declared dead */
-                if (!targets_alive || get_timevaldiff(&prog_start, NULL) >= max_completion_time || (mode == MODE_HOSTCHECK && targets_down)) {
-                        finish(0);
-                }
+        struct sockaddr_storage resp_addr;
+        time_t per_pkt_wait =
+                time_interval / icmp_pkts_en_route(program_state->icmp_sent, program_state->icmp_recv,
+                                                                                   program_state->icmp_lost);
+        static unsigned char buf[65536];
+        union ip_hdr *ip_header;
+        struct timeval packet_received_timestamp;
+        while (icmp_pkts_en_route(program_state->icmp_sent, program_state->icmp_recv,
+                                                          program_state->icmp_lost) &&
+                   get_timevaldiff_to_now(wait_start) < time_interval) {
+                time_t loop_time_interval = per_pkt_wait;
 
                 /* reap responses until we hit a timeout */
-                n = recvfrom_wto(sock, buf, sizeof(buf), (struct sockaddr *)&resp_addr, &t, &now);
-                if (!n) {
+                recvfrom_wto_wrapper recv_foo =
+                        recvfrom_wto(sockset, buf, sizeof(buf), (struct sockaddr *)&resp_addr,
+                                                 &loop_time_interval, &packet_received_timestamp);
+                if (!recv_foo.received) {
                         if (debug > 1) {
-                                printf("recvfrom_wto() timed out during a %u usecs wait\n", per_pkt_wait);
+                                printf("recvfrom_wto() timed out during a %ld usecs wait\n", per_pkt_wait);
                         }
                         continue; /* timeout for this one, so keep trying */
                 }
-                if (n < 0) {
+
+                if (recv_foo.received < 0) {
                         if (debug) {
                                 printf("recvfrom_wto() returned errors\n");
                         }
                         free(packet.buf);
-                        return n;
+                        return (int)recv_foo.received;
                 }
 
-                // FIXME: with ipv6 we don't have an ip header here
-                if (address_family != AF_INET6) {
-                        ip = (union ip_hdr *)buf;
+                if (recv_foo.recv_proto != AF_INET6) {
+                        ip_header = (union ip_hdr *)buf;
 
                         if (debug > 1) {
                                 char address[INET6_ADDRSTRLEN];
                                 parse_address(&resp_addr, address, sizeof(address));
-                                printf("received %u bytes from %s\n", address_family == AF_INET6 ? ntohs(ip->ip6.ip6_plen) : ntohs(ip->ip.ip_len), address);
+                                printf("received %u bytes from %s\n",
+                                           address_family == AF_INET6 ? ntohs(ip_header->ip6.ip6_plen)
+                                                                                                  : ntohs(ip_header->ip.ip_len),
+                                           address);
                         }
                 }
 
-                /* obsolete. alpha on tru64 provides the necessary defines, but isn't broken */
-                /* #if defined( __alpha__ ) && __STDC__ && !defined( __GLIBC__ ) */
-                /* alpha headers are decidedly broken. Using an ansi compiler,
-                 * they provide ip_vhl instead of ip_hl and ip_v, so we mask
-                 * off the bottom 4 bits */
-                /*              hlen = (ip->ip_vhl & 0x0f) << 2; */
-                /* #else */
-                hlen = (address_family == AF_INET6) ? 0 : ip->ip.ip_hl << 2;
-                /* #endif */
-
-                if (n < (hlen + ICMP_MINLEN)) {
+                int hlen = (recv_foo.recv_proto == AF_INET6) ? 0 : ip_header->ip.ip_hl << 2;
+
+                if (recv_foo.received < (hlen + ICMP_MINLEN)) {
                         char address[INET6_ADDRSTRLEN];
                         parse_address(&resp_addr, address, sizeof(address));
-                        crash("received packet too short for ICMP (%d bytes, expected %d) from %s\n", n, hlen + icmp_pkt_size, address);
+                        crash("received packet too short for ICMP (%ld bytes, expected %d) from %s\n",
+                                  recv_foo.received, hlen + icmp_pkt_size, address);
                 }
-                /* else if(debug) { */
-                /*      printf("ip header size: %u, packet size: %u (expected %u, %u)\n", */
-                /*                 hlen, ntohs(ip->ip_len) - hlen, */
-                /*                 sizeof(struct ip), icmp_pkt_size); */
-                /* } */
-
                 /* check the response */
-
                 memcpy(packet.buf, buf + hlen, icmp_pkt_size);
-                /*                      address_family == AF_INET6 ? sizeof(struct icmp6_hdr)
-                                                                   : sizeof(struct icmp));*/
 
-                if ((address_family == PF_INET && (ntohs(packet.icp->icmp_id) != pid || packet.icp->icmp_type != ICMP_ECHOREPLY ||
-                                                                                   ntohs(packet.icp->icmp_seq) >= targets * packets)) ||
-                        (address_family == PF_INET6 && (ntohs(packet.icp6->icmp6_id) != pid || packet.icp6->icmp6_type != ICMP6_ECHO_REPLY ||
-                                                                                        ntohs(packet.icp6->icmp6_seq) >= targets * packets))) {
+                if ((recv_foo.recv_proto == AF_INET &&
+                         (ntohs(packet.icp->icmp_id) != sender_id || packet.icp->icmp_type != ICMP_ECHOREPLY ||
+                          ntohs(packet.icp->icmp_seq) >= number_of_targets * packets)) ||
+                        (recv_foo.recv_proto == AF_INET6 &&
+                         (ntohs(packet.icp6->icmp6_id) != sender_id ||
+                          packet.icp6->icmp6_type != ICMP6_ECHO_REPLY ||
+                          ntohs(packet.icp6->icmp6_seq) >= number_of_targets * packets))) {
                         if (debug > 2) {
                                 printf("not a proper ICMP_ECHOREPLY\n");
                         }
-                        handle_random_icmp(buf + hlen, &resp_addr);
+
+                        handle_random_icmp(buf + hlen, &resp_addr, target_interval, sender_id, table, packets,
+                                                           number_of_targets, program_state);
+
                         continue;
                 }
 
                 /* this is indeed a valid response */
-                if (address_family == PF_INET) {
+                ping_target *target;
+                struct icmp_ping_data data;
+                if (address_family == AF_INET) {
                         memcpy(&data, packet.icp->icmp_data, sizeof(data));
                         if (debug > 2) {
-                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n", (unsigned long)sizeof(data), ntohs(packet.icp->icmp_id),
-                                           ntohs(packet.icp->icmp_seq), packet.icp->icmp_cksum);
+                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n", sizeof(data),
+                                           ntohs(packet.icp->icmp_id), ntohs(packet.icp->icmp_seq),
+                                           packet.icp->icmp_cksum);
                         }
-                        host = table[ntohs(packet.icp->icmp_seq) / packets];
+                        target = table[ntohs(packet.icp->icmp_seq) / packets];
                 } else {
                         memcpy(&data, &packet.icp6->icmp6_dataun.icmp6_un_data8[4], sizeof(data));
                         if (debug > 2) {
-                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n", (unsigned long)sizeof(data), ntohs(packet.icp6->icmp6_id),
-                                           ntohs(packet.icp6->icmp6_seq), packet.icp6->icmp6_cksum);
+                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n", sizeof(data),
+                                           ntohs(packet.icp6->icmp6_id), ntohs(packet.icp6->icmp6_seq),
+                                           packet.icp6->icmp6_cksum);
                         }
-                        host = table[ntohs(packet.icp6->icmp6_seq) / packets];
+                        target = table[ntohs(packet.icp6->icmp6_seq) / packets];
                 }
 
-                tdiff = get_timevaldiff(&data.stime, &now);
+                time_t tdiff = get_timevaldiff(data.stime, packet_received_timestamp);
 
-                if (host->last_tdiff > 0) {
+                if (target->last_tdiff > 0) {
                         /* Calculate jitter */
-                        if (host->last_tdiff > tdiff) {
-                                jitter_tmp = host->last_tdiff - tdiff;
+                        double jitter_tmp;
+                        if (target->last_tdiff > tdiff) {
+                                jitter_tmp = (double)(target->last_tdiff - tdiff);
                         } else {
-                                jitter_tmp = tdiff - host->last_tdiff;
+                                jitter_tmp = (double)(tdiff - target->last_tdiff);
                         }
 
-                        if (host->jitter == 0) {
-                                host->jitter = jitter_tmp;
-                                host->jitter_max = jitter_tmp;
-                                host->jitter_min = jitter_tmp;
+                        if (target->jitter == 0) {
+                                target->jitter = jitter_tmp;
+                                target->jitter_max = jitter_tmp;
+                                target->jitter_min = jitter_tmp;
                         } else {
-                                host->jitter += jitter_tmp;
+                                target->jitter += jitter_tmp;
 
-                                if (jitter_tmp < host->jitter_min) {
-                                        host->jitter_min = jitter_tmp;
+                                if (jitter_tmp < target->jitter_min) {
+                                        target->jitter_min = jitter_tmp;
                                 }
 
-                                if (jitter_tmp > host->jitter_max) {
-                                        host->jitter_max = jitter_tmp;
+                                if (jitter_tmp > target->jitter_max) {
+                                        target->jitter_max = jitter_tmp;
                                 }
                         }
 
                         /* Check if packets in order */
-                        if (host->last_icmp_seq >= packet.icp->icmp_seq) {
-                                host->order_status = STATE_CRITICAL;
+                        if (target->last_icmp_seq >= packet.icp->icmp_seq) {
+                                target->found_out_of_order_packets = true;
                         }
                 }
-                host->last_tdiff = tdiff;
+                target->last_tdiff = tdiff;
 
-                host->last_icmp_seq = packet.icp->icmp_seq;
+                target->last_icmp_seq = packet.icp->icmp_seq;
 
-                host->time_waited += tdiff;
-                host->icmp_recv++;
-                icmp_recv++;
+                target->time_waited += tdiff;
+                target->icmp_recv++;
+                program_state->icmp_recv++;
 
-                if (tdiff > (unsigned int)host->rtmax) {
-                        host->rtmax = tdiff;
+                if (tdiff > (unsigned int)target->rtmax) {
+                        target->rtmax = (double)tdiff;
                 }
 
-                if ((host->rtmin == INFINITY) || (tdiff < (unsigned int)host->rtmin)) {
-                        host->rtmin = tdiff;
+                if ((target->rtmin == INFINITY) || (tdiff < (unsigned int)target->rtmin)) {
+                        target->rtmin = (double)tdiff;
                 }
 
                 if (debug) {
                         char address[INET6_ADDRSTRLEN];
                         parse_address(&resp_addr, address, sizeof(address));
 
-                        switch (address_family) {
+                        switch (recv_foo.recv_proto) {
                         case AF_INET: {
-                                printf("%0.3f ms rtt from %s, outgoing ttl: %u, incoming ttl: %u, max: %0.3f, min: %0.3f\n", (float)tdiff / 1000, address,
-                                           ttl, ip->ip.ip_ttl, (float)host->rtmax / 1000, (float)host->rtmin / 1000);
+                                printf("%0.3f ms rtt from %s, incoming ttl: %u, max: %0.3f, min: %0.3f\n",
+                                           (float)tdiff / 1000, address, ip_header->ip.ip_ttl,
+                                           (float)target->rtmax / 1000, (float)target->rtmin / 1000);
                                 break;
                         };
                         case AF_INET6: {
-                                printf("%0.3f ms rtt from %s, outgoing ttl: %u, max: %0.3f, min: %0.3f\n", (float)tdiff / 1000, address, ttl,
-                                           (float)host->rtmax / 1000, (float)host->rtmin / 1000);
+                                printf("%0.3f ms rtt from %s, max: %0.3f, min: %0.3f\n", (float)tdiff / 1000,
+                                           address, (float)target->rtmax / 1000, (float)target->rtmin / 1000);
                         };
                         }
                 }
-
-                /* if we're in hostcheck mode, exit with limited printouts */
-                if (mode == MODE_HOSTCHECK) {
-                        printf("OK - %s responds to ICMP. Packet %u, rta %0.3fms|"
-                                   "pkt=%u;;;0;%u rta=%0.3f;%0.3f;%0.3f;;\n",
-                                   host->name, icmp_recv, (float)tdiff / 1000, icmp_recv, packets, (float)tdiff / 1000, (float)warn.rta / 1000,
-                                   (float)crit.rta / 1000);
-                        exit(STATE_OK);
-                }
         }
 
         free(packet.buf);
@@ -1137,38 +1270,28 @@ static int wait_for_reply(int sock, u_int t) {
 }
 
 /* the ping functions */
-static int send_icmp_ping(int sock, struct rta_host *host) {
-        long int len;
-        size_t addrlen;
-        struct icmp_ping_data data;
-        struct msghdr hdr;
-        struct iovec iov;
-        struct timeval tv;
-        void *buf = NULL;
-
-        if (sock == -1) {
-                errno = 0;
-                crash("Attempt to send on bogus socket");
-                return -1;
-        }
-
+static int send_icmp_ping(const check_icmp_socket_set sockset, ping_target *host,
+                                                  const unsigned short icmp_pkt_size, const uint16_t sender_id,
+                                                  check_icmp_state *program_state) {
+        void *buf = calloc(1, icmp_pkt_size);
         if (!buf) {
-                if (!(buf = malloc(icmp_pkt_size))) {
-                        crash("send_icmp_ping(): failed to malloc %d bytes for send buffer", icmp_pkt_size);
-                        return -1; /* might be reached if we're in debug mode */
-                }
+                crash("send_icmp_ping(): failed to malloc %d bytes for send buffer", icmp_pkt_size);
+                return -1; /* might be reached if we're in debug mode */
         }
-        memset(buf, 0, icmp_pkt_size);
 
-        if ((gettimeofday(&tv, &tz)) == -1) {
+        struct timeval current_time;
+        if ((gettimeofday(&current_time, NULL)) == -1) {
                 free(buf);
                 return -1;
         }
 
+        struct icmp_ping_data data;
         data.ping_id = 10; /* host->icmp.icmp_sent; */
-        memcpy(&data.stime, &tv, sizeof(tv));
+        memcpy(&data.stime, &current_time, sizeof(current_time));
 
-        if (address_family == AF_INET) {
+        socklen_t addrlen = 0;
+
+        if (host->address.ss_family == AF_INET) {
                 struct icmp *icp = (struct icmp *)buf;
                 addrlen = sizeof(struct sockaddr_in);
 
@@ -1177,15 +1300,19 @@ static int send_icmp_ping(int sock, struct rta_host *host) {
                 icp->icmp_type = ICMP_ECHO;
                 icp->icmp_code = 0;
                 icp->icmp_cksum = 0;
-                icp->icmp_id = htons(pid);
+                icp->icmp_id = htons((uint16_t)sender_id);
                 icp->icmp_seq = htons(host->id++);
                 icp->icmp_cksum = icmp_checksum((uint16_t *)buf, (size_t)icmp_pkt_size);
 
                 if (debug > 2) {
-                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n", (unsigned long)sizeof(data),
-                                   ntohs(icp->icmp_id), ntohs(icp->icmp_seq), icp->icmp_cksum, host->name);
+                        char address[INET6_ADDRSTRLEN];
+                        parse_address((&host->address), address, sizeof(address));
+
+                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n",
+                                   sizeof(data), ntohs(icp->icmp_id), ntohs(icp->icmp_seq), icp->icmp_cksum,
+                                   address);
                 }
-        } else {
+        } else if (host->address.ss_family == AF_INET6) {
                 struct icmp6_hdr *icp6 = (struct icmp6_hdr *)buf;
                 addrlen = sizeof(struct sockaddr_in6);
 
@@ -1194,659 +1321,431 @@ static int send_icmp_ping(int sock, struct rta_host *host) {
                 icp6->icmp6_type = ICMP6_ECHO_REQUEST;
                 icp6->icmp6_code = 0;
                 icp6->icmp6_cksum = 0;
-                icp6->icmp6_id = htons(pid);
+                icp6->icmp6_id = htons((uint16_t)sender_id);
                 icp6->icmp6_seq = htons(host->id++);
                 // let checksum be calculated automatically
 
                 if (debug > 2) {
-                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n", (unsigned long)sizeof(data),
-                                   ntohs(icp6->icmp6_id), ntohs(icp6->icmp6_seq), icp6->icmp6_cksum, host->name);
+                        char address[INET6_ADDRSTRLEN];
+                        parse_address((&host->address), address, sizeof(address));
+
+                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to target %s\n",
+                                   sizeof(data), ntohs(icp6->icmp6_id), ntohs(icp6->icmp6_seq), icp6->icmp6_cksum,
+                                   address);
                 }
+        } else {
+                // unknown address family
+                crash("unknown address family in %s", __func__);
         }
 
+        struct iovec iov;
         memset(&iov, 0, sizeof(iov));
         iov.iov_base = buf;
         iov.iov_len = icmp_pkt_size;
 
+        struct msghdr hdr;
         memset(&hdr, 0, sizeof(hdr));
-        hdr.msg_name = (struct sockaddr *)&host->saddr_in;
+        hdr.msg_name = (struct sockaddr *)&host->address;
         hdr.msg_namelen = addrlen;
         hdr.msg_iov = &iov;
         hdr.msg_iovlen = 1;
 
         errno = 0;
 
-/* MSG_CONFIRM is a linux thing and only available on linux kernels >= 2.3.15, see send(2) */
+        long int len;
+        /* MSG_CONFIRM is a linux thing and only available on linux kernels >= 2.3.15, see send(2) */
+        if (host->address.ss_family == AF_INET) {
+#ifdef MSG_CONFIRM
+                len = sendmsg(sockset.socket4, &hdr, MSG_CONFIRM);
+#else
+                len = sendmsg(sockset.socket4, &hdr, 0);
+#endif
+        } else if (host->address.ss_family == AF_INET6) {
 #ifdef MSG_CONFIRM
-        len = sendmsg(sock, &hdr, MSG_CONFIRM);
+                len = sendmsg(sockset.socket6, &hdr, MSG_CONFIRM);
 #else
-        len = sendmsg(sock, &hdr, 0);
+                len = sendmsg(sockset.socket6, &hdr, 0);
 #endif
+        } else {
+                assert(false);
+        }
 
         free(buf);
 
         if (len < 0 || (unsigned int)len != icmp_pkt_size) {
                 if (debug) {
                         char address[INET6_ADDRSTRLEN];
-                        parse_address((struct sockaddr_storage *)&host->saddr_in, address, sizeof(address));
+                        parse_address((&host->address), address, sizeof(address));
                         printf("Failed to send ping to %s: %s\n", address, strerror(errno));
                 }
                 errno = 0;
                 return -1;
         }
 
-        icmp_sent++;
+        program_state->icmp_sent++;
         host->icmp_sent++;
 
         return 0;
 }
 
-static int recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr, u_int *timo, struct timeval *tv) {
-        u_int slen;
-        int n, ret;
-        struct timeval to, then, now;
-        fd_set rd, wr;
+static recvfrom_wto_wrapper recvfrom_wto(const check_icmp_socket_set sockset, void *buf,
+                                                                                 const unsigned int len, struct sockaddr *saddr,
+                                                                                 time_t *timeout, struct timeval *received_timestamp) {
 #ifdef HAVE_MSGHDR_MSG_CONTROL
         char ans_data[4096];
 #endif // HAVE_MSGHDR_MSG_CONTROL
-        struct msghdr hdr;
-        struct iovec iov;
 #ifdef SO_TIMESTAMP
         struct cmsghdr *chdr;
 #endif
 
-        if (!*timo) {
+        recvfrom_wto_wrapper result = {
+                .received = 0,
+                .recv_proto = AF_UNSPEC,
+        };
+
+        if (!*timeout) {
                 if (debug) {
-                        printf("*timo is not\n");
+                        printf("*timeout is not\n");
                 }
-                return 0;
+                return result;
+        }
+
+        struct timeval real_timeout;
+        real_timeout.tv_sec = *timeout / 1000000;
+        real_timeout.tv_usec = (*timeout - (real_timeout.tv_sec * 1000000));
+
+        // Dummy fds for select
+        fd_set dummy_write_fds;
+        FD_ZERO(&dummy_write_fds);
+
+        // Read fds for select with the socket
+        fd_set read_fds;
+        FD_ZERO(&read_fds);
+
+        if (sockset.socket4 != -1) {
+                FD_SET(sockset.socket4, &read_fds);
+        }
+        if (sockset.socket6 != -1) {
+                FD_SET(sockset.socket6, &read_fds);
         }
 
-        to.tv_sec = *timo / 1000000;
-        to.tv_usec = (*timo - (to.tv_sec * 1000000));
+        int nfds = (sockset.socket4 > sockset.socket6 ? sockset.socket4 : sockset.socket6) + 1;
+
+        struct timeval then;
+        gettimeofday(&then, NULL);
 
-        FD_ZERO(&rd);
-        FD_ZERO(&wr);
-        FD_SET(sock, &rd);
         errno = 0;
-        gettimeofday(&then, &tz);
-        n = select(sock + 1, &rd, &wr, NULL, &to);
-        if (n < 0) {
+        int select_return = select(nfds, &read_fds, &dummy_write_fds, NULL, &real_timeout);
+        if (select_return < 0) {
                 crash("select() in recvfrom_wto");
         }
-        gettimeofday(&now, &tz);
-        *timo = get_timevaldiff(&then, &now);
 
-        if (!n) {
-                return 0; /* timeout */
+        struct timeval now;
+        gettimeofday(&now, NULL);
+        *timeout = get_timevaldiff(then, now);
+
+        if (!select_return) {
+                return result; /* timeout */
         }
 
-        slen = sizeof(struct sockaddr_storage);
+        unsigned int slen = sizeof(struct sockaddr_storage);
 
-        memset(&iov, 0, sizeof(iov));
-        iov.iov_base = buf;
-        iov.iov_len = len;
+        struct iovec iov = {
+                .iov_base = buf,
+                .iov_len = len,
+        };
 
-        memset(&hdr, 0, sizeof(hdr));
-        hdr.msg_name = saddr;
-        hdr.msg_namelen = slen;
-        hdr.msg_iov = &iov;
-        hdr.msg_iovlen = 1;
+        struct msghdr hdr = {
+                .msg_name = saddr,
+                .msg_namelen = slen,
+                .msg_iov = &iov,
+                .msg_iovlen = 1,
 #ifdef HAVE_MSGHDR_MSG_CONTROL
-        hdr.msg_control = ans_data;
-        hdr.msg_controllen = sizeof(ans_data);
+                .msg_control = ans_data,
+                .msg_controllen = sizeof(ans_data),
 #endif
+        };
+
+        ssize_t ret;
+        if (FD_ISSET(sockset.socket4, &read_fds)) {
+                ret = recvmsg(sockset.socket4, &hdr, 0);
+                result.recv_proto = AF_INET;
+        } else if (FD_ISSET(sockset.socket6, &read_fds)) {
+                ret = recvmsg(sockset.socket6, &hdr, 0);
+                result.recv_proto = AF_INET6;
+        } else {
+                assert(false);
+        }
+
+        result.received = ret;
 
-        ret = recvmsg(sock, &hdr, 0);
 #ifdef SO_TIMESTAMP
         for (chdr = CMSG_FIRSTHDR(&hdr); chdr; chdr = CMSG_NXTHDR(&hdr, chdr)) {
-                if (chdr->cmsg_level == SOL_SOCKET && chdr->cmsg_type == SO_TIMESTAMP && chdr->cmsg_len >= CMSG_LEN(sizeof(struct timeval))) {
-                        memcpy(tv, CMSG_DATA(chdr), sizeof(*tv));
+                if (chdr->cmsg_level == SOL_SOCKET && chdr->cmsg_type == SO_TIMESTAMP &&
+                        chdr->cmsg_len >= CMSG_LEN(sizeof(struct timeval))) {
+                        memcpy(received_timestamp, CMSG_DATA(chdr), sizeof(*received_timestamp));
                         break;
                 }
         }
 
-        if (!chdr)
+        if (!chdr) {
+                gettimeofday(received_timestamp, NULL);
+        }
+#else
+        gettimeofday(tv, NULL);
 #endif // SO_TIMESTAMP
-                gettimeofday(tv, &tz);
-        return (ret);
-}
 
-static void finish(int sig) {
-        u_int i = 0;
-        unsigned char pl;
-        double rta;
-        struct rta_host *host;
-        const char *status_string[] = {"OK", "WARNING", "CRITICAL", "UNKNOWN", "DEPENDENT"};
-        int hosts_ok = 0;
-        int hosts_warn = 0;
-        int this_status;
-        double R;
+        return (result);
+}
 
+static void finish(int sig, check_icmp_mode_switches modes, int min_hosts_alive,
+                                   check_icmp_threshold warn, check_icmp_threshold crit,
+                                   const unsigned short number_of_targets, check_icmp_state *program_state,
+                                   check_icmp_target_container host_list[], unsigned short number_of_hosts,
+                                   mp_check overall[static 1]) {
+        // Deactivate alarm
         alarm(0);
+
         if (debug > 1) {
                 printf("finish(%d) called\n", sig);
         }
 
-        if (icmp_sock != -1) {
-                close(icmp_sock);
-        }
-        if (udp_sock != -1) {
-                close(udp_sock);
-        }
-        if (tcp_sock != -1) {
-                close(tcp_sock);
-        }
-
         if (debug) {
-                printf("icmp_sent: %u  icmp_recv: %u  icmp_lost: %u\n", icmp_sent, icmp_recv, icmp_lost);
-                printf("targets: %u  targets_alive: %u\n", targets, targets_alive);
+                printf("icmp_sent: %u  icmp_recv: %u  icmp_lost: %u\n", program_state->icmp_sent,
+                           program_state->icmp_recv, program_state->icmp_lost);
+                printf("targets: %u  targets_alive: %u\n", number_of_targets,
+                           targets_alive(number_of_targets, program_state->targets_down));
         }
 
-        /* iterate thrice to calculate values, give output, and print perfparse */
-        status = STATE_OK;
-        host = list;
-
-        while (host) {
-                this_status = STATE_OK;
-
-                if (!host->icmp_recv) {
-                        /* rta 0 is ofcourse not entirely correct, but will still show up
-                         * conspicuously as missing entries in perfparse and cacti */
-                        pl = 100;
-                        rta = 0;
-                        status = STATE_CRITICAL;
-                        /* up the down counter if not already counted */
-                        if (!(host->flags & FLAG_LOST_CAUSE) && targets_alive) {
-                                targets_down++;
-                        }
-                } else {
-                        pl = ((host->icmp_sent - host->icmp_recv) * 100) / host->icmp_sent;
-                        rta = (double)host->time_waited / host->icmp_recv;
-                }
-
-                if (host->icmp_recv > 1) {
-                        /*
-                         * This algorithm is probably pretty much blindly copied from
-                         * locations like this one: https://www.slac.stanford.edu/comp/net/wan-mon/tutorial.html#mos
-                         * It calculates a MOS value (range of 1 to 5, where 1 is bad and 5 really good).
-                         * According to some quick research MOS originates from the Audio/Video transport network area.
-                         * Whether it can and should be computed from ICMP data, I can not say.
-                         *
-                         * Anyway the basic idea is to map a value "R" with a range of 0-100 to the MOS value
-                         *
-                         * MOS stands likely for Mean Opinion Score ( https://en.wikipedia.org/wiki/Mean_Opinion_Score )
-                         *
-                         * More links:
-                         * - https://confluence.slac.stanford.edu/display/IEPM/MOS
-                         */
-                        host->jitter = (host->jitter / (host->icmp_recv - 1) / 1000);
-
-                        /*
-                         * Take the average round trip latency (in milliseconds), add
-                         * round trip jitter, but double the impact to latency
-                         * then add 10 for protocol latencies (in milliseconds).
-                         */
-                        host->EffectiveLatency = (rta / 1000) + host->jitter * 2 + 10;
-
-                        if (host->EffectiveLatency < 160) {
-                                R = 93.2 - (host->EffectiveLatency / 40);
-                        } else {
-                                R = 93.2 - ((host->EffectiveLatency - 120) / 10);
-                        }
-
-                        // Now, let us deduct 2.5 R values per percentage of packet loss (i.e. a
-                        // loss of 5% will be entered as 5).
-                        R = R - (pl * 2.5);
-
-                        if (R < 0) {
-                                R = 0;
-                        }
-
-                        host->score = R;
-                        host->mos = 1 + ((0.035) * R) + ((.000007) * R * (R - 60) * (100 - R));
-                } else {
-                        host->jitter = 0;
-                        host->jitter_min = 0;
-                        host->jitter_max = 0;
-                        host->mos = 0;
-                }
-
-                host->pl = pl;
-                host->rta = rta;
-
-                /* if no new mode selected, use old schema */
-                if (!rta_mode && !pl_mode && !jitter_mode && !score_mode && !mos_mode && !order_mode) {
-                        rta_mode = true;
-                        pl_mode = true;
-                }
-
-                /* Check which mode is on and do the warn / Crit stuff */
-                if (rta_mode) {
-                        if (rta >= crit.rta) {
-                                this_status = STATE_CRITICAL;
-                                status = STATE_CRITICAL;
-                                host->rta_status = STATE_CRITICAL;
-                        } else if (status != STATE_CRITICAL && (rta >= warn.rta)) {
-                                this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
-                                status = STATE_WARNING;
-                                host->rta_status = STATE_WARNING;
-                        }
-                }
-
-                if (pl_mode) {
-                        if (pl >= crit.pl) {
-                                this_status = STATE_CRITICAL;
-                                status = STATE_CRITICAL;
-                                host->pl_status = STATE_CRITICAL;
-                        } else if (status != STATE_CRITICAL && (pl >= warn.pl)) {
-                                this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
-                                status = STATE_WARNING;
-                                host->pl_status = STATE_WARNING;
-                        }
-                }
-
-                if (jitter_mode) {
-                        if (host->jitter >= crit.jitter) {
-                                this_status = STATE_CRITICAL;
-                                status = STATE_CRITICAL;
-                                host->jitter_status = STATE_CRITICAL;
-                        } else if (status != STATE_CRITICAL && (host->jitter >= warn.jitter)) {
-                                this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
-                                status = STATE_WARNING;
-                                host->jitter_status = STATE_WARNING;
-                        }
-                }
-
-                if (mos_mode) {
-                        if (host->mos <= crit.mos) {
-                                this_status = STATE_CRITICAL;
-                                status = STATE_CRITICAL;
-                                host->mos_status = STATE_CRITICAL;
-                        } else if (status != STATE_CRITICAL && (host->mos <= warn.mos)) {
-                                this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
-                                status = STATE_WARNING;
-                                host->mos_status = STATE_WARNING;
-                        }
-                }
-
-                if (score_mode) {
-                        if (host->score <= crit.score) {
-                                this_status = STATE_CRITICAL;
-                                status = STATE_CRITICAL;
-                                host->score_status = STATE_CRITICAL;
-                        } else if (status != STATE_CRITICAL && (host->score <= warn.score)) {
-                                this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
-                                status = STATE_WARNING;
-                                host->score_status = STATE_WARNING;
-                        }
-                }
+        // loop over targets to evaluate each one
+        int targets_ok = 0;
+        int targets_warn = 0;
+        for (unsigned short i = 0; i < number_of_hosts; i++) {
+                evaluate_host_wrapper host_check = evaluate_host(host_list[i], modes, warn, crit);
 
-                if (this_status == STATE_WARNING) {
-                        hosts_warn++;
-                } else if (this_status == STATE_OK) {
-                        hosts_ok++;
-                }
+                targets_ok += host_check.targets_ok;
+                targets_warn += host_check.targets_warn;
 
-                host = host->next;
+                mp_add_subcheck_to_check(overall, host_check.sc_host);
         }
 
-        /* this is inevitable */
-        if (!targets_alive) {
-                status = STATE_CRITICAL;
-        }
         if (min_hosts_alive > -1) {
-                if (hosts_ok >= min_hosts_alive) {
-                        status = STATE_OK;
-                } else if ((hosts_ok + hosts_warn) >= min_hosts_alive) {
-                        status = STATE_WARNING;
-                }
-        }
-        printf("%s - ", status_string[status]);
-
-        host = list;
-        while (host) {
-                if (debug) {
-                        puts("");
-                }
-
-                if (i) {
-                        if (i < targets) {
-                                printf(" :: ");
-                        } else {
-                                printf("\n");
-                        }
-                }
-
-                i++;
-
-                if (!host->icmp_recv) {
-                        status = STATE_CRITICAL;
-                        host->rtmin = 0;
-                        host->jitter_min = 0;
-
-                        if (host->flags & FLAG_LOST_CAUSE) {
-                                char address[INET6_ADDRSTRLEN];
-                                parse_address(&host->error_addr, address, sizeof(address));
-                                printf("%s: %s @ %s. rta nan, lost %d%%", host->name, get_icmp_error_msg(host->icmp_type, host->icmp_code), address, 100);
-                        } else { /* not marked as lost cause, so we have no flags for it */
-                                printf("%s: rta nan, lost 100%%", host->name);
-                        }
-                } else { /* !icmp_recv */
-                        printf("%s", host->name);
-                        /* rta text output */
-                        if (rta_mode) {
-                                if (status == STATE_OK) {
-                                        printf(" rta %0.3fms", host->rta / 1000);
-                                } else if (status == STATE_WARNING && host->rta_status == status) {
-                                        printf(" rta %0.3fms > %0.3fms", (float)host->rta / 1000, (float)warn.rta / 1000);
-                                } else if (status == STATE_CRITICAL && host->rta_status == status) {
-                                        printf(" rta %0.3fms > %0.3fms", (float)host->rta / 1000, (float)crit.rta / 1000);
-                                }
-                        }
-
-                        /* pl text output */
-                        if (pl_mode) {
-                                if (status == STATE_OK) {
-                                        printf(" lost %u%%", host->pl);
-                                } else if (status == STATE_WARNING && host->pl_status == status) {
-                                        printf(" lost %u%% > %u%%", host->pl, warn.pl);
-                                } else if (status == STATE_CRITICAL && host->pl_status == status) {
-                                        printf(" lost %u%% > %u%%", host->pl, crit.pl);
-                                }
-                        }
-
-                        /* jitter text output */
-                        if (jitter_mode) {
-                                if (status == STATE_OK) {
-                                        printf(" jitter %0.3fms", (float)host->jitter);
-                                } else if (status == STATE_WARNING && host->jitter_status == status) {
-                                        printf(" jitter %0.3fms > %0.3fms", (float)host->jitter, warn.jitter);
-                                } else if (status == STATE_CRITICAL && host->jitter_status == status) {
-                                        printf(" jitter %0.3fms > %0.3fms", (float)host->jitter, crit.jitter);
-                                }
-                        }
-
-                        /* mos text output */
-                        if (mos_mode) {
-                                if (status == STATE_OK) {
-                                        printf(" MOS %0.1f", (float)host->mos);
-                                } else if (status == STATE_WARNING && host->mos_status == status) {
-                                        printf(" MOS %0.1f < %0.1f", (float)host->mos, (float)warn.mos);
-                                } else if (status == STATE_CRITICAL && host->mos_status == status) {
-                                        printf(" MOS %0.1f < %0.1f", (float)host->mos, (float)crit.mos);
-                                }
-                        }
-
-                        /* score text output */
-                        if (score_mode) {
-                                if (status == STATE_OK) {
-                                        printf(" Score %u", (int)host->score);
-                                } else if (status == STATE_WARNING && host->score_status == status) {
-                                        printf(" Score %u < %u", (int)host->score, (int)warn.score);
-                                } else if (status == STATE_CRITICAL && host->score_status == status) {
-                                        printf(" Score %u < %u", (int)host->score, (int)crit.score);
-                                }
-                        }
-
-                        /* order statis text output */
-                        if (order_mode) {
-                                if (status == STATE_OK) {
-                                        printf(" Packets in order");
-                                } else if (status == STATE_CRITICAL && host->order_status == status) {
-                                        printf(" Packets out of order");
-                                }
-                        }
-                }
-                host = host->next;
-        }
-
-        /* iterate once more for pretty perfparse output */
-        if (!(!rta_mode && !pl_mode && !jitter_mode && !score_mode && !mos_mode && order_mode)) {
-                printf("|");
-        }
-        i = 0;
-        host = list;
-        while (host) {
-                if (debug) {
-                        puts("");
-                }
-
-                if (rta_mode) {
-                        if (host->pl < 100) {
-                                printf("%srta=%0.3fms;%0.3f;%0.3f;0; %srtmax=%0.3fms;;;; %srtmin=%0.3fms;;;; ", (targets > 1) ? host->name : "",
-                                           host->rta / 1000, (float)warn.rta / 1000, (float)crit.rta / 1000, (targets > 1) ? host->name : "",
-                                           (float)host->rtmax / 1000, (targets > 1) ? host->name : "",
-                                           (host->rtmin < INFINITY) ? (float)host->rtmin / 1000 : (float)0);
-                        } else {
-                                printf("%srta=U;;;; %srtmax=U;;;; %srtmin=U;;;; ", (targets > 1) ? host->name : "", (targets > 1) ? host->name : "",
-                                           (targets > 1) ? host->name : "");
-                        }
-                }
-
-                if (pl_mode) {
-                        printf("%spl=%u%%;%u;%u;0;100 ", (targets > 1) ? host->name : "", host->pl, warn.pl, crit.pl);
-                }
-
-                if (jitter_mode) {
-                        if (host->pl < 100) {
-                                printf("%sjitter_avg=%0.3fms;%0.3f;%0.3f;0; %sjitter_max=%0.3fms;;;; %sjitter_min=%0.3fms;;;; ",
-                                           (targets > 1) ? host->name : "", (float)host->jitter, (float)warn.jitter, (float)crit.jitter,
-                                           (targets > 1) ? host->name : "", (float)host->jitter_max / 1000, (targets > 1) ? host->name : "",
-                                           (float)host->jitter_min / 1000);
-                        } else {
-                                printf("%sjitter_avg=U;;;; %sjitter_max=U;;;; %sjitter_min=U;;;; ", (targets > 1) ? host->name : "",
-                                           (targets > 1) ? host->name : "", (targets > 1) ? host->name : "");
-                        }
-                }
-
-                if (mos_mode) {
-                        if (host->pl < 100) {
-                                printf("%smos=%0.1f;%0.1f;%0.1f;0;5 ", (targets > 1) ? host->name : "", (float)host->mos, (float)warn.mos, (float)crit.mos);
-                        } else {
-                                printf("%smos=U;;;; ", (targets > 1) ? host->name : "");
-                        }
-                }
-
-                if (score_mode) {
-                        if (host->pl < 100) {
-                                printf("%sscore=%u;%u;%u;0;100 ", (targets > 1) ? host->name : "", (int)host->score, (int)warn.score, (int)crit.score);
-                        } else {
-                                printf("%sscore=U;;;; ", (targets > 1) ? host->name : "");
-                        }
+                mp_subcheck sc_min_targets_alive = mp_subcheck_init();
+                sc_min_targets_alive = mp_set_subcheck_default_state(sc_min_targets_alive, STATE_OK);
+
+                if (targets_ok >= min_hosts_alive) {
+                        sc_min_targets_alive = mp_set_subcheck_state(sc_min_targets_alive, STATE_OK);
+                        xasprintf(&sc_min_targets_alive.output, "%u targets OK of a minimum of %u", targets_ok,
+                                          min_hosts_alive);
+
+                        // Overwrite main state here
+                        overall->evaluation_function = &mp_eval_ok;
+                } else if ((targets_ok + targets_warn) >= min_hosts_alive) {
+                        sc_min_targets_alive = mp_set_subcheck_state(sc_min_targets_alive, STATE_WARNING);
+                        xasprintf(&sc_min_targets_alive.output, "%u targets OK or Warning of a minimum of %u",
+                                          targets_ok + targets_warn, min_hosts_alive);
+                        overall->evaluation_function = &mp_eval_warning;
+                } else {
+                        sc_min_targets_alive = mp_set_subcheck_state(sc_min_targets_alive, STATE_CRITICAL);
+                        xasprintf(&sc_min_targets_alive.output, "%u targets OK or Warning of a minimum of %u",
+                                          targets_ok + targets_warn, min_hosts_alive);
+                        overall->evaluation_function = &mp_eval_critical;
                 }
 
-                host = host->next;
-        }
-
-        if (min_hosts_alive > -1) {
-                if (hosts_ok >= min_hosts_alive) {
-                        status = STATE_OK;
-                } else if ((hosts_ok + hosts_warn) >= min_hosts_alive) {
-                        status = STATE_WARNING;
-                }
+                mp_add_subcheck_to_check(overall, sc_min_targets_alive);
         }
 
         /* finish with an empty line */
-        puts("");
         if (debug) {
-                printf("targets: %u, targets_alive: %u, hosts_ok: %u, hosts_warn: %u, min_hosts_alive: %i\n", targets, targets_alive, hosts_ok,
-                           hosts_warn, min_hosts_alive);
+                printf(
+                        "targets: %u, targets_alive: %u, hosts_ok: %u, hosts_warn: %u, min_hosts_alive: %i\n",
+                        number_of_targets, targets_alive(number_of_targets, program_state->targets_down),
+                        targets_ok, targets_warn, min_hosts_alive);
         }
-
-        exit(status);
 }
 
-static u_int get_timevaldiff(struct timeval *early, struct timeval *later) {
-        u_int ret;
-        struct timeval now;
-
-        if (!later) {
-                gettimeofday(&now, &tz);
-                later = &now;
-        }
-        if (!early) {
-                early = &prog_start;
-        }
-
+static time_t get_timevaldiff(const struct timeval earlier, const struct timeval later) {
         /* if early > later we return 0 so as to indicate a timeout */
-        if (early->tv_sec > later->tv_sec || (early->tv_sec == later->tv_sec && early->tv_usec > later->tv_usec)) {
+        if (earlier.tv_sec > later.tv_sec ||
+                (earlier.tv_sec == later.tv_sec && earlier.tv_usec > later.tv_usec)) {
                 return 0;
         }
-        ret = (later->tv_sec - early->tv_sec) * 1000000;
-        ret += later->tv_usec - early->tv_usec;
+
+        time_t ret = (later.tv_sec - earlier.tv_sec) * 1000000;
+        ret += later.tv_usec - earlier.tv_usec;
 
         return ret;
 }
 
-static int add_target_ip(char *arg, struct sockaddr_storage *in) {
-        struct rta_host *host;
-        struct sockaddr_in *sin, *host_sin;
-        struct sockaddr_in6 *sin6, *host_sin6;
+static time_t get_timevaldiff_to_now(struct timeval earlier) {
+        struct timeval now;
+        gettimeofday(&now, NULL);
+
+        return get_timevaldiff(earlier, now);
+}
+
+static add_target_ip_wrapper add_target_ip(struct sockaddr_storage address) {
+        assert((address.ss_family == AF_INET) || (address.ss_family == AF_INET6));
 
-        if (address_family == AF_INET) {
-                sin = (struct sockaddr_in *)in;
+        if (debug) {
+                char straddr[INET6_ADDRSTRLEN];
+                parse_address((&address), straddr, sizeof(straddr));
+                printf("add_target_ip called with: %s\n", straddr);
+        }
+        struct sockaddr_in *sin;
+        struct sockaddr_in6 *sin6;
+        if (address.ss_family == AF_INET) {
+                sin = (struct sockaddr_in *)&address;
+        } else if (address.ss_family == AF_INET6) {
+                sin6 = (struct sockaddr_in6 *)&address;
         } else {
-                sin6 = (struct sockaddr_in6 *)in;
+                assert(false);
         }
 
+        add_target_ip_wrapper result = {
+                .error_code = OK,
+                .target = NULL,
+        };
+
         /* disregard obviously stupid addresses
          * (I didn't find an ipv6 equivalent to INADDR_NONE) */
-        if (((address_family == AF_INET && (sin->sin_addr.s_addr == INADDR_NONE || sin->sin_addr.s_addr == INADDR_ANY))) ||
-                (address_family == AF_INET6 && (sin6->sin6_addr.s6_addr == in6addr_any.s6_addr))) {
-                return -1;
+        if (((address.ss_family == AF_INET &&
+                  (sin->sin_addr.s_addr == INADDR_NONE || sin->sin_addr.s_addr == INADDR_ANY))) ||
+                (address.ss_family == AF_INET6 && (sin6->sin6_addr.s6_addr == in6addr_any.s6_addr))) {
+                result.error_code = ERROR;
+                return result;
         }
 
-        /* no point in adding two identical IP's, so don't. ;) */
-        host = list;
-        while (host) {
-                host_sin = (struct sockaddr_in *)&host->saddr_in;
-                host_sin6 = (struct sockaddr_in6 *)&host->saddr_in;
-
-                if ((address_family == AF_INET && host_sin->sin_addr.s_addr == sin->sin_addr.s_addr) ||
-                        (address_family == AF_INET6 && host_sin6->sin6_addr.s6_addr == sin6->sin6_addr.s6_addr)) {
-                        if (debug) {
-                                printf("Identical IP already exists. Not adding %s\n", arg);
-                        }
-                        return -1;
-                }
-                host = host->next;
-        }
+        // get string representation of address
+        char straddr[INET6_ADDRSTRLEN];
+        parse_address((&address), straddr, sizeof(straddr));
 
         /* add the fresh ip */
-        host = (struct rta_host *)malloc(sizeof(struct rta_host));
-        if (!host) {
-                char straddr[INET6_ADDRSTRLEN];
-                parse_address((struct sockaddr_storage *)&in, straddr, sizeof(straddr));
-                crash("add_target_ip(%s, %s): malloc(%lu) failed", arg, straddr, sizeof(struct rta_host));
+        ping_target *target = (ping_target *)calloc(1, sizeof(ping_target));
+        if (!target) {
+                crash("add_target_ip(%s): malloc(%lu) failed", straddr, sizeof(ping_target));
         }
-        memset(host, 0, sizeof(struct rta_host));
 
-        /* set the values. use calling name for output */
-        host->name = strdup(arg);
+        ping_target_create_wrapper target_wrapper = ping_target_create(address);
 
-        /* fill out the sockaddr_storage struct */
-        if (address_family == AF_INET) {
-                host_sin = (struct sockaddr_in *)&host->saddr_in;
-                host_sin->sin_family = AF_INET;
-                host_sin->sin_addr.s_addr = sin->sin_addr.s_addr;
+        if (target_wrapper.errorcode == OK) {
+                *target = target_wrapper.host;
+                result.target = target;
         } else {
-                host_sin6 = (struct sockaddr_in6 *)&host->saddr_in;
-                host_sin6->sin6_family = AF_INET6;
-                memcpy(host_sin6->sin6_addr.s6_addr, sin6->sin6_addr.s6_addr, sizeof host_sin6->sin6_addr.s6_addr);
-        }
-
-        /* fill out the sockaddr_in struct */
-        host->rtmin = INFINITY;
-        host->rtmax = 0;
-        host->jitter = 0;
-        host->jitter_max = 0;
-        host->jitter_min = INFINITY;
-        host->last_tdiff = 0;
-        host->order_status = STATE_OK;
-        host->last_icmp_seq = 0;
-        host->rta_status = 0;
-        host->pl_status = 0;
-        host->jitter_status = 0;
-        host->mos_status = 0;
-        host->score_status = 0;
-        host->pl_status = 0;
-
-        if (!list) {
-                list = cursor = host;
-        } else {
-                cursor->next = host;
+                result.error_code = target_wrapper.errorcode;
         }
 
-        cursor = host;
-        targets++;
-
-        return 0;
+        return result;
 }
 
 /* wrapper for add_target_ip */
-static int add_target(char *arg) {
-        int error, result = -1;
-        struct sockaddr_storage ip;
-        struct addrinfo hints, *res, *p;
-        struct sockaddr_in *sin;
-        struct sockaddr_in6 *sin6;
-
-        switch (address_family) {
-        case -1:
-                /* -4 and -6 are not specified on cmdline */
-                address_family = AF_INET;
-                sin = (struct sockaddr_in *)&ip;
-                result = inet_pton(address_family, arg, &sin->sin_addr);
-#ifdef USE_IPV6
-                if (result != 1) {
-                        address_family = AF_INET6;
-                        sin6 = (struct sockaddr_in6 *)&ip;
-                        result = inet_pton(address_family, arg, &sin6->sin6_addr);
-                }
-#endif
-                /* If we don't find any valid addresses, we still don't know the address_family */
-                if (result != 1) {
-                        address_family = -1;
+static add_target_wrapper add_target(char *arg, const check_icmp_execution_mode mode,
+                                                                         sa_family_t enforced_proto) {
+        if (debug > 0) {
+                printf("add_target called with argument %s\n", arg);
+        }
+
+        struct sockaddr_storage address_storage = {};
+        struct sockaddr_in *sin = NULL;
+        struct sockaddr_in6 *sin6 = NULL;
+        int error_code = -1;
+
+        switch (enforced_proto) {
+        case AF_UNSPEC:
+                /*
+                 * no enforced protocol family
+                 * try to parse the address with each one
+                 */
+                sin = (struct sockaddr_in *)&address_storage;
+                error_code = inet_pton(AF_INET, arg, &sin->sin_addr);
+                address_storage.ss_family = AF_INET;
+
+                if (error_code != 1) {
+                        sin6 = (struct sockaddr_in6 *)&address_storage;
+                        error_code = inet_pton(AF_INET6, arg, &sin6->sin6_addr);
+                        address_storage.ss_family = AF_INET6;
                 }
                 break;
         case AF_INET:
-                sin = (struct sockaddr_in *)&ip;
-                result = inet_pton(address_family, arg, &sin->sin_addr);
+                sin = (struct sockaddr_in *)&address_storage;
+                error_code = inet_pton(AF_INET, arg, &sin->sin_addr);
+                address_storage.ss_family = AF_INET;
                 break;
         case AF_INET6:
-                sin6 = (struct sockaddr_in6 *)&ip;
-                result = inet_pton(address_family, arg, &sin6->sin6_addr);
+                sin6 = (struct sockaddr_in6 *)&address_storage;
+                error_code = inet_pton(AF_INET, arg, &sin6->sin6_addr);
+                address_storage.ss_family = AF_INET6;
                 break;
         default:
                 crash("Address family not supported");
         }
 
-        /* don't resolve if we don't have to */
-        if (result == 1) {
+        add_target_wrapper result = {
+                .error_code = OK,
+                .targets = NULL,
+                .has_v4 = false,
+                .has_v6 = false,
+        };
+
+        // if error_code == 1 the address was a valid address parsed above
+        if (error_code == 1) {
                 /* don't add all ip's if we were given a specific one */
-                return add_target_ip(arg, &ip);
-        } else {
-                errno = 0;
-                memset(&hints, 0, sizeof(hints));
-                if (address_family == -1) {
-                        hints.ai_family = AF_UNSPEC;
-                } else {
-                        hints.ai_family = address_family == AF_INET ? PF_INET : PF_INET6;
+                add_target_ip_wrapper targeted = add_target_ip(address_storage);
+
+                if (targeted.error_code != OK) {
+                        result.error_code = ERROR;
+                        return result;
                 }
-                hints.ai_socktype = SOCK_RAW;
-                if ((error = getaddrinfo(arg, NULL, &hints, &res)) != 0) {
-                        errno = 0;
-                        crash("Failed to resolve %s: %s", arg, gai_strerror(error));
-                        return -1;
+
+                if (targeted.target->address.ss_family == AF_INET) {
+                        result.has_v4 = true;
+                } else if (targeted.target->address.ss_family == AF_INET6) {
+                        result.has_v6 = true;
+                } else {
+                        assert(false);
                 }
-                address_family = res->ai_family;
+                result.targets = targeted.target;
+                result.number_of_targets = 1;
+                return result;
+        }
+
+        struct addrinfo hints = {};
+        errno = 0;
+        hints.ai_family = enforced_proto;
+        hints.ai_socktype = SOCK_RAW;
+
+        int error;
+        struct addrinfo *res;
+        if ((error = getaddrinfo(arg, NULL, &hints, &res)) != 0) {
+                errno = 0;
+                crash("Failed to resolve %s: %s", arg, gai_strerror(error));
+                result.error_code = ERROR;
+                return result;
         }
 
         /* possibly add all the IP's as targets */
-        for (p = res; p != NULL; p = p->ai_next) {
-                memcpy(&ip, p->ai_addr, p->ai_addrlen);
-                add_target_ip(arg, &ip);
+        for (struct addrinfo *address = res; address != NULL; address = address->ai_next) {
+                struct sockaddr_storage temporary_ip_address;
+                memcpy(&temporary_ip_address, address->ai_addr, address->ai_addrlen);
+
+                add_target_ip_wrapper tmp = add_target_ip(temporary_ip_address);
+
+                if (tmp.error_code != OK) {
+                        // No proper error handling
+                        // What to do?
+                } else {
+                        if (result.targets == NULL) {
+                                result.targets = tmp.target;
+                                result.number_of_targets = 1;
+                        } else {
+                                result.number_of_targets += ping_target_list_append(result.targets, tmp.target);
+                        }
+                        if (address->ai_family == AF_INET) {
+                                result.has_v4 = true;
+                        } else if (address->ai_family == AF_INET6) {
+                                result.has_v6 = true;
+                        }
+                }
 
                 /* this is silly, but it works */
                 if (mode == MODE_HOSTCHECK || mode == MODE_ALL) {
@@ -1855,18 +1754,20 @@ static int add_target(char *arg) {
                         }
                         continue;
                 }
+
+                // Abort after first hit if not in of the modes above
                 break;
         }
         freeaddrinfo(res);
 
-        return 0;
+        return result;
 }
 
-static void set_source_ip(char *arg) {
+static void set_source_ip(char *arg, const int icmp_sock, sa_family_t addr_family) {
         struct sockaddr_in src;
 
         memset(&src, 0, sizeof(src));
-        src.sin_family = address_family;
+        src.sin_family = addr_family;
         if ((src.sin_addr.s_addr = inet_addr(arg)) == INADDR_NONE) {
                 src.sin_addr.s_addr = get_ip_address(arg);
         }
@@ -1878,8 +1779,8 @@ static void set_source_ip(char *arg) {
 /* TODO: Move this to netutils.c and also change check_dhcp to use that. */
 static in_addr_t get_ip_address(const char *ifname) {
         // TODO: Rewrite this so the function return an error and we exit somewhere else
-        struct sockaddr_in ip;
-        ip.sin_addr.s_addr = 0; // Fake initialization to make compiler happy
+        struct sockaddr_in ip_address;
+        ip_address.sin_addr.s_addr = 0; // Fake initialization to make compiler happy
 #if defined(SIOCGIFADDR)
         struct ifreq ifr;
 
@@ -1897,7 +1798,7 @@ static in_addr_t get_ip_address(const char *ifname) {
         errno = 0;
         crash("Cannot get interface IP address on this platform.");
 #endif
-        return ip.sin_addr.s_addr;
+        return ip_address.sin_addr.s_addr;
 }
 
 /*
@@ -1906,103 +1807,127 @@ static in_addr_t get_ip_address(const char *ifname) {
  * s = seconds
  * return value is in microseconds
  */
-static u_int get_timevar(const char *str) {
-        char p, u, *ptr;
-        size_t len;
-        u_int i, d;          /* integer and decimal, respectively */
-        u_int factor = 1000; /* default to milliseconds */
+static get_timevar_wrapper get_timevar(const char *str) {
+        get_timevar_wrapper result = {
+                .error_code = OK,
+                .time_range = 0,
+        };
 
         if (!str) {
-                return 0;
+                result.error_code = ERROR;
+                return result;
         }
-        len = strlen(str);
+
+        size_t len = strlen(str);
         if (!len) {
-                return 0;
+                result.error_code = ERROR;
+                return result;
         }
 
         /* unit might be given as ms|m (millisec),
          * us|u (microsec) or just plain s, for seconds */
-        p = '\0';
-        u = str[len - 1];
+        char tmp = '\0';
+        char unit = str[len - 1];
         if (len >= 2 && !isdigit((int)str[len - 2])) {
-                p = str[len - 2];
+                tmp = str[len - 2];
         }
-        if (p && u == 's') {
-                u = p;
-        } else if (!p) {
-                p = u;
+
+        if (tmp && unit == 's') {
+                unit = tmp;
+        } else if (!tmp) {
+                tmp = unit;
         }
+
         if (debug > 2) {
-                printf("evaluating %s, u: %c, p: %c\n", str, u, p);
+                printf("evaluating %s, u: %c, p: %c\n", str, unit, tmp);
         }
 
-        if (u == 'u') {
+        unsigned int factor = 1000; /* default to milliseconds */
+        if (unit == 'u') {
                 factor = 1; /* microseconds */
-        } else if (u == 'm') {
+        } else if (unit == 'm') {
                 factor = 1000; /* milliseconds */
-        } else if (u == 's') {
+        } else if (unit == 's') {
                 factor = 1000000; /* seconds */
         }
+
         if (debug > 2) {
                 printf("factor is %u\n", factor);
         }
 
-        i = strtoul(str, &ptr, 0);
+        char *ptr;
+        unsigned long pre_radix;
+        pre_radix = strtoul(str, &ptr, 0);
         if (!ptr || *ptr != '.' || strlen(ptr) < 2 || factor == 1) {
-                return i * factor;
+                result.time_range = (unsigned int)(pre_radix * factor);
+                return result;
         }
 
         /* time specified in usecs can't have decimal points, so ignore them */
         if (factor == 1) {
-                return i;
+                result.time_range = (unsigned int)pre_radix;
+                return result;
         }
 
-        d = strtoul(ptr + 1, NULL, 0);
+        /* integer and decimal, respectively */
+        unsigned int post_radix = (unsigned int)strtoul(ptr + 1, NULL, 0);
 
         /* d is decimal, so get rid of excess digits */
-        while (d >= factor) {
-                d /= 10;
+        while (post_radix >= factor) {
+                post_radix /= 10;
         }
 
         /* the last parenthesis avoids floating point exceptions. */
-        return ((i * factor) + (d * (factor / 10)));
+        result.time_range = (unsigned int)((pre_radix * factor) + (post_radix * (factor / 10)));
+        return result;
 }
 
-/* not too good at checking errors, but it'll do (main() should barfe on -1) */
-static int get_threshold(char *str, threshold *th) {
-        char *p = NULL, i = 0;
+static get_threshold_wrapper get_threshold(char *str, check_icmp_threshold threshold) {
+        get_threshold_wrapper result = {
+                .errorcode = OK,
+                .threshold = threshold,
+        };
 
-        if (!str || !strlen(str) || !th) {
-                return -1;
+        if (!str || !strlen(str)) {
+                result.errorcode = ERROR;
+                return result;
         }
 
         /* pointer magic slims code by 10 lines. i is bof-stop on stupid libc's */
-        p = &str[strlen(str) - 1];
-        while (p != &str[1]) {
-                if (*p == '%') {
-                        *p = '\0';
-                } else if (*p == ',' && i) {
-                        *p = '\0'; /* reset it so get_timevar(str) works nicely later */
-                        th->pl = (unsigned char)strtoul(p + 1, NULL, 0);
+        bool is_at_last_char = false;
+        char *tmp = &str[strlen(str) - 1];
+        while (tmp != &str[1]) {
+                if (*tmp == '%') {
+                        *tmp = '\0';
+                } else if (*tmp == ',' && is_at_last_char) {
+                        *tmp = '\0'; /* reset it so get_timevar(str) works nicely later */
+                        result.threshold.pl = (unsigned char)strtoul(tmp + 1, NULL, 0);
                         break;
                 }
-                i = 1;
-                p--;
+                is_at_last_char = true;
+                tmp--;
         }
-        th->rta = get_timevar(str);
 
-        if (!th->rta) {
-                return -1;
+        get_timevar_wrapper parsed_time = get_timevar(str);
+
+        if (parsed_time.error_code == OK) {
+                result.threshold.rta = parsed_time.time_range;
+        } else {
+                if (debug > 1) {
+                        printf("%s: failed to parse rta threshold\n", __FUNCTION__);
+                }
+                result.errorcode = ERROR;
+                return result;
         }
 
-        if (th->rta > MAXTTL * 1000000) {
-                th->rta = MAXTTL * 1000000;
+        if (result.threshold.rta > MAXTTL * 1000000) {
+                result.threshold.rta = MAXTTL * 1000000;
         }
-        if (th->pl > 100) {
-                th->pl = 100;
+        if (result.threshold.pl > 100) {
+                result.threshold.pl = 100;
         }
 
-        return 0;
+        return result;
 }
 
 /*
@@ -2013,184 +1938,537 @@ static int get_threshold(char *str, threshold *th) {
  * @param[in] length strlen(str)
  * @param[out] warn Pointer to the warn threshold struct to which the values should be assigned
  * @param[out] crit Pointer to the crit threshold struct to which the values should be assigned
- * @param[in] mode Determines whether this a threshold for rta, packet_loss, jitter, mos or score (exclusively)
+ * @param[in] mode Determines whether this a threshold for rta, packet_loss, jitter, mos or score
+ * (exclusively)
  */
-static bool get_threshold2(char *str, size_t length, threshold *warn, threshold *crit, threshold_mode mode) {
-        if (!str || !length || !warn || !crit) {
-                return false;
+static get_threshold2_wrapper get_threshold2(char *str, size_t length, check_icmp_threshold warn,
+                                                                                         check_icmp_threshold crit, threshold_mode mode) {
+        get_threshold2_wrapper result = {
+                .errorcode = OK,
+                .warn = warn,
+                .crit = crit,
+        };
+
+        if (!str || !length) {
+                result.errorcode = ERROR;
+                return result;
         }
 
         // p points to the last char in str
-        char *p = &str[length - 1];
+        char *work_pointer = &str[length - 1];
 
         // first_iteration is bof-stop on stupid libc's
         bool first_iteration = true;
 
-        while (p != &str[0]) {
-                if ((*p == 'm') || (*p == '%')) {
-                        *p = '\0';
-                } else if (*p == ',' && !first_iteration) {
-                        *p = '\0'; /* reset it so get_timevar(str) works nicely later */
+        while (work_pointer != &str[0]) {
+                if ((*work_pointer == 'm') || (*work_pointer == '%')) {
+                        *work_pointer = '\0';
+                } else if (*work_pointer == ',' && !first_iteration) {
+                        *work_pointer = '\0'; /* reset it so get_timevar(str) works nicely later */
 
-                        char *start_of_value = p + 1;
+                        char *start_of_value = work_pointer + 1;
 
-                        if (!parse_threshold2_helper(start_of_value, strlen(start_of_value), crit, mode)) {
-                                return false;
+                        parse_threshold2_helper_wrapper tmp =
+                                parse_threshold2_helper(start_of_value, strlen(start_of_value), result.crit, mode);
+                        if (tmp.errorcode != OK) {
+                                result.errorcode = ERROR;
+                                return result;
                         }
+                        result.crit = tmp.result;
                 }
                 first_iteration = false;
-                p--;
+                work_pointer--;
         }
 
-        return parse_threshold2_helper(p, strlen(p), warn, mode);
+        parse_threshold2_helper_wrapper tmp =
+                parse_threshold2_helper(work_pointer, strlen(work_pointer), result.warn, mode);
+        if (tmp.errorcode != OK) {
+                result.errorcode = ERROR;
+        } else {
+                result.warn = tmp.result;
+        }
+        return result;
 }
 
-static bool parse_threshold2_helper(char *s, size_t length, threshold *thr, threshold_mode mode) {
+static parse_threshold2_helper_wrapper parse_threshold2_helper(char *threshold_string,
+                                                                                                                           size_t length,
+                                                                                                                           check_icmp_threshold thr,
+                                                                                                                           threshold_mode mode) {
         char *resultChecker = {0};
+        parse_threshold2_helper_wrapper result = {
+                .result = thr,
+                .errorcode = OK,
+        };
 
         switch (mode) {
         case const_rta_mode:
-                thr->rta = strtod(s, &resultChecker) * 1000;
+                result.result.rta = (unsigned int)(strtod(threshold_string, &resultChecker) * 1000);
                 break;
         case const_packet_loss_mode:
-                thr->pl = (unsigned char)strtoul(s, &resultChecker, 0);
+                result.result.pl = (unsigned char)strtoul(threshold_string, &resultChecker, 0);
                 break;
         case const_jitter_mode:
-                thr->jitter = strtod(s, &resultChecker);
-
+                result.result.jitter = strtod(threshold_string, &resultChecker);
                 break;
         case const_mos_mode:
-                thr->mos = strtod(s, &resultChecker);
+                result.result.mos = strtod(threshold_string, &resultChecker);
                 break;
         case const_score_mode:
-                thr->score = strtod(s, &resultChecker);
+                result.result.score = strtod(threshold_string, &resultChecker);
                 break;
         }
 
-        if (resultChecker == s) {
+        if (resultChecker == threshold_string) {
                 // Failed to parse
-                return false;
+                result.errorcode = ERROR;
+                return result;
         }
 
-        if (resultChecker != (s + length)) {
+        if (resultChecker != (threshold_string + length)) {
                 // Trailing symbols
-                return false;
+                result.errorcode = ERROR;
         }
 
-        return true;
+        return result;
 }
 
-unsigned short icmp_checksum(uint16_t *p, size_t n) {
-        unsigned short cksum;
+unsigned short icmp_checksum(uint16_t *packet, size_t packet_size) {
         long sum = 0;
 
         /* sizeof(uint16_t) == 2 */
-        while (n >= 2) {
-                sum += *(p++);
-                n -= 2;
+        while (packet_size >= 2) {
+                sum += *(packet++);
+                packet_size -= 2;
         }
 
         /* mop up the occasional odd byte */
-        if (n == 1) {
-                sum += *((uint8_t *)p - 1);
+        if (packet_size == 1) {
+                sum += *((uint8_t *)packet - 1);
         }
 
         sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
         sum += (sum >> 16);                 /* add carry */
-        cksum = ~sum;                       /* ones-complement, trunc to 16 bits */
+        unsigned short cksum;
+        cksum = (unsigned short)~sum; /* ones-complement, trunc to 16 bits */
 
         return cksum;
 }
 
 void print_help(void) {
-        /*print_revision (progname);*/ /* FIXME: Why? */
+        // print_revision (progname); /* FIXME: Why? */
         printf("Copyright (c) 2005 Andreas Ericsson <ae@op5.se>\n");
 
         printf(COPYRIGHT, copyright, email);
 
-        printf("\n\n");
-
         print_usage();
 
         printf(UT_HELP_VRSN);
         printf(UT_EXTRA_OPTS);
 
-        printf(" %s\n", "-H");
-        printf("    %s\n", _("specify a target"));
-        printf(" %s\n", "[-4|-6]");
-        printf("    %s\n", _("Use IPv4 (default) or IPv6 to communicate with the targets"));
-        printf(" %s\n", "-w");
-        printf("    %s", _("warning threshold (currently "));
-        printf("%0.3fms,%u%%)\n", (float)warn.rta / 1000, warn.pl);
-        printf(" %s\n", "-c");
-        printf("    %s", _("critical threshold (currently "));
-        printf("%0.3fms,%u%%)\n", (float)crit.rta / 1000, crit.pl);
-
-        printf(" %s\n", "-R");
-        printf("    %s\n", _("RTA, round trip average,  mode  warning,critical, ex. 100ms,200ms unit in ms"));
-        printf(" %s\n", "-P");
+        printf(" -H, --Host=HOST\n");
+        printf("    %s\n",
+                   _("specify a target, might be one of: resolveable name | IPv6 address | IPv4 address\n"
+                         "    (required, can be given multiple times)"));
+        printf(" %s\n", "[-4|-6], [--ipv4-only|--ipv6-only]");
+        printf("    %s\n", _("Use IPv4 or IPv6 only to communicate with the targets"));
+        printf(" %s\n", "-w, --warning=WARN_VALUE");
+        printf("    %s", _("warning threshold (default "));
+        printf("%0.3fms,%u%%)\n", (float)DEFAULT_WARN_RTA / 1000, DEFAULT_WARN_PL);
+        printf(" %s\n", "-c, --critical=CRIT_VALUE");
+        printf("    %s", _("critical threshold (default "));
+        printf("%0.3fms,%u%%)\n", (float)DEFAULT_CRIT_RTA / 1000, DEFAULT_CRIT_PL);
+
+        printf(" %s\n", "-R, --rta-mode-thresholds=RTA_THRESHOLDS");
+        printf("    %s\n",
+                   _("RTA (round trip average) mode  warning,critical, ex. 100ms,200ms unit in ms"));
+        printf(" %s\n", "-P, --packet-loss-mode-thresholds=PACKET_LOSS_THRESHOLD");
         printf("    %s\n", _("packet loss mode, ex. 40%,50% , unit in %"));
-        printf(" %s\n", "-J");
+        printf(" %s\n", "-J, --jitter-mode-thresholds=JITTER_MODE_THRESHOLD");
         printf("    %s\n", _("jitter mode  warning,critical, ex. 40.000ms,50.000ms , unit in ms "));
-        printf(" %s\n", "-M");
+        printf(" %s\n", "-M, --mos-mode-thresholds=MOS_MODE_THRESHOLD");
         printf("    %s\n", _("MOS mode, between 0 and 4.4  warning,critical, ex. 3.5,3.0"));
-        printf(" %s\n", "-S");
+        printf(" %s\n", "-S, --score-mode-thresholds=SCORE_MODE_THRESHOLD");
         printf("    %s\n", _("score  mode, max value 100  warning,critical, ex. 80,70 "));
-        printf(" %s\n", "-O");
-        printf("    %s\n", _("detect out of order ICMP packts "));
-        printf(" %s\n", "-H");
-        printf("    %s\n", _("specify a target"));
-        printf(" %s\n", "-s");
-        printf("    %s\n", _("specify a source IP address or device name"));
-        printf(" %s\n", "-n");
-        printf("    %s", _("number of packets to send (currently "));
-        printf("%u)\n", packets);
-        printf(" %s\n", "-p");
-        printf("    %s", _("number of packets to send (currently "));
-        printf("%u)\n", packets);
+        printf(" %s\n", "-O, --out-of-order-packets");
+        printf(
+                "    %s\n",
+                _("detect out of order ICMP packets, if such packets are found, the result is CRITICAL"));
+        printf(" %s\n", "[-n|-p], --number-of-packets=NUMBER_OF_PACKETS");
+        printf("    %s", _("number of packets to send (default "));
+        printf("%u)\n", DEFAULT_NUMBER_OF_PACKETS);
+
         printf(" %s\n", "-i");
-        printf("    %s", _("max packet interval (currently "));
-        printf("%0.3fms)\n", (float)pkt_interval / 1000);
-        printf(" %s\n", "-I");
-        printf("    %s", _("max target interval (currently "));
-        printf("%0.3fms)\n", (float)target_interval / 1000);
-        printf(" %s\n", "-m");
-        printf("    %s", _("number of alive hosts required for success"));
+        printf("    %s", _("[DEPRECATED] packet interval (default "));
+        printf("%0.3fms)\n", (float)DEFAULT_PKT_INTERVAL / 1000);
+        printf("    %s", _("This option was never actually used and is just mentioned here for "
+                                           "historical purposes\n"));
+
+        printf(" %s\n", "-I, --target-interval=TARGET_INTERVAL");
+        printf("    %s%0.3fms)\n    The time interval to wait in between one target and the next\n",
+                   _("max target interval (default "), (float)DEFAULT_TARGET_INTERVAL / 1000);
+        printf(" %s\n", "-m, --minimal-host-alive=MIN_ALIVE");
+        printf("    %s", _("number of alive hosts required for success. If less than MIN_ALIVE hosts "
+                                           "are OK, but MIN_ALIVE hosts are WARNING or OK, WARNING, else CRITICAL"));
         printf("\n");
-        printf(" %s\n", "-l");
-        printf("    %s", _("TTL on outgoing packets (currently "));
-        printf("%u)\n", ttl);
-        printf(" %s\n", "-t");
-        printf("    %s", _("timeout value (seconds, currently  "));
-        printf("%u)\n", timeout);
-        printf(" %s\n", "-b");
-        printf("    %s\n", _("Number of icmp data bytes to send"));
-        printf("    %s %u + %d)\n", _("Packet size will be data bytes + icmp header (currently"), icmp_data_size, ICMP_MINLEN);
-        printf(" %s\n", "-v");
-        printf("    %s\n", _("verbose"));
+        printf(" %s\n", "-l, --outgoing-ttl=OUTGOING_TTL");
+        printf("    %s", _("TTL on outgoing packets (default "));
+        printf("%u)\n", DEFAULT_TTL);
+        printf(" %s\n", "-b, --size=SIZE");
+        printf("    %s\n", _("Number of icmp ping data bytes to send"));
+        printf("    %s %lu + %d)\n", _("Packet size will be SIZE + icmp header (default"),
+                   DEFAULT_PING_DATA_SIZE, ICMP_MINLEN);
+        printf(" %s\n", "-v, --verbose");
+        printf("    %s\n", _("Verbosity, can be given multiple times (for debugging)"));
+
+        printf(UT_OUTPUT_FORMAT);
+
         printf("\n");
         printf("%s\n", _("Notes:"));
         printf(" %s\n", _("If none of R,P,J,M,S or O is specified, default behavior is -R -P"));
-        printf(" %s\n", _("The -H switch is optional. Naming a host (or several) to check is not."));
+        printf(" %s\n", _("Naming a host (or several) to check is not."));
         printf("\n");
         printf(" %s\n", _("Threshold format for -w and -c is 200.25,60% for 200.25 msec RTA and 60%"));
         printf(" %s\n", _("packet loss.  The default values should work well for most users."));
-        printf(" %s\n", _("You can specify different RTA factors using the standardized abbreviations"));
-        printf(" %s\n", _("us (microseconds), ms (milliseconds, default) or just plain s for seconds."));
-        /* -d not yet implemented */
-        /*  printf ("%s\n", _("Threshold format for -d is warn,crit.  12,14 means WARNING if >= 12 hops"));
-                        printf ("%s\n", _("are spent and CRITICAL if >= 14 hops are spent."));
-                        printf ("%s\n\n", _("NOTE: Some systems decrease TTL when forming ICMP_ECHOREPLY, others do not."));*/
-        printf("\n");
-        printf(" %s\n", _("The -v switch can be specified several times for increased verbosity."));
-        /*  printf ("%s\n", _("Long options are currently unsupported."));
-                        printf ("%s\n", _("Options marked with * require an argument"));
-                        */
+        printf(" %s\n",
+                   _("You can specify different RTA factors using the standardized abbreviations"));
+        printf(" %s\n",
+                   _("us (microseconds), ms (milliseconds, default) or just plain s for seconds."));
 
         printf(UT_SUPPORT);
 }
 
 void print_usage(void) {
         printf("%s\n", _("Usage:"));
-        printf(" %s [options] [-H] host1 host2 hostN\n", progname);
+        printf(" %s [options] [-H host1 [-H host2 [-H hostN]]]\n", progname);
+}
+
+static add_host_wrapper add_host(char *arg, check_icmp_execution_mode mode,
+                                                                 sa_family_t enforced_proto) {
+        if (debug) {
+                printf("add_host called with argument %s\n", arg);
+        }
+
+        add_host_wrapper result = {
+                .error_code = OK,
+                .host = check_icmp_target_container_init(),
+                .has_v4 = false,
+                .has_v6 = false,
+        };
+
+        add_target_wrapper targets = add_target(arg, mode, enforced_proto);
+
+        if (targets.error_code != OK) {
+                result.error_code = targets.error_code;
+                return result;
+        }
+
+        result.has_v4 = targets.has_v4;
+        result.has_v6 = targets.has_v6;
+
+        result.host = check_icmp_target_container_init();
+
+        result.host.name = strdup(arg);
+        result.host.target_list = targets.targets;
+        result.host.number_of_targets = targets.number_of_targets;
+
+        return result;
+}
+
+mp_subcheck evaluate_target(ping_target target, check_icmp_mode_switches modes,
+                                                        check_icmp_threshold warn, check_icmp_threshold crit) {
+        /* if no new mode selected, use old schema */
+        if (!modes.rta_mode && !modes.pl_mode && !modes.jitter_mode && !modes.score_mode &&
+                !modes.mos_mode && !modes.order_mode) {
+                modes.rta_mode = true;
+                modes.pl_mode = true;
+        }
+
+        mp_subcheck result = mp_subcheck_init();
+        result = mp_set_subcheck_default_state(result, STATE_OK);
+
+        char address[INET6_ADDRSTRLEN];
+        memset(address, 0, INET6_ADDRSTRLEN);
+        parse_address(&target.address, address, sizeof(address));
+
+        xasprintf(&result.output, "%s", address);
+
+        double packet_loss;
+        time_t rta;
+        if (!target.icmp_recv) {
+                /* rta 0 is of course not entirely correct, but will still show up
+                 * conspicuously as missing entries in perfparse and cacti */
+                packet_loss = 100;
+                rta = 0;
+                result = mp_set_subcheck_state(result, STATE_CRITICAL);
+                /* up the down counter if not already counted */
+
+                if (target.flags & FLAG_LOST_CAUSE) {
+                        xasprintf(&result.output, "%s: %s @ %s", result.output,
+                                          get_icmp_error_msg(target.icmp_type, target.icmp_code), address);
+                } else { /* not marked as lost cause, so we have no flags for it */
+                        xasprintf(&result.output, "%s", result.output);
+                }
+        } else {
+                packet_loss =
+                        (unsigned char)((target.icmp_sent - target.icmp_recv) * 100) / target.icmp_sent;
+                rta = target.time_waited / target.icmp_recv;
+        }
+
+        double EffectiveLatency;
+        double mos;   /* Mean opinion score */
+        double score; /* score */
+
+        if (target.icmp_recv > 1) {
+                /*
+                 * This algorithm is probably pretty much blindly copied from
+                 * locations like this one:
+                 * https://www.slac.stanford.edu/comp/net/wan-mon/tutorial.html#mos It calculates a MOS
+                 * value (range of 1 to 5, where 1 is bad and 5 really good). According to some quick
+                 * research MOS originates from the Audio/Video transport network area. Whether it can
+                 * and should be computed from ICMP data, I can not say.
+                 *
+                 * Anyway the basic idea is to map a value "R" with a range of 0-100 to the MOS value
+                 *
+                 * MOS stands likely for Mean Opinion Score (
+                 * https://en.wikipedia.org/wiki/Mean_Opinion_Score )
+                 *
+                 * More links:
+                 * - https://confluence.slac.stanford.edu/display/IEPM/MOS
+                 */
+                target.jitter = (target.jitter / (target.icmp_recv - 1) / 1000);
+
+                /*
+                 * Take the average round trip latency (in milliseconds), add
+                 * round trip jitter, but double the impact to latency
+                 * then add 10 for protocol latencies (in milliseconds).
+                 */
+                EffectiveLatency = ((double)rta / 1000) + target.jitter * 2 + 10;
+
+                double R;
+                if (EffectiveLatency < 160) {
+                        R = 93.2 - (EffectiveLatency / 40);
+                } else {
+                        R = 93.2 - ((EffectiveLatency - 120) / 10);
+                }
+
+                // Now, let us deduct 2.5 R values per percentage of packet loss (i.e. a
+                // loss of 5% will be entered as 5).
+                R = R - (packet_loss * 2.5);
+
+                if (R < 0) {
+                        R = 0;
+                }
+
+                score = R;
+                mos = 1 + ((0.035) * R) + ((.000007) * R * (R - 60) * (100 - R));
+        } else {
+                target.jitter = 0;
+                target.jitter_min = 0;
+                target.jitter_max = 0;
+                mos = 0;
+        }
+
+        /* Check which mode is on and do the warn / Crit stuff */
+        if (modes.rta_mode) {
+                mp_subcheck sc_rta = mp_subcheck_init();
+                sc_rta = mp_set_subcheck_default_state(sc_rta, STATE_OK);
+                xasprintf(&sc_rta.output, "rta %0.3fms", (double)rta / 1000);
+
+                if (rta >= crit.rta) {
+                        sc_rta = mp_set_subcheck_state(sc_rta, STATE_CRITICAL);
+                        xasprintf(&sc_rta.output, "%s >= %0.3fms", sc_rta.output, (double)crit.rta / 1000);
+                } else if (rta >= warn.rta) {
+                        sc_rta = mp_set_subcheck_state(sc_rta, STATE_WARNING);
+                        xasprintf(&sc_rta.output, "%s >= %0.3fms", sc_rta.output, (double)warn.rta / 1000);
+                }
+
+                if (packet_loss < 100) {
+                        mp_perfdata pd_rta = perfdata_init();
+                        xasprintf(&pd_rta.label, "%srta", address);
+                        pd_rta.uom = strdup("ms");
+                        pd_rta.value = mp_create_pd_value(rta / 1000);
+                        pd_rta.min = mp_create_pd_value(0);
+
+                        pd_rta.warn = mp_range_set_end(pd_rta.warn, mp_create_pd_value(warn.rta));
+                        pd_rta.crit = mp_range_set_end(pd_rta.crit, mp_create_pd_value(crit.rta));
+                        mp_add_perfdata_to_subcheck(&sc_rta, pd_rta);
+
+                        mp_perfdata pd_rt_min = perfdata_init();
+                        xasprintf(&pd_rt_min.label, "%srtmin", address);
+                        pd_rt_min.value = mp_create_pd_value(target.rtmin / 1000);
+                        pd_rt_min.uom = strdup("ms");
+                        mp_add_perfdata_to_subcheck(&sc_rta, pd_rt_min);
+
+                        mp_perfdata pd_rt_max = perfdata_init();
+                        xasprintf(&pd_rt_max.label, "%srtmax", address);
+                        pd_rt_max.value = mp_create_pd_value(target.rtmax / 1000);
+                        pd_rt_max.uom = strdup("ms");
+                        mp_add_perfdata_to_subcheck(&sc_rta, pd_rt_max);
+                }
+
+                mp_add_subcheck_to_subcheck(&result, sc_rta);
+        }
+
+        if (modes.pl_mode) {
+                mp_subcheck sc_pl = mp_subcheck_init();
+                sc_pl = mp_set_subcheck_default_state(sc_pl, STATE_OK);
+                xasprintf(&sc_pl.output, "packet loss %.1f%%", packet_loss);
+
+                if (packet_loss >= crit.pl) {
+                        sc_pl = mp_set_subcheck_state(sc_pl, STATE_CRITICAL);
+                        xasprintf(&sc_pl.output, "%s >= %u%%", sc_pl.output, crit.pl);
+                } else if (packet_loss >= warn.pl) {
+                        sc_pl = mp_set_subcheck_state(sc_pl, STATE_WARNING);
+                        xasprintf(&sc_pl.output, "%s >= %u%%", sc_pl.output, warn.pl);
+                }
+
+                mp_perfdata pd_pl = perfdata_init();
+                xasprintf(&pd_pl.label, "%spl", address);
+                pd_pl.uom = strdup("%");
+
+                pd_pl.warn = mp_range_set_end(pd_pl.warn, mp_create_pd_value(warn.pl));
+                pd_pl.crit = mp_range_set_end(pd_pl.crit, mp_create_pd_value(crit.pl));
+                pd_pl.value = mp_create_pd_value(packet_loss);
+
+                mp_add_perfdata_to_subcheck(&sc_pl, pd_pl);
+
+                mp_add_subcheck_to_subcheck(&result, sc_pl);
+        }
+
+        if (modes.jitter_mode) {
+                mp_subcheck sc_jitter = mp_subcheck_init();
+                sc_jitter = mp_set_subcheck_default_state(sc_jitter, STATE_OK);
+                xasprintf(&sc_jitter.output, "jitter %0.3fms", target.jitter);
+
+                if (target.jitter >= crit.jitter) {
+                        sc_jitter = mp_set_subcheck_state(sc_jitter, STATE_CRITICAL);
+                        xasprintf(&sc_jitter.output, "%s >= %0.3fms", sc_jitter.output, crit.jitter);
+                } else if (target.jitter >= warn.jitter) {
+                        sc_jitter = mp_set_subcheck_state(sc_jitter, STATE_WARNING);
+                        xasprintf(&sc_jitter.output, "%s >= %0.3fms", sc_jitter.output, warn.jitter);
+                }
+
+                if (packet_loss < 100) {
+                        mp_perfdata pd_jitter = perfdata_init();
+                        pd_jitter.uom = strdup("ms");
+                        xasprintf(&pd_jitter.label, "%sjitter_avg", address);
+                        pd_jitter.value = mp_create_pd_value(target.jitter);
+                        pd_jitter.warn = mp_range_set_end(pd_jitter.warn, mp_create_pd_value(warn.jitter));
+                        pd_jitter.crit = mp_range_set_end(pd_jitter.crit, mp_create_pd_value(crit.jitter));
+                        mp_add_perfdata_to_subcheck(&sc_jitter, pd_jitter);
+
+                        mp_perfdata pd_jitter_min = perfdata_init();
+                        pd_jitter_min.uom = strdup("ms");
+                        xasprintf(&pd_jitter_min.label, "%sjitter_min", address);
+                        pd_jitter_min.value = mp_create_pd_value(target.jitter_min);
+                        mp_add_perfdata_to_subcheck(&sc_jitter, pd_jitter_min);
+
+                        mp_perfdata pd_jitter_max = perfdata_init();
+                        pd_jitter_max.uom = strdup("ms");
+                        xasprintf(&pd_jitter_max.label, "%sjitter_max", address);
+                        pd_jitter_max.value = mp_create_pd_value(target.jitter_max);
+                        mp_add_perfdata_to_subcheck(&sc_jitter, pd_jitter_max);
+                }
+                mp_add_subcheck_to_subcheck(&result, sc_jitter);
+        }
+
+        if (modes.mos_mode) {
+                mp_subcheck sc_mos = mp_subcheck_init();
+                sc_mos = mp_set_subcheck_default_state(sc_mos, STATE_OK);
+                xasprintf(&sc_mos.output, "MOS %0.1f", mos);
+
+                if (mos <= crit.mos) {
+                        sc_mos = mp_set_subcheck_state(sc_mos, STATE_CRITICAL);
+                        xasprintf(&sc_mos.output, "%s <= %0.1f", sc_mos.output, crit.mos);
+                } else if (mos <= warn.mos) {
+                        sc_mos = mp_set_subcheck_state(sc_mos, STATE_WARNING);
+                        xasprintf(&sc_mos.output, "%s <= %0.1f", sc_mos.output, warn.mos);
+                }
+
+                if (packet_loss < 100) {
+                        mp_perfdata pd_mos = perfdata_init();
+                        xasprintf(&pd_mos.label, "%smos", address);
+                        pd_mos.value = mp_create_pd_value(mos);
+                        pd_mos.warn = mp_range_set_end(pd_mos.warn, mp_create_pd_value(warn.mos));
+                        pd_mos.crit = mp_range_set_end(pd_mos.crit, mp_create_pd_value(crit.mos));
+                        pd_mos.min = mp_create_pd_value(0); // MOS starts at 0
+                        pd_mos.max = mp_create_pd_value(5); // MOS max is 5, by definition
+                        mp_add_perfdata_to_subcheck(&sc_mos, pd_mos);
+                }
+                mp_add_subcheck_to_subcheck(&result, sc_mos);
+        }
+
+        if (modes.score_mode) {
+                mp_subcheck sc_score = mp_subcheck_init();
+                sc_score = mp_set_subcheck_default_state(sc_score, STATE_OK);
+                xasprintf(&sc_score.output, "Score %f", score);
+
+                if (score <= crit.score) {
+                        sc_score = mp_set_subcheck_state(sc_score, STATE_CRITICAL);
+                        xasprintf(&sc_score.output, "%s <= %f", sc_score.output, crit.score);
+                } else if (score <= warn.score) {
+                        sc_score = mp_set_subcheck_state(sc_score, STATE_WARNING);
+                        xasprintf(&sc_score.output, "%s <= %f", sc_score.output, warn.score);
+                }
+
+                if (packet_loss < 100) {
+                        mp_perfdata pd_score = perfdata_init();
+                        xasprintf(&pd_score.label, "%sscore", address);
+                        pd_score.value = mp_create_pd_value(score);
+                        pd_score.warn = mp_range_set_end(pd_score.warn, mp_create_pd_value(warn.score));
+                        pd_score.crit = mp_range_set_end(pd_score.crit, mp_create_pd_value(crit.score));
+                        pd_score.min = mp_create_pd_value(0);
+                        pd_score.max = mp_create_pd_value(100);
+                        mp_add_perfdata_to_subcheck(&sc_score, pd_score);
+                }
+
+                mp_add_subcheck_to_subcheck(&result, sc_score);
+        }
+
+        if (modes.order_mode) {
+                mp_subcheck sc_order = mp_subcheck_init();
+                sc_order = mp_set_subcheck_default_state(sc_order, STATE_OK);
+
+                if (target.found_out_of_order_packets) {
+                        mp_set_subcheck_state(sc_order, STATE_CRITICAL);
+                        xasprintf(&sc_order.output, "Packets out of order");
+                } else {
+                        xasprintf(&sc_order.output, "Packets in order");
+                }
+
+                mp_add_subcheck_to_subcheck(&result, sc_order);
+        }
+
+        return result;
+}
+
+evaluate_host_wrapper evaluate_host(check_icmp_target_container host,
+                                                                        check_icmp_mode_switches modes, check_icmp_threshold warn,
+                                                                        check_icmp_threshold crit) {
+        evaluate_host_wrapper result = {
+                .targets_warn = 0,
+                .targets_ok = 0,
+                .sc_host = mp_subcheck_init(),
+        };
+        result.sc_host = mp_set_subcheck_default_state(result.sc_host, STATE_OK);
+
+        result.sc_host.output = strdup(host.name);
+
+        ping_target *target = host.target_list;
+        for (unsigned int i = 0; i < host.number_of_targets; i++) {
+                mp_subcheck sc_target = evaluate_target(*target, modes, warn, crit);
+
+                mp_state_enum target_state = mp_compute_subcheck_state(sc_target);
+
+                if (target_state == STATE_WARNING) {
+                        result.targets_warn++;
+                } else if (target_state == STATE_OK) {
+                        result.targets_ok++;
+                }
+                mp_add_subcheck_to_subcheck(&result.sc_host, sc_target);
+
+                target = target->next;
+        }
+
+        return result;
 }
diff --git a/plugins-root/check_icmp.d/check_icmp_helpers.c b/plugins-root/check_icmp.d/check_icmp_helpers.c
new file mode 100644
index 00000000..d56fbd8b
--- /dev/null
+++ b/plugins-root/check_icmp.d/check_icmp_helpers.c
@@ -0,0 +1,134 @@
+#include "./config.h"
+#include <math.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include "./check_icmp_helpers.h"
+#include "../../plugins/netutils.h"
+
+// timeout as a global variable to make it available to the timeout handler
+unsigned int timeout = DEFAULT_TIMEOUT;
+
+check_icmp_config check_icmp_config_init() {
+        check_icmp_config tmp = {
+                .modes =
+                        {
+                                .order_mode = false,
+                                .mos_mode = false,
+                                .rta_mode = false,
+                                .pl_mode = false,
+                                .jitter_mode = false,
+                                .score_mode = false,
+                        },
+
+                .min_hosts_alive = -1,
+                .crit = {.pl = DEFAULT_CRIT_PL,
+                                 .rta = DEFAULT_CRIT_RTA,
+                                 .jitter = 50.0,
+                                 .mos = 3.0,
+                                 .score = 70.0},
+                .warn = {.pl = DEFAULT_WARN_PL,
+                                 .rta = DEFAULT_WARN_RTA,
+                                 .jitter = 40.0,
+                                 .mos = 3.5,
+                                 .score = 80.0},
+
+                .ttl = DEFAULT_TTL,
+                .icmp_data_size = DEFAULT_PING_DATA_SIZE,
+                .target_interval = 0,
+                .number_of_packets = DEFAULT_NUMBER_OF_PACKETS,
+
+                .source_ip = NULL,
+                .need_v4 = false,
+                .need_v6 = false,
+
+                .sender_id = 0,
+
+                .mode = MODE_RTA,
+
+                .number_of_targets = 0,
+                .targets = NULL,
+
+                .number_of_hosts = 0,
+                .hosts = NULL,
+
+                .output_format_is_set = false,
+        };
+        return tmp;
+}
+
+ping_target ping_target_init() {
+        ping_target tmp = {
+                .rtmin = INFINITY,
+
+                .jitter_min = INFINITY,
+
+                .found_out_of_order_packets = false,
+        };
+
+        return tmp;
+}
+
+check_icmp_state check_icmp_state_init() {
+        check_icmp_state tmp = {.icmp_sent = 0, .icmp_lost = 0, .icmp_recv = 0, .targets_down = 0};
+
+        return tmp;
+}
+
+ping_target_create_wrapper ping_target_create(struct sockaddr_storage address) {
+        ping_target_create_wrapper result = {
+                .errorcode = OK,
+        };
+
+        struct sockaddr_storage *tmp_addr = &address;
+
+        /* disregard obviously stupid addresses
+         * (I didn't find an ipv6 equivalent to INADDR_NONE) */
+        if (((tmp_addr->ss_family == AF_INET &&
+                  (((struct sockaddr_in *)tmp_addr)->sin_addr.s_addr == INADDR_NONE ||
+                   ((struct sockaddr_in *)tmp_addr)->sin_addr.s_addr == INADDR_ANY))) ||
+                (tmp_addr->ss_family == AF_INET6 &&
+                 (((struct sockaddr_in6 *)tmp_addr)->sin6_addr.s6_addr == in6addr_any.s6_addr))) {
+                result.errorcode = ERROR;
+                return result;
+        }
+
+        /* add the fresh ip */
+        ping_target target = ping_target_init();
+
+        /* fill out the sockaddr_storage struct */
+        target.address = address;
+
+        result.host = target;
+
+        return result;
+}
+
+check_icmp_target_container check_icmp_target_container_init() {
+        check_icmp_target_container tmp = {
+                .name = NULL,
+                .number_of_targets = 0,
+                .target_list = NULL,
+        };
+        return tmp;
+}
+
+unsigned int ping_target_list_append(ping_target *list, ping_target *elem) {
+        if (elem == NULL || list == NULL) {
+                return 0;
+        }
+
+        while (list->next != NULL) {
+                list = list->next;
+        }
+
+        list->next = elem;
+
+        unsigned int result = 1;
+
+        while (elem->next != NULL) {
+                result++;
+                elem = elem->next;
+        }
+
+        return result;
+}
diff --git a/plugins-root/check_icmp.d/check_icmp_helpers.h b/plugins-root/check_icmp.d/check_icmp_helpers.h
new file mode 100644
index 00000000..dc6ea40b
--- /dev/null
+++ b/plugins-root/check_icmp.d/check_icmp_helpers.h
@@ -0,0 +1,68 @@
+#pragma once
+
+#include "../../lib/states.h"
+#include <netinet/in_systm.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip6.h>
+#include <netinet/ip_icmp.h>
+#include <netinet/icmp6.h>
+#include <arpa/inet.h>
+
+typedef struct ping_target {
+        unsigned short id; /* id in **table, and icmp pkts */
+        char *msg;         /* icmp error message, if any */
+
+        struct sockaddr_storage address;              /* the address of this host */
+        struct sockaddr_storage error_addr;           /* stores address of error replies */
+        time_t time_waited;                           /* total time waited, in usecs */
+        unsigned int icmp_sent, icmp_recv, icmp_lost; /* counters */
+        unsigned char icmp_type, icmp_code;           /* type and code from errors */
+        unsigned short flags;                         /* control/status flags */
+
+        double rtmax; /* max rtt */
+        double rtmin; /* min rtt */
+
+        double jitter;     /* measured jitter */
+        double jitter_max; /* jitter rtt maximum */
+        double jitter_min; /* jitter rtt minimum */
+
+        time_t last_tdiff;
+        unsigned int last_icmp_seq; /* Last ICMP_SEQ to check out of order pkts */
+
+        bool found_out_of_order_packets;
+
+        struct ping_target *next;
+} ping_target;
+
+ping_target ping_target_init();
+
+typedef struct {
+        char *name;
+        ping_target *target_list;
+        unsigned int number_of_targets;
+} check_icmp_target_container;
+
+check_icmp_target_container check_icmp_target_container_init();
+
+typedef struct {
+        unsigned int icmp_sent;
+        unsigned int icmp_recv;
+        unsigned int icmp_lost;
+        unsigned short targets_down;
+} check_icmp_state;
+
+check_icmp_state check_icmp_state_init();
+
+typedef struct {
+        int errorcode;
+        ping_target host;
+} ping_target_create_wrapper;
+
+typedef struct {
+        int socket4;
+        int socket6;
+} check_icmp_socket_set;
+
+ping_target_create_wrapper ping_target_create(struct sockaddr_storage address);
+unsigned int ping_target_list_append(ping_target *list, ping_target *elem);
diff --git a/plugins-root/check_icmp.d/config.h b/plugins-root/check_icmp.d/config.h
new file mode 100644
index 00000000..c348bef5
--- /dev/null
+++ b/plugins-root/check_icmp.d/config.h
@@ -0,0 +1,115 @@
+#pragma once
+
+#include "../../config.h"
+#include "../../lib/states.h"
+#include <stddef.h>
+#include <netinet/in_systm.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip6.h>
+#include <netinet/ip_icmp.h>
+#include <netinet/icmp6.h>
+#include <arpa/inet.h>
+#include <stdint.h>
+#include "./check_icmp_helpers.h"
+#include "output.h"
+
+/* threshold structure. all values are maximum allowed, exclusive */
+typedef struct {
+        unsigned char pl; /* max allowed packet loss in percent */
+        time_t rta;       /* roundtrip time average, microseconds */
+        double jitter;    /* jitter time average, microseconds */
+        double mos;       /* MOS */
+        double score;     /* Score */
+} check_icmp_threshold;
+
+/* the different modes of this program are as follows:
+ * MODE_RTA: send all packets no matter what (mimic check_icmp and check_ping)
+ * MODE_HOSTCHECK: Return immediately upon any sign of life
+ *                 In addition, sends packets to ALL addresses assigned
+ *                 to this host (as returned by gethostbyname() or
+ *                 gethostbyaddr() and expects one host only to be checked at
+ *                 a time.  Therefore, any packet response what so ever will
+ *                 count as a sign of life, even when received outside
+ *                 crit.rta limit. Do not misspell any additional IP's.
+ * MODE_ALL:  Requires packets from ALL requested IP to return OK (default).
+ * MODE_ICMP: Default Mode
+ */
+typedef enum {
+        MODE_RTA,
+        MODE_HOSTCHECK,
+        MODE_ALL,
+        MODE_ICMP,
+} check_icmp_execution_mode;
+
+typedef struct {
+        bool order_mode;
+        bool mos_mode;
+        bool rta_mode;
+        bool pl_mode;
+        bool jitter_mode;
+        bool score_mode;
+} check_icmp_mode_switches;
+
+typedef struct {
+        check_icmp_mode_switches modes;
+
+        int min_hosts_alive;
+        check_icmp_threshold crit;
+        check_icmp_threshold warn;
+
+        unsigned long ttl;
+        unsigned short icmp_data_size;
+        time_t target_interval;
+        unsigned short number_of_packets;
+
+        char *source_ip;
+        bool need_v4;
+        bool need_v6;
+
+        uint16_t sender_id; // PID of the main process, which is used as an ID in packets
+
+        check_icmp_execution_mode mode;
+
+        unsigned short number_of_targets;
+        ping_target *targets;
+
+        unsigned short number_of_hosts;
+        check_icmp_target_container *hosts;
+
+        mp_output_format output_format;
+        bool output_format_is_set;
+} check_icmp_config;
+
+check_icmp_config check_icmp_config_init();
+
+/* the data structure */
+typedef struct icmp_ping_data {
+        struct timeval stime; /* timestamp (saved in protocol struct as well) */
+        unsigned short ping_id;
+} icmp_ping_data;
+
+#define MAX_IP_PKT_SIZE        65536 /* (theoretical) max IP packet size */
+#define IP_HDR_SIZE            20
+#define MAX_PING_DATA          (MAX_IP_PKT_SIZE - IP_HDR_SIZE - ICMP_MINLEN)
+#define MIN_PING_DATA_SIZE     sizeof(struct icmp_ping_data)
+#define DEFAULT_PING_DATA_SIZE (MIN_PING_DATA_SIZE + 44)
+
+/* 80 msec packet interval by default */
+// DEPRECATED, remove when removing the option
+#define DEFAULT_PKT_INTERVAL    80000 
+
+#define DEFAULT_TARGET_INTERVAL 0
+
+#define DEFAULT_WARN_RTA 200000
+#define DEFAULT_CRIT_RTA 500000
+#define DEFAULT_WARN_PL  40
+#define DEFAULT_CRIT_PL  80
+
+#define DEFAULT_TIMEOUT 10
+#define DEFAULT_TTL     64
+
+#define DEFAULT_NUMBER_OF_PACKETS 5
+
+#define PACKET_BACKOFF_FACTOR 1.5
+#define TARGET_BACKOFF_FACTOR 1.5
diff --git a/plugins-root/t/check_dhcp.t b/plugins-root/t/check_dhcp.t
index ce627736..70392154 100644
--- a/plugins-root/t/check_dhcp.t
+++ b/plugins-root/t/check_dhcp.t
@@ -12,14 +12,14 @@ my $allow_sudo = getTestParameter( "NP_ALLOW_SUDO",
                                    "no" );
 
 if ($allow_sudo eq "yes" or $> == 0) {
-    plan tests => 6;
+    plan tests => 7;
 } else {
     plan skip_all => "Need sudo to test check_dhcp";
 }
 my $sudo = $> == 0 ? '' : 'sudo';
 
-my $successOutput = '/OK: Received \d+ DHCPOFFER\(s\), \d+ of 1 requested servers responded, max lease time = \d+ sec\./';
-my $failureOutput = '/CRITICAL: (No DHCPOFFERs were received|Received \d+ DHCPOFFER\(s\), 0 of 1 requested servers responded, max lease time = \d+ sec\.)/';
+my $successOutput = '/Received \d+ DHCPOFFER(s)*, max lease time = \d+ seconds/';
+my $failureOutput = '/(No DHCPOFFERs were received|Received \d+ DHCPOFFER\(s\), 0 of 1 requested servers responded, max lease time = \d+ sec\.)/';
 my $invalidOutput = '/Invalid hostname/';
 
 my $host_responsive    = getTestParameter( "NP_HOST_DHCP_RESPONSIVE",
@@ -34,6 +34,8 @@ my $hostname_invalid   = getTestParameter( "NP_HOSTNAME_INVALID",
                                            "An invalid (not known to DNS) hostname",
                                            "nosuchhost" );
 
+my $output_format = "--output-format mp-test-json";
+
 # try to determince interface
 my $interface = '';
 
@@ -49,19 +51,21 @@ my $res;
 SKIP: {
     skip('need responsive test host', 2) unless $host_responsive;
     $res = NPTest->testCmd(
-        "$sudo ./check_dhcp $interface -u -s $host_responsive"
+        "$sudo ./check_dhcp $interface -u -s $host_responsive $output_format"
     );
-    is( $res->return_code, 0, "Syntax ok" );
-    like( $res->output, $successOutput, "Output OK" );
+    is( $res->return_code, 0, "with JSON test format result should always be OK" );
+    like( $res->{'mp_test_result'}->{'state'}, "/OK/", "Output OK" );
+    like( $res->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $successOutput, "Output OK" );
 };
 
 SKIP: {
     skip('need nonresponsive test host', 2) unless $host_nonresponsive;
     $res = NPTest->testCmd(
-        "$sudo ./check_dhcp $interface -u -s $host_nonresponsive"
+        "$sudo ./check_dhcp $interface -u -s $host_nonresponsive $output_format"
     );
-    is( $res->return_code, 2, "Exit code - host nonresponsive" );
-    like( $res->output, $failureOutput, "Output OK" );
+    is( $res->return_code, 0, "with JSON test format result should always be OK" );
+    like( $res->{'mp_test_result'}->{'state'}, "/CRITICAL/", "Exit code - host nonresponsive" );
+    like( $res->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $failureOutput, "Output OK" );
 };
 
 SKIP: {
@@ -69,6 +73,6 @@ SKIP: {
     $res = NPTest->testCmd(
         "$sudo ./check_dhcp $interface -u -s $hostname_invalid"
     );
-    is( $res->return_code, 3, "Exit code - host invalid" );
+    is( $res->return_code, 3, "invalid hostname/address should return UNKNOWN" );
     like( $res->output, $invalidOutput, "Output OK" );
 };
diff --git a/plugins-root/t/check_icmp.t b/plugins-root/t/check_icmp.t
index de1d88d2..d414c3c7 100644
--- a/plugins-root/t/check_icmp.t
+++ b/plugins-root/t/check_icmp.t
@@ -12,15 +12,12 @@ my $allow_sudo = getTestParameter( "NP_ALLOW_SUDO",
         "no" );
 
 if ($allow_sudo eq "yes" or $> == 0) {
-        plan tests => 40;
+        plan tests => 17;
 } else {
         plan skip_all => "Need sudo to test check_icmp";
 }
 my $sudo = $> == 0 ? '' : 'sudo';
 
-my $successOutput = '/OK - .*? rta (?:[\d\.]+ms)|(?:nan), lost \d+%/';
-my $failureOutput = '/(WARNING|CRITICAL) - .*? rta (?:[\d\.]+ms > [\d\.]+ms|nan)/';
-
 my $host_responsive    = getTestParameter( "NP_HOST_RESPONSIVE",
                                 "The hostname of system responsive to network requests",
                                 "localhost" );
@@ -36,108 +33,85 @@ my $hostname_invalid   = getTestParameter( "NP_HOSTNAME_INVALID",
 my $res;
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -w 10000ms,100% -c 10000ms,100%"
+        "$sudo ./check_icmp -H $host_responsive -w 100ms,100% -c 100ms,100%"
         );
 is( $res->return_code, 0, "Syntax ok" );
-like( $res->output, $successOutput, "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -w 0ms,0% -c 10000ms,100%"
+        "$sudo ./check_icmp -H $host_responsive -w 0ms,0% -c 100ms,100%"
         );
 is( $res->return_code, 1, "Syntax ok, with forced warning" );
-like( $res->output, $failureOutput, "Output OK" );
 
 $res = NPTest->testCmd(
         "$sudo ./check_icmp -H $host_responsive -w 0,0% -c 0,0%"
         );
 is( $res->return_code, 2, "Syntax ok, with forced critical" );
-like( $res->output, $failureOutput, "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -t 2"
+        "$sudo ./check_icmp -H $host_nonresponsive -w 100ms,100% -c 100ms,100%"
         );
 is( $res->return_code, 2, "Timeout - host nonresponsive" );
-like( $res->output, '/pl=100%/', "Error contains 'pl=100%' string (for 100% packet loss)" );
-like( $res->output, '/rta=U/', "Error contains 'rta=U' string" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -w 10000ms,100% -c 10000ms,100%"
+        "$sudo ./check_icmp -w 100ms,100% -c 100ms,100%"
         );
 is( $res->return_code, 3, "No hostname" );
-like( $res->output, '/No hosts to check/', "Output with appropriate error message");
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -n 1 -m 0 -t 2"
+        "$sudo ./check_icmp -H $host_nonresponsive -w 100ms,100% -c 100ms,100% -n 1 -m 0"
         );
 is( $res->return_code, 0, "One host nonresponsive - zero required" );
-like( $res->output, $successOutput, "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -n 1 -m 1 -t 2"
+        "$sudo ./check_icmp -H $host_responsive -H $host_nonresponsive -w 100ms,100% -c 100ms,100% -n 1 -m 1"
         );
 is( $res->return_code, 0, "One of two host nonresponsive - one required" );
-like( $res->output, $successOutput, "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -H $host_nonresponsive -w 10000ms,100% -c 10000ms,100% -n 1 -m 2"
+        "$sudo ./check_icmp -H $host_responsive -H $host_nonresponsive -w 100ms,100% -c 100ms,100% -n 1 -m 2"
         );
 is( $res->return_code, 2, "One of two host nonresponsive - two required" );
-like( $res->output, $failureOutput, "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -s 127.0.15.15 -w 10000ms,100% -c 10000ms,100% -n 1 -m 2"
+        "$sudo ./check_icmp -H $host_responsive -s 127.0.15.15 -w 100ms,100% -c 100ms,100% -n 1"
         );
 is( $res->return_code, 0, "IPv4 source_ip accepted" );
-like( $res->output, $successOutput, "Output OK" );
 
 $res = NPTest->testCmd(
         "$sudo ./check_icmp -H $host_responsive -b 65507"
         );
 is( $res->return_code, 0, "Try max packet size" );
-like( $res->output, $successOutput, "Output OK - Didn't overflow" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -R 100,100 -n 1 -t 2"
+        "$sudo ./check_icmp -H $host_responsive -R 100,100 -n 1"
         );
 is( $res->return_code, 0, "rta works" );
-like( $res->output, $successOutput, "Output OK" );
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -P 80,90 -n 1 -t 2"
+        "$sudo ./check_icmp -H $host_responsive -P 80,90 -n 1"
         );
 is( $res->return_code, 0, "pl works" );
-like( $res->output, '/lost 0%/', "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -J 80,90 -t 2"
+        "$sudo ./check_icmp -H $host_responsive -J 80,90"
         );
 is( $res->return_code, 0, "jitter works" );
-like( $res->output, '/jitter \d/', "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -M 4,3 -t 2"
+        "$sudo ./check_icmp -H $host_responsive -M 4,3"
         );
 is( $res->return_code, 0, "mos works" );
-like( $res->output, '/MOS \d/', "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -S 80,70 -t 2"
+        "$sudo ./check_icmp -H $host_responsive -S 80,70"
         );
 is( $res->return_code, 0, "score works" );
-like( $res->output, '/Score \d/', "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -O -t 2"
+        "$sudo ./check_icmp -H $host_responsive -O"
         );
 is( $res->return_code, 0, "order works" );
-like( $res->output, '/Packets in order/', "Output OK" );
 
 $res = NPTest->testCmd(
-        "$sudo ./check_icmp -H $host_responsive -O -S 80,70 -M 4,3 -J 80,90 -P 80,90 -R 100,100 -t 2"
+        "$sudo ./check_icmp -H $host_responsive -O -S 80,70 -M 4,3 -J 80,90 -P 80,90 -R 100,100"
         );
 is( $res->return_code, 0, "order works" );
-like( $res->output, '/Packets in order/', "Output OK" );
-like( $res->output, '/Score \d/', "Output OK" );
-like( $res->output, '/MOS \d/', "Output OK" );
-like( $res->output, '/jitter \d/', "Output OK" );
-like( $res->output, '/lost 0%/', "Output OK" );
-like( $res->output, $successOutput, "Output OK" );
diff --git a/plugins/Makefile.am b/plugins/Makefile.am
index 0920adce..20a62fb2 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,36 +40,47 @@ 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 \
                          $(np_test_scripts) \
+                         negate.d \
                          check_swap.d \
                          check_ldap.d \
                          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 \
                          check_dns.d \
                          check_mrtgtraf.d \
                          check_mysql_query.d \
                          check_mrtg.d \
+                         check_ntp_peer.d \
                          check_apt.d \
                          check_pgsql.d \
                          check_procs.d \
+                         check_ping.d \
                          check_by_ssh.d \
                          check_smtp.d \
                          check_mysql.d \
                          check_ntp_time.d \
                          check_dig.d \
                          check_cluster.d \
+                         check_ups.d \
                          check_fping.d
 
 PLUGINHDRS = common.h
@@ -112,6 +123,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)
@@ -132,7 +144,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)
@@ -159,6 +170,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_fping.c b/plugins/check_fping.c
index ec7abb67..8018e06d 100644
--- a/plugins/check_fping.c
+++ b/plugins/check_fping.c
@@ -79,6 +79,24 @@ int main(int argc, char **argv) {
         server = strscpy(server, config.server_name);
 
         char *option_string = "";
+        char *fping_prog = NULL;
+
+        /* First determine if the target is dualstack or ipv6 only. */
+        bool server_is_inet6_addr = is_inet6_addr(server);
+
+        /*
+         * If the user requested -6 OR the user made no assertion and the address is v6 or dualstack
+         *   -> we use ipv6
+         * If the user requested -4 OR the user made no assertion and the address is v4 ONLY
+         *   -> we use ipv4
+         */
+        if (address_family == AF_INET6 || (address_family == AF_UNSPEC && server_is_inet6_addr)) {
+                xasprintf(&option_string, "%s-6 ", option_string);
+        } else {
+                xasprintf(&option_string, "%s-4 ", option_string);
+        }
+        fping_prog = strdup(PATH_TO_FPING);
+
         /* compose the command */
         if (config.target_timeout) {
                 xasprintf(&option_string, "%s-t %d ", option_string, config.target_timeout);
@@ -99,19 +117,26 @@ int main(int argc, char **argv) {
                 xasprintf(&option_string, "%s-R ", option_string);
         }
 
-        char *fping_prog = NULL;
-#ifdef PATH_TO_FPING6
-        if (address_family != AF_INET && is_inet6_addr(server)) {
-                fping_prog = strdup(PATH_TO_FPING6);
-        } else {
-                fping_prog = strdup(PATH_TO_FPING);
+        if (config.fwmark_set) {
+                xasprintf(&option_string, "%s--fwmark %u ", option_string, config.fwmark);
+        }
+
+        if (config.icmp_timestamp) {
+                xasprintf(&option_string, "%s--icmp-timestamp ", option_string);
+        }
+
+        if (config.check_source) {
+                xasprintf(&option_string, "%s--check-source ", option_string);
         }
-#else
-        fping_prog = strdup(PATH_TO_FPING);
-#endif
 
         char *command_line = NULL;
-        xasprintf(&command_line, "%s %s-b %d -c %d %s", fping_prog, option_string, config.packet_size, config.packet_count, server);
+
+        if (config.icmp_timestamp) {
+                // no packet size settable for ICMP timestamp
+                xasprintf(&command_line, "%s %s -c %d %s", fping_prog, option_string, config.packet_count, server);
+        } else {
+                xasprintf(&command_line, "%s %s-b %d -c %d %s", fping_prog, option_string, config.packet_size, config.packet_count, server);
+        }
 
         if (verbose) {
                 printf("%s\n", command_line);
@@ -268,13 +293,38 @@ mp_state_enum textscan(char *buf, const char *server_name, bool crta_p, double c
 
 /* process command-line arguments */
 check_fping_config_wrapper process_arguments(int argc, char **argv) {
-        static struct option longopts[] = {
-                {"hostname", required_argument, 0, 'H'}, {"sourceip", required_argument, 0, 'S'}, {"sourceif", required_argument, 0, 'I'},
-                {"critical", required_argument, 0, 'c'}, {"warning", required_argument, 0, 'w'},  {"alive", no_argument, 0, 'a'},
-                {"bytes", required_argument, 0, 'b'},    {"number", required_argument, 0, 'n'},   {"target-timeout", required_argument, 0, 'T'},
-                {"interval", required_argument, 0, 'i'}, {"verbose", no_argument, 0, 'v'},        {"version", no_argument, 0, 'V'},
-                {"help", no_argument, 0, 'h'},           {"use-ipv4", no_argument, 0, '4'},       {"use-ipv6", no_argument, 0, '6'},
-                {"dontfrag", no_argument, 0, 'M'},       {"random", no_argument, 0, 'R'},         {0, 0, 0, 0}};
+        enum {
+                FWMARK_OPT = CHAR_MAX + 1,
+                ICMP_TIMESTAMP_OPT,
+                CHECK_SOURCE_OPT,
+        };
+        static struct option longopts[] = {{"hostname", required_argument, 0, 'H'},
+                                                                           {"sourceip", required_argument, 0, 'S'},
+                                                                           {"sourceif", required_argument, 0, 'I'},
+                                                                           {"critical", required_argument, 0, 'c'},
+                                                                           {"warning", required_argument, 0, 'w'},
+                                                                           {"alive", no_argument, 0, 'a'},
+                                                                           {"bytes", required_argument, 0, 'b'},
+                                                                           {"number", required_argument, 0, 'n'},
+                                                                           {"target-timeout", required_argument, 0, 'T'},
+                                                                           {"interval", required_argument, 0, 'i'},
+                                                                           {"verbose", no_argument, 0, 'v'},
+                                                                           {"version", no_argument, 0, 'V'},
+                                                                           {"help", no_argument, 0, 'h'},
+                                                                           {"use-ipv4", no_argument, 0, '4'},
+                                                                           {"use-ipv6", no_argument, 0, '6'},
+                                                                           {"dontfrag", no_argument, 0, 'M'},
+                                                                           {"random", no_argument, 0, 'R'},
+#ifdef FPING_VERSION_5_2_OR_HIGHER
+                                                                           // only available with fping version >= 5.2
+                                                                           {"fwmark", required_argument, NULL, FWMARK_OPT},
+#       ifdef FPING_VERSION_5_3_OR_HIGHER
+                                                                           // only available with fping version >= 5.3
+                                                                           {"icmp-timestamp", no_argument, NULL, ICMP_TIMESTAMP_OPT},
+                                                                           {"check-source", no_argument, NULL, CHECK_SOURCE_OPT},
+#       endif
+#endif
+                                                                           {0, 0, 0, 0}};
 
         char *rv[2];
         rv[PL] = NULL;
@@ -299,7 +349,7 @@ check_fping_config_wrapper process_arguments(int argc, char **argv) {
                 argc--;
         }
 
-        while (1) {
+        while (true) {
                 int option_index = getopt_long(argc, argv, "+hVvaH:S:c:w:b:n:T:i:I:M:R:46", longopts, &option);
 
                 if (option_index == -1 || option_index == EOF || option_index == 1) {
@@ -340,11 +390,7 @@ check_fping_config_wrapper process_arguments(int argc, char **argv) {
                         address_family = AF_INET;
                         break;
                 case '6': /* IPv6 only */
-#ifdef USE_IPV6
                         address_family = AF_INET6;
-#else
-                        usage(_("IPv6 support not available\n"));
-#endif
                         break;
                 case 'c':
                         get_threshold(optarg, rv);
@@ -406,6 +452,20 @@ check_fping_config_wrapper process_arguments(int argc, char **argv) {
                 case 'M':
                         result.config.dontfrag = true;
                         break;
+                case FWMARK_OPT:
+                        if (is_intpos(optarg)) {
+                                result.config.fwmark = (unsigned int)atol(optarg);
+                                result.config.fwmark_set = true;
+                        } else {
+                                usage(_("fwmark must be a positive integer"));
+                        }
+                        break;
+                case ICMP_TIMESTAMP_OPT:
+                        result.config.icmp_timestamp = true;
+                        break;
+                case CHECK_SOURCE_OPT:
+                        result.config.check_source = true;
+                        break;
                 }
         }
 
@@ -493,6 +553,16 @@ void print_help(void) {
         printf("    %s\n", _("set the Don't Fragment flag"));
         printf(" %s\n", "-R, --random");
         printf("    %s\n", _("random packet data (to foil link data compression)"));
+#ifdef FPING_VERSION_5_2_OR_HIGHER
+        printf(" %s\n", "--fwmark=INTEGER");
+        printf("    %s\n", _("set the routing mark to INTEGER (fping option)"));
+#       ifdef FPING_VERSION_5_3_OR_HIGHER
+        printf(" %s\n", "--icmp-timestamp");
+        printf("    %s\n", _("use ICMP Timestamp instead of ICMP Echo (fping option)"));
+        printf(" %s\n", "--check-source");
+        printf("    %s\n", _("discard replies not from target address (fping option)"));
+#       endif
+#endif
         printf(UT_VERBOSE);
         printf("\n");
         printf(" %s\n", _("THRESHOLD is <rta>,<pl>%% where <rta> is the round trip average travel time (ms)"));
diff --git a/plugins/check_fping.d/config.h b/plugins/check_fping.d/config.h
index a0697bf3..d95e9ded 100644
--- a/plugins/check_fping.d/config.h
+++ b/plugins/check_fping.d/config.h
@@ -29,6 +29,21 @@ typedef struct {
         bool cpl_p;
         int wpl;
         bool wpl_p;
+
+        // only available with fping version >= 5.2
+        // for a given uint _fwmark_ fping sets _fwmark_ as a firewall mark
+        // in the packets
+        unsigned int fwmark;
+        bool fwmark_set;
+
+
+        // only available with fping version >= 5.3
+        // Setting icmp_timestamp tells fping to use ICMP Timestamp (ICMP type 13) instead
+        // of ICMP Echo
+        bool icmp_timestamp;
+
+        // Setting check_source lets fping  discard replies which are not from the target address
+        bool check_source;
 } check_fping_config;
 
 check_fping_config check_fping_config_init() {
@@ -53,6 +68,15 @@ check_fping_config check_fping_config_init() {
                 .cpl_p = false,
                 .wpl = 0,
                 .wpl_p = false,
+
+                // only available with fping version >= 5.2
+                .fwmark = 0,
+                .fwmark_set = false, // just to be deterministic
+
+                // only available with fping version >= 5.3
+                .icmp_timestamp = false,
+                .check_source = false,
+
         };
         return tmp;
 }
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_ntp_peer.c b/plugins/check_ntp_peer.c
index f99e5032..6e76bf23 100644
--- a/plugins/check_ntp_peer.c
+++ b/plugins/check_ntp_peer.c
@@ -35,6 +35,7 @@
  *
  *****************************************************************************/
 
+#include "thresholds.h"
 const char *progname = "check_ntp_peer";
 const char *copyright = "2006-2024";
 const char *email = "devel@monitoring-plugins.org";
@@ -42,30 +43,18 @@ const char *email = "devel@monitoring-plugins.org";
 #include "common.h"
 #include "netutils.h"
 #include "utils.h"
+#include "../lib/states.h"
+#include "check_ntp_peer.d/config.h"
 
-static char *server_address = NULL;
-static int port = 123;
 static int verbose = 0;
-static bool quiet = false;
-static char *owarn = "60";
-static char *ocrit = "120";
-static bool do_stratum = false;
-static char *swarn = "-1:16";
-static char *scrit = "-1:16";
-static bool do_jitter = false;
-static char *jwarn = "-1:5000";
-static char *jcrit = "-1:10000";
-static bool do_truechimers = false;
-static char *twarn = "0:";
-static char *tcrit = "0:";
 static bool syncsource_found = false;
 static bool li_alarm = false;
 
-static int process_arguments(int /*argc*/, char ** /*argv*/);
-static thresholds *offset_thresholds = NULL;
-static thresholds *jitter_thresholds = NULL;
-static thresholds *stratum_thresholds = NULL;
-static thresholds *truechimer_thresholds = NULL;
+typedef struct {
+        int errorcode;
+        check_ntp_peer_config config;
+} check_ntp_peer_config_wrapper;
+static check_ntp_peer_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
 static void print_help(void);
 void print_usage(void);
 
@@ -157,25 +146,25 @@ typedef struct {
                 printf("%u.%u.%u.%u", (x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);                                              \
         } while (0);
 
-void print_ntp_control_message(const ntp_control_message *p) {
+void print_ntp_control_message(const ntp_control_message *message) {
         printf("control packet contents:\n");
-        printf("\tflags: 0x%.2x , 0x%.2x\n", p->flags, p->op);
-        printf("\t  li=%d (0x%.2x)\n", LI(p->flags), p->flags & LI_MASK);
-        printf("\t  vn=%d (0x%.2x)\n", VN(p->flags), p->flags & VN_MASK);
-        printf("\t  mode=%d (0x%.2x)\n", MODE(p->flags), p->flags & MODE_MASK);
-        printf("\t  response=%d (0x%.2x)\n", (p->op & REM_RESP) > 0, p->op & REM_RESP);
-        printf("\t  more=%d (0x%.2x)\n", (p->op & REM_MORE) > 0, p->op & REM_MORE);
-        printf("\t  error=%d (0x%.2x)\n", (p->op & REM_ERROR) > 0, p->op & REM_ERROR);
-        printf("\t  op=%d (0x%.2x)\n", p->op & OP_MASK, p->op & OP_MASK);
-        printf("\tsequence: %d (0x%.2x)\n", ntohs(p->seq), ntohs(p->seq));
-        printf("\tstatus: %d (0x%.2x)\n", ntohs(p->status), ntohs(p->status));
-        printf("\tassoc: %d (0x%.2x)\n", ntohs(p->assoc), ntohs(p->assoc));
-        printf("\toffset: %d (0x%.2x)\n", ntohs(p->offset), ntohs(p->offset));
-        printf("\tcount: %d (0x%.2x)\n", ntohs(p->count), ntohs(p->count));
-
-        int numpeers = ntohs(p->count) / (sizeof(ntp_assoc_status_pair));
-        if (p->op & REM_RESP && p->op & OP_READSTAT) {
-                const ntp_assoc_status_pair *peer = (ntp_assoc_status_pair *)p->data;
+        printf("\tflags: 0x%.2x , 0x%.2x\n", message->flags, message->op);
+        printf("\t  li=%d (0x%.2x)\n", LI(message->flags), message->flags & LI_MASK);
+        printf("\t  vn=%d (0x%.2x)\n", VN(message->flags), message->flags & VN_MASK);
+        printf("\t  mode=%d (0x%.2x)\n", MODE(message->flags), message->flags & MODE_MASK);
+        printf("\t  response=%d (0x%.2x)\n", (message->op & REM_RESP) > 0, message->op & REM_RESP);
+        printf("\t  more=%d (0x%.2x)\n", (message->op & REM_MORE) > 0, message->op & REM_MORE);
+        printf("\t  error=%d (0x%.2x)\n", (message->op & REM_ERROR) > 0, message->op & REM_ERROR);
+        printf("\t  op=%d (0x%.2x)\n", message->op & OP_MASK, message->op & OP_MASK);
+        printf("\tsequence: %d (0x%.2x)\n", ntohs(message->seq), ntohs(message->seq));
+        printf("\tstatus: %d (0x%.2x)\n", ntohs(message->status), ntohs(message->status));
+        printf("\tassoc: %d (0x%.2x)\n", ntohs(message->assoc), ntohs(message->assoc));
+        printf("\toffset: %d (0x%.2x)\n", ntohs(message->offset), ntohs(message->offset));
+        printf("\tcount: %d (0x%.2x)\n", ntohs(message->count), ntohs(message->count));
+
+        int numpeers = ntohs(message->count) / (sizeof(ntp_assoc_status_pair));
+        if (message->op & REM_RESP && message->op & OP_READSTAT) {
+                const ntp_assoc_status_pair *peer = (ntp_assoc_status_pair *)message->data;
                 for (int i = 0; i < numpeers; i++) {
                         printf("\tpeer id %.2x status %.2x", ntohs(peer[i].assoc), ntohs(peer[i].status));
                         if (PEER_SEL(peer[i].status) >= PEER_SYNCSOURCE) {
@@ -190,13 +179,13 @@ void print_ntp_control_message(const ntp_control_message *p) {
         }
 }
 
-void setup_control_request(ntp_control_message *p, uint8_t opcode, uint16_t seq) {
-        memset(p, 0, sizeof(ntp_control_message));
-        LI_SET(p->flags, LI_NOWARNING);
-        VN_SET(p->flags, VN_RESERVED);
-        MODE_SET(p->flags, MODE_CONTROLMSG);
-        OP_SET(p->op, opcode);
-        p->seq = htons(seq);
+void setup_control_request(ntp_control_message *message, uint8_t opcode, uint16_t seq) {
+        memset(message, 0, sizeof(ntp_control_message));
+        LI_SET(message->flags, LI_NOWARNING);
+        VN_SET(message->flags, VN_RESERVED);
+        MODE_SET(message->flags, MODE_CONTROLMSG);
+        OP_SET(message->op, opcode);
+        message->seq = htons(seq);
         /* Remaining fields are zero for requests */
 }
 
@@ -211,10 +200,23 @@ void setup_control_request(ntp_control_message *p, uint8_t opcode, uint16_t seq)
  *  status is pretty much useless as syncsource_found is a global variable
  *  used later in main to check is the server was synchronized. It works
  *  so I left it alone */
-int ntp_request(double *offset, int *offset_result, double *jitter, int *stratum, int *num_truechimers) {
-        *offset_result = STATE_UNKNOWN;
-        *jitter = *stratum = -1;
-        *num_truechimers = 0;
+typedef struct {
+        mp_state_enum state;
+        mp_state_enum offset_result;
+        double offset;
+        double jitter;
+        long stratum;
+        int num_truechimers;
+} ntp_request_result;
+ntp_request_result ntp_request(const check_ntp_peer_config config) {
+
+        ntp_request_result result = {
+                .state = STATE_OK,
+                .offset_result = STATE_UNKNOWN,
+                .jitter = -1,
+                .stratum = -1,
+                .num_truechimers = 0,
+        };
 
         /* Long-winded explanation:
          * Getting the sync peer offset, jitter and stratum requires a number of
@@ -237,10 +239,10 @@ int ntp_request(double *offset, int *offset_result, double *jitter, int *stratum
         void *tmp;
         ntp_assoc_status_pair *peers = NULL;
         int peer_offset = 0;
-        int peers_size = 0;
-        int npeers = 0;
+        size_t peers_size = 0;
+        size_t npeers = 0;
         int conn = -1;
-        my_udp_connect(server_address, port, &conn);
+        my_udp_connect(config.server_address, config.port, &conn);
 
         /* keep sending requests until the server stops setting the
          * REM_MORE bit, though usually this is only 1 packet. */
@@ -255,24 +257,28 @@ int ntp_request(double *offset, int *offset_result, double *jitter, int *stratum
                         /* Attempt to read the largest size packet possible */
                         req.count = htons(MAX_CM_SIZE);
                         DBG(printf("receiving READSTAT response"))
-                        if (read(conn, &req, SIZEOF_NTPCM(req)) == -1)
+                        if (read(conn, &req, SIZEOF_NTPCM(req)) == -1) {
                                 die(STATE_CRITICAL, "NTP CRITICAL: No response from NTP server\n");
+                        }
                         DBG(print_ntp_control_message(&req));
                         /* discard obviously invalid packets */
-                        if (ntohs(req.count) > MAX_CM_SIZE)
+                        if (ntohs(req.count) > MAX_CM_SIZE) {
                                 die(STATE_CRITICAL, "NTP CRITICAL: Invalid packet received from NTP server\n");
+                        }
                 } while (!(req.op & OP_READSTAT && ntohs(req.seq) == 1));
 
-                if (LI(req.flags) == LI_ALARM)
+                if (LI(req.flags) == LI_ALARM) {
                         li_alarm = true;
+                }
                 /* Each peer identifier is 4 bytes in the data section, which
                  * we represent as a ntp_assoc_status_pair datatype.
                  */
                 peers_size += ntohs(req.count);
-                if ((tmp = realloc(peers, peers_size)) == NULL)
+                if ((tmp = realloc(peers, peers_size)) == NULL) {
                         free(peers), die(STATE_UNKNOWN, "can not (re)allocate 'peers' buffer\n");
+                }
                 peers = tmp;
-                memcpy((void *)((ptrdiff_t)peers + peer_offset), (void *)req.data, ntohs(req.count));
+                memcpy((peers + peer_offset), (void *)req.data, ntohs(req.count));
                 npeers = peers_size / sizeof(ntp_assoc_status_pair);
                 peer_offset += ntohs(req.count);
         } while (req.op & REM_MORE);
@@ -280,9 +286,9 @@ int ntp_request(double *offset, int *offset_result, double *jitter, int *stratum
         /* first, let's find out if we have a sync source, or if there are
          * at least some candidates. In the latter case we'll issue
          * a warning but go ahead with the check on them. */
-        for (int i = 0; i < npeers; i++) {
+        for (size_t i = 0; i < npeers; i++) {
                 if (PEER_SEL(peers[i].status) >= PEER_TRUECHIMER) {
-                        (*num_truechimers)++;
+                        result.num_truechimers++;
                         if (PEER_SEL(peers[i].status) >= PEER_INCLUDED) {
                                 num_candidates++;
                                 if (PEER_SEL(peers[i].status) >= PEER_SYNCSOURCE) {
@@ -293,31 +299,35 @@ int ntp_request(double *offset, int *offset_result, double *jitter, int *stratum
                 }
         }
 
-        if (verbose)
+        if (verbose) {
                 printf("%d candidate peers available\n", num_candidates);
-        if (verbose && syncsource_found)
+        }
+        if (verbose && syncsource_found) {
                 printf("synchronization source found\n");
+        }
 
-        int status = STATE_OK;
         if (!syncsource_found) {
-                status = STATE_WARNING;
-                if (verbose)
+                result.state = STATE_WARNING;
+                if (verbose) {
                         printf("warning: no synchronization source found\n");
+                }
         }
         if (li_alarm) {
-                status = STATE_WARNING;
-                if (verbose)
+                result.state = STATE_WARNING;
+                if (verbose) {
                         printf("warning: LI_ALARM bit is set\n");
+                }
         }
 
         const char *getvar = "stratum,offset,jitter";
         char *data;
-        for (int i = 0; i < npeers; i++) {
+        for (size_t i = 0; i < npeers; i++) {
                 /* Only query this server if it is the current sync source */
                 /* If there's no sync.peer, query all candidates and use the best one */
                 if (PEER_SEL(peers[i].status) >= min_peer_sel) {
-                        if (verbose)
+                        if (verbose) {
                                 printf("Getting offset, jitter and stratum for peer %.2x\n", ntohs(peers[i].assoc));
+                        }
                         xasprintf(&data, "");
                         do {
                                 setup_control_request(&req, OP_READVAR, 2);
@@ -342,60 +352,68 @@ int ntp_request(double *offset, int *offset_result, double *jitter, int *stratum
                                         DBG(print_ntp_control_message(&req));
                                 } while (!(req.op & OP_READVAR && ntohs(req.seq) == 2));
 
-                                if (!(req.op & REM_ERROR))
+                                if (!(req.op & REM_ERROR)) {
                                         xasprintf(&data, "%s%s", data, req.data);
+                                }
                         } while (req.op & REM_MORE);
 
                         if (req.op & REM_ERROR) {
                                 if (strstr(getvar, "jitter")) {
-                                        if (verbose)
+                                        if (verbose) {
                                                 printf("The command failed. This is usually caused by servers refusing the 'jitter'\nvariable. Restarting with "
                                                            "'dispersion'...\n");
+                                        }
                                         getvar = "stratum,offset,dispersion";
                                         i--;
                                         continue;
                                 }
                                 if (strlen(getvar)) {
-                                        if (verbose)
+                                        if (verbose) {
                                                 printf("Server didn't like dispersion either; will retrieve everything\n");
+                                        }
                                         getvar = "";
                                         i--;
                                         continue;
                                 }
                         }
 
-                        if (verbose > 1)
+                        if (verbose > 1) {
                                 printf("Server responded: >>>%s<<<\n", data);
+                        }
 
                         double tmp_offset = 0;
                         char *value;
                         char *nptr;
                         /* get the offset */
-                        if (verbose)
+                        if (verbose) {
                                 printf("parsing offset from peer %.2x: ", ntohs(peers[i].assoc));
+                        }
 
                         value = np_extract_ntpvar(data, "offset");
                         nptr = NULL;
                         /* Convert the value if we have one */
-                        if (value != NULL)
+                        if (value != NULL) {
                                 tmp_offset = strtod(value, &nptr) / 1000;
+                        }
                         /* If value is null or no conversion was performed */
                         if (value == NULL || value == nptr) {
-                                if (verbose)
+                                if (verbose) {
                                         printf("error: unable to read server offset response.\n");
+                                }
                         } else {
-                                if (verbose)
+                                if (verbose) {
                                         printf("%.10g\n", tmp_offset);
-                                if (*offset_result == STATE_UNKNOWN || fabs(tmp_offset) < fabs(*offset)) {
-                                        *offset = tmp_offset;
-                                        *offset_result = STATE_OK;
+                                }
+                                if (result.offset_result == STATE_UNKNOWN || fabs(tmp_offset) < fabs(result.offset)) {
+                                        result.offset = tmp_offset;
+                                        result.offset_result = STATE_OK;
                                 } else {
                                         /* Skip this one; move to the next */
                                         continue;
                                 }
                         }
 
-                        if (do_jitter) {
+                        if (config.do_jitter) {
                                 /* get the jitter */
                                 if (verbose) {
                                         printf("parsing %s from peer %.2x: ", strstr(getvar, "dispersion") != NULL ? "dispersion" : "jitter",
@@ -404,19 +422,21 @@ int ntp_request(double *offset, int *offset_result, double *jitter, int *stratum
                                 value = np_extract_ntpvar(data, strstr(getvar, "dispersion") != NULL ? "dispersion" : "jitter");
                                 nptr = NULL;
                                 /* Convert the value if we have one */
-                                if (value != NULL)
-                                        *jitter = strtod(value, &nptr);
+                                if (value != NULL) {
+                                        result.jitter = strtod(value, &nptr);
+                                }
                                 /* If value is null or no conversion was performed */
                                 if (value == NULL || value == nptr) {
-                                        if (verbose)
+                                        if (verbose) {
                                                 printf("error: unable to read server jitter/dispersion response.\n");
-                                        *jitter = -1;
+                                        }
+                                        result.jitter = -1;
                                 } else if (verbose) {
-                                        printf("%.10g\n", *jitter);
+                                        printf("%.10g\n", result.jitter);
                                 }
                         }
 
-                        if (do_stratum) {
+                        if (config.do_stratum) {
                                 /* get the stratum */
                                 if (verbose) {
                                         printf("parsing stratum from peer %.2x: ", ntohs(peers[i].assoc));
@@ -424,28 +444,32 @@ int ntp_request(double *offset, int *offset_result, double *jitter, int *stratum
                                 value = np_extract_ntpvar(data, "stratum");
                                 nptr = NULL;
                                 /* Convert the value if we have one */
-                                if (value != NULL)
-                                        *stratum = strtol(value, &nptr, 10);
+                                if (value != NULL) {
+                                        result.stratum = strtol(value, &nptr, 10);
+                                }
                                 if (value == NULL || value == nptr) {
-                                        if (verbose)
+                                        if (verbose) {
                                                 printf("error: unable to read server stratum response.\n");
-                                        *stratum = -1;
+                                        }
+                                        result.stratum = -1;
                                 } else {
-                                        if (verbose)
-                                                printf("%i\n", *stratum);
+                                        if (verbose) {
+                                                printf("%li\n", result.stratum);
+                                        }
                                 }
                         }
                 } /* if (PEER_SEL(peers[i].status) >= min_peer_sel) */
-        }     /* for (i = 0; i < npeers; i++) */
+        } /* for (i = 0; i < npeers; i++) */
 
         close(conn);
-        if (peers != NULL)
+        if (peers != NULL) {
                 free(peers);
+        }
 
-        return status;
+        return result;
 }
 
-int process_arguments(int argc, char **argv) {
+check_ntp_peer_config_wrapper process_arguments(int argc, char **argv) {
         static struct option longopts[] = {
                 {"version", no_argument, 0, 'V'},        {"help", no_argument, 0, 'h'},           {"verbose", no_argument, 0, 'v'},
                 {"use-ipv4", no_argument, 0, '4'},       {"use-ipv6", no_argument, 0, '6'},       {"quiet", no_argument, 0, 'q'},
@@ -454,14 +478,21 @@ int process_arguments(int argc, char **argv) {
                 {"twarn", required_argument, 0, 'm'},    {"tcrit", required_argument, 0, 'n'},    {"timeout", required_argument, 0, 't'},
                 {"hostname", required_argument, 0, 'H'}, {"port", required_argument, 0, 'p'},     {0, 0, 0, 0}};
 
-        if (argc < 2)
+        if (argc < 2) {
                 usage("\n");
+        }
+
+        check_ntp_peer_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_ntp_peer_config_init(),
+        };
 
         while (true) {
                 int option = 0;
                 int option_char = getopt_long(argc, argv, "Vhv46qw:c:W:C:j:k:m:n:t:H:p:", longopts, &option);
-                if (option_char == -1 || option_char == EOF || option_char == 1)
+                if (option_char == -1 || option_char == EOF || option_char == 1) {
                         break;
+                }
 
                 switch (option_char) {
                 case 'h':
@@ -476,45 +507,46 @@ int process_arguments(int argc, char **argv) {
                         verbose++;
                         break;
                 case 'q':
-                        quiet = true;
+                        result.config.quiet = true;
                         break;
                 case 'w':
-                        owarn = optarg;
+                        result.config.owarn = optarg;
                         break;
                 case 'c':
-                        ocrit = optarg;
+                        result.config.ocrit = optarg;
                         break;
                 case 'W':
-                        do_stratum = true;
-                        swarn = optarg;
+                        result.config.do_stratum = true;
+                        result.config.swarn = optarg;
                         break;
                 case 'C':
-                        do_stratum = true;
-                        scrit = optarg;
+                        result.config.do_stratum = true;
+                        result.config.scrit = optarg;
                         break;
                 case 'j':
-                        do_jitter = true;
-                        jwarn = optarg;
+                        result.config.do_jitter = true;
+                        result.config.jwarn = optarg;
                         break;
                 case 'k':
-                        do_jitter = true;
-                        jcrit = optarg;
+                        result.config.do_jitter = true;
+                        result.config.jcrit = optarg;
                         break;
                 case 'm':
-                        do_truechimers = true;
-                        twarn = optarg;
+                        result.config.do_truechimers = true;
+                        result.config.twarn = optarg;
                         break;
                 case 'n':
-                        do_truechimers = true;
-                        tcrit = optarg;
+                        result.config.do_truechimers = true;
+                        result.config.tcrit = optarg;
                         break;
                 case 'H':
-                        if (!is_host(optarg))
+                        if (!is_host(optarg)) {
                                 usage2(_("Invalid hostname/address"), optarg);
-                        server_address = strdup(optarg);
+                        }
+                        result.config.server_address = strdup(optarg);
                         break;
                 case 'p':
-                        port = atoi(optarg);
+                        result.config.port = atoi(optarg);
                         break;
                 case 't':
                         socket_timeout = atoi(optarg);
@@ -536,29 +568,34 @@ int process_arguments(int argc, char **argv) {
                 }
         }
 
-        if (server_address == NULL) {
+        if (result.config.server_address == NULL) {
                 usage4(_("Hostname was not supplied"));
         }
 
-        return 0;
+        set_thresholds(&result.config.offset_thresholds, result.config.owarn, result.config.ocrit);
+        set_thresholds(&result.config.jitter_thresholds, result.config.jwarn, result.config.jcrit);
+        set_thresholds(&result.config.stratum_thresholds, result.config.swarn, result.config.scrit);
+        set_thresholds(&result.config.truechimer_thresholds, result.config.twarn, result.config.tcrit);
+
+        return result;
 }
 
-char *perfd_offset(double offset) {
+char *perfd_offset(double offset, thresholds *offset_thresholds) {
         return fperfdata("offset", offset, "s", true, offset_thresholds->warning->end, true, offset_thresholds->critical->end, false, 0, false,
                                          0);
 }
 
-char *perfd_jitter(double jitter) {
+char *perfd_jitter(double jitter, bool do_jitter, thresholds *jitter_thresholds) {
         return fperfdata("jitter", jitter, "", do_jitter, jitter_thresholds->warning->end, do_jitter, jitter_thresholds->critical->end, true, 0,
                                          false, 0);
 }
 
-char *perfd_stratum(int stratum) {
+char *perfd_stratum(int stratum, bool do_stratum, thresholds *stratum_thresholds) {
         return perfdata("stratum", stratum, "", do_stratum, (int)stratum_thresholds->warning->end, do_stratum,
                                         (int)stratum_thresholds->critical->end, true, 0, true, 16);
 }
 
-char *perfd_truechimers(int num_truechimers) {
+char *perfd_truechimers(int num_truechimers, const bool do_truechimers, thresholds *truechimer_thresholds) {
         return perfdata("truechimers", num_truechimers, "", do_truechimers, (int)truechimer_thresholds->warning->end, do_truechimers,
                                         (int)truechimer_thresholds->critical->end, true, 0, false, 0);
 }
@@ -571,13 +608,13 @@ int main(int argc, char *argv[]) {
         /* Parse extra opts if any */
         argv = np_extra_opts(&argc, argv, progname);
 
-        if (process_arguments(argc, argv) == ERROR)
+        check_ntp_peer_config_wrapper tmp_config = process_arguments(argc, argv);
+
+        if (tmp_config.errorcode == ERROR) {
                 usage4(_("Could not parse arguments"));
+        }
 
-        set_thresholds(&offset_thresholds, owarn, ocrit);
-        set_thresholds(&jitter_thresholds, jwarn, jcrit);
-        set_thresholds(&stratum_thresholds, swarn, scrit);
-        set_thresholds(&truechimer_thresholds, twarn, tcrit);
+        const check_ntp_peer_config config = tmp_config.config;
 
         /* initialize alarm signal handling */
         signal(SIGALRM, socket_timeout_alarm_handler);
@@ -585,44 +622,40 @@ int main(int argc, char *argv[]) {
         /* set socket timeout */
         alarm(socket_timeout);
 
-        int offset_result;
-        int stratum;
-        int num_truechimers;
-        double offset = 0;
-        double jitter = 0;
         /* This returns either OK or WARNING (See comment preceding ntp_request) */
-        int result = ntp_request(&offset, &offset_result, &jitter, &stratum, &num_truechimers);
+        ntp_request_result ntp_res = ntp_request(config);
+        mp_state_enum result = STATE_UNKNOWN;
 
-        if (offset_result == STATE_UNKNOWN) {
+        if (ntp_res.offset_result == STATE_UNKNOWN) {
                 /* if there's no sync peer (this overrides ntp_request output): */
-                result = (quiet ? STATE_UNKNOWN : STATE_CRITICAL);
+                result = (config.quiet ? STATE_UNKNOWN : STATE_CRITICAL);
         } else {
                 /* Be quiet if there's no candidates either */
-                if (quiet && result == STATE_WARNING)
+                if (config.quiet && result == STATE_WARNING) {
                         result = STATE_UNKNOWN;
-                result = max_state_alt(result, get_status(fabs(offset), offset_thresholds));
+                }
+                result = max_state_alt(result, get_status(fabs(ntp_res.offset), config.offset_thresholds));
         }
 
-        int oresult = result;
-
-        int tresult = STATE_UNKNOWN;
+        mp_state_enum oresult = result;
+        mp_state_enum tresult = STATE_UNKNOWN;
 
-        if (do_truechimers) {
-                tresult = get_status(num_truechimers, truechimer_thresholds);
+        if (config.do_truechimers) {
+                tresult = get_status(ntp_res.num_truechimers, config.truechimer_thresholds);
                 result = max_state_alt(result, tresult);
         }
 
-        int sresult = STATE_UNKNOWN;
+        mp_state_enum sresult = STATE_UNKNOWN;
 
-        if (do_stratum) {
-                sresult = get_status(stratum, stratum_thresholds);
+        if (config.do_stratum) {
+                sresult = get_status((double)ntp_res.stratum, config.stratum_thresholds);
                 result = max_state_alt(result, sresult);
         }
 
-        int jresult = STATE_UNKNOWN;
+        mp_state_enum jresult = STATE_UNKNOWN;
 
-        if (do_jitter) {
-                jresult = get_status(jitter, jitter_thresholds);
+        if (config.do_jitter) {
+                jresult = get_status(ntp_res.jitter, config.jitter_thresholds);
                 result = max_state_alt(result, jresult);
         }
 
@@ -641,59 +674,67 @@ int main(int argc, char *argv[]) {
                 xasprintf(&result_line, _("NTP UNKNOWN:"));
                 break;
         }
-        if (!syncsource_found)
+
+        if (!syncsource_found) {
                 xasprintf(&result_line, "%s %s,", result_line, _("Server not synchronized"));
-        else if (li_alarm)
+        } else if (li_alarm) {
                 xasprintf(&result_line, "%s %s,", result_line, _("Server has the LI_ALARM bit set"));
+        }
 
         char *perfdata_line;
-        if (offset_result == STATE_UNKNOWN) {
+        if (ntp_res.offset_result == STATE_UNKNOWN) {
                 xasprintf(&result_line, "%s %s", result_line, _("Offset unknown"));
                 xasprintf(&perfdata_line, "");
         } else if (oresult == STATE_WARNING) {
-                xasprintf(&result_line, "%s %s %.10g secs (WARNING)", result_line, _("Offset"), offset);
+                xasprintf(&result_line, "%s %s %.10g secs (WARNING)", result_line, _("Offset"), ntp_res.offset);
         } else if (oresult == STATE_CRITICAL) {
-                xasprintf(&result_line, "%s %s %.10g secs (CRITICAL)", result_line, _("Offset"), offset);
+                xasprintf(&result_line, "%s %s %.10g secs (CRITICAL)", result_line, _("Offset"), ntp_res.offset);
         } else {
-                xasprintf(&result_line, "%s %s %.10g secs", result_line, _("Offset"), offset);
+                xasprintf(&result_line, "%s %s %.10g secs", result_line, _("Offset"), ntp_res.offset);
         }
-        xasprintf(&perfdata_line, "%s", perfd_offset(offset));
+        xasprintf(&perfdata_line, "%s", perfd_offset(ntp_res.offset, config.offset_thresholds));
 
-        if (do_jitter) {
+        if (config.do_jitter) {
                 if (jresult == STATE_WARNING) {
-                        xasprintf(&result_line, "%s, jitter=%f (WARNING)", result_line, jitter);
+                        xasprintf(&result_line, "%s, jitter=%f (WARNING)", result_line, ntp_res.jitter);
                 } else if (jresult == STATE_CRITICAL) {
-                        xasprintf(&result_line, "%s, jitter=%f (CRITICAL)", result_line, jitter);
+                        xasprintf(&result_line, "%s, jitter=%f (CRITICAL)", result_line, ntp_res.jitter);
                 } else {
-                        xasprintf(&result_line, "%s, jitter=%f", result_line, jitter);
+                        xasprintf(&result_line, "%s, jitter=%f", result_line, ntp_res.jitter);
                 }
-                xasprintf(&perfdata_line, "%s %s", perfdata_line, perfd_jitter(jitter));
+                xasprintf(&perfdata_line, "%s %s", perfdata_line, perfd_jitter(ntp_res.jitter, config.do_jitter, config.jitter_thresholds));
         }
-        if (do_stratum) {
+
+        if (config.do_stratum) {
                 if (sresult == STATE_WARNING) {
-                        xasprintf(&result_line, "%s, stratum=%i (WARNING)", result_line, stratum);
+                        xasprintf(&result_line, "%s, stratum=%l (WARNING)", result_line, ntp_res.stratum);
                 } else if (sresult == STATE_CRITICAL) {
-                        xasprintf(&result_line, "%s, stratum=%i (CRITICAL)", result_line, stratum);
+                        xasprintf(&result_line, "%s, stratum=%l (CRITICAL)", result_line, ntp_res.stratum);
                 } else {
-                        xasprintf(&result_line, "%s, stratum=%i", result_line, stratum);
+                        xasprintf(&result_line, "%s, stratum=%l", result_line, ntp_res.stratum);
                 }
-                xasprintf(&perfdata_line, "%s %s", perfdata_line, perfd_stratum(stratum));
+                xasprintf(&perfdata_line, "%s %s", perfdata_line, perfd_stratum(ntp_res.stratum, config.do_stratum, config.stratum_thresholds));
         }
-        if (do_truechimers) {
+
+        if (config.do_truechimers) {
                 if (tresult == STATE_WARNING) {
-                        xasprintf(&result_line, "%s, truechimers=%i (WARNING)", result_line, num_truechimers);
+                        xasprintf(&result_line, "%s, truechimers=%i (WARNING)", result_line, ntp_res.num_truechimers);
                 } else if (tresult == STATE_CRITICAL) {
-                        xasprintf(&result_line, "%s, truechimers=%i (CRITICAL)", result_line, num_truechimers);
+                        xasprintf(&result_line, "%s, truechimers=%i (CRITICAL)", result_line, ntp_res.num_truechimers);
                 } else {
-                        xasprintf(&result_line, "%s, truechimers=%i", result_line, num_truechimers);
+                        xasprintf(&result_line, "%s, truechimers=%i", result_line, ntp_res.num_truechimers);
                 }
-                xasprintf(&perfdata_line, "%s %s", perfdata_line, perfd_truechimers(num_truechimers));
+                xasprintf(&perfdata_line, "%s %s", perfdata_line,
+                                  perfd_truechimers(ntp_res.num_truechimers, config.do_truechimers, config.truechimer_thresholds));
         }
+
         printf("%s|%s\n", result_line, perfdata_line);
 
-        if (server_address != NULL)
-                free(server_address);
-        return result;
+        if (config.server_address != NULL) {
+                free(config.server_address);
+        }
+
+        exit(result);
 }
 
 void print_help(void) {
diff --git a/plugins/check_ntp_peer.d/config.h b/plugins/check_ntp_peer.d/config.h
new file mode 100644
index 00000000..00e6b05d
--- /dev/null
+++ b/plugins/check_ntp_peer.d/config.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include "../../config.h"
+#include "thresholds.h"
+#include <stddef.h>
+
+enum {
+        DEFAULT_NTP_PORT = 123,
+};
+
+typedef struct {
+        char *server_address;
+        int port;
+
+        bool quiet;
+
+        // truechimer stuff
+        bool do_truechimers;
+        char *twarn;
+        char *tcrit;
+        thresholds *truechimer_thresholds;
+
+        char *owarn;
+        char *ocrit;
+        thresholds *offset_thresholds;
+
+        // stratum stuff
+        bool do_stratum;
+        char *swarn;
+        char *scrit;
+        thresholds *stratum_thresholds;
+
+        // jitter stuff
+        bool do_jitter;
+        char *jwarn;
+        char *jcrit;
+        thresholds *jitter_thresholds;
+
+} check_ntp_peer_config;
+
+check_ntp_peer_config check_ntp_peer_config_init() {
+        check_ntp_peer_config tmp = {
+                .server_address = NULL,
+                .port = DEFAULT_NTP_PORT,
+
+                .quiet = false,
+                .do_truechimers = false,
+                .twarn = "0:",
+                .tcrit = "0:",
+                .truechimer_thresholds = NULL,
+
+                .owarn = "60",
+                .ocrit = "120",
+                .offset_thresholds = NULL,
+
+                .do_stratum = false,
+                .swarn = "-1:16",
+                .scrit = "-1:16",
+                .stratum_thresholds = NULL,
+
+                .do_jitter = false,
+                .jwarn = "-1:5000",
+                .jcrit = "-1:10000",
+                .jitter_thresholds = NULL,
+        };
+        return tmp;
+}
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 4aafaf41..6bcdeaad 100644
--- a/plugins/check_ping.c
+++ b/plugins/check_ping.c
@@ -36,61 +36,52 @@ const char *email = "devel@monitoring-plugins.org";
 #include "netutils.h"
 #include "popen.h"
 #include "utils.h"
+#include "check_ping.d/config.h"
+#include "../lib/states.h"
 
 #include <signal.h>
 
-#define WARN_DUPLICATES   "DUPLICATES FOUND! "
-#define UNKNOWN_TRIP_TIME -1.0 /* -1 seconds */
+#define WARN_DUPLICATES "DUPLICATES FOUND! "
 
-enum {
-        UNKNOWN_PACKET_LOSS = 200, /* 200% */
-        DEFAULT_MAX_PACKETS = 5    /* default no. of ICMP ECHO packets */
-};
+typedef struct {
+        int errorcode;
+        check_ping_config config;
+} check_ping_config_wrapper;
+static check_ping_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
+static check_ping_config_wrapper validate_arguments(check_ping_config_wrapper /*config_wrapper*/);
 
-static int process_arguments(int /*argc*/, char ** /*argv*/);
-static int get_threshold(char * /*arg*/, float * /*trta*/, int * /*tpl*/);
-static int validate_arguments(void);
-static int run_ping(const char *cmd, const char *addr);
-static int error_scan(char buf[MAX_INPUT_BUFFER], const char *addr);
+static int get_threshold(char * /*arg*/, double * /*trta*/, int * /*tpl*/);
+
+typedef struct {
+        mp_state_enum state;
+        double round_trip_average;
+        int packet_loss;
+} ping_result;
+static ping_result run_ping(const char *cmd, const char *addr, double /*crta*/);
+
+static mp_state_enum error_scan(char buf[MAX_INPUT_BUFFER], const char *addr);
 static void print_help(void);
 void print_usage(void);
 
-static bool display_html = false;
-static int wpl = UNKNOWN_PACKET_LOSS;
-static int cpl = UNKNOWN_PACKET_LOSS;
-static float wrta = UNKNOWN_TRIP_TIME;
-static float crta = UNKNOWN_TRIP_TIME;
-static char **addresses = NULL;
-static int n_addresses = 0;
-static int max_addr = 1;
-static int max_packets = -1;
 static int verbose = 0;
 
-static float rta = UNKNOWN_TRIP_TIME;
-static int pl = UNKNOWN_PACKET_LOSS;
-
 static char *warn_text;
 
 int main(int argc, char **argv) {
-        char *cmd = NULL;
-        char *rawcmd = NULL;
-        int result = STATE_UNKNOWN;
-        int this_result = STATE_UNKNOWN;
-        int i;
-
         setlocale(LC_ALL, "");
         setlocale(LC_NUMERIC, "C");
         bindtextdomain(PACKAGE, LOCALEDIR);
         textdomain(PACKAGE);
 
-        addresses = malloc(sizeof(char *) * max_addr);
-        addresses[0] = NULL;
-
         /* Parse extra opts if any */
         argv = np_extra_opts(&argc, argv, progname);
 
-        if (process_arguments(argc, argv) == ERROR)
+        check_ping_config_wrapper tmp_config = process_arguments(argc, argv);
+        if (tmp_config.errorcode == ERROR) {
                 usage4(_("Could not parse arguments"));
+        }
+
+        const check_ping_config config = tmp_config.config;
 
         /* Set signal handling and alarm */
         if (signal(SIGALRM, popen_timeout_alarm_handler) == SIG_ERR) {
@@ -105,71 +96,86 @@ int main(int argc, char **argv) {
         alarm(timeout_interval);
 #endif
 
-        for (i = 0; i < n_addresses; i++) {
-
+        int result = STATE_UNKNOWN;
+        char *rawcmd = NULL;
+        for (size_t i = 0; i < config.n_addresses; i++) {
 #ifdef PING6_COMMAND
-                if (address_family != AF_INET && is_inet6_addr(addresses[i]))
+                if (address_family != AF_INET && is_inet6_addr(config.addresses[i])) {
                         rawcmd = strdup(PING6_COMMAND);
-                else
+                } else {
                         rawcmd = strdup(PING_COMMAND);
+                }
 #else
                 rawcmd = strdup(PING_COMMAND);
 #endif
 
-                        /* does the host address of number of packets argument come first? */
+                char *cmd = NULL;
+
+                /* does the host address of number of packets argument come first? */
 #ifdef PING_PACKETS_FIRST
 #       ifdef PING_HAS_TIMEOUT
-                xasprintf(&cmd, rawcmd, timeout_interval, max_packets, addresses[i]);
+                xasprintf(&cmd, rawcmd, timeout_interval, config.max_packets, config.addresses[i]);
 #       else
-                xasprintf(&cmd, rawcmd, max_packets, addresses[i]);
+                xasprintf(&cmd, rawcmd, config.max_packets, config.addresses[i]);
 #       endif
 #else
-                xasprintf(&cmd, rawcmd, addresses[i], max_packets);
+                xasprintf(&cmd, rawcmd, config.addresses[i], config.max_packets);
 #endif
 
-                if (verbose >= 2)
+                if (verbose >= 2) {
                         printf("CMD: %s\n", cmd);
+                }
 
                 /* run the command */
-                this_result = run_ping(cmd, addresses[i]);
 
-                if (pl == UNKNOWN_PACKET_LOSS || rta < 0.0) {
+                ping_result pinged = run_ping(cmd, config.addresses[i], config.crta);
+
+                if (pinged.packet_loss == UNKNOWN_PACKET_LOSS || pinged.round_trip_average < 0.0) {
                         printf("%s\n", cmd);
                         die(STATE_UNKNOWN, _("CRITICAL - Could not interpret output from ping command\n"));
                 }
 
-                if (pl >= cpl || rta >= crta || rta < 0)
-                        this_result = STATE_CRITICAL;
-                else if (pl >= wpl || rta >= wrta)
-                        this_result = STATE_WARNING;
-                else if (pl >= 0 && rta >= 0)
-                        this_result = max_state(STATE_OK, this_result);
-
-                if (n_addresses > 1 && this_result != STATE_UNKNOWN)
-                        die(STATE_OK, "%s is alive\n", addresses[i]);
-
-                if (display_html == true)
-                        printf("<A HREF='%s/traceroute.cgi?%s'>", CGIURL, addresses[i]);
-                if (pl == 100)
-                        printf(_("PING %s - %sPacket loss = %d%%"), state_text(this_result), warn_text, pl);
-                else
-                        printf(_("PING %s - %sPacket loss = %d%%, RTA = %2.2f ms"), state_text(this_result), warn_text, pl, rta);
-                if (display_html == true)
+                if (pinged.packet_loss >= config.cpl || pinged.round_trip_average >= config.crta || pinged.round_trip_average < 0) {
+                        pinged.state = STATE_CRITICAL;
+                } else if (pinged.packet_loss >= config.wpl || pinged.round_trip_average >= config.wrta) {
+                        pinged.state = STATE_WARNING;
+                } else if (pinged.packet_loss >= 0 && pinged.round_trip_average >= 0) {
+                        pinged.state = max_state(STATE_OK, pinged.state);
+                }
+
+                if (config.n_addresses > 1 && pinged.state != STATE_UNKNOWN) {
+                        die(STATE_OK, "%s is alive\n", config.addresses[i]);
+                }
+
+                if (config.display_html) {
+                        printf("<A HREF='%s/traceroute.cgi?%s'>", CGIURL, config.addresses[i]);
+                }
+                if (pinged.packet_loss == 100) {
+                        printf(_("PING %s - %sPacket loss = %d%%"), state_text(pinged.state), warn_text, pinged.packet_loss);
+                } else {
+                        printf(_("PING %s - %sPacket loss = %d%%, RTA = %2.2f ms"), state_text(pinged.state), warn_text, pinged.packet_loss,
+                                   pinged.round_trip_average);
+                }
+                if (config.display_html) {
                         printf("</A>");
+                }
 
                 /* Print performance data */
-                if (pl != 100) {
-                        printf("|%s",
-                                   fperfdata("rta", (double)rta, "ms", wrta > 0 ? true : false, wrta, crta > 0 ? true : false, crta, true, 0, false, 0));
+                if (pinged.packet_loss != 100) {
+                        printf("|%s", fperfdata("rta", pinged.round_trip_average, "ms", (bool)(config.wrta > 0), config.wrta, (bool)(config.crta > 0),
+                                                                        config.crta, true, 0, false, 0));
                 } else {
-                        printf("| rta=U;%f;%f;;", wrta, crta);
+                        printf("| rta=U;%f;%f;;", config.wrta, config.crta);
                 }
-                printf(" %s\n", perfdata("pl", (long)pl, "%", wpl > 0 ? true : false, wpl, cpl > 0 ? true : false, cpl, true, 0, false, 0));
 
-                if (verbose >= 2)
-                        printf("%f:%d%% %f:%d%%\n", wrta, wpl, crta, cpl);
+                printf(" %s\n", perfdata("pl", (long)pinged.packet_loss, "%", (bool)(config.wpl > 0), config.wpl, (bool)(config.cpl > 0),
+                                                                 config.cpl, true, 0, false, 0));
+
+                if (verbose >= 2) {
+                        printf("%f:%d%% %f:%d%%\n", config.wrta, config.wpl, config.crta, config.cpl);
+                }
 
-                result = max_state(result, this_result);
+                result = max_state(result, pinged.state);
                 free(rawcmd);
                 free(cmd);
         }
@@ -178,11 +184,7 @@ int main(int argc, char **argv) {
 }
 
 /* process command-line arguments */
-int process_arguments(int argc, char **argv) {
-        int c = 1;
-        char *ptr;
-
-        int option = 0;
+check_ping_config_wrapper process_arguments(int argc, char **argv) {
         static struct option longopts[] = {STD_LONG_OPTS,
                                                                            {"packets", required_argument, 0, 'p'},
                                                                            {"nohtml", no_argument, 0, 'n'},
@@ -191,23 +193,35 @@ int process_arguments(int argc, char **argv) {
                                                                            {"use-ipv6", no_argument, 0, '6'},
                                                                            {0, 0, 0, 0}};
 
-        if (argc < 2)
-                return ERROR;
+        check_ping_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_ping_config_init(),
+        };
+
+        if (argc < 2) {
+                result.errorcode = ERROR;
+                return result;
+        }
 
-        for (c = 1; c < argc; c++) {
-                if (strcmp("-to", argv[c]) == 0)
-                        strcpy(argv[c], "-t");
-                if (strcmp("-nohtml", argv[c]) == 0)
-                        strcpy(argv[c], "-n");
+        for (int index = 1; index < argc; index++) {
+                if (strcmp("-to", argv[index]) == 0) {
+                        strcpy(argv[index], "-t");
+                }
+                if (strcmp("-nohtml", argv[index]) == 0) {
+                        strcpy(argv[index], "-n");
+                }
         }
 
-        while (1) {
-                c = getopt_long(argc, argv, "VvhnL46t:c:w:H:p:", longopts, &option);
+        int option = 0;
+        size_t max_addr = MAX_ADDR_START;
+        while (true) {
+                int option_index = getopt_long(argc, argv, "VvhnL46t:c:w:H:p:", longopts, &option);
 
-                if (c == -1 || c == EOF)
+                if (option_index == -1 || option_index == EOF) {
                         break;
+                }
 
-                switch (c) {
+                switch (option_index) {
                 case '?': /* usage */
                         usage5();
                 case 'h': /* help */
@@ -234,17 +248,18 @@ int process_arguments(int argc, char **argv) {
                         usage(_("IPv6 support not available\n"));
 #endif
                         break;
-                case 'H': /* hostname */
-                        ptr = optarg;
-                        while (1) {
-                                n_addresses++;
-                                if (n_addresses > max_addr) {
+                case 'H': /* hostname */ {
+                        char *ptr = optarg;
+                        while (true) {
+                                result.config.n_addresses++;
+                                if (result.config.n_addresses > max_addr) {
                                         max_addr *= 2;
-                                        addresses = realloc(addresses, sizeof(char *) * max_addr);
-                                        if (addresses == NULL)
+                                        result.config.addresses = realloc(result.config.addresses, sizeof(char *) * max_addr);
+                                        if (result.config.addresses == NULL) {
                                                 die(STATE_UNKNOWN, _("Could not realloc() addresses\n"));
+                                        }
                                 }
-                                addresses[n_addresses - 1] = ptr;
+                                result.config.addresses[result.config.n_addresses - 1] = ptr;
                                 if ((ptr = index(ptr, ','))) {
                                         strcpy(ptr, "");
                                         ptr += sizeof(char);
@@ -252,203 +267,248 @@ int process_arguments(int argc, char **argv) {
                                         break;
                                 }
                         }
-                        break;
+                } break;
                 case 'p': /* number of packets to send */
-                        if (is_intnonneg(optarg))
-                                max_packets = atoi(optarg);
-                        else
+                        if (is_intnonneg(optarg)) {
+                                result.config.max_packets = atoi(optarg);
+                        } else {
                                 usage2(_("<max_packets> (%s) must be a non-negative number\n"), optarg);
+                        }
                         break;
                 case 'n': /* no HTML */
-                        display_html = false;
+                        result.config.display_html = false;
                         break;
                 case 'L': /* show HTML */
-                        display_html = true;
+                        result.config.display_html = true;
                         break;
                 case 'c':
-                        get_threshold(optarg, &crta, &cpl);
+                        get_threshold(optarg, &result.config.crta, &result.config.cpl);
                         break;
                 case 'w':
-                        get_threshold(optarg, &wrta, &wpl);
+                        get_threshold(optarg, &result.config.wrta, &result.config.wpl);
                         break;
                 }
         }
 
-        c = optind;
-        if (c == argc)
-                return validate_arguments();
+        int arg_counter = optind;
+        if (arg_counter == argc) {
+                return validate_arguments(result);
+        }
 
-        if (addresses[0] == NULL) {
-                if (!is_host(argv[c])) {
-                        usage2(_("Invalid hostname/address"), argv[c]);
+        if (result.config.addresses[0] == NULL) {
+                if (!is_host(argv[arg_counter])) {
+                        usage2(_("Invalid hostname/address"), argv[arg_counter]);
                 } else {
-                        addresses[0] = argv[c++];
-                        n_addresses++;
-                        if (c == argc)
-                                return validate_arguments();
+                        result.config.addresses[0] = argv[arg_counter++];
+                        result.config.n_addresses++;
+                        if (arg_counter == argc) {
+                                return validate_arguments(result);
+                        }
                 }
         }
 
-        if (wpl == UNKNOWN_PACKET_LOSS) {
-                if (!is_intpercent(argv[c])) {
-                        printf(_("<wpl> (%s) must be an integer percentage\n"), argv[c]);
-                        return ERROR;
-                } else {
-                        wpl = atoi(argv[c++]);
-                        if (c == argc)
-                                return validate_arguments();
+        if (result.config.wpl == UNKNOWN_PACKET_LOSS) {
+                if (!is_intpercent(argv[arg_counter])) {
+                        printf(_("<wpl> (%s) must be an integer percentage\n"), argv[arg_counter]);
+                        result.errorcode = ERROR;
+                        return result;
+                }
+                result.config.wpl = atoi(argv[arg_counter++]);
+                if (arg_counter == argc) {
+                        return validate_arguments(result);
                 }
         }
 
-        if (cpl == UNKNOWN_PACKET_LOSS) {
-                if (!is_intpercent(argv[c])) {
-                        printf(_("<cpl> (%s) must be an integer percentage\n"), argv[c]);
-                        return ERROR;
-                } else {
-                        cpl = atoi(argv[c++]);
-                        if (c == argc)
-                                return validate_arguments();
+        if (result.config.cpl == UNKNOWN_PACKET_LOSS) {
+                if (!is_intpercent(argv[arg_counter])) {
+                        printf(_("<cpl> (%s) must be an integer percentage\n"), argv[arg_counter]);
+                        result.errorcode = ERROR;
+                        return result;
+                }
+                result.config.cpl = atoi(argv[arg_counter++]);
+                if (arg_counter == argc) {
+                        return validate_arguments(result);
                 }
         }
 
-        if (wrta < 0.0) {
-                if (is_negative(argv[c])) {
-                        printf(_("<wrta> (%s) must be a non-negative number\n"), argv[c]);
-                        return ERROR;
-                } else {
-                        wrta = atof(argv[c++]);
-                        if (c == argc)
-                                return validate_arguments();
+        if (result.config.wrta < 0.0) {
+                if (is_negative(argv[arg_counter])) {
+                        printf(_("<wrta> (%s) must be a non-negative number\n"), argv[arg_counter]);
+                        result.errorcode = ERROR;
+                        return result;
+                }
+                result.config.wrta = atof(argv[arg_counter++]);
+                if (arg_counter == argc) {
+                        return validate_arguments(result);
                 }
         }
 
-        if (crta < 0.0) {
-                if (is_negative(argv[c])) {
-                        printf(_("<crta> (%s) must be a non-negative number\n"), argv[c]);
-                        return ERROR;
-                } else {
-                        crta = atof(argv[c++]);
-                        if (c == argc)
-                                return validate_arguments();
+        if (result.config.crta < 0.0) {
+                if (is_negative(argv[arg_counter])) {
+                        printf(_("<crta> (%s) must be a non-negative number\n"), argv[arg_counter]);
+                        result.errorcode = ERROR;
+                        return result;
+                }
+                result.config.crta = atof(argv[arg_counter++]);
+                if (arg_counter == argc) {
+                        return validate_arguments(result);
                 }
         }
 
-        if (max_packets == -1) {
-                if (is_intnonneg(argv[c])) {
-                        max_packets = atoi(argv[c++]);
+        if (result.config.max_packets == -1) {
+                if (is_intnonneg(argv[arg_counter])) {
+                        result.config.max_packets = atoi(argv[arg_counter++]);
                 } else {
-                        printf(_("<max_packets> (%s) must be a non-negative number\n"), argv[c]);
-                        return ERROR;
+                        printf(_("<max_packets> (%s) must be a non-negative number\n"), argv[arg_counter]);
+                        result.errorcode = ERROR;
+                        return result;
                 }
         }
 
-        return validate_arguments();
+        return validate_arguments(result);
 }
 
-int get_threshold(char *arg, float *trta, int *tpl) {
-        if (is_intnonneg(arg) && sscanf(arg, "%f", trta) == 1)
+int get_threshold(char *arg, double *trta, int *tpl) {
+        if (is_intnonneg(arg) && sscanf(arg, "%lf", trta) == 1) {
                 return OK;
-        else if (strpbrk(arg, ",:") && strstr(arg, "%") && sscanf(arg, "%f%*[:,]%d%%", trta, tpl) == 2)
+        }
+
+        if (strpbrk(arg, ",:") && strstr(arg, "%") && sscanf(arg, "%lf%*[:,]%d%%", trta, tpl) == 2) {
                 return OK;
-        else if (strstr(arg, "%") && sscanf(arg, "%d%%", tpl) == 1)
+        }
+
+        if (strstr(arg, "%") && sscanf(arg, "%d%%", tpl) == 1) {
                 return OK;
+        }
 
         usage2(_("%s: Warning threshold must be integer or percentage!\n\n"), arg);
         return STATE_UNKNOWN;
 }
 
-int validate_arguments() {
-        float max_seconds;
-        int i;
-
-        if (wrta < 0.0) {
+check_ping_config_wrapper validate_arguments(check_ping_config_wrapper config_wrapper) {
+        if (config_wrapper.config.wrta < 0.0) {
                 printf(_("<wrta> was not set\n"));
-                return ERROR;
-        } else if (crta < 0.0) {
+                config_wrapper.errorcode = ERROR;
+                return config_wrapper;
+        }
+
+        if (config_wrapper.config.crta < 0.0) {
                 printf(_("<crta> was not set\n"));
-                return ERROR;
-        } else if (wpl == UNKNOWN_PACKET_LOSS) {
+                config_wrapper.errorcode = ERROR;
+                return config_wrapper;
+        }
+
+        if (config_wrapper.config.wpl == UNKNOWN_PACKET_LOSS) {
                 printf(_("<wpl> was not set\n"));
-                return ERROR;
-        } else if (cpl == UNKNOWN_PACKET_LOSS) {
+                config_wrapper.errorcode = ERROR;
+                return config_wrapper;
+        }
+
+        if (config_wrapper.config.cpl == UNKNOWN_PACKET_LOSS) {
                 printf(_("<cpl> was not set\n"));
-                return ERROR;
-        } else if (wrta > crta) {
-                printf(_("<wrta> (%f) cannot be larger than <crta> (%f)\n"), wrta, crta);
-                return ERROR;
-        } else if (wpl > cpl) {
-                printf(_("<wpl> (%d) cannot be larger than <cpl> (%d)\n"), wpl, cpl);
-                return ERROR;
+                config_wrapper.errorcode = ERROR;
+                return config_wrapper;
+        }
+
+        if (config_wrapper.config.wrta > config_wrapper.config.crta) {
+                printf(_("<wrta> (%f) cannot be larger than <crta> (%f)\n"), config_wrapper.config.wrta, config_wrapper.config.crta);
+                config_wrapper.errorcode = ERROR;
+                return config_wrapper;
         }
 
-        if (max_packets == -1)
-                max_packets = DEFAULT_MAX_PACKETS;
+        if (config_wrapper.config.wpl > config_wrapper.config.cpl) {
+                printf(_("<wpl> (%d) cannot be larger than <cpl> (%d)\n"), config_wrapper.config.wpl, config_wrapper.config.cpl);
+                config_wrapper.errorcode = ERROR;
+                return config_wrapper;
+        }
 
-        max_seconds = crta / 1000.0 * max_packets + max_packets;
-        if (max_seconds > timeout_interval)
-                timeout_interval = (int)max_seconds;
+        if (config_wrapper.config.max_packets == -1) {
+                config_wrapper.config.max_packets = DEFAULT_MAX_PACKETS;
+        }
 
-        for (i = 0; i < n_addresses; i++) {
-                if (!is_host(addresses[i]))
-                        usage2(_("Invalid hostname/address"), addresses[i]);
+        double max_seconds = (config_wrapper.config.crta / 1000.0 * config_wrapper.config.max_packets) + config_wrapper.config.max_packets;
+        if (max_seconds > timeout_interval) {
+                timeout_interval = (unsigned int)max_seconds;
+        }
+
+        for (size_t i = 0; i < config_wrapper.config.n_addresses; i++) {
+                if (!is_host(config_wrapper.config.addresses[i])) {
+                        usage2(_("Invalid hostname/address"), config_wrapper.config.addresses[i]);
+                }
         }
 
-        if (n_addresses == 0) {
+        if (config_wrapper.config.n_addresses == 0) {
                 usage(_("You must specify a server address or host name"));
         }
 
-        return OK;
+        return config_wrapper;
 }
 
-int run_ping(const char *cmd, const char *addr) {
-        char buf[MAX_INPUT_BUFFER];
-        int result = STATE_UNKNOWN;
-        int match;
-
-        if ((child_process = spopen(cmd)) == NULL)
+ping_result run_ping(const char *cmd, const char *addr, double crta) {
+        if ((child_process = spopen(cmd)) == NULL) {
                 die(STATE_UNKNOWN, _("Could not open pipe: %s\n"), cmd);
+        }
 
         child_stderr = fdopen(child_stderr_array[fileno(child_process)], "r");
-        if (child_stderr == NULL)
+        if (child_stderr == NULL) {
                 printf(_("Cannot open stderr for %s\n"), cmd);
+        }
 
-        while (fgets(buf, MAX_INPUT_BUFFER - 1, child_process)) {
+        char buf[MAX_INPUT_BUFFER];
+        ping_result result = {
+                .state = STATE_UNKNOWN,
+                .packet_loss = UNKNOWN_PACKET_LOSS,
+                .round_trip_average = UNKNOWN_TRIP_TIME,
+        };
 
-                if (verbose >= 3)
+        while (fgets(buf, MAX_INPUT_BUFFER - 1, child_process)) {
+                if (verbose >= 3) {
                         printf("Output: %s", buf);
+                }
 
-                result = max_state(result, error_scan(buf, addr));
+                result.state = max_state(result.state, error_scan(buf, addr));
 
                 /* get the percent loss statistics */
-                match = 0;
-                if ((sscanf(buf, "%*d packets transmitted, %*d packets received, +%*d errors, %d%% packet loss%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*d packets transmitted, %*d packets received, +%*d duplicates, %d%% packet loss%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*d packets transmitted, %*d received, +%*d duplicates, %d%% packet loss%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*d packets transmitted, %*d packets received, %d%% packet loss%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*d packets transmitted, %*d packets received, %d%% loss, time%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*d packets transmitted, %*d received, %d%% loss, time%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*d packets transmitted, %*d received, %d%% packet loss, time%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*d packets transmitted, %*d received, +%*d errors, %d%% packet loss%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*d packets transmitted %*d received, +%*d errors, %d%% packet loss%n", &pl, &match) && match) ||
-                        (sscanf(buf, "%*[^(](%d%% %*[^)])%n", &pl, &match) && match))
+                int match = 0;
+                if ((sscanf(buf, "%*d packets transmitted, %*d packets received, +%*d errors, %d%% packet loss%n", &result.packet_loss, &match) ==
+                                 1 &&
+                         match) ||
+                        (sscanf(buf, "%*d packets transmitted, %*d packets received, +%*d duplicates, %d%% packet loss%n", &result.packet_loss,
+                                        &match) == 1 &&
+                         match) ||
+                        (sscanf(buf, "%*d packets transmitted, %*d received, +%*d duplicates, %d%% packet loss%n", &result.packet_loss, &match) == 1 &&
+                         match) ||
+                        (sscanf(buf, "%*d packets transmitted, %*d packets received, %d%% packet loss%n", &result.packet_loss, &match) == 1 && match) ||
+                        (sscanf(buf, "%*d packets transmitted, %*d packets received, %d%% loss, time%n", &result.packet_loss, &match) == 1 && match) ||
+                        (sscanf(buf, "%*d packets transmitted, %*d received, %d%% loss, time%n", &result.packet_loss, &match) == 1 && match) ||
+                        (sscanf(buf, "%*d packets transmitted, %*d received, %d%% packet loss, time%n", &result.packet_loss, &match) == 1 && match) ==
+                                1 ||
+                        (sscanf(buf, "%*d packets transmitted, %*d received, +%*d errors, %d%% packet loss%n", &result.packet_loss, &match) == 1 &&
+                         match) ||
+                        (sscanf(buf, "%*d packets transmitted %*d received, +%*d errors, %d%% packet loss%n", &result.packet_loss, &match) == 1 &&
+                         match) ||
+                        (sscanf(buf, "%*[^(](%d%% %*[^)])%n", &result.packet_loss, &match) == 1 && match)) {
                         continue;
+                }
 
                 /* get the round trip average */
-                else if ((sscanf(buf, "round-trip min/avg/max = %*f/%f/%*f%n", &rta, &match) && match) ||
-                                 (sscanf(buf, "round-trip min/avg/max/mdev = %*f/%f/%*f/%*f%n", &rta, &match) && match) ||
-                                 (sscanf(buf, "round-trip min/avg/max/sdev = %*f/%f/%*f/%*f%n", &rta, &match) && match) ||
-                                 (sscanf(buf, "round-trip min/avg/max/stddev = %*f/%f/%*f/%*f%n", &rta, &match) && match) ||
-                                 (sscanf(buf, "round-trip min/avg/max/std-dev = %*f/%f/%*f/%*f%n", &rta, &match) && match) ||
-                                 (sscanf(buf, "round-trip (ms) min/avg/max = %*f/%f/%*f%n", &rta, &match) && match) ||
-                                 (sscanf(buf, "round-trip (ms) min/avg/max/stddev = %*f/%f/%*f/%*f%n", &rta, &match) && match) ||
-                                 (sscanf(buf, "rtt min/avg/max/mdev = %*f/%f/%*f/%*f ms%n", &rta, &match) && match) ||
-                                 (sscanf(buf, "%*[^=] = %*fms, %*[^=] = %*fms, %*[^=] = %fms%n", &rta, &match) && match))
+                if ((sscanf(buf, "round-trip min/avg/max = %*f/%lf/%*f%n", &result.round_trip_average, &match) == 1 && match) ||
+                        (sscanf(buf, "round-trip min/avg/max/mdev = %*f/%lf/%*f/%*f%n", &result.round_trip_average, &match) == 1 && match) ||
+                        (sscanf(buf, "round-trip min/avg/max/sdev = %*f/%lf/%*f/%*f%n", &result.round_trip_average, &match) == 1 && match) ||
+                        (sscanf(buf, "round-trip min/avg/max/stddev = %*f/%lf/%*f/%*f%n", &result.round_trip_average, &match) == 1 && match) ||
+                        (sscanf(buf, "round-trip min/avg/max/std-dev = %*f/%lf/%*f/%*f%n", &result.round_trip_average, &match) == 1 && match) ||
+                        (sscanf(buf, "round-trip (ms) min/avg/max = %*f/%lf/%*f%n", &result.round_trip_average, &match) == 1 && match) ||
+                        (sscanf(buf, "round-trip (ms) min/avg/max/stddev = %*f/%lf/%*f/%*f%n", &result.round_trip_average, &match) == 1 && match) ||
+                        (sscanf(buf, "rtt min/avg/max/mdev = %*f/%lf/%*f/%*f ms%n", &result.round_trip_average, &match) == 1 && match) ||
+                        (sscanf(buf, "%*[^=] = %*fms, %*[^=] = %*fms, %*[^=] = %lfms%n", &result.round_trip_average, &match) == 1 && match)) {
                         continue;
+                }
         }
 
         /* this is needed because there is no rta if all packets are lost */
-        if (pl == 100)
-                rta = crta;
+        if (result.packet_loss == 100) {
+                result.round_trip_average = crta;
+        }
 
         /* check stderr, setting at least WARNING if there is output here */
         /* Add warning into warn_text */
@@ -459,8 +519,8 @@ int run_ping(const char *cmd, const char *addr) {
                         if (verbose >= 3) {
                                 printf("Got stderr: %s", buf);
                         }
-                        if ((result = error_scan(buf, addr)) == STATE_OK) {
-                                result = STATE_WARNING;
+                        if ((result.state = error_scan(buf, addr)) == STATE_OK) {
+                                result.state = STATE_WARNING;
                                 if (warn_text == NULL) {
                                         warn_text = strdup(_("System call sent warnings to stderr "));
                                 } else {
@@ -474,43 +534,46 @@ int run_ping(const char *cmd, const char *addr) {
 
         spclose(child_process);
 
-        if (warn_text == NULL)
+        if (warn_text == NULL) {
                 warn_text = strdup("");
+        }
 
         return result;
 }
 
-int error_scan(char buf[MAX_INPUT_BUFFER], const char *addr) {
-        if (strstr(buf, "Network is unreachable") || strstr(buf, "Destination Net Unreachable") || strstr(buf, "No route"))
+mp_state_enum error_scan(char buf[MAX_INPUT_BUFFER], const char *addr) {
+        if (strstr(buf, "Network is unreachable") || strstr(buf, "Destination Net Unreachable") || strstr(buf, "No route")) {
                 die(STATE_CRITICAL, _("CRITICAL - Network Unreachable (%s)\n"), addr);
-        else if (strstr(buf, "Destination Host Unreachable") || strstr(buf, "Address unreachable"))
+        } else if (strstr(buf, "Destination Host Unreachable") || strstr(buf, "Address unreachable")) {
                 die(STATE_CRITICAL, _("CRITICAL - Host Unreachable (%s)\n"), addr);
-        else if (strstr(buf, "Destination Port Unreachable") || strstr(buf, "Port unreachable"))
+        } else if (strstr(buf, "Destination Port Unreachable") || strstr(buf, "Port unreachable")) {
                 die(STATE_CRITICAL, _("CRITICAL - Bogus ICMP: Port Unreachable (%s)\n"), addr);
-        else if (strstr(buf, "Destination Protocol Unreachable"))
+        } else if (strstr(buf, "Destination Protocol Unreachable")) {
                 die(STATE_CRITICAL, _("CRITICAL - Bogus ICMP: Protocol Unreachable (%s)\n"), addr);
-        else if (strstr(buf, "Destination Net Prohibited"))
+        } else if (strstr(buf, "Destination Net Prohibited")) {
                 die(STATE_CRITICAL, _("CRITICAL - Network Prohibited (%s)\n"), addr);
-        else if (strstr(buf, "Destination Host Prohibited"))
+        } else if (strstr(buf, "Destination Host Prohibited")) {
                 die(STATE_CRITICAL, _("CRITICAL - Host Prohibited (%s)\n"), addr);
-        else if (strstr(buf, "Packet filtered") || strstr(buf, "Administratively prohibited"))
+        } else if (strstr(buf, "Packet filtered") || strstr(buf, "Administratively prohibited")) {
                 die(STATE_CRITICAL, _("CRITICAL - Packet Filtered (%s)\n"), addr);
-        else if (strstr(buf, "unknown host"))
+        } else if (strstr(buf, "unknown host")) {
                 die(STATE_CRITICAL, _("CRITICAL - Host not found (%s)\n"), addr);
-        else if (strstr(buf, "Time to live exceeded") || strstr(buf, "Time exceeded"))
+        } else if (strstr(buf, "Time to live exceeded") || strstr(buf, "Time exceeded")) {
                 die(STATE_CRITICAL, _("CRITICAL - Time to live exceeded (%s)\n"), addr);
-        else if (strstr(buf, "Destination unreachable: "))
+        } else if (strstr(buf, "Destination unreachable: ")) {
                 die(STATE_CRITICAL, _("CRITICAL - Destination Unreachable (%s)\n"), addr);
+        }
 
         if (strstr(buf, "(DUP!)") || strstr(buf, "DUPLICATES FOUND")) {
-                if (warn_text == NULL)
+                if (warn_text == NULL) {
                         warn_text = strdup(_(WARN_DUPLICATES));
-                else if (!strstr(warn_text, _(WARN_DUPLICATES)) && xasprintf(&warn_text, "%s %s", warn_text, _(WARN_DUPLICATES)) == -1)
+                } else if (!strstr(warn_text, _(WARN_DUPLICATES)) && xasprintf(&warn_text, "%s %s", warn_text, _(WARN_DUPLICATES)) == -1) {
                         die(STATE_UNKNOWN, _("Unable to realloc warn_text\n"));
-                return (STATE_WARNING);
+                }
+                return STATE_WARNING;
         }
 
-        return (STATE_OK);
+        return STATE_OK;
 }
 
 void print_help(void) {
@@ -551,9 +614,7 @@ void print_help(void) {
 
         printf("\n");
         printf("%s\n", _("This plugin uses the ping command to probe the specified host for packet loss"));
-        printf("%s\n", _("(percentage) and round trip average (milliseconds). It can produce HTML output"));
-        printf("%s\n", _("linking to a traceroute CGI contributed by Ian Cass. The CGI can be found in"));
-        printf("%s\n", _("the contrib area of the downloads section at http://www.nagios.org/"));
+        printf("%s\n", _("(percentage) and round trip average (milliseconds). It can produce HTML output."));
 
         printf(UT_SUPPORT);
 }
diff --git a/plugins/check_ping.d/config.h b/plugins/check_ping.d/config.h
new file mode 100644
index 00000000..eb2735a7
--- /dev/null
+++ b/plugins/check_ping.d/config.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "../../config.h"
+#include <stddef.h>
+#include <stdlib.h>
+
+enum {
+        UNKNOWN_PACKET_LOSS = 200, /* 200% */
+        DEFAULT_MAX_PACKETS = 5    /* default no. of ICMP ECHO packets */
+};
+
+#define UNKNOWN_TRIP_TIME -1.0 /* -1 seconds */
+
+#define MAX_ADDR_START 1
+
+typedef struct {
+        bool display_html;
+        int max_packets;
+
+        char **addresses;
+        size_t n_addresses;
+
+        int wpl;
+        int cpl;
+        double wrta;
+        double crta;
+} check_ping_config;
+
+check_ping_config check_ping_config_init() {
+        check_ping_config tmp = {
+                .display_html = false,
+                .max_packets = -1,
+
+                .addresses = NULL,
+                .n_addresses = 0,
+
+                .wpl = UNKNOWN_PACKET_LOSS,
+                .cpl = UNKNOWN_PACKET_LOSS,
+                .wrta = UNKNOWN_TRIP_TIME,
+                .crta = UNKNOWN_TRIP_TIME,
+        };
+
+        tmp.addresses = calloc(MAX_ADDR_START, sizeof(char *));
+        tmp.addresses[0] = NULL;
+        return tmp;
+}
diff --git a/plugins/check_radius.c b/plugins/check_radius.c
index d9ff8fa7..cc846709 100644
--- a/plugins/check_radius.c
+++ b/plugins/check_radius.c
@@ -1,32 +1,32 @@
 /*****************************************************************************
-* 
-* Monitoring check_radius plugin
-* 
-* License: GPL
-* Copyright (c) 1999-2024 Monitoring Plugins Development Team
-* 
-* Description:
-* 
-* This file contains the check_radius plugin
-* 
-* Tests to see if a radius server is accepting connections.
-* 
-* 
-* 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/>.
-* 
-* 
-*****************************************************************************/
+ *
+ * Monitoring check_radius plugin
+ *
+ * License: GPL
+ * Copyright (c) 1999-2024 Monitoring Plugins Development Team
+ *
+ * Description:
+ *
+ * This file contains the check_radius plugin
+ *
+ * Tests to see if a radius server is accepting connections.
+ *
+ *
+ * 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_radius";
 const char *copyright = "2000-2024";
@@ -35,64 +35,57 @@ const char *email = "devel@monitoring-plugins.org";
 #include "common.h"
 #include "utils.h"
 #include "netutils.h"
+#include "states.h"
+#include "check_radius.d/config.h"
 
 #if defined(HAVE_LIBRADCLI)
-#include <radcli/radcli.h>
+#       include <radcli/radcli.h>
 #elif defined(HAVE_LIBFREERADIUS_CLIENT)
-#include <freeradius-client.h>
+#       include <freeradius-client.h>
 #elif defined(HAVE_LIBRADIUSCLIENT_NG)
-#include <radiusclient-ng.h>
+#       include <radiusclient-ng.h>
 #else
-#include <radiusclient.h>
+#       include <radiusclient.h>
 #endif
 
-static int process_arguments (int /*argc*/, char ** /*argv*/);
-static void print_help (void);
-void print_usage (void);
+typedef struct {
+        int errorcode;
+        check_radius_config config;
+} check_radius_config_wrapper;
+static check_radius_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
+static void print_help(void);
+void print_usage(void);
 
 #if defined(HAVE_LIBFREERADIUS_CLIENT) || defined(HAVE_LIBRADIUSCLIENT_NG) || defined(HAVE_LIBRADCLI)
-#define my_rc_conf_str(a) rc_conf_str(rch,a)
-#if defined(HAVE_LIBRADCLI)
-#define my_rc_send_server(a,b) rc_send_server(rch,a,b,AUTH)
-#else
-#define my_rc_send_server(a,b) rc_send_server(rch,a,b)
-#endif
-#if defined(HAVE_LIBFREERADIUS_CLIENT) || defined(HAVE_LIBRADCLI)
-#define my_rc_buildreq(a,b,c,d,e,f) rc_buildreq(rch,a,b,c,d,(a)->secret,e,f)
-#else
-#define my_rc_buildreq(a,b,c,d,e,f) rc_buildreq(rch,a,b,c,d,e,f)
-#endif
-#define my_rc_avpair_add(a,b,c,d) rc_avpair_add(rch,a,b,c,-1,d)
-#define my_rc_read_dictionary(a) rc_read_dictionary(rch, a)
+#       define my_rc_conf_str(a) rc_conf_str(rch, a)
+#       if defined(HAVE_LIBRADCLI)
+#               define my_rc_send_server(a, b) rc_send_server(rch, a, b, AUTH)
+#       else
+#               define my_rc_send_server(a, b) rc_send_server(rch, a, b)
+#       endif
+#       if defined(HAVE_LIBFREERADIUS_CLIENT) || defined(HAVE_LIBRADCLI)
+#               define my_rc_buildreq(a, b, c, d, e, f) rc_buildreq(rch, a, b, c, d, (a)->secret, e, f)
+#       else
+#               define my_rc_buildreq(a, b, c, d, e, f) rc_buildreq(rch, a, b, c, d, e, f)
+#       endif
+#       define my_rc_avpair_add(a, b, c, d) rc_avpair_add(rch, a, b, c, -1, d)
+#       define my_rc_read_dictionary(a)     rc_read_dictionary(rch, a)
 #else
-#define my_rc_conf_str(a) rc_conf_str(a)
-#define my_rc_send_server(a,b) rc_send_server(a, b)
-#define my_rc_buildreq(a,b,c,d,e,f) rc_buildreq(a,b,c,d,e,f)
-#define my_rc_avpair_add(a,b,c,d) rc_avpair_add(a, b, c, d)
-#define my_rc_read_dictionary(a) rc_read_dictionary(a)
+#       define my_rc_conf_str(a)                rc_conf_str(a)
+#       define my_rc_send_server(a, b)          rc_send_server(a, b)
+#       define my_rc_buildreq(a, b, c, d, e, f) rc_buildreq(a, b, c, d, e, f)
+#       define my_rc_avpair_add(a, b, c, d)     rc_avpair_add(a, b, c, d)
+#       define my_rc_read_dictionary(a)         rc_read_dictionary(a)
 #endif
 
 /* REJECT_RC is only defined in some version of radiusclient. It has
  * been reported from radiusclient-ng 0.5.6 on FreeBSD 7.2-RELEASE */
 #ifndef REJECT_RC
-#define REJECT_RC BADRESP_RC
+#       define REJECT_RC BADRESP_RC
 #endif
 
-static int my_rc_read_config(char * /*a*/);
-
-#if defined(HAVE_LIBFREERADIUS_CLIENT) || defined(HAVE_LIBRADIUSCLIENT_NG) || defined(HAVE_LIBRADCLI)
-static rc_handle *rch = NULL;
-#endif
+static int my_rc_read_config(char * /*a*/, rc_handle ** /*rch*/);
 
-static char *server = NULL;
-static char *username = NULL;
-static char *password = NULL;
-static char *nasid = NULL;
-static char *nasipaddress = NULL;
-static char *expect = NULL;
-static char *config_file = NULL;
-static unsigned short port = PW_AUTH_UDP_PORT;
-static int retries = 1;
 static bool verbose = false;
 
 /******************************************************************************
@@ -148,149 +141,167 @@ Please note that all tags must be lowercase to use the DocBook XML DTD.
 -@@
 ******************************************************************************/
 
+int main(int argc, char **argv) {
+        setlocale(LC_ALL, "");
+        bindtextdomain(PACKAGE, LOCALEDIR);
+        textdomain(PACKAGE);
 
+        /* Parse extra opts if any */
+        argv = np_extra_opts(&argc, argv, progname);
+
+        check_radius_config_wrapper tmp_config = process_arguments(argc, argv);
+
+        if (tmp_config.errorcode == ERROR) {
+                usage4(_("Could not parse arguments"));
+        }
+
+        check_radius_config config = tmp_config.config;
+
+#if defined(HAVE_LIBFREERADIUS_CLIENT) || defined(HAVE_LIBRADIUSCLIENT_NG) || defined(HAVE_LIBRADCLI)
+        rc_handle *rch = NULL;
+#endif
+
+        char *str = strdup("dictionary");
+        if ((config.config_file && my_rc_read_config(config.config_file, &rch)) || my_rc_read_dictionary(my_rc_conf_str(str))) {
+                die(STATE_UNKNOWN, _("Config file error\n"));
+        }
+
+        uint32_t service = PW_AUTHENTICATE_ONLY;
+
+        SEND_DATA data;
+        memset(&data, 0, sizeof(data));
+        if (!(my_rc_avpair_add(&data.send_pairs, PW_SERVICE_TYPE, &service, 0) &&
+                  my_rc_avpair_add(&data.send_pairs, PW_USER_NAME, config.username, 0) &&
+                  my_rc_avpair_add(&data.send_pairs, PW_USER_PASSWORD, config.password, 0))) {
+                die(STATE_UNKNOWN, _("Out of Memory?\n"));
+        }
+
+        if (config.nas_id != NULL) {
+                if (!(my_rc_avpair_add(&data.send_pairs, PW_NAS_IDENTIFIER, config.nas_id, 0))) {
+                        die(STATE_UNKNOWN, _("Invalid NAS-Identifier\n"));
+                }
+        }
 
-int
-main (int argc, char **argv)
-{
-        struct sockaddr_storage ss;
         char name[HOST_NAME_MAX];
+        if (config.nas_ip_address == NULL) {
+                if (gethostname(name, sizeof(name)) != 0) {
+                        die(STATE_UNKNOWN, _("gethostname() failed!\n"));
+                }
+                config.nas_ip_address = name;
+        }
+
+        struct sockaddr_storage radius_server_socket;
+        if (!dns_lookup(config.nas_ip_address, &radius_server_socket, AF_UNSPEC)) {
+                die(STATE_UNKNOWN, _("Invalid NAS-IP-Address\n"));
+        }
+
+        uint32_t client_id = ntohl(((struct sockaddr_in *)&radius_server_socket)->sin_addr.s_addr);
+        if (my_rc_avpair_add(&(data.send_pairs), PW_NAS_IP_ADDRESS, &client_id, 0) == NULL) {
+                die(STATE_UNKNOWN, _("Invalid NAS-IP-Address\n"));
+        }
+
+        my_rc_buildreq(&data, PW_ACCESS_REQUEST, config.server, config.port, (int)timeout_interval, config.retries);
+
 #ifdef RC_BUFFER_LEN
         char msg[RC_BUFFER_LEN];
 #else
         char msg[BUFFER_LEN];
 #endif
-        SEND_DATA data;
-        int result = STATE_UNKNOWN;
-        uint32_t client_id, service;
-        char *str;
-
-        setlocale (LC_ALL, "");
-        bindtextdomain (PACKAGE, LOCALEDIR);
-        textdomain (PACKAGE);
 
-        /* Parse extra opts if any */
-        argv=np_extra_opts (&argc, argv, progname);
+        int result = my_rc_send_server(&data, msg);
+        rc_avpair_free(data.send_pairs);
+        if (data.receive_pairs) {
+                rc_avpair_free(data.receive_pairs);
+        }
 
-        if (process_arguments (argc, argv) == ERROR)
-                usage4 (_("Could not parse arguments"));
+        if (result == TIMEOUT_RC) {
+                printf("Timeout\n");
+                exit(STATE_CRITICAL);
+        }
 
-        str = strdup ("dictionary");
-        if ((config_file && my_rc_read_config (config_file)) ||
-                        my_rc_read_dictionary (my_rc_conf_str (str)))
-                die (STATE_UNKNOWN, _("Config file error\n"));
+        if (result == ERROR_RC) {
+                printf(_("Auth Error\n"));
+                exit(STATE_CRITICAL);
+        }
 
-        service = PW_AUTHENTICATE_ONLY;
+        if (result == REJECT_RC) {
+                printf(_("Auth Failed\n"));
+                exit(STATE_WARNING);
+        }
 
-        memset (&data, 0, sizeof(data));
-        if (!(my_rc_avpair_add (&data.send_pairs, PW_SERVICE_TYPE, &service, 0) &&
-                                my_rc_avpair_add (&data.send_pairs, PW_USER_NAME, username, 0) &&
-                                my_rc_avpair_add (&data.send_pairs, PW_USER_PASSWORD, password, 0)
-                                ))
-                die (STATE_UNKNOWN, _("Out of Memory?\n"));
+        if (result == BADRESP_RC) {
+                printf(_("Bad Response\n"));
+                exit(STATE_WARNING);
+        }
 
-        if (nasid != NULL) {
-                if (!(my_rc_avpair_add (&data.send_pairs, PW_NAS_IDENTIFIER, nasid, 0)))
-                        die (STATE_UNKNOWN, _("Invalid NAS-Identifier\n"));
+        if (config.expect && !strstr(msg, config.expect)) {
+                printf("%s\n", msg);
+                exit(STATE_WARNING);
         }
 
-        if (nasipaddress == NULL) {
-                if (gethostname (name, sizeof(name)) != 0)
-                        die (STATE_UNKNOWN, _("gethostname() failed!\n"));
-                nasipaddress = name;
+        if (result == OK_RC) {
+                printf(_("Auth OK\n"));
+                exit(STATE_OK);
         }
-        if (!dns_lookup (nasipaddress, &ss, AF_INET)) /* TODO: Support IPv6. */
-                die (STATE_UNKNOWN, _("Invalid NAS-IP-Address\n"));
-        client_id = ntohl (((struct sockaddr_in *)&ss)->sin_addr.s_addr);
-        if (my_rc_avpair_add (&(data.send_pairs), PW_NAS_IP_ADDRESS, &client_id, 0) == NULL)
-                die (STATE_UNKNOWN, _("Invalid NAS-IP-Address\n"));
-
-        my_rc_buildreq (&data, PW_ACCESS_REQUEST, server, port, (int)timeout_interval,
-                     retries);
-
-        result = my_rc_send_server (&data, msg);
-        rc_avpair_free (data.send_pairs);
-        if (data.receive_pairs)
-                rc_avpair_free (data.receive_pairs);
-
-        if (result == TIMEOUT_RC)
-                die (STATE_CRITICAL, _("Timeout\n"));
-        if (result == ERROR_RC)
-                die (STATE_CRITICAL, _("Auth Error\n"));
-        if (result == REJECT_RC)
-                die (STATE_WARNING, _("Auth Failed\n"));
-        if (result == BADRESP_RC)
-                die (STATE_WARNING, _("Bad Response\n"));
-        if (expect && !strstr (msg, expect))
-                die (STATE_WARNING, "%s\n", msg);
-        if (result == OK_RC)
-                die (STATE_OK, _("Auth OK\n"));
+
         (void)snprintf(msg, sizeof(msg), _("Unexpected result code %d"), result);
-        die (STATE_UNKNOWN, "%s\n", msg);
+        printf("%s\n", msg);
+        exit(STATE_UNKNOWN);
 }
 
-
-
 /* process command-line arguments */
-int
-process_arguments (int argc, char **argv)
-{
-        int c;
-
-        int option = 0;
-        static struct option longopts[] = {
-                {"hostname", required_argument, 0, 'H'},
-                {"port", required_argument, 0, 'P'},
-                {"username", required_argument, 0, 'u'},
-                {"password", required_argument, 0, 'p'},
-                {"nas-id", required_argument, 0, 'n'},
-                {"nas-ip-address", required_argument, 0, 'N'},
-                {"filename", required_argument, 0, 'F'},
-                {"expect", required_argument, 0, 'e'},
-                {"retries", required_argument, 0, 'r'},
-                {"timeout", required_argument, 0, 't'},
-                {"verbose", no_argument, 0, 'v'},
-                {"version", no_argument, 0, 'V'},
-                {"help", no_argument, 0, 'h'},
-                {0, 0, 0, 0}
+check_radius_config_wrapper process_arguments(int argc, char **argv) {
+        static struct option longopts[] = {{"hostname", required_argument, 0, 'H'}, {"port", required_argument, 0, 'P'},
+                                                                           {"username", required_argument, 0, 'u'}, {"password", required_argument, 0, 'p'},
+                                                                           {"nas-id", required_argument, 0, 'n'},   {"nas-ip-address", required_argument, 0, 'N'},
+                                                                           {"filename", required_argument, 0, 'F'}, {"expect", required_argument, 0, 'e'},
+                                                                           {"retries", required_argument, 0, 'r'},  {"timeout", required_argument, 0, 't'},
+                                                                           {"verbose", no_argument, 0, 'v'},        {"version", no_argument, 0, 'V'},
+                                                                           {"help", no_argument, 0, 'h'},           {0, 0, 0, 0}};
+
+        check_radius_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_radius_config_init(),
         };
 
-        while (1) {
-                c = getopt_long (argc, argv, "+hVvH:P:F:u:p:n:N:t:r:e:", longopts,
-                                                                         &option);
+        while (true) {
+                int option = 0;
+                int option_index = getopt_long(argc, argv, "+hVvH:P:F:u:p:n:N:t:r:e:", longopts, &option);
 
-                if (c == -1 || c == EOF || c == 1)
+                if (option_index == -1 || option_index == EOF || option_index == 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 'v':                                                                       /* verbose mode */
+                switch (option_index) {
+                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 'v': /* verbose mode */
                         verbose = true;
                         break;
-                case 'H':                                                                       /* hostname */
-                        if (!is_host (optarg)) {
-                                usage2 (_("Invalid hostname/address"), optarg);
+                case 'H': /* hostname */
+                        if (!is_host(optarg)) {
+                                usage2(_("Invalid hostname/address"), optarg);
                         }
-                        server = optarg;
+                        result.config.server = optarg;
                         break;
-                case 'P':                                                                       /* port */
-                        if (is_intnonneg (optarg))
-                                port = (unsigned short)atoi (optarg);
-                        else
-                                usage4 (_("Port must be a positive integer"));
+                case 'P': /* port */
+                        if (is_intnonneg(optarg)) {
+                                result.config.port = (unsigned short)atoi(optarg);
+                        } else {
+                                usage4(_("Port must be a positive integer"));
+                        }
                         break;
-                case 'u':                                                                       /* username */
-                        username = optarg;
+                case 'u': /* username */
+                        result.config.username = optarg;
                         break;
-                case 'p':                                                                       /* password */
-                        password = strdup(optarg);
+                case 'p': /* password */
+                        result.config.password = strdup(optarg);
 
                         /* Delete the password from process list */
                         while (*optarg != '\0') {
@@ -298,119 +309,115 @@ process_arguments (int argc, char **argv)
                                 optarg++;
                         }
                         break;
-                case 'n':                                                                       /* nas id */
-                        nasid = optarg;
+                case 'n': /* nas id */
+                        result.config.nas_id = optarg;
                         break;
-                case 'N':                                                                       /* nas ip address */
-                        nasipaddress = optarg;
+                case 'N': /* nas ip address */
+                        result.config.nas_ip_address = optarg;
                         break;
-                case 'F':                                                                       /* configuration file */
-                        config_file = optarg;
+                case 'F': /* configuration file */
+                        result.config.config_file = optarg;
                         break;
-                case 'e':                                                                       /* expect */
-                        expect = optarg;
+                case 'e': /* expect */
+                        result.config.expect = optarg;
                         break;
-                case 'r':                                                                       /* retries */
-                        if (is_intpos (optarg))
-                                retries = atoi (optarg);
-                        else
-                                usage4 (_("Number of retries must be a positive integer"));
+                case 'r': /* retries */
+                        if (is_intpos(optarg)) {
+                                result.config.retries = atoi(optarg);
+                        } else {
+                                usage4(_("Number of retries must be a positive integer"));
+                        }
                         break;
-                case 't':                                                                       /* timeout */
-                        if (is_intpos (optarg))
-                                timeout_interval = (unsigned)atoi (optarg);
-                        else
-                                usage2 (_("Timeout interval must be a positive integer"), optarg);
+                case 't': /* timeout */
+                        if (is_intpos(optarg)) {
+                                timeout_interval = (unsigned)atoi(optarg);
+                        } else {
+                                usage2(_("Timeout interval must be a positive integer"), optarg);
+                        }
                         break;
                 }
         }
 
-        if (server == NULL)
-                usage4 (_("Hostname was not supplied"));
-        if (username == NULL)
-                usage4 (_("User not specified"));
-        if (password == NULL)
-                usage4 (_("Password not specified"));
-        if (config_file == NULL)
-                usage4 (_("Configuration file not specified"));
+        if (result.config.server == NULL) {
+                usage4(_("Hostname was not supplied"));
+        }
+        if (result.config.username == NULL) {
+                usage4(_("User not specified"));
+        }
+        if (result.config.password == NULL) {
+                usage4(_("Password not specified"));
+        }
+        if (result.config.config_file == NULL) {
+                usage4(_("Configuration file not specified"));
+        }
 
-        return OK;
+        return result;
 }
 
-
-
-void
-print_help (void)
-{
+void print_help(void) {
         char *myport;
-        xasprintf (&myport, "%d", PW_AUTH_UDP_PORT);
+        xasprintf(&myport, "%d", PW_AUTH_UDP_PORT);
 
-        print_revision (progname, NP_VERSION);
+        print_revision(progname, NP_VERSION);
 
-        printf ("Copyright (c) 1999 Robert August Vincent II\n");
-        printf (COPYRIGHT, copyright, email);
+        printf("Copyright (c) 1999 Robert August Vincent II\n");
+        printf(COPYRIGHT, copyright, email);
 
         printf("%s\n", _("Tests to see if a RADIUS server is accepting connections."));
 
-  printf ("\n\n");
-
-        print_usage ();
-
-        printf (UT_HELP_VRSN);
-        printf (UT_EXTRA_OPTS);
-
-        printf (UT_HOST_PORT, 'P', myport);
-
-        printf (" %s\n", "-u, --username=STRING");
-  printf ("    %s\n", _("The user to authenticate"));
-  printf (" %s\n", "-p, --password=STRING");
-  printf ("    %s\n", _("Password for authentication (SECURITY RISK)"));
-  printf (" %s\n", "-n, --nas-id=STRING");
-  printf ("    %s\n", _("NAS identifier"));
-  printf (" %s\n", "-N, --nas-ip-address=STRING");
-  printf ("    %s\n", _("NAS IP Address"));
-  printf (" %s\n", "-F, --filename=STRING");
-  printf ("    %s\n", _("Configuration file"));
-  printf (" %s\n", "-e, --expect=STRING");
-  printf ("    %s\n", _("Response string to expect from the server"));
-  printf (" %s\n", "-r, --retries=INTEGER");
-  printf ("    %s\n", _("Number of times to retry a failed connection"));
-
-        printf (UT_CONN_TIMEOUT, timeout_interval);
-
-  printf ("\n");
-  printf ("%s\n", _("This plugin tests a RADIUS server to see if it is accepting connections."));
-  printf ("%s\n", _("The server to test must be specified in the invocation, as well as a user"));
-  printf ("%s\n", _("name and password. A configuration file must be present. The format of"));
-  printf ("%s\n", _("the configuration file is described in the radiusclient library sources."));
-        printf ("%s\n", _("The password option presents a substantial security issue because the"));
-  printf ("%s\n", _("password can possibly be determined by careful watching of the command line"));
-  printf ("%s\n", _("in a process listing. This risk is exacerbated because the plugin will"));
-  printf ("%s\n", _("typically be executed at regular predictable intervals. Please be sure that"));
-  printf ("%s\n", _("the password used does not allow access to sensitive system resources."));
-
-        printf (UT_SUPPORT);
+        printf("\n\n");
+
+        print_usage();
+
+        printf(UT_HELP_VRSN);
+        printf(UT_EXTRA_OPTS);
+
+        printf(UT_HOST_PORT, 'P', myport);
+
+        printf(" %s\n", "-u, --username=STRING");
+        printf("    %s\n", _("The user to authenticate"));
+        printf(" %s\n", "-p, --password=STRING");
+        printf("    %s\n", _("Password for authentication (SECURITY RISK)"));
+        printf(" %s\n", "-n, --nas-id=STRING");
+        printf("    %s\n", _("NAS identifier"));
+        printf(" %s\n", "-N, --nas-ip-address=STRING");
+        printf("    %s\n", _("NAS IP Address"));
+        printf(" %s\n", "-F, --filename=STRING");
+        printf("    %s\n", _("Configuration file"));
+        printf(" %s\n", "-e, --expect=STRING");
+        printf("    %s\n", _("Response string to expect from the server"));
+        printf(" %s\n", "-r, --retries=INTEGER");
+        printf("    %s\n", _("Number of times to retry a failed connection"));
+
+        printf(UT_CONN_TIMEOUT, timeout_interval);
+
+        printf("\n");
+        printf("%s\n", _("This plugin tests a RADIUS server to see if it is accepting connections."));
+        printf("%s\n", _("The server to test must be specified in the invocation, as well as a user"));
+        printf("%s\n", _("name and password. A configuration file must be present. The format of"));
+        printf("%s\n", _("the configuration file is described in the radiusclient library sources."));
+        printf("%s\n", _("The password option presents a substantial security issue because the"));
+        printf("%s\n", _("password can possibly be determined by careful watching of the command line"));
+        printf("%s\n", _("in a process listing. This risk is exacerbated because the plugin will"));
+        printf("%s\n", _("typically be executed at regular predictable intervals. Please be sure that"));
+        printf("%s\n", _("the password used does not allow access to sensitive system resources."));
+
+        printf(UT_SUPPORT);
 }
 
-
-
-void
-print_usage (void)
-{
-  printf ("%s\n", _("Usage:"));
-        printf ("%s -H host -F config_file -u username -p password\n\
+void print_usage(void) {
+        printf("%s\n", _("Usage:"));
+        printf("%s -H host -F config_file -u username -p password\n\
                         [-P port] [-t timeout] [-r retries] [-e expect]\n\
-                        [-n nas-id] [-N nas-ip-addr]\n", progname);
+                        [-n nas-id] [-N nas-ip-addr]\n",
+                   progname);
 }
 
-
-
-int my_rc_read_config(char * a)
-{
+int my_rc_read_config(char *config_file_name, rc_handle **rch) {
 #if defined(HAVE_LIBFREERADIUS_CLIENT) || defined(HAVE_LIBRADIUSCLIENT_NG) || defined(HAVE_LIBRADCLI)
-        rch = rc_read_config(a);
+        *rch = rc_read_config(config_file_name);
         return (rch == NULL) ? 1 : 0;
 #else
-        return rc_read_config(a);
+        return rc_read_config(config_file_name);
 #endif
 }
diff --git a/plugins/check_radius.d/config.h b/plugins/check_radius.d/config.h
new file mode 100644
index 00000000..b27d31e7
--- /dev/null
+++ b/plugins/check_radius.d/config.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "../../config.h"
+#include <stddef.h>
+#if defined(HAVE_LIBRADCLI)
+#       include <radcli/radcli.h>
+#elif defined(HAVE_LIBFREERADIUS_CLIENT)
+#       include <freeradius-client.h>
+#elif defined(HAVE_LIBRADIUSCLIENT_NG)
+#       include <radiusclient-ng.h>
+#else
+#       include <radiusclient.h>
+#endif
+
+typedef struct {
+        char *server;
+        char *username;
+        char *password;
+        char *config_file;
+        char *nas_id;
+        char *nas_ip_address;
+        int retries;
+        unsigned short port;
+
+        char *expect;
+} check_radius_config;
+
+check_radius_config check_radius_config_init() {
+        check_radius_config tmp = {
+                .server = NULL,
+                .username = NULL,
+                .password = NULL,
+                .config_file = NULL,
+                .nas_id = NULL,
+                .nas_ip_address = NULL,
+                .retries = 1,
+                .port = PW_AUTH_UDP_PORT,
+
+                .expect = NULL,
+        };
+        return tmp;
+}
diff --git a/plugins/check_real.c b/plugins/check_real.c
index 369a88b1..ec0928ed 100644
--- a/plugins/check_real.c
+++ b/plugins/check_real.c
@@ -28,6 +28,8 @@
  *
  *****************************************************************************/
 
+#include "states.h"
+#include <stdio.h>
 const char *progname = "check_real";
 const char *copyright = "2000-2024";
 const char *email = "devel@monitoring-plugins.org";
@@ -35,27 +37,20 @@ const char *email = "devel@monitoring-plugins.org";
 #include "common.h"
 #include "netutils.h"
 #include "utils.h"
-
-enum {
-        PORT = 554
-};
+#include "check_real.d/config.h"
 
 #define EXPECT "RTSP/1."
 #define URL    ""
 
-static int process_arguments(int, char **);
+typedef struct {
+        int errorcode;
+        check_real_config config;
+} check_real_config_wrapper;
+static check_real_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
+
 static void print_help(void);
 void print_usage(void);
 
-static int server_port = PORT;
-static char *server_address;
-static char *host_name;
-static char *server_url = NULL;
-static char *server_expect;
-static int warning_time = 0;
-static bool check_warning_time = false;
-static int critical_time = 0;
-static bool check_critical_time = false;
 static bool verbose = false;
 
 int main(int argc, char **argv) {
@@ -66,8 +61,12 @@ int main(int argc, char **argv) {
         /* Parse extra opts if any */
         argv = np_extra_opts(&argc, argv, progname);
 
-        if (process_arguments(argc, argv) == ERROR)
+        check_real_config_wrapper tmp_config = process_arguments(argc, argv);
+        if (tmp_config.errorcode == ERROR) {
                 usage4(_("Could not parse arguments"));
+        }
+
+        const check_real_config config = tmp_config.config;
 
         /* initialize alarm signal handling */
         signal(SIGALRM, socket_timeout_alarm_handler);
@@ -78,38 +77,51 @@ int main(int argc, char **argv) {
 
         /* try to connect to the host at the given port number */
         int socket;
-        if (my_tcp_connect(server_address, server_port, &socket) != STATE_OK)
-                die(STATE_CRITICAL, _("Unable to connect to %s on port %d\n"), server_address, server_port);
+        if (my_tcp_connect(config.server_address, config.server_port, &socket) != STATE_OK) {
+                die(STATE_CRITICAL, _("Unable to connect to %s on port %d\n"), config.server_address, config.server_port);
+        }
 
         /* Part I - Server Check */
 
         /* send the OPTIONS request */
         char buffer[MAX_INPUT_BUFFER];
-        sprintf(buffer, "OPTIONS rtsp://%s:%d RTSP/1.0\r\n", host_name, server_port);
-        int result = send(socket, buffer, strlen(buffer), 0);
+        sprintf(buffer, "OPTIONS rtsp://%s:%d RTSP/1.0\r\n", config.host_name, config.server_port);
+        ssize_t sent_bytes = send(socket, buffer, strlen(buffer), 0);
+        if (sent_bytes == -1) {
+                die(STATE_CRITICAL, _("Sending options to %s failed\n"), config.host_name);
+        }
 
         /* send the header sync */
         sprintf(buffer, "CSeq: 1\r\n");
-        result = send(socket, buffer, strlen(buffer), 0);
+        sent_bytes = send(socket, buffer, strlen(buffer), 0);
+        if (sent_bytes == -1) {
+                die(STATE_CRITICAL, _("Sending header sync to %s failed\n"), config.host_name);
+        }
 
         /* send a newline so the server knows we're done with the request */
         sprintf(buffer, "\r\n");
-        result = send(socket, buffer, strlen(buffer), 0);
+        sent_bytes = send(socket, buffer, strlen(buffer), 0);
+        if (sent_bytes == -1) {
+                die(STATE_CRITICAL, _("Sending newline to %s failed\n"), config.host_name);
+        }
 
         /* watch for the REAL connection string */
-        result = recv(socket, buffer, MAX_INPUT_BUFFER - 1, 0);
+        ssize_t received_bytes = recv(socket, buffer, MAX_INPUT_BUFFER - 1, 0);
 
         /* return a CRITICAL status if we couldn't read any data */
-        if (result == -1)
-                die(STATE_CRITICAL, _("No data received from %s\n"), host_name);
+        if (received_bytes == -1) {
+                die(STATE_CRITICAL, _("No data received from %s\n"), config.host_name);
+        }
 
+        mp_state_enum result = STATE_OK;
         char *status_line = NULL;
         /* make sure we find the response we are looking for */
-        if (!strstr(buffer, server_expect)) {
-                if (server_port == PORT)
+        if (!strstr(buffer, config.server_expect)) {
+                if (config.server_port == PORT) {
                         printf("%s\n", _("Invalid REAL response received from host"));
-                else
-                        printf(_("Invalid REAL response received from host on port %d\n"), server_port);
+                } else {
+                        printf(_("Invalid REAL response received from host on port %d\n"), config.server_port);
+                }
         } else {
                 /* else we got the REAL string, so check the return code */
 
@@ -117,69 +129,79 @@ int main(int argc, char **argv) {
 
                 result = STATE_OK;
 
-                status_line = (char *)strtok(buffer, "\n");
+                status_line = strtok(buffer, "\n");
 
-                if (strstr(status_line, "200"))
+                if (strstr(status_line, "200")) {
                         result = STATE_OK;
+                }
 
                 /* client errors result in a warning state */
-                else if (strstr(status_line, "400"))
+                else if (strstr(status_line, "400")) {
                         result = STATE_WARNING;
-                else if (strstr(status_line, "401"))
+                } else if (strstr(status_line, "401")) {
                         result = STATE_WARNING;
-                else if (strstr(status_line, "402"))
+                } else if (strstr(status_line, "402")) {
                         result = STATE_WARNING;
-                else if (strstr(status_line, "403"))
+                } else if (strstr(status_line, "403")) {
                         result = STATE_WARNING;
-                else if (strstr(status_line, "404"))
+                } else if (strstr(status_line, "404")) {
                         result = STATE_WARNING;
-
-                /* server errors result in a critical state */
-                else if (strstr(status_line, "500"))
+                } else if (strstr(status_line, "500")) {
+                        /* server errors result in a critical state */
                         result = STATE_CRITICAL;
-                else if (strstr(status_line, "501"))
+                } else if (strstr(status_line, "501")) {
                         result = STATE_CRITICAL;
-                else if (strstr(status_line, "502"))
+                } else if (strstr(status_line, "502")) {
                         result = STATE_CRITICAL;
-                else if (strstr(status_line, "503"))
+                } else if (strstr(status_line, "503")) {
                         result = STATE_CRITICAL;
-
-                else
+                } else {
                         result = STATE_UNKNOWN;
+                }
         }
 
         /* Part II - Check stream exists and is ok */
-        if ((result == STATE_OK) && (server_url != NULL)) {
+        if ((result == STATE_OK) && (config.server_url != NULL)) {
 
                 /* Part I - Server Check */
 
                 /* send the DESCRIBE request */
-                sprintf(buffer, "DESCRIBE rtsp://%s:%d%s RTSP/1.0\r\n", host_name, server_port, server_url);
-                result = send(socket, buffer, strlen(buffer), 0);
+                sprintf(buffer, "DESCRIBE rtsp://%s:%d%s RTSP/1.0\r\n", config.host_name, config.server_port, config.server_url);
+
+                ssize_t sent_bytes = send(socket, buffer, strlen(buffer), 0);
+                if (sent_bytes == -1) {
+                        die(STATE_CRITICAL, _("Sending DESCRIBE request to %s failed\n"), config.host_name);
+                }
 
                 /* send the header sync */
                 sprintf(buffer, "CSeq: 2\r\n");
-                result = send(socket, buffer, strlen(buffer), 0);
+                sent_bytes = send(socket, buffer, strlen(buffer), 0);
+                if (sent_bytes == -1) {
+                        die(STATE_CRITICAL, _("Sending DESCRIBE request to %s failed\n"), config.host_name);
+                }
 
                 /* send a newline so the server knows we're done with the request */
                 sprintf(buffer, "\r\n");
-                result = send(socket, buffer, strlen(buffer), 0);
+                sent_bytes = send(socket, buffer, strlen(buffer), 0);
+                if (sent_bytes == -1) {
+                        die(STATE_CRITICAL, _("Sending DESCRIBE request to %s failed\n"), config.host_name);
+                }
 
                 /* watch for the REAL connection string */
-                result = recv(socket, buffer, MAX_INPUT_BUFFER - 1, 0);
-                buffer[result] = '\0'; /* null terminate received buffer */
-
-                /* return a CRITICAL status if we couldn't read any data */
-                if (result == -1) {
+                ssize_t recv_bytes = recv(socket, buffer, MAX_INPUT_BUFFER - 1, 0);
+                if (recv_bytes == -1) {
+                        /* return a CRITICAL status if we couldn't read any data */
                         printf(_("No data received from host\n"));
                         result = STATE_CRITICAL;
                 } else {
+                        buffer[result] = '\0'; /* null terminate received buffer */
                         /* make sure we find the response we are looking for */
-                        if (!strstr(buffer, server_expect)) {
-                                if (server_port == PORT)
+                        if (!strstr(buffer, config.server_expect)) {
+                                if (config.server_port == PORT) {
                                         printf("%s\n", _("Invalid REAL response received from host"));
-                                else
-                                        printf(_("Invalid REAL response received from host on port %d\n"), server_port);
+                                } else {
+                                        printf(_("Invalid REAL response received from host on port %d\n"), config.server_port);
+                                }
                         } else {
 
                                 /* else we got the REAL string, so check the return code */
@@ -188,51 +210,56 @@ int main(int argc, char **argv) {
 
                                 result = STATE_OK;
 
-                                status_line = (char *)strtok(buffer, "\n");
+                                status_line = strtok(buffer, "\n");
 
-                                if (strstr(status_line, "200"))
+                                if (strstr(status_line, "200")) {
                                         result = STATE_OK;
+                                }
 
                                 /* client errors result in a warning state */
-                                else if (strstr(status_line, "400"))
+                                else if (strstr(status_line, "400")) {
                                         result = STATE_WARNING;
-                                else if (strstr(status_line, "401"))
+                                } else if (strstr(status_line, "401")) {
                                         result = STATE_WARNING;
-                                else if (strstr(status_line, "402"))
+                                } else if (strstr(status_line, "402")) {
                                         result = STATE_WARNING;
-                                else if (strstr(status_line, "403"))
+                                } else if (strstr(status_line, "403")) {
                                         result = STATE_WARNING;
-                                else if (strstr(status_line, "404"))
+                                } else if (strstr(status_line, "404")) {
                                         result = STATE_WARNING;
+                                }
 
                                 /* server errors result in a critical state */
-                                else if (strstr(status_line, "500"))
+                                else if (strstr(status_line, "500")) {
                                         result = STATE_CRITICAL;
-                                else if (strstr(status_line, "501"))
+                                } else if (strstr(status_line, "501")) {
                                         result = STATE_CRITICAL;
-                                else if (strstr(status_line, "502"))
+                                } else if (strstr(status_line, "502")) {
                                         result = STATE_CRITICAL;
-                                else if (strstr(status_line, "503"))
+                                } else if (strstr(status_line, "503")) {
                                         result = STATE_CRITICAL;
+                                }
 
-                                else
+                                else {
                                         result = STATE_UNKNOWN;
+                                }
                         }
                 }
         }
 
         /* Return results */
         if (result == STATE_OK) {
-
-                if (check_critical_time && (end_time - start_time) > critical_time)
+                if (config.check_critical_time && (end_time - start_time) > config.critical_time) {
                         result = STATE_CRITICAL;
-                else if (check_warning_time && (end_time - start_time) > warning_time)
+                } else if (config.check_warning_time && (end_time - start_time) > config.warning_time) {
                         result = STATE_WARNING;
+                }
 
                 /* Put some HTML in here to create a dynamic link */
                 printf(_("REAL %s - %d second response time\n"), state_text(result), (int)(end_time - start_time));
-        } else
+        } else {
                 printf("%s\n", status_line);
+        }
 
         /* close the connection */
         close(socket);
@@ -240,11 +267,11 @@ int main(int argc, char **argv) {
         /* reset the alarm */
         alarm(0);
 
-        return result;
+        exit(result);
 }
 
 /* process command-line arguments */
-int process_arguments(int argc, char **argv) {
+check_real_config_wrapper process_arguments(int argc, char **argv) {
         static struct option longopts[] = {{"hostname", required_argument, 0, 'H'}, {"IPaddress", required_argument, 0, 'I'},
                                                                            {"expect", required_argument, 0, 'e'},   {"url", required_argument, 0, 'u'},
                                                                            {"port", required_argument, 0, 'p'},     {"critical", required_argument, 0, 'c'},
@@ -252,61 +279,70 @@ int process_arguments(int argc, char **argv) {
                                                                            {"verbose", no_argument, 0, 'v'},        {"version", no_argument, 0, 'V'},
                                                                            {"help", no_argument, 0, 'h'},           {0, 0, 0, 0}};
 
-        if (argc < 2)
-                return ERROR;
+        check_real_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_real_config_init(),
+        };
+
+        if (argc < 2) {
+                result.errorcode = ERROR;
+                return result;
+        }
 
         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");
+                }
         }
 
-        int option_char;
         while (true) {
                 int option = 0;
-                option_char = getopt_long(argc, argv, "+hvVI:H:e:u:p:w:c:t:", longopts, &option);
+                int option_char = getopt_long(argc, argv, "+hvVI:H:e:u:p:w:c:t:", longopts, &option);
 
-                if (option_char == -1 || option_char == EOF)
+                if (option_char == -1 || option_char == EOF) {
                         break;
+                }
 
                 switch (option_char) {
                 case 'I': /* hostname */
                 case 'H': /* hostname */
-                        if (server_address)
+                        if (result.config.server_address) {
                                 break;
-                        else if (is_host(optarg))
-                                server_address = optarg;
-                        else
+                        } else if (is_host(optarg)) {
+                                result.config.server_address = optarg;
+                        } else {
                                 usage2(_("Invalid hostname/address"), optarg);
+                        }
                         break;
                 case 'e': /* string to expect in response header */
-                        server_expect = optarg;
+                        result.config.server_expect = optarg;
                         break;
                 case 'u': /* server URL */
-                        server_url = optarg;
+                        result.config.server_url = optarg;
                         break;
                 case 'p': /* port */
                         if (is_intpos(optarg)) {
-                                server_port = atoi(optarg);
+                                result.config.server_port = atoi(optarg);
                         } else {
                                 usage4(_("Port must be a positive integer"));
                         }
                         break;
                 case 'w': /* warning time threshold */
                         if (is_intnonneg(optarg)) {
-                                warning_time = atoi(optarg);
-                                check_warning_time = true;
+                                result.config.warning_time = atoi(optarg);
+                                result.config.check_warning_time = true;
                         } else {
                                 usage4(_("Warning time must be a positive integer"));
                         }
                         break;
                 case 'c': /* critical time threshold */
                         if (is_intnonneg(optarg)) {
-                                critical_time = atoi(optarg);
-                                check_critical_time = true;
+                                result.config.critical_time = atoi(optarg);
+                                result.config.check_critical_time = true;
                         } else {
                                 usage4(_("Critical time must be a positive integer"));
                         }
@@ -332,25 +368,28 @@ int process_arguments(int argc, char **argv) {
                 }
         }
 
-        option_char = optind;
-        if (server_address == NULL && argc > option_char) {
+        int option_char = optind;
+        if (result.config.server_address == NULL && argc > option_char) {
                 if (is_host(argv[option_char])) {
-                        server_address = argv[option_char++];
+                        result.config.server_address = argv[option_char++];
                 } else {
                         usage2(_("Invalid hostname/address"), argv[option_char]);
                 }
         }
 
-        if (server_address == NULL)
+        if (result.config.server_address == NULL) {
                 usage4(_("You must provide a server to check"));
+        }
 
-        if (host_name == NULL)
-                host_name = strdup(server_address);
+        if (result.config.host_name == NULL) {
+                result.config.host_name = strdup(result.config.server_address);
+        }
 
-        if (server_expect == NULL)
-                server_expect = strdup(EXPECT);
+        if (result.config.server_expect == NULL) {
+                result.config.server_expect = strdup(EXPECT);
+        }
 
-        return OK;
+        return result;
 }
 
 void print_help(void) {
diff --git a/plugins/check_real.d/config.h b/plugins/check_real.d/config.h
new file mode 100644
index 00000000..c4663cf9
--- /dev/null
+++ b/plugins/check_real.d/config.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "../../config.h"
+#include <stddef.h>
+
+enum {
+        PORT = 554
+};
+
+typedef struct {
+        char *server_address;
+        char *host_name;
+        int server_port;
+        char *server_url;
+
+        char *server_expect;
+        int warning_time;
+        bool check_warning_time;
+        int critical_time;
+        bool check_critical_time;
+} check_real_config;
+
+check_real_config check_real_config_init() {
+        check_real_config tmp = {
+                .server_address = NULL,
+                .host_name = NULL,
+                .server_port = PORT,
+                .server_url = NULL,
+
+                .server_expect = NULL,
+                .warning_time = 0,
+                .check_warning_time = false,
+                .critical_time = 0,
+                .check_critical_time = false,
+        };
+        return tmp;
+}
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/check_time.c b/plugins/check_time.c
index d1f50683..debf59f3 100644
--- a/plugins/check_time.c
+++ b/plugins/check_time.c
@@ -28,6 +28,7 @@
  *
  *****************************************************************************/
 
+#include "states.h"
 const char *progname = "check_time";
 const char *copyright = "1999-2024";
 const char *email = "devel@monitoring-plugins.org";
@@ -35,28 +36,15 @@ const char *email = "devel@monitoring-plugins.org";
 #include "common.h"
 #include "netutils.h"
 #include "utils.h"
-
-enum {
-        TIME_PORT = 37
-};
+#include "check_time.d/config.h"
 
 #define UNIX_EPOCH 2208988800UL
 
-static uint32_t raw_server_time;
-static unsigned long server_time, diff_time;
-static int warning_time = 0;
-static bool check_warning_time = false;
-static int critical_time = 0;
-static bool check_critical_time = false;
-static unsigned long warning_diff = 0;
-static bool check_warning_diff = false;
-static unsigned long critical_diff = 0;
-static bool check_critical_diff = false;
-static int server_port = TIME_PORT;
-static char *server_address = NULL;
-static bool use_udp = false;
-
-static int process_arguments(int, char **);
+typedef struct {
+        int errorcode;
+        check_time_config config;
+} check_time_config_wrapper;
+static check_time_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
 static void print_help(void);
 void print_usage(void);
 
@@ -68,8 +56,12 @@ int main(int argc, char **argv) {
         /* Parse extra opts if any */
         argv = np_extra_opts(&argc, argv, progname);
 
-        if (process_arguments(argc, argv) == ERROR)
+        check_time_config_wrapper tmp_config = process_arguments(argc, argv);
+        if (tmp_config.errorcode == ERROR) {
                 usage4(_("Could not parse arguments"));
+        }
+
+        const check_time_config config = tmp_config.config;
 
         /* initialize alarm signal handling */
         signal(SIGALRM, socket_timeout_alarm_handler);
@@ -79,37 +71,40 @@ int main(int argc, char **argv) {
         time(&start_time);
 
         int socket;
-        int result = STATE_UNKNOWN;
+        mp_state_enum result = STATE_UNKNOWN;
         /* try to connect to the host at the given port number */
-        if (use_udp) {
-                result = my_udp_connect(server_address, server_port, &socket);
+        if (config.use_udp) {
+                result = my_udp_connect(config.server_address, config.server_port, &socket);
         } else {
-                result = my_tcp_connect(server_address, server_port, &socket);
+                result = my_tcp_connect(config.server_address, config.server_port, &socket);
         }
 
         if (result != STATE_OK) {
-                if (check_critical_time)
+                if (config.check_critical_time) {
                         result = STATE_CRITICAL;
-                else if (check_warning_time)
+                } else if (config.check_warning_time) {
                         result = STATE_WARNING;
-                else
+                } else {
                         result = STATE_UNKNOWN;
-                die(result, _("TIME UNKNOWN - could not connect to server %s, port %d\n"), server_address, server_port);
+                }
+                die(result, _("TIME UNKNOWN - could not connect to server %s, port %d\n"), config.server_address, config.server_port);
         }
 
-        if (use_udp) {
+        if (config.use_udp) {
                 if (send(socket, "", 0, 0) < 0) {
-                        if (check_critical_time)
+                        if (config.check_critical_time) {
                                 result = STATE_CRITICAL;
-                        else if (check_warning_time)
+                        } else if (config.check_warning_time) {
                                 result = STATE_WARNING;
-                        else
+                        } else {
                                 result = STATE_UNKNOWN;
-                        die(result, _("TIME UNKNOWN - could not send UDP request to server %s, port %d\n"), server_address, server_port);
+                        }
+                        die(result, _("TIME UNKNOWN - could not send UDP request to server %s, port %d\n"), config.server_address, config.server_port);
                 }
         }
 
         /* watch for the connection string */
+        uint32_t raw_server_time;
         result = recv(socket, (void *)&raw_server_time, sizeof(raw_server_time), 0);
 
         /* close the connection */
@@ -121,48 +116,56 @@ int main(int argc, char **argv) {
 
         /* return a WARNING status if we couldn't read any data */
         if (result <= 0) {
-                if (check_critical_time)
+                if (config.check_critical_time) {
                         result = STATE_CRITICAL;
-                else if (check_warning_time)
+                } else if (config.check_warning_time) {
                         result = STATE_WARNING;
-                else
+                } else {
                         result = STATE_UNKNOWN;
-                die(result, _("TIME UNKNOWN - no data received from server %s, port %d\n"), server_address, server_port);
+                }
+                die(result, _("TIME UNKNOWN - no data received from server %s, port %d\n"), config.server_address, config.server_port);
         }
 
         result = STATE_OK;
 
         time_t conntime = (end_time - start_time);
-        if (check_critical_time && conntime > critical_time)
+        if (config.check_critical_time && conntime > config.critical_time) {
                 result = STATE_CRITICAL;
-        else if (check_warning_time && conntime > warning_time)
+        } else if (config.check_warning_time && conntime > config.warning_time) {
                 result = STATE_WARNING;
+        }
 
-        if (result != STATE_OK)
+        if (result != STATE_OK) {
                 die(result, _("TIME %s - %d second response time|%s\n"), state_text(result), (int)conntime,
-                        perfdata("time", (long)conntime, "s", check_warning_time, (long)warning_time, check_critical_time, (long)critical_time, true, 0,
-                                         false, 0));
+                        perfdata("time", (long)conntime, "s", config.check_warning_time, (long)config.warning_time, config.check_critical_time,
+                                         (long)config.critical_time, true, 0, false, 0));
+        }
 
+        unsigned long server_time;
+        unsigned long diff_time;
         server_time = ntohl(raw_server_time) - UNIX_EPOCH;
-        if (server_time > (unsigned long)end_time)
+        if (server_time > (unsigned long)end_time) {
                 diff_time = server_time - (unsigned long)end_time;
-        else
+        } else {
                 diff_time = (unsigned long)end_time - server_time;
+        }
 
-        if (check_critical_diff && diff_time > critical_diff)
+        if (config.check_critical_diff && diff_time > config.critical_diff) {
                 result = STATE_CRITICAL;
-        else if (check_warning_diff && diff_time > warning_diff)
+        } else if (config.check_warning_diff && diff_time > config.warning_diff) {
                 result = STATE_WARNING;
+        }
 
         printf(_("TIME %s - %lu second time difference|%s %s\n"), state_text(result), diff_time,
-                   perfdata("time", (long)conntime, "s", check_warning_time, (long)warning_time, check_critical_time, (long)critical_time, true, 0,
-                                        false, 0),
-                   perfdata("offset", diff_time, "s", check_warning_diff, warning_diff, check_critical_diff, critical_diff, true, 0, false, 0));
+                   perfdata("time", (long)conntime, "s", config.check_warning_time, (long)config.warning_time, config.check_critical_time,
+                                        (long)config.critical_time, true, 0, false, 0),
+                   perfdata("offset", diff_time, "s", config.check_warning_diff, config.warning_diff, config.check_critical_diff,
+                                        config.critical_diff, true, 0, false, 0));
         return result;
 }
 
 /* process command-line arguments */
-int process_arguments(int argc, char **argv) {
+check_time_config_wrapper process_arguments(int argc, char **argv) {
         static struct option longopts[] = {{"hostname", required_argument, 0, 'H'},
                                                                            {"warning-variance", required_argument, 0, 'w'},
                                                                            {"critical-variance", required_argument, 0, 'c'},
@@ -175,29 +178,37 @@ int process_arguments(int argc, char **argv) {
                                                                            {"help", no_argument, 0, 'h'},
                                                                            {0, 0, 0, 0}};
 
-        if (argc < 2)
+        if (argc < 2) {
                 usage("\n");
+        }
 
         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("-wd", argv[i]) == 0)
+                } else if (strcmp("-wd", argv[i]) == 0) {
                         strcpy(argv[i], "-w");
-                else if (strcmp("-cd", argv[i]) == 0)
+                } else if (strcmp("-cd", argv[i]) == 0) {
                         strcpy(argv[i], "-c");
-                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");
+                }
         }
 
+        check_time_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_time_config_init(),
+        };
+
         int option_char;
         while (true) {
                 int option = 0;
                 option_char = getopt_long(argc, argv, "hVH:w:c:W:C:p:t:u", longopts, &option);
 
-                if (option_char == -1 || option_char == EOF)
+                if (option_char == -1 || option_char == EOF) {
                         break;
+                }
 
                 switch (option_char) {
                 case '?': /* print short usage statement if args not parsable */
@@ -209,18 +220,19 @@ int process_arguments(int argc, char **argv) {
                         print_revision(progname, NP_VERSION);
                         exit(STATE_UNKNOWN);
                 case 'H': /* hostname */
-                        if (!is_host(optarg))
+                        if (!is_host(optarg)) {
                                 usage2(_("Invalid hostname/address"), optarg);
-                        server_address = optarg;
+                        }
+                        result.config.server_address = optarg;
                         break;
                 case 'w': /* warning-variance */
                         if (is_intnonneg(optarg)) {
-                                warning_diff = strtoul(optarg, NULL, 10);
-                                check_warning_diff = true;
+                                result.config.warning_diff = strtoul(optarg, NULL, 10);
+                                result.config.check_warning_diff = true;
                         } else if (strspn(optarg, "0123456789:,") > 0) {
-                                if (sscanf(optarg, "%lu%*[:,]%d", &warning_diff, &warning_time) == 2) {
-                                        check_warning_diff = true;
-                                        check_warning_time = true;
+                                if (sscanf(optarg, "%lu%*[:,]%d", &result.config.warning_diff, &result.config.warning_time) == 2) {
+                                        result.config.check_warning_diff = true;
+                                        result.config.check_warning_time = true;
                                 } else {
                                         usage4(_("Warning thresholds must be a positive integer"));
                                 }
@@ -230,12 +242,12 @@ int process_arguments(int argc, char **argv) {
                         break;
                 case 'c': /* critical-variance */
                         if (is_intnonneg(optarg)) {
-                                critical_diff = strtoul(optarg, NULL, 10);
-                                check_critical_diff = true;
+                                result.config.critical_diff = strtoul(optarg, NULL, 10);
+                                result.config.check_critical_diff = true;
                         } else if (strspn(optarg, "0123456789:,") > 0) {
-                                if (sscanf(optarg, "%lu%*[:,]%d", &critical_diff, &critical_time) == 2) {
-                                        check_critical_diff = true;
-                                        check_critical_time = true;
+                                if (sscanf(optarg, "%lu%*[:,]%d", &result.config.critical_diff, &result.config.critical_time) == 2) {
+                                        result.config.check_critical_diff = true;
+                                        result.config.check_critical_time = true;
                                 } else {
                                         usage4(_("Critical thresholds must be a positive integer"));
                                 }
@@ -244,48 +256,53 @@ int process_arguments(int argc, char **argv) {
                         }
                         break;
                 case 'W': /* warning-connect */
-                        if (!is_intnonneg(optarg))
+                        if (!is_intnonneg(optarg)) {
                                 usage4(_("Warning threshold must be a positive integer"));
-                        else
-                                warning_time = atoi(optarg);
-                        check_warning_time = true;
+                        } else {
+                                result.config.warning_time = atoi(optarg);
+                        }
+                        result.config.check_warning_time = true;
                         break;
                 case 'C': /* critical-connect */
-                        if (!is_intnonneg(optarg))
+                        if (!is_intnonneg(optarg)) {
                                 usage4(_("Critical threshold must be a positive integer"));
-                        else
-                                critical_time = atoi(optarg);
-                        check_critical_time = true;
+                        } else {
+                                result.config.critical_time = atoi(optarg);
+                        }
+                        result.config.check_critical_time = true;
                         break;
                 case 'p': /* port */
-                        if (!is_intnonneg(optarg))
+                        if (!is_intnonneg(optarg)) {
                                 usage4(_("Port must be a positive integer"));
-                        else
-                                server_port = atoi(optarg);
+                        } else {
+                                result.config.server_port = atoi(optarg);
+                        }
                         break;
                 case 't': /* timeout */
-                        if (!is_intnonneg(optarg))
+                        if (!is_intnonneg(optarg)) {
                                 usage2(_("Timeout interval must be a positive integer"), optarg);
-                        else
+                        } else {
                                 socket_timeout = atoi(optarg);
+                        }
                         break;
                 case 'u': /* udp */
-                        use_udp = true;
+                        result.config.use_udp = true;
                 }
         }
 
         option_char = optind;
-        if (server_address == NULL) {
+        if (result.config.server_address == NULL) {
                 if (argc > option_char) {
-                        if (!is_host(argv[option_char]))
+                        if (!is_host(argv[option_char])) {
                                 usage2(_("Invalid hostname/address"), optarg);
-                        server_address = argv[option_char];
+                        }
+                        result.config.server_address = argv[option_char];
                 } else {
                         usage4(_("Hostname was not supplied"));
                 }
         }
 
-        return OK;
+        return result;
 }
 
 void print_help(void) {
diff --git a/plugins/check_time.d/config.h b/plugins/check_time.d/config.h
new file mode 100644
index 00000000..09bd7c45
--- /dev/null
+++ b/plugins/check_time.d/config.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "../../config.h"
+#include <stddef.h>
+
+enum {
+        TIME_PORT = 37
+};
+
+typedef struct {
+        char *server_address;
+        int server_port;
+        bool use_udp;
+
+        int warning_time;
+        bool check_warning_time;
+        int critical_time;
+        bool check_critical_time;
+        unsigned long warning_diff;
+        bool check_warning_diff;
+        unsigned long critical_diff;
+        bool check_critical_diff;
+} check_time_config;
+
+check_time_config check_time_config_init() {
+        check_time_config tmp = {
+                .server_address = NULL,
+                .server_port = TIME_PORT,
+                .use_udp = false,
+
+                .warning_time = 0,
+                .check_warning_time = false,
+                .critical_time = 0,
+                .check_critical_time = false,
+
+                .warning_diff = 0,
+                .check_warning_diff = false,
+                .critical_diff = 0,
+                .check_critical_diff = false,
+        };
+        return tmp;
+}
diff --git a/plugins/check_ups.c b/plugins/check_ups.c
index 526a29df..ecc0760f 100644
--- a/plugins/check_ups.c
+++ b/plugins/check_ups.c
@@ -39,69 +39,29 @@ const char *email = "devel@monitoring-plugins.org";
 #include "common.h"
 #include "netutils.h"
 #include "utils.h"
-
-enum {
-        PORT = 3493
-};
-
-#define UPS_NONE      0  /* no supported options */
-#define UPS_UTILITY   1  /* supports utility line    */
-#define UPS_BATTPCT   2  /* supports percent battery remaining */
-#define UPS_STATUS    4  /* supports UPS status */
-#define UPS_TEMP      8  /* supports UPS temperature */
-#define UPS_LOADPCT   16 /* supports load percent */
-#define UPS_REALPOWER 32 /* supports real power */
-
-#define UPSSTATUS_NONE    0
-#define UPSSTATUS_OFF     1
-#define UPSSTATUS_OL      2
-#define UPSSTATUS_OB      4
-#define UPSSTATUS_LB      8
-#define UPSSTATUS_CAL     16
-#define UPSSTATUS_RB      32 /*Replace Battery */
-#define UPSSTATUS_BYPASS  64
-#define UPSSTATUS_OVER    128
-#define UPSSTATUS_TRIM    256
-#define UPSSTATUS_BOOST   512
-#define UPSSTATUS_CHRG    1024
-#define UPSSTATUS_DISCHRG 2048
-#define UPSSTATUS_UNKNOWN 4096
-#define UPSSTATUS_ALARM   8192
+#include "check_ups.d/config.h"
+#include "states.h"
 
 enum {
         NOSUCHVAR = ERROR - 1
 };
 
-typedef struct ups_config {
-        unsigned int server_port;
-        char *server_address;
-        char *ups_name;
-        double warning_value;
-        double critical_value;
-        bool check_warn;
-        bool check_crit;
-        int check_variable;
-        int status;
-        bool temp_output_c;
-} ups_config;
-
-ups_config ups_config_init(void) {
-        ups_config tmp = {0};
-        tmp.server_port = PORT;
-        tmp.server_address = NULL;
-        tmp.ups_name = NULL;
-        tmp.check_variable = UPS_NONE;
-        tmp.status = UPSSTATUS_NONE;
-
-        return tmp;
-}
-
 // Forward declarations
-static int determine_status(ups_config * /*config*/, int *supported_options);
-static int get_ups_variable(const char * /*varname*/, char * /*buf*/, ups_config config);
+typedef struct {
+        int errorcode;
+        int ups_status;
+        int supported_options;
+} determine_status_result;
+static determine_status_result determine_status(check_ups_config /*config*/);
+static int get_ups_variable(const char * /*varname*/, char * /*buf*/, check_ups_config config);
+
+typedef struct {
+        int errorcode;
+        check_ups_config config;
+} check_ups_config_wrapper;
+static check_ups_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
+static check_ups_config_wrapper validate_arguments(check_ups_config_wrapper /*config_wrapper*/);
 
-static int process_arguments(int /*argc*/, char ** /*argv*/, ups_config * /*config*/);
-static int validate_arguments(ups_config /*config*/);
 static void print_help(void);
 void print_usage(void);
 
@@ -109,28 +69,16 @@ int main(int argc, char **argv) {
         setlocale(LC_ALL, "");
         bindtextdomain(PACKAGE, LOCALEDIR);
         textdomain(PACKAGE);
-
-        char *ups_status;
-        ups_status = strdup("N/A");
-
-        char *data;
-        data = strdup("");
-
-        char *message;
-        message = strdup("");
-
-        // Exit result
-        int result = STATE_UNKNOWN;
-
         /* Parse extra opts if any */
         argv = np_extra_opts(&argc, argv, progname);
 
-        // Config from commandline
-        ups_config config = ups_config_init();
+        check_ups_config_wrapper tmp_config = process_arguments(argc, argv);
 
-        if (process_arguments(argc, argv, &config) == ERROR) {
+        if (tmp_config.errorcode == ERROR) {
                 usage4(_("Could not parse arguments"));
         }
+        // Config from commandline
+        check_ups_config config = tmp_config.config;
 
         /* initialize alarm signal handling */
         signal(SIGALRM, socket_timeout_alarm_handler);
@@ -138,71 +86,75 @@ int main(int argc, char **argv) {
         /* set socket timeout */
         alarm(socket_timeout);
 
-        int supported_options = UPS_NONE;
-
         /* get the ups status if possible */
-        if (determine_status(&config, &supported_options) != OK) {
+        determine_status_result query_result = determine_status(config);
+        if (query_result.errorcode != OK) {
                 return STATE_CRITICAL;
         }
 
-        if (supported_options & UPS_STATUS) {
+        int ups_status_flags = query_result.ups_status;
+        int supported_options = query_result.supported_options;
 
-                ups_status = strdup("");
+        // Exit result
+        mp_state_enum result = STATE_UNKNOWN;
+        char *message = NULL;
 
+        if (supported_options & UPS_STATUS) {
+                char *ups_status = strdup("");
                 result = STATE_OK;
 
-                if (config.status & UPSSTATUS_OFF) {
+                if (ups_status_flags & UPSSTATUS_OFF) {
                         xasprintf(&ups_status, "Off");
                         result = STATE_CRITICAL;
-                } else if ((config.status & (UPSSTATUS_OB | UPSSTATUS_LB)) == (UPSSTATUS_OB | UPSSTATUS_LB)) {
+                } else if ((ups_status_flags & (UPSSTATUS_OB | UPSSTATUS_LB)) == (UPSSTATUS_OB | UPSSTATUS_LB)) {
                         xasprintf(&ups_status, _("On Battery, Low Battery"));
                         result = STATE_CRITICAL;
                 } else {
-                        if (config.status & UPSSTATUS_OL) {
+                        if (ups_status_flags & UPSSTATUS_OL) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _("Online"));
                         }
-                        if (config.status & UPSSTATUS_OB) {
+                        if (ups_status_flags & UPSSTATUS_OB) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _("On Battery"));
                                 result = max_state(result, STATE_WARNING);
                         }
-                        if (config.status & UPSSTATUS_LB) {
+                        if (ups_status_flags & UPSSTATUS_LB) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Low Battery"));
                                 result = max_state(result, STATE_WARNING);
                         }
-                        if (config.status & UPSSTATUS_CAL) {
+                        if (ups_status_flags & UPSSTATUS_CAL) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Calibrating"));
                         }
-                        if (config.status & UPSSTATUS_RB) {
+                        if (ups_status_flags & UPSSTATUS_RB) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Replace Battery"));
                                 result = max_state(result, STATE_WARNING);
                         }
-                        if (config.status & UPSSTATUS_BYPASS) {
+                        if (ups_status_flags & UPSSTATUS_BYPASS) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", On Bypass"));
                                 // Bypassing the battery is likely a bad thing
                                 result = STATE_CRITICAL;
                         }
-                        if (config.status & UPSSTATUS_OVER) {
+                        if (ups_status_flags & UPSSTATUS_OVER) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Overload"));
                                 result = max_state(result, STATE_WARNING);
                         }
-                        if (config.status & UPSSTATUS_TRIM) {
+                        if (ups_status_flags & UPSSTATUS_TRIM) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Trimming"));
                         }
-                        if (config.status & UPSSTATUS_BOOST) {
+                        if (ups_status_flags & UPSSTATUS_BOOST) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Boosting"));
                         }
-                        if (config.status & UPSSTATUS_CHRG) {
+                        if (ups_status_flags & UPSSTATUS_CHRG) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Charging"));
                         }
-                        if (config.status & UPSSTATUS_DISCHRG) {
+                        if (ups_status_flags & UPSSTATUS_DISCHRG) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Discharging"));
                                 result = max_state(result, STATE_WARNING);
                         }
-                        if (config.status & UPSSTATUS_ALARM) {
+                        if (ups_status_flags & UPSSTATUS_ALARM) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", ALARM"));
                                 result = STATE_CRITICAL;
                         }
-                        if (config.status & UPSSTATUS_UNKNOWN) {
+                        if (ups_status_flags & UPSSTATUS_UNKNOWN) {
                                 xasprintf(&ups_status, "%s%s", ups_status, _(", Unknown"));
                         }
                 }
@@ -211,7 +163,7 @@ int main(int argc, char **argv) {
 
         int res;
         char temp_buffer[MAX_INPUT_BUFFER];
-
+        char *performance_data = strdup("");
         /* get the ups utility voltage if possible */
         res = get_ups_variable("input.voltage", temp_buffer, config);
         if (res == NOSUCHVAR) {
@@ -239,11 +191,12 @@ int main(int argc, char **argv) {
                         } else if (config.check_warn && ups_utility_deviation >= config.warning_value) {
                                 result = max_state(result, STATE_WARNING);
                         }
-                        xasprintf(&data, "%s",
+                        xasprintf(&performance_data, "%s",
                                           perfdata("voltage", (long)(1000 * ups_utility_voltage), "mV", config.check_warn, (long)(1000 * config.warning_value),
                                                            config.check_crit, (long)(1000 * config.critical_value), true, 0, false, 0));
                 } else {
-                        xasprintf(&data, "%s", perfdata("voltage", (long)(1000 * ups_utility_voltage), "mV", false, 0, false, 0, true, 0, false, 0));
+                        xasprintf(&performance_data, "%s",
+                                          perfdata("voltage", (long)(1000 * ups_utility_voltage), "mV", false, 0, false, 0, true, 0, false, 0));
                 }
         }
 
@@ -266,11 +219,12 @@ int main(int argc, char **argv) {
                         } else if (config.check_warn && ups_battery_percent <= config.warning_value) {
                                 result = max_state(result, STATE_WARNING);
                         }
-                        xasprintf(&data, "%s %s", data,
+                        xasprintf(&performance_data, "%s %s", performance_data,
                                           perfdata("battery", (long)ups_battery_percent, "%", config.check_warn, (long)(config.warning_value),
                                                            config.check_crit, (long)(config.critical_value), true, 0, true, 100));
                 } else {
-                        xasprintf(&data, "%s %s", data, perfdata("battery", (long)ups_battery_percent, "%", false, 0, false, 0, true, 0, true, 100));
+                        xasprintf(&performance_data, "%s %s", performance_data,
+                                          perfdata("battery", (long)ups_battery_percent, "%", false, 0, false, 0, true, 0, true, 100));
                 }
         }
 
@@ -293,11 +247,12 @@ int main(int argc, char **argv) {
                         } else if (config.check_warn && ups_load_percent >= config.warning_value) {
                                 result = max_state(result, STATE_WARNING);
                         }
-                        xasprintf(&data, "%s %s", data,
+                        xasprintf(&performance_data, "%s %s", performance_data,
                                           perfdata("load", (long)ups_load_percent, "%", config.check_warn, (long)(config.warning_value), config.check_crit,
                                                            (long)(config.critical_value), true, 0, true, 100));
                 } else {
-                        xasprintf(&data, "%s %s", data, perfdata("load", (long)ups_load_percent, "%", false, 0, false, 0, true, 0, true, 100));
+                        xasprintf(&performance_data, "%s %s", performance_data,
+                                          perfdata("load", (long)ups_load_percent, "%", false, 0, false, 0, true, 0, true, 100));
                 }
         }
 
@@ -329,11 +284,12 @@ int main(int argc, char **argv) {
                         } else if (config.check_warn && ups_temperature >= config.warning_value) {
                                 result = max_state(result, STATE_WARNING);
                         }
-                        xasprintf(&data, "%s %s", data,
+                        xasprintf(&performance_data, "%s %s", performance_data,
                                           perfdata("temp", (long)ups_temperature, tunits, config.check_warn, (long)(config.warning_value), config.check_crit,
                                                            (long)(config.critical_value), true, 0, false, 0));
                 } else {
-                        xasprintf(&data, "%s %s", data, perfdata("temp", (long)ups_temperature, tunits, false, 0, false, 0, true, 0, false, 0));
+                        xasprintf(&performance_data, "%s %s", performance_data,
+                                          perfdata("temp", (long)ups_temperature, tunits, false, 0, false, 0, true, 0, false, 0));
                 }
         }
 
@@ -355,11 +311,12 @@ int main(int argc, char **argv) {
                         } else if (config.check_warn && ups_realpower >= config.warning_value) {
                                 result = max_state(result, STATE_WARNING);
                         }
-                        xasprintf(&data, "%s %s", data,
+                        xasprintf(&performance_data, "%s %s", performance_data,
                                           perfdata("realpower", (long)ups_realpower, "W", config.check_warn, (long)(config.warning_value), config.check_crit,
                                                            (long)(config.critical_value), true, 0, false, 0));
                 } else {
-                        xasprintf(&data, "%s %s", data, perfdata("realpower", (long)ups_realpower, "W", false, 0, false, 0, true, 0, false, 0));
+                        xasprintf(&performance_data, "%s %s", performance_data,
+                                          perfdata("realpower", (long)ups_realpower, "W", false, 0, false, 0, true, 0, false, 0));
                 }
         }
 
@@ -373,66 +330,73 @@ int main(int argc, char **argv) {
         /* reset timeout */
         alarm(0);
 
-        printf("UPS %s - %s|%s\n", state_text(result), message, data);
-        return result;
+        printf("UPS %s - %s|%s\n", state_text(result), message, performance_data);
+        exit(result);
 }
 
 /* determines what options are supported by the UPS */
-int determine_status(ups_config *config, int *supported_options) {
-        char recv_buffer[MAX_INPUT_BUFFER];
+determine_status_result determine_status(const check_ups_config config) {
 
-        int res = get_ups_variable("ups.status", recv_buffer, *config);
+        determine_status_result result = {
+                .errorcode = OK,
+                .ups_status = UPSSTATUS_NONE,
+                .supported_options = 0,
+        };
+
+        char recv_buffer[MAX_INPUT_BUFFER];
+        int res = get_ups_variable("ups.status", recv_buffer, config);
         if (res == NOSUCHVAR) {
-                return OK;
+                return result;
         }
 
         if (res != STATE_OK) {
                 printf("%s\n", _("Invalid response received from host"));
-                return ERROR;
+                result.errorcode = ERROR;
+                return result;
         }
 
-        *supported_options |= UPS_STATUS;
+        result.supported_options |= UPS_STATUS;
 
         char temp_buffer[MAX_INPUT_BUFFER];
 
         strcpy(temp_buffer, recv_buffer);
-        for (char *ptr = (char *)strtok(temp_buffer, " "); ptr != NULL; ptr = (char *)strtok(NULL, " ")) {
+        for (char *ptr = strtok(temp_buffer, " "); ptr != NULL; ptr = strtok(NULL, " ")) {
                 if (!strcmp(ptr, "OFF")) {
-                        config->status |= UPSSTATUS_OFF;
+                        result.ups_status |= UPSSTATUS_OFF;
                 } else if (!strcmp(ptr, "OL")) {
-                        config->status |= UPSSTATUS_OL;
+                        result.ups_status |= UPSSTATUS_OL;
                 } else if (!strcmp(ptr, "OB")) {
-                        config->status |= UPSSTATUS_OB;
+                        result.ups_status |= UPSSTATUS_OB;
                 } else if (!strcmp(ptr, "LB")) {
-                        config->status |= UPSSTATUS_LB;
+                        result.ups_status |= UPSSTATUS_LB;
                 } else if (!strcmp(ptr, "CAL")) {
-                        config->status |= UPSSTATUS_CAL;
+                        result.ups_status |= UPSSTATUS_CAL;
                 } else if (!strcmp(ptr, "RB")) {
-                        config->status |= UPSSTATUS_RB;
+                        result.ups_status |= UPSSTATUS_RB;
                 } else if (!strcmp(ptr, "BYPASS")) {
-                        config->status |= UPSSTATUS_BYPASS;
+                        result.ups_status |= UPSSTATUS_BYPASS;
                 } else if (!strcmp(ptr, "OVER")) {
-                        config->status |= UPSSTATUS_OVER;
+                        result.ups_status |= UPSSTATUS_OVER;
                 } else if (!strcmp(ptr, "TRIM")) {
-                        config->status |= UPSSTATUS_TRIM;
+                        result.ups_status |= UPSSTATUS_TRIM;
                 } else if (!strcmp(ptr, "BOOST")) {
-                        config->status |= UPSSTATUS_BOOST;
+                        result.ups_status |= UPSSTATUS_BOOST;
                 } else if (!strcmp(ptr, "CHRG")) {
-                        config->status |= UPSSTATUS_CHRG;
+                        result.ups_status |= UPSSTATUS_CHRG;
                 } else if (!strcmp(ptr, "DISCHRG")) {
-                        config->status |= UPSSTATUS_DISCHRG;
+                        result.ups_status |= UPSSTATUS_DISCHRG;
                 } else if (!strcmp(ptr, "ALARM")) {
-                        config->status |= UPSSTATUS_ALARM;
+                        result.ups_status |= UPSSTATUS_ALARM;
                 } else {
-                        config->status |= UPSSTATUS_UNKNOWN;
+                        result.ups_status |= UPSSTATUS_UNKNOWN;
                 }
         }
 
-        return OK;
+        return result;
 }
 
 /* gets a variable value for a specific UPS  */
-int get_ups_variable(const char *varname, char *buf, const ups_config config) {
+int get_ups_variable(const char *varname, char *buf, const check_ups_config config) {
         char send_buffer[MAX_INPUT_BUFFER];
 
         /* create the command string to send to the UPS daemon */
@@ -500,7 +464,7 @@ int get_ups_variable(const char *varname, char *buf, const ups_config config) {
                            [-wv warn_value] [-cv crit_value] [-to to_sec] */
 
 /* process command-line arguments */
-int process_arguments(int argc, char **argv, ups_config *config) {
+check_ups_config_wrapper process_arguments(int argc, char **argv) {
 
         static struct option longopts[] = {{"hostname", required_argument, 0, 'H'},
                                                                            {"ups", required_argument, 0, 'u'},
@@ -514,8 +478,14 @@ int process_arguments(int argc, char **argv, ups_config *config) {
                                                                            {"help", no_argument, 0, 'h'},
                                                                            {0, 0, 0, 0}};
 
+        check_ups_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_ups_config_init(),
+        };
+
         if (argc < 2) {
-                return ERROR;
+                result.errorcode = ERROR;
+                return result;
         }
 
         int c;
@@ -542,52 +512,52 @@ int process_arguments(int argc, char **argv, ups_config *config) {
                         usage5();
                 case 'H': /* hostname */
                         if (is_host(optarg)) {
-                                config->server_address = optarg;
+                                result.config.server_address = optarg;
                         } else {
                                 usage2(_("Invalid hostname/address"), optarg);
                         }
                         break;
                 case 'T': /* FIXME: to be improved (ie "-T C" for Celsius or "-T F" for
                                          Fahrenheit) */
-                        config->temp_output_c = true;
+                        result.config.temp_output_c = true;
                         break;
                 case 'u': /* ups name */
-                        config->ups_name = optarg;
+                        result.config.ups_name = optarg;
                         break;
                 case 'p': /* port */
                         if (is_intpos(optarg)) {
-                                config->server_port = atoi(optarg);
+                                result.config.server_port = atoi(optarg);
                         } else {
                                 usage2(_("Port must be a positive integer"), optarg);
                         }
                         break;
                 case 'c': /* critical time threshold */
                         if (is_intnonneg(optarg)) {
-                                config->critical_value = atoi(optarg);
-                                config->check_crit = true;
+                                result.config.critical_value = atoi(optarg);
+                                result.config.check_crit = true;
                         } else {
                                 usage2(_("Critical time must be a positive integer"), optarg);
                         }
                         break;
                 case 'w': /* warning time threshold */
                         if (is_intnonneg(optarg)) {
-                                config->warning_value = atoi(optarg);
-                                config->check_warn = true;
+                                result.config.warning_value = atoi(optarg);
+                                result.config.check_warn = true;
                         } else {
                                 usage2(_("Warning time must be a positive integer"), optarg);
                         }
                         break;
                 case 'v': /* variable */
                         if (!strcmp(optarg, "LINE")) {
-                                config->check_variable = UPS_UTILITY;
+                                result.config.check_variable = UPS_UTILITY;
                         } else if (!strcmp(optarg, "TEMP")) {
-                                config->check_variable = UPS_TEMP;
+                                result.config.check_variable = UPS_TEMP;
                         } else if (!strcmp(optarg, "BATTPCT")) {
-                                config->check_variable = UPS_BATTPCT;
+                                result.config.check_variable = UPS_BATTPCT;
                         } else if (!strcmp(optarg, "LOADPCT")) {
-                                config->check_variable = UPS_LOADPCT;
+                                result.config.check_variable = UPS_LOADPCT;
                         } else if (!strcmp(optarg, "REALPOWER")) {
-                                config->check_variable = UPS_REALPOWER;
+                                result.config.check_variable = UPS_REALPOWER;
                         } else {
                                 usage2(_("Unrecognized UPS variable"), optarg);
                         }
@@ -608,27 +578,27 @@ int process_arguments(int argc, char **argv, ups_config *config) {
                 }
         }
 
-        if (config->server_address == NULL && argc > optind) {
+        if (result.config.server_address == NULL && argc > optind) {
                 if (is_host(argv[optind])) {
-                        config->server_address = argv[optind++];
+                        result.config.server_address = argv[optind++];
                 } else {
                         usage2(_("Invalid hostname/address"), optarg);
                 }
         }
 
-        if (config->server_address == NULL) {
-                config->server_address = strdup("127.0.0.1");
+        if (result.config.server_address == NULL) {
+                result.config.server_address = strdup("127.0.0.1");
         }
 
-        return validate_arguments(*config);
+        return validate_arguments(result);
 }
 
-int validate_arguments(ups_config config) {
-        if (!config.ups_name) {
+check_ups_config_wrapper validate_arguments(check_ups_config_wrapper config_wrapper) {
+        if (config_wrapper.config.ups_name) {
                 printf("%s\n", _("Error : no UPS indicated"));
-                return ERROR;
+                config_wrapper.errorcode = ERROR;
         }
-        return OK;
+        return config_wrapper;
 }
 
 void print_help(void) {
diff --git a/plugins/check_ups.d/config.h b/plugins/check_ups.d/config.h
new file mode 100644
index 00000000..353104f2
--- /dev/null
+++ b/plugins/check_ups.d/config.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "../../config.h"
+#include <stddef.h>
+
+#define UPS_NONE      0  /* no supported options */
+#define UPS_UTILITY   1  /* supports utility line    */
+#define UPS_BATTPCT   2  /* supports percent battery remaining */
+#define UPS_STATUS    4  /* supports UPS status */
+#define UPS_TEMP      8  /* supports UPS temperature */
+#define UPS_LOADPCT   16 /* supports load percent */
+#define UPS_REALPOWER 32 /* supports real power */
+
+#define UPSSTATUS_NONE    0
+#define UPSSTATUS_OFF     1
+#define UPSSTATUS_OL      2
+#define UPSSTATUS_OB      4
+#define UPSSTATUS_LB      8
+#define UPSSTATUS_CAL     16
+#define UPSSTATUS_RB      32 /*Replace Battery */
+#define UPSSTATUS_BYPASS  64
+#define UPSSTATUS_OVER    128
+#define UPSSTATUS_TRIM    256
+#define UPSSTATUS_BOOST   512
+#define UPSSTATUS_CHRG    1024
+#define UPSSTATUS_DISCHRG 2048
+#define UPSSTATUS_UNKNOWN 4096
+#define UPSSTATUS_ALARM   8192
+
+enum {
+        PORT = 3493
+};
+
+typedef struct ups_config {
+        unsigned int server_port;
+        char *server_address;
+        char *ups_name;
+        double warning_value;
+        double critical_value;
+        bool check_warn;
+        bool check_crit;
+        int check_variable;
+        bool temp_output_c;
+} check_ups_config;
+
+check_ups_config check_ups_config_init(void) {
+        check_ups_config tmp = {0};
+        tmp.server_port = PORT;
+        tmp.server_address = NULL;
+        tmp.ups_name = NULL;
+        tmp.check_variable = UPS_NONE;
+
+        return tmp;
+}
+
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/negate.c b/plugins/negate.c
index 750c0bfb..0520d298 100644
--- a/plugins/negate.c
+++ b/plugins/negate.c
@@ -38,21 +38,18 @@ const char *email = "devel@monitoring-plugins.org";
 #include "common.h"
 #include "utils.h"
 #include "utils_cmd.h"
+#include "negate.d/config.h"
+#include "../lib/states.h"
 
-#include <ctype.h>
+typedef struct {
+        int errorcode;
+        negate_config config;
+} negate_config_wrapper;
+static negate_config_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
+static negate_config_wrapper validate_arguments(negate_config_wrapper /*config_wrapper*/);
 
-static const char **process_arguments(int /*argc*/, char ** /*argv*/);
-static void validate_arguments(char ** /*command_line*/);
 static void print_help(void);
 void print_usage(void);
-static bool subst_text = false;
-
-static int state[4] = {
-        STATE_OK,
-        STATE_WARNING,
-        STATE_CRITICAL,
-        STATE_UNKNOWN,
-};
 
 int main(int argc, char **argv) {
         setlocale(LC_ALL, "");
@@ -61,15 +58,24 @@ int main(int argc, char **argv) {
 
         timeout_interval = DEFAULT_TIMEOUT;
 
-        char **command_line = (char **)process_arguments(argc, argv);
+        negate_config_wrapper tmp_config = process_arguments(argc, argv);
+
+        if (tmp_config.errorcode == ERROR) {
+                die(STATE_UNKNOWN, _("negate: Failed to parse input"));
+        }
+
+        negate_config config = tmp_config.config;
+
+        char **command_line = config.command_line;
 
         /* Set signal handling and alarm */
-        if (signal(SIGALRM, timeout_alarm_handler) == SIG_ERR)
+        if (signal(SIGALRM, timeout_alarm_handler) == SIG_ERR) {
                 die(STATE_UNKNOWN, _("Cannot catch SIGALRM"));
+        }
 
-        (void)alarm((unsigned)timeout_interval);
+        (void)alarm(timeout_interval);
 
-        int result = STATE_UNKNOWN;
+        mp_state_enum result = STATE_UNKNOWN;
         output chld_out;
         output chld_err;
 
@@ -86,46 +92,52 @@ int main(int argc, char **argv) {
         }
 
         /* Return UNKNOWN or worse if no output is returned */
-        if (chld_out.lines == 0)
+        if (chld_out.lines == 0) {
                 die(max_state_alt(result, STATE_UNKNOWN), _("No data returned from command\n"));
+        }
 
         char *sub;
         for (size_t i = 0; i < chld_out.lines; i++) {
-                if (subst_text && result >= 0 && result <= 4 && result != state[result]) {
+                if (config.subst_text && result >= 0 && result <= 4 && result != config.state[result]) {
                         /* Loop over each match found */
                         while ((sub = strstr(chld_out.line[i], state_text(result)))) {
                                 /* Terminate the first part and skip over the string we'll substitute */
                                 *sub = '\0';
                                 sub += strlen(state_text(result));
                                 /* then put everything back together */
-                                xasprintf(&chld_out.line[i], "%s%s%s", chld_out.line[i], state_text(state[result]), sub);
+                                xasprintf(&chld_out.line[i], "%s%s%s", chld_out.line[i], state_text(config.state[result]), sub);
                         }
                 }
                 printf("%s\n", chld_out.line[i]);
         }
 
         if (result >= 0 && result <= 4) {
-                exit(state[result]);
+                exit(config.state[result]);
         } else {
                 exit(result);
         }
 }
 
 /* process command-line arguments */
-static const char **process_arguments(int argc, char **argv) {
+static negate_config_wrapper process_arguments(int argc, char **argv) {
         static struct option longopts[] = {{"help", no_argument, 0, 'h'},           {"version", no_argument, 0, 'V'},
                                                                            {"timeout", required_argument, 0, 't'},  {"timeout-result", required_argument, 0, 'T'},
                                                                            {"ok", required_argument, 0, 'o'},       {"warning", required_argument, 0, 'w'},
                                                                            {"critical", required_argument, 0, 'c'}, {"unknown", required_argument, 0, 'u'},
                                                                            {"substitute", no_argument, 0, 's'},     {0, 0, 0, 0}};
 
+        negate_config_wrapper result = {
+                .errorcode = OK,
+                .config = negate_config_init(),
+        };
         bool permute = true;
         while (true) {
                 int option = 0;
                 int option_char = getopt_long(argc, argv, "+hVt:T:o:w:c:u:s", longopts, &option);
 
-                if (option_char == -1 || option_char == EOF)
+                if (option_char == -1 || option_char == EOF) {
                         break;
+                }
 
                 switch (option_char) {
                 case '?': /* help */
@@ -139,58 +151,68 @@ static const char **process_arguments(int argc, char **argv) {
                         print_revision(progname, NP_VERSION);
                         exit(STATE_UNKNOWN);
                 case 't': /* timeout period */
-                        if (!is_integer(optarg))
+                        if (!is_integer(optarg)) {
                                 usage2(_("Timeout interval must be a positive integer"), optarg);
-                        else
+                        } else {
                                 timeout_interval = atoi(optarg);
+                        }
                         break;
                 case 'T': /* Result to return on timeouts */
-                        if ((timeout_state = mp_translate_state(optarg)) == ERROR)
+                        if ((timeout_state = mp_translate_state(optarg)) == ERROR) {
                                 usage4(_("Timeout result must be a valid state name (OK, WARNING, CRITICAL, UNKNOWN) or integer (0-3)."));
+                        }
                         break;
                 case 'o': /* replacement for OK */
-                        if ((state[STATE_OK] = mp_translate_state(optarg)) == ERROR)
+                        if ((result.config.state[STATE_OK] = mp_translate_state(optarg)) == ERROR) {
                                 usage4(_("Ok must be a valid state name (OK, WARNING, CRITICAL, UNKNOWN) or integer (0-3)."));
+                        }
                         permute = false;
                         break;
 
                 case 'w': /* replacement for WARNING */
-                        if ((state[STATE_WARNING] = mp_translate_state(optarg)) == ERROR)
+                        if ((result.config.state[STATE_WARNING] = mp_translate_state(optarg)) == ERROR) {
                                 usage4(_("Warning must be a valid state name (OK, WARNING, CRITICAL, UNKNOWN) or integer (0-3)."));
+                        }
                         permute = false;
                         break;
                 case 'c': /* replacement for CRITICAL */
-                        if ((state[STATE_CRITICAL] = mp_translate_state(optarg)) == ERROR)
+                        if ((result.config.state[STATE_CRITICAL] = mp_translate_state(optarg)) == ERROR) {
                                 usage4(_("Critical must be a valid state name (OK, WARNING, CRITICAL, UNKNOWN) or integer (0-3)."));
+                        }
                         permute = false;
                         break;
                 case 'u': /* replacement for UNKNOWN */
-                        if ((state[STATE_UNKNOWN] = mp_translate_state(optarg)) == ERROR)
+                        if ((result.config.state[STATE_UNKNOWN] = mp_translate_state(optarg)) == ERROR) {
                                 usage4(_("Unknown must be a valid state name (OK, WARNING, CRITICAL, UNKNOWN) or integer (0-3)."));
+                        }
                         permute = false;
                         break;
                 case 's': /* Substitute status text */
-                        subst_text = true;
+                        result.config.subst_text = true;
                         break;
                 }
         }
 
-        validate_arguments(&argv[optind]);
-
         if (permute) { /* No [owcu] switch specified, default to this */
-                state[STATE_OK] = STATE_CRITICAL;
-                state[STATE_CRITICAL] = STATE_OK;
+                result.config.state[STATE_OK] = STATE_CRITICAL;
+                result.config.state[STATE_CRITICAL] = STATE_OK;
         }
 
-        return (const char **)&argv[optind];
+        result.config.command_line = &argv[optind];
+
+        return validate_arguments(result);
 }
 
-void validate_arguments(char **command_line) {
-        if (command_line[0] == NULL)
+negate_config_wrapper validate_arguments(negate_config_wrapper config_wrapper) {
+        if (config_wrapper.config.command_line[0] == NULL) {
                 usage4(_("Could not parse arguments"));
+        }
 
-        if (strncmp(command_line[0], "/", 1) != 0 && strncmp(command_line[0], "./", 2) != 0)
+        if (strncmp(config_wrapper.config.command_line[0], "/", 1) != 0 && strncmp(config_wrapper.config.command_line[0], "./", 2) != 0) {
                 usage4(_("Require path to command"));
+        }
+
+        return config_wrapper;
 }
 
 void print_help(void) {
diff --git a/plugins/negate.d/config.h b/plugins/negate.d/config.h
new file mode 100644
index 00000000..0cf30cd4
--- /dev/null
+++ b/plugins/negate.d/config.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "states.h"
+
+typedef struct {
+        mp_state_enum state[4];
+        bool subst_text;
+        char **command_line;
+} negate_config;
+
+negate_config negate_config_init() {
+        negate_config tmp = {
+                .state =
+                        {
+                                STATE_OK,
+                                STATE_WARNING,
+                                STATE_CRITICAL,
+                                STATE_UNKNOWN,
+                        },
+                .subst_text = false,
+                .command_line = NULL,
+        };
+        return tmp;
+}
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";
diff --git a/plugins/utils.h b/plugins/utils.h
index 92a6c115..1d3c153c 100644
--- a/plugins/utils.h
+++ b/plugins/utils.h
@@ -76,7 +76,7 @@ char *strnl(char *);
 char *strpcpy(char *, const char *, const char *);
 char *strpcat(char *, const char *, const char *);
 int xvasprintf(char **strp, const char *fmt, va_list ap);
-int xasprintf(char **strp, const char *fmt, ...);
+int xasprintf(char **strp, const char *fmt, ...)__attribute__ ((format (printf, 2, 3)));
 
 void usage(const char *) __attribute__((noreturn));
 void usage2(const char *, const char *) __attribute__((noreturn));