 @@ -400,33 +400,27 @@ bpf_cmp_hwaddr(struct bpf_insn *bpf, siz
 		bp++;
+	}
 	/* Last step is always return failure.
 	 * Next step is a positive finish. */
 	BPF_SET_STMT(bp, BPF_RET + BPF_K, 0);
 	bp++;
 	return (unsigned int)(bp - bpf);
+}
 #endif
 #ifdef ARP
 static const struct bpf_insn bpf_arp_ether [] = {
 	/* Ensure packet is at least correct size. */
 	BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0),
 	BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, sizeof(struct ether_arp), 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* Check this is an ARP packet. */
 	BPF_STMT(BPF_LD + BPF_H + BPF_ABS,
 	         offsetof(struct ether_header, ether_type)),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_ARP, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* Load frame header length into X */
 	BPF_STMT(BPF_LDX + BPF_W + BPF_IMM, sizeof(struct ether_header)),
 	/* Make sure the hardware family matches. */
 	BPF_STMT(BPF_LD + BPF_H + BPF_IND, offsetof(struct arphdr, ar_hrd)),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPHRD_ETHER, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 @@ -542,124 +536,75 @@ bpf_arp(struct interface *ifp, int fd)
 			BPF_SET_STMT(bp, BPF_RET + BPF_K, arp_len);
 			bp++;
+		}
 		/* Return nothing, no protocol address match. */
 		BPF_SET_STMT(bp, BPF_RET + BPF_K, 0);
 		bp++;
+	}
 	return bpf_attach(fd, bpf, (unsigned int)(bp - bpf));
+}
 #endif
 #define	BPF_M_FHLEN	0
 #define	BPF_M_IPHLEN	1
 #define	BPF_M_IPLEN	2
 #define	BPF_M_UDP	3
 #define	BPF_M_UDPLEN	4
 #ifdef ARPHRD_NONE
 static const struct bpf_insn bpf_bootp_none[] = {
 	/* Set the frame header length to zero. */
 	BPF_STMT(BPF_LD + BPF_IMM, 0),
 	BPF_STMT(BPF_ST, BPF_M_FHLEN),
 };
 #define BPF_BOOTP_NONE_LEN	__arraycount(bpf_bootp_none)
 #endif
 static const struct bpf_insn bpf_bootp_ether[] = {
 	/* Make sure this is an IP packet. */
 	BPF_STMT(BPF_LD + BPF_H + BPF_ABS,
 	         offsetof(struct ether_header, ether_type)),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_IP, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
-	/* Load frame header length into X. */
+	/* Advance to the IP header. */
-	BPF_STMT(BPF_LDX + BPF_W + BPF_IMM, sizeof(struct ether_header)),
+	BPF_STMT(BPF_LDX + BPF_K, sizeof(struct ether_header)),
 	/* Copy frame header length to memory */
 	BPF_STMT(BPF_STX, BPF_M_FHLEN),
 };
 #define BPF_BOOTP_ETHER_LEN	__arraycount(bpf_bootp_ether)
 #define BOOTP_MIN_SIZE		sizeof(struct ip) + sizeof(struct udphdr) + \
 				sizeof(struct bootp)
 static const struct bpf_insn bpf_bootp_filter[] = {
 	/* Make sure it's an IPv4 packet. */
 	BPF_STMT(BPF_LD + BPF_B + BPF_IND, 0),
 	BPF_STMT(BPF_ALU + BPF_AND + BPF_K, 0xf0),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x40, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* Ensure IP header length is big enough and
 	 * store the IP header length in memory. */
 	BPF_STMT(BPF_LD + BPF_B + BPF_IND, 0),
 	BPF_STMT(BPF_ALU + BPF_AND + BPF_K, 0x0f),
 	BPF_STMT(BPF_ALU + BPF_MUL + BPF_K, 4),
 	BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, sizeof(struct ip), 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	BPF_STMT(BPF_ST, BPF_M_IPHLEN),
 	/* Make sure it's a UDP packet. */
 	BPF_STMT(BPF_LD + BPF_B + BPF_IND, offsetof(struct ip, ip_p)),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* Make sure this isn't a fragment. */
 	BPF_STMT(BPF_LD + BPF_H + BPF_IND, offsetof(struct ip, ip_off)),
 	BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, 0x1fff, 0, 1),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* Store IP length. */
 	BPF_STMT(BPF_LD + BPF_H + BPF_IND, offsetof(struct ip, ip_len)),
 	BPF_STMT(BPF_ST, BPF_M_IPLEN),
 	/* Advance to the UDP header. */
-	BPF_STMT(BPF_LD + BPF_MEM, BPF_M_IPHLEN),
+	BPF_STMT(BPF_LD + BPF_B + BPF_IND, 0),
 	BPF_STMT(BPF_ALU + BPF_AND + BPF_K, 0x0f),
 	BPF_STMT(BPF_ALU + BPF_MUL + BPF_K, 4),
 	BPF_STMT(BPF_ALU + BPF_ADD + BPF_X, 0),
 	BPF_STMT(BPF_MISC + BPF_TAX, 0),
 	/* Store UDP location */
 	BPF_STMT(BPF_STX, BPF_M_UDP),
 	/* Make sure it's from and to the right port. */
 	BPF_STMT(BPF_LD + BPF_W + BPF_IND, 0),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, (BOOTPS << 16) + BOOTPC, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* Store UDP length. */
 	BPF_STMT(BPF_LD + BPF_H + BPF_IND, offsetof(struct udphdr, uh_ulen)),
 	BPF_STMT(BPF_ST, BPF_M_UDPLEN),
 	/* Ensure that UDP length + IP header length == IP length */
 	/* Copy IP header length to X. */
 	BPF_STMT(BPF_LDX + BPF_MEM, BPF_M_IPHLEN),
 	/* Add UDP length (A) to IP header length (X). */
 	BPF_STMT(BPF_ALU + BPF_ADD + BPF_X, 0),
 	/* Store result in X. */
 	BPF_STMT(BPF_MISC + BPF_TAX, 0),
 	/* Copy IP length to A. */
 	BPF_STMT(BPF_LD + BPF_MEM, BPF_M_IPLEN),
 	/* Ensure X == A. */
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_X, 0, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* Advance to the BOOTP packet. */
 	BPF_STMT(BPF_LD + BPF_MEM, BPF_M_UDP),
 	BPF_STMT(BPF_ALU + BPF_ADD + BPF_K, sizeof(struct udphdr)),
 	BPF_STMT(BPF_MISC + BPF_TAX, 0),
 	/* Make sure it's BOOTREPLY. */
 	BPF_STMT(BPF_LD + BPF_B + BPF_IND, offsetof(struct bootp, op)),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, BOOTREPLY, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 };
 #define BPF_BOOTP_FILTER_LEN	__arraycount(bpf_bootp_filter)
 #define BPF_BOOTP_CHADDR_LEN	((BOOTP_CHADDR_LEN / 4) * 3)
 #define	BPF_BOOTP_XID_LEN	4 /* BOUND check is 4 instructions */
 #define BPF_BOOTP_LEN		BPF_BOOTP_ETHER_LEN + BPF_BOOTP_FILTER_LEN \
 				+ BPF_BOOTP_XID_LEN + BPF_BOOTP_CHADDR_LEN + 4
 int
 bpf_bootp(struct interface *ifp, int fd)
+{
 #if 0
 @@ -719,25 +664,19 @@ bpf_bootp(struct interface *ifp, int fd)
 		/* As we're not bound, we need to check xid to ensure
 		 * it's a reply to our transaction. */
 		BPF_SET_STMT(bp, BPF_LD + BPF_W + BPF_IND,
 		             offsetof(struct bootp, xid));
 		bp++;
 		BPF_SET_JUMP(bp, BPF_JMP + BPF_JEQ + BPF_K,
 		             state->xid, 1, 0);
 		bp++;
 		BPF_SET_STMT(bp, BPF_RET + BPF_K, 0);
 		bp++;
+	}
 #endif
-	/* All passed, return the packet - frame length + ip length */
+	/* All passed, return the packet. */
-	BPF_SET_STMT(bp, BPF_LD + BPF_MEM, BPF_M_FHLEN);
+	BPF_SET_STMT(bp, BPF_RET + BPF_K, BPF_WHOLEPACKET);
 	bp++;
 	BPF_SET_STMT(bp, BPF_LDX + BPF_MEM, BPF_M_IPLEN);
 	bp++;
 	BPF_SET_STMT(bp, BPF_ALU + BPF_ADD + BPF_X, 0);
 	bp++;
 	BPF_SET_STMT(bp, BPF_RET + BPF_A, 0);
 	bp++;
 	return bpf_attach(fd, bpf, (unsigned int)(bp - bpf));
+}

 @@ -522,33 +522,26 @@ dhcp6_delegateaddr(struct in6_addr *addr
 		TAILQ_INIT(&state->addrs);
 		state->state = DH6S_DELEGATED;
 		state->reason = "DELEGATED6";
+	}
 	if (sla == NULL || sla->sla_set == 0) {
 		/* No SLA set, so make an assumption of
 		 * desired SLA and prefix length. */
 		asla.sla = ifp->index;
 		asla.prefix_len = 0;
 		asla.sla_set = 0;
 		sla = &asla;
 	} else if (sla->sla == 0 && sla->prefix_len == 0) {
 		/* An SLA of 0 was set with no prefix length specified.
 		 * This means we delegate the whole prefix. */
 		asla.sla = sla->sla;
 		asla.prefix_len = prefix->prefix_len;
 		asla.sla_set = 0;
 		sla = &asla;
 	} else if (sla->prefix_len == 0) {
 		/* An SLA was given, but prefix length was not.
 		 * We need to work out a suitable prefix length for
 		 * potentially more than one interface. */
 		asla.sla = sla->sla;
 		asla.prefix_len = 0;
 		asla.sla_set = 0;
 		sla = &asla;
+	}
 	if (sla->prefix_len == 0) {
 		uint32_t sla_max;
 		int bits;
 @@ -670,47 +663,41 @@ dhcp6_makemessage(struct interface *ifp)
 	if (state->state != DH6S_RELEASE) {
 		for (l = 0, opt = ifp->ctx->dhcp6_opts;
 		    l < ifp->ctx->dhcp6_opts_len;
 		    l++, opt++)
+		{
 			for (n = 0, opt2 = ifo->dhcp6_override;
 			    n < ifo->dhcp6_override_len;
 			    n++, opt2++)
+			{
 				if (opt->option == opt2->option)
 					break;
+			}
 			if (n < ifo->dhcp6_override_len)
-			    continue;
+				continue;
-			if (!(opt->type & OT_NOREQ) &&
+			if (!DHC_REQOPT(opt, ifo->requestmask6, ifo->nomask6))
-			    (opt->type & OT_REQUEST ||
+				continue;
-			    has_option_mask(ifo->requestmask6, opt->option)))
+			n_options++;
 			len += sizeof(o.len);
 				n_options++;
 				len += sizeof(o.len);
+		}
 #ifndef SMALL
 		for (l = 0, opt = ifo->dhcp6_override;
 		    l < ifo->dhcp6_override_len;
 		    l++, opt++)
+		{
-			if (!(opt->type & OT_NOREQ) &&
+			if (!DHC_REQOPT(opt, ifo->requestmask6, ifo->nomask6))
-			    (opt->type & OT_REQUEST ||
+				continue;
-			    has_option_mask(ifo->requestmask6, opt->option)))
+			n_options++;
 			len += sizeof(o.len);
 				n_options++;
 				len += sizeof(o.len);
+		}
 		if (dhcp6_findselfsla(ifp)) {
 			n_options++;
 			len += sizeof(o.len);
+		}
 #endif
 		if (len)
 			len += sizeof(o);
 		if (fqdn != FQDN_DISABLE) {
 			hl = encode_rfc1035(hostname, NULL);
 			len += sizeof(o) + 1 + hl;
+		}
 @@ -1027,77 +1014,70 @@ dhcp6_makemessage(struct interface *ifp)
 			p++;
 			encode_rfc1035(hostname, p);
 			p += hl;
 			o.len = htons((uint16_t)(hl + 1));
 			memcpy(o_lenp, &o.len, sizeof(o.len));
+		}
 		if (ifo->mudurl[0])
 			COPYIN(D6_OPTION_MUDURL,
 			    ifo->mudurl + 1, ifo->mudurl[0]);
 #ifdef AUTH
 		if ((ifo->auth.options & DHCPCD_AUTH_SENDREQUIRE) !=
-		    DHCPCD_AUTH_SENDREQUIRE)
+		    DHCPCD_AUTH_SENDREQUIRE &&
 		    !has_option_mask(ifo->nomask6, D6_OPTION_RECONF_ACCEPT))
 			COPYIN1(D6_OPTION_RECONF_ACCEPT, 0);
 #endif
 		if (n_options) {
 			o_lenp = NEXTLEN;
 			o.len = 0;
 			COPYIN1(D6_OPTION_ORO, 0);
 			for (l = 0, opt = ifp->ctx->dhcp6_opts;
 			    l < ifp->ctx->dhcp6_opts_len;
 			    l++, opt++)
+			{
 #ifndef SMALL
 				for (n = 0, opt2 = ifo->dhcp6_override;
 				    n < ifo->dhcp6_override_len;
 				    n++, opt2++)
+				{
 					if (opt->option == opt2->option)
 						break;
+				}
 				if (n < ifo->dhcp6_override_len)
 				    continue;
 #endif
-				if (!(opt->type & OT_NOREQ) &&
+				if (!DHC_REQOPT(opt, ifo->requestmask6,
-				    (opt->type & OT_REQUEST ||
+				    ifo->nomask6))
-				    has_option_mask(ifo->requestmask6,
+					continue;
-				        opt->option)))
+				o.code = htons((uint16_t)opt->option);
 				memcpy(p, &o.code, sizeof(o.code));
-					o.code = htons((uint16_t)opt->option);
+				p += sizeof(o.code);
-					memcpy(p, &o.code, sizeof(o.code));
+				o.len = (uint16_t)(o.len + sizeof(o.code));
 					p += sizeof(o.code);
 					o.len = (uint16_t)
 					    (o.len + sizeof(o.code));
+			}
 #ifndef SMALL
 			for (l = 0, opt = ifo->dhcp6_override;
 			    l < ifo->dhcp6_override_len;
 			    l++, opt++)
+			{
-				if (!(opt->type & OT_NOREQ) &&
+				if (!DHC_REQOPT(opt, ifo->requestmask6,
-				    (opt->type & OT_REQUEST ||
+				    ifo->nomask6))
-				    has_option_mask(ifo->requestmask6,
+					continue;
-				        opt->option)))
+				o.code = htons((uint16_t)opt->option);
 				memcpy(p, &o.code, sizeof(o.code));
-					o.code = htons((uint16_t)opt->option);
+				p += sizeof(o.code);
-					memcpy(p, &o.code, sizeof(o.code));
+				o.len = (uint16_t)(o.len + sizeof(o.code));
 					p += sizeof(o.code);
 					o.len = (uint16_t)
 					    (o.len + sizeof(o.code));
+			}
 			if (dhcp6_findselfsla(ifp)) {
 				o.code = htons(D6_OPTION_PD_EXCLUDE);
 				memcpy(p, &o.code, sizeof(o.code));
 				p += sizeof(o.code);
 				o.len = (uint16_t)(o.len + sizeof(o.code));
+			}
 #endif
 			o.len = htons(o.len);
 			memcpy(o_lenp, &o.len, sizeof(o.len));
+		}
+	}
 @@ -2998,27 +2978,29 @@ dhcp6_bind(struct interface *ifp, const
 	case DH6S_CONFIRM:
 		if (state->reason == NULL)
 			state->reason = "REBOOT6";
 		/* FALLTHROUGH */
 	case DH6S_TIMEDOUT:
 		if (state->reason == NULL)
 			state->reason = "TIMEOUT6";
 		if (state->renew != 0) {
 			bool all_expired = true;
 			TAILQ_FOREACH(ia, &state->addrs, next) {
 				if (ia->flags & IPV6_AF_STALE)
 					continue;
-				if (ia->prefix_vltime <= state->renew)
+				if (!(state->renew == ND6_INFINITE_LIFETIME &&
 				    ia->prefix_vltime == ND6_INFINITE_LIFETIME)
 				    && ia->prefix_vltime <= state->renew)
 					logwarnx(
 					    "%s: %s will expire before renewal",
 					    ifp->name, ia->saddr);
 				else
 					all_expired = false;
+			}
 			if (all_expired) {
 				/* All address's vltime happens at or before
 				 * the configured T1 in the IA.
 				 * This is a badly configured server and we
 				 * have to use our own notion of what
 				 * T1 and T2 should be as a result.
+				 *
 @@ -3142,26 +3124,28 @@ dhcp6_bind(struct interface *ifp, const
 		if (state->expire != ND6_INFINITE_LIFETIME)
 			eloop_timeout_add_sec(ifp->ctx->eloop,
 			    (time_t)state->expire, dhcp6_startexpire, ifp);
 		else if (timed_out)
 			eloop_timeout_add_sec(ifp->ctx->eloop,
 			    (time_t)state->expire, dhcp6_startdiscover, ifp);
 		ipv6_addaddrs(&state->addrs);
 		dhcp6_deprecateaddrs(&state->addrs);
 		if (state->state == DH6S_INFORMED)
 			lognewinfo("%s: refresh in %"PRIu32" seconds",
 			    ifp->name, state->renew);
 		else if (state->renew == ND6_INFINITE_LIFETIME)
 			lognewinfo("%s: leased for infinity", ifp->name);
 		else if (state->renew || state->rebind)
 			lognewinfo("%s: renew in %"PRIu32", "
 			    "rebind in %"PRIu32", "
 			    "expire in %"PRIu32" seconds",
 			    ifp->name,
 			    state->renew, state->rebind, state->expire);
 		else if (state->expire == 0)
 			lognewinfo("%s: will expire", ifp->name);
 		else
 			lognewinfo("%s: expire in %"PRIu32" seconds",
 			    ifp->name, state->expire);
 		rt_build(ifp->ctx, AF_INET6);
 		if (!timed_out)

 @@ -978,27 +978,28 @@ make_message(struct bootp **bootpm, cons
 			p += len;
+		}
 		/* vendor is already encoded correctly, so just add it */
 		if (ifo->vendor[0]) {
 			AREA_CHECK(ifo->vendor[0]);
 			*p++ = DHO_VENDOR;
 			memcpy(p, ifo->vendor, (size_t)ifo->vendor[0] + 1);
 			p += ifo->vendor[0] + 1;
+		}
 #ifdef AUTH
 		if ((ifo->auth.options & DHCPCD_AUTH_SENDREQUIRE) !=
-		    DHCPCD_AUTH_SENDREQUIRE)
+		    DHCPCD_AUTH_SENDREQUIRE &&
 		    !has_option_mask(ifo->nomask, DHO_FORCERENEW_NONCE))
+		{
 			/* We support HMAC-MD5 */
 			AREA_CHECK(1);
 			*p++ = DHO_FORCERENEW_NONCE;
 			*p++ = 1;
 			*p++ = AUTH_ALG_HMAC_MD5;
+		}
 #endif
 		if (ifo->vivco_len) {
 			AREA_CHECK(sizeof(ul));
 			*p++ = DHO_VIVCO;
 			lp = p++;
 @@ -1022,52 +1023,46 @@ make_message(struct bootp **bootpm, cons
 				p += vivco->len;
 				*lp = (uint8_t)(*lp + vivco->len + 1);
+			}
+		}
 		AREA_CHECK(0);
 		*p++ = DHO_PARAMETERREQUESTLIST;
 		n_params = p;
 		*p++ = 0;
 		for (i = 0, opt = ifp->ctx->dhcp_opts;
 		    i < ifp->ctx->dhcp_opts_len;
 		    i++, opt++)
+		{
-			if (!(opt->type & OT_REQUEST ||
+			if (!DHC_REQOPT(opt, ifo->requestmask, ifo->nomask))
 			    has_option_mask(ifo->requestmask, opt->option)))
 				continue;
 			if (opt->type & OT_NOREQ)
 				continue;
 			if (type == DHCP_INFORM &&
 			    (opt->option == DHO_RENEWALTIME ||
 				opt->option == DHO_REBINDTIME))
 				continue;
 			AREA_FIT(1);
 			*p++ = (uint8_t)opt->option;
+		}
 		for (i = 0, opt = ifo->dhcp_override;
 		    i < ifo->dhcp_override_len;
 		    i++, opt++)
+		{
 			/* Check if added above */
 			for (lp = n_params + 1; lp < p; lp++)
 				if (*lp == (uint8_t)opt->option)
 					break;
 			if (lp < p)
 				continue;
-			if (!(opt->type & OT_REQUEST ||
+			if (!DHC_REQOPT(opt, ifo->requestmask, ifo->nomask))
 			    has_option_mask(ifo->requestmask, opt->option)))
 				continue;
 			if (opt->type & OT_NOREQ)
 				continue;
 			if (type == DHCP_INFORM &&
 			    (opt->option == DHO_RENEWALTIME ||
 				opt->option == DHO_REBINDTIME))
 				continue;
 			AREA_FIT(1);
 			*p++ = (uint8_t)opt->option;
+		}
 		*n_params = (uint8_t)(p - n_params - 1);
+	}
 #ifdef AUTH
 	auth = NULL;	/* appease GCC */
 @@ -1728,35 +1723,52 @@ send_message(struct interface *ifp, uint
 		if (ifp->carrier <= LINK_DOWN)
 			goto fail;
 		logdebugx("%s: sending %s (xid 0x%x), next in %0.1f seconds",
 		    ifp->name,
 		    ifo->options & DHCPCD_BOOTP ? "BOOTP" : get_dhcp_op(type),
 		    state->xid,
 		    timespec_to_double(&tv));
+	}
 	r = make_message(&bootp, ifp, type);
 	if (r == -1)
 		goto fail;
 	len = (size_t)r;
 	from.s_addr = bootp->ciaddr;
-	if (from.s_addr != INADDR_ANY)
+	if (ipv4_iffindaddr(ifp, &state->lease.addr, NULL) != NULL)
 		from.s_addr = state->lease.addr.s_addr;
 	else
 		from.s_addr = INADDR_ANY;
 	if (from.s_addr != INADDR_ANY &&
 	    state->lease.server.s_addr != INADDR_ANY)
 		to.s_addr = state->lease.server.s_addr;
 	else
-		to.s_addr = INADDR_ANY;
+		to.s_addr = INADDR_BROADCAST;
-	/* If unicasting, try and avoid sending by BPF so we don't
+	/*
-	 * use a L2 broadcast. */
+	 * If not listening on the unspecified address we can
-	if (to.s_addr != INADDR_ANY && to.s_addr != INADDR_BROADCAST) {
+	 * only receive broadcast messages via BPF.
 	 * Sockets bound to an address cannot receive broadcast messages
 	 * even if they are setup to send them.
 	 * Broadcasting from UDP is only an optimisation for rebinding
 	 * and on BSD, at least, is reliant on the subnet route being
 	 * correctly configured to recieve the unicast reply.
 	 * As such, we always broadcast and receive the reply to it via BPF.
 	 * This also guarantees we have a DHCP server attached to the
 	 * interface we want to configure because we can't dictate the
 	 * interface via IP_PKTINFO unlike for IPv6.
 	 */
 	if (to.s_addr != INADDR_BROADCAST)
+	{
 		if (dhcp_sendudp(ifp, &to, bootp, len) != -1)
 			goto out;
 		logerr("%s: dhcp_sendudp", ifp->name);
+	}
 	if (dhcp_openbpf(ifp) == -1)
 		goto out;
 	udp = dhcp_makeudppacket(&ulen, (uint8_t *)bootp, len, from, to);
 	if (udp == NULL) {
 		logerr("%s: dhcp_makeudppacket", ifp->name);
 		r = 0;
 	} else {
 @@ -1991,50 +2003,64 @@ dhcp_finish_dad(struct interface *ifp, s
 	if (ifp->ctx->options & DHCPCD_FORKED)
 		return;
 #ifdef IPV4LL
 	/* Stop IPv4LL now we have a working DHCP address */
 	ipv4ll_drop(ifp);
 #endif
 	if (ifp->options->options & DHCPCD_INFORM)
 		dhcp_inform(ifp);
+}
-static void
+static bool
 dhcp_addr_duplicated(struct interface *ifp, struct in_addr *ia)
+{
 	struct dhcp_state *state = D_STATE(ifp);
 	unsigned long long opts = ifp->options->options;
 	struct dhcpcd_ctx *ctx = ifp->ctx;
 	bool deleted = false;
 #ifdef IN_IFF_DUPLICATED
 	struct ipv4_addr *iap;
 #endif
 	if ((state->offer == NULL || state->offer->yiaddr != ia->s_addr) &&
 	    !IN_ARE_ADDR_EQUAL(ia, &state->lease.addr))
-		return;
+		return deleted;
 	/* RFC 2131 3.1.5, Client-server interaction */
 	logerrx("%s: DAD detected %s", ifp->name, inet_ntoa(*ia));
 	unlink(state->leasefile);
-	if (!(ifp->options->options & DHCPCD_STATIC) && !state->lease.frominfo)
+	if (!(opts & DHCPCD_STATIC) && !state->lease.frominfo)
 		dhcp_decline(ifp);
 #ifdef IN_IFF_DUPLICATED
-	if ((iap = ipv4_iffindaddr(ifp, ia, NULL)) != NULL)
+	if ((iap = ipv4_iffindaddr(ifp, ia, NULL)) != NULL) {
 		ipv4_deladdr(iap, 0);
 		deleted = true;
+	}
 #endif
-	eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
+	eloop_timeout_delete(ctx->eloop, NULL, ifp);
 	if (opts & (DHCPCD_STATIC | DHCPCD_INFORM)) {
 		state->reason = "EXPIRE";
 		script_runreason(ifp, state->reason);
 #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
 #if defined(ARP) && (!defined(KERNEL_RFC5227) || defined(ARPING))
 static void
 dhcp_arp_not_found(struct arp_state *astate)
+{
 	struct interface *ifp;
 #ifdef ARPING
 	struct dhcp_state *state;
 	struct if_options *ifo;
 #endif
 @@ -2352,27 +2378,29 @@ dhcp_arp_address(struct interface *ifp)
 	/* If the interface already has the address configured
 	 * then we can't ARP for duplicate detection. */
 	ia = ipv4_iffindaddr(ifp, &addr, NULL);
 #ifdef IN_IFF_NOTUSEABLE
 	if (ia == NULL || ia->addr_flags & IN_IFF_NOTUSEABLE) {
 		state->state = DHS_PROBE;
 		if (ia == NULL) {
 			struct dhcp_lease l;
 			get_lease(ifp, &l, state->offer, state->offer_len);
 			/* Add the address now, let the kernel handle DAD. */
 			ipv4_addaddr(ifp, &l.addr, &l.mask, &l.brd,
 			    l.leasetime, l.rebindtime);
-		} else
+		} else if (ia->addr_flags & IN_IFF_DUPLICATED)
 			dhcp_addr_duplicated(ifp, &ia->addr);
 		else
 			loginfox("%s: waiting for DAD on %s",
 			    ifp->name, inet_ntoa(addr));
 		return 0;
+	}
 #else
 	if (!(ifp->flags & IFF_NOARP) &&
 	    ifp->options->options & DHCPCD_ARP &&
 	    ia == NULL)
+	{
 		struct arp_state *astate;
 		struct dhcp_lease l;
 		astate = dhcp_arp_new(ifp, &addr);
 @@ -2831,50 +2859,56 @@ dhcp_handledhcp(struct interface *ifp, s
 #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)
 #define IS_STATE_ACTIVE(s) ((s)-state != DHS_NONE && \
 	(s)->state != DHS_INIT && (s)->state != DHS_BOUND)
 	if (bootp->op != BOOTREPLY) {
-		logdebugx("%s: op (%d) is not BOOTREPLY",
+		if (IS_STATE_ACTIVE(state))
-		    ifp->name, bootp->op);
+			logdebugx("%s: op (%d) is not BOOTREPLY",
 			    ifp->name, bootp->op);
 		return;
+	}
 	if (state->xid != ntohl(bootp->xid)) {
-		if (state->state != DHS_BOUND && state->state != DHS_NONE)
+		if (IS_STATE_ACTIVE(state))
 			logdebugx("%s: wrong xid 0x%x (expecting 0x%x) from %s",
 			    ifp->name, ntohl(bootp->xid), state->xid,
 			    inet_ntoa(*from));
 		dhcp_redirect_dhcp(ifp, bootp, bootp_len, from);
 		return;
+	}
 	if (ifp->hwlen <= sizeof(bootp->chaddr) &&
 	    memcmp(bootp->chaddr, ifp->hwaddr, ifp->hwlen))
+	{
-		char buf[sizeof(bootp->chaddr) * 3];
+		if (IS_STATE_ACTIVE(state)) {
 			char buf[sizeof(bootp->chaddr) * 3];
-		logdebugx("%s: xid 0x%x is for hwaddr %s",
+			logdebugx("%s: xid 0x%x is for hwaddr %s",
-		    ifp->name, ntohl(bootp->xid),
+			    ifp->name, ntohl(bootp->xid),
-		    hwaddr_ntoa(bootp->chaddr, sizeof(bootp->chaddr),
+			    hwaddr_ntoa(bootp->chaddr, sizeof(bootp->chaddr),
-		    buf, sizeof(buf)));
+				    buf, sizeof(buf)));
+		}
 		dhcp_redirect_dhcp(ifp, bootp, bootp_len, from);
 		return;
+	}
 	if (!ifp->active)
 		return;
 	i = whitelisted_ip(ifp->options, from->s_addr);
 	switch (i) {
 	case WHTLST_NOMATCH:
 		logwarnx("%s: non whitelisted DHCP packet from %s",
 		    ifp->name, inet_ntoa(*from));
 		return;
 @@ -2949,30 +2983,27 @@ dhcp_handledhcp(struct interface *ifp, s
 			dhcp_renew(ifp);
 		else {
 			eloop_timeout_delete(ifp->ctx->eloop,
 			    send_inform, ifp);
 			dhcp_inform(ifp);
+		}
 #else
 		LOGDHCP(logerrx, "unauthenticated Force Renew");
 #endif
 		return;
+	}
 	if (state->state == DHS_BOUND) {
-		/* Before we supported FORCERENEW we closed off the raw
+		LOGDHCP(logdebugx, "bound, ignoring");
 		 * port so we effectively ignored all messages.
 		 * As such we'll not log by default here. */
 		//LOGDHCP(logdebugx, "bound, ignoring");
 		return;
+	}
 	if (state->state == DHS_PROBE) {
 		/* Ignore any DHCP messages whilst probing a lease to bind. */
 		LOGDHCP(logdebugx, "probing, ignoring");
 		return;
+	}
 	/* reset the message counter */
 	state->interval = 0;
 	/* Ensure that no reject options are present */
 @@ -3229,180 +3260,178 @@ rapidcommit:
 static void *
 get_udp_data(void *packet, size_t *len)
+{
 	const struct ip *ip = packet;
 	size_t ip_hl = (size_t)ip->ip_hl * 4;
 	char *p = packet;
 	p += ip_hl + sizeof(struct udphdr);
 	*len = (size_t)ntohs(ip->ip_len) - sizeof(struct udphdr) - ip_hl;
 	return p;
+}
-static int
+static bool
-valid_udp_packet(void *packet, size_t plen, struct in_addr *from,
+is_packet_udp_bootp(void *packet, size_t plen)
 	unsigned int flags)
 	struct ip *ip = packet;
 	size_t ip_hlen;
 	struct udphdr *udp;
 	if (sizeof(*ip) > plen)
 		return false;
 	if (ip->ip_v != IPVERSION || ip->ip_p != IPPROTO_UDP)
 		return false;
 	/* Sanity. */
 	if (ntohs(ip->ip_len) != plen)
 		return false;
 	ip_hlen = (size_t)ip->ip_hl * 4;
 	/* Check we have a UDP header and BOOTP. */
 	if (ip_hlen + sizeof(*udp) + offsetof(struct bootp, vend) > plen)
 		return false;
 	/* Check it's to and from the right ports. */
 	udp = (struct udphdr *)(void *)((char *)ip + ip_hlen);
 	if (udp->uh_dport != htons(BOOTPC) || udp->uh_sport != htons(BOOTPS))
 		return false;
 	return true;
+}
 /* Lengths have already been checked. */
 static bool
 checksums_valid(void *packet,
     struct in_addr *from, unsigned int flags)
+{
 	struct ip *ip = packet;
 	struct ip pseudo_ip = {
 		.ip_p = IPPROTO_UDP,
 		.ip_src = ip->ip_src,
 		.ip_dst = ip->ip_dst
 	};
 	size_t ip_hlen;
-	uint16_t ip_len, udp_len, uh_sum;
+	uint16_t udp_len, uh_sum;
 	struct udphdr *udp;
 	uint32_t csum;
 	if (plen < sizeof(*ip)) {
 		if (from != NULL)
 			from->s_addr = INADDR_ANY;
 		errno = ERANGE;
 		return -1;
 	if (from != NULL)
 		from->s_addr = ip->ip_src.s_addr;
 	/* Check we have the IP header */
 	ip_hlen = (size_t)ip->ip_hl * 4;
-	if (ip_hlen > plen) {
+	if (in_cksum(ip, ip_hlen, NULL) != 0)
-		errno = ENOBUFS;
+		return false;
 		return -1;
-	if (in_cksum(ip, ip_hlen, NULL) != 0) {
+	if (flags & BPF_PARTIALCSUM)
-		errno = EINVAL;
+		return 0;
 		return -1;
 	/* Check we have a payload */
 	ip_len = ntohs(ip->ip_len);
 	if (ip_len <= ip_hlen + sizeof(*udp)) {
 		errno = ERANGE;
 		return -1;
 	/* Check IP doesn't go beyond the payload */
 	if (ip_len > plen) {
 		errno = ENOBUFS;
 		return -1;
 	/* Check UDP doesn't go beyond the payload */
 	udp = (struct udphdr *)(void *)((char *)ip + ip_hlen);
-	udp_len = ntohs(udp->uh_ulen);
+	if (udp->uh_sum == 0)
 	if (udp_len > plen - ip_hlen) {
 		errno =  ENOBUFS;
 		return -1;
 	if (udp->uh_sum == 0 || flags & BPF_PARTIALCSUM)
 		return 0;
 	/* UDP checksum is based on a pseudo IP header alongside
 	 * the UDP header and payload. */
 	udp_len = ntohs(udp->uh_ulen);
 	uh_sum = udp->uh_sum;
 	udp->uh_sum = 0;
 	pseudo_ip.ip_len = udp->uh_ulen;
 	csum = 0;
 	in_cksum(&pseudo_ip, sizeof(pseudo_ip), &csum);
 	csum = in_cksum(udp, udp_len, &csum);
-	if (csum != uh_sum) {
+	return csum == uh_sum;
 		errno = EINVAL;
 		return -1;
 	return 0;
+}
 static void
 dhcp_handlebootp(struct interface *ifp, struct bootp *bootp, size_t len,
     struct in_addr *from)
+{
 	size_t v;
 	/* udp_len must be correct because the values are checked in
 	 * valid_udp_packet(). */
 	if (len < offsetof(struct bootp, vend)) {
 		logerrx("%s: truncated packet (%zu) from %s",
 		    ifp->name, len, inet_ntoa(*from));
 		return;
+	}
 	/* To make our IS_DHCP macro easy, ensure the vendor
 	 * area has at least 4 octets. */
 	v = len - offsetof(struct bootp, vend);
 	while (v < 4) {
 		bootp->vend[v++] = '\0';
 		len++;
+	}
 	dhcp_handledhcp(ifp, bootp, len, from);
+}
 static void
-dhcp_handlepacket(struct interface *ifp, uint8_t *data, size_t len)
+dhcp_handlebpf(struct interface *ifp, uint8_t *data, size_t len)
+{
 	struct bootp *bootp;
 	struct in_addr from;
 	size_t udp_len;
 	const struct dhcp_state *state = D_CSTATE(ifp);
-	if (valid_udp_packet(data, len, &from, state->bpf_flags) == -1) {
+	/* Validate filter. */
-		const char *errstr;
+	if (!is_packet_udp_bootp(data, len)) {
 #ifdef BPF_DEBUG
 		logerrx("%s: DHCP BPF validation failure", ifp->name);
 #endif
 		return;
+	}
-		if (errno == EINVAL)
+	if (!checksums_valid(data, &from, state->bpf_flags)) {
-			errstr = "checksum failure";
+		logerrx("%s: checksum failure from %s",
-		else
+		    ifp->name, inet_ntoa(from));
 			errstr = "invalid UDP packet";
 		logerrx("%s: %s from %s", errstr, ifp->name, inet_ntoa(from));
 		return;
+	}
 	/*
 	 * DHCP has a variable option area rather than a fixed vendor area.
 	 * Because DHCP uses the BOOTP protocol it should still send BOOTP
 	 * sized packets to be RFC compliant.
 	 * However some servers send a truncated vendor area.
 	 * dhcpcd can work fine without the vendor area being sent.
 	 */
 	bootp = get_udp_data(data, &udp_len);
 	dhcp_handlebootp(ifp, bootp, udp_len, &from);
+}
 static void
-dhcp_readpacket(void *arg)
+dhcp_readbpf(void *arg)
+{
 	struct interface *ifp = arg;
 	uint8_t buf[MTU_MAX];
 	ssize_t bytes;
 	struct dhcp_state *state = D_STATE(ifp);
 	/* Some RAW mechanisms are generic file descriptors, not sockets.
 	 * This means we have no kernel call to just get one packet,
 	 * so we have to process the entire buffer. */
 	state->bpf_flags &= ~BPF_EOF;
 	state->bpf_flags |= BPF_READING;
 	while (!(state->bpf_flags & BPF_EOF)) {
 		bytes = bpf_read(ifp, state->bpf_fd, buf, sizeof(buf),
 				 &state->bpf_flags);
 		if (bytes == -1) {
 			if (state->state != DHS_NONE) {
 				logerr("%s: %s", __func__, ifp->name);
 				dhcp_close(ifp);
+			}
 			break;
+		}
-		dhcp_handlepacket(ifp, buf, (size_t)bytes);
+		dhcp_handlebpf(ifp, buf, (size_t)bytes);
 		/* Check we still have a state after processing. */
 		if ((state = D_STATE(ifp)) == NULL)
 			break;
+	}
 	if (state != NULL)
 		state->bpf_flags &= ~BPF_READING;
+}
 static void
 dhcp_readudp(struct dhcpcd_ctx *ctx, struct interface *ifp)
+{
 	const struct dhcp_state *state;
 	struct sockaddr_in from;
 @@ -3495,27 +3524,27 @@ dhcp_openbpf(struct interface *ifp)
 	state->bpf_fd = bpf_open(ifp, bpf_bootp);
 	if (state->bpf_fd == -1) {
 		if (errno == ENOENT) {
 			logerrx("%s not found", bpf_name);
 			/* May as well disable IPv4 entirely at
 			 * this point as we really need it. */
 			ifp->options->options &= ~DHCPCD_IPV4;
 		} else
 			logerr("%s: %s", __func__, ifp->name);
 		return -1;
+	}
 	eloop_event_add(ifp->ctx->eloop,
-	    state->bpf_fd, dhcp_readpacket, ifp);
+	    state->bpf_fd, dhcp_readbpf, ifp);
 	return 0;
+}
 int
 dhcp_dump(struct interface *ifp)
+{
 	struct dhcp_state *state;
 	ifp->if_data[IF_DATA_DHCP] = state = calloc(1, sizeof(*state));
 	if (state == NULL)
 		goto eexit;
 	state->bpf_fd = -1;
 	dhcp_set_leasefile(state->leasefile, sizeof(state->leasefile),
 @@ -3927,82 +3956,84 @@ dhcp_abort(struct interface *ifp)
 		state->arping_index = -1;
 #endif
 	eloop_timeout_delete(ifp->ctx->eloop, dhcp_start1, ifp);
 	if (state != NULL && state->added) {
 		rt_build(ifp->ctx, AF_INET);
 #ifdef ARP
 		arp_announceaddr(ifp->ctx, &state->addr->addr);
 #endif
+	}
+}
-void
+struct ipv4_addr *
 dhcp_handleifa(int cmd, struct ipv4_addr *ia, pid_t pid)
+{
 	struct interface *ifp;
 	struct dhcp_state *state;
 	struct if_options *ifo;
 	uint8_t i;
 	ifp = ia->iface;
 	state = D_STATE(ifp);
 	if (state == NULL || state->state == DHS_NONE)
-		return;
+		return ia;
 	if (cmd == RTM_DELADDR) {
 		if (state->addr == ia) {
 			loginfox("%s: pid %d deleted IP address %s",
 			    ifp->name, pid, ia->saddr);
 			state->addr = NULL;
 			/* Don't clear the added state as we need
 			 * to drop the lease. */
 			dhcp_drop(ifp, "EXPIRE");
 			dhcp_start1(ifp);
 			return NULL;
+		}
 		return;
+	}
 	if (cmd != RTM_NEWADDR)
-		return;
+		return ia;
 #ifdef IN_IFF_NOTUSEABLE
 	if (!(ia->addr_flags & IN_IFF_NOTUSEABLE))
 		dhcp_finish_dad(ifp, &ia->addr);
 	else if (ia->addr_flags & IN_IFF_DUPLICATED)
-		dhcp_addr_duplicated(ifp, &ia->addr);
+		return dhcp_addr_duplicated(ifp, &ia->addr) ? NULL : ia;
 #endif
 	ifo = ifp->options;
 	if (ifo->options & DHCPCD_INFORM) {
 		if (state->state != DHS_INFORM)
 			dhcp_inform(ifp);
-		return;
+		return ia;
+	}
 	if (!(ifo->options & DHCPCD_STATIC))
-		return;
+		return ia;
 	if (ifo->req_addr.s_addr != INADDR_ANY)
-		return;
+		return ia;
 	free(state->old);
 	state->old = state->new;
 	state->new_len = dhcp_message_new(&state->new, &ia->addr, &ia->mask);
 	if (state->new == NULL)
-		return;
+		return ia;
 	if (ifp->flags & IFF_POINTOPOINT) {
 		for (i = 1; i < 255; i++)
 			if (i != DHO_ROUTER && has_option_mask(ifo->dstmask,i))
 				dhcp_message_add_addr(state->new, i, ia->brd);
+	}
 	state->reason = "STATIC";
 	rt_build(ifp->ctx, AF_INET);
 	script_runreason(ifp, state->reason);
 	if (ifo->options & DHCPCD_INFORM) {
 		state->state = DHS_INFORM;
 		dhcp_new_xid(ifp);
 		state->lease.server.s_addr = INADDR_ANY;
 		state->addr = ia;
 		dhcp_inform(ifp);
+	}
 	return ia;
+}

 @@ -510,83 +510,82 @@ parse_addr(struct in_addr *addr, struct
 	return 0;
+}
 #else
 static int
 parse_addr(__unused struct in_addr *addr, __unused struct in_addr *net,
     __unused const char *arg)
+{
 	logerrx("No IPv4 support");
 	return -1;
+}
 #endif
-static const char *
+static void
 set_option_space(struct dhcpcd_ctx *ctx,
     const char *arg,
     const struct dhcp_opt **d, size_t *dl,
     const struct dhcp_opt **od, size_t *odl,
     struct if_options *ifo,
     uint8_t *request[], uint8_t *require[], uint8_t *no[], uint8_t *reject[])
+{
 #if !defined(INET) && !defined(INET6)
 	UNUSED(ctx);
 #endif
 #ifdef INET6
 	if (strncmp(arg, "nd_", strlen("nd_")) == 0) {
 		*d = ctx->nd_opts;
 		*dl = ctx->nd_opts_len;
 		*od = ifo->nd_override;
 		*odl = ifo->nd_override_len;
 		*request = ifo->requestmasknd;
 		*require = ifo->requiremasknd;
 		*no = ifo->nomasknd;
 		*reject = ifo->rejectmasknd;
-		return arg + strlen("nd_");
+		return;
+	}
 #ifdef DHCP6
 	if (strncmp(arg, "dhcp6_", strlen("dhcp6_")) == 0) {
 		*d = ctx->dhcp6_opts;
 		*dl = ctx->dhcp6_opts_len;
 		*od = ifo->dhcp6_override;
 		*odl = ifo->dhcp6_override_len;
 		*request = ifo->requestmask6;
 		*require = ifo->requiremask6;
 		*no = ifo->nomask6;
 		*reject = ifo->rejectmask6;
-		return arg + strlen("dhcp6_");
+		return;
+	}
 #endif
 #endif
 #ifdef INET
 	*d = ctx->dhcp_opts;
 	*dl = ctx->dhcp_opts_len;
 	*od = ifo->dhcp_override;
 	*odl = ifo->dhcp_override_len;
 #else
 	*d = NULL;
 	*dl = 0;
 	*od = NULL;
 	*odl = 0;
 #endif
 	*request = ifo->requestmask;
 	*require = ifo->requiremask;
 	*no = ifo->nomask;
 	*reject = ifo->rejectmask;
 	return arg;
+}
 void
 free_dhcp_opt_embenc(struct dhcp_opt *opt)
+{
 	size_t i;
 	struct dhcp_opt *o;
 	free(opt->var);
 	for (i = 0, o = opt->embopts; i < opt->embopts_len; i++, o++)
 		free_dhcp_opt_embenc(o);
 	free(opt->embopts);
 @@ -796,39 +795,39 @@ parse_option(struct dhcpcd_ctx *ctx, con
 			return -1;
+		}
 		break;
 	case 'm':
 		ARG_REQUIRED;
 		ifo->metric = (int)strtoi(arg, NULL, 0, 0, INT32_MAX, &e);
 		if (e) {
 			logerrx("failed to convert metric %s", arg);
 			return -1;
+		}
 		break;
 	case 'o':
 		ARG_REQUIRED;
-		arg = set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
+		set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
 		    &request, &require, &no, &reject);
 		if (make_option_mask(d, dl, od, odl, request, arg, 1) != 0 ||
 		    make_option_mask(d, dl, od, odl, no, arg, -1) != 0 ||
 		    make_option_mask(d, dl, od, odl, reject, arg, -1) != 0)
+		{
 			logerrx("unknown option `%s'", arg);
 			return -1;
+		}
 		break;
 	case O_REJECT:
 		ARG_REQUIRED;
-		arg = set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
+		set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
 		    &request, &require, &no, &reject);
 		if (make_option_mask(d, dl, od, odl, reject, arg, 1) != 0 ||
 		    make_option_mask(d, dl, od, odl, request, arg, -1) != 0 ||
 		    make_option_mask(d, dl, od, odl, require, arg, -1) != 0)
+		{
 			logerrx("unknown option `%s'", arg);
 			return -1;
+		}
 		break;
 	case 'p':
 		ifo->options |= DHCPCD_PERSISTENT;
 		break;
 	case 'r':
 @@ -1043,39 +1042,39 @@ parse_option(struct dhcpcd_ctx *ctx, con
 		ifo->options |= DHCPCD_BROADCAST;
 		break;
 	case 'K':
 		ifo->options &= ~DHCPCD_LINK;
 		break;
 	case 'L':
 		ifo->options &= ~DHCPCD_IPV4LL;
 		break;
 	case 'M':
 		ifo->options |= DHCPCD_MASTER;
 		break;
 	case 'O':
 		ARG_REQUIRED;
-		arg = set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
+		set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
 		    &request, &require, &no, &reject);
 		if (make_option_mask(d, dl, od, odl, request, arg, -1) != 0 ||
 		    make_option_mask(d, dl, od, odl, require, arg, -1) != 0 ||
 		    make_option_mask(d, dl, od, odl, no, arg, 1) != 0)
+		{
 			logerrx("unknown option `%s'", arg);
 			return -1;
+		}
 		break;
 	case 'Q':
 		ARG_REQUIRED;
-		arg = set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
+		set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
 		    &request, &require, &no, &reject);
 		if (make_option_mask(d, dl, od, odl, require, arg, 1) != 0 ||
 		    make_option_mask(d, dl, od, odl, request, arg, 1) != 0 ||
 		    make_option_mask(d, dl, od, odl, no, arg, -1) != 0 ||
 		    make_option_mask(d, dl, od, odl, reject, arg, -1) != 0)
+		{
 			logerrx("unknown option `%s'", arg);
 			return -1;
+		}
 		break;
 	case 'S':
 		ARG_REQUIRED;
 		p = strchr(arg, '=');
 @@ -1243,27 +1242,27 @@ parse_option(struct dhcpcd_ctx *ctx, con
 			naddr = reallocarray(ifo->arping,
 			    (size_t)ifo->arping_len + 1, sizeof(in_addr_t));
 			if (naddr == NULL) {
 				logerr(__func__);
 				return -1;
+			}
 			ifo->arping = naddr;
 			ifo->arping[ifo->arping_len++] = addr.s_addr;
 			arg = strskipwhite(fp);
+		}
 		break;
 	case O_DESTINATION:
 		ARG_REQUIRED;
-		arg = set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
+		set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
 		    &request, &require, &no, &reject);
 		if (make_option_mask(d, dl, od, odl,
 		    ifo->dstmask, arg, 2) != 0)
+		{
 			if (errno == EINVAL)
 				logerrx("option `%s' does not take"
 				    " an IPv4 address", arg);
 			else
 				logerrx("unknown option `%s'", arg);
 			return -1;
+		}
 		break;
 	case O_FALLBACK:

 @@ -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 August 28, 2019
+.Dd October 9, 2019
 .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
 @@ -193,26 +193,35 @@ options, where the same interface will n
 interface will imply Master mode which this is not.
 To force starting in Master mode with only one interface, the
 .Fl M , Fl Fl master
 option can be used.
 .Pp
 Interfaces are preferred by carrier, DHCP lease/IPv4LL and then lowest metric.
 For systems that support route metrics, each route will be tagged with the
 metric, otherwise
 .Nm
 changes the routes to use the interface with the same route and the lowest
 metric.
 See options below for controlling which interfaces we allow and deny through
 the use of patterns.
 .Pp
 Non-ethernet interfaces and some virtual ethernet interfaces
 such as TAP and bridge are ignored by default,
 as is the FireWire interface.
 To work with these devices they either need to be specified on the command line,
 be listed in
 .Fl Fl allowinterfaces
 or have an interface directive in
 .Pa @SYSCONFDIR@/dhcpcd.conf .
 .Ss Hooking into events
 .Nm
 runs
 .Pa @SCRIPT@ ,
 or the script specified by the
 .Fl c , Fl Fl script
 option.
 This script runs each script found in
 .Pa @HOOKDIR@
 in a lexical order.
 The default installation supplies the scripts
 .Pa 01-test ,
 .Pa 02-dump ,

	@@ -1084,28 +1084,33 @@ dhcpcd_handlelink(void *arg)		@@ -1084,28 +1084,33 @@ dhcpcd_handlelink(void *arg)
1084	if (errno == ENOBUFS \|\| errno == ENOMEM) {	1084	if (errno == ENOBUFS \|\| errno == ENOMEM) {
1085	dhcpcd_linkoverflow(ctx);	1085	dhcpcd_linkoverflow(ctx);
1086	return;	1086	return;
1087	}	1087	}
1088	if (errno != ENOTSUP)	1088	if (errno != ENOTSUP)
1089	logerr(__func__);	1089	logerr(__func__);
1090	}	1090	}
1091	}	1091	}
1092		1092
1093	static void	1093	static void
1094	dhcpcd_checkcarrier(void *arg)	1094	dhcpcd_checkcarrier(void *arg)
1095	{	1095	{
1096	struct interface *ifp = arg;	1096	struct interface *ifp = arg;
		1097	int carrier;
1097		1098
1098	dhcpcd_handlecarrier(ifp->ctx, LINK_UNKNOWN, ifp->flags, ifp->name);	1099	/* Check carrier here rather than setting LINK_UNKNOWN.
		1100	* This is because we force LINK_UNKNOWN as down for wireless which
		1101	* we do not want when dealing with a route socket overflow. */
		1102	carrier = if_carrier(ifp);
		1103	dhcpcd_handlecarrier(ifp->ctx, carrier, ifp->flags, ifp->name);
1099	}	1104	}
1100		1105
1101	#ifndef SMALL	1106	#ifndef SMALL
1102	static void	1107	static void
1103	dhcpcd_setlinkrcvbuf(struct dhcpcd_ctx *ctx)	1108	dhcpcd_setlinkrcvbuf(struct dhcpcd_ctx *ctx)
1104	{	1109	{
1105	socklen_t socklen;	1110	socklen_t socklen;
1106		1111
1107	if (ctx->link_rcvbuf == 0)	1112	if (ctx->link_rcvbuf == 0)
1108	return;	1113	return;
1109		1114
1110	socklen = sizeof(ctx->link_rcvbuf);	1115	socklen = sizeof(ctx->link_rcvbuf);
1111	if (setsockopt(ctx->link_fd, SOL_SOCKET,	1116	if (setsockopt(ctx->link_fd, SOL_SOCKET,

 @@ -91,26 +91,34 @@
 #include "ipv4ll.h"
 #include "ipv6.h"
 #include "ipv6nd.h"
 #include "logerr.h"
 #include "route.h"
 #include "sa.h"
 #ifndef RT_ROUNDUP
 #define RT_ROUNDUP(a)							      \
 	((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
 #define RT_ADVANCE(x, n) (x += RT_ROUNDUP((n)->sa_len))
 #endif
 /* Ignore these interface names which look like ethernet but are virtual. */
 static const char * const ifnames_ignore[] = {
 	"bridge",
 	"fwe",		/* Firewire */
 	"tap",
 	NULL
 };
 #ifdef INET6
 static void ifa_setscope(struct sockaddr_in6 *, unsigned int);
 static unsigned int ifa_getscope(const struct sockaddr_in6 *);
 #endif
 struct priv {
 	int pf_inet6_fd;
 };
 struct rtm
+{
 	struct rt_msghdr hdr;
 	char buffer[sizeof(struct sockaddr_storage) * RTAX_MAX];
 @@ -198,26 +206,81 @@ if_opensockets_os(struct dhcpcd_ctx *ctx
 	return 0;
+}
 void
 if_closesockets_os(struct dhcpcd_ctx *ctx)
+{
 	struct priv *priv;
 	priv = (struct priv *)ctx->priv;
 	if (priv->pf_inet6_fd != -1)
 		close(priv->pf_inet6_fd);
+}
 static bool
 if_ignore1(const char *drvname)
+{
 	const char * const *p;
 	for (p = ifnames_ignore; *p; p++) {
 		if (strcmp(*p, drvname) == 0)
 			return true;
+	}
 	return false;
+}
 bool
 if_ignore(struct dhcpcd_ctx *ctx, const char *ifname)
+{
 	struct if_spec spec;
 	if (if_nametospec(ifname, &spec) != 0)
 		return false;
 	if (if_ignore1(spec.drvname))
 		return true;
 #ifdef SIOCGIFGROUP
 	struct ifgroupreq ifgr = { .ifgr_len = 0 };
 	struct ifg_req *ifg;
 	size_t ifg_len;
 	/* Sadly it is possible to remove the device name
 	 * from the interface groups, but hopefully this
 	 * will be very unlikely.... */
 	strlcpy(ifgr.ifgr_name, ifname, sizeof(ifgr.ifgr_name));
 	if (ioctl(ctx->pf_inet_fd, SIOCGIFGROUP, &ifgr) == -1 ||
 	    (ifgr.ifgr_groups = malloc(ifgr.ifgr_len)) == NULL ||
 	    ioctl(ctx->pf_inet_fd, SIOCGIFGROUP, &ifgr) == -1)
+	{
 		logerr(__func__);
 		return false;
+	}
 	for (ifg = ifgr.ifgr_groups, ifg_len = ifgr.ifgr_len;
 	     ifg && ifg_len >= sizeof(*ifg);
 	     ifg++, ifg_len -= sizeof(*ifg))
+	{
 		if (if_ignore1(ifg->ifgrq_group))
 			return true;
+	}
 #else
 	UNUSED(ctx);
 #endif
 	return false;
+}
 int
 if_carrier(struct interface *ifp)
+{
 	struct ifmediareq ifmr = { .ifm_status = 0 };
 	strlcpy(ifmr.ifm_name, ifp->name, sizeof(ifmr.ifm_name));
 	if (ioctl(ifp->ctx->pf_inet_fd, SIOCGIFMEDIA, &ifmr) == -1 ||
 	    !(ifmr.ifm_status & IFM_AVALID))
 		return LINK_UNKNOWN;
 	return (ifmr.ifm_status & IFM_ACTIVE) ? LINK_UP : LINK_DOWN;
+}