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 "relayd.h"
  26
  27 static struct uloop_fd rtnl_sock;
  28 static unsigned int rtnl_seq, rtnl_dump_seq;
  29
  30 static void rtnl_flush(void)
  31 {
  32         int fd;
  33
  34         fd = open("/proc/sys/net/ipv4/route/flush", O_WRONLY);
  35         if (fd < 0)
  36                 return;
  37
  38         write(fd, "-1", 2);
  39         close(fd);
  40 }
  41
  42 static void rtnl_route_set(struct relayd_host *host, bool add)
  43 {
  44         static struct {
  45                 struct nlmsghdr nl;
  46                 struct rtmsg rt;
  47                 struct {
  48                         struct rtattr rta;
  49                         uint8_t ipaddr[4];
  50                 } __packed dst;
  51                 struct {
  52                         struct rtattr rta;
  53                         int ifindex;
  54                 } __packed dev;
  55         } __packed req = {
  56                 .nl = {
  57                         .nlmsg_len = sizeof(req),
  58                 },
  59                 .rt = {
  60                         .rtm_family = AF_INET,
  61                         .rtm_dst_len = 32,
  62                         .rtm_table = RT_TABLE_MAIN,
  63                 },
  64                 .dst.rta = {
  65                         .rta_type = RTA_DST,
  66                         .rta_len = sizeof(req.dst),
  67                 },
  68                 .dev.rta = {
  69                         .rta_type = RTA_OIF,
  70                         .rta_len = sizeof(req.dev),
  71                 },
  72         };
  73
  74         memcpy(req.dst.ipaddr, host->ipaddr, sizeof(req.dst.ipaddr));
  75         req.dev.ifindex = host->rif->sll.sll_ifindex;
  76
  77         req.nl.nlmsg_flags = NLM_F_REQUEST;
  78         if (add) {
  79                 req.nl.nlmsg_type = RTM_NEWROUTE;
  80                 req.nl.nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE;
  81
  82                 req.rt.rtm_protocol = RTPROT_BOOT;
  83                 req.rt.rtm_scope = RT_SCOPE_LINK;
  84                 req.rt.rtm_type = RTN_UNICAST;
  85         } else {
  86                 req.nl.nlmsg_type = RTM_DELROUTE;
  87                 req.rt.rtm_scope = RT_SCOPE_NOWHERE;
  88         }
  89
  90         send(rtnl_sock.fd, &req, sizeof(req), 0);
  91         rtnl_flush();
  92 }
  93
  94 void relayd_add_route(struct relayd_host *host)
  95 {
  96         rtnl_route_set(host, true);
  97 }
  98
  99 void relayd_del_route(struct relayd_host *host)
 100 {
 101         rtnl_route_set(host, false);
 102 }
 103
 104 #ifndef NDA_RTA
 105 #define NDA_RTA(r) \
 106     ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
 107 #endif
 108
 109 static void rtnl_parse_newneigh(struct nlmsghdr *h)
 110 {
 111         struct relayd_interface *rif = NULL;
 112         struct ndmsg *r = NLMSG_DATA(h);
 113         const uint8_t *lladdr = NULL;
 114         const uint8_t *ipaddr = NULL;
 115         struct rtattr *rta;
 116         int len;
 117
 118         if (r->ndm_family != AF_INET)
 119                 return;
 120
 121         list_for_each_entry(rif, &interfaces, list) {
 122                 if (rif->sll.sll_ifindex == r->ndm_ifindex)
 123                         goto found_interface;
 124         }
 125         return;
 126
 127 found_interface:
 128         len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*r));
 129         for (rta = NDA_RTA(r); RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {
 130                 switch(rta->rta_type) {
 131                 case NDA_LLADDR:
 132                         lladdr = RTA_DATA(rta);
 133                         break;
 134                 case NDA_DST:
 135                         ipaddr = RTA_DATA(rta);
 136                         break;
 137                 default:
 138                         break;
 139                 }
 140         }
 141
 142         if (!lladdr || !ipaddr || (r->ndm_state & (NUD_INCOMPLETE|NUD_FAILED)))
 143                 return;
 144
 145         if (!memcmp(lladdr, "\x00\x00\x00\x00\x00\x00", ETH_ALEN))
 146                 return;
 147
 148         DPRINTF(1, "%s: Found ARP cache entry for host "IP_FMT" ("MAC_FMT")\n",
 149                 rif->ifname, IP_BUF(ipaddr), MAC_BUF(lladdr));
 150         relayd_refresh_host(rif, lladdr, ipaddr);
 151 }
 152
 153 static void rtnl_parse_packet(void *data, int len)
 154 {
 155         struct nlmsghdr *h;
 156
 157         for (h = data; NLMSG_OK(h, len); h = NLMSG_NEXT(h, len)) {
 158                 if (h->nlmsg_type == NLMSG_DONE ||
 159                     h->nlmsg_type == NLMSG_ERROR)
 160                         return;
 161
 162                 if (h->nlmsg_seq != rtnl_dump_seq)
 163                         continue;
 164
 165                 if (h->nlmsg_type == RTM_NEWNEIGH)
 166                         rtnl_parse_newneigh(h);
 167         }
 168 }
 169
 170 static void rtnl_cb(struct uloop_fd *fd, unsigned int events)
 171 {
 172         struct sockaddr_nl nladdr;
 173         static uint8_t buf[16384];
 174         struct iovec iov = {
 175                 .iov_base = buf,
 176                 .iov_len = sizeof(buf),
 177         };
 178         struct msghdr msg = {
 179                 .msg_name = &nladdr,
 180                 .msg_namelen = sizeof(nladdr),
 181                 .msg_iov = &iov,
 182                 .msg_iovlen = 1,
 183         };
 184
 185         do {
 186                 int len;
 187
 188                 len = recvmsg(rtnl_sock.fd, &msg, 0);
 189                 if (len < 0) {
 190                         if (errno == EINTR)
 191                                 continue;
 192
 193                         return;
 194                 }
 195
 196                 if (!len)
 197                         break;
 198
 199                 if (nladdr.nl_pid != 0)
 200                         continue;
 201
 202                 rtnl_parse_packet(buf, len);
 203         } while (1);
 204 }
 205
 206 int relayd_rtnl_init(void)
 207 {
 208         struct sockaddr_nl snl_local;
 209         static struct {
 210                 struct nlmsghdr nlh;
 211                 struct rtgenmsg g;
 212         } req = {
 213                 .nlh = {
 214                         .nlmsg_len = sizeof(req),
 215                         .nlmsg_type = RTM_GETNEIGH,
 216                         .nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST,
 217                         .nlmsg_pid = 0,
 218                 },
 219                 .g.rtgen_family = AF_INET,
 220         };
 221
 222         rtnl_sock.fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
 223         if (rtnl_sock.fd < 0) {
 224                 perror("socket(AF_NETLINK)");
 225                 return -1;
 226         }
 227
 228         snl_local.nl_family = AF_NETLINK;
 229
 230         if (bind(rtnl_sock.fd, (struct sockaddr *) &snl_local, sizeof(struct sockaddr_nl)) < 0) {
 231                 perror("bind");
 232                 close(rtnl_sock.fd);
 233                 return -1;
 234         }
 235
 236         rtnl_sock.cb = rtnl_cb;
 237         uloop_fd_add(&rtnl_sock, ULOOP_READ | ULOOP_EDGE_TRIGGER);
 238
 239         rtnl_seq = time(NULL);
 240         rtnl_dump_seq = rtnl_seq;
 241         req.nlh.nlmsg_seq = rtnl_seq;
 242         send(rtnl_sock.fd, &req, sizeof(req), 0);
 243
 244         return 0;
 245 }
 246
 247 void relayd_rtnl_done(void)
 248 {
 249         uloop_fd_delete(&rtnl_sock);
 250         close(rtnl_sock.fd);
 251 }