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

        SetEvent(tsdPtr->socketListLock);
	return 1;
    }

    infoPtr->flags &= ~SOCKET_PENDING;

    /* Continue async connect if pending and ready */
    if ( (infoPtr->flags & SOCKET_REENTER_PENDING)
	    && (infoPtr->readyEvents & FD_CONNECT) ) {

	DEBUG("FD_CONNECT");

	SetEvent(tsdPtr->socketListLock);
	CreateClientSocket(NULL, infoPtr);
	return 1;

    }

    /*
     * Handle connection requests directly.
     */
    if (infoPtr->readyEvents & FD_ACCEPT) {
	for (fds = infoPtr->sockets; fds != NULL; fds = fds->next) {

    ThreadSpecificData *tsdPtr;
    DWORD error;
    
    DEBUG(async_connect ? "async connect" : "sync connect");

    if (async_callback) {
	DEBUG("subsequent call");
	/* Clear this pending reenter case */
	infoPtr->flags &= ~(SOCKET_REENTER_PENDING);
        goto reenter;
    } else {
	DEBUG("first call");
    }
    
    for (infoPtr->addr = infoPtr->addrlist; infoPtr->addr != NULL;
	 infoPtr->addr = infoPtr->addr->ai_next) {

	    infoPtr->sockets->fd = socket(infoPtr->myaddr->ai_family, SOCK_STREAM, 0);
	    if (infoPtr->sockets->fd == INVALID_SOCKET) {
		DEBUG("socket() failed");
		TclWinConvertError((DWORD) WSAGetLastError());
		continue;
	    }
	    



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

	    SetHandleInformation((HANDLE) infoPtr->sockets->fd, HANDLE_FLAG_INHERIT, 0);

	     */
	    
	    DEBUG("connect()");
	    connect(infoPtr->sockets->fd, infoPtr->addr->ai_addr,
		    infoPtr->addr->ai_addrlen);
	    error = WSAGetLastError();
	    TclWinConvertError(error);
#ifdef DEBUGGING
	    // fprintf(stderr,"error = %lu\n", error);
#endif
	    if (error == WSAEWOULDBLOCK) {
		DEBUG("WSAEWOULDBLOCK");
		/* Jump out and remember that we want to get back in */



		infoPtr->flags |= SOCKET_REENTER_PENDING;
		return TCL_OK;
	    reenter:
		Tcl_SetErrno(infoPtr->lastError);
		DEBUG("reenter");
		infoPtr->selectEvents &= ~(FD_CONNECT);
	    }





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

out:
    DEBUG("connected or finally failed");


    if (Tcl_GetErrno() != 0 && interp != NULL) {
	DEBUG("ERRNO");
        /* Clear async flag so if a read is done it does not block */
        infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
	if (interp != NULL) {
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
				"couldn't open socket: %s", Tcl_PosixError(interp)));
	}
	return TCL_ERROR;
    }
    /*

    int oldMode;
    ThreadSpecificData *tsdPtr = TclThreadDataKeyGet(&dataKey);
    /*
     * A non blocking socket waiting for an asyncronous connect
     * returns directly an error
     */
    if (infoPtr->flags & SOCKET_ASYNC) {
	    *errorCodePtr = EWOULDBLOCK;
	    return 0;
	}

    /*
     * Be sure to disable event servicing so we are truly modal.
     */

    oldMode = Tcl_SetServiceMode(TCL_SERVICE_NONE);

    /*
     * Disable async connect as we continue now synchoneously
     */

    /* ToDo: need thread protection * */
    infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);

    /*
     * Reset WSAAsyncSelect so we have a fresh set of events pending.
     */

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

    while (1) {
	/* Check for connect event */
	if (infoPtr->readyEvents & FD_CONNECT) {



	    /* continue async connect syncroneously */
	    result = CreateClientSocket(NULL, infoPtr);
	    (void) Tcl_SetServiceMode(oldMode);
	    /* Todo: find adequate error code */
	    *errorCodePtr = EFAULT;
	    return (result == TCL_OK);
	}

		    } else if (event & FD_ACCEPT) {
			DEBUG("FD_ACCEPT");
			    infoPtr->acceptEventCount++;
		    }

		    if (event & FD_CONNECT) {
			DEBUG("FD_CONNECT");

			if (error == ERROR_SUCCESS) {
			    /*
			     * The socket is now connected, clear the async connect
			     * flag.
			     */
			    infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
			} else {
			    /*
			     * Remember any error that occurred so we can report
			     * connection failures.
			     */

			    TclWinConvertError((DWORD) error);
			    infoPtr->lastError = Tcl_GetErrno();
			}
		    }
#if 0
		    if (infoPtr->flags & SOCKET_ASYNC_CONNECT) {
			DEBUG("SOCKET_ASYNC_CONNECT");
			// infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
			if (error != ERROR_SUCCESS) {
			    TclWinConvertError((DWORD) error);
			    infoPtr->lastError = Tcl_GetErrno();
			}

			infoPtr->readyEvents |= FD_WRITE;
		    }
#endif

		    infoPtr->readyEvents |= event;

		    /*
		     * Wake up the Main Thread.
		     */

		    SetEvent(tsdPtr->readyEvent);
		    Tcl_ThreadAlert(tsdPtr->threadId);
		    break;
		}
	    }
	}
	SetEvent(tsdPtr->socketListLock);
	break;

    case SOCKET_SELECT:
	    DEBUG("SOCKET_SELECT");
	infoPtr = (SocketInfo *) lParam;
	for (fds = infoPtr->sockets; fds != NULL; fds = fds->next) {
	    infoPtr = (SocketInfo *) lParam;


	    if (wParam == SELECT) {
		DEBUG("SELECT");
		if (infoPtr->selectEvents & FD_READ) DEBUG("  READ");
		if (infoPtr->selectEvents & FD_WRITE) DEBUG("  WRITE");
		if (infoPtr->selectEvents & FD_CLOSE) DEBUG("  CLOSE");
		if (infoPtr->selectEvents & FD_CONNECT) DEBUG("  CONNECT");
		if (infoPtr->selectEvents & FD_ACCEPT) DEBUG("  ACCEPT");