Tcl Source Code

    ClientData acceptProcData;	/* The data for the accept proc. */
    struct addrinfo *addrlist;	/* Addresses to connect to. */
    struct addrinfo *addr;	/* Iterator over addrlist. */
    struct addrinfo *myaddrlist;/* Local address. */
    struct addrinfo *myaddr;	/* Iterator over myaddrlist. */
    int status;                 /* Cache status of async socket. */
    int cachedBlocking;         /* Cache blocking mode of async socket. */
    int lastError;		/* Error code from notifier thread. */
    int connectError;		/* Error code from failed async connect. */
    struct SocketInfo *nextPtr;	/* The next socket on the per-thread socket
				 * list. */
};

/*
 * The following structure is what is added to the Tcl event queue when a
 * socket event occurs.

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,
			    int terminate_connect);
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);

    infoPtr->flags &= ~SOCKET_PENDING;

    /* Continue async connect if pending and ready */
    if ( infoPtr->readyEvents & FD_CONNECT ) {
	infoPtr->readyEvents &= ~(FD_CONNECT);
	DEBUG("FD_CONNECT");
        if ( infoPtr->flags & SOCKET_REENTER_PENDING ) {
	    /* free list lock */
	    SetEvent(tsdPtr->socketListLock);
	    /* Do one connect step */
	    if (TCL_OK != CreateClientSocket(NULL, infoPtr) ) {

		/* On final fail save error for fconfigure -error */
		infoPtr->connectError = Tcl_GetErrno();
	    }
	}
    }

    /*
     * Handle connection requests directly.
     */
    if (infoPtr->readyEvents & FD_ACCEPT) {

	    if (Tcl_GetErrno() == 0) {
		goto out;
	    }
	}
    }

out:
    /*
     * Socket connected or connection failed
     */
    DEBUG("connected or finally failed");
    /* Clear async flag (not really necessary, not used any more) */
    infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);






    /*
     * 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");    
	infoPtr->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) infoPtr);
    } 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 for fail writable");    
	    infoPtr->selectEvents = FD_WRITE;
	    /* get infoPtr lock */
	    WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
	    /* Clear eventual connect flag */
	    infoPtr->readyEvents |= FD_WRITE;
	    /* Free list lock */
	    SetEvent(tsdPtr->socketListLock);
	}
	/*
	 * Error message on syncroneous connect
	 */
	if (interp != NULL) {
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		    "couldn't open socket: %s", Tcl_PosixError(interp)));
	}
	return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * WaitForConnect --
 *
 *	Process an asyncroneous connect by other commands (gets... ).
 *	Do one connect step if pending as if the event loop would run.
 *
 *	Blocking commands may call in with terminate_connect to terminate
 *	the syncroneous connect syncroneously.
 *
 *	This routine should only be called if flag SOCKET_REENTER_PENDING
 *	is set.
 *
 * Results:
 *	Returns 1 on success or 0 on failure, with a possix error code in
 *	errorCodePtr.
 *	If the connect is not terminated, errorCode is set to EWOULDBLOCK
 *	and 0 is returned.
 *
 * Side effects:
 *	Processes socket events off the system queue.
 *	May process asynchroneous connect.
 *
 *----------------------------------------------------------------------
 */

static int
WaitForConnect(
    SocketInfo *infoPtr,	/* Information about this socket. */
    int *errorCodePtr,		/* Where to store errors? */
    int terminate_connect)	/* Should the connect be terminated? */
{
    int result;
    int oldMode;
    ThreadSpecificData *tsdPtr = TclThreadDataKeyGet(&dataKey);

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

	    /* Consume the connect event */
	    infoPtr->readyEvents &= ~(FD_CONNECT);

	    /*
	     * For blocking sockets disable async connect
	     * as we continue now synchoneously
	     */
	    if ( terminate_connect ) {
		infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
	    }

            /* Free list lock */
            SetEvent(tsdPtr->socketListLock);

	    /* continue connect */

        /* Free list lock */
        SetEvent(tsdPtr->socketListLock);

	/*
	 * A non blocking socket waiting for an asyncronous connect
	 * returns directly an error
	 */
	if ( ! terminate_connect ) {
	    *errorCodePtr = EWOULDBLOCK;
	    return 0;
	}

	/*
	 * Wait until something happens.
	 */

     */

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

    /*
     * Check if there is an async connect running.
     * For blocking sockets terminate connect, otherwise do one step.
     * For a non blocking socket return EWOULDBLOCK if connect not terminated
     */

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

    if (!SocketsEnabled()) {
	*errorCodePtr = EFAULT;
	return -1;
    }

    /*
     * Check if there is an async connect running.
     * For blocking sockets terminate connect, otherwise do one step.
     * For a non blocking socket return EWOULDBLOCK if connect not terminated
     */

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

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

    sock = infoPtr->sockets->fd;
    if (optionName != NULL) {
	len = strlen(optionName);
    }

    if ((len > 1) && (optionName[1] == 'e') &&
	    (strncmp(optionName, "-error", len) == 0)) {

	if ( (infoPtr->flags & SOCKET_REENTER_PENDING) ) {

	    /*
	     * Asyncroneous connect is running.
	     * Process it one step without blocking.
	     * Return its error or nothing if connect not
	     * terminated.
	     */

	    int errorCode;
	    if (!WaitForConnect(infoPtr, &errorCode, 0)
		    && errorCode != EWOULDBLOCK) {
		/* connect terminated with error */
		Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(errorCode), -1);
	    }
	} else if (infoPtr->connectError != 0) {
	    /*
	     * An async connect error was not jet reported.
	     */
	    Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(infoPtr->connectError), -1);
	    infoPtr->connectError = 0;
	} else {
	    int optlen;
	    int ret;
    	    DWORD err;

	    optlen = sizeof(int);
	    ret = TclWinGetSockOpt(sock, SOL_SOCKET, SO_ERROR,
		    (char *)&err, &optlen);
	    if (ret == SOCKET_ERROR) {
		err = WSAGetLastError();


		if (err) {
		    TclWinConvertError(err);
		    Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(Tcl_GetErrno()), -1);
		}
	    }
	}
	return TCL_OK;
    }

    if (interp != NULL && Tcl_GetVar(interp, SUPPRESS_RDNS_VAR, 0) != NULL) {
	reverseDNS = NI_NUMERICHOST;
    }

FindFDInList(
    SocketInfo *infoPtr,
    SOCKET socket)
{
    TcpFdList *fds;
    for (fds = infoPtr->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;
}