// 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 "rasdef.h"
//#include "in_ver.h" Changed for dual stack 

TInt CNtRasFactory::Info(TNifAgentInfo& aInfo, TInt) const
	{
	
	CNtRas::FillInInfo(aInfo);
	return 1;
	}

void CNtRasFactory::InstallL()
	{

	}

CNifAgentBase *CNtRasFactory::NewAgentL(const TDesC& aName)
	{

	if(aName.CompareF(RAS_NIF_NAME))
		User::Leave(KErrBadName);

	CNtRas* ras = new (ELeave) CNtRas;
	CleanupStack::PushL(ras);
	ras->ConstructL();
	CleanupStack::Pop();
	return ras;
	}

CNtRas::CNtRas()
	{

	__DECLARE_NAME(_S("CNtRas"));
	}

CNtRas::~CNtRas()
	{

	__ASSERT_DEBUG(!iDatabase, Panic(ENtRasPanic_ObjectNotDeleted));
	__ASSERT_DEBUG(!iLoginBox, Panic(ENtRasPanic_ObjectNotDeleted));
	__ASSERT_DEBUG(!iConnectBox, Panic(ENtRasPanic_ObjectNotDeleted));
	__ASSERT_DEBUG(!iConnector, Panic(ENtRasPanic_ObjectNotDeleted));
	delete iAsyCb;
	delete iExcessData;
	}

void CNtRas::ConstructL()
	{
	
	TCallBack callback = TCallBack(AsyCbHandler, this);
	iAsyCb = new (ELeave) CAsyncCallBack(callback, KNtRasAsyncCbPriority);

	iDatabase = CRasDatabase::NewL(this);
	}

void CNtRas::Info(TNifAgentInfo& aInfo) const
	{
	
	FillInInfo(aInfo);

	// ensure that the name of this agent is unique
	aInfo.iName.AppendFormat(_L("[%x]"), this);
	}

void CNtRas::FillInInfo(TNifAgentInfo& aInfo)
	{
	
	aInfo.iName=RAS_NIF_NAME;
	}

void CNtRas::Connect(TAgentConnectType aType)
	{
	
	if(aType==EAgentStartDialOut)
	    Process(ERasOpStart);
	else
		Process(ERasOpRestart);
	}

void CNtRas::Connect(TAgentConnectType aType, CStoreableOverrideSettings* /*aOverrideSettings*/)
	{
	
	if(aType==EAgentStartDialOut)
	    Process(ERasOpStart);
	else
		Process(ERasOpRestart);
	}


void CNtRas::CancelConnect()
//
// Cancel all oustanding active calls by deleting objects
// Note a call to disconnect is to follow
//
	{

	iAsyCb->Cancel();
	delete iConnectBox;
	iConnectBox=0;

	// Let following Disconnect call sort everything else out
	}

void CNtRas::Reconnect()
	{
	Process(ERasOpReconnect);
	}

void CNtRas::CancelReconnect()
	{
	CancelConnect();
	}

void CNtRas::Disconnect(TInt /* aReason */)
	{

	Process(ERasOpDisconnect);
	}

void CNtRas::Authenticate(TDes& aUsername, TDes& aPassword)
	{

	__ASSERT_DEBUG(iState==ERasOpen, Panic(ENtRasPanic_ObjectNotDeleted));

	iUserNamePtr = &aUsername;
	iPasswordPtr = &aPassword;
	Process(ERasOpAuthenticate);
	}

void CNtRas::CancelAuthenticate()
	{

	iAsyCb->Cancel();
	delete iLoginBox;
	iLoginBox=0;
	iState = ERasOpen;
	}

void CNtRas::AuthenticateDialogComplete(TInt aStatus)
//
// Upcall from Login dialog
//
	{

	__ASSERT_DEBUG(iState==ERasAuthenticate, Panic(ENtRasPanic_ObjectNotDeleted)); 
	
	delete iLoginBox;
	iLoginBox=0;
	iState = ERasOpen;
	iNotify->AuthenticateComplete(aStatus);
	}

TInt CNtRas::GetExcessData(TDes8& aBuffer)
	{

	if(iState!=ERasOpen && iState != ERasAuthenticate)
	    return KErrNotReady;
	
	if(iExcessData)
	    aBuffer.Copy(*iExcessData);
	else
		aBuffer.SetLength(0);
	return KErrNone;
	}

TInt CNtRas::DoReadInt(const TDesC& aField, TUint32& aValue, const RMessagePtr2* /*aMessage*/ )
	{
	if(!iDatabase)
		return KErrNotReady;
	return iDatabase->ReadField(aField, aValue);
	}

TInt CNtRas::DoReadDes(const TDesC& aField, TDes8& aValue, const RMessagePtr2* /*aMessage*/ )
	{
#if !defined(UNICODE)
	if(!iDatabase)
		return KErrNotReady;
	return iDatabase->ReadField(aField, aValue);
#else
	// Remove warnings 
	aValue = aValue;
	const TUint16*  aTemp;
	aTemp = aField.Ptr(); 
	return KErrNotSupported;
#endif
	}

TInt CNtRas::DoReadDes(const TDesC& aField, TDes16& aValue, const RMessagePtr2* /*aMessage*/ )
	{
#if defined(UNICODE)
	if(!iDatabase)
		return KErrNotReady;

	if (aValue.MaxLength() > 256)
		return KErrTooBig;

	TBuf8<256> TempBuffer;
	TInt	RetCode;
	
	RetCode = iDatabase->ReadField(aField, TempBuffer);

	if ( RetCode == KErrNone )
		{
		TInt i;
		TUint8* source;
		TUint16* dest;
		TInt len;

		len = aValue.MaxLength();

		source = CONST_CAST(TUint8*,TempBuffer.Ptr());
		dest = CONST_CAST(TUint16*, aValue.Ptr());

		for (i=0;i<len;i++)
			{
			*(dest+i) = (TUint16)(*(source+i)&0xFF);
			}
		aValue.SetLength(TempBuffer.Length());
		}
	return RetCode;
#else
	// Remove warnings 
	aValue = aValue;
	const TUint8*  aTemp;
	aTemp = aField.Ptr(); 
	return KErrNotSupported;
#endif
	}

TInt CNtRas::DoReadBool(const TDesC& aField, TBool& aValue, const RMessagePtr2* /*aMessage*/ )
	{
	TUint32	TempValue;
	TInt	RetCode;

	if(!iDatabase)
		return KErrNotReady;

	RetCode = iDatabase->ReadField(aField, TempValue);

	if (RetCode == KErrNone)
		{
		if (TempValue)
			{
			aValue = ETrue;
			}
		else
			{
			aValue = EFalse;
			}
		}

	return RetCode;
	}

TInt CNtRas::DoWriteInt(const TDesC& /*aField */, TUint32 /* aValue */, const RMessagePtr2* /*aMessage*/ )
	{
	return KErrNotSupported;
	}

TInt CNtRas::DoWriteDes(const TDesC& /*aField*/, const TDesC8& /*aValue*/, const RMessagePtr2* /*aMessage*/ )
	{
	return KErrNotSupported;
	}

TInt CNtRas::DoWriteDes(const TDesC& /*aField*/, const TDesC16& /*aValue*/, const RMessagePtr2* /*aMessage*/ )
	{
	return KErrNotSupported;
	}

TInt CNtRas::DoWriteBool(const TDesC& /*aField */, TBool /* aValue */, const RMessagePtr2* /*aMessage*/ )
	{
	return KErrNotSupported;
	}

TInt CNtRas::Notification(TNifToAgentEventType aEvent, TAny* /* aInfo */)
	{
	switch (aEvent)
		{
		case ENifToAgentEventTypeQueryIsDialIn:
			{
			return KErrNotSupported;
			}
		case ENifToAgentEventTypePPPCallbackGranted:
			{
			return KErrNotSupported;
			}
		default:
			{
			return KErrNotSupported;
			}
		}

	}

TInt CNtRas::IncomingConnectionReceived()
	{
	return KErrNotSupported;
	}

void CNtRas::GetLastError(TInt& aError)
	{
	aError=KErrNone;
	}

void CNtRas::ConnectDialogComplete(TInt aStatus)
//
// Upcall from Connect dialog
//
	{

	__ASSERT_DEBUG(iState==ERasSelect||iState==ERasReconnect, Panic(ENtRasPanic_BadState));

	// Cleanup connect dialog
	delete iConnectBox;
	iConnectBox=0;

	TInt res = aStatus;
	iNotify->AgentProgress(ERasFinishedSelection, res);

	if(iState==ERasReconnect)
		{
		iNotify->ReconnectComplete(res);
		return;
		}

	if(res==KErrNone)
		{
        iNotify->ServiceStarted();
		if(iOp==ERasOpDisconnect) // ServiceStarted Failed
			return;
		// Start the connector next
		iState=ERasConnect;
		TRAP(res, iConnector=CRasConnect::NewL(this);)
		if(res!=KErrNone)
			iNotify->AgentProgress(ERasConnectionOpen, res);
		}
	
	if(res!=KErrNone)
	    iNotify->ConnectComplete(res); // Disconnect Next
	}

void CNtRas::ConnectComplete(TInt aStatus)
	{

	__ASSERT_DEBUG(iState==ERasConnect, Panic(ENtRasPanic_BadState));
	iNotify->AgentProgress(ERasConnectionOpen, aStatus);
	if(aStatus==KErrNone)
		{
		delete iExcessData;
		if(iConnector->ExcessData().Length())
		    iExcessData=iConnector->ExcessData().Alloc();
		}
	
	if(aStatus==KErrNone)
		iState=ERasOpen;
	iNotify->ConnectComplete(aStatus);
	}

void CNtRas::Process(TRasOp aOp)
//
// Advance to next state and call schedule DoProcess()
//
	{

	iOp = aOp;
	iAsyCb->Call();
	}

TInt CNtRas::AsyCbHandler(TAny* aPtr)
//
// Async CallBack handler - async state advances
//
	{
	((CNtRas*)aPtr)->DoProcess();
	return 0;
	}

void CNtRas::DoProcess()
//
// Process a request from above -> either Connect, Authenticate or Disconnect request
//
	{
	
	TInt res;
	// Do whatever is necessary for the op
	switch (iOp)
		{
	case ERasOpStart: 
		__ASSERT_DEBUG(iState==ERasClosed, Panic(ENtRasPanic_BadState));
		iState=ERasSelect;
		iNotify->AgentProgress(ERasStartingSelection, KErrNone);
	
		TRAP(res, iConnectBox = CConnectBox::NewL(this, EFalse);)
		if(res!=KErrNone)
			ConnectDialogComplete(res);
		break;

	case ERasOpReconnect:
		__ASSERT_DEBUG(iState==ERasOpen, Panic(ENtRasPanic_BadState));
		iNotify->AgentProgress(ERasStartingSelection, KErrNone);
		delete iConnector; // drop the lines
		iConnector=0;
		iState=ERasReconnect;
		TRAP(res, iConnectBox = CConnectBox::NewL(this, ETrue);)
		if(res!=KErrNone)
			ConnectDialogComplete(res);
		break;

	case ERasOpRestart:
		__ASSERT_DEBUG(iState==ERasReconnect, Panic(ENtRasPanic_BadState));
		iState=ERasConnect;
		TRAP(res, iConnector=CRasConnect::NewL(this);)
		if(res!=KErrNone)
			{
			iNotify->AgentProgress(ERasConnectionOpen, res);
			iNotify->ConnectComplete(res);
			}
		break;

	case ERasOpDisconnect:
		__ASSERT_DEBUG(!iConnectBox, Panic(ENtRasPanic_ObjectNotDeleted));
		__ASSERT_DEBUG(!iLoginBox, Panic(ENtRasPanic_ObjectNotDeleted));

		iNotify->AgentProgress(ERasStartingHangUp, KErrNone);
		if(iDatabase)
		    iNotify->ServiceClosed();
		delete iExcessData;
		iExcessData=0;
		delete iDatabase;
		iDatabase=0;
		delete iConnector;
		iConnector=0;
		iState=ERasClosed;
		iNotify->AgentProgress(ERasFinishedHangUp, KErrNone);
		iNotify->AgentProgress(ERasNoConnection, KErrNone);
		iNotify->DisconnectComplete();
		break;

	case ERasOpAuthenticate:
		__ASSERT_DEBUG(!iLoginBox,  Panic(ENtRasPanic_ObjectNotDeleted));
		__ASSERT_DEBUG(iState==ERasOpen, Panic(ENtRasPanic_BadState));
		
		iState=ERasAuthenticate;
	
		TRAP(res, iLoginBox = CLoginBox::NewL(this, *iUserNamePtr, *iPasswordPtr);)
		if (res!=KErrNone)
			AuthenticateDialogComplete(res);

		break;
		}		
	}

TBool CNtRas::IsActive() const
	{
	
	return ETrue;
	}

TBool CNtRas::IsReconnect() const
	{

	return EFalse;
	}

void CNtRas::SetConnectionSettingsL(const TConnectionSettings& aSettings)
	{

	iSettings = aSettings;
	}

TConnectionSettings& CNtRas::ConnectionSettingsL()
	{

	return iSettings;
	}

void CNtRas::SetOverridesL(CStoreableOverrideSettings*)
	{
	}

CStoreableOverrideSettings* CNtRas::OverridesL()
	{

	User::Leave(KErrNotSupported);
	return NULL;
	}

void CNtRas::RequestNotificationOfServiceChangeL(MAgentSessionNotify*)
	{

	User::Leave(KErrNotSupported);
	}

void CNtRas::CancelRequestNotificationOfServiceChange(MAgentSessionNotify*)
	{
	}

HBufC* CNtRas::DoReadLongDesLC(const TDesC&, const RMessagePtr2* /*aMessage*/ )
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}