/*

 * 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);

 	}