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