home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / qnx2.tar.gz / qnx2.tar / qnx2ker.c < prev    next >
C/C++ Source or Header  |  1995-05-01  |  39KB  |  2,308 lines
  1. /*
  2.     File:        kermit.c
  3.     Purpose:    Reliable File Transfer
  4.     Author:        Frank da Cruz, et al.
  5.     Editor:        Bill Hullsiek Hullsiek;    21-Jul-1994
  6.  
  7.     Copyright (C) 1985, 1992, Trustees of Columbia University
  8.     in the City of New York.
  9.  
  10.     Permission is granted to any individual or institution to use this
  11.     software as long as it is not sold for profit.  This copyright notice
  12.     must be retained.  This software may not be included in commercial
  13.     products without the written permission of Columbia University.
  14.  
  15.     This code is based on Kermit: A File Transfer Protocol
  16.  
  17.     Portions of this code is derived from the kermit implementation
  18.     under qcp.
  19.  
  20. */
  21.  
  22. #include    <stdio.h>
  23. #include    <stdlib.h>
  24. #include    <io.h>
  25. #include    <dev.h>
  26. #include    <lfsys.h>
  27. #include    <timer.h>
  28. #include    <magic.h>
  29. #include    <taskinfo.h>
  30. #include    <taskmsgs.h>
  31. #include    <portio.h>
  32. #include    <string.h>
  33. #include    <process.h>
  34. #include    <time.h>
  35. #include    <ctype.h>
  36. #include    <setjmp.h>
  37. #include    <signal.h>
  38.  
  39. #define SOH                    0x01
  40. #define    LF                    0x0a
  41. #define    CR                    0x0d
  42. #define    BLANK                ' '
  43.  
  44. #define    MAXSP                2048
  45. #define    MAXRP                2048
  46. #define MAXBUF                MAXRP + 100
  47. #define MAX_STD_PKT            94
  48. #define AVG_FBLKS            20
  49. #define MAX_NC                (AVG_FBLKS * FBLK_SIZE)
  50. #define    MAXTRY                5
  51.  
  52. #define tochar(ch)            (((ch) + ' ') & 0x7f )
  53. #define unchar(ch)            ((ch) - ' ')
  54. #define ctl(ch)                ((ch) ^ 64 )
  55. #define unpar(ch)            ((ch) & 127)
  56.  
  57. #define BEGIN(x) change_state(x)
  58. #define    RESUME if(server) { SERVE } else if(cx == 1) return(-1); else return(0)
  59. #define SERVE tinit(); BEGIN(sserv);
  60. #define    ERR(x) terror(x); zerror(); if (server) { SERVE } else return (-1);
  61.  
  62. /* Kermit states */
  63.  
  64. enum sttype {     stnull,
  65.                 ssini, ssfil, ssdat, sseot, sseof,
  66.                 srini, srfil, srdat, srgen,
  67.                 sserv, ssgen,
  68.                 sipkt }
  69.  
  70. state = stnull;
  71.  
  72. char    strbuf [500] = "\0";
  73.  
  74. int        spsiz    = MAXSP;
  75. int        rpsiz    = MAXRP;
  76. int        timint    = 5;
  77. int        rtimo    = 7;
  78. int        rpadn    = 0;
  79. int        spadn    = 0;
  80. int        bctr    = 3;
  81. int        bctu    = 1;
  82. int        ebq        = '&';
  83. int        ebqflg    = 0;
  84. int        rqf        = -1;
  85. int        rq        = 0;
  86. int        sq        = 'Y';
  87. int        rpt        = 0;
  88. int        rptq    = '~';
  89. int        rptflg    = 0;
  90. int        capas    = 10;
  91. int        atcapb    = 8;
  92. int        atcapr    = 0;
  93. int        atcapu    = 0;
  94. int        swcapb    = 4;
  95. int        swcapr    = 0;
  96. int        swcapu    = 0;
  97. int        lpcapb    = 2;
  98. int        lpcapr    = 1;
  99. int        lpcapu    = 0;
  100.  
  101. char    spadc    = 0;
  102. char    rpadc    = 0;
  103. char    seol    = '\r';
  104. char    reol    = '\r';
  105. char    rctlq    = '#';
  106. char    sctlq    = '#';
  107. char    ssc        = 0;
  108. char    smark    = SOH;
  109. char    rmark    = SOH;
  110.  
  111. int        seq        = 0;
  112. int        size;
  113. int        osize;
  114. int        maxsiz;
  115. int        rln;
  116. int        rsn;
  117. int        limit            = MAXTRY;
  118. int        sndpkl;
  119. char    sndpkt [MAXBUF];
  120. char    rcvpkt [MAXBUF];
  121. char    *rdatap            = NULL;
  122. char    data [MAXRP+1];
  123. char    *isp             = NULL;
  124. char    *osp             = NULL;
  125.  
  126. FILE    *ifp            = NULL;
  127. FILE    *ofp            = NULL;
  128.  
  129. char    filname        [FILENAME_MAX]    = "";
  130. char    mfilname    [FILENAME_MAX]    = "";
  131. char    ofp_name    [FILENAME_MAX]    = "";
  132. char    ifp_name    [FILENAME_MAX]    = "";
  133. int        nfils            = 0;
  134. int        cc                = 0;    /* control-c */
  135. int        cx                = 0;
  136. int        cz                = 0;
  137. int        xflag            = 0;
  138. int        xpkt            = 0;
  139. int        filcnt            = 0;
  140. int        delay            = 10;
  141. int        mfile            = 0;
  142.  
  143. int        text            = 1;
  144. int        local            = 0;
  145. int        debug            = 0;
  146. int        server            = 0;
  147. int        srv_flg            = 0;
  148. int        first            = 0;
  149. int        recno            = 0;
  150. int        keep            = 0;
  151. char    start            = 0;
  152. int        nakstate        = 0;
  153.  
  154. /* statistics */
  155.  
  156. unsigned long    nspkts    = 0;
  157. unsigned long    nrpkts    = 0;
  158. unsigned long    nnpkts    = 0;
  159. unsigned long    nfchars    = 0;
  160. unsigned long    nschars    = 0;
  161. unsigned long    npchars    = 0;
  162. unsigned long    nrchars    = 0;
  163.  
  164. /* Command Parser */
  165.  
  166. char        **xargv            = NULL;
  167. int            xargc             = 0;
  168. char        *cmarg            = NULL;
  169. char        **cmlist        = NULL;
  170. char        cmbuf [CMD_LINE_SIZE];
  171. char        action            = 0;
  172.  
  173. /* Communication Line */
  174.  
  175. FILE        *tty_ifp;
  176. FILE        *tty_ofp;
  177. unsigned    tty_ifp_opt;
  178. unsigned    tty_ofp_opt;
  179. unsigned    std_opt;
  180. int            parity = 0;
  181. char        ttname [L_tmpnam]        = "$mdm";
  182.  
  183. void usage()
  184. {
  185.     fprintf (stderr, "C-Kermit for QNX-2   21-July-1994  \n\n");
  186.     fprintf (stderr, "kermit -xfrsgtRlip123h\n\n");
  187.     fprintf (stderr, "kermit -x              <server>\n");
  188.     fprintf (stderr, "       -f              <finish>\n");
  189.     fprintf (stderr, "       -r              <receive>\n");
  190.     fprintf (stderr, "       -s filename     <send>\n");
  191.     fprintf (stderr, "       -m filename     <move>\n");
  192.     fprintf (stderr, "       -g filename     <get>\n");
  193.     fprintf (stderr, "       -t filename     <remote type>\n");
  194.     fprintf (stderr, "       -R path1 path2  <remote rename>\n");
  195.     fprintf (stderr, "       -C command      <remote command>\n");
  196.     fprintf (stderr, "       -l device       <device>\n");
  197.     fprintf (stderr, "       -i              <image binary>\n");
  198.     fprintf (stderr, "       -d              <debug mode>\n");
  199.     fprintf (stderr, "       -{1,2,3}        <block check type>\n");
  200.     fprintf (stderr, "       -p {e,o,m,s,n}  <set parity>\n");
  201.     fprintf (stderr, "       -h              <help>\n");
  202. }
  203.  
  204. void tmsg (char *s)        /* put message on the console */
  205. {
  206.     if (s != NULL)
  207.         fputs (s, stdout);
  208.  
  209.     fflush   (stdout);
  210. }
  211.  
  212. void tmsgn (int n)            /* put number on the console */
  213. {
  214.     fprintf (stdout, "%d", n);
  215.     fflush  (stdout);
  216. }
  217.  
  218. void tmsgl (char *s)        /* put message on the console */
  219. {
  220.     if (s != NULL)
  221.         fputs (s, stdout);
  222.  
  223.     fputc ('\n', stdout);
  224.     fflush   (stdout);
  225. }
  226.  
  227. void tchar (char c)        /* display a single character on the console */
  228. {
  229.     fputc (c, stdout);
  230.     fflush   (stdout);
  231. }
  232.  
  233. void tstate (enum sttype state)
  234. {
  235.     switch (state)    {
  236.         case    stnull:        tmsg ("stnull");        break;
  237.         case    ssini:        tmsg ("ssini");            break;
  238.         case    ssfil:        tmsg ("ssfil");            break;
  239.         case    ssdat:        tmsg ("ssdat");            break;
  240.         case    sseot:        tmsg ("sseot");            break;
  241.         case    sseof:        tmsg ("sseof");            break;
  242.         case    srini:        tmsg ("srini");            break;
  243.         case    srfil:        tmsg ("srfil");            break;
  244.         case    srdat:        tmsg ("srdat");            break;
  245.         case    srgen:        tmsg ("srgen");            break;
  246.         case    sserv:        tmsg ("sserv");            break;
  247.         case    ssgen:        tmsg ("ssgen");            break;
  248.         case    sipkt:        tmsg ("sipkt");            break;
  249.         default:            tmsg ("unknown state");
  250.     }
  251. }
  252.  
  253. void tstats (char *s)            /* display statistics */
  254. {
  255.     float    percent;
  256.  
  257.     if (nfchars == 0)
  258.         percent = 0.0;
  259.     else
  260.         percent = ((float) nschars / (float) nfchars) * 100;
  261.  
  262.     fprintf (stdout, "Char sent: %5U",         nschars);
  263.     fprintf (stdout, "; Pckt sent %5U",     nspkts);
  264.     fprintf (stdout, ", resent: %5U",       nrpkts);
  265.     fprintf (stdout, "; percent = %3.0f ",    percent);
  266.     if (debug)
  267.         fprintf (stdout, "\n");
  268.     else
  269.         fprintf (stdout, "%s",     s);
  270.  
  271.     fflush  (stdout);
  272. }
  273.  
  274. int    tt_is_console (FILE *tty_ifp)
  275. {
  276.     int        tty_devno;
  277.     int        std_devno;
  278.     int        tty_tid;
  279.     int        std_tid;
  280.     char    mdm_name [L_tmpnam];
  281.     char    std_name [L_tmpnam];
  282.  
  283.     tty_devno    = fdevno (tty_ifp);
  284.     std_devno    = fdevno (stdin);
  285.     tty_tid        = query_device (tty_devno, mdm_name);
  286.     std_tid        = query_device (std_devno, std_name);
  287.  
  288.     if (tty_devno != std_devno)  /* different device than standard input */
  289.         return (1);
  290.  
  291.     else if (tty_tid != std_tid)    /* different owner */ 
  292.         return (1);
  293.  
  294.     else
  295.         return (0);        /* standard input device */
  296. }
  297.  
  298. int ttopen (char *name)            /* open communication line */
  299. {
  300.     int        local;
  301.  
  302.     local = 0;
  303.     if (strchr (name, '$') == NULL) {
  304.         tty_ifp    = stdin;
  305.         tty_ofp    = stdout;
  306.     }
  307.  
  308.     else if ((tty_ifp = fopen (name, "r")) == NULL)
  309.         error ("Invalid input device '%s'. \r\l", name);
  310.  
  311.     else if ((tty_ofp = fopen (name, "w")) == NULL) 
  312.         error ("Invalid output device '%s'. \r\l", name);
  313.  
  314.     else if (tt_is_console (tty_ifp))
  315.         local = 1;
  316.  
  317.     else {
  318.         fclose (tty_ifp);
  319.         fclose (tty_ofp);
  320.         tty_ifp = stdin;
  321.         tty_ofp = stdout;
  322.     }
  323.  
  324.     return (local);
  325. }
  326.  
  327. int ttread (int i, int max_nc, int ticks)    /* read a terminal line */
  328. {
  329.     int nc;
  330.  
  331.     iotime_set (tty_ifp, ticks);
  332.     nc = fget (&(rcvpkt[i]), max_nc, tty_ifp);
  333.     iotime_can (tty_ifp);
  334.     rcvpkt [i+nc+1] = '\0';
  335.  
  336.     return (nc);
  337. }
  338.  
  339. void ttres()            /* restore original communications */
  340. {
  341.     set_option (tty_ifp, tty_ifp_opt);
  342.     set_option (tty_ofp, tty_ofp_opt);
  343. }
  344.  
  345. void ttclos()
  346. {
  347.     fclose (tty_ifp);
  348.     fclose (tty_ofp);
  349. }
  350.  
  351. int ttpkt ()                /* condition for packet i/o */
  352. {
  353.     unsigned    option;
  354.  
  355.     tty_ifp_opt = get_option (tty_ifp);
  356.     tty_ofp_opt = get_option (tty_ofp);
  357.  
  358.     option = tty_ifp_opt;
  359.     option = option & ~ECHO;
  360.     option = option & ~EDIT;
  361.     option = option & ~MAPCR;
  362.  
  363.     if (option & HFLOW) {
  364.         option = option | IFLOW;
  365.         option = option | OFLOW;
  366.     }
  367.  
  368.     set_option (tty_ifp, option);
  369.  
  370.     flush_input (tty_ifp);
  371.  
  372.     fflush (tty_ofp);
  373. }
  374.  
  375.  
  376.  
  377. void ttflui()        /* Flush input line */
  378. {
  379.     flush_input (tty_ifp);
  380. }
  381.  
  382. int ttol (char s[], int n)    /* output a line */
  383. {
  384.     int    m;
  385.  
  386.     m = fput (s, n, tty_ofp);
  387.     fflush (tty_ofp);
  388.     return (m);
  389. }
  390.  
  391. int ttsspd (int speed)        /* verify speed */
  392. {
  393.     if (speed == 300)
  394.         return (1);
  395.  
  396.     else if (speed = 1200)
  397.         return (1);
  398.  
  399.     else if (speed = 2400)
  400.         return (1);
  401.     
  402.     else if (speed = 4800)
  403.         return (1);
  404.  
  405.     else if (speed = 9600)
  406.         return (1);
  407.  
  408.     else if (speed = 19200)
  409.         return (1);
  410.  
  411.     else
  412.         return (0);
  413.  
  414. }
  415.  
  416. int    zgetc (text)             /* Get a character from input file */
  417. {
  418.     static int        bp    = -1;        /* push-back pointer */
  419.     static unsigned char     buf [MAX_NC];
  420.     static int                c     = 0;
  421.     static int                 i     = 0;
  422.     static int                nc    = 0;
  423.     static unsigned char    pbbuf [4];        /* push-back buffer */
  424.  
  425. if (bp >= 0) {                /* first return any pushed-back data */
  426.         c = pbbuf [bp];
  427.         bp--;
  428.     }
  429.  
  430. else if (cx == 1) {        /* Return error message if interrupted */
  431.         c = -1;
  432.     }
  433.  
  434.     else {
  435.         i++;
  436.         if (i >= nc) {          /* read a buffer of data */
  437.             i = 0;
  438.             nc = fget (buf, MAX_NC, ifp);
  439.             if (nc < 0) {
  440.                     /* treat read error as interruption of file */
  441.                 cx = 1;    
  442.                 tmsgl ("zgetc: read error -- interrupt");
  443.             }
  444.         }
  445.  
  446.         if (i >= nc) {
  447.             c = -1;
  448.         }
  449.  
  450.         else {
  451.             nschars++;
  452.             c = buf [i];
  453.  
  454.             if ((text == 1) && (c == '\n')) {
  455.                 c = CR;
  456.                 bp++;
  457.                 pbbuf [bp] = LF;
  458.             }
  459.         }
  460.     }
  461.  
  462.     if (c == -1) {
  463.         bp = -1;
  464.         nc = 0;
  465.     }
  466.  
  467.     return (c);
  468. }
  469.  
  470. int zputc (int c, int text)
  471. {
  472.     int x;
  473.  
  474.     c &= 255;
  475.     if (text && c == CR) {
  476.         return (0);
  477.     }
  478.  
  479.     else if (text && c == LF) {
  480.         nrchars++;
  481.         x = putc ('\n', ofp);
  482.         return (0);
  483.     }
  484.  
  485.     else {
  486.         nrchars++;
  487.         x = putc (c, ofp) & 255;
  488.         if (c == 255)
  489.             return (0);
  490.  
  491.         return ((x != c) ? -1 : 0);
  492.     }
  493. }
  494.  
  495. int zopeni (char *name)        /* open local file for input */
  496. {
  497.     static struct dir_entry dir;
  498.  
  499.     strcpy (ifp_name, name);
  500.  
  501.     ifp = fopen (name, "r");
  502.     if (ifp == NULL)
  503.         return (-1);
  504.  
  505.     else if (get_dir_entry (ifp, &dir) != 0) {
  506.         error ("Can't read directory entry for %s \n", name);
  507.         return (-1);
  508.     }
  509.  
  510.     else {
  511.         nschars = 0;
  512.         nfchars = (dir.fnum_blks + 1) * FBLK_SIZE;
  513.         nfchars = nfchars - (dir.fnum_xtnt * XTNT_HDR);
  514.         if (dir.fnum_chars_free & 0x400)
  515.           nfchars = nfchars - (dir.fnum_chars_free ^ 0x400); 
  516.  
  517.         return (0);
  518.     }
  519. }
  520.  
  521. int zopeno (char *name)            /* open local file for output */
  522. {
  523.     strcpy (ofp_name, name);
  524.  
  525.     nrchars    = 0;
  526.     ofp = fopen (name, "w");
  527.     if (ofp == NULL)
  528.         return (-1);
  529.     else
  530.         return (0);
  531. }
  532.  
  533. int zclosi()
  534. {
  535.     if (fclose (ifp) == EOF)
  536.         return (-1);
  537.  
  538.     else {
  539.         ifp = NULL;
  540.         return (0);
  541.     }
  542. }
  543.  
  544. int zcloso (int x)
  545. {
  546.     if (fclose (ofp) == EOF)
  547.         return (-1);
  548.  
  549.     else {
  550.         ofp = NULL;
  551.         return (0);
  552.     }
  553.  
  554.     if (x != 0)
  555.         remove (ofp_name);
  556. }
  557.  
  558. void zerror()
  559. {
  560.     if (ifp != NULL)
  561.         zclosi();
  562.  
  563.     if (ofp != NULL)
  564.         zcloso(cx | cz);
  565. }
  566.  
  567.  
  568. int zltor (char *local, char *remote)
  569. {
  570.     char    *p;
  571.     char    *np;
  572.  
  573.     p = local;
  574.     if ( *p == '[' ) {        /* Skip over the node number    */
  575.         while (*p  &&  *p != ']')
  576.             p++;
  577.     }
  578.  
  579.     if (*p == '$')            /* Can't prepend a device name    */
  580.         return (-1);
  581.  
  582.  
  583.     if (*p && *(p+1) == ':')    /* Skip over the drive number    */
  584.         p += 2;
  585.  
  586.     while (np = strchr (p + 1, '/')) { /* skip over the path */
  587.         np++;
  588.         p = np;
  589.     }
  590.  
  591.     if (*p == 0)
  592.         return (-1);
  593.  
  594.     while (*p != '\0')  {
  595.         if (islower (*p) == 0)
  596.             *remote = *p;
  597.         else
  598.             *remote = toupper(*p);
  599.  
  600.         p++;
  601.         remote++;
  602.     }
  603.  
  604.     *remote = '\0';
  605.  
  606. }
  607.  
  608. int zrtol (char *remote, char *local)
  609. {
  610.     for ( ; *remote != '\0'; remote++, local++) {
  611.         *local = (isupper(*remote)) ? tolower (*remote) : * remote;
  612.     }
  613.  
  614.     *local = '\0';
  615.     if (strlen (local) > NCPFN)        /* truncate names */
  616.         local = '\0';
  617. }
  618.  
  619. /* ----------- Presentation Layer ------------ */
  620.  
  621. char *bldlen (char *str, char *dest) {
  622.     int    len;
  623.  
  624.     len = strlen(str);
  625.     *dest = len + 32;
  626.     strcpy (dest+1, str);
  627.     return (dest+len+1);
  628. }
  629.  
  630. char *setgen (char type, char *arg1, char *arg2, char *arg3)
  631. {
  632.     char    *upstr;
  633.     char    *cp;
  634.  
  635.     cp    = cmbuf;
  636.     *cp++ = type;
  637.     *cp   = '\0';
  638.     if (*arg1 != '\0') {
  639.         upstr = bldlen (arg1, cp);
  640.         if (*arg2 != '\0') {
  641.             upstr = bldlen (arg2, upstr);
  642.             if (*arg3 != '\0') {
  643.                 bldlen (arg3, upstr);
  644.             }
  645.         }
  646.     }
  647.  
  648.     return (cmbuf);
  649. }
  650.  
  651. int gnchar() 
  652. {
  653.     int    c;
  654.  
  655.     if (isp == NULL)
  656.         c = zgetc (text);
  657.  
  658.     else if (*isp == '\0')
  659.         c = -1;
  660.  
  661.     else 
  662.         c = *isp++;
  663.  
  664.     return (c);
  665. }
  666.  
  667. int pnchar (int c)
  668. {
  669.     nrchars++;
  670.  
  671.     if (xflag) {
  672.         tchar (c);
  673.         return (1);
  674.     }
  675.  
  676.     else if (osp) {
  677.         *osp++ = c;
  678.         return (1);
  679.     }
  680.  
  681.     else
  682.         return (zputc(c, text));
  683. }
  684.  
  685. void encode (int a, int next)
  686. {
  687.     int        a7, b8;
  688.  
  689.     if (rptflg) {
  690.         if (a == next) {
  691.             if (++rpt < MAX_STD_PKT) {
  692.                 return;
  693.             }
  694.             else if (rpt == MAX_STD_PKT) {
  695.                 data [size++] = rptq;
  696.                 data [size++] = tochar (rpt);
  697.                 rpt = 0;
  698.             }
  699.         }
  700.         else if (rpt == 1) {
  701.             rpt = 0;
  702.             encode (a, -1);
  703.             if (size <= maxsiz) osize = size;
  704.             rpt = 0;
  705.             encode (a, -1);
  706.             return;
  707.         }
  708.         else if (rpt > 1) {
  709.             data [size++] = rptq;
  710.             data [size++] = tochar (++rpt);
  711.             rpt = 0;
  712.         }
  713.     }
  714.  
  715.     a7 = a & 127;
  716.     b8 = a & 128;
  717.  
  718.     if (ebqflg && b8) {
  719.         data [size++] = ebq;
  720.         a = a7;
  721.     }
  722.  
  723.     if (a7 < 32 || a7 == 127) {
  724.         data [size++] = sctlq;
  725.         a = ctl (a);
  726.     }
  727.     else if (a7 == sctlq) {
  728.         data [size++] = sctlq;
  729.     }
  730.     else if (ebqflg && a7 == ebq) {
  731.         data [size++] = sctlq;
  732.     }
  733.     else if (rptflg && a7 == rptq) {
  734.         data [size++] = sctlq;
  735.     }
  736.  
  737.     data [size++] =  a;
  738.     data [size]   = '\0';
  739. }
  740.  
  741. int getpkt (int maxlen)
  742. {
  743.     int        next;
  744.     static int     c;
  745.     static int    n;
  746.     static unsigned char remain [10];
  747.  
  748.     size = 0;
  749.     data [size] = '\0';
  750.  
  751.     if (first == 1) {
  752.         n = -1;    
  753.         c = gnchar();
  754.         if (c < 0) {
  755.             first = -1;
  756.             return (size);
  757.         }
  758.         first = 0;
  759.     }
  760.     else if (first == -1) {
  761.         return (size);
  762.     }
  763.  
  764.     while (n >= 0) 
  765.         data [size++] = remain [n--];
  766.  
  767.     rpt = 0;
  768.     while (first > -1)  {
  769.         npchars++;
  770.         next = gnchar();
  771.         if (next < 0)     first = -1;
  772.  
  773.         osize = size;
  774.         encode (c, next);
  775.         c = next;
  776.  
  777.         if (size == maxlen) 
  778.             return (size);
  779.  
  780.         if (size > maxlen) {
  781.             for ( ; size > osize; size--)
  782.                 remain [++n] = data [size-1];
  783.  
  784.             size = osize;
  785.             data [size] = '\0';    
  786.             return (size);
  787.         }
  788.     }
  789.     return (size);
  790. }
  791.  
  792. int decode()
  793. {
  794.     int    a, a7, b8;
  795.  
  796.     while ((a = *rdatap++) != '\0') {
  797.         rpt = 1;
  798.         if (rptflg) {
  799.             if (a == rptq) {
  800.                 rpt = unchar (*rdatap++);
  801.                 a = *rdatap++;
  802.             }
  803.         }
  804.         b8 = 0;
  805.         if (ebqflg) {
  806.             if (a == ebq) {
  807.                 b8 = 128;
  808.                 a = *rdatap++;
  809.             }
  810.         }
  811.  
  812.         if (a == rctlq) {
  813.             a = *rdatap++;
  814.             a7 = a & 127;
  815.             if (a7 > 62 && a7 < 96)
  816.                 a = ctl (a);
  817.         }
  818.  
  819.         a |= b8;
  820.         for (; rpt > 0; rpt--)
  821.             if (pnchar(a) < 0) return (-1);
  822.     }
  823.  
  824.     return (0);
  825. }
  826.  
  827. int encstr (char *s)
  828. {
  829.     first = 1;
  830.     isp = s;
  831.     getpkt (spsiz);
  832.     isp = NULL;
  833.     return (size);
  834. }
  835.  
  836. void decstr (char *s)
  837. {
  838.     osp = s;
  839.     decode();
  840.     *osp = '\0';
  841.     osp = NULL;
  842. }
  843.  
  844. /* ----------- Tranport Layer ----------- */
  845.  
  846. int nxtpkt (int seq) 
  847. {
  848.     return ( (seq + 1) & 63 );
  849. }
  850.  
  851. void tinit()
  852. {
  853.     seq         = 0;
  854.     sndpkl        = 0;
  855.     *filname     = '\0';
  856.     *sndpkt        = '\0';
  857.     *rcvpkt        = '\0';
  858.  
  859.     ebqflg        = 0;
  860.     sq            = 'Y';
  861.     rqf            = -1;
  862.     bctu        = 1;
  863.     rptflg        = 0;
  864.  
  865.     xflag         = 0;
  866.     xpkt        = 0;
  867.     osp         = NULL;
  868.  
  869.     nspkts        = 0;
  870.     nrpkts        = 0;
  871.     nnpkts        = 0;
  872. }
  873.  
  874. int chksum (char *p)
  875. {
  876.     unsigned int m; long s;
  877.  
  878.     m = (parity)  ? 0177 : 0377;
  879.  
  880.     for (s = 0; *p != '\0'; *p++) 
  881.         s += *p & m;
  882.  
  883.     return ((int) s & 077777);
  884. }
  885.  
  886. int chkl (char *packet)
  887. {
  888.  
  889.     int        s, t;
  890.  
  891.     s = chksum (packet);
  892.     t = (((s & 192) >> 6) + s) & 63;
  893.     return (t);
  894. }
  895.  
  896. int chk3 (char *s)
  897. {
  898. /*
  899.     File:        ccitt.crc
  900.     Author:        Unknown
  901.  
  902.     Usage:        This file is included by Kermit.c
  903.  
  904. */
  905. static unsigned crctable[256] = {   /* CCITT crc */
  906.     0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  907.     0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  908.     0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  909.     0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  910.     0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  911.     0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  912.     0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  913.     0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  914.     0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  915.     0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  916.     0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  917.     0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  918.     0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  919.     0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  920.     0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  921.     0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  922.     0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  923.     0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  924.     0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  925.     0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  926.     0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  927.     0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  928.     0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  929.     0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  930.     0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  931.     0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  932.     0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  933.     0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  934.     0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  935.     0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  936.     0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  937.     0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  938.     };
  939.  
  940.  
  941.     long c, crc;
  942.  
  943.     crc = 0;
  944.     while ((c = *s++) != '\0') {
  945.         if (parity)
  946.             c &= 0x7f;
  947.  
  948.         crc = crctable [ ( c ^ crc ) & 0xff ] ^ ( crc >> 8 );
  949.     }
  950.     return ((int) crc);
  951. }
  952.  
  953. int spack (char type, int n, int len, char *data)
  954. {
  955.     int    chklen, i, j, k;
  956.  
  957.     if (type == 'S' || type == 'I')
  958.         chklen = 1;
  959.     else
  960.         chklen = bctu;
  961.  
  962.     if (debug) {
  963.         tmsg  ("spack:");
  964.         tmsg  (" type = ");    tchar (type);
  965.         tmsg  (" n = ");    tmsgn (n);
  966.         tmsg  (" len = ");    tmsgn (len);
  967.         tmsg  (" chk = ");  tmsgn (chklen);
  968.         tmsg  (" data <");    tmsg  (data);         tmsgl (">");
  969.     }
  970.  
  971.     i = 0;
  972.     while (i < spadn)
  973.         sndpkt [i++] = spadc;
  974.  
  975.     sndpkt [i++] = smark;
  976.     k = i++;
  977.     sndpkt [i++] = tochar (n); 
  978.     sndpkt [i++] = type;
  979.     j = len + chklen;
  980.  
  981.     if (j <= MAX_STD_PKT-2)
  982.         sndpkt [k] = tochar (j+2);
  983.  
  984.     else {
  985.         sndpkt [k]     = tochar (0);
  986.         sndpkt [i++] = tochar (j / 95);
  987.         sndpkt [i++] = tochar (j % 95);
  988.         sndpkt [i]   = '\0';
  989.         sndpkt [i++] = tochar (chkl(sndpkt+k));
  990.     }
  991.  
  992.     sndpkt [i] = '\0';
  993.  
  994.     if (len > 0) {
  995.         memmove (sndpkt+i, data, len);
  996.         i = i + len;
  997.     }
  998.  
  999.     sndpkt [i] = '\0';
  1000.  
  1001.     switch (chklen) {
  1002.         case 1:
  1003.             sndpkt [i++] = tochar (chkl (sndpkt+k));
  1004.             break;
  1005.  
  1006.         case 2:
  1007.             j = chksum (sndpkt+k);
  1008.             sndpkt [i++] = tochar ((j >> 6)  & 077);
  1009.             sndpkt [i++] = tochar ( j        & 077);
  1010.             break;
  1011.  
  1012.         case 3:
  1013.             j = chk3 (sndpkt+k);
  1014.             sndpkt [i++] = tochar ((j >> 12) & 017);
  1015.             sndpkt [i++] = tochar ((j >> 6)  & 077);
  1016.             sndpkt [i++] = tochar ( j        & 077);
  1017.             break;
  1018.  
  1019.         default:
  1020.             error ("spack: block check type (chklen) = %d \n",
  1021.                    chklen);
  1022.     }
  1023.  
  1024.     sndpkt [i++] = seol;
  1025.     sndpkt [i] = '\0';
  1026.     sndpkl = i;
  1027.  
  1028.     i = ttol (sndpkt, sndpkl);
  1029.  
  1030.     return (i);
  1031. }
  1032.  
  1033. int    nak()
  1034. {
  1035.     int    x;
  1036.     x = spack ('N', seq, 0, "");
  1037.     return (x);
  1038. }
  1039.  
  1040. int resend()                /* resend a packet */
  1041. {
  1042.     int    x;
  1043.  
  1044.     if (sndpkl > 0) {
  1045.         nrpkts++;
  1046.         x = ttol (sndpkt, sndpkl);
  1047.         if (local && !xflag)
  1048.             tstats (" (resend) \r");
  1049.     }
  1050.  
  1051.     else if (nakstate == 1) {
  1052.         nnpkts++;
  1053.         x = nak();
  1054.     }
  1055.     else
  1056.         x = 0;
  1057.  
  1058.     return (x);
  1059. }
  1060.  
  1061. int serror (char *s)
  1062. {
  1063.     int    nc;
  1064.  
  1065.     nc = spack('E', seq, strlen(s), s);
  1066.  
  1067.     return (nc);
  1068.  
  1069. }
  1070.  
  1071. void terror (char *s) 
  1072. {
  1073.     if (server)
  1074.         serror (s);
  1075.  
  1076.     else if (local) {
  1077.         tmsg ("\nError: ");
  1078.         tmsgl (s);
  1079.     }
  1080.  
  1081.     return;
  1082. }
  1083.  
  1084. void trap_signal()
  1085. {
  1086.     if (local) 
  1087.         tmsgl ("\nControl-C interrupt of file transfer");
  1088.  
  1089.     cx = 1;        /* handle clean-up */
  1090.     cc = 1;
  1091. }
  1092.  
  1093. int    ack()
  1094. {
  1095.     int    x;
  1096.  
  1097.     x = spack ('Y', seq, 0, "");
  1098.     seq = nxtpkt (seq);
  1099.     return (x);
  1100. }
  1101.  
  1102. int ackl (char *s)
  1103. {
  1104.     int    x;
  1105.  
  1106.     x = spack ('Y', seq, strlen(s), s);
  1107.     seq = nxtpkt (seq);
  1108.     return (x);
  1109. }
  1110.  
  1111. int rpack ()        /* read packet and return packet type */
  1112. {
  1113.     int     chklen    = 0;
  1114.     int     g        = 0;
  1115.     char    hcheck    = '\0';
  1116.     int        lenx1    = 0;
  1117.     int        lenx2    = 0;
  1118.     int        i        = 0;
  1119.     int        j         = 0;
  1120.     int        max_nc    = 1;
  1121.     int        nc        = 0;
  1122.     char     pbc[4];
  1123.     int        rlnpos    = 0;
  1124.  
  1125. enum pkt_states { null_pkt, pkt_start, pkt_hdr, pkt_data, pkt_eol, pkt_end } 
  1126.     state = null_pkt;
  1127.  
  1128.     int        ticks    = 0;
  1129.     char    type    = 'T';
  1130.     int        x        = 0;
  1131.  
  1132.     ticks        = rtimo * 20;        /* 20 ticks per second */
  1133.     rsn         = -1;
  1134.     rln            = -1;
  1135.     rdatap         = NULL;
  1136.  
  1137.     while (state != pkt_end) {
  1138.         if (cc) {
  1139.             type = 'Q';
  1140.             state = pkt_end;
  1141.         }
  1142.  
  1143.         else if (i+max_nc > MAXBUF) {
  1144.             error ("rpack: overflow = %d characters \n", nc);
  1145.             type = 'Q';
  1146.             state = pkt_end;
  1147.         }
  1148.  
  1149.         else if ((nc = ttread (i, max_nc, ticks)) < max_nc)  {
  1150.             type = 'T';
  1151.             state = pkt_end;
  1152.         }
  1153.  
  1154.         else switch (state) {
  1155.           case null_pkt:    if (rcvpkt [i] == rmark) {
  1156.               state = pkt_start;    
  1157.               i++;
  1158.           }
  1159.           else
  1160.             g++;
  1161.             break;
  1162.  
  1163.           case pkt_start: if (rcvpkt [i] == rmark) {
  1164.               /* do nothing */
  1165.           }
  1166.           else { 
  1167.               rlnpos    = i;
  1168.               rln        = unchar(rcvpkt[i++]);
  1169.               state    = pkt_hdr;
  1170.               if (rln == 0) 
  1171.             max_nc = 5;        /* extended hdr */
  1172.               
  1173.               else if (rln == 1) {
  1174.               terror ("rpack: extended hdr 1 \n");
  1175.               type = 'Q';
  1176.               state = pkt_end;
  1177.               }
  1178.               
  1179.               else if (rln == 2) {
  1180.               terror ("rpack: extended hdr 2 \n");
  1181.               type = 'Q';
  1182.               state = pkt_end;
  1183.               }
  1184.               
  1185.               else 
  1186.             max_nc = 2;        /* normal hdr */
  1187.           }
  1188.             break;
  1189.             
  1190.           case pkt_hdr:    rsn        = unchar(rcvpkt [i+0]);
  1191.             type    = rcvpkt [i+1];
  1192.             if (type == 'I' || type == 'S') 
  1193.               chklen = 1;
  1194.             else
  1195.               chklen = bctu;
  1196.  
  1197.             if (rln > 2)
  1198.               rln = rln - 2;
  1199.  
  1200.             else {
  1201.             lenx1    = rcvpkt [i+2];
  1202.             lenx2    = rcvpkt [i+3];
  1203.             hcheck    = rcvpkt [i+4];
  1204.             rcvpkt [i+4] = '\0';
  1205.             if (unchar (hcheck) != chkl(rcvpkt+rlnpos)) {
  1206.                 terror ("rpack: bad header checksum \n");
  1207.                 type = 'Q';
  1208.                 state = pkt_end;
  1209.             }
  1210.  
  1211.             rcvpkt [i+4] = hcheck;
  1212.  
  1213.             rln    = (95 * unchar(lenx1)) + unchar(lenx2);
  1214.             }
  1215.  
  1216.             max_nc    = rln;
  1217.             rln        = rln - chklen;
  1218.             i         = i + nc;
  1219.             j        = i + rln;
  1220.             rdatap    = rcvpkt + i;
  1221.  
  1222.             state = pkt_data;
  1223.             break;
  1224.  
  1225.           case pkt_data:    i = i + nc;
  1226.             max_nc = 1;
  1227.             if (rcvpkt[i] == reol)
  1228.               state = pkt_end;
  1229.             else
  1230.               state = pkt_eol;
  1231.             break;
  1232.  
  1233.           case pkt_eol:    if (rcvpkt[i] == reol)
  1234.             state = pkt_end;
  1235.           else
  1236.             i++;
  1237.             
  1238.             break;
  1239.  
  1240.           case pkt_end:    terror ("rpack: invalid state \n");
  1241.             break;
  1242.         
  1243.         }
  1244.         }
  1245.  
  1246.     /* perform checksum */
  1247.                                 
  1248.     for (x = 0; x < chklen; x++)
  1249.         pbc [x] = rcvpkt [j+x];
  1250.  
  1251.     rcvpkt [j] = '\0'; 
  1252.  
  1253.     switch (chklen) {
  1254.         case 0:    break;    /* bad packet */
  1255.  
  1256.         case 1:
  1257.           if (unchar (pbc[0]) != chkl (rcvpkt+rlnpos)) {
  1258.               if (debug)
  1259.             tmsgl ("rpack: checksum 1 problem");
  1260.               type = 'Q';
  1261.           }
  1262.           break;
  1263.  
  1264.         case  2:
  1265.           x = unchar (pbc[0]) << 6 | unchar (pbc[1]);
  1266.           if (x != chksum (rcvpkt+rlnpos)) {
  1267.               if (debug)
  1268.             tmsgl ("rpack: checksum 2 problem");
  1269.               type = 'Q';
  1270.           }
  1271.           break;
  1272.  
  1273.         case  3:
  1274.           x = unchar(pbc[0])<<12 | unchar(pbc[1])<<6 | unchar(pbc[2]);
  1275.           if (x != chk3 (rcvpkt+rlnpos)) {
  1276.               if (debug)
  1277.             tmsgl ("rpack: checksum 3 problem");
  1278.               type = 'Q';
  1279.           }
  1280.           break;
  1281.  
  1282.         default:
  1283.           error ("rpack: block check type (chklen) = %d \n", chklen);
  1284.     }
  1285.  
  1286.     if (debug) {
  1287.         tmsg  ("rpack:");
  1288.         tmsg  (" g = ");    tmsgn (g);
  1289.         tmsg  (" i = ");    tmsgn (i);
  1290.         tmsg  (" j = ");    tmsgn (j);
  1291.  
  1292.         if (chklen != bctu) {
  1293.             tmsg  (" chklen = ");
  1294.             tmsgn (chklen);
  1295.         }
  1296.  
  1297.         tmsg  (" rln = ");     tmsgn (rln);
  1298.         tmsg  (" type = ");    tchar (type);
  1299.         tmsg  (" rsn = ");    tmsgn (rsn);
  1300.         tmsg  (" data <");
  1301.         if (rdatap != NULL)
  1302.             tmsg (rdatap);    
  1303.  
  1304.         tmsgl (">");
  1305.     }
  1306.  
  1307.     return (type);
  1308. }
  1309.  
  1310. void spar (char *s)                /* set parameters */
  1311. {
  1312.     int    x;
  1313.  
  1314.     s--;
  1315.  
  1316.     x = (rln >= 1) ? unchar(s[1]) : 80;
  1317.     spsiz = (x < 10) ? 80 : x;
  1318.  
  1319.     x = (rln >= 2) ? unchar(s[2]) : 5;
  1320.     timint = (x < 0) ? 5 : x;
  1321.  
  1322.     spadn = 0; spadc = '\0';
  1323.     if (rln >= 3) {
  1324.         spadn = unchar (s[3]);
  1325.         if (rln >= 4)
  1326.             spadc = ctl(s[4]);
  1327.         else
  1328.             spadc = 0;
  1329.     }
  1330.  
  1331.     seol = (rln >= 5) ? unchar (s[5]) : '\r';
  1332.     if ((seol < 2) || (seol > 31))
  1333.         seol = '\r';
  1334.  
  1335.     x = (rln >= 6) ? s[6] : '#';    
  1336.     rctlq = ((x > 32 && x < 63) || (x > 95 && x < 127)) ? x : '#';
  1337.     
  1338.     rq = (rln >= 7) ? s [7] : 0;
  1339.     if (rq == 'Y')
  1340.         rqf = 1;
  1341.  
  1342.     else if ((rq > 32 && rq < 63) || (rq > 96 && rq < 127)) 
  1343.         rqf = 2;
  1344.  
  1345.     else
  1346.         rqf = 0;
  1347.  
  1348.     x = 1;
  1349.     if (rln >= 8) {
  1350.         x = s[8] - '0';
  1351.         if ((x < 1) || (x > 3)) x = 1;
  1352.     }
  1353.     bctr = x;
  1354.  
  1355.     if (bctr < 1 || bctr > 3)
  1356.         error ("spar: Received bad block check \n");
  1357.  
  1358.     if (bctu < 1 || bctu > 3)
  1359.         error ("spar: bctu out of range \n");
  1360.  
  1361.     switch (rqf) {
  1362.         case 0:    ebqflg = 0;    break;
  1363.         case 1:    if (parity) { ebqflg = 1; ebq = '&'; } break;
  1364.         case 2:    if (ebqflg = (ebq == sq || sq == 'Y')) ebq = rq;
  1365.     }
  1366.  
  1367.     if (rln < 9) 
  1368.         rptflg    = 0;
  1369.  
  1370.     else {
  1371.         rptq   = s [9];
  1372.         rptflg = ((rptq > 32 && rptq < 63) || (rptq > 95 && rptq < 127));
  1373.     }
  1374.  
  1375.     atcapu = lpcapu = swcapu = 0;
  1376.     if (rln >= 10) {
  1377.         x = unchar (s[10]);
  1378.         atcapu = (x & atcapb) && atcapr;
  1379.         lpcapu = (x & lpcapb) && lpcapr;
  1380.         swcapu = (x & swcapb) && swcapr;
  1381.  
  1382.         for (capas = 10; (unchar (s[capas]) & 1) && (rln >= capas); capas++) 
  1383.             ;
  1384.     }
  1385.  
  1386.     if (atcapu) {
  1387.         error ("spar: file attributes not supported \n");
  1388.     }
  1389.  
  1390.     if (swcapu) {
  1391.         error ("spar: sliding windows not supported \n");
  1392.     }
  1393.  
  1394.     if (lpcapu) {
  1395.         if (rln > capas+2) {
  1396.         spsiz = (unchar (s[capas+2]) * 95) + unchar (s[capas+3]);
  1397.         if (spsiz > MAXSP)
  1398.           spsiz = MAXSP;
  1399.         }
  1400.     }
  1401.  
  1402.     if (spsiz > MAX_STD_PKT)
  1403.         maxsiz = spsiz - bctr - 6;
  1404.     else
  1405.         maxsiz = spsiz - bctr - 3;
  1406. }
  1407.  
  1408. int    rinit()
  1409. {
  1410.  
  1411. }
  1412.  
  1413. char *rpar ()
  1414. {
  1415.     int    x;
  1416.  
  1417.     data [1]    = tochar (MAX_STD_PKT);
  1418.     data [2]    = tochar (rtimo);
  1419.     data [3]    = tochar (rpadn);
  1420.     data [4]    = ctl (rpadc);
  1421.     data [5]    = tochar (reol);
  1422.     data [6]    = '#';
  1423.  
  1424.     switch (rqf) {
  1425.  
  1426.         case -1:
  1427.         case  1: if (parity) ebq = sq = '&'; break;
  1428.         case  0:
  1429.         case  2: break;
  1430.     }
  1431.  
  1432.     data [7]    = sq;
  1433.     data [8]    = bctr + '0';
  1434.  
  1435.     if (rptflg)
  1436.         data [9] = rptq;
  1437.     else
  1438.         data [9] = '~';
  1439.  
  1440.     x = atcapr ? atcapb : 0 | lpcapr ? lpcapb : 0 | swcapr ? swcapb : 0;
  1441.     data [10] = tochar (x);
  1442.     data [11] = tochar (0);    /* window size */
  1443.  
  1444.     data [12] = tochar (rpsiz / 95);
  1445.     data [13] = tochar (rpsiz % 95);
  1446.  
  1447.     data [14] = '\0';
  1448.  
  1449.     return (data+1);
  1450. }
  1451.  
  1452. int    sinit (char c)
  1453. {
  1454.     char    *s;
  1455.  
  1456.     s = rpar();
  1457.     if (local == 0 && c == 'S' && server == 0) {
  1458.         tmsgl ("Escape back to local system, give RECEIVE command...");
  1459.         sleep (delay);
  1460.     }
  1461.  
  1462.     return (spack (c, seq, strlen(s), s));
  1463. }
  1464.  
  1465. char sfile ()
  1466. {
  1467.  
  1468.     int    x;
  1469.     char pktnam [FILENAME_MAX];
  1470.  
  1471.     if (zopeni (filname) < 0)
  1472.         return (-1);
  1473.  
  1474.     zltor (filname, pktnam);
  1475.     x = encstr (pktnam);
  1476.  
  1477.     if (mfile) {
  1478.         strcpy (mfilname, filname);
  1479.     }
  1480.  
  1481.     if (local) {
  1482.         if (mfile)
  1483.             tmsg ("Moving ");
  1484.         else
  1485.             tmsg ("Sending ");
  1486.         tmsg (filname);
  1487.         tmsg (" as ");
  1488.         tmsg (pktnam);
  1489.         if (parity)
  1490.             tmsgl (" with parity. \n");
  1491.         else
  1492.             tmsgl (" ");
  1493.     }
  1494.     first = 1;
  1495.  
  1496.     seq = nxtpkt (seq);
  1497.  
  1498.     return (spack((xpkt ? 'X' : 'F'), seq, x, data));
  1499.  
  1500. }
  1501.  
  1502. int    sdata()
  1503. {
  1504.     int    x;
  1505.  
  1506.     x = getpkt (maxsiz);
  1507.     if (x == 0) {
  1508.         return (0);
  1509.     }
  1510.  
  1511.     if (cx) {
  1512.         return (0);
  1513.     }
  1514.  
  1515.     seq = nxtpkt (seq);
  1516.  
  1517.     x = spack ('D', seq, x, data);
  1518.  
  1519.     return  (x);
  1520. }
  1521.  
  1522. int    seof (char *s)
  1523. {
  1524.     seq = nxtpkt (seq);
  1525.     if (zclosi () < 0)
  1526.         *s = 'D';
  1527.  
  1528.     return (spack ('Z', seq, strlen(s), s));
  1529. }
  1530.  
  1531. int seot () 
  1532. {
  1533.     seq = nxtpkt (seq);
  1534.     if (local && *cmarg == '\0')
  1535.         tmsgl ("\nDone");
  1536.  
  1537.     return (spack ('B', seq, 0, ""));
  1538.  
  1539. }
  1540.  
  1541. int scmd (char t, char *s)
  1542. {
  1543.     int    x;
  1544.  
  1545.     if (local) {
  1546.         tmsg ("Remote command: ");
  1547.         tmsgl (s);
  1548.     }
  1549.  
  1550.     x = encstr (s);
  1551.     spack (t, seq, x, data);
  1552. }
  1553.  
  1554. int    gnfile()
  1555. {
  1556.     if (cz) {
  1557.         return (0);
  1558.     }
  1559.  
  1560.     else if (nfils-- <= 0) {
  1561.         return (0);
  1562.     }
  1563.  
  1564.     else if (**cmlist == '-')
  1565.         return (0);
  1566.  
  1567.     else {
  1568.         strcpy (filname, *cmlist++);
  1569.         return (1);
  1570.     }
  1571. }
  1572.  
  1573. int rcvfil()
  1574. {
  1575.     char    myname [FILENAME_MAX];
  1576.  
  1577.     decstr (filname);
  1578.     zrtol (filname, myname);
  1579.     if (zopeno (myname) < 0)
  1580.         return (-1);
  1581.  
  1582.     else {
  1583.         if (local && !xflag) {
  1584.             tmsg ("Receiving ");
  1585.             tmsg (filname);
  1586.             tmsg (" as ");
  1587.             tmsgl (myname);
  1588.         }
  1589.         return (0);
  1590.     }
  1591. }
  1592.  
  1593. int closof()
  1594. {
  1595.     int x;    
  1596.  
  1597.     if (xflag)
  1598.         return (0);
  1599.  
  1600.     decstr (strbuf);
  1601.     x = strncmp (strbuf, "D", 1) | cx | cz;
  1602.  
  1603.     if (zcloso (x) < 0)
  1604.         return (-1);
  1605.  
  1606.     return (0);
  1607. }
  1608.  
  1609. int input() 
  1610. {
  1611.     int    type, try;    
  1612.  
  1613.     if (start != 0) {
  1614.         type     = start;
  1615.         start    = 0;
  1616.         return (type);
  1617.     }
  1618.  
  1619.     type = rpack();
  1620.  
  1621.     for (try = 0; rsn != seq || strchr("TQN", type); try++) {
  1622.         if (cc) 
  1623.             return ('T');
  1624.  
  1625.         if (try > limit) 
  1626.             return ('T');
  1627.  
  1628.         if (type == 'N' && rsn == nxtpkt (seq)) 
  1629.             return ('Y');
  1630.  
  1631.         else if (type == 'T' && state == sserv) {
  1632.             /* do nothing */
  1633.         }
  1634.  
  1635.         else if (type == 'E') 
  1636.             return ('E');
  1637.  
  1638.         else 
  1639.             resend();
  1640.  
  1641.         type = rpack();
  1642.     }     
  1643.  
  1644. /*    ttflui();   */
  1645.  
  1646.     return (type);
  1647. }
  1648.  
  1649. void change_state (enum sttype new_state)
  1650. {
  1651.     state = new_state;
  1652.     if (debug) {
  1653.         tmsg ("Change state to ");
  1654.         tstate (new_state);
  1655.         tmsgl (".");
  1656.     }
  1657.  
  1658.     return;
  1659. }
  1660.  
  1661. int yylex()
  1662. {
  1663.     int ss, type, x;
  1664.  
  1665.     while (cc == 0) {
  1666.         type = input();
  1667.  
  1668.         if (debug) {
  1669.             tmsg  ("yylex:");
  1670.             tmsg  (" type = ");        tchar (type);
  1671.             tmsg  (" state = ");    tstate (state);
  1672.             tmsgl (" ");
  1673.         }
  1674.  
  1675.         if (type == 's') {    /* send state */
  1676.             tinit();
  1677.             if (sinit('S') < 0) {
  1678.                 ERR("sinit -- Could not initialize link");
  1679.             }
  1680.  
  1681.             else {
  1682.                 nakstate = 0;
  1683.                 filcnt = 0;
  1684.                 BEGIN(ssfil);
  1685.             }
  1686.         }
  1687.  
  1688.         else if (type == 'v') {    /* receive state */
  1689.             tinit();
  1690.             nakstate = 1;
  1691.             rinit();
  1692.             BEGIN(srini);
  1693.         }
  1694.  
  1695.         else if (type == 'r') {    /* get */
  1696.             tinit();
  1697.             ssc = 0;
  1698.             sinit ('I');
  1699.             BEGIN(sipkt);
  1700.         }
  1701.  
  1702.         else if (type == 'c') {    /* host */
  1703.             tinit();
  1704.             ssc = 'C';
  1705.             sinit ('I');
  1706.             BEGIN(sipkt);
  1707.         }
  1708.  
  1709.         else if (type == 'g') {    /* generic */
  1710.             tinit();
  1711.             ssc = 'G';
  1712.             sinit('I');
  1713.             BEGIN(sipkt);
  1714.         }
  1715.  
  1716.         else if (type == 'x') {    /* server */
  1717.             server = 1;
  1718.             SERVE;
  1719.         }
  1720.  
  1721.         else if (type == 'Y' && (state == ssfil || state == sseof))  {
  1722.  
  1723.             if (state == sseof) {
  1724.                 if (local && !xflag)
  1725.                   tstats (" (sseof)  \r");
  1726.  
  1727.                 if (cx == 1) {
  1728.                 /* do not delete file if interrupted */
  1729.                 } else if (*cmarg != '\0') {
  1730.                 /* start a command sequence at eot */
  1731.                 } else if (mfile == 0)  {
  1732.                 /* only delete if mfile is set */
  1733.                 } else if (remove (mfilname) == 0) {
  1734.                 tmsg("\n");
  1735.                 tmsg(mfilname);
  1736.                 tmsgl(" removed after successful transfer");
  1737.                 } else {
  1738.                 tmsg  ("\nError: ");
  1739.                 tmsg  (mfilname);
  1740.                 tmsgl (" could not be removed\n");
  1741.                 }
  1742.             }
  1743.             if (filcnt++ == 0)
  1744.               spar (rdatap);
  1745.  
  1746.             cx = 0;
  1747.             bctu = bctr;
  1748.  
  1749.             if (gnfile() > 0) {
  1750.                 if (sfile() < 0) {
  1751.                     ERR("Could not open file to send");
  1752.                 }
  1753.  
  1754.                 else {
  1755.                     BEGIN(ssdat);
  1756.                 }
  1757.             }
  1758.  
  1759.             else if (seot() < 0) {
  1760.                 ERR("seot");
  1761.             }
  1762.  
  1763.             else {
  1764.                 BEGIN(sseot);
  1765.             }
  1766.         }
  1767.  
  1768.         else if (type == 'Y' && state == ssdat) {
  1769.             nspkts++;
  1770.             if (local && !xflag) 
  1771.                 tstats (" (ssdat)  \r");
  1772.  
  1773.             decstr (strbuf);
  1774.             if (strbuf[0] == 'X') {
  1775.                 cx = 1;
  1776.                 if (local && !xflag)
  1777.                   tmsgl ("File Transfer interrupted by Ctrl-X");
  1778.             } else if (strbuf[0] == 'Z') {
  1779.                 cz = 1;
  1780.                 if (local && !xflag)
  1781.                   tmsgl ("File Transfer interrupted by Ctrl-Z");
  1782.             }
  1783.             x = sdata();
  1784.             if (x < 0) {
  1785.                 ERR("sdata");
  1786.             } else if (x == 0) {
  1787.                 if (seof((cx | cz) ? "D" : "") < 0) {
  1788.                 ERR("seof");
  1789.                 } else {
  1790.                 BEGIN(sseof);
  1791.                 }
  1792.             }
  1793.             } else if (type == 'Y' && state == sseot) {
  1794.             if (*cmarg != '\0') 
  1795.               start = 'c';
  1796.             else {
  1797.                 RESUME;
  1798.             }
  1799.             }
  1800.  
  1801.         /* Receiver States */
  1802.  
  1803.         else if (type == 'S' && state == srini) {
  1804.             spar (rdatap);
  1805.             ackl (rpar());
  1806.             bctu = bctr;
  1807.             nakstate = 1;
  1808.             BEGIN(srfil);
  1809.         }
  1810.  
  1811.         else if (type == 'B' && state == srfil) {
  1812.             ack();
  1813.             RESUME;
  1814.         }
  1815.  
  1816.         else if (type == 'F' && state == srfil) {
  1817.             if (rcvfil() < 0) {
  1818.                 ERR("rcvfil");
  1819.             }
  1820.  
  1821.             else {
  1822.                 ack();
  1823.                 nakstate = 1;
  1824.                 BEGIN(srdat);
  1825.             }
  1826.         }
  1827.  
  1828.         else if (type == 'D' && state == srdat) {
  1829.             if (decode() < 0) {
  1830.                 ERR("decode");
  1831.             }
  1832.  
  1833.             else {
  1834.                 ack();
  1835.             }
  1836.         }
  1837.  
  1838.         else if (type == 'T' && state == srdat) {
  1839.             cx = 1;
  1840.             ERR("Timeout in srdat state");
  1841.         }
  1842.  
  1843.         else if (type == 'Z' && state == srdat) {
  1844.             if (closof() < 0) {
  1845.                 ERR("closof");
  1846.             }
  1847.  
  1848.             else {
  1849.                 if (cx)
  1850.                     ackl ("X");
  1851.  
  1852.                 else if (cz)
  1853.                     ackl ("Z");
  1854.  
  1855.                 else
  1856.                     ack();
  1857.  
  1858.                 state = srfil;
  1859.             }
  1860.         }
  1861.  
  1862.         /* Client states */
  1863.  
  1864.         else if (type == 'Y' && state == sipkt) {
  1865.             spar(rdatap);
  1866.             start = 'E';
  1867.         }
  1868.  
  1869.         else if (type == 'E' && state == sipkt) {
  1870.             if (ssc) {
  1871.                 if (scmd (ssc, cmarg) < 0) {
  1872.                     ERR("scmd");
  1873.                 }
  1874.  
  1875.                 else {
  1876.                     ssc = 0;
  1877.                     nakstate = 1;
  1878.                     BEGIN(srgen);
  1879.                 }
  1880.             }
  1881.             else {
  1882.                 if (scmd ('R', cmarg) < 0) {
  1883.                     ERR("scmd");
  1884.                 }
  1885.  
  1886.                 else {
  1887.                     nakstate = 1;
  1888.                     BEGIN(srini);
  1889.                 }
  1890.             }
  1891.         }
  1892.  
  1893.         else if (type == 'Y' && state == srgen) {
  1894.             xflag = 1;
  1895.             decode();
  1896.             RESUME;
  1897.         }
  1898.  
  1899.         else if (type == 'S' && state == srgen) {
  1900.             spar (rdatap);
  1901.             ackl (rpar());
  1902.             bctu = bctr;
  1903.             nakstate = 1;
  1904.             BEGIN(srfil);
  1905.  
  1906.     /* When remote command has been ack'd, check -move flag */
  1907.  
  1908.             if (mfile == 1) {
  1909.                 if (remove (mfilname) == 0) {
  1910.                 tmsg  ("\n");
  1911.                 tmsg  (mfilname);
  1912.                 tmsgl (" removed after successful transfer");
  1913.                 }
  1914.                 else {
  1915.                 tmsg  ("\nError: ");
  1916.                 tmsg  (mfilname);
  1917.                 tmsgl (" could not be deleted\n");
  1918.                 }
  1919.             }
  1920.         }
  1921.  
  1922.         /* Server states */
  1923.  
  1924.         else if (type == 'T' && state == sserv) {
  1925.             if (local)
  1926.                 tmsgl ("Kermit: waiting...");
  1927.         }
  1928.  
  1929.         else if (type == 'X' && (state == srgen || state == srfil)) {
  1930.             xflag = 1;
  1931.             ack();
  1932.             nakstate = 1;
  1933.             BEGIN(srdat);
  1934.         }
  1935.  
  1936.         else if (type == 'I' && state == sserv) {
  1937.             spar (rdatap);
  1938.             ackl (rpar());
  1939.             seq = 0;
  1940.         }
  1941.  
  1942.         else if (type == 'R' && state == sserv) {
  1943.             decstr (strbuf);
  1944.             nfils = 1;
  1945.             *cmlist = strbuf; /* point to name for gnfile() */
  1946.             if (sinit ('S') < 0) {
  1947.                 ERR("sinit");
  1948.             }
  1949.  
  1950.             else {
  1951.                 filcnt = 0;
  1952.                 nakstate = 0; /* now I'm the sender */
  1953.                 BEGIN(ssfil);
  1954.             }
  1955.         }
  1956.  
  1957.         else if (type == 'S' && state == sserv) {
  1958.             spar (rdatap);
  1959.             ackl (rpar());
  1960.             bctu = bctr;
  1961.             nakstate = 1;
  1962.             BEGIN(srfil);
  1963.         }
  1964.  
  1965.         else if (type == 'G' && state == sserv) {
  1966.             decstr (strbuf);
  1967.             start = *strbuf;
  1968.             xpkt  = 1;
  1969.             nakstate = 0;    /* now I'm the sender */
  1970.             BEGIN(ssgen);
  1971.         }
  1972.  
  1973.         else if (type == 'C' && state == sserv) {
  1974.             decstr (strbuf);
  1975.             ss = system(strbuf);
  1976.             if (ss == 0)
  1977.                 BEGIN(ssini);
  1978.  
  1979.             else {
  1980.                 terror("Can't do system command");
  1981.                 SERVE;
  1982.             }
  1983.         }
  1984.  
  1985.         else if (type == 'E' && state == sserv) {
  1986.             if (local && rdatap != NULL)
  1987.                 tmsgl (rdatap);
  1988.  
  1989.             SERVE;
  1990.         }
  1991.  
  1992.         else if (state == sserv) {
  1993.             ERR("Unknown server command");
  1994.             SERVE;
  1995.         }
  1996.  
  1997.         /* Generic commands */
  1998.  
  1999.         else if (type == 'F' && state == ssgen) {
  2000.             ack();
  2001.             server = 0;
  2002.             return (0);
  2003.         }
  2004.  
  2005.         else if (type == 'T' && state == ssgen) {
  2006.             decstr(strbuf);
  2007.             nfils = 1;
  2008.             *cmlist = strbuf+2; /* setup for gnfile */
  2009.             if (sinit('S') < 0)  {
  2010.                 ERR("sinit");
  2011.             }
  2012.  
  2013.             else {
  2014.                 filcnt = 0;
  2015.                 BEGIN(ssfil);
  2016.             }
  2017.         }
  2018.  
  2019.         else if (state == ssgen) {
  2020.             serror ("Unknown command");
  2021.             SERVE;
  2022.         }
  2023.  
  2024.         else if (type == 'E') {
  2025.             if (local)
  2026.                 tmsgl (rdatap);
  2027.  
  2028.             RESUME;
  2029.         }
  2030.  
  2031.         else if (type == 'T') {
  2032.             tmsg ("Kermit--timeout in state <");
  2033.             tstate (state);
  2034.             tmsgl (">\n");
  2035.             zerror();
  2036.             if (server) {
  2037.                 tinit();
  2038.                 BEGIN(sserv);
  2039.             }
  2040.             else
  2041.                 return (-1);
  2042.         }
  2043.  
  2044.         else {
  2045.             if (local) {
  2046.                 tmsg ("Kermit--inconsistency:  state <");
  2047.                 tstate (state);
  2048.                 tmsg ("> packet type <");
  2049.                 if (isprint (type))
  2050.                     tchar (type);
  2051.                 else
  2052.                     tmsgn ((int) type);
  2053.  
  2054.                 tmsgl (">\n");
  2055.             }
  2056.  
  2057.             zerror();
  2058.             if (server) {
  2059.                 tinit();
  2060.                 BEGIN(sserv);
  2061.             }
  2062.             else
  2063.                 return (-1);
  2064.         }
  2065.     }
  2066.  
  2067.     ttres();
  2068.  
  2069.     return (-1);
  2070. }
  2071.  
  2072. void doexit (int x)
  2073. {
  2074.     ttres();
  2075.     ttclos();
  2076.     exit (x);
  2077. }
  2078.  
  2079. void fatal (char *msg)
  2080. {
  2081.     fprintf (stderr, "\r\nFatal: %s\n", msg);
  2082.     exit (-1);
  2083. }
  2084.  
  2085. void check_action()
  2086. {
  2087.     if (action)
  2088.         fatal ("conflicting actions");
  2089. }
  2090.  
  2091. void check_bundling (char *xp, char x)
  2092. {
  2093.     if (*(xp+1)) {
  2094.         fprintf (stderr,
  2095.              "\r\nFatal: invalid argument bundling after -%c\n",
  2096.              x);
  2097.         exit (-1);
  2098.     }
  2099. }
  2100.  
  2101. char *check_next_arg (char x)
  2102. {
  2103.     *xargv++;
  2104.     xargc--;
  2105.     if ((xargc == 0) || (**xargv == '-')) {
  2106.         fprintf (stderr, "\r\nFatal: missing argument after -%c\n", x);
  2107.         exit (-1);
  2108.     }
  2109.     return (*xargv);
  2110. }
  2111.  
  2112. char doarg (char x) 
  2113. {
  2114.     int        done;
  2115.     char    *xp;
  2116.     char    *fspc1;
  2117.     char    *fspc2;
  2118.  
  2119.     xp = *xargv+1;
  2120.     while (x) {
  2121.         switch (x) {
  2122.             case 'd':        /* debug switch */
  2123.                 debug = 1;
  2124.                 break;
  2125.  
  2126.             case 'x':        /* server */
  2127.                 check_action();
  2128.                 action = 'x';
  2129.                 break;
  2130.  
  2131.             case 'f':        /* generic finish */
  2132.                 check_action();
  2133.                 action = 'g';
  2134.                 cmarg = setgen ('F', "", "", "");
  2135.                 break;
  2136.  
  2137.             case 'r':        /* receive */
  2138.                 check_action();
  2139.                 action = 'v';
  2140.                 break;
  2141.  
  2142.             case 'm':        /* move */
  2143.                 mfile    = 1;
  2144.  
  2145.             case 's':        /* send */
  2146.                 check_action();
  2147.                 check_bundling (xp, x);
  2148.  
  2149.                 nfils    = 0;
  2150.                 done    = 0;
  2151.                 cmlist    = xargv+1;
  2152.  
  2153.                 while (done == 0) {
  2154.                     xargc--;
  2155.                     *xargv++;
  2156.                     if (xargc < 1)
  2157.                         done = 1;
  2158.  
  2159.                     else if (*xargv == NULL)
  2160.                         done = 1;
  2161.  
  2162.                     else if (**xargv == '-') {
  2163.                         done = 1;
  2164.                         }
  2165.                     else {
  2166.                         nfils++;
  2167.                     }
  2168.                 }
  2169.  
  2170.                 xargc++;
  2171.                 *xargv--;
  2172.  
  2173.                 if (nfils < 1)
  2174.                     fatal ("missing filename for -s");
  2175.  
  2176.                 action = 's';
  2177.                 break;
  2178.  
  2179.             case 'g':        /* get */
  2180.                 check_action();
  2181.                 check_bundling (xp, x);
  2182.                 cmarg = check_next_arg (x);
  2183.                 action = 'r';
  2184.                 break;
  2185.  
  2186.             case 't':            /* remote type */
  2187.                 check_action();
  2188.                 check_bundling (xp, x);
  2189.                 fspc1  = check_next_arg (x); 
  2190.                 cmarg  = setgen ('T', fspc1, "", "");
  2191.                 action = 'g';
  2192.                 break;
  2193.  
  2194.             case 'C':            /* Host Command */
  2195.                 cmarg = check_next_arg (x);
  2196.                 if (action == 0)
  2197.                     action = 'c';
  2198.  
  2199.                 break;
  2200.  
  2201.             case 'R':    /* rename */
  2202.                 check_bundling (xp, x);
  2203.                 fspc1  = check_next_arg (x);
  2204.                 fspc2  = check_next_arg (x);
  2205.                 cmarg  = setgen ('R', fspc1, fspc2, "");
  2206.                 if (action == 0)
  2207.                     action = 'g';
  2208.  
  2209.                 break;
  2210.  
  2211.             case 'h':    /* help */
  2212.                 usage();
  2213.                 return (-1);
  2214.  
  2215.             case 'l':    /* communication device */
  2216.                 check_bundling (xp, x);
  2217.                 fspc1 = check_next_arg (x);
  2218.                 strcpy (ttname, fspc1);
  2219.                 break;
  2220.  
  2221.             case 'i':
  2222.                 text = 0;
  2223.                 break;
  2224.  
  2225.             case 'p':
  2226.                 check_bundling (xp, x);
  2227.                 check_next_arg (x);
  2228.                 switch (x = **xargv) {
  2229.                   case    'e':
  2230.                   case    'o':
  2231.                   case    'm':
  2232.                   case    's':    parity = x; break;
  2233.                   case    'n':    parity = 0; break;
  2234.                   default:    fatal ("invalid parity");
  2235.                 }
  2236.                 break;
  2237.  
  2238.             case '1':
  2239.             case '2':
  2240.             case '3':
  2241.                 bctr = x - '0';
  2242.                 break;
  2243.  
  2244.             default:
  2245.               fatal("Invalid argument, type 'kermit -h' for help");
  2246.         }
  2247.  
  2248.         x = *++xp;
  2249.     }
  2250.  
  2251.     return (0);
  2252. }
  2253.  
  2254. char cmdlin()
  2255. {
  2256.     char    x;
  2257.  
  2258.     cmarg    = "";
  2259.     action    = 0;
  2260.     cmlist    = xargv;
  2261.  
  2262.     while (--xargc > 0) {
  2263.         xargv++;
  2264.         if (**xargv == '-') { 
  2265.             x = *(*xargv+1);
  2266.             x = doarg (x);
  2267.             if (x < 0)
  2268.                 exit (x);
  2269.         }
  2270.         else {
  2271.             usage();
  2272.             exit(0);
  2273.         }
  2274.     }
  2275.  
  2276.     return (action);
  2277. }
  2278.  
  2279. void main (int argc, char **argv)
  2280. {
  2281.     xargc    = argc;
  2282.     xargv    = argv;
  2283.     start    = 0;
  2284.     seq     = 0;
  2285.  
  2286.     if (argc <= 1) 
  2287.         usage();
  2288.  
  2289.     else {
  2290.         signal (SIGINT, trap_signal);
  2291.  
  2292.         start = cmdlin();
  2293.         if (start == 0)
  2294.             fatal ("no start state");
  2295.  
  2296.         else {
  2297.             if ((local = ttopen (ttname)) < 0) 
  2298.                 fatal ("Can't open line");
  2299.  
  2300.             ttpkt();
  2301.  
  2302.             if (start) {
  2303.                 doexit (yylex());
  2304.             }
  2305.         }
  2306.     }
  2307. }
  2308.