![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckuusr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / kermit|
Return to ckuusr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / kermit |
1.1 root 1: char *userv = "User Interface 4C(052), 2 Aug 85";
2:
3: /* C K U U S R -- "User Interface" for Unix Kermit (Part 1) */
4:
5: /*
6: Author: Frank da Cruz (SY.FDC@CU20B),
7: Columbia University Center for Computing Activities, January 1985.
8: Copyright (C) 1985, Trustees of Columbia University in the City of New York.
9: 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:
14: /*
15: The ckuser module contains the terminal input and output functions for Unix
16: Kermit. It includes a simple Unix-style command line parser as well as
17: an interactive prompting keyword command parser. It depends on the existence
18: of Unix facilities like fopen, fgets, feof, (f)printf, argv/argc, etc. Other
19: functions that are likely to vary among Unix implementations -- like setting
20: terminal modes or interrupts -- are invoked via calls to functions that are
21: defined in the system-dependent modules, ck?[ft]io.c.
22:
23: The command line parser processes any arguments found on the command line,
24: as passed to main() via argv/argc. The interactive parser uses the facilities
25: of the cmd package (developed for this program, but usable by any program).
26:
27: Any command parser may be substituted for this one. The only requirements
28: for the Kermit command parser are these:
29:
30: 1. Set parameters via global variables like duplex, speed, ttname, etc.
31: See ckmain.c for the declarations and descriptions of these variables.
32:
33: 2. If a command can be executed without the use of Kermit protocol, then
34: execute the command directly and set the variable sstate to 0. Examples
35: include 'set' commands, local directory listings, the 'connect' command.
36:
37: 3. If a command requires the Kermit protocol, set the following variables:
38:
39: sstate string data
40: 'x' (enter server mode) (none)
41: 'r' (send a 'get' command) cmarg, cmarg2
42: 'v' (enter receive mode) cmarg2
43: 'g' (send a generic command) cmarg
44: 's' (send files) nfils, cmarg & cmarg2 OR cmlist
45: 'c' (send a remote host command) cmarg
46:
47: cmlist is an array of pointers to strings.
48: cmarg, cmarg2 are pointers to strings.
49: nfils is an integer.
50:
51: cmarg can be a filename string (possibly wild), or
52: a pointer to a prefabricated generic command string, or
53: a pointer to a host command string.
54: cmarg2 is the name to send a single file under, or
55: the name under which to store an incoming file; must not be wild.
56: cmlist is a list of nonwild filenames, such as passed via argv.
57: nfils is an integer, interpreted as follows:
58: -1: argument string is in cmarg, and should be expanded internally.
59: 0: stdin.
60: >0: number of files to send, from cmlist.
61:
62: The screen() function is used to update the screen during file transfer.
63: The tlog() function maintains a transaction log.
64: The debug() function maintains a debugging log.
65: The intmsg() and chkint() functions provide the user i/o for interrupting
66: file transfers.
67: */
68:
69: /* Includes */
70:
71: #include "ckcdeb.h"
72: #include <stdio.h>
73: #include <ctype.h>
74: #include <signal.h>
75: #include "ckcker.h"
76: #include "ckucmd.h"
77: #include "ckuusr.h"
78:
79: #ifdef vax11c
80: #define KERMRC "kermit.ini"
81: #else
82: #define KERMRC ".kermrc"
83: #endif
84:
85: /* External Kermit Variables, see ckmain.c for description. */
86:
87: extern int size, spsiz, rpsiz, npad, timint, rtimo, speed, local, server,
88: displa, binary, fncnv, delay, parity, deblog, escape, xargc, flow,
89: turn, duplex, cxseen, czseen, nfils, ckxech, pktlog, seslog, tralog, stdouf,
90: turnch, chklen, bctr, bctu, dfloc, mdmtyp, keep,
91: rptflg, rptq, ebqflg, ebq, warn, quiet, cnflg, timef, spsizf, mypadn, tsecs;
92:
93: extern long filcnt, tlci, tlco, ffc, tfc, fsize;
94:
95: extern char *versio, *protv, *ckxv, *ckzv, *fnsv, *connv, *dftty, *cmdv;
96: extern char *dialv, *loginv;
97: extern char *ckxsys, *ckzsys, *cmarg, *cmarg2, **xargv, **cmlist;
98: extern CHAR mystch, stchr, sstate, mypadc, padch, eol, seol, ctlq, filnam[],
99: ttname[];
100: extern char *DIRCMD, *PWDCMD, cmerrp[];
101: char *strcpy(), *getenv();
102:
103: /* Declarations from cmd package */
104:
105: extern char cmdbuf[]; /* Command buffer */
106:
107: /* Declarations from ck?fio.c module */
108:
109: extern char *SPACMD, *zhome(); /* Space command, home directory. */
110: extern int backgrd; /* Kermit executing in background */
111:
112: /* The background flag is set by ckutio.c (via conint() ) to note whether */
113: /* this kermit is executing in background ('&' on shell command line). */
114:
115:
116: /* Variables and symbols local to this module */
117:
118: char line[CMDBL+10], *lp; /* Character buffer for anything */
119: char debfil[50]; /* Debugging log file name */
120: char pktfil[50]; /* Packet log file name */
121: char sesfil[50]; /* Session log file name */
122: char trafil[50]; /* Transaction log file name */
123:
124: int n, /* General purpose int */
125: cflg, /* Command-line connect cmd given */
126: action, /* Action selected on command line*/
127: repars, /* Reparse needed */
128: tlevel, /* Take command level */
129: cwdf = 0; /* CWD has been done */
130:
131: #define MAXTAKE 20 /* Maximum nesting of TAKE files */
132: FILE *tfile[MAXTAKE]; /* File pointers for TAKE command */
133:
134: char *homdir; /* Pointer to home directory string */
135: char cmdstr[100];
136:
137: /* C M D L I N -- Get arguments from command line */
138: /*
139: Simple Unix-style command line parser, conforming with 'A Proposed Command
140: Syntax Standard for Unix Systems', Hemenway & Armitage, Unix/World, Vol.1,
141: No.3, 1984.
142: */
143: cmdlin() {
144: char x; /* Local general-purpose int */
145: cmarg = ""; /* Initialize globals */
146: cmarg2 = "";
147: action = cflg = 0;
148:
149: while (--xargc > 0) { /* Go through command line words */
150: xargv++;
151: debug(F111,"xargv",*xargv,xargc);
152: if (**xargv == '-') { /* Got an option (begins with dash) */
153: x = *(*xargv+1); /* Get the option letter */
154: x = doarg(x); /* Go handle the option */
155: if (x < 0) exit(GOOD_EXIT);
156: } else { /* No dash where expected */
157: usage();
158: exit(BAD_EXIT);
159: }
160: }
161: debug(F101,"action","",action);
162: if (!local) {
163: if ((action == 'g') || (action == 'r') ||
164: (action == 'c') || (cflg != 0))
165: fatal("-l and -b required");
166: }
167: if (*cmarg2 != 0) {
168: if ((action != 's') && (action != 'r') &&
169: (action != 'v'))
170: fatal("-a without -s, -r, or -g");
171: }
172: if ((action == 'v') && (stdouf) && (!local)) {
173: if (isatty(1))
174: fatal("unredirected -k can only be used in local mode");
175: }
176: if ((action == 's') || (action == 'v') ||
177: (action == 'r') || (action == 'x')) {
178: if (local) displa = 1;
179: if (stdouf) displa = 0;
180: }
181:
182: if (quiet) displa = 0; /* No display if quiet requested */
183:
184: if (cflg) {
185: conect(); /* Connect if requested */
186: if (action == 0) {
187: if (cnflg) conect(); /* And again if requested */
188: doexit(GOOD_EXIT); /* Then exit indicating success */
189: }
190: }
191: if (displa) concb(escape); /* (for console "interrupts") */
192: return(action); /* Then do any requested protocol */
193: }
194:
195: /* D O A R G -- Do a command-line argument. */
196:
197: doarg(x) char x; {
198: int z; char *xp;
199:
200: xp = *xargv+1; /* Pointer for bundled args */
201: while (x) {
202: switch (x) {
203:
204: case 'x': /* server */
205: if (action) fatal("conflicting actions");
206: action = 'x';
207: break;
208:
209: case 'f':
210: if (action) fatal("conflicting actions");
211: action = setgen('F',"","","");
212: break;
213:
214: case 'r': /* receive */
215: if (action) fatal("conflicting actions");
216: action = 'v';
217: break;
218:
219: case 'k': /* receive to stdout */
220: if (action) fatal("conflicting actions");
221: stdouf = 1;
222: action = 'v';
223: break;
224:
225: case 's': /* send */
226: if (action) fatal("conflicting actions");
227: if (*(xp+1)) fatal("invalid argument bundling after -s");
228: z = nfils = 0; /* Initialize file counter, flag */
229: cmlist = xargv+1; /* Remember this pointer */
230: while (--xargc > 0) { /* Traverse the list */
231: *xargv++;
232: if (**xargv == '-') { /* Check for sending stdin */
233: if (strcmp(*xargv,"-") != 0) break;
234: z++;
235: }
236: nfils++; /* Bump file counter */
237: }
238: xargc++, *xargv--; /* Adjust argv/argc */
239: if (nfils < 1) fatal("missing filename for -s");
240: if (z > 1) fatal("-s: too many -'s");
241: if (z == 1) {
242: if (nfils == 1) nfils = 0;
243: else fatal("invalid mixture of filenames and '-' in -s");
244: }
245: if (nfils == 0) {
246: if (isatty(0)) fatal("sending from terminal not allowed");
247: }
248: debug(F101,*xargv,"",nfils);
249: action = 's';
250: break;
251:
252: /* cont'd... */
253:
254: /* ...doarg(), cont'd */
255:
256: case 'g': /* get */
257: if (action) fatal("conflicting actions");
258: if (*(xp+1)) fatal("invalid argument bundling after -g");
259: *xargv++, xargc--;
260: if ((xargc == 0) || (**xargv == '-'))
261: fatal("missing filename for -g");
262: cmarg = *xargv;
263: action = 'r';
264: break;
265:
266: case 'c': /* connect before */
267: cflg = 1;
268: break;
269:
270: case 'n': /* connect after */
271: cnflg = 1;
272: break;
273:
274: case 'h': /* help */
275: usage();
276: return(-1);
277:
278: case 'a': /* "as" */
279: if (*(xp+1)) fatal("invalid argument bundling after -a");
280: *xargv++, xargc--;
281: if ((xargc < 1) || (**xargv == '-'))
282: fatal("missing name in -a");
283: cmarg2 = *xargv;
284: break;
285:
286: case 'l': /* set line */
287: if (*(xp+1)) fatal("invalid argument bundling after -l");
288: *xargv++, xargc--;
289: if ((xargc < 1) || (**xargv == '-'))
290: fatal("communication line device name missing");
291: strcpy(ttname,*xargv);
292: /* if (strcmp(ttname,dftty) == 0) local = dfloc; else local = 1; */
293: local = (strcmp(ttname,CTTNAM) != 0); /* (better than old way) */
294: debug(F101,"local","",local);
295: ttopen(ttname,&local,0);
296: break;
297:
298: case 'b': /* set baud */
299: if (*(xp+1)) fatal("invalid argument bundling");
300: *xargv++, xargc--;
301: if ((xargc < 1) || (**xargv == '-'))
302: fatal("missing baud");
303: z = atoi(*xargv); /* Convert to number */
304: if (chkspd(z) > -1) speed = z; /* Check it */
305: else fatal("unsupported baud rate");
306: break;
307:
308: case 'i': /* Treat files as binary */
309: binary = 1;
310: break;
311:
312: /* cont'd... */
313:
314: /* ...doarg(), cont'd */
315:
316:
317: case 'w': /* File warning */
318: warn = 1;
319: break;
320:
321: case 'q': /* Quiet */
322: quiet = 1;
323: break;
324:
325: case 'd': /* debug */
326: debopn("debug.log");
327: break;
328:
329: case 'p': /* set parity */
330: if (*(xp+1)) fatal("invalid argument bundling");
331: *xargv++, xargc--;
332: if ((xargc < 1) || (**xargv == '-'))
333: fatal("missing parity");
334: switch(x = **xargv) {
335: case 'e':
336: case 'o':
337: case 'm':
338: case 's': parity = x; break;
339: case 'n': parity = 0; break;
340: default: fatal("invalid parity");
341: }
342: break;
343:
344: case 't':
345: turn = 1; /* Line turnaround handshake */
346: turnch = XON; /* XON is turnaround character */
347: duplex = 1; /* Half duplex */
348: flow = 0; /* No flow control */
349: break;
350:
351: default:
352: fatal("invalid argument, type 'kermit -h' for help");
353: }
354:
355: x = *++xp; /* See if options are bundled */
356: }
357: return(0);
358: }
359:
360: /* Misc */
361:
362: fatal(msg) char *msg; { /* Fatal error message */
363: fprintf(stderr,"\r\nFatal: %s\n",msg);
364: tlog(F110,"Fatal:",msg,0l);
365: doexit(BAD_EXIT); /* Exit indicating failure */
366: }
367:
368:
369: ermsg(msg) char *msg; { /* Print error message */
370: if (!quiet) fprintf(stderr,"\r\n%s - %s\n",cmerrp,msg);
371: tlog(F110,"Error -",msg,0l);
372: }
373:
374: /* Interactive command parser */
375:
376:
377: /* Top-Level Keyword Table */
378:
379: struct keytab cmdtab[] = {
380: "!", XXSHE, 0,
381: "%", XXCOM, CM_INV,
382: "bye", XXBYE, 0,
383: "c", XXCON, CM_INV,
384: "close", XXCLO, 0,
385: "connect", XXCON, 0,
386: "cwd", XXCWD, 0,
387: "dial", XXDIAL, 0,
388: "directory", XXDIR, 0,
389: "echo", XXECH, 0,
390: "exit", XXEXI, 0,
391: "finish", XXFIN, 0,
392: "get", XXGET, 0,
393: "help", XXHLP, 0,
394: "log", XXLOG, 0,
395: "quit", XXQUI, 0,
396: "r", XXREC, CM_INV,
397: "receive", XXREC, 0,
398: "remote", XXREM, 0,
399: "s", XXSEN, CM_INV,
400: "script", XXLOGI, 0,
401: "send", XXSEN, 0,
402: "server", XXSER, 0,
403: "set", XXSET, 0,
404: "show", XXSHO, 0,
405: "space", XXSPA, 0,
406: "statistics", XXSTA, 0,
407: "take", XXTAK, 0
408: };
409: int ncmd = (sizeof(cmdtab) / sizeof(struct keytab));
410:
411: /* Parameter keyword table */
412:
413: struct keytab prmtab[] = {
414: "baud", XYSPEE, CM_INV,
415: "block-check", XYCHKT, 0,
416: "delay", XYDELA, 0,
417: "duplex", XYDUPL, 0,
418: "end-of-packet", XYEOL, CM_INV, /* moved to send/receive */
419: "escape-character", XYESC, 0,
420: "file", XYFILE, 0,
421: "flow-control", XYFLOW, 0,
422: "handshake", XYHAND, 0,
423: "incomplete", XYIFD, 0,
424: "line", XYLINE, 0,
425: "modem-dialer", XYMODM, 0,
426: "packet-length", XYLEN, CM_INV, /* moved to send/receive */
427: "pad-character", XYPADC, CM_INV, /* moved to send/receive */
428: "padding", XYNPAD, CM_INV, /* moved to send/receive */
429: "parity", XYPARI, 0,
430: "prompt", XYPROM, 0,
431: "receive", XYRECV, 0,
432: "send", XYSEND, 0,
433: "speed", XYSPEE, 0,
434: "start-of-packet", XYMARK, CM_INV, /* moved to send/receive */
435: "timeout", XYTIMO, CM_INV /* moved to send/receive */
436: };
437: int nprm = (sizeof(prmtab) / sizeof(struct keytab)); /* How many parameters */
438:
439:
440: /* Remote Command Table */
441:
442: struct keytab remcmd[] = {
443: "cwd", XZCWD, 0,
444: "delete", XZDEL, 0,
445: "directory", XZDIR, 0,
446: "help", XZHLP, 0,
447: "host", XZHOS, 0,
448: "space", XZSPA, 0,
449: "type", XZTYP, 0,
450: "who", XZWHO, 0
451: };
452: int nrmt = (sizeof(remcmd) / sizeof(struct keytab));
453:
454: struct keytab logtab[] = {
455: "debugging", LOGD, 0,
456: "packets", LOGP, 0,
457: "session", LOGS, 0,
458: "transactions", LOGT, 0
459: };
460: int nlog = (sizeof(logtab) / sizeof(struct keytab));
461:
462: /* Show command arguments */
463:
464: #define SHPAR 0 /* Parameters */
465: #define SHVER 1 /* Versions */
466:
467: struct keytab shotab[] = {
468: "parameters", SHPAR, 0,
469: "versions", SHVER, 0
470: };
471:
472: /* C M D I N I -- Initialize the interactive command parser */
473:
474: cmdini() {
475:
476: printf("%s,%s\nType ? for help\n",versio,ckxsys);
477: cmsetp("C-Kermit>"); /* Set default prompt. */
478:
479: tlevel = -1; /* Take file level */
480:
481: /* Look for init file in home or current directory. */
482:
483: homdir = zhome();
484: lp = line;
485: lp[0] = '\0';
486: if (homdir) {
487: strcpy(lp,homdir);
488: if (lp[0] == '/') strcat(lp,"/");
489: }
490: strcat(lp,KERMRC);
491: if ((tfile[0] = fopen(line,"r")) != NULL) {
492: tlevel = 0;
493: debug(F110,"init file",line,0);
494: }
495: if (homdir && (tlevel < 0)) {
496: strcpy(lp,KERMRC);
497: if ((tfile[0] = fopen(line,"r")) != NULL) {
498: tlevel = 0;
499: debug(F110,"init file",line,0);
500: } else {
501: debug(F100,"no init file","",0);
502: }
503: }
504:
505: congm(); /* Get console tty modes */
506: }
507:
508:
509: /* T R A P -- Terminal interrupt handler */
510:
511: trap() {
512: debug(F100,"terminal interrupt...","",0);
513: doexit(GOOD_EXIT); /* Exit indicating success */
514: }
515:
516: /* P A R S E R -- Top-level interactive command parser. */
517:
518: parser() {
519: int xx, cbn;
520: char *cbp;
521:
522: concb(escape); /* Put console in cbreak mode. */
523: conint(trap); /* Turn on console terminal interrupts. */
524: /*
525: sstate becomes nonzero when a command has been parsed that requires some
526: action from the protocol module. Any non-protocol actions, such as local
527: directory listing or terminal emulation, are invoked directly from below.
528: */
529: if (local) printf("\n"); /*** Temporary kludge ***/
530: sstate = 0; /* Start with no start state. */
531: while (sstate == 0) { /* Parse cmds until action requested */
532: while ((tlevel > -1) && feof(tfile[tlevel])) { /* If end of take */
533: fclose(tfile[tlevel]); /* file, close it */
534: tlevel--; /* and forget about it. */
535: cmini(ckxech); /* and clear the cmd buffer. */
536: }
537: if (tlevel > -1) { /* If in take file */
538: cbp = cmdbuf; /* Get the next line. */
539: cbn = CMDBL;
540:
541: /* Loop to get next command line and all continuation lines from take file. */
542:
543: again: if (fgets(line,cbn,tfile[tlevel]) == NULL) continue;
544: lp = line; /* Got one, copy it. */
545: while (*cbp++ = *lp++)
546: if (--cbn < 1) fatal("Command too long for internal buffer");
547: if (*(cbp - 3) == '\\') { /* Continued on next line? */
548: cbp -= 3; /* If so, back up pointer, */
549: goto again; /* go back, get next line. */
550: }
551: stripq(cmdbuf); /* Strip any quotes from cmd buffer. */
552:
553: } else { /* No take file, get typein. */
554:
555: prompt(); /* Issue interactive prompt. */
556: cmini(ckxech);
557: }
558: repars = 1;
559: displa = 0;
560: while (repars) {
561: cmres(); /* Reset buffer pointers. */
562: xx = cmkey(cmdtab,ncmd,"Command","");
563: debug(F101,"top-level cmkey","",xx);
564: switch (docmd(xx)) {
565: case -4: /* EOF */
566: doexit(GOOD_EXIT); /* ...exit successfully */
567: case -1: /* Reparse needed */
568: repars = 1;
569: continue;
570: case -2: /* Invalid command given */
571: if (backgrd) /* if in background, terminate */
572: fatal("Kermit command error in background execution");
573: if (tlevel > -1) { /* If in take file, quit */
574: ermsg("Kermit command error: take file terminated.");
575: fclose(tfile[tlevel]);
576: tlevel--;
577: }
578: cmini(ckxech); /* (fall thru) */
579: case -3: /* Empty command OK at top level */
580: default: /* Anything else (fall thru) */
581: repars = 0; /* No reparse, get new command. */
582: continue;
583: }
584: }
585: }
586: /* Got an action command; disable terminal interrupts and return start state */
587:
588: if (!local) connoi(); /* Interrupts off only if remote */
589: return(sstate);
590: }
591:
592: /* D O E X I T -- Exit from the program. */
593:
594: doexit(exitstat) int exitstat; {
595:
596: ttclos(); /* Close external line, if any */
597: if (local) {
598: strcpy(ttname,dftty); /* Restore default tty */
599: local = dfloc; /* And default remote/local status */
600: }
601: if (!quiet) conres(); /* Restore console terminal. */
602: if (!quiet) connoi(); /* Turn off console interrupt traps. */
603:
604: if (deblog) { /* Close any open logs. */
605: debug(F100,"Debug Log Closed","",0);
606: *debfil = '\0';
607: deblog = 0;
608: zclose(ZDFILE);
609: }
610: if (pktlog) {
611: *pktfil = '\0';
612: pktlog = 0;
613: zclose(ZPFILE);
614: }
615: if (seslog) {
616: *sesfil = '\0';
617: seslog = 0;
618: zclose(ZSFILE);
619: }
620: if (tralog) {
621: tlog(F100,"Transaction Log Closed","",0l);
622: *trafil = '\0';
623: tralog = 0;
624: zclose(ZTFILE);
625: }
626: exit(exitstat); /* Exit from the program. */
627: }
628:
629: /* B L D L E N -- Make length-encoded copy of string */
630:
631: char *
632: bldlen(str,dest) char *str, *dest; {
633: int len;
634: len = strlen(str);
635: *dest = tochar(len);
636: strcpy(dest+1,str);
637: return(dest+len+1);
638: }
639:
640:
641: /* S E T G E N -- Construct a generic command */
642:
643: setgen(type,arg1,arg2,arg3) char type, *arg1, *arg2, *arg3; {
644: char *upstr, *cp;
645:
646: cp = cmdstr;
647: *cp++ = type;
648: *cp = NUL;
649: if (*arg1 != NUL) {
650: upstr = bldlen(arg1,cp);
651: if (*arg2 != NUL) {
652: upstr = bldlen(arg2,upstr);
653: if (*arg3 != NUL) bldlen(arg3,upstr);
654: }
655: }
656: cmarg = cmdstr;
657: debug(F110,"setgen",cmarg,0);
658:
659: return('g');
660: }
661:
662: /* D O C M D -- Do a command */
663:
664: /*
665: Returns:
666: -2: user typed an illegal command
667: -1: reparse needed
668: 0: parse was successful (even tho command may have failed).
669: */
670:
671: docmd(cx) int cx; {
672: int x, y;
673: char *s;
674:
675: switch (cx) {
676:
677: case -4: /* EOF */
678: if (!quiet) printf("\r\n");
679: doexit(GOOD_EXIT);
680: case -3: /* Null command */
681: return(0);
682: case -2: /* Error */
683: case -1: /* Reparse needed */
684: return(cx);
685:
686: case XXBYE: /* bye */
687: if ((x = cmcfm()) < 0) return(x);
688: if (!local) {
689: printf("You have to 'set line' first\n");
690: return(0);
691: }
692: sstate = setgen('L',"","","");
693: return(0);
694:
695: case XXCOM: /* comment */
696: if ((x = cmtxt("Text of comment line","",&s)) < 0) return(x);
697: return(0);
698:
699: case XXCON: /* connect */
700: if ((x = cmcfm()) < 0) return(x);
701: return(doconect());
702:
703: case XXCWD:
704: if (cmtxt("Name of local directory, or carriage return",homdir,&s) < 0)
705: return(-1);
706: if (chdir(s)) perror(s);
707: cwdf = 1;
708: system(PWDCMD);
709: return(0);
710:
711: case XXCLO:
712: x = cmkey(logtab,nlog,"Which log to close","");
713: if (x == -3) {
714: printf("?You must tell which log\n");
715: return(-2);
716: }
717: if (x < 0) return(x);
718: if ((y = cmcfm()) < 0) return(y);
719: switch (x) {
720:
721: case LOGD:
722: if (deblog == 0) {
723: printf("?Debugging log wasn't open\n");
724: return(0);
725: }
726: *debfil = '\0';
727: deblog = 0;
728: return(zclose(ZDFILE));
729:
730: case LOGP:
731: if (pktlog == 0) {
732: printf("?Packet log wasn't open\n");
733: return(0);
734: }
735: *pktfil = '\0';
736: pktlog = 0;
737: return(zclose(ZPFILE));
738:
739: case LOGS:
740: if (seslog == 0) {
741: printf("?Session log wasn't open\n");
742: return(0);
743: }
744: *sesfil = '\0';
745: seslog = 0;
746: return(zclose(ZSFILE));
747:
748: case LOGT:
749: if (tralog == 0) {
750: printf("?Transaction log wasn't open\n");
751: return(0);
752: }
753: *trafil = '\0';
754: tralog = 0;
755: return(zclose(ZTFILE));
756:
757: default:
758: printf("\n?Unexpected log designator - %ld\n", x);
759: return(0);
760: }
761:
762: case XXDIAL: /* dial number */
763: if ((x = cmtxt("Number to be dialed","",&s)) < 0) return(x);
764: return(dial(s));
765:
766: case XXDIR: /* directory */
767: if ((x = cmtxt("Directory/file specification",".",&s)) < 0) return(x);
768: lp = line;
769: sprintf(lp,"%s %s",DIRCMD,s);
770: system(line);
771: return(0);
772:
773:
774: case XXECH: /* echo */
775: if ((x = cmtxt("Material to be echoed","",&s)) < 0) return(x);
776: for ( ; *s; s++) {
777: if ((x = *s) == 0134) { /* Convert octal escapes */
778: s++; /* up to 3 digits */
779: for (x = y = 0; *s >= '0' && *s <= '7' && y < 3; s++,y++) {
780: x = x * 8 + (int) *s - 48;
781: }
782: s--;
783: }
784: putchar(x);
785: }
786: printf("\n");
787: return(0);
788:
789: case XXQUI: /* quit, exit */
790: case XXEXI:
791: if ((x = cmcfm()) > -1) doexit(GOOD_EXIT);
792: else return(x);
793:
794: case XXFIN: /* finish */
795: if ((x = cmcfm()) < 0) return(x);
796: if (!local) {
797: printf("You have to 'set line' first\n");
798: return(0);
799: }
800: sstate = setgen('F',"","","");
801: return(0);
802:
803: case XXGET: /* get */
804: if (!local) {
805: printf("\nYou have to 'set line' first\n");
806: return(0);
807: }
808: x = cmtxt("Name of remote file(s), or carriage return","",&cmarg);
809: if ((x == -2) || (x == -1)) return(x);
810:
811: /* If foreign file name omitted, get foreign and local names separately */
812:
813: if (*cmarg == NUL) {
814:
815: if (tlevel > -1) { /* Input is from take file */
816:
817: if (fgets(line,100,tfile[tlevel]) == NULL)
818: fatal("take file ends prematurely in 'get'");
819: stripq(line);
820: cmarg = line;
821: if (fgets(cmdbuf,CMDBL,tfile[tlevel]) == NULL)
822: fatal("take file ends prematurely in 'get'");
823: stripq(cmdbuf);
824: if (*cmdbuf == NUL) cmarg2 = line; else cmarg2 = cmdbuf;
825:
826: } else { /* Input is from terminal */
827:
828: char psave[40]; /* Save old prompt */
829: cmsavp(psave,40);
830: cmsetp(" Remote file specification: "); /* Make new one */
831: cmini(ckxech);
832: x = -1;
833: prompt();
834: while (x == -1) { /* Prompt till they answer */
835: x = cmtxt("Name of remote file(s)","",&cmarg);
836: debug(F111," cmtxt",cmarg,x);
837: }
838: if (x < 0) {
839: cmsetp(psave);
840: return(x);
841: }
842: if (*cmarg == NUL) { /* If user types a bare CR, */
843: printf("(cancelled)\n"); /* Forget about this. */
844: cmsetp(psave); /* Restore old prompt, */
845: return(0); /* and return. */
846: }
847: strcpy(line,cmarg); /* Make a safe copy */
848: cmarg = line;
849: cmsetp(" Local name to store it under: "); /* New prompt */
850: cmini(ckxech);
851: x = -1;
852: prompt(); /* Prompt */
853: while (x < 0) { /* Again, parse till answered */
854: x = cmofi("Local file name","",&cmarg2);
855: if (x == -2) return(x);
856: if (x == -3) { /* If bare CR, */
857: printf("(cancelled)\n"); /* escape from this... */
858: cmsetp(psave); /* restore old prompt, */
859: return(0); /* and return. */
860: }
861: }
862: cmsetp(psave); /* Restore old prompt. */
863: if ((x == cmcfm()) < 0) return(-2);
864: }
865: }
866: sstate = 'r'; /* All ok, set start state. */
867: if (local) displa = 1;
868: return(0);
869:
870: case XXHLP: /* Help */
871: x = cmkey(cmdtab,ncmd,"C-Kermit command","help");
872: return(dohlp(x));
873:
874: case XXLOG: /* Log */
875: x = cmkey(logtab,nlog,"What to log","");
876: if (x == -3) {
877: printf("?You must specify what is to be logged\n");
878: return(-2);
879: }
880: if (x < 0) return(x);
881: return(dolog(x));
882:
883: case XXLOGI: /* Send script remote system */
884: if ((x = cmtxt("Text of login script","",&s)) < 0) return(x);
885: return( login(s) ); /* Return 0=completed, -2=failed */
886:
887: case XXREC: /* Receive */
888: cmarg2 = "";
889: x = cmofi("Name under which to store the file, or CR","",&cmarg2);
890: if ((x == -1) || (x == -2)) return(x);
891: debug(F111,"cmofi cmarg2",cmarg2,x);
892: if ((x = cmcfm()) < 0) return(x);
893: sstate = 'v';
894: if (local) displa = 1;
895: return(0);
896:
897: case XXREM: /* Remote */
898: if (!local) {
899: printf("\nYou have to 'set line' first\n");
900: return(-2);
901: }
902: x = cmkey(remcmd,nrmt,"Remote Kermit server command","");
903: if (x == -3) {
904: printf("?You must specify a command for the remote server\n");
905: return(-2);
906: }
907: return(dormt(x));
908:
909: case XXSEN: /* Send */
910: cmarg = cmarg2 = "";
911: if ((x = cmifi("File(s) to send","",&s,&y)) < 0) {
912: if (x == -3) {
913: printf("?A file specification is required\n");
914: return(-2);
915: }
916: return(x);
917: }
918: nfils = -1; /* Files come from internal list. */
919: strcpy(line,s); /* Save copy of string just parsed. */
920: debug(F101,"Send: wild","",y);
921: *cmarg2 = '\0'; /* Initialize send-as name */
922: if (y == 0) {
923: if ((x = cmtxt("Name to send it with","",&cmarg2)) < 0) return(x);
924: } else {
925: if ((x = cmcfm()) < 0) return(x);
926: }
927: cmarg = line; /* File to send */
928: debug(F110,"Sending:",cmarg,0);
929: if (*cmarg2 != '\0') debug(F110," as:",cmarg2,0);
930: sstate = 's'; /* Set start state */
931: if (local) displa = 1;
932: return(0);
933:
934: case XXSER: /* Server */
935: if ((x = cmcfm()) < 0) return(x);
936: sstate = 'x';
937: if (local) displa = 1;
938: return(0);
939:
940: case XXSET: /* Set */
941: x = cmkey(prmtab,nprm,"Parameter","");
942: if (x == -3) {
943: printf("?You must specify a parameter to set\n");
944: return(-2);
945: }
946: if (x < 0) return(x);
947: return(doprm(x));
948:
949: /* XXSHE code by H. Fischer; copyright rights assigned to Columbia Univ */
950: /*
951: Adapted to use getpwuid to find login shell because many systems do not
952: have SHELL in environment, and to use direct calling of shell rather
953: than intermediate system() call. -- H. Fischer
954: */
955: case XXSHE: /* Local shell command */
956: {
957: int pid;
958: if (cmtxt("Unix shell command to execute","",&s) < 0) return(-1);
959: conres(); /* Make console normal */
960: #ifdef MSDOS
961: zxcmd(s);
962: #else
963: #ifdef vax11c
964:
965: system(s); /* Best we can do for VMS? */
966:
967: #else /* All Unix systems... */
968:
969: if ((pid = fork()) == 0) { /* Make child */
970: char *shpath, *shname, *shptr; /* For finding desired shell */
971: struct passwd *p;
972: extern struct passwd * getpwuid();
973: extern int getuid();
974: char *defShel = "/bin/sh"; /* Default */
975:
976: p = getpwuid( getuid() ); /* Get login data */
977: if ( p == (struct passwd *) NULL || !*(p->pw_shell) )
978: shpath = defShel;
979: else
980: shpath = p->pw_shell;
981: shptr = shname = shpath;
982: while (*shptr != '\0')
983: if (*shptr++ == '/') shname = shptr;
984: if (*s == NUL) /* Interactive shell requested? */
985: execl(shpath,shname,"-i",(char *)0); /* Yes, do that */
986: else /* Otherwise, */
987: execl(shpath,shname,"-c",s,(char *)0); /* exec the given command */
988: exit(GOOD_EXIT); } /* Just punt if it didnt work */
989:
990: else { /* Parent */
991:
992: int wstat; /* Kermit must wait for child */
993: int (*istat)(), (*qstat)();
994:
995: istat = signal(SIGINT,SIG_IGN); /* Let the fork handle keyboard */
996: qstat = signal(SIGQUIT,SIG_IGN); /* interrupts itself... */
997:
998: while (((wstat = wait(0)) != pid) && (wstat != -1)) /* Wait for fork */
999: ;
1000: signal(SIGINT,istat); /* Restore interrupts */
1001: signal(SIGQUIT,qstat);
1002: }
1003: #endif
1004: #endif
1005: concb(escape); /* Console back in cbreak mode */
1006: return(0);
1007: }
1008:
1009: case XXSHO: /* Show */
1010: x = cmkey(shotab,2,"","parameters");
1011: if (x < 0) return(x);
1012: if (y = (cmcfm()) < 0) return(y);
1013: switch (x) {
1014:
1015: case SHPAR:
1016: shopar();
1017: break;
1018:
1019: case SHVER:
1020: printf("\nVersions:\n %s\n %s\n",versio,protv);
1021: printf(" %s\n",fnsv);
1022: printf(" %s\n %s\n %s for%s\n",cmdv,userv,ckxv,ckxsys);
1023: printf(" %s for%s\n %s\n",ckzv,ckzsys,connv);
1024: printf(" %s\n %s\n\n",dialv,loginv);
1025: break;
1026:
1027: default:
1028: printf("\nNothing to show...\n");
1029: break;
1030: }
1031: return(0);
1032:
1033: case XXSPA: /* space */
1034: if ((x = cmcfm()) < 0) return(x);
1035: system(SPACMD);
1036: return(0);
1037:
1038: case XXSTA: /* statistics */
1039: if ((x = cmcfm()) < 0) return(x);
1040: printf("\nMost recent transaction --\n");
1041: printf(" files: %ld\n",filcnt);
1042: printf(" total file characters : %ld\n",tfc);
1043: printf(" communication line in : %ld\n",tlci);
1044: printf(" communication line out : %ld\n",tlco);
1045: printf(" elapsed time : %d sec\n",tsecs);
1046: if (filcnt > 0) {
1047: if (tsecs > 0) {
1048: long lx;
1049: lx = (tfc / tsecs) * 10;
1050: printf(" effective baud rate : %ld\n",lx);
1051: if (speed > 0) {
1052: lx = (lx * 100) / speed;
1053: printf(" efficiency : %ld %%\n",lx);
1054: }
1055: }
1056: printf(" block check type used : %d\n",bctu);
1057: printf(" compression : ");
1058: if (rptflg) printf("yes [%c]\n",rptq); else printf("no\n");
1059: printf(" 8th bit prefixing : ");
1060: if (ebqflg) printf("yes [%c]\n",ebq); else printf("no\n\n");
1061: } else printf("\n");
1062: return(0);
1063:
1064: case XXTAK: /* take */
1065: if (tlevel > MAXTAKE-1) {
1066: printf("?Take files nested too deeply\n");
1067: return(-2);
1068: }
1069: if ((y = cmifi("C-Kermit command file","",&s,&x)) < 0) {
1070: if (y == -3) {
1071: printf("?A file specification is required\n");
1072: return(-2);
1073: } else return(y);
1074: }
1075: if (x != 0) {
1076: printf("?Wildcards not allowed in command file name\n");
1077: return(-2);
1078: }
1079: strcpy(line,s); /* Make a safe copy of the string */
1080: if ((y = cmcfm()) < 0) return(y);
1081: if ((tfile[++tlevel] = fopen(line,"r")) == NULL) {
1082: perror(line);
1083: debug(F110,"Failure to open",line,0);
1084: tlevel--;
1085: }
1086: return(0);
1087:
1088: default:
1089: printf("Not available - %s\n",cmdbuf);
1090: return(-2);
1091: }
1092: }
1093:
1094: /* S H O P A R -- Show Parameters */
1095:
1096: shopar() {
1097:
1098: int i;
1099: extern struct keytab mdmtab[]; extern int nmdm;
1100:
1101: puts("\nCommunications Parameters:");
1102: printf(" Line: %s, speed: %d, mode: ",ttname,speed);
1103: if (local) printf("local"); else printf("remote");
1104:
1105: for (i = 0; i < nmdm; i++) {
1106: if (mdmtab[i].val == mdmtyp) {
1107: printf(", modem-dialer: %s",mdmtab[i].kwd);
1108: break;
1109: }
1110: }
1111: printf("\n Parity: ");
1112: switch (parity) {
1113: case 'e': printf("even"); break;
1114: case 'o': printf("odd"); break;
1115: case 'm': printf("mark"); break;
1116: case 's': printf("space"); break;
1117: case 0: printf("none"); break;
1118: default: printf("invalid - %d",parity); break;
1119: }
1120: printf(", duplex: ");
1121: if (duplex) printf("half, "); else printf("full, ");
1122: printf("flow: ");
1123: if (flow == 1) printf("xon/xoff");
1124: else if (flow == 0) printf("none");
1125: else printf("%d",flow);
1126: printf(", handshake: ");
1127: if (turn) printf("%d\n",turnch); else printf("none\n");
1128:
1129: printf("\nProtocol Parameters: Send Receive");
1130: if (timef || spsizf) printf(" (* = override)");
1131: printf("\n Timeout: %11d%9d", rtimo, timint);
1132: if (timef) printf("*");
1133: printf("\n Padding: %11d%9d\n", npad, mypadn);
1134: printf( " Pad Character:%11d%9d\n", padch, mypadc);
1135: printf( " Packet Start: %11d%9d\n", mystch, stchr);
1136: printf( " Packet End: %11d%9d\n", seol, eol);
1137: printf( " Packet Length:%11d", spsiz);
1138: printf( spsizf ? "*" : " " ); printf("%8d\n", rpsiz);
1139:
1140: printf("\nBlock Check Type: %d, Delay: %d\n",bctr,delay);
1141: if (ebqflg) printf("8th-Bit Prefix: '%c'\n",ebq);
1142: if (rptflg) printf("Repeat-Count Prefix: '%c'\n",rptq);
1143:
1144: printf("\nFile parameters:\n File Names: ");
1145: if (fncnv) printf("%-12s","converted"); else printf("%-12s","literal");
1146: #ifdef DEBUG
1147: printf(" Debugging Log: ");
1148: if (deblog) printf("%s",debfil); else printf("none");
1149: #endif
1150: printf("\n File Type: ");
1151: if (binary) printf("%-12s","binary"); else printf("%-12s","text");
1152: printf(" Packet Log: ");
1153: if (pktlog) printf(pktfil); else printf("none");
1154: printf("\n File Warning: ");
1155: if (warn) printf("%-12s","on"); else printf("%-12s","off");
1156: printf(" Session Log: ");
1157: if (seslog) printf(sesfil); else printf("none");
1158: printf("\n File Display: ");
1159: if (quiet) printf("%-12s","off"); else printf("%-12s","on");
1160: #ifdef TLOG
1161: printf(" Transaction Log: ");
1162: if (tralog) printf(trafil); else printf("none");
1163: #endif
1164: printf("\n\nIncomplete File Disposition: ");
1165: if (keep) printf("keep"); else printf("discard");
1166: #ifdef KERMRC
1167: printf(", Init file: %s",KERMRC);
1168: #endif
1169: puts("\n");
1170: }
1171:
1172: /* D O C O N E C T -- Do the connect command */
1173:
1174: /* Note, we don't call this directly from dial, because we need to give */
1175: /* the user a chance to change parameters (e.g. parity) after the */
1176: /* connection is made. */
1177:
1178: doconect() {
1179: int x;
1180: conres(); /* Put console back to normal */
1181: x = conect(); /* Connect */
1182: concb(escape); /* Put console into cbreak mode, */
1183: return(x); /* for more command parsing. */
1184: }
1185:
1186:
1187: /* D O L O G -- Do the log command */
1188:
1189: dolog(x) int x; {
1190: int y; char *s;
1191:
1192: switch (x) {
1193:
1194: case LOGD:
1195: #ifdef DEBUG
1196: y = cmofi("Name of debugging log file","debug.log",&s);
1197: #else
1198: y = -2; s = "";
1199: printf("%s","- Sorry, debug log not available\n");
1200: #endif
1201: break;
1202:
1203: case LOGP:
1204: y = cmofi("Name of packet log file","packet.log",&s);
1205: break;
1206:
1207: case LOGS:
1208: y = cmofi("Name of session log file","session.log",&s);
1209: break;
1210:
1211: case LOGT:
1212: #ifdef TLOG
1213: y = cmofi("Name of transaction log file","transact.log",&s);
1214: #else
1215: y = -2; s = "";
1216: printf("%s","- Sorry, transaction log not available\n");
1217: #endif
1218: break;
1219:
1220: default:
1221: printf("\n?Unexpected log designator - %d\n",x);
1222: return(-2);
1223: }
1224: if (y < 0) return(y);
1225:
1226: strcpy(line,s);
1227: s = line;
1228: if ((y = cmcfm()) < 0) return(y);
1229:
1230: /* cont'd... */
1231:
1232: /* ...dolog, cont'd */
1233:
1234:
1235: switch (x) {
1236:
1237: case LOGD:
1238: return(deblog = debopn(s));
1239:
1240: case LOGP:
1241: zclose(ZPFILE);
1242: y = zopeno(ZPFILE,s);
1243: if (y > 0) strcpy(pktfil,s); else *pktfil = '\0';
1244: return(pktlog = y);
1245:
1246: case LOGS:
1247: zclose(ZSFILE);
1248: y = zopeno(ZSFILE,s);
1249: if (y > 0) strcpy(sesfil,s); else *sesfil = '\0';
1250: return(seslog = y);
1251:
1252: case LOGT:
1253: zclose(ZTFILE);
1254: tralog = zopeno(ZTFILE,s);
1255: if (tralog > 0) {
1256: strcpy(trafil,s);
1257: tlog(F110,"Transaction Log:",versio,0l);
1258: tlog(F100,ckxsys,"",0);
1259: ztime(&s);
1260: tlog(F100,s,"",0l);
1261: }
1262: else *trafil = '\0';
1263: return(tralog);
1264:
1265: default:
1266: return(-2);
1267: }
1268: }
1269:
1270:
1271: /* D E B O P N -- Open a debugging file */
1272:
1273: debopn(s) char *s; {
1274: #ifdef DEBUG
1275: char *tp;
1276: zclose(ZDFILE);
1277: deblog = zopeno(ZDFILE,s);
1278: if (deblog > 0) {
1279: strcpy(debfil,s);
1280: debug(F110,"Debug Log ",versio,0);
1281: debug(F100,ckxsys,"",0);
1282: ztime(&tp);
1283: debug(F100,tp,"",0);
1284: } else *debfil = '\0';
1285: return(deblog);
1286: #else
1287: return(0);
1288: #endif
1289: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.