X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fodhcpd.git;a=blobdiff_plain;f=src%2Frouter.c;h=89b1c520ab13d4a104e00a65d10dd7c1cf79771d;hp=83da938606fc165bf6b92c02400ffc102e66ab44;hb=053ca41a841aa4a1b1ce86ce6ee9f4304cba7027;hpb=0b68cabeb40d6e24a677a9332d3f3db163b5d723

diff --git a/src/router.c b/src/router.c
index 83da938..89b1c52 100644
--- a/src/router.c
+++ b/src/router.c
@@ -30,13 +30,14 @@ static void forward_router_solicitation(const struct interface *iface);
 static void forward_router_advertisement(uint8_t *data, size_t len);
 
 static void handle_icmpv6(void *addr, void *data, size_t len,
-		struct interface *iface);
-static void send_router_advert(struct uloop_timeout *event);
+		struct interface *iface, void *dest);
+static void trigger_router_advert(struct uloop_timeout *event);
 static void sigusr1_refresh(int signal);
 
 static struct odhcpd_event router_event = {{.fd = -1}, handle_icmpv6};
 
 static FILE *fp_route = NULL;
+#define RA_IOV_LEN 6
 
 
 int init_router(void)
@@ -88,6 +89,9 @@ int init_router(void)
 
 int setup_router_interface(struct interface *iface, bool enable)
 {
+	if (!fp_route || router_event.uloop.fd < 0)
+		return -1;
+
 	struct ipv6_mreq all_nodes = {ALL_IPV6_NODES, iface->ifindex};
 	struct ipv6_mreq all_routers = {ALL_IPV6_ROUTERS, iface->ifindex};
 
@@ -101,7 +105,7 @@ int setup_router_interface(struct interface *iface, bool enable)
 
 	if (!enable) {
 		if (iface->ra)
-			send_router_advert(&iface->timer_rs);
+			trigger_router_advert(&iface->timer_rs);
 	} else {
 		void *mreq = &all_routers;
 
@@ -109,8 +113,8 @@ int setup_router_interface(struct interface *iface, bool enable)
 			mreq = &all_nodes;
 			forward_router_solicitation(iface);
 		} else if (iface->ra == RELAYD_SERVER && !iface->master) {
-			iface->timer_rs.cb = send_router_advert;
-			send_router_advert(&iface->timer_rs);
+			iface->timer_rs.cb = trigger_router_advert;
+			trigger_router_advert(&iface->timer_rs);
 		}
 
 		if (iface->ra == RELAYD_RELAY || (iface->ra == RELAYD_SERVER && !iface->master))
@@ -130,35 +134,39 @@ static void sigusr1_refresh(_unused int signal)
 			uloop_timeout_set(&iface->timer_rs, 1000);
 }
 
-
-// Event handler for incoming ICMPv6 packets
-static void handle_icmpv6(_unused void *addr, void *data, size_t len,
-		struct interface *iface)
+static bool router_icmpv6_valid(struct sockaddr_in6 *source, uint8_t *data, size_t len)
 {
-	struct icmp6_hdr *hdr = data;
-	if ((iface->ra == RELAYD_SERVER && !iface->master)) { // Server mode
-		if (hdr->icmp6_type == ND_ROUTER_SOLICIT)
-			send_router_advert(&iface->timer_rs);
-	} 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());
-	}
-}
+	struct icmp6_hdr *hdr = (struct icmp6_hdr *)data;
+	struct icmpv6_opt *opt, *end = (struct icmpv6_opt*)&data[len];
+
+	/* Hoplimit is already checked in odhcpd_receive_packets */
+	if (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;
 
-static bool match_route(const struct odhcpd_ipaddr *n, const struct in6_addr *addr)
-{
-	if (n->prefix <= 32)
-		return ntohl(n->addr.s6_addr32[0]) >> (32 - n->prefix) ==
-				ntohl(addr->s6_addr32[0]) >> (32 - n->prefix);
+		opt = (struct icmpv6_opt *)((struct nd_router_advert *)data + 1);
+		break;
 
-	if (n->addr.s6_addr32[0] != addr->s6_addr32[0])
+	case ND_ROUTER_SOLICIT:
+		opt = (struct icmpv6_opt *)((struct nd_router_solicit *)data + 1);
+		break;
+
+	default:
 		return false;
+	}
+
+	icmpv6_for_each_option(opt, opt, end)
+		if (opt->type == ND_OPT_SOURCE_LINKADDR &&
+				IN6_IS_ADDR_UNSPECIFIED(&source->sin6_addr) &&
+				hdr->icmp6_type == ND_ROUTER_SOLICIT)
+			return false;
 
-	return ntohl(n->addr.s6_addr32[1]) >> (64 - n->prefix) ==
-			ntohl(addr->s6_addr32[1]) >> (64 - n->prefix);
+	// Check all options parsed successfully
+	return opt == end;
 }
 
 
@@ -169,7 +177,7 @@ static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
 
 	char line[512], ifname[16];
 	bool found_default = false;
-	struct odhcpd_ipaddr p = {IN6ADDR_ANY_INIT, 0, false, 0, 0, 0};
+	struct odhcpd_ipaddr p = {IN6ADDR_ANY_INIT, 0, 0, 0, 0};
 	while (fgets(line, sizeof(line), fp_route)) {
 		uint32_t rflags;
 		if (sscanf(line, "00000000000000000000000000000000 00 "
@@ -186,8 +194,8 @@ static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
 
 			for (ssize_t i = 0; i < len; ++i) {
 				if (n[i].prefix <= 64 && n[i].prefix >= p.prefix &&
-						match_route(&p, &n[i].addr)) {
-					n[i].prefix = p.prefix;
+						!odhcpd_bmemcmp(&p.addr, &n[i].addr, p.prefix)) {
+					n[i].dprefix = p.prefix;
 					break;
 				}
 			}
@@ -198,16 +206,14 @@ static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
 	return found_default;
 }
 
-
 // Router Advert server mode
-static void send_router_advert(struct uloop_timeout *event)
+static uint64_t send_router_advert(struct interface *iface, const struct in6_addr *from)
 {
-	struct interface *iface =
-			container_of(event, struct interface, timer_rs);
+	int mtu = odhcpd_get_interface_config(iface->ifname, "mtu");
+	int hlim = odhcpd_get_interface_config(iface->ifname, "hop_limit");
 
-	int mtu = odhcpd_get_interface_mtu(iface->ifname);
-	if (mtu < 0)
-		mtu = 1500;
+	if (mtu < 1280)
+		mtu = 1280;
 
 	struct {
 		struct nd_router_advert h;
@@ -219,7 +225,13 @@ static void send_router_advert(struct uloop_timeout *event)
 		.lladdr = {ND_OPT_SOURCE_LINKADDR, 1, {0}},
 		.mtu = {ND_OPT_MTU, 1, 0, htonl(mtu)},
 	};
-	adv.h.nd_ra_flags_reserved = ND_RA_FLAG_OTHER;
+
+	if (hlim > 0)
+		adv.h.nd_ra_curhoplimit = hlim;
+
+	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;
 
@@ -232,41 +244,42 @@ static void send_router_advert(struct uloop_timeout *event)
 	// If not currently shutting down
 	struct odhcpd_ipaddr addrs[RELAYD_MAX_PREFIXES];
 	ssize_t ipcnt = 0;
+	uint64_t minvalid = UINT64_MAX;
+	uint64_t maxvalid = 0;
 
 	// If not shutdown
-	if (event->cb) {
+	if (iface->timer_rs.cb) {
 		ipcnt = odhcpd_get_interface_addresses(iface->ifindex,
 				addrs, ARRAY_SIZE(addrs));
 
 		// Check default route
 		if (parse_routes(addrs, ipcnt) || iface->default_router > 1)
-			adv.h.nd_ra_router_lifetime =
-					htons(3 * MaxRtrAdvInterval);
+			adv.h.nd_ra_router_lifetime = 1;
 	}
 
 	// Construct Prefix Information options
-	bool have_public = false;
 	size_t cnt = 0;
 
-	struct in6_addr *dns_addr = NULL;
+	struct in6_addr dns_pref = IN6ADDR_ANY_INIT, *dns_addr = &dns_pref;
 	uint32_t dns_time = 0;
 	size_t dns_cnt = 1;
 
 	for (ssize_t i = 0; i < ipcnt; ++i) {
 		struct odhcpd_ipaddr *addr = &addrs[i];
-		if (addr->prefix > 64 || addr->has_class)
+		if (addr->prefix > 96)
 			continue; // Address not suitable
 
-		if (addr->preferred > MaxPreferredTime)
-			addr->preferred = MaxPreferredTime;
+		if (addr->preferred > MaxValidTime)
+			addr->preferred = MaxValidTime;
 
 		if (addr->valid > MaxValidTime)
 			addr->valid = MaxValidTime;
 
 		struct nd_opt_prefix_info *p = NULL;
 		for (size_t i = 0; i < cnt; ++i) {
-			if (!memcmp(&adv.prefix[i].nd_opt_pi_prefix,
-					&addr->addr, 8))
+			if (addr->prefix == adv.prefix[i].nd_opt_pi_prefix_len &&
+					!odhcpd_bmemcmp(&adv.prefix[i].nd_opt_pi_prefix,
+					&addr->addr, addr->prefix))
 				p = &adv.prefix[i];
 		}
 
@@ -277,46 +290,51 @@ static void send_router_advert(struct uloop_timeout *event)
 			p = &adv.prefix[cnt++];
 		}
 
-		if ((addr->addr.s6_addr[0] & 0xfe) != 0xfc && addr->preferred > 0)
-			have_public = true;
+		if (addr->preferred > 0) {
+			if (minvalid > 1000ULL * addr->valid)
+				minvalid = 1000ULL * addr->valid;
+
+			if (maxvalid < 1000ULL * addr->valid && (iface->default_router ||
+					(addr->addr.s6_addr[0] & 0xfe) != 0xfc))
+				maxvalid = 1000ULL * addr->valid;
+		}
 
-		memcpy(&p->nd_opt_pi_prefix, &addr->addr, 8);
+
+		odhcpd_bmemcpy(&p->nd_opt_pi_prefix, &addr->addr,
+				(iface->ra_advrouter) ? 128 : addr->prefix);
 		p->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
 		p->nd_opt_pi_len = 4;
-		p->nd_opt_pi_prefix_len = 64;
+		p->nd_opt_pi_prefix_len = (addr->prefix < 64) ? 64 : addr->prefix;
 		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)
+		if (iface->managed < RELAYD_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;
 		p->nd_opt_pi_valid_time = htonl(addr->valid);
 		p->nd_opt_pi_preferred_time = htonl(addr->preferred);
 
 		if (addr->preferred > dns_time) {
 			dns_time = addr->preferred;
-			dns_addr = &addr->addr;
+			dns_pref = addr->addr;
 		}
 	}
 
-	if (!have_public && !iface->default_router && adv.h.nd_ra_router_lifetime) {
+	if (!maxvalid && !iface->default_router && adv.h.nd_ra_router_lifetime) {
 		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);
 		adv.h.nd_ra_router_lifetime = 0;
 	}
 
-	if (have_public && iface->deprecate_ula_if_public_avail)
-		for (size_t i = 0; i < cnt; ++i)
-			if ((adv.prefix[i].nd_opt_pi_prefix.s6_addr[0] & 0xfe) == 0xfc)
-				adv.prefix[i].nd_opt_pi_preferred_time = 0;
-
 	// DNS Recursive DNS
 	if (iface->dns_cnt > 0) {
 		dns_addr = iface->dns;
 		dns_cnt = iface->dns_cnt;
-		dns_time = 2 * MaxRtrAdvInterval;
+		dns_time = 0;
 	}
 
-	if (!dns_addr)
+	if (!dns_addr || IN6_IS_ADDR_UNSPECIFIED(dns_addr))
 		dns_cnt = 0;
 
 	struct {
@@ -354,15 +372,10 @@ static void send_router_advert(struct uloop_timeout *event)
 		uint8_t name[];
 	} *search = alloca(sizeof(*search) + search_padded);
 
-	if (!search) {
-		syslog(LOG_ERR, "Alloca failed for dns search on interface %s", iface->ifname);
-		return;
-	}
 	search->type = ND_OPT_DNS_SEARCH;
 	search->len = search_len ? ((sizeof(*search) + search_padded) / 8) : 0;
 	search->pad = 0;
 	search->pad2 = 0;
-	search->lifetime = htonl(2 * MaxRtrAdvInterval);;
 	memcpy(search->name, search_domain, search_len);
 	memset(&search->name[search_len], 0, search_padded - search_len);
 
@@ -379,18 +392,19 @@ static void send_router_advert(struct uloop_timeout *event)
 
 	for (ssize_t i = 0; i < ipcnt; ++i) {
 		struct odhcpd_ipaddr *addr = &addrs[i];
-		if (addr->prefix > 64 || addr->prefix == 0) {
+		if (addr->dprefix > 64 || addr->dprefix == 0 ||
+				(addr->dprefix == 64 && addr->prefix == 64)) {
 			continue; // Address not suitable
-		} else if (addr->prefix > 32) {
-			addr->addr.s6_addr32[1] &= htonl(~((1U << (64 - addr->prefix)) - 1));
-		} else if (addr->prefix <= 32) {
-			addr->addr.s6_addr32[0] &= htonl(~((1U << (32 - addr->prefix)) - 1));
+		} else if (addr->dprefix > 32) {
+			addr->addr.s6_addr32[1] &= htonl(~((1U << (64 - addr->dprefix)) - 1));
+		} else if (addr->dprefix <= 32) {
+			addr->addr.s6_addr32[0] &= htonl(~((1U << (32 - addr->dprefix)) - 1));
 			addr->addr.s6_addr32[1] = 0;
 		}
 
 		routes[routes_cnt].type = ND_OPT_ROUTE_INFO;
 		routes[routes_cnt].len = sizeof(*routes) / 8;
-		routes[routes_cnt].prefix = addr->prefix;
+		routes[routes_cnt].prefix = addr->dprefix;
 		routes[routes_cnt].flags = 0;
 		if (iface->route_preference < 0)
 			routes[routes_cnt].flags |= ND_RA_PREF_LOW;
@@ -399,28 +413,94 @@ static void send_router_advert(struct uloop_timeout *event)
 		routes[routes_cnt].lifetime = htonl(addr->valid);
 		routes[routes_cnt].addr[0] = addr->addr.s6_addr32[0];
 		routes[routes_cnt].addr[1] = addr->addr.s6_addr32[1];
-		routes[routes_cnt].addr[2] = addr->addr.s6_addr32[2];
-		routes[routes_cnt].addr[3] = addr->addr.s6_addr32[3];
+		routes[routes_cnt].addr[2] = 0;
+		routes[routes_cnt].addr[3] = 0;
 
 		++routes_cnt;
 	}
 
+	// Calculate periodic transmit
+	int msecs = 0;
+	uint32_t maxival = iface->ra_maxinterval * 1000;
+	uint32_t minival;
+
+	if (maxival < 4000 || maxival > MaxRtrAdvInterval * 1000)
+		maxival = MaxRtrAdvInterval * 1000;
+
+	if (maxival > minvalid / 3) {
+		maxival = minvalid / 3;
+
+		if (maxival < 4000)
+			maxival = 4000;
+	}
+
+	minival = (maxival * 3) / 4;
+	if (adv.h.nd_ra_router_lifetime)
+		adv.h.nd_ra_router_lifetime = htons(maxvalid / 1000);
+
+	search->lifetime = htonl(maxvalid / 1000);
+
+	if (!dns.lifetime)
+		dns.lifetime = search->lifetime;
+
+	odhcpd_urandom(&msecs, sizeof(msecs));
+	msecs = (labs(msecs) % (maxival - minival)) + minival;
 
-	struct iovec iov[] = {{&adv, (uint8_t*)&adv.prefix[cnt] - (uint8_t*)&adv},
+	struct icmpv6_opt adv_interval = {
+		.type = ND_OPT_RTR_ADV_INTERVAL,
+		.len = 1,
+		.data = {0, 0, maxival >> 24, maxival >> 16, maxival >> 8, maxival}
+	};
+
+	struct iovec iov[RA_IOV_LEN] = {
+			{&adv, (uint8_t*)&adv.prefix[cnt] - (uint8_t*)&adv},
 			{&routes, routes_cnt * sizeof(*routes)},
 			{&dns, (dns_cnt) ? sizeof(dns) : 0},
 			{dns_addr, dns_cnt * sizeof(*dns_addr)},
-			{search, search->len * 8}};
-	struct sockaddr_in6 all_nodes = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
+			{search, search->len * 8},
+			{&adv_interval, adv_interval.len * 8}};
+	struct sockaddr_in6 dest = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
+
+	if (from && !IN6_IS_ADDR_UNSPECIFIED(from))
+		dest.sin6_addr = *from;
+
 	odhcpd_send(router_event.uloop.fd,
-			&all_nodes, iov, ARRAY_SIZE(iov), iface);
+			&dest, iov, ARRAY_SIZE(iov), iface);
 
-	// Rearm timer
-	int msecs;
-	odhcpd_urandom(&msecs, sizeof(msecs));
-	msecs = (labs(msecs) % (1000 * (MaxRtrAdvInterval
-			- MinRtrAdvInterval))) + (MinRtrAdvInterval * 1000);
-	uloop_timeout_set(&iface->timer_rs, msecs);
+	return msecs;
+}
+
+
+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
+	if (event->cb)
+		uloop_timeout_set(event, msecs);
+}
+
+
+// Event handler for incoming ICMPv6 packets
+static void handle_icmpv6(void *addr, void *data, size_t len,
+		struct interface *iface, _unused void *dest)
+{
+	struct icmp6_hdr *hdr = data;
+	struct sockaddr_in6 *from = addr;
+
+	if (!router_icmpv6_valid(addr, data, len))
+		return;
+
+	if ((iface->ra == RELAYD_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());
+	}
 }
 
 
@@ -472,7 +552,6 @@ static void forward_router_advertisement(uint8_t *data, size_t len)
 	struct sockaddr_in6 all_nodes = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
 	struct iovec iov = {data, len};
 
-	struct odhcpd_ipaddr addr;
 	struct interface *iface;
 	list_for_each_entry(iface, &interfaces, head) {
 		if (iface->ra != RELAYD_RELAY || iface->master)
@@ -485,13 +564,14 @@ static void forward_router_advertisement(uint8_t *data, size_t len)
 		// If we have to rewrite DNS entries
 		if (iface->always_rewrite_dns && dns_ptr && dns_count > 0) {
 			const struct in6_addr *rewrite = iface->dns;
+			struct in6_addr addr;
 			size_t rewrite_cnt = iface->dns_cnt;
 
 			if (rewrite_cnt == 0) {
-				if (odhcpd_get_interface_addresses(iface->ifindex, &addr, 1) < 1)
+				if (odhcpd_get_preferred_interface_address(iface->ifindex, &addr) < 1)
 					continue; // Unable to comply
 
-				rewrite = &addr.addr;
+				rewrite = &addr;
 				rewrite_cnt = 1;
 			}