2 * Copyright (C) 2012-2014 Steven Barth <steven@midlink.org>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License v2 as published by
6 * the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
25 #include <arpa/inet.h>
26 #include <sys/socket.h>
27 #include <sys/types.h>
28 #include <netinet/in.h>
29 #include <netinet/icmp6.h>
31 #include <linux/rtnetlink.h>
34 #define SOL_NETLINK 270
37 #ifndef NETLINK_ADD_MEMBERSHIP
38 #define NETLINK_ADD_MEMBERSHIP 1
42 #define IFF_LOWER_UP 0x10000
49 static bool nocarrier = false;
51 static int sock = -1, rtnl = -1;
52 static int if_index = 0;
53 static char if_name[IF_NAMESIZE] = {0};
54 static volatile int rs_attempt = 0;
55 static struct in6_addr lladdr = IN6ADDR_ANY_INIT;
59 struct icmpv6_opt lladdr;
61 .hdr = {ND_ROUTER_SOLICIT, 0, 0, {{0}}},
62 .lladdr = {ND_OPT_SOURCE_LINKADDR, 1, {0}},
66 static void ra_send_rs(int signal __attribute__((unused)));
68 int ra_init(const char *ifname, const struct in6_addr *ifid)
70 const pid_t ourpid = getpid();
71 sock = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
75 if_index = if_nametoindex(ifname);
79 strncpy(if_name, ifname, sizeof(if_name) - 1);
82 rtnl = socket(AF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
86 struct sockaddr_nl rtnl_kernel = { .nl_family = AF_NETLINK };
87 if (connect(rtnl, (const struct sockaddr*)&rtnl_kernel, sizeof(rtnl_kernel)) < 0)
90 int val = RTNLGRP_LINK;
91 setsockopt(rtnl, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &val, sizeof(val));
92 fcntl(rtnl, F_SETOWN, ourpid);
93 fcntl(rtnl, F_SETFL, fcntl(sock, F_GETFL) | O_ASYNC);
99 .hdr = {sizeof(req), RTM_GETLINK, NLM_F_REQUEST, 1, 0},
100 .ifi = {.ifi_index = if_index}
102 send(rtnl, &req, sizeof(req), 0);
105 // Filter ICMPv6 package types
106 struct icmp6_filter filt;
107 ICMP6_FILTER_SETBLOCKALL(&filt);
108 ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filt);
109 setsockopt(sock, IPPROTO_ICMPV6, ICMP6_FILTER, &filt, sizeof(filt));
112 struct ipv6_mreq an = {ALL_IPV6_NODES, if_index};
113 setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &an, sizeof(an));
115 // Let the kernel compute our checksums
117 setsockopt(sock, IPPROTO_RAW, IPV6_CHECKSUM, &val, sizeof(val));
119 // This is required by RFC 4861
121 setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val, sizeof(val));
123 // Receive multicast hops
125 setsockopt(sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &val, sizeof(val));
127 // Bind to one device
128 setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname));
131 fcntl(sock, F_SETOWN, ourpid);
132 fcntl(sock, F_SETFL, fcntl(sock, F_GETFL) | O_ASYNC);
135 signal(SIGALRM, ra_send_rs);
142 static void ra_send_rs(int signal __attribute__((unused)))
144 const struct sockaddr_in6 dest = {AF_INET6, 0, 0, ALL_IPV6_ROUTERS, if_index};
145 const struct icmpv6_opt llnull = {ND_OPT_SOURCE_LINKADDR, 1, {0}};
148 if ((rs_attempt % 2 == 0) && memcmp(&rs.lladdr, &llnull, sizeof(llnull)))
151 len = sizeof(struct icmp6_hdr);
153 sendto(sock, &rs, len, MSG_DONTWAIT, (struct sockaddr*)&dest, sizeof(dest));
155 if (++rs_attempt <= 3)
160 static int16_t pref_to_priority(uint8_t flags)
162 flags = (flags >> 3) & 0x03;
163 return (flags == 0x0) ? 512 : (flags == 0x1) ? 384 :
164 (flags == 0x3) ? 640 : -1;
168 static int update_proc(const char *sect, const char *opt, uint32_t value)
171 snprintf(buf, sizeof(buf), "/proc/sys/net/ipv6/%s/%s/%s", sect, if_name, opt);
173 int fd = open(buf, O_WRONLY);
174 int ret = write(fd, buf, snprintf(buf, sizeof(buf), "%u", value));
181 bool ra_link_up(void)
183 static bool firstcall = true;
186 struct ifinfomsg msg;
194 read = recv(rtnl, &resp, sizeof(resp), MSG_DONTWAIT);
195 if (read < 0 || !NLMSG_OK(&resp.hdr, (size_t)read) ||
196 resp.hdr.nlmsg_type != RTM_NEWLINK ||
197 resp.msg.ifi_index != if_index)
200 ssize_t alen = NLMSG_PAYLOAD(&resp.hdr, sizeof(resp.msg));
201 for (struct rtattr *rta = (struct rtattr*)(resp.pad);
202 RTA_OK(rta, alen); rta = RTA_NEXT(rta, alen)) {
203 if (rta->rta_type == IFLA_ADDRESS &&
204 RTA_PAYLOAD(rta) >= sizeof(rs.lladdr.data))
205 memcpy(rs.lladdr.data, RTA_DATA(rta), sizeof(rs.lladdr.data));
208 bool hascarrier = resp.msg.ifi_flags & IFF_LOWER_UP;
209 if (!firstcall && nocarrier != !hascarrier)
212 nocarrier = !hascarrier;
217 syslog(LOG_NOTICE, "carrier => %i event on %s", (int)!nocarrier, if_name);
226 static bool ra_icmpv6_valid(struct sockaddr_in6 *source, int hlim, uint8_t *data, size_t len)
228 struct icmp6_hdr *hdr = (struct icmp6_hdr*)data;
229 struct icmpv6_opt *opt, *end = (struct icmpv6_opt*)&data[len];
231 if (hlim != 255 || len < sizeof(*hdr) || hdr->icmp6_code)
234 switch (hdr->icmp6_type) {
235 case ND_ROUTER_ADVERT:
236 if (!IN6_IS_ADDR_LINKLOCAL(&source->sin6_addr))
239 opt = (struct icmpv6_opt*)((struct nd_router_advert*)data + 1);
246 icmpv6_for_each_option(opt, opt, end)
252 bool ra_process(void)
255 bool changed = false;
256 uint8_t buf[1500], cmsg_buf[128];
257 struct nd_router_advert *adv = (struct nd_router_advert*)buf;
258 struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT, 0, 0, IN6ADDR_ANY_INIT, 0, 0, 0, 0, 0, 0};
259 const struct in6_addr any = IN6ADDR_ANY_INIT;
261 if (IN6_IS_ADDR_UNSPECIFIED(&lladdr)) {
262 struct sockaddr_in6 addr = {AF_INET6, 0, 0, ALL_IPV6_ROUTERS, if_index};
263 socklen_t alen = sizeof(addr);
264 int sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
266 if (!connect(sock, (struct sockaddr*)&addr, sizeof(addr)) &&
267 !getsockname(sock, (struct sockaddr*)&addr, &alen))
268 lladdr = addr.sin6_addr;
274 struct sockaddr_in6 from;
275 struct iovec iov = {buf, sizeof(buf)};
276 struct msghdr msg = {
277 .msg_name = (void *) &from,
278 .msg_namelen = sizeof(from),
281 .msg_control = cmsg_buf,
282 .msg_controllen = sizeof(cmsg_buf),
286 ssize_t len = recvmsg(sock, &msg, MSG_DONTWAIT);
290 if (IN6_IS_ADDR_UNSPECIFIED(&lladdr))
294 for (struct cmsghdr *ch = CMSG_FIRSTHDR(&msg); ch != NULL;
295 ch = CMSG_NXTHDR(&msg, ch))
296 if (ch->cmsg_level == IPPROTO_IPV6 &&
297 ch->cmsg_type == IPV6_HOPLIMIT)
298 memcpy(&hlim, CMSG_DATA(ch), sizeof(hlim));
300 if (!ra_icmpv6_valid(&from, hlim, buf, len))
303 // Stop sending solicits
304 if (rs_attempt > 0) {
313 uint32_t router_valid = ntohs(adv->nd_ra_router_lifetime);
315 // Parse default route
318 entry.router = from.sin6_addr;
319 entry.priority = pref_to_priority(adv->nd_ra_flags_reserved);
320 if (entry.priority < 0)
321 entry.priority = pref_to_priority(0);
322 entry.valid = router_valid;
323 entry.preferred = entry.valid;
324 changed |= odhcp6c_update_entry(STATE_RA_ROUTE, &entry, 0, true);
327 if (adv->nd_ra_curhoplimit)
328 update_proc("conf", "hop_limit", adv->nd_ra_curhoplimit);
330 // Parse ND parameters
331 uint32_t reachable = ntohl(adv->nd_ra_reachable);
332 if (reachable > 0 && reachable <= 3600000)
333 update_proc("neigh", "base_reachable_time_ms", reachable);
335 uint32_t retransmit = ntohl(adv->nd_ra_retransmit);
336 if (retransmit > 0 && retransmit <= 60000)
337 update_proc("neigh", "retrans_time_ms", retransmit);
341 struct icmpv6_opt *opt;
342 icmpv6_for_each_option(opt, &adv[1], &buf[len]) {
343 if (opt->type == ND_OPT_MTU) {
344 uint32_t *mtu = (uint32_t*)&opt->data[2];
345 if (ntohl(*mtu) >= 1280 && ntohl(*mtu) <= 65535)
346 update_proc("conf", "mtu", ntohl(*mtu));
347 } else if (opt->type == ND_OPT_ROUTE_INFORMATION && opt->len <= 3) {
348 entry.router = from.sin6_addr;
350 entry.priority = pref_to_priority(opt->data[1]);
351 entry.length = opt->data[0];
352 uint32_t *valid = (uint32_t*)&opt->data[2];
353 entry.valid = ntohl(*valid);
354 memcpy(&entry.target, &opt->data[6], (opt->len - 1) * 8);
356 if (entry.length > 128 || IN6_IS_ADDR_LINKLOCAL(&entry.target)
357 || IN6_IS_ADDR_LOOPBACK(&entry.target)
358 || IN6_IS_ADDR_MULTICAST(&entry.target))
361 if (entry.priority > 0)
362 changed |= odhcp6c_update_entry(STATE_RA_ROUTE, &entry, 0, true);
363 } else if (opt->type == ND_OPT_PREFIX_INFORMATION && opt->len == 4) {
364 struct nd_opt_prefix_info *pinfo = (struct nd_opt_prefix_info*)opt;
366 entry.target = pinfo->nd_opt_pi_prefix;
367 entry.priority = 256;
368 entry.length = pinfo->nd_opt_pi_prefix_len;
369 entry.valid = ntohl(pinfo->nd_opt_pi_valid_time);
370 entry.preferred = ntohl(pinfo->nd_opt_pi_preferred_time);
372 if (entry.length > 128 || IN6_IS_ADDR_LINKLOCAL(&entry.target)
373 || IN6_IS_ADDR_LOOPBACK(&entry.target)
374 || IN6_IS_ADDR_MULTICAST(&entry.target)
375 || entry.valid < entry.preferred)
378 if (pinfo->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ONLINK)
379 changed |= odhcp6c_update_entry(STATE_RA_ROUTE, &entry, 7200, true);
381 if (!(pinfo->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_AUTO) ||
382 pinfo->nd_opt_pi_prefix_len != 64)
385 entry.target.s6_addr32[2] = lladdr.s6_addr32[2];
386 entry.target.s6_addr32[3] = lladdr.s6_addr32[3];
388 changed |= odhcp6c_update_entry(STATE_RA_PREFIX, &entry, 7200, true);
389 } else if (opt->type == ND_OPT_RECURSIVE_DNS && opt->len > 2) {
390 entry.router = from.sin6_addr;
393 uint32_t *valid = (uint32_t*)&opt->data[2];
394 entry.valid = ntohl(*valid);
397 for (ssize_t i = 0; i < (opt->len - 1) / 2; ++i) {
398 memcpy(&entry.target, &opt->data[6 + i * sizeof(entry.target)],
399 sizeof(entry.target));
400 changed |= odhcp6c_update_entry(STATE_RA_DNS, &entry, 0, true);
406 struct odhcp6c_entry *entry = odhcp6c_get_state(STATE_RA_DNS, &ra_dns_len);
407 for (size_t i = 0; i < ra_dns_len / sizeof(*entry); ++i)
408 if (IN6_ARE_ADDR_EQUAL(&entry[i].router, &from.sin6_addr) &&
409 entry[i].valid > router_valid)
410 entry[i].valid = router_valid;
416 return found && changed;