Context Navigation

source: trunk/third/kermit/ckucon.c @ 10780

Visit:

Revision 10780, 67.0 KB checked in by brlewis, 27 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r10779, which included commits to RCS files with non-trunk default branches.

Line
1	#include "ckcsym.h"
2	#ifdef NOLOCAL
3	char *connv = "";
4	#else
5	char *connv = "CONNECT Command for UNIX, 6.0.083, 6 Sep 96";
6
7	/* C K U C O N -- Terminal connection to remote system, for UNIX */
8	/*
9	Author: Frank da Cruz <fdc@columbia.edu>,
10	Columbia University Academic Information Systems, New York City.
11
12	Copyright (C) 1985, 1996, Trustees of Columbia University in the City of New
13	York. The C-Kermit software may not be, in whole or in part, licensed or
14	sold for profit as a software product itself, nor may it be included in or
15	distributed with commercial products or otherwise distributed by commercial
16	concerns to their clients or customers without written permission of the
17	Office of Kermit Development and Distribution, Columbia University. This
18	copyright notice must not be removed, altered, or obscured.
19
20	Special thanks to Eduard Vopicka, Prague University of Economics,
21	Czech Republic, for valuable contributions to this module in July 1994,
22	and to Neal P. Murphy of the Motorola Cellular Infrastructure Group
23	for rearranging the code to allow operation on the BeBox, yet still work
24	in regular UNIX.
25	*/
26	#include "ckcdeb.h" /* Common things first */
27
28	#ifdef BEBOX
29	static double time_started = 0.0;
30	#include <kernel/OS.h>
31	_PROTOTYP( static long concld, (void *) );
32	#else
33	_PROTOTYP( static VOID concld, (void) );
34	#endif /* BEBOX */
35
36	#ifdef NEXT
37	#undef NSIG
38	#include <sys/wait.h> /* For wait() */
39	#endif /* NEXT */
40
41	#include <signal.h> /* Signals */
42	#include <errno.h> /* Error numbers */
43
44	#ifdef ZILOG /* Longjumps */
45	#include <setret.h>
46	#else
47	#include <setjmp.h>
48	#endif /* ZILOG */
49	#include "ckcsig.h"
50
51	/* Kermit-specific includes */
52
53	#include "ckcasc.h" /* ASCII characters */
54	#include "ckcker.h" /* Kermit things */
55	#include "ckucmd.h" /* For xxesc() prototype */
56	#include "ckcnet.h" /* Network symbols */
57	#ifndef NOCSETS
58	#include "ckcxla.h" /* Character set translation */
59	#endif /* NOCSETS */
60
61	/* Internal function prototypes */
62
63	_PROTOTYP( VOID ttflux, (void) );
64	_PROTOTYP( VOID doesc, (char) );
65	_PROTOTYP( static VOID logchar, (char) );
66	_PROTOTYP( int hconne, (void) );
67	_PROTOTYP( VOID shomdm, (void) );
68	_PROTOTYP( static int kbget, (void) );
69	_PROTOTYP( static int pipemsg, (int) );
70	_PROTOTYP( static VOID ck_sndmsg, (void) );
71	_PROTOTYP( static int ckcputf, (void) );
72	_PROTOTYP( static VOID ck_sndmsg, (void) );
73
74	/*
75	For inter-fork signaling. Normally we use SIGUSR1, except on SCO, where
76	we use SIGUSR2 because SIGUSR1 is used by the system. You can define
77	CK_FORK_SIG to be whatever other signal you might want to use at compile
78	time. We don't use SIGUSR2 everywhere because in some systems, like
79	UnixWare, the default action for SIGUSR2 is to kill the process that gets it.
80	*/
81	#ifndef CK_FORK_SIG
82
83	#ifndef SIGUSR1 /* User-defined signals */
84	#define SIGUSR1 30
85	#endif /* SIGUSR1 */
86
87	#ifndef SIGUSR2
88	#define SIGUSR2 31
89	#endif /* SIGUSR2 */
90
91	#ifdef M_UNIX
92	#define CK_FORK_SIG SIGUSR2 /* SCO - use SIGUSR2 */
93	#else
94	#define CK_FORK_SIG SIGUSR1 /* Others - use SIGUSR1 */
95	#endif /* M_UNIX */
96
97	#endif /* CK_FORK_SIG */
98
99	/* External variables */
100
101	extern struct ck_p ptab[];
102
103	extern int local, escape, duplex, parity, flow, seslog, sessft, debses,
104	mdmtyp, ttnproto, cmask, cmdmsk, network, nettype, deblog, sosi, tnlm,
105	xitsta, what, ttyfd, quiet, backgrd, pflag, tt_crd, tn_nlm, ttfdflg,
106	tt_escape, justone;
107
108	extern long speed;
109	extern char ttname[], sesfil[], myhost[], *ccntab[];
110	#ifdef TNCODE
111	extern int tn_b_nlm, me_binary, u_binary;
112	#endif /* TNCODE */
113
114	extern int nopush;
115
116	#ifdef CK_APC
117	extern int apcactive; /* Application Program Command (APC) */
118	extern int apcstatus; /* items ... */
119	static int apclength = 0;
120	#ifdef DCMDBUF
121	extern char *apcbuf;
122	#else
123	extern char apcbuf[];
124	#endif /* DCMDBUF */
125	static int apcbuflen = APCBUFLEN - 2;
126	extern int autodl, protocol; /* Auto download */
127	#endif /* CK_APC */
128
129	#ifdef CK_XYZ
130	#ifdef XYZ_INTERNAL
131	static int zmdlok = 1; /* Zmodem autodownloads available */
132	#else
133	static int zmdlok = 0; /* Depends on external protocol def */
134	#endif /* XYZ_INTERNAL */
135	#else
136	static int zmdlok = 0; /* Not available at all */
137	#endif /* CK_XYZ */
138
139	#ifndef NOSETKEY /* Keyboard mapping */
140	extern KEY keymap; / Single-character key map */
141	extern MACRO macrotab; / Key macro pointer table */
142	static MACRO kmptr = NULL; /* Pointer to current key macro */
143	#endif /* NOSETKEY */
144
145	/* Global variables local to this module */
146
147	static int
148	quitnow = 0, /* <esc-char>Q was typed */
149	jbset = 0, /* Flag whether jmp buf is set. */
150	dohangup = 0, /* <esc-char>H was typed */
151	sjval, /* Setjump return value */
152	goterr = 0, /* Fork/pipe creation error flag */
153	#ifndef SUNX25
154	active = 0, /* Lower fork active flag */
155	#endif /* SUNX25 */
156	inshift = 0, /* SO/SI shift states */
157	outshift = 0;
158
159	static PID_T parent_id = (PID_T)0; /* Process ID of keyboard fork */
160
161	static char ecbuf[10], ecbp; / Escape char buffer & pointer */
162
163	#ifdef pdp11
164	#define IBUFL 1536 /* Input buffer length */
165	#else
166	#define IBUFL 4096
167	#endif /* pdp11 */
168
169	static int obc = 0; /* Output buffer count */
170
171	#ifndef OXOS
172	#define OBUFL 1024 /* Output buffer length */
173	#else
174	#define OBUFL IBUFL
175	#endif /* OXOS */
176
177	#define TMPLEN 200 /* Temporary message buffer length */
178	#ifdef DYNAMIC
179	static char ibuf = NULL, obuf = NULL, temp = NULL; / Buffers */
180	#else
181	static char ibuf[IBUFL], obuf[OBUFL], temp[TMPLEN];
182	#endif /* DYNAMIC */
183
184	#ifdef DYNAMIC
185	static char ibp; / Input buffer pointer */
186	#else
187	static char ibp = ibuf; / Input buffer pointer */
188	#endif /DYNAMIC /
189	static int ibc = 0; /* Input buffer count */
190
191	#ifdef DYNAMIC
192	static char obp; / Output buffer pointer */
193	#else
194	static char obp = obuf; / Output buffer pointer */
195	#endif /* DYNAMIC */
196
197	/* SunLink X.25 items */
198
199	#ifdef SUNX25
200	static char p; / General purpose pointer */
201	char x25ibuf[MAXIX25]; /* Input buffer */
202	char x25obuf[MAXOX25]; /* Output buffer */
203	int active = 0; /* Lower fork active flag */
204	int ibufl; /* Length of input buffer */
205	int obufl; /* Length of output buffer */
206	unsigned char tosend = 0;
207	int linkid, lcn;
208	static int dox25clr = 0;
209	extern CHAR padparms[];
210	#endif /* SUNX25 */
211
212	static int xpipe[2] = {-1, -1}; /* Pipe descriptor for child-parent messages */
213	static PID_T pid; /* Process ID of child */
214
215	/* Character-set items */
216
217	#ifndef NOCSETS
218	#ifdef CK_ANSIC /* ANSI C prototypes... */
219	extern CHAR (xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); / Character set */
220	extern CHAR (xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); / translation functions */
221	static CHAR (sxo)(CHAR); / Local translation functions */
222	static CHAR (rxo)(CHAR); / for output (sending) terminal chars */
223	static CHAR (sxi)(CHAR); / and for input (receiving) terminal chars. */
224	static CHAR (*rxi)(CHAR);
225	#else /* Not ANSI C... */
226	extern CHAR (xls[MAXTCSETS+1][MAXFCSETS+1])(); / Character set */
227	extern CHAR (xlr[MAXTCSETS+1][MAXFCSETS+1])(); / translation functions. */
228	static CHAR (sxo)(); / Local translation functions */
229	static CHAR (rxo)(); / for output (sending) terminal chars */
230	static CHAR (sxi)(); / and for input (receiving) terminal chars. */
231	static CHAR (*rxi)();
232	#endif /* CK_ANSIC */
233	extern int language; /* Current language. */
234	static int langsv; /* For remembering language setting. */
235	extern struct csinfo fcsinfo[]; /* File character set info. */
236	extern int tcsr, tcsl; /* Terminal character sets, remote & local. */
237	static int tcs; /* Intermediate ("transfer") character set. */
238	#endif /* NOCSETS */
239
240	/*
241	We do not need to parse and recognize escape sequences if we are being built
242	without character-set support AND without APC support.
243	*/
244	#ifdef NOCSETS /* No character sets */
245	#ifndef CK_APC /* No APC */
246	#ifndef NOESCSEQ
247	#define NOESCSEQ /* So no escape sequence recognizer */
248	#endif /* NOESCSEQ */
249	#endif /* CK_APC */
250	#endif /* NOCSETS */
251	/*
252	Child process events / messages
253	*/
254	#define CEV_NO 0 /* No event */
255	#define CEV_HUP 1 /* Communications hangup */
256	#define CEV_PAD 2 /* X.25 - change PAD parameters */
257	#define CEV_DUP 3 /* Toggle duplex */
258	#define CEV_APC 4 /* Execute APC */
259	#ifdef TNCODE
260	#define CEV_MEBIN 5 /* Change of me_binary */
261	#define CEV_UBIN 6 /* Change of u_binary */
262	#endif /* TNCODE */
263	#define CEV_ADL 7 /* Autodownload */
264	#define CEV_AUL 8 /* Autoupload */
265
266	#ifdef NOESCSEQ
267	#define chkaes(x) 0
268	#else
269	/*
270	As of edit 178, the CONNECT command will skip past ANSI escape sequences
271	to avoid translating the characters within them. This allows the CONNECT
272	command to work correctly when connected to a remote host that uses a
273	7-bit ISO 646 national character set, in which characters like '[' would
274	normally be translated into accented characters, ruining the terminal's
275	interpretation (and generation) of escape sequences.
276
277	As of edit 190, the CONNECT command responds to APC escape sequences
278	(ESC _ text ESC \) if the user SETs TERMINAL APC ON or UNCHECKED, and the
279	program was built with CK_APC defined.
280
281	Non-ANSI/ISO-compliant escape sequences are not handled.
282	*/
283
284	/*
285	States for the escape-sequence recognizer.
286	*/
287	#define ES_NORMAL 0 /* Normal, not in an escape sequence */
288	#define ES_GOTESC 1 /* Current character is ESC */
289	#define ES_ESCSEQ 2 /* Inside an escape sequence */
290	#define ES_GOTCSI 3 /* Inside a control sequence */
291	#define ES_STRING 4 /* Inside DCS,OSC,PM, or APC string */
292	#define ES_TERMIN 5 /* 1st char of string terminator */
293
294	static int
295	escseq = 0, /* 1 = Recognizer is active */
296	inesc = ES_NORMAL, /* State of sequence recognizer */
297	oldesc = -1; /* Previous state of recognizer */
298	/*
299	ANSI escape sequence handling. Only the 7-bit form is treated, because
300	translation is not a problem in the 8-bit environment, in which all GL
301	characters are ASCII and no translation takes place. So we don't check
302	for the 8-bit single-character versions of CSI, DCS, OSC, APC, or ST.
303	Here is the ANSI sequence recognizer state table, followed by the code
304	that implements it.
305
306	Definitions:
307	CAN = Cancel 01/08 Ctrl-X
308	SUB = Substitute 01/10 Ctrl-Z
309	DCS = Device Control Sequence 01/11 05/00 ESC P
310	CSI = Control Sequence Introducer 01/11 05/11 ESC [
311	ST = String Terminator 01/11 05/12 ESC \
312	OSC = Operating System Command 01/11 05/13 ESC ]
313	PM = Privacy Message 01/11 05/14 ESC ^
314	APC = Application Program Command 01/11 05/15 ESC _
315
316	ANSI escape sequence recognizer:
317
318	State Input New State ; Commentary
319
320	NORMAL (start) ; Start in NORMAL state
321
322	(any) CAN NORMAL ; ^X cancels
323	(any) SUB NORMAL ; ^Z cancels
324
325	NORMAL ESC GOTESC ; Begin escape sequence
326	NORMAL other ; NORMAL control or graphic character
327
328	GOTESC ESC ; Start again
329	GOTESC [ GOTCSI ; CSI
330	GOTESC P STRING ; DCS introducer, consume through ST
331	GOTESC ] STRING ; OSC introducer, consume through ST
332	GOTESC ^ STRING ; PM introducer, consume through ST
333	GOTESC _ STRING ; APC introducer, consume through ST
334	GOTESC 0..~ NORMAL ; 03/00 through 17/14 = Final character
335	GOTESC other ESCSEQ ; Intermediate or ignored control character
336
337	ESCSEQ ESC GOTESC ; Start again
338	ESCSEQ 0..~ NORMAL ; 03/00 through 17/14 = Final character
339	ESCSEQ other ; Intermediate or ignored control character
340
341	GOTCSI ESC GOTESC ; Start again
342	GOTCSI @..~ NORMAL ; 04/00 through 17/14 = Final character
343	GOTCSI other ; Intermediate char or ignored control char
344
345	STRING ESC TERMIN ; Maybe have ST
346	STRING other ; Consume all else
347
348	TERMIN \ NORMAL ; End of string
349	TERMIN other STRING ; Still in string
350	*/
351	/*
352	chkaes() -- Check ANSI Escape Sequence.
353	Call with EACH character in input stream.
354	Sets global inesc variable according to escape sequence state.
355	Returns 0 normally, 1 if an APC sequence is to be executed.
356	*/
357	int
358	#ifdef CK_ANSIC
359	chkaes(char c)
360	#else
361	chkaes(c) char c;
362	#endif /* CK_ANSIC */
363	/* chkaes */ {
364
365	oldesc = inesc; /* Remember previous state */
366	if (c == CAN \|\| c == SUB) /* CAN and SUB cancel any sequence */
367	inesc = ES_NORMAL;
368	else /* Otherwise */
369	switch (inesc) { /* enter state switcher */
370
371	case ES_NORMAL: /* NORMAL state */
372	if (c == ESC) /* Got an ESC */
373	inesc = ES_GOTESC; /* Change state to GOTESC */
374	break; /* Otherwise stay in NORMAL state */
375
376	case ES_GOTESC: /* GOTESC state */
377	if (c == '[') /* Left bracket after ESC is CSI */
378	inesc = ES_GOTCSI; /* Change to GOTCSI state */
379	else if (c == 'P' \|\| (c > 0134 && c < 0140)) { /* P, [, ^, or _ */
380	inesc = ES_STRING; /* Switch to STRING-absorption state */
381	#ifdef CK_APC
382	if (c == '_' && pid == 0 && /* APC handled in child only */
383	apcstatus != APC_OFF) { /* and only if not disabled. */
384	debug(F100,"APC begin","",0);
385	apcactive = 1; /* Set APC-Active flag */
386	apclength = 0; /* and reset APC buffer pointer */
387	}
388	#endif /* CK_APC */
389	} else if (c > 057 && c < 0177) /* Final character '0' thru '~' */
390	inesc = ES_NORMAL; /* Back to normal */
391	else if (c != ESC) /* ESC in an escape sequence... */
392	inesc = ES_ESCSEQ; /* starts a new escape sequence */
393	break; /* Intermediate or ignored ctrl char */
394
395	case ES_ESCSEQ: /* ESCSEQ -- in an escape sequence */
396	if (c > 057 && c < 0177) /* Final character '0' thru '~' */
397	inesc = ES_NORMAL; /* Return to NORMAL state. */
398	else if (c == ESC) /* ESC ... */
399	inesc = ES_GOTESC; /* starts a new escape sequence */
400	break; /* Intermediate or ignored ctrl char */
401
402	case ES_GOTCSI: /* GOTCSI -- In a control sequence */
403	if (c > 077 && c < 0177) /* Final character '@' thru '~' */
404	inesc = ES_NORMAL; /* Return to NORMAL. */
405	else if (c == ESC) /* ESC ... */
406	inesc = ES_GOTESC; /* starts over. */
407	break; /* Intermediate or ignored ctrl char */
408
409	case ES_STRING: /* Inside a string */
410	if (c == ESC) /* ESC may be 1st char of terminator */
411	inesc = ES_TERMIN; /* Go see. */
412	#ifdef CK_APC
413	else if (apcactive && (apclength < apcbuflen)) /* If in APC, */
414	apcbuf[apclength++] = c; /* deposit this character. */
415	else { /* Buffer overrun */
416	apcactive = 0; /* Discard what we got */
417	apclength = 0; /* and go back to normal */
418	apcbuf[0] = 0; /* Not pretty, but what else */
419	inesc = ES_NORMAL; /* can we do? (ST might not come) */
420	}
421	#endif /* CK_APC */
422	break; /* Absorb all other characters. */
423
424	case ES_TERMIN: /* May have a string terminator */
425	if (c == '\\') { /* which must be backslash */
426	inesc = ES_NORMAL; /* If so, back to NORMAL */
427	#ifdef CK_APC
428	if (apcactive) { /* If it was an APC string, */
429	debug(F101,"APC terminated","",c);
430	apcbuf[apclength] = NUL; /* terminate it and then ... */
431	return(1);
432	}
433	#endif /* CK_APC */
434	} else { /* Otherwise */
435	inesc = ES_STRING; /* Back to string absorption. */
436	#ifdef CK_APC
437	if (apcactive && (apclength+1 < apcbuflen)) { /* In APC string */
438	apcbuf[apclength++] = ESC; /* deposit the Esc character */
439	apcbuf[apclength++] = c; /* and this character too */
440	}
441	#endif /* CK_APC */
442	}
443	}
444	return(0);
445	}
446	#endif /* NOESCSEQ */
447
448	/* Connect state parent/child communication signal handlers */
449
450	/* Routines used by the child process */
451
452	static int
453	pipemsg(n) int n; { /* Send message ID to parent */
454	int code = n & 255;
455	return(write(xpipe[1], &code, sizeof(code)));
456	}
457
458	/* Environment pointer for CK_FORK_SIG signal handling in child... */
459
460	#ifdef CK_POSIX_SIG
461	static sigjmp_buf sig_env;
462	#else
463	static jmp_buf sig_env;
464	#endif /* CK_POSIX_SIG */
465
466	static SIGTYP /* CK_FORK_SIG handling in child ... */
467	forkint(foo) int foo; {
468	/* It is important to disable CK_FORK_SIG before longjmp */
469	signal(CK_FORK_SIG, SIG_IGN); /* Set to ignore CK_FORK_SIG */
470	debug(F100, "forkint - CK_FORK_SIG", "", 0);
471	/* Force return from ck_sndmsg() */
472	cklongjmp(sig_env, 1);
473	/* NOTREACHED */
474	}
475
476	static VOID
477	ck_sndmsg() { /* Executed by child only ... */
478	debug(F100, "ck_sndmsg - notifying parent", "", 0);
479	if (
480	#ifdef CK_POSIX_SIG
481	sigsetjmp(sig_env,1)
482	#else
483	setjmp(sig_env)
484	#endif /* CK_POSIX_SIG */
485	== 0) {
486	signal(CK_FORK_SIG, forkint); /* Set up signal handler */
487	kill(parent_id, CK_FORK_SIG); /* Kick the parent */
488	for (;;) pause(); /* Wait for CK_FORK_SIG or SIGKILL */
489	/* NOTREACHED */
490	}
491	/* We come here from forkint() via [sig]cklongjmp(sig_env,1) */
492	debug(F100, "ck_sndmsg - returning", "", 0);
493	}
494
495	/* Routines used by the parent process */
496
497	#ifdef CK_POSIX_SIG /* Environment pointer for CONNECT errors */
498	static sigjmp_buf con_env;
499	#else
500	static jmp_buf con_env;
501	#endif /* CK_POSIX_SIG */
502	/*
503	pipeint() handles CK_FORK_SIG signals from the lower (port) fork.
504	It reads a function code from the pipe that connects the two forks,
505	then reads additional data from the pipe, then handles it.
506	*/
507	static SIGTYP
508	pipeint(arg) int arg; { /* Dummy argument */
509	int code;
510	#ifndef NOCCTRAP
511	extern ckjmpbuf cmjbuf;
512	#endif /* NOCCTRAP */
513	/*
514	IMPORTANT: At this point, the child fork is waiting for CK_FORK_SIG
515	(eventually for SIGKILL) inside of ck_sndmsg(). So we can't get any
516	subsequent CK_FORK_SIG from child before we send it CK_FORK_SIG.
517	*/
518	signal(CK_FORK_SIG, SIG_IGN); /* Ignore CK_FORK_SIG now */
519	debug(F101,"pipeint arg","",arg);
520
521	read(xpipe[0], &code, sizeof(code)); /* Get function code from pipe */
522	debug(F101,"pipeint code","",code);
523
524	#ifndef NOCCTRAP
525	#ifndef NOICP
526	#define USECCJMPBUF
527	#endif /* NOICP */
528	#endif /* NOCCTRAP */
529	/*
530	The CEV_HUP case is executed when the other side has hung up on us.
531	In some cases, this happens before we have had a chance to execute the
532	setjmp(con_env,1) call, and in that case we'd better not take the longjmp!
533	A good example is when you TELNET to port 13 on the local host; it prints
534	its asctime() string (26 chars) and then closes the connection.
535	*/
536	switch (code & 255) {
537	case CEV_HUP:
538	sjval = CEV_HUP; /* Set global variable. */
539	if (jbset) { /* jmp_buf is initialized */
540	cklongjmp(con_env,sjval); /* so do the right thing. */
541	} else {
542	#ifdef USECCJMPBUF
543	/* jmp_buf not init'd yet a close approximation... */
544	ttclos(0); /* Close our end of the connection */
545	#ifdef BEBOX
546	{
547	long ret_val;
548	if (pid) kill(pid,SIGKILLTHR); /* Kill lower fork */
549	wait_for_thread (pid, &ret_val);
550	}
551	#else
552	#ifdef Plan9
553	if (pid) kill(pid, SIGKILL); /* (should always use this really) */
554	#else
555	if (pid) kill(pid,9); /* Kill lower fork (history) */
556	#endif /* Plan9 */
557	#endif /* BEBOX */
558	conres(); /* Reset the console. */
559	if (!quiet) {
560	printf("\r\n(Back at %s)\r\n",
561	*myhost ? myhost :
562	#ifdef UNIX
563	"local UNIX system"
564	#else
565	"local system"
566	#endif /* UNIX */
567	);
568	}
569	what = W_NOTHING; /* So console modes are set right. */
570	printf("\r\n"); /* prevent prompt-stomping */
571	cklongjmp(cmjbuf,0); /* Do what the Ctrl-C handler does */
572	#else
573	printf("\r\nLongjump failure - fatal\r\n");
574	doexit(1); /* Better than dumping core... */
575	#endif /* USECCJMPBUF */
576	}
577	#ifdef USECCJMPBUF
578	#undef USECCJMPBUF
579	#endif /* USECCJMPBUF */
580
581	case CEV_DUP: /* Child sends duplex change */
582	read(xpipe[0], (char *)&duplex, sizeof(duplex));
583	debug(F101,"pipeint duplex","",duplex);
584	break;
585	#ifdef TNCODE
586	case CEV_MEBIN: /* Child sends me_binary change */
587	read(xpipe[0], (char *)&me_binary, sizeof(me_binary));
588	debug(F101,"pipeint me_binary","",me_binary);
589	break;
590	case CEV_UBIN: /* Child sends u_binary change */
591	read(xpipe[0], (char *)&u_binary, sizeof(u_binary));
592	debug(F101,"pipeint u_binary","",u_binary);
593	break;
594	#endif /* TNCODE */
595
596	#ifdef CK_APC
597	case CEV_AUL: /* Autoupload */
598	justone = 1;
599	debug(F100,"autoupload at parent","",0);
600	case CEV_ADL: /* Autodownload */
601	apcstatus = APC_LOCAL;
602	if (!justone) debug(F100,"autodownload at parent","",0);
603	case CEV_APC: /* Application Program Command */
604	read(xpipe[0], (char *)&apclength, sizeof(apclength));
605	read(xpipe[0], apcbuf, apclength+1); /* Include trailing zero byte */
606	debug(F111,"APC at parent",apcbuf,apclength);
607	read(xpipe[0], (char )&ibc, sizeof(ibc)); / Copy child's */
608	if (ibc > 0) { /* input buffer. */
609	read(xpipe[0], (char *)&ibp, sizeof(ibp));
610	read(xpipe[0], ibp, ibc);
611	}
612	obc = 0; obp = obuf; obuf = NUL; / Because port fork flushed */
613	sjval = CEV_APC;
614	cklongjmp(con_env,sjval);
615	/* NOTREACHED */
616	#endif /* CK_APC */
617
618	#ifdef SUNX25
619	case CEV_PAD: /* X.25 PAD parameter change */
620	debug(F100,"pipeint PAD change","",0);
621	read(xpipe[0],padparms,MAXPADPARMS);
622	sjval = CEV_PAD; /* Set global variable. */
623	#ifdef COMMENT /* We might not need to do this... */
624	cklongjmp(con_env,sjval);
625	/* NOTREACHED */
626	#else /* COMMENT */
627	break;
628	#endif /* COMMENT */
629	#endif /* SUNX25 */
630	}
631	signal(CK_FORK_SIG, pipeint); /* Set up signal handler */
632	kill(pid, CK_FORK_SIG); /* Signal the port fork ... */
633	}
634
635	/* C K C P U T C -- C-Kermit CONNECT Put Character to Screen */
636	/*
637	Output is buffered to avoid slow screen writes on fast connections.
638	NOTE: These could (easily?) become macros ...
639	*/
640	static int
641	ckcputf() { /* Dump the output buffer */
642	int x = 0;
643	if (obc > 0) /* If we have any characters, */
644	x = conxo(obc,obuf); /* dump them, */
645	obp = obuf; /* reset the pointer */
646	obc = 0; /* and the counter. */
647	return(x); /* Return conxo's return code */
648	}
649
650	int
651	ckcputc(c) int c; {
652	int x;
653
654	obp++ = c & 0xff; / Deposit the character */
655	obc++; /* Count it */
656	if (ibc == 0 \|\| /* If input buffer about empty */
657	obc == OBUFL) { /* or output buffer full */
658	debug(F101,"CKCPUTC obc","",obc);
659	x = conxo(obc,obuf); /* dump the buffer, */
660	obp = obuf; /* reset the pointer */
661	obc = 0; /* and the counter. */
662	return(x); /* Return conxo's return code */
663	} else return(0);
664	}
665
666	/* C K C G E T C -- C-Kermit CONNECT Get Character */
667	/*
668	Buffered read from communication device.
669	Returns the next character, refilling the buffer if necessary.
670	On error, returns ttinc's return code (see ttinc() description).
671	Dummy argument for compatible calling conventions with ttinc().
672	NOTE: We don't have a macro for this because we have to pass
673	a pointer to this function as an argument to tn_doop().
674	*/
675	int
676	ckcgetc(dummy) int dummy; {
677	int c, n;
678
679	debug(F101,"CKCGETC 1 ibc","",ibc); /* Log */
680	if (ibc < 1) { /* Need to refill buffer? */
681	ibc = 0; /* Yes, reset count */
682	ibp = ibuf; /* and buffer pointer */
683	debug(F100,"CKCGETC 1 calling ttinc(0)","",0); /* Log */
684	c = ttinc(0); /* Read one character, blocking */
685	debug(F101,"CKCGETC 1 ttinc(0)","",c); /* Log */
686	if (c < 0) { /* If error, return error code */
687	return(c);
688	} else { /* Otherwise, got one character */
689	ibp++ = c; / Advance buffer pointer */
690	ibc++; /* and count. */
691	}
692
693	/* Now quickly read any more that might have arrived */
694
695	if ((n = ttchk()) > 0) { /* Any more waiting? */
696	if (n > (IBUFL - ibc)) /* Get them all at once. */
697	n = IBUFL - ibc; /* Don't overflow buffer */
698	if ((n = ttxin(n,(CHAR *)ibp)) > 0)
699	ibc += n; /* Advance counter */
700	}
701	debug(F101,"CKCGETC 2 ibc","",ibc); /* Log how many */
702	ibp = ibuf;
703	}
704	c = ibp++ & 0xff; / Get next character from buffer */
705	ibc--; /* Reduce buffer count */
706	return(c); /* Return the character */
707	}
708
709	/*
710	Keyboard handling, buffered for speed, which is needed when C-Kermit is
711	in CONNECT mode between two other computers that are transferring data.
712	*/
713	static char kbp; / Keyboard input buffer pointer */
714	static int kbc; /* Keyboard input buffer count */
715
716	#ifdef pdp11 /* Keyboard input buffer length */
717	#define KBUFL 32 /* Small for PDP-11 UNIX */
718	#else
719	#define KBUFL 257 /* Regular kernel size for others */
720	#endif /* pdp11 */
721
722	#ifdef DYNAMIC
723	static char *kbuf = NULL;
724	#else
725	static char kbuf[KBUFL];
726	#endif /* DYNAMIC */
727
728	/* Macro for reading keystrokes. */
729
730	#define CONGKS() (((--kbc)>=0) ? ((int)(*kbp++) & 0377) : kbget())
731
732	/*
733	Note that we call read() directly here, normally a no-no, but in this case
734	we know it's UNIX and we're only doing what coninc(0) would have done,
735	except we're reading a block of characters rather than just one. There is,
736	at present, no conxin() analog to ttxin() for chunk reads, and instituting
737	one would only add function-call overhead as it would only be a wrapper for
738	a read() call anyway.
739	*/
740	/*
741	Another note: We stick in this read() till the user types something.
742	But the other (lower) fork is running too, and on TELNET connections,
743	it will signal us to indicate echo-change negotiations, and this can
744	interrupt the read(). Some UNIXes automatically restart the interrupted
745	system call, others return from it with errno == EINTR.
746	*/
747	static int /* Keyboard buffer filler */
748	kbget() {
749	#ifdef EINTR
750	int tries = 10; /* If read() is interrupted, */
751	int ok = 0;
752	while (tries-- > 0) { /* try a few times... */
753	#endif /* EINTR */
754	if ((kbc = conchk()) < 1) /* How many chars waiting? */
755	kbc = 1; /* If none or dunno, wait for one. */
756	else if (kbc > KBUFL) /* If too many, */
757	kbc = KBUFL; /* only read this many. */
758	if ((kbc = read(0, kbuf, kbc)) < 1) { /* Now read it/them. */
759	debug(F101,"kbget errno","",errno); /* Got an error. */
760	#ifdef EINTR
761	if (errno == EINTR) /* Interrupted system call. */
762	continue; /* Try again, up to limit. */
763	else /* Something else. */
764	#endif /* EINTR */
765	return(-1); /* Pass along read() error. */
766	}
767	#ifdef EINTR
768	else { ok = 1; break; }
769	}
770	if (!ok) return(-1);
771	#endif /* EINTR */
772	kbp = kbuf; /* Adjust buffer pointer, */
773	kbc--; /* count, */
774	return((int)(kbp++) & 0377); / and return first character. */
775	}
776
777	/* C O N C L D -- Interactive terminal connection child function */
778
779	static
780	#ifdef BEBOX
781	long
782	#else
783	VOID
784	#endif /* BEBOX */
785	concld (
786	#ifdef BEBOX
787	void *bevoid
788	#endif /* BEBOX */
789	) {
790	int n; /* General purpose counter */
791
792	int c; /* c is a character, but must be signed
793	integer to pass thru -1, which is the
794	modem disconnection signal, and is
795	different from the character 0377 */
796	int c2; /* A copy of c */
797	int csave; /* Another copy of c */
798	int tx; /* tn_doop() return code */
799	#ifdef SUNX25
800	int i; /* Worker for X.25 code */
801	#endif /* SUNX25 */
802	#ifdef NETCONN
803
804	#endif /* NETCONN */
805	#ifndef NOESCSEQ
806	int apcrc;
807	#endif /* NOESCSEQ */
808
809
810	int conret = 0; /* Return value from conect() */
811	/* jbchksum = -1L; */
812	jbset = 0; /* jmp_buf not set yet, don't use it */
813	debug(F101,"CONCLD entry","",CK_FORK_SIG);
814	/* *** / / Inferior reads, prints port input */
815
816	if (priv_can()) { /* Cancel all privs */
817	printf("?setuid error - fatal\n");
818	doexit(BAD_EXIT,-1);
819	}
820	signal(SIGINT, SIG_IGN); /* In case these haven't been */
821	signal(SIGQUIT, SIG_IGN); /* inherited from above... */
822	signal(CK_FORK_SIG, SIG_IGN); /* CK_FORK_SIG not expected yet */
823
824	inshift = outshift = 0; /* Initial SO/SI shift state. */
825	{ /* Wait for parent's setup */
826	int i;
827	while ((i = read(xpipe[0], &c, 1)) <= 0) {
828	if (i < 0) {
829	pipemsg(CEV_HUP); /* Read error - hangup */
830	ck_sndmsg(); /* Send and wait to be killed */
831	/* NOTREACHED */
832	} /* Restart interrupted read() */
833	}
834	}
835	close(xpipe[0]); xpipe[0] = -1; /* Child - prevent future reads */
836	#ifdef DEBUG
837	if (deblog) {
838	debug(F100,"CONNECT starting port fork","",0);
839	debug(F101,"CONNECT port fork ibc","",ibc);
840	debug(F101,"CONNECT port fork obc","",obc);
841	}
842	#endif /* DEBUG */
843	what = W_CONNECT;
844
845	while (1) { /* Fresh read, wait for a character. */
846	#ifdef SUNX25
847	if (network && (nettype == NET_SX25)) {
848	bzero(x25ibuf,sizeof(x25ibuf)) ;
849	if ((ibufl = ttxin(MAXIX25,(CHAR *)x25ibuf)) < 0) {
850	if (ibufl == -2) { /* PAD parms changes */
851	pipemsg(CEV_PAD);
852	write(xpipe[1],padparms,MAXPADPARMS);
853	ck_sndmsg();
854	} else {
855	if (!quiet)
856	printf("\r\nCommunications disconnect ");
857	pipemsg(CEV_HUP);
858	ck_sndmsg(); /* Wait to be killed */
859	/* NOTREACHED */
860	}
861	/* pause(); <--- SHOULD BE OBSOLETE NOW! */
862	/* BECAUSE pause() is done inside of ck_sndmsg() */
863	}
864	if (debses) { /* Debugging output */
865	p = x25ibuf ;
866	while (ibufl--) { c = *p++; conol(dbchr(c)); }
867	} else {
868	if (sosi
869	#ifndef NOCSETS
870	\|\| tcsl != tcsr
871	#endif /* NOCSETS */
872	) { /* Character at a time */
873	for (i = 1; i < ibufl; i++) {
874	c = x25ibuf[i] & cmask;
875	if (sosi) { /* Handle SI/SO */
876	if (c == SO) {
877	inshift = 1;
878	continue;
879	} else if (c == SI) {
880	inshift = 0;
881	continue;
882	}
883	if (inshift)
884	c \|= 0200;
885	}
886	#ifndef NOCSETS
887	#ifdef NOESCSEQ
888	/* Translate character sets */
889	/* From local to intermediate. */
890	if (sxo) c = (*sxo)(c);
891	/* From intermediate to remote. */
892	if (rxo) c = (*rxo)(c);
893	#else
894	/* If not inside escape sequence... */
895	if (inesc == ES_NORMAL) {
896	/* Translate character sets */
897	if (sxo) c = (*sxo)(c);
898	if (rxo) c = (*rxo)(c);
899	}
900	if (escseq) apcrc = chkaes(c);
901	#endif /* NOESCSEQ */
902	#endif /* NOCSETS */
903	c &= cmdmsk; /* Apply command mask. */
904	conoc(c); /* Output to screen */
905	logchar(c); /* and session log */
906	}
907	} else { /* All at once */
908	for (i = 1; i < ibufl; i++)
909	x25ibuf[i] &= (cmask & cmdmsk);
910	conxo(ibufl,x25ibuf);
911	if (seslog) zsoutx(ZSFILE,x25ibuf,ibufl);
912	}
913	}
914	continue;
915
916	} else { /* Not X.25... */
917	#endif /* SUNX25 */
918	/*
919	Get the next communication line character from our internal buffer.
920	If the buffer is empty, refill it.
921	*/
922	c = ckcgetc(0); /* Get next character */
923	/* debug(F101,"CONNECT c","",c); */
924	if (c < 0) { /* Failed... */
925	debug(F101,"CONNECT disconnect ibc","",ibc);
926	debug(F101,"CONNECT disconnect obc","",obc);
927	ckcputf(); /* Flush CONNECT output buffer */
928	if (!quiet) {
929	printf("\r\nCommunications disconnect ");
930	if ( c == -3
931	#ifdef ultrix
932	/* This happens on Ultrix if there's no carrier */
933	&& errno != EIO
934	#endif /* ultrix */
935	#ifdef UTEK
936	/* This happens on UTEK if there's no carrier */
937	&& errno != EWOULDBLOCK
938	#endif /* UTEK */
939	)
940	perror("\r\nCan't read character");
941	}
942	#ifdef NOSETBUF
943	fflush(stdout);
944	#endif /* NOSETBUF */
945	tthang(); /* Hang up the connection */
946	pipemsg(CEV_HUP);
947	ck_sndmsg(); /* Wait to be killed */
948	}
949	debug(F101,"** PORT","",c); /* Got character c OK. */
950	#ifdef TNCODE
951	/* Handle TELNET negotiations... */
952
953	if (c == IAC && network && ttnproto == NP_TELNET) {
954	int me_bin = me_binary;
955	int u_bin = u_binary;
956	debug(F100,"CONNECT got IAC","",0);
957	ckcputf(); /* Dump screen-output buffer */
958	if ((tx = tn_doop((CHAR)(c & 0xff),duplex,ckcgetc)) == 0) {
959	if (me_bin != me_binary) {
960	debug(F101,"CONNECT TELNET me_bin","",me_binary);
961	pipemsg(CEV_MEBIN); /* Tell parent */
962	write(xpipe[1], &me_binary, sizeof(me_binary));
963	ck_sndmsg(); /* Tell the parent fork */
964	} else if (u_bin != u_binary) {
965	debug(F101,"CONNECT TELNET u_bin","",u_binary);
966	pipemsg(CEV_UBIN); /* Tell parent */
967	write(xpipe[1], &u_binary, sizeof(u_binary));
968	ck_sndmsg(); /* Tell the parent fork */
969	}
970	continue;
971	} else if (tx == -1) { /* I/O error */
972	if (!quiet)
973	printf("\r\nCommunications disconnect ");
974	#ifdef NOSETBUF
975	fflush(stdout);
976	#endif /* NOSETBUF */
977	pipemsg(CEV_HUP);
978	ck_sndmsg(); /* Wait to be killed */
979	/* NOTREACHED */
980	} else if ((tx == 1) && (!duplex)) { /* ECHO change */
981	duplex = 1; /* Turn on local echo */
982	debug(F101,"CONNECT TELNET duplex change","",duplex);
983	pipemsg(CEV_DUP); /* Tell parent */
984	write(xpipe[1], &duplex, sizeof(duplex));
985	ck_sndmsg(); /* Tell the parent fork */
986	continue;
987	} else if ((tx == 2) && (duplex)) { /* ECHO change */
988	duplex = 0;
989	debug(F101,"CONNECT TELNET duplex change","",duplex);
990	pipemsg(CEV_DUP);
991	write(xpipe[1], &duplex, sizeof(duplex));
992	ck_sndmsg();
993	continue;
994	} else if (tx == 3) { /* Quoted IAC */
995	c = parity ? 127 : 255;
996	} else continue; /* Negotiation OK, get next char. */
997	} else if (parity)
998	c &= 0x7f;
999
1000	#endif /* TNCODE */
1001	if (debses) { /* Output character to screen */
1002	char s; / Debugging display... */
1003	s = dbchr(c);
1004	while (*s)
1005	ckcputc(*s++);
1006	} else { /* Regular display ... */
1007	c &= cmask; /* Apply Kermit-to-remote mask */
1008	#ifdef CK_APC
1009	/*
1010	Autodownload. Check for Kermit S packet prior to translation, since that
1011	can change the packet and make it unrecognizable (as when the terminal
1012	character set is an ISO 646 one)... Ditto for Zmodem start packet.
1013	*/
1014	if (autodl) { /* Autodownload enabled? */
1015	int k;
1016	k = kstart((CHAR)c); /* Kermit S or I packet? */
1017	#ifdef CK_XYZ
1018	if (!k && zmdlok) /* Or an "sz" start? */
1019	k = zstart((CHAR)c);
1020	#endif /* CK_XYZ */
1021	if (k) {
1022	extern CHAR mystch, seol;
1023	CHAR buf[6];
1024	int ksign = 0;
1025	if (k < 0) { /* Minus-Protocol? */
1026	#ifdef NOSERVER
1027	goto noserver; /* Need server mode for this */
1028	#else
1029	ksign = 1; /* Remember */
1030	k = 0 - k; /* Convert to actual protocol */
1031	justone = 1; /* Flag for protocol module */
1032	#endif /* NOSERVER */
1033	} else
1034	justone = 0;
1035	k--; /* Adjust [kz]start's return value */
1036	if (k == PROTO_K
1037	#ifdef CK_XYZ
1038	\|\| k == PROTO_Z
1039	#endif /* CK_XYZ */
1040	) {
1041	/* Temporarily switch protocol */
1042	sprintf(apcbuf,
1043	"set proto %s, %s, set proto %s",
1044	ptab[k].p_name,
1045	ksign ? "server" : "receive",
1046	ptab[protocol].p_name
1047	);
1048	apclength = strlen(apcbuf);
1049	debug(F110,"autodownload",apcbuf,0);
1050	apcactive = APC_LOCAL;
1051	if (k == PROTO_K) { /* Kermit */
1052	/* Send a NAK to make them resend S pkt */
1053	sprintf((char *)buf,
1054	"%c%s%c",
1055	mystch,
1056	"# N3",
1057	seol
1058	);
1059	ttol(buf,6);
1060	}
1061	ckcputf(); /* Force screen update */
1062	/* Notify parent */
1063	pipemsg(justone ? CEV_AUL : CEV_ADL);
1064	/* Write buffer including trailing NUL byte */
1065	write(xpipe[1],
1066	(char *)&apclength,
1067	sizeof(apclength)
1068	);
1069	write(xpipe[1], apcbuf, apclength+1);
1070
1071	/* Copy our input buffer to the parent fork */
1072
1073	debug(F101,"autodownload complete ibc","",ibc);
1074	debug(F101,"autodownload complete obc","",obc);
1075	write(xpipe[1], (char *)&ibc, sizeof(ibc));
1076	if (ibc > 0) {
1077	write(xpipe[1], (char *)&ibp, sizeof(ibp));
1078	write(xpipe[1], ibp, ibc);
1079	}
1080	debug(F101,"autodownload justone","",justone);
1081	ck_sndmsg(); /* Wait to be killed */
1082	/* NOTREACHED */
1083	}
1084	}
1085	}
1086	#ifdef NOSERVER
1087	noserver:
1088	#endif /* NOSERVER */
1089	#endif /* CK_APC */
1090	if (sosi) { /* Handle SI/SO */
1091	if (c == SO) { /* Shift Out */
1092	inshift = 1;
1093	continue;
1094	} else if (c == SI) { /* Shift In */
1095	inshift = 0;
1096	continue;
1097	}
1098	if (inshift) c \|= 0200;
1099	}
1100	#ifndef NOCSETS
1101	if (
1102	#ifndef NOESCSEQ
1103	inesc == ES_NORMAL /* If not in an escape sequence */
1104	#else
1105	1
1106	#endif /* NOESCSEQ */
1107	) { /* Translate character sets */
1108	if (sxi) c = (*sxi)((CHAR)c);
1109	if (rxi) c = (*rxi)((CHAR)c);
1110	}
1111	#endif /* NOCSETS */
1112
1113	#ifndef NOESCSEQ
1114	if (escseq) /* If handling escape sequences */
1115	apcrc = chkaes((char)c); /* update our state */
1116	#ifdef CK_APC
1117	/*
1118	If we are handling APCs, we have several possibilities at this point:
1119	1. Ordinary character to be written to the screen.
1120	2. An Esc; we can't write it because it might be the beginning of an APC.
1121	3. The character following an Esc, in which case we write Esc, then char,
1122	but only if we have not just entered an APC sequence.
1123	*/
1124	if (escseq && apcstatus != APC_OFF) {
1125	if (inesc == ES_GOTESC) /* Don't write ESC yet */
1126	continue;
1127	else if (oldesc == ES_GOTESC && !apcactive) {
1128	ckcputc(ESC); /* Write saved ESC */
1129	if (seslog) logchar((char)ESC);
1130	} else if (apcrc) { /* We have an APC */
1131	debug(F111,"APC complete",apcbuf,apclength);
1132	ckcputf(); /* Force screen update */
1133	pipemsg(CEV_APC); /* Notify parent */
1134	write(xpipe[1],
1135	(char *)&apclength,
1136	sizeof(apclength)
1137	);
1138	/* Write buffer including trailing NUL byte */
1139
1140	write(xpipe[1], apcbuf, apclength+1);
1141
1142	/* Copy our input buffer to the parent fork */
1143
1144	debug(F101,"APC complete ibc","",ibc);
1145	debug(F101,"APC complete obc","",obc);
1146	write(xpipe[1], (char *)&ibc, sizeof(ibc));
1147	if (ibc > 0) {
1148	write(xpipe[1], (char *)&ibp, sizeof(ibp));
1149	write(xpipe[1], ibp, ibc);
1150	}
1151	ck_sndmsg(); /* Wait to be killed */
1152	/* NOTREACHED */
1153	}
1154	}
1155	#endif /* CK_APC */
1156	#endif /* NOESCSEQ */
1157
1158	if (
1159	#ifdef CK_APC
1160	!apcactive /* Ignore APC sequences */
1161	#else
1162	1
1163	#endif /* CK_APC */
1164	) {
1165	c &= cmdmsk; /* Apply command mask. */
1166	if (c == CR && tt_crd) { /* SET TERM CR-DISPLA CRLF? */
1167	ckcputc(c); /* Yes, output CR */
1168	if (seslog) logchar((char)c);
1169	c = LF; /* and insert a linefeed */
1170	}
1171	ckcputc(c); /* Write character to screen */
1172	}
1173	if (seslog) logchar((char)c); /* Handle session log */
1174	}
1175	#ifdef SUNX25
1176	}
1177	#endif /* SUNX25 */
1178	}
1179	}
1180
1181
1182	/* C O N E C T -- Interactive terminal connection */
1183
1184	int
1185	conect() {
1186	int n; /* General purpose counter */
1187
1188	int c; /* c is a character, but must be signed
1189	integer to pass thru -1, which is the
1190	modem disconnection signal, and is
1191	different from the character 0377 */
1192	int c2; /* A copy of c */
1193	int csave; /* Another copy of c */
1194	#ifdef SUNX25
1195	int i; /* Worker for X.25 code */
1196	#endif /* SUNX25 */
1197	#ifdef NETCONN
1198
1199	#endif /* NETCONN */
1200	#ifndef NOESCSEQ
1201	int apcrc;
1202	#endif /* NOESCSEQ */
1203
1204	int conret = 0; /* Return value from conect() */
1205	/* jbchksum = -1L; */
1206	jbset = 0; /* jmp_buf not set yet, don't use it */
1207
1208	debug(F101,"CONNECT fork signal","",CK_FORK_SIG);
1209	signal(CK_FORK_SIG, SIG_IGN); /* Initial CK_FORK_SIG handling, */
1210	/*
1211	The following ttimoff() call should not be necessary, but evidently there
1212	are cases where a timer is left active and then goes off, taking a longjmp
1213	to nowhere after the program's stack has changed. In any case, this is
1214	safe because the CONNECT module uses no timer of any kind, and no other timer
1215	should be armed while Kermit is in CONNECT mode.
1216	*/
1217	ttimoff(); /* Turn off any timer interrupts */
1218
1219	if (!local) {
1220	#ifdef NETCONN
1221	printf("Sorry, you must SET LINE or SET HOST first\n");
1222	#else
1223	printf("Sorry, you must SET LINE first\n");
1224	#endif /* NETCONN */
1225	goto conret0;
1226	}
1227	if (speed < 0L && network == 0 && ttfdflg == 0) {
1228	printf("Sorry, you must SET SPEED first\n");
1229	goto conret0;
1230	}
1231	#ifdef TCPSOCKET
1232	if (network && (nettype != NET_TCPB)
1233	#ifdef SUNX25
1234	&& (nettype != NET_SX25)
1235	#endif /* SUNX25 */
1236	) {
1237	printf("Sorry, network type not supported\n");
1238	goto conret0;
1239	}
1240	#endif /* TCPSOCKET */
1241
1242	#ifdef DYNAMIC
1243	if (!ibuf) {
1244	if (!(ibuf = malloc(IBUFL+1))) { /* Allocate input line buffer */
1245	printf("Sorry, CONNECT input buffer can't be allocated\n");
1246	goto conret0;
1247	} else {
1248	ibp = ibuf;
1249	ibc = 0;
1250	}
1251	}
1252	if (!obuf) {
1253	if (!(obuf = malloc(OBUFL+1))) { /* Allocate output line buffer */
1254	printf("Sorry, CONNECT output buffer can't be allocated\n");
1255	goto conret0;
1256	} else {
1257	obp = obuf;
1258	obc = 0;
1259	}
1260	}
1261	if (!kbuf) {
1262	if (!(kbuf = malloc(KBUFL+1))) { /* Allocate keyboard input buffer */
1263	printf("Sorry, CONNECT keyboard buffer can't be allocated\n");
1264	goto conret0;
1265	}
1266	}
1267	if (!temp) {
1268	if (!(temp = malloc(TMPLEN+1))) { /* Allocate temporary buffer */
1269	printf("Sorry, CONNECT temporary buffer can't be allocated\n");
1270	goto conret0;
1271	}
1272	}
1273	#else
1274	#ifdef COMMENT
1275	ibp = ibuf;
1276	ibc = 0;
1277	#endif /* COMMENT */
1278	obp = obuf;
1279	obc = 0;
1280	#endif /* DYNAMIC */
1281
1282	kbp = kbuf; /* Always clear these. */
1283	kbp = NUL; / No need to preserve them between */
1284	kbc = 0; /* CONNECT sessions. */
1285
1286	#ifdef DEBUG
1287	if (deblog) {
1288	debug(F101,"ckucon entry ttyfd","",ttyfd);
1289	debug(F101,"ckucon entry ibc","",ibc);
1290	debug(F101,"ckucon entry obc","",obc);
1291	debug(F101,"ckucon entry kbc","",kbc);
1292	if (ttyfd > -1) {
1293	n = ttchk();
1294	debug(F101,"ckucon entry ttchk","",n);
1295	}
1296	}
1297	#endif /* DEBUG */
1298
1299	if (ttyfd < 0) { /* If communication device not open */
1300	debug(F111,"ckucon opening",ttname,0); /* Open it now */
1301	if (ttopen(ttname,
1302	&local,
1303	network ? -nettype : mdmtyp,
1304	0
1305	) < 0) {
1306	sprintf(temp,"Sorry, can't open %s",ttname);
1307	perror(temp);
1308	debug(F110,"ckucon open failure",ttname,0);
1309	goto conret0;
1310	}
1311	}
1312	dohangup = 0; /* Hangup not requested yet */
1313	#ifdef SUNX25
1314	dox25clr = 0; /* X.25 clear not requested yet */
1315	#endif /* SUNX25 */
1316
1317	if (!quiet
1318	#ifdef CK_APC
1319	&& !apcactive
1320	#endif /* CK_APC */
1321	) {
1322	#ifdef NETCONN
1323	if (network) {
1324	printf("Connecting to host %s",ttname);
1325	#ifdef SUNX25
1326	if (nettype == NET_SX25)
1327	printf(", Link ID %d, LCN %d",linkid,lcn);
1328	#endif /* SUNX25 */
1329	} else {
1330	#endif /* NETCONN */
1331	printf("Connecting to %s",ttname);
1332	if (speed > -1L) printf(", speed %ld",speed);
1333	#ifdef NETCONN
1334	}
1335	#endif /* NETCONN */
1336	if (tt_escape) {
1337	printf(".\r\nThe escape character is Ctrl-%c (ASCII %d, %s)\r\n",
1338	ctl(escape), escape,
1339	(escape == 127 ? "DEL" : ccntab[escape]));
1340	printf("Type the escape character followed by C to get back,\r\n");
1341	printf("or followed by ? to see other options.\r\n");
1342	} else {
1343	printf(".\r\n\nESCAPE CHARACTER IS DISABLED\r\n\n");
1344	}
1345	if (seslog) {
1346	printf("(Session logged to %s, ",sesfil);
1347	printf("%s)\r\n", sessft ? "binary" : "text");
1348	}
1349	if (debses) printf("Debugging Display...)\r\n");
1350	fflush(stdout);
1351	}
1352
1353	/* Condition console terminal and communication line */
1354
1355	if (conbin((char)escape) < 0) {
1356	printf("Sorry, can't condition console terminal\n");
1357	goto conret0;
1358	}
1359	debug(F101,"CONNECT cmask","",cmask);
1360	debug(F101,"CONNECT cmdmsk","",cmdmsk);
1361	debug(F101,"CONNECT speed before ttvt","",speed);
1362	if ((n = ttvt(speed,flow)) < 0) { /* Enter "virtual terminal" mode */
1363	debug(F101,"CONNECT ttvt","",n);
1364	tthang(); /* Hang up and close the device. */
1365	ttclos(0);
1366	if (ttopen(ttname, /* Open it again... */
1367	&local,
1368	network ? -nettype : mdmtyp,
1369	0
1370	) < 0) {
1371	sprintf(temp,"Sorry, can't reopen %s",ttname);
1372	perror(temp);
1373	goto conret0;
1374	}
1375	if (ttvt(speed,flow) < 0) { /* Try virtual terminal mode again. */
1376	conres(); /* Failure this time is fatal. */
1377	printf("Sorry, Can't condition communication line\n");
1378	goto conret0;
1379	}
1380	}
1381	debug(F101,"CONNECT ttvt ok, escape","",escape);
1382
1383	#ifndef NOCSETS
1384	/* Set up character set translations */
1385
1386	tcs = gettcs(tcsr,tcsl); /* Get intermediate set. */
1387
1388	if (tcsr == tcsl) { /* Remote and local sets the same? */
1389	sxo = rxo = NULL; /* If so, no translation. */
1390	sxi = rxi = NULL;
1391	} else { /* Otherwise, set up */
1392	sxo = xls[tcs][tcsl]; /* translation function */
1393	rxo = xlr[tcs][tcsr]; /* pointers for output functions */
1394	sxi = xls[tcs][tcsr]; /* and for input functions. */
1395	rxi = xlr[tcs][tcsl];
1396	}
1397	/*
1398	This is to prevent use of zmstuff() and zdstuff() by translation functions.
1399	They only work with disk i/o, not with communication i/o. Luckily Russian
1400	translation functions don't do any stuffing...
1401	*/
1402	langsv = language;
1403	#ifndef NOCYRIL
1404	if (language != L_RUSSIAN)
1405	#endif /* NOCYRIL */
1406	language = L_USASCII;
1407
1408	#ifdef COMMENT
1409	#ifdef DEBUG
1410	if (deblog) {
1411	debug(F101,"tcs","",tcs);
1412	debug(F101,"tcsl","",tcsl);
1413	debug(F101,"tcsr","",tcsr);
1414	debug(F101,"fcsinfo[tcsl].size","",fcsinfo[tcsl].size);
1415	debug(F101,"fcsinfo[tcsr].size","",fcsinfo[tcsr].size);
1416	}
1417	#endif /* DEBUG */
1418	#endif /* COMMENT */
1419
1420	#ifdef CK_XYZ
1421	#ifndef XYZ_INTERNAL
1422	{
1423	extern int binary; /* See about ZMODEM autodownloads */
1424	char * s;
1425	s = binary ? ptab[PROTO_Z].p_b_rcmd : ptab[PROTO_Z].p_t_rcmd;
1426	if (!s) s = "";
1427	zmdlok = (s != NUL); / OK if we have external commands */
1428	}
1429	#endif /* XYZ_INTERNAL */
1430	#endif /* CK_XYZ */
1431
1432	#ifndef NOESCSEQ
1433	/*
1434	We need to activate the escape-sequence recognition feature when:
1435	(a) translation is elected, AND
1436	(b) the local and/or remote set is a 7-bit set other than US ASCII.
1437	Or:
1438	SET TERMINAL APC is not OFF (handled in the next statement).
1439	*/
1440	escseq = (tcs != TC_TRANSP) && /* Not transparent */
1441	(fcsinfo[tcsl].size == 128 \|\| fcsinfo[tcsr].size == 128) && /* 7 bits */
1442	(fcsinfo[tcsl].code != FC_USASCII); /* But not ASCII */
1443	#endif /* NOESCSEQ */
1444	#endif /* NOCSETS */
1445
1446	#ifndef NOESCSEQ
1447	#ifdef CK_APC
1448	escseq = escseq \|\| (apcstatus != APC_OFF);
1449	apcactive = 0; /* An APC command is not active */
1450	apclength = 0; /* ... */
1451	#endif /* CK_APC */
1452	inesc = ES_NORMAL; /* Initial state of recognizer */
1453	debug(F101,"escseq","",escseq);
1454	#endif /* NOESCSEQ */
1455
1456	/*
1457	This is a label we jump back to when the lower fork sensed the need
1458	to change modes. As of 5A(178), this is used only by X.25 code
1459	(perhaps unnecessarily? -- The X.25 code needs a lot of testing and
1460	cleaning up...) As of 5A(190), it is not used at all, good.
1461	*/
1462	#ifdef COMMENT
1463	newfork:
1464	debug(F100,"CONNECT newfork","",0);
1465	#endif /* COMMENT */
1466
1467	parent_id = getpid(); /* Get parent's pid for signalling */
1468	debug(F101,"CONNECT parent pid","",parent_id);
1469
1470	if (xpipe[0] > -1) /* If old pipe hanging around, close */
1471	close(xpipe[0]);
1472	xpipe[0] = -1;
1473	if (xpipe[1] > -1)
1474	close(xpipe[1]);
1475	xpipe[1] = -1;
1476	goterr = 0; /* Error flag for pipe & fork */
1477	if (pipe(xpipe) != 0) { /* Create new pipe to pass info */
1478	perror("Can't make pipe"); /* between forks. */
1479	debug(F101,"CONNECT pipe error","",errno);
1480	goterr = 1;
1481	} else
1482	#ifdef BEBOX
1483	{
1484	pid = spawn_thread(concld, "Lower Fork", B_NORMAL_PRIORITY, NULL);
1485	resume_thread(pid);
1486	}
1487	#else
1488	if ((pid = fork()) == (PID_T) -1) { /* Pipe OK, make port fork. */
1489	perror("Can't make port fork");
1490	debug(F101,"CONNECT fork error","",errno);
1491	goterr = 1;
1492	}
1493	#endif /* BEBOX */
1494	if (goterr) { /* Failed to make pipe or fork */
1495	conres(); /* Reset the console. */
1496	if (!quiet) {
1497	printf("\r\nCommunications disconnect (Back at %s)\r\n",
1498	*myhost ?
1499	myhost :
1500	#ifdef UNIX
1501	"local UNIX system"
1502	#else
1503	"local system"
1504	#endif /* UNIX */
1505	);
1506	}
1507	printf("\n");
1508	what = W_NOTHING; /* So console modes are set right. */
1509	#ifndef NOCSETS
1510	language = langsv; /* Restore language */
1511	#endif /* NOCSETS */
1512	parent_id = (PID_T) 0; /* Clean up */
1513	goto conret1;
1514	}
1515	debug(F101,"CONNECT fork pid","",pid);
1516
1517	/* Upper fork (KEYB fork) reads keystrokes and sends them out. */
1518
1519	if (pid) { /* pid != 0, so I am the upper fork. */
1520	/*
1521	Before doing anything significant, the child fork must wait for a go-ahead
1522	character from xpipe[0]. Before starting to wait, we have enough time to
1523	clear buffers and set up the signal handler. When done with this, we will
1524	allow the child to continue by satisfying its pending read.
1525
1526	Remember the child and parent have separate address space. The child has
1527	its own copy of input buffers, so we must clear the input buffers in the
1528	parent. Otherwise strange effects may occur, like chunks of characters
1529	repeatedly echoed on terminal screen. The child process is designed to
1530	empty its input buffers by reading all available characters and either
1531	echoing them on the terminal screen or saving them for future use in the
1532	parent. The latter case happens during APC processing - see the code around
1533	CEV_APC occurrences to see how the child passes its ibuf etc to parent via
1534	xpipe, for preservation until the next entry to this module, to ensure that
1535	no characters are lost between CONNECT sessions.
1536	*/
1537
1538	/*
1539	This one needs a bit of extra explanation... In addition to the CONNECT
1540	module's own buffers, which are communicated and synchronized via xpipe,
1541	the low-level UNIX communication routines (ttinc, ttxin, etc) are also
1542	buffered, statically, in the ckutio.c module. But when the two CONNECT
1543	forks split off, the lower fork is updating this buffer's pointers and
1544	counts, but the upper fork never finds out about it and still has the old
1545	ones. The following UNIX-specific call to the ckutio.c module takes care
1546	of this... Without it, we get dual echoing of incoming characters.
1547	*/
1548	ttflux();
1549	/*
1550	At this point, perhaps you are wondering why we use forks at all. It is
1551	simply because there is no other method portable among all UNIX variations.
1552	Not threads, not select(), ...
1553	*/
1554	ibp = ibuf; /* Clear ibuf[]. */
1555	ibc = 0; /* Child now has its own copy */
1556	signal(CK_FORK_SIG, pipeint); /* Handler for messages from child. */
1557	write(xpipe[1], ibuf, 1); /* Allow child to proceed */
1558	close(xpipe[1]); xpipe[1] = -1; /* Parent - prevent future writes */
1559
1560	what = W_CONNECT; /* Keep track of what we're doing */
1561	active = 1;
1562	debug(F101,"CONNECT keyboard fork duplex","",duplex);
1563	/*
1564	Catch communication errors or mode changes in lower fork.
1565
1566	Note: Some C compilers (e.g. Cray UNICOS) interpret the ANSI C standard
1567	about setjmp() in a way that disallows constructions like:
1568
1569	if ((var = [sig]setjmp(env)) == 0) ...
1570
1571	which prevents the value returned by cklongjmp() from being used at all.
1572	So the signal handlers set a global variable, sjval, instead.
1573	*/
1574	if (
1575	#ifdef CK_POSIX_SIG
1576	sigsetjmp(con_env,1)
1577	#else
1578	setjmp(con_env)
1579	#endif /* CK_POSIX_SIG */
1580	== 0) { /* Normal entry... */
1581	jbset = 1; /* Now we have a longjmp buffer */
1582	sjval = CEV_NO; /* Initialize setjmp return code. */
1583
1584	debug(F101,"CONNECT setjmp normal entry","",sjval);
1585
1586	#ifdef SUNX25
1587	if (network && nettype == NET_SX25) {
1588	obufl = 0;
1589	bzero (x25obuf,sizeof(x25obuf));
1590	}
1591	#endif /* SUNX25 */
1592	/*
1593	Here is the big loop that gets characters from the keyboard and sends them
1594	out the communication device. There are two components to the communication
1595	path: the connection from the keyboard to C-Kermit, and from C-Kermit to
1596	the remote computer. The treatment of the 8th bit of keyboard characters
1597	is governed by SET COMMAND BYTESIZE (cmdmsk). The treatment of the 8th bit
1598	of characters sent to the remote is governed by SET TERMINAL BYTESIZE
1599	(cmask). This distinction was introduced in edit 5A(164).
1600	*/
1601	while (active) {
1602	#ifndef NOSETKEY
1603	if (kmptr) { /* Have current macro? */
1604	debug(F100,"kmptr non NULL","",0);
1605	if ((c = (CHAR) kmptr++) == NUL) { / Get char from it */
1606	kmptr = NULL; /* If no more chars, */
1607	debug(F100,"macro empty, continuing","",0);
1608	continue; /* reset pointer and continue */
1609	}
1610	debug(F000,"char from macro","",c);
1611	} else /* No macro... */
1612	#endif /* NOSETKEY */
1613	c = CONGKS(); /* Read from keyboard */
1614
1615	debug(F101,"** KEYB","",c);
1616
1617	if (c == -1) { /* If read() got an error... */
1618	debug(F101,"CONNECT keyboard read errno","",errno);
1619	#ifdef COMMENT
1620	/*
1621	This seems to cause problems. If read() returns -1, the signal has already
1622	been delivered, and nothing will wake up the pause().
1623	*/
1624	pause(); /* Wait for transmitter to finish. */
1625	#else
1626	#ifdef A986
1627	/*
1628	On Altos machines with Xenix 3.0, pressing DEL in connect mode brings us
1629	here (reason unknown). The console line discipline at this point has
1630	intr = ^C. The communications tty has intr = DEL but we get here after
1631	pressing DEL on the keyboard, even when the remote system has been set not
1632	to echo. With A986 defined, we stay in the read loop and beep only if the
1633	offending character is not DEL.
1634	*/
1635	if ((c & 127) != 127) conoc(BEL);
1636	#else
1637	#ifdef EINTR
1638	/*
1639	This can be caused by the other fork signalling this one about
1640	an echoing change during TELNET negotiations.
1641	*/
1642	if (errno == EINTR)
1643	continue;
1644	#endif /* EINTR */
1645	conoc(BEL); /* Otherwise, beep */
1646	active = 0; /* and terminate the read loop */
1647	continue;
1648	#endif /* A986 */
1649	#endif /* COMMENT */
1650	}
1651	c &= cmdmsk; /* Do any requested masking */
1652	#ifndef NOSETKEY
1653	/*
1654	Note: kmptr is NULL if we got character c from the keyboard, and it is
1655	not NULL if it came from a macro. In the latter case, we must avoid
1656	expanding it again.
1657	*/
1658	if (!kmptr && macrotab[c]) { /* Macro definition for c? */
1659	kmptr = macrotab[c]; /* Yes, set up macro pointer */
1660	continue; /* and restart the loop, */
1661	} else c = keymap[c]; /* else use single-char keymap */
1662	#endif /* NOSETKEY */
1663	if (
1664	#ifndef NOSETKEY
1665	!kmptr &&
1666	#endif /* NOSETKEY */
1667	(tt_escape && (c & 0x7f) == escape)) { /* Escape char? */
1668	debug(F000,"CONNECT got escape","",c);
1669	c = CONGKS() & 0177; /* Got esc, get its arg */
1670	/* No key mapping here */
1671	doesc((char) c); /* Now process it */
1672
1673	} else { /* It's not the escape character */
1674	csave = c; /* Save it before translation */
1675	/* for local echoing. */
1676	#ifndef NOCSETS
1677	#ifdef NOESCSEQ
1678	/* Translate character sets */
1679	if (sxo) c = (sxo)(c); / From local to intermediate. */
1680	if (rxo) c = (rxo)(c); / From intermediate to remote. */
1681	#else
1682	if (inesc == ES_NORMAL) { /* If not inside escape seq.. */
1683	/* Translate character sets */
1684	if (sxo) c = (sxo)((char)c); / Local-intermediate */
1685	if (rxo) c = (rxo)((char)c); / Intermediate-remote */
1686	}
1687	if (escseq) apcrc = chkaes((char)c);
1688	#endif /* NOESCSEQ */
1689	#endif /* NOCSETS */
1690	/*
1691	If Shift-In/Shift-Out is selected and we have a 7-bit connection,
1692	handle shifting here.
1693	*/
1694	if (sosi) { /* Shift-In/Out selected? */
1695	if (cmask == 0177) { /* In 7-bit environment? */
1696	if (c & 0200) { /* 8-bit character? */
1697	if (outshift == 0) { /* If not shifted, */
1698	ttoc(dopar(SO)); /* shift. */
1699	outshift = 1;
1700	}
1701	} else {
1702	if (outshift == 1) { /* 7-bit character */
1703	ttoc(dopar(SI)); /* If shifted, */
1704	outshift = 0; /* unshift. */
1705	}
1706	}
1707	}
1708	if (c == SO) outshift = 1; /* User typed SO */
1709	if (c == SI) outshift = 0; /* User typed SI */
1710	}
1711	c &= cmask; /* Apply Kermit-to-host mask now. */
1712	#ifdef SUNX25
1713	if (network && nettype == NET_SX25) {
1714	if (padparms[PAD_ECHO]) {
1715	if (debses)
1716	conol(dbchr(c)) ;
1717	else
1718	if ((c != padparms[PAD_CHAR_DELETE_CHAR]) &&
1719	(c != padparms[PAD_BUFFER_DELETE_CHAR]) &&
1720	(c != padparms[PAD_BUFFER_DISPLAY_CHAR]))
1721	conoc(c) ;
1722	if (seslog) logchar(c);
1723	}
1724	if (c == CR && (padparms[PAD_LF_AFTER_CR] == 4 \|\|
1725	padparms[PAD_LF_AFTER_CR] == 5)) {
1726	if (debses)
1727	conol(dbchr(LF)) ;
1728	else
1729	conoc(LF) ;
1730	if (seslog) logchar(LF);
1731	}
1732	if (c == padparms[PAD_BREAK_CHARACTER])
1733	breakact();
1734	else if (padparms[PAD_DATA_FORWARD_TIMEOUT]) {
1735	tosend = 1;
1736	x25obuf [obufl++] = c;
1737	} else if (((c == padparms[PAD_CHAR_DELETE_CHAR]) \|\|
1738	(c == padparms[PAD_BUFFER_DELETE_CHAR]) \|\|
1739	(c == padparms[PAD_BUFFER_DISPLAY_CHAR]))
1740	&& (padparms[PAD_EDITING]))
1741	if (c == padparms[PAD_CHAR_DELETE_CHAR])
1742	if (obufl > 0) {
1743	conol("\b \b"); obufl--;
1744	} else {}
1745	else if (c == padparms[PAD_BUFFER_DELETE_CHAR]) {
1746	conol ("\r\nPAD Buffer Deleted\r\n");
1747	obufl = 0;
1748	}
1749	else if (c == padparms[PAD_BUFFER_DISPLAY_CHAR]) {
1750	conol("\r\n");
1751	conol(x25obuf);
1752	conol("\r\n");
1753	} else {}
1754	else {
1755	x25obuf [obufl++] = c;
1756	if (obufl == MAXOX25) tosend = 1;
1757	else if (c == CR) tosend = 1;
1758	}
1759	if (tosend)
1760	if (ttol((CHAR *)x25obuf,obufl) < 0) {
1761	perror ("\r\nCan't send characters");
1762	active = 0;
1763	} else {
1764	bzero (x25obuf,sizeof(x25obuf));
1765	obufl = 0;
1766	tosend = 0;
1767	} else {};
1768	} else {
1769	#endif /* SUNX25 */
1770	if (c == '\015') { /* Carriage Return */
1771	int stuff = -1;
1772	if (tnlm) { /* TERMINAL NEWLINE ON */
1773	stuff = LF; /* Stuff LF */
1774	#ifdef TNCODE
1775	} else if (network && /* TELNET NEWLINE ON/OFF/RAW */
1776	(ttnproto == NP_TELNET)) {
1777	switch (!me_binary ? tn_nlm : tn_b_nlm) {
1778	case TNL_CRLF:
1779	stuff = LF;
1780	break;
1781	case TNL_CRNUL:
1782	stuff = NUL;
1783	break;
1784	}
1785	#endif /* TNCODE */
1786	}
1787	if (stuff > -1) {
1788	ttoc(dopar('\015')); /* Send CR */
1789	if (duplex) conoc('\015'); /* Maybe echo CR */
1790	c = stuff; /* Char to stuff */
1791	csave = c;
1792	}
1793	}
1794	#ifdef TNCODE
1795	/* If user types the 0xff character (TELNET IAC), it must be doubled. */
1796	else /* Not CR */
1797	if ((dopar((CHAR) c) == IAC) && /* IAC (0xff) */
1798	network && (ttnproto == NP_TELNET)) {
1799	/* Send one copy now */
1800	ttoc((char)IAC); /* and the other one just below. */
1801	}
1802	#endif /* TNCODE */
1803	/* Send the character */
1804
1805	if (ttoc((char)dopar((CHAR) c)) > -1) {
1806	if (duplex) { /* If half duplex, must echo */
1807	if (debses)
1808	conol(dbchr(csave)); /* the original char */
1809	else /* not the translated one */
1810	conoc((char)csave);
1811	if (seslog) { /* And maybe log it too */
1812	c2 = csave;
1813	if (sessft == 0 && csave == '\r')
1814	c2 = '\n';
1815	logchar((char)c2);
1816	}
1817	}
1818	} else {
1819	perror("\r\nCan't send character");
1820	active = 0;
1821	}
1822	#ifdef SUNX25
1823	}
1824	#endif /* SUNX25 */
1825	}
1826	}
1827
1828	/* now active == 0 */
1829	signal(CK_FORK_SIG, SIG_IGN); /* Turn off CK_FORK_SIG */
1830	sjval = CEV_NO; /* Set to hangup */
1831	} /* Come here on termination of child */
1832
1833	/* cklongjmp() executed in pipeint() (parent only!) comes here */
1834
1835	/*
1836	Now the child fork is gone or is waiting for CK_FORK_SIG in ck_sndmsg().
1837	So we can't get (in the parent) any subsequent CK_FORK_SIG signals until
1838	we signal the child with CK_FORK_SIG.
1839	*/
1840	debug(F100,"CONNECT signaling port fork","",0);
1841	signal(CK_FORK_SIG, SIG_IGN); /* Turn this off */
1842	debug(F100,"CONNECT killing port fork","",0);
1843	#ifdef BEBOX
1844	{
1845	long ret_val;
1846	if (pid) kill(pid,SIGKILLTHR); /* Kill lower fork */
1847	wait_for_thread (pid, &ret_val);
1848	}
1849	#else
1850	#ifdef Plan9
1851	if (pid) kill(pid,SIGKILL); /* Kill lower fork */
1852	#else
1853	if (pid) kill(pid,9); /* Kill lower fork */
1854	#endif /* Plan9 */
1855	#endif /* BEBOX */
1856	debug(F100,"CONNECT killed port fork","",0);
1857	pid = -1;
1858	wait((WAIT_T )0); / Wait till gone. */
1859
1860	if (sjval == CEV_HUP) { /* Read error on comm device */
1861	dohangup = 1; /* so we want to hang up our side */
1862	#ifdef NETCONN
1863	if (network) { /* and/or close network connection */
1864	ttclos(0);
1865	#ifdef SUNX25
1866	if (nettype == NET_SX25) /* If X.25, restore the PAD params */
1867	initpad();
1868	#endif /* SUNX25 */
1869	}
1870	#endif /* NETCONN */
1871	}
1872	#ifdef SUNX25
1873	#ifdef COMMENT
1874	/* Not used, should not be needed -- see pipeint()... */
1875	if (sjval == CEV_PAD) /* If it was a mode change, go back */
1876	goto newfork; /* and coordinate with other fork. */
1877	#endif /* COMMENT */
1878	#endif /* SUNX25 */
1879
1880	#ifdef CK_APC
1881	if (sjval == CEV_APC) { /* Application Program Command rec'd */
1882	apcactive = 1; /* Flag APC as active */
1883	active = 0; /* Flag CONNECT as inactive */
1884	}
1885	#endif /* CK_APC */
1886	conres(); /* Reset the console. */
1887	if (dohangup > 0) { /* If hangup requested, do that. */
1888	#ifndef NODIAL
1889	if (dohangup > 1) /* User asked for it */
1890	if (mdmhup() < 1) /* Maybe hang up via modem */
1891	#endif /* NODIAL */
1892	tthang(); /* And make sure we don't hang up */
1893	dohangup = 0; /* again unless requested again. */
1894	}
1895
1896	#ifdef COMMENT
1897	#ifdef NETCONN
1898	#ifdef SIGPIPE
1899	if (network && sigpiph) /* Restore previous SIGPIPE handler */
1900	(VOID) signal(SIGPIPE, sigpiph);
1901	#endif /* SIGPIPE */
1902	#endif /* NETCONN */
1903	#endif /* COMMENT */
1904
1905	#ifdef SUNX25
1906	if (dox25clr) { /* If X.25 Clear requested */
1907	x25clear(); /* do that. */
1908	initpad();
1909	dox25clr = 0; /* But only once. */
1910	}
1911	#endif /* SUNX25 */
1912
1913	if (quitnow) doexit(GOOD_EXIT,xitsta); /* Exit now if requested. */
1914	if (!quiet
1915	#ifdef CK_APC
1916	&& !apcactive
1917	#endif /* CK_APC */
1918	)
1919	printf("(Back at %s)", *myhost ? myhost : "local UNIX system");
1920	#ifdef CK_APC
1921	if (!apcactive)
1922	#endif /* CK_APC */
1923	printf("\n");
1924	what = W_NOTHING; /* So console modes set right. */
1925	#ifndef NOCSETS
1926	language = langsv; /* Restore language */
1927	#endif /* NOCSETS */
1928	parent_id = (PID_T) 0;
1929	goto conret1;
1930
1931	}
1932	#ifndef BEBOX
1933	else { /* *** / / Inferior reads, prints port input */
1934	concld(/* (void )&pid /);
1935	}
1936	#endif /* BEBOX */
1937
1938	conret1:
1939	conret = 1;
1940	conret0:
1941	signal(CK_FORK_SIG, SIG_IGN); /* In case this wasn't done already */
1942	debug(F101,"ckucon exit ibc","",ibc);
1943	debug(F101,"ckucon exit obc","",obc);
1944	close(xpipe[0]); xpipe[0] = -1; /* Close the pipe */
1945	close(xpipe[1]); xpipe[1] = -1;
1946	return(conret);
1947	}
1948
1949
1950	/* H C O N N E -- Give help message for connect. */
1951
1952	int
1953	hconne() {
1954	int c;
1955	static char *hlpmsg[] = {
1956	"\r\n ? for this message",
1957	"\r\n 0 (zero) to send a null",
1958	"\r\n B to send a BREAK",
1959	#ifdef CK_LBRK
1960	"\r\n L to send a Long BREAK",
1961	#endif /* CK_LBRK */
1962	#ifdef NETCONN
1963	"\r\n I to send a network interrupt packet",
1964	#ifdef TCPSOCKET
1965	"\r\n A to send Are You There?",
1966	#endif /* TCPSOCKET */
1967	#ifdef SUNX25
1968	"\r\n R to reset X.25 virtual circuit",
1969	#endif /* SUNX25 */
1970	#endif /* NETCONN */
1971	"\r\n U to hangup and close the connection",
1972	"\r\n Q to hangup and quit Kermit",
1973	"\r\n S for status",
1974	#ifdef NOPUSH
1975	"\r\n ! to push to local shell (disabled)",
1976	"\r\n Z to suspend (disabled)",
1977	#else
1978	"\r\n ! to push to local shell",
1979	#ifdef NOJC
1980	"\r\n Z to suspend (disabled)",
1981	#else
1982	"\r\n Z to suspend",
1983	#endif /* NOJC */
1984	#endif /* NOPUSH */
1985	"\r\n \\ backslash code:",
1986	"\r\n \\nnn decimal character code",
1987	"\r\n \\Onnn octal character code",
1988	"\r\n \\Xhh hexadecimal character code",
1989	"\r\n terminate with carriage return.",
1990	"\r\n Type the escape character again to send the escape character, or",
1991	"\r\n press the space-bar to resume the CONNECT command.\r\n\r\n",
1992	"" };
1993	conol("\r\nPress C to return to ");
1994	conol(*myhost ? myhost : "the C-Kermit prompt");
1995	conol(", or:");
1996	conola(hlpmsg); /* Print the help message. */
1997	conol("Command>"); /* Prompt for command. */
1998	c = CONGKS() & 0177; /* Get character, strip any parity. */
1999	/* No key mapping or translation here */
2000	if (c != CMDQ)
2001	conoll("");
2002	return(c); /* Return it. */
2003	}
2004
2005
2006	/* D O E S C -- Process an escape character argument */
2007
2008	VOID
2009	#ifdef CK_ANSIC
2010	doesc(char c)
2011	#else
2012	doesc(c) char c;
2013	#endif /* CK_ANSIC */
2014	/* doesc */ {
2015	CHAR d;
2016
2017	debug(F101,"doesc","",c);
2018	while (1) {
2019	if (c == escape) { /* Send escape character */
2020	d = dopar((CHAR) c); ttoc((char) d); return;
2021	} else /* Or else look it up below. */
2022	if (isupper(c)) c = tolower(c);
2023
2024	switch(c) {
2025
2026	case 'c': /* Escape back to prompt */
2027	case '\03':
2028	active = 0; conol("\r\n"); return;
2029
2030	case 'b': /* Send a BREAK signal */
2031	case '\02':
2032	ttsndb(); return;
2033
2034	#ifdef NETCONN
2035	case 'i': /* Send Interrupt */
2036	case '\011':
2037	#ifdef TCPSOCKET
2038	#ifndef IP
2039	#define IP 244
2040	#endif /* IP */
2041	if (network && ttnproto == NP_TELNET) { /* TELNET */
2042	temp[0] = (CHAR) IAC; /* I Am a Command */
2043	temp[1] = (CHAR) IP; /* Interrupt Process */
2044	temp[2] = NUL;
2045	ttol((CHAR *)temp,2);
2046	} else
2047	#endif /* TCPSOCKET */
2048	#ifdef SUNX25
2049	if (network && (nettype == NET_SX25)) { /* X.25 */
2050	(VOID) x25intr(0); /* X.25 interrupt packet */
2051	conol("\r\n");
2052	} else
2053	#endif /* SUNX25 */
2054	conoc(BEL);
2055	return;
2056
2057	#ifdef TCPSOCKET
2058	case 'a': /* "Are You There?" */
2059	case '\01':
2060	#ifndef AYT
2061	#define AYT 246
2062	#endif /* AYT */
2063	if (network && ttnproto == NP_TELNET) {
2064	temp[0] = (CHAR) IAC; /* I Am a Command */
2065	temp[1] = (CHAR) AYT; /* Are You There? */
2066	temp[2] = NUL;
2067	ttol((CHAR *)temp,2);
2068	} else conoc(BEL);
2069	return;
2070	#endif /* TCPSOCKET */
2071	#endif /* NETCONN */
2072
2073	#ifdef CK_LBRK
2074	case 'l': /* Send a Long BREAK signal */
2075	ttsndlb(); return;
2076	#endif /* CK_LBRK */
2077
2078	case 'u': /* Hangup */
2079	/* case '\010': / / No, too dangerous */
2080	#ifdef SUNX25
2081	if (network && (nettype == NET_SX25)) dox25clr = 1;
2082	else
2083	#endif /* SUNX25 */
2084	dohangup = 2; active = 0; conol("\r\nHanging up "); return;
2085
2086	#ifdef SUNX25
2087	case 'r': /* Reset the X.25 virtual circuit */
2088	case '\022':
2089	if (network && (nettype == NET_SX25)) (VOID) x25reset(0,0);
2090	conol("\r\n"); return;
2091	#endif /* SUNX25 */
2092
2093	case 'q': /* Quit */
2094	dohangup = 2; quitnow = 1; active = 0; conol("\r\n"); return;
2095
2096	case 's': /* Status */
2097	sprintf(temp,
2098	"\r\nConnected %s %s", network ? "to" : "through", ttname);
2099	conol(temp);
2100	#ifdef SUNX25
2101	if (network && (nettype == NET_SX25)) {
2102	sprintf(temp,", Link ID %d, LCN %d",linkid,lcn); conol(temp);
2103	}
2104	#endif /* SUNX25 */
2105	if (speed >= 0L) {
2106	sprintf(temp,", speed %ld", speed);
2107	conoll(temp);
2108	} else conoll("");
2109	sprintf(temp,
2110	"Terminal bytesize: %d, Command bytesize: %d, Parity: ",
2111	(cmask == 0177) ? 7 : 8,
2112	(cmdmsk == 0177) ? 7 : 8 );
2113	conol(temp);
2114
2115	switch (parity) {
2116	case 0: conoll("none"); break;
2117	case 'e': conoll("even"); break;
2118	case 'o': conoll("odd"); break;
2119	case 's': conoll("space"); break;
2120	case 'm': conoll("mark"); break;
2121	}
2122	sprintf(temp,"Terminal echo: %s", duplex ? "local" : "remote");
2123	conoll(temp);
2124	if (seslog) {
2125	conol("Logging to: "); conoll(sesfil);
2126	}
2127	if (!network) shomdm();
2128	return;
2129
2130	case 'h': /* Help */
2131	case '?': /* Help */
2132	c = hconne(); continue;
2133
2134	case '0': /* Send a null */
2135	c = '\0'; d = dopar((CHAR) c); ttoc((char) d); return;
2136
2137	case 'z': case '\032': /* Suspend */
2138	#ifndef NOPUSH
2139	if (!nopush)
2140	stptrap(0);
2141	else
2142	conoc(BEL);
2143	#else
2144	conoc(BEL);
2145	#endif /* NOPUSH */
2146	return;
2147
2148	case '@': /* Start inferior command processor */
2149	case '!':
2150	#ifndef NOPUSH
2151	if (!nopush) {
2152	conres(); /* Put console back to normal */
2153	zshcmd(""); /* Fork a shell. */
2154	if (conbin((char)escape) < 0) {
2155	printf("Error resuming CONNECT session\n");
2156	active = 0;
2157	}
2158	} else conoc(BEL);
2159	#else
2160	conoc(BEL);
2161	#endif /* NOPUSH */
2162	return;
2163
2164	case SP: /* Space, ignore */
2165	return;
2166
2167	default: /* Other */
2168	if (c == CMDQ) { /* Backslash escape */
2169	int x;
2170	ecbp = ecbuf;
2171	*ecbp++ = c;
2172	while (((c = (CONGKS() & cmdmsk)) != '\r') && (c != '\n'))
2173	*ecbp++ = c;
2174	*ecbp = NUL; ecbp = ecbuf;
2175	x = xxesc(&ecbp); /* Interpret it */
2176	if (x >= 0) { /* No key mapping here */
2177	c = dopar((CHAR) x);
2178	ttoc((char) c);
2179	return;
2180	} else { /* Invalid backslash code. */
2181	conoc(BEL);
2182	return;
2183	}
2184	}
2185	conoc(BEL); return; /* Invalid esc arg, beep */
2186	}
2187	}
2188	}
2189
2190	static
2191	VOID
2192	#ifdef CK_ANSIC
2193	logchar(char c)
2194	#else
2195	logchar(c) char c;
2196	#endif /* CK_ANSIC */
2197	/* logchar / { / Log character c to session log */
2198	if (seslog)
2199	if ((sessft != 0) \|\|
2200	(c != '\r' &&
2201	c != '\0' &&
2202	c != XON &&
2203	c != XOFF))
2204	if (zchout(ZSFILE,c) < 0) {
2205	conoll("");
2206	conoll("ERROR WRITING SESSION LOG, LOG CLOSED!");
2207	seslog = 0;
2208	}
2209	}
2210	#endif /* NOLOCAL */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: