home *** CD-ROM | disk | FTP | other *** search
/ High Voltage Shareware / high1.zip / high1 / DIR3 / KA9Q212.ZIP / ARPCMD.C < prev    next >
C/C++ Source or Header  |  1993-07-16  |  5KB  |  242 lines
  1. /* ARP commands
  2.  * Copyright 1991, Phil Karn, KA9Q
  3.  */
  4.  
  5. /****************************************************************************
  6. *    $Id: arpcmd.c 1.2 93/07/16 11:41:50 ROOT_DOS Exp $
  7. *    14 Jun 93    1.2        GT    Fix warnings.                                    *
  8. ****************************************************************************/
  9.  
  10. #include <stdio.h>
  11. #include <ctype.h>
  12. #include "global.h"
  13. #include "mbuf.h"
  14. #include "timer.h"
  15. #include "enet.h"
  16. #include "ax25.h"
  17. #include "arp.h"
  18. #include "netuser.h"
  19. #include "cmdparse.h"
  20. #include "commands.h"
  21. #include "ip.h"
  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.  
  28. static struct cmds Arpcmds[] = {
  29.     { "add", doarpadd, 0, 4,
  30.     "arp add <hostid> ether|ax25|netrom|arcnet <ether addr|callsign>" },
  31.  
  32.     { "drop", doarpdrop, 0, 3,
  33.     "arp drop <hostid> ether|ax25|netrom|arcnet" },
  34.  
  35.     { "flush", doarpflush, 0, 0,
  36.     NULLCHAR },
  37.  
  38. {     "publish", doarpadd, 0, 4,
  39.     "arp publish <hostid> ether|ax25|netrom|arcnet <ether addr|callsign>" },
  40.  
  41.     { NULLCHAR },
  42. };
  43. char *Arptypes[] = {
  44.     "NET/ROM",
  45.     "10 Mb Ethernet",
  46.     "3 Mb Ethernet",
  47.     "AX.25",
  48.     "Pronet",
  49.     "Chaos",
  50.     "",
  51.     "Arcnet",
  52.     "Appletalk"
  53. };
  54.  
  55. int
  56. doarp(argc,argv,p)
  57. int argc;
  58. char *argv[];
  59. void *p;
  60. {
  61.     if(argc < 2){
  62.         dumparp();
  63.         return 0;
  64.     }
  65.     return subcmd(Arpcmds,argc,argv,p);
  66. }
  67. static
  68. doarpadd(argc,argv,p)
  69. int argc;
  70. char *argv[];
  71. void *p;
  72. {
  73.     int16 hardware;
  74.     int32 addr;
  75.     char *hwaddr;
  76.     struct arp_tab *ap;
  77.     struct arp_type *at;
  78.     int pub = 0;
  79.  
  80.     if(argv[0][0] == 'p')    /* Is this entry published? */
  81.         pub = 1;
  82.     if((addr = resolve(argv[1])) == 0){
  83.         tprintf(Badhost,argv[1]);
  84.         return 1;
  85.     }
  86.     /* This is a kludge. It really ought to be table driven */
  87.     switch(tolower(argv[2][0])){
  88.     case 'n':    /* Net/Rom pseudo-type */
  89.         hardware = ARP_NETROM;
  90.         break;
  91.     case 'e':    /* "ether" */
  92.         hardware = ARP_ETHER;
  93.         break;        
  94.     case 'a':    /* "ax25" */
  95.         switch(tolower(argv[2][1])) {
  96.         case 'x':
  97.             hardware = ARP_AX25;
  98.             break;
  99.         case 'r':
  100.             hardware = ARP_ARCNET;
  101.             break;
  102.         default:
  103.             tprintf("unknown hardware type \"%s\"\n",argv[2]);
  104.             return -1;
  105.         }
  106.         break;
  107.     case 'm':    /* "mac appletalk" */
  108.         hardware = ARP_APPLETALK;
  109.         break;
  110.     default:
  111.         tprintf("unknown hardware type \"%s\"\n",argv[2]);
  112.         return -1;
  113.     }
  114.     /* If an entry already exists, clear it */
  115.     if((ap = arp_lookup(hardware,addr)) != NULLARP)
  116.         arp_drop(ap);
  117.  
  118.     at = &Arp_type[hardware];
  119.     if(at->scan == NULLFP){
  120.         tprintf("Attach device first\n");
  121.         return 1;
  122.     }
  123.     /* Allocate buffer for hardware address and fill with remaining args */
  124.     hwaddr = mallocw(at->hwalen);
  125.     /* Destination address */
  126.     (*at->scan)(hwaddr,argv[3]);
  127.     ap = arp_add(addr,hardware,hwaddr,pub);    /* Put in table */
  128.     free(hwaddr);                /* Clean up */
  129.     stop_timer(&ap->timer);            /* Make entry permanent */
  130.     set_timer(&ap->timer,0L);
  131.     return 0;
  132. }
  133. /* Remove an ARP entry */
  134. static
  135. doarpdrop(argc,argv,p)
  136. int argc;
  137. char *argv[];
  138. void *p;
  139. {
  140.     int16 hardware;
  141.     int32 addr;
  142.     struct arp_tab *ap;
  143.  
  144.     if((addr = resolve(argv[1])) == 0){
  145.         tprintf(Badhost,argv[1]);
  146.         return 1;
  147.     }
  148.     /* This is a kludge. It really ought to be table driven */
  149.     switch(tolower(argv[2][0])){
  150.     case 'n':
  151.         hardware = ARP_NETROM;
  152.         break;
  153.     case 'e':    /* "ether" */
  154.         hardware = ARP_ETHER;
  155.         break;        
  156.     case 'a':    /* "ax25" */
  157.         switch(tolower(argv[2][1])) {
  158.         case 'x':
  159.             hardware = ARP_AX25;
  160.             break;
  161.         case 'r':
  162.             hardware = ARP_ARCNET;
  163.             break;
  164.         default:
  165.             hardware = 0;
  166.             break;
  167.         }
  168.         break;
  169.     case 'm':    /* "mac appletalk" */
  170.         hardware = ARP_APPLETALK;
  171.         break;
  172.     default:
  173.         hardware = 0;
  174.         break;
  175.     }
  176.     if((ap = arp_lookup(hardware,addr)) == NULLARP)
  177.         return -1;
  178.     arp_drop(ap);
  179.     return 0;    
  180. }
  181. /* Flush all automatic entries in the arp cache */
  182. static int
  183. doarpflush(argc,argv,p)
  184. int argc;
  185. char *argv[];
  186. void *p;
  187. {
  188.     register struct arp_tab *ap;
  189.     struct arp_tab *aptmp;
  190.     int i;
  191.  
  192.     for(i=0;i<HASHMOD;i++){
  193.         for(ap = Arp_tab[i];ap != NULLARP;ap = aptmp){
  194.             aptmp = ap->next;
  195.             if(dur_timer(&ap->timer) != 0)
  196.                 arp_drop(ap);
  197.         }
  198.     }
  199.     return 0;
  200. }
  201.  
  202. /* Dump ARP table */
  203. static void
  204. dumparp()
  205. {
  206.     register int i;
  207.     register struct arp_tab *ap;
  208.     char e[128];
  209.  
  210.     tprintf("received %u badtype %u bogus addr %u reqst in %u replies %u reqst out %u\n",
  211.      Arp_stat.recv,Arp_stat.badtype,Arp_stat.badaddr,Arp_stat.inreq,
  212.      Arp_stat.replies,Arp_stat.outreq);
  213.  
  214.     tprintf("IP addr         Type           Time Q Addr\n");
  215.     for(i=0;i<HASHMOD;i++){
  216.         for(ap = Arp_tab[i];ap != (struct arp_tab *)NULL;ap = ap->next){
  217.             tprintf("%-16s",inet_ntoa(ap->ip_addr));
  218.             tprintf("%-15s",smsg(Arptypes,NHWTYPES,ap->hardware));
  219.             tprintf("%-5ld",read_timer(&ap->timer)/1000L);
  220.             if(ap->state == ARP_PENDING)
  221.                 tprintf("%-2u",len_q(ap->pending));
  222.             else
  223.                 tprintf("  ");
  224.             if(ap->state == ARP_VALID){
  225.                 if(Arp_type[ap->hardware].format != NULL){
  226.                     (*Arp_type[ap->hardware].format)(e,ap->hw_addr);
  227.                 } else {
  228.                     e[0] = '\0';
  229.                 }
  230.                 tprintf("%s",e);
  231.             } else {
  232.                 tprintf("[unknown]");
  233.             }
  234.             if(ap->pub)
  235.                 tprintf(" (published)");
  236.             if(tprintf("\n") == EOF)
  237.                 return;
  238.         }
  239.     }
  240.     return;
  241. }
  242.