diff -r 000000000000 -r af10295192d8 networkingtestandutils/networkingintegrationtest/NTRas/RASNIF.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkingtestandutils/networkingintegrationtest/NTRas/RASNIF.CPP Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,516 @@ +// 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;iReadField(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; + }