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