1/*
2 * Copyright (c) 1984, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Sun Microsystems, Inc.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 * 4. Neither the name of the University nor the names of its contributors
17 *    may be used to endorse or promote products derived from this software
18 *    without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33#if 0
34#ifndef lint
35static char const copyright[] =
36"@(#) Copyright (c) 1984, 1993\n\
37	The Regents of the University of California.  All rights reserved.\n";
38#endif /* not lint */
39
40#ifndef lint
41static char const sccsid[] = "@(#)from: arp.c	8.2 (Berkeley) 1/2/94";
42#endif /* not lint */
43#endif
44#include <sys/cdefs.h>
45__FBSDID("$FreeBSD: releng/11.0/usr.sbin/arp/arp.c 288297 2015-09-27 04:54:29Z melifaro $");
46
47/*
48 * arp - display, set, and delete arp table entries
49 */
50
51
52#include <sys/param.h>
53#include <sys/file.h>
54#include <sys/socket.h>
55#include <sys/sockio.h>
56#include <sys/sysctl.h>
57#include <sys/ioctl.h>
58#include <sys/time.h>
59
60#include <net/if.h>
61#include <net/if_dl.h>
62#include <net/if_types.h>
63#include <net/route.h>
64#include <net/iso88025.h>
65
66#include <netinet/in.h>
67#include <netinet/if_ether.h>
68
69#include <arpa/inet.h>
70
71#include <ctype.h>
72#include <err.h>
73#include <errno.h>
74#include <netdb.h>
75#include <nlist.h>
76#include <paths.h>
77#include <stdio.h>
78#include <stdlib.h>
79#include <string.h>
80#include <strings.h>
81#include <unistd.h>
82
83typedef void (action_fn)(struct sockaddr_dl *sdl,
84	struct sockaddr_in *s_in, struct rt_msghdr *rtm);
85
86static int search(u_long addr, action_fn *action);
87static action_fn print_entry;
88static action_fn nuke_entry;
89
90static int delete(char *host);
91static void usage(void);
92static int set(int argc, char **argv);
93static int get(char *host);
94static int file(char *name);
95static struct rt_msghdr *rtmsg(int cmd,
96    struct sockaddr_in *dst, struct sockaddr_dl *sdl);
97static int get_ether_addr(in_addr_t ipaddr, struct ether_addr *hwaddr);
98static struct sockaddr_in *getaddr(char *host);
99static int valid_type(int type);
100
101static int nflag;	/* no reverse dns lookups */
102static char *rifname;
103
104static time_t	expire_time;
105static int	flags, doing_proxy;
106
107struct if_nameindex *ifnameindex;
108
109/* which function we're supposed to do */
110#define F_GET		1
111#define F_SET		2
112#define F_FILESET	3
113#define F_REPLACE	4
114#define F_DELETE	5
115
116#define SETFUNC(f)	{ if (func) usage(); func = (f); }
117
118int
119main(int argc, char *argv[])
120{
121	int ch, func = 0;
122	int rtn = 0;
123	int aflag = 0;	/* do it for all entries */
124
125	while ((ch = getopt(argc, argv, "andfsSi:")) != -1)
126		switch(ch) {
127		case 'a':
128			aflag = 1;
129			break;
130		case 'd':
131			SETFUNC(F_DELETE);
132			break;
133		case 'n':
134			nflag = 1;
135			break;
136		case 'S':
137			SETFUNC(F_REPLACE);
138			break;
139		case 's':
140			SETFUNC(F_SET);
141			break;
142		case 'f' :
143			SETFUNC(F_FILESET);
144			break;
145		case 'i':
146			rifname = optarg;
147			break;
148		case '?':
149		default:
150			usage();
151		}
152	argc -= optind;
153	argv += optind;
154
155	if (!func)
156		func = F_GET;
157	if (rifname) {
158		if (func != F_GET && !(func == F_DELETE && aflag))
159			errx(1, "-i not applicable to this operation");
160		if (if_nametoindex(rifname) == 0) {
161			if (errno == ENXIO)
162				errx(1, "interface %s does not exist", rifname);
163			else
164				err(1, "if_nametoindex(%s)", rifname);
165		}
166	}
167	switch (func) {
168	case F_GET:
169		if (aflag) {
170			if (argc != 0)
171				usage();
172			search(0, print_entry);
173		} else {
174			if (argc != 1)
175				usage();
176			rtn = get(argv[0]);
177		}
178		break;
179	case F_SET:
180	case F_REPLACE:
181		if (argc < 2 || argc > 6)
182			usage();
183		if (func == F_REPLACE)
184			(void)delete(argv[0]);
185		rtn = set(argc, argv) ? 1 : 0;
186		break;
187	case F_DELETE:
188		if (aflag) {
189			if (argc != 0)
190				usage();
191			search(0, nuke_entry);
192		} else {
193			if (argc != 1)
194				usage();
195			rtn = delete(argv[0]);
196		}
197		break;
198	case F_FILESET:
199		if (argc != 1)
200			usage();
201		rtn = file(argv[0]);
202		break;
203	}
204
205	if (ifnameindex != NULL)
206		if_freenameindex(ifnameindex);
207
208	return (rtn);
209}
210
211/*
212 * Process a file to set standard arp entries
213 */
214static int
215file(char *name)
216{
217	FILE *fp;
218	int i, retval;
219	char line[100], arg[5][50], *args[5], *p;
220
221	if ((fp = fopen(name, "r")) == NULL)
222		err(1, "cannot open %s", name);
223	args[0] = &arg[0][0];
224	args[1] = &arg[1][0];
225	args[2] = &arg[2][0];
226	args[3] = &arg[3][0];
227	args[4] = &arg[4][0];
228	retval = 0;
229	while(fgets(line, sizeof(line), fp) != NULL) {
230		if ((p = strchr(line, '#')) != NULL)
231			*p = '\0';
232		for (p = line; isblank(*p); p++);
233		if (*p == '\n' || *p == '\0')
234			continue;
235		i = sscanf(p, "%49s %49s %49s %49s %49s", arg[0], arg[1],
236		    arg[2], arg[3], arg[4]);
237		if (i < 2) {
238			warnx("bad line: %s", line);
239			retval = 1;
240			continue;
241		}
242		if (set(i, args))
243			retval = 1;
244	}
245	fclose(fp);
246	return (retval);
247}
248
249/*
250 * Given a hostname, fills up a (static) struct sockaddr_in with
251 * the address of the host and returns a pointer to the
252 * structure.
253 */
254static struct sockaddr_in *
255getaddr(char *host)
256{
257	struct hostent *hp;
258	static struct sockaddr_in reply;
259
260	bzero(&reply, sizeof(reply));
261	reply.sin_len = sizeof(reply);
262	reply.sin_family = AF_INET;
263	reply.sin_addr.s_addr = inet_addr(host);
264	if (reply.sin_addr.s_addr == INADDR_NONE) {
265		if (!(hp = gethostbyname(host))) {
266			warnx("%s: %s", host, hstrerror(h_errno));
267			return (NULL);
268		}
269		bcopy((char *)hp->h_addr, (char *)&reply.sin_addr,
270			sizeof reply.sin_addr);
271	}
272	return (&reply);
273}
274
275/*
276 * Returns true if the type is a valid one for ARP.
277 */
278static int
279valid_type(int type)
280{
281
282	switch (type) {
283	case IFT_ETHER:
284	case IFT_FDDI:
285	case IFT_INFINIBAND:
286	case IFT_ISO88023:
287	case IFT_ISO88024:
288	case IFT_ISO88025:
289	case IFT_L2VLAN:
290	case IFT_BRIDGE:
291		return (1);
292	default:
293		return (0);
294	}
295}
296
297/*
298 * Set an individual arp entry
299 */
300static int
301set(int argc, char **argv)
302{
303	struct sockaddr_in *addr;
304	struct sockaddr_in *dst;	/* what are we looking for */
305	struct sockaddr_dl *sdl;
306	struct rt_msghdr *rtm;
307	struct ether_addr *ea;
308	char *host = argv[0], *eaddr = argv[1];
309	struct sockaddr_dl sdl_m;
310
311	argc -= 2;
312	argv += 2;
313
314	bzero(&sdl_m, sizeof(sdl_m));
315	sdl_m.sdl_len = sizeof(sdl_m);
316	sdl_m.sdl_family = AF_LINK;
317
318	dst = getaddr(host);
319	if (dst == NULL)
320		return (1);
321	doing_proxy = flags = expire_time = 0;
322	while (argc-- > 0) {
323		if (strncmp(argv[0], "temp", 4) == 0) {
324			struct timespec tp;
325			int max_age;
326			size_t len = sizeof(max_age);
327
328			clock_gettime(CLOCK_MONOTONIC, &tp);
329			if (sysctlbyname("net.link.ether.inet.max_age",
330			    &max_age, &len, NULL, 0) != 0)
331				err(1, "sysctlbyname");
332			expire_time = tp.tv_sec + max_age;
333		} else if (strncmp(argv[0], "pub", 3) == 0) {
334			flags |= RTF_ANNOUNCE;
335			doing_proxy = 1;
336			if (argc && strncmp(argv[1], "only", 3) == 0) {
337				/*
338				 * Compatibility: in pre FreeBSD 8 times
339				 * the "only" keyword used to mean that
340				 * an ARP entry should be announced, but
341				 * not installed into routing table.
342				 */
343				argc--; argv++;
344			}
345		} else if (strncmp(argv[0], "blackhole", 9) == 0) {
346			if (flags & RTF_REJECT) {
347				printf("Choose one of blackhole or reject, not both.\n");
348			}
349			flags |= RTF_BLACKHOLE;
350		} else if (strncmp(argv[0], "reject", 6) == 0) {
351			if (flags & RTF_BLACKHOLE) {
352				printf("Choose one of blackhole or reject, not both.\n");
353			}
354			flags |= RTF_REJECT;
355		} else if (strncmp(argv[0], "trail", 5) == 0) {
356			/* XXX deprecated and undocumented feature */
357			printf("%s: Sending trailers is no longer supported\n",
358				host);
359		}
360		argv++;
361	}
362	ea = (struct ether_addr *)LLADDR(&sdl_m);
363	if (doing_proxy && !strcmp(eaddr, "auto")) {
364		if (!get_ether_addr(dst->sin_addr.s_addr, ea)) {
365			printf("no interface found for %s\n",
366			       inet_ntoa(dst->sin_addr));
367			return (1);
368		}
369		sdl_m.sdl_alen = ETHER_ADDR_LEN;
370	} else {
371		struct ether_addr *ea1 = ether_aton(eaddr);
372
373		if (ea1 == NULL) {
374			warnx("invalid Ethernet address '%s'", eaddr);
375			return (1);
376		} else {
377			*ea = *ea1;
378			sdl_m.sdl_alen = ETHER_ADDR_LEN;
379		}
380	}
381
382	/*
383	 * In the case a proxy-arp entry is being added for
384	 * a remote end point, the RTF_ANNOUNCE flag in the
385	 * RTM_GET command is an indication to the kernel
386	 * routing code that the interface associated with
387	 * the prefix route covering the local end of the
388	 * PPP link should be returned, on which ARP applies.
389	 */
390	rtm = rtmsg(RTM_GET, dst, &sdl_m);
391	if (rtm == NULL) {
392		warn("%s", host);
393		return (1);
394	}
395	addr = (struct sockaddr_in *)(rtm + 1);
396	sdl = (struct sockaddr_dl *)(SA_SIZE(addr) + (char *)addr);
397
398	if ((sdl->sdl_family != AF_LINK) ||
399	    (rtm->rtm_flags & RTF_GATEWAY) ||
400	    !valid_type(sdl->sdl_type)) {
401		printf("cannot intuit interface index and type for %s\n", host);
402		return (1);
403	}
404	sdl_m.sdl_type = sdl->sdl_type;
405	sdl_m.sdl_index = sdl->sdl_index;
406	return (rtmsg(RTM_ADD, dst, &sdl_m) == NULL);
407}
408
409/*
410 * Display an individual arp entry
411 */
412static int
413get(char *host)
414{
415	struct sockaddr_in *addr;
416
417	addr = getaddr(host);
418	if (addr == NULL)
419		return (1);
420	if (0 == search(addr->sin_addr.s_addr, print_entry)) {
421		printf("%s (%s) -- no entry",
422		    host, inet_ntoa(addr->sin_addr));
423		if (rifname)
424			printf(" on %s", rifname);
425		printf("\n");
426		return (1);
427	}
428	return (0);
429}
430
431/*
432 * Delete an arp entry
433 */
434static int
435delete(char *host)
436{
437	struct sockaddr_in *addr, *dst;
438	struct rt_msghdr *rtm;
439	struct sockaddr_dl *sdl;
440	struct sockaddr_dl sdl_m;
441
442	dst = getaddr(host);
443	if (dst == NULL)
444		return (1);
445
446	/*
447	 * Perform a regular entry delete first.
448	 */
449	flags &= ~RTF_ANNOUNCE;
450
451	/*
452	 * setup the data structure to notify the kernel
453	 * it is the ARP entry the RTM_GET is interested
454	 * in
455	 */
456	bzero(&sdl_m, sizeof(sdl_m));
457	sdl_m.sdl_len = sizeof(sdl_m);
458	sdl_m.sdl_family = AF_LINK;
459
460	for (;;) {	/* try twice */
461		rtm = rtmsg(RTM_GET, dst, &sdl_m);
462		if (rtm == NULL) {
463			warn("%s", host);
464			return (1);
465		}
466		addr = (struct sockaddr_in *)(rtm + 1);
467		sdl = (struct sockaddr_dl *)(SA_SIZE(addr) + (char *)addr);
468
469		/*
470		 * With the new L2/L3 restructure, the route
471		 * returned is a prefix route. The important
472		 * piece of information from the previous
473		 * RTM_GET is the interface index. In the
474		 * case of ECMP, the kernel will traverse
475		 * the route group for the given entry.
476		 */
477		if (sdl->sdl_family == AF_LINK &&
478		    !(rtm->rtm_flags & RTF_GATEWAY) &&
479		    valid_type(sdl->sdl_type) ) {
480			addr->sin_addr.s_addr = dst->sin_addr.s_addr;
481			break;
482		}
483
484		/*
485		 * Regualar entry delete failed, now check if there
486		 * is a proxy-arp entry to remove.
487		 */
488		if (flags & RTF_ANNOUNCE) {
489			fprintf(stderr, "delete: cannot locate %s\n",host);
490			return (1);
491		}
492
493		flags |= RTF_ANNOUNCE;
494	}
495	rtm->rtm_flags |= RTF_LLDATA;
496	if (rtmsg(RTM_DELETE, dst, NULL) != NULL) {
497		printf("%s (%s) deleted\n", host, inet_ntoa(addr->sin_addr));
498		return (0);
499	}
500	return (1);
501}
502
503
504/*
505 * Search the arp table and do some action on matching entries
506 */
507static int
508search(u_long addr, action_fn *action)
509{
510	int mib[6];
511	size_t needed;
512	char *lim, *buf, *next;
513	struct rt_msghdr *rtm;
514	struct sockaddr_in *sin2;
515	struct sockaddr_dl *sdl;
516	char ifname[IF_NAMESIZE];
517	int st, found_entry = 0;
518
519	mib[0] = CTL_NET;
520	mib[1] = PF_ROUTE;
521	mib[2] = 0;
522	mib[3] = AF_INET;
523	mib[4] = NET_RT_FLAGS;
524#ifdef RTF_LLINFO
525	mib[5] = RTF_LLINFO;
526#else
527	mib[5] = 0;
528#endif
529	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
530		err(1, "route-sysctl-estimate");
531	if (needed == 0)	/* empty table */
532		return 0;
533	buf = NULL;
534	for (;;) {
535		buf = reallocf(buf, needed);
536		if (buf == NULL)
537			errx(1, "could not reallocate memory");
538		st = sysctl(mib, 6, buf, &needed, NULL, 0);
539		if (st == 0 || errno != ENOMEM)
540			break;
541		needed += needed / 8;
542	}
543	if (st == -1)
544		err(1, "actual retrieval of routing table");
545	lim = buf + needed;
546	for (next = buf; next < lim; next += rtm->rtm_msglen) {
547		rtm = (struct rt_msghdr *)next;
548		sin2 = (struct sockaddr_in *)(rtm + 1);
549		sdl = (struct sockaddr_dl *)((char *)sin2 + SA_SIZE(sin2));
550		if (rifname && if_indextoname(sdl->sdl_index, ifname) &&
551		    strcmp(ifname, rifname))
552			continue;
553		if (addr) {
554			if (addr != sin2->sin_addr.s_addr)
555				continue;
556			found_entry = 1;
557		}
558		(*action)(sdl, sin2, rtm);
559	}
560	free(buf);
561	return (found_entry);
562}
563
564/*
565 * Display an arp entry
566 */
567
568static void
569print_entry(struct sockaddr_dl *sdl,
570	struct sockaddr_in *addr, struct rt_msghdr *rtm)
571{
572	const char *host;
573	struct hostent *hp;
574	struct iso88025_sockaddr_dl_data *trld;
575	struct if_nameindex *p;
576	int seg;
577
578	if (ifnameindex == NULL)
579		if ((ifnameindex = if_nameindex()) == NULL)
580			err(1, "cannot retrieve interface names");
581
582	if (nflag == 0)
583		hp = gethostbyaddr((caddr_t)&(addr->sin_addr),
584		    sizeof addr->sin_addr, AF_INET);
585	else
586		hp = 0;
587	if (hp)
588		host = hp->h_name;
589	else {
590		host = "?";
591		if (h_errno == TRY_AGAIN)
592			nflag = 1;
593	}
594	printf("%s (%s) at ", host, inet_ntoa(addr->sin_addr));
595	if (sdl->sdl_alen) {
596		if ((sdl->sdl_type == IFT_ETHER ||
597		    sdl->sdl_type == IFT_L2VLAN ||
598		    sdl->sdl_type == IFT_BRIDGE) &&
599		    sdl->sdl_alen == ETHER_ADDR_LEN)
600			printf("%s", ether_ntoa((struct ether_addr *)LLADDR(sdl)));
601		else {
602			int n = sdl->sdl_nlen > 0 ? sdl->sdl_nlen + 1 : 0;
603
604			printf("%s", link_ntoa(sdl) + n);
605		}
606	} else
607		printf("(incomplete)");
608
609	for (p = ifnameindex; p && ifnameindex->if_index &&
610		 ifnameindex->if_name; p++) {
611		if (p->if_index == sdl->sdl_index) {
612			printf(" on %s", p->if_name);
613			break;
614		}
615	}
616
617	if (rtm->rtm_rmx.rmx_expire == 0)
618		printf(" permanent");
619	else {
620		static struct timespec tp;
621		if (tp.tv_sec == 0)
622			clock_gettime(CLOCK_MONOTONIC, &tp);
623		if ((expire_time = rtm->rtm_rmx.rmx_expire - tp.tv_sec) > 0)
624			printf(" expires in %d seconds", (int)expire_time);
625		else
626			printf(" expired");
627	}
628	if (rtm->rtm_flags & RTF_ANNOUNCE)
629		printf(" published");
630	switch(sdl->sdl_type) {
631	case IFT_ETHER:
632                printf(" [ethernet]");
633                break;
634	case IFT_ISO88025:
635                printf(" [token-ring]");
636		trld = SDL_ISO88025(sdl);
637		if (trld->trld_rcf != 0) {
638			printf(" rt=%x", ntohs(trld->trld_rcf));
639			for (seg = 0;
640			     seg < ((TR_RCF_RIFLEN(trld->trld_rcf) - 2 ) / 2);
641			     seg++)
642				printf(":%x", ntohs(*(trld->trld_route[seg])));
643		}
644                break;
645	case IFT_FDDI:
646                printf(" [fddi]");
647                break;
648	case IFT_ATM:
649                printf(" [atm]");
650                break;
651	case IFT_L2VLAN:
652		printf(" [vlan]");
653		break;
654	case IFT_IEEE1394:
655                printf(" [firewire]");
656                break;
657	case IFT_BRIDGE:
658		printf(" [bridge]");
659		break;
660	case IFT_INFINIBAND:
661		printf(" [infiniband]");
662		break;
663	default:
664		break;
665        }
666
667	printf("\n");
668
669}
670
671/*
672 * Nuke an arp entry
673 */
674static void
675nuke_entry(struct sockaddr_dl *sdl __unused,
676	struct sockaddr_in *addr, struct rt_msghdr *rtm)
677{
678	char ip[20];
679
680	if (rtm->rtm_flags & RTF_PINNED)
681		return;
682
683	snprintf(ip, sizeof(ip), "%s", inet_ntoa(addr->sin_addr));
684	delete(ip);
685}
686
687static void
688usage(void)
689{
690	fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
691		"usage: arp [-n] [-i interface] hostname",
692		"       arp [-n] [-i interface] -a",
693		"       arp -d hostname [pub]",
694		"       arp -d [-i interface] -a",
695		"       arp -s hostname ether_addr [temp] [reject | blackhole] [pub [only]]",
696		"       arp -S hostname ether_addr [temp] [reject | blackhole] [pub [only]]",
697		"       arp -f filename");
698	exit(1);
699}
700
701static struct rt_msghdr *
702rtmsg(int cmd, struct sockaddr_in *dst, struct sockaddr_dl *sdl)
703{
704	static int seq;
705	int rlen;
706	int l;
707	struct sockaddr_in so_mask, *som = &so_mask;
708	static int s = -1;
709	static pid_t pid;
710
711	static struct	{
712		struct	rt_msghdr m_rtm;
713		char	m_space[512];
714	}	m_rtmsg;
715
716	struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
717	char *cp = m_rtmsg.m_space;
718
719	if (s < 0) {	/* first time: open socket, get pid */
720		s = socket(PF_ROUTE, SOCK_RAW, 0);
721		if (s < 0)
722			err(1, "socket");
723		pid = getpid();
724	}
725	bzero(&so_mask, sizeof(so_mask));
726	so_mask.sin_len = 8;
727	so_mask.sin_addr.s_addr = 0xffffffff;
728
729	errno = 0;
730	/*
731	 * XXX RTM_DELETE relies on a previous RTM_GET to fill the buffer
732	 * appropriately.
733	 */
734	if (cmd == RTM_DELETE)
735		goto doit;
736	bzero((char *)&m_rtmsg, sizeof(m_rtmsg));
737	rtm->rtm_flags = flags;
738	rtm->rtm_version = RTM_VERSION;
739
740	switch (cmd) {
741	default:
742		errx(1, "internal wrong cmd");
743	case RTM_ADD:
744		rtm->rtm_addrs |= RTA_GATEWAY;
745		rtm->rtm_rmx.rmx_expire = expire_time;
746		rtm->rtm_inits = RTV_EXPIRE;
747		rtm->rtm_flags |= (RTF_HOST | RTF_STATIC | RTF_LLDATA);
748		if (doing_proxy) {
749			rtm->rtm_addrs |= RTA_NETMASK;
750			rtm->rtm_flags &= ~RTF_HOST;
751		}
752		/* FALLTHROUGH */
753	case RTM_GET:
754		rtm->rtm_addrs |= RTA_DST;
755	}
756#define NEXTADDR(w, s)					   \
757	do {						   \
758		if ((s) != NULL && rtm->rtm_addrs & (w)) { \
759			bcopy((s), cp, sizeof(*(s)));	   \
760			cp += SA_SIZE(s);		   \
761		}					   \
762	} while (0)
763
764	NEXTADDR(RTA_DST, dst);
765	NEXTADDR(RTA_GATEWAY, sdl);
766	NEXTADDR(RTA_NETMASK, som);
767
768	rtm->rtm_msglen = cp - (char *)&m_rtmsg;
769doit:
770	l = rtm->rtm_msglen;
771	rtm->rtm_seq = ++seq;
772	rtm->rtm_type = cmd;
773	if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
774		if (errno != ESRCH || cmd != RTM_DELETE) {
775			warn("writing to routing socket");
776			return (NULL);
777		}
778	}
779	do {
780		l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
781	} while (l > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
782	if (l < 0)
783		warn("read from routing socket");
784	return (rtm);
785}
786
787/*
788 * get_ether_addr - get the hardware address of an interface on the
789 * the same subnet as ipaddr.
790 */
791#define MAX_IFS		32
792
793static int
794get_ether_addr(in_addr_t ipaddr, struct ether_addr *hwaddr)
795{
796	struct ifreq *ifr, *ifend, *ifp;
797	in_addr_t ina, mask;
798	struct sockaddr_dl *dla;
799	struct ifreq ifreq;
800	struct ifconf ifc;
801	struct ifreq ifs[MAX_IFS];
802	int sock;
803	int retval = 0;
804
805	sock = socket(AF_INET, SOCK_DGRAM, 0);
806	if (sock < 0)
807		err(1, "socket");
808
809	ifc.ifc_len = sizeof(ifs);
810	ifc.ifc_req = ifs;
811	if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) {
812		warnx("ioctl(SIOCGIFCONF)");
813		goto done;
814	}
815
816#define NEXTIFR(i)						\
817    ((struct ifreq *)((char *)&(i)->ifr_addr			\
818	+ MAX((i)->ifr_addr.sa_len, sizeof((i)->ifr_addr))) )
819
820	/*
821	 * Scan through looking for an interface with an Internet
822	 * address on the same subnet as `ipaddr'.
823	 */
824	ifend = (struct ifreq *)(ifc.ifc_buf + ifc.ifc_len);
825	for (ifr = ifc.ifc_req; ifr < ifend; ifr = NEXTIFR(ifr) ) {
826		if (ifr->ifr_addr.sa_family != AF_INET)
827			continue;
828		strncpy(ifreq.ifr_name, ifr->ifr_name,
829			sizeof(ifreq.ifr_name));
830		ifreq.ifr_addr = ifr->ifr_addr;
831		/*
832		 * Check that the interface is up,
833		 * and not point-to-point or loopback.
834		 */
835		if (ioctl(sock, SIOCGIFFLAGS, &ifreq) < 0)
836			continue;
837		if ((ifreq.ifr_flags &
838		     (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|
839				IFF_LOOPBACK|IFF_NOARP))
840		     != (IFF_UP|IFF_BROADCAST))
841			continue;
842		/*
843		 * Get its netmask and check that it's on
844		 * the right subnet.
845		 */
846		if (ioctl(sock, SIOCGIFNETMASK, &ifreq) < 0)
847			continue;
848		mask = ((struct sockaddr_in *)
849			&ifreq.ifr_addr)->sin_addr.s_addr;
850		ina = ((struct sockaddr_in *)
851			&ifr->ifr_addr)->sin_addr.s_addr;
852		if ((ipaddr & mask) == (ina & mask))
853			break; /* ok, we got it! */
854	}
855
856	if (ifr >= ifend)
857		goto done;
858
859	/*
860	 * Now scan through again looking for a link-level address
861	 * for this interface.
862	 */
863	ifp = ifr;
864	for (ifr = ifc.ifc_req; ifr < ifend; ifr = NEXTIFR(ifr))
865		if (strcmp(ifp->ifr_name, ifr->ifr_name) == 0 &&
866		    ifr->ifr_addr.sa_family == AF_LINK)
867			break;
868	if (ifr >= ifend)
869		goto done;
870	/*
871	 * Found the link-level address - copy it out
872	 */
873	dla = (struct sockaddr_dl *) &ifr->ifr_addr;
874	memcpy(hwaddr,  LLADDR(dla), dla->sdl_alen);
875	printf("using interface %s for proxy with address ",
876		ifp->ifr_name);
877	printf("%s\n", ether_ntoa(hwaddr));
878	retval = dla->sdl_alen;
879done:
880	close(sock);
881	return (retval);
882}
883