1 files changed, 398 insertions, 343 deletions

diff --git a/plugins-root/check_dhcp.c b/plugins-root/check_dhcp.c
index 70809956..3732d970 100644
--- a/plugins-root/check_dhcp.c
+++ b/plugins-root/check_dhcp.c
@@ -4,7 +4,7 @@
  *
  * License: GPL
  * Copyright (c) 2001-2004 Ethan Galstad (nagios@nagios.org)
- * Copyright (c) 2001-2023 Monitoring Plugins Development Team
+ * Copyright (c) 2001-2025 Monitoring Plugins Development Team
  *
  * Description:
  *
@@ -34,13 +34,17 @@
  *****************************************************************************/
 
 const char *progname = "check_dhcp";
-const char *copyright = "2001-2024";
+const char *copyright = "2001-2025";
 const char *email = "devel@monitoring-plugins.org";
 
-#include "common.h"
-#include "netutils.h"
-#include "utils.h"
+#include "../plugins/common.h"
+#include "../plugins/utils.h"
+#include "./check_dhcp.d/config.h"
+#include "../lib/output.h"
+#include "../lib/utils_base.h"
 
+#include "states.h"
+#include <stdint.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -111,8 +115,9 @@ static long mac_addr_dlpi(const char *, int, u_char *);
 
 /**** Common definitions ****/
 
-#define OK    0
-#define ERROR -1
+#define OK           0
+#define ERROR        -1
+#define MAC_ADDR_LEN 6
 
 /**** DHCP definitions ****/
 
@@ -149,12 +154,6 @@ typedef struct dhcp_offer_struct {
         struct dhcp_offer_struct *next;
 } dhcp_offer;
 
-typedef struct requested_server_struct {
-        struct in_addr server_address;
-        bool answered;
-        struct requested_server_struct *next;
-} requested_server;
-
 #define BOOTREQUEST 1
 #define BOOTREPLY   2
 
@@ -186,65 +185,60 @@ typedef struct requested_server_struct {
 #define ETHERNET_HARDWARE_ADDRESS        1 /* used in htype field of dhcp packet */
 #define ETHERNET_HARDWARE_ADDRESS_LENGTH 6 /* length of Ethernet hardware addresses */
 
-static bool unicast = false;   /* unicast mode: mimic a DHCP relay */
-static bool exclusive = false; /* exclusive mode aka "rogue DHCP server detection" */
-static struct in_addr my_ip;   /* our address (required for relay) */
-static struct in_addr dhcp_ip; /* server to query (if in unicast mode) */
-static unsigned char client_hardware_address[MAX_DHCP_CHADDR_LENGTH] = "";
-static unsigned char *user_specified_mac = NULL;
-
-static char network_interface_name[IFNAMSIZ] = "eth0";
-
-static uint32_t packet_xid = 0;
-
-static uint32_t dhcp_lease_time = 0;
-static uint32_t dhcp_renewal_time = 0;
-static uint32_t dhcp_rebinding_time = 0;
-
-static int dhcpoffer_timeout = 2;
-
-static dhcp_offer *dhcp_offer_list = NULL;
-static requested_server *requested_server_list = NULL;
-
-static int valid_responses = 0; /* number of valid DHCPOFFERs we received */
-static int requested_servers = 0;
-static int requested_responses = 0;
-
-static bool request_specific_address = false;
-static bool received_requested_address = false;
 static int verbose = 0;
-static struct in_addr requested_address;
 
-static int process_arguments(int, char **);
-static int call_getopt(int, char **);
-static int validate_arguments(int);
+typedef struct process_arguments_wrapper {
+        int error;
+        check_dhcp_config config;
+} process_arguments_wrapper;
+
+static process_arguments_wrapper process_arguments(int /*argc*/, char ** /*argv*/);
 void print_usage(void);
 static void print_help(void);
 
-static void resolve_host(const char *in, struct in_addr *out);
-static unsigned char *mac_aton(const char *);
-static void print_hardware_address(const unsigned char *);
-static int get_hardware_address(int, char *);
-static int get_ip_address(int, char *);
-
-static int send_dhcp_discover(int);
-static int get_dhcp_offer(int);
-
-static int get_results(void);
-
-static int add_dhcp_offer(struct in_addr, dhcp_packet *);
-static int free_dhcp_offer_list(void);
-static int free_requested_server_list(void);
-
-static int create_dhcp_socket(void);
-static int close_dhcp_socket(int);
-static int send_dhcp_packet(void *, int, int, struct sockaddr_in *);
-static int receive_dhcp_packet(void *, int, int, int, struct sockaddr_in *);
+static void resolve_host(const char * /*in*/, struct in_addr * /*out*/);
+static unsigned char *mac_aton(const char * /*string*/);
+static void print_hardware_address(const unsigned char * /*address*/);
+static int get_hardware_address(int /*sock*/, char * /*interface_name*/, unsigned char *client_hardware_address);
+
+typedef struct get_ip_address_wrapper {
+        int error;
+        struct in_addr my_ip;
+} get_ip_address_wrapper;
+static get_ip_address_wrapper get_ip_address(int /*sock*/, char * /*interface_name*/);
+
+typedef struct send_dhcp_discover_wrapper {
+        int error;
+        uint32_t packet_xid;
+} send_dhcp_discover_wrapper;
+static send_dhcp_discover_wrapper send_dhcp_discover(int socket, bool unicast, struct in_addr dhcp_ip, struct in_addr requested_address,
+                                                                                                         bool request_specific_address, struct in_addr my_ip,
+                                                                                                         unsigned char *client_hardware_address);
+typedef struct get_dhcp_offer_wrapper {
+        int error;
+        int valid_responses;
+        dhcp_offer *dhcp_offer_list;
+} get_dhcp_offer_wrapper;
+static get_dhcp_offer_wrapper get_dhcp_offer(int /*sock*/, int dhcpoffer_timeout, uint32_t packet_xid, dhcp_offer *dhcp_offer_list,
+                                                                                         const unsigned char *client_hardware_address);
+
+static mp_subcheck get_results(bool exclusive, int requested_servers, struct in_addr requested_address, bool request_specific_address,
+                                                           requested_server *requested_server_list, int valid_responses, dhcp_offer *dhcp_offer_list);
+
+typedef struct add_dhcp_offer_wrapper {
+        int error;
+        dhcp_offer *dhcp_offer_list;
+} add_dhcp_offer_wrapper;
+static add_dhcp_offer_wrapper add_dhcp_offer(struct in_addr /*source*/, dhcp_packet * /*offer_packet*/, dhcp_offer *dhcp_offer_list);
+static int free_dhcp_offer_list(dhcp_offer *dhcp_offer_list);
+static int free_requested_server_list(requested_server *requested_server_list);
+
+static int create_dhcp_socket(bool /*unicast*/, char *network_interface_name);
+static int close_dhcp_socket(int /*sock*/);
+static int send_dhcp_packet(void * /*buffer*/, int /*buffer_size*/, int /*sock*/, struct sockaddr_in * /*dest*/);
+static int receive_dhcp_packet(void * /*buffer*/, int /*buffer_size*/, int /*sock*/, int /*timeout*/, struct sockaddr_in * /*address*/);
 
 int main(int argc, char **argv) {
-        int dhcp_socket;
-        int result = STATE_UNKNOWN;
-
         setlocale(LC_ALL, "");
         bindtextdomain(PACKAGE, LOCALEDIR);
         textdomain(PACKAGE);
@@ -252,45 +246,80 @@ int main(int argc, char **argv) {
         /* Parse extra opts if any */
         argv = np_extra_opts(&argc, argv, progname);
 
-        if (process_arguments(argc, argv) != OK) {
+        process_arguments_wrapper tmp = process_arguments(argc, argv);
+
+        if (tmp.error != OK) {
                 usage4(_("Could not parse arguments"));
         }
 
+        check_dhcp_config config = tmp.config;
+        if (config.output_format_is_set) {
+                mp_set_format(config.output_format);
+        }
+
         /* create socket for DHCP communications */
-        dhcp_socket = create_dhcp_socket();
+        int dhcp_socket = create_dhcp_socket(config.unicast_mode, config.network_interface_name);
 
         /* get hardware address of client machine */
-        if (user_specified_mac != NULL) {
-                memcpy(client_hardware_address, user_specified_mac, 6);
+        unsigned char client_hardware_address[MAX_DHCP_CHADDR_LENGTH] = "";
+        if (config.user_specified_mac != NULL) {
+                memcpy(client_hardware_address, config.user_specified_mac, MAC_ADDR_LEN);
         } else {
-                get_hardware_address(dhcp_socket, network_interface_name);
+                get_hardware_address(dhcp_socket, config.network_interface_name, client_hardware_address);
         }
 
-        if (unicast) { /* get IP address of client machine */
-                get_ip_address(dhcp_socket, network_interface_name);
+        struct in_addr my_ip = {0};
+
+        if (config.unicast_mode) { /* get IP address of client machine */
+                get_ip_address_wrapper tmp_get_ip = get_ip_address(dhcp_socket, config.network_interface_name);
+                if (tmp_get_ip.error == OK) {
+                        my_ip = tmp_get_ip.my_ip;
+                } else {
+                        // TODO failed to get own IP
+                        die(STATE_UNKNOWN, "Failed to retrieve my own IP address in unicast mode");
+                }
         }
 
         /* send DHCPDISCOVER packet */
-        send_dhcp_discover(dhcp_socket);
+        send_dhcp_discover_wrapper disco_res = send_dhcp_discover(dhcp_socket, config.unicast_mode, config.dhcp_ip, config.requested_address,
+                                                                                                                          config.request_specific_address, my_ip, client_hardware_address);
+
+        if (disco_res.error != OK) {
+                // DO something?
+                die(STATE_UNKNOWN, "Failed to send DHCP discover");
+        }
 
         /* wait for a DHCPOFFER packet */
-        get_dhcp_offer(dhcp_socket);
+        get_dhcp_offer_wrapper offer_res =
+                get_dhcp_offer(dhcp_socket, config.dhcpoffer_timeout, disco_res.packet_xid, NULL, client_hardware_address);
+
+        int valid_responses = 0;
+        dhcp_offer *dhcp_offer_list = NULL;
+        if (offer_res.error == OK) {
+                valid_responses = offer_res.valid_responses;
+                dhcp_offer_list = offer_res.dhcp_offer_list;
+        } else {
+                die(STATE_UNKNOWN, "Failed to get DHCP offers");
+        }
 
         /* close socket we created */
         close_dhcp_socket(dhcp_socket);
 
-        /* determine state/plugin output to return */
-        result = get_results();
+        mp_check overall = mp_check_init();
 
+        /* determine state/plugin output to return */
+        mp_subcheck sc_res = get_results(config.exclusive_mode, config.num_of_requested_servers, config.requested_address,
+                                                                         config.request_specific_address, config.requested_server_list, valid_responses, dhcp_offer_list);
+        mp_add_subcheck_to_check(&overall, sc_res);
         /* free allocated memory */
-        free_dhcp_offer_list();
-        free_requested_server_list();
+        free_dhcp_offer_list(dhcp_offer_list);
+        free_requested_server_list(config.requested_server_list);
 
-        return result;
+        mp_exit(overall);
 }
 
 /* determines hardware address on client machine */
-static int get_hardware_address(int sock, char *interface_name) {
+int get_hardware_address(int sock, char *interface_name, unsigned char *client_hardware_address) {
 
 #if defined(__linux__)
         struct ifreq ifr;
@@ -304,7 +333,7 @@ static int get_hardware_address(int sock, char *interface_name) {
                 exit(STATE_UNKNOWN);
         }
 
-        memcpy(&client_hardware_address[0], &ifr.ifr_hwaddr.sa_data, 6);
+        memcpy(&client_hardware_address[0], &ifr.ifr_hwaddr.sa_data, MAC_ADDR_LEN);
 
 #elif defined(__bsd__)
         /* King 2004    see ACKNOWLEDGEMENTS */
@@ -404,7 +433,7 @@ static int get_hardware_address(int sock, char *interface_name) {
 }
 
 /* determines IP address of the client interface */
-static int get_ip_address(int sock, char *interface_name) {
+get_ip_address_wrapper get_ip_address(int sock, char *interface_name) {
 #if defined(SIOCGIFADDR)
         struct ifreq ifr;
 
@@ -416,29 +445,28 @@ static int get_ip_address(int sock, char *interface_name) {
                 exit(STATE_UNKNOWN);
         }
 
-        my_ip = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
-
 #else
         printf(_("Error: Cannot get interface IP address on this platform.\n"));
         exit(STATE_UNKNOWN);
 #endif
 
+        get_ip_address_wrapper result = {
+                .error = OK,
+                .my_ip = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr,
+        };
+
         if (verbose) {
-                printf(_("Pretending to be relay client %s\n"), inet_ntoa(my_ip));
+                printf(_("Pretending to be relay client %s\n"), inet_ntoa(result.my_ip));
         }
 
-        return OK;
+        return result;
 }
 
 /* sends a DHCPDISCOVER broadcast message in an attempt to find DHCP servers */
-static int send_dhcp_discover(int sock) {
-        dhcp_packet discover_packet;
-        struct sockaddr_in sockaddr_broadcast;
-        unsigned short opts;
-
-        /* clear the packet data structure */
-        bzero(&discover_packet, sizeof(discover_packet));
-
+static send_dhcp_discover_wrapper send_dhcp_discover(int sock, bool unicast, struct in_addr dhcp_ip, struct in_addr requested_address,
+                                                                                                         bool request_specific_address, struct in_addr my_ip,
+                                                                                                         unsigned char *client_hardware_address) {
+        dhcp_packet discover_packet = {0};
         /* boot request flag (backward compatible with BOOTP servers) */
         discover_packet.op = BOOTREQUEST;
 
@@ -448,12 +476,15 @@ static int send_dhcp_discover(int sock) {
         /* length of our hardware address */
         discover_packet.hlen = ETHERNET_HARDWARE_ADDRESS_LENGTH;
 
+        send_dhcp_discover_wrapper result = {
+                .error = OK,
+        };
         /*
          * transaction ID is supposed to be random.
          */
         srand(time(NULL) ^ getpid());
-        packet_xid = random();
-        discover_packet.xid = htonl(packet_xid);
+        result.packet_xid = random();
+        discover_packet.xid = htonl(result.packet_xid);
 
         /*discover_packet.secs=htons(65535);*/
         discover_packet.secs = 0xFF;
@@ -473,7 +504,7 @@ static int send_dhcp_discover(int sock) {
         discover_packet.options[2] = '\x53';
         discover_packet.options[3] = '\x63';
 
-        opts = 4;
+        unsigned short opts = 4;
         /* DHCP message type is embedded in options field */
         discover_packet.options[opts++] = DHCP_OPTION_MESSAGE_TYPE; /* DHCP message type option identifier */
         discover_packet.options[opts++] = '\x01';                   /* DHCP message option length in bytes */
@@ -497,10 +528,11 @@ static int send_dhcp_discover(int sock) {
         discover_packet.hops = unicast ? 1 : 0;
 
         /* send the DHCPDISCOVER packet to broadcast address */
-        sockaddr_broadcast.sin_family = AF_INET;
-        sockaddr_broadcast.sin_port = htons(DHCP_SERVER_PORT);
-        sockaddr_broadcast.sin_addr.s_addr = unicast ? dhcp_ip.s_addr : INADDR_BROADCAST;
-        bzero(&sockaddr_broadcast.sin_zero, sizeof(sockaddr_broadcast.sin_zero));
+        struct sockaddr_in sockaddr_broadcast = {
+                .sin_family = AF_INET,
+                .sin_port = htons(DHCP_SERVER_PORT),
+                .sin_addr.s_addr = unicast ? dhcp_ip.s_addr : INADDR_BROADCAST,
+        };
 
         if (verbose) {
                 printf(_("DHCPDISCOVER to %s port %d\n"), inet_ntoa(sockaddr_broadcast.sin_addr), ntohs(sockaddr_broadcast.sin_port));
@@ -518,25 +550,21 @@ static int send_dhcp_discover(int sock) {
                 printf("\n\n");
         }
 
-        return OK;
+        return result;
 }
 
 /* waits for a DHCPOFFER message from one or more DHCP servers */
-static int get_dhcp_offer(int sock) {
-        dhcp_packet offer_packet;
-        struct sockaddr_in source;
-        struct sockaddr_in via;
-        int result = OK;
-        int responses = 0;
-        int x;
+get_dhcp_offer_wrapper get_dhcp_offer(int sock, int dhcpoffer_timeout, uint32_t packet_xid, dhcp_offer *dhcp_offer_list,
+                                                                          const unsigned char *client_hardware_address) {
         time_t start_time;
-        time_t current_time;
-
         time(&start_time);
 
+        int result = OK;
+        int responses = 0;
+        int valid_responses = 0;
         /* receive as many responses as we can */
-        for (responses = 0, valid_responses = 0;;) {
-
+        for (;;) {
+                time_t current_time;
                 time(&current_time);
                 if ((current_time - start_time) >= dhcpoffer_timeout) {
                         break;
@@ -546,9 +574,8 @@ static int get_dhcp_offer(int sock) {
                         printf("\n\n");
                 }
 
-                bzero(&source, sizeof(source));
-                bzero(&via, sizeof(via));
-                bzero(&offer_packet, sizeof(offer_packet));
+                struct sockaddr_in source = {0};
+                dhcp_packet offer_packet = {0};
 
                 result = OK;
                 result = receive_dhcp_packet(&offer_packet, sizeof(offer_packet), sock, dhcpoffer_timeout, &source);
@@ -559,16 +586,16 @@ static int get_dhcp_offer(int sock) {
                         }
 
                         continue;
-                } else {
-                        if (verbose) {
-                                printf(_("Result=OK\n"));
-                        }
-
-                        responses++;
                 }
+                if (verbose) {
+                        printf(_("Result=OK\n"));
+                }
+
+                responses++;
 
                 /* The "source" is either a server or a relay. */
                 /* Save a copy of "source" into "via" even if it's via itself */
+                struct sockaddr_in via = {0};
                 memcpy(&via, &source, sizeof(source));
 
                 if (verbose) {
@@ -593,12 +620,12 @@ static int get_dhcp_offer(int sock) {
                         printf("DHCPOFFER chaddr: ");
                 }
 
-                for (x = 0; x < ETHERNET_HARDWARE_ADDRESS_LENGTH; x++) {
+                for (int i = 0; i < ETHERNET_HARDWARE_ADDRESS_LENGTH; i++) {
                         if (verbose) {
-                                printf("%02X", (unsigned char)offer_packet.chaddr[x]);
+                                printf("%02X", offer_packet.chaddr[i]);
                         }
 
-                        if (offer_packet.chaddr[x] != client_hardware_address[x]) {
+                        if (offer_packet.chaddr[i] != client_hardware_address[i]) {
                                 result = ERROR;
                         }
                 }
@@ -621,7 +648,12 @@ static int get_dhcp_offer(int sock) {
                         printf("DHCPOFFER giaddr: %s\n", inet_ntoa(offer_packet.giaddr));
                 }
 
-                add_dhcp_offer(source.sin_addr, &offer_packet);
+                add_dhcp_offer_wrapper add_res = add_dhcp_offer(source.sin_addr, &offer_packet, dhcp_offer_list);
+                if (add_res.error != OK) {
+                        // TODO
+                } else {
+                        dhcp_offer_list = add_res.dhcp_offer_list;
+                }
 
                 valid_responses++;
         }
@@ -631,14 +663,17 @@ static int get_dhcp_offer(int sock) {
                 printf(_("Valid responses for this machine: %d\n"), valid_responses);
         }
 
-        return OK;
+        get_dhcp_offer_wrapper ret_val = {
+                .error = OK,
+                .valid_responses = valid_responses,
+                .dhcp_offer_list = dhcp_offer_list,
+        };
+        return ret_val;
 }
 
 /* sends a DHCP packet */
-static int send_dhcp_packet(void *buffer, int buffer_size, int sock, struct sockaddr_in *dest) {
-        int result;
-
-        result = sendto(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)dest, sizeof(*dest));
+int send_dhcp_packet(void *buffer, int buffer_size, int sock, struct sockaddr_in *dest) {
+        int result = sendto(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)dest, sizeof(*dest));
 
         if (verbose) {
                 printf(_("send_dhcp_packet result: %d\n"), result);
@@ -652,23 +687,19 @@ static int send_dhcp_packet(void *buffer, int buffer_size, int sock, struct sock
 }
 
 /* receives a DHCP packet */
-static int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int timeout, struct sockaddr_in *address) {
-        struct timeval tv;
-        fd_set readfds;
-        fd_set oobfds;
-        int recv_result;
-        socklen_t address_size;
-        struct sockaddr_in source_address;
-        int nfound;
-
+int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int timeout, struct sockaddr_in *address) {
         /* wait for data to arrive (up time timeout) */
-        tv.tv_sec = timeout;
-        tv.tv_usec = 0;
+        struct timeval timeout_val = {
+                .tv_sec = timeout,
+                .tv_usec = 0,
+        };
+        fd_set readfds;
         FD_ZERO(&readfds);
+        fd_set oobfds;
         FD_ZERO(&oobfds);
         FD_SET(sock, &readfds);
         FD_SET(sock, &oobfds);
-        nfound = select(sock + 1, &readfds, NULL, &oobfds, &tv);
+        int nfound = select(sock + 1, &readfds, NULL, &oobfds, &timeout_val);
 
         /* make sure some data has arrived */
         if (!FD_ISSET(sock, &readfds)) {
@@ -678,51 +709,44 @@ static int receive_dhcp_packet(void *buffer, int buffer_size, int sock, int time
                 return ERROR;
         }
 
-        else {
-                bzero(&source_address, sizeof(source_address));
-                address_size = sizeof(source_address);
-                recv_result = recvfrom(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)&source_address, &address_size);
-                if (verbose) {
-                        printf("recv_result: %d\n", recv_result);
-                }
-
-                if (recv_result == -1) {
-                        if (verbose) {
-                                printf(_("recvfrom() failed, "));
-                                printf("errno: (%d) -> %s\n", errno, strerror(errno));
-                        }
-                        return ERROR;
-                } else {
-                        if (verbose) {
-                                printf(_("receive_dhcp_packet() result: %d\n"), recv_result);
-                                printf(_("receive_dhcp_packet() source: %s\n"), inet_ntoa(source_address.sin_addr));
-                        }
+        struct sockaddr_in source_address = {0};
+        socklen_t address_size = sizeof(source_address);
+        int recv_result = recvfrom(sock, (char *)buffer, buffer_size, 0, (struct sockaddr *)&source_address, &address_size);
+        if (verbose) {
+                printf("recv_result: %d\n", recv_result);
+        }
 
-                        memcpy(address, &source_address, sizeof(source_address));
-                        return OK;
+        if (recv_result == -1) {
+                if (verbose) {
+                        printf(_("recvfrom() failed, "));
+                        printf("errno: (%d) -> %s\n", errno, strerror(errno));
                 }
+                return ERROR;
+        }
+        if (verbose) {
+                printf(_("receive_dhcp_packet() result: %d\n"), recv_result);
+                printf(_("receive_dhcp_packet() source: %s\n"), inet_ntoa(source_address.sin_addr));
         }
 
+        memcpy(address, &source_address, sizeof(source_address));
         return OK;
 }
 
 /* creates a socket for DHCP communication */
-static int create_dhcp_socket(void) {
-        struct sockaddr_in myname;
-        struct ifreq interface;
-        int sock;
-        int flag = 1;
-
+int create_dhcp_socket(bool unicast, char *network_interface_name) {
         /* Set up the address we're going to bind to. */
-        bzero(&myname, sizeof(myname));
-        myname.sin_family = AF_INET;
         /* listen to DHCP server port if we're in unicast mode */
-        myname.sin_port = htons(unicast ? DHCP_SERVER_PORT : DHCP_CLIENT_PORT);
-        myname.sin_addr.s_addr = unicast ? my_ip.s_addr : INADDR_ANY;
-        bzero(&myname.sin_zero, sizeof(myname.sin_zero));
+        struct sockaddr_in myname = {
+                .sin_family = AF_INET,
+                .sin_port = htons(unicast ? DHCP_SERVER_PORT : DHCP_CLIENT_PORT),
+                // TODO previously the next line was trying to use our own IP, we was not set
+                // until some point later, so it was removed. Recheck whether it is actually
+                // necessary/useful
+                .sin_addr.s_addr = INADDR_ANY,
+        };
 
         /* create a socket for DHCP communications */
-        sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+        int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
         if (sock < 0) {
                 printf(_("Error: Could not create socket!\n"));
                 exit(STATE_UNKNOWN);
@@ -733,7 +757,7 @@ static int create_dhcp_socket(void) {
         }
 
         /* set the reuse address flag so we don't get errors when restarting */
-        flag = 1;
+        int flag = 1;
         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&flag, sizeof(flag)) < 0) {
                 printf(_("Error: Could not set reuse address option on DHCP socket!\n"));
                 exit(STATE_UNKNOWN);
@@ -745,6 +769,7 @@ static int create_dhcp_socket(void) {
                 exit(STATE_UNKNOWN);
         }
 
+        struct ifreq interface;
         /* bind socket to interface */
 #if defined(__linux__)
         strncpy(interface.ifr_ifrn.ifrn_name, network_interface_name, IFNAMSIZ - 1);
@@ -769,18 +794,14 @@ static int create_dhcp_socket(void) {
 }
 
 /* closes DHCP socket */
-static int close_dhcp_socket(int sock) {
-
+int close_dhcp_socket(int sock) {
         close(sock);
-
         return OK;
 }
 
 /* adds a requested server address to list in memory */
-static int add_requested_server(struct in_addr server_address) {
-        requested_server *new_server;
-
-        new_server = (requested_server *)malloc(sizeof(requested_server));
+int add_requested_server(struct in_addr server_address, int *requested_servers, requested_server **requested_server_list) {
+        requested_server *new_server = (requested_server *)malloc(sizeof(requested_server));
         if (new_server == NULL) {
                 return ERROR;
         }
@@ -788,10 +809,10 @@ static int add_requested_server(struct in_addr server_address) {
         new_server->server_address = server_address;
         new_server->answered = false;
 
-        new_server->next = requested_server_list;
-        requested_server_list = new_server;
+        new_server->next = *requested_server_list;
+        *requested_server_list = new_server;
 
-        requested_servers++;
+        *requested_servers += 1;
 
         if (verbose) {
                 printf(_("Requested server address: %s\n"), inet_ntoa(new_server->server_address));
@@ -801,29 +822,31 @@ static int add_requested_server(struct in_addr server_address) {
 }
 
 /* adds a DHCP OFFER to list in memory */
-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};
-
+add_dhcp_offer_wrapper add_dhcp_offer(struct in_addr source, dhcp_packet *offer_packet, dhcp_offer *dhcp_offer_list) {
         if (offer_packet == NULL) {
-                return ERROR;
+                add_dhcp_offer_wrapper tmp = {
+                        .error = ERROR,
+                };
+                return tmp;
         }
 
+        uint32_t dhcp_lease_time = 0;
+        uint32_t dhcp_renewal_time = 0;
+        uint32_t dhcp_rebinding_time = 0;
+        dhcp_offer *new_offer;
+        struct in_addr serv_ident = {0};
         /* process all DHCP options present in the packet */
-        for (x = 4; x < MAX_DHCP_OPTIONS_LENGTH - 1;) {
+        for (int dchp_opt_idx = 4; dchp_opt_idx < MAX_DHCP_OPTIONS_LENGTH - 1;) {
 
-                if ((int)offer_packet->options[x] == -1) {
+                if ((int)offer_packet->options[dchp_opt_idx] == -1) {
                         break;
                 }
 
                 /* get option type */
-                option_type = offer_packet->options[x++];
+                unsigned option_type = offer_packet->options[dchp_opt_idx++];
 
                 /* get option length */
-                option_length = offer_packet->options[x++];
+                unsigned option_length = offer_packet->options[dchp_opt_idx++];
 
                 if (verbose) {
                         printf("Option: %d (0x%02X)\n", option_type, option_length);
@@ -832,27 +855,27 @@ static int add_dhcp_offer(struct in_addr source, dhcp_packet *offer_packet) {
                 /* get option data */
                 switch (option_type) {
                 case DHCP_OPTION_LEASE_TIME:
-                        memcpy(&dhcp_lease_time, &offer_packet->options[x], sizeof(dhcp_lease_time));
+                        memcpy(&dhcp_lease_time, &offer_packet->options[dchp_opt_idx], sizeof(dhcp_lease_time));
                         dhcp_lease_time = ntohl(dhcp_lease_time);
                         break;
                 case DHCP_OPTION_RENEWAL_TIME:
-                        memcpy(&dhcp_renewal_time, &offer_packet->options[x], sizeof(dhcp_renewal_time));
+                        memcpy(&dhcp_renewal_time, &offer_packet->options[dchp_opt_idx], sizeof(dhcp_renewal_time));
                         dhcp_renewal_time = ntohl(dhcp_renewal_time);
                         break;
                 case DHCP_OPTION_REBINDING_TIME:
-                        memcpy(&dhcp_rebinding_time, &offer_packet->options[x], sizeof(dhcp_rebinding_time));
+                        memcpy(&dhcp_rebinding_time, &offer_packet->options[dchp_opt_idx], sizeof(dhcp_rebinding_time));
                         dhcp_rebinding_time = ntohl(dhcp_rebinding_time);
                         break;
                 case DHCP_OPTION_SERVER_IDENTIFIER:
-                        memcpy(&serv_ident.s_addr, &offer_packet->options[x], sizeof(serv_ident.s_addr));
+                        memcpy(&serv_ident.s_addr, &offer_packet->options[dchp_opt_idx], sizeof(serv_ident.s_addr));
                         break;
                 }
 
                 /* skip option data we're ignoring */
                 if (option_type == 0) { /* "pad" option, see RFC 2132 (3.1) */
-                        x += 1;
+                        dchp_opt_idx += 1;
                 } else {
-                        x += option_length;
+                        dchp_opt_idx += option_length;
                 }
         }
 
@@ -876,7 +899,10 @@ static int add_dhcp_offer(struct in_addr source, dhcp_packet *offer_packet) {
         new_offer = (dhcp_offer *)malloc(sizeof(dhcp_offer));
 
         if (new_offer == NULL) {
-                return ERROR;
+                add_dhcp_offer_wrapper tmp = {
+                        .error = ERROR,
+                };
+                return tmp;
         }
 
         /*
@@ -907,15 +933,18 @@ static int add_dhcp_offer(struct in_addr source, dhcp_packet *offer_packet) {
         new_offer->next = dhcp_offer_list;
         dhcp_offer_list = new_offer;
 
-        return OK;
+        add_dhcp_offer_wrapper result = {
+                .error = OK,
+                .dhcp_offer_list = dhcp_offer_list,
+        };
+
+        return result;
 }
 
 /* frees memory allocated to DHCP OFFER list */
-static int free_dhcp_offer_list(void) {
-        dhcp_offer *this_offer;
+int free_dhcp_offer_list(dhcp_offer *dhcp_offer_list) {
         dhcp_offer *next_offer;
-
-        for (this_offer = dhcp_offer_list; this_offer != NULL; this_offer = next_offer) {
+        for (dhcp_offer *this_offer = dhcp_offer_list; this_offer != NULL; this_offer = next_offer) {
                 next_offer = this_offer->next;
                 free(this_offer);
         }
@@ -924,11 +953,9 @@ static int free_dhcp_offer_list(void) {
 }
 
 /* frees memory allocated to requested server list */
-static int free_requested_server_list(void) {
-        requested_server *this_server;
+int free_requested_server_list(requested_server *requested_server_list) {
         requested_server *next_server;
-
-        for (this_server = requested_server_list; this_server != NULL; this_server = next_server) {
+        for (requested_server *this_server = requested_server_list; this_server != NULL; this_server = next_server) {
                 next_server = this_server->next;
                 free(this_server);
         }
@@ -937,22 +964,39 @@ static int free_requested_server_list(void) {
 }
 
 /* gets state and plugin output to return */
-static int get_results(void) {
-        dhcp_offer *temp_offer, *undesired_offer = NULL;
-        requested_server *temp_server;
-        int result;
-        uint32_t max_lease_time = 0;
-
-        received_requested_address = false;
+mp_subcheck get_results(bool exclusive, const int requested_servers, const struct in_addr requested_address, bool request_specific_address,
+                                                requested_server *requested_server_list, int valid_responses, dhcp_offer *dhcp_offer_list) {
+        mp_subcheck sc_dhcp_results = mp_subcheck_init();
+        sc_dhcp_results = mp_set_subcheck_default_state(sc_dhcp_results, STATE_OK);
 
-        /* checks responses from requested servers */
-        requested_responses = 0;
-        if (requested_servers > 0) {
+        /* we didn't receive any DHCPOFFERs */
+        if (dhcp_offer_list == NULL) {
+                sc_dhcp_results = mp_set_subcheck_state(sc_dhcp_results, STATE_CRITICAL);
+                xasprintf(&sc_dhcp_results.output, "%s", "No DHCP offers were received");
+                return sc_dhcp_results;
+        }
 
-                for (temp_server = requested_server_list; temp_server != NULL; temp_server = temp_server->next) {
+        if (valid_responses == 0) {
+                // No valid responses at all, so early exit here
+                sc_dhcp_results = mp_set_subcheck_state(sc_dhcp_results, STATE_CRITICAL);
+                xasprintf(&sc_dhcp_results.output, "No valid responses received");
+                return sc_dhcp_results;
+        }
 
-                        for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
+        if (valid_responses == 1) {
+                xasprintf(&sc_dhcp_results.output, "Received %d DHCPOFFER", valid_responses);
+        } else {
+                xasprintf(&sc_dhcp_results.output, "Received %d DHCPOFFERs", valid_responses);
+        }
 
+        bool received_requested_address = false;
+        dhcp_offer *undesired_offer = NULL;
+        uint32_t max_lease_time = 0;
+        /* checks responses from requested servers */
+        int requested_responses = 0;
+        if (requested_servers > 0) {
+                for (requested_server *temp_server = requested_server_list; temp_server != NULL; temp_server = temp_server->next) {
+                        for (dhcp_offer *temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
                                 /* get max lease time we were offered */
                                 if (temp_offer->lease_time > max_lease_time || temp_offer->lease_time == DHCP_INFINITE_TIME) {
                                         max_lease_time = temp_offer->lease_time;
@@ -963,7 +1007,7 @@ static int get_results(void) {
                                         received_requested_address = true;
                                 }
 
-                                /* see if the servers we wanted a response from talked to us or not */
+                                /* see if the servers we wanted a response from, talked to us or not */
                                 if (!memcmp(&temp_offer->server_address, &temp_server->server_address, sizeof(temp_server->server_address))) {
                                         if (verbose) {
                                                 printf(_("DHCP Server Match: Offerer=%s"), inet_ntoa(temp_offer->server_address));
@@ -973,6 +1017,7 @@ static int get_results(void) {
                                                 }
                                                 printf(_("\n"));
                                         }
+
                                         if (!temp_server->answered) {
                                                 requested_responses++;
                                                 temp_server->answered = true;
@@ -983,19 +1028,32 @@ static int get_results(void) {
                 }
 
                 /* exclusive mode: check for undesired offers */
-                for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
+                for (dhcp_offer *temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
                         if (!temp_offer->desired) {
                                 undesired_offer = temp_offer; /* Checks only for the first undesired offer */
                                 break;                        /* no further checks needed */
                         }
                 }
-        }
 
-        /* else check and see if we got our requested address from any server */
-        else {
+                mp_subcheck sc_rqust_srvs = mp_subcheck_init();
+                xasprintf(&sc_rqust_srvs.output, "%d of %d requested servers responded", requested_responses, requested_servers);
 
-                for (temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
+                if (requested_responses == requested_servers) {
+                        sc_rqust_srvs = mp_set_subcheck_state(sc_rqust_srvs, STATE_OK);
+                } else if (requested_responses == 0) {
+                        sc_rqust_srvs = mp_set_subcheck_state(sc_rqust_srvs, STATE_CRITICAL);
+                } else if (requested_responses < requested_servers) {
+                        sc_rqust_srvs = mp_set_subcheck_state(sc_rqust_srvs, STATE_WARNING);
+                } else {
+                        // We received more(!) responses than we asked for?
+                        // This case shouldn't happen, but is here for completion
+                        sc_rqust_srvs = mp_set_subcheck_state(sc_rqust_srvs, STATE_WARNING);
+                }
+                mp_add_subcheck_to_subcheck(&sc_dhcp_results, sc_rqust_srvs);
 
+        } else {
+                /* else check and see if we got our requested address from any server */
+                for (dhcp_offer *temp_offer = dhcp_offer_list; temp_offer != NULL; temp_offer = temp_offer->next) {
                         /* get max lease time we were offered */
                         if (temp_offer->lease_time > max_lease_time || temp_offer->lease_time == DHCP_INFINITE_TIME) {
                                 max_lease_time = temp_offer->lease_time;
@@ -1008,79 +1066,77 @@ static int get_results(void) {
                 }
         }
 
-        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 (max_lease_time == DHCP_INFINITE_TIME) {
+                xasprintf(&sc_dhcp_results.output, "%s, max lease time = Infinity", sc_dhcp_results.output);
+        } else {
+                xasprintf(&sc_dhcp_results.output, "%s, max lease time = %" PRIu32 " seconds", sc_dhcp_results.output, max_lease_time);
         }
 
-        if (exclusive && undesired_offer) {
-                result = STATE_CRITICAL;
-        }
+        if (exclusive) {
+                mp_subcheck sc_rogue_server = mp_subcheck_init();
 
-        if (result == 0) { /* garrett honeycutt 2005 */
-                printf("OK: ");
-        } else if (result == 1) {
-                printf("WARNING: ");
-        } else if (result == 2) {
-                printf("CRITICAL: ");
-        } else if (result == 3) {
-                printf("UNKNOWN: ");
-        }
+                if (undesired_offer != NULL) {
+                        // We wanted to get a DHCPOFFER exclusively from one machine, but another one
+                        // sent one (too)
+                        sc_rogue_server = mp_set_subcheck_state(sc_rogue_server, STATE_CRITICAL);
 
-        /* we didn't receive any DHCPOFFERs */
-        if (dhcp_offer_list == NULL) {
-                printf(_("No DHCPOFFERs were received.\n"));
-                return result;
-        }
+                        // Get the addresses for printout
+                        // 1.address of the sending server
+                        char server_address[INET_ADDRSTRLEN];
+                        const char *server_address_transformed =
+                                inet_ntop(AF_INET, &undesired_offer->server_address, server_address, sizeof(server_address));
+
+                        if (server_address != server_address_transformed) {
+                                die(STATE_UNKNOWN, "inet_ntop failed");
+                        }
 
-        printf(_("Received %d DHCPOFFER(s)"), valid_responses);
+                        // 2.address offered
+                        char offered_address[INET_ADDRSTRLEN];
+                        const char *offered_address_transformed =
+                                inet_ntop(AF_INET, &undesired_offer->offered_address, offered_address, sizeof(offered_address));
 
-        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 (offered_address != offered_address_transformed) {
+                                die(STATE_UNKNOWN, "inet_ntop failed");
+                        }
 
-        if (requested_servers > 0) {
-                printf(_(", %s%d of %d requested servers responded"),
-                           ((requested_responses < requested_servers) && requested_responses > 0) ? "only " : "", requested_responses,
-                           requested_servers);
+                        xasprintf(&sc_rogue_server.output, "Rogue DHCP Server detected! Server %s offered %s", server_address, offered_address);
+                } else {
+                        sc_rogue_server = mp_set_subcheck_state(sc_rogue_server, STATE_OK);
+                        xasprintf(&sc_rogue_server.output, "No Rogue DHCP Server detected");
+                }
+                mp_add_subcheck_to_subcheck(&sc_dhcp_results, sc_rogue_server);
         }
 
         if (request_specific_address) {
-                printf(_(", requested address (%s) was %soffered"), inet_ntoa(requested_address), (received_requested_address) ? "" : _("not "));
-        }
+                mp_subcheck sc_rqustd_addr = mp_subcheck_init();
 
-        printf(_(", max lease time = "));
-        if (max_lease_time == DHCP_INFINITE_TIME) {
-                printf(_("Infinity"));
-        } else {
-                printf("%lu sec", (unsigned long)max_lease_time);
-        }
+                if (received_requested_address) {
+                        sc_rqustd_addr = mp_set_subcheck_state(sc_rqustd_addr, STATE_OK);
+                        xasprintf(&sc_rqustd_addr.output, "Requested address (%s) was offered", inet_ntoa(requested_address));
+                } else {
+                        sc_rqustd_addr = mp_set_subcheck_state(sc_rqustd_addr, STATE_WARNING);
+                        xasprintf(&sc_rqustd_addr.output, "Requested address (%s) was NOT offered", inet_ntoa(requested_address));
+                }
 
-        printf(".\n");
+                mp_add_subcheck_to_subcheck(&sc_dhcp_results, sc_rqustd_addr);
+        }
 
-        return result;
+        return sc_dhcp_results;
 }
 
 /* process command-line arguments */
-static int process_arguments(int argc, char **argv) {
+process_arguments_wrapper process_arguments(int argc, char **argv) {
         if (argc < 1) {
-                return ERROR;
+                process_arguments_wrapper tmp = {
+                        .error = ERROR,
+                };
+                return tmp;
         }
 
-        call_getopt(argc, argv);
-        return validate_arguments(argc);
-}
+        enum {
+                output_format_index = CHAR_MAX + 1,
+        };
 
-static int call_getopt(int argc, char **argv) {
-        extern int optind;
         int option_index = 0;
         static struct option long_options[] = {{"serverip", required_argument, 0, 's'},
                                                                                    {"requestedip", required_argument, 0, 'r'},
@@ -1092,65 +1148,55 @@ static int call_getopt(int argc, char **argv) {
                                                                                    {"verbose", no_argument, 0, 'v'},
                                                                                    {"version", no_argument, 0, 'V'},
                                                                                    {"help", no_argument, 0, 'h'},
+                                                                                   {"output-format", required_argument, 0, output_format_index},
                                                                                    {0, 0, 0, 0}};
 
-        int c = 0;
+        check_dhcp_config config = check_dhcp_config_init();
+        int option_char = 0;
         while (true) {
-                c = getopt_long(argc, argv, "+hVvxt:s:r:t:i:m:u", long_options, &option_index);
+                option_char = getopt_long(argc, argv, "+hVvxt:s:r:t:i:m:u", long_options, &option_index);
 
-                if (c == -1 || c == EOF || c == 1) {
+                if (option_char == -1 || option_char == EOF || option_char == 1) {
                         break;
                 }
 
-                switch (c) {
-
+                switch (option_char) {
                 case 's': /* DHCP server address */
-                        resolve_host(optarg, &dhcp_ip);
-                        add_requested_server(dhcp_ip);
+                        resolve_host(optarg, &config.dhcp_ip);
+                        add_requested_server(config.dhcp_ip, &config.num_of_requested_servers, &config.requested_server_list);
                         break;
 
                 case 'r': /* address we are requested from DHCP servers */
-                        resolve_host(optarg, &requested_address);
-                        request_specific_address = true;
+                        resolve_host(optarg, &config.requested_address);
+                        config.request_specific_address = true;
                         break;
 
                 case 't': /* timeout */
-
-                        /*
-                                 if(is_intnonneg(optarg))
-                                 */
                         if (atoi(optarg) > 0) {
-                                dhcpoffer_timeout = atoi(optarg);
+                                config.dhcpoffer_timeout = atoi(optarg);
                         }
-                        /*
-                                 else
-                                 usage("Time interval must be a nonnegative integer\n");
-                                 */
                         break;
 
                 case 'm': /* MAC address */
-
-                        if ((user_specified_mac = mac_aton(optarg)) == NULL) {
+                        if ((config.user_specified_mac = mac_aton(optarg)) == NULL) {
                                 usage("Cannot parse MAC address.\n");
                         }
                         if (verbose) {
-                                print_hardware_address(user_specified_mac);
+                                print_hardware_address(config.user_specified_mac);
                         }
-
                         break;
 
                 case 'i': /* interface name */
-
-                        strncpy(network_interface_name, optarg, sizeof(network_interface_name) - 1);
-                        network_interface_name[sizeof(network_interface_name) - 1] = '\x0';
-
+                        strncpy(config.network_interface_name, optarg, sizeof(config.network_interface_name) - 1);
+                        config.network_interface_name[sizeof(config.network_interface_name) - 1] = '\x0';
                         break;
 
                 case 'u': /* unicast testing */
-                        unicast = true;
+                        config.unicast_mode = true;
                         break;
+
                 case 'x': /* exclusive testing aka "rogue DHCP server detection" */
-                        exclusive = true;
+                        config.exclusive_mode = true;
                         break;
 
                 case 'V': /* version */
@@ -1164,6 +1210,18 @@ static int call_getopt(int argc, char **argv) {
                 case 'v': /* verbose */
                         verbose = 1;
                         break;
+                case output_format_index: {
+                        parsed_output_format parser = mp_parse_output_format(optarg);
+                        if (!parser.parsing_success) {
+                                // TODO List all available formats here, maybe add anothoer usage function
+                                printf("Invalid output format: %s\n", optarg);
+                                exit(STATE_UNKNOWN);
+                        }
+
+                        config.output_format_is_set = true;
+                        config.output_format = parser.output_format;
+                        break;
+                }
                 case '?': /* help */
                         usage5();
                         break;
@@ -1172,16 +1230,16 @@ static int call_getopt(int argc, char **argv) {
                         break;
                 }
         }
-        return optind;
-}
-
-static int validate_arguments(int argc) {
 
         if (argc - optind > 0) {
                 usage(_("Got unexpected non-option argument"));
         }
 
-        return OK;
+        process_arguments_wrapper result = {
+                .config = config,
+                .error = OK,
+        };
+        return result;
 }
 
 #if defined(__sun__) || defined(__solaris__) || defined(__hpux__)
@@ -1300,7 +1358,7 @@ static int dl_bind(int fd, int sap, u_char *addr) {
  *
  ***********************************************************************/
 
-static long mac_addr_dlpi(const char *dev, int unit, u_char *addr) {
+long mac_addr_dlpi(const char *dev, int unit, u_char *addr) {
         int fd;
         u_char mac_addr[25];
 
@@ -1319,26 +1377,27 @@ static long mac_addr_dlpi(const char *dev, int unit, u_char *addr) {
 #endif
 
 /* resolve host name or die (TODO: move this to netutils.c!) */
-static void resolve_host(const char *in, struct in_addr *out) {
-        struct addrinfo hints, *ai;
+void resolve_host(const char *name, struct in_addr *out) {
+        struct addrinfo hints = {
+                .ai_family = PF_INET,
+        };
+        struct addrinfo *addr_info;
 
-        memset(&hints, 0, sizeof(hints));
-        hints.ai_family = PF_INET;
-        if (getaddrinfo(in, NULL, &hints, &ai) != 0) {
+        if (getaddrinfo(name, NULL, &hints, &addr_info) != 0) {
                 usage_va(_("Invalid hostname/address - %s"), optarg);
         }
 
-        memcpy(out, &((struct sockaddr_in *)ai->ai_addr)->sin_addr, sizeof(*out));
-        freeaddrinfo(ai);
+        memcpy(out, &((struct sockaddr_in *)addr_info->ai_addr)->sin_addr, sizeof(*out));
+        freeaddrinfo(addr_info);
 }
 
 /* parse MAC address string, return 6 bytes (unterminated) or NULL */
-static unsigned char *mac_aton(const char *string) {
-        static unsigned char result[6];
+unsigned char *mac_aton(const char *string) {
+        static unsigned char result[MAC_ADDR_LEN];
         char tmp[3];
-        unsigned i, j;
+        unsigned byte_counter = 0;
 
-        for (i = 0, j = 0; string[i] != '\0' && j < sizeof(result); i++) {
+        for (int i = 0; string[i] != '\0' && byte_counter < sizeof(result); i++) {
                 /* ignore ':' and any other non-hex character */
                 if (!isxdigit(string[i]) || !isxdigit(string[i + 1])) {
                         continue;
@@ -1346,27 +1405,25 @@ static unsigned char *mac_aton(const char *string) {
                 tmp[0] = string[i];
                 tmp[1] = string[i + 1];
                 tmp[2] = '\0';
-                result[j] = strtol(tmp, (char **)NULL, 16);
+                result[byte_counter] = strtol(tmp, (char **)NULL, 16);
                 i++;
-                j++;
+                byte_counter++;
         }
 
-        return (j == 6) ? result : NULL;
+        return (byte_counter == MAC_ADDR_LEN) ? result : NULL;
 }
 
-static void print_hardware_address(const unsigned char *address) {
-        int i;
+void print_hardware_address(const unsigned char *address) {
 
         printf(_("Hardware address: "));
-        for (i = 0; i < 5; i++) {
-                printf("%2.2x:", address[i]);
+        for (int addr_idx = 0; addr_idx < MAC_ADDR_LEN; addr_idx++) {
+                printf("%2.2x:", address[addr_idx]);
         }
-        printf("%2.2x", address[i]);
         putchar('\n');
 }
 
 /* print usage help */
-static void print_help(void) {
+void print_help(void) {
 
         print_revision(progname, NP_VERSION);
 
@@ -1382,6 +1439,7 @@ static void print_help(void) {
         printf(UT_HELP_VRSN);
         printf(UT_EXTRA_OPTS);
 
+        printf(UT_OUTPUT_FORMAT);
         printf(UT_VERBOSE);
 
         printf(" %s\n", "-s, --serverip=IPADDRESS");
@@ -1400,7 +1458,6 @@ static void print_help(void) {
         printf("    %s\n", _("Only requested DHCP server may response (rogue DHCP server detection), requires -s"));
 
         printf(UT_SUPPORT);
-        return;
 }
 
 void print_usage(void) {
@@ -1408,6 +1465,4 @@ void print_usage(void) {
         printf("%s\n", _("Usage:"));
         printf(" %s [-v] [-u] [-x] [-s serverip] [-r requestedip] [-t timeout]\n", progname);
         printf("                  [-i interface] [-m mac]\n");
-
-        return;
 }