// 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 <cflog.h>

#include <rsshared.h>

#include <commschan.h>

#include <cfshared.h>

#include <cfforwardmsg.h>

using namespace CommsFW;

#include "bm_defs.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_ElemRootServerbm, "ElemRootServerbm");

#endif

CPersistentSubModuleAddress::CPersistentSubModuleAddress(const TCFSubModuleAddress& aSubAddr,CPersistentSubModuleAddressCon* aContainerRef) :

	iSubAddr(aSubAddr),

	iContainerRef(aContainerRef),

	iAccessCount(1)

// aContainerRef - the container that will store this object

	{

	}

CPersistentSubModuleAddress* CPersistentSubModuleAddress::NewL(const TCFSubModuleAddress& aSubAddr, CPersistentSubModuleAddressCon* aContainerRef)

	{

	CPersistentSubModuleAddress* self = new (ELeave) CPersistentSubModuleAddress(aSubAddr,aContainerRef);

	return self;

	}

void CPersistentSubModuleAddress::Close(TInt aIndex)

// close a reference to this persistent sub module address

// aIndex - if specified, Close will assume this element is at the specified index in the container

//  otherwise we need to find ourselves in the container.

	{

	--iAccessCount;

	__ASSERT_DEBUG(iAccessCount >= 0, User::Panic(KSpecAssert_ElemRootServerbm, 1));

	if(iAccessCount == 0)

		{

		// remove

		if (aIndex >= 0)

			{

			// caller has already done work of finding which index

			iContainerRef->iPersistentModuleAddresses.Remove(aIndex);

			}

		else

			{

			TInt sessIdx = iContainerRef->iPersistentModuleAddresses.Find(this);

			if(sessIdx >= 0)

				{

				iContainerRef->iPersistentModuleAddresses.Remove(sessIdx);

				}

			}

		delete this;

		}

	}

void CloseObject(TAny* aObject)

/**

 * This method simply closes an object from the cleanup stack.  The object must contain

 * a Close method.

 *

 * @param	aObject - a TAny pointer to the object to close.

 * @return	None

 */

	{

	((CPersistentSubModuleAddress*)aObject)->Close();

	}

CPersistentSubModuleAddressCon* CPersistentSubModuleAddressCon::NewL()

	{

	CPersistentSubModuleAddressCon* self = new (ELeave) CPersistentSubModuleAddressCon();

	return self;

	}

CPersistentSubModuleAddressCon::~CPersistentSubModuleAddressCon()

	{

	__ASSERT_DEBUG(iPersistentModuleAddresses.Count() == 0, User::Panic(KSpecAssert_ElemRootServerbm, 2));

	iPersistentModuleAddresses.ResetAndDestroy();

	}

TCFSubModuleAddress& CPersistentSubModuleAddressCon::SetOrRetrieveNameLC(const TCFSubModuleAddress& aRef)

// aRef - module address to add and return a reference to

// pushes on the cleanup stack an operation to release this ref count object

// returns - ref to the persistent module address created. Increments count on this module address.

	{

	// find name

	TInt countBack = iPersistentModuleAddresses.Count();

	while (countBack > 0)

		{

		--countBack;

		CPersistentSubModuleAddress* modAddrRef = iPersistentModuleAddresses[countBack];

		if (modAddrRef->SubAddrRef()==aRef)

			{

			modAddrRef->Open();

			CleanupStack::PushL(TCleanupItem(CloseObject, modAddrRef));

			return modAddrRef->SubAddrRef();

			}

		}

	//not found so create copy of addr and add

	CPersistentSubModuleAddress* newModuleAddr;

	newModuleAddr = CPersistentSubModuleAddress::NewL(aRef,this);

	CleanupStack::PushL(newModuleAddr);

#ifdef _DEBUG

	TInt ret = iPersistentModuleAddresses.Append(newModuleAddr);

	__ASSERT_DEBUG(ret!=KErrAlreadyExists, User::Panic(KSpecAssert_ElemRootServerbm, 3));

	if (ret!=KErrNone)

		{

		User::Leave(ret);

		}

#else

	iPersistentModuleAddresses.AppendL(newModuleAddr);

#endif

	CleanupStack::Pop(newModuleAddr);

	CleanupStack::PushL(TCleanupItem(CloseObject, newModuleAddr));

	return newModuleAddr->SubAddrRef();

	}

void CPersistentSubModuleAddressCon::Remove(const TCFSubModuleAddress& aRef)

// panics in debug if not found

	{

	//find name

	TInt countBackIdx = iPersistentModuleAddresses.Count();

	while (countBackIdx > 0)

		{

		--countBackIdx;

		if (iPersistentModuleAddresses[countBackIdx]->SubAddrRef()==aRef)

			{

			iPersistentModuleAddresses[countBackIdx]->Close(countBackIdx);

			return;

			}

		}

	__ASSERT_DEBUG(0, User::Panic(KSpecAssert_ElemRootServerbm, 4)); // we should never get a request to remove a non-existent element. In release, under releasing is tolerable (leak), over releasing might panic elsewhere (speculative)

	}

CBindManager* CBindManager::NewL(MRootServerNotify& aRootServerNotifier)

/** Creates new CBindManager object.

@param aRootServerNotifier Callback object when an unknown message is received

@return Pointer to the CBindManager object

@leave KErrNoMemory

*/

	{

    __CFLOG(KLogSubSysRS, KLogCode, _L8("CBindManager::NewL"));

    CBindManager* pBm = new (ELeave) CBindManager();

    pBm->iNotify = &aRootServerNotifier;

	CleanupStack::PushL(pBm);

	pBm->ConstructL();

	CleanupStack::Pop(pBm);

    return pBm;

	}

void CBindManager::ConstructL()

	{

    iModuleNameStor = CPersistentSubModuleAddressCon::NewL();

	}

CBindManager::~CBindManager()

/** Destructor of CBindManager object.

*/

	{

    TDblQueIter<CModule> moduleIter(iModuleList);

    CModule *pModule;

    while((pModule = moduleIter++) != NULL)

		{

		delete pModule;

		}

    TDblQueIter<CJob> jobIter(iJobList);

    CJob *pJob;

    while((pJob = jobIter++) != NULL)

		{

		delete pJob;

		}

	delete iModuleNameStor;

    TDblQueIter<CBindInfo> bindIter(iBindList);

    CBindInfo *pBind;

    while((pBind = bindIter++) != NULL)

		{

		delete pBind;

		}

	}

void CBindManager::CreateModuleL(TRequestStatus& aStatus,

								 const TCFModuleNameF& aModule,

								 const RCFChannel::TMsgQueues& aInputQueues,

								 const RCFChannel::TMsgQueues& aOutputQueues)

/** Called by rootserver to inform the bindmanager of a new module and the queues

to be used for communicating with it. The bindmanager will send a Discovery

message to the module and will not complete the request until a valid

DiscoveryResp is received or timeout occurs.

@param aStatus status which will be completed when finished

@param aModule name of module to create

@param aInputQueues queues on which messages should sent to the module

@param aOutputQueues queues on which messages will be received from the module

@leave KErrNoMemory

@leave ERSModuleAlreadyExist

*/

	{

	// first check this module not already in my list

	TRAPD(ret, GetModulePtrL(aModule));

	if (ret != KErrRSModuleUnknown)

		{

	 	__CFLOG_1(KLogSubSysRS, KLogCode, _L8("CBindManager::CreateModuleL - %S already exists"), &aModule);

		User::Leave(KErrRSModuleAlreadyExist);

		}

	// ok, so add it to my list

	CModule* pModule = CModule::NewL(this, aModule, iTransactionId,

						            aInputQueues, aOutputQueues);

	CleanupStack::PushL(pModule);

	// now start a discovery request

	TUint taskId;

	pModule->DoDiscoverL(taskId);

	// and add the task to a job

	CJob *pJob = CJob::NewL(aStatus, this);

	CleanupStack::PushL(pJob);

	pJob->AddTaskL(taskId, pModule->Name());

	CleanupStack::Pop(pJob);

	// now put module in list

	CleanupStack::Pop(pModule);

	iModuleList.AddLast(*pModule);

	// put job in main list and start its timer

	iJobList.AddLast(*pJob);

	pJob->StartTimeout(KJobTimeoutMicroseconds);

	}

void CBindManager::SendL( const TCFModuleNameF& aModule, const RMessage2& aMessage )

	{

	CModule* pModule = GetModulePtrL( aModule );

	TCFForwardMsg forwardMsg(aMessage);

	pModule->SendL( forwardMsg );

	}

void CBindManager::UnbindAllModuleL(TRequestStatus& aStatus,

								  const TCFModuleNameF& aModule,

								  const TBool aModuleIsDead,

								  CJob*& pJob)

/** Send Unbind requests for every binding involving the specified module. If

the ModuleIsDead parameter is true then no messages will be sent to the

named target module.

@param aStatus status which will be completed when finished

@param aModule name of module to unbind

@param aModuleIsDead indicates whether the target module is dead, and therefore

should not be sent any messages

@param pJob var parameter which will be set to point to a new job if one is

created

@leave KErrNoMemory

@leave ERSModuleUnknown

@leave ERSSubModuleUnknown

@leave ERSBindingInProgress

*/

	{

	// first validate that at least one binding exists and

	// all bindings can be unbound

	TBool bindingFound = EFalse;

    TDblQueIter<CBindInfo> bindIter(iBindList);

    CBindInfo *pBind;

    while((pBind = bindIter++) != NULL)

		{

		if (pBind->SubModuleAddr1().Module() == aModule ||

			pBind->SubModuleAddr2().Module() == aModule)

			{

			bindingFound = ETrue;

			if (pBind->State1() == CBindManager::EBindInProgress ||

			    pBind->State2() == CBindManager::EBindInProgress)

				{

				User::Leave(KErrRSBindingInProgress);

				}

			}

		}

	if (!bindingFound)

		{

		// no tasks to perform so complete request and return immediately

		TRequestStatus *status = &aStatus;

		User::RequestComplete(status, KErrNone);

		pJob = 0;

		return;

		}

	// create a new job

	pJob = CJob::NewL(aStatus, this);

	CleanupStack::PushL(pJob);

	// now remove the bindings

	TBool tasksAdded = EFalse;

    bindIter.SetToFirst();

    while((pBind = bindIter++) != NULL)

		{

		if (pBind->SubModuleAddr1().Module() != aModule &&

			pBind->SubModuleAddr2().Module() != aModule)

			{

			// this binding not relevant

			continue;

			}

		// Bugfix: changed to ignore any binding to/from the module in question

		// if its state is >= EUnbindInProgress. Reasoning - this means that an unbind

		// has already been sent. Sending another can do no further good, and means we

		// have to cope with (legitimately) receiving multiple unbind responses.

		CBindManager::TBMBindState endpt1State = pBind->State1();

		CBindManager::TBMBindState endpt2State = pBind->State2();

		if(endpt1State == EUnbindInProgress || endpt2State == EUnbindInProgress)

			{

			continue;

			}

		TBool unbindModule1 = ETrue;

		if (endpt1State >= CBindManager::EUnbindInProgress ||

			(pBind->SubModuleAddr1().Module() == aModule && aModuleIsDead))

			{

			unbindModule1 = EFalse;

			pBind->SetState1(CBindManager::EUnbound);

			pBind->SetResult1(KErrNone);

			}

		TBool unbindModule2 = ETrue;

		if (endpt2State >= CBindManager::EUnbindInProgress ||

			(pBind->SubModuleAddr2().Module() == aModule && aModuleIsDead))

			{

			unbindModule2 = EFalse;

			pBind->SetState2(CBindManager::EUnbound);

			pBind->SetResult2(KErrNone);

			}

		if (!unbindModule1 && !unbindModule2)

			{

			// must be two binds within dead or not properly bound module -

			// nothing we can do but kill binding and look for next

		   __CFLOG_3(KLogSubSysRS, KLogCode, _L8("CBindManager::UnbindAllModuleL() - deleting CBindInfo(%08x) - es1=%d, es2=%d"), pBind, endpt1State, endpt2State);

			delete pBind;

			continue;

			}

		CTask* pTask1 = 0;

		TBool newTask1 = EFalse;

		CModule* pModule1 = 0;

		if (unbindModule1)

			{

			pModule1 = GetModulePtrL(pBind->SubModuleAddr1());

			const TCFSubModuleAddress& subModule1Ref1 = iModuleNameStor->SetOrRetrieveNameLC(pModule1->SubModuleNameRefL(pBind->SubModuleAddr1()));

			const TCFSubModuleAddress& subModule1Ref2 = iModuleNameStor->SetOrRetrieveNameLC(pModule1->SubModuleNameRefL(pBind->SubModuleAddr2()));

			newTask1 = pModule1->GetUnbindTaskL(

							subModule1Ref1,

							subModule1Ref2,

							aModuleIsDead,

							pTask1);

			if (newTask1)

				{

				CleanupStack::PushL(pTask1);

				}

			// coverity [leave_without_push] - existing tasks have already been allocated

			// and owned, therefore we don't need to push them onto the cleanup stack.

			pBind->SetState1(CBindManager::EUnbindInProgress);

			pJob->AddTaskL(pTask1->TaskId(), pBind->SubModuleAddr1().Module());

			tasksAdded = ETrue;

			}

		CTask* pTask2 = 0;

		TBool newTask2 = EFalse;

		CModule* pModule2 = 0;

		if (unbindModule2)

			{

			pModule2 = GetModulePtrL(pBind->SubModuleAddr2());

			//if we leave we will have this outstanding ref. Need to push onto cleanup stack until

			// we are clear of the "DoStartTaskL".

			const TCFSubModuleAddress& subModule2Ref1 = iModuleNameStor->SetOrRetrieveNameLC(pModule2->SubModuleNameRefL(pBind->SubModuleAddr1()));

			const TCFSubModuleAddress& subModule2Ref2 = iModuleNameStor->SetOrRetrieveNameLC(pModule2->SubModuleNameRefL(pBind->SubModuleAddr2()));

			newTask2 = pModule2->GetUnbindTaskL(

							subModule2Ref2,

							subModule2Ref1,

							aModuleIsDead,

							pTask2);

			if (newTask2)

				{

				CleanupStack::PushL(pTask2);

				}

			pBind->SetState2(CBindManager::EUnbindInProgress);

			// coverity [leave_without_push] - existing tasks have already been allocated

			// and owned, therefore we don't need to push them onto the cleanup stack.

			pJob->AddTaskL(pTask2->TaskId(), pBind->SubModuleAddr2().Module());

			tasksAdded = ETrue;

			if (newTask2)

				{

				pModule2->DoStartTaskL(pTask2);

				CleanupStack::Pop(pTask2);

				CleanupStack::Pop(2);     // moduleAddr refs from SetOrRetrieveNameLC calls

				}

			}

		if (newTask1)

			{

			__ASSERT_DEBUG(pModule1, User::Panic(KSpecAssert_ElemRootServerbm, 5));	// LINT is skeptical

			pModule1->DoStartTaskL(pTask1);

			CleanupStack::Pop(pTask1);

			CleanupStack::Pop(2);     // moduleAddr refs from SetOrRetrieveNameLC calls

			}

		} // end while

	if (tasksAdded)

		{

		iJobList.AddLast(*pJob);

		pJob->StartTimeout(KJobTimeoutMicroseconds);

		CleanupStack::Pop(pJob);

		}

	else

		{

		// no tasks to perform so complete request immediately

		TRequestStatus *status = &aStatus;

		User::RequestComplete(status, KErrNone);

		CleanupStack::PopAndDestroy(pJob);

		pJob = 0;

		}

	}

void CBindManager::ConvertRSBindType(const TRSBindType aType,

											TCFBindType& aUpperBindType,

											TCFBindType& aLowerBindType)

/** Convert a rootserver style binding type to the equivalent comms framework

type

@param aType a RootServer binding type

@param aUpperBindType comms framework bind type for upper submodule

@param aLowerBindType comms framework bind type for lower submodule

*/

	{

	switch(aType)

		{

	case EHierarchical:

		aUpperBindType = EHierarchicalUpper;

		aLowerBindType = EHierarchicalLower;

		break;

	case ECustom:

		aUpperBindType = EHorizontal;

		aLowerBindType = EHorizontal;

		break;

	default:

		aUpperBindType = EOther;

		aLowerBindType = EOther;

		break;

		}

	}

CBindInfo* CBindManager::FindBindInfo(const TCFSubModuleAddress& aUpperSubmodule,

									  const TCFSubModuleAddress& aLowerSubmodule)

/** If a bind exists between the two specified modules, then return a pointer to

it.

@param aUpperSubmodule the upper module in the bindinfo

@param aLowerSubmodule the lower module in the bindinfo

@return Ptr to a matching bindinfo or 0 is none found

*/

	{

    TDblQueIter<CBindInfo> bindIter(iBindList);

	CBindInfo* pBind = 0;

    while((pBind = bindIter++) != NULL)

		{

		// Bugfix; there's one bindinfo for two mirror-imaged requests, hence need to test both possibilities

		if((pBind->SubModuleAddr1() == aUpperSubmodule && pBind->SubModuleAddr2() == aLowerSubmodule) ||

		   (pBind->SubModuleAddr2() == aUpperSubmodule && pBind->SubModuleAddr1() == aLowerSubmodule))

			{

			break;

			}

		}