 @@ -98,27 +98,27 @@ bpf_frame_header_len(const struct interf
 const char *bpf_name = "Berkley Packet Filter";
 int
 bpf_open(struct interface *ifp, int (*filter)(struct interface *, int))
+{
 	struct ipv4_state *state;
 	int fd = -1;
 	struct ifreq ifr;
 	int ibuf_len = 0;
 	size_t buf_len;
 	struct bpf_version pv;
 #ifdef BIOCIMMEDIATE
-	int flags;
+	unsigned int flags;
 #endif
 #ifndef O_CLOEXEC
 	int fd_opts;
 #endif
 #ifdef _PATH_BPF
 	fd = open(_PATH_BPF, O_RDWR | O_NONBLOCK
 #ifdef O_CLOEXEC
 		| O_CLOEXEC
 #endif
 	);
 #else
 	char device[32];
 @@ -401,27 +401,27 @@ static const struct bpf_insn bpf_arp_eth
 	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),
 	/* Make sure the hardware length matches. */
 	BPF_STMT(BPF_LD + BPF_B + BPF_IND, offsetof(struct arphdr, ar_hln)),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K,
-	         sizeof((struct ether_arp *)0)->arp_sha, 1, 0),
+	         sizeof(((struct ether_arp *)0)->arp_sha), 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 };
 #define bpf_arp_ether_len	__arraycount(bpf_arp_ether)
 static const struct bpf_insn bpf_arp_filter [] = {
 	/* Make sure this is for IP. */
 	BPF_STMT(BPF_LD + BPF_H + BPF_IND, offsetof(struct arphdr, ar_pro)),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_IP, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* Make sure this is an ARP REQUEST. */
 	BPF_STMT(BPF_LD + BPF_H + BPF_IND, offsetof(struct arphdr, ar_op)),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REQUEST, 2, 0),
 	/* or ARP REPLY. */
 @@ -530,27 +530,27 @@ static const struct bpf_insn bpf_bootp_e
 	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. */
 	BPF_STMT(BPF_LDX + BPF_W + BPF_IMM, sizeof(struct ether_header)),
 	/* Copy to M0. */
 	BPF_STMT(BPF_STX, 0),
 };
 #define BPF_BOOTP_ETHER_LEN	__arraycount(bpf_bootp_ether)
 static const struct bpf_insn bpf_bootp_filter[] = {
-	/* Make sure it's an IPv4 packet. */
+	/* Make sure it's an optionless IPv4 packet. */
 	BPF_STMT(BPF_LD + BPF_B + BPF_IND, 0),
 	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x45, 1, 0),
 	BPF_STMT(BPF_RET + BPF_K, 0),
 	/* 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),

 @@ -3266,41 +3266,47 @@ get_udp_data(void *udp, size_t *len)
 	p = (struct bootp_pkt *)udp;
 	*len = ntohs(p->ip.ip_len) - sizeof(p->ip) - sizeof(p->udp);
 	return (char *)udp + offsetof(struct bootp_pkt, bootp);
+}
 static int
 valid_udp_packet(void *data, size_t data_len, struct in_addr *from,
     int noudpcsum)
+{
 	struct bootp_pkt *p;
 	uint16_t bytes;
-	if (data_len < sizeof(p->ip) + sizeof(p->udp)) {
+	if (data_len < sizeof(p->ip)) {
 		if (from)
 			from->s_addr = INADDR_ANY;
 		errno = ERANGE;
 		return -1;
+	}
 	p = (struct bootp_pkt *)data;
 	if (from)
 		from->s_addr = p->ip.ip_src.s_addr;
 	if (checksum(&p->ip, sizeof(p->ip)) != 0) {
 		errno = EINVAL;
 		return -1;
+	}
 	bytes = ntohs(p->ip.ip_len);
 	/* Check we have a payload */
 	if (bytes <= sizeof(p->ip) + sizeof(p->udp)) {
 		errno = ERANGE;
 		return -1;
+	}
 	/* Check we don't go beyond the payload */
 	if (bytes > data_len) {
 		errno = ENOBUFS;
 		return -1;
+	}
 	if (noudpcsum == 0) {
 		uint16_t udpsum, iplen;
 		/* This does scribble on the packet, but at this point
 		 * we don't care to keep it. */
 		iplen = p->ip.ip_len;
 		udpsum = p->udp.uh_sum;
 		p->udp.uh_sum = 0;
 @@ -3324,27 +3330,27 @@ valid_udp_packet(void *data, size_t data
 static void
 dhcp_handlepacket(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 & RAW_PARTIALCSUM) == -1)
+	{
 		if (errno == EINVAL)
-			logerrx("%s: UDP checksum failure from %s",
+			logerrx("%s: checksum failure from %s",
 			  ifp->name, inet_ntoa(from));
 		else
 			logerr("%s: invalid UDP packet from %s",
 			  ifp->name, inet_ntoa(from));
 		return;
+	}
 	if (ifp->flags & IFF_POINTOPOINT &&
 	    (state->addr == NULL || state->addr->brd.s_addr != from.s_addr))
+	{
 		logwarnx("%s: server %s is not destination",
 		    ifp->name, inet_ntoa(from));
+	}

 @@ -1350,39 +1350,36 @@ parse_option(struct dhcpcd_ctx *ctx, con
 		if (arg) {
 			p = strchr(arg, '/');
 			if (p)
 				*p++ = '\0';
 			if (parse_iaid(iaid, arg, sizeof(iaid)) == -1) {
 				logerr("invalid IAID: %s", arg);
 				return -1;
+			}
+		}
 		ia = NULL;
 		for (sl = 0; sl < ifo->ia_len; sl++) {
 			if ((arg == NULL && !ifo->ia[sl].iaid_set) ||
 			    (arg != NULL && ifo->ia[sl].iaid_set &&
 			    ifo->ia[sl].ia_type == (uint16_t)i &&
 			    ifo->ia[sl].iaid[0] == iaid[0] &&
 			    ifo->ia[sl].iaid[1] == iaid[1] &&
 			    ifo->ia[sl].iaid[2] == iaid[2] &&
 			    ifo->ia[sl].iaid[3] == iaid[3]))
+			{
 			        ia = &ifo->ia[sl];
 				break;
+			}
+		}
 		if (ia && ia->ia_type != (uint16_t)i) {
 			logerrx("Cannot mix IA for the same IAID");
 			break;
 		if (ia == NULL) {
 			ia = reallocarray(ifo->ia,
 			    ifo->ia_len + 1, sizeof(*ifo->ia));
 			if (ia == NULL) {
 				logerr(__func__);
 				return -1;
+			}
 			ifo->ia = ia;
 			ia = &ifo->ia[ifo->ia_len++];
 			ia->ia_type = (uint16_t)i;
 			if (arg) {
 				ia->iaid[0] = iaid[0];
 				ia->iaid[1] = iaid[1];

 @@ -760,40 +760,43 @@ dhcpcd_handlecarrier(struct dhcpcd_ctx *
 			/* Set any IPv6 Routers we remembered to expire
 			 * faster than they would normally as we
 			 * maybe on a new network. */
 			ipv6nd_expire(ifp, RTR_CARRIER_EXPIRE);
 #endif
 			/* RFC4941 Section 3.5 */
 			ipv6_gentempifid(ifp);
 			dhcpcd_startinterface(ifp);
+		}
+	}
+}
 static void
-warn_iaid_conflict(struct interface *ifp, uint8_t *iaid)
+warn_iaid_conflict(struct interface *ifp, uint16_t ia_type, uint8_t *iaid)
+{
 	struct interface *ifn;
 	size_t i;
 	struct if_ia *ia;
 	TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) {
 		if (ifn == ifp || !ifn->active)
 			continue;
-		if (memcmp(ifn->options->iaid, iaid,
+		if (ia_type == 0 &&
 		    memcmp(ifn->options->iaid, iaid,
 		    sizeof(ifn->options->iaid)) == 0)
 			break;
 		for (i = 0; i < ifn->options->ia_len; i++) {
-			if (memcmp(&ifn->options->ia[i].iaid, iaid,
+			ia = &ifn->options->ia[i];
-			    sizeof(ifn->options->ia[i].iaid)) == 0)
+			if (ia->ia_type == ia_type &&
 			    memcmp(ia->iaid, iaid, sizeof(ia->iaid)) == 0)
 				break;
+		}
+	}
 	/* This is only a problem if the interfaces are on the same network. */
 	if (ifn)
 		logerrx("%s: IAID conflicts with one assigned to %s",
 		    ifp->name, ifn->name);
+}
 void
 dhcpcd_startinterface(void *arg)
+{
 @@ -829,40 +832,41 @@ dhcpcd_startinterface(void *arg)
 	if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6)) {
 		/* Report client DUID */
 		if (ifp->ctx->duid == NULL) {
 			if (duid_init(ifp) == 0)
 				return;
 			loginfox("DUID %s",
 			    hwaddr_ntoa(ifp->ctx->duid,
 			    ifp->ctx->duid_len,
 			    buf, sizeof(buf)));
+		}
+	}
 	if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6)) {
 		struct if_ia *ia;
 		/* Report IAIDs */
 		loginfox("%s: IAID %s", ifp->name,
 		    hwaddr_ntoa(ifo->iaid, sizeof(ifo->iaid),
 		    buf, sizeof(buf)));
-		warn_iaid_conflict(ifp, ifo->iaid);
+		warn_iaid_conflict(ifp, 0, ifo->iaid);
 		for (i = 0; i < ifo->ia_len; i++) {
-			if (memcmp(ifo->iaid, ifo->ia[i].iaid,
+			ia = &ifo->ia[i];
-			    sizeof(ifo->iaid)))
+			if (memcmp(ifo->iaid, ia->iaid, sizeof(ifo->iaid))) {
 				loginfox("%s: IA type %u IAID %s",
-				loginfox("%s: IAID %s",
+				    ifp->name, ia->ia_type,
-				    ifp->name, hwaddr_ntoa(ifo->ia[i].iaid,
+				    hwaddr_ntoa(ia->iaid, sizeof(ia->iaid),
 				    sizeof(ifo->ia[i].iaid),
 				    buf, sizeof(buf)));
-				warn_iaid_conflict(ifp, ifo->ia[i].iaid);
+				warn_iaid_conflict(ifp, ia->ia_type, ia->iaid);
+			}
+		}
+	}
 	if (ifo->options & DHCPCD_IPV6 && ipv6_start(ifp) == -1) {
 		logerr("%s: ipv6_start", ifp->name);
 		ifo->options &= ~DHCPCD_IPV6;
+	}
 	if (ifo->options & DHCPCD_IPV6) {
 		if (ifp->active == IF_ACTIVE_USER) {
 			ipv6_startstatic(ifp);
 			if (ifo->options & DHCPCD_IPV6RS)