![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckucon.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / kermit|
Return to ckucon.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / kermit |
1.1 root 1: char *connv = "Connect Command for Unix, V4C(014) 29 Jul 85";
2:
3: /* C K U C O N -- Dumb terminal connection to remote system, for Unix */
4: /*
5: This module should work under all versions of Unix. It calls externally
6: defined system-dependent functions for i/o, but depends upon the existence
7: of the fork() function.
8:
9: Author: Frank da Cruz (SY.FDC@CU20B),
10: Columbia University Center for Computing Activities, January 1985.
11: Copyright (C) 1985, Trustees of Columbia University in the City of New York.
12: Permission is granted to any individual or institution to use, copy, or
13: redistribute this software so long as it is not sold for profit, provided this
14: copyright notice is retained.
15:
16: Enhanced by H. Fischer to detect when child process (modem reader)
17: reports that the communications line has been broken and hang up.
18: Also enhanced to allow escaping from connect state to command
19: interpreter, to allow sending/receiving without breaking connection.
20: */
21:
22: #include <stdio.h>
23: #include <ctype.h> /* Character types */
24: #include "ckcdeb.h"
25: #include "ckcker.h"
26: #include <signal.h>
27: #include <setjmp.h>
28:
29: #ifndef SIGUSR1
30: #define SIGUSR1 16
31: #endif
32:
33: extern int local, speed, escape, duplex, parity, flow, seslog, mdmtyp;
34: extern int errno;
35: extern char ttname[], sesfil[];
36: extern CHAR dopar();
37:
38: int i, active; /* Variables global to this module */
39: char *chstr();
40: char temp[50];
41:
42: #define LBUFL 200 /* Line buffer */
43: char lbuf[LBUFL];
44:
45: /* Connect state parent/child communication signal handlers */
46:
47: static jmp_buf env_con; /* Envir ptr for connect errors */
48:
49: static
50: conn_int() { /* Modem read failure handler, */
51: longjmp(env_con,1); /* notifies parent process to stop */
52: }
53:
54: /* C O N E C T -- Perform terminal connection */
55:
56: conect() {
57: int pid, /* process id of child (modem reader) */
58: parent_id, /* process id of parent (keyboard reader) */
59: n;
60: int c; /* c is a character, but must be signed
61: integer to pass thru -1, which is the
62: modem disconnection signal, and is
63: different from the character 0377 */
64: char errmsg[50], *erp;
65:
66: if (!local) {
67: printf("Sorry, you must 'set line' first\n");
68: return(-2);
69: }
70: if (speed < 0) {
71: printf("Sorry, you must 'set speed' first\n");
72: return(-2);
73: }
74: if ((escape < 0) || (escape > 0177)) {
75: printf("Your escape character is not ASCII - %d\n",escape);
76: return(-2);
77: }
78: if (ttopen(ttname,&local,mdmtyp) < 0) {
79: erp = errmsg;
80: sprintf(erp,"Sorry, can't open %s",ttname);
81: perror(errmsg);
82: return(-2);
83: }
84: printf("Connecting thru %s, speed %d.\r\n",ttname,speed);
85: printf("The escape character is %s (%d).\r\n",chstr(escape),escape);
86: printf("Type the escape character followed by C to get back,\r\n");
87: printf("or followed by ? to see other options.\r\n");
88: if (seslog) printf("(Session logged to %s.)\r\n",sesfil);
89:
90: /* Condition console terminal and communication line */
91:
92: if (conbin(escape) < 0) {
93: printf("Sorry, can't condition console terminal\n");
94: return(-2);
95: }
96: if (ttvt(speed,flow) < 0) {
97: conres();
98: printf("Sorry, Can't condition communication line\n");
99: return(-2);
100: }
101:
102: /* cont'd... */
103:
104: /* ...connect, cont'd */
105:
106:
107: parent_id = getpid(); /* get parent id for signalling */
108: pid = fork(); /* All ok, make a fork */
109: if (pid) {
110: active = 1; /* This fork reads, sends keystrokes */
111: if (!setjmp(env_con)) { /* comm error in child process */
112: signal(SIGUSR1,conn_int); /* routine for child process exit */
113: while (active) {
114: c = coninc(0) & 0177; /* Get character from keyboard */
115: if (c == escape) { /* Look for escape char */
116: c = coninc(0) & 0177; /* Got esc, get its arg */
117: doesc(c); /* And process it */
118: } else { /* Ordinary character */
119: if (ttoc(dopar(c)) > -1) {
120: if (duplex) { /* Half duplex? */
121: conoc(c); /* Yes, also echo it. */
122: if (seslog) /* And maybe log it. */
123: if (zchout(ZSFILE,c) < 0) seslog = 0;
124: }
125: } else {
126: perror("\r\nCan't send character");
127: active = 0;
128: }
129: }
130: }
131: } /* Come here on death of child */
132: kill(pid,9); /* Done, kill inferior fork. */
133: wait(0); /* Wait till gone. */
134: conres(); /* Reset the console. */
135: printf("[Back at Local System]\n");
136: return(0);
137:
138: } else { /* Inferior reads, prints port input */
139:
140: while (1) { /* Fresh read, wait for a character */
141: if ((c = ttinc(0)) < 0) { /* Comm line hangup detected */
142: if (errno == 9999) /* this value set by ckutio.c myread */
143: printf("\r\nCommunications disconnect ");
144: else perror("\r\nCan't get character");
145: kill(parent_id,SIGUSR1); /* notify parent. */
146: pause(); /* Wait to be killed by parent. */
147: }
148: c &= 0177; /* Got a char, strip parity, etc */
149: conoc(c); /* Put it on the screen. */
150: if (seslog) zchout(ZSFILE,c); /* If logging, log it. */
151: while ((n = ttchk()) > 0) { /* Any more left in buffer? */
152: if (n > LBUFL) n = LBUFL; /* Get them all at once. */
153: if ((n = ttxin(n,lbuf)) > 0) {
154: for (i = 0; i < n; i++) lbuf[i] &= 0177; /* Strip */
155: conxo(n,lbuf); /* Output */
156: if (seslog) zsoutx(ZSFILE,lbuf,n); /* Log */
157: }
158: }
159: }
160: }
161: }
162:
163: /* H C O N N E -- Give help message for connect. */
164:
165: hconne() {
166: int c;
167: static char *hlpmsg[] = {"\
168: \r\nC to close the connection, or:",
169: "\r\n 0 (zero) to send a null",
170: "\r\n B to send a BREAK",
171: "\r\n H to hangup and close connection",
172: "\r\n S for status",
173: "\r\n ? for help",
174: "\r\n escape character twice to send the escape character.\r\n\r\n",
175: "" };
176:
177: conola(hlpmsg); /* Print the help message. */
178: conol("Command>"); /* Prompt for command. */
179: c = coninc(0);
180: conoc(c); /* Echo it. */
181: conoll("");
182: c &= 0177; /* Strip any parity. */
183: return(c); /* Return it. */
184: }
185:
186:
187: /* C H S T R -- Make a printable string out of a character */
188:
189: char *
190: chstr(c) int c; {
191: static char s[8];
192: char *cp = s;
193:
194: if (c < SP) {
195: sprintf(cp,"CTRL-%c",ctl(c));
196: } else sprintf(cp,"'%c'\n",c);
197: cp = s;
198: return(cp);
199: }
200:
201: /* D O E S C -- Process an escape character argument */
202:
203: doesc(c) char c; {
204: CHAR d;
205:
206: c &= 0177;
207: while (1) {
208: if (c == escape) { /* Send escape character */
209: d = dopar(c); ttoc(d); return;
210: } else /* Or else look it up below. */
211: if (isupper(c)) c = tolower(c);
212:
213: switch (c) {
214:
215: case 'c': /* Close connection */
216: case '\03':
217: active = 0; conol("\r\n"); return;
218:
219: case 'b': /* Send a BREAK signal */
220: case '\02':
221: ttsndb(); return;
222:
223: case 'h': /* Hangup */
224: case '\010':
225: tthang(); active = 0; conol("\r\n"); return;
226:
227: case 's': /* Status */
228: case '\023':
229: conol("\r\nConnected thru ");
230: conol(ttname);
231: if (speed >= 0) {
232: sprintf(temp,", speed %d",speed); conol(temp);
233: }
234: if (parity) {
235: conol(", ");
236: switch (parity) {
237: case 'e': conol("even"); break;
238: case 'o': conol("odd"); break;
239: case 's': conol("space"); break;
240: case 'm': conol("mark"); break;
241: }
242: conol(" parity");
243: }
244: if (seslog) {
245: conol(", logging to "); conol(sesfil);
246: }
247: conoll(""); return;
248:
249: case '?': /* Help */
250: c = hconne(); continue;
251:
252: case '0': /* Send a null */
253: c = '\0'; d = dopar(c); ttoc(d); return;
254:
255: case SP: /* Space, ignore */
256: return;
257:
258: default: /* Other */
259: conoc(BEL); return; /* Invalid esc arg, beep */
260: }
261: }
262: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.