// 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;
		}
	}