use herror

[unix-history] / usr / src / usr.sbin / arp / arp.c

/*
* Copyright (c) 1984 Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Sun Microsystems, Inc.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley.  The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1984 Regents of the University of California.\n\
All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)arp.c       5.8 (Berkeley) %G%";
#endif /* not lint */

/*
* arp - display, set, and delete arp table entries
*/

#include <machine/pte.h>

#include <sys/param.h>
#include <sys/vmmac.h>
#include <sys/file.h>
#include <sys/socket.h>
#include <sys/ioctl.h>

#include <netdb.h>
#include <netinet/in.h>
#include <net/if.h>
#include <netinet/if_ether.h>

#include <errno.h>
#include <nlist.h>
#include <stdio.h>

extern int errno;
static int kflag;

main(argc, argv)
       int argc;
       char **argv;
{
       int ch;

       while ((ch = getopt(argc, argv, "adsf")) != EOF)
               switch((char)ch) {
               case 'a': {
                       char *mem;

                       if (argc > 4)
                               usage();
                       if (argc == 4) {
                               kflag = 1;
                               mem = argv[3];
                       }
                       else
                               mem = "/dev/kmem";
                       dump((argc >= 3) ? argv[2] : "/vmunix", mem);
                       exit(0);
               }
               case 'd':
                       if (argc != 3)
                               usage();
                       delete(argv[2]);
                       exit(0);
               case 's':
                       if (argc < 4 || argc > 7)
                               usage();
                       exit(set(argc-2, &argv[2]) ? 1 : 0);
               case 'f':
                       if (argc != 3)
                               usage();
                       exit (file(argv[2]) ? 1 : 0);
               case '?':
               default:
                       usage();
               }
       if (argc != 2)
               usage();
       get(argv[1]);
       exit(0);
}

/*
* Process a file to set standard arp entries
*/
file(name)
       char *name;
{
       FILE *fp;
       int i, retval;
       char line[100], arg[5][50], *args[5];

       if ((fp = fopen(name, "r")) == NULL) {
               fprintf(stderr, "arp: cannot open %s\n", name);
               exit(1);
       }
       args[0] = &arg[0][0];
       args[1] = &arg[1][0];
       args[2] = &arg[2][0];
       args[3] = &arg[3][0];
       args[4] = &arg[4][0];
       retval = 0;
       while(fgets(line, 100, fp) != NULL) {
               i = sscanf(line, "%s %s %s %s %s", arg[0], arg[1], arg[2],
                   arg[3], arg[4]);
               if (i < 2) {
                       fprintf(stderr, "arp: bad line: %s\n", line);
                       retval = 1;
                       continue;
               }
               if (set(i, args))
                       retval = 1;
       }
       fclose(fp);
       return (retval);
}

/*
* Set an individual arp entry 
*/
set(argc, argv)
       int argc;
       char **argv;
{
       struct arpreq ar;
       struct hostent *hp;
       struct sockaddr_in *sin;
       u_char *ea;
       int s;
       char *host = argv[0], *eaddr = argv[1];

       argc -= 2;
       argv += 2;
       bzero((caddr_t)&ar, sizeof ar);
       sin = (struct sockaddr_in *)&ar.arp_pa;
       sin->sin_family = AF_INET;
       sin->sin_addr.s_addr = inet_addr(host);
       if (sin->sin_addr.s_addr == -1) {
               if (!(hp = gethostbyname(host))) {
                       fprintf(stderr, "arp: %s: ", host);
                       herror((char *)NULL);
                       return (1);
               }
               bcopy((char *)hp->h_addr, (char *)&sin->sin_addr,
                   sizeof sin->sin_addr);
       }
       ea = (u_char *)ar.arp_ha.sa_data;
       if (ether_aton(eaddr, ea))
               return (1);
       ar.arp_flags = ATF_PERM;
       while (argc-- > 0) {
               if (strncmp(argv[0], "temp", 4) == 0)
                       ar.arp_flags &= ~ATF_PERM;
               else if (strncmp(argv[0], "pub", 3) == 0)
                       ar.arp_flags |= ATF_PUBL;
               else if (strncmp(argv[0], "trail", 5) == 0)
                       ar.arp_flags |= ATF_USETRAILERS;
               argv++;
       }
       
       s = socket(AF_INET, SOCK_DGRAM, 0);
       if (s < 0) {
               perror("arp: socket");
               exit(1);
       }
       if (ioctl(s, SIOCSARP, (caddr_t)&ar) < 0) {
               perror(host);
               exit(1);
       }
       close(s);
       return (0);
}

/*
* Display an individual arp entry
*/
get(host)
       char *host;
{
       struct arpreq ar;
       struct hostent *hp;
       struct sockaddr_in *sin;
       u_char *ea;
       int s;
       char *inet_ntoa();

       bzero((caddr_t)&ar, sizeof ar);
       ar.arp_pa.sa_family = AF_INET;
       sin = (struct sockaddr_in *)&ar.arp_pa;
       sin->sin_family = AF_INET;
       sin->sin_addr.s_addr = inet_addr(host);
       if (sin->sin_addr.s_addr == -1) {
               if (!(hp = gethostbyname(host))) {
                       fprintf(stderr, "arp: %s: ", host);
                       herror((char *)NULL);
                       exit(1);
               }
               bcopy((char *)hp->h_addr, (char *)&sin->sin_addr,
                   sizeof sin->sin_addr);
       }
       s = socket(AF_INET, SOCK_DGRAM, 0);
       if (s < 0) {
               perror("arp: socket");
               exit(1);
       }
       if (ioctl(s, SIOCGARP, (caddr_t)&ar) < 0) {
               if (errno == ENXIO)
                       printf("%s (%s) -- no entry\n",
                           host, inet_ntoa(sin->sin_addr));
               else
                       perror("SIOCGARP");
               exit(1);
       }
       close(s);
       ea = (u_char *)ar.arp_ha.sa_data;
       printf("%s (%s) at ", host, inet_ntoa(sin->sin_addr));
       if (ar.arp_flags & ATF_COM)
               ether_print(ea);
       else
               printf("(incomplete)");
       if (ar.arp_flags & ATF_PERM)
               printf(" permanent");
       if (ar.arp_flags & ATF_PUBL)
               printf(" published");
       if (ar.arp_flags & ATF_USETRAILERS)
               printf(" trailers");
       printf("\n");
}

/*
* Delete an arp entry 
*/
delete(host)
       char *host;
{
       struct arpreq ar;
       struct hostent *hp;
       struct sockaddr_in *sin;
       int s;

       bzero((caddr_t)&ar, sizeof ar);
       ar.arp_pa.sa_family = AF_INET;
       sin = (struct sockaddr_in *)&ar.arp_pa;
       sin->sin_family = AF_INET;
       sin->sin_addr.s_addr = inet_addr(host);
       if (sin->sin_addr.s_addr == -1) {
               if (!(hp = gethostbyname(host))) {
                       fprintf(stderr, "arp: %s: ", host);
                       herror((char *)NULL);
                       exit(1);
               }
               bcopy((char *)hp->h_addr, (char *)&sin->sin_addr,
                   sizeof sin->sin_addr);
       }
       s = socket(AF_INET, SOCK_DGRAM, 0);
       if (s < 0) {
               perror("arp: socket");
               exit(1);
       }
       if (ioctl(s, SIOCDARP, (caddr_t)&ar) < 0) {
               if (errno == ENXIO)
                       printf("%s (%s) -- no entry\n",
                           host, inet_ntoa(sin->sin_addr));
               else
                       perror("SIOCDARP");
               exit(1);
       }
       close(s);
       printf("%s (%s) deleted\n", host, inet_ntoa(sin->sin_addr));
}

struct nlist nl[] = {
#define X_ARPTAB        0
       { "_arptab" },
#define X_ARPTAB_SIZE   1
       { "_arptab_size" },
#define N_SYSMAP        2
       { "_Sysmap" },
#define N_SYSSIZE       3
       { "_Syssize" },
       { "" },
};

static struct pte *Sysmap;

/*
* Dump the entire arp table
*/
dump(kernel, mem)
       char *kernel, *mem;
{
       extern int h_errno;
       struct arptab *at;
       struct hostent *hp;
       int bynumber, mf, arptab_size, sz;
       char *host, *malloc();
       off_t lseek();

       if (nlist(kernel, nl) < 0 || nl[X_ARPTAB_SIZE].n_type == 0) {
               fprintf(stderr, "arp: %s: bad namelist\n", kernel);
               exit(1);
       }
       mf = open(mem, O_RDONLY);
       if (mf < 0) {
               fprintf(stderr, "arp: cannot open %s\n", mem);
               exit(1);
       }
       if (kflag) {
               off_t off;

               Sysmap = (struct pte *)
                  malloc((u_int)(nl[N_SYSSIZE].n_value * sizeof(struct pte)));
               if (!Sysmap) {
                       fputs("arp: can't get memory for Sysmap.\n", stderr);
                       exit(1);
               }
               off = nl[N_SYSMAP].n_value & ~KERNBASE;
               (void)lseek(mf, off, L_SET);
               (void)read(mf, (char *)Sysmap,
                   (int)(nl[N_SYSSIZE].n_value * sizeof(struct pte)));
       }
       klseek(mf, (long)nl[X_ARPTAB_SIZE].n_value, L_SET);
       read(mf, &arptab_size, sizeof arptab_size);
       if (arptab_size <= 0 || arptab_size > 1000) {
               fprintf(stderr, "arp: %s: namelist wrong\n", kernel);
               exit(1);
       }
       sz = arptab_size * sizeof (struct arptab);
       at = (struct arptab *)malloc((u_int)sz);
       if (at == NULL) {
               fputs("arp: can't get memory for arptab.\n", stderr);
               exit(1);
       }
       klseek(mf, (long)nl[X_ARPTAB].n_value, L_SET);
       if (read(mf, (char *)at, sz) != sz) {
               perror("arp: error reading arptab");
               exit(1);
       }
       close(mf);
       for (bynumber = 0; arptab_size-- > 0; at++) {
               if (at->at_iaddr.s_addr == 0 || at->at_flags == 0)
                       continue;
               if (bynumber == 0)
                       hp = gethostbyaddr((caddr_t)&at->at_iaddr,
                           sizeof at->at_iaddr, AF_INET);
               else
                       hp = 0;
               if (hp)
                       host = hp->h_name;
               else {
                       host = "?";
                       if (h_errno == TRY_AGAIN)
                               bynumber = 1;
               }
               printf("%s (%s) at ", host, inet_ntoa(at->at_iaddr));
               if (at->at_flags & ATF_COM)
                       ether_print(at->at_enaddr);
               else
                       printf("(incomplete)");
               if (at->at_flags & ATF_PERM)
                       printf(" permanent");
               if (at->at_flags & ATF_PUBL)
                       printf(" published");
               if (at->at_flags & ATF_USETRAILERS)
                       printf(" trailers");
               printf("\n");
       }
}

/*
* Seek into the kernel for a value.
*/
klseek(fd, base, off)
       int fd, off;
       off_t base;
{
       off_t lseek();

       if (kflag) {    /* get kernel pte */
               base &= ~KERNBASE;
               base = ctob(Sysmap[btop(base)].pg_pfnum) + (base & PGOFSET);
       }
       (void)lseek(fd, base, off);
}

ether_print(cp)
       u_char *cp;
{
       printf("%x:%x:%x:%x:%x:%x", cp[0], cp[1], cp[2], cp[3], cp[4], cp[5]);
}

ether_aton(a, n)
       char *a;
       u_char *n;
{
       int i, o[6];

       i = sscanf(a, "%x:%x:%x:%x:%x:%x", &o[0], &o[1], &o[2],
                                          &o[3], &o[4], &o[5]);
       if (i != 6) {
               fprintf(stderr, "arp: invalid Ethernet address '%s'\n", a);
               return (1);
       }
       for (i=0; i<6; i++)
               n[i] = o[i];
       return (0);
}

usage()
{
       printf("usage: arp hostname\n");
       printf("       arp -a [/vmunix] [/dev/kmem]\n");
       printf("       arp -d hostname\n");
       printf("       arp -s hostname ether_addr [temp] [pub] [trail]\n");
       printf("       arp -f filename\n");
       exit(1);
}