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

//

#include <e32base.h>

#include <e32property.h>

#include <c32root.h>

#include <cfshared.h>

#include <comms-infras/commsdebugutility.h>

#include "esockloader.h"

__FLOG_STMT(_LIT8(KESockLogSubsys, "esock");)

__FLOG_STMT(_LIT8(KESockLogComponent, "esockloader");)

/** When unloading ESock 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 ESock has "hanging" sessions.

 */

const TInt KGracefulTimeout = 90 * 1000000;

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV")

#define LDD_NAME _L("ECOMM")

#else

#define PDD_NAME _L("EUART1")

#define LDD_NAME _L("ECOMM")

#endif

EXPORT_C TInt ESockLoader::LoadESock(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(KESockLogSubsys, KESockLogComponent);

	__FLOG(_L("ESockLoader::LoadESock"));

	TPtrC pddName = PDD_NAME;

	TPtrC lddName = LDD_NAME;

	// Load the communications drivers first - no use starting C32 without them.

	TInt result = User::LoadPhysicalDevice(pddName);

	if (result!=KErrNone && result!=KErrAlreadyExists)

		{

		__FLOG_2(_L("ESockLoader::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("ESockLoader::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);

		}

	// 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"));

		}

	_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("ESockLoader::LoadESock - 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("ESockLoader::LoadESock - failed with error %d"), result);

		}

	__FLOG_CLOSE;

	return result;

	}

// Helper fn: build a list of instances of CPMs running ESOCKSVR.DLL

void ESockLoader::BuildESockCPMListL(RRootServ& aRootServer, RUnloadInfoArray& aInfo, TDes8& aDispList)

	{

	__FLOG_DECLARATION_VARIABLE;

	__FLOG_OPENC(KESockLogSubsys, KESockLogComponent);

	__FLOG(_L8("ESockLoader::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(KESockSvrDLL, "*ESOCKSVR.DLL");

			if(modInfo.iParams.iDll.MatchF(KESockSvrDLL) >= 0)

				{

				TESockSvrUnloadInfo* unloadInfo = new(ELeave) TESockSvrUnloadInfo;

				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 ESockLoader::TestC32ExeStarted(RFileLogger& __logger__)

#else

	TBool ESockLoader::TestC32ExeStarted()

#endif

	{

	__FLOG(_L8("ESockLoader::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 ESockLoader::KillC32Exe(RFileLogger& __logger__)

#else

	TBool ESockLoader::KillC32Exe()

#endif

	{

	__FLOG(_L8("ESockLoader::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 ESockLoader::DoUnloadESockL(TCFShutdownType aType, MHarnessLogAdaptor* aHarnessLogger, RFileLogger& __logger__)

#else

	void ESockLoader::DoUnloadESockL(TCFShutdownType aType, MHarnessLogAdaptor* aHarnessLogger)

#endif

	{

	__FLOG_1(_L8("ESockLoader::DoUnLoadConfigL - CommsFW::TCFShutdownType==%d"), aType);

	// No need to restart esock (c32exe.exe) if esock (c32exe.exe) 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("ESockLoader::DoUnloadESockL - 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);

	int leakValue;

	RProperty leakProperty;

	TBool checkForLeaks; //if enabled

	//The root server should have been started so we can attack to the leak Property now

	checkForLeaks = (leakProperty.Attach(KUidCommsProcess, KUidCommsModuleLeakCounter) == KErrNone);

	CleanupClosePushL(leakProperty);

	if (checkForLeaks)

		{

		checkForLeaks = (leakProperty.Get(leakValue) == KErrNone);	

		}

	// With the Staged Start-up Architecture it is likely that ESOCK 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 ESOCKSVR.DLL. We treat them all equally rather than trying anything

	// clever such as telling the Main Thread to shutdown last, etc - ESOCK does whatever is best

	RUnloadInfoArray unloadArray(16);

	CleanupClosePushL(unloadArray);

	TBuf8<256> modList;

	BuildESockCPMListL(rootserver, unloadArray, modList);

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

	// Start by asking all of the ESOCK threads to unload when there are no sessions

	TInt numLoaded = unloadArray.Count();

	TInt mod;

	for(mod = numLoaded - 1; mod >= 0; --mod)

		{

		TESockSvrUnloadInfo* info = unloadArray[mod];

		__FLOG_1(_L8("ESockLoader::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);

	BuildESockCPMListL(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

		BuildESockCPMListL(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)

		{

		TESockSvrUnloadInfo* info = unloadArray[mod];

		__FLOG_1(_L8("ESockLoader::DoUnLoadConfigL - CancelUnloadCPM(%S)"), &info->iName);

		rootserver.CancelUnloadCpm(info->iName);

		User::WaitForRequest(info->iStatus);

		}

	// See what's left

	BuildESockCPMListL(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++)

			{

			TESockSvrUnloadInfo* info = unloadArray[mod];

			__FLOG_2(_L8("ESockLoader::DoUnLoadConfigL - Module: %S, State %d"), &info->iName, info->iState);

			if(mod == 0)

				{

				aHarnessLogger->Log(_L8("Timed-out waiting for shutdowns"));

				err = KErrTimedOut;

				}

			aHarnessLogger->Log(_L8("Re-trying %S with EImmediate shutdown"), &info->iName);

			__FLOG_1(_L8("ESockLoader::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++)

			{

			TESockSvrUnloadInfo* info = unloadArray[mod];

			__FLOG_2(_L8("ESockLoader::DoUnLoadConfigL - Module: %S, State %d"), &info->iName, info->iState);

			aHarnessLogger->Log(_L8("Waiting for %S to unload."), &info->iName);

			__FLOG_1(_L8("ESockLoader::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)

		{

		TESockSvrUnloadInfo* info = unloadArray[mod];

		if(info->iStatus != KErrNone && info->iStatus != KErrRSModuleNotLoaded)

			{

			__FLOG_3(_L8("ESockLoader::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"), &info->iName, info->iStatus.Int());

			if(err==KErrNone)

				{

    			err=info->iStatus.Int();

				}

			}

		else

			{

			__FLOG_2(_L8("ESockLoader::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

	// Leave with last seen error, if any

	if(err!=KErrNone)

		{

		User::Leave(err);

		}

	if (checkForLeaks)

		{

		TInt leakVal2;

		if (leakProperty.Get(leakVal2) == KErrNone)

			{

			if (leakVal2 > leakValue)

				{

				User::Leave(KModuleLeaked);

				}

			}

		}

	CleanupStack::Pop(&leakProperty);

	leakProperty.Close();

	}

EXPORT_C TInt ESockLoader::UnloadESock(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(KESockLogSubsys, KESockLogComponent);

	__FLOG(_L8("ESockLoader::UnloadESock"));

	__FLOG_CLOSE;

	TInt err = UnloadESock(EGraceful, aHarnessLogger);

	return err;

    }

EXPORT_C TInt ESockLoader::UnloadESock(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(KESockLogSubsys, KESockLogComponent);

	__FLOG_1(_L8("ESockLoader::UnloadESock, CommsFW::TCFShutdownType==%d."), aType);

#ifdef __FLOG_ACTIVE

	TRAPD(err, DoUnloadESockL(aType, aHarnessLogger, __logger__));

#else

	TRAPD(err, DoUnloadESockL(aType, aHarnessLogger));

#endif

	if(err == KErrNone)

		{

		__FLOG(_L("ESockLoader::UnLoadConfig - succeeded."));

		}

	else

		{

		__FLOG_1(_L("ESockLoader::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;

	}