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

#include <e32base.h>
#include <e32property.h>
#include <c32root.h>
#include <cfshared.h>
#include <comms-infras/commsdebugutility.h>

#include "configloader.h"

__FLOG_STMT(_LIT8(KC32LogSubsys, "RootServer");)
__FLOG_STMT(_LIT8(KC32LogComponent, "Configloader");)

/** When unloading C32 forced we try first in a graceful manner, if it hasn't
unloaded after this timeout it is asked to shutdown immediately.
This will happen if C32 has "hanging" sessions.
 */
const TInt KGracefulTimeout = 90 * 1000000;

#if defined (__EPOC32__)
#define PDD_NAME _L("EUART1")
#define LDD_NAME _L("ECOMM")
#endif

EXPORT_C TInt ConfigLoader::LoadConfig(MHarnessLogAdaptor* aHarnessLogger)
/** Connect to the Comms Rootserver and request load of the Socket Server CPM.
Returns when it is loaded. 
*/
	{
	__FLOG_DECLARATION_VARIABLE;
	__FLOG_OPEN(KC32LogSubsys, KC32LogComponent);
	__FLOG(_L("ConfigLoader::LoadConfig"));
	
	TInt result;
	
#if defined (__EPOC32__)
	TPtrC pddName = PDD_NAME;
	TPtrC lddName = LDD_NAME;

	// Load the communications drivers first - no use starting C32 without them.
	result = User::LoadPhysicalDevice(pddName);
	if (result!=KErrNone && result!=KErrAlreadyExists)
		{
		__FLOG_2(_L("ConfigLoader::LoadConfig - could not load Serial Physical Device Driver \"%S\" due to error %d so the device's COMM ports will not be available"), &pddName, result);
		aHarnessLogger->Log(_L("Could not load Serial Physical Device Driver \"%S\" due to error %d so the device's COMM ports will not be available"), &pddName, result);
		}

	result=User::LoadLogicalDevice(lddName);
	if (result!=KErrNone && result!=KErrAlreadyExists)
		{
		__FLOG_2(_L("ConfigLoader::LoadConfig - could not load Serial Logical Device Driver \"%S\" due to error %d so the device's COMM ports will not be available"), &lddName, result);	
		aHarnessLogger->Log(_L("Could not load Serial Logical Device Driver \"%S\" due to error %d so the device's COMM ports will not be available"), &lddName, result);
		}
#endif

	// Boot the Comms Process, but avoid loading the Phonebook Synchronizer.
	#ifdef __FLOG_ACTIVE
		TBool warmBoot = TestC32ExeStarted(__logger__);
	#else
		TBool warmBoot = TestC32ExeStarted();
	#endif
	if(warmBoot)
		{
		aHarnessLogger->Log(_L("Starting C32Start warm-boot"));
		}
	else
		{
		aHarnessLogger->Log(_L("Starting C32Start cold-boot"));
		}
	
	RProcess C32Start;
	result = C32Start.Create(KCommC32StartExe,KNullDesC);

	// Kill the existing configurator process.
	TRequestStatus status;
	C32Start.Logon(status);
	C32Start.Kill(KErrNone);
	User::WaitForRequest(status);
	
	// Create a timer in case some other entity holds an open handle on the
	// configurator which prevents the kernel from destroying it.  We timeout
	// after one second.
	TAutoClose<RTimer> timer;
	if(timer.iObj.CreateLocal() == KErrNone)
		{
		// Request destruction notification so we know when it is safe to start
		// the process again.
		TRequestStatus destructionStatus;
		C32Start.NotifyDestruction(destructionStatus);
		C32Start.Close();
	
		enum{ KProcessDestructionTimeout = 1000000 };
  					
		TRequestStatus timerStatus;
		timer.iObj.After(timerStatus, KProcessDestructionTimeout);
		
		// Wait for the process 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);
			
			__FLOG_1(_L("ConfigLoader::LoadConfig - existing configurator process has still not been destroyed after %f.0s"), KProcessDestructionTimeout / 1000000.0);
			}
		}
	else
		{
		C32Start.Close();
		}

	_LIT(KPhbkSyncCMI, "phbsync.cmi");
	result=WarmBootC32(KPhbkSyncCMI);
	
	if(result == KErrNone)
		{
		aHarnessLogger->Log(warmBoot ? _L("C32Start warm-boot succeeded") : _L("C32Start cold-boot succeeded"));
		__FLOG(_L("ConfigLoader::LoadConfig - succeeded"));
		}
	else
		{
		aHarnessLogger->Log(warmBoot ? _L("C32Start warm-boot failed with error %d") : _L("C32Start cold-boot failed with error %d"), result);
		__FLOG_1(_L("CConfigLoader::LoadConfig - failed with error %d"), result);
		}
	__FLOG_CLOSE;

	return result;
	}

// Helper fn: build a list of instances of CPMs running C32.DLL
void ConfigLoader::BuildConfigCPMListL(RRootServ& aRootServer, RUnloadInfoArray& aInfo, TDes8& aDispList)
	{
	__FLOG_DECLARATION_VARIABLE;
	__FLOG_OPENC(KC32LogSubsys, KC32LogComponent);
	__FLOG(_L8("ConfigLoader::BuildConfigCPMListL"));

	TRSIter iter;
	TCFModuleName modName;
	TRSModuleInfo modInfo;
	aInfo.ResetAndDestroy();
	aDispList.SetLength(0);
	while(aRootServer.EnumerateModules(iter, modName) == KErrNone)
		{
		if(aRootServer.GetModuleInfo(modName, modInfo) == KErrNone)
			{
			_LIT(KC32DLL, "dummycpm.DLL");
			if(modInfo.iParams.iDll.MatchF(KC32DLL) >= 0)
				{
				TConfigSvrUnloadInfo* unloadInfo = new(ELeave) TConfigSvrUnloadInfo;
				unloadInfo->iName.Copy(modInfo.iParams.iName);
				unloadInfo->iState=modInfo.iParams.iState;
				unloadInfo->iStatus=KErrNone;
				if(aDispList.Length() != 0)
					{
					aDispList.Append(_L8(", "));
					}
				aDispList.Append(unloadInfo->iName);
				TInt err = aInfo.Append(unloadInfo);
				if(err != KErrNone)
					{
					delete unloadInfo;
					User::Leave(err);
					}
				}
			}
		}
	
	__FLOG_CLOSE_CLEANUP;
	}

#ifdef __FLOG_ACTIVE
	TBool ConfigLoader::TestC32ExeStarted(RFileLogger& __logger__)
#else
	TBool ConfigLoader::TestC32ExeStarted()
#endif
	{
	__FLOG(_L8("ConfigLoader::TestC32ExeStarted"));

	_LIT(KC32StartName,"*");
	TBool ret = EFalse;
	TFullName fn;
	TFindProcess fp(KC32StartName);
	while(!ret && fp.Next(fn) == KErrNone)
		{
		RProcess proc;
		TInt result = proc.Open(fn);
		if(result == KErrNone)
			{
			TUidType type = proc.Type();
			if(type[2] == KUidCommsProcess && proc.ExitType() == EExitPending) 
				{
				ret = ETrue;
				}
			proc.Close();	
			}
		}

	return ret;
	}

#ifdef __FLOG_ACTIVE
	TBool ConfigLoader::KillC32Exe(RFileLogger& __logger__)
#else
	TBool ConfigLoader::KillC32Exe()
#endif
	{
	__FLOG(_L8("ConfigLoader::KillC32Exe"));

	_LIT(KC32StartName,"*");
	TBool ret = EFalse;
	TFullName fn;
	TFindProcess fp(KC32StartName);
	while(!ret && fp.Next(fn) == KErrNone)
		{
		RProcess proc;
		TInt result = proc.Open(fn);
		if(result == KErrNone)
			{
			TUidType type = proc.Type();
			if(type[2] == KUidCommsProcess) 
				{
				proc.Kill(KErrNone);
				}
			proc.Close();	
			}
		}

	return ret;
	}

#ifdef __FLOG_ACTIVE
	void ConfigLoader::DoUnLoadConfigL(TCFShutdownType aType, MHarnessLogAdaptor* aHarnessLogger, RFileLogger& __logger__)
#else
	void ConfigLoader::DoUnLoadConfigL(TCFShutdownType aType, MHarnessLogAdaptor* aHarnessLogger)
#endif
	{
	__FLOG_1(_L8("ConfigLoader::DoUnLoadConfigL - CommsFW::TCFShutdownType==%d"), aType);

	// No need to restart C32 if C32(c32exe) is not started...
#ifdef __FLOG_ACTIVE
	if (!TestC32ExeStarted(__logger__))
#else
	if (!TestC32ExeStarted())
#endif
		{
		aHarnessLogger->Log(_L8("C32 is not running so it does not need to be shutdown"));
		__FLOG(_L8("ConfigLoader::DoUnLoadConfigL - C32 is not running so it does not need to be shutdown"));

		return;
		}

	// Start the Comms Process
	_LIT(KPhbkSyncCMI, "phbsync.cmi");
	TInt err=StartC32WithCMISuppressions(KPhbkSyncCMI);

	// With the Staged Start-up Architecture it is likely that C32 modules continue to load after the ECoreComponentsStarted
	// state which releases StartC32() and RSocketServ::Connect(). So here we wait until the RootServer is fully configured before
	// starting the shutdown, which avoids various races (modules may not be bound yet, or even loaded at all by the Configurator
	// and hence invisible to this unloading code)
	RProperty configurationProperty;
	configurationProperty.Attach(KUidSystemCategory, KUidC32StartPropertyKey.iUid);	// needs the KEY
	TInt propertyValue = EInitialising;	// set to safe state
	TInt propertyResult = configurationProperty.Get(propertyValue);
	TRequestStatus propertyStatus;
	while(propertyValue < EConfigurationComplete)
		{
		configurationProperty.Subscribe(propertyStatus);
		
		if(configurationProperty.Get(propertyValue) == KErrNone && propertyValue == EConfigurationComplete)
			{
			configurationProperty.Cancel();
			}
		User::WaitForRequest(propertyStatus);
		}

	RRootServ rootserver;
	if(err==KErrNone)
		{
		err=rootserver.Connect();
		}
	User::LeaveIfError(err);
	CleanupClosePushL(rootserver);
	
	// Find all instances of CPMs running C32.DLL. We treat them all equally rather than trying anything
	// clever such as telling the Main Thread to shutdown last, etc - C32 does whatever is best

	RUnloadInfoArray unloadArray(16);
	CleanupClosePushL(unloadArray);
	TBuf8<256> modList;
	BuildConfigCPMListL(rootserver, unloadArray, modList);

	aHarnessLogger->Log(_L8("%d modules to shutdown: %S"), unloadArray.Count(), &modList);

	// Start by asking all of the C32 threads to unload when there are no sessions
	TInt numLoaded = unloadArray.Count();
	TInt mod;
	for(mod = numLoaded - 1; mod >= 0; --mod)
		{
		TConfigSvrUnloadInfo* info = unloadArray[mod];
		__FLOG_1(_L8("ConfigLoader::DoUnLoadConfigL - UnloadCPM(%S, EGraceful)"), &info->iName);
		rootserver.UnloadCpm(info->iStatus, info->iName, EGraceful);
		}

	// Start polling to see when they all complete unloading - crude but easy. 
	const TInt KPollPeriod = 2000 * 1000;
	TUint maxPolls = 0xFFFFFFFF;	// a saintly degree of patience
	if(aType==EImmediate)
		{
		// Limited patience for the unload; 
		maxPolls = KGracefulTimeout / KPollPeriod;
		}
	TUint poll;
	RUnloadInfoArray pollUnloadArray(16);
	BuildConfigCPMListL(rootserver, pollUnloadArray, modList);
	for(poll = maxPolls; poll != 0 && pollUnloadArray.Count() > 0; --poll)
		{
		User::After(KPollPeriod);
		// See what's left - an earlier version of this code relied upon the unload completions for this, but unload
		// may complete prematurely with failure if the unbind times out. It can legitimately do this if waiting for
		// a session to timeout
		BuildConfigCPMListL(rootserver, pollUnloadArray, modList);
		if(pollUnloadArray.Count() > 0)
			{
			aHarnessLogger->Log(_L8("[%d]:%d remaining: %S"), poll, pollUnloadArray.Count(), &modList);
			}
		}
	pollUnloadArray.ResetAndDestroy();

	if(poll == 0 && unloadArray.Count() > 0)
	    {
	    __FLOG(_L8("Reached maxpolls, gave up."));
	    }

	// Cancel any remaining unloads and eat the events
	for(mod = unloadArray.Count() - 1; mod >= 0; --mod)
		{
		TConfigSvrUnloadInfo* info = unloadArray[mod];
		__FLOG_1(_L8("ConfigLoader::DoUnLoadConfigL - CancelUnloadCPM(%S)"), &info->iName);
		rootserver.CancelUnloadCpm(info->iName);
		User::WaitForRequest(info->iStatus);
		}

	// See what's left
	BuildConfigCPMListL(rootserver, unloadArray, modList);

	err = KErrNone; // Will use this to catch first error below.
	if(unloadArray.Count() > 0 && aType == EImmediate)
		{
		__FLOG(_L8("Entering EImmediate loop."));
		// No more waiting; we order immediate unloads
		for(mod = 0; mod < unloadArray.Count(); mod++)
			{
			TConfigSvrUnloadInfo* info = unloadArray[mod];
			__FLOG_2(_L8("ConfigLoader::DoUnLoadConfigL - Module: %S, State %d"), &info->iName, info->iState);
			if(mod == 0)
				{
				aHarnessLogger->Log(_L8("Timed-out waiting for shutdown"));
				err = KErrTimedOut;
				}
			aHarnessLogger->Log(_L8("Re-trying %S with EImmediate shutdown"), &info->iName);
			__FLOG_1(_L8("ConfigLoader::DoUnLoadConfigL - UnloadCPM(%S, EImmediate)"), &info->iName);
			rootserver.UnloadCpm(info->iStatus, info->iName, EImmediate);
			}
			
		// Wait for them all to return.
		for(mod = 0; mod < unloadArray.Count(); mod++)
			{
			TConfigSvrUnloadInfo* info = unloadArray[mod];
			__FLOG_2(_L8("ConfigLoader::DoUnLoadConfigL - Module: %S, State %d"), &info->iName, info->iState);
			aHarnessLogger->Log(_L8("Waiting for %S to unload"), &info->iName);
			__FLOG_1(_L8("ConfigLoader::DoUnLoadConfigL - WaitForUnloadCPM(%S, EImmediate)"), &info->iName);
			User::WaitForRequest(info->iStatus);
			}
		}

	// Display the status of any remaining modules.  The first module that
	// failed to unload becomes the error code for all.
	for(mod = unloadArray.Count() - 1; mod >= 0; --mod)
		{
		TConfigSvrUnloadInfo* info = unloadArray[mod];
		if(info->iStatus != KErrNone && info->iStatus != KErrRSModuleNotLoaded)
			{
			__FLOG_3(_L8("ConfigLoader::DoUnLoadConfigL - Unresponsive Module: %S cannot be gracefully or immediatly unloaded due to error %d and is stuck in state %d"), &info->iName, info->iStatus.Int(), info->iState);
			aHarnessLogger->Log(_L8("Unresponsive Module: %S cannot be unloaded due to error %d and is stuck in state %d"), &info->iName, info->iStatus.Int(), info->iState);
			if(err==KErrNone)
				{
    			err=info->iStatus.Int();
				}
			}
		else
			{
			__FLOG_2(_L8("ConfigLoader::DoUnLoadConfigL - Unresponsive Module: %S could not be gracefully unloaded and had to be immediatly unloaded while it was stuck in state %d"), &info->iName, info->iState);
			aHarnessLogger->Log(_L8("Unresponsive Module: %S could not be gracefully unloaded and had to be immediatly unloaded while it was stuck in state %d"), &info->iName, info->iState);
			}
		}
	if(err==KErrNone)
		{
		aHarnessLogger->Log(_L("Shutdown completed"));
		}
	CleanupStack::PopAndDestroy(2);	// unloadArray, rootserver
	
	#if defined (__EPOC32__)	
	TPtrC pddName = PDD_NAME;
	TPtrC lddName = LDD_NAME;

	TInt retDD = User::FreePhysicalDevice(pddName);
	if (retDD != KErrNone)
		{
		aHarnessLogger->Log(_L8("Failed unloading Physical Device Driver \"%S\" due to error %d"), &pddName, retDD);	
		}
	
	retDD = User::FreeLogicalDevice(lddName);
	if (retDD != KErrNone)
		{
		aHarnessLogger->Log(_L8("Failed unloading Logical Device Driver \"%S\" due to error %d"), &lddName, retDD);	
		}
	#endif
	
	// Leave with last seen error, if any
	if(err!=KErrNone)
		{
		User::Leave(err);
		}
	}


EXPORT_C TInt ConfigLoader::UnLoadConfig(MHarnessLogAdaptor* aHarnessLogger)
/**
Connects to the Comms Rootserver and requests unload of the Socket Server CPM.
Returns when it is unloaded.
*/
	{
	__FLOG_DECLARATION_VARIABLE;
	__FLOG_OPEN(KC32LogSubsys, KC32LogComponent);
	__FLOG(_L8("ConfigLoader::UnLoadConfig"));
	__FLOG_CLOSE;

	TInt err = UnLoadConfig(EGraceful, aHarnessLogger);
	
	return err;
    }

EXPORT_C TInt ConfigLoader::UnLoadConfig(CommsFW::TCFShutdownType aType, MHarnessLogAdaptor* aHarnessLogger)
/**
Connects to the Comms Rootserver and requests unload of the Socket Server CPM.
Returns when it is unloaded.
*/
	{
	__FLOG_DECLARATION_VARIABLE;
	__FLOG_OPEN(KC32LogSubsys, KC32LogComponent);
	__FLOG_1(_L8("ConfigLoader::UnLoadConfig - CommsFW::TCFShutdownType==%d."), aType);

#ifdef __FLOG_ACTIVE
	TRAPD(err, DoUnLoadConfigL(aType, aHarnessLogger, __logger__));
#else
	TRAPD(err, DoUnLoadConfigL(aType, aHarnessLogger));
#endif

	if(err == KErrNone)
		{
		__FLOG(_L("ConfigLoader::UnLoadConfig - succeeded."));
		}
	else
		{
		__FLOG_1(_L("ConfigLoader::UnLoadConfig - failed with error %d.  The C32 process is in an unstable state and will be killed."), err);
		aHarnessLogger->Log(_L("Shutdown failed with error %d.  The C32 process is in an unstable state and will be killed."), err);
		
		#ifdef __FLOG_ACTIVE
			KillC32Exe(__logger__);
		#else
			KillC32Exe();
		#endif
		}
		
	__FLOG_CLOSE;
	
	return err;
	}