![[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 [Research Unix] / researchv10dc / lbin / kermit|
Return to ckcfns.c CVS log | Up to [Research Unix] / researchv10dc / lbin / kermit |
1.1 root 1: char *fnsv = "C-Kermit functions, 4E(053) 14 Sep 87";
2:
3: /* C K C F N S -- System-independent Kermit protocol support functions. */
4:
5: /* ...Part 1 (others moved to ckcfn2 to make this module small enough) */
6:
7: /*
8: 4E includes support for Data General systems from Phil Julian of SAS
9: Institute, and Megamax native Macintosh C compiler support from
10: Jim Noble of Planning Research Corporation.
11: */
12: /*
13: Author: Frank da Cruz (SY.FDC@CU20B),
14: Columbia University Center for Computing Activities, January 1985.
15: Copyright (C) 1985, Trustees of Columbia University in the City of New York.
16: Permission is granted to any individual or institution to use, copy, or
17: redistribute this software so long as it is not sold for profit, provided this
18: copyright notice is retained.
19: */
20: /*
21: System-dependent primitives defined in:
22:
23: ck?tio.c -- terminal i/o
24: cx?fio.c -- file i/o, directory structure
25: */
26: #include "ckcsym.h" /* Need this for Mac */
27: #include "ckcker.h" /* Symbol definitions for Kermit */
28: #include "ckcdeb.h" /* Debug formats, typedefs, etc. */
29:
30: #ifndef NULL
31: #define NULL 0
32: #endif
33:
34: /* Externals from ckcmai.c */
35: extern int spsiz, rpsiz, timint, rtimo, npad, ebq, ebqflg, rpt, rptq,
36: rptflg, capas, keep;
37: extern int pktnum, prvpkt, sndtyp, bctr, bctu, fmask,
38: size, osize, maxsize, spktl, nfils, stdouf, warn, timef, spsizf;
39: extern int parity, speed, turn, turnch,
40: delay, displa, pktlog, tralog, seslog, xflg, mypadn;
41: extern long filcnt, ffc, flci, flco, tlci, tlco, tfc, fsize;
42: extern int tsecs;
43: extern int deblog, hcflg, binary, savmod, fncnv, local, server, cxseen, czseen;
44: extern int rq, rqf, sq, wsize, urpsiz, rln;
45: extern int atcapr, atcapb, atcapu;
46: extern int lpcapr, lpcapb, lpcapu;
47: extern int swcapr, swcapb, swcapu;
48: extern CHAR padch, mypadc, eol, seol, ctlq, myctlq, sstate;
49: extern CHAR filnam[], sndpkt[], recpkt[], data[], srvcmd[], stchr, mystch;
50: extern char *cmarg, *cmarg2, *hlptxt, **cmlist;
51: extern CHAR *srvptr;
52: extern char *rdatap;
53: long zchki();
54: char *strcpy();
55: CHAR *rpar();
56:
57: /* Variables local to this module */
58:
59: static char *memptr; /* Pointer for memory strings */
60:
61: static char cmdstr[100]; /* Unix system command string */
62:
63: static int sndsrc; /* Flag for where to send from: */
64: /* -1: name in cmdata */
65: /* 0: stdin */
66: /* >0: list in cmlist */
67:
68: static int memstr, /* Flag for input from memory string */
69: first; /* Flag for first char from input */
70: static CHAR t, /* Current character */
71: next; /* Next character */
72: #ifdef datageneral
73: extern int quiet;
74: #endif
75:
76: /* E N C S T R -- Encode a string from memory. */
77:
78: /* Call this instead of getpkt() if source is a string, rather than a file. */
79:
80: encstr(s) char* s; {
81: int m; char *p;
82:
83: m = memstr; p = memptr; /* Save these. */
84:
85: memptr = s; /* Point to the string. */
86: memstr = 1; /* Flag memory string as source. */
87: first = 1; /* Initialize character lookahead. */
88: getpkt(spsiz-bctu-3); /* Fill a packet from the string. */
89: memstr = m; /* Restore memory string flag */
90: memptr = p; /* and pointer */
91: first = 1; /* Put this back as we found it. */
92: }
93:
94: /* E N C O D E - Kermit packet encoding procedure */
95:
96: encode(a) CHAR a; { /* The current character */
97: int a7; /* Low order 7 bits of character */
98: int b8; /* 8th bit of character */
99:
100: if (rptflg) { /* Repeat processing? */
101: if (a == next && (first == 0)) { /* Got a run... */
102: if (++rpt < 94) /* Below max, just count */
103: return;
104: else if (rpt == 94) { /* Reached max, must dump */
105: data[size++] = rptq;
106: data[size++] = tochar(rpt);
107: rpt = 0;
108: }
109: } else if (rpt == 1) { /* Run broken, only 2? */
110: rpt = 0; /* Yes, reset repeat flag & count. */
111: encode(a); /* Do the character twice. */
112: if (size <= maxsize) osize = size;
113: rpt = 0;
114: encode(a);
115: return;
116: } else if (rpt > 1) { /* More than two */
117: data[size++] = rptq; /* Insert the repeat prefix */
118: data[size++] = tochar(++rpt); /* and count. */
119: rpt = 0; /* Reset repeat counter. */
120: }
121: }
122: a7 = a & 0177; /* Isolate ASCII part */
123: b8 = a & 0200; /* and 8th (parity) bit. */
124:
125: if (ebqflg && b8) { /* Do 8th bit prefix if necessary. */
126: data[size++] = ebq;
127: a = a7;
128: }
129: if ((a7 < SP) || (a7==DEL)) { /* Do control prefix if necessary */
130: data[size++] = myctlq;
131: a = ctl(a);
132: }
133: if (a7 == myctlq) /* Prefix the control prefix */
134: data[size++] = myctlq;
135:
136: if ((rptflg) && (a7 == rptq)) /* If it's the repeat prefix, */
137: data[size++] = myctlq; /* quote it if doing repeat counts. */
138:
139: if ((ebqflg) && (a7 == ebq)) /* Prefix the 8th bit prefix */
140: data[size++] = myctlq; /* if doing 8th-bit prefixes */
141:
142: data[size++] = a; /* Finally, insert the character */
143: data[size] = '\0'; /* itself, and mark the end. */
144: }
145:
146: /* D E C O D E -- Kermit packet decoding procedure */
147:
148: /* Call with string to be decoded and an output function. */
149: /* Returns 0 on success, -1 on failure (e.g. disk full). */
150:
151: decode(buf,fn) CHAR *buf; int (*fn)(); {
152: unsigned int a, a7, b8; /* Low order 7 bits, and the 8th bit */
153:
154: rpt = 0; /* Initialize repeat count. */
155:
156: while ((a = *buf++) != '\0') {
157: if (rptflg) { /* Repeat processing? */
158: if (a == rptq) { /* Yes, got a repeat prefix? */
159: rpt = xunchar(*buf++); /* Yes, get the repeat count, */
160: a = *buf++; /* and get the prefixed character. */
161: }
162: }
163: b8 = 0; /* Check high order "8th" bit */
164: if (ebqflg) { /* 8th-bit prefixing? */
165: if (a == ebq) { /* Yes, got an 8th-bit prefix? */
166: b8 = 0200; /* Yes, remember this, */
167: a = *buf++; /* and get the prefixed character. */
168: }
169: }
170: if (a == ctlq) { /* If control prefix, */
171: a = *buf++; /* get its operand. */
172: a7 = a & 0177; /* Only look at low 7 bits. */
173: if ((a7 >= 0100 && a7 <= 0137) || a7 == '?') /* Uncontrollify */
174: a = ctl(a); /* if in control range. */
175: }
176: a |= b8; /* OR in the 8th bit */
177: if (rpt == 0) rpt = 1; /* If no repeats, then one */
178: #ifdef NLCHAR
179: if (!binary) { /* If in text mode, */
180: if (a == CR) continue; /* discard carriage returns, */
181: if (a == LF) a = NLCHAR; /* convert LF to system's newline. */
182: }
183: #endif
184: for (; rpt > 0; rpt--) { /* Output the char RPT times */
185: if ((*fn)(a) < 0) return(-1); /* Send it to the output function. */
186: ffc++, tfc++; /* Count the character */
187: }
188: }
189: return(0);
190: }
191:
192:
193: /* Output functions passed to 'decode': */
194:
195: putsrv(c) char c; { /* Put character in server command buffer */
196: *srvptr++ = c;
197: *srvptr = '\0'; /* Make sure buffer is null-terminated */
198: return(0);
199: }
200:
201: puttrm(c) char c; { /* Output character to console. */
202: conoc(c);
203: return(0);
204: }
205:
206: putfil(c) char c; { /* Output char to file. */
207: if (zchout(ZOFILE, c & fmask) < 0) {
208: czseen = 1; /* If write error... */
209: debug(F101,"putfil zchout write error, setting czseen","",1);
210: return(-1);
211: }
212: return(0);
213: }
214:
215: /* G E T P K T -- Fill a packet data field */
216:
217: /*
218: Gets characters from the current source -- file or memory string.
219: Encodes the data into the packet, filling the packet optimally.
220: Set first = 1 when calling for the first time on a given input stream
221: (string or file).
222:
223: Uses global variables:
224: t -- current character.
225: first -- flag: 1 to start up, 0 for input in progress, -1 for EOF.
226: next -- next character.
227: data -- the packet data buffer.
228: size -- number of characters in the data buffer.
229:
230: Returns the size as value of the function, and also sets global size,
231: and fills (and null-terminates) the global data array. Returns 0 upon eof.
232: */
233:
234: getpkt(bufmax) int bufmax; { /* Fill one packet buffer */
235: int i, x; /* Loop index. */
236:
237: static char leftover[6] = { '\0', '\0', '\0', '\0', '\0', '\0' };
238:
239: if (first == 1) { /* If first time thru... */
240: first = 0; /* remember, */
241: *leftover = '\0'; /* discard any interrupted leftovers, */
242: x = getchx(&t); /* get first character of file into t, */
243: if (x == 0) { /* watching out for null file, */
244: first = -1;
245: return(size = 0);
246: }
247: } else if ((first == -1) && (*leftover == '\0')) /* EOF from last time? */
248: return(size = 0);
249:
250: /* Do any leftovers */
251:
252: for (size = 0; (data[size] = leftover[size]) != '\0'; size++)
253: ;
254: *leftover = '\0';
255: if (first == -1) return(size); /* Handle final leftovers leftovers */
256:
257: /* Now fill up the rest of the packet. */
258:
259: rpt = 0; /* Clear out any old repeat count. */
260: while (first > -1) { /* Until EOF... */
261: x = getchx(&next); /* Get next character for lookahead. */
262: if (x == 0) first = -1; /* Flag eof for next time. */
263: osize = size; /* Remember current position. */
264: encode(t); /* Encode the current character. */
265: t = next; /* Next is now current. */
266:
267: if (size == bufmax) { /* If the packet is exactly full, */
268: /** debug(F101,"getpkt exact fit","",size); **/
269: return(size); /* ... return. */
270: }
271: if (size > bufmax) { /* If too big, save some for next. */
272: for (i = 0; (leftover[i] = data[osize+i]) != '\0'; i++)
273: ;
274: /** debug(F111,"getpkt leftover",leftover,size); **/
275: /** debug(F101," osize","",osize); **/
276: size = osize; /* Return truncated packet. */
277: data[size] = '\0';
278: return(size);
279: }
280: } /* Otherwise, keep filling. */
281: debug(F111,"getpkt eof/eot",data,size); /* Fell thru before packet full, */
282: return(size); /* return partially filled last packet. */
283: }
284:
285: /* G E T C H X -- Get the next character from file (or pipe). */
286:
287: /*
288: On systems like Unix, the Macintosh, etc, that use a single character
289: (NLCHAR, defined in ckcdeb.h) to separate lines in text files, and
290: when in text/ascii mode (binary == 0), this function maps the newline
291: character to CRLF. If NLCHAR is not defined, then this mapping is
292: not done, even in text mode.
293:
294: Returns 1 on success with ch set to the character, or 0 on failure (EOF)
295: */
296: getchx(ch) char *ch; { /* Get next character */
297: int x; CHAR a; /* The character to return. */
298: static int b = 0; /* A character to remember. */
299:
300: if (b > 0) { /* Do we have a LF saved? */
301: b = 0; /* Yes, return that. */
302: *ch = LF;
303: return(1);
304: }
305:
306: if (memstr) /* Try to get the next character */
307: x = ((a = *memptr++) == '\0'); /* from the appropriate source, */
308: else /* memory or the current file. */
309: x = (zchin(ZIFILE,&a) == -1);
310:
311: if (x)
312: return(0); /* No more, return 0 for EOF. */
313: else { /* Otherwise, read the next char. */
314: ffc++, tfc++; /* Count it. */
315: a &= fmask; /* Bytesize mask. */
316: #ifdef NLCHAR
317: if (!binary && (a == NLCHAR)) { /* If nl and we must do nl-CRLF */
318: b = 1; /* mapping, remember a linefeed, */
319: *ch = CR; /* and return a carriage return. */
320: return(1);
321: } else {
322: *ch = a; /* General case, return the char. */
323: return(1);
324: }
325: #else
326: *ch = a;
327: return(1);
328: #endif
329: }
330: }
331:
332:
333: /* C A N N E D -- Check if current file transfer cancelled */
334:
335: canned(buf) char *buf; {
336: if (*buf == 'X') cxseen = 1;
337: if (*buf == 'Z') czseen = 1;
338: debug(F101,"canned: cxseen","",cxseen);
339: debug(F101," czseen","",czseen);
340: return((czseen || cxseen) ? 1 : 0);
341: }
342:
343: /* R E S E T C -- Reset per-transaction character counters */
344: resetc() {
345: tfc = tlci = tlco = 0; /* Total file chars, line chars in & out */
346: }
347:
348:
349: /* T I N I T -- Initialize a transaction */
350:
351: tinit() {
352: xflg = 0; /* Reset x-packet flag */
353: memstr = 0; /* Reset memory-string flag */
354: memptr = NULL; /* and pointer */
355: bctu = 1; /* Reset block check type to 1 */
356: ebq = ebqflg = 0; /* Reset 8th-bit quoting stuff */
357: if (savmod) { /* If binary file mode was saved, */
358: binary = 1; /* restore it, */
359: savmod = 0; /* unsave it. */
360: }
361: prvpkt = -1; /* Reset packet number */
362: pktnum = 0;
363: cxseen = czseen = 0; /* Reset interrupt flags */
364: *filnam = '\0'; /* Clear file name */
365: *sndpkt = '\0'; /* Clear retransmission buffer */
366: if (server) /* If acting as server, */
367: timint = 30; /* Use 30 second timeout, */
368: }
369:
370:
371: /* R I N I T -- Respond to S packet */
372:
373: rinit(d) char *d; {
374: char *tp;
375: ztime(&tp);
376: tlog(F110,"Transaction begins",tp,0l); /* Make transaction log entry */
377: filcnt = 0; /* Init file counter */
378: spar(d);
379: ack1(rpar());
380: #ifdef datageneral
381: if ((local) && (!quiet)) /* Only do this if local & not quiet */
382: consta_mt(); /* Start the asynch read task */
383: #endif
384: }
385:
386: /* S I N I T -- Make sure file exists, then send Send-Init packet */
387:
388: sinit() {
389: int x; char *tp;
390:
391: filcnt = 0;
392: sndsrc = nfils; /* Where to look for files to send */
393: ztime(&tp);
394: tlog(F110,"Transaction begins",tp,0l); /* Make transaction log entry */
395: debug(F101,"sinit: sndsrc","",sndsrc);
396: if (sndsrc < 0) { /* Must expand from 'send' command */
397: nfils = zxpand(cmarg); /* Look up literal name. */
398: if (nfils < 0) {
399: screen(SCR_EM,0,0l,"Too many files");
400: return(0);
401: } else if (nfils == 0) { /* If none found, */
402: char xname[100]; /* convert the name. */
403: zrtol(cmarg,xname);
404: nfils = zxpand(xname); /* Look it up again. */
405: }
406: if (nfils < 1) { /* If no match, report error. */
407: if (server)
408: errpkt("File not found");
409: else
410: screen(SCR_EM,0,0l,"File not found");
411: return(0);
412: }
413: x = gnfile(); /* Position to first file. */
414: if (x < 1) {
415: if (!server)
416: screen(SCR_EM,0,0l,"No readable file to send");
417: else
418: errpkt("No readable file to send");
419: return(0);
420: }
421: } else if (sndsrc > 0) { /* Command line arglist -- */
422: x = gnfile(); /* Get the first file from it. */
423: if (x < 1) return(0); /* (if any) */
424: } else if (sndsrc == 0) { /* stdin or memory always exist... */
425: if ((cmarg2 != NULL) && (*cmarg2)) {
426: strcpy(filnam,cmarg2); /* If F packet, "as" name is used */
427: cmarg2 = ""; /* if provided, */
428: } else /* otherwise */
429: strcpy(filnam,"stdin"); /* just use this. */
430: }
431: debug(F101,"sinit: nfils","",nfils);
432: debug(F110," filnam",filnam,0);
433: debug(F110," cmdstr",cmdstr,0);
434: ttflui(); /* Flush input buffer. */
435: if (!local && !server) sleep(delay);
436: #ifdef datageneral
437: if ((local) && (!quiet)) /* Only do this if local & not quiet */
438: consta_mt(); /* Start the asynch read task */
439: #endif
440: sipkt('S'); /* Send the Send-Init packet. */
441: return(1);
442: }
443:
444: sipkt(c) char c; { /* Send S or I packet. */
445: CHAR *rp;
446: ttflui(); /* Flush pending input. */
447: rp = rpar(); /* Get parameters. */
448: spack(c,pktnum,strlen(rp),rp);
449: }
450:
451: /* R C V F I L -- Receive a file */
452:
453: rcvfil() {
454: int x;
455: ffc = flci = flco = 0; /* Init per-file counters */
456: srvptr = srvcmd; /* Decode file name from packet. */
457: decode(rdatap,putsrv);
458: if (*srvcmd == '\0') /* Watch out for null F packet. */
459: strcpy(srvcmd,"NONAME");
460: screen(SCR_FN,0,0l,srvcmd); /* Put it on screen */
461: tlog(F110,"Receiving",srvcmd,0l); /* Transaction log entry */
462: if (cmarg2 != NULL) { /* Check for alternate name */
463: if (*cmarg2 != '\0') {
464: strcpy(srvcmd,cmarg2); /* Got one, use it. */
465: *cmarg2 = '\0';
466: }
467: }
468: x = openo(srvcmd,filnam); /* Try to open it */
469: if (x) {
470: tlog(F110," as",filnam,0l);
471: screen(SCR_AN,0,0l,filnam);
472: intmsg(++filcnt);
473: #ifdef datageneral
474: /* Need to turn on multi-tasking console interrupt task here, since multiple */
475: /* files may be received. */
476: if ((local) && (!quiet)) /* Only do this if local & not quiet */
477: consta_mt(); /* Start the asynch read task */
478: #endif
479: } else {
480: tlog(F110,"Failure to open",filnam,0l);
481: screen(SCR_EM,0,0l,"Can't open file");
482: }
483: return(x); /* Pass on return code from openo */
484: }
485:
486: /* R E O F -- Receive End Of File */
487:
488: reof() {
489: int x;
490: if (cxseen == 0) cxseen = (*rdatap == 'D'); /* Got discard directive? */
491: x = clsof(cxseen | czseen);
492: if (cxseen || czseen) {
493: tlog(F100," *** Discarding","",0l);
494: cxseen = 0;
495: } else
496: fstats();
497: return(x);
498: }
499:
500:
501: /* R E O T -- Receive End Of Transaction */
502:
503: reot() {
504: cxseen = czseen = 0; /* Reset interruption flags */
505: tstats();
506: }
507:
508: /* S F I L E -- Send File header or teXt header packet */
509:
510: /* Call with x nonzero for X packet, zero for F packet */
511: /* Returns 1 on success, 0 on failure */
512:
513: sfile(x) int x; {
514: char pktnam[100]; /* Local copy of name */
515: char *s;
516:
517: if (x == 0) { /* F-Packet setup */
518:
519: if (*cmarg2 != '\0') { /* If we have a send-as name, */
520: strcpy(pktnam,cmarg2); /* copy it literally, */
521: cmarg2 = ""; /* and blank it out for next time. */
522: } else { /* Otherwise use actual file name: */
523: if (fncnv) { /* If converting names, */
524: zltor(filnam,pktnam); /* convert it to common form, */
525: } else { /* otherwise, */
526: strcpy(pktnam,filnam); /* copy it literally. */
527: }
528: }
529: debug(F110,"sfile",filnam,0); /* Log debugging info */
530: debug(F110," pktnam",pktnam,0);
531: if (openi(filnam) == 0) /* Try to open the file */
532: return(0);
533: s = pktnam; /* Name for packet data field */
534:
535: } else { /* X-packet setup */
536:
537: debug(F110,"sxpack",cmdstr,0); /* Log debugging info */
538: s = cmdstr; /* Name for data field */
539: }
540:
541: flci = flco = ffc = 0; /* Init counters, etc. */
542: encstr(s); /* Encode the name into data[]. */
543: nxtpkt(&pktnum); /* Increment the packet number */
544: spack(x ? 'X' : 'F', pktnum, size, data); /* Send the F or X packet */
545:
546: if (x == 0) { /* Display for F packet */
547: if (displa) { /* Screen */
548: screen(SCR_FN,'F',(long)pktnum,filnam);
549: screen(SCR_AN,0,0l,pktnam);
550: screen(SCR_FS,0,(long)fsize,"");
551: }
552: tlog(F110,"Sending",filnam,0l); /* Transaction log entry */
553: tlog(F110," as",pktnam,0l);
554:
555: } else { /* Display for X-packet */
556:
557: screen(SCR_XD,'X',(long)pktnum,cmdstr); /* Screen */
558: tlog(F110,"Sending from:",cmdstr,0l); /* Transaction log */
559: }
560: intmsg(++filcnt); /* Count file, give interrupt msg */
561: first = 1; /* Init file character lookahead. */
562: return(1);
563: }
564:
565: /* S D A T A -- Send a data packet */
566:
567: /* Return -1 if no data to send, else send packet and return length */
568:
569: sdata() {
570: int len;
571: if (cxseen || czseen) return(-1); /* If interrupted, done. */
572: if ((len = getpkt(spsiz-bctu-3)) == 0) /* Done if no data. */
573: return(-1);
574: nxtpkt(&pktnum); /* Increment the packet number */
575: spack('D',pktnum,len,data); /* Send the packet */
576: return(len);
577: }
578:
579:
580: /* S E O F -- Send an End-Of-File packet */
581:
582: /* Call with a string pointer to character to put in the data field, */
583: /* or else a null pointer or "" for no data. */
584:
585: seof(s) char *s; {
586: nxtpkt(&pktnum); /* Increment the packet number */
587: if ((s != NULL) && (*s != '\0')) {
588: spack('Z',pktnum,1,s);
589: tlog(F100," *** interrupted, sending discard request","",0l);
590: } else {
591: spack('Z',pktnum,0,"");
592: fstats();
593: }
594: }
595:
596:
597: /* S E O T -- Send an End-Of-Transaction packet */
598:
599: seot() {
600: nxtpkt(&pktnum); /* Increment the packet number */
601: spack('B',pktnum,0,""); /* Send the EOT packet */
602: cxseen = czseen = 0; /* Reset interruption flags */
603: tstats(); /* Log timing info */
604: }
605:
606: /* R P A R -- Fill the data array with my send-init parameters */
607:
608: CHAR *
609: rpar() {
610: data[1] = tochar(rpsiz); /* Biggest packet I can receive */
611: data[2] = tochar(rtimo); /* When I want to be timed out */
612: data[3] = tochar(mypadn); /* How much padding I need (none) */
613: data[4] = ctl(mypadc); /* Padding character I want */
614: data[5] = tochar(eol); /* End-Of-Line character I want */
615: data[6] = '#'; /* Control-Quote character I send */
616: switch (rqf) { /* 8th-bit prefix */
617: case -1:
618: case 1: if (parity) ebq = sq = '&'; break;
619: case 0:
620: case 2: break;
621: }
622: data[7] = sq;
623: data[8] = bctr + '0'; /* Block check type */
624: if (rptflg) /* Run length encoding */
625: data[9] = rptq; /* If receiving, agree. */
626: else
627: data[9] = '~';
628:
629: data[10] = tochar(atcapr?atcapb:0 | lpcapr?lpcapb:0 | swcapr?swcapb:0);
630: data[capas+1] = tochar(swcapr ? wsize : 0); /* Window size */
631:
632: rpsiz = urpsiz; /* Long packets ... */
633: data[capas+2] = tochar(rpsiz / 95); /* Long packet size, big part */
634: data[capas+3] = tochar(rpsiz % 95); /* Long packet size, little part */
635: data[capas+4] = '\0'; /* Terminate the init string */
636: if (deblog) {
637: debug(F110,"rpar",data+1,0);
638: rdebu(capas+2);
639: }
640: return(data+1); /* Return pointer to string. */
641: }
642:
643: spar(s) char *s; { /* Set parameters */
644: int x, lpsiz;
645:
646: s--; /* Line up with field numbers. */
647:
648: debug(F101,"spar rln","",rln);
649:
650: /* Limit on size of outbound packets */
651: x = (rln >= 1) ? xunchar(s[1]) : 80;
652: lpsiz = spsiz; /* Remember what they SET. */
653: if (spsizf) { /* SET-command override? */
654: if (x < spsiz) spsiz = x; /* Ignore LEN unless smaller */
655: } else { /* otherwise */
656: spsiz = (x < 10) ? 80 : x; /* believe them if reasonable */
657: }
658:
659: /* Timeout on inbound packets */
660: if (!timef) { /* Only if not SET-cmd override */
661: x = (rln >= 2) ? xunchar(s[2]) : 5;
662: timint = (x < 0) ? 5 : x;
663: }
664:
665: /* Outbound Padding */
666: npad = 0; padch = '\0';
667: if (rln >= 3) {
668: npad = xunchar(s[3]);
669: if (rln >= 4) padch = ctl(s[4]); else padch = 0;
670: }
671:
672: /* Outbound Packet Terminator */
673: seol = (rln >= 5) ? xunchar(s[5]) : '\r';
674: if ((seol < 2) || (seol > 31)) seol = '\r';
675:
676: /* Control prefix */
677: x = (rln >= 6) ? s[6] : '#';
678: myctlq = ((x > 32 && x < 63) || (x > 95 && x < 127)) ? x : '#';
679:
680: /* 8th-bit prefix */
681: rq = (rln >= 7) ? s[7] : 0;
682: if (rq == 'Y') rqf = 1;
683: else if ((rq > 32 && rq < 63) || (rq > 95 && rq < 127)) rqf = 2;
684: else rqf = 0;
685: switch (rqf) {
686: case 0: ebqflg = 0; break;
687: case 1: if (parity) { ebqflg = 1; ebq = '&'; } break;
688: case 2: if (ebqflg = (ebq == sq || sq == 'Y')) ebq = rq;
689: }
690:
691: /* Block check */
692: x = 1;
693: if (rln >= 8) {
694: x = s[8] - '0';
695: if ((x < 1) || (x > 3)) x = 1;
696: }
697: bctr = x;
698:
699: /* Repeat prefix */
700: if (rln >= 9) {
701: rptq = s[9];
702: rptflg = ((rptq > 32 && rptq < 63) || (rptq > 95 && rptq < 127));
703: } else rptflg = 0;
704:
705: /* Capabilities */
706: atcapu = lpcapu = swcapu = 0;
707: if (rln >= 10) {
708: x = xunchar(s[10]);
709: atcapu = (x & atcapb) && atcapr;
710: lpcapu = (x & lpcapb) && lpcapr;
711: swcapu = (x & swcapb) && swcapb;
712: for (capas = 10; (xunchar(s[capas]) & 1) && (rln >= capas); capas++) ;
713: }
714:
715: /* Long Packets */
716: if (lpcapu) {
717: if (rln > capas+2) {
718: x = xunchar(s[capas+2]) * 95 + xunchar(s[capas+3]);
719: if (spsizf) { /* If overriding negotiations */
720: spsiz = (x < lpsiz) ? x : lpsiz; /* do this, */
721: } else { /* otherwise */
722: spsiz = (x > MAXSP) ? MAXSP : x; /* do this. */
723: }
724: if (spsiz < 10) spsiz = 80; /* Be defensive... */
725: }
726: }
727:
728: /* Sliding Windows */
729: if (swcapu) {
730: if (rln > capas+1) {
731: x = xunchar(s[capas+1]);
732: wsize = x > MAXWS ? MAXWS : x;
733: }
734: else wsize = 1;
735: }
736: if (deblog) sdebu(rln); /* Record parameters in debug log */
737: }
738:
739: /* G N F I L E -- Get the next file name from a file group. */
740:
741: /* Returns 1 if there's a next file, 0 otherwise */
742:
743: gnfile() {
744: int x; long y;
745: #ifdef datageneral
746: int dgfiles = 0; /* Number of files expanded */
747: static int dgnfils = -1; /* Saved nfils value */
748: #endif
749:
750: /* If file group interruption (C-Z) occured, fail. */
751:
752: debug(F101,"gnfile: czseen","",czseen);
753:
754: if (czseen) {
755: tlog(F100,"Transaction cancelled","",0l);
756: return(0);
757: }
758:
759: /* If input was stdin or memory string, there is no next file. */
760:
761: if (sndsrc == 0) return(0);
762:
763: /* If file list comes from command line args, get the next list element. */
764:
765: y = -1;
766: while (y < 0) { /* Keep trying till we get one... */
767:
768: if (sndsrc > 0) {
769: if (nfils-- > 0) {
770:
771: #ifdef datageneral
772: /* The DG does not internally expand the file names when a string of */
773: /* filenames is given. So we must in this case. */
774: if (dgnfils == -1) { /* This is executed first time only! */
775: strcpy(filnam,*cmlist++);
776: dgfiles = zxpand(filnam); /* Expand the string */
777: debug(F111,"gnfile:cmlist filnam (x-init)",filnam,dgfiles);
778: dgnfils = nfils + 1;
779: debug(F111,"gnfile:cmlist filnam (x-init)",filnam,dgnfils);
780: }
781: x = znext(filnam);
782: if (x > 0) { /* Get the next file in the expanded list */
783: debug(F111,"gnfile znext: filnam (exp-x=)",filnam,x);
784: nfils = dgnfils; /* The virtual number of files left */
785: }
786: if (x == 0) { /* Expand the next command argument */
787: if (dgnfils == 1) {
788: dgnfils = -1; /* The last argument resets things */
789: *filnam = '\0';
790: debug(F101,"gnfile cmlist: nfils","",nfils);
791: return(0);
792: }
793:
794: strcpy(filnam,*cmlist++); /* Finish expanding last arg */
795: dgfiles = zxpand(filnam); /* Expand the string */
796: debug(F111,"gnfile: cmlist filnam (exp)",filnam,dgnfils);
797: x = znext(filnam);
798: debug(F111,"gnfile znext: filnam (exp)",filnam,x);
799: nfils = dgnfils--;
800: }
801: #else
802: strcpy(filnam,*cmlist++);
803: debug(F111,"gnfile: cmlist filnam",filnam,nfils);
804: #endif
805: } else {
806: *filnam = '\0';
807: debug(F101,"gnfile cmlist: nfils","",nfils);
808: return(0);
809: }
810: }
811:
812: /* Otherwise, step to next element of internal wildcard expansion list. */
813:
814: if (sndsrc < 0) {
815: x = znext(filnam);
816: debug(F111,"gnfile znext: filnam",filnam,x);
817: if (x == 0) return(0);
818: }
819:
820: /* Get here with a filename. */
821:
822: y = zchki(filnam); /* Check if file readable */
823: if (y < 0) {
824: debug(F110,"gnfile skipping:",filnam,0);
825: tlog(F111,filnam,"not sent, reason",(long)y);
826: screen(SCR_ST,ST_SKIP,0l,filnam);
827: } else fsize = y;
828: }
829: return(1);
830: }
831:
832: /* O P E N I -- Open an existing file for input */
833:
834: openi(name) char *name; {
835: int x, filno;
836: if (memstr) return(1); /* Just return if file is memory. */
837:
838: debug(F110,"openi",name,0);
839: debug(F101," sndsrc","",sndsrc);
840:
841: filno = (sndsrc == 0) ? ZSTDIO : ZIFILE; /* ... */
842:
843: debug(F101," file number","",filno);
844:
845: if (zopeni(filno,name)) { /* Otherwise, try to open it. */
846: debug(F110," ok",name,0);
847: return(1);
848: } else { /* If not found, */
849: char xname[100]; /* convert the name */
850: zrtol(name,xname); /* to local form and then */
851: x = zopeni(filno,xname); /* try opening it again. */
852: debug(F101," zopeni","",x);
853: if (x) {
854: debug(F110," ok",xname,0);
855: return(1); /* It worked. */
856: } else {
857: screen(SCR_EM,0,0l,"Can't open file"); /* It didn't work. */
858: tlog(F110,xname,"could not be opened",0l);
859: debug(F110," openi failed",xname,0);
860: return(0);
861: }
862: }
863: }
864:
865: /* O P E N O -- Open a new file for output. */
866:
867: /* Returns actual name under which the file was opened in string 'name2'. */
868:
869: openo(name,name2) char *name, *name2; {
870: char xname[100], *xp;
871:
872: if (stdouf) /* Receiving to stdout? */
873: return(zopeno(ZSTDIO,""));
874:
875: debug(F110,"openo: name",name,0);
876:
877: if (cxseen || czseen) { /* If interrupted, get out before */
878: debug(F100," open cancelled","",0); /* destroying existing file. */
879: return(1); /* Pretend to succeed. */
880: }
881: xp = xname; /* OK to proceed. */
882: if (fncnv) /* If desired, */
883: zrtol(name,xp); /* convert name to local form */
884: else /* otherwise, */
885: strcpy(xname,name); /* use it literally */
886:
887: debug(F110,"openo: xname",xname,0);
888:
889: if (warn) { /* File collision avoidance? */
890: if (zchki(xname) != -1) { /* Yes, file exists? */
891: znewn(xname,&xp); /* Yes, make new name. */
892: strcpy(xname,xp);
893: debug(F110," exists, new name ",xname,0);
894: }
895: }
896: if (zopeno(ZOFILE,xname) == 0) { /* Try to open the file */
897: debug(F110,"openo failed",xname,0);
898: tlog(F110,"Failure to open",xname,0l);
899: return(0);
900: } else {
901: strcpy(name2,xname);
902: debug(F110,"openo ok, name2",name2,0);
903: return(1);
904: }
905: }
906:
907: /* O P E N T -- Open the terminal for output, in place of a file */
908:
909: opent() {
910: ffc = tfc = 0;
911: return(zopeno(ZCTERM,""));
912: }
913:
914: /* C L S I F -- Close the current input file. */
915:
916: clsif() {
917: #ifdef datageneral
918: if ((local) && (!quiet)) /* Only do this if local & not quiet */
919: if (nfils < 1) /* More files to send ... leave it on! */
920: connoi_mt();
921: #endif
922: if (memstr) { /* If input was memory string, */
923: memstr = 0; /* indicate no more. */
924: } else zclose(ZIFILE); /* else close input file. */
925:
926: if (czseen || cxseen)
927: screen(SCR_ST,ST_DISC,0l,"");
928: else
929: screen(SCR_ST,ST_OK,0l,"");
930: cxseen = hcflg = 0; /* Reset flags, */
931: *filnam = '\0'; /* and current file name */
932: }
933:
934:
935: /* C L S O F -- Close an output file. */
936:
937: /* Call with disp != 0 if file is to be discarded. */
938: /* Returns -1 upon failure to close, 0 or greater on success. */
939:
940: clsof(disp) int disp; {
941: int x;
942: #ifdef datageneral
943: if ((local) && (!quiet)) /* Only do this if local & not quiet */
944: connoi_mt();
945: #endif
946: if ((x = zclose(ZOFILE)) < 0) { /* Try to close the file */
947: tlog(F100,"Failure to close",filnam,0l);
948: screen(SCR_ST,ST_ERR,0l,"");
949: } else if (disp && (keep == 0)) { /* Delete it if interrupted, */
950: if (*filnam) zdelet(filnam); /* and not keeping incomplete files */
951: debug(F100,"Discarded","",0);
952: tlog(F100,"Discarded","",0l);
953: screen(SCR_ST,ST_DISC,0l,"");
954: } else { /* Nothing wrong, just keep it */
955: debug(F100,"Closed","",0); /* and give comforting messages. */
956: screen(SCR_ST,ST_OK,0l,"");
957: }
958: *filnam = '\0'; /* Zero the current file name. */
959: return(x); /* Send back zclose() return code. */
960: }
961:
962: /* S N D H L P -- Routine to send builtin help */
963:
964: sndhlp() {
965: nfils = 0; /* No files, no lists. */
966: xflg = 1; /* Flag we must send X packet. */
967: strcpy(cmdstr,"help text"); /* Data for X packet. */
968: first = 1; /* Init getchx lookahead */
969: memstr = 1; /* Just set the flag. */
970: memptr = hlptxt; /* And the pointer. */
971: if (binary) { /* If file mode is binary, */
972: binary = 0; /* turn it back to text for this, */
973: savmod = 1; /* remember to restore it later. */
974: }
975: return(sinit());
976: }
977:
978:
979: /* C W D -- Change current working directory */
980:
981: /*
982: String passed has first byte as length of directory name, rest of string
983: is name. Fails if can't connect, else ACKs (with name) and succeeds.
984: */
985:
986: cwd(vdir) char *vdir; {
987: char *cdd, *zgtdir();
988: vdir[xunchar(*vdir) + 1] = '\0'; /* End with a null */
989: if (zchdir(vdir+1)) {
990: cdd = zgtdir(); /* Get new working directory. */
991: encstr(cdd);
992: ack1(data);
993: tlog(F110,"Changed directory to",cdd,0l);
994: return(1);
995: } else {
996: tlog(F110,"Failed to change directory to",vdir+1,0l);
997: return(0);
998: }
999: }
1000:
1001:
1002: /* S Y S C M D -- Do a system command */
1003:
1004: /* Command string is formed by concatenating the two arguments. */
1005:
1006: syscmd(prefix,suffix) char *prefix, *suffix; {
1007: char *cp;
1008:
1009: if (prefix == NULL || *prefix == '\0') return(0);
1010:
1011: #ifdef datageneral
1012: /* A kludge for now -- the real change needs to be done elsewhere... */
1013: {
1014: extern char *WHOCMD;
1015: if ((strcmp(prefix,WHOCMD) == 0) && (*suffix == 0))
1016: strcpy(suffix,"[!pids]");
1017: }
1018: #endif
1019: for (cp = cmdstr; *prefix != '\0'; *cp++ = *prefix++) ;
1020: while (*cp++ = *suffix++) ;
1021:
1022: debug(F110,"syscmd",cmdstr,0);
1023: if (zopeni(ZSYSFN,cmdstr) > 0) {
1024: debug(F100,"syscmd zopeni ok",cmdstr,0);
1025: nfils = sndsrc = 0; /* Flag that input from stdin */
1026: xflg = hcflg = 1; /* And special flags for pipe */
1027: if (binary) { /* If file mode is binary, */
1028: binary = 0; /* turn it back to text for this, */
1029: savmod = 1; /* remember to restore it later. */
1030: }
1031: return (sinit()); /* Send S packet */
1032: } else {
1033: debug(F100,"syscmd zopeni failed",cmdstr,0);
1034: return(0);
1035: }
1036: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.