* Copyright (c) 1988, 1990 Regents of the University of California.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* 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
static char sccsid
[] = "@(#)sys_bsd.c 5.2 (Berkeley) 3/1/91";
* The following routines try to encapsulate what is system dependent
* (at least between 4.x and dos) which is used in telnet.c.
#if defined(CRAY) || (defined(USE_TERMIO) && !defined(SYSV_TERMIO))
#define SIG_FUNC_RET void
tout
, /* Output file descriptor */
tin
, /* Input file descriptor */
struct tchars otc
= { 0 }, ntc
= { 0 };
struct ltchars oltc
= { 0 }, nltc
= { 0 };
struct sgttyb ottyb
= { 0 }, nttyb
= { 0 };
# define cfgetispeed(ptr) (ptr)->sg_ispeed
# define cfgetospeed(ptr) (ptr)->sg_ospeed
struct termio old_tc
= { 0 };
extern struct termio new_tc
;
# define TCSADRAIN TCSETSW
# define tcgetattr(f, t) ioctl(f, TCGETS, (char *)t)
# define TCSADRAIN TCSETAW
# define tcgetattr(f, t) ioctl(f, TCGETA, (char *)t)
# define TCSANOW TIOCSETA
# define TCSADRAIN TIOCSETAW
# define tcgetattr(f, t) ioctl(f, TIOCGETA, (char *)t)
# define tcsetattr(f, a, t) ioctl(f, a, (char *)t)
# define cfgetospeed(ptr) ((ptr)->c_cflag&CBAUD)
# define cfgetispeed(ptr) (((ptr)->c_cflag&CIBAUD) >> IBSHIFT)
# define cfgetispeed(ptr) cfgetospeed(ptr)
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 */
extern int kludgelinemode
;
* 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
== termQuitChar
) {
} else if (c
== termEofChar
) {
if (my_want_state_is_will(TELOPT_LINEMODE
)) {
} else if (c
== termSuspChar
) {
} else if (c
== termFlushChar
) {
xmitAO(); /* Transmit Abort Output */
} else if (!MODE_LOCAL_CHARS(globalmode
)) {
} else if (c
== termEraseChar
) {
xmitEC(); /* Transmit Erase Character */
* Flush output to the terminal
(void) ioctl(fileno(stdout
), TIOCFLUSH
, (char *) 0);
(void) ioctl(fileno(stdout
), TCFLSH
, (char *) 0);
ioctl(0, TIOCGETP
, (char *)&ottyb
);
ioctl(0, TIOCGETC
, (char *)&otc
);
ioctl(0, TIOCGLTC
, (char *)&oltc
);
ioctl(0, TIOCLGET
, (char *)&olmode
);
termFlushChar
= CONTROL('O');
termWerasChar
= CONTROL('W');
termRprntChar
= CONTROL('R');
termLiteralNextChar
= CONTROL('V');
termStartChar
= CONTROL('Q');
termStopChar
= CONTROL('S');
termAytChar
= CONTROL('T');
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
);
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
);
case SLC_AYT
: return(&termAytChar
);
nttyb
.sg_kill
= ottyb
.sg_kill
;
nttyb
.sg_erase
= ottyb
.sg_erase
;
memcpy(new_tc
.c_cc
, old_tc
.c_cc
, sizeof(old_tc
.c_cc
));
termFlushChar
= CONTROL('O');
termWerasChar
= CONTROL('W');
termRprntChar
= CONTROL('R');
termLiteralNextChar
= CONTROL('V');
termStartChar
= CONTROL('Q');
termStopChar
= CONTROL('S');
termAytChar
= CONTROL('T');
* 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
* MODE_ECHO|MODE_EDIT|MODE_FLOW|MODE_TRAPSIG
* Both Linemode and Single Character mode:
* local/no signal mapping
globalmode
= f
&~MODE_FORCE
;
* Write any outstanding data before switching modes
* ttyflush() returns 0 only when there is no more data
* left to write out, it returns -1 if it couldn't do
* anything at all, otherwise it returns 1 + the number
* of characters left to write.
* 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).
old
= ttyflush(SYNCHing
|flushout
);
if (old
< 0 || old
> 1) {
* Wait for data to drain, then flush again.
tcsetattr(tin
, TCSADRAIN
, &tmp_tc
);
old
= ttyflush(SYNCHing
|flushout
);
} while (old
< 0 || old
> 1);
prevmode
= f
&~MODE_FORCE
;
tmp_tc
.c_oflag
&= ~ONLCR
;
tmp_tc
.c_iflag
&= ~ICRNL
;
if ((f
&MODE_FLOW
) == 0) {
tc
.t_startc
= _POSIX_VDISABLE
;
tc
.t_stopc
= _POSIX_VDISABLE
;
tmp_tc
.c_iflag
&= ~(IXANY
|IXOFF
|IXON
);
tmp_tc
.c_iflag
|= IXANY
|IXOFF
|IXON
;
if ((f
&MODE_TRAPSIG
) == 0) {
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
;
tmp_tc
.c_lflag
|= ICANON
;
tmp_tc
.c_lflag
&= ~ICANON
;
tmp_tc
.c_iflag
&= ~ICRNL
;
if ((f
&(MODE_EDIT
|MODE_TRAPSIG
)) == 0) {
ltc
.t_lnextc
= _POSIX_VDISABLE
;
tmp_tc
.c_cc
[VLNEXT
] = (cc_t
)(_POSIX_VDISABLE
);
tmp_tc
.c_oflag
|= OXTABS
;
tmp_tc
.c_oflag
&= ~TABDLY
;
tmp_tc
.c_oflag
&= ~OXTABS
;
tmp_tc
.c_oflag
&= ~TABDLY
;
tmp_tc
.c_lflag
&= ~ECHOCTL
;
tmp_tc
.c_lflag
|= ECHOCTL
;
tmp_tc
.c_iflag
&= ~ISTRIP
;
tmp_tc
.c_iflag
|= ISTRIP
;
tmp_tc
.c_cflag
&= ~(CSIZE
|PARENB
);
tmp_tc
.c_oflag
&= ~OPOST
;
tmp_tc
.c_cflag
&= ~(CSIZE
|PARENB
);
tmp_tc
.c_cflag
|= old_tc
.c_cflag
& (CSIZE
|PARENB
);
static SIG_FUNC_RET
susp();
static SIG_FUNC_RET
ayt();
(void) signal(SIGTSTP
, susp
);
(void) signal(SIGINFO
, ayt
);
#if defined(USE_TERMIO) && defined(NOKERNINFO)
tmp_tc
.c_lflag
|= NOKERNINFO
;
* 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.
ltc
.t_dsuspc
= _POSIX_VDISABLE
;
tmp_tc
.c_cc
[VDSUSP
] = (cc_t
)(_POSIX_VDISABLE
);
* If the VEOL character is already set, then use VEOL2,
esc
= (rlogin
!= _POSIX_VDISABLE
) ? rlogin
: escape
;
if ((tmp_tc
.c_cc
[VEOL
] != esc
)
&& (tmp_tc
.c_cc
[VEOL2
] != esc
)
if (tmp_tc
.c_cc
[VEOL
] == (cc_t
)(_POSIX_VDISABLE
))
else if (tmp_tc
.c_cc
[VEOL2
] == (cc_t
)(_POSIX_VDISABLE
))
tmp_tc
.c_cc
[VEOL2
] = esc
;
if (tc
.t_brkc
== (cc_t
)(_POSIX_VDISABLE
))
SIG_FUNC_RET
ayt_status();
(void) signal(SIGINFO
, ayt_status
);
(void) signal(SIGTSTP
, SIG_DFL
);
(void) sigsetmask(sigblock(0) & ~(1<<(SIGTSTP
-1)));
ioctl(tin
, TIOCLSET
, (char *)&lmode
);
ioctl(tin
, TIOCSLTC
, (char *)<c
);
ioctl(tin
, TIOCSETC
, (char *)&tc
);
ioctl(tin
, TIOCSETN
, (char *)&sb
);
if (tcsetattr(tin
, TCSADRAIN
, &tmp_tc
) < 0)
tcsetattr(tin
, TCSANOW
, &tmp_tc
);
#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) */
* This code assumes that the values B0, B50, B75...
* are in ascending order. They do not have to be
{ 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
}, { -1, B38400
}
TerminalSpeeds(ispeed
, ospeed
)
register struct termspeeds
*tp
;
out
= cfgetospeed(&old_tc
);
in
= cfgetispeed(&old_tc
);
while ((tp
->speed
!= -1) && (tp
->value
< in
))
while ((tp
->speed
!= -1) && (tp
->value
< out
))
TerminalWindowSize(rows
, cols
)
if (ioctl(fileno(stdin
), TIOCGWINSZ
, (char *)&ws
) >= 0) {
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.
if ((rlogin
!= _POSIX_VDISABLE
) && rlogin_susp())
(void) signal(SIGINT
, intr
);
(void) signal(SIGQUIT
, intr2
);
(void) signal(SIGPIPE
, deadpeer
);
(void) signal(SIGWINCH
, sendwin
);
(void) signal(SIGTSTP
, susp
);
(void) signal(SIGINFO
, ayt
);
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
)) {
(void) 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").
static int bogus_oob
= 0, first
= 1;
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
);
} else if (first
&& c
> 0) {
* Bogosity check. Systems based on 4.2BSD
* do not return an error if you do a second
* recv(MSG_OOB). So, we do one. If it
* succeeds and returns exactly the same
* data, then assume that we are running
* on a broken system and set the bogus_oob
* flag. (If the data was different, then
* we probably got some valid new data, so
* increment the count...)
i
= recv(net
, netiring
.supply
+ c
, canread
- c
, MSG_OOB
);
bcmp(netiring
.supply
, netiring
.supply
+ c
, i
) == 0) {
if (bogus_oob
&& c
> 0) {
* Bogosity. We have to do the read
* to clear the atmark to get out of
i
= read(net
, netiring
.supply
+ c
, canread
- c
);
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
;
Dump('<', ttyiring
.supply
, c
);
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
) > 0);