netstd.cc #1

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

/*
 * netstd.cc - stdio driver for NetConnect, for use with inetd
 *
 * Classes Defined:
 *
 *	NetStdioEndPoint - a stdio subclass of NetEndPoint
 *	NetStdioTransport - a stdio subclass of NetTransport
 *
 * The server half of this is simple: read/write stdin/stdout.
 * On UNIX, we use stdin for both reading/writing, oddly enough, 
 * to free up stdout for debugging messages.  This works because
 * stdin is a socket passed from inetd or from our own client half.
 * On NT, we split stdin/stdout (and you can't turn on debug msgs).
 *
 * The client half is more complicated. On UNIX, fork a child whose 
 * fds 0/1 are at one end of a bidirectional socket, and we read
 * and write from the other.  On NT, we use a pair of pipes, but
 * without fork() we have to adjust stdin/stdout before the spawn
 * and then reset it after.
 */

# define NEED_ERRNO
# define NEED_FILE
# define NEED_FCNTL
# define NEED_IOCTL
# define NEED_SIGNAL
# define NEED_SOCKETPAIR

# ifdef OS_NT
// so we get only winsock2, not both winsock and winsock2
# define WIN32_LEAN_AND_MEAN
# endif // OS_NT

# include <stdhdrs.h>
# include <error.h>
# include <strbuf.h>

# include <debug.h>
# include <strops.h>
# include <runcmd.h>
# include <bitarray.h>

# include <keepalive.h>
# include "netportparser.h"
# include "netaddrinfo.h"
# include "netutils.h"
# include "netconnect.h"
# include "netstd.h"
# include "netdebug.h"
# include <netselect.h>
# include <msgrpc.h>

/*
 * NetStdioEndPoint
 */

NetStdioEndPoint::NetStdioEndPoint( bool separateFDs, Error *e )
: soloFD(!separateFDs)
{
	s = -1;
	rc = 0;
	isAccepted = false;

	// WSAStartup()
	if( int err = NetUtils::InitNetwork() )
	{
	    StrNum errnum( err );
	    e->Net( "Network initialization failure", errnum.Text() );
	}
}

NetStdioEndPoint::~NetStdioEndPoint()
{
	// WSACleanup()
	NetUtils::CleanupNetwork();
	delete rc;
}

void
NetStdioEndPoint::Listen( Error *e )
{
	isAccepted = true;
	// Block SIGPIPE so a departed client doesn't blast us.
	// Block SIGINT, too, so ^C doesn't blast us.

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

# ifdef HAVE_SOCKETPAIR
	// redirect stdout to stderr for debugging
	if( soloFD )	// don't merge FDs for java
	    dup2( 2, 1 );
# endif
}

int
NetStdioEndPoint::CheaterCheck( const char *port )
{
	return 0;
} 

void
NetStdioEndPoint::ListenCheck( Error *e )
{
}

void
NetStdioEndPoint::Unlisten()
{
}


/*
 * NetStdioTransport
 */

NetTransport *
NetStdioEndPoint::Accept( Error *e )
{
# ifdef HAVE_SOCKETPAIR
	// talk both ways via stdin
	return new NetStdioTransport( 0, (soloFD ? 0 : 1), true );
# else
	// separate stdin/stdout
# ifdef OS_NT
	setmode( 0, O_BINARY );
	setmode( 1, O_BINARY );
# endif
	return new NetStdioTransport( 0, 1, true );
# endif
}

# if defined( HAVE_SOCKETPAIR ) || defined( OS_NT ) && !defined( __MWERKS__ )

# define GOT_CONNECTED

NetTransport *
NetStdioEndPoint::Connect( Error *e )
{
	int p[2];
	StrBuf cmd = GetPortParser().Host();

	DEBUGPRINTF( DEBUG_CONNECT, "NetStdioEndPoint: cmd='%s'", cmd.Text() );

	RunArgs args( cmd );

	// XXX RunCommand is dynamically allocated
	// to work around linux 2.5 24x86 compiler bug.
	// See job019111

	rc = new RunCommand;
	int	opts = soloFD ? RCO_SOLO_FD|RCO_P4_RPC : RCO_P4_RPC;
	rc->RunChild( args, opts, p, e );

	if( e->Test() )
	    return 0;

	return new NetStdioTransport( p[0], p[1], false );
}

# endif

# ifndef GOT_CONNECTED

NetTransport *
NetStdioEndPoint::Connect( Error *e )
{
	e->Set( MsgRpc::Stdio );
	return 0;
}

# endif

StrPtr *
NetStdioEndPoint::GetListenAddress( int f )
{
	addr.Set( "unknown" );
        return &addr;
}

/*
 * NetStdioTransport
 */


NetStdioTransport::NetStdioTransport( int r, int s, bool isAccept  )
: isAccepted( isAccept )
{ 
	this->r = r;
	this->t = s;
	breakCallback = 0;

	selector = new NetTcpSelector( r );
}

NetStdioTransport::~NetStdioTransport() 
{ 
	Close(); 

	delete selector;
}

void
NetStdioTransport::Close( void )
{
	if( r >= 0 ) close( r );
	if( t != r && t >= 0 ) close( t );
	r = t = -1;
}

StrPtr *
NetStdioTransport::GetAddress( int f )
{
	addr.Set( "unknown" );
        return &addr;
}

StrPtr *
NetStdioTransport::GetPeerAddress( int f )
{
	addr.Set( "unknown" );
        return &addr;
}

void
NetStdioTransport::Send( const char *buffer, int length, Error *e )
{
	DEBUGPRINTF( DEBUG_TRANS, "NetStdioTransport send %d bytes", length );

	if( write( t, buffer, length ) != length )
	{
	    e->Sys( "write", "socket stdio" );
	    e->Set( MsgRpc::TcpSend );
	}
}

int
NetStdioTransport::Receive( char *buffer, int length, Error *e )
{
	if( breakCallback )
	    for(;;)
	{

#ifdef OS_NT

	    DWORD readable = 1;

	    // 500 is .5 seconds.

	    const int tv = 500;

	    bool res = PeekNamedPipe( (HANDLE)_get_osfhandle( r ),
	                              NULL, 0, NULL, &readable, NULL );
	    if( res && !readable )
	        Sleep( tv );

	    if( !res )
	    {
	        DWORD dwError = GetLastError();

	        if( dwError != ERROR_BROKEN_PIPE &&
	            dwError != ERROR_PIPE_NOT_CONNECTED &&
	            dwError != ERROR_INVALID_HANDLE )
	        {
	            e->Sys( "PeekNamedPipe", "stdio" );
	            return 0;
	        }
	    }

#else

	    int readable = 1;
	    int writable = 0;

	    // 500000 is .5 seconds.

	    const int tv = 500000;

	    if( selector->Select( readable, writable, tv ) < 0 )
	    {
		e->Sys( "select", "socket stdio" );
		return 0;
	    }

#endif

	    // Before checking for data do the callback isalive test.
	    // If the user defined IsAlive() call returns a zero
	    // value then the user wants this request to terminate.

	    if( !breakCallback->IsAlive() )
	    {
		e->Set( MsgRpc::Break );
		return 0;
	    }

	    if( readable )
		break;
	}

	int l = read( r, buffer, length );

	if( l < 0 )
	{
	    e->Sys( "read", "socket stdio" );
	    e->Set( MsgRpc::TcpRecv );
	}

	DEBUGPRINTF( DEBUG_TRANS, "NetStdioTransport recv %d bytes", l );

	return l;
}


# ifdef OS_NT

int
NetStdioTransport::IsAlive()
{
	DWORD readable = 1;
	return PeekNamedPipe( (HANDLE)_get_osfhandle( r ),
	                      NULL, 0, NULL, &readable, NULL ) ? 1 : 0;
}

# else

int
NetStdioTransport::IsAlive()
{ 
	int readable = 1;
	int writeable = 0;

	if( selector->Select( readable, writeable, 0 ) < 0 )
	    return 0;

	// All good if no EOF waiting

	return !readable || selector->Peek();
}

# endif