2 * Copyright (C) 2012-2013 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.
22 #include <arpa/inet.h>
23 #include <sys/socket.h>
24 #include <net/ethernet.h>
25 #include <netinet/ip6.h>
26 #include <netinet/icmp6.h>
27 #include <netpacket/packet.h>
29 #include <linux/rtnetlink.h>
30 #include <linux/filter.h>
32 #include <netlink/msg.h>
33 #include <netlink/socket.h>
34 #include <netlink/attr.h>
40 struct odhcpd_event ev;
45 static void handle_solicit(void *addr, void *data, size_t len,
46 struct interface *iface, void *dest);
47 static void handle_rtnl_event(struct odhcpd_event *ev);
48 static int cb_rtnl_valid(struct nl_msg *msg, void *arg);
49 static void catch_rtnl_err(struct odhcpd_event *e, int error);
51 static int addr6_dump_rqs = 0;
52 static int ping_socket = -1;
53 static struct event_socket rtnl_event = {
55 .uloop = {.fd = - 1, },
57 .handle_error = catch_rtnl_err,
58 .recv_msgs = handle_rtnl_event,
61 .sock_bufsize = 133120,
64 // Filter ICMPv6 messages of type neighbor soliciation
65 static struct sock_filter bpf[] = {
66 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, offsetof(struct ip6_hdr, ip6_nxt)),
67 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, IPPROTO_ICMPV6, 0, 3),
68 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, sizeof(struct ip6_hdr) +
69 offsetof(struct icmp6_hdr, icmp6_type)),
70 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ND_NEIGHBOR_SOLICIT, 0, 1),
71 BPF_STMT(BPF_RET | BPF_K, 0xffffffff),
72 BPF_STMT(BPF_RET | BPF_K, 0),
74 static const struct sock_fprog bpf_prog = {sizeof(bpf) / sizeof(*bpf), bpf};
77 // Initialize NDP-proxy
82 rtnl_event.sock = odhcpd_create_nl_socket(NETLINK_ROUTE);
86 rtnl_event.ev.uloop.fd = nl_socket_get_fd(rtnl_event.sock);
88 if (nl_socket_set_buffer_size(rtnl_event.sock, rtnl_event.sock_bufsize, 0))
91 nl_socket_disable_seq_check(rtnl_event.sock);
93 nl_socket_modify_cb(rtnl_event.sock, NL_CB_VALID, NL_CB_CUSTOM,
96 // Receive IPv6 address, IPv6 routes and neighbor events
97 if (nl_socket_add_memberships(rtnl_event.sock, RTNLGRP_IPV6_IFADDR,
98 RTNLGRP_IPV6_ROUTE, RTNLGRP_NEIGH, 0))
101 odhcpd_register(&rtnl_event.ev);
103 // Open ICMPv6 socket
104 ping_socket = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
105 if (ping_socket < 0) {
106 syslog(LOG_ERR, "Unable to open raw socket: %s", strerror(errno));
110 setsockopt(ping_socket, IPPROTO_RAW, IPV6_CHECKSUM, &val, sizeof(val));
112 // This is required by RFC 4861
114 setsockopt(ping_socket, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val, sizeof(val));
115 setsockopt(ping_socket, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &val, sizeof(val));
117 // Filter all packages, we only want to send
118 struct icmp6_filter filt;
119 ICMP6_FILTER_SETBLOCKALL(&filt);
120 setsockopt(ping_socket, IPPROTO_ICMPV6, ICMP6_FILTER, &filt, sizeof(filt));
125 if (rtnl_event.sock) {
126 nl_socket_free(rtnl_event.sock);
127 rtnl_event.sock = NULL;
128 rtnl_event.ev.uloop.fd = -1;
134 static void dump_neigh_table(const bool proxy)
138 .ndm_family = AF_INET6,
139 .ndm_flags = proxy ? NTF_PROXY : 0,
142 msg = nlmsg_alloc_simple(RTM_GETNEIGH, NLM_F_REQUEST | NLM_F_DUMP);
146 nlmsg_append(msg, &ndm, sizeof(ndm), 0);
148 nl_send_auto_complete(rtnl_event.sock, msg);
153 static void dump_addr6_table(void)
156 struct ifaddrmsg ifa = {
157 .ifa_family = AF_INET6,
160 msg = nlmsg_alloc_simple(RTM_GETADDR, NLM_F_REQUEST | NLM_F_DUMP);
164 nlmsg_append(msg, &ifa, sizeof(ifa), 0);
166 nl_send_auto_complete(rtnl_event.sock, msg);
171 void ndp_handle_addr6_dump(void)
180 inline void ndp_rqs_addr6_dump(void)
185 int setup_ndp_interface(struct interface *iface, bool enable)
188 bool dump_neigh = false;
191 snprintf(procbuf, sizeof(procbuf), "/proc/sys/net/ipv6/conf/%s/proxy_ndp", iface->ifname);
192 procfd = open(procbuf, O_WRONLY);
199 if (iface->ndp_event.uloop.fd > 0) {
200 uloop_fd_delete(&iface->ndp_event.uloop);
201 close(iface->ndp_event.uloop.fd);
202 iface->ndp_event.uloop.fd = -1;
204 if (!enable || iface->ndp != RELAYD_RELAY)
205 if (write(procfd, "0\n", 2) < 0) {}
210 if (enable && iface->ndp == RELAYD_RELAY) {
211 if (write(procfd, "1\n", 2) < 0) {}
213 int sock = socket(AF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, htons(ETH_P_IPV6));
215 syslog(LOG_ERR, "Unable to open packet socket: %s",
221 #ifdef PACKET_RECV_TYPE
222 int pktt = 1 << PACKET_MULTICAST;
223 setsockopt(sock, SOL_PACKET, PACKET_RECV_TYPE, &pktt, sizeof(pktt));
226 if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER,
227 &bpf_prog, sizeof(bpf_prog))) {
228 syslog(LOG_ERR, "Failed to set BPF: %s", strerror(errno));
233 struct sockaddr_ll ll = {
234 .sll_family = AF_PACKET,
235 .sll_ifindex = iface->ifindex,
236 .sll_protocol = htons(ETH_P_IPV6),
242 bind(sock, (struct sockaddr*)&ll, sizeof(ll));
244 struct packet_mreq mreq = {iface->ifindex, PACKET_MR_ALLMULTI, ETH_ALEN, {0}};
245 setsockopt(sock, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
247 iface->ndp_event.uloop.fd = sock;
248 iface->ndp_event.handle_dgram = handle_solicit;
249 odhcpd_register(&iface->ndp_event);
251 // If we already were enabled dump is unnecessary, if not do dump
253 dump_neigh_table(false);
257 ndp_rqs_addr6_dump();
261 dump_neigh_table(true);
271 // Send an ICMP-ECHO. This is less for actually pinging but for the
272 // neighbor cache to be kept up-to-date.
273 static void ping6(struct in6_addr *addr,
274 const struct interface *iface)
276 struct sockaddr_in6 dest = { .sin6_family = AF_INET6, .sin6_addr = *addr, .sin6_scope_id = iface->ifindex, };
277 struct icmp6_hdr echo = { .icmp6_type = ICMP6_ECHO_REQUEST };
278 struct iovec iov = { .iov_base = &echo, .iov_len = sizeof(echo) };
279 char ipbuf[INET6_ADDRSTRLEN];
281 inet_ntop(AF_INET6, addr, ipbuf, sizeof(ipbuf));
282 syslog(LOG_NOTICE, "Pinging for %s%%%s", ipbuf, iface->ifname);
284 odhcpd_setup_route(addr, 128, iface, NULL, 128, true);
285 odhcpd_send(ping_socket, &dest, &iov, 1, iface);
286 odhcpd_setup_route(addr, 128, iface, NULL, 128, false);
289 // Handle solicitations
290 static void handle_solicit(void *addr, void *data, size_t len,
291 struct interface *iface, _unused void *dest)
293 struct ip6_hdr *ip6 = data;
294 struct nd_neighbor_solicit *req = (struct nd_neighbor_solicit*)&ip6[1];
295 struct sockaddr_ll *ll = addr;
296 char ipbuf[INET6_ADDRSTRLEN];
299 // Solicitation is for duplicate address detection
300 bool ns_is_dad = IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src);
302 // Don't process solicit messages on non relay interfaces
303 // Don't forward any non-DAD solicitation for external ifaces
304 // TODO: check if we should even forward DADs for them
305 if (iface->ndp != RELAYD_RELAY || (iface->external && !ns_is_dad))
308 if (len < sizeof(*ip6) + sizeof(*req))
309 return; // Invalid reqicitation
311 if (IN6_IS_ADDR_LINKLOCAL(&req->nd_ns_target) ||
312 IN6_IS_ADDR_LOOPBACK(&req->nd_ns_target) ||
313 IN6_IS_ADDR_MULTICAST(&req->nd_ns_target))
314 return; // Invalid target
316 inet_ntop(AF_INET6, &req->nd_ns_target, ipbuf, sizeof(ipbuf));
317 syslog(LOG_DEBUG, "Got a NS for %s%%%s", ipbuf, iface->ifname);
319 odhcpd_get_mac(iface, mac);
320 if (!memcmp(ll->sll_addr, mac, sizeof(mac)))
321 return; // Looped back
324 list_for_each_entry(c, &interfaces, head)
325 if (iface != c && c->ndp == RELAYD_RELAY &&
326 (ns_is_dad || !c->external))
327 ping6(&req->nd_ns_target, c);
330 // Use rtnetlink to modify kernel routes
331 static void setup_route(struct in6_addr *addr, struct interface *iface, bool add)
333 char ipbuf[INET6_ADDRSTRLEN];
335 inet_ntop(AF_INET6, addr, ipbuf, sizeof(ipbuf));
336 syslog(LOG_NOTICE, "%s about %s%%%s",
337 (add) ? "Learned" : "Forgot", ipbuf, iface->ifname);
339 if (iface->learn_routes)
340 odhcpd_setup_route(addr, 128, iface, NULL, 1024, add);
344 static int prefixcmp(const void *va, const void *vb)
346 const struct odhcpd_ipaddr *a = va, *b = vb;
347 uint32_t a_pref = IN6_IS_ADDR_ULA(&a->addr) ? 1 : a->preferred;
348 uint32_t b_pref = IN6_IS_ADDR_ULA(&b->addr) ? 1 : b->preferred;
349 return (a_pref < b_pref) ? 1 : (a_pref > b_pref) ? -1 : 0;
352 // Check address update
353 static void check_addr_updates(struct interface *iface)
355 struct odhcpd_ipaddr addr[RELAYD_MAX_ADDRS] = {{IN6ADDR_ANY_INIT, 0, 0, 0, 0}};
356 time_t now = odhcpd_time();
357 ssize_t len = odhcpd_get_interface_addresses(iface->ifindex, addr, ARRAY_SIZE(addr));
362 qsort(addr, len, sizeof(*addr), prefixcmp);
364 for (int i = 0; i < len; ++i) {
365 if (addr[i].preferred < UINT32_MAX - now)
366 addr[i].preferred += now;
368 if (addr[i].valid < UINT32_MAX - now)
369 addr[i].valid += now;
372 bool change = len != (ssize_t)iface->ia_addr_len;
373 for (ssize_t i = 0; !change && i < len; ++i)
374 if (!IN6_ARE_ADDR_EQUAL(&addr[i].addr, &iface->ia_addr[i].addr) ||
375 (addr[i].preferred > 0) != (iface->ia_addr[i].preferred > 0) ||
376 addr[i].valid < iface->ia_addr[i].valid ||
377 addr[i].preferred < iface->ia_addr[i].preferred)
381 dhcpv6_ia_preupdate(iface);
383 memcpy(iface->ia_addr, addr, len * sizeof(*addr));
384 iface->ia_addr_len = len;
387 dhcpv6_ia_postupdate(iface, now);
390 syslog(LOG_INFO, "Raising SIGUSR1 due to address change on %s", iface->ifname);
395 static void setup_addr_for_relaying(struct in6_addr *addr, struct interface *iface, bool add)
398 char ipbuf[INET6_ADDRSTRLEN];
400 inet_ntop(AF_INET6, addr, ipbuf, sizeof(ipbuf));
402 list_for_each_entry(c, &interfaces, head) {
403 if (iface == c || (c->ndp != RELAYD_RELAY && !add))
406 bool neigh_add = (c->ndp == RELAYD_RELAY ? add : false);
408 if (odhcpd_setup_proxy_neigh(addr, c, neigh_add))
409 syslog(LOG_DEBUG, "Failed to %s proxy neighbour entry %s%%%s",
410 neigh_add ? "add" : "delete", ipbuf, c->ifname);
412 syslog(LOG_DEBUG, "%s proxy neighbour entry %s%%%s",
413 neigh_add ? "Added" : "Deleted", ipbuf, c->ifname);
417 static void handle_rtnl_event(struct odhcpd_event *e)
419 struct event_socket *ev_sock = container_of(e, struct event_socket, ev);
421 nl_recvmsgs_default(ev_sock->sock);
425 // Handler for neighbor cache entries from the kernel. This is our source
426 // to learn and unlearn hosts on interfaces.
427 static int cb_rtnl_valid(struct nl_msg *msg, _unused void *arg)
429 struct nlmsghdr *hdr = nlmsg_hdr(msg);
430 struct in6_addr *addr = NULL;
431 struct interface *iface = NULL;
433 char ipbuf[INET6_ADDRSTRLEN];
435 switch (hdr->nlmsg_type) {
438 struct rtmsg *rtm = nlmsg_data(hdr);
440 if (!nlmsg_valid_hdr(hdr, sizeof(*rtm)) ||
441 rtm->rtm_family != AF_INET6)
444 if (rtm->rtm_dst_len == 0) {
445 syslog(LOG_INFO, "Raising SIGUSR1 due to default route change");
454 struct ifaddrmsg *ifa = nlmsg_data(hdr);
455 struct nlattr *nla[__IFA_MAX];
457 if (!nlmsg_valid_hdr(hdr, sizeof(*ifa)) ||
458 ifa->ifa_family != AF_INET6)
461 iface = odhcpd_get_interface_by_index(ifa->ifa_index);
465 nlmsg_parse(hdr, sizeof(*ifa), nla, __IFA_MAX - 1, NULL);
466 if (!nla[IFA_ADDRESS])
469 addr = nla_data(nla[IFA_ADDRESS]);
470 if (!addr || IN6_IS_ADDR_LINKLOCAL(addr) ||
471 IN6_IS_ADDR_MULTICAST(addr))
474 inet_ntop(AF_INET6, addr, ipbuf, sizeof(ipbuf));
475 syslog(LOG_DEBUG, "Netlink %s %s%%%s", true ? "newaddr" : "deladdr",
476 ipbuf, iface->ifname);
478 check_addr_updates(iface);
480 if (iface->ndp != RELAYD_RELAY)
483 /* handle the relay logic below */
484 setup_addr_for_relaying(addr, iface, add);
487 dump_neigh_table(false);
494 struct ndmsg *ndm = nlmsg_data(hdr);
495 struct nlattr *nla[__NDA_MAX];
497 if (!nlmsg_valid_hdr(hdr, sizeof(*ndm)) ||
498 ndm->ndm_family != AF_INET6)
501 iface = odhcpd_get_interface_by_index(ndm->ndm_ifindex);
502 if (!iface || iface->ndp != RELAYD_RELAY)
503 return (iface ? NL_OK : NL_SKIP);
505 nlmsg_parse(hdr, sizeof(*ndm), nla, __NDA_MAX - 1, NULL);
509 addr = nla_data(nla[NDA_DST]);
510 if (!addr || IN6_IS_ADDR_LINKLOCAL(addr) ||
511 IN6_IS_ADDR_MULTICAST(addr))
514 inet_ntop(AF_INET6, addr, ipbuf, sizeof(ipbuf));
515 syslog(LOG_DEBUG, "Netlink %s %s%%%s", true ? "newneigh" : "delneigh",
516 ipbuf, iface->ifname);
518 if (ndm->ndm_flags & NTF_PROXY) {
519 /* Dump and flush proxy entries */
520 if (hdr->nlmsg_type == RTM_NEWNEIGH) {
521 odhcpd_setup_proxy_neigh(addr, iface, false);
522 setup_route(addr, iface, false);
523 dump_neigh_table(false);
529 if (add && !(ndm->ndm_state &
530 (NUD_REACHABLE | NUD_STALE | NUD_DELAY | NUD_PROBE |
531 NUD_PERMANENT | NUD_NOARP)))
534 setup_addr_for_relaying(addr, iface, add);
535 setup_route(addr, iface, add);
538 dump_neigh_table(false);
549 static void catch_rtnl_err(struct odhcpd_event *e, int error)
551 struct event_socket *ev_sock = container_of(e, struct event_socket, ev);
553 if (error != ENOBUFS)
556 /* Double netlink event buffer size */
557 ev_sock->sock_bufsize *= 2;
559 if (nl_socket_set_buffer_size(ev_sock->sock, ev_sock->sock_bufsize, 0))
566 odhcpd_deregister(e);