2 * Copyright (C) 2010 Felix Fietkau <nbd@openwrt.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.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
18 #include <sys/socket.h>
26 #include <linux/fib_rules.h>
30 #define NLMSG_ALIGNTO 4U
31 #define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )
33 static struct uloop_fd rtnl_sock;
34 static unsigned int rtnl_seq, rtnl_dump_seq;
35 int route_table = 16800;
37 static void rtnl_flush(void)
41 fd = open("/proc/sys/net/ipv4/route/flush", O_WRONLY);
50 RULE_F_ADD = (1 << 0),
51 RULE_F_DEFGW_WORKAROUND = (1 << 1),
54 static int get_route_table(struct relayd_interface *rif)
59 return local_route_table;
63 rtnl_rule_request(struct relayd_interface *rif, int flags)
78 char ifname[IFNAMSIZ + 1];
82 .rtm_family = AF_INET,
83 .rtm_table = RT_TABLE_UNSPEC,
84 .rtm_scope = RT_SCOPE_UNIVERSE,
85 .rtm_protocol = RTPROT_BOOT,
88 .rta.rta_type = FRA_PRIORITY,
89 .rta.rta_len = sizeof(req.prio),
93 .rta_type = FRA_TABLE,
94 .rta_len = sizeof(req.table),
97 const char *ifname = "lo";
98 int padding = sizeof(req.dev.ifname);
101 ifname = rif->ifname;
103 if (!(flags & RULE_F_DEFGW_WORKAROUND)) {
104 int len = strlen(ifname) + 1;
105 req.dev.rta.rta_type = FRA_IFNAME;
106 padding -= NLMSG_ALIGN(len);
107 strcpy(req.dev.ifname, ifname);
108 req.dev.rta.rta_len = sizeof(req.dev.rta) + len;
110 padding = sizeof(req.dev);
113 req.table.table = get_route_table(rif);
114 req.nl.nlmsg_len = sizeof(req) - padding;
116 req.nl.nlmsg_flags = NLM_F_REQUEST;
117 if (flags & RULE_F_ADD) {
118 req.nl.nlmsg_type = RTM_NEWRULE;
119 req.nl.nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
121 req.rt.rtm_type = RTN_UNICAST;
123 req.nl.nlmsg_type = RTM_DELRULE;
124 req.rt.rtm_type = RTN_UNSPEC;
127 send(rtnl_sock.fd, &req, req.nl.nlmsg_len, 0);
136 static struct rtnl_addr *
137 rtnl_add_addr(struct rtnl_addr *addr, int *len, int type, const uint8_t *ipaddr)
139 addr->rta.rta_type = type;
140 memcpy(addr->ipaddr, ipaddr, 4);
141 *len += sizeof(*addr);
146 rtnl_route_request(struct relayd_interface *rif, struct relayd_host *host,
147 struct relayd_route *route, bool add)
160 struct rtnl_addr addr[3];
163 .rtm_family = AF_INET,
165 .rtm_table = RT_TABLE_MAIN,
168 .rta_type = RTA_TABLE,
169 .rta_len = sizeof(req.table),
173 .rta_len = sizeof(req.dev),
175 .addr[0].rta.rta_len = sizeof(struct rtnl_addr),
176 .addr[1].rta.rta_len = sizeof(struct rtnl_addr),
177 .addr[2].rta.rta_len = sizeof(struct rtnl_addr),
179 int pktlen = sizeof(req) - sizeof(req.addr);
180 struct rtnl_addr *addr = &req.addr[0];
181 const char *ifname = "loopback";
183 req.dev.ifindex = host->rif->sll.sll_ifindex;
184 req.table.table = get_route_table(rif);
186 req.nl.nlmsg_flags = NLM_F_REQUEST;
188 req.nl.nlmsg_type = RTM_NEWROUTE;
189 req.nl.nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE;
191 req.rt.rtm_protocol = RTPROT_BOOT;
193 req.rt.rtm_scope = RT_SCOPE_UNIVERSE;
195 req.rt.rtm_scope = RT_SCOPE_LINK;
197 req.rt.rtm_type = RTN_UNICAST;
199 req.nl.nlmsg_type = RTM_DELROUTE;
200 req.rt.rtm_scope = RT_SCOPE_NOWHERE;
204 ifname = rif->ifname;
207 DPRINTF(2, "%s: add route to "IP_FMT"/%d via "IP_FMT" (%s)\n", ifname,
208 IP_BUF(route->dest), route->mask, IP_BUF(host->ipaddr),
211 req.rt.rtm_dst_len = route->mask;
213 addr = rtnl_add_addr(addr, &pktlen, RTA_DST, route->dest);
214 addr = rtnl_add_addr(addr, &pktlen, RTA_GATEWAY, host->ipaddr);
216 DPRINTF(2, "%s: add host route to "IP_FMT" (%s)\n", ifname,
217 IP_BUF(host->ipaddr), host->rif->ifname);
218 addr = rtnl_add_addr(addr, &pktlen, RTA_DST, host->ipaddr);
219 req.rt.rtm_dst_len = 32;
224 addr = rtnl_add_addr(addr, &pktlen, RTA_PREFSRC, local_addr);
226 req.nl.nlmsg_len = pktlen;
228 rtnl_rule_request(rif, RULE_F_DEFGW_WORKAROUND | RULE_F_ADD);
229 send(rtnl_sock.fd, &req, pktlen, 0);
231 rtnl_rule_request(rif, RULE_F_DEFGW_WORKAROUND);
236 rtnl_route_set(struct relayd_host *host, struct relayd_route *route, bool add)
238 struct relayd_interface *rif;
240 list_for_each_entry(rif, &interfaces, list) {
241 if (rif == host->rif)
244 rtnl_route_request(rif, host, route, add);
246 if (local_route_table)
247 rtnl_route_request(NULL, host, route, add);
250 void relayd_add_interface_routes(struct relayd_interface *rif)
252 rif->rt_table = route_table++;
253 rtnl_rule_request(rif, RULE_F_ADD);
256 void relayd_del_interface_routes(struct relayd_interface *rif)
258 rtnl_rule_request(rif, 0);
263 ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
266 static void rtnl_parse_newneigh(struct nlmsghdr *h)
268 struct relayd_interface *rif = NULL;
269 struct ndmsg *r = NLMSG_DATA(h);
270 const uint8_t *lladdr = NULL;
271 const uint8_t *ipaddr = NULL;
275 if (r->ndm_family != AF_INET)
278 list_for_each_entry(rif, &interfaces, list) {
279 if (rif->sll.sll_ifindex == r->ndm_ifindex)
280 goto found_interface;
285 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*r));
286 for (rta = NDA_RTA(r); RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {
287 switch(rta->rta_type) {
289 lladdr = RTA_DATA(rta);
292 ipaddr = RTA_DATA(rta);
299 if (!lladdr || !ipaddr || (r->ndm_state & (NUD_INCOMPLETE|NUD_FAILED)))
302 if (!memcmp(lladdr, "\x00\x00\x00\x00\x00\x00", ETH_ALEN))
305 DPRINTF(1, "%s: Found ARP cache entry for host "IP_FMT" ("MAC_FMT")\n",
306 rif->ifname, IP_BUF(ipaddr), MAC_BUF(lladdr));
307 relayd_refresh_host(rif, lladdr, ipaddr);
310 static void rtnl_parse_packet(void *data, int len)
314 for (h = data; NLMSG_OK(h, len); h = NLMSG_NEXT(h, len)) {
315 if (h->nlmsg_type == NLMSG_DONE ||
316 h->nlmsg_type == NLMSG_ERROR)
319 if (h->nlmsg_seq != rtnl_dump_seq)
322 if (h->nlmsg_type == RTM_NEWNEIGH)
323 rtnl_parse_newneigh(h);
327 static void rtnl_cb(struct uloop_fd *fd, unsigned int events)
329 struct sockaddr_nl nladdr;
330 static uint8_t buf[16384];
333 .iov_len = sizeof(buf),
335 struct msghdr msg = {
337 .msg_namelen = sizeof(nladdr),
345 len = recvmsg(rtnl_sock.fd, &msg, 0);
356 if (nladdr.nl_pid != 0)
359 rtnl_parse_packet(buf, len);
363 static void rtnl_dump_request(int nlmsg_type)
370 .nlmsg_len = sizeof(req),
371 .nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST,
374 .g.rtgen_family = AF_INET,
376 req.nlh.nlmsg_type = nlmsg_type;
377 req.nlh.nlmsg_seq = rtnl_seq;
378 send(rtnl_sock.fd, &req, sizeof(req), 0);
382 int relayd_rtnl_init(void)
384 struct sockaddr_nl snl_local = {};
386 rtnl_sock.fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
387 if (rtnl_sock.fd < 0) {
388 perror("socket(AF_NETLINK)");
392 snl_local.nl_family = AF_NETLINK;
394 if (bind(rtnl_sock.fd, (struct sockaddr *) &snl_local, sizeof(struct sockaddr_nl)) < 0) {
400 rtnl_sock.cb = rtnl_cb;
401 uloop_fd_add(&rtnl_sock, ULOOP_READ | ULOOP_EDGE_TRIGGER);
403 rtnl_seq = time(NULL);
404 rtnl_dump_seq = rtnl_seq;
405 rtnl_dump_request(RTM_GETNEIGH);
406 rtnl_rule_request(NULL, RULE_F_ADD);
411 void relayd_rtnl_done(void)
413 rtnl_rule_request(NULL, 0);
414 uloop_fd_delete(&rtnl_sock);