*
 *   (Ad 2) The main functions for this are SocketSetupProc() and
 *          SocketCheckProc().
 */

#include "tclWinInt.h"

//#define DEBUGGING
//#ifdef DEBUGGING
#define DEBUG(x) fprintf(stderr, ">>> %p %s(%d): %s<<<\n", \
			    infoPtr, __FUNCTION__, __LINE__, x)
#else
#define DEBUG(x)
#endif

/*

    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
				 * socketThread has been initialized and has
				 * started. */
    HANDLE socketListLock;	/* Win32 Event to lock the socketList */
    SocketInfo *pendingSocketInfo;
				/* This socket is opened but not jet in the
				 * list. This value is also checked by
				 * the event structure. */
    SocketInfo *socketList;	/* Every open socket in this thread has an
				 * entry on this list. */
} ThreadSpecificData;

static Tcl_ThreadDataKey dataKey;
static WNDCLASS windowClass;

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

static int		CreateClientSocket(Tcl_Interp *interp, SocketInfo *infoPtr);
static void		InitSockets(void);
static SocketInfo *	NewSocketInfo(SOCKET socket);
static void		SocketExitHandler(ClientData clientData);
static LRESULT CALLBACK	SocketProc(HWND hwnd, UINT message, WPARAM wParam,
			    LPARAM lParam);
static int		SocketsEnabled(void);
static void		TcpAccept(TcpFdList *fds, SOCKET newSocket, address addr);
static int		WaitForConnect(SocketInfo *infoPtr, int *errorCodePtr);
static int		WaitForSocketEvent(SocketInfo *infoPtr, int events,
			    int *errorCodePtr);
static int		FindFDInList(SocketInfo *infoPtr, SOCKET socket);
static DWORD WINAPI	SocketThread(LPVOID arg);
static void		TcpThreadActionProc(ClientData instanceData,
			    int action);

static Tcl_EventCheckProc	SocketCheckProc;
static Tcl_EventProc		SocketEventProc;
static Tcl_EventSetupProc	SocketSetupProc;

    /*
     * OK, this thread has never done anything with sockets before.  Construct
     * a worker thread to handle asynchronous events related to sockets
     * assigned to _this_ thread.
     */

    tsdPtr = TCL_TSD_INIT(&dataKey);
    tsdPtr->pendingSocketInfo = NULL;
    tsdPtr->socketList = NULL;
    tsdPtr->hwnd       = NULL;
    tsdPtr->threadId   = Tcl_GetCurrentThread();
    tsdPtr->readyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (tsdPtr->readyEvent == NULL) {
	goto initFailure;
    }

     * queued (caused by persistent states that won't generate WinSock
     * events).
     */

    WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
    for (infoPtr = tsdPtr->socketList; infoPtr != NULL;
	    infoPtr = infoPtr->nextPtr) {
	DEBUG("Socket loop");
	if ((infoPtr->readyEvents &
		(infoPtr->watchEvents | FD_CONNECT | FD_ACCEPT))
	    && !(infoPtr->flags & SOCKET_PENDING)
	) {
	    DEBUG("Event found");
	    infoPtr->flags |= SOCKET_PENDING;
	    evPtr = ckalloc(sizeof(SocketEvent));
	    evPtr->header.proc = SocketEventProc;
	    evPtr->socket = infoPtr->sockets->fd;
	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
	}
    }

	    if (bind(infoPtr->sockets->fd, infoPtr->myaddr->ai_addr,
			infoPtr->myaddr->ai_addrlen) == SOCKET_ERROR) {
		DEBUG("bind() failed");
		TclWinConvertError((DWORD) WSAGetLastError());
		continue;
	    }
	    /*
	     * For asyncroneous connect set the socket in nonblocking mode
	     * and activate connect notification
	     */
	    if (async_connect) {
		SocketInfo *infoPtr2;
		int in_socket_list = 0;
		/* get infoPtr lock */
		WaitForSingleObject(tsdPtr->socketListLock, INFINITE);

		/*
		 * Check if my infoPtr is already in the tsdPtr->socketList
		 * It is set after this call by TcpThreadActionProc and is set
		 * on a second round.
		 *
		 * If not, we buffer my infoPtr in the tsd memory so it is not
		 * lost by the event procedure
		 */

		for (infoPtr2 = tsdPtr->socketList; infoPtr2 != NULL;
			infoPtr2 = infoPtr->nextPtr) {
		    if (infoPtr2 == infoPtr) {
			in_socket_list = 1;
			break;
		    }
		}
		if (!in_socket_list) {
		    tsdPtr->pendingSocketInfo = infoPtr;
		}
		/*
		 * Set connect mask to connect events
		 * This is activated by a SOCKET_SELECT message to the notifier
		 * thread.
		 */
		infoPtr->selectEvents |= FD_CONNECT;
		
		/*
		 * Free list lock
		 */
		SetEvent(tsdPtr->socketListLock);


    		/* activate accept notification */
		SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM) SELECT,
			(LPARAM) infoPtr);



	    }

	    /*
	     * Attempt to connect to the remote socket.
	     */
	    
	    DEBUG("connect()");
	    connect(infoPtr->sockets->fd, infoPtr->addr->ai_addr,
		    infoPtr->addr->ai_addrlen);

	    error = WSAGetLastError();
	    TclWinConvertError(error);

	    if (async_connect && error == WSAEWOULDBLOCK) {
		/*
		 * Asynchroneous connect
		 */
		DEBUG("WSAEWOULDBLOCK");


		/*

		 * Remember that we jump back behind this next round
		 */
		infoPtr->flags |= SOCKET_REENTER_PENDING;
		return TCL_OK;

	    reenter:

		DEBUG("reenter");
		/*
		 * Re-entry point for async connect after connect event or
		 * blocking operation
		 *
		 * Clear the reenter flag
		 */
		infoPtr->flags &= ~(SOCKET_REENTER_PENDING);
		/* get infoPtr lock */
		WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
		/* Get signaled connect error */
		Tcl_SetErrno(infoPtr->lastError);
		/* Clear eventual connect flag */
		infoPtr->selectEvents &= ~(FD_CONNECT);
		/* Free list lock */
		SetEvent(tsdPtr->socketListLock);
	    }





#ifdef DEBUGGING
	    fprintf(stderr, "lastError: %d\n", Tcl_GetErrno());
#endif
	    if (Tcl_GetErrno() == 0) {
		goto out;
	    }
	}

    }
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * WaitForConnect --
 *
 *	Terminate an asyncroneous connect syncroneously.
 *	This routine should only be called if flag ASYNC_CONNECT is set.
 *
 * Results:
 *	Returns -1 on success or 0 on failure, with an error code in
 *	errorCodePtr.
 *
 * Side effects:
 *	Processes socket events off the system queue.
 *
 *----------------------------------------------------------------------
 */

static int
WaitForConnect(
    SocketInfo *infoPtr,	/* Information about this socket. */
    int *errorCodePtr)		/* Where to store errors? */
{
    int result;
    int oldMode;
    ThreadSpecificData *tsdPtr = TclThreadDataKeyGet(&dataKey);
    /*
     * A non blocking socket waiting for an asyncronous connect
     * returns directly an error
     */
    if (infoPtr->flags & SOCKET_ASYNC) {

    }

    /*
     * Check if there is an async connect to terminate
     */

    if ( (infoPtr->flags & SOCKET_REENTER_PENDING)
	    && !WaitForConnect(infoPtr, 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

    }

    /*
     * Check if there is an async connect to terminate
     */

    if ( (infoPtr->flags & SOCKET_REENTER_PENDING)
	    && !WaitForConnect(infoPtr, errorCodePtr)) {
	return -1;
    }

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

    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    int event, error;
    SOCKET socket;
    SocketInfo *infoPtr = NULL; /* DEBUG */
    int info_found = 0;
    TcpFdList *fds = NULL;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
#ifdef _WIN64
	    GetWindowLongPtr(hwnd, GWLP_USERDATA);
#else
	    GetWindowLong(hwnd, GWL_USERDATA);
#endif

	break;

    case SOCKET_MESSAGE:
	event = WSAGETSELECTEVENT(lParam);
	error = WSAGETSELECTERROR(lParam);
	socket = (SOCKET) wParam;

        #ifdef DEBUGGING
	fprintf(stderr,"event = %d, error=%d\n",event,error);
	#endif
	if (event & FD_READ) DEBUG("READ Event");
	if (event & FD_WRITE) DEBUG("WRITE Event");
	if (event & FD_CLOSE) DEBUG("CLOSE Event");
	if (event & FD_CONNECT)
	    DEBUG("CONNECT Event");
	if (event & FD_ACCEPT) DEBUG("ACCEPT Event");

	DEBUG("Get list lock");
	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);

	/*
	 * Find the specified socket on the socket list and update its
	 * eventState flag.
	 */




	for (infoPtr = tsdPtr->socketList; infoPtr != NULL;
		infoPtr = infoPtr->nextPtr) {
    	    DEBUG("Cur InfoPtr");
    	    if ( FindFDInList(infoPtr,socket) ) {
    		info_found = 1;
    		DEBUG("InfoPtr found");
    		break;
    	    }
    	}
    	/*
    	 * Check if there is a pending info structure not jet in the
    	 * list
    	 */
    	if ( !info_found
    		&& tsdPtr->pendingSocketInfo != NULL
    		&& FindFDInList(tsdPtr->pendingSocketInfo,socket) ) {
    	    infoPtr = tsdPtr->pendingSocketInfo;
    	    DEBUG("Pending InfoPtr found");
    	    info_found = 1;
    	}
    	if (info_found) {
	    if (event & FD_READ) 
		DEBUG("|->FD_READ");
	    if (event & FD_WRITE) 
		DEBUG("|->FD_WRITE");

	    /*
	     * Update the socket state.
	     *
	     * A count of FD_ACCEPTS is stored, so if an FD_CLOSE event
	     * happens, then clear the FD_ACCEPT count. Otherwise,
	     * increment the count if the current event is an FD_ACCEPT.
	     */

	    if (event & FD_CLOSE) {
		DEBUG("FD_CLOSE");
		infoPtr->acceptEventCount = 0;
		infoPtr->readyEvents &= ~(FD_WRITE|FD_ACCEPT);
	    } else if (event & FD_ACCEPT) {
		DEBUG("FD_ACCEPT");
		    infoPtr->acceptEventCount++;
	    }

	    if (event & FD_CONNECT) {
		DEBUG("FD_CONNECT");
		/*
		 * Remember any error that occurred so we can report
		 * connection failures.
		 */
		if (error != ERROR_SUCCESS) {
		    TclWinConvertError((DWORD) error);
		    infoPtr->lastError = Tcl_GetErrno();
		}
	    }
	    /*
	     * Inform main thread about signaled events
	     */
	    infoPtr->readyEvents |= event;

	    /*
	     * Wake up the Main Thread.
	     */
	    SetEvent(tsdPtr->readyEvent);
	    Tcl_ThreadAlert(tsdPtr->threadId);



	}
	SetEvent(tsdPtr->socketListLock);
	break;

    case SOCKET_SELECT:
	DEBUG("SOCKET_SELECT");
	infoPtr = (SocketInfo *) lParam;

	    DEBUG("SOCKET_TERMINATE");
	DestroyWindow(hwnd);
	break;
    }

    return 0;
}

/*
 *----------------------------------------------------------------------
 *
 * FindFDInList --
 *
 *	Return true, if the given file descriptior is contained in the
 *	file descriptor list.
 *
 * Results:
 *	true if found.
 *
 * Side effects:
 *
 *----------------------------------------------------------------------
 */

static int
FindFDInList(
    SocketInfo *infoPtr,
    SOCKET socket)
{
    TcpFdList *fds;
    for (fds = infoPtr->sockets; fds != NULL; fds = fds->next) {
        #ifdef DEBUGGING
	fprintf(stderr,"socket = %d, fd=%d",socket,fds);
	#endif
	if (fds->fd == socket) {
	    return 1;
	}
    }
    return 0;
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetHostName --
 *
 *	Returns the name of the local host.

	Tcl_MutexLock(&socketMutex);
	InitSockets();
	Tcl_MutexUnlock(&socketMutex);

	tsdPtr = TCL_TSD_INIT(&dataKey);

	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
	DEBUG("Inserting pointer to list");
	infoPtr->nextPtr = tsdPtr->socketList;
	tsdPtr->socketList = infoPtr;
	
	if (infoPtr == tsdPtr->pendingSocketInfo) {
	    DEBUG("Clearing temporary info pointer");
	    tsdPtr->pendingSocketInfo = NULL;
	}
	
	SetEvent(tsdPtr->socketListLock);

	notifyCmd = SELECT;
    } else {
	SocketInfo **nextPtrPtr;
	int removed = 0;

	tsdPtr = TCL_TSD_INIT(&dataKey);

	/*
	 * TIP #218, Bugfix: All access to socketList has to be protected by
	 * the lock.
	 */

	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
	DEBUG("Removing pointer from list");
	for (nextPtrPtr = &(tsdPtr->socketList); (*nextPtrPtr) != NULL;
		nextPtrPtr = &((*nextPtrPtr)->nextPtr)) {
	    if ((*nextPtrPtr) == infoPtr) {
		(*nextPtrPtr) = infoPtr->nextPtr;
		removed = 1;
		break;
	    }