home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / n / tcpip / netkit-a.06 / netkit-a / NetKit-A-0.06 / dip337d-uri / command.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-01  |  20.7 KB  |  1,047 lines
  1. /*
  2.  * dip        A program for handling dialup IP connecions.
  3.  *        Script language processor.
  4.  *
  5.  * Version:    @(#)command.c    3.3.5    12/13/93
  6.  *
  7.  * Author:      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  8.  *        Copyright 1988-1993 MicroWalt Corporation
  9.  *
  10.  *        This program is free software; you can redistribute it
  11.  *        and/or  modify it under  the terms of  the GNU General
  12.  *        Public  License as  published  by  the  Free  Software
  13.  *        Foundation;  either  version 2 of the License, or  (at
  14.  *        your option) any later version.
  15.  */
  16. #include "dip.h"
  17.  
  18.  
  19. struct commands {
  20.   char    *name;
  21.   int    (*func)(int, char **);
  22. };
  23.  
  24.  
  25. static int    timeout;        /* script "wait" timed out    */
  26. static int    errlevel;        /* script command return code    */
  27. static FILE    *scriptfp = (FILE *)NULL;    /* input script pointer    */
  28. static char    *var_modem = NULL;    /* name of modem we are using    */
  29. static char    *var_port = NULL;    /* terminal line used        */
  30. static char    *var_speed = NULL;    /* terminal line speed        */
  31. static int    var_echo = 0;        /* enable line data echoing    */
  32.  
  33.  
  34. static void
  35. TimeOut(int sig)
  36. {
  37.   (void) sig;
  38.   timeout = 1;
  39. }
  40.  
  41.  
  42. /* Convert a C-style backslash sequence to ASCII. */
  43. static char
  44. cvt_char(char c)
  45. {
  46.   if (c == '\0') return(c);
  47.   switch(c) {
  48.     case 'a':
  49.         return('\a');
  50.  
  51.     case 'b':
  52.  
  53.         return('\b');
  54.  
  55.     case 'f':
  56.         return('\f');
  57.  
  58.     case 'n':
  59.         return('\n');
  60.  
  61.     case 'r':
  62.         return('\r');
  63.  
  64.     case 's':
  65.         return(' ');
  66.  
  67.     case 't':
  68.         return('\t');
  69.  
  70.     case 'v':
  71.         return('\v');
  72.  
  73.     case '\\':
  74.         return('\\');
  75.  
  76.     case '\'':
  77.         return('\'');
  78.  
  79.     case '"':
  80.         return('\"');
  81.  
  82.     case '?':
  83.         return('\?');
  84.  
  85.     default:
  86.         return('?');
  87.   }
  88.   /* NOTREACHED */
  89.   return('?');
  90. }
  91.  
  92.  
  93. /* Split the input string into multiple fields. */
  94. static int
  95. getargs(char *string, char *arguments[])
  96. {
  97.   char *sp;
  98.   int argc;
  99.   int i;
  100.  
  101.   sp = string; i = 0;
  102.   arguments[i] = sp;
  103.   while (*sp && i < 32) {
  104.         while (*sp && (*sp == ' ' || *sp == '\t')) sp++;
  105.         arguments[i++] = sp;
  106.         while (*sp && *sp != ' ' && *sp != '\t') sp++;
  107.         if (*sp != '\0') *sp++ = '\0';
  108.   }
  109.   argc = i;
  110.   while (i < 32) arguments[i++] = (char *)NULL;
  111.   return(argc);
  112. }
  113.  
  114.  
  115. /************************************************************************
  116.  *                                    *
  117.  *        Internal Scripting Commands                *
  118.  *                                    *
  119.  ************************************************************************/
  120.  
  121. /* Enable/Disable echoing of data from terminal line. */
  122. static int
  123. do_echo(int argc, char *argv[])
  124. {
  125.   if (argc != 2) {
  126.     fprintf(stderr, "Usage: echo on|off\n");
  127.     return(-1);
  128.   }
  129.   
  130.   if (strcmp(argv[1], "on") == 0) var_echo = 1;
  131.     else if (strcmp(argv[1], "off") == 0) var_echo = 0;
  132.     else {
  133.     fprintf(stderr, "Usage: echo on|off\n");
  134.     return(-1);
  135.   }
  136.     
  137.   if (opt_v == 1) printf("Display modem output: %sabled\n",
  138.                 (var_echo == 0) ? "dis" : "en");
  139.   return(0);
  140. }
  141.  
  142.  
  143. /* Go to some label in the script. */
  144. static int
  145. do_goto(int argc, char *argv[])
  146. {
  147.   char buff[1024];
  148.   off_t oldpos;
  149.   char *label, *xp;
  150.   char *sp;
  151.  
  152.   if (argc != 2) {
  153.     fprintf(stderr, "Usage: goto label\n");
  154.     return(-1);
  155.   }
  156.   if (scriptfp == stdin) {
  157.     fprintf(stderr, "dip: GOTO not possible in TEST mode!\n");
  158.     return(-1);
  159.   }
  160.  
  161.   label = argv[1];
  162.   oldpos = ftell(scriptfp);
  163.   rewind(scriptfp);
  164.   (void) fflush(scriptfp);
  165.  
  166.   do {
  167.         if (fgets(buff, 1024, scriptfp) == (char *)NULL) break;
  168.     if ((sp = strchr(buff, '\n')) != (char *)NULL) *sp = '\0';
  169.     sp = buff;
  170.     while (*sp == ' ' || *sp == '\t') sp++;
  171.     if (*sp == '#' || *sp == '\0') continue;
  172.     if ((xp = strchr(sp, ':')) == (char *)NULL) continue;
  173.     *xp = '\0';
  174.     if (! strcmp(label, sp)) {
  175.         oldpos = ftell(scriptfp);
  176.         (void) fseek(scriptfp, oldpos, SEEK_SET);
  177.         return(0);
  178.     }
  179.   } while(1);
  180.   (void) fseek(scriptfp, oldpos, SEEK_SET);
  181.   (void) fflush(scriptfp);
  182.   return(-1);
  183. }
  184.  
  185.  
  186. /* Check some error (result) code. */
  187. static int
  188. do_if(int argc, char *argv[])
  189. {
  190.   char *cmd[3];
  191.   char opcode;
  192.   long val, var;
  193.   int ret;
  194.  
  195.   if (argc != 6) {
  196.     fprintf(stderr, "Usage: if expr goto label\n");
  197.     return(-1);
  198.   };
  199.   if (! strcmp(argv[2], "==")) opcode = '=';
  200.     else if (! strcmp(argv[2], "!=")) opcode = '@';
  201.     else if (! strcmp(argv[2], "<")) opcode = '<';
  202.     else if (! strcmp(argv[2], ">")) opcode = '>';
  203.     else if (! strcmp(argv[2], "<=")) opcode = 'L';
  204.     else if (! strcmp(argv[2], ">=")) opcode = 'G';
  205.     else {
  206.     fprintf(stderr, "Syntax error: \"%s\" is not an opcode!\n", argv[2]);
  207.     return(-1);
  208.   }
  209.   val = (long) atol(argv[3]);
  210.  
  211.   if (! strcmp(argv[1], "$errlvl")) var = (long) errlevel;
  212.     else if (! strcmp(argv[1], "$locip")) var = (long) mydip.loc_ip.s_addr;
  213.     else if (! strcmp(argv[1], "$rmtip")) var = (long) mydip.rmt_ip.s_addr;
  214.     else {
  215.     fprintf(stderr, "Invalid variable \"%s\" !\n", argv[1]);
  216.     return(-1);
  217.   }
  218.  
  219.   ret = -1;
  220.   switch(opcode) {
  221.     case '=':    /* EQUAL */
  222.         ret = (var == val);
  223.         break;
  224.  
  225.     case '@':    /* NOT EQUAL */
  226.         ret = (var != val);
  227.         break;
  228.  
  229.     case '<':    /* LESS */
  230.         ret = (var < val);
  231.         break;
  232.  
  233.     case 'L':    /* LESS-EQ */
  234.         ret = (var <= val);
  235.         break;
  236.  
  237.     case '>':    /* GREATER */
  238.         ret = (var > val);
  239.         break;
  240.  
  241.     case 'G':    /* GREATER-EQ */
  242.         ret = (var >= val);
  243.         break;
  244.   }
  245.  
  246.   if (strcmp(argv[4], "goto")) {
  247.     fprintf(stderr, "Warning: keyword not \"goto\" !\n");
  248.     argv[4] = "goto";
  249.   }
  250.  
  251.   if (ret != 0) {
  252.     cmd[1] = argv[4];
  253.     cmd[1] = argv[5];
  254.     cmd[2] = (char *)NULL;
  255.     return(do_goto(2, cmd));
  256.   }
  257.   return(-1);
  258. }
  259.  
  260.  
  261. /* Print the contents of some variable. */
  262. static int
  263. do_print(int argc, char *argv[])
  264. {
  265.   char *sp;
  266.   int i;
  267.  
  268.   if (argc == 1) {
  269.     printf("\n");
  270.     return(0);
  271.   }
  272.   i = 0;
  273.   while (argv[++i] != (char *)NULL) {
  274.     sp = argv[i];
  275.     if (i != 1) printf(" ");
  276.     if (*sp == '$') {
  277.         if (! strcmp(++sp, "errlvl")) printf("%d", errlevel);
  278.           else if (! strcmp(sp, "locip")) printf("%s",
  279.                     inet_ntoa(mydip.loc_ip));
  280.           else if (! strcmp(sp, "rmtip")) printf("%s",
  281.                     inet_ntoa(mydip.rmt_ip));
  282.           else if (! strcmp(sp, "local")) printf("%s", mydip.local);
  283.           else if (! strcmp(sp, "remote")) printf("%s", mydip.remote);
  284.           else if (! strcmp(sp, "modem")) printf("%s", var_modem);
  285.           else if (! strcmp(sp, "port")) printf("%s", var_port);
  286.           else if (! strcmp(sp, "speed")) printf("%s", var_speed);
  287.           else fprintf(stderr, "Unknown variable %s\n", sp);
  288.     } else printf("%s", sp);
  289.   }
  290.   printf("\n");
  291.   return(0);
  292. }
  293.  
  294.  
  295. /* Send a string to the serial driver. */
  296. static int
  297. do_send(int argc, char *argv[])
  298. {
  299.   char *sp;
  300.   char c;
  301.   int i;
  302.   
  303.   if (argc < 2) {
  304.     fprintf(stderr, "Usage: send text...\n");
  305.     return(-1);
  306.   }
  307.  
  308.   for (i = 1; i < argc; i++) {
  309.       sp = argv[i];
  310.       while(*sp != '\0') {
  311.         switch(*sp) {
  312.             case '~':
  313.                 tty_putc('\r');
  314.                 tty_putc('\n');
  315.                 break;
  316.  
  317.             case '\\':
  318.                 sp++;
  319.                 c = cvt_char(*sp);
  320.                 tty_putc((int) c);
  321.                 break;
  322.  
  323.             default:
  324.                 c = *sp;
  325.                 tty_putc((int) c);
  326.         }
  327.         sp++;
  328.       }
  329.         if (i < (argc - 1)) tty_putc(' ');
  330.   }
  331.   tty_putc(-1);        /* flush the connection */
  332.   return(0);
  333. }
  334.  
  335.  
  336. /* Wait some time. */
  337. static int
  338. do_sleep(int argc, char *argv[])
  339. {
  340.   int secs;
  341.  
  342.   if (argc != 2) {
  343.     fprintf(stderr, "Usage: sleep time_in_secs\n");
  344.     return(-1);
  345.   }
  346.  
  347.   secs = atoi(argv[1]);
  348.   (void) sleep(secs);
  349.   return(0);
  350. }
  351.  
  352.  
  353. /* Flush tty input */
  354. static int
  355. do_flush(int argc, char *argv[])
  356. {
  357.   if (argc != 1) {
  358.     fprintf(stderr, "Usage: flush\n");
  359.     return(-1);
  360.   }
  361.  
  362.   tty_flush();
  363.   return(0);
  364. }
  365.  
  366.  
  367. /* Wait for some string to arrive. */
  368. static int
  369. do_wait(int argc, char *argv[])
  370. {
  371.   char c, c2, *p;
  372.   int howlong;
  373.   void (*oldsig)(int);
  374.  
  375.   if (argc == 1 || argc > 3) {
  376.     fprintf(stderr, "Usage: wait text [timeout_value]\n");
  377.     return(-1);
  378.   }
  379.  
  380.   if (argc == 3) howlong = atoi(argv[2]);
  381.     else howlong = 0;
  382.   oldsig = signal(SIGALRM, TimeOut);
  383.   (void) alarm(howlong);
  384.  
  385.   p = argv[1];
  386.   timeout = 0;
  387.   while(!timeout && *p != '\0') {
  388.     c = (char) tty_getc();
  389.     c &= 0177;
  390.     if (var_echo == 1) {
  391.         fputc(c, stdout);
  392.         fflush(stdout);
  393.     }
  394.     if (timeout == 1) break;
  395.     if (*p == '\\') c2 = cvt_char(*++p);
  396.       else c2 = *p;
  397.     if (c2 != c) p = argv[1];
  398.       else p++;
  399.   }
  400.   (void) alarm(0);
  401.   (void) signal(SIGALRM, oldsig);
  402.   return((timeout == 1) ? -1 : 0);
  403. }
  404.  
  405.  
  406. /* Show some help. */
  407. static int
  408. do_help(int argc, char *argv[])
  409. {
  410.   extern struct commands commands[];
  411.   int i, j;
  412.  
  413.   i = 0; j = 0;
  414.   printf("DIP knows about the following commands:\n\n");
  415.   while (commands[i].name != (char *)NULL) {
  416.     if (j++ == 0) printf("\t");
  417.     printf("%-8.8s ", commands[i].name);
  418.     if (j == 5) {
  419.         printf("\n");
  420.         j = 0;
  421.     }
  422.     i++;
  423.   }
  424.   if (j != 0) printf("\n\n");
  425.     else printf("\n");
  426.   return(0);
  427. }
  428.  
  429.  
  430. /************************************************************************
  431.  *                                    *
  432.  *        Modem Handling and Dialing Commands            *
  433.  *                                    *
  434.  ************************************************************************/
  435.  
  436.  
  437. /* Set the name of the terminal port to use. */
  438. static int
  439. do_port(int argc, char *argv[])
  440. {
  441.   if (argc != 2) {
  442.     fprintf(stderr, "Usage: port tty_name\n");
  443.     return(-1);
  444.   }
  445.   if (var_port != NULL) {
  446.     fprintf(stderr, "PORT: terminal port already set to \"%s\".\n",
  447.                                 var_port);
  448.     return(-1);
  449.   }
  450.   var_port = argv[1];
  451.   if (opt_v == 1) printf("PORT: terminal port set to \"%s\".\n", var_port);
  452.  
  453.   /* Initialize the terminal line. */
  454.   if (tty_open(var_port) < 0) {
  455.     var_port = NULL;
  456.     return(-1);
  457.   }
  458.  
  459.   return(0);
  460. }
  461.  
  462.  
  463. /* Set the correct DATABITS to use. */
  464. static int
  465. do_databits(int argc, char *argv[])
  466. {
  467.   if (argc != 2) {
  468.         fprintf(stderr, "Usage: databits bits\n");
  469.         return(-1);
  470.   }
  471.   if (var_port == NULL) { 
  472.         fprintf(stderr, "Please set PORT first.\n");
  473.         return(-1);
  474.   }  
  475.   return(tty_databits(argv[1]));
  476. }
  477.  
  478.  
  479. /* Define a modem "INIT" string. */
  480. static int
  481. do_init(int argc, char *argv[])
  482. {
  483.   if (argc != 2) {
  484.     fprintf(stderr, "Usage: init <init string>\n");
  485.     return(-1);
  486.   }
  487.   return(mdm_init(argv[1]));
  488. }
  489.  
  490.  
  491. static int
  492. do_dial(int argc, char *argv[])
  493. {
  494.   if (argc != 2) {
  495.     fprintf(stderr, "Usage: dial telno\n");
  496.     return(-1);
  497.   }
  498.  
  499.   if (var_modem == NULL) {
  500.     fprintf(stderr, "Please set MODEM first.\n");
  501.     return(-1);
  502.   }
  503.   return(mdm_dial(argv[1]));
  504. }
  505.  
  506.  
  507. /* Set the name of the modem we want to use. */
  508. static int
  509. do_modem(int argc, char *argv[])
  510. {
  511.   if (argc != 2) {
  512.     fprintf(stderr, "Usage: modem modem_name\n");
  513.     return(-1);
  514.   }
  515.   if (var_modem != NULL) {
  516.     fprintf(stderr, "MODEM: modem already set to \"%s\".\n", var_modem);
  517.     return(-1);
  518.   }
  519.   var_modem = argv[1];
  520.   if (opt_v == 1) printf("MODEM: modem set to \"%s\".\n", var_modem);
  521.  
  522.   /* Initialize this modem. */
  523.   if (mdm_modem(var_modem) < 0) {
  524.     var_modem = NULL;
  525.     return(-1);
  526.   }
  527.  
  528.   return(0);
  529. }
  530.  
  531.  
  532. static int
  533. do_parity(int argc, char *argv[])
  534. {
  535.   if (argc != 2) {
  536.         fprintf(stderr, "Usage: parity E/O/N\n");
  537.         return(-1);
  538.   }
  539.  
  540.   if (var_port == NULL) {
  541.         fprintf(stderr, "Please set PORT first.\n");
  542.         return(-1);
  543.   }
  544.   return(tty_parity(argv[1]));
  545. }
  546.  
  547.  
  548. /* Reset the modem. */
  549. static int
  550. do_reset(int argc, char *argv[])
  551. {
  552.   if (argc != 1) {
  553.     fprintf(stderr, "Usage: reset\n");
  554.     return(-1);
  555.   }
  556.  
  557.   /* Did we get a modem to work with? */
  558.   if (var_modem == NULL) {
  559.     fprintf(stderr, "Please set MODEM first.\n");
  560.     return(-1);
  561.   }
  562.  
  563.   /* Reset the modem. */
  564.   (void) mdm_reset();
  565.   return(0);
  566. }
  567.  
  568.  
  569. /* Set the correct SPEED to use. */
  570. static int
  571. do_speed(int argc, char *argv[])
  572. {
  573.   if (argc != 2) {
  574.     fprintf(stderr, "Usage: speed baudrate\n");
  575.     return(-1);
  576.   }
  577.   if (var_port == NULL) {
  578.     fprintf(stderr, "Please set PORT first.\n");
  579.     return(-1);
  580.   }
  581.   return(tty_speed(argv[1]));
  582. }
  583.  
  584.  
  585. /* Set the correct STOPBITS to use. */
  586. static int
  587. do_stopbits(int argc, char *argv[])
  588. {
  589.   if (argc != 2) {
  590.         fprintf(stderr, "Usage: stopbits bits\n");
  591.         return(-1);
  592.   }
  593.   if (var_port == NULL) {
  594.         fprintf(stderr, "Please set PORT first.\n");
  595.         return(-1);
  596.   }
  597.   return(tty_stopbits(argv[1]));
  598. } 
  599.  
  600.  
  601. /* Enter a TERMINAL mode. */
  602. static int
  603. do_term(int argc, char *argv[])
  604. {
  605.   if (argc != 1) {
  606.     fprintf(stderr, "Usage: term\n");
  607.     return(-1);
  608.   }
  609.   if (var_port == NULL) {
  610.     fprintf(stderr, "Please set PORT first.\n");
  611.     return(-1);
  612.   }
  613.   do_terminal();
  614.   return(0);
  615. }
  616.  
  617.  
  618. /************************************************************************
  619.  *                                    *
  620.  *        Connection Setup Commands                *
  621.  *                                    *
  622.  ************************************************************************/
  623.  
  624. /*
  625.  * Get or ask for the value of a variable.
  626.  * Get local IP#, Remote IP# and MTU
  627.  */
  628.  
  629. #define VAR_IP        1
  630. #define VAR_NUM        2
  631. #define VAR_STR        3
  632.  
  633. static int
  634. do_get(int argc, char *argv[])
  635. {
  636.   char str[128] = "";
  637.   int var = 0;
  638.   void *v1 = NULL, *v2 = NULL;
  639.   void (*oldsig)(int);
  640.    
  641.   if (argc <= 2 || argc > 4 || argv[1][0] != '$') {
  642.      fprintf(stderr,
  643.         "Usage: get $variable [value|ask|remote [timeout_value]]\n");
  644.      return(-1);
  645.   }
  646.    
  647.   if (! strcmp(argv[1], "$locip") || !strcmp(argv[1], "$local")) {
  648.     v1 = (void *) mydip.local;
  649.     v2 = (void *) &mydip.loc_ip;
  650.     var = VAR_IP;
  651.   } else if (! strcmp(argv[1], "$rmtip") || !strcmp(argv[1], "$remote")) {
  652.     v1 = (void *) mydip.remote;
  653.     v2 = (void *) &mydip.rmt_ip;
  654.     var = VAR_IP;
  655.   } else if (! strcmp(argv[1], "$mtu")) {
  656.     v1 = (void *) &mydip.mtu;
  657.     var = VAR_NUM;
  658.   } else {
  659.      fprintf(stderr, "Variables must be :$locip|$rmtip|$local|$remote|$mtu\n");
  660.      return (-1);
  661.   }
  662.  
  663.   if (argc > 2) {
  664.     if (! strcmp(argv[2], "ask")) {
  665.         /* Ask the stdinput for the value of the variable. */
  666.         register char *sp;
  667.  
  668.         fprintf(stderr, "Enter the value for %s: ", argv[1]);
  669.         if (fgets(str, 128, stdin) == (char *)NULL) return(1);
  670.         if ((sp = strchr(str, '\n')) != (char *)NULL) *sp = '\0';
  671.     } else if (! strcmp(argv[2],"remote")) {
  672.         /* Get the variable string from the "remote" line */
  673.         register char c, *p;
  674.         int howlong = 0, state = 0;
  675.  
  676.         if (argc == 4) howlong = atoi(argv[3]);
  677.         oldsig = signal(SIGALRM, TimeOut);
  678.         (void) alarm(howlong);
  679.  
  680.         p = str;
  681.         timeout = 0;
  682.         state = 0;
  683.         if (var == VAR_IP || var == VAR_NUM) state = 1;
  684.         while(!timeout && (state >= 0)) {
  685.             c = (char) tty_getc();
  686.             c &= 0177;
  687.             if (timeout == 1) break;
  688.             switch (state) {
  689.                 case 0: /* throw away "white space" */
  690.                     if (! strchr(" \n\t", c)) break;
  691.                     if (var == VAR_STR) {
  692.                         *(p++) = c;
  693.                         state = 10;
  694.                         break;
  695.                     }
  696.                     state = 1;
  697.  
  698.                 case 1:
  699.                     if ( c >= '0' && c <= '9' ) {
  700.                         *(p++) = c;
  701.                         if (var == VAR_IP) {
  702.                             state = 2;
  703.                             break;
  704.                         } else state = 5;
  705.                         break;
  706.                     }
  707.                     break; 
  708.  
  709.                 case 2:
  710.                 case 3:
  711.                 case 4:
  712.                     if ((c >= '0' && c <= '9') || c == '.') {
  713.                         *(p++) = c;
  714.                         if (c == '.') state++;
  715.                         break;
  716.                     } 
  717.                     p = str;
  718.                     state = 0;
  719.                     break;
  720.                     case 5:
  721.                     if (c >= '0' && c <= '9') {
  722.                         *(p++) = c;
  723.                         break;
  724.                     } 
  725.                     state = -1;
  726.                     break;
  727.  
  728.                 case 10:
  729.                     if (strchr(" \n\t", c)) state = -1;
  730.                     else *(p++) = c;
  731.                     break;
  732.  
  733.                 default:
  734.                     break;
  735.             }
  736.         }
  737.         *p = '\0';
  738.         (void) alarm(0);
  739.         (void) signal(SIGALRM, oldsig);
  740.         if (timeout == 1) return (1);
  741.     } else {
  742.         /* The third argv is the value for the variable. */
  743.         strncpy(str, argv[2], 128);
  744.     }
  745.   }
  746.  
  747.   if (opt_v == 1) printf("About to set variable %s to %s\n", argv[1], str);
  748.  
  749.   if (*str) {
  750.     switch (var) {
  751.         case VAR_IP:
  752.             {
  753.                 struct hostent *hp;
  754.                 hp = gethostbyname(str);
  755.                 if (hp == (struct hostent *)NULL) {
  756.                     herror(str);
  757.                     return(-1);
  758.                 }
  759.                 strncpy((char *) v1, hp->h_name, 128);
  760.                 memcpy((char *) v2, (char *) hp->h_addr_list[0],
  761.                        hp->h_length);
  762.             }
  763.             break;
  764.  
  765.         case VAR_NUM:
  766.             *(int *) v1 = atoi(str);
  767.             break;
  768.  
  769.         case VAR_STR:
  770.             strcpy((char *) v1, str);
  771.             break;
  772.  
  773.         default:
  774.             break;
  775.     }
  776.   }
  777.  
  778.   return(0);
  779. }
  780.  
  781.  
  782. /* Enter a specific protocol. */
  783. static int
  784. do_mode(int argc, char *argv[])
  785. {
  786.   register int i;
  787.  
  788.   if ((argc != 2) ||
  789.       ((i = get_prot(argv[1])) == 0)) {
  790.     fprintf(stderr, "Usage: mode protocol_name\n");
  791.     return(-1);
  792.   }
  793.  
  794.   if (mydip.rmt_ip.s_addr == INADDR_ANY) {
  795.     fprintf(stderr, "Please set REMOTE first.\n");
  796.     return(-1);
  797.   }
  798.   mydip.protonr = i;
  799.  
  800.   /* Enter BACKGROUND mode here! */
  801.   (void) dip_daemon(&mydip);
  802.  
  803.   /*NOTREACHED*/
  804.   return(i);
  805. }
  806.  
  807. /* Quit upon error - reset the tty to the proper ldisc */
  808. static int
  809. do_quit(int argc, char *argv[])
  810. {
  811.   (void) tty_close();
  812.   exit(1);
  813. }
  814.  
  815. /* Store the netmask in "mydip" structure */
  816. static int
  817. do_netmask(int argc, char *argv[])
  818. {
  819.    if (argc != 2) {
  820.       fprintf(stderr, 
  821.               "Usage of this command: netmask xxx.xxx.xxx.xxx\n");
  822.       return(-1);
  823.    }
  824.    strcpy(mydip.netmask, argv[1]);
  825.    return(0);
  826. }
  827.  
  828. /* Set routing as default */
  829. static int
  830. do_default(int argc, char *argv[])
  831. {
  832.   if (argc != 1) {
  833.     fprintf(stderr, "Usage: default\n");
  834.     return(-1);
  835.   }
  836.   if (opt_v == 1) printf("Destination net/address set to 'default'\n");
  837.  
  838.   mydip.rtdefault = 1;
  839.   return(0);
  840. }
  841.  
  842.  
  843. /************************************************************************
  844.  *                                    *
  845.  *                Password Handling                    *
  846.  *                                    *
  847.  ************************************************************************/
  848.  
  849.  
  850. /* Prompt for a password to be sent */
  851. static int
  852.     do_password(int argc, char *argv[])
  853. {
  854.     char    *prompt = "Password:";
  855.     char    *pass[3];
  856.     
  857.     pass[0] = "send";        /* in case anyone cares */
  858.     pass[2] = NULL;        /* ditto */
  859.     
  860.     if (argc > 1)
  861.     prompt = argv[1];
  862.  
  863.     pass[1] = getpass(prompt);
  864.     do_send(2, &pass[0]);
  865.  
  866.     return(0);
  867. }
  868.  
  869. #ifdef SKEY
  870. /* scan the input stream for an S/Key challenge, prompt
  871.    the user for their secret password, generate the response
  872.    and send it to the remote host - simple....
  873.  
  874.    Parts of this code are based on skey.c in the S/Key package */
  875.  
  876. static int
  877.     do_skey(int    argc, char *argv[])
  878. {
  879.     char    buf[256];
  880.     char    *p = buf;
  881.     char    *sp;
  882.     char    c;
  883.     void    (*oldsig)(int);
  884.     int        howlong = 0;
  885.     int        challenge;
  886.     char    *seed, passwd[256], key[8];
  887.     char    response[33];
  888.     char    *param[4];
  889.  
  890.     if (argc > 2) {
  891.     fprintf(stderr, "Usage: skey [timeout]\n");
  892.     return(-1);
  893.     }
  894.  
  895.     if (argc == 2) howlong = atoi(argv[1]);
  896.     oldsig = signal(SIGALRM, TimeOut);
  897.     (void) alarm(howlong);
  898.     timeout = 0;
  899.  
  900.     while (!timeout) {
  901.     c = (char) tty_getc();
  902.     c &= 0177;
  903.     if (timeout) break;
  904.  
  905.     if (c == '\r') {
  906.         *p = '\0';
  907.         if (strncmp(buf, SKEY_CHALLENGE, strlen(SKEY_CHALLENGE)) == 0)
  908.         break;
  909.         else
  910.         p = buf;
  911.     }
  912.     else if (c != '\n') { /* just add the char to the buffer */
  913.         *p++ = c;
  914.     }
  915.     }
  916.  
  917.     (void) alarm(0);
  918.     (void) signal(SIGALRM, oldsig);
  919.     if (timeout == 1) return (1);
  920.  
  921.     if (opt_v == 1) printf("Challenge string <%s>\n", buf);
  922.  
  923.     p = buf + strlen(SKEY_CHALLENGE);
  924.     while (*p && (!isdigit((int) *p))) p++;
  925.     sp = p;
  926.     while (*p && isdigit((int) *p)) p++;
  927.     *p++ = '\0';
  928.     challenge = atoi(sp);
  929.  
  930.     while (*p && isspace((int) *p)) p++;
  931.     seed = p;
  932.     while (*p && (!isspace((int) *p)) && (*p != ']')) p++;
  933.     *p = '\0';
  934.  
  935.     printf ("Enter secret password: ");
  936.     readpass (passwd, sizeof (passwd));
  937.  
  938.     /* Crunch seed and password into starting key */
  939.     if (keycrunch (key, seed, passwd) != 0) {
  940.     fprintf (stderr, "%s: key crunch failed\n", argv[0]);
  941.     return(1);
  942.     }
  943.  
  944.     while (challenge-- != 0)
  945.     f (key);
  946.  
  947.     (void) btoe (response, key);
  948.  
  949.     /* build up our command for do_send */
  950.     param[0] = "send";
  951.     param[1] = response;
  952.     param[2] = "\r";
  953.     param[3] = NULL;
  954.  
  955.     return(do_send(3, ¶m[0]));
  956. }
  957. #endif /* SKEY */
  958.     
  959.  
  960. struct commands commands[] = {
  961.   { "databits",         do_databits     },
  962.   { "default",        do_default    },
  963.   { "dial",        do_dial        },
  964.   { "echo",        do_echo        },
  965.   { "flush",        do_flush    },
  966.   { "get",        do_get       },
  967.   { "goto",        do_goto        },
  968.   { "help",        do_help        },
  969.   { "if",        do_if        },
  970.   { "init",        do_init        },
  971.   { "mode",        do_mode        },
  972.   { "modem",        do_modem    },
  973.   { "netmask",          do_netmask      },
  974.   { "parity",           do_parity       },
  975.   { "password",        do_password    },
  976.   { "print",        do_print    },
  977.   { "port",        do_port        },
  978.   { "quit",             do_quit         },
  979.   { "reset",        do_reset    },
  980.   { "send",        do_send        },
  981. #ifdef SKEY
  982.   { "skey",        do_skey        },
  983. #endif
  984.   { "sleep",        do_sleep    },
  985.   { "speed",        do_speed    },
  986.   { "stopbits",         do_stopbits     },
  987.   { "term",        do_term        },
  988.   { "wait",        do_wait        },
  989.   { (char *)NULL,    NULL        }
  990. };
  991.  
  992.  
  993. void do_command(fp)
  994. FILE *fp;
  995. {
  996.   char cline[1024];
  997.   char *argv[32];
  998.   int argc, i;
  999.   int running;
  1000.   register char *sp;
  1001.  
  1002.   /* Initialize the command level module. */
  1003.   var_modem = DEF_MODEM;
  1004.   var_speed = DEF_SPEED;
  1005.   scriptfp  = fp;
  1006.   running   = 1;
  1007.   timeout   = 0;
  1008.   errlevel  = 0;
  1009.  
  1010.   /* Tell the MODEM module about the current modem. */
  1011.   mdm_modem(var_modem);
  1012.  
  1013.   do {
  1014.     if (scriptfp == stdin) {
  1015.         if (opt_v == 1) printf("DIP [%-4d]> ", errlevel);
  1016.           else printf("DIP> ");
  1017.         fflush(stdout);
  1018.     }
  1019.         if (fgets(cline, 1024, scriptfp) == (char *)NULL) break;
  1020.     if ((sp = strchr(cline, '\n')) != (char *)NULL) *sp = '\0';
  1021.     sp = cline;
  1022.     while (*sp == ' ' || *sp == '\t') sp++;
  1023.     if (*sp == '#' || *sp == '\0') continue;
  1024.     if (opt_v) fprintf(stderr, ">> %s\n", sp);
  1025.     if ((argc = getargs(sp, argv)) == 0) continue;
  1026.  
  1027.     /* If this is a label, skip it. */
  1028.     if (strchr(argv[0], ':') != (char *)NULL) continue;
  1029.  
  1030.     /* Now, check which command it is. */
  1031.     if (strcmp(argv[0], "exit") != 0) {
  1032.         i = 0;
  1033.         while (commands[i].name != (char *)NULL) {
  1034.             if (!strcmp(commands[i].name, argv[0])) break;
  1035.             i++;
  1036.         }
  1037.         if (commands[i].name != (char *)NULL) {
  1038.             errlevel = (*commands[i].func)(argc, argv);
  1039.         } else printf("? Unknown command (%s).\n", argv[0]);
  1040.     } else running = 0;
  1041.   } while(running);
  1042.   tty_close();
  1043.  
  1044.   /*NOTREACHED*/
  1045.   exit(0);
  1046. }
  1047.