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

// Dummy nifman agent

//

//

#include <comms-infras/nifagt.h>

#include <cdbcols.h>

#include <nifutl.h>

#include "tnifprog.h"

#include <test/es_dummy.h>

class CSimpleAgentFactory : public CNifAgentFactory

	{

protected:

	virtual void InstallL();

	virtual CNifAgentBase *NewAgentL(const TDesC& aName);

	virtual TInt Info(TNifAgentInfo& aInfo, TInt aIndex) const;

	};

class CSimpleAgent : public CNifAgentBase, public MTimer

	{

public:

	CSimpleAgent();

	~CSimpleAgent();

	void ConstructL();

	virtual TInt Control(TUint aOptionLevel, TUint aOptionName, TDes8& aOption);

	virtual void TimerComplete(TInt aStatus);

	virtual void Connect(TAgentConnectType aType);

	virtual void Connect(TAgentConnectType aType, CStoreableOverrideSettings* aOverrideSettings);

	virtual void CancelConnect();

	virtual void Reconnect();

	virtual void CancelReconnect();

	virtual void Authenticate(TDes& aUsername, TDes& aPassword);

	virtual void CancelAuthenticate();

	virtual void Disconnect(TInt aReason);

	virtual TInt GetExcessData(TDes8& aBuffer);

	virtual TInt Notification(TNifToAgentEventType aEvent, TAny* aInfo);

	virtual TInt IncomingConnectionReceived();

	virtual void GetLastError(TInt& aError);

	virtual TBool IsActive() const;

	virtual TBool IsReconnect() const;

	virtual void SetConnectionSettingsL(const TConnectionSettings& aSettings);

	virtual TConnectionSettings& ConnectionSettingsL();

	virtual void SetOverridesL(CStoreableOverrideSettings* aOverrideSettings);

	virtual CStoreableOverrideSettings* OverridesL();

	virtual void RequestNotificationOfServiceChangeL(MAgentSessionNotify* aSession);

	virtual void CancelRequestNotificationOfServiceChange(MAgentSessionNotify* aSession);

	virtual void Info(TNifAgentInfo& aInfo) const;

	static void FillInInfo(TNifAgentInfo& aInfo);

protected:

	virtual TInt DoReadInt(const TDesC& aField, TUint32& aValue,const RMessagePtr2* aMessage);

	virtual TInt DoWriteInt(const TDesC& aField, TUint32 aValue,const RMessagePtr2* aMessage);

	virtual TInt DoReadDes(const TDesC& aField, TDes8& aValue,const RMessagePtr2* aMessage);

	virtual TInt DoReadDes(const TDesC& aField, TDes16& aValue,const RMessagePtr2* aMessage);

	virtual TInt DoWriteDes(const TDesC& aField, const TDesC8& aValue,const RMessagePtr2* aMessage);

	virtual TInt DoWriteDes(const TDesC& aField, const TDesC16& aValue,const RMessagePtr2* aMessage);

	virtual TInt DoReadBool(const TDesC& aField, TBool& aValue,const RMessagePtr2* aMessage);

	virtual TInt DoWriteBool(const TDesC& aField, TBool aValue,const RMessagePtr2* aMessage);

	virtual HBufC* DoReadLongDesLC(const TDesC& aField,const RMessagePtr2* aMessage);

public:

	enum TState

		{

		EIdle,

		EConnecting,

		EAwaitingDisconnect,

		EDisconnecting

		};

	TUint32 iTestNo;

	TState iState;

	TAgentConnectType iConType;

	TConnectionSettings iSettings;

	};

extern "C"

    {

    IMPORT_C CNifFactory * NewAgentFactoryL(void);	// Force export

	EXPORT_C CNifFactory* NewAgentFactoryL(void)

		{

		return new (ELeave) CSimpleAgentFactory;

		}

	}

CNifAgentBase *CSimpleAgentFactory::NewAgentL(const TDesC& aName)

	{

	(void)aName;

	CSimpleAgent* p = new (ELeave) CSimpleAgent;

	CleanupStack::PushL(p);

	p->ConstructL();

	CleanupStack::Pop();

	return p;

	}

void CSimpleAgentFactory::InstallL()

	{ }

TInt CSimpleAgentFactory::Info(TNifAgentInfo& aInfo, TInt) const

	{

	CSimpleAgent::FillInInfo(aInfo);

	return 1;

	}

CSimpleAgent::CSimpleAgent()

	{ }

CSimpleAgent::~CSimpleAgent()

	{

	TimerDelete();

	}

void CSimpleAgent::Info(TNifAgentInfo& aInfo) const

    {

	FillInInfo(aInfo);

	// ensure that the name of this agent is unique

	aInfo.iName.AppendFormat(_L("[%x]"), this);

	}

void CSimpleAgent::FillInInfo(TNifAgentInfo& aInfo)

	{

	aInfo.iName = _L("testagent");

	aInfo.iVersion = TVersion(1,1,1);

	}

void CSimpleAgent::ConstructL()

	{

	TimerConstructL(ESocketTimerPriority);

	}

TInt CSimpleAgent::Control(TUint aOptionLevel, TUint aOptionName, TDes8& aOption)

	{

	if(aOptionLevel!=KCOLAgent)

		return KErrNotSupported;

	switch(aOptionName)

		{

		case KADummySetInitialValue:

			iTestNo = *(REINTERPRET_CAST(const TInt*, aOption.Ptr()));

			return KErrNone;

		case KADummyIssueStop:

			switch (*(REINTERPRET_CAST(const TInt*, aOption.Ptr())))

				{

				case 2:		// not a stop as such - borrowing KADummyIssueStop

					iNotify->AgentEvent(EEtelEvent, ECurrentNetworkChangeEvent, KNullDesC8, NULL);

					break;

				case 1:

					{

					TInt stopCode = KErrEof;

					TPckgC<TInt> stopCodePkg(stopCode);

					iNotify->AgentEvent(EAgentOriginatedConnectionCommand, EAgentConnectionCommandStop, stopCodePkg, NULL);

					return KErrNone;

					break;

					}

				case 0:

					return iNotify->Notification(EAgentToNifEventTypeDisableConnection, NULL);

					break;

				}

		default:

			return KErrNotSupported;

		}

	}

void CSimpleAgent::Connect(TAgentConnectType aType, CStoreableOverrideSettings*)

	{

	iConType=aType;

	iState=EConnecting;

	iNotify->AgentProgress(ETNifmanProg2, KErrNone);

	TimerAfter(500000);

	}

void CSimpleAgent::Connect(TAgentConnectType aConType)

	{

	Connect(aConType, NULL);

	}

void CSimpleAgent::CancelConnect()

	{

	iState = EAwaitingDisconnect;

	TimerCancel();

	}

void CSimpleAgent::TimerComplete(TInt)

	{

	switch(iState)

		{

		case EConnecting:

			{

			if(iTestNo==10)

				{

				iState = EAwaitingDisconnect;

				iNotify->AgentProgress(ETNifmanProg6, KErrCouldNotConnect);

				iNotify->ConnectComplete(KErrCouldNotConnect);

				return;

				}

			if(iConType == EAgentStartDialOut)

				iNotify->ServiceStarted();

			if(iState==EConnecting)

				{

				iState = EAwaitingDisconnect;

				if(iTestNo==11)

					{

					iNotify->AgentProgress(ETNifmanProg6, KErrDisconnected);

					iNotify->ConnectComplete(KErrDisconnected);

					}

				else

					{

					iNotify->AgentProgress(ETNifmanProg6, KErrNone);

					iNotify->ConnectComplete(KErrNone);

					}

				}

			break;

			}

		case EDisconnecting:

			iState=EIdle;

			iNotify->DisconnectComplete();

			break;

		default:

			User::Panic(_L("CSimpleAgent"), 2);

		}

	}

TInt CSimpleAgent::Notification(TNifToAgentEventType aEvent, TAny* aInfo)

	{

	if (aEvent!=ENifToAgentEventTypePPPCallbackGranted)

		return KErrUnknown;

	if (aInfo!=NULL)

		return KErrUnknown;

	return KErrNone;

	}

void CSimpleAgent::Disconnect(TInt)

	{

	__ASSERT_DEBUG(iState==EAwaitingDisconnect, User::Panic(_L("CSimpleAgent"), 0));

	iState=EDisconnecting;

	TimerAfter(500000);

	}

void CSimpleAgent::Reconnect()

	{

	if(iTestNo == 15)

	    iNotify->ReconnectComplete(KErrNone);

	else // 14

		iNotify->ReconnectComplete(KErrBadName);

	}

void CSimpleAgent::CancelReconnect()

	{

	}

void CSimpleAgent::Authenticate(TDes&, TDes&)

	{

	iNotify->AuthenticateComplete(KErrNone);

	}

void CSimpleAgent::CancelAuthenticate()

	{

	}

TInt CSimpleAgent::GetExcessData(TDes8&)

	{

	return KErrNotSupported;

	}

TInt CSimpleAgent::DoReadInt(const TDesC& aField, TUint32& aValue,const RMessagePtr2*)

	{

	if(!aField.CompareF(_L("TestNo")))

		{

		aValue = iTestNo;

		return KErrNone;

		}

	else if(!aField.CompareF(_L("ModemBearer\\LastSocketClosedTimeout")))

		{

		switch (iTestNo)

			{

		case 17:

		case 19: aValue = 2; break;

		default: aValue = KMaxTUint32;

			}

		return KErrNone;

		}

	else if(!aField.CompareF(_L("ModemBearer\\LastSessionClosedTimeout")))

		{

		switch (iTestNo)

			{

		case 17:

		case 19: aValue = 2; break;

		default: aValue = KMaxTUint32;

			}

		return KErrNone;

		}

	else if(!aField.CompareF(_L("ModemBearer\\LastSocketActivityTimeout")))

		{

		switch (iTestNo)

			{

		case 18:

		case 19: aValue = 4; break;

		default: aValue = KMaxTUint32;

			}

		return KErrNone;

		}

	return KErrNotSupported;

	}

TInt CSimpleAgent::DoWriteInt(const TDesC&, TUint32,const RMessagePtr2*)

	{

	return KErrNotSupported;

	}

TInt CSimpleAgent::DoWriteBool(const TDesC&, TBool,const RMessagePtr2*)

	{

	return KErrNotSupported;

	}

TInt CSimpleAgent::DoReadBool(const TDesC&, TBool&,const RMessagePtr2*)

	{

	return KErrNotSupported;

	}

TInt CSimpleAgent::DoReadDes(const TDesC& aField, TDes8& aValue,const RMessagePtr2*)

	{

	if(!aField.CompareF(TPtrC(ISP_IF_NETWORKS)))

		{

		switch (iTestNo)

			{

        case 7:  aValue = _L8("Bogus Protocol"); break;

		case 4:

		case 8:

		case 3:

			{

			TBuf<200> wideBuf;

			wideBuf = KDummyFourName;

			wideBuf.Append(_L(","));

			wideBuf.Append(KDummyThreeName);

			aValue.Copy(wideBuf);

			break;

			}

		case 2:  aValue.Copy(KDummyFourName); break;

		case 5:  aValue.Copy(KDummyOneName); break;

		default: aValue.Copy(KDummyThreeName);

			}

		}

	else if(!aField.CompareF(TPtrC(IF_NAME)))

		{

		switch (iTestNo)

			{

		case 6: aValue = _L8("bogusif");    break;

		case 4:

		case 8:

		case 20:

		case 2: aValue.Copy(KDummyMulIfName);   break;

		default: aValue.Copy(KDummySglIfName); break;

			}

		}

	else if (!aField.CompareF(TPtrC(SERVICE_CONFIG_DAEMON_MANAGER_NAME)))

		{

		return KErrNotFound;

		}

	else if (!aField.CompareF(TPtrC(SERVICE_CONFIG_DAEMON_NAME)))

		{

		return KErrNotFound;

		}

	else

		return KErrNotSupported;

	return KErrNone;

	}

TInt CSimpleAgent::DoReadDes(const TDesC& aField, TDes16& aValue,const RMessagePtr2*)

	{

	if(!aField.CompareF(TPtrC(ISP_IF_NETWORKS)))

		{

		switch (iTestNo)

			{

        case 7:  aValue = _L16("Bogus Protocol"); break;

		case 4:

		case 8:

		case 3:

			{

			aValue = KDummyFourName;

			aValue.Append(_L(","));

			aValue.Append(KDummyThreeName);

			break;

			}

		case 2:  aValue = KDummyFourName; break;

		case 5:  aValue = KDummyOneName; break;

		default: aValue = KDummyThreeName;

			}

		}

	else if(!aField.CompareF(TPtrC(IF_NAME)))

		{

		switch (iTestNo)

			{

		case 6: aValue = _L16("bogusif");    break;

		case 4:

		case 8:

		case 20:

		case 2: aValue = KDummyMulIfName;   break;

		default: aValue = KDummySglIfName; break;

			}

		}

	else

		return KErrNotSupported;

	return KErrNone;

	}

TInt CSimpleAgent::DoWriteDes(const TDesC&, const TDesC8&,const RMessagePtr2*)

	{

	return KErrNotSupported;

	}

TInt CSimpleAgent::DoWriteDes(const TDesC&, const TDesC16&,const RMessagePtr2*)

	{

	return KErrNotSupported;

	}

TInt CSimpleAgent::IncomingConnectionReceived()

	{

	return iNotify->IncomingConnectionReceived();

	}

void CSimpleAgent::GetLastError(TInt& aError)

	{

	aError=KErrNone;

	}

TBool CSimpleAgent::IsActive() const

	{

	return ETrue;

	}

TBool CSimpleAgent::IsReconnect() const

	{

	return EFalse;

	}

void CSimpleAgent::SetConnectionSettingsL(const TConnectionSettings& aSettings)

	{

	iSettings = aSettings;

	}

TConnectionSettings& CSimpleAgent::ConnectionSettingsL()

	{

	return iSettings;

	}

void CSimpleAgent::SetOverridesL(CStoreableOverrideSettings*)

	{ }

CStoreableOverrideSettings* CSimpleAgent::OverridesL()

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

void CSimpleAgent::RequestNotificationOfServiceChangeL(MAgentSessionNotify*)

	{

	User::Leave(KErrNotSupported);

	}

void CSimpleAgent::CancelRequestNotificationOfServiceChange(MAgentSessionNotify*)

	{ }

HBufC* CSimpleAgent::DoReadLongDesLC(const TDesC&,const RMessagePtr2*)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}