*
 *   (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", \
			    statePtr, __FUNCTION__, __LINE__, x)
#else
#define DEBUG(x)
#endif

/*
 * Which version of the winsock API do we want?
 */

#define WSA_VERSION_MAJOR	1
#define WSA_VERSION_MINOR	1

 * The following variable holds the network name of this host.
 */

static TclInitProcessGlobalValueProc InitializeHostName;
static ProcessGlobalValue hostName =
	{0, 0, NULL, NULL, InitializeHostName, NULL, NULL};

/*
 * Address print debug functions
 */
#if 0
void printaddrinfo(struct addrinfo *ai, char *prefix)
{
    char host[NI_MAXHOST], port[NI_MAXSERV];
    getnameinfo(ai->ai_addr, ai->ai_addrlen,
		host, sizeof(host),
		port, sizeof(port),
		NI_NUMERICHOST|NI_NUMERICSERV);
#ifdef DEBUGGING
    fprintf(stderr,"%s: [%s]:%s\n", prefix, host, port);
#endif
}
void printaddrinfolist(struct addrinfo *addrlist, char *prefix)
{
    struct addrinfo *ai;
    for (ai = addrlist; ai != NULL; ai = ai->ai_next) {
	printaddrinfo(ai, prefix);
    }
}
#endif

/*
 *----------------------------------------------------------------------
 *
 * InitializeHostName --
 *
 *	This routine sets the process global value of the name of the local

	if (len == 0) {
	    Tcl_DStringAppendElement(dsPtr, "-sockname");
	    Tcl_DStringStartSublist(dsPtr);
	}
	for (fds = statePtr->sockets; fds != NULL; fds = fds->next) {
	    sock = fds->fd;
#ifdef DEBUGGING
	    fprintf(stderr, "sock == %d\n", sock);
#endif
	    size = sizeof(sockname);
	    if (getsockname(sock, &(sockname.sa), &size) >= 0) {
		int flags = reverseDNS;

		found = 1;
		getnameinfo(&sockname.sa, size, host, sizeof(host),
			NULL, 0, NI_NUMERICHOST);

    ClientData instanceData,	/* The socket state. */
    int mask)			/* Events of interest; an OR-ed combination of
				 * TCL_READABLE, TCL_WRITABLE and
				 * TCL_EXCEPTION. */
{
    TcpState *statePtr = instanceData;

    DEBUG((mask & TCL_READABLE) ? "+r":"-r");
    DEBUG((mask & TCL_WRITABLE) ? "+w":"-w");

    /*
     * Update the watch events mask. Only if the socket is not a server
     * socket. [Bug 557878]
     */

    if (!statePtr->acceptProc) {
	statePtr->watchEvents = 0;

     * was not jet received
     */
    int async_connect = statePtr->flags & TCP_ASYNC_CONNECT;
    /* We were called by the event procedure and continue our loop */
    int async_callback = statePtr->sockets->fd != INVALID_SOCKET;
    ThreadSpecificData *tsdPtr = TclThreadDataKeyGet(&dataKey);
    
    DEBUG(async_connect ? "async connect" : "sync connect");

    if (async_callback) {
	DEBUG("subsequent call");
        goto reenter;
    } else {
	DEBUG("first call");
    }
    
    for (statePtr->addr = statePtr->addrlist; statePtr->addr != NULL;
	 statePtr->addr = statePtr->addr->ai_next) {
	
        for (statePtr->myaddr = statePtr->myaddrlist; statePtr->myaddr != NULL;
	     statePtr->myaddr = statePtr->myaddr->ai_next) {

	    DEBUG("inner loop");

	    /*
	     * No need to try combinations of local and remote addresses
	     * of different families.
	     */

	    if (statePtr->myaddr->ai_family != statePtr->addr->ai_family) {
		DEBUG("family mismatch");
		continue;
	    }

	    DEBUG(statePtr->myaddr->ai_family == AF_INET ? "IPv4" : "IPv6");
	    printaddrinfo(statePtr->myaddr, "~~ from");
	    printaddrinfo(statePtr->addr,   "~~   to");

            /*
             * Close the socket if it is still open from the last unsuccessful
             * iteration.
             */	    
	    if (statePtr->sockets->fd != INVALID_SOCKET) {
		DEBUG("closesocket");
		closesocket(statePtr->sockets->fd);
	    }

	    /* get statePtr lock */
	    WaitForSingleObject(tsdPtr->socketListLock, INFINITE);

	    /*
	     * Reset last error from last try
	     */
	    statePtr->connectError = 0;
	    Tcl_SetErrno(0);
	    
	    statePtr->sockets->fd = socket(statePtr->myaddr->ai_family, SOCK_STREAM, 0);
	    
	    /* Free list lock */
	    SetEvent(tsdPtr->socketListLock);

	    /* continue on socket creation error */
	    if (statePtr->sockets->fd == INVALID_SOCKET) {
		DEBUG("socket() failed");
		TclWinConvertError((DWORD) WSAGetLastError());
		continue;
	    }
	    

#ifdef DEBUGGING
	    fprintf(stderr, "Client socket %d created\n", statePtr->sockets->fd);
#endif
	    /*
	     * Win-NT has a misfeature that sockets are inherited in child
	     * processes by default. Turn off the inherit bit.
	     */

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

	    /*
	     * Set kernel space buffering
	     */

	    TclSockMinimumBuffers((void *) statePtr->sockets->fd, TCP_BUFFER_SIZE);

	    /*
	     * Try to bind to a local port.
	     */

	    if (bind(statePtr->sockets->fd, statePtr->myaddr->ai_addr,
			statePtr->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
	     */

			(LPARAM) statePtr);
	    }

	    /*
	     * Attempt to connect to the remote socket.
	     */
	    
	    DEBUG("connect()");
	    connect(statePtr->sockets->fd, statePtr->addr->ai_addr,
		    statePtr->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
		 */
		statePtr->flags |= TCP_ASYNC_CONNECT_REENTER_PENDING;
		return TCL_OK;

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

	    fprintf(stderr, "connectError: %d\n", Tcl_GetErrno());
#endif
	    /*
	     * Clear the tsd socket list pointer if we did not wait for
	     * the FD_CONNECT asyncroneously
	     */
	    tsdPtr->pendingTcpState = NULL;
	    
	    if (Tcl_GetErrno() == 0) {
		goto out;
	    }
	}
    }

out:
    /*
     * Socket connected or connection failed
     */
    DEBUG("connected or finally failed");

    /*
     * Final connect failure
     */

    if ( Tcl_GetErrno() == 0 ) {
	/*
	 * Succesfully connected
	 */
	/*
	 * Set up the select mask for read/write events.
	 */
	DEBUG("selectEvents = FD_READ | FD_WRITE | FD_CLOSE");    
	statePtr->selectEvents = FD_READ | FD_WRITE | FD_CLOSE;
        
	/*
	 * Register for interest in events in the select mask. Note that this
	 * automatically places the socket into non-blocking mode.
	 */
        
	SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM) SELECT,
		    (LPARAM) statePtr);
    } else {
	/*
	 * Connect failed
	 */
	DEBUG("ERRNO");

	/*
	 * For async connect schedule a writable event to report the fail.
	 */
	if (async_callback) {
	    /*
	     * Set up the select mask for read/write events.
	     */
	    DEBUG("selectEvents = FD_WRITE/FD_READ for connect fail");    
	    statePtr->selectEvents = FD_WRITE|FD_READ;
	    /* get statePtr lock */
	    WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
	    /* Signal ready readable and writable events */
	    statePtr->readyEvents |= FD_WRITE | FD_READ;
	    /* Flag error to event routine */
	    statePtr->flags |= TCP_ASYNC_CONNECT_FAILED;

        }
        if (interp != NULL) {
            Tcl_SetObjResult(interp, Tcl_ObjPrintf(
                    "couldn't open socket: %s", errorMsg));
        }
        return NULL;
    }
    printaddrinfolist(myaddrlist, "local");
    printaddrinfolist(addrlist, "remote");

    statePtr = NewSocketInfo(INVALID_SOCKET);
    statePtr->addrlist = addrlist;
    statePtr->myaddrlist = myaddrlist;
    if (async) {
	statePtr->flags |= TCP_ASYNC_CONNECT;
    }

    /*
     * Create a new client socket and wrap it in a channel.
     */
    DEBUG("");
    if (CreateClientSocket(interp, statePtr) != TCL_OK) {
	TcpCloseProc(statePtr, NULL);
	return NULL;
    }

    sprintf(channelName, SOCK_TEMPLATE, statePtr);

     */
    WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
    for (statePtr = tsdPtr->socketList; statePtr != NULL;
	    statePtr = statePtr->nextPtr) {
	if (statePtr->readyEvents &
	    (statePtr->watchEvents | FD_CONNECT | FD_ACCEPT)
	) {
	    DEBUG("Tcl_SetMaxBlockTime");
	    Tcl_SetMaxBlockTime(&blockTime);
	    break;
	}
    }
    SetEvent(tsdPtr->socketListLock);
}


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

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

static int
SocketEventProc(
    Tcl_Event *evPtr,		/* Event to service. */
    int flags)			/* Flags that indicate what events to handle,
				 * such as TCL_FILE_EVENTS. */
{
    TcpState *statePtr = NULL; /* DEBUG */
    TcpState *statePtr;
    SocketEvent *eventPtr = (SocketEvent *) evPtr;
    int mask = 0, events;
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    TcpFdList *fds;
    SOCKET newSocket;
    address addr;
    int len;

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

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

    }

    statePtr->flags &= ~SOCKET_PENDING;

    /* Continue async connect if pending and ready */
    if ( statePtr->readyEvents & FD_CONNECT ) {
	statePtr->readyEvents &= ~(FD_CONNECT);
	DEBUG("FD_CONNECT");
	if ( statePtr->flags & TCP_ASYNC_CONNECT_REENTER_PENDING ) {
	    SetEvent(tsdPtr->socketListLock);
	    CreateClientSocket(NULL, statePtr);
	    return 1;
	}
    }

	 * out for the channel being deleted out from under us. This may cause
	 * a redundant trip through the event loop, but it's simpler than
	 * trying to do unwind protection.
	 */

	Tcl_Time blockTime = { 0, 0 };

	DEBUG("FD_CLOSE");
	Tcl_SetMaxBlockTime(&blockTime);
	mask |= TCL_READABLE|TCL_WRITABLE;
    } else if (events & FD_READ) {

	/*
	 * Throw the readable event if an async connect failed.
	 */

	if ( statePtr->flags & TCP_ASYNC_CONNECT_FAILED ) {

	    mask |= TCL_READABLE;
	    
	} else {
	    fd_set readFds;
	    struct timeval timeout;

	    /*
	     * 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.
	     * 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.
	     */
	    DEBUG("FD_READ");

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

	    FD_ZERO(&readFds);
	    FD_SET(statePtr->sockets->fd, &readFds);
	    timeout.tv_usec = 0;

    }

    /*
     * writable event
     */

    if (events & FD_WRITE) {
	DEBUG("FD_WRITE");
	mask |= TCL_WRITABLE;
    }
    
    /*
     * Call registered event procedures
     */
     
    if (mask) {
	DEBUG("Calling Tcl_NotifyChannel...");
	Tcl_NotifyChannel(statePtr->channel, mask);
    }
    DEBUG("returning...");
    return 1;
}

/*
 *----------------------------------------------------------------------
 *
 * AddSocketInfoFd --

{
    int result = 1;
    int oldMode;
    ThreadSpecificData *tsdPtr = TclThreadDataKeyGet(&dataKey);
    /*
     * Be sure to disable event servicing so we are truly modal.
     */
    DEBUG("=============");

    oldMode = Tcl_SetServiceMode(TCL_SERVICE_NONE);

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

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

	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 (statePtr = tsdPtr->socketList; statePtr != NULL;
		statePtr = statePtr->nextPtr) {
	    DEBUG("Cur InfoPtr");
	    if ( FindFDInList(statePtr,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->pendingTcpState != NULL
		&& FindFDInList(tsdPtr->pendingTcpState,socket) ) {
	    statePtr = tsdPtr->pendingTcpState;
	    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");
		statePtr->acceptEventCount = 0;
		statePtr->readyEvents &= ~(FD_WRITE|FD_ACCEPT);
	    } else if (event & FD_ACCEPT) {
		DEBUG("FD_ACCEPT");
		    statePtr->acceptEventCount++;
		statePtr->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);
		    statePtr->connectError = Tcl_GetErrno();

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

    case SOCKET_SELECT:
	DEBUG("SOCKET_SELECT");
	statePtr = (TcpState *) lParam;
	for (fds = statePtr->sockets; fds != NULL; fds = fds->next) {
#ifdef DEBUGGING
	    fprintf(stderr,"loop over fd = %d\n",fds->fd);
#endif
	    if (wParam == SELECT) {
		DEBUG("SELECT");
		if (statePtr->selectEvents & FD_READ) DEBUG("  READ");
		if (statePtr->selectEvents & FD_WRITE) DEBUG("  WRITE");
		if (statePtr->selectEvents & FD_CLOSE) DEBUG("  CLOSE");
		if (statePtr->selectEvents & FD_CONNECT) DEBUG("  CONNECT");
		if (statePtr->selectEvents & FD_ACCEPT) DEBUG("  ACCEPT");
		WSAAsyncSelect(fds->fd, hwnd,
			SOCKET_MESSAGE, statePtr->selectEvents);
	    } else {
		/*
		 * Clear the selection mask
		 */

		DEBUG("!SELECT");
		WSAAsyncSelect(fds->fd, hwnd, 0, 0);
	    }
	}
	break;

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

    return 0;
}


static int
FindFDInList(
    TcpState *statePtr,
    SOCKET socket)
{
    TcpFdList *fds;
    for (fds = statePtr->sockets; fds != NULL; fds = fds->next) {
        #ifdef DEBUGGING
	fprintf(stderr,"socket = %d, fd=%d\n",socket,fds);
	#endif
	if (fds->fd == socket) {
	    return 1;
	}
    }
    return 0;
}


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

	tsdPtr = TCL_TSD_INIT(&dataKey);

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

	notifyCmd = SELECT;
    } else {
	TcpState **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) == statePtr) {
		(*nextPtrPtr) = statePtr->nextPtr;
		removed = 1;
		break;
	    }