main.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/ioctl.h>
  19
  20 #include <arpa/inet.h>
  21 #include <net/if.h>
  22 #include <net/ethernet.h>
  23 #include <netinet/if_ether.h>
  24 #include <netinet/ip.h>
  25 #include <netinet/udp.h>
  26
  27 #include <linux/if_packet.h>
  28 #include <linux/rtnetlink.h>
  29 #include <linux/neighbour.h>
  30
  31 #include <stdio.h>
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include <stddef.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <stdint.h>
  38 #include <stdbool.h>
  39 #include <errno.h>
  40 #include <signal.h>
  41
  42 #include "uloop.h"
  43 #include "list.h"
  44
  45 #define DEBUG
  46 #ifdef DEBUG
  47 #define DPRINTF(level, ...) if (debug >= level) fprintf(stderr, __VA_ARGS__);
  48 #else
  49 #define DPRINTF(...) do {} while(0)
  50 #endif
  51
  52 #ifndef __packed
  53 #define __packed __attribute__((packed))
  54 #endif
  55
  56 #define __uc(c) ((unsigned char *)(c))
  57
  58 #define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
  59 #define MAC_BUF(_c) __uc(_c)[0], __uc(_c)[1], __uc(_c)[2], __uc(_c)[3], __uc(_c)[4], __uc(_c)[5]
  60
  61 #define IP_FMT  "%d.%d.%d.%d"
  62 #define IP_BUF(_c) __uc(_c)[0], __uc(_c)[1], __uc(_c)[2], __uc(_c)[3]
  63
  64 #define DUMMY_IP ((uint8_t *) "\x01\x01\x01\x01")
  65
  66 #define DHCP_FLAG_BROADCAST     (1 << 15)
  67
  68 struct relayd_interface {
  69         struct list_head list;
  70         struct uloop_fd fd;
  71         struct uloop_fd bcast_fd;
  72         struct sockaddr_ll sll;
  73         struct sockaddr_ll bcast_sll;
  74         char ifname[IFNAMSIZ];
  75         struct list_head hosts;
  76         uint8_t src_ip[4];
  77         bool managed;
  78 };
  79
  80 struct relayd_host {
  81         struct list_head list;
  82         struct relayd_interface *rif;
  83         uint8_t lladdr[ETH_ALEN];
  84         uint8_t ipaddr[4];
  85         struct uloop_timeout timeout;
  86         int cleanup_pending;
  87 };
  88
  89 struct arp_packet {
  90         struct ether_header eth;
  91         struct ether_arp arp;
  92 } __packed;
  93
  94 struct ip_packet {
  95         struct ether_header eth;
  96         struct iphdr iph;
  97 } __packed;
  98
  99 struct dhcp_header {
 100         uint8_t op, htype, hlen, hops;
 101         uint32_t xit;
 102         uint16_t secs, flags;
 103         struct in_addr ciaddr, yiaddr, siaddr, giaddr;
 104         unsigned char chaddr[16];
 105         unsigned char sname[64];
 106         unsigned char file[128];
 107 } __packed;
 108
 109 struct rtnl_req {
 110         struct nlmsghdr nl;
 111         struct rtmsg rt;
 112 };
 113
 114 static int debug;
 115 static LIST_HEAD(interfaces);
 116 static int host_timeout;
 117 static int inet_sock;
 118 static int forward_bcast;
 119 static int forward_dhcp;
 120 static struct uloop_fd rtnl_sock;
 121 static unsigned int rtnl_seq, rtnl_dump_seq;
 122
 123 static struct relayd_host *find_host_by_ipaddr(struct relayd_interface *rif, const uint8_t *ipaddr)
 124 {
 125         struct relayd_host *host;
 126
 127         if (!rif) {
 128                 list_for_each_entry(rif, &interfaces, list) {
 129                         host = find_host_by_ipaddr(rif, ipaddr);
 130                         if (!host)
 131                                 continue;
 132
 133                         return host;
 134                 }
 135                 return NULL;
 136         }
 137
 138         list_for_each_entry(host, &rif->hosts, list) {
 139                 if (memcmp(ipaddr, host->ipaddr, sizeof(host->ipaddr)) != 0)
 140                         continue;
 141
 142                 return host;
 143         }
 144         return NULL;
 145 }
 146
 147 static void add_arp(struct relayd_host *host)
 148 {
 149         struct sockaddr_in *sin;
 150         struct arpreq arp;
 151
 152         strncpy(arp.arp_dev, host->rif->ifname, sizeof(arp.arp_dev));
 153         arp.arp_flags = ATF_COM;
 154
 155         arp.arp_ha.sa_family = ARPHRD_ETHER;
 156         memcpy(arp.arp_ha.sa_data, host->lladdr, ETH_ALEN);
 157
 158         sin = (struct sockaddr_in *) &arp.arp_pa;
 159         sin->sin_family = AF_INET;
 160         memcpy(&sin->sin_addr, host->ipaddr, sizeof(host->ipaddr));
 161
 162         ioctl(inet_sock, SIOCSARP, &arp);
 163 }
 164
 165 static void rtnl_route_set(struct relayd_host *host, bool add)
 166 {
 167         static struct {
 168                 struct nlmsghdr nl;
 169                 struct rtmsg rt;
 170                 struct {
 171                         struct rtattr rta;
 172                         uint8_t ipaddr[4];
 173                 } __packed dst;
 174                 struct {
 175                         struct rtattr rta;
 176                         int ifindex;
 177                 } __packed dev;
 178         } __packed req;
 179
 180         memset(&req, 0, sizeof(req));
 181
 182         req.nl.nlmsg_len = sizeof(req);
 183         req.rt.rtm_family = AF_INET;
 184         req.rt.rtm_dst_len = 32;
 185
 186         req.dst.rta.rta_type = RTA_DST;
 187         req.dst.rta.rta_len = sizeof(req.dst);
 188         memcpy(req.dst.ipaddr, host->ipaddr, sizeof(req.dst.ipaddr));
 189
 190         req.dev.rta.rta_type = RTA_OIF;
 191         req.dev.rta.rta_len = sizeof(req.dev);
 192         req.dev.ifindex = host->rif->sll.sll_ifindex;
 193
 194         req.nl.nlmsg_flags = NLM_F_REQUEST;
 195         req.rt.rtm_table = RT_TABLE_MAIN;
 196         if (add) {
 197                 req.nl.nlmsg_type = RTM_NEWROUTE;
 198                 req.nl.nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE;
 199
 200                 req.rt.rtm_protocol = RTPROT_BOOT;
 201                 req.rt.rtm_scope = RT_SCOPE_LINK;
 202                 req.rt.rtm_type = RTN_UNICAST;
 203         } else {
 204                 req.nl.nlmsg_type = RTM_DELROUTE;
 205                 req.rt.rtm_scope = RT_SCOPE_NOWHERE;
 206         }
 207
 208         send(rtnl_sock.fd, &req, sizeof(req), 0);
 209 }
 210
 211 static void add_route(struct relayd_host *host)
 212 {
 213         rtnl_route_set(host, true);
 214 }
 215
 216 static void del_route(struct relayd_host *host)
 217 {
 218         rtnl_route_set(host, false);
 219 }
 220
 221 static void del_host(struct relayd_host *host)
 222 {
 223         DPRINTF(1, "%s: deleting host "IP_FMT" ("MAC_FMT")\n", host->rif->ifname,
 224                 IP_BUF(host->ipaddr), MAC_BUF(host->lladdr));
 225
 226         if (host->rif->managed)
 227                 del_route(host);
 228         list_del(&host->list);
 229         free(host);
 230 }
 231
 232 static void fill_arp_request(struct arp_packet *pkt, struct relayd_interface *rif,
 233                              uint8_t spa[4], uint8_t tpa[4])
 234 {
 235         memset(pkt, 0, sizeof(*pkt));
 236
 237         pkt->eth.ether_type = htons(ETHERTYPE_ARP);
 238         memcpy(pkt->eth.ether_shost, rif->sll.sll_addr, ETH_ALEN);
 239
 240         memcpy(pkt->arp.arp_sha, rif->sll.sll_addr, ETH_ALEN);
 241         memcpy(pkt->arp.arp_spa, spa, 4);
 242         memcpy(pkt->arp.arp_tpa, tpa, 4);
 243
 244         pkt->arp.arp_hrd = htons(ARPHRD_ETHER);
 245         pkt->arp.arp_pro = htons(ETH_P_IP);
 246         pkt->arp.arp_hln = ETH_ALEN;
 247         pkt->arp.arp_pln = 4;
 248 }
 249
 250 static void send_arp_request(struct relayd_host *host)
 251 {
 252         struct relayd_interface *rif = host->rif;
 253         struct arp_packet pkt;
 254
 255         fill_arp_request(&pkt, host->rif, host->rif->src_ip, host->ipaddr);
 256
 257         pkt.arp.arp_op = htons(ARPOP_REQUEST);
 258         memcpy(pkt.arp.arp_spa, rif->src_ip, ETH_ALEN);
 259         memset(pkt.arp.arp_tha, 0, ETH_ALEN);
 260         memset(pkt.eth.ether_dhost, 0xff, ETH_ALEN);
 261
 262         DPRINTF(2, "%s: sending ARP who-has "IP_FMT", tell "IP_FMT" ("MAC_FMT")\n",
 263                 rif->ifname, IP_BUF(pkt.arp.arp_tpa),
 264                 IP_BUF(pkt.arp.arp_spa), MAC_BUF(pkt.eth.ether_shost));
 265
 266         sendto(rif->fd.fd, &pkt, sizeof(pkt), 0,
 267                 (struct sockaddr *) &rif->sll, sizeof(rif->sll));
 268 }
 269
 270 static void send_arp_reply(struct relayd_interface *rif, uint8_t spa[4],
 271                            uint8_t tha[ETH_ALEN], uint8_t tpa[4])
 272 {
 273         struct arp_packet pkt;
 274
 275         fill_arp_request(&pkt, rif, spa, tpa);
 276
 277         pkt.arp.arp_op = htons(ARPOP_REPLY);
 278         memcpy(pkt.eth.ether_dhost, tha, ETH_ALEN);
 279         memcpy(pkt.arp.arp_tha, tha, ETH_ALEN);
 280
 281         DPRINTF(2, "%s: sending ARP reply to "IP_FMT", "IP_FMT" is at ("MAC_FMT")\n",
 282                 rif->ifname, IP_BUF(pkt.arp.arp_tpa),
 283                 IP_BUF(pkt.arp.arp_spa), MAC_BUF(pkt.eth.ether_shost));
 284
 285         sendto(rif->fd.fd, &pkt, sizeof(pkt), 0,
 286                 (struct sockaddr *) &rif->sll, sizeof(rif->sll));
 287 }
 288
 289 static void host_entry_timeout(struct uloop_timeout *timeout)
 290 {
 291         struct relayd_host *host = container_of(timeout, struct relayd_host, timeout);
 292
 293         /*
 294          * When a host is behind a managed interface, we must not expire its host
 295          * entry prematurely, as this will cause routes to the node to expire,
 296          * leading to loss of connectivity from the other side.
 297          * When the timeout is reached, try pinging the host a few times before
 298          * giving up on it.
 299          */
 300         if (host->rif->managed && host->cleanup_pending < 2) {
 301                 send_arp_request(host);
 302                 host->cleanup_pending++;
 303                 uloop_timeout_set(&host->timeout, 1000);
 304                 return;
 305         }
 306         del_host(host);
 307 }
 308
 309 static struct relayd_host *add_host(struct relayd_interface *rif, const uint8_t *lladdr, const uint8_t *ipaddr)
 310 {
 311         struct relayd_host *host;
 312
 313         DPRINTF(1, "%s: adding host "IP_FMT" ("MAC_FMT")\n", rif->ifname,
 314                         IP_BUF(ipaddr), MAC_BUF(lladdr));
 315
 316         host = calloc(1, sizeof(*host));
 317         host->rif = rif;
 318         memcpy(host->ipaddr, ipaddr, sizeof(host->ipaddr));
 319         memcpy(host->lladdr, lladdr, sizeof(host->lladdr));
 320         list_add(&host->list, &rif->hosts);
 321         host->timeout.cb = host_entry_timeout;
 322         uloop_timeout_set(&host->timeout, host_timeout * 1000);
 323
 324         add_arp(host);
 325         if (rif->managed)
 326                 add_route(host);
 327
 328         return host;
 329 }
 330
 331 static struct relayd_host *refresh_host(struct relayd_interface *rif, const uint8_t *lladdr, const uint8_t *ipaddr)
 332 {
 333         struct relayd_host *host;
 334
 335         host = find_host_by_ipaddr(rif, ipaddr);
 336         if (!host) {
 337                 host = find_host_by_ipaddr(NULL, ipaddr);
 338
 339                 /*
 340                  * When we suddenly see the host appearing on a different interface,
 341                  * reduce the timeout to make the old entry expire faster, in case the
 342                  * host has moved.
 343                  * If the old entry is behind a managed interface, it will be pinged
 344                  * before we expire it
 345                  */
 346                 if (host && !host->cleanup_pending)
 347                         uloop_timeout_set(&host->timeout, 1);
 348
 349                 host = add_host(rif, lladdr, ipaddr);
 350         } else {
 351                 host->cleanup_pending = false;
 352                 uloop_timeout_set(&host->timeout, host_timeout * 1000);
 353         }
 354
 355         return host;
 356 }
 357
 358 static void relay_arp_request(struct relayd_interface *from_rif, struct arp_packet *pkt)
 359 {
 360         struct relayd_interface *rif;
 361         struct arp_packet reqpkt;
 362
 363         memcpy(&reqpkt, pkt, sizeof(reqpkt));
 364         list_for_each_entry(rif, &interfaces, list) {
 365                 if (rif == from_rif)
 366                         continue;
 367
 368                 memcpy(reqpkt.eth.ether_shost, rif->sll.sll_addr, ETH_ALEN);
 369                 memcpy(reqpkt.arp.arp_sha, rif->sll.sll_addr, ETH_ALEN);
 370
 371                 DPRINTF(2, "%s: sending ARP who-has "IP_FMT", tell "IP_FMT" ("MAC_FMT")\n",
 372                         rif->ifname, IP_BUF(reqpkt.arp.arp_tpa),
 373                         IP_BUF(reqpkt.arp.arp_spa), MAC_BUF(reqpkt.eth.ether_shost));
 374
 375                 sendto(rif->fd.fd, &reqpkt, sizeof(reqpkt), 0,
 376                         (struct sockaddr *) &rif->sll, sizeof(rif->sll));
 377         }
 378 }
 379
 380 static void recv_arp_request(struct relayd_interface *rif, struct arp_packet *pkt)
 381 {
 382         struct relayd_host *host;
 383
 384         DPRINTF(2, "%s: ARP who-has "IP_FMT", tell "IP_FMT" ("MAC_FMT")\n",
 385                 rif->ifname,
 386                 IP_BUF(pkt->arp.arp_tpa),
 387                 IP_BUF(pkt->arp.arp_spa),
 388                 MAC_BUF(pkt->eth.ether_shost));
 389
 390         if (!memcmp(pkt->arp.arp_spa, "\x00\x00\x00\x00", 4))
 391                 return;
 392
 393         refresh_host(rif, pkt->eth.ether_shost, pkt->arp.arp_spa);
 394
 395         host = find_host_by_ipaddr(NULL, pkt->arp.arp_tpa);
 396
 397         /*
 398          * If a host is being pinged because of a timeout, do not use the cached
 399          * entry here. That way we can avoid giving out stale data in case the node
 400          * has moved. We shouldn't relay requests here either, as we might miss our
 401          * chance to create a host route.
 402          */
 403         if (host && host->cleanup_pending)
 404                 return;
 405
 406         relay_arp_request(rif, pkt);
 407 }
 408
 409
 410 static void recv_arp_reply(struct relayd_interface *rif, struct arp_packet *pkt)
 411 {
 412         struct relayd_host *host;
 413
 414         DPRINTF(2, "%s: received ARP reply for "IP_FMT" from "MAC_FMT", deliver to "IP_FMT"\n",
 415                 rif->ifname,
 416                 IP_BUF(pkt->arp.arp_spa),
 417                 MAC_BUF(pkt->eth.ether_shost),
 418                 IP_BUF(pkt->arp.arp_tpa));
 419
 420         refresh_host(rif, pkt->arp.arp_sha, pkt->arp.arp_spa);
 421
 422         if (!memcmp(pkt->arp.arp_tpa, rif->src_ip, 4))
 423                 return;
 424
 425         host = find_host_by_ipaddr(NULL, pkt->arp.arp_tpa);
 426         if (!host)
 427                 return;
 428
 429         send_arp_reply(host->rif, pkt->arp.arp_spa, host->lladdr, host->ipaddr);
 430 }
 431
 432 static void recv_packet(struct uloop_fd *fd, unsigned int events)
 433 {
 434         struct relayd_interface *rif = container_of(fd, struct relayd_interface, fd);
 435         struct arp_packet *pkt;
 436         static char pktbuf[4096];
 437         int pktlen;
 438
 439         do {
 440                 if (rif->fd.error)
 441                         uloop_end();
 442
 443                 pktlen = recv(rif->fd.fd, pktbuf, sizeof(pktbuf), 0);
 444                 if (pktlen < 0) {
 445                         if (errno == EINTR)
 446                                 continue;
 447
 448                         break;
 449                 }
 450
 451                 if (!pktlen)
 452                         break;
 453
 454                 pkt = (void *)pktbuf;
 455                 if (pkt->arp.arp_op == htons(ARPOP_REPLY))
 456                         recv_arp_reply(rif, pkt);
 457                 else if (pkt->arp.arp_op == htons(ARPOP_REQUEST))
 458                         recv_arp_request(rif, pkt);
 459                 else
 460                         DPRINTF(1, "received unknown packet type: %04x\n", ntohs(pkt->arp.arp_op));
 461
 462         } while (1);
 463 }
 464
 465 static void forward_bcast_packet(struct relayd_interface *from_rif, void *packet, int len)
 466 {
 467         struct relayd_interface *rif;
 468         struct ether_header *eth = packet;
 469
 470         list_for_each_entry(rif, &interfaces, list) {
 471                 if (rif == from_rif)
 472                         continue;
 473
 474                 DPRINTF(3, "%s: forwarding broadcast packet to %s\n", from_rif->ifname, rif->ifname);
 475                 memcpy(eth->ether_shost, rif->sll.sll_addr, ETH_ALEN);
 476                 send(rif->bcast_fd.fd, packet, len, 0);
 477         }
 478 }
 479
 480 static uint16_t
 481 chksum(uint16_t sum, const uint8_t *data, uint16_t len)
 482 {
 483         const uint8_t *last;
 484         uint16_t t;
 485
 486         last = data + len - 1;
 487
 488         while(data < last) {
 489                 t = (data[0] << 8) + data[1];
 490                 sum += t;
 491                 if(sum < t)
 492                         sum++;
 493                 data += 2;
 494         }
 495
 496         if(data == last) {
 497                 t = (data[0] << 8) + 0;
 498                 sum += t;
 499                 if(sum < t)
 500                         sum++;
 501         }
 502
 503         return sum;
 504 }
 505
 506 static bool forward_dhcp_packet(struct relayd_interface *rif, void *data, int len)
 507 {
 508         struct ip_packet *pkt = data;
 509         struct udphdr *udp;
 510         struct dhcp_header *dhcp;
 511         int udplen;
 512         uint16_t sum;
 513
 514         if (pkt->eth.ether_type != htons(ETH_P_IP))
 515                 return false;
 516
 517         if (pkt->iph.version != 4)
 518                 return false;
 519
 520         if (pkt->iph.protocol != IPPROTO_UDP)
 521                 return false;
 522
 523         udp = (void *) ((char *) &pkt->iph + (pkt->iph.ihl << 2));
 524         dhcp = (void *) (udp + 1);
 525
 526         udplen = ntohs(udp->len);
 527         if (udplen > len - ((char *) udp - (char *) data))
 528                 return false;
 529
 530         if (udp->dest != htons(67) && udp->source != htons(67))
 531                 return false;
 532
 533         if (dhcp->op != 1 && dhcp->op != 2)
 534                 return false;
 535
 536         if (!forward_dhcp)
 537                 return true;
 538
 539         if (dhcp->op == 2)
 540                 refresh_host(rif, pkt->eth.ether_shost, (void *) &pkt->iph.saddr);
 541
 542         DPRINTF(2, "%s: handling DHCP %s\n", rif->ifname, (dhcp->op == 1 ? "request" : "response"));
 543
 544         dhcp->flags |= htons(DHCP_FLAG_BROADCAST);
 545
 546         udp->check = 0;
 547         sum = udplen + IPPROTO_UDP;
 548         sum = chksum(sum, (void *) &pkt->iph.saddr, 8);
 549         sum = chksum(sum, (void *) udp, udplen);
 550         if (sum == 0)
 551                 sum = 0xffff;
 552
 553         udp->check = htons(~sum);
 554
 555         forward_bcast_packet(rif, data, len);
 556
 557         return true;
 558 }
 559
 560 static void recv_bcast_packet(struct uloop_fd *fd, unsigned int events)
 561 {
 562         struct relayd_interface *rif = container_of(fd, struct relayd_interface, bcast_fd);
 563         static char pktbuf[4096];
 564         int pktlen;
 565
 566         do {
 567                 if (rif->fd.error)
 568                         uloop_end();
 569
 570                 pktlen = recv(rif->bcast_fd.fd, pktbuf, sizeof(pktbuf), 0);
 571                 if (pktlen < 0) {
 572                         if (errno == EINTR)
 573                                 continue;
 574
 575                         break;
 576                 }
 577
 578                 if (!pktlen)
 579                         break;
 580
 581                 if (!forward_bcast && !forward_dhcp)
 582                         continue;
 583
 584                 if (forward_dhcp_packet(rif, pktbuf, pktlen))
 585                         continue;
 586
 587                 if (forward_bcast)
 588                         forward_bcast_packet(rif, pktbuf, pktlen);
 589         } while (1);
 590 }
 591
 592
 593 static int init_interface(struct relayd_interface *rif)
 594 {
 595         struct sockaddr_ll *sll = &rif->sll;
 596         struct sockaddr_in *sin;
 597         struct ifreq ifr;
 598         int fd = rif->fd.fd;
 599 #ifdef PACKET_RECV_TYPE
 600         unsigned int pkt_type;
 601 #endif
 602
 603         fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ARP));
 604         if (fd < 0)
 605                 return -1;
 606
 607         rif->fd.fd = fd;
 608
 609         memset(&ifr, 0, sizeof(ifr));
 610         strcpy(ifr.ifr_name, rif->ifname);
 611
 612         if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
 613                 perror("ioctl(SIOCGIFHWADDR)");
 614                 return -1;
 615         }
 616
 617         memcpy(sll->sll_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
 618         sll->sll_family = AF_PACKET;
 619         sll->sll_protocol = htons(ETH_P_ARP);
 620         sll->sll_pkttype = PACKET_BROADCAST;
 621         sll->sll_hatype = ARPHRD_ETHER;
 622         sll->sll_halen = ETH_ALEN;
 623
 624         if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) {
 625                 perror("ioctl(SIOCGIFINDEX)");
 626                 return -1;
 627         }
 628
 629         sll->sll_ifindex = ifr.ifr_ifindex;
 630
 631         if (ioctl(fd, SIOCGIFADDR, &ifr) < 0) {
 632                 memcpy(rif->src_ip, DUMMY_IP, sizeof(rif->src_ip));
 633         } else {
 634                 sin = (struct sockaddr_in *) &ifr.ifr_addr;
 635                 memcpy(rif->src_ip, &sin->sin_addr.s_addr, sizeof(rif->src_ip));
 636         }
 637
 638         if (bind(fd, (struct sockaddr *)sll, sizeof(struct sockaddr_ll)) < 0) {
 639                 perror("bind(ETH_P_ARP)");
 640                 return -1;
 641         }
 642
 643         rif->fd.cb = recv_packet;
 644         uloop_fd_add(&rif->fd, ULOOP_READ | ULOOP_EDGE_TRIGGER);
 645
 646         if (!forward_bcast && !forward_dhcp)
 647                 return 0;
 648
 649         fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IP));
 650         if (fd < 0)
 651                 return 0;
 652
 653         rif->bcast_fd.fd = fd;
 654         rif->bcast_fd.cb = recv_bcast_packet;
 655
 656         memcpy(&rif->bcast_sll, &rif->sll, sizeof(rif->bcast_sll));
 657         sll = &rif->bcast_sll;
 658         sll->sll_protocol = htons(ETH_P_IP);
 659
 660         if (bind(fd, (struct sockaddr *)sll, sizeof(struct sockaddr_ll)) < 0) {
 661                 perror("bind(ETH_P_IP)");
 662                 return 0;
 663         }
 664
 665 #ifdef PACKET_RECV_TYPE
 666         pkt_type = (1 << PACKET_BROADCAST);
 667         setsockopt(fd, SOL_PACKET, PACKET_RECV_TYPE, &pkt_type, sizeof(pkt_type));
 668 #endif
 669
 670         uloop_fd_add(&rif->bcast_fd, ULOOP_READ | ULOOP_EDGE_TRIGGER);
 671         return 0;
 672 }
 673
 674 static int init_interfaces(void)
 675 {
 676         struct relayd_interface *rif;
 677         int ret;
 678
 679         list_for_each_entry(rif, &interfaces, list) {
 680                 ret = init_interface(rif);
 681                 if (ret < 0)
 682                         return ret;
 683         }
 684
 685         return 0;
 686 }
 687
 688 static void del_interface(struct relayd_interface *rif)
 689 {
 690         struct relayd_host *host, *htmp;
 691
 692         list_for_each_entry_safe(host, htmp, &rif->hosts, list) {
 693                 del_host(host);
 694         }
 695         free(rif);
 696 }
 697
 698 static void cleanup_interfaces(void)
 699 {
 700         struct relayd_interface *rif, *rtmp;
 701
 702         list_for_each_entry_safe(rif, rtmp, &interfaces, list) {
 703                 del_interface(rif);
 704         }
 705 }
 706
 707 static int alloc_interface(const char *ifname, bool managed)
 708 {
 709         struct relayd_interface *rif;
 710
 711         if (strlen(ifname) >= IFNAMSIZ)
 712                 return -1;
 713
 714         rif = calloc(1, sizeof(*rif));
 715         if (!rif)
 716                 return -1;
 717
 718         INIT_LIST_HEAD(&rif->list);
 719         INIT_LIST_HEAD(&rif->hosts);
 720         strcpy(rif->ifname, ifname);
 721         list_add(&rif->list, &interfaces);
 722         rif->managed = managed;
 723
 724         return 0;
 725 }
 726
 727 #ifndef NDA_RTA
 728 #define NDA_RTA(r) \
 729     ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
 730 #endif
 731
 732 static void rtnl_parse_newneigh(struct nlmsghdr *h)
 733 {
 734         struct relayd_interface *rif = NULL;
 735         struct ndmsg *r = NLMSG_DATA(h);
 736         const uint8_t *lladdr = NULL;
 737         const uint8_t *ipaddr = NULL;
 738         struct rtattr *rta;
 739         int len;
 740
 741         if (r->ndm_family != AF_INET)
 742                 return;
 743
 744         list_for_each_entry(rif, &interfaces, list) {
 745                 if (rif->sll.sll_ifindex == r->ndm_ifindex)
 746                         goto found_interface;
 747         }
 748         return;
 749
 750 found_interface:
 751         len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*r));
 752         for (rta = NDA_RTA(r); RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {
 753                 switch(rta->rta_type) {
 754                 case NDA_LLADDR:
 755                         lladdr = RTA_DATA(rta);
 756                         break;
 757                 case NDA_DST:
 758                         ipaddr = RTA_DATA(rta);
 759                         break;
 760                 default:
 761                         break;
 762                 }
 763         }
 764
 765         if (!lladdr || !ipaddr || (r->ndm_state & (NUD_INCOMPLETE|NUD_FAILED)))
 766                 return;
 767
 768         if (!memcmp(lladdr, "\x00\x00\x00\x00\x00\x00", ETH_ALEN))
 769                 return;
 770
 771         DPRINTF(1, "%s: Found ARP cache entry for host "IP_FMT" ("MAC_FMT")\n",
 772                 rif->ifname, IP_BUF(ipaddr), MAC_BUF(lladdr));
 773         refresh_host(rif, lladdr, ipaddr);
 774 }
 775
 776 static void rtnl_parse_packet(void *data, int len)
 777 {
 778         struct nlmsghdr *h;
 779
 780         for (h = data; NLMSG_OK(h, len); h = NLMSG_NEXT(h, len)) {
 781                 if (h->nlmsg_type == NLMSG_DONE ||
 782                     h->nlmsg_type == NLMSG_ERROR)
 783                         return;
 784
 785                 if (h->nlmsg_seq != rtnl_dump_seq)
 786                         continue;
 787
 788                 if (h->nlmsg_type == RTM_NEWNEIGH)
 789                         rtnl_parse_newneigh(h);
 790         }
 791 }
 792
 793 static void rtnl_cb(struct uloop_fd *fd, unsigned int events)
 794 {
 795         struct sockaddr_nl nladdr;
 796         static uint8_t buf[16384];
 797         struct iovec iov = {
 798                 .iov_base = buf,
 799                 .iov_len = sizeof(buf),
 800         };
 801         struct msghdr msg = {
 802                 .msg_name = &nladdr,
 803                 .msg_namelen = sizeof(nladdr),
 804                 .msg_iov = &iov,
 805                 .msg_iovlen = 1,
 806         };
 807
 808         do {
 809                 int len;
 810
 811                 len = recvmsg(rtnl_sock.fd, &msg, 0);
 812                 if (len < 0) {
 813                         if (errno == EINTR)
 814                                 continue;
 815
 816                         return;
 817                 }
 818
 819                 if (!len)
 820                         break;
 821
 822                 if (nladdr.nl_pid != 0)
 823                         continue;
 824
 825                 rtnl_parse_packet(buf, len);
 826         } while (1);
 827 }
 828
 829 static int rtnl_init(void)
 830 {
 831         struct sockaddr_nl snl_local;
 832         static struct {
 833                 struct nlmsghdr nlh;
 834                 struct rtgenmsg g;
 835         } req = {
 836                 .nlh = {
 837                         .nlmsg_len = sizeof(req),
 838                         .nlmsg_type = RTM_GETNEIGH,
 839                         .nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST,
 840                         .nlmsg_pid = 0,
 841                 },
 842                 .g.rtgen_family = AF_INET,
 843         };
 844
 845         rtnl_sock.fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
 846         if (rtnl_sock.fd < 0) {
 847                 perror("socket(AF_NETLINK)");
 848                 return -1;
 849         }
 850
 851         snl_local.nl_family = AF_NETLINK;
 852
 853         if (bind(rtnl_sock.fd, (struct sockaddr *) &snl_local, sizeof(struct sockaddr_nl)) < 0) {
 854                 perror("bind");
 855                 close(rtnl_sock.fd);
 856                 return -1;
 857         }
 858
 859         rtnl_sock.cb = rtnl_cb;
 860         uloop_fd_add(&rtnl_sock, ULOOP_READ | ULOOP_EDGE_TRIGGER);
 861
 862         rtnl_seq = time(NULL);
 863         rtnl_dump_seq = rtnl_seq;
 864         req.nlh.nlmsg_seq = rtnl_seq;
 865         send(rtnl_sock.fd, &req, sizeof(req), 0);
 866
 867         return 0;
 868 }
 869
 870 static void die(int signo)
 871 {
 872         /*
 873          * When we hit SIGTERM, clean up interfaces directly, so that we
 874          * won't leave our routing in an invalid state.
 875          */
 876         cleanup_interfaces();
 877         exit(1);
 878 }
 879
 880 static int usage(const char *progname)
 881 {
 882         fprintf(stderr, "Usage: %s <options>\n"
 883                         "\n"
 884                         "Options:\n"
 885                         "       -d              Enable debug messages\n"
 886                         "       -i <ifname>     Add an interface for relaying\n"
 887                         "       -I <ifname>     Same as -i, except with ARP cache and host route management\n"
 888                         "                       You need to specify at least two interfaces\n"
 889                         "       -t <timeout>    Host entry expiry timeout\n"
 890                         "       -B              Enable broadcast forwarding\n"
 891                         "       -D              Enable DHCP forwarding\n"
 892                         "\n",
 893                 progname);
 894         return -1;
 895 }
 896
 897 int main(int argc, char **argv)
 898 {
 899         bool managed;
 900         int ifnum = 0;
 901         int ch;
 902
 903         debug = 0;
 904         inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
 905         if (inet_sock < 0) {
 906                 perror("socket(AF_INET)");
 907                 return 1;
 908         }
 909
 910         host_timeout = 60;
 911         forward_bcast = 0;
 912         uloop_init();
 913
 914         while ((ch = getopt(argc, argv, "I:i:t:BDd")) != -1) {
 915                 switch(ch) {
 916                 case 'I':
 917                         managed = true;
 918                         /* fall through */
 919                 case 'i':
 920                         ifnum++;
 921                         if (alloc_interface(optarg, managed) < 0)
 922                                 return 1;
 923
 924                         managed = false;
 925                         break;
 926                 case 't':
 927                         host_timeout = atoi(optarg);
 928                         if (host_timeout <= 0)
 929                                 return usage(argv[0]);
 930                         break;
 931                 case 'd':
 932                         debug++;
 933                         break;
 934                 case 'B':
 935                         forward_bcast = 1;
 936                         break;
 937                 case 'D':
 938                         forward_dhcp = 1;
 939                         break;
 940                 case '?':
 941                 default:
 942                         return usage(argv[0]);
 943                 }
 944         }
 945
 946         if (list_empty(&interfaces))
 947                 return usage(argv[0]);
 948
 949         if (ifnum < 2) {
 950                 fprintf(stderr, "ERROR: Need at least 2 interfaces for relaying\n");
 951                 return -1;
 952         }
 953
 954         argc -= optind;
 955         argv += optind;
 956
 957         signal(SIGTERM, die);
 958         signal(SIGHUP, die);
 959         signal(SIGUSR1, die);
 960         signal(SIGUSR2, die);
 961
 962         if (init_interfaces() < 0)
 963                 return 1;
 964
 965         if (rtnl_init() < 0)
 966                 return 1;
 967
 968         uloop_run();
 969         uloop_done();
 970
 971         cleanup_interfaces();
 972         uloop_fd_delete(&rtnl_sock);
 973         close(rtnl_sock.fd);
 974         close(inet_sock);
 975
 976         return 0;
 977 }