// Copyright (c) 2004-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 EsockTestBase.cpp
*/

#include <e32debug.h>
#include "EsockTestBase.h"
#include <e32std.h>
#include <commdbconnpref.h>
#include <cs_subconevents.h>
#include <es_prot.h>
#include <comms-infras/esock_params.h>
#include <dummynif_params.h>

#include <comms-infras/es_parameterbundle.h>
#include <comms-infras/provinfoqueryset.h>
#include "ConnectionServer.TestSteps.h"

#include <dummynifvar.h>


#ifdef _DEBUG
// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module
// (if it could happen through user error then you should give it an explicit, documented, category + code)
_LIT(KSpecAssert_ESockTestEsckTst, "ESockTestEsckTst");
#endif

static const TInt KProtocolInetDummy = 253;

// Temporary measure to configure the rconnserv stuff before its backported to 9.4

using namespace ConnectionServ;


namespace ConnectionServ
{
	class RConnectionServ;
	class CConnectionServParameterBundle;
}

class CConnServStatusQuery : public CActive
	{
public:
	CConnServStatusQuery(ConnectionServ::RConnectionServ* aConnServ);
	static CConnServStatusQuery* NewLC(	ConnectionServ::RConnectionServ* aConnServ,
							const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
							ConnectionServ::CConnectionServParameterBundle& aStatusBundle);
	void ConstructL(const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
					ConnectionServ::CConnectionServParameterBundle& aStatusBundle);
	void RunL();
	void DoCancel();

	TInt ErrCode() const { return iStatus.Int(); }

public:	
	ConnectionServ::RConnectionServ* iConnServ;
	};


CConnServStatusQuery::CConnServStatusQuery(RConnectionServ* aConnServ)
	: CActive(0), iConnServ(aConnServ)
		{
		}

CConnServStatusQuery* CConnServStatusQuery::NewLC(	ConnectionServ::RConnectionServ* aConnServ,
									const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
									ConnectionServ::CConnectionServParameterBundle& aStatusBundle)
	{
	CConnServStatusQuery* inst = new CConnServStatusQuery(aConnServ);
	CleanupStack::PushL(inst);
	inst->ConstructL(aQueryBundle, aStatusBundle);
	return inst;
	}

void CConnServStatusQuery::ConstructL(const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
									ConnectionServ::CConnectionServParameterBundle& aStatusBundle)
	{
	iConnServ->AccessPointStatusQuery(aQueryBundle, aStatusBundle, iStatus );

	// add self to scheduler
	CActiveScheduler::Add(this);
	SetActive();
	}
	

void CConnServStatusQuery::RunL()
	{
	CActiveScheduler::Current()->Stop();
	}

void CConnServStatusQuery::DoCancel()
	{
	iConnServ->CancelAccessPointStatusQuery();
	}
	
	

//
// TMigrateToPreferredCarrierParams - container for parameters for accepting a 
// move for mobility
//

void TMigrateToPreferredCarrierParams::Reset()
	{
	iName.Set(KNullDesC);
	iMobilityApiName.Set(KNullDesC);
	}


//
// TCompareIntegersParams - parameters for comparing to saved integer values
//
void TCompareIntegersParams::Reset()
	{
	iValue1.Set(KNullDesC);
	iValue2.Set(KNullDesC);
    iDifference = 0;
	}

//
//TSocketDataCheckParams - container for parameters for checking data on a socket
void TSocketDataCheckParams::Reset()
	{
	iSocketCheckName.Set(KNullDesC);
    iSocketName.Set(KNullDesC);
    iTransformType = ETransformDataNone;
    iErrorExpected = EFalse;
	}
	
//
//TSocketServerNumProtocolsParams - container for parameters for checking the number of procotols on a socket server instance

void TSocketServerNumProtocolsParams::Reset()
	{
	iSocketServName.Set(KNullDesC);
	iNumberExpected = 0;
	iSavedAsName.Set(KNullDesC);
	iExpected = EFalse;
	iToBeSaved = EFalse;
	}

void TSocketServStartStopProtocolParams::Reset()
	{
	iSocketServName.Set(KNullDesC);
	iAddrFamily = 0;
	iProtocol = 0;
	iSockType = 0;
	}

//
//TRSocketParams - container for parameters (from an .ini file)
//needed for operations on a sockets

void TRSocketParams::Reset()
    {
    iSockServName.Set(KNullDesC);
    iConnectionName.Set(KNullDesC);
    iSocketName.Set(KNullDesC);
    iSubconnectionName.Set(KNullDesC);

    iSocketType = 0;
   	iProtocol = 0;
	iPacketSize = 0;
	iNrOfPackets = 0;
	iLocalIP.FillZ();
   	iRemoteIP.FillZ();
   	iShutdownType = (RSocket::TShutdown)0;

    // Payload colouring
    iPayloadColouringIsEnabled = EFalse;
    iPayloadColour = 0;
    }

void TRSocketGetOptParams::Reset()
	{
    iSocketName.Set(KNullDesC);
	iOptionName = 0;
	iOptionLevel = 0;
	iExpectedOptionOutputText.Set(KNullDesC);
	iTextExpected = EFalse;
	iValueExpected = EFalse;
	}

void TRSocketSetOptParams::Reset()
    {
    iSocketName.Set(KNullDesC);
    iOptionName = 0;
    iOptionLevel = 0;
    iOptionToSetText.Set(KNullDesC);
    iTextSet = EFalse;
    iValueSet = EFalse;
    }

void TRSocketIoctlParams::Reset()
	{
    iSocketName.Set(KNullDesC);
	iIoctlCommand = 0;
	iIoctlLevel = 0;
	iExpectedIoctlOutput.Set(KNullDesC);
	}

TProtocolDescriptionParams::TProtocolDescriptionParams()
	{
	Mem::FillZ(this, sizeof(this));
	}

void TProtocolDescriptionParams::Reset()
	{
	iValuesGiven.Reset();
	}

void TProtocolDescriptionParams::TProtocolDescParamsExpected::Reset()
	{
	iName = EFalse;
	iAddrFamily = EFalse;
	iProtocol = EFalse;
	iSockType = EFalse;
	iVersion = EFalse;
	iByteOrder = EFalse;
	iServiceInfo = EFalse;
	iNamingServices = EFalse;
	iSecurity = EFalse;
	iMessageSize = EFalse;
	}

TBool TProtocolDescriptionParams::MatchesExpected(TProtocolDesc& aProtocolDescription)
	{
	TBool verdict = ETrue;
	
	// Default to pass and then just need to find a single one that does not match
	if(iValuesGiven.iName && (iValues.iName != aProtocolDescription.iName)) verdict = EFalse;
	if(iValuesGiven.iAddrFamily && (iValues.iAddrFamily != aProtocolDescription.iAddrFamily)) verdict = EFalse;
	if(iValuesGiven.iProtocol && (iValues.iProtocol != aProtocolDescription.iProtocol)) verdict = EFalse;
	if(iValuesGiven.iSockType && (iValues.iSockType != aProtocolDescription.iSockType)) verdict = EFalse;
	if(iValuesGiven.iVersion &&
		(
			iValues.iVersion.iMajor != aProtocolDescription.iVersion.iMajor ||
			iValues.iVersion.iMinor != aProtocolDescription.iVersion.iMinor ||
			iValues.iVersion.iBuild != aProtocolDescription.iVersion.iBuild
		))
		verdict = EFalse;
	if(iValuesGiven.iByteOrder && (iValues.iByteOrder != aProtocolDescription.iByteOrder)) verdict = EFalse;
	if(iValuesGiven.iServiceInfo && (iValues.iServiceInfo != aProtocolDescription.iServiceInfo)) verdict = EFalse;
	if(iValuesGiven.iNamingServices && (iValues.iNamingServices != aProtocolDescription.iNamingServices)) verdict = EFalse;
	if(iValuesGiven.iSecurity && (iValues.iSecurity != aProtocolDescription.iSecurity)) verdict = EFalse;
	if(iValuesGiven.iMessageSize && (iValues.iMessageSize != aProtocolDescription.iMessageSize)) verdict = EFalse;

	return verdict;		
	}

_LIT(KName, "Name");
_LIT(KAddrFamily, "AddrFamily");
_LIT(KProtocol, "Protocol");
_LIT(KSockType, "SockType");
_LIT(KVersionMajor, "VersionMajor");
_LIT(KVersionMinor, "VersionMinor");
_LIT(KVersionBuild, "VersionBuild");
_LIT(KByteOrder, "ByteOrder");
_LIT(KServiceInfo, "ServiceInfo");
_LIT(KNamingServices, "NamingServices");
_LIT(KSecurity, "Security");
_LIT(KMessageSize, "MessageSize");

TInt TProtocolDescriptionParams::FetchDescription(TProtocolDescriptionParams& aParams, CTestStep& aTestStep)
	{
    // Protocol name
    TPtrC name;
	if (aTestStep.GetStringFromConfig(aTestStep.ConfigSection(), KName, name) == 1)
        {
		aParams.iValues.iName.Copy(name);
		aParams.iValuesGiven.iName = ETrue;
        }

	// Address family
	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KAddrFamily, (TInt&)aParams.iValues.iAddrFamily) == 1)
        {
		aParams.iValuesGiven.iAddrFamily = ETrue;
        }

	// Protocol
	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KProtocol, (TInt&)aParams.iValues.iProtocol) == 1)
        {
		aParams.iValuesGiven.iProtocol = ETrue;
        }

	// Socket type
	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KSockType, (TInt&)aParams.iValues.iSockType) == 1)
        {
		aParams.iValuesGiven.iSockType = ETrue;
        }

	// Version
	TInt versionMajor;
	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionMajor, versionMajor) == 1)
        {
		aParams.iValues.iVersion.iMajor = (TInt8)versionMajor;

		TInt versionMinor;
		if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionMinor, versionMinor) == 1)
			{
			aParams.iValues.iVersion.iMinor = (TInt8)versionMinor;

			TInt versionBuild;
			if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionBuild, versionBuild) == 1)
				{
				aParams.iValues.iVersion.iBuild = (TInt16)versionBuild;

				// Got all the version info
				aParams.iValuesGiven.iVersion = ETrue;
				}
			}
        }

	// Byte order
	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KByteOrder, (TInt&)aParams.iValues.iByteOrder) == 1)
        {
		aParams.iValuesGiven.iByteOrder = ETrue;
        }

	// Service info
	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KServiceInfo, (TInt&)aParams.iValues.iServiceInfo) == 1)
        {
		aParams.iValuesGiven.iServiceInfo = ETrue;
        }

	// Naming services
	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KNamingServices, (TInt&)aParams.iValues.iNamingServices) == 1)
        {
		aParams.iValuesGiven.iNamingServices = ETrue;
        }

	// Security
	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KSecurity, (TInt&)aParams.iValues.iSecurity) == 1)
        {
		aParams.iValuesGiven.iSecurity = ETrue;
        }

	// Message size
	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KMessageSize, (TInt&)aParams.iValues.iMessageSize) == 1)
        {
		aParams.iValuesGiven.iMessageSize = ETrue;
        }

	return aParams.iValuesGiven.AllExpected() ? KErrNone : KErrNotFound;
	}

TBool TProtocolDescriptionParams::TProtocolDescParamsExpected::NoneExpected()
	{
	return (!iName && !iAddrFamily && !iProtocol && !iSockType && !iVersion && !iByteOrder && !iServiceInfo && !iNamingServices && !iSecurity && !iMessageSize) ?
		ETrue :
		EFalse;
	}
	
TBool TProtocolDescriptionParams::TProtocolDescParamsExpected::AllExpected()
	{
	return (iName && iAddrFamily && iProtocol && iSockType && iVersion && iByteOrder && iServiceInfo && iNamingServices && iSecurity && iMessageSize) ?
		ETrue :
		EFalse;
	}

void TSocketProtocolDescriptionParams::Reset()
	{
	iSocketName.Set(KNullDesC);
	iProtocolDescParams.Reset();
	}

void TSocketServFindProtocolParams::Reset()
	{
	iSocketServName.Set(KNullDesC);
	iProtocolDescParams.Reset();
	}

void TSocketServGetProtocolInfoParams::Reset()
	{
	iSocketServName.Set(KNullDesC);
	iProtocolIndex = 0;
	iProtocolDescParams.Reset();
	}


//
//TRConnectionParams - container for parameters (from an .ini file)
//needed for operations on a connections

void TRConnectionParams::Reset()
    {
    iSockServName.Set(KNullDesC);
    iConnectionName.Set(KNullDesC);
    iAttachToConnectionName.Set(KNullDesC);

	iBearer = 0;
	iIAP = 0;
	iNET = 0;
	iSNAP = 0;

    iConnStopType = (RConnection::TConnStopType)0;
    iConnAttachType = (RConnection::TConnAttachType)0;
    iStartWithOldPreferences = 0;
    iStartWithSnapPreferences = 0;
    iAsynch = EFalse;
    }

//
//TRSubConnectionParams - container for parameters (from an .ini file)
//needed for operations on a subconnections

void TRSubConnectionParams::Reset()
    {
    iSockServName.Set(KNullDesC);
	iConnectionName.Set(KNullDesC);
	iSubConnectionName.Set(KNullDesC);
	iSocketName.Set(KNullDesC);

	iSubConnectionParamsName.Set(KNullDesC);
	iSubConnectionEventName.Set(KNullDesC);

    iSubConnType = (RSubConnection::TSubConnType)0;
    }

//
//TEsockTestEventContainer - encapsulates all necessary RConnection
//or RSubConnection event data so that it can be conveniently stored in a map.

void TEventContainerParams::Reset()
    {
    iEventName.Set(KNullDesC);
	iSubConnectionName.Set(KNullDesC);
	iConnectionName.Set(KNullDesC);
	iAvailabilityExtName.Set(KNullDesC);
	iConnectionManagerExtName.Set(KNullDesC);
	iExtensionName.Set(KNullDesC);
	iMobilityExtName.Set(KNullDesC);
	iAllEvents = EFalse;
	iGenericEvents = EFalse;
	iEventMask = 0;
	iTimeoutMiliSecs = 0;
    }

TEsockTestEventContainer::~TEsockTestEventContainer()
    {
    iEventNotifBuf.Zero();
    }

//
// TEsockTestDataMonitoringEventContainer - encapsulates all necessary data monitoring
// event data so that it can be conveniently stored in a map.    

void TDataMonitorEventParams::Reset()
	{
	iEventName.Copy(KNullDesC);
	iConnectionName.Set(KNullDesC);
	iSubConnectionName.Set(KNullDesC);
	iDataMonitorName.Set(KNullDesC);
	
	iDelta = 0;
	iMinExpectedVolume = 0;
	}

TPtrC& TDataMonitorEventParams::ConnOrSubConnName()
	{
	if(iConnectionName.Length() > 0)
		{
		return iConnectionName;
		}
	else 
		{
		// We return this regardless and consider the default KNullDesC
		// to represent an error
		return iSubConnectionName;
		}
	}

//
//TRSimtsyEventParams - container for parameters (from an .ini file)
void TSimTsyEventParams::Reset()
    {

	iConnectionName.Set(KNullDesC);
	iSimTsyEventName.Set(KNullDesC);
	iEventName.Set(KNullDesC);
	iEventKey=0;
	iEventIndex=0;

    }


//
//CCEsockTestBase

CCEsockTestBase::~CCEsockTestBase()
	{
	CleanAll();
	}

//
//socket server functions library

TInt CCEsockTestBase::CreateSocketServer(const TDesC& aSockServName)
	{
    //check if this secket server hasn't been created already
    if (iSockServs.Find(aSockServName)!=NULL)
    	return KErrAlreadyExists;

    RSocketServ* ss = new RSocketServ;
    if (ss==NULL)
    	return KErrNoMemory;

	TInt error = iSockServs.Add(ss,aSockServName);
	if (error!=KErrNone)
		delete ss;


	return error;
	}

TInt CCEsockTestBase::ConnectSocketServer(const TDesC& aSockServName)
	{
    //check if this secket server hasn't been created already
    RSocketServ* ss = iSockServs.Find(aSockServName);
    if (ss==NULL)
    	return KErrNotFound;

	return ss->Connect();
	}

TInt CCEsockTestBase::CloseSocketServer(const TDesC& aSockServName)
	{
    //check if this secket server hasn't been created already
    RSocketServ* ss = iSockServs.Find(aSockServName);
    if (ss==NULL)
    	return KErrNotFound;

	ss->Close();
	return KErrNone;
	}

TInt CCEsockTestBase::SocketServerNumProtocols(TSocketServerNumProtocolsParams& aParams, TInt& aNumProtocols)
	{
    // Fetch the socket server instance which must already exist
    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
    if (ss == NULL)
    	return KErrNotFound;

	TInt error = ss->NumProtocols((TUint&)aNumProtocols);
	if(error != KErrNone)
		{
		return error;
		}
	
	if(aParams.iToBeSaved)
		{
		// If we are saving the value then do so
		// If it exists already then update it
		TInt* currentValue = NULL;
		currentValue = iIntegerValues.Find(aParams.iSavedAsName);
		if(currentValue != NULL)
			{
			*currentValue = aNumProtocols;
			return KErrNone;
			}

		// Else create the new variable
		currentValue = new TInt(aNumProtocols);
		if (currentValue == NULL)
			return KErrNoMemory;

		error = iIntegerValues.Add(currentValue, aParams.iSavedAsName);
		}

	return error;
	}

TInt CCEsockTestBase::SocketServerFindProtocol(TSocketServFindProtocolParams& aParams, TProtocolDesc& aProtocolDescription)
	{
    // Fetch the socket server instance which must already exist
    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
    if (ss == NULL)
    	return KErrNotFound;

	return ss->FindProtocol(aParams.iProtocolDescParams.iValues.iName, aProtocolDescription);
	}

TInt CCEsockTestBase::SocketServerGetProtocolInfo(TSocketServGetProtocolInfoParams& aParams, TProtocolDesc& aProtocolDescription)
	{
    // Fetch the socket server instance which must already exist
    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
    if (ss == NULL)
    	return KErrNotFound;

	return ss->GetProtocolInfo(aParams.iProtocolIndex, aProtocolDescription);
	}


TInt CCEsockTestBase::SocketServerStartProtocol(TSocketServStartStopProtocolParams& aParams, TRequestStatus& aStatus)
	{
    // Fetch the socket server instance which must already exist
    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
    if (ss == NULL)
    	return KErrNotFound;

	// Start the protocol
	ss->StartProtocol(
		aParams.iAddrFamily,
		aParams.iSockType,
		aParams.iProtocol,
		aStatus);
	return KErrNone;	
	}


TInt CCEsockTestBase::SocketServerStopProtocol(TSocketServStartStopProtocolParams& aParams, TRequestStatus& aStatus)
	{
    // Fetch the socket server instance which must already exist
    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
    if (ss == NULL)
    	return KErrNotFound;

	// Stop the protocol
	ss->StopProtocol(
		aParams.iAddrFamily,
		aParams.iSockType,
		aParams.iProtocol,
		aStatus);
	return KErrNone;	
	}


TInt CCEsockTestBase::__DbgFailNext(const TDesC& aSockServName, TInt aCount)
	{
	RSocketServ* ss = iSockServs.Find(aSockServName);
    if (ss==NULL)
		return KErrNotFound;

	return ss->__DbgFailNext(aCount);
	}	

TBool CCEsockTestBase::__DbgCheckFailNext(const TDesC& aSockServName)
    {
	RSocketServ* ss = iSockServs.Find(aSockServName);
    if (ss==NULL)
		return KErrNotFound;

	return ss->__DbgCheckFailNext();
    }


//
//connection server functions library
TInt CCEsockTestBase::CreateConnectionServer(const TDesC& aConnectionServName)
	{
    if (iConnectionServs.Find(aConnectionServName) != NULL)
    	return KErrAlreadyExists;

    RConnectionServ* connServ = new RConnectionServ;
    if (connServ == NULL)
    	return KErrNoMemory;

	TInt error = iConnectionServs.Add(connServ, aConnectionServName);
	if (error != KErrNone)
		delete connServ;

	return error;
	}

TInt CCEsockTestBase::ConnectConnectionServer(const TDesC& aConnectionServName, TUint aTierId)
	{
    //check if this secket server hasn't been created already
    RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);
    if (connServ == NULL)
    	return KErrNotFound;

	return connServ->Connect(aTierId);
	}

TInt CCEsockTestBase::CloseConnectionServer(const TDesC& aConnectionServName)
	{
    // Find the connection server we are referring to
    RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);
    if (connServ == NULL)
    	return KErrNotFound;

	connServ->Close();
	return KErrNone;
	}

TInt CCEsockTestBase::ConnectionAccessPointStatusQuery(
		const TDesC& aConnectionServName,
		const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
		ConnectionServ::CConnectionServParameterBundle& aResultBundle)
	{
	RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);

	if(connServ == NULL)
		return KErrNotFound;
		
	// Need a local active scheduler for the RConnectionServ API
	CActiveScheduler* as = new(ELeave) CActiveScheduler;
	CleanupStack::PushL(as);
	CActiveScheduler::Install(as);

	CConnServStatusQuery* sq = CConnServStatusQuery::NewLC(connServ, aQueryBundle, aResultBundle);

	TRAP_IGNORE(CActiveScheduler::Start())

	TInt res2 = sq->ErrCode();

	CleanupStack::PopAndDestroy(sq);	
	CleanupStack::PopAndDestroy(as);

	return res2;
	}

class CMyTimer : public CTimer
	{
public:
	static CMyTimer* NewL()
		{
		CMyTimer* timer = new CMyTimer();
		if(timer)
			{
			timer->ConstructL();
			CActiveScheduler::Add(timer);
			}
		return timer;
		}
		
	CMyTimer() : CTimer(EPriorityStandard)
		{
		}
	void RunL()
		{
		// Simply stop the scheduler as this will force the cancellation we are after
		CActiveScheduler::Current()->Stop();		
		}
	};

const TInt KHalfASecondInMicroSeconds = 500000;

TInt CCEsockTestBase::CancelAccessPointStatusQuery(
		const TDesC& aConnectionServName,
		const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
		ConnectionServ::CConnectionServParameterBundle& aResultBundle)
	{
	RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);

	if(connServ == NULL)
		return KErrNotFound;
		
	// Need a local active scheduler for the RConnectionServ API
	CActiveScheduler* as = new(ELeave) CActiveScheduler;
	CleanupStack::PushL(as);
	CActiveScheduler::Install(as);

	// Create a timer that will complete almost immediately and stop the scheduler
	// thereby canceling the query while it is in progress
	// This all requires a long running query
	CMyTimer* timer = CMyTimer::NewL();
	CleanupStack::PushL(timer);
	timer->After(KHalfASecondInMicroSeconds);
	
	// Create active object to manage the query
	CConnServStatusQuery* sq = CConnServStatusQuery::NewLC(connServ, aQueryBundle, aResultBundle);
	
	// Start the scheduler
	TRAP_IGNORE(CActiveScheduler::Start())

	sq->Cancel();
	timer->Cancel();

	// Check that the cancel status is what we expected
	TInt res2 = sq->ErrCode();

	CleanupStack::PopAndDestroy(sq);
	CleanupStack::PopAndDestroy(timer);
	CleanupStack::PopAndDestroy(as);
	
	return res2;
	}


//
//socket functions library

RSocket* CCEsockTestBase::FindSocket(const TDesC& aSocketName)
    {
    return iSocks.Find(aSocketName);
    }

TInt CCEsockTestBase::CreateSocket(const TDesC& aSocketName)
	{
    //check if this socket hasn't been created already
    if (iSocks.Find(aSocketName)!=NULL)
    	return KErrAlreadyExists;

    RSocket* s = new RSocket;
    if (s==NULL)
    	return KErrNoMemory;

	TInt error = iSocks.Add(s,aSocketName);
	if (error!=KErrNone)
		delete s;

	return error;
	}

TInt CCEsockTestBase::OpenSocket(const TRSocketParams& aParams)
	{
    RSocketServ* ss = iSockServs.Find(aParams.iSockServName);
    if (ss==NULL)
		return KErrNotFound;

    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s==NULL)
		return KErrNotFound;

    TInt error;

    //try to find the connection (if specified)
    if (aParams.iConnectionName.Length()>0)
    	{
		RConnection* c = iConns.Find(aParams.iConnectionName);
		if (c==NULL)
			return KErrNotFound;
		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol, *c);
		}
	else if (aParams.iSubconnectionName.Length()>0)
    	{
		RSubConnection* sc = iSubConns.Find(aParams.iSubconnectionName);
		if (sc==NULL)
			{
			return KErrNotFound;
			}
		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol, *sc);
		}
	else if (aParams.iProtocolName.Length()>0)
		{
		error = s->Open(*ss,aParams.iProtocolName);
		}
	else
		{
		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol);
		}


	return error;
	}

TInt CCEsockTestBase::BindSocket(const TRSocketParams& /*aParams*/)
	{
    return KErrNotSupported;
    /*
    RSocket* s = iSocks.Find(aSockeSParams.iSocketName);
	if (s==NULL)
		return KErrNotFound;

	TInt error = KErrNone;
	if (aSockeSParams.iProtocol==KProtocolInetUdp)
	    error = s->SetOpt(KSoUdpSynchronousSend,KSolInetUdp,1);
	if (error!=KErrNone)
		return error;

	//bind to Local address for TCP or UDP
	return s->Bind(aSockeSParams.iLocalIP);
	*/
	}

TInt CCEsockTestBase::ConnectSocket(TRSocketParams& aParams, TRequestStatus& aRequestStatus)
	{
    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s==NULL)
	    {
		return KErrNotFound;
	    }

    TInt err = KErrNone;

    if (aParams.iProtocol==KProtocolInetUdp)
        {
        err = s->SetOpt(KSoUdpSynchronousSend,KSolInetUdp,1);
        if (err != KErrNone)
            {
            return err;
            }
        }

    if (!aParams.iLocalIP.IsUnspecified() || !aParams.iLocalIP.IsWildPort())
        {
        err = s->Bind(aParams.iLocalIP);
        }

    if (err == KErrNone)
        {
        s->Connect(aParams.iRemoteIP, aRequestStatus);
        }

    return err;
	}

TInt CCEsockTestBase::CancelConnectSocket(const TRSocketParams& aParams)
	{
    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s==NULL)
		return KErrNotFound;

    s->CancelConnect();
    return KErrNone;
	}

void CCEsockTestBase::SendAndReceiveDataL(const TRSocketParams& aParams)
	{
    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s==NULL)
		User::Leave(KErrNotFound);

	TInt recvCount = 0;
	TRequestStatus stat;
	TBuf8<50> Data;

	//set up buffers
	HBufC8* writebuf = HBufC8::NewMaxLC(aParams.iPacketSize);
	HBufC8* readbuf  = HBufC8::NewMaxLC(aParams.iPacketSize);
	
	// In the case of armv5, HBufC8 MaxLength is set as 1504 or 1512
	// To sort it out we use TPtr8(TUint8* ,MaxLenghth) constructor
	// instead of using
	// TPtr8 ptrwritebuf = writebuf->Des();
	// TPtr8 ptrreadbuf = readbuf->Des();
	TPtr8 ptrwritebuf(const_cast<TUint8*>(writebuf->Ptr()), aParams.iPacketSize);
	TPtr8 ptrreadbuf(const_cast<TUint8*>(readbuf->Ptr()), aParams.iPacketSize);
	
	// NewMaxLC may give a max size bigger than specified. Make sure length and max length are in sync so that
	// the Read will complete. For example, NewMaxLC(1500) may give back a buffer 1504 as the max size. if you Write
	// then Read on that, it'll write the length (1500) but try to read the max length (1504). this'll never complete
	// because we'll only get back as many bytes as we wrote the the echo server.
	ptrwritebuf.SetLength(ptrwritebuf.MaxLength());
	ptrreadbuf.SetLength(ptrreadbuf.MaxLength());

    if (aParams.iProtocol==KProtocolInetTcp)
        {
   		for (TInt i = 0; i < aParams.iNrOfPackets; i++)
    		{
	    	// initialise data
		    Data.Format(_L8("TCP-packet:%d helloworld"),i);
		    ptrwritebuf.Repeat( Data );

		    // write data
		    s->Write(ptrwritebuf,stat);
		    User::WaitForRequest(stat);
		    User::LeaveIfError(stat.Int());

		    // read data
		    s->Read(ptrreadbuf, stat);
		    User::WaitForRequest(stat);
			User::LeaveIfError(stat.Int());

		    // compare the data
		    if (ptrwritebuf.Compare(ptrreadbuf) != 0)
		    	User::Leave(KErrGeneral);

		    recvCount+=ptrreadbuf.Length();
	    	}
		}
	else if (aParams.iProtocol==KProtocolInetUdp || aParams.iProtocol == KProtocolInetDummy)
		{
        for (TInt i = 0; i < aParams.iNrOfPackets; i++)
		    {
		    // initialise data
		    Data.Format(_L8("UDP-packet:%d helloworld"),i);
		    ptrwritebuf.Repeat( Data );

		    // If we are colouring the payload then first prefix outgoing payload with command byte to tell the stack so
		    if(aParams.iPayloadColouringIsEnabled)
		    	{
				ptrwritebuf[0] = 0xF9; // KColourDataByLinkTierAccessPointId; TODO_CDG
				}
		    
		    // write data
		    s->Send(ptrwritebuf, 0, stat);
		    User::WaitForRequest(stat);
		    User::LeaveIfError(stat.Int());

		    // If the returned data will be coloured by the IP stack for test purposes
		    // then we had better change what we compare it with
		    if(aParams.iPayloadColouringIsEnabled)
		    	{
		    	ptrwritebuf[0] += static_cast<TUint8>(aParams.iPayloadColour);
				}
		    
		    s->Recv(ptrreadbuf, 0, stat);
		    User::WaitForRequest(stat);
		    User::LeaveIfError(stat.Int());

		    // compare the data
		    if (ptrwritebuf.Compare(ptrreadbuf) != 0 )
		    	User::Leave(KErrGeneral);

		    recvCount += ptrreadbuf.Length();
		    }
		}
	else
        User::Leave(KErrNotFound);

    CleanupStack::PopAndDestroy(2, writebuf);	//	writebuf and readbuf

	// check the total received (95 per cent is allowable for us)
	if (recvCount*aParams.iPacketSize < (0.95*(aParams.iNrOfPackets*aParams.iPacketSize)))
		User::Leave(KErrGeneral);
	}

TInt CCEsockTestBase::CloseSocket(const TDesC& aSocketName)
	{
    RSocket* s = iSocks.Find(aSocketName);
	if (s==NULL)
		return KErrNotFound;

	s->Close();
    return KErrNone;
	}

TInt CCEsockTestBase::ShutdownSocket(const TRSocketParams& aParams, TRequestStatus& aRequestStatus)
	{
    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s==NULL)
		return KErrNotFound;

	s->Shutdown(aParams.iShutdownType,aRequestStatus);
    return KErrNone;
	}

TInt CCEsockTestBase::IoctlSocket(const TRSocketIoctlParams& aParams, TDes8& aIoctlOutput, TRequestStatus& aRequestStatus)
	{
    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s == NULL)
		return KErrNotFound;

	s->Ioctl(aParams.iIoctlCommand, aRequestStatus, &aIoctlOutput, aParams.iIoctlLevel);
	User::WaitForRequest(aRequestStatus);

    return KErrNone;
	}

TInt CCEsockTestBase::GetOptSocket(const TRSocketGetOptParams& aParams, TDes8& aGetOptOutput)
	{
    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s == NULL)
		return KErrNotFound;

	return s->GetOpt(aParams.iOptionName, aParams.iOptionLevel, aGetOptOutput);
	}

TInt CCEsockTestBase::GetOptSocket(const TRSocketGetOptParams& aParams, TInt& aGetOptOutput)
	{
    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s == NULL)
		return KErrNotFound;

	return s->GetOpt(aParams.iOptionName, aParams.iOptionLevel, aGetOptOutput);
	}

TInt CCEsockTestBase::SetOptSocket(const TRSocketSetOptParams& aParams, TDes8& aSetOptInput)
    {
    RSocket* s = iSocks.Find(aParams.iSocketName);
    if (s == NULL)
        return KErrNotFound;

    return s->SetOpt(aParams.iOptionName, aParams.iOptionLevel, aSetOptInput);
    }

TInt CCEsockTestBase::SetOptSocket(const TRSocketSetOptParams& aParams, TInt& aSetOptInput)
    {
    RSocket* s = iSocks.Find(aParams.iSocketName);
    if (s == NULL)
        return KErrNotFound;

    return s->SetOpt(aParams.iOptionName, aParams.iOptionLevel, aSetOptInput);
    }

TInt CCEsockTestBase::ProtocolDescription(
	const TSocketProtocolDescriptionParams& aParams,
	TProtocolDesc& aProtocolDescriptionOutput)
	{
    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s == NULL)
		return KErrNotFound;

	return s->Info(aProtocolDescriptionOutput);
	}


//
//connection functions library

RConnection* CCEsockTestBase::FindConnection(const TDesC& aConnectionName)
    {
    return iConns.Find(aConnectionName);
    }

TInt CCEsockTestBase::CreateConnection(const TDesC& aConnectionName)
	{
    //check if this connection hasn't been created already
    if (iConns.Find(aConnectionName)!=NULL)
    	return KErrAlreadyExists;

    RConnection* c = new RConnection;
    if (c==NULL)
    	return KErrNoMemory;

	TInt error = iConns.Add(c,aConnectionName);
	if (error!=KErrNone)
		delete c;

	return error;
	}

TInt CCEsockTestBase::OpenConnection(const TRConnectionParams& aParams)
	{
    RSocketServ* ss = iSockServs.Find(aParams.iSockServName);
    if (ss==NULL)
		return KErrNotFound;

    RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	if(aParams.iConnectionType != -1)
	   return c->Open(*ss,aParams.iConnectionType);

	return c->Open(*ss);
	}

TInt CCEsockTestBase::WaitforIncomingConnection(const TRSubConnectionParams& aParams)
	{
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	return c->WaitForIncoming(*sc);
	}

TInt CCEsockTestBase::WaitforIncomingConnection(const TRSubConnectionParams& aParams,TRequestStatus& reqStat)
	{
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	c->WaitForIncoming(*sc,reqStat);

	return KErrNone;
	}

TInt CCEsockTestBase::AcceptIncomingConnection(const TRSubConnectionParams& aParams)
	{
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	sc->Start();
	
	return KErrNone;
	}
	
TInt CCEsockTestBase::AsyncAcceptIncomingConnection(const TRSubConnectionParams& aParams, TRequestStatus& reqStat)
	{
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	sc->Start(reqStat);
	
	return KErrNone;
	}
	
TInt CCEsockTestBase::RejectIncomingConnection(const TRSubConnectionParams& aParams)
	{
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	sc->Stop();

	return KErrNone;
	}

TInt CCEsockTestBase::CancelIncomingConnection(const TRSubConnectionParams& aParams)
	{
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	c->CancelWaitForIncoming();

	return KErrNone;
	}


TInt CCEsockTestBase::StartConnection(RConnection& aConn, TConnPref& aPrefs, TRequestStatus* aRequestStatus)
	{
	if (aRequestStatus)
		{
		aConn.Start(aPrefs, *aRequestStatus);
		}
	else
		{
		return aConn.Start(aPrefs);
		}
	return KErrNone;
	}

TInt CCEsockTestBase::GetParameters(TPtrC aConnectionName, ESock::CCommsDataObjectBase& aDataObject)
    {
    RConnection* c = iConns.Find(aConnectionName);
    if (c==NULL)
        return KErrNotFound;
    return c->GetParameters(aDataObject);
    }

TInt CCEsockTestBase::GetIntSetting(TPtrC aConnectionName, const TDesC& aSettingName, TUint32& aValue)
    {
    RConnection* c = iConns.Find(aConnectionName);
    if (c==NULL)
        return KErrNotFound;
    return c->GetIntSetting(aSettingName, aValue);
    }


TInt CCEsockTestBase::StartConnection(TRConnectionParams& aParams)
	{
    RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;
	TRequestStatus* requestStatus = NULL;
	if (aParams.iAsynch)
		{
		requestStatus = new TRequestStatus;
	    if (requestStatus==NULL)
	    	return KErrNoMemory;
	    
		TInt error = iRequestStatuses.Add(requestStatus, aParams.iConnectionName);
		if (error!=KErrNone)
			{
			delete requestStatus;
			return error;
			}
		}

	TInt error;
	if (aParams.iStartWithSnapPreferences)
		{
		TCommSnapPref prefs;
		prefs.SetSnap(aParams.iSNAP);

		error = StartConnection(*c, prefs, requestStatus);
		}
	else if (aParams.iStartWithOldPreferences)
		{
		TCommDbConnPref prefs;
		prefs.SetBearerSet(aParams.iBearer);
		prefs.SetIapId(aParams.iIAP);
		error = StartConnection(*c, prefs, requestStatus);
		}
	else if(aParams.iStartWithConPrefList)
		{
		TConnPrefList* prefs = TConnPrefList::NewL();
		CleanupStack::PushL(prefs);
		TConnAPPref* APPref = TConnAPPref::NewL(aParams.iSNAP);
		CleanupStack::PushL(APPref);
		TDummyPref* dummyPref = TDummyPref::NewL(aParams.iDummy);
		CleanupStack::PushL(dummyPref);
		if(aParams.iStartWithDummy)
			prefs->AppendL(dummyPref);
		
		TConnAutoStartPref* autoPref = TConnAutoStartPref::NewL();
		CleanupStack::PushL(autoPref);
		if(aParams.iStartAuto)
			prefs->AppendL(autoPref);
		
		prefs->AppendL(APPref);
		error = StartConnection(*c, *prefs, requestStatus);
		
		delete APPref;
		delete dummyPref;
		delete autoPref;
		if (aParams.iStartAuto)
			prefs->Remove(0);
		if (aParams.iStartWithDummy)
			prefs->Remove(0);
		prefs->Remove(0);
		delete prefs;
		
		CleanupStack::Pop(4);
		}
	else
		{
		if (requestStatus)
			{
			c->Start(*requestStatus);
			}
		else
			{
			error = c->Start();
			}
		}
	
	return error;
	}

TInt CCEsockTestBase::AttachToConnection(const TRConnectionParams& aParams)
	{
	RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	TUint count = 0;
		c->EnumerateConnections(count);
	
	if(count < 1)
		return KErrNotFound;

	//
	TInt error = KErrNotSupported;
	RConnection* atc = iConns.Find(aParams.iAttachToConnectionName);
	if (atc!=NULL)
		{ //Currently this is only for the new attach (TConnProviderInfo)
		//If you want to extend this test step for legacy attach (TConnectionInfo),
		//you need to add a parameter to recognise which attach it is.

		ESock::XProviderInfoQuerySet* querySet = ESock::XProviderInfoQuerySet::NewL();
		CleanupDeletePushL(querySet);
		
		// CProviderInfoQuerySet takes ownership of the X-class
		ESock::CProviderInfoQuerySet* queryContainer = ESock::CProviderInfoQuerySet::NewL(querySet);
		CleanupStack::Pop(querySet);
		CleanupStack::PushL(queryContainer);
		
		error = atc->GetParameters(*queryContainer);
		if (error != KErrNone)
			return error;

		ESock::XProviderInfoQuerySet& outputQuerySet = queryContainer->DataObject();

		TPckg<TConnProviderInfo> pkgConnInfo(outputQuerySet.ConnProviderInfo());
		error = c->Attach(pkgConnInfo, aParams.iConnAttachType);
		
		CleanupStack::PopAndDestroy(queryContainer);
		}
	else
		{
		TConnectionInfo connInfo;
		TPckg<TConnectionInfo> pkgConnInfo(connInfo);

		TBool found = EFalse;
		for(TInt index = 1; index <= count; ++index)
			{
			error = c->GetConnectionInfo(index, pkgConnInfo);
			if(error != KErrNone)
				return error;
			
			if(aParams.iIAP == 0 && aParams.iNET == 0)
				{
				found = ETrue;
				}
			else if(aParams.iIAP > 0 && aParams.iNET > 0)	
				{
				found = (aParams.iIAP == connInfo.iIapId && aParams.iNET == connInfo.iNetId) ? ETrue : EFalse;
				}
			else if(aParams.iIAP > 0)
				{
				found = aParams.iIAP == connInfo.iIapId ? ETrue : EFalse;
				}
			else if(aParams.iNET > 0)	
				{
				found = aParams.iNET == connInfo.iNetId ? ETrue : EFalse;
				}
			
			if(found) 
				break;	
			}
			if(!found)	
				return KErrNotFound;
			
			error = c->Attach(pkgConnInfo,aParams.iConnAttachType);
		}
	
	return error;
	}

TInt CCEsockTestBase::StopConnection(const TRConnectionParams& aParams)
    {
    RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	c->Stop(aParams.iConnStopType);
	return KErrNone;
    }

TInt CCEsockTestBase::CloseConnection(const TDesC& aConnectionName)
	{
    RConnection* c = iConns.Find(aConnectionName);
	if (c==NULL)
		return KErrNotFound;

	c->Close();
	return KErrNone;
	}

//
//connection events
//(each event notification request is encapsulated in a "EventContainer" that can easily be stored in a map.)

TInt CCEsockTestBase::RegisterForProgressNotificationEvent(const TEventContainerParams& aParams)
	{
	TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName);
	if (ec==NULL)
		{
		ec = new TEsockTestEventContainer;
		if (ec==NULL)
			return KErrNoMemory;

		TInt error = iConnEvents.Add(ec,aParams.iEventName);
		if (error!=KErrNone)
			{
			delete ec;
			return error;
			}
		}

	__ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 1));
	RConnection* conn = iConns.Find(aParams.iConnectionName);
	if (conn==NULL)
		{
		return KErrNotFound;
		}
	
	if (aParams.iEventMask == 0)
		return KErrArgument;

	conn->ProgressNotification(ec->iProgressBuf, ec->iEventReceived, aParams.iEventMask);
	return KErrNone;
	}

TInt CCEsockTestBase::ReceiveProgressNotificationEvent(TNifProgress*&aNifProgress, const TDesC& aEventName, TUint aTimeoutInMiliSec)
	{
	TEsockTestEventContainer* ec = iConnEvents.Find(aEventName);
	if (ec==NULL)
		return KErrNotFound;
	if (aTimeoutInMiliSec)
	    {
	    RTimer timer;
	    timer.CreateLocal();	    
	    TRequestStatus timerStatus;
	    timer.After(timerStatus, aTimeoutInMiliSec * 1000);
	    User::WaitForRequest(ec->iEventReceived, timerStatus);
	    }
	else
	    {
	    User::WaitForRequest(ec->iEventReceived);
	    }
	aNifProgress = (ec->iEventReceived.Int()==KErrNone)? &ec->iProgressBuf() : NULL;
	return ec->iEventReceived.Int();
	}


//mobility extensions
RCommsMobilityApiExt* CCEsockTestBase::FindMobilityExtension(const TDesC& aMobilityExtensionName)
    {
    return iMobilityExts.Find(aMobilityExtensionName);
    }

TInt CCEsockTestBase::CreateMobilityExtension(const TDesC& aMobilityExtensionName)
    {
    //check if this extension hasn't been created already
    if (iMobilityExts.Find(aMobilityExtensionName)!=NULL)
    	return KErrAlreadyExists;

    RCommsMobilityApiExt* me = new RCommsMobilityApiExt;
    if (me==NULL)
    	return KErrNoMemory;

	TInt error = iMobilityExts.Add(me,aMobilityExtensionName);
	if (error!=KErrNone)
		delete me;

	return error;
    }


// Data monitoring
//----------------

RCommsDataMonitoringApiExt* CCEsockTestBase::FindDataMonitoringExtension(const TDataMonitorEventParams& aParams)
   {
   return iDataMonitoringExts.Find(aParams.iDataMonitorName);
   }


TEsockTestDataMonitoringResponse* CCEsockTestBase::FindDataMonitoringResponder(const TDataMonitorEventParams& aParams)
	{
	return iDataMonitoringEvents.Find(aParams.iEventName);
	}

TInt CCEsockTestBase::CreateDataMonitoringExtension(const TDataMonitorEventParams& aParams)
   {
   if(iDataMonitoringExts.Find(aParams.iDataMonitorName) != NULL)
      {
      return KErrAlreadyExists;
      }

   RCommsDataMonitoringApiExt* ext = new RCommsDataMonitoringApiExt();

   if(!ext)
      {
    	return KErrNoMemory;
      }

   TInt error = iDataMonitoringExts.Add(ext, aParams.iDataMonitorName);
   
	if (error != KErrNone)
      {
      delete ext;
      }

	return error;
   }

TEsockTestDataMonitoringResponse* CCEsockTestBase::FindOrCreateDataMonitoringResponder(const TDataMonitorEventParams& aParams)
	{
	TEsockTestDataMonitoringResponse* response = FindDataMonitoringResponder(aParams);
	if(response)
		{
		return response;
		}
	
	if(NULL == (response = new TEsockTestDataMonitoringResponse()))
		{
		return NULL;
		}

	TInt err = iDataMonitoringEvents.Add(response, aParams.iEventName);
	if(err != KErrNone)
		{
		delete response;
		response = NULL;
		}
		
	return response;
	}
	
TInt CCEsockTestBase::OpenDataMonitoringExtension(const TDataMonitorEventParams& aParams)
	{
	RCommsSubSession* connOrSubConn = NULL;
	
	if(aParams.iConnectionName.Length() > 0)
		{ // Open extension on an RConnection if specified
		connOrSubConn = iConns.Find(aParams.iConnectionName);
		if(!connOrSubConn) 
			{
			return KErrNotFound;
			}
		}
	else if(aParams.iSubConnectionName.Length() > 0)
		{ // Otherwise open extension on an RSubConnection
		connOrSubConn = iSubConns.Find(aParams.iSubConnectionName);
		if(!connOrSubConn) 
			{
			return KErrNotFound;
			}
		}
	else
		{ // Neither an RConnection or an RSubConnection was specified
		return KErrArgument;
		}
	
	RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName);
	if(!ext)
		{
		return KErrNotFound;
		}
		
	return ext->Open(*connOrSubConn);
	}

TInt CCEsockTestBase::CloseDataMonitoringExtension(const TDataMonitorEventParams& aParams)
	{
	RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName);
	if(!ext)
		{
		return KErrNotFound;
		}
		
	ext->Close();
	
	return KErrNone;
	}

TInt CCEsockTestBase::RequestDataTransferred(const TDataMonitorEventParams& aParams, TDes8& aResponseBuf)
	{
	RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName);
	if(!ext)
		{
		return KErrNotFound;
		}

	TRequestStatus status;	
	ext->RequestDataTransferred(aResponseBuf, status);
	User::WaitForRequest(status);
	
	return KErrNone;
	}

// Find saved stats from a previous DataTransferred request
TDataMonitorStats* CCEsockTestBase::FetchSavedDataMonitorStats(const TDesC& aDataMonitorStatsSavedName)
	{
	return iSavedDataMonitorStats.Find(aDataMonitorStatsSavedName);
	}

// Save data monitor stats for future reference
TInt CCEsockTestBase::SaveDataMonitorStats(const TDesC& aSavedName, TDataMonitorStats& aStatsToSave)
	{
	TInt err;
	
	// Simply add if doesn't already exist
	if(iSavedDataMonitorStats.Find(aSavedName) == NULL)
		{
		err = iSavedDataMonitorStats.Add(&aStatsToSave, aSavedName);
		}
	else
		{
		// Already exists so delete and add in order to replace
		iSavedDataMonitorStats.Remove(aSavedName);
		err = iSavedDataMonitorStats.Add(&aStatsToSave, aSavedName);
		}
		
	return err;
	}

TInt CCEsockTestBase::RequestDataReceivedNotification(const TDataMonitorEventParams& aParams)
	{
	RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams);
	if(!ext)
		{
		return KErrNotFound;
		}

	TEsockTestDataMonitoringResponse* response =	FindOrCreateDataMonitoringResponder(aParams);
	if(!response)
		{
		return KErrNoMemory;
		}

	ext->RequestDataReceivedNotification(aParams.iDelta, aParams.iMinExpectedVolume, response->iBuffer, response->iStatus);
	
	return KErrNone;
	}

TInt CCEsockTestBase::CancelDataReceivedNotificationRequest(const TDataMonitorEventParams& aParams)
	{
	RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams);	
	if(!ext)
		{
		return KErrNotFound;
		}

	TEsockTestDataMonitoringResponse* response = FindOrCreateDataMonitoringResponder(aParams);
	if(!response)
		{
		return KErrNoMemory;
		}

	ext->CancelDataReceivedNotificationRequest();
	User::WaitForRequest(response->iStatus);
	
	// Return the status code from the cancellation
	return response->iStatus.Int();
	}

TInt CCEsockTestBase::ReceiveDataReceivedNotification(const TDataMonitorEventParams& aParams, TDesC8*& aResponseBuf)
	{
	TEsockTestDataMonitoringResponse* response =	FindDataMonitoringResponder(aParams);
	if(!response)
		{
		return KErrNotFound;
		}

	// Check that its not complete already
	if(response->iComplete)
		{
		return KErrGeneral;
		}

	RTimer timer;
	timer.CreateLocal();
	
	TRequestStatus timerStatus;
	timer.After(timerStatus, response->iTimeout * 1000000);
	
	User::WaitForRequest(response->iStatus, timerStatus);
	
	TInt result;
	if(response->iStatus.Int() != KErrNone)
		{
		result = KErrTimedOut;
		}
	else
		{
		timer.Cancel();
		User::WaitForRequest(timerStatus);

	   aResponseBuf = NULL;
	   if(response->iStatus.Int() == KErrNone) 
	   	{
	   	aResponseBuf = &response->iBuffer;
	   	}
   	result = response->iStatus.Int();
   	response->iComplete = ETrue;
		}
		
	timer.Close();
	
	return result;
	}

TInt CCEsockTestBase::RequestDataSentNotification(const TDataMonitorEventParams& aParams)
	{
	// Find the data monitoring extension to start with
	RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams);
	if(!ext)
		{
		return KErrNotFound;
		}
		
	// Find the data monitoring responder that goes with it
	TEsockTestDataMonitoringResponse* response =	FindDataMonitoringResponder(aParams);
	if(!response)
		{
		return KErrNotFound;
		}

	// Make the request on the data monitor
	ext->RequestDataSentNotification(aParams.iDelta, aParams.iMinExpectedVolume, response->iBuffer, response->iStatus);
	
	return KErrNone;
	}

TInt CCEsockTestBase::CancelDataSentNotificationRequest(const TDataMonitorEventParams& aParams)
	{
	RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams);
	if(!ext)
		{
		return KErrNotFound;
		}

	TEsockTestDataMonitoringResponse* response =	FindDataMonitoringResponder(aParams);
	if(!response)
		{
		return KErrNotFound;
		}

	ext->CancelDataSentNotificationRequest();
	User::WaitForRequest(response->iStatus);
	
	// Return the status code from the cancellation
	return response->iStatus.Int();
	}

TInt CCEsockTestBase::ReceiveDataSentNotification(const TDataMonitorEventParams& aParams, TDesC8*& aResponseBuf)
	{
	TEsockTestDataMonitoringResponse* response =	FindDataMonitoringResponder(aParams);
	if(!response)
		{
		return KErrNotFound;
		}

	// Check that its not complete already
	if(response->iComplete)
		{
		return KErrGeneral;
		}

	RTimer timer;
	timer.CreateLocal();
	
	TRequestStatus timerStatus;
	timer.After(timerStatus, response->iTimeout * 1000000);
	
	User::WaitForRequest(response->iStatus, timerStatus);
	
	TInt result;
	if(response->iStatus.Int() != KErrNone)
		{
		result = KErrTimedOut;
		}
	else
		{
		timer.Cancel();
		User::WaitForRequest(timerStatus);

	   aResponseBuf = NULL;
	   if(response->iStatus.Int() == KErrNone) 
	   	{
	   	aResponseBuf = &response->iBuffer;
	   	}
   	result = response->iStatus.Int();
   	response->iComplete = ETrue;
		}
		
	timer.Close();
	
	return result;
	}

#if 0
//
//CommsServer functions library

TInt CCEsockTestBase::CreateCommsServer(const TDesC& aCommsServerName)
	{
    //check if this comms server hasn't been created already
    if (iCommsServers.Find(aCommsServerName)!=NULL)
    	return KErrAlreadyExists;

    RConnection* c = new RConnection;
    if (c==NULL)
    	return KErrNoMemory;

	TInt error = iConns.Add(c,aConnectionName);
	if (error!=KErrNone)
		delete c;

	return error;
	}

TInt CCEsockTestBase::StartCommsServer(const TRCommsServerParams& aParams, TRequestStatus& aRequestStatus)
	{
	RConnManager* c = iCommsServers.Find(aParams.iCommsServerName);
	if (c==NULL)
		return KErrNotFound;
	
	c->Start(prefs,aRequestStatus);
		}
	else if (aParams.iStartWithOldPreferences)
		{
		TCommDbConnPref prefs;
		prefs.SetBearerSet(aParams.iBearer);
		prefs.SetIapId(aParams.iIAP);
		c->Start(prefs,aRequestStatus);
		}
	else
		c->Start(aRequestStatus);

	return KErrNone;
	}

TInt CCEsockTestBase::StartConnection(const TRConnectionParams& aParams)
	{
    RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	TInt error;
	if (aParams.iStartWithSnapPreferences)
		{
		TCommSnapPref prefs;
		prefs.SetSnap(aParams.iSNAP);
		error = c->Start(prefs);
		}
	else if (aParams.iStartWithOldPreferences)
		{
		TCommDbConnPref prefs;
		prefs.SetBearerSet(aParams.iBearer);
		prefs.SetIapId(aParams.iIAP);
		error = c->Start(prefs);
		}
	else
		error = c->Start();

	return error;
	}

TInt CCEsockTestBase::StopConnection(const TRConnectionParams& aParams)
    {
    RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	c->Stop(aParams.iConnStopType);
	return KErrNone;
    }
#endif


// SubConnections
//---------------

RSubConnection* CCEsockTestBase::FindSubConnection(const TDesC& aSubConnectionName)
    {
    return iSubConns.Find(aSubConnectionName);
    }

TInt CCEsockTestBase::CreateSubConnection(const TDesC& aSubConnectionName)
	{
    //check if this sub connection hasn't been created already
    if (iSubConns.Find(aSubConnectionName)!=NULL)
    	return KErrAlreadyExists;

    RSubConnection* sc = new RSubConnection;
    if (sc==NULL)
    	return KErrNoMemory;

	TInt error = iSubConns.Add(sc,aSubConnectionName);
	if (error!=KErrNone)
		delete sc;

	return error;
	}

TInt CCEsockTestBase::OpenSubConnection(const TRSubConnectionParams& aParams)
	{
    RSocketServ* ss = iSockServs.Find(aParams.iSockServName);
    if (ss==NULL)
		return KErrNotFound;

    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	RConnection* c = iConns.Find(aParams.iConnectionName);
	if (c==NULL)
		return KErrNotFound;

	return sc->Open(*ss, aParams.iSubConnType, *c);
	}

TInt CCEsockTestBase::CloseSubConnection(const TDesC& aSubConnectionName)
	{
    RSubConnection* sc = iSubConns.Find(aSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	sc->Close();
	return KErrNone;
	}

TInt CCEsockTestBase::AddSocketToSubConnection(const TRSubConnectionParams& aParams, TRequestStatus& aStatus)
    {
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s==NULL)
		return KErrNotFound;

	sc->Add(*s,aStatus);
	return KErrNone;
	}

TInt CCEsockTestBase::RemoveSocketFromSubConnection(const TRSubConnectionParams& aParams, TRequestStatus& aStatus)
    {
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

    RSocket* s = iSocks.Find(aParams.iSocketName);
	if (s==NULL)
		return KErrNotFound;

	sc->Remove(*s,aStatus);
	return KErrNone;
    }

TInt CCEsockTestBase::SetSubConnectionParameters(const TRSubConnectionParams& aParams)
	{
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	RSubConParameterBundle* scp = iSubConnParams.Find(aParams.iSubConnectionParamsName);
	if (scp==NULL)
		return KErrNotFound;

	return sc->SetParameters(*scp);
	}

TInt CCEsockTestBase::GetSubConnectionParameters(const TRSubConnectionParams& aParams)
	{
    if (iSubConnParams.Find(aParams.iSubConnectionParamsName)!=NULL)
    	return KErrAlreadyExists;

    RSubConParameterBundle* scp = new RSubConParameterBundle;
    if (scp==NULL)
    	return KErrNoMemory;

	TInt error = iSubConnParams.Add(scp,aParams.iSubConnectionParamsName);
	if (error!=KErrNone)
	    {
		delete scp;
		return error;
	    }

    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
		return KErrNotFound;

	return sc->GetParameters(*scp);
	}

TInt CCEsockTestBase::CompareIntegerValues(const TCompareIntegersParams& aParams, TInt& aDifference)
	{
    TInt* value1;
    value1 = iIntegerValues.Find(aParams.iValue1);
    if(value1 == NULL)
    	{
		return KErrNotFound;
		}

    TInt* value2;
    value2 = iIntegerValues.Find(aParams.iValue2);
	if (value2 == NULL)
    	{
		return KErrNotFound;
		}

	// Confirm the values
	aDifference = (*value1 - *value2 + aParams.iDifference);
	return KErrNone;
	}

TInt CCEsockTestBase::AwaitRequestStatus(const TDesC& aStatusName)
	{
    TRequestStatus* req = iRequestStatuses.Find(aStatusName);
    ASSERT(req);
   	User::WaitForRequest(*req);
   	return req->Int();
	}

//
//subconnection parameters
TInt CCEsockTestBase::CreateRSubConnectionParams(const TDesC& aSubConParamsName)
	{
	RSubConParameterBundle* scp = new RSubConParameterBundle;
    if (scp==NULL)
    	return KErrNoMemory;

	TInt error = iSubConnParams.Add(scp,aSubConParamsName);
	if (error!=KErrNone)
		delete scp;

	return error;
	}
// SBLP functions

TInt CCEsockTestBase::CreateTFlowId(const TDesC& aFlowIdName)
	{
	TFlowId* fid = new TFlowId;
	if (fid==NULL)
    	return KErrNoMemory;

	TInt error = iFlowId.Add(fid,aFlowIdName);
	if (error!=KErrNone)
		delete fid;

	return error;

	}

TFlowId* CCEsockTestBase::FindTFlowId(const TDesC& aFlowId)
	{
		return iFlowId.Find(aFlowId);
	}

TInt CCEsockTestBase::CloseRSubConnectionParams(const TDesC& aSubConParamsName)
	{
	RSubConParameterBundle* scp = iSubConnParams.Find(aSubConParamsName);
	if (scp==NULL)
		return KErrNotFound;

	scp->Close();
	return KErrNone;
	}


RSubConParameterBundle* CCEsockTestBase::FindRSubConnectionParams(const TDesC& aSubConParamsName)
	{
		return iSubConnParams.Find(aSubConParamsName);
	}

CSubConParameterFamily* CCEsockTestBase::FindRSubConnectionParameterFamily(const TDesC& aSubConParamsName, const TInt aFamilyId)
    {
    RSubConParameterBundle* bundle = FindRSubConnectionParams(aSubConParamsName);
    if (bundle==NULL)
        return NULL;

    return bundle->FindFamily(aFamilyId);
    }

//
//subconnection events
//(each event notification request is encapsulated in a "EventContainer" that can easily be stored in a map.)

TInt CCEsockTestBase::RegisterForRSubConnectionEvent(const TEventContainerParams& aParams)
    {
    TEsockTestEventContainer* ec = iSubConnEvents.Find(aParams.iEventName);
	if (ec==NULL)
	    {
    	ec = new TEsockTestEventContainer;
        if (ec==NULL)
    	    return KErrNoMemory;

    	TInt error = iSubConnEvents.Add(ec,aParams.iEventName);
	    if (error!=KErrNone)
	        {
		    delete ec;
		    return error;
	        }
	    }

    __ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 2));
    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
	if (sc==NULL)
	    {
		return KErrNotFound;
	    }

	//check if we should simply register for all event
	if (aParams.iAllEvents)
	    {
        sc->EventNotification(static_cast<TNotificationEventBuf&>(ec->iEventNotifBuf), EFalse, ec->iEventReceived);
	    return KErrNone;
	    }

	//no.. what about only generic ones?
	if (aParams.iGenericEvents)
	    {
        sc->EventNotification(static_cast<TNotificationEventBuf&>(ec->iEventNotifBuf), ETrue, ec->iEventReceived);
	    return KErrNone;
	    }

	//no.. reqister for specific events
    if (aParams.iEventMask == 0)
        return KErrArgument;

    (ec->iSubconnEventFilter).iEventGroupUid = KSubConnGenericEventsImplUid;
    (ec->iSubconnEventFilter).iEventMask = aParams.iEventMask;
    sc->EventNotification(static_cast<TNotificationEventBuf&>(ec->iEventNotifBuf), &(ec->iSubconnEventFilter), 1, ec->iEventReceived);
    return KErrNone;
    }

TInt CCEsockTestBase::ReceiveRSubConnectionEvent(TNotificationEventBuf*& aBufferPtr, const TDesC& aSubConEventName)
    {
    TEsockTestEventContainer* ec = iSubConnEvents.Find(aSubConEventName);
	if (ec==NULL)
		return KErrNotFound;

    User::WaitForRequest(ec->iEventReceived);
    aBufferPtr = (ec->iEventReceived.Int()==KErrNone)? &static_cast<TNotificationEventBuf&>(ec->iEventNotifBuf) : NULL;
    __ASSERT_DEBUG(aBufferPtr->GroupId(), User::Panic(KSpecAssert_ESockTestEsckTst, 3));
    return ec->iEventReceived.Int();
    }

//
//mobility notifications
//(each notification request is encapsulated in a "EventContainer" that can easily be stored in a map.)

TInt CCEsockTestBase::RegisterForMobilityNotification(const TEventContainerParams& aParams)
    {
    TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName);
	if (ec==NULL)
	    {
    	ec = new TEsockTestEventContainer;
        if (ec==NULL)
    	    return KErrNoMemory;

    	TInt error = iConnEvents.Add(ec,aParams.iEventName);
	    if (error!=KErrNone)
	        {
		    delete ec;
		    return error;
	        }
	    }

    RCommsMobilityApiExt* me = iMobilityExts.Find(aParams.iMobilityExtName);
	if (me==NULL)
	    {
		return KErrNotFound;
	    }

	//reqister
    __ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 4));
	me->RegisterForMobilityNotification(ec->iEventNotifBuf,ec->iEventReceived);

    return KErrNone;
    }

TInt CCEsockTestBase::ReceiveMobilityNotification(TDesC8*& aBufferPtr, const TEventContainerParams& aParams)
    {
    TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName);
	if (ec==NULL)
		return KErrNotFound;

    RCommsMobilityApiExt* me = iMobilityExts.Find(aParams.iMobilityExtName);
	if (me==NULL)
		return KErrNotFound;

	if (aParams.iTimeoutMiliSecs!=0)
		{
		TRequestStatus timeoutStatus;
		RTimer timer;
		timer.CreateLocal();
		timer.After(timeoutStatus,aParams.iTimeoutMiliSecs*1000);
    	User::WaitForRequest(ec->iEventReceived,timeoutStatus);
    	timer.Cancel();
    	timer.Close();
    	if (ec->iEventReceived==KRequestPending)
    		{
    		me->CancelMobilityNotification();
    		}
    	}
    else
    	{
    	User::WaitForRequest(ec->iEventReceived);
    	
    	}

    aBufferPtr = (ec->iEventReceived.Int()==KErrNone)? &ec->iEventNotifBuf : NULL;
    return ec->iEventReceived.Int();
    }



//
//cleanup

void CCEsockTestBase::CleanAll()
	{
    iSockServs.ResetAndDestroy();
    iSocks.ResetAndDestroy();
	iConns.ResetAndDestroy();
	iSubConns.ResetAndDestroy();
	iConnectionServs.ResetAndDestroy();
	iMobilityExts.ResetAndDestroy();
	iDataMonitoringExts.ResetAndDestroy();
	iDataMonitoringEvents.ResetAndDestroy();
	iNotifWatchers.ResetAndDestroy();
    TInt i = 0;
    for (i = 0; i < iSubConnParams.Count(); i++)
        {
        iSubConnParams[i]->Close();
        }
	iSubConnParams.ResetAndDestroy();
	iSubConnEvents.ResetAndDestroy();
	iConnEvents.ResetAndDestroy();
	iFlowId.ResetAndDestroy();
	iIntegerValues.ResetAndDestroy();
	iRequestStatuses.ResetAndDestroy();
	}

//
//general utils


//
// Simtsy Trigger Event functionality

/**
 Instructs the simtsy to complete a given request/notification. The supported commands are given in TEtelRequestType.
 The parameter supplied in aNewValue instructs the simtsy what data from the config.txt to use in the completion of the request.
 The aNewValue is the index to the entry to be used to complete the request for the current test step section, ie if aNewValue
 is 0, iTestNumber is 3, and aEtelCommand is ENetworkQoSChange, the entry will complete any NotifyNetworkQoSChange calls
 with data from the first QosNetworkNotification= entry of section [test3] in the config.txt file
*/


TInt CCEsockTestBase::EtelRequestL(TUint aEventKey, TInt aNewValue)
	{
  	// simtsy will listen for any changes to the property, and complete the corresponding request
	TInt error = RProperty::Set(KUidPSSimTsyCategory, aEventKey, aNewValue);

	return error;
	}


//



//
//simtsy functionality

TInt TSimTsy::Start()
    {
    //define name of the Phone module to be used for the RTelServer
    _LIT(KMtsyName, "SIM");
    TInt res = StartC32();
    if (res!=KErrNone)
            return res;
    TInt error = iServer.Connect();
    if (error!=KErrNone)
            return error;
    error = iServer.LoadPhoneModule(KMtsyName);
   	if (error!=KErrNone)
            return error;
   	error = iPhone.Open(iServer, KPhoneName);
    if (error!=KErrNone)
            return error;
    error = SetTestNumber(0);
	return error;
    }


void TSimTsy::Stop()
    {
    iPhone.Close();
    iServer.Close();
    }


TInt TSimTsy::SetTestNumber(TInt aTestSectionNumber)
	{
   	return RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyTestNumber, aTestSectionNumber);
	}

//

