// Copyright (c) 2002-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 <e32math.h>

#include <mmf/server/mmfdrmpluginserverproxy.h>

#include "mmfcontrollerframework.h"

#include "mmfcontroller.h"

#include "mmfcontrollerheap.h"

#include "mmfcontrollerframeworkpriv.h"

#include "mmfcontrollerpatchdata.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/mmfcontrollerextendeddata.h>

#include <mmf/common/mmfcustomcommandparsermanager.h>

#include <mmf/common/mmfcontrollerframeworkclasses.h>

#endif

// Panic

enum

	{

	EPanicHeapHalfOpen=1,

	EPanicHeapOpenWithoutTls,

	EPanicReleaseWithoutRegister,

	EPanicBadInvariant

	};

#ifdef _DEBUG

static void Panic(TInt aReason)

	{

	_LIT(KControllerFramework, "ControllerFramework");

	User::Panic(KControllerFramework, aReason);

	}

#endif

EXPORT_C RMMFControllerProxy::RMMFControllerProxy() :

	iDestinationPckg(TMMFMessageDestination(KUidInterfaceMMFControllerProxy, KMMFObjectHandleControllerProxy)),

	iLogonAO(NULL), iThreadPriority(static_cast<TThreadPriority>(KDefaultMMFControllerThreadPriority)), iFlags(0)

	{

	iSubThread.Close();//iSubThread is automatically initialised to be a handle to this thread!

	}

TInt RMMFControllerProxy::LoadController(

	TUid aControllerUid, 

 	const CMMFControllerImplementationInformation& aControllerInfo,

 	TBool aUseSharedHeap,

 	TBool aNoDRMCap)

	{

	// First check that we haven't already created the subthread

	if (iSubThread.Handle() != 0)

		return KErrAlreadyExists;

#ifdef SYMBIAN_FORCE_USE_SHARED_HEAP

	aUseSharedHeap = ETrue;

#endif

	//determine what maximum heap size this thread should be created with

	TUint maxHeapSize =0;

	TInt error = KErrNone;

	maxHeapSize = aControllerInfo.HeapSpaceRequired();

	TUint stackSize = aControllerInfo.StackSize();

	ASSERT(!iLogonAO);

	TRAP(error, iLogonAO = CLogonMonitor::NewL(this));

	if (!error)

		{

		if (aNoDRMCap && aControllerInfo.SupportsSecureDRMProcessMode())

			{

			error = DoCreateSessionForNoDRMCapClient(maxHeapSize, aUseSharedHeap, stackSize);

			}

		else

			{

			// server2 will be set in this function call

			error = DoCreateSubThread(&iLogonAO->Server(), maxHeapSize, aUseSharedHeap, stackSize);

			// Now create a session with the controller proxy server running in the subthread

			if (!error)

				{

				// create a session with iServer2 (local server)

				error = CreateSession(iLogonAO->Server(), KMMFControllerProxyVersion);

				}

			}

		}

	// Finally, tell the controller proxy server to load the relevant plugin

	if (!error)

		{

		TMMFUidPckg uidPckg(aControllerUid);

		error = SendSync(iDestinationPckg, 

						 EMMFControllerProxyLoadControllerPluginByUid, 

						 uidPckg, 

						 KNullDesC8);

		}

	// If an error occurred with any of the above, close all the handles

	if (error)

		Close();

	return error;

	}

EXPORT_C TInt RMMFControllerProxy::LoadController(TUid aControllerUid, TBool aUseSharedHeap)

	{

 	CMMFControllerImplementationInformation* controllerInfo = NULL;

 	TRAPD(err, controllerInfo = CMMFControllerImplementationInformation::NewL(aControllerUid));

	if (!err && controllerInfo)

		{

		err = LoadController(aControllerUid, *controllerInfo, aUseSharedHeap, EFalse);

		delete controllerInfo;

		}

 	return err;

	}

EXPORT_C TInt RMMFControllerProxy::LoadController(const CMMFControllerImplementationInformation& aControllerInfo, TBool aUseSharedHeap)

	{

	return LoadController(aControllerInfo.Uid(), aControllerInfo, aUseSharedHeap, EFalse);

	}

EXPORT_C TInt RMMFControllerProxy::LoadControllerInSecureDRMProcess(TUid aControllerUid, TBool aUseSharedHeap)

	{

	CMMFControllerImplementationInformation* controllerInfo = NULL;

	TRAPD(err, controllerInfo = CMMFControllerImplementationInformation::NewL(aControllerUid));

	if (!err && controllerInfo)

		{

		err = LoadController(aControllerUid, *controllerInfo, aUseSharedHeap, ETrue);

		delete controllerInfo;

		}

	return err;

	}

EXPORT_C TInt RMMFControllerProxy::LoadControllerInSecureDRMProcess(const CMMFControllerImplementationInformation& aControllerInfo, TBool aUseSharedHeap)

	{

	return LoadController(aControllerInfo.Uid(), aControllerInfo, aUseSharedHeap, ETrue);

	}

TUint RMMFControllerProxy::ControllersMaxHeapSizeL(TUid aControllerUid)

	{

	CMMFControllerImplementationInformation* controllerInfo = NULL;

	TRAPD(err, controllerInfo = CMMFControllerImplementationInformation::NewL(aControllerUid));

	TUint maxHeapSize = KMMFDefaultControllerThreadHeapSize;

	if((err != KErrNone) && (err != KErrCorrupt))

		{

		delete controllerInfo;

		User::Leave(err);

		}

	if(controllerInfo && (err == KErrNone))

		maxHeapSize = controllerInfo->HeapSpaceRequired();

	delete controllerInfo;

	return maxHeapSize;

	}

TInt RMMFControllerProxy::DoCreateSubThread(RServer2* aServer2, TUint aMaxHeapSize, TBool aUseSharedHeap, TUint aStackSize)

	{

	TInt error = KErrNone;

	TControllerProxyServerParams params;

	params.iServer = aServer2;

	params.iUsingSharedHeap = aUseSharedHeap;

#ifdef SYMBIAN_USE_CLIENT_HEAP

	// controller threads share the *client* heap (intended for out of memory testing)

	error = iSubThread.Create(_L(""), &CMMFControllerProxyServer::StartThread, 

			aStackSize, NULL, &params, EOwnerThread);

#else

	if( aUseSharedHeap )

		{

		//controller threads all share a controller heap

		CMMFControllerHeap* contHeap = static_cast<CMMFControllerHeap*>(Dll::Tls());

		if(contHeap == NULL)

			{

			TRAP(error, contHeap = CMMFControllerHeap::NewL());

			if(error)

				{			

				return error;	

				}

			Dll::SetTls(contHeap);

			}

		__ASSERT_DEBUG((iFlags&EFlagOpenedSharedHeap)==0, Panic(EPanicHeapHalfOpen));

		RHeap* sharedHeap = contHeap->RegisterHeap();

		// We've registered, so record the fact so can "unregister" on close or error

		iFlags |= EFlagOpenedSharedHeap; 

		error = iSubThread.Create(KNullDesC, &CMMFControllerProxyServer::StartThread,

				aStackSize, sharedHeap, 						

				&params, EOwnerThread);		

		}

	else

		{	

		// Threads create own heap (default behaviour)

		if(aMaxHeapSize < static_cast<TUint>(KMinHeapSize))

			aMaxHeapSize = KMinHeapSize; //else raises a USER 111 panic

		else if(aMaxHeapSize >  static_cast<TUint>(KMMFControllerProxyMaxHeapSize))

			aMaxHeapSize = KMMFControllerProxyMaxHeapSize;

		TThreadCreateInfo threadSettings (KNullDesC, &CMMFControllerProxyServer::StartThread,

										  aStackSize, &params);

		threadSettings.SetCreateHeap(KMinHeapSize, aMaxHeapSize);

		threadSettings.SetOwner(EOwnerThread);

		threadSettings.SetPaging(TThreadCreateInfo::EUnpaged);

		error = iSubThread.Create(threadSettings);

		}

#endif

	if (error)

		{

		return error;

		}

	TRequestStatus rendezvous;

	iSubThread.Rendezvous(rendezvous);

	if (rendezvous != KRequestPending)

		{

		iSubThread.Kill(0);

		}

	else

		{

		iLogonAO->StartMonitoring(iSubThread);

		if (iLogonAO->iStatus != KRequestPending)

			{

			// Failed to logon

			iSubThread.RendezvousCancel(rendezvous);

			User::WaitForRequest(rendezvous);

			iSubThread.Kill(0);

			iSubThread.Close();

			return iLogonAO->iStatus.Int();

			}

		else

			{

			iSubThread.SetPriority(iThreadPriority);

			iSubThread.Resume();

			}

		}

	User::WaitForRequest(rendezvous); // wait for startup or death

	if (rendezvous != KErrNone)

		{

		iLogonAO->Cancel();

		iSubThread.Close();

		// if open failed, but we registered the heap, need to release

		if((iFlags&EFlagOpenedSharedHeap))

			{

			ReleaseHeap();

			}		

		}

	return rendezvous.Int();

	}

EXPORT_C void RMMFControllerProxy::Close()

	{

#ifdef _DEBUG

	_LIT(KMMFClientThreadPanic, "MMFClientThread");

#endif

	// check if thread was created

	TBool subThreadCreated = EFalse;

	TRequestStatus logoffStatus;

	TBool logoffFailed = EFalse;

	if (iSubThread.Handle() != KNullHandle)

		{

		subThreadCreated = ETrue;

		iLogonAO->Cancel();

		iSubThread.Logon(logoffStatus);

		if (logoffStatus == KErrNoMemory && iSubThread.ExitType() == EExitPending)

			{

			// Logon() call has failed because of a lack of memory

			logoffFailed = ETrue;

			}

		}

	// Close the controller and wait for its exit.

	// Close the session to signal the controller proxy server to shut down.

	RHandleBase::Close();

	// Now wait for the death of the subthread if we have a valid handle...

	if (subThreadCreated)

		{

		RProcess thisProcess;

		RProcess controllerProcess;

		iSubThread.Process(controllerProcess);	// ignore error, best try

		TBool secureDrmMode = thisProcess.Id() != controllerProcess.Id();

		thisProcess.Close();

		controllerProcess.Close();

		RTimer timer;

		TInt err = timer.CreateLocal();

		// If we managed to create the timer and logon to the thread, 

		// wait for both the death and the timeout to minimise the risk of deadlock

		if (!err && !logoffFailed)

			{

			TRequestStatus timeout;

			timer.After(timeout, KMmfControllerThreadShutdownTimeout);

			User::WaitForRequest(logoffStatus, timeout);

			if (logoffStatus == KRequestPending)

				{

				// we have timed out.  Kill the controller thread

				iSubThread.LogonCancel(logoffStatus);

				User::WaitForRequest(logoffStatus);

				if (!secureDrmMode)

					{

					// Controller server thread is created in current process

				#ifdef _DEBUG

					iSubThread.Panic(KMMFClientThreadPanic,KErrDied);

				#else

					iSubThread.Kill(KErrDied);

				#endif

					}

				else

					{

					// Controller server thread is created through DRM plugin server

					RMMFDRMPluginServerProxy server;

					// ignore all RMMFDRMPluginServerProxy errors, best try

					err = server.Open();

					if (err == KErrNone)

						{

					#ifdef _DEBUG

						server.PanicControllerThread(iSubThread.Id(), KMMFClientThreadPanic, KErrDied);

					#else

						server.KillControllerThread(iSubThread.Id(), KErrDied);

					#endif

						server.Close();

						}

					}

				}

			else

				{

				// subthread has exited. Cancel the timer.

				timer.Cancel();

				User::WaitForRequest(timeout);

				}

			}

		else

			{

			// We have no timer or we can't logon to the thread so we'll just poll the thread status a maximum

			// of 10 times and kill the thread if it hasn't exited after the polling

			for (TInt i=0; i<10 && iSubThread.ExitType() == EExitPending; ++i)

				{

				User::After(KMmfControllerThreadShutdownTimeout/10);	// wait for a while

				}

			if (iSubThread.ExitType() == EExitPending)

				{

				// The polling hasn't been succesful so we kill the thread

				if (!secureDrmMode)

					{

					iSubThread.Kill(KErrDied);

					}

				else

					{

					// Controller server thread is created through DRM plugin server

					RMMFDRMPluginServerProxy server;

					// ignore all RMMFDRMPluginServerProxy errors, best try

					err = server.Open();

					if (err == KErrNone)

						{

						server.KillControllerThread(iSubThread.Id(), KErrDied);

						}

					}

				}

			User::WaitForRequest(logoffStatus);

			}

		timer.Close();

		}

	// Close the handle to the controller thread

	iSubThread.Close();

	// Delete the Logon AO

	if (iLogonAO)

		{

		delete iLogonAO;

		iLogonAO = NULL;

		}

	// if this is last thread to be killed delete shared heap

	if((iFlags&EFlagOpenedSharedHeap))

		{

		ReleaseHeap();

		}	

	}

// Release the shared heap, should only be called if has previously been registered

// by this thread

void RMMFControllerProxy::ReleaseHeap()

	{

	__ASSERT_DEBUG((iFlags&EFlagOpenedSharedHeap), Panic(EPanicReleaseWithoutRegister));

	CMMFControllerHeap* contHeap = static_cast<CMMFControllerHeap*>(Dll::Tls());

	__ASSERT_DEBUG(contHeap!=NULL, Panic(EPanicHeapOpenWithoutTls));

	if(contHeap != NULL)

		{

		TInt refCount = contHeap->ReleaseHeap();

		if(refCount == 0)

			{  //no other controllers using the heap

			delete contHeap;

			Dll::SetTls(NULL);

			}

		}

	iFlags &= ~EFlagOpenedSharedHeap; // clear flag since we've released the heap

	}

EXPORT_C TInt RMMFControllerProxy::SendSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom) const

	{

	// Make sure we have been opened

	if (iSubThread.Handle() == 0)

		{

		return KErrNotReady;

		}

	else

		return SendReceiveResult(aFunction, aDestination, aDataTo1, aDataTo2, aDataFrom);

	}

EXPORT_C TInt RMMFControllerProxy::SendSync(TInt aFunction, const TIpcArgs& aIpcArgs) const

	{

	// Make sure we have been opened

	if (iSubThread.Handle() == 0)

		{

		return KErrNotReady;

		}

	else

		return RSessionBase::SendReceive(aFunction, aIpcArgs);

	}

EXPORT_C void RMMFControllerProxy::SendAsync(TInt aFunction, const TIpcArgs& aIpcArgs, TRequestStatus& aStatus) const

	{

	// Make sure we have been opened

	if (iSubThread.Handle() == 0)

		{

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status, KErrNotReady);

		}

	else

		RSessionBase::SendReceive(aFunction, aIpcArgs, aStatus);

	}

EXPORT_C TInt RMMFControllerProxy::SendSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2) const

	{

	// Make sure we have been opened

	if (iSubThread.Handle() == 0)

		{

		return KErrNotReady;

		}

	else

		return SendReceive(aFunction, aDestination, aDataTo1, aDataTo2);

	}

EXPORT_C void RMMFControllerProxy::SendAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus) const

	{

	if (iSubThread.Handle() == 0)

		{

		TRequestStatus* stat = &aStatus;

		User::RequestComplete(stat, KErrNotReady);

		}

	else

		SendReceiveResult(aFunction, aDestination, aDataTo1, aDataTo2, aDataFrom, aStatus);

	}

EXPORT_C void RMMFControllerProxy::SendAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus) const

	{

	if (iSubThread.Handle() == 0)

		{

		TRequestStatus* stat = &aStatus;

		User::RequestComplete(stat, KErrNotReady);

		}

	else

		SendReceive(aFunction, aDestination, aDataTo1, aDataTo2, aStatus);

	}

EXPORT_C void RMMFControllerProxy::ReceiveEvents(TMMFEventPckg& aEvent, TRequestStatus& aStatus)

	{

	SendAsync(iDestinationPckg, EMMFControllerProxyReceiveEvents, KNullDesC8, KNullDesC8, aEvent, aStatus);

	}

EXPORT_C TInt RMMFControllerProxy::CancelReceiveEvents()

	{

	return SendSync(iDestinationPckg, EMMFControllerProxyCancelReceiveEvents, KNullDesC8, KNullDesC8);

	}

EXPORT_C TInt RMMFControllerProxy::SetThreadPriority(const TThreadPriority& aPriority) const

	{

	TInt err = KErrNone;

	if (iSubThread.Handle() == 0)

		{

		err = KErrNotReady;

		}

	else

		{

		if (iThreadPriority != aPriority)

			{

			// This is a const method so cast it away to store the priority

			RMMFControllerProxy* nonConstThis = const_cast<RMMFControllerProxy*>(this);

			nonConstThis->iThreadPriority = aPriority;