/* 

  * tclUnixChan.c

  *

  *	Common channel driver for Unix channels based on files, command

  *	pipes and TCP sockets.

  *

  * Copyright (c) 1995-1997 Sun Microsystems, Inc.

  * Copyright (c) 1998-1999 by Scriptics Corporation.

  * Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.  

  *

  * See the file "license.terms" for information on usage and redistribution

  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

  *

  * RCS: @(#) $Id: tclUnixChan.c,v 1.42.2.10 2006/11/28 16:29:48 kennykb Exp $

  */

 #include "tclInt.h"	/* Internal definitions for Tcl. */

 #include "tclPort.h"	/* Portability features for Tcl. */

 #include "tclIO.h"	/* To get Channel type declaration. */

 /*

  * sys/ioctl.h has already been included by tclPort.h.	Including termios.h

  * or termio.h causes a bunch of warning messages because some duplicate

  * (but not contradictory) #defines exist in termios.h and/or termio.h

  */

 #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))

     /*

      * TIP #35 introduced a different on exit flush/close behavior that

      * doesn't work correctly with standard channels on all systems.

      * The problem is tcflush throws away waiting channel data.	 This may

      * be necessary for true serial channels that may block, but isn't

      * correct in the standard case.  This might be replaced with tcdrain

      * instead, but that can block.  For now, we revert to making this do

      * nothing, and TtyOutputProc being the same old FileOutputProc.

      * -- hobbs [Bug #525783]

      */

 #   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)

 /*

  * Can't use ?: operator below because that messes up types on either

  * Linux or Solaris (the two are mutually exclusive!)

  */

 #	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 */

 /*

  * This structure describes per-instance state of a file based channel.

  */

 typedef struct FileState {

     Tcl_Channel channel;	/* Channel associated with this file. */

     int fd;			/* File handle. */

     int validMask;		/* OR'ed combination of TCL_READABLE,

 				 * TCL_WRITABLE, or TCL_EXCEPTION: indicates

 				 * which operations are valid on the file. */

 #ifdef DEPRECATED

     struct FileState *nextPtr;	/* Pointer to next file in list of all

 				 * file channels. */

 #endif /* DEPRECATED */

 } FileState;

 #ifdef SUPPORTS_TTY

 /*

  * The following structure describes per-instance state of a tty-based

  * channel.

  */

 typedef struct TtyState {

     FileState fs;		/* Per-instance state of the file

 				 * descriptor.	Must be the first field. */

     int stateUpdated;		/* Flag to say if the state has been

 				 * modified and needs resetting. */

     IOSTATE savedState;		/* Initial state of device.  Used to reset

 				 * state when device closed. */

 } TtyState;

 /*

  * The following structure is used to set or get the serial port

  * attributes in a platform-independant manner.

  */

 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 {

     /*

      * List of all file channels currently open.  This is per thread and is

      * used to match up fd's to channels, which rarely occurs.

      */

     FileState *firstFilePtr;

 } ThreadSpecificData;

 static Tcl_ThreadDataKey dataKey;

 #endif /* DEPRECATED */

 /*

  * This structure describes per-instance state of a tcp based channel.

  */

 typedef struct TcpState {

     Tcl_Channel channel;	/* Channel associated with this file. */

     int fd;			/* The socket itself. */

     int flags;			/* ORed combination of the bitfields

 				 * defined below. */

     Tcl_TcpAcceptProc *acceptProc;

 				/* Proc to call on accept. */

     ClientData acceptProcData;	/* The data for the accept proc. */

 } TcpState;

 /*

  * These bits may be ORed together into the "flags" field of a TcpState

  * structure.

  */

 #define TCP_ASYNC_SOCKET	(1<<0)	/* Asynchronous socket. */

 #define TCP_ASYNC_CONNECT	(1<<1)	/* Async connect in progress. */

 /*

  * The following defines the maximum length of the listen queue. This is

  * the number of outstanding yet-to-be-serviced requests for a connection

  * on a server socket, more than this number of outstanding requests and

  * the connection request will fail.

  */

 #ifndef SOMAXCONN

 #   define SOMAXCONN	100

 #endif /* SOMAXCONN */

 #if (SOMAXCONN < 100)

 #   undef  SOMAXCONN

 #   define SOMAXCONN	100

 #endif /* SOMAXCONN < 100 */

 /*

  * The following defines how much buffer space the kernel should maintain

  * for a socket.

  */

 #define SOCKET_BUFSIZE	4096

 /*

  * Static routines for this file:

  */

 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));

 #ifdef DEPRECATED

 static void             FileThreadActionProc _ANSI_ARGS_ ((

 			   ClientData instanceData, int action));

 #endif

 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));

 /*

  * This structure describes the channel type structure for file based IO:

  */

 static Tcl_ChannelType fileChannelType = {

     "file",			/* Type name. */

     TCL_CHANNEL_VERSION_4,	/* v4 channel */

     FileCloseProc,		/* Close proc. */

     FileInputProc,		/* Input proc. */

     FileOutputProc,		/* Output proc. */

     FileSeekProc,		/* Seek proc. */

     NULL,			/* Set option proc. */

     NULL,			/* Get option proc. */

     FileWatchProc,		/* Initialize notifier. */

     FileGetHandleProc,		/* Get OS handles out of channel. */

     NULL,			/* close2proc. */

     FileBlockModeProc,		/* Set blocking or non-blocking mode.*/

     NULL,			/* flush proc. */

     NULL,			/* handler proc. */

     FileWideSeekProc,		/* wide seek proc. */

 #ifdef DEPRECATED

     FileThreadActionProc,       /* thread actions */

 #else

     NULL,

 #endif

 };

 #ifdef SUPPORTS_TTY

 /*

  * This structure describes the channel type structure for serial IO.

  * Note that this type is a subclass of the "file" type.

  */

 static Tcl_ChannelType ttyChannelType = {

     "tty",			/* Type name. */

     TCL_CHANNEL_VERSION_4,	/* v4 channel */

     TtyCloseProc,		/* Close proc. */

     FileInputProc,		/* Input proc. */

 #if BAD_TIP35_FLUSH

     TtyOutputProc,		/* Output proc. */

 #else /* !BAD_TIP35_FLUSH */

     FileOutputProc,		/* Output proc. */

 #endif /* BAD_TIP35_FLUSH */

     NULL,			/* Seek proc. */

     TtySetOptionProc,		/* Set option proc. */

     TtyGetOptionProc,		/* Get option proc. */

     FileWatchProc,		/* Initialize notifier. */

     FileGetHandleProc,		/* Get OS handles out of channel. */

     NULL,			/* close2proc. */

     FileBlockModeProc,		/* Set blocking or non-blocking mode.*/

     NULL,			/* flush proc. */

     NULL,			/* handler proc. */

     NULL,			/* wide seek proc. */

     NULL,			/* thread action proc. */

 };

 #endif	/* SUPPORTS_TTY */

 /*

  * This structure describes the channel type structure for TCP socket

  * based IO:

  */

 static Tcl_ChannelType tcpChannelType = {

     "tcp",			/* Type name. */

     TCL_CHANNEL_VERSION_4,	/* v4 channel */

     TcpCloseProc,		/* Close proc. */

     TcpInputProc,		/* Input proc. */

     TcpOutputProc,		/* Output proc. */

     NULL,			/* Seek proc. */

     NULL,			/* Set option proc. */

     TcpGetOptionProc,		/* Get option proc. */

     TcpWatchProc,		/* Initialize notifier. */

     TcpGetHandleProc,		/* Get OS handles out of channel. */

     NULL,			/* close2proc. */

     TcpBlockModeProc,		/* Set blocking or non-blocking mode.*/

     NULL,			/* flush proc. */

     NULL,			/* handler proc. */

     NULL,			/* wide seek proc. */

     NULL,			/* thread action proc. */

 };

 /*

  *----------------------------------------------------------------------

  *

  * FileBlockModeProc --

  *

  *	Helper procedure to set blocking and nonblocking modes on a

  *	file based channel. Invoked by generic IO level code.

  *

  * Results:

  *	0 if successful, errno when failed.

  *

  * Side effects:

  *	Sets the device into blocking or non-blocking mode.

  *

  *----------------------------------------------------------------------

  */

 	/* ARGSUSED */

 static int

 FileBlockModeProc(instanceData, mode)

     ClientData instanceData;		/* File state. */

     int mode;				/* The mode to set. Can be one of

 					 * TCL_MODE_BLOCKING or

 					 * TCL_MODE_NONBLOCKING. */

 {

     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;

 }

 /*

  *----------------------------------------------------------------------

  *

  * FileInputProc --

  *

  *	This procedure is invoked from the generic IO level to read

  *	input from a file based channel.

  *

  * Results:

  *	The number of bytes read is returned or -1 on error. An output

  *	argument contains a POSIX error code if an error occurs, or zero.

  *

  * Side effects:

  *	Reads input from the input device of the channel.

  *

  *----------------------------------------------------------------------

  */

 static int

 FileInputProc(instanceData, buf, toRead, errorCodePtr)

     ClientData instanceData;		/* File state. */

     char *buf;				/* Where to store data read. */

     int toRead;				/* How much space is available

 					 * in the buffer? */

     int *errorCodePtr;			/* Where to store error code. */

 {

     FileState *fsPtr = (FileState *) instanceData;

     int bytesRead;			/* How many bytes were actually

 					 * read from the input device? */

     *errorCodePtr = 0;

     /*

      * Assume there is always enough input available. This will block

      * appropriately, and read will unblock as soon as a short read is

      * possible, if the channel is in blocking mode. If the channel is

      * nonblocking, the read will never block.

      */

     bytesRead = read(fsPtr->fd, buf, (size_t) toRead);

     if (bytesRead > -1) {

 	return bytesRead;

     }

     *errorCodePtr = errno;

     return -1;

 }

 /*

  *----------------------------------------------------------------------

  *

  * FileOutputProc--

  *

  *	This procedure is invoked from the generic IO level to write

  *	output to a file channel.

  *

  * Results:

  *	The number of bytes written is returned or -1 on error. An

  *	output argument contains a POSIX error code if an error occurred,

  *	or zero.

  *

  * Side effects:

  *	Writes output on the output device of the channel.

  *

  *----------------------------------------------------------------------

  */

 static int

 FileOutputProc(instanceData, buf, toWrite, errorCodePtr)

     ClientData instanceData;		/* File state. */

     CONST char *buf;			/* The data buffer. */

     int toWrite;			/* How many bytes to write? */

     int *errorCodePtr;			/* Where to store error code. */

 {

     FileState *fsPtr = (FileState *) instanceData;

     int written;

     *errorCodePtr = 0;

     if (toWrite == 0) {

 	/*

 	 * SF Tcl Bug 465765.

 	 * Do not try to write nothing into a file. STREAM based

 	 * implementations will considers this as EOF (if there is a

 	 * pipe behind the file).

 	 */

 	return 0;

     }

     written = write(fsPtr->fd, buf, (size_t) toWrite);

     if (written > -1) {

 	return written;

     }

     *errorCodePtr = errno;

     return -1;

 }

 /*

  *----------------------------------------------------------------------

  *

  * FileCloseProc --

  *

  *	This procedure is called from the generic IO level to perform

  *	channel-type-specific cleanup when a file based channel is closed.

  *

  * Results:

  *	0 if successful, errno if failed.

  *

  * Side effects:

  *	Closes the device of the channel.

  *

  *----------------------------------------------------------------------

  */

 static int

 FileCloseProc(instanceData, interp)

     ClientData instanceData;	/* File state. */

     Tcl_Interp *interp;		/* For error reporting - unused. */

 {

     FileState *fsPtr = (FileState *) instanceData;

     int errorCode = 0;

 #ifdef DEPRECATED

     FileState **nextPtrPtr;

     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

 #endif /* DEPRECATED */

     Tcl_DeleteFileHandler(fsPtr->fd);

     /*

      * Do not close standard channels while in thread-exit.

      */

     if (!TclInThreadExit()

 	    || ((fsPtr->fd != 0) && (fsPtr->fd != 1) && (fsPtr->fd != 2))) {

 	if (close(fsPtr->fd) < 0) {

 	    errorCode = errno;

 	}

     }

     ckfree((char *) fsPtr);

     return errorCode;

 }

 /*

  *----------------------------------------------------------------------

  *

  * FileSeekProc --

  *

  *	This procedure is called by the generic IO level to move the

  *	access point in a file based channel.

  *

  * Results:

  *	-1 if failed, the new position if successful. An output

  *	argument contains the POSIX error code if an error occurred,

  *	or zero.

  *

  * Side effects:

  *	Moves the location at which the channel will be accessed in

  *	future operations.

  *

  *----------------------------------------------------------------------

  */

 static int

 FileSeekProc(instanceData, offset, mode, errorCodePtr)

     ClientData instanceData;	/* File state. */

     long offset;		/* Offset to seek to. */

     int mode;			/* Relative to where should we seek? Can be

 				 * one of SEEK_START, SEEK_SET or SEEK_END. */

     int *errorCodePtr;		/* To store error code. */

 {

     FileState *fsPtr = (FileState *) instanceData;

     Tcl_WideInt oldLoc, newLoc;

     /*

      * Save our current place in case we need to roll-back the seek.

      */

     oldLoc = TclOSseek(fsPtr->fd, (Tcl_SeekOffset) 0, SEEK_CUR);

     if (oldLoc == Tcl_LongAsWide(-1)) {

 	/*

 	 * Bad things are happening.  Error out...

 	 */

 	*errorCodePtr = errno;

 	return -1;

     }

     newLoc = TclOSseek(fsPtr->fd, (Tcl_SeekOffset) offset, mode);

     /*

      * Check for expressability in our return type, and roll-back otherwise.

      */

     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);

 }

 /*

  *----------------------------------------------------------------------

  *

  * FileWideSeekProc --

  *

  *	This procedure is called by the generic IO level to move the

  *	access point in a file based channel, with offsets expressed

  *	as wide integers.

  *

  * Results:

  *	-1 if failed, the new position if successful. An output

  *	argument contains the POSIX error code if an error occurred,

  *	or zero.

  *

  * Side effects:

  *	Moves the location at which the channel will be accessed in

  *	future operations.

  *

  *----------------------------------------------------------------------

  */

 static Tcl_WideInt

 FileWideSeekProc(instanceData, offset, mode, errorCodePtr)

     ClientData instanceData;	/* File state. */

     Tcl_WideInt offset;		/* Offset to seek to. */

     int mode;			/* Relative to where should we seek? Can be

 				 * one of SEEK_START, SEEK_CUR or SEEK_END. */

     int *errorCodePtr;		/* To store error code. */

 {

     FileState *fsPtr = (FileState *) instanceData;

     Tcl_WideInt newLoc;

     newLoc = TclOSseek(fsPtr->fd, (Tcl_SeekOffset) offset, mode);

     *errorCodePtr = (newLoc == -1) ? errno : 0;

     return newLoc;

 }

 /*

  *----------------------------------------------------------------------

  *

  * FileWatchProc --

  *

  *	Initialize the notifier to watch the fd from this channel.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	Sets up the notifier so that a future event on the channel will

  *	be seen by Tcl.

  *

  *----------------------------------------------------------------------

  */

 static void

 FileWatchProc(instanceData, mask)

     ClientData instanceData;		/* The file state. */

     int mask;				/* Events of interest; an OR-ed

 					 * combination of TCL_READABLE,

 					 * TCL_WRITABLE and TCL_EXCEPTION. */

 {

     FileState *fsPtr = (FileState *) instanceData;

     /*

      * Make sure we only register for events that are valid on this file.

      * Note that we are passing Tcl_NotifyChannel directly to

      * Tcl_CreateFileHandler with the channel pointer as the client data.

      */

     mask &= fsPtr->validMask;

     if (mask) {

 	Tcl_CreateFileHandler(fsPtr->fd, mask,

 		(Tcl_FileProc *) Tcl_NotifyChannel,

 		(ClientData) fsPtr->channel);

     } else {

 	Tcl_DeleteFileHandler(fsPtr->fd);

     }

 }

 /*

  *----------------------------------------------------------------------

  *

  * FileGetHandleProc --

  *

  *	Called from Tcl_GetChannelHandle to retrieve OS handles from

  *	a file based channel.

  *

  * Results:

  *	Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if

  *	there is no handle for the specified direction. 

  *

  * Side effects:

  *	None.

  *

  *----------------------------------------------------------------------

  */

 static int

 FileGetHandleProc(instanceData, direction, handlePtr)

     ClientData instanceData;	/* The file state. */

     int direction;		/* TCL_READABLE or TCL_WRITABLE */

     ClientData *handlePtr;	/* Where to store the handle.  */

 {

     FileState *fsPtr = (FileState *) instanceData;

     if (direction & fsPtr->validMask) {

 	*handlePtr = (ClientData) fsPtr->fd;

 	return TCL_OK;

     } else {

 	return TCL_ERROR;

     }

 }

 #ifdef SUPPORTS_TTY 

 /*

  *----------------------------------------------------------------------

  *

  * TtyCloseProc --

  *

  *	This procedure is called from the generic IO level to perform

  *	channel-type-specific cleanup when a tty based channel is closed.

  *

  * Results:

  *	0 if successful, errno if failed.

  *

  * Side effects:

  *	Closes the device of the channel.

  *

  *----------------------------------------------------------------------

  */

 static int

 TtyCloseProc(instanceData, interp)

     ClientData instanceData;	/* Tty state. */

     Tcl_Interp *interp;		/* For error reporting - unused. */

 {

 #if BAD_TIP35_FLUSH

     TtyState *ttyPtr = (TtyState *) instanceData;

 #endif /* BAD_TIP35_FLUSH */

 #ifdef TTYFLUSH

     TTYFLUSH(ttyPtr->fs.fd);

 #endif /* TTYFLUSH */

 #if 0

     /*

      * TIP#35 agreed to remove the unsave so that TCL could be used as a 

      * simple stty. 

      * It would be cleaner to remove all the stuff related to 

      *	  TtyState.stateUpdated

      *	  TtyState.savedState

      * Then the structure TtyState would be the same as FileState.

      * IMO this cleanup could better be done for the final 8.4 release

      * after nobody complained about the missing unsave. -- schroedter

      */

     if (ttyPtr->stateUpdated) {

 	SETIOSTATE(ttyPtr->fs.fd, &ttyPtr->savedState);

     }

 #endif

     return FileCloseProc(instanceData, interp);

 }

 /*

  *----------------------------------------------------------------------

  *

  * TtyOutputProc--

  *

  *	This procedure is invoked from the generic IO level to write

  *	output to a TTY channel.

  *

  * Results:

  *	The number of bytes written is returned or -1 on error. An

  *	output argument contains a POSIX error code if an error occurred,

  *	or zero.

  *

  * Side effects:

  *	Writes output on the output device of the channel

  *	if the channel is not designated to be closed.

  *

  *----------------------------------------------------------------------

  */

 #if BAD_TIP35_FLUSH

 static int

 TtyOutputProc(instanceData, buf, toWrite, errorCodePtr)

     ClientData instanceData;		/* File state. */

     CONST char *buf;			/* The data buffer. */

     int toWrite;			/* How many bytes to write? */

     int *errorCodePtr;			/* Where to store error code. */

 {

     if (TclInExit()) {

 	/*

 	 * Do not write data during Tcl exit.

 	 * Serial port may block preventing Tcl from exit.

 	 */

 	return toWrite;

     } else {

 	return FileOutputProc(instanceData, buf, toWrite, errorCodePtr);

     }

 }

 #endif /* BAD_TIP35_FLUSH */

 #ifdef USE_TERMIOS

 /*

  *----------------------------------------------------------------------

  *

  * TtyModemStatusStr --

  *

  *  Converts a RS232 modem status list of readable flags

  *

  *----------------------------------------------------------------------

  */

 static void

 TtyModemStatusStr(status, dsPtr)

     int status;		   /* RS232 modem status */

     Tcl_DString *dsPtr;	   /* Where to store string */

 {

 #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 */

 /*

  *----------------------------------------------------------------------

  *

  * TtySetOptionProc --

  *

  *	Sets an option on a channel.

  *

  * Results:

  *	A standard Tcl result. Also sets the interp's result on error if

  *	interp is not NULL.

  *

  * Side effects:

  *	May modify an option on a device.

  *	Sets Error message if needed (by calling Tcl_BadChannelOption).

  *

  *----------------------------------------------------------------------

  */

 static int		

 TtySetOptionProc(instanceData, interp, optionName, value)

     ClientData instanceData;	/* File state. */

     Tcl_Interp *interp;		/* For error reporting - can be NULL. */

     CONST char *optionName;	/* Which option to set? */

     CONST char *value;		/* New value for option. */

 {

     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);

     /*

      * Option -mode baud,parity,databits,stopbits

      */

     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;

 	}

 	/*

 	 * system calls results should be checked there. -- dl

 	 */

 	TtySetAttributes(fsPtr->fd, &tty);

 	((TtyState *) fsPtr)->stateUpdated = 1;

 	return TCL_OK;

     }

 #ifdef USE_TERMIOS

     /*

      * Option -handshake none|xonxoff|rtscts|dtrdsr

      */

     if ((len > 1) && (strncmp(optionName, "-handshake", len) == 0)) {

 	/*

 	 * Reset all handshake options

 	 * DTR and RTS are ON by default

 	 */

 	GETIOSTATE(fsPtr->fd, &iostate);

 	iostate.c_iflag &= ~(IXON | IXOFF | IXANY);

 #ifdef CRTSCTS

 	iostate.c_cflag &= ~CRTSCTS;

 #endif /* CRTSCTS */

 	if (strncasecmp(value, "NONE", vlen) == 0) {

 	    /* leave all handshake options disabled */

 	} 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;

     }

     /*

      * Option -xchar {\x11 \x13}

      */

     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);

 	    }

 	    ckfree((char *) argv);

 	    return TCL_ERROR;

 	}

 	SETIOSTATE(fsPtr->fd, &iostate);

 	ckfree((char *) argv);

 	return TCL_OK;

     }

     /*

      * Option -timeout msec

      */

     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;

     }

     /*

      * Option -ttycontrol {DTR 1 RTS 0 BREAK 0}

      */

     if ((len > 4) && (strncmp(optionName, "-ttycontrol", len) == 0)) {

 	int i;

 	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);

 	    }

 	    ckfree((char *) argv);

 	    return TCL_ERROR;

 	}

 	GETCONTROL(fsPtr->fd, &control);

 	for (i = 0; i < argc-1; i += 2) {

 	    if (Tcl_GetBoolean(interp, argv[i+1], &flag) == TCL_ERROR) {

 		ckfree((char *) argv);

 		return TCL_ERROR;

 	    }

 	    if (strncasecmp(argv[i], "DTR", strlen(argv[i])) == 0) {

 #ifdef TIOCM_DTR

 		if (flag) {

 		    control |= TIOCM_DTR;

 		} else {

 		    control &= ~TIOCM_DTR;

 		}

 #else /* !TIOCM_DTR */

 		UNSUPPORTED_OPTION("-ttycontrol DTR");

 		ckfree((char *) argv);

 		return TCL_ERROR;

 #endif /* TIOCM_DTR */

 	    } else if (strncasecmp(argv[i], "RTS", strlen(argv[i])) == 0) {

 #ifdef TIOCM_RTS

 		if (flag) {

 		    control |= TIOCM_RTS;

 		} else {

 		    control &= ~TIOCM_RTS;

 		}

 #else /* !TIOCM_RTS*/

 		UNSUPPORTED_OPTION("-ttycontrol RTS");

 		ckfree((char *) argv);

 		return TCL_ERROR;

 #endif /* TIOCM_RTS*/

 	    } else if (strncasecmp(argv[i], "BREAK", strlen(argv[i])) == 0) {

 #ifdef SETBREAK

 		SETBREAK(fsPtr->fd, flag);

 #else /* !SETBREAK */

 		UNSUPPORTED_OPTION("-ttycontrol BREAK");

 		ckfree((char *) argv);

 		return TCL_ERROR;

 #endif /* SETBREAK */

 	    } else {

 		if (interp) {

 		    Tcl_AppendResult(interp, "bad signal \"", argv[i],

 			    "\" for -ttycontrol: must be ",

 			    "DTR, RTS or BREAK", (char *) NULL);

 		}

 		ckfree((char *) argv);

 		return TCL_ERROR;

 	    }

 	} /* -ttycontrol options loop */

 	SETCONTROL(fsPtr->fd, &control);

 	ckfree((char *) argv);

 	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 */

 }

 /*

  *----------------------------------------------------------------------

  *

  * TtyGetOptionProc --

  *

  *	Gets a mode associated with an IO channel. If the optionName arg

  *	is non NULL, retrieves the value of that option. If the optionName

  *	arg is NULL, retrieves a list of alternating option names and

  *	values for the given channel.

  *

  * Results:

  *	A standard Tcl result. Also sets the supplied DString to the

  *	string value of the option(s) returned.

  *

  * Side effects:

  *	The string returned by this function is in static storage and

  *	may be reused at any time subsequent to the call.

  *	Sets Error message if needed (by calling Tcl_BadChannelOption).

  *

  *----------------------------------------------------------------------

  */

 static int		

 TtyGetOptionProc(instanceData, interp, optionName, dsPtr)

     ClientData instanceData;	/* File state. */

     Tcl_Interp *interp;		/* For error reporting - can be NULL. */

     CONST char *optionName;	/* Option to get. */

     Tcl_DString *dsPtr;		/* Where to store value(s). */

 {

     FileState *fsPtr = (FileState *) instanceData;

     unsigned int len;

     char buf[3 * TCL_INTEGER_SPACE + 16];

     TtyAttrs tty;

     int valid = 0;  /* flag if valid option parsed */

     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

     /*

      * get option -xchar

      */

     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);

     }

     /*

      * get option -queue

      * option is readonly and returned by [fconfigure chan -queue]

      * but not returned by unnamed [fconfigure chan]

      */

     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);

     }

     /*

      * get option -ttystatus

      * option is readonly and returned by [fconfigure chan -ttystatus]

      * but not returned by unnamed [fconfigure chan]

      */

     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}

 };

 /*

  *---------------------------------------------------------------------------

  *

  * TtyGetSpeed --

  *

  *	Given a baud rate, get the mask value that should be stored in

  *	the termios, termio, or sgttyb structure in order to select that

  *	baud rate.

  *

  * Results:

  *	As above.

  *

  * Side effects:

  *	None.

  *

  *---------------------------------------------------------------------------

  */

 static unsigned long

 TtyGetSpeed(baud)

     int baud;			/* The baud rate to look up. */

 {

     int bestIdx, bestDiff, i, diff;

     bestIdx = 0;

     bestDiff = 1000000;

     /*

      * If the baud rate does not correspond to one of the known mask values,

      * choose the mask value whose baud rate is closest to the specified

      * baud rate.

      */

     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;

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TtyGetBaud --

  *

  *	Given a speed mask value from a termios, termio, or sgttyb

  *	structure, get the baus rate that corresponds to that mask value.

  *

  * Results:

  *	As above.  If the mask value was not recognized, 0 is returned.

  *

  * Side effects:

  *	None.

  *

  *---------------------------------------------------------------------------

  */

 static int

 TtyGetBaud(speed)

     unsigned long speed;	/* Speed mask value to look up. */

 {

     int i;

     for (i = 0; speeds[i].baud >= 0; i++) {

 	if (speeds[i].speed == speed) {

 	    return speeds[i].baud;

 	}

     }

     return 0;

 }

 #endif /* !DIRECT_BAUD */

 /*

  *---------------------------------------------------------------------------

  *

  * TtyGetAttributes --

  *

  *	Get the current attributes of the specified serial device.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	None.

  *

  *---------------------------------------------------------------------------

  */

 static void

 TtyGetAttributes(fd, ttyPtr)

     int fd;			/* Open file descriptor for serial port to

 				 * be queried. */

     TtyAttrs *ttyPtr;		/* Buffer filled with serial port

 				 * attributes. */

 {

     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;

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TtySetAttributes --

  *

  *	Set the current attributes of the specified serial device. 

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	None.

  *

  *---------------------------------------------------------------------------

  */

 static void

 TtySetAttributes(fd, ttyPtr)

     int fd;			/* Open file descriptor for serial port to

 				 * be modified. */

     TtyAttrs *ttyPtr;		/* Buffer containing new attributes for

 				 * serial port. */

 {

     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);

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TtyParseMode --

  *

  *	Parse the "-mode" argument to the fconfigure command.  The argument

  *	is of the form baud,parity,data,stop.

  *

  * Results:

  *	The return value is TCL_OK if the argument was successfully

  *	parsed, TCL_ERROR otherwise.  If TCL_ERROR is returned, an

  *	error message is left in the interp's result (if interp is non-NULL).

  *

  * Side effects:

  *	None.

  *

  *---------------------------------------------------------------------------

  */

 static int

 TtyParseMode(interp, mode, speedPtr, parityPtr, dataPtr, stopPtr)

     Tcl_Interp *interp;		/* If non-NULL, interp for error return. */

     CONST char *mode;		/* Mode string to be parsed. */

     int *speedPtr;		/* Filled with baud rate from mode string. */

     int *parityPtr;		/* Filled with parity from mode string. */

     int *dataPtr;		/* Filled with data bits from mode string. */

     int *stopPtr;		/* Filled with stop bits from mode string. */

 {

     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;

     }

     /*

      * Only allow setting mark/space parity on platforms that support it

      * Make sure to allow for the case where strchr is a macro.

      * [Bug: 5089]

      */

     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;

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TtyInit --

  *

  *	Given file descriptor that refers to a serial port, 

  *	initialize the serial port to a set of sane values so that

  *	Tcl can talk to a device located on the serial port.

  *	Note that no initialization happens if the initialize flag

  *	is not set; this is necessary for the correct handling of

  *	UNIX console TTYs at startup.

  *

  * Results:

  *	A pointer to a FileState suitable for use with Tcl_CreateChannel

  *	and the ttyChannelType structure.

  *

  * Side effects:

  *	Serial device initialized to non-blocking raw mode, similar to

  *	sockets (if initialize flag is non-zero.)  All other modes can

  *	be simulated on top of this in Tcl.

  *

  *---------------------------------------------------------------------------

  */

 static FileState *

 TtyInit(fd, initialize)

     int fd;			/* Open file descriptor for serial port to

 				 * be initialized. */

     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 */

 	/*

 	 * Only update if we're changing anything to avoid possible

 	 * blocking.

 	 */

 	if (ttyPtr->stateUpdated) {

 	    SETIOSTATE(fd, &iostate);

 	}

     }

     return &ttyPtr->fs;

 }

 #endif	/* SUPPORTS_TTY */

 /*

  *----------------------------------------------------------------------

  *

  * TclpOpenFileChannel --

  *

  *	Open an file based channel on Unix systems.

  *

  * Results:

  *	The new channel or NULL. If NULL, the output argument

  *	errorCodePtr is set to a POSIX error and an error message is

  *	left in the interp's result if interp is not NULL.

  *

  * Side effects:

  *	May open the channel and may cause creation of a file on the

  *	file system.

  *

  *----------------------------------------------------------------------

  */

 Tcl_Channel

 TclpOpenFileChannel(interp, pathPtr, mode, permissions)

     Tcl_Interp *interp;			/* Interpreter for error reporting;

 					 * can be NULL. */

     Tcl_Obj *pathPtr;			/* Name of file to open. */

     int mode;				/* POSIX open mode. */

     int permissions;			/* If the open involves creating a

 					 * file, with what modes to create

 					 * it? */

 {

     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:

 	    /*

 	     * This may occurr if modeString was "", for example.

 	     */

 	    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;

     }

     /*

      * Set close-on-exec flag on the fd so that child processes will not

      * inherit this fd.

      */

     fcntl(fd, F_SETFD, FD_CLOEXEC);

     sprintf(channelName, "file%d", fd);

 #ifdef SUPPORTS_TTY

     if (!ctl_tty && isatty(fd)) {

 	/*

 	 * Initialize the serial port to a set of sane parameters.

 	 * Especially important if the remote device is set to echo and

 	 * the serial port driver was also set to echo -- as soon as a char

 	 * were sent to the serial port, the remote device would echo it,

 	 * then the serial driver would echo it back to the device, etc.

 	 */

 	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) {

         /* TIP #218. Removed the code inserting the new structure

 	 * into the global list. This is now handled in the thread

 	 * action callbacks, and only there.

 	 */

         fsPtr->nextPtr = NULL;

     }

 #endif /* DEPRECATED */

     fsPtr->validMask = channelPermissions | TCL_EXCEPTION;

     fsPtr->fd = fd;

     fsPtr->channel = Tcl_CreateChannel(channelTypePtr, channelName,

 	    (ClientData) fsPtr, channelPermissions);

     if (translation != NULL) {

 	/*

 	 * Gotcha.  Most modems need a "\r" at the end of the command

 	 * sequence.  If you just send "at\n", the modem will not respond

 	 * with "OK" because it never got a "\r" to actually invoke the

 	 * command.  So, by default, newlines are translated to "\r\n" on

 	 * output to avoid "bug" reports that the serial port isn't working.

 	 */

 	if (Tcl_SetChannelOption(interp, fsPtr->channel, "-translation",

 		translation) != TCL_OK) {

 	    Tcl_Close(NULL, fsPtr->channel);

 	    return NULL;

 	}

     }

     return fsPtr->channel;

 }

 /*

  *----------------------------------------------------------------------

  *

  * Tcl_MakeFileChannel --

  *

  *	Makes a Tcl_Channel from an existing OS level file handle.

  *

  * Results:

  *	The Tcl_Channel created around the preexisting OS level file handle.

  *

  * Side effects:

  *	None.

  *

  *----------------------------------------------------------------------

  */

 EXPORT_C Tcl_Channel

 Tcl_MakeFileChannel(handle, mode)

     ClientData handle;		/* OS level handle. */

     int mode;			/* ORed combination of TCL_READABLE and

 				 * TCL_WRITABLE to indicate file 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;

     }

     /*

      * Look to see if a channel with this fd and the same mode already exists.

      * If the fd is used, but the mode doesn't match, 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;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TcpBlockModeProc --

  *

  *	This procedure is invoked by the generic IO level to set blocking

  *	and nonblocking mode on a TCP socket based channel.

  *

  * Results:

  *	0 if successful, errno when failed.

  *

  * Side effects:

  *	Sets the device into blocking or nonblocking mode.

  *

  *----------------------------------------------------------------------

  */

 	/* ARGSUSED */

 static int

 TcpBlockModeProc(instanceData, mode)

     ClientData instanceData;		/* Socket state. */

     int mode;				/* The mode to set. Can be one of

 					 * TCL_MODE_BLOCKING or

 					 * TCL_MODE_NONBLOCKING. */

 {

     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;

 }

 /*

  *----------------------------------------------------------------------

  *

  * WaitForConnect --

  *

  *	Waits for a connection on an asynchronously opened socket to

  *	be completed.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	The socket is connected after this function returns.

  *

  *----------------------------------------------------------------------

  */

 static int

 WaitForConnect(statePtr, errorCodePtr)

     TcpState *statePtr;		/* State of the socket. */

     int *errorCodePtr;		/* Where to store errors? */

 {

     int timeOut;		/* How long to wait. */

     int state;			/* Of calling TclWaitForFile. */

     int flags;			/* fcntl flags for the socket. */

     /*

      * If an asynchronous connect is in progress, attempt to wait for it

      * to complete before reading.

      */

     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;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TcpInputProc --

  *

  *	This procedure is invoked by the generic IO level to read input

  *	from a TCP socket based channel.

  *

  *	NOTE: We cannot share code with FilePipeInputProc because here

  *	we must use recv to obtain the input from the channel, not read.

  *

  * Results:

  *	The number of bytes read is returned or -1 on error. An output

  *	argument contains the POSIX error code on error, or zero if no

  *	error occurred.

  *

  * Side effects:

  *	Reads input from the input device of the channel.

  *

  *----------------------------------------------------------------------

  */

 	/* ARGSUSED */

 static int

 TcpInputProc(instanceData, buf, bufSize, errorCodePtr)

     ClientData instanceData;		/* Socket state. */

     char *buf;				/* Where to store data read. */

     int bufSize;			/* How much space is available

 					 * in the buffer? */

     int *errorCodePtr;			/* Where to store error code. */

 {

     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) {

 	/*

 	 * Turn ECONNRESET into a soft EOF condition.

 	 */

 	return 0;

     }

     *errorCodePtr = errno;

     return -1;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TcpOutputProc --

  *

  *	This procedure is invoked by the generic IO level to write output

  *	to a TCP socket based channel.

  *

  *	NOTE: We cannot share code with FilePipeOutputProc because here

  *	we must use send, not write, to get reliable error reporting.

  *

  * Results:

  *	The number of bytes written is returned. An output argument is

  *	set to a POSIX error code if an error occurred, or zero.

  *

  * Side effects:

  *	Writes output on the output device of the channel.

  *

  *----------------------------------------------------------------------

  */

 static int

 TcpOutputProc(instanceData, buf, toWrite, errorCodePtr)

     ClientData instanceData;		/* Socket state. */

     CONST char *buf;			/* The data buffer. */

     int toWrite;			/* How many bytes to write? */

     int *errorCodePtr;			/* Where to store error code. */

 {

     TcpState *statePtr = (TcpState *) instanceData;

     int written;

     int state;				/* Of waiting for connection. */

     *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;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TcpCloseProc --

  *

  *	This procedure is invoked by the generic IO level to perform

  *	channel-type-specific cleanup when a TCP socket based channel

  *	is closed.

  *

  * Results:

  *	0 if successful, the value of errno if failed.

  *

  * Side effects:

  *	Closes the socket of the channel.

  *

  *----------------------------------------------------------------------

  */

 	/* ARGSUSED */

 static int

 TcpCloseProc(instanceData, interp)

     ClientData instanceData;	/* The socket to close. */

     Tcl_Interp *interp;		/* For error reporting - unused. */

 {

     TcpState *statePtr = (TcpState *) instanceData;

     int errorCode = 0;

     /*

      * Delete a file handler that may be active for this socket if this

      * is a server socket - the file handler was created automatically

      * by Tcl as part of the mechanism to accept new client connections.

      * Channel handlers are already deleted in the generic IO channel

      * closing code that called this function, so we do not have to

      * delete them here.

      */

     Tcl_DeleteFileHandler(statePtr->fd);

     if (close(statePtr->fd) < 0) {

 	errorCode = errno;

     }

     ckfree((char *) statePtr);

     return errorCode;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TcpGetOptionProc --

  *

  *	Computes an option value for a TCP socket based channel, or a

  *	list of all options and their values.

  *

  *	Note: This code is based on code contributed by John Haxby.

  *

  * Results:

  *	A standard Tcl result. The value of the specified option or a

  *	list of all options and their values is returned in the

  *	supplied DString. Sets Error message if needed.

  *

  * Side effects:

  *	None.

  *

  *----------------------------------------------------------------------

  */

 static int

 TcpGetOptionProc(instanceData, interp, optionName, dsPtr)

     ClientData instanceData;	 /* Socket state. */

     Tcl_Interp *interp;		 /* For error reporting - can be NULL. */

     CONST char *optionName;	 /* Name of the option to

 				  * retrieve the value for, or

 				  * NULL to get all options and

 				  * their values. */

     Tcl_DString *dsPtr;		 /* Where to store the computed

 				  * value; initialized by caller. */

 {

     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;

 	err = 0;

 	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 = TclpGetHostByAddr(			/* INTL: Native. */

 		    (char *) &peername.sin_addr,

 		    sizeof(peername.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));

 		Tcl_DStringFree(&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 {

 	    /*

 	     * getpeername failed - but if we were asked for all the options

 	     * (len==0), don't flag an error at that point because it could

 	     * be an fconfigure request on a server socket. (which have

 	     * no peer). same must be done on win&mac.

 	     */

 	    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 = TclpGetHostByAddr(			/* INTL: Native. */

 		    (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));

 		Tcl_DStringFree(&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;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TcpWatchProc --

  *

  *	Initialize the notifier to watch the fd from this channel.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	Sets up the notifier so that a future event on the channel will

  *	be seen by Tcl.

  *

  *----------------------------------------------------------------------

  */

 static void

 TcpWatchProc(instanceData, mask)

     ClientData instanceData;		/* The socket state. */

     int mask;				/* Events of interest; an OR-ed

 					 * combination of TCL_READABLE,

 					 * TCL_WRITABLE and TCL_EXCEPTION. */

 {

     TcpState *statePtr = (TcpState *) instanceData;

     /*

      * Make sure we don't mess with server sockets since they will never

      * be readable or writable at the Tcl level.  This keeps Tcl scripts

      * from interfering with the -accept behavior.

      */

     if (!statePtr->acceptProc) {

 	if (mask) {

 	    Tcl_CreateFileHandler(statePtr->fd, mask,

 		    (Tcl_FileProc *) Tcl_NotifyChannel,

 		    (ClientData) statePtr->channel);

 	} else {

 	    Tcl_DeleteFileHandler(statePtr->fd);

 	}

     }

 }

 /*

  *----------------------------------------------------------------------

  *

  * TcpGetHandleProc --

  *

  *	Called from Tcl_GetChannelHandle to retrieve OS handles from inside

  *	a TCP socket based channel.

  *

  * Results:

  *	Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if

  *	there is no handle for the specified direction. 

  *

  * Side effects:

  *	None.

  *

  *----------------------------------------------------------------------

  */

 	/* ARGSUSED */

 static int

 TcpGetHandleProc(instanceData, direction, handlePtr)

     ClientData instanceData;	/* The socket state. */

     int direction;		/* Not used. */

     ClientData *handlePtr;	/* Where to store the handle.  */

 {

     TcpState *statePtr = (TcpState *) instanceData;

     *handlePtr = (ClientData)statePtr->fd;

     return TCL_OK;

 }

 /*

  *----------------------------------------------------------------------

  *

  * CreateSocket --

  *

  *	This function opens a new socket in client or server mode

  *	and initializes the TcpState structure.

  *

  * Results:

  *	Returns a new TcpState, or NULL with an error in the interp's

  *	result, if interp is not NULL.

  *

  * Side effects:

  *	Opens a socket.

  *

  *----------------------------------------------------------------------

  */

 static TcpState *

 CreateSocket(interp, port, host, server, myaddr, myport, async)

     Tcl_Interp *interp;		/* For error reporting; can be NULL. */

     int port;			/* Port number to open. */

     CONST char *host;		/* Name of host on which to open port.

 				 * NULL implies INADDR_ANY */

     int server;			/* 1 if socket should be a server socket,

 				 * else 0 for a client socket. */

     CONST char *myaddr;		/* Optional client-side address */

     int myport;			/* Optional client-side port */

     int async;			/* If nonzero and creating a client socket,

 				 * attempt to do an async connect. Otherwise

 				 * do a synchronous connect or bind. */

 {

     int status, sock, asyncConnect, curState, origState;

     struct sockaddr_in sockaddr;	/* socket address */

     struct sockaddr_in mysockaddr;	/* Socket address for client */

     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;

     }

     /*

      * Set the close-on-exec flag so that the socket will not get

      * inherited by child processes.

      */

     fcntl(sock, F_SETFD, FD_CLOEXEC);

     /*

      * Set kernel space buffering

      */

     TclSockMinimumBuffers(sock, SOCKET_BUFSIZE);

     asyncConnect = 0;

     status = 0;

     if (server) {

 	/*

 	 * Set up to reuse server addresses automatically and bind to the

 	 * specified port.

 	 */

 	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;

 	    }

 	}

 	/*

 	 * Attempt to connect. The connect may fail at present with an

 	 * EINPROGRESS but at a later time it will complete. The caller

 	 * will set up a file handler on the socket if she is interested in

 	 * being informed when the connect completes.

 	 */

 	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 {

 		/*

 		 * Here we are if the connect succeeds. In case of an

 		 * asynchronous connect we have to reset the channel to

 		 * blocking mode.  This appears to happen not very often,

 		 * but e.g. on a HP 9000/800 under HP-UX B.11.00 we enter

 		 * this stage. [Bug: 4388]

 		 */

 		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;

     }

     /*

      * Allocate a new TcpState for this socket.

      */

     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;

 }

 /*

  *----------------------------------------------------------------------

  *

  * CreateSocketAddress --

  *

  *	This function initializes a sockaddr structure for a host and port.

  *

  * Results: