// 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__