X-Git-Url: http://git.archive.openwrt.org/?p=project%2Frelayd.git;a=blobdiff_plain;f=main.c;h=2f3bae855be804c6b26ef2e03dde1579a63f5e2f;hp=a29be2c1e733830c787e7680ac3faeba2e25eb4f;hb=d515c3bc3b1eb92c4ae9f5e8f51ea3886b8d2d2f;hpb=fba3e8d167c037bdbb29ea79c483c10b8f9f2d02;ds=sidebyside diff --git a/main.c b/main.c index a29be2c..2f3bae8 100644 --- a/main.c +++ b/main.c @@ -16,109 +16,39 @@ * */ #include - -#include -#include -#include -#include -#include -#include - -#include -#include -#include +#include #include #include #include #include #include -#include #include #include #include #include +#include -#include "uloop.h" -#include "list.h" - -#define DEBUG -#ifdef DEBUG -#define DPRINTF(level, ...) if (debug >= level) fprintf(stderr, __VA_ARGS__); -#else -#define DPRINTF(...) do {} while(0) -#endif - -#ifndef __packed -#define __packed __attribute__((packed)) -#endif - -#define __uc(c) ((unsigned char *)(c)) - -#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x" -#define MAC_BUF(_c) __uc(_c)[0], __uc(_c)[1], __uc(_c)[2], __uc(_c)[3], __uc(_c)[4], __uc(_c)[5] - -#define IP_FMT "%d.%d.%d.%d" -#define IP_BUF(_c) __uc(_c)[0], __uc(_c)[1], __uc(_c)[2], __uc(_c)[3] - -#define DUMMY_IP ((uint8_t *) "\x01\x01\x01\x01") - -#define DHCP_FLAG_BROADCAST (1 << 15) - -struct relayd_interface { - struct list_head list; - struct uloop_fd fd; - struct uloop_fd bcast_fd; - struct sockaddr_ll sll; - struct sockaddr_ll bcast_sll; - char ifname[IFNAMSIZ]; - struct list_head hosts; - uint8_t src_ip[4]; - bool managed; -}; - -struct relayd_host { - struct list_head list; - struct relayd_interface *rif; - uint8_t lladdr[ETH_ALEN]; - uint8_t ipaddr[4]; - struct uloop_timeout timeout; - int cleanup_pending; -}; +#include "relayd.h" -struct arp_packet { - struct ether_header eth; - struct ether_arp arp; -} __packed; - -struct ip_packet { - struct ether_header eth; - struct iphdr iph; -} __packed; - -struct dhcp_header { - uint8_t op, htype, hlen, hops; - uint32_t xit; - uint16_t secs, flags; - struct in_addr ciaddr, yiaddr, siaddr, giaddr; - unsigned char chaddr[16]; - unsigned char sname[64]; - unsigned char file[128]; -} __packed; - -struct rtnl_req { - struct nlmsghdr nl; - struct rtmsg rt; -}; +static LIST_HEAD(pending_routes); +LIST_HEAD(interfaces); +int debug; -static int debug; -static LIST_HEAD(interfaces); static int host_timeout; +static int host_ping_tries; static int inet_sock; static int forward_bcast; static int forward_dhcp; -static struct uloop_fd rtnl_sock; -static unsigned int rtnl_seq, rtnl_dump_seq; + +uint8_t local_addr[4]; +int local_route_table; + +struct relayd_pending_route { + struct relayd_route rt; + struct uloop_timeout timeout; + uint8_t gateway[4]; +}; static struct relayd_host *find_host_by_ipaddr(struct relayd_interface *rif, const uint8_t *ipaddr) { @@ -162,75 +92,55 @@ static void add_arp(struct relayd_host *host) ioctl(inet_sock, SIOCSARP, &arp); } -static void rtnl_route_set(struct relayd_host *host, bool add) +static void timeout_host_route(struct uloop_timeout *timeout) { - static struct { - struct nlmsghdr nl; - struct rtmsg rt; - struct { - struct rtattr rta; - uint8_t ipaddr[4]; - } __packed dst; - struct { - struct rtattr rta; - int ifindex; - } __packed dev; - } __packed req; - - memset(&req, 0, sizeof(req)); - - req.nl.nlmsg_len = sizeof(req); - req.rt.rtm_family = AF_INET; - req.rt.rtm_dst_len = 32; - - req.dst.rta.rta_type = RTA_DST; - req.dst.rta.rta_len = sizeof(req.dst); - memcpy(req.dst.ipaddr, host->ipaddr, sizeof(req.dst.ipaddr)); - - req.dev.rta.rta_type = RTA_OIF; - req.dev.rta.rta_len = sizeof(req.dev); - req.dev.ifindex = host->rif->sll.sll_ifindex; - - req.nl.nlmsg_flags = NLM_F_REQUEST; - req.rt.rtm_table = RT_TABLE_MAIN; - if (add) { - req.nl.nlmsg_type = RTM_NEWROUTE; - req.nl.nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE; - - req.rt.rtm_protocol = RTPROT_BOOT; - req.rt.rtm_scope = RT_SCOPE_LINK; - req.rt.rtm_type = RTN_UNICAST; - } else { - req.nl.nlmsg_type = RTM_DELROUTE; - req.rt.rtm_scope = RT_SCOPE_NOWHERE; - } + struct relayd_pending_route *rt; - send(rtnl_sock.fd, &req, sizeof(req), 0); + rt = container_of(timeout, struct relayd_pending_route, timeout); + list_del(&rt->rt.list); + free(rt); } -static void add_route(struct relayd_host *host) +void relayd_add_host_route(struct relayd_host *host, const uint8_t *dest, uint8_t mask) { - rtnl_route_set(host, true); -} + struct relayd_route *rt; -static void del_route(struct relayd_host *host) -{ - rtnl_route_set(host, false); + list_for_each_entry(rt, &host->routes, list) { + if (!memcmp(rt->dest, dest, sizeof(rt->dest)) && rt->mask == mask) + return; + } + + rt = calloc(1, sizeof(*rt)); + if (!rt) + return; + + list_add(&rt->list, &host->routes); + memcpy(rt->dest, dest, sizeof(rt->dest)); + rt->mask = mask; + relayd_add_route(host, rt); } static void del_host(struct relayd_host *host) { + struct relayd_route *route, *tmp; + DPRINTF(1, "%s: deleting host "IP_FMT" ("MAC_FMT")\n", host->rif->ifname, IP_BUF(host->ipaddr), MAC_BUF(host->lladdr)); + list_for_each_entry_safe(route, tmp, &host->routes, list) { + relayd_del_route(host, route); + list_del(&route->list); + free(route); + } if (host->rif->managed) - del_route(host); + relayd_del_route(host, NULL); + uloop_timeout_cancel(&host->timeout); list_del(&host->list); free(host); } -static void fill_arp_request(struct arp_packet *pkt, struct relayd_interface *rif, - uint8_t spa[4], uint8_t tpa[4]) +static void fill_arp_packet(struct arp_packet *pkt, struct relayd_interface *rif, + const uint8_t spa[4], const uint8_t tpa[4]) { memset(pkt, 0, sizeof(*pkt)); @@ -247,12 +157,11 @@ static void fill_arp_request(struct arp_packet *pkt, struct relayd_interface *ri pkt->arp.arp_pln = 4; } -static void send_arp_request(struct relayd_host *host) +static void send_arp_request(struct relayd_interface *rif, const uint8_t *ipaddr) { - struct relayd_interface *rif = host->rif; struct arp_packet pkt; - fill_arp_request(&pkt, host->rif, host->rif->src_ip, host->ipaddr); + fill_arp_packet(&pkt, rif, rif->src_ip, ipaddr); pkt.arp.arp_op = htons(ARPOP_REQUEST); memcpy(pkt.arp.arp_spa, rif->src_ip, ETH_ALEN); @@ -267,20 +176,59 @@ static void send_arp_request(struct relayd_host *host) (struct sockaddr *) &rif->sll, sizeof(rif->sll)); } +void relayd_add_pending_route(const uint8_t *gateway, const uint8_t *dest, uint8_t mask, int timeout) +{ + struct relayd_pending_route *rt; + struct relayd_interface *rif; + struct relayd_host *host; + + host = find_host_by_ipaddr(NULL, gateway); + if (host) { + relayd_add_host_route(host, dest, mask); + return; + } + + rt = calloc(1, sizeof(*rt)); + if (!rt) + return; + + memcpy(rt->gateway, gateway, sizeof(rt->gateway)); + memcpy(rt->rt.dest, dest, sizeof(rt->rt.dest)); + rt->rt.mask = mask; + list_add(&rt->rt.list, &pending_routes); + if (timeout <= 0) + return; + + rt->timeout.cb = timeout_host_route; + uloop_timeout_set(&rt->timeout, 10000); + list_for_each_entry(rif, &interfaces, list) { + send_arp_request(rif, gateway); + } +} + static void send_arp_reply(struct relayd_interface *rif, uint8_t spa[4], uint8_t tha[ETH_ALEN], uint8_t tpa[4]) { struct arp_packet pkt; - fill_arp_request(&pkt, rif, spa, tpa); + fill_arp_packet(&pkt, rif, spa, tpa); pkt.arp.arp_op = htons(ARPOP_REPLY); - memcpy(pkt.eth.ether_dhost, tha, ETH_ALEN); - memcpy(pkt.arp.arp_tha, tha, ETH_ALEN); + if (tha) { + memcpy(pkt.eth.ether_dhost, tha, ETH_ALEN); + memcpy(pkt.arp.arp_tha, tha, ETH_ALEN); - DPRINTF(2, "%s: sending ARP reply to "IP_FMT", "IP_FMT" is at ("MAC_FMT")\n", - rif->ifname, IP_BUF(pkt.arp.arp_tpa), - IP_BUF(pkt.arp.arp_spa), MAC_BUF(pkt.eth.ether_shost)); + DPRINTF(2, "%s: sending ARP reply to "IP_FMT", "IP_FMT" is at ("MAC_FMT")\n", + rif->ifname, IP_BUF(pkt.arp.arp_tpa), + IP_BUF(pkt.arp.arp_spa), MAC_BUF(pkt.eth.ether_shost)); + } else { + memset(pkt.eth.ether_dhost, 0xff, ETH_ALEN); + memset(pkt.arp.arp_tha, 0, ETH_ALEN); + + DPRINTF(2, "%s: sending gratuitous ARP: "IP_FMT" is at ("MAC_FMT")\n", + rif->ifname, IP_BUF(pkt.arp.arp_tpa), + MAC_BUF(pkt.eth.ether_shost)); + } sendto(rif->fd.fd, &pkt, sizeof(pkt), 0, (struct sockaddr *) &rif->sll, sizeof(rif->sll)); @@ -297,8 +245,8 @@ static void host_entry_timeout(struct uloop_timeout *timeout) * When the timeout is reached, try pinging the host a few times before * giving up on it. */ - if (host->rif->managed && host->cleanup_pending < 2) { - send_arp_request(host); + if (host->rif->managed && host->cleanup_pending < host_ping_tries) { + send_arp_request(host->rif, host->ipaddr); host->cleanup_pending++; uloop_timeout_set(&host->timeout, 1000); return; @@ -309,11 +257,13 @@ static void host_entry_timeout(struct uloop_timeout *timeout) static struct relayd_host *add_host(struct relayd_interface *rif, const uint8_t *lladdr, const uint8_t *ipaddr) { struct relayd_host *host; + struct relayd_pending_route *route, *rtmp; DPRINTF(1, "%s: adding host "IP_FMT" ("MAC_FMT")\n", rif->ifname, IP_BUF(ipaddr), MAC_BUF(lladdr)); host = calloc(1, sizeof(*host)); + INIT_LIST_HEAD(&host->routes); host->rif = rif; memcpy(host->ipaddr, ipaddr, sizeof(host->ipaddr)); memcpy(host->lladdr, lladdr, sizeof(host->lladdr)); @@ -323,12 +273,25 @@ static struct relayd_host *add_host(struct relayd_interface *rif, const uint8_t add_arp(host); if (rif->managed) - add_route(host); + relayd_add_route(host, NULL); + + list_for_each_entry_safe(route, rtmp, &pending_routes, rt.list) { + if (memcmp(route->gateway, ipaddr, 4) != 0) + continue; + + relayd_add_host_route(host, route->rt.dest, route->rt.mask); + if (!route->timeout.pending) + continue; + + uloop_timeout_cancel(&route->timeout); + list_del(&route->rt.list); + free(route); + } return host; } -static struct relayd_host *refresh_host(struct relayd_interface *rif, const uint8_t *lladdr, const uint8_t *ipaddr) +struct relayd_host *relayd_refresh_host(struct relayd_interface *rif, const uint8_t *lladdr, const uint8_t *ipaddr) { struct relayd_host *host; @@ -343,8 +306,10 @@ static struct relayd_host *refresh_host(struct relayd_interface *rif, const uint * If the old entry is behind a managed interface, it will be pinged * before we expire it */ - if (host && !host->cleanup_pending) + if (host && !host->cleanup_pending) { uloop_timeout_set(&host->timeout, 1); + return NULL; + } host = add_host(rif, lladdr, ipaddr); } else { @@ -390,7 +355,14 @@ static void recv_arp_request(struct relayd_interface *rif, struct arp_packet *pk if (!memcmp(pkt->arp.arp_spa, "\x00\x00\x00\x00", 4)) return; - refresh_host(rif, pkt->eth.ether_shost, pkt->arp.arp_spa); + if (local_route_table && !memcmp(pkt->arp.arp_tpa, local_addr, sizeof(local_addr))) { + send_arp_reply(rif, local_addr, pkt->arp.arp_sha, pkt->arp.arp_spa); + return; + } + + host = find_host_by_ipaddr(NULL, pkt->arp.arp_spa); + if (!host || host->rif != rif) + relayd_refresh_host(rif, pkt->eth.ether_shost, pkt->arp.arp_spa); host = find_host_by_ipaddr(NULL, pkt->arp.arp_tpa); @@ -409,6 +381,7 @@ static void recv_arp_request(struct relayd_interface *rif, struct arp_packet *pk static void recv_arp_reply(struct relayd_interface *rif, struct arp_packet *pkt) { + struct relayd_interface *to_rif; struct relayd_host *host; DPRINTF(2, "%s: received ARP reply for "IP_FMT" from "MAC_FMT", deliver to "IP_FMT"\n", @@ -417,15 +390,30 @@ static void recv_arp_reply(struct relayd_interface *rif, struct arp_packet *pkt) MAC_BUF(pkt->eth.ether_shost), IP_BUF(pkt->arp.arp_tpa)); - refresh_host(rif, pkt->arp.arp_sha, pkt->arp.arp_spa); + if (memcmp(pkt->arp.arp_sha, rif->sll.sll_addr, ETH_ALEN) != 0) + relayd_refresh_host(rif, pkt->arp.arp_sha, pkt->arp.arp_spa); + + if (!memcmp(pkt->arp.arp_tpa, rif->src_ip, 4)) { + /* + * locally initiated lookup, relay as gratuitous ARP + * to all other interfaces + */ + list_for_each_entry(to_rif, &interfaces, list) { + if (rif == to_rif) + continue; - if (!memcmp(pkt->arp.arp_tpa, rif->src_ip, 4)) + send_arp_reply(to_rif, pkt->arp.arp_spa, NULL, pkt->arp.arp_spa); + } return; + } host = find_host_by_ipaddr(NULL, pkt->arp.arp_tpa); if (!host) return; + if (host->rif == rif) + return; + send_arp_reply(host->rif, pkt->arp.arp_spa, host->lladdr, host->ipaddr); } @@ -462,7 +450,7 @@ static void recv_packet(struct uloop_fd *fd, unsigned int events) } while (1); } -static void forward_bcast_packet(struct relayd_interface *from_rif, void *packet, int len) +void relayd_forward_bcast_packet(struct relayd_interface *from_rif, void *packet, int len) { struct relayd_interface *rif; struct ether_header *eth = packet; @@ -477,86 +465,6 @@ static void forward_bcast_packet(struct relayd_interface *from_rif, void *packet } } -static uint16_t -chksum(uint16_t sum, const uint8_t *data, uint16_t len) -{ - const uint8_t *last; - uint16_t t; - - last = data + len - 1; - - while(data < last) { - t = (data[0] << 8) + data[1]; - sum += t; - if(sum < t) - sum++; - data += 2; - } - - if(data == last) { - t = (data[0] << 8) + 0; - sum += t; - if(sum < t) - sum++; - } - - return sum; -} - -static bool forward_dhcp_packet(struct relayd_interface *rif, void *data, int len) -{ - struct ip_packet *pkt = data; - struct udphdr *udp; - struct dhcp_header *dhcp; - int udplen; - uint16_t sum; - - if (pkt->eth.ether_type != htons(ETH_P_IP)) - return false; - - if (pkt->iph.version != 4) - return false; - - if (pkt->iph.protocol != IPPROTO_UDP) - return false; - - udp = (void *) ((char *) &pkt->iph + (pkt->iph.ihl << 2)); - dhcp = (void *) (udp + 1); - - udplen = ntohs(udp->len); - if (udplen > len - ((char *) udp - (char *) data)) - return false; - - if (udp->dest != htons(67) && udp->source != htons(67)) - return false; - - if (dhcp->op != 1 && dhcp->op != 2) - return false; - - if (!forward_dhcp) - return true; - - if (dhcp->op == 2) - refresh_host(rif, pkt->eth.ether_shost, (void *) &pkt->iph.saddr); - - DPRINTF(2, "%s: handling DHCP %s\n", rif->ifname, (dhcp->op == 1 ? "request" : "response")); - - dhcp->flags |= htons(DHCP_FLAG_BROADCAST); - - udp->check = 0; - sum = udplen + IPPROTO_UDP; - sum = chksum(sum, (void *) &pkt->iph.saddr, 8); - sum = chksum(sum, (void *) udp, udplen); - if (sum == 0) - sum = 0xffff; - - udp->check = htons(~sum); - - forward_bcast_packet(rif, data, len); - - return true; -} - static void recv_bcast_packet(struct uloop_fd *fd, unsigned int events) { struct relayd_interface *rif = container_of(fd, struct relayd_interface, bcast_fd); @@ -581,11 +489,11 @@ static void recv_bcast_packet(struct uloop_fd *fd, unsigned int events) if (!forward_bcast && !forward_dhcp) continue; - if (forward_dhcp_packet(rif, pktbuf, pktlen)) + if (relayd_handle_dhcp_packet(rif, pktbuf, pktlen, forward_dhcp)) continue; if (forward_bcast) - forward_bcast_packet(rif, pktbuf, pktlen); + relayd_forward_bcast_packet(rif, pktbuf, pktlen); } while (1); } @@ -668,9 +576,20 @@ static int init_interface(struct relayd_interface *rif) #endif uloop_fd_add(&rif->bcast_fd, ULOOP_READ | ULOOP_EDGE_TRIGGER); + relayd_add_interface_routes(rif); return 0; } +static void ping_static_routes(void) +{ + struct relayd_pending_route *rt; + struct relayd_interface *rif; + + list_for_each_entry(rt, &pending_routes, rt.list) + list_for_each_entry(rif, &interfaces, list) + send_arp_request(rif, rt->gateway); +} + static int init_interfaces(void) { struct relayd_interface *rif; @@ -685,186 +604,46 @@ static int init_interfaces(void) return 0; } -static void del_interface(struct relayd_interface *rif) +static void cleanup_hosts(void) { - struct relayd_host *host, *htmp; + struct relayd_interface *rif; + struct relayd_host *host, *tmp; - list_for_each_entry_safe(host, htmp, &rif->hosts, list) { - del_host(host); + list_for_each_entry(rif, &interfaces, list) { + list_for_each_entry_safe(host, tmp, &rif->hosts, list) { + del_host(host); + } } - free(rif); } -static void cleanup_interfaces(void) +static void free_interfaces(void) { struct relayd_interface *rif, *rtmp; list_for_each_entry_safe(rif, rtmp, &interfaces, list) { - del_interface(rif); + relayd_del_interface_routes(rif); + list_del(&rif->list); + free(rif); } } -static int alloc_interface(const char *ifname, bool managed) +static struct relayd_interface *alloc_interface(const char *ifname, bool managed) { struct relayd_interface *rif; if (strlen(ifname) >= IFNAMSIZ) - return -1; + return NULL; rif = calloc(1, sizeof(*rif)); if (!rif) - return -1; + return NULL; - INIT_LIST_HEAD(&rif->list); INIT_LIST_HEAD(&rif->hosts); strcpy(rif->ifname, ifname); list_add(&rif->list, &interfaces); rif->managed = managed; - return 0; -} - -#ifndef NDA_RTA -#define NDA_RTA(r) \ - ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg)))) -#endif - -static void rtnl_parse_newneigh(struct nlmsghdr *h) -{ - struct relayd_interface *rif = NULL; - struct ndmsg *r = NLMSG_DATA(h); - const uint8_t *lladdr = NULL; - const uint8_t *ipaddr = NULL; - struct rtattr *rta; - int len; - - if (r->ndm_family != AF_INET) - return; - - list_for_each_entry(rif, &interfaces, list) { - if (rif->sll.sll_ifindex == r->ndm_ifindex) - goto found_interface; - } - return; - -found_interface: - len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*r)); - for (rta = NDA_RTA(r); RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) { - switch(rta->rta_type) { - case NDA_LLADDR: - lladdr = RTA_DATA(rta); - break; - case NDA_DST: - ipaddr = RTA_DATA(rta); - break; - default: - break; - } - } - - if (!lladdr || !ipaddr || (r->ndm_state & (NUD_INCOMPLETE|NUD_FAILED))) - return; - - if (!memcmp(lladdr, "\x00\x00\x00\x00\x00\x00", ETH_ALEN)) - return; - - DPRINTF(1, "%s: Found ARP cache entry for host "IP_FMT" ("MAC_FMT")\n", - rif->ifname, IP_BUF(ipaddr), MAC_BUF(lladdr)); - refresh_host(rif, lladdr, ipaddr); -} - -static void rtnl_parse_packet(void *data, int len) -{ - struct nlmsghdr *h; - - for (h = data; NLMSG_OK(h, len); h = NLMSG_NEXT(h, len)) { - if (h->nlmsg_type == NLMSG_DONE || - h->nlmsg_type == NLMSG_ERROR) - return; - - if (h->nlmsg_seq != rtnl_dump_seq) - continue; - - if (h->nlmsg_type == RTM_NEWNEIGH) - rtnl_parse_newneigh(h); - } -} - -static void rtnl_cb(struct uloop_fd *fd, unsigned int events) -{ - struct sockaddr_nl nladdr; - static uint8_t buf[16384]; - struct iovec iov = { - .iov_base = buf, - .iov_len = sizeof(buf), - }; - struct msghdr msg = { - .msg_name = &nladdr, - .msg_namelen = sizeof(nladdr), - .msg_iov = &iov, - .msg_iovlen = 1, - }; - - do { - int len; - - len = recvmsg(rtnl_sock.fd, &msg, 0); - if (len < 0) { - if (errno == EINTR) - continue; - - return; - } - - if (!len) - break; - - if (nladdr.nl_pid != 0) - continue; - - rtnl_parse_packet(buf, len); - } while (1); -} - -static int rtnl_init(void) -{ - struct sockaddr_nl snl_local; - static struct { - struct nlmsghdr nlh; - struct rtgenmsg g; - } req = { - .nlh = { - .nlmsg_len = sizeof(req), - .nlmsg_type = RTM_GETNEIGH, - .nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST, - .nlmsg_pid = 0, - }, - .g.rtgen_family = AF_INET, - }; - - rtnl_sock.fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); - if (rtnl_sock.fd < 0) { - perror("socket(AF_NETLINK)"); - return -1; - } - - snl_local.nl_family = AF_NETLINK; - - if (bind(rtnl_sock.fd, (struct sockaddr *) &snl_local, sizeof(struct sockaddr_nl)) < 0) { - perror("bind"); - close(rtnl_sock.fd); - return -1; - } - - rtnl_sock.cb = rtnl_cb; - uloop_fd_add(&rtnl_sock, ULOOP_READ | ULOOP_EDGE_TRIGGER); - - rtnl_seq = time(NULL); - rtnl_dump_seq = rtnl_seq; - req.nlh.nlmsg_seq = rtnl_seq; - send(rtnl_sock.fd, &req, sizeof(req), 0); - - return 0; + return rif; } static void die(int signo) @@ -873,7 +652,8 @@ static void die(int signo) * When we hit SIGTERM, clean up interfaces directly, so that we * won't leave our routing in an invalid state. */ - cleanup_interfaces(); + cleanup_hosts(); + free_interfaces(); exit(1); } @@ -886,9 +666,15 @@ static int usage(const char *progname) " -i Add an interface for relaying\n" " -I Same as -i, except with ARP cache and host route management\n" " You need to specify at least two interfaces\n" + " -G Set a gateway IP for clients\n" + " -R :/\n" + " Add a static route for / via \n" " -t Host entry expiry timeout\n" + " -p Number of ARP ping attempts before considering a host dead\n" + " -T Set routing table number for automatically added routes\n" " -B Enable broadcast forwarding\n" " -D Enable DHCP forwarding\n" + " -L Enable local access using as source address\n" "\n", progname); return -1; @@ -896,8 +682,13 @@ static int usage(const char *progname) int main(int argc, char **argv) { + struct relayd_interface *rif = NULL; + struct in_addr addr, addr2; + bool local_addr_valid = false; bool managed; int ifnum = 0; + char *s, *s2; + int mask; int ch; debug = 0; @@ -907,18 +698,21 @@ int main(int argc, char **argv) return 1; } - host_timeout = 60; + host_timeout = 30; + host_ping_tries = 5; forward_bcast = 0; + local_route_table = 0; uloop_init(); - while ((ch = getopt(argc, argv, "I:i:t:BDd")) != -1) { + while ((ch = getopt(argc, argv, "I:i:t:BDdT:G:R:L:")) != -1) { switch(ch) { case 'I': managed = true; /* fall through */ case 'i': ifnum++; - if (alloc_interface(optarg, managed) < 0) + rif = alloc_interface(optarg, managed); + if (!rif) return 1; managed = false; @@ -928,6 +722,11 @@ int main(int argc, char **argv) if (host_timeout <= 0) return usage(argv[0]); break; + case 'p': + host_ping_tries = atoi(optarg); + if (host_ping_tries <= 0) + return usage(argv[0]); + break; case 'd': debug++; break; @@ -937,6 +736,53 @@ int main(int argc, char **argv) case 'D': forward_dhcp = 1; break; + case 'T': + route_table = atoi(optarg); + if (route_table <= 0) + return usage(argv[0]); + break; + case 'G': + if (!inet_aton(optarg, &addr)) { + fprintf(stderr, "Address '%s' not found\n", optarg); + return 1; + } + relayd_add_pending_route((uint8_t *) &addr.s_addr, (const uint8_t *) "\x00\x00\x00\x00", 0, 0); + break; + case 'L': + if (!inet_aton(optarg, &addr)) { + fprintf(stderr, "Address '%s' not found\n", optarg); + return 1; + } + memcpy(&local_addr, &addr.s_addr, sizeof(local_addr)); + local_addr_valid = true; + break; + case 'R': + s = strchr(optarg, ':'); + if (!s) + return usage(argv[0]); + + *(s++) = 0; + if (!inet_aton(optarg, &addr)) { + fprintf(stderr, "Address '%s' not found\n", optarg); + return 1; + } + + s2 = strchr(s, '/'); + if (!s2) + return usage(argv[0]); + + *(s2++) = 0; + if (!inet_aton(s, &addr2)) { + fprintf(stderr, "Address '%s' not found\n", s); + return 1; + } + + mask = atoi(s2); + if (mask < 0 || mask > 32) + return usage(argv[0]); + + relayd_add_pending_route((uint8_t *) &addr.s_addr, (uint8_t *) &addr2.s_addr, mask, 0); + break; case '?': default: return usage(argv[0]); @@ -959,18 +805,23 @@ int main(int argc, char **argv) signal(SIGUSR1, die); signal(SIGUSR2, die); - if (init_interfaces() < 0) + if (local_addr_valid) + local_route_table = route_table++; + + if (relayd_rtnl_init() < 0) return 1; - if (rtnl_init() < 0) + if (init_interfaces() < 0) return 1; + ping_static_routes(); + uloop_run(); uloop_done(); - cleanup_interfaces(); - uloop_fd_delete(&rtnl_sock); - close(rtnl_sock.fd); + cleanup_hosts(); + free_interfaces(); + relayd_rtnl_done(); close(inet_sock); return 0;