home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / uniflex.zip / ufset.c < prev    next >
C/C++ Source or Header  |  1993-08-23  |  11KB  |  550 lines
  1. #include "ufk.h"
  2.  
  3. TABLE  set_table[] =
  4. {
  5.    "debug", 1,
  6.    "escape", 2,
  7.    "line", 3,
  8.    "baud", 4,
  9.    "configuration", 5,
  10.    "timeout", 6,
  11.    "prompt", 7,
  12.    "filetype", 8,
  13.    "log", 9,
  14.    "duplex", 10,
  15.    "handshake", 11,
  16.    "block_check_type", 12,
  17.    "repeat_quote", 13,
  18.    "retry", 14,
  19.    "packet_length", 15,
  20.    "padding", 16,
  21.    "padchar", 17,
  22.    "start_of_packet", 18,
  23.    "end_of_line", 19,
  24.    "quote", 20,
  25.    "eight_bit_quote", 21,
  26.    "incomplete", 22,
  27.    "delay", 23,
  28.    "warning", 24,
  29.    "mapping", 25,
  30.    "auto_recover", 26,
  31.    "attributes", 27,
  32.    "", 0
  33. };
  34.  
  35. set()
  36. {
  37.    int   fpoint;
  38.  
  39.    fpoint = parse(params[1], set_table);  /* Parse 'set' command */
  40.    if (fpoint == NULL)                    /* Ambiguous */
  41.       prterr(ER_AMBIGSET);
  42.    else if (fpoint == ERROR)              /* Unknown */
  43.       prterr(ER_UNKNWSET);
  44.    else if (!synerr(3))                   /* Dispatch to command if no error */
  45.       switch(fpoint)
  46.       {
  47.          case 1:
  48.                   set_debug();
  49.                   break;
  50.          case 2:
  51.                   set_escape();
  52.                   break;
  53.          case 3:
  54.                   set_line();
  55.                   break;
  56.          case 4:
  57.                   set_baud(FALSE,0);
  58.                   break;
  59.          case 5:
  60.                   set_config();
  61.                   break;
  62.          case 6:
  63.                   set_timeout();
  64.                   break;
  65.          case 7:
  66.                   set_prompt();
  67.                   break;
  68.          case 8:
  69.                   set_filetype();
  70.                   break;
  71.          case 9:
  72.                   set_log();
  73.                   break;
  74.          case 10:
  75.                   set_dup();
  76.                   break;
  77.          case 11:
  78.                   set_hsh();
  79.                   break;
  80.          case 12:
  81.                   set_block_check_type();
  82.                   break;
  83.          case 13:
  84.                   set_repeat_quote();
  85.                   break;
  86.          case 14:
  87.                   set_retry();
  88.                   break;
  89.          case 15:
  90.                   set_packet_length();
  91.                   break;
  92.          case 16:
  93.                   set_padding();
  94.                   break;
  95.          case 17:
  96.                   set_padchar();
  97.                   break;
  98.          case 18:
  99.                   set_start_of_packet();
  100.                   break;
  101.          case 19:
  102.                   set_end_of_line();
  103.                   break;
  104.          case 20:
  105.                   set_quote();
  106.                   break;
  107.          case 21:
  108.                   set_eight_bit_quote();
  109.                   break;
  110.          case 22:
  111.                   set_incomplete();
  112.                   break;
  113.          case 23:
  114.                   set_delay();
  115.                   break;
  116.          case 24:
  117.                   set_warning();
  118.                   break;
  119.          case 25:
  120.                   set_mapping();
  121.                   break;
  122.          case 26:
  123.                   set_auto_recover();
  124.                   break;
  125.          case 27:
  126.                   set_attributes();
  127.       }
  128. }
  129.  
  130. set_debug()
  131. {
  132.    int temp;
  133.  
  134.    if ((temp = set_onoff(2)) != ERROR)
  135.    {
  136.       debug = temp;
  137.       if (dbgfil != ERROR)                /* Close file */
  138.          fclose(dbgfil);
  139.       dbgfil = ERROR;
  140.    }
  141.    else if (tolower(*params[2]) == 'l')   /* Open debug log file */
  142.    {
  143.       if (numprm < 4)
  144.          prterr(ER_FSPCREQ);
  145.       else
  146.          if (dbgfil != ERROR)
  147.             prterr(ER_FILEOPEN);
  148.          else
  149.          {
  150.             strcpy(dbgfname,params[3]);
  151.             if ((dbgfil = fopen(params[3],"w")) == NULL)
  152.                prterr(ER_OPENERR);
  153.             else
  154.                debug = 2;
  155.          }
  156.    }
  157.    else
  158.       synerr(0);
  159. }
  160.  
  161. set_escape()
  162. {
  163.    escchr = *params[2];                   /* Get escape character */
  164. }
  165.  
  166. set_line()
  167. {
  168.    char save_descr[20];
  169.  
  170.    close_port(FALSE,TRUE);                 /* Make sure it's closed */
  171.    if (tolower(*params[2]) == 'r')
  172.       strcpy(tty_descr,"Remote");          /* Remote connection */
  173.    else
  174.    {
  175.       strcpy(save_descr,tty_descr);        /* Save port */
  176.       strcpy(tty_descr,params[2]);         /* Setup new port */
  177.       if (!open_port(FALSE,TRUE))          /* Check the port */
  178.       {
  179.          strcpy(tty_descr,save_descr);     /* Restore old descriptor */
  180.          prterr(ER_INVDEV);
  181.       }
  182.       else
  183.       {
  184.          close_port(FALSE,TRUE);           /* Make sure it's closed */
  185.          call_baud = TRUE;                 /* Make sure baudrate will be set */
  186.       }
  187.    }
  188. }
  189.  
  190.  
  191. set_baud(startup,argv)
  192. int startup;
  193. char *argv[];
  194. {
  195.    int   temp,
  196.          found,
  197.          *p;
  198.    static int v_speed[] = {
  199.      75,
  200.      150,
  201.      300,
  202.      600,
  203.      1200,
  204.      2400,
  205.      4800,
  206.      9600,
  207.      0 };
  208.  
  209.    if (!strcmp(tty_descr,"Remote"))
  210.    {
  211.       prterr(ER_NOREMBD);
  212.       return(NULL);
  213.    }
  214.    p = v_speed;
  215.  
  216.    if (startup)
  217.       temp = atoi(*argv++);               /* Get speed value */
  218.    else
  219.       temp = atoi(params[2]);             /* Get speed value */
  220.    found = FALSE;
  221.    while (*p)                             /* Do until end of table */
  222.       if (temp == *p++)
  223.          found = TRUE;
  224.  
  225.    if (found)
  226.    {
  227.       if (!baud(tty_descr,temp))
  228.          speed = temp;                      /* Set new speed value */
  229.       else
  230.          prterr(ER_NOBAUD);
  231.       call_baud = FALSE;  /* No need to call it anymore when opening line */
  232.    }
  233.    else
  234.    {
  235.       if (startup)
  236.          return(ERROR);
  237.       else
  238.          prterr(ER_INVBAUD);
  239.    }
  240.    return (NULL);
  241. }
  242.  
  243. set_config()
  244. {
  245.    int temp;
  246.  
  247.    temp = atoi(params[2]);                /* Get configuration */
  248.    if ((temp < 0) || (temp > 7))          /* Check range */
  249.       prterr(ER_ILLVALUE);
  250.    else
  251.    {
  252.       config = temp;                      /* Set new value */
  253.       close_port(FALSE,TRUE);
  254.    }
  255. }
  256.  
  257. set_timeout()
  258. {
  259.    int temp;
  260.  
  261.    temp = atoi(params[2]);                /* Get timeout value */
  262.    if ((temp <= 0) || (temp > 100))       /* Check range */
  263.       prterr(ER_ILLVALUE);
  264.    else
  265.       mytime = temp;                      /* Set new value */
  266. }
  267.  
  268. set_prompt()
  269. {
  270.    if (strlen(params[2]) > 20)
  271.       params[2][20] = '\0';               /* Truncate string */
  272.    strcpy(prompt, params[2]);             /* Setup new prompt */
  273. }
  274.  
  275. set_filetype()
  276. {
  277.    char temp;
  278.  
  279.    temp = tolower(*params[2]);
  280.    if (temp == 'a')                       /* ASCII */
  281.       image = FALSE;
  282.    else if (temp == 'b')                  /* BINARY */
  283.       image = TRUE;
  284.    else
  285.       synerr(0);
  286. }
  287.  
  288. set_log()
  289. {
  290.    if ((params[2][0] == '-') && logfileopen)
  291.    {                                      /* Close file */
  292.       fclose(lfp);
  293.       logfile[0] = '\0';                  /* Zap filename */
  294.       logfileopen = logging = FALSE;
  295.    }
  296.    else
  297.    {
  298.       if (logfileopen)
  299.          prterr(ER_FILEOPEN);
  300.       else
  301.       {
  302.          if (strlen(params[2]) > 80)
  303.             params[2][80] = '\0';            /* Truncate string */
  304.          strcpy(logfile,params[2]);
  305.          if ((lfp = fopen(logfile, "w")) == NULL)
  306.          {
  307.             prterr(ER_OPENERR);
  308.             logfile[0] = '\0';               /* Zap filename */
  309.             logfileopen = logging = FALSE;
  310.          }
  311.          else
  312.          {
  313.             logfileopen = TRUE;
  314.             setbuf(lfp,0);
  315.          }
  316.       }
  317.    }
  318. }
  319.  
  320. set_dup()
  321. {
  322.    char ch;
  323.  
  324.    ch = tolower(*params[2]);
  325.  
  326.    if (ch == 'f')
  327.       fulldup = TRUE;
  328.    else if (ch == 'h')
  329.       fulldup = FALSE;
  330.    else
  331.       synerr(0);
  332. }
  333.  
  334. set_hsh()
  335. {
  336.    char start_tmp, stop_tmp;
  337.  
  338.    if (!synerr(4))                    /* Be sure there are enough parameters */
  339.    {
  340.       start_tmp = atoi(params[2]);        /* Set data start character */
  341.       stop_tmp = atoi(params[3]);         /* Set data stop character */
  342.       if ((start_tmp < 0) || (start_tmp > 127)
  343.          || (stop_tmp < 0) || (stop_tmp > 127))
  344.          prterr(ER_ILLVALUE);
  345.       else
  346.          dstart = start_tmp;
  347.          dstop = stop_tmp;
  348.    }
  349. }
  350.  
  351. set_quote()
  352. {
  353.    char c;
  354.  
  355.    if (check_quote(c = *params[2]))
  356.    {
  357.       if ((c != myeightquote) && (c != myrptquote))
  358.          myquote = c;
  359.       else
  360.          prterr(ER_CHRINUSE);
  361.    }
  362. }
  363.  
  364. set_eight_bit_quote()
  365. {
  366.    char c;
  367.  
  368.    if (toupper(c = *params[2]) == 'N')
  369.       myeightquote = 0;                   /* No eight bit quoting done */
  370.    else if (check_quote(c))
  371.    {
  372.       if ((c != myquote) && (c != myrptquote))
  373.          myeightquote = c;
  374.       else
  375.          prterr(ER_CHRINUSE);
  376.    }
  377. }
  378.  
  379. set_repeat_quote()
  380. {
  381.    char c;
  382.  
  383.    if (toupper(c = *params[2]) == 'N')
  384.       myrptquote = 0;                     /* No repeat quoting done */
  385.    else if (check_quote(c))
  386.    {
  387.       if ((c != myquote) && (c != myeightquote))
  388.          myrptquote = c;
  389.       else
  390.          prterr(ER_CHRINUSE);
  391.    }
  392. }
  393.  
  394. set_packet_length()
  395. {
  396.    int size;
  397.  
  398.    size = atoi(params[2]);
  399.    if ((size < 10) || (size > BIG_SIZE - 8))
  400.       prterr(ER_INVLENG);
  401.    else
  402.       maxpacksiz = size;
  403. }
  404.  
  405. set_padding()
  406. {
  407.    int ptmp;
  408.  
  409.    ptmp = atoi(params[2]);
  410.    if (ptmp > 94)
  411.       prterr(ER_VALOUTRN);
  412.    else
  413.       mypad = ptmp;
  414. }
  415.  
  416. set_padchar()
  417. {
  418.    int ptmp;
  419.  
  420.    sscanf(params[2], "%x", &ptmp);
  421.    mypchar = ptmp;
  422. }
  423.  
  424. set_retry()
  425. {
  426.    maxtry = atoi(params[2]);
  427. }
  428.  
  429. set_end_of_line()
  430. {
  431.    int etmp;
  432.  
  433.    sscanf(params[2], "%x", &etmp);
  434.    if (etmp == mypackstart)
  435.       prterr(ER_EOLDIF);
  436.    else
  437.       myeol = etmp;
  438. }
  439.  
  440. set_start_of_packet()
  441. {
  442.    int ptmp;
  443.  
  444.    sscanf(params[2], "%x", &ptmp);
  445.    if (ptmp == myeol)
  446.       prterr(ER_STRTDIF);
  447.    else
  448.       mypackstart = ptmp;
  449. }
  450.  
  451. set_block_check_type()
  452. {
  453.    char c;
  454.  
  455.    c = atoi(params[2]);
  456.    if ((c >= 1) && (c <= 3))
  457.       myblock_check_type = c;
  458.    else
  459.       prterr(ER_INVCHK);
  460. }
  461.  
  462. set_incomplete()
  463. {
  464.    char c;
  465.  
  466.    c = toupper(*params[2]);
  467.    if (c == 'K')
  468.       save_file = TRUE;                   /* Keep file */
  469.    else if (c == 'D')
  470.       save_file = FALSE;                  /* Discard file */
  471.    else
  472.       synerr(0);
  473. }
  474.  
  475. set_delay()
  476. {
  477.    send_delay = atoi(params[2]);
  478. }
  479.  
  480. set_warning()
  481. {
  482.    int temp;
  483.  
  484.    temp = set_onoff(2);
  485.    if (temp != ERROR)
  486.       warning = temp;
  487.    else
  488.       synerr(0);
  489. }
  490.  
  491. set_mapping()
  492. {
  493.    int temp;
  494.  
  495.    temp = set_onoff(2);
  496.    if (temp != ERROR)
  497.       mapping = temp;
  498.    else
  499.       synerr(0);
  500. }
  501.  
  502. set_autorecover()
  503. {
  504.    int temp;
  505.  
  506.    temp = set_onoff(2);
  507.    if (temp != ERROR)
  508.       auto_recover = temp;
  509.    else
  510.       synerr(0);
  511. }
  512.  
  513. set_attributes()
  514. {
  515.    int temp;
  516.  
  517.    temp = set_onoff(2);
  518.    if (temp != ERROR)
  519.       allowattr = temp;
  520.    else
  521.       synerr(0);
  522. }
  523.  
  524. check_quote(qchar)
  525. char qchar;
  526. {
  527.    if (((qchar >= '!') && (qchar <= '>')) ||
  528.       ((qchar >= '{') && (qchar <= '~')) ||
  529.       (qchar == '`'))
  530.       return (TRUE);                      /* Valid character */
  531.    else
  532.    {
  533.       prterr(ER_INVCHAR);
  534.       return (FALSE);                     /* Invalid character */
  535.    }
  536. }
  537.  
  538. set_onoff(i)
  539. int i;
  540. {
  541.    make_lower(params[i]);
  542.    if (strcmp(params[i], "on") == 0)
  543.       return TRUE;
  544.    else
  545.       if ((strcmp(params[i], "of") == 0) ||
  546.           (strcmp(params[i], "off") == 0))
  547.          return FALSE;
  548.    else return ERROR;
  549. }
  550.