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

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "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:

 //

 #include "panic.h"

 #include "srvreqs.h"

 #include "sessmgr.h"

 #include "cachemgr.h"

 #include "srvsubsess.h"

 #include "srvsess.h"

 CServerSession::~CServerSession()

 	{

 	// Delete the subsession index.

 	delete iSubSessionIx;

 	//Delete the subsession container via the CObjectConIx's remove function  

 	((CSessionManager*)Server())->RemoveContainer(iContainer);

 	}

 //Called by client/server framework after session has been successfully created.

 //In effect, a second-phase constructor.

 //Creates the object index and the object container for this session.

 void CServerSession::CreateL()

 	{

 	// Create new object index

 	iSubSessionIx = CObjectIx::NewL();

 	// Initialize the object container

 	// using the object container index in the server.

 	iContainer = ((CSessionManager*)Server())->NewContainerL();

 	}

 //helper method to resolve and verify subsession using RMessage and subsession handle

 CServerSubSession* CServerSession::SubSessionFromHandle(const RMessage2& aMessage, TInt aHandle)

 	{

 	CServerSubSession* subSession = (CServerSubSession*)iSubSessionIx->At(aHandle);

 	if (subSession == NULL)

 	    {

 		PanicClient(EBadSubsessionHandle, aMessage);	    

 	    }

 	return subSession;

 	}

 // if ServiceL Leaves, execution resumes in this method.

 // this allows us to panic clients using bad descriptors, to deal with OOM conditions

 // and to fail transactions with the correct reason: OOM etc.

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

 	{

 	TServerRequest fn = static_cast<TServerRequest>(aMessage.Function());

 	// If we have failed during initialisation the subsession is no longer available.

 	// Perform additional cleanup by removing the subsession's handle from the server's 

 	// subsession index. 

 	if (fn == EInitialise)

 		{

 		// Retrieve handle

 		TPckgBuf<TInt> handlePckg;

 		TRAPD(res,aMessage.ReadL(3,handlePckg));

 		if (res == KErrNone)

 		 	{

 		 	TInt subSessionHandle = handlePckg();

 			iSubSessionIx->Remove(subSessionHandle);

 		 	}

 		#ifdef _DEBUG

 			else

 				{

 				RDebug::Print(_L("CServerSession::ServiceError - Can't remove subsession handle; aError = %d; res = %d"), aError, res); 

 				}   	

 		#endif 	 

 		}

 	//under following conditions the subsession handles the error

 	if(fn > EInitialise && fn < ELastInTable)

 		{

 		CServerSubSession* subSession = SubSessionFromHandle(aMessage, aMessage.Int3());

 		if(subSession)

 			{

 			subSession->ServiceError(aError);   

 			}

 		#ifdef _DEBUG

 			else

 				{

 				RDebug::Print(_L("CServerSession::ServiceError - bad subsession handle. aError = %d"), aError); 

 				}   	

 		#endif  

 		}

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS		

 	//for multi ROFS instead of leaving we panic the client instead

 	switch (aError)

 		{

 		case KErrMultiRofsOldCreUsed:

 			PanicClient(EMultiRofsPanicOldCre,aMessage);

 			return;

 		case KErrMultiRofsGlobalOverride:

 			PanicClient(EMultiRofsPanicGlobalOverride,aMessage);

 			return;

 		case KErrMultiRofsTypeOverride:

 			PanicClient(EMultiRofsPanicTypeOveride,aMessage);

 			return;

 		case KErrMultiRofsIllegalRofs:

 			PanicClient(EMultiRofsPanicIllegalRofs,aMessage);

 			return;				

 		}

 #endif				

 	CSession2::ServiceError(aMessage, aError);

 	}

 void CServerSession::ServiceL(const RMessage2& aMessage)

 	{

 	TServerRequest fn = static_cast<TServerRequest>(aMessage.Function());

 #if defined(__CENTREP_SERVER_PERFTEST__) || defined(__CENTREP_SERVER_MEMTEST__) || defined(__CENTREP_SERVER_CACHETEST__)

 	if (fn == EGetSetParameters)

 		{

 		TInt r = GetSetParameters(aMessage);

 		aMessage.Complete(r);

 		return;

 		}

 #endif

 	if(fn > ELastInTable)

 		{

 		PanicClient(EBadMessageNumber, aMessage);

 		}

 	CServerSubSession* subSession = NULL;

 #if defined (SYMBIAN_CENTREP_SUPPORT_MULTIROFS) && defined(CENTREP_TRACE)

 	TUint32 startTick=0;

 	TUid repUid;

 	startTick=User::FastCounter();

 #endif

 	PERF_TEST_EVENT_START(subSession, aMessage);

 	if(fn == EInitialise)

 		{

 		//create subsession

 		subSession = NewSubSessionL(aMessage);

 #if defined (SYMBIAN_CENTREP_SUPPORT_MULTIROFS) && defined(CENTREP_TRACE)		

 		repUid=TUid::Uid(aMessage.Int0());

 		subSession->iRepositoryUid=repUid;

 #endif		

 		}

 	else

 		{

 		subSession = SubSessionFromHandle(aMessage, aMessage.Int3());

 #if defined (SYMBIAN_CENTREP_SUPPORT_MULTIROFS) && defined(CENTREP_TRACE)

 		repUid=subSession->iRepositoryUid;

 #endif		

 		}

 	if(subSession)

 		{

 		TInt r = KErrNone;

 		if(fn == EClose)

 			{

 			//delete subsession	

 			DeleteSubSession(aMessage.Int3());

 			}

 		else

 			{

 			//ask subsession to handle the message

 			r = subSession->ServiceL(aMessage);

 			}

 		PERF_TEST_EVENT_END(subSession, aMessage);

 #if defined (SYMBIAN_CENTREP_SUPPORT_MULTIROFS) && defined(CENTREP_TRACE)

 		TUint32 endTick=User::FastCounter();

 		RDebug::Print(_L("[CENTREP],TimeStamp=,%d,Repository=,%x,Function=,%d,TickCount=,%d"),startTick,repUid.iUid,fn,endTick-startTick);

 #endif

 		if (r != CServerSubSession::KDontCompleteMessage)

 			{

 			aMessage.Complete(r);

 			}

 		}

 	//If (subsession == NULL) we don't need to complete the message, as the message is completed already when the client panicked

 	#ifdef _DEBUG   

 		else

 			{

 			RDebug::Print(_L("CServerSession::ServiceL - bad subsession handle. TServerRequest = %d"), fn); 

 			}

 	#endif

 	}

 //Creates a new subsession object, and writes its handle to the message.

 //A subsession object is the server side "partner" to the client side subsession.

 //On return last parameter of aMessage is filled with the handle of the subsession

 //and handle is also returned

 CServerSubSession* CServerSession::NewSubSessionL(const RMessage2& aMessage)

 	{

 	//create a new subsession

 	CServerSubSession* subSession = new (ELeave) CServerSubSession(this);

 	CleanupStack::PushL(subSession);

 	//add the subsession object to this session's object container to generate a unique ID

 	iContainer->AddL(subSession);

 	CleanupStack::Pop(subSession);

 	//add the object to the subsessions index, this returns a unique handle so that we can

 	//refer to the object later

 	TInt handle = iSubSessionIx->AddL(subSession);

 	//write the handle to the client's message

 	TPckgBuf<TInt> handlePckg(handle);

 	TRAPD(res,aMessage.WriteL(3,handlePckg));

 	if (res!=KErrNone)

 		{

 		iSubSessionIx->Remove(handle);

 		PanicClient(EBadSubsessionHandle, aMessage);

 		subSession = NULL;

 		}

 	return subSession;

 	}

 //Deletes a subsession object through its handle.

 void CServerSession::DeleteSubSession(TInt aHandle)

 	{

 	iSubSessionIx->Remove(aHandle);

 	}

 inline CSessionManager* CServerSession::Server()

 	{

 	return static_cast<CSessionManager*>(const_cast<CServer2*>(CSession2::Server()));

 	}

 #if defined(__CENTREP_SERVER_PERFTEST__) || defined (__CENTREP_SERVER_MEMTEST__) || defined(__CENTREP_SERVER_CACHETEST__)

 // GetSetParameters

 // The function code EGetSetParameters is a generic msg reserved

 // for testing purpose. Int0 specifies the function to perform.

 TInt CServerSession::GetSetParameters(const TClientRequest& aMessage)

 	{

 	TServerGetSetParametersSubCmd cmd = static_cast<TServerGetSetParametersSubCmd>(aMessage.Int0());

 #ifdef __CENTREP_SERVER_PERFTEST__

 	if (cmd == EGetPerfResults)

 		{

 		TInt desSize = aMessage.GetDesMaxLength(1);

 		TInt numVals = desSize / sizeof(TUint32);

 		if (numVals < KCentRepPerfTestArraySize)

 			{

 			return KErrOverflow;

 			}

 		TPtrC8 p(reinterpret_cast<const TUint8*>(TServerResources::iPerfTestMgr.Entries()),

 				   KCentRepPerfTestArraySize * sizeof(TUint32));

 		TInt ret = aMessage.Write(1, p);

 		if (ret == KErrNone)

 			{

 			TUint lastCompleteAccess = TServerResources::iPerfTestMgr.LastCompleteAccess();

 			TPckg<TUint> p2(lastCompleteAccess);

 			ret = aMessage.Write(2, p2);

 			}

 		return ret;

 		}

 	else if (cmd == ERestartPerfTests)

 		{

 		TServerResources::iPerfTestMgr.Reset();

 		return KErrNone;

 		}

 	else if (cmd == EStopPerfTests)

 		{

 		TServerResources::iPerfTestMgr.Stop();

 		return KErrNone;

 		}

 #endif // __CENTREP_SERVER_PERFTEST__

 #ifdef __CENTREP_SERVER_MEMTEST__

 	if(cmd == ERestartMemTests)

 		{

 		TServerResources::StartRecordTimerResult();

 		return KErrNone;

 		}

 	else if(cmd == ESingleMemTest)

 		{

 		RECORD_HEAP_SIZE(EMemLcnOnDemand, aMessage.Int1());

 		return KErrNone;

 		}

 	else if(cmd == EGetMemResults)

 		{

 		TInt count = TServerResources::iMemTestDataCount;

 		TPckg<TInt> pCount(count);

 		TInt err = aMessage.Write(1, pCount);

 		if(err == KErrNone && count > 0)

 			{

 			TPtrC8 pBuf(reinterpret_cast<TUint8*>(TServerResources::iMemTestData), (TServerResources::iMemTestDataCount)*sizeof(TInt32));

 			err = aMessage.Write(2, pBuf);

 			}

 		// Stop recording results

 		TServerResources::StopRecordTimerResult();

 		return err;

 		}

 #endif // __CENTREP_SERVER_MEMTEST__

 #ifdef __CENTREP_SERVER_CACHETEST__

 	if (cmd == EEnableCache)

 		{

 		// First parameter is Timer Interval, second is cache size

 		TServerResources::iCacheManager->EnableCache(aMessage.Int1(), aMessage.Int2());

 		return KErrNone;

 		}

 	else if (cmd == EDisableCache)

 		{

 		TServerResources::iCacheManager->DisableCache(ETrue);

 		return KErrNone;

 		}

 #endif  // __CENTREP_SERVER_CACHETEST__

 	return KErrNotSupported;

 	}

 #endif // __CENTREP_SERVER_PERFTEST__ || __CENTREP_SERVER_MEMTEST__ || __CENTREP_SERVER_CACHETEST__