10 files changed, 479 insertions, 278 deletions

diff --git a/plugins/Makefile.am b/plugins/Makefile.am
index fa159f4a..a35f273e 100644
--- a/plugins/Makefile.am
+++ b/plugins/Makefile.am
@@ -66,6 +66,7 @@ EXTRA_DIST = t \
                          check_hpjd.d \
                          check_game.d \
                          check_radius.d \
+                         check_ide_smart.d \
                          check_curl.d \
                          check_disk.d \
                          check_time.d \
diff --git a/plugins/check_ide_smart.c b/plugins/check_ide_smart.c
index 16fe3d01..c1325cf9 100644
--- a/plugins/check_ide_smart.c
+++ b/plugins/check_ide_smart.c
@@ -39,6 +39,8 @@ const char *email = "devel@monitoring-plugins.org";
 
 #include "common.h"
 #include "utils.h"
+#include "check_ide_smart.d/config.h"
+#include "states.h"
 
 static void print_help(void);
 void print_usage(void);
@@ -46,6 +48,7 @@ void print_usage(void);
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>
+
 #ifdef __linux__
 #       include <linux/hdreg.h>
 #       include <linux/types.h>
@@ -77,30 +80,30 @@ void print_usage(void);
 #define OPERATIONAL 0
 #define UNKNOWN     -1
 
-typedef struct threshold_s {
+typedef struct {
         uint8_t id;
         uint8_t threshold;
         uint8_t reserved[10];
-} __attribute__((packed)) threshold_t;
+} __attribute__((packed)) smart_threshold;
 
-typedef struct thresholds_s {
+typedef struct {
         uint16_t revision;
-        threshold_t thresholds[NR_ATTRIBUTES];
+        smart_threshold thresholds[NR_ATTRIBUTES];
         uint8_t reserved[18];
         uint8_t vendor[131];
         uint8_t checksum;
-} __attribute__((packed)) thresholds_t;
+} __attribute__((packed)) smart_thresholds;
 
-typedef struct value_s {
+typedef struct {
         uint8_t id;
         uint16_t status;
         uint8_t value;
         uint8_t vendor[8];
-} __attribute__((packed)) value_t;
+} __attribute__((packed)) smart_value;
 
-typedef struct values_s {
+typedef struct {
         uint16_t revision;
-        value_t values[NR_ATTRIBUTES];
+        smart_value values[NR_ATTRIBUTES];
         uint8_t offline_status;
         uint8_t vendor1;
         uint16_t offline_timeout;
@@ -110,7 +113,7 @@ typedef struct values_s {
         uint8_t reserved[16];
         uint8_t vendor[125];
         uint8_t checksum;
-} __attribute__((packed)) values_t;
+} __attribute__((packed)) smart_values;
 
 static struct {
         uint8_t value;
@@ -133,25 +136,20 @@ enum SmartCommand {
         SMART_CMD_AUTO_OFFLINE
 };
 
-static char *get_offline_text(int);
-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, uint8_t, bool);
-static int smart_read_thresholds(int, thresholds_t *);
-static bool verbose = false;
-
-int main(int argc, char *argv[]) {
-        char *device = NULL;
-        int o;
-        int longindex;
-        int retval = 0;
-
-        thresholds_t thresholds;
-        values_t values;
-        int fd;
-
+static char *get_offline_text(int /*status*/);
+static int smart_read_values(int /*fd*/, smart_values * /*values*/);
+static mp_state_enum compare_values_and_thresholds(smart_values * /*p*/, smart_thresholds * /*t*/);
+static void print_value(smart_value * /*p*/, smart_threshold * /*t*/);
+static void print_values(smart_values * /*p*/, smart_thresholds * /*t*/);
+static mp_state_enum smart_cmd_simple(int /*fd*/, enum SmartCommand /*command*/, uint8_t /*val0*/, bool /*show_error*/);
+static int smart_read_thresholds(int /*fd*/, smart_thresholds * /*thresholds*/);
+static int verbose = 0;
+
+typedef struct {
+        int errorcode;
+        check_ide_smart_config config;
+} check_ide_smart_config_wrapper;
+static check_ide_smart_config_wrapper process_arguments(int argc, char **argv) {
         static struct option longopts[] = {{"device", required_argument, 0, 'd'},
                                                                            {"immediate", no_argument, 0, 'i'},
                                                                            {"quiet-check", no_argument, 0, 'q'},
@@ -162,24 +160,22 @@ int main(int argc, char *argv[]) {
                                                                            {"version", no_argument, 0, 'V'},
                                                                            {0, 0, 0, 0}};
 
-        /* Parse extra opts if any */
-        argv = np_extra_opts(&argc, argv, progname);
-
-        setlocale(LC_ALL, "");
-        bindtextdomain(PACKAGE, LOCALEDIR);
-        textdomain(PACKAGE);
+        check_ide_smart_config_wrapper result = {
+                .errorcode = OK,
+                .config = check_ide_smart_init(),
+        };
 
         while (true) {
+                int longindex = 0;
+                int option_index = getopt_long(argc, argv, "+d:iq10nhVv", longopts, &longindex);
 
-                o = getopt_long(argc, argv, "+d:iq10nhVv", longopts, &longindex);
-
-                if (o == -1 || o == EOF || o == 1) {
+                if (option_index == -1 || option_index == EOF || option_index == 1) {
                         break;
                 }
 
-                switch (o) {
+                switch (option_index) {
                 case 'd':
-                        device = optarg;
+                        result.config.device = optarg;
                         break;
                 case 'q':
                         fprintf(stderr, "%s\n", _("DEPRECATION WARNING: the -q switch (quiet output) is no longer \"quiet\"."));
@@ -189,84 +185,103 @@ int main(int argc, char *argv[]) {
                 case '1':
                 case '0':
                         printf("%s\n", _("SMART commands are broken and have been disabled (See Notes in --help)."));
-                        return STATE_CRITICAL;
+                        result.errorcode = ERROR;
+                        return result;
                         break;
                 case 'n':
                         fprintf(stderr, "%s\n", _("DEPRECATION WARNING: the -n switch (Nagios-compatible output) is now the"));
                         fprintf(stderr, "%s\n", _("default and will be removed from future releases."));
                         break;
                 case 'v': /* verbose */
-                        verbose = true;
+                        verbose++;
                         break;
                 case 'h':
                         print_help();
-                        return STATE_UNKNOWN;
+                        exit(STATE_UNKNOWN);
                 case 'V':
                         print_revision(progname, NP_VERSION);
-                        return STATE_UNKNOWN;
+                        exit(STATE_UNKNOWN);
                 default:
                         usage5();
                 }
         }
 
         if (optind < argc) {
-                device = argv[optind];
+                result.config.device = argv[optind];
         }
 
-        if (!device) {
+        if (result.config.device == NULL) {
                 print_help();
-                return STATE_UNKNOWN;
+                exit(STATE_UNKNOWN);
+        }
+
+        return result;
+}
+
+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_ide_smart_config_wrapper tmp_config = process_arguments(argc, argv);
+
+        if (tmp_config.errorcode != OK) {
+                die(STATE_UNKNOWN, _("Failed to parse commandline"));
         }
 
-        fd = open(device, OPEN_MODE);
+        check_ide_smart_config config = tmp_config.config;
 
-        if (fd < 0) {
-                printf(_("CRITICAL - Couldn't open device %s: %s\n"), device, strerror(errno));
+        int device_file_descriptor = open(config.device, OPEN_MODE);
+
+        if (device_file_descriptor < 0) {
+                printf(_("CRITICAL - Couldn't open device %s: %s\n"), config.device, strerror(errno));
                 return STATE_CRITICAL;
         }
 
-        if (smart_cmd_simple(fd, SMART_CMD_ENABLE, 0, false)) {
+        if (smart_cmd_simple(device_file_descriptor, SMART_CMD_ENABLE, 0, false)) {
                 printf(_("CRITICAL - SMART_CMD_ENABLE\n"));
                 return STATE_CRITICAL;
         }
 
-        smart_read_values(fd, &values);
-        smart_read_thresholds(fd, &thresholds);
-        retval = nagios(&values, &thresholds);
+        smart_values values;
+        smart_read_values(device_file_descriptor, &values);
+        smart_thresholds thresholds;
+        smart_read_thresholds(device_file_descriptor, &thresholds);
+        mp_state_enum retval = compare_values_and_thresholds(&values, &thresholds);
         if (verbose) {
                 print_values(&values, &thresholds);
         }
 
-        close(fd);
+        close(device_file_descriptor);
         return retval;
 }
 
 char *get_offline_text(int status) {
-        int i;
-        for (i = 0; offline_status_text[i].text; i++) {
-                if (offline_status_text[i].value == status) {
-                        return offline_status_text[i].text;
+        for (int index = 0; offline_status_text[index].text; index++) {
+                if (offline_status_text[index].value == status) {
+                        return offline_status_text[index].text;
                 }
         }
         return "UNKNOWN";
 }
 
-int smart_read_values(int fd, values_t *values) {
+int smart_read_values(int file_descriptor, smart_values *values) {
 #ifdef __linux__
-        int e;
         uint8_t args[4 + 512];
         args[0] = WIN_SMART;
         args[1] = 0;
         args[2] = SMART_READ_VALUES;
         args[3] = 1;
-        if (ioctl(fd, HDIO_DRIVE_CMD, &args)) {
-                e = errno;
+        if (ioctl(file_descriptor, HDIO_DRIVE_CMD, &args)) {
+                int errno_storage = errno;
                 printf(_("CRITICAL - SMART_READ_VALUES: %s\n"), strerror(errno));
-                return e;
+                return errno_storage;
         }
         memcpy(values, args + 4, 512);
-#endif /* __linux__ */
-#ifdef __NetBSD__
+#elif defined __NetBSD__
         struct atareq req;
         unsigned char inbuf[DEV_BSIZE];
 
@@ -281,34 +296,37 @@ int smart_read_values(int fd, values_t *values) {
         req.datalen = sizeof(inbuf);
         req.cylinder = WDSMART_CYL;
 
-        if (ioctl(fd, ATAIOCCOMMAND, &req) == 0) {
+        if (ioctl(file_descriptor, ATAIOCCOMMAND, &req) == 0) {
                 if (req.retsts != ATACMD_OK) {
                         errno = ENODEV;
                 }
         }
 
         if (errno != 0) {
-                int e = errno;
+                int errno_storage = errno;
                 printf(_("CRITICAL - SMART_READ_VALUES: %s\n"), strerror(errno));
-                return e;
+                return errno_storage;
         }
 
         (void)memcpy(values, inbuf, 512);
-#endif /* __NetBSD__ */
+#else // __linux__ || __NetBSD__
+#       error Not implemented for this OS
+#endif
+
         return 0;
 }
 
-int nagios(values_t *p, thresholds_t *t) {
-        value_t *value = p->values;
-        threshold_t *threshold = t->thresholds;
+mp_state_enum compare_values_and_thresholds(smart_values *values, smart_thresholds *thresholds) {
+        smart_value *value = values->values;
+        smart_threshold *threshold = thresholds->thresholds;
+
         int status = OPERATIONAL;
         int prefailure = 0;
         int advisory = 0;
         int failed = 0;
         int passed = 0;
         int total = 0;
-        int i;
-        for (i = 0; i < NR_ATTRIBUTES; i++) {
+        for (int i = 0; i < NR_ATTRIBUTES; i++) {
                 if (value->id && threshold->id && value->id == threshold->id) {
                         if (value->value < threshold->threshold) {
                                 ++failed;
@@ -327,6 +345,7 @@ int nagios(values_t *p, thresholds_t *t) {
                 ++value;
                 ++threshold;
         }
+
         switch (status) {
         case PREFAILURE:
                 printf(_("CRITICAL - %d Harddrive PreFailure%cDetected! %d/%d tests failed.\n"), prefailure, prefailure > 1 ? 's' : ' ', failed,
@@ -349,50 +368,51 @@ int nagios(values_t *p, thresholds_t *t) {
         return status;
 }
 
-void print_value(value_t *p, threshold_t *t) {
-        printf("Id=%3d, Status=%2d {%s , %s}, Value=%3d, Threshold=%3d, %s\n", p->id, p->status, p->status & 1 ? "PreFailure" : "Advisory   ",
-                   p->status & 2 ? "OnLine " : "OffLine", p->value, t->threshold, p->value >= t->threshold ? "Passed" : "Failed");
+void print_value(smart_value *value_pointer, smart_threshold *threshold_pointer) {
+        printf("Id=%3d, Status=%2d {%s , %s}, Value=%3d, Threshold=%3d, %s\n", value_pointer->id, value_pointer->status,
+                   value_pointer->status & 1 ? "PreFailure" : "Advisory   ", value_pointer->status & 2 ? "OnLine " : "OffLine",
+                   value_pointer->value, threshold_pointer->threshold, value_pointer->value >= threshold_pointer->threshold ? "Passed" : "Failed");
 }
 
-void print_values(values_t *p, thresholds_t *t) {
-        value_t *value = p->values;
-        threshold_t *threshold = t->thresholds;
-        int i;
-        for (i = 0; i < NR_ATTRIBUTES; i++) {
+void print_values(smart_values *values, smart_thresholds *thresholds) {
+        smart_value *value = values->values;
+        smart_threshold *threshold = thresholds->thresholds;
+        for (int i = 0; i < NR_ATTRIBUTES; i++) {
                 if (value->id && threshold->id && value->id == threshold->id) {
                         print_value(value++, threshold++);
                 }
         }
-        printf(_("OffLineStatus=%d {%s}, AutoOffLine=%s, OffLineTimeout=%d minutes\n"), p->offline_status,
-                   get_offline_text(p->offline_status & 0x7f), (p->offline_status & 0x80 ? "Yes" : "No"), p->offline_timeout / 60);
-        printf(_("OffLineCapability=%d {%s %s %s}\n"), p->offline_capability, p->offline_capability & 1 ? "Immediate" : "",
-                   p->offline_capability & 2 ? "Auto" : "", p->offline_capability & 4 ? "AbortOnCmd" : "SuspendOnCmd");
-        printf(_("SmartRevision=%d, CheckSum=%d, SmartCapability=%d {%s %s}\n"), p->revision, p->checksum, p->smart_capability,
-                   p->smart_capability & 1 ? "SaveOnStandBy" : "", p->smart_capability & 2 ? "AutoSave" : "");
+        printf(_("OffLineStatus=%d {%s}, AutoOffLine=%s, OffLineTimeout=%d minutes\n"), values->offline_status,
+                   get_offline_text(values->offline_status & 0x7f), (values->offline_status & 0x80 ? "Yes" : "No"), values->offline_timeout / 60);
+        printf(_("OffLineCapability=%d {%s %s %s}\n"), values->offline_capability, values->offline_capability & 1 ? "Immediate" : "",
+                   values->offline_capability & 2 ? "Auto" : "", values->offline_capability & 4 ? "AbortOnCmd" : "SuspendOnCmd");
+        printf(_("SmartRevision=%d, CheckSum=%d, SmartCapability=%d {%s %s}\n"), values->revision, values->checksum, values->smart_capability,
+                   values->smart_capability & 1 ? "SaveOnStandBy" : "", values->smart_capability & 2 ? "AutoSave" : "");
 }
 
-int smart_cmd_simple(int fd, enum SmartCommand command, uint8_t val0, bool show_error) {
-        int e = STATE_UNKNOWN;
+mp_state_enum smart_cmd_simple(int file_descriptor, enum SmartCommand command, uint8_t val0, bool show_error) {
+        mp_state_enum result = STATE_UNKNOWN;
 #ifdef __linux__
-        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;
+        uint8_t args[4] = {
+                WIN_SMART,
+                val0,
+                smart_command[command].value,
+                0,
+        };
+
+        if (ioctl(file_descriptor, HDIO_DRIVE_CMD, &args)) {
+                result = STATE_CRITICAL;
                 if (show_error) {
                         printf(_("CRITICAL - %s: %s\n"), smart_command[command].text, strerror(errno));
                 }
         } else {
-                e = STATE_OK;
+                result = STATE_OK;
                 if (show_error) {
                         printf(_("OK - Command sent (%s)\n"), smart_command[command].text);
                 }
         }
 
-#endif /* __linux__ */
-#ifdef __NetBSD__
+#elif defined __NetBSD__
         struct atareq req;
 
         memset(&req, 0, sizeof(req));
@@ -403,7 +423,7 @@ int smart_cmd_simple(int fd, enum SmartCommand command, uint8_t val0, bool show_
         req.cylinder = WDSMART_CYL;
         req.sec_count = val0;
 
-        if (ioctl(fd, ATAIOCCOMMAND, &req) == 0) {
+        if (ioctl(file_descriptor, ATAIOCCOMMAND, &req) == 0) {
                 if (req.retsts != ATACMD_OK) {
                         errno = ENODEV;
                 }
@@ -413,42 +433,42 @@ int smart_cmd_simple(int fd, enum SmartCommand command, uint8_t val0, bool show_
         }
 
         if (errno != 0) {
-                e = STATE_CRITICAL;
+                result = STATE_CRITICAL;
                 if (show_error) {
                         printf(_("CRITICAL - %s: %s\n"), smart_command[command].text, strerror(errno));
                 }
         } else {
-                e = STATE_OK;
+                result = STATE_OK;
                 if (show_error) {
                         printf(_("OK - Command sent (%s)\n"), smart_command[command].text);
                 }
         }
-
+#else
+#       error Not implemented for this OS
 #endif /* __NetBSD__ */
-        return e;
+
+        return result;
 }
 
-int smart_read_thresholds(int fd, thresholds_t *thresholds) {
+int smart_read_thresholds(int file_descriptor, smart_thresholds *thresholds) {
 #ifdef __linux__
-        int e;
         uint8_t args[4 + 512];
         args[0] = WIN_SMART;
         args[1] = 0;
         args[2] = SMART_READ_THRESHOLDS;
         args[3] = 1;
-        if (ioctl(fd, HDIO_DRIVE_CMD, &args)) {
-                e = errno;
+        if (ioctl(file_descriptor, HDIO_DRIVE_CMD, &args)) {
+                int errno_storage = errno;
                 printf(_("CRITICAL - SMART_READ_THRESHOLDS: %s\n"), strerror(errno));
-                return e;
+                return errno_storage;
         }
         memcpy(thresholds, args + 4, 512);
-#endif /* __linux__ */
-#ifdef __NetBSD__
+#elif defined __NetBSD__
         struct atareq req;
-        unsigned char inbuf[DEV_BSIZE];
-
         memset(&req, 0, sizeof(req));
         req.timeout = 1000;
+
+        unsigned char inbuf[DEV_BSIZE];
         memset(&inbuf, 0, sizeof(inbuf));
 
         req.flags = ATACMD_READ;
@@ -458,20 +478,23 @@ int smart_read_thresholds(int fd, thresholds_t *thresholds) {
         req.datalen = sizeof(inbuf);
         req.cylinder = WDSMART_CYL;
 
-        if (ioctl(fd, ATAIOCCOMMAND, &req) == 0) {
+        if (ioctl(file_descriptor, ATAIOCCOMMAND, &req) == 0) {
                 if (req.retsts != ATACMD_OK) {
                         errno = ENODEV;
                 }
         }
 
         if (errno != 0) {
-                int e = errno;
+                int errno_storage = errno;
                 printf(_("CRITICAL - SMART_READ_THRESHOLDS: %s\n"), strerror(errno));
-                return e;
+                return errno_storage;
         }
 
         (void)memcpy(thresholds, inbuf, 512);
+#else
+#       error Not implemented for this OS
 #endif /* __NetBSD__ */
+
         return 0;
 }
 
diff --git a/plugins/check_ide_smart.d/config.h b/plugins/check_ide_smart.d/config.h
new file mode 100644
index 00000000..36899abe
--- /dev/null
+++ b/plugins/check_ide_smart.d/config.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../../config.h"
+#include <stddef.h>
+
+typedef struct {
+        char *device;
+} check_ide_smart_config;
+
+check_ide_smart_config check_ide_smart_init() {
+        check_ide_smart_config tmp = {
+                .device = NULL,
+        };
+        return tmp;
+}
diff --git a/plugins/check_radius.c b/plugins/check_radius.c
index d26f7cf3..93352bcc 100644
--- a/plugins/check_radius.c
+++ b/plugins/check_radius.c
@@ -28,6 +28,7 @@
  *
  *****************************************************************************/
 
+#include "output.h"
 const char *progname = "check_radius";
 const char *copyright = "2000-2024";
 const char *email = "devel@monitoring-plugins.org";
@@ -158,49 +159,80 @@ int main(int argc, char **argv) {
 
         check_radius_config config = tmp_config.config;
 
+        if (config.output_format_is_set) {
+                mp_set_format(config.output_format);
+        }
+
 #if defined(HAVE_LIBFREERADIUS_CLIENT) || defined(HAVE_LIBRADIUSCLIENT_NG) ||                      \
         defined(HAVE_LIBRADCLI)
         rc_handle *rch = NULL;
 #endif
 
+        mp_check overall = mp_check_init();
+        mp_subcheck sc_read_config = mp_subcheck_init();
+
         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"));
+                sc_read_config = mp_set_subcheck_state(sc_read_config, STATE_UNKNOWN);
+                xasprintf(&sc_read_config.output, "failed to read config file");
+                mp_add_subcheck_to_check(&overall, sc_read_config);
+                mp_exit(overall);
         }
 
+        sc_read_config = mp_set_subcheck_state(sc_read_config, STATE_OK);
+        xasprintf(&sc_read_config.output, "read config file successfully");
+        mp_add_subcheck_to_check(&overall, sc_read_config);
+
         uint32_t service = PW_AUTHENTICATE_ONLY;
 
+        mp_subcheck sc_configuring = mp_subcheck_init();
         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"));
+                xasprintf(&sc_configuring.output, "Failed to the radius options: Out of Memory?");
+                sc_configuring = mp_set_subcheck_state(sc_configuring, STATE_UNKNOWN);
+                mp_add_subcheck_to_check(&overall, sc_configuring);
+                mp_exit(overall);
         }
 
         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"));
+                        xasprintf(&sc_configuring.output,
+                                          "Failed to the radius options: invalid NAS identifier?");
+                        sc_configuring = mp_set_subcheck_state(sc_configuring, STATE_UNKNOWN);
+                        mp_add_subcheck_to_check(&overall, sc_configuring);
+                        mp_exit(overall);
                 }
         }
 
         char name[HOST_NAME_MAX];
         if (config.nas_ip_address == NULL) {
                 if (gethostname(name, sizeof(name)) != 0) {
-                        die(STATE_UNKNOWN, _("gethostname() failed!\n"));
+                        xasprintf(&sc_configuring.output, "gethostname() failed");
+                        sc_configuring = mp_set_subcheck_state(sc_configuring, STATE_UNKNOWN);
+                        mp_add_subcheck_to_check(&overall, sc_configuring);
+                        mp_exit(overall);
                 }
                 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"));
+                xasprintf(&sc_configuring.output, "invalid NAS IP address. Lookup failed");
+                sc_configuring = mp_set_subcheck_state(sc_configuring, STATE_UNKNOWN);
+                mp_add_subcheck_to_check(&overall, sc_configuring);
+                mp_exit(overall);
         }
 
         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"));
+                xasprintf(&sc_configuring.output, "invalid NAS IP address. Setting option failed");
+                sc_configuring = mp_set_subcheck_state(sc_configuring, STATE_UNKNOWN);
+                mp_add_subcheck_to_check(&overall, sc_configuring);
+                mp_exit(overall);
         }
 
         my_rc_buildreq(&data, PW_ACCESS_REQUEST, config.server, config.port, (int)timeout_interval,
@@ -218,51 +250,78 @@ int main(int argc, char **argv) {
                 rc_avpair_free(data.receive_pairs);
         }
 
+        mp_subcheck sc_eval = mp_subcheck_init();
+
         if (result == TIMEOUT_RC) {
-                printf("Timeout\n");
-                exit(STATE_CRITICAL);
+                xasprintf(&sc_eval.output, "timeout");
+                sc_eval = mp_set_subcheck_state(sc_eval, STATE_CRITICAL);
+                mp_add_subcheck_to_check(&overall, sc_eval);
+                mp_exit(overall);
         }
 
         if (result == ERROR_RC) {
-                printf(_("Auth Error\n"));
-                exit(STATE_CRITICAL);
+                xasprintf(&sc_eval.output, "auth error");
+                sc_eval = mp_set_subcheck_state(sc_eval, STATE_CRITICAL);
+                mp_add_subcheck_to_check(&overall, sc_eval);
+                mp_exit(overall);
         }
 
         if (result == REJECT_RC) {
-                printf(_("Auth Failed\n"));
-                exit(STATE_WARNING);
+                xasprintf(&sc_eval.output, "auth failed");
+                sc_eval = mp_set_subcheck_state(sc_eval, STATE_WARNING);
+                mp_add_subcheck_to_check(&overall, sc_eval);
+                mp_exit(overall);
         }
 
         if (result == BADRESP_RC) {
-                printf(_("Bad Response\n"));
-                exit(STATE_WARNING);
+                xasprintf(&sc_eval.output, "bad response");
+                sc_eval = mp_set_subcheck_state(sc_eval, STATE_WARNING);
+                mp_add_subcheck_to_check(&overall, sc_eval);
+                mp_exit(overall);
         }
 
         if (config.expect && !strstr(msg, config.expect)) {
-                printf("%s\n", msg);
-                exit(STATE_WARNING);
+                xasprintf(&sc_eval.output, "%s", msg);
+                sc_eval = mp_set_subcheck_state(sc_eval, STATE_WARNING);
+                mp_add_subcheck_to_check(&overall, sc_eval);
+                mp_exit(overall);
         }
 
         if (result == OK_RC) {
-                printf(_("Auth OK\n"));
-                exit(STATE_OK);
+                xasprintf(&sc_eval.output, "auth OK");
+                sc_eval = mp_set_subcheck_state(sc_eval, STATE_OK);
+                mp_add_subcheck_to_check(&overall, sc_eval);
+                mp_exit(overall);
         }
 
-        (void)snprintf(msg, sizeof(msg), _("Unexpected result code %d"), result);
-        printf("%s\n", msg);
-        exit(STATE_UNKNOWN);
+        xasprintf(&sc_eval.output, "unexpected result code: %d", result);
+        sc_eval = mp_set_subcheck_state(sc_eval, STATE_UNKNOWN);
+        mp_add_subcheck_to_check(&overall, sc_eval);
+
+        mp_exit(overall);
 }
 
 /* process command-line arguments */
 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}};
+        enum {
+                output_format_index
+        };
+
+        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'},
+                                                                           {"output-format", required_argument, 0, output_format_index},
+                                                                           {0, 0, 0, 0}};
 
         check_radius_config_wrapper result = {
                 .errorcode = OK,
@@ -340,6 +399,18 @@ check_radius_config_wrapper process_arguments(int argc, char **argv) {
                                 usage2(_("Timeout interval must be a positive integer"), optarg);
                         }
                         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;
+                }
                 }
         }
 
@@ -393,6 +464,7 @@ void print_help(void) {
         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_OUTPUT_FORMAT);
 
         printf(UT_CONN_TIMEOUT, timeout_interval);
 
diff --git a/plugins/check_radius.d/config.h b/plugins/check_radius.d/config.h
index b27d31e7..656bf98e 100644
--- a/plugins/check_radius.d/config.h
+++ b/plugins/check_radius.d/config.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../../config.h"
+#include "output.h"
 #include <stddef.h>
 #if defined(HAVE_LIBRADCLI)
 #       include <radcli/radcli.h>
@@ -23,6 +24,9 @@ typedef struct {
         unsigned short port;
 
         char *expect;
+
+        bool output_format_is_set;
+        mp_output_format output_format;
 } check_radius_config;
 
 check_radius_config check_radius_config_init() {
@@ -37,6 +41,8 @@ check_radius_config check_radius_config_init() {
                 .port = PW_AUTH_UDP_PORT,
 
                 .expect = NULL,
+
+                .output_format_is_set = false,
         };
         return tmp;
 }
diff --git a/plugins/check_real.c b/plugins/check_real.c
index 66d07f8f..15c8a20c 100644
--- a/plugins/check_real.c
+++ b/plugins/check_real.c
@@ -28,19 +28,21 @@
  *
  *****************************************************************************/
 
+#include "output.h"
+#include "perfdata.h"
 #include "states.h"
 #include <stdio.h>
-const char *progname = "check_real";
-const char *copyright = "2000-2024";
-const char *email = "devel@monitoring-plugins.org";
-
 #include "common.h"
 #include "netutils.h"
+#include "thresholds.h"
 #include "utils.h"
 #include "check_real.d/config.h"
 
-#define EXPECT "RTSP/1."
-#define URL    ""
+const char *progname = "check_real";
+const char *copyright = "2000-2024";
+const char *email = "devel@monitoring-plugins.org";
+
+#define URL ""
 
 typedef struct {
         int errorcode;
@@ -68,42 +70,68 @@ int main(int argc, char **argv) {
 
         const check_real_config config = tmp_config.config;
 
+        if (config.output_format_is_set) {
+                mp_set_format(config.output_format);
+        }
+
         /* initialize alarm signal handling */
         signal(SIGALRM, socket_timeout_alarm_handler);
 
         /* set socket timeout */
         alarm(socket_timeout);
+        time_t start_time;
         time(&start_time);
 
+        mp_check overall = mp_check_init();
+        mp_subcheck sc_connect = mp_subcheck_init();
+
         /* try to connect to the host at the given port number */
         int socket;
         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);
+                xasprintf(&sc_connect.output, _("unable to connect to %s on port %d"),
+                                  config.server_address, config.server_port);
+                sc_connect = mp_set_subcheck_state(sc_connect, STATE_CRITICAL);
+                mp_add_subcheck_to_check(&overall, sc_connect);
+                mp_exit(overall);
         }
 
+        xasprintf(&sc_connect.output, _("connected to %s on port %d"), config.server_address,
+                          config.server_port);
+        sc_connect = mp_set_subcheck_state(sc_connect, STATE_OK);
+        mp_add_subcheck_to_check(&overall, sc_connect);
+
         /* Part I - Server Check */
+        mp_subcheck sc_send = mp_subcheck_init();
 
         /* send the OPTIONS request */
         char buffer[MAX_INPUT_BUFFER];
         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);
+                xasprintf(&sc_send.output, _("Sending options to %s failed"), config.host_name);
+                sc_send = mp_set_subcheck_state(sc_send, STATE_CRITICAL);
+                mp_add_subcheck_to_check(&overall, sc_send);
+                mp_exit(overall);
         }
 
         /* send the header sync */
         sprintf(buffer, "CSeq: 1\r\n");
         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);
+                xasprintf(&sc_send.output, _("Sending header sync to %s failed"), config.host_name);
+                sc_send = mp_set_subcheck_state(sc_send, STATE_CRITICAL);
+                mp_add_subcheck_to_check(&overall, sc_send);
+                mp_exit(overall);
         }
 
         /* send a newline so the server knows we're done with the request */
         sprintf(buffer, "\r\n");
         sent_bytes = send(socket, buffer, strlen(buffer), 0);
         if (sent_bytes == -1) {
-                die(STATE_CRITICAL, _("Sending newline to %s failed\n"), config.host_name);
+                xasprintf(&sc_send.output, _("Sending newline to %s failed"), config.host_name);
+                sc_send = mp_set_subcheck_state(sc_send, STATE_CRITICAL);
+                mp_add_subcheck_to_check(&overall, sc_send);
+                mp_exit(overall);
         }
 
         /* watch for the REAL connection string */
@@ -111,60 +139,75 @@ int main(int argc, char **argv) {
 
         /* return a CRITICAL status if we couldn't read any data */
         if (received_bytes == -1) {
-                die(STATE_CRITICAL, _("No data received from %s\n"), config.host_name);
+                xasprintf(&sc_send.output, _("No data received from %s"), config.host_name);
+                sc_send = mp_set_subcheck_state(sc_send, STATE_CRITICAL);
+                mp_add_subcheck_to_check(&overall, sc_send);
+                mp_exit(overall);
         }
 
-        mp_state_enum result = STATE_OK;
-        char *status_line = NULL;
-        /* make sure we find the response we are looking for */
-        if (!strstr(buffer, config.server_expect)) {
-                if (config.server_port == PORT) {
-                        printf("%s\n", _("Invalid REAL response received from host"));
+        time_t end_time;
+        {
+                mp_subcheck sc_options_request = mp_subcheck_init();
+                mp_state_enum options_result = STATE_OK;
+                /* make sure we find the response we are looking for */
+                if (!strstr(buffer, config.server_expect)) {
+                        if (config.server_port == PORT) {
+                                xasprintf(&sc_options_request.output, "invalid REAL response received from host");
+                        } else {
+                                xasprintf(&sc_options_request.output,
+                                                  "invalid REAL response received from host on port %d",
+                                                  config.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 */
+                        /* else we got the REAL string, so check the return code */
+                        time(&end_time);
 
-                time(&end_time);
+                        options_result = STATE_OK;
 
-                result = STATE_OK;
+                        char *status_line = strtok(buffer, "\n");
+                        xasprintf(&sc_options_request.output, "status line: %s", status_line);
 
-                status_line = strtok(buffer, "\n");
-
-                if (strstr(status_line, "200")) {
-                        result = STATE_OK;
+                        if (strstr(status_line, "200")) {
+                                options_result = STATE_OK;
+                        }
+                        /* client errors options_result in a warning state */
+                        else if (strstr(status_line, "400")) {
+                                options_result = STATE_WARNING;
+                        } else if (strstr(status_line, "401")) {
+                                options_result = STATE_WARNING;
+                        } else if (strstr(status_line, "402")) {
+                                options_result = STATE_WARNING;
+                        } else if (strstr(status_line, "403")) {
+                                options_result = STATE_WARNING;
+                        } else if (strstr(status_line, "404")) {
+                                options_result = STATE_WARNING;
+                        } else if (strstr(status_line, "500")) {
+                                /* server errors options_result in a critical state */
+                                options_result = STATE_CRITICAL;
+                        } else if (strstr(status_line, "501")) {
+                                options_result = STATE_CRITICAL;
+                        } else if (strstr(status_line, "502")) {
+                                options_result = STATE_CRITICAL;
+                        } else if (strstr(status_line, "503")) {
+                                options_result = STATE_CRITICAL;
+                        } else {
+                                options_result = STATE_UNKNOWN;
+                        }
                 }
 
-                /* client errors result in a warning state */
-                else if (strstr(status_line, "400")) {
-                        result = STATE_WARNING;
-                } else if (strstr(status_line, "401")) {
-                        result = STATE_WARNING;
-                } else if (strstr(status_line, "402")) {
-                        result = STATE_WARNING;
-                } else if (strstr(status_line, "403")) {
-                        result = STATE_WARNING;
-                } else if (strstr(status_line, "404")) {
-                        result = STATE_WARNING;
-                } else if (strstr(status_line, "500")) {
-                        /* server errors result in a critical state */
-                        result = STATE_CRITICAL;
-                } else if (strstr(status_line, "501")) {
-                        result = STATE_CRITICAL;
-                } else if (strstr(status_line, "502")) {
-                        result = STATE_CRITICAL;
-                } else if (strstr(status_line, "503")) {
-                        result = STATE_CRITICAL;
-                } else {
-                        result = STATE_UNKNOWN;
+                sc_options_request = mp_set_subcheck_state(sc_options_request, options_result);
+                mp_add_subcheck_to_check(&overall, sc_options_request);
+
+                if (options_result != STATE_OK) {
+                        // exit here if Setting options already failed
+                        mp_exit(overall);
                 }
         }
 
         /* Part II - Check stream exists and is ok */
-        if ((result == STATE_OK) && (config.server_url != NULL)) {
-
+        if (config.server_url != NULL) {
                 /* Part I - Server Check */
+                mp_subcheck sc_describe = mp_subcheck_init();
 
                 /* send the DESCRIBE request */
                 sprintf(buffer, "DESCRIBE rtsp://%s:%d%s RTSP/1.0\r\n", config.host_name,
@@ -172,98 +215,115 @@ int main(int argc, char **argv) {
 
                 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);
+                        sc_describe = mp_set_subcheck_state(sc_describe, STATE_CRITICAL);
+                        xasprintf(&sc_describe.output, "sending DESCRIBE request to %s failed",
+                                          config.host_name);
+                        mp_add_subcheck_to_check(&overall, sc_describe);
+                        mp_exit(overall);
                 }
 
                 /* send the header sync */
                 sprintf(buffer, "CSeq: 2\r\n");
                 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);
+                        sc_describe = mp_set_subcheck_state(sc_describe, STATE_CRITICAL);
+                        xasprintf(&sc_describe.output, "sending DESCRIBE request to %s failed",
+                                          config.host_name);
+                        mp_add_subcheck_to_check(&overall, sc_describe);
+                        mp_exit(overall);
                 }
 
                 /* send a newline so the server knows we're done with the request */
                 sprintf(buffer, "\r\n");
                 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);
+                        sc_describe = mp_set_subcheck_state(sc_describe, STATE_CRITICAL);
+                        xasprintf(&sc_describe.output, "sending DESCRIBE request to %s failed",
+                                          config.host_name);
+                        mp_add_subcheck_to_check(&overall, sc_describe);
+                        mp_exit(overall);
                 }
 
                 /* watch for the REAL connection string */
                 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;
+                        sc_describe = mp_set_subcheck_state(sc_describe, STATE_CRITICAL);
+                        xasprintf(&sc_describe.output, "No data received from host on DESCRIBE request");
+                        mp_add_subcheck_to_check(&overall, sc_describe);
+                        mp_exit(overall);
                 } else {
-                        buffer[result] = '\0'; /* null terminate received buffer */
+                        buffer[recv_bytes] = '\0'; /* null terminate received buffer */
                         /* make sure we find the response we are looking for */
                         if (!strstr(buffer, config.server_expect)) {
                                 if (config.server_port == PORT) {
-                                        printf("%s\n", _("Invalid REAL response received from host"));
+                                        xasprintf(&sc_describe.output, "invalid REAL response received from host");
                                 } else {
-                                        printf(_("Invalid REAL response received from host on port %d\n"),
-                                                   config.server_port);
+                                        xasprintf(&sc_describe.output,
+                                                          "invalid REAL response received from host on port %d",
+                                                          config.server_port);
                                 }
-                        } else {
 
+                                sc_describe = mp_set_subcheck_state(sc_describe, STATE_UNKNOWN);
+                                mp_add_subcheck_to_check(&overall, sc_describe);
+                                mp_exit(overall);
+                        } else {
                                 /* else we got the REAL string, so check the return code */
 
                                 time(&end_time);
 
-                                result = STATE_OK;
-
-                                status_line = strtok(buffer, "\n");
+                                char *status_line = strtok(buffer, "\n");
+                                xasprintf(&sc_describe.output, "status line: %s", status_line);
 
+                                mp_state_enum describe_result;
                                 if (strstr(status_line, "200")) {
-                                        result = STATE_OK;
+                                        describe_result = STATE_OK;
                                 }
-
-                                /* client errors result in a warning state */
+                                /* client errors describe_result in a warning state */
                                 else if (strstr(status_line, "400")) {
-                                        result = STATE_WARNING;
+                                        describe_result = STATE_WARNING;
                                 } else if (strstr(status_line, "401")) {
-                                        result = STATE_WARNING;
+                                        describe_result = STATE_WARNING;
                                 } else if (strstr(status_line, "402")) {
-                                        result = STATE_WARNING;
+                                        describe_result = STATE_WARNING;
                                 } else if (strstr(status_line, "403")) {
-                                        result = STATE_WARNING;
+                                        describe_result = STATE_WARNING;
                                 } else if (strstr(status_line, "404")) {
-                                        result = STATE_WARNING;
+                                        describe_result = STATE_WARNING;
                                 }
-
-                                /* server errors result in a critical state */
+                                /* server errors describe_result in a critical state */
                                 else if (strstr(status_line, "500")) {
-                                        result = STATE_CRITICAL;
+                                        describe_result = STATE_CRITICAL;
                                 } else if (strstr(status_line, "501")) {
-                                        result = STATE_CRITICAL;
+                                        describe_result = STATE_CRITICAL;
                                 } else if (strstr(status_line, "502")) {
-                                        result = STATE_CRITICAL;
+                                        describe_result = STATE_CRITICAL;
                                 } else if (strstr(status_line, "503")) {
-                                        result = STATE_CRITICAL;
+                                        describe_result = STATE_CRITICAL;
+                                } else {
+                                        describe_result = STATE_UNKNOWN;
                                 }
 
-                                else {
-                                        result = STATE_UNKNOWN;
-                                }
+                                sc_describe = mp_set_subcheck_state(sc_describe, describe_result);
+                                mp_add_subcheck_to_check(&overall, sc_describe);
                         }
                 }
         }
 
         /* Return results */
-        if (result == STATE_OK) {
-                if (config.check_critical_time && (end_time - start_time) > config.critical_time) {
-                        result = STATE_CRITICAL;
-                } else if (config.check_warning_time && (end_time - start_time) > config.warning_time) {
-                        result = STATE_WARNING;
-                }
+        mp_subcheck sc_timing = mp_subcheck_init();
+        xasprintf(&sc_timing.output, "response time: %lds", end_time - start_time);
+        sc_timing = mp_set_subcheck_default_state(sc_timing, STATE_OK);
 
-                /* 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 {
-                printf("%s\n", status_line);
-        }
+        mp_perfdata pd_response_time = perfdata_init();
+        pd_response_time = mp_set_pd_value(pd_response_time, (end_time - start_time));
+        pd_response_time.label = "response_time";
+        pd_response_time.uom = "s";
+        pd_response_time = mp_pd_set_thresholds(pd_response_time, config.time_thresholds);
+        mp_add_perfdata_to_subcheck(&sc_connect, pd_response_time);
+        sc_timing = mp_set_subcheck_state(sc_timing, mp_get_pd_status(pd_response_time));
+
+        mp_add_subcheck_to_check(&overall, sc_timing);
 
         /* close the connection */
         close(socket);
@@ -271,18 +331,28 @@ int main(int argc, char **argv) {
         /* reset the alarm */
         alarm(0);
 
-        exit(result);
+        mp_exit(overall);
 }
 
 /* process command-line arguments */
 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'},
-                {"warning", required_argument, 0, 'w'},  {"timeout", required_argument, 0, 't'},
-                {"verbose", no_argument, 0, 'v'},        {"version", no_argument, 0, 'V'},
-                {"help", no_argument, 0, 'h'},           {0, 0, 0, 0}};
+        enum {
+                output_format_index = CHAR_MAX + 1,
+        };
+
+        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'},
+                                                                           {"warning", required_argument, 0, 'w'},
+                                                                           {"timeout", required_argument, 0, 't'},
+                                                                           {"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}};
 
         check_real_config_wrapper result = {
                 .errorcode = OK,
@@ -337,21 +407,23 @@ check_real_config_wrapper process_arguments(int argc, char **argv) {
                         }
                         break;
                 case 'w': /* warning time threshold */
-                        if (is_intnonneg(optarg)) {
-                                result.config.warning_time = atoi(optarg);
-                                result.config.check_warning_time = true;
-                        } else {
-                                usage4(_("Warning time must be a positive integer"));
+                {
+                        mp_range_parsed critical_range = mp_parse_range_string(optarg);
+                        if (critical_range.error != MP_PARSING_SUCCES) {
+                                die(STATE_UNKNOWN, "failed to parse warning threshold: %s", optarg);
                         }
-                        break;
+                        result.config.time_thresholds =
+                                mp_thresholds_set_warn(result.config.time_thresholds, critical_range.range);
+                } break;
                 case 'c': /* critical time threshold */
-                        if (is_intnonneg(optarg)) {
-                                result.config.critical_time = atoi(optarg);
-                                result.config.check_critical_time = true;
-                        } else {
-                                usage4(_("Critical time must be a positive integer"));
+                {
+                        mp_range_parsed critical_range = mp_parse_range_string(optarg);
+                        if (critical_range.error != MP_PARSING_SUCCES) {
+                                die(STATE_UNKNOWN, "failed to parse critical threshold: %s", optarg);
                         }
-                        break;
+                        result.config.time_thresholds =
+                                mp_thresholds_set_crit(result.config.time_thresholds, critical_range.range);
+                } break;
                 case 'v': /* verbose */
                         verbose = true;
                         break;
@@ -368,6 +440,18 @@ check_real_config_wrapper process_arguments(int argc, char **argv) {
                 case 'h': /* help */
                         print_help();
                         exit(STATE_UNKNOWN);
+                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;
+                }
                 case '?': /* usage */
                         usage5();
                 }
@@ -390,10 +474,6 @@ check_real_config_wrapper process_arguments(int argc, char **argv) {
                 result.config.host_name = strdup(result.config.server_address);
         }
 
-        if (result.config.server_expect == NULL) {
-                result.config.server_expect = strdup(EXPECT);
-        }
-
         return result;
 }
 
@@ -420,7 +500,7 @@ void print_help(void) {
         printf(" %s\n", "-u, --url=STRING");
         printf("    %s\n", _("Connect to this url"));
         printf(" %s\n", "-e, --expect=STRING");
-        printf(_("String to expect in first line of server response (default: %s)\n"), EXPECT);
+        printf(_("String to expect in first line of server response (default: %s)\n"), default_expect);
 
         printf(UT_WARN_CRIT);
 
diff --git a/plugins/check_real.d/config.h b/plugins/check_real.d/config.h
index c4663cf9..2d99ad49 100644
--- a/plugins/check_real.d/config.h
+++ b/plugins/check_real.d/config.h
@@ -1,12 +1,16 @@
 #pragma once
 
 #include "../../config.h"
+#include "output.h"
+#include "thresholds.h"
 #include <stddef.h>
 
 enum {
         PORT = 554
 };
 
+const char *default_expect = "RTSP/1.";
+
 typedef struct {
         char *server_address;
         char *host_name;
@@ -14,10 +18,11 @@ typedef struct {
         char *server_url;
 
         char *server_expect;
-        int warning_time;
-        bool check_warning_time;
-        int critical_time;
-        bool check_critical_time;
+
+        mp_thresholds time_thresholds;
+
+        bool output_format_is_set;
+        mp_output_format output_format;
 } check_real_config;
 
 check_real_config check_real_config_init() {
@@ -27,11 +32,11 @@ check_real_config check_real_config_init() {
                 .server_port = PORT,
                 .server_url = NULL,
 
-                .server_expect = NULL,
-                .warning_time = 0,
-                .check_warning_time = false,
-                .critical_time = 0,
-                .check_critical_time = false,
+                .server_expect = default_expect,
+
+                .time_thresholds = mp_thresholds_init(),
+
+                .output_format_is_set = false,
         };
         return tmp;
 }
diff --git a/plugins/check_time.c b/plugins/check_time.c
index fc9ba3f9..99708ad3 100644
--- a/plugins/check_time.c
+++ b/plugins/check_time.c
@@ -68,6 +68,7 @@ int main(int argc, char **argv) {
 
         /* set socket timeout */
         alarm(socket_timeout);
+        time_t start_time;
         time(&start_time);
 
         int socket;
@@ -113,6 +114,7 @@ int main(int argc, char **argv) {
         close(socket);
 
         /* reset the alarm */
+        time_t end_time;
         time(&end_time);
         alarm(0);
 
diff --git a/plugins/utils.c b/plugins/utils.c
index 41fe5fcf..dc6f5a85 100644
--- a/plugins/utils.c
+++ b/plugins/utils.c
@@ -40,7 +40,6 @@ extern const char *progname;
 #define STRLEN 64
 #define TXTBLK 128
 
-time_t start_time, end_time;
 
 void usage(const char *msg) {
         printf("%s\n", msg);
diff --git a/plugins/utils.h b/plugins/utils.h
index 1f0e021b..68ff1630 100644
--- a/plugins/utils.h
+++ b/plugins/utils.h
@@ -32,8 +32,6 @@ suite of plugins. */
 void support(void);
 void print_revision(const char *, const char *);
 
-extern time_t start_time, end_time;
-
 /* Test input types */
 
 bool is_integer(char *);