home *** CD-ROM | disk | FTP | other *** search
/ Super Net 1 / SUPERNET_1.iso / PC / OTROS / MSDOS / KA9Q / MSWIN / RTSORT.ZIP / ARPCMD.C next >
Encoding:
C/C++ Source or Header  |  1992-02-08  |  6.3 KB  |  294 lines
  1. /* ARP commands
  2.  * Copyright 1991 Phil Karn, KA9Q
  3.  */
  4.  /* Mods by G1EMM */
  5. #include <stdio.h>
  6. #include <ctype.h>
  7. #include "global.h"
  8. #include "config.h"
  9. #include "mbuf.h"
  10. #include "timer.h"
  11. #include "enet.h"
  12. #include "ax25.h"
  13. #include "arp.h"
  14. #include "netuser.h"
  15. #include "cmdparse.h"
  16. #include "commands.h"
  17. #include "iface.h"
  18. #include "rspf.h"
  19.  
  20. int Arp_Sort=1;
  21.  
  22. static int doarpadd __ARGS((int argc,char *argv[],void *p));
  23. static int doarpdrop __ARGS((int argc,char *argv[],void *p));
  24. static int doarpflush __ARGS((int argc,char *argv[],void *p));
  25. static void dumparp __ARGS((void));
  26. static char * make_arp_string __ARGS((struct arp_tab *ap));
  27. static int doarpsort __ARGS((int argc,char *argv[],void *p));
  28.  
  29. static struct cmds Arpcmds[] = {
  30.     "add", doarpadd, 0, 4,
  31.     "arp add <hostid> ether|ax25|netrom|arcnet <ether addr|callsign>",
  32.  
  33.     "drop", doarpdrop, 0, 3,
  34.     "arp drop <hostid> ether|ax25|netrom|arcnet",
  35.  
  36.     "flush", doarpflush, 0, 0,
  37.     NULLCHAR,
  38.  
  39.     "publish", doarpadd, 0, 4,
  40.     "arp publish <hostid> ether|ax25|netrom|arcnet <ether addr|callsign>",
  41.     
  42.     "sort",    doarpsort, 0, 0,
  43.     NULLCHAR,
  44.  
  45.     NULLCHAR,
  46. };
  47. char *Arptypes[] = {
  48.     "NET/ROM",
  49.     "10 Mb Ethernet",
  50.     "3 Mb Ethernet",
  51.     "AX.25",
  52.     "Pronet",
  53.     "Chaos",
  54.     "",
  55.     "Arcnet",
  56.     "Appletalk"
  57. };
  58.  
  59. int
  60. doarp(argc,argv,p)
  61. int argc;
  62. char *argv[];
  63. void *p;
  64. {
  65.     if(argc < 2){
  66.         dumparp();
  67.         return 0;
  68.     }
  69.     return subcmd(Arpcmds,argc,argv,p);
  70. }
  71. static
  72. doarpadd(argc,argv,p)
  73. int argc;
  74. char *argv[];
  75. void *p;
  76. {
  77.     int16 hardware;
  78.     int32 addr;
  79.     char *hwaddr;
  80.     struct arp_tab *ap;
  81.     struct arp_type *at;
  82.     int pub = 0;
  83.  
  84.     if(argv[0][0] == 'p')   /* Is this entry published? */
  85.         pub = 1;
  86.     if((addr = resolve(argv[1])) == 0){
  87.         tprintf(Badhost,argv[1]);
  88.         return 1;
  89.     }
  90.     /* This is a kludge. It really ought to be table driven */
  91.     switch(tolower(argv[2][0])){
  92.     case 'n':       /* Net/Rom pseudo-type */
  93.         hardware = ARP_NETROM;
  94.         break;
  95.     case 'e':       /* "ether" */
  96.         hardware = ARP_ETHER;
  97.         break;          
  98.     case 'a':       /* "ax25" */
  99.         switch(tolower(argv[2][1])) {
  100.         case 'x':
  101.             hardware = ARP_AX25;
  102.             break;
  103.         case 'r':
  104.             hardware = ARP_ARCNET;
  105.             break;
  106.         default:
  107.             tprintf("unknown hardware type \"%s\"\n",argv[2]);
  108.             return -1;
  109.         }
  110.         break;
  111.     case 'm':       /* "mac appletalk" */
  112.         hardware = ARP_APPLETALK;
  113.         break;
  114.     default:
  115.         tprintf("unknown hardware type \"%s\"\n",argv[2]);
  116.         return -1;
  117.     }
  118.     /* If an entry already exists, clear it */
  119.     if((ap = arp_lookup(hardware,addr)) != NULLARP)
  120.         arp_drop(ap);
  121.  
  122.     at = &Arp_type[hardware];
  123.     if(at->scan == NULLFP){
  124.         tprintf("Attach device first\n");
  125.         return 1;
  126.     }
  127.     /* Allocate buffer for hardware address and fill with remaining args */
  128.     hwaddr = mallocw(at->hwalen);
  129.     /* Destination address */
  130.     (*at->scan)(hwaddr,argv[3]);
  131.     ap = arp_add(addr,hardware,hwaddr,pub); /* Put in table */
  132.     free(hwaddr);                           /* Clean up */
  133.     stop_timer(&ap->timer);                 /* Make entry permanent */
  134.     set_timer(&ap->timer,0L);
  135. #ifdef  RSPF
  136.     rspfarpupcall(addr,hardware,NULLIF);    /* Do an RSPF upcall */
  137. #endif  /* RSPF */
  138.     return 0;
  139. }
  140. /* Remove an ARP entry */
  141. static
  142. doarpdrop(argc,argv,p)
  143. int argc;
  144. char *argv[];
  145. void *p;
  146. {
  147.     int16 hardware;
  148.     int32 addr;
  149.     struct arp_tab *ap;
  150.  
  151.     if((addr = resolve(argv[1])) == 0){
  152.         tprintf(Badhost,argv[1]);
  153.         return 1;
  154.     }
  155.     /* This is a kludge. It really ought to be table driven */
  156.     switch(tolower(argv[2][0])){
  157.     case 'n':
  158.         hardware = ARP_NETROM;
  159.         break;
  160.     case 'e':       /* "ether" */
  161.         hardware = ARP_ETHER;
  162.         break;          
  163.     case 'a':       /* "ax25" */
  164.         switch(tolower(argv[2][1])) {
  165.         case 'x':
  166.             hardware = ARP_AX25;
  167.             break;
  168.         case 'r':
  169.             hardware = ARP_ARCNET;
  170.             break;
  171.         default:
  172.             hardware = 0;
  173.             break;
  174.         }
  175.         break;
  176.     case 'm':       /* "mac appletalk" */
  177.         hardware = ARP_APPLETALK;
  178.         break;
  179.     default:
  180.         hardware = 0;
  181.         break;
  182.     }
  183.     if((ap = arp_lookup(hardware,addr)) == NULLARP)
  184.         return -1;
  185.     arp_drop(ap);
  186.     return 0;       
  187. }
  188. /* Flush all automatic entries in the arp cache */
  189. static int
  190. doarpflush(argc,argv,p)
  191. int argc;
  192. char *argv[];
  193. void *p;
  194. {
  195.     register struct arp_tab *ap;
  196.     struct arp_tab *aptmp;
  197.     int i;
  198.  
  199.     for(i=0;i<HASHMOD;i++){
  200.         for(ap = Arp_tab[i];ap != NULLARP;ap = aptmp){
  201.             aptmp = ap->next;
  202.             if(dur_timer(&ap->timer) != 0)
  203.                 arp_drop(ap);
  204.         }
  205.     }
  206.     return 0;
  207. }
  208.  
  209. /* Dump ARP table */
  210. static void
  211. dumparp()
  212. {
  213.     register int i,j,k;
  214.     register struct arp_tab *ap;
  215.     char *temp;        
  216.     
  217.     tprintf("received %u badtype %u bogus addr %u reqst in %u replies %u reqst out %u\n",
  218.      Arp_stat.recv,Arp_stat.badtype,Arp_stat.badaddr,Arp_stat.inreq,
  219.      Arp_stat.replies,Arp_stat.outreq);
  220.  
  221.     tprintf("IP addr         Type           Time Q Addr\n");
  222.     
  223.     for(i=0,j=0;i<HASHMOD;i++)
  224.        for(ap = Arp_tab[i];ap != (struct arp_tab *)NULL;ap = ap->next,j++);
  225.     
  226.     if (j) {
  227.  
  228.       temp=mallocw(j*80);
  229.     
  230.       for(i=0,k=0;i<HASHMOD;i++) {
  231.          for(ap = Arp_tab[i];ap != (struct arp_tab *)NULL;ap = ap->next,k+=80)
  232.            strcpy(&temp[k],make_arp_string(ap));
  233.       }
  234.  
  235.       if (Arp_Sort) qsort(temp,(size_t)j,80,strcmp);
  236.  
  237.       for(i=0,k=4;i<j;i++,k+=80) {
  238.           tprintf("%s",&temp[k]);
  239.           if(tprintf("\n") == EOF) {
  240.              free(temp);
  241.              return;
  242.           }
  243.       }
  244.  
  245.       free(temp);
  246.     }
  247.  
  248. }
  249.  
  250. static char*
  251. make_arp_string(ap)
  252. register struct arp_tab *ap;
  253. {
  254.       char e[128];
  255.       char buf[80];
  256.       unsigned a=0;
  257.       
  258.       a=sprintf(buf,"%4s",inet_ntobos(ap->ip_addr));
  259.       a+=sprintf(&buf[a],"%-16s",inet_ntoa(ap->ip_addr));
  260.       a+=sprintf(&buf[a],"%-15s",smsg(Arptypes,NHWTYPES,ap->hardware));
  261.       a+=sprintf(&buf[a],"%-5ld",read_timer(&ap->timer)/1000L);
  262.       if(ap->state == ARP_PENDING)
  263.           a+=sprintf(&buf[a],"%-2u",len_q(ap->pending));
  264.       else
  265.           a+=sprintf(&buf[a],"  ");
  266.       if(ap->state == ARP_VALID){
  267.        if(Arp_type[ap->hardware].format != NULL){
  268.            (*Arp_type[ap->hardware].format)(e,ap->hw_addr);
  269.        } else {
  270.            e[0] = '\0';
  271.        }
  272.        a+=sprintf(&buf[a],"%s",e);
  273.        } else {
  274.            a+=sprintf(&buf[a],"[unknown]");
  275.        }
  276.        if(ap->pub)
  277.            a+=sprintf(&buf[a]," (published)");
  278.  
  279.        return buf;
  280. }
  281.  
  282. /* Sort ARP dump */
  283. static int
  284. doarpsort(argc,argv,p)
  285. int argc ;
  286. char *argv[] ;
  287. void *p;
  288. {
  289.     extern int Arp_Sort;
  290.  
  291.     return setbool(&Arp_Sort,"ARP Sort flag",argc,argv);
  292. }
  293.  
  294.