X-Git-Url: https://git.decadent.org.uk/gitweb/?p=odhcp6c.git;a=blobdiff_plain;f=src%2Fra.c;h=1c121e63e3f8153064886293b3b8d5bcc72533b0;hp=e32670ecbba0124b8629d6205df36fb07149ea93;hb=d21764d12bb799f89d42c94dc20d4adb6d588077;hpb=18c1cff36bd3b36b80321282fa7086d8752b63cc

diff --git a/src/ra.c b/src/ra.c
index e32670e..1c121e6 100644
--- a/src/ra.c
+++ b/src/ra.c
@@ -1,36 +1,108 @@
+/**
+ * Copyright (C) 2012-2014 Steven Barth <steven@midlink.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License v2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
 #include <fcntl.h>
 #include <stdio.h>
 #include <signal.h>
 #include <string.h>
 #include <stddef.h>
 #include <stdbool.h>
+#include <syslog.h>
 #include <unistd.h>
+#include <resolv.h>
+#include <alloca.h>
 
 #include <net/if.h>
+#include <arpa/inet.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 #include <netinet/in.h>
 #include <netinet/icmp6.h>
 
 #include <linux/rtnetlink.h>
 
+#ifndef SOL_NETLINK
+#define SOL_NETLINK 270
+#endif
+
+#ifndef NETLINK_ADD_MEMBERSHIP
+#define NETLINK_ADD_MEMBERSHIP 1
+#endif
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP 0x10000
+#endif
 
 #include "odhcp6c.h"
 #include "ra.h"
 
 
-static int sock = -1, rtnl_sock = -1;
-static unsigned if_index = 0;
+static bool nocarrier = false;
+
+static int sock = -1, rtnl = -1;
+static int if_index = 0;
 static char if_name[IF_NAMESIZE] = {0};
 static volatile int rs_attempt = 0;
 static struct in6_addr lladdr = IN6ADDR_ANY_INIT;
 
+struct {
+	struct icmp6_hdr hdr;
+	struct icmpv6_opt lladdr;
+} rs = {
+	.hdr = {ND_ROUTER_SOLICIT, 0, 0, {{0}}},
+	.lladdr = {ND_OPT_SOURCE_LINKADDR, 1, {0}},
+};
+
+
 static void ra_send_rs(int signal __attribute__((unused)));
 
-int ra_init(const char *ifname)
+int ra_init(const char *ifname, const struct in6_addr *ifid)
 {
+	const pid_t ourpid = getpid();
 	sock = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
+	if (sock < 0)
+		return -1;
+
 	if_index = if_nametoindex(ifname);
+	if (!if_index)
+		return -1;
+
 	strncpy(if_name, ifname, sizeof(if_name) - 1);
+	lladdr = *ifid;
+
+	rtnl = socket(AF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
+	if (rtnl < 0)
+		return -1;
+
+	struct sockaddr_nl rtnl_kernel = { .nl_family = AF_NETLINK };
+	if (connect(rtnl, (const struct sockaddr*)&rtnl_kernel, sizeof(rtnl_kernel)) < 0)
+		return -1;
+
+	int val = RTNLGRP_LINK;
+	setsockopt(rtnl, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &val, sizeof(val));
+	fcntl(rtnl, F_SETOWN, ourpid);
+	fcntl(rtnl, F_SETFL, fcntl(sock, F_GETFL) | O_ASYNC);
+
+	struct {
+		struct nlmsghdr hdr;
+		struct ifinfomsg ifi;
+	} req = {
+		.hdr = {sizeof(req), RTM_GETLINK, NLM_F_REQUEST, 1, 0},
+		.ifi = {.ifi_index = if_index}
+	};
+	send(rtnl, &req, sizeof(req), 0);
+	ra_link_up();
 
 	// Filter ICMPv6 package types
 	struct icmp6_filter filt;
@@ -43,46 +115,24 @@ int ra_init(const char *ifname)
 	setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &an, sizeof(an));
 
 	// Let the kernel compute our checksums
-	int val = 2;
+	val = 2;
 	setsockopt(sock, IPPROTO_RAW, IPV6_CHECKSUM, &val, sizeof(val));
 
 	// This is required by RFC 4861
 	val = 255;
 	setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val, sizeof(val));
 
+	// Receive multicast hops
+	val = 1;
+	setsockopt(sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &val, sizeof(val));
+
 	// Bind to one device
 	setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname));
 
 	// Add async-mode
-	const pid_t ourpid = getpid();
 	fcntl(sock, F_SETOWN, ourpid);
 	fcntl(sock, F_SETFL, fcntl(sock, F_GETFL) | O_ASYNC);
 
-	// Get LL-addr
-	FILE *fp = fopen("/proc/net/if_inet6", "r");
-	if (fp) {
-		char addrbuf[33], ifbuf[16];
-		while (fscanf(fp, "%32s %*x %*x %*x %*x %15s", addrbuf, ifbuf) == 2) {
-			if (!strcmp(ifbuf, if_name)) {
-				script_unhexlify((uint8_t*)&lladdr, sizeof(lladdr), addrbuf);
-				break;
-			}
-		}
-		fclose(fp);
-	}
-
-	// Open rtnetlink socket
-	rtnl_sock = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
-	struct sockaddr_nl rtnl_kernel = { .nl_family = AF_NETLINK };
-	if (connect(rtnl_sock, (struct sockaddr*)&rtnl_kernel, sizeof(rtnl_kernel)))
-		return -1;
-	uint32_t group = RTNLGRP_IPV6_IFADDR;
-	setsockopt(rtnl_sock, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &group, sizeof(group));
-
-	// Add async-mode
-	fcntl(rtnl_sock, F_SETOWN, ourpid);
-	fcntl(rtnl_sock, F_SETFL, fcntl(rtnl_sock, F_GETFL) | O_ASYNC);
-
 	// Send RS
 	signal(SIGALRM, ra_send_rs);
 	ra_send_rs(SIGALRM);
@@ -93,9 +143,16 @@ int ra_init(const char *ifname)
 
 static void ra_send_rs(int signal __attribute__((unused)))
 {
-	const struct icmp6_hdr rs = {ND_ROUTER_SOLICIT, 0, 0, {{0}}};
 	const struct sockaddr_in6 dest = {AF_INET6, 0, 0, ALL_IPV6_ROUTERS, if_index};
-	sendto(sock, &rs, sizeof(rs), MSG_DONTWAIT, (struct sockaddr*)&dest, sizeof(dest));
+	const struct icmpv6_opt llnull = {ND_OPT_SOURCE_LINKADDR, 1, {0}};
+	size_t len;
+
+	if ((rs_attempt % 2 == 0) && memcmp(&rs.lladdr, &llnull, sizeof(llnull)))
+		len = sizeof(rs);
+	else
+		len = sizeof(struct icmp6_hdr);
+
+	sendto(sock, &rs, len, MSG_DONTWAIT, (struct sockaddr*)&dest, sizeof(dest));
 
 	if (++rs_attempt <= 3)
 		alarm(4);
@@ -105,85 +162,165 @@ static void ra_send_rs(int signal __attribute__((unused)))
 static int16_t pref_to_priority(uint8_t flags)
 {
 	flags = (flags >> 3) & 0x03;
-	return (flags == 0x0) ? 1024 : (flags == 0x1) ? 512 :
-			(flags == 0x3) ? 2048 : -1;
+	return (flags == 0x0) ? 512 : (flags == 0x1) ? 384 :
+			(flags == 0x3) ? 640 : -1;
 }
 
 
-static void update_proc(const char *sect, const char *opt, uint32_t value)
+bool ra_link_up(void)
 {
-	char buf[64];
-	snprintf(buf, sizeof(buf), "/proc/sys/net/ipv6/%s/%s/%s", sect, if_name, opt);
+	static bool firstcall = true;
+	struct {
+		struct nlmsghdr hdr;
+		struct ifinfomsg msg;
+		uint8_t pad[4000];
+	} resp;
+
+	bool ret = false;
+	ssize_t read;
+
+	do {
+		read = recv(rtnl, &resp, sizeof(resp), MSG_DONTWAIT);
+		if (read < 0 || !NLMSG_OK(&resp.hdr, (size_t)read) ||
+				resp.hdr.nlmsg_type != RTM_NEWLINK ||
+				resp.msg.ifi_index != if_index)
+			continue;
 
-	int fd = open(buf, O_WRONLY);
-	write(fd, buf, snprintf(buf, sizeof(buf), "%u", value));
-	close(fd);
-}
+		ssize_t alen = NLMSG_PAYLOAD(&resp.hdr, sizeof(resp.msg));
+		for (struct rtattr *rta = (struct rtattr*)(resp.pad);
+				RTA_OK(rta, alen); rta = RTA_NEXT(rta, alen)) {
+			if (rta->rta_type == IFLA_ADDRESS &&
+					RTA_PAYLOAD(rta) >= sizeof(rs.lladdr.data))
+				memcpy(rs.lladdr.data, RTA_DATA(rta), sizeof(rs.lladdr.data));
+		}
+
+		bool hascarrier = resp.msg.ifi_flags & IFF_LOWER_UP;
+		if (!firstcall && nocarrier != !hascarrier)
+			ret = true;
 
+		nocarrier = !hascarrier;
+		firstcall = false;
+	} while (read > 0);
 
-static bool ra_deduplicate(const struct in6_addr *any, uint8_t length)
+	if (ret) {
+		syslog(LOG_NOTICE, "carrier => %i event on %s", (int)!nocarrier, if_name);
+
+		rs_attempt = 0;
+		ra_send_rs(SIGALRM);
+	}
+
+	return ret;
+}
+
+static bool ra_icmpv6_valid(struct sockaddr_in6 *source, int hlim, uint8_t *data, size_t len)
 {
-	struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT, length, 0, *any, 0, 0};
-	struct odhcp6c_entry *x = odhcp6c_find_entry(STATE_RA_PREFIX, &entry);
-	if (x) {
-		odhcp6c_random(&x->target.s6_addr32[2], 2 * sizeof(uint32_t));
-	} else if (odhcp6c_find_entry(STATE_IA_NA, &entry)) {
-		dhcpv6_request(DHCPV6_MSG_DECLINE);
-		raise(SIGUSR2);
+	struct icmp6_hdr *hdr = (struct icmp6_hdr*)data;
+	struct icmpv6_opt *opt, *end = (struct icmpv6_opt*)&data[len];
+
+	if (hlim != 255 || len < sizeof(*hdr) || hdr->icmp6_code)
+		return false;
+
+	switch (hdr->icmp6_type) {
+	case ND_ROUTER_ADVERT:
+		if (!IN6_IS_ADDR_LINKLOCAL(&source->sin6_addr))
+			return false;
+
+		opt = (struct icmpv6_opt*)((struct nd_router_advert*)data + 1);
+		break;
+
+	default:
+		return false;
 	}
 
-	return !!x;
+	icmpv6_for_each_option(opt, opt, end)
+		;
+
+	return opt == end;
 }
 
+int ra_conf_hoplimit(int newvalue)
+{
+	static int value = 0;
+	if (newvalue > 0)
+		value = newvalue;
+	return value;
+}
 
-bool ra_rtnl_process(void)
+int ra_conf_mtu(int newvalue)
 {
-	bool found = false;
-	uint8_t buf[8192];
-	while (true) {
-		ssize_t len = recv(rtnl_sock, buf, sizeof(buf), MSG_DONTWAIT);
-		if (len < 0)
-			break;
+	static int value = 0;
+	if (newvalue >= 1280 && newvalue <= 65535)
+		value = newvalue;
+	return value;
+}
 
-		for (struct nlmsghdr *nh = (struct nlmsghdr*)buf; NLMSG_OK(nh, (size_t)len);
-					nh = NLMSG_NEXT(nh, len)) {
-			struct ifaddrmsg *ifa = NLMSG_DATA(nh);
-			struct in6_addr *addr = NULL;
-			if (NLMSG_PAYLOAD(nh, 0) < sizeof(*ifa) || ifa->ifa_index != if_index ||
-					(nh->nlmsg_type == RTM_NEWADDR && !(ifa->ifa_flags & IFA_F_DADFAILED)) ||
-					(nh->nlmsg_type == RTM_DELADDR && !(ifa->ifa_flags & IFA_F_TENTATIVE)))
-				continue;
-
-			ssize_t alen = NLMSG_PAYLOAD(nh, sizeof(*ifa));
-			for (struct rtattr *rta = (struct rtattr*)&ifa[1]; RTA_OK(rta, alen);
-					rta = RTA_NEXT(rta, alen))
-				if (rta->rta_type == IFA_ADDRESS && RTA_PAYLOAD(rta) >= sizeof(*addr))
-					addr = RTA_DATA(rta);
-
-			if (addr)
-				found |= ra_deduplicate(addr, ifa->ifa_prefixlen);
-		}
-	}
-	return found;
+int ra_conf_reachable(int newvalue)
+{
+	static int value = 0;
+	if (newvalue > 0 && newvalue <= 3600000)
+		value = newvalue;
+	return value;
 }
 
+int ra_conf_retransmit(int newvalue)
+{
+	static int value = 0;
+	if (newvalue > 0 && newvalue <= 60000)
+		value = newvalue;
+	return value;
+}
 
 bool ra_process(void)
 {
 	bool found = false;
-	uint8_t buf[1500];
+	bool changed = false;
+	uint8_t buf[1500], cmsg_buf[128];
 	struct nd_router_advert *adv = (struct nd_router_advert*)buf;
-	struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT, 0, 0, IN6ADDR_ANY_INIT, 0, 0};
+	struct odhcp6c_entry *entry = alloca(sizeof(*entry) + 256);
 	const struct in6_addr any = IN6ADDR_ANY_INIT;
-	odhcp6c_expire();
+
+	memset(entry, 0, sizeof(*entry));
+
+	if (IN6_IS_ADDR_UNSPECIFIED(&lladdr)) {
+		struct sockaddr_in6 addr = {AF_INET6, 0, 0, ALL_IPV6_ROUTERS, if_index};
+		socklen_t alen = sizeof(addr);
+		int sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
+
+		if (!connect(sock, (struct sockaddr*)&addr, sizeof(addr)) &&
+				!getsockname(sock, (struct sockaddr*)&addr, &alen))
+			lladdr = addr.sin6_addr;
+
+		close(sock);
+	}
 
 	while (true) {
 		struct sockaddr_in6 from;
-		socklen_t from_len = sizeof(from);
-		ssize_t len = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT, &from, &from_len);
-		if (len < 0)
+		struct iovec iov = {buf, sizeof(buf)};
+		struct msghdr msg = {
+			.msg_name = (void *) &from,
+			.msg_namelen = sizeof(from),
+			.msg_iov = &iov,
+			.msg_iovlen = 1,
+			.msg_control = cmsg_buf,
+			.msg_controllen = sizeof(cmsg_buf),
+			.msg_flags = 0
+		};
+
+		ssize_t len = recvmsg(sock, &msg, MSG_DONTWAIT);
+		if (len <= 0)
 			break;
-		else if (len < (ssize_t)sizeof(*adv))
+
+		if (IN6_IS_ADDR_UNSPECIFIED(&lladdr))
+			continue;
+
+		int hlim = 0;
+		for (struct cmsghdr *ch = CMSG_FIRSTHDR(&msg); ch != NULL;
+				ch = CMSG_NXTHDR(&msg, ch))
+			if (ch->cmsg_level == IPPROTO_IPV6 &&
+					ch->cmsg_type == IPV6_HOPLIMIT)
+				memcpy(&hlim, CMSG_DATA(ch), sizeof(hlim));
+
+		if (!ra_icmpv6_valid(&from, hlim, buf, len))
 			continue;
 
 		// Stop sending solicits
@@ -192,95 +329,131 @@ bool ra_process(void)
 			rs_attempt = 0;
 		}
 
-		found = true;
+		if (!found) {
+			odhcp6c_expire();
+			found = true;
+		}
 		uint32_t router_valid = ntohs(adv->nd_ra_router_lifetime);
 
 		// Parse default route
-		entry.router = from.sin6_addr;
-		entry.priority = pref_to_priority(adv->nd_ra_flags_reserved);
-		if (entry.priority < 0)
-			entry.priority = pref_to_priority(0);
-		entry.valid = router_valid;
-		entry.preferred = entry.valid;
-		odhcp6c_update_entry(STATE_RA_ROUTE, &entry);
+		entry->target = any;
+		entry->length = 0;
+		entry->router = from.sin6_addr;
+		entry->priority = pref_to_priority(adv->nd_ra_flags_reserved);
+		if (entry->priority < 0)
+			entry->priority = pref_to_priority(0);
+		entry->valid = router_valid;
+		entry->preferred = entry->valid;
+		changed |= odhcp6c_update_entry(STATE_RA_ROUTE, entry, 0, true);
+
+		// Parse hoplimit
+		ra_conf_hoplimit(adv->nd_ra_curhoplimit);
 
 		// Parse ND parameters
-		if (adv->nd_ra_reachable)
-			update_proc("neigh", "base_reachable_time_ms", ntohl(adv->nd_ra_reachable));
-
-		if (adv->nd_ra_retransmit)
-			update_proc("neigh", "retrans_time_ms", ntohl(adv->nd_ra_retransmit));
-
+		ra_conf_reachable(ntohl(adv->nd_ra_reachable));
+		ra_conf_retransmit(ntohl(adv->nd_ra_retransmit));
 
 		// Evaluate options
 		struct icmpv6_opt *opt;
 		icmpv6_for_each_option(opt, &adv[1], &buf[len]) {
 			if (opt->type == ND_OPT_MTU) {
-				update_proc("conf", "mtu", ntohl(*((uint32_t*)&opt->data[2])));
+				uint32_t *mtu = (uint32_t*)&opt->data[2];
+				ra_conf_mtu(ntohl(*mtu));
 			} else if (opt->type == ND_OPT_ROUTE_INFORMATION && opt->len <= 3) {
-				entry.router = from.sin6_addr;
-				entry.target = any;
-				entry.priority = pref_to_priority(opt->data[1]);
-				entry.length = opt->data[0];
-				entry.valid = ntohl(*((uint32_t*)&opt->data[2]));
-				memcpy(&entry.target, &opt->data[6], (opt->len - 1) * 8);
-
-				if (entry.length > 128 || IN6_IS_ADDR_LINKLOCAL(&entry.target)
-						|| IN6_IS_ADDR_LOOPBACK(&entry.target)
-						|| IN6_IS_ADDR_MULTICAST(&entry.target))
+				entry->router = from.sin6_addr;
+				entry->target = any;
+				entry->priority = pref_to_priority(opt->data[1]);
+				entry->length = opt->data[0];
+				uint32_t *valid = (uint32_t*)&opt->data[2];
+				entry->valid = ntohl(*valid);
+				memcpy(&entry->target, &opt->data[6], (opt->len - 1) * 8);
+
+				if (entry->length > 128 || IN6_IS_ADDR_LINKLOCAL(&entry->target)
+						|| IN6_IS_ADDR_LOOPBACK(&entry->target)
+						|| IN6_IS_ADDR_MULTICAST(&entry->target))
 					continue;
 
-				if (entry.priority > 0)
-					odhcp6c_update_entry(STATE_RA_ROUTE, &entry);
+				if (entry->priority > 0)
+					changed |= odhcp6c_update_entry(STATE_RA_ROUTE, entry, 0, true);
 			} else if (opt->type == ND_OPT_PREFIX_INFORMATION && opt->len == 4) {
 				struct nd_opt_prefix_info *pinfo = (struct nd_opt_prefix_info*)opt;
-				entry.router = any;
-				entry.target = pinfo->nd_opt_pi_prefix;
-				entry.priority = 0;
-				entry.length = pinfo->nd_opt_pi_prefix_len;
-				entry.valid = ntohl(pinfo->nd_opt_pi_valid_time);
-				entry.preferred = ntohl(pinfo->nd_opt_pi_preferred_time);
-
-				if (entry.length > 128 || IN6_IS_ADDR_LINKLOCAL(&entry.target)
-						|| IN6_IS_ADDR_LOOPBACK(&entry.target)
-						|| IN6_IS_ADDR_MULTICAST(&entry.target)
-						|| entry.valid < entry.preferred)
+				entry->router = any;
+				entry->target = pinfo->nd_opt_pi_prefix;
+				entry->priority = 256;
+				entry->length = pinfo->nd_opt_pi_prefix_len;
+				entry->valid = ntohl(pinfo->nd_opt_pi_valid_time);
+				entry->preferred = ntohl(pinfo->nd_opt_pi_preferred_time);
+
+				if (entry->length > 128 || IN6_IS_ADDR_LINKLOCAL(&entry->target)
+						|| IN6_IS_ADDR_LOOPBACK(&entry->target)
+						|| IN6_IS_ADDR_MULTICAST(&entry->target)
+						|| entry->valid < entry->preferred)
 					continue;
 
 				if (pinfo->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ONLINK)
-					odhcp6c_update_entry_safe(STATE_RA_ROUTE, &entry, 7200);
+					changed |= odhcp6c_update_entry(STATE_RA_ROUTE, entry, 7200, true);
 
 				if (!(pinfo->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_AUTO) ||
 						pinfo->nd_opt_pi_prefix_len != 64)
 					continue;
 
-				entry.target.s6_addr32[2] = lladdr.s6_addr32[2];
-				entry.target.s6_addr32[3] = lladdr.s6_addr32[3];
+				entry->target.s6_addr32[2] = lladdr.s6_addr32[2];
+				entry->target.s6_addr32[3] = lladdr.s6_addr32[3];
 
-				odhcp6c_update_entry_safe(STATE_RA_PREFIX, &entry, 7200);
+				changed |= odhcp6c_update_entry(STATE_RA_PREFIX, entry, 7200, true);
 			} else if (opt->type == ND_OPT_RECURSIVE_DNS && opt->len > 2) {
-				entry.router = from.sin6_addr;
-				entry.priority = 0;
-				entry.length = 128;
-				entry.valid = ntohl(*((uint32_t*)&opt->data[2]));
-				entry.preferred = 0;
+				entry->router = from.sin6_addr;
+				entry->priority = 0;
+				entry->length = 128;
+				uint32_t *valid = (uint32_t*)&opt->data[2];
+				entry->valid = ntohl(*valid);
+				entry->preferred = 0;
 
 				for (ssize_t i = 0; i < (opt->len - 1) / 2; ++i) {
-					memcpy(&entry.target, &opt->data[6 + i * sizeof(entry.target)],
-							sizeof(entry.target));
-					odhcp6c_update_entry(STATE_RA_DNS, &entry);
+					memcpy(&entry->target, &opt->data[6 + i * sizeof(entry->target)],
+							sizeof(entry->target));
+					changed |= odhcp6c_update_entry(STATE_RA_DNS, entry, 0, true);
+				}
+			} else if (opt->type == ND_OPT_DNSSL && opt->len > 1) {
+				uint32_t *valid = (uint32_t*)&opt->data[2];
+				uint8_t *buf = &opt->data[6];
+				uint8_t *end = &buf[(opt->len - 1) * 8];
+
+				entry->router = from.sin6_addr;
+				entry->valid = ntohl(*valid);
+
+				while (buf < end) {
+					int len = dn_expand(buf, end, buf, (char*)entry->auxtarget, 256);
+					if (len < 1)
+						break;
+
+					buf = &buf[len];
+					entry->auxlen = strlen((char*)entry->auxtarget);
+
+					if (entry->auxlen == 0)
+						continue;
+
+					changed |= odhcp6c_update_entry(STATE_RA_SEARCH, entry, 0, true);
+					entry->auxlen = 0;
 				}
 			}
 		}
 
-		size_t ra_dns_len;
-		struct odhcp6c_entry *entry = odhcp6c_get_state(STATE_RA_DNS, &ra_dns_len);
-		for (size_t i = 0; i < ra_dns_len / sizeof(*entry); ++i)
-			if (IN6_ARE_ADDR_EQUAL(&entry[i].router, &from.sin6_addr) &&
-					entry[i].valid > router_valid)
-				entry[i].valid = router_valid;
+		int states[2] = {STATE_RA_DNS, STATE_RA_SEARCH};
+		for (size_t i = 0; i < 2; ++i) {
+			size_t ra_dns_len;
+			uint8_t *start = odhcp6c_get_state(states[i], &ra_dns_len);
+			for (struct odhcp6c_entry *c = (struct odhcp6c_entry*)start;
+						(uint8_t*)c < &start[ra_dns_len] && &c->auxtarget[c->auxlen] <= &start[ra_dns_len];
+						c = (struct odhcp6c_entry*)(&c->auxtarget[c->auxlen]))
+				if (IN6_ARE_ADDR_EQUAL(&c->router, &from.sin6_addr) &&
+						c->valid > router_valid)
+					c->valid = router_valid;
+		}
 	}
 
-	odhcp6c_expire();
-	return found;
+	if (found)
+		odhcp6c_expire();
+
+	return found && changed;
 }