client.h #1

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

/*
 * Client - the Perforce client, implemented as an RPC service
 *
 * Basic flow:
 *
 *	ClientUser ui;
 *	Client client;
 *
 *	client.SetProtocol( "gui", "1" ); // optional
 *	client.Dispatcher( &dispatchTable ); // optional
 *
 *	// SetPort() must happen _before_ the Init().
 *
 *	client.SetPort( somefunctionof( client.GetPort() ) ); //optional
 *
 *	client.Init( e );
 *
 *	// GetClient() must happen _after_ the Init().
 *
 *	client.SetClient( somefunctionof( client.GetClient() ) ); //optional
 *	client.SetCwd( somefunctionof( client.GetCwd() ) ); //optional
 *	client.SetUser( somefunctionof( client.GetUser() ) ); //optional
 *
 *	while( !client.Dropped() )
 *	{
 *	    client.SetArgv( argc, argv )
 *	    client.Run( func, &ui )
 *	}
 *
 *	return client.Final( e );
 *
 * Public methods:
 *
 *	Client::Init() - establish connection and prepare to run commands.
 *
 *	Client::Run() - run a single command, assuming arguments have
 *		already been set up.
 *
 *	Client::RunTag() - run a single command (potentially) asynchronously.
 *
 *	Client::WaitTag() - wait for a RunTag()/all RunTag()s to complete.
 *
 *	Client::Final() - clean up end of connection, returning error count.
 *
 *	Client::Dispatcher() - just a shortcut to the service dispatcher.
 *
 *	Client::SetProtocol() - just a shortcut to the service SetProtocol.
 *
 *	Client::SetCharset()
 *	Client::SetClient()
 *	Client::SetCwd()
 *	Client::SetHost()
 *	Client::SetLanguage()
 *	Client::SetPassword()
 *	Client::SetPort()
 *	Client::SetUser() - set current directory, client, host, port, or 
 *		user, overridding all defaults.  SetPort() must be called 
 *		before Init() in order to take effect.  The others must be 
 *		set before Run() to take effect.
 *
 *		SetCwd() additionally searches for a new P4CONFIG file.
 *
 *	Client::DefineCharset()
 *	Client::DefineClient()
 *	Client::DefineHost()
 *	Client::DefineLanguage()
 *	Client::DefinePassword()
 *	Client::DefinePort()
 *	Client::DefineUser() - sets client, port, or user in the registry
 *		and (so as to take permanent effect) then calls SetClient(),
 *		etc. to take immediate effect.
 *
 *	Client::GetBuild()
 *	Client::GetCharset()
 *	Client::GetClient()
 *	Client::GetCwd()
 *	Client::GetHost()
 *	Client::GetLanague()
 *	Client::GetOs()
 *	Client::GetPassword()
 *	Client::GetPort()
 *	Client::GetUser() - get current directory, client, OS, port or user,
 *		as determined by defaults or by corresponding set value.
 *		GetClient()/GetHost() are not valid until after Init() 
 *		establishes the connection, because the hostname of the 
 *		local endpoint may serve as the default client name.
 *
 *	Client::GetConfig() - get the filename pointed to by P4CONFIG, as
 *		determined by enviro::Config().
 *
 *	Client::GetEnv() - set the cwd/client/host/os/user variables (using
 *		Rpc::SetVar() call).  These variables are needed by just
 *		about all calls (via Rpc::Invoke()) to the server.
 *
 *	Client::Confirm() - copy all recv vars to send vars, excluding 
 *		'data' and 'func', and Invoke() the named func.
 *
 *	Client::SetError() - bumps an error counter, whose value is 
 *		returned by GetErrors().  Used by OutputError() to
 *		track any errors returned by the server.
 *
 *	Client::GetErrors() - returns error count of times OutputError()
 *		has been called, so that the client's main routine can
 *		exit non-zero if errors occurred.
 *
 *	Client::OutputError() - a gentle way of reporting an error, rather
 *		than having to blurted out by Rpc::Dispatch().
 */

const int ClientTags = 4; // max pending RunTags()

class ClientUser;
class CharSetCvt;
class Ignore;
class Enviro;

enum EnvVarType
{
	VAR_P4USER =	0x0001,   // P4USER
	VAR_P4CLIENT =	0x0002,   // P4CLIENT
	VAR_P4PORT =	0x0004,   // P4PORT
	VAR_P4PASSWD =	0x0008    // P4PASSWD
} ;

class Client : public Rpc {

    public:
	// caller's main interface

			Client( Enviro * = 0 );
			~Client();

	void		SetTrans( int output, int content = -2,
				int fnames = -2, int dialog = -2 );
	int		GuessCharset();
	int		ContentCharset();

	void		Init( Error *e );
	void		Run( const char *func, ClientUser *ui );
	int		Final( Error *e );

	// alternative async Run() interface

	void		RunTag( const char *func, ClientUser *ui );
	void		WaitTag( ClientUser *ui = 0 );

	void		SetArgv(int ac, char * const * av);

    public:
	// for fine tuning caller's use

	void		SetCharset( const StrPtr *c ) { charset.Set( c ); }
	void		SetClient( const StrPtr *c ) { client.Set( c ); }
	void		SetClientPath( const StrPtr *c )
	                { clientPath.Set( c ); }
	void		SetCwd( const StrPtr *c );
	void		SetCwdNoReload( const StrPtr *c ) { cwd.Set( c ); }
	void		SetHost( const StrPtr *c ) { host.Set( c ); }
	void		SetIgnoreFile( const StrPtr *c ) { ignorefile.Set( c ); }
	void		SetLanguage( const StrPtr *c ) { language.Set( c ); }
	void		SetPort( const StrPtr *c ) { port.Set( c ); }
	void		SetProg( const StrPtr *c );
	void		SetVersion( const StrPtr *c );

	void		SetPassword( const StrPtr *c )
	    { password.Set( c ); password2.Set( c ); ticketKey.Clear(); authenticated = 0; }

	void		SetUser( const StrPtr *c ) 
			{ user.Set( c ); authenticated = 0; }

	void		SetTicketFile( const StrPtr *c )
			{ ticketfile.Set( c ); }

	void		SetTrustFile( const StrPtr *c ) { trustfile.Set( c ); }
	void		SetEnviroFile( const StrPtr *c )
	    { if( c ) SetEnviroFile( c->Text() ); }

	void		SetCharset( const char *c ) { charset.Set( c ); }
	void		SetClient( const char *c ) { client.Set( c ); }
	void		SetCwd( const char *c );
	void		SetCwdNoReload( const char *c ) { cwd.Set( c ); }
	void		SetHost( const char *c ) { host.Set( c ); }
	void		SetIgnoreFile( const char *c ) { ignorefile.Set( c ); }
	void		SetLanguage( const char *c ) { language.Set( c ); }
	void		SetPort( const char *c ) { port.Set( c ); }
	void		SetProg( const char *c );
	void		SetVersion( const char *c );
	void		SetExecutable( const char *c ) { exeName.Set( c ); }

	void		SetPassword( const char *c ) 
	    { password.Set( c ); ticketKey.Clear(); authenticated = 0; }

	void		SetUser( const char *c ) 
			{ user.Set( c ); authenticated = 0; }

	void		SetTicketFile( const char *c )
			{ ticketfile.Set( c ); }

	void		SetTrustFile( const char *c ) { trustfile.Set( c ); }

	void		SetEnviroFile( const char *c );

	void		SetInitRoot( const char *c ) { initRoot.Set( c ); }

	void		SetServerID( const char *c )
	                { serverID.Set( c ); }

	void		DefineCharset( const char *c, Error *e );
	void		DefineClient( const char *c, Error *e );
	void		DefineHost( const char *c, Error *e );
	void		DefineIgnoreFile( const char *c, Error *e );
	void		DefineLanguage( const char *c, Error *e );
	void		DefinePassword( const char *c, Error *e );
	void		DefinePort( const char *c, Error *e );
	void		DefineUser( const char *c, Error *e );

	const StrPtr	&GetCharset();
	const StrPtr	&GetClient();
	const StrPtr	&GetClientNoHost();
	const StrPtr	&GetClientPath();
	const StrPtr	&GetCwd();
	const StrPtr	&GetHost();
	const StrPtr	&GetLanguage();
	const StrPtr	&GetOs();
	const StrPtr	&GetPassword();
	const StrPtr	&GetPassword2();
	const StrPtr	&GetPort();
	const StrPtr	&GetUser();
	const StrPtr	&GetTicketFile();
	const StrPtr	&GetTrustFile();
	const StrPtr	&GetConfig();
	const StrPtr	&GetLoginSSO();
	const StrPtr	&GetSyncTrigger();
	const StrPtr	&GetIgnoreFile();
	const StrPtr	&GetInitRoot();
	const StrPtr	&GetBuild() { return buildInfo; }
	const StrPtr	&GetExecutable() { return exeName; }

	void		SetIgnorePassword() 
			{ ignoreList |= VAR_P4PASSWD; }

	int		IsIgnorePassword()
			{ return ( ignoreList & VAR_P4PASSWD ); }

	void		SetProtocol( const char *p, const char *v )
			{ service.SetProtocol( p, v ); }

	void		SetProtocol( const char *p )
			{ service.SetProtocol( p ); }

	void		SetProtocolV( const char *arg )
			{ service.SetProtocolV( arg ); }

	void		Dispatcher( RpcDispatch *d )
			{ service.Dispatcher( d ); }

    public:
	// for use by the client service implementation

	void		GetEnv();
	Enviro*		GetEnviro() { return enviro; }
	const StrPtr *	GetEnviroFile();
	Ignore*		GetIgnore() { return ignore; }
	void		Confirm( const StrPtr *confirm );
	ClientUser *	GetUi() { return tags[ lowerTag ]; }

	void		SetError() { errors++; }
	int		GetErrors() { return errors; }
	void		SetFatal() { fatals++; }
	int		GetFatals() { return fatals; }
	
	void		OutputError( Error *e );

	Handlers	handles;

	void		NewHandler();
	CharSetCvt	*fromTransDialog, *toTransDialog;
        StrDict		*translated, *transfname;
	int		unknownUnicode;
	int		content_charset; // file content charset
	int		output_charset;  // result output charset
 
	void		VSetVar( const StrPtr &var, const StrPtr &val );

	int		protocolXfiles;	// 'xfiles' protocol
	int		protocolNocase;	// 'nocase' protocol
	int		protocolSecurity;  // server 'security' protocol
	int		protocolUnicode;	// server 'unicode' protocol

        StrPtr *	GetProtocol( const StrPtr &var );

	void		SetSecretKey( StrPtr &s ) { secretKey.Set( s ); }
	void		ClearSecretKey() { secretKey.Clear(); }
	StrPtr *	GetSecretKey() { return( &secretKey ); }
	void		SetPBuf( StrPtr &s ) { pBuf.Set( s ); }
	void		ClearPBuf() { pBuf.Clear(); }
	StrPtr *	GetPBuf() { return( &pBuf ); }

	void		SetTicketKey( const StrPtr *s ) { ticketKey.Set( *s ); }

        int             IsUnicode() { return is_unicode; }

	void		SetSyncTime( int t ) { syncTime = t; }
	int		GetSyncTime()        { return syncTime; }

	int		ServerDVCS() { return protocolServer >= 39; }

    public:
	// Old closure stuff, only used by scc api and to be retired

	void		*GetClosure() { return closure; }
	void		SetClosure( void *v ) { closure = v; }
	void		*closure;

    protected:
	virtual RpcType	GetRpcType()
	{
	    return RPC_CLIENT;
	}

    private:
	ClientUser	*tags[ClientTags];
	int		lowerTag;
	int		upperTag;
	int		authenticated;
	int		pubKeyChecked;

	RpcService	service;
	int		errors;
	int		fatals;

	StrBuf		charset;	// character set
	StrBuf		client;		// client's name
	StrBuf		clientPath;	// Authorized areas of the filesystem
	StrBuf		cwd;		// current directory
	StrBuf		host;		// client host name
	StrBuf		os;		// client's OS
	StrBuf		programName;	// (optionally) set by SetProg()
	StrBuf		port;		// server address (P4PORT)
	StrBuf		serverID;	// server address (ID from server)
	StrBuf		user;		// user's name
	StrBuf		password;	// user's password
	StrBuf		password2;	// user's password (password is ticket)
	StrBuf		ticketKey;	// key used to look up ticket
	StrBuf		language;	// language for err messages
	StrBuf		ticketfile;	// alternate location for ticketfile
	StrBuf		trustfile;	// trusted finger print file
	StrBuf		secretKey;	// for salting password key
	StrBuf		pBuf;		// for salting password key
	StrBuf		loginSSO;	// single signon binary
	StrBuf		syncTrigger;	// sync trigger binary
	StrBuf		ignorefile;	// ignore filename
	StrBuf		exeName;
	StrBuf		charsetVar;
	StrBuf		initRoot;
	StrRef		buildInfo;

	Enviro		*enviro;	// environment vars
	Ignore		*ignore;	// naughty list
	int      	ignoreList;	// environment vars to ignore
	int		is_unicode;	// talking in unicode mode
	int		hostprotoset;
	int		syncTime;
	int		ownEnviro;

	StrNum		protocolBuf;	// for our GetProtocol

	void		CleanupTrans();	// free translators
	void		SetupUnicode( Error * );
	void		LearnUnicode( Error * );
	void		LateUnicodeSetup( const char *, Error * );
} ;