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