/* 
 * tclWinSock.c --
 *
 *	This file contains Windows-specific socket related code.
 *
 * Copyright (c) 1995-1997 Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tclWinSock.c,v 1.10 1999/05/26 20:24:43 redman Exp $
 */

#include "tclWinInt.h"

/*
 * The following variable is used to tell whether this module has been
 * initialized.
 */

static int initialized = 0;

static int  hostnameInitialized = 0;
static char hostname[255];	/* This buffer should be big enough for
                                 * hostname plus domain name. */
static int useThreads = 0;

static HANDLE   socketThread;  /* Thread used with WSAEventSelect to check
				  sockets for fileevents on NT (not used for
				  Win95 or Win98) */
static WSAEVENT socketEvent;   /* Event triggered by WSAEventSelect, for all
				  sockets, NT only */
static WSAEVENT killEvent;     /* Event used to kill off the socketThread, NT
				  only */

static CRITICAL_SECTION socketCS; /* Critical Section used even when building
				     without threads */
TCL_DECLARE_MUTEX(socketMutex)    /* Mutex used when built with multithreading
				   */ 

    
/*
 * The following structure contains pointers to all of the WinSock API entry
 * points used by Tcl.  It is initialized by InitSockets.  Since we
 * dynamically load Winsock.dll on demand, we must use this function table
 * to refer to functions in the socket API.
 */

    int (PASCAL FAR *getsockname)(SOCKET sock, struct sockaddr FAR *name,
            int FAR *namelen);
    int (PASCAL FAR *WSAStartup)(WORD wVersionRequired, LPWSADATA lpWSAData);
    int (PASCAL FAR *WSACleanup)(void);
    int (PASCAL FAR *WSAGetLastError)(void);
    int (PASCAL FAR *WSAAsyncSelect)(SOCKET s, HWND hWnd, u_int wMsg,
	    long lEvent);

    /*
     * The following are used for the WinSock 2.0 for NT implementation
     */

    WSAEVENT (PASCAL FAR *WSACreateEvent)(void);
    BOOL (PASCAL FAR *WSACloseEvent)(WSAEVENT event);
    int (PASCAL FAR *WSAEventSelect)(SOCKET s, WSAEVENT event, long lEvent);
    BOOL (PASCAL FAR *WSAResetEvent)(WSAEVENT event);
    BOOL (PASCAL FAR *WSASetEvent)(WSAEVENT event);
    int (PASCAL FAR *WSAEnumNetworkEvents)(SOCKET s, WSAEVENT event,
	    LPWSANETWORKEVENTS events);
    DWORD (PASCAL FAR *WSAWaitForMultipleEvents)(DWORD cEvents,
	    const WSAEVENT FAR *events, 
	    BOOL fWaitAll, DWORD dwTimeOUT, BOOL fAlertable); 
} winSock;

/*
 * The following defines declare the messages used on socket windows.
 */

#define SOCKET_MESSAGE	WM_USER+1

/*
 * The following defines the timeout value for the WSAWaitForMultipleEvents
 * in milliseconds.
 */

#define TCL_SOCKET_EVENT_TIMEOUT 100

/*
 * The following structure is used to store the data associated with
 * each socket.
 */

typedef struct SocketInfo {
    Tcl_Channel channel;	   /* Channel associated with this socket. */
    SOCKET socket;		   /* Windows SOCKET handle. */
    int flags;			   /* Bit field comprised of the flags
				    * described below.  */
    int watchEvents;		   /* OR'ed combination of FD_READ, FD_WRITE,
                                    * FD_CLOSE, FD_ACCEPT and FD_CONNECT that
				    * indicate which events are interesting. */
    int readyEvents;		   /* OR'ed combination of FD_READ, FD_WRITE,
                                    * FD_CLOSE, FD_ACCEPT and FD_CONNECT that
				    * indicate which events have occurred. Not
				    * used for the WinSock 2.0 for NT
				    * implementation. */
    int selectEvents;		   /* OR'ed combination of FD_READ, FD_WRITE,
                                    * FD_CLOSE, FD_ACCEPT and FD_CONNECT that
				    * indicate which events are currently
				    * being selected. */
    Tcl_TcpAcceptProc *acceptProc; /* Proc to call on accept. */
    ClientData acceptProcData;	   /* The data for the accept proc. */
    int lastError;		   /* Error code from last message. */

#define SOCKET_EOF		(1<<1)	/* A zero read happened on
					 * the socket. */
#define SOCKET_ASYNC_CONNECT	(1<<2)	/* This socket uses async connect. */
#define SOCKET_PENDING		(1<<3)	/* A message has been sent
					 * for this socket */

typedef struct ThreadSpecificData {
    SocketInfo *socketList;     /* List of all sockets in the thread */

    /*
     * Data need for the Win95/Win98 implementation:

     */
    
    HWND hwnd;			/* Handle to window for socket messages. */

    /*
     * Data need for the WinNT implementation:
     */
    
    HANDLE wakeEvent;           /* Event to wake up the socket thread */
    Tcl_ThreadId threadId;     /* ID of the thread */

    struct ThreadSpecificData *next; /* Next entry in the thread list */
} ThreadSpecificData;

ThreadSpecificData *firstWaitingThread; /* List of threads */

static Tcl_ThreadDataKey dataKey;

/*
 * Static functions defined in this file.
 */

static SocketInfo *	CreateSocket _ANSI_ARGS_((Tcl_Interp *interp,

static void		SocketCheckProc _ANSI_ARGS_((ClientData clientData,
			    int flags));
static int		SocketEventProc _ANSI_ARGS_((Tcl_Event *evPtr,
			    int flags));
static void		SocketExitHandler _ANSI_ARGS_((ClientData clientData));
static LRESULT CALLBACK	SocketProc _ANSI_ARGS_((HWND hwnd, UINT message,
			    WPARAM wParam, LPARAM lParam));
static DWORD WINAPI     SocketThread(LPVOID arg);
static void		SocketSetupProc _ANSI_ARGS_((ClientData clientData,
			    int flags));
static void		SocketThreadExitHandler _ANSI_ARGS_((ClientData clientData));
static int		SocketsEnabled _ANSI_ARGS_((void));
static void		TcpAccept _ANSI_ARGS_((SocketInfo *infoPtr));
static int		TcpBlockProc _ANSI_ARGS_((ClientData instanceData,
			    int mode));

/*
 * Define version of Winsock required by Tcl.
 */

#define WSA_VERSION_REQD MAKEWORD(1,1)


/*
 *----------------------------------------------------------------------
 *
 * GetSocketState --
 *
 *	Retrieve the state of a given socket from the winsock API
 *      using WSAEnumNetWorkEvents.  Modify the state appropriately
 *      when the winsock version is wrong.
 *
 *	Assumes Mutex is held.
 *
 * Results:
 *	State of the socket in FD_* masks.
 *
 * Side effects:
 *	Modifies the infoPtr values to reflect the current state.
 *
 *----------------------------------------------------------------------
 */

int GetSocketState(SocketInfo *infoPtr)
{
    WSANETWORKEVENTS netEvents;
    int event = 0;

    if (!useThreads) {
	return infoPtr->readyEvents;
    }
    
    EnterCriticalSection(&socketCS);
    if ((*winSock.WSAEnumNetworkEvents)(infoPtr->socket,
	    socketEvent, &netEvents) == 0) {
	
	event = netEvents.lNetworkEvents;
	
	if (event & FD_CLOSE) {
	    event &= ~(FD_WRITE|FD_ACCEPT);
	}
	if (event & FD_CONNECT) {
	    /*
	     * The socket is now connected, so clear the
	     * async connect flag.
	     */
	    
	    infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
	    
	} 
	if(infoPtr->flags & SOCKET_ASYNC_CONNECT) {
	    infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
	    event |= FD_WRITE;
	}
    }
    LeaveCriticalSection(&socketCS);

    return event;
}

/*
 *----------------------------------------------------------------------
 *
 * InitSockets --
 *
 *	Initialize the socket module.  Attempts to load the wsock32.dll
 *	library and set up the winSock function table.  If successful,
 *	registers the event window for the socket notifier code.


 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Dynamically loads wsock32.dll, and registers a new window
 *	class and creates a window for use in asynchronous socket
 *	notification.
 *
 *----------------------------------------------------------------------
 */

static void
InitSockets()
{
    WSADATA wsaData;
    DWORD id;
    OSVERSIONINFO info;
    static WNDCLASSA class;
    ThreadSpecificData *tsdPtr = 
	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);

    Tcl_MutexLock(&socketMutex);
    if (! initialized) {
	
	InitializeCriticalSection(&socketCS);
	initialized = 1;
	Tcl_CreateExitHandler(SocketExitHandler, (ClientData) NULL);
    
	/*
	 * Find out if we're running on Win32s.
	 */
    
	info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	GetVersionEx(&info);
    
	/*
	 * Check to see if Sockets are supported on this system.
	 *
	 * For WinNT, use the WinSock 2.0 API to avoid creating extra windows
	 * to handle socket events.
	 *
	 * Not all versions of Win95 have WinSock 2.0, don't count on it being
	 * there.  Also, until someone can get the code to work on Win98 or
	 * Win95 with WinSock 2.0, use the window-based version for those
	 * OS's.  Major socket users (servers) will probably be on NT anyway.
	 */
    
	if ((info.dwPlatformId == VER_PLATFORM_WIN32_NT)&&
		(SearchPathA(NULL, "ws2_32", ".dll", 0, NULL, NULL) != 0) ) {
	    useThreads = 1;
	    winSock.hInstance = LoadLibraryA("ws2_32.dll");
	} else if (SearchPathA(NULL, "wsock32", ".dll", 0, NULL, NULL) != 0) {
	    winSock.hInstance = LoadLibraryA("wsock32.dll");
	} else {
	    winSock.hInstance = NULL;
	}
    
	/*
	 * Initialize the function table.
	 */
    
	if (!SocketsEnabled()) {
	    Tcl_MutexUnlock(&socketMutex);
	    return;
	}
    
	winSock.accept = (SOCKET (PASCAL FAR *)(SOCKET s,
		struct sockaddr FAR *addr, int FAR *addrlen))
	    GetProcAddress(winSock.hInstance, "accept");
	winSock.bind = (int (PASCAL FAR *)(SOCKET s,

	winSock.getservbyname = (struct servent FAR * (PASCAL FAR *)
		(const char FAR * name, const char FAR * proto))
	    GetProcAddress(winSock.hInstance, "getservbyname");
	winSock.getsockname = (int (PASCAL FAR *)(SOCKET sock,
		struct sockaddr FAR *name, int FAR *namelen))
	    GetProcAddress(winSock.hInstance, "getsockname");
	winSock.WSAStartup = (int (PASCAL FAR *)(WORD wVersionRequired,
		LPWSADATA lpWSAData)) GetProcAddress(winSock.hInstance,
			"WSAStartup");
	winSock.WSACleanup = (int (PASCAL FAR *)(void))
	    GetProcAddress(winSock.hInstance, "WSACleanup");
	winSock.WSAGetLastError = (int (PASCAL FAR *)(void))
	    GetProcAddress(winSock.hInstance, "WSAGetLastError");
	winSock.WSAAsyncSelect = (int (PASCAL FAR *)(SOCKET s, HWND hWnd,
		u_int wMsg, long lEvent))
	    GetProcAddress(winSock.hInstance, "WSAAsyncSelect");

	if (useThreads) {
	    winSock.WSACreateEvent = (WSAEVENT (PASCAL FAR *)(void))
		GetProcAddress(winSock.hInstance, "WSACreateEvent");
	    winSock.WSACloseEvent = (BOOL (PASCAL FAR *)(WSAEVENT event))
		GetProcAddress(winSock.hInstance, "WSACloseEvent");
	    winSock.WSAEventSelect = (int (PASCAL FAR *)(SOCKET s,
		    WSAEVENT event,
		    long lEvent))
		GetProcAddress(winSock.hInstance, "WSAEventSelect");
	    winSock.WSAResetEvent = (BOOL (PASCAL FAR *)(WSAEVENT event))
		GetProcAddress(winSock.hInstance, "WSAResetEvent");
	    winSock.WSASetEvent = (BOOL (PASCAL FAR *)(WSAEVENT event))
		GetProcAddress(winSock.hInstance, "WSASetEvent");
	    winSock.WSAEnumNetworkEvents = (int (PASCAL FAR *)(SOCKET s,
		    WSAEVENT event,
		    LPWSANETWORKEVENTS events))
		GetProcAddress(winSock.hInstance, "WSAEnumNetworkEvents");
	    winSock.WSAWaitForMultipleEvents =
		(DWORD (PASCAL FAR *)(DWORD cEvents,
			const WSAEVENT FAR *events, 
			BOOL fWaitAll, DWORD dwTimeOUT, BOOL fAlertable))
		GetProcAddress(winSock.hInstance, "WSAWaitForMultipleEvents");
	}	    
	
	/*
	 * Now check that all fields are properly initialized. If not, return
	 * zero to indicate that we failed to initialize properly.
	 */
    
	if ((winSock.hInstance == NULL) ||
		(winSock.accept == NULL) ||

		(winSock.getservbyname == NULL) ||
		(winSock.getsockname == NULL) ||
		(winSock.WSAStartup == NULL) ||
		(winSock.WSACleanup == NULL) ||
		(winSock.WSAGetLastError == NULL) ||
		(winSock.WSAAsyncSelect == NULL)) {
	    goto unloadLibrary;
	} else if (useThreads &&
		((winSock.WSACreateEvent == NULL) ||
			(winSock.WSACloseEvent == NULL) ||
			(winSock.WSAGetLastError == NULL) ||
			(winSock.WSAEventSelect == NULL) ||
			(winSock.WSAResetEvent == NULL) ||
			(winSock.WSASetEvent == NULL) ||
			(winSock.WSAEnumNetworkEvents == NULL) ||
			(winSock.WSAWaitForMultipleEvents == NULL))) {
	    /*
	     * WinSock 2.0 not correctly installed, use 1.x
	     */
	    
	    useThreads = 0;
	}
	
	/*
	 * Create the async notification window with a new class.  We
	 * must create a new class to avoid a Windows 95 bug that causes
	 * us to get the wrong message number for socket events if the
	 * message window is a subclass of a static control.
	 */
	if (!useThreads) {
	    class.style = 0;
	    class.cbClsExtra = 0;
	    class.cbWndExtra = 0;
	    class.hInstance = TclWinGetTclInstance();
	    class.hbrBackground = NULL;
	    class.lpszMenuName = NULL;
	    class.lpszClassName = "TclSocket";
	    class.lpfnWndProc = SocketProc;
	    class.hIcon = NULL;
	    class.hCursor = NULL;
	    
	    if (!RegisterClassA(&class)) {
		TclWinConvertError(GetLastError());
		(*winSock.WSACleanup)();
		goto unloadLibrary;
	    }
	}
	
	/*
	 * Initialize the winsock library and check the version number.
	 */
	
	if ((*winSock.WSAStartup)(WSA_VERSION_REQD, &wsaData) != 0) {
		goto unloadLibrary;
	}
	if (wsaData.wVersion != WSA_VERSION_REQD) {
	    (*winSock.WSACleanup)();
	    goto unloadLibrary;
	}

    	if (useThreads) {
	    socketEvent = (*winSock.WSACreateEvent)();
	    killEvent = (*winSock.WSACreateEvent)();
	    socketThread = CreateThread(NULL, 8000, SocketThread,
		    NULL, 0, &id);
	    SetThreadPriority(socketThread, THREAD_PRIORITY_HIGHEST);
	}	
    }
    Tcl_MutexUnlock(&socketMutex);

    /*
     * Check for per-thread initialization.
     */

    EnterCriticalSection(&socketCS);
    if (tsdPtr == NULL) {
	tsdPtr = TCL_TSD_INIT(&dataKey);
	tsdPtr->socketList = NULL;
    
	if (useThreads) {
	    tsdPtr->wakeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

	} else {
	    tsdPtr->hwnd = CreateWindowA("TclSocket", "TclSocket", 
		    WS_TILED, 0, 0, 0, 0, NULL, NULL, class.hInstance, NULL);

	    if (tsdPtr->hwnd == NULL) {
		FreeLibrary(winSock.hInstance);
		winSock.hInstance = NULL;
		LeaveCriticalSection(&socketCS);
		return;
	    }
	}
	    
	Tcl_CreateEventSource(SocketSetupProc, SocketCheckProc, NULL);
	Tcl_CreateThreadExitHandler(SocketThreadExitHandler, NULL);

	tsdPtr->threadId = Tcl_GetCurrentThread();
	tsdPtr->next = firstWaitingThread;
	firstWaitingThread = tsdPtr;

    }
    LeaveCriticalSection(&socketCS);
    return;

unloadLibrary:
    FreeLibrary(winSock.hInstance);
    winSock.hInstance = NULL;
    Tcl_MutexUnlock(&socketMutex);
    return;
}

/*
 *----------------------------------------------------------------------
 *
 * SocketsEnabled --

 */

    /* ARGSUSED */
static int
SocketsEnabled()
{
    int enabled;
    EnterCriticalSection(&socketCS);
    enabled = (winSock.hInstance != NULL);
    LeaveCriticalSection(&socketCS);
    return enabled;
}


/*
 *----------------------------------------------------------------------
 *

 */

    /* ARGSUSED */
static void
SocketExitHandler(clientData)
    ClientData clientData;              /* Not used. */
{
    EnterCriticalSection(&socketCS);
    if (useThreads && (socketThread != NULL)) {
	LeaveCriticalSection(&socketCS);
	(*winSock.WSASetEvent)(killEvent);
	WaitForSingleObject(socketThread, INFINITE);
	EnterCriticalSection(&socketCS);
	CloseHandle(socketThread);
	(*winSock.WSACloseEvent)(killEvent);
	(*winSock.WSACloseEvent)(socketEvent);
    }
    if (winSock.hInstance) {
	if (!useThreads) {
	    UnregisterClassA("TclSocket", TclWinGetTclInstance());
	}
	(*winSock.WSACleanup)();
	FreeLibrary(winSock.hInstance);
	winSock.hInstance = NULL;
    }
    initialized = 0;
    hostnameInitialized = 0;
    LeaveCriticalSection(&socketCS);
}

/*
 *----------------------------------------------------------------------
 *
 * SocketThreadExitHandler --
 *

 */

    /* ARGSUSED */
static void
SocketThreadExitHandler(clientData)
    ClientData clientData;              /* Not used. */
{
    ThreadSpecificData *tsdPtr, *nextPtr;

    tsdPtr = (ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);

    if (useThreads) {
	EnterCriticalSection(&socketCS);
	CloseHandle(tsdPtr->wakeEvent);
	
	if (firstWaitingThread == tsdPtr) {
	    firstWaitingThread = tsdPtr->next;
	} else {
	    for (nextPtr = firstWaitingThread;
		 nextPtr != NULL;
		 nextPtr = nextPtr->next) {
		
		if (nextPtr->next == tsdPtr) {
		    nextPtr->next = tsdPtr->next;
		    break;
		}
	    }
	}
	LeaveCriticalSection(&socketCS);
    } else {
	DestroyWindow(tsdPtr->hwnd);
    }

    Tcl_DeleteEventSource(SocketSetupProc, SocketCheckProc, NULL);
}

/*
 *----------------------------------------------------------------------
 *

 *----------------------------------------------------------------------
 */

int
TclpHasSockets(interp)
    Tcl_Interp *interp;
{

    InitSockets();


    if (SocketsEnabled()) {
	return TCL_OK;
    }
    if (interp != NULL) {
	Tcl_AppendResult(interp, "sockets are not available on this system",
		NULL);

SocketSetupProc(data, flags)
    ClientData data;		/* Not used. */
    int flags;			/* Event flags as passed to Tcl_DoOneEvent. */
{
    SocketInfo *infoPtr;
    Tcl_Time blockTime = { 0, 0 };
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    int readyEvents;
    
    if (!(flags & TCL_FILE_EVENTS)) {
	return;
    }
    
    /*
     * Check to see if there is a ready socket.  If so, poll.
     */

    EnterCriticalSection(&socketCS);
    for (infoPtr = tsdPtr->socketList; infoPtr != NULL; 
	    infoPtr = infoPtr->nextPtr) {
	readyEvents = GetSocketState(infoPtr);
	if (readyEvents & infoPtr->watchEvents) {
	    Tcl_SetMaxBlockTime(&blockTime);
	    break;
	}
    }
    LeaveCriticalSection(&socketCS);
}

/*
 *----------------------------------------------------------------------
 *
 * SocketCheckProc --
 *

 */

static void
SocketCheckProc(data, flags)
    ClientData data;		/* Not used. */
    int flags;			/* Event flags as passed to Tcl_DoOneEvent. */
{
    int readyEvents;
    SocketInfo *infoPtr;
    SocketEvent *evPtr;
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    
    if (!(flags & TCL_FILE_EVENTS)) {
	return;
    }
    
    /*
     * Queue events for any ready sockets that don't already have events
     * queued (caused by persistent states that won't generate WinSock
     * events).
     */

    EnterCriticalSection(&socketCS);
    for (infoPtr = tsdPtr->socketList; infoPtr != NULL; 
	    infoPtr = infoPtr->nextPtr) {
	readyEvents = GetSocketState(infoPtr);
	if ((readyEvents & infoPtr->watchEvents)
		&& !(infoPtr->flags & SOCKET_PENDING)) {
	    infoPtr->flags |= SOCKET_PENDING;
	    evPtr = (SocketEvent *) ckalloc(sizeof(SocketEvent));
	    evPtr->header.proc = SocketEventProc;
	    evPtr->socket = infoPtr->socket;
	    LeaveCriticalSection(&socketCS);
	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
	    EnterCriticalSection(&socketCS);
	}
    }
    LeaveCriticalSection(&socketCS);
}

/*
 *----------------------------------------------------------------------
 *
 * SocketEventProc --
 *

    int flags;			/* Flags that indicate what events to
				 * handle, such as TCL_FILE_EVENTS. */
{
    SocketInfo *infoPtr;
    SocketEvent *eventPtr = (SocketEvent *) evPtr;
    int mask = 0;
    int events;
    int readyEvents;
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    if (!(flags & TCL_FILE_EVENTS)) {
	return 0;
    }

    /*
     * Find the specified socket on the socket list.
     */

    EnterCriticalSection(&socketCS);
    for (infoPtr = tsdPtr->socketList; infoPtr != NULL; 
	    infoPtr = infoPtr->nextPtr) {
	if (infoPtr->socket == eventPtr->socket) {
	    break;
	}
    }
    LeaveCriticalSection(&socketCS);

    /*
     * Discard events that have gone stale.
     */

    if (!infoPtr) {
	return 1;
    }

    infoPtr->flags &= ~SOCKET_PENDING;

    /*
     * Handle connection requests directly.
     */

    readyEvents = GetSocketState(infoPtr);
    if (readyEvents & FD_ACCEPT) {
	TcpAccept(infoPtr);
	return 1;
    }


    /*
     * Mask off unwanted events and compute the read/write mask so 
     * we can notify the channel.
     */

    events = readyEvents & infoPtr->watchEvents;

    if (events & FD_CLOSE) {
	/*
	 * If the socket was closed and the channel is still interested
	 * in read events, then we need to ensure that we keep polling
	 * for this event until someone does something with the channel.
	 * Note that we do this before calling Tcl_NotifyChannel so we don't

	 * We must check to see if data is really available, since someone
	 * could have consumed the data in the meantime.  Turn off async
	 * notification so select will work correctly.	If the socket is
	 * still readable, notify the channel driver, otherwise reset the
	 * async select handler and keep waiting.
	 */

	if (!useThreads) {
	    (void) (*winSock.WSAAsyncSelect)(infoPtr->socket,
		    tsdPtr->hwnd, 0, 0);
	}
	
	FD_ZERO(&readFds);
	FD_SET(infoPtr->socket, &readFds);
	timeout.tv_usec = 0;
	timeout.tv_sec = 0;
 
	if ((*winSock.select)(0, &readFds, NULL, NULL, &timeout) != 0) {
	    mask |= TCL_READABLE;
	} else if (!useThreads) {
	    (void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd,
		    SOCKET_MESSAGE, infoPtr->selectEvents);
	}
	infoPtr->readyEvents &= ~(FD_READ);

    }
    if (events & (FD_WRITE | FD_CONNECT)) {
	mask |= TCL_WRITABLE;
    }

    if (mask) {
	Tcl_NotifyChannel(infoPtr->channel, mask);

        }
    }

    /*
     * Remove the socket from socketList.
     */

    EnterCriticalSection(&socketCS);
    for (nextPtrPtr = &(tsdPtr->socketList); (*nextPtrPtr) != NULL;
	 nextPtrPtr = &((*nextPtrPtr)->nextPtr)) {
	if ((*nextPtrPtr) == infoPtr) {
	    (*nextPtrPtr) = infoPtr->nextPtr;
	    break;
	}
    }
    LeaveCriticalSection(&socketCS);

    ckfree((char *) infoPtr);
    return errorCode;
}

/*
 *----------------------------------------------------------------------

    infoPtr->flags = 0;
    infoPtr->watchEvents = 0;
    infoPtr->readyEvents = 0;
    infoPtr->selectEvents = 0;
    infoPtr->acceptProc = NULL;
    infoPtr->lastError = 0;

    EnterCriticalSection(&socketCS);
    infoPtr->nextPtr = tsdPtr->socketList;
    tsdPtr->socketList = infoPtr;
    LeaveCriticalSection(&socketCS);

    return infoPtr;
}

/*
 *----------------------------------------------------------------------
 *

	infoPtr = NewSocketInfo(sock);

	/*
	 * Set up the select mask for connection request events.
	 */

	EnterCriticalSection(&socketCS);
	infoPtr->selectEvents = FD_ACCEPT;
	infoPtr->watchEvents |= FD_ACCEPT;
	LeaveCriticalSection(&socketCS);

    } else {

        /*
         * Try to bind to a local port, if specified.
         */
        

	infoPtr = NewSocketInfo(sock);

	/*
	 * Set up the select mask for read/write events.  If the connect
	 * attempt has not completed, include connect events.
	 */

	EnterCriticalSection(&socketCS);
	infoPtr->selectEvents = FD_READ | FD_WRITE | FD_CLOSE;
	if (asyncConnect) {
	    infoPtr->flags |= SOCKET_ASYNC_CONNECT;
	    infoPtr->selectEvents |= FD_CONNECT;
	}
	LeaveCriticalSection(&socketCS);
    }

    /*
     * Register for interest in events in the select mask.  Note that this
     * automatically places the socket into non-blocking mode.
     */

    if (useThreads) {
	(void) (*winSock.WSAEventSelect)(infoPtr->socket, socketEvent,
		infoPtr->selectEvents);
    } else {
	(*winSock.ioctlsocket)(sock, FIONBIO, &flag);
	(void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd,
		SOCKET_MESSAGE, infoPtr->selectEvents);
    }
    
    return infoPtr;

error:
    TclWinConvertWSAError((*winSock.WSAGetLastError)());
    if (interp != NULL) {
	Tcl_AppendResult(interp, "couldn't open socket: ",
		Tcl_PosixError(interp), (char *) NULL);

static int
WaitForSocketEvent(infoPtr, events, errorCodePtr)
    SocketInfo *infoPtr;	/* Information about this socket. */
    int events;			/* Events to look for. */
    int *errorCodePtr;		/* Where to store errors? */
{
    MSG msg;
    int readyEvents;
    int result = 1;
    int oldMode;
    ThreadSpecificData *tsdPtr = 
	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);

    /*
     * Be sure to disable event servicing so we are truly modal.
     */
    
    oldMode = Tcl_SetServiceMode(TCL_SERVICE_NONE);
	
    if (useThreads) {

	while (1) {
	    readyEvents = GetSocketState(infoPtr);
	    if (infoPtr->lastError) {
		*errorCodePtr = infoPtr->lastError;
		result = 0;
		break;
	    } else if (readyEvents & events) {
		break;
	    } else if (infoPtr->flags & SOCKET_ASYNC) {
		*errorCodePtr = EWOULDBLOCK;
		result = 0;
		break;
	    }
	    WaitForSingleObject(tsdPtr->wakeEvent, 100);
//	    Tcl_ServiceAll();
	}
    } else {
	
	/*
	 * Reset WSAAsyncSelect so we have a fresh set of events pending.
	 */

	(void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd, 0, 0);
	(void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd,
		SOCKET_MESSAGE, infoPtr->selectEvents);

	while (1) {
	    /*
	     * Process all outstanding messages on the socket window.
	     */
	    
	    while (PeekMessage(&msg, tsdPtr->hwnd, 0, 0, PM_REMOVE)) {
		DispatchMessage(&msg);
	    }
	    
	    if (infoPtr->lastError) {
		*errorCodePtr = infoPtr->lastError;
		result = 0;
		break;
	    } else if (infoPtr->readyEvents & events) {
		break;
	    } else if (infoPtr->flags & SOCKET_ASYNC) {
		*errorCodePtr = EWOULDBLOCK;
		result = 0;
		break;
	    }
	    
	    /*
	     * Wait until something happens.
	     */
	    
	    WaitMessage();
	}
    }
    (void) Tcl_SetServiceMode(oldMode);


    return result;
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_OpenTcpClient --

     * Set kernel space buffering and non-blocking.
     */

    TclSockMinimumBuffers((SOCKET) sock, TCP_BUFFER_SIZE);

    infoPtr = NewSocketInfo((SOCKET) sock);

    if (infoPtr == NULL) {
	return NULL;
    }
    
    /*
     * Start watching for read/write events on the socket.
     */

    infoPtr->selectEvents = FD_READ | FD_CLOSE | FD_WRITE;

    if (useThreads) {
	(void) (*winSock.WSAEventSelect)(infoPtr->socket, socketEvent,
		infoPtr->selectEvents);
    } else {
	(void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd,
		SOCKET_MESSAGE, infoPtr->selectEvents);
    }
    
    wsprintfA(channelName, "sock%d", infoPtr->socket);
    infoPtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
	    (ClientData) infoPtr, (TCL_READABLE | TCL_WRITABLE));
    Tcl_SetChannelOption(NULL, infoPtr->channel, "-translation", "auto crlf");
    return infoPtr->channel;
}


    /*
     * Clear the ready mask so we can detect the next connection request.
     * Note that connection requests are level triggered, so if there is
     * a request already pending, a new event will be generated.
     */

    infoPtr->readyEvents &= ~(FD_ACCEPT);
    
    if (newSocket == INVALID_SOCKET) {
        return;
    }

    /*
     * Win-NT has a misfeature that sockets are inherited in child
     * processes by default.  Turn off the inherit bit.

    newInfoPtr = NewSocketInfo(newSocket);

    /*
     * Select on read/write events and create the channel.
     */

    newInfoPtr->selectEvents = (FD_READ | FD_WRITE | FD_CLOSE);
    if (useThreads) {
	(void) (*winSock.WSAEventSelect)(newInfoPtr->socket, socketEvent, 
		newInfoPtr->selectEvents);
    } else {
	(void) (*winSock.WSAAsyncSelect)(newInfoPtr->socket, tsdPtr->hwnd, 
		SOCKET_MESSAGE, newInfoPtr->selectEvents);
    }
    
    wsprintfA(channelName, "sock%d", newInfoPtr->socket);
    newInfoPtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
	    (ClientData) newInfoPtr, (TCL_READABLE | TCL_WRITABLE));
    if (Tcl_SetChannelOption(NULL, newInfoPtr->channel, "-translation",
	    "auto crlf") == TCL_ERROR) {
        Tcl_Close((Tcl_Interp *) NULL, newInfoPtr->channel);
        return;

    char *buf;				/* Where to store data. */
    int toRead;				/* Maximum number of bytes to read. */
    int *errorCodePtr;			/* Where to store error codes. */
{
    SocketInfo *infoPtr = (SocketInfo *) instanceData;
    int bytesRead;
    int error;
    int readyEvents;
    ThreadSpecificData *tsdPtr = 
	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
    
    *errorCodePtr = 0;

    /*
     * Check that WinSock is initialized; do not call it if not, to

    if (infoPtr->flags & SOCKET_EOF) {
	return 0;
    }

    /*
     * Check to see if the socket is connected before trying to read.
     */
    infoPtr->selectEvents |= FD_READ | FD_CLOSE;

    if (useThreads) {
	(void) (*winSock.WSAEventSelect)(infoPtr->socket, socketEvent,
		infoPtr->selectEvents);
    }	
    
    if ((infoPtr->flags & SOCKET_ASYNC_CONNECT)
	    && ! WaitForSocketEvent(infoPtr,  FD_CONNECT, errorCodePtr)) {
	return -1;
    }
    
    /*
     * No EOF, and it is connected, so try to read more from the socket.
     * Note that we clear the FD_READ bit because read events are level
     * triggered so a new event will be generated if there is still data
     * available to be read.  We have to simulate blocking behavior here
     * since we are always using non-blocking sockets.
     */

    while (1) {

	if (!useThreads) {
	    (void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd,
		    0, 0);
	}
	bytesRead = (*winSock.recv)(infoPtr->socket, buf, toRead, 0);

	infoPtr->readyEvents &= ~(FD_READ);
	
	/*
	 * Check for end-of-file condition or successful read.
	 */
  
	if (bytesRead == 0) {
	    infoPtr->flags |= SOCKET_EOF;
	}
	if (bytesRead != SOCKET_ERROR) {
	    break;
	}
  
	/*
	 * If an error occurs after the FD_CLOSE has arrived,
	 * then ignore the error and report an EOF.
	 */
	readyEvents = GetSocketState(infoPtr);
	
	if (readyEvents & FD_CLOSE) {
	    infoPtr->flags |= SOCKET_EOF;
	    bytesRead = 0;
	    break;
	}
  
	/*
	 * Check for error condition or underflow in non-blocking case.
	 */
  
	error = (*winSock.WSAGetLastError)();
	if ((error != 0) && ((infoPtr->flags & SOCKET_ASYNC)
		|| (error != WSAEWOULDBLOCK))) {
	    TclWinConvertWSAError(error);
	    *errorCodePtr = Tcl_GetErrno();
	    bytesRead = -1;
	    break;
	}

	/*
	 * In the blocking case, wait until the file becomes readable
	 * or closed and try again.
	 */

	if (!WaitForSocketEvent(infoPtr, FD_READ|FD_CLOSE, errorCodePtr)) {
	    bytesRead = -1;
	    break;
  	}
    }

    if (!useThreads) {
	(void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd,
		SOCKET_MESSAGE, infoPtr->selectEvents);
    }
    return bytesRead;
}

/*
 *----------------------------------------------------------------------
 *
 * TcpOutputProc --

    
    if ((infoPtr->flags & SOCKET_ASYNC_CONNECT)
	    && ! WaitForSocketEvent(infoPtr,  FD_CONNECT, errorCodePtr)) {
	return -1;
    }

    while (1) {
	if (!useThreads) {
	    (void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd,
		    0, 0);
	}
	
	bytesWritten = (*winSock.send)(infoPtr->socket, buf, toWrite, 0);
	if (bytesWritten != SOCKET_ERROR) {
	    if (!useThreads && (infoPtr->watchEvents & FD_WRITE)) {
		/*
		 * Since Windows won't generate a new write event until we hit
		 * an overflow condition, we need to force the event loop to
		 * poll until the condition changes.
		 */


		Tcl_Time blockTime = { 0, 0 };
		Tcl_SetMaxBlockTime(&blockTime);
	    }
	    break;
	}
	
	/*
	 * Check for error condition or overflow.  In the event of overflow, we
	 * need to clear the FD_WRITE flag so we can detect the next writable
	 * event.  Note that Windows only sends a new writable event after a
	 * send fails with WSAEWOULDBLOCK.
	 */

	error = (*winSock.WSAGetLastError)();

	if (error == WSAEWOULDBLOCK) {
	    infoPtr->readyEvents &= ~(FD_WRITE);
	    if (infoPtr->flags & SOCKET_ASYNC) {
		*errorCodePtr = EWOULDBLOCK;
		bytesWritten = -1;
		break;
	    } 

	if (!WaitForSocketEvent(infoPtr, FD_WRITE|FD_CLOSE, errorCodePtr)) {
	    bytesWritten = -1;
	    break;
	}
    }

    if (!useThreads) {
	(void) (*winSock.WSAAsyncSelect)(infoPtr->socket, tsdPtr->hwnd,
		SOCKET_MESSAGE, infoPtr->selectEvents);
    }
    return bytesWritten;
}

/*
 *----------------------------------------------------------------------
 *
 * TcpGetOptionProc --

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. */
{
    int readyEvents;
    SocketInfo *infoPtr = (SocketInfo *) instanceData;
    
    /*
     * Update the watch events mask.
     */

    EnterCriticalSection(&socketCS);
    infoPtr->watchEvents = 0;
    if (mask & TCL_READABLE) {
	infoPtr->watchEvents |= (FD_READ|FD_CLOSE|FD_ACCEPT);
    }
    if (mask & TCL_WRITABLE) {
	infoPtr->watchEvents |= (FD_WRITE|FD_CONNECT);
    }
    LeaveCriticalSection(&socketCS);

    /*
     * If there are any conditions already set, then tell the notifier to poll
     * rather than block.
     */

    readyEvents = GetSocketState(infoPtr);
    if (readyEvents & infoPtr->watchEvents) {
	Tcl_Time blockTime = { 0, 0 };
	Tcl_SetMaxBlockTime(&blockTime);
    }		
}

/*
 *----------------------------------------------------------------------

    ClientData *handlePtr;	/* Where to store the handle.  */
{
    SocketInfo *statePtr = (SocketInfo *) instanceData;

    *handlePtr = (ClientData) statePtr->socket;
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * SocketThread --
 *
 *      Use a separate thread to check state for the sockets in each
 *      thread.  Using a window isn't the best way, especially if the
 *      WinSock2 API is available and working.  Also, creating N threads
 *      per socket like the pipe, console, and serial drivers isn't
 *      very efficient.  Currently, all sockets are tied to one event.
 *      The overhead involved in creating an event for each socket is
 *      a concern.  But, in order to avoid deadlocks, the call to
 *      WSAWaitForMultipleEvents() needs to timeout to check for
 *      status changes which haven't been handled (race condition).
 *
 * Results:
 *	0 on success.
 *
 * Side effects:
 *
 *----------------------------------------------------------------------
 */

static DWORD WINAPI
SocketThread(LPVOID arg)
{
    SocketInfo *infoPtr;
    WSAEVENT events[2];
    ThreadSpecificData *tsdPtr;
    DWORD result;
		
    /*
     * Find the specified socket on the socket list and update its
     * eventState flag.
     */

    events[0] = killEvent;
    events[1] = socketEvent;
    
    while (1) {

	result = (*winSock.WSAWaitForMultipleEvents)(2, events, FALSE,
		TCL_SOCKET_EVENT_TIMEOUT, FALSE);

	switch (result) {
	    case WSA_WAIT_TIMEOUT:
	    case (WSA_WAIT_EVENT_0 +1):

		/*
		 * A socket event has fired, determine which socket(s) it was
		 * and which thread(s) it came from.
		 */

		EnterCriticalSection(&socketCS);
		for (tsdPtr = firstWaitingThread; tsdPtr != NULL;
		     tsdPtr = tsdPtr->next) {
		    
		    for (infoPtr = tsdPtr->socketList; infoPtr != NULL; 
			 infoPtr = infoPtr->nextPtr) {
			
			if (GetSocketState(infoPtr) & infoPtr->watchEvents) {
			    Tcl_ThreadAlert(tsdPtr->threadId);
			    SetEvent(tsdPtr->wakeEvent);
			}
		    }
		}
		LeaveCriticalSection(&socketCS);
		(*winSock.WSAResetEvent)(socketEvent);
		break;

	    case WSA_WAIT_EVENT_0:
		/*
		 * This thread is supposed to kill itself off
		 */

		return 0;
		break;
		
	    default:
		/*
		 * The thread has detected a fatal error
		 */
		
		return 1;
		break;
	}
    }

    return 0;
}

/*
 *----------------------------------------------------------------------
 *
 * SocketProc --
 *
 *	This function is called when WSAAsyncSelect has been used