// Copyright (c) 1997-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:

// Server session object implementation.

// 

//

#include "EComServerStart.h"

#include "EComMessageIds.h"

#include <ecom/ecomerrorcodes.h>

#include <ecom/implementationinformation.h>

#include "EComServerSession.h"

#include "EComSessionAux.h"

#include "EComServer.h"

#include "TestUtilities.h"	// For __FILE__LINE__

#include "EComPerformance.h"

#include "EComDebug.h"

//

// RMessage::Panic() completes the message. This is:

// (a) important for efficient cleanup within the kernel.

// (b) a problem if the message is completed a second time.

//

void PanicClient(const TClientRequest& aMessage, TInt aPanicCode)

	{

	aMessage.Panic(KEComServerPanicCategory, aPanicCode);

	}

//

//	class CEComServerSession

//

CEComServerSession::CEComServerSession()

	: CSession2()

	{

	// Do nothing

	}

//

// 2nd phase construct for sessions - called by the CServer framework

//

void CEComServerSession::CreateL()

	{

	Server().AddSession();

	}

CEComServerSession::~CEComServerSession()

	{

	CleanupInternalList();

	CompleteNotifications(KErrCancel);

	delete iMemoryStore;

	Server().DropSession();

	}

//

// Deliver the notification message to the client

//

void CEComServerSession::CompleteNotifications(TInt aCompletionCode)

	{

	const TInt count = iNotificationRequests.Count();

	for(TInt i = 0; i < count; ++i)

		{

		  iNotificationRequests[i].iMessage.Complete(aCompletionCode);

		}

	iNotificationRequests.Reset();

	}

//

// Handle a client request.

// Leaving is handled by CEComServer::RunError() which reports the error code

// to the client.

//

void CEComServerSession::ServiceL(const RMessage2& aMessage)

{

	const TClientRequest msg(aMessage);

	ServiceL(msg);

}

void CEComServerSession::ServiceL(const TClientRequest& aMessage)

	{

	TInt completionCode = KErrNone;

	TBool asyncRequest = EFalse;

	switch (aMessage.Function())

		{

	case ENotifyOnChange:

		{

RECORD_CLIENT_REQUEST_START_TIMER_RESULT(EEComNotifyOnChangeRequestType, Server().GetCurrentStartupState());

		SEComNotification notif;

		notif.iMessage=aMessage;

		// the TRequestStatus as a TInt is stored for later comparisons

		notif.iRequestStatusHandle=aMessage.Int0();

		//Check that this TRequestStatus is not already being used.

		const TInt count = iNotificationRequests.Count();

		for(TInt i = 0; i < count; ++i)

		{

			if(iNotificationRequests[i].iRequestStatusHandle == notif.iRequestStatusHandle)

				User::Leave(KErrArgument);

		}

		User::LeaveIfError(iNotificationRequests.Append(notif));

		asyncRequest = ETrue;

RECORD_CLIENT_REQUEST_END_TIMER_RESULT;

		break;

		}

	case ECancelNotifyOnChange:

			{

RECORD_CLIENT_REQUEST_START_TIMER_RESULT(EEComCancelNotifyOnChangeRequestType, Server().GetCurrentStartupState());

			TInt statusHandle = aMessage.Int0();

			const TInt count = iNotificationRequests.Count();

			for(TInt i = 0; i < count; ++i)

				{

				if(iNotificationRequests[i].iRequestStatusHandle == statusHandle)

					{

						iNotificationRequests[i].iMessage.Complete(KErrCancel);

						iNotificationRequests.Remove(i);

						break;  // Terminate the loop

					}

				}

			}

RECORD_CLIENT_REQUEST_END_TIMER_RESULT;

		break;

	case EListImplementations:

	case EListResolvedImplementations:

	case EListCustomResolvedImplementations:

		if(Server().RegistryIndexValid())

			{

RECORD_CLIENT_REQUEST_START_TIMER_RESULT(EEComListRequestType, Server().GetCurrentStartupState());

			DoListImplementationsL(aMessage);

RECORD_CLIENT_REQUEST_END_TIMER_RESULT;

			}

		else

			{

			if(ReceivePending())

				User::Leave(KEComErrListInvalidAwaitNotification);

			else

				User::Leave(KEComErrListCurrentlyUnavailable);

			}

		break;

	case ECollectImplementationsList:

RECORD_CLIENT_REQUEST_START_TIMER_RESULT(EEComCollectImplementationsRequestType, Server().GetCurrentStartupState());

		if(!DoCollectListL(aMessage))

			completionCode = KErrNotReady;

RECORD_CLIENT_REQUEST_END_TIMER_RESULT;

		break;

	case EGetImplementationCreationMethod:

	case EGetResolvedCreationMethod:

	case EGetCustomResolvedCreationMethod:

RECORD_CLIENT_REQUEST_START_TIMER_RESULT(EEComCreateRequestType, Server().GetCurrentStartupState());

		DoGetResolvedImplementationL(aMessage);

RECORD_CLIENT_REQUEST_END_TIMER_RESULT;

		break;

	case EListExtendedInterfaces:

RECORD_CLIENT_REQUEST_START_TIMER_RESULT(EEComListExtendedInterfacesRequestType, Server().GetCurrentStartupState());

		DoListExtendedInterfacesL(aMessage);

RECORD_CLIENT_REQUEST_END_TIMER_RESULT;

		break;

	case EEnableImplementation:

	case EDisableImplementation:

		// Ommissions for 6.2

		completionCode = KErrNotSupported;

		break;

#if defined(__ECOM_SERVER_TESTABILITY__) || defined(__ECOM_SERVER_PERFORMANCE__)

	case ESetGetParameters:

		DoSetGetParametersL(aMessage);

		break;

#endif

	//EDestroyedImplementation obsolete due to implementation creation

	//relocation to client side from server

	case EDestroyedImplementation:

	default:

		// Something badly wrong if we get here.

		PanicClient(aMessage,KEComErrUnknownService);

		// RMessage::Panic() has completed the message

		// so treat this as an asynch request.

		asyncRequest = ETrue;

		}

	if (!asyncRequest)

		aMessage.Complete(completionCode);

	}

TInt const KDefaultStoreSize = 256;	// Enough space for approx 1 implementation : will grow to fit if required

/**

UnPack the match string and extended interface from the client supplied parameters.

@param			aMessage 

@param			aExtendedInterfaces Return value consisting of an array containing the extended interfaces.

@param			aMatchStr Return value consisting of the matching string.

*/

void CEComServerSession::UnpackMatchStrAndExtendedInterfacesFromClientL(const TClientRequest& aMessage,

													RExtendedInterfacesArray& aExtendedInterfaces,

													RBuf8& aMatchStr)

	{

	//now get the matchString and extendedInterfaces

	TInt sizeOfMatchStrExtInfBuf = aMessage.GetDesLength(KIPCParameterMatchStrExtInf);

	User::LeaveIfError(sizeOfMatchStrExtInfBuf);

	RBuf8 matchStrExtInfBuf;

	matchStrExtInfBuf.CreateMaxL(sizeOfMatchStrExtInfBuf);

	matchStrExtInfBuf.CleanupClosePushL();

	aMessage.ReadL(KIPCParameterMatchStrExtInf,matchStrExtInfBuf);

	RDesReadStream readStream;

	CleanupClosePushL(readStream);

	readStream.Open(matchStrExtInfBuf);

	TInt lenOfMatchStr = readStream.ReadInt32L();

	aMatchStr.CreateMaxL(lenOfMatchStr);

	aMatchStr.CleanupClosePushL();

	if (lenOfMatchStr>0)

		{

		readStream.ReadL(aMatchStr,lenOfMatchStr);		

		}

	TInt numOfExtendedInterfaces = readStream.ReadInt32L();

	CleanupClosePushL(aExtendedInterfaces);

	for(TInt i = 0; i < numOfExtendedInterfaces; i++)

		{

		aExtendedInterfaces.AppendL(TUid::Uid(readStream.ReadInt32L()));

		}

	CleanupStack::Pop(&aExtendedInterfaces);

	CleanupStack::Pop(&aMatchStr);

	CleanupStack::PopAndDestroy(&readStream);

	CleanupStack::PopAndDestroy(&matchStrExtInfBuf); 

	}

// Note that this method for returning the arbitrary sized data set 

// will not work IF the session is shared so...

// DO NOT SHARE SERVER SIDE SESSIONS BETWEEN CLIENTS

void CEComServerSession::DoListImplementationsL(const TClientRequest& aMessage)

	{

	// Unpack the client supplied parameters

	// Firstly get the uids

	TUidType uids;

	TPckg<TUidType> uidsPkg(uids);	

	aMessage.ReadL(KIPCParameterUids, uidsPkg);

	if(uids[KInterfaceUidIndex] == KNullUid)

		{

		User::Leave(KEComErrMissingParameter);

		}

	//now get the TListImplParam parameters

  	TListImplParam listParam;

  	TPckg<TListImplParam> listParamPkg(listParam);

  	aMessage.ReadL(2,listParamPkg);

	// Now rebuild the TEComResolverParams

	TEComResolverParams resolverParameters;

	resolverParameters.SetGenericMatch(listParam.iMatchType);

	//now get the matchString and extendedInterfaces

	RBuf8 matchStr;

	RExtendedInterfacesArray extendedInterfaces;

	UnpackMatchStrAndExtendedInterfacesFromClientL(aMessage,extendedInterfaces,matchStr);

	matchStr.CleanupClosePushL();

	CleanupClosePushL(extendedInterfaces);

	if(matchStr.Length()>0)

		{	

		resolverParameters.SetDataType(matchStr);

		}

	// Else the client's resolver params are default constructed i.e. invalid

	// data type descriptor or its length is zero, so use empty RBuf8 above.

	// Pass to the server

	iListContext = aMessage.Function();

	switch(iListContext)

		{

		case EListImplementations:

			iList = Server().ListImplementationsL( uids[KInterfaceUidIndex], extendedInterfaces, aMessage );

			break;

		case EListResolvedImplementations:

			if(matchStr.Length() == 0)

				{

				User::Leave(KEComErrMissingParameter);

				}

			iList = Server().ListImplementationsL( uids[KInterfaceUidIndex], resolverParameters, extendedInterfaces, aMessage);

			break;

		case EListCustomResolvedImplementations:

			if(uids[KResolverUidIndex] == KNullUid)

				{

				User::Leave(KEComErrMissingParameter);

				}

			iList = Server().ListImplementationsL( uids[KInterfaceUidIndex], resolverParameters, uids[KResolverUidIndex], extendedInterfaces, aMessage);

			break;

		default:

			break;

		}

	//Now cleanup the extended interface

	CleanupStack::PopAndDestroy(&extendedInterfaces);

	CleanupStack::PopAndDestroy(&matchStr);

	TInt bufferSizeRequired=0;

	// Package the array for return

	if(iList)

		{

		if(iList->Count()>0)

			{

			// Allocate a new store and replace the old one first

			CBufFlat* memoryStore = CBufFlat::NewL(KDefaultStoreSize);

			delete iMemoryStore;

			iMemoryStore = memoryStore;

			// Note : There is no need to push

			// the write stream onto the cleanup stack

			// because it has no internal resources.

			RBufWriteStream writeStream;

			writeStream.Open(*iMemoryStore);

			// Build the store data then calculate the end size;

			const TInt entryCount = iList->Count();		

			writeStream.WriteInt32L(entryCount);

			for(TInt i = 0; i < entryCount; ++i)

				(*iList)[i]->ExternalizeL(ETrue,writeStream);

			writeStream.CommitL();

			// Set to actual size

			bufferSizeRequired=iMemoryStore->Size();

			__ECOM_TRACE1("ECOM ListImplementations request buffer size required=%d",bufferSizeRequired);

			}

			CleanupInternalList();	

		}

	//if nothing is returned we should still indicate this to the client side

	if (bufferSizeRequired==0)

		{

		//write back the bufferSize

		listParam.iBufferSize=0;

  		aMessage.WriteL(2,listParamPkg);

		return;

		}

	//if the preallocated size is big enough to hold our entry

	//copy it to the client

	if (listParam.iBufferSize >= bufferSizeRequired)

		{

		if (iMemoryStore)

			{

			//write back the bufferSize

			listParam.iBufferSize=bufferSizeRequired;

  			aMessage.WriteL(2,listParamPkg);

			TPtr8 data=iMemoryStore->Ptr(0);

			aMessage.WriteL(3,data);

			delete iMemoryStore;

			iMemoryStore=NULL;

			}

		}

	//if not rewrite back to the client the size that is required

	//and signal with KErrOverFlow to the client

	else

		{

		//write back the bufferSize

		listParam.iBufferSize=bufferSizeRequired;

  		aMessage.WriteL(2,listParamPkg);

		User::Leave(KErrOverflow);

		}

	}

TBool CEComServerSession::DoCollectListL(const TClientRequest& aMessage)

	{

	TBool success = EFalse;

	if(iMemoryStore)

		{

		TPtr8 data=iMemoryStore->Ptr(0);

		aMessage.WriteL(0, data);

		delete iMemoryStore;

		iMemoryStore = NULL;

		success = ETrue;

		}

	return success;

	}

void CEComServerSession::DoGetResolvedImplementationL(const TClientRequest& aMessage)

	{

	// Unpack the client supplied parameters

	// Firstly get the uids

	TUidType uids;

	TPckg<TUidType> uidsPkg(uids);

	aMessage.ReadL(KIPCParameterUids, uidsPkg);

	// Now rebuild the TEComResolverParams

	TEComResolverParams resolverParameters;

	resolverParameters.SetGenericMatch(KIPCParameterResolverParamsTypePtr);	

	//now get the matchString and extendedInterfaces

	RBuf8 matchStr;

	matchStr.CleanupClosePushL();

	RExtendedInterfacesArray extendedInterfaces;

	CleanupClosePushL(extendedInterfaces);

	UnpackMatchStrAndExtendedInterfacesFromClientL(aMessage,extendedInterfaces,matchStr);

    if(matchStr.Length()>0)

		{	

		resolverParameters.SetDataType(matchStr);

		}

	// Else the client's resolver params are default constructed i.e. invalid

	// data type descriptor or its length is zero, so use empty HBufC8 above.

	// Set up for the return value

	TUid dtorIdKey(KNullUid);

	TEntry loadInfo;

	switch(aMessage.Function())

		{

		case EGetImplementationCreationMethod:

			Server().GetResolvedDllInfoL(uids[KInterfaceUidIndex], 

										 loadInfo, 

										 dtorIdKey,

										 aMessage);

			break;

		case EGetResolvedCreationMethod:

			Server().GetResolvedDllInfoL(uids[KInterfaceUidIndex], 

										 resolverParameters, 

										 extendedInterfaces,

										 loadInfo, 

										 dtorIdKey,

										 aMessage);

			break;

		case EGetCustomResolvedCreationMethod:

			Server().GetResolvedDllInfoL(uids[KInterfaceUidIndex], 

										 resolverParameters, 

										 uids[KResolverUidIndex], 

										 extendedInterfaces,

										 loadInfo, 

										 dtorIdKey,

										 aMessage);

			break;

		default:

			break;

		}

	CleanupStack::PopAndDestroy(&extendedInterfaces);

	CleanupStack::PopAndDestroy(&matchStr);

// ??? Compile time assert that sizeof(TProxyNewLPtr) == sizeof(TAny*)?

// Currently I'm not arranging for the client-side of the session to

// convert from TAny* to TProxyNewLPtr, and using this to avoid the

// full agony of following through with conversion...

	// Then re-package the results for return

	// Firstly the Interface Implementation creation method pointer

	TPckg<TEntry> result(loadInfo);

	aMessage.WriteL(KIPCReturnParameterCreationMethodPtr, result);

	// Next the destruction identification uid

	TUidType type(KNullUid,dtorIdKey,KNullUid);

	TPckg<TUidType> dtorIdKeyPkg(type);

	aMessage.WriteL(KIPCReturnParameterUidsPtr, dtorIdKeyPkg);

	}

// Return the list of interfaces to the client. If not enough space

// has been allocated by the client, KErrOverflow will be returned.

//

void CEComServerSession::DoListExtendedInterfacesL(const TClientRequest& aMessage)

	{

	// Unpack the client supplied parameters

	TInt bufferSize = 0;

	TUid implementationUid(KNullUid);

	TPckg<TUid> implementationUidDes(implementationUid);

	TPckg<TInt> bufferSizeDes(bufferSize);

	aMessage.ReadL(KIPCParameterImplementationUid,implementationUidDes);

	aMessage.ReadL(KIPCParameterBufferSize,bufferSizeDes);

	// Get the implementation information for this implementation UID.

	CImplementationInformation* implInfo = NULL;

	Server().GetImplementationInformationL(implementationUid,implInfo,aMessage);

	TInt numExtendedInterfaces = 0; // Number of extended interfaces to return to client.

	if(implInfo)

		{

		TInt bufferSizeRequired = 0; // Buffer required to send extended interface data back to client

		// Fetch the list of extended interfaces

		RExtendedInterfacesArray* extendedInterfaceList = implInfo->GetExtendedInterfaceList();

		if (extendedInterfaceList != NULL)

			{

			numExtendedInterfaces = extendedInterfaceList->Count();

			}

		if (numExtendedInterfaces > 0)

			{

			bufferSizeRequired = numExtendedInterfaces * sizeof(TUid);

			__ECOM_TRACE1("ECOM ListInterfaces request buffer size required=%d",bufferSizeRequired);

			//if the preallocated size is big enough to hold our entry

			//copy it to the client

			if (bufferSize >= bufferSizeRequired)

				{

				RBuf8 buf;

				CleanupClosePushL(buf);

				buf.CreateL(bufferSizeRequired);   // Create the RBuf.

				// Note : There is no need to push the write stream onto the cleanup stack

				// because it has no internal resources.

				RDesWriteStream writeStream;

				writeStream.Open(buf);

				// Build the data of extendedInterfaces;

				for(TInt i = 0; i < numExtendedInterfaces; ++i)

					{

					writeStream.WriteInt32L((*extendedInterfaceList)[i].iUid);

					}

				writeStream.CommitL();

				// Copy the data to the client.

				bufferSize=bufferSizeRequired;

				aMessage.WriteL(KIPCParameterBufferSize,bufferSizeDes);

				aMessage.WriteL(KIPCParameterInterfaceData,buf);

				CleanupStack::PopAndDestroy(&buf);

				}

			//if not rewrite back to the client the size that is required

			//and signal with KErrOverFlow to the client

			else

				{

				bufferSize=bufferSizeRequired;

				aMessage.WriteL(KIPCParameterBufferSize,bufferSizeDes);

				User::Leave(KErrOverflow);

				}

			}

		}

	//if nothing is returned we should still indicate this to the client side

	if (numExtendedInterfaces == 0)

		{

		bufferSize=0;

		aMessage.WriteL(KIPCParameterBufferSize,bufferSizeDes);

		}

	}

#if defined(__ECOM_SERVER_TESTABILITY__) || defined(__ECOM_SERVER_PERFORMANCE__)

/**

This method is provided for testability. It allows the user to 

send and receive any parameters. 

@param aMessage IPC message between server and client

*/

void CEComServerSession::DoSetGetParametersL(const TClientRequest& aMessage)

	{

	TInt parameterType = aMessage.Int0();

	switch(parameterType)

		{

#ifdef __ECOM_SERVER_TESTABILITY__

		case EChangeStartupState:

			Server().ChangeStartupStateL(aMessage.Int1());

			break;

		case EProcessStartupState:

			Server().ProcessCurrentStartupStateL();

			break;

		case EGetStartupState:

			{

			TInt state = Server().GetCurrentStartupState();

			TPckg<TInt> pckgState(state);

		    aMessage.Write(1, pckgState);

			break;

			}

#endif

#ifdef __ECOM_SERVER_PERFORMANCE__

		case EGetStartupStateTimerResult:

			{

			TStartupStateTimerEntry timerEntry;

			TInt ret = EComPerformance::GetStartupStateTimerResult(aMessage.Int1(), timerEntry.iTimerResult, timerEntry.iState);

			TPckg<TInt> pckgRetValue(ret);

			aMessage.Write(2, pckgRetValue);

			TPckg<TStartupStateTimerEntry> pckgTimerEntry(timerEntry);

			aMessage.Write(3, pckgTimerEntry);

			break;

			}

		case EGetAccumulatedClientRequestsTimerResult:

			{

			TClientRequestTimerEntry timerEntry;

			TInt ret = EComPerformance::GetAccumulatedClientRequestTimerResult(aMessage.Int1(), timerEntry);

			TPckg<TInt> pckgRetValue(ret);

			aMessage.Write(2, pckgRetValue);

			TPckg<TClientRequestTimerEntry> pckgTimerEntry(timerEntry);

			aMessage.Write(3, pckgTimerEntry);

			break;

			}

		case EGetRegistryCounts:

			{

			RegistryCounts::TRegistryCounts counts;

			Server().GetRegistryCountsL(aMessage.Int1(), counts);

			TPckg<RegistryCounts::TRegistryCounts> pckgRegistryCounts(counts);

			aMessage.Write(2, pckgRegistryCounts);

			break;

			}

		case EResetStartupStateTimerCounts:

			{

			EComPerformance::ResetStartupStateTimerResult();

			break;

			}

		case EGetEComPerfTimeRecord:

			{

			TEComPerfTimeRecordEntry timerEntry;

			TInt ret = EComPerformance::GetEComPerfTimeRecord(aMessage.Int1(), timerEntry);

			TPckg<TInt> pckgRetValue(ret);

			aMessage.Write(2, pckgRetValue);

			TPckg<TEComPerfTimeRecordEntry> pckgTimerEntry(timerEntry);

			aMessage.Write(3, pckgTimerEntry);

			break;

			}

		case EResetEComPerfTimeRecords:

			{

			EComPerformance::ResetEComPerfTimeRecords();

			}

		case EGetEComServerHeapResult:

			{

			TEComPerfHeapUsage heapEntry;

			TInt ret= EComPerformance::GetEComHeapSize(aMessage.Int1(),heapEntry);

			TPckg<TInt> pckgRetValue(ret);

			aMessage.Write(2, pckgRetValue);

			TPckg<TEComPerfHeapUsage> pckgHeapEntry(heapEntry);

			aMessage.Write(3, pckgHeapEntry);

			break;			

			}

#endif

		default:

			break;

		}

	}

#endif

void CEComServerSession::CleanupInternalList()

	{

	if (iList != NULL)

		{

		iList->Reset();

		delete iList;

		iList = NULL;

		}

	}