X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Frouter.c;h=93b75bf8957e3b54d2a4c1534bfc78e5ea2f9dc0;hb=0523bdd981f0cc56c2391f73649baeda39ab43e0;hp=19702a2d08f3af29e23a74e508dcb2e777fcebeb;hpb=18df6cca092743a07be8e0f05d0a9ef941957b66;p=oweals%2Fodhcpd.git

diff --git a/src/router.c b/src/router.c
index 19702a2..93b75bf 100644
--- a/src/router.c
+++ b/src/router.c
@@ -1,5 +1,6 @@
 /**
  * Copyright (C) 2012-2013 Steven Barth <steven@midlink.org>
+ * Copyright (C) 2018 Hans Dedecker <dedeckeh@gmail.com>
  *
  * 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
@@ -23,121 +24,227 @@
 #include <arpa/inet.h>
 #include <net/route.h>
 
+#include <libubox/utils.h>
+
 #include "router.h"
 #include "odhcpd.h"
 
 
 static void forward_router_solicitation(const struct interface *iface);
-static void forward_router_advertisement(uint8_t *data, size_t len);
+static void forward_router_advertisement(const struct interface *iface, uint8_t *data, size_t len);
 
 static void handle_icmpv6(void *addr, void *data, size_t len,
 		struct interface *iface, void *dest);
 static void trigger_router_advert(struct uloop_timeout *event);
-static void sigusr1_refresh(int signal);
+static void router_netevent_cb(unsigned long event, struct netevent_handler_info *info);
 
-static struct odhcpd_event router_event = {.uloop = {.fd = -1}, .handle_dgram = handle_icmpv6, };
+static struct netevent_handler router_netevent_handler = { .cb = router_netevent_cb, };
 
 static FILE *fp_route = NULL;
 
+
 #define TIME_LEFT(t1, now) ((t1) != UINT32_MAX ? (t1) - (now) : UINT32_MAX)
 
-int init_router(void)
+int router_init(void)
 {
-	// Open ICMPv6 socket
-	int sock = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
-	if (sock < 0 && errno != EAFNOSUPPORT) {
-		syslog(LOG_ERR, "Failed to open RAW-socket: %s", strerror(errno));
-		return -1;
+	int ret = 0;
+
+	if (!(fp_route = fopen("/proc/net/ipv6_route", "r"))) {
+		syslog(LOG_ERR, "fopen(/proc/net/ipv6_route): %m");
+		ret = -1;
+		goto out;
+	}
+
+	if (netlink_add_netevent_handler(&router_netevent_handler) < 0) {
+		syslog(LOG_ERR, "Failed to add netevent handler");
+		ret = -1;
 	}
 
-	// Let the kernel compute our checksums
-	int 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));
-	setsockopt(sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &val, sizeof(val));
-
-	// We need to know the source interface
-	val = 1;
-	setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, &val, sizeof(val));
-	setsockopt(sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &val, sizeof(val));
-
-	// Don't loop back
-	val = 0;
-	setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val, sizeof(val));
-
-	// Filter ICMPv6 package types
-	struct icmp6_filter filt;
-	ICMP6_FILTER_SETBLOCKALL(&filt);
-	ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filt);
-	ICMP6_FILTER_SETPASS(ND_ROUTER_SOLICIT, &filt);
-	setsockopt(sock, IPPROTO_ICMPV6, ICMP6_FILTER, &filt, sizeof(filt));
-
-	// Register socket
-	router_event.uloop.fd = sock;
-	odhcpd_register(&router_event);
-
-	if (!(fp_route = fopen("/proc/net/ipv6_route", "r")))
-		syslog(LOG_ERR, "Failed to open routing table: %s",
-				strerror(errno));
-
-	signal(SIGUSR1, sigusr1_refresh);
-	return 0;
+out:
+	if (ret < 0 && fp_route) {
+		fclose(fp_route);
+		fp_route = NULL;
+	}
+
+	return ret;
 }
 
 
-int setup_router_interface(struct interface *iface, bool enable)
+int router_setup_interface(struct interface *iface, bool enable)
 {
-	if (!fp_route || router_event.uloop.fd < 0)
-		return -1;
+	int ret = 0;
 
-	struct ipv6_mreq all_nodes = {ALL_IPV6_NODES, iface->ifindex};
-	struct ipv6_mreq all_routers = {ALL_IPV6_ROUTERS, iface->ifindex};
-
-	uloop_timeout_cancel(&iface->timer_rs);
-	iface->timer_rs.cb = NULL;
+	if (!fp_route) {
+		ret = -1;
+		goto out;
+	}
 
-	if (iface->ifindex <= 0)
-		return -1;
 
-	setsockopt(router_event.uloop.fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
-			&all_nodes, sizeof(all_nodes));
-	setsockopt(router_event.uloop.fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
-			&all_routers, sizeof(all_routers));
+	if ((!enable || iface->ra == MODE_DISABLED) && iface->router_event.uloop.fd >= 0) {
+		if (!iface->master) {
+			uloop_timeout_cancel(&iface->timer_rs);
+			iface->timer_rs.cb = NULL;
 
-	if (!enable) {
-		if (iface->ra)
 			trigger_router_advert(&iface->timer_rs);
-	} else {
-		void *mreq = &all_routers;
+		}
+
+		uloop_fd_delete(&iface->router_event.uloop);
+		close(iface->router_event.uloop.fd);
+		iface->router_event.uloop.fd = -1;
+	} else if (enable && iface->ra != MODE_DISABLED) {
+		struct icmp6_filter filt;
+		struct ipv6_mreq mreq;
+		int val = 2;
+
+		if (iface->router_event.uloop.fd < 0) {
+			/* Open ICMPv6 socket */
+			iface->router_event.uloop.fd = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC,
+							      IPPROTO_ICMPV6);
+			if (iface->router_event.uloop.fd < 0) {
+				syslog(LOG_ERR, "socket(AF_INET6): %m");
+				ret = -1;
+				goto out;
+			}
+
+			if (setsockopt(iface->router_event.uloop.fd, SOL_SOCKET, SO_BINDTODEVICE,
+				       iface->ifname, strlen(iface->ifname)) < 0) {
+				syslog(LOG_ERR, "setsockopt(SO_BINDTODEVICE): %m");
+				ret = -1;
+				goto out;
+			}
+
+			/* Let the kernel compute our checksums */
+			if (setsockopt(iface->router_event.uloop.fd, IPPROTO_RAW, IPV6_CHECKSUM,
+				       &val, sizeof(val)) < 0) {
+				syslog(LOG_ERR, "setsockopt(IPV6_CHECKSUM): %m");
+				ret = -1;
+				goto out;
+			}
 
-		if (iface->ra == RELAYD_RELAY && iface->master) {
-			mreq = &all_nodes;
+			/* This is required by RFC 4861 */
+			val = 255;
+			if (setsockopt(iface->router_event.uloop.fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
+				       &val, sizeof(val)) < 0) {
+				syslog(LOG_ERR, "setsockopt(IPV6_MULTICAST_HOPS): %m");
+				ret = -1;
+				goto out;
+			}
+
+			if (setsockopt(iface->router_event.uloop.fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
+				       &val, sizeof(val)) < 0) {
+				syslog(LOG_ERR, "setsockopt(IPV6_UNICAST_HOPS): %m");
+				ret = -1;
+				goto out;
+			}
+
+			/* We need to know the source interface */
+			val = 1;
+			if (setsockopt(iface->router_event.uloop.fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
+				       &val, sizeof(val)) < 0) {
+				syslog(LOG_ERR, "setsockopt(IPV6_RECVPKTINFO): %m");
+				ret = -1;
+				goto out;
+			}
+
+			if (setsockopt(iface->router_event.uloop.fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT,
+				       &val, sizeof(val)) < 0) {
+				syslog(LOG_ERR, "setsockopt(IPV6_RECVHOPLIMIT): %m");
+				ret = -1;
+				goto out;
+			}
+
+			/* Don't loop back */
+			val = 0;
+			if (setsockopt(iface->router_event.uloop.fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
+				       &val, sizeof(val)) < 0) {
+				syslog(LOG_ERR, "setsockopt(IPV6_MULTICAST_LOOP): %m");
+				ret = -1;
+				goto out;
+			}
+
+			/* Filter ICMPv6 package types */
+			ICMP6_FILTER_SETBLOCKALL(&filt);
+			ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filt);
+			ICMP6_FILTER_SETPASS(ND_ROUTER_SOLICIT, &filt);
+			if (setsockopt(iface->router_event.uloop.fd, IPPROTO_ICMPV6, ICMP6_FILTER,
+				       &filt, sizeof(filt)) < 0) {
+				syslog(LOG_ERR, "setsockopt(ICMP6_FILTER): %m");
+				ret = -1;
+				goto out;
+			}
+
+			iface->router_event.handle_dgram = handle_icmpv6;
+			odhcpd_register(&iface->router_event);
+		} else {
+			uloop_timeout_cancel(&iface->timer_rs);
+			iface->timer_rs.cb = NULL;
+
+			memset(&mreq, 0, sizeof(mreq));
+			mreq.ipv6mr_interface = iface->ifindex;
+			inet_pton(AF_INET6, ALL_IPV6_NODES, &mreq.ipv6mr_multiaddr);
+			setsockopt(iface->router_event.uloop.fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
+				   &mreq, sizeof(mreq));
+
+			inet_pton(AF_INET6, ALL_IPV6_ROUTERS, &mreq.ipv6mr_multiaddr);
+			setsockopt(iface->router_event.uloop.fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
+				   &mreq, sizeof(mreq));
+		}
+
+		memset(&mreq, 0, sizeof(mreq));
+		mreq.ipv6mr_interface = iface->ifindex;
+		inet_pton(AF_INET6, ALL_IPV6_ROUTERS, &mreq.ipv6mr_multiaddr);
+
+		if (iface->ra == MODE_RELAY && iface->master) {
+			inet_pton(AF_INET6, ALL_IPV6_NODES, &mreq.ipv6mr_multiaddr);
 			forward_router_solicitation(iface);
-		} else if (iface->ra == RELAYD_SERVER && !iface->master) {
+		} else if (iface->ra == MODE_SERVER) {
 			iface->timer_rs.cb = trigger_router_advert;
 			uloop_timeout_set(&iface->timer_rs, 1000);
 		}
 
-		if (iface->ra == RELAYD_RELAY || (iface->ra == RELAYD_SERVER && !iface->master))
-			setsockopt(router_event.uloop.fd, IPPROTO_IPV6,
-					IPV6_ADD_MEMBERSHIP, mreq, sizeof(all_nodes));
+		if (setsockopt(iface->router_event.uloop.fd, IPPROTO_IPV6,
+			       IPV6_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
+			ret = -1;
+			syslog(LOG_ERR, "setsockopt(IPV6_ADD_MEMBERSHIP): %m");
+			goto out;
+		}
+	}
+out:
+	if (ret < 0 && iface->router_event.uloop.fd >= 0) {
+		close(iface->router_event.uloop.fd);
+		iface->router_event.uloop.fd = -1;
 	}
-	return 0;
+
+	return ret;
 }
 
 
-// Signal handler to resend all RDs
-static void sigusr1_refresh(_unused int signal)
+static void router_netevent_cb(unsigned long event, struct netevent_handler_info *info)
 {
 	struct interface *iface;
-	list_for_each_entry(iface, &interfaces, head)
-		if (iface->ra == RELAYD_SERVER && !iface->master)
+
+	switch (event) {
+	case NETEV_ROUTE6_ADD:
+	case NETEV_ROUTE6_DEL:
+		if (info->rt.dst_len)
+			break;
+
+		avl_for_each_element(&interfaces, iface, avl) {
+			if (iface->ra == MODE_SERVER && !iface->master)
+				uloop_timeout_set(&iface->timer_rs, 1000);
+		}
+		break;
+	case NETEV_ADDR6LIST_CHANGE:
+		iface = info->iface;
+		if (iface && iface->ra == MODE_SERVER && !iface->master)
 			uloop_timeout_set(&iface->timer_rs, 1000);
+		break;
+	default:
+		break;
+	}
 }
 
+
 static bool router_icmpv6_valid(struct sockaddr_in6 *source, uint8_t *data, size_t len)
 {
 	struct icmp6_hdr *hdr = (struct icmp6_hdr *)data;
@@ -169,20 +276,20 @@ static bool router_icmpv6_valid(struct sockaddr_in6 *source, uint8_t *data, size
 				hdr->icmp6_type == ND_ROUTER_SOLICIT)
 			return false;
 
-	// Check all options parsed successfully
+	/* Check all options parsed successfully */
 	return opt == end;
 }
 
 
-// Detect whether a default route exists, also find the source prefixes
+/* Detect whether a default route exists, also find the source prefixes */
 static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
 {
-	rewind(fp_route);
-
-	char line[512], ifname[16];
-	bool found_default = false;
 	struct odhcpd_ipaddr p = { .addr.in6 = IN6ADDR_ANY_INIT, .prefix = 0,
 					.dprefix = 0, .preferred = 0, .valid = 0};
+	bool found_default = false;
+	char line[512], ifname[16];
+
+	rewind(fp_route);
 
 	while (fgets(line, sizeof(line), fp_route)) {
 		uint32_t rflags;
@@ -205,7 +312,6 @@ static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
 					break;
 				}
 			}
-
 		}
 	}
 
@@ -260,46 +366,80 @@ enum {
 	IOV_RA_PFXS,
 	IOV_RA_ROUTES,
 	IOV_RA_DNS,
-	IOV_RA_DNS_ADDR,
 	IOV_RA_SEARCH,
 	IOV_RA_ADV_INTERVAL,
 	IOV_RA_TOTAL,
 };
 
-// Router Advert server mode
-static uint64_t send_router_advert(struct interface *iface, const struct in6_addr *from)
+struct adv_msg {
+	struct nd_router_advert h;
+	struct icmpv6_opt lladdr;
+	struct nd_opt_mtu mtu;
+};
+
+struct nd_opt_dns_server {
+	uint8_t type;
+	uint8_t len;
+	uint8_t pad;
+	uint8_t pad2;
+	uint32_t lifetime;
+	struct in6_addr addr[];
+};
+
+struct nd_opt_search_list {
+	uint8_t type;
+	uint8_t len;
+	uint8_t pad;
+	uint8_t pad2;
+	uint32_t lifetime;
+	uint8_t name[];
+};
+
+struct nd_opt_route_info {
+	uint8_t type;
+	uint8_t len;
+	uint8_t prefix;
+	uint8_t flags;
+	uint32_t lifetime;
+	uint32_t addr[4];
+};
+
+/* Router Advert server mode */
+static int send_router_advert(struct interface *iface, const struct in6_addr *from)
 {
 	time_t now = odhcpd_time();
-	int mtu = iface->ra_mtu;
-	int hlim = iface->ra_hoplimit;
-
-	if (mtu == 0)
-		mtu = odhcpd_get_interface_config(iface->ifname, "mtu");
+	struct odhcpd_ipaddr *addrs = NULL;
+	struct adv_msg adv;
+	struct nd_opt_prefix_info *pfxs = NULL;
+	struct nd_opt_dns_server *dns = NULL;
+	struct nd_opt_search_list *search = NULL;
+	struct nd_opt_route_info *routes = NULL;
+	struct nd_opt_adv_interval adv_interval;
+	struct iovec iov[IOV_RA_TOTAL];
+	struct sockaddr_in6 dest;
+	size_t dns_sz = 0, search_sz = 0, pfxs_cnt = 0, routes_cnt = 0;
+	ssize_t addr_cnt = 0;
+	uint32_t minvalid = UINT32_MAX, maxival;
+	int msecs, mtu = iface->ra_mtu, hlim = iface->ra_hoplimit;
+	bool default_route = false;
+	bool valid_prefix = false;
+	char buf[INET6_ADDRSTRLEN];
 
-	if (mtu < 1280)
-		mtu = 1280;
+	memset(&adv, 0, sizeof(adv));
+	adv.h.nd_ra_type = ND_ROUTER_ADVERT;
 
 	if (hlim == 0)
 		hlim = odhcpd_get_interface_config(iface->ifname, "hop_limit");
 
-	struct {
-		struct nd_router_advert h;
-		struct icmpv6_opt lladdr;
-		struct nd_opt_mtu mtu;
-	} adv = {
-		.h = {{.icmp6_type = ND_ROUTER_ADVERT, .icmp6_code = 0}, 0, 0},
-		.lladdr = {ND_OPT_SOURCE_LINKADDR, 1, {0}},
-		.mtu = {ND_OPT_MTU, 1, 0, htonl(mtu)},
-	};
-
 	if (hlim > 0)
 		adv.h.nd_ra_curhoplimit = hlim;
 
-	if (iface->dhcpv6)
+	if (iface->dhcpv6) {
 		adv.h.nd_ra_flags_reserved = ND_RA_FLAG_OTHER;
 
-	if (iface->managed >= RELAYD_MANAGED_MFLAG)
-		adv.h.nd_ra_flags_reserved |= ND_RA_FLAG_MANAGED;
+		if (iface->ra_managed >= RA_MANAGED_MFLAG)
+			adv.h.nd_ra_flags_reserved |= ND_RA_FLAG_MANAGED;
+	}
 
 	if (iface->route_preference < 0)
 		adv.h.nd_ra_flags_reserved |= ND_RA_PREF_LOW;
@@ -309,58 +449,66 @@ static uint64_t send_router_advert(struct interface *iface, const struct in6_add
 	adv.h.nd_ra_reachable = htonl(iface->ra_reachabletime);
 	adv.h.nd_ra_retransmit = htonl(iface->ra_retranstime);
 
+	adv.lladdr.type = ND_OPT_SOURCE_LINKADDR;
+	adv.lladdr.len = 1;
 	odhcpd_get_mac(iface, adv.lladdr.data);
 
-	// If not currently shutting down
-	struct odhcpd_ipaddr *addrs = NULL;
-	ssize_t ipcnt = 0;
-	uint32_t minvalid = UINT32_MAX;
-	bool default_route = false;
-	bool valid_prefix = false;
+	adv.mtu.nd_opt_mtu_type = ND_OPT_MTU;
+	adv.mtu.nd_opt_mtu_len = 1;
+
+	if (mtu == 0)
+		mtu = odhcpd_get_interface_config(iface->ifname, "mtu");
+
+	if (mtu < 1280)
+		mtu = 1280;
+
+	adv.mtu.nd_opt_mtu_mtu = htonl(mtu);
+
+	iov[IOV_RA_ADV].iov_base = (char *)&adv;
+	iov[IOV_RA_ADV].iov_len = sizeof(adv);
 
-	// If not shutdown
+	/* If not shutdown */
 	if (iface->timer_rs.cb) {
-		size_t size = sizeof(*addrs) * iface->ia_addr_len;
+		size_t size = sizeof(*addrs) * iface->addr6_len;
+
 		addrs = alloca(size);
-		memcpy(addrs, iface->ia_addr, size);
+		memcpy(addrs, iface->addr6, size);
 
-		ipcnt = iface->ia_addr_len;
+		addr_cnt = iface->addr6_len;
 
-		// Check default route
+		/* Check default route */
 		if (iface->default_router) {
 			default_route = true;
 
 			if (iface->default_router > 1)
 				valid_prefix = true;
-		} else if (parse_routes(addrs, ipcnt))
+		} else if (parse_routes(addrs, addr_cnt))
 			default_route = true;
 	}
 
-
-	struct in6_addr dns_pref, *dns_addr = &dns_pref;
-	size_t dns_cnt = 1;
-
-	odhcpd_get_interface_dns_addr(iface, &dns_pref);
-
-	// Construct Prefix Information options
-	size_t pfxs_cnt = 0;
-	struct nd_opt_prefix_info *pfxs = NULL;
-
-	for (ssize_t i = 0; i < ipcnt; ++i) {
+	/* Construct Prefix Information options */
+	for (ssize_t i = 0; i < addr_cnt; ++i) {
 		struct odhcpd_ipaddr *addr = &addrs[i];
+		struct nd_opt_prefix_info *p = NULL;
 		uint32_t preferred = 0;
 		uint32_t valid = 0;
 
 		if (addr->prefix > 96 || addr->valid <= (uint32_t)now) {
-			char namebuf[INET6_ADDRSTRLEN];
-
-			inet_ntop(AF_INET6, &addr->addr.in6, namebuf, sizeof(namebuf));
 			syslog(LOG_INFO, "Address %s (prefix %d, valid %u) not suitable as RA prefix on %s",
-					namebuf, addr->prefix, addr->valid, iface->ifname);
+				inet_ntop(AF_INET6, &addr->addr.in6, buf, sizeof(buf)), addr->prefix,
+				addr->valid, iface->name);
 			continue;
 		}
 
-		struct nd_opt_prefix_info *p = NULL;
+		if (odhcpd_bmemcmp(&addr->addr, &iface->pio_filter_addr,
+				   iface->pio_filter_length) != 0 ||
+		    addr->prefix < iface->pio_filter_length) {
+			syslog(LOG_INFO, "Address %s filtered out as RA prefix on %s",
+			       inet_ntop(AF_INET6, &addr->addr.in6, buf, sizeof(buf)),
+			       iface->name);
+			continue; /* PIO filtered out of this RA */
+		}
+
 		for (size_t i = 0; i < pfxs_cnt; ++i) {
 			if (addr->prefix == pfxs[i].nd_opt_pi_prefix_len &&
 					!odhcpd_bmemcmp(&pfxs[i].nd_opt_pi_prefix,
@@ -373,7 +521,7 @@ static uint64_t send_router_advert(struct interface *iface, const struct in6_add
 
 			tmp = realloc(pfxs, sizeof(*pfxs) * (pfxs_cnt + 1));
 			if (!tmp) {
-				syslog(LOG_ERR, "Realloc failed for RA prefix option on interface %s", iface->ifname);
+				syslog(LOG_ERR, "Realloc failed for RA prefix option on %s", iface->name);
 				continue;
 			}
 
@@ -408,7 +556,7 @@ static uint64_t send_router_advert(struct interface *iface, const struct in6_add
 		p->nd_opt_pi_flags_reserved = 0;
 		if (!iface->ra_not_onlink)
 			p->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_ONLINK;
-		if (iface->managed < RELAYD_MANAGED_NO_AFLAG && addr->prefix <= 64)
+		if (iface->ra_managed < RA_MANAGED_NO_AFLAG && addr->prefix <= 64)
 			p->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_AUTO;
 		if (iface->ra_advrouter)
 			p->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_RADDR;
@@ -416,14 +564,16 @@ static uint64_t send_router_advert(struct interface *iface, const struct in6_add
 		p->nd_opt_pi_valid_time = htonl(valid);
 	}
 
-	// Calculate periodic transmit
-	uint32_t maxival;
-	int msecs = calc_adv_interval(iface, minvalid, &maxival);
+	iov[IOV_RA_PFXS].iov_base = (char *)pfxs;
+	iov[IOV_RA_PFXS].iov_len = pfxs_cnt * sizeof(*pfxs);
+
+	/* Calculate periodic transmit */
+	msecs = calc_adv_interval(iface, minvalid, &maxival);
 
 	if (default_route) {
 		if (!valid_prefix) {
 			syslog(LOG_WARNING, "A default route is present but there is no public prefix "
-					"on %s thus we don't announce a default route!", iface->ifname);
+					"on %s thus we don't announce a default route!", iface->name);
 			adv.h.nd_ra_router_lifetime = 0;
 		} else
 			adv.h.nd_ra_router_lifetime = htons(calc_ra_lifetime(iface, maxival));
@@ -431,74 +581,90 @@ static uint64_t send_router_advert(struct interface *iface, const struct in6_add
 	} else
 		adv.h.nd_ra_router_lifetime = 0;
 
-	syslog(LOG_INFO, "Using a RA lifetime of %d seconds on %s", ntohs(adv.h.nd_ra_router_lifetime), iface->ifname);
+	syslog(LOG_INFO, "Using a RA lifetime of %d seconds on %s", ntohs(adv.h.nd_ra_router_lifetime), iface->name);
+
+	/* DNS options */
+	if (iface->ra_dns) {
+		struct in6_addr dns_pref, *dns_addr = NULL;
+		size_t dns_cnt = 0, search_padded = 0, search_len = iface->search_len;
+		uint8_t *search_domain = iface->search;
+
+		/* DNS Recursive DNS */
+		if (iface->dns_cnt > 0) {
+			dns_addr = iface->dns;
+			dns_cnt = iface->dns_cnt;
+		} else if (!odhcpd_get_interface_dns_addr(iface, &dns_pref)) {
+			dns_addr = &dns_pref;
+			dns_cnt = 1;
+		}
 
-	// DNS Recursive DNS
-	if (iface->dns_cnt > 0) {
-		dns_addr = iface->dns;
-		dns_cnt = iface->dns_cnt;
-	}
+		if (dns_cnt) {
+			dns_sz = sizeof(*dns) + sizeof(struct in6_addr)*dns_cnt;
 
-	if (!dns_addr || IN6_IS_ADDR_UNSPECIFIED(dns_addr))
-		dns_cnt = 0;
-
-	struct {
-		uint8_t type;
-		uint8_t len;
-		uint8_t pad;
-		uint8_t pad2;
-		uint32_t lifetime;
-	} dns = {ND_OPT_RECURSIVE_DNS, (1 + (2 * dns_cnt)), 0, 0, 0};
-
-	// DNS Search options
-	uint8_t search_buf[256], *search_domain = iface->search;
-	size_t search_len = iface->search_len, search_padded = 0;
-
-	if (!search_domain && !res_init() && _res.dnsrch[0] && _res.dnsrch[0][0]) {
-		int len = dn_comp(_res.dnsrch[0], search_buf,
-				sizeof(search_buf), NULL, NULL);
-		if (len > 0) {
-			search_domain = search_buf;
-			search_len = len;
+			dns = alloca(dns_sz);
+			memset(dns, 0, dns_sz);
+			dns->type = ND_OPT_RECURSIVE_DNS;
+			dns->len = 1 + (2 * dns_cnt);
+			dns->lifetime = htonl(maxival*10);
+			memcpy(dns->addr, dns_addr, sizeof(struct in6_addr)*dns_cnt);
+		}
+
+		/* DNS Search options */
+		if (!search_domain && !res_init() && _res.dnsrch[0] && _res.dnsrch[0][0]) {
+			uint8_t search_buf[256];
+
+			int len = dn_comp(_res.dnsrch[0], search_buf,
+					sizeof(search_buf), NULL, NULL);
+			if (len > 0) {
+				search_domain = search_buf;
+				search_len = len;
+			}
+		}
+
+		if (search_len > 0)
+			search_padded = ((search_len + 7) & (~7)) + 8;
+
+		search_sz = sizeof(*search) + search_padded;
+
+		search = alloca(search_sz);
+		memset(search, 0, search_sz);
+		search->type = ND_OPT_DNS_SEARCH;
+		search->len = search_len ? ((sizeof(*search) + search_padded) / 8) : 0;
+		search->lifetime = htonl(maxival*10);
+
+		if (search_len > 0) {
+			memcpy(search->name, search_domain, search_len);
+			memset(&search->name[search_len], 0, search_padded - search_len);
 		}
 	}
 
-	if (search_len > 0)
-		search_padded = ((search_len + 7) & (~7)) + 8;
-
-	struct {
-		uint8_t type;
-		uint8_t len;
-		uint8_t pad;
-		uint8_t pad2;
-		uint32_t lifetime;
-		uint8_t name[];
-	} *search = alloca(sizeof(*search) + search_padded);
-
-	search->type = ND_OPT_DNS_SEARCH;
-	search->len = search_len ? ((sizeof(*search) + search_padded) / 8) : 0;
-	search->pad = 0;
-	search->pad2 = 0;
-	memcpy(search->name, search_domain, search_len);
-	memset(&search->name[search_len], 0, search_padded - search_len);
-
-
-	size_t routes_cnt = 0;
-	struct {
-		uint8_t type;
-		uint8_t len;
-		uint8_t prefix;
-		uint8_t flags;
-		uint32_t lifetime;
-		uint32_t addr[4];
-	} *tmp, *routes = NULL;
-
-	for (ssize_t i = 0; i < ipcnt; ++i) {
+	iov[IOV_RA_DNS].iov_base = (char *)dns;
+	iov[IOV_RA_DNS].iov_len = dns_sz;
+	iov[IOV_RA_SEARCH].iov_base = (char *)search;
+	iov[IOV_RA_SEARCH].iov_len = search_sz;
+
+	for (ssize_t i = 0; i < addr_cnt; ++i) {
 		struct odhcpd_ipaddr *addr = &addrs[i];
-		if (addr->dprefix > 64 || addr->dprefix == 0 || addr->valid <= (uint32_t)now ||
-				(addr->dprefix == 64 && addr->prefix == 64)) {
-			continue; // Address not suitable
-		} else if (addr->dprefix > 32) {
+		struct nd_opt_route_info *tmp;
+
+		if (addr->dprefix > 64 || addr->dprefix == 0 || addr->valid <= (uint32_t)now) {
+			syslog(LOG_INFO, "Address %s (dprefix %d, valid %u) not suitable as RA route on %s",
+				inet_ntop(AF_INET6, &addr->addr.in6, buf, sizeof(buf)),
+				addr->dprefix, addr->valid, iface->name);
+
+			continue; /* Address not suitable */
+		}
+
+		if (odhcpd_bmemcmp(&addr->addr, &iface->pio_filter_addr,
+				iface->pio_filter_length) != 0 ||
+				addr->prefix < iface->pio_filter_length) {
+			syslog(LOG_INFO, "Address %s filtered out as RA route on %s",
+			       inet_ntop(AF_INET6, &addr->addr.in6, buf, sizeof(buf)),
+			       iface->name);
+			continue; /* PIO filtered out of this RA */
+		}
+
+		if (addr->dprefix > 32) {
 			addr->addr.in6.s6_addr32[1] &= htonl(~((1U << (64 - addr->dprefix)) - 1));
 		} else if (addr->dprefix <= 32) {
 			addr->addr.in6.s6_addr32[0] &= htonl(~((1U << (32 - addr->dprefix)) - 1));
@@ -507,7 +673,7 @@ static uint64_t send_router_advert(struct interface *iface, const struct in6_add
 
 		tmp = realloc(routes, sizeof(*routes) * (routes_cnt + 1));
 		if (!tmp) {
-			syslog(LOG_ERR, "Realloc failed for RA route option on interface %s", iface->ifname);
+			syslog(LOG_ERR, "Realloc failed for RA route option on %s", iface->name);
 			continue;
 		}
 
@@ -522,6 +688,7 @@ static uint64_t send_router_advert(struct interface *iface, const struct in6_add
 			routes[routes_cnt].flags |= ND_RA_PREF_LOW;
 		else if (iface->route_preference > 0)
 			routes[routes_cnt].flags |= ND_RA_PREF_HIGH;
+
 		routes[routes_cnt].lifetime = htonl(TIME_LEFT(addr->valid, now));
 		routes[routes_cnt].addr[0] = addr->addr.in6.s6_addr32[0];
 		routes[routes_cnt].addr[1] = addr->addr.in6.s6_addr32[1];
@@ -531,30 +698,28 @@ static uint64_t send_router_advert(struct interface *iface, const struct in6_add
 		++routes_cnt;
 	}
 
-	search->lifetime = htonl(maxival*10);
-	dns.lifetime = search->lifetime;
-
-	struct icmpv6_opt adv_interval = {
-		.type = ND_OPT_RTR_ADV_INTERVAL,
-		.len = 1,
-		.data = {0, 0, (maxival*1000) >> 24, (maxival*1000) >> 16, (maxival*1000) >> 8, maxival*1000}
-	};
-
-	struct iovec iov[IOV_RA_TOTAL] = {
-			[IOV_RA_ADV] = {&adv, sizeof(adv)},
-			[IOV_RA_PFXS] = {pfxs, pfxs_cnt * sizeof(*pfxs)},
-			[IOV_RA_ROUTES] = {routes, routes_cnt * sizeof(*routes)},
-			[IOV_RA_DNS] = {&dns, (dns_cnt) ? sizeof(dns) : 0},
-			[IOV_RA_DNS_ADDR] = {dns_addr, dns_cnt * sizeof(*dns_addr)},
-			[IOV_RA_SEARCH] = {search, search->len * 8},
-			[IOV_RA_ADV_INTERVAL] = {&adv_interval, adv_interval.len * 8}};
-	struct sockaddr_in6 dest = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
+	iov[IOV_RA_ROUTES].iov_base = (char *)routes;
+	iov[IOV_RA_ROUTES].iov_len = routes_cnt * sizeof(*routes);
+
+	memset(&adv_interval, 0, sizeof(adv_interval));
+	adv_interval.nd_opt_adv_interval_type = ND_OPT_RTR_ADV_INTERVAL;
+	adv_interval.nd_opt_adv_interval_len = 1;
+	adv_interval.nd_opt_adv_interval_ival = htonl(maxival);
+
+	iov[IOV_RA_ADV_INTERVAL].iov_base = (char *)&adv_interval;
+	iov[IOV_RA_ADV_INTERVAL].iov_len = adv_interval.nd_opt_adv_interval_len * 8;
+
+	memset(&dest, 0, sizeof(dest));
+	dest.sin6_family = AF_INET6;
 
 	if (from && !IN6_IS_ADDR_UNSPECIFIED(from))
 		dest.sin6_addr = *from;
+	else
+		inet_pton(AF_INET6, ALL_IPV6_NODES, &dest.sin6_addr);
 
-	odhcpd_send(router_event.uloop.fd,
-			&dest, iov, ARRAY_SIZE(iov), iface);
+	syslog(LOG_NOTICE, "Sending a RA on %s", iface->name);
+
+	odhcpd_send(iface->router_event.uloop.fd, &dest, iov, ARRAY_SIZE(iov), iface);
 
 	free(pfxs);
 	free(routes);
@@ -568,13 +733,13 @@ static void trigger_router_advert(struct uloop_timeout *event)
 	struct interface *iface = container_of(event, struct interface, timer_rs);
 	int msecs = send_router_advert(iface, NULL);
 
-	// Rearm timer if not shut down
+	/* Rearm timer if not shut down */
 	if (event->cb)
 		uloop_timeout_set(event, msecs);
 }
 
 
-// Event handler for incoming ICMPv6 packets
+/* Event handler for incoming ICMPv6 packets */
 static void handle_icmpv6(void *addr, void *data, size_t len,
 		struct interface *iface, _unused void *dest)
 {
@@ -584,96 +749,111 @@ static void handle_icmpv6(void *addr, void *data, size_t len,
 	if (!router_icmpv6_valid(addr, data, len))
 		return;
 
-	if ((iface->ra == RELAYD_SERVER && !iface->master)) { // Server mode
+	if ((iface->ra == MODE_SERVER && !iface->master)) { /* Server mode */
 		if (hdr->icmp6_type == ND_ROUTER_SOLICIT)
 			send_router_advert(iface, &from->sin6_addr);
-	} else if (iface->ra == RELAYD_RELAY) { // Relay mode
-		if (hdr->icmp6_type == ND_ROUTER_ADVERT && iface->master)
-			forward_router_advertisement(data, len);
-		else if (hdr->icmp6_type == ND_ROUTER_SOLICIT && !iface->master)
-			forward_router_solicitation(odhcpd_get_master_interface());
+	} else if (iface->ra == MODE_RELAY) { /* Relay mode */
+		if (hdr->icmp6_type == ND_ROUTER_SOLICIT && !iface->master) {
+			struct interface *c;
+
+			avl_for_each_element(&interfaces, c, avl) {
+				if (!c->master || c->ra != MODE_RELAY)
+					continue;
+
+				forward_router_solicitation(c);
+			}
+		} else if (hdr->icmp6_type == ND_ROUTER_ADVERT && iface->master)
+			forward_router_advertisement(iface, data, len);
 	}
 }
 
 
-// Forward router solicitation
+/* Forward router solicitation */
 static void forward_router_solicitation(const struct interface *iface)
 {
+	struct icmp6_hdr rs = {ND_ROUTER_SOLICIT, 0, 0, {{0}}};
+	struct iovec iov = {&rs, sizeof(rs)};
+	struct sockaddr_in6 all_routers;
+
 	if (!iface)
 		return;
 
-	struct icmp6_hdr rs = {ND_ROUTER_SOLICIT, 0, 0, {{0}}};
-	struct iovec iov = {&rs, sizeof(rs)};
-	struct sockaddr_in6 all_routers =
-		{AF_INET6, 0, 0, ALL_IPV6_ROUTERS, iface->ifindex};
+	memset(&all_routers, 0, sizeof(all_routers));
+	all_routers.sin6_family = AF_INET6;
+	inet_pton(AF_INET6, ALL_IPV6_ROUTERS, &all_routers.sin6_addr);
+	all_routers.sin6_scope_id = iface->ifindex;
 
-	syslog(LOG_NOTICE, "Sending RS to %s", iface->ifname);
-	odhcpd_send(router_event.uloop.fd, &all_routers, &iov, 1, iface);
+	syslog(LOG_NOTICE, "Sending RS to %s", iface->name);
+	odhcpd_send(iface->router_event.uloop.fd, &all_routers, &iov, 1, iface);
 }
 
 
-// Handler for incoming router solicitations on slave interfaces
-static void forward_router_advertisement(uint8_t *data, size_t len)
+/* Handler for incoming router solicitations on slave interfaces */
+static void forward_router_advertisement(const struct interface *iface, uint8_t *data, size_t len)
 {
 	struct nd_router_advert *adv = (struct nd_router_advert *)data;
-
-	// Rewrite options
+	struct sockaddr_in6 all_nodes;
+	struct icmpv6_opt *opt;
+	struct interface *c;
+	struct iovec iov = { .iov_base = data, .iov_len = len };
+	/* Rewrite options */
 	uint8_t *end = data + len;
 	uint8_t *mac_ptr = NULL;
 	struct in6_addr *dns_ptr = NULL;
 	size_t dns_count = 0;
 
-	struct icmpv6_opt *opt;
 	icmpv6_for_each_option(opt, &adv[1], end) {
 		if (opt->type == ND_OPT_SOURCE_LINKADDR) {
-			// Store address of source MAC-address
+			/* Store address of source MAC-address */
 			mac_ptr = opt->data;
 		} else if (opt->type == ND_OPT_RECURSIVE_DNS && opt->len > 1) {
-			// Check if we have to rewrite DNS
+			/* Check if we have to rewrite DNS */
 			dns_ptr = (struct in6_addr*)&opt->data[6];
 			dns_count = (opt->len - 1) / 2;
 		}
 	}
 
-	syslog(LOG_NOTICE, "Got a RA");
+	syslog(LOG_NOTICE, "Got a RA on %s", iface->name);
 
-	// Indicate a proxy, however we don't follow the rest of RFC 4389 yet
+	/* Indicate a proxy, however we don't follow the rest of RFC 4389 yet */
 	adv->nd_ra_flags_reserved |= ND_RA_FLAG_PROXY;
 
-	// Forward advertisement to all slave interfaces
-	struct sockaddr_in6 all_nodes = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
-	struct iovec iov = {data, len};
+	/* Forward advertisement to all slave interfaces */
+	memset(&all_nodes, 0, sizeof(all_nodes));
+	all_nodes.sin6_family = AF_INET6;
+	inet_pton(AF_INET6, ALL_IPV6_NODES, &all_nodes.sin6_addr);
 
-	struct interface *iface;
-	list_for_each_entry(iface, &interfaces, head) {
-		if (iface->ra != RELAYD_RELAY || iface->master)
+	avl_for_each_element(&interfaces, c, avl) {
+		if (c->ra != MODE_RELAY || c->master)
 			continue;
 
-		// Fixup source hardware address option
+		/* Fixup source hardware address option */
 		if (mac_ptr)
-			odhcpd_get_mac(iface, mac_ptr);
+			odhcpd_get_mac(c, mac_ptr);
 
-		// If we have to rewrite DNS entries
-		if (iface->always_rewrite_dns && dns_ptr && dns_count > 0) {
-			const struct in6_addr *rewrite = iface->dns;
+		/* If we have to rewrite DNS entries */
+		if (c->always_rewrite_dns && dns_ptr && dns_count > 0) {
+			const struct in6_addr *rewrite = c->dns;
 			struct in6_addr addr;
-			size_t rewrite_cnt = iface->dns_cnt;
+			size_t rewrite_cnt = c->dns_cnt;
 
 			if (rewrite_cnt == 0) {
-				if (odhcpd_get_interface_dns_addr(iface, &addr))
-					continue; // Unable to comply
+				if (odhcpd_get_interface_dns_addr(c, &addr))
+					continue; /* Unable to comply */
 
 				rewrite = &addr;
 				rewrite_cnt = 1;
 			}
 
-			// Copy over any other addresses
+			/* Copy over any other addresses */
 			for (size_t i = 0; i < dns_count; ++i) {
 				size_t j = (i < rewrite_cnt) ? i : rewrite_cnt - 1;
 				dns_ptr[i] = rewrite[j];
 			}
 		}
 
-		odhcpd_send(router_event.uloop.fd, &all_nodes, &iov, 1, iface);
+		syslog(LOG_NOTICE, "Forward a RA on %s", c->name);
+
+		odhcpd_send(c->router_event.uloop.fd, &all_nodes, &iov, 1, c);
 	}
 }