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