check_swap: clang-format + minor cosmetics/debugging/etc

1 files changed, 330 insertions, 303 deletions

diff --git a/plugins/check_swap.c b/plugins/check_swap.c
index 6e995156..40ac2ed3 100644
--- a/plugins/check_swap.c
+++ b/plugins/check_swap.c
@@ -1,31 +1,31 @@
 /*****************************************************************************
-*
-* Monitoring check_swap plugin
-*
-* License: GPL
-* Copyright (c) 2000 Karl DeBisschop (kdebisschop@users.sourceforge.net)
-* Copyright (c) 2000-2007 Monitoring Plugins Development Team
-*
-* Description:
-*
-* This file contains the check_swap plugin
-*
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-*
-*****************************************************************************/
+ *
+ * Monitoring check_swap plugin
+ *
+ * License: GPL
+ * Copyright (c) 2000 Karl DeBisschop (kdebisschop@users.sourceforge.net)
+ * Copyright (c) 2000-2007 Monitoring Plugins Development Team
+ *
+ * Description:
+ *
+ * This file contains the check_swap plugin
+ *
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ *****************************************************************************/
 
 const char *progname = "check_swap";
 const char *copyright = "2000-2007";
@@ -36,19 +36,19 @@ const char *email = "devel@monitoring-plugins.org";
 #include "utils.h"
 
 #ifdef HAVE_DECL_SWAPCTL
-# ifdef HAVE_SYS_PARAM_H
-#  include <sys/param.h>
-# endif
-# ifdef HAVE_SYS_SWAP_H
-#  include <sys/swap.h>
-# endif
-# ifdef HAVE_SYS_STAT_H
-#  include <sys/stat.h>
-# endif
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#ifdef HAVE_SYS_SWAP_H
+#include <sys/swap.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
 #endif
 
 #ifndef SWAP_CONVERSION
-# define SWAP_CONVERSION 1
+#define SWAP_CONVERSION 1
 #endif
 
 typedef struct {
@@ -57,8 +57,8 @@ typedef struct {
 } threshold;
 
 typedef struct {
-        unsigned long long free; // Free swap in Bytes!
-        unsigned long long used; // Used swap in Bytes!
+        unsigned long long free;  // Free swap in Bytes!
+        unsigned long long used;  // Used swap in Bytes!
         unsigned long long total; // Total swap size, you guessed it, in Bytes!
 } swap_metrics;
 
@@ -81,9 +81,10 @@ typedef struct {
         swap_config config;
 } swap_config_wrapper;
 
-swap_config_wrapper process_arguments (swap_config_wrapper config, int argc, char **argv);
-void print_usage ();
-void print_help (swap_config);
+swap_config_wrapper process_arguments(swap_config_wrapper config, int argc,
+                                                                          char **argv);
+void print_usage();
+void print_help(swap_config);
 
 swap_result getSwapFromProcMeminfo(swap_config config);
 swap_result getSwapFromSwapCommand(swap_config config);
@@ -91,7 +92,7 @@ swap_result getSwapFromSwapctl_BSD(swap_config config);
 swap_result getSwapFromSwap_SRV4(swap_config config);
 
 swap_config swap_config_init() {
-        swap_config tmp = { 0 };
+        swap_config tmp = {0};
         tmp.allswaps = false;
         tmp.no_swap_state = STATE_CRITICAL;
         tmp.verbose = 0;
@@ -99,28 +100,25 @@ swap_config swap_config_init() {
         return tmp;
 }
 
-
-int main (int argc, char **argv) {
-        setlocale (LC_ALL, "");
-        bindtextdomain (PACKAGE, LOCALEDIR);
-        textdomain (PACKAGE);
+int main(int argc, char **argv) {
+        setlocale(LC_ALL, "");
+        bindtextdomain(PACKAGE, LOCALEDIR);
+        textdomain(PACKAGE);
 
         char *status;
-        status = strdup ("");
+        status = strdup("");
 
         /* Parse extra opts if any */
-        argv=np_extra_opts (&argc, argv, progname);
+        argv = np_extra_opts(&argc, argv, progname);
 
-        swap_config_wrapper tmp = {
-                .errorcode = OK
-        };
+        swap_config_wrapper tmp = {.errorcode = OK};
 
         tmp.config = swap_config_init();
 
-        tmp = process_arguments (tmp, argc, argv);
+        tmp = process_arguments(tmp, argc, argv);
 
         if (tmp.errorcode != OK) {
-                usage4 (_("Could not parse arguments"));
+                usage4(_("Could not parse arguments"));
         }
 
         swap_config config = tmp.config;
@@ -128,194 +126,208 @@ int main (int argc, char **argv) {
 #ifdef HAVE_PROC_MEMINFO
         swap_result data = getSwapFromProcMeminfo(config);
 #else
-# ifdef HAVE_SWAP
+#ifdef HAVE_SWAP
         swap_result data = getSwapFromSwapCommand();
-# else
-#  ifdef CHECK_SWAP_SWAPCTL_SVR4
+#else
+#ifdef CHECK_SWAP_SWAPCTL_SVR4
         swap_result data = getSwapFromSwapctl_SRV4();
-#  else
-#   ifdef CHECK_SWAP_SWAPCTL_BSD
+#else
+#ifdef CHECK_SWAP_SWAPCTL_BSD
         swap_result data = getSwapFromSwapctl_BSD();
-#   else
-        #error No now found to retrieve swap
-#   endif /* CHECK_SWAP_SWAPCTL_BSD */
-#  endif /* CHECK_SWAP_SWAPCTL_SVR4 */
-# endif /* HAVE_SWAP */
+#else
+#error No way found to retrieve swap
+#endif /* CHECK_SWAP_SWAPCTL_BSD */
+#endif /* CHECK_SWAP_SWAPCTL_SVR4 */
+#endif /* HAVE_SWAP */
 #endif /* HAVE_PROC_MEMINFO */
 
         double percent_used;
 
         /* if total_swap_mb == 0, let's not divide by 0 */
-        if(data.metrics.total != 0) {
-                percent_used = 100 * ((double) data.metrics.used) / ((double) data.metrics.total);
+        if (data.metrics.total != 0) {
+                percent_used =
+                        100 * ((double)data.metrics.used) / ((double)data.metrics.total);
         } else {
-                printf (_("SWAP %s - Swap is either disabled, not present, or of zero size."),
-                        state_text (data.statusCode));
+                printf(_("SWAP %s - Swap is either disabled, not present, or of zero "
+                                 "size."),
+                           state_text(data.statusCode));
                 exit(config.no_swap_state);
         }
 
+        if (config.verbose) {
+                printf("Computed usage percentage: %g\n", percent_used);
+        }
+
         uint64_t warn_print = config.warn.value;
         if (config.warn.is_percentage) {
-                warn_print =
-                        config.warn.value * (data.metrics.total / 100);
+                warn_print = config.warn.value * (data.metrics.total / 100);
         }
 
         uint64_t crit_print = config.crit.value;
         if (config.crit.is_percentage) {
-                crit_print =
-                        config.crit.value * (data.metrics.total  / 100);
+                crit_print = config.crit.value * (data.metrics.total / 100);
         }
 
-        char *perfdata = perfdata_uint64(
-                "swap",
-                data.metrics.free,
-                "B",
-                true, warn_print,
-                true, crit_print,
-                true, 0,
-                true, (long)data.metrics.total);
+        char *perfdata =
+                perfdata_uint64("swap", data.metrics.free, "B", true, warn_print, true,
+                                                crit_print, true, 0, true, (long)data.metrics.total);
 
         if (config.verbose > 1) {
-                printf("Warn threshold value: %"PRIu64"\n", config.warn.value);
+                printf("Warn threshold value: %" PRIu64 "\n", config.warn.value);
         }
 
-        if ((config.warn.is_percentage && (percent_used >= (100 - config.warn.value))) ||
-                        config.warn.value >= data.metrics.free) {
-                        data.statusCode = max_state (data.statusCode, STATE_WARNING);
-                }
+        if ((config.warn.is_percentage &&
+                 (percent_used >= (100 - config.warn.value))) ||
+                config.warn.value >= data.metrics.free) {
+                data.statusCode = max_state(data.statusCode, STATE_WARNING);
+        }
 
-        if ((config.crit.is_percentage && (percent_used >= (100 - config.crit.value))) ||
-                        config.crit.value >= data.metrics.free) {
-                        data.statusCode = max_state (data.statusCode, STATE_CRITICAL);
-                }
+        if (config.verbose > 1) {
+                printf("Crit threshold value: %" PRIu64 "\n", config.crit.value);
+        }
 
-        printf (_("SWAP %s - %g%% free (%lluMB out of %lluMB) %s|%s\n"),
-                        state_text (data.statusCode),
-                        (100 - percent_used), data.metrics.free, data.metrics.total, status,
-                        perfdata);
+        if ((config.crit.is_percentage &&
+                 (percent_used >= (100 - config.crit.value))) ||
+                config.crit.value >= data.metrics.free) {
+                data.statusCode = max_state(data.statusCode, STATE_CRITICAL);
+        }
+
+        printf(_("SWAP %s - %g%% free (%lluMB out of %lluMB) %s|%s\n"),
+                   state_text(data.statusCode), (100 - percent_used), data.metrics.free,
+                   data.metrics.total, status, perfdata);
 
         exit(data.statusCode);
 }
 
 /* process command-line arguments */
-swap_config_wrapper process_arguments (swap_config_wrapper conf_wrapper, int argc, char **argv) {
+swap_config_wrapper process_arguments(swap_config_wrapper conf_wrapper,
+                                                                          int argc, char **argv) {
         if (argc < 2) {
                 conf_wrapper.errorcode = ERROR;
                 return conf_wrapper;
         }
 
         int option = 0;
-        static struct option longopts[] = {
-                {"warning", required_argument, 0, 'w'},
-                {"critical", required_argument, 0, 'c'},
-                {"allswaps", no_argument, 0, 'a'},
-                {"no-swap", required_argument, 0, 'n'},
-                {"verbose", no_argument, 0, 'v'},
-                {"version", no_argument, 0, 'V'},
-                {"help", no_argument, 0, 'h'},
-                {0, 0, 0, 0}
-        };
-
-        int c = 0;  /* option character */
+        static struct option longopts[] = {{"warning", required_argument, 0, 'w'},
+                                                                           {"critical", required_argument, 0, 'c'},
+                                                                           {"allswaps", no_argument, 0, 'a'},
+                                                                           {"no-swap", required_argument, 0, 'n'},
+                                                                           {"verbose", no_argument, 0, 'v'},
+                                                                           {"version", no_argument, 0, 'V'},
+                                                                           {"help", no_argument, 0, 'h'},
+                                                                           {0, 0, 0, 0}};
+
+        int c = 0; /* option character */
         while (true) {
-                c = getopt_long (argc, argv, "+?Vvhac:w:n:", longopts, &option);
+                c = getopt_long(argc, argv, "+?Vvhac:w:n:", longopts, &option);
 
                 if (c == -1 || c == EOF)
                         break;
 
                 switch (c) {
                 case 'w': /* warning size threshold */
-                        {
-                                /*
-                                 * We expect either a positive integer value without a unit, which means
-                                 * the unit is Bytes or a positive integer value and a percentage sign (%),
-                                 * which means the value must be with 0 and 100 and is relative to the total swap
-                                 */
-                                size_t length;
-                                length = strlen(optarg);
-
-                                if (optarg[length - 1] == '%') {
-                                        /* It's percentage */
-                                        conf_wrapper.config.warn.is_percentage = true;
-                                        optarg[length - 1] = '\0';
-                                        if (is_uint64(optarg, &conf_wrapper.config.warn.value)) {
-                                                if (conf_wrapper.config.warn.value > 100) {
-                                                        usage4 (_("Warning threshold percentage must be <= 100!"));
-                                                }
+                {
+                        /*
+                         * We expect either a positive integer value without a unit, which
+                         * means the unit is Bytes or a positive integer value and a
+                         * percentage sign (%), which means the value must be with 0 and 100
+                         * and is relative to the total swap
+                         */
+                        size_t length;
+                        length = strlen(optarg);
+
+                        if (optarg[length - 1] == '%') {
+                                /* It's percentage */
+                                conf_wrapper.config.warn.is_percentage = true;
+                                optarg[length - 1] = '\0';
+                                if (is_uint64(optarg, &conf_wrapper.config.warn.value)) {
+                                        if (conf_wrapper.config.warn.value > 100) {
+                                                usage4(
+                                                        _("Warning threshold percentage must be <= 100!"));
                                         }
+                                }
+                                break;
+                        } else {
+                                /* It's Bytes */
+                                conf_wrapper.config.warn.is_percentage = false;
+                                if (is_uint64(optarg, &conf_wrapper.config.warn.value)) {
                                         break;
                                 } else {
-                                        /* It's Bytes */
-                                        conf_wrapper.config.warn.is_percentage = false;
-                                        if (is_uint64(optarg, &conf_wrapper.config.warn.value)) {
-                                                break;
-                                        } else {
-                                                usage4 (_("Warning threshold be positive integer or percentage!"));
-                                        }
+                                        usage4(_("Warning threshold be positive integer or "
+                                                         "percentage!"));
                                 }
                         }
+                }
                 case 'c': /* critical size threshold */
-                        {
-                                /*
-                                 * We expect either a positive integer value without a unit, which means
-                                 * the unit is Bytes or a positive integer value and a percentage sign (%),
-                                 * which means the value must be with 0 and 100 and is relative to the total swap
-                                 */
-                                size_t length;
-                                length = strlen(optarg);
-
-                                if (optarg[length - 1] == '%') {
-                                        /* It's percentage */
-                                        conf_wrapper.config.crit.is_percentage = true;
-                                        optarg[length - 1] = '\0';
-                                        if (is_uint64(optarg, &conf_wrapper.config.crit.value)) {
-                                                if (conf_wrapper.config.crit.value> 100) {
-                                                        usage4 (_("Critical threshold percentage must be <= 100!"));
-                                                }
+                {
+                        /*
+                         * We expect either a positive integer value without a unit, which
+                         * means the unit is Bytes or a positive integer value and a
+                         * percentage sign (%), which means the value must be with 0 and 100
+                         * and is relative to the total swap
+                         */
+                        size_t length;
+                        length = strlen(optarg);
+
+                        if (optarg[length - 1] == '%') {
+                                /* It's percentage */
+                                conf_wrapper.config.crit.is_percentage = true;
+                                optarg[length - 1] = '\0';
+                                if (is_uint64(optarg, &conf_wrapper.config.crit.value)) {
+                                        if (conf_wrapper.config.crit.value > 100) {
+                                                usage4(
+                                                        _("Critical threshold percentage must be <= 100!"));
                                         }
+                                }
+                                break;
+                        } else {
+                                /* It's Bytes */
+                                conf_wrapper.config.crit.is_percentage = false;
+                                if (is_uint64(optarg, &conf_wrapper.config.crit.value)) {
                                         break;
                                 } else {
-                                        /* It's Bytes */
-                                        conf_wrapper.config.crit.is_percentage = false;
-                                        if (is_uint64(optarg, &conf_wrapper.config.crit.value)) {
-                                                break;
-                                        } else {
-                                                usage4 (_("Critical threshold be positive integer or percentage!"));
-                                        }
+                                        usage4(_("Critical threshold be positive integer or "
+                                                         "percentage!"));
                                 }
-                          }
-                case 'a':                                                                       /* all swap */
+                        }
+                }
+                case 'a': /* all swap */
                         conf_wrapper.config.allswaps = true;
                         break;
                 case 'n':
-                        if ((conf_wrapper.config.no_swap_state = mp_translate_state(optarg)) == ERROR) {
-                                usage4 (_("no-swap result must be a valid state name (OK, WARNING, CRITICAL, UNKNOWN) or integer (0-3)."));
+                        if ((conf_wrapper.config.no_swap_state =
+                                         mp_translate_state(optarg)) == ERROR) {
+                                usage4(_("no-swap result must be a valid state name (OK, "
+                                                 "WARNING, CRITICAL, UNKNOWN) or integer (0-3)."));
                         }
                         break;
-                case 'v':                                                                       /* verbose */
+                case 'v': /* verbose */
                         conf_wrapper.config.verbose++;
                         break;
-                case 'V':                                                                       /* version */
-                        print_revision (progname, NP_VERSION);
-                        exit (STATE_UNKNOWN);
-                case 'h':                                                                       /* help */
-                        print_help (conf_wrapper.config);
-                        exit (STATE_UNKNOWN);
-                case '?':                                                                       /* error */
-                        usage5 ();
+                case 'V': /* version */
+                        print_revision(progname, NP_VERSION);
+                        exit(STATE_UNKNOWN);
+                case 'h': /* help */
+                        print_help(conf_wrapper.config);
+                        exit(STATE_UNKNOWN);
+                case '?': /* error */
+                        usage5();
                 }
         }
 
         c = optind;
 
-        if (conf_wrapper.config.warn.value == 0 && conf_wrapper.config.crit.value == 0) {
+        if (conf_wrapper.config.warn.value == 0 &&
+                conf_wrapper.config.crit.value == 0) {
                 conf_wrapper.errorcode = ERROR;
                 return conf_wrapper;
-        } else if ((conf_wrapper.config.warn.is_percentage == conf_wrapper.config.crit.is_percentage) &&
-                        (conf_wrapper.config.warn.value < conf_wrapper.config.crit.value)) {
-                /* This is NOT triggered if warn and crit are different units, e.g warn is percentage
-                 * and crit is absolute. We cannot determine the condition at this point since we
-                 * dont know the value of total swap yet
+        } else if ((conf_wrapper.config.warn.is_percentage ==
+                                conf_wrapper.config.crit.is_percentage) &&
+                           (conf_wrapper.config.warn.value >=
+                                conf_wrapper.config.crit.value)) {
+                /* This is NOT triggered if warn and crit are different units, e.g warn
+                 * is percentage and crit is absolute. We cannot determine the condition
+                 * at this point since we dont know the value of total swap yet
                  */
                 usage4(_("Warning should be more than critical"));
         }
@@ -323,52 +335,57 @@ swap_config_wrapper process_arguments (swap_config_wrapper conf_wrapper, int arg
         return conf_wrapper;
 }
 
+void print_help(swap_config config) {
+        print_revision(progname, NP_VERSION);
 
-void
-print_help (swap_config config)
-{
-        print_revision (progname, NP_VERSION);
+        printf(_(COPYRIGHT), copyright, email);
 
-        printf (_(COPYRIGHT), copyright, email);
+        printf("%s\n", _("Check swap space on local machine."));
 
-        printf ("%s\n", _("Check swap space on local machine."));
-
-        printf ("\n\n");
+        printf("\n\n");
 
         print_usage();
 
-        printf (UT_HELP_VRSN);
-        printf (UT_EXTRA_OPTS);
-
-        printf (" %s\n", "-w, --warning=INTEGER");
-        printf ("    %s\n", _("Exit with WARNING status if less than INTEGER bytes of swap space are free"));
-        printf (" %s\n", "-w, --warning=PERCENT%");
-        printf ("    %s\n", _("Exit with WARNING status if less than PERCENT of swap space is free"));
-        printf (" %s\n", "-c, --critical=INTEGER");
-        printf ("    %s\n", _("Exit with CRITICAL status if less than INTEGER bytes of swap space are free"));
-        printf (" %s\n", "-c, --critical=PERCENT%");
-        printf ("    %s\n", _("Exit with CRITICAL status if less than PERCENT of swap space is free"));
-        printf (" %s\n", "-a, --allswaps");
-        printf ("    %s\n", _("Conduct comparisons for all swap partitions, one by one"));
-        printf (" %s\n", "-n, --no-swap=<ok|warning|critical|unknown>");
-        printf ("    %s %s\n", _("Resulting state when there is no swap regardless of thresholds. Default:"), state_text(config.no_swap_state));
-        printf (UT_VERBOSE);
-
-        printf ("\n");
-        printf ("%s\n", _("Notes:"));
-        printf (" %s\n", _("Both INTEGER and PERCENT thresholds can be specified, they are all checked."));
-        printf (" %s\n", _("On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s."));
-
-        printf (UT_SUPPORT);
+        printf(UT_HELP_VRSN);
+        printf(UT_EXTRA_OPTS);
+
+        printf(" %s\n", "-w, --warning=INTEGER");
+        printf("    %s\n", _("Exit with WARNING status if less than INTEGER bytes "
+                                                 "of swap space are free"));
+        printf(" %s\n", "-w, --warning=PERCENT%");
+        printf("    %s\n", _("Exit with WARNING status if less than PERCENT of "
+                                                 "swap space is free"));
+        printf(" %s\n", "-c, --critical=INTEGER");
+        printf("    %s\n", _("Exit with CRITICAL status if less than INTEGER bytes "
+                                                 "of swap space are free"));
+        printf(" %s\n", "-c, --critical=PERCENT%");
+        printf("    %s\n", _("Exit with CRITICAL status if less than PERCENT of "
+                                                 "swap space is free"));
+        printf(" %s\n", "-a, --allswaps");
+        printf("    %s\n",
+                   _("Conduct comparisons for all swap partitions, one by one"));
+        printf(" %s\n", "-n, --no-swap=<ok|warning|critical|unknown>");
+        printf("    %s %s\n",
+                   _("Resulting state when there is no swap regardless of thresholds. "
+                         "Default:"),
+                   state_text(config.no_swap_state));
+        printf(UT_VERBOSE);
+
+        printf("\n");
+        printf("%s\n", _("Notes:"));
+        printf(" %s\n", _("Both INTEGER and PERCENT thresholds can be specified, "
+                                          "they are all checked."));
+        printf(
+                " %s\n",
+                _("On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s."));
+
+        printf(UT_SUPPORT);
 }
 
-
-void
-print_usage ()
-{
-        printf ("%s\n", _("Usage:"));
-        printf (" %s [-av] -w <percent_free>%% -c <percent_free>%%\n",progname);
-        printf ("  -w <bytes_free> -c <bytes_free> [-n <state>]\n");
+void print_usage() {
+        printf("%s\n", _("Usage:"));
+        printf(" %s [-av] -w <percent_free>%% -c <percent_free>%%\n", progname);
+        printf("  -w <bytes_free> -c <bytes_free> [-n <state>]\n");
 }
 
 #ifdef HAVE_PROC_MEMINFO
@@ -379,10 +396,9 @@ swap_result getSwapFromProcMeminfo(swap_config config) {
         }
 
         FILE *fp;
-        fp = fopen (PROC_MEMINFO, "r");
-
+        fp = fopen(PROC_MEMINFO, "r");
 
-        swap_result result  = { 0 };
+        swap_result result = {0};
         result.statusCode = STATE_OK;
 
         uint64_t swap_total = 0, swap_used = 0, swap_free = 0;
@@ -390,13 +406,14 @@ swap_result getSwapFromProcMeminfo(swap_config config) {
         char input_buffer[MAX_INPUT_BUFFER];
         char str[32];
 
-        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
+        while (fgets(input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
                 uint64_t tmp_KB = 0;
 
                 /*
-                 * The following sscanf call looks for a line looking like: "Swap: 123 123 123"
-                 * On which kind of system this format exists, I can not say, but I wanted to
-                 * document this for people who are not adapt with sscanf anymore, like me
+                 * The following sscanf call looks for a line looking like: "Swap: 123
+                 * 123 123" On which kind of system this format exists, I can not say,
+                 * but I wanted to document this for people who are not adapt with
+                 * sscanf anymore, like me
                  */
                 if (sscanf(input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %lu %lu %lu",
                                    &swap_total, &swap_used, &swap_free) == 3) {
@@ -440,7 +457,7 @@ swap_result getSwapFromProcMeminfo(swap_config config) {
 
 #ifdef HAVE_SWAP
 swap_result getSwapFromSwapCommand() {
-        swap_result result  = { 0 };
+        swap_result result = {0};
 
         char *temp_buffer;
         char *swap_command;
@@ -450,128 +467,135 @@ swap_result getSwapFromSwapCommand() {
         xasprintf(&swap_command, "%s", SWAP_COMMAND);
         xasprintf(&swap_format, "%s", SWAP_FORMAT);
 
-/* These override the command used if a summary (and thus ! allswaps) is required */
-/* The summary flag returns more accurate information about swap usage on these OSes */
-# ifdef _AIX
+/* These override the command used if a summary (and thus ! allswaps) is
+ * required */
+/* The summary flag returns more accurate information about swap usage on these
+ * OSes */
+#ifdef _AIX
         if (!allswaps) {
                 xasprintf(&swap_command, "%s", "/usr/sbin/lsps -s");
                 xasprintf(&swap_format, "%s", "%lu%*s %lu");
                 conv_factor = 1;
         }
-# endif
+#endif
 
         if (verbose >= 2)
-                printf (_("Command: %s\n"), swap_command);
+                printf(_("Command: %s\n"), swap_command);
         if (verbose >= 3)
-                printf (_("Format: %s\n"), swap_format);
+                printf(_("Format: %s\n"), swap_format);
 
-        child_process = spopen (swap_command);
+        child_process = spopen(swap_command);
         if (child_process == NULL) {
-                printf (_("Could not open pipe: %s\n"), swap_command);
+                printf(_("Could not open pipe: %s\n"), swap_command);
                 return STATE_UNKNOWN;
         }
 
-        child_stderr = fdopen (child_stderr_array[fileno (child_process)], "r");
+        child_stderr = fdopen(child_stderr_array[fileno(child_process)], "r");
         if (child_stderr == NULL)
-                printf (_("Could not open stderr for %s\n"), swap_command);
+                printf(_("Could not open stderr for %s\n"), swap_command);
 
-        sprintf (str, "%s", "");
+        sprintf(str, "%s", "");
         /* read 1st line */
-        fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process);
-        if (strcmp (swap_format, "") == 0) {
-                temp_buffer = strtok (input_buffer, " \n");
+        fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_process);
+        if (strcmp(swap_format, "") == 0) {
+                temp_buffer = strtok(input_buffer, " \n");
                 while (temp_buffer) {
-                        if (strstr (temp_buffer, "blocks"))
-                                sprintf (str, "%s %s", str, "%lu");
-                        else if (strstr (temp_buffer, "dskfree"))
-                                sprintf (str, "%s %s", str, "%lu");
+                        if (strstr(temp_buffer, "blocks"))
+                                sprintf(str, "%s %s", str, "%lu");
+                        else if (strstr(temp_buffer, "dskfree"))
+                                sprintf(str, "%s %s", str, "%lu");
                         else
-                                sprintf (str, "%s %s", str, "%*s");
-                        temp_buffer = strtok (NULL, " \n");
+                                sprintf(str, "%s %s", str, "%*s");
+                        temp_buffer = strtok(NULL, " \n");
                 }
         }
 
-/* If different swap command is used for summary switch, need to read format differently */
-# ifdef _AIX
+/* If different swap command is used for summary switch, need to read format
+ * differently */
+#ifdef _AIX
         if (!allswaps) {
-                fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_process);       /* Ignore first line */
-                sscanf (input_buffer, swap_format, &total_swap_mb, &used_swap_mb);
-                free_swap_mb = total_swap_mb * (100 - used_swap_mb) /100;
+                fgets(input_buffer, MAX_INPUT_BUFFER - 1,
+                          child_process); /* Ignore first line */
+                sscanf(input_buffer, swap_format, &total_swap_mb, &used_swap_mb);
+                free_swap_mb = total_swap_mb * (100 - used_swap_mb) / 100;
                 used_swap_mb = total_swap_mb - free_swap_mb;
                 if (verbose >= 3)
-                        printf (_("total=%.0f, used=%.0f, free=%.0f\n"), total_swap_mb, used_swap_mb, free_swap_mb);
+                        printf(_("total=%.0f, used=%.0f, free=%.0f\n"), total_swap_mb,
+                                   used_swap_mb, free_swap_mb);
         } else {
-# endif
-                while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
-                        sscanf (input_buffer, swap_format, &dsktotal_mb, &dskfree_mb);
+#endif
+                while (fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+                        sscanf(input_buffer, swap_format, &dsktotal_mb, &dskfree_mb);
 
                         dsktotal_mb = dsktotal_mb / conv_factor;
                         /* AIX lists percent used, so this converts to dskfree in MBs */
-#  ifdef _AIX
+#ifdef _AIX
                         dskfree_mb = dsktotal_mb * (100 - dskfree_mb) / 100;
-#  else
-                        dskfree_mb = dskfree_mb / conv_factor;
-#  endif
+#else
+                dskfree_mb = dskfree_mb / conv_factor;
+#endif
                         if (verbose >= 3)
-                                printf (_("total=%.0f, free=%.0f\n"), dsktotal_mb, dskfree_mb);
+                                printf(_("total=%.0f, free=%.0f\n"), dsktotal_mb, dskfree_mb);
 
                         dskused_mb = dsktotal_mb - dskfree_mb;
                         total_swap_mb += dsktotal_mb;
                         used_swap_mb += dskused_mb;
                         free_swap_mb += dskfree_mb;
                         if (allswaps) {
-                                percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
-                                result = max_state (result, check_swap (dskfree_mb, dsktotal_mb));
+                                percent = 100 * (((double)dskused_mb) / ((double)dsktotal_mb));
+                                result = max_state(result, check_swap(dskfree_mb, dsktotal_mb));
                                 if (verbose)
-                                        xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
+                                        xasprintf(&status, "%s [%.0f (%d%%)]", status, dskfree_mb,
+                                                          100 - percent);
                         }
                 }
-#  ifdef _AIX
+#ifdef _AIX
         }
-#  endif
+#endif
 
         /* If we get anything on STDERR, at least set warning */
-        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
-                result = max_state (result, STATE_WARNING);
+        while (fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = max_state(result, STATE_WARNING);
 
         /* close stderr */
-        (void) fclose (child_stderr);
+        (void)fclose(child_stderr);
 
         /* close the pipe */
-        if (spclose (child_process))
-                result = max_state (result, STATE_WARNING);
+        if (spclose(child_process))
+                result = max_state(result, STATE_WARNING);
 }
 #endif // HAVE_SWAP
 
 #ifdef CHECK_SWAP_SWAPCTL_BSD
 swap_result getSwapFromSwapctl_BSD() {
-        int i=0, nswaps=0, swapctl_res=0;
+        int i = 0, nswaps = 0, swapctl_res = 0;
         struct swapent *ent;
         int conv_factor = SWAP_CONVERSION;
 
         /* get the number of active swap devices */
-        nswaps=swapctl(SWAP_NSWAP, NULL, 0);
+        nswaps = swapctl(SWAP_NSWAP, NULL, 0);
 
         /* initialize swap table + entries */
-        ent=(struct swapent*)malloc(sizeof(struct swapent)*nswaps);
+        ent = (struct swapent *)malloc(sizeof(struct swapent) * nswaps);
 
         /* and now, tally 'em up */
-        swapctl_res=swapctl(SWAP_STATS, ent, nswaps);
-        if(swapctl_res < 0){
+        swapctl_res = swapctl(SWAP_STATS, ent, nswaps);
+        if (swapctl_res < 0) {
                 perror(_("swapctl failed: "));
                 die(STATE_UNKNOWN, _("Error in swapctl call\n"));
         }
 
-        for(i=0;i<nswaps;i++){
-                dsktotal_mb = (float) ent[i].se_nblks / conv_factor;
-                dskused_mb = (float) ent[i].se_inuse / conv_factor;
-                dskfree_mb = ( dsktotal_mb - dskused_mb );
+        for (i = 0; i < nswaps; i++) {
+                dsktotal_mb = (float)ent[i].se_nblks / conv_factor;
+                dskused_mb = (float)ent[i].se_inuse / conv_factor;
+                dskfree_mb = (dsktotal_mb - dskused_mb);
 
-                if(allswaps && dsktotal_mb > 0){
-                        percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
-                        result = max_state (result, check_swap(dskfree_mb, dsktotal_mb));
+                if (allswaps && dsktotal_mb > 0) {
+                        percent = 100 * (((double)dskused_mb) / ((double)dsktotal_mb));
+                        result = max_state(result, check_swap(dskfree_mb, dsktotal_mb));
                         if (verbose) {
-                                xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
+                                xasprintf(&status, "%s [%.0f (%d%%)]", status, dskfree_mb,
+                                                  100 - percent);
                         }
                 }
 
@@ -587,52 +611,55 @@ swap_result getSwapFromSwapctl_BSD() {
 
 #ifdef CHECK_SWAP_SWAPCTL_SVR4
 swap_result getSwapFromSwap_SRV4() {
-        int i=0, nswaps=0, swapctl_res=0;
-        swaptbl_t *tbl=NULL;
-        swapent_t *ent=NULL;
+        int i = 0, nswaps = 0, swapctl_res = 0;
+        swaptbl_t *tbl = NULL;
+        swapent_t *ent = NULL;
         /* get the number of active swap devices */
-        if((nswaps=swapctl(SC_GETNSWP, NULL))== -1)
-                die(STATE_UNKNOWN, _("Error getting swap devices\n") );
+        if ((nswaps = swapctl(SC_GETNSWP, NULL)) == -1)
+                die(STATE_UNKNOWN, _("Error getting swap devices\n"));
 
-        if(nswaps == 0)
+        if (nswaps == 0)
                 die(STATE_OK, _("SWAP OK: No swap devices defined\n"));
 
-        if(verbose >= 3)
+        if (verbose >= 3)
                 printf("Found %d swap device(s)\n", nswaps);
 
         /* initialize swap table + entries */
-        tbl=(swaptbl_t*)malloc(sizeof(swaptbl_t)+(sizeof(swapent_t)*nswaps));
+        tbl = (swaptbl_t *)malloc(sizeof(swaptbl_t) + (sizeof(swapent_t) * nswaps));
 
-        if(tbl==NULL)
+        if (tbl == NULL)
                 die(STATE_UNKNOWN, _("malloc() failed!\n"));
 
-        memset(tbl, 0, sizeof(swaptbl_t)+(sizeof(swapent_t)*nswaps));
-        tbl->swt_n=nswaps;
-        for(i=0;i<nswaps;i++){
-                if((tbl->swt_ent[i].ste_path=(char*)malloc(sizeof(char)*MAXPATHLEN)) == NULL)
+        memset(tbl, 0, sizeof(swaptbl_t) + (sizeof(swapent_t) * nswaps));
+        tbl->swt_n = nswaps;
+        for (i = 0; i < nswaps; i++) {
+                if ((tbl->swt_ent[i].ste_path =
+                                 (char *)malloc(sizeof(char) * MAXPATHLEN)) == NULL)
                         die(STATE_UNKNOWN, _("malloc() failed!\n"));
         }
 
         /* and now, tally 'em up */
-        swapctl_res=swapctl(SC_LIST, tbl);
-        if(swapctl_res < 0){
+        swapctl_res = swapctl(SC_LIST, tbl);
+        if (swapctl_res < 0) {
                 perror(_("swapctl failed: "));
                 die(STATE_UNKNOWN, _("Error in swapctl call\n"));
         }
 
-        for(i=0;i<nswaps;i++){
-                dsktotal_mb = (float) tbl->swt_ent[i].ste_pages / SWAP_CONVERSION;
-                dskfree_mb = (float) tbl->swt_ent[i].ste_free /  SWAP_CONVERSION;
-                dskused_mb = ( dsktotal_mb - dskfree_mb );
+        for (i = 0; i < nswaps; i++) {
+                dsktotal_mb = (float)tbl->swt_ent[i].ste_pages / SWAP_CONVERSION;
+                dskfree_mb = (float)tbl->swt_ent[i].ste_free / SWAP_CONVERSION;
+                dskused_mb = (dsktotal_mb - dskfree_mb);
 
                 if (verbose >= 3)
-                        printf ("dsktotal_mb=%.0f dskfree_mb=%.0f dskused_mb=%.0f\n", dsktotal_mb, dskfree_mb, dskused_mb);
+                        printf("dsktotal_mb=%.0f dskfree_mb=%.0f dskused_mb=%.0f\n",
+                                   dsktotal_mb, dskfree_mb, dskused_mb);
 
-                if(allswaps && dsktotal_mb > 0){
-                        percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
-                        result = max_state (result, check_swap (dskfree_mb, dsktotal_mb));
+                if (allswaps && dsktotal_mb > 0) {
+                        percent = 100 * (((double)dskused_mb) / ((double)dsktotal_mb));
+                        result = max_state(result, check_swap(dskfree_mb, dsktotal_mb));
                         if (verbose) {
-                                xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
+                                xasprintf(&status, "%s [%.0f (%d%%)]", status, dskfree_mb,
+                                                  100 - percent);
                         }
                 }
 
@@ -642,7 +669,7 @@ swap_result getSwapFromSwap_SRV4() {
         }
 
         /* and clean up after ourselves */
-        for(i=0;i<nswaps;i++){
+        for (i = 0; i < nswaps; i++) {
                 free(tbl->swt_ent[i].ste_path);
         }
         free(tbl);