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

//

#if !defined(__PDUMMY_H__)

#define __PDUMMY_H__

#include <comms-infras/nifif_internal.h>

#include "ES_DUMMY.H"

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

NONSHARABLE_CLASS(CDProtocolFamily): public CProtocolFamilyBase

	{

public:

	static CDProtocolFamily * NewL();

	void ConstructL();

	TInt Install();

	TInt Remove();

	CProtocolBase * NewProtocolL(TUint aSockType,TUint aProtocol);

	TUint ProtocolList(TServerProtocolDesc *& aProtocolList);

	CDProtocolFamily();

private:

	void Construct();

private:

	TServerProtocolDesc iProtocolDescs[5];

	};

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

NONSHARABLE_CLASS(CDummyProtocol): public CProtocolBase

	{

public:

	IMPORT_C static CDummyProtocol *NewL(TInt aProtocol, TServerProtocolDesc* aProtoDesc);

	IMPORT_C TInt ProtocolBaseBind(CProtocolBase* aProt, TUint aId);

	IMPORT_C TInt ProtocolBaseBindTo(CProtocolBase* aProt);

	IMPORT_C TInt ProtocolBaseError(CProtocolBase* aProt);

	IMPORT_C TInt ProtocolBaseGetOption(TUint aLevel, TUint aName, TDes8& aBuf, CProtocolBase* aProt);

	IMPORT_C TInt ProtocolBaseNewHostResolver();

	IMPORT_C TInt ProtocolBaseNewNetDatabase();

	IMPORT_C TInt ProtocolBaseNewSAP(TUint aProt);

	IMPORT_C TInt ProtocolBaseNewServiceResolver();

	IMPORT_C TInt ProtocolBaseProcess(RMBufChain &aChain, CProtocolBase* aProt);		

	IMPORT_C TInt ProtocolBaseSend(RMBufChain &aChain, CProtocolBase* aProt);

	IMPORT_C TInt ProtocolBaseSetOption(TUint aLevel, TUint aName, TDes8& aBuf, CProtocolBase* aProt);

	IMPORT_C TInt ProtocolBaseSendWithAddress(TDes8& aBuf,TSockAddr* aTo,TSockAddr* aFrom, CProtocolBase* aProt);

	IMPORT_C TInt ProtocolBaseProcessWithAddress(TDes8& aPDU, TSockAddr* aFrom, TSockAddr* aTo, CProtocolBase* aProt);

	IMPORT_C CDummyProtocol(TServerProtocolDesc* aProtoDesc);

	IMPORT_C ~CDummyProtocol();

public:

	CServProviderBase *NewSAPL(TUint aProtocol);

	virtual CHostResolvProvdBase *NewHostResolverL();

	virtual CServiceResolvProvdBase *NewServiceResolverL();

	virtual CNetDBProvdBase* NewNetDatabaseL();

	TBool CanCreateSockets();

	void InitL(TDesC& aTag);

	void BindL(CProtocolBase *aProtocol, TUint anId);

	virtual void BindToL(CProtocolBase *protocol);

	void StartL(void);

	TInt Send(RMBufChain &,CProtocolBase* aSourceProtocol);

	void Process(RMBufChain &,CProtocolBase* aSourceProtocol);

	TInt Send(TDes8 &, TSockAddr *to,TSockAddr *from,CProtocolBase* aSourceProtocol);

	void Process(TDes8 & ,TSockAddr *from,TSockAddr *to,CProtocolBase* aSourceProtocol);

	void Identify(TServerProtocolDesc *)const;

	TInt GetOption(TUint level,TUint name,TDes8 &anOption,CProtocolBase* aSourceProtocol);

	TInt SetOption(TUint level,TUint name,const TDesC8& option,CProtocolBase* aSourceProtocol);

	void Error(TInt anError,CProtocolBase* aSourceProtocol);

	TBool IsStarted(){return iIsStarted;}	

protected:

	TInt iType;

	TServerProtocolDesc* iProtoDesc;

	TBool iIsStarted;

	CArrayFixFlat<CProtocolBase *> iProtocols;

	};

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

class CInterfaceProtocol;

NONSHARABLE_CLASS(CIfHolder) : public CBase

	{

public:

	CIfHolder(CInterfaceProtocol&);

	~CIfHolder();

	TDblQueLink iLink;

	CNifIfBase *iIf;

	};

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

NONSHARABLE_CLASS(CInterfaceProtocol) : public CDummyProtocol, public MNifIfUser

	{

friend class CIfHolder;

public:

	CInterfaceProtocol(TServerProtocolDesc* aProtoDesc);

	~CInterfaceProtocol();

	virtual TInt GetOption(TUint level,TUint name,TDes8 &anOption,CProtocolBase* aSourceProtocol);

	virtual void IfUserBindFailure(TInt aResult, TAny* aId);

	virtual void IfUserNewInterfaceL(CNifIfBase* aIf, TAny* aId);

	virtual void IfUserInterfaceDown(TInt aResult, CNifIfBase* aIf);

	virtual CProtocolBase* IfUserProtocol();

	virtual void IfUserOpenNetworkLayer();

	virtual void IfUserCloseNetworkLayer();

	virtual TBool IfUserIsNetworkLayerActive();

	virtual void Close();

	void StartAutoInterfaceL();

private:

	TDblQue<CIfHolder> iInterfaces;

	TName iInterfaceName;

	TInt iInterfaceCount;

	};

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

class CAsyncSocketErrorer;

NONSHARABLE_CLASS(CDummyProvd) : public CServProviderBase

	{

public:

	~CDummyProvd();

	static CDummyProvd *NewL(CDummyProtocol &aProtocol);

	virtual void LocalName(TSockAddr &anAddr)const;

	virtual TInt SetLocalName(TSockAddr &anAddr);

	virtual void RemName(TSockAddr &anAddr)const;

	virtual TInt SetRemName(TSockAddr &anAddr);

	virtual TInt GetOption(TUint level,TUint name,TDes8 &anOption)const;

	virtual TInt SetOption(TUint level,TUint name,const TDesC8 &anOption);

	virtual void Ioctl(TUint level,TUint name,TDes8 *anOption);

	virtual void CancelIoctl(TUint aLevel,TUint aName);

	virtual TInt Write(RMBufChain& aData, TUint options, TSockAddr* anAddr=NULL);

	virtual TUint Write(const TDesC8& aDesc, TUint options, TSockAddr* anAddr);

	virtual TInt GetData(RMBufChain& aData, TUint aLength, TUint options,TSockAddr* anAddr=NULL);

	virtual void GetData(TDes8& aDesc,TUint aOptions,TSockAddr*aAddr = NULL);

	virtual void ActiveOpen(void);

	virtual void ActiveOpen(const TDesC8 &aConnectionData);

	virtual TInt PassiveOpen(TUint aQue);

	virtual TInt PassiveOpen(TUint aQue,const TDesC8 &aConnectionData);

	virtual void AutoBind( void );

	virtual void Shutdown(TCloseType option);

	virtual void Shutdown(TCloseType option,const TDesC8 &aDisconnectData);

	virtual void Start();

	virtual	TInt SecurityCheck(MProvdSecurityChecker *aSecurityChecker);

	void DestroyAsyncErrorer();

private:

	class CFlowOnTimer;

	friend class CDummyProvd::CFlowOnTimer;

    static TInt NoBearerCB(TAny* aArg);

	void ConstructL();

	TBool IsTransportType(TUint aType);

	CDummyProvd(CDummyProtocol &aProtocol);

	void HangModule(void);

	TInt SetBlockedConnect(const TDesC8 &aOption);

	TInt OptToErr(const TDesC8 &aOption, TInt &aRes);

	TInt GobbleMBufs();

	void FreeMBufs();

	void FreeMBufs(TUint aNumber);

private:

	CArrayFixFlat<RMBufChain>* iDataArray;

	TBool iIsBound;

	CDummyProtocol *iProtocol;

	TSockAddr iAddr;

	CAsyncSocketErrorer* iAsyncErrorer;

	TBool iInputStopped;

	TInt iListenErrorCode;

	TBool iCancelIoctl; // Set when an IOCTL has been cancelled.

	TBool iBlockOnClose; //Used by and test Ioctl to cause the socket to hang on close

	TBool iCompleteIoctl;

	TBool iConnectCompleteState; //Whether connects should be completes or not;

	TBool iConnectPending; //Whether a connect is awaiting completion; 

	RBuf8 iListenData;

	TInt iErrorForNextWrite; //Whether write should send an error if == KErrNone the operates normally

	TInt iErrorForNextShutdown; //Whether write should send an error if == KErrNone the operates normally

	TInt iErrorForNextConnect; //Whether write should send an error if == KErrNone the operates normally

	TBool iFlowOffWrite;

	TInt iFlowOffWriteTimeout;

	CFlowOnTimer* iFlowOnTimer;

	RMBufChain iChain;

	TBool iErrNoMBufs;

	CAsyncCallBack iNoBearerCB;

	};

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

class CDNSQueryProcessor;

NONSHARABLE_CLASS(CDatagramHostResolver): public CHostResolvProvdBase

	{

private:

	CDatagramHostResolver();

public:

	static CDatagramHostResolver* NewL();

	void   ConstructL();

           ~CDatagramHostResolver();

    virtual void GetByName(TNameRecord &iName);

	virtual void GetByAddress(TNameRecord &iName);

	virtual void SetHostName(TDes &aNameBuf);

	virtual void GetHostName(TDes &aNameBuf);

	virtual TInt SetOption(TUint level,TUint name,const TDesC8 &anOption);

	virtual void CancelCurrentOperation();

    virtual void Query(const TDesC8& aQryBuf, TDes8& aResBuf, TInt aCounter);

	virtual	TInt SecurityCheck(MProvdSecurityChecker *aSecurityChecker);

private:

    CDNSQueryProcessor*  ipDNSQueryProcessor; //< simulates DNS queries processing

    };

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

NONSHARABLE_CLASS(CDatagramServResolver) : public CServiceResolvProvdBase

	{

private:

	CDatagramServResolver();

public:

	static  CDatagramServResolver* NewL();

	virtual void GetByName(const TDesC &aNameBuf,TInt32 &aPortNum);

	virtual void GetByNumber(TDes &aNameBuf,TInt32 aPortNum);

	virtual void RegisterService(const TDesC &aNameBuf,TInt32 aPortNum);

	virtual void RemoveService(const TDesC &aNameBuf,TInt32 aPortNum);

	virtual void CancelCurrentOperation();

	virtual	TInt SecurityCheck(MProvdSecurityChecker *aSecurityChecker);

	};

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

NONSHARABLE_CLASS(CDatagramNetDataBase) : public  CNetDBProvdBase

	{

public:

	virtual void Query(TDes8& aBuffer);

	virtual void Add(TDes8& aBuffer);

	virtual void Remove(TDes8& aBuffer);

	virtual void CancelCurrentOperation();

	static CDatagramNetDataBase* NewL();

	virtual	TInt SecurityCheck(MProvdSecurityChecker *aSecurityChecker);

private:

	CDatagramNetDataBase();

	TInt iCount;

	};

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

NONSHARABLE_CLASS(CAsyncSocketErrorer) : public CActive

	{

public:

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

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

	~CAsyncSocketErrorer();

private:

	CAsyncSocketErrorer(MSocketNotify& aSocket,TInt aErrorCode,TUint aOpMask,CDummyProtocol * apProtocols, CDummyProvd* aOwner, const TDesC8* aListenData = NULL);

	void RunL();

	void DoCancel();

	MSocketNotify& iSocket;

	TInt iErrorCode;

	TUint iOpMask;

    CDummyProtocol* ipProtocols;

	CDummyProvd* iOwner;

	const TDesC8* iListenData;

	};

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

/**

* This class simulates DNS query processing.

* It checks incoming query data, forges DNS query responses

* and simulates processing by generating random delays.

* @see CDatagramHostResolver

*/

NONSHARABLE_CLASS(CDNSQueryProcessor) : public CActive

{

public:

   static   CDNSQueryProcessor* NewL(); 

           ~CDNSQueryProcessor();

    void    SetNotifier(MResolverNotify *aNotifier) {iDnsNotifier = aNotifier;}

    void    ProcessQuery(const TDnsQuery& aQry, TDes8& aResBuf, TInt aCounter);

private:    

    CDNSQueryProcessor();

    void    RunL();

    void    DoCancel();

    void    ConstructL(void);

    void    CompleteImmediately();

    void    CompleteImmediately(TInt aResultCode);

    void    SetQryProcessDelay();

    void    SetCompletionCode(TInt aResultCode) {iCompleteResult = aResultCode;}

    //-- queries processors

    void    QryProcessA     (const TDnsQuery& aQry, TDnsRespA&      aQryResult, TInt aCounter);

    void    QryProcessSRV   (const TDnsQuery& aQry, TDnsRespSRV&    aQryResult, TInt aCounter);

    void    QryProcessPTR   (const TDnsQuery& aQry, TDnsRespPTR&    aQryResult, TInt aCounter);

    void    QryProcessNAPTR (const TDnsQuery& aQry, TDnsRespNAPTR&  aQryResult, TInt aCounter);

    void    QryProcessMX    (const TDnsQuery& aQry, TDnsRespMX&     aQryResult, TInt aCounter);

    void    QryProcessAAAA  (const TDnsQuery& aQry, TDnsRespAAAA&   aQryResult, TInt aCounter);

private:    

    RTimer              iDelayTimer;        //< generates delays simulating queries completion

    MResolverNotify    *iDnsNotifier;       //< notifier, QueryComplete will be called  

    TInt                iCompleteResult;    //< Query completion result

    TUint16             iCurrQryType;       //< current query type, used by QueryGetNext

    TInt64              iRndSeed;           //< random seed, for delays

};

#endif //__PDUMMY_H__