home *** CD-ROM | disk | FTP | other *** search
/ HAM Radio 3 / hamradioversion3.0examsandprograms1992.iso / packet / n17jsrc / arpcmd.c < prev    next >
C/C++ Source or Header  |  1991-04-26  |  5KB  |  242 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. static int doarpadd __ARGS((int argc,char *argv[],void *p));
  21. static int doarpdrop __ARGS((int argc,char *argv[],void *p));
  22. static int doarpflush __ARGS((int argc,char *argv[],void *p));
  23. static void dumparp __ARGS((void));
  24.  
  25. static struct cmds Arpcmds[] = {
  26.     "add", doarpadd, 0, 4,
  27.     "arp add <hostid> ether|ax25|netrom|arcnet <ether addr|callsign>",
  28.  
  29.     "drop", doarpdrop, 0, 3,
  30.     "arp drop <hostid> ether|ax25|netrom|arcnet",
  31.  
  32.     "flush", doarpflush, 0, 0,
  33.     NULLCHAR,
  34.  
  35.     "publish", doarpadd, 0, 4,
  36.     "arp publish <hostid> ether|ax25|netrom|arcnet <ether addr|callsign>",
  37.  
  38.     NULLCHAR,
  39. };
  40. char *Arptypes[] = {
  41.     "NET/ROM",
  42.     "10 Mb Ethernet",
  43.     "3 Mb Ethernet",
  44.     "AX.25",
  45.     "Pronet",
  46.     "Chaos",
  47.     "",
  48.     "Arcnet",
  49.     "Appletalk"
  50. };
  51.  
  52. int
  53. doarp(argc,argv,p)
  54. int argc;
  55. char *argv[];
  56. void *p;
  57. {
  58.     if(argc < 2){
  59.         dumparp();
  60.         return 0;
  61.     }
  62.     return subcmd(Arpcmds,argc,argv,p);
  63. }
  64. static
  65. doarpadd(argc,argv,p)
  66. int argc;
  67. char *argv[];
  68. void *p;
  69. {
  70.     int16 hardware;
  71.     int32 addr;
  72.     char *hwaddr;
  73.     struct arp_tab *ap;
  74.     struct arp_type *at;
  75.     int pub = 0;
  76.  
  77.     if(argv[0][0] == 'p')    /* Is this entry published? */
  78.         pub = 1;
  79.     if((addr = resolve(argv[1])) == 0){
  80.         tprintf(Badhost,argv[1]);
  81.         return 1;
  82.     }
  83.     /* This is a kludge. It really ought to be table driven */
  84.     switch(tolower(argv[2][0])){
  85.     case 'n':    /* Net/Rom pseudo-type */
  86.         hardware = ARP_NETROM;
  87.         break;
  88.     case 'e':    /* "ether" */
  89.         hardware = ARP_ETHER;
  90.         break;        
  91.     case 'a':    /* "ax25" */
  92.         switch(tolower(argv[2][1])) {
  93.         case 'x':
  94.             hardware = ARP_AX25;
  95.             break;
  96.         case 'r':
  97.             hardware = ARP_ARCNET;
  98.             break;
  99.         default:
  100.             tprintf("unknown hardware type \"%s\"\n",argv[2]);
  101.             return -1;
  102.         }
  103.         break;
  104.     case 'm':    /* "mac appletalk" */
  105.         hardware = ARP_APPLETALK;
  106.         break;
  107.     default:
  108.         tprintf("unknown hardware type \"%s\"\n",argv[2]);
  109.         return -1;
  110.     }
  111.     /* If an entry already exists, clear it */
  112.     if((ap = arp_lookup(hardware,addr)) != NULLARP)
  113.         arp_drop(ap);
  114.  
  115.     at = &Arp_type[hardware];
  116.     if(at->scan == NULLFP){
  117.         tprintf("Attach device first\n");
  118.         return 1;
  119.     }
  120.     /* Allocate buffer for hardware address and fill with remaining args */
  121.     hwaddr = mallocw(at->hwalen);
  122.     /* Destination address */
  123.     (*at->scan)(hwaddr,argv[3]);
  124.     ap = arp_add(addr,hardware,hwaddr,pub);    /* Put in table */
  125.     free(hwaddr);                /* Clean up */
  126.     stop_timer(&ap->timer);            /* Make entry permanent */
  127.     set_timer(&ap->timer,0L);
  128. #ifdef    RSPF
  129.     rspfarpupcall(addr,hardware,NULLIF);    /* Do an RSPF upcall */
  130. #endif    /* RSPF */
  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.