![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckcpro.w 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 ckcpro.w CVS log | Up to [MW Coherent from dump] / coherent / e / bin / cku179 |
1.1 root 1: char *protv = "C-Kermit Protocol Module 5A(043), 25 Dec 91"; /* -*-C-*- */
2:
3: /* C K C P R O -- C-Kermit Protocol Module, in Wart preprocessor notation. */
4: /*
5: Author: Frank da Cruz ([email protected], [email protected]),
6: Columbia University Center for Computing Activities.
7: First released January 1985.
8: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
9: York. Permission is granted to any individual or institution to use, copy, or
10: redistribute this software so long as it is not sold for profit, provided this
11: copyright notice is retained.
12: */
13: #include "ckcdeb.h"
14: #include "ckcasc.h"
15: #include "ckcker.h"
16: /*
17: Note -- This file may also be preprocessed by the Unix Lex program, but
18: you must indent the above #include statements before using Lex, and then
19: restore them to the left margin in the resulting C program before compilation.
20: Also, the invocation of the "wart()" function below must be replaced by an
21: invocation of the "yylex()" function. It might also be necessary to remove
22: comments in the %%...%% section.
23: */
24:
25: /* State definitions for Wart (or Lex) */
26: %states ipkt rfile rattr rdata ssinit ssfile ssattr ssdata sseof sseot
27: %states serve generic get rgen
28:
29: /* External C-Kermit variable declarations */
30: extern char *versio, *srvtxt, *cmarg, *cmarg2, **cmlist;
31: extern char filnam[], ttname[];
32: extern CHAR sstate, *rpar(), encbuf[], *srvptr, *data;
33: extern int timint, pkttim, nfils, hcflg, xflg, flow, mdmtyp, network;
34: extern int cxseen, czseen, server, srvdis, local, displa, bctu, bctr, quiet;
35: extern int tsecs, parity, backgrd, nakstate, atcapu, wslotn, winlo;
36: extern int wslots, success, xitsta, rprintf, discard, cdtimo, keep;
37: extern long speed;
38: extern char *DIRCMD, *DIRCM2, *DELCMD, *TYPCMD, *SPACMD, *SPACM2, *WHOCMD;
39: extern CHAR *rdatap;
40: extern struct zattr iattr;
41: #ifdef DYNAMIC
42: extern CHAR *srvcmd;
43: #else
44: extern CHAR srvcmd[];
45: #endif /* DYNAMIC */
46:
47: #ifndef NOSPL
48: extern int cmdlvl;
49: #else
50: extern int tlevel;
51: #endif /* NOSPL */
52:
53: #ifdef NOMSEND
54: extern int sndsrc;
55: #endif /* NOMSEND */
56:
57: /* Flags for the ENABLE and DISABLE commands */
58: extern int
59: en_cwd, en_del, en_dir, en_fin, en_get, en_bye,
60: en_hos, en_sen, en_spa, en_set, en_typ, en_who;
61:
62: /* Global variables declared here */
63:
64: int what = W_NOTHING; /* What we're doing */
65:
66: /* Local variables */
67:
68: static char vstate = 0; /* Saved State */
69: static char vcmd = 0; /* Saved Command */
70:
71: static int x; /* General-purpose integer */
72: static char *s; /* General-purpose string pointer */
73:
74: /* Macros - Note, BEGIN is predefined by Wart (and Lex) as "state = ", */
75: /* BEGIN is NOT a GOTO! */
76: #define TINIT if (tinit() < 0) return(-9)
77: #define SERVE TINIT; nakstate = 1; what = W_NOTHING; BEGIN serve
78: #define RESUME if (server) { SERVE; } else { sleep(2); return(0); }
79: #define QUIT x=quiet; quiet=1; clsif(); clsof(1); tsecs=gtimer(); quiet=x; \
80: return(1)
81:
82: %%
83: /* Protocol entry points, one for each start state (sstate) */
84: /* nakstate = 1 means we're in a receiving state, in which we can send NAKs */
85:
86: s { TINIT; /* Do Send command */
87: if (sinit()) BEGIN ssinit;
88: else RESUME; }
89:
90: v { TINIT; nakstate = 1; BEGIN get; } /* Receive */
91: r { TINIT; vstate = get; vcmd = 0; sipkt('I'); BEGIN ipkt; } /* Get */
92: c { TINIT; vstate = rgen; vcmd = 'C'; sipkt('I'); BEGIN ipkt; } /* Host */
93: k { TINIT; vstate = rgen; vcmd = 'K'; sipkt('I'); BEGIN ipkt; } /* Kermit */
94: g { TINIT; vstate = rgen; vcmd = 'G'; sipkt('I'); BEGIN ipkt; } /* Generic */
95:
96: x { sleep(1); SERVE; } /* Be a Server */
97:
98: a { if (!data) TINIT; /* "ABEND" -- Tell other side. */
99: errpkt((CHAR *)"User cancelled");
100: success = 0;
101: return(0); } /* Return from protocol. */
102:
103: /* Dynamic states: <current-states>input-character { action } */
104:
105: <rgen,get,serve>S { /* Receive Send-Init packet. */
106: if (state == serve && !en_sen) { /* Not allowed if in server mode */
107: errpkt((CHAR *)"SEND disabled"); /* and SEND is disabled. */
108: SERVE;
109: } else { /* OK to go ahead. */
110: nakstate = 1; /* Can send NAKs from here. */
111: rinit(rdatap); /* Set parameters */
112: bctu = bctr; /* Switch to agreed-upon block check */
113: timint = pkttim; /* Switch to per-packet timer */
114: chktimo(); /* Check & adjust timeout */
115: resetc(); /* Reset counters */
116: rtimer(); /* Reset timer */
117: what = W_RECV; /* Remember we're receiving */
118: BEGIN rfile; /* Go into receive-file state */
119: }
120: }
121:
122: /* States in which we get replies back from commands sent to a server. */
123: /* Complicated because direction of protocol changes, packet number */
124: /* stays at zero through I-G-S sequence, and complicated even more by */
125: /* sliding windows buffer allocation. */
126:
127: <ipkt>Y { /* Get ack for I-packet */
128: spar(rdatap); /* Set parameters */
129: #ifdef COMMENT
130: getsbuf(winlo = 0); /* Set window-low back to zero */
131: #else
132: winlo = 0;
133: #endif
134: if (vcmd) { /* If sending a generic command */
135: scmd(vcmd,(CHAR *)cmarg); /* Do that */
136: vcmd = 0; /* and then un-remember it. */
137: } else if (vstate == get) srinit(); /* If sending GET command, do that */
138: winlo = 0; /* Again! */
139: nakstate = 1; /* Can send NAKs from here. */
140: BEGIN vstate; /* Switch to desired state */
141: }
142:
143: <ipkt>E { /* Ignore Error reply to I packet */
144: #ifdef COMMENT
145: getsbuf(winlo = 0); /* Set window-low back to zero */
146: #else
147: winlo = 0;
148: #endif
149: if (vcmd) { /* in case other Kermit doesn't */
150: scmd(vcmd,(CHAR *)cmarg); /* understand I-packets. */
151: vcmd = 0; /* Otherwise act as above... */
152: } else if (vstate == get) srinit();
153: winlo = 0; /* Back to packet 0 again. */
154: freerpkt(winlo); /* Discard the Error packet. */
155: nakstate = 1; /* Can send NAKs from here. */
156: BEGIN vstate;
157: }
158:
159: <get>Y { /* Resend of previous I-pkt ACK, same seq number! */
160: srinit();
161: }
162:
163: /* States in which we're being a server */
164:
165: <serve>I { /* Get I-packet */
166: spar(rdatap); /* Set parameters from it */
167: ack1(rpar()); /* Respond with our own parameters */
168: pktinit(); /* Reinitialize packet numbers */
169: }
170:
171: <serve>R { /* Get Receive-Init (GET) */
172: debug(F100,"<serve>R","",0);
173: if (!en_get) { /* Only if not disabled! */
174: errpkt((CHAR *)"GET disabled");
175: SERVE;
176: } else { /* OK to go ahead. */
177: srvptr = srvcmd; /* Point to server command buffer */
178: decode(rdatap,putsrv,0); /* Decode the GET command into it */
179: /* Accept multiple filespecs */
180: cmarg2 = ""; /* Don't use cmarg2 */
181: cmarg = ""; /* Don't use cmarg */
182: #ifndef NOMSEND /* New way. */
183: nfils = fnparse((char *)srvcmd); /* Use cmlist instead */
184: #else
185: nfils = 0 - zxpand((char *)srvcmd);
186: #endif /* NOMSEND */
187: nakstate = 0; /* Now I'm the sender! */
188: if (sinit()) { /* Send Send-Init */
189: timint = pkttim; /* Switch to per-packet timer */
190: BEGIN ssinit; /* If successful, switch state */
191: } else { SERVE; } /* Else back to server command wait */
192: }
193: }
194:
195: <serve>G { /* Generic server command */
196: srvptr = srvcmd; /* Point to command buffer */
197: decode(rdatap,putsrv,0); /* Decode packet data into it */
198: putsrv('\0'); /* Insert a couple nulls */
199: putsrv('\0'); /* for termination */
200: if (srvcmd[0]) {
201: sstate = srvcmd[0]; /* Set requested start state */
202: nakstate = 0; /* Now I'm the sender. */
203: what = W_REMO; /* Doing a REMOTE command. */
204: timint = pkttim; /* Switch to per-packet timer */
205: BEGIN generic; /* Switch to generic command state */
206: } else {
207: errpkt((CHAR *)"Badly formed server command"); /* report error */
208: SERVE; /* & go back to server command wait */
209: }
210: }
211:
212: <serve>C { /* Receive Host command */
213: if (!en_hos) {
214: errpkt((CHAR *)"REMOTE HOST disabled");
215: SERVE;
216: } else {
217: srvptr = srvcmd; /* Point to command buffer */
218: decode(rdatap,putsrv,0); /* Decode command packet into it */
219: putsrv('\0'); /* Null-terminate */
220: nakstate = 0; /* Now sending, not receiving */
221: if (syscmd((char *)srvcmd,"")) { /* Try to execute the command */
222: what = W_REMO; /* Doing a REMOTE command. */
223: timint = pkttim; /* Switch to per-packet timer */
224: BEGIN ssinit; /* If OK, send back its output */
225: } else { /* Otherwise */
226: errpkt((CHAR *)"Can't do system command"); /* report error */
227: SERVE; /* & go back to server command wait */
228: }
229: }
230: }
231:
232: <serve>q { /* User typed Ctrl-C... */
233: if (!en_fin) {
234: errpkt((CHAR *)"QUIT disabled");
235: SERVE;
236: } else {
237: success = 0; QUIT;
238: }
239: }
240:
241: <serve>. { /* Any other command in this state */
242: errpkt((CHAR *)"Unimplemented server function"); /* we don't know about */
243: SERVE; /* back to server command wait */
244: }
245:
246: <generic>C { /* Got REMOTE CWD command */
247: if (!en_cwd) {
248: errpkt((CHAR *)"REMOTE CD disabled");
249: SERVE;
250: } else {
251: if (!cwd((char *)(srvcmd+1))) errpkt((CHAR *)"Can't change directory");
252: SERVE; /* Back to server command wait */
253: }
254: }
255:
256: <generic>D { /* REMOTE DIRECTORY command */
257: char *n2;
258: if (!en_dir) { /* If DIR is disabled, */
259: errpkt((CHAR *)"REMOTE DIRECTORY disabled"); /* refuse. */
260: SERVE;
261: } else { /* DIR is enabled. */
262: if (!en_cwd) { /* But if CWD is disabled */
263: zstrip((char *)(srvcmd+2),&n2); /* and they included a pathname, */
264: if (strcmp((char *)(srvcmd+2),n2)) { /* refuse. */
265: errpkt((CHAR *)"Access denied");
266: SERVE; /* Remember, this is not a goto! */
267: }
268: }
269: if (state == generic) { /* It's OK to go ahead. */
270: n2 = (*(srvcmd+2)) ? DIRCMD : DIRCM2;
271: if (syscmd(n2,(char *)(srvcmd+2))) /* If it can be done */
272: BEGIN ssinit; /* send the results back */
273: else { /* otherwise */
274: errpkt((CHAR *)"Can't list directory"); /* report failure, */
275: SERVE; /* return to server command wait */
276: }
277: }
278: }
279: }
280:
281: <generic>E { /* REMOTE DELETE (Erase) command */
282: char *n2;
283: if (!en_del) {
284: errpkt((CHAR *)"REMOTE DELETE disabled");
285: SERVE;
286: } else {
287: if (!en_cwd) { /* But if CWD is disabled */
288: zstrip((char *)(srvcmd+2),&n2); /* and they included a pathname, */
289: if (strcmp((char *)(srvcmd+2),n2)) { /* refuse. */
290: errpkt((CHAR *)"Access denied");
291: SERVE; /* Remember, this is not a goto! */
292: }
293: }
294: if (state == generic) { /* It's OK to go ahead. */
295: if (syscmd(DELCMD,(char *)(srvcmd+2))) /* Try to do it */
296: BEGIN ssinit; /* If OK send results back */
297: else { /* otherwise */
298: errpkt((CHAR *)"Can't remove file"); /* report failure */
299: SERVE; /* & return to server command wait */
300: }
301: }
302: }
303: }
304:
305: <generic>F { /* FINISH */
306: if (!en_fin) {
307: errpkt((CHAR *)"FINISH disabled");
308: SERVE;
309: } else {
310: ack(); /* Acknowledge */
311: screen(SCR_TC,0,0l,""); /* Display */
312: return(0); /* Done */
313: }
314: }
315:
316: <generic>L { /* BYE (LOGOUT) */
317: if (!en_bye) {
318: errpkt((CHAR *)"BYE disabled");
319: SERVE;
320: } else {
321: ack(); /* Acknowledge */
322: ttres(); /* Reset the terminal */
323: screen(SCR_TC,0,0l,""); /* Display */
324: doclean(); /* Clean up files, etc */
325: return(zkself()); /* Try to log self out */
326: }
327: }
328:
329: <generic>H { /* REMOTE HELP */
330: if (sndhlp()) BEGIN ssinit; /* Try to send it */
331: else { /* If not ok, */
332: errpkt((CHAR *)"Can't send help"); /* send error message instead */
333: SERVE; /* and return to server command wait */
334: }
335: }
336:
337: <generic>S { /* REMOTE SET */
338: if (!en_set) {
339: errpkt((CHAR *)"REMOTE SET disabled");
340: SERVE;
341: } else {
342: if (remset((char *)(srvcmd+1))) /* Try to do what they ask */
343: ack(); /* If OK, then acknowledge */
344: else /* Otherwise */
345: errpkt((CHAR *)"Unknown REMOTE SET parameter"); /* give error msg */
346: SERVE; /* Return to server command wait */
347: }
348: }
349:
350: <generic>T { /* REMOTE TYPE */
351: char *n2;
352: if (!en_typ) {
353: errpkt((CHAR *)"REMOTE TYPE disabled");
354: SERVE;
355: } else {
356: if (!en_cwd) { /* But if CWD is disabled */
357: zstrip((char *)(srvcmd+2),&n2); /* and they included a pathname, */
358: if (strcmp((char *)(srvcmd+2),n2)) { /* refuse. */
359: errpkt((CHAR *)"Access denied");
360: SERVE; /* Remember, this is not a goto! */
361: }
362: }
363: if (state == generic) { /* It's OK to go ahead. */
364: if (syscmd(TYPCMD,(char *)(srvcmd+2))) /* Try */
365: BEGIN ssinit; /* OK */
366: else { /* not OK */
367: errpkt((CHAR *)"Can't type file"); /* give error message */
368: SERVE; /* wait for next server command */
369: }
370: }
371: }
372: }
373:
374: <generic>U { /* REMOTE SPACE */
375: if (!en_spa) {
376: errpkt((CHAR *)"REMOTE SPACE disabled");
377: SERVE;
378: } else {
379: x = *(srvcmd+1); /* Get area to check */
380: x = ((x == '\0') || (x == SP));
381: if (!x && !en_cwd) { /* If CWD disabled and they gave */
382: errpkt((CHAR *)"Access denied"); /* a non-default area, */
383: SERVE; /* refuse. */
384: } else {
385: x = (x ? syscmd(SPACMD,"") : syscmd(SPACM2,(char *)(srvcmd+2)));
386: if (x) { /* If we got the info */
387: BEGIN ssinit; /* send it */
388: } else { /* otherwise */
389: errpkt((CHAR *)"Can't check space"); /* send error message */
390: SERVE; /* and await next server command */
391: }
392: }
393: }
394: }
395:
396: <generic>W { /* REMOTE WHO */
397: if (!en_who) {
398: errpkt((CHAR *)"REMOTE WHO disabled");
399: SERVE;
400: } else {
401: if (syscmd(WHOCMD,(char *)(srvcmd+2))) /* The now-familiar scenario. */
402: BEGIN ssinit;
403: else {
404: errpkt((CHAR *)"Can't do who command");
405: SERVE;
406: }
407: }
408: }
409:
410: <generic>q {
411: if (!en_fin) { /* Ctrl-C typed */
412: errpkt((CHAR *)"QUIT disabled");
413: SERVE;
414: } else {
415: success = 0; QUIT;
416: }
417: }
418:
419: <generic>. { /* Anything else in this state... */
420: errpkt((CHAR *)"Unimplemented REMOTE command"); /* Complain */
421: SERVE; /* and return to server command wait */
422: }
423:
424: <rgen>Y { /* Short-Form reply */
425: decode(rdatap,puttrm,0); /* in ACK Data field */
426: RESUME;
427: }
428:
429: <rgen,rfile>F { /* File header */
430: xflg = 0; /* Not screen data */
431: if (!rcvfil(filnam)) { /* Figure out local filename */
432: errpkt((CHAR *)"Can't transform filename"); /* Trouble */
433: RESUME;
434: } else { /* OK to receive */
435: encstr((CHAR *)filnam); /* Encode the name */
436: ack1((CHAR *)(encbuf+7)); /* Send it back in ACK */
437: initattr(&iattr); /* Clear file attribute structure */
438: window(wslotn); /* allocate negotiated window slots */
439: BEGIN rattr; /* Now expect Attribute packets */
440: }
441: }
442:
443: <rgen,rfile>X { /* X-packet instead of file header */
444: xflg = 1; /* Screen data */
445: ack(); /* Acknowledge the X-packet */
446: initattr(&iattr); /* Initialize attribute structure */
447: window(wslotn); /* allocate negotiated window slots */
448: what = W_REMO; /* we're doing a REMOTE command */
449: BEGIN rattr; /* Expect Attribute packets */
450: }
451:
452: <rattr>A { /* Attribute packet */
453: if (discard) { /* If SET FILE COLLISION DISCARD */
454: ack1((CHAR *)"N"); /* refuse it */
455: } else if (gattr(rdatap,&iattr) == 0) /* Read into attribute structure */
456: ack(); /* If OK, acknowledge */
457: else /* Otherwise */
458: ack1((CHAR *)iattr.reply.val); /* refuse to accept the file */
459: }
460:
461: <rattr>D { /* First data packet */
462: if (discard) { /* if we're discarding the file */
463: ack1((CHAR *)"X"); /* just ack the data like this. */
464: BEGIN rdata; /* and wait for more data packets. */
465: } else { /* Not discarding. */
466: if (xflg) /* If screen data */
467: x = opent(&iattr); /* "open" the screen */
468: else /* otherwise */
469: x = opena(filnam,&iattr); /* open the file, with attributes */
470: if (x) { /* If file was opened ok */
471: if (decode(rdatap,putfil,1) < 0) { /* decode first data packet */
472: errpkt((CHAR *)"Error writing data");
473: RESUME;
474: }
475: ack(); /* acknowledge it */
476: BEGIN rdata; /* and switch to receive-data state */
477: } else { /* otherwise */
478: errpkt((CHAR *)"Can't open file"); /* send error message */
479: RESUME; /* and quit. */
480: }
481: }
482: }
483:
484: <rfile>B { /* EOT, no more files */
485: ack(); /* Acknowledge */
486: tsecs = gtimer(); /* Get timing for statistics */
487: reot(); /* Do EOT things */
488: RESUME; /* and quit */
489: }
490:
491: <rdata>D { /* Data packet */
492: if (cxseen || discard) /* If file interrupt */
493: ack1((CHAR *)"X"); /* put "X" in ACK */
494: else if (czseen) /* If file-group interrupt */
495: ack1((CHAR *)"Z"); /* put "Z" in ACK */
496: else if (decode(rdatap,putfil,1) < 0) { /* Normal case, decode to file */
497: errpkt((CHAR *)"Error writing data"); /* If failure, */
498: clsof(!keep); /* Close & keep/discard the file */
499: RESUME; /* Send ACK only after data */
500: } else ack(); /* written to file OK. */
501: }
502:
503: <rattr>Z { /* EOF immediately after A-Packet. */
504: if (xflg) /* Zero-length file. If screen data */
505: x = opent(&iattr); /* "open" the screen */
506: else /* otherwise */
507: x = opena(filnam,&iattr); /* open the file, with attributes. */
508: if (!x || reof(filnam, &iattr) < 0) { /* Now close & dispose of the file */
509: errpkt((CHAR *)"Can't create file"); /* If problem, send error msg */
510: RESUME; /* and quit */
511: } else { /* otherwise */
512: ack(); /* acknowledge the EOF packet */
513: success = 1;
514: BEGIN rfile; /* and await another file */
515: }
516: }
517:
518: <rdata>Z { /* End Of File (EOF) Packet */
519: /* wslots = 1; */ /* Window size back to 1 */
520: if (discard) { /* If discarding, there's no file */
521: discard = 0; /* to close, just reset the discard */
522: ack(); /* flag, ack, and proceed normally. */
523: success = 1; /* Count this as a success. */
524: BEGIN rfile;
525: } else
526: #ifndef COHERENT
527: /*
528: Coherent compiler blows up on this switch() statement.
529: */
530: switch (x = reof(filnam, &iattr)) {
531: case -3: /* If problem, send error msg */
532: errpkt((CHAR *)"Can't print file");
533: RESUME;
534: break;
535: case -2:
536: errpkt((CHAR *)"Can't mail file");
537: RESUME;
538: break;
539: case 2:
540: case 3:
541: errpkt((CHAR *)"Can't delete temp file");
542: RESUME;
543: break;
544: default:
545: if (x < 0) {
546: errpkt((CHAR *)"Can't close file");
547: RESUME;
548: } else { /* Success */
549: success = 1;
550: ack(); /* Acknowledge the EOF packet */
551: BEGIN rfile; /* and await another file */
552: }
553: }
554: #else
555: if (reof(filnam, &iattr) < 0) { /* Close and dispose of the file */
556: errpkt((CHAR *)"Error at end of file");
557: RESUME;
558: } else {
559: ack();
560: success = 1;
561: BEGIN rfile;
562: }
563: #endif /* COHERENT */
564: }
565:
566: <ssinit>Y { /* ACK for Send-Init */
567: spar(rdatap); /* set parameters from it */
568: bctu = bctr; /* switch to agreed-upon block check */
569: what = W_SEND; /* Remember we're sending */
570: x = sfile(xflg); /* Send X or F header packet */
571: if (x) { /* If the packet was sent OK */
572: resetc(); /* reset per-transaction counters */
573: rtimer(); /* reset timers */
574: chktimo(); /* Check & adjust timeout */
575: BEGIN ssfile; /* and switch to receive-file state */
576: } else { /* otherwise send error msg & quit */
577: s = xflg ? "Can't execute command" : "Can't open file";
578: errpkt((CHAR *)s);
579: RESUME;
580: }
581: }
582:
583: /*
584: These states are necessary to handle the case where we get a server command
585: packet (R, G, or C) reply with an S packet, but the client retransmits the
586: command packet. The input() function doesn't catch this because the packet
587: number is still zero.
588: */
589: <ssinit>R { /* R packet was retransmitted. */
590: xsinit(); /* Resend packet 0 */
591: }
592:
593: <ssinit>G { /* Same deal if G packet comes again */
594: xsinit();
595: }
596:
597: <ssinit>C { /* Same deal if C packet comes again */
598: xsinit();
599: }
600:
601: <ssfile>Y { /* ACK for F packet */
602: srvptr = srvcmd; /* Point to string buffer */
603: decode(rdatap,putsrv,0); /* Decode data field, if any */
604: putsrv('\0'); /* Terminate with null */
605: if (*srvcmd) /* If remote name was recorded */
606: tlog(F110," stored as",(char *) srvcmd,0L); /* Log in transaction log. */
607: if (atcapu) { /* If attributes are to be used */
608: if (sattr(xflg) < 0) { /* set and send them */
609: errpkt((CHAR *)"Can't send attributes"); /* if problem, say so */
610: RESUME; /* and quit */
611: } else BEGIN ssattr; /* if ok, switch to attribute state */
612: } else {
613: window(wslotn);
614: if (sdata() < 0) { /* No attributes, send data */
615: clsif(); /* If not ok, close input file, */
616: window(wslots = 1); /* put window size back to 1, */
617: seof((CHAR *)""); /* send EOF packet, */
618: BEGIN sseof; /* and switch to EOF state. */
619: } else BEGIN ssdata; /* All ok, switch to send-data state */
620: }
621: }
622:
623: <ssattr>Y { /* Got ACK to A packet */
624: if (rsattr(rdatap) < 0) { /* Was the file refused? */
625: clsif(); /* yes, close it */
626: sxeof((CHAR *)"D"); /* send EOF with "discard" code */
627: BEGIN sseof; /* switch to send-EOF state */
628: } else {
629: window(wslotn); /* Allocate negotiated window. */
630: if (sdata() < 0) { /* File accepted, send data */
631: clsif(); /* If problem, close input file */
632: window(wslots = 1); /* Window size back to 1... */
633: seof((CHAR *)""); /* send EOF packet */
634: BEGIN sseof; /* and switch to send-EOF state. */
635: } else { /* All ok, enter send-data state. */
636: BEGIN ssdata;
637: }
638: }
639: }
640:
641: <ssdata>Y { /* Got ACK to Data packet */
642: canned(rdatap); /* Check if file transfer cancelled */
643: if (sdata() < 0) { /* Try to send next data */
644: clsif(); /* If no more data, close file */
645: window(wslots = 1); /* Window size back to 1... */
646: if (cxseen || czseen) /* If interrupted */
647: seof((CHAR *)"D"); /* send special EOF packet */
648: else seof((CHAR *)""); /* Otherwise regular EOF packet */
649: BEGIN sseof; /* And enter send-eof state */
650: }
651: }
652:
653: <sseof>Y { /* Got ACK to EOF */
654: success = (cxseen == 0 && czseen == 0); /* Set this for IF command */
655: cxseen = 0; /* This goes back to zero. */
656: if (gnfile() > 0) { /* Any more files to send? */
657: if (sfile(xflg)) /* Yes, try to send next file header */
658: BEGIN ssfile; /* if ok, enter send-file state */
659: else { /* otherwise */
660: errpkt((CHAR *)"Can't open file"); /* send error message */
661: RESUME; /* and quit */
662: }
663: } else { /* No next file */
664: tsecs = gtimer(); /* get statistics timers */
665: seot(); /* send EOT packet */
666: BEGIN sseot; /* enter send-eot state */
667: }
668: }
669:
670: <sseot>Y { /* Got ACK to EOT */
671: RESUME; /* All done, just quit */
672: }
673:
674: E { /* Got Error packet, in any state */
675: ermsg((char *)rdatap); /* Issue message. */
676: success = 0; /* For IF SUCCESS/FAIL. */
677: debug(F101,"ckcpro.w sstate at E pkt","",sstate);
678: x = quiet; quiet = 1; /* Close files silently, */
679: clsif(); clsof(1); /* discarding any output file. */
680: tsecs = gtimer(); /* Get timers */
681: quiet = x; /* restore quiet state */
682: if (backgrd && !server) fatal("Protocol error");
683: xitsta |= what; /* Save this for doexit(). */
684: RESUME;
685: }
686:
687: q { QUIT; } /* Ctrl-C interrupt during packets. */
688:
689: . { /* Anything not accounted for above */
690: errpkt((CHAR *)"Unexpected packet type"); /* Give error message */
691: xitsta |= what; /* Save this for doexit(). */
692: RESUME; /* and quit */
693: }
694: %%
695:
696: /* P R O T O -- Protocol entry function */
697:
698: VOID
699: proto() {
700:
701: int x;
702: long lx;
703:
704: /* Set up the communication line for file transfer. */
705:
706: if (local && (speed < 0L) && (network == 0)) {
707: screen(SCR_EM,0,0l,"Sorry, you must 'set speed' first");
708: return;
709: }
710: x = -1;
711: if (ttopen(ttname,&x,mdmtyp,cdtimo) < 0) {
712: debug(F111,"failed: proto ttopen local",ttname,local);
713: screen(SCR_EM,0,0l,"Can't open line");
714: return;
715: }
716: if (x > -1) local = x;
717: debug(F111,"proto ttopen local",ttname,local);
718:
719: lx = (local && !network) ? speed : -1;
720: if (ttpkt(lx,flow,parity) < 0) { /* Put line in packet mode, */
721: screen(SCR_EM,0,0l,"Can't condition line");
722: return;
723: }
724: if (!local) connoi(); /* No console interrupts if remote */
725:
726: if (sstate == 'x') { /* If entering server mode, */
727: server = 1; /* set flag, */
728: debug(F101,"server backgrd","",backgrd);
729: debug(F101,"server quiet","",quiet);
730: if (!quiet && !backgrd) {
731: debug(F100,"SHOULD NOT SEE THIS IF IN BACKGROUND!","",0);
732: if (!local) /* and issue appropriate message. */
733: conol(srvtxt);
734: else {
735: conol("Entering server mode on ");
736: conoll(ttname);
737: conoll("Type Ctrl-C to quit.");
738: if (srvdis) intmsg(-1L);
739: }
740: }
741: } else server = 0;
742: #ifdef VMS
743: if (!quiet && !backgrd) /* So message doesn't overwrite prompt */
744: conoll("");
745: if (local) conres(); /* So Ctrl-C will work */
746: #endif /* VMS */
747: if (sstate == 'v' && !local && !quiet && !backgrd &&
748: #ifndef NOSPL
749: cmdlvl == 0
750: #else
751: tlevel < 0
752: #endif /* NOSPL */
753: )
754: conoll("Escape back to your local Kermit and give a SEND command...");
755: if (sstate == 's' && !local && !quiet && !backgrd &&
756: #ifndef NOSPL
757: cmdlvl == 0
758: #else
759: tlevel < 0
760: #endif /* NOSPL */
761: )
762: conoll("Escape back to your local Kermit and give a RECEIVE command...");
763: sleep(1);
764: /*
765: The 'wart()' function is generated by the wart program. It gets a
766: character from the input() routine and then based on that character and
767: the current state, selects the appropriate action, according to the state
768: table above, which is transformed by the wart program into a big case
769: statement. The function is active for one transaction.
770: */
771: wart(); /* Enter the state table switcher. */
772:
773: if (server) { /* Back from packet protocol. */
774: server = 0;
775: if (!quiet && !backgrd) { /* Give appropriate message */
776: conoll("");
777: conoll("C-Kermit server done");
778: }
779: }
780: /*
781: Note: the following is necessary in case we have just done a remote-mode
782: file transfer, in which case the controlling terminal modes have been
783: changed by ttpkt(). In particular, special characters like Ctrl-C and
784: Ctrl-\ might have been turned off (see ttpkt). So this call to ttres() is
785: essential.
786: */
787: if (!local) ttres(); /* Reset the terminal */
788: screen(SCR_TC,0,0l,""); /* Transaction complete */
789: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.