home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / tcp_ip / rip2 / ripcmd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-28  |  9.6 KB  |  418 lines
  1. /* RIP-related user commands
  2.  *   Al Broscious, N3FCT
  3.  *   Phil Karn, KA9Q
  4.  *
  5.  *    Changes Copyright (c) 1993 Jeff White - N0POY, All Rights Reserved.
  6.  *    Permission granted for non-commercial copying and use, provided
  7.  *    this notice is retained.
  8.  *
  9.  * Rehack for RIP-2 (RFC1388) by N0POY 4/1993
  10.  *
  11.  * Beta release 8/12/93 V0.91
  12.  *
  13.  */
  14.  
  15. #include <stdio.h>
  16. #include "global.h"
  17. #include "mbuf.h"
  18. #include "netuser.h"
  19. #include "internet.h"
  20. #include "cmdparse.h"
  21. #include "timer.h"
  22. #include "iface.h"
  23. #include "udp.h"
  24. #include "rip.h"
  25. #include "commands.h"
  26.  
  27. struct cmds Ripcmds[] = {
  28.    "accept",   dodroprefuse,  0, 2,
  29.       "rip accept <gateway> ",
  30.    "add",      doripadd,      0, 3,
  31.       "rip add <dest> <interval> [<flags>] [<ripver>] [AUTH <password>] [RD <routing domain>]",
  32.    "proxy",    doripproxy,    0, 4,
  33.       "rip proxy <src> <dest> <interval> [<flags>] [AUTH <password>] [RD <routing domain>]",
  34.    "drop",     doripdrop,     0, 2,
  35.       "rip drop <dest> [<domain>]",
  36.    "authadd",  doripauthadd,  0, 3,
  37.       "rip authadd <interface> <routing domain> [<password>]",
  38.    "authdrop", doripauthdrop, 0, 3,
  39.       "rip authdrop <interface> <routing domain>",
  40.    "reject",   doripreject,   0, 2,
  41.       "rip reject <version>",
  42.    "filter",   doripfilter,   0, 0, NULLCHAR,
  43.    "kick",     doripkick,     0, 0, NULLCHAR,
  44.    "merge",    doripmerge,    0, 0, NULLCHAR,
  45.    "refuse",   doaddrefuse,   0, 2,
  46.       "rip refuse <gateway>",    
  47.    "request",  doripreq,      0, 2, NULLCHAR,
  48.    "status",   doripstat,     0, 0, NULLCHAR,
  49.    "trace",    doriptrace,    0, 0, NULLCHAR,
  50.    "ttl",      doripttl,      0, 0, NULLCHAR,
  51.    NULLCHAR,
  52. };
  53.  
  54. // rip add 192.133.30.15 360 SUBPA 2 AUTH password RD 2 RT 0
  55. // rip add <dest> <interval> <ripver> [<flags>] [AUTH <password>] 
  56. //    [RD <routing domain>]
  57. // rip proxy <src> <dest> <interval> [<flags>] [AUTH <password>]
  58. //    [RD <routing domain>]
  59. // rip authadd <ifc> <rd> [<password>]
  60. // rip authdrop <ifc> <rd>
  61. // rip reject <ifc> <version>
  62. // rip filter <on|off>
  63. // rip drop <dest> <domain>
  64.  
  65. int
  66. dorip(argc,argv,p)
  67. int argc;
  68. char *argv[];
  69. void *p;
  70. {
  71.     return subcmd(Ripcmds,argc,argv,p);
  72. }
  73.  
  74. /* Add an entry to the RIP output list */
  75.  
  76. int
  77. doripadd(argc,argv,p)
  78. int argc;
  79. char *argv[];
  80. void *p;
  81. {
  82.    int x;
  83.    char flags = RIP_SPLIT | RIP_BROADCAST | RIP_POISON;
  84.    char ripver = 1;
  85.    char rip_auth[RIP_AUTH_SIZE+1];
  86.    int16 domain = 0;
  87.    int16 route_tag = 0;
  88.    int32 dest;
  89.  
  90.    for (x = 0; x < RIP_AUTH_SIZE+1; x++)    /* Null out the string */
  91.       rip_auth[x] = '\0';
  92.  
  93.    strcpy(rip_auth, RIP_NO_AUTH);
  94.  
  95.    if (argc > 3)
  96.       flags = htoi(argv[3]);
  97.    if (argc > 4)
  98.       ripver = atoi(argv[4]);
  99.    if (argc > 5) {
  100.       for (x = 5; x < argc; x++) {
  101.          if (!strcmp(argv[x], "AUTH")) {
  102.             x++;
  103.             strcpy(rip_auth,argv[x]);
  104.          } else if (!strcmp(argv[x], "RD")) {
  105.             x++;
  106.             domain = atoi(argv[x]);
  107.          }
  108.       }
  109.    }
  110.  
  111.    dest = resolve(argv[1]);
  112.     if (rip_add(dest,atol(argv[2]),flags,ripver,rip_auth,domain,route_tag,0)) {
  113.       return 0;
  114. //      if (ripver > RIP_VERSION_1) {
  115. //         struct route *rp;
  116. //
  117. //         rp = rt_lookup(dest);
  118. //         return(ripauthadd(rp->iface->name,domain,rip_auth));
  119. //      }
  120.    } else {
  121.       return 1;
  122.    }
  123.    return 0;
  124. }
  125.  
  126. /* Add a proxy entry to the RIP output list */
  127.  
  128. int
  129. doripproxy(argc,argv,p)
  130. int argc;
  131. char *argv[];
  132. void *p;
  133. {
  134.    int x;
  135.    char flags = RIP_SPLIT | RIP_BROADCAST | RIP_POISON;
  136.    char ripver = RIP_VERSION_2;
  137.    char rip_auth[RIP_AUTH_SIZE];
  138.    int16 domain = 0;
  139.    int16 route_tag = 0;
  140.    int32 dest;
  141.    int32 proxy;
  142.    struct route *rp;
  143.  
  144.    for (x = 0; x < RIP_AUTH_SIZE+1; x++)    /* Null out the string */
  145.       rip_auth[x] = '\0';
  146.  
  147.    strcpy(rip_auth, RIP_NO_AUTH);
  148.  
  149.    if (argc > 4)
  150.       flags = htoi(argv[4]);
  151.    if (argc > 5) {
  152.       for (x = 5; x < argc; x++) {
  153.          if (!strcmp(argv[x], "AUTH")) {
  154.             x++;
  155.             strcpy(rip_auth,argv[x]);
  156.          } else if (!strcmp(argv[x], "RD")) {
  157.             x++;
  158.             domain = atoi(argv[x]);
  159.          }
  160.       }
  161.    }
  162.  
  163.    dest = resolve(argv[2]);
  164.    proxy = resolve(argv[1]);
  165.     if (rip_add(dest,atol(argv[3]),flags,ripver,rip_auth,domain,route_tag,proxy)) {
  166. //      rp = rt_lookup(dest);
  167. //      return(ripauthadd(rp->iface->name,domain,rip_auth));
  168.    }
  169.    return 1;
  170. }
  171.  
  172. /* Add an entry to the RIP refuse list */
  173.  
  174. int
  175. doaddrefuse(argc,argv,p)
  176. int argc;
  177. char *argv[];
  178. void *p;
  179. {
  180.    return riprefadd(resolve(argv[1]));
  181. }
  182.  
  183. /* Drop an entry from the RIP output list */
  184.  
  185. int
  186. doripdrop(argc,argv,p)
  187. int argc;
  188. char *argv[];
  189. void *p;
  190. {
  191.    int16 domain = 0;
  192.  
  193.    if (argc > 2)
  194.       domain = atoi(argv[2]);
  195.  
  196.     return rip_drop(resolve(argv[1]),domain);
  197. }
  198.  
  199. /* Add an entry to the RIP authentication list */
  200.  
  201. int
  202. doripauthadd(argc,argv,p)
  203. int argc;
  204. char *argv[];
  205. void *p;
  206. {
  207.    if (argc > 3) {
  208.        return ripauthadd(argv[1],atoi(argv[2]),argv[3]);
  209.    } else {
  210.        return ripauthadd(argv[1],atoi(argv[2]),RIP_NO_AUTH);
  211.    }
  212. }
  213.  
  214. /* Drop an entry from the RIP authentication list */
  215.  
  216. int
  217. doripauthdrop(argc,argv,p)
  218. int argc;
  219. char *argv[];
  220. void *p;
  221. {
  222.     return ripauthdrop(argv[1],atoi(argv[2]));
  223. }
  224.  
  225. int
  226. doripkick(argc,argv,p)
  227. int argc;
  228. char *argv[];
  229. void *p;
  230. {
  231.    register struct rip_list *rl;
  232.  
  233.    rl = (struct rip_list *)Rip_list;
  234.    if(Rip_list != NULLRL)
  235.       for(rl = Rip_list; rl != NULLRL; rl = rl->next)
  236.          rip_shout(rl);
  237.    return 0;
  238. }
  239.  
  240. /* Drop an entry from the RIP refuse list */
  241.  
  242. int
  243. dodroprefuse(argc,argv,p)
  244. int argc;
  245. char *argv[];
  246. void *p;
  247. {
  248.    return riprefdrop(resolve(argv[1]));
  249. }
  250.  
  251. /* Initialize the RIP listener */
  252.  
  253. int
  254. doripinit(argc,argv,p)
  255. int argc;
  256. char *argv[];
  257. void *p;
  258. {
  259.    return rip_init();
  260. }
  261.  
  262. int
  263. doripstop(argc,argv,p)
  264. int argc;
  265. char *argv[];
  266. void *p;
  267. {
  268.    del_udp(Rip_cb);
  269.    Rip_cb = NULLUDP;
  270.    return 0;
  271. }
  272.  
  273. int
  274. doripreq(argc,argv,p)
  275. int argc;
  276. char *argv[];
  277. void *p;
  278. {
  279.    int16 replyport;
  280.    int16 version;
  281.  
  282.    if (argc > 2)
  283.       version = atoi(argv[2]);
  284.    else
  285.       version = 2;
  286.  
  287.    if(argc > 3)
  288.       replyport = atoi(argv[3]);
  289.    else
  290.       replyport = RIP_PORT;
  291.    return ripreq(resolve(argv[1]),replyport,version);
  292. }
  293.  
  294. /* Dump RIP statistics */
  295. int
  296. doripstat(argc,argv,p)
  297. int argc;
  298. char *argv[];
  299. void *p;
  300. {
  301.     struct rip_list *rl;
  302.     struct rip_refuse *rfl;
  303.    struct rip_auth *ra;
  304.    int cnt;
  305.  
  306.    for (cnt = 1; cnt < RIP_VERSIONS; cnt++) {
  307.        tprintf("RIP V%d: sent %lu rcvd %lu reqst %lu resp %lu unk %lu\n",
  308.         cnt, Rip_stat.vdata[cnt].output, Rip_stat.vdata[cnt].rcvd,
  309.        Rip_stat.vdata[cnt].request, Rip_stat.vdata[cnt].response,
  310.         Rip_stat.vdata[cnt].unknown);
  311.    }
  312.  
  313.    tprintf("Version Errors:            %lu   ",Rip_stat.version);
  314.    tprintf("Address Family Errors:     %lu\n",Rip_stat.addr_family);
  315.    tprintf("Rip refusals:              %lu   ",Rip_stat.refusals);
  316.    tprintf("Wrong Domain on Interace:  %lu\n",Rip_stat.wrong_domain);
  317.    tprintf("Authentication failures:   %lu   ",Rip_stat.auth_fail);
  318.    tprintf("Unknown Authentication:    %lu\n",Rip_stat.unknown_auth);
  319.  
  320.     if(Rip_list != NULLRL){
  321.         tprintf("Active RIP output interfaces:\n");
  322.         tprintf("Ver Dest Addr       Int  Flags Domain Proxy           Authentication\n");
  323.         for(rl=Rip_list; rl != NULLRL; rl = rl->next){
  324.          tprintf("%-4d%-16s%-5lu0x%-4X%-7u", rl->rip_version,
  325.              inet_ntoa(rl->dest),rl->interval, rl->flags,rl->domain);
  326.          tprintf("%-16s%-16s\n", inet_ntoa(rl->proxy_route), rl->rip_auth_code);
  327.         }
  328.     }
  329.     if(Rip_refuse != NULLREF){
  330.         tprintf("Refusing announcements from gateways:\n");
  331.         for(rfl=Rip_refuse; rfl != NULLREF;rfl = rfl->next){
  332.             if(tprintf("%s\n",inet_ntoa(rfl->target)) == EOF)
  333.                 break;
  334.         }
  335.     }
  336.    if (Rip_auth != NULLAUTH) {
  337.       tprintf("\nAuthentications accepted:\n");
  338.       tprintf("Interface           Domain   Password\n");
  339.       for (ra = Rip_auth; ra != NULLAUTH; ra = ra->next) {
  340.          tprintf("%-20s%-9u%-16s\n",ra->ifc_name,ra->domain,ra->rip_auth_code);
  341.       }
  342.    }
  343.    tprintf("Refusing versions less than or equal to V%d\n",Rip_ver_refuse);
  344.  
  345.     return 0;
  346. }
  347.  
  348. int
  349. doriptrace(argc,argv,p)
  350. int argc;
  351. char *argv[];
  352. void *p;
  353. {
  354.    if (argc > 1) {
  355.       Rip_trace = atoi(argv[1]);
  356.       if ((Rip_trace == 0) && (Rip_trace_file != NULLFILE)) {  // Turn off tracing
  357.          fclose(Rip_trace_file);
  358.          Rip_trace_file = NULLFILE;
  359.          if (Rip_trace_fname != NULLCHAR) {
  360.             free(Rip_trace_fname);
  361.             Rip_trace_fname = NULLCHAR;
  362.          }
  363.       }
  364.       if (argc > 2) {
  365.          if ((Rip_trace_file = fopen(argv[2],APPEND_TEXT)) == NULLFILE) {
  366.             tprintf("Cannot write to %s\n",argv[2]);
  367.          } else {
  368.             Rip_trace_fname = strdup(argv[2]);
  369.          }
  370.          fclose(Rip_trace_file);
  371.       }
  372.    } else {
  373.       if (Rip_trace_file != NULLFILE) {
  374.          tprintf("Tracing RIP status level %d to file %s\n", Rip_trace,
  375.             Rip_trace_fname);
  376.       } else {
  377.          tprintf("Tracing RIP status level %d\n", Rip_trace);
  378.       }
  379.    }
  380.    return 0;
  381. }
  382.  
  383. int
  384. doripttl(argc,argv,p)
  385. int argc;
  386. char *argv[];
  387. void *p;
  388. {
  389.    return setlong(&Rip_ttl,"RIP route ttl",argc,argv);
  390. }
  391.  
  392. int
  393. doripreject(argc,argv,p)
  394. int argc;
  395. char *argv[];
  396. void *p;
  397. {
  398.    return setshort(&Rip_ver_refuse,"RIP version refusal level",argc,argv);
  399. }
  400.  
  401. int
  402. doripmerge(argc,argv,p)
  403. int argc;
  404. char *argv[];
  405. void *p;
  406. {
  407.    return setbool((int *)&Rip_merge,"RIP merging",argc,argv);
  408. }
  409.  
  410. int
  411. doripfilter(argc,argv,p)
  412. int argc;
  413. char *argv[];
  414. void *p;
  415. {
  416.    return setbool((int *)&Rip_default_refuse,"RIP default refusal",argc,argv);
  417. }
  418.