/*

* 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: 

* CScsSession implementation.	 See class and function definitions

* for more detail.

*

*/

/**

 @file

*/

#include <scs/scsserver.h>

#include "scsserverconstants.h"

EXPORT_C void CScsSession::ConstructL()

/**

	The subsession [handle] container could be constructed

	here, but that is deferred until the subsession is allocated to

	avoid the memory overhead for sessions which may not require

	subsessions.

 */

	{

	iServer.IncrementSessionCount();

	}

EXPORT_C CScsSession::CScsSession(CScsServer &aServer)

	: iServer(aServer)

/**

   Setup the iServer member variable so it can be used during construction

 */

	{

	}

EXPORT_C CScsSession::~CScsSession()

/**

	Deletes any subsessions.

	Deletes any outstanding requests.

	Decrements the server's session count so the server can be shut down

	if there are no open sessions.

 */

	{

	iServer.CancelOutstandingRequests(this, /* aCompleteClientRequests */ EFalse);

	DeleteSubsessionContainers();	// closes any remaining subsessions

	// decrement the session count, so the server can be shut down if

	// there are no more open sessions.

	iServer.DecrementSessionCount();

	}

EXPORT_C void CScsSession::CloseAllSubsessionsL()

	{

	DeleteSubsessionContainers();

	}

EXPORT_C void CScsSession::ServiceL(const RMessage2& aMessage)

/**

	Implement CSession2 by handling any SCS-specific messages, and

	otherwise delegating to the subclass' implementation.

	@param	aMessage		Standard server-side message object.

 */

	{

	ScsImpl::TScsFunction scsFunc;

	TInt implFunc;

	ScsImpl::ExtractScsAndImplFunctions(aMessage, &scsFunc, &implFunc);

	TBool completeMessage = ETrue;

	switch (scsFunc)

		{

	// sessions

	case ScsImpl::ECallSessionFunc:

		completeMessage = DoServiceL(implFunc, aMessage);

		break;

	case ScsImpl::EPreCloseSession:

		PreCloseSession();

		break;

	case ScsImpl::ECancelSessionFunc:

		CancelAsyncSessionRequestL(implFunc);

		break;

	case ScsImpl::EGetServerPid:

		{

		TPckgBuf<TProcessId> idBuf;

		RProcess proc;

		idBuf() = proc.Id();

		aMessage.WriteL(0, idBuf);

		break;

		}

	case ScsImpl::EShutdownAsap:

		iServer.ShutdownWhenIdleL();

		break;

	// subsessions

	case ScsImpl::ECreateSubsession:

		// if there are no open subsessions before this attempt then clean up

		// the containers if it fails.	This is to ensure the server heap balances

		// in the event of failure.

		iPreCreateSubsessionCount = iSsHandles ? iSsHandles->ActiveCount() : 0;

		CreateSubsessionL(implFunc, aMessage);

		break;

	case ScsImpl::ECloseSubsession:

		CloseSubsessionL(aMessage);

		break;

	case ScsImpl::ECallSubsessionFunc:

		completeMessage = CallSubsessionFunctionL(implFunc, aMessage);

		break;

	case ScsImpl::ECancelSubsessionFunc:

		CancelAsyncSubsessionRequestL(implFunc, aMessage);

		break;

	// server heap testing

	case ScsImpl::EUHeapSetFail:

#ifdef _DEBUG

		iServer.DoPreHeapMarkOrCheckL();

		__UHEAP_MARK;

		__UHEAP_SETFAIL(RAllocator::EDeterministic, aMessage.Int0());

		iServer.DoPostHeapMarkOrCheckL();

#endif

		break;

	case ScsImpl::EUHeapResetFail:

#ifdef _DEBUG

		iServer.DoPreHeapMarkOrCheckL();

		__UHEAP_RESET;

		__UHEAP_MARKEND;

		iServer.DoPostHeapMarkOrCheckL();

#endif

		break;

	// unrecognized SCS code, so fail with KErrNotSupported

	default:

		User::Leave(KErrNotSupported);

		}

	// None of the delegate functions have left so complete with KErrNone.

	if(completeMessage)

		{

		aMessage.Complete(KErrNone);

		}

	}

EXPORT_C void CScsSession::ServiceError(const RMessage2& aMessage, TInt aError)

/**

	Override CSession2 by handling any leave which occurred during the ServiceL.

	Panick the client if the leave is because of a bad descriptor or subsession

	handle.	 Otherwise, complete the request with the error code.

	@param	aMessage		Message which caused leave to occur.

	@param	aError			Leave code.	 This is a Symbian OS error code.

	@see CSession2::ServiceError

 */

	{

	// if failed to create first subsession then free containers so heap

	// balances after message has been completed.

	ScsImpl::TScsFunction scsFunc;

	ScsImpl::ExtractScsAndImplFunctions(aMessage, &scsFunc, NULL);

	if (scsFunc == ScsImpl::ECreateSubsession && iPreCreateSubsessionCount == 0)

		DeleteSubsessionContainers();

	switch (aError)

		{

	case KErrBadDescriptor:

		PanicClient(aMessage, ScsImpl::EScsClBadDesc);

		break;

	case KErrBadHandle:

		PanicClient(aMessage, ScsImpl::EScsClBadHandle);

		break;

	case KErrScsAsyncAlreadyQueued:

		PanicClient(aMessage, ScsImpl::EScsClAsyncAlreadyQueued);

		break;

	default:

		aMessage.Complete(aError);

		break;

		}

	}

// -------- session close --------

void CScsSession::PreCloseSession()

/**

	This function is invoked from RScsClientBase::Close

	just before the session is closed, to cancel any

	outstanding requests.

 */

	{

	iServer.CancelOutstandingRequests(this, /* aCompleteClientRequests */ ETrue);

	}

// -------- asynchronous requests --------

void CScsSession::CancelAsyncSessionRequestL(TInt aFunction)

/**

	This function is called when handling an ECancelSessionFunction message.

	If the outstanding function cannot be found, this function does nothing.

	@param aFunction		Implementation function without SCS code.

 */

	{

	iServer.CancelAsyncRequest(this, /* aSubsession */ 0, aFunction);

	}

// -------- subsessions --------

CScsSubsession* CScsSession::GetSubsessionL(const RMessage2& aMessage)

/**

	Extract subsession handle from the supplied message and return

	a pointer to the corresponding subsession object.

	@param	aMessage		Standard server-side message object.  The fourth

							argument is the subsession handle.

	@return					Pointer to corresponding subsession object.

	@leave					KErrBadHandle if the handle does not identify a

							current subsession.

 */

	{

	TInt handle = aMessage.Int3();

	CObject* obj = iSsHandles->AtL(handle);	// leaves with KErrBadHandle if not found

	return static_cast<CScsSubsession*>(obj);

	}

void CScsSession::DeleteSubsessionContainers()

/**

	Free the handle and object containers which this session uses

	to manage subsessions.	It is safe to call this function if the

	containers were not set up successfully.

 */

	{

	delete iSsHandles;

	iSsHandles = 0;

	if (iSsObjects != 0)

		{

		iServer.iContainerIndex->Remove(iSsObjects);

		iSsObjects = 0;

		}

	}

void CScsSession::CreateSubsessionL(TInt aFunction, const RMessage2& aMessage)

/**

	Attempt to allocate a subsession object for this session.  The actual

	subsession allocation is delegated to the subclass's implementation

	of DoCreateSubsessionL.	 If the subclass has not reimplemented this

	function, then default implementation leaves with KErrNotSupported.

	@param	aFunction		Function identifier without SCS code.

	@param	aMessage		Standard server-side message object.

 */

	{

	// if this is the first subsession then create the object container and index

	if (iSsObjects == 0)

		{

		iSsObjects = iServer.iContainerIndex->CreateL();

		iSsHandles = CObjectIx::NewL();

		}

	CScsSubsession* ss = DoCreateSubsessionL(aFunction, aMessage);

	CleanupClosePushL(*ss);

	iSsObjects->AddL(ss);

	TInt handle = iSsHandles->AddL(ss);

	CleanupStack::Pop(ss);

	TPckg<TInt> handlePckg(handle);

	TInt r = aMessage.Write(3, handlePckg);

	User::LeaveIfError(r);

	}

#ifdef _BullseyeCoverage

static const char * const bull1="BullseyeCoverage save off";

#endif

EXPORT_C CScsSubsession* CScsSession::DoCreateSubsessionL(TInt aFunction, const RMessage2& aMessage)

/**

	This default implementation leaves with KErrNotSupported.  The subclass

	does not have to supply its own implementation unless it actually wants

	to support subsessions.

	@param	aFunction		Function identifier without SCS code.  The subclass

							implementation of this function would use this to decide

							what kind of subsession object to create.

	@param	aMessage		Client message.	 Not used.

	@leave					KErrNotSupported.

 */

	{

	(void) aFunction;

	(void) aMessage;

	User::Leave(KErrNotSupported);	

	/*lint -unreachable*/ // Avoid compiler warning and keep lint happy

	return 0;	

	}

#ifdef _BullseyeCoverage

static const char * const bull2="BullseyeCoverage restore";

#endif

void CScsSession::CloseSubsessionL(const RMessage2& aMessage)

/**

	Delete the subsession identified in the supplied message.

	If the subsession cannot be found this function leaves with KErrBadHandle,

	and the client is panicked in ServiceError.

	@param	aMessage		Standard server-side message handle.  The fourth

							integer contains the subsession handle.

 */

	{

	TInt handle = aMessage.Int3();

	CObject* obj = iSsHandles->AtL(handle);	// leaves with KErrBadHandle if not found

	CScsSubsession* ss = static_cast<CScsSubsession*>(obj);

	iServer.CancelOutstandingRequests(this, ss, /* aCancelClientRequests */ ETrue);

	iSsHandles->Remove(handle);

	// close the container objects to ensure the heap balances when the last subsession is closed

	if (iSsHandles->ActiveCount() == 0)

		DeleteSubsessionContainers();

	}

TBool CScsSession::CallSubsessionFunctionL(TInt aFunction, const RMessage2& aMessage)

/**

	Pass the supplied function identifier and message to the subsession

	which is identified in the message.

	If the subsession cannot be found this function leaves with KErrBadHandle,

	and the client is panicked in ServiceError.

	@param	aFunction		Function identifier without SCS code.

	@param	aMessage		Client message.

	@return ETrue means complete client request now.

 */

	{

	CScsSubsession* ss = GetSubsessionL(aMessage);

	return ss->DoServiceL(aFunction, aMessage);

	}

void CScsSession::CancelAsyncSubsessionRequestL(TInt aFunction, const RMessage2& aMessage)

/**

	Cancel an outstanding asynchronous request for the subsession

	identified in the supplied message.

	@param	aFunction		Function identifier without SCS code.

	@param	aMessage		Standard server-side message handle.  The fourth

							integer contains the subsession handle.

 */

	{

	CScsSubsession* ss = GetSubsessionL(aMessage);

	iServer.CancelAsyncRequest(this, ss, aFunction);

	}