Tcl Source Code

2011-05-27  Reinhard Max  <[email protected]>

	* unix/tclUnixSock.c: Fix [socket -async], so that all addresses
	returned by getaddrinfo() are tried, not just the first one. This
	requires the event loop to be running while the async connection
	is in progress. ***POTENTIAL INCOMPATIBILITY***
	* tests/socket.test: Add a test for the above.

2011-05-25  Don Porter  <[email protected]>

	* library/msgcat/msgcat.tcl:	Bump to msgcat 1.4.4.
	* library/msgcat/pkgIndex.tcl:
	* unix/Makefile.in
	* win/Makefile.in

# cleanup
if {$remoteProcChan ne ""} {
    catch {sendCommand exit}
}
catch {close $commandSocket}
catch {close $remoteProcChan}
}
unset ::tcl::unsupported::socketAF
test socket-14.0 {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]
        # fileevent $client readable [list set x [fconfigure $client -error]]
        after 1000 {set x [fconfigure $client -error]}
        vwait x
        set x
    } -cleanup {
        close $server
        close $client
    } -result ok
::tcltest::cleanupTests
flush stdout
return

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

} TcpFdList;

struct TcpState {
    Tcl_Channel channel;	/* Channel associated with this file. */
    TcpFdList *fds;		/* The file descriptors of the sockets. */
    int flags;			/* ORed combination of the bitfields defined
				 * below. */
    union {
        struct {
            /* 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;
            struct addrinfo *myaddrlist;
            struct addrinfo *addr;
            struct addrinfo *myaddr;
        };
    };
};

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

#define SOCKET_BUFSIZE	4096

/*
 * Static routines for this file:
 */

static int		CreateClientSocket(Tcl_Interp *interp,
                                           TcpState *state);

static void		TcpAccept(ClientData data, int mask);
static int		TcpBlockModeProc(ClientData data, int mode);
static int		TcpCloseProc(ClientData instanceData,
			    Tcl_Interp *interp);
static int		TcpClose2Proc(ClientData instanceData,
			    Tcl_Interp *interp, int flags);
static int		TcpGetHandleProc(ClientData instanceData,

    ClientData *handlePtr)	/* Where to store the handle. */
{
    TcpState *statePtr = (TcpState *) instanceData;

    *handlePtr = INT2PTR(statePtr->fds->fd);
    return TCL_OK;
}

static void
TcpAsyncCallback(
    ClientData clientData,	/* The socket state. */
    int mask)			/* Events of interest; an OR-ed combination of
				 * TCL_READABLE, TCL_WRITABLE and
				 * TCL_EXCEPTION. */
{
    CreateClientSocket(NULL, clientData);
}

/*
 *----------------------------------------------------------------------
 *
 * CreateClientSocket --
 *
 *	This function opens a new socket in client mode.

 *
 * Results:
 *      TCL_OK, if the socket was successfully connected or an asynchronous
 *      connection is in progress. If an error occurs, TCL_ERROR is returned
 *      and an error message is left in interp.
 *
 * Side effects:
 *	Opens a socket.
 *
 *----------------------------------------------------------------------
 */

static int
CreateClientSocket(
    Tcl_Interp *interp,		/* For error reporting; can be NULL. */
    TcpState *state)







{
    int status = -1, 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) {
        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;
	    }

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

	    /*
	     * Set the close-on-exec flag so that the socket will not get
	     * inherited by child processes.
	     */
	    
	    fcntl(state->fds->fd, F_SETFD, FD_CLOEXEC);
	    
	    /*
	     * Set kernel space buffering
	     */
	    
	    TclSockMinimumBuffers(INT2PTR(state->fds->fd), SOCKET_BUFSIZE);
    
	    if (async) {
		status = TclUnixSetBlockingMode(state->fds->fd, TCL_MODE_NONBLOCKING);
		if (status < 0) {
		    goto looperror;
		}
	    }

            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) {
                goto looperror;
            }

	    /*
	     * 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);
                // fprintf(stderr, "here: %d \n", state->fds->fd);
                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);             
                    // fprintf(stderr, "there: %d \n", state->fds->fd);
                } while (0);
            }
	    if (status == 0) {
		connected = 1;
		break;
	    }
	looperror:
	    if (state->fds->fd != -1) {
		close(state->fds->fd);
		state->fds->fd = -1;
	    }
	}
	if (connected) {
	    break;
	} 
	status = -1;
	if (state->fds->fd >= 0) {
	    close(state->fds->fd);
	    state->fds->fd = -1;
	}
    }
    if (async) {
	/*
	 * Restore blocking mode.
	 */

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



    freeaddrinfo(state->addrlist);


    freeaddrinfo(state->myaddrlist);


    if (status < 0 && !async) {
        if (interp != NULL) {
	    Tcl_AppendResult(interp, "couldn't open socket: ",
                             Tcl_PosixError(interp), NULL);


	}

	if (state->fds->fd != -1) {
	    close(state->fds->fd);
	}


        ckfree(state->fds);

        ckfree(state);

	return TCL_ERROR;





    }
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_OpenTcpClient --
 *

    const char *host,		/* Host on which to open port. */
    const char *myaddr,		/* Client-side address */
    int myport,			/* Client-side port */
    int async)			/* If nonzero, attempt to do an asynchronous
				 * connect. Otherwise we do a blocking
				 * connect. */
{
    TcpState *state;
    const char *errorMsg = NULL;
    struct addrinfo *addrlist, *myaddrlist;
    char channelName[4+16+1];	/* "sock" + up to 16 hex chars + \0 */


    /*
     * Do the name lookups for the local and remote addresses.
     */
    if (!TclCreateSocketAddress(interp, &addrlist, host, port, 0, &errorMsg)) {
	goto error;
    }
    if (!TclCreateSocketAddress(interp, &myaddrlist, myaddr, myport, 1,
                                &errorMsg)) {
        freeaddrinfo(addrlist);
        goto error;
    }

    /*
     * Allocate a new TcpState for this socket.
     */
    state = ckalloc(sizeof(TcpState));
    memset(state, 0, sizeof(TcpState));
    state->flags = async ? TCP_ASYNC_CONNECT : 0;
    state->addrlist = addrlist;
    state->myaddrlist = myaddrlist;
    state->fds = ckalloc(sizeof(TcpFdList));
    memset(state->fds, (int) 0, sizeof(TcpFdList));
    state->fds->fd = -1;

    /*
     * Create a new client socket and wrap it in a channel.
     */

    if (CreateClientSocket(interp, state) != TCL_OK) {


        goto error;
    }




    sprintf(channelName, "sock%lx", (long)state);

    state->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
                                       state, (TCL_READABLE | TCL_WRITABLE));
    if (Tcl_SetChannelOption(interp, state->channel, "-translation",
	    "auto crlf") == TCL_ERROR) {
	Tcl_Close(NULL, state->channel);
	return NULL;
    }
    return state->channel;

error:
    if (interp != NULL) {
        Tcl_AppendResult(interp, "couldn't open socket: ",
                         Tcl_PosixError(interp), NULL);
        if (errorMsg != NULL) {
            Tcl_AppendResult(interp, " (", errorMsg, ")", NULL);
        }
    }
    return NULL;
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_MakeTcpClientChannel --
 *