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

// EPOC includes
#include <e32base.h>
#include <e32property.h>
#include <es_sock.h>
#include <in_sock.h>
#include <c32root.h>

// Test system includes
#include "TestStepESockSSA.h"
#include "blocker.h"
#include "ES_DUMMY.H"


RMultipleWait::RMultipleWait(TInt aInitialCount)
: iCount(aInitialCount)
	{
	iOwnerThread.Open(RThread().Id());
	}
	
void RMultipleWait::Close()
	{
	iOwnerThread.Close();
	inherited::Close();
	}
	
void RMultipleWait::Signal(TInt aDelta)
	{
	inherited::Wait();
	iCount += aDelta;
	iOwnerThread.RequestSignal();
	inherited::Signal();
	}
	
void RMultipleWait::Wait()
	{
	while(iCount < 0)
		{
		User::WaitForAnyRequest();
		}
	inherited::Wait();
	--iCount;
	inherited::Signal();
	}

CTestStepESockSSA::CTestStepESockSSA()
	{
	}

CTestStepESockSSA::~CTestStepESockSSA()
	{
	}

void CTestStepESockSSA::SetDummyBlocking()
	{
	// Set the blocking state, so that when the blocking module is loaded it will block
	TSecurityPolicy nullPolicy(ECapability_None);
	TInt err = RProperty::Define(TBlockerSID, CBlockerChannelHandler::EBlockingStateKey, RProperty::EInt, nullPolicy, nullPolicy);
	if(err == KErrNone || err == KErrAlreadyExists)
		{
		RProperty::Set(TBlockerSID, CBlockerChannelHandler::EBlockingStateKey, CBlockerChannelHandler::EStateBlock);
		}
	}

void CTestStepESockSSA::ClearDummyBlocking()
	{
	// Set the blocking state, so that when the blocking module is loaded it will block
	TSecurityPolicy nullPolicy(ECapability_None);
	TInt err = RProperty::Define(TBlockerSID, CBlockerChannelHandler::EBlockingStateKey, RProperty::EInt, nullPolicy, nullPolicy);
	if(err == KErrNone || err == KErrAlreadyExists)
		{
		RProperty::Set(TBlockerSID, CBlockerChannelHandler::EBlockingStateKey, CBlockerChannelHandler::EStateRelease);
		}
	}

void CTestStepESockSSA::DoDataThreadL(TDataThreadControl& aControl)
	{
	User::LeaveIfError(aControl.iSession.Connect());

	// Wait for blocker to start blocking; we can then create an IP socket as it will have already loaded
	RProperty blockProp;
	TInt err = blockProp.Attach(TBlockerSID, CBlockerChannelHandler::EBlockingStateKey);
	if(err == KErrNone)
		{
		TRequestStatus status;
		do
			{
			blockProp.Subscribe(status);
			TInt blockState;
			err = blockProp.Get(blockState);
			if(err != KErrNone || blockState >= CBlockerChannelHandler::EStateBlocking)
				{
				blockProp.Cancel();
				}
			User::WaitForRequest(status);
			} while(status == KErrNone);
		blockProp.Close();
		}
	
	switch(aControl.iRequest)
		{
	case TDataThreadControl::ESocketOpen:
		{
		RSocket sock;
		User::LeaveIfError(sock.Open(aControl.iSession, KAfInet, KSockDatagram, KProtocolInetUdp));
		sock.Close();
		aControl.iBlocked = ETrue;
		aControl.iBlockSemaphore.Signal(1);
		aControl.iResult = sock.Open(aControl.iSession, KDummyOneName);		// should block
		sock.Close();
		break;
		}
	case TDataThreadControl::EHostResolverOpen:
		{
		RHostResolver hr;
		hr.Open(aControl.iSession, KAfInet, KProtocolInetUdp);
		hr.Close();
		aControl.iBlocked = ETrue;
		aControl.iBlockSemaphore.Signal(1);
		aControl.iResult = hr.Open(aControl.iSession, KDummyAddrFamily, KDummyOne);		// should block
		hr.Close();
		break;
		}
	case TDataThreadControl::EHostResolverOpenMulti:
		{
		RHostResolver hr;
		aControl.iBlocked = ETrue;
		aControl.iBlockSemaphore.Signal(1);
		aControl.iResult = hr.Open(aControl.iSession, KDummyAddrFamily, KDummyOne);		// should block
		hr.Close();
		break;
		}
	case TDataThreadControl::EServiceResolverOpen:
		{
		RServiceResolver sr;
		sr.Open(aControl.iSession, KAfInet, KSockDatagram, KProtocolInetUdp);
		sr.Close();
		aControl.iBlocked = ETrue;
		aControl.iBlockSemaphore.Signal(1);
		aControl.iResult = sr.Open(aControl.iSession, KDummyAddrFamily, KSockDatagram, KDummyOne);		// should block
		sr.Close();
		break;
		}
	case TDataThreadControl::ENetDBOpen:
		{
		RNetDatabase ndb;
		ndb.Open(aControl.iSession, KAfInet, KProtocolInetUdp);
		ndb.Close();
		aControl.iBlocked = ETrue;
		aControl.iBlockSemaphore.Signal(1);
		aControl.iResult = ndb.Open(aControl.iSession, KDummyAddrFamily, KDummyOne);		// should block
		ndb.Close();
		break;
		}
	case TDataThreadControl::ENumProtocols:
		{
		TUint numOfProtocols;
		aControl.iBlocked = ETrue;
		aControl.iBlockSemaphore.Signal(1);
		aControl.iResult = aControl.iSession.NumProtocols(numOfProtocols);		// should block
		break;
		}
	case TDataThreadControl::EGetProtocolInfo:
		{
		TUint absentIndex = 99;
		TProtocolDesc protocolDesc;
		RHostResolver hr;
		hr.Open(aControl.iSession, KAfInet, KProtocolInetUdp);
		hr.Close();
		aControl.iBlocked = ETrue;
		aControl.iBlockSemaphore.Signal(1);
		aControl.iResult = aControl.iSession.GetProtocolInfo(absentIndex, protocolDesc);		// should block
		break;
		}
	case TDataThreadControl::EFindProtocol:
		{
		_LIT(KAbsentProtocolName,"NoSuchProtocol");
		TProtocolDesc protocolDesc;
		RHostResolver hr;
		hr.Open(aControl.iSession, KAfInet, KProtocolInetUdp);
		hr.Close();
		aControl.iBlocked = ETrue;
		aControl.iBlockSemaphore.Signal(1);
		aControl.iResult = aControl.iSession.FindProtocol(KAbsentProtocolName(), protocolDesc);		// should block
		break;
		}
	default:
		ASSERT(0);
		}
	}

TInt CTestStepESockSSA::DataThreadEntry(TDataThreadControl& aControl)
	{
	CTrapCleanup* cleanupStack = CTrapCleanup::New();
	if(!cleanupStack)
		{
		return KErrNoMemory;
		}
	TRAPD(err, DoDataThreadL(aControl));
	// Signal that the thread is exiting. If we got here by a Leave() we still need to signal the control thread
	aControl.iBlockSemaphore.Signal(1);

	delete cleanupStack;
	return err;
	}

TInt CTestStepESockSSA::CreateDataThread(TDataThreadControl::TRequestType aRequest, TDataThreadControl& aControl)
	{
	aControl.iRequest = aRequest;
	aControl.iResult = KRequestPending;
	aControl.iBlocked = EFalse;
	return aControl.iThread.Create(KNullDesC, reinterpret_cast<TThreadFunction>(CTestStepESockSSA::DataThreadEntry), 8192, NULL, &aControl);
	}

TVerdict CTestStepESockSSA::WaitForDataThreadsToBlock(TDataThreadControl* aThreads, TInt aNumThreads)
	{
	TVerdict verdict = EPass;
	Logger().WriteFormat(_L("Resuming %d data thread(s) & waiting for blocking"), aNumThreads);
	for(TInt i = 0; i < aNumThreads; ++i)
		{
		aThreads[i].iThread.Resume();
		User::After(1000000);
		Logger().WriteFormat(_L("Data thread: #%d %d %d"), i, aThreads[i].iThread.ExitReason(), aThreads[i].iBlocked);
		}
	
	aThreads[0].iBlockSemaphore.Wait();	// blocks until all data threads signal. If it hangs forever then check if one died
	User::After(KBlockedRequestIssueDelay);
	// Check whether all data threads have blocked
	for(TInt i = 0; i < aNumThreads; ++i)
		{
		if(!aThreads[i].iBlocked)
			{
			Logger().WriteFormat(_L("ERROR: Data thread #%d never got to block"), i);
			verdict =  EFail;
			}
		else if(aThreads[i].iResult != KRequestPending)
			{
			Logger().WriteFormat(_L("ERROR: Data thread #%d went past block with %d"), i, aThreads[i].iResult);
			verdict = EFail;
			}
		}
	return verdict;
	}

TVerdict CTestStepESockSSA::WaitForDataThreadsToComplete(TDataThreadControl* aThreads, TInt aNumThreads)
	{
	TVerdict verdict = EPass;
	Logger().WriteFormat(_L("Resuming ESOCK boot & waiting for %d data thread(s) to complete"), aNumThreads);
	aThreads[0].iBlockSemaphore.Signal(- aNumThreads + 1);
	ClearDummyBlocking();
	aThreads[0].iBlockSemaphore.Wait();	// blocks until all data threads signal. If it hangs forever then check if one died

	User::After(KBlockedRequestCompletionDelay);
	// Check whether all data threads completed their requests properly
	for(TInt i = 0; i < aNumThreads; ++i)
		{
		if(aThreads[i].iResult != aThreads[i].iExpectedResult)
			{
			Logger().WriteFormat(_L("ERROR: Data thread #%d completed with %d, expected %d"), i, aThreads[i].iResult, aThreads[i].iExpectedResult);
			verdict = EFail;
			}
		}
	return verdict;
	}

void CTestStepESockSSA::UnloadBlockerL()
	{
	// Unload the blocker module if it's there
	Logger().WriteFormat(_L("Unloading blocker module"));
	TAutoClose<RRootServ> rootserver;
	User::LeaveIfError(rootserver.iObj.Connect());
	rootserver.PushL();
	TRequestStatus status;
	TCFModuleName blockerName(KBlockerCPMName);
	rootserver.iObj.UnloadCpm(status, blockerName, EGraceful);
	User::WaitForRequest(status);
	rootserver.Pop();
	Logger().WriteFormat(_L("Request completed with %d"), status.Int());
	}

void CTestStepESockSSA::KillC32Start()
	{
	// Start by looking for the running configurator and kill it if found. The caller
	// needs the appropriate capability to do this

	RDebug::Printf("Finding existing configurator process.");	
	_LIT(KC32StartName, "*");
	TInt result;
	TBool configuratorWasPresent;
	TInt count = 0;
	const TInt KMaxKillRetry = 10;
	do 
		{
		configuratorWasPresent = EFalse;
		TFullName fn;
		TFindProcess fp(KC32StartName);
		while(fp.Next(fn) == KErrNone)
			{
			RProcess proc;
			result = proc.Open(fn);
			if(result == KErrNone)
				{
				TUidType type = proc.Type();
				if(type[2] == TUid::Uid(KUidC32StartProcess) && proc.ExitType() == EExitPending) 
					{
					// Kill the existing configurator process.
					RDebug::Print(_L("Opened existing configurator process \"%S\""), &fn);
					TRequestStatus status;
					proc.Logon(status);
					proc.Kill(KErrNone);
					RDebug::Printf("Killed process.");
					User::WaitForRequest(status);
					TExitType exitType = proc.ExitType();
					
					// 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;
						proc.NotifyDestruction(destructionStatus);
						proc.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);
			
							RDebug::Printf("Existing configurator process has still not been destroyed after %f.0s", KProcessDestructionTimeout / 1000000.0);
							}
						}
					else
						{
						proc.Close();
						}
						
					RDebug::Printf("Process logon completed with %d, exitType %d", status.Int(), exitType);
					configuratorWasPresent = ETrue;
					}
				else
					{
					proc.Close();	
					}
				}
			}
		} while(configuratorWasPresent && ++count < KMaxKillRetry);

		if (count >= KMaxKillRetry)
			{
			RDebug::Printf("KillC32Start - Cannot kill the configurator process, we will try continue and hope all is well");
			}
		
	// Restart the boot sequence from scratch - the configurator reads this.
	RProperty::Set(KUidSystemCategory, KUidC32StartPropertyKey.iUid, EReset);
	}

TVerdict CTestStepESockSSA::doTestStepPreambleL()
	{
	SetDummyBlocking();
	RProperty ::Set(KUidSystemCategory, KUidC32StartPropertyKey.iUid, EReset);
	UnloadBlockerL();
	KillC32Start();
	return EPass;
	}

TVerdict CTestStepESockSSA::doTestStepPostambleL()
	{
	UnloadBlockerL();
	return EPass;
	}