// Copyright (c) 1997-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 <es_prot.h>

#include <e32test.h>

#include "ES_DUMMY.H"

#include <comms-infras/nifif.h>

#include <es_mbuf.h>

#include <ss_std.h>

#include <ss_pman.h>

#include <ss_glob.h>

#include <e32math.h>

#include <dns_qry.h>

#include <agenterrors.h>

#include <e32property.h>

#include <nifman_internal.h>

#include "pdummy.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_ESockTestPDUMMY, "ESockTestPDUMMY.");

#endif

const TInt KPDummyDefaultGranularity=0xA; // Default number of incoming messages the protocol can queue up

//---------------------------------------------------------------------------------------------------------

CAsyncSocketErrorer* CAsyncSocketErrorer::NewL(MSocketNotify& aSocket,TInt aErrorCode,TUint aOpMask,

                                  CDummyProtocol * apProtocols, CDummyProvd* aOwner,const TDesC8* aListenData )

	{

	return new(ELeave) CAsyncSocketErrorer(aSocket, aErrorCode, aOpMask,apProtocols,aOwner,aListenData);

	}

CAsyncSocketErrorer::CAsyncSocketErrorer(MSocketNotify& aSocket, TInt aErrorCode, TUint aOpMask,

		CDummyProtocol* apProtocols, CDummyProvd* aOwner, const TDesC8* aListenData):

    CActive(KMaxTInt),

	iSocket(aSocket),

	iErrorCode(aErrorCode),

	iOpMask(aOpMask),

	ipProtocols(apProtocols),

	iOwner(aOwner),

	iListenData(aListenData)

	{

	CActiveScheduler::Add(this);

	SetActive();

	TRequestStatus* p = &iStatus;

	User::RequestComplete(p, KErrNone);

	}

void CAsyncSocketErrorer::RunL()

	{

	CDummyProvd* p = NULL;

    if ( iErrorCode == KErrNone )

        {

	    TRAP(iErrorCode,p = CDummyProvd::NewL(*ipProtocols););

	    if (iErrorCode)

	    	{

	    	iOpMask = MSocketNotify::EErrorFatal;

	    	}

        }

    if ( iErrorCode == KErrNone )

        {

	    if(iListenData)

	    	{

	    	iSocket.ConnectComplete(*p, *iListenData);

	    	}

	    else

	    	{

	    	iSocket.ConnectComplete(*p);

	    	}

        }

    else

        {

	    iSocket.Error(iErrorCode,iOpMask);

        }

	iOwner->DestroyAsyncErrorer();	// ie "delete this"

	}

CAsyncSocketErrorer::~CAsyncSocketErrorer()

	{

	Cancel();

	}

void CAsyncSocketErrorer::DoCancel()

	{

	}

//---------------------------------------------------------------------------------------------------------

NONSHARABLE_CLASS(CDummyProvd::CFlowOnTimer): public CTimer

	{

public:

	static CFlowOnTimer* NewL(CDummyProvd& aProvd, MSocketNotify& aSocketNotify);

	virtual ~CFlowOnTimer();

	virtual void RunL();

private:

	CFlowOnTimer(CDummyProvd& aProvd, MSocketNotify& aSocket);

	CDummyProvd& iProvd;

	MSocketNotify& iSocketNotify;

	};

CDummyProvd::CFlowOnTimer* CDummyProvd::CFlowOnTimer::NewL(CDummyProvd& aProvd, MSocketNotify& aSocketNotify)

	{

	CFlowOnTimer* self = new(ELeave) CFlowOnTimer(aProvd, aSocketNotify);

	CleanupStack::PushL(self);

	self->ConstructL();

	CActiveScheduler::Add(self);

	CleanupStack::Pop(self);

	return self;

	}

CDummyProvd::CFlowOnTimer::CFlowOnTimer(CDummyProvd& aProvd, MSocketNotify& aSocketNotify)

	: CTimer(CActive::EPriorityStandard), iProvd(aProvd), iSocketNotify(aSocketNotify)

	{

	}

CDummyProvd::CFlowOnTimer::~CFlowOnTimer()

	{

	Cancel();

	}

void CDummyProvd::CFlowOnTimer::RunL()

	{

	iProvd.iFlowOffWriteTimeout = 0;

	iSocketNotify.CanSend();

	}

enum TDPanic

	{

	EBadProtocol,

	EBadCall,

	ENotBound,

	ENotStarted,

	EInterfaceNotDeleted,

	EIdAndNoHolder,

	EIfAndHolder,

	ETestPanic

	};

// RTest test(_L("Dummy protocol"));

LOCAL_C void Panic(TDPanic aPanic)

//

// Panic the Protocol

//

	{

	User::Panic(_L("Dummy Prot"),aPanic);

	}

extern "C"

	{

	IMPORT_C CProtocolFamilyBase* InstallDummy(void);	// Force export

	EXPORT_C CProtocolFamilyBase * InstallDummy(void)

	//

	// Create a new protocol family

	//

		{

		return CDProtocolFamily::NewL();

		}

	}

CDProtocolFamily* CDProtocolFamily::NewL()

//

//

//

	{

	CDProtocolFamily* pf = new (ELeave) CDProtocolFamily();

	CleanupStack::PushL(pf);

	pf->ConstructL();

	CleanupStack::Pop();

	return pf;

	}

void CDProtocolFamily::ConstructL()

//

//

//

	{

	// Force a fail on Memory tests

	char* ptr=new(ELeave) char;

	delete ptr;

	}

CDProtocolFamily::CDProtocolFamily() : CProtocolFamilyBase()

	{

	iProtocolDescs[0].iAddrFamily=KDummyAddrFamily;

	iProtocolDescs[0].iSockType=KSockDatagram;

	iProtocolDescs[0].iProtocol=KDummyOne;

	iProtocolDescs[0].iVersion=TVersion(KDummyMajor,KDummyMinor,KDummyBuild);

	iProtocolDescs[0].iByteOrder=EBigEndian;

	// KSIRequiresOwnerInfo is required to ensure that SetOption(KSoSetPlatSecApi) is issued to

	// TransportFlowShim for NoBearer() testing.

	iProtocolDescs[0].iServiceInfo=kDDatagramServiceInfo|KSIPeekData|KSIRequiresOwnerInfo;

	iProtocolDescs[0].iSecurity=KSocketNoSecurity;

	iProtocolDescs[0].iMessageSize=0x300;

	iProtocolDescs[0].iName=KDummyOneName;

	iProtocolDescs[0].iServiceTypeInfo=ESocketSupport|ECantProcessMBufChains;

	iProtocolDescs[0].iNamingServices=KNSNameResolution|KNSServiceResolution|KNSInfoDatabase;

	iProtocolDescs[0].iNumSockets=100;

	iProtocolDescs[1].iAddrFamily=KDummyAddrFamily;

	iProtocolDescs[1].iSockType=KSockStream;

	iProtocolDescs[1].iProtocol=KDummyTwo;

	iProtocolDescs[1].iVersion=TVersion(KDummyMajor,KDummyMinor,KDummyBuild);

	iProtocolDescs[1].iByteOrder=EBigEndian;

	iProtocolDescs[1].iServiceInfo=KDStreamServiceInfo;

	iProtocolDescs[1].iSecurity=KSocketNoSecurity;

	iProtocolDescs[1].iMessageSize=KSocketMessageSizeIsStream;

	iProtocolDescs[1].iName=KDummyTwoName;

	iProtocolDescs[1].iServiceTypeInfo=ESocketSupport|ECantProcessMBufChains;

	iProtocolDescs[1].iNamingServices=0;

	iProtocolDescs[1].iNumSockets=100;

	iProtocolDescs[2].iAddrFamily=KDummyAddrFamily;

	iProtocolDescs[2].iSockType=KSockSeqPacket;

	iProtocolDescs[2].iProtocol=KDummyThree;

	iProtocolDescs[2].iVersion=TVersion(KDummyMajor,KDummyMinor,KDummyBuild);

	iProtocolDescs[2].iByteOrder=EBigEndian;

	iProtocolDescs[2].iServiceInfo=KSIReliable|KSIInOrder|KSIDatagram|KSIGracefulClose|KSIBroadcast|KSIQOS|KSICanReconnect|KSIConnectData|KSIDisconnectData;

	iProtocolDescs[2].iSecurity=KSocketNoSecurity;

	iProtocolDescs[2].iMessageSize=KSocketMessageSizeNoLimit;

	iProtocolDescs[2].iName=KDummyThreeName;

	iProtocolDescs[2].iServiceTypeInfo=ESocketSupport|ECantProcessMBufChains|ETransport|EPreferDescriptors|EUseCanSend;

	iProtocolDescs[2].iNamingServices=0;

	iProtocolDescs[2].iNumSockets=100;

	iProtocolDescs[3].iAddrFamily=KDummyAddrFamily;

	iProtocolDescs[3].iSockType=KSockStream;

	iProtocolDescs[3].iProtocol=KDummyFour;

	iProtocolDescs[3].iVersion=TVersion(KDummyMajor,KDummyMinor,KDummyBuild);

	iProtocolDescs[3].iByteOrder=EBigEndian;

	iProtocolDescs[3].iServiceInfo=KDStreamServiceInfo;

	iProtocolDescs[3].iSecurity=KSocketNoSecurity;

	iProtocolDescs[3].iMessageSize=KSocketMessageSizeIsStream;

	iProtocolDescs[3].iName=KDummyFourName;

	iProtocolDescs[3].iServiceTypeInfo=ESocketSupport|ENeedMBufs;

	iProtocolDescs[3].iNamingServices=0;

	iProtocolDescs[3].iNumSockets=100;

	iProtocolDescs[4].iAddrFamily=KDummyAddrFamily;

	iProtocolDescs[4].iSockType=KSockDatagram;

	iProtocolDescs[4].iProtocol=KDummyFive;

	iProtocolDescs[4].iVersion=TVersion(KDummyMajor,KDummyMinor,KDummyBuild);

	iProtocolDescs[4].iByteOrder=EBigEndian;

	iProtocolDescs[4].iServiceInfo=kDDatagramServiceInfo|KSIPeekData;

	iProtocolDescs[4].iSecurity=KSocketNoSecurity;

	iProtocolDescs[4].iMessageSize=KSocketMessageSizeNoLimit;

	iProtocolDescs[4].iName=KDummyFiveName;

	iProtocolDescs[4].iServiceTypeInfo=ESocketSupport|ECantProcessMBufChains;

	iProtocolDescs[4].iNamingServices=KNSNameResolution|KNSServiceResolution|KNSInfoDatabase;

	iProtocolDescs[4].iNumSockets=100;

	__DECLARE_NAME(_S("CDProtocolFamily"));

	}

#pragma warning( disable : 4100 )

TInt CDProtocolFamily::Install()

	{

	// Force a fail on Memory tests

	char* ptr=new char;

	if (!ptr)

		return KErrNoMemory;

	delete ptr;

	return KErrNone;

	}

TInt CDProtocolFamily::Remove()

	{

	return KErrNone;

	}

TUint CDProtocolFamily::ProtocolList(TServerProtocolDesc *& aProtocolDescPointer)

	{

  	aProtocolDescPointer=new TServerProtocolDesc[KPDummyNumProtocols];

  	if (!aProtocolDescPointer)

  		return 0;

	Mem::Copy(aProtocolDescPointer, iProtocolDescs, sizeof(TServerProtocolDesc)*KPDummyNumProtocols);

	TRAP_IGNORE(Nif::CheckInstalledMBufManagerL();)

	return KPDummyNumProtocols;

	};

CProtocolBase * CDProtocolFamily::NewProtocolL(TUint /* aSockType */,TUint aProtocol)

	{

	CDummyProtocol* p=CDummyProtocol::NewL(aProtocol, &iProtocolDescs[aProtocol-1]);

	return p;

	}

//---------------------------------------------------------------------------------------------------------

CServProviderBase * CDummyProtocol::NewSAPL(TUint /*aProtocol*/)

	{

	return CDummyProvd::NewL(*this);

	}

CHostResolvProvdBase* CDummyProtocol::NewHostResolverL()

	{

	return CDatagramHostResolver::NewL();

	}

CServiceResolvProvdBase* CDummyProtocol::NewServiceResolverL()

	{

	return CDatagramServResolver::NewL();

	}

CNetDBProvdBase* CDummyProtocol::NewNetDatabaseL()

	{

	return CDatagramNetDataBase::NewL();

	}

CDummyProtocol::~CDummyProtocol()

	{

	for (TInt i=0;i<iProtocols.Count();i++)

		{

		iProtocols[i]->Close();

		}

	}

void CDummyProtocol::InitL(TDesC& /*aTag*/)

	{

	// Force a fail on Memory tests

	char* ptr=new(ELeave) char;

	delete ptr;

	}

void CDummyProtocol::BindL(CProtocolBase* /*aProtocol*/, TUint /*anId*/)

	{

	// Force a fail on Memory tests

	char* ptr=new(ELeave) char;

	delete ptr;

	}

void CDummyProtocol::BindToL(CProtocolBase* aProtocol)

	{

	// Force a fail on Memory tests

	char* ptr=new(ELeave) char;

	delete ptr;

	iProtocols.AppendL(aProtocol);

	aProtocol->Open();

	}

void CDummyProtocol::StartL(void)

	{

	// Force a fail on Memory tests

	char* ptr=new(ELeave) char;

	delete ptr;

	iIsStarted=ETrue;

	}

TInt CDummyProtocol::Send(RMBufChain &,CProtocolBase* /*aSourceProtocol*/)

	{

	return 1;

	}

TInt CDummyProtocol::Send(TDes8 &, TSockAddr* /*to*/,TSockAddr* /*from*/,CProtocolBase* /*aSourceProtocol*/)

	{

	return 1;

	}

void CDummyProtocol::Process(RMBufChain &,CProtocolBase* /*aSourceProtocol*/)

	{

	}

void CDummyProtocol::Process(TDes8 & ,TSockAddr* /*from*/,TSockAddr* /*to*/,CProtocolBase* /*aSourceProtocol*/)

	{

	}

void CDummyProtocol::Identify(TServerProtocolDesc *aDesc) const

	{

	Mem::Copy(aDesc, iProtoDesc, sizeof(TServerProtocolDesc));

	}

TInt CDummyProtocol::GetOption(TUint level,TUint,TDes8&,CProtocolBase* /*aSourceProtocol*/)

	{

	if(level==KNifOptLevel)

		{

		return KErrNotSupported;

		}

	return KErrNone;

	}

TInt CDummyProtocol::SetOption(TUint /*level*/,TUint /*name*/,const TDesC8& /*option*/,CProtocolBase* /*aSourceProtocol*/)

	{

	return KErrNone;

	}

void CDummyProtocol::Error(TInt /*anerror*/,CProtocolBase* /*aSourceProtocol*/)

	{

	}

EXPORT_C CDummyProtocol *CDummyProtocol::NewL(TInt aType, TServerProtocolDesc* aProtoDesc)

	{

	CDummyProtocol* p=0;

	switch (aType)

		{

	case KDummyOne:

	case KDummyTwo:

	case KDummyFive:

		p=new (ELeave) CDummyProtocol(aProtoDesc);

		break;

	case KDummyThree:

	case KDummyFour:

		p=new (ELeave) CInterfaceProtocol(aProtoDesc);

		break;

	default:

		p=(CDummyProtocol*)0xABCD; // keep lint happy

		Panic(EBadProtocol);

		}

	p->iType=aType;

	return p;

	}

EXPORT_C CDummyProtocol::CDummyProtocol(TServerProtocolDesc* aProtoDesc)

	:CProtocolBase(),iProtoDesc(aProtoDesc),iProtocols(0x16)

	{

	__DECLARE_NAME(_S("CDummyProtocol"));

	iIsStarted=EFalse;

	}

/* exported functions that are used to exercise ProtocolBase functionality

*/

EXPORT_C TInt CDummyProtocol::ProtocolBaseBind(CProtocolBase* aProt, TUint aId)

	// expected to Panic(EDoesNotBindBelow);

	{

	TRAPD(ret, CProtocolBase::BindL(aProt, aId));

	return ret;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseBindTo(CProtocolBase* aProt)

	// expected to Panic(EDoesNotBindAbove);

	{

	TRAPD(ret, CProtocolBase::BindToL(aProt));

	return ret;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseError(CProtocolBase* aProt)

	// expected to Panic(EErrorCallNotHandled)

	{

	CProtocolBase::Error(KErrNone, aProt);

	return KErrNone;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseGetOption(TUint aLevel, TUint aName, TDes8& aBuf, CProtocolBase* aProt)

	{

	// expected to return KErrNotSupported

	TInt ret = CProtocolBase::GetOption(aLevel,aName,aBuf,aProt);

	__ASSERT_DEBUG(ret == KErrNotSupported, User::Panic(KSpecAssert_ESockTestPDUMMY, 1));

	return ret;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseNewHostResolver()

	// expected to panic with Fault(EBadHostResolver);

	{

	TRAPD(ret, CProtocolBase::NewHostResolverL());

	return ret;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseNewNetDatabase()

	// expected to panic with Fault(EBadNetDBRequest)

	{

	TRAPD(ret, CProtocolBase::NewNetDatabaseL());

	return ret;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseNewSAP(TUint aProt)

	// expected to panic with Fault(EOddSock)

	{

	TRAPD(ret, CProtocolBase::NewSAPL(aProt));

	return ret;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseNewServiceResolver()

	// expected to panic with Fault(EBadServiceResolver)

	{

	TRAPD(ret, CProtocolBase::NewServiceResolverL());

	return ret;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseProcess(RMBufChain &aChain, CProtocolBase* aProt)

	// expected to panic with Panic(ECantProcessMbufs)

	{

	CProtocolBase::Process(aChain, aProt);

	return KErrNone;

	}

EXPORT_C TInt CDummyProtocol::ProtocolBaseSend(RMBufChain &aChain, CProtocolBase* aProt)