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

#include <comms-infras/c32startcli.h>

#include <e32property.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <cflog.h>

#endif

#include "cs_roles.h"

#include "C32LOG.H"

#include "CS_STD.H"

#include "cs_msgs.h"

#include "cs_glob.h"

using namespace RootServer;

#define MSG_PRM(prmIndex)		(prmIndex)		// subsession is passed in message as parameter 3

const TInt KIniDataBufSizeIncrement = 60;   // Initial buffer of 60 chars - after finding 

                                           // usual iniData section uses about 40 chars to describe workerId,Role and CSYlist

//

// CC32WorkerDataGlobals

//

CC32WorkerDataGlobals* CC32WorkerDataGlobals::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(sizeof(TC32WorkerThreadRegister), KMaxWorkerThreadId);

	CleanupStack::Pop(self);

	return self;

	}

//

// CCSYInfo

//

CCSYInfo::CCSYInfo(TInt aThreadNum)

: iThreadNum(aThreadNum),

iLoaded(EFalse),

iLoadIndex(-1)

	{

	}

CCSYInfo* CCSYInfo::NewL(const TDesC8& aCSYName, TInt aThreadNum)

	{

	CCSYInfo* self = new (ELeave) CCSYInfo(aThreadNum);

	CleanupStack::PushL(self);

	self->ConstructL(aCSYName);

	CleanupStack::Pop(self);

	return self;

	}

void CCSYInfo::ConstructL(const TDesC8& aCSYName)

	{

	iCSYName=aCSYName.AllocL();

	}

CCSYInfo::~CCSYInfo()

	{

	delete iCSYName;

	iCSYPortPrefix.Close();

	}

TInt CCSYInfo::CompareCSYInfo(const CCSYInfo& aFirst,const CCSYInfo& aSecond)

// compares CSY records by comparing the csy filenames

    {

    //-ve if first is less than second

    return aFirst.iCSYName->CompareF(*(aSecond.iCSYName));

    }

TInt CCSYInfo::SetPortNameSizeToMaximum()

	{

	__ASSERT_DEBUG(iCSYPortPrefix.Length()==0,Fault(EBadState,_L8("CCSYInfo: attempt to grow portname for CSY for a non-null string (ie, module looks loaded)")));

	return iCSYPortPrefix.ReAlloc(KMaxFullName);	

	}

void CCSYInfo::SetPortName(const TDesC& aPortName)

	{

	// since this may be called at end of csy load process, we have no reasonable way to deal with OOM,

	// so before the csy load process started, the portname

	// was grown to max. After setting the string we resize the portname so that the remaining

	// memory is freed. An RBuf allows us to resize in-place.

	iCSYPortPrefix = aPortName;

#ifdef _DEBUG

	TInt ret = iCSYPortPrefix.ReAlloc(aPortName.Length());

	__ASSERT_DEBUG(ret == KErrNone,Fault(EBadState,_L8("CCSYInfo::SetPortName: failed to shrink port prefix. Ret: %d"),ret));

#else

	(void)iCSYPortPrefix.ReAlloc(aPortName.Length()); // on failure, continue with current size.

#endif

	}

void CCSYInfo::SetCSYHandle(CSerial* aSerialHandle)

//this handle is never actually used by CCSYInfo, just passed back to player later

	{

	iCSYHandle=aSerialHandle;

	}

//

// CC32ThreadManager::CC32ParsedIniData

//

CC32ThreadManager::CC32ParsedIniData::CC32ParsedIniData()

	{

	}

CC32ThreadManager::CC32ParsedIniData* CC32ThreadManager::CC32ParsedIniData::NewL(const TDesC8& aIniData, const TBool aIsDealer)

// aIsDealer specifies whether this data was sent to us from the configurator as it spawned the

// dealer thread

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aIniData,aIsDealer);

	CleanupStack::Pop(self);

	return self;

	}

CC32ThreadManager::CC32ParsedIniData::~CC32ParsedIniData()

	{

	iCSYs.Close();

	}

void CC32ThreadManager::CC32ParsedIniData::ConstructL(const TDesC8& aIniData, const TBool aIsDealer)

// we could have had the NewL perform this function, but because that would men creating and destroying

// this object for each data read, we chose to save that by making this operation separate

// aIsDealer - true if this is the inidata for the dealer loading all the cmi files. This allows

//             us to know this is a dealer even if nothing of the sort is in the [iniData] section and

//             thus we can preserve backwards compat.

// on exit the data should be:

// workerID = always correct - if we are dealer it is automatically 0 regardless of what config says. If we

//            are player we leave unless this is provided. We leave if it is zero and we are player.

// isPlayer - is false if we know we are dealer (aIsDealer) regardless of aIniData. Is true if we

//            see Role=player. If role missing and we are not Dealer (!aIsDealer) then we don't try

//            any recovery since a workerthread assumes it is a dealer if no role.

// isWildcard - true if a wildcard is provided in the csy list

// iCSYs - list of the csys in CSYList. It is valid that a dealer may not have a CSY list

	{

	TPtrC8 roleValue;

	TPtrC8 workerIdValue;

	TPtrC8 csyListValue;

	if (&aIniData==NULL || aIniData.Length()==0)

		{

		if (!aIsDealer)

			{

			C32LOG(KC32Warning,_L8("CC32ParsedIniData: Corrupt CMI file that references C32.DLL: Missing [IniData] section."));

			C32LOG(KC32Warning,_L8("CC32ParsedIniData: Please migrate all *.cmi files that reference C32.DLL to include Group token and [IniData] section."));

			// we don't panic in this scenario since this could be an old ini file we've found

			// in future we will panic here once licencees have migrated any cmi files they need to

			User::Leave(KErrCorrupt);

			}

		else

			{

			// dealers are allowed to not have CSYLists and we know what the role & workerId should be so continue

			// in future this will be a config error but during migration we continue.

   		    C32LOG(KC32Detail,_L8("CC32ParsedIniData: Supplied inidata for dealer is empty - must be old CMI file. Skipping."));

			return;

			}

		}

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

		{

		C32LOG(KC32Warning,_L8("CC32ParsedIniData: Corrupt [IniData] section - missing workerId value."));

		if (aIsDealer)

			{

			C32LOG(KC32Warning,_L8("CC32ParsedIniData: As we are dealer, ignoring corruption by setting workerId to 0 and continuing"));

			iCMIWorkerId = KMainThreadId;

			}

		else

			{

#ifdef _DEBUG

			Fault(EBadIniData); // panic

#endif

			User::Leave(KErrCorrupt);

			}

		}

	else

		{

		// we accept whatever we get as the workerId

		TLex8 lex(workerIdValue);

		(void)lex.Val(iCMIWorkerId);		

		}

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

		{

		C32LOG(KC32Warning,_L8("CC32ParsedIniData: Corrupt [IniData] section - missing Role label."));

		if (!aIsDealer)

			{

#ifdef _DEBUG

		Fault(EBadIniData); // panic

#endif

		User::Leave(KErrCorrupt);

			}

		}

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

		{

		iIsPlayer = ETrue;

		}

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

		{

		C32LOG2(KC32Warning,_L8("CC32ParsedIniData: Corrupt [IniData] section: Specified Role not recognised; must be Dealer or Player: %d "),&roleValue);

#ifdef _DEBUG

		Fault(EBadIniData); // panic

#endif

		User::Leave(KErrCorrupt);

		}

	if (iIsPlayer && (iCMIWorkerId < 0 || iCMIWorkerId > KMaxWorkerThreadId))

		{

		C32LOG2(KC32Warning,_L8("CC32ParsedIniData: Corrupt [IniData] section: Role=Player and WorkerId invalid: %d"),iCMIWorkerId);

#ifdef _DEBUG

		Fault(EBadIniData); // panic

#endif

		User::Leave(KErrCorrupt);

		}

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

		{

		if (iIsPlayer)

			{

			C32LOG(KC32Warning,_L8("CC32ParsedIniData: Corrupt [IniData] section - missing CSYList definition."));

#ifdef _DEBUG

		Fault(EBadIniData); // panic

#endif

			User::Leave(KErrCorrupt);

			}

		}

	else

		{

		TInt sectionLen = 0;	

		TPtrC8 section(csyListValue);

		while (section.Length() > 0)

			{

			// assume that a CSY name is at least 1 characters long

			sectionLen = section.Find(TPtrC8(_S8(",")));

			if (sectionLen > 0)

				{

				iCSYs.AppendL(section.Mid(0,sectionLen));

				if (sectionLen+1 < section.Length())

					{

					section.Set(section.Mid(sectionLen+1));

					} 

				else

					{

					section.Set(KNullDesC8);

					}

				} 

			else if ((sectionLen==0) && (section.Length() > 0))

				{

				//possibly a double comma - we'll be nice and ignore it

				section.Set(section.Mid(sectionLen+1));

				} 

			else if (section[0]=='*')

				{

				iIsDefault = ETrue;

				if (section.Length() > 1)

					{

					section.Set(section.Mid(1));

					} 

				else

					{

					section.Set(KNullDesC8);

					}

				}

			else

				{

				iCSYs.AppendL(section);

				section.Set(KNullDesC8);

				}

			}

		}		

	}

//

// CC32ThreadManager::CC32ThreadInfo

//

CC32ThreadManager::CC32ThreadInfo::CC32ThreadInfo()

	{

	}

CC32ThreadManager::CC32ThreadInfo* CC32ThreadManager::CC32ThreadInfo::NewL(const TDesC8& aModuleName)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aModuleName);

	CleanupStack::Pop(self);

	return self;	

	}

void CC32ThreadManager::CC32ThreadInfo::ConstructL(const TDesC8& aModuleName)

	{

	iModuleName = aModuleName.AllocL();

	}

void CC32ThreadManager::CC32ThreadInfo::SetModuleNameL(const TDesC8& aModuleName)

	{

	delete iModuleName;

	iModuleName = NULL;

	iModuleName = aModuleName.AllocL();

	}

CC32ThreadManager::CC32ThreadInfo::~CC32ThreadInfo()

	{

	delete iModuleName;

	}

TBool CC32ThreadManager::CC32ThreadInfo::CompareThreadInfo(const CC32ThreadInfo& aFirst,const CC32ThreadInfo& aSecond)

// aFirst should always be non-empty. aSecond may be an empty string if it is the dealer entry

	{

	return (aFirst.iModuleName==aSecond.iModuleName);

	}

//

// CCPMLoader

//

CC32ThreadManager::CCPMLoader::CCPMLoader()

    : CActive(EPriorityStandard)

    {

    // server is at a super-high priority, so whatever priority we choose is not going to make any difference

    CActiveScheduler::Add(this);

    }

CC32ThreadManager::CCPMLoader* CC32ThreadManager::CCPMLoader::NewL()

	{

    CCPMLoader* self = new(ELeave) CC32ThreadManager::CCPMLoader();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);    

    return self;

	}

void CC32ThreadManager::CCPMLoader::ConstructL()

	{

	TInt ret = iCfgSvr.Connect();

	if (ret != KErrNone)

 		 {

 		 C32LOG2(KC32Dealer,_L8("CC32Dealer::LoadModule failed during connect to configurator. Code: %d"),ret);

 		 User::Leave(ret);

 		 }

	}

void CC32ThreadManager::CCPMLoader::DoCancel()

	{

	C32LOG(KC32Detail,_L8("CC32Dealer::CCPMLoader: DoCancel called"));

	iCfgSvr.CancelLoadCpm(iName);

	}

CC32ThreadManager::CCPMLoader::~CCPMLoader()

    {

    Cancel();

    iCfgSvr.Close();

    // deques on delete of parent

    }	

void CC32ThreadManager::CCPMLoader::RequestModuleLoad(CC32ThreadManager* aThreadMgr, CommsFW::TWorkerId aWorker, const TCFModuleName& aName)

// Begin the asynchronous process of loading a player

	{

	__ASSERT_DEBUG(!IsActive(),Fault(EBadState,_L8("CCPMLoader: Loader already busy with another request when loading module %S. Panicking"),&aName));

	iName = TCFModuleName(aName);    // store so that when we lose stack at this function exit, RRs server can still read data

	iThreadManager = aThreadMgr;

	iWorkerId = aWorker;

	iCfgSvr.LoadCpm(iName,iStatus);

	SetActive();

	C32LOG2(KC32Dealer,_L8("CCPMLoader: Load request for module %S sent to Configurator"),&iName);

	}

void CC32ThreadManager::CCPMLoader::RunL()

// this normally never runs in the success case since new player's response beats it and dealer kills the loader.

	{

	TInt res = iStatus.Int();

	C32LOG4(KC32Dealer,_L8("CC32Dealer: Configurator has completed LoadCPM (%S)(WorkId%d) request with %d"),&iName,iWorkerId,res);

	// assert_debug in here that status is never "already running"

	__ASSERT_DEBUG(res != KErrRSModuleAlreadyExist, Fault(EBadState,_L8("CC32Dealer: LoadCPM returned KErrRSModuleAlreadyExists - this is unexpected so Panicking.")));

	__ASSERT_DEBUG(res != KErrRSModuleUnknown, Fault(EBadState,_L8("CC32Dealer: LoadCPM returned KErrRSModuleUnknown - probably incorrect CMI file. Panicking.")));

	// on success there is nothing we need to do with this response - just capture it and log it.

	// on failure we clean up.

	if (res==KErrNone)

		{

		C32LOG2(KC32Detail,_L8("CC32Dealer::LoadCPM: Load for (%S) has been successful"),&iName);

		}

	else

		{

		__ASSERT_DEBUG(!iThreadManager->Dealer()->WorkerExists(iWorkerId),Fault(EBadState,_L8("CCPMLoader::RunL - WorkerExists(%d) but configurator returned a failure: %d"),iWorkerId,res));

		C32LOG2(KC32Dealer,_L8("CC32Dealer::LoadCPM (%S) has apparently failed so cleaning up pending requests and threadmanager"),&iName);

		// give threadmanager a chance to remove any memory we allocated before 

		// commencing the module load.

		iThreadManager->ProcessModuleLoadFailed(iWorkerId);

		// we now leave ourselves inactive but still valid since we will be needed on the next attempt to load this cpm

		// and there is no obvious place to delete ourselves

		}

	}

//

// CC32ThreadManager

//

CC32ThreadManager::CC32ThreadManager(CC32Dealer* aDealer)

	{

	iDealer = aDealer;

	}

CC32ThreadManager* CC32ThreadManager::NewL(CC32Dealer* aDealer)

	{

	CC32ThreadManager* self = new (ELeave) CC32ThreadManager(aDealer);

	return self;

	}

CC32ThreadManager::~CC32ThreadManager()

	{

	iCSYList.ResetAndDestroy();

	iC32ThreadList.ResetAndDestroy();

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

		{

		delete iCPMLoader[i];

		}

	}

CC32Dealer* CC32ThreadManager::Dealer()

	{

	__ASSERT_DEBUG(iDealer!=NULL,Fault(EBadState,_L8("CC32ThreadManager: Dealer() - iDealer is NULL. Panicking.")));

	return iDealer;

	}

TWorkerId CC32ThreadManager::DefaultThread()

	{

	return iDefaultThreadIndex;

	}

TBool CC32ThreadManager::FindThreadByPortPrefix(const TDesC& aPortName, TWorkerId& aWorker) const

// returns EFalse if not found, ETrue otherwise

// unloaded csys or csys yet to be loaded have an empty port prefix so will not be found

// searching is done in folded way to avoid case problems.