![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kermit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin|
Return to kermit.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin |
1.1 root 1: /*
2: * K e r m i t File Transfer Utility
3: *
4: * UNIX Kermit, Columbia University, 1981, 1982, 1983
5: * Bill Catchings, Bob Cattani, Chris Maio, Frank da Cruz, Alan Crosswell
6: *
7: * Also: Jim Guyton, Rand Corporation
8: * Walter Underwood, Ford Aerospace
9: * Lauren Weinstein
10: *
11: * usage: kermit c|C [lbe line baud escapechar] to connect
12: * kermit s [d..iflbht line baud] file ... to send files
13: * kermit r [d..iflbht line baud] to receive files
14: *
15: * where c|C=connect, s=send, r=receive,
16: * d=debug, i=image mode, f=no filename conversion, l=tty line,
17: * b=baud rate, e=escape char, h=host (server) mode, t=tymnet mode.
18: *
19: * For remote Kermit, format is either:
20: * kermit r to receive files
21: * or kermit s file ... to send files
22: *
23: */
24:
25: /*
26: * Modification History:
27: *
28: * Oct. 17 Included fixes from Alan Crosswell (CUCCA) for IBM_UTS:
29: * - Changed MYEOL character from \n to \r.
30: * - Change char to int in bufill so getc would return -1 on
31: * EOF instead of 255 (-1 truncated to 8 bits)
32: * - Added read() in rpack to eat the EOL character
33: * - Added fflush() call in printmsg to force the output
34: * NOTE: The last three changes are not conditionally compiled
35: * since they should work equally well on any system.
36: *
37: * Changed Berkeley 4.x conditional compilation flag from
38: * UNIX4X to UCB4X.
39: * Added support for error packets and cleaned up the printing
40: * routines.
41: * Nov. 5, 1983 (Lauren Weinstein)
42: * Changed "write(0..." to "write(1..." in escape char code.
43: * Changed escape char processing to send the escape char to
44: * the remote system if entered twice in a row.
45: * Added support for the "Coherent" OS.
46: * Changed the "UCB4X" conditional to "UNIXL" to more correctly
47: * indicate its broader meaning.
48: * Added explicit "host" (server) flag ("-h") option.
49: * Misc. code cleanups.
50: * Jan. 21, 1984 (Lauren Weinstein)
51: * Added "suspend" (no hangup) command (^s) for Coherent.
52: * Added default tty line/speed settings for Coherent.
53: * Added Tymnet mode option ("-t").
54: * Apr. 6, 1984 (Lauren Weinstein)
55: * Misc. code cleanups.
56: * June 4, 1984 (Lauren Weinstein)
57: * Added ability to pass the first line of data to send over the
58: * connection via the command line (after the "-C" option flag).
59: */
60:
61: #include <stdio.h> /* Standard UNIX definitions */
62: #include <errno.h>
63:
64: /* Conditional compilation for different machines/operating systems */
65: /* One and only one of the following lines should be 1 */
66:
67: #define UNIXL 1 /* Various UNIX and UNIX look-alikes */
68: #define TOPS_20 0 /* TOPS-20 */
69: #define IBM_UTS 0 /* Amdahl UTS on IBM systems */
70: #define VAX_VMS 0 /* VAX/VMS (not yet implemented) */
71:
72: /* Conditional compilation for the different Unix and Unix-like variants */
73: /* 0 means don't compile it, nonzero means do */
74:
75: #if UNIXL
76: #define V6_LIBS 0 /* Use retrofit libraries */
77: #define NO_FIONREAD 1 /* Don't use ioctl for flushinput() */
78: #define NO_TANDEM 0 /* Don't use TANDEM line discipline (xon/xoff) */
79: #define MULTIREAD 1 /*++1++*/
80: /* True for multiple byte read/write in -c mode */
81: #define COHERENT 1 /* True for Coherent OS */
82: #define LOCK_LINE 1 /* Lock the line when in local mode */
83: #endif
84:
85: #if IBM_UTS
86: #define V6_LIBS 0 /* Use retrofit libraries */
87: #define NO_FIONREAD 1 /* Don't use ioctl for flushinput() */
88: #define NO_TANDEM 1 /* Don't use TANDEM line discipline (xon/xoff) */
89: #define MULTIREAD 0 /* True for multiple byte read/write in -c mode */
90: #endif
91:
92: #if V6_LIBS
93: #include <retrofit/sgtty.h>
94: #include <retrofit/signal.h>
95: #include <retrofit/setjmp.h>
96: #else
97: #include <sgtty.h>
98: #include <signal.h>
99: #include <setjmp.h>
100: #endif
101:
102: #if NO_TANDEM
103: #define TANDEM 0 /* define it to be nothing if it's unsupported */
104: #endif
105:
106: #if COHERENT
107: #define DEFLINE "/dev/modem" /* default tty comm line */
108: #define DEFSPEED 9600 /* default tty speed */
109: #endif
110:
111: /* Symbol Definitions */
112:
113: #define MAXPACKSIZ 94 /* Maximum packet size */
114: #define SOH 1 /* Start of header */
115: #define CR 13 /* ASCII Carriage Return */
116: #define SP 32 /* ASCII space */
117: #define DEL 127 /* Delete (rubout) */
118: #define ESCCHR '^' /* Default escape character for CONNECT */
119:
120: #define MAXTRY 20 /* Times to retry a packet */
121: #define MYQUOTE '#' /* Quote character I will use */
122: #define MYPAD 0 /* Number of padding characters I will need */
123: #define MYPCHAR 0 /* Padding character I need (NUL) */
124: #define NUL '\0'
125: #if IBM_UTS
126: #define MYEOL '\r' /* End-Of-Line character for UTS systems */
127: #else
128: #define MYEOL '\n' /* End-Of-Line character I need */
129: #endif
130:
131: #define MYTIME 10 /* (10) Seconds after which I should be timed out */
132: #define MAXTIM 60 /* (60) Maximum timeout interval */
133: #define MINTIM 2 /* (2) Minumum timeout interval */
134:
135: #define TRUE -1 /* Boolean constants */
136: #define FALSE 0
137:
138:
139: /* Macro Definitions */
140:
141: /*
142: * tochar: converts a control character to a printable one by adding a space.
143: *
144: * unchar: undoes tochar.
145: *
146: * ctl: converts between control characters and printable characters by
147: * toggling the control bit (ie. ^A becomes A and A becomes ^A).
148: */
149: #define tochar(ch) ((ch) + ' ')
150: #define unchar(ch) ((ch) - ' ')
151: #define ctl(ch) ((ch) ^ 64 )
152:
153:
154: /* Global Variables */
155:
156: int size, /* Size of present data */
157: rpsiz, /* Maximum receive packet size */
158: spsiz, /* Maximum send packet size */
159: pad, /* How much padding to send */
160: timint, /* Timeout for foreign host on sends */
161: n, /* Packet number */
162: numtry, /* Times this packet retried */
163: oldtry, /* Times previous packet retried */
164: ttyfd, /* File descriptor of tty for I/O, 0 if remote */
165: remote, /* -1 means we're a remote kermit */
166: image, /* -1 means 8-bit mode */
167: debug, /* indicates level of debugging output (0=none) */
168: filnamcnv, /* -1 means do file name case conversions */
169: filecount, /* Number of files left to send */
170: tflg; /* Flag for Tymnet mode */
171: logflg; /* Log connect transactions */
172: loglastch; /* last log character for cr elim */
173:
174: char state, /* Present state of the automaton */
175: padchar, /* Padding character to send */
176: eol, /* End-Of-Line character to send */
177: escchr, /* Connect command escape character */
178: quote, /* Quote character in incoming data */
179: **filelist, /* List of files to be sent */
180: *filnam, /* Current file name */
181: *ttyline, /* Pointer to tty line */
182: ttynbuff[128]; /* Name buffer for tty line */
183: inbuff[128]; /* remote data input buffer */
184: recpkt[MAXPACKSIZ], /* Receive packet buffer */
185: packet[MAXPACKSIZ]; /* Packet buffer */
186: ldata[1024]; /* First line of data to send over connection */
187:
188: FILE *fp, /* File pointer for current disk file */
189: *log; /* File pointer for Logfile */
190: int logfd; /* File descriptor for Logfile */
191:
192: jmp_buf env; /* Environment ptr for timeout longjump */
193:
194:
195: /*
196: * m a i n
197: *
198: * Main routine - parse command and options, set up the
199: * tty lines, and dispatch to the appropriate routine.
200: */
201:
202: main(argc,argv)
203: int argc; /* Character pointers to and count of */
204: char **argv; /* command line arguments */
205: {
206: char *cp; /* char pointer */
207: int speed, /* speed of assigned tty, */
208: cflg, rflg, sflg; /* flags for CONNECT, RECEIVE, SEND */
209: int hflg; /* flag for HOST (server) mode */
210: struct sgttyb
211: rawmode, /* Controlling tty raw mode */
212: cookedmode, /* Controlling tty cooked mode */
213: ttymode; /* mode of tty line in LINE option */
214:
215: if (argc < 2) usage(); /* Make sure there's a command line */
216:
217: cp = *++argv; argv++; argc -= 2; /* Set up pointers to args */
218:
219: /* Initialize these values and hope the first packet will get across OK */
220:
221: eol = CR; /* EOL for outgoing packets */
222: quote = '#'; /* Standard control-quote char "#" */
223: pad = 0; /* No padding */
224: padchar = NUL; /* Use null if any padding wanted */
225:
226: speed = hflg = cflg = logflg = sflg = 0; /* Turn off all parse flags */
227: loglastch = -1;
228: rflg = tflg = 0;
229: ttyline = 0; /* Default is remote mode */
230:
231: #if UNIXL /* Default to 7-bit masking, CRLF */
232: image = FALSE; /* translation and filename case */
233: filnamcnv = TRUE; /* conversion for UNIX systems */
234: #if COHERENT
235: ttyline = DEFLINE; /* set default tty line */
236: speed = DEFSPEED; /* set default tty speed */
237: #endif
238: #else
239: image = TRUE; /* Default to no processing for */
240: filnamcnv = FALSE; /* non-UNIX-type systems */
241: #endif
242:
243: escchr = ESCCHR; /* Default escape character */
244:
245: while ((*cp) != NUL) /* Parse characters in first arg */
246: switch (*cp++)
247: {
248: case 'c': /* c/C = Connect command */
249: case 'C':
250: cflg++;
251: if (*(cp-1) == 'C' && argc--) /* "C" command? */
252: strcpy(ldata, *argv++); /* get starting data line */
253: break;
254: case 's': sflg++; break; /* S = Send command */
255: case 'r': rflg++; break; /* R = Receive command */
256: case 'h': hflg++; break; /* H = Host (server) mode */
257: case 't': tflg++; break; /* T = Tymnet mode */
258: case 'd': /* D = Increment debug mode count */
259: debug++; break;
260:
261: case 'f':
262: filnamcnv = FALSE; /* F = don't do case conversion */
263: break; /* on filenames */
264:
265: case 'i': /* I = Image (8-bit) mode */
266: image = TRUE; break; /* (this is default for non-UNIX) */
267:
268: case 'l': /* L = specify tty line to use */
269: if (argc--) ttyline = *argv++;
270: else usage();
271: if (debug) printf("Line to remote host is %s\n", ttyline);
272: break;
273:
274: case 'L': /* write to log file */
275: logflg++; break;
276:
277: case 'e': /* E = specify escape char */
278: if (argc--) escchr = **argv++;
279: else usage();
280: if (debug) printf("Escape char is \"%c\"\n",escchr);
281: break;
282:
283: case 'b': /* B = specify baud rate */
284: #if UNIXL
285: if (argc--) speed = atoi(*argv++);
286: else usage();
287: if (debug) printf("Line speed to remote host is %d\n",speed);
288: break;
289: #else
290: printmsg("Speed setting not implemented.");
291: exit(1);
292: #endif
293: }
294:
295: /* Done parsing */
296:
297: if ((cflg+sflg+rflg) != 1) /* Only one command allowed */
298: usage();
299:
300: if (!hflg) /* local mode if "hflg" is FALSE */
301: {
302: ttyfd = open(ttyline,2); /* Open the tty line */
303: if (ttyfd < 0) {
304: printmsg("Cannot open %s", ttyline);
305: exit(1);
306: }
307: #if LOCK_LINE /* Set exclusive-use mode on line */
308: if (ioctl(ttyfd,TIOCEXCL,0) != 0)
309: {
310: printmsg("Cannot lock %s", ttyline);
311: exit(1);
312: }
313: #endif
314: remote = FALSE; /* Indicate we're in local mode */
315: }
316: else /* No LINE specified so we operate */
317: { /* in remote mode (ie. controlling */
318: ttyfd = 0; /* tty is the communications line) */
319: remote = TRUE;
320: }
321:
322:
323: /* Put the proper tty into the correct mode */
324:
325: if (remote) /* If remote, use controlling tty */
326: {
327: gtty(0,&cookedmode); /* Save current mode so we can */
328: gtty(0,&rawmode); /* restore it later */
329: rawmode.sg_flags |= (RAW|TANDEM);
330: rawmode.sg_flags &= ~(ECHO|CRMOD);
331: stty(0,&rawmode); /* Put tty in raw mode */
332: }
333: else /* Local, use assigned line */
334: {
335: gtty(ttyfd,&ttymode);
336: ttymode.sg_flags |= (RAW|TANDEM);
337: ttymode.sg_flags &= ~(ECHO|CRMOD);
338:
339: #if UNIXL /* Speed changing for UNIX only */
340: if (speed) /* User specified a speed? */
341: {
342: switch(speed) /* Get internal system code */
343: {
344: case 110: speed = B110; break;
345: case 150: speed = B150; break;
346: case 300: speed = B300; break;
347: case 1200: speed = B1200; break;
348: case 2400: speed = B2400; break;
349: case 4800: speed = B4800; break;
350: case 9600: speed = B9600; break;
351: case 19200: speed = B19200; break;
352:
353: default:
354: printmsg("Bad line speed.");
355: exit(1);
356: }
357: ttymode.sg_ispeed = speed;
358: ttymode.sg_ospeed = speed;
359: }
360: #endif /* UNIXL */
361:
362: stty(ttyfd,&ttymode); /* Put asg'd tty in raw mode */
363: }
364:
365:
366: /* All set up, now execute the command that was given. */
367:
368: if (debug)
369: {
370: printf("Debugging level = %d\n\n",debug);
371:
372: if (cflg) printf("Connect command\n\n");
373: if (sflg) printf("Send command\n\n");
374: if (rflg) printf("Receive command\n\n");
375: if (logflg) printf("Logging connect transactions\n\n");
376: }
377:
378: if (cflg) connect(); /* Connect command */
379:
380: if (sflg) /* Send command */
381: {
382: if (argc--) filnam = *argv++; /* Get file to send */
383: else
384: { if (remote)
385: stty(0,&cookedmode); /* Restore controlling tty's modes */
386: usage(); /* and give error */
387: }
388: fp = NULL; /* Indicate no file open yet */
389: filelist = argv; /* Set up the rest of the file list */
390: filecount = argc; /* Number of files left to send */
391: if (sendsw() == FALSE) /* Send the file(s) */
392: printmsg("Send failed."); /* Report failure */
393: else /* or */
394: printmsg("done."); /* success */
395: }
396:
397: if (rflg) /* Receive command */
398: {
399: if (recsw() == FALSE) /* Receive the file(s) */
400: printmsg("Receive failed.");
401: else /* Report failure */
402: printmsg("done."); /* or success */
403: }
404:
405: if (remote) stty(0,&cookedmode); /* Restore controlling tty's modes */
406: exit(0);
407: }
408:
409:
410: /*
411: * s e n d s w
412: *
413: * Sendsw is the state table switcher for sending files. It loops until
414: * either it finishes, or an error is encountered. The routines called
415: * by sendsw are responsible for changing the state.
416: *
417: */
418:
419: sendsw()
420: {
421: char sinit(), sfile(), sdata(), seof(), sbreak();
422:
423: state = 'S'; /* Send initiate is the start state */
424: n = 0; /* Initialize message number */
425: numtry = 0; /* Say no tries yet */
426: while(TRUE) /* Do this as long as necessary */
427: {
428: if (debug) printf("sendsw state: %c\n",state);
429: switch(state)
430: {
431: case 'S': state = sinit(); break; /* Send-Init */
432: case 'F': state = sfile(); break; /* Send-File */
433: case 'D': state = sdata(); break; /* Send-Data */
434: case 'Z': state = seof(); break; /* Send-End-of-File */
435: case 'B': state = sbreak(); break; /* Send-Break */
436: case 'C': return (TRUE); /* Complete */
437: case 'A': return (FALSE); /* "Abort" */
438: default: return (FALSE); /* Unknown, fail */
439: }
440: }
441: }
442:
443:
444: /*
445: * s i n i t
446: *
447: * Send Initiate: send this host's parameters and get other side's back.
448: */
449:
450: char sinit()
451: {
452: int num, len; /* Packet number, length */
453:
454: if (numtry++ > MAXTRY) return('A'); /* If too many tries, give up */
455: spar(packet); /* Fill up init info packet */
456:
457: flushinput(); /* Flush pending input */
458:
459: spack('S',n,6,packet); /* Send an S packet */
460: switch(rpack(&len,&num,recpkt)) /* What was the reply? */
461: {
462: case 'N': return(state); /* NAK, try it again */
463:
464: case 'Y': /* ACK */
465: if (n != num) /* If wrong ACK, stay in S state */
466: return(state); /* and try again */
467: rpar(recpkt); /* Get other side's init info */
468:
469: if (eol == 0) eol = '\n'; /* Check and set defaults */
470: if (quote == 0) quote = '#';
471:
472: numtry = 0; /* Reset try counter */
473: n = (n+1)%64; /* Bump packet count */
474: return('F'); /* OK, switch state to F */
475:
476: case 'E': /* Error packet received */
477: prerrpkt(recpkt); /* Print it out and */
478: return('A'); /* abort */
479:
480: case FALSE: return(state); /* Receive failure, try again */
481:
482: default: return('A'); /* Anything else, just "abort" */
483: }
484: }
485:
486:
487: /*
488: * s f i l e
489: *
490: * Send File Header.
491: */
492:
493: char sfile()
494: {
495: int num, len; /* Packet number, length */
496: char filnam1[50], /* Converted file name */
497: *newfilnam, /* Pointer to file name to send */
498: *cp; /* char pointer */
499:
500: if (numtry++ > MAXTRY) return('A'); /* If too many tries, give up */
501:
502: if (fp == NULL) /* If not already open, */
503: { if (debug) printf(" Opening %s for sending.\n",filnam);
504: fp = fopen(filnam,"r"); /* open the file to be sent */
505: if (fp == NULL) /* If bad file pointer, give up */
506: {
507: error("Cannot open file %s",filnam);
508: return('A');
509: }
510: }
511:
512: strcpy(filnam1, filnam); /* Copy file name */
513: newfilnam = cp = filnam1;
514: while (*cp != '\0') /* Strip off all leading directory */
515: if (*cp++ == '/') /* names (ie. up to the last /). */
516: newfilnam = cp;
517:
518: if (filnamcnv) /* Convert lower case to upper */
519: for (cp = newfilnam; *cp != '\0'; cp++)
520: if (*cp >= 'a' && *cp <= 'z')
521: *cp ^= 040;
522:
523: len = cp - newfilnam; /* Compute length of new filename */
524:
525: printmsg("Sending %s as %s",filnam,newfilnam);
526:
527: spack('F',n,len,newfilnam); /* Send an F packet */
528: switch(rpack(&len,&num,recpkt)) /* What was the reply? */
529: {
530: case 'N': /* NAK, just stay in this state, */
531: num = (--num<0 ? 63:num); /* unless it's NAK for next packet */
532: if (n != num) /* which is just like an ACK for */
533: return(state); /* this packet so fall thru to... */
534:
535: case 'Y': /* ACK */
536: if (n != num) return(state); /* If wrong ACK, stay in F state */
537: numtry = 0; /* Reset try counter */
538: n = (n+1)%64; /* Bump packet count */
539: size = bufill(packet); /* Get first data from file */
540: return('D'); /* Switch state to D */
541:
542: case 'E': /* Error packet received */
543: prerrpkt(recpkt); /* Print it out and */
544: return('A'); /* abort */
545:
546: case FALSE: return(state); /* Receive failure, stay in F state */
547:
548: default: return('A'); /* Something else, just "abort" */
549: }
550: }
551:
552:
553: /*
554: * s d a t a
555: *
556: * Send File Data
557: */
558:
559: char sdata()
560: {
561: int num, len; /* Packet number, length */
562:
563: if (numtry++ > MAXTRY) return('A'); /* If too many tries, give up */
564: spack('D',n,size,packet); /* Send a D packet */
565: switch(rpack(&len,&num,recpkt)) /* What was the reply? */
566: {
567: case 'N': /* NAK, just stay in this state, */
568: num = (--num<0 ? 63:num); /* unless it's NAK for next packet */
569: if (n != num) /* which is just like an ACK for */
570: return(state); /* this packet so fall thru to... */
571:
572: case 'Y': /* ACK */
573: if (n != num) return(state); /* If wrong ACK, fail */
574: numtry = 0; /* Reset try counter */
575: n = (n+1)%64; /* Bump packet count */
576: if ((size = bufill(packet)) == EOF) /* Get data from file */
577: return('Z'); /* If EOF set state to that */
578: return('D'); /* Got data, stay in state D */
579:
580: case 'E': /* Error packet received */
581: prerrpkt(recpkt); /* Print it out and */
582: return('A'); /* abort */
583:
584: case FALSE: return(state); /* Receive failure, stay in D */
585:
586: default: return('A'); /* Anything else, "abort" */
587: }
588: }
589:
590:
591: /*
592: * s e o f
593: *
594: * Send End-Of-File.
595: */
596:
597: char seof()
598: {
599: int num, len; /* Packet number, length */
600: if (numtry++ > MAXTRY) return('A'); /* If too many tries, "abort" */
601:
602: spack('Z',n,0,packet); /* Send a 'Z' packet */
603: switch(rpack(&len,&num,recpkt)) /* What was the reply? */
604: {
605: case 'N': /* NAK, just stay in this state, */
606: num = (--num<0 ? 63:num); /* unless it's NAK for next packet, */
607: if (n != num) /* which is just like an ACK for */
608: return(state); /* this packet so fall thru to... */
609:
610: case 'Y': /* ACK */
611: if (n != num) return(state); /* If wrong ACK, hold out */
612: numtry = 0; /* Reset try counter */
613: n = (n+1)%64; /* and bump packet count */
614: if (debug) printf(" Closing input file %s, ",filnam);
615: fclose(fp); /* Close the input file */
616: fp = NULL; /* Set flag indicating no file open */
617:
618: if (debug) printf("looking for next file...\n");
619: if (gnxtfl() == FALSE) /* No more files go? */
620: return('B'); /* if not, break, EOT, all done */
621: if (debug) printf(" New file is %s\n",filnam);
622: return('F'); /* More files, switch state to F */
623:
624: case 'E': /* Error packet received */
625: prerrpkt(recpkt); /* Print it out and */
626: return('A'); /* abort */
627:
628: case FALSE: return(state); /* Receive failure, stay in Z */
629:
630: default: return('A'); /* Something else, "abort" */
631: }
632: }
633:
634:
635: /*
636: * s b r e a k
637: *
638: * Send Break (EOT)
639: */
640:
641: char sbreak()
642: {
643: int num, len; /* Packet number, length */
644: if (numtry++ > MAXTRY) return('A'); /* If too many tries "abort" */
645:
646: spack('B',n,0,packet); /* Send a B packet */
647: switch (rpack(&len,&num,recpkt)) /* What was the reply? */
648: {
649: case 'N': /* NAK, just stay in this state, */
650: num = (--num<0 ? 63:num); /* unless NAK for previous packet, */
651: if (n != num) /* which is just like an ACK for */
652: return(state); /* this packet so fall thru to... */
653:
654: case 'Y': /* ACK */
655: if (n != num) return(state); /* If wrong ACK, fail */
656: numtry = 0; /* Reset try counter */
657: n = (n+1)%64; /* and bump packet count */
658: return('C'); /* Switch state to Complete */
659:
660: case 'E': /* Error packet received */
661: prerrpkt(recpkt); /* Print it out and */
662: return('A'); /* abort */
663:
664: case FALSE: return(state); /* Receive failure, stay in B */
665:
666: default: return ('A'); /* Other, "abort" */
667: }
668: }
669:
670:
671: /*
672: * r e c s w
673: *
674: * This is the state table switcher for receiving files.
675: */
676:
677: recsw()
678: {
679: char rinit(), rfile(), rdata(); /* Use these procedures */
680:
681: state = 'R'; /* Receive-Init is the start state */
682: n = 0; /* Initialize message number */
683: numtry = 0; /* Say no tries yet */
684:
685: while(TRUE)
686: {
687: if (debug) printf(" recsw state: %c\n",state);
688: switch(state) /* Do until done */
689: {
690: case 'R': state = rinit(); break; /* Receive-Init */
691: case 'F': state = rfile(); break; /* Receive-File */
692: case 'D': state = rdata(); break; /* Receive-Data */
693: case 'C': return(TRUE); /* Complete state */
694: case 'A': return(FALSE); /* "Abort" state */
695: }
696: }
697: }
698:
699:
700: /*
701: * r i n i t
702: *
703: * Receive Initialization
704: */
705:
706: char rinit()
707: {
708: int len, num; /* Packet length, number */
709:
710: if (numtry++ > MAXTRY) return('A'); /* If too many tries, "abort" */
711:
712: switch(rpack(&len,&num,packet)) /* Get a packet */
713: {
714: case 'S': /* Send-Init */
715: rpar(packet); /* Get the other side's init data */
716: spar(packet); /* Fill up packet with my init info */
717: spack('Y',n,6,packet); /* ACK with my parameters */
718: oldtry = numtry; /* Save old try count */
719: numtry = 0; /* Start a new counter */
720: n = (n+1)%64; /* Bump packet number, mod 64 */
721: return('F'); /* Enter File-Receive state */
722:
723: case 'E': /* Error packet received */
724: prerrpkt(recpkt); /* Print it out and */
725: return('A'); /* abort */
726:
727: case FALSE: /* Didn't get packet */
728: spack('N',n,0,0); /* Return a NAK */
729: return(state); /* Keep trying */
730:
731: default: return('A'); /* Some other packet type, "abort" */
732: }
733: }
734:
735:
736: /*
737: * r f i l e
738: *
739: * Receive File Header
740: */
741:
742: char rfile()
743: {
744: int num, len; /* Packet number, length */
745: char filnam1[50]; /* Holds the converted file name */
746:
747: if (numtry++ > MAXTRY) return('A'); /* "abort" if too many tries */
748:
749: switch(rpack(&len,&num,packet)) /* Get a packet */
750: {
751: case 'S': /* Send-Init, maybe our ACK lost */
752: if (oldtry++ > MAXTRY) return('A'); /* If too many tries abort */
753: if (num == ((n==0) ? 63:n-1)) /* Previous packet, mod 64? */
754: { /* Yes, ACK it again with */
755: spar(packet); /* our Send-Init parameters */
756: spack('Y',num,6,packet);
757: numtry = 0; /* Reset try counter */
758: return(state); /* Stay in this state */
759: }
760: else return('A'); /* Not previous packet, "abort" */
761:
762: case 'Z': /* End-Of-File */
763: if (oldtry++ > MAXTRY) return('A');
764: if (num == ((n==0) ? 63:n-1)) /* Previous packet, mod 64? */
765: { /* Yes, ACK it again. */
766: spack('Y',num,0,0);
767: numtry = 0;
768: return(state); /* Stay in this state */
769: }
770: else return('A'); /* Not previous packet, "abort" */
771:
772: case 'F': /* File Header (just what we want) */
773: if (num != n) return('A'); /* The packet number must be right */
774: strcpy(filnam1, packet); /* Copy the file name */
775:
776: if (filnamcnv) /* Convert upper case to lower */
777: for (filnam=filnam1; *filnam != '\0'; filnam++)
778: if (*filnam >= 'A' && *filnam <= 'Z')
779: *filnam |= 040;
780:
781: if ((fp=fopen(filnam1,"w"))==NULL) /* Try to open a new file */
782: {
783: error("Cannot create %s",filnam1); /* Give up if can't */
784: return('A');
785: }
786: else /* OK, give message */
787: printmsg("Receiving %s as %s",packet,filnam1);
788:
789: spack('Y',n,0,0); /* Acknowledge the file header */
790: oldtry = numtry; /* Reset try counters */
791: numtry = 0; /* ... */
792: n = (n+1)%64; /* Bump packet number, mod 64 */
793: return('D'); /* Switch to Data state */
794:
795: case 'B': /* Break transmission (EOT) */
796: if (num != n) return ('A'); /* Need right packet number here */
797: spack('Y',n,0,0); /* Say OK */
798: return('C'); /* Go to complete state */
799:
800: case 'E': /* Error packet received */
801: prerrpkt(recpkt); /* Print it out and */
802: return('A'); /* abort */
803:
804: case FALSE: /* Didn't get packet */
805: spack('N',n,0,0); /* Return a NAK */
806: return(state); /* Keep trying */
807:
808: default: return ('A'); /* Some other packet, "abort" */
809: }
810: }
811:
812:
813: /*
814: * r d a t a
815: *
816: * Receive Data
817: */
818:
819: char rdata()
820: {
821: int num, len; /* Packet number, length */
822: if (numtry++ > MAXTRY) return('A'); /* "abort" if too many tries */
823:
824: if (tflg)
825: sleep(1); /* Delay for Tymnet */
826:
827: switch(rpack(&len,&num,packet)) /* Get packet */
828: {
829: case 'D': /* Got Data packet */
830: if (num != n) /* Right packet? */
831: { /* No */
832: if (oldtry++ > MAXTRY)
833: return('A'); /* If too many tries, abort */
834: if (num == ((n==0) ? 63:n-1)) /* Else check packet number */
835: { /* Previous packet again? */
836: spack('Y',num,6,packet); /* Yes, re-ACK it */
837: numtry = 0; /* Reset try counter */
838: return(state); /* Don't write out data! */
839: }
840: else
841: return('A'); /* sorry, wrong number */
842: }
843: /* Got data with right packet number */
844: bufemp(packet,len); /* Write the data to the file */
845: spack('Y',n,0,0); /* Acknowledge the packet */
846: oldtry = numtry; /* Reset the try counters */
847: numtry = 0; /* ... */
848: n = (n+1)%64; /* Bump packet number, mod 64 */
849: return('D'); /* Remain in data state */
850:
851: case 'F': /* Got a File Header */
852: if (oldtry++ > MAXTRY)
853: return('A'); /* If too many tries, "abort" */
854: if (num == ((n==0) ? 63:n-1)) /* Else check packet number */
855: { /* It was the previous one */
856: spack('Y',num,0,0); /* ACK it again */
857: numtry = 0; /* Reset try counter */
858: return(state); /* Stay in Data state */
859: }
860: else
861: return('A'); /* Not previous packet, "abort" */
862:
863: case 'Z': /* End-Of-File */
864: if (num != n) return('A'); /* Must have right packet number */
865: spack('Y',n,0,0); /* OK, ACK it. */
866: fclose(fp); /* Close the file */
867: n = (n+1)%64; /* Bump packet number */
868: return('F'); /* Go back to Receive File state */
869:
870: case 'E': /* Error packet received */
871: prerrpkt(recpkt); /* Print it out and */
872: return('A'); /* abort */
873:
874: case FALSE: /* Didn't get packet */
875: spack('N',n,0,0); /* Return a NAK */
876: return(state); /* Keep trying */
877:
878: default:
879: return('A'); /* Some other packet, "abort" */
880:
881: }
882: }
883:
884: /*
885: * c o n n e c t
886: *
887: * Establish a virtual terminal connection with the remote host, over an
888: * assigned tty line.
889: */
890:
891: connect()
892: {
893: int pid, /* Holds process id of child */
894: connected; /* TRUE if connection open */
895: int closemode = FALSE; /* TRUE if we closed connection */
896: register char *p;
897: register int count;
898: char filetoread [25];
899: char * ofp;
900: int rcount;
901: char bel = '\07',
902: c;
903: static char *heremsg = "\r\nYes, I'm still here... ^r version\r\n";
904: struct sgttyb
905: rawmode, /* Controlling tty raw mode */
906: cookedmode; /* Controlling tty cooked mode */
907:
908: if (remote) /* Nothing to connect to in remote */
909: { /* mode, so just return */
910: printmsg("No line specified for connection.");
911: return;
912: }
913:
914: gtty(0,&cookedmode); /* Save current mode so we can */
915: gtty(0,&rawmode); /* restore it later */
916: rawmode.sg_flags |= (RAW|TANDEM);
917: rawmode.sg_flags &= ~(ECHO|CRMOD);
918: stty(0,&rawmode); /* Put tty in raw mode */
919:
920: if (logflg) {
921: if ((logfd = open ("Log", 2)) == -1) {
922: if ((logfd = creat ("Log", 0644)) == -1) {
923: printmsg ("Cannot open log file\n");
924: stty(0, &cookedmode); /* Restore tty mode */
925: return(-1);
926: }
927: }
928: if ((lseek (logfd, 0L, 2) == -1)) {
929: printmsg ("Cannot seek to end of log file\n");
930: stty(0, &cookedmode); /* Restore tty mode */
931: return (-1);
932: }
933: }
934:
935: pid = fork(); /* Start fork to get typeout from remote host */
936:
937: if (pid) /* Parent: send type-in to remote host */
938: {
939: printmsg("connected...\r");
940: connected = TRUE; /* Put us in "connect mode" */
941:
942: if (*ldata) /* initial data line to send? */
943: { write(ttyfd, ldata, strlen(ldata));
944: write(ttyfd, "\r", 1); /* ending <CR> */
945: }
946:
947: while (connected)
948: {
949: read(0,&c,1); /* Get a character */
950: if ((c&0177) == escchr) /* Check for escape character */
951: {
952: read(0,&c,1);
953: if ((c&0177) == escchr)
954: write(ttyfd,&c,1);
955: else
956: switch (c&0177)
957: {
958: case 'c': /* close connection */
959: case 'C':
960: closemode = TRUE; /* we're closing connection */
961: #if COHERENT
962: ioctl(ttyfd, TIOCHPCL); /* set hangup on modem */
963:
964: case 's': /* suspend connection */
965: case 'S':
966: #endif
967: connected = FALSE;
968: write(1,"\r\n",2);
969: break;
970:
971: case 'r': /* read a file and send it */
972: ofp = filetoread;
973: write (0, "File to send: ", strlen("File to send: "));
974: read(0, &c, 1);
975: while (c != '\r') {
976: write(0, &c, 1);
977: *ofp++ = c;
978: read(0, &c, 1);
979: }
980: *ofp++ = '\0';
981: write(0,"\r\n",2);
982: fp = fopen (filetoread,"r");
983:
984: if (fp == NULL) {
985: error("Cannot open file %s\r\n",filetoread);
986: } else {
987: while((c = getc(fp)) != EOF) {
988: if (c == '\n')
989: c = '\r';
990: write(ttyfd, &c, 1);
991: }
992: fclose(fp);
993: }
994: fp = NULL;
995: break;
996:
997: case 'h':
998: case 'H':
999: write(1,heremsg, strlen(heremsg));
1000: break;
1001:
1002: default:
1003: write(1,"\7",1); /* bell */
1004: break;
1005: }
1006: }
1007: else
1008: { /* If not escape charater, */
1009: write(ttyfd,&c,1); /* write it out */
1010: c = NUL; /* Nullify it (why?) */
1011: }
1012: }
1013: kill(pid,9); /* Done, kill the child */
1014: wait(0); /* and bury him */
1015: stty(0,&cookedmode); /* Restore tty mode */
1016: printmsg(closemode ? "disconnected." : "suspended.");
1017: return; /* Done */
1018: }
1019: else /* Child does the reading from the remote host */
1020: {
1021: for(;;) /* Do this forever */
1022: {
1023: #if MULTIREAD
1024: count = rcount = read(ttyfd, inbuff, 128); /* read chars */
1025: #else
1026: count = read(ttyfd, inbuff, 1); /* read one char */
1027: #endif
1028: if (count > 0){
1029: #if COHERENT
1030: for (p = inbuff; count--; p++)
1031: *p &= 0177; /* strip parity for IBM display */
1032: #endif
1033: #if MULTIREAD
1034: write(1, inbuff, rcount); /* write chars */
1035: if (logflg) {
1036: p = inbuff;
1037: for (count = rcount; count--; p++) {
1038: if (*p != '\r')
1039: write (logfd, p, 1);
1040: }
1041: }
1042: #else
1043: write(1, inbuff, 1); /* write char */
1044:
1045: if (logflg)
1046: if (inbuff [0] != '\r');
1047: write (logfd, inbuff, 1); /* log chars */
1048: #endif
1049: }
1050: }
1051: }
1052: }
1053:
1054: /*
1055: * KERMIT utilities.
1056: */
1057:
1058: clkint() /* Timer interrupt handler */
1059: {
1060: longjmp(env, TRUE); /* Tell rpack to give up */
1061: }
1062:
1063:
1064: /*
1065: * s p a c k
1066: *
1067: * Send a Packet
1068: */
1069:
1070: spack(type,num,len,data)
1071: char type, *data;
1072: int num, len;
1073: {
1074: int i; /* Character loop counter */
1075: char chksum, buffer[100]; /* Checksum, packet buffer */
1076: register char *bufp; /* Buffer pointer */
1077:
1078: if (debug>1) /* Display outgoing packet */
1079: {
1080: if (data != NULL)
1081: data[len] = '\0'; /* Null-terminate data to print it */
1082: printf(" spack type: %c\n",type);
1083: printf(" num: %d\n",num);
1084: printf(" len: %d\n",len);
1085: if (data != NULL)
1086: printf(" data: \"%s\"\n",data);
1087: }
1088:
1089: bufp = buffer; /* Set up buffer pointer */
1090: for (i=1; i<=pad; i++) write(ttyfd,&padchar,1); /* Issue any padding */
1091:
1092: *bufp++ = SOH; /* Packet marker, ASCII 1 (SOH) */
1093: *bufp++ = tochar(len+3); /* Send the character count */
1094: chksum = tochar(len+3); /* Initialize the checksum */
1095: *bufp++ = tochar(num); /* Packet number */
1096: chksum += tochar(num); /* Update checksum */
1097: *bufp++ = type; /* Packet type */
1098: chksum += type; /* Update checksum */
1099:
1100: for (i=0; i<len; i++) /* Loop for all data characters */
1101: {
1102: *bufp++ = data[i]; /* Get a character */
1103: chksum += data[i]; /* Update checksum */
1104: }
1105: chksum = (((chksum&0300) >> 6)+chksum)&077; /* Compute final checksum */
1106: *bufp++ = tochar(chksum); /* Put it in the packet */
1107: *bufp = eol; /* Extra-packet line terminator */
1108: write(ttyfd, buffer,bufp-buffer+1); /* Send the packet */
1109: }
1110:
1111: /*
1112: * r p a c k
1113: *
1114: * Read a Packet
1115: */
1116:
1117: rpack(len,num,data)
1118: int *len, *num; /* Packet length, number */
1119: char *data; /* Packet data */
1120: {
1121: int i, done; /* Data character number, loop exit */
1122: char t, /* Current input character */
1123: type, /* Packet type */
1124: cchksum, /* Our (computed) checksum */
1125: rchksum; /* Checksum received from other host */
1126:
1127: #if UNIXL /* TOPS-20 can't handle timeouts... */
1128: if (setjmp(env)) return FALSE; /* Timed out, fail */
1129: signal(SIGALRM,clkint); /* Setup the timeout */
1130: if ((timint > MAXTIM) || (timint < MINTIM)) timint = MYTIME;
1131: alarm(timint);
1132: #endif /* UNIXL */
1133:
1134: while (t != SOH) /* Wait for packet header */
1135: {
1136: read(ttyfd,&t,1);
1137: t &= 0177; /* Handle parity */
1138: }
1139:
1140: done = FALSE; /* Got SOH, init loop */
1141: while (!done) /* Loop to get a packet */
1142: {
1143: read(ttyfd,&t,1); /* Get character */
1144: if (!image) t &= 0177; /* Handle parity */
1145: if (t == SOH) continue; /* Resynchronize if SOH */
1146: cchksum = t; /* Start the checksum */
1147: *len = unchar(t)-3; /* Character count */
1148:
1149: read(ttyfd,&t,1); /* Get character */
1150: if (!image) t &= 0177; /* Handle parity */
1151: if (t == SOH) continue; /* Resynchronize if SOH */
1152: cchksum = cchksum + t; /* Update checksum */
1153: *num = unchar(t); /* Packet number */
1154:
1155: read(ttyfd,&t,1); /* Get character */
1156: if (!image) t &= 0177; /* Handle parity */
1157: if (t == SOH) continue; /* Resynchronize if SOH */
1158: cchksum = cchksum + t; /* Update checksum */
1159: type = t; /* Packet type */
1160:
1161: for (i=0; i<*len; i++) /* The data itself, if any */
1162: { /* Loop for character count */
1163: read(ttyfd,&t,1); /* Get character */
1164: if (!image) t &= 0177; /* Handle parity */
1165: if (t == SOH) continue; /* Resynch if SOH */
1166: cchksum = cchksum + t; /* Update checksum */
1167: data[i] = t; /* Put it in the data buffer */
1168: }
1169: data[*len] = 0; /* Mark the end of the data */
1170:
1171: read(ttyfd,&t,1); /* Get last character (checksum) */
1172: rchksum = unchar(t); /* Convert to numeric */
1173: read(ttyfd,&t,1); /* get EOL character and toss it */
1174: if (!image) t &= 0177; /* Handle parity */
1175: if (t == SOH) continue; /* Resynchronize if SOH */
1176: done = TRUE; /* Got checksum, done */
1177: }
1178:
1179: #if UNIXL
1180: alarm(0); /* Disable the timer interrupt */
1181: #endif
1182:
1183: if (debug>1) /* Display incoming packet */
1184: {
1185: if (data != NULL)
1186: data[*len] = '\0'; /* Null-terminate data to print it */
1187: printf(" rpack type: %c\n",type);
1188: printf(" num: %d\n",*num);
1189: printf(" len: %d\n",*len);
1190: if (data != NULL)
1191: printf(" data: \"%s\"\n",data);
1192: }
1193: /* Fold in bits 7,8 to compute */
1194: cchksum = (((cchksum&0300) >> 6)+cchksum)&077; /* final checksum */
1195:
1196: if (cchksum != rchksum) return(FALSE);
1197:
1198: return(type); /* All OK, return packet type */
1199: }
1200:
1201:
1202: /*
1203: * b u f i l l
1204: *
1205: * Get a bufferful of data from the file that's being sent.
1206: * Only control-quoting is done; 8-bit & repeat count prefixes are
1207: * not handled.
1208: */
1209:
1210: bufill(buffer)
1211: char buffer[]; /* Buffer */
1212: {
1213: int i, /* Loop index */
1214: t; /* Char read from file */
1215: char t7; /* 7-bit version of above */
1216:
1217: i = 0; /* Init data buffer pointer */
1218: while((t = getc(fp)) != EOF) /* Get the next character */
1219: {
1220: t7 = t & 0177; /* Get low order 7 bits */
1221:
1222: if (t7 < SP || t7==DEL || t7==quote) /* Does this char require */
1223: { /* special handling? */
1224: if (t=='\n' && !image)
1225: { /* Do LF->CRLF mapping if !image */
1226: buffer[i++] = quote;
1227: buffer[i++] = ctl('\r');
1228: }
1229: buffer[i++] = quote; /* Quote the character */
1230: if (t7 != quote)
1231: {
1232: t = ctl(t); /* and uncontrolify */
1233: t7 = ctl(t7);
1234: }
1235: }
1236: if (image)
1237: buffer[i++] = t; /* Deposit the character itself */
1238: else
1239: buffer[i++] = t7;
1240:
1241: if (i >= spsiz-8) return(i); /* Check length */
1242: }
1243: if (i==0) return(EOF); /* Wind up here only on EOF */
1244: return(i); /* Handle partial buffer */
1245: }
1246:
1247:
1248: /*
1249: * b u f e m p
1250: *
1251: * Put data from an incoming packet into a file.
1252: */
1253:
1254: bufemp(buffer,len)
1255: char buffer[]; /* Buffer */
1256: int len; /* Length */
1257: {
1258: int i; /* Counter */
1259: char t; /* Character holder */
1260:
1261: for (i=0; i<len; i++) /* Loop thru the data field */
1262: {
1263: t = buffer[i]; /* Get character */
1264: if (t == MYQUOTE) /* Control quote? */
1265: { /* Yes */
1266: t = buffer[++i]; /* Get the quoted character */
1267: if ((t & 0177) != MYQUOTE) /* Low order bits match quote char? */
1268: t = ctl(t); /* No, uncontrollify it */
1269: }
1270: if (t==CR && !image) /* Don't pass CR if in image mode */
1271: continue;
1272:
1273: putc(t,fp);
1274: }
1275: }
1276:
1277:
1278: /*
1279: * g n x t f l
1280: *
1281: * Get next file in a file group
1282: */
1283:
1284: gnxtfl()
1285: {
1286: if (debug) printf(" gnxtfl: filelist = \"%s\"\n",*filelist);
1287: filnam = *(filelist++);
1288: if (filecount-- == 0) return FALSE; /* If no more, fail */
1289: else return TRUE; /* else succeed */
1290: }
1291:
1292:
1293: /*
1294: * s p a r
1295: *
1296: * Fill the data array with my send-init parameters
1297: *
1298: */
1299:
1300: spar(data)
1301: char data[];
1302: {
1303: data[0] = tochar(MAXPACKSIZ); /* Biggest packet I can receive */
1304: data[1] = tochar(MYTIME); /* When I want to be timed out */
1305: data[2] = tochar(MYPAD); /* How much padding I need */
1306: data[3] = ctl(MYPCHAR); /* Padding character I want */
1307: data[4] = tochar(MYEOL); /* End-Of-Line character I want */
1308: data[5] = MYQUOTE; /* Control-Quote character I send */
1309: }
1310:
1311:
1312: /* r p a r
1313: *
1314: * Get the other host's send-init parameters
1315: *
1316: */
1317:
1318: rpar(data)
1319: char data[];
1320: {
1321: spsiz = unchar(data[0]); /* Maximum send packet size */
1322: timint = unchar(data[1]); /* When I should time out */
1323: pad = unchar(data[2]); /* Number of pads to send */
1324: padchar = ctl(data[3]); /* Padding character to send */
1325: eol = unchar(data[4]); /* EOL character I must send */
1326: quote = data[5]; /* Incoming data quote character */
1327: }
1328:
1329:
1330: /*
1331: * f l u s h i n p u t
1332: *
1333: * Dump all pending input to clear stacked up NACK's.
1334: * (Implemented only for Berkeley Unix at this time).
1335: */
1336:
1337: #if UNIXL&(~NO_FIONREAD)
1338: flushinput()
1339: {
1340: #if COHERENT
1341: int count; /* Number of bytes ready to read */
1342: #else
1343: long int count; /* Number of bytes ready to read */
1344: #endif
1345: long int i; /* Number of bytes to read in loop */
1346:
1347: #if COHERENT
1348: ioctl(ttyfd, TIOCQUERY, &count); /* See how many bytes pending read */
1349: #else
1350: ioctl(ttyfd, FIONREAD, &count); /* See how many bytes pending read */
1351: #endif
1352:
1353: if (!count) return; /* If zero, then no input to flush */
1354:
1355: while (count) /* Loop till all are flushed */
1356: {
1357: i = (count<sizeof(recpkt)) ? /* Read min of count and size of */
1358: count : sizeof(recpkt); /* the read buffer */
1359: read(ttyfd, recpkt, i); /* Read a bunch */
1360: count -= i; /* Subtract from amount to read */
1361: }
1362: }
1363: #else
1364: flushinput() /* Null version */
1365: {}
1366: #endif /* UNIXL&(~FIONREAD) */
1367:
1368:
1369: /*
1370: * Kermit printing routines:
1371: *
1372: * usage - print command line options showing proper syntax
1373: * printmsg - like printf with "Kermit: " prepended
1374: * error - like printmsg if local kermit; sends a error packet if remote
1375: * prerrpkt - print contents of error packet received from remote host
1376: */
1377:
1378: /*
1379: * u s a g e
1380: *
1381: * Print summary of usage info and quit
1382: */
1383:
1384: usage()
1385: {
1386: #if UNIXL
1387: printf("Usage: kermit c|C [lbe line baud esc.char] (connect mode)\n");
1388: printf("or: kermit s[diflbht line baud] file ... (send mode)\n");
1389: printf("or: kermit r[diflbht line baud] (receive mode)\n");
1390: #else
1391: printf("Usage: kermit c|C [le line esc.char] (connect mode)\n");
1392: printf("or: kermit s[diflht line] file ... (send mode)\n");
1393: printf("or: kermit r[diflht line] (receive mode)\n");
1394: #endif
1395: exit(1);
1396: }
1397:
1398: /*
1399: * p r i n t m s g
1400: *
1401: * Print message on standard output if not remote.
1402: */
1403:
1404: /*VARARGS1*/
1405: printmsg(fmt, a1, a2, a3, a4, a5)
1406: char *fmt;
1407: {
1408: if (!remote)
1409: {
1410: printf("kermit: ");
1411: printf(fmt,a1,a2,a3,a4,a5);
1412: printf("\n");
1413: fflush(stdout); /* force output (UTS needs it) */
1414: }
1415: }
1416:
1417: /*
1418: * e r r o r
1419: *
1420: * Print error message.
1421: *
1422: * If local, print error message with printmsg.
1423: * If remote, send an error packet with the message.
1424: */
1425:
1426: /*VARARGS1*/
1427: error(fmt, a1, a2, a3, a4, a5)
1428: char *fmt;
1429: {
1430: char msg[80];
1431: int len;
1432:
1433: if (remote)
1434: {
1435: sprintf(msg,fmt,a1,a2,a3,a4,a5); /* Make it a string */
1436: len = strlen(msg);
1437: spack('E',n,len,msg); /* Send the error packet */
1438: }
1439: else
1440: printmsg(fmt, a1, a2, a3, a4, a5);
1441:
1442: return;
1443: }
1444:
1445: /*
1446: * p r e r r p k t
1447: *
1448: * Print contents of error packet received from remote host.
1449: */
1450: prerrpkt(msg)
1451: char *msg;
1452: {
1453: printf("kermit: aborting with following error from remote host:\n%s\n",
1454: msg);
1455: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.