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 ping_socket = -1;
52 static struct event_socket rtnl_event = {
54 .uloop = {.fd = - 1, },
56 .handle_error = catch_rtnl_err,
57 .recv_msgs = handle_rtnl_event,
60 .sock_bufsize = 133120,
63 // Filter ICMPv6 messages of type neighbor soliciation
64 static struct sock_filter bpf[] = {
65 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, offsetof(struct ip6_hdr, ip6_nxt)),
66 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, IPPROTO_ICMPV6, 0, 3),
67 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, sizeof(struct ip6_hdr) +
68 offsetof(struct icmp6_hdr, icmp6_type)),
69 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ND_NEIGHBOR_SOLICIT, 0, 1),
70 BPF_STMT(BPF_RET | BPF_K, 0xffffffff),
71 BPF_STMT(BPF_RET | BPF_K, 0),
73 static const struct sock_fprog bpf_prog = {sizeof(bpf) / sizeof(*bpf), bpf};
76 // Initialize NDP-proxy
81 rtnl_event.sock = odhcpd_create_nl_socket(NETLINK_ROUTE);
85 rtnl_event.ev.uloop.fd = nl_socket_get_fd(rtnl_event.sock);
87 if (nl_socket_set_buffer_size(rtnl_event.sock, rtnl_event.sock_bufsize, 0))
90 nl_socket_disable_seq_check(rtnl_event.sock);
92 nl_socket_modify_cb(rtnl_event.sock, NL_CB_VALID, NL_CB_CUSTOM,
95 // Receive IPv4 address, IPv6 address, IPv6 routes and neighbor events
96 if (nl_socket_add_memberships(rtnl_event.sock, RTNLGRP_IPV4_IFADDR,
97 RTNLGRP_IPV6_IFADDR, RTNLGRP_IPV6_ROUTE,
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_addr_table(bool v6)
156 struct ifaddrmsg ifa = {
157 .ifa_family = v6 ? AF_INET6 : AF_INET,
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 int setup_ndp_interface(struct interface *iface, bool enable)
174 bool dump_neigh = false;
177 snprintf(procbuf, sizeof(procbuf), "/proc/sys/net/ipv6/conf/%s/proxy_ndp", iface->ifname);
178 procfd = open(procbuf, O_WRONLY);
185 if (iface->ndp_event.uloop.fd > 0) {
186 uloop_fd_delete(&iface->ndp_event.uloop);
187 close(iface->ndp_event.uloop.fd);
188 iface->ndp_event.uloop.fd = -1;
190 if (!enable || iface->ndp != MODE_RELAY)
191 if (write(procfd, "0\n", 2) < 0) {}
196 if (enable && iface->ndp == MODE_RELAY) {
197 if (write(procfd, "1\n", 2) < 0) {}
199 int sock = socket(AF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, htons(ETH_P_IPV6));
201 syslog(LOG_ERR, "Unable to open packet socket: %s",
207 #ifdef PACKET_RECV_TYPE
208 int pktt = 1 << PACKET_MULTICAST;
209 setsockopt(sock, SOL_PACKET, PACKET_RECV_TYPE, &pktt, sizeof(pktt));
212 if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER,
213 &bpf_prog, sizeof(bpf_prog))) {
214 syslog(LOG_ERR, "Failed to set BPF: %s", strerror(errno));
219 struct sockaddr_ll ll = {
220 .sll_family = AF_PACKET,
221 .sll_ifindex = iface->ifindex,
222 .sll_protocol = htons(ETH_P_IPV6),
228 bind(sock, (struct sockaddr*)&ll, sizeof(ll));
230 struct packet_mreq mreq = {iface->ifindex, PACKET_MR_ALLMULTI, ETH_ALEN, {0}};
231 setsockopt(sock, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
233 iface->ndp_event.uloop.fd = sock;
234 iface->ndp_event.handle_dgram = handle_solicit;
235 odhcpd_register(&iface->ndp_event);
237 // If we already were enabled dump is unnecessary, if not do dump
239 dump_neigh_table(false);
245 dump_neigh_table(true);
255 // Send an ICMP-ECHO. This is less for actually pinging but for the
256 // neighbor cache to be kept up-to-date.
257 static void ping6(struct in6_addr *addr,
258 const struct interface *iface)
260 struct sockaddr_in6 dest = { .sin6_family = AF_INET6, .sin6_addr = *addr, .sin6_scope_id = iface->ifindex, };
261 struct icmp6_hdr echo = { .icmp6_type = ICMP6_ECHO_REQUEST };
262 struct iovec iov = { .iov_base = &echo, .iov_len = sizeof(echo) };
263 char ipbuf[INET6_ADDRSTRLEN];
265 inet_ntop(AF_INET6, addr, ipbuf, sizeof(ipbuf));
266 syslog(LOG_NOTICE, "Pinging for %s%%%s", ipbuf, iface->ifname);
268 odhcpd_setup_route(addr, 128, iface, NULL, 128, true);
269 odhcpd_send(ping_socket, &dest, &iov, 1, iface);
270 odhcpd_setup_route(addr, 128, iface, NULL, 128, false);
273 // Handle solicitations
274 static void handle_solicit(void *addr, void *data, size_t len,
275 struct interface *iface, _unused void *dest)
277 struct ip6_hdr *ip6 = data;
278 struct nd_neighbor_solicit *req = (struct nd_neighbor_solicit*)&ip6[1];
279 struct sockaddr_ll *ll = addr;
280 char ipbuf[INET6_ADDRSTRLEN];
283 // Solicitation is for duplicate address detection
284 bool ns_is_dad = IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src);
286 // Don't process solicit messages on non relay interfaces
287 // Don't forward any non-DAD solicitation for external ifaces
288 // TODO: check if we should even forward DADs for them
289 if (iface->ndp != MODE_RELAY || (iface->external && !ns_is_dad))
292 if (len < sizeof(*ip6) + sizeof(*req))
293 return; // Invalid reqicitation
295 if (IN6_IS_ADDR_LINKLOCAL(&req->nd_ns_target) ||
296 IN6_IS_ADDR_LOOPBACK(&req->nd_ns_target) ||
297 IN6_IS_ADDR_MULTICAST(&req->nd_ns_target))
298 return; // Invalid target
300 inet_ntop(AF_INET6, &req->nd_ns_target, ipbuf, sizeof(ipbuf));
301 syslog(LOG_DEBUG, "Got a NS for %s%%%s", ipbuf, iface->ifname);
303 odhcpd_get_mac(iface, mac);
304 if (!memcmp(ll->sll_addr, mac, sizeof(mac)))
305 return; // Looped back
308 list_for_each_entry(c, &interfaces, head)
309 if (iface != c && c->ndp == MODE_RELAY &&
310 (ns_is_dad || !c->external))
311 ping6(&req->nd_ns_target, c);
314 // Use rtnetlink to modify kernel routes
315 static void setup_route(struct in6_addr *addr, struct interface *iface, bool add)
317 char ipbuf[INET6_ADDRSTRLEN];
319 inet_ntop(AF_INET6, addr, ipbuf, sizeof(ipbuf));
320 syslog(LOG_NOTICE, "%s about %s%%%s",
321 (add) ? "Learned" : "Forgot", ipbuf, iface->ifname);
323 if (iface->learn_routes)
324 odhcpd_setup_route(addr, 128, iface, NULL, 1024, add);
327 // Check address update
328 static void check_addr_updates(struct interface *iface)
330 struct odhcpd_ipaddr *addr = NULL;
331 ssize_t len = odhcpd_get_interface_addresses(iface->ifindex, false, &addr);
336 bool change = len != (ssize_t)iface->addr4_len;
337 for (ssize_t i = 0; !change && i < len; ++i)
338 if (addr[i].addr.in.s_addr != iface->addr4[i].addr.in.s_addr)
343 iface->addr4_len = len;
346 // Check v6 address update
347 static void check_addr6_updates(struct interface *iface)
349 struct odhcpd_ipaddr *addr = NULL;
350 ssize_t len = odhcpd_get_interface_addresses(iface->ifindex, true, &addr);
355 bool change = len != (ssize_t)iface->ia_addr_len;
356 for (ssize_t i = 0; !change && i < len; ++i)
357 if (!IN6_ARE_ADDR_EQUAL(&addr[i].addr.in6, &iface->ia_addr[i].addr.in6) ||
358 (addr[i].preferred > 0) != (iface->ia_addr[i].preferred > 0) ||
359 addr[i].valid < iface->ia_addr[i].valid ||
360 addr[i].preferred < iface->ia_addr[i].preferred)
364 dhcpv6_ia_preupdate(iface);
366 free(iface->ia_addr);
367 iface->ia_addr = addr;
368 iface->ia_addr_len = len;
371 dhcpv6_ia_postupdate(iface);
372 syslog(LOG_INFO, "Raising SIGUSR1 due to address change on %s", iface->ifname);
377 static void setup_addr_for_relaying(struct in6_addr *addr, struct interface *iface, bool add)
380 char ipbuf[INET6_ADDRSTRLEN];
382 inet_ntop(AF_INET6, addr, ipbuf, sizeof(ipbuf));
384 list_for_each_entry(c, &interfaces, head) {
385 if (iface == c || (c->ndp != MODE_RELAY && !add))
388 bool neigh_add = (c->ndp == MODE_RELAY ? add : false);
390 if (odhcpd_setup_proxy_neigh(addr, c, neigh_add))
391 syslog(LOG_DEBUG, "Failed to %s proxy neighbour entry %s%%%s",
392 neigh_add ? "add" : "delete", ipbuf, c->ifname);
394 syslog(LOG_DEBUG, "%s proxy neighbour entry %s%%%s",
395 neigh_add ? "Added" : "Deleted", ipbuf, c->ifname);
399 static void handle_rtnl_event(struct odhcpd_event *e)
401 struct event_socket *ev_sock = container_of(e, struct event_socket, ev);
403 nl_recvmsgs_default(ev_sock->sock);
407 // Handler for neighbor cache entries from the kernel. This is our source
408 // to learn and unlearn hosts on interfaces.
409 static int cb_rtnl_valid(struct nl_msg *msg, _unused void *arg)
411 struct nlmsghdr *hdr = nlmsg_hdr(msg);
412 struct in6_addr *addr6 = NULL;
413 struct interface *iface = NULL;
415 char ipbuf[INET6_ADDRSTRLEN];
417 switch (hdr->nlmsg_type) {
420 struct rtmsg *rtm = nlmsg_data(hdr);
422 if (!nlmsg_valid_hdr(hdr, sizeof(*rtm)) ||
423 rtm->rtm_family != AF_INET6)
426 if (rtm->rtm_dst_len == 0) {
427 syslog(LOG_INFO, "Raising SIGUSR1 due to default route change");
437 struct ifaddrmsg *ifa = nlmsg_data(hdr);
438 struct nlattr *nla[__IFA_MAX];
440 if (!nlmsg_valid_hdr(hdr, sizeof(*ifa)) ||
441 (ifa->ifa_family != AF_INET6 &&
442 ifa->ifa_family != AF_INET))
445 iface = odhcpd_get_interface_by_index(ifa->ifa_index);
449 nlmsg_parse(hdr, sizeof(*ifa), nla, __IFA_MAX - 1, NULL);
451 if (ifa->ifa_family == AF_INET6) {
452 if (!nla[IFA_ADDRESS])
455 addr6 = nla_data(nla[IFA_ADDRESS]);
456 if (!addr6 || IN6_IS_ADDR_LINKLOCAL(addr6) ||
457 IN6_IS_ADDR_MULTICAST(addr6))
460 inet_ntop(AF_INET6, addr6, ipbuf, sizeof(ipbuf));
461 syslog(LOG_DEBUG, "Netlink %s %s%%%s", add ? "newaddr" : "deladdr",
462 ipbuf, iface->ifname);
464 check_addr6_updates(iface);
466 if (iface->ndp != MODE_RELAY)
469 /* handle the relay logic below */
470 setup_addr_for_relaying(addr6, iface, add);
473 dump_neigh_table(false);
478 struct in_addr *addr = nla_data(nla[IFA_ADDRESS]);
480 inet_ntop(AF_INET, addr, ipbuf, sizeof(ipbuf));
481 syslog(LOG_DEBUG, "Netlink %s %s%%%s", add ? "newaddr" : "deladdr",
482 ipbuf, iface->ifname);
484 check_addr_updates(iface);
493 struct ndmsg *ndm = nlmsg_data(hdr);
494 struct nlattr *nla[__NDA_MAX];
496 if (!nlmsg_valid_hdr(hdr, sizeof(*ndm)) ||
497 ndm->ndm_family != AF_INET6)
500 iface = odhcpd_get_interface_by_index(ndm->ndm_ifindex);
501 if (!iface || iface->ndp != MODE_RELAY)
502 return (iface ? NL_OK : NL_SKIP);
504 nlmsg_parse(hdr, sizeof(*ndm), nla, __NDA_MAX - 1, NULL);
508 addr6 = nla_data(nla[NDA_DST]);
509 if (!addr6 || IN6_IS_ADDR_LINKLOCAL(addr6) ||
510 IN6_IS_ADDR_MULTICAST(addr6))
513 inet_ntop(AF_INET6, addr6, ipbuf, sizeof(ipbuf));
514 syslog(LOG_DEBUG, "Netlink %s %s%%%s", true ? "newneigh" : "delneigh",
515 ipbuf, iface->ifname);
517 if (ndm->ndm_flags & NTF_PROXY) {
518 /* Dump and flush proxy entries */
519 if (hdr->nlmsg_type == RTM_NEWNEIGH) {
520 odhcpd_setup_proxy_neigh(addr6, iface, false);
521 setup_route(addr6, iface, false);
522 dump_neigh_table(false);
528 if (add && !(ndm->ndm_state &
529 (NUD_REACHABLE | NUD_STALE | NUD_DELAY | NUD_PROBE |
530 NUD_PERMANENT | NUD_NOARP)))
533 setup_addr_for_relaying(addr6, iface, add);
534 setup_route(addr6, iface, add);
537 dump_neigh_table(false);
548 static void catch_rtnl_err(struct odhcpd_event *e, int error)
550 struct event_socket *ev_sock = container_of(e, struct event_socket, ev);
552 if (error != ENOBUFS)
555 /* Double netlink event buffer size */
556 ev_sock->sock_bufsize *= 2;
558 if (nl_socket_set_buffer_size(ev_sock->sock, ev_sock->sock_bufsize, 0))
561 dump_addr_table(true);
565 odhcpd_deregister(e);