![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckuusx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / ckermit|
Return to ckuusx.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / ckermit |
1.1 root 1: /* C K U U S X -- "User Interface" common functions. */
2:
3: /*
4: Author: Frank da Cruz ([email protected], [email protected]),
5: Columbia University Center for Computing Activities.
6: First released January 1985.
7: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
8: York. Permission is granted to any individual or institution to use this
9: software as long as it is not sold for profit. This copyright notice must be
10: retained. This software may not be included in commercial products without
11: written permission of Columbia University.
12: */
13:
14: /*
15: This module contains user interface functions needed by both the interactive
16: user interface and the command-line-only user interface.
17: */
18:
19: /* Includes */
20:
21: #include "ckcdeb.h"
22: #include "ckcasc.h"
23: #include "ckcker.h"
24: #include "ckuusr.h"
25: #ifndef WINTCP
26: #include <signal.h>
27: #endif /* WINTCP */
28:
29: #ifdef VMS
30: #ifdef WINTCP
31: #include <descrip.h>
32: #include <ssdef.h>
33: #include <stsdef.h>
34: #include <signal.h>
35: #else
36: #include <descrip.h>
37: #include <ssdef.h>
38: #include <stsdef.h>
39: #endif /* WINTCP */
40: #endif /* VMS */
41:
42: /* Used internally */
43: _PROTOTYP( VOID screenc, (int, char, long, char *) );
44: static int ft_win = 0; /* Fullscreen file transfer display window is active */
45:
46: /* Variables declared here */
47:
48: int fdispla = XYFD_R; /* File transfer display type */
49: int tt_crd = 0; /* Carriage return display */
50:
51: #ifdef DEBUG
52: char debfil[50]; /* Debugging log file name */
53: #endif /* DEBUG */
54:
55: #ifdef TLOG
56: char trafil[50]; /* Transaction log file name */
57: #endif /* TLOG */
58:
59: char pktfil[50]; /* Packet log file name */
60: char sesfil[50]; /* Session log file name */
61:
62: #ifndef NOFRILLS
63: char optbuf[100]; /* Options for MAIL or REMOTE PRINT */
64: #endif /* NOFRILLS */
65: char cmdstr[256]; /* Place to build generic command */
66:
67: char fspec[FSPECL]; /* Filename string for \v(filespec) */
68:
69: /* C C N T A B -- Names of ASCII control characters 0-31 */
70:
71: char *ccntab[] = { "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
72: "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
73: "DLE", "DC1/XON", "DC2", "DC3/XOFF", "DC4", "NAK", "SYN", "ETB", "CAN",
74: "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
75: };
76:
77: int success = 1, /* Command success/failure flag */
78:
79: #ifndef NOSPL
80: cmdlvl = 0, /* Command level */
81: #endif /* NOSPL */
82: action, /* Action selected on command line*/
83: sessft = 0, /* Session log file type, 0 = text */
84: pflag = 1, /* Print prompt */
85: msgflg = 1; /* Print informational messages */
86:
87: #ifndef NOMSEND /* Multiple SEND */
88: char *msfiles[MSENDMAX];
89: #endif /* NOMSEND */
90:
91: /* External variables */
92:
93: #ifndef NODIAL
94: extern FILE * dialfd; /* Dialing directory */
95: #endif /* NODIAL */
96:
97: extern int local, quiet, binary, bctu, rptflg, ebqflg, network, server,
98: what, spsiz, urpsiz, wmax, czseen, cxseen, winlo, displa, timint, parity,
99: npad, ebq, ebqflg, bctr, rptq, atcapu, lpcapu, swcapu, wslotn, wslotr, rtimo,
100: mypadn, sq, capas, rpsiz, tsecs, dfloc, tralog, pktlog, seslog, lscapu,
101: xitsta, escape, tlevel, bgset, backgrd, wslots, suspend, srvdis,
102: spackets, spktl, rpktl, retrans, wcur, numerrs, fsecs;
103:
104: #ifdef datageneral /* 2/12/92 ENH */
105: #include <sysid.h>
106: extern int con_reads_mt, conint_ch, conint_avl;
107: #endif /* datageneral */
108:
109: extern long speed, filcnt, ffc, tfc, rptn, fsize;
110:
111: extern CHAR *rdatap, padch, seol, ctlq, mypadc, eol;
112:
113: extern char ttname[], *dftty, *cmarg, **cmlist, *versio, myhost[];
114: #ifndef NOICP
115: #ifdef DCMDBUF
116: extern char *cmdbuf; /* Command buffer */
117: #else
118: extern char cmdbuf[]; /* Command buffer */
119: #endif /* DCMDBUF */
120: #endif /* NOICP */
121:
122: #ifndef NOCCTRAP
123: #include <setjmp.h> /* Control-C trap */
124: jmp_buf cmjbuf;
125: #endif /* NOCCTRAP */
126:
127:
128: /* P A R N A M -- Return parity name */
129:
130: char *
131: #ifdef CK_ANSIC
132: parnam(char c)
133: #else
134: parnam(c) char c;
135: #endif /* CK_ANSIC */
136: /* parnam */ {
137: switch (c) {
138: case 'e': return("even");
139: case 'o': return("odd");
140: case 'm': return("mark");
141: case 's': return("space");
142: case 0: return("none");
143: default: return("invalid");
144: }
145: }
146:
147: /* S H O M D M -- Show modem signals */
148:
149: VOID
150: shomdm() {
151: /*
152: Note use of "\r\n" to make sure this report prints right, even when
153: called during CONNECT mode.
154: */
155: int y;
156: y = ttgmdm();
157: switch (y) {
158: case -3: printf(
159: "Modem signals unavailable in this version of Kermit\r\n");
160: break;
161: case -2: printf("No modem control for this device\r\n"); break;
162: case -1: printf("Modem signals unavailable\r\n"); break;
163: default:
164: #ifndef MAC
165: printf(
166: " Carrier Detect (CD): %s\r\n",(y & BM_DCD) ? "On": "Off");
167: printf(
168: " Dataset Ready (DSR): %s\r\n",(y & BM_DSR) ? "On": "Off");
169: #endif /* MAC */
170: printf(
171: " Clear To Send (CTS): %s\r\n",(y & BM_CTS) ? "On": "Off");
172: #ifndef MAC
173: printf(
174: " Ring Indicator (RI): %s\r\n",(y & BM_RNG) ? "On": "Off");
175: #endif /* MAC */
176: printf(
177: " Data Terminal Ready (DTR): %s\r\n",(y & BM_DTR) ? "On": "Off");
178: #ifndef MAC
179: printf(
180: " Request to Send (RTS): %s\r\n",(y & BM_RTS) ? "On": "Off");
181: #endif /* MAC */
182: }
183: }
184:
185: /* S D E B U -- Record spar results in debugging log */
186:
187: VOID
188: sdebu(len) int len; {
189: debug(F111,"spar: data",(char *) rdatap,len);
190: debug(F101," spsiz ","", spsiz);
191: debug(F101," timint","",timint);
192: debug(F101," npad ","", npad);
193: debug(F101," padch ","", padch);
194: debug(F101," seol ","", seol);
195: debug(F101," ctlq ","", ctlq);
196: debug(F101," ebq ","", ebq);
197: debug(F101," ebqflg","",ebqflg);
198: debug(F101," bctr ","", bctr);
199: debug(F101," rptq ","", rptq);
200: debug(F101," rptflg","",rptflg);
201: debug(F101," lscapu","",lscapu);
202: debug(F101," atcapu","",atcapu);
203: debug(F101," lpcapu","",lpcapu);
204: debug(F101," swcapu","",swcapu);
205: debug(F101," wslotn","", wslotn);
206: }
207: /* R D E B U -- Debugging display of rpar() values */
208:
209: VOID
210: rdebu(d,len) CHAR *d; int len; {
211: debug(F111,"rpar: data",d,len);
212: debug(F101," rpsiz ","", xunchar(d[0]));
213: debug(F101," rtimo ","", rtimo);
214: debug(F101," mypadn","",mypadn);
215: debug(F101," mypadc","",mypadc);
216: debug(F101," eol ","", eol);
217: debug(F101," ctlq ","", ctlq);
218: debug(F101," sq ","", sq);
219: debug(F101," ebq ","", ebq);
220: debug(F101," ebqflg","",ebqflg);
221: debug(F101," bctr ","", bctr);
222: debug(F101," rptq ","", d[8]);
223: debug(F101," rptflg","",rptflg);
224: debug(F101," capas ","", capas);
225: debug(F101," bits ","",d[capas]);
226: debug(F101," lscapu","",lscapu);
227: debug(F101," atcapu","",atcapu);
228: debug(F101," lpcapu","",lpcapu);
229: debug(F101," swcapu","",swcapu);
230: debug(F101," wslotr","", wslotr);
231: debug(F101," rpsiz(extended)","",rpsiz);
232: }
233:
234: #ifdef COMMENT
235: /* C H K E R R -- Decide whether to exit upon a protocol error */
236:
237: VOID
238: chkerr() {
239: if (backgrd && !server) fatal("Protocol error");
240: }
241: #endif /* COMMENT */
242:
243: /* F A T A L -- Fatal error message */
244:
245: VOID
246: fatal(msg) char *msg; {
247: #ifdef VMS
248: #ifndef NOICP
249: if (strncmp(msg,"%CKERMIT",8)) {
250: sprintf(cmdbuf,"%%CKERMIT-E-FATAL, %s",msg);
251: msg = cmdbuf;
252: }
253: #endif /* NOICP */
254: conoll(msg);
255: #else
256: screen(SCR_EM,0,0L,msg);
257: #endif /* VMS */
258: debug(F110,"fatal",msg,0);
259: tlog(F110,"Fatal:",msg,0L);
260: doexit(BAD_EXIT,xitsta | 1); /* Exit indicating failure */
261: }
262:
263: /* B L D L E N -- Make length-encoded copy of string */
264:
265: char *
266: bldlen(str,dest) char *str, *dest; {
267: int len;
268: len = (int)strlen(str);
269: *dest = tochar(len);
270: strcpy(dest+1,str);
271: return(dest+len+1);
272: }
273:
274:
275: /* S E T G E N -- Construct a generic command */
276:
277: CHAR
278: #ifdef CK_ANSIC
279: setgen(char type,char * arg1, char * arg2, char * arg3)
280: #else
281: setgen(type,arg1,arg2,arg3) char type, *arg1, *arg2, *arg3;
282: #endif /* CK_ANSIC */
283: /* setgen */ {
284: char *upstr, *cp;
285:
286: cp = cmdstr;
287: *cp++ = type;
288: *cp = NUL;
289: if (*arg1 != NUL) {
290: upstr = bldlen(arg1,cp);
291: if (*arg2 != NUL) {
292: upstr = bldlen(arg2,upstr);
293: if (*arg3 != NUL) bldlen(arg3,upstr);
294: }
295: }
296: cmarg = cmdstr;
297: debug(F110,"setgen",cmarg,0);
298:
299: return('g');
300: }
301:
302: #ifndef NOMSEND
303: static char *mgbufp = NULL;
304:
305: /* F N P A R S E -- */
306:
307: /*
308: Argument is a character string containing one or more filespecs.
309: This function breaks the string apart into an array of pointers, one
310: to each filespec, and returns the number of filespecs. Used by server
311: when it receives a GET command to allow it to process multiple file
312: specifications in one transaction. Sets cmlist to point to a list of
313: file pointers, exactly as if they were command line arguments.
314:
315: This version of fnparse treats spaces as filename separators. If your
316: operating system allows spaces in filenames, you'll need a different
317: separator.
318:
319: This version of fnparse mallocs a string buffer to contain the names. It
320: cannot assume that the string that is pointed to by the argument is safe.
321: */
322: int
323: fnparse(string) char *string; {
324: char *p, *s, *q;
325: int r = 0, x; /* Return code */
326:
327: if (mgbufp) free(mgbufp); /* Free this from last time. */
328: mgbufp = malloc((int)strlen(string)+2);
329: if (!mgbufp) {
330: debug(F100,"fnparse malloc error","",0);
331: return(0);
332: }
333: #ifndef NOICP
334: #ifndef NOSPL
335: strncpy(fspec,string,FSPECL); /* Make copy for \v(filespec) */
336: #endif /* NOSPL */
337: #endif /* NOICP */
338: s = string; /* Input string */
339: p = q = mgbufp; /* Point to the copy */
340: r = 0; /* Initialize our return code */
341: while (*s == SP || *s == HT) /* Skip leading spaces and tabs */
342: s++;
343: for (x = strlen(s); /* Strip trailing spaces */
344: (x > 1) && (s[x-1] == SP || s[x-1] == HT);
345: x--)
346: s[x-1] = NUL;
347: while (1) { /* Loop through rest of string */
348: if (*s == CMDQ) { /* Backslash (quote character)? */
349: if ((x = xxesc(&s)) > -1) { /* Go interpret it. */
350: *q++ = (char) x; /* Numeric backslash code, ok */
351: } else { /* Just let it quote next char */
352: s++; /* get past the backslash */
353: *q++ = *s++; /* deposit next char */
354: }
355: continue;
356: } else if (*s == SP || *s == NUL) { /* Unquoted space or NUL? */
357: *q++ = NUL; /* End of output filename. */
358: msfiles[r] = p; /* Add this filename to the list */
359: debug(F111,"fnparse",msfiles[r],r);
360: r++; /* Count it */
361: if (*s == NUL) break; /* End of string? */
362: while (*s == SP) s++; /* Skip repeated spaces */
363: p = q; /* Start of next name */
364: continue;
365: } else *q++ = *s; /* Otherwise copy the character */
366: s++; /* Next input character */
367: }
368: debug(F101,"fnparse r","",r);
369: msfiles[r] = ""; /* Put empty string at end of list */
370: cmlist = msfiles;
371: return(r);
372: }
373: #endif /* NOMSEND */
374:
375: char * /* dbchr() for DEBUG SESSION */
376: dbchr(c) int c; {
377: static char s[8];
378: char *cp = s;
379:
380: c &= 0xff;
381: if (c & 0x80) { /* 8th bit on */
382: *cp++ = '~';
383: c &= 0x7f;
384: }
385: if (c < SP) { /* Control character */
386: *cp++ = '^';
387: *cp++ = ctl(c);
388: } else if (c == DEL) {
389: *cp++ = '^';
390: *cp++ = '?';
391: } else { /* Printing character */
392: *cp++ = c;
393: }
394: *cp = '\0'; /* Terminate string */
395: cp = s; /* Return pointer to it */
396: return(cp);
397: }
398:
399: /* C K H O S T -- Get name of local host (where C-Kermit is running) */
400:
401: /*
402: Call with pointer to buffer to put hostname in, and length of buffer.
403: Copies hostname into buffer on success, puts null string in buffer on
404: failure.
405: */
406: #ifdef BSD44
407: #define BSD4
408: #undef ATTSV
409: #endif /* BSD44 */
410:
411: #ifdef ATTSV
412: #include <sys/utsname.h>
413: #endif /* ATTSV */
414:
415: VOID
416: ckhost(vvbuf,vvlen) char * vvbuf; int vvlen; {
417: char *g;
418: #ifdef VMS
419: int x;
420: #endif /* VMS */
421: #ifdef ATTSV
422: struct utsname hname;
423: #endif /* ATTSV */
424: #ifdef datageneral
425: int ac0 = (char *) vvbuf, ac1 = -1, ac2 = 0;
426: #endif /* datageneral */
427:
428: *vvbuf = NUL;
429: #ifdef ATTSV
430: if (uname(&hname) > -1) strncpy(vvbuf,hname.nodename,vvlen);
431: #else
432: #ifdef BSD4
433: if (gethostname(vvbuf,vvlen) < 0) *vvbuf = NUL;
434: #else
435: #ifdef VMS
436: g = getenv("SYS$NODE");
437: if (g) strncpy(vvbuf,g,vvlen);
438: x = (int)strlen(vvbuf);
439: if (x > 1 && vvbuf[x-1] == ':' && vvbuf[x-2] == ':') vvbuf[x-2] = NUL;
440: #else
441: #ifdef datageneral
442: if (sys($HNAME,&ac0,&ac1,&ac2) == 0) /* successful */
443: vvlen = ac2 + 1; /* enh - have to add one */
444: #else
445: #ifdef OS2 /* OS/2 */
446: g = getenv("SYSTEMNAME");
447: if (!g) g = getenv("HOSTNAME");
448: if (g) strncpy(vvbuf,g,vvlen);
449: #endif /* OS2 */
450: #endif /* datageneral */
451: #endif /* VMS */
452: #endif /* BSD4 */
453: #endif /* ATTSV */
454: if (*vvbuf == NUL) { /* If it's still empty */
455: g = getenv("HOST"); /* try this */
456: if (g) strncpy(vvbuf,g,vvlen);
457: }
458: vvbuf[vvlen-1] = NUL; /* Make sure result is terminated. */
459: }
460: #ifdef BSD44
461: #undef BSD4
462: #define ATTSV
463: #endif /* BSD44 */
464:
465:
466: #ifndef NOSPL
467: #define ASKMORE
468: #endif /* NOSPL */
469: #ifndef NOHELP
470: #ifndef ASKMORE
471: #define ASKMORE
472: #endif /* ASKMORE */
473: #endif /* NOHELP */
474:
475: #ifdef ASKMORE
476: /*
477: A S K M O R E -- Poor person's "more".
478: Returns 0 if no more, 1 if more wanted.
479: Presently used by SHO MAC, SHO GLOB, SHO VAR, and HELP, so compiled out if
480: those options are also compiled out.
481: */
482: int
483: askmore() {
484: char c; int rv;
485:
486: rv = -1;
487: while (rv < 0) {
488: #ifndef OS2
489: printf("more? ");
490: #ifdef UNIX
491: #ifdef NOSETBUF
492: fflush(stdout);
493: #endif /* NOSETBUF */
494: #endif /* UNIX */
495: #else
496: printf("more? (Y or space-bar for yes, N for no) ");
497: fflush(stdout);
498: #endif /* OS2 */
499: c = coninc(0);
500: switch (c) {
501: /* Yes */
502: case SP: case 'y': case 'Y': case 012: case 015:
503: printf("\015 \015");
504: rv = 1;
505: break;
506: /* No */
507: case 'n': case 'N': case 'q': case 'Q':
508: printf("\015\012");
509: rv = 0;
510: break;
511: /* Invalid answer */
512: default:
513: printf("Y or space-bar for yes, N for no\n");
514: continue;
515: }
516: #ifdef OS2
517: printf("\r \r");
518: fflush(stdout);
519: #endif /* OS2 */
520: }
521: return(rv);
522: }
523: #endif /* ASKMORE */
524:
525: /* T R A P -- Terminal interrupt handler */
526:
527: SIGTYP
528: trap(sig) int sig; {
529: #ifdef VMS
530: int i; FILE *f;
531: #endif /* VMS */
532: #ifdef __EMX__
533: signal(SIGINT, SIG_ACK);
534: #endif
535: #ifdef GEMDOS
536: /* GEM is not reentrant, no i/o from interrupt level */
537: longjmp(cmjbuf,1); /* Jump back to parser now! */
538: #endif /* GEMDOS */
539: debug(F101,"^C trap() caught signal","",sig);
540: zclose(ZIFILE); /* If we were transferring a file, */
541: zclose(ZOFILE); /* close it. */
542: #ifdef VMS
543: /*
544: Fix terminal.
545: */
546: if (ft_win) { /* If curses window open */
547: screen(SCR_CW,0,0L,""); /* Close it */
548: conres(); /* Restore terminal */
549: i = printf("^C..."); /* Echo ^C to standard output */
550: } else {
551: conres();
552: i = printf("^C...\n"); /* Echo ^C to standard output */
553: }
554: if (i < 1 && ferror(stdout)) { /* If there was an error */
555: fclose(stdout); /* close standard output */
556: f = fopen(dftty, "w"); /* open the controlling terminal */
557: if (f) stdout = f; /* and make it standard output */
558: printf("^C...\n"); /* and echo the ^C again. */
559: }
560: #else /* Not VMS */
561: if (ft_win) { /* If curses window open, */
562: screen(SCR_CW,0,0L,""); /* close it. */
563: printf("^C..."); /* Echo ^C to standard output */
564: } else {
565: printf("^C...\n");
566: }
567: #endif /* VMS */
568: #ifdef datageneral
569: connoi_mt(); /* Kill asynch task that listens to */
570: ttimoff(); /* the keyboard */
571: conres();
572: #endif /* datageneral */
573:
574: #ifndef NOCCTRAP
575: #ifdef UNIX
576: ttimoff(); /* Turn off any timer interrupts */
577: #endif /* UNIX */
578: #ifdef OSK
579: ttimoff(); /* Turn off any timer interrupts */
580: sigmask(-1);
581: /*
582: We are in an intercept routine but do not perform a F$RTE (done implicitly
583: but rts). We have to decrement the sigmask as F$RTE does. Warning:
584: longjump only restores the cpu registers, NOT the fpu registers. So don't
585: use fpu at all or at least don't use common fpu (double or float) register
586: variables.
587: */
588: #endif /* OSK */
589: longjmp(cmjbuf,1); /* Jump back to parser */
590: #else
591: /* No Ctrl-C trap, just exit. */
592: #ifdef CK_CURSES /* Curses support? */
593: screen(SCR_CW,0,0L,""); /* Close curses window */
594: #endif /* CK_CURSES */
595: doexit(BAD_EXIT,what); /* Exit poorly */
596: #endif /* NOCCTRAP */
597: SIGRETURN;
598: }
599:
600: /* C C _ C L E A N -- Cleanup after terminal interrupt handler */
601:
602: #ifdef GEMDOS
603: int
604: cc_clean() {
605: zclose(ZIFILE); /* If we were transferring a file, */
606: zclose(ZOFILE); /* close it. */
607: printf("^C...\n"); /* Not VMS, no problem... */
608: }
609: #endif /* GEMDOS */
610:
611:
612: /* S T P T R A P -- Handle SIGTSTP (suspend) signals */
613:
614: SIGTYP
615: stptrap(sig) int sig; {
616: #ifndef NOJC
617: int x; extern int cmflgs;
618: debug(F101,"stptrap() caught signal","",sig);
619: if (!suspend) {
620: printf("\r\nsuspend disabled\r\n");
621: #ifndef NOICP
622: if (what == W_COMMAND) { /* If we were parsing commands */
623: prompt(xxstring); /* reissue the prompt and partial */
624: if (!cmflgs) /* command (if any) */
625: printf("%s",cmdbuf);
626: }
627: #endif /* NOICP */
628: } else {
629: conres(); /* Reset the console */
630: #ifndef OS2
631: /* Flush pending output first, in case we are continued */
632: /* in the background, which could make us block */
633: fflush(stdout);
634:
635: x = psuspend(suspend); /* Try to suspend. */
636: if (x < 0)
637: #endif /* OS2 */
638: printf("Job control not supported\r\n");
639: conint(trap,stptrap); /* Rearm the trap. */
640: debug(F100,"stptrap back from suspend","",0);
641: switch (what) {
642: case W_CONNECT: /* If suspended during CONNECT? */
643: conbin((char)escape); /* put console back in binary mode */
644: debug(F100,"stptrap W_CONNECT","",0);
645: break;
646: #ifndef NOICP
647: case W_COMMAND: /* Suspended in command mode */
648: debug(F101,"stptrap W_COMMAND pflag","",pflag);
649: concb((char)escape); /* Put back CBREAK tty mode */
650: if (pflag) { /* If command parsing was */
651: prompt(xxstring); /* reissue the prompt and partial */
652: if (!cmflgs) /* command (if any) */
653: printf("%s",cmdbuf);
654: }
655: break;
656: #endif /* NOICP */
657: default: /* All other cases... */
658: debug(F100,"stptrap default","",0);
659: concb((char)escape); /* Put it back in CBREAK mode */
660: break;
661: }
662: }
663: #endif /* NOJC */
664: SIGRETURN;
665: }
666:
667: #ifndef MAC
668: /*
669: The rest of this file is for all implementations but the Macintosh.
670: */
671:
672: /* C H K I N T -- Check for console interrupts */
673:
674: int
675: chkint() {
676: int ch, cn; long zz;
677:
678: if ((!local) || (quiet)) return(0); /* Only do this if local & not quiet */
679: #ifdef datageneral
680: if (con_reads_mt) /* if conint_mt task is active */
681: if (conint_avl) { /* and there's an interrupt pending */
682: cn = 1; /* process it */
683: ch = conint_ch;
684: conint_avl = 0; /* turn off flag so conint_mt can */
685: } else /* proceed */
686: return(0);
687: else /* if conint_mt not active */
688: if ((ch = coninc(2)) < 0) /* try to get char manually */
689: return(0); /* I/O error, or no data */
690: else /* if successful, set cn so we */
691: cn = 1; /* know we got one */
692: debug(F101,"chkint got keyboard character",ch,cn);
693: #else
694: cn = conchk(); /* Any input waiting? */
695: debug(F101,"conchk","",cn);
696: if (cn < 1) return(0);
697: if ((ch = coninc(5)) < 0) return(0);
698: #endif /* datageneral */
699:
700: switch (ch & 0177) {
701: case 'A': case 'a': case 0001: /* Status report */
702: if (fdispla != XYFD_R && fdispla != XYFD_S)
703: return(0); /* Only for serial or simple */
704: screen(SCR_TN,0,0l,"Status report:");
705: screen(SCR_TN,0,0l," file type: ");
706: if (binary) {
707: #ifdef VMS
708: if (binary == XYFT_I) /* VMS-only file types */
709: screen(SCR_TZ,0,0l,"image");
710: else if (binary == XYFT_L)
711: screen(SCR_TZ,0,0l,"labeled");
712: else screen(SCR_TZ,0,0l,"binary");
713: #else
714: screen(SCR_TZ,0,0l,"binary");
715: #endif /* VMS */
716: } else {
717: screen(SCR_TZ,0,0l,"text");
718: }
719: screen(SCR_QE,0,filcnt," file number");
720: if (fsize) screen(SCR_QE,0,fsize," size");
721: screen(SCR_QE,0,ffc, " characters so far");
722: if (fsize > 0L) {
723: zz = ( ffc * 100L ) / fsize;
724: screen(SCR_QE,0,zz, " percent done");
725: }
726: if (bctu == 4) { /* Block check */
727: screen(SCR_TU,0,0L," block check: ");
728: screen(SCR_TZ,0,0L,"blank-free-2");
729: } else screen(SCR_QE,0,(long)bctu, " block check");
730: screen(SCR_QE,0,(long)rptflg," compression");
731: screen(SCR_QE,0,(long)ebqflg," 8th-bit prefixing");
732: screen(SCR_QE,0,(long)lscapu," locking shifts");
733: if (!network)
734: screen(SCR_QE,0, speed, " speed");
735: if (what == W_SEND)
736: screen(SCR_QE,0,(long)spsiz, " packet length");
737: else if (what == W_RECV || what == W_REMO)
738: screen(SCR_QE,0,(long)urpsiz," packet length");
739: screen(SCR_QE,0,(long)wslots, " window slots");
740: return(0);
741:
742: case 'B': case 'b': case 0002: /* Cancel batch */
743: case 'Z': case 'z': case 0032:
744: screen(SCR_TN,0,0l,"Cancelling Batch ");
745: czseen = 1;
746: return(0);
747:
748: case 'F': case 'f': case 0006: /* Cancel file */
749: case 'X': case 'x': case 0030:
750: screen(SCR_TN,0,0l,"Cancelling File ");
751: cxseen = 1;
752: return(0);
753:
754: case 'R': case 'r': case 0022: /* Resend */
755: case 0015: case 0012:
756: screen(SCR_TN,0,0l,"Resending packet ");
757: numerrs++;
758: resend(winlo);
759: return(1);
760:
761: case 'E': case 'e': /* Send error packet */
762: case 0005:
763: return(-1);
764:
765: #ifdef datageneral
766: case '\03': /* We're not trapping ^C's with */
767: trap(0); /* signals, so we check here */
768: #endif /* datageneral */
769:
770: default: /* Anything else, print message */
771: intmsg(1);
772: return(0);
773: }
774: }
775:
776: /* I N T M S G -- Issue message about terminal interrupts */
777:
778: VOID
779: #ifdef CK_ANSIC
780: intmsg(long n)
781: #else
782: intmsg(n) long n;
783: #endif /* CK_ANSIC */
784: /* intmsg */ {
785: char buf[80];
786:
787: if (!displa || quiet) /* Not if we're being quiet */
788: return;
789: if (server && (!srvdis || n > -1L)) /* Special for server */
790: return;
791: buf[0] = NUL; /* Keep compilers happy */
792: #ifdef SVORPOSIX
793: conchk(); /* Clear out pending escape-signals */
794: #endif /* SVORPOSIX */
795: #ifdef VMS
796: conres(); /* So Ctrl-C will work */
797: #endif /* VMS */
798: if ((!server && n == 1L) || (server && n < 0L)) {
799:
800: #ifdef SVORPOSIX /* We need to signal before kb input */
801: #ifndef aegis
802: #ifndef datageneral
803: sprintf(buf,"Type escape character (%s) followed by:",dbchr(escape));
804: screen(SCR_TN,0,0l,buf);
805: #endif /* datageneral */
806: #endif /* aegis */
807: #endif /* SVORPOSIX */
808:
809: screen(SCR_TN,0,0l,"X to cancel file, CR to resend current packet");
810: screen(SCR_TN,0,0l,"Z to cancel group, A for status report");
811: screen(SCR_TN,0,0l,"E to send Error packet, Ctrl-C to quit immediately: ");
812: /* if (server) */ screen(SCR_TN,0,0l,"");
813: }
814: else screen(SCR_TU,0,0l," ");
815: }
816:
817: static int newdpy = 0; /* New display flag */
818: static char fbuf[80]; /* Filename buffer */
819: static char abuf[80]; /* As-name buffer */
820: static long oldffc = 0L;
821: static long dots = 0L;
822: static int hpos = 0;
823:
824: static VOID /* Initialize Serial or CTR display */
825: dpyinit() {
826: newdpy = 0; /* Don't do this again */
827: oldffc = 0L; /* Reset this */
828: dots = 0L; /* and this.. */
829: conoll(""); /* New line */
830: if (what == W_SEND) conol("Sending: "); /* Action */
831: else if (what == W_RECV) conol("Receiving: ");
832: conol(fbuf);
833: if (*abuf) conol(" => "); conoll(abuf); /* Names */
834: *fbuf = NUL; *abuf = NUL;
835: if (fsize > -1L) { /* Size */
836: sprintf(fbuf,"Size: %ld, Type: ",fsize);
837: conol(fbuf); *fbuf = NUL;
838: } else conol("Size: unknown, Type: ");
839: if (binary) { /* Type */
840: #ifdef VMS
841: if (binary == XYFT_I) /* VMS-only file types */
842: conoll("image");
843: else if (binary == XYFT_L)
844: conoll("labeled");
845: else
846: #endif /* VMS */
847: conoll("binary");
848: } else conoll("text");
849: if (fdispla == XYFD_S) { /* CRT field headings */
850:
851: /*
852: Define CK_CPS to show current transfer rate.
853: Leave it undefined to show estimated time remaining.
854: Estimated-time-remaining code from Andy Fyfe, not tested on
855: pathological cases.
856: */
857: #define CK_CPS
858:
859: #ifdef CK_CPS
860: conoll(" File Percent Packet");
861: conoll(" Bytes Done CPS Length");
862: #else
863: conoll(" File Percent Secs Packet");
864: conoll(" Bytes Done Left Length");
865: #endif /* CK_CPS */
866: newdpy = 0;
867: }
868: hpos = 0;
869: }
870:
871: /*
872: showpkt(c)
873: c = completion code: 0 means transfer in progress, nonzero means it's done.
874: show the file transfer progress counter and perhaps verbose packet type.
875: Original by: Kai Uwe Rommel.
876: */
877: VOID
878: #ifdef CK_ANSIC
879: showpkt(char c)
880: #else
881: showpkt(c) char c;
882: #endif /* CK_ANSIC */
883: /* showpkt */ {
884:
885: if (newdpy) /* Put up filenames, etc, */
886: dpyinit(); /* if they're not there already. */
887:
888: if (fdispla == XYFD_S) { /* CRT display */
889: char buffer[40];
890: long et; /* Elapsed time, entire batch */
891: long pd; /* Percent done, this file */
892: long tp; /* Transfer rate, entire batch */
893: long ps; /* Packet size, current packet */
894: long myffc, mytfc; /* Local copies of byte counters */
895:
896: et = gtimer(); /* Elapsed time */
897: ps = (what == W_RECV) ? rpktl+1 : spktl+1; /* Packet length */
898: pd = -1; /* Percent done. */
899: if (c == NUL) { /* Still going, figure % done */
900: if (fsize == 0L) return; /* Empty file, don't bother */
901: pd = (fsize > 99L) ? (ffc / (fsize / 100L)) : 0L;
902: if (pd > 100) pd = 100; /* Expansion */
903: } else pd = 100; /* File complete, so 100%. */
904:
905: #ifndef CK_CPS
906: /*
907: fsecs = time (from gtimer) that this file started (set in sfile()).
908: Rate so far is ffc / (et - fsecs), estimated time for remaining bytes
909: is (fsize - ffc) / ( ffc / (et - fsecs )).
910: */
911: tp = (ffc > 0L) ? (fsize - ffc) * (et - fsecs) / ffc : 0L;
912: #endif /* CK_CPS */
913:
914: myffc = (ffc > 0) ? ffc - 1L : ffc; /* No, I don't know why... */
915: if (myffc < 0L) myffc = 0L;
916: #ifdef CK_CPS
917: mytfc = (pd < 100) ? tfc + myffc : tfc;
918: tp = (et > 0) ? mytfc / et : 0; /* Transfer rate */
919: if (c && (tp == 0)) /* Watch out for subsecond times */
920: tp = myffc;
921: #endif /* CK_CPS */
922: if (pd > -1L)
923: sprintf(buffer, "%c%9ld%5ld%%%8ld%8ld ", CR, myffc, pd, tp, ps);
924: else
925: sprintf(buffer, "%c%9ld %8ld%8ld ", CR, myffc, tp, ps);
926: conol(buffer);
927: hpos = 31;
928: } else { /* SERIAL display */
929: long i, k;
930: if (ffc - oldffc < 1024) /* Update display every 1K */
931: return;
932: oldffc = ffc; /* Time for new display */
933: k = (ffc / 1024L) - dots; /* How many K so far */
934: for (i = 0L; i < k; i++) {
935: if (hpos++ > 77) { /* Time to wrap? */
936: conoll("");
937: hpos = 0;
938: }
939: conoc('.'); /* Print a dot for this K */
940: dots++; /* Count it */
941: }
942: }
943: }
944:
945: /* S C R E E N -- Screen display function */
946:
947: /*
948: screen(f,c,n,s)
949: f - argument descriptor
950: c - a character or small integer
951: n - a long integer
952: s - a string.
953: Fill in this routine with the appropriate display update for the system.
954: FILE DISPLAY SERIAL: Default, works on any terminal, even hardcopy.
955: FILE DISPLAY CRT: Works on any CRT, writes over current line.
956: FILE DISPLAY FULLSCREEN: Requires terminal-dependent screen control.
957: */
958: VOID
959: #ifdef CK_ANSIC
960: screen(int f, char c,long n,char *s)
961: #else
962: screen(f,c,n,s) int f; char c; long n; char *s;
963: #endif /* CK_ANSIC */
964: /* screen */ {
965: char buf[80];
966: int len; /* Length of string */
967: #ifdef UNIX
968: #ifndef NOJC
969: int obg;
970: _PROTOTYP( VOID conbgt, (int) );
971:
972: if (local) {
973: obg = backgrd; /* Previous background status */
974: conbgt(1); /* See if running in background */
975: if (!backgrd && obg) { /* Just came into foreground? */
976: concb((char)escape); /* Put console back in CBREAK mode */
977: conint(trap,stptrap); /* Turn interrupts back on. */
978: }
979: }
980: #endif /* NOJC */
981: #endif /* UNIX */
982:
983: if ((f != SCR_WM) && (f != SCR_EM)) /* Always update warnings & errors */
984: if (!displa || quiet || backgrd || fdispla == XYFD_N ||
985: (server && !srvdis))
986: return;
987:
988: #ifdef CK_CURSES
989: if (fdispla == XYFD_C) { /* If fullscreen display selected */
990: screenc(f,c,n,s); /* call the fullscreen version */
991: return;
992: }
993: #endif /* CK_CURSES */
994:
995: len = (int)strlen(s); /* Length of string */
996:
997: switch (f) { /* Handle our function code */
998:
999: case SCR_FN: /* Filename */
1000: #ifdef MAC
1001: conoll(""); conol(s); conoc(SP); hpos = len + 1;
1002: #else
1003: strncpy(fbuf,s,80);
1004: newdpy = 1; /* New file so refresh display */
1005: #endif /* MAC */
1006: return;
1007:
1008: case SCR_AN: /* As-name */
1009: #ifdef MAC
1010: if (hpos + len > 75) { conoll(""); hpos = 0; }
1011: conol("=> "); conol(s);
1012: if ((hpos += (len + 3)) > 78) { conoll(""); hpos = 0; }
1013: #else
1014: strncpy(abuf,s,80);
1015: #endif /* MAC */
1016: return;
1017:
1018: case SCR_FS: /* File-size */
1019: #ifdef MAC
1020: sprintf(buf,", Size: %ld",n); conoll(buf); hpos = 0;
1021: #endif /* MAC */
1022: return;
1023:
1024: case SCR_XD: /* X-packet data */
1025: #ifdef MAC
1026: conoll(""); conoll(s); hpos = 0;
1027: #else
1028: strncpy(fbuf,s,80);
1029: #endif /* MAC */
1030: return;
1031:
1032: case SCR_ST: /* File status */
1033: switch (c) {
1034: case ST_OK: /* Transferred OK */
1035: showpkt('Z'); /* Update numbers one last time */
1036: if ((hpos += 5) > 78) conoll(""); /* Wrap screen line if necessary. */
1037: conoll(" [OK]"); hpos = 0; /* Print OK message. */
1038: if (fdispla == XYFD_S) { /* We didn't show Z packet when */
1039: conoc('Z'); /* it came, so show it now. */
1040: hpos = 1;
1041: }
1042: return;
1043:
1044: case ST_DISC: /* Discarded */
1045: if ((hpos += 12) > 78) conoll("");
1046: conoll(" [discarded]"); hpos = 0;
1047: return;
1048:
1049: case ST_INT: /* Interrupted */
1050: if ((hpos += 14) > 78) conoll("");
1051: conoll(" [interrupted]"); hpos = 0;
1052: return;
1053:
1054: case ST_SKIP: /* Skipped */
1055: if ((hpos += 10) > 78) conoll("");
1056: conol(" [skipped]"); hpos = 0;
1057: return;
1058:
1059: case ST_ERR: /* Error */
1060: conoll("");
1061: conol("Error: "); conoll(s); hpos = 0;
1062: return;
1063:
1064: case ST_REFU: /* Refused */
1065: conoll("");
1066: conol("Refused: "); conoll(s); hpos = 0;
1067: return;
1068:
1069: case ST_INC: /* Incomplete */
1070: if ((hpos += 12) > 78) conoll("");
1071: conoll(" [incomplete]"); hpos = 0;
1072: return;
1073:
1074: default:
1075: conoll("*** screen() called with bad status ***");
1076: hpos = 0;
1077: return;
1078: }
1079:
1080: #ifdef MAC
1081: case SCR_PN: /* Packet number */
1082: sprintf(buf,"%s: %ld",s,n); conol(buf); hpos += (int)strlen(buf); return;
1083: #endif /* MAC */
1084:
1085: case SCR_PT: /* Packet type or pseudotype */
1086: if (c == 'Y') return; /* Don't bother with ACKs */
1087: if (c == 'D') { /* In data transfer phase, */
1088: showpkt(NUL); /* show progress. */
1089: return;
1090: }
1091: #ifndef AMIGA
1092: if (hpos++ > 77) { /* If near right margin, */
1093: conoll(""); /* Start new line */
1094: hpos = 0; /* and reset counter. */
1095: }
1096: #endif /* AMIGA */
1097: if (c == 'Z' && fdispla == XYFD_S)
1098: return;
1099: else
1100: conoc(c); /* Display the packet type. */
1101: #ifdef AMIGA
1102: if (c == 'G') conoll(""); /* New line after G packets */
1103: #endif /* AMIGA */
1104: return;
1105:
1106: case SCR_TC: /* Transaction complete */
1107: conoc(BEL); conoll(""); return;
1108:
1109: case SCR_EM: /* Error message */
1110: conoll(""); conoc('?'); conoll(s); hpos = 0; return;
1111:
1112: case SCR_WM: /* Warning message */
1113: conoll(""); conoll(s); hpos = 0; return;
1114:
1115: case SCR_TU: /* Undelimited text */
1116: if ((hpos += len) > 77) { conoll(""); hpos = len; }
1117: conol(s); return;
1118:
1119: case SCR_TN: /* Text delimited at beginning */
1120: conoll(""); conol(s); hpos = len; return;
1121:
1122: case SCR_TZ: /* Text delimited at end */
1123: if ((hpos += len) > 77) { conoll(""); hpos = len; }
1124: conoll(s); return;
1125:
1126: case SCR_QE: /* Quantity equals */
1127: sprintf(buf,"%s: %ld",s,n);
1128: conoll(buf); hpos = 0; return;
1129:
1130: case SCR_CW: /* Close fullscreen window */
1131: return; /* No window to close */
1132:
1133: default:
1134: conoll("*** screen() called with bad object ***");
1135: hpos = 0;
1136: return;
1137: }
1138: }
1139:
1140: /* E R M S G -- Nonfatal error message */
1141:
1142: /* Should be used only for printing the message text from an Error packet. */
1143:
1144: VOID
1145: ermsg(msg) char *msg; { /* Print error message */
1146: if (local)
1147: screen(SCR_EM,0,0L,msg);
1148: tlog(F110,"Protocol Error:",msg,0L);
1149: }
1150:
1151: VOID
1152: doclean() { /* General cleanup upon exit */
1153: #ifndef NOICP
1154: #ifndef NOSPL
1155: extern struct mtab *mactab; /* For ON_EXIT macro. */
1156: extern int nmac;
1157: #endif /* NOSPL */
1158: #endif /* NOICP */
1159:
1160: #ifdef DEBUG
1161: if (deblog) { /* Close any open logs. */
1162: debug(F100,"Debug Log Closed","",0);
1163: *debfil = '\0';
1164: deblog = 0;
1165: zclose(ZDFILE);
1166: }
1167: #endif /* DEBUG */
1168: if (pktlog) {
1169: *pktfil = '\0';
1170: pktlog = 0;
1171: zclose(ZPFILE);
1172: }
1173: if (seslog) {
1174: *sesfil = '\0';
1175: seslog = 0;
1176: zclose(ZSFILE);
1177: }
1178: #ifdef TLOG
1179: if (tralog) {
1180: tlog(F100,"Transaction Log Closed","",0L);
1181: *trafil = '\0';
1182: tralog = 0;
1183: zclose(ZTFILE);
1184: }
1185: #endif /* TLOG */
1186:
1187: #ifndef NOICP
1188: #ifndef NOSPL
1189: zclose(ZRFILE); /* READ and WRITE files, if any. */
1190: zclose(ZWFILE);
1191: #ifndef NODIAL
1192: if (dialfd) fclose(dialfd); /* Dial directory, if any. */
1193: #endif /* NODIAL */
1194: /*
1195: If a macro named "on_exit" is defined, execute it. Also remove it from the
1196: macro table, in case its definition includes an EXIT or QUIT command, which
1197: would cause much recursion and would prevent the program from ever actually
1198: EXITing.
1199: */
1200: if (nmac) { /* Any macros defined? */
1201: int k; /* Yes */
1202: k = mlook(mactab,"on_exit",nmac); /* Look up "on_exit" */
1203: if (k >= 0) { /* If found, */
1204: *(mactab[k].kwd) = NUL; /* poke its name from the table, */
1205: if (dodo(k,"") > -1) /* set it up, */
1206: parser(1); /* and execute it */
1207: }
1208: }
1209: #endif /* NOSPL */
1210: #endif /* NOICP */
1211:
1212: /*
1213: Put console terminal back to normal. This is done here because the
1214: ON_EXIT macro calls the parser, which meddles with console terminal modes.
1215: */
1216: ttclos(0); /* Close external line, if any */
1217: if (local) {
1218: strcpy(ttname,dftty); /* Restore default tty */
1219: local = dfloc; /* And default remote/local status */
1220: }
1221: conres(); /* Restore console terminal. */
1222:
1223: #ifdef COMMENT
1224: /* Should be no need for this, and maybe it's screwing things up? */
1225: connoi(); /* Turn off console interrupt traps */
1226: #endif /* COMMENT */
1227:
1228: syscleanup(); /* System-dependent cleanup, last */
1229: }
1230:
1231: /* D O E X I T -- Exit from the program. */
1232:
1233: /*
1234: First arg is general, system-independent symbol: GOOD_EXIT or BAD_EXIT.
1235: If second arg is -1, take 1st arg literally.
1236: If second arg is not -1, work it into the exit code.
1237: */
1238: VOID
1239: doexit(exitstat,what) int exitstat, what; {
1240: #ifdef VMS
1241: char envstr[64];
1242: static $DESCRIPTOR(symnam,"CKERMIT_STATUS");
1243: static struct dsc$descriptor_s symval;
1244: int i;
1245: #endif /* VMS */
1246:
1247: debug(F101,"doexit exitstat","",exitstat);
1248: debug(F101,"doexit what","",what);
1249:
1250: doclean(); /* First, clean up everything */
1251:
1252: #ifdef VMS
1253: if (what == -1)
1254: what = 0; /* Since we set two different items */
1255: sprintf(envstr,"%d", exitstat | what);
1256: symval.dsc$w_length = (int)strlen(envstr);
1257: symval.dsc$a_pointer = envstr;
1258: symval.dsc$b_class = DSC$K_CLASS_S;
1259: symval.dsc$b_dtype = DSC$K_DTYPE_T;
1260: i = 2; /* Store in global table */
1261: LIB$SET_SYMBOL(&symnam, &symval, &i);
1262: if (exitstat == BAD_EXIT)
1263: exitstat = SS$_ABORT | STS$M_INHIB_MSG;
1264: if (exitstat == GOOD_EXIT)
1265: exitstat = SS$_NORMAL | STS$M_INHIB_MSG;
1266: exit(exitstat);
1267: #else /* Not VMS */
1268: if (what == -1) /* Take 1st arg literally */
1269: exit(exitstat); /* e.g. user-supplied exit code */
1270: else /* otherwise */
1271: exit(exitstat | what); /* OR in the bits */
1272: #endif /* VMS */
1273: }
1274:
1275: /* Set up interrupts */
1276:
1277: VOID
1278: setint() {
1279: conint(trap,stptrap); /* Turn on console terminal interrupts. */
1280: bgchk(); /* Check background status */
1281: }
1282:
1283: VOID
1284: bgchk() { /* Check background status */
1285: if (bgset < 0)
1286: pflag = !backgrd; /* Set prompt flag */
1287: else /* based on foreground/background */
1288: pflag = (bgset == 0 ? 1 : 0);
1289:
1290: /* Message flag on only if at top level, pflag is on, and QUIET is OFF */
1291:
1292: if (
1293: #ifndef NOSPL
1294: cmdlvl == 0
1295: #else
1296: tlevel < 0
1297: #endif /* NOSPL */
1298: )
1299: msgflg = (pflag == 0) ? 0 : !quiet;
1300: else msgflg = 0;
1301: }
1302:
1303: #ifdef DEBUG
1304: /* D E B U G -- Enter a record in the debugging log */
1305:
1306: /*
1307: Call with a format, two strings, and a number:
1308: f - Format, a bit string in range 0-7.
1309: If bit x is on, then argument number x is printed.
1310: s1 - String, argument number 1. If selected, printed as is.
1311: s2 - String, argument number 2. If selected, printed in brackets.
1312: n - Int, argument 3. If selected, printed preceded by equals sign.
1313:
1314: f=0 is special: print s1,s2, and interpret n as a char.
1315: */
1316: #define DBUFL 2300
1317: static char *dbptr = (char *)0;
1318:
1319: int
1320: dodebug(f,s1,s2,n) int f; char *s1, *s2; long n; {
1321: char *sp;
1322:
1323: if (!deblog) return(0); /* If no debug log, don't. */
1324: if (!dbptr) {
1325: dbptr = malloc(DBUFL+1);
1326: if (!dbptr)
1327: return(0);
1328: }
1329: sp = dbptr;
1330: if (!s1) s1="(NULL)";
1331: if (!s2) s2="(NULL)";
1332: switch (f) {
1333: case F000: /* 0, print both strings, and n as a char */
1334: if ((int)strlen(s1) + (int)strlen(s2) + 5 > DBUFL) {
1335: sprintf(sp,"DEBUG string too long\n");
1336: } else {
1337: if (n > 31 && n < 127)
1338: sprintf(sp,"%s%s:%c\n",s1,s2,n);
1339: else if (n < 32 || n == 127)
1340: sprintf(sp,"%s%s:^%c\n",s1,s2,(n+64) & 0x7F);
1341: else if (n > 127 && n < 160)
1342: sprintf(sp,"%s%s:~^%c\n",s1,s2,(n-64) & 0x7F);
1343: else if (n > 159 && n < 256)
1344: sprintf(sp,"%s%s:~%c\n",s1,s2,n & 0x7F);
1345: else sprintf(sp,"%s%s:%ld\n",s1,s2,n);
1346: }
1347: if (zsout(ZDFILE,dbptr) < 0) deblog = 0;
1348: break;
1349: case F001: /* 1, "=n" */
1350: sprintf(sp,"=%ld\n",n);
1351: if (zsout(ZDFILE,dbptr) < 0) deblog = 0;
1352: break;
1353: case F010: /* 2, "[s2]" */
1354: if ((int)strlen(s2) + 4 > DBUFL)
1355: sprintf(sp,"DEBUG string too long\n");
1356: else sprintf(sp,"[%s]\n",s2);
1357: if (zsout(ZDFILE,"") < 0) deblog = 0;
1358: break;
1359: case F011: /* 3, "[s2]=n" */
1360: if ((int)strlen(s2) + 15 > DBUFL)
1361: sprintf(sp,"DEBUG string too long\n");
1362: else sprintf(sp,"[%s]=%ld\n",s2,n);
1363: if (zsout(ZDFILE,dbptr) < 0) deblog = 0;
1364: break;
1365: case F100: /* 4, "s1" */
1366: if (zsoutl(ZDFILE,s1) < 0) deblog = 0;
1367: break;
1368: case F101: /* 5, "s1=n" */
1369: if ((int)strlen(s1) + 15 > DBUFL)
1370: sprintf(sp,"DEBUG string too long\n");
1371: else sprintf(sp,"%s=%ld\n",s1,n);
1372: if (zsout(ZDFILE,dbptr) < 0) deblog = 0;
1373: break;
1374: case F110: /* 6, "s1[s2]" */
1375: if ((int)strlen(s1) + (int)strlen(s2) + 4 > DBUFL)
1376: sprintf(sp,"DEBUG string too long\n");
1377: else sprintf(sp,"%s[%s]\n",s1,s2);
1378: if (zsout(ZDFILE,dbptr) < 0) deblog = 0;
1379: break;
1380: case F111: /* 7, "s1[s2]=n" */
1381: if ((int)strlen(s1) + (int)strlen(s2) + 15 > DBUFL)
1382: sprintf(sp,"DEBUG string too long\n");
1383: else sprintf(sp,"%s[%s]=%ld\n",s1,s2,n);
1384: if (zsout(ZDFILE,dbptr) < 0) deblog = 0;
1385: break;
1386: default:
1387: sprintf(sp,"\n?Invalid format for debug() - %d\n",f);
1388: if (zsout(ZDFILE,dbptr) < 0) deblog = 0;
1389: }
1390: return(0);
1391: }
1392: #endif /* DEBUG */
1393:
1394: #ifdef TLOG
1395: #define TBUFL 300
1396: /* T L O G -- Log a record in the transaction file */
1397: /*
1398: Call with a format and 3 arguments: two strings and a number:
1399: f - Format, a bit string in range 0-7, bit x is on, arg #x is printed.
1400: s1,s2 - String arguments 1 and 2.
1401: n - Int, argument 3.
1402: */
1403: VOID
1404: tlog(f,s1,s2,n) int f; long n; char *s1, *s2; {
1405: static char s[TBUFL];
1406: char *sp = s; int x;
1407:
1408: if (!tralog) return; /* If no transaction log, don't */
1409: switch (f) {
1410: case F000: /* 0 (special) "s1 n s2" */
1411: if ((int)strlen(s1) + (int)strlen(s2) + 15 > TBUFL)
1412: sprintf(sp,"?T-Log string too long\n");
1413: else sprintf(sp,"%s %ld %s\n",s1,n,s2);
1414: if (zsout(ZTFILE,s) < 0) tralog = 0;
1415: break;
1416: case F001: /* 1, " n" */
1417: sprintf(sp," %ld\n",n);
1418: if (zsout(ZTFILE,s) < 0) tralog = 0;
1419: break;
1420: case F010: /* 2, "[s2]" */
1421: x = (int)strlen(s2);
1422: if (s2[x] == '\n') s2[x] = '\0';
1423: if (x + 6 > TBUFL)
1424: sprintf(sp,"?T-Log string too long\n");
1425: else sprintf(sp,"[%s]\n",s2);
1426: if (zsout(ZTFILE,"") < 0) tralog = 0;
1427: break;
1428: case F011: /* 3, "[s2] n" */
1429: x = (int)strlen(s2);
1430: if (s2[x] == '\n') s2[x] = '\0';
1431: if (x + 6 > TBUFL)
1432: sprintf(sp,"?T-Log string too long\n");
1433: else sprintf(sp,"[%s] %ld\n",s2,n);
1434: if (zsout(ZTFILE,s) < 0) tralog = 0;
1435: break;
1436: case F100: /* 4, "s1" */
1437: if (zsoutl(ZTFILE,s1) < 0) tralog = 0;
1438: break;
1439: case F101: /* 5, "s1: n" */
1440: if ((int)strlen(s1) + 15 > TBUFL)
1441: sprintf(sp,"?T-Log string too long\n");
1442: else sprintf(sp,"%s: %ld\n",s1,n);
1443: if (zsout(ZTFILE,s) < 0) tralog = 0;
1444: break;
1445: case F110: /* 6, "s1 s2" */
1446: x = (int)strlen(s2);
1447: if (s2[x] == '\n') s2[x] = '\0';
1448: if ((int)strlen(s1) + x + 4 > TBUFL)
1449: sprintf(sp,"?T-Log string too long\n");
1450: else sprintf(sp,"%s %s\n",s1,s2);
1451: if (zsout(ZTFILE,s) < 0) tralog = 0;
1452: break;
1453: case F111: /* 7, "s1 s2: n" */
1454: x = (int)strlen(s2);
1455: if (s2[x] == '\n') s2[x] = '\0';
1456: if ((int)strlen(s1) + x + 15 > TBUFL)
1457: sprintf(sp,"?T-Log string too long\n");
1458: else sprintf(sp,"%s %s: %ld\n",s1,s2,n);
1459: if (zsout(ZTFILE,s) < 0) tralog = 0;
1460: break;
1461: default:
1462: sprintf(sp,"\n?Invalid format for tlog() - %ld\n",n);
1463: if (zsout(ZTFILE,s) < 0) tralog = 0;
1464: }
1465: }
1466: #endif /* TLOG */
1467:
1468: #ifdef CK_CURSES
1469:
1470: /*
1471: There are three different ways to do fullscreen on VMS.
1472: 1. Use the real curses library, VAXCCURSE.
1473: 2. Use do-it-yourself code.
1474: 3. Use the Screen Manager, SMG$.
1475:
1476: Method 1 doesn't work quite right; you can't call endwin(), so once you've
1477: started curses mode, you can never leave.
1478:
1479: Method 2 doesn't optimize the screen, and so much more time is spent in
1480: screen writes. This actually causes file transfers to fail because the
1481: tty device input buffer can be overrun while the screen is being updated,
1482: especially on a slow MicroVAX that has small typeahead buffers.
1483:
1484: In the following #ifdef block, #define one of them and #undef the other 2.
1485:
1486: So now let's try method 3...
1487: */
1488: #ifdef VMS
1489: #define CK_SMG /* Screen Manager */
1490: #undef MYCURSES /* Do-it-yourself */
1491: #undef VMSCURSE /* VAXCCURSE library */
1492: #endif /* VMS */
1493:
1494: /* S C R E E N C -- Screen display function, uses curses */
1495:
1496: /* Idea for curses display contributed by Chris Pratt of APV Baker, UK */
1497:
1498: /* Avoid conficts with curses.h */
1499:
1500: #ifndef MYCURSES
1501: #undef VOID /* This was defined in ckcdeb.h */
1502: #endif /* MYCURSES */
1503:
1504: #undef BS /* These were defined in ckcasc.h */
1505: #undef CR
1506: #undef NL
1507: #undef SO
1508: #undef US
1509:
1510: #ifdef VMS /* VMS fullscreen display */
1511: #ifdef MYCURSES /* Do-it-yourself method */
1512: extern int isvt52; /* From CKVTIO.C */
1513: #define printw printf
1514: #else
1515: #ifdef VMSCURSE /* VMS curses library VAXCCURSE */
1516: #include <curses.h>
1517: /* Note: Screen manager doesn't need a header file */
1518: #endif /* VMSCURSE */
1519: #endif /* MYCURSES */
1520: #else /* Not VMS */
1521: #ifdef MYCURSES /* Do-it-yourself method */
1522: #define isvt52 0 /* Used by OS/2, VT-100/ANSI always */
1523: #define printw printf
1524: #else
1525: #include <curses.h> /* So use real curses */
1526: #endif /* MYCURSES */
1527: #endif /* VMS */
1528:
1529: #ifdef CK_SMG
1530: /*
1531: Long section for Screen Manager starts here...
1532: By William Bader.
1533: */
1534: #include "ckvvms.h"
1535: /* #include <smgdef.h> */
1536: /* #include <smgmsg.h> */
1537:
1538: extern unsigned int vms_status; /* Used for system service return status */
1539:
1540: static long smg_pasteboard_id = -1; /* pasteboard identifier */
1541: static long smg_display_id = -1; /* display identifier */
1542: static int smg_open = 0; /* flag if smg current open */
1543:
1544: #define clrtoeol() SMG$ERASE_LINE(&smg_display_id, 0, 0)
1545:
1546: #define clear() SMG$ERASE_DISPLAY(&smg_display_id, 0, 0, 0, 0)
1547:
1548: #define touchwin(scr) SMG$REPAINT_SCREEN(&smg_pasteboard_id)
1549:
1550: static void
1551: move(row, col) int row, col; {
1552: /* Change from 0-based for curses to 1-based for SMG */
1553: ++row; ++col;
1554: CHECK_ERR("move: smg$set_cursor_abs",
1555: SMG$SET_CURSOR_ABS(&smg_display_id, &row, &col));
1556: }
1557:
1558: static void
1559: refresh() {
1560: CHECK_ERR("refresh: smg$end_pasteboard_update",
1561: SMG$END_PASTEBOARD_UPDATE(&smg_pasteboard_id));
1562: CHECK_ERR("refresh: smg$begin_pasteboard_update",
1563: SMG$BEGIN_PASTEBOARD_UPDATE(&smg_pasteboard_id));
1564: }
1565:
1566: #ifdef VMS_V40
1567: #define OLD_VMS
1568: #endif /* VMS_V40 */
1569: #ifdef VMS_V42
1570: #define OLD_VMS
1571: #endif /* VMS_V42 */
1572: #ifdef VMS_V44
1573: #define OLD_VMS
1574: #endif /* VMS_V44 */
1575:
1576: static int
1577: initscr() {
1578: int rows = 24, cols = 80;
1579: int row = 1, col = 1;
1580:
1581: if (smg_pasteboard_id == -1) { /* Open the screen */
1582: #ifdef OLD_VMS
1583: CHECK_ERR("initscr: smg$create_pasteboard",
1584: SMG$CREATE_PASTEBOARD(&smg_pasteboard_id, 0, 0, 0, 0));
1585: #else
1586: /* For VMS V5, not tested */
1587: CHECK_ERR("initscr: smg$create_pasteboard",
1588: SMG$CREATE_PASTEBOARD(&smg_pasteboard_id, 0, 0, 0, 0, 0));
1589: #endif /* OLD_VMS */
1590: }
1591:
1592: if (smg_display_id == -1) { /* Create a display window */
1593:
1594: CHECK_ERR("initscr: smg$create_virtual_display",
1595: SMG$CREATE_VIRTUAL_DISPLAY(&rows, &cols, &smg_display_id,
1596: 0, 0, 0));
1597:
1598: /* Connect the display window to the screen */
1599: CHECK_ERR("initscr: smg$paste_virtual_display",
1600: SMG$PASTE_VIRTUAL_DISPLAY(&smg_display_id,&smg_pasteboard_id,
1601: &row,&col));
1602: }
1603:
1604: if (!smg_open) { /* Start a batch update */
1605: smg_open = 1;
1606: CHECK_ERR("initscr: smg$begin_pasteboard_update",
1607: SMG$BEGIN_PASTEBOARD_UPDATE(&smg_pasteboard_id));
1608: }
1609: return(1);
1610: }
1611:
1612: static void
1613: endwin() {
1614: if (!smg_open)
1615: return;
1616:
1617: smg_open = 0;
1618:
1619: CHECK_ERR("endwin: smg$end_pasteboard_update",
1620: SMG$END_PASTEBOARD_UPDATE(&smg_pasteboard_id));
1621:
1622: move(22, 0);
1623:
1624: #ifdef COMMENT
1625: /*
1626: These calls clear the screen.
1627: */
1628: CHECK_ERR("endwin: smg$delete_virtual_display",
1629: SMG$DELETE_VIRTUAL_DISPLAY(&smg_display_id));
1630: smg_display_id = -1;
1631:
1632: CHECK_ERR("endwin: smg$delete_pasteboard",
1633: SMG$DELETE_PASTEBOARD(&smg_pasteboard_id, 0));
1634: smg_pasteboard_id = -1;
1635: #endif /* COMMENT */
1636: }
1637:
1638: static void printw(str, a1, a2, a3, a4, a5, a6, a7, a8)
1639: char *str;
1640: long a1, a2, a3, a4, a5, a6, a7, a8;
1641: /* printw */ {
1642: char buf[255];
1643: $DESCRIPTOR(text_dsc, buf);
1644:
1645: text_dsc.dsc$w_length = sprintf(buf, str, a1, a2, a3, a4, a5, a6, a7, a8);
1646: CHECK_ERR("printw: smg$put_chars",
1647: SMG$PUT_CHARS(&smg_display_id, &text_dsc, 0, 0, 0, 0, 0));
1648: }
1649: #endif /* CK_SMG */
1650:
1651: #ifdef MYCURSES
1652: /*
1653: Do-it-yourself curses implementation for VMS, OS/2 and other ANSI/VT-100's.
1654: Supports only the VT52 and VT1xx (and later VT2xx/3xx/4xx) terminals.
1655: By Terry Kennedy, St Peters College.
1656:
1657: First, some stuff we can just ignore:
1658: */
1659:
1660: int
1661: touchwin(x) int x; {
1662: }
1663: int
1664: initscr() {
1665: }
1666: int
1667: refresh() {
1668: }
1669: int
1670: endwin() {
1671: }
1672:
1673: /*
1674: * Now, some stuff we need to do:
1675: */
1676:
1677: _PROTOTYP( int move, (int, int) );
1678:
1679: int
1680: move(row, col) int row, col; {
1681: if (isvt52)
1682: printf("\033Y%c%c", row + 037, col + 037);
1683: else
1684: printf("\033[%d;%dH", row + 1, col + 1);
1685: }
1686:
1687: int
1688: clear() {
1689: move(1,1);
1690: if (isvt52)
1691: printf("\033J");
1692: else
1693: printf("\033[J");
1694: }
1695:
1696: int
1697: clrtoeol() {
1698: if (isvt52)
1699: printf("\033K");
1700: else
1701: printf("\033[K");
1702: }
1703: #endif /* MYCURSES */
1704:
1705: /* Screen line numbers */
1706:
1707: #define CW_BAN 0 /* Curses Window Banner */
1708: #define CW_DIR 2 /* Current directory */
1709: #define CW_LIN 3 /* Communication device */
1710: #define CW_SPD 4 /* Communication speed */
1711: #define CW_PAR 5 /* Parity */
1712: #define CW_NAM 7 /* Filename */
1713: #define CW_TYP 8 /* File type */
1714: #define CW_SIZ 9 /* File size */
1715: #define CW_PCD 10 /* Percent done */
1716: #define CW_TR 11 /* Time remaining */
1717: #define CW_WS 12 /* Window slots */
1718: #define CW_PT 13 /* Packet type */
1719: #define CW_PC 14 /* Packet count */
1720: #define CW_PL 15 /* Packet length */
1721: #define CW_PR 16 /* Packet retry */
1722: #define CW_PB 17 /* Packet block check */
1723: #define CW_ERR 19 /* Error message */
1724: #define CW_MSG 20 /* Info message */
1725: #define CW_INT 22 /* Instructions */
1726:
1727: static int cinit = 0; /* Flag for curses init'd */
1728: static int cendw = 0; /* endwin() was called */
1729:
1730: static
1731: #ifdef CK_ANSIC /* Because VOID used by curses.h */
1732: void
1733: #else
1734: #ifdef MYCURSES
1735: VOID
1736: #else
1737: int
1738: #endif /* MYCURSES */
1739: #endif /* CK_ANSIC */
1740: scrft() { /* Display file type */
1741: move(CW_TYP,22);
1742: if (binary) {
1743: #ifdef VMS
1744: if (binary == XYFT_I)
1745: printw("image");
1746: else if (binary == XYFT_L)
1747: printw("labeled");
1748: else printw("binary");
1749: #else /* Not VMS */
1750: printw("binary");
1751: #endif /* VMS */
1752: } else {
1753: printw("text");
1754: }
1755: clrtoeol();
1756: return;
1757: }
1758:
1759: char * /* Convert seconds to hh:mm:ss */
1760: #ifdef CK_ANSIC
1761: hhmmss(long x)
1762: #else
1763: hhmmss(x) long x;
1764: #endif /* CK_ANSIC */
1765: /* hhmmss(x) */ {
1766: static char buf[10];
1767: long s, h, m;
1768: h = x / 3600L; /* Hours */
1769: x = x % 3600L;
1770: m = x / 60L; /* Minutes */
1771: s = x % 60L; /* Seconds */
1772: if (x > -1L)
1773: sprintf(buf,"%02ld:%02ld:%02ld",h,m,s);
1774: else buf[0] = NUL;
1775: return((char *)buf);
1776: }
1777:
1778: #ifdef CK_NEWTERM
1779: static FILE *ck_stdout = NULL;
1780: static int ck_fd = -1;
1781: #endif /* CK_NEWTERM */
1782:
1783: static long pct = 100, oldpct = 0; /* Percent done */
1784: static int oldtyp = 0, oldwin = -1, oldtry = -1, oldlen = -1;
1785:
1786: #ifdef CK_ANSIC
1787: void
1788: screenc(int f, char c,long n,char *s)
1789: #else
1790: #ifdef MYCURSES
1791: VOID
1792: #else
1793: int
1794: #endif /* MYCURSES */
1795: screenc(f,c,n,s)
1796: int f; /* argument descriptor */
1797: char c; /* a character or small integer */
1798: long n; /* a long integer */
1799: char *s; /* a string */
1800: #endif /* CK_ANSIC */
1801: /* screenc() */ {
1802:
1803: static int q = 0;
1804: static long fsiz = -1L; /* Copy of file size */
1805: static long fcnt = 0L; /* File count */
1806: static long fbyt = 0L; /* Total file bytes */
1807:
1808: int len; /* Length of string */
1809: int x; /* Worker */
1810:
1811: if (cinit == 0 || cendw > 0) { /* Handle borderline cases... */
1812: if (f == SCR_CW) { /* Close window, but it's not open */
1813: ft_win = 0;
1814: return;
1815: }
1816: if (f == SCR_EM ||
1817: (f == SCR_PT && c == 'E')) { /* Fatal error before window open */
1818: conoll(""); conoc('?'); conoll(s); return; /* Regular display */
1819: }
1820: }
1821: if (cinit == 0) { /* Only call initscr() once */
1822: cendw = 1; /* New window needs repainting */
1823: #ifdef COMMENT
1824: if (!initscr()) { /* Oops, can't initialize window? */
1825: /*
1826: In fact, this doesn't happen. "man curses" says initscr() halts the
1827: entire program if it fails, which is true on the systems where I've
1828: tested it. It will fail if your terminal type is not known to it.
1829: That's why SET FILE DISPLAY FULLSCREEN calls tgetent() to make sure the
1830: terminal type is known before allowing a curses display.
1831: */
1832: fprintf(stderr,"CURSES INITSCR ERROR\r\n");
1833: fdispla = XYFD_R; /* Go back to regular display */
1834: return;
1835: } else {
1836: cinit++; /* Window initialized ok */
1837: debug(F100,"CURSES INITSCR OK","",0);
1838: }
1839: #else /* Save some memory. */
1840: #ifdef CK_NEWTERM
1841: /* (From Andy Fyfe <[email protected]>)
1842: System V curses seems to reserve the right to alter the buffering
1843: on the output FILE* without restoring it. Fortunately System V
1844: curses provides newterm(), an alternative to initscr(), that
1845: allows us to specify explicitly the terminal type and input and
1846: output FILE pointers. Thus we duplicate stdout, and let curses
1847: have the copy. The original remains unaltered. Unfortunately,
1848: newterm() seems to be particular to System V.
1849: */
1850: s = getenv("TERM");
1851: if (ck_fd < 0) {
1852: ck_fd = dup(fileno(stdout));
1853: ck_stdout = (ck_fd >= 0) ? fdopen(ck_fd, "w") : NULL;
1854: }
1855: if (ck_stdout == NULL || newterm(s, ck_stdout, stdin) == 0) {
1856: fprintf(stderr,
1857: "Fullscreen display not supported for terminal type: %s\r\n",s);
1858: fdispla = XYFD_R; /* Go back to regular display */
1859: return;
1860: }
1861: #else
1862: initscr(); /* Initialize curses. */
1863: #endif /* CK_NEWTERM */
1864: cinit++; /* Remember curses was initialized. */
1865: #endif /* COMMENT */
1866: }
1867: ft_win = 1; /* Window is open */
1868: if (cendw) { /* endwin() was called previously */
1869: #ifdef VMS
1870: initscr(); /* (or should have been!) */
1871: clear();
1872: touchwin(stdscr);
1873: refresh();
1874: #else /* All others... */
1875: clear();
1876: #endif /* VMS */
1877:
1878: move(CW_BAN,0); /* Display the banner */
1879: if (*myhost) printw("%s, %s",versio,(char *)myhost);
1880: else printw("%s",versio);
1881: move(CW_DIR,3); printw("Current Directory: %s",zgtdir());
1882: if (network) {
1883: move(CW_LIN,9); printw("Remote Host: %s",ttname);
1884: } else {
1885: move(CW_LIN,0); printw("Communication Device: %s",ttname);
1886: }
1887: move(CW_SPD,1); printw("Communication Speed: ");
1888: move(CW_SPD,22); /* Speed */
1889: if (network) {
1890: printw("(network)");
1891: } else {
1892: if (speed < 0L) speed = ttgspd();
1893: if (speed > 0L) {
1894: if (speed == 8880) printw("75/1200");
1895: else printw("%ld",speed);
1896: } else printw("unknown");
1897: }
1898: move(CW_PAR,14); printw("Parity: %s",parnam((char)parity));
1899: move(CW_TYP,11); printw("File Type:");
1900: move(CW_SIZ,11); printw("File Size:");
1901: move(CW_PCD, 8); printw("Percent Done:");
1902: move(CW_TR, 1); printw("Estimated Time Left:");
1903: move(CW_WS, 8); printw("Window Slots:");
1904: move(CW_PT, 9); printw("Packet Type:");
1905: move(CW_PC, 8); printw("Packet Count:");
1906: move(CW_PL, 7); printw("Packet Length:");
1907: move(CW_PR, 2); printw("Packet Retry Count:");
1908: move(CW_PB, 2); printw("Packet Block Check:");
1909: move(CW_ERR,10); printw("Last Error:");
1910: move(CW_MSG, 8); printw("Last Message:");
1911: #ifdef ATTSV
1912: #ifndef aegis
1913: #ifndef datageneral
1914: #define CK_NEED_SIG
1915: #endif /* datageneral */
1916: #endif /* aegis */
1917: #endif /* ATTSV */
1918: #ifdef POSIX
1919: #ifndef CK_NEED_SIG
1920: #define CK_NEED_SIG
1921: #endif /* CK_NEED_SIG */
1922: #endif /* POSIX */
1923:
1924: #ifdef CK_NEED_SIG
1925: move(CW_INT, 0); printw(
1926: "<%s>X to cancel file, <%s>Z to cancel group, <%s><CR> to resend packet",
1927: dbchr(escape), dbchr(escape), dbchr(escape));
1928: move(CW_INT + 1, 0); printw(
1929: "<%s>E to send Error packet, or Ctrl-C to quit immediately.", dbchr(escape));
1930: #else
1931: move(CW_INT, 0);
1932: #ifdef OS2
1933: printw(
1934: "X to cancel file, Z to cancel group, <Enter> to resend packet,");
1935: #else
1936: printw("X to cancel file, Z to cancel group, <CR> to resend packet,");
1937: #endif /* OS2 */
1938: move(CW_INT + 1, 0);
1939: printw("E to send Error packet, or Ctrl-C to quit immediately.");
1940: #endif /* CK_NEED_SIG */
1941: refresh();
1942: cendw = 0;
1943: }
1944: len = strlen(s); /* Length of argument string */
1945:
1946: debug(F101,"SCREENC switch","",f); /* Handle our function code */
1947: switch (f) {
1948: case SCR_FN: /* Filename */
1949: fsiz = -1L; /* Invalidate previous file size */
1950: move(CW_PCD,22); /* Erase percent done from last time */
1951: clrtoeol();
1952: move(CW_SIZ,22); /* Erase file size from last time */
1953: clrtoeol();
1954: move(CW_ERR,22); /* And last error message */
1955: clrtoeol();
1956: if (what == W_SEND) { /* If we're sending... */
1957: move(CW_NAM,13);
1958: printw("Sending:");
1959: } else if (what == W_RECV) { /* If we're receiving... */
1960: move(CW_NAM,11);
1961: printw("Receiving:");
1962: } else { /* If we don't know... */
1963: move(CW_NAM,11); /* (should never see this) */
1964: printw("File Name:");
1965: }
1966: move(CW_NAM,22); /* Display the filename */
1967: if (len > 57) {
1968: printw("%.54s..",s);
1969: len = 57;
1970: } else printw("%s",s);
1971: q = len; /* Remember name length for later */
1972: clrtoeol();
1973: scrft(); /* Display file type */
1974: refresh(); return;
1975:
1976: case SCR_AN: /* File as-name */
1977: if (q + len < 58) { /* Will fit */
1978: move(CW_NAM, 22 + q);
1979: printw(" => %s",s);
1980: } else { /* Too long */
1981: move(CW_NAM, 22); /* Overwrite previous name */
1982: q = 0;
1983: len = 54;
1984: printw(" => %.51s..", s); /* Truncate */
1985: }
1986: q += len + 4; /* Remember horizontal position */
1987: clrtoeol(); refresh(); return;
1988:
1989: case SCR_FS: /* File size */
1990: fsiz = n;
1991: move(CW_SIZ,22);
1992: if (fsiz > -1L) printw("%ld",n);
1993: clrtoeol();
1994: scrft(); /* File type */
1995: refresh(); return;
1996:
1997: case SCR_PT: /* Packet type or pseudotype */
1998: if (spackets < 5) {
1999: /* Things that won't change after the 4th packet */
2000: move(CW_PAR,22); printw("%s",parnam((char)parity)); clrtoeol();
2001: clrtoeol();
2002: move(CW_PB, 22); /* Block check on this packet */
2003: if (bctu == 4) printw("B"); else printw("%d",bctu);
2004: clrtoeol();
2005: }
2006:
2007: x = (what == W_RECV) ? /* Packet length */
2008: rpktl+1 :
2009: spktl+1;
2010: if (x != oldlen) { /* But only if it changed. */
2011: move(CW_PL, 22);
2012: printw("%d",x);
2013: clrtoeol();
2014: oldlen = x;
2015: }
2016: move(CW_PC, 22); /* Packet count (always). */
2017: printw("%d",spackets); /* WARNING: this can slow us way */
2018: clrtoeol(); /* down with short packets. */
2019:
2020: if (wcur != oldwin) { /* Window slots, if changed. */
2021: move(CW_WS, 22);
2022: printw("%d of %d",wcur,wslotr);
2023: clrtoeol();
2024: oldwin = wcur;
2025: }
2026: if (retrans != oldtry) { /* Retry count, if changed */
2027: move(CW_PR, 22);
2028: printw("%d",retrans);
2029: clrtoeol();
2030: oldtry = retrans;
2031: }
2032: if (c != oldtyp && c != 'Y' && c != 'N') { /* Sender's packet type */
2033: move(CW_PT,22);
2034: printw("%c",c);
2035: clrtoeol();
2036: oldtyp = c;
2037: }
2038: switch (c) { /* Now handle specific packet types */
2039: case 'S': /* Beginning of transfer */
2040: fcnt = fbyt = 0L; /* Clear counters */
2041: break;
2042: case 'D': /* Data packet */
2043: if (fsiz > 0L) { /* Show percent done if known */
2044: long s, x;
2045: oldpct = pct; /* Remember previous percent */
2046: pct = (fsiz > 99L) ? (ffc / (fsiz / 100L)) : 0L; /* New one */
2047: if (pct > 100L || /* Allow expansion */
2048: oldpct == 99L && pct < 0L) /* other boundary conditions */
2049: pct = 100L;
2050: if (pct != oldpct) { /* Only do this 100 times per file */
2051: move(CW_PCD,22);
2052: printw("%ld", pct);
2053: clrtoeol();
2054:
2055: /* Time remaining for this file */
2056:
2057: s = (long) ((unsigned) gtimer() - fsecs); /* Secs so far */
2058: if (s > 0L) {
2059: /*
2060: Time remaining must be calculated using the smallest
2061: possible quantities, to prevent overflow:
2062: (seconds_so_far * percent_left) / percent_done.
2063: And avoid divide_by_zero.
2064: */
2065: x = (pct > 0L) ? ((s * (100 - pct)) / pct) : -1L;
2066: if (x > -1L) {
2067: move(CW_TR,22);
2068: printw("%s",hhmmss(x));
2069: clrtoeol();
2070: }
2071: }
2072: }
2073: }
2074: break;
2075: case 'E': /* Error packet */
2076: #ifdef COMMENT
2077: move(CW_ERR,22); /* Print its data field */
2078: if (*s) printw("%s",s);
2079: clrtoeol();
2080: #endif /* COMMENT */
2081: fcnt = fbyt = 0; /* So no bytes for this file */
2082: break;
2083: case 'Q': /* Crunched packet */
2084: move(CW_ERR,22);
2085: printw("Damaged Packet");
2086: clrtoeol();
2087: break;
2088: case 'T': /* Timeout */
2089: move(CW_ERR,22);
2090: printw("Timeout");
2091: clrtoeol();
2092: break;
2093: default: /* Others, do nothing */
2094: break;
2095: }
2096: refresh(); return;
2097:
2098: case SCR_ST: /* File transfer status */
2099: move(CW_PCD,22); /* Update percent done */
2100: if (c == ST_OK) { /* OK, print 100 % */
2101: pct = 100;
2102: printw("100");
2103: } else if (fsiz > 0L) /* Not OK, update final percent */
2104: printw("%ld",( ffc * 100L ) / fsiz);
2105: clrtoeol();
2106: move(CW_MSG,22); /* Remove any previous message */
2107: clrtoeol(); refresh();
2108: move(CW_TR, 22);
2109: clrtoeol(); refresh();
2110:
2111: switch (c) { /* Print new status message */
2112: case ST_OK: /* Transfer OK */
2113: fcnt++; /* Count this file */
2114: if (ffc > 0L) /* For some reason ffc is off by 1 */
2115: fbyt += ffc - 1L; /* Count its bytes */
2116: move(CW_MSG,22);
2117: printw("Transfer OK"); /* Say Transfer was OK */
2118: clrtoeol(); refresh();
2119: return;
2120:
2121: case ST_DISC: /* Discarded */
2122: move(CW_ERR,22); printw("File discarded");
2123: clrtoeol(); refresh();
2124: return;
2125:
2126: case ST_INT: /* Interrupted */
2127: move(CW_ERR,22); printw("Transfer interrupted");
2128: clrtoeol(); refresh();
2129: return;
2130:
2131: case ST_SKIP: /* Skipped */
2132: move(CW_ERR,22); printw("File skipped");
2133: clrtoeol(); refresh();
2134: return;
2135:
2136: case ST_ERR: /* Error message */
2137: move(CW_ERR,22); printw("%s",s);
2138: clrtoeol(); refresh();
2139: return;
2140:
2141: case ST_REFU: /* Refused */
2142: move(CW_ERR,22);
2143: if (*s)
2144: printw("Refused, %s",s);
2145: else printw("Refused");
2146: clrtoeol(); refresh();
2147: return;
2148:
2149: case ST_INC:
2150: move(CW_ERR,22); printw("Incomplete");
2151: clrtoeol(); refresh();
2152: return;
2153:
2154: default: /* Bad call */
2155: move(CW_ERR,22); printw("*** screen() called with bad status ***");
2156: clrtoeol(); refresh(); return;
2157: }
2158:
2159: case SCR_TC: /* Transaction complete */
2160: move(CW_MSG,22); /* Print statistics in message line */
2161: if (tsecs > 0)
2162: printw("Files: %ld, Total Bytes: %ld, %ld cps",
2163: fcnt, fbyt, ((fbyt * 10L) / (long) tsecs) / 10L);
2164: else printw("Files: %ld, Total Bytes: %ld",fcnt,fbyt);
2165: clrtoeol();
2166: move(CW_TR, 1);
2167: printw(" Elapsed Time: %s",hhmmss((long)tsecs));
2168: clrtoeol();
2169: move(23,0); clrtoeol(); /* Clear instructions lines */
2170: move(22,0); clrtoeol(); /* to make room for prompt. */
2171: refresh();
2172: #ifndef VMSCURSE
2173: endwin();
2174: #endif /* VMSCURSE */
2175: pct = 100; oldpct = 0; /* Reset these for next time. */
2176: oldtyp = 0; oldwin = -1; oldtry = -1; oldlen = -1;
2177: cendw = 1; conoc(BEL); /* Close window, then beep. */
2178: ft_win = 0; /* Window closed. */
2179: return;
2180:
2181: case SCR_EM: /* Error packet (fatal) */
2182: move (CW_ERR,22);
2183: printw("? %s",s);
2184: conoc(BEL);
2185: clrtoeol(); refresh(); return;
2186:
2187: case SCR_QE: /* Quantity equals */
2188: case SCR_TU: /* Undelimited text */
2189: case SCR_TN: /* Text delimited at start */
2190: case SCR_TZ: /* Text delimited at end */
2191: return; /* (ignored in fullscreen display) */
2192:
2193: case SCR_XD: /* X-packet data */
2194: move(CW_NAM,22);
2195: printw("%s",s);
2196: clrtoeol(); refresh(); return;
2197:
2198: case SCR_CW: /* Close Window */
2199: clrtoeol(); move(23,0); clrtoeol(); move(22,0); clrtoeol();
2200: refresh();
2201: pct = 100; oldpct = 0; /* Reset these for next time. */
2202: oldtyp = 0; oldwin = -1; oldtry = -1; oldlen = -1;
2203:
2204: #ifndef VMSCURSE
2205: endwin();
2206: #endif /* VMSCURSE */
2207: ft_win = 0; /* Flag that window is closed. */
2208: cendw = 1; return;
2209:
2210: default: /* Bad call */
2211: move (CW_ERR,22);
2212: printw("*** screen() called with bad function code ***");
2213: clrtoeol(); refresh(); return;
2214: }
2215: }
2216: #endif /* CK_CURSES */
2217:
2218: #endif /* MAC */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.