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