route.c

   1 /*
   2  *   Copyright (C) 2010 Felix Fietkau <nbd@openwrt.org>
   3  *
   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.
   7  *
   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.
  12  *
  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.
  16  */
  17
  18 #include <sys/socket.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24
  25 #include <linux/fib_rules.h>
  26
  27 #include "relayd.h"
  28
  29 static struct uloop_fd rtnl_sock;
  30 static unsigned int rtnl_seq, rtnl_dump_seq;
  31 int route_table = 16800;
  32
  33 static void rtnl_flush(void)
  34 {
  35         int fd;
  36
  37         fd = open("/proc/sys/net/ipv4/route/flush", O_WRONLY);
  38         if (fd < 0)
  39                 return;
  40
  41         write(fd, "-1", 2);
  42         close(fd);
  43 }
  44
  45 static void
  46 rtnl_route_request(struct relayd_interface *rif, struct relayd_host *host,
  47                    struct relayd_route *route, bool add)
  48 {
  49         static struct {
  50                 struct nlmsghdr nl;
  51                 struct rtmsg rt;
  52                 struct {
  53                         struct rtattr rta;
  54                         uint8_t ipaddr[4];
  55                 } __packed dst;
  56                 struct {
  57                         struct rtattr rta;
  58                         int table;
  59                 } __packed table;
  60                 struct {
  61                         struct rtattr rta;
  62                         int ifindex;
  63                 } __packed dev;
  64                 struct {
  65                         struct rtattr rta;
  66                         uint8_t ipaddr[4];
  67                 } __packed gw;
  68         } __packed req = {
  69                 .rt = {
  70                         .rtm_family = AF_INET,
  71                         .rtm_dst_len = 32,
  72                         .rtm_table = RT_TABLE_MAIN,
  73                 },
  74                 .table.rta = {
  75                         .rta_type = RTA_TABLE,
  76                         .rta_len = sizeof(req.table),
  77                 },
  78                 .dst.rta = {
  79                         .rta_len = sizeof(req.dst),
  80                 },
  81                 .dev.rta = {
  82                         .rta_type = RTA_OIF,
  83                         .rta_len = sizeof(req.dev),
  84                 },
  85                 .gw.rta = {
  86                         .rta_type = RTA_GATEWAY,
  87                         .rta_len = sizeof(req.gw),
  88                 },
  89         };
  90         int pktlen = sizeof(req);
  91
  92         req.dev.ifindex = host->rif->sll.sll_ifindex;
  93         req.table.table = rif->rt_table;
  94
  95         req.nl.nlmsg_flags = NLM_F_REQUEST;
  96         if (add) {
  97                 req.nl.nlmsg_type = RTM_NEWROUTE;
  98                 req.nl.nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE;
  99
 100                 req.rt.rtm_protocol = RTPROT_BOOT;
 101                 if (route) {
 102                         req.rt.rtm_scope = RT_SCOPE_UNIVERSE;
 103                 } else {
 104                         req.rt.rtm_scope = RT_SCOPE_LINK;
 105                 }
 106                 req.rt.rtm_type = RTN_UNICAST;
 107         } else {
 108                 req.nl.nlmsg_type = RTM_DELROUTE;
 109                 req.rt.rtm_scope = RT_SCOPE_NOWHERE;
 110         }
 111
 112         req.dst.rta.rta_type = RTA_DST;
 113         if (route) {
 114                 DPRINTF(2, "%s: add route to "IP_FMT"/%d via "IP_FMT"\n",
 115                         host->rif->ifname, IP_BUF(route->dest), route->mask, IP_BUF(host->ipaddr));
 116                 if (!route->mask) {
 117                         /* No DST -> reuse the DST attribute as the gateway attribute */
 118                         memcpy(req.dst.ipaddr, host->ipaddr, sizeof(req.dst.ipaddr));
 119                         req.dst.rta.rta_type = RTA_GATEWAY;
 120                         pktlen -= sizeof(req.gw);
 121                         req.rt.rtm_dst_len = 0;
 122                 } else {
 123                         memcpy(req.gw.ipaddr, host->ipaddr, sizeof(req.gw.ipaddr));
 124                         memcpy(req.dst.ipaddr, route->dest, sizeof(req.dst.ipaddr));
 125                         req.rt.rtm_dst_len = route->mask;
 126                 }
 127         } else {
 128                 pktlen -= sizeof(req.gw);
 129                 req.rt.rtm_dst_len = 32;
 130                 memcpy(req.dst.ipaddr, host->ipaddr, sizeof(req.dst.ipaddr));
 131         }
 132
 133         req.nl.nlmsg_len = pktlen;
 134         send(rtnl_sock.fd, &req, pktlen, 0);
 135         rtnl_flush();
 136 }
 137
 138 static void rtnl_rule_request(struct relayd_interface *rif, bool add)
 139 {
 140         static struct {
 141                 struct nlmsghdr nl;
 142                 struct rtmsg rt;
 143                 struct {
 144                         struct rtattr rta;
 145                         int table;
 146                 } __packed table;
 147                 struct {
 148                         struct rtattr rta;
 149                         char ifname[IFNAMSIZ + 1];
 150                 } __packed dev;
 151         } __packed req = {
 152                 .rt = {
 153                         .rtm_family = AF_INET,
 154                         .rtm_table = RT_TABLE_UNSPEC,
 155                         .rtm_scope = RT_SCOPE_UNIVERSE,
 156                         .rtm_protocol = RTPROT_BOOT,
 157                 },
 158                 .table.rta = {
 159                         .rta_type = FRA_TABLE,
 160                         .rta_len = sizeof(req.table),
 161                 },
 162                 .dev.rta = {
 163                         .rta_type = FRA_IFNAME,
 164                 },
 165         };
 166
 167         int padding = sizeof(req.dev.ifname);
 168         padding -= strlen(rif->ifname) + 1;
 169
 170         strcpy(req.dev.ifname, rif->ifname);
 171         req.dev.rta.rta_len = sizeof(req.dev.rta) + strlen(rif->ifname) + 1;
 172         req.table.table = rif->rt_table;
 173         req.nl.nlmsg_len = sizeof(req) - padding;
 174
 175         req.nl.nlmsg_flags = NLM_F_REQUEST;
 176         if (add) {
 177                 req.nl.nlmsg_type = RTM_NEWRULE;
 178                 req.nl.nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
 179
 180                 req.rt.rtm_type = RTN_UNICAST;
 181         } else {
 182                 req.nl.nlmsg_type = RTM_DELRULE;
 183                 req.rt.rtm_type = RTN_UNSPEC;
 184         }
 185
 186         send(rtnl_sock.fd, &req, req.nl.nlmsg_len, 0);
 187         rtnl_flush();
 188 }
 189
 190 void
 191 rtnl_route_set(struct relayd_host *host, struct relayd_route *route, bool add)
 192 {
 193         struct relayd_interface *rif;
 194
 195         list_for_each_entry(rif, &interfaces, list) {
 196                 if (rif == host->rif)
 197                         continue;
 198
 199                 rtnl_route_request(rif, host, route, add);
 200         }
 201 }
 202
 203 void relayd_add_interface_routes(struct relayd_interface *rif)
 204 {
 205         rif->rt_table = route_table++;
 206         rtnl_rule_request(rif, true);
 207 }
 208
 209 void relayd_del_interface_routes(struct relayd_interface *rif)
 210 {
 211         rtnl_rule_request(rif, false);
 212 }
 213
 214 #ifndef NDA_RTA
 215 #define NDA_RTA(r) \
 216     ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
 217 #endif
 218
 219 static void rtnl_parse_newneigh(struct nlmsghdr *h)
 220 {
 221         struct relayd_interface *rif = NULL;
 222         struct ndmsg *r = NLMSG_DATA(h);
 223         const uint8_t *lladdr = NULL;
 224         const uint8_t *ipaddr = NULL;
 225         struct rtattr *rta;
 226         int len;
 227
 228         if (r->ndm_family != AF_INET)
 229                 return;
 230
 231         list_for_each_entry(rif, &interfaces, list) {
 232                 if (rif->sll.sll_ifindex == r->ndm_ifindex)
 233                         goto found_interface;
 234         }
 235         return;
 236
 237 found_interface:
 238         len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*r));
 239         for (rta = NDA_RTA(r); RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {
 240                 switch(rta->rta_type) {
 241                 case NDA_LLADDR:
 242                         lladdr = RTA_DATA(rta);
 243                         break;
 244                 case NDA_DST:
 245                         ipaddr = RTA_DATA(rta);
 246                         break;
 247                 default:
 248                         break;
 249                 }
 250         }
 251
 252         if (!lladdr || !ipaddr || (r->ndm_state & (NUD_INCOMPLETE|NUD_FAILED)))
 253                 return;
 254
 255         if (!memcmp(lladdr, "\x00\x00\x00\x00\x00\x00", ETH_ALEN))
 256                 return;
 257
 258         DPRINTF(1, "%s: Found ARP cache entry for host "IP_FMT" ("MAC_FMT")\n",
 259                 rif->ifname, IP_BUF(ipaddr), MAC_BUF(lladdr));
 260         relayd_refresh_host(rif, lladdr, ipaddr);
 261 }
 262
 263 static void rtnl_parse_packet(void *data, int len)
 264 {
 265         struct nlmsghdr *h;
 266
 267         for (h = data; NLMSG_OK(h, len); h = NLMSG_NEXT(h, len)) {
 268                 if (h->nlmsg_type == NLMSG_DONE ||
 269                     h->nlmsg_type == NLMSG_ERROR)
 270                         return;
 271
 272                 if (h->nlmsg_seq != rtnl_dump_seq)
 273                         continue;
 274
 275                 if (h->nlmsg_type == RTM_NEWNEIGH)
 276                         rtnl_parse_newneigh(h);
 277         }
 278 }
 279
 280 static void rtnl_cb(struct uloop_fd *fd, unsigned int events)
 281 {
 282         struct sockaddr_nl nladdr;
 283         static uint8_t buf[16384];
 284         struct iovec iov = {
 285                 .iov_base = buf,
 286                 .iov_len = sizeof(buf),
 287         };
 288         struct msghdr msg = {
 289                 .msg_name = &nladdr,
 290                 .msg_namelen = sizeof(nladdr),
 291                 .msg_iov = &iov,
 292                 .msg_iovlen = 1,
 293         };
 294
 295         do {
 296                 int len;
 297
 298                 len = recvmsg(rtnl_sock.fd, &msg, 0);
 299                 if (len < 0) {
 300                         if (errno == EINTR)
 301                                 continue;
 302
 303                         return;
 304                 }
 305
 306                 if (!len)
 307                         break;
 308
 309                 if (nladdr.nl_pid != 0)
 310                         continue;
 311
 312                 rtnl_parse_packet(buf, len);
 313         } while (1);
 314 }
 315
 316 int relayd_rtnl_init(void)
 317 {
 318         struct sockaddr_nl snl_local;
 319         static struct {
 320                 struct nlmsghdr nlh;
 321                 struct rtgenmsg g;
 322         } req = {
 323                 .nlh = {
 324                         .nlmsg_len = sizeof(req),
 325                         .nlmsg_type = RTM_GETNEIGH,
 326                         .nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST,
 327                         .nlmsg_pid = 0,
 328                 },
 329                 .g.rtgen_family = AF_INET,
 330         };
 331
 332         rtnl_sock.fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
 333         if (rtnl_sock.fd < 0) {
 334                 perror("socket(AF_NETLINK)");
 335                 return -1;
 336         }
 337
 338         snl_local.nl_family = AF_NETLINK;
 339
 340         if (bind(rtnl_sock.fd, (struct sockaddr *) &snl_local, sizeof(struct sockaddr_nl)) < 0) {
 341                 perror("bind");
 342                 close(rtnl_sock.fd);
 343                 return -1;
 344         }
 345
 346         rtnl_sock.cb = rtnl_cb;
 347         uloop_fd_add(&rtnl_sock, ULOOP_READ | ULOOP_EDGE_TRIGGER);
 348
 349         rtnl_seq = time(NULL);
 350         rtnl_dump_seq = rtnl_seq;
 351         req.nlh.nlmsg_seq = rtnl_seq;
 352         send(rtnl_sock.fd, &req, sizeof(req), 0);
 353
 354         return 0;
 355 }
 356
 357 void relayd_rtnl_done(void)
 358 {
 359         uloop_fd_delete(&rtnl_sock);
 360         close(rtnl_sock.fd);
 361 }