Merge branch 'master' into fix/check_ssh-variable-stuff

2 files changed, 1315 insertions, 1394 deletions

diff --git a/plugins-root/check_dhcp.c b/plugins-root/check_dhcp.c
index 4b8f5e2..6802232 100644
--- a/plugins-root/check_dhcp.c
+++ b/plugins-root/check_dhcp.c
@@ -4,7 +4,7 @@
  *
  * License: GPL
  * Copyright (c) 2001-2004 Ethan Galstad (nagios@nagios.org)
- * Copyright (c) 2001-2007 Monitoring Plugins Development Team
+ * Copyright (c) 2001-2023 Monitoring Plugins Development Team
  *
  * Description:
  *
@@ -34,7 +34,7 @@
  *****************************************************************************/
 
 const char *progname = "check_dhcp";
-const char *copyright = "2001-2023";
+const char *copyright = "2001-2024";
 const char *email = "devel@monitoring-plugins.org";
 
 #include "common.h"
@@ -59,45 +59,45 @@ const char *email = "devel@monitoring-plugins.org";
 #include <arpa/inet.h>
 
 #if HAVE_SYS_SOCKIO_H
-#include <sys/sockio.h>
+#       include <sys/sockio.h>
 #endif // HAVE_SYS_SOCKIO_H
 
-#if defined( __linux__ )
+#if defined(__linux__)
 
-#include <linux/if_ether.h>
-#include <features.h>
+#       include <linux/if_ether.h>
+#       include <features.h>
 
-#elif defined (__bsd__)
+#elif defined(__bsd__)
 
-#include <netinet/if_ether.h>
-#include <sys/param.h>
-#include <sys/sysctl.h>
-#include <net/if_dl.h>
+#       include <netinet/if_ether.h>
+#       include <sys/param.h>
+#       include <sys/sysctl.h>
+#       include <net/if_dl.h>
 
 #elif defined(__sun__) || defined(__solaris__) || defined(__hpux__)
 
-#define INSAP 22
-#define OUTSAP 24
+#       define INSAP  22
+#       define OUTSAP 24
 
-#include <signal.h>
-#include <ctype.h>
-#include <sys/stropts.h>
-#include <sys/poll.h>
-#include <sys/dlpi.h>
+#       include <signal.h>
+#       include <ctype.h>
+#       include <sys/stropts.h>
+#       include <sys/poll.h>
+#       include <sys/dlpi.h>
 
-#define bcopy(source, destination, length) memcpy(destination, source, length)
+#       define bcopy(source, destination, length) memcpy(destination, source, length)
 
-#define AREA_SZ 5000            /* buffer length in bytes */
+#       define AREA_SZ 5000 /* buffer length in bytes */
 static u_long ctl_area[AREA_SZ];
 static u_long dat_area[AREA_SZ];
 static struct strbuf ctl = {AREA_SZ, 0, (char *)ctl_area};
 static struct strbuf dat = {AREA_SZ, 0, (char *)dat_area};
 
-#define GOT_CTRL 1
-#define GOT_DATA 2
-#define GOT_BOTH 3
-#define GOT_INTR 4
-#define GOT_ERR 128
+#       define GOT_CTRL 1
+#       define GOT_DATA 2
+#       define GOT_BOTH 3
+#       define GOT_INTR 4
+#       define GOT_ERR  128
 
 static int get_msg(int);
 static int check_ctrl(int);
@@ -105,178 +105,168 @@ static int put_ctrl(int, int, int);
 static int put_both(int, int, int, int);
 static int dl_open(const char *, int, int *);
 static int dl_bind(int, int, u_char *);
-long mac_addr_dlpi( const char *, int, u_char *);
+static long mac_addr_dlpi(const char *, int, u_char *);
 
 #endif // __sun__ || __solaris__ || __hpux
 
-
-
 /**** Common definitions ****/
 
-#define OK                0
-#define ERROR             -1
-
+#define OK    0
+#define ERROR -1
 
 /**** DHCP definitions ****/
 
-#define MAX_DHCP_CHADDR_LENGTH           16
-#define MAX_DHCP_SNAME_LENGTH            64
-#define MAX_DHCP_FILE_LENGTH             128
-#define MAX_DHCP_OPTIONS_LENGTH          312
-
-
-typedef struct dhcp_packet_struct{
-        uint8_t  op;                   /* packet type */
-        uint8_t  htype;                /* type of hardware address for this machine (Ethernet, etc) */
-        uint8_t  hlen;                 /* length of hardware address (of this machine) */
-        uint8_t  hops;                 /* hops */
-        uint32_t xid;                  /* random transaction id number - chosen by this machine */
-        uint16_t secs;                 /* seconds used in timing */
-        uint16_t flags;                /* flags */
-        struct in_addr ciaddr;          /* IP address of this machine (if we already have one) */
-        struct in_addr yiaddr;          /* IP address of this machine (offered by the DHCP server) */
-        struct in_addr siaddr;          /* IP address of next server */
-        struct in_addr giaddr;          /* IP address of DHCP relay */
-        unsigned char chaddr [MAX_DHCP_CHADDR_LENGTH];      /* hardware address of this machine */
-        char sname [MAX_DHCP_SNAME_LENGTH];    /* name of DHCP server */
-        char file [MAX_DHCP_FILE_LENGTH];      /* boot file name (used for diskless booting?) */
-        char options[MAX_DHCP_OPTIONS_LENGTH];  /* options */
-}dhcp_packet;
-
-
-typedef struct dhcp_offer_struct{
-        struct in_addr server_address;   /* address of DHCP server that sent this offer */
-        struct in_addr offered_address;  /* the IP address that was offered to us */
+#define MAX_DHCP_CHADDR_LENGTH  16
+#define MAX_DHCP_SNAME_LENGTH   64
+#define MAX_DHCP_FILE_LENGTH    128
+#define MAX_DHCP_OPTIONS_LENGTH 312
+
+typedef struct dhcp_packet_struct {
+        uint8_t op;                                   /* packet type */
+        uint8_t htype;                                /* type of hardware address for this machine (Ethernet, etc) */
+        uint8_t hlen;                                 /* length of hardware address (of this machine) */
+        uint8_t hops;                                 /* hops */
+        uint32_t xid;                                 /* random transaction id number - chosen by this machine */
+        uint16_t secs;                                /* seconds used in timing */
+        uint16_t flags;                               /* flags */
+        struct in_addr ciaddr;                        /* IP address of this machine (if we already have one) */
+        struct in_addr yiaddr;                        /* IP address of this machine (offered by the DHCP server) */
+        struct in_addr siaddr;                        /* IP address of next server */
+        struct in_addr giaddr;                        /* IP address of DHCP relay */
+        unsigned char chaddr[MAX_DHCP_CHADDR_LENGTH]; /* hardware address of this machine */
+        char sname[MAX_DHCP_SNAME_LENGTH];            /* name of DHCP server */
+        char file[MAX_DHCP_FILE_LENGTH];              /* boot file name (used for diskless booting?) */
+        char options[MAX_DHCP_OPTIONS_LENGTH];        /* options */
+} dhcp_packet;
+
+typedef struct dhcp_offer_struct {
+        struct in_addr server_address;  /* address of DHCP server that sent this offer */
+        struct in_addr offered_address; /* the IP address that was offered to us */
         uint32_t lease_time;            /* lease time in seconds */
         uint32_t renewal_time;          /* renewal time in seconds */
         uint32_t rebinding_time;        /* rebinding time in seconds */
-        bool desired;                 /* is this offer desired (necessary in exclusive mode) */
+        bool desired;                   /* is this offer desired (necessary in exclusive mode) */
         struct dhcp_offer_struct *next;
-}dhcp_offer;
-
+} dhcp_offer;
 
-typedef struct requested_server_struct{
+typedef struct requested_server_struct {
         struct in_addr server_address;
         bool answered;
         struct requested_server_struct *next;
-}requested_server;
-
-
-#define BOOTREQUEST     1
-#define BOOTREPLY       2
-
-#define DHCPDISCOVER    1
-#define DHCPOFFER       2
-#define DHCPREQUEST     3
-#define DHCPDECLINE     4
-#define DHCPACK         5
-#define DHCPNACK        6
-#define DHCPRELEASE     7
-
-#define DHCP_OPTION_MESSAGE_TYPE        53
-#define DHCP_OPTION_HOST_NAME           12
-#define DHCP_OPTION_BROADCAST_ADDRESS   28
-#define DHCP_OPTION_REQUESTED_ADDRESS   50
-#define DHCP_OPTION_LEASE_TIME          51
-#define DHCP_OPTION_SERVER_IDENTIFIER   54
-#define DHCP_OPTION_RENEWAL_TIME        58
-#define DHCP_OPTION_REBINDING_TIME      59
-#define DHCP_OPTION_END                 255
-
-#define DHCP_INFINITE_TIME              0xFFFFFFFF
+} requested_server;
+
+#define BOOTREQUEST 1
+#define BOOTREPLY   2
+
+#define DHCPDISCOVER 1
+#define DHCPOFFER    2
+#define DHCPREQUEST  3
+#define DHCPDECLINE  4
+#define DHCPACK      5
+#define DHCPNACK     6
+#define DHCPRELEASE  7
+
+#define DHCP_OPTION_MESSAGE_TYPE      53
+#define DHCP_OPTION_HOST_NAME         12
+#define DHCP_OPTION_BROADCAST_ADDRESS 28
+#define DHCP_OPTION_REQUESTED_ADDRESS 50
+#define DHCP_OPTION_LEASE_TIME        51
+#define DHCP_OPTION_SERVER_IDENTIFIER 54
+#define DHCP_OPTION_RENEWAL_TIME      58
+#define DHCP_OPTION_REBINDING_TIME    59
+#define DHCP_OPTION_END               255
+
+#define DHCP_INFINITE_TIME 0xFFFFFFFF
 
 #define DHCP_BROADCAST_FLAG 32768
 
-#define DHCP_SERVER_PORT   67
-#define DHCP_CLIENT_PORT   68
+#define DHCP_SERVER_PORT 67
+#define DHCP_CLIENT_PORT 68
 
-#define ETHERNET_HARDWARE_ADDRESS            1     /* used in htype field of dhcp packet */
-#define ETHERNET_HARDWARE_ADDRESS_LENGTH     6     /* length of Ethernet hardware addresses */
+#define ETHERNET_HARDWARE_ADDRESS        1 /* used in htype field of dhcp packet */
+#define ETHERNET_HARDWARE_ADDRESS_LENGTH 6 /* length of Ethernet hardware addresses */
 
-bool unicast = false;        /* unicast mode: mimic a DHCP relay */
-bool exclusive = false;      /* exclusive mode aka "rogue DHCP server detection" */
-struct in_addr my_ip;        /* our address (required for relay) */
-struct in_addr dhcp_ip;      /* server to query (if in unicast mode) */
-unsigned char client_hardware_address[MAX_DHCP_CHADDR_LENGTH]="";
-unsigned char *user_specified_mac=NULL;
+static bool unicast = false;   /* unicast mode: mimic a DHCP relay */
+static bool exclusive = false; /* exclusive mode aka "rogue DHCP server detection" */
+static struct in_addr my_ip;   /* our address (required for relay) */
+static struct in_addr dhcp_ip; /* server to query (if in unicast mode) */
+static unsigned char client_hardware_address[MAX_DHCP_CHADDR_LENGTH] = "";
+static unsigned char *user_specified_mac = NULL;
 
-char network_interface_name[IFNAMSIZ]="eth0";
+static char network_interface_name[IFNAMSIZ] = "eth0";
 
-uint32_t packet_xid=0;
+static uint32_t packet_xid = 0;
 
-uint32_t dhcp_lease_time=0;
-uint32_t dhcp_renewal_time=0;
-uint32_t dhcp_rebinding_time=0;
+static uint32_t dhcp_lease_time = 0;
+static uint32_t dhcp_renewal_time = 0;
+static uint32_t dhcp_rebinding_time = 0;
 
-int dhcpoffer_timeout=2;
+static int dhcpoffer_timeout = 2;
 
-dhcp_offer *dhcp_offer_list=NULL;
-requested_server *requested_server_list=NULL;
+static dhcp_offer *dhcp_offer_list = NULL;
+static requested_server *requested_server_list = NULL;
 
-int valid_responses=0;     /* number of valid DHCPOFFERs we received */
-int requested_servers=0;
-int requested_responses=0;
+static int valid_responses = 0; /* number of valid DHCPOFFERs we received */
+static int requested_servers = 0;
+static int requested_responses = 0;
 
-bool request_specific_address=false;
-bool received_requested_address=false;
-int verbose=0;
-struct in_addr requested_address;
+static bool request_specific_address = false;
+static bool received_requested_address = false;
+static int verbose = 0;
+static struct in_addr requested_address;
 
-
-int process_arguments(int, char **);
-int call_getopt(int, char **);
-int validate_arguments(int);
+static int process_arguments(int, char **);
+static int call_getopt(int, char **);
+static int validate_arguments(int);
 void print_usage(void);
-void print_help(void);
-
-void resolve_host(const char *in,struct in_addr *out);
-unsigned char *mac_aton(const char *);
-void print_hardware_address(const unsigned char *);
-int get_hardware_address(int,char *);
-int get_ip_address(int,char *);
+static void print_help(void);
 
-int send_dhcp_discover(int);
-int get_dhcp_offer(int);
+static void resolve_host(const char *in, struct in_addr *out);
+static unsigned char *mac_aton(const char *);
+static void print_hardware_address(const unsigned char *);
+static int get_hardware_address(int, char *);
+static int get_ip_address(int, char *);
 
-int get_results(void);
+static int send_dhcp_discover(int);
+static int get_dhcp_offer(int);
 
-int add_dhcp_offer(struct in_addr,dhcp_packet *);
-int free_dhcp_offer_list(void);
-int free_requested_server_list(void);
+static int get_results(void);
 
-int create_dhcp_socket(void);
-int close_dhcp_socket(int);
-int send_dhcp_packet(void *,int,int,struct sockaddr_in *);
-int receive_dhcp_packet(void *,int,int,int,struct sockaddr_in *);
+static int add_dhcp_offer(struct in_addr, dhcp_packet *);
+static int free_dhcp_offer_list(void);
+static int free_requested_server_list(void);
 
+static int create_dhcp_socket(void);
+static int close_dhcp_socket(int);
+static int send_dhcp_packet(void *, int, int, struct sockaddr_in *);
+static int receive_dhcp_packet(void *, int, int, int, struct sockaddr_in *);
 
-
-int main(int argc, char **argv){
+int main(int argc, char **argv) {
         int dhcp_socket;
         int result = STATE_UNKNOWN;
 
-        setlocale (LC_ALL, "");
-        bindtextdomain (PACKAGE, LOCALEDIR);
-        textdomain (PACKAGE);
+        setlocale(LC_ALL, "");
+        bindtextdomain(PACKAGE, LOCALEDIR);
+        textdomain(PACKAGE);
 
         /* Parse extra opts if any */
-        argv=np_extra_opts(&argc, argv, progname);
+        argv = np_extra_opts(&argc, argv, progname);
 
-        if(process_arguments(argc,argv)!=OK){
-                usage4 (_("Could not parse arguments"));
+        if (process_arguments(argc, argv) != OK) {
+                usage4(_("Could not parse arguments"));
         }
 
         /* create socket for DHCP communications */
-        dhcp_socket=create_dhcp_socket();
+        dhcp_socket = create_dhcp_socket();
 
         /* get hardware address of client machine */
-        if(user_specified_mac!=NULL)
-                memcpy(client_hardware_address,user_specified_mac,6);
+        if (user_specified_mac != NULL)
+                memcpy(client_hardware_address, user_specified_mac, 6);
         else
-                get_hardware_address(dhcp_socket,network_interface_name);
+                get_hardware_address(dhcp_socket, network_interface_name);
 
-        if(unicast) /* get IP address of client machine */
-                get_ip_address(dhcp_socket,network_interface_name);
+        if (unicast) /* get IP address of client machine */
+                get_ip_address(dhcp_socket, network_interface_name);
 
         /* send DHCPDISCOVER packet */
         send_dhcp_discover(dhcp_socket);
@@ -288,7 +278,7 @@ int main(int argc, char **argv){
         close_dhcp_socket(dhcp_socket);
 
         /* determine state/plugin output to return */
-        result=get_results();
+        result = get_results();
 
         /* free allocated memory */
         free_dhcp_offer_list();
@@ -297,34 +287,32 @@ int main(int argc, char **argv){
         return result;
 }
 
-
-
 /* determines hardware address on client machine */
-int get_hardware_address(int sock,char *interface_name){
+static int get_hardware_address(int sock, char *interface_name) {
 
 #if defined(__linux__)
         struct ifreq ifr;
 
-        strncpy((char *)&ifr.ifr_name,interface_name,sizeof(ifr.ifr_name)-1);
-        ifr.ifr_name[sizeof(ifr.ifr_name)-1]='\0';
+        strncpy((char *)&ifr.ifr_name, interface_name, sizeof(ifr.ifr_name) - 1);
+        ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 
         /* try and grab hardware address of requested interface */
-        if(ioctl(sock,SIOCGIFHWADDR,&ifr)<0){
-                printf(_("Error: Could not get hardware address of interface '%s'\n"),interface_name);
+        if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0) {
+                printf(_("Error: Could not get hardware address of interface '%s'\n"), interface_name);
                 exit(STATE_UNKNOWN);
         }
 
-        memcpy(&client_hardware_address[0],&ifr.ifr_hwaddr.sa_data,6);
+        memcpy(&client_hardware_address[0], &ifr.ifr_hwaddr.sa_data, 6);
 
 #elif defined(__bsd__)
         /* King 2004    see ACKNOWLEDGEMENTS */
 
-        size_t                  len;
-        int                     mib[6];
-        char                    *buf;
-        unsigned char           *ptr;
-        struct if_msghdr        *ifm;
-        struct sockaddr_dl      *sdl;
+        size_t len;
+        int mib[6];
+        char *buf;
+        unsigned char *ptr;
+        struct if_msghdr *ifm;
+        struct sockaddr_dl *sdl;
 
         mib[0] = CTL_NET;
         mib[1] = AF_ROUTE;
@@ -332,22 +320,22 @@ int get_hardware_address(int sock,char *interface_name){
         mib[3] = AF_LINK;
         mib[4] = NET_RT_IFLIST;
 
-        if((mib[5] = if_nametoindex(interface_name)) == 0){
+        if ((mib[5] = if_nametoindex(interface_name)) == 0) {
                 printf(_("Error: if_nametoindex error - %s.\n"), strerror(errno));
                 exit(STATE_UNKNOWN);
         }
 
-        if(sysctl(mib, 6, NULL, &len, NULL, 0) < 0){
+        if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) {
                 printf(_("Error: Couldn't get hardware address from %s. sysctl 1 error - %s.\n"), interface_name, strerror(errno));
                 exit(STATE_UNKNOWN);
         }
 
-        if((buf = malloc(len)) == NULL){
+        if ((buf = malloc(len)) == NULL) {
                 printf(_("Error: Couldn't get hardware address from interface %s. malloc error - %s.\n"), interface_name, strerror(errno));
                 exit(4);
         }
 
-        if(sysctl(mib, 6, buf, &len, NULL, 0) < 0){
+        if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
                 printf(_("Error: Couldn't get hardware address from %s. sysctl 2 error - %s.\n"), interface_name, strerror(errno));
                 exit(STATE_UNKNOWN);
         }
@@ -355,7 +343,7 @@ int get_hardware_address(int sock,char *interface_name){
         ifm = (struct if_msghdr *)buf;
         sdl = (struct sockaddr_dl *)(ifm + 1);
         ptr = (unsigned char *)LLADDR(sdl);
-        memcpy(&client_hardware_address[0], ptr, 6) ;
+        memcpy(&client_hardware_address[0], ptr, 6);
         /* King 2004 */
 
 #elif defined(__sun__) || defined(__solaris__)
@@ -368,22 +356,21 @@ int get_hardware_address(int sock,char *interface_name){
 
         /* get last number from interfacename, eg lnc0, e1000g0*/
         int i;
-        p = interface_name + strlen(interface_name) -1;
-        for(i = strlen(interface_name) -1; i > 0; p--) {
-                if(isalpha(*p))
+        p = interface_name + strlen(interface_name) - 1;
+        for (i = strlen(interface_name) - 1; i > 0; p--) {
+                if (isalpha(*p))
                         break;
         }
         p++;
-        if( p != interface_name ){
-                unit = atoi(p) ;
-                strncat(dev, interface_name, 6) ;
-        }
-        else{
+        if (p != interface_name) {
+                unit = atoi(p);
+                strncat(dev, interface_name, 6);
+        } else {
                 printf(_("Error: can't find unit number in interface_name (%s) - expecting TypeNumber eg lnc0.\n"), interface_name);
                 exit(STATE_UNKNOWN);
         }
         stat = mac_addr_dlpi(dev, unit, client_hardware_address);
-        if(stat != 0){
+        if (stat != 0) {
                 printf(_("Error: can't read MAC address from DLPI streams interface for device %s unit %d.\n"), dev, unit);
                 exit(STATE_UNKNOWN);
         }
@@ -391,11 +378,11 @@ int get_hardware_address(int sock,char *interface_name){
 #elif defined(__hpux__)
 
         long stat;
-        char dev[20] = "/dev/dlpi" ;
+        char dev[20] = "/dev/dlpi";
         int unit = 0;
 
         stat = mac_addr_dlpi(dev, unit, client_hardware_address);
-        if(stat != 0){
+        if (stat != 0) {
                 printf(_("Error: can't read MAC address from DLPI streams interface for device %s unit %d.\n"), dev, unit);
                 exit(STATE_UNKNOWN);
         }
@@ -406,68 +393,65 @@ int get_hardware_address(int sock,char *interface_name){
         exit(STATE_UNKNOWN);
 #endif
 
-        if(verbose)
+        if (verbose)
                 print_hardware_address(client_hardware_address);
 
         return OK;
 }
 
 /* determines IP address of the client interface */
-int get_ip_address(int sock,char *interface_name){
+static int get_ip_address(int sock, char *interface_name) {
 #if defined(SIOCGIFADDR)
         struct ifreq ifr;
 
-        strncpy((char *)&ifr.ifr_name,interface_name,sizeof(ifr.ifr_name)-1);
-        ifr.ifr_name[sizeof(ifr.ifr_name)-1]='\0';
+        strncpy((char *)&ifr.ifr_name, interface_name, sizeof(ifr.ifr_name) - 1);
+        ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 
-        if(ioctl(sock,SIOCGIFADDR,&ifr)<0){
-                printf(_("Error: Cannot determine IP address of interface %s\n"),
-                                interface_name);
+        if (ioctl(sock, SIOCGIFADDR, &ifr) < 0) {
+                printf(_("Error: Cannot determine IP address of interface %s\n"), interface_name);
                 exit(STATE_UNKNOWN);
         }
 
-        my_ip=((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
+        my_ip = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
 
 #else
         printf(_("Error: Cannot get interface IP address on this platform.\n"));
         exit(STATE_UNKNOWN);
 #endif
 
-        if(verbose)
-                printf(_("Pretending to be relay client %s\n"),inet_ntoa(my_ip));
+        if (verbose)
+                printf(_("Pretending to be relay client %s\n"), inet_ntoa(my_ip));
 
         return OK;
 }
 
 /* sends a DHCPDISCOVER broadcast message in an attempt to find DHCP servers */
-int send_dhcp_discover(int sock){
+static int send_dhcp_discover(int sock) {
         dhcp_packet discover_packet;
         struct sockaddr_in sockaddr_broadcast;
         unsigned short opts;
 
-
         /* clear the packet data structure */
-        bzero(&discover_packet,sizeof(discover_packet));
-
+        bzero(&discover_packet, sizeof(discover_packet));
 
         /* boot request flag (backward compatible with BOOTP servers) */
-        discover_packet.op=BOOTREQUEST;
+        discover_packet.op = BOOTREQUEST;
 
         /* hardware address type */
-        discover_packet.htype=ETHERNET_HARDWARE_ADDRESS;
+        discover_packet.htype = ETHERNET_HARDWARE_ADDRESS;
 
         /* length of our hardware address */
-        discover_packet.hlen=ETHERNET_HARDWARE_ADDRESS_LENGTH;
+        discover_packet.hlen = ETHERNET_HARDWARE_ADDRESS_LENGTH;
 
         /*
          * transaction ID is supposed to be random.
          */
-        srand(time(NULL)^getpid());
-        packet_xid=random();
-        discover_packet.xid=htonl(packet_xid);
+        srand(time(NULL) ^ getpid());
+        packet_xid = random();
+        discover_packet.xid = htonl(packet_xid);
 
         /*discover_packet.secs=htons(65535);*/
-        discover_packet.secs=0xFF;
+        discover_packet.secs = 0xFF;
 
         /*
          * server needs to know if it should broadcast or unicast its response:
@@ -476,71 +460,67 @@ int send_dhcp_discover(int sock){
         discover_packet.flags = unicast ? 0 : htons(DHCP_BROADCAST_FLAG);
 
         /* our hardware address */
-        memcpy(discover_packet.chaddr,client_hardware_address,ETHERNET_HARDWARE_ADDRESS_LENGTH);
+        memcpy(discover_packet.chaddr, client_hardware_address, ETHERNET_HARDWARE_ADDRESS_LENGTH);
 
         /* first four bytes of options field is magic cookie (as per RFC 2132) */
-        discover_packet.options[0]='\x63';
-        discover_packet.options[1]='\x82';
-        discover_packet.options[2]='\x53';
-        discover_packet.options[3]='\x63';
+        discover_packet.options[0] = '\x63';
+        discover_packet.options[1] = '\x82';
+        discover_packet.options[2] = '\x53';
+        discover_packet.options[3] = '\x63';
 
         opts = 4;
         /* DHCP message type is embedded in options field */
-        discover_packet.options[opts++]=DHCP_OPTION_MESSAGE_TYPE;    /* DHCP message type option identifier */
-        discover_packet.options[opts++]='\x01';               /* DHCP message option length in bytes */
-        discover_packet.options[opts++]=DHCPDISCOVER;
+        discover_packet.options[opts++] = DHCP_OPTION_MESSAGE_TYPE; /* DHCP message type option identifier */
+        discover_packet.options[opts++] = '\x01';                   /* DHCP message option length in bytes */
+        discover_packet.options[opts++] = DHCPDISCOVER;
 
         /* the IP address we're requesting */
-        if(request_specific_address){
-                discover_packet.options[opts++]=DHCP_OPTION_REQUESTED_ADDRESS;
-                discover_packet.options[opts++]='\x04';
-                memcpy(&discover_packet.options[opts],&requested_address,sizeof(requested_address));
+        if (request_specific_address) {
+                discover_packet.options[opts++] = DHCP_OPTION_REQUESTED_ADDRESS;
+                discover_packet.options[opts++] = '\x04';
+                memcpy(&discover_packet.options[opts], &requested_address, sizeof(requested_address));
                 opts += sizeof(requested_address);
         }
-        discover_packet.options[opts++]= (char)DHCP_OPTION_END;
+        discover_packet.options[opts++] = (char)DHCP_OPTION_END;
 
         /* unicast fields */
-        if(unicast)
+        if (unicast)
                 discover_packet.giaddr.s_addr = my_ip.s_addr;
 
         /* see RFC 1542, 4.1.1 */
         discover_packet.hops = unicast ? 1 : 0;
 
         /* send the DHCPDISCOVER packet to broadcast address */
-        sockaddr_broadcast.sin_family=AF_INET;
-        sockaddr_broadcast.sin_port=htons(DHCP_SERVER_PORT);
+        sockaddr_broadcast.sin_family = AF_INET;
+        sockaddr_broadcast.sin_port = htons(DHCP_SERVER_PORT);
         sockaddr_broadcast.sin_addr.s_addr = unicast ? dhcp_ip.s_addr : INADDR_BROADCAST;
-        bzero(&sockaddr_broadcast.sin_zero,sizeof(sockaddr_broadcast.sin_zero));
-
-
-        if(verbose){
-                printf(_("DHCPDISCOVER to %s port %d\n"),inet_ntoa(sockaddr_broadcast.sin_addr),ntohs(sockaddr_broadcast.sin_port));
-                printf("DHCPDISCOVER XID: %u (0x%X)\n",ntohl(discover_packet.xid),ntohl(discover_packet.xid));
-                printf("DHCDISCOVER ciaddr:  %s\n",inet_ntoa(discover_packet.ciaddr));
-                printf("DHCDISCOVER yiaddr:  %s\n",inet_ntoa(discover_packet.yiaddr));
-                printf("DHCDISCOVER siaddr:  %s\n",inet_ntoa(discover_packet.siaddr));
-                printf("DHCDISCOVER giaddr:  %s\n",inet_ntoa(discover_packet.giaddr));
+        bzero(&sockaddr_broadcast.sin_zero, sizeof(sockaddr_broadcast.sin_zero));
+
+        if (verbose) {
+                printf(_("DHCPDISCOVER to %s port %d\n"), inet_ntoa(sockaddr_broadcast.sin_addr), ntohs(sockaddr_broadcast.sin_port));
+                printf("DHCPDISCOVER XID: %u (0x%X)\n", ntohl(discover_packet.xid), ntohl(discover_packet.xid));
+                printf("DHCDISCOVER ciaddr:  %s\n", inet_ntoa(discover_packet.ciaddr));
+                printf("DHCDISCOVER yiaddr:  %s\n", inet_ntoa(discover_packet.yiaddr));
+                printf("DHCDISCOVER siaddr:  %s\n", inet_ntoa(discover_packet.siaddr));
+                printf("DHCDISCOVER giaddr:  %s\n", inet_ntoa(discover_packet.giaddr));
         }
 
         /* send the DHCPDISCOVER packet out */
-        send_dhcp_packet(&discover_packet,sizeof(discover_packet),sock,&sockaddr_broadcast);
+        send_dhcp_packet(&discover_packet, sizeof(discover_packet), sock, &sockaddr_broadcast);
 
-        if(verbose)
+        if (verbose)
                 printf("\n\n");
 
         return OK;
 }
 
-
-
-
 /* waits for a DHCPOFFER message from one or more DHCP servers */
-int get_dhcp_offer(int sock){
+static int get_dhcp_offer(int sock) {
         dhcp_packet offer_packet;
         struct sockaddr_in source;
         struct sockaddr_in via;
-        int result=OK;
-        int responses=0;
+        int result = OK;
+        int responses = 0;
         int x;
         time_t start_time;
         time_t current_time;
@@ -548,30 +528,29 @@ int get_dhcp_offer(int sock){
         time(&start_time);
 
         /* receive as many responses as we can */
-        for(responses=0,valid_responses=0;;){
+        for (responses = 0, valid_responses = 0;;) {
 
                 time(&current_time);
-                if((current_time-start_time)>=dhcpoffer_timeout)
+                if ((current_time - start_time) >= dhcpoffer_timeout)
                         break;
 
-                if(verbose)
+                if (verbose)
                         printf("\n\n");
 
-                bzero(&source,sizeof(source));
-                bzero(&via,sizeof(via));
-                bzero(&offer_packet,sizeof(offer_packet));
+                bzero(&source, sizeof(source));
+                bzero(&via, sizeof(via));
+                bzero(&offer_packet, sizeof(offer_packet));
 
-                result=OK;
-                result=receive_dhcp_packet(&offer_packet,sizeof(offer_packet),sock,dhcpoffer_timeout,&source);
+                result = OK;
+                result = receive_dhcp_packet(&offer_packet, sizeof(offer_packet), sock, dhcpoffer_timeout, &source);
 
-                if(result!=OK){
-                        if(verbose)
+                if (result != OK) {
+                        if (verbose)
                                 printf(_("Result=ERROR\n"));
 
                         continue;
-                }
-                else{
-                        if(verbose)
+                } else {
+                        if (verbose)
                                 printf(_("Result=OK\n"));
 
                         responses++;
@@ -579,85 +558,81 @@ int get_dhcp_offer(int sock){
 
                 /* The "source" is either a server or a relay. */
                 /* Save a copy of "source" into "via" even if it's via itself */
-                memcpy(&via,&source,sizeof(source)) ;
+                memcpy(&via, &source, sizeof(source));
 
-                if(verbose){
-                        printf(_("DHCPOFFER from IP address %s"),inet_ntoa(source.sin_addr));
-                        printf(_(" via %s\n"),inet_ntoa(via.sin_addr));
-                        printf("DHCPOFFER XID: %u (0x%X)\n",ntohl(offer_packet.xid),ntohl(offer_packet.xid));
+                if (verbose) {
+                        printf(_("DHCPOFFER from IP address %s"), inet_ntoa(source.sin_addr));
+                        printf(_(" via %s\n"), inet_ntoa(via.sin_addr));
+                        printf("DHCPOFFER XID: %u (0x%X)\n", ntohl(offer_packet.xid), ntohl(offer_packet.xid));
                 }
 
                 /* check packet xid to see if its the same as the one we used in the discover packet */
-                if(ntohl(offer_packet.xid)!=packet_xid){
-                        if(verbose)
-                                printf(_("DHCPOFFER XID (%u) did not match DHCPDISCOVER XID (%u) - ignoring packet\n"),ntohl(offer_packet.xid),packet_xid);
+                if (ntohl(offer_packet.xid) != packet_xid) {
+                        if (verbose)
+                                printf(_("DHCPOFFER XID (%u) did not match DHCPDISCOVER XID (%u) - ignoring packet\n"), ntohl(offer_packet.xid), packet_xid);
 
                         continue;
                 }
 
                 /* check hardware address */
-                result=OK;
-                if(verbose)
+                result = OK;
+                if (verbose)
                         printf("DHCPOFFER chaddr: ");
 
-                for(x=0;x<ETHERNET_HARDWARE_ADDRESS_LENGTH;x++){
-                        if(verbose)
-                                printf("%02X",(unsigned char)offer_packet.chaddr[x]);
+                for (x = 0; x < ETHERNET_HARDWARE_ADDRESS_LENGTH; x++) {
+                        if (verbose)
+                                printf("%02X", (unsigned char)offer_packet.chaddr[x]);
 
-                        if(offer_packet.chaddr[x]!=client_hardware_address[x])
-                                result=ERROR;
+                        if (offer_packet.chaddr[x] != client_hardware_address[x])
+                                result = ERROR;
                 }
-                if(verbose)
+                if (verbose)
                         printf("\n");
 
-                if(result==ERROR){
-                        if(verbose)
+                if (result == ERROR) {
+                        if (verbose)
                                 printf(_("DHCPOFFER hardware address did not match our own - ignoring packet\n"));
 
                         continue;
                 }
 
-                if(verbose){
-                        printf("DHCPOFFER ciaddr: %s\n",inet_ntoa(offer_packet.ciaddr));
-                        printf("DHCPOFFER yiaddr: %s\n",inet_ntoa(offer_packet.yiaddr));
-                        printf("DHCPOFFER siaddr: %s\n",inet_ntoa(offer_packet.siaddr));
-                        printf("DHCPOFFER giaddr: %s\n",inet_ntoa(offer_packet.giaddr));
+                if (verbose) {
+                        printf("DHCPOFFER ciaddr: %s\n", inet_ntoa(offer_packet.ciaddr));
+                        printf("DHCPOFFER yiaddr: %s\n", inet_ntoa(offer_packet.yiaddr));
+                        printf("DHCPOFFER siaddr: %s\n", inet_ntoa(offer_packet.siaddr));
+                        printf("DHCPOFFER giaddr: %s\n", inet_ntoa(offer_packet.giaddr));
                 }
 
-                add_dhcp_offer(source.sin_addr,&offer_packet);
+                add_dhcp_offer(source.sin_addr, &offer_packet);
 
                 valid_responses++;
         }
 
-        if(verbose){
-                printf(_("Total responses seen on the wire: %d\n"),responses);
-                printf(_("Valid responses for this machine: %d\n"),valid_responses);
+        if (verbose) {
+                printf(_("Total responses seen on the wire: %d\n"), responses);
+                printf(_("Valid responses for this machine: %d\n"), valid_responses);
         }
 
         return OK;
 }
 
-
-
 /* sends a DHCP packet */
-int send_dhcp_packet(void *buffer, int buffer_size, int sock, struct sockaddr_in *dest){
+static int send_dhcp_packet(void *buffer, int buffer_size, int sock, struct sockaddr_in *dest) {
         int result;
 
-        result=sendto(sock,(char *)buffer,buffer_size,0,(struct sockaddr *)dest,sizeof(*dest));
+        result = sendto(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)dest, sizeof(*dest));
 
-        if(verbose)
-                printf(_("send_dhcp_packet result: %d\n"),result);
+        if (verbose)
+                printf(_("send_dhcp_packet result: %d\n"), result);
 
-        if(result<0)
+        if (result < 0)
                 return ERROR;
 
         return OK;
 }
 
-
-
 /* receives a DHCP packet */
-int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int timeout, struct sockaddr_in *address){
+static int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int timeout, struct sockaddr_in *address) {
         struct timeval tv;
         fd_set readfds;
         fd_set oobfds;
@@ -666,44 +641,42 @@ int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int timeout, st
         struct sockaddr_in source_address;
         int nfound;
 
-
         /* wait for data to arrive (up time timeout) */
-        tv.tv_sec=timeout;
-        tv.tv_usec=0;
+        tv.tv_sec = timeout;
+        tv.tv_usec = 0;
         FD_ZERO(&readfds);
         FD_ZERO(&oobfds);
-        FD_SET(sock,&readfds);
-        FD_SET(sock,&oobfds);
-        nfound = select(sock+1,&readfds,NULL,&oobfds,&tv);
+        FD_SET(sock, &readfds);
+        FD_SET(sock, &oobfds);
+        nfound = select(sock + 1, &readfds, NULL, &oobfds, &tv);
 
         /* make sure some data has arrived */
-        if(!FD_ISSET(sock,&readfds)){
-                if(verbose)
+        if (!FD_ISSET(sock, &readfds)) {
+                if (verbose)
                         printf(_("No (more) data received (nfound: %d)\n"), nfound);
                 return ERROR;
         }
 
-        else{
-                bzero(&source_address,sizeof(source_address));
-                address_size=sizeof(source_address);
-                recv_result=recvfrom(sock,(char *)buffer,buffer_size,0,(struct sockaddr *)&source_address,&address_size);
-                if(verbose)
-                        printf("recv_result: %d\n",recv_result);
+        else {
+                bzero(&source_address, sizeof(source_address));
+                address_size = sizeof(source_address);
+                recv_result = recvfrom(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)&source_address, &address_size);
+                if (verbose)
+                        printf("recv_result: %d\n", recv_result);
 
-                if(recv_result==-1){
-                        if(verbose){
+                if (recv_result == -1) {
+                        if (verbose) {
                                 printf(_("recvfrom() failed, "));
-                                printf("errno: (%d) -> %s\n",errno,strerror(errno));
+                                printf("errno: (%d) -> %s\n", errno, strerror(errno));
                         }
                         return ERROR;
-                }
-                else{
-                        if(verbose){
-                                printf(_("receive_dhcp_packet() result: %d\n"),recv_result);
-                                printf(_("receive_dhcp_packet() source: %s\n"),inet_ntoa(source_address.sin_addr));
+                } else {
+                        if (verbose) {
+                                printf(_("receive_dhcp_packet() result: %d\n"), recv_result);
+                                printf(_("receive_dhcp_packet() source: %s\n"), inet_ntoa(source_address.sin_addr));
                         }
 
-                        memcpy(address,&source_address,sizeof(source_address));
+                        memcpy(address, &source_address, sizeof(source_address));
                         return OK;
                 }
         }
@@ -711,172 +684,166 @@ int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int timeout, st
         return OK;
 }
 
-
 /* creates a socket for DHCP communication */
-int create_dhcp_socket(void){
+static int create_dhcp_socket(void) {
         struct sockaddr_in myname;
         struct ifreq interface;
         int sock;
-        int flag=1;
+        int flag = 1;
 
         /* Set up the address we're going to bind to. */
-        bzero(&myname,sizeof(myname));
-        myname.sin_family=AF_INET;
+        bzero(&myname, sizeof(myname));
+        myname.sin_family = AF_INET;
         /* listen to DHCP server port if we're in unicast mode */
         myname.sin_port = htons(unicast ? DHCP_SERVER_PORT : DHCP_CLIENT_PORT);
         myname.sin_addr.s_addr = unicast ? my_ip.s_addr : INADDR_ANY;
-        bzero(&myname.sin_zero,sizeof(myname.sin_zero));
+        bzero(&myname.sin_zero, sizeof(myname.sin_zero));
 
         /* create a socket for DHCP communications */
-        sock=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
-        if(sock<0){
+        sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+        if (sock < 0) {
                 printf(_("Error: Could not create socket!\n"));
                 exit(STATE_UNKNOWN);
         }
 
-        if(verbose)
-                printf("DHCP socket: %d\n",sock);
+        if (verbose)
+                printf("DHCP socket: %d\n", sock);
 
         /* set the reuse address flag so we don't get errors when restarting */
-        flag=1;
-        if(setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char *)&flag,sizeof(flag))<0){
+        flag = 1;
+        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&flag, sizeof(flag)) < 0) {
                 printf(_("Error: Could not set reuse address option on DHCP socket!\n"));
                 exit(STATE_UNKNOWN);
         }
 
         /* set the broadcast option - we need this to listen to DHCP broadcast messages */
-        if(!unicast && setsockopt(sock,SOL_SOCKET,SO_BROADCAST,(char *)&flag,sizeof flag)<0){
+        if (!unicast && setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&flag, sizeof flag) < 0) {
                 printf(_("Error: Could not set broadcast option on DHCP socket!\n"));
                 exit(STATE_UNKNOWN);
         }
 
         /* bind socket to interface */
 #if defined(__linux__)
-        strncpy(interface.ifr_ifrn.ifrn_name,network_interface_name,IFNAMSIZ-1);
-        interface.ifr_ifrn.ifrn_name[IFNAMSIZ-1]='\0';
-        if(setsockopt(sock,SOL_SOCKET,SO_BINDTODEVICE,(char *)&interface,sizeof(interface))<0){
-                printf(_("Error: Could not bind socket to interface %s.  Check your privileges...\n"),network_interface_name);
+        strncpy(interface.ifr_ifrn.ifrn_name, network_interface_name, IFNAMSIZ - 1);
+        interface.ifr_ifrn.ifrn_name[IFNAMSIZ - 1] = '\0';
+        if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, (char *)&interface, sizeof(interface)) < 0) {
+                printf(_("Error: Could not bind socket to interface %s.  Check your privileges...\n"), network_interface_name);
                 exit(STATE_UNKNOWN);
         }
 
 #else
-        strncpy(interface.ifr_name,network_interface_name,IFNAMSIZ-1);
-        interface.ifr_name[IFNAMSIZ-1]='\0';
+        strncpy(interface.ifr_name, network_interface_name, IFNAMSIZ - 1);
+        interface.ifr_name[IFNAMSIZ - 1] = '\0';
 #endif
 
         /* bind the socket */
-        if(bind(sock,(struct sockaddr *)&myname,sizeof(myname))<0){
-                printf(_("Error: Could not bind to DHCP socket (port %d)!  Check your privileges...\n"),DHCP_CLIENT_PORT);
+        if (bind(sock, (struct sockaddr *)&myname, sizeof(myname)) < 0) {
+                printf(_("Error: Could not bind to DHCP socket (port %d)!  Check your privileges...\n"), DHCP_CLIENT_PORT);
                 exit(STATE_UNKNOWN);
         }
 
         return sock;
 }
 
-
 /* closes DHCP socket */
-int close_dhcp_socket(int sock){
+static int close_dhcp_socket(int sock) {
 
         close(sock);
 
         return OK;
 }
 
-
 /* adds a requested server address to list in memory */
-int add_requested_server(struct in_addr server_address){
+static int add_requested_server(struct in_addr server_address) {
         requested_server *new_server;
 
-        new_server=(requested_server *)malloc(sizeof(requested_server));
-        if(new_server==NULL)
+        new_server = (requested_server *)malloc(sizeof(requested_server));
+        if (new_server == NULL)
                 return ERROR;
 
-        new_server->server_address=server_address;
-        new_server->answered=false;
+        new_server->server_address = server_address;
+        new_server->answered = false;
 
-        new_server->next=requested_server_list;
-        requested_server_list=new_server;
+        new_server->next = requested_server_list;
+        requested_server_list = new_server;
 
         requested_servers++;
 
-        if(verbose)
-                printf(_("Requested server address: %s\n"),inet_ntoa(new_server->server_address));
+        if (verbose)
+                printf(_("Requested server address: %s\n"), inet_ntoa(new_server->server_address));
 
         return OK;
 }
 
-
-
-
 /* adds a DHCP OFFER to list in memory */
-int add_dhcp_offer(struct in_addr source,dhcp_packet *offer_packet){
+static int add_dhcp_offer(struct in_addr source, dhcp_packet *offer_packet) {
         dhcp_offer *new_offer;
         int x;
         unsigned option_type;
         unsigned option_length;
         struct in_addr serv_ident = {0};
 
-        if(offer_packet==NULL)
+        if (offer_packet == NULL)
                 return ERROR;
 
         /* process all DHCP options present in the packet */
-        for(x=4;x<MAX_DHCP_OPTIONS_LENGTH-1;){
+        for (x = 4; x < MAX_DHCP_OPTIONS_LENGTH - 1;) {
 
-                if((int)offer_packet->options[x]==-1)
+                if ((int)offer_packet->options[x] == -1)
                         break;
 
                 /* get option type */
-                option_type=offer_packet->options[x++];
+                option_type = offer_packet->options[x++];
 
                 /* get option length */
-                option_length=offer_packet->options[x++];
+                option_length = offer_packet->options[x++];
 
-                if(verbose)
-                        printf("Option: %d (0x%02X)\n",option_type,option_length);
+                if (verbose)
+                        printf("Option: %d (0x%02X)\n", option_type, option_length);
 
                 /* get option data */
-                switch(option_type){
-                        case DHCP_OPTION_LEASE_TIME:
-                                memcpy(&dhcp_lease_time, &offer_packet->options[x],sizeof(dhcp_lease_time));
-                                dhcp_lease_time = ntohl(dhcp_lease_time);
-                                break;
-                        case DHCP_OPTION_RENEWAL_TIME:
-                                memcpy(&dhcp_renewal_time, &offer_packet->options[x],sizeof(dhcp_renewal_time));
-                                dhcp_renewal_time = ntohl(dhcp_renewal_time);
-                                break;
-                        case DHCP_OPTION_REBINDING_TIME:
-                                memcpy(&dhcp_rebinding_time, &offer_packet->options[x],sizeof(dhcp_rebinding_time));
-                                dhcp_rebinding_time = ntohl(dhcp_rebinding_time);
-                                break;
-                        case DHCP_OPTION_SERVER_IDENTIFIER:
-                                memcpy(&serv_ident.s_addr, &offer_packet->options[x],sizeof(serv_ident.s_addr));
-                                break;
+                switch (option_type) {
+                case DHCP_OPTION_LEASE_TIME:
+                        memcpy(&dhcp_lease_time, &offer_packet->options[x], sizeof(dhcp_lease_time));
+                        dhcp_lease_time = ntohl(dhcp_lease_time);
+                        break;
+                case DHCP_OPTION_RENEWAL_TIME:
+                        memcpy(&dhcp_renewal_time, &offer_packet->options[x], sizeof(dhcp_renewal_time));
+                        dhcp_renewal_time = ntohl(dhcp_renewal_time);
+                        break;
+                case DHCP_OPTION_REBINDING_TIME:
+                        memcpy(&dhcp_rebinding_time, &offer_packet->options[x], sizeof(dhcp_rebinding_time));
+                        dhcp_rebinding_time = ntohl(dhcp_rebinding_time);
+                        break;
+                case DHCP_OPTION_SERVER_IDENTIFIER:
+                        memcpy(&serv_ident.s_addr, &offer_packet->options[x], sizeof(serv_ident.s_addr));
+                        break;
                 }
 
                 /* skip option data we're ignoring */
-                if(option_type==0) /* "pad" option, see RFC 2132 (3.1) */
-                        x+=1;
+                if (option_type == 0) /* "pad" option, see RFC 2132 (3.1) */
+                        x += 1;
                 else
-                        x+=option_length;
+                        x += option_length;
         }
 
-        if(verbose){
-                if(dhcp_lease_time==DHCP_INFINITE_TIME)
+        if (verbose) {
+                if (dhcp_lease_time == DHCP_INFINITE_TIME)
                         printf(_("Lease Time: Infinite\n"));
                 else
-                        printf(_("Lease Time: %lu seconds\n"),(unsigned long)dhcp_lease_time);
-                if(dhcp_renewal_time==DHCP_INFINITE_TIME)
+                        printf(_("Lease Time: %lu seconds\n"), (unsigned long)dhcp_lease_time);
+                if (dhcp_renewal_time == DHCP_INFINITE_TIME)
                         printf(_("Renewal Time: Infinite\n"));
                 else
-                        printf(_("Renewal Time: %lu seconds\n"),(unsigned long)dhcp_renewal_time);
-                if(dhcp_rebinding_time==DHCP_INFINITE_TIME)
+                        printf(_("Renewal Time: %lu seconds\n"), (unsigned long)dhcp_renewal_time);
+                if (dhcp_rebinding_time == DHCP_INFINITE_TIME)
                         printf(_("Rebinding Time: Infinite\n"));
-                printf(_("Rebinding Time: %lu seconds\n"),(unsigned long)dhcp_rebinding_time);
+                printf(_("Rebinding Time: %lu seconds\n"), (unsigned long)dhcp_rebinding_time);
         }
 
-        new_offer=(dhcp_offer *)malloc(sizeof(dhcp_offer));
+        new_offer = (dhcp_offer *)malloc(sizeof(dhcp_offer));
 
-        if(new_offer==NULL)
+        if (new_offer == NULL)
                 return ERROR;
 
         /*
@@ -891,298 +858,286 @@ int add_dhcp_offer(struct in_addr source,dhcp_packet *offer_packet){
          * DHCPOFFER from.  If 'serv_ident' isn't available for some reason, we
          * use 'source'.
          */
-        new_offer->server_address=serv_ident.s_addr?serv_ident:source;
-        new_offer->offered_address=offer_packet->yiaddr;
-        new_offer->lease_time=dhcp_lease_time;
-        new_offer->renewal_time=dhcp_renewal_time;
-        new_offer->rebinding_time=dhcp_rebinding_time;
-        new_offer->desired=false; /* exclusive mode: we'll check that in get_results */
-
-
-        if(verbose){
-                printf(_("Added offer from server @ %s"),inet_ntoa(new_offer->server_address));
-                printf(_(" of IP address %s\n"),inet_ntoa(new_offer->offered_address));
+        new_offer->server_address = serv_ident.s_addr ? serv_ident : source;
+        new_offer->offered_address = offer_packet->yiaddr;
+        new_offer->lease_time = dhcp_lease_time;
+        new_offer->renewal_time = dhcp_renewal_time;
+        new_offer->rebinding_time = dhcp_rebinding_time;
+        new_offer->desired = false; /* exclusive mode: we'll check that in get_results */
+
+        if (verbose) {
+                printf(_("Added offer from server @ %s"), inet_ntoa(new_offer->server_address));
+                printf(_(" of IP address %s\n"), inet_ntoa(new_offer->offered_address));
         }
 
         /* add new offer to head of list */
-        new_offer->next=dhcp_offer_list;
-        dhcp_offer_list=new_offer;
+        new_offer->next = dhcp_offer_list;
+        dhcp_offer_list = new_offer;
 
         return OK;
 }
 
-
 /* frees memory allocated to DHCP OFFER list */
-int free_dhcp_offer_list(void){
+static int free_dhcp_offer_list(void) {
         dhcp_offer *this_offer;
         dhcp_offer *next_offer;
 
-        for(this_offer=dhcp_offer_list;this_offer!=NULL;this_offer=next_offer){
-                next_offer=this_offer->next;
+        for (this_offer = dhcp_offer_list; this_offer != NULL; this_offer = next_offer) {
+                next_offer = this_offer->next;
                 free(this_offer);
         }
 
         return OK;
 }
 
-
 /* frees memory allocated to requested server list */
-int free_requested_server_list(void){
+static int free_requested_server_list(void) {
         requested_server *this_server;
         requested_server *next_server;
 
-        for(this_server=requested_server_list;this_server!=NULL;this_server=next_server){
-                next_server=this_server->next;
+        for (this_server = requested_server_list; this_server != NULL; this_server = next_server) {
+                next_server = this_server->next;
                 free(this_server);
         }
 
         return OK;
 }
 
-
 /* gets state and plugin output to return */
-int get_results(void){
-        dhcp_offer *temp_offer, *undesired_offer=NULL;
+static int get_results(void) {
+        dhcp_offer *temp_offer, *undesired_offer = NULL;
         requested_server *temp_server;
         int result;
-        uint32_t max_lease_time=0;
+        uint32_t max_lease_time = 0;
 
-        received_requested_address=false;
+        received_requested_address = false;
 
         /* checks responses from requested servers */
-        requested_responses=0;
-        if(requested_servers>0){
+        requested_responses = 0;
+        if (requested_servers > 0) {
 
-                for(temp_server=requested_server_list;temp_server!=NULL;temp_server=temp_server->next){
+                for (temp_server = requested_server_list; temp_server != NULL; temp_server = temp_server->next) {
 
-                        for(temp_offer=dhcp_offer_list;temp_offer!=NULL;temp_offer=temp_offer->next){
+                        for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
 
                                 /* get max lease time we were offered */
-                                if(temp_offer->lease_time>max_lease_time || temp_offer->lease_time==DHCP_INFINITE_TIME)
-                                        max_lease_time=temp_offer->lease_time;
+                                if (temp_offer->lease_time > max_lease_time || temp_offer->lease_time == DHCP_INFINITE_TIME)
+                                        max_lease_time = temp_offer->lease_time;
 
                                 /* see if we got the address we requested */
-                                if(!memcmp(&requested_address,&temp_offer->offered_address,sizeof(requested_address)))
-                                        received_requested_address=true;
+                                if (!memcmp(&requested_address, &temp_offer->offered_address, sizeof(requested_address)))
+                                        received_requested_address = true;
 
                                 /* see if the servers we wanted a response from talked to us or not */
-                                if(!memcmp(&temp_offer->server_address,&temp_server->server_address,sizeof(temp_server->server_address))){
-                                        if(verbose){
-                                                printf(_("DHCP Server Match: Offerer=%s"),inet_ntoa(temp_offer->server_address));
-                                                printf(_(" Requested=%s"),inet_ntoa(temp_server->server_address));
-                                                if(temp_server->answered)
+                                if (!memcmp(&temp_offer->server_address, &temp_server->server_address, sizeof(temp_server->server_address))) {
+                                        if (verbose) {
+                                                printf(_("DHCP Server Match: Offerer=%s"), inet_ntoa(temp_offer->server_address));
+                                                printf(_(" Requested=%s"), inet_ntoa(temp_server->server_address));
+                                                if (temp_server->answered)
                                                         printf(_(" (duplicate)"));
                                                 printf(_("\n"));
                                         }
-                                        if(!temp_server->answered){
+                                        if (!temp_server->answered) {
                                                 requested_responses++;
-                                                temp_server->answered=true;
-                                                temp_offer->desired=true;
+                                                temp_server->answered = true;
+                                                temp_offer->desired = true;
                                         }
                                 }
                         }
                 }
 
                 /* exclusive mode: check for undesired offers */
-                for(temp_offer=dhcp_offer_list;temp_offer!=NULL;temp_offer=temp_offer->next) {
+                for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
                         if (!temp_offer->desired) {
-                                undesired_offer=temp_offer; /* Checks only for the first undesired offer */
-                                break; /* no further checks needed */
+                                undesired_offer = temp_offer; /* Checks only for the first undesired offer */
+                                break;                        /* no further checks needed */
                         }
                 }
         }
 
         /* else check and see if we got our requested address from any server */
-        else{
+        else {
 
-                for(temp_offer=dhcp_offer_list;temp_offer!=NULL;temp_offer=temp_offer->next){
+                for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
 
                         /* get max lease time we were offered */
-                        if(temp_offer->lease_time>max_lease_time || temp_offer->lease_time==DHCP_INFINITE_TIME)
-                                max_lease_time=temp_offer->lease_time;
+                        if (temp_offer->lease_time > max_lease_time || temp_offer->lease_time == DHCP_INFINITE_TIME)
+                                max_lease_time = temp_offer->lease_time;
 
                         /* see if we got the address we requested */
-                        if(!memcmp(&requested_address,&temp_offer->offered_address,sizeof(requested_address)))
-                                received_requested_address=true;
+                        if (!memcmp(&requested_address, &temp_offer->offered_address, sizeof(requested_address)))
+                                received_requested_address = true;
                 }
         }
 
-        result=STATE_OK;
-        if(valid_responses==0)
-                result=STATE_CRITICAL;
-        else if(requested_servers>0 && requested_responses==0)
-                result=STATE_CRITICAL;
-        else if(requested_responses<requested_servers)
-                result=STATE_WARNING;
-        else if(request_specific_address && !received_requested_address)
-                result=STATE_WARNING;
+        result = STATE_OK;
+        if (valid_responses == 0)
+                result = STATE_CRITICAL;
+        else if (requested_servers > 0 && requested_responses == 0)
+                result = STATE_CRITICAL;
+        else if (requested_responses < requested_servers)
+                result = STATE_WARNING;
+        else if (request_specific_address && !received_requested_address)
+                result = STATE_WARNING;
 
-        if(exclusive && undesired_offer)
-                result=STATE_CRITICAL;
+        if (exclusive && undesired_offer)
+                result = STATE_CRITICAL;
 
-        if(result==0)               /* garrett honeycutt 2005 */
+        if (result == 0) /* garrett honeycutt 2005 */
                 printf("OK: ");
-        else if(result==1)
+        else if (result == 1)
                 printf("WARNING: ");
-        else if(result==2)
+        else if (result == 2)
                 printf("CRITICAL: ");
-        else if(result==3)
+        else if (result == 3)
                 printf("UNKNOWN: ");
 
         /* we didn't receive any DHCPOFFERs */
-        if(dhcp_offer_list==NULL){
+        if (dhcp_offer_list == NULL) {
                 printf(_("No DHCPOFFERs were received.\n"));
                 return result;
         }
 
-        printf(_("Received %d DHCPOFFER(s)"),valid_responses);
-
+        printf(_("Received %d DHCPOFFER(s)"), valid_responses);
 
-        if(exclusive && undesired_offer){
-                printf(_(", Rogue DHCP Server detected! Server %s"),inet_ntoa(undesired_offer->server_address));
-                printf(_(" offered %s \n"),inet_ntoa(undesired_offer->offered_address));
+        if (exclusive && undesired_offer) {
+                printf(_(", Rogue DHCP Server detected! Server %s"), inet_ntoa(undesired_offer->server_address));
+                printf(_(" offered %s \n"), inet_ntoa(undesired_offer->offered_address));
                 return result;
         }
 
-        if(requested_servers>0)
-                printf(_(", %s%d of %d requested servers responded"),((requested_responses<requested_servers) && requested_responses>0)?"only ":"",requested_responses,requested_servers);
+        if (requested_servers > 0)
+                printf(_(", %s%d of %d requested servers responded"), ((requested_responses < requested_servers) && requested_responses > 0) ? "only " : "", requested_responses,
+                           requested_servers);
 
-        if(request_specific_address)
-                printf(_(", requested address (%s) was %soffered"),inet_ntoa(requested_address),(received_requested_address)?"":_("not "));
+        if (request_specific_address)
+                printf(_(", requested address (%s) was %soffered"), inet_ntoa(requested_address), (received_requested_address) ? "" : _("not "));
 
         printf(_(", max lease time = "));
-        if(max_lease_time==DHCP_INFINITE_TIME)
+        if (max_lease_time == DHCP_INFINITE_TIME)
                 printf(_("Infinity"));
         else
-                printf("%lu sec",(unsigned long)max_lease_time);
+                printf("%lu sec", (unsigned long)max_lease_time);
 
         printf(".\n");
 
         return result;
 }
 
-
 /* process command-line arguments */
-int process_arguments(int argc, char **argv){
-        if(argc<1)
+static int process_arguments(int argc, char **argv) {
+        if (argc < 1)
                 return ERROR;
 
-        call_getopt(argc,argv);
+        call_getopt(argc, argv);
         return validate_arguments(argc);
 }
 
-
-
-int call_getopt(int argc, char **argv){
+static int call_getopt(int argc, char **argv) {
         extern int optind;
         int option_index = 0;
-        static struct option long_options[] =
-        {
-                {"serverip",       required_argument,0,'s'},
-                {"requestedip",    required_argument,0,'r'},
-                {"timeout",        required_argument,0,'t'},
-                {"interface",      required_argument,0,'i'},
-                {"mac",            required_argument,0,'m'},
-                {"unicast",        no_argument,      0,'u'},
-                {"exclusive",      no_argument,      0,'x'},
-                {"verbose",        no_argument,      0,'v'},
-                {"version",        no_argument,      0,'V'},
-                {"help",           no_argument,      0,'h'},
-                {0,0,0,0}
-        };
-
-        int c=0;
-        while(true){
-                c=getopt_long(argc,argv,"+hVvxt:s:r:t:i:m:u",long_options,&option_index);
-
-                if(c==-1||c==EOF||c==1)
+        static struct option long_options[] = {{"serverip", required_argument, 0, 's'},
+                                                                                   {"requestedip", required_argument, 0, 'r'},
+                                                                                   {"timeout", required_argument, 0, 't'},
+                                                                                   {"interface", required_argument, 0, 'i'},
+                                                                                   {"mac", required_argument, 0, 'm'},
+                                                                                   {"unicast", no_argument, 0, 'u'},
+                                                                                   {"exclusive", no_argument, 0, 'x'},
+                                                                                   {"verbose", no_argument, 0, 'v'},
+                                                                                   {"version", no_argument, 0, 'V'},
+                                                                                   {"help", no_argument, 0, 'h'},
+                                                                                   {0, 0, 0, 0}};
+
+        int c = 0;
+        while (true) {
+                c = getopt_long(argc, argv, "+hVvxt:s:r:t:i:m:u", long_options, &option_index);
+
+                if (c == -1 || c == EOF || c == 1)
                         break;
 
-                switch(c){
-
-                        case 's': /* DHCP server address */
-                                resolve_host(optarg,&dhcp_ip);
-                                add_requested_server(dhcp_ip);
-                                break;
+                switch (c) {
 
-                        case 'r': /* address we are requested from DHCP servers */
-                                resolve_host(optarg,&requested_address);
-                                request_specific_address=true;
-                                break;
+                case 's': /* DHCP server address */
+                        resolve_host(optarg, &dhcp_ip);
+                        add_requested_server(dhcp_ip);
+                        break;
 
-                        case 't': /* timeout */
+                case 'r': /* address we are requested from DHCP servers */
+                        resolve_host(optarg, &requested_address);
+                        request_specific_address = true;
+                        break;
 
-                                /*
-                                         if(is_intnonneg(optarg))
-                                         */
-                                if(atoi(optarg)>0)
-                                        dhcpoffer_timeout=atoi(optarg);
-                                /*
-                                         else
-                                         usage("Time interval must be a nonnegative integer\n");
-                                         */
-                                break;
+                case 't': /* timeout */
+
+                        /*
+                                 if(is_intnonneg(optarg))
+                                 */
+                        if (atoi(optarg) > 0)
+                                dhcpoffer_timeout = atoi(optarg);
+                        /*
+                                 else
+                                 usage("Time interval must be a nonnegative integer\n");
+                                 */
+                        break;
 
-                        case 'm': /* MAC address */
+                case 'm': /* MAC address */
 
-                                if((user_specified_mac=mac_aton(optarg)) == NULL)
-                                        usage("Cannot parse MAC address.\n");
-                                if(verbose)
-                                        print_hardware_address(user_specified_mac);
+                        if ((user_specified_mac = mac_aton(optarg)) == NULL)
+                                usage("Cannot parse MAC address.\n");
+                        if (verbose)
+                                print_hardware_address(user_specified_mac);
 
-                                break;
+                        break;
 
-                        case 'i': /* interface name */
+                case 'i': /* interface name */
 
-                                strncpy(network_interface_name,optarg,sizeof(network_interface_name)-1);
-                                network_interface_name[sizeof(network_interface_name)-1]='\x0';
+                        strncpy(network_interface_name, optarg, sizeof(network_interface_name) - 1);
+                        network_interface_name[sizeof(network_interface_name) - 1] = '\x0';
 
-                                break;
+                        break;
 
-                        case 'u': /* unicast testing */
-                                unicast=true;
-                                break;
-                        case 'x': /* exclusive testing aka "rogue DHCP server detection" */
-                                exclusive=true;
-                                break;
+                case 'u': /* unicast testing */
+                        unicast = true;
+                        break;
+                case 'x': /* exclusive testing aka "rogue DHCP server detection" */
+                        exclusive = true;
+                        break;
 
-                        case 'V': /* version */
-                                print_revision(progname, NP_VERSION);
-                                exit(STATE_UNKNOWN);
+                case 'V': /* version */
+                        print_revision(progname, NP_VERSION);
+                        exit(STATE_UNKNOWN);
 
-                        case 'h': /* help */
-                                print_help();
-                                exit(STATE_UNKNOWN);
+                case 'h': /* help */
+                        print_help();
+                        exit(STATE_UNKNOWN);
 
-                        case 'v': /* verbose */
-                                verbose=1;
-                                break;
-                        case '?': /* help */
-                                usage5 ();
-                                break;
+                case 'v': /* verbose */
+                        verbose = 1;
+                        break;
+                case '?': /* help */
+                        usage5();
+                        break;
 
-                        default:
-                                break;
+                default:
+                        break;
                 }
         }
         return optind;
 }
 
+static int validate_arguments(int argc) {
 
-int validate_arguments(int argc){
-
-        if(argc - optind > 0)
+        if (argc - optind > 0)
                 usage(_("Got unexpected non-option argument"));
 
         return OK;
 }
 
-
 #if defined(__sun__) || defined(__solaris__) || defined(__hpux__)
 /* Kompf 2000-2003      see ACKNOWLEDGEMENTS */
 
 /* get a message from a stream; return type of message */
-static int get_msg(int fd){
+static int get_msg(int fd) {
         int flags = 0;
         int res, ret;
         ctl_area[0] = 0;
@@ -1190,30 +1145,29 @@ static int get_msg(int fd){
         ret = 0;
         res = getmsg(fd, &ctl, &dat, &flags);
 
-        if(res < 0){
-                if(errno == EINTR){
-                        return(GOT_INTR);
-                }
-                else{
+        if (res < 0) {
+                if (errno == EINTR) {
+                        return (GOT_INTR);
+                } else {
                         printf("%s\n", "get_msg FAILED.");
-                        return(GOT_ERR);
+                        return (GOT_ERR);
                 }
         }
-        if(ctl.len > 0){
+        if (ctl.len > 0) {
                 ret |= GOT_CTRL;
         }
-        if(dat.len > 0){
+        if (dat.len > 0) {
                 ret |= GOT_DATA;
         }
 
-        return(ret);
+        return (ret);
 }
 
 /* verify that dl_primitive in ctl_area = prim */
-static int check_ctrl(int prim){
+static int check_ctrl(int prim) {
         dl_error_ack_t *err_ack = (dl_error_ack_t *)ctl_area;
 
-        if(err_ack->dl_primitive != prim){
+        if (err_ack->dl_primitive != prim) {
                 printf(_("Error: DLPI stream API failed to get MAC in check_ctrl: %s.\n"), strerror(errno));
                 exit(STATE_UNKNOWN);
         }
@@ -1222,35 +1176,35 @@ static int check_ctrl(int prim){
 }
 
 /* put a control message on a stream */
-static int put_ctrl(int fd, int len, int pri){
+static int put_ctrl(int fd, int len, int pri) {
 
         ctl.len = len;
-        if(putmsg(fd, &ctl, 0, pri) < 0){
+        if (putmsg(fd, &ctl, 0, pri) < 0) {
                 printf(_("Error: DLPI stream API failed to get MAC in put_ctrl/putmsg(): %s.\n"), strerror(errno));
                 exit(STATE_UNKNOWN);
         }
 
-        return  0;
+        return 0;
 }
 
 /* put a control + data message on a stream */
-static int put_both(int fd, int clen, int dlen, int pri){
+static int put_both(int fd, int clen, int dlen, int pri) {
 
         ctl.len = clen;
         dat.len = dlen;
-        if(putmsg(fd, &ctl, &dat, pri) < 0){
+        if (putmsg(fd, &ctl, &dat, pri) < 0) {
                 printf(_("Error: DLPI stream API failed to get MAC in put_both/putmsg().\n"), strerror(errno));
                 exit(STATE_UNKNOWN);
         }
 
-        return  0;
+        return 0;
 }
 
 /* open file descriptor and attach */
-static int dl_open(const char *dev, int unit, int *fd){
+static int dl_open(const char *dev, int unit, int *fd) {
         dl_attach_req_t *attach_req = (dl_attach_req_t *)ctl_area;
 
-        if((*fd = open(dev, O_RDWR)) == -1){
+        if ((*fd = open(dev, O_RDWR)) == -1) {
                 printf(_("Error: DLPI stream API failed to get MAC in dl_attach_req/open(%s..): %s.\n"), dev, strerror(errno));
                 exit(STATE_UNKNOWN);
         }
@@ -1262,7 +1216,7 @@ static int dl_open(const char *dev, int unit, int *fd){
 }
 
 /* send DL_BIND_REQ */
-static int dl_bind(int fd, int sap, u_char *addr){
+static int dl_bind(int fd, int sap, u_char *addr) {
         dl_bind_req_t *bind_req = (dl_bind_req_t *)ctl_area;
         dl_bind_ack_t *bind_ack = (dl_bind_ack_t *)ctl_area;
 
@@ -1274,12 +1228,11 @@ static int dl_bind(int fd, int sap, u_char *addr){
         bind_req->dl_xidtest_flg = 0;
         put_ctrl(fd, sizeof(dl_bind_req_t), 0);
         get_msg(fd);
-        if (GOT_ERR == check_ctrl(DL_BIND_ACK)){
+        if (GOT_ERR == check_ctrl(DL_BIND_ACK)) {
                 printf(_("Error: DLPI stream API failed to get MAC in dl_bind/check_ctrl(): %s.\n"), strerror(errno));
                 exit(STATE_UNKNOWN);
         }
-        bcopy((u_char *)bind_ack + bind_ack->dl_addr_offset, addr,
-                        bind_ack->dl_addr_length);
+        bcopy((u_char *)bind_ack + bind_ack->dl_addr_offset, addr, bind_ack->dl_addr_length);
 
         return 0;
 }
@@ -1296,13 +1249,13 @@ static int dl_bind(int fd, int sap, u_char *addr){
  *
  ***********************************************************************/
 
-long mac_addr_dlpi( const char *dev, int unit, u_char  *addr){
+static long mac_addr_dlpi(const char *dev, int unit, u_char *addr) {
         int fd;
         u_char mac_addr[25];
 
-        if(GOT_ERR != dl_open(dev, unit, &fd)){
-                if(GOT_ERR != dl_bind(fd, INSAP, mac_addr)){
-                        bcopy( mac_addr, addr, 6);
+        if (GOT_ERR != dl_open(dev, unit, &fd)) {
+                if (GOT_ERR != dl_bind(fd, INSAP, mac_addr)) {
+                        bcopy(mac_addr, addr, 6);
                         return 0;
                 }
         }
@@ -1314,99 +1267,93 @@ long mac_addr_dlpi( const char *dev, int unit, u_char  *addr){
 /* Kompf 2000-2003 */
 #endif
 
-
 /* resolve host name or die (TODO: move this to netutils.c!) */
-void resolve_host(const char *in,struct in_addr *out){
+static void resolve_host(const char *in, struct in_addr *out) {
         struct addrinfo hints, *ai;
 
-        memset(&hints,0,sizeof(hints));
-        hints.ai_family=PF_INET;
-        if (getaddrinfo(in,NULL,&hints,&ai) != 0)
-                usage_va(_("Invalid hostname/address - %s"),optarg);
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = PF_INET;
+        if (getaddrinfo(in, NULL, &hints, &ai) != 0)
+                usage_va(_("Invalid hostname/address - %s"), optarg);
 
-        memcpy(out,&((struct sockaddr_in *)ai->ai_addr)->sin_addr,sizeof(*out));
+        memcpy(out, &((struct sockaddr_in *)ai->ai_addr)->sin_addr, sizeof(*out));
         freeaddrinfo(ai);
 }
 
-
 /* parse MAC address string, return 6 bytes (unterminated) or NULL */
-unsigned char *mac_aton(const char *string){
+static unsigned char *mac_aton(const char *string) {
         static unsigned char result[6];
         char tmp[3];
         unsigned i, j;
 
-        for(i=0, j=0; string[i] != '\0' && j < sizeof(result); i++){
+        for (i = 0, j = 0; string[i] != '\0' && j < sizeof(result); i++) {
                 /* ignore ':' and any other non-hex character */
-                if(!isxdigit(string[i]) || !isxdigit(string[i+1]))
+                if (!isxdigit(string[i]) || !isxdigit(string[i + 1]))
                         continue;
-                tmp[0]=string[i];
-                tmp[1]=string[i+1];
-                tmp[2]='\0';
-                result[j]=strtol(tmp,(char **)NULL,16);
+                tmp[0] = string[i];
+                tmp[1] = string[i + 1];
+                tmp[2] = '\0';
+                result[j] = strtol(tmp, (char **)NULL, 16);
                 i++;
                 j++;
         }
 
-        return (j==6) ? result : NULL;
+        return (j == 6) ? result : NULL;
 }
 
-
-void print_hardware_address(const unsigned char *address){
+static void print_hardware_address(const unsigned char *address) {
         int i;
 
         printf(_("Hardware address: "));
-        for (i=0; i<5; i++)
+        for (i = 0; i < 5; i++)
                 printf("%2.2x:", address[i]);
         printf("%2.2x", address[i]);
         putchar('\n');
 }
 
-
 /* print usage help */
-void print_help(void){
+static void print_help(void) {
 
         print_revision(progname, NP_VERSION);
 
         printf("Copyright (c) 2001-2004 Ethan Galstad (nagios@nagios.org)\n");
-        printf (COPYRIGHT, copyright, email);
+        printf(COPYRIGHT, copyright, email);
 
         printf("%s\n", _("This plugin tests the availability of DHCP servers on a network."));
 
-        printf ("\n\n");
+        printf("\n\n");
 
         print_usage();
 
-        printf (UT_HELP_VRSN);
-        printf (UT_EXTRA_OPTS);
-
-        printf (UT_VERBOSE);
-
-        printf (" %s\n", "-s, --serverip=IPADDRESS");
-        printf ("    %s\n", _("IP address of DHCP server that we must hear from"));
-        printf (" %s\n", "-r, --requestedip=IPADDRESS");
-        printf ("    %s\n", _("IP address that should be offered by at least one DHCP server"));
-        printf (" %s\n", "-t, --timeout=INTEGER");
-        printf ("    %s\n", _("Seconds to wait for DHCPOFFER before timeout occurs"));
-        printf (" %s\n", "-i, --interface=STRING");
-        printf ("    %s\n", _("Interface to to use for listening (i.e. eth0)"));
-        printf (" %s\n", "-m, --mac=STRING");
-        printf ("    %s\n", _("MAC address to use in the DHCP request"));
-        printf (" %s\n", "-u, --unicast");
-        printf ("    %s\n", _("Unicast testing: mimic a DHCP relay, requires -s"));
-        printf (" %s\n", "-x, --exclusive");
-        printf ("    %s\n", _("Only requested DHCP server may response (rogue DHCP server detection), requires -s"));
-
-        printf (UT_SUPPORT);
+        printf(UT_HELP_VRSN);
+        printf(UT_EXTRA_OPTS);
+
+        printf(UT_VERBOSE);
+
+        printf(" %s\n", "-s, --serverip=IPADDRESS");
+        printf("    %s\n", _("IP address of DHCP server that we must hear from"));
+        printf(" %s\n", "-r, --requestedip=IPADDRESS");
+        printf("    %s\n", _("IP address that should be offered by at least one DHCP server"));
+        printf(" %s\n", "-t, --timeout=INTEGER");
+        printf("    %s\n", _("Seconds to wait for DHCPOFFER before timeout occurs"));
+        printf(" %s\n", "-i, --interface=STRING");
+        printf("    %s\n", _("Interface to to use for listening (i.e. eth0)"));
+        printf(" %s\n", "-m, --mac=STRING");
+        printf("    %s\n", _("MAC address to use in the DHCP request"));
+        printf(" %s\n", "-u, --unicast");
+        printf("    %s\n", _("Unicast testing: mimic a DHCP relay, requires -s"));
+        printf(" %s\n", "-x, --exclusive");
+        printf("    %s\n", _("Only requested DHCP server may response (rogue DHCP server detection), requires -s"));
+
+        printf(UT_SUPPORT);
         return;
 }
 
+void print_usage(void) {
 
-void
-print_usage(void){
-
-        printf ("%s\n", _("Usage:"));
-        printf (" %s [-v] [-u] [-x] [-s serverip] [-r requestedip] [-t timeout]\n",progname);
-        printf ("                  [-i interface] [-m mac]\n");
+        printf("%s\n", _("Usage:"));
+        printf(" %s [-v] [-u] [-x] [-s serverip] [-r requestedip] [-t timeout]\n", progname);
+        printf("                  [-i interface] [-m mac]\n");
 
         return;
 }
diff --git a/plugins-root/check_icmp.c b/plugins-root/check_icmp.c
index f788d42..960ab8f 100644
--- a/plugins-root/check_icmp.c
+++ b/plugins-root/check_icmp.c
@@ -1,45 +1,45 @@
 /*****************************************************************************
-*
-* Monitoring check_icmp plugin
-*
-* License: GPL
-* Copyright (c) 2005-2008 Monitoring Plugins Development Team
-* Original Author : Andreas Ericsson <ae@op5.se>
-*
-* Description:
-*
-* This file contains the check_icmp plugin
-*
-* Relevant RFC's: 792 (ICMP), 791 (IP)
-*
-* This program was modeled somewhat after the check_icmp program,
-* which was in turn a hack of fping (www.fping.org) but has been
-* completely rewritten since to generate higher precision rta values,
-* and support several different modes as well as setting ttl to control.
-* redundant routes. The only remainders of fping is currently a few
-* function names.
-*
-*
-* 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_icmp plugin
+ *
+ * License: GPL
+ * Copyright (c) 2005-2024 Monitoring Plugins Development Team
+ * Original Author : Andreas Ericsson <ae@op5.se>
+ *
+ * Description:
+ *
+ * This file contains the check_icmp plugin
+ *
+ * Relevant RFC's: 792 (ICMP), 791 (IP)
+ *
+ * This program was modeled somewhat after the check_icmp program,
+ * which was in turn a hack of fping (www.fping.org) but has been
+ * completely rewritten since to generate higher precision rta values,
+ * and support several different modes as well as setting ttl to control.
+ * redundant routes. The only remainders of fping is currently a few
+ * function names.
+ *
+ *
+ * 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/>.
+ *
+ *
+ *****************************************************************************/
 
 /* progname may change */
 /* char *progname = "check_icmp"; */
 char *progname;
-const char *copyright = "2005-2008";
+const char *copyright = "2005-2024";
 const char *email = "devel@monitoring-plugins.org";
 
 /** Monitoring Plugins basic includes */
@@ -48,7 +48,7 @@ const char *email = "devel@monitoring-plugins.org";
 #include "utils.h"
 
 #if HAVE_SYS_SOCKIO_H
-#include <sys/sockio.h>
+#       include <sys/sockio.h>
 #endif
 
 #include <sys/time.h>
@@ -65,84 +65,83 @@ const char *email = "devel@monitoring-plugins.org";
 #include <netinet/icmp6.h>
 #include <arpa/inet.h>
 
-
 /** sometimes undefined system macros (quite a few, actually) **/
 #ifndef MAXTTL
-# define MAXTTL 255
+#       define MAXTTL 255
 #endif
 #ifndef INADDR_NONE
-# define INADDR_NONE (in_addr_t)(-1)
+#       define INADDR_NONE (in_addr_t)(-1)
 #endif
 
 #ifndef SOL_IP
-#define SOL_IP 0
+#       define SOL_IP 0
 #endif
 
 /* we bundle these in one #ifndef, since they're all from BSD
  * Put individual #ifndef's around those that bother you */
 #ifndef ICMP_UNREACH_NET_UNKNOWN
-# define ICMP_UNREACH_NET_UNKNOWN 6
-# define ICMP_UNREACH_HOST_UNKNOWN 7
-# define ICMP_UNREACH_ISOLATED 8
-# define ICMP_UNREACH_NET_PROHIB 9
-# define ICMP_UNREACH_HOST_PROHIB 10
-# define ICMP_UNREACH_TOSNET 11
-# define ICMP_UNREACH_TOSHOST 12
+#       define ICMP_UNREACH_NET_UNKNOWN  6
+#       define ICMP_UNREACH_HOST_UNKNOWN 7
+#       define ICMP_UNREACH_ISOLATED     8
+#       define ICMP_UNREACH_NET_PROHIB   9
+#       define ICMP_UNREACH_HOST_PROHIB  10
+#       define ICMP_UNREACH_TOSNET       11
+#       define ICMP_UNREACH_TOSHOST      12
 #endif
 /* tru64 has the ones above, but not these */
 #ifndef ICMP_UNREACH_FILTER_PROHIB
-# define ICMP_UNREACH_FILTER_PROHIB 13
-# define ICMP_UNREACH_HOST_PRECEDENCE 14
-# define ICMP_UNREACH_PRECEDENCE_CUTOFF 15
+#       define ICMP_UNREACH_FILTER_PROHIB     13
+#       define ICMP_UNREACH_HOST_PRECEDENCE   14
+#       define ICMP_UNREACH_PRECEDENCE_CUTOFF 15
 #endif
 
-typedef unsigned short range_t;  /* type for get_range() -- unimplemented */
+typedef unsigned short range_t; /* type for get_range() -- unimplemented */
 
 typedef struct rta_host {
-        unsigned short id;           /* id in **table, and icmp pkts */
-        char *name;                  /* arg used for adding this host */
-        char *msg;                   /* icmp error message, if any */
-        struct sockaddr_storage saddr_in;     /* the address of this host */
-        struct sockaddr_storage error_addr;   /* stores address of error replies */
-        unsigned long long time_waited; /* total time waited, in usecs */
+        unsigned short id;                            /* id in **table, and icmp pkts */
+        char *name;                                   /* arg used for adding this host */
+        char *msg;                                    /* icmp error message, if any */
+        struct sockaddr_storage saddr_in;             /* the address of this host */
+        struct sockaddr_storage error_addr;           /* stores address of error replies */
+        unsigned long long time_waited;               /* total time waited, in usecs */
         unsigned int icmp_sent, icmp_recv, icmp_lost; /* counters */
-        unsigned char icmp_type, icmp_code; /* type and code from errors */
-        unsigned short flags;        /* control/status flags */
-        double rta;                  /* measured RTA */
-        int rta_status;              // check result for RTA checks
-        double rtmax;                /* max rtt */
-        double rtmin;                /* min rtt */
-        double jitter;               /* measured jitter */
-        int jitter_status;           // check result for Jitter checks
-        double jitter_max;           /* jitter rtt maximum */
-        double jitter_min;           /* jitter rtt minimum */
+        unsigned char icmp_type, icmp_code;           /* type and code from errors */
+        unsigned short flags;                         /* control/status flags */
+        double rta;                                   /* measured RTA */
+        int rta_status;                               // check result for RTA checks
+        double rtmax;                                 /* max rtt */
+        double rtmin;                                 /* min rtt */
+        double jitter;                                /* measured jitter */
+        int jitter_status;                            // check result for Jitter checks
+        double jitter_max;                            /* jitter rtt maximum */
+        double jitter_min;                            /* jitter rtt minimum */
         double EffectiveLatency;
-        double mos;                  /* Mean opnion score */
-        int mos_status;              // check result for MOS checks
-        double  score;               /* score */
-        int score_status;            // check result for score checks
+        double mos;       /* Mean opnion score */
+        int mos_status;   // check result for MOS checks
+        double score;     /* score */
+        int score_status; // check result for score checks
         u_int last_tdiff;
-        u_int last_icmp_seq;         /* Last ICMP_SEQ to check out of order pkts */
-        unsigned char pl;            /* measured packet loss */
-        int pl_status;               // check result for packet loss checks
-        struct rta_host *next;       /* linked list */
-        int order_status;            // check result for packet order checks
+        u_int last_icmp_seq;   /* Last ICMP_SEQ to check out of order pkts */
+        unsigned char pl;      /* measured packet loss */
+        int pl_status;         // check result for packet loss checks
+        struct rta_host *next; /* linked list */
+        int order_status;      // check result for packet order checks
 } rta_host;
 
-#define FLAG_LOST_CAUSE 0x01  /* decidedly dead target. */
+#define FLAG_LOST_CAUSE 0x01 /* decidedly dead target. */
 
 /* threshold structure. all values are maximum allowed, exclusive */
 typedef struct threshold {
-        unsigned char pl;                       /* max allowed packet loss in percent */
-        unsigned int rta;                       /* roundtrip time average, microseconds */
-        double jitter;  /* jitter time average, microseconds */
-        double mos;                     /* MOS */
-        double score;           /* Score */
+        unsigned char pl; /* max allowed packet loss in percent */
+        unsigned int rta; /* roundtrip time average, microseconds */
+        double jitter;    /* jitter time average, microseconds */
+        double mos;       /* MOS */
+        double score;     /* Score */
 } threshold;
 
 /* the data structure */
 typedef struct icmp_ping_data {
-        struct timeval stime;   /* timestamp (saved in protocol struct as well) */
+        struct timeval stime; /* timestamp (saved in protocol struct as well) */
         unsigned short ping_id;
 } icmp_ping_data;
 
@@ -171,10 +170,10 @@ typedef union icmp_packet {
  * MODE_ICMP: implement something similar to check_icmp (MODE_RTA without
  *            tcp and udp args does this)
  */
-#define MODE_RTA 0
+#define MODE_RTA       0
 #define MODE_HOSTCHECK 1
-#define MODE_ALL 2
-#define MODE_ICMP 3
+#define MODE_ALL       2
+#define MODE_ICMP      3
 
 enum enum_threshold_mode {
         const_rta_mode,
@@ -189,30 +188,30 @@ typedef enum enum_threshold_mode threshold_mode;
 /* the different ping types we can do
  * TODO: investigate ARP ping as well */
 #define HAVE_ICMP 1
-#define HAVE_UDP 2
-#define HAVE_TCP 4
-#define HAVE_ARP 8
-
-#define MIN_PING_DATA_SIZE sizeof(struct icmp_ping_data)
-#define MAX_IP_PKT_SIZE 65536   /* (theoretical) max IP packet size */
-#define IP_HDR_SIZE 20
-#define MAX_PING_DATA (MAX_IP_PKT_SIZE - IP_HDR_SIZE - ICMP_MINLEN)
+#define HAVE_UDP  2
+#define HAVE_TCP  4
+#define HAVE_ARP  8
+
+#define MIN_PING_DATA_SIZE     sizeof(struct icmp_ping_data)
+#define MAX_IP_PKT_SIZE        65536 /* (theoretical) max IP packet size */
+#define IP_HDR_SIZE            20
+#define MAX_PING_DATA          (MAX_IP_PKT_SIZE - IP_HDR_SIZE - ICMP_MINLEN)
 #define DEFAULT_PING_DATA_SIZE (MIN_PING_DATA_SIZE + 44)
 
 /* various target states */
-#define TSTATE_INACTIVE 0x01    /* don't ping this host anymore */
-#define TSTATE_WAITING 0x02             /* unanswered packets on the wire */
-#define TSTATE_ALIVE 0x04       /* target is alive (has answered something) */
-#define TSTATE_UNREACH 0x08
+#define TSTATE_INACTIVE 0x01 /* don't ping this host anymore */
+#define TSTATE_WAITING  0x02 /* unanswered packets on the wire */
+#define TSTATE_ALIVE    0x04 /* target is alive (has answered something) */
+#define TSTATE_UNREACH  0x08
 
 /** prototypes **/
-void print_help (void);
-void print_usage (void);
+void print_help(void);
+void print_usage(void);
 static u_int get_timevar(const char *);
 static u_int get_timevaldiff(struct timeval *, struct timeval *);
 static in_addr_t get_ip_address(const char *);
 static int wait_for_reply(int, u_int);
-static int recvfrom_wto(int, void *, unsigned int, struct sockaddr *, u_int *, struct timeval*);
+static int recvfrom_wto(int, void *, unsigned int, struct sockaddr *, u_int *, struct timeval *);
 static int send_icmp_ping(int, struct rta_host *);
 static int get_threshold(char *str, threshold *th);
 static bool get_threshold2(char *str, size_t length, threshold *, threshold *, threshold_mode mode);
@@ -235,20 +234,8 @@ extern char **environ;
 /** global variables **/
 static struct rta_host **table, *cursor, *list;
 
-static threshold crit = {
-        .pl = 80,
-        .rta = 500000,
-        .jitter = 0.0,
-        .mos = 0.0,
-        .score = 0.0
-};
-static threshold warn = {
-        .pl = 40,
-        .rta = 200000,
-        .jitter = 0.0,
-        .mos = 0.0,
-        .score = 0.0
-};
+static threshold crit = {.pl = 80, .rta = 500000, .jitter = 0.0, .mos = 0.0, .score = 0.0};
+static threshold warn = {.pl = 40, .rta = 200000, .jitter = 0.0, .mos = 0.0, .score = 0.0};
 
 static int mode, protocols, sockets, debug = 0, timeout = 10;
 static unsigned short icmp_data_size = DEFAULT_PING_DATA_SIZE;
@@ -266,19 +253,17 @@ static struct timeval prog_start;
 static unsigned long long max_completion_time = 0;
 static unsigned int warn_down = 1, crit_down = 1; /* host down threshold values */
 static int min_hosts_alive = -1;
-float pkt_backoff_factor = 1.5;
-float target_backoff_factor = 1.5;
-bool rta_mode=false;
-bool pl_mode=false;
-bool jitter_mode=false;
-bool score_mode=false;
-bool mos_mode=false;
-bool order_mode=false;
+static float pkt_backoff_factor = 1.5;
+static float target_backoff_factor = 1.5;
+static bool rta_mode = false;
+static bool pl_mode = false;
+static bool jitter_mode = false;
+static bool score_mode = false;
+static bool mos_mode = false;
+static bool order_mode = false;
 
 /** code start **/
-static void
-crash(const char *fmt, ...)
-{
+static void crash(const char *fmt, ...) {
         va_list ap;
 
         printf("%s: ", progname);
@@ -287,55 +272,100 @@ crash(const char *fmt, ...)
         vprintf(fmt, ap);
         va_end(ap);
 
-        if(errno) printf(": %s", strerror(errno));
+        if (errno)
+                printf(": %s", strerror(errno));
         puts("");
 
         exit(3);
 }
 
-
-static const char *
-get_icmp_error_msg(unsigned char icmp_type, unsigned char icmp_code)
-{
+static const char *get_icmp_error_msg(unsigned char icmp_type, unsigned char icmp_code) {
         const char *msg = "unreachable";
 
-        if(debug > 1) printf("get_icmp_error_msg(%u, %u)\n", icmp_type, icmp_code);
-        switch(icmp_type) {
+        if (debug > 1)
+                printf("get_icmp_error_msg(%u, %u)\n", icmp_type, icmp_code);
+        switch (icmp_type) {
         case ICMP_UNREACH:
-                switch(icmp_code) {
-                case ICMP_UNREACH_NET: msg = "Net unreachable"; break;
-                case ICMP_UNREACH_HOST: msg = "Host unreachable"; break;
-                case ICMP_UNREACH_PROTOCOL: msg = "Protocol unreachable (firewall?)"; break;
-                case ICMP_UNREACH_PORT: msg = "Port unreachable (firewall?)"; break;
-                case ICMP_UNREACH_NEEDFRAG: msg = "Fragmentation needed"; break;
-                case ICMP_UNREACH_SRCFAIL: msg = "Source route failed"; break;
-                case ICMP_UNREACH_ISOLATED: msg = "Source host isolated"; break;
-                case ICMP_UNREACH_NET_UNKNOWN: msg = "Unknown network"; break;
-                case ICMP_UNREACH_HOST_UNKNOWN: msg = "Unknown host"; break;
-                case ICMP_UNREACH_NET_PROHIB: msg = "Network denied (firewall?)"; break;
-                case ICMP_UNREACH_HOST_PROHIB: msg = "Host denied (firewall?)"; break;
-                case ICMP_UNREACH_TOSNET: msg = "Bad TOS for network (firewall?)"; break;
-                case ICMP_UNREACH_TOSHOST: msg = "Bad TOS for host (firewall?)"; break;
-                case ICMP_UNREACH_FILTER_PROHIB: msg = "Prohibited by filter (firewall)"; break;
-                case ICMP_UNREACH_HOST_PRECEDENCE: msg = "Host precedence violation"; break;
-                case ICMP_UNREACH_PRECEDENCE_CUTOFF: msg = "Precedence cutoff"; break;
-                default: msg = "Invalid code"; break;
+                switch (icmp_code) {
+                case ICMP_UNREACH_NET:
+                        msg = "Net unreachable";
+                        break;
+                case ICMP_UNREACH_HOST:
+                        msg = "Host unreachable";
+                        break;
+                case ICMP_UNREACH_PROTOCOL:
+                        msg = "Protocol unreachable (firewall?)";
+                        break;
+                case ICMP_UNREACH_PORT:
+                        msg = "Port unreachable (firewall?)";
+                        break;
+                case ICMP_UNREACH_NEEDFRAG:
+                        msg = "Fragmentation needed";
+                        break;
+                case ICMP_UNREACH_SRCFAIL:
+                        msg = "Source route failed";
+                        break;
+                case ICMP_UNREACH_ISOLATED:
+                        msg = "Source host isolated";
+                        break;
+                case ICMP_UNREACH_NET_UNKNOWN:
+                        msg = "Unknown network";
+                        break;
+                case ICMP_UNREACH_HOST_UNKNOWN:
+                        msg = "Unknown host";
+                        break;
+                case ICMP_UNREACH_NET_PROHIB:
+                        msg = "Network denied (firewall?)";
+                        break;
+                case ICMP_UNREACH_HOST_PROHIB:
+                        msg = "Host denied (firewall?)";
+                        break;
+                case ICMP_UNREACH_TOSNET:
+                        msg = "Bad TOS for network (firewall?)";
+                        break;
+                case ICMP_UNREACH_TOSHOST:
+                        msg = "Bad TOS for host (firewall?)";
+                        break;
+                case ICMP_UNREACH_FILTER_PROHIB:
+                        msg = "Prohibited by filter (firewall)";
+                        break;
+                case ICMP_UNREACH_HOST_PRECEDENCE:
+                        msg = "Host precedence violation";
+                        break;
+                case ICMP_UNREACH_PRECEDENCE_CUTOFF:
+                        msg = "Precedence cutoff";
+                        break;
+                default:
+                        msg = "Invalid code";
+                        break;
                 }
                 break;
 
         case ICMP_TIMXCEED:
                 /* really 'out of reach', or non-existent host behind a router serving
                  * two different subnets */
-                switch(icmp_code) {
-                case ICMP_TIMXCEED_INTRANS: msg = "Time to live exceeded in transit"; break;
-                case ICMP_TIMXCEED_REASS: msg = "Fragment reassembly time exceeded"; break;
-                default: msg = "Invalid code"; break;
+                switch (icmp_code) {
+                case ICMP_TIMXCEED_INTRANS:
+                        msg = "Time to live exceeded in transit";
+                        break;
+                case ICMP_TIMXCEED_REASS:
+                        msg = "Fragment reassembly time exceeded";
+                        break;
+                default:
+                        msg = "Invalid code";
+                        break;
                 }
                 break;
 
-        case ICMP_SOURCEQUENCH: msg = "Transmitting too fast"; break;
-        case ICMP_REDIRECT: msg = "Redirect (change route)"; break;
-        case ICMP_PARAMPROB: msg = "Bad IP header (required option absent)"; break;
+        case ICMP_SOURCEQUENCH:
+                msg = "Transmitting too fast";
+                break;
+        case ICMP_REDIRECT:
+                msg = "Redirect (change route)";
+                break;
+        case ICMP_PARAMPROB:
+                msg = "Bad IP header (required option absent)";
+                break;
 
                 /* the following aren't error messages, so ignore */
         case ICMP_TSTAMP:
@@ -344,25 +374,26 @@ get_icmp_error_msg(unsigned char icmp_type, unsigned char icmp_code)
         case ICMP_IREQREPLY:
         case ICMP_MASKREQ:
         case ICMP_MASKREPLY:
-        default: msg = ""; break;
+        default:
+                msg = "";
+                break;
         }
 
         return msg;
 }
 
-static int
-handle_random_icmp(unsigned char *packet, struct sockaddr_storage *addr)
-{
+static int handle_random_icmp(unsigned char *packet, struct sockaddr_storage *addr) {
         struct icmp p, sent_icmp;
         struct rta_host *host = NULL;
 
         memcpy(&p, packet, sizeof(p));
-        if(p.icmp_type == ICMP_ECHO && ntohs(p.icmp_id) == pid) {
+        if (p.icmp_type == ICMP_ECHO && ntohs(p.icmp_id) == pid) {
                 /* echo request from us to us (pinging localhost) */
                 return 0;
         }
 
-        if(debug) printf("handle_random_icmp(%p, %p)\n", (void *)&p, (void *)addr);
+        if (debug)
+                printf("handle_random_icmp(%p, %p)\n", (void *)&p, (void *)addr);
 
         /* only handle a few types, since others can't possibly be replies to
          * us in a sane network (if it is anyway, it will be counted as lost
@@ -374,44 +405,39 @@ handle_random_icmp(unsigned char *packet, struct sockaddr_storage *addr)
          * TIMXCEED actually sends a proper icmp response we will have passed
          * too many hops to have a hope of reaching it later, in which case it
          * indicates overconfidence in the network, poor routing or both. */
-        if(p.icmp_type != ICMP_UNREACH && p.icmp_type != ICMP_TIMXCEED &&
-           p.icmp_type != ICMP_SOURCEQUENCH && p.icmp_type != ICMP_PARAMPROB)
-        {
+        if (p.icmp_type != ICMP_UNREACH && p.icmp_type != ICMP_TIMXCEED && p.icmp_type != ICMP_SOURCEQUENCH && p.icmp_type != ICMP_PARAMPROB) {
                 return 0;
         }
 
         /* might be for us. At least it holds the original package (according
          * to RFC 792). If it isn't, just ignore it */
         memcpy(&sent_icmp, packet + 28, sizeof(sent_icmp));
-        if(sent_icmp.icmp_type != ICMP_ECHO || ntohs(sent_icmp.icmp_id) != pid ||
-           ntohs(sent_icmp.icmp_seq) >= targets*packets)
-        {
-                if(debug) printf("Packet is no response to a packet we sent\n");
+        if (sent_icmp.icmp_type != ICMP_ECHO || ntohs(sent_icmp.icmp_id) != pid || ntohs(sent_icmp.icmp_seq) >= targets * packets) {
+                if (debug)
+                        printf("Packet is no response to a packet we sent\n");
                 return 0;
         }
 
         /* it is indeed a response for us */
-        host = table[ntohs(sent_icmp.icmp_seq)/packets];
-        if(debug) {
+        host = table[ntohs(sent_icmp.icmp_seq) / packets];
+        if (debug) {
                 char address[INET6_ADDRSTRLEN];
                 parse_address(addr, address, sizeof(address));
-                printf("Received \"%s\" from %s for ICMP ECHO sent to %s.\n",
-                        get_icmp_error_msg(p.icmp_type, p.icmp_code),
-                        address, host->name);
+                printf("Received \"%s\" from %s for ICMP ECHO sent to %s.\n", get_icmp_error_msg(p.icmp_type, p.icmp_code), address, host->name);
         }
 
         icmp_lost++;
         host->icmp_lost++;
         /* don't spend time on lost hosts any more */
-        if(host->flags & FLAG_LOST_CAUSE) return 0;
+        if (host->flags & FLAG_LOST_CAUSE)
+                return 0;
 
         /* source quench means we're sending too fast, so increase the
          * interval and mark this packet lost */
-        if(p.icmp_type == ICMP_SOURCEQUENCH) {
+        if (p.icmp_type == ICMP_SOURCEQUENCH) {
                 pkt_interval *= pkt_backoff_factor;
                 target_interval *= target_backoff_factor;
-        }
-        else {
+        } else {
                 targets_down++;
                 host->flags |= FLAG_LOST_CAUSE;
         }
@@ -422,21 +448,18 @@ handle_random_icmp(unsigned char *packet, struct sockaddr_storage *addr)
         return 0;
 }
 
-void parse_address(struct sockaddr_storage *addr, char *address, int size)
-{
+void parse_address(struct sockaddr_storage *addr, char *address, int size) {
         switch (address_family) {
         case AF_INET:
                 inet_ntop(address_family, &((struct sockaddr_in *)addr)->sin_addr, address, size);
-        break;
+                break;
         case AF_INET6:
                 inet_ntop(address_family, &((struct sockaddr_in6 *)addr)->sin6_addr, address, size);
-        break;
+                break;
         }
 }
 
-int
-main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
         int i;
         char *ptr;
         long int arg;
@@ -450,10 +473,10 @@ main(int argc, char **argv)
         int on = 1;
 #endif
         char *source_ip = NULL;
-        char * opts_str = "vhVw:c:n:p:t:H:s:i:b:I:l:m:P:R:J:S:M:O64";
-        setlocale (LC_ALL, "");
-        bindtextdomain (PACKAGE, LOCALEDIR);
-        textdomain (PACKAGE);
+        char *opts_str = "vhVw:c:n:p:t:H:s:i:b:I:l:m:P:R:J:S:M:O64";
+        setlocale(LC_ALL, "");
+        bindtextdomain(PACKAGE, LOCALEDIR);
+        textdomain(PACKAGE);
 
         /* we only need to be setsuid when we get the sockets, so do
          * that before pointer magic (esp. on network data) */
@@ -465,8 +488,10 @@ main(int argc, char **argv)
         /* get calling name the old-fashioned way for portability instead
          * of relying on the glibc-ism __progname */
         ptr = strrchr(argv[0], '/');
-        if(ptr) progname = &ptr[1];
-        else progname = argv[0];
+        if (ptr)
+                progname = &ptr[1];
+        else
+                progname = argv[0];
 
         /* now set defaults. Use progname to set them initially (allows for
          * superfast check_host program when target host is up */
@@ -478,31 +503,29 @@ main(int argc, char **argv)
         crit.rta = 500000;
         crit.pl = 80;
         crit.jitter = 50;
-        crit.mos= 3;
-        crit.score=70;
+        crit.mos = 3;
+        crit.score = 70;
         /* Default warning thresholds */
         warn.rta = 200000;
         warn.pl = 40;
         warn.jitter = 40;
-        warn.mos= 3.5;
-        warn.score=80;
+        warn.mos = 3.5;
+        warn.score = 80;
 
         protocols = HAVE_ICMP | HAVE_UDP | HAVE_TCP;
-        pkt_interval = 80000;  /* 80 msec packet interval by default */
+        pkt_interval = 80000; /* 80 msec packet interval by default */
         packets = 5;
 
-        if(!strcmp(progname, "check_icmp") || !strcmp(progname, "check_ping")) {
+        if (!strcmp(progname, "check_icmp") || !strcmp(progname, "check_ping")) {
                 mode = MODE_ICMP;
                 protocols = HAVE_ICMP;
-        }
-        else if(!strcmp(progname, "check_host")) {
+        } else if (!strcmp(progname, "check_host")) {
                 mode = MODE_HOSTCHECK;
                 pkt_interval = 1000000;
                 packets = 5;
                 crit.rta = warn.rta = 1000000;
                 crit.pl = warn.pl = 100;
-        }
-        else if(!strcmp(progname, "check_rta_multi")) {
+        } else if (!strcmp(progname, "check_rta_multi")) {
                 mode = MODE_ALL;
                 target_interval = 0;
                 pkt_interval = 50000;
@@ -510,17 +533,17 @@ main(int argc, char **argv)
         }
 
         /* support "--help" and "--version" */
-        if(argc == 2) {
-                if(!strcmp(argv[1], "--help"))
+        if (argc == 2) {
+                if (!strcmp(argv[1], "--help"))
                         strcpy(argv[1], "-h");
-                if(!strcmp(argv[1], "--version"))
+                if (!strcmp(argv[1], "--version"))
                         strcpy(argv[1], "-V");
         }
 
         /* Parse protocol arguments first */
-        for(i = 1; i < argc; i++) {
-                while((arg = getopt(argc, argv, opts_str)) != EOF) {
-                        switch(arg) {
+        for (i = 1; i < argc; i++) {
+                while ((arg = getopt(argc, argv, opts_str)) != EOF) {
+                        switch (arg) {
                         case '4':
                                 if (address_family != -1)
                                         crash("Multiple protocol versions not supported");
@@ -532,7 +555,7 @@ main(int argc, char **argv)
                                         crash("Multiple protocol versions not supported");
                                 address_family = AF_INET6;
 #else
-                                usage (_("IPv6 support not available\n"));
+                                usage(_("IPv6 support not available\n"));
 #endif
                                 break;
                         }
@@ -545,22 +568,20 @@ main(int argc, char **argv)
         unsigned long size;
         bool err;
         /* parse the arguments */
-        for(i = 1; i < argc; i++) {
-                while((arg = getopt(argc, argv, opts_str)) != EOF) {
-                        switch(arg) {
+        for (i = 1; i < argc; i++) {
+                while ((arg = getopt(argc, argv, opts_str)) != EOF) {
+                        switch (arg) {
                         case 'v':
                                 debug++;
                                 break;
                         case 'b':
-                                size = strtol(optarg,NULL,0);
-                                if (size >= (sizeof(struct icmp) + sizeof(struct icmp_ping_data)) &&
-                                    size < MAX_PING_DATA) {
+                                size = strtol(optarg, NULL, 0);
+                                if (size >= (sizeof(struct icmp) + sizeof(struct icmp_ping_data)) && size < MAX_PING_DATA) {
                                         icmp_data_size = size;
                                         icmp_pkt_size = size + ICMP_MINLEN;
                                 } else
-                                        usage_va("ICMP data length must be between: %lu and %lu",
-                                                 sizeof(struct icmp) + sizeof(struct icmp_ping_data),
-                                                 MAX_PING_DATA - 1);
+                                        usage_va("ICMP data length must be between: %lu and %lu", sizeof(struct icmp) + sizeof(struct icmp_ping_data),
+                                                         MAX_PING_DATA - 1);
                                 break;
                         case 'i':
                                 pkt_interval = get_timevar(optarg);
@@ -580,7 +601,8 @@ main(int argc, char **argv)
                                 break;
                         case 't':
                                 timeout = strtoul(optarg, NULL, 0);
-                                if(!timeout) timeout = 10;
+                                if (!timeout)
+                                        timeout = 10;
                                 break;
                         case 'H':
                                 add_target(optarg);
@@ -593,7 +615,7 @@ main(int argc, char **argv)
                                 break;
                         case 'd': /* implement later, for cluster checks */
                                 warn_down = (unsigned char)strtoul(optarg, &ptr, 0);
-                                if(ptr) {
+                                if (ptr) {
                                         crit_down = (unsigned char)strtoul(ptr + 1, NULL, 0);
                                 }
                                 break;
@@ -601,54 +623,54 @@ main(int argc, char **argv)
                                 source_ip = optarg;
                                 break;
                         case 'V': /* version */
-                                print_revision (progname, NP_VERSION);
-                                exit (STATE_UNKNOWN);
+                                print_revision(progname, NP_VERSION);
+                                exit(STATE_UNKNOWN);
                         case 'h': /* help */
-                                print_help ();
-                                exit (STATE_UNKNOWN);
+                                print_help();
+                                exit(STATE_UNKNOWN);
                                 break;
                         case 'R': /* RTA mode */
                                 err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_rta_mode);
                                 if (!err) {
-                                                crash("Failed to parse RTA threshold");
+                                        crash("Failed to parse RTA threshold");
                                 }
 
-                                rta_mode=true;
+                                rta_mode = true;
                                 break;
                         case 'P': /* packet loss mode */
                                 err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_packet_loss_mode);
                                 if (!err) {
-                                                crash("Failed to parse packet loss threshold");
+                                        crash("Failed to parse packet loss threshold");
                                 }
 
-                                pl_mode=true;
+                                pl_mode = true;
                                 break;
                         case 'J': /* jitter mode */
                                 err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_jitter_mode);
                                 if (!err) {
-                                                crash("Failed to parse jitter threshold");
+                                        crash("Failed to parse jitter threshold");
                                 }
 
-                                jitter_mode=true;
+                                jitter_mode = true;
                                 break;
                         case 'M': /* MOS mode */
                                 err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_mos_mode);
                                 if (!err) {
-                                                crash("Failed to parse MOS threshold");
+                                        crash("Failed to parse MOS threshold");
                                 }
 
-                                mos_mode=true;
+                                mos_mode = true;
                                 break;
                         case 'S': /* score mode */
                                 err = get_threshold2(optarg, strlen(optarg), &warn, &crit, const_score_mode);
                                 if (!err) {
-                                                crash("Failed to parse score threshold");
+                                        crash("Failed to parse score threshold");
                                 }
 
-                                score_mode=true;
+                                score_mode = true;
                                 break;
                         case 'O': /* out of order mode */
-                                order_mode=true;
+                                order_mode = true;
                                 break;
                         }
                 }
@@ -663,37 +685,42 @@ main(int argc, char **argv)
         /* printf("pid = %u\n", pid); */
 
         /* Parse extra opts if any */
-        argv=np_extra_opts(&argc, argv, progname);
+        argv = np_extra_opts(&argc, argv, progname);
 
         argv = &argv[optind];
-        while(*argv) {
+        while (*argv) {
                 add_target(*argv);
                 argv++;
         }
 
-        if(!targets) {
+        if (!targets) {
                 errno = 0;
                 crash("No hosts to check");
         }
 
         // add_target might change address_family
-        switch ( address_family ){
-                case AF_INET:   icmp_proto = IPPROTO_ICMP;
-                                break;
-                case AF_INET6:  icmp_proto = IPPROTO_ICMPV6;
-                                break;
-                default:        crash("Address family not supported");
+        switch (address_family) {
+        case AF_INET:
+                icmp_proto = IPPROTO_ICMP;
+                break;
+        case AF_INET6:
+                icmp_proto = IPPROTO_ICMPV6;
+                break;
+        default:
+                crash("Address family not supported");
         }
-        if((icmp_sock = socket(address_family, SOCK_RAW, icmp_proto)) != -1)
+        if ((icmp_sock = socket(address_family, SOCK_RAW, icmp_proto)) != -1)
                 sockets |= HAVE_ICMP;
-        else icmp_sockerrno = errno;
+        else
+                icmp_sockerrno = errno;
 
-        if( source_ip )
+        if (source_ip)
                 set_source_ip(source_ip);
 
 #ifdef SO_TIMESTAMP
-        if(setsockopt(icmp_sock, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on)))
-          if(debug) printf("Warning: no SO_TIMESTAMP support\n");
+        if (setsockopt(icmp_sock, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on)))
+                if (debug)
+                        printf("Warning: no SO_TIMESTAMP support\n");
 #endif // SO_TIMESTAMP
 
         /* now drop privileges (no effect if not setsuid or geteuid() == 0) */
@@ -702,8 +729,8 @@ main(int argc, char **argv)
                 return 1;
         }
 
-        if(!sockets) {
-                if(icmp_sock == -1) {
+        if (!sockets) {
+                if (icmp_sock == -1) {
                         errno = icmp_sockerrno;
                         crash("Failed to obtain ICMP socket");
                         return -1;
@@ -719,13 +746,16 @@ main(int argc, char **argv)
                 /*      return -1; */
                 /* } */
         }
-        if(!ttl) ttl = 64;
+        if (!ttl)
+                ttl = 64;
 
-        if(icmp_sock) {
+        if (icmp_sock) {
                 result = setsockopt(icmp_sock, SOL_IP, IP_TTL, &ttl, sizeof(ttl));
-                if(debug) {
-                        if(result == -1) printf("setsockopt failed\n");
-                        else printf("ttl set to %u\n", ttl);
+                if (debug) {
+                        if (result == -1)
+                                printf("setsockopt failed\n");
+                        else
+                                printf("ttl set to %u\n", ttl);
                 }
         }
 
@@ -733,85 +763,83 @@ main(int argc, char **argv)
          * (nothing will break if they do), but some anal plugin maintainer
          * will probably add some printf() thing here later, so it might be
          * best to at least show them where to do it. ;) */
-        if(warn.pl > crit.pl) warn.pl = crit.pl;
-        if(warn.rta > crit.rta) warn.rta = crit.rta;
-        if(warn_down > crit_down) crit_down = warn_down;
-        if(warn.jitter > crit.jitter) crit.jitter = warn.jitter;
-        if(warn.mos < crit.mos) warn.mos = crit.mos;
-        if(warn.score < crit.score) warn.score = crit.score;
+        if (warn.pl > crit.pl)
+                warn.pl = crit.pl;
+        if (warn.rta > crit.rta)
+                warn.rta = crit.rta;
+        if (warn_down > crit_down)
+                crit_down = warn_down;
+        if (warn.jitter > crit.jitter)
+                crit.jitter = warn.jitter;
+        if (warn.mos < crit.mos)
+                warn.mos = crit.mos;
+        if (warn.score < crit.score)
+                warn.score = crit.score;
 
 #ifdef HAVE_SIGACTION
         sig_action.sa_sigaction = NULL;
         sig_action.sa_handler = finish;
         sigfillset(&sig_action.sa_mask);
-        sig_action.sa_flags = SA_NODEFER|SA_RESTART;
+        sig_action.sa_flags = SA_NODEFER | SA_RESTART;
         sigaction(SIGINT, &sig_action, NULL);
         sigaction(SIGHUP, &sig_action, NULL);
         sigaction(SIGTERM, &sig_action, NULL);
         sigaction(SIGALRM, &sig_action, NULL);
-#else /* HAVE_SIGACTION */
+#else  /* HAVE_SIGACTION */
         signal(SIGINT, finish);
         signal(SIGHUP, finish);
         signal(SIGTERM, finish);
         signal(SIGALRM, finish);
 #endif /* HAVE_SIGACTION */
-        if(debug) printf("Setting alarm timeout to %u seconds\n", timeout);
+        if (debug)
+                printf("Setting alarm timeout to %u seconds\n", timeout);
         alarm(timeout);
 
         /* make sure we don't wait any longer than necessary */
         gettimeofday(&prog_start, &tz);
-        max_completion_time =
-                ((targets * packets * pkt_interval) + (targets * target_interval)) +
-                (targets * packets * crit.rta) + crit.rta;
+        max_completion_time = ((targets * packets * pkt_interval) + (targets * target_interval)) + (targets * packets * crit.rta) + crit.rta;
 
-        if(debug) {
+        if (debug) {
                 printf("packets: %u, targets: %u\n"
                            "target_interval: %0.3f, pkt_interval %0.3f\n"
                            "crit.rta: %0.3f\n"
                            "max_completion_time: %0.3f\n",
-                           packets, targets,
-                           (float)target_interval / 1000, (float)pkt_interval / 1000,
-                           (float)crit.rta / 1000,
+                           packets, targets, (float)target_interval / 1000, (float)pkt_interval / 1000, (float)crit.rta / 1000,
                            (float)max_completion_time / 1000);
         }
 
-        if(debug) {
-                if(max_completion_time > (u_int)timeout * 1000000) {
-                        printf("max_completion_time: %llu  timeout: %u\n",
-                                   max_completion_time, timeout);
-                        printf("Timeout must be at least %llu\n",
-                                   max_completion_time / 1000000 + 1);
+        if (debug) {
+                if (max_completion_time > (u_int)timeout * 1000000) {
+                        printf("max_completion_time: %llu  timeout: %u\n", max_completion_time, timeout);
+                        printf("Timeout must be at least %llu\n", max_completion_time / 1000000 + 1);
                 }
         }
 
-        if(debug) {
-                printf("crit = {%u, %u%%}, warn = {%u, %u%%}\n",
-                           crit.rta, crit.pl, warn.rta, warn.pl);
-                printf("pkt_interval: %u  target_interval: %u  retry_interval: %u\n",
-                           pkt_interval, target_interval, retry_interval);
-                printf("icmp_pkt_size: %u  timeout: %u\n",
-                           icmp_pkt_size, timeout);
+        if (debug) {
+                printf("crit = {%u, %u%%}, warn = {%u, %u%%}\n", crit.rta, crit.pl, warn.rta, warn.pl);
+                printf("pkt_interval: %u  target_interval: %u  retry_interval: %u\n", pkt_interval, target_interval, retry_interval);
+                printf("icmp_pkt_size: %u  timeout: %u\n", icmp_pkt_size, timeout);
         }
 
-        if(packets > 20) {
+        if (packets > 20) {
                 errno = 0;
                 crash("packets is > 20 (%d)", packets);
         }
 
-        if(min_hosts_alive < -1) {
+        if (min_hosts_alive < -1) {
                 errno = 0;
                 crash("minimum alive hosts is negative (%i)", min_hosts_alive);
         }
 
         host = list;
         table = malloc(sizeof(struct rta_host *) * targets);
-        if(!table) {
+        if (!table) {
                 crash("main(): malloc failed for host table");
         }
 
         i = 0;
-        while(host) {
-                host->id = i*packets;
+        while (host) {
+                host->id = i * packets;
                 table[i] = host;
                 host = host->next;
                 i++;
@@ -822,25 +850,24 @@ main(int argc, char **argv)
         errno = 0;
         finish(0);
 
-        return(0);
+        return (0);
 }
 
-static void
-run_checks()
-{
+static void run_checks(void) {
         u_int i, t;
         u_int final_wait, time_passed;
 
         /* this loop might actually violate the pkt_interval or target_interval
          * settings, but only if there aren't any packets on the wire which
          * indicates that the target can handle an increased packet rate */
-        for(i = 0; i < packets; i++) {
-                for(t = 0; t < targets; t++) {
+        for (i = 0; i < packets; i++) {
+                for (t = 0; t < targets; t++) {
                         /* don't send useless packets */
-                        if(!targets_alive) finish(0);
-                        if(table[t]->flags & FLAG_LOST_CAUSE) {
-                                if(debug) printf("%s is a lost cause. not sending any more\n",
-                                                                 table[t]->name);
+                        if (!targets_alive)
+                                finish(0);
+                        if (table[t]->flags & FLAG_LOST_CAUSE) {
+                                if (debug)
+                                        printf("%s is a lost cause. not sending any more\n", table[t]->name);
                                 continue;
                         }
 
@@ -851,28 +878,27 @@ run_checks()
                 wait_for_reply(icmp_sock, pkt_interval * targets);
         }
 
-        if(icmp_pkts_en_route && targets_alive) {
+        if (icmp_pkts_en_route && targets_alive) {
                 time_passed = get_timevaldiff(NULL, NULL);
                 final_wait = max_completion_time - time_passed;
 
-                if(debug) {
-                        printf("time_passed: %u  final_wait: %u  max_completion_time: %llu\n",
-                                   time_passed, final_wait, max_completion_time);
+                if (debug) {
+                        printf("time_passed: %u  final_wait: %u  max_completion_time: %llu\n", time_passed, final_wait, max_completion_time);
                 }
-                if(time_passed > max_completion_time) {
-                        if(debug) printf("Time passed. Finishing up\n");
+                if (time_passed > max_completion_time) {
+                        if (debug)
+                                printf("Time passed. Finishing up\n");
                         finish(0);
                 }
 
                 /* catch the packets that might come in within the timeframe, but
                  * haven't yet */
-                if(debug) printf("Waiting for %u micro-seconds (%0.3f msecs)\n",
-                                                 final_wait, (float)final_wait / 1000);
+                if (debug)
+                        printf("Waiting for %u micro-seconds (%0.3f msecs)\n", final_wait, (float)final_wait / 1000);
                 wait_for_reply(icmp_sock, final_wait);
         }
 }
 
-
 /* response structure:
  * IPv4:
  * ip header   : 20 bytes
@@ -883,9 +909,7 @@ run_checks()
  * both:
  * icmp echo reply : the rest
  */
-static int
-wait_for_reply(int sock, u_int t)
-{
+static int wait_for_reply(int sock, u_int t) {
         int n, hlen;
         static unsigned char buf[65536];
         struct sockaddr_storage resp_addr;
@@ -898,15 +922,14 @@ wait_for_reply(int sock, u_int t)
         double jitter_tmp;
 
         if (!(packet.buf = malloc(icmp_pkt_size))) {
-                crash("send_icmp_ping(): failed to malloc %d bytes for send buffer",
-                        icmp_pkt_size);
-                return -1;      /* might be reached if we're in debug mode */
+                crash("send_icmp_ping(): failed to malloc %d bytes for send buffer", icmp_pkt_size);
+                return -1; /* might be reached if we're in debug mode */
         }
 
         memset(packet.buf, 0, icmp_pkt_size);
 
         /* if we can't listen or don't have anything to listen to, just return */
-        if(!t || !icmp_pkts_en_route) {
+        if (!t || !icmp_pkts_en_route) {
                 free(packet.buf);
                 return 0;
         }
@@ -915,29 +938,25 @@ wait_for_reply(int sock, u_int t)
 
         i = t;
         per_pkt_wait = t / icmp_pkts_en_route;
-        while(icmp_pkts_en_route && get_timevaldiff(&wait_start, NULL) < i) {
+        while (icmp_pkts_en_route && get_timevaldiff(&wait_start, NULL) < i) {
                 t = per_pkt_wait;
 
                 /* wrap up if all targets are declared dead */
-                if(!targets_alive ||
-                   get_timevaldiff(&prog_start, NULL) >= max_completion_time ||
-                   (mode == MODE_HOSTCHECK && targets_down))
-                {
+                if (!targets_alive || get_timevaldiff(&prog_start, NULL) >= max_completion_time || (mode == MODE_HOSTCHECK && targets_down)) {
                         finish(0);
                 }
 
                 /* reap responses until we hit a timeout */
-                n = recvfrom_wto(sock, buf, sizeof(buf),
-                                         (struct sockaddr *)&resp_addr, &t, &now);
-                if(!n) {
-                        if(debug > 1) {
-                                printf("recvfrom_wto() timed out during a %u usecs wait\n",
-                                           per_pkt_wait);
+                n = recvfrom_wto(sock, buf, sizeof(buf), (struct sockaddr *)&resp_addr, &t, &now);
+                if (!n) {
+                        if (debug > 1) {
+                                printf("recvfrom_wto() timed out during a %u usecs wait\n", per_pkt_wait);
                         }
-                        continue;       /* timeout for this one, so keep trying */
+                        continue; /* timeout for this one, so keep trying */
                 }
-                if(n < 0) {
-                        if(debug) printf("recvfrom_wto() returned errors\n");
+                if (n < 0) {
+                        if (debug)
+                                printf("recvfrom_wto() returned errors\n");
                         free(packet.buf);
                         return n;
                 }
@@ -946,31 +965,27 @@ wait_for_reply(int sock, u_int t)
                 if (address_family != AF_INET6) {
                         ip = (union ip_hdr *)buf;
 
-                        if(debug > 1) {
+                        if (debug > 1) {
                                 char address[INET6_ADDRSTRLEN];
                                 parse_address(&resp_addr, address, sizeof(address));
-                                printf("received %u bytes from %s\n",
-                                        address_family == AF_INET6 ? ntohs(ip->ip6.ip6_plen)
-                                                                   : ntohs(ip->ip.ip_len),
-                                        address);
+                                printf("received %u bytes from %s\n", address_family == AF_INET6 ? ntohs(ip->ip6.ip6_plen) : ntohs(ip->ip.ip_len), address);
                         }
                 }
 
-/* obsolete. alpha on tru64 provides the necessary defines, but isn't broken */
-/* #if defined( __alpha__ ) && __STDC__ && !defined( __GLIBC__ ) */
+                /* obsolete. alpha on tru64 provides the necessary defines, but isn't broken */
+                /* #if defined( __alpha__ ) && __STDC__ && !defined( __GLIBC__ ) */
                 /* alpha headers are decidedly broken. Using an ansi compiler,
                  * they provide ip_vhl instead of ip_hl and ip_v, so we mask
                  * off the bottom 4 bits */
-/*              hlen = (ip->ip_vhl & 0x0f) << 2; */
-/* #else */
+                /*              hlen = (ip->ip_vhl & 0x0f) << 2; */
+                /* #else */
                 hlen = (address_family == AF_INET6) ? 0 : ip->ip.ip_hl << 2;
-/* #endif */
+                /* #endif */
 
-                if(n < (hlen + ICMP_MINLEN)) {
+                if (n < (hlen + ICMP_MINLEN)) {
                         char address[INET6_ADDRSTRLEN];
                         parse_address(&resp_addr, address, sizeof(address));
-                        crash("received packet too short for ICMP (%d bytes, expected %d) from %s\n",
-                                  n, hlen + icmp_pkt_size, address);
+                        crash("received packet too short for ICMP (%d bytes, expected %d) from %s\n", n, hlen + icmp_pkt_size, address);
                 }
                 /* else if(debug) { */
                 /*      printf("ip header size: %u, packet size: %u (expected %u, %u)\n", */
@@ -981,16 +996,15 @@ wait_for_reply(int sock, u_int t)
                 /* check the response */
 
                 memcpy(packet.buf, buf + hlen, icmp_pkt_size);
-/*                      address_family == AF_INET6 ? sizeof(struct icmp6_hdr)
-                                                   : sizeof(struct icmp));*/
-
-                if(   (address_family == PF_INET &&
-                        (ntohs(packet.icp->icmp_id) != pid || packet.icp->icmp_type != ICMP_ECHOREPLY
-                         || ntohs(packet.icp->icmp_seq) >= targets * packets))
-                   || (address_family == PF_INET6 &&
-                        (ntohs(packet.icp6->icmp6_id) != pid || packet.icp6->icmp6_type != ICMP6_ECHO_REPLY
-                        || ntohs(packet.icp6->icmp6_seq) >= targets * packets))) {
-                        if(debug > 2) printf("not a proper ICMP_ECHOREPLY\n");
+                /*                      address_family == AF_INET6 ? sizeof(struct icmp6_hdr)
+                                                                   : sizeof(struct icmp));*/
+
+                if ((address_family == PF_INET && (ntohs(packet.icp->icmp_id) != pid || packet.icp->icmp_type != ICMP_ECHOREPLY ||
+                                                                                   ntohs(packet.icp->icmp_seq) >= targets * packets)) ||
+                        (address_family == PF_INET6 && (ntohs(packet.icp6->icmp6_id) != pid || packet.icp6->icmp6_type != ICMP6_ECHO_REPLY ||
+                                                                                        ntohs(packet.icp6->icmp6_seq) >= targets * packets))) {
+                        if (debug > 2)
+                                printf("not a proper ICMP_ECHOREPLY\n");
                         handle_random_icmp(buf + hlen, &resp_addr);
                         continue;
                 }
@@ -999,22 +1013,20 @@ wait_for_reply(int sock, u_int t)
                 if (address_family == PF_INET) {
                         memcpy(&data, packet.icp->icmp_data, sizeof(data));
                         if (debug > 2)
-                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n",
-                                        (unsigned long)sizeof(data), ntohs(packet.icp->icmp_id),
-                                        ntohs(packet.icp->icmp_seq), packet.icp->icmp_cksum);
-                        host = table[ntohs(packet.icp->icmp_seq)/packets];
+                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n", (unsigned long)sizeof(data), ntohs(packet.icp->icmp_id),
+                                           ntohs(packet.icp->icmp_seq), packet.icp->icmp_cksum);
+                        host = table[ntohs(packet.icp->icmp_seq) / packets];
                 } else {
                         memcpy(&data, &packet.icp6->icmp6_dataun.icmp6_un_data8[4], sizeof(data));
                         if (debug > 2)
-                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n",
-                                        (unsigned long)sizeof(data), ntohs(packet.icp6->icmp6_id),
-                                        ntohs(packet.icp6->icmp6_seq), packet.icp6->icmp6_cksum);
-                        host = table[ntohs(packet.icp6->icmp6_seq)/packets];
+                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n", (unsigned long)sizeof(data), ntohs(packet.icp6->icmp6_id),
+                                           ntohs(packet.icp6->icmp6_seq), packet.icp6->icmp6_cksum);
+                        host = table[ntohs(packet.icp6->icmp6_seq) / packets];
                 }
 
                 tdiff = get_timevaldiff(&data.stime, &now);
 
-                if (host->last_tdiff>0) {
+                if (host->last_tdiff > 0) {
                         /* Calculate jitter */
                         if (host->last_tdiff > tdiff) {
                                 jitter_tmp = host->last_tdiff - tdiff;
@@ -1022,29 +1034,29 @@ wait_for_reply(int sock, u_int t)
                                 jitter_tmp = tdiff - host->last_tdiff;
                         }
 
-                        if (host->jitter==0) {
-                                host->jitter=jitter_tmp;
-                                host->jitter_max=jitter_tmp;
-                                host->jitter_min=jitter_tmp;
+                        if (host->jitter == 0) {
+                                host->jitter = jitter_tmp;
+                                host->jitter_max = jitter_tmp;
+                                host->jitter_min = jitter_tmp;
                         } else {
-                                host->jitter+=jitter_tmp;
+                                host->jitter += jitter_tmp;
 
                                 if (jitter_tmp < host->jitter_min) {
-                                        host->jitter_min=jitter_tmp;
+                                        host->jitter_min = jitter_tmp;
                                 }
 
                                 if (jitter_tmp > host->jitter_max) {
-                                        host->jitter_max=jitter_tmp;
+                                        host->jitter_max = jitter_tmp;
                                 }
                         }
 
                         /* Check if packets in order */
                         if (host->last_icmp_seq >= packet.icp->icmp_seq)
-                                host->order_status=STATE_CRITICAL;
+                                host->order_status = STATE_CRITICAL;
                 }
-                host->last_tdiff=tdiff;
+                host->last_tdiff = tdiff;
 
-                host->last_icmp_seq=packet.icp->icmp_seq;
+                host->last_icmp_seq = packet.icp->icmp_seq;
 
                 host->time_waited += tdiff;
                 host->icmp_recv++;
@@ -1054,39 +1066,29 @@ wait_for_reply(int sock, u_int t)
                 if (tdiff < (unsigned int)host->rtmin)
                         host->rtmin = tdiff;
 
-                if(debug) {
+                if (debug) {
                         char address[INET6_ADDRSTRLEN];
                         parse_address(&resp_addr, address, sizeof(address));
 
-                        switch(address_family) {
-                                case AF_INET: {
-                                        printf("%0.3f ms rtt from %s, outgoing ttl: %u, incoming ttl: %u, max: %0.3f, min: %0.3f\n",
-                                                (float)tdiff / 1000,
-                                                address,
-                                                ttl,
-                                                ip->ip.ip_ttl,
-                                                (float)host->rtmax / 1000,
-                                                (float)host->rtmin / 1000);
-                                        break;
-                                          };
-                                case AF_INET6: {
-                                        printf("%0.3f ms rtt from %s, outgoing ttl: %u, max: %0.3f, min: %0.3f\n",
-                                                (float)tdiff / 1000,
-                                                address,
-                                                ttl,
-                                                (float)host->rtmax / 1000,
-                                                (float)host->rtmin / 1000);
-                                          };
-                           }
+                        switch (address_family) {
+                        case AF_INET: {
+                                printf("%0.3f ms rtt from %s, outgoing ttl: %u, incoming ttl: %u, max: %0.3f, min: %0.3f\n", (float)tdiff / 1000, address,
+                                           ttl, ip->ip.ip_ttl, (float)host->rtmax / 1000, (float)host->rtmin / 1000);
+                                break;
+                        };
+                        case AF_INET6: {
+                                printf("%0.3f ms rtt from %s, outgoing ttl: %u, max: %0.3f, min: %0.3f\n", (float)tdiff / 1000, address, ttl,
+                                           (float)host->rtmax / 1000, (float)host->rtmin / 1000);
+                        };
+                        }
                 }
 
                 /* if we're in hostcheck mode, exit with limited printouts */
-                if(mode == MODE_HOSTCHECK) {
+                if (mode == MODE_HOSTCHECK) {
                         printf("OK - %s responds to ICMP. Packet %u, rta %0.3fms|"
-                                "pkt=%u;;;0;%u rta=%0.3f;%0.3f;%0.3f;;\n",
-                                host->name, icmp_recv, (float)tdiff / 1000,
-                                icmp_recv, packets, (float)tdiff / 1000,
-                                (float)warn.rta / 1000, (float)crit.rta / 1000);
+                                   "pkt=%u;;;0;%u rta=%0.3f;%0.3f;%0.3f;;\n",
+                                   host->name, icmp_recv, (float)tdiff / 1000, icmp_recv, packets, (float)tdiff / 1000, (float)warn.rta / 1000,
+                                   (float)crit.rta / 1000);
                         exit(STATE_OK);
                 }
         }
@@ -1096,9 +1098,7 @@ wait_for_reply(int sock, u_int t)
 }
 
 /* the ping functions */
-static int
-send_icmp_ping(int sock, struct rta_host *host)
-{
+static int send_icmp_ping(int sock, struct rta_host *host) {
         long int len;
         size_t addrlen;
         struct icmp_ping_data data;
@@ -1107,22 +1107,21 @@ send_icmp_ping(int sock, struct rta_host *host)
         struct timeval tv;
         void *buf = NULL;
 
-        if(sock == -1) {
+        if (sock == -1) {
                 errno = 0;
                 crash("Attempt to send on bogus socket");
                 return -1;
         }
 
-        if(!buf) {
+        if (!buf) {
                 if (!(buf = malloc(icmp_pkt_size))) {
-                        crash("send_icmp_ping(): failed to malloc %d bytes for send buffer",
-                                  icmp_pkt_size);
-                        return -1;      /* might be reached if we're in debug mode */
+                        crash("send_icmp_ping(): failed to malloc %d bytes for send buffer", icmp_pkt_size);
+                        return -1; /* might be reached if we're in debug mode */
                 }
         }
         memset(buf, 0, icmp_pkt_size);
 
-        if((gettimeofday(&tv, &tz)) == -1) {
+        if ((gettimeofday(&tv, &tz)) == -1) {
                 free(buf);
                 return -1;
         }
@@ -1131,7 +1130,7 @@ send_icmp_ping(int sock, struct rta_host *host)
         memcpy(&data.stime, &tv, sizeof(tv));
 
         if (address_family == AF_INET) {
-                struct icmp *icp = (struct icmp*)buf;
+                struct icmp *icp = (struct icmp *)buf;
                 addrlen = sizeof(struct sockaddr_in);
 
                 memcpy(&icp->icmp_data, &data, sizeof(data));
@@ -1141,14 +1140,13 @@ send_icmp_ping(int sock, struct rta_host *host)
                 icp->icmp_cksum = 0;
                 icp->icmp_id = htons(pid);
                 icp->icmp_seq = htons(host->id++);
-                icp->icmp_cksum = icmp_checksum((uint16_t*)buf, (size_t)icmp_pkt_size);
+                icp->icmp_cksum = icmp_checksum((uint16_t *)buf, (size_t)icmp_pkt_size);
 
                 if (debug > 2)
-                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n",
-                                (unsigned long)sizeof(data), ntohs(icp->icmp_id), ntohs(icp->icmp_seq), icp->icmp_cksum, host->name);
-        }
-        else {
-                struct icmp6_hdr *icp6 = (struct icmp6_hdr*)buf;
+                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n", (unsigned long)sizeof(data),
+                                   ntohs(icp->icmp_id), ntohs(icp->icmp_seq), icp->icmp_cksum, host->name);
+        } else {
+                struct icmp6_hdr *icp6 = (struct icmp6_hdr *)buf;
                 addrlen = sizeof(struct sockaddr_in6);
 
                 memcpy(&icp6->icmp6_dataun.icmp6_un_data8[4], &data, sizeof(data));
@@ -1161,9 +1159,8 @@ send_icmp_ping(int sock, struct rta_host *host)
                 // let checksum be calculated automatically
 
                 if (debug > 2) {
-                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n",
-                                (unsigned long)sizeof(data), ntohs(icp6->icmp6_id),
-                                ntohs(icp6->icmp6_seq), icp6->icmp6_cksum, host->name);
+                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n", (unsigned long)sizeof(data),
+                                   ntohs(icp6->icmp6_id), ntohs(icp6->icmp6_seq), icp6->icmp6_cksum, host->name);
                 }
         }
 
@@ -1188,8 +1185,8 @@ send_icmp_ping(int sock, struct rta_host *host)
 
         free(buf);
 
-        if(len < 0 || (unsigned int)len != icmp_pkt_size) {
-                if(debug) {
+        if (len < 0 || (unsigned int)len != icmp_pkt_size) {
+                if (debug) {
                         char address[INET6_ADDRSTRLEN];
                         parse_address((struct sockaddr_storage *)&host->saddr_in, address, sizeof(address));
                         printf("Failed to send ping to %s: %s\n", address, strerror(errno));
@@ -1204,10 +1201,7 @@ send_icmp_ping(int sock, struct rta_host *host)
         return 0;
 }
 
-static int
-recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr,
-                         u_int *timo, struct timeval* tv)
-{
+static int recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr, u_int *timo, struct timeval *tv) {
         u_int slen;
         int n, ret;
         struct timeval to, then, now;
@@ -1218,11 +1212,12 @@ recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr,
         struct msghdr hdr;
         struct iovec iov;
 #ifdef SO_TIMESTAMP
-        struct cmsghdr* chdr;
+        struct cmsghdr *chdr;
 #endif
 
-        if(!*timo) {
-                if(debug) printf("*timo is not\n");
+        if (!*timo) {
+                if (debug)
+                        printf("*timo is not\n");
                 return 0;
         }
 
@@ -1235,11 +1230,13 @@ recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr,
         errno = 0;
         gettimeofday(&then, &tz);
         n = select(sock + 1, &rd, &wr, NULL, &to);
-        if(n < 0) crash("select() in recvfrom_wto");
+        if (n < 0)
+                crash("select() in recvfrom_wto");
         gettimeofday(&now, &tz);
         *timo = get_timevaldiff(&then, &now);
 
-        if(!n) return 0;                                /* timeout */
+        if (!n)
+                return 0; /* timeout */
 
         slen = sizeof(struct sockaddr_storage);
 
@@ -1259,12 +1256,10 @@ recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr,
 
         ret = recvmsg(sock, &hdr, 0);
 #ifdef SO_TIMESTAMP
-        for(chdr = CMSG_FIRSTHDR(&hdr); chdr; chdr = CMSG_NXTHDR(&hdr, chdr)) {
-                if(chdr->cmsg_level == SOL_SOCKET
-                   && chdr->cmsg_type == SO_TIMESTAMP
-                   && chdr->cmsg_len >= CMSG_LEN(sizeof(struct timeval))) {
+        for (chdr = CMSG_FIRSTHDR(&hdr); chdr; chdr = CMSG_NXTHDR(&hdr, chdr)) {
+                if (chdr->cmsg_level == SOL_SOCKET && chdr->cmsg_type == SO_TIMESTAMP && chdr->cmsg_len >= CMSG_LEN(sizeof(struct timeval))) {
                         memcpy(tv, CMSG_DATA(chdr), sizeof(*tv));
-                        break ;
+                        break;
                 }
         }
 
@@ -1274,54 +1269,55 @@ recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr,
         return (ret);
 }
 
-static void
-finish(int sig)
-{
+static void finish(int sig) {
         u_int i = 0;
         unsigned char pl;
         double rta;
         struct rta_host *host;
-        const char *status_string[] =
-        {"OK", "WARNING", "CRITICAL", "UNKNOWN", "DEPENDENT"};
+        const char *status_string[] = {"OK", "WARNING", "CRITICAL", "UNKNOWN", "DEPENDENT"};
         int hosts_ok = 0;
         int hosts_warn = 0;
         int this_status;
         double R;
 
         alarm(0);
-        if(debug > 1) printf("finish(%d) called\n", sig);
-
-        if(icmp_sock != -1) close(icmp_sock);
-        if(udp_sock != -1) close(udp_sock);
-        if(tcp_sock != -1) close(tcp_sock);
-
-        if(debug) {
-                printf("icmp_sent: %u  icmp_recv: %u  icmp_lost: %u\n",
-                           icmp_sent, icmp_recv, icmp_lost);
+        if (debug > 1)
+                printf("finish(%d) called\n", sig);
+
+        if (icmp_sock != -1)
+                close(icmp_sock);
+        if (udp_sock != -1)
+                close(udp_sock);
+        if (tcp_sock != -1)
+                close(tcp_sock);
+
+        if (debug) {
+                printf("icmp_sent: %u  icmp_recv: %u  icmp_lost: %u\n", icmp_sent, icmp_recv, icmp_lost);
                 printf("targets: %u  targets_alive: %u\n", targets, targets_alive);
         }
 
         /* iterate thrice to calculate values, give output, and print perfparse */
-        status=STATE_OK;
+        status = STATE_OK;
         host = list;
 
-        while(host) {
+        while (host) {
                 this_status = STATE_OK;
 
-                if(!host->icmp_recv) {
+                if (!host->icmp_recv) {
                         /* rta 0 is ofcourse not entirely correct, but will still show up
                          * conspicuously as missing entries in perfparse and cacti */
                         pl = 100;
                         rta = 0;
                         status = STATE_CRITICAL;
                         /* up the down counter if not already counted */
-                        if(!(host->flags & FLAG_LOST_CAUSE) && targets_alive) targets_down++;
+                        if (!(host->flags & FLAG_LOST_CAUSE) && targets_alive)
+                                targets_down++;
                 } else {
                         pl = ((host->icmp_sent - host->icmp_recv) * 100) / host->icmp_sent;
                         rta = (double)host->time_waited / host->icmp_recv;
                 }
 
-                if (host->icmp_recv>1) {
+                if (host->icmp_recv > 1) {
                         /*
                          * This algorithm is probably pretty much blindly copied from
                          * locations like this one: https://www.slac.stanford.edu/comp/net/wan-mon/tutorial.html#mos
@@ -1336,19 +1332,19 @@ finish(int sig)
                          * More links:
                          * - https://confluence.slac.stanford.edu/display/IEPM/MOS
                          */
-                        host->jitter=(host->jitter / (host->icmp_recv - 1)/1000);
+                        host->jitter = (host->jitter / (host->icmp_recv - 1) / 1000);
 
                         /*
                          * Take the average round trip latency (in milliseconds), add
                          * round trip jitter, but double the impact to latency
                          * then add 10 for protocol latencies (in milliseconds).
                          */
-                        host->EffectiveLatency = (rta/1000) + host->jitter * 2 + 10;
+                        host->EffectiveLatency = (rta / 1000) + host->jitter * 2 + 10;
 
                         if (host->EffectiveLatency < 160) {
-                           R = 93.2 - (host->EffectiveLatency / 40);
+                                R = 93.2 - (host->EffectiveLatency / 40);
                         } else {
-                           R = 93.2 - ((host->EffectiveLatency - 120) / 10);
+                                R = 93.2 - ((host->EffectiveLatency - 120) / 10);
                         }
 
                         // Now, let us deduct 2.5 R values per percentage of packet loss (i.e. a
@@ -1360,12 +1356,12 @@ finish(int sig)
                         }
 
                         host->score = R;
-                        host->mos= 1 + ((0.035) * R) + ((.000007) * R * (R-60) * (100-R));
+                        host->mos = 1 + ((0.035) * R) + ((.000007) * R * (R - 60) * (100 - R));
                 } else {
-                        host->jitter=0;
-                        host->jitter_min=0;
-                        host->jitter_max=0;
-                        host->mos=0;
+                        host->jitter = 0;
+                        host->jitter_min = 0;
+                        host->jitter_max = 0;
+                        host->mos = 0;
                 }
 
                 host->pl = pl;
@@ -1379,62 +1375,62 @@ finish(int sig)
 
                 /* Check which mode is on and do the warn / Crit stuff */
                 if (rta_mode) {
-                        if(rta >= crit.rta) {
+                        if (rta >= crit.rta) {
                                 this_status = STATE_CRITICAL;
                                 status = STATE_CRITICAL;
-                                host->rta_status=STATE_CRITICAL;
-                        } else if(status!=STATE_CRITICAL && (rta >= warn.rta)) {
+                                host->rta_status = STATE_CRITICAL;
+                        } else if (status != STATE_CRITICAL && (rta >= warn.rta)) {
                                 this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
                                 status = STATE_WARNING;
-                                host->rta_status=STATE_WARNING;
+                                host->rta_status = STATE_WARNING;
                         }
                 }
 
                 if (pl_mode) {
-                        if(pl >= crit.pl) {
+                        if (pl >= crit.pl) {
                                 this_status = STATE_CRITICAL;
                                 status = STATE_CRITICAL;
-                                host->pl_status=STATE_CRITICAL;
-                        } else if(status!=STATE_CRITICAL && (pl >= warn.pl)) {
+                                host->pl_status = STATE_CRITICAL;
+                        } else if (status != STATE_CRITICAL && (pl >= warn.pl)) {
                                 this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
                                 status = STATE_WARNING;
-                                host->pl_status=STATE_WARNING;
+                                host->pl_status = STATE_WARNING;
                         }
                 }
 
                 if (jitter_mode) {
-                        if(host->jitter >= crit.jitter) {
+                        if (host->jitter >= crit.jitter) {
                                 this_status = STATE_CRITICAL;
                                 status = STATE_CRITICAL;
-                                host->jitter_status=STATE_CRITICAL;
-                        } else if(status!=STATE_CRITICAL && (host->jitter >= warn.jitter)) {
+                                host->jitter_status = STATE_CRITICAL;
+                        } else if (status != STATE_CRITICAL && (host->jitter >= warn.jitter)) {
                                 this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
                                 status = STATE_WARNING;
-                                host->jitter_status=STATE_WARNING;
+                                host->jitter_status = STATE_WARNING;
                         }
                 }
 
                 if (mos_mode) {
-                        if(host->mos <= crit.mos) {
+                        if (host->mos <= crit.mos) {
                                 this_status = STATE_CRITICAL;
                                 status = STATE_CRITICAL;
-                                host->mos_status=STATE_CRITICAL;
-                        } else if(status!=STATE_CRITICAL && (host->mos <= warn.mos)) {
+                                host->mos_status = STATE_CRITICAL;
+                        } else if (status != STATE_CRITICAL && (host->mos <= warn.mos)) {
                                 this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
                                 status = STATE_WARNING;
-                                host->mos_status=STATE_WARNING;
+                                host->mos_status = STATE_WARNING;
                         }
                 }
 
                 if (score_mode) {
-                        if(host->score <= crit.score) {
+                        if (host->score <= crit.score) {
                                 this_status = STATE_CRITICAL;
                                 status = STATE_CRITICAL;
-                                host->score_status=STATE_CRITICAL;
-                        } else if(status!=STATE_CRITICAL && (host->score <= warn.score)) {
+                                host->score_status = STATE_CRITICAL;
+                        } else if (status != STATE_CRITICAL && (host->score <= warn.score)) {
                                 this_status = (this_status <= STATE_WARNING ? STATE_WARNING : this_status);
                                 status = STATE_WARNING;
-                                host->score_status=STATE_WARNING;
+                                host->score_status = STATE_WARNING;
                         }
                 }
 
@@ -1447,91 +1443,92 @@ finish(int sig)
                 host = host->next;
         }
 
-
         /* this is inevitable */
-        if(!targets_alive) status = STATE_CRITICAL;
-        if(min_hosts_alive > -1) {
-                if(hosts_ok >= min_hosts_alive) status = STATE_OK;
-                else if((hosts_ok + hosts_warn) >= min_hosts_alive) status = STATE_WARNING;
+        if (!targets_alive)
+                status = STATE_CRITICAL;
+        if (min_hosts_alive > -1) {
+                if (hosts_ok >= min_hosts_alive)
+                        status = STATE_OK;
+                else if ((hosts_ok + hosts_warn) >= min_hosts_alive)
+                        status = STATE_WARNING;
         }
         printf("%s - ", status_string[status]);
 
         host = list;
-        while(host) {
-
-                if(debug) puts("");
-                if(i) {
-                        if(i < targets) printf(" :: ");
-                        else printf("\n");
+        while (host) {
+
+                if (debug)
+                        puts("");
+                if (i) {
+                        if (i < targets)
+                                printf(" :: ");
+                        else
+                                printf("\n");
                 }
                 i++;
-                if(!host->icmp_recv) {
+                if (!host->icmp_recv) {
                         status = STATE_CRITICAL;
-                        host->rtmin=0;
-                        host->jitter_min=0;
-                        if(host->flags & FLAG_LOST_CAUSE) {
+                        host->rtmin = 0;
+                        host->jitter_min = 0;
+                        if (host->flags & FLAG_LOST_CAUSE) {
                                 char address[INET6_ADDRSTRLEN];
                                 parse_address(&host->error_addr, address, sizeof(address));
-                                printf("%s: %s @ %s. rta nan, lost %d%%",
-                                           host->name,
-                                           get_icmp_error_msg(host->icmp_type, host->icmp_code),
-                                           address,
-                                           100);
+                                printf("%s: %s @ %s. rta nan, lost %d%%", host->name, get_icmp_error_msg(host->icmp_type, host->icmp_code), address, 100);
                         } else { /* not marked as lost cause, so we have no flags for it */
                                 printf("%s: rta nan, lost 100%%", host->name);
                         }
-                } else {        /* !icmp_recv */
+                } else { /* !icmp_recv */
                         printf("%s", host->name);
                         /* rta text output */
                         if (rta_mode) {
                                 if (status == STATE_OK)
                                         printf(" rta %0.3fms", host->rta / 1000);
-                                else if (status==STATE_WARNING && host->rta_status==status)
-                                        printf(" rta %0.3fms > %0.3fms", (float)host->rta / 1000, (float)warn.rta/1000);
-                                else if (status==STATE_CRITICAL && host->rta_status==status)
-                                        printf(" rta %0.3fms > %0.3fms", (float)host->rta / 1000, (float)crit.rta/1000);
+                                else if (status == STATE_WARNING && host->rta_status == status)
+                                        printf(" rta %0.3fms > %0.3fms", (float)host->rta / 1000, (float)warn.rta / 1000);
+                                else if (status == STATE_CRITICAL && host->rta_status == status)
+                                        printf(" rta %0.3fms > %0.3fms", (float)host->rta / 1000, (float)crit.rta / 1000);
                         }
                         /* pl text output */
                         if (pl_mode) {
                                 if (status == STATE_OK)
                                         printf(" lost %u%%", host->pl);
-                                else if (status==STATE_WARNING && host->pl_status==status)
+                                else if (status == STATE_WARNING && host->pl_status == status)
                                         printf(" lost %u%% > %u%%", host->pl, warn.pl);
-                                else if (status==STATE_CRITICAL && host->pl_status==status)
+                                else if (status == STATE_CRITICAL && host->pl_status == status)
                                         printf(" lost %u%% > %u%%", host->pl, crit.pl);
                         }
                         /* jitter text output */
                         if (jitter_mode) {
                                 if (status == STATE_OK)
                                         printf(" jitter %0.3fms", (float)host->jitter);
-                                else if (status==STATE_WARNING && host->jitter_status==status)
+                                else if (status == STATE_WARNING && host->jitter_status == status)
                                         printf(" jitter %0.3fms > %0.3fms", (float)host->jitter, warn.jitter);
-                                else if (status==STATE_CRITICAL && host->jitter_status==status)
+                                else if (status == STATE_CRITICAL && host->jitter_status == status)
                                         printf(" jitter %0.3fms > %0.3fms", (float)host->jitter, crit.jitter);
                         }
                         /* mos text output */
                         if (mos_mode) {
                                 if (status == STATE_OK)
                                         printf(" MOS %0.1f", (float)host->mos);
-                                else if (status==STATE_WARNING && host->mos_status==status)
+                                else if (status == STATE_WARNING && host->mos_status == status)
                                         printf(" MOS %0.1f < %0.1f", (float)host->mos, (float)warn.mos);
-                                else if (status==STATE_CRITICAL && host->mos_status==status)
+                                else if (status == STATE_CRITICAL && host->mos_status == status)
                                         printf(" MOS %0.1f < %0.1f", (float)host->mos, (float)crit.mos);
                         }
                         /* score text output */
                         if (score_mode) {
                                 if (status == STATE_OK)
                                         printf(" Score %u", (int)host->score);
-                                else if (status==STATE_WARNING && host->score_status==status )
+                                else if (status == STATE_WARNING && host->score_status == status)
                                         printf(" Score %u < %u", (int)host->score, (int)warn.score);
-                                else if (status==STATE_CRITICAL && host->score_status==status )
+                                else if (status == STATE_CRITICAL && host->score_status == status)
                                         printf(" Score %u < %u", (int)host->score, (int)crit.score);
                         }
                         /* order statis text output */
                         if (order_mode) {
                                 if (status == STATE_OK)
                                         printf(" Packets in order");
-                                else if (status==STATE_CRITICAL && host->order_status==status)
+                                else if (status == STATE_CRITICAL && host->order_status == status)
                                         printf(" Packets out of order");
                         }
                 }
@@ -1540,25 +1537,23 @@ finish(int sig)
 
         /* iterate once more for pretty perfparse output */
         if (!(!rta_mode && !pl_mode && !jitter_mode && !score_mode && !mos_mode && order_mode)) {
-                        printf("|");
+                printf("|");
         }
         i = 0;
         host = list;
-        while(host) {
-                if(debug) puts("");
+        while (host) {
+                if (debug)
+                        puts("");
 
                 if (rta_mode) {
-                        if (host->pl<100) {
-                                printf("%srta=%0.3fms;%0.3f;%0.3f;0; %srtmax=%0.3fms;;;; %srtmin=%0.3fms;;;; ",
-                                        (targets > 1) ? host->name : "",
-                                        host->rta / 1000, (float)warn.rta / 1000, (float)crit.rta / 1000,
-                                        (targets > 1) ? host->name : "", (float)host->rtmax / 1000,
-                                        (targets > 1) ? host->name : "", (host->rtmin < INFINITY) ? (float)host->rtmin / 1000 : (float)0);
+                        if (host->pl < 100) {
+                                printf("%srta=%0.3fms;%0.3f;%0.3f;0; %srtmax=%0.3fms;;;; %srtmin=%0.3fms;;;; ", (targets > 1) ? host->name : "",
+                                           host->rta / 1000, (float)warn.rta / 1000, (float)crit.rta / 1000, (targets > 1) ? host->name : "",
+                                           (float)host->rtmax / 1000, (targets > 1) ? host->name : "",
+                                           (host->rtmin < INFINITY) ? (float)host->rtmin / 1000 : (float)0);
                         } else {
-                                printf("%srta=U;;;; %srtmax=U;;;; %srtmin=U;;;; ",
-                                        (targets > 1) ? host->name : "",
-                                        (targets > 1) ? host->name : "",
-                                        (targets > 1) ? host->name : "");
+                                printf("%srta=U;;;; %srtmax=U;;;; %srtmin=U;;;; ", (targets > 1) ? host->name : "", (targets > 1) ? host->name : "",
+                                           (targets > 1) ? host->name : "");
                         }
                 }
 
@@ -1567,43 +1562,28 @@ finish(int sig)
                 }
 
                 if (jitter_mode) {
-                        if (host->pl<100) {
+                        if (host->pl < 100) {
                                 printf("%sjitter_avg=%0.3fms;%0.3f;%0.3f;0; %sjitter_max=%0.3fms;;;; %sjitter_min=%0.3fms;;;; ",
-                                        (targets > 1) ? host->name : "",
-                                        (float)host->jitter,
-                                        (float)warn.jitter,
-                                        (float)crit.jitter,
-                                        (targets > 1) ? host->name : "",
-                                        (float)host->jitter_max / 1000, (targets > 1) ? host->name : "",
-                                        (float)host->jitter_min / 1000
-                                );
+                                           (targets > 1) ? host->name : "", (float)host->jitter, (float)warn.jitter, (float)crit.jitter,
+                                           (targets > 1) ? host->name : "", (float)host->jitter_max / 1000, (targets > 1) ? host->name : "",
+                                           (float)host->jitter_min / 1000);
                         } else {
-                                printf("%sjitter_avg=U;;;; %sjitter_max=U;;;; %sjitter_min=U;;;; ",
-                                        (targets > 1) ? host->name : "",
-                                        (targets > 1) ? host->name : "",
-                                        (targets > 1) ? host->name : "");
+                                printf("%sjitter_avg=U;;;; %sjitter_max=U;;;; %sjitter_min=U;;;; ", (targets > 1) ? host->name : "",
+                                           (targets > 1) ? host->name : "", (targets > 1) ? host->name : "");
                         }
                 }
 
                 if (mos_mode) {
-                        if (host->pl<100) {
-                                printf("%smos=%0.1f;%0.1f;%0.1f;0;5 ",
-                                        (targets > 1) ? host->name : "",
-                                        (float)host->mos,
-                                        (float)warn.mos,
-                                        (float)crit.mos);
+                        if (host->pl < 100) {
+                                printf("%smos=%0.1f;%0.1f;%0.1f;0;5 ", (targets > 1) ? host->name : "", (float)host->mos, (float)warn.mos, (float)crit.mos);
                         } else {
                                 printf("%smos=U;;;; ", (targets > 1) ? host->name : "");
                         }
                 }
 
                 if (score_mode) {
-                        if (host->pl<100) {
-                                printf("%sscore=%u;%u;%u;0;100 ",
-                                        (targets > 1) ? host->name : "",
-                                        (int)host->score,
-                                        (int)warn.score,
-                                        (int)crit.score);
+                        if (host->pl < 100) {
+                                printf("%sscore=%u;%u;%u;0;100 ", (targets > 1) ? host->name : "", (int)host->score, (int)warn.score, (int)crit.score);
                         } else {
                                 printf("%sscore=U;;;; ", (targets > 1) ? host->name : "");
                         }
@@ -1612,35 +1592,35 @@ finish(int sig)
                 host = host->next;
         }
 
-        if(min_hosts_alive > -1) {
-                if(hosts_ok >= min_hosts_alive) status = STATE_OK;
-                else if((hosts_ok + hosts_warn) >= min_hosts_alive) status = STATE_WARNING;
+        if (min_hosts_alive > -1) {
+                if (hosts_ok >= min_hosts_alive)
+                        status = STATE_OK;
+                else if ((hosts_ok + hosts_warn) >= min_hosts_alive)
+                        status = STATE_WARNING;
         }
 
         /* finish with an empty line */
         puts("");
-        if(debug) printf("targets: %u, targets_alive: %u, hosts_ok: %u, hosts_warn: %u, min_hosts_alive: %i\n",
-                                         targets, targets_alive, hosts_ok, hosts_warn, min_hosts_alive);
+        if (debug)
+                printf("targets: %u, targets_alive: %u, hosts_ok: %u, hosts_warn: %u, min_hosts_alive: %i\n", targets, targets_alive, hosts_ok,
+                           hosts_warn, min_hosts_alive);
 
         exit(status);
 }
 
-static u_int
-get_timevaldiff(struct timeval *early, struct timeval *later)
-{
+static u_int get_timevaldiff(struct timeval *early, struct timeval *later) {
         u_int ret;
         struct timeval now;
 
-        if(!later) {
+        if (!later) {
                 gettimeofday(&now, &tz);
                 later = &now;
         }
-        if(!early) early = &prog_start;
+        if (!early)
+                early = &prog_start;
 
         /* if early > later we return 0 so as to indicate a timeout */
-        if(early->tv_sec > later->tv_sec ||
-           (early->tv_sec == later->tv_sec && early->tv_usec > later->tv_usec))
-        {
+        if (early->tv_sec > later->tv_sec || (early->tv_sec == later->tv_sec && early->tv_usec > later->tv_usec)) {
                 return 0;
         }
         ret = (later->tv_sec - early->tv_sec) * 1000000;
@@ -1649,9 +1629,7 @@ get_timevaldiff(struct timeval *early, struct timeval *later)
         return ret;
 }
 
-static int
-add_target_ip(char *arg, struct sockaddr_storage *in)
-{
+static int add_target_ip(char *arg, struct sockaddr_storage *in) {
         struct rta_host *host;
         struct sockaddr_in *sin, *host_sin;
         struct sockaddr_in6 *sin6, *host_sin6;
@@ -1661,51 +1639,46 @@ add_target_ip(char *arg, struct sockaddr_storage *in)
         else
                 sin6 = (struct sockaddr_in6 *)in;
 
-
-
         /* disregard obviously stupid addresses
          * (I didn't find an ipv6 equivalent to INADDR_NONE) */
-        if (((address_family == AF_INET && (sin->sin_addr.s_addr == INADDR_NONE
-                                        || sin->sin_addr.s_addr == INADDR_ANY)))
-                || (address_family == AF_INET6 && (sin6->sin6_addr.s6_addr == in6addr_any.s6_addr))) {
+        if (((address_family == AF_INET && (sin->sin_addr.s_addr == INADDR_NONE || sin->sin_addr.s_addr == INADDR_ANY))) ||
+                (address_family == AF_INET6 && (sin6->sin6_addr.s6_addr == in6addr_any.s6_addr))) {
                 return -1;
         }
 
         /* no point in adding two identical IP's, so don't. ;) */
         host = list;
-        while(host) {
+        while (host) {
                 host_sin = (struct sockaddr_in *)&host->saddr_in;
                 host_sin6 = (struct sockaddr_in6 *)&host->saddr_in;
 
-                if(   (address_family == AF_INET && host_sin->sin_addr.s_addr == sin->sin_addr.s_addr)
-                   || (address_family == AF_INET6 && host_sin6->sin6_addr.s6_addr == sin6->sin6_addr.s6_addr)) {
-                        if(debug) printf("Identical IP already exists. Not adding %s\n", arg);
+                if ((address_family == AF_INET && host_sin->sin_addr.s_addr == sin->sin_addr.s_addr) ||
+                        (address_family == AF_INET6 && host_sin6->sin6_addr.s6_addr == sin6->sin6_addr.s6_addr)) {
+                        if (debug)
+                                printf("Identical IP already exists. Not adding %s\n", arg);
                         return -1;
                 }
                 host = host->next;
         }
 
         /* add the fresh ip */
-        host = (struct rta_host*)malloc(sizeof(struct rta_host));
-        if(!host) {
+        host = (struct rta_host *)malloc(sizeof(struct rta_host));
+        if (!host) {
                 char straddr[INET6_ADDRSTRLEN];
-                parse_address((struct sockaddr_storage*)&in, straddr, sizeof(straddr));
-                crash("add_target_ip(%s, %s): malloc(%lu) failed",
-                        arg, straddr, sizeof(struct rta_host));
+                parse_address((struct sockaddr_storage *)&in, straddr, sizeof(straddr));
+                crash("add_target_ip(%s, %s): malloc(%lu) failed", arg, straddr, sizeof(struct rta_host));
         }
         memset(host, 0, sizeof(struct rta_host));
 
         /* set the values. use calling name for output */
         host->name = strdup(arg);
 
-
         /* fill out the sockaddr_storage struct */
-        if(address_family == AF_INET) {
+        if (address_family == AF_INET) {
                 host_sin = (struct sockaddr_in *)&host->saddr_in;
                 host_sin->sin_family = AF_INET;
                 host_sin->sin_addr.s_addr = sin->sin_addr.s_addr;
-        }
-        else {
+        } else {
                 host_sin6 = (struct sockaddr_in6 *)&host->saddr_in;
                 host_sin6->sin6_family = AF_INET6;
                 memcpy(host_sin6->sin6_addr.s6_addr, sin6->sin6_addr.s6_addr, sizeof host_sin6->sin6_addr.s6_addr);
@@ -1714,22 +1687,23 @@ add_target_ip(char *arg, struct sockaddr_storage *in)
         /* fill out the sockaddr_in struct */
         host->rtmin = INFINITY;
         host->rtmax = 0;
-        host->jitter=0;
-        host->jitter_max=0;
-        host->jitter_min=INFINITY;
-        host->last_tdiff=0;
-        host->order_status=STATE_OK;
-        host->last_icmp_seq=0;
-        host->rta_status=0;
-        host->pl_status=0;
-        host->jitter_status=0;
-        host->mos_status=0;
-        host->score_status=0;
-        host->pl_status=0;
-
-
-        if(!list) list = cursor = host;
-        else cursor->next = host;
+        host->jitter = 0;
+        host->jitter_max = 0;
+        host->jitter_min = INFINITY;
+        host->last_tdiff = 0;
+        host->order_status = STATE_OK;
+        host->last_icmp_seq = 0;
+        host->rta_status = 0;
+        host->pl_status = 0;
+        host->jitter_status = 0;
+        host->mos_status = 0;
+        host->score_status = 0;
+        host->pl_status = 0;
+
+        if (!list)
+                list = cursor = host;
+        else
+                cursor->next = host;
 
         cursor = host;
         targets++;
@@ -1738,9 +1712,7 @@ add_target_ip(char *arg, struct sockaddr_storage *in)
 }
 
 /* wrapper for add_target_ip */
-static int
-add_target(char *arg)
-{
+static int add_target(char *arg) {
         int error, result = -1;
         struct sockaddr_storage ip;
         struct addrinfo hints, *res, *p;
@@ -1754,14 +1726,14 @@ add_target(char *arg)
                 sin = (struct sockaddr_in *)&ip;
                 result = inet_pton(address_family, arg, &sin->sin_addr);
 #ifdef USE_IPV6
-                if( result != 1 ){
+                if (result != 1) {
                         address_family = AF_INET6;
                         sin6 = (struct sockaddr_in6 *)&ip;
                         result = inet_pton(address_family, arg, &sin6->sin6_addr);
                 }
 #endif
                 /* If we don't find any valid addresses, we still don't know the address_family */
-                if ( result != 1) {
+                if (result != 1) {
                         address_family = -1;
                 }
                 break;
@@ -1773,15 +1745,15 @@ add_target(char *arg)
                 sin6 = (struct sockaddr_in6 *)&ip;
                 result = inet_pton(address_family, arg, &sin6->sin6_addr);
                 break;
-        default: crash("Address family not supported");
+        default:
+                crash("Address family not supported");
         }
 
         /* don't resolve if we don't have to */
-        if(result == 1) {
+        if (result == 1) {
                 /* don't add all ip's if we were given a specific one */
                 return add_target_ip(arg, &ip);
-        }
-        else {
+        } else {
                 errno = 0;
                 memset(&hints, 0, sizeof(hints));
                 if (address_family == -1) {
@@ -1790,7 +1762,7 @@ add_target(char *arg)
                         hints.ai_family = address_family == AF_INET ? PF_INET : PF_INET6;
                 }
                 hints.ai_socktype = SOCK_RAW;
-                if((error = getaddrinfo(arg, NULL, &hints, &res)) != 0) {
+                if ((error = getaddrinfo(arg, NULL, &hints, &res)) != 0) {
                         errno = 0;
                         crash("Failed to resolve %s: %s", arg, gai_strerror(error));
                         return -1;
@@ -1799,13 +1771,14 @@ add_target(char *arg)
         }
 
         /* possibly add all the IP's as targets */
-        for(p = res; p != NULL; p = p->ai_next) {
+        for (p = res; p != NULL; p = p->ai_next) {
                 memcpy(&ip, p->ai_addr, p->ai_addrlen);
                 add_target_ip(arg, &ip);
 
                 /* this is silly, but it works */
-                if(mode == MODE_HOSTCHECK || mode == MODE_ALL) {
-                        if(debug > 2) printf("mode: %d\n", mode);
+                if (mode == MODE_HOSTCHECK || mode == MODE_ALL) {
+                        if (debug > 2)
+                                printf("mode: %d\n", mode);
                         continue;
                 }
                 break;
@@ -1815,24 +1788,20 @@ add_target(char *arg)
         return 0;
 }
 
-static void
-set_source_ip(char *arg)
-{
+static void set_source_ip(char *arg) {
         struct sockaddr_in src;
 
         memset(&src, 0, sizeof(src));
         src.sin_family = address_family;
-        if((src.sin_addr.s_addr = inet_addr(arg)) == INADDR_NONE)
+        if ((src.sin_addr.s_addr = inet_addr(arg)) == INADDR_NONE)
                 src.sin_addr.s_addr = get_ip_address(arg);
-        if(bind(icmp_sock, (struct sockaddr *)&src, sizeof(src)) == -1)
+        if (bind(icmp_sock, (struct sockaddr *)&src, sizeof(src)) == -1)
                 crash("Cannot bind to IP address %s", arg);
 }
 
 /* TODO: Move this to netutils.c and also change check_dhcp to use that. */
-static in_addr_t
-get_ip_address(const char *ifname)
-{
-  // TODO: Rewrite this so the function return an error and we exit somewhere else
+static in_addr_t get_ip_address(const char *ifname) {
+        // TODO: Rewrite this so the function return an error and we exit somewhere else
         struct sockaddr_in ip;
         ip.sin_addr.s_addr = 0; // Fake initialization to make compiler happy
 #if defined(SIOCGIFADDR)
@@ -1842,12 +1811,12 @@ get_ip_address(const char *ifname)
 
         ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 
-        if(ioctl(icmp_sock, SIOCGIFADDR, &ifr) == -1)
+        if (ioctl(icmp_sock, SIOCGIFADDR, &ifr) == -1)
                 crash("Cannot determine IP address of interface %s", ifname);
 
         memcpy(&ip, &ifr.ifr_addr, sizeof(ip));
 #else
-        (void) ifname;
+        (void)ifname;
         errno = 0;
         crash("Cannot get interface IP address on this platform.");
 #endif
@@ -1860,63 +1829,73 @@ get_ip_address(const char *ifname)
  * s = seconds
  * return value is in microseconds
  */
-static u_int
-get_timevar(const char *str)
-{
+static u_int get_timevar(const char *str) {
         char p, u, *ptr;
         size_t len;
-        u_int i, d;                 /* integer and decimal, respectively */
-        u_int factor = 1000;    /* default to milliseconds */
+        u_int i, d;          /* integer and decimal, respectively */
+        u_int factor = 1000; /* default to milliseconds */
 
-        if(!str) return 0;
+        if (!str)
+                return 0;
         len = strlen(str);
-        if(!len) return 0;
+        if (!len)
+                return 0;
 
         /* unit might be given as ms|m (millisec),
          * us|u (microsec) or just plain s, for seconds */
         p = '\0';
         u = str[len - 1];
-        if(len >= 2 && !isdigit((int)str[len - 2])) p = str[len - 2];
-        if(p && u == 's') u = p;
-        else if(!p) p = u;
-        if(debug > 2) printf("evaluating %s, u: %c, p: %c\n", str, u, p);
-
-        if(u == 'u') factor = 1;            /* microseconds */
-        else if(u == 'm') factor = 1000;        /* milliseconds */
-        else if(u == 's') factor = 1000000;     /* seconds */
-        if(debug > 2) printf("factor is %u\n", factor);
+        if (len >= 2 && !isdigit((int)str[len - 2]))
+                p = str[len - 2];
+        if (p && u == 's')
+                u = p;
+        else if (!p)
+                p = u;
+        if (debug > 2)
+                printf("evaluating %s, u: %c, p: %c\n", str, u, p);
+
+        if (u == 'u')
+                factor = 1; /* microseconds */
+        else if (u == 'm')
+                factor = 1000; /* milliseconds */
+        else if (u == 's')
+                factor = 1000000; /* seconds */
+        if (debug > 2)
+                printf("factor is %u\n", factor);
 
         i = strtoul(str, &ptr, 0);
-        if(!ptr || *ptr != '.' || strlen(ptr) < 2 || factor == 1)
+        if (!ptr || *ptr != '.' || strlen(ptr) < 2 || factor == 1)
                 return i * factor;
 
         /* time specified in usecs can't have decimal points, so ignore them */
-        if(factor == 1) return i;
+        if (factor == 1)
+                return i;
 
         d = strtoul(ptr + 1, NULL, 0);
 
         /* d is decimal, so get rid of excess digits */
-        while(d >= factor) d /= 10;
+        while (d >= factor)
+                d /= 10;
 
         /* the last parenthesis avoids floating point exceptions. */
         return ((i * factor) + (d * (factor / 10)));
 }
 
 /* not too good at checking errors, but it'll do (main() should barfe on -1) */
-static int
-get_threshold(char *str, threshold *th)
-{
+static int get_threshold(char *str, threshold *th) {
         char *p = NULL, i = 0;
 
-        if(!str || !strlen(str) || !th) return -1;
+        if (!str || !strlen(str) || !th)
+                return -1;
 
         /* pointer magic slims code by 10 lines. i is bof-stop on stupid libc's */
         p = &str[strlen(str) - 1];
-        while(p != &str[1]) {
-                if(*p == '%') *p = '\0';
-                else if(*p == ',' && i) {
-                        *p = '\0';      /* reset it so get_timevar(str) works nicely later */
-                        th->pl = (unsigned char)strtoul(p+1, NULL, 0);
+        while (p != &str[1]) {
+                if (*p == '%')
+                        *p = '\0';
+                else if (*p == ',' && i) {
+                        *p = '\0'; /* reset it so get_timevar(str) works nicely later */
+                        th->pl = (unsigned char)strtoul(p + 1, NULL, 0);
                         break;
                 }
                 i = 1;
@@ -1924,10 +1903,13 @@ get_threshold(char *str, threshold *th)
         }
         th->rta = get_timevar(str);
 
-        if(!th->rta) return -1;
+        if (!th->rta)
+                return -1;
 
-        if(th->rta > MAXTTL * 1000000) th->rta = MAXTTL * 1000000;
-        if(th->pl > 100) th->pl = 100;
+        if (th->rta > MAXTTL * 1000000)
+                th->rta = MAXTTL * 1000000;
+        if (th->pl > 100)
+                th->pl = 100;
 
         return 0;
 }
@@ -1943,8 +1925,8 @@ get_threshold(char *str, threshold *th)
  * @param[in] mode Determines whether this a threshold for rta, packet_loss, jitter, mos or score (exclusively)
  */
 static bool get_threshold2(char *str, size_t length, threshold *warn, threshold *crit, threshold_mode mode) {
-        if (!str || !length || !warn || !crit) return false;
-
+        if (!str || !length || !warn || !crit)
+                return false;
 
         // p points to the last char in str
         char *p = &str[length - 1];
@@ -1952,18 +1934,17 @@ static bool get_threshold2(char *str, size_t length, threshold *warn, threshold
         // first_iteration is bof-stop on stupid libc's
         bool first_iteration = true;
 
-        while(p != &str[0]) {
-                if( (*p == 'm') || (*p == '%') ) {
+        while (p != &str[0]) {
+                if ((*p == 'm') || (*p == '%')) {
                         *p = '\0';
-                } else if(*p == ',' && !first_iteration) {
-                        *p = '\0';      /* reset it so get_timevar(str) works nicely later */
+                } else if (*p == ',' && !first_iteration) {
+                        *p = '\0'; /* reset it so get_timevar(str) works nicely later */
 
                         char *start_of_value = p + 1;
 
-                        if (!parse_threshold2_helper(start_of_value, strlen(start_of_value), crit, mode)){
+                        if (!parse_threshold2_helper(start_of_value, strlen(start_of_value), crit, mode)) {
                                 return false;
                         }
-
                 }
                 first_iteration = false;
                 p--;
@@ -1976,22 +1957,22 @@ static bool parse_threshold2_helper(char *s, size_t length, threshold *thr, thre
         char *resultChecker = {0};
 
         switch (mode) {
-                case const_rta_mode:
-                        thr->rta = strtod(s, &resultChecker) * 1000;
-                        break;
-                case const_packet_loss_mode:
-                        thr->pl = (unsigned char)strtoul(s, &resultChecker, 0);
-                        break;
-                case const_jitter_mode:
-                        thr->jitter = strtod(s, &resultChecker);
+        case const_rta_mode:
+                thr->rta = strtod(s, &resultChecker) * 1000;
+                break;
+        case const_packet_loss_mode:
+                thr->pl = (unsigned char)strtoul(s, &resultChecker, 0);
+                break;
+        case const_jitter_mode:
+                thr->jitter = strtod(s, &resultChecker);
 
-                        break;
-                case const_mos_mode:
-                        thr->mos = strtod(s, &resultChecker);
-                        break;
-                case const_score_mode:
-                        thr->score = strtod(s, &resultChecker);
-                        break;
+                break;
+        case const_mos_mode:
+                thr->mos = strtod(s, &resultChecker);
+                break;
+        case const_score_mode:
+                thr->score = strtod(s, &resultChecker);
+                break;
         }
 
         if (resultChecker == s) {
@@ -2007,123 +1988,116 @@ static bool parse_threshold2_helper(char *s, size_t length, threshold *thr, thre
         return true;
 }
 
-unsigned short
-icmp_checksum(uint16_t *p, size_t n)
-{
+unsigned short icmp_checksum(uint16_t *p, size_t n) {
         unsigned short cksum;
         long sum = 0;
 
         /* sizeof(uint16_t) == 2 */
-        while(n >= 2) {
+        while (n >= 2) {
                 sum += *(p++);
                 n -= 2;
         }
 
         /* mop up the occasional odd byte */
-        if(n == 1) sum += *((uint8_t *)p -1);
+        if (n == 1)
+                sum += *((uint8_t *)p - 1);
 
-        sum = (sum >> 16) + (sum & 0xffff);     /* add hi 16 to low 16 */
-        sum += (sum >> 16);                     /* add carry */
-        cksum = ~sum;                           /* ones-complement, trunc to 16 bits */
+        sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
+        sum += (sum >> 16);                 /* add carry */
+        cksum = ~sum;                       /* ones-complement, trunc to 16 bits */
 
         return cksum;
 }
 
-void
-print_help(void)
-{
+void print_help(void) {
         /*print_revision (progname);*/ /* FIXME: Why? */
-        printf ("Copyright (c) 2005 Andreas Ericsson <ae@op5.se>\n");
-
-        printf (COPYRIGHT, copyright, email);
-
-        printf ("\n\n");
-
-        print_usage ();
-
-        printf (UT_HELP_VRSN);
-        printf (UT_EXTRA_OPTS);
-
-        printf (" %s\n", "-H");
-        printf ("    %s\n", _("specify a target"));
-        printf (" %s\n", "[-4|-6]");
-        printf ("    %s\n", _("Use IPv4 (default) or IPv6 to communicate with the targets"));
-        printf (" %s\n", "-w");
-        printf ("    %s", _("warning threshold (currently "));
-        printf ("%0.3fms,%u%%)\n", (float)warn.rta / 1000, warn.pl);
-        printf (" %s\n", "-c");
-        printf ("    %s", _("critical threshold (currently "));
-        printf ("%0.3fms,%u%%)\n", (float)crit.rta / 1000, crit.pl);
-
-        printf (" %s\n", "-R");
-        printf ("    %s\n", _("RTA, round trip average,  mode  warning,critical, ex. 100ms,200ms unit in ms"));
-        printf (" %s\n", "-P");
-        printf ("    %s\n", _("packet loss mode, ex. 40%,50% , unit in %"));
-        printf (" %s\n", "-J");
-        printf ("    %s\n", _("jitter mode  warning,critical, ex. 40.000ms,50.000ms , unit in ms "));
-        printf (" %s\n", "-M");
-        printf ("    %s\n", _("MOS mode, between 0 and 4.4  warning,critical, ex. 3.5,3.0"));
-        printf (" %s\n", "-S");
-        printf ("    %s\n", _("score  mode, max value 100  warning,critical, ex. 80,70 "));
-        printf (" %s\n", "-O");
-        printf ("    %s\n", _("detect out of order ICMP packts "));
-        printf (" %s\n", "-H");
-        printf ("    %s\n", _("specify a target"));
-        printf (" %s\n", "-s");
-        printf ("    %s\n", _("specify a source IP address or device name"));
-        printf (" %s\n", "-n");
-        printf ("    %s", _("number of packets to send (currently "));
-        printf ("%u)\n",packets);
-        printf (" %s\n", "-p");
-        printf ("    %s", _("number of packets to send (currently "));
-        printf ("%u)\n",packets);
-        printf (" %s\n", "-i");
-        printf ("    %s", _("max packet interval (currently "));
-        printf ("%0.3fms)\n",(float)pkt_interval / 1000);
-        printf (" %s\n", "-I");
-        printf ("    %s", _("max target interval (currently "));
-        printf ("%0.3fms)\n", (float)target_interval / 1000);
-        printf (" %s\n", "-m");
-        printf ("    %s",_("number of alive hosts required for success"));
-        printf ("\n");
-        printf (" %s\n", "-l");
-        printf ("    %s", _("TTL on outgoing packets (currently "));
-        printf ("%u)\n", ttl);
-        printf (" %s\n", "-t");
-        printf ("    %s",_("timeout value (seconds, currently  "));
-        printf ("%u)\n", timeout);
-        printf (" %s\n", "-b");
-        printf ("    %s\n", _("Number of icmp data bytes to send"));
-        printf ("    %s %u + %d)\n", _("Packet size will be data bytes + icmp header (currently"),icmp_data_size, ICMP_MINLEN);
-        printf (" %s\n", "-v");
-        printf ("    %s\n", _("verbose"));
-        printf ("\n");
-        printf ("%s\n", _("Notes:"));
-        printf (" %s\n", _("If none of R,P,J,M,S or O is specified, default behavior is -R -P"));
-        printf (" %s\n", _("The -H switch is optional. Naming a host (or several) to check is not."));
-        printf ("\n");
-        printf (" %s\n", _("Threshold format for -w and -c is 200.25,60% for 200.25 msec RTA and 60%"));
-        printf (" %s\n", _("packet loss.  The default values should work well for most users."));
-        printf (" %s\n", _("You can specify different RTA factors using the standardized abbreviations"));
-        printf (" %s\n", _("us (microseconds), ms (milliseconds, default) or just plain s for seconds."));
+        printf("Copyright (c) 2005 Andreas Ericsson <ae@op5.se>\n");
+
+        printf(COPYRIGHT, copyright, email);
+
+        printf("\n\n");
+
+        print_usage();
+
+        printf(UT_HELP_VRSN);
+        printf(UT_EXTRA_OPTS);
+
+        printf(" %s\n", "-H");
+        printf("    %s\n", _("specify a target"));
+        printf(" %s\n", "[-4|-6]");
+        printf("    %s\n", _("Use IPv4 (default) or IPv6 to communicate with the targets"));
+        printf(" %s\n", "-w");
+        printf("    %s", _("warning threshold (currently "));
+        printf("%0.3fms,%u%%)\n", (float)warn.rta / 1000, warn.pl);
+        printf(" %s\n", "-c");
+        printf("    %s", _("critical threshold (currently "));
+        printf("%0.3fms,%u%%)\n", (float)crit.rta / 1000, crit.pl);
+
+        printf(" %s\n", "-R");
+        printf("    %s\n", _("RTA, round trip average,  mode  warning,critical, ex. 100ms,200ms unit in ms"));
+        printf(" %s\n", "-P");
+        printf("    %s\n", _("packet loss mode, ex. 40%,50% , unit in %"));
+        printf(" %s\n", "-J");
+        printf("    %s\n", _("jitter mode  warning,critical, ex. 40.000ms,50.000ms , unit in ms "));
+        printf(" %s\n", "-M");
+        printf("    %s\n", _("MOS mode, between 0 and 4.4  warning,critical, ex. 3.5,3.0"));
+        printf(" %s\n", "-S");
+        printf("    %s\n", _("score  mode, max value 100  warning,critical, ex. 80,70 "));
+        printf(" %s\n", "-O");
+        printf("    %s\n", _("detect out of order ICMP packts "));
+        printf(" %s\n", "-H");
+        printf("    %s\n", _("specify a target"));
+        printf(" %s\n", "-s");
+        printf("    %s\n", _("specify a source IP address or device name"));
+        printf(" %s\n", "-n");
+        printf("    %s", _("number of packets to send (currently "));
+        printf("%u)\n", packets);
+        printf(" %s\n", "-p");
+        printf("    %s", _("number of packets to send (currently "));
+        printf("%u)\n", packets);
+        printf(" %s\n", "-i");
+        printf("    %s", _("max packet interval (currently "));
+        printf("%0.3fms)\n", (float)pkt_interval / 1000);
+        printf(" %s\n", "-I");
+        printf("    %s", _("max target interval (currently "));
+        printf("%0.3fms)\n", (float)target_interval / 1000);
+        printf(" %s\n", "-m");
+        printf("    %s", _("number of alive hosts required for success"));
+        printf("\n");
+        printf(" %s\n", "-l");
+        printf("    %s", _("TTL on outgoing packets (currently "));
+        printf("%u)\n", ttl);
+        printf(" %s\n", "-t");
+        printf("    %s", _("timeout value (seconds, currently  "));
+        printf("%u)\n", timeout);
+        printf(" %s\n", "-b");
+        printf("    %s\n", _("Number of icmp data bytes to send"));
+        printf("    %s %u + %d)\n", _("Packet size will be data bytes + icmp header (currently"), icmp_data_size, ICMP_MINLEN);
+        printf(" %s\n", "-v");
+        printf("    %s\n", _("verbose"));
+        printf("\n");
+        printf("%s\n", _("Notes:"));
+        printf(" %s\n", _("If none of R,P,J,M,S or O is specified, default behavior is -R -P"));
+        printf(" %s\n", _("The -H switch is optional. Naming a host (or several) to check is not."));
+        printf("\n");
+        printf(" %s\n", _("Threshold format for -w and -c is 200.25,60% for 200.25 msec RTA and 60%"));
+        printf(" %s\n", _("packet loss.  The default values should work well for most users."));
+        printf(" %s\n", _("You can specify different RTA factors using the standardized abbreviations"));
+        printf(" %s\n", _("us (microseconds), ms (milliseconds, default) or just plain s for seconds."));
         /* -d not yet implemented */
         /*  printf ("%s\n", _("Threshold format for -d is warn,crit.  12,14 means WARNING if >= 12 hops"));
                         printf ("%s\n", _("are spent and CRITICAL if >= 14 hops are spent."));
                         printf ("%s\n\n", _("NOTE: Some systems decrease TTL when forming ICMP_ECHOREPLY, others do not."));*/
-        printf ("\n");
-        printf (" %s\n", _("The -v switch can be specified several times for increased verbosity."));
+        printf("\n");
+        printf(" %s\n", _("The -v switch can be specified several times for increased verbosity."));
         /*  printf ("%s\n", _("Long options are currently unsupported."));
                         printf ("%s\n", _("Options marked with * require an argument"));
                         */
 
-        printf (UT_SUPPORT);
+        printf(UT_SUPPORT);
 }
 
-
-
-void
-print_usage (void)
-{
-        printf ("%s\n", _("Usage:"));
+void print_usage(void) {
+        printf("%s\n", _("Usage:"));
         printf(" %s [options] [-H] host1 host2 hostN\n", progname);
 }