]> git.saurik.com Git - apple/network_cmds.git/blob - arp.tproj/arp.c
projects / apple / network_cmds.git / blob
? search:


665aa94d140b5a646a2632b80ba5be27e4eb9ae0
[apple/network_cmds.git] / arp.tproj / arp.c
1 /*
2 * Copyright (c) 2003-2011 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29 /*
30 * Copyright (c) 1984, 1993
31 * The Regents of the University of California. All rights reserved.
32 *
33 * This code is derived from software contributed to Berkeley by
34 * Sun Microsystems, Inc.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 4. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 */
60
61 #if 0
62 #ifndef lint
63 static char const copyright[] =
64 "@(#) Copyright (c) 1984, 1993\n\
65 The Regents of the University of California. All rights reserved.\n";
66 #endif /* not lint */
67
68 #ifndef lint
69 static char const sccsid[] = "@(#)from: arp.c 8.2 (Berkeley) 1/2/94";
70 #endif /* not lint */
71 #include <sys/cdefs.h>
72 __FBSDID("$FreeBSD: src/usr.sbin/arp/arp.c,v 1.65.2.1 2008/04/25 16:38:14 sam Exp $");
73 #endif
74
75 /*
76 * arp - display, set, and delete arp table entries
77 */
78
79
80 #include <sys/param.h>
81 #include <sys/file.h>
82 #include <sys/socket.h>
83 #include <sys/sockio.h>
84 #include <sys/sysctl.h>
85 #include <sys/ioctl.h>
86 #include <sys/time.h>
87
88 #include <net/if.h>
89 #include <net/if_dl.h>
90 #include <net/if_types.h>
91 #include <net/route.h>
92 #if 0
93 #include <net/iso88025.h>
94 #endif
95
96 #include <netinet/in.h>
97 #include <netinet/if_ether.h>
98
99 #include <arpa/inet.h>
100
101 #include <ctype.h>
102 #include <err.h>
103 #include <errno.h>
104 #include <netdb.h>
105 #include <nlist.h>
106 #include <paths.h>
107 #include <stdio.h>
108 #include <stdlib.h>
109 #include <string.h>
110 #include <strings.h>
111 #include <unistd.h>
112
113 typedef void (action_fn)(struct sockaddr_dl *sdl,
114 struct sockaddr_inarp *s_in, struct rt_msghdr *rtm);
115 typedef void (action_ext_fn)(struct sockaddr_dl *sdl,
116 struct sockaddr_inarp *s_in, struct rt_msghdr_ext *rtm);
117
118 static int search(in_addr_t addr, action_fn *action);
119 static int search_ext(in_addr_t addr, action_ext_fn *action);
120 static action_fn print_entry;
121 static action_fn nuke_entry;
122 static action_ext_fn print_entry_ext;
123
124 static char *print_lladdr(struct sockaddr_dl *);
125 static int delete(char *host, int do_proxy);
126 static void usage(void);
127 static int set(int argc, char **argv);
128 static int get(char *host);
129 static int file(char *name);
130 static struct rt_msghdr *rtmsg(int cmd,
131 struct sockaddr_inarp *dst, struct sockaddr_dl *sdl);
132 static int get_ether_addr(in_addr_t ipaddr, struct ether_addr *hwaddr);
133 static struct sockaddr_inarp *getaddr(char *host);
134 static int valid_type(int type);
135 static char *sec2str(time_t);
136
137 static int nflag; /* no reverse dns lookups */
138 static char *rifname;
139
140 static int expire_time, flags, doing_proxy, proxy_only;
141
142 static char *boundif = NULL;
143 static unsigned int ifscope = 0;
144
145 /* which function we're supposed to do */
146 #define F_GET 1
147 #define F_SET 2
148 #define F_FILESET 3
149 #define F_REPLACE 4
150 #define F_DELETE 5
151
152 #ifndef SA_SIZE
153 #define SA_SIZE(sa) \
154 ( (!(sa) || ((struct sockaddr *)(sa))->sa_len == 0) ? \
155 sizeof(uint32_t) : \
156 1 + ( (((struct sockaddr *)(sa))->sa_len - 1) | (sizeof(uint32_t) - 1) ) )
157 #endif
158
159 #define SETFUNC(f) { if (func) usage(); func = (f); }
160
161
162 int
163 main(int argc, char *argv[])
164 {
165 int ch, func = 0;
166 int rtn = 0;
167 int aflag = 0; /* do it for all entries */
168 int lflag = 0;
169 uint32_t ifindex = 0;
170
171 while ((ch = getopt(argc, argv, "andflsSi:")) != -1)
172 switch((char)ch) {
173 case 'a':
174 aflag = 1;
175 break;
176 case 'd':
177 SETFUNC(F_DELETE);
178 break;
179 case 'n':
180 nflag = 1;
181 break;
182 case 'l':
183 lflag = 1;
184 break;
185 case 'S':
186 SETFUNC(F_REPLACE);
187 break;
188 case 's':
189 SETFUNC(F_SET);
190 break;
191 case 'f' :
192 SETFUNC(F_FILESET);
193 break;
194 case 'i':
195 rifname = optarg;
196 break;
197 case '?':
198 default:
199 usage();
200 }
201 argc -= optind;
202 argv += optind;
203
204 if (!func)
205 func = F_GET;
206 if (rifname) {
207 if (func != F_GET && !(func == F_DELETE && aflag))
208 errx(1, "-i not applicable to this operation");
209 if ((ifindex = if_nametoindex(rifname)) == 0) {
210 if (errno == ENXIO)
211 errx(1, "interface %s does not exist", rifname);
212 else
213 err(1, "if_nametoindex(%s)", rifname);
214 }
215 }
216 switch (func) {
217 case F_GET:
218 if (aflag) {
219 if (argc != 0)
220 usage();
221 if (lflag) {
222 printf("%-23s %-17s %-9.9s %-9.9s %8.8s %4s "
223 "%4s\n", "Neighbor", "Linklayer Address",
224 "Expire(O)", "Expire(I)", "Netif", "Refs",
225 "Prbs");
226 search_ext(0, print_entry_ext);
227 } else {
228 search(0, print_entry);
229 }
230 } else {
231 if (argc != 1)
232 usage();
233 rtn = get(argv[0]);
234 }
235 break;
236 case F_SET:
237 case F_REPLACE:
238 if (argc < 2 || argc > 6)
239 usage();
240 if (func == F_REPLACE)
241 (void)delete(argv[0], 0);
242 rtn = set(argc, argv) ? 1 : 0;
243 break;
244 case F_DELETE:
245 if (aflag) {
246 if (argc != 0)
247 usage();
248 search(0, nuke_entry);
249 } else {
250 int do_proxy = 0;
251 int i;
252
253 for (i = 1; i < argc; i++) {
254 if (strncmp(argv[i], "pub", sizeof("pub")) == 0) {
255 do_proxy = SIN_PROXY;
256 } else if (strncmp(argv[i], "ifscope", sizeof("ifscope")) == 0) {
257 if (i + 1 >= argc) {
258 printf("ifscope needs an interface parameter\n");
259 return (1);
260 }
261 boundif = argv[++i];
262 if ((ifscope = if_nametoindex(boundif)) == 0)
263 errx(1, "ifscope has bad interface name: %s", boundif);
264 } else {
265 usage();
266 }
267 }
268 if (i > argc)
269 usage();
270 rtn = delete(argv[0], do_proxy);
271 }
272 break;
273 case F_FILESET:
274 if (argc != 1)
275 usage();
276 rtn = file(argv[0]);
277 break;
278 }
279
280 return (rtn);
281 }
282
283 /*
284 * Process a file to set standard arp entries
285 */
286 static int
287 file(char *name)
288 {
289 FILE *fp;
290 int i, retval;
291 char line[128], arg[7][50], *args[7], *p;
292
293 if ((fp = fopen(name, "r")) == NULL)
294 err(1, "cannot open %s", name);
295 args[0] = &arg[0][0];
296 args[1] = &arg[1][0];
297 args[2] = &arg[2][0];
298 args[3] = &arg[3][0];
299 args[4] = &arg[4][0];
300 args[5] = &arg[5][0];
301 args[6] = &arg[6][0];
302 retval = 0;
303 while(fgets(line, sizeof(line), fp) != NULL) {
304 if ((p = strchr(line, '#')) != NULL)
305 *p = '\0';
306 for (p = line; isblank(*p); p++);
307 if (*p == '\n' || *p == '\0')
308 continue;
309 i = sscanf(p, "%49s %49s %49s %49s %49s %49s %49s", arg[0], arg[1],
310 arg[2], arg[3], arg[4], arg[5], arg[6]);
311 if (i < 2) {
312 warnx("bad line: %s", line);
313 retval = 1;
314 continue;
315 }
316 if (set(i, args))
317 retval = 1;
318 }
319 fclose(fp);
320 return (retval);
321 }
322
323 /*
324 * Given a hostname, fills up a (static) struct sockaddr_inarp with
325 * the address of the host and returns a pointer to the
326 * structure.
327 */
328 static struct sockaddr_inarp *
329 getaddr(char *host)
330 {
331 struct hostent *hp;
332 static struct sockaddr_inarp reply;
333
334 bzero(&reply, sizeof(reply));
335 reply.sin_len = sizeof(reply);
336 reply.sin_family = AF_INET;
337 reply.sin_addr.s_addr = inet_addr(host);
338 if (reply.sin_addr.s_addr == INADDR_NONE) {
339 if (!(hp = gethostbyname(host))) {
340 warnx("%s: %s", host, hstrerror(h_errno));
341 return (NULL);
342 }
343 bcopy((char *)hp->h_addr, (char *)&reply.sin_addr,
344 sizeof reply.sin_addr);
345 }
346 return (&reply);
347 }
348
349 /*
350 * Returns true if the type is a valid one for ARP.
351 */
352 static int
353 valid_type(int type)
354 {
355
356 switch (type) {
357 case IFT_ETHER:
358 case IFT_FDDI:
359 case IFT_ISO88023:
360 case IFT_ISO88024:
361 #if 0
362 case IFT_ISO88025:
363 #endif
364 case IFT_L2VLAN:
365 #ifdef IFT_BRIDGE
366 case IFT_BRIDGE:
367 #endif
368 return (1);
369 default:
370 return (0);
371 }
372 }
373
374 /*
375 * Set an individual arp entry
376 */
377 static int
378 set(int argc, char **argv)
379 {
380 struct sockaddr_inarp *addr;
381 struct sockaddr_inarp *dst; /* what are we looking for */
382 struct sockaddr_dl *sdl;
383 struct rt_msghdr *rtm;
384 struct ether_addr *ea;
385 char *host = argv[0], *eaddr = argv[1];
386 struct sockaddr_dl sdl_m;
387
388 argc -= 2;
389 argv += 2;
390
391 bzero(&sdl_m, sizeof(sdl_m));
392 sdl_m.sdl_len = sizeof(sdl_m);
393 sdl_m.sdl_family = AF_LINK;
394
395 dst = getaddr(host);
396 if (dst == NULL)
397 return (1);
398 doing_proxy = flags = proxy_only = expire_time = 0;
399 boundif = NULL;
400 ifscope = 0;
401 while (argc-- > 0) {
402 if (strncmp(argv[0], "temp", sizeof("temp")) == 0) {
403 struct timeval tv;
404 gettimeofday(&tv, 0);
405 expire_time = tv.tv_sec + 20 * 60;
406 } else if (strncmp(argv[0], "pub", sizeof("pub")) == 0) {
407 flags |= RTF_ANNOUNCE;
408 doing_proxy = 1;
409 if (argc && strncmp(argv[1], "only", sizeof("only")) == 0) {
410 proxy_only = 1;
411 dst->sin_other = SIN_PROXY;
412 argc--; argv++;
413 }
414 } else if (strncmp(argv[0], "blackhole", sizeof("blackhole")) == 0) {
415 flags |= RTF_BLACKHOLE;
416 } else if (strncmp(argv[0], "reject", sizeof("reject")) == 0) {
417 flags |= RTF_REJECT;
418 } else if (strncmp(argv[0], "trail", sizeof("trail")) == 0) {
419 /* XXX deprecated and undocumented feature */
420 printf("%s: Sending trailers is no longer supported\n",
421 host);
422 } else if (strncmp(argv[0], "ifscope", sizeof("ifscope")) == 0) {
423 if (argc < 1) {
424 printf("ifscope needs an interface parameter\n");
425 return (1);
426 }
427 boundif = argv[1];
428 if ((ifscope = if_nametoindex(boundif)) == 0)
429 errx(1, "ifscope has bad interface name: %s", boundif);
430 argc--; argv++;
431 }
432 argv++;
433 }
434 ea = (struct ether_addr *)LLADDR(&sdl_m);
435 if (doing_proxy && !strcmp(eaddr, "auto")) {
436 if (!get_ether_addr(dst->sin_addr.s_addr, ea)) {
437 printf("no interface found for %s\n",
438 inet_ntoa(dst->sin_addr));
439 return (1);
440 }
441 sdl_m.sdl_alen = ETHER_ADDR_LEN;
442 } else {
443 struct ether_addr *ea1 = ether_aton(eaddr);
444
445 if (ea1 == NULL) {
446 warnx("invalid Ethernet address '%s'", eaddr);
447 return (1);
448 } else {
449 *ea = *ea1;
450 sdl_m.sdl_alen = ETHER_ADDR_LEN;
451 }
452 }
453 for (;;) { /* try at most twice */
454 rtm = rtmsg(RTM_GET, dst, &sdl_m);
455 if (rtm == NULL) {
456 warn("%s", host);
457 return (1);
458 }
459 addr = (struct sockaddr_inarp *)(rtm + 1);
460 sdl = (struct sockaddr_dl *)(SA_SIZE(addr) + (char *)addr);
461 if (addr->sin_addr.s_addr != dst->sin_addr.s_addr)
462 break;
463 if (sdl->sdl_family == AF_LINK &&
464 (rtm->rtm_flags & RTF_LLINFO) &&
465 !(rtm->rtm_flags & RTF_GATEWAY) &&
466 valid_type(sdl->sdl_type) )
467 break;
468 /*
469 * If we asked for a scope entry and did not get one or
470 * did not asked for a scope entry and got one, we can
471 * proceed.
472 */
473 if ((ifscope != 0) != (rtm->rtm_flags & RTF_IFSCOPE))
474 break;
475 if (doing_proxy == 0) {
476 printf("set: can only proxy for %s\n", host);
477 return (1);
478 }
479 if (dst->sin_other & SIN_PROXY) {
480 printf("set: proxy entry exists for non 802 device\n");
481 return (1);
482 }
483 dst->sin_other = SIN_PROXY;
484 proxy_only = 1;
485 }
486
487 if (sdl->sdl_family != AF_LINK) {
488 printf("cannot intuit interface index and type for %s\n", host);
489 return (1);
490 }
491 sdl_m.sdl_type = sdl->sdl_type;
492 sdl_m.sdl_index = sdl->sdl_index;
493 return (rtmsg(RTM_ADD, dst, &sdl_m) == NULL);
494 }
495
496 /*
497 * Display an individual arp entry
498 */
499 static int
500 get(char *host)
501 {
502 struct sockaddr_inarp *addr;
503
504 addr = getaddr(host);
505 if (addr == NULL)
506 return (1);
507 if (0 == search(addr->sin_addr.s_addr, print_entry)) {
508 printf("%s (%s) -- no entry",
509 host, inet_ntoa(addr->sin_addr));
510 if (rifname)
511 printf(" on %s", rifname);
512 printf("\n");
513 return (1);
514 }
515 return (0);
516 }
517
518 /*
519 * Delete an arp entry
520 */
521 static int
522 delete(char *host, int do_proxy)
523 {
524 struct sockaddr_inarp *addr, *dst;
525 struct rt_msghdr *rtm;
526 struct sockaddr_dl *sdl;
527
528 dst = getaddr(host);
529 if (dst == NULL)
530 return (1);
531 dst->sin_other = do_proxy;
532 for (;;) { /* try twice */
533 rtm = rtmsg(RTM_GET, dst, NULL);
534 if (rtm == NULL) {
535 warn("%s", host);
536 return (1);
537 }
538 addr = (struct sockaddr_inarp *)(rtm + 1);
539 sdl = (struct sockaddr_dl *)(SA_SIZE(addr) + (char *)addr);
540 if (addr->sin_addr.s_addr == dst->sin_addr.s_addr &&
541 sdl->sdl_family == AF_LINK &&
542 (rtm->rtm_flags & RTF_LLINFO) &&
543 !(rtm->rtm_flags & RTF_GATEWAY) &&
544 valid_type(sdl->sdl_type) )
545 break; /* found it */
546 if (dst->sin_other & SIN_PROXY) {
547 fprintf(stderr, "delete: cannot locate %s\n",host);
548 return (1);
549 }
550 dst->sin_other = SIN_PROXY;
551 }
552 if (rtmsg(RTM_DELETE, dst, NULL) != NULL) {
553 printf("%s (%s) deleted\n", host, inet_ntoa(addr->sin_addr));
554 return (0);
555 }
556 return (1);
557 }
558
559 /*
560 * Search the arp table and do some action on matching entries
561 */
562 static int
563 search(in_addr_t addr, action_fn *action)
564 {
565 int mib[6];
566 size_t needed;
567 char *lim, *buf, *newbuf, *next;
568 struct rt_msghdr *rtm;
569 struct sockaddr_inarp *sin2;
570 struct sockaddr_dl *sdl;
571 char ifname[IF_NAMESIZE];
572 int st, found_entry = 0;
573
574 mib[0] = CTL_NET;
575 mib[1] = PF_ROUTE;
576 mib[2] = 0;
577 mib[3] = AF_INET;
578 mib[4] = NET_RT_FLAGS;
579 mib[5] = RTF_LLINFO;
580 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
581 err(1, "route-sysctl-estimate");
582 if (needed == 0) /* empty table */
583 return 0;
584 buf = NULL;
585 for (;;) {
586 newbuf = realloc(buf, needed);
587 if (newbuf == NULL) {
588 if (buf != NULL)
589 free(buf);
590 errx(1, "could not reallocate memory");
591 }
592 buf = newbuf;
593 st = sysctl(mib, 6, buf, &needed, NULL, 0);
594 if (st == 0 || errno != ENOMEM)
595 break;
596 needed += needed / 8;
597 }
598 if (st == -1)
599 err(1, "actual retrieval of routing table");
600 lim = buf + needed;
601 for (next = buf; next < lim; next += rtm->rtm_msglen) {
602 rtm = (struct rt_msghdr *)next;
603 sin2 = (struct sockaddr_inarp *)(rtm + 1);
604 sdl = (struct sockaddr_dl *)((char *)sin2 + SA_SIZE(sin2));
605 if (rifname && if_indextoname(sdl->sdl_index, ifname) &&
606 strcmp(ifname, rifname))
607 continue;
608 if (addr) {
609 if (addr != sin2->sin_addr.s_addr)
610 continue;
611 found_entry = 1;
612 }
613 (*action)(sdl, sin2, rtm);
614 }
615 free(buf);
616 return (found_entry);
617 }
618
619 /*
620 * Stolen and adapted from ifconfig
621 */
622 static char *
623 print_lladdr(struct sockaddr_dl *sdl)
624 {
625 static char buf[256];
626 char *cp;
627 int n, bufsize = sizeof (buf), p = 0;
628
629 bzero(buf, sizeof (buf));
630 cp = (char *)LLADDR(sdl);
631 if ((n = sdl->sdl_alen) > 0) {
632 while (--n >= 0)
633 p += snprintf(buf + p, bufsize - p, "%x%s",
634 *cp++ & 0xff, n > 0 ? ":" : "");
635 }
636 return (buf);
637 }
638
639 /*
640 * Display an arp entry
641 */
642 static void
643 print_entry(struct sockaddr_dl *sdl,
644 struct sockaddr_inarp *addr, struct rt_msghdr *rtm)
645 {
646 const char *host;
647 struct hostent *hp;
648 char ifname[IF_NAMESIZE];
649 #if 0
650 struct iso88025_sockaddr_dl_data *trld;
651 int seg;
652 #endif
653
654 if (nflag == 0)
655 hp = gethostbyaddr((caddr_t)&(addr->sin_addr),
656 sizeof addr->sin_addr, AF_INET);
657 else
658 hp = 0;
659 if (hp)
660 host = hp->h_name;
661 else {
662 host = "?";
663 if (h_errno == TRY_AGAIN)
664 nflag = 1;
665 }
666 printf("%s (%s) at ", host, inet_ntoa(addr->sin_addr));
667 if (sdl->sdl_alen) {
668 #if 1
669 printf("%s", print_lladdr(sdl));
670 #else
671 if ((sdl->sdl_type == IFT_ETHER ||
672 sdl->sdl_type == IFT_L2VLAN ||
673 sdl->sdl_type == IFT_BRIDGE) &&
674 sdl->sdl_alen == ETHER_ADDR_LEN)
675 printf("%s", ether_ntoa((struct ether_addr *)LLADDR(sdl)));
676 else {
677 int n = sdl->sdl_nlen > 0 ? sdl->sdl_nlen + 1 : 0;
678
679 printf("%s", link_ntoa(sdl) + n);
680 }
681 #endif
682 } else
683 printf("(incomplete)");
684 if (if_indextoname(sdl->sdl_index, ifname) != NULL)
685 printf(" on %s", ifname);
686 if ((rtm->rtm_flags & RTF_IFSCOPE))
687 printf(" ifscope");
688 if (rtm->rtm_rmx.rmx_expire == 0)
689 printf(" permanent");
690 if (addr->sin_other & SIN_PROXY)
691 printf(" published (proxy only)");
692 if (rtm->rtm_addrs & RTA_NETMASK) {
693 addr = (struct sockaddr_inarp *)
694 (SA_SIZE(sdl) + (char *)sdl);
695 if (addr->sin_addr.s_addr == 0xffffffff)
696 printf(" published");
697 if (addr->sin_len != 8)
698 printf("(weird)");
699 }
700 switch(sdl->sdl_type) {
701 case IFT_ETHER:
702 printf(" [ethernet]");
703 break;
704 #if 0
705 case IFT_ISO88025:
706 printf(" [token-ring]");
707 trld = SDL_ISO88025(sdl);
708 if (trld->trld_rcf != 0) {
709 printf(" rt=%x", ntohs(trld->trld_rcf));
710 for (seg = 0;
711 seg < ((TR_RCF_RIFLEN(trld->trld_rcf) - 2 ) / 2);
712 seg++)
713 printf(":%x", ntohs(*(trld->trld_route[seg])));
714 }
715 break;
716 #endif
717 case IFT_FDDI:
718 printf(" [fddi]");
719 break;
720 case IFT_ATM:
721 printf(" [atm]");
722 break;
723 case IFT_L2VLAN:
724 printf(" [vlan]");
725 break;
726 case IFT_IEEE1394:
727 printf(" [firewire]");
728 break;
729 #ifdef IFT_BRIDGE
730 case IFT_BRIDGE:
731 printf(" [bridge]");
732 break;
733 #endif
734 default:
735 break;
736 }
737
738 printf("\n");
739
740 }
741
742 /*
743 * Nuke an arp entry
744 */
745 static void
746 nuke_entry(struct sockaddr_dl *sdl __unused,
747 struct sockaddr_inarp *addr, struct rt_msghdr *rtm)
748 {
749 char ip[20];
750
751 snprintf(ip, sizeof(ip), "%s", inet_ntoa(addr->sin_addr));
752 /*
753 * When deleting all entries, specify the interface scope of each entry
754 */
755 if ((rtm->rtm_flags & RTF_IFSCOPE))
756 ifscope = rtm->rtm_index;
757 (void)delete(ip, 0);
758 ifscope = 0;
759 }
760
761 static void
762 usage(void)
763 {
764 fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
765 "usage: arp [-n] [-i interface] hostname",
766 " arp [-n] [-i interface] [-l] -a",
767 " arp -d hostname [pub] [ifscope interface]",
768 " arp -d [-i interface] -a",
769 " arp -s hostname ether_addr [temp] [reject] [blackhole] [pub [only]] [ifscope interface]",
770 " arp -S hostname ether_addr [temp] [reject] [blackhole] [pub [only]] [ifscope interface]",
771 " arp -f filename");
772 exit(1);
773 }
774
775 static struct rt_msghdr *
776 rtmsg(int cmd, struct sockaddr_inarp *dst, struct sockaddr_dl *sdl)
777 {
778 static int seq;
779 int rlen;
780 int l;
781 struct sockaddr_in so_mask, *so_mask_ptr = &so_mask;
782 static int s = -1;
783 static pid_t pid;
784
785 static struct {
786 struct rt_msghdr m_rtm;
787 char m_space[512];
788 } m_rtmsg;
789
790 struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
791 char *cp = m_rtmsg.m_space;
792
793 if (s < 0) { /* first time: open socket, get pid */
794 s = socket(PF_ROUTE, SOCK_RAW, 0);
795 if (s < 0)
796 err(1, "socket");
797 pid = getpid();
798 }
799 bzero(&so_mask, sizeof(so_mask));
800 so_mask.sin_len = 8;
801 so_mask.sin_addr.s_addr = 0xffffffff;
802
803 errno = 0;
804 /*
805 * XXX RTM_DELETE relies on a previous RTM_GET to fill the buffer
806 * appropriately (except for the mask set just above).
807 */
808 if (cmd == RTM_DELETE)
809 goto doit;
810 bzero((char *)&m_rtmsg, sizeof(m_rtmsg));
811 rtm->rtm_flags = flags;
812 rtm->rtm_version = RTM_VERSION;
813
814 /*
815 * Note: On RTM_GET the kernel will return a scoped route when both a scoped route and
816 * a unscoped route exist. That means we cannot delete a unscoped route if there is
817 * also a matching scope route
818 */
819 if (ifscope) {
820 rtm->rtm_index = ifscope;
821 rtm->rtm_flags |= RTF_IFSCOPE;
822 }
823
824 switch (cmd) {
825 default:
826 errx(1, "internal wrong cmd");
827 case RTM_ADD:
828 rtm->rtm_addrs |= RTA_GATEWAY;
829 rtm->rtm_rmx.rmx_expire = expire_time;
830 rtm->rtm_inits = RTV_EXPIRE;
831 rtm->rtm_flags |= (RTF_HOST | RTF_STATIC);
832 dst->sin_other = 0;
833 if (doing_proxy) {
834 if (proxy_only)
835 dst->sin_other = SIN_PROXY;
836 else {
837 rtm->rtm_addrs |= RTA_NETMASK;
838 rtm->rtm_flags &= ~RTF_HOST;
839 }
840 }
841 /* FALLTHROUGH */
842 case RTM_GET:
843 rtm->rtm_addrs |= RTA_DST;
844 }
845 #define NEXTADDR(w, s) \
846 if ((s) != NULL && rtm->rtm_addrs & (w)) { \
847 bcopy((s), cp, sizeof(*(s))); cp += SA_SIZE(s);}
848
849 NEXTADDR(RTA_DST, dst);
850 NEXTADDR(RTA_GATEWAY, sdl);
851 NEXTADDR(RTA_NETMASK, so_mask_ptr);
852
853 rtm->rtm_msglen = cp - (char *)&m_rtmsg;
854 doit:
855 l = rtm->rtm_msglen;
856 rtm->rtm_seq = ++seq;
857 rtm->rtm_type = cmd;
858 if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
859 if (errno != ESRCH || cmd != RTM_DELETE) {
860 warn("writing to routing socket");
861 return (NULL);
862 }
863 }
864 do {
865 l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
866 } while (l > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
867 if (l < 0)
868 warn("read from routing socket");
869 return (rtm);
870 }
871
872 /*
873 * get_ether_addr - get the hardware address of an interface on the
874 * the same subnet as ipaddr.
875 */
876 #define MAX_IFS 32
877
878 static int
879 get_ether_addr(in_addr_t ipaddr, struct ether_addr *hwaddr)
880 {
881 struct ifreq *ifr, *ifend, *ifp;
882 in_addr_t ina, mask;
883 struct sockaddr_dl *dla;
884 struct ifreq ifreq;
885 struct ifconf ifc;
886 struct ifreq ifs[MAX_IFS];
887 int sock;
888 int retval = 0;
889
890 sock = socket(AF_INET, SOCK_DGRAM, 0);
891 if (sock < 0)
892 err(1, "socket");
893
894 ifc.ifc_len = sizeof(ifs);
895 ifc.ifc_req = ifs;
896 if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) {
897 warnx("ioctl(SIOCGIFCONF)");
898 goto done;
899 }
900
901 #define NEXTIFR(i) \
902 ((struct ifreq *)((char *)&(i)->ifr_addr \
903 + MAX((i)->ifr_addr.sa_len, sizeof((i)->ifr_addr))) )
904
905 /*
906 * Scan through looking for an interface with an Internet
907 * address on the same subnet as `ipaddr'.
908 */
909 ifend = (struct ifreq *)(ifc.ifc_buf + ifc.ifc_len);
910 for (ifr = ifc.ifc_req; ifr < ifend; ifr = NEXTIFR(ifr) ) {
911 if (ifr->ifr_addr.sa_family != AF_INET)
912 continue;
913 strncpy(ifreq.ifr_name, ifr->ifr_name,
914 sizeof(ifreq.ifr_name));
915 ifreq.ifr_addr = ifr->ifr_addr;
916 /*
917 * Check that the interface is up,
918 * and not point-to-point or loopback.
919 */
920 if (ioctl(sock, SIOCGIFFLAGS, &ifreq) < 0)
921 continue;
922 if ((ifreq.ifr_flags &
923 (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|
924 IFF_LOOPBACK|IFF_NOARP))
925 != (IFF_UP|IFF_BROADCAST))
926 continue;
927 /*
928 * Get its netmask and check that it's on
929 * the right subnet.
930 */
931 if (ioctl(sock, SIOCGIFNETMASK, &ifreq) < 0)
932 continue;
933 mask = ((struct sockaddr_in *)
934 &ifreq.ifr_addr)->sin_addr.s_addr;
935 ina = ((struct sockaddr_in *)
936 &ifr->ifr_addr)->sin_addr.s_addr;
937 if ((ipaddr & mask) == (ina & mask))
938 break; /* ok, we got it! */
939 }
940
941 if (ifr >= ifend)
942 goto done;
943
944 /*
945 * Now scan through again looking for a link-level address
946 * for this interface.
947 */
948 ifp = ifr;
949 for (ifr = ifc.ifc_req; ifr < ifend; ifr = NEXTIFR(ifr))
950 if (strcmp(ifp->ifr_name, ifr->ifr_name) == 0 &&
951 ifr->ifr_addr.sa_family == AF_LINK)
952 break;
953 if (ifr >= ifend)
954 goto done;
955 /*
956 * Found the link-level address - copy it out
957 */
958 dla = (struct sockaddr_dl *) &ifr->ifr_addr;
959 memcpy(hwaddr, LLADDR(dla), dla->sdl_alen);
960 printf("using interface %s for proxy with address ",
961 ifp->ifr_name);
962 printf("%s\n", ether_ntoa(hwaddr));
963 retval = dla->sdl_alen;
964 done:
965 close(sock);
966 return (retval);
967 }
968
969 static char *
970 sec2str(total)
971 time_t total;
972 {
973 static char result[256];
974 int days, hours, mins, secs;
975 int first = 1;
976 char *p = result;
977
978 days = total / 3600 / 24;
979 hours = (total / 3600) % 24;
980 mins = (total / 60) % 60;
981 secs = total % 60;
982
983 if (days) {
984 first = 0;
985 p += snprintf(p, sizeof(result) - (p - result), "%dd", days);
986 }
987 if (!first || hours) {
988 first = 0;
989 p += snprintf(p, sizeof(result) - (p - result), "%dh", hours);
990 }
991 if (!first || mins) {
992 first = 0;
993 p += snprintf(p, sizeof(result) - (p - result), "%dm", mins);
994 }
995 snprintf(p, sizeof(result) - (p - result), "%ds", secs);
996
997 return(result);
998 }
999
1000 static int
1001 search_ext(in_addr_t addr, action_ext_fn *action)
1002 {
1003 int mib[6];
1004 size_t needed;
1005 char *lim, *buf, *newbuf, *next;
1006 struct rt_msghdr_ext *ertm;
1007 struct sockaddr_inarp *sin2;
1008 struct sockaddr_dl *sdl;
1009 char ifname[IF_NAMESIZE];
1010 int st, found_entry = 0;
1011
1012 mib[0] = CTL_NET;
1013 mib[1] = PF_ROUTE;
1014 mib[2] = 0;
1015 mib[3] = AF_INET;
1016 mib[4] = NET_RT_DUMPX_FLAGS;
1017 mib[5] = RTF_LLINFO;
1018 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
1019 err(1, "route-sysctl-estimate");
1020 if (needed == 0) /* empty table */
1021 return 0;
1022 buf = NULL;
1023 for (;;) {
1024 newbuf = realloc(buf, needed);
1025 if (newbuf == NULL) {
1026 if (buf != NULL)
1027 free(buf);
1028 errx(1, "could not reallocate memory");
1029 }
1030 buf = newbuf;
1031 st = sysctl(mib, 6, buf, &needed, NULL, 0);
1032 if (st == 0 || errno != ENOMEM)
1033 break;
1034 needed += needed / 8;
1035 }
1036 if (st == -1)
1037 err(1, "actual retrieval of routing table");
1038 lim = buf + needed;
1039 for (next = buf; next < lim; next += ertm->rtm_msglen) {
1040 ertm = (struct rt_msghdr_ext *)next;
1041 sin2 = (struct sockaddr_inarp *)(ertm + 1);
1042 sdl = (struct sockaddr_dl *)((char *)sin2 + SA_SIZE(sin2));
1043 if (rifname && if_indextoname(sdl->sdl_index, ifname) &&
1044 strcmp(ifname, rifname))
1045 continue;
1046 if (addr) {
1047 if (addr != sin2->sin_addr.s_addr)
1048 continue;
1049 found_entry = 1;
1050 }
1051 (*action)(sdl, sin2, ertm);
1052 }
1053 free(buf);
1054 return (found_entry);
1055 }
1056
1057 static void
1058 print_entry_ext(struct sockaddr_dl *sdl, struct sockaddr_inarp *addr,
1059 struct rt_msghdr_ext *ertm)
1060 {
1061 const char *host;
1062 struct hostent *hp;
1063 char ifname[IF_NAMESIZE];
1064 struct timeval time;
1065
1066 if (nflag == 0)
1067 hp = gethostbyaddr((caddr_t)&(addr->sin_addr),
1068 sizeof (addr->sin_addr), AF_INET);
1069 else
1070 hp = 0;
1071
1072 if (hp)
1073 host = hp->h_name;
1074 else
1075 host = inet_ntoa(addr->sin_addr);
1076
1077 printf("%-23s ", host);
1078
1079 if (sdl->sdl_alen)
1080 printf("%-17s ", print_lladdr(sdl));
1081 else
1082 printf("%-17s ", "(incomplete)");
1083
1084 gettimeofday(&time, 0);
1085
1086 if (ertm->rtm_ri.ri_refcnt == 0 || ertm->rtm_ri.ri_snd_expire == 0)
1087 printf("%-9.9s ", "(none)");
1088 else if (ertm->rtm_ri.ri_snd_expire > time.tv_sec)
1089 printf("%-9.9s ",
1090 sec2str(ertm->rtm_ri.ri_snd_expire - time.tv_sec));
1091 else
1092 printf("%-9.9s ", "expired");
1093
1094 if (ertm->rtm_ri.ri_refcnt == 0 || ertm->rtm_ri.ri_rcv_expire == 0)
1095 printf("%-9.9s", "(none)");
1096 else if (ertm->rtm_ri.ri_rcv_expire > time.tv_sec)
1097 printf("%-9.9s",
1098 sec2str(ertm->rtm_ri.ri_rcv_expire - time.tv_sec));
1099 else
1100 printf("%-9.9s", "expired");
1101
1102 if (if_indextoname(sdl->sdl_index, ifname) == NULL)
1103 snprintf(ifname, sizeof (ifname), "%s", "?");
1104 printf(" %8.8s", ifname);
1105
1106 if (ertm->rtm_ri.ri_refcnt) {
1107 printf(" %4d", ertm->rtm_ri.ri_refcnt);
1108 if (ertm->rtm_ri.ri_probes)
1109 printf(" %4d", ertm->rtm_ri.ri_probes);
1110 }
1111 printf("\n");
1112 }
mirror of network_cmds