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

#include "C32LOG.H"

#include "CS_STD.H"

#include "cs_roles.h"

#include "cs_msgs.h"

#include "cs_glob.h"

#include <elements/nm_address_internal.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <cflog.h>

#endif

#include <elements/cftransportmsg.h>

using namespace CommsFW;

#ifndef KLogSubSysSerComms

__CFLOG_STMT(_LIT8(KLogSubSysSerComms, "SerComms");)

#endif

//

//	CC32WorkerThread class definitions

//

CC32WorkerThread* CC32WorkerThread::NewL(TCFModuleInfo* aModuleInfo)

	{

	CleanupStack::PushL(TCleanupItem(DeleteHBufC8, aModuleInfo->iIniData));	

	CC32WorkerThread* self = new (ELeave) CC32WorkerThread;

	CleanupStack::PushL(self);

	self->ConstructL(aModuleInfo);

	CleanupStack::Pop(self);

	CleanupStack::PopAndDestroy();	// aModuleInfo->iIniData	

	return self;

	}

CC32WorkerThread::CC32WorkerThread()

#ifdef _DEBUG  

   : iFailType(RAllocator::ENone)

#endif

	{

	}

/**

The worker thread secondary construction will create the relevant Player/Dealer

instances needed as well as the channel handler to the Root Server. If and only if it

is the main thread it will also create the PitBoss.

@note If it has a Dealer and is not the main thread it is a WorkerDealer.

*/

void CC32WorkerThread::ConstructL(TCFModuleInfo* aModuleInfo)

	{

	TBool isDealer;

	TBool isPlayer;

	__CFLOG_OPEN;

	C32LOG1(KC32Bootup,_L8("CC32WorkerThread::ConstructL Determining roles"));

	DetermineRoleL(*aModuleInfo->iIniData, isDealer, isPlayer);

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

	iTransport = CCommsTransport::NewL(*iWorkerRegister, NULL, NULL);

	iTransport->RegisterLegacyInterface(this);

	// initglobals allocates on heap and stores pointer in TLS, so

	// requires special cleanup if we leave beyond here - handled in RunC32Thread

	C32GlobalUtil::InitC32GlobalsL(this);

#ifdef _DEBUG

  	if(aModuleInfo->iIniData!=NULL)

  		{

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

	  			C32LOG1(KC32Bootup, _L("Panic - Corrupt Ini data - AllocFail param"));

	  			Fault(EBadIniData);

	  			}

	  		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	// _DEBUG

	if(isDealer)

		{

		if(IsMainThread())

			{

			C32LOG(KC32Bootup, _L8("I am the Main Thread. Creating Dealer."));

			iDealer = CC32Dealer::NewL(this,*(aModuleInfo->iIniData));

			if(iDealer->ThreadManager())

				{

				if(iDealer->ThreadManager()->DefaultThread() == KMainThreadId)

					{

					/*

					The default thread which loads unlisted CSYs is the dealer/main thread (workerId=0),

					this isn't	normal in a multi-threaded configuration, but can happen due to 

					1. BAD configuration (would fault in debug builds to signal a corrupt configuration, but not in release)

					2. CMI files with no C32SerComms group field in it.

					3. CSYList=* field present in IniData section of dealer/main thread (workerId=0) [valid, but discouraged in multi-threaded conf]

					*/

					C32LOG(KC32Warning,_L8("Dealer is default thread for loading unlisted CSYs! A BAD configuration perhaps ?"));

					isPlayer=ETrue;

					}

				}

			}

		}

	else

		{

		SetDealerShutdownComplete(ETrue);

		}

	if(isPlayer)

		{

		C32LOG1(KC32Bootup, _L8("I am a Player, creating instance."));

		iPlayer = CC32Player::NewL(this);

		}

	else

		{

		SetPlayerShutdownComplete(ETrue);

		}

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

	C32LOG1(KC32Bootup, _L8("CC32WorkerThread::ConstructL Init RS ChannelHandler"));

	iChannelHandler = CCommChannelHandler::NewL(aModuleInfo->iRxQueues, aModuleInfo->iTxQueues, this);

	C32LOG1(KC32Bootup, _L8("CC32WorkerThread::ConstructL Done"));

	}

CC32WorkerThread::~CC32WorkerThread()

	{

	C32LOG2(KC32Shutdown, _L8("CC32WorkerThread(%08x)::~CC32WorkerThread()"), this);

	delete iTransport;

	delete iChannelHandler;

	delete iPlayer;

	if(IsMainThread())

		{

		delete iDealer;

		}

	delete iWorkerRegister;

	C32LOG2(KC32Shutdown, _L8("CC32WorkerThread(%08x)::~CC32WorkerThread() complete"), this);

	__CFLOG_CLOSE;

	}

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

void CC32WorkerThread::DetermineRoleL(const TDesC8& aIniData, TBool &aIsDealer, TBool &aIsPlayer)

	{

	aIsDealer = EFalse;

	aIsPlayer = EFalse;

	// BC when No IniData present, this CPM is both Dealer and Player

	if(&aIniData==NULL)

		{

		aIsDealer = ETrue;

		aIsPlayer = ETrue;

		}

	else

		{

		TPtrC8 roleValue;

		// Role missing - Dealer

		if (!GetVarFromIniData(aIniData, KNullDesC8, KRoleLabel, roleValue))

			{

			aIsDealer = ETrue;

			}

		else

			{

			// Role present - player

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

				{

				aIsPlayer = ETrue;

				}

			// Role present - dealer

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

				{

				aIsDealer = ETrue;

				}

			// Role present - invalid arg

			else

				{

				C32LOG2(KC32Warning, _L8("Invalid Role in [IniData] section: %S"),&roleValue);

				__ASSERT_DEBUG(0,Fault(EBadIniData));

				}

			}

		// WorkerId missing

		TPtrC8 workerIdValue;

		if(!GetVarFromIniData(aIniData, KNullDesC8, KWorkerIdLabel, workerIdValue))

			{

			C32LOG1(KC32Warning, _L8("Corrupt [IniData]: WorkerId missing."));

			__ASSERT_DEBUG(0,Fault(EBadIniData));

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

			User::Leave(KErrCorrupt);		

			}

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

		// check for boundary values for WorkerId

		if(iWorkerId > TC32WorkerThreadPublicInfo::EMaxWorkerThreadId)

			{

			C32LOG2(KC32Warning, _L8("Corrupt [IniData]: Invalid WorkerId: %d"),iWorkerId);

			__ASSERT_DEBUG(0,Fault(EBadIniData));

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

			User::Leave(KErrCorrupt);

			}

		if(iWorkerId == TC32WorkerThreadPublicInfo::EMainThread && aIsDealer == EFalse)

			{

			C32LOG1(KC32Warning, _L8("Worker Id zero with no dealer role. overriding"));

			aIsDealer = ETrue;

			}

		// CSYList present - Player

		TPtrC8 csyListValue;

		if(GetVarFromIniData(aIniData, KNullDesC8, KCSYListLabel, csyListValue))

			{

			aIsPlayer = ETrue;

			}

		}	// End of else block [if(aIniData==NULL)]

	}

/**

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

*/

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

	{

	TInt err = KErrNone;

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

		{

		err = KErrCorrupt;	

		}

	else 

		{

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

			aPeerId > TC32WorkerThreadPublicInfo::EMaxWorkerThreadId)

			{

			err = KErrCorrupt;	

			}

		}

	return err;

	}

/**

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

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

Bindings are expressed in C32 by CCommsTransport. Since all sub-module

names are unique across all C32 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

CCommsTransport 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 "dumb" Player: Send bind response immediately.

	-# This worker is the Main thread: Send introduction messages to remote end and 

	postpone bind response until introduction response messages have arrived back.

@see CCommsTransport

*/

void CC32WorkerThread::CFBindMessageReceived(const TCFBindMsg& aMsg)

	{

    __CFLOG_SMADDR2(( KLogSubSysSerComms, KLogSubSysSerComms, _L8("W%d: CFBindMessageReceived %S <=> %S"),

		WorkerId(),

		&aMsg.SubModule1()->Printable(__FullModName1), 

		&aMsg.SubModule2()->Printable(__FullModName2) ));

	TWorkerId bindId;

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

	ASSERT(bindId <=  TC32WorkerThreadPublicInfo::EMaxWorkerThreadId);

	if(err == KErrNone)

		{

		if(iTransport->PeerReachable(bindId))

			{

			C32LOG2(KC32Bootup, _L("%d Already exists. Error in configuration of cmi files"),bindId);

			//Must panic b/c the new module will be left in a half bound state and will tend to get out of hand

			__ASSERT_DEBUG(0, User::Panic(KCFTransportPanic, ECFTransInvalidWorkerId));

			}

		else

			{

			err = iTransport->EstablishTransportToPeer(bindId, aMsg.ChannelInput(), aMsg.ChannelOutput());

			// Main thread introduces itself; workers wait passively for this

			if(err == KErrNone)

				{

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

				if(IsMainThread())

					{

					C32LOG1(KC32Bootup, _L("Sending Introduction Message to Worker"));

					DealerByRef().SendIntroductionToWorker(bindId);

					}

				}

			}

		}

	/* Main dealer only completes when it has received the introduction response messages from peers,

	dumb players respond immediately. */

	if(err!=KErrNone || !IsMainThread())

		{

		TCFBindCompleteMsg respMsg(aMsg.Identifier(), err);

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

		}

	}

void CC32WorkerThread::SetDealerShutdownComplete(TBool aComplete)

	{

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

	if(aComplete)

		{

		iDealerShutdownComplete = aComplete;

		MaybeCompleteUnbindings();

		}

	}

void CC32WorkerThread::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 CC32WorkerThread::MaybeCompleteUnbinding

*/

void CC32WorkerThread::CFUnbindMessageReceived(const TCFUnbindMsg& aMsg)

	{

	// Mark the peer handler as unbinding

    __CFLOG_SMADDR2(( KLogSubSysSerComms, KLogSubSysSerComms, _L8("W%d: CFUnbindMessageReceived %S <=> %S"),

		WorkerId(),

		&aMsg.SubModule1()->Printable(__FullModName1), 

		&aMsg.SubModule2()->Printable(__FullModName2) ));

	TWorkerId unbindId;

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

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

		{

		__ASSERT_DEBUG(0, User::Panic(KCFTransportPanic, ECFTransAbsentWorker)); // shouldn't happen, but could possibly by race with thread panicked in shutdown?

		err = KErrNotFound;	

		}

	if(err == KErrNone)

		{

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

		iTransport->SetDropTransportPending(unbindId, ETrue);

		MaybeCompleteUnbinding(unbindId);

		}

	else

		{

		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 CC32WorkerThread::MaybeCompleteUnbinding

*/

void CC32WorkerThread::MaybeCompleteUnbindings()

	{

	if(iProlongBindingLife == 0)

		{

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

			{

			MaybeCompleteUnbinding(player);

			}

		}

	}

/** 

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 CC32Dealer::CanUnbindFromWorker

@see CC32Player::CanUnbindFromWorker

@see TCFUnbindCompleteMsg

*/

void CC32WorkerThread::MaybeCompleteUnbinding(TWorkerId aWorker)

	{

	if(iTransport->PeerReachable(aWorker) && iTransport->IsDropTransportPending(aWorker))

		{

		if(!Dealer() || Dealer()->CanUnbindFromWorker(aWorker))

			{

			if(!Player() || Player()->CanUnbindFromWorker(aWorker))

				{

				C32LOG2(KC32Bootup, _L("CC32WorkerThread::MaybeCompleteUnbinding(%d) - dropping transport & unbinding"), aWorker);

				TCFUnbindCompleteMsg respMsg(iTransport->LastRequestIdConcerningPeer(aWorker), KErrNone);

				iTransport->DropTransportToPeer(aWorker);

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

				}

			}

		}

	}

/** 

A shutdown message can be of several types:

    -# EImmediate: We shutdown immediately even if leaking resources, although doing a best effort to cleanup. However, SymbianOS doesnt allow the server to gracefully terminate sessions so certain things cant be cleaned up.

	-# EOptional: Ignored.

	-# EGraceful: The module only unloads once no resources remain, which means for the Dealer no sessions and for the Player no subsessions. The shutdown request arrives after the unbind requests.

@see CommsFW::TCFShutdownMsg

@see CommsFW::TCFShutdownType

@see CC32Dealer::ProcessShutdownRequest

@see CC32Player::ProcessShutdownRequest

@see CC32WorkerThread::SetShuttingDown

@see CC32WorkerThread::MaybeTriggerThreadShutdownCallback

*/

void CC32WorkerThread::CFShutdownMessageReceived(const CommsFW::TCFShutdownMsg& aMsg)

	{

	const CommsFW::TCFShutdownType type = aMsg.Type();

	C32LOG2(KC32Shutdown, _L("CFShutdownMessageReceived(%d)"), type);

	if(EOptional == type)

		{

		C32LOG1(KC32Shutdown, _L("Type is EOptional: ignoring"));

		return;

		}

	else if(EImmediate == type)

		{

		C32LOG1(KC32Shutdown, _L("Type is EImmediate"));

		DealerByRef().SetImmediateShutdownPresent();

		}

	SetShuttingDown();

	if(Dealer())

		{

		Dealer()->ProcessShutdownRequest(type);

		}

	if(Player())

		{

		Player()->ProcessShutdownRequest(type);

		}

	MaybeTriggerThreadShutdownCallback();

	}

void CC32WorkerThread::PostMessage(TWorkerId aWorkerId, TCFMessage& aMessage)

	{

	TCFLegacyMessagePacker::PackForPostage(aWorkerId, aMessage);

	iTransport->PostMessage(aMessage);

	}

/** 

Deal with incoming messages from other workers.

*/

void CC32WorkerThread::DispatchL(const TCFMessage& aMessage, TWorkerId aSenderId)

	{

	switch(aMessage.Code())

		{

	case TC32WorkerMsg::EMainIntroduction:

		{

		C32LOG2(KC32CommsTrspMsg, _L("DispatchL(%d). EMainIntroduction"), aSenderId);

		ASSERT(!IsMainThread());

		const TC32WorkerMainIntroductionMsg& msg = reinterpret_cast<const TC32WorkerMainIntroductionMsg&>(aMessage);

		iDealer = msg.Dealer();

		iWorkerRegister->SetGlobalThreadRegister(&iDealer->WorkerDataGlobals());

		TC32WorkerThreadPublicInfo info;

		info.Init(WorkerId(), aSenderId == TC32WorkerThreadPublicInfo::EMainThread);

		info.iWorker = this;

		TC32WorkerMainIntroductionRespMsg respMsg(info);

#ifdef _DEBUG

  		respMsg.SetFailType(iFailType);