usr/src/cmd/cmd-inet/usr.sbin/arp.c

   1 /*
   2  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  */
   5 /*
   6  * Copyright (c) 1984 Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to Berkeley by
  10  * Sun Microsystems, Inc.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *      This product includes software developed by the University of
  23  *      California, Berkeley and its contributors.
  24  * 4. Neither the name of the University nor the names of its contributors
  25  *    may be used to endorse or promote products derived from this software
  26  *    without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  38  * SUCH DAMAGE.
  39  */
  40
  41
  42 /*
  43  * arp - display, set, and delete arp table entries
  44  */
  45
  46 #include <stdio.h>
  47 #include <sys/types.h>
  48 #include <sys/socket.h>
  49 #include <netinet/in.h>
  50 #include <sys/ioctl.h>
  51 #include <errno.h>
  52 #include <netdb.h>
  53 #include <net/if.h>
  54 #include <net/if_arp.h>
  55 #include <stdlib.h>
  56 #include <unistd.h>
  57 #include <string.h>
  58 #include <arpa/inet.h>
  59 #include <net/if_types.h>
  60 #include <net/if_dl.h>
  61
  62 static int file(char *);
  63 static int set(int, char *[]);
  64 static void get(char *);
  65 static void delete(char *);
  66 static void usage(void);
  67
  68 int
  69 main(int argc, char *argv[])
  70 {
  71         int c, nflags = 0, argsleft;
  72         int n_flag, a_flag, d_flag, f_flag, s_flag;
  73
  74         n_flag = a_flag = d_flag = f_flag = s_flag = 0;
  75
  76 #define CASE(x, y)                              \
  77                 case x:                         \
  78                         if (nflags > 0) {       \
  79                                 usage();        \
  80                                 exit(1);        \
  81                         } else                  \
  82                                 y##_flag = 1;   \
  83                                 nflags++;       \
  84                         break
  85
  86         while ((c = getopt(argc, argv, "nadfs")) != EOF) {
  87                 switch (c) {
  88                 case '?':
  89                         usage();
  90                         exit(1);
  91                         /* NOTREACHED */
  92                         break;
  93                 case 'n':
  94                         n_flag = 1;
  95                         break;
  96                 CASE('a', a);
  97                 CASE('d', d);
  98                 CASE('f', f);
  99                 CASE('s', s);
 100                 }
 101         }
 102
 103 #undef CASE
 104
 105         /*
 106          * -n only allowed with -a
 107          */
 108         if (n_flag && !a_flag) {
 109                 usage();
 110                 exit(1);
 111         }
 112
 113         argsleft = argc - optind;
 114
 115         if (a_flag && (argsleft == 0)) {
 116                 /*
 117                  * the easiest way to get the complete arp table
 118                  * is to let netstat, which prints it as part of
 119                  * the MIB statistics, do it.
 120                  */
 121                 (void) execl("/usr/bin/netstat", "netstat",
 122                     (n_flag ? "-np" : "-p"),
 123                     "-f", "inet", (char *)0);
 124                 (void) fprintf(stderr, "failed to exec netstat: %s\n",
 125                     strerror(errno));
 126                 exit(1);
 127
 128         } else if (s_flag && (argsleft >= 2)) {
 129                 if (set(argsleft, &argv[optind]) != 0)
 130                         exit(1);
 131
 132         } else if (d_flag && (argsleft == 1)) {
 133                 delete(argv[optind]);
 134
 135         } else if (f_flag && (argsleft == 1)) {
 136                 if (file(argv[optind]) != 0)
 137                         exit(1);
 138
 139         } else if ((nflags == 0) && (argsleft == 1)) {
 140                 get(argv[optind]);
 141
 142         } else {
 143                 usage();
 144                 exit(1);
 145         }
 146         return (0);
 147 }
 148
 149 /*
 150  * Process a file to set standard arp entries
 151  */
 152 static int
 153 file(char *name)
 154 {
 155         /*
 156          * A line of input can be:
 157          * <hostname> <macaddr> ["temp"] ["pub"] ["trail"] ["permanent"]
 158          */
 159 #define MAX_LINE_LEN    (MAXHOSTNAMELEN + \
 160         sizeof (" xx:xx:xx:xx:xx:xx temp pub trail permanent\n"))
 161 #define MIN_ARGS        2
 162 #define MAX_ARGS        5
 163
 164         FILE *fp;
 165         char line[MAX_LINE_LEN];
 166         int retval;
 167
 168         if ((fp = fopen(name, "r")) == NULL) {
 169                 (void) fprintf(stderr, "arp: cannot open %s\n", name);
 170                 exit(1);
 171         }
 172
 173         retval = 0;
 174         while (fgets(line, MAX_LINE_LEN, fp) != NULL) {
 175                 char line_copy[MAX_LINE_LEN];
 176                 char *args[MAX_ARGS];
 177                 char *start;
 178                 int i;
 179
 180                 /*
 181                  * Keep a copy of the un-altered line for error
 182                  * reporting.
 183                  */
 184                 (void) strlcpy(line_copy, line, MAX_LINE_LEN);
 185
 186                 start = line_copy;
 187                 for (i = 0; i < MAX_ARGS; i++) {
 188                         if ((args[i] = strtok(start, " \t\n")) == NULL)
 189                                 break;
 190
 191                         start = NULL;
 192                 }
 193
 194                 if (i < MIN_ARGS) {
 195                         (void) fprintf(stderr, "arp: bad line: %s\n",
 196                             line);
 197                         retval = 1;
 198                         continue;
 199                 }
 200
 201                 if (set(i, args) != 0)
 202                         retval = 1;
 203         }
 204
 205 #undef  MAX_LINE_LEN
 206 #undef  MIN_ARGS
 207 #undef  MAX_ARGS
 208
 209         (void) fclose(fp);
 210         return (retval);
 211 }
 212
 213 /*
 214  * Set an individual arp entry
 215  */
 216 static int
 217 set(int argc, char *argv[])
 218 {
 219         struct xarpreq ar;
 220         struct hostent *hp;
 221         struct sockaddr_in *sin;
 222         uchar_t *ea;
 223         int s;
 224         char *host = argv[0], *eaddr = argv[1];
 225
 226         argc -= 2;
 227         argv += 2;
 228         (void) memset(&ar, 0, sizeof (ar));
 229         sin = (struct sockaddr_in *)&ar.xarp_pa;
 230         sin->sin_family = AF_INET;
 231         sin->sin_addr.s_addr = inet_addr(host);
 232         if (sin->sin_addr.s_addr == (in_addr_t)-1) {
 233                 hp = gethostbyname(host);
 234                 if (hp == NULL) {
 235                         (void) fprintf(stderr, "arp: %s: unknown host\n",
 236                             host);
 237                         return (1);
 238                 }
 239                 (void) memcpy(&sin->sin_addr, hp->h_addr,
 240                     sizeof (sin->sin_addr));
 241         }
 242         ea = _link_aton(eaddr, &s);
 243         if (ea == NULL) {
 244                 if (s == -1) {
 245                         (void) fprintf(stderr,
 246                             "arp: invalid link layer address '%s'\n", eaddr);
 247                         return (1);
 248                 }
 249                 perror("arp: nomem");
 250                 exit(1);
 251         }
 252         ar.xarp_ha.sdl_alen = s;
 253         (void) memcpy(LLADDR(&ar.xarp_ha), ea, ar.xarp_ha.sdl_alen);
 254         free(ea);
 255         ar.xarp_ha.sdl_family = AF_LINK;
 256         ar.xarp_flags = ATF_PERM;
 257         while (argc-- > 0) {
 258                 if (strncmp(argv[0], "temp", 4) == 0) {
 259                         ar.xarp_flags &= ~ATF_PERM;
 260                 } else if (strncmp(argv[0], "pub", 3) == 0) {
 261                         ar.xarp_flags |= ATF_PUBL;
 262                 } else if (strncmp(argv[0], "trail", 5) == 0) {
 263                         ar.xarp_flags |= ATF_USETRAILERS;
 264                 } else if (strcmp(argv[0], "permanent") == 0) {
 265                         ar.xarp_flags |= ATF_AUTHORITY;
 266                 } else {
 267                         (void) fprintf(stderr,
 268                             "arp: unknown keyword '%s'\n", argv[0]);
 269                         return (1);
 270                 }
 271                 argv++;
 272         }
 273
 274         if ((ar.xarp_flags & (ATF_PERM|ATF_AUTHORITY)) == ATF_AUTHORITY) {
 275                 (void) fprintf(stderr, "arp: 'temp' and 'permanent' flags are "
 276                     "not usable together.\n");
 277                 return (1);
 278         }
 279
 280         s = socket(AF_INET, SOCK_DGRAM, 0);
 281         if (s < 0) {
 282                 perror("arp: socket");
 283                 exit(1);
 284         }
 285         if (ioctl(s, SIOCSXARP, (caddr_t)&ar) < 0) {
 286                 perror(host);
 287                 exit(1);
 288         }
 289         (void) close(s);
 290         return (0);
 291 }
 292
 293 /*
 294  * Display an individual arp entry
 295  */
 296 static void
 297 get(char *host)
 298 {
 299         struct xarpreq ar;
 300         struct hostent *hp;
 301         struct sockaddr_in *sin;
 302         uchar_t *ea;
 303         int s;
 304         char *str = NULL;
 305
 306         (void) memset(&ar, 0, sizeof (ar));
 307         sin = (struct sockaddr_in *)&ar.xarp_pa;
 308         sin->sin_family = AF_INET;
 309         sin->sin_addr.s_addr = inet_addr(host);
 310         if (sin->sin_addr.s_addr == (in_addr_t)-1) {
 311                 hp = gethostbyname(host);
 312                 if (hp == NULL) {
 313                         (void) fprintf(stderr, "arp: %s: unknown host\n",
 314                             host);
 315                         exit(1);
 316                 }
 317                 (void) memcpy(&sin->sin_addr, hp->h_addr,
 318                     sizeof (sin->sin_addr));
 319         }
 320         s = socket(AF_INET, SOCK_DGRAM, 0);
 321         if (s < 0) {
 322                 perror("arp: socket");
 323                 exit(1);
 324         }
 325         ar.xarp_ha.sdl_family = AF_LINK;
 326         if (ioctl(s, SIOCGXARP, (caddr_t)&ar) < 0) {
 327                 if (errno == ENXIO)
 328                         (void) printf("%s (%s) -- no entry\n",
 329                             host, inet_ntoa(sin->sin_addr));
 330                 else
 331                         perror("SIOCGXARP");
 332                 exit(1);
 333         }
 334         (void) close(s);
 335         ea = (uchar_t *)LLADDR(&ar.xarp_ha);
 336         if (ar.xarp_flags & ATF_COM) {
 337                 str = _link_ntoa(ea, str, ar.xarp_ha.sdl_alen, IFT_OTHER);
 338                 if (str != NULL) {
 339                         (void) printf("%s (%s) at %s", host,
 340                             inet_ntoa(sin->sin_addr), str);
 341                         free(str);
 342                 } else {
 343                         perror("arp: nomem");
 344                         exit(1);
 345                 }
 346         } else {
 347                 (void) printf("%s (%s) at (incomplete)", host,
 348                     inet_ntoa(sin->sin_addr));
 349         }
 350         if (!(ar.xarp_flags & ATF_PERM))
 351                 (void) printf(" temp");
 352         if (ar.xarp_flags & ATF_PUBL)
 353                 (void) printf(" pub");
 354         if (ar.xarp_flags & ATF_USETRAILERS)
 355                 (void) printf(" trail");
 356         if (ar.xarp_flags & ATF_AUTHORITY)
 357                 (void) printf(" permanent");
 358         (void) printf("\n");
 359 }
 360
 361 /*
 362  * Delete an arp entry
 363  */
 364 static void
 365 delete(char *host)
 366 {
 367         struct xarpreq ar;
 368         struct hostent *hp;
 369         struct sockaddr_in *sin;
 370         int s;
 371
 372         (void) memset(&ar, 0, sizeof (ar));
 373         sin = (struct sockaddr_in *)&ar.xarp_pa;
 374         sin->sin_family = AF_INET;
 375         sin->sin_addr.s_addr = inet_addr(host);
 376         if (sin->sin_addr.s_addr == (in_addr_t)-1) {
 377                 hp = gethostbyname(host);
 378                 if (hp == NULL) {
 379                         (void) fprintf(stderr, "arp: %s: unknown host\n",
 380                             host);
 381                         exit(1);
 382                 }
 383                 (void) memcpy(&sin->sin_addr, hp->h_addr,
 384                     sizeof (sin->sin_addr));
 385         }
 386         s = socket(AF_INET, SOCK_DGRAM, 0);
 387         if (s < 0) {
 388                 perror("arp: socket");
 389                 exit(1);
 390         }
 391         ar.xarp_ha.sdl_family = AF_LINK;
 392         if (ioctl(s, SIOCDXARP, (caddr_t)&ar) < 0) {
 393                 if (errno == ENXIO)
 394                         (void) printf("%s (%s) -- no entry\n",
 395                             host, inet_ntoa(sin->sin_addr));
 396                 else
 397                         perror("SIOCDXARP");
 398                 exit(1);
 399         }
 400         (void) close(s);
 401         (void) printf("%s (%s) deleted\n", host, inet_ntoa(sin->sin_addr));
 402 }
 403
 404 static void
 405 usage(void)
 406 {
 407         (void) printf("Usage: arp hostname\n");
 408         (void) printf("       arp -a [-n]\n");
 409         (void) printf("       arp -d hostname\n");
 410         (void) printf("       arp -s hostname ether_addr "
 411             "[temp] [pub] [trail] [permanent]\n");
 412         (void) printf("       arp -f filename\n");
 413 }