sys_bsd.c revision de81e71e031139a0a7f13b7bf64152c3faa76698
/*
* 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
* 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.
*
*/
#ifndef lint
#endif /* not lint */
/*
* 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 <signal.h>
#include <errno.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
int olmode = 0;
#else /* USE_TERMIO */
#endif /* USE_TERMIO */
static SIG_FUNC_RET susp(int);
void fatal_tty_error(char *doing_what);
void
init_sys()
{
errno = 0;
}
int
TerminalWrite(buf, n)
char *buf;
int n;
{
}
static int
TerminalRead(buf, n)
char *buf;
int 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
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
{
}
}
void
{
#ifndef USE_TERMIO
#else /* USE_TERMIO */
#endif /* USE_TERMIO */
}
cc_t *
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
{
#ifndef USE_TERMIO
#else /* USE_TERMIO */
#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 signal mapping
*
* Linemode:
* Both Linemode and Single Character mode:
*/
void
register int f;
{
#ifndef USE_TERMIO
int lmode;
#else /* USE_TERMIO */
#endif /* USE_TERMIO */
int onoff;
int old;
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
#ifdef USE_TERMIO
#endif /* USE_TERMIO */
do {
/*
* Wait for data to drain, then flush again.
*/
#ifdef USE_TERMIO
#endif /* USE_TERMIO */
}
prevmode = f&~MODE_FORCE;
#ifndef USE_TERMIO
#else
#endif
if (f&MODE_ECHO) {
#ifndef USE_TERMIO
#else
if (crlf)
#endif
} else {
#ifndef USE_TERMIO
#else
#ifdef notdef
if (crlf)
#endif
#endif
}
if ((f&MODE_FLOW) == 0) {
#ifndef USE_TERMIO
#else
} else {
if (restartany < 0) {
/* Leave the IXANY bit alone */
} else if (restartany > 0) {
} else {
}
#endif
}
if ((f&MODE_TRAPSIG) == 0) {
#ifndef USE_TERMIO
#else
#endif
localchars = 0;
} else {
#ifdef USE_TERMIO
#endif
localchars = 1;
}
if (f&MODE_EDIT) {
#ifndef USE_TERMIO
#else
#endif
} else {
#ifndef USE_TERMIO
if (f&MODE_ECHO)
else
#else
#endif
}
if ((f&(MODE_EDIT|MODE_TRAPSIG)) == 0) {
#ifndef USE_TERMIO
#else
#endif
}
if (f&MODE_SOFT_TAB) {
#ifndef USE_TERMIO
#else
#endif
} else {
#ifndef USE_TERMIO
#else
#endif
}
if (f&MODE_LIT_ECHO) {
#ifndef USE_TERMIO
#else
#endif
} else {
#ifndef USE_TERMIO
#else
#endif
}
if (f == -1) {
onoff = 0;
} else {
#ifndef USE_TERMIO
if (f & MODE_OUTBIN)
else
#else
if (f & MODE_OUTBIN) {
} else {
}
#endif
onoff = 1;
}
if (f != -1) {
#if defined(USE_TERMIO) && defined(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
#else
#endif
#ifdef USE_TERMIO
/*
* If the VEOL character is already set, then use VEOL2,
* otherwise use VEOL.
*/
/* XXX */ &&
/* XXX */) {
}
#else
#endif
} else {
(void) sigemptyset(&nset);
#ifndef USE_TERMIO
#else
#endif
}
#ifndef USE_TERMIO
#else
#endif
}
}
/*
* 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[] = {
{ -1, B0 }
};
void
int *ispeed;
int *ospeed;
{
register struct termspeeds *tp;
if (in == 0)
tp = termspeeds;
tp++;
}
tp--; /* back up to fastest defined speed */
tp = termspeeds;
tp++;
}
tp--;
}
int
{
return (1);
}
return (0);
}
static void
int fd;
int onoff;
{
}
/*
* Various signal handling routines.
*/
/* ARGSUSED */
static SIG_FUNC_RET
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.
*/
flushout = 1;
}
/* ARGSUSED */
static SIG_FUNC_RET
int sig;
{
if (intr_waiting) {
intr_happened = 1;
return;
}
if (localchars) {
intp();
return;
}
}
/* ARGSUSED */
static SIG_FUNC_RET
int sig;
{
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
int sig;
{
return;
if (localchars)
sendsusp();
}
/* ARGSUSED */
static SIG_FUNC_RET
int sig;
{
if (connected) {
sendnaws();
}
}
void
{
setconnmode(0);
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);
exit(1);
}
/*
* Process 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.
*/
int
int poll; /* If 0, then block until something to do */
{
register 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;
int i;
if (netout) {
}
if (ttyout) {
}
if (ttyin) {
}
if (netin) {
}
if (netex) {
}
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.
*/
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?
*/
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...
*/
int canread;
if (c < 0 && errno == EWOULDBLOCK) {
c = 0;
} else if (c <= 0) {
return (-1);
}
if (netdata) {
}
if (c)
ring_supplied(&netiring, c);
returnValue = 1;
}
/*
* Something to read from the tty...
*/
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) &&
/* must be an EOF... */
eof_pending = 1;
return (1);
}
if (c <= 0) {
returnValue = -1;
goto next;
}
if (termdata) {
}
ring_supplied(&ttyiring, c);
}
}
next:
returnValue |= netflush();
}
if (i == -2) {
/* This will not return. */
fatal_tty_error("write");
}
returnValue |= (i > 0);
}
return (returnValue);
}