#include "tclInt.h" /* Internal definitions for Tcl. */
#include "tclPort.h" /* Portability features for Tcl. */
#include "tclIO.h" /* To get Channel type declaration. */
#undef NL0
#undef NL1
#undef CR0
#undef CR1
#undef CR2
#undef CR3
#undef TAB0
#undef TAB1
#undef TAB2
#undef XTABS
#undef BS0
#undef BS1
#undef FF0
#undef FF1
#undef ECHO
#undef NOFLSH
#undef TOSTOP
#undef FLUSHO
#undef PENDIN
#define SUPPORTS_TTY
#ifdef USE_TERMIOS
# include <termios.h>
# ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
# endif /* HAVE_SYS_IOCTL_H */
# ifdef HAVE_SYS_MODEM_H
# include <sys/modem.h>
# endif /* HAVE_SYS_MODEM_H */
# define IOSTATE struct termios
# define GETIOSTATE(fd, statePtr) tcgetattr((fd), (statePtr))
# define SETIOSTATE(fd, statePtr) tcsetattr((fd), TCSADRAIN, (statePtr))
# define GETCONTROL(fd, intPtr) ioctl((fd), TIOCMGET, (intPtr))
# define SETCONTROL(fd, intPtr) ioctl((fd), TIOCMSET, (intPtr))
# define BAD_TIP35_FLUSH 0
# if BAD_TIP35_FLUSH
# define TTYFLUSH(fd) tcflush((fd), TCIOFLUSH);
# else
# define TTYFLUSH(fd)
# endif /* BAD_TIP35_FLUSH */
# ifdef FIONREAD
# define GETREADQUEUE(fd, int) ioctl((fd), FIONREAD, &(int))
# elif defined(FIORDCHK)
# define GETREADQUEUE(fd, int) int = ioctl((fd), FIORDCHK, NULL)
# endif /* FIONREAD */
# ifdef TIOCOUTQ
# define GETWRITEQUEUE(fd, int) ioctl((fd), TIOCOUTQ, &(int))
# endif /* TIOCOUTQ */
# if defined(TIOCSBRK) && defined(TIOCCBRK)
# define SETBREAK(fd, flag) \
if
(flag) { \
ioctl((fd), TIOCSBRK, NULL); \
}
else
{ \
ioctl((fd), TIOCCBRK, NULL); \
}
# endif /* TIOCSBRK&TIOCCBRK */
# if !defined(CRTSCTS) && defined(CNEW_RTSCTS)
# define CRTSCTS CNEW_RTSCTS
# endif /* !CRTSCTS&CNEW_RTSCTS */
#else /* !USE_TERMIOS */
#ifdef USE_TERMIO
# include <termio.h>
# define IOSTATE struct termio
# define GETIOSTATE(fd, statePtr) ioctl((fd), TCGETA, (statePtr))
# define SETIOSTATE(fd, statePtr) ioctl((fd), TCSETAW, (statePtr))
#else /* !USE_TERMIO */
#ifdef USE_SGTTY
# include <sgtty.h>
# define IOSTATE struct sgttyb
# define GETIOSTATE(fd, statePtr) ioctl((fd), TIOCGETP, (statePtr))
# define SETIOSTATE(fd, statePtr) ioctl((fd), TIOCSETP, (statePtr))
#else /* !USE_SGTTY */
# undef SUPPORTS_TTY
#endif /* !USE_SGTTY */
#endif /* !USE_TERMIO */
#endif /* !USE_TERMIOS */
typedef
struct
FileState {
Tcl_Channel channel;
int
fd;
int
validMask;
#ifdef DEPRECATED
struct
FileState *nextPtr;
#endif /* DEPRECATED */
} FileState;
#ifdef SUPPORTS_TTY
typedef
struct
TtyState {
FileState fs;
int
stateUpdated;
IOSTATE savedState;
} TtyState;
typedef
struct
TtyAttrs {
int
baud;
int
parity;
int
data;
int
stop;
} TtyAttrs;
#endif /* !SUPPORTS_TTY */
#define UNSUPPORTED_OPTION(detail) \
if
(interp) { \
Tcl_AppendResult(interp, (detail), \
" not supported for this platform"
, (
char
*) NULL); \
}
#ifdef DEPRECATED
typedef
struct
ThreadSpecificData {
FileState *firstFilePtr;
} ThreadSpecificData;
static
Tcl_ThreadDataKey dataKey;
#endif /* DEPRECATED */
typedef
struct
TcpState {
Tcl_Channel channel;
int
fd;
int
flags;
Tcl_TcpAcceptProc *acceptProc;
ClientData acceptProcData;
} TcpState;
#define TCP_ASYNC_SOCKET (1<<0) /* Asynchronous socket. */
#define TCP_ASYNC_CONNECT (1<<1) /* Async connect in progress. */
#ifndef SOMAXCONN
# define SOMAXCONN 100
#endif /* SOMAXCONN */
#if (SOMAXCONN < 100)
# undef SOMAXCONN
# define SOMAXCONN 100
#endif /* SOMAXCONN < 100 */
#define SOCKET_BUFSIZE 4096
static
TcpState * CreateSocket _ANSI_ARGS_((Tcl_Interp *interp,
int
port, CONST
char
*host,
int
server,
CONST
char
*myaddr,
int
myport,
int
async));
static
int
CreateSocketAddress _ANSI_ARGS_(
(
struct
sockaddr_in *sockaddrPtr,
CONST
char
*host,
int
port));
static
int
FileBlockModeProc _ANSI_ARGS_((
ClientData instanceData,
int
mode));
static
int
FileCloseProc _ANSI_ARGS_((ClientData instanceData,
Tcl_Interp *interp));
static
int
FileGetHandleProc _ANSI_ARGS_((ClientData instanceData,
int
direction, ClientData *handlePtr));
static
int
FileInputProc _ANSI_ARGS_((ClientData instanceData,
char
*buf,
int
toRead,
int
*errorCode));
static
int
FileOutputProc _ANSI_ARGS_((
ClientData instanceData, CONST
char
*buf,
int
toWrite,
int
*errorCode));
static
int
FileSeekProc _ANSI_ARGS_((ClientData instanceData,
long
offset,
int
mode,
int
*errorCode));
static
Tcl_WideInt FileWideSeekProc _ANSI_ARGS_((ClientData instanceData,
Tcl_WideInt offset,
int
mode,
int
*errorCode));
static
void
FileWatchProc _ANSI_ARGS_((ClientData instanceData,
int
mask));
static
void
TcpAccept _ANSI_ARGS_((ClientData data,
int
mask));
static
int
TcpBlockModeProc _ANSI_ARGS_((ClientData data,
int
mode));
static
int
TcpCloseProc _ANSI_ARGS_((ClientData instanceData,
Tcl_Interp *interp));
static
int
TcpGetHandleProc _ANSI_ARGS_((ClientData instanceData,
int
direction, ClientData *handlePtr));
static
int
TcpGetOptionProc _ANSI_ARGS_((ClientData instanceData,
Tcl_Interp *interp, CONST
char
*optionName,
Tcl_DString *dsPtr));
static
int
TcpInputProc _ANSI_ARGS_((ClientData instanceData,
char
*buf,
int
toRead,
int
*errorCode));
static
int
TcpOutputProc _ANSI_ARGS_((ClientData instanceData,
CONST
char
*buf,
int
toWrite,
int
*errorCode));
static
void
TcpWatchProc _ANSI_ARGS_((ClientData instanceData,
int
mask));
#ifdef SUPPORTS_TTY
static
int
TtyCloseProc _ANSI_ARGS_((ClientData instanceData,
Tcl_Interp *interp));
static
void
TtyGetAttributes _ANSI_ARGS_((
int
fd,
TtyAttrs *ttyPtr));
static
int
TtyGetOptionProc _ANSI_ARGS_((ClientData instanceData,
Tcl_Interp *interp, CONST
char
*optionName,
Tcl_DString *dsPtr));
static
FileState * TtyInit _ANSI_ARGS_((
int
fd,
int
initialize));
#if BAD_TIP35_FLUSH
static
int
TtyOutputProc _ANSI_ARGS_((ClientData instanceData,
CONST
char
*buf,
int
toWrite,
int
*errorCode));
#endif /* BAD_TIP35_FLUSH */
static
int
TtyParseMode _ANSI_ARGS_((Tcl_Interp *interp,
CONST
char
*mode,
int
*speedPtr,
int
*parityPtr,
int
*dataPtr,
int
*stopPtr));
static
void
TtySetAttributes _ANSI_ARGS_((
int
fd,
TtyAttrs *ttyPtr));
static
int
TtySetOptionProc _ANSI_ARGS_((ClientData instanceData,
Tcl_Interp *interp, CONST
char
*optionName,
CONST
char
*value));
#endif /* SUPPORTS_TTY */
static
int
WaitForConnect _ANSI_ARGS_((TcpState *statePtr,
int
*errorCodePtr));
static
Tcl_Channel MakeTcpClientChannelMode _ANSI_ARGS_(
(ClientData tcpSocket,
int
mode));
static
Tcl_ChannelType fileChannelType = {
"file"
,
TCL_CHANNEL_VERSION_3,
FileCloseProc,
FileInputProc,
FileOutputProc,
FileSeekProc,
NULL,
NULL,
FileWatchProc,
FileGetHandleProc,
NULL,
FileBlockModeProc,
NULL,
NULL,
FileWideSeekProc,
};
#ifdef SUPPORTS_TTY
static
Tcl_ChannelType ttyChannelType = {
"tty"
,
TCL_CHANNEL_VERSION_2,
TtyCloseProc,
FileInputProc,
#if BAD_TIP35_FLUSH
TtyOutputProc,
#else /* !BAD_TIP35_FLUSH */
FileOutputProc,
#endif /* BAD_TIP35_FLUSH */
NULL,
TtySetOptionProc,
TtyGetOptionProc,
FileWatchProc,
FileGetHandleProc,
NULL,
FileBlockModeProc,
NULL,
NULL,
};
#endif /* SUPPORTS_TTY */
static
Tcl_ChannelType tcpChannelType = {
"tcp"
,
TCL_CHANNEL_VERSION_2,
TcpCloseProc,
TcpInputProc,
TcpOutputProc,
NULL,
NULL,
TcpGetOptionProc,
TcpWatchProc,
TcpGetHandleProc,
NULL,
TcpBlockModeProc,
NULL,
NULL,
};
static
int
FileBlockModeProc(instanceData, mode)
ClientData instanceData;
int
mode;
{
FileState *fsPtr = (FileState *) instanceData;
int
curStatus;
#ifndef USE_FIONBIO
curStatus = fcntl(fsPtr->fd, F_GETFL);
if
(mode == TCL_MODE_BLOCKING) {
curStatus &= (~(O_NONBLOCK));
}
else
{
curStatus |= O_NONBLOCK;
}
if
(fcntl(fsPtr->fd, F_SETFL, curStatus) < 0) {
return
errno
;
}
curStatus = fcntl(fsPtr->fd, F_GETFL);
#else /* USE_FIONBIO */
if
(mode == TCL_MODE_BLOCKING) {
curStatus = 0;
}
else
{
curStatus = 1;
}
if
(ioctl(fsPtr->fd, (
int
) FIONBIO, &curStatus) < 0) {
return
errno
;
}
#endif /* !USE_FIONBIO */
return
0;
}
static
int
FileInputProc(instanceData, buf, toRead, errorCodePtr)
ClientData instanceData;
char
*buf;
int
toRead;
int
*errorCodePtr;
{
FileState *fsPtr = (FileState *) instanceData;
int
bytesRead;
*errorCodePtr = 0;
bytesRead = read(fsPtr->fd, buf, (
size_t
) toRead);
if
(bytesRead > -1) {
return
bytesRead;
}
*errorCodePtr =
errno
;
return
-1;
}
static
int
FileOutputProc(instanceData, buf, toWrite, errorCodePtr)
ClientData instanceData;
CONST
char
*buf;
int
toWrite;
int
*errorCodePtr;
{
FileState *fsPtr = (FileState *) instanceData;
int
written;
*errorCodePtr = 0;
if
(toWrite == 0) {
return
0;
}
written = write(fsPtr->fd, buf, (
size_t
) toWrite);
if
(written > -1) {
return
written;
}
*errorCodePtr =
errno
;
return
-1;
}
static
int
FileCloseProc(instanceData, interp)
ClientData instanceData;
Tcl_Interp *interp;
{
FileState *fsPtr = (FileState *) instanceData;
int
errorCode = 0;
#ifdef DEPRECATED
FileState **nextPtrPtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
#endif /* DEPRECATED */
Tcl_DeleteFileHandler(fsPtr->fd);
if
(!TclInThreadExit()
|| ((fsPtr->fd != 0) && (fsPtr->fd != 1) && (fsPtr->fd != 2))) {
if
(close(fsPtr->fd) < 0) {
errorCode =
errno
;
}
}
ckfree((
char
*) fsPtr);
return
errorCode;
}
static
int
FileSeekProc(instanceData, offset, mode, errorCodePtr)
ClientData instanceData;
long
offset;
int
mode;
int
*errorCodePtr;
{
FileState *fsPtr = (FileState *) instanceData;
Tcl_WideInt oldLoc, newLoc;
oldLoc = TclOSseek(fsPtr->fd, (Tcl_SeekOffset) 0, SEEK_CUR);
if
(oldLoc == Tcl_LongAsWide(-1)) {
*errorCodePtr =
errno
;
return
-1;
}
newLoc = TclOSseek(fsPtr->fd, (Tcl_SeekOffset) offset, mode);
if
(newLoc > Tcl_LongAsWide(INT_MAX)) {
*errorCodePtr = EOVERFLOW;
TclOSseek(fsPtr->fd, (Tcl_SeekOffset) oldLoc, SEEK_SET);
return
-1;
}
else
{
*errorCodePtr = (newLoc == Tcl_LongAsWide(-1)) ?
errno
: 0;
}
return
(
int
) Tcl_WideAsLong(newLoc);
}
static
Tcl_WideInt
FileWideSeekProc(instanceData, offset, mode, errorCodePtr)
ClientData instanceData;
Tcl_WideInt offset;
int
mode;
int
*errorCodePtr;
{
FileState *fsPtr = (FileState *) instanceData;
Tcl_WideInt newLoc;
newLoc = TclOSseek(fsPtr->fd, (Tcl_SeekOffset) offset, mode);
*errorCodePtr = (newLoc == -1) ?
errno
: 0;
return
newLoc;
}
static
void
FileWatchProc(instanceData, mask)
ClientData instanceData;
int
mask;
{
FileState *fsPtr = (FileState *) instanceData;
mask &= fsPtr->validMask;
if
(mask) {
Tcl_CreateFileHandler(fsPtr->fd, mask,
(Tcl_FileProc *) Tcl_NotifyChannel,
(ClientData) fsPtr->channel);
}
else
{
Tcl_DeleteFileHandler(fsPtr->fd);
}
}
static
int
FileGetHandleProc(instanceData, direction, handlePtr)
ClientData instanceData;
int
direction;
ClientData *handlePtr;
{
FileState *fsPtr = (FileState *) instanceData;
if
(direction & fsPtr->validMask) {
*handlePtr = (ClientData) fsPtr->fd;
return
TCL_OK;
}
else
{
return
TCL_ERROR;
}
}
#ifdef SUPPORTS_TTY
static
int
TtyCloseProc(instanceData, interp)
ClientData instanceData;
Tcl_Interp *interp;
{
#if BAD_TIP35_FLUSH
TtyState *ttyPtr = (TtyState *) instanceData;
#endif /* BAD_TIP35_FLUSH */
#ifdef TTYFLUSH
TTYFLUSH(ttyPtr->fs.fd);
#endif /* TTYFLUSH */
#if 0
if
(ttyPtr->stateUpdated) {
SETIOSTATE(ttyPtr->fs.fd, &ttyPtr->savedState);
}
#endif
return
FileCloseProc(instanceData, interp);
}
#if BAD_TIP35_FLUSH
static
int
TtyOutputProc(instanceData, buf, toWrite, errorCodePtr)
ClientData instanceData;
CONST
char
*buf;
int
toWrite;
int
*errorCodePtr;
{
if
(TclInExit()) {
return
toWrite;
}
else
{
return
FileOutputProc(instanceData, buf, toWrite, errorCodePtr);
}
}
#endif /* BAD_TIP35_FLUSH */
#ifdef USE_TERMIOS
static
void
TtyModemStatusStr(status, dsPtr)
int
status;
Tcl_DString *dsPtr;
{
#ifdef TIOCM_CTS
Tcl_DStringAppendElement(dsPtr,
"CTS"
);
Tcl_DStringAppendElement(dsPtr, (status & TIOCM_CTS) ?
"1"
:
"0"
);
#endif /* TIOCM_CTS */
#ifdef TIOCM_DSR
Tcl_DStringAppendElement(dsPtr,
"DSR"
);
Tcl_DStringAppendElement(dsPtr, (status & TIOCM_DSR) ?
"1"
:
"0"
);
#endif /* TIOCM_DSR */
#ifdef TIOCM_RNG
Tcl_DStringAppendElement(dsPtr,
"RING"
);
Tcl_DStringAppendElement(dsPtr, (status & TIOCM_RNG) ?
"1"
:
"0"
);
#endif /* TIOCM_RNG */
#ifdef TIOCM_CD
Tcl_DStringAppendElement(dsPtr,
"DCD"
);
Tcl_DStringAppendElement(dsPtr, (status & TIOCM_CD) ?
"1"
:
"0"
);
#endif /* TIOCM_CD */
}
#endif /* USE_TERMIOS */
static
int
TtySetOptionProc(instanceData, interp, optionName, value)
ClientData instanceData;
Tcl_Interp *interp;
CONST
char
*optionName;
CONST
char
*value;
{
FileState *fsPtr = (FileState *) instanceData;
unsigned
int
len, vlen;
TtyAttrs tty;
#ifdef USE_TERMIOS
int
flag, control, argc;
CONST
char
**argv;
IOSTATE iostate;
#endif /* USE_TERMIOS */
len =
strlen
(optionName);
vlen =
strlen
(value);
if
((len > 2) && (
strncmp
(optionName,
"-mode"
, len) == 0)) {
if
(TtyParseMode(interp, value, &tty.baud, &tty.parity, &tty.data,
&tty.stop) != TCL_OK) {
return
TCL_ERROR;
}
TtySetAttributes(fsPtr->fd, &tty);
((TtyState *) fsPtr)->stateUpdated = 1;
return
TCL_OK;
}
#ifdef USE_TERMIOS
if
((len > 1) && (
strncmp
(optionName,
"-handshake"
, len) == 0)) {
GETIOSTATE(fsPtr->fd, &iostate);
iostate.c_iflag &= ~(IXON | IXOFF | IXANY);
#ifdef CRTSCTS
iostate.c_cflag &= ~CRTSCTS;
#endif /* CRTSCTS */
if
(strncasecmp(value,
"NONE"
, vlen) == 0) {
}
else
if
(strncasecmp(value,
"XONXOFF"
, vlen) == 0) {
iostate.c_iflag |= (IXON | IXOFF | IXANY);
}
else
if
(strncasecmp(value,
"RTSCTS"
, vlen) == 0) {
#ifdef CRTSCTS
iostate.c_cflag |= CRTSCTS;
#else /* !CRTSTS */
UNSUPPORTED_OPTION(
"-handshake RTSCTS"
);
return
TCL_ERROR;
#endif /* CRTSCTS */
}
else
if
(strncasecmp(value,
"DTRDSR"
, vlen) == 0) {
UNSUPPORTED_OPTION(
"-handshake DTRDSR"
);
return
TCL_ERROR;
}
else
{
if
(interp) {
Tcl_AppendResult(interp,
"bad value for -handshake: "
,
"must be one of xonxoff, rtscts, dtrdsr or none"
,
(
char
*) NULL);
}
return
TCL_ERROR;
}
SETIOSTATE(fsPtr->fd, &iostate);
return
TCL_OK;
}
if
((len > 1) && (
strncmp
(optionName,
"-xchar"
, len) == 0)) {
GETIOSTATE(fsPtr->fd, &iostate);
if
(Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
return
TCL_ERROR;
}
if
(argc == 2) {
iostate.c_cc[VSTART] = argv[0][0];
iostate.c_cc[VSTOP] = argv[1][0];
}
else
{
if
(interp) {
Tcl_AppendResult(interp,
"bad value for -xchar: should be a list of two elements"
,
(
char
*) NULL);
}
return
TCL_ERROR;
}
SETIOSTATE(fsPtr->fd, &iostate);
return
TCL_OK;
}
if
((len > 2) && (
strncmp
(optionName,
"-timeout"
, len) == 0)) {
int
msec;
GETIOSTATE(fsPtr->fd, &iostate);
if
(Tcl_GetInt(interp, value, &msec) != TCL_OK) {
return
TCL_ERROR;
}
iostate.c_cc[VMIN] = 0;
iostate.c_cc[VTIME] = (msec == 0) ? 0 : (msec < 100) ? 1 : (msec+50)/100;
SETIOSTATE(fsPtr->fd, &iostate);
return
TCL_OK;
}
if
((len > 4) && (
strncmp
(optionName,
"-ttycontrol"
, len) == 0)) {
if
(Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
return
TCL_ERROR;
}
if
((argc % 2) == 1) {
if
(interp) {
Tcl_AppendResult(interp,
"bad value for -ttycontrol: should be a list of"
,
"signal,value pairs"
, (
char
*) NULL);
}
return
TCL_ERROR;
}
GETCONTROL(fsPtr->fd, &control);
while
(argc > 1) {
if
(Tcl_GetBoolean(interp, argv[1], &flag) == TCL_ERROR) {
return
TCL_ERROR;
}
if
(strncasecmp(argv[0],
"DTR"
,
strlen
(argv[0])) == 0) {
#ifdef TIOCM_DTR
if
(flag) {
control |= TIOCM_DTR;
}
else
{
control &= ~TIOCM_DTR;
}
#else /* !TIOCM_DTR */
UNSUPPORTED_OPTION(
"-ttycontrol DTR"
);
return
TCL_ERROR;
#endif /* TIOCM_DTR */
}
else
if
(strncasecmp(argv[0],
"RTS"
,
strlen
(argv[0])) == 0) {
#ifdef TIOCM_RTS
if
(flag) {
control |= TIOCM_RTS;
}
else
{
control &= ~TIOCM_RTS;
}
#else /* !TIOCM_RTS*/
UNSUPPORTED_OPTION(
"-ttycontrol RTS"
);
return
TCL_ERROR;
#endif /* TIOCM_RTS*/
}
else
if
(strncasecmp(argv[0],
"BREAK"
,
strlen
(argv[0])) == 0) {
#ifdef SETBREAK
SETBREAK(fsPtr->fd, flag);
#else /* !SETBREAK */
UNSUPPORTED_OPTION(
"-ttycontrol BREAK"
);
return
TCL_ERROR;
#endif /* SETBREAK */
}
else
{
if
(interp) {
Tcl_AppendResult(interp,
"bad signal for -ttycontrol: must be "
,
"DTR, RTS or BREAK"
, (
char
*) NULL);
}
return
TCL_ERROR;
}
argc -= 2, argv += 2;
}
SETCONTROL(fsPtr->fd, &control);
return
TCL_OK;
}
return
Tcl_BadChannelOption(interp, optionName,
"mode handshake timeout ttycontrol xchar "
);
#else /* !USE_TERMIOS */
return
Tcl_BadChannelOption(interp, optionName,
"mode"
);
#endif /* USE_TERMIOS */
}
static
int
TtyGetOptionProc(instanceData, interp, optionName, dsPtr)
ClientData instanceData;
Tcl_Interp *interp;
CONST
char
*optionName;
Tcl_DString *dsPtr;
{
FileState *fsPtr = (FileState *) instanceData;
unsigned
int
len;
char
buf[3 * TCL_INTEGER_SPACE + 16];
TtyAttrs tty;
int
valid = 0;
if
(optionName == NULL) {
len = 0;
}
else
{
len =
strlen
(optionName);
}
if
(len == 0) {
Tcl_DStringAppendElement(dsPtr,
"-mode"
);
}
if
(len==0 || (len>2 &&
strncmp
(optionName,
"-mode"
, len)==0)) {
valid = 1;
TtyGetAttributes(fsPtr->fd, &tty);
sprintf
(buf,
"%d,%c,%d,%d"
, tty.baud, tty.parity, tty.data, tty.stop);
Tcl_DStringAppendElement(dsPtr, buf);
}
#ifdef USE_TERMIOS
if
(len == 0) {
Tcl_DStringAppendElement(dsPtr,
"-xchar"
);
Tcl_DStringStartSublist(dsPtr);
}
if
(len==0 || (len>1 &&
strncmp
(optionName,
"-xchar"
, len)==0)) {
IOSTATE iostate;
valid = 1;
GETIOSTATE(fsPtr->fd, &iostate);
sprintf
(buf,
"%c"
, iostate.c_cc[VSTART]);
Tcl_DStringAppendElement(dsPtr, buf);
sprintf
(buf,
"%c"
, iostate.c_cc[VSTOP]);
Tcl_DStringAppendElement(dsPtr, buf);
}
if
(len == 0) {
Tcl_DStringEndSublist(dsPtr);
}
if
((len > 1) && (
strncmp
(optionName,
"-queue"
, len) == 0)) {
int
inQueue=0, outQueue=0;
int
inBuffered, outBuffered;
valid = 1;
#ifdef GETREADQUEUE
GETREADQUEUE(fsPtr->fd, inQueue);
#endif /* GETREADQUEUE */
#ifdef GETWRITEQUEUE
GETWRITEQUEUE(fsPtr->fd, outQueue);
#endif /* GETWRITEQUEUE */
inBuffered = Tcl_InputBuffered(fsPtr->channel);
outBuffered = Tcl_OutputBuffered(fsPtr->channel);
sprintf
(buf,
"%d"
, inBuffered+inQueue);
Tcl_DStringAppendElement(dsPtr, buf);
sprintf
(buf,
"%d"
, outBuffered+outQueue);
Tcl_DStringAppendElement(dsPtr, buf);
}
if
((len > 4) && (
strncmp
(optionName,
"-ttystatus"
, len) == 0)) {
int
status;
valid = 1;
GETCONTROL(fsPtr->fd, &status);
TtyModemStatusStr(status, dsPtr);
}
#endif /* USE_TERMIOS */
if
(valid) {
return
TCL_OK;
}
else
{
return
Tcl_BadChannelOption(interp, optionName,
#ifdef USE_TERMIOS
"mode queue ttystatus xchar"
);
#else /* !USE_TERMIOS */
"mode"
);
#endif /* USE_TERMIOS */
}
}
#undef DIRECT_BAUD
#ifdef B4800
# if (B4800 == 4800)
# define DIRECT_BAUD
# endif /* B4800 == 4800 */
#endif /* B4800 */
#ifdef DIRECT_BAUD
# define TtyGetSpeed(baud) ((unsigned) (baud))
# define TtyGetBaud(speed) ((int) (speed))
#else /* !DIRECT_BAUD */
static
struct
{
int
baud; unsigned
long
speed;} speeds[] = {
#ifdef B0
{0, B0},
#endif
#ifdef B50
{50, B50},
#endif
#ifdef B75
{75, B75},
#endif
#ifdef B110
{110, B110},
#endif
#ifdef B134
{134, B134},
#endif
#ifdef B150
{150, B150},
#endif
#ifdef B200
{200, B200},
#endif
#ifdef B300
{300, B300},
#endif
#ifdef B600
{600, B600},
#endif
#ifdef B1200
{1200, B1200},
#endif
#ifdef B1800
{1800, B1800},
#endif
#ifdef B2400
{2400, B2400},
#endif
#ifdef B4800
{4800, B4800},
#endif
#ifdef B9600
{9600, B9600},
#endif
#ifdef B14400
{14400, B14400},
#endif
#ifdef B19200
{19200, B19200},
#endif
#ifdef EXTA
{19200, EXTA},
#endif
#ifdef B28800
{28800, B28800},
#endif
#ifdef B38400
{38400, B38400},
#endif
#ifdef EXTB
{38400, EXTB},
#endif
#ifdef B57600
{57600, B57600},
#endif
#ifdef _B57600
{57600, _B57600},
#endif
#ifdef B76800
{76800, B76800},
#endif
#ifdef B115200
{115200, B115200},
#endif
#ifdef _B115200
{115200, _B115200},
#endif
#ifdef B153600
{153600, B153600},
#endif
#ifdef B230400
{230400, B230400},
#endif
#ifdef B307200
{307200, B307200},
#endif
#ifdef B460800
{460800, B460800},
#endif
{-1, 0}
};
static
unsigned
long
TtyGetSpeed(baud)
int
baud;
{
int
bestIdx, bestDiff, i, diff;
bestIdx = 0;
bestDiff = 1000000;
for
(i = 0; speeds[i].baud >= 0; i++) {
diff = speeds[i].baud - baud;
if
(diff < 0) {
diff = -diff;
}
if
(diff < bestDiff) {
bestIdx = i;
bestDiff = diff;
}
}
return
speeds[bestIdx].speed;
}
static
int
TtyGetBaud(speed)
unsigned
long
speed;
{
int
i;
for
(i = 0; speeds[i].baud >= 0; i++) {
if
(speeds[i].speed == speed) {
return
speeds[i].baud;
}
}
return
0;
}
#endif /* !DIRECT_BAUD */
static
void
TtyGetAttributes(fd, ttyPtr)
int
fd;
TtyAttrs *ttyPtr;
{
IOSTATE iostate;
int
baud, parity, data, stop;
GETIOSTATE(fd, &iostate);
#ifdef USE_TERMIOS
baud = TtyGetBaud(cfgetospeed(&iostate));
parity =
'n'
;
#ifdef PAREXT
switch
((
int
) (iostate.c_cflag & (PARENB | PARODD | PAREXT))) {
case
PARENB : parity =
'e'
;
break
;
case
PARENB | PARODD : parity =
'o'
;
break
;
case
PARENB | PAREXT : parity =
's'
;
break
;
case
PARENB | PARODD | PAREXT : parity =
'm'
;
break
;
}
#else /* !PAREXT */
switch
((
int
) (iostate.c_cflag & (PARENB | PARODD))) {
case
PARENB : parity =
'e'
;
break
;
case
PARENB | PARODD : parity =
'o'
;
break
;
}
#endif /* !PAREXT */
data = iostate.c_cflag & CSIZE;
data = (data == CS5) ? 5 : (data == CS6) ? 6 : (data == CS7) ? 7 : 8;
stop = (iostate.c_cflag & CSTOPB) ? 2 : 1;
#endif /* USE_TERMIOS */
#ifdef USE_TERMIO
baud = TtyGetBaud(iostate.c_cflag & CBAUD);
parity =
'n'
;
switch
(iostate.c_cflag & (PARENB | PARODD | PAREXT)) {
case
PARENB : parity =
'e'
;
break
;
case
PARENB | PARODD : parity =
'o'
;
break
;
case
PARENB | PAREXT : parity =
's'
;
break
;
case
PARENB | PARODD | PAREXT : parity =
'm'
;
break
;
}
data = iostate.c_cflag & CSIZE;
data = (data == CS5) ? 5 : (data == CS6) ? 6 : (data == CS7) ? 7 : 8;
stop = (iostate.c_cflag & CSTOPB) ? 2 : 1;
#endif /* USE_TERMIO */
#ifdef USE_SGTTY
baud = TtyGetBaud(iostate.sg_ospeed);
parity =
'n'
;
if
(iostate.sg_flags & EVENP) {
parity =
'e'
;
}
else
if
(iostate.sg_flags & ODDP) {
parity =
'o'
;
}
data = (iostate.sg_flags & (EVENP | ODDP)) ? 7 : 8;
stop = 1;
#endif /* USE_SGTTY */
ttyPtr->baud = baud;
ttyPtr->parity = parity;
ttyPtr->data = data;
ttyPtr->stop = stop;
}
static
void
TtySetAttributes(fd, ttyPtr)
int
fd;
TtyAttrs *ttyPtr;
{
IOSTATE iostate;
#ifdef USE_TERMIOS
int
parity, data, flag;
GETIOSTATE(fd, &iostate);
cfsetospeed(&iostate, TtyGetSpeed(ttyPtr->baud));
cfsetispeed(&iostate, TtyGetSpeed(ttyPtr->baud));
flag = 0;
parity = ttyPtr->parity;
if
(parity !=
'n'
) {
flag |= PARENB;
#ifdef PAREXT
iostate.c_cflag &= ~PAREXT;
if
((parity ==
'm'
) || (parity ==
's'
)) {
flag |= PAREXT;
}
#endif /* PAREXT */
if
((parity ==
'm'
) || (parity ==
'o'
)) {
flag |= PARODD;
}
}
data = ttyPtr->data;
flag |= (data == 5) ? CS5 : (data == 6) ? CS6 : (data == 7) ? CS7 : CS8;
if
(ttyPtr->stop == 2) {
flag |= CSTOPB;
}
iostate.c_cflag &= ~(PARENB | PARODD | CSIZE | CSTOPB);
iostate.c_cflag |= flag;
#endif /* USE_TERMIOS */
#ifdef USE_TERMIO
int
parity, data, flag;
GETIOSTATE(fd, &iostate);
iostate.c_cflag &= ~CBAUD;
iostate.c_cflag |= TtyGetSpeed(ttyPtr->baud);
flag = 0;
parity = ttyPtr->parity;
if
(parity !=
'n'
) {
flag |= PARENB;
if
((parity ==
'm'
) || (parity ==
's'
)) {
flag |= PAREXT;
}
if
((parity ==
'm'
) || (parity ==
'o'
)) {
flag |= PARODD;
}
}
data = ttyPtr->data;
flag |= (data == 5) ? CS5 : (data == 6) ? CS6 : (data == 7) ? CS7 : CS8;
if
(ttyPtr->stop == 2) {
flag |= CSTOPB;
}
iostate.c_cflag &= ~(PARENB | PARODD | PAREXT | CSIZE | CSTOPB);
iostate.c_cflag |= flag;
#endif /* USE_TERMIO */
#ifdef USE_SGTTY
int
parity;
GETIOSTATE(fd, &iostate);
iostate.sg_ospeed = TtyGetSpeed(ttyPtr->baud);
iostate.sg_ispeed = TtyGetSpeed(ttyPtr->baud);
parity = ttyPtr->parity;
if
(parity ==
'e'
) {
iostate.sg_flags &= ~ODDP;
iostate.sg_flags |= EVENP;
}
else
if
(parity ==
'o'
) {
iostate.sg_flags &= ~EVENP;
iostate.sg_flags |= ODDP;
}
#endif /* USE_SGTTY */
SETIOSTATE(fd, &iostate);
}
static
int
TtyParseMode(interp, mode, speedPtr, parityPtr, dataPtr, stopPtr)
Tcl_Interp *interp;
CONST
char
*mode;
int
*speedPtr;
int
*parityPtr;
int
*dataPtr;
int
*stopPtr;
{
int
i, end;
char
parity;
static
char
*bad =
"bad value for -mode"
;
i =
sscanf
(mode,
"%d,%c,%d,%d%n"
, speedPtr, &parity, dataPtr,
stopPtr, &end);
if
((i != 4) || (mode[end] !=
'\0'
)) {
if
(interp != NULL) {
Tcl_AppendResult(interp, bad,
": should be baud,parity,data,stop"
,
NULL);
}
return
TCL_ERROR;
}
if
(
#if defined(PAREXT) || defined(USE_TERMIO)
strchr
(
"noems"
, parity) == NULL
#else
strchr
(
"noe"
, parity) == NULL
#endif /* PAREXT|USE_TERMIO */
) {
if
(interp != NULL) {
Tcl_AppendResult(interp, bad,
#if defined(PAREXT) || defined(USE_TERMIO)
" parity: should be n, o, e, m, or s"
,
#else
" parity: should be n, o, or e"
,
#endif /* PAREXT|USE_TERMIO */
NULL);
}
return
TCL_ERROR;
}
*parityPtr = parity;
if
((*dataPtr < 5) || (*dataPtr > 8)) {
if
(interp != NULL) {
Tcl_AppendResult(interp, bad,
" data: should be 5, 6, 7, or 8"
,
NULL);
}
return
TCL_ERROR;
}
if
((*stopPtr < 0) || (*stopPtr > 2)) {
if
(interp != NULL) {
Tcl_AppendResult(interp, bad,
" stop: should be 1 or 2"
, NULL);
}
return
TCL_ERROR;
}
return
TCL_OK;
}
static
FileState *
TtyInit(fd, initialize)
int
fd;
int
initialize;
{
TtyState *ttyPtr;
ttyPtr = (TtyState *) ckalloc((unsigned)
sizeof
(TtyState));
GETIOSTATE(fd, &ttyPtr->savedState);
ttyPtr->stateUpdated = 0;
if
(initialize) {
IOSTATE iostate = ttyPtr->savedState;
#if defined(USE_TERMIOS) || defined(USE_TERMIO)
if
(iostate.c_iflag != IGNBRK ||
iostate.c_oflag != 0 ||
iostate.c_lflag != 0 ||
iostate.c_cflag & CREAD ||
iostate.c_cc[VMIN] != 1 ||
iostate.c_cc[VTIME] != 0) {
ttyPtr->stateUpdated = 1;
}
iostate.c_iflag = IGNBRK;
iostate.c_oflag = 0;
iostate.c_lflag = 0;
iostate.c_cflag |= CREAD;
iostate.c_cc[VMIN] = 1;
iostate.c_cc[VTIME] = 0;
#endif /* USE_TERMIOS|USE_TERMIO */
#ifdef USE_SGTTY
if
((iostate.sg_flags & (EVENP | ODDP)) ||
!(iostate.sg_flags & RAW)) {
ttyPtr->stateUpdated = 1;
}
iostate.sg_flags &= (EVENP | ODDP);
iostate.sg_flags |= RAW;
#endif /* USE_SGTTY */
if
(ttyPtr->stateUpdated) {
SETIOSTATE(fd, &iostate);
}
}
return
&ttyPtr->fs;
}
#endif /* SUPPORTS_TTY */
Tcl_Channel
TclpOpenFileChannel(interp, pathPtr, mode, permissions)
Tcl_Interp *interp;
Tcl_Obj *pathPtr;
int
mode;
int
permissions;
{
int
fd, channelPermissions;
FileState *fsPtr;
CONST
char
*native, *translation;
char
channelName[16 + TCL_INTEGER_SPACE];
Tcl_ChannelType *channelTypePtr;
#ifdef SUPPORTS_TTY
int
ctl_tty;
#endif /* SUPPORTS_TTY */
#ifdef DEPRECATED
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
#endif /* DEPRECATED */
switch
(mode & (O_RDONLY | O_WRONLY | O_RDWR)) {
case
O_RDONLY:
channelPermissions = TCL_READABLE;
break
;
case
O_WRONLY:
channelPermissions = TCL_WRITABLE;
break
;
case
O_RDWR:
channelPermissions = (TCL_READABLE | TCL_WRITABLE);
break
;
default
:
panic(
"TclpOpenFileChannel: invalid mode value"
);
return
NULL;
}
native = Tcl_FSGetNativePath(pathPtr);
if
(native == NULL) {
return
NULL;
}
fd = TclOSopen(native, mode, permissions);
#ifdef SUPPORTS_TTY
ctl_tty = (
strcmp
(native,
"/dev/tty"
) == 0);
#endif /* SUPPORTS_TTY */
if
(fd < 0) {
if
(interp != (Tcl_Interp *) NULL) {
Tcl_AppendResult(interp,
"couldn't open \""
,
Tcl_GetString(pathPtr),
"\": "
,
Tcl_PosixError(interp), (
char
*) NULL);
}
return
NULL;
}
fcntl(fd, F_SETFD, FD_CLOEXEC);
sprintf
(channelName,
"file%d"
, fd);
#ifdef SUPPORTS_TTY
if
(!ctl_tty && isatty(fd)) {
translation =
"auto crlf"
;
channelTypePtr = &ttyChannelType;
fsPtr = TtyInit(fd, 1);
}
else
#endif /* SUPPORTS_TTY */
{
translation = NULL;
channelTypePtr = &fileChannelType;
fsPtr = (FileState *) ckalloc((unsigned)
sizeof
(FileState));
}
#ifdef DEPRECATED
if
(channelTypePtr == &fileChannelType) {
fsPtr->nextPtr = tsdPtr->firstFilePtr;
tsdPtr->firstFilePtr = fsPtr;
}
#endif /* DEPRECATED */
fsPtr->validMask = channelPermissions | TCL_EXCEPTION;
fsPtr->fd = fd;
fsPtr->channel = Tcl_CreateChannel(channelTypePtr, channelName,
(ClientData) fsPtr, channelPermissions);
if
(translation != NULL) {
if
(Tcl_SetChannelOption(interp, fsPtr->channel,
"-translation"
,
translation) != TCL_OK) {
Tcl_Close(NULL, fsPtr->channel);
return
NULL;
}
}
return
fsPtr->channel;
}
Tcl_Channel
Tcl_MakeFileChannel(handle, mode)
ClientData handle;
int
mode;
{
FileState *fsPtr;
char
channelName[16 + TCL_INTEGER_SPACE];
int
fd = (
int
) handle;
Tcl_ChannelType *channelTypePtr;
#ifdef DEPRECATED
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
#endif /* DEPRECATED */
struct
sockaddr sockaddr;
socklen_t sockaddrLen =
sizeof
(sockaddr);
if
(mode == 0) {
return
NULL;
}
#ifdef DEPRECATED
for
(fsPtr = tsdPtr->firstFilePtr; fsPtr != NULL; fsPtr = fsPtr->nextPtr) {
if
(fsPtr->fd == fd) {
return
((mode|TCL_EXCEPTION) == fsPtr->validMask) ?
fsPtr->channel : NULL;
}
}
#endif /* DEPRECATED */
sockaddr.sa_family = AF_UNSPEC;
#ifdef SUPPORTS_TTY
if
(isatty(fd)) {
fsPtr = TtyInit(fd, 0);
channelTypePtr = &ttyChannelType;
sprintf
(channelName,
"serial%d"
, fd);
}
else
#endif /* SUPPORTS_TTY */
if
(getsockname(fd, (
struct
sockaddr *)&sockaddr, &sockaddrLen) == 0
&& sockaddrLen > 0
&& sockaddr.sa_family == AF_INET) {
return
MakeTcpClientChannelMode((ClientData) fd, mode);
}
else
{
channelTypePtr = &fileChannelType;
fsPtr = (FileState *) ckalloc((unsigned)
sizeof
(FileState));
sprintf
(channelName,
"file%d"
, fd);
}
#ifdef DEPRECATED
if
(channelTypePtr == &fileChannelType) {
fsPtr->nextPtr = tsdPtr->firstFilePtr;
tsdPtr->firstFilePtr = fsPtr;
}
#endif /* DEPRECATED */
fsPtr->fd = fd;
fsPtr->validMask = mode | TCL_EXCEPTION;
fsPtr->channel = Tcl_CreateChannel(channelTypePtr, channelName,
(ClientData) fsPtr, mode);
return
fsPtr->channel;
}
static
int
TcpBlockModeProc(instanceData, mode)
ClientData instanceData;
int
mode;
{
TcpState *statePtr = (TcpState *) instanceData;
int
setting;
#ifndef USE_FIONBIO
setting = fcntl(statePtr->fd, F_GETFL);
if
(mode == TCL_MODE_BLOCKING) {
statePtr->flags &= (~(TCP_ASYNC_SOCKET));
setting &= (~(O_NONBLOCK));
}
else
{
statePtr->flags |= TCP_ASYNC_SOCKET;
setting |= O_NONBLOCK;
}
if
(fcntl(statePtr->fd, F_SETFL, setting) < 0) {
return
errno
;
}
#else /* USE_FIONBIO */
if
(mode == TCL_MODE_BLOCKING) {
statePtr->flags &= (~(TCP_ASYNC_SOCKET));
setting = 0;
if
(ioctl(statePtr->fd, (
int
) FIONBIO, &setting) == -1) {
return
errno
;
}
}
else
{
statePtr->flags |= TCP_ASYNC_SOCKET;
setting = 1;
if
(ioctl(statePtr->fd, (
int
) FIONBIO, &setting) == -1) {
return
errno
;
}
}
#endif /* !USE_FIONBIO */
return
0;
}
static
int
WaitForConnect(statePtr, errorCodePtr)
TcpState *statePtr;
int
*errorCodePtr;
{
int
timeOut;
int
state;
int
flags;
if
(statePtr->flags & TCP_ASYNC_CONNECT) {
if
(statePtr->flags & TCP_ASYNC_SOCKET) {
timeOut = 0;
}
else
{
timeOut = -1;
}
errno
= 0;
state = TclUnixWaitForFile(statePtr->fd,
TCL_WRITABLE | TCL_EXCEPTION, timeOut);
if
(!(statePtr->flags & TCP_ASYNC_SOCKET)) {
#ifndef USE_FIONBIO
flags = fcntl(statePtr->fd, F_GETFL);
flags &= (~(O_NONBLOCK));
(
void
) fcntl(statePtr->fd, F_SETFL, flags);
#else /* USE_FIONBIO */
flags = 0;
(
void
) ioctl(statePtr->fd, FIONBIO, &flags);
#endif /* !USE_FIONBIO */
}
if
(state & TCL_EXCEPTION) {
return
-1;
}
if
(state & TCL_WRITABLE) {
statePtr->flags &= (~(TCP_ASYNC_CONNECT));
}
else
if
(timeOut == 0) {
*errorCodePtr =
errno
= EWOULDBLOCK;
return
-1;
}
}
return
0;
}
static
int
TcpInputProc(instanceData, buf, bufSize, errorCodePtr)
ClientData instanceData;
char
*buf;
int
bufSize;
int
*errorCodePtr;
{
TcpState *statePtr = (TcpState *) instanceData;
int
bytesRead, state;
*errorCodePtr = 0;
state = WaitForConnect(statePtr, errorCodePtr);
if
(state != 0) {
return
-1;
}
bytesRead = recv(statePtr->fd, buf, (
size_t
) bufSize, 0);
if
(bytesRead > -1) {
return
bytesRead;
}
if
(
errno
== ECONNRESET) {
return
0;
}
*errorCodePtr =
errno
;
return
-1;
}
static
int
TcpOutputProc(instanceData, buf, toWrite, errorCodePtr)
ClientData instanceData;
CONST
char
*buf;
int
toWrite;
int
*errorCodePtr;
{
TcpState *statePtr = (TcpState *) instanceData;
int
written;
int
state;
*errorCodePtr = 0;
state = WaitForConnect(statePtr, errorCodePtr);
if
(state != 0) {
return
-1;
}
written = send(statePtr->fd, buf, (
size_t
) toWrite, 0);
if
(written > -1) {
return
written;
}
*errorCodePtr =
errno
;
return
-1;
}
static
int
TcpCloseProc(instanceData, interp)
ClientData instanceData;
Tcl_Interp *interp;
{
TcpState *statePtr = (TcpState *) instanceData;
int
errorCode = 0;
Tcl_DeleteFileHandler(statePtr->fd);
if
(close(statePtr->fd) < 0) {
errorCode =
errno
;
}
ckfree((
char
*) statePtr);
return
errorCode;
}
static
int
TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
ClientData instanceData;
Tcl_Interp *interp;
CONST
char
*optionName;
Tcl_DString *dsPtr;
{
TcpState *statePtr = (TcpState *) instanceData;
struct
sockaddr_in sockname;
struct
sockaddr_in peername;
struct
hostent *hostEntPtr;
socklen_t size =
sizeof
(
struct
sockaddr_in);
size_t
len = 0;
char
buf[TCL_INTEGER_SPACE];
if
(optionName != (
char
*) NULL) {
len =
strlen
(optionName);
}
if
((len > 1) && (optionName[1] ==
'e'
) &&
(
strncmp
(optionName,
"-error"
, len) == 0)) {
socklen_t optlen =
sizeof
(
int
);
int
err, ret;
ret = getsockopt(statePtr->fd, SOL_SOCKET, SO_ERROR,
(
char
*)&err, &optlen);
if
(ret < 0) {
err =
errno
;
}
if
(err != 0) {
Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(err), -1);
}
return
TCL_OK;
}
if
((len == 0) ||
((len > 1) && (optionName[1] ==
'p'
) &&
(
strncmp
(optionName,
"-peername"
, len) == 0))) {
if
(getpeername(statePtr->fd, (
struct
sockaddr *) &peername,
&size) >= 0) {
if
(len == 0) {
Tcl_DStringAppendElement(dsPtr,
"-peername"
);
Tcl_DStringStartSublist(dsPtr);
}
Tcl_DStringAppendElement(dsPtr, inet_ntoa(peername.sin_addr));
hostEntPtr = gethostbyaddr(
(
char
*) &peername.sin_addr,
sizeof
(peername.sin_addr), AF_INET);
if
(hostEntPtr != NULL) {
Tcl_DString ds;
Tcl_ExternalToUtfDString(NULL, hostEntPtr->h_name, -1, &ds);
Tcl_DStringAppendElement(dsPtr, Tcl_DStringValue(&ds));
}
else
{
Tcl_DStringAppendElement(dsPtr, inet_ntoa(peername.sin_addr));
}
TclFormatInt(buf, ntohs(peername.sin_port));
Tcl_DStringAppendElement(dsPtr, buf);
if
(len == 0) {
Tcl_DStringEndSublist(dsPtr);
}
else
{
return
TCL_OK;
}
}
else
{
if
(len) {
if
(interp) {
Tcl_AppendResult(interp,
"can't get peername: "
,
Tcl_PosixError(interp), (
char
*) NULL);
}
return
TCL_ERROR;
}
}
}
if
((len == 0) ||
((len > 1) && (optionName[1] ==
's'
) &&
(
strncmp
(optionName,
"-sockname"
, len) == 0))) {
if
(getsockname(statePtr->fd, (
struct
sockaddr *) &sockname,
&size) >= 0) {
if
(len == 0) {
Tcl_DStringAppendElement(dsPtr,
"-sockname"
);
Tcl_DStringStartSublist(dsPtr);
}
Tcl_DStringAppendElement(dsPtr, inet_ntoa(sockname.sin_addr));
hostEntPtr = gethostbyaddr(
(
char
*) &sockname.sin_addr,
sizeof
(sockname.sin_addr), AF_INET);
if
(hostEntPtr != (
struct
hostent *) NULL) {
Tcl_DString ds;
Tcl_ExternalToUtfDString(NULL, hostEntPtr->h_name, -1, &ds);
Tcl_DStringAppendElement(dsPtr, Tcl_DStringValue(&ds));
}
else
{
Tcl_DStringAppendElement(dsPtr, inet_ntoa(sockname.sin_addr));
}
TclFormatInt(buf, ntohs(sockname.sin_port));
Tcl_DStringAppendElement(dsPtr, buf);
if
(len == 0) {
Tcl_DStringEndSublist(dsPtr);
}
else
{
return
TCL_OK;
}
}
else
{
if
(interp) {
Tcl_AppendResult(interp,
"can't get sockname: "
,
Tcl_PosixError(interp), (
char
*) NULL);
}
return
TCL_ERROR;
}
}
if
(len > 0) {
return
Tcl_BadChannelOption(interp, optionName,
"peername sockname"
);
}
return
TCL_OK;
}
static
void
TcpWatchProc(instanceData, mask)
ClientData instanceData;
int
mask;
{
TcpState *statePtr = (TcpState *) instanceData;
if
(!statePtr->acceptProc) {
if
(mask) {
Tcl_CreateFileHandler(statePtr->fd, mask,
(Tcl_FileProc *) Tcl_NotifyChannel,
(ClientData) statePtr->channel);
}
else
{
Tcl_DeleteFileHandler(statePtr->fd);
}
}
}
static
int
TcpGetHandleProc(instanceData, direction, handlePtr)
ClientData instanceData;
int
direction;
ClientData *handlePtr;
{
TcpState *statePtr = (TcpState *) instanceData;
*handlePtr = (ClientData)statePtr->fd;
return
TCL_OK;
}
static
TcpState *
CreateSocket(interp, port, host, server, myaddr, myport, async)
Tcl_Interp *interp;
int
port;
CONST
char
*host;
int
server;
CONST
char
*myaddr;
int
myport;
int
async;
{
int
status, sock, asyncConnect, curState, origState;
struct
sockaddr_in sockaddr;
struct
sockaddr_in mysockaddr;
TcpState *statePtr;
sock = -1;
origState = 0;
if
(! CreateSocketAddress(&sockaddr, host, port)) {
goto
addressError;
}
if
((myaddr != NULL || myport != 0) &&
! CreateSocketAddress(&mysockaddr, myaddr, myport)) {
goto
addressError;
}
sock = socket(AF_INET, SOCK_STREAM, 0);
if
(sock < 0) {
goto
addressError;
}
fcntl(sock, F_SETFD, FD_CLOEXEC);
TclSockMinimumBuffers(sock, SOCKET_BUFSIZE);
asyncConnect = 0;
status = 0;
if
(server) {
status = 1;
(
void
) setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (
char
*) &status,
sizeof
(status));
status = bind(sock, (
struct
sockaddr *) &sockaddr,
sizeof
(
struct
sockaddr));
if
(status != -1) {
status = listen(sock, SOMAXCONN);
}
}
else
{
if
(myaddr != NULL || myport != 0) {
curState = 1;
(
void
) setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(
char
*) &curState,
sizeof
(curState));
status = bind(sock, (
struct
sockaddr *) &mysockaddr,
sizeof
(
struct
sockaddr));
if
(status < 0) {
goto
bindError;
}
}
if
(async) {
#ifndef USE_FIONBIO
origState = fcntl(sock, F_GETFL);
curState = origState | O_NONBLOCK;
status = fcntl(sock, F_SETFL, curState);
#else /* USE_FIONBIO */
curState = 1;
status = ioctl(sock, FIONBIO, &curState);
#endif /* !USE_FIONBIO */
}
else
{
status = 0;
}
if
(status > -1) {
status = connect(sock, (
struct
sockaddr *) &sockaddr,
sizeof
(sockaddr));
if
(status < 0) {
if
(
errno
== EINPROGRESS) {
asyncConnect = 1;
status = 0;
}
}
else
{
if
(async) {
#ifndef USE_FIONBIO
origState = fcntl(sock, F_GETFL);
curState = origState & ~(O_NONBLOCK);
status = fcntl(sock, F_SETFL, curState);
#else /* USE_FIONBIO */
curState = 0;
status = ioctl(sock, FIONBIO, &curState);
#endif /* !USE_FIONBIO */
}
}
}
}
bindError:
if
(status < 0) {
if
(interp != NULL) {
Tcl_AppendResult(interp,
"couldn't open socket: "
,
Tcl_PosixError(interp), (
char
*) NULL);
}
if
(sock != -1) {
close(sock);
}
return
NULL;
}
statePtr = (TcpState *) ckalloc((unsigned)
sizeof
(TcpState));
statePtr->flags = 0;
if
(asyncConnect) {
statePtr->flags = TCP_ASYNC_CONNECT;
}
statePtr->fd = sock;
return
statePtr;
addressError:
if
(sock != -1) {
close(sock);
}
if
(interp != NULL) {
Tcl_AppendResult(interp,
"couldn't open socket: "
,
Tcl_PosixError(interp), (
char
*) NULL);
}
return
NULL;
}
static
int
CreateSocketAddress(sockaddrPtr, host, port)
struct
sockaddr_in *sockaddrPtr;
CONST
char
*host;
int
port;
{
struct
hostent *hostent;
struct
in_addr addr;
(
void
)
memset
((
VOID
*) sockaddrPtr,
'\0'
,
sizeof
(
struct
sockaddr_in));
sockaddrPtr->sin_family = AF_INET;
sockaddrPtr->sin_port = htons((unsigned
short
) (port & 0xFFFF));
if
(host == NULL) {
addr.s_addr = INADDR_ANY;
}
else
{
Tcl_DString ds;
CONST
char
*native;
if
(host == NULL) {
native = NULL;
}
else
{
native = Tcl_UtfToExternalDString(NULL, host, -1, &ds);
}
addr.s_addr = inet_addr(native);
if
(addr.s_addr == 0xFFFFFFFF) {
hostent = gethostbyname(native);
if
(hostent != NULL) {
memcpy
((
VOID
*) &addr,
(
VOID
*) hostent->h_addr_list[0],
(
size_t
) hostent->h_length);
}
else
{
#ifdef EHOSTUNREACH
errno
= EHOSTUNREACH;
#else /* !EHOSTUNREACH */
#ifdef ENXIO
errno
= ENXIO;
#endif /* ENXIO */
#endif /* EHOSTUNREACH */
if
(native != NULL) {
Tcl_DStringFree(&ds);
}
return
0;
}
}
if
(native != NULL) {
Tcl_DStringFree(&ds);
}
}
sockaddrPtr->sin_addr.s_addr = addr.s_addr;
return
1;
}
Tcl_Channel
Tcl_OpenTcpClient(interp, port, host, myaddr, myport, async)
Tcl_Interp *interp;
int
port;
CONST
char
*host;
CONST
char
*myaddr;
int
myport;
int
async;
{
TcpState *statePtr;
char
channelName[16 + TCL_INTEGER_SPACE];
statePtr = CreateSocket(interp, port, host, 0, myaddr, myport, async);
if
(statePtr == NULL) {
return
NULL;
}
statePtr->acceptProc = NULL;
statePtr->acceptProcData = (ClientData) NULL;
sprintf
(channelName,
"sock%d"
, statePtr->fd);
statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
(ClientData) statePtr, (TCL_READABLE | TCL_WRITABLE));
if
(Tcl_SetChannelOption(interp, statePtr->channel,
"-translation"
,
"auto crlf"
) == TCL_ERROR) {
Tcl_Close((Tcl_Interp *) NULL, statePtr->channel);
return
NULL;
}
return
statePtr->channel;
}
Tcl_Channel
Tcl_MakeTcpClientChannel(sock)
ClientData sock;
{
return
MakeTcpClientChannelMode(sock, (TCL_READABLE | TCL_WRITABLE));
}
static
Tcl_Channel
MakeTcpClientChannelMode(sock, mode)
ClientData sock;
int
mode;
{
TcpState *statePtr;
char
channelName[16 + TCL_INTEGER_SPACE];
statePtr = (TcpState *) ckalloc((unsigned)
sizeof
(TcpState));
statePtr->fd = (
int
) sock;
statePtr->flags = 0;
statePtr->acceptProc = NULL;
statePtr->acceptProcData = (ClientData) NULL;
sprintf
(channelName,
"sock%d"
, statePtr->fd);
statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
(ClientData) statePtr, mode);
if
(Tcl_SetChannelOption((Tcl_Interp *) NULL, statePtr->channel,
"-translation"
,
"auto crlf"
) == TCL_ERROR) {
Tcl_Close((Tcl_Interp *) NULL, statePtr->channel);
return
NULL;
}
return
statePtr->channel;
}
Tcl_Channel
Tcl_OpenTcpServer(interp, port, myHost, acceptProc, acceptProcData)
Tcl_Interp *interp;
int
port;
CONST
char
*myHost;
Tcl_TcpAcceptProc *acceptProc;
ClientData acceptProcData;
{
TcpState *statePtr;
char
channelName[16 + TCL_INTEGER_SPACE];
statePtr = CreateSocket(interp, port, myHost, 1, NULL, 0, 0);
if
(statePtr == NULL) {
return
NULL;
}
statePtr->acceptProc = acceptProc;
statePtr->acceptProcData = acceptProcData;
Tcl_CreateFileHandler(statePtr->fd, TCL_READABLE, TcpAccept,
(ClientData) statePtr);
sprintf
(channelName,
"sock%d"
, statePtr->fd);
statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
(ClientData) statePtr, 0);
return
statePtr->channel;
}
static
void
TcpAccept(data, mask)
ClientData data;
int
mask;
{
TcpState *sockState;
int
newsock;
TcpState *newSockState;
struct
sockaddr_in addr;
socklen_t len;
char
channelName[16 + TCL_INTEGER_SPACE];
sockState = (TcpState *) data;
len =
sizeof
(
struct
sockaddr_in);
newsock = accept(sockState->fd, (
struct
sockaddr *) &addr, &len);
if
(newsock < 0) {
return
;
}
(
void
) fcntl(newsock, F_SETFD, FD_CLOEXEC);
newSockState = (TcpState *) ckalloc((unsigned)
sizeof
(TcpState));
newSockState->flags = 0;
newSockState->fd = newsock;
newSockState->acceptProc = NULL;
newSockState->acceptProcData = NULL;
sprintf
(channelName,
"sock%d"
, newsock);
newSockState->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
(ClientData) newSockState, (TCL_READABLE | TCL_WRITABLE));
Tcl_SetChannelOption(NULL, newSockState->channel,
"-translation"
,
"auto crlf"
);
if
(sockState->acceptProc != NULL) {
(*sockState->acceptProc)(sockState->acceptProcData,
newSockState->channel, inet_ntoa(addr.sin_addr),
ntohs(addr.sin_port));
}
}
Tcl_Channel
TclpGetDefaultStdChannel(type)
int
type;
{
Tcl_Channel channel = NULL;
int
fd = 0;
int
mode = 0;
char
*bufMode = NULL;
#define ZERO_OFFSET ((Tcl_SeekOffset) 0)
#define ERROR_OFFSET ((Tcl_SeekOffset) -1)
switch
(type) {
case
TCL_STDIN:
if
((TclOSseek(0, ZERO_OFFSET, SEEK_CUR) == ERROR_OFFSET)
&& (
errno
== EBADF)) {
return
(Tcl_Channel) NULL;
}
fd = 0;
mode = TCL_READABLE;
bufMode =
"line"
;
break
;
case
TCL_STDOUT:
if
((TclOSseek(1, ZERO_OFFSET, SEEK_CUR) == ERROR_OFFSET)
&& (
errno
== EBADF)) {
return
(Tcl_Channel) NULL;
}
fd = 1;
mode = TCL_WRITABLE;
bufMode =
"line"
;
break
;
case
TCL_STDERR:
if
((TclOSseek(2, ZERO_OFFSET, SEEK_CUR) == ERROR_OFFSET)
&& (
errno
== EBADF)) {
return
(Tcl_Channel) NULL;
}
fd = 2;
mode = TCL_WRITABLE;
bufMode =
"none"
;
break
;
default
:
panic(
"TclGetDefaultStdChannel: Unexpected channel type"
);
break
;
}
#undef ZERO_OFFSET
#undef ERROR_OFFSET
channel = Tcl_MakeFileChannel((ClientData) fd, mode);
if
(channel == NULL) {
return
NULL;
}
if
(Tcl_GetChannelType(channel) == &fileChannelType) {
Tcl_SetChannelOption(NULL, channel,
"-translation"
,
"auto"
);
}
else
{
Tcl_SetChannelOption(NULL, channel,
"-translation"
,
"auto crlf"
);
}
Tcl_SetChannelOption(NULL, channel,
"-buffering"
, bufMode);
return
channel;
}
int
Tcl_GetOpenFile(interp, string, forWriting, checkUsage, filePtr)
Tcl_Interp *interp;
CONST
char
*string;
int
forWriting;
int
checkUsage;
ClientData *filePtr;
{
Tcl_Channel chan;
int
chanMode;
Tcl_ChannelType *chanTypePtr;
ClientData data;
int
fd;
FILE
*f;
chan = Tcl_GetChannel(interp, string, &chanMode);
if
(chan == (Tcl_Channel) NULL) {
return
TCL_ERROR;
}
if
((forWriting) && ((chanMode & TCL_WRITABLE) == 0)) {
Tcl_AppendResult(interp,
"\""
, string,
"\" wasn't opened for writing"
, (
char
*) NULL);
return
TCL_ERROR;
}
else
if
((!(forWriting)) && ((chanMode & TCL_READABLE) == 0)) {
Tcl_AppendResult(interp,
"\""
, string,
"\" wasn't opened for reading"
, (
char
*) NULL);
return
TCL_ERROR;
}
chanTypePtr = Tcl_GetChannelType(chan);
if
((chanTypePtr == &fileChannelType)
#ifdef SUPPORTS_TTY
|| (chanTypePtr == &ttyChannelType)
#endif /* SUPPORTS_TTY */
|| (chanTypePtr == &tcpChannelType)
|| (
strcmp
(chanTypePtr->typeName,
"pipe"
) == 0)) {
if
(Tcl_GetChannelHandle(chan,
(forWriting ? TCL_WRITABLE : TCL_READABLE),
(ClientData*) &data) == TCL_OK) {
fd = (
int
) data;
f = fdopen(fd, (forWriting ?
"w"
:
"r"
));
if
(f == NULL) {
Tcl_AppendResult(interp,
"cannot get a FILE * for \""
, string,
"\""
, (
char
*) NULL);
return
TCL_ERROR;
}
*filePtr = (ClientData) f;
return
TCL_OK;
}
}
Tcl_AppendResult(interp,
"\""
, string,
"\" cannot be used to get a FILE *"
, (
char
*) NULL);
return
TCL_ERROR;
}
int
TclUnixWaitForFile(fd, mask, timeout)
int
fd;
int
mask;
int
timeout;
{
Tcl_Time abortTime, now;
struct
timeval blockTime, *timeoutPtr;
int
index, bit, numFound, result = 0;
fd_mask readyMasks[3*MASK_SIZE];
if
(timeout > 0) {
Tcl_GetTime(&now);
abortTime.sec = now.sec + timeout/1000;
abortTime.usec = now.usec + (timeout%1000)*1000;
if
(abortTime.usec >= 1000000) {
abortTime.usec -= 1000000;
abortTime.sec += 1;
}
timeoutPtr = &blockTime;
}
else
if
(timeout == 0) {
timeoutPtr = &blockTime;
blockTime.tv_sec = 0;
blockTime.tv_usec = 0;
}
else
{
timeoutPtr = NULL;
}
if
(fd >= FD_SETSIZE) {
panic(
"TclWaitForFile can't handle file id %d"
, fd);
}
memset
((
VOID
*) readyMasks, 0, 3*MASK_SIZE*
sizeof
(fd_mask));
index = fd/(NBBY*
sizeof
(fd_mask));
bit = 1 << (fd%(NBBY*
sizeof
(fd_mask)));
while
(1) {
if
(timeout > 0) {
blockTime.tv_sec = abortTime.sec - now.sec;
blockTime.tv_usec = abortTime.usec - now.usec;
if
(blockTime.tv_usec < 0) {
blockTime.tv_sec -= 1;
blockTime.tv_usec += 1000000;
}
if
(blockTime.tv_sec < 0) {
blockTime.tv_sec = 0;
blockTime.tv_usec = 0;
}
}
if
(mask & TCL_READABLE) {
readyMasks[index] |= bit;
}
if
(mask & TCL_WRITABLE) {
(readyMasks+MASK_SIZE)[index] |= bit;
}
if
(mask & TCL_EXCEPTION) {
(readyMasks+2*(MASK_SIZE))[index] |= bit;
}
numFound = select(fd+1, (SELECT_MASK *) &readyMasks[0],
(SELECT_MASK *) &readyMasks[MASK_SIZE],
(SELECT_MASK *) &readyMasks[2*MASK_SIZE], timeoutPtr);
if
(numFound == 1) {
if
(readyMasks[index] & bit) {
result |= TCL_READABLE;
}
if
((readyMasks+MASK_SIZE)[index] & bit) {
result |= TCL_WRITABLE;
}
if
((readyMasks+2*(MASK_SIZE))[index] & bit) {
result |= TCL_EXCEPTION;
}
result &= mask;
if
(result) {
break
;
}
}
if
(timeout == 0) {
break
;
}
Tcl_GetTime(&now);
if
((abortTime.sec < now.sec)
|| ((abortTime.sec == now.sec)
&& (abortTime.usec <= now.usec))) {
break
;
}
}
return
result;
}
void
TclpCutFileChannel(chan)
Tcl_Channel chan;
{
#ifdef DEPRECATED
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
Channel *chanPtr = (Channel *) chan;
FileState *fsPtr;
FileState **nextPtrPtr;
int
removed = 0;
if
(chanPtr->typePtr != &fileChannelType)
return
;
fsPtr = (FileState *) chanPtr->instanceData;
for
(nextPtrPtr = &(tsdPtr->firstFilePtr); (*nextPtrPtr) != NULL;
nextPtrPtr = &((*nextPtrPtr)->nextPtr)) {
if
((*nextPtrPtr) == fsPtr) {
(*nextPtrPtr) = fsPtr->nextPtr;
removed = 1;
break
;
}
}
if
(!removed)
panic(
"file info ptr not on thread channel list"
);
#endif /* DEPRECATED */
}
void
TclpSpliceFileChannel(chan)
Tcl_Channel chan;
{
#ifdef DEPRECATED
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
Channel *chanPtr = (Channel *) chan;
FileState *fsPtr;
if
(chanPtr->typePtr != &fileChannelType)
return
;
fsPtr = (FileState *) chanPtr->instanceData;
fsPtr->nextPtr = tsdPtr->firstFilePtr;
tsdPtr->firstFilePtr = fsPtr;
#endif /* DEPRECATED */
}