1*018518e2Sozaki-r /* $NetBSD: arp.c,v 1.52 2015/07/29 06:07:35 ozaki-r 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*018518e2Sozaki-r __RCSID("$NetBSD: arp.c,v 1.52 2015/07/29 06:07:35 ozaki-r 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 79*018518e2Sozaki-r #include "prog_ops.h" 80*018518e2Sozaki-r 818adc537dSdyoung static int is_llinfo(const struct sockaddr_dl *, int); 826fef5d35Schristos static int delete(const char *, const char *); 836fef5d35Schristos static void dump(uint32_t); 846fef5d35Schristos static void delete_all(void); 856fef5d35Schristos static void sdl_print(const struct sockaddr_dl *); 866fef5d35Schristos static int getifname(u_int16_t, char *, size_t); 876fef5d35Schristos static int atosdl(const char *s, struct sockaddr_dl *sdl); 886fef5d35Schristos static int file(const char *); 896fef5d35Schristos static void get(const char *); 906fef5d35Schristos static int getinetaddr(const char *, struct in_addr *); 916fef5d35Schristos static void getsocket(void); 926fef5d35Schristos static int rtmsg(int); 936fef5d35Schristos static int set(int, char **); 948b0f9554Sperry static void usage(void) __dead; 9500cef679Sis 966fef5d35Schristos static pid_t pid; 97c0da9e56Satatat static int aflag, nflag, vflag; 9838e37321Smikel static int s = -1; 99ecf05965Srafal static struct ifaddrs* ifaddrs = NULL; 1006fef5d35Schristos static struct sockaddr_in so_mask = { 1016fef5d35Schristos .sin_len = 8, 1026fef5d35Schristos .sin_addr = { 1036fef5d35Schristos .s_addr = 0xffffffff 1046fef5d35Schristos } 1056fef5d35Schristos }; 1066fef5d35Schristos static struct sockaddr_inarp blank_sin = { 1076fef5d35Schristos .sin_len = sizeof(blank_sin), 1086fef5d35Schristos .sin_family = AF_INET 1096fef5d35Schristos }; 1106fef5d35Schristos static struct sockaddr_inarp sin_m; 1116fef5d35Schristos static struct sockaddr_dl blank_sdl = { 1126fef5d35Schristos .sdl_len = sizeof(blank_sdl), 1136fef5d35Schristos .sdl_family = AF_LINK 1146fef5d35Schristos }; 1156fef5d35Schristos static struct sockaddr_dl sdl_m; 1166fef5d35Schristos 1176fef5d35Schristos static int expire_time, flags, export_only, doing_proxy, found_entry; 1186fef5d35Schristos static struct { 1196fef5d35Schristos struct rt_msghdr m_rtm; 1206fef5d35Schristos char m_space[512]; 1216fef5d35Schristos } m_rtmsg; 12238e37321Smikel 123c4516a41Schopps int 1244d3d9104Sxtraeme main(int argc, char **argv) 12561f28255Scgd { 12661f28255Scgd int ch; 127f3b151f5Smikel int op = 0; 12861f28255Scgd 129eda273b9Stv setprogname(argv[0]); 130eda273b9Stv 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 158*018518e2Sozaki-r if (prog_init && prog_init() == -1) 159*018518e2Sozaki-r err(1, "init failed"); 160*018518e2Sozaki-r 161*018518e2Sozaki-r pid = prog_getpid(); 162*018518e2Sozaki-r 163f3b151f5Smikel switch((char)op) { 164f3b151f5Smikel case 'a': 165f3b151f5Smikel dump(0); 166f3b151f5Smikel break; 167f3b151f5Smikel case 'd': 168c0da9e56Satatat if (aflag && argc == 0) 169c0da9e56Satatat delete_all(); 170c0da9e56Satatat else { 171c0da9e56Satatat if (aflag || argc < 1 || argc > 2) 17261f28255Scgd usage(); 173f3b151f5Smikel (void)delete(argv[0], argv[1]); 174c0da9e56Satatat } 175f3b151f5Smikel break; 176f3b151f5Smikel case 's': 1778f2efeecSchristos if (argc < 2 || argc > 7) 178f3b151f5Smikel usage(); 179f3b151f5Smikel return (set(argc, argv) ? 1 : 0); 180f3b151f5Smikel case 'f': 181f3b151f5Smikel if (argc != 1) 182f3b151f5Smikel usage(); 183f3b151f5Smikel return (file(argv[0])); 184f3b151f5Smikel default: 185f3b151f5Smikel if (argc != 1) 186f3b151f5Smikel usage(); 187f3b151f5Smikel get(argv[0]); 188f3b151f5Smikel break; 189f3b151f5Smikel } 190c4516a41Schopps return (0); 19161f28255Scgd } 19261f28255Scgd 19361f28255Scgd /* 19461f28255Scgd * Process a file to set standard arp entries 19561f28255Scgd */ 1966fef5d35Schristos static int 1976fef5d35Schristos file(const char *name) 19861f28255Scgd { 1996fef5d35Schristos char *line, *argv[5]; 200c4516a41Schopps int i, retval; 201c4516a41Schopps FILE *fp; 20261f28255Scgd 2036ea002c7Sdholland if (!strcmp(name, "-")) { 2046ea002c7Sdholland fp = stdin; 2056ea002c7Sdholland } else { 2066ea002c7Sdholland fp = fopen(name, "r"); 2076ea002c7Sdholland if (fp == NULL) { 2086ea002c7Sdholland err(1, "Cannot open %s", name); 2096ea002c7Sdholland } 2106ea002c7Sdholland } 21161f28255Scgd retval = 0; 2126fef5d35Schristos for (; (line = fparseln(fp, NULL, NULL, NULL, 0)) != NULL; free(line)) { 2136fef5d35Schristos char **ap, *inputstring; 2146fef5d35Schristos 2156fef5d35Schristos inputstring = line; 2166fef5d35Schristos for (ap = argv; ap < &argv[sizeof(argv) / sizeof(argv[0])] && 2176fef5d35Schristos (*ap = stresep(&inputstring, " \t", '\\')) != NULL;) { 2186fef5d35Schristos if (**ap != '\0') 2196fef5d35Schristos ap++; 2206fef5d35Schristos } 2216fef5d35Schristos i = ap - argv; 22261f28255Scgd if (i < 2) { 223c4516a41Schopps warnx("bad line: %s", line); 22461f28255Scgd retval = 1; 22561f28255Scgd continue; 22661f28255Scgd } 2276fef5d35Schristos if (set(i, argv)) 22861f28255Scgd retval = 1; 22961f28255Scgd } 2306ea002c7Sdholland if (fp != stdin) 2316fef5d35Schristos (void)fclose(fp); 2326fef5d35Schristos return retval; 23361f28255Scgd } 23461f28255Scgd 2356fef5d35Schristos static void 2364d3d9104Sxtraeme getsocket(void) 237c4516a41Schopps { 238c4516a41Schopps if (s >= 0) 239c4516a41Schopps return; 240*018518e2Sozaki-r s = prog_socket(PF_ROUTE, SOCK_RAW, 0); 241c4516a41Schopps if (s < 0) 242c4516a41Schopps err(1, "socket"); 24317c454feSmycroft } 24417c454feSmycroft 245e17012b1Schristos static int 246e17012b1Schristos getlink(const char *name, struct sockaddr_dl *sdl) 247e17012b1Schristos { 248e17012b1Schristos struct ifaddrs *ifap, *ifa; 249e17012b1Schristos 250e17012b1Schristos if (getifaddrs(&ifap) != 0) { 251e17012b1Schristos warn("getifaddrs"); 252e17012b1Schristos return 0; 253e17012b1Schristos } 254e17012b1Schristos 255e17012b1Schristos for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 256e17012b1Schristos if (ifa->ifa_addr->sa_family != AF_LINK) 257e17012b1Schristos continue; 258e17012b1Schristos if (strcmp(ifa->ifa_name, name) != 0) 259e17012b1Schristos continue; 260e17012b1Schristos memcpy(sdl, ifa->ifa_addr, sizeof(*sdl)); 261e17012b1Schristos freeifaddrs(ifap); 262e17012b1Schristos return 1; 263e17012b1Schristos } 264e17012b1Schristos freeifaddrs(ifap); 265e17012b1Schristos return 0; 266e17012b1Schristos } 267e17012b1Schristos 26861f28255Scgd /* 26961f28255Scgd * Set an individual arp entry 27061f28255Scgd */ 2716fef5d35Schristos static int 2724d3d9104Sxtraeme set(int argc, char **argv) 27361f28255Scgd { 2744d3d9104Sxtraeme struct sockaddr_inarp *sina; 27540980191Slukem struct sockaddr_dl *sdl; 27640980191Slukem struct rt_msghdr *rtm; 277c4516a41Schopps char *host = argv[0], *eaddr; 27892e05e0eSmrg int rval; 279c4516a41Schopps 2804d3d9104Sxtraeme sina = &sin_m; 281c4516a41Schopps rtm = &(m_rtmsg.m_rtm); 282c4516a41Schopps eaddr = argv[1]; 28361f28255Scgd 28417c454feSmycroft getsocket(); 28561f28255Scgd argc -= 2; 28661f28255Scgd argv += 2; 287c4516a41Schopps sdl_m = blank_sdl; /* struct copy */ 288c4516a41Schopps sin_m = blank_sin; /* struct copy */ 2894d3d9104Sxtraeme if (getinetaddr(host, &sina->sin_addr) == -1) 29061f28255Scgd return (1); 29100cef679Sis if (atosdl(eaddr, &sdl_m)) 29200cef679Sis warnx("invalid link-level address '%s'", eaddr); 29317c454feSmycroft doing_proxy = flags = export_only = expire_time = 0; 294e17012b1Schristos for (; argc-- > 0; argv++) { 29517c454feSmycroft if (strncmp(argv[0], "temp", 4) == 0) { 2964d3d9104Sxtraeme struct timeval timev; 2974d3d9104Sxtraeme (void)gettimeofday(&timev, 0); 2984d3d9104Sxtraeme expire_time = timev.tv_sec + 20 * 60; 29917c454feSmycroft } 30017c454feSmycroft else if (strncmp(argv[0], "pub", 3) == 0) { 30117c454feSmycroft flags |= RTF_ANNOUNCE; 30217c454feSmycroft doing_proxy = SIN_PROXY; 30340918b5aSseanb if (argc && strncmp(argv[1], "pro", 3) == 0) { 30440918b5aSseanb export_only = 1; 30540918b5aSseanb argc--; argv++; 30640918b5aSseanb } 30717c454feSmycroft } else if (strncmp(argv[0], "trail", 5) == 0) { 3086fef5d35Schristos warnx("%s: Sending trailers is no longer supported", 30917c454feSmycroft host); 310e17012b1Schristos } else if (strcmp(argv[0], "ifscope") == 0) { 311e17012b1Schristos if (argc == 0) { 312e17012b1Schristos warnx("missing interface for ifscope"); 313e17012b1Schristos continue; 31417c454feSmycroft } 315e17012b1Schristos argc--; 31661f28255Scgd argv++; 317e17012b1Schristos if (!getlink(argv[0], &sdl_m)) 318e17012b1Schristos warnx("cannot get link address for %s", argv[0]); 31961f28255Scgd } 320e17012b1Schristos 321e17012b1Schristos } 322e17012b1Schristos if (memcmp(&sdl_m, &blank_sdl, sizeof(blank_sdl))) 323e17012b1Schristos goto out; 32417c454feSmycroft tryagain: 32517c454feSmycroft if (rtmsg(RTM_GET) < 0) { 326c4516a41Schopps warn("%s", host); 32717c454feSmycroft return (1); 32861f28255Scgd } 3296fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1); 330af069eb3Schristos sdl = (struct sockaddr_dl *)(void *)(RT_ROUNDUP(sina->sin_len) + 3316fef5d35Schristos (char *)(void *)sina); 3324d3d9104Sxtraeme if (sina->sin_addr.s_addr == sin_m.sin_addr.s_addr) { 3338adc537dSdyoung if (is_llinfo(sdl, rtm->rtm_flags)) 33417c454feSmycroft goto overwrite; 33517c454feSmycroft if (doing_proxy == 0) { 3366fef5d35Schristos warnx("set: can only proxy for %s", host); 33717c454feSmycroft return (1); 33817c454feSmycroft } 33917c454feSmycroft if (sin_m.sin_other & SIN_PROXY) { 3406fef5d35Schristos warnx("set: proxy entry exists for non 802 device"); 34117c454feSmycroft return (1); 34217c454feSmycroft } 34317c454feSmycroft sin_m.sin_other = SIN_PROXY; 34417c454feSmycroft export_only = 1; 34517c454feSmycroft goto tryagain; 34617c454feSmycroft } 34717c454feSmycroft overwrite: 34817c454feSmycroft if (sdl->sdl_family != AF_LINK) { 3496fef5d35Schristos warnx("cannot intuit interface index and type for %s", 350c4516a41Schopps host); 35117c454feSmycroft return (1); 35217c454feSmycroft } 35317c454feSmycroft sdl_m.sdl_type = sdl->sdl_type; 35417c454feSmycroft sdl_m.sdl_index = sdl->sdl_index; 355e17012b1Schristos out: 35692e05e0eSmrg rval = rtmsg(RTM_ADD); 35792e05e0eSmrg if (vflag) 35892e05e0eSmrg (void)printf("%s (%s) added\n", host, eaddr); 35992e05e0eSmrg return (rval); 36061f28255Scgd } 36161f28255Scgd 36261f28255Scgd /* 36361f28255Scgd * Display an individual arp entry 36461f28255Scgd */ 3656fef5d35Schristos static void 3664d3d9104Sxtraeme get(const char *host) 36761f28255Scgd { 3684d3d9104Sxtraeme struct sockaddr_inarp *sina; 36961f28255Scgd 3704d3d9104Sxtraeme sina = &sin_m; 371c4516a41Schopps sin_m = blank_sin; /* struct copy */ 3724d3d9104Sxtraeme if (getinetaddr(host, &sina->sin_addr) == -1) 37361f28255Scgd exit(1); 3744d3d9104Sxtraeme dump(sina->sin_addr.s_addr); 3756fef5d35Schristos if (found_entry == 0) 3766fef5d35Schristos errx(1, "%s (%s) -- no entry", host, inet_ntoa(sina->sin_addr)); 37761f28255Scgd } 37861f28255Scgd 3798adc537dSdyoung 3808adc537dSdyoung static int 3818adc537dSdyoung is_llinfo(const struct sockaddr_dl *sdl, int rtflags) 3828adc537dSdyoung { 3838adc537dSdyoung if (sdl->sdl_family != AF_LINK || 3848adc537dSdyoung (rtflags & (RTF_LLINFO|RTF_GATEWAY)) != RTF_LLINFO) 3858adc537dSdyoung return 0; 3868adc537dSdyoung 3878adc537dSdyoung switch (sdl->sdl_type) { 3888adc537dSdyoung case IFT_ETHER: 3898adc537dSdyoung case IFT_FDDI: 3908adc537dSdyoung case IFT_ISO88023: 3918adc537dSdyoung case IFT_ISO88024: 3928adc537dSdyoung case IFT_ISO88025: 3938adc537dSdyoung case IFT_ARCNET: 3948adc537dSdyoung return 1; 3958adc537dSdyoung default: 3968adc537dSdyoung return 0; 3978adc537dSdyoung } 3988adc537dSdyoung } 3998adc537dSdyoung 40061f28255Scgd /* 40161f28255Scgd * Delete an arp entry 40261f28255Scgd */ 403c4516a41Schopps int 4044d3d9104Sxtraeme delete(const char *host, const char *info) 40561f28255Scgd { 4064d3d9104Sxtraeme struct sockaddr_inarp *sina; 40740980191Slukem struct rt_msghdr *rtm; 40817c454feSmycroft struct sockaddr_dl *sdl; 40961f28255Scgd 4104d3d9104Sxtraeme sina = &sin_m; 411c4516a41Schopps rtm = &m_rtmsg.m_rtm; 412c4516a41Schopps 41317c454feSmycroft getsocket(); 414c4516a41Schopps sin_m = blank_sin; /* struct copy */ 41540918b5aSseanb if (info && strncmp(info, "pro", 3) == 0) 41640918b5aSseanb sina->sin_other = SIN_PROXY; 4174d3d9104Sxtraeme if (getinetaddr(host, &sina->sin_addr) == -1) 41817c454feSmycroft return (1); 41917c454feSmycroft tryagain: 42017c454feSmycroft if (rtmsg(RTM_GET) < 0) { 421c4516a41Schopps warn("%s", host); 42217c454feSmycroft return (1); 42361f28255Scgd } 4246fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1); 425af069eb3Schristos sdl = (struct sockaddr_dl *)(void *)(RT_ROUNDUP(sina->sin_len) + 4266fef5d35Schristos (char *)(void *)sina); 4278adc537dSdyoung if (sina->sin_addr.s_addr == sin_m.sin_addr.s_addr && 4288adc537dSdyoung is_llinfo(sdl, rtm->rtm_flags)) 42917c454feSmycroft goto delete; 43017c454feSmycroft if (sin_m.sin_other & SIN_PROXY) { 431c4516a41Schopps warnx("delete: can't locate %s", host); 43217c454feSmycroft return (1); 43317c454feSmycroft } else { 43417c454feSmycroft sin_m.sin_other = SIN_PROXY; 43517c454feSmycroft goto tryagain; 43617c454feSmycroft } 43717c454feSmycroft delete: 43817c454feSmycroft if (sdl->sdl_family != AF_LINK) { 4396fef5d35Schristos (void)warnx("cannot locate %s", host); 44017c454feSmycroft return (1); 44117c454feSmycroft } 442c4516a41Schopps if (rtmsg(RTM_DELETE)) 443c4516a41Schopps return (1); 44492e05e0eSmrg if (vflag) 44592e05e0eSmrg (void)printf("%s (%s) deleted\n", host, 4464d3d9104Sxtraeme inet_ntoa(sina->sin_addr)); 447c4516a41Schopps return (0); 44861f28255Scgd } 44961f28255Scgd 45061f28255Scgd /* 45161f28255Scgd * Dump the entire arp table 45261f28255Scgd */ 453c4516a41Schopps void 4546fef5d35Schristos dump(uint32_t addr) 45561f28255Scgd { 45617c454feSmycroft int mib[6]; 45717c454feSmycroft size_t needed; 4580ea0f71aSfair char ifname[IFNAMSIZ]; 4594d3d9104Sxtraeme char *lim, *buf, *next; 4604d3d9104Sxtraeme const char *host; 46117c454feSmycroft struct rt_msghdr *rtm; 4624d3d9104Sxtraeme struct sockaddr_inarp *sina; 46317c454feSmycroft struct sockaddr_dl *sdl; 46461f28255Scgd struct hostent *hp; 46561f28255Scgd 46617c454feSmycroft mib[0] = CTL_NET; 46717c454feSmycroft mib[1] = PF_ROUTE; 46817c454feSmycroft mib[2] = 0; 46917c454feSmycroft mib[3] = AF_INET; 47017c454feSmycroft mib[4] = NET_RT_FLAGS; 47117c454feSmycroft mib[5] = RTF_LLINFO; 472*018518e2Sozaki-r if (prog_sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 473c4516a41Schopps err(1, "route-sysctl-estimate"); 4749bef2d1dSfvdl if (needed == 0) 4759bef2d1dSfvdl return; 47617c454feSmycroft if ((buf = malloc(needed)) == NULL) 477c4516a41Schopps err(1, "malloc"); 478*018518e2Sozaki-r if (prog_sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 479c4516a41Schopps err(1, "actual retrieval of routing table"); 48017c454feSmycroft lim = buf + needed; 48117c454feSmycroft for (next = buf; next < lim; next += rtm->rtm_msglen) { 4826fef5d35Schristos rtm = (struct rt_msghdr *)(void *)next; 4836fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1); 4846fef5d35Schristos sdl = (struct sockaddr_dl *)(void *) 485af069eb3Schristos (RT_ROUNDUP(sina->sin_len) + (char *)(void *)sina); 48617c454feSmycroft if (addr) { 4874d3d9104Sxtraeme if (addr != sina->sin_addr.s_addr) 48861f28255Scgd continue; 48917c454feSmycroft found_entry = 1; 49017c454feSmycroft } 49117c454feSmycroft if (nflag == 0) 4926fef5d35Schristos hp = gethostbyaddr((const char *)(void *) 4936fef5d35Schristos &(sina->sin_addr), 4944d3d9104Sxtraeme sizeof sina->sin_addr, AF_INET); 49561f28255Scgd else 496f5e60284Schristos hp = NULL; 497f5e60284Schristos 498f5e60284Schristos host = hp ? hp->h_name : "?"; 499f5e60284Schristos 5004d3d9104Sxtraeme (void)printf("%s (%s) at ", host, inet_ntoa(sina->sin_addr)); 50117c454feSmycroft if (sdl->sdl_alen) 50200cef679Sis sdl_print(sdl); 50361f28255Scgd else 504c4516a41Schopps (void)printf("(incomplete)"); 5050ea0f71aSfair 5060ea0f71aSfair if (sdl->sdl_index) { 5074a1c105cSitojun if (getifname(sdl->sdl_index, ifname, sizeof(ifname)) == 0) 5086fef5d35Schristos (void)printf(" on %s", ifname); 5090ea0f71aSfair } 5100ea0f71aSfair 51117c454feSmycroft if (rtm->rtm_rmx.rmx_expire == 0) 512c4516a41Schopps (void)printf(" permanent"); 5134d3d9104Sxtraeme if (sina->sin_other & SIN_PROXY) 514c4516a41Schopps (void)printf(" published (proxy only)"); 51517c454feSmycroft if (rtm->rtm_addrs & RTA_NETMASK) { 5166fef5d35Schristos sina = (struct sockaddr_inarp *)(void *) 517af069eb3Schristos (RT_ROUNDUP(sdl->sdl_len) + (char *)(void *)sdl); 5184d3d9104Sxtraeme if (sina->sin_addr.s_addr == 0xffffffff) 519c4516a41Schopps (void)printf(" published"); 5204d3d9104Sxtraeme if (sina->sin_len != 8) 5219a18c8bbSerh (void)printf("(weird)"); 52217c454feSmycroft } 523c4516a41Schopps (void)printf("\n"); 52461f28255Scgd } 525c4191f38Sitojun free(buf); 52661f28255Scgd } 52761f28255Scgd 528c0da9e56Satatat /* 529c0da9e56Satatat * Delete the entire arp table 530c0da9e56Satatat */ 531c0da9e56Satatat void 532c0da9e56Satatat delete_all(void) 533c0da9e56Satatat { 534c0da9e56Satatat int mib[6]; 535c0da9e56Satatat size_t needed; 536c0da9e56Satatat char addr[sizeof("000.000.000.000\0")]; 537c0da9e56Satatat char *lim, *buf, *next; 538c0da9e56Satatat struct rt_msghdr *rtm; 5394d3d9104Sxtraeme struct sockaddr_inarp *sina; 540c0da9e56Satatat 541c0da9e56Satatat mib[0] = CTL_NET; 542c0da9e56Satatat mib[1] = PF_ROUTE; 543c0da9e56Satatat mib[2] = 0; 544c0da9e56Satatat mib[3] = AF_INET; 545c0da9e56Satatat mib[4] = NET_RT_FLAGS; 546c0da9e56Satatat mib[5] = RTF_LLINFO; 547*018518e2Sozaki-r if (prog_sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 548c0da9e56Satatat err(1, "route-sysctl-estimate"); 549c0da9e56Satatat if (needed == 0) 550c0da9e56Satatat return; 551c0da9e56Satatat if ((buf = malloc(needed)) == NULL) 552c0da9e56Satatat err(1, "malloc"); 553*018518e2Sozaki-r if (prog_sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 554c0da9e56Satatat err(1, "actual retrieval of routing table"); 555c0da9e56Satatat lim = buf + needed; 556c0da9e56Satatat for (next = buf; next < lim; next += rtm->rtm_msglen) { 5576fef5d35Schristos rtm = (struct rt_msghdr *)(void *)next; 5586fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1); 5596fef5d35Schristos (void)snprintf(addr, sizeof(addr), "%s", 5606fef5d35Schristos inet_ntoa(sina->sin_addr)); 5616fef5d35Schristos (void)delete(addr, NULL); 562c0da9e56Satatat } 563c4191f38Sitojun free(buf); 564c0da9e56Satatat } 565c0da9e56Satatat 566c4516a41Schopps void 5674d3d9104Sxtraeme sdl_print(const struct sockaddr_dl *sdl) 56861f28255Scgd { 56958777943Sbjh21 char hbuf[NI_MAXHOST]; 57000cef679Sis 5716fef5d35Schristos if (getnameinfo((const struct sockaddr *)(const void *)sdl, 5726fef5d35Schristos (socklen_t)sdl->sdl_len, 57358777943Sbjh21 hbuf, sizeof(hbuf), NULL, 0, NI_NUMERICHOST) != 0) 5746fef5d35Schristos (void)printf("<invalid>"); 57558777943Sbjh21 else 5766fef5d35Schristos (void)printf("%s", hbuf); 57700cef679Sis } 57800cef679Sis 5796fef5d35Schristos static int 5804d3d9104Sxtraeme atosdl(const char *ss, struct sockaddr_dl *sdl) 58100cef679Sis { 58200cef679Sis int i; 5836fef5d35Schristos unsigned long b; 5846fef5d35Schristos char *endp; 5856fef5d35Schristos char *p; 58600cef679Sis char *t, *r; 58700cef679Sis 58800cef679Sis p = LLADDR(sdl); 5896fef5d35Schristos endp = ((char *)(void *)sdl) + sdl->sdl_len; 59000cef679Sis i = 0; 59100cef679Sis 5926fef5d35Schristos b = strtoul(ss, &t, 16); 5936fef5d35Schristos if (b > 255 || t == ss) 59400cef679Sis return 1; 59500cef679Sis 5966fef5d35Schristos *p++ = (char)b; 59700cef679Sis ++i; 59800cef679Sis while ((p < endp) && (*t++ == ':')) { 5996fef5d35Schristos b = strtoul(t, &r, 16); 6006fef5d35Schristos if (b > 255 || r == t) 60100cef679Sis break; 6026fef5d35Schristos *p++ = (char)b; 60300cef679Sis ++i; 60400cef679Sis t = r; 60500cef679Sis } 60600cef679Sis sdl->sdl_alen = i; 60700cef679Sis 60800cef679Sis return 0; 60961f28255Scgd } 61061f28255Scgd 6116fef5d35Schristos static void 6124d3d9104Sxtraeme usage(void) 61361f28255Scgd { 6149da6188fSpooka const char *progname; 6157cbe3d2cSlukem 6169da6188fSpooka progname = getprogname(); 6176fef5d35Schristos (void)fprintf(stderr, "Usage: %s [-n] hostname\n", progname); 6186fef5d35Schristos (void)fprintf(stderr, " %s [-nv] -a\n", progname); 61940918b5aSseanb (void)fprintf(stderr, " %s [-v] -d [-a|hostname [pub [proxy]]]\n", 6206fef5d35Schristos progname); 62140918b5aSseanb (void)fprintf(stderr, " %s -s hostname ether_addr [temp] [pub [proxy]]\n", 6226fef5d35Schristos progname); 6236fef5d35Schristos (void)fprintf(stderr, " %s -f filename\n", progname); 62461f28255Scgd exit(1); 62561f28255Scgd } 62617c454feSmycroft 6276fef5d35Schristos static int 6284d3d9104Sxtraeme rtmsg(int cmd) 62917c454feSmycroft { 63017c454feSmycroft static int seq; 63140980191Slukem struct rt_msghdr *rtm; 63240980191Slukem char *cp; 63340980191Slukem int l; 63417c454feSmycroft 635c4516a41Schopps rtm = &m_rtmsg.m_rtm; 636c4516a41Schopps cp = m_rtmsg.m_space; 63717c454feSmycroft errno = 0; 638c4516a41Schopps 63917c454feSmycroft if (cmd == RTM_DELETE) 64017c454feSmycroft goto doit; 641c4516a41Schopps (void)memset(&m_rtmsg, 0, sizeof(m_rtmsg)); 64217c454feSmycroft rtm->rtm_flags = flags; 64317c454feSmycroft rtm->rtm_version = RTM_VERSION; 64417c454feSmycroft 64517c454feSmycroft switch (cmd) { 64617c454feSmycroft default: 647c4516a41Schopps errx(1, "internal wrong cmd"); 648c4516a41Schopps /*NOTREACHED*/ 64917c454feSmycroft case RTM_ADD: 65017c454feSmycroft rtm->rtm_addrs |= RTA_GATEWAY; 65117c454feSmycroft rtm->rtm_rmx.rmx_expire = expire_time; 65217c454feSmycroft rtm->rtm_inits = RTV_EXPIRE; 65317c454feSmycroft rtm->rtm_flags |= (RTF_HOST | RTF_STATIC); 65417c454feSmycroft sin_m.sin_other = 0; 65517c454feSmycroft if (doing_proxy) { 65617c454feSmycroft if (export_only) 65717c454feSmycroft sin_m.sin_other = SIN_PROXY; 65817c454feSmycroft else { 65917c454feSmycroft rtm->rtm_addrs |= RTA_NETMASK; 66017c454feSmycroft rtm->rtm_flags &= ~RTF_HOST; 66117c454feSmycroft } 66217c454feSmycroft } 66317c454feSmycroft /* FALLTHROUGH */ 66417c454feSmycroft case RTM_GET: 66517c454feSmycroft rtm->rtm_addrs |= RTA_DST; 66617c454feSmycroft } 6679a18c8bbSerh 66817c454feSmycroft #define NEXTADDR(w, s) \ 66917c454feSmycroft if (rtm->rtm_addrs & (w)) { \ 6706fef5d35Schristos (void)memcpy(cp, &s, \ 6716fef5d35Schristos (size_t)((struct sockaddr *)(void *)&s)->sa_len); \ 672af069eb3Schristos RT_ADVANCE(cp, ((struct sockaddr *)(void *)&s)); \ 6739a18c8bbSerh } 67417c454feSmycroft 67517c454feSmycroft NEXTADDR(RTA_DST, sin_m); 67617c454feSmycroft NEXTADDR(RTA_GATEWAY, sdl_m); 67717c454feSmycroft NEXTADDR(RTA_NETMASK, so_mask); 67817c454feSmycroft 6796fef5d35Schristos rtm->rtm_msglen = cp - (char *)(void *)&m_rtmsg; 68017c454feSmycroft doit: 68117c454feSmycroft l = rtm->rtm_msglen; 68217c454feSmycroft rtm->rtm_seq = ++seq; 68317c454feSmycroft rtm->rtm_type = cmd; 684*018518e2Sozaki-r if (prog_write(s, &m_rtmsg, (size_t)l) < 0) { 68517c454feSmycroft if (errno != ESRCH || cmd != RTM_DELETE) { 686c4516a41Schopps warn("writing to routing socket"); 68717c454feSmycroft return (-1); 68817c454feSmycroft } 68917c454feSmycroft } 69017c454feSmycroft do { 691*018518e2Sozaki-r l = prog_read(s, &m_rtmsg, sizeof(m_rtmsg)); 69217c454feSmycroft } while (l > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid)); 69317c454feSmycroft if (l < 0) 694c4516a41Schopps warn("read from routing socket"); 69517c454feSmycroft return (0); 69617c454feSmycroft } 69717c454feSmycroft 6986fef5d35Schristos static int 6994d3d9104Sxtraeme getinetaddr(const char *host, struct in_addr *inap) 70017c454feSmycroft { 701c4516a41Schopps struct hostent *hp; 702c4516a41Schopps 7039a1b7b98Schopps if (inet_aton(host, inap) == 1) 704c4516a41Schopps return (0); 705c4516a41Schopps if ((hp = gethostbyname(host)) == NULL) { 7062df1fdaaSchs warnx("%s: %s", host, hstrerror(h_errno)); 707c4516a41Schopps return (-1); 708c4516a41Schopps } 709c4516a41Schopps (void)memcpy(inap, hp->h_addr, sizeof(*inap)); 710c4516a41Schopps return (0); 71117c454feSmycroft } 7120ea0f71aSfair 7136fef5d35Schristos static int 7144d3d9104Sxtraeme getifname(u_int16_t ifindex, char *ifname, size_t l) 7150ea0f71aSfair { 716ecf05965Srafal int i; 717ecf05965Srafal struct ifaddrs *addr; 7180ea0f71aSfair const struct sockaddr_dl *sdl = NULL; 7190ea0f71aSfair 720ecf05965Srafal if (ifaddrs == NULL) { 721ecf05965Srafal i = getifaddrs(&ifaddrs); 722ecf05965Srafal if (i != 0) 723ecf05965Srafal err(1, "getifaddrs"); 7240ea0f71aSfair } 7250ea0f71aSfair 726ecf05965Srafal for (addr = ifaddrs; addr; addr = addr->ifa_next) { 727ecf05965Srafal if (addr->ifa_addr == NULL || 728ecf05965Srafal addr->ifa_addr->sa_family != AF_LINK) 7290ea0f71aSfair continue; 7300ea0f71aSfair 7316fef5d35Schristos sdl = (const struct sockaddr_dl *)(void *)addr->ifa_addr; 7320ea0f71aSfair if (sdl && sdl->sdl_index == ifindex) { 7334a1c105cSitojun (void) strlcpy(ifname, addr->ifa_name, l); 7340ea0f71aSfair return 0; 7350ea0f71aSfair } 7360ea0f71aSfair } 7370ea0f71aSfair 7380ea0f71aSfair return -1; 7390ea0f71aSfair } 740