 @@ -1510,53 +1510,74 @@ again:
 		goto again;
+	}
 	/* We can't do this when sharing leases across interfaes */
 #if 0
 	/* As the XID changes, re-apply the filter. */
 	if (state->bpf_fd != -1) {
 		if (bpf_bootp(ifp, state->bpf_fd) == -1)
 			logerr(__func__); /* try to continue */
+	}
 #endif
+}
-void
+static void
-dhcp_close(struct interface *ifp)
+dhcp_closebpf(struct interface *ifp)
+{
 	struct dhcpcd_ctx *ctx = ifp->ctx;
 	struct dhcp_state *state = D_STATE(ifp);
 	if (state == NULL)
 		return;
 #ifdef PRIVSEP
-	if (IN_PRIVSEP_SE(ctx)) {
+	if (IN_PRIVSEP_SE(ctx))
 		ps_bpf_closebootp(ifp);
 		if (state->addr != NULL)
 			ps_inet_closebootp(state->addr);
 #endif
 	if (state->bpf != NULL) {
 		eloop_event_delete(ctx->eloop, state->bpf->bpf_fd);
 		bpf_close(state->bpf);
 		state->bpf = NULL;
+	}
+}
 static void
 dhcp_closeinet(struct interface *ifp)
+{
 	struct dhcpcd_ctx *ctx = ifp->ctx;
 	struct dhcp_state *state = D_STATE(ifp);
 #ifdef PRIVSEP
 	if (IN_PRIVSEP_SE(ctx)) {
 		if (state->addr != NULL)
 			ps_inet_closebootp(state->addr);
+	}
 #endif
 	if (state->udp_rfd != -1) {
 		eloop_event_delete(ctx->eloop, state->udp_rfd);
 		close(state->udp_rfd);
 		state->udp_rfd = -1;
+	}
+}
 void
 dhcp_close(struct interface *ifp)
+{
 	struct dhcp_state *state = D_STATE(ifp);
 	if (state == NULL)
 		return;
 	dhcp_closebpf(ifp);
 	dhcp_closeinet(ifp);
 	state->interval = 0;
+}
 int
 dhcp_openudp(struct in_addr *ia)
+{
 	int s;
 	struct sockaddr_in sin;
 	int n;
 	if ((s = xsocket(PF_INET, SOCK_DGRAM | SOCK_CXNB, IPPROTO_UDP)) == -1)
 		return -1;
 @@ -2051,32 +2072,34 @@ dhcp_addr_duplicated(struct interface *i
 #define NOT_ONLY_SELF (DHCPCD_MASTER | DHCPCD_IPV6RS | DHCPCD_DHCP6)
 		if (!(ctx->options & NOT_ONLY_SELF))
 			eloop_exit(ifp->ctx->eloop, EXIT_FAILURE);
 		return deleted;
+	}
 	eloop_timeout_add_sec(ifp->ctx->eloop,
 	    DHCP_RAND_MAX, dhcp_discover, ifp);
 	return deleted;
+}
 #endif
 #ifdef ARP
 #ifdef KERNEL_RFC5227
 #ifdef ARPING
 static void
 dhcp_arp_announced(struct arp_state *state)
+{
 	arp_free(state);
+}
 #endif
 #else
 static void
 dhcp_arp_defend_failed(struct arp_state *astate)
+{
 	struct interface *ifp = astate->iface;
 	dhcp_drop(ifp, "EXPIRED");
 	dhcp_start1(ifp);
+}
 #endif
 #if !defined(KERNEL_RFC5227) || defined(ARPING)
 static void dhcp_arp_not_found(struct arp_state *);
 @@ -2311,43 +2334,44 @@ dhcp_bind(struct interface *ifp)
 		    " seconds",
 		    ifp->name, lease->renewaltime, lease->rebindtime);
+	}
 	state->state = DHS_BOUND;
 	if (!state->lease.frominfo &&
 	    !(ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))) {
 		logdebugx("%s: writing lease: %s",
 		    ifp->name, state->leasefile);
 		if (dhcp_writefile(ifp->ctx, state->leasefile, 0640,
 		    state->new, state->new_len) == -1)
 			logerr("dhcp_writefile: %s", state->leasefile);
+	}
 	old_state = state->added;
 	/* Close the BPF filter as we can now receive DHCP messages
 	 * on a UDP socket. */
-	old_state = state->added;
+	dhcp_closebpf(ifp);
 	if (ctx->options & DHCPCD_MASTER ||
 	    state->old == NULL ||
 	    state->old->yiaddr != state->new->yiaddr || old_state & STATE_FAKE)
 		dhcp_close(ifp);
 	/* Add the address */
 	ipv4_applyaddr(ifp);
 	/* If not in master mode, open an address specific socket. */
 	if (ctx->options & DHCPCD_MASTER ||
 	    (state->old != NULL &&
-	    state->old->yiaddr == state->new->yiaddr &&
+	     state->old->yiaddr == state->new->yiaddr &&
-	    old_state & STATE_ADDED && !(old_state & STATE_FAKE)))
+	     old_state & STATE_ADDED && !(old_state & STATE_FAKE)))
 		return;
 	dhcp_closeinet(ifp);
 #ifdef PRIVSEP
 	if (IN_PRIVSEP_SE(ctx)) {
 		if (ps_inet_openbootp(state->addr) == -1)
 		    logerr(__func__);
 		return;
+	}
 #endif
 	state->udp_rfd = dhcp_openudp(&state->addr->addr);
 	if (state->udp_rfd == -1) {
 		logerr(__func__);
 		/* Address sharing without master mode is not supported.
 		 * It's also possible another DHCP client could be running,
 @@ -2916,26 +2940,28 @@ dhcp_redirect_dhcp(struct interface *ifp
 static void
 dhcp_handledhcp(struct interface *ifp, struct bootp *bootp, size_t bootp_len,
     const struct in_addr *from)
+{
 	struct dhcp_state *state = D_STATE(ifp);
 	struct if_options *ifo = ifp->options;
 	struct dhcp_lease *lease = &state->lease;
 	uint8_t type, tmp;
 	struct in_addr addr;
 	unsigned int i;
 	char *msg;
 	bool bootp_copied;
 	uint32_t v6only_time = 0;
 	bool use_v6only = false;
 #ifdef AUTH
 	const uint8_t *auth;
 	size_t auth_len;
 #endif
 #ifdef IN_IFF_DUPLICATED
 	struct ipv4_addr *ia;
 #endif
 #define LOGDHCP0(l, m) \
 	log_dhcp((l), (m), ifp, bootp, bootp_len, from, 0)
 #define LOGDHCP(l, m) \
 	log_dhcp((l), (m), ifp, bootp, bootp_len, from, 1)
 @@ -3133,26 +3159,43 @@ dhcp_handledhcp(struct interface *ifp, s
+		{
 			/* If we are BOOTP, then ignore the need for serverid.
 			 * To ignore BOOTP, require dhcp_message_type.
 			 * However, nothing really stops BOOTP from providing
 			 * DHCP style options as well so the above isn't
 			 * always true. */
 			if (type == 0 && i == DHO_SERVERID)
 				continue;
 			LOGDHCP(LOG_WARNING, "reject DHCP");
 			return;
+		}
+	}
 	if (has_option_mask(ifo->requestmask, DHO_IPV6_PREFERRED_ONLY)) {
 		if (get_option_uint32(ifp->ctx, &v6only_time, bootp, bootp_len,
 		    DHO_IPV6_PREFERRED_ONLY) == 0 &&
 		    (state->state == DHS_DISCOVER || state->state == DHS_REBOOT))
+		{
 			char v6msg[128];
 			use_v6only = true;
 			if (v6only_time < MIN_V6ONLY_WAIT)
 				v6only_time = MIN_V6ONLY_WAIT;
 			snprintf(v6msg, sizeof(v6msg),
 			    "IPv6-Only Preferred received (%u seconds)",
 			    v6only_time);
 			LOGDHCP(LOG_INFO, v6msg);
+		}
+	}
 	/* DHCP Auto-Configure, RFC 2563 */
 	if (type == DHCP_OFFER && bootp->yiaddr == 0) {
 		LOGDHCP(LOG_WARNING, "no address given");
 		if ((msg = get_option_string(ifp->ctx,
 		    bootp, bootp_len, DHO_MESSAGE)))
+		{
 			logwarnx("%s: message: %s", ifp->name, msg);
 			free(msg);
+		}
 #ifdef IPV4LL
 		if (state->state == DHS_DISCOVER &&
 		    get_option_uint8(ifp->ctx, &tmp, bootp, bootp_len,
 		    DHO_AUTOCONFIGURE) == 0)
 @@ -3167,32 +3210,42 @@ dhcp_handledhcp(struct interface *ifp, s
 				break;
 			case 1:
 				LOGDHCP(LOG_WARNING, "IPv4LL enabled from");
 				ipv4ll_start(ifp);
 				break;
 			default:
 				logerrx("%s: unknown auto configuration "
 				    "option %d",
 				    ifp->name, tmp);
 				break;
+			}
 			eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
 			eloop_timeout_add_sec(ifp->ctx->eloop,
-			    DHCP_MAX, dhcp_discover, ifp);
+			    use_v6only ? v6only_time : DHCP_MAX,
 			    dhcp_discover, ifp);
+		}
 #endif
 		return;
+	}
 	if (use_v6only) {
 		dhcp_drop(ifp, "EXPIRE");
 		dhcp_unlink(ifp->ctx, state->leasefile);
 		eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
 		eloop_timeout_add_sec(ifp->ctx->eloop, v6only_time,
 		    dhcp_discover, ifp);
 		return;
+	}
 	/* Ensure that the address offered is valid */
 	if ((type == 0 || type == DHCP_OFFER || type == DHCP_ACK) &&
 	    (bootp->ciaddr == INADDR_ANY || bootp->ciaddr == INADDR_BROADCAST)
 	    &&
 	    (bootp->yiaddr == INADDR_ANY || bootp->yiaddr == INADDR_BROADCAST))
+	{
 		LOGDHCP(LOG_WARNING, "reject invalid address");
 		return;
+	}
 #ifdef IN_IFF_DUPLICATED
 	ia = ipv4_iffindaddr(ifp, &lease->addr, NULL);
 	if (ia && ia->addr_flags & IN_IFF_DUPLICATED) {

 @@ -14,27 +14,27 @@
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 .\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.Dd September 2, 2020
+.Dd October 30, 2020
 .Dt DHCPCD 8
 .Os
 .Sh NAME
 .Nm dhcpcd
 .Nd a DHCP client
 .Sh SYNOPSIS
 .Nm
 .Op Fl 146ABbDdEGgHJKLMNPpqTV
 .Op Fl C , Fl Fl nohook Ar hook
 .Op Fl c , Fl Fl script Ar script
 .Op Fl e , Fl Fl env Ar value
 .Op Fl F , Fl Fl fqdn Ar FQDN
 .Op Fl f , Fl Fl config Ar file
 @@ -836,23 +836,15 @@ Control socket to per interface daemon.
 .Xr resolv.conf 5 ,
 .Xr dhcpcd-run-hooks 8 ,
 .Xr resolvconf 8
 .Sh STANDARDS
 RFC\ 951, RFC\ 1534, RFC\ 2104, RFC\ 2131, RFC\ 2132, RFC\ 2563, RFC\ 2855,
 RFC\ 3004, RFC\ 3118, RFC\ 3203, RFC\ 3315, RFC\ 3361, RFC\ 3633, RFC\ 3396,
 RFC\ 3397, RFC\ 3442, RFC\ 3495, RFC\ 3925, RFC\ 3927, RFC\ 4039, RFC\ 4075,
 RFC\ 4242, RFC\ 4361, RFC\ 4390, RFC\ 4702, RFC\ 4074, RFC\ 4861, RFC\ 4833,
 RFC\ 4941, RFC\ 5227, RFC\ 5942, RFC\ 5969, RFC\ 6106, RFC\ 6334, RFC\ 6355,
 RFC\ 6603, RFC\ 6704, RFC\ 7217, RFC\ 7550, RFC\ 7844.
 .Sh AUTHORS
 .An Roy Marples Aq Mt roy@marples.name
 .Sh BUGS
 If
 .Nm
 is running in a
 .Xr chroot 2
 then re-opening the
 .Fl Fl logfile
 from SIGUSR2 may not work.
 .Pp
 Please report them to
 .Lk http://roy.marples.name/projects/dhcpcd

 @@ -1412,30 +1412,35 @@ dhcpcd_signal_cb(int sig, void *arg)
 		loginfox(sigmsg, "SIGHUP", "rebinding");
 		reload_config(ctx);
 		/* Preserve any options passed on the commandline
 		 * when we were started. */
 		reconf_reboot(ctx, 1, ctx->argc, ctx->argv,
 		    ctx->argc - ctx->ifc);
 		return;
 	case SIGUSR1:
 		loginfox(sigmsg, "SIGUSR1", "renewing");
 		dhcpcd_renew(ctx);
 		return;
 	case SIGUSR2:
 		loginfox(sigmsg, "SIGUSR2", "reopening log");
-		/* XXX This may not work that well in a chroot */
+#ifdef PRIVSEP
-		logclose();
+		if (IN_PRIVSEP(ctx)) {
 			if (ps_root_logreopen(ctx) == -1)
 				logerr("ps_root_logreopen");
 			return;
+		}
 #endif
 		if (logopen(ctx->logfile) == -1)
-			logerr(__func__);
+			logerr("logopen");
 		return;
 	case SIGCHLD:
 		while (waitpid(-1, NULL, WNOHANG) > 0)
+			;
 		return;
 	default:
 		logerrx("received signal %d but don't know what to do with it",
 		    sig);
 		return;
+	}
 	if (!(ctx->options & DHCPCD_TEST))
 		stop_all_interfaces(ctx, opts);
 @@ -1850,27 +1855,27 @@ main(int argc, char **argv, char **envp)
 #endif
 #ifdef INET
 	ctx.udp_rfd = -1;
 	ctx.udp_wfd = -1;
 #endif
 #if defined(INET6) && !defined(__sun)
 	ctx.nd_fd = -1;
 #endif
 #ifdef DHCP6
 	ctx.dhcp6_rfd = -1;
 	ctx.dhcp6_wfd = -1;
 #endif
 #ifdef PRIVSEP
-	ctx.ps_root_fd = ctx.ps_data_fd = -1;
+	ctx.ps_root_fd = ctx.ps_log_fd = ctx.ps_data_fd = -1;
 	ctx.ps_inet_fd = ctx.ps_control_fd = -1;
 	TAILQ_INIT(&ctx.ps_processes);
 #endif
 	/* Check our streams for validity */
 	ctx.stdin_valid =  fcntl(STDIN_FILENO,  F_GETFD) != -1;
 	ctx.stdout_valid = fcntl(STDOUT_FILENO, F_GETFD) != -1;
 	ctx.stderr_valid = fcntl(STDERR_FILENO, F_GETFD) != -1;
 	logopts = LOGERR_LOG | LOGERR_LOG_DATE | LOGERR_LOG_PID;
 	if (ctx.stderr_valid)
 		logopts |= LOGERR_ERR;
 @@ -2318,26 +2323,27 @@ printpidfile:
 			eloop_event_add(ctx.eloop, ctx.stderr_fd,
 			    dhcpcd_stderr_cb, &ctx);
+		}
 #ifdef PRIVSEP
 		if (IN_PRIVSEP(&ctx) && ps_mastersandbox(&ctx, NULL) == -1)
 			goto exit_failure;
 #endif
 		goto run_loop;
+	}
 	/* We have now forked, setsid, forked once more.
 	 * From this point on, we are the controlling daemon. */
 	ctx.options |= DHCPCD_STARTED;
 	logdebugx("spawned master process on PID %d", getpid());
 	if ((pid = pidfile_lock(ctx.pidfile)) != 0) {
 		logerr("%s: pidfile_lock %d", __func__, pid);
 #ifdef PRIVSEP
 		/* privsep has not started ... */
 		ctx.options &= ~DHCPCD_PRIVSEP;
 #endif
 		goto exit_failure;
+	}
 #endif
 	os_init();
 #if defined(BSD) && defined(INET6)

 @@ -37,61 +37,71 @@
 #include <time.h>
 #include <unistd.h>
 #include "logerr.h"
 #ifndef	LOGERR_SYSLOG_FACILITY
 #define	LOGERR_SYSLOG_FACILITY	LOG_DAEMON
 #endif
 #ifdef SMALL
 #undef LOGERR_TAG
 #endif
 /* syslog protocol is 1k message max, RFC 3164 section 4.1 */
 #define LOGERR_SYSLOGBUF	1024 + sizeof(int) + sizeof(pid_t)
 #define UNUSED(a)		(void)(a)
 struct logctx {
 	char		 log_buf[BUFSIZ];
 	unsigned int	 log_opts;
 	int		 log_fd;
 	pid_t		 log_pid;
 #ifndef SMALL
 	FILE		*log_file;
 #ifdef LOGERR_TAG
 	const char	*log_tag;
 #endif
 #endif
 };
 static struct logctx _logctx = {
 	/* syslog style, but without the hostname or tag. */
 	.log_opts = LOGERR_LOG | LOGERR_LOG_DATE | LOGERR_LOG_PID,
 	.log_fd = -1,
 	.log_pid = 0,
 };
-#if defined(LOGERR_TAG) && defined(__linux__)
+#if defined(__linux__)
 /* Poor man's getprogname(3). */
 static char *_logprog;
 static const char *
 getprogname(void)
+{
 	const char *p;
 	/* Use PATH_MAX + 1 to avoid truncation. */
 	if (_logprog == NULL) {
 		/* readlink(2) does not append a NULL byte,
 		 * so zero the buffer. */
 		if ((_logprog = calloc(1, PATH_MAX + 1)) == NULL)
 			return NULL;
 		if (readlink("/proc/self/exe", _logprog, PATH_MAX + 1) == -1) {
 			free(_logprog);
 			_logprog = NULL;
 			return NULL;
+		}
+	}
 	if (readlink("/proc/self/exe", _logprog, PATH_MAX + 1) == -1)
 		return NULL;
 	if (_logprog[0] == '[')
 		return NULL;
 	p = strrchr(_logprog, '/');
 	if (p == NULL)
 		return _logprog;
 	return p + 1;
+}
 #endif
 #ifndef SMALL
 /* Write the time, syslog style. month day time - */
 static int
 logprintdate(FILE *stream)
 @@ -137,27 +147,33 @@ vlogprintf_r(struct logctx *ctx, FILE *s
 	    (stream != stderr && ctx->log_opts & LOGERR_LOG_TAG));
 	if (log_tag) {
 		if (ctx->log_tag == NULL)
 			ctx->log_tag = getprogname();
 		if ((e = fprintf(stream, "%s", ctx->log_tag)) == -1)
 			return -1;
 		len += e;
+	}
 #endif
 	log_pid = ((stream == stderr && ctx->log_opts & LOGERR_ERR_PID) ||
 	    (stream != stderr && ctx->log_opts & LOGERR_LOG_PID));
 	if (log_pid) {
-		if ((e = fprintf(stream, "[%d]", getpid())) == -1)
+		pid_t pid;
 		if (ctx->log_pid == 0)
 			pid = getpid();
 		else
 			pid = ctx->log_pid;
 		if ((e = fprintf(stream, "[%d]", pid)) == -1)
 			return -1;
 		len += e;
+	}
 #ifdef LOGERR_TAG
 	if (log_tag || log_pid)
 #else
 	if (log_pid)
 #endif
+	{
 		if ((e = fprintf(stream, ": ")) == -1)
 			return -1;
 		len += e;
 @@ -188,42 +204,57 @@ vlogprintf_r(struct logctx *ctx, FILE *s
  * Until NetBSD solves this issue, we have to disable a gcc diagnostic
  * for our fully standards compliant code in the logger function.
  */
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmissing-format-attribute"
 #endif
 __printflike(2, 0) static int
 vlogmessage(int pri, const char *fmt, va_list args)
+{
 	struct logctx *ctx = &_logctx;
 	int len = 0;
 	if (ctx->log_fd != -1) {
 		char buf[LOGERR_SYSLOGBUF];
 		pid_t pid;
 		memcpy(buf, &pri, sizeof(pri));
 		pid = getpid();
 		memcpy(buf + sizeof(pri), &pid, sizeof(pid));
 		len = vsnprintf(buf + sizeof(pri) + sizeof(pid),
 		    sizeof(buf) - sizeof(pri) - sizeof(pid),
 		    fmt, args);
 		if (len != -1)
 			len = (int)write(ctx->log_fd, buf,
 			    ((size_t)++len) + sizeof(pri) + sizeof(pid));
 		return len;
+	}
 	if (ctx->log_opts & LOGERR_ERR &&
 	    (pri <= LOG_ERR ||
 	    (!(ctx->log_opts & LOGERR_QUIET) && pri <= LOG_INFO) ||
 	    (ctx->log_opts & LOGERR_DEBUG && pri <= LOG_DEBUG)))
 		len = vlogprintf_r(ctx, stderr, fmt, args);
 	if (!(ctx->log_opts & LOGERR_LOG))
 		return len;
 #ifndef SMALL
 	if (ctx->log_file != NULL &&
 	    (pri != LOG_DEBUG || (ctx->log_opts & LOGERR_DEBUG)))
 		len = vlogprintf_r(ctx, ctx->log_file, fmt, args);
 #endif
-	vsyslog(pri, fmt, args);
+	if (ctx->log_opts & LOGERR_LOG)
 		vsyslog(pri, fmt, args);
 	return len;
+}
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5))
 #pragma GCC diagnostic pop
 #endif
 __printflike(2, 3) void
 logmessage(int pri, const char *fmt, ...)
+{
 	va_list args;
 	va_start(args, fmt);
 	vlogmessage(pri, fmt, args);
 @@ -321,26 +352,74 @@ log_err(const char *fmt, ...)
 	va_end(args);
+}
 void
 log_errx(const char *fmt, ...)
+{
 	va_list args;
 	va_start(args, fmt);
 	vlogmessage(LOG_ERR, fmt, args);
 	va_end(args);
+}
 int
 loggetfd(void)
+{
 	struct logctx *ctx = &_logctx;
 	return ctx->log_fd;
+}
 void
 logsetfd(int fd)
+{
 	struct logctx *ctx = &_logctx;
 	ctx->log_fd = fd;
 #ifndef SMALL
 	if (fd != -1 && ctx->log_file != NULL) {
 		fclose(ctx->log_file);
 		ctx->log_file = NULL;
+	}
 #endif
+}
 int
 logreadfd(int fd)
+{
 	struct logctx *ctx = &_logctx;
 	char buf[LOGERR_SYSLOGBUF];
 	int len, pri;
 	len = (int)read(fd, buf, sizeof(buf));
 	if (len == -1)
 		return -1;
 	/* Ensure we have pri, pid and a terminator */
 	if (len < (int)(sizeof(pri) + sizeof(pid_t) + 1) ||
 	    buf[len - 1] != '\0')
+	{
 		errno = EINVAL;
 		return -1;
+	}
 	memcpy(&pri, buf, sizeof(pri));
 	memcpy(&ctx->log_pid, buf + sizeof(pri), sizeof(ctx->log_pid));
 	logmessage(pri, "%s", buf + sizeof(pri) + sizeof(ctx->log_pid));
 	ctx->log_pid = 0;
 	return len;
+}
 unsigned int
 loggetopts(void)
+{
 	struct logctx *ctx = &_logctx;
 	return ctx->log_opts;
+}
 void
 logsetopts(unsigned int opts)
+{
 	struct logctx *ctx = &_logctx;
 @@ -363,35 +442,36 @@ logsettag(const char *tag)
 #endif
 int
 logopen(const char *path)
+{
 	struct logctx *ctx = &_logctx;
 	int opts = 0;
 	/* Cache timezone */
 	tzset();
 	(void)setvbuf(stderr, ctx->log_buf, _IOLBF, sizeof(ctx->log_buf));
-	if (!(ctx->log_opts & LOGERR_LOG))
+#ifndef SMALL
-		return 1;
+	if (ctx->log_file != NULL) {
 		fclose(ctx->log_file);
-#ifdef LOG_NDELAY
+		ctx->log_file = NULL;
 	opts |= LOG_NDELAY;
 #endif
 	if (ctx->log_opts & LOGERR_LOG_PID)
 		opts |= LOG_PID;
-	openlog(NULL, opts, LOGERR_SYSLOG_FACILITY);
+	openlog(getprogname(), opts, LOGERR_SYSLOG_FACILITY);
 	if (path == NULL)
 		return 1;
 #ifndef SMALL
 	if ((ctx->log_file = fopen(path, "ae")) == NULL)
 		return -1;
 	setlinebuf(ctx->log_file);
 	return fileno(ctx->log_file);
 #else
 	errno = ENOTSUP;
 	return -1;
 #endif
+}
 @@ -400,17 +480,17 @@ void
 logclose(void)
+{
 #ifndef SMALL
 	struct logctx *ctx = &_logctx;
 #endif
 	closelog();
 #ifndef SMALL
 	if (ctx->log_file == NULL)
 		return;
 	fclose(ctx->log_file);
 	ctx->log_file = NULL;
 #endif
-#if defined(LOGERR_TAG) && defined(__linux__)
+#if defined(__linux__)
 	free(_logprog);
 #endif
+}

 @@ -532,26 +532,39 @@ ps_entersandbox(const char *_pledge, con
 int
 ps_mastersandbox(struct dhcpcd_ctx *ctx, const char *_pledge)
+{
 	const char *sandbox = NULL;
 	bool forked;
 	int dropped;
 	forked = ctx->options & DHCPCD_FORKED;
 	ctx->options &= ~DHCPCD_FORKED;
 	dropped = ps_dropprivs(ctx);
 	if (forked)
 		ctx->options |= DHCPCD_FORKED;
 	/*
 	 * If we don't have a root process, we cannot use syslog.
 	 * If it cannot be opened before chrooting then syslog(3) will fail.
 	 * openlog(3) does not return an error which doubly sucks.
 	 */
 	if (ctx->ps_root_fd == -1) {
 		unsigned int logopts = loggetopts();
 		logopts &= ~LOGERR_LOG;
 		logsetopts(logopts);
+	}
 	if (dropped == -1) {
 		logerr("%s: ps_dropprivs", __func__);
 		return -1;
+	}
 #ifdef PRIVSEP_RIGHTS
 	if ((ctx->pf_inet_fd != -1 &&
 	    ps_rights_limit_ioctl(ctx->pf_inet_fd) == -1) ||
 	     ps_rights_limit_stdio(ctx) == -1)
+	{
 		logerr("%s: cap_rights_limit", __func__);
 		return -1;
+	}