Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

ckucns.c @ 20081

Visit:

Revision 20081, 75.5 KB checked in by zacheiss, 21 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r20080, which included commits to RCS files with non-trunk default branches.

Rev	Line
[20080]	1	#include "ckcsym.h"
	2	char *connv = "CONNECT Command for UNIX:select(), 8.0.135, 29 Nov 2002";
	3
	4	/* C K U C N S -- Terminal connection to remote system, for UNIX */
	5	/*
	6	Author: Frank da Cruz <fdc@columbia.edu>,
	7	Columbia University Academic Information Systems, New York City.
	8
	9	Copyright (C) 1985, 2002,
	10	Trustees of Columbia University in the City of New York.
	11	All rights reserved. See the C-Kermit COPYING.TXT file or the
	12	copyright text in the ckcmai.c module for disclaimer and permissions.
	13	*/
	14
	15	/*
	16	This version of the UNIX CONNECT module uses select(), which is required for
	17	Kerberos encryption. Thus it can be used only on UNIX systems that support
	18	select() on both TCP/IP and serial connections. A separate module that uses
	19	a completely portable fork() structure can be used on systems where select()
	20	is not available or does not work as required.
	21	*/
	22
	23	#include "ckcdeb.h" /* Common things first */
	24
	25	#ifndef NOLOCAL
	26
	27	#ifdef OSF13
	28	#ifdef CK_ANSIC
	29	#ifdef _NO_PROTO
	30	#undef _NO_PROTO
	31	#endif /* _NO_PROTO */
	32	#endif /* CK_ANSIC */
	33	#endif /* OSF13 */
	34
	35	#include <errno.h> /* Error numbers */
	36
	37	#ifndef NOTIMEH
	38	#include <time.h> /* For FD_blah */
	39	#ifdef SYSTIMEH /* (IRIX 5.3) */
	40	#include <sys/time.h>
	41	#endif /* SYSTIMEH */
	42	#endif /* NOTIMEH */
	43
	44	#ifdef BSD42HACK /* Why is this necessary? */
	45	#ifndef DCLTIMEVAL
	46	#define DCLTIMEVAL
	47	#endif /* DCLTIMEVAL */
	48	#endif /* BSD42HACK */
	49
	50	/* Kermit-specific includes */
	51
	52	#include "ckcasc.h" /* ASCII characters */
	53	#include "ckcker.h" /* Kermit things */
	54	#include "ckucmd.h" /* For xxesc() prototype */
	55	#include "ckcnet.h" /* Network symbols */
	56	#ifndef NOCSETS
	57	#include "ckcxla.h" /* Character set translation */
	58	#endif /* NOCSETS */
	59
	60	#ifdef BEBOX
	61	#include <kernel/OS.h>
	62	#include <socket.h>
	63	#include <stdio.h>
	64	#endif /* BEBOX */
	65
	66	#include <signal.h> /* Signals */
	67
	68	/* All the following is for select()... */
	69
	70	#ifdef CKTIDLE /* Timeouts only for SET TERM IDLE */
	71
	72	#ifndef DCLTIMEVAL
	73	#ifdef UNIXWARE
	74	#ifndef UW7
	75	#define DCLTIMEVAL
	76	#endif /* UW7 */
	77	#endif /* UNIXWARE */
	78	#endif /* DCLTIMEVAL */
	79
	80	#ifdef DCLTIMEVAL /* Declare timeval ourselves */
	81	struct timeval {
	82	long tv_sec;
	83	long tv_usec;
	84	};
	85	#else /* !DCLTIMEVAL */
	86	#ifndef NOSYSTIMEBH
	87	#ifdef SYSTIMEBH
	88	#include <sys/timeb.h>
	89	#endif /* SYSTIMEBH */
	90	#endif /* NOSYSTIMEBH */
	91	#endif /* DCLTIMEVAL */
	92	#endif /* CKTIDLE */
	93
	94	#ifndef SCO_OSR504
	95	#ifdef SELECT_H
	96	#include <sys/select.h>
	97	#endif /* SELECT_H */
	98	#endif /* SCO_OSR504 */
	99
	100	#ifndef FD_SETSIZE
	101	#ifdef CK_FORWARD_X
	102	#define FD_SETSIZE 256
	103	#else
	104	#define FD_SETSIZE 32
	105	#endif /* CK_FORWARD_X */
	106	#endif /* FD_SETSIZE */
	107
	108	#ifdef HPUX
	109	#ifndef HPUX10
	110	#ifndef HPUX1100
	111	/* The three interior args to select() are (int ) rather than (fd_set ) */
	112	#ifndef INTSELECT
	113	#define INTSELECT
	114	#endif /* INTSELECT */
	115	#endif /* HPUX1100 */
	116	#endif /* HPUX10 */
	117	#endif /* HPUX */
	118
	119	/* Internal function prototypes */
	120
	121	#ifdef NEWFTP
	122	#endif /* NEWFTP */
	123	_PROTOTYP( VOID ttflux, (void) );
	124	_PROTOTYP( VOID doesc, (char) );
	125	_PROTOTYP( int hconne, (void) );
	126	#ifndef NOSHOW
	127	_PROTOTYP( VOID shomdm, (void) );
	128	#endif /* NOSHOW */
	129	_PROTOTYP( static int kbget, (void) );
	130	_PROTOTYP( static int ckcputf, (void) );
	131
	132	/* External variables */
	133
	134	extern struct ck_p ptab[];
	135
	136	extern int local, escape, duplex, parity, flow, seslog, sessft, debses,
	137	mdmtyp, ttnproto, cmask, cmdmsk, network, nettype, sosi, tnlm,
	138	xitsta, what, ttyfd, ttpipe, quiet, backgrd, pflag, tt_crd, tn_nlm, ttfdflg,
	139	tt_escape, justone, carrier, ttpty, hwparity;
	140
	141	#ifndef NODIAL
	142	extern int dialmhu, dialsta;
	143	#endif /* NODIAL */
	144
	145	#ifdef CKLEARN
	146	extern FILE * learnfp;
	147	extern int learning;
	148	static ULONG learnt1;
	149	static char learnbuf[LEARNBUFSIZ] = { NUL, NUL };
	150	static int learnbc = 0;
	151	static int learnbp = 0;
	152	static int learnst = 0;
	153	#endif /* CKLEARN */
	154
	155	extern long speed;
	156	extern char ttname[], sesfil[], myhost[], *ccntab[];
	157	#ifdef TNCODE
	158	extern int tn_b_nlm, tn_rem_echo;
	159	#endif /* TNCODE */
	160
	161	#ifdef CK_TRIGGER
	162	extern char * tt_trigger[], * triggerval;
	163	#endif /* CK_TRIGGER */
	164
	165	#ifdef CKTIDLE
	166	extern int tt_idlelimit, tt_idleact;
	167	extern char * tt_idlestr;
	168	static int idlelimit = 0;
	169	#endif /* CKTIDLE */
	170	extern int cx_status; /* CONNECT status code */
	171
	172	extern int nopush;
	173
	174	#ifdef CK_APC
	175	extern int apcactive; /* Application Program Command (APC) */
	176	extern int apcstatus; /* items ... */
	177	static int apclength = 0;
	178	#ifdef DCMDBUF
	179	extern char *apcbuf;
	180	#else
	181	extern char apcbuf[];
	182	#endif /* DCMDBUF */
	183	static int apcbuflen = APCBUFLEN - 2;
	184	extern int protocol;
	185	#endif /* CK_APC */
	186	#ifndef NOXFER
	187	extern int autodl; /* Auto download */
	188	#endif /* NOXFER */
	189
	190	#ifdef CK_AUTODL
	191	extern CHAR ksbuf[];
	192	extern CHAR stchr;
	193	extern int kstartactive;
	194	#endif /* CK_AUTODL */
	195
	196	#ifdef CK_ENCRYPTION
	197	extern int me_auth;
	198	#endif /* CK_ENCRYPTION */
	199
	200	#ifdef CK_XYZ
	201	#ifdef XYZ_INTERNAL
	202	static int zmdlok = 1; /* Zmodem autodownloads available */
	203	#else
	204	static int zmdlok = 0; /* Depends on external protocol def */
	205	#endif /* XYZ_INTERNAL */
	206	#else
	207	static int zmdlok = 0; /* Not available at all */
	208	#endif /* CK_XYZ */
	209
	210	#ifndef NOSETKEY /* Keyboard mapping */
	211	extern KEY keymap; / Single-character key map */
	212	extern MACRO macrotab; / Key macro pointer table */
	213	static MACRO kmptr = NULL; /* Pointer to current key macro */
	214	#endif /* NOSETKEY */
	215
	216	/* Global variables local to this module */
	217
	218	static int
	219	active = 0,
	220	quitnow = 0, /* <esc-char>Q was typed */
	221	dohangup = 0, /* <esc-char>H was typed */
	222	inshift = 0, /* SO/SI shift states */
	223	outshift = 0;
	224
	225	static char ecbuf[10], ecbp; / Escape char buffer & pointer */
	226
	227	#ifdef CK_SMALL
	228	#define IBUFL 1536 /* Input buffer length */
	229	#else
	230	#define IBUFL 4096
	231	#endif /* CK_SMALL */
	232
	233	static int obc = 0; /* Output buffer count */
	234
	235	#ifndef OXOS
	236	#define OBUFL 1024 /* Output buffer length */
	237	#else
	238	#define OBUFL IBUFL
	239	#endif /* OXOS */
	240
	241	#ifdef BIGBUFOK
	242	#define TMPLEN 4096 /* Temporary message buffer length */
	243	#else
	244	#define TMPLEN 200
	245	#endif /* BIGBUFOK */
	246
	247	#ifdef DYNAMIC
	248	static char ibuf = NULL, obuf = NULL, temp = NULL; / Buffers */
	249	#else
	250	static char ibuf[IBUFL], obuf[OBUFL], temp[TMPLEN];
	251	#endif /* DYNAMIC */
	252
	253	#ifdef TNCODE
	254	static char tnopt[4];
	255	#endif /* TNCODE */
	256
	257	#ifdef DYNAMIC
	258	static char ibp; / Input buffer pointer */
	259	#else
	260	static char ibp = ibuf; / Input buffer pointer */
	261	#endif /DYNAMIC /
	262	static int ibc = 0; /* Input buffer count */
	263
	264	#ifdef DYNAMIC
	265	static char obp; / Output buffer pointer */
	266	#else
	267	static char obp = obuf; / Output buffer pointer */
	268	#endif /* DYNAMIC */
	269
	270	/* Character-set items */
	271
	272	static int unicode = 0;
	273
	274	#ifndef NOCSETS
	275	#ifdef CK_ANSIC /* ANSI C prototypes... */
	276	extern CHAR (xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); / Character set */
	277	extern CHAR (xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); / translation functions */
	278	static CHAR (sxo)(CHAR); / Local translation functions */
	279	static CHAR (rxo)(CHAR); / for output (sending) terminal chars */
	280	static CHAR (sxi)(CHAR); / and for input (receiving) terminal chars. */
	281	static CHAR (*rxi)(CHAR);
	282	#else /* Not ANSI C... */
	283	extern CHAR (xls[MAXTCSETS+1][MAXFCSETS+1])(); / Character set */
	284	extern CHAR (xlr[MAXTCSETS+1][MAXFCSETS+1])(); / translation functions. */
	285	static CHAR (sxo)(); / Local translation functions */
	286	static CHAR (rxo)(); / for output (sending) terminal chars */
	287	static CHAR (sxi)(); / and for input (receiving) terminal chars. */
	288	static CHAR (*rxi)();
	289	#endif /* CK_ANSIC */
	290	extern int language; /* Current language. */
	291	static int langsv; /* For remembering language setting. */
	292	extern struct csinfo fcsinfo[]; /* File character set info. */
	293	extern int tcsr, tcsl; /* Terminal character sets, remote & local. */
	294	static int tcs; /* Intermediate ("transfer") character set. */
	295	static int tcssize = 0; /* Size of tcs */
	296	#ifdef UNICODE /* UTF-8 support */
	297	#ifdef CK_ANSIC
	298	extern int (xl_ufc[MAXFCSETS+1])(USHORT); / Unicode to FCS */
	299	extern USHORT (xl_fcu[MAXFCSETS+1])(CHAR); / FCS to Unicode */
	300	extern int (xuf)(USHORT); / Translation function UCS to FCS */
	301	extern USHORT (xfu)(CHAR); / Translation function FCS to UCS */
	302	#else
	303	extern int (*xl_ufc[MAXFCSETS+1])();
	304	extern USHORT (*xl_fcu[MAXFCSETS+1])();
	305	extern int (*xuf)();
	306	extern USHORT (*xfu)();
	307	#endif /* CK_ANSIC */
	308	#endif /* UNICODE */
	309	#endif /* NOCSETS */
	310
	311	static int printing = 0;
	312
	313	/*
	314	We do not need to parse and recognize escape sequences if we are being built
	315	without character-set support AND without APC support.
	316	*/
	317	#ifdef NOESCSEQ
	318	#ifdef XPRINT
	319	#undef XPRINT
	320	#endif /* XPRINT */
	321
	322	#else /* NOESCSEQ not defined from outside */
	323
	324	#ifdef NOCSETS /* No character sets */
	325	#ifndef CK_APC /* No APC */
	326	#ifndef XPRINT /* No transparent printing */
	327	#define NOESCSEQ /* So no escape sequence recognizer */
	328	#endif /* XPRINT */
	329	#endif /* CK_APC */
	330	#endif /* NOCSETS */
	331	#endif /* NOESCSEQ */
	332
	333	static int escseq = 0; /* 1 = Recognizer is active */
	334	static int inesc[2] = { 0, 0 }; /* State of sequence recognizer */
	335	static int oldesc[2] = { -1, -1 }; /* Previous state of recognizer */
	336
	337	#ifdef NOESCSEQ
	338	#define chkaes(x,y) 0
	339	#else
	340	/*
	341	As of C-Kermit 5A(178), the CONNECT command skips past ANSI escape sequences
	342	to avoid translating the characters within them. This allows the CONNECT
	343	command to work correctly with a host that uses a 7-bit ISO 646 national
	344	character set, in which characters like '[' would normally be translated
	345	into accented characters, ruining the terminal's interpretation (and
	346	generation) of escape sequences.
	347
	348	As of 5A(190), the CONNECT command responds to APC escape sequences
	349	(ESC _ text ESC \) if the user SETs TERMINAL APC ON or UNCHECKED, and the
	350	program was built with CK_APC defined.
	351
	352	Non-ANSI/ISO-compliant escape sequences are not handled. */
	353
	354	/* States for the escape-sequence recognizer. */
	355
	356	#define ES_NORMAL 0 /* Normal, not in an escape sequence */
	357	#define ES_GOTESC 1 /* Current character is ESC */
	358	#define ES_ESCSEQ 2 /* Inside an escape sequence */
	359	#define ES_GOTCSI 3 /* Inside a control sequence */
	360	#define ES_STRING 4 /* Inside DCS,OSC,PM, or APC string */
	361	#define ES_TERMIN 5 /* 1st char of string terminator */
	362
	363	/*
	364	ANSI escape sequence handling. Only the 7-bit form is treated, because
	365	translation is not a problem in the 8-bit environment, in which all GL
	366	characters are ASCII and no translation takes place. So we don't check
	367	for the 8-bit single-character versions of CSI, DCS, OSC, APC, or ST.
	368	Here is the ANSI sequence recognizer state table, followed by the code
	369	that implements it.
	370
	371	Definitions:
	372	CAN = Cancel 01/08 Ctrl-X
	373	SUB = Substitute 01/10 Ctrl-Z
	374	DCS = Device Control Sequence 01/11 05/00 ESC P
	375	CSI = Control Sequence Introducer 01/11 05/11 ESC [
	376	ST = String Terminator 01/11 05/12 ESC \
	377	OSC = Operating System Command 01/11 05/13 ESC ]
	378	PM = Privacy Message 01/11 05/14 ESC ^
	379	APC = Application Program Command 01/11 05/15 ESC _
	380
	381	ANSI escape sequence recognizer:
	382
	383	State Input New State ; Commentary
	384
	385	NORMAL (start) ; Start in NORMAL state
	386
	387	(any) CAN NORMAL ; ^X cancels
	388	(any) SUB NORMAL ; ^Z cancels
	389
	390	NORMAL ESC GOTESC ; Begin escape sequence
	391	NORMAL other ; NORMAL control or graphic character
	392
	393	GOTESC ESC ; Start again
	394	GOTESC [ GOTCSI ; CSI
	395	GOTESC P STRING ; DCS introducer, consume through ST
	396	GOTESC ] STRING ; OSC introducer, consume through ST
	397	GOTESC ^ STRING ; PM introducer, consume through ST
	398	GOTESC _ STRING ; APC introducer, consume through ST
	399	GOTESC 0..~ NORMAL ; 03/00 through 17/14 = Final character
	400	GOTESC other ESCSEQ ; Intermediate or ignored control character
	401
	402	ESCSEQ ESC GOTESC ; Start again
	403	ESCSEQ 0..~ NORMAL ; 03/00 through 17/14 = Final character
	404	ESCSEQ other ; Intermediate or ignored control character
	405
	406	GOTCSI ESC GOTESC ; Start again
	407	GOTCSI @..~ NORMAL ; 04/00 through 17/14 = Final character
	408	GOTCSI other ; Intermediate char or ignored control char
	409
	410	STRING ESC TERMIN ; Maybe have ST
	411	STRING other ; Consume all else
	412
	413	TERMIN \ NORMAL ; End of string
	414	TERMIN other STRING ; Still in string
	415	*/
	416
	417	#ifdef XPRINT /* Transparent print support */
	418	/*
	419	We can't just print each byte as it comes in because then the printer-off
	420	sequence would be sent to the printer. Thus we have to buffer up escape
	421	sequences and print them only when they are complete AND we know they are
	422	not the printer-off sequence. All printing is done via zsoutx(ZMFILE,s,n).
	423	This allows for strings that contain NULs. Don't mix calls to zsoutx() with
	424	calls to zchout(), or the output will be scrambled. Also note that when
	425	printing a saved-up escape sequence, we never print its final character
	426	because that will be printed in the mainline code, upon return from
	427	chkaes(). Note that the printer-on sequence is passed to the screen; this
	428	is unavoidable, since we don't know what it is until after we get to the
	429	end, and for screen display purposes we can't buffer up escape sequences
	430	for numerous reasons. Therefore we also must output the printer-off
	431	sequence, otherwise a real terminal or emulator will be stuck in print mode.
	432	*/
	433	extern int tt_print;
	434	#define ESCBUFLEN 63
	435	static char escbuf[ESCBUFLEN+1] = { NUL, NUL };
	436	static int escbufc = 0;
	437	static int dontprint = 0;
	438
	439	VOID
	440	printon() { /* Turn printing on */
	441	int x, pp;
	442	char * p;
	443	extern int printpipe, noprinter;
	444	extern char * printername;
	445
	446	if (noprinter) {
	447	debug(F110,"PRINTER ON NOPRINTER","",0);
	448	return;
	449	}
	450	p = printername;
	451	pp = printpipe;
	452	if (!p) p = "";
	453	if (!*p) {
	454	#ifdef ANYBSD
	455	p = "lpr";
	456	#else
	457	p = "lp";
	458	#endif /* ANYBSD */
	459	pp = 1;
	460	debug(F110,"PRINTER DEFAULT",p,0);
	461	}
	462	debug(F111,"PRINTER ON",p,pp);
	463	if (pp) { /* Printing to pipe */
	464	x = zxcmd(ZMFILE,p);
	465	} else { /* Append to file */
	466	struct filinfo xx;
	467	xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0;
	468	xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = NUL;
	469	xx.lblopts = 0;
	470	x = zopeno(ZMFILE,p,NULL,&xx);
	471	}
	472	debug(F101,"PRINTER OPEN","",x);
	473	printing = 1;
	474	}
	475
	476	VOID
	477	printoff() { /* Turn printing off */
	478	int x;
	479	extern int noprinter;
	480	if (noprinter) {
	481	printing = 0;
	482	debug(F100,"PRINTER OFF NOPRINTER","",0);
	483	return;
	484	}
	485	debug(F100,"PRINTER OFF","",0);
	486	if (printing) {
	487	x = zclose(ZMFILE);
	488	debug(F101,"PRINTER CLOSE","",x);
	489	printing = 0;
	490	}
	491	}
	492	#endif /* XPRINT */
	493
	494	/*
	495	C H K A E S -- Check ANSI Escape Sequence.
	496
	497	Call with EACH character in input stream.
	498	src = 0 means c is incoming from remote; 1 = char from keyboard.
	499	Sets global inesc[src] variable according to escape sequence state.
	500	Returns 0 normally, 1 if an APC sequence is to be executed.
	501	Handles transparent printing internally.
	502	*/
	503	int
	504	#ifdef CK_ANSIC
	505	chkaes(char c, int src)
	506	#else
	507	chkaes(c,src) char c; int src;
	508	#endif /* CK_ANSIC */
	509	/* chkaes */ {
	510
	511	debug(F111,"chkaes entry inesc",ckitoa(src),inesc[src]);
	512	debug(F101,"chkaes c","",c);
	513
	514	if (src < 0 \|\| src > 1) /* Don't allow bad args. */
	515	return(0);
	516
	517	oldesc[src] = inesc[src]; /* Remember previous state */
	518
	519	#ifdef XPRINT
	520	if (inesc[src] && !src) { /* Save up escape seq for printing */
	521	if (!c) return(0); /* Ignore NULs */
	522	if (escbufc < ESCBUFLEN) {
	523	escbuf[escbufc++] = c;
	524	escbuf[escbufc] = NUL;
	525	debug(F111,"ESCBUF 1",escbuf,escbufc);
	526	} else { /* Buffer overrun */
	527	if (printing && escbufc) /* Print what's there so far */
	528	zsoutx(ZMFILE,escbuf,escbufc);
	529	escbufc = 1; /* clear it out */
	530	escbuf[0] = c; /* and start off fresh buffer */
	531	escbuf[1] = NUL; /* with this character. */
	532	}
	533	}
	534	#endif /* XPRINT */
	535
	536	if (c == CAN \|\| c == SUB) { /* CAN and SUB cancel any sequence */
	537	#ifdef XPRINT
	538	if (!src) {
	539	if (printing && escbufc > 1)
	540	zsoutx(ZMFILE,escbuf,escbufc-1);
	541	escbufc = 0; /* Clear buffer */
	542	escbuf[0] = NUL;
	543	}
	544	#endif /* XPRINT */
	545	inesc[src] = ES_NORMAL;
	546	} else /* Otherwise */
	547
	548	switch (inesc[src]) { /* enter state switcher */
	549	case ES_NORMAL: /* NORMAL state */
	550	if (c == ESC) { /* Got an ESC */
	551	inesc[src] = ES_GOTESC; /* Change state to GOTESC */
	552	#ifdef XPRINT
	553	if (!src) {
	554	escbufc = 1; /* Clear escape sequence buffer */
	555	escbuf[0] = c; /* and deposit the ESC */
	556	escbuf[1] = NUL;
	557	debug(F111,"ESCBUF 2",escbuf,escbufc);
	558	}
	559	#endif /* XPRINT */
	560	}
	561	break; /* Otherwise stay in NORMAL state */
	562
	563	case ES_GOTESC: /* GOTESC state - prev char was ESC*/
	564	if (c == '[') { /* Left bracket after ESC is CSI */
	565	inesc[src] = ES_GOTCSI; /* Change to GOTCSI state */
	566	} else if (c == 'P' \|\| (c > 0134 && c < 0140)) { /* P, ], ^, or _ */
	567	inesc[src] = ES_STRING; /* Switch to STRING-absorption state */
	568	#ifdef XPRINT
	569	debug(F111,"ESCBUF STRING",escbuf,escbufc);
	570	#endif /* XPRINT */
	571	#ifdef CK_APC
	572	/* If APC not disabled */
	573	if (!src && c == '_' && (apcstatus & APC_ON)) {
	574	debug(F100,"CONNECT APC begin","",0);
	575	apcactive = APC_REMOTE; /* Set APC-Active flag */
	576	apclength = 0; /* and reset APC buffer pointer */
	577	}
	578	#endif /* CK_APC */
	579	} else if (c > 057 && c < 0177) { /* Final character '0' thru '~' */
	580	inesc[src] = ES_NORMAL; /* Back to normal */
	581	#ifdef XPRINT
	582	if (!src) {
	583	if (printing && escbufc > 1) {
	584	/* Dump esc seq buf to printer */
	585	zsoutx(ZMFILE,escbuf,escbufc-1);
	586	debug(F111,"ESCBUF PRINT 1",escbuf,escbufc);
	587	}
	588
	589	escbufc = 0; /* Clear parameter buffer */
	590	escbuf[0] = NUL;
	591	}
	592	#endif /* XPRINT */
	593	} else if (c != ESC) { /* ESC in an escape sequence... */
	594	inesc[src] = ES_ESCSEQ; /* starts a new escape sequence */
	595	}
	596	break; /* Intermediate or ignored ctrl char */
	597
	598	case ES_ESCSEQ: /* ESCSEQ -- in an escape sequence */
	599	if (c > 057 && c < 0177) { /* Final character '0' thru '~' */
	600	inesc[src] = ES_NORMAL; /* Return to NORMAL state. */
	601	#ifdef XPRINT
	602	if (!src) {
	603	if (printing && escbufc > 1) {
	604	zsoutx(ZMFILE,escbuf,escbufc-1);
	605	debug(F111,"ESCBUF PRINT 2",escbuf,escbufc);
	606	}
	607	escbufc = 0; /* Clear escseq buffer */
	608	escbuf[0] = NUL;
	609	}
	610	#endif /* XPRINT */
	611	} else if (c == ESC) { /* ESC ... */
	612	inesc[src] = ES_GOTESC; /* starts a new escape sequence */
	613	}
	614	break; /* Intermediate or ignored ctrl char */
	615
	616	case ES_GOTCSI: /* GOTCSI -- In a control sequence */
	617	if (c > 077 && c < 0177) { /* Final character '@' thru '~' */
	618	#ifdef XPRINT
	619	if (!src && tt_print) { /* Printer enabled? */
	620	if (c == 'i') { /* Final char is "i"? */
	621	char * p = (char *) (escbuf + escbufc - 4);
	622	if (!strncmp(p, "\033[5i", 4)) { /* Turn printer on */
	623	printon();
	624	} else if (!strncmp(p, "\033[4i", 4)) { /* Or off... */
	625	int i;
	626	printoff(); /* Turn off printer. */
	627	dontprint = 1;
	628	for (i = 0; i < escbufc; i++) /* And output the */
	629	ckcputc(escbuf[i]); /* sequence. */
	630	} else if (printing && escbufc > 1) {
	631	zsoutx(ZMFILE,escbuf,escbufc-1);
	632	debug(F011,"ESCBUF PRINT 3",escbuf,escbufc);
	633	}
	634	} else if (printing && escbufc > 1) {
	635	zsoutx(ZMFILE,escbuf,escbufc-1);
	636	debug(F111,"ESCBUF PRINT 4",escbuf,escbufc);
	637	}
	638	}
	639	if (!src) {
	640	escbufc = 0; /* Clear esc sequence buffer */
	641	escbuf[0] = NUL;
	642	}
	643	#endif /* XPRINT */
	644	inesc[src] = ES_NORMAL; /* Return to NORMAL. */
	645	} else if (c == ESC) { /* ESC ... */
	646	inesc[src] = ES_GOTESC; /* starts over. */
	647	}
	648	break;
	649
	650	case ES_STRING: /* Inside a string */
	651	if (c == ESC) /* ESC may be 1st char of terminator */
	652	inesc[src] = ES_TERMIN; /* Go see. */
	653	#ifdef CK_APC
	654	else if (apcactive) { /* If in APC */
	655	if (apclength < apcbuflen) { /* and there is room... */
	656	apcbuf[apclength++] = c; /* deposit this character. */
	657	} else { /* Buffer overrun */
	658	apcactive = 0; /* Discard what we got */
	659	apclength = 0; /* and go back to normal */
	660	apcbuf[0] = 0; /* Not pretty, but what else */
	661	inesc[src] = ES_NORMAL; /* can we do? (ST might not come) */
	662	}
	663	}
	664	#endif /* CK_APC */
	665	break; /* Absorb all other characters. */
	666
	667	case ES_TERMIN: /* Maybe a string terminator */
	668	if (c == '\\') { /* which must be backslash */
	669	inesc[src] = ES_NORMAL; /* If so, back to NORMAL */
	670	#ifdef XPRINT
	671	if (!src) {
	672	if (printing && escbufc > 1) { /* If printing... */
	673	/* Print esc seq buffer */
	674	zsoutx(ZMFILE,escbuf,escbufc-1);
	675	debug(F111,"ESCBUF PRINT 5",escbuf,escbufc);
	676	}
	677	escbufc = 0; /* Clear escseq buffer */
	678	escbuf[0] = NUL;
	679	}
	680	#endif /* XPRINT */
	681	#ifdef CK_APC
	682	if (!src && apcactive) { /* If it was an APC string, */
	683	debug(F101,"CONNECT APC terminated","",c);
	684	apcbuf[apclength] = NUL; /* terminate it and then ... */
	685	return(1);
	686	}
	687	#endif /* CK_APC */
	688	} else { /* It's not a backslash so... */
	689	inesc[src] = ES_STRING; /* back to string absorption. */
	690	#ifdef CK_APC
	691	if (apcactive) { /* In APC string */
	692	if (apclength+1 < apcbuflen) { /* If enough room */
	693	apcbuf[apclength++] = ESC; /* deposit the Esc */
	694	apcbuf[apclength++] = c; /* and this character too. */
	695	} else { /* Buffer overrun */
	696	apcactive = 0;
	697	apclength = 0;
	698	apcbuf[0] = 0;
	699	inesc[src] = ES_NORMAL;
	700	}
	701	}
	702	#endif /* CK_APC */
	703	}
	704	} /* switch() */
	705	debug(F111,"chkaes exit inesc",ckitoa(src),inesc[src]);
	706	return(0);
	707	}
	708	#endif /* NOESCSEQ */
	709
	710	/* C K C P U T C -- C-Kermit CONNECT Put Character to Screen */
	711	/*
	712	Output is buffered to avoid slow screen writes on fast connections.
	713	*/
	714	static int
	715	ckcputf() { /* Dump the console output buffer */
	716	int x = 0;
	717	if (obc > 0) /* If we have any characters, */
	718	x = conxo(obc,obuf); /* dump them, */
	719	obp = obuf; /* reset the pointer */
	720	obc = 0; /* and the counter. */
	721	return(x); /* Return conxo's return code */
	722	}
	723
	724	/*
	725	NOTE: This is probably the right place for character-set translation,
	726	rather than down below in the mainline code. ckcputc() would act like
	727	xpnbyte() in ckcfns.c, and ckcgetc() would act like xgnbyte(). This
	728	would shield the rest of the code from all the complexities of many-to-one
	729	and one-to-many conversions, and would allow handling of Kanji and other
	730	CJK sets along with UTF-8 and the rest.
	731	*/
	732	int
	733	ckcputc(c) int c; {
	734	int x;
	735
	736	obp++ = c & 0xff; / Deposit the character */
	737	obc++; /* Count it */
	738	if (ibc == 0 \|\| /* If input buffer about empty */
	739	obc == OBUFL) { /* or output buffer full */
	740	debug(F101,"CONNECT CKCPUTC obc","",obc);
	741	x = conxo(obc,obuf); /* dump the buffer, */
	742	obp = obuf; /* reset the pointer */
	743	obc = 0; /* and the counter. */
	744	return(x); /* Return conxo's return code */
	745	} else return(0);
	746	}
	747
	748	/* C K C G E T C -- C-Kermit CONNECT Get Character */
	749	/*
	750	Buffered read from communication device.
	751	Returns the next character, refilling the buffer if necessary.
	752	On error, returns ttinc's return code (see ttinc() description).
	753	Dummy argument for compatible calling conventions with ttinc()
	754	so a pointer to this function can be passed to tn_doop().
	755	*/
	756	int
	757	ckcgetc(dummy) int dummy; {
	758	int c, n;
	759	#ifdef CK_SSL
	760	extern int ssl_active_flag, tls_active_flag;
	761	#endif /* CK_SSL */
	762
	763	#ifdef CK_ENCRYPTION
	764	/* No buffering for possibly encrypted connections */
	765	if (network && IS_TELNET() && TELOPT_ME(TELOPT_AUTHENTICATION))
	766	return(ttinc(0));
	767	#endif /* CK_ENCRYPTION */
	768	#ifdef CK_SSL
	769	if (ssl_active_flag \|\| tls_active_flag)
	770	return(ttinc(0));
	771	#endif /* CK_SSL */
	772
	773	if (ibc < 1) { /* Need to refill buffer? */
	774	ibc = 0; /* Yes, reset count */
	775	ibp = ibuf; /* and buffer pointer */
	776	c = ttinc(0); /* Read one character, blocking */
	777	if (c < 0) { /* If error, return error code */
	778	return(c);
	779	} else { /* Otherwise, got one character */
	780	ibp++ = c; / Advance buffer pointer */
	781	ibc++; /* and count. */
	782	}
	783	if ((n = ttchk()) > 0) { /* Any more waiting? */
	784	if (n > (IBUFL - ibc)) /* Get them all at once. */
	785	n = IBUFL - ibc; /* Don't overflow buffer */
	786	if ((n = ttxin(n,(CHAR *)ibp)) > 0) {
	787	ibc += n; /* Advance counter */
	788	}
	789	} else if (n < 0) { /* Error? */
	790	return(n); /* Return the error code */
	791	}
	792	ibp = ibuf; /* Point to beginning of buffer */
	793	}
	794	c = ibp++ & 0xff; / Get next character from buffer */
	795	ibc--; /* Reduce buffer count */
	796	/* debug(F000,"CKCGETC","",c); */
	797	return(c); /* Return the character */
	798	}
	799
	800	/*
	801	Keyboard handling, buffered for speed, which is needed when C-Kermit is
	802	in CONNECT mode between two other computers that are transferring data.
	803	*/
	804	static char kbp; / Keyboard input buffer pointer */
	805	static int kbc; /* Keyboard input buffer count */
	806
	807	#ifdef CK_SMALL /* Keyboard input buffer length */
	808	#define KBUFL 32 /* Small for PDP-11 UNIX */
	809	#else
	810	#define KBUFL 257 /* Regular kernel size for others */
	811	#endif /* CK_SMALL */
	812
	813	#ifdef DYNAMIC
	814	static char *kbuf = NULL;
	815	#else
	816	static char kbuf[KBUFL];
	817	#endif /* DYNAMIC */
	818
	819	/* Macro for reading keystrokes. */
	820
	821	#define CONGKS() (((--kbc)>=0) ? ((int)(*kbp++) & 0377) : kbget())
	822
	823	/*
	824	Note that we call read() directly here, normally a no-no, but in this case
	825	we know it's UNIX and we're only doing what coninc(0) would have done,
	826	except we're reading a block of characters rather than just one. There is,
	827	at present, no conxin() analog to ttxin() for chunk reads, and instituting
	828	one would only add function-call overhead as it would only be a wrapper for
	829	a read() call anyway.
	830
	831	Another note: We stick in this read() till the user types something.
	832	But we know they already did, since select() said so. Therefore something
	833	would need to be mighty wrong before we get stuck here.
	834	*/
	835	static int /* Keyboard buffer filler */
	836	kbget() {
	837	#ifdef EINTR
	838	int tries = 10; /* If read() is interrupted, */
	839	int ok = 0;
	840	while (tries-- > 0) { /* try a few times... */
	841	#endif /* EINTR */
	842	kbc = conchk(); /* How many chars waiting? */
	843	debug(F101,"kbget kbc","",kbc);
	844	if (kbc < 1)
	845	kbc = 1; /* If none or dunno, wait for one. */
	846	else if (kbc > KBUFL) /* If too many, */
	847	kbc = KBUFL; /* only read this many. */
	848	if ((kbc = read(0, kbuf, kbc)) < 1) { /* Now read it/them. */
	849	debug(F101,"CONNECT kbget errno","",errno); /* Got an error. */
	850	#ifdef EINTR
	851	if (errno == EINTR) /* Interrupted system call. */
	852	continue; /* Try again, up to limit. */
	853	else /* Something else. */
	854	#endif /* EINTR */
	855	return(-1); /* Pass along read() error. */
	856	}
	857	#ifdef EINTR
	858	else { ok = 1; break; }
	859	}
	860	if (!ok) return(-1);
	861	#endif /* EINTR */
	862	kbp = kbuf; /* Adjust buffer pointer, */
	863	kbc--; /* count, */
	864	return((int)(kbp++) & 0377); / and return first character. */
	865	}
	866
	867	#ifdef BEBOX
	868	/*
	869	* CreateSocketPair --
	870	*
	871	* This procedure creates a connected socket pair
	872	*
	873	* Results:
	874	* 0 if OK, the error if not OK.
	875	*
	876	* Side effects:
	877	* None
	878	*/
	879	int
	880	socketpair(int *pair) {
	881	int servsock;
	882	int val;
	883	struct sockaddr_in serv_addr, cli_addr;
	884	extern char myipaddr[];
	885
	886	debug(F110,"socketpair",myipaddr,0);
	887
	888	if (myipaddr[0] == 0)
	889	getlocalipaddr();
	890
	891	servsock = socket(AF_INET, SOCK_STREAM, 0);
	892	if (servsock == 0) {
	893	return h_errno;
	894	}
	895	debug(F111,"socketpair","socket",servsock);
	896
	897	memset(&serv_addr, 0, sizeof(serv_addr));
	898	serv_addr.sin_family = AF_INET;
	899	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	900	serv_addr.sin_port = htons(0);
	901
	902	val = sizeof(serv_addr);
	903	if (bind(servsock, (struct sockaddr *) &serv_addr, val) < 0) {
	904	closesocket(servsock);
	905	return h_errno;
	906	}
	907	debug(F111,"socketpair","bind",0);
	908
	909	listen(servsock, 1);
	910	debug(F111,"socketpair","listen",0);
	911
	912	if (getsockname(servsock, (struct sockaddr *) &serv_addr, &val) < 0) {
	913	closesocket(servsock);
	914	return h_errno;
	915	}
	916	debug(F111,"socketpair","getsockname",0);
	917
	918	pair[0] = socket(AF_INET, SOCK_STREAM, 0);
	919	if (pair[0] == 0) {
	920	closesocket(servsock);
	921	return h_errno;
	922	}
	923	debug(F111,"socketpair","socket",pair[0]);
	924
	925	memset(&cli_addr, 0, sizeof(cli_addr));
	926	cli_addr.sin_family = AF_INET;
	927	cli_addr.sin_addr.s_addr = inet_addr(myipaddr[0]?myipaddr:"127.0.0.1");
	928	cli_addr.sin_port = serv_addr.sin_port;
	929
	930	if (connect(pair[0],(struct sockaddr *) &cli_addr, sizeof(cli_addr)) < 0) {
	931	closesocket(pair[0]);
	932	closesocket(servsock);
	933	return h_errno;
	934	}
	935	debug(F111,"socketpair","connect",0);
	936
	937	pair[1] = accept(servsock, (struct sockaddr *) &serv_addr, &val);
	938	if (pair[1] == 0) {
	939	closesocket(pair[0]);
	940	closesocket(servsock);
	941	return h_errno;
	942	}
	943	debug(F111,"socketpair","accept",pair[1]);
	944
	945	closesocket(servsock);
	946	debug(F111,"socketpair","closesocket",0);
	947	return 0;
	948	}
	949
	950	long
	951	kbdread(void * param) {
	952	int sock = (int) param;
	953	char ch;
	954	int rc = 0;
	955
	956	debug(F111,"kbdread","sock",sock);
	957
	958	while (rc >= 0) {
	959	rc = read(fileno(stdin), &ch, 1); /* Read a character. */
	960	if (rc > 0) {
	961	rc = send(sock,&ch,1,0);
	962	/* debug(F000,"kbdread","send()",ch); */
	963	printf("\r\ngot: %c rc = %d\r\n",ch,rc);
	964	} else
	965	msleep(100);
	966	}
	967	debug(F110,"kbdread","terminating",0);
	968	return(rc);
	969	}
	970	#endif /* BEBOX */
	971
	972	#ifdef CKLEARN
	973	static VOID
	974	learnchar(c) int c; { /* Learned script keyboard character */
	975	int cc;
	976	char xbuf[8];
	977
	978	if (!learning \|\| !learnfp)
	979	return;
	980
	981	switch (learnst) { /* Learn state... */
	982	case 0: /* Neutral */
	983	case 1: /* Net */
	984	if (learnbc > 0) { /* Have net characters? */
	985	char buf[LEARNBUFSIZ];
	986	int i, j, n;
	987	ULONG t;
	988
	989	t = (ULONG) time(0); /* Calculate INPUT timeout */
	990	j = t - learnt1;
	991	j += (j / 4) > 0 ? (j / 4) : 1; /* Add some slop */
	992	if (j < 2) j = 2; /* 2 seconds minimum */
	993
	994	fputs("\nINPUT ",learnfp); /* Give INPUT command for them */
	995	fputs(ckitoa(j),learnfp);
	996	fputs(" {",learnfp);
	997	learnt1 = t;
	998
	999	n = LEARNBUFSIZ;
	1000	if (learnbc < LEARNBUFSIZ) { /* Circular buffer */
	1001	n = learnbc; /* hasn't wrapped yet. */
	1002	learnbp = 0;
	1003	}
	1004	j = 0; /* Copy to linear buffer */
	1005	for (i = 0; i < n; i++) { /* Number of chars in circular buf */
	1006
	1007	cc = learnbuf[(learnbp + i) % LEARNBUFSIZ];
	1008
	1009	/* Later account for prompts that end with a newline? */
	1010
	1011	if (cc == CR && j > 0) {
	1012	if (buf[j-1] != LF)
	1013	j = 0;
	1014	}
	1015	buf[j++] = cc;
	1016	}
	1017	for (i = 0; i < j; i++) { /* Now copy out the buffer */
	1018	cc = buf[i]; /* interpreting control chars */
	1019	if (cc == 0) { /* We don't INPUT NULs */
	1020	continue;
	1021	} else if (cc < SP \|\| /* Controls need quoting */
	1022	(cc > 126 && cc < 160)) {
	1023	ckmakmsg(xbuf,8,"\\{",ckitoa((int)cc),"}",NULL);
	1024	fputs(xbuf,learnfp);
	1025	} else { /* Plain character */
	1026	putc(cc,learnfp);
	1027	}
	1028	}
	1029	fputs("}\nIF FAIL STOP 1 INPUT timeout",learnfp);
	1030	learnbc = 0;
	1031	}
	1032	learnbp = 0;
	1033	fputs("\nPAUSE 1\nOUTPUT ",learnfp); /* Emit OUTPUT and fall thru */
	1034
	1035	case 2: /* Already in Keyboard state */
	1036	if (c == 0) {
	1037	fputs("\\N",learnfp);
	1038	} else if (c == -7) {
	1039	fputs("\\B",learnfp);
	1040	} else if (c == -8) {
	1041	fputs("\\L",learnfp);
	1042	} else if (c < SP \|\| (c > 126 && c < 160)) {
	1043	ckmakmsg(xbuf,8,"\\{",ckitoa((int)c),"}",NULL);
	1044	fputs(xbuf,learnfp);
	1045	} else {
	1046	putc(c,learnfp);
	1047	}
	1048	}
	1049	}
	1050	#endif /* CKLEARN */
	1051
	1052	static int printbar = 0;
	1053
	1054	#define OUTXBUFSIZ 15
	1055	static CHAR inxbuf[OUTXBUFSIZ+1]; /* Host-to-screen expansion buffer */
	1056	static int inxcount = 0; /* and count */
	1057	static CHAR outxbuf[OUTXBUFSIZ+1]; /* Keyboard-to-host expansion buf */
	1058	static int outxcount = 0; /* and count */
	1059
	1060	int
	1061	conect() {
	1062	int rc = 0; /* Return code: 0 = fail, 1 = OK */
	1063	int i, x = 0, prev = -1; /* Reason code in cx_status */
	1064	#ifdef CKLEARN
	1065	int crflag = 0;
	1066	#endif /* CKLEARN */
	1067	register int c = -1, c2, csave; /* Characters */
	1068	#ifdef TNCODE
	1069	int tx; /* For Telnet negotiations */
	1070	#endif /* TNCODE */
	1071	int apcrc = 0; /* For APC and transparent print */
	1072	int n, kbin, scrnout; /* select() items... */
	1073	fd_set in, out, err; /* File descriptor sets */
	1074	int gotnet = 0; /* Flag for net ready to read */
	1075	int gotkbd = 0; /* Flag for keyboard ready to read */
	1076	int oldprt = 0; /* Used with printing */
	1077	int msgflg = 0;
	1078	char cbuf[2]; /* Ditto */
	1079
	1080	#ifdef BEBOX
	1081	int tid = 0; /* Thread ID */
	1082	int pair[2]; /* Socket Pair */
	1083	CHAR ch;
	1084	CHAR buf[64];
	1085	#endif /* BEBOX */
	1086
	1087	cx_status = CSX_INTERNAL;
	1088	debok = 1;
	1089
	1090	#ifdef BEBOX
	1091	{
	1092	/* Create a socket pair to be used for the keyboard input */
	1093	if (socketpair(pair)) {
	1094	debug(F110,"conect","unable to create socket pair",0);
	1095	return(-1);
	1096	}
	1097	debug(F111,"connect","socket pair[0]",pair[0]);
	1098	debug(F111,"connect","socket pair[1]",pair[1]);
	1099
	1100	/* Assign one end of the socket to kbin */
	1101	kbin = pair[0];
	1102	tid = spawn_thread(kbdread,
	1103	"Kbd to Socket Pair",
	1104	B_NORMAL_PRIORITY,
	1105	(void *)pair[1]
	1106	);
	1107	resume_thread(tid);
	1108	debug(F110,"connect","tid",tid);
	1109	}
	1110	#else /* BEBOX */
	1111	kbin = fileno(stdin); /* stdin file descriptor */
	1112	#endif /* BEBOX */
	1113
	1114	scrnout = fileno(stdout); /* stdout file descriptor */
	1115
	1116	#ifdef CK_TRIGGER
	1117	makestr(&triggerval,NULL); /* Reset trigger */
	1118	#endif /* CK_TRIGGER */
	1119
	1120	#ifdef XPRINT
	1121	escbufc = 0; /* Reset esc-sequence buffer */
	1122	escbuf[0] = NUL;
	1123	#endif /* XPRINT */
	1124	cbuf[1] = NUL;
	1125
	1126	ttimoff(); /* Turn off any timer interrupts */
	1127	if (!local) { /* Be sure we're not in remote mode */
	1128	#ifdef NETCONN
	1129	#ifdef NEWFTP
	1130	if (ftpisconnected())
	1131	printf("Sorry, you can't CONNECT to an FTP server\n");
	1132	else
	1133	#endif /* NEWFTP */
	1134	printf("Sorry, you must SET LINE or SET HOST first\n");
	1135	#else
	1136	printf("Sorry, you must SET LINE first\n");
	1137	#endif /* NETCONN */
	1138	return(0);
	1139	}
	1140	if (speed < 0L && network == 0 && ttfdflg == 0) {
	1141	printf("Sorry, you must SET SPEED first\n");
	1142	return(0);
	1143	}
	1144	#ifdef TCPSOCKET
	1145	if (network && !ttpipe && (nettype != NET_TCPB && nettype != NET_PTY)) {
	1146	printf("Sorry, network type not supported\n");
	1147	return(0);
	1148	}
	1149	#endif /* TCPSOCKET */
	1150
	1151	#ifdef DYNAMIC
	1152	if (!ibuf) {
	1153	if (!(ibuf = malloc(IBUFL+1))) { /* Allocate input line buffer */
	1154	printf("Sorry, CONNECT input buffer can't be allocated\n");
	1155	return(0);
	1156	} else {
	1157	ibp = ibuf;
	1158	ibc = 0;
	1159	}
	1160	}
	1161	if (!obuf) {
	1162	if (!(obuf = malloc(OBUFL+1))) { /* Allocate output line buffer */
	1163	printf("Sorry, CONNECT output buffer can't be allocated\n");
	1164	return(0);
	1165	} else {
	1166	obp = obuf;
	1167	obc = 0;
	1168	}
	1169	}
	1170	if (!kbuf) {
	1171	if (!(kbuf = malloc(KBUFL+1))) { /* Allocate keyboard input buffer */
	1172	printf("Sorry, CONNECT keyboard buffer can't be allocated\n");
	1173	return(0);
	1174	}
	1175	}
	1176	if (!temp) {
	1177	if (!(temp = malloc(TMPLEN+1))) { /* Allocate temporary buffer */
	1178	printf("Sorry, CONNECT temporary buffer can't be allocated\n");
	1179	return(0);
	1180	}
	1181	}
	1182	#else
	1183	obp = obuf;
	1184	obc = 0;
	1185	#endif /* DYNAMIC */
	1186
	1187	kbp = kbuf; /* Always clear these. */
	1188	kbp = NUL; / No need to preserve them between */
	1189	kbc = 0; /* CONNECT sessions. */
	1190
	1191	#ifdef DEBUG
	1192	if (deblog) {
	1193	debug(F101,"CONNECT conect entry ttyfd","",ttyfd);
	1194	debug(F101,"CONNECT conect entry ibc","",ibc);
	1195	debug(F101,"CONNECT conect entry obc","",obc);
	1196	debug(F101,"CONNECT conect entry kbc","",kbc);
	1197	#ifdef CK_TRIGGER
	1198	debug(F110,"CONNECT conect trigger",tt_trigger[0],0);
	1199	#endif /* CK_TRIGGER */
	1200	if (ttyfd > -1) {
	1201	n = ttchk();
	1202	debug(F101,"CONNECT conect entry ttchk","",n);
	1203	}
	1204	}
	1205	#endif /* DEBUG */
	1206
	1207	if (ttyfd < 0) { /* If communication device not open */
	1208	#ifdef TTLEBUF
	1209	int n = le_inbuf();
	1210	debug(F111,"CONNECT le_inbuf()","ttyfd < 0",n);
	1211	if (n > 0) {
	1212	while (n--) {
	1213	CHAR ch;
	1214	le_getchar(&ch);
	1215	conoc(ch);
	1216	}
	1217	return(0);
	1218	}
	1219	#endif /* TTLEBUF */
	1220
	1221	debug(F101,"CONNECT ttnproto","",ttnproto);
	1222	debug(F111,"CONNECT opening",ttname,0); /* Open it now */
	1223	if (ttopen(ttname,
	1224	&local,
	1225	network ? -nettype : mdmtyp,
	1226	0
	1227	) < 0) {
	1228	ckmakmsg(temp,TMPLEN,"Sorry, can't open ",ttname,NULL,NULL);
	1229	perror(temp);
	1230	debug(F110,"CONNECT open failure",ttname,0);
	1231	return(0);
	1232	}
	1233
	1234	#ifdef IKS_OPTION
	1235	/* If peer is in Kermit server mode, return now. */
	1236	if (TELOPT_SB(TELOPT_KERMIT).kermit.u_start) {
	1237	cx_status = CSX_IKSD;
	1238	return(0);
	1239	}
	1240	#endif /* IKS_OPTION */
	1241	}
	1242	dohangup = 0; /* Hangup not requested yet */
	1243
	1244	msgflg = !quiet
	1245	#ifdef CK_APC
	1246	&& !apcactive
	1247	#endif /* CK_APC */
	1248	;
	1249
	1250	if (msgflg) {
	1251	#ifdef NETCONN
	1252	if (network) {
	1253	#ifdef CK_ENCRYPTION
	1254	extern int me_encrypt, u_encrypt;
	1255	if (ck_tn_encrypting() && ck_tn_decrypting())
	1256	printf("SECURE connection to host %s",ttname);
	1257	else
	1258	#endif /* CK_ENCRYPTION */
	1259	if (ttpipe \|\| ttpty)
	1260	printf("Connecting via command \"%s\"",ttname);
	1261	else
	1262	printf("Connecting to host %s",ttname);
	1263	} else {
	1264	#endif /* NETCONN */
	1265	printf("Connecting to %s",ttname);
	1266	if (speed > -1L) printf(", speed %ld",speed);
	1267	#ifdef NETCONN
	1268	}
	1269	#endif /* NETCONN */
	1270	if (tt_escape) {
	1271	printf("\r\n");
	1272	shoesc(escape);
	1273	printf("Type the escape character followed by C to get back,\r\n");
	1274	printf("or followed by ? to see other options.\r\n");
	1275	} else {
	1276	printf(".\r\n\nESCAPE CHARACTER IS DISABLED\r\n\n");
	1277	}
	1278	if (seslog) {
	1279	extern int slogts;
	1280	char * s = "";
	1281	switch (sessft) {
	1282	case XYFT_D:
	1283	s = "debug"; break;
	1284	case XYFT_T:
	1285	s = slogts ? "timestamped-text" : "text"; break;
	1286	default:
	1287	s = "binary";
	1288	}
	1289	printf("Session Log: %s, %s\r\n",sesfil,s);
	1290	}
	1291	if (debses) printf("Debugging Display...)\r\n");
	1292	}
	1293
	1294	/* Condition console terminal and communication line */
	1295
	1296	if (conbin((char)escape) < 0) {
	1297	printf("Sorry, can't condition console terminal\n");
	1298	fflush(stdout);
	1299	return(0);
	1300	}
	1301	debug(F101,"CONNECT cmask","",cmask);
	1302	debug(F101,"CONNECT cmdmsk","",cmdmsk);
	1303	debug(F101,"CONNECT speed before ttvt","",speed);
	1304	if ((n = ttvt(speed,flow)) < 0) { /* Enter "virtual terminal" mode */
	1305	if (!network) {
	1306	debug(F101,"CONNECT ttvt","",n);
	1307	tthang(); /* Hang up and close the device. */
	1308	ttclos(0);
	1309	dologend();
	1310	if (ttopen(ttname, /* Open it again... */
	1311	&local,
	1312	network ? -nettype : mdmtyp,
	1313	0
	1314	) < 0) {
	1315	cx_status = CSX_INTERNAL;
	1316	ckmakmsg(temp,TMPLEN,"Sorry, can't reopen ",ttname,NULL,NULL);
	1317	perror(temp);
	1318	return(0);
	1319	}
	1320	#ifdef IKS_OPTION
	1321	if (TELOPT_SB(TELOPT_KERMIT).kermit.u_start) {
	1322	cx_status = CSX_IKSD;
	1323	return(0);
	1324	}
	1325	#endif /* IKS_OPTION */
	1326
	1327	if (ttvt(speed,flow) < 0) { /* Try virtual terminal mode again. */
	1328	conres(); /* Failure this time is fatal. */
	1329	printf("Sorry, Can't condition communication line\n");
	1330	cx_status = CSX_INTERNAL;
	1331	return(0);
	1332	}
	1333	}
	1334	}
	1335	debug(F101,"CONNECT ttvt ok, escape","",escape);
	1336
	1337	/* Despite ttvt() this is still needed in HP-UX */
	1338	/* because of the HP-9000 <RESET> key.*/
	1339
	1340	signal(SIGINT, SIG_IGN);
	1341	signal(SIGQUIT, SIG_IGN);
	1342
	1343	debug(F101,"CONNECT carrier-watch","",carrier);
	1344	if ((!network
	1345	#ifdef TN_COMPORT
	1346	\|\| istncomport()
	1347	#endif /* TN_COMPORT */
	1348	) && (carrier != CAR_OFF)) {
	1349	int x;
	1350	x = ttgmdm();
	1351	debug(F100,"CONNECT ttgmdm","",x);
	1352	if ((x > -1) && !(x & BM_DCD)) {
	1353	#ifndef NOHINTS
	1354	extern int hints;
	1355	#endif /* NOHINTS */
	1356	debug(F100,"CONNECT ttgmdm CD test fails","",x);
	1357	conres();
	1358	printf("?Carrier required but not detected.\n");
	1359	#ifndef NOHINTS
	1360	cx_status = CSX_CARRIER;
	1361	if (!hints)
	1362	return(0);
	1363	printf("***********************************\n");
	1364	printf(" Hint: To CONNECT to a serial device that\n");
	1365	printf(" is not presenting the Carrier Detect signal,\n");
	1366	printf(" first tell C-Kermit to:\n\n");
	1367	printf(" SET CARRIER-WATCH OFF\n\n");
	1368	printf("***********************************\n\n");
	1369	#endif /* NOHINTS */
	1370	return(0);
	1371	}
	1372	debug(F100,"CONNECT ttgmdm ok","",0);
	1373	}
	1374
	1375	/* Now we are connected. */
	1376
	1377	if (msgflg \|\| printbar)
	1378	printf("----------------------------------------------------\r\n");
	1379	fflush(stdout);
	1380
	1381	#ifndef NOCSETS
	1382	/* Set up character set translations */
	1383
	1384	unicode = 0; /* Assume Unicode won't be involved */
	1385	tcs = 0; /* "Transfer" or "Other" charset */
	1386	sxo = rxo = NULL; /* Initialize byte-to-byte functions */
	1387	sxi = rxi = NULL;
	1388
	1389	if (tcsr != tcsl) { /* Remote and local sets differ... */
	1390	#ifdef UNICODE
	1391	if (tcsr == FC_UTF8 \|\| /* Remote charset is UTF-8 */
	1392	tcsl == FC_UTF8) { /* or local one is. */
	1393	xuf = xl_ufc[tcsl]; /* Incoming Unicode to local */
	1394	if (xuf \|\| tcsl == FC_UTF8) {
	1395	tcs = (tcsr == FC_UTF8) ? tcsl : tcsr; /* The "other" set */
	1396	xfu = xl_fcu[tcs]; /* Local byte to remote Unicode */
	1397	if (xfu)
	1398	unicode = (tcsr == FC_UTF8) ? 1 : 2;
	1399	}
	1400	tcssize = fcsinfo[tcs].size; /* Size of other character set. */
	1401	} else {
	1402	#endif /* UNICODE */
	1403	tcs = gettcs(tcsr,tcsl); /* Get intermediate set. */
	1404	sxo = xls[tcs][tcsl]; /* translation function */
	1405	rxo = xlr[tcs][tcsr]; /* pointers for output functions */
	1406	sxi = xls[tcs][tcsr]; /* and for input functions. */
	1407	rxi = xlr[tcs][tcsl];
	1408	#ifdef UNICODE
	1409	}
	1410	#endif /* UNICODE */
	1411	}
	1412	/*
	1413	This is to prevent use of zmstuff() and zdstuff() by translation functions.
	1414	They only work with disk i/o, not with communication i/o. Luckily Russian
	1415	translation functions don't do any stuffing...
	1416	*/
	1417	langsv = language;
	1418	#ifndef NOCYRIL
	1419	if (language != L_RUSSIAN)
	1420	#endif /* NOCYRIL */
	1421	language = L_USASCII;
	1422
	1423	#ifdef COMMENT
	1424	#ifdef DEBUG
	1425	if (deblog) {
	1426	debug(F101,"CONNECT tcs","",tcs);
	1427	debug(F101,"CONNECT tcsl","",tcsl);
	1428	debug(F101,"CONNECT tcsr","",tcsr);
	1429	debug(F101,"CONNECT fcsinfo[tcsl].size","",fcsinfo[tcsl].size);
	1430	debug(F101,"CONNECT fcsinfo[tcsr].size","",fcsinfo[tcsr].size);
	1431	debug(F101,"CONNECT unicode","",unicode);
	1432	}
	1433	#endif /* DEBUG */
	1434	#endif /* COMMENT */
	1435
	1436	#ifdef CK_XYZ
	1437	#ifndef XYZ_INTERNAL
	1438	{
	1439	extern int binary; /* See about ZMODEM autodownloads */
	1440	char * s;
	1441	s = binary ? ptab[PROTO_Z].p_b_rcmd : ptab[PROTO_Z].p_t_rcmd;
	1442	if (!s) s = "";
	1443	zmdlok = (s != NUL); / OK if we have external commands */
	1444	}
	1445	#endif /* XYZ_INTERNAL */
	1446	#endif /* CK_XYZ */
	1447
	1448	#ifndef NOESCSEQ
	1449	/*
	1450	We need to activate the escape-sequence recognition feature when:
	1451	(a) translation is elected, AND
	1452	(b) the local and/or remote set is a 7-bit set other than US ASCII.
	1453	Or:
	1454	SET TERMINAL APC is not OFF (handled in the next statement).
	1455	*/
	1456	escseq = (tcs != TC_TRANSP) && /* Not transparent */
	1457	(fcsinfo[tcsl].size == 128 \|\| fcsinfo[tcsr].size == 128) && /* 7 bits */
	1458	(fcsinfo[tcsl].code != FC_USASCII); /* But not ASCII */
	1459	#endif /* NOESCSEQ */
	1460	#endif /* NOCSETS */
	1461
	1462	#ifndef NOESCSEQ
	1463	#ifdef CK_APC
	1464	escseq = escseq \|\| (apcstatus & APC_ON);
	1465	apcactive = 0; /* An APC command is not active */
	1466	apclength = 0; /* ... */
	1467	#endif /* CK_APC */
	1468	#ifdef XPRINT
	1469	escseq \|= tt_print;
	1470	#endif /* XPRINT */
	1471	inesc[0] = ES_NORMAL; /* Initial state of recognizer */
	1472	inesc[1] = ES_NORMAL;
	1473	debug(F101,"CONNECT escseq","",escseq);
	1474	#endif /* NOESCSEQ */
	1475
	1476	if (ttyfd > -1) { /* (just in case...) */
	1477	what = W_CONNECT; /* Keep track of what we're doing */
	1478	active = 1;
	1479	}
	1480	#ifdef CKLEARN
	1481	if (learning) { /* Learned script active... */
	1482	learnbp = 0; /* INPUT buffer pointer */
	1483	learnbc = 0; /* INPUT buffer count */
	1484	learnst = 0; /* State (0 = neutral, none) */
	1485	learnt1 = (ULONG) time(0);
	1486	}
	1487	#endif /* CKLEARN */
	1488
	1489	#ifdef CKTIDLE
	1490	idlelimit = tt_idlelimit;
	1491	#endif /* CKTIDLE */
	1492
	1493	while (active) { /* Big loop... */
	1494	debug(F100,"CONNECT top of loop","",0);
	1495	FD_ZERO(&in); /* Clear select() structs */
	1496	FD_ZERO(&out);
	1497	FD_ZERO(&err);
	1498	gotkbd = 0;
	1499	gotnet = ttpeek(); /* Something sitting in ckutio buf */
	1500	debug(F101,"CONNECT ttpeek","",gotnet);
	1501
	1502	if (
	1503	#ifndef NOSETKEY
	1504	!kmptr /* Check for key macro active */
	1505	#else
	1506	1
	1507	#endif /* NOSETKEY */
	1508	) {
	1509	if (obc) { /* No key macro - set up for select */
	1510	FD_SET(ttyfd, &out); /* Have stuff to send to net */
	1511	} else {
	1512	FD_SET(kbin, &in); /* Need to read stuff from keyboard */
	1513	}
	1514	#ifdef BEBOX
	1515	if (!(ibc \|\| gotnet > 0))
	1516	FD_SET(ttyfd, &in); /* Need to read stuff from net */
	1517	#else /* BEBOX */
	1518	if (ibc \|\| gotnet > 0) {
	1519	FD_SET(scrnout, &out); /* Have stuff to put on screen */
	1520	} else {
	1521	FD_SET(ttyfd, &in); /* Need to read stuff from net */
	1522	}
	1523	#endif /* BEBOX */
	1524	FD_SET(ttyfd, &err);
	1525	#ifdef CK_FORWARD_X
	1526	fwdx_init_fd_set(&in);
	1527	#endif /* CK_FORWARD_X */
	1528
	1529	/* Wait till the first one of the above is ready for i/o */
	1530	/* or TERM IDLE-SEND is active and we time out. */
	1531
	1532	errno = 0;
	1533	#ifdef CKTIDLE
	1534	/* This really could be moved out of the loop... */
	1535	if (idlelimit) { /* Idle timeout set */
	1536	struct timeval tv;
	1537	if (idlelimit > 0) { /* Positive = sec */
	1538	tv.tv_sec = (long) idlelimit;
	1539	tv.tv_usec = 0L;
	1540	} else { /* Negative = millisec */
	1541	long u = (0 - idlelimit);
	1542	tv.tv_sec = u / 1000L;
	1543	tv.tv_usec = ((u % 1000L) * 1000L);
	1544	}
	1545	#ifdef INTSELECT
	1546	c = select(FD_SETSIZE,(int )&in,(int )&out,(int *)&err, &tv);
	1547	#else
	1548	c = select(FD_SETSIZE, &in, &out, &err, &tv);
	1549	#endif /* INTSELECT */
	1550	} else
	1551	#endif /* CKTIDLE */
	1552	#ifdef INTSELECT
	1553	c = select(FD_SETSIZE, (int )&in, (int )&out, (int *)&err, 0);
	1554	#else
	1555	c = select(FD_SETSIZE, &in, &out, &err, 0);
	1556	#endif /* INTSELECT */
	1557	if (c < 1) {
	1558	#ifdef CKTIDLE
	1559	if (c == 0) { /* Timeout */
	1560	debug(F101,"CONNECT select() timeout","",tt_idleact);
	1561	switch (tt_idleact) {
	1562	case IDLE_HANG: { /* Hang up */
	1563	int x = 0;
	1564	#ifndef NODIAL
	1565	if (dialmhu)
	1566	x = mdmhup();
	1567	if (x < 1)
	1568	#endif /* NODIAL */
	1569	tthang(); /* fall thru deliberately... */
	1570	}
	1571	case IDLE_RET: /* Return to command mode */
	1572	cx_status = CSX_IDLE;
	1573	active = 0;
	1574	continue;
	1575	case IDLE_OUT: /* OUTPUT a string */
	1576	if (tt_idlestr) {
	1577	int len = strlen(tt_idlestr);
	1578	if (len > 0)
	1579	ttol((CHAR *)tt_idlestr,len);
	1580	else
	1581	ttoc(NUL); /* No string, send a NUL */
	1582	} else
	1583	ttoc(NUL); /* No string, send a NUL */
	1584	continue;
	1585	case IDLE_EXIT: /* Exit from Kermit */
	1586	doexit(GOOD_EXIT,xitsta);
	1587	#ifdef TNCODE
	1588	case IDLE_TAYT: /* Send Telnet Are You There? */
	1589	if (network && IS_TELNET()) {
	1590	tnopt[0] = (CHAR) IAC;
	1591	tnopt[1] = (CHAR) TN_AYT;
	1592	tnopt[2] = NUL;
	1593	if (ttol((CHAR *)tnopt,2) < 0)
	1594	active = 0;
	1595	}
	1596	continue;
	1597
	1598	case IDLE_TNOP: /* Send Telnet NOP */
	1599	if (network && IS_TELNET()) {
	1600	tnopt[0] = (CHAR) IAC;
	1601	tnopt[1] = (CHAR) TN_NOP;
	1602	tnopt[2] = NUL;
	1603	if (ttol((CHAR *)tnopt,2) < 0)
	1604	active = 0;
	1605	}
	1606	continue;
	1607	#endif /* TNCODE */
	1608	}
	1609	}
	1610	#endif /* CKTIDLE */
	1611
	1612	debug(F101,"CONNECT select() errno","",errno);
	1613	/* A too-big first arg to select() gets EBADF */
	1614	#ifdef EINTR
	1615	if (c == -1) {
	1616	if (errno == EINTR) {
	1617	continue;
	1618	}
	1619	}
	1620	#endif /* EINTR */
	1621	sleep(1);
	1622	continue;
	1623	}
	1624	#ifndef BEBOX
	1625	#ifdef DEBUG
	1626	if (FD_ISSET(scrnout, &out)) {
	1627	debug(F100,"CONNECT SELECT scrnout","",0);
	1628	}
	1629	#endif /* DEBUG */
	1630	#endif /* BEBOX */
	1631
	1632	#ifdef CK_FORWARD_X
	1633	fwdx_check_sockets(&in);
	1634	#endif /* CK_FORWARD_X */
	1635
	1636	if (FD_ISSET(ttyfd, &in)) { /* Read from net? */
	1637	debug(F110,"CONNECT SELECT ttyfd","in",0);
	1638	FD_CLR(ttyfd, &in);
	1639	gotnet = 1; /* Net is ready */
	1640	}
	1641	if (FD_ISSET(kbin, &in)) { /* Read from keyboard? */
	1642	debug(F100,"CONNECT SELECT kbin","",0);
	1643	FD_CLR(kbin, &in);
	1644	gotkbd = 1; /* Keyboard is ready */
	1645	}
	1646	if (FD_ISSET(ttyfd, &err)) {
	1647	debug(F110,"CONNECT SELECT ttyfd","err",0);
	1648	FD_CLR(ttyfd, &err);
	1649	#ifdef NETPTY
	1650	#ifdef HAVE_PTYTRAP
	1651	/* Special handling for HP-UX pty i/o */
	1652	if (ttpty) {
	1653	if (pty_trap_handler(ttyfd) > 0) {
	1654	ttclos(0);
	1655	goto conret1;
	1656	}
	1657	continue;
	1658	}
	1659	#endif /* HAVE_PTYTRAP */
	1660	#endif /* NETPTY */
	1661	gotnet = 1; /* Net is ready (don't set if pty) */
	1662	}
	1663	}
	1664	#ifdef DEBUG
	1665	if (deblog) {
	1666	debug(F101,"CONNECT gotkbd","",gotkbd);
	1667	debug(F101,"CONNECT kbc","",kbc);
	1668	#ifndef NOSETKEY
	1669	debug(F101,"CONNECT kmptr","",kmptr);
	1670	#endif /* NOSETKEY */
	1671	}
	1672	#endif /* DEBUG */
	1673
	1674	while (gotkbd \|\| kbc > 0 /* If we have keyboard chars */
	1675	#ifndef NOSETKEY
	1676	\|\| kmptr
	1677	#endif /* NOSETKEY */
	1678	) {
	1679	#ifndef NOSETKEY
	1680	if (kmptr) { /* Have current macro? */
	1681	debug(F100,"CONNECT kmptr non NULL","",0);
	1682	if ((c = (CHAR) kmptr++) == NUL) { / Get char from it */
	1683	debug(F100,"CONNECT macro empty, continuing","",0);
	1684	kmptr = NULL; /* If no more chars, */
	1685	continue; /* Reset pointer and continue */
	1686	}
	1687	debug(F000,"CONNECT char from macro","",c);
	1688	} else { /* No macro... */
	1689	#endif /* NOSETKEY */
	1690	#ifdef BEBOX
	1691	{
	1692	int rc = 0;
	1693	if ((rc = recv(kbin,buf,1,0)) > 0)
	1694	c = buf[0];
	1695	else
	1696	c = -1;
	1697	debug(F111,"recv","rc",rc);
	1698	printf("\r\nrecv: %c rc=%d\r\n",buf[0],rc);
	1699	}
	1700	#else /* BEBOX */
	1701	c = CONGKS(); /* Yes, read from keyboard */
	1702	#endif /* BEBOX */
	1703	gotkbd = 0; /* Turn off select() result flag */
	1704	#ifndef NOSETKEY
	1705	}
	1706	#endif /* NOSETKEY */
	1707	if (c == -1) {
	1708	#ifdef EINTR
	1709	if (errno == EINTR)
	1710	continue;
	1711	#endif /* EINTR */
	1712	cx_status = CSX_IOERROR;
	1713	conoc(BEL);
	1714	goto conret0;
	1715	}
	1716	c &= cmdmsk; /* Do any requested masking */
	1717
	1718	#ifndef NOSETKEY
	1719	/*
	1720	Note: kmptr is NULL if we got character c from the keyboard, and it is
	1721	not NULL if it came from a macro. In the latter case, we must avoid
	1722	expanding it again.
	1723	*/
	1724	if (!kmptr && macrotab[c]) { /* Macro definition for c? */
	1725	debug(F000,"CONNECT macro key",macrotab[c],c);
	1726	kmptr = macrotab[c]; /* Yes, set up macro pointer */
	1727	continue; /* and restart the loop, */
	1728	} else c = keymap[c]; /* else use single-char keymap */
	1729	#endif /* NOSETKEY */
	1730	if (
	1731	#ifndef NOSETKEY
	1732	!kmptr &&
	1733	#endif /* NOSETKEY */
	1734	(tt_escape && ((c & 0xff) == escape))) { /* Escape char? */
	1735	debug(F000,"CONNECT got escape","",c);
	1736	#ifdef BEBOX
	1737	if (recv(kbin,buf,1,0)>=0)
	1738	c = buf[0];
	1739	else
	1740	c = -1;
	1741	#else /* BEBOX */
	1742	c = CONGKS() & 0x7f; /* Read argument */
	1743	#endif /* BEBOX */
	1744	doesc((char) c); /* Handle it */
	1745	continue; /* Back to loop */
	1746	}
	1747	csave = c; /* Save it before translation */
	1748	/* for local echoing. */
	1749	#ifdef CKLEARN
	1750	crflag = (c == CR); /* Remember if it was CR. */
	1751	#endif /* CKLEARN */
	1752
	1753	#ifndef NOCSETS
	1754	if (inesc[1] == ES_NORMAL) { /* If not inside escape seq.. */
	1755	/* Translate character sets */
	1756	#ifdef UNICODE
	1757	int x;
	1758	if (unicode == 1) { /* Remote is UTF-8 */
	1759	outxcount = b_to_u((CHAR)c,outxbuf,OUTXBUFSIZ,tcssize);
	1760	outxbuf[outxcount] = NUL;
	1761	} else if (unicode == 2) { /* Local is UTF-8 */
	1762
	1763	x = u_to_b((CHAR)c);
	1764	if (x < 0)
	1765	continue;
	1766	outxbuf[0] = (unsigned)(x & 0xff);
	1767	outxcount = 1;
	1768	outxbuf[outxcount] = NUL;
	1769	} else {
	1770	#endif /* UNICODE */
	1771	if (sxo) c = (sxo)((char)c); / Local-intermediate */
	1772	if (rxo) c = (rxo)((char)c); / Intermediate-remote */
	1773	outxbuf[0] = c;
	1774	outxcount = 1;
	1775	outxbuf[outxcount] = NUL;
	1776	#ifdef UNICODE
	1777	}
	1778	#endif /* UNICODE */
	1779	} else {
	1780	outxbuf[0] = c;
	1781	outxcount = 1;
	1782	outxbuf[outxcount] = NUL;
	1783	}
	1784	if (escseq)
	1785	apcrc = chkaes((char)c,1);
	1786	#else
	1787	outxbuf[0] = c;
	1788	outxcount = 1;
	1789	outxbuf[outxcount] = NUL;
	1790	#endif /* NOCSETS */
	1791
	1792	debug(F111,"OUTXBUF",outxbuf,outxcount);
	1793
	1794	for (i = 0; i < outxcount; i++) {
	1795	c = outxbuf[i];
	1796	/*
	1797	If Shift-In/Shift-Out is selected and we have a 7-bit connection,
	1798	handle shifting here.
	1799	*/
	1800	if (sosi) { /* Shift-In/Out selected? */
	1801	if (cmask == 0177) { /* In 7-bit environment? */
	1802	if (c & 0200) { /* 8-bit character? */
	1803	if (outshift == 0) { /* If not shifted, */
	1804	ttoc(dopar(SO)); /* shift. */
	1805	outshift = 1;
	1806	}
	1807	} else {
	1808	if (outshift == 1) { /* 7-bit character */
	1809	ttoc(dopar(SI)); /* If shifted, */
	1810	outshift = 0; /* unshift. */
	1811	}
	1812	}
	1813	}
	1814	if (c == SO) outshift = 1; /* User typed SO */
	1815	if (c == SI) outshift = 0; /* User typed SI */
	1816	}
	1817	c &= cmask; /* Apply Kermit-to-host mask now. */
	1818	if (c == '\015') { /* Carriage Return */
	1819	int stuff = -1;
	1820	if (tnlm) { /* TERMINAL NEWLINE ON */
	1821	stuff = LF; /* Stuff LF */
	1822	#ifdef TNCODE
	1823	} else if (network && /* TELNET NEWLINE ON/OFF/RAW */
	1824	IS_TELNET()) {
	1825	switch (!TELOPT_ME(TELOPT_BINARY) ? tn_nlm : tn_b_nlm){
	1826	case TNL_CRLF:
	1827	stuff = LF;
	1828	break;
	1829	case TNL_CRNUL:
	1830	stuff = NUL;
	1831	break;
	1832	}
	1833	#endif /* TNCODE */
	1834	}
	1835	if (stuff > -1) {
	1836	ttoc(dopar('\015')); /* Send CR */
	1837	if (duplex) conoc('\015'); /* Maybe echo CR */
	1838	c = stuff; /* Char to stuff */
	1839	csave = c;
	1840	}
	1841	}
	1842	#ifdef TNCODE
	1843	/* If user types the 0xff character (TELNET IAC), it must be doubled. */
	1844	else /* Not CR */
	1845	if ((dopar((CHAR) c) == IAC) && /* IAC (0xff) */
	1846	network && IS_TELNET()) { /* Send one now */
	1847	ttoc((char)IAC); /* and the other one just below. */
	1848	}
	1849	#endif /* TNCODE */
	1850	/* Send the character */
	1851
	1852	x = ttoc((char)dopar((CHAR) c));
	1853	if (x > -1) {
	1854	#ifdef CKLEARN
	1855	if (learning) { /* Learned script active */
	1856	if (crflag) { /* User typed CR */
	1857	learnchar(CR); /* Handle CR */
	1858	learnst = 0; /* Shift to Neutral */
	1859	} else {
	1860	learnchar(c); /* Not CR */
	1861	learnst = 2; /* Change state to Keyboard */
	1862	}
	1863	}
	1864	#endif /* CKLEARN */
	1865	if (duplex) { /* If half duplex, must echo */
	1866	if (debses)
	1867	conol(dbchr(csave)); /* the original char */
	1868	else /* not the translated one */
	1869	conoc((char)csave);
	1870	if (seslog) { /* And maybe log it too */
	1871	c2 = csave;
	1872	if (sessft == 0 && csave == '\r')
	1873	c2 = '\n';
	1874	logchar((char)c2);
	1875	}
	1876	}
	1877	} else {
	1878	perror("\r\nCan't send character");
	1879	cx_status = CSX_IOERROR;
	1880	active = 0;
	1881	break;
	1882	}
	1883	}
	1884	}
	1885	if (FD_ISSET(ttyfd, &out)) {
	1886	FD_CLR(ttyfd, &out);
	1887	}
	1888	while (gotnet > 0 \|\| ibc > 0) {
	1889	gotnet = 0;
	1890	prev = c;
	1891	c = ckcgetc(0); /* Get next character */
	1892	/* debug(F101,"CONNECT c","",c); */
	1893	if (c < 0) { /* Failed... */
	1894	ckcputf(); /* Flush CONNECT output buffer */
	1895	if (msgflg) {
	1896	printf("\r\nCommunications disconnect ");
	1897	#ifdef COMMENT
	1898	if (c == -3
	1899	#ifdef ultrix
	1900	/* This happens on Ultrix if there's no carrier */
	1901	&& errno != EIO
	1902	#endif /* ultrix */
	1903	#ifdef UTEK
	1904	/* This happens on UTEK if there's no carrier */
	1905	&& errno != EWOULDBLOCK
	1906	#endif /* UTEK */
	1907	)
	1908	perror("\r\nCan't read character");
	1909	#endif /* COMMENT */
	1910	}
	1911	#ifdef NOSETBUF
	1912	fflush(stdout);
	1913	#endif /* NOSETBUF */
	1914	dologend();
	1915	tthang(); /* Hang up the connection */
	1916	debug(F111,"CONNECT i/o error 1",ck_errstr(),errno);
	1917	cx_status = CSX_HOSTDISC;
	1918	goto conret0;
	1919	}
	1920	#ifdef TNCODE
	1921	tx = 0;
	1922	if ((c == NUL) && network && IS_TELNET()) {
	1923	if (prev == CR) { /* Discard <NUL> of <CR><NUL> if peer */
	1924	if (!TELOPT_U(TELOPT_BINARY)) { /* not in binary mode */
	1925	debug(F111,"CONNECT NUL",ckitoa(prev),c);
	1926	ckcputf(); /* Flush screen output buffer */
	1927	break;
	1928	}
	1929	}
	1930	}
	1931	debug(F111,"CONNECT","c",c);
	1932	debug(F111,"CONNECT","network",network);
	1933	debug(F111,"CONNECT","IS_TELNET",IS_TELNET());
	1934	if ((c == IAC) && network && IS_TELNET()) {
	1935	#ifdef CK_ENCRYPTION
	1936	int x_auth = TELOPT_ME(TELOPT_AUTHENTICATION);
	1937	#else
	1938	int x_auth = 0;
	1939	#endif /* CK_ENCRYPTION */
	1940	int me_bin = TELOPT_ME(TELOPT_BINARY);
	1941	int u_bin = TELOPT_U(TELOPT_BINARY);
	1942	debug(F100,"CONNECT got IAC","",0);
	1943	ckcputf(); /* Dump screen-output buffer */
	1944	if ((tx = tn_doop((CHAR)(c & 0xff),duplex,ckcgetc)) == 0) {
	1945	if (me_bin != TELOPT_ME(TELOPT_BINARY)) {
	1946	me_bin = TELOPT_ME(TELOPT_BINARY);
	1947	} else if (u_bin != TELOPT_U(TELOPT_BINARY)) {
	1948	u_bin = TELOPT_U(TELOPT_BINARY);
	1949	#ifdef CK_ENCRYPTION
	1950	/*
	1951	Here we have to push back any bytes we have read using block reads, so we
	1952	can read them again using single-character reads, so they can be decrypted
	1953	in case there was a switch to encryption in the block. Note that we can't
	1954	handle switches in the encryption state itself this way -- which would be
	1955	nice, since it would eliminate the need for single-character reads. Why?
	1956	Because if a series of characters has already been decrypted that shouldn't
	1957	have been, then (a) it's ruined, and (b) so is the state of the decryption
	1958	machine. Too bad.
	1959	*/
	1960	} else if (TELOPT_ME(TELOPT_AUTHENTICATION) != 0 &&
	1961	TELOPT_ME(TELOPT_AUTHENTICATION) != x_auth
	1962	) {
	1963	if (ttpushback((CHAR *)ibp,ibc) > -1) {
	1964	ibc = 0;
	1965	ibp = ibuf;
	1966	}
	1967	#endif /* CK_ENCRYPTION */
	1968	}
	1969	continue;
	1970	} else if (tx == -1) { /* I/O error */
	1971	if (msgflg)
	1972	printf("\r\nCommunications disconnect ");
	1973	#ifdef NOSETBUF
	1974	fflush(stdout);
	1975	#endif /* NOSETBUF */
	1976	dologend();
	1977	debug(F111,"CONNECT i/o error 2",ck_errstr(),errno);
	1978	cx_status = CSX_IOERROR;
	1979	goto conret0;
	1980	} else if (tx == -2) { /* I/O error */
	1981	if (msgflg)
	1982	printf("\r\nConnection closed by peer");
	1983	#ifdef NOSETBUF
	1984	fflush(stdout);
	1985	#endif /* NOSETBUF */
	1986	dologend();
	1987	debug(F111,"CONNECT i/o error 3",ck_errstr(),errno);
	1988	cx_status = CSX_IOERROR;
	1989	goto conret0;
	1990	} else if (tx == -3) { /* I/O error */
	1991	if (msgflg)
	1992	printf("\r\nConnection closed due to telnet policy");
	1993	#ifdef NOSETBUF
	1994	fflush(stdout);
	1995	#endif /* NOSETBUF */
	1996	dologend();
	1997	debug(F111,"CONNECT i/o error 4",ck_errstr(),errno);
	1998	cx_status = CSX_IOERROR;
	1999	goto conret0;
	2000	} else if ((tx == 1) && (!duplex)) { /* ECHO change */
	2001	duplex = 1; /* Turn on local echo */
	2002	continue;
	2003	} else if ((tx == 2) && (duplex)) { /* ECHO change */
	2004	duplex = 0;
	2005	continue;
	2006	} else if (tx == 3) { /* Quoted IAC */
	2007	c = parity ? 127 : 255;
	2008	}
	2009	#ifdef IKS_OPTION
	2010	else if (tx == 4) { /* IKS State Change */
	2011	if (TELOPT_SB(TELOPT_KERMIT).kermit.u_start &&
	2012	!tcp_incoming
	2013	) {
	2014	/* here we need to print a msg that the other */
	2015	/* side is in SERVER mode and that REMOTE */
	2016	/* commands should be used. And CONNECT mode */
	2017	/* should be ended. */
	2018	cx_status = CSX_IKSD;
	2019	active = 0;
	2020	}
	2021	}
	2022	#endif /* IKS_OPTION */
	2023	else if (tx == 6) {
	2024	/* DO LOGOUT was received */
	2025	if (msgflg)
	2026	printf("\r\nRemote Logout ");
	2027	#ifdef NOSETBUF
	2028	fflush(stdout);
	2029	#endif /* NOSETBUF */
	2030	debug(F100,"CONNECT Remote Logout","",0);
	2031	cx_status = CSX_TRIGGER;
	2032	goto conret0;
	2033	} else
	2034	continue; /* Negotiation OK, get next char. */
	2035	} else if (parity)
	2036	c &= 0x7f;
	2037
	2038	/* I'm echoing for the remote */
	2039	if (TELOPT_ME(TELOPT_ECHO) && tn_rem_echo)
	2040	ttoc((char)c);
	2041	#endif /* TNCODE */
	2042
	2043	#ifdef CKLEARN
	2044	/* Learned script: Record incoming chars if not in Keyboard state */
	2045
	2046	if (learning && learnst != 2) { /* Learned script active */
	2047	learnbuf[learnbp++] = c; /* Save for INPUT command */
	2048	if (learnbp >= LEARNBUFSIZ) /* in circular buffer */
	2049	learnbp = 0; /* wrapping if at end. */
	2050	learnbc++; /* Count this byte. */
	2051	learnst = 1; /* State is Net. */
	2052	}
	2053	#endif /* CKLEARN */
	2054
	2055	if (debses) { /* Output character to screen */
	2056	char s; / Debugging display... */
	2057	s = dbchr(c);
	2058	while (*s)
	2059	ckcputc(*s++);
	2060	} else { /* Regular display ... */
	2061	c &= cmask; /* Apply Kermit-to-remote mask */
	2062	if (seslog && sessft) /* If binary session log */
	2063	logchar((char)c); /* log the character now. */
	2064	#ifndef NOXFER
	2065	#ifdef CK_AUTODL
	2066	/*
	2067	Autodownload. Check for Kermit S packet prior to translation, since that
	2068	can change the packet and make it unrecognizable (as when the terminal
	2069	character set is an ISO 646 one)... Ditto for Zmodem start packet.
	2070	*/
	2071	if (autodl /* Autodownload enabled? */
	2072	#ifdef IKS_OPTION
	2073	\|\| TELOPT_SB(TELOPT_KERMIT).kermit.me_start
	2074	#endif /* IKS_OPTION */
	2075	) {
	2076	int k = 0;
	2077
	2078	if (kstartactive \|\| c == stchr /* Kermit S or I packet? */
	2079	#ifdef COMMENT
	2080	\|\| adl_kmode == ADLSTR /* Not used in C-Kermit */
	2081	#endif /* COMMENT */
	2082	)
	2083	k = kstart((CHAR)c);
	2084	#ifdef CK_XYZ
	2085	if (!k && zmdlok) /* Or an "sz" start? */
	2086	k = zstart((CHAR)c);
	2087	#endif /* CK_XYZ */
	2088	if (k) {
	2089	int ksign = 0;
	2090	debug(F101,"CONNECT autodownload k","",k);
	2091	if (k < 0) { /* Minus-Protocol? */
	2092	#ifdef NOSERVER
	2093	goto noserver; /* Need server mode for this */
	2094	#else
	2095	ksign = 1; /* Remember */
	2096	k = 0 - k; /* Convert to actual protocol */
	2097	justone = 1; /* Flag for protocol module */
	2098	#endif /* NOSERVER */
	2099	} else
	2100	justone = 0;
	2101	k--; /* Adjust [kz]start's return value */
	2102	if (k == PROTO_K
	2103	#ifdef CK_XYZ
	2104	\|\| k == PROTO_Z
	2105	#endif /* CK_XYZ */
	2106	) {
	2107	/* Damage the packet so that it doesn't trigger */
	2108	/* autodownload detection downstream. */
	2109	if (k == PROTO_K) {
	2110	int i, len = strlen((char *)ksbuf);
	2111	for (i = 0; i < len; i++)
	2112	ckcputc(BS);
	2113	}
	2114	#ifdef CK_XYZ
	2115	else {
	2116	int i;
	2117	for (i = 0; i < 3; i++)
	2118	ckcputc(CAN);
	2119	}
	2120	#endif /* CK_XYZ */
	2121
	2122	#ifndef NOICP
	2123	/* sprintf is safe here (builtin keywords) */
	2124	sprintf(apcbuf,
	2125	"set proto %s, %s, set proto %s",
	2126	ptab[k].p_name,
	2127	ksign ? "server" : "receive",
	2128	ptab[protocol].p_name
	2129	);
	2130	apclength = strlen(apcbuf);
	2131	debug(F111,"CONNECT ksbuf",ksbuf,k);
	2132	debug(F110,"CONNECT autodownload",apcbuf,0);
	2133	apcactive = APC_LOCAL;
	2134	ckcputf(); /* Force screen update */
	2135	cx_status = CSX_APC;
	2136	goto conret1;
	2137	#else
	2138	/*
	2139	Here's another way that doesn't require APC, but then we'll have to change
	2140	all the other CONNECT modules, and then the mainline code that calls them.
	2141	*/
	2142	{
	2143	extern char sstate;
	2144	sstate = ksign ? 'x' : 'v';
	2145	proto();
	2146	}
	2147	#endif /* NOICP */
	2148	}
	2149	}
	2150	}
	2151	#ifdef NOSERVER
	2152	noserver:
	2153	#endif /* NOSERVER */
	2154
	2155	#endif /* CK_AUTODL */
	2156	#endif /* NOXFER */
	2157	if (sosi) { /* Handle SI/SO */
	2158	if (c == SO) { /* Shift Out */
	2159	inshift = 1;
	2160	continue;
	2161	} else if (c == SI) { /* Shift In */
	2162	inshift = 0;
	2163	continue;
	2164	}
	2165	if (inshift) c \|= 0200;
	2166	}
	2167	inxbuf[0] = c; /* In case there is no translation */
	2168	inxcount = 1; /* ... */
	2169	#ifndef NOCSETS
	2170	if (inesc[0] == ES_NORMAL /* If not in an escape sequence */
	2171	&& !printing /* and not in transparent print */
	2172	) { /* Translate character sets */
	2173	#ifdef UNICODE
	2174	int x;
	2175	if (unicode == 1) { /* Remote is UTF-8 */
	2176	x = u_to_b((CHAR)c);
	2177	if (x == -1)
	2178	continue;
	2179	else if (x == -2) { /* LS or PS */
	2180	inxbuf[0] = CR;
	2181	inxbuf[1] = LF;
	2182	inxcount = 2;
	2183	} else if (x == -9) { /* UTF-8 error */
	2184	inxbuf[0] = '?';
	2185	inxbuf[1] = u_to_b2();
	2186	inxcount = 2;
	2187	} else {
	2188	inxbuf[0] = (unsigned)(x & 0xff);
	2189	}
	2190	c = inxbuf[0];
	2191	} else if (unicode == 2) { /* Local is UTF-8 */
	2192	inxcount = b_to_u((CHAR)c,inxbuf,OUTXBUFSIZ,tcssize);
	2193	c = inxbuf[0];
	2194	} else {
	2195	#endif /* UNICODE */
	2196	if (sxi) c = (*sxi)((CHAR)c);
	2197	if (rxi) c = (*rxi)((CHAR)c);
	2198	inxbuf[0] = c;
	2199	#ifdef UNICODE
	2200	}
	2201	#endif /* UNICODE */
	2202	}
	2203	#endif /* NOCSETS */
	2204
	2205	#ifndef NOESCSEQ
	2206	if (escseq) { /* If handling escape sequences */
	2207	oldprt = printing; /* remember printer state */
	2208	apcrc = chkaes((char)c,0); /* and update escseq state. */
	2209	if (printing && !oldprt) /* If printer was turned on */
	2210	continue; /* don't print final char of escseq */
	2211	}
	2212	#ifdef CK_APC
	2213	/*
	2214	If we are handling APCs, we have several possibilities at this point:
	2215	1. Ordinary character to be written to the screen.
	2216	2. An Esc; we can't write it because it might be the beginning of an APC.
	2217	3. The character following an Esc, in which case we write Esc, then char,
	2218	but only if we have not just entered an APC sequence.
	2219	*/
	2220	if (escseq && (apcstatus & APC_ON)) {
	2221	if (inesc[0] == ES_GOTESC) /* Don't write ESC yet */
	2222	continue;
	2223	else if (oldesc[0] == ES_GOTESC && !apcactive) {
	2224	ckcputc(ESC); /* Write saved ESC */
	2225	if (seslog && !sessft) logchar((char)ESC);
	2226	} else if (apcrc) { /* We have an APC */
	2227	debug(F111,"CONNECT APC complete",apcbuf,apclength);
	2228	ckcputf(); /* Force screen update */
	2229	cx_status = CSX_APC;
	2230	goto conret1;
	2231	}
	2232	}
	2233	#endif /* CK_APC */
	2234	#endif /* NOESCSEQ */
	2235
	2236	debug(F111,"INXBUF",inxbuf,inxcount);
	2237	for (i = 0; i < inxcount; i++) { /* Loop thru */
	2238	c = inxbuf[i]; /* input expansion buffer... */
	2239	if (
	2240	#ifdef CK_APC
	2241	!apcactive && /* Don't display APC sequences */
	2242	#endif /* CK_APC */
	2243	!printing /* or transparent print material */
	2244
	2245	) {
	2246	c &= cmdmsk; /* Apply command mask. */
	2247	if (c == CR && tt_crd) { /* SET TERM CR-DISPLA CRLF? */
	2248	ckcputc(c); /* Yes, output CR */
	2249	if (seslog && !sessft) logchar((char)c);
	2250	c = LF; /* and insert a linefeed */
	2251	}
	2252	if (dontprint) { /* Do transparent printing. */
	2253	dontprint = 0;
	2254	continue;
	2255	} else
	2256
	2257	ckcputc(c); /* Write character to screen */
	2258	}
	2259	if (seslog && !sessft) /* Handle session log. */
	2260	logchar((char)c);
	2261	#ifdef XPRINT
	2262	if (printing && !inesc[0]) {
	2263	/* zchout() can't be used because */
	2264	/* it's buffered differently. */
	2265	cbuf[0] = c;
	2266	zsoutx(ZMFILE,(char *)cbuf,1);
	2267	}
	2268	#endif /* XPRINT */
	2269
	2270	#ifdef CK_TRIGGER
	2271	/* Check for trigger string */
	2272	if (tt_trigger[0]) {
	2273	int i;
	2274	if ((i = autoexitchk((CHAR)c)) > -1) {
	2275	makestr(&triggerval,tt_trigger[i]);
	2276	ckcputf(); /* Force screen update */
	2277	#ifdef NOSETBUF
	2278	fflush(stdout); /* I mean really force it */
	2279	#endif /* NOSETBUF */
	2280	cx_status = CSX_TRIGGER;
	2281	goto conret1;
	2282	}
	2283	}
	2284	#endif /* CK_TRIGGER */
	2285	}
	2286	}
	2287	}
	2288	#ifndef BEBOX
	2289	if (FD_ISSET(scrnout, &out)) {
	2290	FD_CLR(scrnout, &out);
	2291	}
	2292	#endif /* BEBOX */
	2293	} /* End of big loop */
	2294	conret1: /* Come here to succeed */
	2295	rc = 1;
	2296	conret0: /* Common exit point */
	2297	#ifdef BEBOX
	2298	{
	2299	long ret_val;
	2300	closesocket(pair[0]);
	2301	closesocket(pair[1]);
	2302	x = kill(tid,SIGKILLTHR); /* Kill thread */
	2303	wait_for_thread (tid, &ret_val);
	2304	}
	2305	#endif /* BEBOX */
	2306
	2307	#ifdef CKLEARN
	2308	if (learning && learnfp)
	2309	fputs("\n",learnfp);
	2310	#endif /* CKLEARN */
	2311
	2312	conres();
	2313	if (dohangup > 0) {
	2314	#ifdef NETCONN
	2315	if (network
	2316	#ifdef TNCODE
	2317	&& !TELOPT_ME(TELOPT_COMPORT)
	2318	#endif /* TNCODE */
	2319	)
	2320	ttclos(0);
	2321	#endif /* NETCONN */
	2322
	2323	#ifndef COMMENT
	2324	/*
	2325	This is bad because if they said SET MODEM HANGUP-METHOD MODEM-COMMAND,
	2326	they mean it -- we shouldn't fall back on tthang() if mdmhup() fails,
	2327	because maybe they have some special kind of connection. On the other
	2328	hand, making this change prevents dialing from working at all in some
	2329	cases. Further study needed.
	2330	*/
	2331	#ifndef NODIAL
	2332	if (dohangup > 1) /* User asked for it */
	2333	if (mdmhup() < 1) /* Maybe hang up via modem */
	2334	#endif /* NODIAL */
	2335	tthang(); /* And make sure we don't hang up */
	2336	#else
	2337	if (!network) { /* Serial connection. */
	2338	#ifndef NODIAL
	2339	if (dialmhu) /* Hang up the way they said to. */
	2340	mdmhup();
	2341	else
	2342	#endif /* NODIAL */
	2343	tthang();
	2344	}
	2345	#endif /* COMMENT */
	2346	dologend();
	2347	dohangup = 0; /* again unless requested again. */
	2348	}
	2349	if (quitnow) /* Exit now if requested. */
	2350	doexit(GOOD_EXIT,xitsta);
	2351	if (msgflg
	2352	#ifdef CK_APC
	2353	&& !apcactive
	2354	#endif /* CK_APC */
	2355	)
	2356	printf("(Back at %s)", *myhost ? myhost : "local UNIX system");
	2357	#ifdef CK_APC
	2358	if (!apcactive)
	2359	#endif /* CK_APC */
	2360	printf("\n");
	2361	what = W_NOTHING; /* So console modes set right. */
	2362	#ifndef NOCSETS
	2363	language = langsv; /* Restore language */
	2364	#endif /* NOCSETS */
	2365	#ifdef CK_APC
	2366	debug(F101,"CONNECT exit apcactive","",apcactive);
	2367	debug(F101,"CONNECT exit justone","",justone);
	2368	#endif /* CK_APC */
	2369	if (msgflg) {
	2370	#ifdef CK_APC
	2371	if (apcactive == APC_LOCAL)
	2372	printf("\n");
	2373	#endif /* CK_APC */
	2374	printf("----------------------------------------------------\n");
	2375	printbar = 1;
	2376	} else
	2377	printbar = 0;
	2378	fflush(stdout);
	2379	return(rc);
	2380	}
	2381
	2382	/* H C O N N E -- Give help message for connect. */
	2383
	2384	#define CXM_SER 1 /* Serial connections only */
	2385	#define CXM_NET 2 /* Network only (but not Telnet) */
	2386	#define CXM_TEL 4 /* Telnet only */
	2387
	2388	static struct hmsgtab {
	2389	char * hmsg;
	2390	int hflags;
	2391	} hlpmsg[] = {
	2392	{" ? or H for this message", 0},
	2393	{" 0 (zero) to send the NUL (0) character", 0},
	2394	{" B to send a BREAK signal (0.275sec)", CXM_SER},
	2395	#ifdef NETCONN
	2396	{" B to send a network BREAK", CXM_NET},
	2397	{" B to send a Telnet BREAK", CXM_TEL},
	2398	#endif /* NETCONN */
	2399	#ifdef CK_LBRK
	2400	{" L to send a Long BREAK (1.5sec)", CXM_SER},
	2401	#endif /* CK_LBRK */
	2402	#ifdef NETCONN
	2403	{" I to send a network interrupt packet", CXM_NET},
	2404	{" I to send a Telnet Interrupt request", CXM_TEL},
	2405	#ifdef TNCODE
	2406	{" A to send Telnet Are-You-There?", CXM_TEL},
	2407	#endif /* TNCODE */
	2408	#endif /* NETCONN */
	2409	{" U to hangup and close the connection", 0},
	2410	{" Q to hangup and quit Kermit", 0},
	2411	{" S for status", 0},
	2412	#ifdef NOPUSH
	2413	{" ! to push to local shell (disabled)", 0},
	2414	{" Z to suspend (disabled)", 0},
	2415	#else
	2416	{" ! to push to local shell", 0},
	2417	#ifdef NOJC
	2418	{" Z to suspend (disabled)", 0},
	2419	#else
	2420	{" Z to suspend", 0},
	2421	#endif /* NOJC */
	2422	#endif /* NOPUSH */
	2423	{" \\ backslash code:", 0},
	2424	{" \\nnn decimal character code", 0},
	2425	{" \\Onnn octal character code", 0},
	2426	{" \\Xhh hexadecimal character code;", 0},
	2427	{" terminate with Carriage Return.", 0},
	2428	{" Type the escape character again to send the escape character itself,",
	2429	0},
	2430	{" or press the space-bar to resume the CONNECT session.", 0},
	2431	{NULL, 0}
	2432	};
	2433
	2434	int
	2435	hconne() {
	2436	int c, i, cxtype;
	2437	if (network)
	2438	cxtype = IS_TELNET() ? CXM_TEL : CXM_NET;
	2439	else
	2440	cxtype = CXM_SER;
	2441
	2442	conol("\r\n----------------------------------------------------\r\n");
	2443	conoll("Press:");
	2444	conol(" C to return to ");
	2445	conoll(*myhost ? myhost : "the C-Kermit prompt");
	2446	for (i = 0; hlpmsg[i].hmsg; i++) {
	2447	if (!(hlpmsg[i].hflags) \|\| (hlpmsg[i].hflags == cxtype))
	2448	conoll(hlpmsg[i].hmsg);
	2449	}
	2450	conol("Press a key>"); /* Prompt for command. */
	2451	c = CONGKS() & 0177; /* Get character, strip any parity. */
	2452	/* No key mapping or translation here */
	2453	if (c != CMDQ)
	2454	conoll("");
	2455	conoll("----------------------------------------------------");
	2456	return(c); /* Return it. */
	2457	}
	2458
	2459
	2460	/* D O E S C -- Process an escape character argument */
	2461
	2462	VOID
	2463	#ifdef CK_ANSIC
	2464	doesc(char c)
	2465	#else
	2466	doesc(c) char c;
	2467	#endif /* CK_ANSIC */
	2468	/* doesc */ {
	2469	CHAR d;
	2470
	2471	debug(F101,"CONNECT doesc","",c);
	2472	while (1) {
	2473	if (c == escape) { /* Send escape character */
	2474	d = dopar((CHAR) c); ttoc((char) d); return;
	2475	} else /* Or else look it up below. */
	2476	if (isupper(c)) c = tolower(c);
	2477
	2478	switch(c) {
	2479
	2480	case 'c': /* Escape back to prompt */
	2481	case '\03':
	2482	cx_status = CSX_ESCAPE;
	2483	#ifdef NOICP
	2484	conoll("");
	2485	conoll("");
	2486	conoll(
	2487	" WARNING: This version of C-Kermit has no command processor to escape"
	2488	);
	2489	conoll(
	2490	" back to. To return to your local system, log out from the remote and/or"
	2491	);
	2492	conoll(
	2493	" use the escape character followed by the letter U to close (hang Up) the"
	2494	);
	2495	conoll(
	2496	" connection. Resuming your session..."
	2497	);
	2498	conoll("");
	2499	return;
	2500	#else
	2501	active = 0; conol("\r\n"); return;
	2502	#endif /* NOICP */
	2503
	2504	case 'b': /* Send a BREAK signal */
	2505	case '\02':
	2506	#ifdef CKLEARN
	2507	learnchar(-7);
	2508	#endif /* CKLEARN */
	2509	ttsndb(); return;
	2510
	2511	#ifdef NETCONN
	2512	case 'i': /* Send Interrupt */
	2513	case '\011':
	2514	#ifdef TCPSOCKET
	2515	if (network && IS_TELNET()) { /* TELNET */
	2516	temp[0] = (CHAR) IAC; /* I Am a Command */
	2517	temp[1] = (CHAR) TN_IP; /* Interrupt Process */
	2518	temp[2] = NUL;
	2519	ttol((CHAR *)temp,2);
	2520	} else
	2521	#endif /* TCPSOCKET */
	2522	conoc(BEL);
	2523	return;
	2524
	2525	#ifdef TCPSOCKET
	2526	case 'a': /* "Are You There?" */
	2527	case '\01':
	2528	if (network && IS_TELNET()) {
	2529	temp[0] = (CHAR) IAC; /* I Am a Command */
	2530	temp[1] = (CHAR) TN_AYT; /* Are You There? */
	2531	temp[2] = NUL;
	2532	ttol((CHAR *)temp,2);
	2533	} else conoc(BEL);
	2534	return;
	2535	#endif /* TCPSOCKET */
	2536	#endif /* NETCONN */
	2537
	2538	#ifdef CK_LBRK
	2539	case 'l': /* Send a Long BREAK signal */
	2540	#ifdef CKLEARN
	2541	learnchar(-8);
	2542	#endif /* CKLEARN */
	2543	ttsndlb(); return;
	2544	#endif /* CK_LBRK */
	2545
	2546	case 'u': /* Hangup */
	2547	/* case '\010': / / No, too dangerous */
	2548	cx_status = CSX_USERDISC;
	2549	dohangup = 2; active = 0; conol("\r\nHanging up "); return;
	2550
	2551	case 'q': /* Quit */
	2552	cx_status = CSX_USERDISC;
	2553	dohangup = 2; quitnow = 1; active = 0; conol("\r\n"); return;
	2554
	2555	case 's': /* Status */
	2556	conoll("");
	2557	conoll("----------------------------------------------------");
	2558	#ifdef PTYORPIPE
	2559	if (ttpipe)
	2560	ckmakmsg(temp,TMPLEN," Pipe: \"",ttname,"\"",NULL);
	2561	else if (ttpty)
	2562	ckmakmsg(temp,TMPLEN," Pty: \"",ttname,"\"",NULL);
	2563	else
	2564	#endif /* PTYORPIPE */
	2565	ckmakmsg(temp,
	2566	TMPLEN,
	2567	" ",
	2568	(network ? "Host" : "Device"),
	2569	": ",
	2570	ttname
	2571	);
	2572	conoll(temp);
	2573
	2574	/* The following sprintf's are safe, temp[] size is at least 200 */
	2575
	2576	if (!network && speed >= 0L) {
	2577	sprintf(temp,"Speed %ld", speed);
	2578	conoll(temp);
	2579	}
	2580	sprintf(temp," Terminal echo: %s", duplex ? "local" : "remote");
	2581	conoll(temp);
	2582	sprintf(temp," Terminal bytesize: %d", (cmask == 0177) ? 7 : 8);
	2583	conoll(temp);
	2584	sprintf(temp," Command bytesize: %d", (cmdmsk == 0177) ? 7 : 8);
	2585	conoll(temp);
	2586	if (hwparity)
	2587	sprintf(temp," Parity[hardware]: %s",parnam(hwparity));
	2588	else
	2589	sprintf(temp," Parity: %s", parnam(parity));
	2590	conoll(temp);
	2591	#ifndef NOXFER
	2592	sprintf(temp," Autodownload: %s", autodl ? "on" : "off");
	2593	conoll(temp);
	2594	#endif /* NOXFER */
	2595	ckmakmsg(temp, /* (would not be safe for sprintf) */
	2596	TMPLEN,
	2597	" Session log: ",
	2598	*sesfil ? sesfil : "(none)",
	2599	NULL,
	2600	NULL
	2601	);
	2602	conoll(temp);
	2603	#ifndef NOSHOW
	2604	if (!network) shomdm();
	2605	#endif /* NOSHOW */
	2606	#ifdef CKLOGDIAL
	2607	{
	2608	long z;
	2609	z = dologshow(0);
	2610	if (z > -1L) {
	2611	sprintf(temp," Elapsed time: %s",hhmmss(z));
	2612	conoll(temp);
	2613	}
	2614	}
	2615	#endif /* CKLOGDIAL */
	2616	conoll("----------------------------------------------------");
	2617	return;
	2618
	2619	case 'h': /* Help */
	2620	case '?': /* Help */
	2621	c = hconne(); continue;
	2622
	2623	case '0': /* Send a null */
	2624	c = '\0'; d = dopar((CHAR) c); ttoc((char) d); return;
	2625
	2626	case 'z': case '\032': /* Suspend */
	2627	#ifndef NOPUSH
	2628	if (!nopush)
	2629	stptrap(0);
	2630	else
	2631	conoc(BEL);
	2632	#else
	2633	conoc(BEL);
	2634	#endif /* NOPUSH */
	2635	return;
	2636
	2637	case '@': /* Start inferior command processor */
	2638	case '!':
	2639	#ifndef NOPUSH
	2640	if (!nopush) {
	2641	conres(); /* Put console back to normal */
	2642	zshcmd(""); /* Fork a shell. */
	2643	if (conbin((char)escape) < 0) {
	2644	cx_status = CSX_INTERNAL;
	2645	printf("Error resuming CONNECT session\n");
	2646	active = 0;
	2647	}
	2648	} else conoc(BEL);
	2649	#else
	2650	conoc(BEL);
	2651	#endif /* NOPUSH */
	2652	return;
	2653
	2654	case SP: /* Space, ignore */
	2655	return;
	2656
	2657	default: /* Other */
	2658	if (c == CMDQ) { /* Backslash escape */
	2659	int x;
	2660	ecbp = ecbuf;
	2661	*ecbp++ = c;
	2662	while (((c = (CONGKS() & cmdmsk)) != '\r') && (c != '\n'))
	2663	*ecbp++ = c;
	2664	*ecbp = NUL; ecbp = ecbuf;
	2665	x = xxesc(&ecbp); /* Interpret it */
	2666	if (x >= 0) { /* No key mapping here */
	2667	c = dopar((CHAR) x);
	2668	ttoc((char) c);
	2669	return;
	2670	} else { /* Invalid backslash code. */
	2671	conoc(BEL);
	2672	return;
	2673	}
	2674	}
	2675	conoc(BEL); return; /* Invalid esc arg, beep */
	2676	}
	2677	}
	2678	}
	2679	#endif /* NOLOCAL */

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

Context Navigation

source: trunk/third/kermit/ckucns.c @ 20081

Download in other formats: