1*af069eb3Schristos /* $NetBSD: arp.c,v 1.48 2009/04/02 21:02:06 christos Exp $ */ 27f624aaaSchopps 361f28255Scgd /* 417c454feSmycroft * Copyright (c) 1984, 1993 517c454feSmycroft * The Regents of the University of California. All rights reserved. 661f28255Scgd * 761f28255Scgd * This code is derived from software contributed to Berkeley by 861f28255Scgd * Sun Microsystems, Inc. 961f28255Scgd * 1061f28255Scgd * Redistribution and use in source and binary forms, with or without 1161f28255Scgd * modification, are permitted provided that the following conditions 1261f28255Scgd * are met: 1361f28255Scgd * 1. Redistributions of source code must retain the above copyright 1461f28255Scgd * notice, this list of conditions and the following disclaimer. 1561f28255Scgd * 2. Redistributions in binary form must reproduce the above copyright 1661f28255Scgd * notice, this list of conditions and the following disclaimer in the 1761f28255Scgd * documentation and/or other materials provided with the distribution. 18326b2259Sagc * 3. Neither the name of the University nor the names of its contributors 1961f28255Scgd * may be used to endorse or promote products derived from this software 2061f28255Scgd * without specific prior written permission. 2161f28255Scgd * 2261f28255Scgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 2361f28255Scgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2461f28255Scgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2561f28255Scgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 2661f28255Scgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2761f28255Scgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2861f28255Scgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2961f28255Scgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 3061f28255Scgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 3161f28255Scgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3261f28255Scgd * SUCH DAMAGE. 3361f28255Scgd */ 3461f28255Scgd 3540980191Slukem #include <sys/cdefs.h> 3661f28255Scgd #ifndef lint 379c194566Slukem __COPYRIGHT("@(#) Copyright (c) 1984, 1993\ 389c194566Slukem The Regents of the University of California. All rights reserved."); 3961f28255Scgd #endif /* not lint */ 4061f28255Scgd 4161f28255Scgd #ifndef lint 4240980191Slukem #if 0 4340980191Slukem static char sccsid[] = "@(#)arp.c 8.3 (Berkeley) 4/28/95"; 4440980191Slukem #else 45*af069eb3Schristos __RCSID("$NetBSD: arp.c,v 1.48 2009/04/02 21:02:06 christos Exp $"); 4640980191Slukem #endif 4761f28255Scgd #endif /* not lint */ 4861f28255Scgd 4961f28255Scgd /* 5061f28255Scgd * arp - display, set, and delete arp table entries 5161f28255Scgd */ 5261f28255Scgd 5361f28255Scgd #include <sys/param.h> 5461f28255Scgd #include <sys/file.h> 5561f28255Scgd #include <sys/socket.h> 5617c454feSmycroft #include <sys/sysctl.h> 570ea0f71aSfair #include <sys/ioctl.h> 5861f28255Scgd 5961f28255Scgd #include <net/if.h> 6017c454feSmycroft #include <net/if_dl.h> 6100cef679Sis #include <net/if_ether.h> 6217c454feSmycroft #include <net/if_types.h> 6317c454feSmycroft #include <net/route.h> 6417c454feSmycroft #include <netinet/in.h> 6500cef679Sis #include <netinet/if_inarp.h> 66804c4234Smycroft #include <arpa/inet.h> 6761f28255Scgd 68c4516a41Schopps #include <err.h> 69f3b151f5Smikel #include <errno.h> 70f3b151f5Smikel #include <netdb.h> 7161f28255Scgd #include <nlist.h> 72f3b151f5Smikel #include <paths.h> 7361f28255Scgd #include <stdio.h> 74c4516a41Schopps #include <stdlib.h> 75867b4b0fScgd #include <string.h> 76f3b151f5Smikel #include <unistd.h> 77ecf05965Srafal #include <ifaddrs.h> 7861f28255Scgd 798adc537dSdyoung static int is_llinfo(const struct sockaddr_dl *, int); 806fef5d35Schristos static int delete(const char *, const char *); 816fef5d35Schristos static void dump(uint32_t); 826fef5d35Schristos static void delete_all(void); 836fef5d35Schristos static void sdl_print(const struct sockaddr_dl *); 846fef5d35Schristos static int getifname(u_int16_t, char *, size_t); 856fef5d35Schristos static int atosdl(const char *s, struct sockaddr_dl *sdl); 866fef5d35Schristos static int file(const char *); 876fef5d35Schristos static void get(const char *); 886fef5d35Schristos static int getinetaddr(const char *, struct in_addr *); 896fef5d35Schristos static void getsocket(void); 906fef5d35Schristos static int rtmsg(int); 916fef5d35Schristos static int set(int, char **); 928b0f9554Sperry static void usage(void) __dead; 9300cef679Sis 946fef5d35Schristos static pid_t pid; 95c0da9e56Satatat static int aflag, nflag, vflag; 9638e37321Smikel static int s = -1; 97ecf05965Srafal static struct ifaddrs* ifaddrs = NULL; 986fef5d35Schristos static struct sockaddr_in so_mask = { 996fef5d35Schristos .sin_len = 8, 1006fef5d35Schristos .sin_addr = { 1016fef5d35Schristos .s_addr = 0xffffffff 1026fef5d35Schristos } 1036fef5d35Schristos }; 1046fef5d35Schristos static struct sockaddr_inarp blank_sin = { 1056fef5d35Schristos .sin_len = sizeof(blank_sin), 1066fef5d35Schristos .sin_family = AF_INET 1076fef5d35Schristos }; 1086fef5d35Schristos static struct sockaddr_inarp sin_m; 1096fef5d35Schristos static struct sockaddr_dl blank_sdl = { 1106fef5d35Schristos .sdl_len = sizeof(blank_sdl), 1116fef5d35Schristos .sdl_family = AF_LINK 1126fef5d35Schristos }; 1136fef5d35Schristos static struct sockaddr_dl sdl_m; 1146fef5d35Schristos 1156fef5d35Schristos static int expire_time, flags, export_only, doing_proxy, found_entry; 1166fef5d35Schristos static struct { 1176fef5d35Schristos struct rt_msghdr m_rtm; 1186fef5d35Schristos char m_space[512]; 1196fef5d35Schristos } m_rtmsg; 12038e37321Smikel 121c4516a41Schopps int 1224d3d9104Sxtraeme main(int argc, char **argv) 12361f28255Scgd { 12461f28255Scgd int ch; 125f3b151f5Smikel int op = 0; 12661f28255Scgd 127eda273b9Stv setprogname(argv[0]); 128eda273b9Stv 12917c454feSmycroft pid = getpid(); 130f3b151f5Smikel 13192e05e0eSmrg while ((ch = getopt(argc, argv, "andsfv")) != -1) 13261f28255Scgd switch((char)ch) { 13317c454feSmycroft case 'a': 134c0da9e56Satatat aflag = 1; 135c0da9e56Satatat break; 13661f28255Scgd case 'd': 137f3b151f5Smikel case 's': 138f3b151f5Smikel case 'f': 139f3b151f5Smikel if (op) 14061f28255Scgd usage(); 141f3b151f5Smikel op = ch; 142f3b151f5Smikel break; 14317c454feSmycroft case 'n': 14417c454feSmycroft nflag = 1; 145c4516a41Schopps break; 14692e05e0eSmrg case 'v': 14792e05e0eSmrg vflag = 1; 14892e05e0eSmrg break; 14961f28255Scgd default: 15061f28255Scgd usage(); 15161f28255Scgd } 152f3b151f5Smikel argc -= optind; 153f3b151f5Smikel argv += optind; 154f3b151f5Smikel 155c0da9e56Satatat if (!op && aflag) 156c0da9e56Satatat op = 'a'; 157c0da9e56Satatat 158f3b151f5Smikel switch((char)op) { 159f3b151f5Smikel case 'a': 160f3b151f5Smikel dump(0); 161f3b151f5Smikel break; 162f3b151f5Smikel case 'd': 163c0da9e56Satatat if (aflag && argc == 0) 164c0da9e56Satatat delete_all(); 165c0da9e56Satatat else { 166c0da9e56Satatat if (aflag || argc < 1 || argc > 2) 16761f28255Scgd usage(); 168f3b151f5Smikel (void)delete(argv[0], argv[1]); 169c0da9e56Satatat } 170f3b151f5Smikel break; 171f3b151f5Smikel case 's': 172f3b151f5Smikel if (argc < 2 || argc > 5) 173f3b151f5Smikel usage(); 174f3b151f5Smikel return (set(argc, argv) ? 1 : 0); 175f3b151f5Smikel case 'f': 176f3b151f5Smikel if (argc != 1) 177f3b151f5Smikel usage(); 178f3b151f5Smikel return (file(argv[0])); 179f3b151f5Smikel default: 180f3b151f5Smikel if (argc != 1) 181f3b151f5Smikel usage(); 182f3b151f5Smikel get(argv[0]); 183f3b151f5Smikel break; 184f3b151f5Smikel } 185c4516a41Schopps return (0); 18661f28255Scgd } 18761f28255Scgd 18861f28255Scgd /* 18961f28255Scgd * Process a file to set standard arp entries 19061f28255Scgd */ 1916fef5d35Schristos static int 1926fef5d35Schristos file(const char *name) 19361f28255Scgd { 1946fef5d35Schristos char *line, *argv[5]; 195c4516a41Schopps int i, retval; 196c4516a41Schopps FILE *fp; 19761f28255Scgd 198c4516a41Schopps if ((fp = fopen(name, "r")) == NULL) 199c4516a41Schopps err(1, "cannot open %s", name); 20061f28255Scgd retval = 0; 2016fef5d35Schristos for (; (line = fparseln(fp, NULL, NULL, NULL, 0)) != NULL; free(line)) { 2026fef5d35Schristos char **ap, *inputstring; 2036fef5d35Schristos 2046fef5d35Schristos inputstring = line; 2056fef5d35Schristos for (ap = argv; ap < &argv[sizeof(argv) / sizeof(argv[0])] && 2066fef5d35Schristos (*ap = stresep(&inputstring, " \t", '\\')) != NULL;) { 2076fef5d35Schristos if (**ap != '\0') 2086fef5d35Schristos ap++; 2096fef5d35Schristos } 2106fef5d35Schristos i = ap - argv; 21161f28255Scgd if (i < 2) { 212c4516a41Schopps warnx("bad line: %s", line); 21361f28255Scgd retval = 1; 21461f28255Scgd continue; 21561f28255Scgd } 2166fef5d35Schristos if (set(i, argv)) 21761f28255Scgd retval = 1; 21861f28255Scgd } 2196fef5d35Schristos (void)fclose(fp); 2206fef5d35Schristos return retval; 22161f28255Scgd } 22261f28255Scgd 2236fef5d35Schristos static void 2244d3d9104Sxtraeme getsocket(void) 225c4516a41Schopps { 226c4516a41Schopps if (s >= 0) 227c4516a41Schopps return; 22817c454feSmycroft s = socket(PF_ROUTE, SOCK_RAW, 0); 229c4516a41Schopps if (s < 0) 230c4516a41Schopps err(1, "socket"); 23117c454feSmycroft } 23217c454feSmycroft 23361f28255Scgd /* 23461f28255Scgd * Set an individual arp entry 23561f28255Scgd */ 2366fef5d35Schristos static int 2374d3d9104Sxtraeme set(int argc, char **argv) 23861f28255Scgd { 2394d3d9104Sxtraeme struct sockaddr_inarp *sina; 24040980191Slukem struct sockaddr_dl *sdl; 24140980191Slukem struct rt_msghdr *rtm; 242c4516a41Schopps char *host = argv[0], *eaddr; 24392e05e0eSmrg int rval; 244c4516a41Schopps 2454d3d9104Sxtraeme sina = &sin_m; 246c4516a41Schopps rtm = &(m_rtmsg.m_rtm); 247c4516a41Schopps eaddr = argv[1]; 24861f28255Scgd 24917c454feSmycroft getsocket(); 25061f28255Scgd argc -= 2; 25161f28255Scgd argv += 2; 252c4516a41Schopps sdl_m = blank_sdl; /* struct copy */ 253c4516a41Schopps sin_m = blank_sin; /* struct copy */ 2544d3d9104Sxtraeme if (getinetaddr(host, &sina->sin_addr) == -1) 25561f28255Scgd return (1); 25600cef679Sis if (atosdl(eaddr, &sdl_m)) 25700cef679Sis warnx("invalid link-level address '%s'", eaddr); 25817c454feSmycroft doing_proxy = flags = export_only = expire_time = 0; 25961f28255Scgd while (argc-- > 0) { 26017c454feSmycroft if (strncmp(argv[0], "temp", 4) == 0) { 2614d3d9104Sxtraeme struct timeval timev; 2624d3d9104Sxtraeme (void)gettimeofday(&timev, 0); 2634d3d9104Sxtraeme expire_time = timev.tv_sec + 20 * 60; 26417c454feSmycroft } 26517c454feSmycroft else if (strncmp(argv[0], "pub", 3) == 0) { 26617c454feSmycroft flags |= RTF_ANNOUNCE; 26717c454feSmycroft doing_proxy = SIN_PROXY; 26840918b5aSseanb if (argc && strncmp(argv[1], "pro", 3) == 0) { 26940918b5aSseanb export_only = 1; 27040918b5aSseanb argc--; argv++; 27140918b5aSseanb } 27217c454feSmycroft } else if (strncmp(argv[0], "trail", 5) == 0) { 2736fef5d35Schristos warnx("%s: Sending trailers is no longer supported", 27417c454feSmycroft host); 27517c454feSmycroft } 27661f28255Scgd argv++; 27761f28255Scgd } 27817c454feSmycroft tryagain: 27917c454feSmycroft if (rtmsg(RTM_GET) < 0) { 280c4516a41Schopps warn("%s", host); 28117c454feSmycroft return (1); 28261f28255Scgd } 2836fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1); 284*af069eb3Schristos sdl = (struct sockaddr_dl *)(void *)(RT_ROUNDUP(sina->sin_len) + 2856fef5d35Schristos (char *)(void *)sina); 2864d3d9104Sxtraeme if (sina->sin_addr.s_addr == sin_m.sin_addr.s_addr) { 2878adc537dSdyoung if (is_llinfo(sdl, rtm->rtm_flags)) 28817c454feSmycroft goto overwrite; 28917c454feSmycroft if (doing_proxy == 0) { 2906fef5d35Schristos warnx("set: can only proxy for %s", host); 29117c454feSmycroft return (1); 29217c454feSmycroft } 29317c454feSmycroft if (sin_m.sin_other & SIN_PROXY) { 2946fef5d35Schristos warnx("set: proxy entry exists for non 802 device"); 29517c454feSmycroft return (1); 29617c454feSmycroft } 29717c454feSmycroft sin_m.sin_other = SIN_PROXY; 29817c454feSmycroft export_only = 1; 29917c454feSmycroft goto tryagain; 30017c454feSmycroft } 30117c454feSmycroft overwrite: 30217c454feSmycroft if (sdl->sdl_family != AF_LINK) { 3036fef5d35Schristos warnx("cannot intuit interface index and type for %s", 304c4516a41Schopps host); 30517c454feSmycroft return (1); 30617c454feSmycroft } 30717c454feSmycroft sdl_m.sdl_type = sdl->sdl_type; 30817c454feSmycroft sdl_m.sdl_index = sdl->sdl_index; 30992e05e0eSmrg rval = rtmsg(RTM_ADD); 31092e05e0eSmrg if (vflag) 31192e05e0eSmrg (void)printf("%s (%s) added\n", host, eaddr); 31292e05e0eSmrg return (rval); 31361f28255Scgd } 31461f28255Scgd 31561f28255Scgd /* 31661f28255Scgd * Display an individual arp entry 31761f28255Scgd */ 3186fef5d35Schristos static void 3194d3d9104Sxtraeme get(const char *host) 32061f28255Scgd { 3214d3d9104Sxtraeme struct sockaddr_inarp *sina; 32261f28255Scgd 3234d3d9104Sxtraeme sina = &sin_m; 324c4516a41Schopps sin_m = blank_sin; /* struct copy */ 3254d3d9104Sxtraeme if (getinetaddr(host, &sina->sin_addr) == -1) 32661f28255Scgd exit(1); 3274d3d9104Sxtraeme dump(sina->sin_addr.s_addr); 3286fef5d35Schristos if (found_entry == 0) 3296fef5d35Schristos errx(1, "%s (%s) -- no entry", host, inet_ntoa(sina->sin_addr)); 33061f28255Scgd } 33161f28255Scgd 3328adc537dSdyoung 3338adc537dSdyoung static int 3348adc537dSdyoung is_llinfo(const struct sockaddr_dl *sdl, int rtflags) 3358adc537dSdyoung { 3368adc537dSdyoung if (sdl->sdl_family != AF_LINK || 3378adc537dSdyoung (rtflags & (RTF_LLINFO|RTF_GATEWAY)) != RTF_LLINFO) 3388adc537dSdyoung return 0; 3398adc537dSdyoung 3408adc537dSdyoung switch (sdl->sdl_type) { 3418adc537dSdyoung case IFT_ETHER: 3428adc537dSdyoung case IFT_FDDI: 3438adc537dSdyoung case IFT_ISO88023: 3448adc537dSdyoung case IFT_ISO88024: 3458adc537dSdyoung case IFT_ISO88025: 3468adc537dSdyoung case IFT_ARCNET: 3478adc537dSdyoung return 1; 3488adc537dSdyoung default: 3498adc537dSdyoung return 0; 3508adc537dSdyoung } 3518adc537dSdyoung } 3528adc537dSdyoung 35361f28255Scgd /* 35461f28255Scgd * Delete an arp entry 35561f28255Scgd */ 356c4516a41Schopps int 3574d3d9104Sxtraeme delete(const char *host, const char *info) 35861f28255Scgd { 3594d3d9104Sxtraeme struct sockaddr_inarp *sina; 36040980191Slukem struct rt_msghdr *rtm; 36117c454feSmycroft struct sockaddr_dl *sdl; 36261f28255Scgd 3634d3d9104Sxtraeme sina = &sin_m; 364c4516a41Schopps rtm = &m_rtmsg.m_rtm; 365c4516a41Schopps 36617c454feSmycroft getsocket(); 367c4516a41Schopps sin_m = blank_sin; /* struct copy */ 36840918b5aSseanb if (info && strncmp(info, "pro", 3) == 0) 36940918b5aSseanb sina->sin_other = SIN_PROXY; 3704d3d9104Sxtraeme if (getinetaddr(host, &sina->sin_addr) == -1) 37117c454feSmycroft return (1); 37217c454feSmycroft tryagain: 37317c454feSmycroft if (rtmsg(RTM_GET) < 0) { 374c4516a41Schopps warn("%s", host); 37517c454feSmycroft return (1); 37661f28255Scgd } 3776fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1); 378*af069eb3Schristos sdl = (struct sockaddr_dl *)(void *)(RT_ROUNDUP(sina->sin_len) + 3796fef5d35Schristos (char *)(void *)sina); 3808adc537dSdyoung if (sina->sin_addr.s_addr == sin_m.sin_addr.s_addr && 3818adc537dSdyoung is_llinfo(sdl, rtm->rtm_flags)) 38217c454feSmycroft goto delete; 38317c454feSmycroft if (sin_m.sin_other & SIN_PROXY) { 384c4516a41Schopps warnx("delete: can't locate %s", host); 38517c454feSmycroft return (1); 38617c454feSmycroft } else { 38717c454feSmycroft sin_m.sin_other = SIN_PROXY; 38817c454feSmycroft goto tryagain; 38917c454feSmycroft } 39017c454feSmycroft delete: 39117c454feSmycroft if (sdl->sdl_family != AF_LINK) { 3926fef5d35Schristos (void)warnx("cannot locate %s", host); 39317c454feSmycroft return (1); 39417c454feSmycroft } 395c4516a41Schopps if (rtmsg(RTM_DELETE)) 396c4516a41Schopps return (1); 39792e05e0eSmrg if (vflag) 39892e05e0eSmrg (void)printf("%s (%s) deleted\n", host, 3994d3d9104Sxtraeme inet_ntoa(sina->sin_addr)); 400c4516a41Schopps return (0); 40161f28255Scgd } 40261f28255Scgd 40361f28255Scgd /* 40461f28255Scgd * Dump the entire arp table 40561f28255Scgd */ 406c4516a41Schopps void 4076fef5d35Schristos dump(uint32_t addr) 40861f28255Scgd { 40917c454feSmycroft int mib[6]; 41017c454feSmycroft size_t needed; 4110ea0f71aSfair char ifname[IFNAMSIZ]; 4124d3d9104Sxtraeme char *lim, *buf, *next; 4134d3d9104Sxtraeme const char *host; 41417c454feSmycroft struct rt_msghdr *rtm; 4154d3d9104Sxtraeme struct sockaddr_inarp *sina; 41617c454feSmycroft struct sockaddr_dl *sdl; 41761f28255Scgd struct hostent *hp; 41861f28255Scgd 41917c454feSmycroft mib[0] = CTL_NET; 42017c454feSmycroft mib[1] = PF_ROUTE; 42117c454feSmycroft mib[2] = 0; 42217c454feSmycroft mib[3] = AF_INET; 42317c454feSmycroft mib[4] = NET_RT_FLAGS; 42417c454feSmycroft mib[5] = RTF_LLINFO; 42517c454feSmycroft if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 426c4516a41Schopps err(1, "route-sysctl-estimate"); 4279bef2d1dSfvdl if (needed == 0) 4289bef2d1dSfvdl return; 42917c454feSmycroft if ((buf = malloc(needed)) == NULL) 430c4516a41Schopps err(1, "malloc"); 43117c454feSmycroft if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 432c4516a41Schopps err(1, "actual retrieval of routing table"); 43317c454feSmycroft lim = buf + needed; 43417c454feSmycroft for (next = buf; next < lim; next += rtm->rtm_msglen) { 4356fef5d35Schristos rtm = (struct rt_msghdr *)(void *)next; 4366fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1); 4376fef5d35Schristos sdl = (struct sockaddr_dl *)(void *) 438*af069eb3Schristos (RT_ROUNDUP(sina->sin_len) + (char *)(void *)sina); 43917c454feSmycroft if (addr) { 4404d3d9104Sxtraeme if (addr != sina->sin_addr.s_addr) 44161f28255Scgd continue; 44217c454feSmycroft found_entry = 1; 44317c454feSmycroft } 44417c454feSmycroft if (nflag == 0) 4456fef5d35Schristos hp = gethostbyaddr((const char *)(void *) 4466fef5d35Schristos &(sina->sin_addr), 4474d3d9104Sxtraeme sizeof sina->sin_addr, AF_INET); 44861f28255Scgd else 449f5e60284Schristos hp = NULL; 450f5e60284Schristos 451f5e60284Schristos host = hp ? hp->h_name : "?"; 452f5e60284Schristos 4534d3d9104Sxtraeme (void)printf("%s (%s) at ", host, inet_ntoa(sina->sin_addr)); 45417c454feSmycroft if (sdl->sdl_alen) 45500cef679Sis sdl_print(sdl); 45661f28255Scgd else 457c4516a41Schopps (void)printf("(incomplete)"); 4580ea0f71aSfair 4590ea0f71aSfair if (sdl->sdl_index) { 4604a1c105cSitojun if (getifname(sdl->sdl_index, ifname, sizeof(ifname)) == 0) 4616fef5d35Schristos (void)printf(" on %s", ifname); 4620ea0f71aSfair } 4630ea0f71aSfair 46417c454feSmycroft if (rtm->rtm_rmx.rmx_expire == 0) 465c4516a41Schopps (void)printf(" permanent"); 4664d3d9104Sxtraeme if (sina->sin_other & SIN_PROXY) 467c4516a41Schopps (void)printf(" published (proxy only)"); 46817c454feSmycroft if (rtm->rtm_addrs & RTA_NETMASK) { 4696fef5d35Schristos sina = (struct sockaddr_inarp *)(void *) 470*af069eb3Schristos (RT_ROUNDUP(sdl->sdl_len) + (char *)(void *)sdl); 4714d3d9104Sxtraeme if (sina->sin_addr.s_addr == 0xffffffff) 472c4516a41Schopps (void)printf(" published"); 4734d3d9104Sxtraeme if (sina->sin_len != 8) 4749a18c8bbSerh (void)printf("(weird)"); 47517c454feSmycroft } 476c4516a41Schopps (void)printf("\n"); 47761f28255Scgd } 478c4191f38Sitojun free(buf); 47961f28255Scgd } 48061f28255Scgd 481c0da9e56Satatat /* 482c0da9e56Satatat * Delete the entire arp table 483c0da9e56Satatat */ 484c0da9e56Satatat void 485c0da9e56Satatat delete_all(void) 486c0da9e56Satatat { 487c0da9e56Satatat int mib[6]; 488c0da9e56Satatat size_t needed; 489c0da9e56Satatat char addr[sizeof("000.000.000.000\0")]; 490c0da9e56Satatat char *lim, *buf, *next; 491c0da9e56Satatat struct rt_msghdr *rtm; 4924d3d9104Sxtraeme struct sockaddr_inarp *sina; 493c0da9e56Satatat 494c0da9e56Satatat mib[0] = CTL_NET; 495c0da9e56Satatat mib[1] = PF_ROUTE; 496c0da9e56Satatat mib[2] = 0; 497c0da9e56Satatat mib[3] = AF_INET; 498c0da9e56Satatat mib[4] = NET_RT_FLAGS; 499c0da9e56Satatat mib[5] = RTF_LLINFO; 500c0da9e56Satatat if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 501c0da9e56Satatat err(1, "route-sysctl-estimate"); 502c0da9e56Satatat if (needed == 0) 503c0da9e56Satatat return; 504c0da9e56Satatat if ((buf = malloc(needed)) == NULL) 505c0da9e56Satatat err(1, "malloc"); 506c0da9e56Satatat if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 507c0da9e56Satatat err(1, "actual retrieval of routing table"); 508c0da9e56Satatat lim = buf + needed; 509c0da9e56Satatat for (next = buf; next < lim; next += rtm->rtm_msglen) { 5106fef5d35Schristos rtm = (struct rt_msghdr *)(void *)next; 5116fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1); 5126fef5d35Schristos (void)snprintf(addr, sizeof(addr), "%s", 5136fef5d35Schristos inet_ntoa(sina->sin_addr)); 5146fef5d35Schristos (void)delete(addr, NULL); 515c0da9e56Satatat } 516c4191f38Sitojun free(buf); 517c0da9e56Satatat } 518c0da9e56Satatat 519c4516a41Schopps void 5204d3d9104Sxtraeme sdl_print(const struct sockaddr_dl *sdl) 52161f28255Scgd { 52258777943Sbjh21 char hbuf[NI_MAXHOST]; 52300cef679Sis 5246fef5d35Schristos if (getnameinfo((const struct sockaddr *)(const void *)sdl, 5256fef5d35Schristos (socklen_t)sdl->sdl_len, 52658777943Sbjh21 hbuf, sizeof(hbuf), NULL, 0, NI_NUMERICHOST) != 0) 5276fef5d35Schristos (void)printf("<invalid>"); 52858777943Sbjh21 else 5296fef5d35Schristos (void)printf("%s", hbuf); 53000cef679Sis } 53100cef679Sis 5326fef5d35Schristos static int 5334d3d9104Sxtraeme atosdl(const char *ss, struct sockaddr_dl *sdl) 53400cef679Sis { 53500cef679Sis int i; 5366fef5d35Schristos unsigned long b; 5376fef5d35Schristos char *endp; 5386fef5d35Schristos char *p; 53900cef679Sis char *t, *r; 54000cef679Sis 54100cef679Sis p = LLADDR(sdl); 5426fef5d35Schristos endp = ((char *)(void *)sdl) + sdl->sdl_len; 54300cef679Sis i = 0; 54400cef679Sis 5456fef5d35Schristos b = strtoul(ss, &t, 16); 5466fef5d35Schristos if (b > 255 || t == ss) 54700cef679Sis return 1; 54800cef679Sis 5496fef5d35Schristos *p++ = (char)b; 55000cef679Sis ++i; 55100cef679Sis while ((p < endp) && (*t++ == ':')) { 5526fef5d35Schristos b = strtoul(t, &r, 16); 5536fef5d35Schristos if (b > 255 || r == t) 55400cef679Sis break; 5556fef5d35Schristos *p++ = (char)b; 55600cef679Sis ++i; 55700cef679Sis t = r; 55800cef679Sis } 55900cef679Sis sdl->sdl_alen = i; 56000cef679Sis 56100cef679Sis return 0; 56261f28255Scgd } 56361f28255Scgd 5646fef5d35Schristos static void 5654d3d9104Sxtraeme usage(void) 56661f28255Scgd { 5679da6188fSpooka const char *progname; 5687cbe3d2cSlukem 5699da6188fSpooka progname = getprogname(); 5706fef5d35Schristos (void)fprintf(stderr, "Usage: %s [-n] hostname\n", progname); 5716fef5d35Schristos (void)fprintf(stderr, " %s [-nv] -a\n", progname); 57240918b5aSseanb (void)fprintf(stderr, " %s [-v] -d [-a|hostname [pub [proxy]]]\n", 5736fef5d35Schristos progname); 57440918b5aSseanb (void)fprintf(stderr, " %s -s hostname ether_addr [temp] [pub [proxy]]\n", 5756fef5d35Schristos progname); 5766fef5d35Schristos (void)fprintf(stderr, " %s -f filename\n", progname); 57761f28255Scgd exit(1); 57861f28255Scgd } 57917c454feSmycroft 5806fef5d35Schristos static int 5814d3d9104Sxtraeme rtmsg(int cmd) 58217c454feSmycroft { 58317c454feSmycroft static int seq; 58440980191Slukem struct rt_msghdr *rtm; 58540980191Slukem char *cp; 58640980191Slukem int l; 58717c454feSmycroft 588c4516a41Schopps rtm = &m_rtmsg.m_rtm; 589c4516a41Schopps cp = m_rtmsg.m_space; 59017c454feSmycroft errno = 0; 591c4516a41Schopps 59217c454feSmycroft if (cmd == RTM_DELETE) 59317c454feSmycroft goto doit; 594c4516a41Schopps (void)memset(&m_rtmsg, 0, sizeof(m_rtmsg)); 59517c454feSmycroft rtm->rtm_flags = flags; 59617c454feSmycroft rtm->rtm_version = RTM_VERSION; 59717c454feSmycroft 59817c454feSmycroft switch (cmd) { 59917c454feSmycroft default: 600c4516a41Schopps errx(1, "internal wrong cmd"); 601c4516a41Schopps /*NOTREACHED*/ 60217c454feSmycroft case RTM_ADD: 60317c454feSmycroft rtm->rtm_addrs |= RTA_GATEWAY; 60417c454feSmycroft rtm->rtm_rmx.rmx_expire = expire_time; 60517c454feSmycroft rtm->rtm_inits = RTV_EXPIRE; 60617c454feSmycroft rtm->rtm_flags |= (RTF_HOST | RTF_STATIC); 60717c454feSmycroft sin_m.sin_other = 0; 60817c454feSmycroft if (doing_proxy) { 60917c454feSmycroft if (export_only) 61017c454feSmycroft sin_m.sin_other = SIN_PROXY; 61117c454feSmycroft else { 61217c454feSmycroft rtm->rtm_addrs |= RTA_NETMASK; 61317c454feSmycroft rtm->rtm_flags &= ~RTF_HOST; 61417c454feSmycroft } 61517c454feSmycroft } 61617c454feSmycroft /* FALLTHROUGH */ 61717c454feSmycroft case RTM_GET: 61817c454feSmycroft rtm->rtm_addrs |= RTA_DST; 61917c454feSmycroft } 6209a18c8bbSerh 62117c454feSmycroft #define NEXTADDR(w, s) \ 62217c454feSmycroft if (rtm->rtm_addrs & (w)) { \ 6236fef5d35Schristos (void)memcpy(cp, &s, \ 6246fef5d35Schristos (size_t)((struct sockaddr *)(void *)&s)->sa_len); \ 625*af069eb3Schristos RT_ADVANCE(cp, ((struct sockaddr *)(void *)&s)); \ 6269a18c8bbSerh } 62717c454feSmycroft 62817c454feSmycroft NEXTADDR(RTA_DST, sin_m); 62917c454feSmycroft NEXTADDR(RTA_GATEWAY, sdl_m); 63017c454feSmycroft NEXTADDR(RTA_NETMASK, so_mask); 63117c454feSmycroft 6326fef5d35Schristos rtm->rtm_msglen = cp - (char *)(void *)&m_rtmsg; 63317c454feSmycroft doit: 63417c454feSmycroft l = rtm->rtm_msglen; 63517c454feSmycroft rtm->rtm_seq = ++seq; 63617c454feSmycroft rtm->rtm_type = cmd; 6376fef5d35Schristos if (write(s, &m_rtmsg, (size_t)l) < 0) { 63817c454feSmycroft if (errno != ESRCH || cmd != RTM_DELETE) { 639c4516a41Schopps warn("writing to routing socket"); 64017c454feSmycroft return (-1); 64117c454feSmycroft } 64217c454feSmycroft } 64317c454feSmycroft do { 6446fef5d35Schristos l = read(s, &m_rtmsg, sizeof(m_rtmsg)); 64517c454feSmycroft } while (l > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid)); 64617c454feSmycroft if (l < 0) 647c4516a41Schopps warn("read from routing socket"); 64817c454feSmycroft return (0); 64917c454feSmycroft } 65017c454feSmycroft 6516fef5d35Schristos static int 6524d3d9104Sxtraeme getinetaddr(const char *host, struct in_addr *inap) 65317c454feSmycroft { 654c4516a41Schopps struct hostent *hp; 655c4516a41Schopps 6569a1b7b98Schopps if (inet_aton(host, inap) == 1) 657c4516a41Schopps return (0); 658c4516a41Schopps if ((hp = gethostbyname(host)) == NULL) { 6592df1fdaaSchs warnx("%s: %s", host, hstrerror(h_errno)); 660c4516a41Schopps return (-1); 661c4516a41Schopps } 662c4516a41Schopps (void)memcpy(inap, hp->h_addr, sizeof(*inap)); 663c4516a41Schopps return (0); 66417c454feSmycroft } 6650ea0f71aSfair 6666fef5d35Schristos static int 6674d3d9104Sxtraeme getifname(u_int16_t ifindex, char *ifname, size_t l) 6680ea0f71aSfair { 669ecf05965Srafal int i; 670ecf05965Srafal struct ifaddrs *addr; 6710ea0f71aSfair const struct sockaddr_dl *sdl = NULL; 6720ea0f71aSfair 673ecf05965Srafal if (ifaddrs == NULL) { 674ecf05965Srafal i = getifaddrs(&ifaddrs); 675ecf05965Srafal if (i != 0) 676ecf05965Srafal err(1, "getifaddrs"); 6770ea0f71aSfair } 6780ea0f71aSfair 679ecf05965Srafal for (addr = ifaddrs; addr; addr = addr->ifa_next) { 680ecf05965Srafal if (addr->ifa_addr == NULL || 681ecf05965Srafal addr->ifa_addr->sa_family != AF_LINK) 6820ea0f71aSfair continue; 6830ea0f71aSfair 6846fef5d35Schristos sdl = (const struct sockaddr_dl *)(void *)addr->ifa_addr; 6850ea0f71aSfair if (sdl && sdl->sdl_index == ifindex) { 6864a1c105cSitojun (void) strlcpy(ifname, addr->ifa_name, l); 6870ea0f71aSfair return 0; 6880ea0f71aSfair } 6890ea0f71aSfair } 6900ea0f71aSfair 6910ea0f71aSfair return -1; 6920ea0f71aSfair } 693