1 files changed, 344 insertions, 236 deletions

diff --git a/plugins/check_ping.c b/plugins/check_ping.c
index 4aafaf41..61feb958 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,90 @@ 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) {
+                if (pinged.packet_loss != 100) {
                         printf("|%s",
-                                   fperfdata("rta", (double)rta, "ms", wrta > 0 ? true : false, wrta, crta > 0 ? true : false, crta, true, 0, false, 0));
+                                   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 +188,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 +197,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 +252,19 @@ 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,219 +272,302 @@ 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 */
         while (fgets(buf, MAX_INPUT_BUFFER - 1, child_stderr)) {
-                if (!strstr(buf, "WARNING - no SO_TIMESTAMP support, falling back to SIOCGSTAMP") && !strstr(buf, "Warning: time of day goes back")
+                if (!strstr(buf, "WARNING - no SO_TIMESTAMP support, falling back to SIOCGSTAMP") &&
+                        !strstr(buf, "Warning: time of day goes back")
 
                 ) {
                         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 {
-                                        xasprintf(&warn_text, "%s %s", warn_text, _("System call sent warnings to stderr "));
+                                        xasprintf(&warn_text, "%s %s", warn_text,
+                                                          _("System call sent warnings to stderr "));
                                 }
                         }
                 }
@@ -474,43 +577,48 @@ 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) {
@@ -550,10 +658,10 @@ void print_help(void) {
         printf("%s\n", _("percentage of packet loss to trigger an alarm state."));
 
         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",
+                   _("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(UT_SUPPORT);
 }