Tcl Source Code

if {$remoteProcChan ne ""} {
    catch {sendCommand exit}
}
catch {close $commandSocket}
catch {close $remoteProcChan}
}
unset ::tcl::unsupported::socketAF
test socket-14.0 {[socket -async] when server only listens on one address family} \
    -constraints [list socket supported_any] \
    -setup {
        proc accept {s a p} {
            global x
            puts $s bye
            close $s
            set x ok
        }
        set server [socket -server accept -myaddr 127.0.0.1 0]
        set port [lindex [fconfigure $server -sockname] 2]
    } -body {
        set client [socket -async localhost $port]

        after 1000 {set x [fconfigure $client -error]}
        vwait x
        set x
    } -cleanup {
        close $server
        close $client
    } -result ok
test socket-14.1 {[socket -async] fileevent while still connecting} \
    -constraints [list socket supported_any] \
    -setup {
        proc accept {s a p} {
            global x
            puts $s bye
            close $s
            set x ok
        }
        set server [socket -server accept -myaddr 127.0.0.1 2222]
        set port [lindex [fconfigure $server -sockname] 2]
    } -body {
        set client [socket -async localhost $port]
        fileevent $client readable {lappend x [fconfigure $client -error]}
        set after [after 1000 {set x timeout}]
        vwait x
        vwait x
        set x
    } -cleanup {
        after cancel $after
        close $server
        close $client
    } -result {ok {}}
test socket-14.2 {[socket -async] fileevent connection refused} \
    -constraints [list socket supported_any] \
    -body {
        set client [socket -async localhost 0]
        fileevent $client readable {set x [fconfigure $client -error]}
        set after [after 1000 {set x timeout}]
        vwait x
        set x
    } -cleanup {
        after cancel $after
        close $client
    } -result "connection refused"

::tcltest::cleanupTests
flush stdout
return

# Local Variables:
# mode: tcl
# fill-column: 78

            /* Only needed for server sockets */
            Tcl_TcpAcceptProc *acceptProc;
				/* Proc to call on accept. */
            ClientData acceptProcData;
				/* The data for the accept proc. */
        };
        struct {
            /*
             * Only needed for client sockets
             */
            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 filehandlers;	/* Caches FileHandlers that get set up while
                                 * an async socket is not yet connected   */
            int status;         /* Cache status of async socket */
        };
    };
};

/*
 * These bits may be ORed together into the "flags" field of a TcpState
 * structure.

    }

    if ((len > 1) && (optionName[1] == 'e') &&
	    (strncmp(optionName, "-error", len) == 0)) {
	socklen_t optlen = sizeof(int);
	int err, ret;

        if (statePtr->status == 0) {
            ret = getsockopt(statePtr->fds->fd, SOL_SOCKET, SO_ERROR,
                             (char *)&err, &optlen);
            if (ret < 0) {
                err = errno;
            }
        } else {
            err = statePtr->status;
            statePtr->status = 0;
        }
	if (err != 0) {
	    Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(err), -1);
	}
	return TCL_OK;
    }

    if (interp != NULL && Tcl_GetVar(interp, SUPPRESS_RDNS_VAR, 0) != NULL) {

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

     
    if (statePtr->flags & TCP_ASYNC_CONNECT) {
        /* Async sockets use a FileHandler internally while connecting, so we
         * need to cache this request until the connection has succeeded. */
        statePtr->filehandlers = mask;
    } else if (mask) {
        Tcl_CreateFileHandler(statePtr->fds->fd, mask,
                              (Tcl_FileProc *) Tcl_NotifyChannel,
                              (ClientData) statePtr->channel);
    } else {
        Tcl_DeleteFileHandler(statePtr->fds->fd);

    }
}

/*
 *----------------------------------------------------------------------
 *
 * TcpGetHandleProc --

 */

static int
CreateClientSocket(
    Tcl_Interp *interp,		/* For error reporting; can be NULL. */
    TcpState *state)
{
    int status, connected = 0;
    int async = state->flags & TCP_ASYNC_CONNECT;

    if (state->addr != NULL) {
        goto coro_continue;
    }
    
    for (state->addr = state->addrlist; state->addr != NULL;
         state->addr = state->addr->ai_next) {

	status = -1;

        for (state->myaddr = state->myaddrlist; state->myaddr != NULL;
             state->myaddr = state->myaddr->ai_next) {
            int reuseaddr;
            
	    /*
	     * No need to try combinations of local and remote addresses of
	     * different families.
	     */

	    if (state->myaddr->ai_family != state->addr->ai_family) {
		continue;
	    }

            /*
             * Close the socket if it is still open from the last unsuccessful
             * iteration.
             */
            if (state->fds->fd >= 0) {
		close(state->fds->fd);
		state->fds->fd = -1;
	    }

	    state->fds->fd = socket(state->addr->ai_family, SOCK_STREAM, 0);
	    if (state->fds->fd < 0) {
		continue;
	    }

	    /*

	     */
	    
	    TclSockMinimumBuffers(INT2PTR(state->fds->fd), SOCKET_BUFSIZE);
    
	    if (async) {
		status = TclUnixSetBlockingMode(state->fds->fd, TCL_MODE_NONBLOCKING);
		if (status < 0) {
                    continue;
		}
	    }

            reuseaddr = 1;
            (void) setsockopt(state->fds->fd, SOL_SOCKET, SO_REUSEADDR,
                    (char *) &reuseaddr, sizeof(reuseaddr));
            status = bind(state->fds->fd, state->myaddr->ai_addr,
                          state->myaddr->ai_addrlen);
            if (status < 0) {
                continue;
            }

	    /*
	     * Attempt to connect. The connect may fail at present with an
	     * EINPROGRESS but at a later time it will complete. The caller
	     * will set up a file handler on the socket if she is interested
	     * in being informed when the connect completes.
	     */
	    
	    status = connect(state->fds->fd, state->addr->ai_addr,
                             state->addr->ai_addrlen);
	    if (status < 0 && errno == EINPROGRESS) {
                Tcl_CreateFileHandler(state->fds->fd, TCL_WRITABLE,
                                      TcpAsyncCallback, state);

                return TCL_OK;
            coro_continue:
                do {
                    socklen_t optlen = sizeof(int);
                    Tcl_DeleteFileHandler(state->fds->fd);
                    getsockopt(state->fds->fd, SOL_SOCKET, SO_ERROR,
                               (char *)&status, &optlen);
                    state->status = status;
                } while (0);
            }
	    if (status == 0) {
		connected = 1;
		break;
	    }





	}
	if (connected) {
	    break;
	} 





    }
    if (async) {
	/*
	 * Restore blocking mode.
	 */

	status = TclUnixSetBlockingMode(state->fds->fd, TCL_MODE_BLOCKING);
    }

    freeaddrinfo(state->addrlist);
    freeaddrinfo(state->myaddrlist);

    if (async) {
        CLEAR_BITS(state->flags, TCP_ASYNC_CONNECT);
        if (state->filehandlers != 0) {
            TcpWatchProc(state, state->filehandlers);
        }
        return TCL_OK;
    }
    if (status < 0) {
        if (interp != NULL) {
	    Tcl_AppendResult(interp, "couldn't open socket: ",
                             Tcl_PosixError(interp), NULL);
	}
	if (state->fds->fd != -1) {
	    close(state->fds->fd);
	}

    int mode)			/* ORed combination of TCL_READABLE and
				 * TCL_WRITABLE to indicate file mode. */
{
    TcpState *statePtr;
    char channelName[16 + TCL_INTEGER_SPACE];

    statePtr = ckalloc(sizeof(TcpState));
    memset(statePtr, 0, sizeof(TcpState));
    statePtr->fds = ckalloc(sizeof(TcpFdList));
    memset(statePtr->fds, (int) 0, sizeof(TcpFdList));
    statePtr->fds->fd = PTR2INT(sock);
    statePtr->flags = 0;



    sprintf(channelName, "sock%d", statePtr->fds->fd);

    statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
	    statePtr, mode);
    if (Tcl_SetChannelOption(NULL, statePtr->channel, "-translation",
	    "auto crlf") == TCL_ERROR) {

        memset(newfds, (int) 0, sizeof(TcpFdList));
        if (statePtr == NULL) {
            /*
             * Allocate a new TcpState for this socket.
             */
            
            statePtr = ckalloc(sizeof(TcpState));
            memset(statePtr, 0, sizeof(TcpState));
            statePtr->fds = newfds;
            statePtr->acceptProc = acceptProc;
            statePtr->acceptProcData = acceptProcData;
            sprintf(channelName, "sock%d", sock);
        } else {
            fds->next = newfds;
        }

     * Set close-on-exec flag to prevent the newly accepted socket from being
     * inherited by child processes.
     */

    (void) fcntl(newsock, F_SETFD, FD_CLOEXEC);

    newSockState = ckalloc(sizeof(TcpState));
    memset(newSockState, 0, sizeof(TcpState));
    newSockState->flags = 0;
    newSockState->fds = ckalloc(sizeof(TcpFdList));
    memset(newSockState->fds, (int) 0, sizeof(TcpFdList));
    newSockState->fds->fd = newsock;



    sprintf(channelName, "sock%d", newsock);
    newSockState->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
	    newSockState, (TCL_READABLE | TCL_WRITABLE));

    Tcl_SetChannelOption(NULL, newSockState->channel, "-translation",
	    "auto crlf");