home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / c / ck5a188s.zip / CKCFNS.C < prev    next >
C/C++ Source or Header  |  1992-11-23  |  67KB  |  2,105 lines
  1. char *fnsv = "C-Kermit functions, 5A(079) 23 Nov 92";
  2.  
  3. /*  C K C F N S  --  System-independent Kermit protocol support functions.  */
  4.  
  5. /*  ...Part 1 (others moved to ckcfn2,3 to make this module small enough) */
  6.  
  7. /*
  8.   Author: Frank da Cruz (fdc@columbia.edu, FDCCU@CUVMA.BITNET),
  9.   Columbia University Center for Computing Activities.
  10.   First released January 1985.
  11.   Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
  12.   York.  Permission is granted to any individual or institution to use this
  13.   software as long as it is not sold for profit.  This copyright notice must be
  14.   retained.  This software may not be included in commercial products without
  15.   written permission of Columbia University.
  16. */
  17. /*
  18.  System-dependent primitives defined in:
  19.  
  20.    ck?tio.c -- terminal i/o
  21.    cx?fio.c -- file i/o, directory structure
  22. */
  23. #include "ckcsym.h"            /* Once needed this for Mac... */
  24. #include "ckcasc.h"            /* ASCII symbols */
  25. #include "ckcdeb.h"            /* Debug formats, typedefs, etc. */
  26. #include "ckcker.h"            /* Symbol definitions for Kermit */
  27. #include "ckcxla.h"            /* Character set symbols */
  28.  
  29. /* Externals from ckcmai.c */
  30. extern int spsiz, spmax, rpsiz, timint, srvtim, rtimo, npad, ebq, ebqflg,
  31.  rpt, rptq, rptflg, capas, keep, fncact, pkttim, autopar, spsizr;
  32. extern int pktnum, bctr, bctu, bctl, fmask, clfils, sbufnum,
  33.  size, osize, spktl, nfils, warn, timef, spsizf, sndtyp, success;
  34. extern int parity, turn, network, what, fsecs,
  35.  delay, displa, xflg, mypadn;
  36. extern long filcnt, ffc, flci, flco, tlci, tlco, tfc, fsize, speed;
  37. extern int fblksiz, frecl, frecfm, forg, fcctrl;
  38. extern int spackets, rpackets, timeouts, retrans, crunched, wmax;
  39. extern int hcflg, binary, savmod, fncnv, local, server, cxseen, czseen;
  40. extern int nakstate, discard;
  41. extern int rq, rqf, sq, wslots, wslotn, wslotr, winlo, urpsiz, rln;
  42. extern int atcapr, atcapb, atcapu;
  43. extern int lpcapr, lpcapb, lpcapu;
  44. extern int swcapr, swcapb, swcapu;
  45. extern int lscapr, lscapb, lscapu;
  46. extern int bsave, bsavef;
  47. extern int sseqtbl[];
  48. extern int numerrs;
  49. extern long rptn;
  50. extern int maxtry;
  51.  
  52. #ifndef NOCSETS
  53. extern int tcharset, fcharset;
  54. extern int ntcsets;
  55. extern struct csinfo tcsinfo[], fcsinfo[];
  56. #endif /* NOCSETS */
  57.  
  58. extern int
  59.   atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko,
  60.   attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso; 
  61.  
  62. extern int bigsbsiz, bigrbsiz;
  63.  
  64. #ifdef DYNAMIC
  65.   extern CHAR *srvcmd;
  66. #else
  67.   extern CHAR srvcmd[];
  68. #endif /* DYNAMIC */
  69. extern CHAR padch, mypadc, eol, seol, ctlq, myctlq, sstate;
  70. extern CHAR *recpkt, *data, padbuf[], stchr, mystch;
  71. extern CHAR *srvptr;
  72. extern CHAR *rdatap;
  73. extern char *cmarg, *cmarg2, *hlptxt, **cmlist, filnam[], fspec[];
  74.  
  75. _PROTOTYP( CHAR *rpar, (void) );
  76. _PROTOTYP( int lslook, (unsigned int b) );    /* Locking Shift Lookahead */
  77. _PROTOTYP( int szeof, (CHAR *s) );
  78.  
  79. /* International character sets */
  80.  
  81. #ifndef NOCSETS
  82. /* Pointers to translation functions */
  83. #ifdef CK_ANSIC
  84. extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* Character set */
  85. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* translation functions */
  86. #else
  87. extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])();    /* Character set */
  88. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])();    /* translation functions. */
  89. #endif /* CK_ANSIC */
  90. _PROTOTYP( CHAR (*rx), (CHAR) );    /* Input translation function */
  91. _PROTOTYP( CHAR (*sx), (CHAR) );    /* Output translation function */
  92. _PROTOTYP( CHAR ident, (CHAR) );    /* Identity translation function */
  93. #endif /* NOCSETS */
  94.  
  95. /* Windowing things */
  96.  
  97. extern int rseqtbl[];            /* Rec'd-packet sequence # table */
  98.  
  99. /* (PWP) external def. of things used in buffered file input and output */
  100.  
  101. #ifdef DYNAMIC
  102. extern char *zinbuffer, *zoutbuffer;
  103. #else
  104. extern char zinbuffer[], zoutbuffer[];
  105. #endif
  106. extern char *zinptr, *zoutptr;
  107. extern int zincnt, zoutcnt;
  108.  
  109. /* Variables defined in this module, but shared by ckcfn3, to which */
  110. /* several functions have been moved... */
  111.  
  112. int sndsrc;        /* Flag for where to get names of files to send: */
  113.                     /* -1: znext() function */
  114.                     /*  0: stdin */
  115.                     /* >0: list in cmlist */
  116.  
  117. int  memstr;                /* Flag for input from memory string */
  118.  
  119. #ifdef pdp11
  120. CHAR myinit[25];            /* Copy of my Send-Init data */
  121. #else
  122. CHAR myinit[100];            /* Copy of my Send-Init data */
  123. #endif /* pdp11 */
  124.  
  125. /* Variables local to this module */
  126.  
  127. static char *memptr;            /* Pointer for memory strings */
  128.  
  129. #ifdef pdp11
  130. static char cmdstr[50];            /* System command string. */
  131. #else
  132. static char cmdstr[100];
  133. #endif /* pdp11 */
  134.  
  135. static int drain;            /* For draining stacked-up ACKs. */
  136.  
  137. static int first;            /* Flag for first char from input */
  138. static CHAR t,                /* Current character */
  139.     next;                /* Next character */
  140.  
  141. static int lsstate = 0;            /* Locking shift state */
  142. static int lsquote = 0;            /* Locking shift quote */
  143.  
  144. #ifdef datageneral
  145. extern int quiet;
  146. #endif
  147.  
  148. /*  E N C S T R  --  Encode a string from memory. */
  149.  
  150. /*
  151.   Call this instead of getpkt() if source is a string, rather than a file.
  152.   Note: Character set translation is never done in this case.
  153. */
  154.  
  155. #ifdef pdp11
  156. #define ENCBUFL 100
  157. #else
  158. #define ENCBUFL 200
  159. #endif /* pdp11 */
  160. CHAR encbuf[ENCBUFL];
  161.  
  162. int
  163. encstr(s) CHAR* s; {
  164.     int m; char *p;
  165.     CHAR *dsave;
  166.  
  167.     if ((m = (int)strlen((char *)s)) > ENCBUFL) {
  168.     debug(F111,"encstr string too long for buffer",s,ENCBUFL);
  169.     s[ENCBUFL] = '\0';
  170.     }
  171.     if (m > spsiz-bctl-3) {
  172.     debug(F111,"encstr string too long for packet",s,spsiz-bctl-3);
  173.     s[spsiz-bctl-3] = '\0';
  174.     }
  175.     m = memstr; p = memptr;        /* Save these. */
  176.  
  177.     memptr = (char *)s;            /* Point to the string. */
  178.     memstr = 1;                /* Flag memory string as source. */
  179.     first = 1;                /* Initialize character lookahead. */
  180.     dsave = data;            /* Boy is this ugly... */
  181.     data = encbuf + 7;            /* Why + 7?  See spack()... */
  182. #ifdef COMMENT
  183.     getpkt(spsiz-bctl-3,0);        /* Fill a packet from the string. */
  184. #else
  185.     getpkt(spsiz,0);
  186. #endif /* COMMENT */
  187.     data = dsave;            /* (sorry...) */
  188.     memstr = m;                /* Restore memory string flag */
  189.     memptr = p;                /* and pointer */
  190.     first = 1;                /* Put this back as we found it. */
  191.     return(0);
  192. }
  193.  
  194. #ifdef COMMENT
  195. /*
  196.   We don't use this routine any more -- the code has been incorporated
  197.   directly into getpkt() to reduce per-character function call overhead.
  198.   Also, watch out: it hasn't been updated since it was commented out a
  199.   long time ago.
  200. */
  201. /* E N C O D E - Kermit packet encoding procedure */
  202.  
  203. VOID
  204. encode(a) CHAR a; {            /* The current character */
  205.     int a7;                /* Low order 7 bits of character */
  206.     int b8;                /* 8th bit of character */
  207.  
  208. #ifndef NOCSETS
  209.     if (!binary && sx) a = (*sx)(a);    /* Translate. */
  210. #endif /* NOCSETS */
  211.  
  212.     if (rptflg)    {                   /* Repeat processing? */
  213.         if (a == next && (first == 0)) { /* Got a run... */
  214.         if (++rpt < 94)        /* Below max, just count */
  215.                 return;
  216.         else if (rpt == 94) {    /* Reached max, must dump */
  217.                 data[size++] = rptq;
  218.                 data[size++] = tochar(rpt);
  219.         rptn += rpt;        /* Count, for stats */
  220.                 rpt = 0;
  221.         }
  222.         } else if (rpt == 1) {        /* Run broken, only 2? */
  223.             rpt = 0;            /* Yes, reset repeat flag & count. */
  224.         encode(a);            /* Do the character twice. */
  225.         if (size <= maxsize) osize = size;
  226.         rpt = 0;
  227.         encode(a);
  228.         return;
  229.     } else if (rpt > 1) {        /* More than two */
  230.             data[size++] = rptq;    /* Insert the repeat prefix */
  231.             data[size++] = tochar(++rpt); /* and count. */
  232.         rptn += rpt;
  233.             rpt = 0;            /* Reset repeat counter. */
  234.         }
  235.     }
  236.     a7 = a & 0177;            /* Isolate ASCII part */
  237.     b8 = a & 0200;            /* and 8th (parity) bit. */
  238.  
  239.     if (ebqflg && b8) {            /* Do 8th bit prefix if necessary. */
  240.         data[size++] = ebq;
  241.         a = a7;
  242.     }
  243.     if ((a7 < SP) || (a7==DEL))    {    /* Do control prefix if necessary */
  244.         data[size++] = myctlq;
  245.     a = ctl(a);
  246.     }
  247.     if (a7 == myctlq)            /* Prefix the control prefix */
  248.         data[size++] = myctlq;
  249.  
  250.     if ((rptflg) && (a7 == rptq))    /* If it's the repeat prefix, */
  251.         data[size++] = myctlq;        /* quote it if doing repeat counts. */
  252.  
  253.     if ((ebqflg) && (a7 == ebq))    /* Prefix the 8th bit prefix */
  254.         data[size++] = myctlq;        /* if doing 8th-bit prefixes */
  255.  
  256.     data[size++] = a;            /* Finally, insert the character */
  257.     data[size] = '\0';            /* itself, and mark the end. */
  258. }
  259. #endif /* COMMENT */
  260.  
  261. /*  Output functions passed to 'decode':  */
  262.  
  263. int                   /*  Put character in server command buffer  */
  264. #ifdef CK_ANSIC
  265. putsrv(char c)
  266. #else
  267. putsrv(c) register char c;
  268. #endif /* CK_ANSIC */
  269. /* putsrv */ {
  270.     *srvptr++ = c;
  271.     *srvptr = '\0';        /* Make sure buffer is null-terminated */
  272.     return(0);
  273. }
  274.  
  275. int                    /*  Output character to console.  */
  276. #ifdef CK_ANSIC
  277. puttrm(char c)
  278. #else
  279. puttrm(c) register char c;
  280. #endif /* CK_ANSIC */
  281. /* puttrm */ {
  282.     conoc(c);
  283.     return(0);
  284. }
  285.  
  286. int                    /*  Output char to file. */
  287. #ifdef CK_ANSIC
  288. putfil(char c)
  289. #else
  290. putfil(c) register char c;
  291. #endif /* CK_ANSIC */
  292. /* putfil */ {
  293.     if (zchout(ZOFILE, (char) (c & fmask)) < 0) {
  294.     czseen = 1;               /* If write error... */
  295.     debug(F101,"putfil zchout write error, setting czseen","",1);
  296.     return(-1);
  297.     }
  298.     return(0);
  299. }
  300.  
  301. /* D E C O D E  --  Kermit packet decoding procedure */
  302.  
  303. /*
  304.  Call with string to be decoded and an output function.
  305.  Returns 0 on success, -1 on failure (e.g. disk full).
  306.  
  307.  This is the "inner loop" when receiving files, and must be coded as 
  308.  efficiently as possible.  Note some potential problems:  if a packet
  309.  is badly formed, having a prefixed sequence ending prematurely, this
  310.  function, as coded, could read past the end of the packet.  This has
  311.  never happened, thus the additional (time-consuming) tests have not
  312.  been added.
  313. */
  314.  
  315. static CHAR *xdbuf;    /* Global version of decode()'s buffer pointer */
  316.                         /* for use by translation functions. */
  317.  
  318. /* Function for pushing a character onto decode()'s input stream. */
  319.  
  320. VOID
  321. #ifdef CK_ANSIC
  322. zdstuff(CHAR c)
  323. #else
  324. zdstuff(c) CHAR c;
  325. #endif /* CK_ANSIC */
  326. /* zdstuff */ {    
  327.     xdbuf--;                /* Back up the pointer. */
  328.     *xdbuf = c;                /* Stuff the character. */
  329. }
  330.  
  331. int
  332. #ifdef CK_ANSIC
  333. decode(CHAR *buf, int (*fn)(char), int xlate)
  334. #else
  335. decode(buf,fn,xlate) register CHAR *buf; register int (*fn)(); int xlate;
  336. #endif /* CK_ANSIC */
  337. /* decode */ {
  338.     register unsigned int a, a7, a8, b8; /* Various copies of current char */
  339.     int t;                /* Int version of character */
  340.     int ssflg;                /* Character was single-shifted */
  341.  
  342. /*
  343.   Catch the case in which we are asked to decode into a file that is not open,
  344.   for example, if the user interrupted the transfer, but the other Kermit
  345.   keeps sending.
  346. */
  347.     if ((cxseen || czseen || discard) && (fn == putfil))
  348.       return(0);
  349.  
  350.     xdbuf = buf;            /* Make global copy of pointer. */
  351.     rpt = 0;                /* Initialize repeat count. */
  352.  
  353.     while ((a = *xdbuf++ & 0xFF) != '\0') { /* Get next character. */
  354.     if (a == rptq && rptflg) {    /* Got a repeat prefix? */
  355.         rpt = xunchar(*xdbuf++ & 0xFF); /* Yes, get the repeat count, */
  356.         rptn += rpt;
  357.         a = *xdbuf++ & 0xFF;    /* and get the prefixed character. */
  358.     }
  359.     b8 = lsstate ? 0200 : 0;    /* 8th-bit value from SHIFT-STATE */
  360.     if (ebqflg && a == ebq) {    /* Have 8th-bit prefix? */
  361.         b8 ^= 0200;            /* Yes, invert the 8th bit's value, */
  362.         ssflg = 1;            /* remember we did this, */
  363.         a = *xdbuf++ & 0xFF;    /* and get the prefixed character. */
  364.     } else ssflg = 0;
  365.  
  366.     if (a == ctlq) {        /* If control prefix, */
  367.         a  = *xdbuf++ & 0xFF;    /* get its operand */
  368.         a7 = a & 0x7F;        /* and its low 7 bits. */
  369.         if ((a7 >= 0100 && a7 <= 0137) || a7 == '?') /* Controllify */
  370.           a = ctl(a);        /* if in control range. */
  371.         if (lscapu) {        /* If doing locking shifts... */
  372.         if (lsstate)        /* If SHIFTED */
  373.           a8 = (a & ~b8) & 0xFF; /* Invert meaning of 8th bit */
  374.         else            /* otherwise */
  375.           a8 = a | b8;        /* OR in 8th bit */
  376.         /* If we're not in a quoted sequence */
  377.         if (!lsquote && (!lsstate || !ssflg)) {
  378.             if (a8 == DLE) {    /* Check for DLE quote */
  379.             lsquote = 1;    /* prefixed by single shift! */
  380.             continue;
  381.             } else if (a8 == SO) { /* Check for Shift-Out */
  382.             lsstate = 1;    /* SHIFT-STATE = SHIFTED */
  383.             continue;
  384.             } else if (a8 == SI) { /* or Shift-In */
  385.             lsstate = 0;    /* SHIFT-STATE = UNSHIFTED */
  386.             continue;
  387.             }
  388.         } else lsquote = 0;
  389.         }
  390.     }
  391.     a |= b8;            /* OR in the 8th bit */
  392.     if (rpt == 0) rpt = 1;        /* If no repeats, then one */
  393.     if (!binary) {            /* If in text mode, */
  394. #ifdef NLCHAR
  395.         if (a == CR) continue;    /* Discard carriage returns, */
  396.             if (a == LF) a = NLCHAR;     /* convert LF to system's newline. */
  397. #endif /* NLCHAR */
  398.  
  399. #ifndef NOCSETS                /* Character-set translation */
  400. #ifdef KANJI                /* For Kanji transfers, */
  401.         if (tcharset != TC_JEUC)    /* postpone translation. */
  402. #endif /* KANJI */
  403.           if (xlate && rx) a = (*rx)((CHAR) a); /* Translate charset */
  404. #endif /* NOCSETS */
  405.         }
  406.     if (fn == putfil) { /* (PWP) speedup via buffered output and a macro */
  407.         for (; rpt > 0; rpt--) {    /* Output the char RPT times */
  408. #ifndef NOCSETS
  409. #ifdef KANJI
  410.         if (!binary && tcharset == TC_JEUC &&
  411.             fcharset != FC_JEUC) { /* Translating from J-EUC */
  412.             if (ffc == 0L) xkanjf();
  413.             if (xkanji(a,fn) < 0)  /* to something else? */
  414.               return(-1);
  415.         } else
  416. #endif /* KANJI */
  417. #endif /* NOCSETS */
  418.         if ((t = zmchout(a & fmask)) < 0) { /* zmchout is a macro */
  419. #ifdef COMMENT
  420. /* Too costly, uncomment these if you really need them. */
  421.             debug(F101,"decode zmchout","",t);
  422.             debug(F101,"decode zoutcnt","",zoutcnt);
  423.             debug(F101,"decode a","",a);
  424. #endif /* COMMENT */
  425.             return(-1);
  426.         }
  427.         ffc++;            /* Count the character */
  428.         }
  429.     } else {            /* Output to something else. */
  430.         a &= fmask;            /* Apply file mask */
  431.         for (; rpt > 0; rpt--) {    /* Output the char RPT times */
  432.         if ((*fn)((char) a) < 0) return(-1); /* Send to output func. */
  433.         ffc++;
  434.         }
  435.     }
  436.     }
  437.     return(0);
  438. }
  439.  
  440. /*  G E T P K T -- Fill a packet data field  */
  441.  
  442. /*
  443.  Gets characters from the current source -- file or memory string.
  444.  Encodes the data into the packet, filling the packet optimally.
  445.  Set first = 1 when calling for the first time on a given input stream
  446.  (string or file).
  447.  
  448.  Call with:
  449.  bufmax -- current send-packet size
  450.  xlate  -- flag: 0 to skip character-set translation, 1 to translate
  451.  
  452.  Uses global variables:
  453.  t     -- current character.
  454.  first -- flag: 1 to start up, 0 for input in progress, -1 for EOF.
  455.  next  -- next character.
  456.  data  -- pointer to the packet data buffer.
  457.  size  -- number of characters in the data buffer.
  458.  memstr - flag that input is coming from a memory string instead of a file.
  459.  memptr - pointer to string in memory.
  460.  (*sx)()  character set translation function
  461.  
  462. Returns the size as value of the function, and also sets global "size",
  463. and fills (and null-terminates) the global data array.  Returns 0 upon eof.
  464.  
  465. Rewritten by Paul W. Placeway (PWP) of Ohio State University, March 1989.
  466. Incorporates old getchx() and encode() inline to reduce function calls,
  467. uses buffered input for much-improved efficiency, and clears up some
  468. confusion with line termination (CRLF vs LF vs CR).
  469.  
  470. Rewritten again by Frank da Cruz to incorporate locking shift mechanism,
  471. May 1991.
  472. */
  473.  
  474. /*
  475.   Lookahead function to decide whether locking shift is worth it.  Looks at
  476.   the next four input characters to see if all of their 8th bits match the
  477.   argument.  Call with 0 or 0200.  Returns 1 if so, 0 if not.  If we don't
  478.   happen to have at least 4 more characters waiting in the input buffer,
  479.   returns 1.  Note that zinptr points two characters ahead of the current
  480.   character because of repeat-count lookahead.
  481. */
  482.  
  483. #ifdef KANJI
  484. int
  485. kgetf() {
  486.     return(zminchar());
  487. }
  488.  
  489. int
  490. kgetm() {
  491.     int x;
  492.     if (x = *memptr++) return(x);
  493.     else return(-1);
  494. }
  495. #endif /* KANJI */
  496.  
  497. int
  498. lslook(b) unsigned int b; {        /* Locking Shift Lookahead */
  499.     int i;
  500.     if (zincnt < 3)            /* If not enough chars in buffer, */
  501.       return(1);            /* force shift-state switch. */
  502.     b &= 0200;                /* Force argument to proper form. */
  503.     for (i = -1; i < 3; i++)        /* Look at next 5 characters to */
  504.       if (((*(zinptr+i)) & 0200) != b)    /* see if all their 8th bits match.  */
  505.     return(0);            /* They don't. */
  506.     return(1);                /* They do. */
  507. }
  508.  
  509. int
  510. getpkt(bufmax,xlate) int bufmax, xlate; { /* Fill one packet buffer */
  511.     register CHAR rt = t, rnext = next; /* register shadows of the globals */
  512.     register CHAR *dp, *odp, *odp2, *p1, *p2; /* pointers... */
  513.     register int x;            /* Loop index. */
  514.     register int a7;            /* Low 7 bits of character */
  515.     static CHAR leftover[9] = { '\0','\0','\0','\0','\0','\0','\0','\0','\0' };
  516.     CHAR xxls, xxdl, xxrc, xxss, xxcq;    /* Pieces of prefixed sequence */
  517.     int n;                /* worker */
  518.  
  519. /*
  520.   Assume bufmax is the receiver's total receive-packet buffer length.
  521.   Our whole packet has to fit into it, so we adjust the data field length.
  522.   We also decide optimally whether it is better to use a short-format or
  523.   long-format packet when we're near the borderline.
  524. */
  525.     n = bufmax - 5;            /* Space for Data and Checksum */
  526.     if (n > 92 && n < 96) n = 92;    /* "Short" Long packets don't pay */
  527.     if (n > 92 && lpcapu == 0)        /* If long packets needed, */
  528.       n = 92;                /* make sure they've been negotiated */
  529.     bufmax = n - bctl;            /* Space for data */
  530.     if (n > 92) bufmax -= 3;        /* Long packet needs header chksum */
  531.  
  532.     if (first == 1) {        /* If first character of this file... */
  533.     ffc = 0L;        /* Reset file character counter */
  534.     first = 0;        /* Next character won't be first */
  535.     *leftover = '\0';    /* Discard any interrupted leftovers, */
  536.  
  537.     /* get first character of file into rt, watching out for null file */
  538.  
  539. #ifndef NOCSETS
  540. #ifdef KANJI
  541.     if (!binary && tcharset == TC_JEUC && xlate) {
  542.         x = zkanjf();
  543.         if ((x = zkanji( memstr ? kgetm : kgetf )) < 0) {
  544.             first = -1;
  545.             size = 0;
  546.             if (x == -2) {
  547.                 debug(F100,"getpkt(zkanji): input error","",0);
  548.                 cxseen = 1;
  549.             } else debug(F100,"getpkt(zkanji): empty string/file","",0);
  550.             return (0);
  551.         }
  552.         ffc++;
  553.         rt = x;
  554.     } else {
  555. #endif /* KANJI */
  556. #endif /* not NOCSETS */
  557.     if (memstr) {            /* Reading data from memory string */
  558.         if ((rt = *memptr++) == '\0') { /* end of string ==> EOF */
  559.         first = -1;
  560.             size = 0;
  561.         debug(F100,"getpkt: empty string","",0);
  562.         return (0);
  563.         }
  564.  
  565.     } else {            /* Reading data from a file */
  566.  
  567.         if ((x = zminchar()) < 0) { /* End of file or input error */
  568.         first = -1;
  569.             size = 0;
  570.         if (x == -2) {        /* Error */
  571.             debug(F100,"getpkt: input error","",0);
  572.             cxseen = 1;        /* Interrupt the file transfer */
  573.         } else debug(F100,"getpkt: empty file","",0); /* Empty file */
  574.         return(0);
  575.         }
  576.         ffc++;            /* Count a file character */
  577.         rt = x;            /* Convert int to char */
  578.         debug(F101,"getpkt zminchar","",rt);
  579.     }
  580. #ifndef NOCSETS
  581. #ifdef KANJI
  582.     }
  583. #endif /* KANJI */
  584. #endif /* not NOCSETS */
  585.  
  586.     rt &= fmask;            /* Apply SET FILE BYTESIZE mask */
  587.     debug(F101,"getpkt fmask","",fmask);
  588.     debug(F101,"getpkt new rt","",rt);
  589.  
  590. #ifndef NOCSETS
  591.     if (xlate) {
  592.         debug(F101,"getpkt about to call translate function","",rt);
  593.         debug(F101,"tcharset","",tcharset);
  594.         debug(F101,"fcharset","",fcharset);
  595.     }
  596. #ifdef KANJI
  597.     if (tcharset != TC_JEUC)
  598. #endif /* KANJI */
  599.       if (!binary && sx && xlate) {
  600.           rt = (*sx)(rt); /* Translate */
  601.           debug(F101," translate function returns","",rt);
  602.       }
  603. #endif /* not NOCSETS */
  604.  
  605.     /* PWP: handling of NLCHAR is done later (in the while loop)... */
  606.  
  607.     } else if ((first == -1) && (*leftover == '\0')) /* EOF from last time? */
  608.         return(size = 0);
  609. /*
  610.   Here we handle characters that were encoded for the last packet but
  611.   did not fit, and so were saved in the "leftover" array.
  612. */
  613.     dp = data;                /* Point to packet data buffer */
  614.     for (p1 = leftover; (*dp = *p1) != '\0'; p1++, dp++) /* Copy leftovers */
  615.         ;
  616.     *leftover = '\0';            /* Delete leftovers */
  617.     if (first == -1)            /* Handle EOF */
  618.       return(size = (dp - data));
  619.   
  620. /* Now fill up the rest of the packet. */
  621.  
  622.     rpt = 0;                /* Initialize character repeat count */
  623.  
  624.     while (first > -1) {        /* Until EOF... */
  625. #ifndef NOCSETS
  626. #ifdef KANJI
  627.     if (!binary && xlate && tcharset == TC_JEUC) {
  628.         if ((x = zkanji( memstr ? kgetm : kgetf )) < 0) {
  629.             first = -1;
  630.             if (x == -2) cxseen = 1;
  631.         }
  632.         ffc++;
  633.         rnext = x & fmask;
  634.     } else {
  635. #endif /* KANJI */
  636. #endif /* not NOCSETS */
  637.     if (memstr) {            /* Get next char from memory string */
  638.         if ((x = *memptr++) == '\0') /* End of string means EOF */
  639.           first = -1;        /* Flag EOF for next time. */
  640.         rnext = x & fmask;        /* Apply file mask */
  641.     } else {
  642.         if ((x = zminchar()) < 0) { /* Real file, check for EOF */
  643.         first = -1;        /* Flag eof for next time. */
  644.         if (x == -2) cxseen = 1; /* If error, cancel this file. */
  645.         }
  646.         rnext = x & fmask;        /* Apply file mask */
  647.     } 
  648.     ffc++;                /* Count the character */
  649. #ifndef NOCSETS
  650. #ifdef KANJI
  651.     }
  652. #endif /* KANJI */
  653. #endif /* not NOCSETS */
  654.  
  655.     /*** debug(F101,"getpkt rnext","",rnext); ***/
  656.  
  657. #ifndef NOCSETS
  658. #ifdef KANJI
  659.     if (tcharset != TC_JEUC)
  660. #endif /* KANJI */
  661.         if (!binary && sx && xlate) {
  662.         rnext = (*sx)(rnext); /* Translate */
  663.         debug(F101,"getpkt xlated rnext to","",rnext);
  664.         }
  665. #endif /* not NOCSETS */
  666.  
  667.     odp = dp;            /* Remember where we started. */
  668.     xxls = xxdl = xxrc = xxss = xxcq = NUL;    /* Clear these. */
  669.  
  670. /*
  671.   Now encode the character according to the options that are in effect:
  672.     binary: text or binary mode.
  673.     rptflg: repeat counts enabled.
  674.     ebqflg: 8th-bit prefixing enabled.
  675.     lscapu: locking shifts enabled.
  676. */
  677.     if (rptflg) {            /* Repeat processing is on? */
  678.         if (
  679. #ifdef NLCHAR
  680.         /*
  681.          * If the next char is really CRLF, then we cannot
  682.          * be doing a repeat (unless CR,CR,LF which becomes
  683.          * "~ <n-1> CR CR LF", which is OK but not most efficient).
  684.          * I just plain don't worry about this case.  The actual
  685.          * conversion from NL to CRLF is done after the rptflg if...
  686.          */
  687.         (binary || (rnext != NLCHAR)) &&
  688. #endif /* NLCHAR */
  689.         (rt == rnext) && (first == 0)) { /* Got a run... */
  690.         if (++rpt < 94) {    /* Below max, just count */
  691.             continue;        /* go back and get another */
  692.         }
  693.         else if (rpt == 94) {    /* Reached max, must dump */
  694.             xxrc = tochar(rpt);    /* Put the repeat count here */
  695.             rptn += rpt;    /* Accumulate it for statistics */
  696.             rpt = 0;        /* And reset it */
  697.         }
  698.         } else if (rpt > 1) {    /* More than two */
  699.         xxrc = tochar(++rpt);    /* and count. */
  700.         rptn += rpt;
  701.         rpt = 0;        /* Reset repeat counter. */
  702.         }
  703.         /*
  704.           If (rpt == 1) we must encode exactly two characters.
  705.           This is done later, after the first character is encoded.
  706.         */
  707.     }
  708.  
  709. #ifdef NLCHAR
  710.     if (!binary && (rt == NLCHAR)) { /* It's the newline character */
  711.         if (lscapu && lsstate) {    /* If SHIFT-STATE is SHIFTED */
  712.         if (ebqflg) {        /* If single shifts enabled, */
  713.             *dp++ = ebq;    /* insert a single shift. */
  714.         } else {        /* Otherwise must shift in. */
  715.             *dp++ = myctlq;    /* Insert shift-out code */
  716.             *dp++ = 'O';
  717.             lsstate = 0;    /* Change shift state */
  718.         }
  719.         }
  720.         *dp++ = myctlq;        /* Insert carriage return directly */
  721.         *dp++ = 'M';
  722.         rt = LF;            /* Now make next char be linefeed. */
  723.     }
  724. #endif /* NLCHAR */
  725.  
  726. /*
  727.   Now handle the 8th bit of the file character.  If we have an 8-bit
  728.   connection, we preserve the 8th bit.  If we have a 7-bit connection,
  729.   we employ either single or locking shifts (if they are enabled).
  730. */
  731.     a7 = rt & 0177;            /* Get low 7 bits of character */
  732.     if (rt & 0200) {        /* 8-bit character? */
  733.         if (lscapu) {        /* Locking shifts enabled? */
  734.         if (!lsstate) {        /* Not currently shifted? */
  735.             x = lslook(0200);    /* Look ahead */
  736.             if (x != 0 || ebqflg == 0) { /* Locking shift decision */
  737.             xxls = 'N';       /* Need locking shift-out */
  738.             lsstate = 1;       /* and change to shifted state */
  739.             } else if (ebqflg) {   /* Not worth it */
  740.             xxss = ebq;       /* Use single shift */
  741.             }
  742.         }
  743.         rt = a7;        /* Replace character by 7-bit value */
  744.         } else if (ebqflg) {    /* 8th bit prefixing is on? */
  745.         xxss = ebq;        /* Insert single shift */
  746.         rt = a7;        /* Replace character by 7-bit value */
  747.         }
  748.  
  749.     } else if (lscapu) {        /* 7-bit character */
  750.  
  751.         if (lsstate) {        /* Comes while shifted out? */
  752.         x = lslook(0);        /* Yes, look ahead */
  753.         if (x || ebqflg == 0) {    /* Time to shift in. */
  754.             xxls = 'O';        /* Set shift-in code */
  755.             lsstate = 0;    /* Exit shifted state */
  756.         } else if (ebqflg) {    /* Not worth it, stay shifted out */
  757.             xxss = ebq;        /* Insert single shift */
  758.         }
  759.         }
  760.     }
  761.     /* If data character is significant to locking shift protocol... */
  762.     if (lscapu && (a7 == SO || a7 == SI || a7 == DLE))
  763.       xxdl = 'P';            /* Insert datalink escape */
  764.  
  765.     if ((a7 < SP) || (a7 == DEL)) { /* Do control prefixing if necessary */
  766.         xxcq = myctlq;        /* The prefix */
  767.         rt = ctl(rt);        /* Uncontrollify the character */
  768.     }
  769.     if (a7 == myctlq)        /* Always prefix the control prefix */
  770.       xxcq = myctlq;
  771.  
  772.     if ((rptflg) && (a7 == rptq))    /* If it's the repeat prefix, */
  773.       xxcq = myctlq;        /* prefix it if doing repeat counts */
  774.  
  775.     if ((ebqflg) && (a7 == ebq))    /* Prefix the 8th-bit prefix */
  776.       xxcq = myctlq;        /* if doing 8th-bit prefixes */
  777.  
  778. /* Now construct the entire sequence */
  779.  
  780.     if (xxls) { *dp++ = myctlq; *dp++ = xxls; } /* Locking shift */
  781.     odp2 = dp;                    /* (Save this place) */
  782.     if (xxdl) { *dp++ = myctlq; *dp++ = xxdl; } /* Datalink escape */
  783.     if (xxrc) { *dp++ = rptq;   *dp++ = xxrc; } /* Repeat count */
  784.     if (xxss) { *dp++ = ebq; }            /* Single shift */
  785.     if (xxcq) { *dp++ = myctlq; }                /* Control prefix */
  786.     *dp++ = rt;            /* Finally, the character itself */
  787.  
  788.     if (rpt == 1) {            /* Exactly two copies? */
  789.         rpt = 0;
  790.         p2 = dp;            /* Save place temporarily */
  791.         for (p1 = odp2; p1 < p2; p1++) /* Copy the old chars over again */
  792.           *dp++ = *p1;
  793.         if ((p2-data) <= bufmax) odp = p2; /* Check packet bounds */
  794.     }
  795.     rt = rnext;            /* Next character is now current. */
  796.  
  797. /* Done encoding the character.  Now take care of packet buffer overflow. */
  798.  
  799.     if ((dp-data) >= bufmax) {    /* If too big, save some for next. */
  800.         size = (dp-data);        /* Calculate the size. */
  801.         *dp = '\0';            /* Mark the end. */
  802.         if ((dp-data) > bufmax) {    /* if packet is overfull */
  803.         /* copy the part that doesn't fit into the leftover buffer, */
  804.         /* taking care not to split a prefixed sequence. */
  805.         for (p1 = leftover, p2=odp; (*p1 = *p2) != '\0'; p1++,p2++)
  806.             ;
  807.         debug(F111,"getpkt leftover",leftover,size);
  808.         debug(F101," osize","",(odp-data));
  809.         size = (odp-data);    /* Return truncated packet. */
  810.         *odp = '\0';        /* Mark the new end */
  811.         }
  812.         t = rt; next = rnext;    /* save for next time */
  813.         return(size);
  814.     }
  815.     }                    /* Otherwise, keep filling. */
  816.  
  817.     size = (dp-data);            /* End of file */
  818.     *dp = '\0';                /* Mark the end of the data. */
  819.     debug(F111,"getpkt eof/eot",data,size); /* Fell thru before packet full, */
  820.     return(size);             /* return partially filled last packet. */
  821. }
  822.  
  823. /*  T I N I T  --  Initialize a transaction  */
  824.  
  825. int
  826. tinit() {
  827.     int x;
  828.  
  829. #ifndef NOCSETS
  830.     if (tcharset == TC_TRANSP) {    /* Character set translation */
  831.     rx = sx = NULL;            /* Transparent, no translation */
  832. #ifdef KANJI
  833.     } else if (tcharset == TC_JEUC) {
  834.     rx = sx = NULL;            /* Transparent, no translation */      
  835. #endif /* KANJI */
  836.     } else {                /* otherwise */
  837.     rx = xlr[tcharset][fcharset];    /* Input translation function */
  838.     sx = xls[tcharset][fcharset];    /* Output translation function */
  839.     }
  840.     debug(F101,"tinit tcharset","",tcharset);
  841.     debug(F101,"tinit fcharset","",fcharset);
  842. #ifdef COMMENT
  843.     debug(F101,"tinit sx   ","",sx);
  844.     debug(F101,"tinit rx   ","",rx);
  845. #endif /* COMMENT */
  846. #endif /* NOCSETS */
  847.     myinit[0] = '\0';            /* Haven't sent init string yet */
  848.     autopar = 0;            /* Automatic parity detection flag */
  849.     retrans = 0;            /* Packet retransmission count */
  850.     sndtyp = 0;                /* No previous packet */
  851.     xflg = 0;                /* Reset x-packet flag */
  852.     rqf = -1;                /* Reset 8th-bit-quote request flag */
  853.     memstr = 0;                /* Reset memory-string flag */
  854.     memptr = NULL;            /*  and pointer */
  855.     bctu = bctl = 1;            /* Reset block check type to 1 */
  856.     ebq = MYEBQ;            /* Reset 8th-bit quoting stuff */
  857.     ebqflg = 0;
  858.     if (savmod) {            /* If global file mode was saved, */
  859.         binary = savmod;        /*  restore it, */
  860.     savmod = 0;            /*  unsave it. */
  861.     }
  862.     pktnum = 0;                /* Initial packet number */
  863.     cxseen = czseen = discard = 0;    /* Reset interrupt flags */
  864.     *filnam = '\0';            /* Clear file name */
  865.     spktl = 0;                /* And its length */
  866.     nakstate = 0;            /* Assume not in a NAK'ing state */
  867.     numerrs = 0;            /* Transmission error counter */
  868.     if (server)             /* If acting as server, */
  869.       timint = srvtim;            /* Use server timeout interval. */
  870.     else                /* Otherwise */
  871.       timint = chktimo(rtimo,timef);    /* Begin by using local value */
  872.     spsiz = spsizr;            /* Initial send-packet size */
  873.     wslots = 1;                /* One window slot */
  874.     wslotn = 1;                /* No window negotiated yet */
  875.     winlo = 0;                /* Packet 0 is at window-low */
  876.     x = mksbuf(1);            /* Make a 1-slot send-packet buffer */
  877.     if (x < 0) return(x);
  878.     x = getsbuf(0);            /* Allocate first send-buffer. */
  879.     debug(F101,"tinit getsbuf","",x);
  880.     if (x < 0) return(x);
  881.     dumpsbuf();
  882.     x = mkrbuf(wslots);            /* & a 1-slot receive-packet buffer. */
  883.     if (x < 0) return(x);
  884.     what = W_NOTHING;            /* Doing nothing so far... */
  885.     lsstate = 0;            /* Initialize locking shift state */
  886.     return(0);
  887. }
  888.  
  889. VOID
  890. pktinit() {                /* Initialize packet sequence */
  891.     pktnum = 0;                /* number & window low. */
  892.     winlo = 0;
  893. }
  894.  
  895. /*  R I N I T  --  Respond to S or I packet  */
  896.  
  897. VOID
  898. rinit(d) CHAR *d; {
  899.     char *tp;
  900.     ztime(&tp);
  901.     tlog(F110,"Transaction begins",tp,0L); /* Make transaction log entry */
  902.     if (binary)
  903.       tlog(F100,"Global file mode = binary","",0L);
  904.     else
  905.       tlog(F100,"Global file mode = text","",0L);
  906.     filcnt = 0;                /* Init file counter */
  907.     spar(d);
  908.     ack1(rpar());
  909. #ifdef datageneral
  910.     if ((local) && (!quiet))            /* Only do this if local & not quiet */
  911.         consta_mt();                    /* Start the asynch read task */
  912. #endif /* datageneral */
  913. }
  914.  
  915.  
  916. /*  R E S E T C  --  Reset per-transaction character counters */
  917.  
  918. VOID
  919. resetc() {
  920.     rptn = 0;                /* Repeat counts */
  921.     fsecs = flci = flco = 0L;        /* File chars in and out */
  922.     tfc = tlci = tlco = 0L;        /* Total file, line chars in & out */
  923. #ifdef COMMENT
  924.     fsize = -1L;            /* File size */
  925. #else
  926.     if (what != W_SEND)
  927.       fsize = -1L;
  928.     debug(F101,"resetc fsize","",fsize);
  929. #endif /* COMMENT */
  930.     timeouts = retrans = 0;        /* Timeouts, retransmissions */
  931.     spackets = rpackets = 0;        /* Packet counts out & in */
  932.     crunched = 0;            /* Crunched packets */
  933.     wmax = 1;                /* Maximum window size used */
  934. }
  935.  
  936. /*  S I N I T  --  Get & verify first file name, then send Send-Init packet */
  937. /*
  938.  Returns:
  939.    1 if send operation begins successfully
  940.    0 if send operation fails
  941. */
  942. #ifdef DYNAMIC
  943. char *cmargbuf = NULL;
  944. #else
  945. char cmargbuf[256];
  946. #endif /* DYNAMIC */
  947. char *cmargp[2];
  948.  
  949. int
  950. sinit() {
  951.     int x;                /* Worker int */
  952.     char *tp, *xp, *m;            /* Worker string pointers */
  953.  
  954.     filcnt = 0;                /* Initialize file counter */
  955.     sndsrc = nfils;            /* Source for filenames */
  956. #ifdef DYNAMIC
  957.     if (!cmargbuf && !(cmargbuf = malloc(256)))
  958.     fatal("sinit: no memory for cmargbuf");
  959. #endif /* DYNAMIC */
  960.     cmargbuf[0] = NUL;            /* Initialize name buffer */
  961.  
  962.     debug(F101,"sinit nfils","",nfils);
  963.     debug(F110,"sinit cmarg",cmarg,0);
  964.     debug(F110,"sinit cmarg2",cmarg2,0);
  965.     if (nfils == 0) {            /* Sending from stdin or memory. */
  966.     if ((cmarg2 != NULL) && (*cmarg2)) {
  967.         cmarg = cmarg2;        /* If F packet, "as-name" is used */
  968.         cmarg2 = "";        /* if provided */
  969.     } else cmarg = "stdin";        /* otherwise just use "stdin" */
  970.     strcpy(cmargbuf,cmarg);
  971.     cmargp[0] = cmargbuf;
  972.     cmargp[1] = "";
  973.     cmlist = cmargp;
  974.     nfils = 1;
  975.     }
  976. #ifdef COMMENT
  977.     if (nfils < 1) {            /* Filespec pointed to by cmarg */
  978.     if (nfils < 0) sndsrc = 1;
  979.     nfils = 1;            /* Change it to cmlist */
  980.     strcpy(cmargbuf,cmarg);        /* so we have a consistent way */
  981.     cmargp[0] = cmargbuf;        /* of going thru the file list. */
  982.     cmargp[1] = "";
  983.     cmlist = cmargp;
  984.     }
  985.  
  986. /* At this point, cmlist contains the list of filespecs to send */
  987.  
  988.     debug(F111,"sinit *cmlist",*cmlist,nfils);
  989.  
  990.     xp = *cmlist;            /* Save this for messages */
  991. #else
  992.     xp = (nfils < 0) ? cmarg : *cmlist;
  993. #endif
  994.  
  995.     x = gnfile();            /* Get first filename. */
  996.     m = NULL;                /* Error message pointer */
  997.     debug(F101,"sinit gnfil","",x);
  998.     switch (x) {
  999.       case -5: m = "Too many files match wildcard"; break;
  1000.       case -4: m = "Cancelled"; break;
  1001.       case -3: m = "Read access denied"; break;
  1002.       case -2: m = "File is not readable"; break;
  1003.       case -1: m = iswild(filnam) ? "No files match" : "File not found";
  1004.     break;
  1005.       case  0: m = "No filespec given!" ; break;
  1006.       default:
  1007.     break;
  1008.     }
  1009.     debug(F101,"sinit nfils","",nfils);
  1010.     debug(F110,"sinit filnam",filnam,0);
  1011.     debug(F110,"sinit cmdstr",cmdstr,0);
  1012.     if (x < 1) {            /* Didn't get a file. */
  1013.     if (server)            /* Doing GET command */
  1014.       errpkt((CHAR *)m);        /* so send Error packet. */
  1015.     else                /* Doing SEND command */
  1016.       screen(SCR_EM,0,0l,m);    /* so print message. */
  1017.     tlog(F110,xp,m,0L);        /* Make transaction log entry. */
  1018.     freerbuf(rseqtbl[0]);        /* Free the buffer the GET came in. */
  1019.     return(0);            /* Return failure code */
  1020.     }
  1021.     if (!local && !server) sleep(delay); /* Delay if requested */
  1022. #ifdef datageneral
  1023.     if ((local) && (!quiet))            /* Only do this if local & not quiet */
  1024.         consta_mt();                    /* Start the asynch read task */
  1025. #endif /* datageneral */
  1026.     freerbuf(rseqtbl[0]);        /* Free the buffer the GET came in. */
  1027.     sipkt('S');                /* Send the Send-Init packet. */
  1028.     ztime(&tp);                /* Get current date/time */
  1029.     tlog(F110,"Transaction begins",tp,0L); /* Make transaction log entry */
  1030.     debug(F111,"sinit ok",filnam,0);
  1031.     return(1);
  1032. }
  1033.  
  1034. int
  1035. #ifdef CK_ANSIC
  1036. sipkt(char c)                /* Send S or I packet. */
  1037. #else
  1038. sipkt(c) char c;
  1039. #endif
  1040. /* sipkt */ {
  1041.     CHAR *rp; int k;
  1042.     debug(F101,"sipkt pktnum","",pktnum);
  1043.     k = sseqtbl[pktnum];        /* Find slot for this packet */
  1044.     debug(F101,"sipkt k","",k);
  1045.     if (k < 0) {            /* No slot? */
  1046.     k = getsbuf(winlo = pktnum);    /* Make one. */
  1047.     debug(F101,"sipkt getsbuf","",k);    
  1048.     }
  1049.     ttflui();                /* Flush pending input. */
  1050.     rp = rpar();            /* Get protocol parameters. */
  1051.     return(spack(c,pktnum,(int)strlen((char *)rp),rp)); /* Send them. */
  1052. }
  1053.  
  1054. /*  X S I N I T  --  Retransmit S-packet  */
  1055. /*
  1056.   For use in the GET-SEND sequence, when we start to send, but receive another
  1057.   copy of the GET command because the receiver didn't get our S packet.
  1058.   This retransmits the S packet and frees the receive buffer for the ACK.
  1059.   The only reason this special case is necessary is that packet number zero
  1060.   is being re-used.
  1061. */
  1062. VOID
  1063. xsinit() {
  1064.     int k;    
  1065.     k = rseqtbl[0];
  1066.     debug(F101,"xsinit k","",k);
  1067.     if (k > -1)
  1068.       freerbuf(k);
  1069.     resend(0);
  1070. }        
  1071.  
  1072. /*  R C V F I L -- Receive a file  */
  1073.  
  1074. /*
  1075.   Incoming filename is in data field of F packet.
  1076.   This function decodes it into the srvcmd buffer, substituting an
  1077.   alternate "as-name", if one was given.
  1078.   Then it does any requested transformations (like converting to
  1079.   lowercase), and finally if a file of the same name already exists, 
  1080.   takes the desired collision action.
  1081. */
  1082. #ifdef pdp11
  1083. #define XNAMLEN 256
  1084. #else
  1085. #define XNAMLEN 65
  1086. #endif /* pdp11 */
  1087.  
  1088. int
  1089. rcvfil(n) char *n; {
  1090.     char xname[XNAMLEN], *xp;        /* Buffer for constructing name */
  1091. #ifdef DTILDE
  1092.     char *dirp, *tilde_expand();
  1093. #endif /* DTILDE */
  1094.  
  1095.     lsstate = 0;            /* Cancel locking-shift state */
  1096.     srvptr = srvcmd;            /* Decode file name from packet. */
  1097.     decode(rdatap,putsrv,0);        /* Don't xlate charsets. */
  1098.     if (*srvcmd == '\0')        /* Watch out for null F packet. */
  1099.       strcpy((char *)srvcmd,"NONAME");
  1100. #ifdef DTILDE
  1101.     dirp = tilde_expand((char *)srvcmd); /* Expand tilde, if any. */
  1102.     if (*dirp != '\0') strcpy((char *)srvcmd,dirp);
  1103. #endif /* DTILDE */
  1104.     screen(SCR_FN,0,0l,(char *)srvcmd);    /* Put it on screen if local */
  1105.     debug(F110,"rcvfil",(char *)srvcmd,0); /* Debug log entry */
  1106.     debug(F101,"rcvfil cmarg2","",cmarg2);
  1107.     tlog(F110,"Receiving",(char *)srvcmd,0L); /* Transaction log entry */
  1108.     if (cmarg2 != NULL) {               /* Check for alternate name */
  1109.         if (*cmarg2 != '\0') {
  1110.             strcpy((char *)srvcmd,cmarg2); /* Got one, use it. */
  1111.         }
  1112.     } else cmarg2 = "";
  1113. /*
  1114.   NOTE: Much of this code should be moved to opena(), where the file is
  1115.   actually opened, AFTER we have received the Attribute packet(s).  That
  1116.   way, if the file is mail, or is being sent to the printer, we don't have
  1117.   to fuss with collision options, etc, but instead we just pipe the data
  1118.   straight into lpr or mail (in UNIX anyway), and then we can also have
  1119.   nice subject lines for mail messages by using whatever is in the file
  1120.   header packet data field, whether it's a legal filename or not.
  1121. */
  1122.     if ((int)strlen((char *)srvcmd) > XNAMLEN) /* Watch out for overflow */
  1123.       *(srvcmd + XNAMLEN - 1) = NUL;
  1124.  
  1125.     xp = xname;                /* OK to proceed. */
  1126.     if (fncnv && !*cmarg2)
  1127.       zrtol((char *)srvcmd,xp);        /* convert name to local form */
  1128.     else                /* otherwise, */
  1129.       strcpy(xname,(char *)srvcmd);    /* use it literally */
  1130.     cmarg2 = "";            /* Remove alternate name */
  1131.     debug(F110,"rcvfil as",xname,0);
  1132.  
  1133. #ifdef COMMENT                /* Old code... */
  1134.     if (warn) {                /* File collision avoidance? */
  1135.     if (zchki(xname) != -1) {    /* Yes, file exists? */
  1136.         znewn(xname,&xp);        /* Yes, make new name. */
  1137.         strcpy(xname,xp);
  1138.         debug(F110," exists, new name ",xname,0);
  1139.         }
  1140.     }
  1141. #endif /* COMMENT */
  1142.  
  1143. /* Filename collision action section. */
  1144.  
  1145.     if (
  1146. #ifdef UNIX
  1147.     strcmp(xname,"/dev/null") &&    /* It's not the null device? */
  1148. #endif /* UNIX */
  1149.     (zchki(xname) != -1)        /* File of same name exists? */
  1150.     ) {                
  1151.     debug(F111,"rcvfil exists",xname,fncact);
  1152.     switch (fncact) {        /* Yes, do what user said. */
  1153.       case XYFX_A:            /* Append */
  1154.         debug(F100,"rcvfil append","",0);
  1155.         break;
  1156.       case XYFX_Q:            /* Query (Ask) */
  1157.         break;            /* not yet implemented */
  1158.       case XYFX_B:            /* Backup (rename old file) */
  1159.         znewn(xname,&xp);        /* Get new unique name */
  1160.         debug(F110,"rcvfil backup",xname,0);
  1161.         debug(F110,"rcvfil backup",xp,0);
  1162.         if (zrename(xname,xp) < 0) {
  1163.         debug(F110,"rcvfil rename fails",xname,0);
  1164.         return(0);
  1165.         }
  1166.         break;
  1167.       case XYFX_D:            /* Discard (refuse new file) */
  1168.         discard = 1;
  1169.         debug(F101,"rcvfil discard","",discard);
  1170.         break;            /* not yet implemented */
  1171.       case XYFX_R:            /* Rename new file */
  1172.         znewn(xname,&xp);        /* Make new name. */
  1173.         strcpy(xname,xp);
  1174.         debug(F110,"rcvfil rename",xname,0);
  1175.       case XYFX_X:            /* Replace old file */
  1176.         debug(F100,"rcvfil overwrite","",0);
  1177.         break;
  1178.       case XYFX_U:            /* Refuse if older */
  1179.         debug(F100,"rcvfil update","",0);
  1180.         break;            /* Not here, we don't have */
  1181.                     /* the attribute packet yet. */
  1182.       default:
  1183.         debug(F101,"rcvfil bad collision action","",fncact);
  1184.         break;
  1185.     }
  1186.     }
  1187.     debug(F110,"rcvfil: xname",xname,0);
  1188.     screen(SCR_AN,0,0l,xname);        /* Display it */
  1189.     strcpy(n,xname);            /* Return pointer to actual name. */
  1190.  
  1191. #ifndef NOICP
  1192. #ifndef MAC
  1193. /* Why not Mac? */
  1194.     strcpy(fspec,xname);        /* Here too for \v(filespec) */
  1195. #endif /* MAC */
  1196. #endif /* NOICP */
  1197.     debug(F110,"rcvfil: n",n,0);
  1198.     ffc = 0L;                /* Init per-file counters */
  1199.     fsecs = gtimer();            /* Time this file started */
  1200.     filcnt++;
  1201.     intmsg(filcnt);
  1202.     return(1);                /* Always succeeds */
  1203. }
  1204.  
  1205.  
  1206. /*  R E O F  --  Receive End Of File packet for incoming file */
  1207.  
  1208. /*
  1209.   Closes the received file.
  1210.   Returns:
  1211.     0 on success.
  1212.    -1 if file could not be closed.
  1213.     2 if disposition was mail, mail was sent, but temp file not deleted.
  1214.     3 if disposition was print, file was printed, but not deleted.
  1215.    -2 if disposition was mail and mail could not be sent
  1216.    -3 if disposition was print and file could not be printed
  1217. */
  1218. int
  1219. reof(f,yy) char *f; struct zattr *yy; {
  1220.     int x;
  1221.     char *p;
  1222.     char c;
  1223.  
  1224.     debug(F111,"reof fncact",f,fncact);
  1225.     debug(F101,"reof discard","",discard);
  1226.     success = 1;            /* Assume status is OK */
  1227.     lsstate = 0;            /* Cancel locking-shift state */
  1228.     if (
  1229. #ifdef COMMENT
  1230. /*
  1231.   If the discard flag is set, for whatever reason, we discard it, right?
  1232. */
  1233.     (fncact == XYFX_D || fncact == XYFX_U) &&
  1234. #endif /* COMMENT */
  1235.     discard != 0) {       /* SET FILE COLLISION DISCARD or UPDATE */
  1236.  
  1237.     debug(F101,"reof discarding","",0);
  1238.     discard = 0;            /* We never opened it, */
  1239.     return(0);            /* so we won't close it. */
  1240.     }
  1241.     if (cxseen == 0) cxseen = (*rdatap == 'D');    /* Got cancel directive? */
  1242.     success = (cxseen || czseen) ? 0 : 1; /* Set SUCCESS flag appropriately */
  1243.     x = clsof(cxseen || czseen);    /* Close the file (resets cxseen) */
  1244.     if (x < 0) success = 0;        /* If failure to close, FAIL */
  1245.     if (atcapu) zstime(f,yy,0);        /* Set file creation date */
  1246.  
  1247. /* Handle dispositions from attribute packet... */
  1248.  
  1249. #ifndef NOFRILLS
  1250.     if (yy->disp.len != 0) {
  1251.     p = yy->disp.val;
  1252.     c = *p++;
  1253.     if (c == 'M') {            /* Mail to user. */
  1254.         x = zmail(p,filnam);    /* Do the system's mail command */
  1255.         if (x < 0) success = 0;    /* Remember status */
  1256.         tlog(F110,"mailed",filnam,0L);
  1257.         tlog(F110," to",p,0L);
  1258.         zdelet(filnam);        /* Delete the file */
  1259.     } else if (c == 'P') {        /* Print the file. */
  1260.         x = zprint(p,filnam);    /* Do the system's print command */
  1261.         if (x < 0) success = 0;    /* Remember status */
  1262.         tlog(F110,"printed",filnam,0L);
  1263.         tlog(F110," with options",p,0L);
  1264. #ifndef VMS
  1265.         if (zdelet(filnam) && x == 0) x = 3; /* Delete the file */
  1266. #endif /* VMS */
  1267.     }
  1268.     }
  1269. #endif /* NOFRILLS */
  1270.     debug(F101,"reof returns","",x);
  1271.     *filnam = '\0';
  1272.     return(x);
  1273. }
  1274.  
  1275. /*  R E O T  --  Receive End Of Transaction  */
  1276.  
  1277. VOID
  1278. reot() {
  1279.     cxseen = czseen = discard = 0;    /* Reset interruption flags */
  1280.     tstats();
  1281. }
  1282.  
  1283. /*  S F I L E -- Send File header or teXt header packet  */
  1284.  
  1285. /*  Call with x nonzero for X packet, zero for F packet  */
  1286. /*  Returns 1 on success, 0 on failure                   */
  1287.  
  1288. int
  1289. sfile(x) int x; {
  1290. #ifdef pdp11
  1291. #define PKTNL 64
  1292. #else
  1293. #define PKTNL 256
  1294. #endif /* pdp11 */
  1295.     char pktnam[PKTNL+1];        /* Local copy of name */
  1296.     char *s;
  1297.  
  1298.     lsstate = 0;            /* Cancel locking-shift state */
  1299.     if (nxtpkt() < 0) return(0);    /* Bump packet number, get buffer */
  1300.     if (x == 0) {            /* F-Packet setup */
  1301.  
  1302.         if (*cmarg2 != '\0') {        /* If we have a send-as name, */
  1303.         strncpy(pktnam,cmarg2,PKTNL); /* copy it literally, */
  1304.         cmarg2 = "";        /* and blank it out for next time. */
  1305.         } else {            /* Otherwise use actual file name: */
  1306.         if (fncnv) {        /* If converting names, */
  1307.             zltor(filnam,pktnam);    /* convert it to common form, */
  1308.         } else {            /* otherwise, */
  1309.             strncpy(pktnam,filnam,PKTNL); /* copy it literally. */
  1310.             }
  1311.         }
  1312.         debug(F110,"sfile",filnam,0);    /* Log debugging info */
  1313.         debug(F110," pktnam",pktnam,0);
  1314.         if (openi(filnam) == 0)     /* Try to open the file */
  1315.       return(0);         
  1316.         s = pktnam;            /* Name for packet data field */
  1317.  
  1318.     } else {                /* X-packet setup */
  1319.  
  1320.         debug(F110,"sxpack",cmdstr,0);    /* Log debugging info */
  1321.         s = cmdstr;            /* Name for data field */
  1322.     }
  1323.  
  1324.     encstr((CHAR *)s);            /* Encode the name into encbuf[]. */
  1325.                     /* Send the F or X packet */
  1326.     spack((char) (x ? 'X' : 'F'), pktnum, size, encbuf+7);
  1327.  
  1328.     if (x == 0) {            /* Display for F packet */
  1329.         if (displa) {            /* Screen */
  1330.         screen(SCR_FN,'F',(long)pktnum,filnam);
  1331.         screen(SCR_AN,0,0l,pktnam);
  1332.         screen(SCR_FS,0,fsize,"");
  1333.         }
  1334.         tlog(F110,"Sending",filnam,0L);    /* Transaction log entry */
  1335.         tlog(F110," as",pktnam,0L);
  1336.     if (binary) {            /* Log file mode in transaction log */
  1337.         tlog(F101," mode: binary","",(long) binary);
  1338.     } else {            /* If text mode, check character set */
  1339.         tlog(F100," mode: text","",0L);
  1340. #ifndef NOCSETS
  1341.         tlog(F110," file character set",fcsinfo[fcharset].name,0L);
  1342.         if (tcharset == TC_TRANSP)
  1343.           tlog(F110," xfer character set","transparent",0L);
  1344.         else
  1345.           tlog(F110," xfer character set",tcsinfo[tcharset].name,0L);
  1346. #endif /* NOCSETS */
  1347.     }
  1348.     } else {                /* Display for X-packet */
  1349.  
  1350.         screen(SCR_XD,'X',(long)pktnum,cmdstr);    /* Screen */
  1351.         tlog(F110,"Sending from:",cmdstr,0L);    /* Transaction log */
  1352.     }
  1353.     intmsg(++filcnt);            /* Count file, give interrupt msg */
  1354.     first = 1;                /* Init file character lookahead. */
  1355.     ffc = 0L;                /* Init file character counter. */
  1356.     fsecs = gtimer();            /* Time this file started */
  1357.     debug(F101,"SFILE fsecs","",fsecs);
  1358.     return(1);
  1359. }
  1360.  
  1361. /*  S D A T A -- Send a data packet */
  1362.  
  1363. /*
  1364.   Returns -1 if no data to send (end of file).  If there is data, a data
  1365.   packet is sent, and sdata() returns 1.
  1366.  
  1367.   For window size greater than 1, keep sending data packets until window
  1368.   is full or characters start to appear from the other Kermit, whichever
  1369.   happens first.
  1370.  
  1371.   In the windowing case, when there is no more data left to send (or when
  1372.   sending has been interrupted), sdata() does nothing and returns 0 each time
  1373.   it is called until the current packet number catches up to the last data
  1374.   packet that was sent.
  1375. */
  1376.  
  1377. int
  1378. sdata() {
  1379.     int i, x, len;
  1380.     
  1381.     debug(F101,"sdata entry, first","",first);
  1382.     debug(F101," drain","",drain);
  1383.  
  1384. /* The "drain" flag is used with window size > 1.  It means we have sent  */
  1385. /* our last data packet.  If called and drain is not zero, then we return */
  1386. /* 0 as if we had sent an empty data packet, until all data packets have  */
  1387. /* been ACK'd, then then we can finally return -1 indicating EOF, so that */
  1388. /* the protocol can switch to seof state.  This is a kludge, but at least */
  1389. /* it's localized...  */
  1390.  
  1391.     if (first == 1) drain = 0;        /* Start of file, init drain flag. */
  1392.  
  1393.     if (drain) {            /* If draining... */
  1394.     debug(F101,"sdata draining, winlo","",winlo);
  1395.     if (winlo == pktnum)        /* If all data packets are ACK'd */
  1396.       return(-1);            /* return EOF indication */
  1397.     else                /* otherwise */
  1398.       return(0);            /* pretend we sent a data packet. */
  1399.     }
  1400.     debug(F101,"sdata sbufnum","",sbufnum);
  1401.     for (i = sbufnum; i > 0; i--) {
  1402.         debug(F101,"sdata countdown","",i);
  1403.     x = nxtpkt();            /* Get next pkt number and buffer */
  1404.     debug(F101,"sdata packet","",pktnum);
  1405.     if (x < 0) return(0);
  1406. /***    dumpsbuf(); */
  1407.     if (cxseen || czseen) {        /* If interrupted, done. */
  1408.         if (wslots > 1) {
  1409.         drain = 1;
  1410.         debug(F101,"sdata cx/zseen, drain","",cxseen);
  1411.         return(0);
  1412.         } else {
  1413.         return(-1);
  1414.         }
  1415.     }
  1416. #ifdef COMMENT
  1417.     if (spsiz > 94)            /* Fill the packet's data buffer */
  1418.       len = getpkt(spsiz-bctl-6,1);    /* long packet */
  1419.     else                /*  or */
  1420.       len = getpkt(spsiz-bctl-3,1);    /* short packet */
  1421. #else
  1422.     len = getpkt(spsiz,1);
  1423. #endif /* COMMENT */
  1424.     if (len == 0) {            /* Done if no data. */
  1425.         if (pktnum == winlo) return(-1);
  1426.         drain = 1;            /* But can't return -1 until all */
  1427.         debug(F101,"sdata eof, drain","",drain);
  1428.         return(0);            /* ACKs are drained. */
  1429.     }
  1430.     spack('D',pktnum,len,data);    /* Send the data packet. */
  1431.     x = ttchk();            /* Peek at input buffer. */
  1432.     debug(F101,"sdata ttchk","",x);    /* ACKs waiting, maybe?  */
  1433.     if (x) return(1);        /* Yes, stop sending data packets */
  1434.     }                    /* and go try to read the ACKs. */
  1435.     return(1);
  1436. }
  1437.  
  1438.  
  1439. /*  S E O F -- Send an End-Of-File packet */
  1440.  
  1441. /*  Call with a string pointer to character to put in the data field, */
  1442. /*  or else a null pointer or "" for no data.  */
  1443.  
  1444. /*
  1445.   There are two "send-eof" functions.  seof() is used to send the normal eof
  1446.   packet at the end of a file's data (even if the file has no data), or when
  1447.   a file transfer is interrupted.  sxeof() is used to send an EOF packet that
  1448.   occurs because of attribute refusal.  The difference is purely a matter of
  1449.   buffer allocation and packet sequence number management.  Both functions
  1450.   act as "front ends" to the common send-eof function, szeof().
  1451. */
  1452.  
  1453. /* Code common to both seof() and sxeof() */
  1454.  
  1455. int
  1456. szeof(s) CHAR *s; {
  1457.     lsstate = 0;            /* Cancel locking-shift state */
  1458.     if ((s != NULL) && (*s != '\0')) {
  1459.     spack('Z',pktnum,1,s);
  1460.     tlog(F100," *** interrupted, sending discard request","",0L);
  1461.     } else {
  1462.     spack('Z',pktnum,0,(CHAR *)"");
  1463.     }
  1464.     discard = 0;            /* Turn off per-file discard flag */
  1465.     return(0);
  1466. }
  1467.  
  1468. int
  1469. seof(s) CHAR *s; {
  1470.  
  1471. /*
  1472.   ckcpro.w, before calling seof(), sets window size back to 1 and then calls
  1473.   window(), which clears out the old buffers.  This is OK because the final
  1474.   data packet for the file has been ACK'd.  However, sdata() has already
  1475.   called nxtpkt(), which set the new value of pktnum which seof() will use.
  1476.   So all we need to do here is is allocate a new send-buffer.
  1477. */
  1478.     if (getsbuf(pktnum) < 0) {    /* Get a buffer for packet n */
  1479.     debug(F101,"seof can't get s-buffer","",pktnum);
  1480.     return(-1);
  1481.     }
  1482.     return(szeof(s));
  1483. }
  1484.  
  1485. /*
  1486.   Version of seof() to be called when sdata() has not been called before.  The
  1487.   difference is that this version calls nxtpkt() to allocate a send-buffer and
  1488.   get the next packet number.
  1489. */
  1490. int
  1491. sxeof(s) CHAR *s; {
  1492.     int x;
  1493.     x = nxtpkt();            /* Get next pkt number and buffer */
  1494.     if (x < 0)
  1495.       debug(F101,"sxeof nxtpkt fails","",pktnum);
  1496.     else
  1497.       debug(F101,"sxeof packet","",pktnum);
  1498.     return(szeof(s));
  1499. }
  1500.  
  1501. /*  S E O T -- Send an End-Of-Transaction packet */
  1502.  
  1503. int
  1504. seot() {
  1505.     if (nxtpkt() < 0) return(-1);    /* Bump packet number, get buffer */
  1506.     spack('B',pktnum,0,(CHAR *)"");    /* Send the EOT packet */
  1507.     cxseen = czseen = discard = 0;    /* Reset interruption flags */
  1508.     tstats();                /* Log timing info */
  1509.     return(0);
  1510. }
  1511.  
  1512. /*   R P A R -- Fill the data array with my send-init parameters  */
  1513.  
  1514.  
  1515. CHAR dada[20];                /* Use this instead of data[]. */
  1516.                     /* To avoid some kind of wierd */
  1517.                     /* addressing foulup in spack()... */
  1518.                     /* (which might be fixed now...) */
  1519.  
  1520. CHAR *
  1521. rpar() {
  1522.     if (rpsiz > MAXPACK)        /* Biggest normal packet I want. */
  1523.       dada[0] = tochar(MAXPACK);    /* If > 94, use 94, but specify */
  1524.     else                /* extended packet length below... */
  1525.       dada[0] = tochar(rpsiz);        /* else use what the user said. */
  1526.     dada[1] = tochar(chktimo(pkttim,0)); /* When I want to be timed out */
  1527.     dada[2] = tochar(mypadn);        /* How much padding I need (none) */
  1528.     dada[3] = ctl(mypadc);        /* Padding character I want */
  1529.     dada[4] = tochar(eol);        /* End-Of-Line character I want */
  1530.     dada[5] = '#';            /* Control-Quote character I send */
  1531.     switch (rqf) {            /* 8th-bit prefix */
  1532.     case -1:
  1533.     case  1: if (parity) ebq = sq = '&'; break;
  1534.     case  0:
  1535.     case  2: break;
  1536.     }
  1537.     debug(F000,"rpar 8bq sq","",sq);
  1538.     debug(F000,"rpar 8bq ebq","",ebq);
  1539.     if (lscapu == 2)            /* LOCKING-SHIFT FORCED */
  1540.       dada[6] = 'N';            /* means no single-shift */
  1541.     else
  1542.       dada[6] = sq;
  1543.     dada[7] = (bctr == 4) ? 'B' : bctr + '0'; /* Block check type */
  1544.     if (rptflg)                /* Run length encoding */
  1545.         dada[8] = rptq;            /* If receiving, agree. */
  1546.     else
  1547.         dada[8] = '~';         
  1548.     /* CAPAS mask */
  1549.     dada[9] = tochar((lscapr ? lscapb : 0) | /* Locking shifts */
  1550.              (atcapr ? atcapb : 0) | /* Attribute packets */
  1551.              (lpcapr ? lpcapb : 0) | /* Long packets */
  1552.              (swcapr ? swcapb : 0)); /* Sliding windows */
  1553.     dada[10] = tochar(swcapr ? wslotr : 1);  /* Window size */
  1554.     rpsiz = urpsiz - 1;            /* Long packets ... */
  1555.     dada[11] = tochar(rpsiz / 95);    /* Long packet size, big part */
  1556.     dada[12] = tochar(rpsiz % 95);    /* Long packet size, little part */
  1557.     dada[13] = '\0';            /* Terminate the init string */
  1558. #ifdef DEBUG
  1559.     if (deblog) {
  1560.     debug(F110,"rpar",dada,0);
  1561.     rdebu(dada,(int)strlen((char *)dada));
  1562.     }
  1563. #endif /* DEBUG */
  1564.     strcpy((char *)myinit,(char *)dada);
  1565.     return(dada);            /* Return pointer to string. */
  1566. }
  1567.  
  1568. int
  1569. spar(s) CHAR *s; {            /* Set parameters */
  1570.     int x, y, lpsiz;
  1571.  
  1572.     debug(F110,"entering spar",s,0);
  1573.  
  1574.     s--;                /* Line up with field numbers. */
  1575.  
  1576. /* Limit on size of outbound packets */
  1577.     x = (rln >= 1) ? xunchar(s[1]) : 80;
  1578.     lpsiz = spsizr;            /* Remember what they SET. */
  1579.     if (spsizf) {            /* SET-command override? */
  1580.     if (x < spsizr) spsiz = x;    /* Ignore LEN unless smaller */
  1581.     } else {                /* otherwise */
  1582.     spsiz = (x < 10) ? 80 : x;    /* believe them if reasonable */
  1583.     }
  1584.     spmax = spsiz;            /* Remember maximum size */
  1585.  
  1586. /* Timeout on inbound packets */
  1587.     if (timef) {
  1588.     timint = rtimo;            /* SET SEND TIMEOUT value overrides */
  1589.     } else {                /* Otherwise use requested value, */
  1590.     x = (rln >= 2) ? xunchar(s[2]) : rtimo; /* if it is legal. */
  1591.     timint = (x < 0) ? rtimo : x;
  1592.     }
  1593.     timint = chktimo(timint,timef);    /* Adjust if necessary */
  1594.  
  1595. /* Outbound Padding */
  1596.     npad = 0; padch = '\0';
  1597.     if (rln >= 3) {
  1598.     npad = xunchar(s[3]);
  1599.     if (rln >= 4) padch = ctl(s[4]); else padch = 0;
  1600.     }
  1601.     if (npad) {
  1602.     int i;
  1603.     for (i = 0; i < npad; i++) padbuf[i] = dopar(padch);
  1604.     }
  1605.  
  1606. /* Outbound Packet Terminator */
  1607.     seol = (rln >= 5) ? xunchar(s[5]) : CR;
  1608.     if ((seol < 2) || (seol > 31)) seol = CR;
  1609.  
  1610. /* Control prefix */
  1611.     x = (rln >= 6) ? s[6] : '#';
  1612.     myctlq = ((x > 32 && x < 63) || (x > 95 && x < 127)) ? x : '#';
  1613.  
  1614. /* 8th-bit prefix */
  1615.     rq = (rln >= 7) ? s[7] : 0;
  1616.     if (rq == 'Y') rqf = 1;
  1617.       else if ((rq > 32 && rq < 63) || (rq > 95 && rq < 127)) rqf = 2;
  1618.         else rqf = 0;
  1619.     debug(F000,"spar 8bq rq","",rq);
  1620.     debug(F000,"spar 8bq sq","",sq);
  1621.     debug(F000,"spar 8bq ebq","",ebq);
  1622.     debug(F101,"spar 8bq rqf","",rqf);
  1623.     switch (rqf) {
  1624.     case 0: ebqflg = 0; break;
  1625.     case 1: if (parity) { ebqflg = 1; ebq = '&'; } break;
  1626.     case 2: if (ebqflg = (ebq == sq || sq == 'Y')) ebq = rq;
  1627.     }
  1628.     if (lscapu == 2) {     /* No single-shifts if LOCKING-SHIFT FORCED */
  1629.     ebqflg = 0;
  1630.     ebq = 'N';
  1631.     }
  1632.  
  1633. /* Block check */
  1634.     x = 1;
  1635.     if (rln >= 8) {
  1636.     if (s[8] == 'B') x = 4;
  1637.     else x = s[8] - '0';
  1638.     if ((x < 1) || (x > 4)) x = 1;
  1639.     }
  1640.     bctr = x;
  1641.  
  1642. /* Repeat prefix */
  1643.     if (rln >= 9) {
  1644.     rptq = s[9]; 
  1645.     rptflg = ((rptq > 32 && rptq < 63) || (rptq > 95 && rptq < 127));
  1646.     } else rptflg = 0;
  1647.  
  1648. /* Capabilities */
  1649.     atcapu = lpcapu = swcapu = 0;    /* Assume none of these */
  1650.     if (lscapu != 2) lscapu = 0;    /* Assume no LS unless forced. */
  1651.     y = 11;                /* Position of next field, if any */
  1652.     if (rln >= 10) {
  1653.         x = xunchar(s[10]);
  1654.     debug(F101,"spar capas","",x);
  1655.         atcapu = (x & atcapb) && atcapr;
  1656.     lpcapu = (x & lpcapb) && lpcapr;
  1657.     swcapu = (x & swcapb) && swcapr;
  1658.     debug(F101,"spar lscapu","",lscapu);
  1659.     debug(F101,"spar lscapr","",lscapr);
  1660.     debug(F101,"spar ebqflg","",ebqflg);
  1661.     if (lscapu != 2) lscapu = ((x & lscapb) && lscapr && ebqflg) ? 1 : 0;
  1662.     debug(F101,"spar swcapr","",swcapr);
  1663.     debug(F101,"spar swcapu","",swcapu);
  1664.     debug(F101,"spar lscapu","",lscapu);
  1665.     for (y = 10; (xunchar(s[y]) & 1) && (rln >= y); y++) ;
  1666.     debug(F101,"spar y","",y);
  1667.     }
  1668.  
  1669. /* Long Packets */
  1670.     debug(F101,"spar lpcapu","",lpcapu);
  1671.     if (lpcapu) {
  1672.         if (rln > y+1) {
  1673.         x = xunchar(s[y+2]) * 95 + xunchar(s[y+3]);
  1674.         debug(F101,"spar lp len","",x);
  1675.         if (spsizf) {        /* If overriding negotiations */
  1676.         spsiz = (x < lpsiz) ? x : lpsiz; /* do this, */
  1677.         } else {                     /* otherwise */
  1678.         spsiz = (x > MAXSP) ? MAXSP : x; /* do this. */
  1679.         }
  1680.         if (spsiz < 10) spsiz = 80;    /* Be defensive... */
  1681.     }
  1682.     }
  1683.     /* (PWP) save current send packet size for optimal packet size calcs */
  1684.     spmax = spsiz;
  1685.     debug(F101,"spar lp spmax","",spmax);
  1686.     timint = chktimo(timint,timef);    /* Recalculate the packet timeout! */
  1687.     
  1688. /* Sliding Windows... */
  1689.  
  1690.     if (swcapr) {            /* Only if requested... */
  1691.         if (rln > y) {            /* See what other Kermit says */
  1692.         x = xunchar(s[y+1]);
  1693.         debug(F101,"spar window","",x);
  1694.         wslotn = (x > MAXWS) ? MAXWS : x;
  1695. /*
  1696.   wslotn = negotiated size (from other Kermit's S or I packet).
  1697.   wslotr = requested window size (from this Kermit's SET WINDOW command).
  1698. */
  1699.         if (wslotn > wslotr)    /* Use the smaller of the two */
  1700.           wslotn = wslotr;
  1701.         if (wslotn < 1)        /* Watch out for bad negotiation */
  1702.           wslotn = 1;
  1703.         if (wslotn > 1)
  1704.           swcapu = 1; /* We do windows... */
  1705.         debug(F101,"spar window after adjustment","",x);
  1706.     } else {            /* No window size specified. */
  1707.         wslotn = 1;            /* We don't do windows... */
  1708.         debug(F101,"spar window","",x);
  1709.         swcapu = 0;
  1710.         debug(F101,"spar no windows","",wslotn);
  1711.     }
  1712.     }
  1713.  
  1714. /* Now recalculate packet length based on number of windows.   */
  1715. /* The nogotiated number of window slots will be allocated,    */
  1716. /* and the maximum packet length will be reduced if necessary, */
  1717. /* so that a windowful of packets can fit in the big buffer.   */
  1718.  
  1719.     if (wslotn > 1) {            /* Shrink to fit... */
  1720.     x = adjpkl(spsiz,wslotn,bigsbsiz);
  1721.     if (x < spsiz) {
  1722.         spsiz = spmax = x;
  1723.         debug(F101,"spar sending, redefine spsiz","",spsiz);
  1724.     }
  1725.     }
  1726.  
  1727. /* Record parameters in debug log */
  1728. #ifdef DEBUG
  1729.     if (deblog) sdebu(rln);
  1730. #endif /* DEBUG */
  1731.     numerrs = 0;            /* Start counting errors here. */
  1732.     return(0);
  1733. }
  1734.  
  1735. /*  G N F I L E  --  Get name of next file to send  */
  1736. /*
  1737.   Expects global sndsrc to be:
  1738.    -1: next filename to be obtained by calling znext().
  1739.     0: no next file name
  1740.     1: (or greater) next filename to be obtained from **cmlist.
  1741.   Returns:
  1742.     1, with name of next file in filnam.
  1743.     0, no more files, with filnam set to empty string.
  1744.    -1, file not found
  1745.    -2, file is not readable
  1746.    -3, read access denied
  1747.    -4, cancelled
  1748.    -5, too many files match wildcard
  1749. */
  1750.  
  1751. int
  1752. gnfile() {
  1753.     int x; long y;
  1754.     int retcode = 0;
  1755.  
  1756.     debug(F101,"gnfile sndsrc","",sndsrc);
  1757.     fsize = -1L;            /* Initialize file size */
  1758.     if (sndsrc == 0) {            /* It's not really a file */
  1759.     if (nfils > 0) {        /* It's a pipe, or stdin */
  1760.         strcpy(filnam, *cmlist);    /* Copy its "name" */
  1761.         nfils = 0;            /* There is no next file */
  1762.         return(1);            /* OK this time */
  1763.     } else return(0);        /* but not next time */
  1764.     }
  1765.  
  1766. /* If file group interruption (C-Z) occurred, fail.  */
  1767.  
  1768.     if (czseen) {
  1769.     tlog(F100,"Transaction cancelled","",0L);
  1770.         debug(F100,"gnfile czseen","",0);
  1771.     return(-4);
  1772.     }
  1773.  
  1774. /* Loop through file list till we find a readable, sendable file */
  1775.  
  1776.     y = -1L;                /* Loop exit (file size) variable */
  1777.     while (y < 0L) {            /* Keep trying till we get one... */
  1778.     if (sndsrc > 0) {        /* File list in cmlist */
  1779.         debug(F101,"gnfile nfils","",nfils);
  1780.         if (nfils-- > 0) {        /* Still some left? */
  1781.         strcpy(filnam,*cmlist++);
  1782.         debug(F111,"gnfile cmlist filnam",filnam,nfils);
  1783.         if (!clfils) {        /* Expand only if not from cmdline */
  1784.             x = zxpand(filnam);
  1785.             debug(F101,"gnfile zxpand","",x);
  1786.             if (x == 1) {
  1787.             znext(filnam);
  1788.             goto gotnam;
  1789.             }
  1790.             if (x == 0) {
  1791.             retcode = -1; /* None match */
  1792.             continue;
  1793.             }
  1794.             if (x < 0) return(-5); /* Too many to expand */
  1795.             sndsrc = -1;    /* Change send-source to znext() */
  1796.         }
  1797.         } else {            /* We're out of files. */
  1798.         debug(F101,"gnfile done","",nfils);
  1799.         *filnam = '\0';
  1800.         return(retcode);
  1801.         }
  1802.     }
  1803.  
  1804. /* Otherwise, step to next element of internal wildcard expansion list. */
  1805.  
  1806.     if (sndsrc < 0) {
  1807.         x = znext(filnam);
  1808.         debug(F111,"gnfile znext",filnam,x);
  1809.         if (x == 0) {        /* If no more, */
  1810.         sndsrc = 1;        /* go back to list */
  1811.         continue;
  1812.         }
  1813.     }
  1814.  
  1815. /* Get here with a filename. */
  1816.  
  1817. gotnam:
  1818.     if (sndsrc) {
  1819.         y = zchki(filnam);        /* Check if file readable */
  1820.         retcode = (int) y;        /* Possible return code */
  1821.         if (y == -1L) {        /* If not found */
  1822.         debug(F110,"gnfile skipping:",filnam,0);
  1823.         tlog(F111,filnam,"not sent, reason",(long)y);
  1824.         screen(SCR_ST,ST_SKIP,0l,filnam);
  1825.         continue;
  1826.         } else if (y < 0) {
  1827.         continue;
  1828.         } else {
  1829.         fsize = y;
  1830.         return(1);
  1831.         }
  1832.     } else return(1);        /* sndsrc is 0... */
  1833.     }
  1834.     *filnam = '\0';            /* Should never get here */
  1835.     return(0);
  1836. }
  1837.  
  1838.  
  1839. /*  S N D H L P  --  Routine to send builtin help  */
  1840.  
  1841. int
  1842. sndhlp() {
  1843. #ifndef NOSERVER
  1844.     nfils = 0;                /* No files, no lists. */
  1845.     xflg = 1;                /* Flag we must send X packet. */
  1846.     strcpy(cmdstr,"help text");        /* Data for X packet. */
  1847.     first = 1;                /* Init getchx lookahead */
  1848.     memstr = 1;                /* Just set the flag. */
  1849.     memptr = hlptxt;            /* And the pointer. */
  1850.     if (binary) {            /* If file mode is binary, */
  1851.     savmod = binary;        /*  remember to restore it later. */
  1852.     binary = 0;            /*  turn it back to text for this, */
  1853.     }
  1854.     return(sinit());
  1855. #else
  1856.     return(0);
  1857. #endif /* NOSERVER */
  1858. }
  1859.  
  1860. #ifdef OS2
  1861. /*  S N D S P A C E -- send disk space message  */
  1862. int
  1863. sndspace(int drive) {
  1864. #ifndef NOSERVER
  1865.     static char spctext[64];
  1866.     if (drive)
  1867.       sprintf(spctext, " Drive %c: %ldK free\n", drive, 
  1868.           zdskspace(drive - 'A' + 1) / 1024L);
  1869.     else
  1870.       sprintf(spctext, " Free space: %ldK\n", zdskspace(0)/1024L);
  1871.     nfils = 0;            /* No files, no lists. */
  1872.     xflg = 1;            /* Flag we must send X packet. */
  1873.     strcpy(cmdstr,"free space");/* Data for X packet. */
  1874.     first = 1;            /* Init getchx lookahead */
  1875.     memstr = 1;            /* Just set the flag. */
  1876.     memptr = spctext;        /* And the pointer. */
  1877.     if (binary) {        /* If file mode is binary, */
  1878.         savmod = binary;    /*  remember to restore it later. */
  1879.         binary = 0;        /*  turn it back to text for this, */
  1880.     }
  1881.     return(sinit());
  1882. #else
  1883.     return(0);
  1884. #endif /* NOSERVER */
  1885. }
  1886. #endif /* OS2 */
  1887.  
  1888. /*  C W D  --  Change current working directory  */
  1889.  
  1890. /*
  1891.  String passed has first byte as length of directory name, rest of string
  1892.  is name.  Fails if can't connect, else ACKs (with name) and succeeds. 
  1893. */
  1894.  
  1895. int
  1896. cwd(vdir) char *vdir; {
  1897.     char *cdd, *zgtdir(), *dirp;
  1898.  
  1899.     vdir[xunchar(*vdir) + 1] = '\0';    /* Terminate string with a null */
  1900.     dirp = vdir+1;
  1901.     tlog(F110,"Directory requested: ",dirp,0L);
  1902.     if (zchdir(dirp)) {        /* Try to change */
  1903.     cdd = zgtdir();        /* Get new working directory. */
  1904.     debug(F110,"cwd",cdd,0);
  1905.     encstr((CHAR *)cdd);
  1906.     ack1((CHAR *)(encbuf+7));
  1907.     tlog(F110,"Changed directory to",cdd,0L);
  1908.     return(1); 
  1909.     } else {
  1910.     debug(F110,"cwd failed",dirp,0);
  1911.     tlog(F110,"Failed to change directory to",dirp,0L);
  1912.     return(0);
  1913.     }
  1914. }
  1915.  
  1916.  
  1917. /*  S Y S C M D  --  Do a system command  */
  1918.  
  1919. /*  Command string is formed by concatenating the two arguments.  */
  1920.  
  1921. int
  1922. syscmd(prefix,suffix) char *prefix, *suffix; {
  1923.     char *cp;
  1924.  
  1925.     if (prefix == NULL || *prefix == '\0') return(0);
  1926.  
  1927.     for (cp = cmdstr; *prefix != '\0'; *cp++ = *prefix++) ;
  1928.     while (*cp++ = *suffix++) ;        /* copy suffix */
  1929.  
  1930.     debug(F110,"syscmd",cmdstr,0);
  1931.     if (zxcmd(ZIFILE,cmdstr) > 0) {
  1932.     debug(F110,"syscmd zxcmd ok",cmdstr,0);
  1933.     nfils = sndsrc = 0;        /* Flag that input is from stdin */
  1934.     xflg = hcflg = 1;        /* And special flags for pipe */
  1935.     if (binary) {            /* If file mode is binary, */
  1936.         savmod = binary;        /*  remember to restore it later. */
  1937.         binary = 0;            /*  turn it back to text for this, */
  1938.     }
  1939.     return (sinit());        /* Send S packet */
  1940.     } else {
  1941.     debug(F100,"syscmd zxcmd failed",cmdstr,0);
  1942.     return(0);
  1943.     }
  1944. }
  1945.  
  1946. /*  R E M S E T  --  Remote Set  */
  1947. /*  Called by server to set variables as commanded in REMOTE SET packets.  */
  1948. /*  Returns 1 on success, 0 on failure.  */
  1949.  
  1950. int
  1951. remset(s) char *s; {
  1952.     int len, i, x, y;
  1953.     char *p;
  1954.  
  1955.     len = xunchar(*s++);        /* Length of first field */
  1956.     p = s + len;            /* Pointer to second length field */
  1957.     *p++ = '\0';            /* Zero out second length field */
  1958.     x = atoi(s);            /* Value of first field */
  1959.     debug(F111,"remset",s,x);
  1960.     debug(F110,"remset",p,0);
  1961.     switch (x) {            /* Do the right thing */
  1962.       case 132:                /* Attributes (all, in) */
  1963.     atcapr = atoi(p);
  1964.     return(1);
  1965.       case 133:                /* File length attributes */
  1966.       case 233:                /* IN/OUT combined */
  1967.       case 148:                /* Both kinds of lengths */
  1968.       case 248:
  1969.     atleni = atleno = atoi(p);
  1970.     return(1);
  1971.       case 134:                /* File Type (text/binary) */
  1972.       case 234:
  1973.     attypi = attypo = atoi(p);
  1974.     return(1);
  1975.       case 135:                /* File creation date */
  1976.       case 235:
  1977.     atdati = atdato = atoi(p);
  1978.     return(1);
  1979.       case 139:                /* File Blocksize */
  1980.       case 239:
  1981.     atblki = atblko = atoi(p);
  1982.     return(1);
  1983.       case 141:                /* Encoding / Character Set */
  1984.       case 241:
  1985.     atenci = atenco = atoi(p);
  1986.     return(1);
  1987.       case 142:                /* Disposition */
  1988.       case 242:
  1989.     atdisi = atdiso = atoi(p);
  1990.     return(1);
  1991.       case 145:                /* System ID */
  1992.       case 245:
  1993.     atsidi = atsido = atoi(p);
  1994.     return(1);
  1995.       case 147:                /* System-Dependent Info */
  1996.       case 247:
  1997.     atsysi = atsyso = atoi(p);
  1998.     return(1);
  1999.       case 232:                /* Attributes (all, out) */
  2000.     atcapr = atoi(p);
  2001.     return(1);
  2002.       case 300:                /* File type (text, binary) */
  2003.     binary = atoi(p);
  2004.     return(1);
  2005.       case 301:                /* File name conversion */
  2006.     fncnv = 1 - atoi(p);        /* (oops) */
  2007.     return(1);
  2008.       case 302:                /* File name collision */
  2009.     x = atoi(p);
  2010.     if (x == XYFX_R) warn = 1;    /* Rename */
  2011.     if (x == XYFX_X) warn = 0;    /* Replace */
  2012.     fncact = x;
  2013.     return(1);
  2014.       case 310:                /* Incomplete File Disposition */
  2015.     keep = atoi(p);            /* Keep, Discard */
  2016.     return(1);
  2017.       case 311:                /* Blocksize */
  2018.     fblksiz = atoi(p);
  2019.     return(1);
  2020.       case 312:                /* Record Length */
  2021.     frecl = atoi(p);
  2022.     return(1);
  2023.       case 313:                /* Record format */
  2024.     frecfm = atoi(p);
  2025.     return(1);
  2026.       case 314:                /* File organization */
  2027.     forg = atoi(p);
  2028.     return(1);
  2029.       case 315:                /* File carriage control */
  2030.     fcctrl = atoi(p);
  2031.     return(1);
  2032.       case 400:                /* Block check */
  2033.     y = atoi(p);
  2034.     if (y < 5 && y > 0) {
  2035.         bctr = y;
  2036.         return(1);
  2037.     } else if (*p == 'B') {
  2038.         bctr = 4;
  2039.         return(1);
  2040.     }
  2041.     return(0);
  2042.       case 401:                /* Receive packet-length */
  2043.     urpsiz = atoi(p);
  2044.     if (urpsiz > MAXRP) urpsiz = MAXRP;
  2045.     urpsiz = adjpkl(urpsiz,wslots,bigrbsiz);
  2046.     return(1);
  2047.       case 402:                /* Receive timeout */
  2048.     y = atoi(p);            /* Client is telling us */
  2049.     if (y > -1 && y < 999) {    /* the timeout that it wants */
  2050.         pkttim = chktimo(y,timef);    /* us to tell it to use. */
  2051.         return(1);
  2052.     } else return(0);
  2053.       case 403:                /* Retry limit */
  2054.     y = atoi(p);
  2055.     if (y > -1 && y < 95) {
  2056.         maxtry = y;
  2057.         return(1);
  2058.     } else return(0);
  2059.       case 404:                /* Server timeout */
  2060.     y = atoi(p);
  2061.     if (y < 0) return(0);
  2062.     srvtim = y;
  2063.     return(1);
  2064.  
  2065. #ifndef NOCSETS
  2066.       case 405:                /* Transfer character set */
  2067.     for (i = 0; i < ntcsets; i++) { 
  2068.         if (!strcmp(tcsinfo[i].designator,p)) break;
  2069.     }
  2070.     debug(F101,"remset xfer charset lookup","",i);
  2071.     if (i == ntcsets) return(0);
  2072.     tcharset = tcsinfo[i].code;    /* if known, use it */
  2073.     if (tcharset == TC_TRANSP)
  2074.       rx = NULL;
  2075.     else
  2076.       rx = xlr[tcharset][fcharset];    /* translation function */
  2077.     return(1);
  2078. #endif /* NOCSETS */
  2079.  
  2080.       case 406:                /* Window slots */
  2081.     y = atoi(p);
  2082.     if (y == 0) y = 1;
  2083.     if (y < 1 && y > 31) return(0);
  2084.     wslotr = y;
  2085.     swcapr = 1;
  2086.     urpsiz = adjpkl(urpsiz,wslots,bigrbsiz);
  2087.     return(1);
  2088.       default:                /* Anything else... */
  2089.     return(0);
  2090.     }
  2091. }
  2092.  
  2093. /* Adjust packet length based on number of window slots and buffer size */
  2094.  
  2095. int
  2096. adjpkl(pktlen,slots,bufsiz) int pktlen, slots, bufsiz; {
  2097.     debug(F101,"adjpkl len","",pktlen);
  2098.     debug(F101,"adjpkl slots","",slots);
  2099.     debug(F101,"adjpkl bufsiz","",bufsiz);
  2100.     if (((pktlen + 6) * slots) > bufsiz)
  2101.       pktlen = (bufsiz / slots) - 6;
  2102.     debug(F101,"adjpkl new len","",pktlen);
  2103.     return(pktlen);
  2104. }
  2105.