/*

 * 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 <errno.h>

#include <fcntl.h>

#include <signal.h>

#include <poll.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#include <linux/if.h>

#include <linux/if_arp.h>

#include <linux/if_packet.h>

#include <linux/filter.h>

#include <sys/ioctl.h>

#include <sys/socket.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 = (char *)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

		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

			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

			if (pset[i].revents&EVENTS)

				serve_it(pset[i].fd);

		}

	}

}