#define SOCKET_ASYNC		(1<<0)	/* The socket is in blocking mode. */
#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 */
#define SOCKET_HSENT		(1<<5)	/* Socket had already sent data. */
#define SOCKET_HRECV		(1<<6)	/* Socket had already received data. */

typedef struct {
    HWND hwnd;			/* Handle to window for socket messages. */
    HANDLE socketThread;	/* Thread handling the window */
    Tcl_ThreadId threadId;	/* Parent thread. */
    HANDLE readyEvent;		/* Event indicating that a socket event is
				 * ready. Also used to indicate that the

     * WinSock ran before other exit handlers that want to use sockets.
     */

    if (SocketsEnabled()) {
	/*
	 * Clean up the OS socket handle. The default Windows setting for a
	 * socket is SO_DONTLINGER, which does a graceful shutdown in the
	 * background.
	 * background, this can cause a flood with pending sockets in TIME_WAIT
	 * state, so can result to exceeding of FD_SETSIZE, etc
	 * (see bug [b6d0d8cc2c]). So try do a graceful disconnect manually,
	 * if success don't linger otherwise lingering for 5 seconds, that should be
	 * enough per default to fullfil a shutdown (flush buffers etc).
	 * The port can remain longer in TIME_WAIT state, but windows could
	 * probably use it earlier in out of sockets situation.
	 */

	SOCKET s = infoPtr->socket;
	LINGER l;
	l.l_linger = 5; /* 0 would cause a hard reset, so use carefully */

	/* if server socket - simply close it */
	if (infoPtr->acceptProc) {
	    goto closeSocket;
	}
	/* if nothing was sent through this connection - execute a reset */
	if (!(infoPtr->flags & (SOCKET_HSENT|SOCKET_HRECV))) {
	    l.l_linger = 0; /* hard reset */
	    goto lingerSocket;
	}

	/* If FD_CLOSE has been not yet received */
	infoPtr->flags &= ~SOCKET_EOF;
	infoPtr->flags |= (infoPtr->readyEvents & FD_CLOSE) ? SOCKET_EOF : 0;
	if (!(infoPtr->flags & SOCKET_EOF)) {

	    WSAEVENT eventObj = WSACreateEvent();
	    int fdWrite = 0;

	    /* We'll made an attempt of graceful disconnect (if possible).
	     * Thereby FD_WRITE signaling that we'd avoid immediate disconnect. */
	    if ((infoPtr->flags & SOCKET_HSENT) && (infoPtr->readyEvents & FD_WRITE)) {
		fdWrite = FD_WRITE;
	    }
	    if (
		   WSAEventSelect(s, eventObj, (FD_CLOSE|fdWrite)) != SOCKET_ERROR
		&& (fdWrite || WSASendDisconnect(s, NULL) != SOCKET_ERROR)
	    ) {
		/* Wait a bit (1ms) for FD_CLOSE gets signalled (e. g. fast
		 * (local) connect or already pending FIN/RST from other peer) */
		while (WSAWaitForMultipleEvents(1, &eventObj, 0, 1, 0)
			== WSA_WAIT_EVENT_0
		) {

		    WSANETWORKEVENTS evv;
		    if (WSAEnumNetworkEvents(s, eventObj, &evv) == 0) {

			if (evv.lNetworkEvents & FD_CLOSE) {
			    infoPtr->flags |= SOCKET_EOF;
			    break;
			}
			if (fdWrite) {
			    /* send disconnect now (and reset it to stop repeat) */
			    fdWrite &= ~FD_WRITE;
			    /* don't need write anymore - send disconnect and repeat */
			    if (WSASendDisconnect(s, NULL) != SOCKET_ERROR) {
				continue;
			    }
			}
		    }
		    break;
		}
		(void) WSAEventSelect(s, NULL, 0);
	    }
	    WSACloseEvent(eventObj);
	}

	/* If attempt succeeded (noticed FD_CLOSE) */
	if (  (infoPtr->flags & SOCKET_EOF) 
	  || !(infoPtr->flags & SOCKET_HSENT)
	) { /* don't need lingering. */
	    int v = 0; /* the socket will not remain open */
	    setsockopt(s, SOL_SOCKET, SO_DONTLINGER,
			(const char *) &v, sizeof(v));
	} else {
lingerSocket:
	    l.l_onoff = 1; /* the socket will remain open for l_linger time */
	    setsockopt(s, SOL_SOCKET, SO_LINGER,
			(const char *) &l, sizeof(l));
	}

closeSocket:
	/* Now close it. */
	if (closesocket(infoPtr->socket) == SOCKET_ERROR) {
	if (closesocket(s) == SOCKET_ERROR) {
	    TclWinConvertWSAError((DWORD) WSAGetLastError());
	    errorCode = Tcl_GetErrno();
	}
    }

    /*
     * Clear an eventual tsd info list pointer.
     * This may be called, if an async socket connect fails or is closed
     * between connect and thread action callback.
     */
    if (tsdPtr->pendingSocketInfo != NULL
    if (tsdPtr->pendingSocketInfo == infoPtr) {
	    && tsdPtr->pendingSocketInfo == infoPtr) {

	/* get infoPtr lock, because this concerns the notifier thread */
	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);

	tsdPtr->pendingSocketInfo = NULL;

	/* Free list lock */

                (LPARAM) infoPtr);
    
        SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM) SELECT,
                (LPARAM) infoPtr);
    }

    while (1) {
	int rc;

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

	WaitForSingleObject(tsdPtr->readyEvent, INFINITE);
	rc = WaitForSingleObject(tsdPtr->readyEvent, INFINITE);
	if (rc) {
#if 0
	    if (rc == WAIT_TIMEOUT) {
		*errorCodePtr = ETIMEDOUT;
		result = 0;
		break;
	    }
#endif
	    if (rc == WAIT_FAILED) {
		TclWinConvertError(GetLastError());
		*errorCodePtr = infoPtr->lastError = errno;
		result = 0;
		break;
	    }
	}
    }

    (void) Tcl_SetServiceMode(oldMode);
    return result;
}

/*

	bytesRead = 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) {
	    infoPtr->flags |= (bytesRead == 0) ? SOCKET_EOF : SOCKET_HRECV;
	}
	if (bytesRead != SOCKET_ERROR) {
	    break;
	}

	/*
	 * If an error occurs after the FD_CLOSE has arrived, then ignore the
	 * error and report an EOF.
	 */

    while (1) {
	SendMessage(tsdPtr->hwnd, SOCKET_SELECT,
		(WPARAM) UNSELECT, (LPARAM) infoPtr);

	bytesWritten = send(infoPtr->socket, buf, toWrite, 0);
	if (bytesWritten != SOCKET_ERROR) {
	    /* Signal data sent to peer */
	    infoPtr->flags |= toWrite ? SOCKET_HSENT : 0;
	    /*
	     * 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.
	     */

	    if (infoPtr->watchEvents & FD_WRITE) {

	 * Check if there is a pending info structure not jet in the
	 * list
	 */
	if ( !info_found
		&& tsdPtr->pendingSocketInfo != NULL
		&& tsdPtr->pendingSocketInfo->socket ==socket ) {
	    infoPtr = tsdPtr->pendingSocketInfo;
	    tsdPtr->pendingSocketInfo = NULL;
	    info_found = 1;
	}
	if (info_found) {

	    /*
	     * Update the socket state.
	     *