home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckcfn3.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  77KB  |  2,607 lines
  1. /*  C K C F N 3  --  Packet buffer management for C-Kermit  */
  2.  
  3. /* (plus assorted functions tacked on at the end) */
  4.  
  5. /*
  6.   Author: Frank da Cruz <fdc@columbia.edu>,
  7.   Columbia University Academic Information Systems, New York City.
  8.  
  9.   Copyright (C) 1985, 2010,
  10.     Trustees of Columbia University in the City of New York.
  11.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  12.     copyright text in the ckcmai.c module for disclaimer and permissions.
  13. */
  14. /*
  15.  Note -- if you change this file, please amend the version number and date at
  16.  the top of ckcfns.c accordingly.
  17. */
  18.  
  19. #include "ckcsym.h"
  20. #include "ckcdeb.h"
  21. #include "ckcasc.h"
  22. #include "ckcker.h"
  23. #include "ckcxla.h"
  24.  
  25. /*  C K M K D I R  --  Create a directory  */
  26. /*
  27.   Call with:
  28.     int fc    = 0 to create, nonzero to remove, a directory.
  29.     char * s  = pointer to name of directory to create or remove.
  30.     char ** r = address of pointer to return name or message.
  31.     int m     = 1 to print error messages, 0 to be silent.
  32.     int cvt   = 1 means convert s from standard format to local format;
  33.                 0 means use s as is.
  34.   Returns:
  35.     0 on success (directory was created or removed).
  36.    -1 when attempt to create the directory failed.
  37.    -2 on internal error (e.g. no code for creating directories).
  38.   On success, the name is pointed to by p.
  39.   On failure, the reason is pointed to by p.
  40. */
  41. #ifdef CK_MKDIR
  42. static char ckmkdbuf[CKMAXPATH+1];
  43. #else
  44. #ifdef datageneral
  45. static char ckmkdbuf[CKMAXPATH+1];
  46. #endif /* datageneral */
  47. #endif /* CK_MKDIR */
  48.  
  49. #ifdef CK_MKDIR
  50. int
  51. ckmkdir(fc,s,r,m,cvt) int fc; char * s; char ** r; int m; int cvt; {
  52.     int x, rc = -2;
  53.     char tmpbuf[CKMAXPATH+1];
  54.     char buf2[CKMAXPATH+1];
  55.     if (!s) s = "";
  56.     debug(F110,"ckmkdir 1 fc",s,fc);
  57.     if (!*s) {
  58.     ckmakmsg(ckmkdbuf,
  59.          CKMAXPATH+1,
  60.          (fc == 0) ? "mkdir" : "rmdir",
  61.          ": no name given",
  62.          NULL,
  63.          NULL
  64.          );
  65.     *r = ckmkdbuf;
  66.     return(-2);
  67.     }
  68. #ifdef datageneral
  69. /* Come back and make this nicer later if anybody notices */
  70.     if (fc == 0) {            /* mkdir */
  71.     rc = createdir(s,0);
  72.     } else {                /* rmdir */
  73.     /* AOS/VS rmdir() is a no-op. */
  74.     ckmakmsg(tmpbuf,CKMAXPATH+1,"delete ",s,NULL,NULL);
  75.     debug(F110,"ckmkdir 2",tmpbuf,0);
  76.     rc = system(tmpbuf);
  77.     }
  78.     *r = NULL;
  79. #else /* not datageneral */
  80.  
  81. /* First make sure the name has an acceptable directory-name format */
  82.  
  83. #ifdef VMS
  84.     {
  85.     char *p = s;
  86.     int lb = 0, rb = 0, sl = 0;
  87.     while (*p) {
  88.         if      (*p == '[' || *p == '<') lb++;   /* Count brackets */
  89.         else if (*p == ']' || *p == '>') rb++;
  90.         else if (*p == '/')          sl++;    /* and slashes */
  91.         p++;
  92.     }
  93.     if (lb != 1 && rb != 1 && sl == 0 && p > s && *(p-1) != ':') {
  94.         /* Probably just a word - convert to VMS format */
  95.         ckmakmsg(buf2,
  96.              CKMAXPATH+1,
  97.              "[",
  98.              (*s == '.') ? "" : ".",
  99.              s,
  100.              "]"
  101.              );
  102.         s = buf2;
  103.     } else if (lb == 0 && rb == 0 && sl != 0 && p > s && *(p-1) != ':') {
  104.         int flag = 0;
  105.         /* Seems to be in UNIX format */
  106.         x = strlen(s);
  107.         if (x > 0 && s[x-1] != '/')
  108.           flag = 1;
  109.         ckmakmsg(buf2,CKMAXPATH+1,s,flag ? "/" : "",NULL,NULL);
  110.         s = buf2;
  111.     }
  112.     if (s == buf2) {
  113.         ckstrncpy(tmpbuf,s,CKMAXPATH+1);
  114.         s = tmpbuf;
  115.     }
  116.     debug(F110,"ckmkdir 2+VMS",s,0);
  117.     }
  118. #else
  119. #ifdef UNIXOROSK
  120. #ifdef DTILDE
  121.     s = tilde_expand(s);
  122. #endif /* DTILDE */
  123.     ckstrncpy(tmpbuf,s,CKMAXPATH+1);
  124.     s = tmpbuf;
  125.     x = strlen(s);
  126.     if (x > 0 && s[x-1] != '/') {    /* Must end in "/" for zmkdir() */
  127.     s[x] = '/';
  128.     s[x+1] = NUL;
  129.     debug(F110,"ckmkdir 2+UNIXOROSK",s,0);
  130.     }
  131. #else /* UNIXOROSK */
  132. #ifdef OS2
  133.     ckstrncpy(tmpbuf,s,CKMAXPATH+1);
  134.     s = tmpbuf;
  135.     x = strlen(s);
  136.     if (fc == 0 && x > 0 && s[x-1] != '/') { /* Must end in "/" for zmkdir() */
  137.     s[x] = '/';
  138.     s[x+1] = NUL;
  139.     debug(F110,"ckmkdir 2+OS2",s,0);
  140.     }
  141. #endif /* OS2 */
  142. #endif /* UNIXOROSK */
  143. #endif /* VMS */
  144. #ifdef NZLTOR
  145.     /* Server is calling us, so convert to local format if necessary */
  146.     if (cvt) {
  147.     nzrtol(s,(char *)buf2,1,PATH_ABS,CKMAXPATH);
  148.     s = buf2;
  149.     debug(F110,"ckmkdir 3",s,0);
  150.     }
  151. #endif /* NZLTOR */
  152.     debug(F110,"ckmkdir 4",s,0);
  153.     if (fc == 0) {            /* Making */
  154. #ifdef CK_MKDIR
  155.     rc = zmkdir(s);
  156. #else
  157. #ifdef NT
  158.     rc = _mkdir(s);
  159. #else
  160.     rc = mkdir(s,0777);
  161. #endif /* NT */
  162. #endif /* CK_MKDIR */
  163.     } else {                /* Removing */
  164. #ifdef ZRMDIR
  165.     rc = zrmdir(s);
  166. #else
  167. #ifdef NT
  168.     rc = _rmdir(s);
  169. #else
  170. #ifdef OSK
  171.     rc = -2;
  172. #else
  173.     rc = rmdir(s);
  174. #endif /* OSK */
  175. #endif /* NT */
  176. #endif /* ZRMDIR */
  177.     }
  178. #endif /* datageneral */
  179.     debug(F101,"ckmkdir rc","",rc);
  180.     if (rc == -2) {
  181.     ckmakmsg(ckmkdbuf,
  182.          CKMAXPATH,
  183.          "Directory ",
  184.          (fc == 0) ? "creation" : "removal",
  185.          "not implemented in this version of C-Kermit",
  186.          NULL
  187.          );
  188.     *r = ckmkdbuf;
  189.     if (m) printf("%s\n",*r);
  190.     } else if (rc < 0) {
  191.     if (m) perror(s);
  192.     ckmakmsg(ckmkdbuf,CKMAXPATH,s,": ",ck_errstr(),NULL);
  193.     *r = ckmkdbuf;
  194.     } else if (fc == 0 && zfnqfp(s,CKMAXPATH,ckmkdbuf)) {
  195.     *r = ckmkdbuf;
  196.     } else if (fc != 0) {
  197.     ckmakmsg(ckmkdbuf,CKMAXPATH,s,": removed",NULL,NULL);
  198.     *r = ckmkdbuf;
  199.     }
  200.     return(rc);
  201. }
  202. #endif /* CK_MKDIR */
  203.  
  204. #ifndef NOXFER                /* Rest of this file... */
  205.  
  206. #ifndef NODISPO
  207. #ifdef pdp11
  208. #define NODISPO
  209. #endif /* pdpd11 */
  210. #endif /* NODISPO */
  211.  
  212. extern int pipesend;
  213. #ifdef PIPESEND
  214. extern char ** sndfilter;
  215. #endif /* PIPESEND */
  216.  
  217. extern int unkcs, wmax, wcur, discard, bctu, bctl, local, fdispla, what,
  218.     sendmode, opnerr, dest, epktrcvd, epktsent, filestatus, eofmethod, dispos,
  219.     fncnv, fnrpath;
  220.  
  221. extern char * ofn2;
  222. extern char * rfspec, * sfspec, * prfspec, * psfspec, * rrfspec, * prrfspec;
  223. extern char ofn1[];
  224. extern int ofn1x;
  225. extern char * ofperms;
  226.  
  227. #ifdef VMS
  228. extern int batch;
  229. #else
  230. extern int backgrd;
  231. #endif /* VMS */
  232.  
  233. extern int xflg, remfile, remappd;
  234. extern CHAR *data;
  235. extern char filnam[];
  236. #ifndef NOFRILLS
  237. extern int rprintf, rmailf;        /* REMOTE MAIL, PRINT */
  238. char optbuf[OPTBUFLEN];            /* Options for MAIL or REMOTE PRINT */
  239. #endif /* NOFRILLS */
  240. extern int wslots;
  241. extern int fblksiz, frecl, forg, frecfm, fncact, fncsav, fcctrl, lf_opts;
  242. extern CHAR * srvcmd;
  243. extern int srvcmdlen;
  244.  
  245. extern int binary, spsiz;
  246. extern int pktnum, cxseen, czseen, nfils, stdinf;
  247. extern int memstr, stdouf, keep, sndsrc, hcflg;
  248. extern int server, en_cwd, en_mai, en_pri;
  249.  
  250. /* Attributes in/out enabled flags */
  251.  
  252. extern int
  253.   atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko,
  254.   attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso;
  255.  
  256. #ifdef CK_PERMS
  257. extern int atlpri, atlpro, atgpri, atgpro;
  258. #endif /* CK_PERMS */
  259.  
  260. #ifdef STRATUS
  261. extern int atfrmi, atfrmo, atcrei, atcreo, atacti, atacto;
  262. #endif /* STRATUS */
  263.  
  264. #ifdef datageneral
  265. extern int quiet;
  266. #endif /* datageneral */
  267.  
  268. extern long filcnt;
  269. extern CK_OFF_T fsize, ffc, tfc, sendstart, calibrate;
  270. CK_OFF_T rs_len;
  271.  
  272. #ifndef NOCSETS
  273. _PROTOTYP (VOID setxlate, (void));
  274. extern int tcharset, fcharset;
  275. extern int ntcsets, xlatype, xfrxla;
  276. extern struct csinfo tcsinfo[], fcsinfo[];
  277. #endif /* NOCSETS */
  278.  
  279. /* Variables global to Kermit that are defined in this module */
  280.  
  281. #ifdef CKXXCHAR                /* DOUBLE / IGNORE char table */
  282. int dblflag = 0;
  283. int ignflag = 0;
  284. short dblt[256] = {
  285.     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,
  286.     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,
  287.     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,
  288.     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,
  289.     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,
  290.     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,
  291.     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,
  292.     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
  293. };
  294. #endif /* CKXXCHAR */
  295.  
  296. int winlo;                /* packet number at low window edge  */
  297.  
  298. int sbufnum;                /* number of free buffers */
  299. int dum001 = 1234;            /* protection... */
  300. int sbufuse[MAXWS];            /* buffer in-use flag */
  301. int dum003 = 1111;
  302. int rbufnum;                /* number of free buffers */
  303. int dum002 = 4321;            /* more protection */
  304. int rbufuse[MAXWS];            /* buffer in-use flag */
  305. int sseqtbl[64];            /* sequence # to buffer # table */
  306. int rseqtbl[64];            /* sequence # to buffer # table */
  307. int sacktbl[64];            /* sequence # ack table */
  308.  
  309. int o_isopen = 0, i_isopen = 0;        /* Input & output files are open */
  310.  
  311. #ifdef DYNAMIC
  312. struct pktinfo *s_pkt = NULL;        /* array of pktinfo structures */
  313. struct pktinfo *r_pkt = NULL;        /* array of pktinfo structures */
  314. #else
  315. struct pktinfo s_pkt[MAXWS];        /* array of pktinfo structures */
  316. struct pktinfo r_pkt[MAXWS];        /* array of pktinfo structures */
  317. #endif /* DYNAMIC */
  318.  
  319. #ifdef DEBUG
  320. char xbuf[200];                /* For debug logging */
  321. #endif /* DEBUG */
  322.  
  323. #ifdef DYNAMIC
  324. CHAR *bigsbuf = NULL, *bigrbuf = NULL;
  325. #else
  326. char bigsbt[8];                /* Protection (shouldn't need this). */
  327.                     /* BUT DON'T REMOVE IT! */
  328. CHAR bigsbuf[SBSIZ + 5];        /* Send-packet buffer area */
  329. char bigrbt[8];                /* Safety padding */
  330. CHAR bigrbuf[RBSIZ + 5];        /* Receive-packet area */
  331. #endif
  332. int bigsbsiz = SBSIZ;            /* Sizes of big send & rcv buffers. */
  333. int bigrbsiz = RBSIZ;
  334.  
  335. #ifdef VMS
  336. int zchkpath(char *s);
  337. #endif /* VMS */
  338.  
  339. /* FUNCTIONS */
  340.  
  341. VOID
  342. dofast() {
  343.     long maxbufsiz = RBSIZ;        /* Configuration parameters */
  344.     int maxpktsiz = MAXSP;
  345.     extern int spsizf,            /* For bug in IRIX Telnet server */
  346.       rpsiz, urpsiz, spsizr, spmax, wslotr;
  347.     extern struct ck_p ptab[];
  348.  
  349.     if (maxpktsiz < 40)            /* Long packet length */
  350.       maxpktsiz = 40;
  351.     else if (maxpktsiz > 4000)
  352.       maxpktsiz = 4000;
  353.     wslotr = maxbufsiz / maxpktsiz;
  354.     if (wslotr > MAXWS)            /* Window slots */
  355.       wslotr = MAXWS;
  356.     if (wslotr > 30)
  357.       wslotr = 30;
  358.     else if (wslotr < 1)
  359.       wslotr = 1;
  360.     urpsiz = adjpkl(maxpktsiz,wslotr,maxbufsiz);
  361.     ptab[PROTO_K].rpktlen = urpsiz;
  362.     rpsiz = (urpsiz > 94) ? 94 : urpsiz; /* Max non-long packet length */
  363.     debug(F111,"dofast","uprsiz",urpsiz);
  364. #ifdef IRIX
  365. #ifndef IRIX65
  366.     /* IRIX Telnet server chops off writes longer than 4K */
  367.     spsiz = spmax = spsizr = urpsiz;
  368.     debug(F101,"doarg Q IRIX spsiz","",spsiz);
  369.     spsizf = 1;
  370. #endif /* IRIX65 */
  371. #endif /* IRIX */
  372. #ifdef CK_SPEED
  373.     setprefix(PX_CAU);            /* Cautious unprefixing */
  374. #endif /* CK_SPEED */
  375. }
  376.  
  377.  
  378. /* For sanity, use "i" for buffer slots, "n" for packet numbers. */
  379.  
  380. /* I N I B U F S */
  381.  
  382. /*
  383.   Allocates the big send and receive buffers.
  384.   Call with size for big send buffer (s) and receive buffer (r).
  385.   These sizes can be different.
  386.   Attempts to allocate buffers of the requested size, but if it can't,
  387.   it will allocate smaller ones.
  388.   Sets global variables bigsbsiz and bigrbsiz to the actual sizes,
  389.   and bigsbuf and bigrbuf pointing to the actual buffers.
  390.   Designed to be called more than once.
  391.   Returns 0 on success, -1 on failure.
  392. */
  393.  
  394. CHAR *bigbufp = NULL;
  395.  
  396. int
  397. inibufs(s,r) int s, r; {
  398. #ifdef DYNAMIC
  399.     unsigned
  400.       int size;
  401. #ifdef OS2
  402.     unsigned        /* Don't you wish everybody had unsigned long... */
  403. #endif /* OS2 */
  404.       long z;
  405.     int x;
  406.  
  407.     debug(F101,"inibufs s","",s);
  408.     debug(F101,"inibufs r","",r);
  409.  
  410.     if (s < 80 || r < 80) return(-1);    /* Validate arguments. */
  411.  
  412.     if (!s_pkt) {            /* Allocate packet info structures */
  413.     if (!(s_pkt = (struct pktinfo *) malloc(sizeof(struct pktinfo)*MAXWS)))
  414.       fatal("ini_pkts: no memory for s_pkt");
  415.     }
  416.     for (x = 0; x < MAXWS; x++)
  417.       s_pkt[x].pk_adr = NULL;        /* Initialize addresses */
  418.  
  419.     if (!r_pkt) {
  420.     if (!(r_pkt = (struct pktinfo *) malloc(sizeof(struct pktinfo)*MAXWS)))
  421.       fatal("ini_pkts: no memory for s_pkt");
  422.     }
  423.     for (x = 0; x < MAXWS; x++)
  424.       r_pkt[x].pk_adr = NULL;        /* Initialize addresses */
  425.  
  426.     if (!srvcmd) {            /* Allocate srvcmd buffer */
  427.     srvcmd = (CHAR *) malloc(r + 100);
  428.     if (!srvcmd) return(-1);
  429.     srvcmdlen = r + 99;
  430.     *srvcmd = NUL;
  431.     }
  432.     if (bigbufp) {            /* Free previous buffers, if any. */
  433.     free(bigbufp);
  434.     bigbufp = NULL;
  435.     }
  436.     size = s + r + 40;            /* Combined requested size + padding */
  437.     z  = (unsigned) s + (unsigned) r + 40;
  438.     debug(F101,"inibufs size 1","",size);
  439.     debug(F101,"inibufs size z","",z);
  440.     if ((long) size != z) {
  441.     debug(F100,"inibufs overflow","",0);
  442.     size = 65535;
  443.     }
  444.  
  445.     /* Try to get the space.  If malloc fails, try to get a little less. */
  446.     /* (Obviously, this algorithm can be refined.) */
  447.  
  448.     while (!(bigbufp = (CHAR *) malloc(size))) {
  449.     debug(F101,"inibufs bigbuf malloc failed","",size);
  450.     size = (size * 2) / 3;        /* Failed, cut size by 1/3. */
  451.     if (size < 200)            /* Try again until too small. */
  452.       return(-1);
  453.     }
  454.     debug(F101,"inibufs size 2","",size); /* OK, we got some space. */
  455.  
  456. /*
  457.   Now divide the allocated space between the send and receive buffers in the
  458.   requested proportion.  The natural formula would be (s / (s + r)) * size
  459.   (for the send buffer), but that doesn't work with integer arithmetic and we
  460.   can't use floating point because some machines don't have it.  This can be
  461.   rearranged as (s * size) / (s + r).  But (s * size) can be VERY large, too
  462.   large for 32 bits.  So let's do it this way.  This arithmetic works for
  463.   buffer sizes up to about 5,000,000.
  464. */
  465. #define FACTOR 20L
  466.     z = ( (long) s * FACTOR ) / ( (long) s + (long) r );
  467.     x = ( z * ( (long) size / FACTOR ) );
  468.     if (x < 0) return(-1);        /* Catch overflow */
  469.  
  470.     bigsbsiz = x - 5;            /* Size of send buffer */
  471.     bigsbuf = bigbufp;            /* Address of send buffer */
  472.     debug(F101,"inibufs bigsbsiz","",bigsbsiz);
  473.  
  474.     bigrbsiz = size - x - 5;        /* Size of receive buffer */
  475.     bigrbuf = bigbufp + x;        /* Addresss of receive buffer */
  476.     debug(F101,"inibufs bigrbsiz","",bigrbsiz);
  477.  
  478.     return(0);                /* Success */
  479. #else                    /* No dynamic allocation */
  480.     bigsbsiz = SBSIZ;            /* Just use the symbols */
  481.     bigrbsiz = RBSIZ;            /* ... */
  482.     return(0);                /* Success. */
  483. #endif /* DYNAMIC */
  484. }
  485.  
  486.  
  487. /* M A K E B U F  --  Makes and clears a new buffers.  */
  488.  
  489. /* Call with: */
  490. /*  slots:  number of buffer slots to make, 1 to 32 */
  491. /*  bufsiz: size of the big buffer */
  492. /*  buf:    address of the big buffer */
  493. /*  xx:     pointer to array of pktinfo structures for these buffers */
  494.  
  495. /* Subdivides the big buffer into "slots" buffers. */
  496.  
  497. /* Returns: */
  498. /*  -1 if too many or too few slots requested,     */
  499. /*  -2 if slots would be too small.      */
  500. /*   n (positive) on success = size of one buffer. */
  501. /*   with pktinfo structure initialized for this set of buffers. */
  502.  
  503. int
  504. makebuf(slots,bufsiz,buf,xx)
  505. /* makebuf */ int slots, bufsiz; CHAR buf[]; struct pktinfo *xx; {
  506.  
  507.     CHAR *a;
  508.     int i, size;
  509.  
  510.     debug(F101,"makebuf","",slots);
  511.     debug(F101,"makebuf bufsiz","",bufsiz);
  512.     debug(F101,"makebuf MAXWS","",MAXWS);
  513.  
  514.     if (slots > MAXWS || slots < 1) return(-1);
  515.     if (bufsiz < slots * 10 ) return(-2);
  516.  
  517.     size = bufsiz / slots;        /* Divide up the big buffer. */
  518.     a = buf;                /* Address of first piece. */
  519.  
  520.     for (i = 0; i < slots; i++) {
  521.     struct pktinfo *x = &xx[i];
  522.     x->bf_adr = a;            /* Address of this buffer */
  523.     x->bf_len = size;        /* Length of this buffer */
  524.     x->pk_len = 0;            /* Length of data field */
  525.         x->pk_typ = ' ';        /* packet type */
  526.     x->pk_seq = -1;            /* packet sequence number */
  527.         x->pk_rtr = 0;            /* retransmissions */
  528.     *a = '\0';            /* Clear the buffer */
  529.     a += size;            /* Position to next buffer slot */
  530.     }
  531.     return(size);
  532. }
  533.  
  534. /*  M A K S B U F  --  Makes the send-packet buffer  */
  535.  
  536. int
  537. mksbuf(slots) int slots; {
  538.     int i, x;
  539.     sbufnum = 0;
  540.     if ((x = makebuf(slots,bigsbsiz,bigsbuf,s_pkt)) < 0) {
  541.     debug(F101,"mksbuf makebuf return","",x);
  542.     return(x);
  543.     }
  544.     debug(F101,"mksbuf makebuf return","",x);
  545.     for (i = 0; i < 64; i++) {        /* Initialize sequence-number- */
  546.     sseqtbl[i] = -1;        /* to-buffer-number table. */
  547.         sacktbl[i] = 0;
  548.     }
  549.     for (i = 0; i < MAXWS; i++)
  550.       sbufuse[i] = 0;            /* Mark each buffer as free */
  551.     sbufnum = slots;
  552.     wcur = 0;
  553.     return(x);
  554. }
  555.  
  556. /*  M A K R B U F  --  Makes the receive-packet buffer  */
  557.  
  558. int
  559. mkrbuf(slots) int slots; {
  560.     int i, x;
  561.     rbufnum = 0;
  562.     if ((x = makebuf(slots,bigrbsiz,bigrbuf,r_pkt)) < 0) {
  563.     debug(F101,"mkrbuf makebuf return","",x);
  564.     return(x);
  565.     }
  566.     debug(F101,"mkrbuf makebuf return","",x);
  567.     for (i = 0; i < 64; i++) {        /* Initialize sequence-number- */
  568.     rseqtbl[i] = -1;        /* to-buffer-number table. */
  569.     }
  570.     for (i = 0; i < MAXWS; i++)
  571.       rbufuse[i] = 0;            /* Mark each buffer as free */
  572.     rbufnum = slots;
  573.     wcur = 0;
  574.     return(x);
  575. }
  576.  
  577. /*  W I N D O W  --  Resize the window to n  */
  578.  
  579. int
  580. window(n) int n; {
  581.     debug(F101,"window","",n);
  582.     if (n < 1 || n > MAXWS) return(-1);
  583.     if (mksbuf(n) < 0) return(-1);
  584.     if (mkrbuf(n) < 0) return(-1);
  585.     wslots = n;
  586. #ifdef DEBUG
  587.     if (deblog) dumpsbuf();
  588.     if (deblog) dumprbuf();
  589. #endif /* DEBUG */
  590.     return(0);
  591. }
  592.  
  593. /*  G E T S B U F  --  Allocate a send-buffer.  */
  594.  
  595. /*  Call with packet sequence number to allocate buffer for. */
  596. /*  Returns: */
  597. /*   -4 if argument is invalid (negative, or greater than 63) */
  598. /*   -3 if buffers were thought to be available but really weren't (bug!) */
  599. /*   -2 if the number of free buffers is negative (bug!) */
  600. /*   -1 if no free buffers. */
  601. /*   0 or positive, packet sequence number, with buffer allocated for it. */
  602.  
  603. int
  604. getsbuf(n) int n; {            /* Allocate a send-buffer */
  605.     int i;
  606.     CHAR * p = NULL;
  607.     if (n < 0 || n > 63) {
  608.     debug(F101,"getsbuf bad arg","",n);
  609.     return(-4);    /* Bad argument */
  610.     }
  611.     debug(F101,"getsbuf packet","",n);
  612.     /* debug(F101,"getsbuf, sbufnum","",sbufnum); */
  613.     if (sbufnum == 0) return(-1);    /* No free buffers. */
  614.     if (sbufnum < 0) return(-2);    /* Shouldn't happen. */
  615.     for (i = 0; i < wslots; i++)    /* Find the first one not in use. */
  616.       if (sbufuse[i] == 0) {        /* Got one? */
  617.       sbufuse[i] = 1;        /* Mark it as in use. */
  618.       sbufnum--;            /* One less free buffer. */
  619.       *s_pkt[i].bf_adr = '\0';    /* Zero the buffer data field */
  620.       s_pkt[i].pk_seq = n;        /* Put in the sequence number */
  621.           sseqtbl[n] = i;        /* Back pointer from sequence number */
  622.           sacktbl[n] = 0;        /* ACK flag */
  623.       s_pkt[i].pk_len = 0;        /* Data field length now zero. */
  624.       s_pkt[i].pk_typ = ' ';    /* Blank the packet type too. */
  625.       s_pkt[i].pk_rtr = 0;        /* Zero the retransmission count */
  626.       p = s_pkt[i].bf_adr + 7;    /* Set global "data" address. */
  627.       debug(F101,"getsbuf p","",0);
  628.       data = p;
  629.       if (!data) {
  630.           debug(F100,"getsbuf data == NULL","",0);
  631.               return(-3);
  632.           }
  633.       if ((what & (W_SEND|W_REMO)) && (++wcur > wmax))
  634.         wmax = wcur;        /* For statistics. */
  635.       /* debug(F101,"getsbuf wcur","",wcur); */
  636.       return(n);            /* Return its index. */
  637.       }
  638.     sbufnum = 0;            /* Didn't find one. */
  639.     return(-3);                /* Shouldn't happen! */
  640. }
  641.  
  642. int
  643. getrbuf() {                /* Allocate a receive buffer */
  644.     int i;
  645. #ifdef COMMENT
  646.     /* This code is pretty stable by now... */
  647.     /* Looks like we might need this after all */
  648.     debug(F101,"getrbuf rbufnum","",rbufnum);
  649.     debug(F101,"getrbuf wslots","",wslots);
  650.     debug(F101,"getrbuf dum002","",dum002);
  651.     debug(F101,"getrbuf dum003","",dum003);
  652. #endif /* COMMENT */
  653.     if (rbufnum == 0) return(-1);    /* No free buffers. */
  654.     if (rbufnum < 0) return(-2);    /* Shouldn't happen. */
  655.     for (i = 0; i < wslots; i++)    /* Find the first one not in use. */
  656.       if (rbufuse[i] == 0) {        /* Got one? */
  657.       rbufuse[i] = 1;        /* Mark it as in use. */
  658.       *r_pkt[i].bf_adr = '\0';    /* Zero the buffer data field */
  659.       rbufnum--;            /* One less free buffer. */
  660.       debug(F101,"getrbuf new rbufnum","",rbufnum);
  661.       if ((what & W_RECV) && (++wcur > wmax))
  662.         wmax = wcur;        /* For statistics. */
  663.       /* debug(F101,"getrbuf wcur","",wcur); */
  664.       return(i);            /* Return its index. */
  665.       }
  666.     /* debug(F101,"getrbuf foulup","",i); */
  667.     rbufnum = 0;            /* Didn't find one. */
  668.     return(-3);                /* Shouldn't happen! */
  669. }
  670.  
  671. /*  F R E E S B U F  --  Free send-buffer for given packet sequence number */
  672.  
  673. /*  Returns:  */
  674. /*   1 upon success  */
  675. /*  -1 if specified buffer does not exist */
  676.  
  677. int
  678. freesbuf(n) int n; {            /* Release send-buffer for packet n. */
  679.     int i;
  680.  
  681.     debug(F101,"freesbuf","",n);
  682.     if (n < 0 || n > 63)        /* No such packet. */
  683.       return(-1);
  684.     i = sseqtbl[n];            /* Get the window slot number. */
  685.     if (i > -1 && i <= wslots) {
  686.     sseqtbl[n] = -1;        /* If valid, remove from seqtbl */
  687.      sbufnum++;            /* and count one more free buffer */
  688.     sbufuse[i] = 0;            /* and mark it as free, */
  689.     if (what & (W_SEND|W_REMO))    /* decrement active slots */
  690.       wcur--;            /* for statistics and display. */
  691.     } else {
  692.     debug(F101," sseqtbl[n]","",sseqtbl[n]);
  693.     return(-1);
  694.     }
  695.  
  696. /* The following is done only so dumped buffers will look right. */
  697.  
  698.     if (1) {
  699.     *s_pkt[i].bf_adr = '\0';    /* Zero the buffer data field */
  700.     s_pkt[i].pk_seq = -1;        /* Invalidate the sequence number */
  701.     s_pkt[i].pk_len = 0;        /* Data field length now zero. */
  702.     s_pkt[i].pk_typ = ' ';        /* Blank the packet type too. */
  703.     s_pkt[i].pk_rtr = 0;        /* And the retries field. */
  704.     }
  705.     return(1);
  706. }
  707.  
  708. int
  709. freerbuf(i) int i; {            /* Release receive-buffer slot "i". */
  710.     int n;
  711.  
  712. /* NOTE !! Currently, this function frees the indicated buffer, but */
  713. /* does NOT erase the data.  The program counts on this.  Will find a */
  714. /* better way later.... */
  715.  
  716.     /* debug(F101,"freerbuf, slot","",i); */
  717.     if (i < 0 || i >= wslots) {        /* No such slot. */
  718.     debug(F101,"freerbuf no such slot","",i);
  719.     return(-1);
  720.     }
  721.     n = r_pkt[i].pk_seq;        /* Get the packet sequence number */
  722.     debug(F101,"freerbuf packet","",n);
  723.     if (n > -1 && n < 64)        /* If valid, remove from seqtbl */
  724.       rseqtbl[n] = -1;
  725.     if (rbufuse[i] != 0) {        /* If really allocated, */
  726.     rbufuse[i] = 0;            /* mark it as free, */
  727.     rbufnum++;            /* and count one more free buffer. */
  728.     if (what & W_RECV)        /* Keep track of current slots */
  729.       wcur--;            /*  for statistics and display */
  730.     debug(F101,"freerbuf rbufnum","",rbufnum);
  731.     }
  732.  
  733. /* The following is done only so dumped buffers will look right. */
  734.  
  735.     if (1) {
  736.      /* *r_pkt[i].bf_adr = '\0'; */    /* Zero the buffer data field */
  737.     r_pkt[i].pk_seq = -1;        /* And from packet list */
  738.     r_pkt[i].pk_len = 0;        /* Data field length now zero. */
  739.     r_pkt[i].pk_typ = ' ';        /* Blank the packet type too. */
  740.     r_pkt[i].pk_rtr = 0;        /* And the retries field. */
  741.     }
  742.     return(1);
  743. }
  744.  
  745. /* This is like freerbuf, except it's called with a packet sequence number */
  746. /* rather than a packet buffer index. */
  747.  
  748. VOID
  749. freerpkt(seq) int seq; {
  750.     int k;
  751.     debug(F101,"freerpkt seq","",seq);
  752.     k = rseqtbl[seq];
  753.     /* debug(F101,"freerpkt k","",k); */
  754.     if (k > -1) {
  755.     k = freerbuf(k);
  756.     /* debug(F101,"freerpkt freerbuf","",k); */
  757.     }
  758. }
  759.  
  760.  
  761. /*  C H K W I N  --  Check if packet n is in window. */
  762.  
  763. /*  Returns: */
  764. /*    0 if it is in the current window,  */
  765. /*   +1 if it would have been in previous window (e.g. if ack was lost), */
  766. /*   -1 if it is outside any window (protocol error),   */
  767. /*   -2 if either of the argument packet numbers is out of range.  */
  768.  
  769. /* Call with packet number to check (n), lowest packet number in window */
  770. /* (bottom), and number of slots in window (slots).  */
  771.  
  772. int
  773. chkwin(n,bottom,slots) int n, bottom, slots; {
  774.     int top, prev;
  775.  
  776.     debug(F101,"chkwin packet","",n);
  777.     debug(F101,"chkwin winlo","",bottom);
  778.     debug(F101,"chkwin slots","",slots);
  779.  
  780. /* First do the easy and common cases, where the windows are not split. */
  781.  
  782.     if (n < 0 || n > 63 || bottom < 0 || bottom > 63)
  783.       return(-2);
  784.  
  785.     if (n == bottom) return(0);        /* In a perfect world... */
  786.  
  787.     top = bottom + slots;        /* Calculate window top. */
  788.     if (top < 64 && n < top && n >= bottom)
  789.       return(0);            /* In current window. */
  790.  
  791.     prev = bottom - slots;        /* Bottom of previous window. */
  792.     if (prev > -1 && n < bottom && n > prev)
  793.       return(1);            /* In previous. */
  794.  
  795. /* Now consider the case where the current window is split. */
  796.  
  797.     if (top > 63) {            /* Wraparound... */
  798.     top -= 64;            /* Get modulo-64 sequence number */
  799.     if (n < top || n >= bottom) {
  800.         return(0);            /* In current window. */
  801.     } else {            /* Not in current window. */
  802.         if (n < bottom && n >= prev) /* Previous window can't be split. */
  803.           return(1);        /* In previous window. */
  804.         else
  805.           return(-1);        /* Not in previous window. */
  806.     }
  807.     }
  808.  
  809. /* Now the case where current window not split, but previous window is. */
  810.  
  811.     if (prev < 0) {            /* Is previous window split? */
  812.     prev += 64;            /* Yes. */
  813.     if (n < bottom || n >= prev)
  814.       return(1);            /* In previous window. */
  815.     } else {                /* Previous window not split. */
  816.     if (n < bottom && n >= prev)
  817.       return(1);            /* In previous window. */
  818.     }
  819.  
  820. /* It's not in the current window, and not in the previous window... */
  821.  
  822.     return(-1);                /* So it's not in any window. */
  823. }
  824.  
  825. int
  826. dumpsbuf() {                /* Dump send-buffers */
  827. #ifdef DEBUG
  828.     int j, x, z;            /* to debug log. */
  829.  
  830.     if (! deblog) return(0);
  831.     x = zsoutl(ZDFILE,"SEND BUFFERS:");
  832.     if (x < 0) {
  833.     deblog = 0;
  834.     return(0);
  835.     }
  836.     x=zsoutl(ZDFILE,"buffer inuse address length data type seq flag retries");
  837.     if (x < 0) {
  838.     deblog = 0;
  839.     return(0);
  840.     }
  841.     for (j = 0; j < wslots; j++) {
  842.     if (!sbufuse[j])
  843.       continue;
  844.     z = ((unsigned long)(s_pkt[j].bf_adr)) & 0xffff;
  845.  
  846.     sprintf(xbuf,            /* safe (200) */
  847.         "%4d%6d%10d%5d%6d%4c%5d%6d\n",
  848.         j,
  849.         sbufuse[j],
  850.         /* Avoid warnings when addresses are bigger than ints */
  851.         z,
  852.         s_pkt[j].bf_len,
  853.         s_pkt[j].pk_len,
  854.         s_pkt[j].pk_typ,
  855.         s_pkt[j].pk_seq,
  856.         s_pkt[j].pk_rtr
  857.         );
  858.     if (zsout(ZDFILE,xbuf) < 0)  {
  859.         deblog = 0;
  860.         return(0);
  861.     }
  862.     if (s_pkt[j].pk_adr) {
  863.         x = (int)strlen((char *) s_pkt[j].pk_adr);
  864.         if (x)
  865.           sprintf(xbuf,        /* safe (checked) */
  866.               "[%.72s%s]\n",s_pkt[j].pk_adr, x > 72 ? "..." : "");
  867.         else
  868.           sprintf(xbuf,"[(empty string)]\n"); /* safe (200) */
  869.     } else {
  870.         sprintf(xbuf,"[(null pointer)]\n");    /* safe (200) */
  871.     }
  872.     if (zsout(ZDFILE,xbuf) < 0) {
  873.         deblog = 0;
  874.         return(0);
  875.     }
  876.     }
  877.     sprintf(xbuf,"free: %d, winlo: %d\n", sbufnum, winlo); /* safe (200) */
  878.     if (zsout(ZDFILE,xbuf) < 0) {
  879.     deblog = 0;
  880.     return(0);
  881.     }
  882. #endif /* DEBUG */
  883.     return(0);
  884. }
  885. int
  886. dumprbuf() {                /* Dump receive-buffers */
  887. #ifdef DEBUG
  888.     int j, x, z;
  889.     if (! deblog) return(0);
  890.     if (zsoutl(ZDFILE,"RECEIVE BUFFERS:") < 0) {
  891.     deblog = 0;
  892.     return(0);
  893.     }
  894.     x=zsoutl(ZDFILE,"buffer inuse address length data type seq flag retries");
  895.     if (x < 0) {
  896.     deblog = 0;
  897.     return(0);
  898.     }
  899.     for ( j = 0; j < wslots; j++ ) {
  900.     if (!rbufuse[j])
  901.       continue;
  902.     z = ((unsigned long)(r_pkt[j].bf_adr)) & 0xffff;
  903.     sprintf(xbuf,            /* 200, safe */
  904.         "%4d%6d%10d%5d%6d%4c%5d%6d\n",
  905.         j,
  906.         rbufuse[j],
  907.         /* Avoid warnings when addresses are bigger than ints */
  908.         z,
  909.         r_pkt[j].bf_len,
  910.         r_pkt[j].pk_len,
  911.         r_pkt[j].pk_typ,
  912.         r_pkt[j].pk_seq,
  913.         r_pkt[j].pk_rtr
  914.         );
  915.     if (zsout(ZDFILE,xbuf) < 0) {
  916.         deblog = 0;
  917.         return(0);
  918.     }
  919.     x = (int)strlen((char *)r_pkt[j].bf_adr);
  920.     sprintf(xbuf,            /* safe (checked) */
  921.         "[%.72s%s]\n",r_pkt[j].bf_adr, x > 72 ? "..." : "");
  922.     if (zsout(ZDFILE,xbuf) < 0)  {
  923.         deblog = 0;
  924.         return(0);
  925.     }
  926.     }
  927.     sprintf(xbuf,"free: %d, winlo: %d\n", rbufnum, winlo); /* safe (200) */
  928.     if (zsout(ZDFILE,xbuf) < 0)  {
  929.     deblog = 0;
  930.     return(0);
  931.     }
  932. #endif /* DEBUG */
  933.     return(0);
  934. }
  935.  
  936. /*  S A T T R  --  Send an Attribute Packet  */
  937.  
  938. /*
  939.   Sends attribute packet(s) for the current file.  If the info will not
  940.   fit into one packet, it can be called repeatedly until all the fields
  941.   that will fit are sent.
  942.  
  943.   Call with:
  944.     xp == 0 if we're sending a real file (F packet), or:
  945.     xp != 0 for screen data (X packet).
  946.   And:
  947.     flag == 1 for first A packet
  948.     flag == 0 for subsequent A packets.
  949.   Returns:
  950.     1 or greater if an A packet was sent, or:
  951.     0 if an S-packet was not sent because there was no data to send or
  952.       there was no data left that was short enough to send, or:
  953.    -1 on any kind of error.
  954. */
  955.  
  956. /* (don't) #define TSOFORMAT */
  957. /* which was only for making C-Kermit send TSO-Kermit-like A packets */
  958. /* to try to track down a problem somebody reported... */
  959.  
  960. int
  961. sattr(xp, flag) int xp, flag; {        /* Send Attributes */
  962.  
  963.     static int max;            /* Maximum length for Attributes */
  964.     static short done[95];        /* Field-complete array */
  965.     static struct zattr x;        /* File attribute struct */
  966.     static char xdate[24];
  967.  
  968.     extern char * cksysid;
  969.  
  970.     /* Some extra flags are used because the "done" array is sparse */
  971.  
  972.     int i, j, rc, aln, left = 0, numset = 0, xbin = 0; /* Workers */
  973.     int notafile = 0;
  974.     char *tp, c;
  975.  
  976.     notafile = sndarray || pipesend ||
  977. #ifdef PIPESEND
  978.       sndfilter ||
  979. #endif /* PIPESEND */
  980.     calibrate;
  981.  
  982.     debug(F101,"sattr flag","",flag);
  983.     if (!flag)                /* No more attributes to send */
  984.       if (done[xunchar('@')])
  985.     return(0);
  986.  
  987.     /* Initialize Attribute mechanism */
  988.  
  989.     if (flag) {                /* First time here for this file? */
  990.     initattr(&x);            /* Blank out all the fields. */
  991.     for (j = 0; j < 95; j++)    /* Init array of completed fields */
  992.       done[j] = 0;
  993.     max = maxdata();        /* Get maximum data field length */
  994.     if (notafile || xp == 1) {    /* Is it not a real file? */
  995.         extern char * zzndate();
  996.         char * p;
  997.         int i;
  998. #ifdef CALIBRATE
  999.         if (calibrate) {        /* Calibration run... */
  1000.         x.lengthk = calibrate / 1024L; /* We know the length */
  1001.         x.length = calibrate;
  1002.         }
  1003. #endif /* CALIBRATE */
  1004.         x.systemid.val = cksysid;    /* System ID */
  1005.         x.systemid.len = (int)strlen(cksysid);
  1006.         ckstrncpy(xdate,zzndate(),24);
  1007.         xdate[8] = SP;
  1008.         ztime(&p);
  1009.         for (i = 11; i < 19; i++)    /* copy hh:mm:ss */
  1010.           xdate[i - 2] = p[i];    /* to xdate */
  1011.         xdate[17] = NUL;        /* terminate */
  1012.         x.date.val = xdate;
  1013.         x.date.len = 17;
  1014.         debug(F111,"sattr notafile date",x.date.val,x.date.len);
  1015.     } else {            /* Real file */
  1016.         rc = zsattr(&x);        /* Get attributes for this file  */
  1017.         debug(F101,"sattr zsattr","",rc);
  1018.         if (rc < 0)            /* Can't get 'em so don't send 'em */
  1019.           return(0);
  1020.         debug(F101,"sattr init max","",max);
  1021.     }
  1022.     }
  1023.     if (nxtpkt() < 0)            /* Got 'em, get next packet number */
  1024.       return(-1);            /* Bad news if we can't */
  1025.  
  1026.     i = 0;                /* Init data field character number */
  1027.  
  1028.     /* Do each attribute using first-fit method, marking as we go */
  1029.     /* This is rather long and repititious - could be done more cleverly */
  1030.  
  1031.     if (atsido && !done[xunchar(c = '.')]) { /* System type */
  1032.     if (max - i >= x.systemid.len + 2) { /* Enough space ? */
  1033.         data[i++] = c;             /* Yes, add parameter */
  1034.         data[i++] = tochar(x.systemid.len);     /* Add length */
  1035.         for (j = 0; j < x.systemid.len; j++) /* Add data */
  1036.           data[i++] = x.systemid.val[j];
  1037.         numset++;            /* Count that we did at least one */
  1038.         done[xunchar(c)] = 1;    /* Mark this attribute as done */
  1039.     } else                /* No */
  1040.       left++;            /* so mark this one left to do */
  1041.     }
  1042. #ifdef STRATUS
  1043.     if (atcreo && !done[xunchar(c = '$')]) { /* Creator */
  1044.     if (max - i >= x.creator.len + 2) { /* Enough space ? */
  1045.         data[i++] = c;
  1046.         data[i++] = tochar(x.creator.len);
  1047.         for (j = 0; j < x.creator.len; j++)
  1048.           data[i++] = x.creator.val[j];
  1049.         numset++;
  1050.         done[xunchar(c)] = 1;
  1051.     } else
  1052.       left++;
  1053.     }
  1054.     if (atacto && !done[xunchar(c = '%')]) { /* File account */
  1055.     if (max - i >= x.account.len + 2) {
  1056.         data[i++] = c;
  1057.         data[i++] = tochar(x.account.len);
  1058.         for (j = 0; j < x.account.len; j++)
  1059.           data[i++] = x.account.val[j];
  1060.         numset++;
  1061.         done[xunchar(c)] = 1;
  1062.     } else
  1063.       left++;
  1064.     }
  1065.     if (atfrmo && !done[xunchar(c = '/')]) { /* Packet data format */
  1066.     if (max - i >= x.recfm.len + 2) {
  1067.         data[i++] = c;
  1068.         data[i++] = tochar(x.recfm.len); /*  Copy from attr structure */
  1069.         for (j = 0; j < x.recfm.len; j++)
  1070.           data[i++] = x.recfm.val[j];
  1071.         numset++;
  1072.         done[xunchar(c)] = 1;
  1073.     } else
  1074.       left++;
  1075.     }
  1076. #endif /* STRATUS */
  1077.  
  1078.     xbin =                /* Is the transfer in binary mode? */
  1079. #ifdef VMS
  1080.       binary == XYFT_I || binary == XYFT_L || /* IMAGE or LABELED */
  1081.     !strncmp(x.recfm.val,"F",1)    /* or RECFM=Fxxxxxx */
  1082. #else
  1083.       binary                /* User said SET FILE TYPE BINARY  */
  1084. #endif /* VMS */
  1085.     ;
  1086.  
  1087.     if (attypo && !done[xunchar(c = '"')]) { /* File type */
  1088.     if (max - i >= 5) {        /* Max length for this field */
  1089.         data[i++] = c;
  1090.         if (xbin) {            /* Binary */
  1091.         data[i++] = tochar(2);    /*  Two characters */
  1092.         data[i++] = 'B';    /*  B for Binary */
  1093.         data[i++] = '8';    /*  8-bit bytes (note assumption...) */
  1094. #ifdef CK_LABELED
  1095.         if (binary != XYFT_L
  1096. #ifdef VMS
  1097.             && binary != XYFT_I
  1098. #endif /* VMS */
  1099.             )
  1100.           binary = XYFT_B;
  1101. #endif /* CK_LABELED */
  1102.         } else {            /* Text */
  1103. #ifdef TSOFORMAT
  1104.         data[i++] = tochar(1);    /*  One character */
  1105.         data[i++] = 'A';    /*  A = (extended) ASCII with CRLFs */
  1106. #else
  1107.         data[i++] = tochar(3);    /*  Three characters */
  1108.         data[i++] = 'A';    /*  A = (extended) ASCII with CRLFs */
  1109.         data[i++] = 'M';    /*  M for carriage return */
  1110.         data[i++] = 'J';    /*  J for linefeed */
  1111. #endif /* TSOFORMAT */
  1112.  
  1113. #ifdef VMS
  1114.         binary = XYFT_T;    /* We automatically detected text */
  1115. #endif /* VMS */
  1116.         }
  1117.         numset++;
  1118.         done[xunchar(c)] = 1;
  1119.     } else
  1120.       left++;
  1121.     }
  1122.  
  1123. #ifdef TSOFORMAT
  1124.     if (attypo && !xbin && !done[xunchar(c = '/')]) { /* Record format */
  1125.     if (max - i >= 5) {
  1126.         data[i++] = c;
  1127.         data[i++] = tochar(3);    /*  Three characters */
  1128.         data[i++] = 'A';        /*  A = variable with CRLFs */
  1129.         data[i++] = 'M';        /*  M for carriage return */
  1130.         data[i++] = 'J';        /*  J for linefeed */
  1131.     }
  1132.     }
  1133. #endif /* TSOFORMAT */
  1134.  
  1135.     if (attypo && !xbin && !done[xunchar(c = '*')]) { /* Text encoding */
  1136. #ifdef NOCSETS
  1137.     if (max - i >= 3) {
  1138.         data[i++] = c;
  1139.         data[i++] = tochar(1);    /* Length of value is 1 */
  1140.         data[i++] = 'A';        /* A for ASCII */
  1141.         numset++;
  1142.         done[xunchar(c)] = 1;
  1143.     } else
  1144.       left++;
  1145. #else
  1146.     if (tcharset == TC_TRANSP || !xfrxla) {    /* Transfer character set */
  1147.         if (max - i >= 3) {
  1148.         data[i++] = c;        /* Encoding */
  1149.         data[i++] = tochar(1);    /* Length of value is 1 */
  1150.         data[i++] = 'A';    /* A for ASCII (i.e. text) */
  1151.         numset++;
  1152.         done[xunchar(c)] = 1;
  1153.         } else
  1154.           left++;
  1155.     } else {
  1156.         tp = tcsinfo[tcharset].designator;
  1157.         if (!tp) tp = "";
  1158.         aln = strlen(tp);
  1159.         if (aln > 0) {
  1160.         if (max - i >= aln + 2) {
  1161.             data[i++] = c;    /* Encoding */
  1162.             data[i++] = tochar(aln+1); /* Length of designator. */
  1163.             data[i++] = 'C'; /* Text in specified charset. */
  1164.             for (j = 0; j < aln; j++) /* Copy designator */
  1165.               data[i++] = *tp++; /*  Example: *&I6/100 */
  1166.             numset++;
  1167.             done[xunchar(c)] = 1;
  1168.         } else
  1169.           left++;
  1170.         } else
  1171.           done[xunchar(c)] = 1;
  1172.     }
  1173. #endif /* NOCSETS */
  1174.     }
  1175.     if (atdato && !done[xunchar(c = '#')] && /* Creation date, if any */
  1176.     (aln = x.date.len) > 0) {
  1177.     if (max - i >= aln + 2) {
  1178.         data[i++] = c;
  1179.         data[i++] = tochar(aln);
  1180.         for (j = 0; j < aln; j++)
  1181.           data[i++] = x.date.val[j];
  1182.         numset++;
  1183.         done[xunchar(c)] = 1;
  1184.     } else
  1185.       left++;
  1186.     }
  1187.     /* File length in K */
  1188.     if (atleno && !done[xunchar(c = '!')] && x.lengthk > (CK_OFF_T)-1) {
  1189. #ifdef COMMENT
  1190.     sprintf((char *) &data[i+2],"%ld",x.lengthk); /* safe */
  1191. #else
  1192.     ckstrncpy((char *)&data[i+2],ckfstoa(x.lengthk),32);
  1193. #endif    /* COMMENT */
  1194.     aln = (int)strlen((char *)(data+i+2));
  1195.     if (max - i >= aln + 2) {
  1196.         data[i] = c;
  1197.         data[i+1] = tochar(aln);
  1198.         i += aln + 2;
  1199.         numset++;
  1200.         done[xunchar(c)] = 1;
  1201.     } else {
  1202.         data[i] = NUL;
  1203.         left++;
  1204.     }
  1205.     }
  1206.     /* File length in bytes */
  1207.     if (atleno && !done[xunchar(c = '1')] && x.length > (CK_OFF_T)-1) {
  1208. #ifdef COMMENT
  1209.     sprintf((char *) &data[i+2],"%ld",x.length); /* safe */
  1210. #else
  1211.     ckstrncpy((char *)&data[i+2],ckfstoa(x.length),32);
  1212. #endif    /* COMMENT */
  1213.     aln = (int)strlen((char *)(data+i+2));
  1214.     if (max - i >= aln + 2) {
  1215.         data[i] = c;
  1216.         data[i+1] = tochar(aln);
  1217.         i += aln + 2;
  1218.         numset++;
  1219.         done[xunchar(c)] = 1;
  1220.     } else {
  1221.         data[i] = NUL;
  1222.         left++;
  1223.     }
  1224.     }
  1225. #ifdef CK_PERMS
  1226.     if (atlpro && !done[xunchar(c = ',')] && /* Local protection */
  1227.     (aln = x.lprotect.len) > 0 && !notafile && xp == 0) {
  1228.     if (max - i >= aln + 2) {
  1229.         data[i++] = c;
  1230.         data[i++] = tochar(aln);
  1231.         for (j = 0; j < aln; j++)
  1232.           data[i++] = x.lprotect.val[j];
  1233.         numset++;
  1234.         done[xunchar(c)] = 1;
  1235.     } else
  1236.       left++;
  1237.     }
  1238.     if (atgpro && !done[xunchar(c = '-')] && /* Generic protection */
  1239.     (aln = x.gprotect.len) > 0 && !notafile && xp == 0) {
  1240.     if (max - i >= aln + 2) {
  1241.         data[i++] = c;
  1242.         data[i++] = tochar(aln);
  1243.         for (j = 0; j < aln; j++)
  1244.           data[i++] = x.gprotect.val[j];
  1245.         numset++;
  1246.         done[xunchar(c)] = 1;
  1247.     } else
  1248.       left++;
  1249.     }
  1250. #endif /* CK_PERMS */
  1251.     if (atblko && fblksiz && !done[xunchar(c = '(')] &&
  1252.     !notafile && xp == 0) {    /* Blocksize */
  1253.     sprintf((char *) &data[i+2],"%d",fblksiz); /* safe */
  1254.     aln = (int)strlen((char *)(data+i+2));
  1255.     if (max - i >= aln + 2) {
  1256.         data[i] = c;
  1257.         data[i+1] = tochar(aln);
  1258.         i += aln + 2;
  1259.         numset++;
  1260.         done[xunchar(c)] = 1;
  1261.     } else {
  1262.         data[i] = NUL;
  1263.         left++;
  1264.     }
  1265.     }
  1266. #ifndef NOFRILLS
  1267.     if ((rprintf || rmailf) && atdiso && /* MAIL, or REMOTE PRINT?  */
  1268.     !done[xunchar(c = '+')]) {
  1269.     aln = (int) strlen(optbuf) + 1;    /* Options, if any */
  1270.     if (max - i >= aln + 2) {
  1271.         data[i++] = c;        /* Disposition */
  1272.         data[i++] = tochar(aln);    /* Options, if any */
  1273.         if (rprintf)
  1274.           data[i++] = 'P';        /* P for Print */
  1275.         else
  1276.           data[i++] = 'M';        /* M for Mail */
  1277.         for (j = 0; optbuf[j]; j++)    /* Copy any options */
  1278.           data[i++] = optbuf[j];
  1279.         numset++;
  1280.         done[xunchar(c)] = 1;
  1281.     } else {
  1282.         data[i] = NUL;
  1283.         left++;
  1284.     }
  1285.     }
  1286. #endif /* NOFRILLS */
  1287. #ifdef CK_RESEND
  1288.     if (sendmode == SM_RESEND && !done[xunchar(c = '+')]) {
  1289.     if (max - i >= 3) {
  1290.         data[i++] = c;        /* Disposition */
  1291.         data[i++] = tochar(1);
  1292.         data[i++] = 'R';        /* is RESEND */
  1293.         numset++;
  1294.         done[xunchar(c)] = 1;
  1295.     } else
  1296.       left++;
  1297.     }
  1298. #endif /* CK_RESEND */
  1299.  
  1300.     /* End of Attributes -- to be sent only after sending all others */
  1301.  
  1302.     debug(F111,"sattr","@",i);
  1303.     debug(F101,"sattr numset","",numset);
  1304.     debug(F101,"sattr left","",left);
  1305.  
  1306.     if ((left == 0 || numset == 0) && !done[xunchar(c = '@')]) {
  1307.     if (max - i >= 3) {
  1308.         data[i++] = c;        /* End of Attributes */
  1309.         data[i++] = SP;        /* Length 0 */
  1310.         data[i] = NUL;        /* Make sure it's null-terminated */
  1311.         numset++;
  1312.         done[xunchar(c)] = 1;
  1313.     }
  1314.     }
  1315.  
  1316.     /* Finished - send the packet off if we have anything in it */
  1317.  
  1318.     if (numset) {
  1319.     data[i] = NUL;            /* Terminate last good field */
  1320.     debug(F111,"sattr sending",data,left);
  1321.     aln = (int)strlen((char *)data); /* Get overall length of attributes */
  1322.     return(spack('A',pktnum,aln,data)); /* Send it */
  1323.     } else
  1324.       return(0);
  1325. }
  1326.  
  1327. static char *refused = "";
  1328.  
  1329. static char *reason[] = {
  1330.     "size", "type", "date", "creator", "account", "area", "password",
  1331.     "blocksize", "access", "encoding", "disposition", "protection",
  1332.     "protection", "origin", "format",
  1333.     "sys-dependent",            /* 0 */
  1334.     "size",                /* 1 */
  1335.     "2",                /* 2 */
  1336.     "3",                /* 3 */
  1337.     "4",                /* 4 */
  1338.     "5",                /* 5 */
  1339.     "6",                /* 6 */
  1340.     "7",                /* 7 */
  1341.     "8",                /* 8 */
  1342.     "9",                /* 9 */
  1343.     ":",                /* : */
  1344.     ";",                /* ; */
  1345.     "<",                /* < */
  1346.     "=",                /* = */
  1347.     ">",                /* > */
  1348.     "name",                /* ? */
  1349.     "@"
  1350. };
  1351. static int nreason = sizeof(reason) / sizeof(char *);
  1352. int rejection = -1;
  1353.  
  1354. char *
  1355. getreason(s) char *s; {            /* Decode attribute refusal reason */
  1356.     char c, *p;
  1357.     if (rejection == 1)            /* Kludge for SET FIL COLL DISCARD */
  1358.       return("name");            /* when other Kermit doesn't... */
  1359.     p = s;
  1360.     if (*p++ != 'N') return("");    /* Should start with N */
  1361.     else if ((c = *p) > SP) {        /* get reason, */
  1362.     rejection = c;            /* remember it, */
  1363.     c -= '!';            /* get offset */
  1364.     p = ((unsigned int) ((CHAR) c) <= (unsigned int) nreason) ?
  1365.       reason[c] :
  1366.         "unknown";
  1367.     }
  1368.     return(p);
  1369. }
  1370.  
  1371. int
  1372. rsattr(s) CHAR *s; {            /* Read response to attribute packet */
  1373.     debug(F111,"rsattr",s,*s);
  1374.     if (*s == 'N') {            /* If it's 'N' followed by anything, */
  1375.     refused = getreason((char *)s);    /* they are refusing, get reason. */
  1376.     debug(F110,"rsattr refused",refused,0);
  1377.     tlog(F110," refused:",refused,0L);
  1378.     return(-1);
  1379.     }
  1380. #ifdef CK_RESEND
  1381.     if (sendmode == SM_RESEND && *s == '1') { /* RESEND length */
  1382.     int n; CK_OFF_T z; CHAR *p;
  1383.     p = s + 1;
  1384.     n = xunchar(*p++);
  1385.     debug(F101,"rsattr RESEND n","",n);
  1386.     z = (CK_OFF_T)0;
  1387.     while (n-- > 0)            /* We assume the format is good. */
  1388.       z = (CK_OFF_T)10 * z + (CK_OFF_T)(*p++ - '0');
  1389.     debug(F101,"rsattr RESEND z","",z);
  1390.     if (z > (CK_OFF_T)0) sendstart = z;
  1391.     debug(F101,"rsattr RESEND sendstart","",sendstart);
  1392.     if (sendstart > (CK_OFF_T)0)
  1393.       if (zfseek(sendstart) < 0)    /* Input file is already open. */
  1394.         return(0);
  1395. #ifdef CK_CURSES
  1396.     if (fdispla == XYFD_C)
  1397.       xxscreen(SCR_FS,0,fsize,"");    /* Refresh file transfer display */
  1398. #endif /* CK_CURSES */
  1399.     }
  1400. #endif /* CK_RESEND */
  1401.     refused = "";
  1402.     return(0);
  1403. }
  1404.  
  1405. /*
  1406.   Get attributes from incoming A packet.  Returns:
  1407.    0 on success, file is to be accepted
  1408.   -1 on failure, file is to be refused
  1409. */
  1410. int
  1411. gattr(s, yy) CHAR *s; struct zattr *yy; { /* Read incoming attribute packet */
  1412.     char c, d;
  1413.     char *ff;
  1414.     int aln, i, overflow = 0;
  1415.  
  1416. #ifndef NOCSETS
  1417.     extern int r_cset, axcset[];
  1418. #endif /* NOCSETS */
  1419.  
  1420. #define ABUFL 40            /* Temporary buffer for conversions */
  1421.     char abuf[ABUFL+1];
  1422. #define RFBUFL 10            /* Record-format buffer */
  1423.     static char rfbuf[RFBUFL+1];
  1424. #define FTBUFL 10            /* File type buffer */
  1425.     static char ftbuf[FTBUFL+1];
  1426. #define DTBUFL 40            /* File creation date */
  1427.     static char dtbuf[DTBUFL+1];
  1428. #define TSBUFL 10            /* Transfer syntax */
  1429.     static char tsbuf[TSBUFL+1];
  1430. #define IDBUFL 10            /* System ID */
  1431.     static char idbuf[IDBUFL+1];
  1432. #ifndef DYNAMIC
  1433. #define DSBUFL 100            /* Disposition */
  1434.     static char dsbuf[DSBUFL+1];
  1435. #define SPBUFL 512            /* System-dependent parameters */
  1436.     static char spbuf[SPBUFL+1];
  1437. #else
  1438. #define DSBUFL 100            /* Disposition */
  1439.     static char *dsbuf = NULL;
  1440. #define SPBUFL 512            /* System-dependent parameters */
  1441.     static char *spbuf = NULL;
  1442. #endif /* DYNAMIC */
  1443. #define RPBUFL 20            /* Attribute reply */
  1444.     static char rpbuf[RPBUFL+1];
  1445.  
  1446. #ifdef CK_PERMS
  1447.     static char lprmbuf[CK_PERMLEN+1];
  1448.     static char gprmbuf[2];
  1449. #endif /* CK_PERMS */
  1450.  
  1451.     char *rp;                /* Pointer to reply buffer */
  1452.     int retcode;            /* Return code */
  1453.  
  1454.     d = SP;                /* Initialize disposition */
  1455.     ff = filnam;            /* Filename returned by rcvfil */
  1456.     if (fncact == XYFX_R && ofn1x && ofn1[0]) /* But watch out for FC=RENAME */
  1457.       ff = ofn1;            /* because we haven't renamed it yet */
  1458.  
  1459. /* Fill in the attributes we have received */
  1460.  
  1461.     rp = rpbuf;                /* Initialize reply buffer */
  1462.     *rp++ = 'N';            /* for negative reply. */
  1463.     *rp = NUL;
  1464.     retcode = 0;            /* Initialize return code. */
  1465.  
  1466.     if (dest == DEST_P) {        /* SET DESTINATION PRINTER */
  1467. #ifdef DYNAMIC
  1468.     if (!dsbuf)
  1469.       if ((dsbuf = malloc(DSBUFL+1)) == NULL)
  1470.         fatal("gtattr: no memory for dsbuf");
  1471. #endif /* DYNAMIC */
  1472.     dsbuf[0] = 'P';
  1473.     dsbuf[1] = '\0';
  1474.     yy->disp.val = dsbuf;
  1475.     yy->disp.len = 1;
  1476.     }
  1477.     while (c = *s++) {            /* Get attribute tag */
  1478.     aln = xunchar(*s++);        /* Length of attribute string */
  1479.     switch (c) {
  1480. #ifdef COMMENT                /* This case combined with '1' below */
  1481.       case '!':            /* File length in K */
  1482.         for (i = 0; (i < aln) && (i < ABUFL); i++) /* Copy it */
  1483.           abuf[i] = *s++;
  1484.         abuf[i] = '\0';        /* Terminate with null */
  1485.         if (i < aln) s += (aln - i); /* If field was too long for buffer */
  1486.         yy->lengthk = ckatofs(abuf); /* Convert to number */
  1487.         break;
  1488. #endif    /* COMMENT */
  1489.  
  1490.       case '/':            /* Record format */
  1491.         rfbuf[1] = NUL;
  1492.         rfbuf[2] = NUL;
  1493.         for (i = 0; (i < aln) && (i < RFBUFL); i++) /* Copy it */
  1494.           rfbuf[i] = *s++;
  1495.         rfbuf[i] = NUL;        /* Terminate with null */
  1496.         yy->recfm.val = rfbuf;    /* Pointer to string */
  1497.         yy->recfm.len = i;        /* Length of string */
  1498.         if ((rfbuf[0] != 'A') ||
  1499.         (rfbuf[1] && rfbuf[1] != 'M') ||
  1500.         (rfbuf[2] && rfbuf[2] != 'J')) {
  1501.         debug(F110,"gattr bad recfm",rfbuf,0);
  1502.         *rp++ = c;
  1503.         retcode = -1;
  1504.         }
  1505.         break;
  1506.  
  1507.       case '"':            /* File type (text, binary, ...) */
  1508.         for (i = 0; (i < aln) && (i < FTBUFL); i++)
  1509.           ftbuf[i] = *s++;        /* Copy it into a static string */
  1510.         ftbuf[i] = '\0';
  1511.         if (i < aln) s += (aln - i);
  1512.         /* TYPE attribute is enabled? */
  1513.         if (attypi) {
  1514.         yy->type.val = ftbuf;    /* Pointer to string */
  1515.         yy->type.len = i;    /* Length of string */
  1516.         debug(F111,"gattr file type", ftbuf, i);
  1517.         debug(F101,"gattr binary 1","",binary);
  1518.         /* Unknown type? */
  1519.         if ((*ftbuf != 'A' && *ftbuf != 'B' && *ftbuf != 'I')
  1520. #ifdef CK_LABELED
  1521. /* ... Or our FILE TYPE is LABELED and the incoming file is text... */
  1522.             || (binary == XYFT_L && *ftbuf == 'A' && !xflg)
  1523. #endif /* CK_LABELED */
  1524.             ) {
  1525.             retcode = -1;    /* Reject the file */
  1526.             *rp++ = c;
  1527.             if (!opnerr) tlog(F100," refused: type","",0);
  1528.             break;
  1529.         }
  1530. /*
  1531.   The following code moved here from opena() so we set binary mode
  1532.   as soon as requested by the attribute packet.  That way when the first
  1533.   data packet comes, the mode of transfer can be displayed correctly
  1534.   before opena() is called.
  1535. */
  1536.         if (yy->type.val[0] == 'A') { /* Check received attributes. */
  1537. #ifdef VMS
  1538.             if (binary != XYFT_I) /* VMS IMAGE overrides this */
  1539. #endif /* VMS */
  1540.               binary = XYFT_T;    /* Set current type to Text. */
  1541.             debug(F101,"gattr binary 2","",binary);
  1542.         } else if (yy->type.val[0] == 'B') {
  1543. #ifdef CK_LABELED
  1544.             if (binary != XYFT_L
  1545. #ifdef VMS
  1546.             && binary != XYFT_U /* VMS special case */
  1547. #endif /* VMS */
  1548.             )
  1549. #endif /* CK_LABELED */
  1550. #ifdef MAC
  1551.             if (binary != XYFT_M) /* If not MacBinary... */
  1552. #endif /* MAC */
  1553.               binary = XYFT_B;
  1554.             debug(F101,"gattr binary 3","",binary);
  1555.         }
  1556.         }
  1557.         break;
  1558.  
  1559.       case '#':            /* File creation date */
  1560.         for (i = 0; (i < aln) && (i < DTBUFL); i++)
  1561.           dtbuf[i] = *s++;        /* Copy it into a static string */
  1562.         if (i < aln) s += (aln - i);
  1563.         dtbuf[i] = '\0';
  1564.         if (atdati && !xflg) {    /* Real file and dates enabled */
  1565.         yy->date.val = dtbuf;    /* Pointer to string */
  1566.         yy->date.len = i;    /* Length of string */
  1567.         if (fncact == XYFX_U) {    /* Receiving in update mode? */
  1568.             if (zstime(ff,yy,1) > 0) { /* Compare dates */
  1569.             *rp++ = c;    /* Discard if older, reason = date. */
  1570.             if (!opnerr) tlog(F100," refused: date","",0);
  1571.             retcode = -1;    /* Rejection notice. */
  1572.             }
  1573.         }
  1574.         }
  1575.         break;
  1576.  
  1577.       case '(':            /* File Block Size */
  1578.         for (i = 0; (i < aln) && (i < ABUFL); i++) /* Copy it */
  1579.           abuf[i] = *s++;
  1580.         abuf[i] = '\0';        /* Terminate with null */
  1581.         if (i < aln) s += (aln - i);
  1582.         if (atblki)
  1583.           yy->blksize = atol(abuf); /* Convert to number */
  1584.         break;
  1585.  
  1586.       case '*':            /* Encoding (transfer syntax) */
  1587.         for (i = 0; (i < aln) && (i < TSBUFL); i++)
  1588.           tsbuf[i] = *s++;        /* Copy it into a static string */
  1589.         if (i < aln) s += (aln - i);
  1590.         tsbuf[i] = '\0';
  1591. #ifndef NOCSETS
  1592.         xlatype = XLA_NONE;        /* Assume no translation */
  1593. #endif /* NOCSETS */
  1594.         if (atenci) {
  1595.         char * ss;
  1596.         yy->encoding.val = tsbuf; /* Pointer to string */
  1597.         yy->encoding.len = i;    /* Length of string */
  1598.         debug(F101,"gattr encoding",tsbuf,i);
  1599.         ss = tsbuf+1;
  1600.         switch (*tsbuf) {
  1601. #ifndef NOCSETS
  1602.           case 'A':          /* Normal, nothing special */
  1603.             tcharset = TC_TRANSP; /* Transparent chars untranslated */
  1604.             debug(F110,"gattr sets tcharset TC_TRANSP","A",0);
  1605.             break;
  1606.           case 'C':          /* Specified character set */
  1607.             if (!xfrxla) {      /* But translation disabled */
  1608.             tcharset = TC_TRANSP;
  1609.             debug(F110,"gattr sets tcharset TC_TRANSP","C",0);
  1610.             break;
  1611.             }
  1612. #ifdef UNICODE
  1613.             if (!strcmp("I196",ss)) /* Treat I196 (UTF-8 no level) */
  1614.               ss = "I190";        /* as I190 (UTF-8 Level 1) */
  1615. #endif /* UNICODE */
  1616.             if (!strcmp("I6/204",ss)) /* Treat "Latin-1 + Euro" */
  1617.               ss = "I6/100";          /* as I6/100 (regular Latin-1) */
  1618.             for (i = 0; i < ntcsets; i++) {
  1619.             if (!strcmp(tcsinfo[i].designator,ss))
  1620.               break;
  1621.             }
  1622.             debug(F101,"gattr xfer charset lookup","",i);
  1623.             if (i == ntcsets) {    /* If unknown character set, */
  1624.             debug(F110,"gattr: xfer charset unknown",ss,0);
  1625.             if (!unkcs) {    /* and SET UNKNOWN DISCARD, */
  1626.                 retcode = -1; /* reject the file. */
  1627.                 *rp++ = c;
  1628.                 if (!opnerr)
  1629.                   tlog(F100," refused: character set","",0);
  1630.             }
  1631.             } else {
  1632.             tcharset = tcsinfo[i].code; /* it's known, use it */
  1633.             debug(F101,"gattr switch tcharset","",tcharset);
  1634.             debug(F101,"gattr fcharset","",fcharset);
  1635.             if (r_cset == XMODE_A) { /* Automatic switching? */
  1636.                 if (tcharset > -1 && tcharset <= MAXTCSETS) {
  1637.                 int x;
  1638.                 x = axcset[tcharset];
  1639.                 if (x > 0 && x <= MAXFCSETS) {
  1640.                     fcharset = x;
  1641.                     debug(F101,"gattr switch fcharset","",x);
  1642.                 }
  1643.                 }
  1644.             }
  1645.             /* Set up translation type and function */
  1646.             setxlatype(tcharset,fcharset);
  1647.             }
  1648.         break;
  1649. #endif /* NOCSETS */
  1650.           default:            /* Something else. */
  1651.         debug(F110,"gattr unk encoding attribute",tsbuf,0);
  1652.         if (!unkcs) {        /* If SET UNK DISC */
  1653.             retcode = -1;
  1654.             *rp++ = c;
  1655.             if (!opnerr) tlog(F100," refused: encoding","",0);
  1656.         }
  1657.         break;
  1658.         }
  1659.         }
  1660.         break;
  1661.  
  1662.       case '+':            /* Disposition */
  1663. #ifdef DYNAMIC
  1664.         if (!dsbuf)
  1665.           if ((dsbuf = malloc(DSBUFL+1)) == NULL)
  1666.         fatal("gtattr: no memory for dsbuf");
  1667. #endif /* DYNAMIC */
  1668.         for (i = 0; (i < aln) && (i < DSBUFL); i++)
  1669.           dsbuf[i] = *s++;        /* Copy it into a separate string */
  1670.         dsbuf[i] = '\0';
  1671.         if (i < aln) s += (aln - i);
  1672.         rs_len = (CK_OFF_T)0;
  1673.         if (atdisi) {        /* We are doing this attribute */
  1674.         /* Copy it into the attribute structure */
  1675.         yy->disp.val = dsbuf;    /* Pointer to string */
  1676.         yy->disp.len = i;    /* Length of string */
  1677.         d = *dsbuf;
  1678. #ifndef NODISPO
  1679. /*
  1680.   Define NODISPO to disable receipt of mail or print files and of RESEND.
  1681. */
  1682.         if (
  1683. #ifndef datageneral            /* MAIL supported only for */
  1684. #ifndef OS2                /* UNIX, VMS, and OS-9 */
  1685. #ifndef MAC
  1686. #ifndef GEMDOS
  1687. #ifndef AMIGA
  1688.             d != 'M' &&        /* MAIL */
  1689. #endif /* AMIGA */
  1690. #endif /* GEMDOS */
  1691. #endif /* MAC */
  1692. #endif /* OS/2 */
  1693. #endif /* datageneral */
  1694. #ifdef CK_RESEND
  1695.             d != 'R' &&        /* RESEND */
  1696. #endif /* CK_RESEND */
  1697.             d != 'P') {        /* PRINT */
  1698.             retcode = -1;    /* Unknown/unsupported disposition */
  1699.             *rp++ = c;
  1700.             if (!opnerr) tlog(F101," refused: bad disposition","",d);
  1701.         }
  1702.         dispos = d;
  1703.         debug(F000,"gattr dispos","",dispos);
  1704.         switch (d) {
  1705. #ifndef NOFRILLS
  1706.           case 'M':
  1707.             if (!en_mai) {
  1708.             retcode = -1;
  1709.             *rp++ = c;
  1710.             if (!opnerr) tlog(F100," refused: mail disabled","",0);
  1711.             dispos = 0;
  1712.             }
  1713.             break;
  1714. #endif /* NOFRILLS */
  1715.           case 'P':
  1716.             if (!en_pri) {
  1717.             retcode = -1;
  1718.             *rp++ = c;
  1719.             if (!opnerr)
  1720.               tlog(F100," refused: print disabled","",0);
  1721.             dispos = 0;
  1722.             }
  1723.             break;
  1724.  
  1725.           case 'R':
  1726.             dispos = 0;
  1727. #ifdef CK_RESEND
  1728.             rs_len = zgetfs(ff); /* Get length of file */
  1729.             debug(F111,"gattr RESEND",ff,rs_len);
  1730. #ifdef VMS
  1731.             rs_len &= (long) -512; /* Ensure block boundary if VMS */
  1732.             rs_len -= 512;      /* In case last block not complete */
  1733.             debug(F111,"gattr rs_len",ff,rs_len);
  1734. #endif /* VMS */
  1735. #ifdef COMMENT
  1736.             if (rs_len < 0L)    /* Local file doesn't exist */
  1737.               rs_len = 0L;
  1738. #endif /* COMMENT */
  1739. /*
  1740.   Another possibility here (or later, really) would be to check if the two
  1741.   file lengths are the same, and if so, keep the prevailing collision action
  1742.   as is (note: rs_len == length of existing file; yy->length == fsize ==
  1743.   length of incoming file).  This could be complicated, though, since
  1744.   (a) we might not have received the length attribute yet, and in fact it
  1745.   might even be in a subsequent A-packet, yet (b) we have to accept or reject
  1746.   the Recover attribute now.  So better to leave as-is.  Anyway, it's probably
  1747.   more useful this way.
  1748. */
  1749.             if (rs_len > (CK_OFF_T)0) {
  1750.             fncsav = fncact; /* Save collision action */
  1751.             fncact = XYFX_A; /* Switch to APPEND */
  1752.             }
  1753. #else
  1754.             retcode = -1;    /* This shouldn't happen */
  1755.             *rp++ = c;        /* 'cause it wasn't negotiated. */
  1756.             if (!opnerr) tlog(F100," refused: resend","",0);
  1757. #endif /* CK_RESEND */
  1758.         }
  1759. #else  /* NODISPO */
  1760.         retcode = -1;
  1761.         *rp++ = c;
  1762.         if (!opnerr) tlog(F100," refused: NODISPO","",0);
  1763. #endif /* NODISPO */
  1764.         }
  1765.         break;
  1766.  
  1767.       case '.':            /* Sender's system ID */
  1768.         for (i = 0; (i < aln) && (i < IDBUFL); i++)
  1769.           idbuf[i] = *s++;        /* Copy it into a static string */
  1770.         idbuf[i] = '\0';
  1771.         if (i < aln) s += (aln - i);
  1772.         if (atsidi) {
  1773.         yy->systemid.val = idbuf; /* Pointer to string */
  1774.         yy->systemid.len = i;    /* Length of string */
  1775.         }
  1776.         break;
  1777.  
  1778.       case '0':            /* System-dependent parameters */
  1779. #ifdef DYNAMIC
  1780.         if (!spbuf && !(spbuf = malloc(SPBUFL)))
  1781.         fatal("gattr: no memory for spbuf");
  1782. #endif /* DYNAMIC */
  1783.         for (i = 0; (i < aln) && (i < SPBUFL); i++)
  1784.           spbuf[i] = *s++;        /* Copy it into a static string */
  1785.         spbuf[i] = '\0';
  1786.         if (i < aln) s += (aln - i);
  1787.         if (atsysi) {
  1788.         yy->sysparam.val = spbuf; /* Pointer to string */
  1789.         yy->sysparam.len = i;    /* Length of string */
  1790.         }
  1791.         break;
  1792.  
  1793.       case '!':            /* File length in K */
  1794.       case '1': {            /* File length in bytes */
  1795.           char * l2;
  1796.           CK_OFF_T xlen;
  1797.           for (i = 0; (i < aln) && (i < ABUFL); i++) /* Copy it */
  1798.         abuf[i] = *s++;
  1799.           abuf[i] = '\0';        /* Terminate with null */
  1800.           if (i < aln) s += (aln - i);
  1801.           if (rdigits(abuf)) {    /* Make sure string is all digits */
  1802.           xlen = ckatofs(abuf);    /* Convert to number */
  1803.           l2 = ckfstoa(xlen);    /* Convert number back to string */
  1804.           if (c == '1')
  1805.             debug(F111,"gattr length",abuf,xlen);
  1806.           else
  1807.             debug(F111,"gattr lengthk",abuf,xlen);
  1808.           if (ckstrcmp(abuf,l2,-1,1)) { /* This is how we check... */
  1809.               xlen = (CK_OFF_T)-2; /* -2 = unk, possibly too long */
  1810.               overflow++;
  1811.               debug(F111,"gattr overflow",
  1812.                 (c == '1') ? "length" : "lengthk",
  1813.                 xlen);
  1814.           }
  1815.           if (c == '1') {
  1816.               yy->length = xlen;
  1817.               debug(F101,"gattr length","",xlen);
  1818.           } else {
  1819.               yy->lengthk = xlen;
  1820.               debug(F101,"gattr lengthk","",xlen);
  1821.           }
  1822.           }
  1823.           /* If the length field is not numeric accept the file */
  1824.           /* anyway but with an unknown length */
  1825.           break;
  1826.       }
  1827.  
  1828. #ifdef CK_PERMS
  1829.       case ',':            /* System-dependent protection code */
  1830.         for (i = 0; (i < aln) && (i < CK_PERMLEN); i++)
  1831.           lprmbuf[i] = *s++;    /* Just copy it - decode later */
  1832.         lprmbuf[i] = '\0';        /* Terminate with null */
  1833.         if (i < aln) s += (aln - i);
  1834.         if (atlpri) {
  1835.         yy->lprotect.val = (char *)lprmbuf;
  1836.         yy->lprotect.len = i;
  1837.         } else
  1838.           lprmbuf[0] = NUL;
  1839.         break;
  1840.  
  1841.       case '-':            /* Generic "world" protection code */
  1842.         gprmbuf[0] = NUL;        /* Just 1 byte by definition */
  1843.         for (i = 0; i < aln; i++)    /* But allow for more... */
  1844.           if (i == 0) gprmbuf[0] = *s++;
  1845.         gprmbuf[1] = NUL;
  1846.         if (atgpri) {
  1847.         yy->gprotect.val = (char *)gprmbuf;
  1848.         yy->gprotect.len = gprmbuf[0] ? 1 : 0;
  1849.         } else
  1850.           gprmbuf[0] = NUL;
  1851.         break;
  1852. #endif /* CK_PERMS */
  1853.  
  1854.       default:            /* Unknown attribute */
  1855.         s += aln;            /* Just skip past it */
  1856.         break;
  1857.     }
  1858.     }
  1859.  
  1860.     /* Check space now, because we also need to know the file type */
  1861.     /* in case zchkspa() differentiates text and binary (VMS version does) */
  1862.  
  1863.     if (atleni && !calibrate) {        /* Length attribute enabled? */
  1864.     if (yy->length > (CK_OFF_T)-1) { /* Length-in-bytes attribute rec'd? */
  1865.         if (!zchkspa(ff,(yy->length))) { /* Check space */
  1866.         retcode = -1;             /* Not enuf */
  1867.         *rp++ = '1';
  1868.         if (!opnerr) tlog(F100," refused: length bytes","",0);
  1869.         }
  1870.     } else if (yy->lengthk > (CK_OFF_T)-1) { /* Length in K received? */
  1871.         long xlen;
  1872.         xlen = yy->lengthk * 1024;
  1873.         if (!zchkspa(ff,xlen)) {
  1874.         retcode = -1;        /* Check space */
  1875.         *rp++ = '!';
  1876.         if (!opnerr) tlog(F100," refused: length K","",0);
  1877.         }
  1878.     }
  1879.     }
  1880.     if (retcode > -1L) {        /* Remember the file size */
  1881.     if (yy->length > (CK_OFF_T)-1) {
  1882.         fsize = yy->length;
  1883.     } else if (yy->lengthk > (CK_OFF_T)-1 && !overflow) {
  1884.         fsize = yy->lengthk * 1024L;
  1885.     } else fsize = yy->length;    /* (e.g. -2L) */
  1886.     }
  1887.  
  1888. #ifdef DEBUG
  1889.     if (deblog) {
  1890. #ifdef COMMENT
  1891.     sprintf(abuf,"%ld",fsize);    /* safe */
  1892. #else
  1893.     ckstrncpy(abuf,ckfstoa(fsize),ABUFL);
  1894. #endif    /* COMMENT */
  1895. debug(F110,"gattr fsize",abuf,0);
  1896.     }
  1897. #endif /* DEBUG */
  1898.  
  1899.     if (retcode == 0) rp = rpbuf;    /* Null reply string if accepted */
  1900.     *rp = '\0';                /* End of reply string */
  1901.  
  1902. #ifdef CK_RESEND
  1903.     if (d == 'R') {            /* Receiving a RESEND? */
  1904.     debug(F101,"gattr RESEND","",retcode);
  1905.     /* We ignore retcodes because this overrides */
  1906.     if (binary != XYFT_B) {        /* Reject if not binary */
  1907.         retcode = -1;        /* in case type field came */
  1908.         ckstrncpy(rpbuf,"N+",RPBUFL); /* after the disposition field */
  1909.         debug(F111,"gattr RESEND not binary",rpbuf,binary);
  1910.     } else {            /* Binary mode */
  1911.         retcode = 0;        /* Accept the file */
  1912.         discard = 0;        /* If SET FILE COLLISION DISCARD */
  1913. #ifdef COMMENT
  1914.         sprintf(rpbuf+2,"%ld",rs_len); /* Reply with length of file */
  1915. #else
  1916.         ckstrncpy(rpbuf+2,ckfstoa(rs_len),RPBUFL-2);
  1917. #endif    /* COMMENT */
  1918.         rpbuf[0] = '1';        /* '1' means Length in Bytes */
  1919.         rpbuf[1] = tochar((int)strlen(rpbuf+2)); /* Length of length */
  1920.         debug(F111,"gattr RESEND OK",rpbuf,retcode);
  1921.     }
  1922.     }
  1923. #endif /* CK_RESEND */
  1924.     if (retcode == 0 && discard != 0) {    /* Do we still have a discard flag? */
  1925.     ckstrncpy(rpbuf,"N?",RPBUFL);    /* Yes, must be filename collision */
  1926.     retcode = -1;            /* "?" = name (reply-only code) */
  1927.     }
  1928.     yy->reply.val = rpbuf;        /* Add it to attribute structure */
  1929.     yy->reply.len = (int)strlen(rpbuf);
  1930.     if (retcode < 0) {            /* If we are rejecting */
  1931.     discard = 1;            /* remember to discard the file */
  1932.     rejection = rpbuf[1];        /* and use the first reason given. */
  1933.     if (fncsav != -1) {
  1934.         fncact = fncsav;
  1935.         fncsav = -1;
  1936.     }
  1937.     }
  1938.     debug(F111,"gattr return",rpbuf,retcode);
  1939.     return(retcode);
  1940. }
  1941.  
  1942. /*  I N I T A T T R  --  Initialize file attribute structure  */
  1943.  
  1944. int
  1945. initattr(yy) struct zattr *yy; {
  1946.     yy->lengthk = yy->length = (CK_OFF_T)-1;
  1947.     yy->type.val = "";
  1948.     yy->type.len = 0;
  1949.     yy->date.val = "";
  1950.     yy->date.len = 0;
  1951.     yy->encoding.val = "";
  1952.     yy->encoding.len = 0;
  1953.     yy->disp.val = "";
  1954.     yy->disp.len = 0;
  1955.     yy->systemid.val = "";
  1956.     yy->systemid.len = 0;
  1957.     yy->sysparam.val = "";
  1958.     yy->sysparam.len = 0;
  1959.     yy->creator.val = "";
  1960.     yy->creator.len = 0;
  1961.     yy->account.val = "";
  1962.     yy->account.len = 0;
  1963.     yy->area.val = "";
  1964.     yy->area.len = 0;
  1965.     yy->password.val = "";
  1966.     yy->password.len = 0;
  1967.     yy->blksize = -1L;
  1968.     yy->xaccess.val = "";
  1969.     yy->xaccess.len = 0;
  1970. #ifdef CK_PERMS
  1971.     if (!ofperms) ofperms = "";
  1972.     debug(F110,"initattr ofperms",ofperms,0);
  1973.     yy->lprotect.val = ofperms;
  1974.     yy->lprotect.len = 0 - strlen(ofperms); /* <-- NOTE! */
  1975.     /*
  1976.       A negative length indicates that we have a permissions string but it has
  1977.       been inherited from a previously existing file rather than picked up
  1978.       from an incoming A-packet.
  1979.     */
  1980. #else
  1981.     yy->lprotect.val = "";
  1982.     yy->lprotect.len = 0;
  1983. #endif /* CK_PERMS */
  1984.     yy->gprotect.val = "";
  1985.     yy->gprotect.len = 0;
  1986.     yy->recfm.val = "";
  1987.     yy->recfm.len = 0;
  1988.     yy->reply.val = "";
  1989.     yy->reply.len = 0;
  1990. #ifdef OS2
  1991.     yy->longname.len = 0 ;
  1992.     yy->longname.val = "" ;
  1993. #endif /* OS2 */
  1994.     return(0);
  1995. }
  1996.  
  1997. /*  A D E B U -- Write attribute packet info to debug log  */
  1998.  
  1999. int
  2000. adebu(f,zz) char *f; struct zattr *zz; {
  2001. #ifdef DEBUG
  2002.     if (deblog == 0) return(0);
  2003.     debug(F110,"Attributes for incoming file ",f,0);
  2004.     debug(F101," length in K","",(int) zz->lengthk);
  2005.     debug(F111," file type",zz->type.val,zz->type.len);
  2006.     debug(F111," creation date",zz->date.val,zz->date.len);
  2007.     debug(F111," creator",zz->creator.val,zz->creator.len);
  2008.     debug(F111," account",zz->account.val,zz->account.len);
  2009.     debug(F111," area",zz->area.val,zz->area.len);
  2010.     debug(F111," password",zz->password.val,zz->password.len);
  2011.     debug(F101," blksize","",(int) zz->blksize);
  2012.     debug(F111," access",zz->xaccess.val,zz->xaccess.len);
  2013.     debug(F111," encoding",zz->encoding.val,zz->encoding.len);
  2014.     debug(F111," disposition",zz->disp.val,zz->disp.len);
  2015.     debug(F111," lprotection",zz->lprotect.val,zz->lprotect.len);
  2016.     debug(F111," gprotection",zz->gprotect.val,zz->gprotect.len);
  2017.     debug(F111," systemid",zz->systemid.val,zz->systemid.len);
  2018.     debug(F111," recfm",zz->recfm.val,zz->recfm.len);
  2019.     debug(F111," sysparam",zz->sysparam.val,zz->sysparam.len);
  2020.     debug(F101," length","",(int) zz->length);
  2021.     debug(F110," reply",zz->reply.val,0);
  2022. #endif /* DEBUG */
  2023.     return(0);
  2024. }
  2025.  
  2026. /*  O P E N A -- Open a file, with attributes.  */
  2027. /*
  2028.   This function tries to open a new file to put the arriving data in.  The
  2029.   filename is the one in the srvcmd buffer.  File collision actions are:
  2030.   OVERWRITE (the existing file is overwritten), RENAME (the new file is
  2031.   renamed), BACKUP (the existing file is renamed), DISCARD (the new file is
  2032.   refused), UPDATE (the incoming file replaces the existing file only if the
  2033.   incoming file has a newer creation date).
  2034.  
  2035.   Returns 0 on failure, nonzero on success.
  2036. */
  2037. extern char *rf_err;
  2038.  
  2039. int
  2040. opena(f,zz) char *f; struct zattr *zz; {
  2041.     int x, dispos = 0;
  2042.     static struct filinfo fcb;        /* Must be static! */
  2043.  
  2044.     debug(F110,"opena f",f,0);
  2045.     debug(F101,"opena discard","",discard);
  2046.  
  2047.     adebu(f,zz);            /* Write attributes to debug log */
  2048.  
  2049.     ffc = (CK_OFF_T)0;            /* Init file-character counter */
  2050.  
  2051. #ifdef PIPESEND
  2052.     if (pipesend)            /* Receiving to a pipe - easy. */
  2053.       return(openo(f,zz,&fcb));        /* Just open the pipe. */
  2054. #endif /* PIPESEND */
  2055.  
  2056.     /* Receiving to a file - set up file control structure */
  2057.  
  2058.     fcb.bs = fblksiz;            /* Blocksize */
  2059. #ifndef NOCSETS
  2060.     fcb.cs = fcharset;            /* Character set */
  2061. #else
  2062.     fcb.cs = 0;                /* Character set */
  2063. #endif /* NOCSETS */
  2064.     fcb.rl = frecl;            /* Record Length */
  2065.     fcb.fmt = frecfm;            /* Record Format */
  2066.     fcb.org = forg;            /* Organization */
  2067.     fcb.cc = fcctrl;            /* Carriage control */
  2068.     fcb.typ = binary;            /* Type */
  2069.     debug(F101,"opena xflg","",xflg);
  2070.     debug(F101,"opena remfile","",remfile);
  2071.     debug(F101,"opena remappd","",remappd);
  2072.     if (xflg && remfile && remappd)    /* REMOTE output redirected with >> */
  2073.       fcb.dsp = XYFZ_A;
  2074.     else
  2075.       fcb.dsp = (fncact == XYFX_A) ? XYFZ_A : XYFZ_N; /* Disposition */
  2076.     debug(F101,"opena disp","",fcb.dsp);
  2077.     fcb.os_specific = "";        /* OS-specific info */
  2078. #ifdef CK_LABELED
  2079.     fcb.lblopts = lf_opts;        /* Labeled file options */
  2080. #else
  2081.     fcb.lblopts = 0;
  2082. #endif /* CK_LABELED */
  2083.  
  2084.     if (zz->disp.len > 0) {        /* Incoming file has a disposition? */
  2085.     debug(F111,"open disposition",zz->disp.val,zz->disp.len);
  2086.     dispos = (int) (*(zz->disp.val));
  2087.     }
  2088.     if (!dispos && xflg && remfile && remappd) /* REMOTE redirect append ? */
  2089.       dispos = fcb.dsp;
  2090.  
  2091.     debug(F101,"opena dispos","",dispos);
  2092.  
  2093.     if (!dispos) {                     /* No special disposition? */
  2094.     if (fncact == XYFX_B && ofn1x && ofn2) { /* File collision = BACKUP? */
  2095.         if (zrename(ofn1,ofn2) < 0) {        /* Rename existing file. */
  2096.         debug(F110,"opena rename fails",ofn1,0);
  2097.         rf_err = "Can't create backup file";
  2098.         return(0);
  2099.         } else debug(F110,"opena rename ok",ofn2,0);
  2100.     }
  2101.     } else if (dispos == 'R') {        /* Receiving a RESEND */
  2102.     debug(F101,"opena remote len","",zz->length);
  2103.     debug(F101,"opena local len","",rs_len);
  2104. #ifdef COMMENT
  2105.         if (fncact == XYFX_R)        /* and file collision = RENAME */
  2106.       if (ofn1x)
  2107. #endif /* COMMENT */
  2108.     if (ofn1[0])
  2109.       f = ofn1;            /* use original name. */
  2110.         if (fncact == XYFX_R)        /* if file collision is RENAME */
  2111.           ckstrncpy(filnam,ofn1,CKMAXPATH+1); /* restore the real name */
  2112.         xxscreen(SCR_AN,0,0L,f);    /* update name on screen */
  2113.     if (zz->length == rs_len)    /* Local and remote lengths equal? */
  2114.       return(-17);            /* Secret code */
  2115.     }
  2116.     debug(F111,"opena [file]=mode: ",f,fcb.dsp);
  2117.     if (x = openo(f,zz,&fcb)) {        /* Try to open the file. */
  2118. #ifdef pdp11
  2119.     tlog(F110," local name:",f,0L);    /* OK, open, record local name. */
  2120.     makestr(&prfspec,f);        /* New preliminary name */
  2121. #else
  2122. #ifndef ZFNQFP
  2123.     tlog(F110," local name:",f,0L);
  2124.     makestr(&prfspec,f);
  2125. #else
  2126.     {                /* Log full local pathname */
  2127.         char *p = NULL, *q = f;
  2128.         if ((p = malloc(CKMAXPATH+1)))
  2129.           if (zfnqfp(filnam, CKMAXPATH, p))
  2130.         q = p;
  2131.         tlog(F110," local name:",q,0L);
  2132.         makestr(&prfspec,q);
  2133.         if (p) free(p);
  2134.     }
  2135. #endif /* ZFNQFP */
  2136. #endif /* pdp11 */
  2137.  
  2138.     if (binary) {            /* Log file mode in transaction log */
  2139.         tlog(F101," mode: binary","",(long) binary);
  2140.     } else {            /* If text mode, check character set */
  2141.         tlog(F100," mode: text","",0L);
  2142. #ifndef NOCSETS
  2143.         if (xfrxla) {
  2144.         if (fcharset > -1 && fcharset <= MAXFCSETS)
  2145.           tlog(F110," file character-set:",fcsinfo[fcharset].name,0L);
  2146.         if (tcharset > -1 && tcharset <= MAXTCSETS)
  2147.           tlog(F110," xfer character-set:",tcsinfo[tcharset].name,0L);
  2148.         } else {
  2149.           tlog(F110," character-set:","transparent",0L);
  2150.         }
  2151. #endif /* NOCSETS */
  2152.         debug(F111,"opena charset",zz->encoding.val,zz->encoding.len);
  2153.     }
  2154.     debug(F101,"opena binary","",binary);
  2155.  
  2156. #ifdef COMMENT
  2157.     if (fsize >= 0)
  2158. #endif /* COMMENT */
  2159.       xxscreen(SCR_FS,0,fsize,"");
  2160.  
  2161. #ifdef datageneral
  2162. /*
  2163.   Need to turn on multi-tasking console interrupt task here, since multiple
  2164.   files may be received (huh?) ...
  2165. */
  2166.         if ((local) && (!quiet))        /* Only do this if local & not quiet */
  2167.       consta_mt();            /* Start the async read task */
  2168. #endif /* datageneral */
  2169.  
  2170.     } else {                /* Did not open file OK. */
  2171.  
  2172.     rf_err = ck_errstr();        /* Get system error message */
  2173.     if (*rf_err)
  2174.       xxscreen(SCR_EM,0,0l,rf_err);
  2175.     else
  2176.       xxscreen(SCR_EM,0,0l,"Can't open output file");
  2177.         tlog(F110,"Failure to open",f,0L);
  2178.         tlog(F110,"Error:",rf_err,0L);
  2179.     debug(F110,"opena error",rf_err,0);
  2180.     }
  2181.     return(x);                /* Pass on return code from openo */
  2182. }
  2183.  
  2184. /*  O P E N C  --  Open a command (in place of a file) for output */
  2185.  
  2186. int
  2187. openc(n,s) int n; char * s; {
  2188.     int x;
  2189. #ifndef NOPUSH
  2190.     x = zxcmd(n,s);
  2191. #else
  2192.     x = 0;
  2193. #endif /* NOPUSH */
  2194.     debug(F111,"openc zxcmd",s,x);
  2195.     o_isopen = (x > 0) ? 1 : 0;
  2196.     return(x);
  2197. }
  2198.  
  2199. /*  C A N N E D  --  Check if current file transfer cancelled */
  2200.  
  2201. int
  2202. canned(buf) CHAR *buf; {
  2203.     extern int interrupted;
  2204.     if (*buf == 'X') cxseen = 1;
  2205.     if (*buf == 'Z') czseen = 1;
  2206.     if (czseen || cxseen)
  2207.       interrupted = 1;
  2208.     debug(F101,"canned: cxseen","",cxseen);
  2209.     debug(F101," czseen","",czseen);
  2210.     return((czseen || cxseen) ? 1 : 0);
  2211. }
  2212.  
  2213.  
  2214. /*  O P E N I  --  Open an existing file for input  */
  2215.  
  2216. int
  2217. openi(name) char *name; {
  2218. #ifndef NOSERVER
  2219.     extern int fromgetpath;
  2220. #endif /* NOSERVER */
  2221.     int x, filno;
  2222.     char *name2;
  2223.     extern CHAR *epktmsg;
  2224.  
  2225.     epktmsg[0] = NUL;            /* Initialize error message */
  2226.     if (memstr || sndarray) {        /* Just return if "file" is memory. */
  2227.     i_isopen = 1;
  2228.     return(1);
  2229.     }
  2230.     debug(F110,"openi name",name,0);
  2231.     debug(F101,"openi sndsrc","",sndsrc);
  2232.  
  2233.     filno = (sndsrc == 0) ? ZSTDIO : ZIFILE;    /* ... */
  2234.     debug(F101,"openi file number","",filno);
  2235.  
  2236. #ifndef NOSERVER
  2237.     /* If I'm a server and CWD is disabled and name is not from GET-PATH... */
  2238.  
  2239.     if (server && !en_cwd && !fromgetpath) {
  2240.     zstrip(name,&name2);
  2241.     if (                /* ... check if pathname included. */
  2242. #ifdef VMS
  2243.         zchkpath(name)
  2244. #else
  2245.         strcmp(name,name2)
  2246. #endif /* VMS */
  2247.         ) {
  2248.         tlog(F110,name,"access denied",0L);
  2249.         debug(F110,"openi CD disabled",name,0);
  2250.         ckstrncpy((char *)epktmsg,"Access denied",PKTMSGLEN);
  2251.         return(0);
  2252.     } else name = name2;
  2253.     }
  2254. #endif /* NOSERVER */
  2255.  
  2256. #ifdef PIPESEND
  2257.     debug(F101,"openi pipesend","",pipesend);
  2258.     if (pipesend) {
  2259.     int x;
  2260. #ifndef NOPUSH
  2261.     x = zxcmd(ZIFILE,name);
  2262. #else
  2263.     x = 0;
  2264. #endif /* NOPUSH */
  2265.     i_isopen = (x > 0) ? 1 : 0;
  2266.     if (!i_isopen)
  2267.       ckstrncpy((char *)epktmsg,"Command or pipe failure",PKTMSGLEN);
  2268.     debug(F111,"openi pipesend zxcmd",name,x);
  2269.     return(i_isopen);
  2270.     }
  2271. #endif /* PIPESEND */
  2272.  
  2273. #ifdef CALIBRATE
  2274.     if (calibrate) {
  2275.     i_isopen = 1;
  2276.         return(1);
  2277.     }
  2278. #endif /* CALIBRATE */
  2279.  
  2280.     x = zopeni(filno,name);        /* Otherwise, try to open it. */
  2281.     debug(F111,"openi zopeni 1",name,x);
  2282.     if (x) {
  2283.     i_isopen = 1;
  2284.         return(1);
  2285.     } else {                /* If not found, */
  2286.     char xname[CKMAXPATH];        /* convert the name */
  2287. #ifdef NZLTOR
  2288.     nzrtol(name,xname,fncnv,fnrpath,CKMAXPATH);
  2289. #else
  2290.     zrtol(name,xname);        /* to local form and then */
  2291. #endif /*  NZLTOR */
  2292.     x = zopeni(filno,xname);    /* try opening it again. */
  2293.     debug(F111,"openi zopeni 2",xname,x);
  2294.     if (x) {
  2295.         i_isopen = 1;
  2296.         return(1);            /* It worked. */
  2297.         } else {
  2298.         char * s;
  2299.         s = ck_errstr();
  2300.         if (s) if (!s) s = NULL;
  2301.         if (!s) s = "Can't open file";
  2302.         ckstrncpy((char *)epktmsg,s,PKTMSGLEN);
  2303.         tlog(F110,xname,s,0L);
  2304.         debug(F110,"openi failed",xname,0);
  2305.         debug(F110,"openi message",s,0);
  2306.         i_isopen = 0;
  2307.         return(0);
  2308.         }
  2309.     }
  2310. }
  2311.  
  2312. /*  O P E N O  --  Open a new file for output.  */
  2313.  
  2314. int
  2315. openo(name,zz,fcb) char *name; struct zattr *zz; struct filinfo *fcb; {
  2316.     char *name2;
  2317. #ifdef DTILDE
  2318.     char *dirp;
  2319. #endif /* DTILDE */
  2320.  
  2321.     int channel, x;
  2322.  
  2323.     if (stdouf) {                /* Receiving to stdout? */
  2324.     x = zopeno(ZSTDIO,"",zz,NULL);
  2325.     o_isopen = (x > 0);
  2326.     debug(F101,"openo stdouf zopeno","",x);
  2327.     return(x);
  2328.     }
  2329.     debug(F110,"openo: name",name,0);
  2330.  
  2331.     if (cxseen || czseen || discard) {    /* If interrupted, get out before */
  2332.     debug(F100," open cancelled","",0); /* destroying existing file. */
  2333.     return(1);            /* Pretend to succeed. */
  2334.     }
  2335.     channel = ZOFILE;            /* SET DESTINATION DISK or PRINTER */
  2336.  
  2337. #ifdef PIPESEND
  2338.     debug(F101,"openo pipesend","",pipesend);
  2339.     if (pipesend) {
  2340.     int x;
  2341. #ifndef NOPUSH
  2342.     x = zxcmd(ZOFILE,(char *)srvcmd);
  2343. #else
  2344.     x = 0;
  2345. #endif /* NOPUSH */
  2346.     o_isopen = x > 0;
  2347.     debug(F101,"openo zxcmd","",x);
  2348.     return(x);
  2349.     }
  2350. #endif /* PIPESEND */
  2351.  
  2352.     if (dest == DEST_S) {        /* SET DEST SCREEN... */
  2353.     channel = ZCTERM;
  2354.     fcb = NULL;
  2355.     }
  2356. #ifdef DTILDE
  2357.     if (*name == '~') {
  2358.     dirp = tilde_expand(name);
  2359.     if (*dirp) ckstrncpy(name,dirp,CKMAXPATH+1);
  2360.     }
  2361. #endif /* DTILDE */
  2362.     if (server && !en_cwd) {        /* If running as server */
  2363.     zstrip(name,&name2);        /* and CWD is disabled, */
  2364.     if (strcmp(name,name2)) {    /* check if pathname was included. */
  2365.         tlog(F110,name,"authorization failure",0L);
  2366.         debug(F110,"openo CD disabled",name,0);
  2367.         return(0);
  2368.     } else name = name2;
  2369.     }
  2370.     if (zopeno(channel,name,zz,fcb) <= 0) { /* Try to open the file */
  2371.     o_isopen = 0;
  2372.     debug(F110,"openo failed",name,0);
  2373.     /* tlog(F110,"Failure to open",name,0L); */
  2374.     return(0);
  2375.     } else {
  2376.     o_isopen = 1;
  2377.     debug(F110,"openo ok, name",name,0);
  2378.     return(1);
  2379.     }
  2380. }
  2381.  
  2382. /*  O P E N T  --  Open the terminal for output, in place of a file  */
  2383.  
  2384. int
  2385. opent(zz) struct zattr *zz; {
  2386.     int x;
  2387.     ffc = tfc = (CK_OFF_T)0;
  2388.     x = zopeno(ZCTERM,"",zz,NULL);
  2389.     debug(F101,"opent zopeno","",x);
  2390.     if (x >= 0) {
  2391.     o_isopen = 1;
  2392.     binary = XYFT_T;
  2393.     } else
  2394.       return(0);
  2395.     return(x);
  2396. }
  2397.  
  2398. /*  O P E N X  --  Open nothing (incoming file to be accepted but ignored)  */
  2399.  
  2400. int
  2401. ckopenx(zz) struct zattr *zz; {
  2402.     ffc = tfc = (CK_OFF_T)0;        /* Reset counters */
  2403.     o_isopen = 1;
  2404.     debug(F101,"ckopenx fsize","",fsize);
  2405.     xxscreen(SCR_FS,0,fsize,"");    /* Let screen display know the size */
  2406.     return(1);
  2407. }
  2408.  
  2409. /*  C L S I F  --  Close the current input file. */
  2410.  
  2411. int
  2412. clsif() {
  2413.     extern int xferstat, success;
  2414.     int x = 0;
  2415.  
  2416.     fcps();            /* Calculate CPS quickly */
  2417.  
  2418. #ifdef datageneral
  2419.     if ((local) && (!quiet))    /* Only do this if local & not quiet */
  2420.       if (nfils < 1)        /* More files to send ... leave it on! */
  2421.     connoi_mt();
  2422. #endif /* datageneral */
  2423.  
  2424.     debug(F101,"clsif i_isopen","",i_isopen);
  2425.     if (i_isopen) {            /* If input file is open... */
  2426.     if (memstr) {            /* If input was memory string, */
  2427.         memstr = 0;            /* indicate no more. */
  2428.     } else {
  2429.         x = zclose(ZIFILE);        /* else close input file. */
  2430.     }
  2431. #ifdef DEBUG
  2432.     if (deblog) {
  2433.         debug(F101,"clsif zclose","",x);
  2434.         debug(F101,"clsif success","",success);
  2435.         debug(F101,"clsif xferstat","",xferstat);
  2436.         debug(F101,"clsif fsize","",fsize);
  2437.         debug(F101,"clsif ffc","",ffc);
  2438.         debug(F101,"clsif cxseen","",cxseen);
  2439.         debug(F101,"clsif czseen","",czseen);
  2440.         debug(F101,"clsif discard","",czseen);
  2441.     }
  2442. #endif /* DEBUG */
  2443.     if ((cxseen || czseen) && !epktsent) { /* If interrupted */
  2444.         xxscreen(SCR_ST,ST_INT,0l,""); /* say so */
  2445. #ifdef TLOG
  2446.         if (tralog && !tlogfmt)
  2447.           doxlog(what,psfspec,fsize,binary,1,"Interrupted");
  2448. #endif /* TLOG */
  2449.     } else if (discard && !epktsent) { /* If I'm refusing */
  2450.         xxscreen(SCR_ST,ST_REFU,0l,refused); /* say why */
  2451. #ifdef TLOG
  2452.         if (tralog && !tlogfmt) {
  2453.         char buf[128];
  2454.         ckmakmsg(buf,128,"Refused: ",refused,NULL,NULL);
  2455.         doxlog(what,psfspec,fsize,binary,1,buf);
  2456.         }
  2457. #endif /* TLOG */
  2458.     } else if (!epktrcvd && !epktsent && !cxseen && !czseen) {
  2459.         CK_OFF_T zz;
  2460.         zz = ffc;
  2461. #ifdef CK_RESEND
  2462.         if (sendmode == SM_RESEND || sendmode == SM_PSEND)
  2463.           zz += sendstart;
  2464. #endif /* CK_RESEND */
  2465.         debug(F101,"clsif fstats","",zz);
  2466.         fstats();            /* Update statistics */
  2467.         if (            /* Was the whole file sent? */
  2468. #ifdef VMS
  2469.         0            /* Not a reliable check in VMS */
  2470. #else
  2471. #ifdef STRATUS
  2472.         0            /* Probably not for VOS either */
  2473. #else
  2474.         zz < fsize
  2475. #ifdef CK_CTRLZ
  2476.         && ((eofmethod != XYEOF_Z && !binary) || binary)
  2477. #endif /* CK_CTRLZ */
  2478. #endif /* STRATUS */
  2479. #endif /* VMS */
  2480.         ) {
  2481.         xxscreen(SCR_ST,ST_INT,0l,"");
  2482. #ifdef TLOG
  2483.         if (tralog && !tlogfmt)
  2484.           doxlog(what,psfspec,fsize,binary,1,"Incomplete");
  2485. #endif /* TLOG */
  2486.         } else {
  2487. #ifdef COMMENT
  2488.         /* Not yet -- we don't have confirmation from the receiver */
  2489.         xxscreen(SCR_ST,ST_OK,0l,"");
  2490. #endif /* COMMENT */
  2491. #ifdef TLOG
  2492.         if (tralog && !tlogfmt)
  2493.           doxlog(what,psfspec,fsize,binary,0,"");
  2494. #endif /* TLOG */
  2495.         }
  2496.     }
  2497.     }
  2498.     i_isopen = 0;
  2499.     hcflg = 0;                /* Reset flags */
  2500.     sendstart = (CK_OFF_T)0;        /* Don't do this again! */
  2501. #ifdef COMMENT
  2502. /*
  2503.   This prevents a subsequent call to clsof() from deleting the file
  2504.   when given the discard flag.
  2505. */
  2506.     *filnam = '\0';            /* and current file name */
  2507. #endif /* COMMENT */
  2508.     return(x);
  2509. }
  2510.  
  2511.  
  2512. /*  C L S O F  --  Close an output file.  */
  2513.  
  2514. /*  Call with disp != 0 if file is to be discarded.  */
  2515. /*  Returns -1 upon failure to close, 0 or greater on success. */
  2516.  
  2517. int
  2518. clsof(disp) int disp; {
  2519.     int x = 0;
  2520.     extern int success;
  2521.  
  2522.     fcps();                /* Calculate CPS quickly */
  2523.  
  2524.     debug(F101,"clsof disp","",disp);
  2525.     debug(F101,"clsof cxseen","",cxseen);
  2526.     debug(F101,"clsof success","",success);
  2527.  
  2528.     debug(F101,"clsof o_isopen","",o_isopen);
  2529.     if (fncsav != -1) {            /* Saved file collision action... */
  2530.     fncact = fncsav;        /* Restore it. */
  2531.     fncsav = -1;            /* Unsave it. */
  2532.     }
  2533. #ifdef datageneral
  2534.     if ((local) && (!quiet))        /* Only do this if local & not quiet */
  2535.       connoi_mt();
  2536. #endif /* datageneral */
  2537.     if (o_isopen && !calibrate) {
  2538.     if ((x = zclose(ZOFILE)) < 0) { /* Try to close the file */
  2539.         tlog(F100,"Failure to close",filnam,0L);
  2540.         xxscreen(SCR_ST,ST_ERR,0l,"Can't close file");
  2541. #ifdef TLOG
  2542.         if (tralog && !tlogfmt)
  2543.           doxlog(what,prfspec,fsize,binary,1,"Can't close file");
  2544. #endif /* TLOG */
  2545.     } else if (disp) {        /* Interrupted or refused */
  2546.         if (keep == 0 ||        /* If not keeping incomplete files */
  2547.         (keep == SET_AUTO && binary == XYFT_T)
  2548.         ) {
  2549.         if (*filnam && (what & W_RECV)) /* AND we're receiving */
  2550.           zdelet(filnam);    /* ONLY THEN, delete it */
  2551.         if (what & W_KERMIT) {
  2552.             debug(F100,"clsof incomplete discarded","",0);
  2553.             tlog(F100," incomplete: discarded","",0L);
  2554.             if (!epktrcvd && !epktsent) {
  2555.             xxscreen(SCR_ST,ST_DISC,0l,"");
  2556. #ifdef TLOG
  2557.             if (tralog && !tlogfmt)
  2558.               doxlog(what,prfspec,fsize,binary,1,"Discarded");
  2559. #endif /* TLOG */
  2560.             }
  2561.         }
  2562.         } else {            /* Keep incomplete copy */
  2563.         debug(F100,"clsof fstats 1","",0);
  2564.         fstats();
  2565.         if (!discard) {     /* Unless discarding for other reason... */
  2566.             if (what & W_KERMIT) {
  2567.             debug(F100,"closf incomplete kept","",0);
  2568.             tlog(F100," incomplete: kept","",0L);
  2569.             }
  2570.         }
  2571.         if (what & W_KERMIT) {
  2572.             if (!epktrcvd && !epktsent) {
  2573.             xxscreen(SCR_ST,ST_INC,0l,"");
  2574. #ifdef TLOG
  2575.             if (tralog && !tlogfmt)
  2576.               doxlog(what,prfspec,fsize,binary,1,"Incomplete");
  2577. #endif /* TLOG */
  2578.             }
  2579.         }
  2580.         }
  2581.     }
  2582.     }
  2583.     if (o_isopen && x > -1 && !disp) {
  2584.     debug(F110,"clsof OK",rfspec,0);
  2585.     makestr(&rfspec,prfspec);
  2586.     makestr(&rrfspec,prrfspec);
  2587.     fstats();
  2588.     if (!epktrcvd && !epktsent && !cxseen && !czseen) {
  2589.         xxscreen(SCR_ST,ST_OK,0L,"");
  2590. #ifdef TLOG
  2591.         if (tralog && !tlogfmt)
  2592.           doxlog(what,rfspec,fsize,binary,0,"");
  2593. #endif /* TLOG */
  2594.     }
  2595.     }
  2596.     rs_len = (CK_OFF_T)0;
  2597.     o_isopen = 0;            /* The file is not open any more. */
  2598.     cxseen = 0;                /* Reset per-file interruption flag */
  2599.     return(x);                /* Send back zclose() return code. */
  2600. }
  2601.  
  2602. #ifdef SUNOS4S5
  2603. tolower(c) char c; { return((c)-'A'+'a'); }
  2604. toupper(c) char c; { return((c)-'a'+'A'); }
  2605. #endif /* SUNOS4S5 */
  2606. #endif /* NOXFER */
  2607.