* Copyright (c) 1988 Regents of the University of California.
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
static char sccsid
[] = "@(#)sys_bsd.c 1.16 (Berkeley) 11/29/88";
* The following routines try to encapsulate what is system dependent
* (at least between 4.x and dos) which is used in telnet.c.
tout
, /* Output file descriptor */
tin
, /* Input file descriptor */
static struct tchars otc
= { 0 }, ntc
= { 0 };
static struct ltchars oltc
= { 0 }, nltc
= { 0 };
static struct sgttyb ottyb
= { 0 }, nttyb
= { 0 };
static fd_set ibits
, obits
, xbits
;
return write(tout
, buf
, n
);
return read(tin
, buf
, n
);
ioctl(0, TIOCLGET
, (char *)&flush
);
return !(flush
&LNOFLSH
); /* if LNOFLSH, no autoflush */
* Look at an input character to see if it is a special character
* 0 Don't add this character.
* 1 Do add this character
void xmitAO(), xmitEL(), xmitEC(), intp(), sendbrk();
} else if (c
== ntc
.t_quitc
) {
} else if (c
== nltc
.t_flushc
) {
xmitAO(); /* Transmit Abort Output */
} else if (!MODE_LOCAL_CHARS(globalmode
)) {
if (c
== nttyb
.sg_kill
) {
} else if (c
== nttyb
.sg_erase
) {
xmitEC(); /* Transmit Erase Character */
* Flush output to the terminal
(void) ioctl(fileno(stdout
), TIOCFLUSH
, (char *) 0);
ioctl(0, TIOCGETP
, (char *)&ottyb
);
ioctl(0, TIOCGETC
, (char *)&otc
);
ioctl(0, TIOCGLTC
, (char *)&oltc
);
termEofChar
= ntc
.t_eofc
;
termEraseChar
= nttyb
.sg_erase
;
termFlushChar
= nltc
.t_flushc
;
termIntChar
= ntc
.t_intrc
;
termKillChar
= nttyb
.sg_kill
;
termQuitChar
= ntc
.t_quitc
;
* TerminalNewMode - set up terminal to a specific mode.
static struct tchars notc
= { -1, -1, -1, -1, -1, -1 };
static struct ltchars noltc
= { -1, -1, -1, -1, -1, -1 };
case 1: /* remote character processing, remote echo */
case 2: /* remote character processing, local echo */
case 6: /* 3270 mode - like 1, but with xon/xoff local */
/* (might be nice to have "6" in telnet also...) */
if ((f
== 1) || (f
== 6)) {
sb
.sg_flags
&= ~(ECHO
|CRMOD
);
sb
.sg_flags
|= ECHO
|CRMOD
;
sb
.sg_erase
= sb
.sg_kill
= -1;
/* get XON, XOFF characters */
tc3
.t_startc
= otc
.t_startc
;
tc3
.t_stopc
= otc
.t_stopc
;
* If user hasn't specified one way or the other,
* then default to not trapping signals.
notc2
.t_intrc
= ntc
.t_intrc
;
notc2
.t_quitc
= ntc
.t_quitc
;
case 3: /* local character processing, remote echo */
case 4: /* local character processing, local echo */
case 5: /* local character processing, no echo */
* If user hasn't specified one way or the other,
* then default to trapping signals.
notc2
.t_brkc
= nltc
.t_flushc
;
notc2
.t_intrc
= notc2
.t_quitc
= -1;
ioctl(tin
, TIOCSLTC
, (char *)ltc
);
ioctl(tin
, TIOCSETC
, (char *)tc
);
ioctl(tin
, TIOCSETP
, (char *)&sb
);
#if (!defined(TN3270)) || ((!defined(NOT43)) || defined(PUTCHAR))
ioctl(tin
, FIONBIO
, (char *)&onoff
);
ioctl(tout
, FIONBIO
, (char *)&onoff
);
#endif /* (!defined(TN3270)) || ((!defined(NOT43)) || defined(PUTCHAR)) */
ioctl(tin
, FIOASYNC
, (char *)&onoff
);
#endif /* defined(TN3270) */
(void) signal(SIGTSTP
, (int (*)())doescape
);
} else if (MODE_LINE(old
)) {
(void) signal(SIGTSTP
, SIG_DFL
);
sigsetmask(sigblock(0) & ~(1<<(SIGTSTP
-1)));
NetNonblockingIO(fd
, onoff
)
ioctl(fd
, FIONBIO
, (char *)&onoff
);
ioctl(fd
, FIOASYNC
, (char *)&onoff
); /* hear about input */
fcntl(fd
, F_SETOWN
, myPid
);
#endif /*defined(TN3270)*/
* Various signal handling routines.
(void) signal(SIGINT
, (int (*)())intr
);
(void) signal(SIGQUIT
, (int (*)())intr2
);
(void) signal(SIGPIPE
, (int (*)())deadpeer
);
NetNonblockingIO(net
, 1);
if (noasynchnet
== 0) { /* DBX can't handle! */
#endif /* defined(TN3270) */
#if defined(SO_OOBINLINE)
if (SetSockOpt(net
, SOL_SOCKET
, SO_OOBINLINE
, 1) == -1) {
#endif /* defined(SO_OOBINLINE) */
* 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.
process_rings(netin
, netout
, netex
, ttyin
, ttyout
, poll
)
int poll
; /* If 0, then block until something to do */
/* 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).
static struct timeval TimeValue
= { 0 };
#else /* defined(TN3270) */
#endif /* defined(TN3270) */
# else /* !defined(TN3270) */
# endif /* !defined(TN3270) */
if ((c
= select(16, &ibits
, &obits
, &xbits
,
(poll
== 0)? (struct timeval
*)0 : &TimeValue
)) < 0) {
* we can get EINTR if we are in line mode,
* and the user does an escape (TSTP), or
* some other signal generator.
* we can get EBADF if we were in transparent
* mode, and the transcom process died.
* zero the bits (even though kernel does it)
* to make sure we are selecting on the right
# endif /* defined(TN3270) */
/* I don't like this, does it ever happen? */
printf("sleep(5) from telnet, after select\r\n");
if (FD_ISSET(net
, &xbits
)) {
ttyflush(1); /* flush already enqueued data */
* Something to read from the network...
if (FD_ISSET(net
, &ibits
)) {
canread
= ring_empty_consecutive(&netiring
);
#if !defined(SO_OOBINLINE)
* In 4.2 (and some early 4.3) systems, the
* OOB indication and data handling in the kernel
* is such that if two separate TCP Urgent requests
* come in, one byte of TCP data will be overlaid.
* This is fatal for Telnet, but we try to live
* In addition, in 4.2 (and...), a special protocol
* is needed to pick up the TCP Urgent data in
* What we do is: if we think we are in urgent
* mode, we look to see if we are "at the mark".
* If we are, we do an OOB receive. If we run
* this twice, we will do the OOB receive twice,
* but the second will fail, since the second
* time we were "at the mark", but there wasn't
* any data there (the kernel doesn't reset
* "at the mark" until we do a normal read).
* Once we've read the OOB data, we go ahead
* There is also another problem, which is that
* since the OOB byte we read doesn't put us
* out of OOB state, and since that byte is most
* likely the TELNET DM (data mark), we would
* stay in the TELNET SYNCH (SYNCHing) state.
* So, clocks to the rescue. If we've "just"
* received a DM, then we test for the
* presence of OOB data when the receive OOB
* fails (and AFTER we did the normal mode read
* to clear "at the mark").
ioctl(net
, SIOCATMARK
, (char *)&atmark
);
c
= recv(net
, netiring
.supply
, canread
, MSG_OOB
);
if ((c
== -1) && (errno
== EINVAL
)) {
c
= recv(net
, netiring
.supply
, canread
, 0);
if (clocks
.didnetreceive
< clocks
.gotDM
) {
SYNCHing
= stilloob(net
);
c
= recv(net
, netiring
.supply
, canread
, 0);
c
= recv(net
, netiring
.supply
, canread
, 0);
#else /* !defined(SO_OOBINLINE) */
c
= recv(net
, netiring
.supply
, canread
, 0);
#endif /* !defined(SO_OOBINLINE) */
if (c
< 0 && errno
== EWOULDBLOCK
) {
Dump('<', netiring
.supply
, c
);
ring_supplied(&netiring
, c
);
* Something to read from the tty...
if (FD_ISSET(tin
, &ibits
)) {
c
= TerminalRead(ttyiring
.supply
, ring_empty_consecutive(&ttyiring
));
if (c
< 0 && errno
== EWOULDBLOCK
) {
/* EOF detection for line mode!!!! */
if ((c
== 0) && MODE_LOCAL_CHARS(globalmode
) && isatty(tin
)) {
*ttyiring
.supply
= termEofChar
;
ring_supplied(&ttyiring
, c
);
returnValue
= 1; /* did something useful */
if (FD_ISSET(net
, &obits
)) {
returnValue
|= netflush();
if (FD_ISSET(tout
, &obits
)) {
returnValue
|= ttyflush(SYNCHing
|flushout
);
#endif /* defined(unix) */