/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 1988, 1990, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

/*
 * The following routines try to encapsulate what is system dependent
 * (at least between 4.x and dos) which is used in telnet.c.
 */


#include <fcntl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <signal.h>
#include <errno.h>
#include <arpa/telnet.h>

#include "ring.h"

#include "defines.h"
#include "externs.h"
#include "types.h"

#define	SIG_FUNC_RET	void

int tout;			/* Output file descriptor */
static int tin;			/* Input file descriptor */
int net = -1;


#ifndef	USE_TERMIO
struct	tchars otc = { 0 }, ntc = { 0 };
struct	ltchars oltc = { 0 }, nltc = { 0 };
struct	sgttyb ottyb = { 0 }, nttyb = { 0 };
int	olmode = 0;
#define	cfgetispeed(ptr)	(ptr)->sg_ispeed
#define	cfgetospeed(ptr)	(ptr)->sg_ospeed
#define	old_tc ottyb

#else	/* USE_TERMIO */
static struct	termio old_tc = { 0 };
extern struct termio new_tc;
#endif	/* USE_TERMIO */

static fd_set ibits, obits, xbits;

static SIG_FUNC_RET susp(int);
void fatal_tty_error(char *doing_what);


void
init_sys()
{
	tout = fileno(stdout);
	tin = fileno(stdin);
	FD_ZERO(&ibits);
	FD_ZERO(&obits);
	FD_ZERO(&xbits);

	errno = 0;
}


int
TerminalWrite(buf, n)
	char *buf;
	int  n;
{
	return (write(tout, buf, n));
}

static int
TerminalRead(buf, n)
	char *buf;
	int  n;
{
	return (read(tin, buf, n));
}

#ifdef	KLUDGELINEMODE
extern int kludgelinemode;
#endif
/*
 * TerminalSpecialChars()
 *
 * Look at an input character to see if it is a special character
 * and decide what to do.
 *
 * Output:
 *
 *	0	Don't add this character.
 *	1	Do add this character
 */
int
TerminalSpecialChars(c)
	int	c;
{
	/*
	 * Don't check for signal characters here.  If MODE_TRAPSIG is on,
	 * then the various signal handlers will catch the characters.  If
	 * the character in question gets here, then it must have been LNEXTed
	 */
	if (c == termQuitChar) {
#ifdef	KLUDGELINEMODE
		if (kludgelinemode) {
			if (sendbrk() == -1) {
				/* This won't return. */
				fatal_tty_error("write");
			}
			return (0);
		}
#endif
	} else if (c == termFlushChar) {
		/* Transmit Abort Output */
		if (xmitAO() == -1) {
			/* This won't return. */
			fatal_tty_error("write");
		}
		return (0);
	} else if (!MODE_LOCAL_CHARS(globalmode)) {
		if (c == termKillChar) {
			xmitEL();
			return (0);
		} else if (c == termEraseChar) {
			xmitEC();	/* Transmit Erase Character */
			return (0);
		}
	}
	return (1);
}


/*
 * Flush output to the terminal
 */

void
TerminalFlushOutput()
{
	if (isatty(fileno(stdout))) {
		(void) ioctl(fileno(stdout), TIOCFLUSH, NULL);
	}
}

void
TerminalSaveState()
{
#ifndef	USE_TERMIO
	(void) ioctl(0, TIOCGETP, &ottyb);
	(void) ioctl(0, TIOCGETC, &otc);
	(void) ioctl(0, TIOCGLTC, &oltc);
	(void) ioctl(0, TIOCLGET, &olmode);

	ntc = otc;
	nltc = oltc;
	nttyb = ottyb;

#else	/* USE_TERMIO */
	(void) tcgetattr(0, &old_tc);

	new_tc = old_tc;
	termAytChar = CONTROL('T');
#endif	/* USE_TERMIO */
}

cc_t *
tcval(func)
	register int func;
{
	switch (func) {
	case SLC_IP:	return (&termIntChar);
	case SLC_ABORT:	return (&termQuitChar);
	case SLC_EOF:	return (&termEofChar);
	case SLC_EC:	return (&termEraseChar);
	case SLC_EL:	return (&termKillChar);
	case SLC_XON:	return (&termStartChar);
	case SLC_XOFF:	return (&termStopChar);
	case SLC_FORW1:	return (&termForw1Char);
#ifdef	USE_TERMIO
	case SLC_FORW2:	return (&termForw2Char);
	case SLC_AO:	return (&termFlushChar);
	case SLC_SUSP:	return (&termSuspChar);
	case SLC_EW:	return (&termWerasChar);
	case SLC_RP:	return (&termRprntChar);
	case SLC_LNEXT:	return (&termLiteralNextChar);
#endif

	case SLC_SYNCH:
	case SLC_BRK:
	case SLC_EOR:
	default:
		return ((cc_t *)0);
	}
}

void
TerminalDefaultChars()
{
#ifndef	USE_TERMIO
	ntc = otc;
	nltc = oltc;
	nttyb.sg_kill = ottyb.sg_kill;
	nttyb.sg_erase = ottyb.sg_erase;
#else	/* USE_TERMIO */
	(void) memcpy(new_tc.c_cc, old_tc.c_cc, sizeof (old_tc.c_cc));
	termAytChar = CONTROL('T');
#endif	/* USE_TERMIO */
}

/*
 * TerminalNewMode - set up terminal to a specific mode.
 *	MODE_ECHO: do local terminal echo
 *	MODE_FLOW: do local flow control
 *	MODE_TRAPSIG: do local mapping to TELNET IAC sequences
 *	MODE_EDIT: do local line editing
 *
 *	Command mode:
 *		MODE_ECHO|MODE_EDIT|MODE_FLOW|MODE_TRAPSIG
 *		local echo
 *		local editing
 *		local xon/xoff
 *		local signal mapping
 *
 *	Linemode:
 *		local/no editing
 *	Both Linemode and Single Character mode:
 *		local/remote echo
 *		local/no xon/xoff
 *		local/no signal mapping
 */


void
TerminalNewMode(f)
	register int f;
{
	static int prevmode = -2;	/* guaranteed unique */
#ifndef	USE_TERMIO
	struct tchars tc;
	struct ltchars ltc;
	struct sgttyb sb;
	int lmode;
#else	/* USE_TERMIO */
	struct termio tmp_tc;
#endif	/* USE_TERMIO */
	int onoff;
	int old;
	cc_t esc;
	sigset_t nset;

	globalmode = f&~MODE_FORCE;
	if (prevmode == f)
		return;

	/*
	 * Write any outstanding data before switching modes
	 * ttyflush() returns 0 only when there was no data
	 * to write out; it returns -1 if it couldn't do
	 * anything at all, returns -2 if there was a write
	 * error (other than EWOULDBLOCK), and otherwise it
	 * returns 1 + the number of characters left to write.
	 */
#ifndef	USE_TERMIO
	/*
	 * We would really like ask the kernel to wait for the output
	 * to drain, like we can do with the TCSADRAIN, but we don't have
	 * that option.  The only ioctl that waits for the output to
	 * drain, TIOCSETP, also flushes the input queue, which is NOT
	 * what we want(TIOCSETP is like TCSADFLUSH).
	 */
#endif
	old = ttyflush(SYNCHing|flushout);
	if (old == -1 || old > 1) {
#ifdef	USE_TERMIO
		(void) tcgetattr(tin, &tmp_tc);
#endif	/* USE_TERMIO */
		do {
			/*
			 * Wait for data to drain, then flush again.
			 */
#ifdef	USE_TERMIO
			(void) tcsetattr(tin, TCSADRAIN, &tmp_tc);
#endif	/* USE_TERMIO */
			old = ttyflush(SYNCHing|flushout);
		} while (old == -1 || old > 1);
	}

	old = prevmode;
	prevmode = f&~MODE_FORCE;
#ifndef	USE_TERMIO
	sb = nttyb;
	tc = ntc;
	ltc = nltc;
	lmode = olmode;
#else
	tmp_tc = new_tc;
#endif

	if (f&MODE_ECHO) {
#ifndef	USE_TERMIO
		sb.sg_flags |= ECHO;
#else
		tmp_tc.c_lflag |= ECHO;
		tmp_tc.c_oflag |= ONLCR;
		if (crlf)
			tmp_tc.c_iflag |= ICRNL;
#endif
	} else {
#ifndef	USE_TERMIO
		sb.sg_flags &= ~ECHO;
#else
		tmp_tc.c_lflag &= ~ECHO;
		tmp_tc.c_oflag &= ~ONLCR;
#ifdef notdef
		if (crlf)
			tmp_tc.c_iflag &= ~ICRNL;
#endif
#endif
	}

	if ((f&MODE_FLOW) == 0) {
#ifndef	USE_TERMIO
		tc.t_startc = _POSIX_VDISABLE;
		tc.t_stopc = _POSIX_VDISABLE;
#else
		tmp_tc.c_iflag &= ~(IXOFF|IXON); /* Leave the IXANY bit alone */
	} else {
		if (restartany < 0) {
			/* Leave the IXANY bit alone */
			tmp_tc.c_iflag |= IXOFF|IXON;
		} else if (restartany > 0) {
			tmp_tc.c_iflag |= IXOFF|IXON|IXANY;
		} else {
			tmp_tc.c_iflag |= IXOFF|IXON;
			tmp_tc.c_iflag &= ~IXANY;
		}
#endif
	}

	if ((f&MODE_TRAPSIG) == 0) {
#ifndef	USE_TERMIO
		tc.t_intrc = _POSIX_VDISABLE;
		tc.t_quitc = _POSIX_VDISABLE;
		tc.t_eofc = _POSIX_VDISABLE;
		ltc.t_suspc = _POSIX_VDISABLE;
		ltc.t_dsuspc = _POSIX_VDISABLE;
#else
		tmp_tc.c_lflag &= ~ISIG;
#endif
		localchars = 0;
	} else {
#ifdef	USE_TERMIO
		tmp_tc.c_lflag |= ISIG;
#endif
		localchars = 1;
	}

	if (f&MODE_EDIT) {
#ifndef	USE_TERMIO
		sb.sg_flags &= ~CBREAK;
		sb.sg_flags |= CRMOD;
#else
		tmp_tc.c_lflag |= ICANON;
#endif
	} else {
#ifndef	USE_TERMIO
		sb.sg_flags |= CBREAK;
		if (f&MODE_ECHO)
			sb.sg_flags |= CRMOD;
		else
			sb.sg_flags &= ~CRMOD;
#else
		tmp_tc.c_lflag &= ~ICANON;
		tmp_tc.c_iflag &= ~ICRNL;
		tmp_tc.c_cc[VMIN] = 1;
		tmp_tc.c_cc[VTIME] = 0;
#endif
	}

	if ((f&(MODE_EDIT|MODE_TRAPSIG)) == 0) {
#ifndef	USE_TERMIO
		ltc.t_lnextc = _POSIX_VDISABLE;
#else
		tmp_tc.c_cc[VLNEXT] = (cc_t)(_POSIX_VDISABLE);
#endif
	}

	if (f&MODE_SOFT_TAB) {
#ifndef USE_TERMIO
		sb.sg_flags |= XTABS;
#else
		tmp_tc.c_oflag &= ~TABDLY;
		tmp_tc.c_oflag |= TAB3;
#endif
	} else {
#ifndef USE_TERMIO
		sb.sg_flags &= ~XTABS;
#else
		tmp_tc.c_oflag &= ~TABDLY;
#endif
	}

	if (f&MODE_LIT_ECHO) {
#ifndef USE_TERMIO
		lmode &= ~LCTLECH;
#else
		tmp_tc.c_lflag &= ~ECHOCTL;
#endif
	} else {
#ifndef USE_TERMIO
		lmode |= LCTLECH;
#else
		tmp_tc.c_lflag |= ECHOCTL;
#endif
	}

	if (f == -1) {
		onoff = 0;
	} else {
#ifndef	USE_TERMIO
		if (f & MODE_OUTBIN)
			lmode |= LLITOUT;
		else
			lmode &= ~LLITOUT;
#else
		if (f & MODE_OUTBIN) {
			tmp_tc.c_cflag &= ~(CSIZE|PARENB);
			tmp_tc.c_cflag |= CS8;
			tmp_tc.c_oflag &= ~OPOST;
		} else {
			tmp_tc.c_cflag &= ~(CSIZE|PARENB);
			tmp_tc.c_cflag |= old_tc.c_cflag & (CSIZE|PARENB);
			tmp_tc.c_oflag |= OPOST;
		}
#endif
		onoff = 1;
	}

	if (f != -1) {

		(void) signal(SIGTSTP, susp);

#if	defined(USE_TERMIO) && defined(NOKERNINFO)
		tmp_tc.c_lflag |= NOKERNINFO;
#endif
		/*
		 * We don't want to process ^Y here.  It's just another
		 * character that we'll pass on to the back end.  It has
		 * to process it because it will be processed when the
		 * user attempts to read it, not when we send it.
		 */
#ifndef	USE_TERMIO
		ltc.t_dsuspc = _POSIX_VDISABLE;
#else
		tmp_tc.c_cc[VDSUSP] = (cc_t)(_POSIX_VDISABLE);
#endif
#ifdef	USE_TERMIO
		/*
		 * If the VEOL character is already set, then use VEOL2,
		 * otherwise use VEOL.
		 */
		esc = (rlogin != _POSIX_VDISABLE) ? rlogin : escape;
		if ((tmp_tc.c_cc[VEOL] != esc)
		    /* XXX */ &&
		    (tmp_tc.c_cc[VEOL2] != esc)
		    /* XXX */) {
			if (tmp_tc.c_cc[VEOL] == (cc_t)(_POSIX_VDISABLE))
				tmp_tc.c_cc[VEOL] = esc;
			else if (tmp_tc.c_cc[VEOL2] == (cc_t)(_POSIX_VDISABLE))
				tmp_tc.c_cc[VEOL2] = esc;
		}
#else
		if (tc.t_brkc == (cc_t)(_POSIX_VDISABLE))
			tc.t_brkc = esc;
#endif
	} else {
		(void) signal(SIGTSTP, SIG_DFL);
		(void) sigemptyset(&nset);
		(void) sigaddset(&nset, SIGTSTP);
		(void) sigprocmask(SIG_UNBLOCK, &nset, 0);
#ifndef USE_TERMIO
		ltc = oltc;
		tc = otc;
		sb = ottyb;
		lmode = olmode;
#else
		tmp_tc = old_tc;
#endif
	}
	if (isatty(tin)) {
#ifndef USE_TERMIO
		(void) ioctl(tin, TIOCLSET, &lmode);
		(void) ioctl(tin, TIOCSLTC, &ltc);
		(void) ioctl(tin, TIOCSETC, &tc);
		(void) ioctl(tin, TIOCSETN, &sb);
#else
		if (tcsetattr(tin, TCSADRAIN, &tmp_tc) < 0)
			(void) tcsetattr(tin, TCSANOW, &tmp_tc);
#endif
		(void) ioctl(tin, FIONBIO, &onoff);
		(void) ioctl(tout, FIONBIO, &onoff);
	}

}

/*
 * This code assumes that the values B0, B50, B75...
 * are in ascending order.  They do not have to be
 * contiguous.
 */
static struct termspeeds {
	int speed;
	int value;
} termspeeds[] = {
	{ 0, B0 },		{ 50, B50 },		{ 75, B75 },
	{ 110, B110 },		{ 134, B134 },		{ 150, B150 },
	{ 200, B200 },		{ 300, B300 },		{ 600, B600 },
	{ 1200, B1200 },	{ 1800, B1800 },	{ 2400, B2400 },
	{ 4800, B4800 },	{ 9600, B9600 },	{ 19200, B19200 },
	{ 38400, B38400 },	{ 57600, B57600 },	{ 76800, B76800 },
	{ 115200, B115200 },	{ 153600, B153600 },	{ 230400, B230400 },
	{ 307200, B307200 },	{ 460800, B460800 },	{ 921600, B921600 },
	{ 1000000, B1000000 },	{ 1152000, B1152000 },	{ 1500000, B1500000 },
	{ 2000000, B2000000 },	{ 2500000, B2500000 },	{ 3000000, B3000000 },
	{ 3500000, B3500000 },	{ 4000000, B4000000 },	{ -1, B0 }
};

void
TerminalSpeeds(ispeed, ospeed)
	int *ispeed;
	int *ospeed;
{
	register struct termspeeds *tp;
	register int in, out;

	out = cfgetospeed(&old_tc);
	in = cfgetispeed(&old_tc);
	if (in == 0)
		in = out;

	tp = termspeeds;
	while ((tp->speed != -1) && (tp->value < in)) {
		tp++;
	}
	if (tp->speed == -1)
		tp--;			/* back up to fastest defined speed */
	*ispeed = tp->speed;

	tp = termspeeds;
	while ((tp->speed != -1) && (tp->value < out)) {
		tp++;
	}
	if (tp->speed == -1)
		tp--;
	*ospeed = tp->speed;
}

int
TerminalWindowSize(rows, cols)
	unsigned short *rows, *cols;
{
	struct winsize ws;

	if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) >= 0) {
		*rows = ws.ws_row;
		*cols = ws.ws_col;
		return (1);
	}
	return (0);
}

static void
NetNonblockingIO(fd, onoff)
	int fd;
	int onoff;
{
	(void) ioctl(fd, FIONBIO, &onoff);
}

/*
 * Various signal handling routines.
 */

/* ARGSUSED */
static SIG_FUNC_RET
deadpeer(sig)
	int sig;
{
	/*
	 * Once is all we should catch SIGPIPE.  If we get it again,
	 * it means we tried to put still more data out to a pipe
	 * which has disappeared.  In that case, telnet will exit.
	 */
	(void) signal(SIGPIPE, SIG_IGN);
	flushout = 1;
	setcommandmode();
	longjmp(peerdied, -1);
}

boolean_t intr_happened	= B_FALSE;
boolean_t intr_waiting	= B_FALSE;

/* ARGSUSED */
static SIG_FUNC_RET
intr(sig)
	int sig;
{
	if (intr_waiting) {
		intr_happened = 1;
		return;
	}
	(void) signal(SIGINT, intr);
	if (localchars) {
		intp();
		return;
	}
	setcommandmode();
	longjmp(toplevel, -1);
}

/* ARGSUSED */
static SIG_FUNC_RET
intr2(sig)
	int sig;
{
	(void) signal(SIGQUIT, intr2);
	if (localchars) {
		/*
		 * Ignore return to the next two function calls
		 * since we're doing SIGQUIT
		 */
#ifdef	KLUDGELINEMODE
		if (kludgelinemode) {
			(void) sendbrk();
		}
		else
#endif
			sendabort();
		return;
	}
}

/* ARGSUSED */
static SIG_FUNC_RET
susp(sig)
	int sig;
{
	(void) signal(SIGTSTP, susp);
	if ((rlogin != _POSIX_VDISABLE) && rlogin_susp())
		return;
	if (localchars)
		sendsusp();
}

/* ARGSUSED */
static SIG_FUNC_RET
sendwin(sig)
	int sig;
{
	(void) signal(SIGWINCH, sendwin);
	if (connected) {
		sendnaws();
	}
}

void
sys_telnet_init()
{
	(void) signal(SIGINT, intr);
	(void) signal(SIGQUIT, intr2);
	(void) signal(SIGPIPE, deadpeer);
	(void) signal(SIGWINCH, sendwin);
	(void) signal(SIGTSTP, susp);

	setconnmode(0);

	NetNonblockingIO(net, 1);

	if (SetSockOpt(net, SOL_SOCKET, SO_OOBINLINE, 1) == -1) {
		perror("SetSockOpt");
	}
}


/*
 * fatal_tty_error -
 *	Handle case where there is an unrecoverable error on the tty
 *      connections.  Print an error, reset the terminal settings
 *	and get out as painlessly as possible.
 */
void
fatal_tty_error(char *doing_what)
{
	TerminalNewMode(-1);
	(void) fprintf(stderr, "Error processing %s:  %s\n", doing_what,
	    strerror(errno));
	exit(1);
}


/*
 * Process rings -
 *
 *	This routine tries to fill up/empty our various rings.
 *
 *	The parameter specifies whether this is a poll operation,
 *	or a block-until-something-happens operation.
 *
 *	The return value is 1 if something happened, 0 if not.
 *	If poll == 0, then block until something to do.
 */
int
process_rings(int netin, int netout, int netex, int ttyin, int ttyout, int poll)
{
	int c;
	/*
	 * One wants to be a bit careful about setting returnValue
	 * to one, since a one implies we did some useful work,
	 * and therefore probably won't be called to block next
	 * time (TN3270 mode only).
	 */
	int returnValue = 0;
	static struct timeval TimeValue = { 0 };
	int i;

	if (netout) {
		FD_SET(net, &obits);
	}
	if (ttyout) {
		FD_SET(tout, &obits);
	}
	if (ttyin) {
		FD_SET(tin, &ibits);
	}
	if (netin) {
		FD_SET(net, &ibits);
	}
	if (netex) {
		FD_SET(net, &xbits);
	}
	if ((c = select(16, &ibits, &obits, &xbits,
			(poll == 0) ? NULL : &TimeValue)) < 0) {
		if (c == -1) {
			/*
			 * we can get EINTR if we are in line mode,
			 * and the user does an escape (TSTP), or
			 * some other signal generator.
			 */
			if (errno == EINTR) {
				return (0);
			}
			/* I don't like this, does it ever happen? */
			(void) printf("sleep(5) from telnet, after select\r\n");
			(void) sleep(5);
		}
		return (0);
	}

	/*
	 * Any urgent data?
	 */
	if (FD_ISSET(net, &xbits)) {
		FD_CLR(net, &xbits);
		SYNCHing = 1;

		/* flush any data that is already enqueued */
		i = ttyflush(1);
		if (i == -2) {
			/* This will not return. */
			fatal_tty_error("write");
		}
	}

	/*
	 * Something to read from the network...
	 */
	if (FD_ISSET(net, &ibits)) {
		int canread;

		FD_CLR(net, &ibits);
		canread = ring_empty_consecutive(&netiring);
		c = recv(net, netiring.supply, canread, 0);
		if (c < 0 && errno == EWOULDBLOCK) {
			c = 0;
		} else if (c <= 0) {
			return (-1);
		}
		if (netdata) {
			Dump('<', netiring.supply, c);
		}
		if (c)
			ring_supplied(&netiring, c);
		returnValue = 1;
	}

	/*
	 * Something to read from the tty...
	 */
	if (FD_ISSET(tin, &ibits)) {
		FD_CLR(tin, &ibits);
		c = TerminalRead((char *)ttyiring.supply,
		    ring_empty_consecutive(&ttyiring));
		if (c < 0) {
			if (errno != EWOULDBLOCK) {
				/* This will not return. */
				fatal_tty_error("read");
			}
			c = 0;
		} else {
			/* EOF detection for line mode!!!! */
			if ((c == 0) && MODE_LOCAL_CHARS(globalmode) &&
			    isatty(tin)) {
				/* must be an EOF... */
				eof_pending = 1;
				return (1);
			}
			if (c <= 0) {
				returnValue = -1;
				goto next;
			}
			if (termdata) {
				Dump('<', ttyiring.supply, c);
			}
			ring_supplied(&ttyiring, c);
		}
		returnValue = 1;		/* did something useful */
	}

next:
	if (FD_ISSET(net, &obits)) {
		FD_CLR(net, &obits);
		returnValue |= netflush();
	}
	if (FD_ISSET(tout, &obits)) {
		FD_CLR(tout, &obits);
		i = ttyflush(SYNCHing|flushout);
		if (i == -2) {
			/* This will not return. */
			fatal_tty_error("write");
		}
		returnValue |= (i > 0);
	}

	return (returnValue);
}