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/ioctl.h>
19 #include <sys/socket.h>
34 LIST_HEAD(interfaces);
37 static int host_timeout;
39 static int forward_bcast;
40 static int forward_dhcp;
42 static struct relayd_host *find_host_by_ipaddr(struct relayd_interface *rif, const uint8_t *ipaddr)
44 struct relayd_host *host;
47 list_for_each_entry(rif, &interfaces, list) {
48 host = find_host_by_ipaddr(rif, ipaddr);
57 list_for_each_entry(host, &rif->hosts, list) {
58 if (memcmp(ipaddr, host->ipaddr, sizeof(host->ipaddr)) != 0)
66 static void add_arp(struct relayd_host *host)
68 struct sockaddr_in *sin;
71 strncpy(arp.arp_dev, host->rif->ifname, sizeof(arp.arp_dev));
72 arp.arp_flags = ATF_COM;
74 arp.arp_ha.sa_family = ARPHRD_ETHER;
75 memcpy(arp.arp_ha.sa_data, host->lladdr, ETH_ALEN);
77 sin = (struct sockaddr_in *) &arp.arp_pa;
78 sin->sin_family = AF_INET;
79 memcpy(&sin->sin_addr, host->ipaddr, sizeof(host->ipaddr));
81 ioctl(inet_sock, SIOCSARP, &arp);
84 static void del_host(struct relayd_host *host)
86 DPRINTF(1, "%s: deleting host "IP_FMT" ("MAC_FMT")\n", host->rif->ifname,
87 IP_BUF(host->ipaddr), MAC_BUF(host->lladdr));
89 if (host->rif->managed)
90 relayd_del_route(host);
91 uloop_timeout_cancel(&host->timeout);
92 list_del(&host->list);
96 static void fill_arp_request(struct arp_packet *pkt, struct relayd_interface *rif,
97 uint8_t spa[4], uint8_t tpa[4])
99 memset(pkt, 0, sizeof(*pkt));
101 pkt->eth.ether_type = htons(ETHERTYPE_ARP);
102 memcpy(pkt->eth.ether_shost, rif->sll.sll_addr, ETH_ALEN);
104 memcpy(pkt->arp.arp_sha, rif->sll.sll_addr, ETH_ALEN);
105 memcpy(pkt->arp.arp_spa, spa, 4);
106 memcpy(pkt->arp.arp_tpa, tpa, 4);
108 pkt->arp.arp_hrd = htons(ARPHRD_ETHER);
109 pkt->arp.arp_pro = htons(ETH_P_IP);
110 pkt->arp.arp_hln = ETH_ALEN;
111 pkt->arp.arp_pln = 4;
114 static void send_arp_request(struct relayd_host *host)
116 struct relayd_interface *rif = host->rif;
117 struct arp_packet pkt;
119 fill_arp_request(&pkt, host->rif, host->rif->src_ip, host->ipaddr);
121 pkt.arp.arp_op = htons(ARPOP_REQUEST);
122 memcpy(pkt.arp.arp_spa, rif->src_ip, ETH_ALEN);
123 memset(pkt.arp.arp_tha, 0, ETH_ALEN);
124 memset(pkt.eth.ether_dhost, 0xff, ETH_ALEN);
126 DPRINTF(2, "%s: sending ARP who-has "IP_FMT", tell "IP_FMT" ("MAC_FMT")\n",
127 rif->ifname, IP_BUF(pkt.arp.arp_tpa),
128 IP_BUF(pkt.arp.arp_spa), MAC_BUF(pkt.eth.ether_shost));
130 sendto(rif->fd.fd, &pkt, sizeof(pkt), 0,
131 (struct sockaddr *) &rif->sll, sizeof(rif->sll));
134 static void send_arp_reply(struct relayd_interface *rif, uint8_t spa[4],
135 uint8_t tha[ETH_ALEN], uint8_t tpa[4])
137 struct arp_packet pkt;
139 fill_arp_request(&pkt, rif, spa, tpa);
141 pkt.arp.arp_op = htons(ARPOP_REPLY);
142 memcpy(pkt.eth.ether_dhost, tha, ETH_ALEN);
143 memcpy(pkt.arp.arp_tha, tha, ETH_ALEN);
145 DPRINTF(2, "%s: sending ARP reply to "IP_FMT", "IP_FMT" is at ("MAC_FMT")\n",
146 rif->ifname, IP_BUF(pkt.arp.arp_tpa),
147 IP_BUF(pkt.arp.arp_spa), MAC_BUF(pkt.eth.ether_shost));
149 sendto(rif->fd.fd, &pkt, sizeof(pkt), 0,
150 (struct sockaddr *) &rif->sll, sizeof(rif->sll));
153 static void host_entry_timeout(struct uloop_timeout *timeout)
155 struct relayd_host *host = container_of(timeout, struct relayd_host, timeout);
158 * When a host is behind a managed interface, we must not expire its host
159 * entry prematurely, as this will cause routes to the node to expire,
160 * leading to loss of connectivity from the other side.
161 * When the timeout is reached, try pinging the host a few times before
164 if (host->rif->managed && host->cleanup_pending < 2) {
165 send_arp_request(host);
166 host->cleanup_pending++;
167 uloop_timeout_set(&host->timeout, 1000);
173 static struct relayd_host *add_host(struct relayd_interface *rif, const uint8_t *lladdr, const uint8_t *ipaddr)
175 struct relayd_host *host;
177 DPRINTF(1, "%s: adding host "IP_FMT" ("MAC_FMT")\n", rif->ifname,
178 IP_BUF(ipaddr), MAC_BUF(lladdr));
180 host = calloc(1, sizeof(*host));
182 memcpy(host->ipaddr, ipaddr, sizeof(host->ipaddr));
183 memcpy(host->lladdr, lladdr, sizeof(host->lladdr));
184 list_add(&host->list, &rif->hosts);
185 host->timeout.cb = host_entry_timeout;
186 uloop_timeout_set(&host->timeout, host_timeout * 1000);
190 relayd_add_route(host);
195 struct relayd_host *relayd_refresh_host(struct relayd_interface *rif, const uint8_t *lladdr, const uint8_t *ipaddr)
197 struct relayd_host *host;
199 host = find_host_by_ipaddr(rif, ipaddr);
201 host = find_host_by_ipaddr(NULL, ipaddr);
204 * When we suddenly see the host appearing on a different interface,
205 * reduce the timeout to make the old entry expire faster, in case the
207 * If the old entry is behind a managed interface, it will be pinged
208 * before we expire it
210 if (host && !host->cleanup_pending)
211 uloop_timeout_set(&host->timeout, 1);
213 host = add_host(rif, lladdr, ipaddr);
215 host->cleanup_pending = false;
216 uloop_timeout_set(&host->timeout, host_timeout * 1000);
222 static void relay_arp_request(struct relayd_interface *from_rif, struct arp_packet *pkt)
224 struct relayd_interface *rif;
225 struct arp_packet reqpkt;
227 memcpy(&reqpkt, pkt, sizeof(reqpkt));
228 list_for_each_entry(rif, &interfaces, list) {
232 memcpy(reqpkt.eth.ether_shost, rif->sll.sll_addr, ETH_ALEN);
233 memcpy(reqpkt.arp.arp_sha, rif->sll.sll_addr, ETH_ALEN);
235 DPRINTF(2, "%s: sending ARP who-has "IP_FMT", tell "IP_FMT" ("MAC_FMT")\n",
236 rif->ifname, IP_BUF(reqpkt.arp.arp_tpa),
237 IP_BUF(reqpkt.arp.arp_spa), MAC_BUF(reqpkt.eth.ether_shost));
239 sendto(rif->fd.fd, &reqpkt, sizeof(reqpkt), 0,
240 (struct sockaddr *) &rif->sll, sizeof(rif->sll));
244 static void recv_arp_request(struct relayd_interface *rif, struct arp_packet *pkt)
246 struct relayd_host *host;
248 DPRINTF(2, "%s: ARP who-has "IP_FMT", tell "IP_FMT" ("MAC_FMT")\n",
250 IP_BUF(pkt->arp.arp_tpa),
251 IP_BUF(pkt->arp.arp_spa),
252 MAC_BUF(pkt->eth.ether_shost));
254 if (!memcmp(pkt->arp.arp_spa, "\x00\x00\x00\x00", 4))
257 relayd_refresh_host(rif, pkt->eth.ether_shost, pkt->arp.arp_spa);
259 host = find_host_by_ipaddr(NULL, pkt->arp.arp_tpa);
262 * If a host is being pinged because of a timeout, do not use the cached
263 * entry here. That way we can avoid giving out stale data in case the node
264 * has moved. We shouldn't relay requests here either, as we might miss our
265 * chance to create a host route.
267 if (host && host->cleanup_pending)
270 relay_arp_request(rif, pkt);
274 static void recv_arp_reply(struct relayd_interface *rif, struct arp_packet *pkt)
276 struct relayd_host *host;
278 DPRINTF(2, "%s: received ARP reply for "IP_FMT" from "MAC_FMT", deliver to "IP_FMT"\n",
280 IP_BUF(pkt->arp.arp_spa),
281 MAC_BUF(pkt->eth.ether_shost),
282 IP_BUF(pkt->arp.arp_tpa));
284 relayd_refresh_host(rif, pkt->arp.arp_sha, pkt->arp.arp_spa);
286 if (!memcmp(pkt->arp.arp_tpa, rif->src_ip, 4))
289 host = find_host_by_ipaddr(NULL, pkt->arp.arp_tpa);
293 if (host->rif == rif)
296 send_arp_reply(host->rif, pkt->arp.arp_spa, host->lladdr, host->ipaddr);
299 static void recv_packet(struct uloop_fd *fd, unsigned int events)
301 struct relayd_interface *rif = container_of(fd, struct relayd_interface, fd);
302 struct arp_packet *pkt;
303 static char pktbuf[4096];
310 pktlen = recv(rif->fd.fd, pktbuf, sizeof(pktbuf), 0);
321 pkt = (void *)pktbuf;
322 if (pkt->arp.arp_op == htons(ARPOP_REPLY))
323 recv_arp_reply(rif, pkt);
324 else if (pkt->arp.arp_op == htons(ARPOP_REQUEST))
325 recv_arp_request(rif, pkt);
327 DPRINTF(1, "received unknown packet type: %04x\n", ntohs(pkt->arp.arp_op));
332 static void forward_bcast_packet(struct relayd_interface *from_rif, void *packet, int len)
334 struct relayd_interface *rif;
335 struct ether_header *eth = packet;
337 list_for_each_entry(rif, &interfaces, list) {
341 DPRINTF(3, "%s: forwarding broadcast packet to %s\n", from_rif->ifname, rif->ifname);
342 memcpy(eth->ether_shost, rif->sll.sll_addr, ETH_ALEN);
343 send(rif->bcast_fd.fd, packet, len, 0);
348 chksum(uint16_t sum, const uint8_t *data, uint16_t len)
353 last = data + len - 1;
356 t = (data[0] << 8) + data[1];
364 t = (data[0] << 8) + 0;
373 static bool forward_dhcp_packet(struct relayd_interface *rif, void *data, int len)
375 struct ip_packet *pkt = data;
377 struct dhcp_header *dhcp;
381 if (pkt->eth.ether_type != htons(ETH_P_IP))
384 if (pkt->iph.version != 4)
387 if (pkt->iph.protocol != IPPROTO_UDP)
390 udp = (void *) ((char *) &pkt->iph + (pkt->iph.ihl << 2));
391 dhcp = (void *) (udp + 1);
393 udplen = ntohs(udp->len);
394 if (udplen > len - ((char *) udp - (char *) data))
397 if (udp->dest != htons(67) && udp->source != htons(67))
400 if (dhcp->op != 1 && dhcp->op != 2)
407 relayd_refresh_host(rif, pkt->eth.ether_shost, (void *) &pkt->iph.saddr);
409 DPRINTF(2, "%s: handling DHCP %s\n", rif->ifname, (dhcp->op == 1 ? "request" : "response"));
411 dhcp->flags |= htons(DHCP_FLAG_BROADCAST);
414 sum = udplen + IPPROTO_UDP;
415 sum = chksum(sum, (void *) &pkt->iph.saddr, 8);
416 sum = chksum(sum, (void *) udp, udplen);
420 udp->check = htons(~sum);
422 forward_bcast_packet(rif, data, len);
427 static void recv_bcast_packet(struct uloop_fd *fd, unsigned int events)
429 struct relayd_interface *rif = container_of(fd, struct relayd_interface, bcast_fd);
430 static char pktbuf[4096];
437 pktlen = recv(rif->bcast_fd.fd, pktbuf, sizeof(pktbuf), 0);
448 if (!forward_bcast && !forward_dhcp)
451 if (forward_dhcp_packet(rif, pktbuf, pktlen))
455 forward_bcast_packet(rif, pktbuf, pktlen);
460 static int init_interface(struct relayd_interface *rif)
462 struct sockaddr_ll *sll = &rif->sll;
463 struct sockaddr_in *sin;
466 #ifdef PACKET_RECV_TYPE
467 unsigned int pkt_type;
470 fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ARP));
476 memset(&ifr, 0, sizeof(ifr));
477 strcpy(ifr.ifr_name, rif->ifname);
479 if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
480 perror("ioctl(SIOCGIFHWADDR)");
484 memcpy(sll->sll_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
485 sll->sll_family = AF_PACKET;
486 sll->sll_protocol = htons(ETH_P_ARP);
487 sll->sll_pkttype = PACKET_BROADCAST;
488 sll->sll_hatype = ARPHRD_ETHER;
489 sll->sll_halen = ETH_ALEN;
491 if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) {
492 perror("ioctl(SIOCGIFINDEX)");
496 sll->sll_ifindex = ifr.ifr_ifindex;
498 if (ioctl(fd, SIOCGIFADDR, &ifr) < 0) {
499 memcpy(rif->src_ip, DUMMY_IP, sizeof(rif->src_ip));
501 sin = (struct sockaddr_in *) &ifr.ifr_addr;
502 memcpy(rif->src_ip, &sin->sin_addr.s_addr, sizeof(rif->src_ip));
505 if (bind(fd, (struct sockaddr *)sll, sizeof(struct sockaddr_ll)) < 0) {
506 perror("bind(ETH_P_ARP)");
510 rif->fd.cb = recv_packet;
511 uloop_fd_add(&rif->fd, ULOOP_READ | ULOOP_EDGE_TRIGGER);
513 if (!forward_bcast && !forward_dhcp)
516 fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IP));
520 rif->bcast_fd.fd = fd;
521 rif->bcast_fd.cb = recv_bcast_packet;
523 memcpy(&rif->bcast_sll, &rif->sll, sizeof(rif->bcast_sll));
524 sll = &rif->bcast_sll;
525 sll->sll_protocol = htons(ETH_P_IP);
527 if (bind(fd, (struct sockaddr *)sll, sizeof(struct sockaddr_ll)) < 0) {
528 perror("bind(ETH_P_IP)");
532 #ifdef PACKET_RECV_TYPE
533 pkt_type = (1 << PACKET_BROADCAST);
534 setsockopt(fd, SOL_PACKET, PACKET_RECV_TYPE, &pkt_type, sizeof(pkt_type));
537 uloop_fd_add(&rif->bcast_fd, ULOOP_READ | ULOOP_EDGE_TRIGGER);
541 static int init_interfaces(void)
543 struct relayd_interface *rif;
546 list_for_each_entry(rif, &interfaces, list) {
547 ret = init_interface(rif);
555 static void del_interface(struct relayd_interface *rif)
557 struct relayd_host *host, *htmp;
559 list_for_each_entry_safe(host, htmp, &rif->hosts, list) {
565 static void cleanup_interfaces(void)
567 struct relayd_interface *rif, *rtmp;
569 list_for_each_entry_safe(rif, rtmp, &interfaces, list) {
574 static int alloc_interface(const char *ifname, bool managed)
576 struct relayd_interface *rif;
578 if (strlen(ifname) >= IFNAMSIZ)
581 rif = calloc(1, sizeof(*rif));
585 INIT_LIST_HEAD(&rif->list);
586 INIT_LIST_HEAD(&rif->hosts);
587 strcpy(rif->ifname, ifname);
588 list_add(&rif->list, &interfaces);
589 rif->managed = managed;
594 static void die(int signo)
597 * When we hit SIGTERM, clean up interfaces directly, so that we
598 * won't leave our routing in an invalid state.
600 cleanup_interfaces();
604 static int usage(const char *progname)
606 fprintf(stderr, "Usage: %s <options>\n"
609 " -d Enable debug messages\n"
610 " -i <ifname> Add an interface for relaying\n"
611 " -I <ifname> Same as -i, except with ARP cache and host route management\n"
612 " You need to specify at least two interfaces\n"
613 " -t <timeout> Host entry expiry timeout\n"
614 " -B Enable broadcast forwarding\n"
615 " -D Enable DHCP forwarding\n"
621 int main(int argc, char **argv)
628 inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
630 perror("socket(AF_INET)");
638 while ((ch = getopt(argc, argv, "I:i:t:BDd")) != -1) {
645 if (alloc_interface(optarg, managed) < 0)
651 host_timeout = atoi(optarg);
652 if (host_timeout <= 0)
653 return usage(argv[0]);
666 return usage(argv[0]);
670 if (list_empty(&interfaces))
671 return usage(argv[0]);
674 fprintf(stderr, "ERROR: Need at least 2 interfaces for relaying\n");
681 signal(SIGTERM, die);
683 signal(SIGUSR1, die);
684 signal(SIGUSR2, die);
686 if (init_interfaces() < 0)
689 if (relayd_rtnl_init() < 0)
695 cleanup_interfaces();