/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

* Generic client-side code for client-server interaction.

* Attempts to establish a connection to a session counting server,

* starting the process if required.

*

*/

/**

 @file

*/

#include <scs/scsclient.h>

#include <scs/scscommon.h>

using namespace ScsImpl;

EXPORT_C RScsClientBase::RScsClientBase()

/**

	This constructor is protected to ensure this class is not

	instantiated directly.

 */

:	RSessionBase()

	{

	// empty.

	}

EXPORT_C void RScsClientBase::Close()

/**

	This method should be used in preference to RScsSessionBase::Close

	because it sends a message to cancel any outstanding requests on the

	session or its subsessions.

 */

	{

	if(iHandle)

		{

		RSessionBase::SendReceive(EPreCloseSession);

		RSessionBase::Close();

		}

	}

TInt RScsClientBase::StartServerProcess(const TDesC& aExeName, const TUidType& aFullExeUid)

/**

	This function is defined for the convenience of subclasses which need to start

	a server process before they can connect to the server.

	@param	aExeName		Executable which hosts the server.

	@param	aFullExeUid		The server executable's full UID.  This is used to ensure the

							intended executable is started, and not another executable

							with the same name.

	@return					Symbian OS error code.  KErrNone indicates success, and any other

							value indicates failure.

	@pre This function should only be called by Connect(const TVersion&) if the server is

		not already running.

 */

	{

	RProcess pr;

	TInt r = pr.Create(aExeName, /* aCommand */ KNullDesC, aFullExeUid);

	if (r != KErrNone)

		return r;

	TRequestStatus rs;

	pr.Rendezvous(rs);

	if (rs != KRequestPending)

		r = rs.Int();

	else

		{

		pr.Resume();

		User::WaitForRequest(rs);

		if (rs.Int()==KErrAlreadyExists)

			r=KErrAlreadyExists;

		else

			r = (pr.ExitType() == EExitPending) ? rs.Int() : KErrGeneral;

		}

	pr.Close();

	return r;

	}

EXPORT_C TInt RScsClientBase::Connect(

	const TDesC& aSvrName, const TVersion& aReqVer, const TDesC& aExeName, const TUidType& aFullExeUid)

/**

	Attempt to connect to the named server.  If the server is not available then attempt

	to start its hosting process.

	@param	aSvrName		Name of server to connect to.

	@param	aReqVer			Required server version.

	@param	aExeName		Executable which hosts the server.  This function will launch this

							executable if the server is not running.

	@param	aFullExeUid		The server executable's full UID.  This ensures the intended

							executable is started, and not another executable with the same name.

	@return					Symbian OS error code.  KErrNone indicates success,

							and any other value indicates failure.

 */

	{

	TInt retries = 2;		// number of remaining retries

	for (;;)

		{

		TInt r = CreateSession(aSvrName, aReqVer);

		// if connected then finished

		if (r == KErrNone)

			return r;

		// if any reason other than server not available then abort

		if (r != KErrNotFound && r != KErrServerTerminated)

			return r;

		if (--retries == 0)

			return r;

		r = StartServerProcess(aExeName, aFullExeUid);

		if (r != KErrNone && r != KErrAlreadyExists)

			return r;

		}	// for (;;)

	}

// -------- server heap checking --------

EXPORT_C TInt RScsClientBase::SetServerHeapFail(TInt aRate)

/**

	Start marking the server heap and set a deterministic

	fail rate.  This should matched with a call to EndServerHeapFail.

	This function is empty in release builds.

	@param	aRate			Number of allocations after which allocation

							should fail on the server heap.

	@see EndServerHeapFail

	@see __UHEAP_MARK

	@see __UHEAP_SETFAIL

 */

	{

#ifndef _DEBUG

	(void) aRate;

	return KErrNone;

#else

	TIpcArgs ipc(aRate);

	return RSessionBase::SendReceive(ScsImpl::EUHeapSetFail, ipc);

#endif

	}

EXPORT_C TInt RScsClientBase::ResetServerHeapFail()

/**

	Finish marking the server heap and reset the failure rate.

	This should match a previous call to SetServerHeapFail.

	If there is a heap imbalance, then the server will be panicked.

	This function is empty in release builds.

	@see SetServerHeapFail

	@see __UHEAP_MARKEND

	@see __UHEAP_RESET

 */

	{

#ifdef _DEBUG

	return RSessionBase::SendReceive(ScsImpl::EUHeapResetFail);	

#else

	return KErrNone;

#endif

	}

// -------- passing arguments to a server-side session --------

EXPORT_C TInt RScsClientBase::ShutdownServer()

/**

DEBUG USE ONLY - Tells the server to shutdown down ASAP, and block

until it has done so. This also closes the current session.

If the server is not configured to use a inactivity shutdown timer,

this will fail with KErrNotSupported.

nb. You may still need to call the Close function of a derived class

to ensure it gets to cleanup...

	@return					Symbian OS error code where KErrNone indicates

							success and any other value indicates failure.

 */

	{

	// Find servers PID

	TPckgBuf<TProcessId> idBuf;

	TIpcArgs args(&idBuf);

	TInt r = RSessionBase::SendReceive(ScsImpl::EGetServerPid, args);

	if(r != KErrNone) return r;

	// Open a handle for the server thread

	RProcess server;

	r = server.Open(idBuf(), EOwnerThread);

	if(r != KErrNone) return r;

	// Logon to the server process to spot when it exits

	TRequestStatus rs;

	server.Logon(rs);

	// Ask the server to exit ASAP

	r = RSessionBase::SendReceive(ScsImpl::EShutdownAsap);

	if(r != KErrNone)

		{

		(void) server.LogonCancel(rs);

		server.Close();

		return r;

		}

	// Close our session

	Close();

	// Wait for the server to finish shutting down

	User::WaitForRequest(rs); // nb. we do not care what code it shutdown with.

	// Close our server process handle

	server.Close();

	return KErrNone;

	}

// -------- passing arguments to a server-side session --------

EXPORT_C TInt RScsClientBase::CallSessionFunction(TInt aFunction) const

/**

	Send a command to the corresponding server-side session.  The

	subclass uses this function instead of directly calling

	RSubSessionBase::SendReceive because it adds the SCS code

	which marks this as an ordinary session call.

	@param	aFunction		Function identifier.  Bits 31:24 must be zero,

							because they are reserved for SCS commands.

	@return					Error code with which the server completed the request.

 */

	{

	__ASSERT_DEBUG(! ScsFieldUsed(aFunction), ClientSidePanic(EScsClNoArgsSessUsedScs));

	TInt f = ECallSessionFunc | aFunction;

	return RSessionBase::SendReceive(f);

	}

EXPORT_C TInt RScsClientBase::CallSessionFunction(TInt aFunction, const TIpcArgs& aArgs) const

/**

	Send a command to the corresponding server-side session.  The

	subclass uses this function instead of directly calling

	RSubSessionBase::SendReceive because it adds the SCS code which

	marks this as an ordinary session call.

	@param	aFunction		Session function identifier.  Bits 31:24 must be zero,

							because they are reserved for SCS commands.

	@param	aArgs			Standard IPC arguments.

	@return					Error code with which the server completed the request.

 */

	{

	__ASSERT_DEBUG(! ScsFieldUsed(aFunction), ClientSidePanic(EScsClArgsSessUsedScs));

	TInt f = ECallSessionFunc | aFunction;

	return RSessionBase::SendReceive(f, aArgs);

	}

EXPORT_C void RScsClientBase::CallSessionFunction(TInt aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus) const

/**

	Send the supplied function identifier and arguments to the server-side

	session.  The subclass uses this function instead of directly calling

	RSubSessionBase::SendReceive because it adds the SCS code which marks

	this as an ordinary session call.

	@param	aFunction		Session function identifier.  Bits 31:24 must be zero,

							because they are reserved for SCS commands.

	@param	aArgs			Standard IPC arguments.

	@param	aStatus			This will be completed by the server when it has

							finished handling the function.

 */

	{

	__ASSERT_DEBUG(! ScsFieldUsed(aFunction), ClientSidePanic(EScsClArgsSessAsyncUsedScs));

	TInt f = ECallSessionFunc | aFunction;

	RSessionBase::SendReceive(f, aArgs, aStatus);

	}

EXPORT_C void RScsClientBase::CancelSessionFunction(TInt aFunction) const

/**

	Cancel an outstanding session request.  This has no effect if the

	request is not outstanding.

	@param	aFunction		Implementation function.  This must be the

							same value that was supplied to CallSessionFunction.

 */

	{

	__ASSERT_DEBUG(! ScsFieldUsed(aFunction), ClientSidePanic(EScsClCancelSessUsedScs));

	TInt f = ECancelSessionFunc | aFunction;

	RSessionBase::SendReceive(f);

	}