xref: /csrg-svn/usr.bin/telnet/sys_bsd.c (revision 36274)
132147Sminshall /*
233685Sbostic  * Copyright (c) 1988 Regents of the University of California.
333685Sbostic  * All rights reserved.
433685Sbostic  *
533685Sbostic  * Redistribution and use in source and binary forms are permitted
634898Sbostic  * provided that the above copyright notice and this paragraph are
734898Sbostic  * duplicated in all such forms and that any documentation,
834898Sbostic  * advertising materials, and other materials related to such
934898Sbostic  * distribution and use acknowledge that the software was developed
1034898Sbostic  * by the University of California, Berkeley.  The name of the
1134898Sbostic  * University may not be used to endorse or promote products derived
1234898Sbostic  * from this software without specific prior written permission.
1334898Sbostic  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
1434898Sbostic  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
1534898Sbostic  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
1633685Sbostic  */
1733685Sbostic 
1833685Sbostic #ifndef lint
19*36274Sminshall static char sccsid[] = "@(#)sys_bsd.c	1.16 (Berkeley) 11/29/88";
2033685Sbostic #endif /* not lint */
2133685Sbostic 
2233685Sbostic /*
2332147Sminshall  * The following routines try to encapsulate what is system dependent
2432147Sminshall  * (at least between 4.x and dos) which is used in telnet.c.
2532147Sminshall  */
2632147Sminshall 
2732147Sminshall #if	defined(unix)
2832147Sminshall 
29*36274Sminshall #include <fcntl.h>
3032147Sminshall #include <sys/ioctl.h>
3132381Sminshall #include <sys/types.h>
3232147Sminshall #include <sys/time.h>
3332531Sminshall #include <sys/socket.h>
3432147Sminshall #include <signal.h>
3532531Sminshall #include <errno.h>
3632147Sminshall 
3732381Sminshall #include "ring.h"
3832381Sminshall 
3932657Sminshall #include "fdset.h"
4032657Sminshall 
4132147Sminshall #include "defines.h"
4232147Sminshall #include "externs.h"
4332147Sminshall #include "types.h"
4432147Sminshall 
4532147Sminshall int
4632531Sminshall 	tout,			/* Output file descriptor */
4732531Sminshall 	tin,			/* Input file descriptor */
4836242Sminshall 	net;
4932147Sminshall 
5032147Sminshall static struct	tchars otc = { 0 }, ntc = { 0 };
5132147Sminshall static struct	ltchars oltc = { 0 }, nltc = { 0 };
5232147Sminshall static struct	sgttyb ottyb = { 0 }, nttyb = { 0 };
5332147Sminshall 
5432531Sminshall static fd_set ibits, obits, xbits;
5532147Sminshall 
5632531Sminshall 
5732531Sminshall init_sys()
5832531Sminshall {
5932531Sminshall     tout = fileno(stdout);
6032531Sminshall     tin = fileno(stdin);
6132531Sminshall     FD_ZERO(&ibits);
6232531Sminshall     FD_ZERO(&obits);
6332531Sminshall     FD_ZERO(&xbits);
6432531Sminshall 
6532531Sminshall     errno = 0;
6632531Sminshall }
6732531Sminshall 
6832531Sminshall 
6933286Sminshall TerminalWrite(buf, n)
7032147Sminshall char	*buf;
7132147Sminshall int	n;
7232147Sminshall {
7333286Sminshall     return write(tout, buf, n);
7432147Sminshall }
7532147Sminshall 
7633286Sminshall TerminalRead(buf, n)
7732147Sminshall char	*buf;
7832147Sminshall int	n;
7932147Sminshall {
8033286Sminshall     return read(tin, buf, n);
8132147Sminshall }
8232147Sminshall 
8332147Sminshall /*
8432147Sminshall  *
8532147Sminshall  */
8632147Sminshall 
8732147Sminshall int
8832553Sminshall TerminalAutoFlush()
8932147Sminshall {
9032147Sminshall #if	defined(LNOFLSH)
9132147Sminshall     int flush;
9232147Sminshall 
9332147Sminshall     ioctl(0, TIOCLGET, (char *)&flush);
9432147Sminshall     return !(flush&LNOFLSH);	/* if LNOFLSH, no autoflush */
9532147Sminshall #else	/* LNOFLSH */
9632147Sminshall     return 1;
9732147Sminshall #endif	/* LNOFLSH */
9832147Sminshall }
9932147Sminshall 
10032147Sminshall /*
10132147Sminshall  * TerminalSpecialChars()
10232147Sminshall  *
10332147Sminshall  * Look at an input character to see if it is a special character
10432147Sminshall  * and decide what to do.
10532147Sminshall  *
10632147Sminshall  * Output:
10732147Sminshall  *
10832147Sminshall  *	0	Don't add this character.
10932147Sminshall  *	1	Do add this character
11032147Sminshall  */
11132147Sminshall 
11232147Sminshall int
11332553Sminshall TerminalSpecialChars(c)
11432147Sminshall int	c;
11532147Sminshall {
11632553Sminshall     void xmitAO(), xmitEL(), xmitEC(), intp(), sendbrk();
11732147Sminshall 
11832147Sminshall     if (c == ntc.t_intrc) {
11932147Sminshall 	intp();
12032147Sminshall 	return 0;
12132147Sminshall     } else if (c == ntc.t_quitc) {
12232147Sminshall 	sendbrk();
12332147Sminshall 	return 0;
12432147Sminshall     } else if (c == nltc.t_flushc) {
12532147Sminshall 	xmitAO();		/* Transmit Abort Output */
12632147Sminshall 	return 0;
12732147Sminshall     } else if (!MODE_LOCAL_CHARS(globalmode)) {
12832147Sminshall 	if (c == nttyb.sg_kill) {
12932147Sminshall 	    xmitEL();
13032147Sminshall 	    return 0;
13132147Sminshall 	} else if (c == nttyb.sg_erase) {
13232147Sminshall 	    xmitEC();		/* Transmit Erase Character */
13332147Sminshall 	    return 0;
13432147Sminshall 	}
13532147Sminshall     }
13632147Sminshall     return 1;
13732147Sminshall }
13832147Sminshall 
13932147Sminshall 
14032147Sminshall /*
14132147Sminshall  * Flush output to the terminal
14232147Sminshall  */
14332147Sminshall 
14432147Sminshall void
14532553Sminshall TerminalFlushOutput()
14632147Sminshall {
14732147Sminshall     (void) ioctl(fileno(stdout), TIOCFLUSH, (char *) 0);
14832147Sminshall }
14932147Sminshall 
15032147Sminshall void
15132553Sminshall TerminalSaveState()
15232147Sminshall {
15332147Sminshall     ioctl(0, TIOCGETP, (char *)&ottyb);
15432147Sminshall     ioctl(0, TIOCGETC, (char *)&otc);
15532147Sminshall     ioctl(0, TIOCGLTC, (char *)&oltc);
15632147Sminshall 
15732147Sminshall     ntc = otc;
15832147Sminshall     nltc = oltc;
15932147Sminshall     nttyb = ottyb;
16032254Sminshall 
16132254Sminshall     termEofChar = ntc.t_eofc;
16232254Sminshall     termEraseChar = nttyb.sg_erase;
16332254Sminshall     termFlushChar = nltc.t_flushc;
16432254Sminshall     termIntChar = ntc.t_intrc;
16532254Sminshall     termKillChar = nttyb.sg_kill;
16632254Sminshall     termQuitChar = ntc.t_quitc;
16732147Sminshall }
16832147Sminshall 
16932147Sminshall void
17032553Sminshall TerminalRestoreState()
17132147Sminshall {
17232147Sminshall }
17332147Sminshall 
17432147Sminshall /*
17532147Sminshall  * TerminalNewMode - set up terminal to a specific mode.
17632147Sminshall  */
17732147Sminshall 
17832147Sminshall 
17932147Sminshall void
18033286Sminshall TerminalNewMode(f)
18132147Sminshall register int f;
18232147Sminshall {
18332147Sminshall     static int prevmode = 0;
18432147Sminshall     struct tchars *tc;
18532147Sminshall     struct tchars tc3;
18632147Sminshall     struct ltchars *ltc;
18732147Sminshall     struct sgttyb sb;
18832147Sminshall     int onoff;
18932147Sminshall     int old;
19032147Sminshall     struct	tchars notc2;
19132147Sminshall     struct	ltchars noltc2;
19232147Sminshall     static struct	tchars notc =	{ -1, -1, -1, -1, -1, -1 };
19332147Sminshall     static struct	ltchars noltc =	{ -1, -1, -1, -1, -1, -1 };
19432147Sminshall 
19532147Sminshall     globalmode = f;
19632147Sminshall     if (prevmode == f)
19732147Sminshall 	return;
19832147Sminshall     old = prevmode;
19932147Sminshall     prevmode = f;
20032147Sminshall     sb = nttyb;
20132147Sminshall 
20232147Sminshall     switch (f) {
20332147Sminshall 
20432147Sminshall     case 0:
20532147Sminshall 	onoff = 0;
20632147Sminshall 	tc = &otc;
20732147Sminshall 	ltc = &oltc;
20832147Sminshall 	break;
20932147Sminshall 
21032147Sminshall     case 1:		/* remote character processing, remote echo */
21132147Sminshall     case 2:		/* remote character processing, local echo */
21232147Sminshall     case 6:		/* 3270 mode - like 1, but with xon/xoff local */
21332147Sminshall 		    /* (might be nice to have "6" in telnet also...) */
21432147Sminshall 	    sb.sg_flags |= CBREAK;
21532147Sminshall 	    if ((f == 1) || (f == 6)) {
21632147Sminshall 		sb.sg_flags &= ~(ECHO|CRMOD);
21732147Sminshall 	    } else {
21832147Sminshall 		sb.sg_flags |= ECHO|CRMOD;
21932147Sminshall 	    }
22032147Sminshall 	    sb.sg_erase = sb.sg_kill = -1;
22132147Sminshall 	    if (f == 6) {
22232147Sminshall 		tc = &tc3;
22332147Sminshall 		tc3 = notc;
22432147Sminshall 		    /* get XON, XOFF characters */
22532147Sminshall 		tc3.t_startc = otc.t_startc;
22632147Sminshall 		tc3.t_stopc = otc.t_stopc;
22732147Sminshall 	    } else {
22832147Sminshall 		/*
22932147Sminshall 		 * If user hasn't specified one way or the other,
23032147Sminshall 		 * then default to not trapping signals.
23132147Sminshall 		 */
23232147Sminshall 		if (!donelclchars) {
23332147Sminshall 		    localchars = 0;
23432147Sminshall 		}
23532147Sminshall 		if (localchars) {
23632147Sminshall 		    notc2 = notc;
23732147Sminshall 		    notc2.t_intrc = ntc.t_intrc;
23832147Sminshall 		    notc2.t_quitc = ntc.t_quitc;
23932147Sminshall 		    tc = &notc2;
24032147Sminshall 		} else {
24132147Sminshall 		    tc = &notc;
24232147Sminshall 		}
24332147Sminshall 	    }
24432147Sminshall 	    ltc = &noltc;
24532147Sminshall 	    onoff = 1;
24632147Sminshall 	    break;
24732147Sminshall     case 3:		/* local character processing, remote echo */
24832147Sminshall     case 4:		/* local character processing, local echo */
24932147Sminshall     case 5:		/* local character processing, no echo */
25032147Sminshall 	    sb.sg_flags &= ~CBREAK;
25132147Sminshall 	    sb.sg_flags |= CRMOD;
25232147Sminshall 	    if (f == 4)
25332147Sminshall 		sb.sg_flags |= ECHO;
25432147Sminshall 	    else
25532147Sminshall 		sb.sg_flags &= ~ECHO;
25632147Sminshall 	    notc2 = ntc;
25732147Sminshall 	    tc = &notc2;
25832147Sminshall 	    noltc2 = oltc;
25932147Sminshall 	    ltc = &noltc2;
26032147Sminshall 	    /*
26132147Sminshall 	     * If user hasn't specified one way or the other,
26232147Sminshall 	     * then default to trapping signals.
26332147Sminshall 	     */
26432147Sminshall 	    if (!donelclchars) {
26532147Sminshall 		localchars = 1;
26632147Sminshall 	    }
26732147Sminshall 	    if (localchars) {
26832147Sminshall 		notc2.t_brkc = nltc.t_flushc;
26932147Sminshall 		noltc2.t_flushc = -1;
27032147Sminshall 	    } else {
27132147Sminshall 		notc2.t_intrc = notc2.t_quitc = -1;
27232147Sminshall 	    }
27332147Sminshall 	    noltc2.t_suspc = escape;
27432147Sminshall 	    noltc2.t_dsuspc = -1;
27532147Sminshall 	    onoff = 1;
27632147Sminshall 	    break;
27732147Sminshall 
27832147Sminshall     default:
27932147Sminshall 	    return;
28032147Sminshall     }
28133286Sminshall     ioctl(tin, TIOCSLTC, (char *)ltc);
28233286Sminshall     ioctl(tin, TIOCSETC, (char *)tc);
28333286Sminshall     ioctl(tin, TIOCSETP, (char *)&sb);
28432147Sminshall #if	(!defined(TN3270)) || ((!defined(NOT43)) || defined(PUTCHAR))
28533286Sminshall     ioctl(tin, FIONBIO, (char *)&onoff);
28633286Sminshall     ioctl(tout, FIONBIO, (char *)&onoff);
28732147Sminshall #endif	/* (!defined(TN3270)) || ((!defined(NOT43)) || defined(PUTCHAR)) */
28832147Sminshall #if	defined(TN3270)
28936242Sminshall     if (noasynchtty == 0) {
29033286Sminshall 	ioctl(tin, FIOASYNC, (char *)&onoff);
29132147Sminshall     }
29232147Sminshall #endif	/* defined(TN3270) */
29332147Sminshall 
29432147Sminshall     if (MODE_LINE(f)) {
29532147Sminshall 	void doescape();
29632147Sminshall 
29734849Sminshall 	(void) signal(SIGTSTP, (int (*)())doescape);
29832147Sminshall     } else if (MODE_LINE(old)) {
29934849Sminshall 	(void) signal(SIGTSTP, SIG_DFL);
30032147Sminshall 	sigsetmask(sigblock(0) & ~(1<<(SIGTSTP-1)));
30132147Sminshall     }
30232147Sminshall }
30332147Sminshall 
30432147Sminshall 
30532147Sminshall int
30635417Sminshall NetClose(fd)
30735417Sminshall int	fd;
30832147Sminshall {
30935417Sminshall     return close(fd);
31032147Sminshall }
31132147Sminshall 
31232147Sminshall 
31332147Sminshall void
31432553Sminshall NetNonblockingIO(fd, onoff)
31532147Sminshall int
31632147Sminshall 	fd,
31732147Sminshall 	onoff;
31832147Sminshall {
31932147Sminshall     ioctl(fd, FIONBIO, (char *)&onoff);
32032147Sminshall }
32132147Sminshall 
32234849Sminshall #if	defined(TN3270)
32332147Sminshall void
32432553Sminshall NetSigIO(fd, onoff)
32532147Sminshall int
32632147Sminshall 	fd,
32732147Sminshall 	onoff;
32832147Sminshall {
32932147Sminshall     ioctl(fd, FIOASYNC, (char *)&onoff);	/* hear about input */
33032147Sminshall }
33132147Sminshall 
33232147Sminshall void
33332553Sminshall NetSetPgrp(fd)
33432147Sminshall int fd;
33532147Sminshall {
33632147Sminshall     int myPid;
33732147Sminshall 
33832147Sminshall     myPid = getpid();
339*36274Sminshall     fcntl(fd, F_SETOWN, myPid);
34032147Sminshall }
34134849Sminshall #endif	/*defined(TN3270)*/
34232553Sminshall 
34332553Sminshall /*
34432553Sminshall  * Various signal handling routines.
34532553Sminshall  */
34632147Sminshall 
34733286Sminshall static void
34832553Sminshall deadpeer()
34932553Sminshall {
35032553Sminshall 	setcommandmode();
35132553Sminshall 	longjmp(peerdied, -1);
35232553Sminshall }
35332147Sminshall 
35433286Sminshall static void
35532553Sminshall intr()
35632553Sminshall {
35732553Sminshall     if (localchars) {
35832553Sminshall 	intp();
35932553Sminshall 	return;
36032553Sminshall     }
36132553Sminshall     setcommandmode();
36232553Sminshall     longjmp(toplevel, -1);
36332553Sminshall }
36432553Sminshall 
36533286Sminshall static void
36632553Sminshall intr2()
36732553Sminshall {
36832553Sminshall     if (localchars) {
36932553Sminshall 	sendbrk();
37032553Sminshall 	return;
37132553Sminshall     }
37232553Sminshall }
37332553Sminshall 
37433286Sminshall static void
37532553Sminshall doescape()
37632553Sminshall {
37732553Sminshall     command(0);
37832553Sminshall }
37932553Sminshall 
38032553Sminshall void
38132531Sminshall sys_telnet_init()
38232531Sminshall {
38334849Sminshall     (void) signal(SIGINT, (int (*)())intr);
38434849Sminshall     (void) signal(SIGQUIT, (int (*)())intr2);
38534849Sminshall     (void) signal(SIGPIPE, (int (*)())deadpeer);
38632553Sminshall 
38732531Sminshall     setconnmode();
38832531Sminshall 
38932531Sminshall     NetNonblockingIO(net, 1);
39032531Sminshall 
39132531Sminshall #if	defined(TN3270)
39236242Sminshall     if (noasynchnet == 0) {			/* DBX can't handle! */
39332531Sminshall 	NetSigIO(net, 1);
39432531Sminshall 	NetSetPgrp(net);
39532531Sminshall     }
39632531Sminshall #endif	/* defined(TN3270) */
39732531Sminshall 
39832531Sminshall #if	defined(SO_OOBINLINE)
39934849Sminshall     if (SetSockOpt(net, SOL_SOCKET, SO_OOBINLINE, 1) == -1) {
40034849Sminshall 	perror("SetSockOpt");
40134849Sminshall     }
40232531Sminshall #endif	/* defined(SO_OOBINLINE) */
40332531Sminshall }
40432531Sminshall 
40532531Sminshall /*
40632531Sminshall  * Process rings -
40732531Sminshall  *
40832531Sminshall  *	This routine tries to fill up/empty our various rings.
40932531Sminshall  *
41032531Sminshall  *	The parameter specifies whether this is a poll operation,
41132531Sminshall  *	or a block-until-something-happens operation.
41232531Sminshall  *
41332531Sminshall  *	The return value is 1 if something happened, 0 if not.
41432531Sminshall  */
41532531Sminshall 
41632531Sminshall int
41732531Sminshall process_rings(netin, netout, netex, ttyin, ttyout, poll)
41832531Sminshall int poll;		/* If 0, then block until something to do */
41932531Sminshall {
42032531Sminshall     register int c;
42132531Sminshall 		/* One wants to be a bit careful about setting returnValue
42232531Sminshall 		 * to one, since a one implies we did some useful work,
42332531Sminshall 		 * and therefore probably won't be called to block next
42432531Sminshall 		 * time (TN3270 mode only).
42532531Sminshall 		 */
42632531Sminshall     int returnValue = 0;
42732531Sminshall     static struct timeval TimeValue = { 0 };
42832531Sminshall 
42932531Sminshall     if (netout) {
43032531Sminshall 	FD_SET(net, &obits);
43132531Sminshall     }
43232531Sminshall     if (ttyout) {
43332531Sminshall 	FD_SET(tout, &obits);
43432531Sminshall     }
43532531Sminshall #if	defined(TN3270)
43632531Sminshall     if (ttyin) {
43732531Sminshall 	FD_SET(tin, &ibits);
43832531Sminshall     }
43932531Sminshall #else	/* defined(TN3270) */
44032531Sminshall     if (ttyin) {
44132531Sminshall 	FD_SET(tin, &ibits);
44232531Sminshall     }
44332531Sminshall #endif	/* defined(TN3270) */
44432531Sminshall #if	defined(TN3270)
44532531Sminshall     if (netin) {
44632531Sminshall 	FD_SET(net, &ibits);
44732531Sminshall     }
44832531Sminshall #   else /* !defined(TN3270) */
44932531Sminshall     if (netin) {
45032531Sminshall 	FD_SET(net, &ibits);
45132531Sminshall     }
45232531Sminshall #   endif /* !defined(TN3270) */
45332531Sminshall     if (netex) {
45432531Sminshall 	FD_SET(net, &xbits);
45532531Sminshall     }
45632531Sminshall     if ((c = select(16, &ibits, &obits, &xbits,
45732531Sminshall 			(poll == 0)? (struct timeval *)0 : &TimeValue)) < 0) {
45832531Sminshall 	if (c == -1) {
45932531Sminshall 		    /*
46032531Sminshall 		     * we can get EINTR if we are in line mode,
46132531Sminshall 		     * and the user does an escape (TSTP), or
46232531Sminshall 		     * some other signal generator.
46332531Sminshall 		     */
46432531Sminshall 	    if (errno == EINTR) {
46532531Sminshall 		return 0;
46632531Sminshall 	    }
46732531Sminshall #	    if defined(TN3270)
46832531Sminshall 		    /*
46932531Sminshall 		     * we can get EBADF if we were in transparent
47032531Sminshall 		     * mode, and the transcom process died.
47132531Sminshall 		    */
47232531Sminshall 	    if (errno == EBADF) {
47332531Sminshall 			/*
47432531Sminshall 			 * zero the bits (even though kernel does it)
47532531Sminshall 			 * to make sure we are selecting on the right
47632531Sminshall 			 * ones.
47732531Sminshall 			*/
47832531Sminshall 		FD_ZERO(&ibits);
47932531Sminshall 		FD_ZERO(&obits);
48032531Sminshall 		FD_ZERO(&xbits);
48132531Sminshall 		return 0;
48232531Sminshall 	    }
48332531Sminshall #	    endif /* defined(TN3270) */
48432531Sminshall 		    /* I don't like this, does it ever happen? */
48532531Sminshall 	    printf("sleep(5) from telnet, after select\r\n");
48632531Sminshall 	    sleep(5);
48732531Sminshall 	}
48832531Sminshall 	return 0;
48932531Sminshall     }
49032531Sminshall 
49132531Sminshall     /*
49232531Sminshall      * Any urgent data?
49332531Sminshall      */
49432531Sminshall     if (FD_ISSET(net, &xbits)) {
49532531Sminshall 	FD_CLR(net, &xbits);
49632531Sminshall 	SYNCHing = 1;
49732531Sminshall 	ttyflush(1);	/* flush already enqueued data */
49832531Sminshall     }
49932531Sminshall 
50032531Sminshall     /*
50132531Sminshall      * Something to read from the network...
50232531Sminshall      */
50332531Sminshall     if (FD_ISSET(net, &ibits)) {
50432531Sminshall 	int canread;
50532531Sminshall 
50632531Sminshall 	FD_CLR(net, &ibits);
50732531Sminshall 	canread = ring_empty_consecutive(&netiring);
50832531Sminshall #if	!defined(SO_OOBINLINE)
50932531Sminshall 	    /*
51032531Sminshall 	     * In 4.2 (and some early 4.3) systems, the
51132531Sminshall 	     * OOB indication and data handling in the kernel
51232531Sminshall 	     * is such that if two separate TCP Urgent requests
51332531Sminshall 	     * come in, one byte of TCP data will be overlaid.
51432531Sminshall 	     * This is fatal for Telnet, but we try to live
51532531Sminshall 	     * with it.
51632531Sminshall 	     *
51732531Sminshall 	     * In addition, in 4.2 (and...), a special protocol
51832531Sminshall 	     * is needed to pick up the TCP Urgent data in
51932531Sminshall 	     * the correct sequence.
52032531Sminshall 	     *
52132531Sminshall 	     * What we do is:  if we think we are in urgent
52232531Sminshall 	     * mode, we look to see if we are "at the mark".
52332531Sminshall 	     * If we are, we do an OOB receive.  If we run
52432531Sminshall 	     * this twice, we will do the OOB receive twice,
52532531Sminshall 	     * but the second will fail, since the second
52632531Sminshall 	     * time we were "at the mark", but there wasn't
52732531Sminshall 	     * any data there (the kernel doesn't reset
52832531Sminshall 	     * "at the mark" until we do a normal read).
52932531Sminshall 	     * Once we've read the OOB data, we go ahead
53032531Sminshall 	     * and do normal reads.
53132531Sminshall 	     *
53232531Sminshall 	     * There is also another problem, which is that
53332531Sminshall 	     * since the OOB byte we read doesn't put us
53432531Sminshall 	     * out of OOB state, and since that byte is most
53532531Sminshall 	     * likely the TELNET DM (data mark), we would
53632531Sminshall 	     * stay in the TELNET SYNCH (SYNCHing) state.
53732531Sminshall 	     * So, clocks to the rescue.  If we've "just"
53832531Sminshall 	     * received a DM, then we test for the
53932531Sminshall 	     * presence of OOB data when the receive OOB
54032531Sminshall 	     * fails (and AFTER we did the normal mode read
54132531Sminshall 	     * to clear "at the mark").
54232531Sminshall 	     */
54332531Sminshall 	if (SYNCHing) {
54432531Sminshall 	    int atmark;
54532531Sminshall 
54632531Sminshall 	    ioctl(net, SIOCATMARK, (char *)&atmark);
54732531Sminshall 	    if (atmark) {
54832531Sminshall 		c = recv(net, netiring.supply, canread, MSG_OOB);
54932531Sminshall 		if ((c == -1) && (errno == EINVAL)) {
55032531Sminshall 		    c = recv(net, netiring.supply, canread, 0);
55132531Sminshall 		    if (clocks.didnetreceive < clocks.gotDM) {
55232531Sminshall 			SYNCHing = stilloob(net);
55332531Sminshall 		    }
55432531Sminshall 		}
55532531Sminshall 	    } else {
55632531Sminshall 		c = recv(net, netiring.supply, canread, 0);
55732531Sminshall 	    }
55832531Sminshall 	} else {
55932531Sminshall 	    c = recv(net, netiring.supply, canread, 0);
56032531Sminshall 	}
56132531Sminshall 	settimer(didnetreceive);
56232531Sminshall #else	/* !defined(SO_OOBINLINE) */
56332531Sminshall 	c = recv(net, netiring.supply, canread, 0);
56432531Sminshall #endif	/* !defined(SO_OOBINLINE) */
56532531Sminshall 	if (c < 0 && errno == EWOULDBLOCK) {
56632531Sminshall 	    c = 0;
56732531Sminshall 	} else if (c <= 0) {
56832531Sminshall 	    return -1;
56932531Sminshall 	}
57032531Sminshall 	if (netdata) {
57132531Sminshall 	    Dump('<', netiring.supply, c);
57232531Sminshall 	}
57332667Sminshall 	if (c)
57432667Sminshall 	    ring_supplied(&netiring, c);
57532531Sminshall 	returnValue = 1;
57632531Sminshall     }
57732531Sminshall 
57832531Sminshall     /*
57932531Sminshall      * Something to read from the tty...
58032531Sminshall      */
58132531Sminshall     if (FD_ISSET(tin, &ibits)) {
58232531Sminshall 	FD_CLR(tin, &ibits);
58333286Sminshall 	c = TerminalRead(ttyiring.supply, ring_empty_consecutive(&ttyiring));
58432531Sminshall 	if (c < 0 && errno == EWOULDBLOCK) {
58532531Sminshall 	    c = 0;
58632531Sminshall 	} else {
58732531Sminshall 	    /* EOF detection for line mode!!!! */
58833281Sminshall 	    if ((c == 0) && MODE_LOCAL_CHARS(globalmode) && isatty(tin)) {
58932531Sminshall 			/* must be an EOF... */
59032531Sminshall 		*ttyiring.supply = termEofChar;
59132531Sminshall 		c = 1;
59232531Sminshall 	    }
59332531Sminshall 	    if (c <= 0) {
59432531Sminshall 		return -1;
59532531Sminshall 	    }
59632667Sminshall 	    ring_supplied(&ttyiring, c);
59732531Sminshall 	}
59832531Sminshall 	returnValue = 1;		/* did something useful */
59932531Sminshall     }
60032531Sminshall 
60132531Sminshall     if (FD_ISSET(net, &obits)) {
60232531Sminshall 	FD_CLR(net, &obits);
60332531Sminshall 	returnValue |= netflush();
60432531Sminshall     }
60532531Sminshall     if (FD_ISSET(tout, &obits)) {
60632531Sminshall 	FD_CLR(tout, &obits);
60732531Sminshall 	returnValue |= ttyflush(SYNCHing|flushout);
60832531Sminshall     }
60932531Sminshall 
61032531Sminshall     return returnValue;
61132531Sminshall }
61232531Sminshall #endif	/* defined(unix) */
613