nettcpendpoint.cc #1

// -*- mode: C++; tab-width: 4; -*-
// vi:ts=8 sw=4 noexpandtab autoindent

/*
 * NetTcpEndPoint
 *
 * Copyright 1995, 1996, 2011 Perforce Software.  All rights reserved.
 *
 * This file is part of Perforce - the FAST SCM System.
 * - previously part of nettcp.cc
 */

# define NEED_ERRNO
# define NEED_SIGNAL
# ifdef OS_NT
# define NEED_FILE
# endif
# define NEED_FCNTL
# define NEED_IOCTL
# define NEED_TYPES
# define NEED_SOCKET_IO

# ifdef OS_MPEIX
# define _SOCKET_SOURCE /* for sys/types.h */
# endif

# include "netportipv6.h"	// must be included before stdhdrs.h
# include <stdhdrs.h>

# if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_DARWIN)
# include <sys/un.h>
# endif // OS_LINUX || OS_MACOSX

# include <error.h>
# include <strbuf.h>
# include "netaddrinfo.h"
# include <bitarray.h>
# include <debug.h>
# include <tunable.h>
# include <keepalive.h>
# include <msgrpc.h>
# include "netportparser.h"
# include "netconnect.h"
# include "netutils.h"
# include "nettcpendpoint.h"
# include "nettcptransport.h"
# include "netselect.h"
# include "netport.h"
# include "netdebug.h"
# include "netsupport.h"

static int one = 1;

/*
 * For 2012.1, default hints flags to nothing.
 * For 2012.2, perhaps default them to AI_ADDRCONFIG.
 *
 * AI_ADDRCONFIG suppresses unnecessary AAAA DNS lookups
 * from hosts that have no IPv6 connectivity,
 * thus preventing long IPv6 stalls for such hosts.
 * See RFC 2553 "Basic Socket Interface Extensions for IPv6".
 *
 * However, AI_ADDRCONFIG also prevents "localhost" (*and* "::1")
 * lookups from returning IPv6 addresses if there are no interfaces
 * with routable IPv6 addresses; this prevents IPv6 testing in 2012.1
 * until we provide IPv6 infrastructure internally.
 * In order to support internal testing of IPv6 in 2012.1
 * we don't turn this flag on.
 *
 * In 2012.1 clients must explicitly request an IPv6 connection
 * via one of the IPv6 transport prefixes; presumably they won't
 * do that at all, as IPv6 support is for internal testing only in 2012.1.
 * Therefore, the lack of AI_ADDRCONFIG should not be a problem in 2012.1.
 *
 * In 2012.2 we could consider changing the default and tcp/ssl transports
 * to IPv4+IPv6 and use the system-defined preference (by default, prefer
 * IPv6), rather than using our own prefer-v4 or prefer-v6 transport
 * prefixes.
 * See RFC 3484 "Default Address Selection for Internet Protocol version 6 (IPv6)".
 * At the same time we should turn on AI_ADDRCONFIG to prevent stalls when
 * trying to connect via IPv6 if the host can't use IPv6.  As a convenience,
 * we could consider not adding AI_ADDRCONFIG if the requested hostname is
 * either "localhost" or "::1" (there's no real need to check for the myriad
 * of localhost aliases or of the different ways to write "::1").
 */
static const int kBaseHintsFlags = 0;

/*
 * NetTcp utility routines
 */

void
NetTcpEndPoint::SetupSocket( int fd, int ai_family, AddrType type, Error *e )
{
# if defined(F_SETFD) && !defined(OS_NT)
	// attempt to set close on exec flag, ignore failures
	fcntl(fd, F_SETFD, 1);
# endif

	// Set buffer size.

	// Turn on misc options:
	//    REUSEADDR - allows listens while dead connections exist
	//    REUSEPORT - allows listens while live connections exist (BSD)
	//    KEEPALIVE - detects dead PCs

	// Do these separately: although SO_XXX look like bit flags, they're not.
	// AIX just plain chokes sometimes on these, so we don't check.
	// Well, we now check, but don't report an error unless DT_NET debugging is enabled.

	//
	// Don't set SO_REUSEADDR on Windows since it doesn't do what it's
	// supposed to. Instead of allowing you to reuse a port within the
	// TIME_WAIT period, it allows a process to bind to a port that's
	// actively being used by another process. Yuk. The good news
	// is that SO_REUSEADDR is not required to rebind within the 
	// TIME_WAIT period on Windows.
	// 

	int sz;
	TYPE_SOCKLEN rsz = sizeof( sz );
	const int MinBufSz = p4tunable.Get( P4TUNE_NET_TCPSIZE );

# ifdef SO_SNDBUF
	// never reduce the buffer size, so don't set it if we can't get the old value
	if( !getsockopt( fd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<SOCKOPT_T *>(&sz), &rsz ) )
	{
	    if( sz < MinBufSz )
	    {
	        sz = MinBufSz;
	        do_setsockopt( "NetTcpEndPoint", fd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<SOCKOPT_T *>(&sz), rsz );
	    }
	}
# endif

# ifdef SO_RCVBUF
	// never reduce the buffer size, so don't set it if we can't get the old value
	if( !getsockopt( fd, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<SOCKOPT_T *>(&sz), &rsz ) )
	{
	    if( sz < MinBufSz )
	    {
	        sz = MinBufSz;
	        do_setsockopt( "NetTcpEndPoint", fd, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<SOCKOPT_T *>(&sz), rsz );
	    }
	}
# endif

# if defined( SO_REUSEADDR ) && !defined( OS_NT )
	if( (type == AT_LISTEN) || (type == AT_CHECK) )
	{
	    do_setsockopt( "NetTcpEndPoint", fd, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<SOCKOPT_T *>(&one), rsz );
	}
# endif

# ifdef SO_REUSEPORT
	const int reuseport = p4tunable.Get( P4TUNE_NET_REUSEPORT );
	if( ((type == AT_LISTEN) || (type == AT_CHECK)) && reuseport )
	{
	    do_setsockopt( "NetTcpEndPoint", fd, SOL_SOCKET, SO_REUSEPORT, reinterpret_cast<SOCKOPT_T *>(&one), rsz );
	}
# endif

# if defined(IPV6_V6ONLY) && !defined(OS_MINGW) && (!defined(_MSC_VER) || (_MSC_VER >= 1400))
	/*
	 * We allow the IPV6_V6ONLY sockopt on Windows only when building on VS 2005 or above,
	 * but we support only VS 2008 and later.
	 *
	 * RFC 3493 says that by default IPv6 sockets accept IPv4 connection requests.
	 * However, on Windows Vista and later the default is that they don't accept
	 * IPv4 connections.  Rather than #ifdef the defaults for all the platforms
	 * (and track them when they change their defaults), we don't rely on the default
	 * and always set this option appropriately.
	 *
	 * Note that it makes no sense to try to configure an IPv4 socket either to be
	 * IPV6-only or to be IPV6-and-IPV4, so we set it only on IPv6 sockets.
	 * Most dual-stack implementations seem to allow its use on IPv4 sockets,
	 * but it seems silly, so we don't do it.
	 *
	 * However, only dual-stack implementations provide this call, so we are #ifdef'ed
	 * on IPV6_V6ONLY.
	 */

	// don't try to set IPV6_V6ONLY on a v4 socket
	if( (type == AT_LISTEN) && (ai_family == AF_INET6) )
	{
	    const int val = GetPortParser().MustIPv6();
	    TRANSPORT_PRINTF( DEBUG_CONNECT, "NetTcpEndPoint setsockopt(IPV6_V6ONLY, %d)", val )

	    // this will fail harmlessly on Windows XP (but only if it passes the #ifdef test)
	    do_setsockopt( "NetTcpEndPoint", fd, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const SOCKOPT_T *>(&val), sizeof(val) );
	}
# endif

	MoreSocketSetup( fd, type, e );    // for subclasses to add extra behavior
}

// subclasses can do more setup here, if desired
void
NetTcpEndPoint::MoreSocketSetup( int fd, AddrType type, Error *e )
{
}

int
NetTcpEndPoint::CreateSocket(
	AddrType type,
	const NetAddrInfo &ai,
	int af_target,
	bool useAlternate,
	Error *e )
{
	int fd = -1;

	// iterate through the address list and use the first of the correct address family
	for( const addrinfo *aip = ai.begin(); aip != ai.end(); aip = aip->ai_next )
	{
	    if( useAlternate && (af_target == AF_UNSPEC) && (aip == ai.begin()) )
	    {
	        /*
	         * If we are to use an alternate address then try the first
	         * address that isn't the same family as the first entry.
	         * For RFC 3484 we try addresses in returned order,
	         * but only the first address (if any) of each family.
	         * If useAlternate was true then we must already have
	         * tried the first entry, so skip it now.
	         */
	        af_target = (aip->ai_family == AF_INET) ? AF_INET6 : AF_INET;
	        continue;
	    }

	    // don't discard any responses if no preference was given
	    if( (AF_UNSPEC != af_target) && (aip->ai_family != af_target) )
	        continue;

	    if( DEBUG_CONNECT )
	    {
	        StrBuf	addr;
	        NetUtils::GetAddress( aip->ai_family, aip->ai_addr, RAF_PORT, addr );
	        TRANSPORT_PRINTF( DEBUG_CONNECT, "NetTcpEndPoint try socket(%d, %d, %d, %s)",
	            aip->ai_family, aip->ai_socktype, aip->ai_protocol, addr.Text() );
	    }

	    fd = ::socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
	    if( fd == -1 )
	    {
	        // odd ... probably either EACCES or ENFILE
	        e->Net( "socket", "create" );

	        if( DEBUG_CONNECT )
	        {
	            StrBuf errnum;
	            Error::StrNetError( errnum );
	            TRANSPORT_PRINTF( DEBUG_CONNECT, "NetTcpEndPoint socket(%d, %d, %d) failed, error = %s",
	                aip->ai_family, aip->ai_socktype, aip->ai_protocol, errnum.Text() );
	        }
	        //continue;    // uncomment to try all addresses in this family
	    }
	    else
	    {
	        SetupSocket( fd, aip->ai_family, type, e );

		int result;		// the result of the connect or bind
		const char *op4;	// the name of the IPv4 operation ["connect" or "connect (IPv6)"]
		const char *op6;	// the name of the IPv6 operation ["bind" or "bind (IPv6)"]

	        switch( type )
	        {
	        case AT_CONNECT:
	            result = connect( fd, aip->ai_addr, aip->ai_addrlen );
		    op4 = "connect";
		    op6 = "connect (IPv6)";
	            break;
	        case AT_CHECK:
	        case AT_LISTEN:
	            result = bind( fd, aip->ai_addr, aip->ai_addrlen );
		    op4 = "bind";
		    op6 = "bind (IPv6)";
		    break;
		}

		// did the connect/bind fail?
		if( result == -1 )
		{
		    // preserve/restore the listen error across the GetAddress call
		    int err = Error::GetNetError();
		    StrBuf addrBuf;
		    NetUtils::GetAddress( aip->ai_family, aip->ai_addr, RAF_PORT, addrBuf );
		    Error::SetNetError(err);	// restore the "last" error

		    // use different error ids/args for IPv4 and IPv6 so the correct address arg is output
		    if( aip->ai_family == AF_INET6 )
			e->Net2( op6, addrBuf.Text() );
		    else
			e->Net( op4, addrBuf.Text() );
		    NET_CLOSE_SOCKET( fd );
		    return -1;
		}
	    }
	    break;
	}

	return fd;
}

/**
 * return true if we resolved the address, false otherwise
 */
bool
NetTcpEndPoint::GetAddrInfo( AddrType type, NetAddrInfo &ai, Error *e )
{
	StrBuf port = ai.Port();
	StrBuf host = ai.Host();
	StrBuf hostPort = "[";
	hostPort.Append( &host );
	hostPort.Append( "]:" );
	hostPort.Append( &port );

	e->Clear();
	if( port.IsNumeric() )
	{
	    int portAsInt = port.Atoi();
	    if( portAsInt < 0 || portAsInt >= 65536 )
	    {
	        e->Set( MsgRpc::TcpPortInvalid ) << port;
	        return false;
	    }
	}

	NetPortParser &pp = GetPortParser();
	int ai_family = pp.MustIPv4() ? AF_INET : (pp.MustIPv6() ? AF_INET6 : AF_UNSPEC);
	int ai_flags = kBaseHintsFlags | AI_ALL | (pp.WantIPv6() ? 0 : AI_ADDRCONFIG );

	ai.SetHintsFamily( ai_family );

	// set AI_PASSIVE to get IPv4 addresses mapped in IPv6 if host isn't specified
	if( type != AT_CONNECT )
	{
	    ai_flags |= AI_PASSIVE;

	    if( pp.MayIPv4() && pp.MayIPv6() )
	    {
	        ai_flags |= AI_V4MAPPED;
	    }
	}

	if( DEBUG_CONNECT )
	{
	    p4debug.printf( "NetTcpEndPoint::GetAddrInfo(port=%s, family=%d, flags=0x%x)\n",
	        hostPort.Text(), ai_family, ai_flags );
	}

	ai.SetHintsFlags( ai_flags );
	bool result = ai.GetInfo(e);   // resolve the host and service/port names (IPv4 and/or IPv6)
	if( !result )
	{
	    if( ai.GetStatus() == EAI_BADFLAGS )
	    {
	        /*
	         * Apparently our OS doesn't support AI_ALL or AI_V4MAPPED.
	         *     Maybe it's a single-stack server:
	         *         FreeBSD 7.0 or older
	         *         Windows XP or older
	         *         ...
	         * We'll try again without those flags.
	         */
	        ai_flags = kBaseHintsFlags | (pp.WantIPv6() ? 0 : AI_ADDRCONFIG )
	                   | ( (type == AT_CONNECT) ? 0 : AI_PASSIVE );
	        ai.SetHintsFlags( ai_flags );

		TRANSPORT_PRINTF( DEBUG_CONNECT,
			"NetTcpEndPoint::GetAddrInfo(port=%s, family=%d, flags=0x%x) [retry]",
		         hostPort.Text(), ai_family, ai_flags );

	        e->Clear();
	        result = ai.GetInfo(e);
	    }
	}

	if( !result )
	{
	    // job062842 -- allow local operation without a routable address
	    if( (ai.GetStatus() == EAI_NONAME) && (ai_flags & AI_ADDRCONFIG) )
	    {
	        /*
		 * Perhaps we don't have a routable address and are trying
		 * to run locally.  Try again without AI_ADDRCONFIG.
	         */
	        ai_flags &= ~AI_ADDRCONFIG;
	        ai.SetHintsFlags( ai_flags );

		TRANSPORT_PRINTF( DEBUG_CONNECT,
			"NetTcpEndPoint::GetAddrInfo(port=%s, family=%d, flags=0x%x) [retry-2]",
		         hostPort.Text(), ai_family, ai_flags );

	        e->Clear();
	        result = ai.GetInfo(e);
	    }
	}

	return result;
}

int
NetTcpEndPoint::BindOrConnect( AddrType type, struct Error *e )
{
	int fd = -1;

	// first setup an addrinfo from the parsed P4PORT {transport, host, port} tuple
	NetPortParser &pp = GetPortParser();
	StrBuf	host = pp.Host();
	StrBuf	port = pp.Port();

	// ListenCheck is passed "host" or "host:port"
	if( type == AT_CHECK )
	{
	    /*
	     * We're called with AT_CHECK only from ListenCheck(),
	     * which just wants to ensure that we can bind to the
	     * provided address.
	     */

	    // NetPortParser assumes "host:port" or just "port"
	    if( host.Length() == 0 )
	        host.Set( pp.HostPort() );

	    /*
	     * Don't bind to a specific port; we care about the host address
	     * for this check, not the port, and another service might be
	     * running on the licensed port.  We don't want to get an
	     * EADDRINUSE error just because the port is in use.
	     */
	    port.Set( "" );
	}
	else
	{
	    // check that the address specifies a port
	    // only if we're not checking the license
	    if( !pp.IsValid(e) )
		return -1;
	}

	NetAddrInfo ai( host, port );
	if( !GetAddrInfo(type, ai, e) )
	{
	    // give up if we didn't succeed in resolving the address
	    return -1;
	}

	// now create a socket of the appropriate address family

	/*
	 * In 2012.1 we interpret "tcp:" and "ssl:" to mean IPv4
	 * so that we don't break existing licenses and protects tables.
	 *
	 * Note that if the server specifies "tcp6:" or "ssl6:"
	 * then they are explicitly rejecting IPv4.  Because "tcp:" and "ssl:"
	 * means IPv4 then the user must use "tcp46:" or "tcp64:" (or the ssl
	 * equivalents) to specify "either IPv4 or IPv6".  The first of "4"
	 * or "6" is the preferred transport.
	 *
	 * IPv6 will also work for IPv4 connections (transport only until
	 * 2012.2), except for servers on single-stack OSes: Windows XP or
	 * FreeBSD 7.0 or earlier.
	 * Using "tcp64:" or "ssl64:" on those servers won't provide
	 * IPv4-mapped-in-IPv6.
	 */
	bool rfc3484 = pp.MustRfc3484();
	int af_target = rfc3484 ? AF_UNSPEC
	                        : (pp.PreferIPv6() ? AF_INET6 : AF_INET);

	/*
	 * RFC 3484 specifies a precedence for deciding the order of returned
	 * addresses to be used for connect/bind.  If we're following RFC 3484
	 * then we won't also apply our coarse IPv4-first or IPv6-first ordering.
	 * If we aren't following RFC 3484 then we'll still use the intra-family
	 * order provided by getaddrinfo.
	 *
	 * In 2012.1, NetPortParser.MustRfc3484() will always return false,
	 * but in 2013.1 and later it will return the value of "-v net.rfc3484"
	 * if the transport didn't specify an IPv4 or IPv6 preference (via
	 * transport prefix or numeric address).
	 */
	fd = CreateSocket( type, ai, af_target, false, e );
	if( fd == -1 )
	{
	    // didn't get a socket the first time; try again
	    if( rfc3484 )
	    {
	        // try the first address of the other family
	        fd = CreateSocket( type, ai, af_target, true, e );
	    }
	    else
	    {
	        /*
	         * If we tried and failed to get a socket of our preferred family,
	         * try to get a socket of an acceptable alternate family.
	         * The "else" clause handles IPv6-only hosts, as well as
	         * connect attempts to hosts that are reachable only via IPv6,
	         * when the preferred transport is IPv4 (currently IPv4-only is
	         * the default).
	         */
	        if( (af_target == AF_INET6) && pp.MayIPv4() ) // "tcp64:" or "ssl64:"
	            fd = CreateSocket( type, ai, AF_INET, false, e );
	        else if( (af_target == AF_INET) && pp.MayIPv6() ) // "tcp46:" or "ssl46:"
	            fd = CreateSocket( type, ai, AF_INET6, false, e );
	    }
	}

	if( fd == -1 )
	{
	    // failed to get a socket and/or bind/connect
	    return -1;
	}

	// finally, setup the socket options and return it
	e->Clear();    // because the first CreateSocket() might have set an error

	return fd;
}

/*
 * NetTcpEndPoint
 */

NetTcpEndPoint::NetTcpEndPoint( Error *e )
{
	s = -1;
	/*
	 * Initialize as "false" so client side of connection:
	 *   !isFromClient == isToServer
	 * Will be set to true if "listen" is invoked.
	 */
	isAccepted = false;

	int err = NetUtils::InitNetwork();
	if( err )
	{
	    StrNum errnum( err );

	    e->Net( "Network initialization failure", errnum.Text() );
	}
}

NetTcpEndPoint::~NetTcpEndPoint()
{
	Unlisten();
	NetUtils::CleanupNetwork();
}

void
NetTcpEndPoint::Listen( Error *e )
{
	const int backlog = p4tunable.Get( P4TUNE_NET_BACKLOG );
	isAccepted = true;

	if( ( s = BindOrConnect( AT_LISTEN, e ) ) < 0 )
	{
	    e->Set( MsgRpc::TcpListen ) << GetPortParser().HostPort();
	    return;
	}

	// Now listen

	if( listen( s, backlog ) < 0 )
	{
	    e->Net( "listen", GetPortParser().String().Text() );
	    StrBuf listenAddress;
	    GetListenAddress( s, RAF_PORT, listenAddress );
	    NET_CLOSE_SOCKET( s );
	    e->Set( MsgRpc::TcpListen ) << listenAddress;
	}

# ifdef SIGPIPE
	signal( SIGPIPE, SIG_IGN );
# endif

	if( DEBUG_CONNECT )
	{
	    StrBuf listenAddress;
	    GetListenAddress( s, RAF_PORT, listenAddress );
	    TRANSPORT_PRINTF( DEBUG_CONNECT, "NetTcpEndPoint %s listening",
	        listenAddress.Text() );
	}
}

/**
 * Return the first addrinfo pointer of the desired family;
 * return NULL if none.
 */
const addrinfo *
NetTcpEndPoint::GetMatchingAddrInfo(
	const NetAddrInfo &ai,
	int af_target,
	bool useAlternate)
{
	// iterate through the address list and use the first of the correct address family
	for( const addrinfo *aip = ai.begin(); aip != ai.end(); aip = aip->ai_next )
	{
	    if( useAlternate && (af_target == AF_UNSPEC) && (aip == ai.begin()) )
	    {
	        /*
	         * If we are to use an alternate address then try the first
	         * address that isn't the same family as the first entry.
	         * For RFC 3484 we try addresses in returned order,
	         * but only the first address (if any) of each family.
	         * If useAlternate was true then we must already have
	         * tried the first entry, so skip it now.
	         */
	        af_target = (aip->ai_family == AF_INET) ? AF_INET6 : AF_INET;
	        continue;
	    }

	    if( (AF_UNSPEC == af_target) || (aip->ai_family == af_target) )
	        return aip;
	}

	return NULL;
}

/**
 * "requestedPort" is the P4PORT (or the command-line "-p") string.
 * The "this" NetTcpEndPoint object was constructed using the
 * address[:port] in the license file.
 */
int
NetTcpEndPoint::CheaterCheck( const char *requestedPort )
{
	Error e;

	NetPortParser &ppLicensed = GetPortParser();
	StrBuf	ppLicHost = ppLicensed.Host();
	StrBuf	ppLicPort = ppLicensed.Port();

	NetPortParser ppRequested( requestedPort );
	if( !ppRequested.IsValid( &e ) )
	    return 1;

	// no host? then we were created with just a host, not a port
	if( ppLicHost.Length() == 0 )
	{
	    ppLicHost.Set( ppLicensed.Port() );
	    ppLicPort.Set( "" );
	}

	// We already called BindOrConnect() once from ListenCheck() and there
	// wasn't an error then, so there shouldn't be one now.

	NetAddrInfo ai( ppLicHost, ppLicPort );
	// see the comments in BindOrConnect about RFC 3484 compliance
	bool rfc3484 = ppLicensed.MustRfc3484();
	int af_target = rfc3484 ? AF_UNSPEC
	                        : (ppLicensed.PreferIPv6() ? AF_INET6 : AF_INET);
	if( !GetAddrInfo(AT_CHECK, ai, &e) )
	{
	    return 1;
	}

	// get the addrinfo that we would use if we were to listen
	const addrinfo *aip = GetMatchingAddrInfo( ai, af_target, false );
	if( aip == NULL )
	{
	    if( rfc3484 )
	    {
	        // try the first address of the other family
	        // pointless, really, but matches the BindOrConnect logic
	        aip = GetMatchingAddrInfo( ai, AF_UNSPEC, true );
	    }
	    else
	    {
	        if( (af_target == AF_INET6) && ppLicensed.MayIPv4() )
	            aip = GetMatchingAddrInfo( ai, AF_INET, false );
	        else if( (af_target == AF_INET) && ppLicensed.MayIPv6() )
	            aip = GetMatchingAddrInfo( ai, AF_INET6, false );
	    }
	}
	if( aip == NULL )
	{
	    // no acceptable address
	    return 1;
	}

	// Are they trying to start the server on a port other than
	// the licensed one ???

	int myPort = NetUtils::GetInPort( aip->ai_addr );
	if( myPort == -1 )
	{
	    // bad address family -- shouldn't happen
	    return 1;
	}

	// If the license file has an ip address but no port number we
	// must still allow this.

	unsigned short requestedPortNum = ppRequested.PortNum();
	if( (myPort == 0) || (myPort == requestedPortNum) )
	{
	    return 0;
	}

	return 1;
}

void
NetTcpEndPoint::ListenCheck( Error *e )
{
	int fd = BindOrConnect( AT_CHECK, e );
	if( fd >= 0 )
	{
	    close( fd );
	}
}

void
NetTcpEndPoint::GetListenAddress( int s, int raf_flags, StrBuf &listenAddress )
{
	struct sockaddr_storage addr;
	struct sockaddr *saddrp = reinterpret_cast<struct sockaddr *>(&addr);
	TYPE_SOCKLEN addrlen = sizeof addr;

	if( getsockname( s, saddrp, &addrlen ) < 0 || addrlen > sizeof addr )
	{
	    listenAddress.Set( "unknown" );
	}
	else
	{
	    NetUtils::GetAddress( addr.ss_family, saddrp, raf_flags, listenAddress );
	}
}

StrPtr *
NetTcpEndPoint::GetHost()
{
	ipAddr = GetPortParser().Host();

	return &ipAddr;
}

/*
 * job063713 -- ensure that IPv6 literal addresses are in our
 * standard form, per RFC 3986 : surrounded with brackets
 * - matches the behavior of NetUtils::GetAddress()
 */
StrBuf
NetTcpEndPoint::GetPrintableHost()
{
	StrPtr	host = GetPortParser().Host();

	if( (host[0] != '[') && NetUtils::IsIpV6Address(host.Text()) )
	{
	    StrBuf	tmp = "[";
	    tmp.Append( host.Text() );
	    tmp.Append( "]" );

	    return tmp;
	}

	return host;
}

void
NetTcpEndPoint::Unlisten()
{
	NET_CLOSE_SOCKET( s );
}

NetTransport *
NetTcpEndPoint::Accept( Error *e )
{
	TYPE_SOCKLEN lpeer;
	struct sockaddr_storage peer;
	int t;

	TRANSPORT_PRINTF( DEBUG_CONNECT, "NetTcpEndpoint accept on %d", s );

	lpeer = sizeof peer;

	// Loop accepting, as it gets interrupted (by SIGCHILD) on
	// some platforms (MachTen, but not FreeBSD).

	while( ( t = accept( s, reinterpret_cast<struct sockaddr *>(&peer), &lpeer ) ) < 0 )
	{
	    if( errno != EINTR )
	    {
	        e->Net( "accept", "socket" );
	        e->Set( MsgRpc::TcpAccept );;
	        return 0;
	    }
	}

# ifdef F_SETFD
	// close on exec
	// so p4web's launched processes don't get our socket
	fcntl( t, F_SETFD, 1 );
# endif

	NetTcpTransport *transport = new NetTcpTransport( t, true );
	if( transport )
	    transport->SetPortParser(GetPortParser());
	return transport;
}

NetTransport *
NetTcpEndPoint::Connect( Error *e )
{
	int t;

	// Set up addresses
	if( ( t = BindOrConnect( AT_CONNECT, e ) ) < 0 )
	{
	    e->Set( MsgRpc::TcpConnect ) << GetPortParser().HostPort();
	    return 0;
	}

	TRANSPORT_PRINTF( DEBUG_CONNECT, "NetTcpEndpoint connect on %d", t );

# ifdef SIGPIPE
	signal( SIGPIPE, SIG_IGN );
# endif

	NetTcpTransport *transport = new NetTcpTransport( t, false );
	if( transport )
	    transport->SetPortParser(GetPortParser());
	return transport;
}

# if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_DARWIN)
// returns -1 or error or a valid socket fd on success
socketfd_t
NetTcpEndPoint::OpenUnixSocket( const StrBuf &sockName, Error &e )
{
	//NET_ENTER();
	struct sockaddr_un sockAddr;
	socketfd_t        sock = -1;
	int count = 1;
	StrBuf buf;

	//TRANSPORT_PRINTF( DEBUG_CONNECT, "OpenUnixSocket socket filename is: \"%s\"",
	//        sockName.Text() );
	// Verify that we have gotten the filename for the socket
	if ( sockName.Length() == 0 )
	{
	    e.Set(MsgRpc::UnixDomainOpen) << "open" << "invalid filename";
	    //NET_DUMP_ERROR( e );
	    return -1;
	}

	sock = socket( PF_UNIX, SOCK_STREAM, 0 );
	if( sock < 0 )
	{
	    StrBuf buf;
	    Error::StrError(buf);
	    e.Set(MsgRpc::UnixDomainOpen) << "socket" << buf;
	    //NET_DUMP_ERROR( e );
	    return -1;
	}

	memset( &sockAddr, 0, sizeof(struct sockaddr_un) );

	sockAddr.sun_family = AF_UNIX;
	memcpy( sockAddr.sun_path,
	            sockName.Text(),
	            sockName.Length() );
	sockAddr.sun_path[ sockName.Length() ] = '\0';

	//TRANSPORT_PRINTF( DEBUG_CONNECT, "OpenUnixSocket socket filename is: \"%s\"",
	//        sockName.Text() );
	while( connect( sock,
	        (struct sockaddr *) &sockAddr,
	        sizeof(struct sockaddr_un) ) != 0 && (count++ < 10))
	{
	    if( errno == ECONNREFUSED || errno == ENOENT )
	    {
	        sleep(1);
	        continue;
	    }
	    Error::StrError(buf);
	    e.Set(MsgRpc::UnixDomainOpen) << "connect" << buf;
	    //NET_DUMP_ERROR( e );
	    return -1;
	}
	if( count >= 10 )
	{
	    Error::StrError(buf);
	    e.Set(MsgRpc::UnixDomainOpen) << "connect" << buf;
	    //NET_DUMP_ERROR( e );
	    return -1;
	}

	return sock;
}
# endif // OS_LINUX || OS_MACOSX || OS_DARWIN