 @@ -1,2232 +1,2232 @@
-/*	$NetBSD: dhclient.c,v 1.3 2020/08/03 21:10:56 christos Exp $	*/
+/*	$NetBSD: dhclient.c,v 1.4 2021/05/26 22:52:31 christos Exp $	*/
 /* dhclient.c
    DHCP Client. */
 /*
- * Copyright (c) 2004-2020 by Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (c) 2004-2021 by Internet Systems Consortium, Inc. ("ISC")
  * Copyright (c) 1995-2003 by Internet Software Consortium
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
  *   Internet Systems Consortium, Inc.
  *   950 Charter Street
  *   Redwood City, CA 94063
  *   <info@isc.org>
  *   https://www.isc.org/
+ *
  * This code is based on the original client state machine that was
  * written by Elliot Poger.  The code has been extensively hacked on
  * by Ted Lemon since then, so any mistakes you find are probably his
  * fault and not Elliot's.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: dhclient.c,v 1.3 2020/08/03 21:10:56 christos Exp $");
+__RCSID("$NetBSD: dhclient.c,v 1.4 2021/05/26 22:52:31 christos Exp $");
 #include "dhcpd.h"
 #include <isc/util.h>
 #include <isc/file.h>
 #include <dns/result.h>
 #include <syslog.h>
 #include <signal.h>
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/wait.h>
 #include <limits.h>
 TIME default_lease_time = 43200; /* 12 hours... */
 TIME max_lease_time = 86400; /* 24 hours... */
 const char *path_dhclient_conf = _PATH_DHCLIENT_CONF;
 const char *path_dhclient_db = NULL;
 const char *path_dhclient_pid = NULL;
 static char path_dhclient_script_array[] = _PATH_DHCLIENT_SCRIPT;
 char *path_dhclient_script = path_dhclient_script_array;
 const char *path_dhclient_duid = NULL;
 static void add_to_tail(struct client_lease** lease_list, struct client_lease* lease);
 /* False (default) => we write and use a pid file */
 isc_boolean_t no_pid_file = ISC_FALSE;
 isc_boolean_t hw_mismatch_drop = ISC_TRUE;
 int dhcp_max_agent_option_packet_length = 0;
 int interfaces_requested = 0;
 int interfaces_left = 0;
 struct iaddr iaddr_broadcast = { 4, { 255, 255, 255, 255 } };
 struct iaddr iaddr_any = { 4, { 0, 0, 0, 0 } };
 struct in_addr inaddr_any;
 struct sockaddr_in sockaddr_broadcast;
 struct in_addr giaddr;
 struct data_string default_duid;
 int duid_type = 0;
 int duid_v4 = 0;
 int std_dhcid = 0;
 int decline_wait_time = 10; /* Default to 10 secs per, RFC 2131, 3.1.5 */
 /* ASSERT_STATE() does nothing now; it used to be
    assert (state_is == state_shouldbe). */
 #define ASSERT_STATE(state_is, state_shouldbe) {}
 #ifndef UNIT_TEST
-static const char copyright[] = "Copyright 2004-2020 Internet Systems Consortium.";
+static const char copyright[] = "Copyright 2004-2021 Internet Systems Consortium.";
 static const char arr [] = "All rights reserved.";
 static const char message [] = "Internet Systems Consortium DHCP Client";
 static const char url [] = "For info, please visit https://www.isc.org/software/dhcp/";
 #endif /* UNIT_TEST */
 u_int16_t local_port = 0;
 u_int16_t remote_port = 0;
 #if defined(DHCPv6) && defined(DHCP4o6)
 int dhcp4o6_state = -1; /* -1 = stopped, 0 = polling, 1 = started */
 #endif
 int no_daemon = 0;
 int dfd[2] = { -1, -1 };
 struct string_list *client_env = NULL;
 int client_env_count = 0;
 int onetry = 0;
 int quiet = 1;
 int nowait = 0;
 int stateless = 0;
 int wanted_ia_na = -1;		/* the absolute value is the real one. */
 int wanted_ia_ta = 0;
 int wanted_ia_pd = 0;
 int require_all_ias = 0;	/* If the user requires all of the IAs to
 				   be available before accepting a lease
 = no, 1 = requries */
 #if defined(DHCPv6)
 int dad_wait_time = 0;
 int prefix_len_hint = 0;
 #endif
 int address_prefix_len = DHCLIENT_DEFAULT_PREFIX_LEN;
 char *mockup_relay = NULL;
 libdhcp_callbacks_t dhclient_callbacks = {
 	&local_port,
 	&remote_port,
 	classify,
 	check_collection,
 	dhcp,
 #ifdef DHCPv6
 	dhcpv6,
 #endif /* DHCPv6 */
 	bootp,
 	find_class,
 	parse_allow_deny,
 	dhcp_set_control_state,
 };
 char *progname = NULL;
 void run_stateless(int exit_mode, u_int16_t port);
 static isc_result_t write_duid(struct data_string *duid);
 static void add_reject(struct packet *packet);
 static int check_domain_name(const char *ptr, size_t len, int dots);
 static int check_domain_name_list(const char *ptr, size_t len, int dots);
 static int check_option_values(struct universe *universe, unsigned int opt,
 			       const char *ptr, size_t len);
 #if defined(NSUPDATE)
 static void dhclient_ddns_cb_free(dhcp_ddns_cb_t *ddns_cb,
                                    char* file, int line);
 #endif /* defined NSUPDATE */
 static void
 setup(void) {
 	isc_result_t status;
 	/* Set up the isc and dns library managers */
 	status = dhcp_context_create(DHCP_CONTEXT_PRE_DB, NULL, NULL);
 	if (status != ISC_R_SUCCESS)
 		log_fatal("Can't initialize context: %s",
 			isc_result_totext(status));
 	/* Set up the OMAPI. */
 	status = omapi_init();
 	if (status != ISC_R_SUCCESS)
 		log_fatal("Can't initialize OMAPI: %s",
 			isc_result_totext(status));
 	/* Set up the OMAPI wrappers for various server database internal
 	   objects. */
 	dhcp_common_objects_setup();
 	dhcp_interface_discovery_hook = dhclient_interface_discovery_hook;
 	dhcp_interface_shutdown_hook = dhclient_interface_shutdown_hook;
 	dhcp_interface_startup_hook = dhclient_interface_startup_hook;
+}
 static void
 go_daemon(void)
+{
 	int pid;
 	if (pipe(dfd) == -1)
 		log_fatal("Can't get pipe: %m");
 	if ((pid = fork ()) < 0)
 		log_fatal("Can't fork daemon: %m");
 	if (pid != 0) {
 		/* Parent: wait for the child to start */
 		int n;
 		(void) close(dfd[1]);
 		do {
 			char buf;
 			n = read(dfd[0], &buf, 1);
 			if (n == 1)
 				_exit((int)buf);
 		} while (n == -1 && errno == EINTR);
 		_exit(1);
+	}
 	/* Child */
 	(void) close(dfd[0]);
+}
 static void
 add_interfaces(char **ifaces, int nifaces)
+{
 	isc_result_t status;
 	for (int i = 0; i < nifaces; i++) {
 		struct interface_info *tmp = NULL;
 		status = interface_allocate(&tmp, MDL);
 		if (status != ISC_R_SUCCESS)
 			log_fatal("Can't record interface %s:%s",
 		ifaces[i], isc_result_totext(status));
 		if (strlen(ifaces[i]) >= sizeof(tmp->name))
 			log_fatal("%s: interface name too long (is %ld)",
 		ifaces[i], (long)strlen(ifaces[i]));
 		strcpy(tmp->name, ifaces[i]);
 		if (interfaces) {
 			interface_reference(&tmp->next, interfaces, MDL);
 			interface_dereference(&interfaces, MDL);
+		}
 		interface_reference(&interfaces, tmp, MDL);
 		tmp->flags = INTERFACE_REQUESTED;
+	}
+}
 /*!
+ *
  * \brief Print the generic usage message
+ *
  * If the user has provided an incorrect command line print out
  * the description of the command line.  The arguments provide
  * a way for the caller to request more specific information about
  * the error be printed as well.  Mostly this will be that some
  * comamnd doesn't include its argument.
+ *
  * \param sfmt - The basic string and format for the specific error
  * \param sarg - Generally the offending argument from the comamnd line.
+ *
  * \return Nothing
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: dhclient.c,v 1.3 2020/08/03 21:10:56 christos Exp $");
+__RCSID("$NetBSD: dhclient.c,v 1.4 2021/05/26 22:52:31 christos Exp $");
 #if defined(DHCPv6) && defined(DHCP4o6)
 static void dhcp4o6_poll(void *dummy);
 static void dhcp4o6_resume(void);
 static void recv_dhcpv4_response(struct data_string *raw);
 static int send_dhcpv4_query(struct client_state *client, int broadcast);
 static void dhcp4o6_stop(void);
 static void forw_dhcpv4_response(struct packet *packet);
 static void forw_dhcpv4_query(struct data_string *raw);
 #endif
 #ifndef UNIT_TEST
 /* These are only used when we call usage() from the main routine
  * which isn't compiled when building for unit tests
  */
 static const char use_noarg[] = "No argument for command: %s";
 #ifdef DHCPv6
 static const char use_v6command[] = "Command not used for DHCPv4: %s";
 #endif
 #ifdef DHCPv6
 #ifdef DHCP4o6
 #define DHCLIENT_USAGE0 \
 "[-4|-6] [-SNTPRI1dvrxi] [-nw] -4o6 <port>] [-p <port>] [-D LL|LLT]\n" \
 "                [--dad-wait-time <seconds>] [--prefix-len-hint <length>]\n" \
 "                [--decline-wait-time <seconds>]\n" \
 "                [--address-prefix-len <length>]\n"
 #else /* DHCP4o6 */
 #define DHCLIENT_USAGE0 \
 "[-4|-6] [-SNTPRI1dvrxi] [-nw] [-p <port>] [-D LL|LLT]\n" \
 "                [--dad-wait-time <seconds>] [--prefix-len-hint <length>]\n" \
 "                [--decline-wait-time <seconds>]\n" \
 "                [--address-prefix-len <length>]\n"
 #endif
 #else /* DHCPv6 */
 #define DHCLIENT_USAGE0 \
 "[-I1dvrxi] [-nw] [-p <port>] [-D LL|LLT] \n" \
 "                [--decline-wait-time <seconds>]\n"
 #endif
 #define DHCLIENT_USAGEC \
 "                [-s server-addr] [-cf config-file]\n" \
 "                [-df duid-file] [-lf lease-file]\n" \
 "                [-pf pid-file] [--no-pid] [-e VAR=val]\n" \
 "                [-sf script-file] [interface]*"
 #define DHCLIENT_USAGEH "{--version|--help|-h}"
 static void
 usage(const char *sfmt, const char *sarg)
+{
 	log_info("%s %s", message, PACKAGE_VERSION);
 	log_info(copyright);
 	log_info(arr);
 	log_info(url);
 	/* If desired print out the specific error message */
 #ifdef PRINT_SPECIFIC_CL_ERRORS
 	if (sfmt != NULL)
 		log_error(sfmt, sarg);
 #endif
 	log_fatal("Usage: %s %s%s\n       %s %s",
 		  isc_file_basename(progname),
 		  DHCLIENT_USAGE0,
 		  DHCLIENT_USAGEC,
 		  isc_file_basename(progname),
 		  DHCLIENT_USAGEH);
+}
 extern void initialize_client_option_spaces(void);
 int
 main(int argc, char **argv) {
 	int fd;
 	int i;
 	struct interface_info *ip;
 	struct client_state *client;
 	unsigned seed;
 	char *server = NULL;
 	int exit_mode = 0;
 	int release_mode = 0;
 	struct timeval tv;
 	omapi_object_t *listener;
 	isc_result_t result;
 	int persist = 0;
 	int no_dhclient_conf = 0;
 	int no_dhclient_db = 0;
 	int no_dhclient_pid = 0;
 	int no_dhclient_script = 0;
 #ifdef DHCPv6
 	int local_family_set = 0;
 #ifdef DHCP4o6
 	u_int16_t dhcp4o6_port = 0;
 #endif /* DHCP4o6 */
 #endif /* DHCPv6 */
 	char *s;
 	char **ifaces;
 	libdhcp_callbacks_register(&dhclient_callbacks);
 #ifdef OLD_LOG_NAME
 	progname = "dhclient";
 #else
 	progname = argv[0];
 #endif
 	/* Initialize client globals. */
 	memset(&default_duid, 0, sizeof(default_duid));
 	/* Make sure that file descriptors 0 (stdin), 1, (stdout), and
 (stderr) are open. To do this, we assume that when we
 	   open a file the lowest available file descriptor is used. */
 	fd = open("/dev/null", O_RDWR);
 	if (fd == 0)
 		fd = open("/dev/null", O_RDWR);
 	if (fd == 1)
 		fd = open("/dev/null", O_RDWR);
 	if (fd == 2)
 		log_perror = 0; /* No sense logging to /dev/null. */
 	else if (fd != -1)
 		close(fd);
 	openlog(isc_file_basename(progname), DHCP_LOG_OPTIONS, LOG_DAEMON);
 #if !(defined(DEBUG) || defined(__CYGWIN32__))
 	setlogmask(LOG_UPTO(LOG_INFO));
 #endif
 	if ((ifaces = malloc(sizeof(*ifaces) * argc)) == NULL) {
 		log_fatal("Can't allocate memory");
 		return 1;
+	}
 	/* Parse arguments changing no_daemon */
 	for (i = 1; i < argc; i++) {
 		if (!strcmp(argv[i], "-r")) {
 			no_daemon = 1;
 		} else if (!strcmp(argv[i], "-x")) {
 			no_daemon = 0;
 		} else if (!strcmp(argv[i], "-d")) {
 			no_daemon = 1;
 		} else if (!strcmp(argv[i], "--version")) {
 			const char vstring[] = "isc-dhclient-";
 			IGNORE_RET(write(STDERR_FILENO, vstring,
 					 strlen(vstring)));
 			IGNORE_RET(write(STDERR_FILENO,
 					 PACKAGE_VERSION,
 					 strlen(PACKAGE_VERSION)));
 			IGNORE_RET(write(STDERR_FILENO, "\n", 1));
 			exit(0);
 		} else if (!strcmp(argv[i], "--help") ||
 			   !strcmp(argv[i], "-h")) {
 			const char *pname = isc_file_basename(progname);
 			IGNORE_RET(write(STDERR_FILENO, "Usage: ", 7));
 			IGNORE_RET(write(STDERR_FILENO, pname, strlen(pname)));
 			IGNORE_RET(write(STDERR_FILENO, " ", 1));
 			IGNORE_RET(write(STDERR_FILENO, DHCLIENT_USAGE0,
 					 strlen(DHCLIENT_USAGE0)));
 			IGNORE_RET(write(STDERR_FILENO, DHCLIENT_USAGEC,
 					 strlen(DHCLIENT_USAGEC)));
 			IGNORE_RET(write(STDERR_FILENO, "\n", 1));
 			IGNORE_RET(write(STDERR_FILENO, "       ", 7));
 			IGNORE_RET(write(STDERR_FILENO, pname, strlen(pname)));
 			IGNORE_RET(write(STDERR_FILENO, " ", 1));
 			IGNORE_RET(write(STDERR_FILENO, DHCLIENT_USAGEH,
 					 strlen(DHCLIENT_USAGEH)));
 			IGNORE_RET(write(STDERR_FILENO, "\n", 1));
 			exit(0);
+		}
+	}
 	/* When not forbidden prepare to become a daemon */
 	if (!no_daemon) {
 		go_daemon();
+	}
 	setup();
 	for (i = 1; i < argc; i++) {
 		if (!strcmp(argv[i], "-r")) {
 			release_mode = 1;
 			/* no_daemon = 1; */
 #ifdef DHCPv6
 		} else if (!strcmp(argv[i], "-4")) {
 			if (local_family_set && local_family != AF_INET)
 				log_fatal("Client can only do v4 or v6, not "
 					  "both.");
 			local_family_set = 1;
 			local_family = AF_INET;
 		} else if (!strcmp(argv[i], "-6")) {
 			if (local_family_set && local_family != AF_INET6)
 				log_fatal("Client can only do v4 or v6, not "
 					  "both.");
 			local_family_set = 1;
 			local_family = AF_INET6;
 #ifdef DHCP4o6
 		} else if (!strcmp(argv[i], "-4o6")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			dhcp4o6_port = validate_port_pair(argv[i]);
 			log_debug("DHCPv4 over DHCPv6 over ::1 port %d and %d",
 				  ntohs(dhcp4o6_port),
 				  ntohs(dhcp4o6_port) + 1);
 			dhcpv4_over_dhcpv6 = 1;
 #endif /* DHCP4o6 */
 #endif /* DHCPv6 */
 		} else if (!strcmp(argv[i], "-x")) { /* eXit, no release */
 			release_mode = 0;
 			/* no_daemon = 0; */
 			exit_mode = 1;
 		} else if (!strcmp(argv[i], "-p")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			local_port = validate_port(argv[i]);
 			log_debug("binding to user-specified port %d",
 				  ntohs(local_port));
 		} else if (!strcmp(argv[i], "-d")) {
 			/* no_daemon = 1; */
 			quiet = 0;
 		} else if (!strcmp(argv[i], "-pf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhclient_pid = argv[i];
 			no_dhclient_pid = 1;
 		} else if (!strcmp(argv[i], "--no-pid")) {
 			no_pid_file = ISC_TRUE;
 		} else if (!strcmp(argv[i], "-cf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhclient_conf = argv[i];
 			no_dhclient_conf = 1;
 		} else if (!strcmp(argv[i], "-df")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhclient_duid = argv[i];
 		} else if (!strcmp(argv[i], "-lf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhclient_db = argv[i];
 			no_dhclient_db = 1;
 		} else if (!strcmp(argv[i], "-sf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhclient_script = argv[i];
 			no_dhclient_script = 1;
 		} else if (!strcmp(argv[i], "-1")) {
 			onetry = 1;
 		} else if (!strcmp(argv[i], "-q")) {
 			quiet = 1;
 		} else if (!strcmp(argv[i], "-s")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			server = argv[i];
 		} else if (!strcmp(argv[i], "-g")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			mockup_relay = argv[i];
 		} else if (!strcmp(argv[i], "-nw")) {
 			nowait = 1;
 		} else if (!strcmp(argv[i], "-n")) {
 			/* do not start up any interfaces */
 			interfaces_requested = -1;
 		} else if (!strcmp(argv[i], "-w")) {
 			/* do not exit if there are no broadcast interfaces. */
 			persist = 1;
 		} else if (!strcmp(argv[i], "-e")) {
 			struct string_list *tmp;
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			tmp = dmalloc(strlen(argv[i]) + sizeof *tmp, MDL);
 			if (!tmp)
 				log_fatal("No memory for %s", argv[i]);
 			strcpy(tmp->string, argv[i]);
 			tmp->next = client_env;
 			client_env = tmp;
 			client_env_count++;
 #ifdef DHCPv6
 		} else if (!strcmp(argv[i], "-S")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			wanted_ia_na = 0;
 			stateless = 1;
 		} else if (!strcmp(argv[i], "-N")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			if (wanted_ia_na < 0) {
 				wanted_ia_na = 0;
+			}
 			wanted_ia_na++;
 		} else if (!strcmp(argv[i], "-T")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			if (wanted_ia_na < 0) {
 				wanted_ia_na = 0;
+			}
 			wanted_ia_ta++;
 		} else if (!strcmp(argv[i], "-P")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			if (wanted_ia_na < 0) {
 				wanted_ia_na = 0;
+			}
 			wanted_ia_pd++;
 		} else if (!strcmp(argv[i], "-R")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			require_all_ias = 1;
 		} else if (!strcmp(argv[i], "--dad-wait-time")) {
 			if (++i == argc) {
 				usage(use_noarg, argv[i-1]);
+			}
 			errno = 0;
 			dad_wait_time = (int)strtol(argv[i], &s, 10);
 			if (errno || (*s != '\0') || (dad_wait_time < 0)) {
 				usage("Invalid value for --dad-wait-time: %s",
 				      argv[i]);
+			}
 		} else if (!strcmp(argv[i], "--prefix-len-hint")) {
 			if (++i == argc) {
 				usage(use_noarg, argv[i-1]);
+			}
 			errno = 0;
 			prefix_len_hint = (int)strtol(argv[i], &s, 10);
 			if (errno || (*s != '\0') || (prefix_len_hint < 0)) {
 				usage("Invalid value for --prefix-len-hint: %s",
 				      argv[i]);
+			}
 		} else if (!strcmp(argv[i], "--address-prefix-len")) {
 			if (++i == argc) {
 				usage(use_noarg, argv[i-1]);
+			}
 			errno = 0;
 			address_prefix_len = (int)strtol(argv[i], &s, 10);
 			if (errno || (*s != '\0') ||
 			    (address_prefix_len < 0)) {
 				usage("Invalid value for"
 				      " --address-prefix-len: %s", argv[i]);
+			}
 #endif /* DHCPv6 */
 		} else if (!strcmp(argv[i], "--decline-wait-time")) {
 			if (++i == argc) {
 				usage(use_noarg, argv[i-1]);
+			}
 			errno = 0;
 			decline_wait_time = (int)strtol(argv[i], &s, 10);
 			if (errno || (*s != '\0') ||
 			    (decline_wait_time < 0)) {
 				usage("Invalid value for "
 				      "--decline-wait-time: %s", argv[i]);
+			}
 		} else if (!strcmp(argv[i], "-D")) {
 			duid_v4 = 1;
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			if (!strcasecmp(argv[i], "LL")) {
 				duid_type = DUID_LL;
 			} else if (!strcasecmp(argv[i], "LLT")) {
 				duid_type = DUID_LLT;
 			} else {
 				usage("Unknown argument to -D: %s", argv[i]);
+			}
 		} else if (!strcmp(argv[i], "-i")) {
 			/* enable DUID support for DHCPv4 clients */
 			duid_v4 = 1;
 		} else if (!strcmp(argv[i], "-I")) {
 			/* enable standard DHCID support for DDNS updates */
 			std_dhcid = 1;
 		} else if (!strcmp(argv[i], "-m")) {
 			hw_mismatch_drop = ISC_FALSE;
 		} else if (!strcmp(argv[i], "-v")) {
 			quiet = 0;
 		} else if (argv[i][0] == '-') {
 			usage("Unknown command: %s", argv[i]);
 		} else if (interfaces_requested < 0) {
 			usage("No interfaces comamnd -n and "
 			      " requested interface %s", argv[i]);
 		} else {
 		    ifaces[interfaces_requested++] = argv[i];
+		}
+	}
 	/*
 	 * Do this before setup, otherwise if we are using threads things
 	 * are not going to work
 	 */
 	if (interfaces_requested > 0) {
 		add_interfaces(ifaces, interfaces_requested);
 		interfaces_left = interfaces_requested;
+	}
 	free(ifaces);
 	if (wanted_ia_na < 0) {
 		wanted_ia_na = 1;
+	}
 	/* Support only one (requested) interface for Prefix Delegation. */
 	if (wanted_ia_pd && (interfaces_requested != 1)) {
 		usage("PD %s only supports one requested interface", "-P");
+	}
 #if defined(DHCPv6) && defined(DHCP4o6)
 	if ((local_family == AF_INET6) && dhcpv4_over_dhcpv6 &&
 	    (exit_mode || release_mode))
 		log_error("Can't relay DHCPv4-over-DHCPv6 "
 			  "without a persistent DHCPv6 client");
 	if ((local_family == AF_INET) && dhcpv4_over_dhcpv6 &&
 	    (interfaces_requested != 1))
 		log_fatal("DHCPv4-over-DHCPv6 requires an explicit "
 			  "interface on which to be applied");
 #endif
 	if (!no_dhclient_conf && (s = getenv("PATH_DHCLIENT_CONF"))) {
 		path_dhclient_conf = s;
+	}
 	if (!no_dhclient_db && (s = getenv("PATH_DHCLIENT_DB"))) {
 		path_dhclient_db = s;
+	}
 	if (!no_dhclient_pid && (s = getenv("PATH_DHCLIENT_PID"))) {
 		path_dhclient_pid = s;
+	}
 	if (!no_dhclient_script && (s = getenv("PATH_DHCLIENT_SCRIPT"))) {
 		path_dhclient_script = s;
+	}
 	/* Set up the initial dhcp option universe. */
 	initialize_common_option_spaces();
 	/* Set up the initial client option universe. */
 	initialize_client_option_spaces();
 	/* Assign v4 or v6 specific running parameters. */
 	if (local_family == AF_INET)
 		dhcpv4_client_assignments();
 #ifdef DHCPv6
 	else if (local_family == AF_INET6)
 		dhcpv6_client_assignments();
 #endif /* DHCPv6 */
 	else
 		log_fatal("Impossible condition at %s:%d.", MDL);
 	/*
 	 * convert relative path names to absolute, for files that need
 	 * to be reopened after chdir() has been called
 	 */
 	if (path_dhclient_db[0] != '/') {
 		path_dhclient_db = absolute_path(path_dhclient_db);
+	}
 	if (path_dhclient_script[0] != '/') {
 		path_dhclient_script = absolute_path(path_dhclient_script);
+	}
 	/*
 	 * See if we should  kill off any currently running client
 	 * we don't try to kill it off if the user told us not
 	 * to write a pid file - we assume they are controlling
 	 * the process in some other fashion.
 	 */
 	if (path_dhclient_pid != NULL &&
 	    (release_mode || exit_mode) && (no_pid_file == ISC_FALSE)) {
 		FILE *pidfd;
 		pid_t oldpid;
 		long temp;
 		int e;
 		if ((pidfd = fopen(path_dhclient_pid, "r")) != NULL) {
 			e = fscanf(pidfd, "%ld\n", &temp);
 			oldpid = (pid_t)temp;
 			if (e != 0 && e != EOF && oldpid) {
 				if (kill(oldpid, SIGTERM) == 0) {
 					log_info("Killed old client process");
 					(void) unlink(path_dhclient_pid);
 					/*
 					 * wait for the old process to
 					 * cleanly terminate.
 					 * Note kill() with sig=0 could
 					 * detect termination but only
 					 * the parent can be signaled...
 					 */
 					sleep(1);
 				} else if (errno == ESRCH) {
 					log_info("Removed stale PID file");
 					(void) unlink(path_dhclient_pid);
+				}
+			}
 			fclose(pidfd);
+		}
+	}
 	if (!quiet) {
 		log_info("%s %s", message, PACKAGE_VERSION);
 		log_info(copyright);
 		log_info(arr);
 		log_info(url);
 		log_info("%s", "");
 	} else {
 		log_perror = 0;
 		quiet_interface_discovery = 1;
+	}
 	/* If we're given a relay agent address to insert, for testing
 	   purposes, figure out what it is. */
 	if (mockup_relay) {
 		if (!inet_aton(mockup_relay, &giaddr)) {
 			struct hostent *he;
 			he = gethostbyname(mockup_relay);
 			if (he) {
 				memcpy(&giaddr, he->h_addr_list[0],
 				       sizeof giaddr);
 			} else {
 				log_fatal("%s: no such host", mockup_relay);
+			}
+		}
+	}
 	/* Get the current time... */
 	gettimeofday(&cur_tv, NULL);
 	sockaddr_broadcast.sin_family = AF_INET;
 	sockaddr_broadcast.sin_port = remote_port;
 	if (server) {
 		if (!inet_aton(server, &sockaddr_broadcast.sin_addr)) {
 			struct hostent *he;
 			he = gethostbyname(server);
 			if (he) {
 				memcpy(&sockaddr_broadcast.sin_addr,
 				       he->h_addr_list[0],
 				       sizeof sockaddr_broadcast.sin_addr);
 			} else
 				sockaddr_broadcast.sin_addr.s_addr =
 					INADDR_BROADCAST;
+		}
 	} else {
 		sockaddr_broadcast.sin_addr.s_addr = INADDR_BROADCAST;
+	}
 	inaddr_any.s_addr = INADDR_ANY;
 	/* Stateless special case. */
 	if (stateless) {
 		if (release_mode || (wanted_ia_na > 0) ||
 		    wanted_ia_ta || wanted_ia_pd ||
 		    (interfaces_requested != 1)) {
 			usage("Stateless command: %s incompatibile with "
 			      "other commands", "-S");
+		}
 #if defined(DHCPv6) && defined(DHCP4o6)
 		run_stateless(exit_mode, dhcp4o6_port);
 #else
 		run_stateless(exit_mode, 0);
 #endif
 		finish(0);
+	}
 	/* Discover all the network interfaces. */
 	discover_interfaces(DISCOVER_UNCONFIGURED);
 	/* Parse the dhclient.conf file. */
 	read_client_conf();
 	/* Parse the lease database. */
 	read_client_leases();
 	/* If desired parse the secondary lease database for a DUID */
 	if ((default_duid.len == 0) && (path_dhclient_duid != NULL)) {
 		read_client_duid();
+	}
 	/* Rewrite the lease database... */
 	rewrite_client_leases();
 	/* XXX */
 /* 	config_counter(&snd_counter, &rcv_counter); */
 	/*
 	 * If no broadcast interfaces were discovered, call the script
 	 * and tell it so.
 	 */
 	if (!interfaces) {
 		/*
 		 * Call dhclient-script with the NBI flag,
 		 * in case somebody cares.
 		 */
 		script_init(NULL, "NBI", NULL);
 		script_go(NULL);
 		/*
 		 * If we haven't been asked to persist, waiting for new
 		 * interfaces, then just exit.
 		 */
 		if (!persist) {
 			/* Nothing more to do. */
 			log_info("No broadcast interfaces found - exiting.");
 			finish(0);
+		}
 	} else if (!release_mode && !exit_mode) {
 		/* Call the script with the list of interfaces. */
 		for (ip = interfaces; ip; ip = ip->next) {
 			/*
 			 * If interfaces were specified, don't configure
 			 * interfaces that weren't specified!
 			 */
 			if ((interfaces_requested > 0) &&
 			    ((ip->flags & (INTERFACE_REQUESTED |
 					   INTERFACE_AUTOMATIC)) !=
 			     INTERFACE_REQUESTED))
 				continue;
 			if (local_family == AF_INET6) {
 				script_init(ip->client, "PREINIT6", NULL);
 			} else {
 				script_init(ip->client, "PREINIT", NULL);
 			    	if (ip->client->alias != NULL)
 					script_write_params(ip->client,
 							    "alias_",
 							    ip->client->alias);
+			}
 			script_go(ip->client);
+		}
+	}
 	/* At this point, all the interfaces that the script thinks
 	   are relevant should be running, so now we once again call
 	   discover_interfaces(), and this time ask it to actually set
 	   up the interfaces. */
 	discover_interfaces(interfaces_requested != 0
 			    ? DISCOVER_REQUESTED
 			    : DISCOVER_RUNNING);
 	/* Make up a seed for the random number generator from current
 	   time plus the sum of the last four bytes of each
 	   interface's hardware address interpreted as an integer.
 	   Not much entropy, but we're booting, so we're not likely to
 	   find anything better. */
 	seed = 0;
 	for (ip = interfaces; ip; ip = ip->next) {
 		int junk;
 		memcpy(&junk,
 		       &ip->hw_address.hbuf[ip->hw_address.hlen -
 					    sizeof seed], sizeof seed);
 		seed += junk;
+	}
 	srandom(seed + cur_time + (unsigned)getpid());
 	/*
 	 * Establish a default DUID.  We always do so for v6 and
 	 * do so if desired for v4 via the -D or -i options
 	 */
 	if ((local_family == AF_INET6) ||
 	    ((local_family == AF_INET) && (duid_v4 == 1))) {
 		if (default_duid.len == 0) {
 			if (default_duid.buffer != NULL)
 				data_string_forget(&default_duid, MDL);
 			form_duid(&default_duid, MDL);
 			write_duid(&default_duid);
+		}
+	}
 #if defined(DHCPv6) && defined(DHCP4o6)
 	if (dhcpv4_over_dhcpv6 && !exit_mode)
 		dhcp4o6_setup(dhcp4o6_port);
 #endif
 	/* Start a configuration state machine for each interface. */
 #ifdef DHCPv6
 	if (local_family == AF_INET6) {
 		for (ip = interfaces ; ip != NULL ; ip = ip->next) {
 			for (client = ip->client ; client != NULL ;
 			     client = client->next) {
 				if (release_mode) {
 					start_release6(client);
 					continue;
 				} else if (exit_mode) {
 					unconfigure6(client, "STOP6");
 					continue;
+				}
 				/* If we have a previous binding, Confirm
 				 * that we can (or can't) still use it.
 				 */
 				if ((client->active_lease != NULL) &&
 				    !client->active_lease->released)
 					start_confirm6(client);
 				else
 					start_init6(client);
+			}
+		}
 	} else
 #endif /* DHCPv6 */
+	{
 		for (ip = interfaces ; ip ; ip = ip->next) {
 			ip->flags |= INTERFACE_RUNNING;
 			for (client = ip->client ; client ;
 			     client = client->next) {
 				if (exit_mode)
 					state_stop(client);
 				if (release_mode)
 					do_release(client);
 				else {
 					client->state = S_INIT;
 					if (top_level_config.initial_delay>0)
+					{
 						tv.tv_sec = 0;
 						if (top_level_config.
 						    initial_delay>1)
 							tv.tv_sec = cur_time
 							+ random()
 							% (top_level_config.
 							   initial_delay-1);
 						tv.tv_usec = random()
 							% 1000000;
 						/*
 						 * this gives better
 						 * distribution than just
 						 *whole seconds
 						 */
 						add_timeout(&tv, state_reboot,
 						            client, 0, 0);
 					} else {
 						state_reboot(client);
+					}
+				}
+			}
+		}
+	}
 	if (exit_mode)
 		finish(0);
 	if (release_mode) {
 #ifndef DHCPv6
 		finish(0);
 #else
 		if ((local_family == AF_INET6) || dhcpv4_over_dhcpv6) {
 			if (onetry)
 				finish(0);
 		} else
 			finish(0);
 #endif /* DHCPv6 */
+	}
 	/* Start up a listener for the object management API protocol. */
 	if (top_level_config.omapi_port != -1) {
 		listener = NULL;
 		result = omapi_generic_new(&listener, MDL);
 		if (result != ISC_R_SUCCESS)
 			log_fatal("Can't allocate new generic object: %s\n",
 				  isc_result_totext(result));
 		result = omapi_protocol_listen(listener,
 					       (unsigned)
 					       top_level_config.omapi_port,
 );
 		if (result != ISC_R_SUCCESS)
 			log_fatal("Can't start OMAPI protocol: %s",
 				  isc_result_totext (result));
+	}
 	/* Set up the bootp packet handler... */
 	bootp_packet_handler = do_packet;
 #ifdef DHCPv6
 	dhcpv6_packet_handler = do_packet6;
 #endif /* DHCPv6 */
 #if defined(DEBUG_MEMORY_LEAKAGE) || defined(DEBUG_MALLOC_POOL) || \
 		defined(DEBUG_MEMORY_LEAKAGE_ON_EXIT)
 	dmalloc_cutoff_generation = dmalloc_generation;
 	dmalloc_longterm = dmalloc_outstanding;
 	dmalloc_outstanding = 0;
 #endif
 #if defined(ENABLE_GENTLE_SHUTDOWN)
 	/* no signal handlers until we deal with the side effects */
         /* install signal handlers */
 	signal(SIGINT, dhcp_signal_handler);   /* control-c */
 	signal(SIGTERM, dhcp_signal_handler);  /* kill */
 #endif
 	/* If we're not supposed to wait before getting the address,
 	   don't. */
 	if (nowait)
 		detach();
 	/* If we're not going to daemonize, write the pid file
 	   now. */
 	if (no_daemon || nowait)
 		write_client_pid_file();
 	/* Start dispatching packets and timeouts... */
 	dispatch();
 	/* In fact dispatch() never returns. */
 	return 0;
+}
 /*
  * \brief Run the DHCPv6 stateless client (dhclient -6 -S)
+ *
  * \param exist_mode set to 1 when dhclient was called with -x
  * \param port DHCPv4-over-DHCPv6 client inter-process communication
  *  UDP port pair (port,port+1 with port in network byte order)
  */
 void run_stateless(int exit_mode, u_int16_t port)
+{
 #ifdef DHCPv6
 	struct client_state *client;
 	omapi_object_t *listener;
 	isc_result_t result;
 #ifndef DHCP4o6
 	IGNORE_UNUSED(port);
 #endif
 	/* Discover the network interface. */
 	discover_interfaces(DISCOVER_REQUESTED);
 	if (!interfaces)
 		usage("No interfaces available for stateless command: %s", "-S");
 	/* Parse the dhclient.conf file. */
 #ifdef DHCP4o6
 	if (dhcpv4_over_dhcpv6) {
 		/* Mark we want to request IRT too! */
 		dhcpv4_over_dhcpv6++;
+	}
 #endif
 	read_client_conf();
 	/* Parse the lease database. */
 	read_client_leases();
 	/* If desired parse the secondary lease database for a DUID */
 	if ((default_duid.len == 0) && (path_dhclient_duid != NULL)) {
 		read_client_duid();
+	}
 	/* Establish a default DUID. */
 	if (default_duid.len == 0) {
 		if (default_duid.buffer != NULL)
 			data_string_forget(&default_duid, MDL);
 		form_duid(&default_duid, MDL);
+	}
 #ifdef DHCP4o6
 	if (dhcpv4_over_dhcpv6 && !exit_mode)
 		dhcp4o6_setup(port);
 #endif
 	/* Start a configuration state machine. */
 	for (client = interfaces->client ;
 	     client != NULL ;
 	     client = client->next) {
 		if (exit_mode) {
 			unconfigure6(client, "STOP6");
 			continue;
+		}
 		start_info_request6(client);
+	}
 	if (exit_mode)
 		return;
 	/* Start up a listener for the object management API protocol. */
 	if (top_level_config.omapi_port != -1) {
 		listener = NULL;
 		result = omapi_generic_new(&listener, MDL);
 		if (result != ISC_R_SUCCESS)
 			log_fatal("Can't allocate new generic object: %s\n",
 				  isc_result_totext(result));
 		result = omapi_protocol_listen(listener,
 					       (unsigned)
 					       top_level_config.omapi_port,
 );
 		if (result != ISC_R_SUCCESS)
 			log_fatal("Can't start OMAPI protocol: %s",
 				  isc_result_totext(result));
+	}
 	/* Set up the packet handler... */
 	dhcpv6_packet_handler = do_packet6;
 #if defined(DEBUG_MEMORY_LEAKAGE) || defined(DEBUG_MALLOC_POOL) || \
 		defined(DEBUG_MEMORY_LEAKAGE_ON_EXIT)
 	dmalloc_cutoff_generation = dmalloc_generation;
 	dmalloc_longterm = dmalloc_outstanding;
 	dmalloc_outstanding = 0;
 #endif
 	/* If we're not supposed to wait before getting the address,
 	   don't. */
 	if (nowait)
 		detach();
 	/* If we're not going to daemonize, write the pid file
 	   now. */
 	if (no_daemon || nowait)
 		write_client_pid_file();
 	/* Start dispatching packets and timeouts... */
 	dispatch();
 #endif /* DHCPv6 */
 	return;
+}
 #endif /* !UNIT_TEST */
 isc_result_t find_class (struct class **c,
 		const char *s, const char *file, int line)
+{
 	return 0;
+}
 int check_collection (packet, lease, collection)
 	struct packet *packet;
 	struct lease *lease;
 	struct collection *collection;
+{
 	return 0;
+}
 void classify (packet, class)
 	struct packet *packet;
 	struct class *class;
+{
+}
 void unbill_class (lease)
 	struct lease *lease;
+{
+}
 int find_subnet (struct subnet **sp,
 		 struct iaddr addr, const char *file, int line)
+{
 	return 0;
+}
 /* Individual States:
+ *
  * Each routine is called from the dhclient_state_machine() in one of
  * these conditions:
  * -> entering INIT state
  * -> recvpacket_flag == 0: timeout in this state
  * -> otherwise: received a packet in this state
+ *
  * Return conditions as handled by dhclient_state_machine():
  * Returns 1, sendpacket_flag = 1: send packet, reset timer.
  * Returns 1, sendpacket_flag = 0: just reset the timer (wait for a milestone).
  * Returns 0: finish the nap which was interrupted for no good reason.
+ *
  * Several per-interface variables are used to keep track of the process:
  *   active_lease: the lease that is being used on the interface
  *                 (null pointer if not configured yet).
  *   offered_leases: leases corresponding to DHCPOFFER messages that have
  *		     been sent to us by DHCP servers.
  *   acked_leases: leases corresponding to DHCPACK messages that have been
  *		   sent to us by DHCP servers.
  *   sendpacket: DHCP packet we're trying to send.
  *   destination: IP address to send sendpacket to
  * In addition, there are several relevant per-lease variables.
  *   T1_expiry, T2_expiry, lease_expiry: lease milestones
  * In the active lease, these control the process of renewing the lease;
  * In leases on the acked_leases list, this simply determines when we
  * can no longer legitimately use the lease.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: dhclient.c,v 1.3 2020/08/03 21:10:56 christos Exp $");
+__RCSID("$NetBSD: dhclient.c,v 1.4 2021/05/26 22:52:31 christos Exp $");
 void state_reboot (cpp)
 	void *cpp;
+{
 	struct client_state *client = cpp;
 #if defined(DHCPv6) && defined(DHCP4o6)
 	if (dhcpv4_over_dhcpv6 && (dhcp4o6_state <= 0)) {
 		if (dhcp4o6_state < 0)
 			dhcp4o6_poll(NULL);
 		client->pending = P_REBOOT;
 		return;
+	}
 #endif
 	client->pending= P_NONE;
 	/* If we don't remember an active lease, go straight to INIT. */
 	if (!client -> active ||
 	    client -> active -> is_bootp ||
 	    client -> active -> expiry <= cur_time) {
 		state_init (client);
 		return;
+	}
 	/* We are in the rebooting state. */
 	client -> state = S_REBOOTING;
 	/*
 	 * make_request doesn't initialize xid because it normally comes
 	 * from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER,
 	 * so pick an xid now.
 	 */
 	client -> xid = random ();
 	/*
 	 * Make a DHCPREQUEST packet, and set
 	 * appropriate per-interface flags.
 	 */
 	make_request (client, client -> active);
 	client -> destination = iaddr_broadcast;
 	client -> first_sending = cur_time;
 	client -> interval = client -> config -> initial_interval;
 	/* Zap the medium list... */
 	client -> medium = NULL;
 	/* Send out the first DHCPREQUEST packet. */
 	send_request (client);
+}
 /* Called when a lease has completely expired and we've been unable to
    renew it. */
 void state_init (cpp)
 	void *cpp;
+{
 	struct client_state *client = cpp;
 	ASSERT_STATE(state, S_INIT);
 	/* Make a DHCPDISCOVER packet, and set appropriate per-interface
 	   flags. */
 	make_discover (client, client -> active);
 	client -> xid = client -> packet.xid;
 	client -> destination = iaddr_broadcast;
 	client -> state = S_SELECTING;
 	client -> first_sending = cur_time;
 	client -> interval = client -> config -> initial_interval;
 	/* Add an immediate timeout to cause the first DHCPDISCOVER packet
 	   to go out. */
 	send_discover (client);
+}
 /*
  * state_selecting is called when one or more DHCPOFFER packets have been
  * received and a configurable period of time has passed.
  */
 void state_selecting (cpp)
 	void *cpp;
+{
 	struct client_state *client = cpp;
 	struct client_lease *lp, *next, *picked;
 	ASSERT_STATE(state, S_SELECTING);
 	/*
 	 * Cancel state_selecting and send_discover timeouts, since either
 	 * one could have got us here.
 	 */
 	cancel_timeout (state_selecting, client);
 	cancel_timeout (send_discover, client);
 	/*
 	 * We have received one or more DHCPOFFER packets.   Currently,
 	 * the only criterion by which we judge leases is whether or
 	 * not we get a response when we arp for them.
 	 */
 	picked = NULL;
 	for (lp = client -> offered_leases; lp; lp = next) {
 		next = lp -> next;
 		/*
 		 * Check to see if we got an ARPREPLY for the address
 		 * in this particular lease.
 		 */
 		if (!picked) {
 			picked = lp;
 			picked -> next = NULL;
 		} else {
 			destroy_client_lease (lp);
+		}
+	}
 	client -> offered_leases = NULL;
 	/*
 	 * If we just tossed all the leases we were offered, go back
 	 * to square one.
 	 */
 	if (!picked) {
 		client -> state = S_INIT;
 		state_init (client);
 		return;
+	}
 	/* If it was a BOOTREPLY, we can just take the address right now. */
 	if (picked -> is_bootp) {
 		client -> new = picked;
 		/* Make up some lease expiry times
 		   XXX these should be configurable. */
 		client -> new -> expiry = cur_time + 12000;
 		client -> new -> renewal += cur_time + 8000;
 		client -> new -> rebind += cur_time + 10000;
 		client -> state = S_REQUESTING;
 		/* Bind to the address we received. */
 		bind_lease (client);
 		return;
+	}
 	/* Go to the REQUESTING state. */
 	client -> destination = iaddr_broadcast;
 	client -> state = S_REQUESTING;
 	client -> first_sending = cur_time;
 	client -> interval = client -> config -> initial_interval;
 	/* Make a DHCPREQUEST packet from the lease we picked. */
 	make_request (client, picked);
 	client -> xid = client -> packet.xid;
 	/* Toss the lease we picked - we'll get it back in a DHCPACK. */
 	destroy_client_lease (picked);
 	/* Add an immediate timeout to send the first DHCPREQUEST packet. */
 	send_request (client);
+}
 static isc_boolean_t
 compare_hw_address(const char *name, struct packet *packet) {
 	if (packet->interface->hw_address.hlen - 1 != packet->raw->hlen ||
 	    memcmp(&packet->interface->hw_address.hbuf[1],
 	    packet->raw->chaddr, packet->raw->hlen)) {
 		unsigned char *c  = packet->raw ->chaddr;
 		log_error ("%s raw = %d %.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
 		    name, packet->raw->hlen,
 		    c[0], c[1], c[2], c[3], c[4], c[5]);
 		c = &packet -> interface -> hw_address.hbuf [1];
 		log_error ("%s cooked = %d %.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
 		    name, packet->interface->hw_address.hlen - 1,
 		    c[0], c[1], c[2], c[3], c[4], c[5]);
 		log_error ("%s in wrong transaction (%s ignored).", name,
 		        hw_mismatch_drop ? "packet" : "error");
 		return hw_mismatch_drop;
+	}
 	return ISC_FALSE;
+}
 /* state_requesting is called when we receive a DHCPACK message after
    having sent out one or more DHCPREQUEST packets. */
 void dhcpack (packet)
 	struct packet *packet;
+{
 	struct interface_info *ip = packet -> interface;
 	struct client_state *client;
 	struct client_lease *lease;
 	struct option_cache *oc;
 	struct data_string ds;
 	/* If we're not receptive to an offer right now, or if the offer
 	   has an unrecognizable transaction id, then just drop it. */
 	for (client = ip -> client; client; client = client -> next) {
 		if (client -> xid == packet -> raw -> xid)
 			break;
+	}
 	if (!client || compare_hw_address("DHCPACK", packet) == ISC_TRUE)
 		return;
 	if (client -> state != S_REBOOTING &&
 	    client -> state != S_REQUESTING &&
 	    client -> state != S_RENEWING &&
 	    client -> state != S_REBINDING) {
 #if defined (DEBUG)
 		log_debug ("DHCPACK in wrong state.");
 #endif
 		return;
+	}
 	log_info ("DHCPACK of %s from %s",
 		  inet_ntoa(packet->raw->yiaddr),
 		  piaddr (packet->client_addr));
 	lease = packet_to_lease (packet, client);
 	if (!lease) {
 		log_info ("packet_to_lease failed.");
 		return;
+	}
 	client -> new = lease;
 	/* Stop resending DHCPREQUEST. */
 	cancel_timeout (send_request, client);
 	/* Figure out the lease time. */
 	oc = lookup_option (&dhcp_universe, client -> new -> options,
 			    DHO_DHCP_LEASE_TIME);
 	memset (&ds, 0, sizeof ds);
 	if (oc &&
 	    evaluate_option_cache (&ds, packet, (struct lease *)0, client,
 				   packet -> options, client -> new -> options,
 				   &global_scope, oc, MDL)) {
 		if (ds.len > 3)
 			client -> new -> expiry = getULong (ds.data);
 		else
 			client -> new -> expiry = 0;
 		data_string_forget (&ds, MDL);
 	} else
 			client -> new -> expiry = 0;
 	if (client->new->expiry == 0) {
 		struct timeval tv;
 		log_error ("no expiry time on offered lease.");
 		/* Quench this (broken) server.  Return to INIT to reselect. */
 		add_reject(packet);
 		/* 1/2 second delay to restart at INIT. */
 		tv.tv_sec = cur_tv.tv_sec;
 		tv.tv_usec = cur_tv.tv_usec + 500000;
 		if (tv.tv_usec >= 1000000) {
 			tv.tv_sec++;
 			tv.tv_usec -= 1000000;
+		}
 		add_timeout(&tv, state_init, client, 0, 0);
 		return;
+	}
 	/*
 	 * A number that looks negative here is really just very large,
 	 * because the lease expiry offset is unsigned.
 	 */
 	if (client->new->expiry < 0)
 		client->new->expiry = TIME_MAX;
 	/* Take the server-provided renewal time if there is one. */
 	oc = lookup_option (&dhcp_universe, client -> new -> options,
 			    DHO_DHCP_RENEWAL_TIME);
 	if (oc &&
 	    evaluate_option_cache (&ds, packet, (struct lease *)0, client,
 				   packet -> options, client -> new -> options,
 				   &global_scope, oc, MDL)) {
 		if (ds.len > 3)
 			client -> new -> renewal = getULong (ds.data);
 		else
 			client -> new -> renewal = 0;
 		data_string_forget (&ds, MDL);
 	} else
 			client -> new -> renewal = 0;
 	/* If it wasn't specified by the server, calculate it. */
 	if (!client -> new -> renewal)
 		client -> new -> renewal = client -> new -> expiry / 2 + 1;
 	if (client -> new -> renewal <= 0)
 		client -> new -> renewal = TIME_MAX;
 	/* Now introduce some randomness to the renewal time: */
 	if (client->new->renewal <= ((TIME_MAX / 3) - 3))
 		client->new->renewal = (((client->new->renewal * 3) + 3) / 4) +
 				(((random() % client->new->renewal) + 3) / 4);
 	/* Same deal with the rebind time. */
 	oc = lookup_option (&dhcp_universe, client -> new -> options,
 			    DHO_DHCP_REBINDING_TIME);
 	if (oc &&
 	    evaluate_option_cache (&ds, packet, (struct lease *)0, client,
 				   packet -> options, client -> new -> options,
 				   &global_scope, oc, MDL)) {
 		if (ds.len > 3)
 			client -> new -> rebind = getULong (ds.data);
 		else
 			client -> new -> rebind = 0;
 		data_string_forget (&ds, MDL);
 	} else
 			client -> new -> rebind = 0;
 	if (client -> new -> rebind <= 0) {
 		if (client -> new -> expiry <= TIME_MAX / 7)
 			client -> new -> rebind =
 					client -> new -> expiry * 7 / 8;
 		else
 			client -> new -> rebind =
 					client -> new -> expiry / 8 * 7;
+	}
 	/* Make sure our randomness didn't run the renewal time past the
 	   rebind time. */
 	if (client -> new -> renewal > client -> new -> rebind) {
 		if (client -> new -> rebind <= TIME_MAX / 3)
 			client -> new -> renewal =
 					client -> new -> rebind * 3 / 4;
 		else
 			client -> new -> renewal =
 					client -> new -> rebind / 4 * 3;
+	}
 	client -> new -> expiry += cur_time;
 	/* Lease lengths can never be negative. */
 	if (client -> new -> expiry < cur_time)
 		client -> new -> expiry = TIME_MAX;
 	client -> new -> renewal += cur_time;
 	if (client -> new -> renewal < cur_time)
 		client -> new -> renewal = TIME_MAX;
 	client -> new -> rebind += cur_time;
 	if (client -> new -> rebind < cur_time)
 		client -> new -> rebind = TIME_MAX;
 	bind_lease (client);
+}
 void bind_lease (client)
 	struct client_state *client;
+{
 	struct timeval tv;
 	/* Remember the medium. */
 	client->new->medium = client->medium;
 	/* Run the client script with the new parameters. */
 	script_init(client, (client->state == S_REQUESTING ? "BOUND" :
 			     (client->state == S_RENEWING ? "RENEW" :
 			      (client->state == S_REBOOTING ? "REBOOT" :
 			       "REBIND"))),
 		    client->new->medium);
 	if (client->active && client->state != S_REBOOTING)
 		script_write_params(client, "old_", client->active);
 	script_write_params(client, "new_", client->new);
 	script_write_requested(client);
 	if (client->alias)
 		script_write_params(client, "alias_", client->alias);
 	/* If the BOUND/RENEW code detects another machine using the
 	   offered address, it exits nonzero.  We need to send a
 	   DHCPDECLINE and toss the lease. */
 	if (script_go(client)) {
 		make_decline(client, client->new);
 		send_decline(client);
 		destroy_client_lease(client->new);
 		client->new = NULL;
 		if (onetry) {
 			if (!quiet) {
 				log_info("Unable to obtain a lease on first "
 					 "try (declined).  Exiting.");
+			}
 #if defined (CALL_SCRIPT_ON_ONETRY_FAIL)
 			/* Let's call a script and we're done */
 			script_init(client, "FAIL", (struct string_list *)0);
 			script_go(client);
 #endif
 			finish(2);
 		} else {
 			struct timeval tv;
 			tv.tv_sec = cur_tv.tv_sec + decline_wait_time;
 			tv.tv_usec = cur_tv.tv_usec;
 			add_timeout(&tv, state_init, client, 0, 0);
 			return;
+		}
+	}
 	/* Write out the new lease if it has been long enough. */
 	if (!client->last_write ||
 	    (cur_time - client->last_write) >= MIN_LEASE_WRITE)
 		write_client_lease(client, client->new, 0, 1);
 	/* Replace the old active lease with the new one. */
 	if (client->active) {
 		if (client->active->is_static) {
 			// We need to preserve the fallback lease in case
 			// we lose DHCP service again.
 			add_to_tail(&client->leases, client->active);
 		} else {
 			destroy_client_lease(client->active);
+		}
+	}
 	client->active = client->new;
 	client->new = NULL;
 	/* Set up a timeout to start the renewal process. */
 	tv.tv_sec = client->active->renewal;
 	tv.tv_usec = ((client->active->renewal - cur_tv.tv_sec) > 1) ?
 			random() % 1000000 : cur_tv.tv_usec;
 	add_timeout(&tv, state_bound, client, 0, 0);
 	log_info("bound to %s -- renewal in %ld seconds.",
 	      piaddr(client->active->address),
 	      (long)(client->active->renewal - cur_time));
 	client->state = S_BOUND;
 	reinitialize_interfaces();
 	detach();
 #if defined (NSUPDATE)
 	if (client->config->do_forward_update)
 		dhclient_schedule_updates(client, &client->active->address, 1);
 #endif /* defined NSUPDATE */
+}
 /* state_bound is called when we've successfully bound to a particular
    lease, but the renewal time on that lease has expired.   We are
    expected to unicast a DHCPREQUEST to the server that gave us our
    original lease. */
 void state_bound (cpp)
 	void *cpp;
+{
 	struct client_state *client = cpp;
 	struct option_cache *oc;
 	struct data_string ds;
 	ASSERT_STATE(state, S_BOUND);
 	/* T1 has expired. */
 	make_request (client, client -> active);
 	client -> xid = client -> packet.xid;
 	memset (&ds, 0, sizeof ds);
 	oc = lookup_option (&dhcp_universe, client -> active -> options,
 			    DHO_DHCP_SERVER_IDENTIFIER);
 	if (oc &&
 	    evaluate_option_cache (&ds, (struct packet *)0, (struct lease *)0,
 				   client, (struct option_state *)0,
 				   client -> active -> options,
 				   &global_scope, oc, MDL)) {
 		if (ds.len > 3) {
 			memcpy (client -> destination.iabuf, ds.data, 4);
 			client -> destination.len = 4;
 		} else
 			client -> destination = iaddr_broadcast;
 		data_string_forget (&ds, MDL);
 	} else
 		client -> destination = iaddr_broadcast;
 	client -> first_sending = cur_time;
 	client -> interval = client -> config -> initial_interval;
 	client -> state = S_RENEWING;
 	/* Send the first packet immediately. */
 	send_request (client);
+}
 /* state_stop is called when we've been told to shut down.   We unconfigure
    the interfaces, and then stop operating until told otherwise. */
 void state_stop (cpp)
 	void *cpp;
+{
 	struct client_state *client = cpp;
 	client->pending = P_NONE;
 	/* Cancel all timeouts. */
 	cancel_timeout(state_selecting, client);
 	cancel_timeout(send_discover, client);
 	cancel_timeout(send_request, client);
 	cancel_timeout(state_bound, client);
 	/* If we have an address, unconfigure it. */
 	if (client->active) {
 		script_init(client, "STOP", client->active->medium);
 		script_write_params(client, "old_", client->active);
 		script_write_requested(client);
 		if (client->alias)
 			script_write_params(client, "alias_", client->alias);
 		script_go(client);
+	}
+}
 int commit_leases ()
+{
 	return 0;
+}
 int write_lease (lease)
 	struct lease *lease;
+{
 	return 0;
+}
 int write_host (host)
 	struct host_decl *host;
+{
 	return 0;
+}
 void db_startup (testp)
 	int testp;
+{
+}
 void bootp (packet)
 	struct packet *packet;
+{
 	struct iaddrmatchlist *ap;
 	char addrbuf[4*16];
 	char maskbuf[4*16];
 	if (packet -> raw -> op != BOOTREPLY)
 		return;
 	/* If there's a reject list, make sure this packet's sender isn't
 	   on it. */
 	for (ap = packet -> interface -> client -> config -> reject_list;
 	     ap; ap = ap -> next) {
 		if (addr_match(&packet->client_addr, &ap->match)) {
 		        /* piaddr() returns its result in a static
 			   buffer sized 4*16 (see common/inet.c). */
 		        strcpy(addrbuf, piaddr(ap->match.addr));
 		        strcpy(maskbuf, piaddr(ap->match.mask));
 			log_info("BOOTREPLY from %s rejected by rule %s "
 				 "mask %s.", piaddr(packet->client_addr),
 				 addrbuf, maskbuf);
 			return;
+		}
+	}
 	dhcpoffer (packet);
+}
 void dhcp (packet)
 	struct packet *packet;
+{
 	struct iaddrmatchlist *ap;
 	void (*handler) (struct packet *);
 	const char *type;
 	char addrbuf[4*16];
 	char maskbuf[4*16];
 	switch (packet -> packet_type) {
 	      case DHCPOFFER:
 		handler = dhcpoffer;
 		type = "DHCPOFFER";
 		break;
 	      case DHCPNAK:
 		handler = dhcpnak;
 		type = "DHCPNACK";
 		break;
 	      case DHCPACK:
 		handler = dhcpack;
 		type = "DHCPACK";
 		break;
 	      default:
 		return;
+	}
 	/* If there's a reject list, make sure this packet's sender isn't
 	   on it. */
 	for (ap = packet -> interface -> client -> config -> reject_list;
 	     ap; ap = ap -> next) {
 		if (addr_match(&packet->client_addr, &ap->match)) {
 		        /* piaddr() returns its result in a static
 			   buffer sized 4*16 (see common/inet.c). */
 		        strcpy(addrbuf, piaddr(ap->match.addr));
 		        strcpy(maskbuf, piaddr(ap->match.mask));
 			log_info("%s from %s rejected by rule %s mask %s.",
 				 type, piaddr(packet->client_addr),
 				 addrbuf, maskbuf);
 			return;
+		}
+	}
 	(*handler) (packet);
+}
 #ifdef DHCPv6
 void
 dhcpv6(struct packet *packet) {
 	struct iaddrmatchlist *ap;
 	struct client_state *client;
 	char addrbuf[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")];
 	/* Silently drop bogus messages. */
 	if (packet->dhcpv6_msg_type >= dhcpv6_type_name_max)
 		return;
 	/* Discard, with log, packets from quenched sources. */
 	for (ap = packet->interface->client->config->reject_list ;
 	     ap ; ap = ap->next) {
 		if (addr_match(&packet->client_addr, &ap->match)) {
 			strcpy(addrbuf, piaddr(packet->client_addr));
 			log_info("%s from %s rejected by rule %s",
 				 dhcpv6_type_names[packet->dhcpv6_msg_type],
 				 addrbuf,
 				 piaddrmask(&ap->match.addr, &ap->match.mask));
 			return;
+		}
+	}
 	/* Screen out nonsensical messages. */
 	switch(packet->dhcpv6_msg_type) {
 #ifdef DHCP4o6
 	      case DHCPV6_DHCPV4_RESPONSE:
 		if (dhcpv4_over_dhcpv6) {
 		  log_info("RCV: %s message on %s from %s.",
 			   dhcpv6_type_names[packet->dhcpv6_msg_type],
 			   packet->interface->name,
 			   piaddr(packet->client_addr));
 		  forw_dhcpv4_response(packet);
+		}
 		return;
 #endif
 	      case DHCPV6_ADVERTISE:
 	      case DHCPV6_RECONFIGURE:
 		if (stateless)
 		  return;
 	      /* Falls through */
 	      case DHCPV6_REPLY:
 		log_info("RCV: %s message on %s from %s.",
 			 dhcpv6_type_names[packet->dhcpv6_msg_type],
 			 packet->interface->name, piaddr(packet->client_addr));
 		break;
 	      default:
 		return;
+	}
 	/* Find a client state that matches the incoming XID. */
 	for (client = packet->interface->client ; client ;
 	     client = client->next) {
 		if (memcmp(&client->dhcpv6_transaction_id,
 			   packet->dhcpv6_transaction_id, 3) == 0) {
 			client->v6_handler(packet, client);
 			return;
+		}
+	}
 	/* XXX: temporary log for debugging */
 	log_info("Packet received, but nothing done with it.");
+}
 #ifdef DHCP4o6
 /*
  * \brief Forward a DHCPv4-response to the DHCPv4 client.
  *  (DHCPv6 client function)
+ *
  * The DHCPv6 client receives a DHCPv4-response which is forwarded
  * to the DHCPv4 client.
  * Format: address:16 + DHCPv4 message content
  * (we have no state to keep the address so it is transported in
  *  DHCPv6 <-> DHCPv6 inter-process messages)
+ *
  * \param packet the DHCPv4-response packet
  */
 static void forw_dhcpv4_response(struct packet *packet)
+{
 	struct option_cache *oc;
 	struct data_string enc_opt_data;
 	struct data_string ds;
 	int cc;
 	/*
 	 * Discard if relay is not ready.
 	 */
 	if (dhcp4o6_state == -1) {
 		log_info("forw_dhcpv4_response: not ready.");
 		return;
+	}
 	if (packet->client_addr.len != 16) {
 		log_error("forw_dhcpv4_response: bad address");
 		return;
+	}
 	/*
 	 * Get our encapsulated DHCPv4 message.
 	 */
 	oc = lookup_option(&dhcpv6_universe, packet->options, D6O_DHCPV4_MSG);
 	if (oc == NULL) {
 		log_info("DHCPv4-response from %s missing "
 			 "DHCPv4 Message option.",
 			 piaddr(packet->client_addr));
 		return;
+	}
 	memset(&enc_opt_data, 0, sizeof(enc_opt_data));
 	if (!evaluate_option_cache(&enc_opt_data, NULL, NULL, NULL,
 				   NULL, NULL, &global_scope, oc, MDL)) {
 		log_error("forw_dhcpv4_response: error evaluating "
 			  "DHCPv4 message.");
 		data_string_forget(&enc_opt_data, MDL);
 		return;
+	}
 	if (enc_opt_data.len < DHCP_FIXED_NON_UDP) {
 		log_error("forw_dhcpv4_response: "
 			  "no memory for encapsulated packet.");
 		data_string_forget(&enc_opt_data, MDL);
 		return;
+	}
 	/*
 	 * Append address.
 	 */
 	memset(&ds, 0, sizeof(ds));
 	if (!buffer_allocate(&ds.buffer, enc_opt_data.len + 16, MDL)) {
 		log_error("forw_dhcpv4_response: no memory buffer.");
 		data_string_forget(&enc_opt_data, MDL);
 		return;
+	}
 	ds.data = ds.buffer->data;
 	ds.len = enc_opt_data.len + 16;
 	memcpy(ds.buffer->data, enc_opt_data.data, enc_opt_data.len);
 	memcpy(ds.buffer->data + enc_opt_data.len,
 	       packet->client_addr.iabuf, 16);
 	data_string_forget(&enc_opt_data, MDL);
 	/*
 	 * Forward them.
 	 */
 	cc = send(dhcp4o6_fd, ds.data, ds.len, 0);
 	if (cc < 0)
 		log_error("forw_dhcpv4_response: send(): %m");
 	data_string_forget(&ds, MDL);
+}
 /*
  * \brief Receive a DHCPv4-response from the DHCPv6 client.
  *  (DHCPv4 client function)
+ *
  * The DHCPv4 client receives a DHCPv4-response forwarded
  * by the DHCPv6 client (using \ref forw_dhcpv4_response())
+ *
  * \param raw the DHCPv4-response raw packet
  */
 static void recv_dhcpv4_response(struct data_string *raw)
+{
 	struct packet *packet;
 	struct iaddr from;
 	if (interfaces == NULL) {
 		log_error("recv_dhcpv4_response: no interfaces.");
 		return;
+	}
 	from.len = 16;
 	memcpy(from.iabuf, raw->data + (raw->len - 16), 16);
 	/*
 	 * Build a packet structure.
 	 */
 	packet = NULL;
 	if (!packet_allocate(&packet, MDL)) {
 		log_error("recv_dhcpv4_response: no memory for packet.");
 		return;
+	}
 	packet->raw = (struct dhcp_packet *) raw->data;
 	packet->packet_length = raw->len - 16;
 	packet->client_port = remote_port;
 	packet->client_addr = from;
 	interface_reference(&packet->interface, interfaces, MDL);
 	/* Allocate packet->options now so it is non-null for all packets */
 	if (!option_state_allocate (&packet->options, MDL)) {
 		log_error("recv_dhcpv4_response: no memory for options.");
 		packet_dereference (&packet, MDL);
 		return;
+	}
 	/* If there's an option buffer, try to parse it. */
 	if (packet->packet_length >= DHCP_FIXED_NON_UDP + 4) {
 		struct option_cache *op;
 		if (!parse_options(packet)) {
 			if (packet->options)
 				option_state_dereference
 					(&packet->options, MDL);
 			packet_dereference (&packet, MDL);
 			return;
+		}
 		if (packet->options_valid &&
 		    (op = lookup_option(&dhcp_universe,
 					packet->options,
 					DHO_DHCP_MESSAGE_TYPE))) {
 			struct data_string dp;
 			memset(&dp, 0, sizeof dp);
 			evaluate_option_cache(&dp, packet, NULL, NULL,
 					      packet->options, NULL,
 					      NULL, op, MDL);
 			if (dp.len > 0)
 				packet->packet_type = dp.data[0];
 			else
 				packet->packet_type = 0;
 			data_string_forget(&dp, MDL);
+		}
+	}
 	if (validate_packet(packet) != 0) {
 		if (packet->packet_type)
 			dhcp(packet);
 		else
 			bootp(packet);
+	}
 	/* If the caller kept the packet, they'll have upped the refcnt. */
 	packet_dereference(&packet, MDL);
+}
 #endif /* DHCP4o6 */
 #endif /* DHCPv6 */
 void dhcpoffer (packet)
 	struct packet *packet;
+{
 	struct interface_info *ip = packet -> interface;
 	struct client_state *client;
 	struct client_lease *lease, *lp;
 	struct option **req;
 	int i;
 	int stop_selecting;
 	const char *name = packet -> packet_type ? "DHCPOFFER" : "BOOTREPLY";
 	char obuf [1024];
 	struct timeval tv;
 #ifdef DEBUG_PACKET
 	dump_packet (packet);
 #endif
 	/* Find a client state that matches the xid... */
 	for (client = ip -> client; client; client = client -> next)
 		if (client -> xid == packet -> raw -> xid)
 			break;
 	/* If we're not receptive to an offer right now, or if the offer
 	   has an unrecognizable transaction id, then just drop it. */
 	if (!client || client -> state != S_SELECTING ||
 	    compare_hw_address(name, packet) == ISC_TRUE)
 		return;
 	sprintf (obuf, "%s of %s from %s", name,
 		 inet_ntoa(packet->raw->yiaddr),
 		 piaddr(packet->client_addr));
 	/* If this lease doesn't supply the minimum required DHCPv4 parameters,
 	 * ignore it.
 	 */
 	req = client->config->required_options;
 	if (req != NULL) {
 		for (i = 0 ; req[i] != NULL ; i++) {
 			if ((req[i]->universe == &dhcp_universe) &&
 			    !lookup_option(&dhcp_universe, packet->options,
 					   req[i]->code)) {
 				struct option *option = NULL;
 				unsigned code = req[i]->code;
 				option_code_hash_lookup(&option,
 							dhcp_universe.code_hash,
 							&code, 0, MDL);
 				if (option)
 					log_info("%s: no %s option.", obuf,
 						 option->name);
 				else
 					log_info("%s: no unknown-%u option.",
 						 obuf, code);
 				option_dereference(&option, MDL);
 				return;
+			}
+		}
+	}
 	/* If we've already seen this lease, don't record it again. */
 	for (lease = client -> offered_leases; lease; lease = lease -> next) {
 		if (lease -> address.len == sizeof packet -> raw -> yiaddr &&
 		    !memcmp (lease -> address.iabuf,
 			     &packet -> raw -> yiaddr, lease -> address.len)) {
 			log_debug ("%s: already seen.", obuf);
 			return;
+		}
+	}
 	lease = packet_to_lease (packet, client);
 	if (!lease) {
 		log_info ("%s: packet_to_lease failed.", obuf);
 		return;
+	}
 	/* log it now, so it emits before the request goes out */
 	log_info("%s", obuf);
 	/* If this lease was acquired through a BOOTREPLY, record that
 	   fact. */
 	if (!packet -> options_valid || !packet -> packet_type)
 		lease -> is_bootp = 1;
 	/* Record the medium under which this lease was offered. */
 	lease -> medium = client -> medium;
 	/* Figure out when we're supposed to stop selecting. */
 	stop_selecting = (client -> first_sending +
 			  client -> config -> select_interval);
 	/* If this is the lease we asked for, put it at the head of the
 	   list, and don't mess with the arp request timeout. */
 	if (lease -> address.len == client -> requested_address.len &&
 	    !memcmp (lease -> address.iabuf,
 		     client -> requested_address.iabuf,
 		     client -> requested_address.len)) {
 		lease -> next = client -> offered_leases;
 		client -> offered_leases = lease;
 	} else {
 		/* Put the lease at the end of the list. */
 		lease -> next = (struct client_lease *)0;
 		if (!client -> offered_leases)
 			client -> offered_leases = lease;
 		else {
 			for (lp = client -> offered_leases; lp -> next;
 			     lp = lp -> next)
+				;
 			lp -> next = lease;
+		}
+	}
 	/* If the selecting interval has expired, go immediately to
 	   state_selecting().  Otherwise, time out into
 	   state_selecting at the select interval. */
 	if (stop_selecting <= cur_tv.tv_sec)
 		state_selecting (client);
 	else {
 		tv.tv_sec = stop_selecting;
 		tv.tv_usec = cur_tv.tv_usec;
 		add_timeout(&tv, state_selecting, client, 0, 0);
 		cancel_timeout(send_discover, client);
+	}
+}
 /* Allocate a client_lease structure and initialize it from the parameters
    in the specified packet. */
 struct client_lease *packet_to_lease (packet, client)
 	struct packet *packet;
 	struct client_state *client;
+{
 	struct client_lease *lease;
 	unsigned i;
 	struct option_cache *oc;
 	struct option *option = NULL;
 	struct data_string data;
 	lease = (struct client_lease *)new_client_lease (MDL);
 	if (!lease) {
 		log_error("packet_to_lease: no memory to record lease.\n");
 		return NULL;
+	}
 	memset(lease, 0, sizeof(*lease));
 	/* Copy the lease options. */

 @@ -1,1031 +1,1031 @@
-/*	$NetBSD: parse.c,v 1.3 2020/08/03 21:10:56 christos Exp $	*/
+/*	$NetBSD: parse.c,v 1.4 2021/05/26 22:52:31 christos Exp $	*/
 /* parse.c
    Common parser code for dhcpd and dhclient. */
 /*
- * Copyright (c) 2004-2019 by Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (c) 2004-2021 by Internet Systems Consortium, Inc. ("ISC")
  * Copyright (c) 1995-2003 by Internet Software Consortium
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
  *   Internet Systems Consortium, Inc.
  *   950 Charter Street
  *   Redwood City, CA 94063
  *   <info@isc.org>
  *   https://www.isc.org/
+ *
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: parse.c,v 1.3 2020/08/03 21:10:56 christos Exp $");
+__RCSID("$NetBSD: parse.c,v 1.4 2021/05/26 22:52:31 christos Exp $");
 #include "dhcpd.h"
 #include <isc/util.h>
 #include <syslog.h>
 struct collection default_collection = { NULL, "default", NULL };
 struct collection *collections = &default_collection;
 /* Enumerations can be specified in option formats, and are used for
    parsing, so we define the routines that manage them here. */
 struct enumeration *enumerations;
 void add_enumeration (struct enumeration *enumeration)
+{
 	enumeration -> next = enumerations;
 	enumerations = enumeration;
+}
 struct enumeration *find_enumeration (const char *name, int length)
+{
 	struct enumeration *e;
 	for (e = enumerations; e; e = e -> next)
 		if (strlen (e -> name) == length &&
 		    !memcmp (e -> name, name, (unsigned)length))
 			return e;
 	return (struct enumeration *)0;
+}
 struct enumeration_value *find_enumeration_value (const char *name,
 						  int length,
 						  unsigned *widthp,
 						  const char *value)
+{
 	struct enumeration *e;
 	int i;
 	e = find_enumeration (name, length);
 	if (e) {
 		if (widthp != NULL)
 			*widthp = e->width;
 		for (i = 0; e -> values [i].name; i++) {
 			if (!strcmp (value, e -> values [i].name))
 				return &e -> values [i];
+		}
+	}
 	return (struct enumeration_value *)0;
+}
 /* Skip to the semicolon ending the current statement.   If we encounter
    braces, the matching closing brace terminates the statement.
 */
 void skip_to_semi (cfile)
 	struct parse *cfile;
+{
 	skip_to_rbrace(cfile, 0);
+}
 /* Skips everything from the current point upto (and including) the given
  number of right braces.  If we encounter a semicolon but haven't seen a
  left brace, consume it and return.
  This lets us skip over:
    	statement;
 	statement foo bar { }
 	statement foo bar { statement { } }
 	statement}
 	...et cetera. */
 void skip_to_rbrace (cfile, brace_count)
 	struct parse *cfile;
 	int brace_count;
+{
 	enum dhcp_token token;
 	const char *val;
 #if defined (DEBUG_TOKENS)
 	log_error("skip_to_rbrace: %d\n", brace_count);
 #endif
 	do {
 		token = peek_token(&val, NULL, cfile);
 		if (token == RBRACE) {
 			if (brace_count > 0) {
 				--brace_count;
+			}
 			if (brace_count == 0) {
 				/* Eat the brace and return. */
 				skip_token(&val, NULL, cfile);
 				return;
+			}
 		} else if (token == LBRACE) {
 			brace_count++;
 		} else if (token == SEMI && (brace_count == 0)) {
 			/* Eat the semicolon and return. */
 			skip_token(&val, NULL, cfile);
 			return;
 		} else if (token == EOL) {
 			/* EOL only happens when parsing /etc/resolv.conf,
 			   and we treat it like a semicolon because the
 			   resolv.conf file is line-oriented. */
 			skip_token(&val, NULL, cfile);
 			return;
+		}
 		/* Eat the current token */
 		token = next_token(&val, NULL, cfile);
 	} while (token != END_OF_FILE);
+}
 int parse_semi (cfile)
 	struct parse *cfile;
+{
 	enum dhcp_token token;
 	const char *val;
 	token = next_token (&val, (unsigned *)0, cfile);
 	if (token != SEMI) {
 		parse_warn (cfile, "semicolon expected.");
 		skip_to_semi (cfile);
 		return 0;
+	}
 	return 1;
+}
 /* string-parameter :== STRING SEMI */
 int parse_string (cfile, sptr, lptr)
 	struct parse *cfile;
 	char **sptr;
 	unsigned *lptr;
+{
 	const char *val;
 	enum dhcp_token token;
 	char *s;
 	unsigned len;
 	token = next_token (&val, &len, cfile);
 	if (token != STRING) {
 		parse_warn (cfile, "expecting a string");
 		skip_to_semi (cfile);
 		return 0;
+	}
 	s = (char *)dmalloc (len + 1, MDL);
 	if (!s)
 		log_fatal ("no memory for string %s.", val);
 	memcpy (s, val, len + 1);
 	if (!parse_semi (cfile)) {
 		dfree (s, MDL);
 		return 0;
+	}
 	if (sptr)
 		*sptr = s;
 	else
 		dfree (s, MDL);
 	if (lptr)
 		*lptr = len;
 	return 1;
+}
 /*
  * hostname :== IDENTIFIER
  *		| IDENTIFIER DOT
  *		| hostname DOT IDENTIFIER
  */
 char *parse_host_name (cfile)
 	struct parse *cfile;
+{
 	const char *val;
 	enum dhcp_token token;
 	unsigned len = 0;
 	char *s;
 	char *t;
 	pair c = (pair)0;
 	int ltid = 0;
 	/* Read a dotted hostname... */
 	do {
 		/* Read a token, which should be an identifier. */
 		token = peek_token (&val, (unsigned *)0, cfile);
 		if (!is_identifier (token) && token != NUMBER)
 			break;
 		skip_token(&val, (unsigned *)0, cfile);
 		/* Store this identifier... */
 		if (!(s = (char *)dmalloc (strlen (val) + 1, MDL)))
 			log_fatal ("can't allocate temp space for hostname.");
 		strcpy (s, val);
 		c = cons ((caddr_t)s, c);
 		len += strlen (s) + 1;
 		/* Look for a dot; if it's there, keep going, otherwise
 		   we're done. */
 		token = peek_token (&val, (unsigned *)0, cfile);
 		if (token == DOT) {
 			token = next_token (&val, (unsigned *)0, cfile);
 			ltid = 1;
 		} else
 			ltid = 0;
 	} while (token == DOT);
 	/* Should be at least one token. */
 	if (!len)
 		return (char *)0;
 	/* Assemble the hostname together into a string. */
 	if (!(s = (char *)dmalloc (len + ltid, MDL)))
 		log_fatal ("can't allocate space for hostname.");
 	t = s + len + ltid;
 	*--t = 0;
 	if (ltid)
 		*--t = '.';
 	while (c) {
 		pair cdr = c -> cdr;
 		unsigned l = strlen ((char *)(c -> car));
 		t -= l;
 		memcpy (t, (char *)(c -> car), l);
 		/* Free up temp space. */
 		dfree (c -> car, MDL);
 		dfree (c, MDL);
 		c = cdr;
 		if (t != s)
 			*--t = '.';
+	}
 	return s;
+}
 /* ip-addr-or-hostname :== ip-address | hostname
    ip-address :== NUMBER DOT NUMBER DOT NUMBER DOT NUMBER
    Parse an ip address or a hostname.   If uniform is zero, put in
    an expr_substring node to limit hostnames that evaluate to more
    than one IP address.
    Note that RFC1123 permits hostnames to consist of all digits,
    making it difficult to quickly disambiguate them from ip addresses.
 */
 int parse_ip_addr_or_hostname (expr, cfile, uniform)
 	struct expression **expr;
 	struct parse *cfile;
 	int uniform;
+{
 	const char *val;
 	enum dhcp_token token;
 	unsigned char addr [4];
 	unsigned len = sizeof addr;
 	char *name;
 	struct expression *x = (struct expression *)0;
 	int ipaddr = 0;
 	token = peek_token (&val, (unsigned *)0, cfile);
 	if (token == NUMBER) {
 		/*
 		 * a hostname may be numeric, but domain names must
 		 * start with a letter, so we can disambiguate by
 		 * looking ahead a few tokens.  we save the parse
 		 * context first, and restore it after we know what
 		 * we're dealing with.
 		 */
 		save_parse_state(cfile);
 		skip_token(NULL, NULL, cfile);
 		if (next_token(NULL, NULL, cfile) == DOT &&
 		    next_token(NULL, NULL, cfile) == NUMBER)
 			ipaddr = 1;
 		restore_parse_state(cfile);
 		if (ipaddr &&
 		    parse_numeric_aggregate (cfile, addr, &len, DOT, 10, 8))
 			return make_const_data (expr, addr, len, 0, 1, MDL);
+	}
 	if (is_identifier (token) || token == NUMBER) {
 		name = parse_host_name (cfile);
 		if (!name)
 			return 0;
 		if (!make_host_lookup (expr, name)) {
 			dfree(name, MDL);
 			return 0;
+		}
 		dfree(name, MDL);
 		if (!uniform) {
 			if (!make_limit (&x, *expr, 4))
 				return 0;
 			expression_dereference (expr, MDL);
 			*expr = x;
+		}
 	} else {
 		if (token != RBRACE && token != LBRACE)
 			token = next_token (&val, (unsigned *)0, cfile);
 		parse_warn (cfile, "%s (%d): expecting IP address or hostname",
 			    val, token);
 		if (token != SEMI)
 			skip_to_semi (cfile);
 		return 0;
+	}
 	return 1;
+}
 /*
  * ip-address :== NUMBER DOT NUMBER DOT NUMBER DOT NUMBER
  */
 int parse_ip_addr (cfile, addr)
 	struct parse *cfile;
 	struct iaddr *addr;
+{
 	addr -> len = 4;
 	if (parse_numeric_aggregate (cfile, addr -> iabuf,
 				     &addr -> len, DOT, 10, 8))
 		return 1;
 	return 0;
+}
 /*
  * Return true if every character in the string is hexadecimal.
  */
 static int
 is_hex_string(const char *s) {
 	while (*s != '\0') {
 		if (!isxdigit((int)*s)) {
 			return 0;
+		}
 		s++;
+	}
 	return 1;
+}
 /*
  * ip-address6 :== (complicated set of rules)
+ *
  * See section 2.2 of RFC 1884 for details.
+ *
  * We are lazy for this. We pull numbers, names, colons, and dots
  * together and then throw the resulting string at the inet_pton()
  * function.
  */
 int
 parse_ip6_addr(struct parse *cfile, struct iaddr *addr) {
 	enum dhcp_token token;
 	const char *val;
 	int val_len;
 	char v6[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
 	int v6_len;
 	/*
 	 * First token is non-raw. This way we eat any whitespace before
 	 * our IPv6 address begins, like one would expect.
 	 */
 	token = peek_token(&val, NULL, cfile);
 	/*
 	 * Gather symbols.
 	 */
 	v6_len = 0;
 	for (;;) {
 		if ((((token == NAME) || (token == NUMBER_OR_NAME)) &&
 		     is_hex_string(val)) ||
 		    (token == NUMBER) ||
 		    (token == TOKEN_ADD) ||
 		    (token == DOT) ||
 		    (token == COLON)) {
 			next_raw_token(&val, NULL, cfile);
 			val_len = strlen(val);
 			if ((v6_len + val_len) >= sizeof(v6)) {
 				parse_warn(cfile, "Invalid IPv6 address.");
 				skip_to_semi(cfile);
 				return 0;
+			}
 			memcpy(v6+v6_len, val, val_len);
 			v6_len += val_len;
 		} else {
 			break;
+		}
 		token = peek_raw_token(&val, NULL, cfile);
+	}
 	v6[v6_len] = '\0';
 	/*
 	 * Use inet_pton() for actual work.
 	 */
 	if (inet_pton(AF_INET6, v6, addr->iabuf) <= 0) {
 		parse_warn(cfile, "Invalid IPv6 address.");
 		skip_to_semi(cfile);
 		return 0;
+	}
 	addr->len = 16;
 	return 1;
+}
 /*
  * Same as parse_ip6_addr() above, but returns the value in the
  * expression rather than in an address structure.
  */
 int
 parse_ip6_addr_expr(struct expression **expr,
 		    struct parse *cfile) {
 	struct iaddr addr;
 	if (!parse_ip6_addr(cfile, &addr)) {
 		return 0;
+	}
 	return make_const_data(expr, addr.iabuf, addr.len, 0, 1, MDL);
+}
 /*
  * ip6-prefix :== ip6-address "/" NUMBER
  */
 int
 parse_ip6_prefix(struct parse *cfile, struct iaddr *addr, u_int8_t *plen) {
 	enum dhcp_token token;
 	const char *val;
 	int n;
 	if (!parse_ip6_addr(cfile, addr)) {
 		return 0;
+	}
 	token = next_token(&val, NULL, cfile);
 	if (token != SLASH) {
 		parse_warn(cfile, "Slash expected.");
 		if (token != SEMI)
 			skip_to_semi(cfile);
 		return 0;
+	}
 	token = next_token(&val, NULL, cfile);
 	if (token != NUMBER) {
 		parse_warn(cfile, "Number expected.");
 		if (token != SEMI)
 			skip_to_semi(cfile);
 		return 0;
+	}
 	n = atoi(val);
 	if ((n < 0) || (n > 128)) {
 		parse_warn(cfile, "Invalid IPv6 prefix length.");
 		skip_to_semi(cfile);
 		return 0;
+	}
 	if (!is_cidr_mask_valid(addr, n)) {
 		parse_warn(cfile, "network mask too short.");
 		skip_to_semi(cfile);
 		return 0;
+	}
 	*plen = n;
 	return 1;
+}
 /*
  * ip-address-with-subnet :== ip-address |
  *                          ip-address "/" NUMBER
  */
 int
 parse_ip_addr_with_subnet(cfile, match)
 	struct parse *cfile;
 	struct iaddrmatch *match;
+{
 	const char *val, *orig;
 	enum dhcp_token token;
 	int prefixlen;
 	int fflen;
 	unsigned char newval, warnmask=0;
 	if (parse_ip_addr(cfile, &match->addr)) {
 		/* default to host mask */
 		prefixlen = match->addr.len * 8;
 		token = peek_token(&val, NULL, cfile);
 		if (token == SLASH) {
 			skip_token(&val, NULL, cfile);
 			token = next_token(&val, NULL, cfile);
 			if (token != NUMBER) {
 				parse_warn(cfile, "Invalid CIDR prefix length:"
 						  " expecting a number.");
 				return 0;
+			}
 			prefixlen = atoi(val);
 			if (prefixlen < 0 ||
 			    prefixlen > (match->addr.len * 8)) {
 				parse_warn(cfile, "subnet prefix is out of "
 						  "range [0..%d].",
 						  match->addr.len * 8);
 				return 0;
+			}
+		}
 		/* construct a suitable mask field */
 		/* copy length */
 		match->mask.len = match->addr.len;
 		/* count of 0xff bytes in mask */
 		fflen = prefixlen / 8;
 		/* set leading mask */
 		memset(match->mask.iabuf, 0xff, fflen);
 		/* set zeroes */
 		if (fflen < match->mask.len) {
 			match->mask.iabuf[fflen] =
 			    "\x00\x80\xc0\xe0\xf0\xf8\xfc\xfe"[prefixlen % 8];
 			memset(match->mask.iabuf+fflen+1, 0x00,
 			       match->mask.len - fflen - 1);
 			/* AND-out insignificant bits from supplied netmask. */
 			orig = piaddr(match->addr);
 			do {
 				newval = match->addr.iabuf[fflen] &
 					 match->mask.iabuf[fflen];
 				if (newval != match->addr.iabuf[fflen]) {
 					warnmask = 1;
 					match->addr.iabuf[fflen] = newval;
+				}
 			} while (++fflen < match->mask.len);
 			if (warnmask) {
 				log_error("Warning: Extraneous bits removed "
 					  "in address component of %s/%d.",
 					  orig, prefixlen);
 				log_error("New value: %s/%d.",
 					  piaddr(match->addr), prefixlen);
+			}
+		}
 		return 1;
+	}
 	parse_warn(cfile,
 		   "expecting ip-address or ip-address/prefixlen");
 	return 0;  /* let caller pick up pieces */
+}
 /*
  * hardware-parameter :== HARDWARE hardware-type colon-separated-hex-list SEMI
  * hardware-type :== ETHERNET | TOKEN_RING | TOKEN_FDDI | INFINIBAND
  * Note that INFINIBAND may not be useful for some items, such as classification
  * as the hardware address won't always be available.
  */
 void parse_hardware_param (cfile, hardware)
 	struct parse *cfile;
 	struct hardware *hardware;
+{
 	const char *val;
 	enum dhcp_token token;
 	unsigned hlen;
 	unsigned char *t;
 	token = next_token(&val, NULL, cfile);
 	switch (token) {
 	      case ETHERNET:
 		hardware->hbuf[0] = HTYPE_ETHER;
 		break;
 	      case TOKEN_RING:
 		hardware->hbuf[0] = HTYPE_IEEE802;
 		break;
 	      case TOKEN_FDDI:
 		hardware->hbuf[0] = HTYPE_FDDI;
 		break;
 	      case TOKEN_INFINIBAND:
 		hardware->hbuf[0] = HTYPE_INFINIBAND;
 		break;
 	      default:
 		if (!strncmp(val, "unknown-", 8)) {
 			hardware->hbuf[0] = atoi(&val[8]);
 		} else {
 			parse_warn(cfile,
 				   "expecting a network hardware type");
 			skip_to_semi(cfile);
 			return;
+		}
+	}
 	/* Parse the hardware address information.   Technically,
 	   it would make a lot of sense to restrict the length of the
 	   data we'll accept here to the length of a particular hardware
 	   address type.   Unfortunately, there are some broken clients
 	   out there that put bogus data in the chaddr buffer, and we accept
 	   that data in the lease file rather than simply failing on such
 	   clients.   Yuck. */
 	hlen = 0;
 	token = peek_token(&val, NULL, cfile);
 	if (token == SEMI) {
 		hardware->hlen = 1;
 		goto out;
+	}
 	t = parse_numeric_aggregate(cfile, NULL, &hlen, COLON, 16, 8);
 	if (t == NULL) {
 		hardware->hlen = 1;
 		return;
+	}
 	if (hlen + 1 > sizeof(hardware->hbuf)) {
 		dfree(t, MDL);
 		parse_warn(cfile, "hardware address too long");
 	} else {
 		hardware->hlen = hlen + 1;
 		memcpy((unsigned char *)&hardware->hbuf[1], t, hlen);
 		if (hlen + 1 < sizeof(hardware->hbuf))
 			memset(&hardware->hbuf[hlen + 1], 0,
 			       (sizeof(hardware->hbuf)) - hlen - 1);
 		dfree(t, MDL);
+	}
       out:
 	token = next_token(&val, NULL, cfile);
 	if (token != SEMI) {
 		parse_warn(cfile, "expecting semicolon.");
 		skip_to_semi(cfile);
+	}
+}
 /* lease-time :== NUMBER SEMI */
 void parse_lease_time (cfile, timep)
 	struct parse *cfile;
 	TIME *timep;
+{
 	const char *val;
 	enum dhcp_token token;
 	u_int32_t num;
 	token = next_token (&val, (unsigned *)0, cfile);
 	if (token != NUMBER) {
 		parse_warn (cfile, "Expecting numeric lease time");
 		skip_to_semi (cfile);
 		return;
+	}
 	convert_num(cfile, (unsigned char *)&num, val, 10, 32);
 	/* Unswap the number - convert_num returns stuff in NBO. */
 	*timep = ntohl(num);
 	parse_semi (cfile);
+}
 /* No BNF for numeric aggregates - that's defined by the caller.  What
    this function does is to parse a sequence of numbers separated by
    the token specified in separator.  If max is zero, any number of
    numbers will be parsed; otherwise, exactly max numbers are
    expected.  Base and size tell us how to internalize the numbers
    once they've been tokenized.
    buf - A pointer to space to return the parsed value, if it is null
    then the function will allocate space for the return.
    max - The maximum number of items to store.  If zero there is no
    maximum.  When buf is null and the function needs to allocate space
    it will do an allocation of max size at the beginning if max is non
    zero.  If max is zero then the allocation will be done later, after
    the function has determined the size necessary for the incoming
    string.
    returns NULL on errors or a pointer to the value string on success.
    The pointer will either be buf if it was non-NULL or newly allocated
    space if buf was NULL
  */
 unsigned char *parse_numeric_aggregate (cfile, buf,
 					max, separator, base, size)
 	struct parse *cfile;
 	unsigned char *buf;
 	unsigned *max;
 	int separator;
 	int base;
 	unsigned size;
+{
 	const char *val;
 	enum dhcp_token token;
 	unsigned char *bufp = buf, *s, *t;
 	unsigned count = 0;
 	pair c = (pair)0;
 	if (!bufp && *max) {
 		bufp = (unsigned char *)dmalloc (*max * size / 8, MDL);
 		if (!bufp)
 			log_fatal ("no space for numeric aggregate");
+	}
 	s = bufp;
 	do {
 		if (count) {
 			token = peek_token (&val, (unsigned *)0, cfile);
 			if (token != separator) {
 				if (!*max)
 					break;
 				if (token != RBRACE && token != LBRACE)
 					token = next_token (&val,
 							    (unsigned *)0,
 							    cfile);
 				parse_warn (cfile, "too few numbers.");
 				if (token != SEMI)
 					skip_to_semi (cfile);
 				/* free bufp if it was allocated */
 				if ((bufp != NULL) && (bufp != buf))
 					dfree(bufp, MDL);
 				return (unsigned char *)0;
+			}
 			skip_token(&val, (unsigned *)0, cfile);
+		}
 		token = next_token (&val, (unsigned *)0, cfile);
 		if (token == END_OF_FILE) {
 			parse_warn (cfile, "unexpected end of file");
 			break;
+		}
 		/* Allow NUMBER_OR_NAME if base is 16. */
 		if (token != NUMBER &&
 		    (base != 16 || token != NUMBER_OR_NAME)) {
 			parse_warn (cfile, "expecting numeric value.");
 			skip_to_semi (cfile);
 			/* free bufp if it was allocated */
 			if ((bufp != NULL) && (bufp != buf))
 				dfree(bufp, MDL);
 			/* free any linked numbers we may have allocated */
 			while (c) {
 				pair cdr = c->cdr;
 				dfree(c->car, MDL);
 				dfree(c, MDL);
 				c = cdr;
+			}
 			return (NULL);
+		}
 		/* If we can, convert the number now; otherwise, build
 		   a linked list of all the numbers. */
 		if (s) {
 			convert_num (cfile, s, val, base, size);
 			s += size / 8;
 		} else {
 			t = (unsigned char *)dmalloc (strlen (val) + 1, MDL);
 			if (!t)
 				log_fatal ("no temp space for number.");
 			strcpy ((char *)t, val);
 			c = cons ((caddr_t)t, c);
+		}
 	} while (++count != *max);
 	/* If we had to cons up a list, convert it now. */
 	if (c) {
 		/*
 		 * No need to cleanup bufp, to get here we didn't allocate
 		 * bufp above
 		 */
 		bufp = (unsigned char *)dmalloc (count * size / 8, MDL);
 		if (!bufp)
 			log_fatal ("no space for numeric aggregate.");
 		s = bufp + count - size / 8;
 		*max = count;
+	}
 	while (c) {
 		pair cdr = c -> cdr;
 		convert_num (cfile, s, (char *)(c -> car), base, size);
 		s -= size / 8;
 		/* Free up temp space. */
 		dfree (c -> car, MDL);
 		dfree (c, MDL);
 		c = cdr;
+	}
 	return bufp;
+}
 void convert_num (cfile, buf, str, base, size)
 	struct parse *cfile;
 	unsigned char *buf;
 	const char *str;
 	int base;
 	unsigned size;
+{
 	const unsigned char *ptr = (const unsigned char *)str;
 	int negative = 0;
 	u_int32_t val = 0;
 	int tval;
 	int max;
 	if (*ptr == '-') {
 		negative = 1;
 		++ptr;
+	}
 	/* If base wasn't specified, figure it out from the data. */
 	if (!base) {
 		if (ptr [0] == '0') {
 			if (ptr [1] == 'x') {
 				base = 16;
 				ptr += 2;
 			} else if (isascii (ptr [1]) && isdigit (ptr [1])) {
 				base = 8;
 				ptr += 1;
 			} else {
 				base = 10;
+			}
 		} else {
 			base = 10;
+		}
+	}
 	do {
 		tval = *ptr++;
 		/* XXX assumes ASCII... */
 		if (tval >= 'a')
 			tval = tval - 'a' + 10;
 		else if (tval >= 'A')
 			tval = tval - 'A' + 10;
 		else if (tval >= '0')
 			tval -= '0';
 		else {
 			parse_warn (cfile, "Bogus number: %s.", str);
 			break;
+		}
 		if (tval >= base) {
 			parse_warn (cfile,
 				    "Bogus number %s: digit %d not in base %d",
 				    str, tval, base);
 			break;
+		}
 		val = val * base + tval;
 	} while (*ptr);
 	if (negative)
 		max = (1 << (size - 1));
 	else
 		max = (1 << (size - 1)) + ((1 << (size - 1)) - 1);
 	if (val > max) {
 		switch (base) {
 		      case 8:
 			parse_warn (cfile,
 				    "%s%lo exceeds max (%d) for precision.",
 				    negative ? "-" : "",
 				    (unsigned long)val, max);
 			break;
 		      case 16:
 			parse_warn (cfile,
 				    "%s%lx exceeds max (%d) for precision.",
 				    negative ? "-" : "",
 				    (unsigned long)val, max);
 			break;
 		      default:
 			parse_warn (cfile,
 				    "%s%lu exceeds max (%d) for precision.",
 				    negative ? "-" : "",
 				    (unsigned long)val, max);
 			break;
+		}
+	}
 	if (negative) {
 		switch (size) {
 		      case 8:
 			*buf = -(unsigned long)val;
 			break;
 		      case 16:
 			putShort (buf, -(long)val);
 			break;
 		      case 32:
 			putLong (buf, -(long)val);
 			break;
 		      default:
 			parse_warn (cfile,
 				    "Unexpected integer size: %d\n", size);
 			break;
+		}
 	} else {
 		switch (size) {
 		      case 8:
 			*buf = (u_int8_t)val;
 			break;
 		      case 16:
 			putUShort (buf, (u_int16_t)val);
 			break;
 		      case 32:
 			putULong (buf, val);
 			break;
 		      default:
 			parse_warn (cfile,
 				    "Unexpected integer size: %d\n", size);
 			break;
+		}
+	}
+}
 /*
  * date :== NUMBER NUMBER SLASH NUMBER SLASH NUMBER
  *		NUMBER COLON NUMBER COLON NUMBER |
  *          NUMBER NUMBER SLASH NUMBER SLASH NUMBER
  *		NUMBER COLON NUMBER COLON NUMBER NUMBER |
  *          EPOCH NUMBER |
  *	    NEVER
+ *
  * Dates are stored in UTC or with a timezone offset; first number is day
  * of week; next is year/month/day; next is hours:minutes:seconds on a
  * 24-hour clock, followed by the timezone offset in seconds, which is
  * optional.
  */
 /*
  * just parse the date
  * any trailing semi must be consumed by the caller of this routine
  */
 TIME
 parse_date_core(cfile)
 	struct parse *cfile;
+{
 	int guess;
 	int tzoff, year, mon, mday, hour, min, sec;
 	const char *val;
 	enum dhcp_token token;
 	static int months[11] = { 31, 59, 90, 120, 151, 181,
 , 243, 273, 304, 334 };
 	/* "never", "epoch" or day of week */
 	token = peek_token(&val, NULL, cfile);
 	if (token == NEVER) {
 		skip_token(&val, NULL, cfile); /* consume NEVER */
 		return(MAX_TIME);
+	}
 	/* This indicates 'local' time format. */
 	if (token == EPOCH) {
 		skip_token(&val, NULL, cfile); /* consume EPOCH */
 		token = peek_token(&val, NULL, cfile);
 		if (token != NUMBER) {
 			if (token != SEMI)
 				skip_token(&val, NULL, cfile);
 			parse_warn(cfile, "Seconds since epoch expected.");
 			return((TIME)0);
+		}
 		skip_token(&val, NULL, cfile); /* consume number */
 		guess = atoi(val);
 		return((TIME)guess);
+	}
 	if (token != NUMBER) {
 		if (token != SEMI)
 			skip_token(&val, NULL, cfile);
 		parse_warn(cfile, "numeric day of week expected.");
 		return((TIME)0);
+	}
 	skip_token(&val, NULL, cfile); /* consume day of week */
         /* we are not using this for anything */
 	/* Year... */
 	token = peek_token(&val, NULL, cfile);
 	if (token != NUMBER) {
 		if (token != SEMI)
 			skip_token(&val, NULL, cfile);
 		parse_warn(cfile, "numeric year expected.");
 		return((TIME)0);
+	}
 	skip_token(&val, NULL, cfile); /* consume year */
 	/* Note: the following is not a Y2K bug - it's a Y1.9K bug.   Until
 	   somebody invents a time machine, I think we can safely disregard
 	   it.   This actually works around a stupid Y2K bug that was present
 	   in a very early beta release of dhcpd. */
 	year = atoi(val);
 	if (year > 1900)
 		year -= 1900;
 	/* Slash separating year from month... */
 	token = peek_token(&val, NULL, cfile);
 	if (token != SLASH) {
 		if (token != SEMI)
 			skip_token(&val, NULL, cfile);
 		parse_warn(cfile,
 			   "expected slash separating year from month.");
 		return((TIME)0);
+	}
 	skip_token(&val, NULL, cfile); /* consume SLASH */
 	/* Month... */
 	token = peek_token(&val, NULL, cfile);
 	if (token != NUMBER) {
 		if (token != SEMI)
 			skip_token(&val, NULL, cfile);
 		parse_warn(cfile, "numeric month expected.");
 		return((TIME)0);
+	}
 	skip_token(&val, NULL, cfile); /* consume month */
 	mon = atoi(val) - 1;
 @@ -4565,1208 +4565,1209 @@ int parse_expression (expr, cfile, lose,
 		context = expression_context (rhs);
 		break;
 	      case OR:
 		next_op = expr_or;
 		context = expression_context (rhs);
 		break;
 	      case PLUS:
 		next_op = expr_add;
 		context = expression_context (rhs);
 		break;
 	      case MINUS:
 		next_op = expr_subtract;
 		context = expression_context (rhs);
 		break;
 	      case SLASH:
 		next_op = expr_divide;
 		context = expression_context (rhs);
 		break;
 	      case ASTERISK:
 		next_op = expr_multiply;
 		context = expression_context (rhs);
 		break;
 	      case PERCENT:
 		next_op = expr_remainder;
 		context = expression_context (rhs);
 		break;
 	      case AMPERSAND:
 		next_op = expr_binary_and;
 		context = expression_context (rhs);
 		break;
 	      case PIPE:
 		next_op = expr_binary_or;
 		context = expression_context (rhs);
 		break;
 	      case CARET:
 		next_op = expr_binary_xor;
 		context = expression_context (rhs);
 		break;
 	      default:
 		next_op = expr_none;
+	}
 	/* If we have no lhs yet, we just parsed it. */
 	if (!lhs) {
 		/* If there was no operator following what we just parsed,
 		   then we're done - return it. */
 		if (next_op == expr_none) {
 			*expr = rhs;
 			return 1;
+		}
 		lhs = rhs;
 		rhs = (struct expression *)0;
 		binop = next_op;
 		skip_token(&val, (unsigned *)0, cfile);
 		goto new_rhs;
+	}
 	/* If the next binary operator is of greater precedence than the
 	 * current operator, then rhs we have parsed so far is actually
 	 * the lhs of the next operator.  To get this value, we have to
 	 * recurse.
 	 */
 	if (binop != expr_none && next_op != expr_none &&
 	    op_precedence (binop, next_op) < 0) {
 		/* Eat the subexpression operator token, which we pass to
 		 * parse_expression...we only peek()'d earlier.
 		 */
 		skip_token(&val, (unsigned *)0, cfile);
 		/* Continue parsing of the right hand side with that token. */
 		tmp = rhs;
 		rhs = (struct expression *)0;
 		if (!parse_expression (&rhs, cfile, lose, op_context (next_op),
 				       &tmp, next_op)) {
 			if (!*lose) {
 				parse_warn (cfile,
 					    "expecting a subexpression");
 				*lose = 1;
+			}
 			return 0;
+		}
 		next_op = expr_none;
+	}
 	if (binop != expr_none) {
 	  rhs_context = expression_context(rhs);
 	  lhs_context = expression_context(lhs);
 	  if ((rhs_context != context_any) && (lhs_context != context_any) &&
 			(rhs_context != lhs_context)) {
 	    parse_warn (cfile, "illegal expression relating different types");
 	    skip_to_semi (cfile);
 	    expression_dereference (&rhs, MDL);
 	    expression_dereference (&lhs, MDL);
 	    *lose = 1;
 	    return 0;
+	  }
 	  switch(binop) {
 	    case expr_not_equal:
 	    case expr_equal:
 		if ((rhs_context != context_data_or_numeric) &&
 		    (rhs_context != context_data) &&
 		    (rhs_context != context_numeric) &&
 		    (rhs_context != context_any)) {
 			parse_warn (cfile, "expecting data/numeric expression");
 			skip_to_semi (cfile);
 			expression_dereference (&rhs, MDL);
 			*lose = 1;
 			return 0;
+		}
 		break;
 	    case expr_regex_match:
 #ifdef HAVE_REGEX_H
 		if (expression_context(rhs) != context_data) {
 			parse_warn(cfile, "expecting data expression");
 			skip_to_semi(cfile);
 			expression_dereference(&rhs, MDL);
 			*lose = 1;
 			return 0;
+		}
 #else
 		/* It should not be possible to attempt to parse the right
 		 * hand side of an operator there is no support for.
 		 */
 		log_fatal("Impossible condition at %s:%d.", MDL);
 #endif
 		break;
 	    case expr_and:
 	    case expr_or:
 		if ((rhs_context != context_boolean) &&
 		    (rhs_context != context_any)) {
 			parse_warn (cfile, "expecting boolean expressions");
 			skip_to_semi (cfile);
 			expression_dereference (&rhs, MDL);
 			*lose = 1;
 			return 0;
+		}
 		break;
 	    case expr_add:
 	    case expr_subtract:
 	    case expr_divide:
 	    case expr_multiply:
 	    case expr_remainder:
 	    case expr_binary_and:
 	    case expr_binary_or:
 	    case expr_binary_xor:
 		if ((rhs_context != context_numeric) &&
 		    (rhs_context != context_any)) {
 			parse_warn (cfile, "expecting numeric expressions");
                         skip_to_semi (cfile);
                         expression_dereference (&rhs, MDL);
                         *lose = 1;
                         return 0;
+		}
 		break;
 	    default:
 		break;
+	  }
+	}
 	/* Now, if we didn't find a binary operator, we're done parsing
 	   this subexpression, so combine it with the preceding binary
 	   operator and return the result. */
 	if (next_op == expr_none) {
 		if (!expression_allocate (expr, MDL))
 			log_fatal ("Can't allocate expression!");
 		(*expr) -> op = binop;
 		/* All the binary operators' data union members
 		   are the same, so we'll cheat and use the member
 		   for the equals operator. */
 		(*expr) -> data.equal [0] = lhs;
 		(*expr) -> data.equal [1] = rhs;
 		return 1;
+	}
 	/* Eat the operator token - we now know it was a binary operator... */
 	skip_token(&val, (unsigned *)0, cfile);
 	/* Now combine the LHS and the RHS using binop. */
 	tmp = (struct expression *)0;
 	if (!expression_allocate (&tmp, MDL))
 		log_fatal ("No memory for equal precedence combination.");
 	/* Store the LHS and RHS. */
 	tmp -> data.equal [0] = lhs;
 	tmp -> data.equal [1] = rhs;
 	tmp -> op = binop;
 	lhs = tmp;
 	tmp = (struct expression *)0;
 	rhs = (struct expression *)0;
 	binop = next_op;
 	goto new_rhs;
+}
 int parse_option_data (expr, cfile, lookups, option)
 struct expression **expr;
 struct parse *cfile;
 int lookups;
 struct option *option;
+{
 	const char *val;
 	const char *fmt = NULL;
 	struct expression *tmp;
 	enum dhcp_token token;
 	do {
 		/*
                  * Set a flag if this is an array of a simple type (i.e.,
                  * not an array of pairs of IP addresses, or something like
                  * that.
                  */
 		int uniform = 0;
 	      and_again:
 		/* Set fmt to start of format for 'A' and one char back
 		 * for 'a'.
 		 */
 		if ((fmt != NULL) && (fmt != option->format) && (*fmt == 'a'))
 			fmt -= 1;
 		else if ((fmt == NULL) || (*fmt == 'A'))
 			fmt = option->format;
 		/* 'a' means always uniform */
 		if ((fmt[0] != 'Z') && (tolower((unsigned char)fmt[1]) == 'a'))
 			uniform = 1;
 		do {
 			if ((*fmt == 'A') || (*fmt == 'a'))
 				break;
 			if (*fmt == 'o') {
 				/* consume the optional flag */
 				fmt++;
 				continue;
+			}
 			if (fmt[1] == 'o') {
 				/*
 				 * A value for the current format is
 				 * optional - check to see if the next
 				 * token is a semi-colon if so we don't
 				 * need to parse it and doing so would
 				 * consume the semi-colon which our
 				 * caller is expecting to parse
 				 */
 				token = peek_token(&val, (unsigned *)0,
 						   cfile);
 				if (token == SEMI) {
 					fmt++;
 					continue;
+				}
+			}
 			tmp = *expr;
 			*expr = NULL;
 			if (!parse_option_token(expr, cfile, &fmt, tmp,
 						uniform, lookups)) {
 				if (fmt [1] != 'o') {
 					if (tmp)
 						expression_dereference (&tmp,
 									MDL);
 					return 0;
+				}
 				*expr = tmp;
 				tmp = NULL;
+			}
 			if (tmp)
 				expression_dereference (&tmp, MDL);
 			fmt++;
 		} while (*fmt != '\0');
 		if ((*fmt == 'A') || (*fmt == 'a')) {
 			token = peek_token (&val, (unsigned *)0, cfile);
 			/* Comma means: continue with next element in array */
 			if (token == COMMA) {
 				skip_token(&val, (unsigned *)0, cfile);
 				continue;
+			}
 			/* no comma: end of array.
 			   'A' or end of string means: leave the loop */
 			if ((*fmt == 'A') || (fmt[1] == '\0'))
 				break;
 			/* 'a' means: go on with next char */
 			if (*fmt == 'a') {
 				fmt++;
 				goto and_again;
+			}
+		}
 	} while ((*fmt == 'A') || (*fmt == 'a'));
         return 1;
+}
 /* option-statement :== identifier DOT identifier <syntax> SEMI
 		      | identifier <syntax> SEMI
    Option syntax is handled specially through format strings, so it
    would be painful to come up with BNF for it.   However, it always
    starts as above and ends in a SEMI. */
 int parse_option_statement (result, cfile, lookups, option, op)
 	struct executable_statement **result;
 	struct parse *cfile;
 	int lookups;
 	struct option *option;
 	enum statement_op op;
+{
 	const char *val;
 	enum dhcp_token token;
 	struct expression *expr = (struct expression *)0;
 	int lose;
 	token = peek_token (&val, (unsigned *)0, cfile);
 	if ((token == SEMI) && (option->format[0] != 'Z')) {
 		/* Eat the semicolon... */
 		/*
 		 * XXXSK: I'm not sure why we should ever get here, but we
 		 * 	  do during our startup. This confuses things if
 		 * 	  we are parsing a zero-length option, so don't
 		 * 	  eat the semicolon token in that case.
 		 */
 		skip_token(&val, (unsigned *)0, cfile);
 	} else if (token == EQUAL) {
 		/* Eat the equals sign. */
 		skip_token(&val, (unsigned *)0, cfile);
 		/* Parse a data expression and use its value for the data. */
 		if (!parse_data_expression (&expr, cfile, &lose)) {
 			/* In this context, we must have an executable
 			   statement, so if we found something else, it's
 			   still an error. */
 			if (!lose) {
 				parse_warn (cfile,
 					    "expecting a data expression.");
 				skip_to_semi (cfile);
+			}
 			return 0;
+		}
 	} else {
 		if (! parse_option_data(&expr, cfile, lookups, option))
 			return 0;
+	}
 	if (!parse_semi (cfile))
 		return 0;
 	if (!executable_statement_allocate (result, MDL))
 		log_fatal ("no memory for option statement.");
         (*result)->op = op;
 	if (expr && !option_cache (&(*result)->data.option,
 				   NULL, expr, option, MDL))
 		log_fatal ("no memory for option cache");
 	if (expr)
 		expression_dereference (&expr, MDL);
 	return 1;
+}
 int parse_option_token (rv, cfile, fmt, expr, uniform, lookups)
 	struct expression **rv;
 	struct parse *cfile;
 	const char **fmt;
 	struct expression *expr;
 	int uniform;
 	int lookups;
+{
 	const char *val;
 	enum dhcp_token token;
 	struct expression *t = (struct expression *)0;
 	unsigned char buf [4];
 	unsigned len;
 	struct iaddr addr;
 	int compress;
 	isc_boolean_t freeval = ISC_FALSE;
 	const char *f, *g;
 	struct enumeration_value *e;
 	switch (**fmt) {
 	      case 'U':
 		token = next_token (&val, &len, cfile);
 		if (!is_identifier (token)) {
 			if ((*fmt) [1] != 'o') {
 				parse_warn (cfile, "expecting identifier.");
 				if (token != SEMI)
 					skip_to_semi (cfile);
+			}
 			return 0;
+		}
 		if (!make_const_data (&t, (const unsigned char *)val,
 				      len, 1, 1, MDL))
 			log_fatal ("No memory for %s", val);
 		break;
 	      case 'E':
 		g = strchr (*fmt, '.');
 		if (!g) {
 			parse_warn (cfile,
 				    "malformed encapsulation format (bug!)");
 			skip_to_semi (cfile);
 			return 0;
+		}
 		*fmt = g;
 		/* FALL THROUGH */
 		/* to get string value for the option */
 	      case 'X':
 		token = peek_token (&val, (unsigned *)0, cfile);
 		if (token == NUMBER_OR_NAME || token == NUMBER) {
 			if (!expression_allocate (&t, MDL))
 				return 0;
 			if (!parse_cshl (&t -> data.const_data, cfile)) {
 				expression_dereference (&t, MDL);
 				return 0;
+			}
 			t -> op = expr_const_data;
 		} else {
 			token = next_token (&val, &len, cfile);
 			if(token == STRING) {
 				if (!make_const_data (&t,
 						(const unsigned char *)val,
 							len, 1, 1, MDL))
 					log_fatal ("No memory for \"%s\"", val);
 			} else {
                                 if ((*fmt) [1] != 'o') {
 				        parse_warn (cfile, "expecting string "
 					            "or hexadecimal data.");
 				        skip_to_semi (cfile);
+                                }
 				return 0;
+			}
+		}
 		break;
               case 'D': /* Domain list... */
 		if ((*fmt)[1] == 'c') {
 			compress = 1;
 			/* Skip the compress-flag atom. */
 			(*fmt)++;
 		} else
 			compress = 0;
 		t = parse_domain_list(cfile, compress);
 		if (!t) {
 			if ((*fmt)[1] != 'o')
 				skip_to_semi(cfile);
 			return 0;
+		}
 		break;
 	      case 'd': /* Domain name... */
 		t = parse_domain_name(cfile);
 		if (!t) {
 			parse_warn(cfile, "not a valid domain name.");
 			skip_to_semi(cfile);
 			return 0;
+		}
 		break;
 	      case 't': /* Text string... */
 		token = next_token (&val, &len, cfile);
 		if (token != STRING && !is_identifier (token)) {
 			if ((*fmt) [1] != 'o') {
 				parse_warn (cfile, "expecting string.");
 				if (token != SEMI)
 					skip_to_semi (cfile);
+			}
 			return 0;
+		}
 		if (!make_const_data (&t, (const unsigned char *)val,
 				      len, 1, 1, MDL))
 			log_fatal ("No memory for concatenation");
 		if (freeval == ISC_TRUE) {
 			dfree((char *)val, MDL);
 			freeval = ISC_FALSE;
 			POST(freeval);
+		}
 		break;
 	      case 'k': /* key name */
 		token = peek_token (&val, &len, cfile);
 		if (token == STRING) {
 			token = next_token (&val, &len, cfile);
 		} else {
 			val = parse_host_name(cfile);
 			if (!val) {
 				parse_warn(cfile, "not a valid key name.");
 				skip_to_semi(cfile);
 				return 0;
+			}
 			freeval = ISC_TRUE;
+		}
 		if (!make_const_data (&t, (const unsigned char *)val,
 				      strlen(val), 1, 1, MDL)) {
 			log_fatal ("No memory key name");
+		}
 		if (freeval == ISC_TRUE) {
 			dfree((char *)val, MDL);
 			freeval = ISC_FALSE;
+		}
 		break;
 	      case 'N':
 		f = (*fmt) + 1;
 		g = strchr (*fmt, '.');
 		if (!g) {
 			parse_warn (cfile, "malformed %s (bug!)",
 				    "enumeration format");
 		      foo:
 			skip_to_semi (cfile);
 			return 0;
+		}
 		*fmt = g;
 		token = next_token (&val, (unsigned *)0, cfile);
 		if (!is_identifier (token)) {
 			parse_warn (cfile,
 				    "identifier expected");
 			goto foo;
+		}
 		e = find_enumeration_value (f, (*fmt) - f, &len, val);
 		if (!e) {
 			parse_warn (cfile, "unknown value");
 			goto foo;
+		}
 		if (!make_const_data (&t, &e -> value, len, 0, 1, MDL))
 			return 0;
 		break;
 	      case 'I': /* IP address or hostname. */
 		if (lookups) {
 			if (!parse_ip_addr_or_hostname (&t, cfile, uniform))
 				return 0;
 		} else {
 			if (!parse_ip_addr (cfile, &addr))
 				return 0;
 			if (!make_const_data (&t, addr.iabuf, addr.len,
 , 1, MDL))
 				return 0;
+		}
 		break;
 	      case '6': /* IPv6 address. */
 		if (!parse_ip6_addr(cfile, &addr)) {
 			return 0;
+		}
 		if (!make_const_data(&t, addr.iabuf, addr.len, 0, 1, MDL)) {
 			return 0;
+		}
 		break;
 	      case 'T':	/* Lease interval. */
 		token = next_token (&val, (unsigned *)0, cfile);
 		if (token != INFINITE)
 			goto check_number;
 		putLong (buf, -1);
 		if (!make_const_data (&t, buf, 4, 0, 1, MDL))
 			return 0;
 		break;
 	      case 'L': /* Unsigned 32-bit integer... */
 	      case 'l':	/* Signed 32-bit integer... */
 		token = next_token (&val, (unsigned *)0, cfile);
 	      check_number:
 		if ((token != NUMBER) && (token != NUMBER_OR_NAME)) {
 		      need_number:
 			if ((*fmt) [1] != 'o') {
 				parse_warn (cfile, "expecting number.");
 				if (token != SEMI)
 					skip_to_semi (cfile);
+			}
 			return 0;
+		}
 		convert_num (cfile, buf, val, 0, 32);
 		if (!make_const_data (&t, buf, 4, 0, 1, MDL))
 			return 0;
 		break;
 	      case 's':	/* Signed 16-bit integer. */
 	      case 'S':	/* Unsigned 16-bit integer. */
 		token = next_token (&val, (unsigned *)0, cfile);
 		if ((token != NUMBER) && (token != NUMBER_OR_NAME))
 			goto need_number;
 		convert_num (cfile, buf, val, 0, 16);
 		if (!make_const_data (&t, buf, 2, 0, 1, MDL))
 			return 0;
 		break;
 	      case 'b':	/* Signed 8-bit integer. */
 	      case 'B':	/* Unsigned 8-bit integer. */
 		token = next_token (&val, (unsigned *)0, cfile);
 		if ((token != NUMBER) && (token != NUMBER_OR_NAME))
 			goto need_number;
 		convert_num (cfile, buf, val, 0, 8);
 		if (!make_const_data (&t, buf, 1, 0, 1, MDL))
 			return 0;
 		break;
 	      case 'f': /* Boolean flag. */
 		token = next_token (&val, (unsigned *)0, cfile);
 		if (!is_identifier (token)) {
 			if ((*fmt) [1] != 'o')
 				parse_warn (cfile, "expecting identifier.");
 		      bad_flag:
 			if ((*fmt) [1] != 'o') {
 				if (token != SEMI)
 					skip_to_semi (cfile);
+			}
 			return 0;
+		}
 		if (!strcasecmp (val, "true")
 		    || !strcasecmp (val, "on"))
 			buf [0] = 1;
 		else if (!strcasecmp (val, "false")
 			 || !strcasecmp (val, "off"))
 			buf [0] = 0;
 		else if (!strcasecmp (val, "ignore"))
 			buf [0] = 2;
 		else {
 			if ((*fmt) [1] != 'o')
 				parse_warn (cfile, "expecting boolean.");
 			goto bad_flag;
+		}
 		if (!make_const_data (&t, buf, 1, 0, 1, MDL))
 			return 0;
 		break;
 	      case 'Z': /* Zero-length option. */
 		token = peek_token (&val, (unsigned *)0, cfile);
 		if (token != SEMI) {
 			parse_warn(cfile, "semicolon expected.");
 			skip_to_semi(cfile);
+		}
 		buf[0] = '\0';
 		if (!make_const_data(&t,        /* expression */
 				     buf,       /* buffer */
 ,         /* length */
 ,         /* terminated */
 ,         /* allocate */
 				     MDL))
 			return 0;
 		break;
 	      default:
 		parse_warn (cfile, "Bad format '%c' in parse_option_token.",
 			    **fmt);
 		skip_to_semi (cfile);
 		return 0;
+	}
 	if (expr) {
 		if (!make_concat (rv, expr, t))
 			return 0;
 	} else
 		expression_reference (rv, t, MDL);
 	expression_dereference (&t, MDL);
 	return 1;
+}
 int parse_option_decl (oc, cfile)
 	struct option_cache **oc;
 	struct parse *cfile;
+{
 	const char *val;
 	int token;
 	u_int8_t buf [4];
 	u_int8_t hunkbuf [1024];
 	unsigned hunkix = 0;
 	const char *fmt, *f;
 	struct option *option=NULL;
 	struct iaddr ip_addr;
 	u_int8_t *dp;
 	const u_int8_t *cdp;
 	unsigned len;
 	int nul_term = 0;
 	struct buffer *bp;
 	int known = 0;
 	int compress;
 	struct expression *express = NULL;
 	struct enumeration_value *e;
 	isc_result_t status;
 	status = parse_option_name (cfile, 0, &known, &option);
 	if (status != ISC_R_SUCCESS || option == NULL)
 		return 0;
 	fmt = option->format;
 	/* Parse the option data... */
 	do {
 		for (; *fmt; fmt++) {
 			if (*fmt == 'A') {
 				/* 'A' is an array of records, start at
 				 *  the beginning
 				 */
 				fmt = option->format;
 				break;
+			}
 			if (*fmt == 'a') {
 				/* 'a' is an array of the last field,
 				 * back up one format character
 				 */
 				fmt--;
 				break;
+			}
 			if (*fmt == 'o' && fmt != option -> format)
 				continue;
 			switch (*fmt) {
 			      case 'E':
 				fmt = strchr (fmt, '.');
 				if (!fmt) {
 					parse_warn (cfile,
 						    "malformed %s (bug!)",
 						    "encapsulation format");
 					goto parse_exit;
+				}
 				/* FALL THROUGH */
 				/* to get string value for the option */
 			      case 'X':
 				len = parse_X (cfile, &hunkbuf [hunkix],
 					       sizeof hunkbuf - hunkix);
 				hunkix += len;
 				break;
 			      case 't': /* Text string... */
 				token = peek_token (&val,
 						    &len, cfile);
 				if (token == SEMI && fmt[1] == 'o') {
 					fmt++;
 					break;
+				}
 				token = next_token (&val,
 						    &len, cfile);
 				if (token != STRING) {
 					parse_warn (cfile,
 						    "expecting string.");
 					goto parse_exit;
+				}
 				if (hunkix + len + 1 > sizeof hunkbuf) {
 					parse_warn (cfile,
 						    "option data buffer %s",
 						    "overflow");
 					goto parse_exit;
+				}
 				memcpy (&hunkbuf [hunkix], val, len + 1);
 				nul_term = 1;
 				hunkix += len;
 				break;
 			      case 'D':
 				if (fmt[1] == 'c') {
 					compress = 1;
 					fmt++;
 				} else
 					compress = 0;
 				express = parse_domain_list(cfile, compress);
 				if (express == NULL)
 					goto exit;
 				if (express->op != expr_const_data) {
 					parse_warn(cfile, "unexpected "
 							  "expression");
 					goto parse_exit;
+				}
 				len = express->data.const_data.len;
 				cdp = express->data.const_data.data;
 				if ((hunkix + len) > sizeof(hunkbuf)) {
 					parse_warn(cfile, "option data buffer "
 							  "overflow");
 					goto parse_exit;
+				}
 				memcpy(&hunkbuf[hunkix], cdp, len);
 				hunkix += len;
 				expression_dereference(&express, MDL);
 				break;
 			      case 'N':
 				f = fmt + 1;
 				fmt = strchr (fmt, '.');
 				if (!fmt) {
 					parse_warn (cfile,
 						    "malformed %s (bug!)",
 						    "enumeration format");
 					goto parse_exit;
+				}
 				token = next_token (&val,
 						    (unsigned *)0, cfile);
 				if (!is_identifier (token)) {
 					parse_warn (cfile,
 						    "identifier expected");
 					goto parse_exit;
+				}
 				e = find_enumeration_value (f, fmt - f,
 							    &len, val);
 				if (!e) {
 					parse_warn (cfile,
 						    "unknown value");
 					goto parse_exit;
+				}
 				dp = &e -> value;
 				goto alloc;
 			      case '6':
 				if (!parse_ip6_addr(cfile, &ip_addr))
 					goto exit;
 				len = ip_addr.len;
 				dp = ip_addr.iabuf;
 				goto alloc;
 			      case 'I': /* IP address. */
 				if (!parse_ip_addr (cfile, &ip_addr))
 					goto exit;
 				len = ip_addr.len;
 				dp = ip_addr.iabuf;
 			      alloc:
 				if (hunkix + len > sizeof hunkbuf) {
 					parse_warn (cfile,
 						    "option data buffer %s",
 						    "overflow");
 					goto parse_exit;
+				}
 				memcpy (&hunkbuf [hunkix], dp, len);
 				hunkix += len;
 				break;
 			      case 'L': /* Unsigned 32-bit integer... */
 			      case 'l':	/* Signed 32-bit integer... */
 				token = next_token (&val,
 						    (unsigned *)0, cfile);
 				if ((token != NUMBER) &&
 				    (token != NUMBER_OR_NAME)) {
 				      need_number:
 					parse_warn (cfile,
 						    "expecting number.");
 					if (token != SEMI)
 						goto parse_exit;
 					else
 						goto exit;
+				}
 				convert_num (cfile, buf, val, 0, 32);
 				len = 4;
 				dp = buf;
 				goto alloc;
 			      case 's':	/* Signed 16-bit integer. */
 			      case 'S':	/* Unsigned 16-bit integer. */
 				token = next_token (&val,
 						    (unsigned *)0, cfile);
 				if ((token != NUMBER) &&
 				    (token != NUMBER_OR_NAME))
 					goto need_number;
 				convert_num (cfile, buf, val, 0, 16);
 				len = 2;
 				dp = buf;
 				goto alloc;
 			      case 'b':	/* Signed 8-bit integer. */
 			      case 'B':	/* Unsigned 8-bit integer. */
 				token = next_token (&val,
 						    (unsigned *)0, cfile);
 				if ((token != NUMBER) &&
 				    (token != NUMBER_OR_NAME))
 					goto need_number;
 				convert_num (cfile, buf, val, 0, 8);
 				len = 1;
 				dp = buf;
 				goto alloc;
 			      case 'f': /* Boolean flag. */
 				token = next_token (&val,
 						    (unsigned *)0, cfile);
 				if (!is_identifier (token)) {
 					parse_warn (cfile,
 						    "expecting identifier.");
 				      bad_flag:
 					if (token != SEMI)
 						goto parse_exit;
 					else
 						goto exit;
+				}
 				if (!strcasecmp (val, "true")
 				    || !strcasecmp (val, "on"))
 					buf [0] = 1;
 				else if (!strcasecmp (val, "false")
 					 || !strcasecmp (val, "off"))
 					buf [0] = 0;
 				else {
 					parse_warn (cfile,
 						    "expecting boolean.");
 					goto bad_flag;
+				}
 				len = 1;
 				dp = buf;
 				goto alloc;
 			      case 'Z':	/* Zero-length option */
 				token = peek_token(&val, (unsigned *)0, cfile);
 				if (token != SEMI) {
 					parse_warn(cfile,
 						   "semicolon expected.");
 					goto parse_exit;
+				}
 				len = 0;
 				buf[0] = '\0';
 				break;
 			      default:
 				log_error ("parse_option_param: Bad format %c",
 				      *fmt);
 				goto parse_exit;
+			}
+		}
 		token = next_token (&val, (unsigned *)0, cfile);
 	} while (*fmt && token == COMMA);
 	if (token != SEMI) {
 		parse_warn (cfile, "semicolon expected.");
 		goto parse_exit;
+	}
 	bp = (struct buffer *)0;
 	if (!buffer_allocate (&bp, hunkix + nul_term, MDL))
 		log_fatal ("no memory to store option declaration.");
 	memcpy (bp -> data, hunkbuf, hunkix + nul_term);
 	if (!option_cache_allocate (oc, MDL))
 		log_fatal ("out of memory allocating option cache.");
 	(*oc) -> data.buffer = bp;
 	(*oc) -> data.data = &bp -> data [0];
 	(*oc) -> data.terminated = nul_term;
 	(*oc) -> data.len = hunkix;
 	option_reference(&(*oc)->option, option, MDL);
 	option_dereference(&option, MDL);
 	return 1;
 parse_exit:
 	if (express != NULL)
 		expression_dereference(&express, MDL);
 	skip_to_semi (cfile);
 exit:
 	option_dereference(&option, MDL);
 	return 0;
+}
 /* Consider merging parse_cshl into this. */
 int parse_X (cfile, buf, max)
 	struct parse *cfile;
 	u_int8_t *buf;
 	unsigned max;
+{
 	int token;
 	const char *val;
 	unsigned len;
 	token = peek_token (&val, (unsigned *)0, cfile);
 	if (token == NUMBER_OR_NAME || token == NUMBER) {
 		len = 0;
 		do {
 			token = next_token (&val, (unsigned *)0, cfile);
 			if (token != NUMBER && token != NUMBER_OR_NAME) {
 				parse_warn (cfile,
 					    "expecting hexadecimal constant.");
 				skip_to_semi (cfile);
 				return 0;
+			}
-			convert_num (cfile, &buf [len], val, 16, 8);
+			if (len >= max) {
 			if (len++ > max) {
 				parse_warn (cfile,
 					    "hexadecimal constant too long.");
 				skip_to_semi (cfile);
 				return 0;
+			}
 			convert_num (cfile, &buf [len], val, 16, 8);
 			len++;
 			token = peek_token (&val, (unsigned *)0, cfile);
 			if (token == COLON)
 				token = next_token (&val,
 						    (unsigned *)0, cfile);
 		} while (token == COLON);
 		val = (char *)buf;
 	} else if (token == STRING) {
 		skip_token(&val, &len, cfile);
 		if (len + 1 > max) {
 			parse_warn (cfile, "string constant too long.");
 			skip_to_semi (cfile);
 			return 0;
+		}
 		memcpy (buf, val, len + 1);
 	} else {
 		parse_warn (cfile, "expecting string or hexadecimal data");
 		skip_to_semi (cfile);
 		return 0;
+	}
 	return len;
+}
 int parse_warn (struct parse *cfile, const char *fmt, ...)
+{
 	va_list list;
 	char lexbuf [256];
 	char mbuf [1024];  /* errorwarn.c CVT_BUF_MAX + 1 */
 	char fbuf [2048];
 	char final[4096];
 	unsigned i, lix;
 	/* Replace %m in fmt with errno error text */
 	do_percentm (mbuf, sizeof(mbuf), fmt);
 	/* %Audit% This is log output. %2004.06.17,Safe%
 	 * If we truncate we hope the user can get a hint from the log.
 	 */
 	/* Prepend the file and line number */
 	snprintf (fbuf, sizeof fbuf, "%s line %d: %s",
 		  cfile -> tlname, cfile -> lexline, mbuf);
 	/* Now add the var args to the format for the final log message. */
 	va_start (list, fmt);
 	vsnprintf (final, sizeof final, fbuf, list);
 	va_end (list);
 	lix = 0;
 	for (i = 0;
 	     cfile -> token_line [i] && i < (cfile -> lexchar - 1); i++) {
 		if (lix < (sizeof lexbuf) - 1)
 			lexbuf [lix++] = ' ';
 		if (cfile -> token_line [i] == '\t') {
 			for (; lix < (sizeof lexbuf) - 1 && (lix & 7); lix++)
 				lexbuf [lix] = ' ';
+		}
+	}
 	lexbuf [lix] = 0;
 #ifndef DEBUG
 	syslog (LOG_ERR, "%s", final);
 	syslog (LOG_ERR, "%s", cfile -> token_line);
 	if (cfile -> lexchar < 81)
 		syslog (LOG_ERR, "%s^", lexbuf);
 #endif
 	if (log_perror) {
 		IGNORE_RET (write (STDERR_FILENO, final, strlen (final)));
 		IGNORE_RET (write (STDERR_FILENO, "\n", 1));
 		IGNORE_RET (write (STDERR_FILENO, cfile -> token_line,
 				   strlen (cfile -> token_line)));
 		IGNORE_RET (write (STDERR_FILENO, "\n", 1));
 		if (cfile -> lexchar < 81)
 			IGNORE_RET (write (STDERR_FILENO, lexbuf, lix));
 		IGNORE_RET (write (STDERR_FILENO, "^\n", 2));
+	}
 	cfile -> warnings_occurred = 1;
 	return 0;
+}
 struct expression *
 parse_domain_list(struct parse *cfile, int compress)
+{
 	const char *val;
 	enum dhcp_token token = SEMI;
 	struct expression *t = NULL;
 	unsigned len, clen = 0;
 	int result;
 	unsigned char compbuf[256 * NS_MAXCDNAME];
 	const unsigned char *dnptrs[256], **lastdnptr;
 	memset(compbuf, 0, sizeof(compbuf));
 	memset(dnptrs, 0, sizeof(dnptrs));
 	dnptrs[0] = compbuf;
 	lastdnptr = &dnptrs[255];
 	do {
 		/* Consume the COMMA token if peeked. */
 		if (token == COMMA)
 			skip_token(&val, NULL, cfile);
 		/* Get next (or first) value. */
 		token = next_token(&val, &len, cfile);
 		if (token != STRING) {
 			parse_warn(cfile, "Expecting a domain string.");
 			return NULL;
+		}
 		/* If compression pointers are enabled, compress.  If not,
 		 * just pack the names in series into the buffer.
 		 */
 		if (compress) {
 			result = MRns_name_compress(val, compbuf + clen,
 						    sizeof(compbuf) - clen,
 						    dnptrs, lastdnptr);
 			if (result < 0) {
 				parse_warn(cfile, "Error compressing domain "
 						  "list: %m");
 				return NULL;
+			}
 			clen += result;
 		} else {
 			result = MRns_name_pton(val, compbuf + clen,
 						sizeof(compbuf) - clen);
 			/* result == 1 means the input was fully qualified.
 			 * result == 0 means the input wasn't.
 			 * result == -1 means bad things.
 			 */
 			if (result < 0) {
 				parse_warn(cfile, "Error assembling domain "
 						  "list: %m");
 				return NULL;
+			}
 			/*
 			 * We need to figure out how many bytes to increment
 			 * our buffer pointer since pton doesn't tell us.
 			 */
 			while (compbuf[clen] != 0)
 				clen += compbuf[clen] + 1;
 			/* Count the last label (0). */
 			clen++;
+		}
 		if (clen > sizeof(compbuf))
 			log_fatal("Impossible error at %s:%d", MDL);
 		token = peek_token(&val, NULL, cfile);
 	} while (token == COMMA);
 	if (!make_const_data(&t, compbuf, clen, 1, 1, MDL))
 		log_fatal("No memory for domain list object.");
 	return t;
+}
 struct expression *
 parse_domain_name(struct parse *cfile)
+{
 	const char *val;
 	struct expression *t = NULL;
 	unsigned len;
 	int result;
 	unsigned char buf[NS_MAXCDNAME];
 	val = parse_host_name(cfile);
 	if (!val) {
 		return NULL;
+	}
 	result = MRns_name_pton(val, buf, sizeof(buf));
 	/* No longer need val */
 	dfree((char *)val, MDL);
 	/* result == 1 means the input was fully qualified.
 	 * result == 0 means the input wasn't.
 	 * result == -1 means bad things.
 	 */
 	if (result < 0) {
 		parse_warn(cfile, "Error assembling domain name: %m");
 		return NULL;
+	}
 	/* Compute the used length */
 	len = 0;
 	while (buf[len] != 0) {
 		len += buf[len] + 1;
+	}
 	/* Count the last label (0). */
 	len++;
 	if (!make_const_data(&t, buf, len, 1, 1, MDL))
 		log_fatal("No memory for domain name object.");
 	return t;
+}

 @@ -1,2183 +1,2182 @@
-/*	$NetBSD: dhcrelay.c,v 1.4 2021/05/21 21:07:37 christos Exp $	*/
+/*	$NetBSD: dhcrelay.c,v 1.5 2021/05/26 22:52:32 christos Exp $	*/
 /* dhcrelay.c
    DHCP/BOOTP Relay Agent. */
 /*
- * Copyright(c) 2004-2020 by Internet Systems Consortium, Inc.("ISC")
+ * Copyright(c) 2004-2021 by Internet Systems Consortium, Inc.("ISC")
  * Copyright(c) 1997-2003 by Internet Software Consortium
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
  *   Internet Systems Consortium, Inc.
  *   950 Charter Street
  *   Redwood City, CA 94063
  *   <info@isc.org>
  *   https://www.isc.org/
+ *
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: dhcrelay.c,v 1.4 2021/05/21 21:07:37 christos Exp $");
+__RCSID("$NetBSD: dhcrelay.c,v 1.5 2021/05/26 22:52:32 christos Exp $");
 #include "dhcpd.h"
 #include <syslog.h>
 #include <signal.h>
 #include <sys/time.h>
 #include <isc/file.h>
 TIME default_lease_time = 43200; /* 12 hours... */
 TIME max_lease_time = 86400; /* 24 hours... */
 struct tree_cache *global_options[256];
 struct option *requested_opts[2];
 /* Needed to prevent linking against conflex.c. */
 int lexline;
 int lexchar;
 char *token_line;
 char *tlname;
 const char *path_dhcrelay_pid = _PATH_DHCRELAY_PID;
 isc_boolean_t no_dhcrelay_pid = ISC_FALSE;
 /* False (default) => we write and use a pid file */
 isc_boolean_t no_pid_file = ISC_FALSE;
 int bogus_agent_drops = 0;	/* Packets dropped because agent option
 				   field was specified and we're not relaying
 				   packets that already have an agent option
 				   specified. */
 int bogus_giaddr_drops = 0;	/* Packets sent to us to relay back to a
 				   client, but with a bogus giaddr. */
 int client_packets_relayed = 0;	/* Packets relayed from client to server. */
 int server_packet_errors = 0;	/* Errors sending packets to servers. */
 int server_packets_relayed = 0;	/* Packets relayed from server to client. */
 int client_packet_errors = 0;	/* Errors sending packets to clients. */
 int add_agent_options = 0;	/* If nonzero, add relay agent options. */
 int add_rfc3527_suboption = 0;	/* If nonzero, add RFC3527 link selection sub-option. */
 int agent_option_errors = 0;    /* Number of packets forwarded without
 				   agent options because there was no room. */
 int drop_agent_mismatches = 0;	/* If nonzero, drop server replies that
 				   don't have matching circuit-id's. */
 int corrupt_agent_options = 0;	/* Number of packets dropped because
 				   relay agent information option was bad. */
 int missing_agent_option = 0;	/* Number of packets dropped because no
 				   RAI option matching our ID was found. */
 int bad_circuit_id = 0;		/* Circuit ID option in matching RAI option
 				   did not match any known circuit ID. */
 int missing_circuit_id = 0;	/* Circuit ID option in matching RAI option
 				   was missing. */
 int max_hop_count = 10;		/* Maximum hop count */
 int no_daemon = 0;
 int dfd[2] = { -1, -1 };
 #ifdef DHCPv6
 	/* Force use of DHCPv6 interface-id option. */
 isc_boolean_t use_if_id = ISC_FALSE;
 #endif
 	/* Maximum size of a packet with agent options added. */
 int dhcp_max_agent_option_packet_length = DHCP_MTU_MIN;
 	/* What to do about packets we're asked to relay that
 	   already have a relay option: */
 enum { forward_and_append,	/* Forward and append our own relay option. */
        forward_and_replace,	/* Forward, but replace theirs with ours. */
        forward_untouched,	/* Forward without changes. */
        discard } agent_relay_mode = forward_and_replace;
 u_int16_t local_port = 0;
 u_int16_t remote_port = 0;
 /* Relay agent server list. */
 struct server_list {
 	struct server_list *next;
 	struct sockaddr_in to;
 } *servers;
 struct interface_info *uplink = NULL;
 #ifdef DHCPv6
 struct stream_list {
 	struct stream_list *next;
 	struct interface_info *ifp;
 	struct sockaddr_in6 link;
 	int id;
 } *downstreams, *upstreams;
 #ifndef UNIT_TEST
 static struct stream_list *parse_downstream(char *);
 static struct stream_list *parse_upstream(char *);
 static void setup_streams(void);
 #endif /* UNIT_TEST */
 /*
  * A pointer to a subscriber id to add to the message we forward.
  * This is primarily for testing purposes as we only have one id
  * for the entire relay and don't determine one per client which
  * would be more useful.
  */
 char *dhcrelay_sub_id = NULL;
 #endif
 libdhcp_callbacks_t dhcrelay_callbacks = {
 	&local_port,
 	&remote_port,
 	classify,
 	check_collection,
 	dhcp,
 #ifdef DHCPv6
 	dhcpv6,
 #endif /* DHCPv6 */
 	bootp,
 	find_class,
 	parse_allow_deny,
 	dhcp_set_control_state,
 };
 #ifndef UNIT_TEST
 static void do_relay4(struct interface_info *, struct dhcp_packet *,
 	              unsigned int, unsigned int, struct iaddr,
 		      struct hardware *);
 #endif /* UNIT_TEST */
 extern int add_relay_agent_options(struct interface_info *,
 				            struct dhcp_packet *, unsigned,
 				            struct in_addr);
 extern int find_interface_by_agent_option(struct dhcp_packet *,
 			                       struct interface_info **, u_int8_t *, int);
 extern int strip_relay_agent_options(struct interface_info *,
 				              struct interface_info **,
 				              struct dhcp_packet *, unsigned);
 #ifndef UNIT_TEST
 static void request_v4_interface(const char* name, int flags);
 static const char copyright[] =
-"Copyright 2004-2020 Internet Systems Consortium.";
+"Copyright 2004-2021 Internet Systems Consortium.";
 static const char arr[] = "All rights reserved.";
 static const char message[] =
 "Internet Systems Consortium DHCP Relay Agent";
 static const char url[] =
 "For info, please visit https://www.isc.org/software/dhcp/";
 char *progname;
 #ifdef DHCPv6
 #ifdef RELAY_PORT
 #define DHCRELAY_USAGE \
 "Usage: %s [-4] [-d] [-q] [-a] [-D]\n" \
 "                     [-A <length>] [-c <hops>]\n" \
 "                     [-p <port> | -rp <relay-port>]\n" \
 "                     [-pf <pid-file>] [--no-pid]\n"\
 "                     [-m append|replace|forward|discard]\n" \
 "                     [-i interface0 [ ... -i interfaceN]\n" \
 "                     [-iu interface0 [ ... -iu interfaceN]\n" \
 "                     [-id interface0 [ ... -id interfaceN]\n" \
 "                     [-U interface]\n" \
 "                     server0 [ ... serverN]\n\n" \
 "       %s -6   [-d] [-q] [-I] [-c <hops>]\n" \
 "                     [-p <port> | -rp <relay-port>]\n" \
 "                     [-pf <pid-file>] [--no-pid]\n" \
 "                     [-s <subscriber-id>]\n" \
 "                     -l lower0 [ ... -l lowerN]\n" \
 "                     -u upper0 [ ... -u upperN]\n" \
 "           lower (client link): [address%%]interface[#index]\n" \
 "           upper (server link): [address%%]interface\n\n" \
 "       %s {--version|--help|-h}"
 #else
 #define DHCRELAY_USAGE \
 "Usage: %s [-4] [-d] [-q] [-a] [-D]\n" \
 "                     [-A <length>] [-c <hops>] [-p <port>]\n" \
 "                     [-pf <pid-file>] [--no-pid]\n"\
 "                     [-m append|replace|forward|discard]\n" \
 "                     [-i interface0 [ ... -i interfaceN]\n" \
 "                     [-iu interface0 [ ... -iu interfaceN]\n" \
 "                     [-id interface0 [ ... -id interfaceN]\n" \
 "                     [-U interface]\n" \
 "                     server0 [ ... serverN]\n\n" \
 "       %s -6   [-d] [-q] [-I] [-c <hops>] [-p <port>]\n" \
 "                     [-pf <pid-file>] [--no-pid]\n" \
 "                     [-s <subscriber-id>]\n" \
 "                     -l lower0 [ ... -l lowerN]\n" \
 "                     -u upper0 [ ... -u upperN]\n" \
 "           lower (client link): [address%%]interface[#index]\n" \
 "           upper (server link): [address%%]interface\n\n" \
 "       %s {--version|--help|-h}"
 #endif
 #else /* !DHCPv6 */
 #ifdef RELAY_PORT
 #define DHCRELAY_USAGE \
 "Usage: %s [-d] [-q] [-a] [-D] [-A <length>] [-c <hops>]\n" \
 "                [-p <port> | -rp <relay-port>]\n" \
 "                [-pf <pid-file>] [--no-pid]\n" \
 "                [-m append|replace|forward|discard]\n" \
 "                [-i interface0 [ ... -i interfaceN]\n" \
 "                [-iu interface0 [ ... -iu interfaceN]\n" \
 "                [-id interface0 [ ... -id interfaceN]\n" \
 "                [-U interface]\n" \
 "                server0 [ ... serverN]\n\n" \
 "       %s {--version|--help|-h}"
 #else
 #define DHCRELAY_USAGE \
 "Usage: %s [-d] [-q] [-a] [-D] [-A <length>] [-c <hops>] [-p <port>]\n" \
 "                [-pf <pid-file>] [--no-pid]\n" \
 "                [-m append|replace|forward|discard]\n" \
 "                [-i interface0 [ ... -i interfaceN]\n" \
 "                [-iu interface0 [ ... -iu interfaceN]\n" \
 "                [-id interface0 [ ... -id interfaceN]\n" \
 "                [-U interface]\n" \
 "                server0 [ ... serverN]\n\n" \
 "       %s {--version|--help|-h}"
 #endif
 #endif
 /*!
+ *
  * \brief Print the generic usage message
+ *
  * If the user has provided an incorrect command line print out
  * the description of the command line.  The arguments provide
  * a way for the caller to request more specific information about
  * the error be printed as well.  Mostly this will be that some
  * comamnd doesn't include its argument.
+ *
  * \param sfmt - The basic string and format for the specific error
  * \param sarg - Generally the offending argument from the comamnd line.
+ *
  * \return Nothing
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: dhcrelay.c,v 1.4 2021/05/21 21:07:37 christos Exp $");
+__RCSID("$NetBSD: dhcrelay.c,v 1.5 2021/05/26 22:52:32 christos Exp $");
 static const char use_noarg[] = "No argument for command: %s";
 #ifdef RELAY_PORT
 static const char use_port_defined[] = "Port already set, %s inappropriate";
 #if !defined (USE_BPF_RECEIVE) && !defined (USE_LPF_RECEIVE)
 static const char bpf_sock_support[] = "Only LPF and BPF are supported: %s";
 #endif
 #endif
 #ifdef DHCPv6
 static const char use_badproto[] = "Protocol already set, %s inappropriate";
 static const char use_v4command[] = "Command not used for DHCPv6: %s";
 static const char use_v6command[] = "Command not used for DHCPv4: %s";
 #endif
 static void
 usage(const char *sfmt, const char *sarg) {
 	log_info("%s %s", message, PACKAGE_VERSION);
 	log_info(copyright);
 	log_info(arr);
 	log_info(url);
 	/* If desired print out the specific error message */
 #ifdef PRINT_SPECIFIC_CL_ERRORS
 	if (sfmt != NULL)
 		log_error(sfmt, sarg);
 #endif
 	log_fatal(DHCRELAY_USAGE,
 #ifdef DHCPv6
 		  isc_file_basename(progname),
 #endif
 		  isc_file_basename(progname),
 		  isc_file_basename(progname));
+}
 int
 main(int argc, char **argv) {
 	isc_result_t status;
 	struct servent *ent;
 	struct server_list *sp = NULL;
 	char *service_local = NULL, *service_remote = NULL;
 	u_int16_t port_local = 0, port_remote = 0;
 	int quiet = 0;
 	int fd;
 	int i;
 #ifdef RELAY_PORT
 	int port_defined = 0;
 #endif
 #ifdef DHCPv6
 	struct stream_list *sl = NULL;
 	int local_family_set = 0;
 #endif
 	libdhcp_callbacks_register(&dhcrelay_callbacks);
 #ifdef OLD_LOG_NAME
 	progname = "dhcrelay";
 #else
 	progname = argv[0];
 #endif
 	/* Make sure that file descriptors 0(stdin), 1,(stdout), and
 (stderr) are open. To do this, we assume that when we
 	   open a file the lowest available file descriptor is used. */
 	fd = open("/dev/null", O_RDWR);
 	if (fd == 0)
 		fd = open("/dev/null", O_RDWR);
 	if (fd == 1)
 		fd = open("/dev/null", O_RDWR);
 	if (fd == 2)
 		log_perror = 0; /* No sense logging to /dev/null. */
 	else if (fd != -1)
 		close(fd);
 	openlog(isc_file_basename(progname), DHCP_LOG_OPTIONS, LOG_DAEMON);
 #if !defined(DEBUG)
 	setlogmask(LOG_UPTO(LOG_INFO));
 #endif
 	/* Parse arguments changing no_daemon */
 	for (i = 1; i < argc; i++) {
 		if (!strcmp(argv[i], "-d")) {
 			no_daemon = 1;
 		} else if (!strcmp(argv[i], "--version")) {
 			log_info("isc-dhcrelay-%s", PACKAGE_VERSION);
 			exit(0);
 		} else if (!strcmp(argv[i], "--help") ||
 			   !strcmp(argv[i], "-h")) {
 			log_info(DHCRELAY_USAGE,
 #ifdef DHCPv6
 				 isc_file_basename(progname),
 #endif
 				 isc_file_basename(progname),
 				 isc_file_basename(progname));
 			exit(0);
+		}
+	}
 	/* When not forbidden prepare to become a daemon */
 	if (!no_daemon) {
 		int pid;
 		if (pipe(dfd) == -1)
 			log_fatal("Can't get pipe: %m");
 		if ((pid = fork ()) < 0)
 			log_fatal("Can't fork daemon: %m");
 		if (pid != 0) {
 			/* Parent: wait for the child to start */
 			int n;
 			(void) close(dfd[1]);
 			do {
 				char buf;
 				n = read(dfd[0], &buf, 1);
 				if (n == 1)
 					_exit(0);
 			} while (n == -1 && errno == EINTR);
 			_exit(1);
+		}
 		/* Child */
 		(void) close(dfd[0]);
+	}
 	/* Set up the isc and dns library managers */
 	status = dhcp_context_create(DHCP_CONTEXT_PRE_DB, NULL, NULL);
 	if (status != ISC_R_SUCCESS)
 		log_fatal("Can't initialize context: %s",
 			  isc_result_totext(status));
 	/* Set up the OMAPI. */
 	status = omapi_init();
 	if (status != ISC_R_SUCCESS)
 		log_fatal("Can't initialize OMAPI: %s",
 			   isc_result_totext(status));
 	/* Set up the OMAPI wrappers for the interface object. */
 	interface_setup();
 	for (i = 1; i < argc; i++) {
 		if (!strcmp(argv[i], "-4")) {
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_badproto, "-4");
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 		} else if (!strcmp(argv[i], "-6")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_badproto, "-6");
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 #endif
 		} else if (!strcmp(argv[i], "-d")) {
 			/* no_daemon = 1; */
 		} else if (!strcmp(argv[i], "-q")) {
 			quiet = 1;
 			quiet_interface_discovery = 1;
 		} else if (!strcmp(argv[i], "-p")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 #ifdef RELAY_PORT
 			if (port_defined)
 				usage(use_port_defined, argv[i-1]);
 			port_defined = 1;
 #endif
 			local_port = validate_port(argv[i]);
 			log_debug("binding to user-specified port %d",
 				  ntohs(local_port));
 #ifdef RELAY_PORT
 		} else if (!strcmp(argv[i], "-rp")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			if (port_defined)
 				usage(use_port_defined, argv[i-1]);
 			port_defined = 1;
 			relay_port = validate_port(argv[i]);
 			log_debug("binding to user-specified relay port %d",
 				  ntohs(relay_port));
 			add_agent_options = 1;
 #endif
 		} else if (!strcmp(argv[i], "-c")) {
 			int hcount;
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			hcount = atoi(argv[i]);
 			if (hcount <= 255)
 				max_hop_count= hcount;
 			else
 				usage("Bad hop count to -c: %s", argv[i]);
  		} else if (!strcmp(argv[i], "-i")) {
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_v4command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 #endif
 			if (++i == argc) {
 				usage(use_noarg, argv[i-1]);
+			}
 			request_v4_interface(argv[i], INTERFACE_STREAMS);
 		} else if (!strcmp(argv[i], "-iu")) {
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_v4command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 #endif
 			if (++i == argc) {
 				usage(use_noarg, argv[i-1]);
+			}
 			request_v4_interface(argv[i], INTERFACE_UPSTREAM);
 		} else if (!strcmp(argv[i], "-id")) {
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_v4command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 #endif
 			if (++i == argc) {
 				usage(use_noarg, argv[i-1]);
+			}
 			request_v4_interface(argv[i], INTERFACE_DOWNSTREAM);
 		} else if (!strcmp(argv[i], "-a")) {
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_v4command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 #endif
 			add_agent_options = 1;
 		} else if (!strcmp(argv[i], "-A")) {
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_v4command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 #endif
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			dhcp_max_agent_option_packet_length = atoi(argv[i]);
 			if (dhcp_max_agent_option_packet_length > DHCP_MTU_MAX)
 				log_fatal("%s: packet length exceeds "
 					  "longest possible MTU\n",
 					  argv[i]);
 		} else if (!strcmp(argv[i], "-m")) {
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_v4command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 #endif
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			if (!strcasecmp(argv[i], "append")) {
 				agent_relay_mode = forward_and_append;
 			} else if (!strcasecmp(argv[i], "replace")) {
 				agent_relay_mode = forward_and_replace;
 			} else if (!strcasecmp(argv[i], "forward")) {
 				agent_relay_mode = forward_untouched;
 			} else if (!strcasecmp(argv[i], "discard")) {
 				agent_relay_mode = discard;
 			} else
 				usage("Unknown argument to -m: %s", argv[i]);
 		} else if (!strcmp(argv [i], "-U")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			if (uplink) {
 				usage("more than one uplink (-U) specified: %s"
 				      ,argv[i]);
+			}
 			/* Allocate the uplink interface */
 			status = interface_allocate(&uplink, MDL);
 			if (status != ISC_R_SUCCESS) {
 				log_fatal("%s: uplink interface_allocate: %s",
 					 argv[i], isc_result_totext(status));
+			}
 			if (strlen(argv[i]) >= sizeof(uplink->name)) {
 				log_fatal("%s: uplink name too long,"
 					  " it cannot exceed: %ld characters",
 					  argv[i], (long)(sizeof(uplink->name) - 1));
+			}
 			uplink->name[sizeof(uplink->name) - 1] = 0x00;
 			strncpy(uplink->name, argv[i],
 				sizeof(uplink->name) - 1);
 			interface_snorf(uplink, (INTERFACE_REQUESTED |
 						INTERFACE_STREAMS));
 			/* Turn on -a, in case they don't do so explicitly */
 			add_agent_options = 1;
 			add_rfc3527_suboption = 1;
 		} else if (!strcmp(argv[i], "-D")) {
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_v4command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 #endif
 			drop_agent_mismatches = 1;
 #ifdef DHCPv6
 		} else if (!strcmp(argv[i], "-I")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			use_if_id = ISC_TRUE;
 		} else if (!strcmp(argv[i], "-l")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			if (downstreams != NULL)
 				use_if_id = ISC_TRUE;
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			sl = parse_downstream(argv[i]);
 			sl->next = downstreams;
 			downstreams = sl;
 		} else if (!strcmp(argv[i], "-u")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			sl = parse_upstream(argv[i]);
 			sl->next = upstreams;
 			upstreams = sl;
 		} else if (!strcmp(argv[i], "-s")) {
 			if (local_family_set && (local_family == AF_INET)) {
 				usage(use_v6command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET6;
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			dhcrelay_sub_id = argv[i];
 #endif
 		} else if (!strcmp(argv[i], "-pf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhcrelay_pid = argv[i];
 			no_dhcrelay_pid = ISC_TRUE;
 		} else if (!strcmp(argv[i], "--no-pid")) {
 			no_pid_file = ISC_TRUE;
  		} else if (argv[i][0] == '-') {
 			usage("Unknown command: %s", argv[i]);
  		} else {
 			struct hostent *he;
 			struct in_addr ia, *iap = NULL;
 #ifdef DHCPv6
 			if (local_family_set && (local_family == AF_INET6)) {
 				usage(use_v4command, argv[i]);
+			}
 			local_family_set = 1;
 			local_family = AF_INET;
 #endif
 			if (inet_aton(argv[i], &ia)) {
 				iap = &ia;
 			} else {
 				he = gethostbyname(argv[i]);
 				if (!he) {
 					log_error("%s: host unknown", argv[i]);
 				} else {
 					iap = ((struct in_addr *)
 					       he->h_addr_list[0]);
+				}
+			}
 			if (iap) {
 				sp = ((struct server_list *)
 				      dmalloc(sizeof *sp, MDL));
 				if (!sp)
 					log_fatal("no memory for server.\n");
 				sp->next = servers;
 				servers = sp;
 				memcpy(&sp->to.sin_addr, iap, sizeof *iap);
+			}
+ 		}
+	}
 #if defined(RELAY_PORT) && \
     !defined (USE_BPF_RECEIVE) && !defined (USE_LPF_RECEIVE)
 	if (relay_port && (local_family == AF_INET))
 		usage(bpf_sock_support, "-rp");
 #endif
 	/*
 	 * If the user didn't specify a pid file directly
 	 * find one from environment variables or defaults
 	 */
 	if (no_dhcrelay_pid == ISC_FALSE) {
 		if (local_family == AF_INET) {
 			path_dhcrelay_pid = getenv("PATH_DHCRELAY_PID");
 			if (path_dhcrelay_pid == NULL)
 				path_dhcrelay_pid = _PATH_DHCRELAY_PID;
+		}
 #ifdef DHCPv6
 		else {
 			path_dhcrelay_pid = getenv("PATH_DHCRELAY6_PID");
 			if (path_dhcrelay_pid == NULL)
 				path_dhcrelay_pid = _PATH_DHCRELAY6_PID;
+		}
 #endif
+	}
 	if (!quiet) {
 		log_info("%s %s", message, PACKAGE_VERSION);
 		log_info(copyright);
 		log_info(arr);
 		log_info(url);
 	} else
 		log_perror = 0;
 	/* Set default port */
 	if (local_family == AF_INET) {
  		service_local = "bootps";
  		service_remote = "bootpc";
 		port_local = htons(67);
  		port_remote = htons(68);
+	}
 #ifdef DHCPv6
 	else {
 		service_local = "dhcpv6-server";
 		service_remote = "dhcpv6-client";
 		port_local = htons(547);
 		port_remote = htons(546);
+	}
 #endif
 	if (!local_port) {
 		ent = getservbyname(service_local, "udp");
 		if (ent)
 			local_port = ent->s_port;
 		else
 			local_port = port_local;
 		ent = getservbyname(service_remote, "udp");
 		if (ent)
 			remote_port = ent->s_port;
 		else
 			remote_port = port_remote;
 		endservent();
+	}
 	if (local_family == AF_INET) {
 		/* We need at least one server */
 		if (servers == NULL) {
 			log_fatal("No servers specified.");
+		}
 		/* Set up the server sockaddrs. */
 		for (sp = servers; sp; sp = sp->next) {
 			sp->to.sin_port = local_port;
 			sp->to.sin_family = AF_INET;
 #ifdef HAVE_SA_LEN
 			sp->to.sin_len = sizeof sp->to;
 #endif
+		}
+	}
 #ifdef DHCPv6
 	else {
 		unsigned code;
 		/* We need at least one upstream and one downstream interface */
 		if (upstreams == NULL || downstreams == NULL) {
 			log_info("Must specify at least one lower "
 				 "and one upper interface.\n");
 			usage(NULL, NULL);
+		}
 		/* Set up the initial dhcp option universe. */
 		initialize_common_option_spaces();
 		/* Check requested options. */
 		code = D6O_RELAY_MSG;
 		if (!option_code_hash_lookup(&requested_opts[0],
 					     dhcpv6_universe.code_hash,
 					     &code, 0, MDL))
 			log_fatal("Unable to find the RELAY_MSG "
 				  "option definition.");
 		code = D6O_INTERFACE_ID;
 		if (!option_code_hash_lookup(&requested_opts[1],
 					     dhcpv6_universe.code_hash,
 					     &code, 0, MDL))
 			log_fatal("Unable to find the INTERFACE_ID "
 				  "option definition.");
+	}
 #endif
 	/* Become a daemon... */
 	if (!no_daemon) {
 		char buf = 0;
 		FILE *pf;
 		int pfdesc;
 		log_perror = 0;
 		/* Signal parent we started successfully. */
 		if (dfd[0] != -1 && dfd[1] != -1) {
 			if (write(dfd[1], &buf, 1) != 1)
 				log_fatal("write to parent: %m");
 			(void) close(dfd[1]);
 			dfd[0] = dfd[1] = -1;
+		}
 		/* Create the pid file. */
 		if (no_pid_file == ISC_FALSE) {
 			pfdesc = open(path_dhcrelay_pid,
 				      O_CREAT | O_TRUNC | O_WRONLY, 0644);
 			if (pfdesc < 0) {
 				log_error("Can't create %s: %m",
 					  path_dhcrelay_pid);
 			} else {
 				pf = fdopen(pfdesc, "w");
 				if (!pf)
 					log_error("Can't fdopen %s: %m",
 						  path_dhcrelay_pid);
 				else {
 					fprintf(pf, "%ld\n",(long)getpid());
 					fclose(pf);
+				}
+			}
+		}
 		(void) close(0);
 		(void) close(1);
 		(void) close(2);
 		(void) setsid();
 		IGNORE_RET (chdir("/"));
+	}
 	/* Set up the isc and dns library managers */
 	status = dhcp_context_create(DHCP_CONTEXT_PRE_DB | DHCP_CONTEXT_POST_DB,
 				     NULL, NULL);
 	if (status != ISC_R_SUCCESS)
 		log_fatal("Can't initialize context: %s",
 			  isc_result_totext(status));
 	/* Get the current time... */
 	gettimeofday(&cur_tv, NULL);
 	/* Discover all the network interfaces. */
 	discover_interfaces(DISCOVER_RELAY);
 #ifdef DHCPv6
 	if (local_family == AF_INET6)
 		setup_streams();
 #endif
 	/* Set up the packet handler... */
 	if (local_family == AF_INET)
 		bootp_packet_handler = do_relay4;
 #ifdef DHCPv6
 	else
 		dhcpv6_packet_handler = do_packet6;
 #endif
 #if defined(ENABLE_GENTLE_SHUTDOWN)
 	/* no signal handlers until we deal with the side effects */
         /* install signal handlers */
 	signal(SIGINT, dhcp_signal_handler);   /* control-c */
 	signal(SIGTERM, dhcp_signal_handler);  /* kill */
 #endif
 	/* Start dispatching packets and timeouts... */
 	dispatch();
 	/* In fact dispatch() never returns. */
 	return (0);
+}
 static void
 do_relay4(struct interface_info *ip, struct dhcp_packet *packet,
 	  unsigned int length, unsigned int from_port, struct iaddr from,
 	  struct hardware *hfrom) {
 	struct server_list *sp;
 	struct sockaddr_in to;
 	struct interface_info *out;
 	struct hardware hto, *htop;
 	if (packet->hlen > sizeof packet->chaddr) {
 		log_info("Discarding packet with invalid hlen, received on "
 			 "%s interface.", ip->name);
 		return;
+	}
 	if (ip->address_count < 1 || ip->addresses == NULL) {
 		log_info("Discarding packet received on %s interface that "
 			 "has no IPv4 address assigned.", ip->name);
 		return;
+	}
 	/* Find the interface that corresponds to the giaddr
 	   in the packet. */
 	if (packet->giaddr.s_addr) {
 		for (out = interfaces; out; out = out->next) {
 			int i;
 			for (i = 0 ; i < out->address_count ; i++ ) {
 				if (out->addresses[i].s_addr ==
 				    packet->giaddr.s_addr) {
 					i = -1;
 					break;
+				}
+			}
 			if (i == -1)
 				break;
+		}
 	} else {
 		out = NULL;
+	}
 	/* If it's a bootreply, forward it to the client. */
 	if (packet->op == BOOTREPLY) {
 		if (!(ip->flags & INTERFACE_UPSTREAM)) {
 			log_debug("Dropping reply received on %s", ip->name);
 			return;
+		}
 		if (!(packet->flags & htons(BOOTP_BROADCAST)) &&
 			can_unicast_without_arp(out)) {
 			to.sin_addr = packet->yiaddr;
 			to.sin_port = remote_port;
 			/* and hardware address is not broadcast */
 			htop = &hto;
 		} else {
 			to.sin_addr.s_addr = htonl(INADDR_BROADCAST);
 			to.sin_port = remote_port;
 			/* hardware address is broadcast */
 			htop = NULL;
+		}
 		to.sin_family = AF_INET;
 #ifdef HAVE_SA_LEN
 		to.sin_len = sizeof to;
 #endif
 		memcpy(&hto.hbuf[1], packet->chaddr, packet->hlen);
 		hto.hbuf[0] = packet->htype;
 		hto.hlen = packet->hlen + 1;
 		/* Wipe out the agent relay options and, if possible, figure
 		   out which interface to use based on the contents of the
 		   option that we put on the request to which the server is
 		   replying. */
 		if (!(length =
 		      strip_relay_agent_options(ip, &out, packet, length)))
 			return;
 		if (!out) {
 			log_error("Packet to bogus giaddr %s.\n",
 			      inet_ntoa(packet->giaddr));
 			++bogus_giaddr_drops;
 			return;
+		}
 		if (send_packet(out, NULL, packet, length, out->addresses[0],
 				&to, htop) < 0) {
 			++server_packet_errors;
 		} else {
 			log_debug("Forwarded BOOTREPLY for %s to %s",
 			       print_hw_addr(packet->htype, packet->hlen,
 					      packet->chaddr),
 			       inet_ntoa(to.sin_addr));
 			++server_packets_relayed;
+		}
 		return;
+	}
 	/* If giaddr matches one of our addresses, ignore the packet -
 	   we just sent it. */
 	if (out)
 		return;
 	if (!(ip->flags & INTERFACE_DOWNSTREAM)) {
 		log_debug("Dropping request received on %s", ip->name);
 		return;
+	}
 	/* Add relay agent options if indicated.   If something goes wrong,
 	 * drop the packet.  Note this may set packet->giaddr if RFC3527
 	 * is enabled. */
 	if (!(length = add_relay_agent_options(ip, packet, length,
 					       ip->addresses[0])))
 		return;
 	/* If giaddr is not already set, Set it so the server can
 	   figure out what net it's from and so that we can later
 	   forward the response to the correct net.    If it's already
 	   set, the response will be sent directly to the relay agent
 	   that set giaddr, so we won't see it. */
 	if (!packet->giaddr.s_addr)
 		packet->giaddr = ip->addresses[0];
 	if (packet->hops < max_hop_count)
 		packet->hops = packet->hops + 1;
 	else
 		return;
 	/* Otherwise, it's a BOOTREQUEST, so forward it to all the
 	   servers. */
 	for (sp = servers; sp; sp = sp->next) {
 		if (send_packet((fallback_interface
 				 ? fallback_interface : interfaces),
 				 NULL, packet, length, ip->addresses[0],
 				 &sp->to, NULL) < 0) {
 			++client_packet_errors;
 		} else {
 			log_debug("Forwarded BOOTREQUEST for %s to %s",
 			       print_hw_addr(packet->htype, packet->hlen,
 					      packet->chaddr),
 			       inet_ntoa(sp->to.sin_addr));
 			++client_packets_relayed;
+		}
+	}
+}
 #endif /* UNIT_TEST */
 /* Strip any Relay Agent Information options from the DHCP packet
    option buffer.   If there is a circuit ID suboption, look up the
    outgoing interface based upon it. */
 int
 strip_relay_agent_options(struct interface_info *in,
 			  struct interface_info **out,
 			  struct dhcp_packet *packet,
 			  unsigned length) {
 	int is_dhcp = 0;
 	u_int8_t *op, *nextop, *sp, *max;
 	int good_agent_option = 0;
 	int status;
 	/* If we're not adding agent options to packets, we're not taking
 	   them out either. */
 	if (!add_agent_options)
 		return (length);
 	/* If there's no cookie, it's a bootp packet, so we should just
 	   forward it unchanged. */
 	if (memcmp(packet->options, DHCP_OPTIONS_COOKIE, 4))
 		return (length);
 	max = ((u_int8_t *)packet) + length;
 	sp = op = &packet->options[4];
 	while (op < max) {
 		switch(*op) {
 			/* Skip padding... */
 		      case DHO_PAD:
 			if (sp != op)
 				*sp = *op;
 			++op;
 			++sp;
 			continue;
 			/* If we see a message type, it's a DHCP packet. */
 		      case DHO_DHCP_MESSAGE_TYPE:
 			is_dhcp = 1;
 			goto skip;
 			break;
 			/* Quit immediately if we hit an End option. */
 		      case DHO_END:
 			if (sp != op)
 				*sp++ = *op++;
 			goto out;
 		      case DHO_DHCP_AGENT_OPTIONS:
 			/* We shouldn't see a relay agent option in a
 			   packet before we've seen the DHCP packet type,
 			   but if we do, we have to leave it alone. */
 			if (!is_dhcp)
 				goto skip;
 			/* Do not process an agent option if it exceeds the
 			 * buffer.  Fail this packet.
 			 */
 			nextop = op + op[1] + 2;
 			if (nextop > max)
 				return (0);
 			status = find_interface_by_agent_option(packet,
 								out, op + 2,
 								op[1]);
 			if (status == -1 && drop_agent_mismatches)
 				return (0);
 			if (status)
 				good_agent_option = 1;
 			op = nextop;
 			break;
 		      skip:
 			/* Skip over other options. */
 		      default:
 			/* Fail if processing this option will exceed the
 			 * buffer(op[1] is malformed).
 			 */
 			nextop = op + op[1] + 2;
 			if (nextop > max)
 				return (0);
 			if (sp != op) {
 				size_t mlen = op[1] + 2;
 				memmove(sp, op, mlen);
 				sp += mlen;
 				if (sp > max) {
 					return (0);
+				}
 				op = nextop;
 			} else
 				op = sp = nextop;
 			break;
+		}
+	}
       out:
 	/* If it's not a DHCP packet, we're not supposed to touch it. */
 	if (!is_dhcp)
 		return (length);
 	/* If none of the agent options we found matched, or if we didn't
 	   find any agent options, count this packet as not having any
 	   matching agent options, and if we're relying on agent options
 	   to determine the outgoing interface, drop the packet. */
 	if (!good_agent_option) {
 		++missing_agent_option;
 		if (drop_agent_mismatches)
 			return (0);
+	}
 	/* Adjust the length... */
 	if (sp != op) {
 		length = sp -((u_int8_t *)packet);
 		/* Make sure the packet isn't short(this is unlikely,
 		   but WTH) */
 		if (length < BOOTP_MIN_LEN) {
 			memset(sp, DHO_PAD, BOOTP_MIN_LEN - length);
 			length = BOOTP_MIN_LEN;
+		}
+	}
 	return (length);
+}
 /* Find an interface that matches the circuit ID specified in the
    Relay Agent Information option.   If one is found, store it through
    the pointer given; otherwise, leave the existing pointer alone.
    We actually deviate somewhat from the current specification here:
    if the option buffer is corrupt, we suggest that the caller not
    respond to this packet.  If the circuit ID doesn't match any known
    interface, we suggest that the caller to drop the packet.  Only if
    we find a circuit ID that matches an existing interface do we tell
    the caller to go ahead and process the packet. */
 int
 find_interface_by_agent_option(struct dhcp_packet *packet,
 			       struct interface_info **out,
 			       u_int8_t *buf, int len) {
 	int i = 0;
 	u_int8_t *circuit_id = 0;
 	unsigned circuit_id_len = 0;
 	struct interface_info *ip;
 	while (i < len) {
 		/* If the next agent option overflows the end of the
 		   packet, the agent option buffer is corrupt. */
 		if (i + 1 == len ||
 		    i + buf[i + 1] + 2 > len) {
 			++corrupt_agent_options;
 			return (-1);
+		}
 		switch(buf[i]) {
 			/* Remember where the circuit ID is... */
 		      case RAI_CIRCUIT_ID:
 			circuit_id = &buf[i + 2];
 			circuit_id_len = buf[i + 1];
 			i += circuit_id_len + 2;
 			continue;
 		      default:
 			i += buf[i + 1] + 2;
 			break;
+		}
+	}
 	/* If there's no circuit ID, it's not really ours, tell the caller
 	   it's no good. */
 	if (!circuit_id) {
 		++missing_circuit_id;
 		return (-1);
+	}
 	/* Scan the interface list looking for an interface whose
 	   name matches the one specified in circuit_id. */
 	for (ip = interfaces; ip; ip = ip->next) {
 		if (ip->circuit_id &&
 		    ip->circuit_id_len == circuit_id_len &&
 		    !memcmp(ip->circuit_id, circuit_id, circuit_id_len))
 			break;
+	}
 	/* If we got a match, use it. */
 	if (ip) {
 		*out = ip;
 		return (1);
+	}
 	/* If we didn't get a match, the circuit ID was bogus. */
 	++bad_circuit_id;
 	return (-1);
+}
 /*
  * Examine a packet to see if it's a candidate to have a Relay
  * Agent Information option tacked onto its tail.   If it is, tack
  * the option on.
  */
 int
 add_relay_agent_options(struct interface_info *ip, struct dhcp_packet *packet,
 			unsigned length, struct in_addr giaddr) {
 	int is_dhcp = 0, mms;
 	unsigned optlen;
 	u_int8_t *op, *nextop, *sp, *max, *end_pad = NULL;
 	int adding_link_select;
 	/* If we're not adding agent options to packets, we can skip
 	   this. */
 	if (!add_agent_options)
 		return (length);
 	/* If there's no cookie, it's a bootp packet, so we should just
 	   forward it unchanged. */
 	if (memcmp(packet->options, DHCP_OPTIONS_COOKIE, 4))
 		return (length);
 	max = ((u_int8_t *)packet) + dhcp_max_agent_option_packet_length;
 	/* Add link selection suboption if enabled and we're the first relay */
 	adding_link_select = (add_rfc3527_suboption
 			      && (packet->giaddr.s_addr == 0));
 	/* Commence processing after the cookie. */
 	sp = op = &packet->options[4];
 	while (op < max) {
 		switch(*op) {
 			/* Skip padding... */
 		      case DHO_PAD:
 			/* Remember the first pad byte so we can commandeer
 			 * padded space.
+			 *
 			 * XXX: Is this really a good idea?  Sure, we can
 			 * seemingly reduce the packet while we're looking,
 			 * but if the packet was signed by the client then
 			 * this padding is part of the checksum(RFC3118),
 			 * and its nonpresence would break authentication.
 			 */
 			if (end_pad == NULL)
 				end_pad = sp;
 			if (sp != op)
 				*sp++ = *op++;
 			else
 				sp = ++op;
 			continue;
 			/* If we see a message type, it's a DHCP packet. */
 		      case DHO_DHCP_MESSAGE_TYPE:
 			is_dhcp = 1;
 			goto skip;
 			/*
 			 * If there's a maximum message size option, we
 			 * should pay attention to it
 			 */
 		      case DHO_DHCP_MAX_MESSAGE_SIZE:
 			mms = ntohs(*(op + 2));
 			if (mms < dhcp_max_agent_option_packet_length &&
 			    mms >= DHCP_MTU_MIN)
 				max = ((u_int8_t *)packet) + mms;
 			goto skip;
 			/* Quit immediately if we hit an End option. */
 		      case DHO_END:
 			goto out;
 		      case DHO_DHCP_AGENT_OPTIONS:
 			/* We shouldn't see a relay agent option in a
 			   packet before we've seen the DHCP packet type,
 			   but if we do, we have to leave it alone. */
 			if (!is_dhcp)
 				goto skip;
 			end_pad = NULL;
 			/* There's already a Relay Agent Information option
 			   in this packet.   How embarrassing.   Decide what
 			   to do based on the mode the user specified. */
 			switch(agent_relay_mode) {
 			      case forward_and_append:
 				goto skip;
 			      case forward_untouched:
 				return (length);
 			      case discard:
 				return (0);
 			      case forward_and_replace:
 			      default:
 				break;
+			}
 			/* Skip over the agent option and start copying
 			   if we aren't copying already. */
 			op += op[1] + 2;
 			break;
 		      skip:
 			/* Skip over other options. */
 		      default:
 			/* Fail if processing this option will exceed the
 			 * buffer(op[1] is malformed).
 			 */
 			nextop = op + op[1] + 2;
 			if (nextop > max)
 				return (0);
 			end_pad = NULL;
 			if (sp != op) {
 				size_t mlen = op[1] + 2;
 				memmove(sp, op, mlen);
 				sp += mlen;
 				if (sp > max) {
 					return (0);
+				}
 				op = nextop;
 			} else
 				op = sp = nextop;
 			break;
+		}
+	}
       out:
 	/* If it's not a DHCP packet, we're not supposed to touch it. */
 	if (!is_dhcp)
 		return (length);
 	/* If the packet was padded out, we can store the agent option
 	   at the beginning of the padding. */
 	if (end_pad != NULL)
 		sp = end_pad;
 #if 0
 	/* Remember where the end of the packet was after parsing
 	   it. */
 	op = sp;
 #endif
 	/* Sanity check.  Had better not ever happen. */
 	if ((ip->circuit_id_len > 255) ||(ip->circuit_id_len < 1))
 		log_fatal("Circuit ID length %d out of range [1-255] on "
 			  "%s\n", ip->circuit_id_len, ip->name);
 	optlen = ip->circuit_id_len + 2;            /* RAI_CIRCUIT_ID + len */
 	if (ip->remote_id) {
 		if (ip->remote_id_len > 255 || ip->remote_id_len < 1)
 			log_fatal("Remote ID length %d out of range [1-255] "
 				  "on %s\n", ip->remote_id_len, ip->name);
 		optlen += ip->remote_id_len + 2;    /* RAI_REMOTE_ID + len */
+	}
 	if (adding_link_select) {
 		optlen += 6;
+	}
 #ifdef RELAY_PORT
 	if (relay_port) {
 		optlen += 2;
+	}
 #endif
 	/* We do not support relay option fragmenting(multiple options to
 	 * support an option data exceeding 255 bytes).
 	 */
 	if ((optlen < 3) ||(optlen > 255))
 		log_fatal("Total agent option length(%u) out of range "
 			   "[3 - 255] on %s\n", optlen, ip->name);
 	/*
 	 * Is there room for the option, its code+len, and DHO_END?
 	 * If not, forward without adding the option.
 	 */
 	if (max - sp >= optlen + 3) {
 		log_debug("Adding %d-byte relay agent option", optlen + 3);
 		/* Okay, cons up *our* Relay Agent Information option. */
 		*sp++ = DHO_DHCP_AGENT_OPTIONS;
 		*sp++ = optlen;
 		/* Copy in the circuit id... */
 		*sp++ = RAI_CIRCUIT_ID;
 		*sp++ = ip->circuit_id_len;
 		memcpy(sp, ip->circuit_id, ip->circuit_id_len);
 		sp += ip->circuit_id_len;
 		/* Copy in remote ID... */
 		if (ip->remote_id) {
 			*sp++ = RAI_REMOTE_ID;
 			*sp++ = ip->remote_id_len;
 			memcpy(sp, ip->remote_id, ip->remote_id_len);
 			sp += ip->remote_id_len;
+		}
 		/* RFC3527: Use the inbound packet's interface address in
 		 * the link selection suboption and set the outbound giaddr
 		 * to the uplink address. */
 		if (adding_link_select) {
 			*sp++ = RAI_LINK_SELECT;
 			*sp++ = 4u;
 			memcpy(sp, &giaddr.s_addr, 4);
 			sp += 4;
 			packet->giaddr = uplink->addresses[0];
 			log_debug ("Adding link selection suboption"
 				   " with addr: %s", inet_ntoa(giaddr));
+		}
 #ifdef RELAY_PORT
 		/* draft-ietf-dhc-relay-port-10.txt section 5.1 */
 		if (relay_port) {
 			*sp++ = RAI_RELAY_PORT;
 			*sp++ = 0u;
+		}
 #endif
 	} else {
 		++agent_option_errors;
 		log_error("No room in packet (used %d of %d) "
 			  "for %d-byte relay agent option: omitted",
 			   (int) (sp - ((u_int8_t *) packet)),
 			   (int) (max - ((u_int8_t *) packet)),
 			   optlen + 3);
+	}
 	/*
 	 * Deposit an END option unless the packet is full (shouldn't
 	 * be possible).
 	 */
 	if (sp < max)
 		*sp++ = DHO_END;
 	/* Recalculate total packet length. */
 	length = sp -((u_int8_t *)packet);
 	/* Make sure the packet isn't short(this is unlikely, but WTH) */
 	if (length < BOOTP_MIN_LEN) {
 		memset(sp, DHO_PAD, BOOTP_MIN_LEN - length);
 		return (BOOTP_MIN_LEN);
+	}
 	return (length);
+}
 #ifdef DHCPv6
 #ifndef UNIT_TEST
 #ifdef DHCPv6
 /*
  * Parse a downstream argument: [address%]interface[#index].
  */
 static struct stream_list *
 parse_downstream(char *arg) {
 	struct stream_list *dp, *up;
 	struct interface_info *ifp = NULL;
 	char *ifname, *addr, *iid;
 	isc_result_t status;
 	if (!supports_multiple_interfaces(ifp) &&
 	    (downstreams != NULL))
 		log_fatal("No support for multiple interfaces.");
 	/* Decode the argument. */
 	ifname = strchr(arg, '%');
 	if (ifname == NULL) {
 		ifname = arg;
 		addr = NULL;
 	} else {
 		*ifname++ = '\0';
 		addr = arg;
+	}
 	iid = strchr(ifname, '#');
 	if (iid != NULL) {
 		*iid++ = '\0';
+	}
 	if (strlen(ifname) >= sizeof(ifp->name)) {
 		usage("Interface name '%s' too long", ifname);
+	}
 	/* Don't declare twice. */
 	for (dp = downstreams; dp; dp = dp->next) {
 		if (strcmp(ifname, dp->ifp->name) == 0)
 			log_fatal("Down interface '%s' declared twice.",
 				  ifname);
+	}
 	/* Share with up side? */
 	for (up = upstreams; up; up = up->next) {
 		if (strcmp(ifname, up->ifp->name) == 0) {
 			log_info("parse_downstream: Interface '%s' is "
 				 "both down and up.", ifname);
 			ifp = up->ifp;
 			break;
+		}
+	}
 	/* New interface. */
 	if (ifp == NULL) {
 		status = interface_allocate(&ifp, MDL);
 		if (status != ISC_R_SUCCESS)
 			log_fatal("%s: interface_allocate: %s",
 				  arg, isc_result_totext(status));
 		strcpy(ifp->name, ifname);
 		if (interfaces) {
 			interface_reference(&ifp->next, interfaces, MDL);
 			interface_dereference(&interfaces, MDL);
+		}
 		interface_reference(&interfaces, ifp, MDL);
+	}
 	ifp->flags |= INTERFACE_REQUESTED | INTERFACE_DOWNSTREAM;
 	/* New downstream. */
 	dp = (struct stream_list *) dmalloc(sizeof(*dp), MDL);
 	if (!dp)
 		log_fatal("No memory for downstream.");
 	dp->ifp = ifp;
 	if (iid != NULL) {
 		dp->id = atoi(iid);
 	} else {
 		dp->id = -1;
+	}
 	/* !addr case handled by setup. */
 	if (addr && (inet_pton(AF_INET6, addr, &dp->link.sin6_addr) <= 0))
 		log_fatal("Bad link address '%s'", addr);
 	return dp;
+}
 /*
  * Parse an upstream argument: [address]%interface.
  */
 static struct stream_list *
 parse_upstream(char *arg) {
 	struct stream_list *up, *dp;
 	struct interface_info *ifp = NULL;
 	char *ifname, *addr;
 	isc_result_t status;
 	/* Decode the argument. */
 	ifname = strchr(arg, '%');
 	if (ifname == NULL) {
 		ifname = arg;
 		addr = All_DHCP_Servers;
 	} else {
 		*ifname++ = '\0';
 		addr = arg;
+	}
 	if (strlen(ifname) >= sizeof(ifp->name)) {
 		log_fatal("Interface name '%s' too long", ifname);
+	}
 	/* Shared up interface? */
 	for (up = upstreams; up; up = up->next) {
 		if (strcmp(ifname, up->ifp->name) == 0) {
 			ifp = up->ifp;
 			break;
+		}
+	}
 	for (dp = downstreams; dp; dp = dp->next) {
 		if (strcmp(ifname, dp->ifp->name) == 0) {
 			log_info("parse_upstream: Interface '%s' is "
 				 "both down and up.", ifname);
 			ifp = dp->ifp;
 			break;
+		}
+	}
 	/* New interface. */
 	if (ifp == NULL) {
 		status = interface_allocate(&ifp, MDL);
 		if (status != ISC_R_SUCCESS)
 			log_fatal("%s: interface_allocate: %s",
 				  arg, isc_result_totext(status));
 		strcpy(ifp->name, ifname);
 		if (interfaces) {
 			interface_reference(&ifp->next, interfaces, MDL);
 			interface_dereference(&interfaces, MDL);
+		}
 		interface_reference(&interfaces, ifp, MDL);
+	}
 	ifp->flags |= INTERFACE_REQUESTED | INTERFACE_UPSTREAM;
 	/* New upstream. */
 	up = (struct stream_list *) dmalloc(sizeof(*up), MDL);
 	if (up == NULL)
 		log_fatal("No memory for upstream.");
 	up->ifp = ifp;
 	if (inet_pton(AF_INET6, addr, &up->link.sin6_addr) <= 0)
 		log_fatal("Bad address %s", addr);
 	return up;
+}
 /*
  * Setup downstream interfaces.
  */
 static void
 setup_streams(void) {
 	struct stream_list *dp, *up;
 	int i;
 	isc_boolean_t link_is_set;
 	for (dp = downstreams; dp; dp = dp->next) {
 		/* Check interface */
 		if (dp->ifp->v6address_count == 0)
 			log_fatal("Interface '%s' has no IPv6 addresses.",
 				  dp->ifp->name);
 		/* Check/set link. */
 		if (IN6_IS_ADDR_UNSPECIFIED(&dp->link.sin6_addr))
 			link_is_set = ISC_FALSE;
 		else
 			link_is_set = ISC_TRUE;
 		for (i = 0; i < dp->ifp->v6address_count; i++) {
 			if (IN6_IS_ADDR_LINKLOCAL(&dp->ifp->v6addresses[i]))
 				continue;
 			if (!link_is_set)
 				break;
 			if (!memcmp(&dp->ifp->v6addresses[i],
 				    &dp->link.sin6_addr,
 				    sizeof(dp->link.sin6_addr)))
 				break;
+		}
 		if (i == dp->ifp->v6address_count)
 			log_fatal("Interface %s does not have global IPv6 "
 				  "address assigned.", dp->ifp->name);
 		if (!link_is_set)
 			memcpy(&dp->link.sin6_addr,
 			       &dp->ifp->v6addresses[i],
 			       sizeof(dp->link.sin6_addr));
 		/* Set interface-id. */
 		if (dp->id == -1)
 			dp->id = dp->ifp->index;
+	}
 	for (up = upstreams; up; up = up->next) {
 		up->link.sin6_port = local_port;
 		up->link.sin6_family = AF_INET6;
 #ifdef HAVE_SA_LEN
 		up->link.sin6_len = sizeof(up->link);
 #endif
 		if (up->ifp->v6address_count == 0)
 			log_fatal("Interface '%s' has no IPv6 addresses.",
 				  up->ifp->name);
 		/* RFC 3315 Sec 20 - "If the relay agent relays messages to
 		 * the All_DHCP_Servers address or other multicast addresses,
 		 * it sets the Hop Limit field to 32." */
 		if (IN6_IS_ADDR_MULTICAST(&up->link.sin6_addr)) {
 			set_multicast_hop_limit(up->ifp, HOP_COUNT_LIMIT);
+		}
+	}
+}
 /*
  * Add DHCPv6 agent options here.
  */
 static const int required_forw_opts[] = {
 	D6O_INTERFACE_ID,
 	D6O_SUBSCRIBER_ID,
 #if defined(RELAY_PORT)
 	D6O_RELAY_SOURCE_PORT,
 #endif
 	D6O_RELAY_MSG,
 };
 /*
  * Process a packet upwards, i.e., from client to server.
  */
 static void
 process_up6(struct packet *packet, struct stream_list *dp) {
 	char forw_data[65535];
 	unsigned cursor;
 	struct dhcpv6_relay_packet *relay;
 	struct option_state *opts;
 	struct stream_list *up;
 	u_int16_t relay_client_port = 0;
 	/* Check if the message should be relayed to the server. */
 	switch (packet->dhcpv6_msg_type) {
 	      case DHCPV6_SOLICIT:
 	      case DHCPV6_REQUEST:
 	      case DHCPV6_CONFIRM:
 	      case DHCPV6_RENEW:
 	      case DHCPV6_REBIND:
 	      case DHCPV6_RELEASE:
 	      case DHCPV6_DECLINE:
 	      case DHCPV6_INFORMATION_REQUEST:
 	      case DHCPV6_RELAY_FORW:
 	      case DHCPV6_LEASEQUERY:
 	      case DHCPV6_DHCPV4_QUERY:
 		log_info("Relaying %s from %s port %d going up.",
 			 dhcpv6_type_names[packet->dhcpv6_msg_type],
 			 piaddr(packet->client_addr),
 			 ntohs(packet->client_port));
 		break;
 	      case DHCPV6_ADVERTISE:
 	      case DHCPV6_REPLY:
 	      case DHCPV6_RECONFIGURE:
 	      case DHCPV6_RELAY_REPL:
 	      case DHCPV6_LEASEQUERY_REPLY:
 	      case DHCPV6_DHCPV4_RESPONSE:
 		log_info("Discarding %s from %s port %d going up.",
 			 dhcpv6_type_names[packet->dhcpv6_msg_type],
 			 piaddr(packet->client_addr),
 			 ntohs(packet->client_port));
 		return;
 	      default:
 		log_info("Unknown %d type from %s port %d going up.",
 			 packet->dhcpv6_msg_type,
 			 piaddr(packet->client_addr),
 			 ntohs(packet->client_port));
 		return;
+	}
 	/* Build the relay-forward header. */
 	relay = (struct dhcpv6_relay_packet *) forw_data;
 	cursor = offsetof(struct dhcpv6_relay_packet, options);
 	relay->msg_type = DHCPV6_RELAY_FORW;
 	if (packet->dhcpv6_msg_type == DHCPV6_RELAY_FORW) {
 		if (packet->dhcpv6_hop_count >= max_hop_count) {
 			log_info("Hop count exceeded,");
 			return;
+		}
 		relay->hop_count = packet->dhcpv6_hop_count + 1;
 		if (dp) {
 			memcpy(&relay->link_address, &dp->link.sin6_addr, 16);
 		} else {
 			/* On smart relay add: && !global. */
 			if (!use_if_id && downstreams->next) {
 				log_info("Shan't get back the interface.");
 				return;
+			}
 			memset(&relay->link_address, 0, 16);
+		}
 		if (packet->client_port != htons(547)) {
 			relay_client_port = packet->client_port;
+		}
 	} else {
 		relay->hop_count = 0;
 		if (!dp)
 			return;
 		memcpy(&relay->link_address, &dp->link.sin6_addr, 16);
+	}
 	memcpy(&relay->peer_address, packet->client_addr.iabuf, 16);
 	/* Get an option state. */
 	opts = NULL;
 	if (!option_state_allocate(&opts, MDL)) {
 		log_fatal("No memory for upwards options.");
+	}
 	/* Add an interface-id (if used). */
 	if (use_if_id) {
 		int if_id;
 		if (dp) {
 			if_id = dp->id;
 		} else if (!downstreams->next) {
 			if_id = downstreams->id;
 		} else {
 			log_info("Don't know the interface.");
 			option_state_dereference(&opts, MDL);
 			return;
+		}
 		if (!save_option_buffer(&dhcpv6_universe, opts,
 					NULL, (unsigned char *) &if_id,
 					sizeof(int),
 					D6O_INTERFACE_ID, 0)) {
 			log_error("Can't save interface-id.");
 			option_state_dereference(&opts, MDL);
 			return;
+		}
+	}
 	/* Add a subscriber-id if desired. */
 	/* This is for testing rather than general use */
 	if (dhcrelay_sub_id != NULL) {
 		if (!save_option_buffer(&dhcpv6_universe, opts, NULL,
 					(unsigned char *) dhcrelay_sub_id,
 					strlen(dhcrelay_sub_id),
 					D6O_SUBSCRIBER_ID, 0)) {
 			log_error("Can't save subsriber-id.");
 			option_state_dereference(&opts, MDL);
 			return;
+		}
+	}
 #if defined(RELAY_PORT)
 	/*
 	 * If we use a non-547 UDP source port or if we have received
 	 * from a downstream relay agent uses a non-547 port, we need
 	 * to include the RELAY-SOURCE-PORT option. The "Downstream
 	 * UDP Port" field value in the option allow us to send
 	 * relay-reply message back to the downstream relay agent
 	 * with the correct UDP source port.
         */
 	if (relay_port || relay_client_port) {
 		if (!save_option_buffer(&dhcpv6_universe, opts, NULL,
 					(unsigned char *) &relay_client_port,
 					sizeof(u_int16_t),
 					D6O_RELAY_SOURCE_PORT, 0)) {
 			log_error("Can't save relay-source-port.");
 			option_state_dereference(&opts, MDL);
 			return;
+		}
+	}
 #else
 	/* Avoid unused but set warning, */
 	(void)(relay_client_port);
 #endif
 	/* Add the relay-msg carrying the packet. */
 	if (!save_option_buffer(&dhcpv6_universe, opts,
 				NULL, (unsigned char *) packet->raw,
 				packet->packet_length,
 				D6O_RELAY_MSG, 0)) {
 		log_error("Can't save relay-msg.");
 		option_state_dereference(&opts, MDL);
 		return;
+	}
 	/* Finish the relay-forward message. */
 	cursor += store_options6(forw_data + cursor,
 				 sizeof(forw_data) - cursor,
 				 opts, packet,
 				 required_forw_opts, NULL);
 	option_state_dereference(&opts, MDL);
 	/* Send it to all upstreams. */
 	for (up = upstreams; up; up = up->next) {
 		send_packet6(up->ifp, (unsigned char *) forw_data,
 			     (size_t) cursor, &up->link);
+	}
+}
 /*
  * Process a packet downwards, i.e., from server to client.
  */
 static void
 process_down6(struct packet *packet) {
 	struct stream_list *dp;
 	struct option_cache *oc;
 	struct data_string relay_msg;
 	const struct dhcpv6_packet *msg;
 	struct data_string if_id;
 #if defined(RELAY_PORT)
 	struct data_string down_port;
 #endif
 	struct sockaddr_in6 to;
 	struct iaddr peer;
 	/* The packet must be a relay-reply message. */
 	if (packet->dhcpv6_msg_type != DHCPV6_RELAY_REPL) {
 		if (packet->dhcpv6_msg_type < dhcpv6_type_name_max)
 			log_info("Discarding %s from %s port %d going down.",
 				 dhcpv6_type_names[packet->dhcpv6_msg_type],
 				 piaddr(packet->client_addr),
 				 ntohs(packet->client_port));
 		else
 			log_info("Unknown %d type from %s port %d going down.",
 				 packet->dhcpv6_msg_type,
 				 piaddr(packet->client_addr),
 				 ntohs(packet->client_port));
 		return;
+	}
 	/* Inits. */
 	memset(&relay_msg, 0, sizeof(relay_msg));
 	memset(&if_id, 0, sizeof(if_id));
 #if defined(RELAY_PORT)
 	memset(&down_port, 0, sizeof(down_port));
 #endif
 	memset(&to, 0, sizeof(to));
 	to.sin6_family = AF_INET6;
 #ifdef HAVE_SA_LEN
 	to.sin6_len = sizeof(to);
 #endif
 	to.sin6_port = remote_port;
 	peer.len = 16;
 	/* Get the relay-msg option (carrying the message to relay). */
 	oc = lookup_option(&dhcpv6_universe, packet->options, D6O_RELAY_MSG);
 	if (oc == NULL) {
 		log_info("No relay-msg.");
 		return;
+	}
 	if (!evaluate_option_cache(&relay_msg, packet, NULL, NULL,
 				   packet->options, NULL,
 				   &global_scope, oc, MDL) ||
 	    (relay_msg.len < offsetof(struct dhcpv6_packet, options))) {
 		log_error("Can't evaluate relay-msg.");
 		goto cleanup;
+	}
 	msg = (const struct dhcpv6_packet *) relay_msg.data;
 	/* Get the interface-id (if exists) and the downstream. */
 	oc = lookup_option(&dhcpv6_universe, packet->options,
 			   D6O_INTERFACE_ID);
 	if (oc != NULL) {
 		int if_index;
 		if (!evaluate_option_cache(&if_id, packet, NULL, NULL,
 					   packet->options, NULL,
 					   &global_scope, oc, MDL) ||
 		    (if_id.len != sizeof(int))) {
 			log_info("Can't evaluate interface-id.");
 			goto cleanup;
+		}
 		memcpy(&if_index, if_id.data, sizeof(int));
 		for (dp = downstreams; dp; dp = dp->next) {
 			if (dp->id == if_index)
 				break;
+		}
 	} else {
 		if (use_if_id) {
 			/* Require an interface-id. */
 			log_info("No interface-id.");
 			goto cleanup;
+		}
 		for (dp = downstreams; dp; dp = dp->next) {
 			/* Get the first matching one. */
 			if (!memcmp(&dp->link.sin6_addr,
 				    &packet->dhcpv6_link_address,
 				    sizeof(struct in6_addr)))
 				break;
+		}
+	}
 	/* Why bother when there is no choice. */
 	if (!dp && downstreams && !downstreams->next)
 		dp = downstreams;
 	if (!dp) {
 		log_info("Can't find the down interface.");
 		goto cleanup;
+	}
 	memcpy(peer.iabuf, &packet->dhcpv6_peer_address, peer.len);
 	to.sin6_addr = packet->dhcpv6_peer_address;
 	/* Check if we should relay the carried message. */
 	switch (msg->msg_type) {
 		/* Relay-Reply of for another relay, not a client. */
 	      case DHCPV6_RELAY_REPL:
 		to.sin6_port = local_port;
 #if defined(RELAY_PORT)
 		oc = lookup_option(&dhcpv6_universe, packet->options,
 				   D6O_RELAY_SOURCE_PORT);
 		if (oc != NULL) {
 			u_int16_t down_relay_port;
 			memset(&down_port, 0, sizeof(down_port));
 			if (!evaluate_option_cache(&down_port, packet, NULL,
 						   NULL, packet->options, NULL,
 						   &global_scope, oc, MDL) ||
 			    (down_port.len != sizeof(u_int16_t))) {
 				log_info("Can't evaluate down "
 					 "relay-source-port.");
 				goto cleanup;
+			}
 			memcpy(&down_relay_port, down_port.data,
 			       sizeof(u_int16_t));
 			/*
 			 * If the down_relay_port value is non-zero,
 			 * that means our downstream relay agent uses
 			 * a non-547 UDP source port sending
 			 * relay-forw message to us. We need to use
 			 * the same UDP port sending reply back.
 			 */
 			if (down_relay_port) {
 				to.sin6_port = down_relay_port;
+			}
+		}
 #endif
 		/* Fall into: */
 	      case DHCPV6_ADVERTISE:
 	      case DHCPV6_REPLY:
 	      case DHCPV6_RECONFIGURE:
 	      case DHCPV6_RELAY_FORW:
 	      case DHCPV6_LEASEQUERY_REPLY:
 	      case DHCPV6_DHCPV4_RESPONSE:
 		log_info("Relaying %s to %s port %d down.",
 			 dhcpv6_type_names[msg->msg_type],
 			 piaddr(peer),
 			 ntohs(to.sin6_port));
 		break;
 	      case DHCPV6_SOLICIT:
 	      case DHCPV6_REQUEST:
 	      case DHCPV6_CONFIRM:
 	      case DHCPV6_RENEW:
 	      case DHCPV6_REBIND:
 	      case DHCPV6_RELEASE:
 	      case DHCPV6_DECLINE:
 	      case DHCPV6_INFORMATION_REQUEST:
 	      case DHCPV6_LEASEQUERY:
 	      case DHCPV6_DHCPV4_QUERY:
 		log_info("Discarding %s to %s port %d down.",
 			 dhcpv6_type_names[msg->msg_type],
 			 piaddr(peer),
 			 ntohs(to.sin6_port));
 		goto cleanup;
 	      default:
 		log_info("Unknown %d type to %s port %d down.",
 			 msg->msg_type,
 			 piaddr(peer),
 			 ntohs(to.sin6_port));
 		goto cleanup;
+	}
 	/* Send the message to the downstream. */
 	send_packet6(dp->ifp, (unsigned char *) relay_msg.data,
 		     (size_t) relay_msg.len, &to);
       cleanup:
 	if (relay_msg.data != NULL)
 		data_string_forget(&relay_msg, MDL);
 	if (if_id.data != NULL)
 		data_string_forget(&if_id, MDL);
+}
 #endif /* UNIT_TEST */
 /*
  * Called by the dispatch packet handler with a decoded packet.
  */
 void
 dhcpv6(struct packet *packet) {
 #ifndef UNIT_TEST
 	struct stream_list *dp;
 	/* Try all relay-replies downwards. */
 	if (packet->dhcpv6_msg_type == DHCPV6_RELAY_REPL) {
 		process_down6(packet);
 		return;
+	}
 	/* Others are candidates to go up if they come from down. */
 	for (dp = downstreams; dp; dp = dp->next) {
 		if (packet->interface != dp->ifp)
 			continue;
 		process_up6(packet, dp);
 		return;
+	}
 	/* Relay-forward could work from an unknown interface. */
 	if (packet->dhcpv6_msg_type == DHCPV6_RELAY_FORW) {
 		process_up6(packet, NULL);
 		return;
+	}
 	log_info("Can't process packet from interface '%s'.",
 		 packet->interface->name);
 #endif /* UNIT_TEST */
+}
-#endif /* DHCPv6 */
+#endif
 /* Stub routines needed for linking with DHCP libraries. */
 void
 bootp(struct packet *packet) {
 	return;
+}
 void
 dhcp(struct packet *packet) {
 	return;
+}
 #if defined(DHCPv6) && defined(DHCP4o6)
 isc_result_t dhcpv4o6_handler(omapi_object_t *h)
+{
 	return ISC_R_NOTIMPLEMENTED;
+}
 #endif
 void
 classify(struct packet *p, struct class *c) {
 	return;
+}
 int
 check_collection(struct packet *p, struct lease *l, struct collection *c) {
 	return 0;
+}
 isc_result_t
 find_class(struct class **class, const char *c1, const char *c2, int i) {
 	return ISC_R_NOTFOUND;
+}
 int
 parse_allow_deny(struct option_cache **oc, struct parse *p, int i) {
 	return 0;
+}
 isc_result_t
 dhcp_set_control_state(control_object_state_t oldstate,
 		       control_object_state_t newstate) {
 	char buf = 0;
 	if (newstate != server_shutdown)
 		return ISC_R_SUCCESS;
 	/* Log shutdown on signal. */
 	log_info("Received signal %d, initiating shutdown.", shutdown_signal);
 	if (no_pid_file == ISC_FALSE)
 		(void) unlink(path_dhcrelay_pid);
 	if (!no_daemon && dfd[0] != -1 && dfd[1] != -1) {
 		IGNORE_RET(write(dfd[1], &buf, 1));
 		(void) close(dfd[1]);
 		dfd[0] = dfd[1] = -1;
+	}
 	exit(0);
+}
 /*!
+ *
  * \brief Allocate an interface as requested with a given set of flags
+ *
  * The requested interface is allocated, its flags field is set to
  * INTERFACE_REQUESTED OR'd with the given flags,  and then added to
  * the list of interfaces.
+ *
  * \param name - name of the requested interface
  * \param flags - additional flags for the interface
+ *
  * \return Nothing
  */
 void request_v4_interface(const char* name, int flags) {
         struct interface_info *tmp = NULL;
         int len = strlen(name);
         isc_result_t status;
         if (len >= sizeof(tmp->name)) {
                 log_fatal("%s: interface name too long (is %d)", name, len);
+        }
         status = interface_allocate(&tmp, MDL);
         if (status != ISC_R_SUCCESS) {
                 log_fatal("%s: interface_allocate: %s", name,
                           isc_result_totext(status));
+        }
 	log_debug("Requesting: %s as upstream: %c downstream: %c", name,
 		  (flags & INTERFACE_UPSTREAM ? 'Y' : 'N'),
 		  (flags & INTERFACE_DOWNSTREAM ? 'Y' : 'N'));
         memcpy(tmp->name, name, len);
         interface_snorf(tmp, (INTERFACE_REQUESTED | flags));
         interface_dereference(&tmp, MDL);
+}
 #endif /* UNIT_TEST */

 @@ -1,413 +1,439 @@
-/*	$NetBSD: relay_unittests.c,v 1.2 2020/08/03 21:10:57 christos Exp $	*/
+/*	$NetBSD: relay_unittests.c,v 1.3 2021/05/26 22:52:32 christos Exp $	*/
 /*
  * Copyright (c) 2019-2020 by Internet Systems Consortium, Inc. ("ISC")
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
  *   Internet Systems Consortium, Inc.
  *   950 Charter Street
  *   Redwood City, CA 94063
  *   <info@isc.org>
  *   https://www.isc.org/
+ *
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: relay_unittests.c,v 1.2 2020/08/03 21:10:57 christos Exp $");
+__RCSID("$NetBSD: relay_unittests.c,v 1.3 2021/05/26 22:52:32 christos Exp $");
 #include "config.h"
 #include <atf-c.h>
 #include <omapip/omapip_p.h>
 #include "dhcpd.h"
 /* @brief Externs for dhcrelay.c functions under test */
 extern int add_agent_options;
 extern int add_relay_agent_options(struct interface_info *,
                                    struct dhcp_packet *, unsigned,
                                    struct in_addr);
 extern int find_interface_by_agent_option(struct dhcp_packet *,
                                           struct interface_info **,
                                           u_int8_t *, int);
 extern int strip_relay_agent_options(struct interface_info *,
                                      struct interface_info **,
                                      struct dhcp_packet *, unsigned);
 /* @brief Add the given option data to a DHCPv4 packet
+*
 * It first fills the packet.options buffer with the given pad character.
 * Next it copies the DHCP magic cookie value into the beginning of the
 * options buffer. Finally it appends the given data after the cookie.
+*
 * @param packet pointer to the packet
 * @param data pointer to the option data to copy into the packet's options
 * buffer
 * @param len length of the option data to copy
 * @param pad byte value with which to initialize the packet's options buffer
+*
 * @return returns the new length of the packet
 */
 unsigned set_packet_options(struct dhcp_packet *packet,
                             unsigned char* data, unsigned len,
                             unsigned char pad) {
     unsigned new_len;
     memset(packet->options, pad, DHCP_MAX_OPTION_LEN);
     // Add the COOKIE
     new_len = 4;
     memcpy(packet->options, DHCP_OPTIONS_COOKIE, new_len);
     new_len += len;
     if (new_len > DHCP_MAX_OPTION_LEN) {
         return(0);
+    }
     memcpy(&packet->options[4], data, len);
     return(new_len + DHCP_FIXED_NON_UDP);
+}
 /* @brief Checks two sets of option data for equalit
+*
 * It constructs the expected options content by creating an options buffer
 * filled with the pad value.  Next it copies the DHCP magic cookie value
 * into the beginning of the buffer and then appends the expected data after
 * the cookie.  It the compares this buffer to the actual buffer passed in
 * for equality and returns the result.
+*
 * @param actual_options pointer to the packet::options to be checked
 * @param expected_data pointer to the expected options data (everything after
 * the DHCP cookie)
 * @param data_len length of the expected options data
 * @param pad byte value with which to initialize the packet's options buffer
+*
 * @return zero it the sets of data match, non-zero otherwise
 */
 int check_with_pad(unsigned char* actual_options,
                    unsigned char *expected_data,
                    unsigned data_len, unsigned char pad) {
     unsigned char exp_options[DHCP_MAX_OPTION_LEN];
     unsigned new_len;
     memset(exp_options, pad, DHCP_MAX_OPTION_LEN);
     new_len = 4;
     memcpy(exp_options, DHCP_OPTIONS_COOKIE, new_len);
     new_len += data_len;
     if (new_len > DHCP_MAX_OPTION_LEN) {
         return(-1);
+    }
     memcpy(&exp_options[4], expected_data, data_len);
     return (memcmp(actual_options, exp_options, DHCP_MAX_OPTION_LEN));
+}
 ATF_TC(strip_relay_agent_options_test);
 ATF_TC_HEAD(strip_relay_agent_options_test, tc) {
     atf_tc_set_md_var(tc, "descr", "tests strip_relay-agent_options");
+}
 /* This Test exercises strip_relay_agent_options() function */
 ATF_TC_BODY(strip_relay_agent_options_test, tc) {
     struct interface_info ifaces;
     struct interface_info *matched;
     struct dhcp_packet packet;
     unsigned len;
     int ret;
     memset(&ifaces, 0x0, sizeof(ifaces));
     matched = 0;
     memset(&packet, 0x0, sizeof(packet));
     len = 0;
     /* Make sure an empty packet is harmless. We set add_agent_options = 1
      * to avoid early return when it's 0.  */
     add_agent_options = 1;
     ret = strip_relay_agent_options(&ifaces, &matched, &packet, len);
     if (ret != 0) {
        atf_tc_fail("empty packet failed");
+    }
+    {
         /*
          * Uses valid input option data to verify that:
          * - When add_agent_options is false, the output option data is the
          *   the same as the input option data (i.e. nothing removed)
          * - When add_agent_options is true, 0 length relay agent option has
          *   been removed from the output option data
          * - When add_agent_options is true, a relay agent option has
          *   been removed from the output option data
+         *
         */
         unsigned char input_data[] = {
 x35, 0x00,                   /* DHCP_TYPE = DISCOVER */
 x52, 0x08, 0x01, 0x06, 0x65, /* Relay Agent Option, len = 8 */
 x6e, 0x70, 0x30, 0x73, 0x4f,
 x42, 0x02, 0x00, 0x10,       /* Opt 0x42, len = 2 */
 x43, 0x00                    /* Opt 0x43, len = 0 */
         };
         unsigned char input_data2[] = {
 x35, 0x00,                   /* DHCP_TYPE = DISCOVER */
 x52, 0x00,                   /* Relay Agent Option, len = 0 */
 x42, 0x02, 0x00, 0x10,       /* Opt 0x42, len = 2 */
 x43, 0x00                    /* Opt 0x43, len = 0 */
         };
         unsigned char output_data[] = {
 x35, 0x00,                   /* DHCP_TYPE = DISCOVER */
 x42, 0x02, 0x00, 0x10,       /* Opt 0x42, len = 2 */
 x43, 0x00                    /* Opt 0x43, len = 0 */
         };
         unsigned char pad = 0x0;
         len = set_packet_options(&packet, input_data, sizeof(input_data), pad);
         if (len == 0) {
             atf_tc_fail("input_data: set_packet_options failed");
+        }
         /* When add_agent_options = 0, no change should occur */
         add_agent_options = 0;
         ret = strip_relay_agent_options(&ifaces, &matched, &packet, len);
         if (ret != len) {
             atf_tc_fail("expected unchanged len %d, returned %d", len, ret);
+        }
         if (check_with_pad(packet.options, input_data, sizeof(input_data),
                            pad) != 0) {
             atf_tc_fail("expected unchanged data, does not match");
+        }
         /* When add_agent_options = 1, it should remove the eight byte
          * relay agent option. */
         add_agent_options = 1;
         /* Beause the inbound option data is less than the BOOTP_MIN_LEN,
          * the output data  should get padded out to BOOTP_MIN_LEN
          * padded out to BOOTP_MIN_LEN */
         ret = strip_relay_agent_options(&ifaces, &matched, &packet, len);
         if (ret != BOOTP_MIN_LEN) {
             atf_tc_fail("input_data: len of %d, returned %d",
                         BOOTP_MIN_LEN, ret);
+        }
         if (check_with_pad(packet.options, output_data, sizeof(output_data),
                            pad) != 0) {
             atf_tc_fail("input_data: expected data does not match");
+        }
         /* Now let's repeat it with a relay agent option 0 bytes in length. */
         len = set_packet_options(&packet, input_data2, sizeof(input_data2), pad);
         if (len == 0) {
             atf_tc_fail("input_data2 set_packet_options failed");
+        }
         /* Because the inbound option data is less than the BOOTP_MIN_LEN,
          * the output data should get padded out to BOOTP_MIN_LEN
          * padded out to BOOTP_MIN_LEN */
         ret = strip_relay_agent_options(&ifaces, &matched, &packet, len);
         if (ret != BOOTP_MIN_LEN) {
             atf_tc_fail("input_data2: len of %d, returned %d",
                         BOOTP_MIN_LEN, ret);
+        }
         if (check_with_pad(packet.options, output_data, sizeof(output_data),
                            pad) != 0) {
             atf_tc_fail("input_data2: expected output does not match");
+        }
+    }
+    {
         /* Verify that oversized packet filled with long options does not
          * cause overrun */
         /* We borrowed this union from discover.c:got_one() */
         union {
                 unsigned char packbuf [4095]; /* Packet input buffer.
                                                * Must be as large as largest
                                                * possible MTU. */
                 struct dhcp_packet packet;
         } u;
         unsigned char input_data[] = {
 x35, 0x00,             /* DHCP_TYPE = DISCOVER        */
 x52, 0x00,             /* Relay Agent Option, len = 0 */
 x42, 0x02, 0x00, 0x10, /* Opt 0x42, len = 2           */
 x43, 0x00              /* Opt 0x43, len = 0           */
         };
         /* We'll pad it 0xFE, that way wherever we hit for "length" we'll
          * have length of 254. Increasing the odds we'll push over the end. */
         unsigned char pad = 0xFE;
         memset(u.packbuf, pad, 4095);
         len = set_packet_options(&u.packet, input_data, sizeof(input_data), pad);
         if (len == 0) {
             atf_tc_fail("overrun: set_packet_options failed");
+        }
         /* Enable option stripping by setting add_agent_options = 1 */
         add_agent_options = 1;
         /* strip_relay_agent_options() should detect the overrun and return 0 */
         ret = strip_relay_agent_options(&ifaces, &matched, &u.packet, 4095);
         if (ret != 0) {
             atf_tc_fail("overrun expected return len = 0, we got %d", ret);
+        }
+    }
+}
 ATF_TC(add_relay_agent_options_test);
 ATF_TC_HEAD(add_relay_agent_options_test, tc) {
     atf_tc_set_md_var(tc, "descr", "tests agent_relay-agent_options");
+}
 /* This Test exercises add_relay_agent_options() function */
 ATF_TC_BODY(add_relay_agent_options_test, tc) {
     struct interface_info ifc;
     struct dhcp_packet packet;
     unsigned len;
     int ret;
     struct in_addr giaddr;
     giaddr.s_addr = inet_addr("192.0.1.1");
     u_int8_t circuit_id[] = { 0x01,0x02,0x03,0x04,0x05,0x06 };
     u_int8_t remote_id[] = { 0x11,0x22,0x33,0x44,0x55,0x66 };
     memset(&ifc, 0x0, sizeof(ifc));
     ifc.circuit_id = circuit_id;
     ifc.circuit_id_len = sizeof(circuit_id);
     ifc.remote_id = remote_id;
     ifc.remote_id_len = sizeof(remote_id);
     memset(&packet, 0x0, sizeof(packet));
     len = 0;
     /* Make sure an empty packet is harmless */
     ret = add_relay_agent_options(&ifc, &packet, len, giaddr);
     if (ret != 0) {
        atf_tc_fail("empty packet failed");
+    }
+    {
         /*
          * Uses valid input option data to verify that:
          * - When add_agent_options is false, the output option data is the
          *   the same as the input option data (i.e. nothing removed)
          * - When add_agent_options is true, the relay agent option has
          *   been removed from the output option data
          * - When add_agent_options is true, 0 length relay agent option has
          *   been removed from the output option data
+         *
         */
         unsigned char input_data[] = {
 x35, 0x00,                   /* DHCP_TYPE = DISCOVER */
 x52, 0x08, 0x01, 0x06, 0x65, /* Relay Agent Option, len = 8 */
 x6e, 0x70, 0x30, 0x73, 0x4f,
 x42, 0x02, 0x00, 0x10,       /* Opt 0x42, len = 2 */
 x43, 0x00                    /* Opt 0x43, len = 0 */
         };
         unsigned char input_data2[] = {
 x35, 0x00,                   /* DHCP_TYPE = DISCOVER */
 x52, 0x00,                   /* Relay Agent Option, len = 0 */
 x42, 0x02, 0x00, 0x10,       /* Opt 0x42, len = 2 */
 x43, 0x00                    /* Opt 0x43, len = 0 */
         };
         unsigned char output_data[] = {
 x35, 0x00,                   /* DHCP_TYPE = DISCOVER */
 x42, 0x02, 0x00, 0x10,       /* Opt 0x42, len = 2 */
 x43, 0x00,                   /* Opt 0x43, len = 0 */
 x52, 0x10,                   /* Relay Agent, len = 16 */
 x1, 0x6,                     /* Circuit id, len = 6 */
 x1, 0x2, 0x3, 0x4, 0x5, 0x6,
 x2, 0x6,                     /* Remete id, len = 6 */
 x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xff
         };
         unsigned char pad = 0x0;
         len = set_packet_options(&packet, input_data, sizeof(input_data), pad);
         if (len == 0) {
             atf_tc_fail("input_data: set_packet_options failed");
+        }
         /* When add_agent_options = 0, no change should occur */
         add_agent_options = 0;
         ret = add_relay_agent_options(&ifc, &packet, len, giaddr);
         if (ret != len) {
             atf_tc_fail("expected unchanged len %d, returned %d", len, ret);
+        }
         if (check_with_pad(packet.options, input_data, sizeof(input_data),
                            pad) != 0) {
             atf_tc_fail("expected unchanged data, does not match");
+        }
         /* When add_agent_options = 1, it should remove the eight byte
          * relay agent option. */
         add_agent_options = 1;
         /* Because the inbound option data is less than the BOOTP_MIN_LEN,
          * the output data should get padded out to BOOTP_MIN_LEN
          * padded out to BOOTP_MIN_LEN */
         ret = add_relay_agent_options(&ifc, &packet, len, giaddr);
         if (ret != BOOTP_MIN_LEN) {
             atf_tc_fail("input_data: len of %d, returned %d",
                         BOOTP_MIN_LEN, ret);
+        }
         if (check_with_pad(packet.options, output_data, sizeof(output_data),
                            pad) != 0) {
             atf_tc_fail("input_data: expected data does not match");
+        }
         /* Now let's repeat it with a relay agent option 0 bytes in length. */
         len = set_packet_options(&packet, input_data2, sizeof(input_data2),
                                  pad);
         if (len == 0) {
             atf_tc_fail("input_data2 set_packet_options failed");
+        }
         /* Because the inbound option data is less than the BOOTP_MIN_LEN,
          * the output data should get padded out to BOOTP_MIN_LEN
          * padded out to BOOTP_MIN_LEN */
         ret = add_relay_agent_options(&ifc, &packet, len, giaddr);
         if (ret != BOOTP_MIN_LEN) {
             atf_tc_fail("input_data2: len of %d, returned %d",
                         BOOTP_MIN_LEN, ret);
+        }
         if (check_with_pad(packet.options, output_data, sizeof(output_data),
                            pad) != 0) {
             atf_tc_fail("input_data2: expected output does not match");
+        }
+    }
+}
 ATF_TP_ADD_TCS(tp) {
     ATF_TP_ADD_TC(tp, strip_relay_agent_options_test);
     ATF_TP_ADD_TC(tp, add_relay_agent_options_test);
     return (atf_no_error());
+}
 /* Below are dummy function definitions to satisfy "required" symbols */
 isc_result_t find_class (struct class **c, const char *s,
                          const char *file, int line) {
 	return 0;
+}
 int check_collection (struct packet *packet, struct lease *lease,
                       struct collection *collection) {
 	return 0;
+}
 void classify (struct packet *packet, struct class *class){}
 void bootp(struct packet *packet){}
 void dhcp(struct packet *packet){}
 void dhcpv6(struct packet *packet){}
 int parse_allow_deny (struct option_cache **oc, struct parse *cfile,
                       int flag) {
     return 0;
+}
 isc_result_t dhcp_set_control_state (control_object_state_t oldstate,
                                      control_object_state_t newstate) {
     return (ISC_R_SUCCESS);
+}

 @@ -1,1228 +1,1228 @@
-/*	$NetBSD: dhcpd.c,v 1.3 2020/08/03 21:10:57 christos Exp $	*/
+/*	$NetBSD: dhcpd.c,v 1.4 2021/05/26 22:52:32 christos Exp $	*/
 /* dhcpd.c
    DHCP Server Daemon. */
 /*
- * Copyright (c) 2004-2020 by Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (c) 2004-2021 by Internet Systems Consortium, Inc. ("ISC")
  * Copyright (c) 1996-2003 by Internet Software Consortium
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
  *   Internet Systems Consortium, Inc.
  *   950 Charter Street
  *   Redwood City, CA 94063
  *   <info@isc.org>
  *   https://www.isc.org/
+ *
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: dhcpd.c,v 1.3 2020/08/03 21:10:57 christos Exp $");
+__RCSID("$NetBSD: dhcpd.c,v 1.4 2021/05/26 22:52:32 christos Exp $");
 static const char copyright[] =
-"Copyright 2004-2020 Internet Systems Consortium.";
+"Copyright 2004-2021 Internet Systems Consortium.";
 static const char arr [] = "All rights reserved.";
 static const char message [] = "Internet Systems Consortium DHCP Server";
 static const char url [] =
 "For info, please visit https://www.isc.org/software/dhcp/";
 #include "dhcpd.h"
 #include <omapip/omapip_p.h>
 #include <syslog.h>
 #include <signal.h>
 #include <errno.h>
 #include <limits.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <isc/file.h>
 #if defined (PARANOIA)
 #  include <sys/types.h>
 #  include <unistd.h>
 #  include <pwd.h>
 /* get around the ISC declaration of group */
 #  define group real_group
 #    include <grp.h>
 #  undef group
 /* global values so db.c can look at them */
 uid_t set_uid = 0;
 gid_t set_gid = 0;
 #endif /* PARANOIA */
 struct class unknown_class;
 struct class known_class;
 struct iaddr server_identifier;
 int server_identifier_matched;
 #if defined (NSUPDATE)
 /* This stuff is always executed to figure the default values for certain
    ddns variables. */
 char std_nsupdate [] = "						    \n\
 option server.ddns-hostname =						    \n\
   pick (option fqdn.hostname, option host-name, config-option host-name);   \n\
 option server.ddns-domainname =	config-option domain-name;		    \n\
 option server.ddns-rev-domainname = \"in-addr.arpa.\";";
 /* Stores configured DDNS conflict detection flags */
 u_int16_t ddns_conflict_mask;
 #endif /* NSUPDATE */
 int ddns_update_style;
 int dont_use_fsync = 0; /* 0 = default, use fsync, 1 = don't use fsync */
 int server_id_check = 0; /* 0 = default, don't check server id, 1 = do check */
 #ifdef DHCPv6
 int prefix_length_mode = PLM_PREFER;
 int do_release_on_roam = 0; /* 0 = default, do not release v6 leases on roam */
 #endif
 #ifdef EUI_64
 int persist_eui64 = 1; /* 1 = write EUI64 leases to disk, 0 = don't */
 #endif
 int authoring_byte_order = 0; /* 0 = not set */
 int lease_id_format = TOKEN_OCTAL; /* octal by default */
 u_int32_t abandon_lease_time = DEFAULT_ABANDON_LEASE_TIME;
 const char *path_dhcpd_conf = _PATH_DHCPD_CONF;
 const char *path_dhcpd_db = _PATH_DHCPD_DB;
 const char *path_dhcpd_pid = _PATH_DHCPD_PID;
 /* False (default) => we write and use a pid file */
 isc_boolean_t no_pid_file = ISC_FALSE;
 int dhcp_max_agent_option_packet_length = DHCP_MTU_MAX;
 static omapi_auth_key_t *omapi_key = (omapi_auth_key_t *)0;
 int omapi_port;
 #if defined (TRACING)
 trace_type_t *trace_srandom;
 #endif
 uint16_t local_port = 0;
 uint16_t remote_port = 0;
 libdhcp_callbacks_t dhcpd_callbacks = {
 	&local_port,
 	&remote_port,
 	classify,
 	check_collection,
 	dhcp,
 #ifdef DHCPv6
 	dhcpv6,
 #endif /* DHCPv6 */
 	bootp,
 	find_class,
 	parse_allow_deny,
 	dhcp_set_control_state,
 };
 char *progname;
 static isc_result_t verify_addr (omapi_object_t *l, omapi_addr_t *addr) {
 	return ISC_R_SUCCESS;
+}
 static isc_result_t verify_auth (omapi_object_t *p, omapi_auth_key_t *a) {
 	if (a != omapi_key)
 		return DHCP_R_INVALIDKEY;
 	return ISC_R_SUCCESS;
+}
 static void omapi_listener_start (void *foo)
+{
 	omapi_object_t *listener;
 	isc_result_t result;
 	struct timeval tv;
 	listener = (omapi_object_t *)0;
 	result = omapi_generic_new (&listener, MDL);
 	if (result != ISC_R_SUCCESS)
 		log_fatal ("Can't allocate new generic object: %s",
 			   isc_result_totext (result));
 	result = omapi_protocol_listen (listener,
 					(unsigned)omapi_port, 1);
 	if (result == ISC_R_SUCCESS && omapi_key)
 		result = omapi_protocol_configure_security
 			(listener, verify_addr, verify_auth);
 	if (result != ISC_R_SUCCESS) {
 		log_error ("Can't start OMAPI protocol: %s",
 			   isc_result_totext (result));
 		tv.tv_sec = cur_tv.tv_sec + 5;
 		tv.tv_usec = cur_tv.tv_usec;
 		add_timeout (&tv, omapi_listener_start, 0, 0, 0);
+	}
 	omapi_object_dereference (&listener, MDL);
+}
 #ifndef UNIT_TEST
 #define DHCPD_USAGE0 \
 "[-p <UDP port #>] [-f] [-d] [-q] [-t|-T]\n"
 #ifdef DHCPv6
 #ifdef DHCP4o6
 #define DHCPD_USAGE1 \
 "             [-4|-6] [-4o6 <port>]\n" \
 "             [-cf config-file] [-lf lease-file]\n"
 #else /* DHCP4o6 */
 #define DHCPD_USAGE1 \
 "             [-4|-6] [-cf config-file] [-lf lease-file]\n"
 #endif /* DHCP4o6 */
 #else /* !DHCPv6 */
 #define DHCPD_USAGE1 \
 "             [-cf config-file] [-lf lease-file]\n"
 #endif /* DHCPv6 */
 #if defined (PARANOIA)
 #define DHCPD_USAGEP \
 "             [-user user] [-group group] [-chroot dir]\n"
 #else
 #define DHCPD_USAGEP ""
 #endif /* PARANOIA */
 #if defined (TRACING)
 #define DHCPD_USAGET \
 "             [-tf trace-output-file]\n" \
 "             [-play trace-input-file]\n"
 #else
 #define DHCPD_USAGET ""
 #endif /* TRACING */
 #define DHCPD_USAGEC \
 "             [-pf pid-file] [--no-pid] [-s server]\n" \
 "             [if0 [...ifN]]"
 #define DHCPD_USAGEH "{--version|--help|-h}"
 /*!
+ *
  * \brief Print the generic usage message
+ *
  * If the user has provided an incorrect command line print out
  * the description of the command line.  The arguments provide
  * a way for the caller to request more specific information about
  * the error be printed as well.  Mostly this will be that some
  * comamnd doesn't include its argument.
+ *
  * \param sfmt - The basic string and format for the specific error
  * \param sarg - Generally the offending argument from the comamnd line.
+ *
  * \return Nothing
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: dhcpd.c,v 1.3 2020/08/03 21:10:57 christos Exp $");
+__RCSID("$NetBSD: dhcpd.c,v 1.4 2021/05/26 22:52:32 christos Exp $");
 static char use_noarg[] = "No argument for command: %s ";
 static void
 usage(const char *sfmt, const char *sarg) {
 	log_info("%s %s", message, PACKAGE_VERSION);
 	log_info(copyright);
 	log_info(arr);
 	log_info(url);
 	/* If desired print out the specific error message */
 #ifdef PRINT_SPECIFIC_CL_ERRORS
 	if (sfmt != NULL)
 		log_error(sfmt, sarg);
 #endif
 	log_fatal("Usage: %s %s%s%s%s%s\n       %s %s",
 		  isc_file_basename(progname),
 		  DHCPD_USAGE0,
 		  DHCPD_USAGE1,
 		  DHCPD_USAGEP,
 		  DHCPD_USAGET,
 		  DHCPD_USAGEC,
 		  isc_file_basename(progname),
 		  DHCPD_USAGEH);
+}
 /* Note: If we add unit tests to test setup_chroot it will
  * need to be moved to be outside the ifndef UNIT_TEST block.
  */
 #if defined (PARANOIA)
 /* to be used in one of two possible scenarios */
 static void setup_chroot (char *chroot_dir) {
   if (geteuid())
     log_fatal ("you must be root to use chroot");
   if (chroot(chroot_dir)) {
     log_fatal ("chroot(\"%s\"): %m", chroot_dir);
+  }
   if (chdir ("/")) {
     /* probably permission denied */
     log_fatal ("chdir(\"/\"): %m");
+  }
+}
 #endif /* PARANOIA */
 int
 main(int argc, char **argv) {
 	int fd;
 	int i, status;
 	struct servent *ent;
 	char *s;
 	int cftest = 0;
 	int lftest = 0;
 	int pid;
 	char pbuf [20];
 #ifndef DEBUG
 	int daemon = 1;
 	int dfd[2] = { -1, -1 };
 #endif
 	int quiet = 0;
 	char *server = (char *)0;
 	isc_result_t result;
 	unsigned seed;
 	struct interface_info *ip;
 #if defined (NSUPDATE)
 	struct parse *parse;
 	int lose;
 #endif
 	int have_dhcpd_conf = 0;
 	int have_dhcpd_db = 0;
 	int have_dhcpd_pid = 0;
 #ifdef DHCPv6
 	int local_family_set = 0;
 #ifdef DHCP4o6
 	u_int16_t dhcp4o6_port = 0;
 #endif /* DHCP4o6 */
 #endif /* DHCPv6 */
 #if defined (TRACING)
 	char *traceinfile = (char *)0;
 	char *traceoutfile = (char *)0;
 #endif
 #if defined (PARANOIA)
 	char *set_user   = 0;
 	char *set_group  = 0;
 	char *set_chroot = 0;
 #endif /* PARANOIA */
 	libdhcp_callbacks_register(&dhcpd_callbacks);
 #ifdef OLD_LOG_NAME
 	progname = "dhcpd";
 #else
 	progname = argv[0];
 #endif
         /* Make sure that file descriptors 0 (stdin), 1, (stdout), and
 (stderr) are open. To do this, we assume that when we
            open a file the lowest available file descriptor is used. */
         fd = open("/dev/null", O_RDWR);
         if (fd == 0)
                 fd = open("/dev/null", O_RDWR);
         if (fd == 1)
                 fd = open("/dev/null", O_RDWR);
         if (fd == 2)
                 log_perror = 0; /* No sense logging to /dev/null. */
         else if (fd != -1)
                 close(fd);
 	/* Parse arguments changing daemon */
 	for (i = 1; i < argc; i++) {
 		if (!strcmp (argv [i], "-f")) {
 #ifndef DEBUG
 			daemon = 0;
 #endif
 		} else if (!strcmp (argv [i], "-d")) {
 #ifndef DEBUG
 			daemon = 0;
 #endif
 		} else if (!strcmp (argv [i], "-t")) {
 #ifndef DEBUG
 			daemon = 0;
 #endif
 		} else if (!strcmp (argv [i], "-T")) {
 #ifndef DEBUG
 			daemon = 0;
 #endif
 		} else if (!strcmp (argv [i], "--version")) {
 			const char vstring[] = "isc-dhcpd-";
 			IGNORE_RET(write(STDERR_FILENO, vstring,
 					 strlen(vstring)));
 			IGNORE_RET(write(STDERR_FILENO,
 					 PACKAGE_VERSION,
 					 strlen(PACKAGE_VERSION)));
 			IGNORE_RET(write(STDERR_FILENO, "\n", 1));
 			exit (0);
 		} else if (!strcmp(argv[i], "--help") ||
 			   !strcmp(argv[i], "-h")) {
 			const char *pname = isc_file_basename(progname);
 			IGNORE_RET(write(STDERR_FILENO, "Usage: ", 7));
 			IGNORE_RET(write(STDERR_FILENO, pname, strlen(pname)));
 			IGNORE_RET(write(STDERR_FILENO, " ", 1));
 			IGNORE_RET(write(STDERR_FILENO, DHCPD_USAGE0,
 					 strlen(DHCPD_USAGE0)));
 			IGNORE_RET(write(STDERR_FILENO, DHCPD_USAGE1,
 					 strlen(DHCPD_USAGE1)));
 #if defined (PARANOIA)
 			IGNORE_RET(write(STDERR_FILENO, DHCPD_USAGEP,
 					 strlen(DHCPD_USAGEP)));
 #endif
 #if defined (TRACING)
 			IGNORE_RET(write(STDERR_FILENO, DHCPD_USAGET,
 					 strlen(DHCPD_USAGET)));
 #endif
 			IGNORE_RET(write(STDERR_FILENO, DHCPD_USAGEC,
 					 strlen(DHCPD_USAGEC)));
 			IGNORE_RET(write(STDERR_FILENO, "\n", 1));
 			IGNORE_RET(write(STDERR_FILENO, "       ", 7));
 			IGNORE_RET(write(STDERR_FILENO, pname, strlen(pname)));
 			IGNORE_RET(write(STDERR_FILENO, " ", 1));
 			IGNORE_RET(write(STDERR_FILENO, DHCPD_USAGEH,
 					 strlen(DHCPD_USAGEH)));
 			IGNORE_RET(write(STDERR_FILENO, "\n", 1));
 			exit(0);
 #ifdef TRACING
 		} else if (!strcmp (argv [i], "-play")) {
 #ifndef DEBUG
 			daemon = 0;
 #endif
 #endif
+		}
+	}
 #ifndef DEBUG
 	/* When not forbidden prepare to become a daemon */
 	if (daemon) {
 		if (pipe(dfd) == -1)
 			log_fatal("Can't get pipe: %m");
 		if ((pid = fork ()) < 0)
 			log_fatal("Can't fork daemon: %m");
 		if (pid != 0) {
 			/* Parent: wait for the child to start */
 			int n;
 			(void) close(dfd[1]);
 			do {
 				char buf;
 				n = read(dfd[0], &buf, 1);
 				if (n == 1)
 					_exit((int)buf);
 			} while (n == -1 && errno == EINTR);
 			_exit(1);
+		}
 		/* Child */
 		(void) close(dfd[0]);
+	}
 #endif
 	/* Set up the isc and dns library managers */
 	status = dhcp_context_create(DHCP_CONTEXT_PRE_DB,
 				     NULL, NULL);
 	if (status != ISC_R_SUCCESS)
 		log_fatal("Can't initialize context: %s",
 			  isc_result_totext(status));
 	/* Set up the client classification system. */
 	classification_setup ();
 	/* Initialize the omapi system. */
 	result = omapi_init ();
 	if (result != ISC_R_SUCCESS)
 		log_fatal ("Can't initialize OMAPI: %s",
 			   isc_result_totext (result));
 	/* Set up the OMAPI wrappers for common objects. */
 	dhcp_db_objects_setup ();
 	/* Set up the OMAPI wrappers for various server database internal
 	   objects. */
 	dhcp_common_objects_setup ();
 	/* Initially, log errors to stderr as well as to syslogd. */
 	openlog (isc_file_basename(progname),
 		 DHCP_LOG_OPTIONS, DHCPD_LOG_FACILITY);
 	for (i = 1; i < argc; i++) {
 		if (!strcmp (argv [i], "-p")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			local_port = validate_port (argv [i]);
 			log_debug ("binding to user-specified port %d",
 			       ntohs (local_port));
 		} else if (!strcmp (argv [i], "-f")) {
 #ifndef DEBUG
 			/* daemon = 0; */
 #endif
 		} else if (!strcmp (argv [i], "-d")) {
 #ifndef DEBUG
 			/* daemon = 0; */
 #endif
 			log_perror = -1;
 		} else if (!strcmp (argv [i], "-s")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			server = argv [i];
 #if defined (PARANOIA)
 		} else if (!strcmp (argv [i], "-user")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			set_user = argv [i];
 		} else if (!strcmp (argv [i], "-group")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			set_group = argv [i];
 		} else if (!strcmp (argv [i], "-chroot")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			set_chroot = argv [i];
 #endif /* PARANOIA */
 		} else if (!strcmp (argv [i], "-cf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhcpd_conf = argv [i];
 			have_dhcpd_conf = 1;
 		} else if (!strcmp (argv [i], "-lf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhcpd_db = argv [i];
 			have_dhcpd_db = 1;
 		} else if (!strcmp (argv [i], "-pf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			path_dhcpd_pid = argv [i];
 			have_dhcpd_pid = 1;
 		} else if (!strcmp(argv[i], "--no-pid")) {
 			no_pid_file = ISC_TRUE;
                 } else if (!strcmp (argv [i], "-t")) {
 			/* test configurations only */
 #ifndef DEBUG
 			/* daemon = 0; */
 #endif
 			cftest = 1;
 			log_perror = -1;
                 } else if (!strcmp (argv [i], "-T")) {
 			/* test configurations and lease file only */
 #ifndef DEBUG
 			/* daemon = 0; */
 #endif
 			cftest = 1;
 			lftest = 1;
 			log_perror = -1;
 		} else if (!strcmp (argv [i], "-q")) {
 			quiet = 1;
 			quiet_interface_discovery = 1;
 #ifdef DHCPv6
 		} else if (!strcmp(argv[i], "-4")) {
 			if (local_family_set && (local_family != AF_INET)) {
 				log_fatal("Server cannot run in both IPv4 and "
 					  "IPv6 mode at the same time.");
+			}
 			local_family = AF_INET;
 			local_family_set = 1;
 		} else if (!strcmp(argv[i], "-6")) {
 			if (local_family_set && (local_family != AF_INET6)) {
 				log_fatal("Server cannot run in both IPv4 and "
 					  "IPv6 mode at the same time.");
+			}
 			local_family = AF_INET6;
 			local_family_set = 1;
 #ifdef DHCP4o6
 		} else if (!strcmp(argv[i], "-4o6")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			dhcp4o6_port = validate_port_pair(argv[i]);
 			log_debug("DHCPv4 over DHCPv6 over ::1 port %d and %d",
 				  ntohs(dhcp4o6_port),
 				  ntohs(dhcp4o6_port) + 1);
 			dhcpv4_over_dhcpv6 = 1;
 #endif /* DHCP4o6 */
 #endif /* DHCPv6 */
 #if defined (TRACING)
 		} else if (!strcmp (argv [i], "-tf")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			traceoutfile = argv [i];
 		} else if (!strcmp (argv [i], "-play")) {
 			if (++i == argc)
 				usage(use_noarg, argv[i-1]);
 			traceinfile = argv [i];
 			trace_replay_init ();
 #endif /* TRACING */
 		} else if (argv [i][0] == '-') {
 			usage("Unknown command %s", argv[i]);
 		} else {
 			struct interface_info *tmp =
 				(struct interface_info *)0;
 			if (strlen(argv[i]) >= sizeof(tmp->name))
 				log_fatal("%s: interface name too long "
 					  "(is %ld)",
 					  argv[i], (long)strlen(argv[i]));
 			result = interface_allocate (&tmp, MDL);
 			if (result != ISC_R_SUCCESS)
 				log_fatal ("Insufficient memory to %s %s: %s",
 					   "record interface", argv [i],
 					   isc_result_totext (result));
 			strcpy (tmp -> name, argv [i]);
 			if (interfaces) {
 				interface_reference (&tmp -> next,
 						     interfaces, MDL);
 				interface_dereference (&interfaces, MDL);
+			}
 			interface_reference (&interfaces, tmp, MDL);
 			tmp -> flags = INTERFACE_REQUESTED;
+		}
+	}
 #if defined(DHCPv6) && defined(DHCP4o6)
 	if (dhcpv4_over_dhcpv6) {
 		if (!local_family_set)
 			log_error("please specify the address family "
 				  "with DHPv4 over DHCPv6 [-4|-6].");
 		if ((local_family == AF_INET) && (interfaces != NULL))
 			log_fatal("DHCPv4 server in DHPv4 over DHCPv6 "
 				  "mode with command line specified "
 				  "interfaces.");
+	}
 #endif /* DHCPv6 && DHCP4o6 */
 	if (!have_dhcpd_conf && (s = getenv ("PATH_DHCPD_CONF"))) {
 		path_dhcpd_conf = s;
+	}
 #ifdef DHCPv6
         if (local_family == AF_INET6) {
                 /* DHCPv6: override DHCPv4 lease and pid filenames */
 	        if (!have_dhcpd_db) {
                         if ((s = getenv ("PATH_DHCPD6_DB")))
 		                path_dhcpd_db = s;
                         else
 		                path_dhcpd_db = _PATH_DHCPD6_DB;
+	        }
 	        if (!have_dhcpd_pid) {
                         if ((s = getenv ("PATH_DHCPD6_PID")))
 		                path_dhcpd_pid = s;
                         else
 		                path_dhcpd_pid = _PATH_DHCPD6_PID;
+	        }
         } else
 #endif /* DHCPv6 */
+        {
 	        if (!have_dhcpd_db && (s = getenv ("PATH_DHCPD_DB"))) {
 		        path_dhcpd_db = s;
 			have_dhcpd_db = 1;
+	        }
 	        if (!have_dhcpd_pid && (s = getenv ("PATH_DHCPD_PID"))) {
 		        path_dhcpd_pid = s;
 			have_dhcpd_pid = 1;
+	        }
+        }
         /*
          * convert relative path names to absolute, for files that need
          * to be reopened after chdir() has been called
          */
         if (have_dhcpd_db && path_dhcpd_db[0] != '/') {
                 path_dhcpd_db = absolute_path(path_dhcpd_db);
+        }
 	if (!quiet) {
 		log_info("%s %s", message, PACKAGE_VERSION);
 		log_info (copyright);
 		log_info (arr);
 		log_info (url);
 	} else {
 		log_perror = 0;
+	}
 #ifndef DEBUG
 	/*
 	 * We need to fork before we call the context create
 	 * call that creates the worker threads!
 	 */
 	if (daemon) {
 		/* First part of becoming a daemon... */
 		if ((pid = fork ()) < 0)
 			log_fatal ("Can't fork daemon: %m");
 		else if (pid)
 			exit (0);
+	}
 #endif
 	/* Set up the isc and dns library managers */
 	status = dhcp_context_create(DHCP_CONTEXT_PRE_DB, NULL, NULL);
 	if (status != ISC_R_SUCCESS)
 		log_fatal("Can't initialize context: %s",
 		          isc_result_totext(status));
 	/* Set up the client classification system. */
 	classification_setup ();
 #if defined (TRACING)
 	trace_init (set_time, MDL);
 	if (traceoutfile) {
 		result = trace_begin (traceoutfile, MDL);
 		if (result != ISC_R_SUCCESS)
 			log_fatal ("Unable to begin trace: %s",
 				isc_result_totext (result));
+	}
 	interface_trace_setup ();
 	parse_trace_setup ();
 	trace_srandom = trace_type_register ("random-seed", (void *)0,
 					     trace_seed_input,
 					     trace_seed_stop, MDL);
 #if defined (NSUPDATE)
 	trace_ddns_init();
 #endif /* NSUPDATE */
 #endif
 #if defined (PARANOIA)
 	/* get user and group info if those options were given */
 	if (set_user) {
 		struct passwd *tmp_pwd;
 		if (geteuid())
 			log_fatal ("you must be root to set user");
 		if (!(tmp_pwd = getpwnam(set_user)))
 			log_fatal ("no such user: %s", set_user);
 		set_uid = tmp_pwd->pw_uid;
 		/* use the user's group as the default gid */
 		if (!set_group)
 			set_gid = tmp_pwd->pw_gid;
+	}
 	if (set_group) {
 /* get around the ISC declaration of group */
 #define group real_group
 		struct group *tmp_grp;
 		if (geteuid())
 			log_fatal ("you must be root to set group");
 		if (!(tmp_grp = getgrnam(set_group)))
 			log_fatal ("no such group: %s", set_group);
 		set_gid = tmp_grp->gr_gid;
 #undef group
+	}
 #  if defined (EARLY_CHROOT)
 	if (set_chroot) setup_chroot (set_chroot);
 #  endif /* EARLY_CHROOT */
 #endif /* PARANOIA */
 	/* Default to the DHCP/BOOTP port. */
 	if (!local_port)
+	{
 		if ((s = getenv ("DHCPD_PORT"))) {
 			local_port = validate_port (s);
 			log_debug ("binding to environment-specified port %d",
 				   ntohs (local_port));
 		} else {
 			if (local_family == AF_INET) {
 				ent = getservbyname("dhcp", "udp");
 				if (ent == NULL) {
 					local_port = htons(67);
 				} else {
 					local_port = ent->s_port;
+				}
 			} else {
 				/* INSIST(local_family == AF_INET6); */
 				ent = getservbyname("dhcpv6-server", "udp");
 				if (ent == NULL) {
 					local_port = htons(547);
 				} else {
 					local_port = ent->s_port;
+				}
+			}
 #ifndef __CYGWIN32__ /* XXX */
 			endservent ();
 #endif
+		}
+	}
   	if (local_family == AF_INET) {
 		remote_port = htons(ntohs(local_port) + 1);
 	} else {
 		/* INSIST(local_family == AF_INET6); */
 		ent = getservbyname("dhcpv6-client", "udp");
 		if (ent == NULL) {
 			remote_port = htons(546);
 		} else {
 			remote_port = ent->s_port;
+		}
+	}
 	if (server) {
 		if (local_family != AF_INET) {
 			log_fatal("You can only specify address to send "
 			          "replies to when running an IPv4 server.");
+		}
 		if (!inet_aton (server, &limited_broadcast)) {
 			struct hostent *he;
 			he = gethostbyname (server);
 			if (he) {
 				memcpy (&limited_broadcast,
 					he -> h_addr_list [0],
 					sizeof limited_broadcast);
 			} else
 				limited_broadcast.s_addr = INADDR_BROADCAST;
+		}
 	} else {
 		limited_broadcast.s_addr = INADDR_BROADCAST;
+	}
 	/* Get the current time... */
 	gettimeofday(&cur_tv, NULL);
 	/* Set up the initial dhcp option universe. */
 	initialize_common_option_spaces ();
 	initialize_server_option_spaces ();
 	/* Add the ddns update style enumeration prior to parsing. */
 	add_enumeration (&ddns_styles);
 	add_enumeration (&syslog_enum);
 #if defined (LDAP_CONFIGURATION)
 	add_enumeration (&ldap_methods);
 #if defined (LDAP_USE_SSL)
 	add_enumeration (&ldap_ssl_usage_enum);
 	add_enumeration (&ldap_tls_reqcert_enum);
 	add_enumeration (&ldap_tls_crlcheck_enum);
 #endif
 #endif
 	if (!group_allocate (&root_group, MDL))
 		log_fatal ("Can't allocate root group!");
 	root_group -> authoritative = 0;
 	/* Set up various hooks. */
 	dhcp_interface_setup_hook = dhcpd_interface_setup_hook;
 	bootp_packet_handler = do_packet;
 #ifdef DHCPv6
 	add_enumeration (&prefix_length_modes);
 	dhcpv6_packet_handler = do_packet6;
 #endif /* DHCPv6 */
 #if defined (NSUPDATE)
 	/* Set up the standard name service updater routine. */
 	parse = NULL;
 	status = new_parse(&parse, -1, std_nsupdate, sizeof(std_nsupdate) - 1,
 			    "standard name service update routine", 0);
 	if (status != ISC_R_SUCCESS)
 		log_fatal ("can't begin parsing name service updater!");
 	if (parse != NULL) {
 		lose = 0;
 		if (!(parse_executable_statements(&root_group->statements,
 						  parse, &lose, context_any))) {
 			end_parse(&parse);
 			log_fatal("can't parse standard name service updater!");
+		}
 		end_parse(&parse);
+	}
 #endif
 	/* Initialize icmp support... */
 	if (!cftest && !lftest)
 		icmp_startup (1, lease_pinged);
 #if defined (TRACING)
 	if (traceinfile) {
 	    if (!have_dhcpd_db) {
 		    log_error ("%s", "");
 		    log_error ("** You must specify a lease file with -lf.");
 		    log_error ("   Dhcpd will not overwrite your default");
 		    log_fatal ("   lease file when playing back a trace. **");
+	    }
 	    trace_file_replay (traceinfile);
 #if defined (DEBUG_MEMORY_LEAKAGE) && \
                 defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
             free_everything ();
             omapi_print_dmalloc_usage_by_caller ();
 #endif
 	    exit (0);
+	}
 #endif
 #ifdef DHCPv6
 	/* set up DHCPv6 hashes */
 	if (!ia_new_hash(&ia_na_active, DEFAULT_HASH_SIZE, MDL)) {
 		log_fatal("Out of memory creating hash for active IA_NA.");
+	}
 	if (!ia_new_hash(&ia_ta_active, DEFAULT_HASH_SIZE, MDL)) {
 		log_fatal("Out of memory creating hash for active IA_TA.");
+	}
 	if (!ia_new_hash(&ia_pd_active, DEFAULT_HASH_SIZE, MDL)) {
 		log_fatal("Out of memory creating hash for active IA_PD.");
+	}
 #endif /* DHCPv6 */
 	/* Read the dhcpd.conf file... */
 	if (readconf () != ISC_R_SUCCESS)
 		log_fatal ("Configuration file errors encountered -- exiting");
 	postconf_initialization (quiet);
 #if defined (FAILOVER_PROTOCOL)
 	dhcp_failover_sanity_check();
 #endif
 #if defined(DHCPv6) && defined(DHCP4o6)
 	if (dhcpv4_over_dhcpv6) {
 		if ((local_family == AF_INET) && (interfaces != NULL))
 			log_fatal("DHCPv4 server in DHPv4 over DHCPv6 "
 				  "mode with config file specified "
 				  "interfaces.");
+	}
 #endif /* DHCPv6 && DHCP4o6 */
 #if defined (PARANOIA) && !defined (EARLY_CHROOT)
 	if (set_chroot) setup_chroot (set_chroot);
 #endif /* PARANOIA && !EARLY_CHROOT */
 #ifdef DHCPv6
 	/* log info about ipv6_ponds with large address ranges */
 	report_jumbo_ranges();
 #endif
         /* test option should cause an early exit */
 	if (cftest && !lftest) {
  		exit(0);
+	}
 	/*
 	 * First part of dealing with pid files.  Check to see if
 	 * we should continue running or not.  We run if:
 	 * - we are testing the lease file out
 	 * - we don't have a pid file to check
 	 * - there is no other process running
 	 */
 	if ((lftest == 0) && (no_pid_file == ISC_FALSE)) {
 		/*Read previous pid file. */
 		if ((i = open(path_dhcpd_pid, O_RDONLY)) >= 0) {
 			status = read(i, pbuf, (sizeof pbuf) - 1);
 			close(i);
 			if (status > 0) {
 				pbuf[status] = 0;
 				pid = atoi(pbuf);
 				/*
 				 * If there was a previous server process and
 				 * it is still running, abort
 				 */
 				if (!pid ||
 				    (pid != getpid() && kill(pid, 0) == 0))
 					log_fatal("There's already a "
 						  "DHCP server running.");
+			}
+		}
+	}
 	group_write_hook = group_writer;
 	/* Start up the database... */
 	db_startup (lftest);
 	if (lftest)
 		exit (0);
 	/* Discover all the network interfaces and initialize them. */
 #if defined(DHCPv6) && defined(DHCP4o6)
 	if (dhcpv4_over_dhcpv6) {
 		int real_family = local_family;
 		local_family = AF_INET6;
 		/* The DHCPv4 side of DHCPv4-over-DHCPv6 service
 		   uses a specific discovery which doesn't register
 		   DHCPv6 sockets. */
 		if (real_family == AF_INET)
 			discover_interfaces(DISCOVER_SERVER46);
 		else
 			discover_interfaces(DISCOVER_SERVER);
 		local_family = real_family;
 	} else
 #endif /* DHCPv6 && DHCP4o6 */
 	discover_interfaces(DISCOVER_SERVER);
 #ifdef DHCPv6
 	/*
 	 * Remove addresses from our pools that we should not issue
 	 * to clients.
+	 *
 	 * We currently have no support for this in IPv4. It is not
 	 * as important in IPv4, as making pools with ranges that
 	 * leave out interfaces and hosts is fairly straightforward
 	 * using range notation, but not so handy with CIDR notation.
 	 */
 	if (local_family == AF_INET6) {
 		mark_hosts_unavailable();
 		mark_phosts_unavailable();
 		mark_interfaces_unavailable();
+	}
 #endif /* DHCPv6 */
 	/* Make up a seed for the random number generator from current
 	   time plus the sum of the last four bytes of each
 	   interface's hardware address interpreted as an integer.
 	   Not much entropy, but we're booting, so we're not likely to
 	   find anything better. */
 	seed = 0;
 	for (ip = interfaces; ip; ip = ip -> next) {
 		int junk;
 		memcpy (&junk,
 			&ip -> hw_address.hbuf [ip -> hw_address.hlen -
 					       sizeof seed], sizeof seed);
 		seed += junk;
+	}
 	srandom (seed + cur_time);
 #if defined (TRACING)
 	trace_seed_stash (trace_srandom, seed + cur_time);
 #endif
 	postdb_startup ();
 #ifdef DHCPv6
 	/*
 	 * Set server DHCPv6 identifier - we go in order:
 	 * dhcp6.server-id in the config file
 	 * server-duid from the lease file
 	 * server-duid from the config file (the config file is read first
 	 * and the lease file overwrites the config file information)
 	 * generate a new one from the interface hardware addresses.
 	 * In all cases we write it out to the lease file.
 	 * See dhcpv6.c for discussion of setting DUID.
 	 */
 	if ((set_server_duid_from_option() != ISC_R_SUCCESS) &&
 	    (!server_duid_isset()) &&
 	    (generate_new_server_duid() != ISC_R_SUCCESS)) {
 		log_fatal("Unable to set server identifier.");
+	}
 	write_server_duid();
 #ifdef DHCP4o6
 	if (dhcpv4_over_dhcpv6)
 		dhcp4o6_setup(dhcp4o6_port);
 #endif /* DHCP4o6 */
 #endif /* DHCPv6 */
 #ifndef DEBUG
 	/*
 	 * Second part of dealing with pid files.  Now
 	 * that we have forked we can write our pid if
 	 * appropriate.
 	 */
 	if (no_pid_file == ISC_FALSE) {
 		i = open(path_dhcpd_pid, O_WRONLY|O_CREAT|O_TRUNC, 0644);
 		if (i >= 0) {
 			sprintf(pbuf, "%d\n", (int) getpid());
 			IGNORE_RET(write(i, pbuf, strlen(pbuf)));
 			close(i);
 		} else {
 			log_error("Can't create PID file %s: %m.",
 				  path_dhcpd_pid);
+		}
+	}
 #if defined (PARANOIA)
 	/* change uid to the specified one */
 	if (set_gid) {
 		if (setgroups (0, (void *)0))
 			log_fatal ("setgroups: %m");
 		if (setgid (set_gid))
 			log_fatal ("setgid(%d): %m", (int) set_gid);
+	}
 	if (set_uid) {
 		if (setuid (set_uid))
 			log_fatal ("setuid(%d): %m", (int) set_uid);
+	}
 #endif /* PARANOIA */
 	/* If we were requested to log to stdout on the command line,
 	   keep doing so; otherwise, stop. */
 	if (log_perror == -1)
 		log_perror = 1;
 	else
 		log_perror = 0;
 	if (daemon) {
 		if (dfd[0] != -1 && dfd[1] != -1) {
 			char buf = 0;
 			if (write(dfd[1], &buf, 1) != 1)
 				log_fatal("write to parent: %m");
 			(void) close(dfd[1]);
 			dfd[0] = dfd[1] = -1;
+		}
 		/* Become session leader and get pid... */
 		(void) setsid();
                 /* Close standard I/O descriptors. */
                 (void) close(0);
                 (void) close(1);
                 (void) close(2);
                 /* Reopen them on /dev/null. */
                 (void) open("/dev/null", O_RDWR);
                 (void) open("/dev/null", O_RDWR);
                 (void) open("/dev/null", O_RDWR);
                 log_perror = 0; /* No sense logging to /dev/null. */
        		IGNORE_RET (chdir("/"));
+	}
 #endif /* !DEBUG */
 #if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL) || \
 		defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
 	dmalloc_cutoff_generation = dmalloc_generation;
 	dmalloc_longterm = dmalloc_outstanding;
 	dmalloc_outstanding = 0;
 #endif
 	omapi_set_int_value ((omapi_object_t *)dhcp_control_object,
 			     (omapi_object_t *)0, "state", server_running);
 #if defined(ENABLE_GENTLE_SHUTDOWN)
 	/* no signal handlers until we deal with the side effects */
         /* install signal handlers */
 	signal(SIGINT, dhcp_signal_handler);   /* control-c */
 	signal(SIGTERM, dhcp_signal_handler);  /* kill */
 #endif
 	/* Log that we are about to start working */
 	log_info("Server starting service.");
 	/*
 	 * Receive packets and dispatch them...
 	 * dispatch() will never return.
 	 */
 	dispatch ();
 	/* Let's return status code */
 	return 0;
+}
 #endif /* !UNIT_TEST */
 void postconf_initialization (int quiet)
+{
 	struct option_state *options = NULL;
 	struct data_string db;
 	struct option_cache *oc;
 	char *s;
 	isc_result_t result;
 	int tmp;
 #if defined (NSUPDATE)
 	struct in_addr  local4, *local4_ptr = NULL;
 	struct in6_addr local6, *local6_ptr = NULL;
 #endif
 	/* Now try to get the lease file name. */
 	option_state_allocate(&options, MDL);
 	execute_statements_in_scope(NULL, NULL, NULL, NULL, NULL,
 				    options, &global_scope, root_group,
 				    NULL, NULL);
 	memset(&db, 0, sizeof db);
 	oc = lookup_option(&server_universe, options, SV_LEASE_FILE_NAME);
 	if (oc &&
 	    evaluate_option_cache(&db, NULL, NULL, NULL, options, NULL,
 				  &global_scope, oc, MDL)) {
 		s = dmalloc(db.len + 1, MDL);
 		if (!s)
 			log_fatal("no memory for lease db filename.");
 		memcpy(s, db.data, db.len);
 		s[db.len] = 0;
 		data_string_forget(&db, MDL);
 		path_dhcpd_db = s;
+	}
 	oc = lookup_option(&server_universe, options, SV_PID_FILE_NAME);
 	if (oc &&
 	    evaluate_option_cache(&db, NULL, NULL, NULL, options, NULL,
 				  &global_scope, oc, MDL)) {
 		s = dmalloc(db.len + 1, MDL);
 		if (!s)
 			log_fatal("no memory for pid filename.");
 		memcpy(s, db.data, db.len);
 		s[db.len] = 0;
 		data_string_forget(&db, MDL);
 		path_dhcpd_pid = s;
+	}
 #ifdef DHCPv6
         if (local_family == AF_INET6) {
                 /*
                  * Override lease file name with dhcpv6 lease file name,
                  * if it was set; then, do the same with the pid file name
                  */
                 oc = lookup_option(&server_universe, options,
                                    SV_DHCPV6_LEASE_FILE_NAME);
                 if (oc &&
                     evaluate_option_cache(&db, NULL, NULL, NULL, options, NULL,
 					  &global_scope, oc, MDL)) {
                         s = dmalloc(db.len + 1, MDL);
                         if (!s)
                                 log_fatal("no memory for lease db filename.");
                         memcpy(s, db.data, db.len);
                         s[db.len] = 0;
                         data_string_forget(&db, MDL);
                         path_dhcpd_db = s;
+                }
                 oc = lookup_option(&server_universe, options,
                                    SV_DHCPV6_PID_FILE_NAME);
                 if (oc &&
                     evaluate_option_cache(&db, NULL, NULL, NULL, options, NULL,
 					  &global_scope, oc, MDL)) {
                         s = dmalloc(db.len + 1, MDL);
                         if (!s)
                                 log_fatal("no memory for pid filename.");
                         memcpy(s, db.data, db.len);
                         s[db.len] = 0;
                         data_string_forget(&db, MDL);
                         path_dhcpd_pid = s;
+                }
 		oc = lookup_option(&server_universe, options,
 				   SV_LOCAL_ADDRESS6);
 		if (oc &&
 		    evaluate_option_cache(&db, NULL, NULL, NULL, options, NULL,
 					  &global_scope, oc, MDL)) {
 			if (db.len == 16) {
 				memcpy(&local_address6, db.data, 16);
 			} else
 				log_fatal("invalid local address "
 					  "data length");
 			data_string_forget(&db, MDL);
+		}
 		oc = lookup_option(&server_universe, options,
 				   SV_BIND_LOCAL_ADDRESS6);
 		if (oc &&
 		    evaluate_boolean_option_cache(NULL, NULL, NULL,
 						  NULL, options, NULL,
 						  &global_scope, oc, MDL)) {
 			bind_local_address6 = 1;
+		}
+        }
 #endif /* DHCPv6 */
 	omapi_port = -1;
 	oc = lookup_option(&server_universe, options, SV_OMAPI_PORT);
 	if (oc &&

 @@ -1,144 +1,228 @@
-/*	$NetBSD: option_unittest.c,v 1.2 2018/04/07 22:37:29 christos Exp $	*/
+/*	$NetBSD: option_unittest.c,v 1.3 2021/05/26 22:52:31 christos Exp $	*/
 /*
- * Copyright (C) 2018 Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (C) 2018-2021 Internet Systems Consortium, Inc. ("ISC")
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  * AND FITNESS.	 IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
 #include <config.h>
 #include <atf-c.h>
 #include "dhcpd.h"
 ATF_TC(option_refcnt);
 ATF_TC_HEAD(option_refcnt, tc)
+{
     atf_tc_set_md_var(tc, "descr",
 		      "Verify option reference count does not overflow.");
+}
 /* This test does a simple check to see if option reference count is
  * decremented even an error path exiting parse_option_buffer()
  */
 ATF_TC_BODY(option_refcnt, tc)
+{
     struct option_state *options;
     struct option *option;
     unsigned code;
     int refcnt;
     unsigned char buffer[3] = { 15, 255, 0 };
     initialize_common_option_spaces();
     options = NULL;
     if (!option_state_allocate(&options, MDL)) {
 	atf_tc_fail("can't allocate option state");
+    }
     option = NULL;
     code = 15; /* domain-name */
     if (!option_code_hash_lookup(&option, dhcp_universe.code_hash,
 				 &code, 0, MDL)) {
 	atf_tc_fail("can't find option 15");
+    }
     if (option == NULL) {
 	atf_tc_fail("option is NULL");
+    }
     refcnt = option->refcnt;
     buffer[0] = 15;
     buffer[1] = 255; /* invalid */
     buffer[2] = 0;
     if (parse_option_buffer(options, buffer, 3, &dhcp_universe)) {
 	atf_tc_fail("parse_option_buffer is expected to fail");
+    }
     if (refcnt != option->refcnt) {
 	atf_tc_fail("refcnt changed from %d to %d", refcnt, option->refcnt);
+    }
+}
 ATF_TC(pretty_print_option);
 ATF_TC_HEAD(pretty_print_option, tc)
+{
     atf_tc_set_md_var(tc, "descr",
 		      "Verify pretty_print_option does not overrun its buffer.");
+}
 /*
  * This test verifies that pretty_print_option() will not overrun its
  * internal, static buffer when given large 'x/X' format options.
+ *
  */
 ATF_TC_BODY(pretty_print_option, tc)
+{
     struct option *option;
     unsigned code;
     unsigned char bad_data[32*1024];
     unsigned char good_data[] = { 1,2,3,4,5,6 };
     int emit_commas = 1;
     int emit_quotes = 1;
     const char *output_buf;
     /* Initialize whole thing to non-printable chars */
     memset(bad_data, 0x1f, sizeof(bad_data));
     initialize_common_option_spaces();
     /* We'll use dhcp_client_identitifer because it happens to be format X */
     code = 61;
     option = NULL;
     if (!option_code_hash_lookup(&option, dhcp_universe.code_hash,
 				 &code, 0, MDL)) {
 	    atf_tc_fail("can't find option %d", code);
+    }
     if (option == NULL) {
 	    atf_tc_fail("option is NULL");
+    }
     /* First we will try a good value we know should fit. */
     output_buf = pretty_print_option (option, good_data, sizeof(good_data),
                                       emit_commas, emit_quotes);
     /* Make sure we get what we expect */
     if (!output_buf || strcmp(output_buf, "1:2:3:4:5:6")) {
 	    atf_tc_fail("pretty_print_option did not return \"<error>\"");
+    }
     /* Now we'll try a data value that's too large */
     output_buf = pretty_print_option (option, bad_data, sizeof(bad_data),
                                       emit_commas, emit_quotes);
     /* Make sure we safely get an error */
     if (!output_buf || strcmp(output_buf, "<error>")) {
 	    atf_tc_fail("pretty_print_option did not return \"<error>\"");
+    }
+}
 ATF_TC(parse_X);
 ATF_TC_HEAD(parse_X, tc)
+{
     atf_tc_set_md_var(tc, "descr",
 		      "Verify parse_X survices option too big.");
+}
 /* Initializes a parse struct from an input buffer of data. */
 static void init_parse(struct parse *cfile, char* name, char *input) {
     memset(cfile, 0, sizeof(struct parse));
     cfile->tlname = name;
     cfile->lpos = cfile->line = 1;
     cfile->cur_line = cfile->line1;
     cfile->prev_line = cfile->line2;
     cfile->token_line = cfile->cur_line;
     cfile->cur_line[0] = cfile->prev_line[0] = 0;
     cfile->file = -1;
     cfile->eol_token = 0;
     cfile->inbuf = input;
     cfile->buflen = strlen(input);
     cfile->bufsiz = 0;
+}
 /*
  * This test verifies that parse_X does not overwrite the output
  * buffer when given input data that exceeds the output buffer
  * capacity.
 */
 ATF_TC_BODY(parse_X, tc)
+{
     struct parse cfile;
     u_int8_t output[10];
     unsigned len;
     /* Input hex literal */
     char *input = "01:02:03:04:05:06:07:08";
     unsigned expected_len = 8;
     /* Normal output plus two filler bytes */
     u_int8_t expected_plus_two[] = {
 x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xff, 0xff
     };
     /* Safe output when option is too long */
     unsigned short_buf_len = 4;
     u_int8_t expected_too_long[] = {
 x01, 0x02, 0x03, 0x04, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
     };
     /* First we'll run one that works normally */
     memset(output, 0xff, sizeof(output));
     init_parse(&cfile, "hex_fits", input);
     len = parse_X(&cfile, output, expected_len);
     // Len should match the expected len.
     if (len != expected_len) {
 	    atf_tc_fail("parse_X failed, output len: %d", len);
+    }
     // We should not have written anything past the end of the buffer.
     if (memcmp(output, expected_plus_two, sizeof(output))) {
 	    atf_tc_fail("parse_X failed, output does not match expected");
+    }
     // Now we'll try it with a buffer that's too small.
     init_parse(&cfile, "hex_too_long", input);
     memset(output, 0xff, sizeof(output));
     len = parse_X(&cfile, output, short_buf_len);
     // On errors, len should be zero.
     if (len != 0) {
 	    atf_tc_fail("parse_X failed, we should have had an error");
+    }
     // We should not have written anything past the end of the buffer.
     if (memcmp(output, expected_too_long, sizeof(output))) {
         atf_tc_fail("parse_X overwrote buffer!");
+    }
+}
 /* This macro defines main() method that will call specified
    test cases. tp and simple_test_case names can be whatever you want
    as long as it is a valid variable identifier. */
 ATF_TP_ADD_TCS(tp)
+{
     ATF_TP_ADD_TC(tp, option_refcnt);
     ATF_TP_ADD_TC(tp, pretty_print_option);
     ATF_TP_ADD_TC(tp, parse_X);
     return (atf_no_error());
+}