home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckcfns.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  213KB  |  7,166 lines
  1. char *fnsv = "C-Kermit functions, 9.0.233, 3 Jun 2011";
  2.  
  3. char *nm[] =  { "Disabled", "Local only", "Remote only", "Enabled" };
  4.  
  5. /*  C K C F N S  --  System-independent Kermit protocol support functions.  */
  6.  
  7. /*  ...Part 1 (others moved to ckcfn2,3 to make this module smaller) */
  8.  
  9. /*
  10.   Author: Frank da Cruz <fdc@columbia.edu>,
  11.   Columbia University Academic Information Systems, New York City.
  12.  
  13.   Copyright (C) 1985, 2011,
  14.     Trustees of Columbia University in the City of New York.
  15.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  16.     copyright text in the ckcmai.c module for disclaimer and permissions.
  17. */
  18. /*
  19.  System-dependent primitives defined in:
  20.  
  21.    ck?tio.c -- terminal (communications) i/o
  22.    cx?fio.c -- file i/o, directory structure
  23. */
  24. #include "ckcsym.h"            /* Needed for Stratus VOS */
  25. #include "ckcasc.h"            /* ASCII symbols */
  26. #include "ckcdeb.h"            /* Debug formats, typedefs, etc. */
  27. #include "ckcker.h"            /* Symbol definitions for Kermit */
  28. #include "ckcxla.h"            /* Character set symbols */
  29. #include "ckcnet.h"                     /* VMS definition of TCPSOCKET */
  30. #ifdef OS2
  31. #ifdef OS2ONLY
  32. #include <os2.h>
  33. #endif /* OS2ONLY */
  34. #include "ckocon.h"
  35. #endif /* OS2 */
  36.  
  37. int docrc  = 0;                /* Accumulate CRC for \v(crc16) */
  38. long crc16 = 0L;            /* File CRC = \v(crc16) */
  39. int gnferror = 0;            /* gnfile() failure reason */
  40.  
  41. extern CHAR feol;
  42. extern int byteorder, xflg, what, fmask, cxseen, czseen, nscanfile, sysindex;
  43. extern int xcmdsrc, dispos, matchfifo;
  44. extern int inserver;
  45.  
  46. extern int nolinks;
  47. #ifdef VMSORUNIX
  48. extern int zgfs_dir;
  49. #ifdef CKSYMLINK
  50. extern int zgfs_link;
  51. #endif /* CKSYMLINK */
  52. #endif /* VMSORUNIX */
  53.  
  54. #ifndef NOXFER
  55.  
  56. #ifndef NOICP
  57. #ifndef NOSPL
  58. extern char * clcmds;
  59. extern int haveurl;
  60. #ifdef CK_APC
  61. extern int apcactive, adl_ask;
  62. #endif /* CK_APC */
  63. #endif /* NOSPL */
  64. #endif /* NOICP */
  65.  
  66. extern int remfile;
  67.  
  68. /* (move these prototypes to the appropriate .h files...) */
  69.  
  70. #ifdef COMMENT
  71. /* Not used */
  72. #ifdef VMS
  73. _PROTOTYP( int getvnum, (char *) );
  74. #endif /* VMS */
  75. #endif /* COMMENT */
  76.  
  77. _PROTOTYP( static int bgetpkt, (int) );
  78. #ifndef NOCSETS
  79. _PROTOTYP( int lookup, (struct keytab[], char *, int, int *) );
  80. #endif /* NOCSETS */
  81. #ifndef NOSPL
  82. _PROTOTYP( int zzstring, (char *, char **, int *) );
  83. #endif /* NOSPL */
  84.  
  85. #ifdef OS2
  86. #include <io.h>
  87. #ifdef OS2ONLY
  88. #include <os2.h>
  89. #endif /* OS2ONLY */
  90. #endif /* OS2 */
  91.  
  92. #ifdef VMS
  93. #include <errno.h>
  94. #endif /* VMS */
  95.  
  96. /* Externals from ckcmai.c */
  97.  
  98. extern int srvcdmsg, srvidl, idletmo;
  99. extern char * cdmsgfile[];
  100. extern int spsiz, spmax, rpsiz, timint, srvtim, rtimo, npad, ebq, ebqflg,
  101.  rpt, rptq, rptflg, capas, keep, fncact, pkttim, autopar, spsizr, xitsta;
  102. extern int pktnum, bctr, bctu, bctf, bctl, clfils, sbufnum, protocol,
  103.  size, osize, spktl, nfils, ckwarn, timef, spsizf, sndtyp, rcvtyp, success;
  104. extern int parity, turn, network, whatru, fsecs, justone, slostart,
  105.  ckdelay, displa, mypadn, moving, recursive, nettype;
  106. extern long filcnt;
  107. extern CK_OFF_T
  108.  tfc, fsize, sendstart, rs_len, flci, flco, tlci, tlco, calibrate;
  109. extern long filrej, oldcps, cps, peakcps, ccu, ccp, filestatus;
  110. extern int fblksiz, frecl, frecfm, forg, fcctrl, fdispla, skipbup;
  111. extern int spackets, rpackets, timeouts, retrans, crunched, wmax, wcur;
  112. extern int hcflg, binary, fncnv, b_save, f_save, server;
  113. extern int nakstate, discard, rejection, local, xfermode, interrupted;
  114. extern int rq, rqf, sq, wslots, wslotn, wslotr, winlo, urpsiz, rln;
  115. extern int fnspath, fnrpath, eofmethod, diractive, whatru2, wearealike;
  116. extern int atcapr, atcapb, atcapu;
  117. extern int lpcapr, lpcapb, lpcapu;
  118. extern int swcapr, swcapb, swcapu;
  119. extern int lscapr, lscapb, lscapu;
  120. extern int rscapr, rscapb, rscapu;
  121. extern int rptena, rptmin;
  122. extern int sseqtbl[];
  123. extern int numerrs, nzxopts;
  124. extern long rptn;
  125. extern int maxtry;
  126. extern int stdouf;
  127. extern int sendmode;
  128. extern int carrier, ttprty;
  129. extern int g_fnrpath;
  130. #ifdef TCPSOCKET
  131. extern int ttnproto;
  132. #endif /* TCPSOCKET */
  133.  
  134. #ifndef NOSPL
  135. extern int sndxin, sndxhi, sndxlo;
  136. #endif /* NOSPL */
  137.  
  138. extern int g_binary, g_fncnv;
  139.  
  140. #ifdef GFTIMER
  141. extern CKFLOAT fpfsecs;
  142. #endif /* GFTIMER */
  143.  
  144. #ifdef OS2
  145. extern struct zattr iattr;
  146. #endif /* OS2 */
  147.  
  148. #ifdef PIPESEND
  149. extern int usepipes;
  150. #endif /* PIPESEND */
  151. extern int pipesend;
  152.  
  153. #ifdef STREAMING
  154. extern int streamrq, streaming, streamed, streamok;
  155. #endif /* STREAMING */
  156. extern int reliable, clearrq, cleared, urclear;
  157.  
  158. extern int
  159.   atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko,
  160.   attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso;
  161.  
  162. extern int bigsbsiz, bigrbsiz;
  163. extern char *versio;
  164. extern char *filefile;
  165. extern char whoareu[], * cksysid;
  166.  
  167. #ifndef NOSERVER
  168. extern int ngetpath;
  169. extern char * getpath[];
  170. extern int fromgetpath;
  171. #endif /* NOSERVER */
  172.  
  173. #ifdef CK_LOGIN
  174. extern int isguest;
  175. #endif /* CK_LOGIN */
  176.  
  177. extern int srvcmdlen;
  178. extern CHAR *srvcmd, * epktmsg;
  179. extern CHAR padch, mypadc, eol, seol, ctlq, myctlq, sstate, myrptq;
  180. extern CHAR *data, padbuf[], stchr, mystch;
  181. extern CHAR *srvptr;
  182. extern CHAR *rdatap;
  183. extern char *cmarg, *cmarg2, **cmlist, filnam[], ofilnam[];
  184. extern char *rfspec, *prfspec, *rrfspec, *prrfspec, *sfspec, *psfspec, *rfspec;
  185. extern char fspec[];
  186. extern int fspeclen;
  187.  
  188. #ifndef NOMSEND
  189. extern struct filelist * filehead, * filenext;
  190. extern int addlist;
  191. #endif /* NOMSEND */
  192.  
  193. _PROTOTYP( int lslook, (unsigned int b) ); /* Locking Shift Lookahead */
  194. _PROTOTYP( int szeof, (CHAR *s) );
  195. _PROTOTYP( VOID fnlist, (void) );
  196. #endif /* NOXFER */
  197.  
  198. extern CK_OFF_T ffc;
  199.  
  200. /* Character set Translation */
  201.  
  202. #ifndef NOCSETS
  203. extern int tcharset, fcharset, dcset7, dcset8;
  204. extern int fcs_save, tcs_save;
  205. extern int ntcsets, xlatype, cseqtab[];
  206. extern struct csinfo tcsinfo[], fcsinfo[];
  207. extern int r_cset, s_cset, afcset[];
  208. #ifdef UNICODE
  209. extern int ucsorder, fileorder;
  210. #endif /* UNICODE */
  211.  
  212. _PROTOTYP( CHAR ident, (CHAR) );    /* Identity translation function */
  213.  
  214. /* Arrays of and pointers to character translation functions */
  215.  
  216. #ifdef CK_ANSIC
  217. extern CHAR (*rx)(CHAR); /* Pointer to input character translation function */
  218. extern CHAR (*sx)(CHAR); /* Pointer to output character translation function */
  219. extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* Byte-to-Byte Send */
  220. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* Byte-to-Byte Recv */
  221. #ifdef UNICODE
  222. extern int (*xut)(USHORT);    /* Translation function UCS to TCS */
  223. extern int (*xuf)(USHORT);    /* Translation function UCS to FCS */
  224. extern USHORT (*xtu)(CHAR);    /* Translation function TCS to UCS */
  225. extern USHORT (*xfu)(CHAR);    /* Translation function FCS to UCS */
  226. #endif /* UNICODE */
  227.  
  228. #else /* The same declarations again for non-ANSI comilers... */
  229.  
  230. extern CHAR (*rx)();
  231. extern CHAR (*sx)();
  232. extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])();
  233. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])();
  234. #ifdef UNICODE
  235. extern int (*xut)();
  236. extern int (*xuf)();
  237. extern USHORT (*xtu)();
  238. extern USHORT (*xfu)();
  239. #endif /* UNICODE */
  240. #endif /* CK_ANSIC */
  241. #endif /* NOCSETS */
  242.  
  243. /* (PWP) external def. of things used in buffered file input and output */
  244.  
  245. #ifdef DYNAMIC
  246. extern char *zinbuffer, *zoutbuffer;
  247. #else
  248. extern char zinbuffer[], zoutbuffer[];
  249. #endif /* DYNAMIC */
  250. extern char *zinptr, *zoutptr;
  251. extern int zincnt, zoutcnt, zobufsize, xfrxla;
  252.  
  253. extern long crcta[], crctb[];        /* CRC-16 generation tables */
  254. extern int rseqtbl[];            /* Rec'd-packet sequence # table */
  255.  
  256. #ifndef NOXFER
  257.  
  258. /* Criteria used by gnfile()... */
  259.  
  260. char sndafter[19]   = { NUL, NUL };
  261. char sndbefore[19]  = { NUL, NUL };
  262. char sndnafter[19]  = { NUL, NUL };
  263. char sndnbefore[19] = { NUL, NUL };
  264. char *sndexcept[NSNDEXCEPT]  = { NULL, NULL };
  265. char *rcvexcept[NSNDEXCEPT]  = { NULL, NULL };
  266. CK_OFF_T sndsmaller = (CK_OFF_T)-1;
  267. CK_OFF_T sndlarger  = (CK_OFF_T)-1;
  268.  
  269. /* Variables defined in this module but shared by other modules. */
  270.  
  271. int xfrbel = 1;
  272. char * ofperms = "";            /* Output file permissions */
  273. int autopath = 0;            /* SET RECEIVE PATHNAMES AUTO flag */
  274.  
  275. #ifdef CALIBRATE
  276. #define CAL_O 3
  277. #define CAL_M 253
  278.  
  279. int cal_j = 0;
  280.  
  281. CHAR
  282. cal_a[] = {
  283.  16, 45, 98,  3, 52, 41, 14,  7, 76,165,122, 11,104, 77,166, 15,
  284. 160, 93, 18, 19,112, 85, 54, 23,232,213, 90, 27, 12, 81,126, 31,
  285.   4,205, 34, 35,144, 73,110, 39, 28,133,218, 43,156, 65,102, 47,
  286.  84, 61, 50, 51,208,117, 86, 55,  8,245, 74, 59, 44,125,222, 63,
  287.  80,  1,162, 67,116,105,206, 71,120,  9,250, 75, 88, 97,  6, 79,
  288. 100,221, 82, 83, 36, 89, 94, 87, 40, 21,106, 91,236,145,150, 95,
  289. 228, 33,130, 99,148,137,198,103,108,169, 42,107,184,129, 78,111,
  290.   0, 49,114,115, 32,121,254,119,172, 57,138,123,152,177, 22,127,
  291. 240,193,  2,131,176,  5, 38,135,204,229, 10,139,200,161,174,143,
  292. 128, 17,146,147, 68,153, 30,151, 72,217,170,155, 24,209, 62,159,
  293.  64,225,194,163,244,201, 70,167,216,197,234,171,188,109,230,175,
  294. 212,113,178,179,132,185,190,183,136,249,202,187, 92,241,118,191,
  295.  48,237, 66,195, 96,233,142,199,248, 37, 58,203, 60, 13,134,207,
  296.  20, 29,210,211,164,149,182,215,220, 25, 26,219,124,157,246,223,
  297. 180,141,226,227,192,101,238,231, 56, 69,154,235,252,173, 46,239,
  298. 224,253,242,243,196, 53,214,247,168,181,186,251,140,189,158,255
  299. };
  300. #endif /* CALIBRATE */
  301.  
  302. char * rf_err = "Error receiving file";    /* rcvfil() error message */
  303.  
  304. #ifdef CK_SPEED
  305. short ctlp[256] = {        /* Control-Prefix table */
  306.   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* C0  */
  307.   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* G0  */
  308.   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  309.   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* DEL */
  310.   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* C1  */
  311.   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* G1  */
  312.   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  313.   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1  /* 255 */
  314. };
  315. #endif /* CK_SPEED */
  316.  
  317. int sndsrc;        /* Flag for where to get names of files to send: */
  318.                     /* -1: znext() function */
  319.                     /*  0: stdin */
  320.                     /* >0: list in cmlist or other list */
  321.                     /* -9: calibrate */
  322.  
  323. int  memstr;                /* Flag for input from memory string */
  324. int  funcstr;                /* Flag for input from function */
  325. int  bestlen = 0;
  326. int  maxsend = 0;
  327.  
  328. int gnf_binary = 0;            /* Prevailing xfer mode for gnfile */
  329.  
  330. #ifdef pdp11
  331. #define MYINITLEN 32
  332. #else
  333. #define MYINITLEN 100
  334. #endif /* pdp11 */
  335. CHAR myinit[MYINITLEN];            /* Copy of my Send-Init data */
  336.  
  337. /* Variables local to this module */
  338.  
  339. #ifdef TLOG
  340. #ifndef XYZ_INTERNAL
  341. static
  342. #endif /* XYZ_INTERNAL */
  343. char *fncnam[] = {
  344.   "rename", "replace", "backup", "append", "discard", "ask",
  345.   "update", "dates-differ", ""
  346. };
  347. #endif /* TLOG */
  348.  
  349. static char *memptr;            /* Pointer for memory strings */
  350.  
  351. #ifdef VMS
  352. extern int batch;
  353. #else
  354. extern int backgrd;
  355. #endif /* VMS */
  356.  
  357. #ifdef CK_CTRLZ
  358. static int lastchar = 0;
  359. #endif /* CK_CTRLZ */
  360.  
  361. #ifdef CK_ANSIC
  362. static int (*funcptr)(void);        /* Pointer for function strings */
  363. #else
  364. static int (*funcptr)();
  365. #endif /* CK_ANSIC */
  366.  
  367. #ifdef pdp11
  368. #define CMDSTRL 50
  369. static char cmdstr[50];            /* System command string. */
  370. #else
  371. #ifdef BIGBUFOK
  372. #define CMDSTRL 1024
  373. #else
  374. #define CMDSTRL 256
  375. #endif /* BIGBUFOK */
  376. static char cmdstr[CMDSTRL+1];
  377. #endif /* pdp11 */
  378.  
  379. static int drain;            /* For draining stacked-up ACKs. */
  380.  
  381. static int first;            /* Flag for first char from input */
  382. static CHAR t;                /* Current character */
  383. #ifdef COMMENT
  384. static CHAR next;            /* Next character */
  385. #endif /* COMMENT */
  386.  
  387. static int ebqsent = 0;            /* 8th-bit prefix bid that I sent */
  388. static int lsstate = 0;            /* Locking shift state */
  389. static int lsquote = 0;            /* Locking shift quote */
  390.  
  391. extern int quiet;
  392.  
  393. /*  E N C S T R  --  Encode a string from memory. */
  394.  
  395. /*
  396.   Call this instead of getpkt() if source is a string, rather than a file.
  397.   Note: Character set translation is never done in this case.
  398. */
  399.  
  400. #ifdef COMMENT
  401. #define ENCBUFL 200
  402. #ifndef pdp11
  403. CHAR encbuf[ENCBUFL];
  404. #else
  405. /* This is gross, but the pdp11 root segment is out of space */
  406. /* Will allocate it in ckuusr.c. */
  407. extern CHAR encbuf[];
  408. #endif /* pdp11 */
  409. #endif /* COMMENT */
  410.  
  411. /*
  412.   Encode packet data from a string in memory rather than from a file.
  413.   Returns the length of the encoded string on success, -1 if the string
  414.   could not be completely encoded into the currently negotiated data
  415.   field length.
  416. */
  417. int
  418. #ifdef CK_ANSIC
  419. encstr(CHAR *s)
  420. #else /* CK_ANSIC */
  421. encstr(s) CHAR* s;
  422. #endif /* CK_ANSIC */
  423. {
  424. /*
  425.   Recoded 30 Jul 94 to use the regular data buffer and the negotiated
  426.   maximum packet size.  Previously we were limited to the length of encbuf[].
  427.   Also, to return a failure code if the entire encoded string would not fit.
  428.   Modified 14 Jul 98 to return length of encoded string.
  429. */
  430.     int m, rc, slen; char *p;
  431.     if (!data) {            /* Watch out for null pointers. */
  432.     debug(F100,"SERIOUS ERROR: encstr data == NULL","",0);
  433.     return(-1);
  434.     }
  435.     if (!s) s = (CHAR *)"";        /* Ditto. */
  436.     slen = strlen((char *)s);        /* Length of source string. */
  437.     debug(F111,"encstr",s,slen);
  438.     rc = 0;                /* Return code. */
  439.     m = memstr; p = memptr;        /* Save these. */
  440.     memptr = (char *)s;            /* Point to the string. */
  441.     /* debug(F101,"encstr memptr 1","",memptr); */
  442.     memstr = 1;                /* Flag memory string as source. */
  443.     first = 1;                /* Initialize character lookahead. */
  444.     *data = NUL;            /* In case s is empty */
  445.     debug(F101,"encstr spsiz","",spsiz);
  446.     rc = getpkt(spsiz,0);        /* Fill a packet from the string. */
  447.     debug(F101,"encstr getpkt rc","",rc);
  448.     if (rc > -1 && memptr < (char *)(s + slen)) { /* Means we didn't encode */
  449.     rc = -1;            /* the whole string. */
  450.     debug(F101,"encstr string too big","",size);
  451.     }
  452.     debug(F101,"encstr getpkt rc","",rc);
  453.     memstr = m;                /* Restore memory string flag */
  454.     memptr = p;                /* and pointer */
  455.     first = 1;                /* Put this back as we found it. */
  456.     return(rc);
  457. }
  458.  
  459. /*  Output functions passed to 'decode':  */
  460.  
  461. int                   /*  Put character in server command buffer  */
  462. #ifdef CK_ANSIC
  463. putsrv(char c)
  464. #else
  465. putsrv(c) register char c;
  466. #endif /* CK_ANSIC */
  467. /* putsrv */ {
  468.     *srvptr++ = c;
  469.     *srvptr = '\0';        /* Make sure buffer is null-terminated */
  470.     return(0);
  471. }
  472.  
  473. int                    /*  Output character to console.  */
  474. #ifdef CK_ANSIC
  475. puttrm(char c)
  476. #else
  477. puttrm(c) register char c;
  478. #endif /* CK_ANSIC */
  479. /* puttrm */ {
  480.     extern int rcdactive;
  481. #ifndef NOSPL
  482.     extern char * qbufp;        /* If REMOTE QUERY active, */
  483.     extern int query, qbufn;        /* also store response in */
  484.     if (query && qbufn++ < 1024) {    /* query buffer. */
  485.     *qbufp++ = c;
  486.     *qbufp = NUL;
  487.     }
  488.     if (!query || !xcmdsrc)
  489. #endif /* NOSPL */
  490. /*
  491.   This routine is used (among other things) for printing the server's answer
  492.   to a REMOTE command.  But REMOTE CD is special because it isn't really 
  493.   asking for an answer from the server.  Thus some people want to suppress
  494.   the confirmation message (e.g. when the server sends back the actual path
  495.   of the directory CD'd to), and expect to be able to do this with SET QUIET
  496.   ON.  But they would not want SET QUIET ON to suppress the other server
  497.   replies, which are pointless without their answers.  Thus the "rcdactive"
  498.   flag (REMOTE CD command is active).  Thu Oct 10 16:38:21 2002
  499. */
  500.       if (!(quiet && rcdactive))    /* gross, yuk */
  501.     conoc(c);
  502.     return(0);
  503. }
  504. #endif /* NOXFER */
  505.  
  506. int                    /*  Output char to file. */
  507. #ifdef CK_ANSIC
  508. putmfil(char c)                /* Just like putfil but to ZMFILE */
  509. #else                    /* rather than ZOFILE... */
  510. putmfil(c) register char c;
  511. #endif /* CK_ANSIC */
  512. /* putmfil */ {
  513.     debug(F000,"putfil","",c);
  514.     if (zchout(ZMFILE, (char) (c & fmask)) < 0) {
  515.     czseen = 1;
  516.     debug(F101,"putfil zchout write error, setting czseen","",1);
  517.     return(-1);
  518.     }
  519.     return(0);
  520. }
  521.  
  522. int                    /*  Output char to nowhere. */
  523. #ifdef CK_ANSIC
  524. putnowhere(char c)
  525. #else
  526. putnowhere(c) register char c;
  527. #endif /* CK_ANSIC */
  528. /* putnowhere */ {
  529.     return(0);
  530. }
  531.  
  532.  
  533. int                    /*  Output char to file. */
  534. #ifdef CK_ANSIC
  535. putfil(char c)
  536. #else
  537. putfil(c) register char c;
  538. #endif /* CK_ANSIC */
  539. /* putfil */ {
  540.     debug(F000,"putfil","",c);
  541.     if (zchout(ZOFILE, (char) (c & fmask)) < 0) {
  542.     czseen = 1;               /* If write error... */
  543.     debug(F101,"putfil zchout write error, setting czseen","",1);
  544.     return(-1);
  545.     }
  546.     return(0);
  547. }
  548.  
  549. /*
  550.   The following function is a wrapper for putfil().  The only reason for its
  551.   existence is to be passed as a function pointer to decode(), which treats
  552.   putfil() itself specially -- bypassing it and using an internal macro
  553.   instead to speed things up.  Use zputfil() instead of putfil() in cases where
  554.   we do not want this to happen, e.g. when we need to send output to the file
  555.   with a mixture of zchout() and zsout()/zsoutl() calls (as is the case with
  556.   incoming short-form REMOTE command replies redirected to a file), which would
  557.   otherwise result in data written to the file out of order.
  558. */
  559. int
  560. #ifdef CK_ANSIC
  561. zputfil(char c)
  562. #else
  563. zputfil(c) register char c;
  564. #endif /* CK_ANSIC */
  565. /* zputfil */ {
  566.     return(putfil(c));
  567. }
  568.  
  569. #ifndef NOXFER
  570.  
  571. /* D E C O D E  --  Kermit packet decoding procedure */
  572.  
  573. /*
  574.  Call with string to be decoded and an output function.
  575.  Returns 0 on success, -1 on failure (e.g. disk full).
  576.  
  577.  This is the "inner loop" when receiving files, and must be coded as
  578.  efficiently as possible.  Note some potential problems:  if a packet
  579.  is badly formed, having a prefixed sequence ending prematurely, this
  580.  function, as coded, could read past the end of the packet.  This has
  581.  never happened, thus the additional (time-consuming) tests have not
  582.  been added.
  583. */
  584.  
  585. static CHAR *xdbuf;    /* Global version of decode()'s buffer pointer */
  586.                         /* for use by translation functions. */
  587.  
  588. /* Function for pushing a character onto decode()'s input stream. */
  589.  
  590. VOID
  591. #ifdef CK_ANSIC
  592. zdstuff(CHAR c)
  593. #else
  594. zdstuff(c) CHAR c;
  595. #endif /* CK_ANSIC */
  596. /* zdstuff */ {
  597.     xdbuf--;                /* Back up the pointer. */
  598.     *xdbuf = c;                /* Stuff the character. */
  599. }
  600.  
  601. #ifdef CKTUNING
  602. /*
  603.   Trimmed-down packet decoder for binary-mode no-parity transfers.
  604.   decode() is the full version.
  605. */
  606. int
  607. #ifdef CK_ANSIC
  608. bdecode(CHAR *buf, int (*fn)(char))
  609. #else
  610. bdecode(buf,fn) register CHAR *buf; register int (*fn)();
  611. #endif /* CK_ANSIC */
  612. /* bdecode */ {
  613.     register unsigned int a, a7;    /* Various copies of current char */
  614.     int ccpflg;                /* For Ctrl-unprefixing stats */
  615.     int t;                /* Int version of character */
  616.     int len;
  617.     long z;                /* For CRC calculation */
  618.     CHAR c;                /* Current character */
  619.  
  620.     if (!binary || parity || fn != putfil) /* JUST IN CASE */
  621.       return(decode(buf,fn,1));
  622.     debug(F100,"BDECODE","",0);
  623.  
  624.     xdbuf = buf;            /* Global copy of source pointer. */
  625.  
  626.     len = rln;                /* Number of bytes in data field */
  627.     while (len > 0) {
  628.         a = *xdbuf++ & 0xff;        /* Get next character */
  629.     len--;
  630.     rpt = 0;            /* Initialize repeat count. */
  631.     if (a == rptq && rptflg) {    /* Got a repeat prefix? */
  632.         rpt = xunchar(*xdbuf++ & 0xFF); /* Yes, get the repeat count, */
  633.         rptn += rpt;
  634.         a = *xdbuf++ & 0xFF;    /* and get the prefixed character. */
  635.         len -= 2;
  636.     }
  637.     ccpflg = 0;            /* Control prefix flag. */
  638.     if (a == ctlq) {        /* If control prefix, */
  639.         a  = *xdbuf++ & 0xFF;    /* get its operand */
  640.         len--;
  641.         a7 = a & 0x7F;        /* and its low 7 bits. */
  642.         if ((a7 >= 0100 && a7 <= 0137) || a7 == '?') { /* Controllify */
  643.         a = ctl(a);        /* if in control range. */
  644.         a7 = a & 0x7F;
  645.         ccpflg = 1;        /* Note that we did this */
  646.         ccp++;            /* Count for stats */
  647.         }
  648.     } else a7 = a & 0x7f;        /* Not control quote */
  649.     if (a7 < 32 || a7 == 127)    /* A bare control character? */
  650.       if (!ccpflg) ccu++;        /* Count it */
  651.     if (!rpt) rpt = 1;
  652.     for (; rpt > 0; rpt--) {    /* Output the char RPT times */
  653. #ifdef CALIBRATE
  654.         if (calibrate) {
  655.         ffc++;
  656.         continue;
  657.         }
  658. #endif /* CALIBRATE */
  659. #ifdef OS2
  660.             if (xflg && !remfile) {        /* Write to virtual screen */
  661.                 char _a;
  662.                 _a = a & fmask;
  663.                 t = conoc(_a);
  664.                 if (t < 1)
  665.                     t = -1;
  666.             } else
  667. #endif /* OS2 */
  668.           t = zmchout(a & fmask);    /* zmchout is a macro */
  669.         if (t < 0) {
  670.         debug(F101,"bdecode write error - errno","",errno);
  671.         return(-1);
  672.         }
  673.         ffc++;            /* Count the character */
  674.         if (docrc && !remfile) {    /* Update file CRC */
  675.         c = a;            /* Force conversion to unsigned char */
  676.         z = crc16 ^ (long)c;
  677.         crc16 = (crc16 >> 8) ^
  678.           (crcta[(z & 0xF0) >> 4] ^ crctb[z & 0x0F]);
  679.         }
  680.     }
  681. #ifdef CK_CTRLZ
  682.     lastchar = a;
  683. #endif /* CK_CTRLZ */
  684.     }
  685.     return(0);
  686. }
  687. #endif /* CKTUNING */
  688. #endif /* NOXFER */
  689.  
  690. /*  P N B Y T E  --  Output next byte to file or other destination  */
  691.  
  692. static CK_OFF_T offc = 0L;
  693.  
  694. static int
  695. #ifdef CK_ANSIC
  696. pnbyte(CHAR c, int (*fn)(char))
  697. #else
  698. pnbyte(c,fn) CHAR c; int (*fn)();
  699. #endif /* CK_ANSIC */
  700. /* pnbyte */ {
  701.     int rc;
  702.     long z;
  703.  
  704. #ifdef OS2
  705. #ifndef NOXFER
  706.     if (xflg && !remfile) {        /* Write to virtual screen */
  707.     char _a;
  708.     _a = c & fmask;
  709.     rc = conoc(_a);
  710.     if (rc < 1)
  711.       return(-1);
  712.     } else
  713. #endif /* NOXFER */
  714. #endif /* OS2 */
  715.     {
  716.     if (fn == putfil) {        /* Execute output function */
  717.         rc = zmchout(c);        /* to-file macro (fast) */
  718.     } else if (!fn) {
  719.         rc = putchar(c);        /* to-screen macro (fast) */
  720.         } else {
  721.         rc = (*fn)(c);        /* function call (not as fast) */
  722.     }
  723.     if (rc < 0)
  724.       return(rc);
  725.     }
  726. /*
  727.   Both xgnbyte() and xpnbyte() increment ffc (the file byte counter).
  728.   During file transfer, only one of these functions is called.  However,
  729.   the TRANSLATE command is likely to call them both.  offc, therefore,
  730.   contains the output byte count, necessary for handling the UCS-2 BOM.
  731.   NOTE: It might be safe to just test for W_SEND, FTP or not.
  732. */
  733.     if ((what & (W_FTP|W_SEND)) != (W_FTP|W_SEND)) {
  734.     offc++;                /* Count the byte */
  735.     ffc++;                /* Count the byte */
  736.     }
  737. #ifndef NOXFER
  738.     if (docrc && !xflg && !remfile) {    /* Update file CRC */
  739.     z = crc16 ^ (long)c;
  740.     crc16 = (crc16 >> 8) ^
  741.       (crcta[(z & 0xF0) >> 4] ^ crctb[z & 0x0F]);
  742.     }
  743. #endif /* NOXFER */
  744.     return(1);
  745. }
  746.  
  747. /*
  748.   X P N B Y T E  --  Translate and put next byte to file.
  749.  
  750.   Only for Unicode.  Call with next untranslated byte from incoming
  751.   byte stream, which can be in any Transfer Character Set: UCS-2, UTF-8,
  752.   Latin-1, Latin-Hebrew, etc.  Translates to the file character set and
  753.   writes bytes to the output file.  Call with character to translate
  754.   as an int, plus the transfer character set (to translate from) and the
  755.   file character set (to translate to), or -1,0,0 to reset the UCS-2 byte
  756.   number (which should be done at the beginning of a file).  If the transfer
  757.   (source) character-set is UCS-2, bytes MUST arrive in Big-Endian order.
  758.   Returns:
  759.    -1: On error
  760.     0: Nothing to write (mid-sequence)
  761.    >0: Number of bytes written.
  762. */
  763. #ifdef KANJI
  764. static int jstate = 0, jx = 0;        /* For outputting JIS-7 */
  765. static char jbuf[16] = { NUL, NUL };
  766. #endif /* KANJI */
  767.  
  768. int
  769. #ifdef CK_ANSIC
  770. xpnbyte(int a, int tcs, int fcs, int (*fn)(char))
  771. #else
  772. xpnbyte(a,tcs,fcs,fn) int a, tcs, fcs; int (*fn)();
  773. #endif /* CK_ANSIC */
  774. /* xpnbyte */ {
  775. #ifdef UNICODE
  776.     extern int ucsbom;            /* Byte order */
  777. #endif /* UNICODE */
  778.     /* CHAR c; */            /* Unsigned char worker */
  779.     static union ck_short uc, eu, sj;    /* UCS-2, EUC, and Shift-JIS workers */
  780.     USHORT ch;                /* ditto... */
  781.     USHORT * us = NULL;            /* ditto... */
  782.     int c7, rc, haveuc = 0;        /* Return code and UCS-2 flag */
  783.     int utferror = 0;            /* UTF-8 error */
  784.     static int bn = 0;            /* UCS-2 byte number */
  785.     int swapping = 0;            /* Swapping UCS bytes to output? */
  786.                     /* swapping must be 0 or 1 */
  787.     if (a == -1 && (tcs | fcs) == 0) {    /* Reset in case previous run */
  788.     bn = 0;                /* left bn at 1... */
  789.     offc = (CK_OFF_T)0;
  790.     debug(F101,"xpnbyte RESET","",bn);
  791.     return(0);
  792.     }
  793.     debug(F001,"xpnbyte a","",a);
  794.  
  795. #ifdef UNICODE
  796.  
  797. /*
  798.   byteorder = hardware byte order of this machine.
  799.   ucsorder  = override by SET FILE UCS BYTE-ORDER command.
  800.   fileorder = byte order of UCS-2 input file detected from BOM.
  801.   swapping applies only when output charset is UCS-2.
  802. */
  803.     if (ucsorder != 1 && ucsorder != 0)    /* Also just in case... */
  804.       ucsorder = byteorder;
  805.     if ((byteorder && !ucsorder) || (!byteorder && fileorder))
  806.       swapping = 1;            /* Swapping bytes to output */
  807.  
  808. #ifdef COMMENT
  809.     debug(F101,"xpnbyte ucsorder","",ucsorder);
  810.     debug(F101,"xpnbyte swapping","",swapping);
  811. #endif /* COMMENT */
  812.  
  813.     if (tcs == TC_UTF8) {        /* 'a' is from a UTF-8 stream */
  814.     ch = a;
  815.     if (fcs == TC_UTF8)        /* Output is UTF-8 too */
  816.       return(pnbyte(ch,fn));    /* so just copy. */
  817.     rc = utf8_to_ucs2(ch,&us);    /* Otherwise convert to UCS-2 */
  818.     if (rc == 0) {            /* Done with this sequence */
  819.         uc.x_short = *us;        /* We have a Unicode */
  820.         haveuc = 1;
  821.     } else if (rc < 0) {        /* Error */
  822.         debug(F101,"xpnbyte UTF-8 conversion error","",rc);
  823.         haveuc = 1;            /* Replace by U+FFFD */
  824.         uc.x_short = *us;
  825.         utferror = 1;
  826.     } else                /* Sequence incomplete */
  827.       return(0);
  828.     } else if (tcs == TC_UCS2) {    /* 'a' is UCS-2 */
  829.     /* Here we have incoming UCS-2 in guaranteed Big Endian order */
  830.     /* so we must exchange bytes if local machine is Little Endian. */
  831.     switch (bn) {            /* Which byte? */
  832.       case 0:            /* High... */
  833.         uc.x_char[byteorder] = (unsigned)a & 0xff;
  834.         bn++;
  835.         return(0);            /* Wait for next */
  836.       case 1:            /* Low... */
  837.         uc.x_char[1-byteorder] = (unsigned)a & 0xff;
  838.         bn = 0;            /* Done with sequence */
  839.         haveuc = 1;            /* Have a Unicode */
  840.     }
  841.     } else
  842. #endif /* UNICODE */
  843.  
  844. #ifdef KANJI                /* Whether UNICODE is defined or not */
  845.       if (tcs == TC_JEUC) {        /* Incoming Japanese EUC */
  846.     int bad = 0;
  847.     static int kanji = 0;        /* Flags set in case 0 for case 1 */
  848.     static int kana = 0;
  849.     switch (bn) {            /* Byte number */
  850.       case 0:            /* Byte 0 */
  851.         eu.x_short = 0;
  852.         if ((a & 0x80) == 0) {
  853.         sj.x_short = (unsigned)a & 0xff; /* Single byte */
  854.         kanji = kana = 0;
  855.         } else {            /* Double byte */
  856.         c7 = a & 0x7f;
  857.         if (c7 > 0x20 && c7 < 0x7f) { /* Kanji */
  858.             eu.x_char[byteorder] = (CHAR) a;  /* Store first byte */
  859.             bn++;              /* Set up for second byte */
  860.             kanji = 1;
  861.             kana = 0;
  862.             return(0);
  863.         } else if (a == 0x8e) {    /* SS2 -- Katakana prefix */
  864.             eu.x_char[byteorder] = (CHAR) a; /* Save it */
  865.             bn++;
  866.             kana = 1;
  867.             kanji = 0;
  868.             return(0);
  869.         } else {
  870.             bad++;
  871.         }
  872.         }
  873.         break;
  874.       case 1:            /* Byte 1 */
  875.         bn = 0;
  876.         if (kanji) {
  877.         eu.x_char[1-byteorder] = (CHAR) a;
  878.         sj.x_short = eu_to_sj(eu.x_short);
  879.         break;
  880.         } else if (kana) {
  881.         sj.x_short = (CHAR) (a | 0x80);
  882.         break;
  883.         } else {            /* (shouldn't happen) */
  884.         bad++;
  885.         }
  886.     }
  887.     /* Come here with one Shift-JIS character */
  888.  
  889. #ifdef UNICODE
  890.     if (bad) {
  891.         uc.x_short = 0xfffd;
  892.     } else {
  893.         uc.x_short = sj_to_un(sj.x_short); /* Convert to Unicode */
  894.     }
  895.     haveuc = 1;
  896. #endif /* UNICODE */
  897.     } else
  898. #endif /* KANJI */
  899.  
  900. #ifdef UNICODE
  901.     uc.x_short = (unsigned)a & 0xff; /* Latin-1 or whatever... */
  902.  
  903.     /* Come here with uc = the character to be translated. */
  904.     /* If (haveuc) it's UCS-2 in native order, otherwise it's a byte. */
  905.  
  906.     debug(F101,"xpnbyte haveuc","",haveuc);
  907.  
  908.     if (haveuc) {            /* If we have a Unicode... */
  909.     debug(F001,"xpnbyte uc.x_short","[A]",uc.x_short);
  910.     debug(F101,"xpnbyte feol","",feol);
  911.     if (what & W_XFER) {        /* If transferring a file */
  912.         if (feol && uc.x_short == CR) { /* handle eol conversion. */
  913.         return(0);
  914.         } else if (feol && uc.x_short == LF) {
  915.         uc.x_short = feol;
  916.         }
  917.     }
  918.     debug(F001,"xpnbyte uc.x_short","[B]",uc.x_short);
  919.     if (fcs == FC_UCS2) {        /* And FCS is UCS-2 */
  920.         /* Write out the bytes in the appropriate byte order */
  921.         int count = 0;
  922. #ifndef IKSDONLY
  923. #ifdef OS2
  924.             extern int k95stdout,wherex[],wherey[];
  925.             extern unsigned char colorcmd;
  926.             union {
  927.                 USHORT ucs2;
  928.                 UCHAR  bytes[2];
  929.             } output;
  930. #endif /* OS2 */
  931. #endif /* IKSDONLY */
  932.         if (!offc && ucsbom) {    /* Beginning of file? */
  933.  
  934. #ifndef IKSDONLY
  935. #ifdef OS2
  936.                 if (fn == NULL && !k95stdout && !inserver) {
  937.             offc++;
  938. #ifdef COMMENT
  939.             /* Don't print the BOM to the display */
  940.                     output.bytes[0] = (!ucsorder ? 0xff : 0xfe);
  941.                     output.bytes[1] = (!ucsorder ? 0xfe : 0xff);
  942.  
  943.                     VscrnWrtUCS2StrAtt(VCMD,
  944.                                        &output.ucs2,
  945.                                        1,
  946.                                        wherey[VCMD],
  947.                                        wherex[VCMD],
  948.                                        &colorcmd
  949.                                        );
  950. #endif /* COMMENT */
  951.                 } else 
  952. #endif /* OS2 */
  953. #endif /* IKSDONLY */
  954.                 {
  955.             if ((rc = pnbyte((ucsorder ? 0xff : 0xfe),fn)) < 0)
  956.               return(rc);    /* BOM */
  957.             if ((rc = pnbyte((ucsorder ? 0xfe : 0xff),fn)) < 0)
  958.               return(rc);
  959.         }
  960.         count += 2;
  961.         }
  962.         if (utferror) {
  963. #ifndef IKSDONLY
  964. #ifdef OS2
  965.                 if (fn == NULL && !k95stdout && !inserver) {
  966.                     offc++;
  967.                     output.bytes[0] = (!ucsorder ? 0xfd : 0xff);
  968.                     output.bytes[1] = (!ucsorder ? 0xff : 0xfd);
  969.  
  970.                     VscrnWrtUCS2StrAtt(VCMD,
  971.                                        &output.ucs2,
  972.                                        1,
  973.                                        wherey[VCMD],
  974.                                        wherex[VCMD],
  975.                                        &colorcmd
  976.                                        );
  977.                 } else 
  978. #endif /* OS2 */
  979. #endif /* IKSDONLY */
  980.         {
  981.             if ((rc = pnbyte((ucsorder ? 0xfd : 0xff),fn)) < 0)
  982.               return(rc);
  983.             if ((rc = pnbyte((ucsorder ? 0xff : 0xfd),fn)) < 0)
  984.               return(rc);
  985.         }
  986.         count += 2;
  987.         }
  988. #ifndef IKSDONLY
  989. #ifdef OS2
  990.             if (fn == NULL && !k95stdout && !inserver) {
  991.                 offc++;
  992.                 output.bytes[0] = uc.x_char[swapping];
  993.                 output.bytes[1] = uc.x_char[1-swapping];
  994.  
  995.                 VscrnWrtUCS2StrAtt(VCMD,
  996.                                    &output.ucs2,
  997.                                    1,
  998.                                    wherey[VCMD],
  999.                                    wherex[VCMD],
  1000.                                    &colorcmd
  1001.                                    );
  1002.             } else 
  1003. #endif /* OS2 */
  1004. #endif /* IKSDONLY */
  1005.             {
  1006.         if ((rc = pnbyte(uc.x_char[swapping],fn)) < 0)
  1007.           return(rc);
  1008.         if ((rc = pnbyte(uc.x_char[1-swapping],fn)) < 0)
  1009.           return(rc);
  1010.         }
  1011.         count += 2;
  1012.         return(count);
  1013.     } else if (fcs == FC_UTF8) {    /* Convert to UTF-8 */
  1014.         CHAR * buf = NULL;
  1015.         int i, count;
  1016.         if (utferror) {
  1017.         if ((rc = pnbyte((ucsorder ? 0xbd : 0xff),fn)) < 0)
  1018.           return(rc);
  1019.         if ((rc = pnbyte((ucsorder ? 0xff : 0xbd),fn)) < 0)
  1020.           return(rc);
  1021.         }
  1022.         if ((count = ucs2_to_utf8(uc.x_short,&buf)) < 1)
  1023.           return(-1);
  1024.         debug(F011,"xpnbyte buf",buf,count);
  1025.         for (i = 0; i < count; i++)
  1026.           if ((rc = pnbyte(buf[i],fn)) < 0)
  1027.         return(rc);
  1028.         if (utferror)
  1029.           count += 2;
  1030.         return(count);
  1031.     } else {            /* Translate UCS-2 to byte */
  1032.         if (uc.x_short == 0x2028 || uc.x_short == 0x2029) {
  1033.         if (utferror)
  1034.           pnbyte(UNK,fn);
  1035.         if (feol)
  1036.           return(pnbyte((CHAR)feol,fn));
  1037.         if ((rc = pnbyte((CHAR)CR,fn)) < 0)
  1038.           return(rc);
  1039.         if ((rc = pnbyte((CHAR)LF,fn)) < 0)
  1040.           return(rc);
  1041.         else
  1042.           return(utferror ? 3 : 2);
  1043.         } else if (xuf) {        /* UCS-to-FCS function */
  1044.         int x = 0;
  1045.         if (utferror)
  1046.           pnbyte(UNK,fn);
  1047.         if ((rc = (*xuf)(uc.x_short)) < 0) /* These can fail... */
  1048.           ch = UNK;
  1049.         else
  1050.           ch = (unsigned)((unsigned)rc & 0xffff);
  1051.         x = pnbyte(ch,fn);
  1052.         if (x < 0)
  1053.           return(x);
  1054.         else if (utferror)
  1055.           x++;
  1056.         return(x);
  1057. #ifdef KANJI
  1058.  
  1059. /*  Also see the non-Unicode Kanji section further down in this function. */
  1060.  
  1061.         } else if (fcsinfo[fcs].alphabet == AL_JAPAN) {
  1062.  
  1063.         /* Translate UCS-2 to Japanese set */
  1064.         debug(F001,"xpnbyte uc","",uc.x_short);
  1065.         sj.x_short = un_to_sj(uc.x_short); /* First to Shift-JIS */
  1066.         debug(F001,"xpnbyte sj","",sj.x_short);
  1067.  
  1068.         switch (fcs) {        /* File character set */
  1069.           case FC_SHJIS:    /* Shift-JIS -- just output it */
  1070.             if (sj.x_char[byteorder]) /* But not high byte if zero */
  1071.               if ((rc = pnbyte((CHAR)sj.x_char[byteorder],fn)) < 0)
  1072.             return(rc);
  1073.             if ((rc = pnbyte((CHAR)sj.x_char[1-byteorder],fn)) < 0)
  1074.               return(rc);
  1075.             return(2);
  1076.           case FC_JEUC:        /* EUC-JP */
  1077.             eu.x_short = sj_to_eu(sj.x_short); /* Shift-JIS to EUC */
  1078.             debug(F001,"xpnbyte eu","",eu.x_short);
  1079.             if (eu.x_short == 0xffff) { /* Bad */
  1080.             if ((rc = pnbyte(UNK,fn)) < 0)
  1081.               return(rc);
  1082.             return(1);
  1083.             } else {        /* Good */
  1084.             int count = 0;    /* Write high byte if not zero */
  1085.             if (eu.x_char[byteorder]) {
  1086.                 if ((rc=pnbyte((CHAR)eu.x_char[byteorder],fn)) < 0)
  1087.                   return(rc);
  1088.                 count++;
  1089.             }
  1090.             /* Always write low byte */
  1091.             if ((rc = pnbyte((CHAR)eu.x_char[1-byteorder],fn)) < 0)
  1092.               return(rc);
  1093.             count++;
  1094.             return(count);
  1095.             }
  1096.             break;
  1097.  
  1098.           case FC_JIS7:        /* JIS-7 */
  1099.           case FC_JDEC:        /* DEC Kanji */
  1100.             eu.x_short = sj_to_eu(sj.x_short); /* Shift-JIS to EUC */
  1101.             if (eu.x_short == 0xffff) { /* Bad */
  1102.             debug(F001,"xpnbyte bad eu","",eu.x_short);
  1103.             if ((rc = pnbyte(UNK,fn)) < 0)
  1104.               return(rc);
  1105.             return(1);
  1106.             } else {        /* Good */
  1107.             int i;
  1108.             /* Use another name - 'a' hides parameter */
  1109.             /* It's OK as is but causes compiler warnings */
  1110.             char a = eu.x_char[1-byteorder]; /* Low byte */
  1111.             debug(F001,"xpnbyte eu","",eu.x_short);
  1112.             if (eu.x_char[byteorder] == 0) { /* Roman */
  1113.                 switch (jstate) {
  1114.                   case 1:    /* Current state is Katakana */
  1115.                 jbuf[0] = 0x0f;    /* SI */
  1116.                 jbuf[1] = a;
  1117.                 jx = 2;
  1118.                 break;
  1119.                   case 2:    /* Current state is Kanji */
  1120.                 jbuf[0] = 0x1b;    /* ESC */
  1121.                 jbuf[1] = 0x28;    /* ( */
  1122.                 jbuf[2] = 0x4a;    /* J */
  1123.                 jbuf[3] = a;
  1124.                 jx = 4;
  1125.                 break;
  1126.                   default:    /* Current state is Roman */
  1127.                 jbuf[0] = a;
  1128.                 jx = 1;
  1129.                 break;
  1130.                 }
  1131.                 jstate = 0;    /* New state is Roman */
  1132.             } else if (eu.x_char[byteorder] == 0x8e) { /* Kana */
  1133.                 jx = 0;
  1134.                 switch (jstate) {
  1135.                   case 2:           /* from Kanji */
  1136.                 jbuf[jx++] = 0x1b; /* ESC */
  1137.                 jbuf[jx++] = 0x28; /* ( */
  1138.                 jbuf[jx++] = 0x4a; /* J */
  1139.                   case 0:           /* from Roman */
  1140.                 jbuf[jx++] = 0x0e; /* SO */
  1141.                   default:           /* State is already Kana*/
  1142.                 jbuf[jx++] = (a & 0x7f); /* and the char */
  1143.                 break;
  1144.                 }
  1145.                 jstate = 1;    /* New state is Katakana */
  1146.             } else {    /* Kanji */
  1147.                 jx = 0;
  1148.                 switch (jstate) {
  1149.                   case 1:    /* Current state is Katakana */
  1150.                 jbuf[jx++] = 0x0f; /* SI  */
  1151.                   case 0:    /* Current state is Roman */
  1152.                 jbuf[jx++] = 0x1b; /* ESC */
  1153.                 jbuf[jx++] = 0x24; /* $   */
  1154.                 jbuf[jx++] = 0x42; /* B   */
  1155.                   default:    /* Current state is already Kanji */
  1156.                 jbuf[jx++] = eu.x_char[byteorder] & 0x7f;
  1157.                 jbuf[jx++] = eu.x_char[1-byteorder] & 0x7f;
  1158.                 break;
  1159.                 }
  1160.                 jstate = 2;    /* Set state to Kanji */
  1161.             }
  1162.             for (i = 0; i < jx; i++) /* Output the result */
  1163.               if ((rc = pnbyte(jbuf[i],fn)) < 0)
  1164.                 return(rc);
  1165.             return(jx);    /* Return its length */
  1166.             }
  1167.         }
  1168. #endif /* KANJI */
  1169.         } else {            /* No translation function */
  1170.         int count = 0;
  1171.         if (utferror) {
  1172.             if ((rc = pnbyte((ucsorder ? 0xfd : 0xff),fn)) < 0)
  1173.               return(rc);
  1174.             if ((rc = pnbyte((ucsorder ? 0xff : 0xfd),fn)) < 0)
  1175.               return(rc);
  1176.             count += 2;
  1177.         }
  1178.         if ((rc = pnbyte(uc.x_char[swapping],fn)) < 0)
  1179.           return(rc);
  1180.         if ((rc = pnbyte(uc.x_char[1-swapping],fn)) < 0)
  1181.           return(rc);
  1182.         count += 2;
  1183.         return(count);
  1184.         }
  1185.     }
  1186.     } else {                /* Byte to Unicode */
  1187.     if (xtu) {            /* TCS-to-UCS function */
  1188.         if (((tcsinfo[tcs].size > 128) && (uc.x_short & 0x80)) ||
  1189.         tcsinfo[tcs].size <= 128)
  1190.           uc.x_short = (*xtu)(uc.x_short);
  1191.     }
  1192.     if (fcs == FC_UCS2) {        /* And FCS is UCS-2 */
  1193.         /* Write out the bytes in the appropriate byte order */
  1194.         if (!offc && ucsbom) {    /* Beginning of file? */
  1195.         if ((rc = pnbyte((ucsorder ? 0xff : 0xfe),fn)) < 0) /* BOM */
  1196.           return(rc);
  1197.         if ((rc = pnbyte((ucsorder ? 0xfe : 0xff),fn)) < 0)
  1198.           return(rc);
  1199.         }
  1200.         if ((rc = pnbyte(uc.x_char[swapping],fn)) < 0)
  1201.           return(rc);
  1202.         if ((rc = pnbyte(uc.x_char[1-swapping],fn)) < 0)
  1203.           return(rc);
  1204.         return(2);
  1205.     } else if (fcs == FC_UTF8) {    /* Convert to UTF-8 */
  1206.         CHAR * buf = NULL;
  1207.         int i, count;
  1208.         if ((count = ucs2_to_utf8(uc.x_short,&buf)) < 1)
  1209.           return(-1);
  1210.         for (i = 0; i < count; i++)
  1211.           if ((rc = pnbyte(buf[i],fn)) < 0)
  1212.         return(rc);
  1213.         return(count);
  1214.     } else {
  1215.         debug(F100,"xpnbyte impossible combination","",0);
  1216.         return(-1);
  1217.     }
  1218.     }
  1219. #else
  1220. #ifdef KANJI
  1221. /*
  1222.   This almost, but not quite, duplicates the Kanji section above.
  1223.   There is no doubt a way to combine the sections more elegantly,
  1224.   but probably only at the expense of additional execution overhead.
  1225.   As matters stand, be careful to reflect any changes in this section
  1226.   to the other Kanji section above.
  1227. */
  1228.     if (tcs == TC_JEUC) {        /* Incoming Japanese EUC */
  1229.     int count = 0;
  1230.     switch (fcs) {            /* File character set */
  1231.       case FC_SHJIS:        /* Shift-JIS -- just output it */
  1232.         if (sj.x_char[byteorder])    /* But not high byte if zero */
  1233.           if ((rc = pnbyte((CHAR)sj.x_char[byteorder],fn)) < 0)
  1234.         return(rc);
  1235.         count++;
  1236.         if ((rc = pnbyte((CHAR)sj.x_char[1-byteorder],fn)) < 0)
  1237.           return(rc);
  1238.         count++;
  1239.         return(count);
  1240.       case FC_JEUC:            /* EUC-JP */
  1241.         eu.x_short = sj_to_eu(sj.x_short); /* Shift-JIS to EUC */
  1242.         debug(F001,"xpnbyte FC_JEUC eu","",eu.x_short);
  1243.         if (eu.x_short == 0xffff) { /* Bad */
  1244.         if ((rc = pnbyte(UNK,fn)) < 0)
  1245.           return(rc);
  1246.         return(1);
  1247.         } else {            /* Good */
  1248.         int count = 0;        /* Write high byte if not zero */
  1249.         if (eu.x_char[byteorder]) {
  1250.             if ((rc = pnbyte((CHAR)eu.x_char[byteorder],fn)) < 0)
  1251.               return(rc);
  1252.             count++;
  1253.         }
  1254.         /* Always write low byte */
  1255.         if ((rc = pnbyte((CHAR)eu.x_char[1-byteorder],fn)) < 0)
  1256.           return(rc);
  1257.         count++;
  1258.         return(count);
  1259.         }
  1260.         break;
  1261.  
  1262.       case FC_JIS7:            /* JIS-7 */
  1263.       case FC_JDEC:            /* DEC Kanji */
  1264.         eu.x_short = sj_to_eu(sj.x_short); /* Shift-JIS to EUC */
  1265.         if (eu.x_short == 0xffff) { /* Bad */
  1266.         debug(F001,"xpnbyte FC_JIS7 bad eu","",eu.x_short);
  1267.         if ((rc = pnbyte(UNK,fn)) < 0)
  1268.           return(rc);
  1269.         return(1);
  1270.         } else {            /* Good */
  1271.         int i;
  1272.         char a = eu.x_char[1-byteorder]; /* Low byte */
  1273.         debug(F001,"xpnbyte FC_JIS7 eu","",eu.x_short);
  1274.         if (eu.x_char[byteorder] == 0) { /* Roman */
  1275.             switch (jstate) {
  1276.               case 1:        /* Current state is Katakana */
  1277.             jbuf[0] = 0x0f;    /* SI */
  1278.             jbuf[1] = a;
  1279.             jx = 2;
  1280.             break;
  1281.               case 2:        /* Current state is Kanji */
  1282.             jbuf[0] = 0x1b;    /* ESC */
  1283.             jbuf[1] = 0x28;    /* ( */
  1284.             jbuf[2] = 0x4a;    /* J */
  1285.             jbuf[3] = a;
  1286.             jx = 4;
  1287.             break;
  1288.               default:        /* Current state is Roman */
  1289.             jbuf[0] = a;
  1290.             jx = 1;
  1291.             break;
  1292.             }
  1293.             jstate = 0;        /* New state is Roman */
  1294.         } else if (eu.x_char[byteorder] == 0x8e) { /* Kana */
  1295.             jx = 0;
  1296.             switch (jstate) {
  1297.               case 2:           /* from Kanji */
  1298.             jbuf[jx++] = 0x1b; /* ESC */
  1299.             jbuf[jx++] = 0x28; /* ( */
  1300.             jbuf[jx++] = 0x4a; /* J */
  1301.               case 0:           /* from Roman */
  1302.             jbuf[jx++] = 0x0e; /* SO */
  1303.               default:           /* State is already Kana*/
  1304.             jbuf[jx++] = (a & 0x7f); /* and the char */
  1305.             break;
  1306.             }
  1307.             jstate = 1;        /* New state is Katakana */
  1308.         } else {        /* Kanji */
  1309.             jx = 0;
  1310.             switch (jstate) {
  1311.               case 1:        /* Current state is Katakana */
  1312.             jbuf[jx++] = 0x0f; /* SI  */
  1313.               case 0:        /* Current state is Roman */
  1314.             jbuf[jx++] = 0x1b; /* ESC */
  1315.             jbuf[jx++] = 0x24; /* $   */
  1316.             jbuf[jx++] = 0x42; /* B   */
  1317.               default:        /* Current state is already Kanji */
  1318.             jbuf[jx++] = eu.x_char[byteorder] & 0x7f;
  1319.             jbuf[jx++] = eu.x_char[1-byteorder] & 0x7f;
  1320.             break;
  1321.             }
  1322.             jstate = 2;        /* Set state to Kanji */
  1323.         }
  1324.         for (i = 0; i < jx; i++) /* Output the result */
  1325.           if ((rc = pnbyte(jbuf[i],fn)) < 0)
  1326.             return(rc);
  1327.         return(jx);        /* Return its length */
  1328.         }
  1329.       default:
  1330.         if (sj.x_short < 0x80)
  1331.           return(sj.x_short);
  1332.         else
  1333.           return('?');
  1334.     }
  1335.     }
  1336. #endif /* KANJI */
  1337. #endif /* UNICODE */
  1338.     debug(F100,"xpnbyte BAD FALLTHRU","",0);
  1339.     return(-1);
  1340. }
  1341.  
  1342. #ifndef NOXFER
  1343.  
  1344. /*  D E C O D E  --  Kermit Data-packet decoder  */
  1345.  
  1346. int
  1347. #ifdef CK_ANSIC
  1348. decode(CHAR *buf, int (*fn)(char), int xlate)
  1349. #else
  1350. decode(buf,fn,xlate) register CHAR *buf; register int (*fn)(); int xlate;
  1351. #endif /* CK_ANSIC */
  1352. /* decode */ {
  1353.     register unsigned int a, a7, a8, b8; /* Various copies of current char */
  1354.     int t;                /* Int version of character */
  1355.     int ssflg;                /* Character was single-shifted */
  1356.     int ccpflg;                /* For Ctrl-unprefixing stats */
  1357.     int len;
  1358.     long z;
  1359.     CHAR c;
  1360. /*
  1361.   Catch the case in which we are asked to decode into a file that is not open,
  1362.   for example, if the user interrupted the transfer, but the other Kermit
  1363.   keeps sending.
  1364. */
  1365.     if ((cxseen || czseen || discard) && (fn == putfil))
  1366.       return(0);
  1367.  
  1368. #ifdef COMMENT
  1369. #ifdef CKTUNING
  1370.     if (binary && !parity)
  1371.       return(bdecode(buf,fn));
  1372. #endif /* CKTUNING */
  1373. #endif /* COMMENT */
  1374.     debug(F100,"DECODE","",0);
  1375.  
  1376.     xdbuf = buf;            /* Make global copy of pointer. */
  1377.     rpt = 0;                /* Initialize repeat count. */
  1378.  
  1379.     len = rln;                /* Number of bytes in data field */
  1380.     while (len > 0) {            /* Loop for each byte */
  1381.         a = *xdbuf++ & 0xff;        /* Get next character */
  1382.     len--;
  1383.     if (a == rptq && rptflg) {    /* Got a repeat prefix? */
  1384.         rpt = xunchar(*xdbuf++ & 0xFF); /* Yes, get the repeat count, */
  1385.         rptn += rpt;
  1386.         a = *xdbuf++ & 0xFF;    /* and get the prefixed character. */
  1387.         len -= 2;
  1388.     }
  1389.     b8 = lsstate ? 0200 : 0;    /* 8th-bit value from SHIFT-STATE */
  1390.     if (ebqflg && a == ebq) {    /* Have 8th-bit prefix? */
  1391.         b8 ^= 0200;            /* Yes, invert the 8th bit's value, */
  1392.         ssflg = 1;            /* remember we did this, */
  1393.         a = *xdbuf++ & 0xFF;    /* and get the prefixed character. */
  1394.         len--;
  1395.     } else ssflg = 0;
  1396.     ccpflg = 0;
  1397.     if (a == ctlq) {        /* If control prefix, */
  1398.         a  = *xdbuf++ & 0xFF;    /* get its operand */
  1399.         len--;
  1400.         a7 = a & 0x7F;        /* and its low 7 bits. */
  1401.         if ((a7 >= 0100 && a7 <= 0137) || a7 == '?') { /* Controllify */
  1402.         a = ctl(a);        /* if in control range. */
  1403.         a7 = a & 0x7F;
  1404.         ccpflg = 1;        /* Note that we did this */
  1405.         ccp++;            /* Count for stats */
  1406.         }
  1407.     } else a7 = a & 0x7f;        /* Not control quote */
  1408.     if (a7 < 32 || a7 == 127) {    /* Control character? */
  1409.         if (!ccpflg) ccu++;        /* A bare one, count it */
  1410.         if (lscapu) {        /* If doing locking shifts... */
  1411.         if (lsstate)        /* If SHIFTED */
  1412.           a8 = (a & ~b8) & 0xFF; /* Invert meaning of 8th bit */
  1413.         else            /* otherwise */
  1414.           a8 = a | b8;        /* OR in 8th bit */
  1415.         /* If we're not in a quoted sequence */
  1416.         if (!lsquote && (!lsstate || !ssflg)) {
  1417.             if (a8 == DLE) {    /* Check for DLE quote */
  1418.             lsquote = 1;    /* prefixed by single shift! */
  1419.             continue;
  1420.             } else if (a8 == SO) { /* Check for Shift-Out */
  1421.             lsstate = 1;    /* SHIFT-STATE = SHIFTED */
  1422.             continue;
  1423.             } else if (a8 == SI) { /* or Shift-In */
  1424.             lsstate = 0;    /* SHIFT-STATE = UNSHIFTED */
  1425.             continue;
  1426.             }
  1427.         } else lsquote = 0;
  1428.         }
  1429.     }
  1430.     a |= b8;            /* OR in the 8th bit */
  1431.     if (rpt == 0) rpt = 1;        /* If no repeats, then one */
  1432. #ifndef NOCSETS
  1433.     if (!binary) {            /* If in text mode, */
  1434.         if (tcharset != TC_UCS2) {
  1435.         if (feol && a == CR)    /* Convert CRLF to newline char */
  1436.           continue;
  1437.         if (feol && a == LF)
  1438.           a = feol;
  1439.         }
  1440.         if (xlatype == XLA_BYTE)    /* Byte-for-byte - do it now */
  1441.           if (xlate && rx) a = (*rx)((CHAR) a);
  1442.         }
  1443. #endif /* NOCSETS */
  1444.     /* (PWP) Decoding speedup via buffered output and a macro... */
  1445.     if (fn == putfil) {
  1446.         for (; rpt > 0; rpt--) {    /* Output the char RPT times */
  1447. #ifdef CALIBRATE
  1448.         if (calibrate) {
  1449.             ffc++;
  1450.             continue;
  1451.         }
  1452. #endif /* CALIBRATE */
  1453.  
  1454. /* Note: The Unicode and Kanji sections can probably be combined now; */
  1455. /* the Unicode method (xpnbyte()) covers Kanji too. */
  1456.  
  1457. #ifdef UNICODE
  1458.         if (!binary && xlatype == XLA_UNICODE)
  1459.           t = xpnbyte((unsigned)((unsigned)a & 0xff),
  1460.                   tcharset,
  1461.                   fcharset,
  1462.                   fn
  1463.                   );
  1464.         else
  1465. #endif /* UNICODE */
  1466. #ifdef KANJI
  1467.         if (!binary && tcharset == TC_JEUC &&
  1468.             fcharset != FC_JEUC) { /* Translating from J-EUC */
  1469.             if (!ffc) xkanjf();
  1470.             if (xkanji(a,fn) < 0)  /* to something else? */
  1471.               return(-1);
  1472.             else t = 1;
  1473.         } else
  1474. #endif /* KANJI */
  1475.         {
  1476. #ifdef OS2
  1477.               if (xflg && !remfile) { /* Write to virtual screen */
  1478.               char _a;
  1479.               _a = a & fmask;
  1480.               t = conoc(_a);
  1481.               if (t < 1)
  1482.                 t = -1;
  1483.               } else
  1484. #endif /* OS2 */
  1485.             t = zmchout(a & fmask); /* zmchout is a macro */
  1486.         }
  1487.         if (t < 0) {
  1488.             debug(F101,"decode write errno","",errno);
  1489.             return(-1);
  1490.         }
  1491. #ifdef UNICODE
  1492.         if (xlatype != XLA_UNICODE || binary) {
  1493.             ffc++;        /* Count the character */
  1494.             if (docrc && !xflg && !remfile) { /* Update file CRC */
  1495.             c = a;        /* Force conversion to unsigned char */
  1496.             z = crc16 ^ (long)c;
  1497.             crc16 = (crc16 >> 8) ^
  1498.               (crcta[(z & 0xF0) >> 4] ^ crctb[z & 0x0F]);
  1499.             }
  1500.         }
  1501. #endif /* UNICODE */
  1502.         }
  1503.     } else {            /* Output to something else. */
  1504.         a &= fmask;            /* Apply file mask */
  1505.         for (; rpt > 0; rpt--) {    /* Output the char RPT times */
  1506. #ifdef CALIBRATE
  1507.         if (calibrate) {
  1508.             ffc++;
  1509.             continue;
  1510.         }
  1511. #endif /* CALIBRATE */
  1512.         if ((*fn)((char) a) < 0) return(-1); /* Send to output func. */
  1513.         }
  1514.     }
  1515. #ifdef CK_CTRLZ
  1516.     lastchar = a;
  1517. #endif /* CK_CTRLZ */
  1518.     }
  1519.     return(0);
  1520. }
  1521.  
  1522. /*  G E T P K T -- Fill a packet data field  */
  1523.  
  1524. /*
  1525.   Gets characters from the current source -- file or memory string.
  1526.   Encodes the data into the packet, filling the packet optimally.
  1527.   Set first = 1 when calling for the first time on a given input stream
  1528.   (string or file).
  1529.  
  1530.   Call with:
  1531.     bufmax -- current send-packet size
  1532.     xlate  -- flag: 0 to skip character-set translation, 1 to translate
  1533.  
  1534.   Uses global variables:
  1535.     t     -- current character.
  1536.     first -- flag: 1 to start up, 0 for input in progress, -1 for EOF.
  1537.     next  -- next character (not used any more).
  1538.     data  -- pointer to the packet data buffer.
  1539.     size  -- number of characters in the data buffer.
  1540.     memstr - flag that input is coming from a memory string instead of a file.
  1541.     memptr - pointer to string in memory.
  1542.     (*sx)()  character set translation function
  1543.  
  1544.   Returns:
  1545.     The size as value of the function, and also sets global "size",
  1546.     and fills (and null-terminates) the global data array.
  1547.     Returns:
  1548.       0 on EOF.
  1549.      -1 on fatal (internal) error.
  1550.      -3 on timeout (e.g. when reading data from a pipe).
  1551.  
  1552.   Rewritten by Paul W. Placeway (PWP) of Ohio State University, March 1989.
  1553.   Incorporates old getchx() and encode() inline to reduce function calls,
  1554.   uses buffered input for much-improved efficiency, and clears up some
  1555.   confusion with line termination (CRLF vs LF vs CR).
  1556.  
  1557.   Rewritten again by Frank da Cruz to incorporate locking shift mechanism,
  1558.   May 1991.  And again in 1998 for efficiency, etc, with a separate
  1559.   bgetpkt() split out for binary-mode no-parity transfers.
  1560. */
  1561.  
  1562. /*
  1563.   Note: Separate Kanji support dates from circa 1991 and now (1999) can most
  1564.   likely be combined with the the Unicode support: the xgnbyte()/xpnbyte()
  1565.   mechanism works for both Unicode and Kanji.
  1566. */
  1567. #ifdef KANJI
  1568. int
  1569. kgetf(
  1570. #ifdef CK_ANSIC
  1571.       VOID
  1572. #endif /* CK_ANSIC */
  1573.       ) {
  1574.     if (funcstr)
  1575.       return((*funcptr)());
  1576.     else
  1577.       return(zminchar());
  1578. }
  1579.  
  1580. int
  1581. kgetm(
  1582. #ifdef CK_ANSIC
  1583.       VOID
  1584. #endif /* CK_ANSIC */
  1585.       ) {
  1586.     int x;
  1587.     if ((x = *memptr++)) return(x);
  1588.     else return(-1);
  1589. }
  1590. #endif /* KANJI */
  1591.  
  1592. /*
  1593.   Lookahead function to decide whether locking shift is worth it.  Looks at
  1594.   the next four input characters to see if all of their 8th bits match the
  1595.   argument.  Call with 0 or 0200.  Returns 1 on match, 0 if they don't match.
  1596.   If we don't happen to have at least 4 more characters waiting in the input
  1597.   buffer, returns 1.  Note that zinptr points two characters ahead of the
  1598.   current character because of repeat-count lookahead.
  1599. */
  1600. int
  1601. lslook(b) unsigned int b; {        /* Locking Shift Lookahead */
  1602.     int i;
  1603.     if (zincnt < 3)            /* If not enough chars in buffer, */
  1604.       return(1);            /* force shift-state switch. */
  1605.     b &= 0200;                /* Force argument to proper form. */
  1606.     for (i = -1; i < 3; i++)        /* Look at next 5 characters to */
  1607.       if (((*(zinptr+i)) & 0200) != b)    /* see if all their 8th bits match.  */
  1608.     return(0);            /* They don't. */
  1609.     return(1);                /* They do. */
  1610. }
  1611.  
  1612. /* Routine to compute maximum data length for packet to be filled */
  1613.  
  1614. int
  1615. maxdata() {                /* Get maximum data length */
  1616.     int n, len;
  1617.     debug(F101,"maxdata spsiz 1","",spsiz);
  1618.     if (spsiz < 0)            /* How could this happen? */
  1619.       spsiz = DSPSIZ;
  1620.     debug(F101,"maxdata spsiz 2","",spsiz);
  1621.     n = spsiz - 5;            /* Space for Data and Checksum */
  1622.     if (n > 92 && n < 96) n = 92;    /* "Short" Long packets don't pay */
  1623.     if (n > 92 && lpcapu == 0)        /* If long packets needed, */
  1624.       n = 92;                /* make sure they've been negotiated */
  1625.     len = n - bctl;            /* Space for data */
  1626.     if (n > 92) len -= 3;        /* Long packet needs header chksum */
  1627.     debug(F101,"maxdata len 1","",len);
  1628.     if (len < 0) len = 10;
  1629.     debug(F101,"maxdata len 2","",len);
  1630.     return(len);
  1631. }
  1632.  
  1633. static CHAR leftover[9] = { '\0','\0','\0','\0','\0','\0','\0','\0','\0' };
  1634. static int nleft = 0;
  1635.  
  1636. #ifdef CKTUNING
  1637. /*
  1638.   When CKTUNING is defined we use this special trimmed-down version of getpkt
  1639.   to speed up binary-mode no-parity transfers.  When CKTUNING is not defined,
  1640.   or for text-mode or parity transfers, we use the regular getpkt() function.
  1641.   Call just like getpkt() but test first for transfer mode and parity.  NOTE:
  1642.   This routine is only to be called when sending a real file -- not for
  1643.   filenames, server responses, etc, because it only reads from the input file.
  1644.   See getpkt() for more detailed commentary.
  1645. */
  1646. static int
  1647. bgetpkt(bufmax) int bufmax; {
  1648.     register CHAR rt = t, rnext;
  1649.     register CHAR *dp, *odp, *p1, *p2;
  1650.     register int x = 0, a7;
  1651.  
  1652.     CHAR xxrc, xxcq;            /* Pieces of prefixed sequence */
  1653.  
  1654.     long z;                /* A long worker (for CRC) */
  1655.  
  1656.     if (!binary || parity || memstr)    /* JUST IN CASE caller didn't test */
  1657.       return(getpkt(bufmax,!binary));
  1658.  
  1659.     if (!data) {
  1660.     debug(F100,"SERIOUS ERROR: bgetpkt data == NULL","",0);
  1661.     return(-1);
  1662.     }
  1663.     dp = data;                /* Point to packet data buffer */
  1664.     size = 0;                /* And initialize its size */
  1665.     bufmax = maxdata();            /* Get maximum data length */
  1666.  
  1667. #ifdef DEBUG
  1668.     if (deblog)
  1669.       debug(F101,"bgetpkt bufmax","",bufmax);
  1670. #endif /* DEBUG */
  1671.  
  1672.     if (first == 1) {            /* If first character of this file.. */
  1673.     ffc = (CK_OFF_T)0;        /* reset file character counter */
  1674. #ifdef COMMENT
  1675. /* Moved to below */
  1676.     first = 0;            /* Next character won't be first */
  1677. #endif /* COMMENT */
  1678.     *leftover = '\0';        /* Discard any interrupted leftovers */
  1679.     nleft = 0;
  1680.  
  1681.     /* Get first character of file into rt, watching out for null file */
  1682.  
  1683. #ifdef CALIBRATE
  1684.     if (calibrate) {
  1685. #ifdef NORANDOM
  1686.         rt = 17;
  1687. #else
  1688.         rt = cal_a[rand() & 0xff];
  1689. #endif /* NORANDOM */
  1690.         first = 0;
  1691.     } else
  1692. #endif /* CALIBRATE */
  1693.  
  1694.     if ((x = zminchar()) < 0) {    /* EOF or error */
  1695.         if (x == -3) {        /* Timeout. */
  1696.         size = (dp - data);
  1697.         debug(F101,"bgetpkt timeout size","",size);
  1698.         return((size == 0) ? x : size);
  1699.         }
  1700.         first = -1;
  1701.         size = 0;
  1702.         if (x == -2) {        /* Error */
  1703.         debug(F100,"bgetpkt: input error","",0);
  1704.         cxseen = 1;        /* Interrupt the file transfer */
  1705.         } else {
  1706.         debug(F100,"bgetpkt empty file","",0);
  1707.         }
  1708.         return(0);
  1709.     }
  1710.     first = 0;            /* Next char will not be the first */
  1711.     ffc++;                /* Count a file character */
  1712.     rt = (CHAR) x;            /* Convert int to char */
  1713.     if (docrc && (what & W_SEND)) {    /* Accumulate file crc */
  1714.         z = crc16 ^ (long)rt;
  1715.         crc16 = (crc16 >> 8) ^
  1716.           (crcta[(z & 0xF0) >> 4] ^ crctb[z & 0x0F]);
  1717.     }
  1718.     rt &= fmask;            /* Apply SET FILE BYTESIZE mask */
  1719.  
  1720.     } else if (first == -1 && nleft == 0) { /* EOF from last time */
  1721.  
  1722.         return(size = 0);
  1723.     }
  1724. /*
  1725.   Here we handle characters that were encoded for the last packet but
  1726.   did not fit, and so were saved in the "leftover" array.
  1727. */
  1728.     if (nleft) {
  1729.     for (p1 = leftover; nleft > 0; nleft--) /* Copy leftovers */
  1730.       *dp++ = *p1++;
  1731.     *leftover = '\0';        /* Delete leftovers */
  1732.     nleft = 0;
  1733.     }
  1734.     if (first == -1)            /* Handle EOF */
  1735.       return(size = (dp - data));
  1736.  
  1737. /* Now fill up the rest of the packet. */
  1738.  
  1739.     rpt = 0;                /* Initialize character repeat count */
  1740.  
  1741.     while (first > -1) {        /* Until EOF... */
  1742. #ifdef CALIBRATE
  1743.     if (calibrate) {        /* We generate our own "file" */
  1744.         if (ffc >= calibrate) {    /* EOF */
  1745.         first = -1;
  1746.         ffc--;
  1747.         } else {            /* Generate next character */
  1748.         if (cal_j > CAL_M * ffc)
  1749.           cal_j = cal_a[ffc & 0xff];
  1750.         x = (unsigned)cal_a[(cal_j & 0xff)];
  1751.         if (x == rt) x ^= 2;
  1752.         }
  1753.         ffc++;
  1754.         cal_j += (unsigned int)(ffc + CAL_O);
  1755.     } else
  1756. #endif /* CALIBRATE */
  1757.     if ((x = zminchar()) < 0) {    /* Check for EOF */
  1758.         if (x == -3) {        /* Timeout. */
  1759.         t = rt;
  1760.         size = (dp-data);
  1761.         debug(F101,"bgetpkt timeout size","",size);
  1762.         return((size == 0) ? x : size);
  1763.         }
  1764.         first = -1;            /* Flag eof for next time. */
  1765.         if (x == -2) cxseen = 1;    /* If error, cancel this file. */
  1766.     } else {
  1767.         ffc++;            /* Count the character */
  1768.         if (docrc && (what & W_SEND)) { /* Accumulate file crc */
  1769.         z = crc16 ^ (long)((CHAR)x & 0xff);
  1770.         crc16 = (crc16 >> 8) ^
  1771.           (crcta[(z & 0xF0) >> 4] ^ crctb[z & 0x0F]);
  1772.         }
  1773.     }
  1774.     rnext = (CHAR) (x & fmask);    /* Apply file mask */
  1775. /*
  1776.   At this point, the character we just read is in rnext,
  1777.   and the character we are about to encode into the packet is in rt.
  1778. */
  1779.     odp = dp;            /* Remember where we started. */
  1780.     xxrc = xxcq = NUL;        /* Clear these. */
  1781. /*
  1782.   Now encode the character according to the options that are in effect:
  1783.     ctlp[]: whether this control character needs prefixing.
  1784.     rptflg: repeat counts enabled.
  1785.     Other options don't apply in this routine.
  1786. */
  1787.     if (rptflg && (rt == rnext) && (first == 0)) { /* Got a run... */
  1788.         if (++rpt < 94) {        /* Below max, just count */
  1789.         continue;        /* go back and get another */
  1790.         } else if (rpt == 94) {    /* Reached max, must dump */
  1791.         xxrc = (CHAR) tochar(rpt); /* Put the repeat count here */
  1792.         rptn += rpt;        /* Accumulate it for statistics */
  1793.         rpt = 0;        /* And reset it */
  1794.         }
  1795.     } else if (rpt > 0) {        /* End of run */
  1796.         xxrc = (CHAR)tochar(++rpt); /* The count */
  1797.         rptn += rpt;        /* For stats */
  1798.         rpt = 0;            /* Reset repeat count */
  1799.     }
  1800.     a7 = rt & 0177;            /* Get low 7 bits of character */
  1801.     if (
  1802. #ifdef CK_SPEED
  1803.         ctlp[(unsigned)(rt & 0xff)]    /* Lop off any "sign" extension */
  1804. #else
  1805.         (a7 < SP) || (a7 == DEL)
  1806. #endif /* CK_SPEED */
  1807.         ) {                /* Do control prefixing if necessary */
  1808.         xxcq = myctlq;        /* The prefix */
  1809.         ccp++;            /* Count it */
  1810.         rt = (CHAR) ctl(rt);    /* Uncontrollify the character */
  1811.     }
  1812. #ifdef CK_SPEED
  1813.     else if ((a7 < SP) || (a7 == DEL)) /* Count an unprefixed one */
  1814.       ccu++;
  1815. #endif /* CK_SPEED */
  1816.  
  1817.     if (a7 == myctlq)        /* Always prefix the control prefix */
  1818.       xxcq = myctlq;
  1819.  
  1820.     if ((rptflg) && (a7 == rptq))    /* If it's the repeat prefix, */
  1821.       xxcq = myctlq;        /* prefix it if doing repeat counts */
  1822.  
  1823. /* Now construct the prefixed sequence */
  1824.  
  1825.     if (xxrc) {            /* Repeat count */
  1826. #ifdef COMMENT
  1827.         if (xxrc == (CHAR) '"' && !xxcq) { /* 2 in a row & not prefixed */
  1828.         *dp++ = rt;        /* So just do this */
  1829.         } else {            /* More than two or prefixed */
  1830.         *dp++ = (CHAR) rptq; *dp++ = xxrc; /* Emit repeat sequence */
  1831.         }
  1832. #else                    /* CHECK THIS */
  1833.         if (xxrc == (CHAR) '"' && !xxcq) { /* 2 in a row & not prefixed */
  1834.                 if (dp == data) {
  1835.                     *dp++ = rt;        /* So just do this */
  1836.                 } else if (*(dp-1) == rt) {
  1837.                     *dp++ = (CHAR) rptq;
  1838.             *dp++ = xxrc;    /* Emit repeat sequence */
  1839.                 } else {
  1840.                     *dp++ = rt;        /* So just do this */
  1841.                 }
  1842.         } else {            /* More than two or prefixed */
  1843.         *dp++ = (CHAR) rptq;
  1844.         *dp++ = xxrc;        /* Emit repeat sequence */
  1845.         }
  1846. #endif /* COMMENT */
  1847.     }
  1848.     if (xxcq) { *dp++ = myctlq; }    /* Control prefix */
  1849.     *dp++ = rt;            /* Finally, the character itself */
  1850.     rt = rnext;            /* Next character is now current. */
  1851.  
  1852. /* Done encoding the character.  Now take care of packet buffer overflow. */
  1853.  
  1854.     size = dp - data;        /* How many bytes we put in buffer. */
  1855.     if (size >= bufmax) {        /* If too big, save some for next. */
  1856.         *dp = '\0';            /* Mark the end. */
  1857.         if (size > bufmax) {    /* if packet is overfull */
  1858.         /* Copy the part that doesn't fit into the leftover buffer, */
  1859.         /* taking care not to split a prefixed sequence. */
  1860.         int i;
  1861.         nleft = dp - odp;
  1862.         p1 = leftover;
  1863.         p2 = odp;
  1864.         for (i = 0; i < nleft; i++)
  1865.           *p1++ = *p2++;
  1866.         size = odp - data;    /* Return truncated packet. */
  1867.         *odp = '\0';        /* Mark the new end */
  1868.         }
  1869.         t = rt;            /* Save for next time */
  1870.         return(size);
  1871.     }
  1872.     }                    /* Otherwise, keep filling. */
  1873.     size = dp - data;            /* End of file */
  1874.     *dp = '\0';                /* Mark the end of the data. */
  1875.     return(size);             /* Return partially filled last packet. */
  1876. }
  1877. #endif /* CKTUNING */
  1878.  
  1879. VOID
  1880. dofilcrc(c) int c; {            /* Accumulate file crc */
  1881.     long z;
  1882.     z = crc16 ^ (long)c;
  1883.     crc16 = (crc16 >> 8) ^
  1884.       (crcta[(z & 0xF0) >> 4] ^ crctb[z & 0x0F]);
  1885. }
  1886.  
  1887. /* For SENDing from an array... */
  1888.  
  1889. int
  1890. agnbyte() {                /* Get next byte from array */
  1891. #ifndef NOSPL
  1892.     char c;
  1893.     static int save = 0;        /* For CRLF */
  1894.     static char ** ap = NULL;        /* Array pointer */
  1895.     static char * p = NULL;        /* Character pointer */
  1896.     static int i = 0, n = 0;        /* Array index and limit */
  1897.     extern int a_dim[];            /* Array dimension */
  1898.  
  1899.     if (!ap) {                /* First time thru */
  1900.     ap = sndarray;            /* Set up array pointers */
  1901.     if (!ap || (i = sndxlo) > a_dim[sndxin]) {
  1902.         sndarray = NULL;
  1903.         ap = NULL;
  1904.         return(-1);
  1905.     }
  1906.     p = ap[i];            /* Point to first element in range */
  1907.     n = sndxhi;            /* Index of last element in range */
  1908.     if (sndxhi > a_dim[sndxin])    /* Adjust if necessary */
  1909.       n = a_dim[sndxin];
  1910.     }
  1911.     if (save) {                /* If anything saved */
  1912.     c = save;            /* unsave it */
  1913.     save = 0;            /* and return it */
  1914.     return(c & 0xff);
  1915.     }
  1916.     if (i > n) {            /* No more elements */
  1917.     sndarray = NULL;
  1918.     ap = NULL;
  1919.     return(-1);
  1920.     }
  1921.     if (!p)                /* Source pointer is NULL */
  1922.       c = NUL;                /* this means an empty line */
  1923.     else                /* Source pointer not NULL */
  1924.       c = *p++;                /* Next char */
  1925.     if (!c) {                /* Char is empty? */
  1926.     if (!binary) {            /* Text: end of line. */
  1927.         if (feol) {            /* Supply NL */
  1928.         c = feol;
  1929.         } else {            /* or CRLF */
  1930.         save = LF;
  1931.         c = CR;
  1932.         }
  1933.         p = ap[++i];
  1934.         return(c & 0xff);
  1935.     }
  1936.     while (i++ < n) {        /* Binary - get next element */
  1937.         p = ap[i];
  1938.         if (!p)            /* Empty line? */
  1939.           continue;            /* Ignore it and get another */
  1940.         c = *p++;            /* Get next char */
  1941.         if (!c)            /* Emtpy char? */
  1942.           continue;            /* Ignore it and get another */
  1943.         return(c & 0xff);        /* Not empty - return it */
  1944.     }
  1945.     sndarray = NULL;
  1946.     ap = NULL;
  1947.     return(-1);            /* Done */
  1948.     }
  1949.     return(c & 0xff);            /* Char is not empty */
  1950. #else
  1951.     sndarray = NULL;
  1952.     return(-1);
  1953. #endif /* NOSPL */
  1954. }
  1955. #endif /* NOXFER */
  1956.  
  1957. #ifndef NOCSETS
  1958. static CHAR xlabuf[32] = { 0, 0, 0, 0, 0, 0, 0, 0 };
  1959. static int xlacount = 0;
  1960. static int xlaptr = 0;
  1961. /* static USHORT lastucs2 = 0; */
  1962.  
  1963. /*
  1964.   X G N B Y T E --  Get next translated byte from the input file.
  1965.  
  1966.   Returns the next byte that is to be put into the packet, already translated.
  1967.   This isolates getpkt() from having to know anything about translation,
  1968.   single- vs multibyte character sets, one-to-many vs many-to-one, etc, but it
  1969.   has rather high overhead, so don't call it unless you know translation is
  1970.   needed to or from Unicode, Japanese, or other multibyte character set.
  1971.  
  1972.   Call with:
  1973.     fcs:  File character set (source, file we are reading from)
  1974.     tcs:  Target character set (use an FC_xxx code, not a TC_xxx code)
  1975.   Returns:
  1976.     >= 0: A translated byte suitable for writing.
  1977.     <  0: Fatal error (such as EOF on input source).
  1978.   As of Sat Sep  7 18:37:41 2002:  
  1979.     When the output character-set is UCS-2, bytes are ALWAYS returned in
  1980.     big-endian order (previously they could also be returned in LE order
  1981.     under certain conditions, which was just way too confusing).
  1982. */
  1983. int
  1984. #ifdef CK_ANSIC
  1985. xgnbyte(int tcs, int fcs, int (*fn)(void))
  1986. #else /* CK_ANSIC */
  1987. xgnbyte(tcs,fcs,fn) int tcs, fcs, (*fn)();
  1988. #endif /* CK_ANSIC */
  1989. /* xgnbyte */ {
  1990.     _PROTOTYP( int (*xx), (USHORT) ) = NULL;
  1991.     int haveuc = 0;            /* Flag for have Unicode character */
  1992. #ifdef KANJI
  1993.     int havesj = 0;            /* Have Shift-JIS character */
  1994.     int haveeu = 0;            /* Have EUC-JP character */
  1995. #endif /* KANJI */
  1996.     int rc = -1, x = 0, flag = 0;
  1997.     int utferror = 0;
  1998.     int eolflag = 0;
  1999.     unsigned int xc, thischar;
  2000.     static int swapping = 0;
  2001.     CHAR rt;
  2002.     /* USHORT ch; */
  2003. #ifdef UNICODE
  2004.     union ck_short uc;
  2005. #endif /* UNICODE */
  2006. #ifdef KANJI
  2007.     union ck_short sj, eu;        /* Shift-JIS character */
  2008. #endif /* KANJI */
  2009.  
  2010. #ifdef KANJI
  2011.     sj.x_short = 0;
  2012. #endif /* KANJI */
  2013.  
  2014. #ifdef DEBUG
  2015.     if (deblog && !ffc) {
  2016.     debug(F101,"xgnbyte initial swap","",swapping);
  2017.     }
  2018. #endif /* DEBUG */
  2019.  
  2020.     if (xlacount-- > 0) {        /* We already have some */
  2021.     x = xlabuf[xlaptr++];
  2022.     debug(F001,"xgnbyte from buf","",x);
  2023.     return(x);
  2024.     }
  2025.     if (xlatype != XLA_NONE) {        /* Not not translating... */
  2026.     haveuc = 0;
  2027. #ifdef UNICODE
  2028.     if (fcs == FC_UCS2) {        /* UCS-2: Read two bytes */
  2029.         if (!ffc)            /* Beginning of file? */
  2030.           swapping = 0;        /* Reset byte-swapping flag */
  2031.         uc.x_short = 0;
  2032.       bomskip:
  2033.         x = fn ? (*fn)() : zminchar(); /* Get first byte */
  2034.         debug(F001,"zminchar swapping","",swapping);
  2035.         debug(F001,"zminchar C0","",x);
  2036.         flag = 1;            /* Remember we called zminchar() */
  2037.         if (x > -1) {        /* Didn't fail */
  2038.         ffc++;            /* Count a file byte */
  2039.         uc.x_char[swapping] = x & 0xff;
  2040. #ifndef NOXFER
  2041.         if (docrc && (what & W_SEND))
  2042.           dofilcrc(x);
  2043. #endif /* NOXFER */
  2044.         x = fn ? (*fn)() : zminchar(); /* Get second byte */
  2045.         if (x > -1) {        /* If didn't fail */
  2046.             debug(F001,"zminchar C1","",x);
  2047.             ffc++;        /* count another file byte */
  2048.             uc.x_char[1-swapping] = x & 0xff;
  2049.             haveuc = 1;        /* And remember we have Unicode */
  2050. #ifndef NOXFER
  2051.             if (docrc && (what & W_SEND))
  2052.               dofilcrc(x);
  2053. #endif /* NOXFER */
  2054.             if (ffc == (CK_OFF_T)2) { /* Second char of file */
  2055.             debug(F001,"xgnbyte 1st UCS2","",uc.x_short);
  2056.             debug(F111,"xgnbyte fileorder","A",fileorder);
  2057.             if (fileorder < 0) /* Byte order of this file */
  2058.               fileorder = ucsorder;    /* Default is ucsorder */
  2059.             if (fileorder > 1)
  2060.               fileorder = 1;
  2061.             debug(F111,"xgnbyte fileorder","B",fileorder);
  2062.             if (uc.x_short == (USHORT)0xfeff) {
  2063.                 swapping = 0;
  2064.                 debug(F101,
  2065.                   "xgnbyte UCS2 goodbom swap","",swapping);
  2066.                 fileorder = byteorder; /* Note: NOT 0 */
  2067.                 goto bomskip;
  2068.             } else if (uc.x_short == (USHORT)0xfffe) {
  2069.                 swapping = 1;
  2070.                 debug(F101,
  2071.                   "xgnbyte UCS2 badbom swap","",swapping);
  2072.                 fileorder = (1 - byteorder); /* Note: NOT 1 */
  2073.                 goto bomskip;
  2074.             } else if ((byteorder && !fileorder) || /* No BOM */
  2075.                    (!byteorder && fileorder > 0)) {
  2076.                 /* fileorder might have been set by scanfile() */
  2077.                 CHAR c;
  2078.                 c = uc.x_char[0];
  2079.                 uc.x_char[0] = uc.x_char[1];
  2080.                 uc.x_char[1] = c;
  2081.                 swapping = 1;
  2082.                 debug(F111,"xgnbyte UCS2 noBOM swap","A",swapping);
  2083.             } else {
  2084.                 swapping = 0;
  2085.                 debug(F111,"xgnbyte UCS2 noBOM swap","B",swapping);
  2086.             }
  2087.             debug(F111,"xgnbyte fileorder","C",fileorder);
  2088.             }
  2089.         } else
  2090.           return(x);
  2091.         } else
  2092.           return(x);
  2093.         debug(F001,"xgnbyte UCS2","",uc.x_short);
  2094.  
  2095.     } else if (fcs == FC_UTF8) {    /* File is UTF-8 */
  2096.         CHAR ch = 0;        /* Data types needed for API... */
  2097.         USHORT * us = NULL;
  2098.         uc.x_short = 0;
  2099.         flag = 1;            /* We (will) have called zminchar() */
  2100.         /* Read source bytes */
  2101.         while ((x = fn ? (*fn)() : zminchar()) > -1) {
  2102.         ffc++;            /* Got a byte - count it */
  2103. #ifndef NOXFER
  2104.         if (docrc && (what & W_SEND))
  2105.           dofilcrc(x);
  2106. #endif /* NOXFER */
  2107.         ch = x;
  2108.         rc = utf8_to_ucs2(ch,&us); /* Convert to UCS-2 */
  2109.         if (rc == 0) {        /* Done */
  2110.             uc.x_short = *us;
  2111.             haveuc = 1;
  2112.             break;
  2113.         } else if (rc < 0) {    /* Error */
  2114.             utferror = 1;
  2115.             debug(F101,"xgnbyte UTF-8 input error","",rc);
  2116.             haveuc = 1;
  2117.             uc.x_short = *us;
  2118.             break;
  2119.         }
  2120.         }
  2121.         if (x < 0)
  2122.           return(x);
  2123.         debug(F001,"xgnbyte UTF8->UCS2","",uc.x_short);
  2124.     }
  2125. #endif /* UNICODE */
  2126.  
  2127. #ifdef KANJI
  2128. #ifdef UNICODE
  2129.     else
  2130. #endif /* UNICODE */
  2131.       if (fcsinfo[fcs].alphabet == AL_JAPAN) { /* Japanese source file */
  2132.         int c7, x, y;
  2133.         if (fcs == FC_JIS7) {    /* If file charset is JIS-7 */
  2134.         if (!ffc)        /* If first byte of file */
  2135.           j7init();        /* Initialize JIS-7 parser */
  2136.         x = getj7();        /* Get a JIS-7 byte */
  2137.         } else            /* Otherwise */
  2138.           x = fn ? (*fn)() : zminchar(); /* Just get byte */
  2139.         if (x < 0) {        /* Propogate EOF or error */
  2140.         debug(F100,"XGNBYTE EOF","",0);
  2141.         return(x);
  2142.         }
  2143.         debug(F001,"XGNBYTE x","",x);
  2144.         ffc++;            /* Count */
  2145. #ifndef NOXFER
  2146.         if (docrc && (what & W_SEND)) dofilcrc(x); /* Do CRC */
  2147. #endif /* NOXFER */
  2148.         switch (fcs) {        /* What next depends on charset */
  2149.           case FC_SHJIS:        /* Shift-JIS */
  2150.         if ((x <= 0x80) ||    /* Any 7-bit char... */
  2151.             (x >= 0xa0 && x <= 0xdf)) { /* or halfwidth Katakana */
  2152.             sj.x_short = (USHORT) x;    /* we read one byte. */
  2153.         } else {        /* Anything else */
  2154.             if ((y = fn ? (*fn)() : zminchar()) < 0) /* get another */
  2155.               return(y);
  2156. #ifndef NOXFER
  2157.             if (docrc && (what & W_SEND)) dofilcrc(y);
  2158. #endif /* NOXFER */
  2159.             ffc++;
  2160.             sj.x_char[byteorder] = (CHAR) x;
  2161.             sj.x_char[1-byteorder] = (CHAR) y;
  2162.         }
  2163.         break;
  2164.  
  2165.           case FC_JIS7:        /* JIS-7 */
  2166.           case FC_JDEC:        /* DEC Kanji */
  2167.           case FC_JEUC:        /* EUC-JP */
  2168.         if ((x & 0x80) == 0) {    /* Convert to Shift-JIS */
  2169.             sj.x_short = (USHORT) x; /* C0 or G0: one byte */
  2170.             eu.x_short = (USHORT) x;
  2171.             haveeu = 1;
  2172.         } else {
  2173.             c7 = x & 0x7f;
  2174.             if (c7 > 0x20 && c7 < 0x7f) { /* Kanji: two bytes */
  2175.             if ((y = (fcs == FC_JEUC) ?
  2176.                  (fn ? (*fn)() : zminchar()) :
  2177.                  getj7()    /* ^^^ */
  2178.                  ) < 0)
  2179.               return(y);
  2180.             ffc++;
  2181. #ifndef NOXFER
  2182.             if (docrc && (what & W_SEND)) dofilcrc(y);
  2183. #endif /* NOXFER */
  2184.             eu.x_char[byteorder] = (CHAR) x;
  2185.             eu.x_char[1-byteorder] = (CHAR) y;
  2186.             sj.x_short = eu_to_sj(eu.x_short);
  2187.             haveeu = 1;
  2188.             } else if (x == 0x8e) { /* SS2 Katakana prefix: 2 bytes */
  2189.             if ((y = (fcs == FC_JIS7) ?
  2190.                  getj7() :    /* ^^^ */
  2191.                  (fn ? (*fn)() : zminchar())
  2192.                  ) < 0)
  2193.               return(y);
  2194.             ffc++;
  2195. #ifndef NOXFER
  2196.             if (docrc && (what & W_SEND)) dofilcrc(y);
  2197. #endif /* NOXFER */
  2198.             sj.x_short = y | 0x80;
  2199.             debug(F001,"XGNBYTE KANA SJ","",sj.x_short);
  2200.             } else {
  2201.             /* Something that translates to U+FFFD */
  2202.             sj.x_short = UNKSJIS;
  2203.             }
  2204.         }
  2205.         break;
  2206.         }
  2207.         havesj = 1;            /* Have Shift-JIS */
  2208. #ifdef UNICODE
  2209.         uc.x_short = sj_to_un(sj.x_short); /* Translate to UCS-2 */
  2210.         haveuc = 1;            /* Have Unicode */
  2211. #endif /* UNICODE */
  2212.         flag = 1;            /* Have a char */
  2213.     }
  2214. #endif /* KANJI */
  2215.     }
  2216.     if (!flag) {            /* If no character was read yet... */
  2217.     if ((x = (fn ? (*fn)() : zminchar())) > -1)    /* read one now */
  2218.       ffc++;
  2219.     debug(F101,"xgnbyte zminchar 1","",x);
  2220.     if (x < 0)
  2221.       return(x);
  2222.     haveuc = 0;
  2223.     }
  2224. #ifdef UNICODE
  2225.     if (haveuc) {
  2226.     thischar = uc.x_short;
  2227.     /* lastucs2 = uc.x_short; */
  2228.     } else
  2229. #endif /* UNICODE */
  2230.       thischar = x;
  2231.     debug(F001,"xgnbyte thischar",haveuc ? "[UNICODE]" : "[other]",thischar);
  2232.  
  2233. #ifdef CK_CTRLZ                /* SET EOF CTRLZ */
  2234.     if (eofmethod == XYEOF_Z && !binary && thischar == 26) {
  2235.     debug(F100,"xgnbyte EOF on Ctrl-Z 1","",0);
  2236.     return(-1);
  2237.     }
  2238. #endif /* CK_CTRLZ */
  2239.  
  2240. #ifdef UNICODE
  2241.     if (!haveuc)            /* If not Unicode... */
  2242. #endif /* UNICODE */
  2243.       x &= fmask;            /* Apply SET FILE BYTESIZE mask */
  2244.  
  2245.     switch (xlatype) {            /* Translation type... */
  2246. #ifdef UNICODE
  2247.       case XLA_UNICODE: {        /* Unicode is involved */
  2248.       xc = 0;
  2249. /*
  2250.   Here we must choose the appropriate translation function.  If we are being
  2251.   called by getpkt() (i.e. when transferring a file), we are translating from
  2252.   Unicode to the Transfer Character Set and therefore must use the function
  2253.   pointed to by xut.  Otherwise, e.g. during TRANSLATE, CONNECT, TRANSMIT, etc,
  2254.   we are translating from Unicode to the File Character Set and so must call
  2255.   the function pointed to by xuf.  There might be a cleaner way to set this
  2256.   up but I don't think so.  For example, setxlatype() might have been called
  2257.   too soon and so might not have known whether it was a file transfer or a
  2258.   local operation.
  2259. */
  2260. /*
  2261.   (Many years later...) In testing this code I noticed that TRANSLATE'ing
  2262.   Russian text from UTF-8 to ISO Latin/Cyrillic produced all question marks.
  2263.   Rereading the previous paragraph it seems to me we are (I am) overloading
  2264.   this function with responsibilites, satisfying the needs of file transfer
  2265.   (local file charset -> transfer charset for outbound packet) and local file
  2266.   conversion.  In the case of TRANSLATE, we call (xgnbyte(), xpnbyte()) in a
  2267.   loop, expecting the xgnbyte() will feed UCS2 to xpnbyte().  But the
  2268.   following code does what xpnbyte() is going to do, returning (in this case)
  2269.   an ISO Latin/Cyrillic byte stream, which xpnbyte() believes to be UCS2, and
  2270.   comes up with nonsense.  Not wanting to rip the whole thing apart and start
  2271.   over, I made the following change that should do no harm, upon observing
  2272.   that if the input character set is UTF-8 or UCS-2, then when we get here it
  2273.   has already been converted to UCS2, so if we are not transferring a file, we
  2274.   don't need to do anything else except put the bytes in the right place to be
  2275.   returned, which is done further along.
  2276. */
  2277. #ifdef COMMENT
  2278.       /* Previous code */
  2279.       xx = (what & W_SEND) ? xut : xuf;
  2280. #else
  2281.       /* New code 2011-06-03 */
  2282.       if (what & W_SEND) {
  2283.           xx = xut;
  2284.       } else {
  2285.           if (fcs == FC_UCS2 || fcs == FC_UTF8)
  2286.         xx = NULL;
  2287.           else
  2288.         xx = xuf;
  2289.       }
  2290. #endif    /* COMMENT */
  2291.  
  2292.       eolflag = 0;
  2293.       if (haveuc) {            /* File is Unicode */
  2294.           /* See Unicode TR13, "Converting to Other Character Sets" */
  2295.           if (uc.x_short == 0x2028 || /* Line Separator? */
  2296.           uc.x_short == 0x2029 || /* Paragraph Separator */
  2297.           (feol && (uc.x_short == (USHORT)feol))
  2298.           ) {
  2299.           debug(F001,"xgnbyte uc eol","",uc.x_short);
  2300.           rc = 0;
  2301.           eolflag = 1;        /* Don't translate and handle later */
  2302.           }
  2303.           if (xx && !eolflag) {    /* UCS-to-TCS function (UCS->byte) */
  2304.           rc = (*xx)(uc.x_short); /* These can fail... */
  2305.           debug(F101,"xgnbyte xx rc","",rc);
  2306.           if (rc < 0)        /* If it can't be translated */
  2307.             uc.x_short = UNK;    /* Put unknown-character symbol */
  2308.           else
  2309.             uc.x_short = (unsigned)((unsigned)rc & 0xffff);
  2310.           debug(F101,"xgnbyte xx uc","",uc.x_short);
  2311.           }
  2312. #ifdef KANJI
  2313.           if (tcs == FC_JEUC) {    /* Translating to EUC-JP */
  2314.           USHORT sj = 0;
  2315.           union ck_short eu;
  2316.           debug(F001,"xgnbyte UCS->EUC UCS","",uc.x_short);
  2317.           if (!havesj)        /* If we don't already have it */
  2318.             sj = un_to_sj(uc.x_short); /* convert to Shift-JIS */
  2319.           eu.x_short = sj_to_eu(sj);
  2320.           debug(F001,"xgnbyte UCS->EUC EUC","",eu.x_short);
  2321.           xlaptr = 0;
  2322.           xlacount = 0;
  2323.           if (eolflag) {
  2324.               if (what & W_SEND) {
  2325.               xlabuf[xlacount++] = LF;
  2326.               return(CR);
  2327.               } else {
  2328.               return(feol);
  2329.               }
  2330.           }
  2331.           if (eu.x_char[byteorder]) {    /* Two bytes */
  2332.               rc = eu.x_char[byteorder];
  2333.               xlabuf[xlacount++] = eu.x_char[1-byteorder];
  2334.               debug(F001,"xgnbyte UCS->EUC xlabuf[0]","",xlabuf[0]);
  2335.           } else {        /* One byte */
  2336.               rc = eu.x_char[1-byteorder];
  2337.           }
  2338.           debug(F101,"xgnbyte UCS->EUC xlacount","",xlacount);
  2339.           debug(F001,"xgnbyte UCS->EUC rc","",rc);
  2340.           return(rc);
  2341.           } else
  2342. #endif /* KANJI */
  2343.           if (tcs != FC_UCS2 && tcs != FC_UTF8) {
  2344.           if (uc.x_short & 0xff00) {    /* Decoding error */
  2345.               debug(F001,"xgnbyte decoding error","",uc.x_short);
  2346.               return(-2);
  2347.           } else
  2348.             return((unsigned int)(uc.x_short & 0xff));
  2349.           }
  2350.           xc = uc.x_short;
  2351.  
  2352.       } else {            /* File is not Unicode */
  2353.           USHORT ch;
  2354.           /* Translate from single FCS byte to UCS-2 */
  2355. /*
  2356.   This is a bit nonobvious...  The blah_u() (Blah-to-Unicode) routines are
  2357.   called only with pieces of character sets, in the ISO 2022 sense.  So,
  2358.   for example, if ch is a Latin-1 character, we call the translation
  2359.   routine only if it is in the right half; if it's in the left half, it
  2360.   isn't translated, and in fact will give the wrong result if sent to the
  2361.   translation function.  That's because those functions were designed for
  2362.   use with the ISO 2022 G0..G3 sets, not for file transfer.  On the other
  2363.   hand, if it's a 7-bit character set, we *do* call the translation
  2364.   function.  (To put it another way, the left half of any 8-bit character
  2365.   set is ASCII and therefore doesn't need to be translated but 7-bit sets
  2366.   such as ISO 646 German do need translation).
  2367. */
  2368.           ch = (unsigned)(thischar & 0xff);
  2369.           if (((fcsinfo[fcs].size > 128) && (ch & 0x80)) ||
  2370.           fcsinfo[fcs].size <= 128) {
  2371.           if (xfu) {         /* FCS-to-UCS function */
  2372.               ch = (*xfu)(ch);
  2373.           }
  2374.           }
  2375.           xc = ch;
  2376.       }
  2377.       /* At this point we have a UCS-2 character in native format */
  2378.       /* (Big Endian or Little Endian) in xc, which is an unsigned int. */
  2379.  
  2380.       debug(F001,"xgnbyte xc","",xc);
  2381.  
  2382.       if (tcs == FC_UTF8) {        /* Now convert to UTF-8 */
  2383.           USHORT c;            /* NOTE: this is FC_UTF8 on purpose! */
  2384.           CHAR * buf = NULL;
  2385.           int i, k = 0, x;
  2386.  
  2387.           xlaptr = 0;
  2388.           if (utferror) {
  2389.           xlabuf[k++] = 0xff;
  2390.           xlabuf[k++] = 0xbd;
  2391.           }
  2392.           if (eolflag) {        /* We detected EOL in source file */
  2393.           if (what & W_SEND) {    /* Convert to CRLF */
  2394.               xlabuf[k++] = LF;
  2395.               xlacount = k;
  2396.               return((unsigned int)CR);
  2397. #ifdef COMMENT
  2398.           } else {        /* Or to local line-end */
  2399.               xlacount = k;
  2400.               return((unsigned int)feol);
  2401. #endif /* COMMENT */
  2402.           }
  2403.           }
  2404.           c = xc;
  2405.           if ((x = ucs2_to_utf8(c,&buf)) < 1) {
  2406.           debug(F101,"xgnbyte ucs2_to_utf8 error","",c);
  2407.           return(-2);
  2408.           }
  2409.           debug(F101,"xgnbyte UTF8 buf[0]","",buf[0]);
  2410.           for (i = 1; i < x; i++) {
  2411.           xlabuf[k+i-1] = buf[i];
  2412.           debug(F111,"xgnbyte UTF8 xlabuf",ckitoa(i-1),buf[i]);
  2413.           }
  2414.           xlaptr = 0;
  2415.           xlacount = x - 1;
  2416.           debug(F101,"xgnbyte UTF8 xlacount","",xlacount);
  2417.           return((unsigned int)buf[0]);
  2418.       } else {            /* Or keep it as UCS-2 */
  2419.           int k = 0;
  2420.           CHAR c;
  2421.           xlaptr = 0;
  2422.           if (utferror) {
  2423.           xlabuf[k++] = 0xff;
  2424.           xlabuf[k++] = 0xfd;
  2425.           debug(F101,"xgnbyte error","",k);
  2426.           }
  2427.           if (eolflag) {        /* We detected EOL in source file */
  2428.           if (what & W_SEND) {    /* Convert to CRLF */
  2429.               xlabuf[k++] = CR;
  2430.               xlabuf[k++] = NUL;
  2431.               xlabuf[k++] = LF;
  2432.               xlacount = k;
  2433.               debug(F101,"xgnbyte send CRLF","",k);
  2434.               return(0);    /* Return NUL */
  2435.           } else {        /* Or to local line-end */
  2436. #ifdef COMMENT
  2437.               /* This bypasses byte swapping that we might need */
  2438.               xlabuf[k++] = (CHAR)feol;
  2439.               xlacount = k;
  2440.               debug(F101,"xgnbyte send feol","",k);
  2441.               return(0);    /* Return NUL */
  2442. #else
  2443.               xc = (CHAR)feol;
  2444. #endif /* COMMENT */
  2445.           }
  2446.           }
  2447.           /* In which order should we return the bytes? */
  2448. #ifdef COMMENT
  2449.           if ( (what & W_SEND) || (what & W_FTP) || (fileorder == 0)) {
  2450. #endif /* COMMENT */
  2451.           /* ALWAYS RETURN IN BIG ENDIAN ORDER... 7 Sep 2002   */
  2452.           /* xgnbyte() is almost always used to feed xpnbyte() */
  2453.           /* which requires bytes in BE order. In cases where  */
  2454.           /* xgnbyte is used in isolation, the caller can swap */
  2455.           /* bytes itself afterwards. */
  2456.           xlabuf[k++] = (xc >> 8) & 0xff; /* Big Endian */
  2457.           xlabuf[k++] = xc & 0xff;
  2458.           debug(F001,"xgnbyte->UCS2BE",
  2459.             ckitox((int)xlabuf[0]),xlabuf[1]);
  2460. #ifdef COMMENT
  2461.           } else {            /* Little Endian */
  2462.           xlabuf[k++] = xc & 0xff;
  2463.           xlabuf[k++] = (xc >> 8) & 0xff;
  2464.           debug(F001,"xgnbyte->UCS2LE",
  2465.             ckitox((int)xlabuf[0]),xlabuf[1]);
  2466.           }
  2467. #endif /* COMMENT */
  2468.           c = xlabuf[0];
  2469.           xlaptr = 1;
  2470.           xlacount = k-1;
  2471.           debug(F101,"xgnbyte c","",c);
  2472.           debug(F101,"xgnbyte xlaptr","",xlaptr);
  2473.           debug(F011,"xgnbyte xlabuf",xlabuf,xlacount);
  2474.           return((unsigned int)c);
  2475.       }
  2476.       }
  2477. #endif /* UNICODE */
  2478.       case XLA_NONE:
  2479.     return((fn ? (*fn)() : zminchar()));
  2480.       case XLA_BYTE:            /* Byte-for-Byte translation */
  2481.     rt = x;
  2482.     if (sx)
  2483.       rt = (*sx)(rt);
  2484. #ifdef UNICODE
  2485.     if (utferror) {
  2486.         xlaptr = 0;
  2487.         xlacount = 1;
  2488.         xlabuf[0] = rt;
  2489.         return(UNK);
  2490.     } else
  2491. #endif /* UNICODE */
  2492.       return((unsigned int)rt);
  2493.  
  2494. #ifdef KANJI
  2495.       case XLA_JAPAN:            /* Come here with Shift-JIS */
  2496.     if (tcs == FC_JEUC) {        /* It better be... */
  2497.         xlaptr = 0;
  2498.         xlacount = 0;
  2499.         if (!havesj) {
  2500.         printf("BAD BAD\n");
  2501.         return(-2);
  2502.         }
  2503.         if (!haveeu)        /* We might already have EUC too */
  2504.           eu.x_short = sj_to_eu(sj.x_short);
  2505.         if (eu.x_char[byteorder]) {
  2506.         xlabuf[xlacount++] = eu.x_char[1-byteorder];
  2507.         return(eu.x_char[byteorder]);
  2508.         } else {
  2509.         return(eu.x_char[1-byteorder]);
  2510.         }
  2511.         break;
  2512.     }
  2513. #endif /* KANJI */
  2514.  
  2515.       default:
  2516.     debug(F101,"xgnbyte bad xlatype","",xlatype);
  2517.     return(-2);
  2518.     }
  2519. #ifdef COMMENT
  2520. /*    
  2521.   If there is a return() statement here, some compilers complain
  2522.   about "statement not reached".  If there is no return() statement,
  2523.   other compilers complain that "Non-void function should return a value".
  2524.   There is no path through this function that falls through to here.
  2525. */
  2526.     debug(F100,"xgnbyte switch failure","",0);
  2527.     return(-2);
  2528. #endif /* COMMENT */
  2529. }
  2530. #endif /* NOCSETS */
  2531.  
  2532. #ifndef NOXFER
  2533.  
  2534. /*  G E T P K T  --  Fill a packet data field from the indicated source.  */
  2535.  
  2536. /*
  2537.   Parameters:
  2538.     bufmax: Maximum length of entire packet.
  2539.     xlate:  Flag for whether to translate charsets when in text mode.
  2540.   Returns:  Number of characters written to packet data field, 0 or more,
  2541.             Or -1 on failure (internal error),
  2542.             or -3 on timeout (e.g. when reading from a pipe).
  2543.  
  2544.   This is the full version allowing for parity and text-mode conversions;
  2545.   i.e. it works in all cases.   Also see bgetpkt(), a special lean/mean/fast
  2546.   packet encoder that works only for binary-mode no-parity transfers.
  2547. */
  2548. static int uflag = 0;
  2549.  
  2550. int
  2551. getpkt(bufmax,xlate) int bufmax, xlate; { /* Fill one packet buffer */
  2552.     register CHAR rt = t, rnext = NUL;      /* Register shadows of the globals */
  2553.     register CHAR *dp, *odp, *odp2, *p1, *p2; /* pointers... */
  2554.     register int x;            /* Loop index. */
  2555.     register int a7;            /* Low 7 bits of character */
  2556.  
  2557.     CHAR xxls, xxdl, xxrc, xxss, xxcq;    /* Pieces of prefixed sequence */
  2558.  
  2559.     if (binary) xlate = 0;        /* We don't translate if binary */
  2560.  
  2561.     if (!data) {
  2562.     debug(F100,"SERIOUS ERROR: getpkt data == NULL","",0);
  2563.     return(-1);
  2564.     }
  2565.     dp = data;                /* Point to packet data buffer */
  2566.     size = 0;                /* And initialize its size */
  2567. /*
  2568.   Assume bufmax is the receiver's total receive-packet buffer length.
  2569.   Our whole packet has to fit into it, so we adjust the data field length.
  2570.   We also decide optimally whether it is better to use a short-format or
  2571.   long-format packet when we're near the borderline.
  2572. */
  2573.     bufmax = maxdata();            /* Get maximum data length */
  2574.  
  2575.     if (first == 1) {            /* If first character of this file.. */
  2576. #ifdef UNICODE
  2577.     /* Special end-of-line handling for Unicode */
  2578.     if (tcharset == TC_UCS2 || tcharset == TC_UTF8)
  2579.       uflag = 1;
  2580. #endif /* UNICODE */
  2581.     debug(F101,"getpkt first uflag","",uflag);
  2582.     debug(F101,"getpkt first rt","",rt);
  2583.     if (!memstr && !funcstr)    /* and real file... */
  2584.       ffc = (CK_OFF_T)0;        /* reset file character counter */
  2585. #ifdef COMMENT
  2586.     /* Moved to below... */
  2587.     first = 0;            /* Next character won't be first */
  2588. #endif /* COMMENT */
  2589.     *leftover = '\0';        /* Discard any interrupted leftovers */
  2590.     nleft = 0;
  2591. #ifndef NOCSETS
  2592.     setxlatype(tcharset,fcharset);    /* Set up charset translations */
  2593. #endif /* NOCSETS */
  2594.  
  2595.     /* Get first character of file into rt, watching out for null file */
  2596.  
  2597. #ifdef CALIBRATE
  2598.     if (calibrate && !memstr) {
  2599. #ifdef NORANDOM
  2600.         x = rt = 53;
  2601. #else
  2602.         x = rt = cal_a[rand() & 0xff];
  2603. #endif /* NORANDOM */
  2604.         first = 0;
  2605.         ffc++;
  2606.     } else
  2607. #endif /* CALIBRATE */
  2608. #ifdef KANJI
  2609.     if (xlate && tcharset == TC_JEUC) { /* Kanji text */
  2610.         x = zkanjf();
  2611.         if ((x = zkanji(memstr ? kgetm : kgetf)) < 0) {
  2612.             first = -1;
  2613.             size = 0;
  2614.             if (x == -2) {
  2615.                 debug(F100,"getpkt zkanji: input error","",0);
  2616.                 cxseen = 1;
  2617.             } else debug(F100,"getpkt zkanji: empty string/file","",0);
  2618.             return(0);
  2619.         }
  2620.         rt = x;
  2621.         first = 0;
  2622.         if (!memstr) {
  2623.         ffc++;
  2624.         if (docrc && (what & W_SEND)) /* Accumulate file crc */
  2625.           dofilcrc((int)rt);
  2626.         }
  2627.     } else {            /* Not Kanji text */
  2628. #endif /* KANJI */
  2629.         if (memstr) {        /* Reading data from memory string */
  2630.         /* This will not be Unicode */
  2631.         if ((rt = *memptr++) == '\0') { /* end of string ==> EOF */
  2632.             first = -1;
  2633.             size = 0;
  2634.             debug(F100,"getpkt: empty string","",0);
  2635.             return(0);
  2636.         }
  2637.         first = 0;
  2638.         } else if (funcstr) {    /* Reading data from a function */
  2639.         /* This will not be Unicode */
  2640.         if ((x = (*funcptr)()) < 0) { /* End of input  */
  2641.             first = -1;
  2642.             size = 0;        /* Empty */
  2643.             return(0);
  2644.         }
  2645.         ffc++;            /* Count a file character */
  2646.         rt = (CHAR) x;        /* Convert int to char */
  2647.         first = 0;
  2648.         debug(F000,"getpkt funcstr","",rt);
  2649.  
  2650.         } else {            /* Reading data from a file */
  2651. #ifndef NOCSETS
  2652.         if (xlate && !binary) {    /* Could be Unicode */
  2653.             if (xlatype == XLA_UNICODE) {
  2654.             /* Get next translated byte */
  2655.             x = xgnbyte(cseqtab[tcharset],fcharset,NULL);
  2656.             debug(F101,"getpkt xgnbyte","",x);
  2657.             } else {        /* Not Unicode */
  2658.             x = zminchar();    /* Get next byte, translate below */
  2659.             debug(F101,"getpkt zminchar A","",x);
  2660.             }
  2661.         } else {        /* Just get next byte */
  2662. #endif /* NOCSETS */
  2663.             x = zminchar();
  2664.             debug(F101,"getpkt zminchar B","",x);
  2665. #ifndef NOCSETS
  2666.         }
  2667. #endif /* NOCSETS */
  2668.         if (x < 0) {        /* End of file or input error */
  2669.             if (x == -3) {    /* Timeout. */
  2670.             size = (dp-data);
  2671.             debug(F101,"getpkt timeout size","",size);
  2672.             return((size == 0) ? x : size);
  2673.             }
  2674.             first = -1;
  2675.             size = 0;
  2676.             if (x == -2) {    /* Error */
  2677.             debug(F100,"getpkt: input error","",0);
  2678.             cxseen = 1;    /* Interrupt the file transfer */
  2679.             } else {
  2680.             debug(F100,"getpkt empty file","",0);
  2681.             }
  2682.             return(0);
  2683.         }
  2684.         first = 0;        /* Next character won't be first */
  2685.         rt = (CHAR) x;        /* Convert int to char */
  2686. #ifndef NOCSETS
  2687.         if (xlatype != XLA_UNICODE || binary) {
  2688.             ffc++;
  2689.             if (sx)
  2690.               rt = (*sx)(rt);
  2691.             if (docrc && (what & W_SEND))
  2692.               dofilcrc(x);
  2693.         }
  2694. #endif /* NOCSETS */
  2695. #ifdef DEBUG
  2696.         if (deblog)
  2697.           debug(F101,"getpkt 1st char","",rt);
  2698. #endif /* DEBUG */
  2699.         if (/* !haveuc && */ docrc && (what & W_SEND)) /* File CRC */
  2700.           dofilcrc(x);
  2701.         }
  2702. #ifdef KANJI
  2703.     }
  2704. #endif /* KANJI */
  2705.     /* PWP: handling of feol is done later (in the while loop)... */
  2706.  
  2707.     } else if ((first == -1) && (nleft == 0)) { /* EOF from last time */
  2708. #ifdef DEBUG
  2709.     if (deblog) {
  2710.         debug(F101,"getpkt eof crc16","",crc16);
  2711.         debug(F101,"getpkt eof ffc","",ffc);
  2712.     }
  2713. #endif /* DEBUG */
  2714.         return(size = 0);
  2715.     }
  2716. /*
  2717.   Here we handle characters that were encoded for the last packet but
  2718.   did not fit, and so were saved in the "leftover" array.
  2719. */
  2720.     debug(F101,"getpkt nleft","",nleft);
  2721.     if (nleft) {
  2722.     for (p1 = leftover; nleft > 0; nleft--) /* Copy leftovers */
  2723.       *dp++ = *p1++;
  2724.     *leftover = '\0';            /* Delete leftovers */
  2725.     nleft = 0;
  2726.     }
  2727.     if (first == -1)            /* Handle EOF */
  2728.       return(size = (dp - data));
  2729.  
  2730. /* Now fill up the rest of the packet. */
  2731.  
  2732.     rpt = 0;                /* Initialize character repeat count */
  2733.  
  2734.     while (first > -1) {        /* Until EOF... */
  2735. #ifdef CALIBRATE
  2736.     if (calibrate && !memstr) {    /* We generate our own "file" */
  2737.         if (ffc >= calibrate) {    /* EOF */
  2738.         first = -1;
  2739.         ffc--;
  2740.         } else {            /* Generate next character */
  2741.         if (cal_j > CAL_M * ffc)
  2742.           cal_j = cal_a[ffc & 0xff];
  2743.         x = (unsigned)cal_a[(cal_j & 0xff)];
  2744.         if (x == rt) x ^= 2;
  2745.         }
  2746.         cal_j += (unsigned int)(ffc + CAL_O);
  2747.         ffc++;
  2748.     } else
  2749. #endif /* CALIBRATE */
  2750. #ifdef KANJI
  2751.       if (xlate && tcharset == TC_JEUC) {
  2752.           if ((x = zkanji(memstr ? kgetm : kgetf)) < 0) {
  2753.           first = -1;
  2754.           if (x == -2) cxseen = 1;
  2755.           } else if (!memstr) ffc++;
  2756.           rnext = (CHAR) (x & fmask);
  2757.       } else {
  2758. #endif /* KANJI */
  2759.         if (memstr) {        /* Get next char from memory string */
  2760.         if ((x = *memptr++) == '\0') /* End of string means EOF */
  2761.           first = -1;        /* Flag EOF for next time. */
  2762.         rnext = (CHAR) (x & fmask); /* Apply file mask */
  2763.         } else if (funcstr) {    /* Get next char from function */
  2764.         if ((x = (*funcptr)()) < 0) /* End of string means EOF */
  2765.           first = -1;        /* Flag EOF for next time. */
  2766.         rnext = (CHAR) (x & fmask); /* Apply file mask */
  2767.         } else {            /* From file... */
  2768. #ifndef NOCSETS
  2769.         if (xlate && !binary) {    /* Could be Unicode */
  2770.             if (xlatype == XLA_UNICODE) {
  2771.             /* Get next translated byte */
  2772.             x = xgnbyte(cseqtab[tcharset],fcharset,NULL);
  2773.             } else {        /* Not Unicode */
  2774.             x = zminchar(); /* Get next byte, translate below */
  2775.             /* debug(F101,"xgnbyte B zminchar","",x); */
  2776.             }
  2777.         } else {        /* Just get next byte */
  2778. #endif /* NOCSETS */
  2779.             x = zminchar();
  2780.             /* debug(F101,"xgnbyte C zminchar","",x); */
  2781. #ifndef NOCSETS
  2782.         }
  2783. #endif /* NOCSETS */
  2784.         if (x < 0) {        /* Check for EOF */
  2785.             if (x == -3) {    /* Timeout reading from pipe */
  2786.             t = rt;
  2787.             size = (dp-data);
  2788.             debug(F101,"getpkt timeout size","",size);
  2789.             return((size == 0) ? x : size);
  2790.             }
  2791.             first = -1;        /* Flag eof for next time. */
  2792.             if (x == -2) cxseen = 1; /* If error, cancel this file. */
  2793.         }
  2794.         rnext = (CHAR) (x & fmask); /* Apply file mask */
  2795. #ifndef NOCSETS
  2796.         if (xlatype != XLA_UNICODE) {
  2797. #endif /* NOCSETS */
  2798.             ffc++;
  2799. #ifndef NOCSETS
  2800.             if (sx)
  2801.               rt = (*sx)(rt);
  2802. #endif /* NOCSETS */
  2803.             if (docrc && (what & W_SEND))
  2804.               dofilcrc(x);
  2805.  
  2806. #ifndef NOCSETS
  2807.         }
  2808. #endif /* NOCSETS */
  2809.         }
  2810. #ifdef KANJI
  2811.     }
  2812. #endif /* KANJI */
  2813. /*
  2814.   At this point, the character we just read is in rnext,
  2815.   and the character we are about to encode into the packet is in rt.
  2816. */
  2817.     odp = dp;            /* Remember where we started. */
  2818.      xxls = xxdl = xxrc = xxss = xxcq = NUL;    /* Clear these. */
  2819. /*
  2820.   Now encode the character according to the options that are in effect:
  2821.     ctlp[]: whether this control character needs prefixing.
  2822.     binary: text or binary mode.
  2823.     rptflg: repeat counts enabled.
  2824.     ebqflg: 8th-bit prefixing enabled.
  2825.     lscapu: locking shifts enabled.
  2826. */
  2827.     if (rptflg) {            /* Repeat processing is on? */
  2828.         if (!uflag &&
  2829.         /*
  2830.          * If the next char is really CRLF, then we cannot
  2831.          * be doing a repeat (unless CR,CR,LF which becomes
  2832.          * "~ <n-1> CR CR LF", which is OK but not most efficient).
  2833.          * I just plain don't worry about this case.  The actual
  2834.          * conversion from NL to CRLF is done after the rptflg if...
  2835.          */
  2836.         (!feol || binary || (feol && (rnext != feol))) &&
  2837.         (rt == rnext) && (first == 0)) { /* Got a run... */
  2838.         if (++rpt < 94) {    /* Below max, just count */
  2839.             continue;        /* go back and get another */
  2840.         } else if (rpt == 94) {    /* Reached max, must dump */
  2841.             xxrc = (CHAR) tochar(rpt); /* Put the repeat count here */
  2842.             rptn += rpt;    /* Accumulate it for statistics */
  2843.             rpt = 0;        /* And reset it */
  2844.         }
  2845.         } else if (rpt > 1) {    /* More than two */
  2846.         xxrc = (CHAR) tochar(++rpt); /* and count. */
  2847.         rptn += rpt;
  2848.         rpt = 0;        /* Reset repeat counter. */
  2849.         }
  2850.         /*
  2851.           If (rpt == 1) we must encode exactly two characters.
  2852.           This is done later, after the first character is encoded.
  2853.         */
  2854.     }
  2855.     /* If it's the newline character... */
  2856.     if (!uflag && !binary && feol && (rt == feol)) {
  2857.         if (lscapu && lsstate) {    /* If SHIFT-STATE is SHIFTED */
  2858.         if (ebqflg) {        /* If single shifts enabled, */
  2859.             *dp++ = (CHAR) ebq;    /* insert a single shift. */
  2860.         } else {        /* Otherwise must shift in. */
  2861.             *dp++ = myctlq;    /* Insert shift-out code */
  2862.             *dp++ = 'O';
  2863.             lsstate = 0;    /* Change shift state */
  2864.         }
  2865.         }
  2866. #ifdef CK_SPEED
  2867.         if (ctlp[CR]) {
  2868.         *dp++ = myctlq;        /* Insert carriage return directly */
  2869.         *dp++ = 'M';
  2870.         ccp++;
  2871.         } else {
  2872.         *dp++ = CR;        /* Perhaps literally */
  2873.         ccu++;
  2874.         }
  2875. #else /* !CK_SPEED */
  2876.         *dp++ = myctlq;        /* Insert carriage return directly */
  2877.         *dp++ = 'M';
  2878.         ccp++;
  2879. #endif /* CK_SPEED */
  2880.         rt = LF;            /* Now make next char be linefeed. */
  2881.     }
  2882. /*
  2883.   Now handle the 8th bit of the file character.  If we have an 8-bit
  2884.   connection, we preserve the 8th bit.  If we have a 7-bit connection,
  2885.   we employ either single or locking shifts (if they are enabled).
  2886. */
  2887.     a7 = rt & 0177;            /* Get low 7 bits of character */
  2888.     if (rt & 0200) {        /* 8-bit character? */
  2889.         if (lscapu) {        /* Locking shifts enabled? */
  2890.         if (!lsstate) {        /* Not currently shifted? */
  2891.             x = lslook(0200);    /* Look ahead */
  2892.             if (x != 0 || ebqflg == 0) { /* Locking shift decision */
  2893.             xxls = 'N';       /* Need locking shift-out */
  2894.             lsstate = 1;       /* and change to shifted state */
  2895.             } else if (ebqflg) {   /* Not worth it */
  2896.             xxss = (CHAR) ebq; /* Use single shift */
  2897.             }
  2898.         }
  2899.         rt = (CHAR) a7;        /* Replace character by 7-bit value */
  2900.         } else if (ebqflg) {    /* 8th bit prefixing is on? */
  2901.         xxss = (CHAR) ebq;    /* Insert single shift */
  2902.         rt = (CHAR) a7;        /* Replace character by 7-bit value */
  2903.         }
  2904. /*
  2905.   In case we have a 7-bit connection and this is an 8-bit character, AND
  2906.   neither locking shifts nor single shifts are enabled, then the character's
  2907.   8th bit will be destroyed in transmission, and a block check error will
  2908.   occur.
  2909. */
  2910.     } else if (lscapu) {        /* 7-bit character */
  2911.  
  2912.         if (lsstate) {        /* Comes while shifted out? */
  2913.         x = lslook(0);        /* Yes, look ahead */
  2914.         if (x || ebqflg == 0) {    /* Time to shift in. */
  2915.             xxls = 'O';        /* Set shift-in code */
  2916.             lsstate = 0;    /* Exit shifted state */
  2917.         } else if (ebqflg) {    /* Not worth it, stay shifted out */
  2918.             xxss = (CHAR) ebq;    /* Insert single shift */
  2919.         }
  2920.         }
  2921.     }
  2922.     /* If data character is significant to locking shift protocol... */
  2923.     if (lscapu && (a7 == SO || a7 == SI || a7 == DLE))
  2924.       xxdl = 'P';            /* Insert datalink escape */
  2925.  
  2926.     if (
  2927. #ifdef CK_SPEED
  2928.         /*
  2929.           Thwart YET ANOTHER unwanted, unneeded, and unloved sign
  2930.           extension.  This one was particularly nasty because it prevented
  2931.           255 (Telnet IAC) from being prefixed on some platforms -- e.g.
  2932.           VMS with VAX C -- but not others, thus causing file transfers to
  2933.           fail on Telnet connections by sending bare IACs.  Not to mention
  2934.           the stray memory reference.  Signed chars are a BAD idea.
  2935.         */
  2936.         ctlp[(unsigned)(rt & 0xff)]    /* Lop off any "sign" extension */
  2937. #else
  2938.         (a7 < SP) || (a7 == DEL)
  2939. #endif /* CK_SPEED */
  2940.         ) {                /* Do control prefixing if necessary */
  2941.         xxcq = myctlq;        /* The prefix */
  2942.         ccp++;            /* Count it */
  2943.         rt = (CHAR) ctl(rt);    /* Uncontrollify the character */
  2944.     }
  2945. #ifdef CK_SPEED
  2946.     else if ((a7 < SP) || (a7 == DEL)) /* Count an unprefixed one */
  2947.       ccu++;
  2948. #endif /* CK_SPEED */
  2949.  
  2950.     if (a7 == myctlq)        /* Always prefix the control prefix */
  2951.       xxcq = myctlq;
  2952.  
  2953.     if ((rptflg) && (a7 == rptq))    /* If it's the repeat prefix, */
  2954.       xxcq = myctlq;        /* prefix it if doing repeat counts */
  2955.  
  2956.     if ((ebqflg) && (a7 == ebq))    /* Prefix the 8th-bit prefix */
  2957.       xxcq = myctlq;        /* if doing 8th-bit prefixes */
  2958.  
  2959. /* Now construct the entire sequence */
  2960.  
  2961.     if (xxls) { *dp++ = myctlq; *dp++ = xxls; } /* Locking shift */
  2962.     odp2 = dp;                    /* (Save this place) */
  2963.     if (xxdl) { *dp++ = myctlq; *dp++ = xxdl; } /* Datalink escape */
  2964.     if (xxrc) { *dp++ = (CHAR) rptq; *dp++ = xxrc; } /* Repeat count */
  2965.     if (xxss) { *dp++ = (CHAR) ebq; }           /* Single shift */
  2966.     if (xxcq) { *dp++ = myctlq; }                /* Control prefix */
  2967.     *dp++ = rt;            /* Finally, the character itself */
  2968.  
  2969.     if (rpt == 1) {            /* Exactly two copies? */
  2970.         rpt = 0;
  2971.         p2 = dp;            /* Save place temporarily */
  2972.         for (p1 = odp2; p1 < p2; p1++) /* Copy the old chars over again */
  2973.           *dp++ = *p1;
  2974.         if ((p2-data) <= bufmax) odp = p2; /* Check packet bounds */
  2975.         if ((p2-data) < bufmax) odp = p2; /* Check packet bounds */
  2976.     }
  2977.     rt = rnext;            /* Next character is now current. */
  2978.  
  2979. /* Done encoding the character.  Now take care of packet buffer overflow. */
  2980.  
  2981.     if ((dp-data) >= bufmax) {    /* If too big, save some for next. */
  2982.  
  2983.         debug(F000,"getpkt EOP","",rt);
  2984.  
  2985.         size = (dp-data);        /* Calculate the size. */
  2986.         *dp = '\0';            /* Mark the end. */
  2987.         if (memstr) {        /* No leftovers for memory strings */
  2988.         if (rt)            /* Char we didn't encode yet */
  2989.           memptr--;        /* (for encstr()) */
  2990.         return(size);
  2991.         }
  2992.         if ((dp-data) > bufmax) {    /* if packet is overfull */
  2993.         /* copy the part that doesn't fit into the leftover buffer, */
  2994.         /* taking care not to split a prefixed sequence. */
  2995.         int i;
  2996.         nleft = dp - odp;
  2997.         for (i = 0, p1 = leftover, p2 = odp; i < nleft; i++) {
  2998.             *p1++ = *p2++;
  2999.             if (memstr) memptr--; /* (for encstr) */
  3000.         }
  3001.         debug(F111,"getpkt leftover",leftover,size);
  3002.         debug(F101,"getpkt osize","",(odp-data));
  3003.         size = (odp-data);    /* Return truncated packet. */
  3004.         *odp = '\0';        /* Mark the new end */
  3005.         }
  3006.         t = rt;            /* Save for next time */
  3007.         return(size);
  3008.     }
  3009.     }                    /* Otherwise, keep filling. */
  3010.     size = (dp-data);            /* End of file */
  3011.     *dp = '\0';                /* Mark the end of the data. */
  3012.     debug(F111,"getpkt eof/eot",data,size); /* Fell thru before packet full, */
  3013.     return(size);             /* return partially filled last packet. */
  3014. }
  3015.  
  3016. /*  T I N I T  --  Initialize a transaction  */
  3017.  
  3018. int epktrcvd = 0, epktsent = 0;
  3019.  
  3020. /*
  3021.   Call with 1 to reset everything before S/I/Y negotiation, or 0 to
  3022.   reset only the things that are not set in the S/I/Y negotiation.
  3023.   Returns -1 on failure (e.g. to create packet buffers), 0 on success.
  3024. */
  3025. int
  3026. tinit(flag) int flag; {
  3027.     int x;
  3028. #ifdef CK_TIMERS
  3029.     extern int rttflg;
  3030. #endif /* CK_TIMERS */
  3031.     extern int rcvtimo;
  3032.     extern int fatalio;
  3033.  
  3034.     debug(F101,"tinit flag","",flag);
  3035.  
  3036.     *epktmsg = NUL;
  3037.     epktrcvd = 0;
  3038.     epktsent = 0;
  3039.     ofperms = "";
  3040.     diractive = 0;            /* DIR / REMOTE DIR not active */
  3041.     interrupted = 0;            /* Not interrupted */
  3042.     fatalio = 0;            /* No fatal i/o error */
  3043.     if (server) {
  3044.     moving  = 0;
  3045.     pipesend = 0; /* This takes care of multiple GETs sent to a server. */
  3046.     }
  3047.     bestlen = 0;            /* For packet length optimization */
  3048.     maxsend = 0;            /* Biggest data field we can send */
  3049. #ifdef STREAMING
  3050.     streamok = 0;            /* Streaming negotiated */
  3051.     streaming = 0;            /* Streaming being done now */
  3052. #endif /* STREAMING */
  3053.  
  3054.     binary = b_save;            /* ... */
  3055.     gnf_binary = binary;        /* Per-file transfer mode */
  3056.     retrans = 0;            /* Packet retransmission count */
  3057.     sndtyp = 0;                /* No previous packet */
  3058.     xflg = 0;                /* Reset x-packet flag */
  3059.     memstr = 0;                /* Reset memory-string flag */
  3060.     memptr = NULL;            /*  and buffer pointer */
  3061.     funcstr = 0;            /* Reset "read from function" flag */
  3062.     funcptr = NULL;            /*  and function pointer */
  3063.     autopar = 0;            /* Automatic parity detection flag */
  3064.  
  3065.     /* This stuff is only for BEFORE S/I/Y negotiation, not after */
  3066.  
  3067.     if (flag) {
  3068.     if (bctf) {              /* Force Block Check 3 on all packets */
  3069.         bctu = bctl = 3;        /* Set block check type to 3 */
  3070.     } else {
  3071.         bctu = bctl = 1;        /* Reset block check type to 1 */
  3072.     }
  3073.     myinit[0] = '\0';        /* Haven't sent init string yet */
  3074.     rqf = -1;            /* Reset 8th-bit-quote request flag */
  3075.     ebq = MYEBQ;            /* Reset 8th-bit quoting stuff */
  3076.     ebqflg = 0;            /* 8th bit quoting not enabled */
  3077.     ebqsent = 0;            /* No 8th-bit prefix bid sent yet */
  3078.     sq = 'Y';            /* 8th-bit prefix bid I usually send */
  3079.     spsiz = spsizr;            /* Initial send-packet size */
  3080.     debug(F101,"tinit spsiz","",spsiz);
  3081.     wslots = 1;            /* One window slot */
  3082.     wslotn = 1;            /* No window negotiated yet */
  3083.     justone = 0;            /* (should this be zero'd here?) */
  3084.     whoareu[0] = NUL;        /* Partner's system type */
  3085.     sysindex = -1;
  3086.     wearealike = 0;
  3087.     what = W_INIT;            /* Doing nothing so far... */
  3088.     }
  3089.     fncnv = f_save;            /* Back to what user last said */
  3090.     pktnum = 0;                /* Initial packet number to send */
  3091.     cxseen = czseen = discard = 0;    /* Reset interrupt flags */
  3092.     *filnam = '\0';            /* Clear file name */
  3093.     spktl = 0;                /* And its length */
  3094.     nakstate = 0;            /* Assume we're not in a NAK state */
  3095.     numerrs = 0;            /* Transmission error counter */
  3096.     idletmo = 0;            /* No idle timeout yet */
  3097.     if (server) {             /* If acting as server, */
  3098.     if (srvidl > 0)            /* If an idle timeout is given */
  3099.       timint = srvidl;
  3100.     else
  3101.       timint = srvtim;        /* use server timeout interval. */
  3102.     } else {                /* Otherwise */
  3103.     timint = chktimo(rtimo,timef);    /* and use local timeout value */
  3104.     }
  3105.     debug(F101,"tinit timint","",timint);
  3106.  
  3107. #ifdef CK_TIMERS
  3108.     if (rttflg && timint > 0)        /* Using round-trip timers? */
  3109.       rttinit();
  3110.     else
  3111. #endif /* CK_TIMERS */
  3112.       rcvtimo = timint;
  3113.  
  3114.     winlo = 0;                /* Packet 0 is at window-low */
  3115.     debug(F101,"tinit winlo","",winlo);
  3116.     x = mksbuf(1);            /* Make a 1-slot send-packet buffer */
  3117.     if (x < 0) return(x);
  3118.     x = getsbuf(0);            /* Allocate first send-buffer. */
  3119.     debug(F101,"tinit getsbuf","",x);
  3120.     if (x < 0) return(x);
  3121.     dumpsbuf();
  3122.     x = mkrbuf(wslots);            /* & a 1-slot receive-packet buffer. */
  3123.     if (x < 0) return(x);
  3124.     lsstate = 0;            /* Initialize locking shift state */
  3125.     if (autopath) {            /* SET RECEIVE PATHNAMES AUTO fixup */
  3126.     fnrpath = PATH_AUTO;
  3127.     autopath = 0;
  3128.     }
  3129.     return(0);
  3130. }
  3131.  
  3132. VOID
  3133. pktinit() {                /* Initialize packet sequence */
  3134.     pktnum = 0;                /* number & window low. */
  3135.     winlo = 0;
  3136.     debug(F101,"pktinit winlo","",winlo);
  3137. }
  3138.  
  3139. /*  R I N I T  --  Respond to S or I packet  */
  3140.  
  3141. VOID
  3142. rinit(d) CHAR *d; {
  3143.     char *tp = NULL;
  3144.     ztime(&tp);
  3145.     tlog(F110,"Transaction begins",tp,0L); /* Make transaction log entry */
  3146.     tlog(F110,"Global file mode:", binary ? "binary" : "text", 0L);
  3147.     tlog(F110,"Collision action:", fncnam[fncact],0);
  3148.     tlog(F100,"","",0);
  3149.     debug(F101,"rinit fncact","",fncact);
  3150.     filcnt = filrej = 0;        /* Init file counters */
  3151.     spar(d);
  3152.     ack1(rpar());
  3153. #ifdef datageneral
  3154.     if ((local) && (!quiet))            /* Only do this if local & not quiet */
  3155.         consta_mt();                    /* Start the asynch read task */
  3156. #endif /* datageneral */
  3157. }
  3158.  
  3159.  
  3160. /*  R E S E T C  --  Reset per-transaction character counters */
  3161.  
  3162. VOID
  3163. resetc() {
  3164.     rptn = 0;                /* Repeat counts */
  3165.     fsecs = flci = flco = (CK_OFF_T)0;    /* File chars in and out */
  3166. #ifdef GFTIMER
  3167.     fpfsecs = 0.0;
  3168. #endif /* GFTIMER */
  3169.     tfc = tlci = tlco = (CK_OFF_T)0;    /* Total file, line chars in & out */
  3170.     ccu = ccp = 0L;            /* Control-char statistics */
  3171. #ifdef COMMENT
  3172.     fsize = (CK_OFF_T)-1;        /* File size */
  3173. #else
  3174.     if (!(what & W_SEND))
  3175.       fsize = (CK_OFF_T)-1;
  3176.     debug(F101,"resetc fsize","",fsize);
  3177. #endif /* COMMENT */
  3178.     timeouts = retrans = 0;        /* Timeouts, retransmissions */
  3179.     spackets = rpackets = 0;        /* Packet counts out & in */
  3180.     crunched = 0;            /* Crunched packets */
  3181.     wcur = 0;                /* Current window size */
  3182.     wmax = 0;                /* Maximum window size used */
  3183.     peakcps = 0;                        /* Peak chars per second */
  3184. }
  3185.  
  3186. /*  S I N I T  --  Get & verify first file name, then send Send-Init packet */
  3187. /*
  3188.  Returns:
  3189.    1 if send operation begins successfully
  3190.    0 if send operation fails
  3191. */
  3192. #ifdef DYNAMIC
  3193. char *cmargbuf = NULL;
  3194. #else
  3195. char cmargbuf[CKMAXPATH+1];
  3196. #endif /* DYNAMIC */
  3197. char *cmargp[2];
  3198.  
  3199. VOID
  3200. fnlist() {
  3201.     if (!calibrate)
  3202.       sndsrc = (nfils < 0) ? -1 : nfils; /* Source for filenames */
  3203. #ifdef DYNAMIC
  3204.     if (!cmargbuf && !(cmargbuf = malloc(CKMAXPATH+1)))
  3205.       fatal("fnlist: no memory for cmargbuf");
  3206. #endif /* DYNAMIC */
  3207.     cmargbuf[0] = NUL;            /* Initialize name buffer */
  3208.  
  3209.     debug(F101,"fnlist nfils","",nfils);
  3210.     debug(F110,"fnlist cmarg",cmarg,0);
  3211.     debug(F110,"fnlist cmarg2",cmarg2,0);
  3212.     if (!cmarg2) cmarg2 = "";
  3213.     if (nfils == 0) {            /* Sending from stdin or memory. */
  3214.     if ((cmarg2 != NULL) && (*cmarg2)) {
  3215.         cmarg = cmarg2;        /* If F packet, "as-name" is used */
  3216.         cmarg2 = "";        /* if provided */
  3217.     } else
  3218.       cmarg = "stdin";        /* otherwise just use "stdin" */
  3219.     ckstrncpy(cmargbuf,cmarg,CKMAXPATH+1);
  3220.     cmargp[0] = cmargbuf;
  3221.     cmargp[1] = "";
  3222.     cmlist = cmargp;
  3223.     nfils = 1;
  3224.     }
  3225. }
  3226.  
  3227. int
  3228. sinit() {
  3229.     int x;                /* Worker int */
  3230.     char *tp, *xp, *m;            /* Worker string pointers */
  3231.  
  3232.     filcnt = filrej = 0;        /* Initialize file counters */
  3233.  
  3234.     fnlist();
  3235.  
  3236.     xp = "";
  3237.     if (nfils < 0) {
  3238. #ifdef PIPESEND
  3239.     if (usepipes && protocol == PROTO_K && *cmarg == '!') {
  3240.         pipesend = 1;
  3241.         cmarg++;
  3242.     }
  3243. #endif /* PIPESEND */
  3244.     xp = cmarg;
  3245.     } else {
  3246. #ifndef NOMSEND
  3247.     if (addlist)
  3248.       xp = filehead->fl_name;
  3249.     else
  3250. #endif /* NOMSEND */
  3251.       if (filefile)
  3252.         xp = filefile;
  3253.       else if (calibrate)
  3254.         xp = "Calibration";
  3255.       else
  3256.         xp = *cmlist;
  3257.     }
  3258.     debug(F110,"sinit xp",xp,0);
  3259.     x = gnfile();            /* Get first filename. */
  3260.     debug(F111,"sinit gnfile",ckitoa(gnferror),x);
  3261.     if (x == 0) x = gnferror;        /* If none, get error reason */
  3262.     m = NULL;                /* Error message pointer */
  3263.     debug(F101,"sinit gnfil","",x);
  3264.     switch (x) {
  3265.       case -6: m = "No files meet selection criteria"; break;
  3266.       case -5: m = "Too many files match wildcard"; break;
  3267.       case -4: m = "Cancelled"; break;
  3268.       case -3: m = "Read access denied"; break;
  3269.       case -2: m = "File is not readable"; break;
  3270. #ifdef COMMENT
  3271.       case -1: m = iswild(filnam) ? "No files match" : "File not found";
  3272.     break;
  3273.       case  0: m = "No filespec given!"; break;
  3274. #else
  3275.       case  0:
  3276.       case -1: m = iswild(filnam) ? "No files match" : "File not found";
  3277.     break;
  3278. #endif /* COMMENT */
  3279.       default:
  3280.     break;
  3281.     }
  3282.     debug(F101,"sinit nfils","",nfils);
  3283.     debug(F110,"sinit filnam",filnam,0);
  3284.     if (x < 1) {            /* Didn't get a file. */
  3285.     debug(F111,"sinit msg",m,x);
  3286.     if (server) {            /* Doing GET command */
  3287.         errpkt((CHAR *)m);        /* so send Error packet. */
  3288.     } else if (!local) {         /* Doing SEND command */
  3289.         interrupted = 1;        /* (To suppress hint) */
  3290.         printf("?%s\r\n",m);
  3291.     } else {
  3292.         xxscreen(SCR_EM,0,0l,m);    /* so print message. */
  3293.     }
  3294.     tlog(F110,xp,m,0L);        /* Make transaction log entry. */
  3295.     freerbuf(rseqtbl[0]);        /* Free the buffer the GET came in. */
  3296.     return(0);            /* Return failure code */
  3297.     }
  3298.     if (!local && !server && ckdelay > 0) /* OS-9 sleep(0) == infinite */
  3299.       sleep(ckdelay);            /* Delay if requested */
  3300. #ifdef datageneral
  3301.     if ((local) && (!quiet))            /* Only do this if local & not quiet */
  3302.       consta_mt();            /* Start the async read task */
  3303. #endif /* datageneral */
  3304.     freerbuf(rseqtbl[0]);        /* Free the buffer the GET came in. */
  3305.     sipkt('S');                /* Send the Send-Init packet. */
  3306.     ztime(&tp);                /* Get current date/time */
  3307.     tlog(F110,"Transaction begins",tp,0L); /* Make transaction log entry */
  3308.     tlog(F110,"Global file mode:", binary ? "binary" : "text", 0L);
  3309.     tlog(F100,"","",0);
  3310.     debug(F111,"sinit ok",filnam,0);
  3311.     return(1);
  3312. }
  3313.  
  3314. int
  3315. #ifdef CK_ANSIC
  3316. sipkt(char c)                /* Send S or I packet. */
  3317. #else
  3318. sipkt(c) char c;
  3319. #endif
  3320. /* sipkt */ {
  3321.     CHAR *rp; int k, x;
  3322.     extern int sendipkts;
  3323.     debug(F101,"sipkt pktnum","",pktnum); /* (better be 0...) */
  3324.     ttflui();                /* Flush pending input. */
  3325.     /*
  3326.       If this is an I packet and SET SEND I-PACKETS is OFF, don't send it;
  3327.       set sstate to 'Y' which makes the next input() call return 'Y' as if we
  3328.       had received an ACK to the I packet we didn't send.  This is to work
  3329.       around buggy Kermit servers that can't handle I packets.
  3330.     */
  3331.     if ((sendipkts == 0) && (c == 'I')) { /* I packet but don't send I pkts? */
  3332.     sstate = 'Y';              /* Yikes! */
  3333.     return(0);              /* (see input()..)*/
  3334.     }
  3335.     k = sseqtbl[pktnum];        /* Find slot for this packet */
  3336.     if (k < 0) {            /* No slot? */
  3337.     k = getsbuf(winlo = pktnum);    /* Make one. */
  3338.     debug(F101,"sipkt getsbuf","",k);
  3339.     }
  3340.     rp = rpar();            /* Get protocol parameters. */
  3341.     if (!rp) rp = (CHAR *)"";
  3342.     x = spack(c,pktnum,(int)strlen((char *)rp),rp); /* Send them. */
  3343.     return(x);
  3344. }
  3345.  
  3346. /*  X S I N I T  --  Retransmit S-packet  */
  3347. /*
  3348.   For use in the GET-SEND sequence, when we start to send, but receive another
  3349.   copy of the GET command because the receiver didn't get our S packet.
  3350.   This retransmits the S packet and frees the receive buffer for the ACK.
  3351.   This special case is necessary because packet number zero is being re-used.
  3352. */
  3353. VOID
  3354. xsinit() {
  3355.     int k;
  3356.     k = rseqtbl[0];
  3357.     debug(F101,"xsinit k","",k);
  3358.     if (k > -1)
  3359.     freerbuf(k);
  3360.     resend(0);
  3361. }
  3362.  
  3363. /*  R C V F I L -- Receive a file  */
  3364.  
  3365. /*
  3366.   Incoming filename is in data field of F packet.
  3367.   This function decodes it into the srvcmd buffer, substituting an
  3368.   alternate "as-name", if one was given.
  3369.   Then it does any requested transformations (like converting to
  3370.   lowercase), and finally if a file of the same name already exists,
  3371.   takes the desired collision action.
  3372.   Returns:
  3373.     1 on success.
  3374.     0 on failure.
  3375. */
  3376. char ofn1[CKMAXPATH+4];            /* Buffer for output file name */
  3377. char * ofn2;                /* Pointer to backup file name */
  3378. int ofn1x;                /* Flag output file already exists */
  3379. CK_OFF_T ofn1len = (CK_OFF_T)0;
  3380. int opnerr;                /* Flag for open error */
  3381.  
  3382. int                    /* Returns success ? 1 : 0 */
  3383. rcvfil(n) char *n; {
  3384.     extern int en_cwd;
  3385.     int i, skipthis;
  3386.     char * n2;
  3387.     char * dispo;
  3388. #ifdef OS2ONLY
  3389.     char *zs, *longname, *newlongname, *pn; /* OS/2 long name items */
  3390. #endif /* OS2ONLY */
  3391. #ifdef DTILDE
  3392.     char *dirp;
  3393. #endif /* DTILDE */
  3394.     int dirflg, x, y;
  3395. #ifdef PIPESEND
  3396.     extern char * rcvfilter;
  3397. #endif /* PIPESEND */
  3398. #ifdef CALIBRATE
  3399.     extern int dest;
  3400.     CK_OFF_T csave;
  3401.     csave = calibrate;            /* So we can decode filename */
  3402.     calibrate = (CK_OFF_T)0;
  3403. #endif /* CALIBRATE */
  3404.  
  3405.     ofperms = "";            /* Reset old-file permissions */
  3406.     opnerr = 0;                /* No open error (yet) */
  3407.     ofn2 = NULL;            /* No new name (yet) */
  3408.     lsstate = 0;            /* Cancel locking-shift state */
  3409.     srvptr = srvcmd;            /* Decode file name from packet. */
  3410.  
  3411. #ifdef UNICODE
  3412.     xpnbyte(-1,0,0,NULL);        /* Reset UCS-2 byte counter. */
  3413. #endif /* UNICODE */
  3414.  
  3415.     debug(F110,"rcvfil rdatap",rdatap,0);
  3416.     decode(rdatap,putsrv,0);        /* Don't xlate charsets. */
  3417. #ifdef CALIBRATE
  3418.     calibrate = csave;
  3419.     if (dest == DEST_N) {
  3420.     calibrate = 1;
  3421.     cmarg2 = "CALIBRATE";
  3422.     }
  3423. #endif /* CALIBRATE */
  3424.     if (*srvcmd == '\0')        /* Watch out for null F packet. */
  3425.       ckstrncpy((char *)srvcmd,"NONAME",srvcmdlen);
  3426.     makestr(&prrfspec,(char *)srvcmd);    /* New preliminary filename */
  3427. #ifdef DTILDE
  3428.     if (*srvcmd == '~') {
  3429.     dirp = tilde_expand((char *)srvcmd); /* Expand tilde, if any. */
  3430.     if (*dirp != '\0')
  3431.       ckstrncpy((char *)srvcmd,dirp,srvcmdlen);
  3432.     }
  3433. #else
  3434. #ifdef OS2
  3435.     if (isalpha(*srvcmd) && srvcmd[1] == ':' && srvcmd[2] == '\0')
  3436.       ckstrncat((char *)srvcmd,"NONAME",srvcmdlen);
  3437. #endif /* OS2 */
  3438. #endif /* DTILDE */
  3439.  
  3440. #ifndef NOICP
  3441. #ifndef NOSPL
  3442. /* File dialog when downloading...  */
  3443.     if (
  3444. #ifdef CK_APC
  3445.     (apcactive == APC_LOCAL && adl_ask) || /* Autodownload with ASK */
  3446. #endif /* CK_APC */
  3447.     (clcmds && haveurl)        /* Or "kermit:" or "iksd:" URL */
  3448.     ) {
  3449.     int x;
  3450.     char fnbuf[CKMAXPATH+1];    /* Result buffer */
  3451.     char * preface;
  3452.  
  3453.     if (clcmds && haveurl)
  3454.       preface = "\r\nIncoming file from Kermit server...\r\n\
  3455. Please confirm output file specification or supply an alternative:";
  3456.     else
  3457.       preface = "\r\nIncoming file from remote Kermit...\r\n\
  3458. Please confirm output file specification or supply an alternative:";
  3459.  
  3460.     x = uq_file(preface,        /* Preface */
  3461.             NULL,        /* Prompt (let uq_file() built it) */
  3462.             3,            /* Output file */
  3463.             NULL,        /* Help text */
  3464.             (char *)srvcmd,    /* Default */
  3465.             fnbuf,        /* Result buffer */
  3466.             CKMAXPATH+1        /* Size of result buffer */
  3467.             );
  3468.     if (x < 1) {            /* Refused */
  3469.         rf_err = "Refused by user";
  3470.         return(0);
  3471.     }
  3472.     ckstrncpy((char *)srvcmd,fnbuf,CKMAXPATH+1);
  3473.     if (isabsolute((char *)srvcmd)) { /* User gave an absolute path */
  3474.         g_fnrpath = fnrpath;    /* Save current RECEIVE PATHNAMES */
  3475.         fnrpath = PATH_ABS;        /* switch to ABSOLUTE */
  3476.     }
  3477.     }
  3478. #endif /* NOSPL */
  3479. #endif /* NOICP */
  3480.  
  3481.     if (!ENABLED(en_cwd)) {        /* CD is disabled */
  3482.     zstrip((char *)(srvcmd+2),&n2); /* and they included a pathname, */
  3483.     if (strcmp((char *)(srvcmd+2),n2)) { /* so refuse. */
  3484.         rf_err = "Access denied";
  3485.         return(0);
  3486.     }
  3487.     }
  3488. #ifdef COMMENT
  3489.     /* Wrong place for this -- handle cmarg2 first -- see below...  */
  3490.  
  3491.     if (zchko((char *)srvcmd) < 0) {    /* Precheck for write access */
  3492.     debug(F110,"rcvfil access denied",srvcmd,0);
  3493.     rf_err = "Write access denied";
  3494.     discard = opnerr = 1;
  3495.     return(0);
  3496.     }
  3497.     xxscreen(SCR_FN,0,0l,(char *)srvcmd); /* Put it on screen if local */
  3498.     debug(F110,"rcvfil srvcmd 1",srvcmd,0);
  3499.     tlog(F110,"Receiving",(char *)srvcmd,0L); /* Transaction log entry */
  3500. #endif /* COMMENT */
  3501.  
  3502.     skipthis = 0;            /* This file in our exception list? */
  3503.     for (i = 0; i < NSNDEXCEPT; i++) {
  3504.     if (!rcvexcept[i]) {
  3505.         break;
  3506.     }
  3507.     if (ckmatch(rcvexcept[i],(char *)srvcmd,filecase,1)) {
  3508.         skipthis = 1;
  3509.         break;
  3510.     }
  3511.     }
  3512.  
  3513. #ifdef DEBUG
  3514.     if (deblog && skipthis) {
  3515.     debug(F111,"rcvfil rcvexcept",rcvexcept[i],i);
  3516.     debug(F110,"rcvfil skipping",srvcmd,0);
  3517.     }
  3518. #endif /* DEBUG */
  3519.  
  3520.     if (skipthis) {            /* Skipping this file */
  3521.     discard = 1;
  3522.     rejection = 1;
  3523.     rf_err = "Exception list";
  3524.     debug(F101,"rcvfil discard","",discard);
  3525.     tlog(F100," refused: exception list","",0);
  3526.     return(1);
  3527.     }
  3528.  
  3529.     /* File is not in exception list */
  3530.  
  3531.     if (!cmarg2)            /* No core dumps please */
  3532.       cmarg2 = "";
  3533.     debug(F110,"rcvfil cmarg2",cmarg2,0);
  3534.  
  3535.     if (*cmarg2) {            /* Check for alternate name */
  3536. #ifndef NOSPL
  3537.     int y; char *s;            /* Pass it thru the evaluator */
  3538.     extern int cmd_quoting;
  3539.     if (cmd_quoting) {
  3540.         y = MAXRP;
  3541.         ckstrncpy(ofn1,(char *)srvcmd,CKMAXPATH+1); /* for \v(filename) */
  3542.         s = (char *)srvcmd;
  3543.         zzstring(cmarg2,&s,&y);
  3544.     } else
  3545.       *srvcmd = NUL;
  3546.     if (!*srvcmd)            /* If we got something */
  3547. #endif /* NOSPL */
  3548.       ckstrncpy((char *)srvcmd,cmarg2,srvcmdlen);
  3549.     }
  3550.     debug(F110,"rcvfil srvcmd 2",srvcmd,0);
  3551.  
  3552. #ifdef PIPESEND
  3553.     /* If it starts with "bang", it's a pipe, not a file. */
  3554.     if (usepipes && protocol == PROTO_K && *srvcmd == '!' && !rcvfilter) {
  3555.     CHAR *s;
  3556.     s = srvcmd+1;            /* srvcmd[] is not a pointer. */
  3557.     while (*s) {            /* So we have to slide the contents */
  3558.         *(s-1) = *s;        /* over 1 space to the left. */
  3559.         s++;
  3560.     }
  3561.     *(s-1) = NUL;
  3562.     pipesend = 1;
  3563.     }
  3564. #endif /* PIPESEND */
  3565.  
  3566. #ifdef COMMENT
  3567. /*
  3568.   This is commented out because we need to know whether the name we are
  3569.   using was specified by the local user as an override, or came from the
  3570.   incoming packet.  In the former case, we don't do stuff to it (like
  3571.   strip the pathname) that we might do to it in the latter.
  3572. */
  3573.     cmarg2 = "";            /* Done with alternate name */
  3574. #endif /* COMMENT */
  3575.  
  3576.     if ((int)strlen((char *)srvcmd) > CKMAXPATH) /* Watch out for overflow */
  3577.       *(srvcmd + CKMAXPATH - 1) = NUL;
  3578.  
  3579.     /* At this point, srvcmd[] contains the incoming filename or as-name. */
  3580.     /* So NOW we check for write access. */
  3581.  
  3582.     if (zchko((char *)srvcmd) < 0) {    /* Precheck for write access */
  3583.     debug(F110,"rcvfil access denied",srvcmd,0);
  3584.     rf_err = "Write access denied";
  3585.     discard = opnerr = 1;
  3586.     return(0);
  3587.     }
  3588.     xxscreen(SCR_FN,0,0l,(char *)srvcmd); /* Put it on screen if local */
  3589.     debug(F110,"rcvfil srvcmd 1",srvcmd,0);
  3590.     tlog(F110,"Receiving",(char *)srvcmd,0L); /* Transaction log entry */
  3591.  
  3592. #ifdef CK_LABELED
  3593. #ifdef VMS
  3594. /*
  3595.   If we have an as-name, this overrides the internal name if we are doing
  3596.   a labeled-mode transfer.
  3597. */
  3598.     if (*cmarg2) {
  3599.     extern int lf_opts;
  3600.     lf_opts &= ~LBL_NAM;
  3601.     }
  3602. #endif /* VMS */
  3603. #endif /* CK_LABELED */
  3604.  
  3605.     debug(F111,"rcvfil pipesend",srvcmd,pipesend);
  3606.  
  3607. #ifdef PIPESEND
  3608.     /* Skip all the filename manipulation and collision actions */
  3609.     if (pipesend) {
  3610.     dirflg = 0;
  3611.     ofn1[0] = '!';
  3612.     ckstrncpy(&ofn1[1],(char *)srvcmd,CKMAXPATH+1);
  3613.     ckstrncpy(n,ofn1,CKMAXPATH+1);
  3614.     ckstrncpy(fspec,ofn1,CKMAXPATH+1);
  3615.     makestr(&prfspec,fspec);    /* New preliminary filename */
  3616.     debug(F110,"rcvfil pipesend",ofn1,0);
  3617.     goto rcvfilx;
  3618.     }
  3619. #endif /* PIPESEND */
  3620. /*
  3621.   This is to avoid passing email subjects through nzrtol().
  3622.   We haven't yet received the A packet so we don't yet know it's e-mail,
  3623.   so in fact we go ahead and convert it anyway, but later we get the
  3624.   original back from ofilnam[].
  3625. */  
  3626.     dispos = 0;
  3627.     ckstrncpy(ofilnam,(char *)srvcmd,CKMAXPATH+1);
  3628.  
  3629. #ifdef NZLTOR
  3630.     if (*cmarg2)
  3631.       ckstrncpy((char *)ofn1,(char *)srvcmd,CKMAXPATH+1);
  3632.     else
  3633.       nzrtol((char *)srvcmd,        /* Filename from packet */
  3634.          (char *)ofn1,        /* Where to put result */
  3635.          fncnv,            /* Filename conversion */
  3636.          fnrpath,            /* Pathname handling */
  3637.          CKMAXPATH            /* Size of result buffer */
  3638.          );
  3639. #else
  3640.     debug(F101,"rcvfil fnrpath","",fnrpath); /* Handle pathnames */
  3641.     if (fnrpath == PATH_OFF && !*cmarg2) { /* RECEIVE PATHNAMES OFF? */
  3642.     char *t;            /* Yes. */
  3643.     zstrip((char *)srvcmd,&t);    /* If there is a pathname, strip it */
  3644.     debug(F110,"rcvfil PATH_OFF zstrip",t,0);
  3645.     if (!t)                /* Be sure we didn't strip too much */
  3646.       sprintf(ofn1,"FILE%02ld",filcnt);
  3647.     else if (*t == '\0')
  3648.       sprintf(ofn1,"FILE%02ld",filcnt);
  3649.     else
  3650.       ckstrncpy(ofn1,t,CKMAXPATH+1);
  3651.     ckstrncpy((char *)srvcmd,ofn1,srvcmdlen); /* Now copy it back. */
  3652.     }
  3653. /*
  3654.   SET RECEIVE PATHNAMES RELATIVE...
  3655.   The following doesn't belong here but doing it right would require
  3656.   defining and implementing a new file routine for all ck?fio.c modules.
  3657.   So for now...
  3658. */
  3659. #ifdef UNIXOROSK
  3660.     else if (fnrpath == PATH_REL && !*cmarg2) {
  3661.     if (isabsolute((char *)srvcmd)) {
  3662.         ofn1[0] = '.';
  3663.         ckstrncpy(&of1n[1],(char *)srvcmd,CKMAXPATH+1);
  3664.         ckstrncpy((char *)srvcmd,ofn1,srvcmdlen);
  3665.         debug(F110,"rcvfil PATH_REL",ofn1,0);
  3666.     }
  3667.     }
  3668. #else
  3669. #ifdef OS2
  3670.     else if (fnrpath == PATH_REL && !*cmarg2) {
  3671.     if (isabsolute((char *)srvcmd)) {
  3672.         char *p = (char *)srvcmd;
  3673.         if (isalpha(*p) && *(p+1) == ':')
  3674.           p += 2;
  3675.         if (*p == '\\' || *p == '/')
  3676.           p++;
  3677.         ckstrncpy(ofn1,p,CKMAXPATH+1);
  3678.         ckstrncpy((char *)srvcmd,ofn1,srvcmdlen);
  3679.         debug(F110,"rcvfil OS2 PATH_REL",ofn1,0);
  3680.     }
  3681.     }
  3682. #endif /* OS2 */
  3683. #endif /* UNIXOROSK */
  3684.  
  3685.     /* Now srvcmd contains incoming filename with path possibly stripped */
  3686.  
  3687.     if (fncnv)                /* FILE NAMES CONVERTED? */
  3688.       zrtol((char *)srvcmd,(char *)ofn1); /* Yes, convert to local form */
  3689.     else
  3690.       ckstrncpy(ofn1,(char *)srvcmd,CKMAXPATH+1); /* No, copy literally. */
  3691. #endif /* NZLTOR */
  3692.  
  3693. #ifdef PIPESEND
  3694.     if (rcvfilter) {
  3695.     char * p = NULL, * q;
  3696.     int nn = MAXRP;
  3697.     pipesend = 1;
  3698.     debug(F110,"rcvfil rcvfilter ",rcvfilter,0);
  3699. #ifndef NOSPL
  3700.     if ((p = (char *) malloc(nn + 1))) {
  3701.         q = p;
  3702. #ifdef COMMENT
  3703.             /* We have already processed srvcmd and placed it into ofn1 */
  3704.             ckstrncpy(ofn1,(char *)srvcmd,CKMAXPATH+1); /* For \v(filename) */
  3705. #endif /* COMMENT */
  3706.         debug(F110,"rcvfile pipesend filter",rcvfilter,0);
  3707.         zzstring(rcvfilter,&p,&nn);
  3708.         debug(F111,"rcvfil pipename",q,nn);
  3709.         if (nn <= 0) {
  3710.         printf(
  3711.                "?Sorry, receive filter + filename too long, %d max.\n",
  3712.                CKMAXPATH
  3713.                );
  3714.         rf_err = "Name too long";
  3715.         free(q);
  3716.         return(0);
  3717.         }
  3718.         ckstrncpy((char *)srvcmd,q,MAXRP);
  3719.         free(q);
  3720.     }
  3721. #endif /* NOSPL */
  3722.     }
  3723. #endif /* PIPESEND */
  3724.  
  3725.     /* Now the incoming filename, possibly converted, is in ofn1[]. */
  3726.  
  3727. #ifdef OS2
  3728.     /* Don't refuse the file just because the name is illegal. */
  3729.     if (!IsFileNameValid(ofn1)) {    /* Name is OK for OS/2? */
  3730. #ifdef OS2ONLY
  3731.     char *zs = NULL;
  3732.     zstrip(ofn1, &zs);        /* Not valid, strip unconditionally */
  3733.     if (zs) {
  3734.         if (iattr.longname.len &&    /* Free previous longname, if any */
  3735.         iattr.longname.val)
  3736.           free(iattr.longname.val);
  3737.         iattr.longname.len = strlen(zs); /* Store in attribute structure */
  3738.         iattr.longname.val = (char *) malloc(iattr.longname.len + 1);
  3739.         if (iattr.longname.val)    /* Remember this (illegal) name */
  3740.           strcpy(iattr.longname.val, zs); /* safe */
  3741.     }
  3742. #endif /* OS2ONLY */
  3743.     debug(F110,"rcvfil: invalid file name",ofn1,0);
  3744.     ChangeNameForFAT(ofn1);    /* Change to an acceptable name */
  3745.     debug(F110,"rcvfil: FAT file name",ofn1,0);
  3746.  
  3747.     } else {                /* Name is OK. */
  3748.  
  3749.     debug(F110,"rcvfil: valid file name",ofn1,0);
  3750. #ifdef OS2ONLY
  3751.     if (iattr.longname.len &&
  3752.          iattr.longname.val)    /* Free previous longname, if any */
  3753.       free(iattr.longname.val);
  3754.     iattr.longname.len = 0;
  3755.     iattr.longname.val = NULL;    /* This file doesn't need a longname */
  3756. #endif /* OS2ONLY */
  3757.     }
  3758. #endif /* OS2 */
  3759.     debug(F110,"rcvfil as",ofn1,0);
  3760.  
  3761. /* Filename collision action section. */
  3762.  
  3763.     dirflg =                /* Is it a directory name? */
  3764. #ifdef CK_TMPDIR
  3765.         isdir(ofn1)
  3766. #else
  3767.     0
  3768. #endif /* CK_TMPDIR */
  3769.       ;
  3770.     debug(F101,"rcvfil dirflg","",dirflg);
  3771.     ofn1len = zchki(ofn1);        /* File already exists? */
  3772.     debug(F111,"rcvfil ofn1len",ofn1,ofn1len);
  3773.     ofn1x = (ofn1len != (CK_OFF_T)-1);
  3774.  
  3775.     if ( (
  3776. #ifdef UNIX
  3777.     strcmp(ofn1,"/dev/null") &&    /* It's not the null device? */
  3778. #else
  3779. #ifdef OSK
  3780.     strcmp(ofn1,"/nil") &&
  3781. #endif /* OSK */
  3782. #endif /* UNIX */
  3783.     !stdouf ) &&            /* Not copying to standard output? */
  3784.     ofn1x ||            /* File of same name exists? */
  3785.     dirflg ) {            /* Or file is a directory? */
  3786.         debug(F111,"rcvfil exists",ofn1,fncact);
  3787. #ifdef CK_PERMS
  3788.     ofperms = zgperm((char *)ofn1);    /* Get old file's permissions */
  3789.     debug(F110,"rcvfil perms",ofperms,0);
  3790. #endif /* CK_PERMS */
  3791.  
  3792.     debug(F101,"rcvfil fncact","",fncact);
  3793.     switch (fncact) {        /* Yes, do what user said. */
  3794.       case XYFX_A:            /* Append */
  3795.         ofperms = "";
  3796.         debug(F100,"rcvfil append","",0);
  3797.         if (dirflg) {
  3798.         rf_err = "Can't append to a directory";
  3799.         tlog(F100," error - can't append to directory","",0);
  3800.         discard = opnerr = 1;
  3801.         return(0);
  3802.         }
  3803.         tlog(F110," appending to",ofn1,0);
  3804.         break;
  3805. #ifdef COMMENT
  3806.       case XYFX_Q:            /* Query (Ask) */
  3807.         break;            /* not implemented */
  3808. #endif /* COMMENT */
  3809.       case XYFX_B:            /* Backup (rename old file) */
  3810.         if (dirflg) {
  3811.         rf_err = "Can't rename existing directory";
  3812.         tlog(F100," error - can't rename directory","",0);
  3813.         discard = opnerr = 1;
  3814.         return(0);
  3815.         }
  3816.         znewn(ofn1,&ofn2);        /* Get new unique name */
  3817.         tlog(F110," backup:",ofn2,0);
  3818.         debug(F110,"rcvfil backup ofn1",ofn1,0);
  3819.         debug(F110,"rcvfil backup ofn2",ofn2,0);
  3820. #ifdef CK_LABELED
  3821. #ifdef OS2ONLY
  3822. /*
  3823.   In case this is a FAT file system, we can't change only the FAT name, we
  3824.   also have to change the longname from the extended attributes block.
  3825.   Otherwise, we'll have many files with the same longname and if we copy them
  3826.   to an HPFS volume, only one will survive.
  3827. */
  3828.         if (os2getlongname(ofn1, &longname) > -1) {
  3829.         if (strlen(longname)) {
  3830.             char tmp[10];
  3831.             extern int ck_znewn;
  3832.             sprintf(tmp,".~%d~",ck_znewn);
  3833.             newlongname =
  3834.               (char *) malloc(strlen(longname) + strlen(tmp) + 1);
  3835.             if (newlongname) {
  3836.             strcpy(newlongname, longname); /* safe (prechecked) */
  3837.             strcat(newlongname, tmp); /* safe (prechecked) */
  3838.             os2setlongname(ofn1, newlongname);
  3839.             free(newlongname);
  3840.             newlongname = NULL;
  3841.             }
  3842.         }
  3843.         } else debug(F100,"rcvfil os2getlongname failed","",0);
  3844. #endif /* OS2ONLY */
  3845. #endif /* CK_LABELED */
  3846.  
  3847. #ifdef COMMENT
  3848.         /* Do this later, in opena()... */
  3849.         if (zrename(ofn1,ofn2) < 0) {
  3850.         rf_err = "Can't transform filename";
  3851.         debug(F110,"rcvfil rename fails",ofn1,0);
  3852.         discard = opnerr = 1;
  3853.         return(0);
  3854.         }
  3855. #endif /* COMMENT */
  3856.         break;
  3857.  
  3858.       case XYFX_D:            /* Discard (refuse new file) */
  3859.         ofperms = "";
  3860.         discard = 1;
  3861.         rejection = 1;        /* Horrible hack: reason = name */
  3862.         debug(F101,"rcvfil discard","",discard);
  3863.         tlog(F100," refused: name","",0);
  3864.         break;
  3865.  
  3866.       case XYFX_R:            /* Rename incoming file */
  3867.         znewn(ofn1,&ofn2);        /* Make new name for it */
  3868. #ifdef OS2ONLY
  3869.         if (iattr.longname.len) {
  3870.         char tmp[10];
  3871.         extern int ck_znewn;
  3872.         sprintf(tmp,".~%d~",ck_znewn);
  3873.         newlongname =
  3874.           (char *) malloc(iattr.longname.len + strlen(tmp) + 1);
  3875.         if (newlongname) {
  3876.             strcpy(newlongname, iattr.longname.val); /* safe */
  3877.             strcat(newlongname, tmp); /* safe */
  3878.             debug(F110,
  3879.               "Rename Incoming: newlongname",newlongname,0);
  3880.             if (iattr.longname.len &&
  3881.             iattr.longname.val)
  3882.               free(iattr.longname.val);
  3883.             iattr.longname.len = strlen(newlongname);
  3884.             iattr.longname.val = newlongname;
  3885.             /* free(newlongname) here ? */
  3886.         }
  3887.         }
  3888. #endif /* OS2ONLY */
  3889.         break;
  3890.       case XYFX_X:            /* Replace old file */
  3891.         debug(F100,"rcvfil overwrite","",0);
  3892.         if (dirflg) {
  3893.         rf_err = "Can't overwrite existing directory";
  3894.         tlog(F100," error - can't overwrite directory","",0);
  3895.         discard = opnerr = 1;
  3896. #ifdef COMMENT
  3897.         return(0);
  3898. #else
  3899.         break;
  3900. #endif /* COMMENT */
  3901.         }
  3902.         tlog(F110,"overwriting",ofn1,0);
  3903.         break;
  3904.       case XYFX_U:            /* Refuse if older */
  3905.         debug(F110,"rcvfil update",ofn1,0);
  3906.         if (dirflg) {
  3907.         rf_err = "File has same name as existing directory";
  3908.         tlog(F110," error - directory exists:",ofn1,0);
  3909.         discard = opnerr = 1;
  3910. #ifdef COMMENT
  3911.         /* Don't send an error packet, just refuse the file */
  3912.         return(0);
  3913. #endif /* COMMENT */
  3914.         }
  3915.         break;            /* Not here, we don't have */
  3916.                     /* the attribute packet yet. */
  3917.       default:
  3918.         ofperms = "";
  3919.         debug(F101,"rcvfil bad collision action","",fncact);
  3920.         break;
  3921.     }
  3922.     }
  3923.     debug(F110,"rcvfil ofn1",ofn1,0);
  3924.     debug(F110,"rcvfil ofn2",ofn2,0);
  3925.     debug(F110,"rcvfil ofperms",ofperms,0);
  3926.     if (fncact == XYFX_R && ofn1x && ofn2) { /* Renaming incoming file? */
  3927.     xxscreen(SCR_AN,0,0l,ofn2);    /* Display renamed name */
  3928.     ckstrncpy(n, ofn2, CKMAXPATH+1); /* Return it */
  3929.     } else {                /* No */
  3930.     xxscreen(SCR_AN,0,0l,ofn1);    /* Display regular name */
  3931.     ckstrncpy(n, ofn1, CKMAXPATH+1); /* and return it. */
  3932.     }
  3933.  
  3934. #ifdef CK_MKDIR
  3935. /*  Create directory(s) if necessary.  */
  3936.     if (!discard && fnrpath != PATH_OFF) { /* RECEIVE PATHAMES ON? */
  3937.     int x;
  3938.     debug(F110,"rcvfil calling zmkdir",ofn1,0); /* Yes */
  3939.     if ((x = zmkdir(ofn1)) < 0) {
  3940.         debug(F100,"zmkdir fails","",0);
  3941.         tlog(F110," error - directory creation failure:",ofn1,0);
  3942.         rf_err = "Directory creation failure.";
  3943.         discard = 1;
  3944.         return(0);
  3945.     }
  3946. #ifdef TLOG
  3947.     else if (x > 0)
  3948.       tlog(F110," path created:",ofn1,0);
  3949. #endif /* TLOG */
  3950.     }
  3951. #else
  3952.     debug(F110,"rcvfil CK_MKDIR not defined",ofn1,0);
  3953. #endif /* CK_MKDIR */
  3954.  
  3955.     if (calibrate)
  3956.       ckstrncpy(fspec,ofn1,CKMAXPATH+1);
  3957.     else
  3958.       zfnqfp(ofn1,fspeclen,fspec);
  3959.     debug(F110,"rcvfil fspec",fspec,0);
  3960.  
  3961. #ifdef COMMENT
  3962.     /* See comments with VMS zfnqfp()... */
  3963. #ifdef VMS
  3964.     /* zfnqfp() does not return the version number */
  3965.     if (!calibrate) {
  3966.     int x, v;
  3967.     x = strlen(ofn1);
  3968.     if (x > 0) {
  3969.         if (ofn1[x-1] == ';') {
  3970.         v = getvnum(ofn1);
  3971.         ckstrncpy(&ofn1[x],ckitoa(v),CKMAXPATH-x);
  3972.         }
  3973.     }
  3974.     }
  3975. #endif /* VMS */
  3976. #endif /* COMMENT */
  3977.     fspec[fspeclen] = NUL;
  3978.     makestr(&prfspec,fspec);        /* New preliminary filename */
  3979.  
  3980. #ifdef PIPESEND
  3981.   rcvfilx:
  3982. #endif /* PIPESEND */
  3983.  
  3984.     debug(F110,"rcvfilx: n",n,0);
  3985.     debug(F110,"rcvfilx: ofn1",ofn1,0);
  3986.     ffc = (CK_OFF_T)0;            /* Init per-file counters */
  3987.     cps = oldcps = 0L;
  3988.     rs_len = (CK_OFF_T)0;
  3989.     rejection = -1;
  3990.     fsecs = gtimer();            /* Time this file started */
  3991. #ifdef GFTIMER
  3992.     fpfsecs = gftimer();
  3993.     debug(F101,"rcvfil fpfsecs","",fpfsecs);
  3994. #endif /* GFTIMER */
  3995.     filcnt++;
  3996.     intmsg(filcnt);
  3997.     return(1);                /* Successful return */
  3998. }
  3999.  
  4000.  
  4001. /*  R E O F  --  Receive End Of File packet for incoming file */
  4002.  
  4003. /*
  4004.   Closes the received file.
  4005.   Returns:
  4006.     0 on success.
  4007.    -1 if file could not be closed.
  4008.     2 if disposition was mail, mail was sent, but temp file not deleted.
  4009.     3 if disposition was print, file was printed, but not deleted.
  4010.    -2 if disposition was mail and mail could not be sent
  4011.    -3 if disposition was print and file could not be printed
  4012.    -4 if MOVE-TO: failed
  4013.    -5 if RENAME-TO: failed
  4014. */
  4015. int
  4016. reof(f,yy) char *f; struct zattr *yy; {
  4017.     extern char * rcv_move, * rcv_rename;
  4018.     extern int o_isopen;
  4019.     int rc = 0;                /* Return code */
  4020.     char *p;
  4021.     char c;
  4022.  
  4023.     debug(F111,"reof fncact",f,fncact);
  4024.     debug(F101,"reof discard","",discard);
  4025.     success = 1;            /* Assume status is OK */
  4026.     lsstate = 0;            /* Cancel locking-shift state */
  4027.     if (discard) {            /* Handle attribute refusals, etc. */
  4028.     debug(F101,"reof discarding","",0);
  4029.     success = 0;            /* Status = failed. */
  4030.     if (rejection == '#' ||        /* Unless rejection reason is */
  4031.         rejection ==  1  ||        /* date or name (SET FILE COLLISION */
  4032.         rejection == '?')        /* UPDATE or DISCARD) */
  4033.       success = 1;
  4034.     debug(F101,"reof success","",success);
  4035.     filrej++;            /* Count this rejection. */
  4036.     discard = 0;            /* We never opened the file, */
  4037.     return(0);            /* so we don't close it. */
  4038.     }
  4039. #ifdef DEBUG
  4040.     if (deblog) {
  4041.     debug(F101,"reof cxseen","",cxseen);
  4042.     debug(F101,"reof czseen","",czseen);
  4043.     debug(F110,"reof rdatap",rdatap,0);
  4044.     }
  4045. #endif /* DEBUG */
  4046.  
  4047.     if (cxseen == 0)            /* Got cancel directive? */
  4048.       cxseen = (*rdatap == 'D');
  4049.     if (cxseen || czseen)        /* (for hints) */
  4050.       interrupted = 1;
  4051.     success = (cxseen || czseen) ? 0 : 1; /* Set SUCCESS flag appropriately */
  4052.     if (!success)              /* "Uncount" this file */
  4053.       filrej++;
  4054.     debug(F101,"reof o_isopen","",o_isopen);
  4055.  
  4056.     if (o_isopen) {            /* If an output file was open... */
  4057.  
  4058. #ifdef CK_CTRLZ
  4059.     if (success) {
  4060.         debug(F101,"reof lastchar","",lastchar);
  4061.         if (!binary && eofmethod == XYEOF_Z && lastchar != 26 &&
  4062.         (!xflg || (xflg && remfile)))
  4063.           pnbyte((char)26,putfil);
  4064.     }
  4065. #endif /* CK_CTRLZ */
  4066.  
  4067.     rc = clsof(cxseen || czseen);    /* Close the file (resets cxseen) */
  4068.     debug(F101,"reof closf","",rc);
  4069.     if (rc < 0) {            /* If failure to close, FAIL */
  4070.         if (success) filrej++;
  4071.         success = 0;
  4072.     }
  4073.     if (!calibrate) {
  4074.         /* Set file modification date and/or permissions */
  4075.         if (success)
  4076.           zstime(f,yy,0);
  4077. #ifdef OS2ONLY
  4078. #ifdef CK_LABELED
  4079.         if (success && yy->longname.len)
  4080.           os2setlongname(f, yy->longname.val);
  4081. #endif /* CK_LABELED */
  4082. #endif /* OS2ONLY */
  4083.     }
  4084.     if (success == 0) {        /* And program return code */
  4085.         xitsta |= W_RECV;
  4086.     } else if (success == 1) {    /* File rec'd successfully */
  4087.         makestr(&rrfspec,prrfspec);    /* Record it for wheremsg */
  4088.         makestr(&rfspec,prfspec);
  4089.     }
  4090.  
  4091. /* Handle dispositions from attribute packet... */
  4092.  
  4093.     c = NUL;
  4094. #ifndef NOFRILLS
  4095.     if (!calibrate && yy->disp.len != 0) {
  4096.         p = yy->disp.val;
  4097.         c = *p++;
  4098. #ifndef UNIX
  4099. /*
  4100.   See ckcpro.w.  In UNIX we don't use temp files any more -- we pipe the
  4101.   stuff right into mail or lpr.
  4102. */
  4103.         if (c == 'M') {        /* Mail to user. */
  4104.         rc = zmail(p,filnam);    /* Do the system's mail command */
  4105.         if (rc < 0) success = 0;    /* Remember status */
  4106.         tlog(F110,"mailed",filnam,0L);
  4107.         tlog(F110," to",p,0L);
  4108.         zdelet(filnam);        /* Delete the file */
  4109.         } else if (c == 'P') {    /* Print the file. */
  4110.         rc = zprint(p,filnam);    /* Do the system's print command */
  4111.         if (rc < 0) success = 0; /* Remember status */
  4112.         tlog(F110,"printed",filnam,0L);
  4113.         tlog(F110," with options",p,0L);
  4114. #ifndef VMS
  4115. #ifndef STRATUS
  4116.         /* spooler deletes file after print complete in VOS & VMS */
  4117.         if (zdelet(filnam) && rc == 0) rc = 3; /* Delete the file */
  4118. #endif /* STRATUS */
  4119. #endif /* VMS */
  4120.         }
  4121. #endif /* UNIX */
  4122.     }
  4123. #endif /* NOFRILLS */
  4124.  
  4125.     if (success &&
  4126.         !pipesend &&
  4127.         !calibrate && c != 'M' && c != 'P') {
  4128.         if (rcv_move) {        /* If /MOVE-TO was given... */
  4129.         char * p = rcv_move;
  4130. #ifdef COMMENT
  4131. /* No need for this - it's a directory name */
  4132.         char tmpbuf[CKMAXPATH+1];
  4133.         extern int cmd_quoting;    /* for \v(filename) */
  4134.         if (cmd_quoting) {    /* But only if cmd_quoting is on */
  4135.             int n;
  4136.             n = CKMAXPATH;
  4137.             p = tmpbuf;
  4138.             debug(F111,"reof /move-to",rcv_move,0);
  4139.             zzstring(rcv_move,&p,&n);
  4140.             p = tmpbuf;
  4141.         }
  4142. #endif /* COMMENT */
  4143. /*
  4144.   Here we could create the directory if it didn't exist (and it was relative)
  4145.   but there would have to be a user-settable option to say whether to do this.
  4146. */
  4147.         rc = zrename(filnam,p);
  4148.         debug(F111,"reof MOVE zrename",rcv_move,rc);
  4149.         if (rc > -1) {
  4150.             tlog(F110," moving received file to",rcv_move,0);
  4151.         } else {
  4152.             rc = -4;
  4153.             tlog(F110," FAILED to move received file to",rcv_move,0);
  4154.         }
  4155.         } else if (rcv_rename) {    /* Or /RENAME-TO: */
  4156.         char *s = rcv_rename;    /* This is the renaming string */
  4157. #ifndef NOSPL
  4158.         char tmpnam[CKMAXPATH+16];
  4159.         extern int cmd_quoting;    /* for \v(filename) */
  4160.         if (cmd_quoting) {    /* But only if cmd_quoting is on */
  4161.             int n;        /* Pass it thru the evaluator */
  4162.             n = CKMAXPATH;
  4163.             s = (char *)tmpnam;
  4164.             zzstring(rcv_rename,&s,&n);
  4165.             s = (char *)tmpnam;
  4166.         }
  4167. #endif /* NOSPL */
  4168.         if (s) if (*s) {
  4169.             rc = zrename(filnam,s);
  4170.             debug(F111,"reof RENAME zrename",s,rc);
  4171.             if (rc > -1) {
  4172.             tlog(F110," renaming received file to",s,0);
  4173.             } else {
  4174.             rc = -5;
  4175.             tlog(F110," FAILED to rename received file to",s,0);
  4176.             }
  4177.         }
  4178.         }
  4179.     }
  4180.     }
  4181.     debug(F101,"reof success","",success);
  4182.     debug(F101,"reof returns","",rc);
  4183.  
  4184.     filnam[0] = NUL;            /* Erase the filename */
  4185.     return(rc);
  4186. }
  4187.  
  4188. /*  R E O T  --  Receive End Of Transaction  */
  4189.  
  4190. VOID
  4191. reot() {
  4192.     cxseen = czseen = discard = 0;    /* Reset interruption flags */
  4193.     tstats();                /* Finalize transfer statistics */
  4194. }
  4195.  
  4196. /*  S F I L E -- Send File header or teXt header packet  */
  4197.  
  4198. /*
  4199.   Call with x nonzero for X packet, zero for F packet.
  4200.   If X == 0, filename to send is in filnam[], and if cmarg2 is not null
  4201.   or empty, the file should be sent under this name rather than filnam[].
  4202.   If sndfilter not NULL, it is the name of a send filter.
  4203.   Returns 1 on success, 0 on failure.
  4204. */
  4205. int
  4206. sfile(x) int x; {
  4207. #ifdef pdp11
  4208. #define PKTNL 64
  4209. #else
  4210. #define PKTNL 256
  4211. #endif /* pdp11 */
  4212.     char pktnam[PKTNL+1];        /* Local copy of name */
  4213.     char *s;
  4214.     int rc;
  4215.     int notafile = 0;
  4216.     extern int filepeek;
  4217. #ifdef PIPESEND
  4218.     extern char * sndfilter;
  4219.  
  4220.     if (sndfilter) {
  4221.     pipesend = 1;
  4222.     debug(F110,"sfile send filter ",sndfilter,0);
  4223.     }
  4224. #endif /* PIPESEND */
  4225.  
  4226.     notafile = calibrate || sndarray || pipesend || x;
  4227.     debug(F101,"sfile x","",x);
  4228.     debug(F101,"sfile notafile","",notafile);
  4229.  
  4230. #ifndef NOCSETS
  4231.     if (tcs_save > -1) {                /* Character sets */
  4232.         tcharset = tcs_save;
  4233.         tcs_save = -1;
  4234.     debug(F101,"sfile restored tcharset","",tcharset);
  4235.     }
  4236.     if (fcs_save > -1) {
  4237.         fcharset = fcs_save;
  4238.         fcs_save = -1;
  4239.     debug(F101,"sfile restored fcharset","",fcharset);
  4240.     }
  4241.     setxlatype(tcharset,fcharset);      /* Translation type */
  4242. #endif /* NOCSETS */
  4243.  
  4244.     /* cmarg2 or filnam (with that precedence) have the file's name */
  4245.  
  4246.     lsstate = 0;            /* Cancel locking-shift state */
  4247. #ifdef COMMENT
  4248.     /* Do this after making sure we can open the file */
  4249.     if (nxtpkt() < 0) return(0);    /* Bump packet number, get buffer */
  4250. #endif /* COMMENT */
  4251.     pktnam[0] = NUL;            /* Buffer for name we will send */
  4252.     if (x == 0) {            /* F-Packet setup */
  4253.     if (!cmarg2) cmarg2 = "";
  4254. #ifdef DEBUG
  4255.     if (deblog) {
  4256.         /* debug(F111,"sfile cmarg2",cmarg2,cmarg2); */
  4257.         debug(F101,"sfile binary 1","",binary);
  4258.         debug(F101,"sfile wearealike","",wearealike);
  4259.         debug(F101,"sfile xfermode","",xfermode);
  4260.         debug(F101,"sfile filepeek","",filepeek);
  4261. #ifndef NOCSETS
  4262.         debug(F101,"sfile s_cset","",s_cset);
  4263.         debug(F101,"sfile tcharset","",tcharset);
  4264.         debug(F101,"sfile xfrxla","",xfrxla);
  4265. #endif /* NOCSETS */
  4266.     }
  4267. #endif /* DEBUG */
  4268.     if (xfermode == XMODE_A        /* TRANSFER MODE AUTOMATIC */
  4269. #ifndef NOMSEND
  4270.         && !addlist            /* And not working from a SEND-LIST */
  4271. #endif /* NOMSEND */
  4272.         ) {
  4273.         /* Other Kermit is on a like system and no charset translation */
  4274.         if (wearealike
  4275. #ifndef NOCSETS
  4276.         && (tcharset == TC_TRANSP || xfrxla == 0)
  4277. #endif /* NOCSETS */
  4278.         ) {
  4279. #ifdef VMS
  4280.         if (binary != XYFT_I)
  4281. #endif /* VMS */
  4282. #ifdef CK_LABELED
  4283.           if (binary != XYFT_L)
  4284. #endif /* CK_LABELED */
  4285.             binary = XYFT_B;    /* Send all files in binary mode */
  4286.         }
  4287.  
  4288.         /* Otherwise select transfer mode based on file info */
  4289.  
  4290.         else if (!notafile        /* but not if sending from pipe */
  4291. #ifdef CK_LABELED
  4292.              && binary != XYFT_L /* and not if FILE TYPE LABELED */
  4293. #endif /* CK_LABELED */
  4294. #ifdef VMS
  4295.              && binary != XYFT_I /* or FILE TYPE IMAGE */
  4296. #endif /* VMS */
  4297.              ) {
  4298. #ifdef UNICODE
  4299.         fileorder = -1;        /* File byte order */
  4300. #endif /* UNICODE */
  4301.         if (filepeek && !notafile) { /* Real file, FILE SCAN is ON */
  4302.             int k, x;
  4303.             k = scanfile(filnam,&x,nscanfile); /* Scan the file */
  4304.             debug(F101,"sfile scanfile","",k);
  4305.             switch (k) {
  4306.               case FT_TEXT:    /* Unspecified text */
  4307.             debug(F100,"sfile scanfile text","",0);
  4308.             binary = XYFT_T; /* SET FILE TYPE TEXT */
  4309.             break;
  4310. #ifndef NOCSETS
  4311.               case FT_7BIT:        /* 7-bit text */
  4312.             binary = XYFT_T;    /* SET FILE TYPE TEXT */
  4313.             /* If SEND CHARSET-SELECTION AUTO  */
  4314.             /* and SET TRANSFER TRANSLATION is ON */
  4315.             debug(F100,"sfile scanfile text7","",0);
  4316.             if (s_cset == XMODE_A && xfrxla) {
  4317.                 if (fcsinfo[fcharset].size != 128) {
  4318.                 fcs_save = fcharset; /* Current FCS not 7bit */
  4319.                 fcharset = dcset7;   /* Use default 7bit set */
  4320.                 debug(F101,"sfile scanfile 7 fcharset",
  4321.                       "",fcharset);
  4322.                 }
  4323.                 /* And also switch to appropriate TCS */
  4324.                 if (afcset[fcharset] > -1 &&
  4325.                 afcset[fcharset] <= MAXTCSETS) {
  4326.                 tcs_save = tcharset;
  4327.                 tcharset = afcset[fcharset];
  4328.                 debug(F101,"sfile scanfile 7 tcharset","",
  4329.                       tcharset);
  4330.                 }
  4331.                 setxlatype(tcharset,fcharset);
  4332.             }
  4333.             break;
  4334.  
  4335.               case FT_8BIT:    /* 8-bit text */
  4336.             binary = XYFT_T; /* SET FILE TYPE TEXT */
  4337.             /* If SEND CHARSET-SELEC AUTO  */
  4338.             /* and SET TRANSFER TRANSLATION is ON */
  4339.             debug(F100,"sfile scanfile text8","",0);
  4340.             if (s_cset == XMODE_A && xfrxla) {
  4341.                 if (fcsinfo[fcharset].size != 256) {
  4342.                 fcs_save = fcharset; /* Current FCS not 8bit */
  4343.                 fcharset = dcset8; /* Use default 8bit set */
  4344.                 debug(F101,"sfile scanfile 8 fcharset",
  4345.                       "",fcharset);
  4346.                 }
  4347.                 /* Switch to corresponding transfer charset */
  4348.                 if (afcset[fcharset] > -1 &&
  4349.                 afcset[fcharset] <= MAXTCSETS) {
  4350.                 tcs_save = tcharset;
  4351.                 tcharset = afcset[fcharset];
  4352.                 debug(F101,"sfile scanfile 8 tcharset","",
  4353.                       tcharset);
  4354.                 }
  4355.                 setxlatype(tcharset,fcharset);
  4356.             }
  4357.             break;
  4358. #ifdef UNICODE
  4359.               case FT_UTF8:    /* UTF-8 text */
  4360.               case FT_UCS2:    /* UCS-2 text */
  4361.             debug(F101,"sfile scanfile Unicode","",k);
  4362.             binary = XYFT_T;
  4363.             /* If SEND CHARSET-SELEC AUTO  */
  4364.             /* and SET TRANSFER TRANSLATION is ON */
  4365.             if (s_cset == XMODE_A && xfrxla) {
  4366.                 fcs_save = fcharset;
  4367.                 tcs_save = tcharset;
  4368.                 fcharset = (k == FT_UCS2) ? FC_UCS2 : FC_UTF8;
  4369.                 if (k == FT_UCS2 && x > -1)
  4370.                   fileorder = x;
  4371.             }
  4372.             /* Switch to associated transfer charset if any */
  4373.             if (afcset[fcharset] > -1 &&
  4374.                 afcset[fcharset] <= MAXTCSETS)
  4375.               tcharset = afcset[fcharset];
  4376.             if (tcharset == TC_TRANSP) /* If none */
  4377.               tcharset = TC_UTF8;      /* use UTF-8 */
  4378.             setxlatype(tcharset,fcharset);
  4379.             debug(F101,"sfile Unicode tcharset","",tcharset);
  4380.             break;
  4381. #endif /* UNICODE */
  4382. #endif /* NOCSETS */
  4383.               case FT_BIN:
  4384.             debug(F101,"sfile scanfile binary","",k);
  4385.             binary = XYFT_B;
  4386.             break;
  4387.             /* Default: Don't change anything */
  4388.             }
  4389.         }
  4390.         }
  4391.         debug(F101,"sfile binary 2","",binary);
  4392.         debug(F101,"sfile sendmode","",sendmode);
  4393.     }
  4394.         if (*cmarg2) {            /* If we have a send-as name... */
  4395.         int y; char *s;
  4396. #ifndef NOSPL                /* and a script programming language */
  4397.         extern int cmd_quoting;
  4398.         if (cmd_quoting) {        /* and it's not turned off */
  4399.         y = PKTNL;        /* pass as-name thru the evaluator */
  4400.         s = pktnam;
  4401.         zzstring(cmarg2,&s,&y);
  4402. #ifdef COMMENT
  4403. /* This ruins macros like BSEND */
  4404.         if (!pktnam[0])        /* and make sure result is not empty */
  4405.           sprintf(pktnam,"FILE%02ld",filcnt);
  4406. #endif /* COMMENT */
  4407.         } else
  4408. #endif /* NOSPL */
  4409.           ckstrncpy(pktnam,cmarg2,PKTNL); /* copy it literally, */
  4410.  
  4411.         debug(F110,"sfile pktnam",pktnam,0);
  4412. #ifdef COMMENT
  4413. /* We don't do this any more because now we have filename templates */
  4414.         cmarg2 = "";        /* and blank it out for next time. */
  4415. #endif /* COMMENT */
  4416.         }
  4417.     if (!*pktnam) {            /* No as-name... */
  4418. #ifdef NZLTOR
  4419.         int xfncnv, xpath;
  4420.         debug(F101,"sfile fnspath","",fnspath);
  4421.         debug(F101,"sfile fncnv","",fncnv);
  4422.         xfncnv = fncnv;
  4423.         xpath = fnspath;
  4424.         if (notafile) {        /* If not an actual file */
  4425.         xfncnv = 0;        /* Don't convert name */
  4426.         xpath = PATH_OFF;    /* Leave path off */
  4427.         } else if (xfncnv &&
  4428.                (!strcmp(whoareu,"U1") || !strcmp(whoareu,"UN"))
  4429.                ) {
  4430.         /* Less-strict conversion if partner is UNIX or Win32 */
  4431.         xfncnv = -1;
  4432.         }
  4433.         debug(F101,"sfile xpath","",xpath);
  4434.         debug(F101,"sfile xfncnv","",xfncnv);
  4435.         nzltor(filnam,pktnam,xfncnv,xpath,PKTNL);
  4436.  
  4437. #else  /* Not NZLTOR */
  4438.  
  4439.         debug(F101,"sfile fnspath","",fnspath);
  4440.         if (fnspath == PATH_OFF    /* Stripping path names? */
  4441.         && (!notafile)        /* (of actual files) */
  4442.         ) {
  4443.         char *t;        /* Yes. */
  4444.         zstrip(filnam,&t);    /* Strip off the path. */
  4445.         debug(F110,"sfile zstrip",t,0);
  4446.         if (!t) t = "UNKNOWN";    /* Be cautious... */
  4447.         else if (*t == '\0')
  4448.           t = "UNKNOWN";
  4449.         ckstrncpy(pktnam,t,PKTNL); /* Copy stripped name literally. */
  4450.         } else if (fnspath == PATH_ABS && !notafile) {
  4451.         /* Converting to absolute form */
  4452.         zfnqfp(filnam,PKTNL,pktnam);
  4453.         } else
  4454.         ckstrncpy(pktnam,filnam,PKTNL);
  4455.  
  4456.         /* pktnam[] has the packet name, filnam[] has the original name. */
  4457.         /* But we still need to convert pktnam if FILE NAMES CONVERTED.  */
  4458.  
  4459.         debug(F101,"sfile fncnv","",fncnv);
  4460.         if (fncnv && !notafile) {    /* If converting names of files */
  4461.         zltor(pktnam,(char *)srvcmd); /* convert it to common form, */
  4462.         ckstrncpy(pktnam,(char *)srvcmd,PKTNL);
  4463.         *srvcmd = NUL;
  4464.         }
  4465. #endif /* NZLTOR */
  4466.         }
  4467.     if (!*pktnam)            /* Failsafe... */
  4468.       sprintf(pktnam,"FILE%02ld",filcnt);
  4469.     debug(F110,"sfile filnam 1",filnam,0);
  4470.     debug(F110,"sfile pktnam 1",pktnam,0);
  4471. #ifdef PIPESEND
  4472. /* If we have a send filter, substitute the current filename into it */
  4473.  
  4474.     if (sndfilter) {
  4475.         char * p = NULL, * q;
  4476.         int n = CKMAXPATH;
  4477. #ifndef NOSPL
  4478.         if ((p = (char *) malloc(n + 1))) {
  4479.         q = p;
  4480.         debug(F110,"sfile pipesend filter",sndfilter,0);
  4481.         zzstring(sndfilter,&p,&n);
  4482.         debug(F111,"sfile pipename",q,n);
  4483.         if (n <= 0) {
  4484.             printf(
  4485.               "?Sorry, send filter + filename too long, %d max.\n",
  4486.                CKMAXPATH
  4487.                );
  4488.             free(q);
  4489.             return(0);
  4490.         }
  4491.         ckstrncpy(filnam,q,CKMAXPATH+1);
  4492.         free(q);
  4493.         }
  4494. #endif /* NOSPL */
  4495.     }
  4496. #endif /* PIPESEND */
  4497.  
  4498.         debug(F110,"sfile filnam 2",filnam,0); /* Log debugging info */
  4499.         debug(F110,"sfile pktnam 2",pktnam,0);
  4500.         if (openi(filnam) == 0)     /* Try to open the input file */
  4501.       return(0);
  4502.  
  4503. #ifdef CK_RESEND
  4504. /*
  4505.   The following check is done after openi() is called, since openi() itself
  4506.   can change the transfer mode (as in VMS).
  4507. */
  4508.         if ((binary == XYFT_T
  4509. #ifdef VMS
  4510.          || binary == XYFT_L
  4511. #endif /* VMS */
  4512.          ) && sendmode == SM_RESEND) {
  4513.             /* Trying to RESEND/REGET a file first sent in TEXT mode. */
  4514.         debug(F111,"sfile error - Recover vs Text",filnam,binary);
  4515.             /* Set appropriate error messages and make log entries here */
  4516. #ifdef VMS
  4517.         if (binary == XYFT_L)
  4518.           ckmakmsg((char *)epktmsg,
  4519.                PKTMSGLEN,
  4520.                "Recovery attempted in LABELED mode: ",
  4521.                filnam,
  4522.                NULL,
  4523.                NULL
  4524.                );
  4525.         else
  4526. #endif /* VMS */
  4527.           ckmakmsg((char *)epktmsg,
  4528.                PKTMSGLEN,
  4529.                "Recovery attempted in TEXT mode: ",
  4530.                filnam,
  4531.                NULL,
  4532.                NULL
  4533.                );
  4534.             return(0);
  4535.         }
  4536.     if (sendmode == SM_PSEND)    /* PSENDing? */
  4537.       if (sendstart > (CK_OFF_T)0)    /* Starting position */
  4538.         if (zfseek(sendstart) < 0)    /* seek to it... */
  4539.           return(0);
  4540. #endif /* CK_RESEND */
  4541.         s = pktnam;            /* Name for packet data field */
  4542. #ifdef OS2
  4543.     /* Never send a disk letter. */
  4544.     if (isalpha(*s) && (*(s+1) == ':'))
  4545.       s += 2;
  4546. #endif /* OS2 */
  4547.  
  4548.     } else {                /* X-packet setup, not F-packet. */
  4549.     binary = XYFT_T;        /* Text always */
  4550.         debug(F110,"sfile X packet",cmdstr,0); /* Log debugging info */
  4551.         s = cmdstr;            /* Name for data field */
  4552.     }
  4553.  
  4554.     /* Now s points to the string that goes in the packet data field. */
  4555.  
  4556.     debug(F101,"sfile binary","",binary); /* Log debugging info */
  4557.     encstr((CHAR *)s);            /* Encode the name. */
  4558.                     /* Send the F or X packet */
  4559.     /* If the encoded string did not fit into the packet, it was truncated. */
  4560.  
  4561.     if (nxtpkt() < 0) return(0);    /* Bump packet number, get buffer */
  4562.  
  4563.     rc = spack((char) (x ? 'X' : 'F'), pktnum, size, data);
  4564.     if (rc < 0)
  4565.       return(rc);
  4566.  
  4567. #ifndef NOCSETS
  4568.     setxlatype(tcharset,fcharset);    /* Set up charset translations */
  4569. #endif /* NOCSETS */
  4570.  
  4571.     if (x == 0) {            /* Display for F packet */
  4572.         if (displa) {            /* Screen */
  4573.         xxscreen(SCR_FN,'F',(long)pktnum,filnam);
  4574.         xxscreen(SCR_AN,0,0L,pktnam);
  4575.         xxscreen(SCR_FS,0,calibrate ? calibrate : fsize,"");
  4576.         }
  4577. #ifdef pdp11
  4578.         tlog(F110,"Sending",filnam,0L); /* Transaction log entry */
  4579.     makestr(&psfspec,filnam);    /* New filename */
  4580. #else
  4581. #ifndef ZFNQFP
  4582.         tlog(F110,"Sending",filnam,0L);
  4583.     makestr(&psfspec,filnam);    /* New filename */
  4584. #else
  4585.     if (notafile) {            /* If not a file log simple name */
  4586.         tlog(F110,"Sending", filnam, 0L);
  4587.     } else {            /* Log fully qualified filename */
  4588. #ifdef COMMENT
  4589.         /* This section generates bad code in SCO 3.2v5.0.5's cc */
  4590.         char *p = NULL, *q = filnam;
  4591.         debug(F101,"sfile CKMAXPATH","",CKMAXPATH);
  4592.         if ((p = malloc(CKMAXPATH+1))) {
  4593.         debug(F111,"sfile calling zfnqfp",filnam,strlen(filnam));
  4594.         if (zfnqfp(filnam, CKMAXPATH, p)) {
  4595.             debug(F111,"sfile zfnqfp ok",p,strlen(p));
  4596.             q = p;
  4597.         }
  4598.         }
  4599. #else
  4600.         char tmpbuf[CKMAXPATH+1];
  4601.         char *p = tmpbuf, *q = filnam;
  4602.         if (zfnqfp(filnam, CKMAXPATH, p))
  4603.           q = p;
  4604. #endif /* COMMENT */
  4605.         debug(F111,"sfile q",q,strlen(q));
  4606.         tlog(F110,"Sending",q,0L);
  4607.         makestr(&psfspec,q);    /* New preliminary filename */
  4608. #ifdef COMMENT
  4609.         if (p) free(p);
  4610. #endif /* COMMENT */
  4611.     }
  4612. #endif /* ZFNQFP */
  4613. #endif /* pdp11 */
  4614.         tlog(F110," as",pktnam,0L);
  4615.     if (binary) {            /* Log file mode in transaction log */
  4616.         tlog(F101," mode: binary","",(long) binary);
  4617.     } else {            /* If text mode, check character set */
  4618.         tlog(F100," mode: text","",0L);
  4619. #ifndef NOCSETS
  4620.         if (tcharset == TC_TRANSP || xfrxla == 0) {
  4621.         tlog(F110," character set","transparent",0L);
  4622.         } else {
  4623.         tlog(F110," xfer character set",tcsinfo[tcharset].name,0L);
  4624.         tlog(F110," file character set",fcsinfo[fcharset].name,0L);
  4625.         }
  4626. #endif /* NOCSETS */
  4627.     }
  4628.     } else {                /* Display for X-packet */
  4629.  
  4630.         xxscreen(SCR_XD,'X',(long)pktnum,cmdstr); /* Screen */
  4631.         tlog(F110,"Sending from:",cmdstr,0L);    /* Transaction log */
  4632.     }
  4633.     intmsg(++filcnt);            /* Count file, give interrupt msg */
  4634.     first = 1;                /* Init file character lookahead. */
  4635.     ffc = (CK_OFF_T)0;            /* Init file character counter. */
  4636.     cps = oldcps = 0L;            /* Init cps statistics */
  4637.     rejection = -1;
  4638.     fsecs = gtimer();            /* Time this file started */
  4639. #ifdef GFTIMER
  4640.     fpfsecs = gftimer();
  4641.     debug(F101,"SFILE fpfsecs","",fpfsecs);
  4642. #endif /* GFTIMER */
  4643.     debug(F101,"SFILE fsecs","",fsecs);
  4644.     return(1);
  4645. }
  4646.  
  4647. /*  S D A T A -- Send a data packet */
  4648.  
  4649. /*
  4650.   Returns -1 if no data to send (end of file), -2 if connection is broken.
  4651.   If there is data, a data packet is sent, and sdata() returns 1.
  4652.  
  4653.   In the streaming case, the window is regarded as infinite and we keep
  4654.   sending data packets until EOF or there appears to be a Kermit packet on the
  4655.   reverse channel.  When not streaming and the window size is greater than 1,
  4656.   we keep sending data packets until window is full or characters start to
  4657.   appear from the other Kermit.
  4658.  
  4659.   In the windowing or streaming case, when there is no more data left to send
  4660.   (or when sending has been interrupted), sdata() does nothing and returns 0
  4661.   each time it is called until the acknowledgement sequence number catches up
  4662.   to the last data packet that was sent.
  4663. */
  4664. int
  4665. sdata() {
  4666.     int i, x, len;
  4667.     char * s;
  4668.  
  4669.     debug(F101,"sdata entry, first","",first);
  4670.     debug(F101,"sdata drain","",drain);
  4671. /*
  4672.   The "drain" flag is used with window size > 1.  It means we have sent
  4673.   our last data packet.  If called and drain is not zero, then we return
  4674.   0 as if we had sent an empty data packet, until all data packets have
  4675.   been ACK'd, then then we can finally return -1 indicating EOF, so that
  4676.   the protocol can switch to seof state.  This is a kludge, but at least
  4677.   it's localized...
  4678. */
  4679.     if (first == 1) drain = 0;        /* Start of file, init drain flag. */
  4680.  
  4681.     if (drain) {            /* If draining... */
  4682.     debug(F101,"sdata draining, winlo","",winlo);
  4683.     if (winlo == pktnum)        /* If all data packets are ACK'd */
  4684.       return(-1);            /* return EOF indication */
  4685.     else                /* otherwise */
  4686.       return(0);            /* pretend we sent a data packet. */
  4687.     }
  4688.     debug(F101,"sdata sbufnum","",sbufnum);
  4689.     for (i = sbufnum;
  4690.      i > 0
  4691. #ifdef STREAMING
  4692.      || streaming
  4693. #endif /* STREAMING */
  4694.      ;
  4695.      i--) {
  4696.     if (i < 0)
  4697.       break;
  4698.         debug(F101,"sdata countdown","",i);
  4699. #ifdef STREAMING
  4700.     if (streaming) {
  4701.         pktnum = (pktnum + 1) % 64;
  4702.         winlo = pktnum;
  4703.         debug(F101,"sdata streaming pktnum","",pktnum);
  4704.     } else {
  4705. #endif /* STREAMING */
  4706.         x = nxtpkt();        /* Get next pkt number and buffer */
  4707.         debug(F101,"sdata nxtpkt pktnum","",pktnum);
  4708.         if (x < 0) return(0);
  4709. #ifdef STREAMING
  4710.     }
  4711. #endif /* STREAMING */
  4712.     debug(F101,"sdata packet","",pktnum);
  4713.     if (chkint() < 0)        /* Especially important if streaming */
  4714.       return(-9);
  4715.     if (cxseen || czseen) {        /* If interrupted, done. */
  4716.         if (wslots > 1) {
  4717.         drain = 1;
  4718.         debug(F100,"sdata cx/zseen windowing","",0);
  4719.         return(0);
  4720.         } else {
  4721.         debug(F100,"sdata cx/zseen nonwindowing","",0);
  4722.         return(-1);
  4723.         }
  4724.     }
  4725. #ifdef DEBUG
  4726.     if (deblog) {
  4727.         debug(F101,"sdata spsiz","",spsiz);
  4728.         debug(F101,"sdata binary","",binary);
  4729.         debug(F101,"sdata parity","",parity);
  4730.     }
  4731. #endif /* DEBUG */
  4732. #ifdef CKTUNING
  4733.     if (binary && !parity && !memstr && !funcstr)
  4734.       len = bgetpkt(spsiz);
  4735.     else
  4736.       len = getpkt(spsiz,1);
  4737. #else
  4738.     len = getpkt(spsiz,1);
  4739. #endif /* CKTUNING */
  4740.     s = (char *)data;
  4741.     if (len == -3) {        /* Timed out (e.g.reading from pipe) */
  4742.         s = "";            /* Send an empty data packet. */
  4743.         len = 0;
  4744.     } else if (len == 0) {        /* Done if no data. */
  4745.         if (pktnum == winlo)
  4746.           return(-1);
  4747.         drain = 1;            /* But can't return -1 until all */
  4748.         debug(F101,"sdata eof, drain","",drain);
  4749.         return(0);            /* ACKs are drained. */
  4750.     }
  4751.     debug(F101,"sdata pktnum","",pktnum);
  4752.     debug(F101,"sdata len","",len);
  4753.     debug(F011,"sdata data",data,52);
  4754.  
  4755.     x = spack('D',pktnum,len,(CHAR *)s); /* Send the data packet. */
  4756.     debug(F101,"sdata spack","",x);
  4757.     if (x < 0) {            /* Error */
  4758.         ttchk();            /* See if connection is still there */
  4759.         return(-2);
  4760.     }
  4761. #ifdef STREAMING
  4762.     if (streaming)            /* What an ACK would do. */
  4763.       winlo = pktnum;
  4764. #endif /* STREAMING */
  4765.     x = ttchk();            /* Peek at input buffer. */
  4766.     debug(F101,"sdata ttchk","",x);    /* ACKs waiting, maybe?  */
  4767.     if (x < 0)            /* Or connection broken? */
  4768.       return(-2);
  4769. /*
  4770.   Here we check to see if any ACKs or NAKs have arrived, in which case we
  4771.   break out of the D-packet-sending loop and return to the state switcher
  4772.   to process them.  This is what makes our windows slide instead of lurch.
  4773. */
  4774.     if (
  4775. #ifdef GEMDOS
  4776. /*
  4777.   In the Atari ST version, ttchk() can only return 0 or 1.  But note: x will
  4778.   probably always be > 0, since the as-yet-unread packet terminator from the
  4779.   last packet is probably still in the buffer, so sliding windows will
  4780.   probably never happen when the Atari ST is the file sender.  The alternative
  4781.   is to say "if (0)", in which case the ST will always send a window full of
  4782.   packets before reading any ACKs or NAKs.
  4783. */
  4784.         x > 0
  4785.  
  4786. #else /* !GEMDOS */
  4787. /*
  4788.   In most other versions, ttchk() returns the actual count.
  4789.   It can't be a Kermit packet if it's less than five bytes long.
  4790. */
  4791.         x > 4 + bctu
  4792.  
  4793. #endif /* GEMDOS */
  4794.         )
  4795.       return(1);            /* Yes, stop sending data packets */
  4796.     }                    /* and go try to read the ACKs. */
  4797.     return(1);
  4798. }
  4799.  
  4800.  
  4801. /*  S E O F -- Send an End-Of-File packet */
  4802.  
  4803. /*  Call with a string pointer to character to put in the data field, */
  4804. /*  or else a null pointer or "" for no data.  */
  4805.  
  4806. /*
  4807.   There are two "send-eof" functions.  seof() is used to send the normal eof
  4808.   packet at the end of a file's data (even if the file has no data), or when
  4809.   a file transfer is interrupted.  sxeof() is used to send an EOF packet that
  4810.   occurs because of attribute refusal or interruption prior to entering data
  4811.   state.  The difference is purely a matter of buffer allocation and packet
  4812.   sequence number management.  Both functions act as "front ends" to the
  4813.   common send-eof function, szeof().
  4814. */
  4815.  
  4816. /* Code common to both seof() and sxeof() */
  4817.  
  4818. int
  4819. szeof(s) CHAR *s; {
  4820.     int x;
  4821.     lsstate = 0;            /* Cancel locking-shift state */
  4822.     if (!s) s = (CHAR *)"";
  4823.     debug(F111,"szeof",s,pktnum);
  4824.     if (*s) {
  4825.     x = spack('Z',pktnum,1,s);
  4826.     xitsta |= W_SEND;
  4827. #ifdef COMMENT
  4828.     tlog(F100," *** interrupted, sending discard request","",0L);
  4829. #endif /* COMMENT */
  4830.     filrej++;
  4831.     } else {
  4832.     x = spack('Z',pktnum,0,(CHAR *)"");
  4833.     }
  4834.     if (x < 0)
  4835.       return(x);
  4836.  
  4837. #ifdef COMMENT
  4838.     /* No, too soon */
  4839.     discard = 0;            /* Turn off per-file discard flag */
  4840. #endif /* COMMENT */
  4841.  
  4842. /* If we were sending from a pipe, we're not any more... */
  4843.     pipesend = 0;
  4844.     return(0);
  4845. }
  4846.  
  4847. int
  4848. seof(x) int x; {
  4849.     char * s;
  4850. /*
  4851.   ckcpro.w, before calling seof(), sets window size back to 1 and then calls
  4852.   window(), which clears out the old buffers.  This is OK because the final
  4853.   data packet for the file has been ACK'd.  However, sdata() has already
  4854.   called nxtpkt(), which set the new value of pktnum which seof() will use.
  4855.   So all we need to do here is is allocate a new send-buffer.
  4856. */
  4857.     s = x ? "D" : "";
  4858.     debug(F111,"seof",s,pktnum);
  4859.     if (getsbuf(pktnum) < 0) {    /* Get a buffer for packet n */
  4860.     debug(F101,"seof can't get s-buffer","",pktnum);
  4861.     return(-1);
  4862.     }
  4863.     return(szeof((CHAR *)s));
  4864. }
  4865.  
  4866. /*
  4867.   Version of seof() to be called when sdata() has not been called before.  The
  4868.   difference is that this version calls nxtpkt() to allocate a send-buffer and
  4869.   get the next packet number.
  4870. */
  4871. int
  4872. sxeof(x) int x; {
  4873.     char * s;
  4874.     s = x ? "D" : "";
  4875.     if (nxtpkt() < 0)            /* Get next pkt number and buffer */
  4876.       debug(F101,"sxeof nxtpkt fails","",pktnum);
  4877.     else
  4878.       debug(F101,"sxeof packet","",pktnum);
  4879.     return(szeof((CHAR *)s));
  4880. }
  4881.  
  4882. /*  S E O T -- Send an End-Of-Transaction packet */
  4883.  
  4884. int
  4885. seot() {
  4886.     int x;
  4887.     x = nxtpkt();
  4888.     debug(F101,"seot nxtpkt","",x);
  4889.     if (x < 0) return(-1);        /* Bump packet number, get buffer */
  4890.     x = spack('B',pktnum,0,(CHAR *)"");    /* Send the EOT packet */
  4891.     if (x < 0)
  4892.       return(x);
  4893.     cxseen = czseen = discard = 0;    /* Reset interruption flags */
  4894.     tstats();                /* Log timing info */
  4895.     return(0);
  4896. }
  4897.  
  4898.  
  4899. /*   R P A R -- Fill the data array with my send-init parameters  */
  4900.  
  4901. int q8flag = 0;
  4902.  
  4903. CHAR dada[32];                /* Use this instead of data[]. */
  4904.                     /* To avoid some kind of wierd */
  4905.                     /* addressing foulup in spack()... */
  4906.                     /* (which might be fixed now...) */
  4907.  
  4908. CHAR *
  4909. rpar() {
  4910.     char *p;
  4911.     int i, x, max;
  4912.     extern int sprmlen;
  4913.  
  4914.     max = maxdata();            /* Biggest data field I can send */
  4915.     debug(F101, "rpar max 1","",max);
  4916.     debug(F101, "rpar sprmlen","",sprmlen);
  4917.     if (sprmlen > 1 && sprmlen < max)    /* User override */
  4918.       max = sprmlen;
  4919.     debug(F101, "rpar max 2","",max);
  4920.  
  4921.     if (rpsiz > MAXPACK)        /* Biggest normal packet I want. */
  4922.       dada[0] = (char) tochar(MAXPACK);    /* If > 94, use 94, but specify */
  4923.     else                /* extended packet length below... */
  4924.       dada[0] = (char) tochar(rpsiz);    /* else use what the user said. */
  4925.     dada[1] = (char) tochar(chktimo(pkttim,0)); /* When to time me out */
  4926.     dada[2] = (char) tochar(mypadn);    /* How much padding I need (none) */
  4927.     dada[3] = (char) ctl(mypadc);    /* Padding character I want */
  4928.     dada[4] = (char) tochar(eol);    /* End-Of-Line character I want */
  4929.     dada[5] = myctlq;            /* Control-Quote character I send */
  4930.  
  4931.     if (max < 6) { dada[6] = NUL; rqf = 0; ebq = sq = NUL; return(dada); }
  4932.  
  4933.     switch (rqf) {            /* 8th-bit prefix (single-shift) */
  4934.       case -1:                /* I'm opening the bids */
  4935.       case  1:                /* Other Kermit already bid 'Y' */
  4936.     if (parity) ebq = sq = MYEBQ;    /* So I reply with '&' if parity */
  4937.     break;                /*  otherwise with 'Y'. */
  4938.       case  2:                /* Other Kermit sent a valid prefix */
  4939.     if (q8flag)
  4940.       sq = ebq;            /* Fall through on purpose */
  4941.       case  0:                /* Other Kermit bid nothing */
  4942.     break;                /* So I reply with 'Y'. */
  4943.     }
  4944.     debug(F000,"rpar 8bq sq","",sq);
  4945.     debug(F000,"rpar 8bq ebq","",ebq);
  4946.     if (lscapu == 2)            /* LOCKING-SHIFT FORCED */
  4947.       dada[6] = 'N';            /* requires no single-shift */
  4948.     else                /* otherwise send prefix or 'Y' */
  4949.       dada[6] = (char) sq;
  4950.     ebqsent = dada[6];            /* And remember what I really sent */
  4951.  
  4952.     if (max < 7) { dada[7] = NUL; bctr = 1; return(dada); }
  4953.  
  4954.     dada[7] = (char) (bctr == 4) ? 'B' : bctr + '0'; /* Block check type */
  4955.  
  4956.     if (max < 8) { dada[8] = NUL; rptflg = 0; return(dada); }
  4957.  
  4958.     if (rptena) {
  4959.     if (rptflg)            /* Run length encoding */
  4960.       dada[8] = (char) rptq;    /* If receiving, agree */
  4961.     else                /* by replying with same character. */
  4962.       dada[8] = (char) (rptq = myrptq); /* When sending use this. */
  4963.     } else dada[8] = SP;        /* Not enabled, put a space here. */
  4964.  
  4965.     /* CAPAS mask */
  4966.  
  4967.     if (max < 9) {
  4968.     dada[9] = NUL;
  4969.     atcapr = 0;
  4970.     lpcapr = 0;
  4971.     swcapr = 0;
  4972.     rscapr = 0;
  4973.     return(dada);
  4974.     }
  4975.     dada[9] = (char) tochar((lscapr ? lscapb : 0) | /* Locking shifts */
  4976.              (atcapr ? atcapb : 0) | /* Attribute packets */
  4977.              (lpcapr ? lpcapb : 0) | /* Long packets */
  4978.              (swcapr ? swcapb : 0) | /* Sliding windows */
  4979.              (rscapr ? rscapb : 0)); /* RESEND */
  4980.     if (max < 10) { wslotr = 1; return(dada); }
  4981.     dada[10] = (char) tochar(swcapr ? wslotr : 1); /* CAPAS+1 = Window size */
  4982.  
  4983.     if (max < 12) { rpsiz = 80; return(dada); }
  4984.     if (urpsiz > 94)
  4985.       rpsiz = urpsiz - 1;        /* Long packets ... */
  4986.     dada[11] = (char) tochar(rpsiz / 95); /* Long packet size, big part */
  4987.     dada[12] = (char) tochar(rpsiz % 95); /* Long packet size, little part */
  4988.  
  4989.     if (max < 16) return(dada);
  4990.     dada[13] = '0';            /* CAPAS+4 = WONT CHKPNT */
  4991.     dada[14] = '_';            /* CAPAS+5 = CHKINT (reserved) */
  4992.     dada[15] = '_';            /* CAPAS+6 = CHKINT (reserved) */
  4993.     dada[16] = '_';            /* CAPAS+7 = CHKINT (reserved) */
  4994.     if (max < 17) return(dada);
  4995. #ifndef WHATAMI
  4996.     dada[17] = ' ';
  4997. #else
  4998.     x = 0;
  4999.     if (server) x |= WMI_SERVE;        /* Whether I am a server */
  5000.     if (binary) x |= WMI_FMODE;        /* My file transfer mode is ... */
  5001.     if (fncnv)  x |= WMI_FNAME;        /* My filename conversion is ... */
  5002. #ifdef STREAMING
  5003.     if (streamrq == SET_ON)
  5004.       x |= WMI_STREAM;
  5005.     else if (streamrq == SET_AUTO && reliable == SET_ON)
  5006.       x |= WMI_STREAM;
  5007.     /*
  5008.       Always offer to stream when in remote mode and STREAMING is AUTO
  5009.       and RELIABLE is not OFF (i.e. is ON or AUTO).
  5010.     */
  5011.     else if (!local && streamrq == SET_AUTO && reliable != SET_OFF)
  5012.       x |= WMI_STREAM;
  5013. #endif /* STREAMING */
  5014. #ifdef TCPSOCKET
  5015.     if (clearrq == SET_ON)
  5016.       x |= WMI_CLEAR;
  5017.     else if (clearrq == SET_AUTO &&    /* SET CLEAR-CHANNEL AUTO */
  5018.          ((network && nettype == NET_TCPB /* TCP/IP */
  5019. #ifdef RLOGCODE
  5020.                 && ttnproto != NP_RLOGIN/* Rlogin is not clear */
  5021.                 && !(ttnproto >= NP_K4LOGIN && ttnproto <= NP_EK5LOGIN)
  5022. #endif /* RLOGCODE */
  5023.            )
  5024. #ifdef SSHBUILTIN
  5025.               || (network && nettype == NET_SSH)
  5026. #endif /* SSHBUILTIN */
  5027. #ifdef IKSD
  5028.           || inserver        /* We are IKSD */
  5029. #endif /* IKSD */
  5030.           ))
  5031.       x |= WMI_CLEAR;
  5032. #endif /* TCPSOCKET */
  5033.     x |= WMI_FLAG;
  5034.     dada[17] = (char) tochar(x);
  5035. #endif /* WHATAMI */
  5036.     i = 18;                /* Position of next field */
  5037.     p = cksysid;            /* WHOAMI (my system ID) */
  5038.     x = strlen(p);
  5039.     if (max - i < x + 1) return(dada);
  5040.     if (x > 0) {
  5041.     dada[i++] = (char) tochar(x);
  5042.     while (*p)
  5043.       dada[i++] = *p++;
  5044.     }
  5045.  
  5046.     if (max < i+1) return(dada);
  5047. #ifndef WHATAMI                /* WHATAMI2 */
  5048.     dada[i++] = ' ';
  5049. #else
  5050.     debug(F101,"rpar xfermode","",xfermode);
  5051.     x = WMI2_FLAG;            /* Is-Valid flag */
  5052.     if (xfermode != XMODE_A)        /* If TRANSFER MODE is MANUAL */
  5053.       x |= WMI2_XMODE;            /* set the XFERMODE bit */
  5054.     if (recursive > 0)            /* If this is a recursive transfer */
  5055.       x |= WMI2_RECU;            /* set the RECURSIVE bit */
  5056.     dada[i++] = tochar(x);
  5057.     debug(F101,"rpar whatami2","",x);
  5058. #endif /* WHATAMI */
  5059.  
  5060.     dada[i] = '\0';            /* Terminate the init string */
  5061.  
  5062. #ifdef DEBUG
  5063.     if (deblog) {
  5064.     debug(F110,"rpar",dada,0);
  5065.     rdebu(dada,(int)strlen((char *)dada));
  5066.     }
  5067. #endif /* DEBUG */
  5068.     ckstrncpy((char *)myinit,(char *)dada,MYINITLEN);
  5069.     return(dada);            /* Return pointer to string. */
  5070. }
  5071.  
  5072. int
  5073. spar(s) CHAR *s; {            /* Set parameters */
  5074.     int x, y, lpsiz, biggest;
  5075.     extern int rprmlen, lastspmax;
  5076.     extern struct sysdata sysidlist[];
  5077.  
  5078.     whatru = 0;
  5079.     whoareu[0] = NUL;
  5080. #ifdef STREAMING
  5081.     streamok = 0;
  5082.     streaming = 0;
  5083. #endif /* STREAMING */
  5084.     biggest = rln;
  5085.  
  5086.     debug(F101, "spar biggest 1","",biggest);
  5087.     debug(F101, "spar rprmlen","",rprmlen);
  5088.     if (rprmlen > 1 && rprmlen < biggest)
  5089.       biggest = rprmlen;
  5090.     debug(F101, "rpar biggest 2","",biggest);
  5091.     debug(F110,"spar packet",s,0);
  5092.  
  5093.     s--;                /* Line up with field numbers. */
  5094.  
  5095. /* Limit on size of outbound packets */
  5096.     x = (biggest >= 1) ? xunchar(s[1]) : 80;
  5097.     lpsiz = spsizr;            /* Remember what they SET. */
  5098.     if (spsizf) {            /* SET-command override? */
  5099.     if (x < spsizr) spsiz = x;    /* Ignore LEN unless smaller */
  5100.     } else {                /* otherwise */
  5101.     spsiz = (x < 10) ? 80 : x;    /* believe them if reasonable */
  5102.     }
  5103.     spmax = spsiz;            /* Remember maximum size */
  5104.  
  5105. /* Timeout on inbound packets */
  5106.     if (timef) {
  5107.     timint = rtimo;            /* SET SEND TIMEOUT value overrides */
  5108.     } else {                /* Otherwise use requested value, */
  5109.     x = (biggest >= 2) ? xunchar(s[2]) : rtimo; /* if it is legal. */
  5110.     timint = (x < 0) ? rtimo : x;
  5111.     }
  5112.     timint = chktimo(timint,timef);    /* Adjust if necessary */
  5113.  
  5114. /* Outbound Padding */
  5115.     npad = 0; padch = '\0';
  5116.     if (biggest >= 3) {
  5117.     npad = xunchar(s[3]);
  5118.     if (biggest >= 4) padch = (CHAR) ctl(s[4]); else padch = 0;
  5119.     }
  5120.     if (npad) {
  5121.     int i;
  5122.     for (i = 0; i < npad; i++) padbuf[i] = dopar(padch);
  5123.     }
  5124.  
  5125. /* Outbound Packet Terminator */
  5126.     seol = (CHAR) (biggest >= 5) ? xunchar(s[5]) : CR;
  5127.     if ((seol < 1) || (seol > 31)) seol = CR;
  5128.  
  5129. /* Control prefix that the other Kermit is sending */
  5130.     x = (biggest >= 6) ? s[6] : '#';
  5131.     ctlq = (CHAR) (((x > 32 && x < 63) || (x > 95 && x < 127)) ? x : '#');
  5132.  
  5133. /* 8th-bit prefix */
  5134. /*
  5135.   NOTE: Maybe this could be simplified using rcvtyp.
  5136.   If rcvtyp == 'Y' then we're reading the ACK,
  5137.   otherwise we're reading the other Kermit's initial bid.
  5138.   But his horrendous code has been working OK for years, so...
  5139. */
  5140.     rq = (biggest >= 7) ? s[7] : 0;
  5141.     if (rq == 'Y') rqf = 1;
  5142.       else if ((rq > 32 && rq < 63) || (rq > 95 && rq < 127)) rqf = 2;
  5143.         else rqf = 0;
  5144.     debug(F000,"spar 8bq rq","",rq);
  5145.     debug(F000,"spar 8bq sq","",sq);
  5146.     debug(F000,"spar 8bq ebq","",ebq);
  5147.     debug(F101,"spar 8bq rqf","",rqf);
  5148.     switch (rqf) {
  5149.       case 0:                /* Field is missing from packet. */
  5150.     ebqflg = 0;            /* So no 8th-bit prefixing. */
  5151.     break;
  5152.       case 1:                /* Other Kermit sent 'Y' = Will Do. */
  5153.     /*
  5154.           When I am the file receiver, ebqsent is 0 because I didn't send a
  5155.           negotiation yet.  If my parity is set to anything other than NONE,
  5156.           either because my user SET PARITY or because I detected parity bits
  5157.           on this packet, I reply with '&', otherwise 'Y'.
  5158.  
  5159.       When I am the file sender, ebqsent is what I just sent in rpar(),
  5160.           which can be 'Y', 'N', or '&'.  If I sent '&', then this 'Y' means
  5161.           the other Kermit agrees to do 8th-bit prefixing.
  5162.  
  5163.           If I sent 'Y' or 'N', but then detected parity on the ACK packet
  5164.           that came back, then it's too late: there is no longer any way for
  5165.           me to tell the other Kermit that I want to do 8th-bit prefixing, so
  5166.           I must not do it, and in that case, if there is any 8-bit data in
  5167.           the file to be transferred, the transfer will fail because of block
  5168.           check errors.
  5169.  
  5170.           The following clause covers all of these situations:
  5171.     */
  5172.     if (parity && (ebqsent == 0 || ebqsent == '&')) {
  5173.         ebqflg = 1;
  5174.         ebq = MYEBQ;
  5175.     }
  5176.     break;
  5177.       case 2:                /* Other Kermit sent a valid prefix */
  5178.     ebqflg = (ebq == sq || sq == 'Y');
  5179.     if (ebqflg) {
  5180.         ebq = rq;
  5181.         debug(F101,"spar setting parity to space","",ebq);
  5182.         if (!parity) parity = ttprty = 's';
  5183.     }
  5184.     }
  5185.     if (lscapu == 2) {     /* But no single-shifts if LOCKING-SHIFT FORCED */
  5186.     ebqflg = 0;
  5187.     ebq = 'N';
  5188.     }
  5189.  
  5190. /* Block check */
  5191.     x = 1;
  5192.     if (biggest >= 8) {
  5193.     if (s[8] == 'B') x = 4;
  5194.     else x = s[8] - '0';
  5195.     if ((x < 1) || (x > 5)) x = 1;    /* "5" 20110605 */
  5196.     }
  5197.     bctr = x;
  5198.  
  5199. /* Repeat prefix */
  5200.  
  5201.     rptflg = 0;                /* Assume no repeat-counts */
  5202.     if (biggest >= 9) {            /* Is there a repeat-count field? */
  5203.     char t;                /* Yes. */
  5204.     t = s[9];            /* Get its contents. */
  5205. /*
  5206.   If I'm sending files, then I'm reading these parameters from an ACK, and so
  5207.   this character must agree with what I sent.
  5208. */
  5209.     if (rptena) {            /* If enabled ... */
  5210.         if ((char) rcvtyp == 'Y') {    /* Sending files, reading ACK. */
  5211.         if (t == myrptq) rptflg = 1;
  5212.         } else {            /* I'm receiving files */
  5213.         if ((t > 32 && t < 63) || (t > 95 && t < 127)) {
  5214.             rptflg = 1;
  5215.             rptq = t;
  5216.         }
  5217.         }
  5218.     } else rptflg = 0;
  5219.     }
  5220.  
  5221. /* Capabilities */
  5222.  
  5223.     atcapu = lpcapu = swcapu = rscapu = 0; /* Assume none of these. */
  5224.     if (lscapu != 2) lscapu = 0;    /* Assume no LS unless forced. */
  5225.     y = 11;                /* Position of next field, if any */
  5226.     if (biggest >= 10) {
  5227.         x = xunchar(s[10]);
  5228.     debug(F101,"spar capas","",x);
  5229.         atcapu = (x & atcapb) && atcapr; /* Attributes */
  5230.     lpcapu = (x & lpcapb) && lpcapr; /* Long packets */
  5231.     swcapu = (x & swcapb) && swcapr; /* Sliding windows */
  5232.     rscapu = (x & rscapb) && rscapr; /* RESEND */
  5233.     debug(F101,"spar lscapu","",lscapu);
  5234.     debug(F101,"spar lscapr","",lscapr);
  5235.     debug(F101,"spar ebqflg","",ebqflg);
  5236.     if (lscapu != 2) lscapu = ((x & lscapb) && lscapr && ebqflg) ? 1 : 0;
  5237.     debug(F101,"spar swcapr","",swcapr);
  5238.     debug(F101,"spar swcapu","",swcapu);
  5239.     debug(F101,"spar lscapu","",lscapu);
  5240.     for (y = 10; (xunchar(s[y]) & 1) && (biggest >= y); y++);
  5241.     debug(F101,"spar y","",y);
  5242.     }
  5243.  
  5244. /* Long Packets */
  5245.     debug(F101,"spar lpcapu","",lpcapu);
  5246.     if (lpcapu) {
  5247.         if (biggest > y+1) {
  5248.         x = xunchar(s[y+2]) * 95 + xunchar(s[y+3]);
  5249.         debug(F101,"spar lp len","",x);
  5250.         if (spsizf) {        /* If overriding negotiations */
  5251.         spsiz = (x < lpsiz) ? x : lpsiz; /* do this, */
  5252.         } else {                     /* otherwise */
  5253.         spsiz = (x > MAXSP) ? MAXSP : x; /* do this. */
  5254.         }
  5255.         if (spsiz < 10) spsiz = 80;    /* Be defensive... */
  5256.     }
  5257.     }
  5258.     /* (PWP) save current send packet size for optimal packet size calcs */
  5259.     spmax = spsiz;            /* Maximum negotiated length */
  5260.     lastspmax = spsiz;            /* For stats */
  5261.     if (slostart && spsiz > 499)    /* Slow start length */
  5262.       spsiz = 244;
  5263.     debug(F101,"spar slow-start spsiz","",spsiz);
  5264.     debug(F101,"spar lp spmax","",spmax);
  5265.     timint = chktimo(timint,timef);    /* Recalculate the packet timeout */
  5266.  
  5267. /* Sliding Windows... */
  5268.  
  5269.     if (swcapr) {            /* Only if requested... */
  5270.         if (biggest > y) {        /* See what other Kermit says */
  5271.         x = xunchar(s[y+1]);
  5272.         debug(F101,"spar window","",x);
  5273.         wslotn = (x > MAXWS) ? MAXWS : x;
  5274. /*
  5275.   wslotn = negotiated size (from other Kermit's S or I packet).
  5276.   wslotr = requested window size (from this Kermit's SET WINDOW command).
  5277. */
  5278.         if (wslotn > wslotr)    /* Use the smaller of the two */
  5279.           wslotn = wslotr;
  5280.         if (wslotn < 1)        /* Watch out for bad negotiation */
  5281.           wslotn = 1;
  5282.         if (wslotn > 1) {
  5283.         swcapu = 1;        /* We do windows... */
  5284.         if (wslotn > maxtry)    /* Retry limit must be greater */
  5285.           maxtry = wslotn + 1;    /* than window size. */
  5286.         }
  5287.         debug(F101,"spar window after adjustment","",x);
  5288.     } else {            /* No window size specified. */
  5289.         wslotn = 1;            /* We don't do windows... */
  5290.         debug(F101,"spar window","",x);
  5291.         swcapu = 0;
  5292.         debug(F101,"spar no windows","",wslotn);
  5293.     }
  5294.     }
  5295.  
  5296. /* Now recalculate packet length based on number of windows.   */
  5297. /* The nogotiated number of window slots will be allocated,    */
  5298. /* and the maximum packet length will be reduced if necessary, */
  5299. /* so that a windowful of packets can fit in the big buffer.   */
  5300.  
  5301.     if (wslotn > 1) {            /* Shrink to fit... */
  5302.     x = adjpkl(spmax,wslotn,bigsbsiz);
  5303.     if (x < spmax) {
  5304.         spmax = x;
  5305.         lastspmax = spsiz;
  5306.         if (slostart && spsiz > 499) spsiz = 244; /* Slow start again */
  5307.         debug(F101,"spar sending, redefine spmax","",spmax);
  5308.     }
  5309.     }
  5310. #ifdef WHATAMI
  5311.     debug(F101,"spar biggest","",biggest);
  5312.     if (biggest > y+7) {        /* Get WHATAMI info if any */
  5313.     whatru = xunchar(s[y+8]);
  5314.     debug(F101,"spar whatru","",whatru);
  5315.     }
  5316.     if (whatru & WMI_FLAG) {        /* Only valid if this bit is set */
  5317. #ifdef STREAMING
  5318.     if (whatru & WMI_STREAM) {
  5319.         if (streamrq == SET_ON ||
  5320.         (streamrq == SET_AUTO &&
  5321.          (reliable == SET_ON || (reliable == SET_AUTO && !local)
  5322. #ifdef TN_COMPORT
  5323.                   && !istncomport()
  5324. #endif /* TN_COMPORT */
  5325. #ifdef IKSD
  5326.                    || inserver
  5327. #endif /* IKSD */
  5328.                    ))) {
  5329.         streamok = 1;        /* Streaming negotiated */
  5330.         slostart = 0;        /* Undo slow-start machinations */
  5331.         spsiz = lastspmax;
  5332.         }
  5333.     }
  5334.     streamed = streamok;
  5335.     debug(F101,"spar streamok","",streamok);
  5336.     debug(F101,"spar clearrq","",clearrq);
  5337.     if (clearrq == SET_ON ||
  5338.              (clearrq == SET_AUTO &&
  5339.                ((network && nettype == NET_TCPB
  5340. #ifdef RLOGCODE
  5341.                 && ttnproto != NP_RLOGIN/* Rlogin is not clear */
  5342.                 && !(ttnproto >= NP_K4LOGIN && ttnproto <= NP_EK5LOGIN)
  5343. #endif /* RLOGCODE */
  5344. #ifdef TN_COMPORT
  5345.                 && !istncomport()
  5346. #endif /* TN_COMPORT */
  5347.                   )
  5348. #ifdef SSHBUILTIN
  5349.                  || (network && nettype == NET_SSH)
  5350. #endif /* SSHBUILTIN */
  5351. #ifdef IKSD
  5352.                  || inserver
  5353. #endif /* IKSD */
  5354.                  )))
  5355.           urclear = (whatru & WMI_CLEAR);
  5356.     debug(F101,"spar urclear","",urclear);
  5357. #ifdef CK_SPEED
  5358.     if (urclear)
  5359.       setprefix(PX_NON);
  5360. #endif /* CK_SPEED */
  5361.     cleared = urclear;
  5362. #endif /* STREAMING */
  5363.     }
  5364. #endif /* WHATAMI */
  5365.  
  5366.     if (biggest > y+8) {        /* Get WHOAREYOU info if any */
  5367.     int x, z;
  5368.     x = xunchar(s[y+9]);        /* Length of it */
  5369.     z = y;
  5370.     y += (9 + x);
  5371.     debug(F101,"spar sysindex x","",x);
  5372.     debug(F101,"spar sysindex y","",y);
  5373.     debug(F101,"spar sysindex biggest","",biggest);
  5374.  
  5375.     if (x > 0 && x < 16 && biggest >= y) {
  5376.         strncpy(whoareu,(char *)s+z+10,x); /* Other Kermit's system ID */
  5377.         debug(F111,"spar whoareyou",whoareu,whoareu[0]);
  5378.         if (whoareu[0]) {        /* Got one? */
  5379.         sysindex = getsysix((char *)whoareu);
  5380.         debug(F101,"spar sysindex",whoareu,sysindex);
  5381.         }
  5382.     }
  5383.     } else
  5384.       goto xspar;
  5385.  
  5386. #ifdef WHATAMI
  5387.     y++;                /* Advance pointer */
  5388.     if (biggest >= y) {
  5389.     whatru2 = xunchar(s[y]);    /* Next field is WHATAMI2 */
  5390.     debug(F101,"spar whatru2","",whatru2);
  5391.     if (whatru2 & WMI2_FLAG) {    /* Valid only if this bit is set */
  5392.         if (server) {        /* Server obeys client's xfer mode */
  5393.         xfermode = (whatru2 & WMI2_XMODE) ? XMODE_M : XMODE_A;
  5394.         debug(F101,"spar whatru2 xfermode","",xfermode);
  5395.         }
  5396.         if (whatru2 & WMI2_RECU) {    /* RECURSIVE transfer */
  5397.         if (fnrpath == PATH_AUTO) { /* If REC PATH AUTO */
  5398.             fnrpath = PATH_REL;    /* Set it to RELATIVE */
  5399.             autopath = 1;    /* and remember we did this */
  5400.         }
  5401.         }
  5402.     }
  5403.     }
  5404. #endif /* WHATAMI */
  5405.  
  5406.   xspar:
  5407.     if (sysindex > -1) {
  5408.     char * p;
  5409.     p = sysidlist[sysindex].sid_name;
  5410.     tlog(F110,"Remote system type: ",p,0L);
  5411.     if (sysindex > 0) {        /* If partnet's system type known */
  5412.         whoarewe();            /* see if we are a match. */
  5413. #ifdef CK_SPEED
  5414. /* Never unprefix XON and XOFF when sending to VMS */
  5415.         debug(F111,"proto whoareu",whoareu,sysindex);
  5416.         if (!strcmp((char *)whoareu,"D7")) {
  5417.         debug(F111,"proto special VMS prefixing","",0);
  5418.         ctlp[XON] = ctlp[XOFF] = 1;
  5419.         ctlp[XON+128] = ctlp[XOFF+128] = 1;
  5420.         ctlp[3] = 1;        /* Ctrl-C might be dangerous too */
  5421.         ctlp[14] = ctlp[15] = 1; /* And SO/SI */
  5422.         ctlp[24] = ctlp[25] = 1; /* And ^X/^Y */
  5423.         ctlp[141] = 1;        /* And CR+128 */
  5424.         }
  5425. #endif /* CK_SPEED */
  5426.     }
  5427.     }
  5428.  
  5429. /* Record parameters in debug log */
  5430. #ifdef DEBUG
  5431.     if (deblog) sdebu(biggest);
  5432. #endif /* DEBUG */
  5433.     numerrs = 0;            /* Start counting errors here. */
  5434.     return(0);
  5435. }
  5436.  
  5437. /*  G N F I L E  --  Get name of next file to send  */
  5438. /*
  5439.   Expects global sndsrc to be:
  5440.    -9: if we are generating a file internally for calibration.
  5441.    -1: next filename to be obtained by calling znext().
  5442.     0: no next file name
  5443.     1: (or greater) next filename to be obtained from **cmlist,
  5444.        or if addlist != 0, from the "filehead" linked list,
  5445.        or if filefile pointer not null from that file (which is already open).
  5446.   Returns:
  5447.     1, with name of next file in filnam.
  5448.     0, no more files, with filnam set to empty string.
  5449.    -1, file not found
  5450.    -2, file is not readable (but then we just skip to the next one if any)
  5451.    -3, read access denied
  5452.    -4, cancelled
  5453.    -5, too many files match wildcard
  5454.    -6, no files selected
  5455.   NOTE:
  5456.     If gnfile() returns 0, then the global variable gnferror should be checked
  5457.     to find out the most recent gnfile() error, and use that instead of the
  5458.     return code (for reasons to hard to explain).
  5459. */
  5460. int
  5461. gnfile() {
  5462.     int i = 0, x = 0;
  5463.     CK_OFF_T filesize = 0;
  5464.     int dodirstoo = 0;
  5465.     int retcode = 0;
  5466.  
  5467.     char fullname[CKMAXPATH+1];
  5468.  
  5469.     dodirstoo = ((what & (W_FTP|W_SEND)) == (W_FTP|W_SEND)) && recursive;
  5470.  
  5471.     debug(F101,"gnfile sndsrc","",sndsrc);
  5472.     debug(F101,"gnfile filcnt","",filcnt);
  5473.     debug(F101,"gnfile what","",what);
  5474.     debug(F101,"gnfile recursive","",recursive);
  5475.     debug(F101,"gnfile dodirstoo","",dodirstoo);
  5476.     gnferror = 0;
  5477.     fsize = (CK_OFF_T)-1;        /* Initialize file size */
  5478.     fullname[0] = NUL;
  5479.  
  5480. #ifdef VMS
  5481.     /* 
  5482.       In VMS, zopeni() sets binary 0/1 automatically from the file
  5483.       attributes.  Don't undo it here.
  5484.     */
  5485.     debug(F101,"gnfile VMS binary","",binary);
  5486. #else  /* VMS */
  5487.     if (!(what & W_REMO) && (xfermode == XMODE_A)
  5488. #ifndef NOMSEND
  5489.     && !addlist
  5490. #endif /* NOMSEND */
  5491.     ) {
  5492.     extern int stdinf;
  5493.     if (!stdinf)            /* Not if sending from stdin */
  5494. #ifdef WHATAMI
  5495.       /* We don't do this in server mode because it undoes WHATAMI */
  5496.       if (!server || (server && ((whatru & WMI_FLAG) == 0)))
  5497. #endif /* WHATAMI */
  5498.         binary = gnf_binary;    /* Restore prevailing transfer mode */
  5499.     debug(F101,"gnfile binary = gnf_binary","",gnf_binary);
  5500.     }
  5501. #endif    /* VMS */
  5502.  
  5503. #ifdef PIPESEND
  5504.     debug(F101,"gnfile pipesend","",pipesend);
  5505.     if (pipesend) {            /* First one */
  5506.     if (filcnt == 0) {
  5507.         ckstrncpy(filnam,cmarg,CKMAXPATH+1);
  5508.         return(1);
  5509.     } else {            /* There's only one... */
  5510.         *filnam = NUL;
  5511.         pipesend = 0;
  5512.         return(0);
  5513.     }
  5514.     }
  5515. #endif /* PIPESEND */
  5516.  
  5517. #ifdef CALIBRATE
  5518.     if (sndsrc == -9) {
  5519.     debug(F100,"gnfile calibrate","",0);
  5520.     ckstrncpy(filnam,"CALIBRATION",CKMAXPATH);
  5521.     nfils = 0;
  5522.     cal_j = 0;
  5523.     fsize = calibrate;
  5524.     sndsrc = 0;            /* For next time */
  5525.     nfils = 0;
  5526.     return(1);
  5527.     }
  5528. #endif /* CALIBRATE */
  5529.  
  5530. #ifndef NOSPL
  5531.     if (sndarray) {            /* Sending from an array */
  5532.     extern char sndxnam[];        /* Pseudo filename */
  5533.     debug(F100,"gnfile array","",0);
  5534.     nfils = 0;
  5535.     fsize = (CK_OFF_T)-1;        /* Size unknown */
  5536.     sndsrc = 0;
  5537.     ckstrncpy(filnam,sndxnam,CKMAXPATH);
  5538.     return(1);
  5539.     }
  5540. #endif /* NOSPL */
  5541.  
  5542.     if (sndsrc == 0) {            /* It's not really a file */
  5543.     if (nfils > 0) {        /* It's a pipe, or stdin */
  5544.         ckstrncpy(filnam,*cmlist,CKMAXPATH+1); /* Copy its "name" */
  5545.         nfils = 0;            /* There is no next file */
  5546.         return(1);            /* OK this time */
  5547.     } else return(0);        /* but not next time */
  5548.     }
  5549.  
  5550. /* If file group interruption (C-Z) occurred, fail.  */
  5551.  
  5552.     if (czseen) {
  5553.     tlog(F100,"Transaction cancelled","",0L);
  5554.         debug(F100,"gnfile czseen","",0);
  5555.     return(-4);
  5556.     }
  5557.  
  5558. /* Loop through file list till we find a readable, sendable file */
  5559.  
  5560.     filesize = (CK_OFF_T)-1;        /* Loop exit (file size) variable */
  5561.     while (filesize < 0) {        /* Keep trying till we get one... */
  5562.     retcode = 0;
  5563.     if (sndsrc > 0) {        /* File list in cmlist or file */
  5564.         if (filefile) {        /* Reading list from file... */
  5565.         if (zsinl(ZMFILE,filnam,CKMAXPATH) < 0) { /* Read a line */
  5566.             zclose(ZMFILE);                      /* Failed */
  5567.             debug(F110,"gnfile filefile EOF",filefile,0);
  5568.             makestr(&filefile,NULL);
  5569.             return(0);
  5570.         }
  5571.         debug(F110,"gnfile filefile filnam",filnam,0);
  5572.         }
  5573.         debug(F101,"gnfile nfils","",nfils);
  5574.         if (nfils-- > 0 || filefile) { /* Still some left? */
  5575. #ifndef NOMSEND
  5576.         if (addlist) {
  5577.             if (filenext && filenext->fl_name) {
  5578.             ckstrncpy(filnam,filenext->fl_name,CKMAXPATH+1);
  5579.             cmarg2 =
  5580.               filenext->fl_alias ?
  5581.                 filenext->fl_alias :
  5582.                   "";
  5583.             binary = filenext->fl_mode;
  5584.             } else {
  5585.             printf("?Internal error expanding ADD list\n");
  5586.             return(-5);
  5587.             }
  5588.             filenext = filenext->fl_next;
  5589.             debug(F111,"gnfile addlist filnam",filnam,nfils);
  5590.         } else if (sndsrc > 0 && !filefile) {
  5591. #endif /* NOMSEND */
  5592.             ckstrncpy(filnam,*cmlist++,CKMAXPATH+1);
  5593.             debug(F111,"gnfile cmlist filnam",filnam,nfils);
  5594. #ifndef NOMSEND
  5595.         }
  5596. #endif /* NOMSEND */
  5597.         i = 0;
  5598. #ifndef NOSERVER
  5599.         debug(F101,"gnfile ngetpath","",ngetpath);
  5600. #endif /* NOSERVER */
  5601. nextinpath:
  5602. #ifndef NOSERVER
  5603.         fromgetpath = 0;
  5604.         if (server && !isabsolute(filnam) && (ngetpath > i)) {
  5605.             ckstrncpy(fullname,getpath[i],CKMAXPATH+1);
  5606.             ckstrncat(fullname,filnam,CKMAXPATH);
  5607.             debug(F111,"gnfile getpath",fullname,i);
  5608.             fromgetpath = 1;
  5609.             i++;
  5610.         } else {
  5611.             i = ngetpath + 1;
  5612. #else
  5613.             i = 1;        /* ? */
  5614. #endif /* NOSERVER */
  5615.             ckstrncpy(fullname,filnam,CKMAXPATH+1);
  5616.             debug(F110,"gnfile absolute",fullname,0);
  5617. #ifndef NOSERVER
  5618.         }
  5619. #endif /* NOSERVER */
  5620.         if (iswild(fullname)
  5621. #ifdef RECURSIVE
  5622.             || recursive > 0 || !strcmp(fullname,".")
  5623. #endif /* RECURSIVE */
  5624.             ) {    /* It looks wild... */
  5625.             /* First check if a file with this name exists */
  5626.             debug(F110,"gnfile wild",fullname,0);
  5627.             if (zchki(fullname) >= 0) {
  5628.             /*
  5629.                Here we have a file whose name actually
  5630.                contains wildcard characters.
  5631.             */
  5632.             goto gotnam;
  5633.             }
  5634. #ifdef COMMENT
  5635.             nzxopts = ZX_FILONLY; /* (was 0: 25 Jul 2001 fdc) */
  5636. #else
  5637.             nzxopts = recursive ? 0 : ZX_FILONLY; /* 30 Jul 2001 */
  5638. #endif /* COMMENT */
  5639.             if (nolinks) nzxopts |= ZX_NOLINKS;    /* (26 Jul 2001 fdc) */
  5640. #ifdef UNIXOROSK
  5641.             if (matchdot) nzxopts |= ZX_MATCHDOT;
  5642. #endif /* UNIXOROSK */
  5643.             if (recursive) nzxopts |= ZX_RECURSE;
  5644.             x = nzxpand(fullname,nzxopts); /* Expand wildcards */
  5645.             debug(F101,"gnfile nzxpand","",x);
  5646.             if (x == 1) {
  5647.             int xx;
  5648.             xx = znext(fullname);
  5649.             debug(F111,"gnfile znext A",fullname,xx);
  5650.             goto gotnam;
  5651.             }
  5652.             if (x == 0) {    /* None match */
  5653. #ifndef NOSERVER
  5654.             if (server && ngetpath > i)
  5655.               goto nextinpath;
  5656. #endif /* NOSERVER */
  5657.             retcode = -1;
  5658.             debug(F101,"gnfile gnferror A","",gnferror);
  5659.             gnferror = -1;
  5660.             continue;
  5661.             }
  5662.             if (x < 0) {    /* Too many to expand */
  5663.             debug(F101,"gnfile gnferror B","",gnferror);
  5664.             gnferror = -5;
  5665.             return(-5);
  5666.             }
  5667.             sndsrc = -1;    /* Change send-source to znext() */
  5668.         }
  5669.         } else {            /* We're out of files. */
  5670.         debug(F111,"gnfile done",ckitoa(gnferror),nfils);
  5671.         *filnam = '\0';
  5672.         return(0);
  5673.         }
  5674.     }
  5675.  
  5676. /* Otherwise, step to next element of internal wildcard expansion list. */
  5677.  
  5678.     if (sndsrc == -1) {
  5679.         int xx = 0;
  5680.         while (1) {
  5681.         debug(F111,"gnfile znext X",filnam,xx);
  5682.         xx = znext(filnam);
  5683.         debug(F111,"gnfile znext B",filnam,xx);
  5684.         if (!filnam[0])
  5685.           break;
  5686.         if (dodirstoo) {
  5687.             debug(F111,"gnfile FTP MPUT /RECURSIVE",filnam,xx);
  5688.             break;
  5689.         }
  5690.         if (!isdir(filnam))
  5691.           break;
  5692.         }
  5693.         debug(F111,"gnfile znext C",filnam,x);
  5694.         if (!filnam[0]) {        /* If no more, */
  5695.         sndsrc = 1;        /* go back to previous list */
  5696.         debug(F101,"gnfile setting sndsrc back","",sndsrc);
  5697.         continue;
  5698.         } else
  5699.           ckstrncpy(fullname,filnam,CKMAXPATH+1);
  5700.     }
  5701.  
  5702. /* Get here with a filename. */
  5703.  
  5704. gotnam:
  5705.     debug(F110,"gnfile fullname",fullname,0);
  5706.     if (fullname[0]) {
  5707. #ifdef DTILDE
  5708.         char * dirp = "";
  5709.         if (fullname[0] == '~') {
  5710.         dirp = tilde_expand((char *)fullname);
  5711.         if (*dirp) ckstrncpy(fullname,dirp,CKMAXPATH+1);
  5712.         }
  5713. #endif /* DTILDE */
  5714.         filesize = zchki(fullname);    /* Check if file readable */
  5715.         debug(F111,"gnfile zchki",fullname,filesize);
  5716.         retcode = filesize;        /* Possible return code */
  5717.         if (filesize == (CK_OFF_T)-2 && dodirstoo) {
  5718.         filesize = 0;
  5719.         }
  5720.         if (filesize < 0) {
  5721.         gnferror = (int)filesize;
  5722.         debug(F101,"gnfile gnferror C","",gnferror);
  5723.         }
  5724.         if (filesize == (CK_OFF_T)-1) { /* If not found */
  5725.         debug(F100,"gnfile -1","",0);
  5726. #ifndef NOSERVER
  5727.         if (server && ngetpath > i)
  5728.           goto nextinpath;
  5729. #endif /* NOSERVER */
  5730.         debug(F110,"gnfile skipping:",fullname,0);
  5731.         tlog(F110,fullname,": open failure - skipped",0);
  5732.         xxscreen(SCR_FN,0,0l,fullname);
  5733.         xxscreen(SCR_ST,ST_SKIP,SKP_ACC,fullname);
  5734. #ifdef TLOG
  5735.         if (tralog && !tlogfmt)
  5736.           doxlog(what,fullname,fsize,binary,1,"Skipped");
  5737. #endif /* TLOG */
  5738.         continue;
  5739.         } else if (filesize < 0) {
  5740.         if (filesize == (CK_OFF_T)-3) { /* Exists but not readable */
  5741.             debug(F100,"gnfile -3","",0);
  5742.             filrej++;        /* Count this one as not sent */
  5743.             tlog(F110,"Read access denied",fullname,0); /* Log this */
  5744.             xxscreen(SCR_FN,0,0l,fullname);
  5745.             xxscreen(SCR_ST,ST_SKIP,SKP_ACC,fullname); /* Display it */
  5746. #ifdef TLOG
  5747.             if (tralog && !tlogfmt)
  5748.               doxlog(what,fullname,fsize,binary,1,"Skipped");
  5749. #endif /* TLOG */
  5750.         }
  5751.         continue;
  5752.         } else {
  5753.         int xx;
  5754.         fsize = filesize;
  5755. /* +++ */
  5756.     debug(F111,"gnfile sndsmaller",ckfstoa(sndsmaller),sndsmaller);
  5757.     debug(F111,"gnfile sndlarger",ckfstoa(sndlarger),sndlarger);
  5758.     debug(F111,"gnfile (CK_OFF_T)-1",ckfstoa((CK_OFF_T)-1),(CK_OFF_T)-1);
  5759.  
  5760.         xx = fileselect(fullname,
  5761.                 sndafter, sndbefore,
  5762.                 sndnafter,sndnbefore,
  5763.                 sndsmaller,sndlarger,
  5764.                 skipbup,
  5765.                 NSNDEXCEPT,sndexcept);
  5766.         debug(F111,"gnfile fileselect",fullname,xx);
  5767.         if (!xx) {
  5768.             filesize = (CK_OFF_T)-1;
  5769.             gnferror = -6;
  5770.             debug(F101,"gnfile gnferror D","",gnferror);
  5771.             continue;
  5772.         }
  5773.         ckstrncpy(filnam,fullname,CKMAXPATH+1);
  5774.         return(1);
  5775.         }
  5776. #ifdef COMMENT
  5777.     /* This can't be right! */
  5778.     } else {            /* sndsrc is 0... */
  5779.         if (!fileselect(fullname,
  5780.                 sndafter, sndbefore,
  5781.                 sndnafter,sndnbefore,
  5782.                 sndsmaller,sndlarger,
  5783.                 skipbup,
  5784.                 NSNDEXCEPT,sndexcept)) {
  5785.         gnferror = -6;
  5786.         debug(F111,"gnfile fileselect",fullname,gnferror);
  5787.         filesize = (CK_OFF_T)-1;
  5788.         continue;
  5789.         }
  5790.         ckstrncpy(filnam,fullname,CKMAXPATH+1);
  5791.         return(1);
  5792. #endif /* COMMENT */
  5793.     }
  5794.     }
  5795.     debug(F101,"gnfile result","",retcode);
  5796.     *filnam = '\0';
  5797.     return(0);
  5798. }
  5799.  
  5800. /*
  5801.   The following bunch of routines feed internally generated data to the server
  5802.   to send to the client in response to REMOTE commands like DIRECTORY, DELETE,
  5803.   and so on.  We have to write these lines in the format appropriate to our
  5804.   platform, so they can be converted to generic (CRLF) text format by the
  5805.   packetizer.
  5806. */
  5807. #ifdef UNIX
  5808. char * endline = "\12";
  5809. #else
  5810. #ifdef datageneral
  5811. char * endline = "\12";
  5812. #else
  5813. #ifdef MAC
  5814. char * endline = "\15";
  5815. #else
  5816. #ifdef OSK
  5817. char * endline = "\15";
  5818. #else
  5819. char * endline = "\15\12";
  5820. #endif /* OSK */
  5821. #endif /* MAC */
  5822. #endif /* datageneral */
  5823. #endif /* UNIX */
  5824.  
  5825. #ifdef MAC
  5826. #define FNCBUFL 256
  5827. #else
  5828. #ifdef CKSYMLINK
  5829. #define FNCBUFL (CKMAXPATH + CKMAXPATH + 64)
  5830. #else
  5831. #define FNCBUFL (CKMAXPATH + 64)
  5832. #endif /* CKSYMLINK */
  5833. #endif /* MAC */
  5834.  
  5835. /* NB: The minimum FNCBUFL is 255 */
  5836.  
  5837. static CHAR funcbuf[FNCBUFL];
  5838. static int  funcnxt =  0;
  5839. static int  funclen =  0;
  5840. static int  nxpnd   = -1;
  5841. static long ndirs   =  0;
  5842. static long nfiles  =  0;
  5843. static CK_OFF_T nbytes  =  0;
  5844.  
  5845. int
  5846. sndstring(p) char * p; {
  5847. #ifndef NOSERVER
  5848.     nfils = 0;                /* No files, no lists. */
  5849.     xflg = 1;                /* Flag we must send X packet. */
  5850.     ckstrncpy(cmdstr,versio,CMDSTRL);    /* Data for X packet. */
  5851.     first = 1;                /* Init getchx lookahead */
  5852.     memstr = 1;                /* Just set the flag. */
  5853.     memptr = p;                /* And the pointer. */
  5854.     binary = XYFT_T;            /* Text mode for this. */
  5855.     return(sinit());
  5856. #else
  5857.     return(0);
  5858. #endif /* NOSERVER */
  5859. }
  5860.  
  5861. /*  S N D H L P  --  Routine to send builtin help  */
  5862.  
  5863. static int srvhlpnum = 0;
  5864.  
  5865. #ifdef IKSD
  5866. static char *nmx[] =  { "Disabled", "Disabled", "Enabled", "Enabled" };
  5867. #endif /* IKSD */
  5868.  
  5869. static char *
  5870. xnm(x) int x; {
  5871. #ifdef IKSD
  5872.     if (inserver)
  5873.       return(nmx[x]);
  5874.     else
  5875. #endif /* IKSD */
  5876.       return(nm[x]);
  5877. }
  5878.  
  5879. static int
  5880. nxthlp(
  5881. #ifdef CK_ANSIC
  5882.        void
  5883. #endif /* CK_ANSIC */
  5884.        ) {
  5885.     int x = 0;
  5886.     extern int
  5887.       en_cpy, en_cwd, en_del, en_dir, en_fin, en_get, en_bye, en_mai,
  5888.       en_pri, en_hos, en_ren, en_sen, en_spa, en_set, en_typ, en_who,
  5889.       /* en_ret, */ en_mkd, en_rmd, en_asg, en_que, en_xit, x_login, x_logged,
  5890.       xfinish;
  5891.     extern char * ckxsys;
  5892.  
  5893.     if (funcnxt < funclen)
  5894.       return (funcbuf[funcnxt++]);
  5895.  
  5896.     switch (srvhlpnum++) {
  5897.       case 0:
  5898.     x = ckstrncpy((char *)funcbuf,
  5899.               "Client Command     Status        Description\n",
  5900.               FNCBUFL
  5901.               );
  5902.     if (x_login && !x_logged) {
  5903.         x += ckstrncat((char *)funcbuf,
  5904.                " REMOTE LOGIN       required\n",
  5905.                FNCBUFL
  5906.                );
  5907.     }
  5908.     if (FNCBUFL - x > 74)
  5909.     sprintf((char *)(funcbuf+x)," GET                %-14s%s\n",
  5910.         xnm(en_get),
  5911.         "Transfer file(s) from server to client."
  5912.         );
  5913.     break;
  5914.  
  5915. /* NOTE: The minimum funcbuf[] size is 255; all of the following are safe. */
  5916.  
  5917.       case 1:
  5918.     sprintf((char *)funcbuf," SEND               %-14s%s\n",
  5919.         xnm(en_sen),
  5920.         "Transfer file(s) from client to server."
  5921.         );
  5922.     break;
  5923.  
  5924.       case 2:
  5925.     sprintf((char *)funcbuf," MAIL               %-14s%s\n",
  5926.         xnm(inserver ? 0 : en_mai),
  5927.         "Send file(s) as e-mail."
  5928.         );
  5929.     break;
  5930.  
  5931.       case 3:
  5932. #ifndef NOSPL
  5933.     sprintf((char *)funcbuf," REMOTE ASSIGN      %-14s%s\n",
  5934.         xnm(en_asg),
  5935.         "Assign value to server variable or macro."
  5936.         );
  5937. #else
  5938.     sprintf((char *)funcbuf," REMOTE ASSIGN      not configured\n");
  5939. #endif /* NOSPL */
  5940.  
  5941.     break;
  5942.       case 4:
  5943.     sprintf((char *)funcbuf," REMOTE CD          %-14s%s\n",
  5944.         xnm(en_cwd),
  5945.         "Change server's directory."
  5946.         );
  5947.     break;
  5948.  
  5949.       case 5:
  5950. #ifdef ZCOPY
  5951.     sprintf((char *)funcbuf," REMOTE COPY        %-14s%s\n",
  5952.         xnm(en_cpy),
  5953.         "Copy a file on the server."
  5954.         );
  5955. #else
  5956.     sprintf((char *)funcbuf," REMOTE COPY        not configured\n");
  5957. #endif /* ZCOPY */
  5958.  
  5959.     break;
  5960.       case 6:
  5961.     sprintf((char *)funcbuf," REMOTE DELETE      %-14s%s\n",
  5962.         xnm(en_del),
  5963.         "Delete a file on the server."
  5964.         );
  5965.     break;
  5966.  
  5967.       case 7:
  5968.     sprintf((char *)funcbuf," REMOTE DIRECTORY   %-14s%s\n",
  5969.         xnm(en_dir),
  5970.         "List files on the server."
  5971.         );
  5972.     break;
  5973.  
  5974.       case 8:
  5975.     sprintf((char *)funcbuf," REMOTE EXIT        %-14s%s\n",
  5976.         xnm(en_xit),
  5977.         "Exit from Kermit server program."
  5978.         );
  5979.     break;
  5980.  
  5981.       case 9:
  5982.     sprintf((char *)funcbuf," REMOTE HOST        %-14s%s\n",
  5983.         xnm(inserver ? 0 : en_hos),
  5984. #ifdef datageneral
  5985.         "Execute a CLI command on the server."
  5986. #else
  5987. #ifdef VMS
  5988.         "Execute a DCL command on the server."
  5989. #else
  5990.         "Execute a shell command on the server."
  5991. #endif /* VMS */
  5992. #endif /* datageneral */
  5993.         );
  5994.     break;
  5995.  
  5996.       case 10:
  5997.     sprintf((char *)funcbuf," REMOTE PRINT       %-14s%s\n",
  5998.         xnm(inserver ? 0 : en_pri),
  5999.         "Send a file to the server for printing."
  6000.         );
  6001.     break;
  6002.  
  6003.       case 11:
  6004. #ifndef NOSPL
  6005.     sprintf((char *)funcbuf," REMOTE QUERY       %-14s%s\n",
  6006.         xnm(en_que),
  6007.         "Get value of server variable or macro."
  6008.         );
  6009.  
  6010. #else
  6011.     sprintf((char *)funcbuf," REMOTE QUERY       not configured\n");
  6012. #endif /* NOSPL */
  6013.  
  6014.     break;
  6015.       case 12:
  6016.     sprintf((char *)funcbuf," REMOTE MKDIR       %-14s%s\n",
  6017.         xnm(en_mkd),
  6018.         "Create a directory on the server."
  6019.         );
  6020.     break;
  6021.  
  6022.       case 13:
  6023.     sprintf((char *)funcbuf," REMOTE RMDIR       %-14s%s\n",
  6024.         xnm(en_rmd),
  6025.         "Remove a directory on the server."
  6026.         );
  6027.     break;
  6028.  
  6029.       case 14:
  6030.     sprintf((char *)funcbuf," REMOTE RENAME      %-14s%s\n",
  6031.         xnm(en_ren),
  6032.         "Rename a file on the server."
  6033.         );
  6034.     break;
  6035.  
  6036.       case 15:
  6037.     sprintf((char *)funcbuf," REMOTE SET         %-14s%s\n",
  6038.         xnm(en_set),
  6039.         "Set a parameter on the server"
  6040.         );
  6041.     break;
  6042.  
  6043.       case 16:
  6044.     sprintf((char *)funcbuf," REMOTE SPACE       %-14s%s\n",
  6045.         xnm(en_spa),
  6046.         "Inquire about disk space on the server."
  6047.         );
  6048.     break;
  6049.  
  6050.       case 17:
  6051.     sprintf((char *)funcbuf," REMOTE TYPE        %-14s%s\n",
  6052.         xnm(en_typ),
  6053.         "Display a server file on your screen."
  6054.         );
  6055.     break;
  6056.  
  6057.       case 18:
  6058.     sprintf((char *)funcbuf," REMOTE WHO         %-14s%s\n",
  6059.         xnm(inserver ? 0 : en_who),
  6060.         "List who is logged in to the server."
  6061.         );
  6062.     break;
  6063.  
  6064.       case 19:
  6065.     sprintf((char *)funcbuf," FINISH             %-14s%s\n",
  6066.         xnm(en_fin),
  6067.         xfinish ?
  6068.         "Exit from Kermit server program." :
  6069.         "Return the server to its command prompt."
  6070.         );
  6071.     break;
  6072.  
  6073.       case 20:
  6074.     sprintf((char *)funcbuf," BYE                %-14s%s\n\n",
  6075.         xnm(en_bye),
  6076.         "Log the server out and disconnect."
  6077.         );
  6078.     break;
  6079.  
  6080.       default:
  6081.     return(-1);
  6082.     }
  6083.     funcnxt = 0;
  6084.     funclen = strlen((char *)funcbuf);
  6085.     return(funcbuf[funcnxt++]);
  6086. }
  6087.  
  6088. int
  6089. sndhlp() {
  6090. #ifndef NOSERVER
  6091.     extern char * ckxsys;
  6092.  
  6093.     first = 1;                /* Init getchx lookahead */
  6094.     nfils = 0;                /* No files, no lists. */
  6095.     xflg = 1;                /* Flag we must send X packet. */
  6096.     ckstrncpy(cmdstr,"REMOTE HELP",CMDSTRL); /* Data for X packet. */
  6097.     sprintf((char *)funcbuf, "C-Kermit %s,%s\n\n", versio, ckxsys);
  6098.     funclen = strlen((char *)funcbuf);
  6099. #ifdef IKSD
  6100.     if (inserver) {
  6101.     sprintf((char *)(funcbuf+funclen),
  6102.         "Internet Kermit Service (EXPERIMENTAL)\n\n");
  6103.     funclen = strlen((char *)funcbuf);
  6104.     }
  6105. #endif /* IKSD */
  6106.     funcnxt = 0;
  6107.     funcptr = nxthlp;
  6108.     funcstr = 1;
  6109.     srvhlpnum = 0;
  6110.     binary = XYFT_T;            /* Text mode for this. */
  6111.     return(sinit());
  6112. #else
  6113.     return(0);
  6114. #endif /* NOSERVER */
  6115. }
  6116.  
  6117. /*
  6118.    Returns the next available character,
  6119.   -1 if no more data.
  6120. */
  6121. static int
  6122. nxttype(
  6123. #ifdef CK_ANSIC
  6124.        void
  6125. #endif /* CK_ANSIC */
  6126.     ) {
  6127.     int c;
  6128.     if (zchin(ZIFILE,&c) < 0) {
  6129.         zclose(ZIFILE);
  6130.         return(-1);
  6131.     } else {
  6132.     return((unsigned)c);
  6133.     }
  6134. }
  6135.  
  6136. /*  S N D T Y P -- TYPE a file to remote client */
  6137.  
  6138. int
  6139. sndtype(file) char * file; {
  6140. #ifndef NOSERVER
  6141.     char name[CKMAXPATH+1];
  6142.  
  6143. #ifdef OS2
  6144.     char * p = NULL;
  6145.  
  6146.     if (*file) {
  6147.         ckstrncpy(name, file, CKMAXPATH+1);
  6148.         /* change / to \. */
  6149.         p = name;
  6150.         while (*p) {            /* Change them back to \ */
  6151.             if (*p == '/') *p = '\\';
  6152.             p++;
  6153.         }
  6154.     } else
  6155.       return(0);
  6156. #else
  6157.     ckstrncpy(name, file, CKMAXPATH+1);
  6158. #endif /* OS2 */
  6159.  
  6160.     funcnxt = 0;
  6161.     funclen = strlen((char *)funcbuf);
  6162.     if (zchki(name) == -2) {
  6163.         /* Found a directory */
  6164.         return(0);
  6165.     }
  6166.     if (!zopeni(ZIFILE,name))
  6167.       return(0);
  6168.  
  6169.     nfils = 0;                /* No files, no lists. */
  6170.     xflg = 1;                /* Flag we must send X packet. */
  6171.     ckstrncpy(cmdstr,"type",CMDSTRL);    /* Data for X packet. */
  6172.     first = 1;                /* Init getchx lookahead */
  6173.     funcstr = 1;            /* Just set the flag. */
  6174.     funcptr = nxttype;            /* And the pointer. */
  6175.     binary = XYFT_T;            /* Text mode for this */
  6176.     return(sinit());
  6177. #else
  6178.     return(0);
  6179. #endif /* NOSERVER */
  6180. }
  6181.  
  6182. /*
  6183.    N X T D I R  --  Provide data for senddir()
  6184.  
  6185.    Returns the next available character or -1 if no more data.
  6186. */
  6187. #ifndef NOICP
  6188. /* Directory listing parameters set by the user interface, if any. */
  6189. extern int dir_head, dir_dots, dir_back;
  6190. #endif /* NOICP */
  6191. static int sd_hdg, sd_bkp, sd_dot;    /* Local listing parameters */
  6192.  
  6193. static int
  6194. nxtdir(
  6195. #ifdef CK_ANSIC
  6196.        void
  6197. #endif /* CK_ANSIC */
  6198.        ) {
  6199.     char name[CKMAXPATH+1], dbuf[24], *p = NULL;
  6200.     char *dstr = NULL, * lnk = "";
  6201.     CHAR c, * linebuf = funcbuf;
  6202. #ifdef OSK
  6203.     /* Work around bugs in OSK compiler */
  6204.     char *dirtag = "directories";
  6205.     char *filetag = "files";
  6206.     char *bytetag = "bytes";
  6207. #endif /* OSK */
  6208.     CK_OFF_T len = 0;
  6209.     int x, itsadir = 0, gotone = 0;
  6210.  
  6211. #ifdef DEBUG
  6212.     if (deblog) {
  6213.     debug(F101,"nxtdir funcnxt","",funcnxt);
  6214.     debug(F101,"nxtdir funclen","",funclen);
  6215.     debug(F110,"nxtdir funcbuf",funcbuf+funcnxt,0);
  6216.     }
  6217. #endif /* DEBUG */
  6218.     if (funcnxt < funclen) {        /* Return next character from buffer */
  6219.     c = funcbuf[funcnxt++];
  6220.     debug(F000,"nxtdir return 1","",(unsigned)(c & 0xff));
  6221.     return((unsigned)(c & 0xff));
  6222.     }
  6223.     while (nxpnd > 0) {            /* Buffer needs refill */
  6224.         nxpnd--;
  6225.     znext(name);            /* Get next filename */
  6226.         if (!name[0]) {            /* None left - done */
  6227.             nxpnd = 0;
  6228.             return(nxtdir());
  6229.         }
  6230.     if (sd_bkp) {            /* Showing backup files? */
  6231.         gotone = 1;            /* Yes, no need to check. */
  6232.         break;
  6233.     }
  6234.     x = ckmatch(            /* No - see if this is one */
  6235. #ifdef CKREGEX
  6236.             "*.~[0-9]*~"    /* Not perfect but close enough. */
  6237. #else
  6238.             "*.~*~"        /* Less close. */
  6239. #endif /* CKREGEX */
  6240.             ,name,filecase,1);
  6241.     debug(F111,"nxtdir ckmatch",name,x);
  6242.     if (x) {
  6243.         continue;            /* It's a backup file - skip it */
  6244.     } else {
  6245.         gotone = 1;            /* It's not, break from loop. */
  6246.         break;
  6247.     }
  6248.     }
  6249.     if (gotone) {
  6250.         len = zgetfs(name);        /* Get file size */
  6251.     debug(F111,"nxtdir zgetfs",name,len);
  6252. #ifdef VMSORUNIX
  6253.     itsadir = zgfs_dir;        /* See if it's a directory */
  6254. #else
  6255.     itsadir = (len == -2 || isdir(name));
  6256. #endif /* VMSORUNIX */
  6257.         dstr = zfcdat(name);
  6258.     debug(F111,"nxtdir zcfdat",dstr,0);
  6259.     if (!dstr)
  6260.       dstr = "0000-00-00 00:00:00";
  6261.     if (!*dstr) {
  6262.       dstr = "0000-00-00 00:00:00";
  6263.     } else {
  6264.         dbuf[0] = dstr[0];
  6265.         dbuf[1] = dstr[1];
  6266.         dbuf[2] = dstr[2];
  6267.         dbuf[3] = dstr[3];
  6268.         dbuf[4] = '-';
  6269.         dbuf[5] = dstr[4];
  6270.         dbuf[6] = dstr[5];
  6271.         dbuf[7] = '-';
  6272.         dbuf[8] = dstr[6];
  6273.         dbuf[9] = dstr[7];
  6274.         strcpy(dbuf+10,dstr+8);
  6275.         dstr = dbuf;
  6276.     }
  6277. #ifdef CK_PERMS
  6278. #ifdef VMSORUNIX
  6279.     p = ziperm(name);        /* Get permissions */
  6280. #else
  6281.     p = zgperm(name);
  6282. #endif /* VMSORUNIX */
  6283. #else
  6284.     p = NULL;
  6285. #endif /* CK_PERMS */
  6286.     debug(F110,"domydir perms",p,0);
  6287.  
  6288. #ifdef VMS
  6289.     /* Make name relative */
  6290.     ckstrncpy(name,zrelname(name,zgtdir()),CKMAXPATH+1);
  6291. #endif /* VMS */
  6292.  
  6293.     if (itsadir) {
  6294.         ndirs++;
  6295.     } else {
  6296.         nfiles++;
  6297.         nbytes += len;
  6298.     }
  6299.     lnk = "";
  6300. #ifdef UNIX
  6301. #ifdef CKSYMLINK
  6302.     if (zgfs_link) {
  6303.         extern char linkname[];
  6304.         lnk = linkname;
  6305.     }
  6306.     debug(F111,"nxtdir linkname",lnk,zgfs_link);
  6307. #endif /* CKSYMLINK */
  6308. #endif /* UNIX */
  6309.  
  6310. /*
  6311.   The following sprintf's are safe; linebuf is a pointer to funcbuf,
  6312.   which is 64 bytes larger than CKMAXPATH (or double CKMAXPATH when
  6313.   symlinks are possible).  64 allows for the fixed-field portions of
  6314.   the file listing line: permissions, size, and date.  CKMAXPATH allows
  6315.   for the longest possible pathname.
  6316. */
  6317.     if (itsadir && len < 0) {    /* Directory */
  6318. #ifdef VMS
  6319.         sprintf((char *)linebuf,
  6320.             "%-22s%-10s  %s  %s\n",p,"<DIR>",dstr,name);
  6321. #else
  6322.         if (p)
  6323.           sprintf((char *)linebuf,
  6324.               "%10s%-10s  %s  %s\n",p,"<DIR>",dstr,name);
  6325.         else
  6326.           sprintf((char *)linebuf,
  6327.               "%-10s  %s  %s\n", "<DIR>", dstr, name);
  6328. #endif /* VMS */
  6329.     } else {            /* Regular file */
  6330. #ifdef VMS
  6331.         sprintf((char *)linebuf,
  6332.             "%-22s%10s  %s  %s\n", p, ckfstoa(len), dstr, name);
  6333. #else
  6334.         if (p)
  6335.           sprintf((char *)linebuf,
  6336.               "%10s%10s  %s  %s%s%s\n",
  6337.               p, ckfstoa(len), dstr, name,
  6338.               *lnk ? " -> " : "",
  6339.               lnk
  6340.               );
  6341.         else
  6342.           sprintf((char *)linebuf,
  6343.               "%10s  %s  %s%s%s\n",
  6344.               ckfstoa(len), dstr, name,
  6345.               *lnk ? " -> " : "",
  6346.               lnk
  6347.               );
  6348. #endif /* VMS */
  6349.     }
  6350.         funcnxt = 0;
  6351.         funclen = strlen((char *)funcbuf);
  6352.     } else if (sd_hdg && nxpnd == 0) {    /* Done, send summary */
  6353.     char *blankline = "";        /* At beginning of summary */
  6354. /*
  6355.   The idea is to prevent (a) unnecessary multiple blanklines, and (b)
  6356.   prompt-stomping.  Preventing (b) is practically impossible, because it
  6357.   depends on the client so for now always include that final CRLF.
  6358. */
  6359.     if (!ndirs || !nbytes || !nfiles)
  6360.       blankline = endline;
  6361. #ifdef OSK
  6362. /* Workaround bugs in OS-9 compiler... */
  6363.         if (ndirs == 1)
  6364.            dirtag = "directory";
  6365.         if (nfiles == 1)
  6366.            filetag = "file";
  6367.         if (nbytes == (CK_OFF_T)1)
  6368.            bytetag = "byte";
  6369.         sprintf((char *)funcbuf,
  6370.         "%sSummary: %ld %s, %ld %s, %s %s%s",
  6371.         blankline,
  6372.         ndirs,
  6373.         dirtag,
  6374.         nfiles,
  6375.         filetag,
  6376.         ckfstoa(nbytes),
  6377.         bytetag,
  6378.         endline);
  6379. #else
  6380.         sprintf((char *)funcbuf,
  6381.         "%sSummary: %ld director%s, %ld file%s, %s byte%s%s",
  6382.         blankline,
  6383.         ndirs,
  6384.         (ndirs == 1) ? "y" : "ies",
  6385.         nfiles,
  6386.         (nfiles == 1) ? "" : "s",
  6387.         ckfstoa(nbytes),
  6388.         (nbytes == (CK_OFF_T)1) ? "" : "s",
  6389.         endline
  6390.         );
  6391. #endif /* OSK */
  6392.         nxpnd--;
  6393.         funcnxt = 0;
  6394.         funclen = strlen((char *)funcbuf);
  6395.     } else {
  6396.         funcbuf[0] = '\0';
  6397.         funcnxt = 0;
  6398.         funclen = 0;
  6399.     }
  6400.     debug(F101,"nxtdir funclen","",funclen);
  6401.  
  6402.     if (funcnxt < funclen) {        /* If we have data to send... */
  6403.     c = funcbuf[funcnxt++];
  6404.     debug(F000,"nxtdir return 2","",(unsigned)(c & 0xff));
  6405.     return((unsigned)(c & 0xff));
  6406.     } else
  6407.       return(-1);            /* Nothing left, done. */
  6408. }
  6409.  
  6410. /*  S N D D I R -- send directory listing  */
  6411.  
  6412. int
  6413. snddir(spec) char * spec; {
  6414. #ifndef NOSERVER
  6415.     char * p = NULL, name[CKMAXPATH+1];
  6416.     int t = 0, rc = 0;
  6417.     char fnbuf[CKMAXPATH+1];
  6418.  
  6419.     debug(F111,"snddir matchdot",spec,matchdot);
  6420.  
  6421. #ifndef NOICP
  6422.     debug(F111,"snddir dir_dots",spec,dir_dots);
  6423.     sd_hdg = dir_head > 0;        /* Import listing parameters if any */
  6424.     sd_bkp = dir_back > 0;
  6425.     if (dir_dots > -1)
  6426.       sd_dot = dir_dots;
  6427.     else
  6428.       sd_dot = matchdot;
  6429. #else
  6430.     sd_hdg = 1;                /* Or use hardwired defaults */
  6431.     sd_bkp = 1;
  6432.     sd_dot = matchdot;
  6433. #endif /* NOICP */
  6434.  
  6435.     if (!spec) spec = "";
  6436.     debug(F111,"snddir sd_dot",spec,sd_dot);
  6437.     if (*spec) {
  6438. #ifdef COMMENT
  6439.     zfnqfp(spec,CKMAXPATH,name);
  6440.     debug(F110,"snddir zfnqfp",name,0);
  6441. #else
  6442.     ckstrncpy(name,spec,CKMAXPATH+1);
  6443.     debug(F110,"snddir name",name,0);
  6444. #endif /* COMMENT */
  6445.     } else {
  6446. #ifdef OS2
  6447.     strcpy(name, "*");
  6448. #else
  6449. #ifdef UNIXOROSK
  6450.     strcpy(name, "./*");
  6451. #else
  6452. #ifdef VMS
  6453.     strcpy(name, "*.*");
  6454. #else
  6455. #ifdef datageneral
  6456.     strcpy(name, "+");
  6457. #else
  6458.     debug(F101,"snddir quit (no filespec)","",0);
  6459.     return(0);
  6460. #endif /* datageneral */
  6461. #endif /* VMS */
  6462. #endif /* UNIX */
  6463. #endif /* OS2 */
  6464.     }
  6465.     debug(F110,"snddir name 1",name,0);
  6466.     ndirs = 0L;
  6467.     nfiles = 0L;
  6468.     nbytes = (CK_OFF_T)0;
  6469.  
  6470.     if (zfnqfp(name,CKMAXPATH,fnbuf))
  6471.  
  6472.     debug(F110,"snddir name 2",name,0);
  6473.     p = name + strlen(name);        /* Move it to end of list */
  6474.  
  6475.     /* sprintf safe because funcbuf size >= max path len + 64 */
  6476.  
  6477.     if (sd_hdg) {
  6478.     sprintf((char *)funcbuf,"Listing files: %s%s%s",fnbuf,endline,endline);
  6479.     funcnxt = 0;
  6480.     funclen = strlen((char *)funcbuf);
  6481.     }
  6482.     diractive = 1;
  6483.  
  6484. #ifdef OS2
  6485.     if (zchki(name) == -2) {        /* Found a directory */
  6486.         p--;
  6487.         if (*p == '\\' || *p == '/')
  6488.           ckstrncat(name, "*", CKMAXPATH);
  6489.         else if (*p == ':')
  6490.           ckstrncat(name, ".", CKMAXPATH);
  6491.         else
  6492.           ckstrncat(name, "\\*", CKMAXPATH);
  6493.     debug(F110,"snddir directory",name,0);
  6494.     }
  6495. #else
  6496.     if (!iswild(name) && isdir(name)) {
  6497.     char * s = name;
  6498.     p--;
  6499. #ifdef UNIXOROSK
  6500.     if (*p == '/')            /* So append wildcard to it */
  6501.       ckstrncat(s, "*", CKMAXPATH);
  6502.     else
  6503.       ckstrncat(s, "/*", CKMAXPATH);
  6504. #else
  6505. #ifdef VMS
  6506.     if (*p == ']' || *p == '>' || *p == ':')
  6507.       ckstrncat(s, "*.*", CKMAXPATH);
  6508. #else
  6509. #ifdef datageneral
  6510.     if (*p == ':')
  6511.       ckstrncat(s, "+", CKMAXPATH);
  6512.     else
  6513.       ckstrncat(s, ":+", CKMAXPATH);
  6514. #else
  6515. #ifdef VOS
  6516.     if (*p == '>')
  6517.       ckstrncat(s, "*", CKMAXPATH);
  6518.     else
  6519.       ckstrncat(s, ">*", CKMAXPATH);
  6520. #endif /* VOS */
  6521. #endif /* datageneral */
  6522. #endif /* VMS */
  6523. #endif /* UNIXOROSK */
  6524.     debug(F110,"snddir directory",name,0);
  6525.     }
  6526. #endif /* OS2 */
  6527.  
  6528.     nzxopts = 0;
  6529. #ifdef UNIX
  6530.     {
  6531.     extern char ** mtchs;
  6532.     debug(F111,"snddir sd_dot",spec,sd_dot);
  6533.     if (sd_dot > 0)
  6534.       nzxopts |= ZX_MATCHDOT;
  6535.     if (recursive)
  6536.       nzxopts |= ZX_RECURSE;
  6537.     debug(F111,"snddir nzxopts",spec,nzxopts);
  6538.     nxpnd = nzxpand(name,nzxopts);    /* Get the array of names */
  6539.     sh_sort(mtchs,NULL,nxpnd,0,0,1); /* Sort the array */
  6540.     }
  6541. #else
  6542.     if (recursive) nzxopts |= ZX_RECURSE;
  6543.     nxpnd = nzxpand(name,nzxopts);
  6544. #endif /* UNIX */
  6545.  
  6546.     debug(F101,"snddir nzxpand nxpnd","",nxpnd);
  6547.     if (nxpnd < 1)
  6548.       return(-1);
  6549.     nfils = 0;                /* No files, no lists. */
  6550.     xflg = 1;                /* Flag we must send X packet. */
  6551.     if ((int)strlen(name) < CMDSTRL - 11) /* Data for X packet. */
  6552.       sprintf(cmdstr,"DIRECTORY %s",name); /* safe */
  6553.     else
  6554.       ckstrncpy(cmdstr,"DIRECTORY",CMDSTRL);
  6555.     first = 1;                /* Init getchx lookahead */
  6556.     funcstr = 1;            /* Just set the flag. */
  6557.     funcptr = nxtdir;            /* And the pointer. */
  6558.     binary = XYFT_T;            /* Text mode for this */
  6559.     rc = sinit();            /* 26 Aug 2005 */
  6560.     debug(F111,"snddir","sinit()",rc);
  6561.     return(rc);
  6562. #else
  6563.     return(0);
  6564. #endif /* NOSERVER */
  6565. }
  6566.  
  6567. /*  N X T D E L -- provide data for delete   */
  6568.  
  6569. /*  Returns the next available character or -1 if no more data  */
  6570.  
  6571. static int
  6572. nxtdel(
  6573. #ifdef CK_ANSIC
  6574.        void
  6575. #endif /* CK_ANSIC */
  6576.        ) {
  6577.     char name[257], *p = NULL;
  6578.     int len = 0;
  6579.  
  6580.     if (funcnxt < funclen)
  6581.       return ((unsigned)funcbuf[funcnxt++]);
  6582.  
  6583.     if (nxpnd > 0) {
  6584.         nxpnd--;
  6585.     znext(name);
  6586.         if (!name[0]) {
  6587.             nxpnd = 0;
  6588.             return(nxtdel());
  6589.         }
  6590.         len = zchki(name);
  6591.  
  6592.         /* Find just the name of the file */
  6593.  
  6594.         for (p = name + strlen(name); p != name && *p != '/' ; p--) ;
  6595.         if (*p == '/') p++;
  6596.  
  6597.     /* sprintf's safe because size of funcbuf >= 64 + maxpathlen */
  6598.  
  6599.         if (len > -1L) {
  6600.         if (zdelet(name)) {
  6601.         sprintf((char *)funcbuf," %10s: %s%s","skipping",p,endline);
  6602.         } else {
  6603.         nfiles++;
  6604.         nbytes += len;
  6605.         sprintf((char *)funcbuf," %10s: %s%s","deleted",p,endline);
  6606.         }
  6607.         } else
  6608.       sprintf((char *)funcbuf," directory: %s%s", p, endline);
  6609.         funcnxt = 0;
  6610.         funclen = strlen((char *)funcbuf);
  6611.     } else
  6612.  
  6613.     /* If done processing the expanded entries send a summary statement */
  6614.  
  6615.       if (nxpnd == 0) {
  6616.       sprintf((char *)funcbuf,
  6617.           "%s%ld file%s deleted, %s byte%s freed%s",
  6618.           endline,
  6619.           nfiles,
  6620.           (nfiles == 1) ? "" : "s",
  6621.           ckfstoa(nbytes),
  6622.           (nbytes == (CK_OFF_T)1) ? "" : "s",
  6623.           endline
  6624.           );
  6625.       nxpnd--;
  6626.       funcnxt = 0;
  6627.       funclen = strlen((char *)funcbuf);
  6628.       } else {
  6629.       funcbuf[0] = '\0';
  6630.       funcnxt = 0;
  6631.       funclen = 0;
  6632.       }
  6633.  
  6634.     /* If we have data to send */
  6635.  
  6636.     if (funcnxt < funclen)
  6637.       return ((unsigned)funcbuf[funcnxt++]); /* Return a character */
  6638.     else
  6639.       return(-1);            /* No more input */
  6640. }
  6641.  
  6642. /*  S N D D E L  --  Send delete message  */
  6643.  
  6644. int
  6645. snddel(spec) char * spec; {
  6646. #ifndef NOSERVER
  6647.     char name[CKMAXPATH+1];
  6648. #ifdef OS2
  6649.     char * p = NULL;
  6650. #endif /* #ifdef OS2 */
  6651.  
  6652.     if (!*spec)
  6653.       return(0);
  6654.  
  6655.     ckstrncpy(name, spec, CKMAXPATH+1);
  6656.  
  6657. #ifdef OS2
  6658.     /* change / to \. */
  6659.     p = name;
  6660.     while (*p) {            /* Change them back to \ */
  6661.         if (*p == '/') *p = '\\';
  6662.         p++;
  6663.     }
  6664. #endif /* OS2 */
  6665.  
  6666.     nfiles = 0L;
  6667.     nbytes = (CK_OFF_T)0;
  6668.     sprintf((char *)funcbuf,"Deleting \"%s\"%s",name,endline);
  6669.     funcnxt = 0;
  6670.     funclen = strlen((char *)funcbuf);
  6671.  
  6672.     nzxopts = ZX_FILONLY;        /* Files only */
  6673. #ifdef UNIXOROSK
  6674.     if (matchdot) nzxopts |= ZX_MATCHDOT;
  6675. #endif /* UNIXOROSK */
  6676. #ifdef COMMENT
  6677.     /* Recursive deleting not supported yet */
  6678.     if (recursive) nzxopts |= ZX_RECURSE;
  6679. #endif /* COMMENT */
  6680.     nxpnd = nzxpand(name,nzxopts);
  6681.     if (nxpnd < 1)
  6682.       return(-1);
  6683.     nfils = 0;                /* No files, no lists. */
  6684.     xflg = 1;                /* Flag we must send X packet. */
  6685.     ckstrncpy(cmdstr,"REMOTE DELETE",CMDSTRL); /* Data for X packet. */
  6686.     first = 1;                /* Init getchx lookahead */
  6687.     funcstr = 1;            /* Just set the flag. */
  6688.     funcptr = nxtdel;            /* And the pointer. */
  6689.     binary = XYFT_T;            /* Use text mode for this, */
  6690.     return(sinit());
  6691. #else
  6692.     return(0);
  6693. #endif /* NOSERVER */
  6694. }
  6695.  
  6696. #ifdef OS2
  6697. /*  S N D S P A C E -- send disk space message  */
  6698. int
  6699. sndspace(drive) int drive; {
  6700. #ifndef NOSERVER
  6701.     static char spctext[64];
  6702.     unsigned long space;
  6703.  
  6704.     if (drive) {
  6705.     space = zdskspace(drive - 'A' + 1);
  6706.     if (space > 0 && space < 1024)
  6707.       sprintf(spctext,
  6708.           " Drive %c: unknown%s",
  6709.           drive,
  6710.           endline
  6711.           );
  6712.     else
  6713.       sprintf(spctext,
  6714.           " Drive %c: %ldK free%s",
  6715.           drive,
  6716.           space / 1024L,
  6717.           endline
  6718.           );
  6719.     } else {
  6720.     space = zdskspace(0);
  6721.     if (space > 0 && space < 1024)
  6722.       sprintf(spctext, " Free space: unknown%s", endline);
  6723.     else
  6724.       sprintf(spctext, " Free space: %ldK%s", space / 1024L, endline);
  6725.     }
  6726.     nfils = 0;                /* No files, no lists. */
  6727.     xflg = 1;                /* Flag we must send X packet. */
  6728.     ckstrncpy(cmdstr,"free space",CMDSTRL); /* Data for X packet. */
  6729.     first = 1;                /* Init getchx lookahead */
  6730.     memstr = 1;                /* Just set the flag. */
  6731.     memptr = spctext;            /* And the pointer. */
  6732.     binary = XYFT_T;            /* Text mode for this. */
  6733.     return(sinit());
  6734. #else
  6735.     return(0);
  6736. #endif /* NOSERVER */
  6737. }
  6738.  
  6739. /*  S N D W H O -- send who message  */
  6740. int
  6741. sndwho(who) char * who; {
  6742. #ifndef NOSERVER
  6743.     nfils = 0;                /* No files, no lists. */
  6744.     xflg = 1;                /* Flag we must send X packet. */
  6745.     ckstrncpy(cmdstr,"who",CMDSTRL);    /* Data for X packet. */
  6746.     first = 1;                /* Init getchx lookahead */
  6747.     memstr = 1;                /* Just set the flag. */
  6748. #ifdef NT
  6749.     memptr = "\15\12K95 SERVER\15\12";    /* And the pointer. */
  6750. #else
  6751.     memptr = "\15\12K/2 SERVER\15\12";
  6752. #endif /* NT */
  6753.     binary = XYFT_T;            /* Use text mode */
  6754.     return(sinit());
  6755. #else
  6756.     return(0);
  6757. #endif /* NOSERVER */
  6758. }
  6759. #endif /* OS2 */
  6760.  
  6761. /*  C W D  --  Change server's working directory  */
  6762.  
  6763. /*
  6764.  String passed has first byte as length of directory name, rest of string
  6765.  is name.  Returns:
  6766.   0 on failure.
  6767.   1 on success after sending short-form response (ACK with name).
  6768.   2 on success if a CD Message file is to be sent.
  6769. */
  6770. int
  6771. cwd(vdir) char *vdir; {
  6772.     char *cdd, *dirp;
  6773.  
  6774.     vdir[xunchar(*vdir) + 1] = '\0';    /* Terminate string with a null */
  6775.     dirp = vdir+1;
  6776.     tlog(F110,"Directory requested: ",dirp,0L);
  6777.     if (zchdir(dirp)) {            /* Try to change */
  6778.     cdd = zgtdir();            /* Get new working directory. */
  6779.     debug(F110,"cwd",cdd,0);
  6780.     if (srvcdmsg) {            /* Send orientation file? */
  6781.         int i;
  6782.         for (i = 0; i < 8; i++) {
  6783.         if (zchki(cdmsgfile[i]) > -1) {
  6784.             xxscreen(SCR_CD,0,0l,cdd);
  6785.             tlog(F110,"Changed directory to",cdd,0L);
  6786.             return(2);
  6787.         }
  6788.         }
  6789.     }
  6790.     encstr((CHAR *)cdd);        /* Send short-form reply */
  6791.     ack1(data);            /* containing directory name. */
  6792.     xxscreen(SCR_CD,0,0l,cdd);
  6793.     tlog(F110,"Changed directory to",cdd,0L);
  6794.     return(1);
  6795.     } else {
  6796.     debug(F110,"cwd failed",dirp,0);
  6797.     tlog(F110,"Failed to change directory to",dirp,0L);
  6798.     return(0);
  6799.     }
  6800. }
  6801.  
  6802.  
  6803. /*  S Y S C M D  --  Do a system command  */
  6804.  
  6805. /*  Command string is formed by concatenating the two arguments.  */
  6806.  
  6807. int
  6808. syscmd(prefix,suffix) char *prefix, *suffix; {
  6809.     extern int i_isopen;
  6810. #ifndef NOPUSH
  6811.     char *cp;
  6812.  
  6813.     i_isopen = 0;
  6814.     if (!prefix)
  6815.       return(0);
  6816.     if (!*prefix)
  6817.       return(0);
  6818.     for (cp = cmdstr; *prefix != '\0'; (*cp++ = *prefix++));
  6819.     while ((*cp++ = *suffix++))
  6820. #ifdef OS2
  6821.         /* This takes away more than we gain in convenience
  6822.         if (*(cp-1) == '/') *(cp-1) = '\\' */
  6823. #endif /* OS2 */
  6824.       ;                    /* Copy suffix */
  6825.  
  6826.     debug(F110,"syscmd",cmdstr,0);
  6827.  
  6828.     if (zxcmd(ZIFILE,cmdstr) > 0) {
  6829.         debug(F110,"syscmd zxcmd ok",cmdstr,0);
  6830.     nfils = sndsrc = 0;        /* Flag that input is from stdin */
  6831.         xflg = hcflg = 1;        /* And special flags for pipe */
  6832.     binary = XYFT_T;        /* Go to text mode */
  6833.     i_isopen = 1;
  6834.         return (sinit());        /* Send S packet */
  6835.     } else {
  6836.         debug(F100,"syscmd zxcmd failed",cmdstr,0);
  6837.     i_isopen = 0;
  6838.         return(0);
  6839.     }
  6840. #else
  6841.     debug(F100,"syscmd zxcmd NOPUSH",cmdstr,0);
  6842.     i_isopen = 0;
  6843.     return(0);
  6844. #endif /* NOPUSH */
  6845. }
  6846.  
  6847. /*  R E M S E T  --  Remote Set  */
  6848. /*  Called by server to set variables as commanded in REMOTE SET packets.  */
  6849. /*  Returns 1 on success, 0 on failure.  */
  6850.  
  6851. int
  6852. remset(s) char *s; {
  6853.     extern int c_save, en_del;
  6854.     int len, i, x, y;
  6855.     char *p;
  6856.  
  6857.     len = xunchar(*s++);        /* Length of first field */
  6858.     p = s + len;            /* Pointer to second length field */
  6859.     *p++ = '\0';            /* Zero out second length field */
  6860.     x = atoi(s);            /* Value of first field */
  6861.     debug(F111,"remset",s,x);
  6862.     debug(F110,"remset",p,0);
  6863.     switch (x) {            /* Do the right thing */
  6864.       case 132:                /* Attributes (all, in) */
  6865.     atcapr = atoi(p);
  6866.     return(1);
  6867.       case 133:                /* File length attributes */
  6868.       case 233:                /* IN/OUT combined */
  6869.       case 148:                /* Both kinds of lengths */
  6870.       case 248:
  6871.     atleni = atleno = atoi(p);
  6872.     return(1);
  6873.       case 134:                /* File Type (text/binary) */
  6874.       case 234:
  6875.     attypi = attypo = atoi(p);
  6876.     return(1);
  6877.       case 135:                /* File creation date */
  6878.       case 235:
  6879.     atdati = atdato = atoi(p);
  6880.     return(1);
  6881.       case 139:                /* File Blocksize */
  6882.       case 239:
  6883.     atblki = atblko = atoi(p);
  6884.     return(1);
  6885.       case 141:                /* Encoding / Character Set */
  6886.       case 241:
  6887.     atenci = atenco = atoi(p);
  6888.     return(1);
  6889.       case 142:                /* Disposition */
  6890.       case 242:
  6891.     atdisi = atdiso = atoi(p);
  6892.     return(1);
  6893.       case 145:                /* System ID */
  6894.       case 245:
  6895.     atsidi = atsido = atoi(p);
  6896.     return(1);
  6897.       case 147:                /* System-Dependent Info */
  6898.       case 247:
  6899.     atsysi = atsyso = atoi(p);
  6900.     return(1);
  6901.       case 232:                /* Attributes (all, out) */
  6902.     atcapr = atoi(p);
  6903.     return(1);
  6904.       case 300:                /* File type (text, binary) */
  6905.     binary = atoi(p);
  6906.     b_save = binary;
  6907. #ifndef NOICP
  6908.     g_binary = -1;
  6909. #endif /* NOICP */
  6910.     return(1);
  6911.       case 301:                /* File name conversion */
  6912.     fncnv = 1 - atoi(p);        /* (oops) */
  6913.     f_save = fncnv;
  6914. #ifndef NOICP
  6915.     g_fncnv = -1;
  6916. #endif /* NOICP */
  6917.     return(1);
  6918.       case 302:                /* File name collision */
  6919. #ifdef IKSD
  6920. #ifdef CK_LOGIN
  6921.     if (inserver && isguest)    /* May not be changed by guest */
  6922.       return(0);
  6923. #endif /* CK_LOGIN */
  6924. #endif /* IKSD */
  6925.     x = atoi(p);
  6926.     if (!ENABLED(en_del) && (x == XYFX_X || x == XYFX_U))
  6927.       return(0);
  6928.     if (x == XYFX_R) ckwarn = 1;    /* Rename */
  6929.     if (x == XYFX_X) ckwarn = 0;    /* Replace */
  6930.     fncact = x;
  6931.     return(1);
  6932.       case 310:                /* Incomplete File Disposition */
  6933.     keep = atoi(p);            /* Keep, Discard, Auto */
  6934.     return(1);
  6935.       case 311:                /* Blocksize */
  6936.     fblksiz = atoi(p);
  6937.     return(1);
  6938.       case 312:                /* Record Length */
  6939.     frecl = atoi(p);
  6940.     return(1);
  6941.       case 313:                /* Record format */
  6942.     frecfm = atoi(p);
  6943.     return(1);
  6944.       case 314:                /* File organization */
  6945.     forg = atoi(p);
  6946.     return(1);
  6947.       case 315:                /* File carriage control */
  6948.     fcctrl = atoi(p);
  6949.     return(1);
  6950.       case 330:                /* Match dotfiles */
  6951. #ifndef NOICP
  6952.     dir_dots = -1;            /* This undoes DIR /DOT option */
  6953. #endif /* NOICP */
  6954.     matchdot = atoi(p);
  6955.     return(1);
  6956.       case 331:                /* Match FIFOs */
  6957.     matchfifo = atoi(p);
  6958.     return(1);
  6959.       case 400:                /* Block check */
  6960.     y = atoi(p);
  6961.     if (y < 5 && y > 0) {
  6962.         bctr = y;
  6963.         c_save = -1;
  6964.         return(1);
  6965.     } else if (*p == 'B') {
  6966.         bctr = 4;
  6967.         c_save = -1;
  6968.         return(1);
  6969.     } else if (*p == '5') {
  6970.         bctr = 3;
  6971.         c_save = -1;
  6972.         return(1);
  6973.     }
  6974.     return(0);
  6975.       case 401:                /* Receive packet-length */
  6976.     rpsiz = urpsiz = atoi(p);
  6977.     if (urpsiz > MAXRP) urpsiz = MAXRP; /* Max long-packet length */
  6978.     if (rpsiz > 94) rpsiz = 94;        /* Max short-packet length */
  6979.     urpsiz = adjpkl(urpsiz,wslots,bigrbsiz);
  6980.     return(1);
  6981.       case 402:                /* Receive timeout */
  6982.     y = atoi(p);            /* Client is telling us */
  6983.     if (y > -1 && y < 999) {    /* the timeout that it wants */
  6984.         pkttim = chktimo(y,timef);    /* us to tell it to use. */
  6985.         return(1);
  6986.     } else return(0);
  6987.       case 403:                /* Retry limit */
  6988.     y = atoi(p);
  6989.     if (y > -1 && y < 95) {
  6990.         maxtry = y;
  6991.         return(1);
  6992.     } else return(0);
  6993.       case 404:                /* Server timeout */
  6994.     y = atoi(p);
  6995.     if (y < 0) return(0);
  6996.     srvtim = y;
  6997.     return(1);
  6998.  
  6999. #ifndef NOCSETS
  7000.       case 405: {                /* Transfer character set */
  7001.       extern int s_cset, axcset[];
  7002.       int i;
  7003.       for (i = 0; i < ntcsets; i++) {
  7004.           if (!strcmp(tcsinfo[i].designator,p)) break;
  7005.       }
  7006.       debug(F101,"remset tcharset lookup","",i);
  7007.       if (i == ntcsets) return(0);
  7008.       tcharset = tcsinfo[i].code;    /* If known, use it */
  7009.       debug(F101,"remset tcharset","",tcharset);
  7010.       if (s_cset == XMODE_A)
  7011.         if (axcset[tcharset] > -1 && axcset[tcharset] > MAXFCSETS)
  7012.           fcharset = axcset[tcharset]; /* Auto-pick file charset */
  7013.       debug(F101,"remset tcharset fcharset","",fcharset);
  7014.       setxlatype(tcharset,fcharset); /* Set up charset translations */
  7015.       debug(F101,"remset xlatype","",xlatype);
  7016.       debug(F101,"remset tcharset after setxlatype","",tcharset);
  7017.       tcs_save = -1;
  7018.       return(1);
  7019.       }
  7020.       case 320: {            /* File character set */
  7021.       extern struct keytab fcstab[];
  7022.       extern int nfilc, s_cset, r_cset;
  7023.       x = lookup(fcstab,p,nfilc,&y);
  7024.       debug(F111,"RSET FILE CHAR name",p,x);
  7025.       if (x < 0)
  7026.         return(0);
  7027.       s_cset = XMODE_M;        /* No automatic charset switching */
  7028.       r_cset = XMODE_M;
  7029.       fcharset = x;            /* Set file charset */
  7030.       setxlatype(tcharset,fcharset); /* and translation type */
  7031.       fcs_save = -1;
  7032.       return(1);
  7033.       }
  7034. #endif /* NOCSETS */
  7035.  
  7036.       case 406:                /* Window slots */
  7037.     y = atoi(p);
  7038.     if (y == 0) y = 1;
  7039.     if (y < 1 || y > MAXWS) return(0);
  7040.     wslotr = y;
  7041.     swcapr = 1;
  7042.     urpsiz = adjpkl(urpsiz,wslotr,bigrbsiz);
  7043.     return(1);
  7044.  
  7045.       case 410:                /* Transfer mode */
  7046.     y = atoi(p);            /* 0 = automatic, nonzero = manual */
  7047.     if (y != 0) y = 1;
  7048.     xfermode = y;
  7049.     debug(F101,"REMOTE SET xfermode","",xfermode);
  7050.     return(1);
  7051.  
  7052.       case 420:                /* SERVER CD-MESSAGE { ON, OFF } */
  7053.     y = atoi(p);            /* 0 = automatic, nonzero = manual */
  7054.     srvcdmsg = y;
  7055.     return(1);
  7056.  
  7057.       default:                /* Anything else... */
  7058.     return(0);
  7059.     }
  7060. }
  7061.  
  7062. /* Adjust packet length based on number of window slots and buffer size */
  7063.  
  7064. int
  7065. adjpkl(pktlen,slots,bufsiz) int pktlen, slots, bufsiz; {
  7066.     if (protocol != PROTO_K) return(pktlen);
  7067.     debug(F101,"adjpkl len","",pktlen);
  7068.     debug(F101,"adjpkl slots","",slots);
  7069.     debug(F101,"adjpkl bufsiz","",bufsiz);
  7070.     if (((pktlen + 6) * slots) > bufsiz)
  7071.       pktlen = (bufsiz / slots) - 6;
  7072.     debug(F101,"adjpkl new len","",pktlen);
  7073.     return(pktlen);
  7074. }
  7075.  
  7076. /* Set transfer mode and file naming based on comparison of system types */
  7077.  
  7078.  
  7079. VOID
  7080. whoarewe() {
  7081. #ifndef NOICP
  7082.     extern int g_xfermode;
  7083. #endif /* NOICP */
  7084.  
  7085.     wearealike = 0;
  7086.  
  7087.     debug(F101,"whoarewe xfermode","",xfermode);
  7088. #ifndef NOICP
  7089.     debug(F101,"whoarewe g_xfermode","",g_xfermode);
  7090. #endif /* NOICP */
  7091.     if (whoareu[0]) {            /* If we know partner's system type */
  7092.     char * p = (char *)whoareu;
  7093.     debug(F110,"whoarewe remote sysid",whoareu,0);
  7094.     if (!strcmp(p,cksysid))        /* Other system same as us */
  7095.       wearealike = 1;
  7096.  
  7097. #ifdef UNIX
  7098.     else if (!strcmp(p,"L3"))    /* UNIX is sort of like AmigaDOS */
  7099.       wearealike = 1;        /* (same directory separator) */
  7100.     else if (!strcmp(p,"N3"))    /* UNIX like Aegis */
  7101.       wearealike = 1;
  7102. #else
  7103. #ifdef AMIGA
  7104. /* Like UNIX, but case distinctions are ignored and can begin with device:. */
  7105.     else if (!strcmp(p,"U1"))    /* Amiga is sort of like UNIX */
  7106.       wearealike = 1;
  7107.     else if (!strcmp(p,"N3"))    /* Amiga is sort of like Aegis */
  7108.       wearealike = 1;
  7109. #else
  7110. #ifdef OS2                /* (Includes Windows 95/NT) */
  7111.  
  7112.     /* DOS, GEMDOS, Windows 3.x, Windows 95, Windows NT */
  7113.     /* All "the same" for FAT partitions but all bets off otherwise */
  7114.     /* so this part needs some refinement ...  */
  7115.  
  7116.     else if (!strcmp(p,"U8"))    /* MS-DOS */
  7117.       wearealike = 1;
  7118.     else if (!strcmp(p,"UO"))    /* OS/2 */
  7119.       wearealike = 1;
  7120.     else if (!strcmp(p,"UN"))    /* Windows NT or 95 */
  7121.       wearealike = 1;
  7122.     else if (!strcmp(p,"K2"))    /* GEMDOS */
  7123.       wearealike = 1;
  7124. #else
  7125. #ifdef GEMDOS
  7126.     else if (!strcmp(p,"U8"))
  7127.       wearealike = 1;
  7128.     else if (!strcmp(p,"UO"))
  7129.       wearealike = 1;
  7130.     else if (!strcmp(p,"UN"))
  7131.       wearealike = 1;
  7132.     else if (!strcmp(p,"K2"))
  7133.       wearealike = 1;
  7134. #endif /* GEMDOS */
  7135. #endif /* OS2 */
  7136. #endif /* AMIGA */
  7137. #endif /* UNIX */
  7138.  
  7139.     /* Get here with wearealike == 1 if system types match */
  7140.  
  7141.     debug(F101,"whoarewe wearealike","",wearealike);
  7142.     if (!wearealike)        /* Not alike */
  7143.       return;
  7144.  
  7145.     fncnv = XYFN_L;            /* Alike, so literal filenames */
  7146.     debug(F101,"whoarewe setting fncnv","",fncnv);
  7147.  
  7148.     if (xfermode == XMODE_A) {    /* Current xfer mode is auto */
  7149. #ifdef VMS
  7150.         binary = XYFT_L;        /* For VMS-to-VMS, use labeled */
  7151. #else
  7152. #ifdef OS2
  7153.         /* OS/2 but not Windows */
  7154.         if (!strcmp(cksysid,"UO") && !strcmp((char *)whoareu,"UO"))
  7155.           binary = XYFT_L;        /* For OS/2-to-OS/2, use labeled */
  7156. #else
  7157.         binary = XYFT_B;        /* For all others use binary */
  7158. #endif /* OS2 */
  7159. #endif /* VMS */
  7160.         gnf_binary = binary;    /* Prevailing type for gnfile() */
  7161.         debug(F101,"whoarewe setting binary","",binary);
  7162.     }
  7163.     }
  7164. }
  7165. #endif /* NOXFER */
  7166.