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

//

/**

 @file

 @internalComponent

*/

#include "rsstd.h"

#include <elements/cfmacro.h>

#include <cfmsgs.h>

#include <cfshared.h>

#include <cflog.h>

#include <cfextras.h>

#include "bindmgr.h"

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ElemRootServerrt, "ElemRootServerrt");

#endif

__CFLOG_STMT(_LIT8(KLogSubSysRS, "RootServer");) // subsystem name

CNotifySuddenDeathContainer::CNotifySuddenDeathContainer(MNotifySuddenDeath* aNotifier):

    iNotifier(aNotifier)

    /** Constructor for Sudden Death notifier container

     @param aNotifier The object to be notified of death

     */

    {

    }

void CNotifySuddenDeathContainer::Dequeue()

	/** Dequeue

	 */

    {

    iLink.Deque();

    }

void CNotifySuddenDeathContainer::Notify(TInt aReason)

	/** Notify of SuddenDeath

	 @param aReason The reason to associate with the Sudden Death event

	 */

    {

    iNotifier->SuddenDeath(aReason);

    }

CModuleUndertaker* CModuleUndertaker::NewL(MNotifySuddenDeath& aNotifier, RThread& aThread)

    /** Creates new CModuleUndertaker object.

     @param aNotifier The object to be notified of death.

     @param aThread The thread to be monitored.

     @return Pointer to the undertaker object.

     */

    {

    CModuleUndertaker* pUndertaker = new (ELeave) CModuleUndertaker(aNotifier, aThread);

    CActiveScheduler::Add(pUndertaker);

    return pUndertaker;

    }

void CModuleUndertaker::Logon()

    /** Logs on to thread.

     Thread logon to monitor for death

     */

    {

	iThread.Logon(iStatus);

    SetActive();

    }

void CModuleUndertaker::DoCancel()

    {

	(void)iThread.LogonCancel(iStatus);

    }

void CModuleUndertaker::RunL()

    /** Calls sudden death function on object registered for notification

     */

    {

    LogThreadDeath();

    TExitType type = iThread.ExitType();

	TInt reason = iThread.ExitReason();

	// Decide if the thread exit was expected or caused by an error.

	if((iThread.ExitType() != EExitKill) || (reason != KErrNone))

		{

		// Looks like a panic or a forced kill/terminate happened to it.

		reason = KErrRSSuddenViolentDeath;

		}

	else

		{

		reason = KErrRSSuddenDeath;

		}

	// Call the notifier.

    iNotifier.SuddenDeath(reason);

    }

void CModuleUndertaker::LogThreadDeath()

	{

	#if defined _DEBUG || defined __CFLOG_ACTIVE || defined SYMBIAN_TRACE_ENABLE

		    RThread& deadThread = iThread;

	    TExitType type = deadThread.ExitType();

		TInt reason = deadThread.ExitReason();

	    TName processName = RProcess().Name();

	    TPtrC processDisplayName = processName;

	    TInt pos = processName.Locate(L'[');

	    if(pos > 0)

	    	{

	    	// Strip off the UID and instance number.

	    	processDisplayName.Set(processName.Left(pos));

	    	}

	    TBuf8<KMaxName> processName8;

	    processName8.Copy(processDisplayName);

	    TName threadName = deadThread.Name();

	    TBuf8<KMaxName> threadName8;

	    threadName8.Copy(threadName);

	    TBuf8<KMaxExitCategoryName> cat8;

	    cat8.Copy(deadThread.ExitCategory());

		if(type == EExitPending)

			{

			__CFLOG_1(KLogSubSysRS, KLogCode,

				_L8("ERROR: CModuleUndertaker::RunL - the death of thread %S was reported but the exit type indicates that the thread is still running.  The rootserver is probably in an unstable state."),

				&threadName8);

			__CF_BREAK_IF_DEBUGGER();

			}

		else

			{

			_LIT8(KExitNormalStr, "(Normal)");

			_LIT8(KExitKillStr, "(Kill)");

			_LIT8(KExitTerminateStr, "(Terminate)");

			_LIT8(KExitPanicStr, "Panic:");

			_LIT8(KKillNormalInfoFormatStr, "%S::%S Thread Died %S - Category: \"%S\", Reason: %d, Thread ID: %x, BTrace ID: 0x%x");

			_LIT8(KKillCancelInfoFormatStr, "%S::%S Thread Died %S - Category: \"%S\", Reason: %d, Thread ID: %x, BTrace ID: 0x%x");

			_LIT8(KKillErrorInfoFormatStr, "ERROR: %S::%S Thread Died %S - Category: \"%S\", Reason: %d, Thread ID: %x, BTrace ID: 0x%x");

			_LIT8(KPanicInfoFormatStr, "ERROR: %S::%S Thread Died %S %S %d - Thread ID: %x, BTrace ID: 0x%x");

			TPtrC8 type8;

			TPtrC8 formatStr;

			// Determine the reason why the thread exited and try to log as much information

			// as possible if the exit was unexpected.

			switch(type)

				{

				case EExitKill:

					{

					switch(reason)

						{

						case KErrNone:

							type8.Set(KExitNormalStr);

							formatStr.Set(KKillNormalInfoFormatStr);

						break;

						case KErrCancel:

							type8.Set(KExitKillStr);

							formatStr.Set(KKillCancelInfoFormatStr);

						break;

						default:

							type8.Set(KExitKillStr);

							formatStr.Set(KKillErrorInfoFormatStr);

						break;

						}

					}

				break;

				case EExitTerminate:

					type8.Set(KExitTerminateStr);

					formatStr.Set(KKillErrorInfoFormatStr);

				break;

				case EExitPanic:

					type8.Set(KExitPanicStr);

					formatStr.Set(KPanicInfoFormatStr);

				break;

				default:

					__ASSERT_DEBUG(false, User::Panic(KSpecAssert_ElemRootServerrt, 1)); // should never get here

				break;

				}

			// Decide if the thread exit was expected or caused by an error.

			#ifdef _DEBUG

				if((deadThread.ExitType() != EExitKill) || ((reason != KErrNone) && (reason != KErrCancel)))

					{

					// Log unexpected thread exits to the debug port.

					RDebug::Printf(reinterpret_cast<const char*>(formatStr.Ptr()), &processName8, &threadName8, &type8, &cat8, reason, TUint(deadThread.Id().Id()), deadThread.BTraceId());

					}

			#endif

			// Log the thread's death to UTrace if available.

			#ifdef SYMBIAN_TRACE_ENABLE

			    enum

			        {

			        KPrimaryFilter = 194, // server den

			        KMaxLogTextLength = 250

			        };

			    class TLogIgnoreOverflow8 : public TDes8Overflow

			        {

			        public:

			            void Overflow(TDes8& /*aDes*/) { }

			        };

				// Format the log text into a buffer for UTrace.

			    TBuf8<KMaxLogTextLength> buf;

		    	TLogIgnoreOverflow8 overflowHandler;

			    buf.AppendFormat(formatStr, &overflowHandler, &processName8, &threadName8, &type8, &cat8, reason, TUint(deadThread.Id().Id()), deadThread.BTraceId());

				UTracePfAny(KPrimaryFilter, KText, ETrue, EFalse, buf.Length(), buf.Ptr(), buf.Length());

			#endif

			// Log the thread's death to CFlog if available.

			__CFLOG_VAR((KLogSubSysRS, KLogCode, formatStr, &processName8, &threadName8, &type8, &cat8, reason, TUint(deadThread.Id().Id()), deadThread.BTraceId()));

			}

	#endif

	}

CModuleUndertaker::CModuleUndertaker(MNotifySuddenDeath& aNotifier, RThread& aThread)

: CActive(EPriorityLow),	// NB! lower priority than that of the session handlers to avoid race between undertaker & load handler

  iNotifier(aNotifier),

  iThread(aThread)

    /** Constructor for ModuleUndertaker

     */

    {

    }

CModuleUndertaker::~CModuleUndertaker()

    /** Destructor for ModuleUndertaker

     */

    {

    Cancel();

    }

EXPORT_C CCommsProviderModule::CCommsProviderModule( RThread& aThread ) 

	: CActive(EPriorityStandard)

	, iState(EIdle)

	, iThread(aThread)

	, iNotifiers(_FOFF(CNotifySuddenDeathContainer, iLink))

// Surplus initialisers left as documentation of intent

//iUndertaker(NULL),

    {}

EXPORT_C CCommsProviderModule::~CCommsProviderModule()

    {

	__CFLOG_1(KLogSubSysRS, KLogCode,

			_L8("CCommsProviderModule::~CCommsProviderModule: %S"), &iName);

    iSend.Close();

    iRecv.Close();

	if(iHeapPtr)

		{

#if defined(SYMBIAN_C32ROOT_API_V3)

#if !defined(ESOCKV3_TEMPORARY_PAIN_RELIEF)

#ifdef _DEBUG

		// If modules sharing a heap are unloaded in anything but LIFO order then

		// they can't easily check for leaks (ie A marks heap, B loads, A unloads but

		// doesn't check heap because it sees that someone else is using it, B unloads

		// and doesn't check heap either. The real owner of the heap is the RootServer,

		// so here we check the count and log leaked cells if any remain after the last

		// user has unloaded.

		// In _DEBUG builds we also execute a debugger breakpoint when cells remain,

		// unless the module has been flagged as "unstable". A stable module sharing a

		// heap with an unstable one might see this breakpoint but in general a leaky

		// module should have a private heap to ensure cleanup.

		RCFSharedHeap& heap = static_cast<RCFSharedHeap&>(*iHeapPtr);

		if(heap.AccessCount() <= 2)	//@todo worry more about why it's two

			{

			if(heap.Count() > 0)

				{

				__CFLOG_VAR( (KLogSubSysRSModule, KLogCode, _L8("~CCommsProviderModule: module '%S' heap(%08x) has %d cells remaining:"), &iName, &heap, heap.Count()) );

				heap.LogAllocatedCells(KLogSubSysRSModule, KLogRSLeakTag);

				// The configuration flags suppressing the panic: modules known to be unstable are not checked. These

				// include all modules that have panicked (if they never had the chance to cleanup it isn't helpful

				// to list "leaks")

				const TUint32 noCheckCondition = TRSStartModuleParamContainer::KCF_UnstableModule;

				// If not waivered by optional flags, call __DEBUGGER()

				if( (iControlFlags & noCheckCondition)==0)

					{

					RProperty pubsub;

					TInt res = pubsub.Attach(iRootServer->iProcessKey, iRootServer->iLeakKey.iUid);	

					//Does not leave before close therefore no need for cleanup stack

					if (res == KErrNone)

						{

						TInt count;

						res =pubsub.Get(count);

						if (res == KErrNone)

							{

							++count;

							res =pubsub.Set(count);

							}

						}

					pubsub.Close();

					if (res != KErrNone)

						{

						__CFLOG_1(KLogSubSysRSModule, KLogRSLeakTag, _L8("Unable to report leaks. Error: %d"), res);

						}

					}

				// As much as anything this log line is here to make it apparent that the breakpoint above was hit

				// See the comment block above for more explanations.

				__CFLOG_VAR( (KLogSubSysRSModule, KLogRSLeakTag, _L8("--- end of leaked cell log")) );

				}

			}

#endif

#endif

#endif

		iHeapPtr->Close();

		}

	if(iRootServer->FindCpm(iName))

		{

		iLink.Deque();                     // Remove from list in Root Server

		__CFLOG_1(KLogSubSysRS, KLogCode,

		_L8("CCommsProviderModule::~CCommsProviderModule: removing %S from RS List"), &iName);

		}

    delete iUndertaker;

	// Create a timer in case some other entity holds an open handle on the

	// thread which prevents the kernel from destroying it.  We timeout

	// after one second.

	TAutoClose<RTimer> timer;

	if(timer.iObj.CreateLocal() == KErrNone)

		{

		// Ensure the thread has been destroyed by using a notification so that its unique name is available for

		// reuse in case the module is reloaded soon afterwards.

		TRequestStatus destructionStatus;

		iThread.NotifyDestruction(destructionStatus);

	    iThread.Close();

		enum{ KThreadDestructionTimeout = 1000000 };

		TRequestStatus timerStatus;

		timer.iObj.After(timerStatus, KThreadDestructionTimeout);

		// Wait for the thread to be destroyed or for the timeout.

		User::WaitForRequest(destructionStatus, timerStatus);

		if(timerStatus.Int() == KRequestPending)

			{

			timer.iObj.Cancel();

			User::WaitForRequest(timerStatus);

			}

		else

			{

			User::CancelMiscNotifier(destructionStatus);

			User::WaitForRequest(destructionStatus);

			__CFLOG_2(KLogSubSysRS, KLogCode,

				_L8("CCommsProviderModule::~CCommsProviderModule: %S thread has still not been destroyed after %fs"), &iName, KThreadDestructionTimeout / 1000.0);

			}

		}

	else

		{

		iThread.Close();

		}

	// If a starting thread has been given the pointer then it's too dangerous to delete it here as might crash

	// them - better to risk a small leak

	if(iState != EStarting)

		{

		delete iThreadStartupInfo;

		}

#ifdef SYMBIAN_C32ROOT_API_V3

	delete iIniData;

#endif

	// Remove from CActiveScheduler

    if(IsAdded())

    	{

        Deque();

        }

	// Remove from RootServer list of modules

	if(iLink.iNext != NULL)

		{

		iLink.Deque();

		}

    }

TInt CCommsProviderModule::CancelLoad()

    /** Cancel Load. Marks whether an attempt to cancel load has happened

     *

     * @return	KErrCancel if cancelation of the load module operation was initiated

     *			or KErrRSModuleAlreadyExist if the module's thread has started

     *			running and can no longer be canceled.

     */	

    {

	__CFLOG_1(KLogSubSysRS, KLogCode,

			_L8("CCommsProviderModule - CancelLoad %S"), &iName);

	TInt result = KErrCancel;			

	// Check to see if the load module operation can be canceled or if the thread

	// is already in the process of starting.

	if((iState == EStarting) || (iState == ERunning))

		{

		__CFLOG_1(KLogSubSysRS, KLogCode,

				_L8("CCommsProviderModule - CancelLoad: %S module has already started running and can no longer be canceled"), &iName);

		result = KErrRSModuleAlreadyExist;

		}

	return result;

    }

TInt CCommsProviderModule::CancelUnload(TRSUnLoadType aType)

    /** Cancel unload. Marks whether an attempt to cancel an unload has happened

     *

     * @param	aType The type of unload that was in progress

     * @return	KErrCancel if cancelation of the unload module operation was initiated

     *			or KErrRSModuleNotLoaded if the module's thread has started dying and

     *			can no longer be canceled.

     */	    

	{

	#ifdef __CFLOG_ACTIVE

		TPtrC8 unloadType = GetUnloadTypeName(aType);

		__CFLOG_2(KLogSubSysRS, KLogCode,

				_L8("CCommsProviderModule - CancelUnload: %S module has started an %S unload"), &iName, &unloadType);

	#endif

	TInt result = KErrCancel;			

	// Check to see if the unload module operation can be canceled or if the thread

	// is already in the process of dying.

	if(aType == EUnGraceful)

		{

		__CFLOG_1(KLogSubSysRS, KLogCode,

				_L8("CCommsProviderModule - CancelUnload: %S module has already started an EUnGraceful unload and can no longer be canceled"), &iName);

		result = KErrRSModuleNotLoaded;

		}

	else

		{

	 	if(iState==EStopping)

			{

			iState=ERunning;

			}

		}

	return result;

    }

void CCommsProviderModule::CreateThreadL()

    /** Creates and sets up thread ready for initialisation

     */

    {

    iUndertaker = CModuleUndertaker::NewL(*this, iThread);

    TInt res = iLibrary.Load(iDll);

    __CFLOG_STMT(TBuf8<KMaxFileName> fnam;)

	__CFLOG_STMT(fnam.Copy(iDll);)

    if (res!=KErrNone && res!=KErrAlreadyExists)

		{

		__CFLOG_2(KLogSubSysRS, KLogCode,

			_L8("CModuleBase::CreateThreadL: Unable to load DLL %S: %d."),

			&fnam, res);

        User::Leave(res);

		}

	__CFLOG_1( KLogSubSysRS, KLogCode,

		_L8("CModuleBase::CreateThreadL: Loaded module library %S."),

		&fnam);

    TUidType type = iLibrary.Type();

    if ( ! UidMatch(type[1]) )

		{

		__CFLOG_1(KLogSubSysRS, KLogCode,_L8("CModuleBase - UID mismatch for %S"), &fnam);

        User::Leave(KErrRSInvalidUidType);

		}

	// If ordinal is set to 0, default to 1 (first)

	if(iThreadFunctionOrdinal==0)

		{

		__CFLOG(KLogSubSysRS, KLogCode, _L8("CModuleBase - Using default ordinal: 1"));

		iThreadFunctionOrdinal = 1;

		}

	__CFLOG_STMT(

	else

		{

		__CFLOG_1(KLogSubSysRS, KLogCode,_L8("CModuleBase - Using configured ordinal: %d"), iThreadFunctionOrdinal);

		}

		); // __CFLOG_STMT

    TThreadFunction libEntry=(TThreadFunction)iLibrary.Lookup(iThreadFunctionOrdinal);

    if (libEntry==NULL)

    	{

        User::Leave(KErrBadLibraryEntryPoint);

        }

    RCFChannel::TMsgQueues inputQueue;

	RCFChannel::TMsgQueues outputQueue;

	iSend.GetMsgQueues(inputQueue);

	iRecv.GetMsgQueues(outputQueue);

	iThreadStartupInfo = new(ELeave) CRSTransientModuleInfo(outputQueue, inputQueue, iHeapType, libEntry, iIniData, iPriority, iControlFlags);

#ifdef SYMBIAN_C32ROOT_API_V3

	iIniData = NULL;	// iThreadStartupInfo now has ownership

#endif

	switch(iHeapType)

		{