// Copyright (c) 2008-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 "sd_log.h"

#include <ecom/ecom.h>

#include "sd_roles.h"

#include "sd_rootserverchannelhandler.h"

#include "sd_thread.h"

#include "sd_msgs.h"

#include "sd_mintercept.h"

#include <elements/cfmacro.h>

#include <elements/cftransportmsg.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_ElemSvrDenWrkrTC, "ElemSvrDenWrkrTC");

#endif

using namespace Den;

using namespace CommsFW;

using namespace Elements;

CWorkerRootServChannelHandler::CWorkerRootServChannelHandler(CCommonWorkerThread* aWorkerThread)

:	CCFModuleChannelHandler(CActive::EPriorityStandard),

	iWorkerThread(aWorkerThread)

	{

	}

EXPORT_C CWorkerRootServChannelHandler* CWorkerRootServChannelHandler::NewL(RCFChannel::TMsgQueues aRxQueues,

																   RCFChannel::TMsgQueues aTxQueues,

																   CCommonWorkerThread* aWorkerThread)

	{

	CWorkerRootServChannelHandler* pHandler = new (ELeave) CWorkerRootServChannelHandler(aWorkerThread);

	CleanupStack::PushL(pHandler);

	pHandler->ConstructL(aRxQueues, aTxQueues);

	CleanupStack::Pop(pHandler);

	return pHandler;

	}

EXPORT_C TInt CWorkerRootServChannelHandler::Send(const TCFMessage &aMessage)

	{

	return inherited::Send(aMessage);

	}

/**

This will be called by the handler when a shutdown message have been received from

the Root Server. Delegating the call to the Worker Thread.

*/

void CWorkerRootServChannelHandler::CFMessageShutdown(const TCFShutdownMsg& aMessage)

	{

	iWorkerThread->CFShutdownMessageReceived(aMessage);

	}

/**

This will be called by the handler when a Discovery message have been received from

the Root Server. It will send a response, telling the Root Server that it has a single

sub-module/binding point which is named after the WorkerID.

As each Worker has a unique ID each worker thus also has a unique sub-module name to bind to,

which potentially allows for simpler handling code and easy to interpret logs.

*/

void CWorkerRootServChannelHandler::CFMessageDiscover(const TCFDiscoverMsg& aMessage)

	{

	// ESOCKV3 CPMs use a single binding point for all messages

	__ASSERT_DEBUG(aMessage.Size() > 0, User::Panic(KSpecAssert_ElemSvrDenWrkrTC, 1));

	TBuf<4> subname;

	_LIT(subconst, "%d");

	subname.Format(subconst, iWorkerThread->WorkerId());

	aMessage.SubModuleNames()->Copy(subname);

	TCFDiscoverRespMsg respMsg(aMessage.Identifier(), 1, EFalse);

	VERIFY_RESULT(Send(respMsg), KErrNone);

	}

/**

This will be called by the handler when a Bind message have been received from

the Root Server. Delegating the call to the Worker Thread.

*/

void CWorkerRootServChannelHandler::CFMessageBind(const TCFBindMsg& aMessage)

	{

	iWorkerThread->CFBindMessageReceived(aMessage);

	}

/**

This will be called by the handler when a Unbind message have has received from

the Root Server. Delegating the call to the Worker Thread.

*/

void CWorkerRootServChannelHandler::CFMessageUnbind(const TCFUnbindMsg& aMessage)

	{

	(void) aMessage;

	iWorkerThread->CFUnbindMessageReceived(aMessage);

	}

/**

This will be called by the handler when a transport message has been received from

the Root Server. Delegating the call to the Worker Thread.

*/

void CWorkerRootServChannelHandler::CFMessageForward(const TCFForwardMsg& aMessage)

	{

	iWorkerThread->CFMessageForward(aMessage);

	}

// CCommonWorkerThread class definitions

//

EXPORT_C void CCommonWorkerThread::DeleteHBufC8(TAny* aHBufC)

	{

	delete static_cast<HBufC8*>(aHBufC);

	}

EXPORT_C CCommonWorkerThread::CCommonWorkerThread()

:	iFailType(RAllocator::ENone),

	iFailRate(0)

	{

	}

EXPORT_C CCommonWorkerThread::~CCommonWorkerThread()

	{

	COMMONLOG((WorkerId(), KECommonServerTag, _L8("CCommonWorkerThread(%08x)::~CCommonWorkerThread()"), this));

	delete iChannelHandler;

	delete iPlayer;

	delete iDealer;

	delete iShutdownWatchDog;

	if(IsMainThread())

		{

		delete iPitBoss;

		}

	delete iWorkerRegister;

	Messages::TlsGlobals::UnInstallGlobals();

	delete iTransport;

#ifdef __ELEMENTS_MESSAGE_INTERCEPT_ACTIVE

	if(IsMainThread())

		{

		// We created and took ownership of the message intercept register so lets be the one to get rid of it

		delete &CMessageInterceptRegister::GetGlobal();

		}

	CMessageInterceptRegister::SetGlobal(NULL);

#endif // __ELEMENTS_MESSAGE_INTERCEPT_ACTIVE

	}

EXPORT_C void CCommonWorkerThread::ConstructL(TCFModuleInfo& aModuleInfo, CShutdownWatchDog& aShutdownWatchDog)

	{

	__ASSERT_DEBUG(iShutdownWatchDog==NULL, User::Panic(KSpecAssert_ElemSvrDenWrkrTC, 2));

	iShutdownWatchDog = &aShutdownWatchDog;

	COMMONLOG((iWorkerId, KECommonBootingTag, _L8("CCommonWorkerThread::ConstructL Determining roles")));

	TBool isDealer;

	TBool isPlayer;

	TPlayerRole playerRole;

	DetermineRoleL(aModuleInfo.iIniData, isDealer, isPlayer, playerRole);

	iWorkerRegister = CWorkerRegister::NewL(WorkerId(), NULL);

	iGlobals = &Messages::TlsGlobals::InstallGlobalsL();

	iTransport = CCommsTransport::NewL(*iWorkerRegister, iGlobals->VirtualCtor(), NULL); //walker);

	iGlobals->SetTransportSender(&iTransport->GetSender());

	iGlobals->SetTransportReceiver(&iTransport->GetReceiver());

	iTransport->RegisterLegacyInterface(this);

	if(isDealer)

		{

		COMMONLOG((iWorkerId, KECommonBootingTag, _L8("Creating Dealer.")));

		iDealer = DoCreateDealerL(this, playerRole);

		if(IsMainThread())

			{

			COMMONLOG((iWorkerId, KECommonBootingTag, _L8("Creating PitBoss.")));

			iPitBoss = DoCreatePitBossL(this);

			}		

		}

	else

		{

		SetDealerShutdownComplete(ETrue);

		}

	if(isPlayer)

		{

		COMMONLOG((iWorkerId, KECommonBootingTag, _L8("I am a Player for roles #%08x, creating instance."), playerRole.Role()));

		iPlayer = DoCreatePlayerL(this, playerRole);

		}

	else

		{

		SetPlayerShutdownComplete(ETrue);

		}

#if defined (_DEBUG)

	// Support for simulated heap allocation failures: place "AllocFail= type rate" in .CMI file

	// where:

	//	type == ERandom, ETrueRandom, EDeterministic, EFailNext

	//	rate == rate/chance of failure

	// See RAllocator documentation for details. Best to set this for the heap owner only, since the

	// last one processed will determine function for all heap users & it could get confusing.

	_LIT8(KAllocFailLabel, "AllocFail");

	TPtrC8 allocFail;

	if(GetVarFromIniData(*(aModuleInfo.iIniData), KNullDesC8, KAllocFailLabel, allocFail))

		{

		TLex8 lex(allocFail);

		TPtrC8 failTypeTok = lex.NextToken();

		const struct

			{

			const TText8* iLabel;

			RAllocator::TAllocFail iType;

			} failModes[] =

			{

				{ _S8("ERandom"), RAllocator::ERandom },

				{ _S8("ETrueRandom"), RAllocator::ETrueRandom },

				{ _S8("EDeterministic"), RAllocator::EDeterministic },

				{ _S8("EFailNext"), RAllocator::EFailNext }

			};

		TInt i;

		for(i = sizeof(failModes) / sizeof(failModes[0]) - 1; i >= 0; --i)

			{

			if(TPtrC8(failModes[i].iLabel).CompareF(failTypeTok) == 0)

				{

				break;

				}

			}

		TInt rate = 0;

		lex.SkipSpace();

		if(i < 0 || lex.Val(rate) != KErrNone)

			{

			// Already in Debug mode so just log and panic

			COMMONLOG((iWorkerId, KECommonBootingTag, _L8("Panic - Corrupt Ini data ")));

			User::Panic(KDenFaultPanic, ECommonCorruptIniData);

			}

		iFailType = failModes[i].iType;

		iFailRate = rate;

		}

	/*

	For debug builds, ensure that the array inside the cleanup stack will never

	need to allocate any memory. This aids checking for leaked cells across a

	sequence of calls that is heap-balanced.

	*/

		{

		const TInt KStretchExtent = 10;

		TRAP_IGNORE(

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

				{

				CleanupStack::PushL((TAny*)1);

				}

			CleanupStack::Pop(KStretchExtent);

			)

		}

#endif

	// Start listening for binds, etc, from the RS

	COMMONLOG((iWorkerId, KECommonBootingTag, _L8("CWorkerThread::ConstructL Init RS ChannelHandler")));

	iChannelHandler = CWorkerRootServChannelHandler::NewL(aModuleInfo.iRxQueues, aModuleInfo.iTxQueues, this);

#ifdef __ELEMENTS_MESSAGE_INTERCEPT_ACTIVE

	if(iDealer)

		{

		if(IsMainThread())

			{

			// Create our process wide esock debug message intercept register singleton here

			// We are the main thread and so in charge of esock debug

			// We are only going to ever create one so something wrong if already exists

			CMessageInterceptRegister* msgIntercept = CMessageInterceptRegister::NewL();

			CMessageInterceptRegister* current = CMessageInterceptRegister::SetGlobal(msgIntercept);

			__ASSERT_DEBUG(!current, User::Panic(KSpecAssert_ElemSvrDenWrkrTC, 3));

			// Can also register our debug message interface here

			// The main thread is the only place we will be dispatching them

			iGlobals->RegisterInterfaceL(TMIMessages::ImplementationUid(),

				                         TMIMessages::ImplementationProxyTableSize(),

				                         TMIMessages::ImplementationProxyTable());

			}

		}

#endif // __ELEMENTS_MESSAGE_INTERCEPT_ACTIVE

	}

EXPORT_C void CCommonWorkerThread::DestroyDealer()

	{

	COMMONLOG((WorkerId(), KECommonServerTag, _L8("CCommonWorkerThread::DestroyDealer()")));

	delete iDealer;

	iDealer = NULL;

	}

EXPORT_C void CCommonWorkerThread::DestroyPlayer()

	{

	COMMONLOG((WorkerId(), KECommonServerTag, _L8("CCommonWorkerThread::DestroyPlayer()")) );

	delete iPlayer;

	iPlayer = NULL;

	}

/** Determine from inidata whether this worker is Dealer, Player or both. */

EXPORT_C void CCommonWorkerThread::DetermineRoleL(HBufC8* aIniData, TBool& aIsDealer, TBool& aIsPlayer, TPlayerRole& aPlayerRole)

	{

	_LIT8(KRoleLabel, "Role");

	_LIT8(KDealerRole, "Dealer");

	_LIT8(KPlayerRole, "Player");

	_LIT8(KDealerPlayerRole, "DealerPlayer");

	_LIT8(KWorkerIdLabel, "WorkerId");

	_LIT8(KDefaultOptimalDealer, "DefaultOptimalDealer");

	__ASSERT_DEBUG(iShutdownWatchDog, User::Panic(KSpecAssert_ElemSvrDenWrkrTC, 4)); //Have you called CCommonWorkerThread::ConstructL?

	TPtrC8 roleValue;

	TPtrC8 workerIdValue;

	if(aIniData==NULL || !CommsFW::GetVarFromIniData(*aIniData, KNullDesC8, KRoleLabel, roleValue) ||

		!CommsFW::GetVarFromIniData(*aIniData, KNullDesC8, KWorkerIdLabel, workerIdValue))

		{

		COMMONLOG((WorkerId(), KECommonBootingTag, _L8("Corrupt IniData.")));

#ifdef _DEBUG

			User::Panic(KDenFaultPanic, ECommonCorruptIniData);

#endif

		// leave if ini data corrupt rather than panic unless debug

		User::Leave(KErrCorrupt);

		}

	aIsDealer = EFalse;

	aIsPlayer = EFalse;

	if(roleValue.CompareF(KDealerPlayerRole)==0)

		{

		aIsDealer = ETrue;

		aIsPlayer = ETrue;

		}

	else if(roleValue.CompareF(KDealerRole)==0)

		{

		aIsDealer = ETrue;

		}

	else if(roleValue.CompareF(KPlayerRole)==0)

		{

		aIsPlayer = ETrue;

		}

	else

		{

		COMMONLOG((WorkerId(), KECommonBootingTag, _L8("Corrupt IniData, no role recognised - Must be Dealer, Player or DealerPlayer")));

#ifdef _DEBUG

		User::Panic(KDenFaultPanic,ECommonCorruptIniData);

#endif

		// leave if ini data corrupt rather than panic if not debug

		User::Leave(KErrCorrupt);

		}

	User::LeaveIfError(CommsFW::ConvertVal(workerIdValue, iWorkerId));

	if(iWorkerId > TWorkerThreadPublicInfo::EMaxWorkerThreadId)

		{

		COMMONLOG((WorkerId(), KECommonBootingTag, _L8("Corrupt IniData, invalid WorkerId.")));

#ifdef _DEBUG

		User::Panic(KDenFaultPanic, ECommonCorruptIniData);

#endif

		// leave if ini data corrupt rather than panic if not debug

		User::Leave(KErrCorrupt);

		}

	CommsFW::GetVarFromIniData(*aIniData, KNullDesC8, KDefaultOptimalDealer, iDefaultOptimalDealer);

	if(aIsPlayer)

		{

		DoDeterminePlayerRoleL(aIniData, aPlayerRole);

		}

	}

/**

Check that our end sub-module address is correctly named: the sub-module name must be numeric and match our worker id.

*/

EXPORT_C TInt CCommonWorkerThread::DecodePeerId(const TCFSubModuleAddress* aSubModule1, const TCFSubModuleAddress* aSubModule2, TWorkerId& aPeerId)

	{

	TInt err = KErrNone;

	if(CommsFW::ConvertVal(aSubModule1->SubModule(), aPeerId) != KErrNone || aPeerId != WorkerId())

		{

		err = KErrCorrupt;

		}

	else

		{

		if(CommsFW::ConvertVal(aSubModule2->SubModule(), aPeerId) != KErrNone ||

			aPeerId > TWorkerThreadPublicInfo::EMaxWorkerThreadId)

			{

			err = KErrCorrupt;

			}

		}

	return err;

	}

/**

Deals with binding requests from the Root Server. Note that although the Root Server allows

multiple identical bindings ESock does not allow this and will panic if the binding already exists.

Bindings are expressed in ESock by worker transport objects stored in an array. Since all sub-module

names are unique across all instances (they are the individual owning worker ID converted to text)

they can be used here. I.e. the remote end sub-module is converted back to int and used to insert the

CWorkerTransport into an array in the position corresponding to the remote end sub-module name/number.

As for responding to the bind request there are two cases:

    -# This worker is a "peer Player: Immediately introduce ourselves.

	-# This worker is the Main thread: Wait to receive its introduction message.

@see CWorkerTransport

*/

EXPORT_C void CCommonWorkerThread::SetDealerShutdownComplete(TBool aComplete)

	{

	// Backsliding not permitted; cannot step back to !complete

	if(aComplete)

		{

		iDealerShutdownComplete = aComplete;

		MaybeCompleteUnbindings();

		}

	}

EXPORT_C void CCommonWorkerThread::SetPlayerShutdownComplete(TBool aComplete)

	{

	// Backsliding not permitted; cannot step back to !complete

	if(aComplete)

		{

		iPlayerShutdownComplete = aComplete;

		MaybeCompleteUnbindings();

		}

	}

/**

The unbind requests are only responded to once the channel is presumed to be idle:

   - for Dealers this means no sessions remain with subsessions on that Player

   - for Players this means no subsessions remain for that Dealer

So the peer handler is marked as pending unbind but the unbind response is not sent back

until both Dealer and Player (if any) confirm idleness, which has to be checked whenever

closing sessions or subsessions.

Perhaps this could/should switch to using ref counts?

Once unbind is pending the Dealer refrains from creating any new subsessions which use it.

@see CCommonWorkerThread::MaybeCompleteUnbinding

*/

void CCommonWorkerThread::CFUnbindMessageReceived(const CommsFW::TCFUnbindMsg& aMsg)

	{

	// Get the bound module names for logging purposes.

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

		TCFFullModuleName fullModName1;

		TCFFullModuleName fullModName2;

		aMsg.SubModule1()->Printable(fullModName1);

		aMsg.SubModule2()->Printable(fullModName2);

	#endif

	// Mark the peer handler as unbinding

		WorkerId(),

		&fullModName1,

		&fullModName2 ));

	TWorkerId unbindId;

	TInt err = DecodePeerId(aMsg.SubModule1(), aMsg.SubModule2(), unbindId);

	if(err == KErrNone && !iTransport->PeerReachable(unbindId))

		{

		// This can happen if a module fails during startup (e.g., it is a duplicate protocol

		// which has been forcibly killed by the pitboss before it completed its binding) so

		// we log the failure and handle it silently unless a debugger is attached since it is

		// normally the result of a previous failure.  This enables the module cleanup code to

		// work properly and avoids a situation where the server is left in a bad state if we

		// paniced the ESock_Main thread instead.

		COMMONLOG((WorkerId(), KECommonErrorTag, _L8("ERROR: %S <=> %S cannot be unbound: W%d peer is no longer reachable"), &fullModName1, &fullModName2, unbindId));

		#ifdef _DEBUG

			// Add ASCII delimiters.

			fullModName1.Append('\0');

			fullModName2.Append('\0');

			RDebug::Printf("CCommonWorkerThread::CFUnbindMessageReceived ERROR: %s <=> %s cannot be unbound: W%d peer is no longer reachable", fullModName1.Ptr(), fullModName2.Ptr(), unbindId);

		#endif

		__CF_BREAK_IF_DEBUGGER();

		err = KErrNotFound;

		}

	if(err == KErrNone)

		{

		iTransport->SetLastRequestIdConcerningPeer(unbindId, aMsg.Identifier());

		iTransport->SetDropTransportPending(unbindId, ETrue);

		}

	else

		{

		CommsFW::TCFUnbindCompleteMsg respMsg(aMsg.Identifier(), err);

		VERIFY_RESULT(iChannelHandler->Send(respMsg), KErrNone);

		}

	}

/**

Can be called at any time, will poll all peer handlers for unbind "readiness" and make sure

they complete the unbind if possible.

@see CCommonWorkerThread::MaybeCompleteUnbinding

@return EFalse if one or more bindings remain

*/

EXPORT_C TBool CCommonWorkerThread::MaybeCompleteUnbindings()

	{

	if(iProlongBindingLife <= 0)

		{

		for(TWorkerId player = TWorkerThreadPublicInfo::EMainThread; player <= TWorkerThreadPublicInfo::EMaxWorkerThreadId; ++player)

			{

			// We always have a transport to ourself & it needs no unbinding

			if(player != WorkerId())

				{

				if(iTransport->PeerReachable(player))

					{

					return EFalse;

					}

				}

			}

		return ETrue;

		}

	return EFalse;	// as long as we're in nested prolong a binding *could* remain

	}

/**

If the peer handler have been marked for unbind check whether local Dealer/Player is ready to

unbind from this particular worker. If so, deletes handler and send unbind response to Root Server.

@see CCommonDealer::CanUnbindFromWorker

@see CCommonPlayer::CanUnbindFromWorker

@see TCFUnbindCompleteMsg

*/