/*
* rarpd.c RARP daemon.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
*/
#include <stdio.h>
#include <syslog.h>
#include <dirent.h>
#include <malloc.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/socket.h>
#include <sys/signal.h>
#include <linux/if.h>
#include <linux/if_arp.h>
#include <netinet/in.h>
#include <linux/if_packet.h>
#include <linux/filter.h>
int do_reload = 1;
int debug;
int verbose;
int ifidx;
int allow_offlink;
int only_ethers;
int all_ifaces;
int listen_arp;
char *ifname;
char *tftp_dir = "/etc/tftpboot";
extern int ether_ntohost(char *name, unsigned char *ea);
void usage(void) __attribute__((noreturn));
struct iflink
{
struct iflink *next;
int index;
int hatype;
unsigned char lladdr[16];
char name[IFNAMSIZ];
struct ifaddr *ifa_list;
} *ifl_list;
struct ifaddr
{
struct ifaddr *next;
__u32 prefix;
__u32 mask;
__u32 local;
};
struct rarp_map
{
struct rarp_map *next;
int ifindex;
int arp_type;
int lladdr_len;
unsigned char lladdr[16];
__u32 ipaddr;
} *rarp_db;
void usage()
{
fprintf(stderr, "Usage: rarpd [ -dveaA ] [ -b tftpdir ] [ interface]\n");
exit(1);
}
void load_db(void)
{
}
void load_if(void)
{
int fd;
struct ifreq *ifrp, *ifend;
struct iflink *ifl;
struct ifaddr *ifa;
struct ifconf ifc;
struct ifreq ibuf[256];
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
syslog(LOG_ERR, "socket: %m");
return;
}
ifc.ifc_len = sizeof ibuf;
ifc.ifc_buf = (caddr_t)ibuf;
if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
ifc.ifc_len < (int)sizeof(struct ifreq)) {
syslog(LOG_ERR, "SIOCGIFCONF: %m");
close(fd);
return;
}
while ((ifl = ifl_list) != NULL) {
while ((ifa = ifl->ifa_list) != NULL) {
ifl->ifa_list = ifa->next;
free(ifa);
}
ifl_list = ifl->next;
free(ifl);
}
ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
for (ifrp = ibuf; ifrp < ifend; ifrp++) {
__u32 addr;
__u32 mask;
__u32 prefix;
if (ifrp->ifr_addr.sa_family != AF_INET)
continue;
addr = ((struct sockaddr_in*)&ifrp->ifr_addr)->sin_addr.s_addr;
if (addr == 0)
continue;
if (ioctl(fd, SIOCGIFINDEX, ifrp)) {
syslog(LOG_ERR, "ioctl(SIOCGIFNAME): %m");
continue;
}
if (ifidx && ifrp->ifr_ifindex != ifidx)
continue;
for (ifl = ifl_list; ifl; ifl = ifl->next)
if (ifl->index == ifrp->ifr_ifindex)
break;
if (ifl == NULL) {
char *p;
int index = ifrp->ifr_ifindex;
if (ioctl(fd, SIOCGIFHWADDR, ifrp)) {
syslog(LOG_ERR, "ioctl(SIOCGIFHWADDR): %m");
continue;
}
ifl = (struct iflink*)malloc(sizeof(*ifl));
if (ifl == NULL)
continue;
memset(ifl, 0, sizeof(*ifl));
ifl->next = ifl_list;
ifl_list = ifl;
ifl->index = index;
ifl->hatype = ifrp->ifr_hwaddr.sa_family;
memcpy(ifl->lladdr, ifrp->ifr_hwaddr.sa_data, 14);
strncpy(ifl->name, ifrp->ifr_name, IFNAMSIZ);
p = strchr(ifl->name, ':');
if (p)
*p = 0;
if (verbose)
syslog(LOG_INFO, "link %s", ifl->name);
}
if (ioctl(fd, SIOCGIFNETMASK, ifrp)) {
syslog(LOG_ERR, "ioctl(SIOCGIFMASK): %m");
continue;
}
mask = ((struct sockaddr_in*)&ifrp->ifr_netmask)->sin_addr.s_addr;
if (ioctl(fd, SIOCGIFDSTADDR, ifrp)) {
syslog(LOG_ERR, "ioctl(SIOCGIFDSTADDR): %m");
continue;
}
prefix = ((struct sockaddr_in*)&ifrp->ifr_dstaddr)->sin_addr.s_addr;
for (ifa = ifl->ifa_list; ifa; ifa = ifa->next) {
if (ifa->local == addr &&
ifa->prefix == prefix &&
ifa->mask == mask)
break;
}
if (ifa == NULL) {
if (mask == 0 || prefix == 0)
continue;
ifa = (struct ifaddr*)malloc(sizeof(*ifa));
memset(ifa, 0, sizeof(*ifa));
ifa->local = addr;
ifa->prefix = prefix;
ifa->mask = mask;
ifa->next = ifl->ifa_list;
ifl->ifa_list = ifa;
if (verbose) {
int i;
__u32 m = ~0U;
for (i=32; i>=0; i--) {
if (htonl(m) == mask)
break;
m <<= 1;
}
if (addr == prefix) {
syslog(LOG_INFO, " addr %s/%d on %s\n",
inet_ntoa(*(struct in_addr*)&addr), i, ifl->name);
} else {
char tmpa[64];
sprintf(tmpa, "%s", inet_ntoa(*(struct in_addr*)&addr));
syslog(LOG_INFO, " addr %s %s/%d on %s\n", tmpa,
inet_ntoa(*(struct in_addr*)&prefix), i, ifl->name);
}
}
}
}
}
void configure(void)
{
load_if();
load_db();
}
int bootable(__u32 addr)
{
struct dirent *dent;
DIR *d;
char name[9];
sprintf(name, "%08X", (__u32)ntohl(addr));
d = opendir(tftp_dir);
if (d == NULL) {
syslog(LOG_ERR, "opendir: %m");
return 0;
}
while ((dent = readdir(d)) != NULL) {
if (strncmp(dent->d_name, name, 8) == 0)
break;
}
closedir(d);
return dent != NULL;
}
struct ifaddr *select_ipaddr(int ifindex, __u32 *sel_addr, __u32 **alist)
{
struct iflink *ifl;
struct ifaddr *ifa;
int retry = 0;
int i;
retry:
for (ifl=ifl_list; ifl; ifl=ifl->next)
if (ifl->index == ifindex)
break;
if (ifl == NULL && !retry) {
retry++;
load_if();
goto retry;
}
if (ifl == NULL)
return NULL;
for (i=0; alist[i]; i++) {
__u32 addr = *(alist[i]);
for (ifa=ifl->ifa_list; ifa; ifa=ifa->next) {
if (!((ifa->prefix^addr)&ifa->mask)) {
*sel_addr = addr;
return ifa;
}
}
if (ifa == NULL && retry==0) {
retry++;
load_if();
goto retry;
}
}
if (i==1 && allow_offlink) {
*sel_addr = *(alist[0]);
return ifl->ifa_list;
}
syslog(LOG_ERR, "Off-link request on %s", ifl->name);
return NULL;
}
struct rarp_map *rarp_lookup(int ifindex, int hatype,
int halen, unsigned char *lladdr)
{
struct rarp_map *r;
for (r=rarp_db; r; r=r->next) {
if (r->arp_type != hatype && r->arp_type != -1)
continue;
if (r->lladdr_len != halen)
continue;
if (r->ifindex != ifindex && r->ifindex != 0)
continue;
if (memcmp(r->lladdr, lladdr, halen) == 0)
break;
}
if (r == NULL) {
if (hatype == ARPHRD_ETHER && halen == 6) {
struct ifaddr *ifa;
struct hostent *hp;
char ename[256];
static struct rarp_map emap = {
NULL,
0,
ARPHRD_ETHER,
6,
};
if (ether_ntohost(ename, lladdr) != 0 ||
(hp = gethostbyname(ename)) == NULL) {
if (verbose)
syslog(LOG_INFO, "not found in /etc/ethers");
return NULL;
}
if (hp->h_addrtype != AF_INET) {
syslog(LOG_ERR, "no IP address");
return NULL;
}
ifa = select_ipaddr(ifindex, &emap.ipaddr, (__u32 **)hp->h_addr_list);
if (ifa) {
memcpy(emap.lladdr, lladdr, 6);
if (only_ethers || bootable(emap.ipaddr))
return &emap;
if (verbose)
syslog(LOG_INFO, "not bootable");
}
}
}
return r;
}
static int load_arp_bpflet(int fd)
{
static struct sock_filter insns[] = {
BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 6),
BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, ARPOP_RREQUEST, 0, 1),
BPF_STMT(BPF_RET|BPF_K, 1024),
BPF_STMT(BPF_RET|BPF_K, 0),
};
static struct sock_fprog filter = {
sizeof insns / sizeof(insns[0]),
insns
};
return setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter));
}
int put_mylladdr(unsigned char **ptr_p, int ifindex, int alen)
{
struct iflink *ifl;
for (ifl=ifl_list; ifl; ifl = ifl->next)
if (ifl->index == ifindex)
break;
if (ifl==NULL)
return -1;
memcpy(*ptr_p, ifl->lladdr, alen);
*ptr_p += alen;
return 0;
}
int put_myipaddr(unsigned char **ptr_p, int ifindex, __u32 hisipaddr)
{
__u32 laddr = 0;
struct iflink *ifl;
struct ifaddr *ifa;
for (ifl=ifl_list; ifl; ifl = ifl->next)
if (ifl->index == ifindex)
break;
if (ifl==NULL)
return -1;
for (ifa=ifl->ifa_list; ifa; ifa=ifa->next) {
if (!((ifa->prefix^hisipaddr)&ifa->mask)) {
laddr = ifa->local;
break;
}
}
memcpy(*ptr_p, &laddr, 4);
*ptr_p += 4;
return 0;
}
void arp_advise(int ifindex, unsigned char *lladdr, int lllen, __u32 ipaddr)
{
int fd;
struct arpreq req;
struct sockaddr_in *sin;
struct iflink *ifl;
for (ifl=ifl_list; ifl; ifl = ifl->next)
if (ifl->index == ifindex)
break;
if (ifl == NULL)
return;
fd = socket(AF_INET, SOCK_DGRAM, 0);
memset(&req, 0, sizeof(req));
req.arp_flags = ATF_COM;
sin = (struct sockaddr_in *)&req.arp_pa;
sin->sin_family = AF_INET;
sin->sin_addr.s_addr = ipaddr;
req.arp_ha.sa_family = ifl->hatype;
memcpy(req.arp_ha.sa_data, lladdr, lllen);
memcpy(req.arp_dev, ifl->name, IFNAMSIZ);
if (ioctl(fd, SIOCSARP, &req))
syslog(LOG_ERR, "SIOCSARP: %m");
close(fd);
}
void serve_it(int fd)
{
unsigned char buf[1024];
struct sockaddr_ll sll;
socklen_t sll_len = sizeof(sll);
struct arphdr *a = (struct arphdr*)buf;
struct rarp_map *rmap;
unsigned char *ptr;
int n;
n = recvfrom(fd, buf, sizeof(buf), MSG_DONTWAIT, (struct sockaddr*)&sll, &sll_len);
if (n<0) {
if (errno != EINTR && errno != EAGAIN)
syslog(LOG_ERR, "recvfrom: %m");
return;
}
/* Do not accept packets for other hosts and our own ones */
if (sll.sll_pkttype != PACKET_BROADCAST &&
sll.sll_pkttype != PACKET_MULTICAST &&
sll.sll_pkttype != PACKET_HOST)
return;
if (ifidx && sll.sll_ifindex != ifidx)
return;
if (n<sizeof(*a)) {
syslog(LOG_ERR, "truncated arp packet; len=%d", n);
return;
}
/* Accept only RARP requests */
if (a->ar_op != htons(ARPOP_RREQUEST))
return;
if (verbose) {
int i;
char tmpbuf[16*3];
char *ptr = tmpbuf;
for (i=0; i<sll.sll_halen; i++) {
if (i) {
sprintf(ptr, ":%02x", sll.sll_addr[i]);
ptr++;
} else
sprintf(ptr, "%02x", sll.sll_addr[i]);
ptr += 2;
}
syslog(LOG_INFO, "RARP request from %s on if%d", tmpbuf, sll.sll_ifindex);
}
/* Sanity checks */
/* 1. IP only -> pln==4 */
if (a->ar_pln != 4) {
syslog(LOG_ERR, "interesting rarp_req plen=%d", a->ar_pln);
return;
}
/* 2. ARP protocol must be IP */
if (a->ar_pro != htons(ETH_P_IP)) {
syslog(LOG_ERR, "rarp protocol is not IP %04x", ntohs(a->ar_pro));
return;
}
/* 3. ARP types must match */
if (htons(sll.sll_hatype) != a->ar_hrd) {
switch (sll.sll_hatype) {
case ARPHRD_FDDI:
if (a->ar_hrd == htons(ARPHRD_ETHER) ||
a->ar_hrd == htons(ARPHRD_IEEE802))
break;
default:
syslog(LOG_ERR, "rarp htype mismatch");
return;
}
}
/* 3. LL address lengths must be equal */
if (a->ar_hln != sll.sll_halen) {
syslog(LOG_ERR, "rarp hlen mismatch");
return;
}
/* 4. Check packet length */
if (sizeof(*a) + 2*4 + 2*a->ar_hln > n) {
syslog(LOG_ERR, "truncated rarp request; len=%d", n);
return;
}
/* 5. Silly check: if this guy set different source
addresses in MAC header and in ARP, he is insane
*/
if (memcmp(sll.sll_addr, a+1, sll.sll_halen)) {
syslog(LOG_ERR, "this guy set different his lladdrs in arp and header");
return;
}
/* End of sanity checks */
/* Lookup requested target in our database */
rmap = rarp_lookup(sll.sll_ifindex, sll.sll_hatype,
sll.sll_halen, (unsigned char*)(a+1) + sll.sll_halen + 4);
if (rmap == NULL)
return;
/* Prepare reply. It is almost ready, we only
replace ARP packet type, put our lladdr and
IP address to source fileds,
and fill target IP address.
*/
a->ar_op = htons(ARPOP_RREPLY);
ptr = (unsigned char*)(a+1);
if (put_mylladdr(&ptr, sll.sll_ifindex, rmap->lladdr_len))
return;
if (put_myipaddr(&ptr, sll.sll_ifindex, rmap->ipaddr))
return;
/* It is already filled */
ptr += rmap->lladdr_len;
memcpy(ptr, &rmap->ipaddr, 4);
ptr += 4;
/* Update our ARP cache. Probably, this guy
will not able to make ARP (if it is broken)
*/
arp_advise(sll.sll_ifindex, rmap->lladdr, rmap->lladdr_len, rmap->ipaddr);
/* Sendto is blocking, but with 5sec timeout */
alarm(5);
sendto(fd, buf, ptr - buf, 0, (struct sockaddr*)&sll, sizeof(sll));
alarm(0);
}
void catch_signal(int sig, void (*handler)(int))
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handler;
#ifdef SA_INTERRUPT
sa.sa_flags = SA_INTERRUPT;
#endif
sigaction(sig, &sa, NULL);
}
void sig_alarm(int signo)
{
}
void sig_hup(int signo)
{
do_reload = 1;
}
int main(int argc, char **argv)
{
struct pollfd pset[2];
int psize;
int opt;
opterr = 0;
while ((opt = getopt(argc, argv, "aAb:dvoe")) != EOF) {
switch (opt) {
case 'a':
++all_ifaces;
break;
case 'A':
++listen_arp;
break;
case 'd':
++debug;
break;
case 'v':
++verbose;
break;
case 'o':
++allow_offlink;
break;
case 'e':
++only_ethers;
break;
case 'b':
tftp_dir = optarg;
break;
default:
usage();
}
}
if (argc > optind) {
if (argc > optind+1)
usage();
ifname = argv[optind];
}
psize = 1;
pset[0].fd = socket(PF_PACKET, SOCK_DGRAM, 0);
if (ifname) {
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
if (ioctl(pset[0].fd, SIOCGIFINDEX, &ifr)) {
perror("ioctl(SIOCGIFINDEX)");
usage();
}
ifidx = ifr.ifr_ifindex;
}
pset[1].fd = -1;
if (listen_arp) {
pset[1].fd = socket(PF_PACKET, SOCK_DGRAM, 0);
if (pset[1].fd >= 0) {
load_arp_bpflet(pset[1].fd);
psize = 1;
}
}
if (pset[1].fd >= 0) {
struct sockaddr_ll sll;
memset(&sll, 0, sizeof(sll));
sll.sll_family = AF_PACKET;
sll.sll_protocol = htons(ETH_P_ARP);
sll.sll_ifindex = all_ifaces ? 0 : ifidx;
if (bind(pset[1].fd, (struct sockaddr*)&sll, sizeof(sll)) < 0) {
close(pset[1].fd);
pset[1].fd = -1;
psize = 1;
}
}
if (pset[0].fd >= 0) {
struct sockaddr_ll sll;
memset(&sll, 0, sizeof(sll));
sll.sll_family = AF_PACKET;
sll.sll_protocol = htons(ETH_P_RARP);
sll.sll_ifindex = all_ifaces ? 0 : ifidx;
if (bind(pset[0].fd, (struct sockaddr*)&sll, sizeof(sll)) < 0) {
close(pset[0].fd);
pset[0].fd = -1;
}
}
if (pset[0].fd < 0) {
pset[0] = pset[1];
psize--;
}
if (psize == 0) {
fprintf(stderr, "failed to bind any socket. Aborting.\n");
exit(1);
}
if (!debug) {
int fd;
pid_t pid = fork();
if (pid > 0)
exit(0);
else if (pid == -1) {
perror("rarpd: fork");
exit(1);
}
if (chdir("/") < 0) {
perror("rarpd: chdir");
exit(1);
}
fd = open("/dev/null", O_RDWR);
if (fd >= 0) {
dup2(fd, 0);
dup2(fd, 1);
dup2(fd, 2);
if (fd > 2)
close(fd);
}
setsid();
}
openlog("rarpd", LOG_PID | LOG_CONS, LOG_DAEMON);
catch_signal(SIGALRM, sig_alarm);
catch_signal(SIGHUP, sig_hup);
for (;;) {
int i;
if (do_reload) {
configure();
do_reload = 0;
}
#define EVENTS (POLLIN|POLLPRI|POLLERR|POLLHUP)
pset[0].events = EVENTS;
pset[0].revents = 0;
pset[1].events = EVENTS;
pset[1].revents = 0;
i = poll(pset, psize, -1);
if (i <= 0) {
if (errno != EINTR && i<0) {
syslog(LOG_ERR, "poll returned some crap: %m\n");
sleep(10);
}
continue;
}
for (i=0; i<psize; i++) {
if (pset[i].revents&EVENTS)
serve_it(pset[i].fd);
}
}
}