![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckuus7.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / ckermit|
Return to ckuus7.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / ckermit |
1.1 root 1: #ifndef NOICP
2:
3: /* C K U U S 7 -- "User Interface" for Unix Kermit, part 7 */
4:
5: /*
6: Author: Frank da Cruz ([email protected], [email protected]),
7: Columbia University Center for Computing Activities.
8: First released January 1985.
9: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
10: York. Permission is granted to any individual or institution to use this
11: software as long as it is not sold for profit. This copyright notice must be
12: retained. This software may not be included in commercial products without
13: written permission of Columbia University.
14: */
15:
16: /*
17: This file created from parts of ckuus3.c, which became to big for
18: Mark Williams Coherent compiler to handle.
19: */
20:
21: /*
22: Definitions here supersede those from system include files.
23: */
24: #include "ckcdeb.h" /* Debugging & compiler things */
25: #include "ckcasc.h" /* ASCII character symbols */
26: #include "ckcker.h" /* Kermit application definitions */
27: #include "ckcxla.h" /* Character set translation */
28: #include "ckcnet.h" /* Network symbols */
29: #include "ckuusr.h" /* User interface symbols */
30:
31: static int x, y = 0, z;
32: static char *s;
33:
34: static int mdmsav = -1; /* Save modem type around network */
35: static int oldplex = -1; /* Duplex holder around network */
36:
37: extern int success, nfilp, fmask, fncnv, frecl, nfttyp, binary, warn, msgflg;
38: extern int cmask, maxrps, wslotr, bigsbsiz, bigrbsiz, urpsiz, rpsiz, spsiz;
39: extern int spsizr, spsizf, maxsps, spmax, pflag, bctr, npad, timef, timint;
40: extern int pkttim, rtimo, local, nfils, displa, atcapr, nettype, escape;
41: extern int mdmtyp, duplex, dfloc, network, cdtimo, fncact, mypadn;
42: extern int tnlm, sosi, tlevel, lf_opts, backgrd, flow, fdispla;
43: extern int
44: atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko,
45: attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso;
46:
47: extern long speed;
48:
49: extern CHAR sstate, eol, seol, stchr, mystch, mypadc, padch;
50:
51: extern char *cmarg, *cmarg2, *dftty;
52:
53: extern char tmpbuf[], *tp, *lp; /* Temporary buffer & pointers */
54: #ifndef NOFRILLS
55: extern char optbuf[]; /* Buffer for MAIL or PRINT options */
56: extern int rprintf; /* REMOTE PRINT flag */
57: #endif /* NOFRILLS */
58: extern char ttname[];
59:
60: extern struct keytab onoff[], filtab[], fttab[], rltab[];
61: extern int nrlt;
62:
63: #ifdef DCMDBUF
64: extern char *atxbuf; /* Atom buffer */
65: extern char *cmdbuf; /* Command buffer */
66: extern char *line; /* Character buffer for anything */
67: #ifdef CK_CURSES
68: /* This needs cleaning up... */
69: #ifdef UNIX
70: extern char *trmbuf; /* Termcap buffer */
71: #endif /* UNIX */
72: #ifdef OS2
73: extern char *trmbuf; /* Termcap buffer */
74: #endif /* OS2 */
75: #ifdef OSK
76: extern char *trmbuf; /* Termcap buffer */
77: #endif /* OSK */
78: #ifdef AMIGA
79: extern char *trmbuf; /* Termcap buffer */
80: #endif /* AMIGA */
81: #endif /* CK_CURSES */
82: #else
83: extern char atxbuf[]; /* Atom buffer */
84: extern char cmdbuf[]; /* Command buffer */
85: extern char line[]; /* Character buffer for anything */
86: #ifdef CK_CURSES
87: #ifdef UNIX
88: extern char trmbuf[]; /* Termcap buffer */
89: #endif /* UNIX */
90: #endif /* CK_CURSES */
91: #endif /* DCMDBUF */
92:
93: #ifndef NOCSETS
94: extern struct keytab fcstab[]; /* For 'set file character-set' */
95: extern struct keytab ttcstab[];
96: extern int nfilc, fcharset, ntermc, tcsr, tcsl;
97: #endif /* NOCSETS */
98:
99: #ifndef NOSPL
100: extern int cmdlvl; /* Overall command level */
101: #endif /* NOSPL */
102:
103: #ifdef TNCODE
104: extern int tn_init;
105: #endif /* TNCODE */
106:
107: #ifdef SUNX25
108: extern int revcall, closgr, cudata, nx25, npadx3;
109: extern char udata[MAXCUDATA];
110: extern CHAR padparms[MAXPADPARMS+1];
111: extern struct keytab x25tab[], padx3tab[];
112: #endif /* SUNX25 */
113:
114: #ifdef CK_CURSES
115: #ifndef VMS
116: _PROTOTYP(int tgetent,(char *, char *));
117: #endif /* VMS */
118: #endif /* CK_CURSES */
119:
120: #ifndef NODIAL
121: extern int dialhng, dialtmo, dialksp, dialdpy, dialmnp, dialmhu;
122: extern int mdmspd;
123: extern char *dialini, *dialdir, *dialcmd, *dialnpr;
124: extern FILE * dialfd;
125:
126:
127: struct keytab dialtab[] = {
128: "dial-command", XYDDIA, 0,
129: "directory", XYDDIR, 0,
130: "display", XYDDPY, 0,
131: "hangup", XYDHUP, 0,
132: "init-string", XYDINI, 0,
133: "kermit-spoof", XYDKSP, 0,
134: "mnp-enable", XYDMNP, 0,
135: #ifdef MDMHUP
136: "modem-hangup", XYDMHU, 0,
137: #endif /* MDMHUP */
138: "prefix", XYDNPR, 0,
139: "speed-matching", XYDSPD, 0,
140: "timeout", XYDTMO, 0
141: };
142: int ndial = (sizeof(dialtab) / sizeof(struct keytab));
143: #endif /* NODIAL */
144:
145: #ifndef NOXMIT
146: /* set transmit */
147: #define XMITF 0
148: #define XMITL 1
149: #define XMITP 2
150: #define XMITE 3
151: #define XMITX 4
152: #define XMITS 5
153: #define XMITW 6
154:
155: #ifndef NOXMIT
156: #define XMBUFL 50
157: extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw;
158: char xmitbuf[XMBUFL+1] = { NUL }; /* TRANSMIT eof string */
159: #endif /* NOXMIT */
160:
161: struct keytab xmitab[] = {
162: "echo", XMITX, 0,
163: "eof", XMITE, 0,
164: "fill", XMITF, 0,
165: "linefeed", XMITL, 0,
166: "locking-shift", XMITS, 0,
167: "pause", XMITW, 0,
168: "prompt", XMITP, 0
169: };
170: int nxmit = (sizeof(xmitab) / sizeof(struct keytab));
171: #endif /* NOXMIT */
172:
173: /* For SET FILE COLLISION */
174: /* Some of the following may be possible for some C-Kermit implementations */
175: /* but not others. Those that are not possible for your implementation */
176: /* should be ifdef'd out. */
177:
178: struct keytab colxtab[] = { /* SET FILE COLLISION options */
179: "append", XYFX_A, 0, /* append to old file */
180: #ifdef COMMENT
181: "ask", XYFX_Q, 0, /* ask what to do (not implemented) */
182: #endif
183: "backup", XYFX_B, 0, /* rename old file */
184: "discard", XYFX_D, 0, /* don't accept new file */
185: "no-supersede", XYFX_D, CM_INV, /* ditto (MSK compatibility) */
186: "overwrite", XYFX_X, 0, /* overwrite the old file == file warning off */
187: "rename", XYFX_R, 0, /* rename the incoming file == file warning on */
188: "update", XYFX_U, 0, /* replace if newer */
189: };
190: int ncolx = (sizeof(colxtab) / sizeof(struct keytab));
191:
192: static struct keytab rfiltab[] = { /* for REMOTE SET FILE */
193: "collision", XYFILX, 0,
194: "record-length", XYFILR, 0,
195: "type", XYFILT, 0
196: };
197: int nrfilp = (sizeof(rfiltab) / sizeof(struct keytab));
198:
199: struct keytab fntab[] = { /* File naming */
200: "converted", 1, 0,
201: "literal", 0, 0
202: };
203:
204: /* Terminal parameters table */
205: struct keytab trmtab[] = {
206: #ifdef OS2
207: "arrow-keys", XYTARR, 0,
208: #endif /* OS2 */
209: "bytesize", XYTBYT, 0,
210: #ifndef NOCSETS
211: "character-set", XYTCS, 0,
212: #endif /* NOCSETS */
213: #ifdef OS2
214: "color", XYTCOL, 0,
215: #endif /* OS2 */
216: "cr-display", XYTCRD, 0,
217: #ifdef OS2
218: "cursor", XYTCUR, 0,
219: #endif /* OS2 */
220: "echo", XYTEC, 0,
221: #ifdef OS2
222: "keypad-mode", XYTKPD, 0,
223: #endif /* OS2 */
224: "locking-shift", XYTSO, 0,
225: "newline-mode", XYTNL, 0
226: #ifdef OS2
227: , "type", XYTTYP, 0,
228: "wrap", XYTWRP, 0
229: #endif /* OS2 */
230: };
231: int ntrm = (sizeof(trmtab) / sizeof(struct keytab));
232:
233: struct keytab crdtab[] = { /* Carriage-return display */
234: "crlf", 1, 0,
235: "normal", 0, 0
236: };
237: extern int tt_crd; /* Carriage-return display variable */
238:
239: #ifdef OS2
240: /*
241: OS/2 serial communication devices.
242: */
243: struct keytab os2devtab[] = {
244: "1", 1, CM_INV, /* Invisible synonyms, like */
245: "2", 2, CM_INV, /* "set port 1" */
246: "3", 3, CM_INV,
247: "4", 4, CM_INV,
248: "5", 5, CM_INV,
249: "6", 6, CM_INV,
250: "7", 7, CM_INV,
251: "8", 8, CM_INV,
252: "com1", 1, 0, /* Real device names */
253: "com2", 2, 0,
254: "com3", 3, 0,
255: "com4", 4, 0,
256: "com5", 5, 0,
257: "com6", 6, 0,
258: "com7", 7, 0,
259: "com8", 7, 0
260: };
261: int nos2dev = (sizeof(os2devtab) / sizeof(struct keytab));
262:
263: /*
264: Terminal parameters that can be set by SET commands.
265: Used by the ck?con.c terminal emulator code.
266: For now, only use for OS/2. Should add these for Macintosh.
267: */
268: int tt_arrow = 1; /* Arrow key mode */
269: int tt_keypad = 0; /* Keypad mode */
270: int tt_wrap = 1; /* Autowrap */
271: int tt_type = TT_VT102; /* Terminal type */
272: int tt_cursor = 0; /* Cursor type */
273: #endif /* OS2 */
274:
275: #ifdef OS2
276: struct keytab akmtab[] = { /* Arrow key mode */
277: "application", 1, 0,
278: "cursor", 0, 0
279: };
280: struct keytab kpmtab[] = { /* Keypad mode */
281: "application", 0, 0,
282: "numeric", 1, 0
283: };
284:
285: struct keytab ttycoltab[] = { /* Items to be colored */
286: "help", 4, 0, /* Help screen */
287: "normal", 0, 0, /* Normal screen text */
288: "reverse", 1, 0, /* Reverse video */
289: "status", 3, 0, /* Status line */
290: "underlined", 2, 0 /* Underlined text */
291: };
292: int ncolors = 5;
293:
294: struct keytab ttyclrtab[] = { /* Colors */
295: "black", 0, 0,
296: "blue", 1, 0,
297: "brown", 6, 0,
298: "cyan", 3, 0,
299: "dgray", 8, 0,
300: "green", 2, 0,
301: "lblue", 9, 0,
302: "lcyan", 11, 0,
303: "lgray", 7, 0,
304: "lgreen", 10, 0,
305: "lmagenta", 13, 0,
306: "lred", 12, 0,
307: "magenta", 5, 0,
308: "red", 4, 0,
309: "white", 15, 0,
310: "yellow", 14, 0
311: };
312: int nclrs = 16;
313:
314: struct keytab ttycurtab[] = {
315: "full", 2, 0,
316: "half", 1, 0,
317: "underline", 0, 0
318: };
319: int ncursors = 3;
320: #endif /* OS2 */
321:
322: #ifdef OS2
323: struct keytab ttyptab[] = {
324: #ifdef COMMENT
325: /*
326: Not supported yet...
327: The idea is to let the console driver handle the escape sequences.
328: */
329: "none", TT_NONE, 0,
330: #endif /* COMMENT */
331: #ifdef OS2PM
332: "tek4014", TT_TEK40, 0,
333: #endif /* OS2PM */
334: "vt102", TT_VT102, 0,
335: "vt52", TT_VT52, 0
336: };
337: int nttyp = 2;
338: #endif /* OS2 */
339:
340: /* #ifdef VMS */
341: struct keytab fbtab[] = { /* Binary record types for VMS */
342: "fixed", XYFT_B, 0, /* Fixed is normal for binary */
343: "undefined", XYFT_U, 0 /* Undefined if they ask for it */
344: };
345: int nfbtyp = (sizeof(fbtab) / sizeof(struct keytab));
346: /* #endif */
347:
348: #ifdef VMS
349: struct keytab lbltab[] = { /* Labeled File info */
350: "acl", LBL_ACL, 0,
351: "backup-date", LBL_BCK, 0,
352: "name", LBL_NAM, 0,
353: "owner", LBL_OWN, 0,
354: "path", LBL_PTH, 0
355: };
356: int nlblp = (sizeof(lbltab) / sizeof(struct keytab));
357: #endif /* VMS */
358:
359: struct keytab fdtab[] = { /* SET FILE DISPLAY options */
360: #ifdef MAC /* Macintosh */
361: "fullscreen", XYFD_R, 0, /* Full-screen but not curses */
362: "none", XYFD_N, 0,
363: "off", XYFD_N, CM_INV,
364: "on", XYFD_R, CM_INV,
365: "quiet", XYFD_N, CM_INV
366:
367: #else /* Not Mac */
368: "crt", XYFD_S, 0, /* CRT display */
369: #ifdef CK_CURSES
370: #ifdef COMMENT
371: "curses", XYFD_C, CM_INV, /* Full-screen, curses */
372: #endif /* COMMENT */
373: "fullscreen", XYFD_C, 0, /* Full-screen, whatever the method */
374: #endif /* CK_CURSES */
375: "none", XYFD_N, 0, /* No display */
376: "off", XYFD_N, CM_INV, /* Ditto */
377: "on", XYFD_R, CM_INV, /* On = Serial */
378: "quiet", XYFD_N, CM_INV, /* No display */
379: "serial", XYFD_R, 0 /* Serial */
380: #endif /* MAC */
381: };
382: int nfdtab = (sizeof(fdtab) / sizeof(struct keytab));
383:
384: struct keytab rsrtab[] = { /* For REMOTE SET RECEIVE */
385: "packet-length", XYLEN, 0,
386: "timeout", XYTIMO, 0
387: };
388: int nrsrtab = (sizeof(rsrtab) / sizeof(struct keytab));
389:
390: /* Send/Receive Parameters */
391:
392: struct keytab srtab[] = {
393: "end-of-packet", XYEOL, 0,
394: "packet-length", XYLEN, 0,
395: "pad-character", XYPADC, 0,
396: "padding", XYNPAD, 0,
397: "start-of-packet", XYMARK, 0,
398: "timeout", XYTIMO, 0
399: };
400: int nsrtab = (sizeof(srtab) / sizeof(struct keytab));
401:
402: /* REMOTE SET */
403:
404: struct keytab rmstab[] = {
405: "attributes", XYATTR, 0,
406: "block-check", XYCHKT, 0,
407: "file", XYFILE, 0,
408: "incomplete", XYIFD, 0,
409: "receive", XYRECV, 0,
410: "retry", XYRETR, 0,
411: "server", XYSERV, 0,
412: "transfer", XYXFER, 0,
413: "window", XYWIND, 0
414: };
415: int nrms = (sizeof(rmstab) / sizeof(struct keytab));
416:
417: struct keytab attrtab[] = {
418: "all", AT_XALL, 0,
419: #ifdef COMMENT
420: "blocksize", AT_BLKS, 0, /* not used */
421: #endif /* COMMENT */
422: "character-set", AT_ENCO, 0,
423: "date", AT_DATE, 0,
424: "disposition", AT_DISP, 0,
425: "encoding", AT_ENCO, CM_INV,
426: "length", AT_LENK, 0,
427: "off", AT_ALLN, 0,
428: "on", AT_ALLY, 0,
429: #ifdef COMMENT
430: "os-specific", AT_SYSP, 0, /* not used by UNIX or VMS */
431: #endif /* COMMENT */
432: "system-id", AT_SYSI, 0,
433: "type", AT_FTYP, 0,
434: };
435: int natr = (sizeof(attrtab) / sizeof(struct keytab)); /* how many attributes */
436:
437: #ifndef NOSPL
438: extern int indef, intime, incase, inecho, insilence;
439: struct keytab inptab [] = { /* SET INPUT parameters */
440: "case", IN_CAS, 0,
441: "default-timeout", IN_DEF, CM_INV,
442: "echo", IN_ECH, 0,
443: "silence", IN_SIL, 0,
444: "timeout-action", IN_TIM, 0
445: };
446: int ninp = (sizeof(inptab) / sizeof(struct keytab));
447:
448: struct keytab intimt[] = { /* SET INPUT TIMEOUT parameters */
449: "proceed", 0, 0, /* 0 = proceed */
450: "quit", 1, 0 /* 1 = quit */
451: };
452:
453: struct keytab incast[] = { /* SET INPUT CASE parameters */
454: "ignore", 0, 0, /* 0 = ignore */
455: "observe", 1, 0 /* 1 = observe */
456: };
457: #endif /* NOSPL */
458:
459: /* The following routines broken out of doprm() to give compilers a break. */
460:
461: /* S E T O N -- Parse on/off (default on), set parameter to result */
462:
463: int
464: seton(prm) int *prm; {
465: int x, y;
466: if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
467: if ((x = cmcfm()) < 0) return(x);
468: *prm = y;
469: return(1);
470: }
471:
472: /* S E T N U M -- Set parameter to result of cmnum() parse. */
473: /*
474: Call with pointer to integer variable to be set,
475: x = number from cnum parse, y = return code from cmnum,
476: max = maximum value to accept, -1 if no maximum.
477: Returns -9 on failure, after printing a message, or 1 on success.
478: */
479: int
480: setnum(prm,x,y,max) int x, y, *prm, max; {
481: extern int cmflgs;
482: debug(F101,"setnum","",y);
483: if (y == -3) {
484: printf("\n?Value required\n");
485: return(-9);
486: }
487: if (y == -2) {
488: printf("%s?Not a number: %s\n",cmflgs == 1 ? "" : "\n", atxbuf);
489: return(-9);
490: }
491: if (y < 0) return(y);
492: if (max > -1 && x > max) {
493: printf("?Sorry, %d is the maximum\n",max);
494: return(-9);
495: }
496: if ((y = cmcfm()) < 0) return(y);
497: *prm = x;
498: return(1);
499: }
500:
501: /* S E T C C -- Set parameter to an ASCII control character value. */
502:
503: int
504: setcc(prm,x,y) int x, y, *prm; {
505: if (y == -3) {
506: printf("\n?Value required\n");
507: return(-3);
508: }
509: if (y < 0) return(y);
510: if ((x > 037) && (x != 0177)) {
511: printf("\n?Not in ASCII control range - %d\n",x);
512: return(-2);
513: }
514: if ((y = cmcfm()) < 0) return(y);
515: *prm = x;
516: return(1);
517: }
518:
519: #ifndef NODIAL
520: _PROTOTYP(static int dialstr,(char **, char *));
521: /*
522: Parse a DIAL-related string, stripping enclosing braces, if any.
523: */
524: static int
525: dialstr(p,msg) char **p; char *msg; {
526: int x;
527: if ((x = cmtxt(msg, "", &s, xxstring)) < 0)
528: return(x);
529: if (*s == '{') { /* Strip enclosing braces, if any */
530: x = strlen(s);
531: if (s[x-1] == '}') {
532: s[x-1] = NUL;
533: s++;
534: }
535: }
536: if (*p) { /* Free any previous string. */
537: free(*p);
538: *p = (char *) 0;
539: }
540: if ((x = strlen(s)) > 0) {
541: *p = malloc(x + 1); /* Allocate space for it */
542: strcpy(*p,s); /* and make a safe copy. */
543: } else *p = (char *) 0;
544: return(success = 1);
545: }
546:
547: int /* Set DIAL command options */
548: setdial() {
549: if ((y = cmkey(dialtab,ndial,"","",xxstring)) < 0) return(y);
550: switch (y) {
551: case XYDHUP: /* DIAL HANGUP */
552: return(success = seton(&dialhng));
553: case XYDINI: /* DIAL INIT-STRING */
554: return(dialstr(&dialini,"Modem dialer initialization string"));
555: case XYDNPR: /* DIAL NUMBER-PREFIX */
556: return(dialstr(&dialnpr,"Modem dialer telephone number prefix"));
557: case XYDDIA: /* DIAL DIAL-COMMAND */
558: x = cmtxt("Dialing command for modem,\n\
559: include \"%s\" to stand for phone number,\n\
560: for example, \"set dial dial-command ATDT%s\\13\"",
561: "",
562: &s,
563: xxstring);
564: if (x < 0 && x != -3) /* Handle parse errors */
565: return(x);
566: y = x = strlen(s); /* Get length of text */
567: if (x > 0 && *s == '{') { /* Strip enclosing braces, */
568: if (s[x-1] == '}') { /* if any. */
569: s[x-1] = NUL;
570: s++;
571: y -= 2;
572: }
573: }
574: if (y > 0) { /* If there is any text (left), */
575: for (x = 0; x < y; x++) { /* make sure they included "%s" */
576: if (s[x] != '%') continue;
577: if (s[x+1] == 's') break;
578: }
579: if (x == y) {
580: printf(
581: "?Dial-command must contain \"%cs\" for phone number.\n",'%');
582: return(-9);
583: }
584: }
585: if (dialcmd) { /* Free any previous string. */
586: free(dialcmd);
587: dialcmd = (char *) 0;
588: }
589: if (y > 0) {
590: dialcmd = malloc(y + 1); /* Allocate space for it */
591: strcpy(dialcmd,s); /* and make a safe copy. */
592: }
593: return(success = 1);
594: case XYDKSP: /* DIAL KERMIT-SPOOF */
595: return(success = seton(&dialksp));
596: case XYDTMO: /* DIAL TIMEOUT */
597: y = cmnum("Seconds to wait for call completion","0",10,&x,xxstring);
598: return(success = setnum(&dialtmo,x,y,10000));
599: case XYDDPY: /* DIAL DISPLAY */
600: return(success = seton(&dialdpy));
601: case XYDSPD: /* DIAL SPEED-MATCHING */
602: /* used to be speed-changing */
603: if ((y = seton(&mdmspd)) < 0) return(y);
604: #ifdef COMMENT
605: mdmspd = 1 - mdmspd; /* so here we reverse the meaning */
606: #endif /* COMMENT */
607: return(success = 1);
608: case XYDMNP: /* DIAL MNP-ENABLE */
609: return(success = seton(&dialmnp));
610: #ifdef MDMHUP
611: case XYDMHU: /* DIAL MODEM-HANGUP */
612: return(success = seton(&dialmhu));
613: #endif /* MDMHUP */
614: case XYDDIR: /* DIAL DIRECTORY */
615: if ((y = cmifi("Name of dialing directory file","",&s,&y,
616: xxstring)) < 0) {
617: if (y == -3) {
618: if (dialdir) free(dialdir); /* Free any previous storage */
619: dialdir = NULL;
620: return(success = 1);
621: } else return(y);
622: }
623: if (y) {
624: printf("?Wildcards not allowed\n");
625: return(-9);
626: }
627: strcpy(line,s); /* Make safe copy of dial string */
628: if ((y = cmcfm()) < 0) return(y); /* Confirm the command */
629: if (dialdir) free(dialdir); /* Free previous filename storage */
630: if (dialfd) { /* Close previous file, if any */
631: fclose(dialfd);
632: dialfd = NULL;
633: }
634: s = line; /* Point back to dial string */
635: if (s == NULL || *s == NUL) { /* If no name given */
636: dialdir = NULL; /* remove the name string */
637: return(success = 1);
638: } else if ((dialdir = malloc(strlen(s)+1)) == NULL) {
639: return(success = 0); /* Can't malloc storage for name */
640: } else { /* Have storage for name */
641: strcpy(dialdir,s); /* Copy string into new storage */
642: if ((dialfd = fopen(dialdir,"r")) == NULL) { /* Open the file */
643: perror(dialdir); /* Can't, print message saying why */
644: success = 0; /* We didn't succeed */
645: return(-9); /* Fail, message already printed */
646: }
647: return(success = 1); /* Everything is OK */
648: }
649:
650: default:
651: printf("?Unexpected SET DIAL parameter\n");
652: return(-2);
653: }
654: }
655: #endif /* NODIAL */
656:
657: int
658: setfil(rmsflg) int rmsflg; {
659: if (rmsflg) {
660: if ((y = cmkey(rfiltab,nrfilp,"Remote file parameter","",
661: xxstring)) < 0) {
662: if (y == -3) {
663: printf("?Remote file parameter required\n");
664: return(-9);
665: } else return(y);
666: }
667: } else {
668: if ((y = cmkey(filtab,nfilp,"File parameter","",xxstring)) < 0)
669: return(y);
670: }
671: switch (y) {
672: #ifdef COMMENT /* Not needed */
673: case XYFILB: /* Blocksize */
674: sprintf(tmpbuf,"%d",DBLKSIZ);
675: if ((y = cmnum("file block size",tmpbuf,10,&z,xxstring)) < 0)
676: return(y);
677: if ((x = cmcfm()) < 0) return(x);
678: if (rmsflg) {
679: sprintf(tmpbuf,"%d",z);
680: sstate = setgen('S', "311", tmpbuf, "");
681: return((int) sstate);
682: } else {
683: fblksiz = z;
684: return(success = 1);
685: }
686: #endif /* COMMENT */
687:
688: case XYFILS: /* Byte size */
689: if ((y = cmnum("file byte size (7 or 8)","8",10,&z,xxstring)) < 0)
690: return(y);
691: if (z != 7 && z != 8) {
692: printf("\n?The choices are 7 and 8\n");
693: return(0);
694: }
695: if ((y = cmcfm()) < 0) return(y);
696: if (z == 7) fmask = 0177;
697: else if (z == 8) fmask = 0377;
698: return(success = 1);
699:
700: #ifndef NOCSETS
701: case XYFILC: /* Character set */
702: if ((x = cmkey(fcstab,nfilc,"local file code","ascii", xxstring)) < 0)
703: return(x);
704: if ((z = cmcfm()) < 0) return(z);
705: fcharset = x;
706: return(success = 1);
707: #endif /* NOCSETS */
708:
709: case XYFILD: /* Display */
710: if ((x = cmkey(fdtab,nfdtab,"file transfer display style","",
711: xxstring)) < 0)
712: return(x);
713: if ((z = cmcfm()) < 0) return(z);
714: #ifdef CK_CURSES
715: if (x == XYFD_C) {
716: #ifdef VMS
717: lp = line;
718: #else
719: lp = trmbuf;
720: #endif /* VMS */
721: #ifndef MYCURSES
722: s = getenv("TERM");
723: if (tgetent(lp,s) < 1) {
724: #ifdef VMS
725: printf("Sorry, terminal type not supported: %s\n",s);
726: #else
727: printf("Sorry, terminal type unknown: %s\n",s);
728: #endif /* VMS */
729: return(success = 0);
730: }
731: #endif /* MYCURSES */
732: line[0] = '\0';
733: }
734: #endif /* CK_CURSES */
735: fdispla = x; /* It's OK. */
736: return(success = 1);
737:
738: case XYFILN: /* Names */
739: if ((x = cmkey(fntab,2,"how to handle filenames","converted",
740: xxstring)) < 0)
741: return(x);
742: if ((z = cmcfm()) < 0) return(z);
743: fncnv = x;
744: return(success = 1);
745:
746: case XYFILR: /* Record length */
747: sprintf(tmpbuf,"%d",DLRECL);
748: if ((y = cmnum("file record length",tmpbuf,10,&z,xxstring)) < 0)
749: return(y);
750: if ((x = cmcfm()) < 0) return(x);
751: if (rmsflg) {
752: sprintf(tmpbuf,"%d",z);
753: sstate = setgen('S', "312", tmpbuf, "");
754: return((int) sstate);
755: } else {
756: frecl = z;
757: return(success = 1);
758: }
759:
760: #ifdef COMMENT
761: case XYFILO: /* Organization */
762: if ((x = cmkey(forgtab,nforg,"file organization","sequential",
763: xxstring)) < 0)
764: return(x);
765: if ((y = cmcfm()) < 0) return(y);
766: if (rmsflg) {
767: sprintf(tmpbuf,"%d",x);
768: sstate = setgen('S', "314", tmpbuf, "");
769: return((int) sstate);
770: } else {
771: forg = x;
772: return(success = 1);
773: }
774: #endif /* COMMENT */
775:
776: #ifdef COMMENT /* Not needed */
777: case XYFILF: /* Format */
778: if ((x = cmkey(frectab,nfrec,"file record format","stream",
779: xxstring)) < 0)
780: return(x);
781: if ((y = cmcfm()) < 0) return(y);
782: if (rmsflg) {
783: sprintf(tmpbuf,"%d",x);
784: sstate = setgen('S', "313", tmpbuf, "");
785: return((int) sstate);
786: } else {
787: frecfm = x;
788: return(success = 1);
789: }
790: #endif /* COMMENT */
791:
792: #ifdef COMMENT
793: case XYFILP: /* Printer carriage control */
794: if ((x = cmkey(fcctab,nfcc,"file carriage control","newline",
795: xxstring)) < 0)
796: return(x);
797: if ((y = cmcfm()) < 0) return(y);
798: if (rmsflg) {
799: sprintf(tmpbuf,"%d",x);
800: sstate = setgen('S', "315", tmpbuf, "");
801: return((int) sstate);
802: } else {
803: fcctrl = x;
804: return(success = 1);
805: }
806: #endif /* COMMENT */
807:
808: case XYFILT: /* Type */
809: if ((x = cmkey(fttab,nfttyp,"type of file","text",xxstring)) < 0)
810: return(x);
811: #ifdef COMMENT
812: if ((y = cmnum("file byte size (7 or 8)","8",10,&z,xxstring)) < 0)
813: return(y);
814: if (z != 7 && z != 8) {
815: printf("\n?The choices are 7 and 8\n");
816: return(0);
817: }
818: #endif /* COMMENT */
819:
820: #ifdef VMS
821: /* Allow VMS users to choose record format for binary files */
822: if ((x == XYFT_B) && (rmsflg == 0)) {
823: if ((x = cmkey(fbtab,nfbtyp,"VMS record format","fixed",
824: xxstring)) < 0)
825: return(x);
826: }
827: #endif /* VMS */
828: if ((y = cmcfm()) < 0) return(y);
829: if (rmsflg) {
830: sstate = setgen('S', "300", x ? "1" : "0", "");
831: return((int) sstate);
832: } else {
833: binary = x;
834: #ifdef COMMENT
835: if (z == 7) fmask = 0177;
836: else if (z == 8) fmask = 0377;
837: #endif /* COMMENT */
838: return(success = 1);
839: }
840:
841: case XYFILX: /* Collision Action */
842: if ((x = cmkey(colxtab,ncolx,"Filename collision action","backup",
843: xxstring)) < 0)
844: return(x);
845: if ((y = cmcfm()) < 0) return(y);
846: fncact = x;
847: if (rmsflg) {
848: sprintf(tmpbuf,"%d",fncact);
849: sstate = setgen('S', "302", tmpbuf, "");
850: return((int) sstate);
851: } else {
852: if (fncact == XYFX_R) warn = 1; /* SET FILE WARNING implications */
853: if (fncact == XYFX_X) warn = 0; /* ... */
854: return(success = 1);
855: }
856:
857: case XYFILW: /* Warning/Write-Protect */
858: seton(&warn);
859: if (warn)
860: fncact = XYFX_R;
861: else
862: fncact = XYFX_X;
863: return(success = 1);
864:
865: #ifdef VMS
866: case XYFILL: /* LABELED FILE parameters */
867: if ((x = cmkey(lbltab,nlblp,"VMS labeled file feature","",
868: xxstring)) < 0)
869: return(x);
870: if ((success = seton(&y)) < 0)
871: return(success);
872: if (y) /* Set or reset the selected bit */
873: lf_opts |= x; /* in the options bitmask. */
874: else
875: lf_opts &= ~x;
876: return(success);
877: #endif /* VMS */
878:
879: case XYFILI: /* INCOMPLETE */
880: return(doprm(XYIFD,rmsflg));
881:
882: default:
883: printf("?unexpected file parameter\n");
884: return(-2);
885: }
886: }
887:
888: int
889: settrm() {
890: if ((y = cmkey(trmtab,ntrm,"","",xxstring)) < 0) return(y);
891: #ifdef MAC
892: printf("\n?Sorry, not implemented yet. Please use the Settings menu.\n");
893: return(-9);
894: #else
895: switch (y) {
896: case XYTBYT: /* SET TERMINAL BYTESIZE */
897: if ((y = cmnum("bytesize for terminal connection","8",10,&x,
898: xxstring)) < 0)
899: return(y);
900: if (x != 7 && x != 8) {
901: printf("\n?The choices are 7 and 8\n");
902: return(success = 0);
903: }
904: if ((y = cmcfm()) < 0) return(y);
905: if (x == 7) cmask = 0177;
906: else if (x == 8) cmask = 0377;
907: return(success = 1);
908:
909: case XYTSO: /* SET TERMINAL LOCKING-SHIFT */
910: return(success = seton(&sosi));
911:
912: case XYTNL: /* SET TERMINAL NEWLINE-MODE */
913: return(success = seton(&tnlm));
914:
915: #ifdef OS2
916: case XYTCOL: /* SET TERMINAL COLOR */
917: if ((x = cmkey(ttycoltab,ncolors,"","normal",xxstring)) < 0) {
918: return(x);
919: } else {
920: extern int colornormal, colorreverse, colorunderline,
921: colorstatus, colorhelp, scrninitialised;
922: int fg, bg;
923: if ((fg = cmkey(ttyclrtab,nclrs,
924: "foreground color","black",xxstring)) < 0)
925: return(fg);
926: if ((bg = cmkey(ttyclrtab,nclrs,
927: "background color","cyan",xxstring)) < 0)
928: return(bg);
929: if ((y = cmcfm()) < 0)
930: return(y);
931: switch (x) {
932: case 0:
933: colornormal = fg | bg << 4;
934: break;
935: case 1:
936: colorreverse = fg | bg << 4;
937: break;
938: case 2:
939: colorunderline = fg | bg << 4;
940: break;
941: case 3:
942: colorstatus = fg | bg << 4;
943: break;
944: case 4:
945: colorhelp = fg | bg << 4;
946: break;
947: default:
948: printf("%s - invalid\n",cmdbuf);
949: return(-9);
950: break;
951: }
952: scrninitialised = 0;
953: }
954: return(success = 1);
955:
956: case XYTCUR: /* SET TERMINAL CURSOR */
957: if ((x = cmkey(ttycurtab,ncursors,"","underline",xxstring)) < 0)
958: return(x);
959: if ((y = cmcfm()) < 0) return(y);
960: tt_cursor = x;
961: return(success = 1);
962:
963: case XYTTYP: /* SET TERMINAL TYPE */
964: if ((x = cmkey(ttyptab,nttyp,"","vt102",xxstring)) < 0) return(x);
965: if ((y = cmcfm()) < 0) return(y);
966: tt_type = x;
967: return(success = 1);
968:
969: case XYTARR: /* SET TERMINAL ARROW-KEYS */
970: if ((x = cmkey(akmtab,2,"","",xxstring)) < 0) return(x);
971: if ((y = cmcfm()) < 0) return(y);
972: tt_arrow = x; /* 0 = application, 1 = cursor */
973: return(success = 1);
974:
975: case XYTKPD: /* SET TERMINAL KEYPAD-MODE */
976: if ((x = cmkey(kpmtab,2,"","",xxstring)) < 0) return(x);
977: if ((y = cmcfm()) < 0) return(y);
978: tt_keypad = x; /* 0 = application, 1 = numeric */
979: return(success = 1);
980:
981: case XYTWRP: /* SET TERMINAL WRAP */
982: seton(&tt_wrap);
983: return(success = 1);
984: #endif /* OS2 */
985:
986: #ifndef NOCSETS
987: case XYTCS: /* SET TERMINAL CHARACTER-SET */
988: /* set terminal character-set <remote> <local> */
989: if ((x = cmkey(ttcstab,ntermc,
990: "remote terminal character-set","",xxstring)) < 0)
991: return(x);
992: if (x == FC_TRANSP) { /* TRANSPARENT? */
993: if ((x = cmcfm()) < 0) return(x); /* Confirm the command */
994: tcsr = tcsl = FC_USASCII; /* Make them both the same */
995: return(success = 1);
996: }
997:
998: /* Not transparent, so get local set to translate it into */
999:
1000: s = ""; /* Make current file char set */
1001: for (y = 0; y <= nfilc; y++) /* be the default... */
1002: if (fcstab[y].kwval == fcharset) {
1003: s = fcstab[y].kwd;
1004: break;
1005: }
1006: if ((y = cmkey(fcstab,nfilc,
1007: "local character-set",s,xxstring)) < 0)
1008: return(y);
1009: if ((z = cmcfm()) < 0) return(z); /* Confirm the command */
1010: tcsr = x; /* Remote character set */
1011: tcsl = y; /* Local character set */
1012: return(success = 1);
1013: #endif /* NOCSETS */
1014:
1015: case XYTEC: /* SET TERMINAL ECHO */
1016: if ((x = cmkey(rltab,nrlt,"which side echos during CONNECT",
1017: "remote", xxstring)) < 0) return(x);
1018: if ((y = cmcfm()) < 0) return(y);
1019: duplex = x;
1020: return(success = 1);
1021:
1022: case XYTCRD: /* SET TERMINAL CR-DISPLAY */
1023: if ((x = cmkey(crdtab,2,"", "normal", xxstring)) < 0) return(x);
1024: if ((y = cmcfm()) < 0) return(y);
1025: tt_crd = x;
1026: return(success = 1);
1027:
1028: default: /* Shouldn't get here. */
1029: return(-2);
1030: }
1031: #endif /* MAC */
1032: }
1033:
1034: int /* SET SEND/RECEIVE */
1035: setsr(xx, rmsflg) int xx; int rmsflg; {
1036: if (xx == XYRECV)
1037: strcpy(line,"Parameter for inbound packets");
1038: else
1039: strcpy(line,"Parameter for outbound packets");
1040:
1041: if (rmsflg) {
1042: if ((y = cmkey(rsrtab,nrsrtab,line,"",xxstring)) < 0) {
1043: if (y == -3) {
1044: printf("?Remote receive parameter required\n");
1045: return(-9);
1046: } else return(y);
1047: }
1048: } else {
1049: if ((y = cmkey(srtab,nsrtab,line,"",xxstring)) < 0) return(y);
1050: }
1051: switch (y) {
1052:
1053: case XYEOL:
1054: y = cmnum("Decimal ASCII code for packet terminator","13",10,&x,
1055: xxstring);
1056: if ((y = setcc(&z,x,y)) < 0) return(y);
1057: if (xx == XYRECV) eol = z; else seol = z;
1058: return(success = y);
1059:
1060: case XYLEN:
1061: y = cmnum("Maximum number of characters in a packet","90",10,&x,
1062: xxstring);
1063: if (xx == XYRECV) { /* Receive... */
1064: if ((y = setnum(&z,x,y,maxrps)) < 0)
1065: return(y);
1066: if (z < 10) {
1067: printf("Sorry, 10 is the minimum\n");
1068: return(-9);
1069: }
1070: if (rmsflg) {
1071: tp = tmpbuf;
1072: sprintf(tp,"%d",z);
1073: sstate = setgen('S', "401", tp, "");
1074: return((int) sstate);
1075: } else {
1076: if (z > MAXRP) z = MAXRP;
1077: y = adjpkl(z,wslotr,bigrbsiz);
1078: if (y != z) {
1079: urpsiz = y;
1080: if (
1081: #ifndef NOSPL
1082: cmdlvl == 0
1083: #else
1084: tlevel < 0
1085: #endif /* NOSPL */
1086: )
1087: if (msgflg) printf(
1088: " Adjusting receive packet-length to %d for %d window slots\n",
1089: y, wslotr);
1090: }
1091: urpsiz = y;
1092: rpsiz = (y > 94) ? 94 : y;
1093: }
1094: } else { /* Send... */
1095: if ((y = setnum(&z,x,y,maxsps)) < 0)
1096: return(y);
1097: if (z < 10) {
1098: printf("Sorry, 10 is the minimum\n");
1099: return(-9);
1100: }
1101: if (z > MAXSP) z = MAXSP;
1102: spsiz = z; /* Set it */
1103: y = adjpkl(spsiz,wslotr,bigsbsiz);
1104: if (y != spsiz &&
1105: #ifndef NOSPL
1106: cmdlvl == 0
1107: #else
1108: tlevel < 0
1109: #endif /* NOSPL */
1110: )
1111: if (msgflg)
1112: printf("Adjusting packet size to %d for %d window slots\n",
1113: y,wslotr);
1114: spsiz = spmax = spsizr = y; /* Set it and flag that it was set */
1115: spsizf = 1; /* to allow overriding Send-Init. */
1116: }
1117: if (pflag &&
1118: #ifndef NOSPL
1119: cmdlvl == 0
1120: #else
1121: tlevel < 0
1122: #endif /* NOSPL */
1123: ) {
1124: if (z > 94 && msgflg) {
1125: printf("Extended-length packets requested.\n");
1126: if (bctr < 2 && z > 200) printf("\
1127: Remember to SET BLOCK 2 or 3 for long packets.\n");
1128: }
1129: if (speed <= 0L) speed = ttgspd();
1130: #ifdef COMMENT
1131: /*
1132: Kermit does this now itself.
1133: */
1134: if (speed <= 0L && z > 200 && msgflg) {
1135: printf("\
1136: Make sure your timeout interval is long enough for %d-byte packets.\n",z);
1137: }
1138: #endif /* COMMENT */
1139: }
1140: return(success = y);
1141:
1142: case XYMARK:
1143: y = cmnum("Code for packet-start character","1",10,&x,xxstring);
1144: #ifdef UNIX
1145: /*
1146: Printable start-of-packet works for UNIX and VMS only!
1147: */
1148: if ((y = setnum(&z,x,y,126)) < 0) return(y);
1149: #else
1150: #ifdef VMS
1151: if ((y = setnum(&z,x,y,126)) < 0) return(y);
1152: #else
1153: if ((y = setcc(&z,x,y)) < 0) return(y);
1154: #endif /* VMS */
1155: #endif /* UNIX */
1156: if (xx == XYRECV) stchr = z; else mystch = z;
1157: return(success = y);
1158:
1159:
1160: case XYNPAD: /* PADDING */
1161: y = cmnum("How many padding characters for inbound packets","0",10,&x,
1162: xxstring);
1163: if ((y = setnum(&z,x,y,94)) < 0) return(y);
1164: if (xx == XYRECV) mypadn = z; else npad = z;
1165: return(success = y);
1166:
1167: case XYPADC: /* PAD-CHARACTER */
1168: y = cmnum("Decimal ASCII code for packet padding character","0",10,&x,
1169: xxstring);
1170: if ((y = setcc(&z,x,y)) < 0) return(y);
1171: if (xx == XYRECV) mypadc = z; else padch = z;
1172: return(success = y);
1173:
1174: case XYTIMO: /* TIMEOUT */
1175: if (xx == XYRECV) {
1176: char buf[16]; /* Construct default */
1177: sprintf(buf,"%d",URTIME);
1178: y = cmnum("Packet timeout interval",buf,10,&x,xxstring);
1179: if ((y = setnum(&z,x,y,94)) < 0) return(y);
1180:
1181: if (rmsflg) { /* REMOTE SET RECEIVE TIMEOUT */
1182: tp = tmpbuf; /* Tell Kermit server what */
1183: sprintf(tp,"%d",z); /* timeout to ask me to use. */
1184: sstate = setgen('S', "402", tp, "");
1185: return((int) sstate);
1186: } else { /* SET RECEIVE TIMEOUT */
1187: pkttim = z; /* Value to put in my negotiation */
1188: } /* packet for other Kermit to use */
1189:
1190: } else { /* SET SEND TIMEOUT */
1191: y = cmnum("Packet timeout interval","",10,&x,xxstring);
1192: if (y == -3) { /* They cancelled a previous */
1193: x = DMYTIM; /* SET SEND command, so restore */
1194: y = 0; /* the default */
1195: timef = 0; /* and turn off the override flag */
1196: } else { /* They gave a number */
1197: timef = 1; /* so turn on the override flag */
1198: }
1199: if ((y = setnum(&z,x,y,94)) < 0)
1200: return(y);
1201: timint = rtimo = z; /* Override value for me to use */
1202: }
1203: return(success = 1);
1204:
1205: default:
1206: return(-2);
1207: } /* End of SET SEND/RECEIVE... */
1208: }
1209:
1210: #ifndef NOXMIT
1211: int
1212: setxmit() {
1213: if ((y = cmkey(xmitab,nxmit,"","",xxstring)) < 0) return(y);
1214: switch (y) {
1215: case XMITE: /* EOF */
1216: y = cmtxt("Characters to send at end of file,\n\
1217: Use backslash codes for control characters","",&s,xxstring);
1218: if (y < 0) return(y);
1219: if ((int)strlen(s) > XMBUFL) {
1220: printf("?Too many characters, %d maximum\n",XMBUFL);
1221: return(-2);
1222: }
1223: strcpy(xmitbuf,s);
1224: return(success = 1);
1225:
1226: case XMITF: /* Fill */
1227: y = cmnum("Numeric code for blank-line fill character","0",10,&x,
1228: xxstring);
1229: if ((y = setnum(&z,x,y,127)) < 0) return(y);
1230: xmitf = z;
1231: return(success = 1);
1232: case XMITL: /* Linefeed */
1233: return(success = seton(&xmitl));
1234: case XMITS: /* Locking-Shift */
1235: return(success = seton(&xmits));
1236: case XMITP: /* Prompt */
1237: y = cmnum("Numeric code for host's prompt character, 0 for none",
1238: "10",10,&x,xxstring);
1239: if ((y = setnum(&z,x,y,127)) < 0) return(y);
1240: xmitp = z;
1241: return(success = 1);
1242: case XMITX: /* Echo */
1243: return(success = seton(&xmitx));
1244: case XMITW: /* Pause */
1245: y = cmnum("Number of milliseconds to pause between binary characters\n\
1246: or text lines during transmission","0",10,&x,xxstring);
1247: if ((y = setnum(&z,x,y,1000)) < 0) return(y);
1248: xmitw = z;
1249: return(success = 1);
1250: default:
1251: return(-2);
1252: }
1253: }
1254: #endif /* NOXMIT */
1255:
1256: /* D O R M T -- Do a remote command */
1257:
1258: #ifdef ATTSV
1259: #ifndef aegis
1260: #ifndef datageneral
1261: #define CK_NEED_SIG
1262: #endif /* datageneral */
1263: #endif /* aegis */
1264: #endif /* ATTSV */
1265:
1266: VOID rmsg() {
1267: if (pflag)
1268: printf(
1269: #ifdef CK_NEEDSIG
1270:
1271: " Type your escape character, %s, followed by X or E to cancel.\n",
1272: dbchr(escape)
1273: #else
1274: " Press the X or E key to cancel.\n"
1275: #endif /* CK_NEEDSIG */
1276: );
1277: }
1278:
1279: int
1280: dormt(xx) int xx; {
1281: int x, y, retcode;
1282: char *s, sbuf[50], *s2;
1283:
1284:
1285: if (xx < 0) return(xx);
1286:
1287: if (xx == XZSET) { /* REMOTE SET */
1288: if ((y = cmkey(rmstab,nrms,"","",xxstring)) < 0) {
1289: if (y == -3) {
1290: printf("?Parameter name required\n");
1291: return(-9);
1292: } else return(y);
1293: }
1294: return(doprm(y,1));
1295: }
1296:
1297: switch (xx) { /* Others... */
1298:
1299: case XZCWD: /* CWD */
1300: if ((x = cmtxt("Remote directory name","",&s,xxstring)) < 0) return(x);
1301: debug(F111,"XZCWD: ",s,x);
1302: *sbuf = NUL;
1303: s2 = sbuf;
1304:
1305: /* The following is commented out, because there is practically no */
1306: /* computer in the world that requires a password for directory changing. */
1307: /* (The DEC-20 was the only one, and they're mostly all gone.) */
1308: #ifdef DIRPWDPR
1309: if (*s != NUL) { /* If directory name given, */
1310: /* get password on separate line. */
1311: if (tlevel > -1) { /* From take file... */
1312:
1313: if (fgets(sbuf,50,tfile[tlevel]) == NULL)
1314: fatal("take file ends prematurely in 'remote cwd'");
1315: debug(F110," pswd from take file",s2,0);
1316: for (x = (int)strlen(sbuf);
1317: x > 0 && (sbuf[x-1] == NL || sbuf[x-1] == CR);
1318: x--)
1319: sbuf[x-1] = '\0';
1320:
1321: } else { /* From terminal... */
1322:
1323: printf(" Password: "); /* get a password */
1324: #ifdef OS2
1325: while (((x = isatty(0) ? coninc(0) :
1326: getchar()) != NL) && (x != CR)) { /* with no echo */
1327: #else
1328: while (((x = getchar()) != NL) && (x != CR)) { /* with no echo */
1329: #endif /* OS2 */
1330: if ((x &= 0177) == '?') {
1331: printf("? Password of remote directory\n Password: ");
1332: s2 = sbuf;
1333: *sbuf = NUL;
1334: }
1335: else if (x == ESC) /* Mini command line editor... */
1336: putchar(BEL);
1337: else if (x == BS || x == 0177)
1338: s2--;
1339: else if (x == 025) { /* Ctrl-U */
1340: s2 = sbuf;
1341: *sbuf = NUL;
1342: }
1343: else
1344: *s2++ = x;
1345: }
1346: *s2 = NUL;
1347: putchar('\n');
1348: }
1349: s2 = sbuf;
1350: } else s2 = "";
1351: #endif /* DIRPWDPR */
1352:
1353: debug(F110," password",s2,0);
1354: sstate = setgen('C',s,s2,"");
1355: retcode = 0;
1356: break;
1357:
1358: case XZDEL: /* Delete */
1359: if ((x = cmtxt("Name of remote file(s) to delete","",&s,xxstring)) < 0) {
1360: if (x == -3) {
1361: printf("?Name of remote file(s) required\n");
1362: return(-9);
1363: } else return(x);
1364: }
1365: if (local) ttflui(); /* If local, flush tty input buffer */
1366: retcode = sstate = rfilop(s,'E');
1367: break;
1368:
1369: case XZDIR: /* Directory */
1370: if ((x = cmtxt("Remote directory or file specification","",&s,
1371: xxstring)) < 0)
1372: return(x);
1373: if (local) ttflui(); /* If local, flush tty input buffer */
1374: rmsg();
1375: retcode = sstate = setgen('D',s,"","");
1376: break;
1377:
1378: case XZHLP: /* Help */
1379: if ((x = cmcfm()) < 0) return(x);
1380: sstate = setgen('H',"","","");
1381: retcode = 0;
1382: break;
1383:
1384: #ifndef NOPUSH
1385: case XZHOS: /* Host */
1386: if ((x = cmtxt("Command for remote system","",&cmarg,xxstring)) < 0)
1387: return(x);
1388: if ((int)strlen(cmarg) < 1) {
1389: if (x == -3) {
1390: printf("?Remote host command required\n");
1391: return(-9);
1392: } else return(x);
1393: }
1394: rmsg();
1395: retcode = sstate = 'c';
1396: break;
1397: #endif /* NOPUSH */
1398:
1399: #ifndef NOFRILLS
1400: case XZKER:
1401: if ((x = cmtxt("Command for remote Kermit","",&cmarg,xxstring)) < 0)
1402: return(x);
1403: if ((int)strlen(cmarg) < 1) {
1404: if (x == -3) {
1405: printf("?Remote Kermit command required\n");
1406: return(-9);
1407: } else return(x);
1408: }
1409: retcode = sstate = 'k';
1410: rmsg();
1411: break;
1412:
1413: case XZLGI: { /* Login */
1414: char *p1, *p2, *p3;
1415: if ((x = cmfld("User ID","",&s,xxstring)) < 0) return(x);
1416: if ((p1 = malloc((int)strlen(s) + 1)) == NULL) {
1417: printf("Internal error: malloc\n");
1418: return(-2);
1419: } else strcpy(p1,s);
1420: if ((x = cmfld("Password","",&s,xxstring)) < 0) return(x);
1421: if ((p2 = malloc((int)strlen(s) + 1)) == NULL) {
1422: printf("Internal error: malloc\n");
1423: return(-2);
1424: } else strcpy(p2,s);
1425: if ((x = cmtxt("Account or carriage return","",
1426: &s,xxstring)) < 0 && x != -3)
1427: return(x);
1428: if ((p3 = malloc((int)strlen(s) + 1)) == NULL) {
1429: printf("Internal error: malloc\n");
1430: return(-2);
1431: } else strcpy(p3,s);
1432: sstate = setgen('I',p1,p2,p3);
1433: if (p3) free(p3);
1434: if (p2) free(p2);
1435: if (p1) free(p1);
1436: retcode = 0;
1437: break;
1438: }
1439:
1440: case XZLGO: /* Logout */
1441: if ((x = cmcfm()) < 0) return(x);
1442: sstate = setgen('I',"","","");
1443: retcode = 0;
1444: break;
1445:
1446: case XZPRI: /* Print */
1447: if (!atdiso || !atcapr) { /* Disposition attribute off? */
1448: printf("?Disposition Attribute is Off\n");
1449: return(-2);
1450: }
1451: cmarg = "";
1452: cmarg2 = "";
1453: if ((x = cmifi("Local file(s) to print on remote printer","",&s,&y,
1454: xxstring)) < 0) {
1455: if (x == -3) {
1456: printf("?Name of local file(s) required\n");
1457: return(-9);
1458: }
1459: return(x);
1460: }
1461: strcpy(line,s); /* Make a safe copy of filename */
1462: *optbuf = NUL; /* Wipe out any old options */
1463: if ((x = cmtxt("Options for remote print command","",&s,xxstring)) < 0)
1464: return(x);
1465: strcpy(optbuf,s); /* Make a safe copy of options */
1466: if ((int)strlen(optbuf) > 94) { /* Make sure this is legal */
1467: printf("?Option string too long\n");
1468: return(-9);
1469: }
1470: nfils = -1; /* Expand file list internally */
1471: cmarg = line; /* Point to file list. */
1472: rprintf = 1; /* REMOTE PRINT modifier for SEND */
1473: sstate = 's'; /* Set start state to SEND */
1474: if (local) displa = 1;
1475: retcode = 0;
1476: break;
1477: #endif /* NOFRILLS */
1478:
1479: case XZSPA: /* Space */
1480: if ((x = cmtxt("Confirm, or remote directory name","",&s,xxstring)) < 0)
1481: return(x);
1482: retcode = sstate = setgen('U',s,"","");
1483: break;
1484:
1485: #ifndef NOFRILLS
1486: case XZTYP: /* Type */
1487: if ((x = cmtxt("Remote file specification","",&s,xxstring)) < 0)
1488: return(x);
1489: if ((int)strlen(s) < 1) {
1490: printf("?Remote filename required\n");
1491: return(-9);
1492: }
1493: rmsg();
1494: retcode = sstate = rfilop(s,'T');
1495: break;
1496: #endif /* NOFRILLS */
1497:
1498: #ifndef NOFRILLS
1499: case XZWHO:
1500: if ((x = cmtxt("Remote user name, or carriage return","",&s,xxstring)) < 0)
1501: return(x);
1502: retcode = sstate = setgen('W',s,"","");
1503: break;
1504: #endif /* NOFRILLS */
1505:
1506: default:
1507: if ((x = cmcfm()) < 0) return(x);
1508: printf("?Not implemented - %s\n",cmdbuf);
1509: return(-2);
1510: }
1511: if (local) ttflui(); /* If local, flush tty input buffer */
1512: return(retcode);
1513: }
1514:
1515:
1516: /* R F I L O P -- Remote File Operation */
1517:
1518: CHAR
1519: #ifdef CK_ANSIC
1520: rfilop(char * s, char t)
1521: #else
1522: rfilop(s,t) char *s, t;
1523: #endif /* CK_ANSIC */
1524: /* rfilop */ {
1525: if (*s == NUL) {
1526: printf("?File specification required\n");
1527: return((CHAR) 0);
1528: }
1529: debug(F111,"rfilop",s,t);
1530: return(setgen(t,s,"",""));
1531: }
1532:
1533: #ifdef SUNX25
1534: int
1535: setx25() {
1536: if ((y = cmkey(x25tab,nx25,"X.25 call options","",xxstring)) < 0)
1537: return(y);
1538: switch (y) {
1539: case XYUDAT:
1540: if ((z = cmkey(onoff,2,"X.25 call user data","",xxstring))
1541: < 0) return(z);
1542: if (z == 0) {
1543: if ((z = cmcfm()) < 0) return(z);
1544: cudata = 0; /* disable call user data */
1545: return (success = 1);
1546: }
1547: if ((x = cmtxt("X.25 call user data string","",&s,xxstring)) < 0)
1548: return(x);
1549: if ((int)strlen(s) == 0) {
1550: return (-3);
1551: } else if ((int)strlen(s) > MAXCUDATA) {
1552: printf("?The length must be > 0 and <= %d\n",MAXCUDATA);
1553: return(-2);
1554: }
1555: if ((y = cmcfm()) < 0) return(y);
1556: strcpy(udata,s);
1557: cudata = 1; /* X.25 call user data specified */
1558: return (success = 1);
1559: case XYCLOS:
1560: if ((z = cmkey(onoff,2,"X.25 closed user group call","",xxstring))
1561: < 0) return(z);
1562: if (z == 0) {
1563: if ((z = cmcfm()) < 0) return(z);
1564: closgr = -1; /* disable closed user group */
1565: return (success = 1);
1566: }
1567: if ((y = cmnum("0 <= cug index >= 99","",10,&x,xxstring)) < 0)
1568: return(y);
1569: if (x < 0 || x > 99) {
1570: printf("?The choices are 0 <= cug index >= 99\n");
1571: return(-2);
1572: }
1573: if ((y = cmcfm()) < 0) return(y);
1574: closgr = x; /* closed user group selected */
1575: return (success = 1);
1576:
1577: case XYREVC:
1578: if((z = cmkey(onoff,2,"X.25 reverse charge call","",xxstring)) < 0)
1579: return(z);
1580: if ((x = cmcfm()) < 0) return(x);
1581: revcall = z;
1582: return (success = 1);
1583: }
1584: }
1585:
1586: int
1587: setpadp() {
1588: if ((y = cmkey(padx3tab,npadx3,"PAD X.3 parameter name","",xxstring)) < 0)
1589: return(y);
1590: x = y;
1591: switch (x) {
1592: case PAD_BREAK_CHARACTER:
1593: if ((y = cmnum("PAD break character value","",10,&z,xxstring)) < 0)
1594: return(y);
1595: if ((y = cmcfm()) < 0) return(y);
1596: break;
1597: case PAD_ESCAPE:
1598: if ((y = cmnum("PAD escape","",10,&z,xxstring)) < 0) return(y);
1599: if (z != 0 && z != 1) {
1600: printf("?The choices are 0 or 1\n");
1601: return(-2);
1602: }
1603: if ((y = cmcfm()) < 0) return(y);
1604: break;
1605: case PAD_ECHO:
1606: if ((y = cmnum("PAD echo","",10,&z,xxstring)) < 0) return(y);
1607: if (z != 0 && z != 1) {
1608: printf("?The choices are 0 or 1\n");
1609: return(-2);
1610: }
1611: if ((y = cmcfm()) < 0) return(y);
1612: break;
1613: case PAD_DATA_FORWARD_CHAR:
1614: if ((y = cmnum("PAD data forward char","",10,&z,xxstring)) < 0)
1615: return(y);
1616: if (z != 0 && z != 2) {
1617: printf("?The choices are 0 or 2\n");
1618: return(-2);
1619: }
1620: if ((y = cmcfm()) < 0) return(y);
1621: break;
1622: case PAD_DATA_FORWARD_TIMEOUT:
1623: if ((y = cmnum("PAD data forward timeout","",10,&z,xxstring)) < 0)
1624: return(y);
1625: if (z < 0 || z > 255) {
1626: printf("?The choices are 0 or 1 <= timeout <= 255\n");
1627: return(-2);
1628: }
1629: if ((y = cmcfm()) < 0) return(y);
1630: break;
1631: case PAD_FLOW_CONTROL_BY_PAD:
1632: if ((y = cmnum("PAD pad flow control","",10,&z,xxstring)) < 0)
1633: return(y);
1634: if (z != 0 && z != 1) {
1635: printf("?The choices are 0 or 1\n");
1636: return(-2);
1637: }
1638: if ((y = cmcfm()) < 0) return(y);
1639: break;
1640: case PAD_SUPPRESSION_OF_SIGNALS:
1641: if ((y = cmnum("PAD service","",10,&z,xxstring)) < 0) return(y);
1642: if (z != 0 && z != 1) {
1643: printf("?The choices are 0 or 1\n");
1644: return(-2);
1645: }
1646: if ((y = cmcfm()) < 0) return(y);
1647: break;
1648:
1649: case PAD_BREAK_ACTION:
1650: if ((y = cmnum("PAD break action","",10,&z,xxstring)) < 0) return(y);
1651: if (z != 0 && z != 1 && z != 2 && z != 5 && z != 8 && z != 21) {
1652: printf("?The choices are 0, 1, 2, 5, 8 or 21\n");
1653: return(-2);
1654: }
1655: if ((y = cmcfm()) < 0) return(y);
1656: break;
1657:
1658: case PAD_SUPPRESSION_OF_DATA:
1659: if ((y = cmnum("PAD data delivery","",10,&z,xxstring)) < 0) return(y);
1660: if (z != 0 && z != 1) {
1661: printf("?The choices are 0 or 1\n");
1662: return(-2);
1663: }
1664: if ((y = cmcfm()) < 0) return(y);
1665: break;
1666:
1667: case PAD_PADDING_AFTER_CR:
1668: if ((y = cmnum("PAD crpad","",10,&z,xxstring)) < 0) return(y);
1669: if (z < 0 || z > 7) {
1670: printf("?The choices are 0 or 1 <= crpad <= 7\n");
1671: return(-2);
1672: }
1673: if ((y = cmcfm()) < 0) return(y);
1674: break;
1675:
1676: case PAD_LINE_FOLDING:
1677: if ((y = cmnum("PAD linefold","",10,&z,xxstring)) < 0) return(y);
1678: if (z < 0 || z > 255) {
1679: printf("?The choices are 0 or 1 <= linefold <= 255\n");
1680: return(-2);
1681: }
1682: if ((y = cmcfm()) < 0) return(y);
1683: break;
1684:
1685: case PAD_LINE_SPEED:
1686: if ((y = cmnum("PAD baudrate","",10,&z,xxstring)) < 0) return(y);
1687: if (z < 0 || z > 18) {
1688: printf("?The choices are 0 <= baudrate <= 18\n");
1689: return(-2);
1690: }
1691: if ((y = cmcfm()) < 0) return(y);
1692: break;
1693:
1694: case PAD_FLOW_CONTROL_BY_USER:
1695: if ((y = cmnum("PAD terminal flow control","",10,&z,xxstring)) < 0)
1696: return(y);
1697: if (z != 0 && z != 1) {
1698: printf("?The choices are 0 or 1\n");
1699: return(-2);
1700: }
1701: if ((y = cmcfm()) < 0) return(y);
1702: break;
1703:
1704: case PAD_LF_AFTER_CR:
1705: if ((y = cmnum("PAD crpad","",10,&z,xxstring)) < 0) return(y);
1706: if (z < 0 || z == 3 || z > 7) {
1707: printf("?The choices are 0, 1, 2, 4, 5, 6 or 7\n");
1708: return(-2);
1709: }
1710: if ((y = cmcfm()) < 0) return(y);
1711: break;
1712:
1713: case PAD_PADDING_AFTER_LF:
1714: if ((y = cmnum("PAD lfpad","",10,&z,xxstring)) < 0) return(y);
1715: if (z < 0 || z > 7) {
1716: printf("?The choices are 0 or 1 <= lfpad <= 7\n");
1717: return(-2);
1718: }
1719: if ((y = cmcfm()) < 0) return(y);
1720: break;
1721:
1722: case PAD_EDITING:
1723: if ((y = cmnum("PAD edit control","",10,&z,xxstring)) < 0) return(y);
1724: if (z != 0 && z != 1) {
1725: printf("?The choices are 0 or 1\n");
1726: return(-2);
1727: }
1728: if ((y = cmcfm()) < 0) return(y);
1729: break;
1730:
1731: case PAD_CHAR_DELETE_CHAR:
1732: if ((y = cmnum("PAD char delete char","",10,&z,xxstring)) < 0)
1733: return(y);
1734: if (z < 0 || z > 127) {
1735: printf("?The choices are 0 or 1 <= chardelete <= 127\n");
1736: return(-2);
1737: }
1738: if ((y = cmcfm()) < 0) return(y);
1739: break;
1740:
1741: case PAD_BUFFER_DELETE_CHAR:
1742: if ((y = cmnum("PAD buffer delete char","",10,&z,xxstring)) < 0)
1743: return(y);
1744: if (z < 0 || z > 127) {
1745: printf("?The choices are 0 or 1 <= bufferdelte <= 127\n");
1746: return(-2);
1747: }
1748: if ((y = cmcfm()) < 0) return(y);
1749: break;
1750:
1751: case PAD_BUFFER_DISPLAY_CHAR:
1752: if ((y = cmnum("PAD display line char","",10,&z,xxstring)) < 0)
1753: return(y);
1754: if (z < 0 || z > 127) {
1755: printf("?The choices are 0 or 1 <= displayline <= 127\n");
1756: return(-2);
1757: }
1758: if ((y = cmcfm()) < 0) return(y);
1759: break;
1760: }
1761: padparms[x] = z;
1762: return(success = 1);
1763: }
1764: #endif /* SUNX25 */
1765:
1766: int
1767: setat(rmsflg) int rmsflg; {
1768: int xx;
1769: if ((y = cmkey(attrtab,natr,"File Attribute packets","",xxstring)) < 0)
1770: return(y);
1771: if (y == AT_XALL) { /* ATTRIBUTES ALL ON or ALL OFF */
1772: if ((z = seton(&xx)) < 0) return(z);
1773: if (rmsflg) {
1774: printf("Sorry, command not available\n");
1775: return(-9);
1776: } else {
1777: atenci = xx; /* Encoding in */
1778: atenco = xx; /* Encoding out */
1779: atdati = xx; /* Date in */
1780: atdato = xx; /* Date out */
1781: atdisi = xx; /* Disposition in/out */
1782: atdiso = xx;
1783: atleni = xx; /* Length in/out (both kinds) */
1784: atleno = xx;
1785: atblki = xx; /* Blocksize in/out */
1786: atblko = xx;
1787: attypi = xx; /* File type in/out */
1788: attypo = xx;
1789: atsidi = xx; /* System ID in/out */
1790: atsido = xx;
1791: atsysi = xx; /* System-dependent params in/out */
1792: atsyso = xx;
1793: }
1794: return(z);
1795: } else if (y == AT_ALLY || y == AT_ALLN) { /* ATTRIBUTES ON or OFF */
1796: if ((x = cmcfm()) < 0) return(x);
1797: atcapr = (y == AT_ALLY) ? 1 : 0;
1798: if (rmsflg) {
1799: sstate = setgen('S', "132", atcapr ? "1" : "0", "");
1800: return((int) sstate);
1801: } else return(success = 1);
1802: }
1803: /* Otherwise, it's an individual attribute that wants turning off/on */
1804:
1805: if ((z = cmkey(onoff,2,"","",xxstring)) < 0) return(z);
1806: if ((x = cmcfm()) < 0) return(x);
1807:
1808: /* There are better ways to do this... */
1809: /* The real problem is that we're not separating the in and out cases */
1810: /* and so we have to arbitrarily pick the "in" case, i.e tell the remote */
1811: /* server to ignore incoming attributes of the specified type, rather */
1812: /* than telling it not to send them. The protocol does not (yet) define */
1813: /* codes for "in-and-out-at-the-same-time". */
1814:
1815: switch(y) {
1816: case AT_DISP:
1817: if (rmsflg) {
1818: sstate = setgen('S', "142", z ? "1" : "0", "");
1819: return((int) sstate);
1820: }
1821: atdisi = atdiso = z; break;
1822: case AT_ENCO:
1823: if (rmsflg) {
1824: sstate = setgen('S', "141", z ? "1" : "0", "");
1825: return((int) sstate);
1826: }
1827: atenci = atenco = z; break;
1828: case AT_DATE:
1829: if (rmsflg) {
1830: sstate = setgen('S', "135", z ? "1" : "0", "");
1831: return((int) sstate);
1832: }
1833: atdati = atdato = z; break;
1834: case AT_LENB:
1835: case AT_LENK:
1836: if (rmsflg) {
1837: sstate = setgen('S', "133", z ? "1" : "0", "");
1838: return((int) sstate);
1839: }
1840: atleni = atleno = z; break;
1841: case AT_BLKS:
1842: if (rmsflg) {
1843: sstate = setgen('S', "139", z ? "1" : "0", "");
1844: return((int) sstate);
1845: }
1846: atblki = atblko = z; break;
1847: case AT_FTYP:
1848: if (rmsflg) {
1849: sstate = setgen('S', "134", z ? "1" : "0", "");
1850: return((int) sstate);
1851: }
1852: attypi = attypo = z; break;
1853: case AT_SYSI:
1854: if (rmsflg) {
1855: sstate = setgen('S', "145", z ? "1" : "0", "");
1856: return((int) sstate);
1857: }
1858: atsidi = atsido = z; break;
1859: case AT_SYSP:
1860: if (rmsflg) {
1861: sstate = setgen('S', "147", z ? "1" : "0", "");
1862: return((int) sstate);
1863: }
1864: atsysi = atsyso = z; break;
1865: default:
1866: printf("?Not available\n");
1867: return(-2);
1868: }
1869: return(1);
1870: }
1871:
1872: #ifndef NOSPL
1873: int
1874: setinp() {
1875: if ((y = cmkey(inptab,ninp,"","",xxstring)) < 0) return(y);
1876: switch (y) {
1877: case IN_DEF: /* SET INPUT DEFAULT-TIMEOUT */
1878: z = cmnum("Positive number","",10,&x,xxstring);
1879: return(success = setnum(&indef,x,z,94));
1880: case IN_TIM: /* SET INPUT TIMEOUT-ACTION */
1881: if ((z = cmkey(intimt,2,"","",xxstring)) < 0) return(z);
1882: if ((x = cmcfm()) < 0) return(x);
1883: intime = z;
1884: return(success = 1);
1885: case IN_CAS: /* SET INPUT CASE */
1886: if ((z = cmkey(incast,2,"","",xxstring)) < 0) return(z);
1887: if ((x = cmcfm()) < 0) return(x);
1888: incase = z;
1889: return(success = 1);
1890: case IN_ECH: /* SET INPUT ECHO */
1891: return(success = seton(&inecho));
1892: case IN_SIL: /* SET INPUT SILENCE */
1893: z = cmnum("Positive number","",10,&x,xxstring);
1894: return(success = setnum(&insilence,x,z,-1));
1895: }
1896: return(0);
1897: }
1898: #endif /* NOSPL */
1899:
1900: /*
1901: setlin -- parse name of and then open a communication device.
1902: Call with:
1903: xx == XXLINE for a serial (tty) line, XXHOST for a network host,
1904: zz == 0 means if user doesn't give a device name, continue current
1905: active connection (if any);
1906: zz != 0 means if user doesn't give a device name, then close the
1907: current connection and restore the default communication device.
1908: */
1909: int
1910: setlin(xx, zz) int xx, zz; {
1911: if (xx == XYHOST) { /* SET HOST <hostname> */
1912: #ifndef NETCONN
1913: printf("?Network connections not supported\n");
1914: return(-9);
1915: #else
1916: if (
1917: (nettype != NET_DEC) &&
1918: (nettype != NET_SX25) &&
1919: (nettype != NET_TCPB)) {
1920: printf("?Network type not supported\n");
1921: return(-9);
1922: }
1923: if (nettype != NET_TCPB) { /* Not a TCP/IP connection */
1924: /* Just get a text string */
1925: if ((x = cmtxt( zz ?
1926: "Network host name,\n or carriage return to close an open connection" :
1927: "Network host name,\n or carriage return to resume an open connection",
1928: "",&s,xxstring)) < 0)
1929: return(x);
1930:
1931: } else { /* TCP/IP connection... */
1932:
1933: /* Parse for host and service separately. */
1934:
1935: if ((x = cmfld( zz ?
1936: "IP host name or number,\n or carriage return to close an open connection" :
1937: "IP host name or number,\n or carriage return to resume an open connection",
1938: "",&s,xxstring)) < 0) {
1939: if (x != -3) /* Parse error */
1940: return(x); /* return it */
1941: else if (!zz) /* No hostname given */
1942: return(1); /* and none required, */
1943: } /* continue current connection. */
1944: if (*s) { /* If they gave a host name... */
1945: strcpy(line,s); /* make a copy */
1946: /* Check for "host:service" */
1947: for ( ; (*s != '\0') && (*s != ':'); s++) ;
1948:
1949: /* If no service given, let them type one now. */
1950:
1951: if (!*s) {
1952: if ((x = cmfld(
1953: "TCP service name or number,\n or carriage return for telnet (23)",
1954: "23",&s,xxstring)) < 0 && x != -3)
1955: return(x);
1956: if (*s) { /* If they gave a service, */
1957: strcat(line,":"); /* concatenate it to the hostname */
1958: strcat(line,s); /* separated by a colon, because */
1959: } /* this is how ttopen() wants it. */
1960: }
1961: if ((x = cmcfm()) < 0) return(x); /* Confirm the command */
1962: s = line;
1963: }
1964: }
1965:
1966: /* New connection wanted. */
1967:
1968: ttflui(); /* Clear away buffered up junk */
1969: ttclos(0); /* Close old connection, if any */
1970: if (oldplex > -1) /* Restore duplex setting. */
1971: duplex = oldplex;
1972: if (*s) { /* They gave a hostname */
1973: x = 1; /* Network connection always local */
1974: mdmsav = mdmtyp; /* Remember old modem type */
1975: mdmtyp = -nettype; /* Special code for network */
1976: if (nettype == NET_TCPB) { /* For TCP/IP telnet connections */
1977: oldplex = duplex; /* Remember previous duplex */
1978: duplex = 0; /* Set full duplex and let */
1979: } /* negotiations change if necessary. */
1980: } else { /* They just said "set host" */
1981: if (network && msgflg)
1982: printf(" Closing connection\n");
1983: s = dftty; /* So go back to normal */
1984: x = dfloc; /* default tty, location, */
1985: network = 0; /* No more network connection. */
1986: duplex = oldplex; /* Restore old duplex setting. */
1987: if (mdmtyp < 0) { /* Switching from net to async? */
1988: if (mdmsav > -1) /* Restore modem type from last */
1989: mdmtyp = mdmsav; /* SET MODEM command, if any. */
1990: else
1991: mdmtyp = 0;
1992: }
1993: }
1994: #endif /* NETCONN */
1995: }
1996:
1997: /* Serial tty device, possibly modem, connection... */
1998:
1999: if (xx == XYLINE) { /* SET LINE */
2000: #ifdef OS2 /* or SET PORT */
2001: if ((x = cmkey(os2devtab,nos2dev,"serial communication device name",
2002: "com1", xxstring)) < 0) {
2003: debug(F101,"OS2 SET PORT x","",x);
2004: if (x != -9) return(x);
2005: s = atxbuf; /* Doesn't match keyword */
2006: if (*s == '_') s++; /* Secret notation for file handle */
2007: else return(-9);
2008: } else if (x >= 1 && x <= 8) { /* Regular COM port */
2009: s = os2devtab[x+7].kwd; /* Use its real name */
2010: } else s = atxbuf; /* Something else, believe it */
2011: #else
2012: if ((x = cmtxt("Communication device name",dftty,&s,xxstring)) < 0)
2013: return(x);
2014: #endif /* OS2 */
2015:
2016: if (local) ttflui(); /* Clear away buffered up junk */
2017: ttclos(0); /* Close old line, if any was open */
2018: if (*s) { /* They gave a device name */
2019: x = -1; /* Let ttopen decide about it */
2020: } else { /* They just said "set line" */
2021: s = dftty; /* so go back to normal tty */
2022: x = dfloc; /* and mode. */
2023: }
2024: if (mdmtyp < 0) { /* Switching from net to async? */
2025: if (mdmsav > -1) /* Restore modem type from last */
2026: mdmtyp = mdmsav; /* SET MODEM command, if any. */
2027: else
2028: mdmtyp = 0;
2029: mdmsav = -1;
2030: }
2031: if (oldplex > -1) { /* Restore previous duplex setting. */
2032: duplex = oldplex;
2033: oldplex = -1;
2034: }
2035: network = 0; /* No more network. */
2036: }
2037: #ifdef COMMENT
2038: /*
2039: The following is removed, not so much because it's a horrible hack, but
2040: because it only works if the SET FLOW command was given *before* the SET
2041: LINE command, whereas normally these commands can be given in any order.
2042: */
2043: #ifdef NEXT
2044: /*
2045: This is a horrible hack, but it's nice for users. On the NeXT, you select
2046: RTS/CTS hardware flow control not by system calls, but by referring to the
2047: device with a different name. If the user has asked for RTS/CTS flow
2048: control on a NeXT, but used the non-RTS/CTS device name in the SET LINE
2049: command, we make the appropriate substitute here. I wonder how much bigger
2050: this section of code will grow as the years go by...
2051: */
2052: if ((flow == FLO_RTSC) && /* RTS/CTS flow control selected */
2053: strcmp(s,dftty)) { /* ...on external port? */
2054: y = strlen(s); /* Yes, insert "f" as next-to-last */
2055: if (s[y-2] != 'f') { /* character in device name if not */
2056: strcpy(line,s); /* already there... */
2057: line[y] = line[y-1]; /* So /dev/cua => /dev/cufa, etc. */
2058: line[y-1] = 'f';
2059: line[y+1] = '\0';
2060: s = line;
2061: }
2062: }
2063: #endif /* NEXT */
2064: #endif /* COMMENT */
2065:
2066: if ((y = ttopen(s,&x,mdmtyp,cdtimo)) < 0 ) { /* Open the new line */
2067: if (y == -2) {
2068: printf("?Timed out, no carrier.\n");
2069: printf("Try SET CARRIER OFF and SET LINE again, or else\n");
2070: printf("SET MODEM, SET LINE, and then DIAL.\n");
2071: } else if (y == -3) {
2072: printf("Sorry, access to lock denied: %s\n",s);
2073: } else if (y == -4) {
2074: printf("Sorry, access to device denied: %s\n",s);
2075: } else if (y == -5) {
2076: #ifdef VMS
2077: printf("Sorry, device is in use or otherwise unavailable: %s\n",s);
2078: #else
2079: printf("Sorry, device is in use: %s\n",s);
2080: #endif /* VMS */
2081: } else { /* Other error. */
2082: #ifndef VMS
2083: if (errno) {
2084: tp = tmpbuf;
2085: sprintf(tp,"Sorry, can't open connection: %s",s);
2086: perror(tp);
2087: } else
2088: #endif /* VMS */
2089: printf("Sorry, can't open connection: %s\n",s);
2090: }
2091: local = dfloc; /* Go back to normal */
2092: #ifndef MAC
2093: strcpy(ttname,dftty); /* Restore default tty name */
2094: #endif /* MAC */
2095: speed = ttgspd();
2096: network = 0; /* No network connection active */
2097: return(success = 0); /* Return failure */
2098: }
2099: if (x > -1) local = x; /* Opened ok, set local/remote. */
2100: network = (mdmtyp < 0); /* Remember connection type. */
2101: #ifdef TNCODE
2102: if (network) tn_init = 0; /* Say telnet not init'd yet. */
2103: #endif /* TNCODE */
2104: strcpy(ttname,s); /* Copy name into real place. */
2105: speed = ttgspd(); /* Get the current speed. */
2106: debug(F111,"set line ",ttname,local);
2107: #ifdef NETCONN
2108: #ifdef SUNX25
2109: if (nettype == NET_SX25) duplex = 1; /* Duplex half */
2110: #endif /* SUNX25 */
2111: #endif /* NETCONN */
2112: return(success = 1);
2113: }
2114: #endif /* NOICP */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.