diff -r 000000000000 -r 3553901f7fa8 telephonyprotocols/csdagt/src/Nd_dlupStates.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyprotocols/csdagt/src/Nd_dlupStates.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,1262 @@ +// Copyright (c) 2003-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: +// Dial Up States +// +// + +/** + @file Nd_dlupstates.cpp +*/ + + +#include "Nd_dlupStates.h" +#include "SLOGGER.H" +#include +#include +#include "ND_DBACC.H" + + +CDlUpInit* CDlUpInit::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up Init State + +2 phased constructor for CDlUpInit, first phase. + +@param aSMObserver a reference to state machine observer. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +@exception Leaves if ConstructL() leaves, or not enough memory is available. +@return a new CDlUpInit object. +*/ + { + CDlUpInit* r=new(ELeave) CDlUpInit(aSMObserver, aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpInit::CDlUpInit(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv) +/** +Private constructor for CDlUpInit, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpInit::ConstructL() +/** +Instantiate Member variable. +Call base class CNdCallBackStateBase::ConstructL(). + +@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available. +*/ + {} + +CDlUpInit::~CDlUpInit() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpInit::StartState() +/** +Starts dialup init state. +If connection is reconnect and used script is not NULL, delete script. +Call JumpToRunl() with KErrNone. +*/ + { + if (((iNdEnv->BaseEnv())->IsReconnect()) && (iNdEnv->Script()!=NULL)) + { + iNdEnv->DeleteScript(); + } + JumpToRunl(KErrNone); + } + +CAgentStateBase* CDlUpInit::NextStateL(TBool aContinue) +/** +Changes to from init state to next state. +If connection is not continued, create disconnect state. +Else create dialling state. + +@exception Leaves if NewL() leaves. +@return a new CDlUpDisconnect or CDlUpDialling object. +*/ + { + if(!aContinue) + { + return CDlUpDisconnect::NewL(*iSMObserver,*iNdEnv); + } + else + { + return CDlUpDialling::NewL(*iSMObserver,*iNdEnv); + } + } + +void CDlUpInit::DoCancel() +/** +Cancels active requests. +*/ + { + } + +void CDlUpInit::RunL() +/** +Dial up init completed. +Call CompleteState() with KErrNone. +*/ + { + __ASSERT_DEBUG(iStatus==KErrNone, User::Invariant()); + (iNdEnv->BaseEnv())->CompleteState(KErrNone); + } + +CDlUpDialling* CDlUpDialling::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up Dialling State + +2 phased constructor for CDlUpDialling, first phase. + +@param aSMObserver a reference to state machine observer. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +@exception Leaves if ConstructL() leaves, or not enough memory is available. +@return a new CDlUpDialling object. +*/ + { + CDlUpDialling* r=new(ELeave) CDlUpDialling(aSMObserver,aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpDialling::CDlUpDialling(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv) +/** +Private constructor for CDlUpDialling, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpDialling::ConstructL() +/** +Instantiate Member variable. +Call base class CNdCallBackStateBase::ConstructL(). + +@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available. +*/ + {} + +CDlUpDialling::~CDlUpDialling() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpDialling::StartState() +/** +Starts dialup dialling state. +Call UpdateProgress() with EStartingDialling and KErrNone. +If reconnect, trap and start reconnect by calling StartReconnectL() from ETel server processor. +Else trap and start dial up by calling StartDialUpL() from ETel server processor. +If trap error, call JumpToRunl() with the trap error and return. +Else set state active. +*/ + { + TInt err=KErrNone; + iSMObserver->UpdateProgress(ECsdStartingDialling,KErrNone); + // Either start reconnection or dial up + if ((iNdEnv->BaseEnv())->IsReconnect()) + { + TRAP(err,(iNdEnv->TelServPrc())->StartReconnectL(*this)); + } + else + { + TRAP(err,(iNdEnv->TelServPrc())->StartDialUpL(*this)); + } + // JumpToRunl with leave error if ETel server processor calls leave. + if(err!=KErrNone) + { + JumpToRunl(err); + return; + } + // Else continue connection, set state active and wait for completition. + else + { + iStatus=KRequestPending; + SetActive(); + } + } + +CAgentStateBase* CDlUpDialling::NextStateL(TBool aContinue) +/** +Changes to from dialling state to next state. +If connection is not continued or iStatus is not KErrNone, create Disconnect state. +Else create Open Data Port (BCA), Scan Script (non-BCA) state. + +@exception Leaves if NewL() leaves. +@return a new CDlUpDisconnect or CDlUpOpenDataPort (BCA) / CDlUpScanScript (non-BCA) object. +*/ + { + if((!aContinue)||(iStatus!=KErrNone)) + { + return CDlUpDisconnect::NewL(*iSMObserver,*iNdEnv); + } + else + { +#ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT + if (iNdEnv->UseScript()) + { + return CDlUpOpenDataPort::NewL(*iSMObserver, *iNdEnv); + } + else + { + return CDlUpOpen::NewL(*iSMObserver,*iNdEnv); + } +#else + return CDlUpOpenDataPort::NewL(*iSMObserver, *iNdEnv); + +#endif + } + } + +void CDlUpDialling::TelFunctionComplete(TInt aError) + { + TRequestStatus* status=&iStatus; + User::RequestComplete(status,aError); + } + +void CDlUpDialling::DoCancel() +/** +Cancels active requests. +*/ + { + // if a log event creation is ongoing, we want to let it go and the log event should reflect the reality + // a call has been made and custumer will be charged for it + //iNdEnv->Logger()->Cancel(); + if((iNdEnv->TelServPrc())!=NULL) + (iNdEnv->TelServPrc())->Cancel(); + if (iStatus == KRequestPending) + { + TelFunctionComplete(KErrCancel); + } + } + +void CDlUpDialling::RunL() +/** +Dialling completed (should not complete if connection cancelled). +If there is an error then signal it by calling ConnectionComplete() with EFinishedDialling and iStatus.Int(). +Call UpdateProgress() with ECsdFinishedDialling and KErrNone. +Call PreventConnectionRetries() to stop new connections. +Call CompleteState() with KErrNone. +Dialling is always asynchronous, so should not complete if cancelled. +*/ + { + if(iStatus!=KErrNone) + { + __FLOG_STMT(_LIT(logString3,"Dialling");) + __FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue(KCompletedPhaseLogString()), &logString3() ,iStatus.Int()); + if (iNdEnv->Script()!=NULL) + iNdEnv->Script()->CloseScript(); + iSMObserver->ConnectionComplete(ECsdFinishedDialling,iStatus.Int()); + return; + } + iSMObserver->UpdateProgress(ECsdFinishedDialling,KErrNone); + iSMObserver->PreventConnectionRetries(); + // request asynch creation of logevent and go to next state + TBuf remoteParty; + (iNdEnv->NetDialDb())->GetRemoteParty(remoteParty); + TDialString telNum; + TRAPD(ret, (iNdEnv->NetDialDb())->DoDiallingResolutionL(telNum,EForDisplay)); +#ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT + iNdEnv->GetUseScriptL(); + if (!iNdEnv->UseScript()) + { + // We need to do this stuff now because it will not be done later in the login script setup + RCall::TCommPort commPort; + iNdEnv->TelServPrc()->GetCommPortL(commPort); //This updates Nifman's record and is needed by ppp + iSMObserver->ServiceStarted(); + } +#endif // SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT + // JumpToRunl if error + if(ret==KErrNone) + { + // no logging if problem in finding telephone number + iNdEnv->Logger()->LogDataAddEvent(R_LOG_CON_CONNECTED, remoteParty,R_LOG_DIR_OUT,telNum,KLogDataEventTypeUid); + } + // go to next state without waiting for logevent creation being completed. + (iNdEnv->BaseEnv())->CompleteState(KErrNone); + } +TInt CDlUpDialling::RunError(TInt aError) +/** + Handles errors +*/ + { + iSMObserver->ConnectionComplete(ECsdScannedScript,aError); + return KErrNone; + } + +CDlUpScanScript* CDlUpScanScript::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up Scan Script State + +2 phased constructor for CDlUpScanScript, first phase. + +@param aSMObserver a reference to state machine observer. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +@exception Leaves if ConstructL() leaves, or not enough memory is available. +@return a new CDlUpScanScript object. +*/ + { + CDlUpScanScript* r=new(ELeave) CDlUpScanScript(aSMObserver,aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpScanScript::CDlUpScanScript(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv) +/** +Private constructor for CDlUpDialling, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpScanScript::ConstructL() +/** +Instantiate Member variable. +Call base class CNdCallBackStateBase::ConstructL(). + +@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available. +*/ + {} + +CDlUpScanScript::~CDlUpScanScript() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpScanScript::StartState() +/** +Starts Dialup Scan Script state, scans "login" script for READ command. +Call UpdateProgress() with ECsdScanningScript and KErrNone. +Setup script by calling SetUpScriptL(). +If SetUpScriptL leaves, call JumpToRunl() with leave error. +If script is used, start scannin script and set state active. +Else call JumpToRunl() with KErrNone. +*/ + { + if (iNdEnv->UseScript()) + { + (iNdEnv->Script())->Scan(*this); + iStatus=KRequestPending; + SetActive(); + } + else + { + JumpToRunl(KErrNone); + } + } + +CAgentStateBase* CDlUpScanScript::NextStateL(TBool aContinue) +/** +Changes to from Scan Script state to next state. +If connection is not continued or iStatus is not KErrNone, create Close Data Port (BCA) / Hangup (non-BCA) state. +Else create get login info state. + +@exception Leaves if NewL() leaves. +@return a new CDlUpCloseDataPort (BCA) / CDlUpHangUp (non-BCA) or CDlUpGetLoginInfo object. +*/ + { + if((!aContinue)||(iStatus!=KErrNone)) + { + return CDlUpCloseDataPort::NewL(*iSMObserver,*iNdEnv, iStatus.Int()); + } + else + { + return CDlUpGetLoginInfo::NewL(*iSMObserver,*iNdEnv); + } + } + +void CDlUpScanScript::DoCancel() +/** +Cancels active requests. +*/ + { + if (iNdEnv->Script()!=NULL) + { + (iNdEnv->Script())->Cancel(); + } + if (iStatus == KRequestPending) + { + ScriptFunctionComplete(KErrCancel); + } + } + +void CDlUpScanScript::RunL() +/** +Scan completed (should not complete if connection cancelled). +If there is an error then signal it by calling ConnectionComplete() with EScannedScript and iStatus.Int(). +Call UpdateProgress() with ECsdScannedScript and KErrNone. +Call CompleteState() with KErrNone. +*/ + { + if(iStatus!=KErrNone) + { + __FLOG_STMT(_LIT(logString3,"Scan Script");) + __FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue(KCompletedPhaseLogString()), &logString3(), iStatus.Int()); + if (iNdEnv->Script()!=NULL) + iNdEnv->Script()->CloseScript(); + iSMObserver->ConnectionComplete(ECsdScannedScript,iStatus.Int()); + return; + } + iSMObserver->UpdateProgress(ECsdScannedScript,KErrNone); + (iNdEnv->BaseEnv())->CompleteState(KErrNone); + } + +void CDlUpScanScript::ScriptFunctionComplete(TInt aError) + { + TRequestStatus* status=&iStatus; + User::RequestComplete(status,aError); + } + +CDlUpGetLoginInfo* CDlUpGetLoginInfo::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up Get Login Info State + +2 phased constructor for CDlUpGetLoginInfo, first phase. + +@param aSMObserver a reference to state machine observer. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +@exception Leaves if ConstructL() leaves, or not enough memory is available. +@return a new CDlUpGetLoginInfo object. +*/ + { + CDlUpGetLoginInfo* r=new(ELeave) CDlUpGetLoginInfo(aSMObserver,aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpGetLoginInfo::CDlUpGetLoginInfo(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CGetLoginInfo(aSMObserver,aNdEnv) +/** +Private constructor for CDlUpGetLoginInfo, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpGetLoginInfo::ConstructL() +/** +Instantiate Member variable. +*/ + {} + +CDlUpGetLoginInfo::~CDlUpGetLoginInfo() +/** +Destructor. + +Cancel active request. +*/ + { + } + +CAgentStateBase* CDlUpGetLoginInfo::NextStateL(TBool aContinue) +/** +Changes to from get login info state to next state. + +If connection is not continued or iStatus is not KErrNone, create Hangup state. +Else create login state. + +@exception Leaves if NewL() leaves. +@return a new CDlUpCloseDataPort (BCA) / CDlUpHangUp (non-BCA) or CDlUpLogin object. +*/ + { + if((!aContinue)||(iStatus!=KErrNone)) + { + __FLOG_STMT(_LIT(logString,"NetDial:\tGetLoginInfo state cancelling (aContinue %d, iStatus %d)");) + __FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue(logString()), aContinue, iStatus.Int()); + + TInt err = iStatus.Int(); + if (!aContinue && err == KErrNone) + { + // Ensure that CDlUpCloseDataPort receives an error in the case where aContinue==EFalse and iStatus==KErrNone. + // If not, CDlUpCloseDataPort will carry on as if we are doing a normal startup, advance to CDlUpOpen, and cause + // a NIFMAN panic (ConnectComplete(), state is EDisconnecting). Note that the aContinue flag does not seem to be + // propagated between states, so even though it may be EFalse here (indicating a connection cancellation), in + // CDlUpCloseDataPort it seems to revert back to ETrue. + err = KErrCancel; + } + return CDlUpCloseDataPort::NewL(*iSMObserver,*iNdEnv, err); + } + else //succesful run of state + { + return CDlUpLogin::NewL(*iSMObserver,*iNdEnv); + } + } + +CDlUpLogin* CDlUpLogin::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up Login State + +2 phased constructor for CDlUpLogin, first phase. + +@param aSMObserver a reference to state machine observer. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +@exception Leaves if ConstructL() leaves, or not enough memory is available. +@return a new CDlUpLogin object. +*/ + { + CDlUpLogin* r=new(ELeave) CDlUpLogin(aSMObserver,aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpLogin::CDlUpLogin(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv) +/** +Private constructor for CDlUpLogin, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpLogin::ConstructL() +/** +Instantiate Member variable. +*/ + {} + +CDlUpLogin::~CDlUpLogin() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpLogin::StartState() +/** +Starts dialup call login state. +Call UpdateProgress() with ECsdStartingLogIn and KErrNone. +Call DoStartStateL() and trap possible leave. +If DoStartStateL leaves, call JumpToRunl() with leave error. +*/ + { + iSMObserver->UpdateProgress(ECsdStartingLogIn,KErrNone); + // This call executes the actual script. + TRAPD(ret,DoStartStateL()); + if (ret!=KErrNone) + JumpToRunl(ret); + } + +void CDlUpLogin::DoStartStateL() +/** +If login script is valid then execute it. +If script is used, call ExecuteL() and set state active. +Else call JumpToRunl() with KErrNone. +*/ + { + if (iNdEnv->UseScript()) + { + (iNdEnv->Script())->ExecuteL(*this); + iStatus=KRequestPending; + SetActive(); + } + else + { + JumpToRunl(KErrNone); + } + } + +CAgentStateBase* CDlUpLogin::NextStateL(TBool aContinue) +/** +Changes to from login state to next state. +If connection is not continued or iStatus is not KErrNone, create hangup state. +Else create open state (non-BCA). Create close data port state (BCA). + +@exception Leaves if NewL() leaves. +@return a new CDlUpCloseDataPort (BCA), CDlUpHangUp or CDlUpOpen (non-BCA) object. +*/ + { + (void)aContinue; + return CDlUpCloseDataPort::NewL(*iSMObserver,*iNdEnv, iStatus.Int()); + } + +void CDlUpLogin::ScriptFunctionComplete(TInt aError) + { + TRequestStatus* status=&iStatus; + User::RequestComplete(status,aError); + } + +void CDlUpLogin::DoCancel() +/** +Cancels active requests. +*/ + { + if(iNdEnv->Script()!=NULL) + (iNdEnv->Script())->Cancel(); + if (iStatus == KRequestPending) + { + ScriptFunctionComplete(KErrCancel); + } + } + +void CDlUpLogin::RunL() +/** +Login completed (should not complete if connection cancelled). +If there is an error then signal it by calling ConnectionComplete() with ECsdFinishedLogIn and iStatus.Int(). +Call UpdateProgress() with EScannedScript and KErrNone. +Call CompleteState() with KErrNone. +*/ + { + if(iStatus!=KErrNone) + { + __FLOG_STMT(_LIT(logString3,"Login");) + __FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue(KCompletedPhaseLogString()), &logString3(), iStatus.Int()); + if (iNdEnv->Script()!=NULL) + iNdEnv->Script()->CloseScript(); + iSMObserver->ConnectionComplete(ECsdFinishedLogIn,iStatus.Int()); + return; + } + + iSMObserver->UpdateProgress(ECsdFinishedLogIn,KErrNone); + (iNdEnv->BaseEnv())->CompleteState(KErrNone); + } + +CDlUpOpen* CDlUpOpen::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up Open State + +2 phased constructor for CDlUpOpen, first phase. + +@param aSMObserver a reference to state machine observer. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +@exception Leaves if ConstructL() leaves, or not enough memory is available. +@return a new CDlUpOpen object. +*/ + { + CDlUpOpen* r=new(ELeave) CDlUpOpen(aSMObserver,aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpOpen::CDlUpOpen(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CNdCallBackStateBase(aSMObserver),iNdEnv(&aNdEnv) +/** +Private constructor for CDlUpOpen, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpOpen::ConstructL() +/** +Instantiate Member variable. +Call base class CNdCallBackStateBase::ConstructL(). + +@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available. +*/ + { + CNdCallBackStateBase::ConstructL(); + } + +CDlUpOpen::~CDlUpOpen() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpOpen::StartState() +/** +Starts dialup open state. +Call JumpToRunl() with KErrNone. +*/ + { + JumpToRunl(KErrNone); + } + +CAgentStateBase* CDlUpOpen::NextStateL(TBool /*aContinue*/) +/** +Changes to from open state to next state. +If call back is used, create dial in init state. +else if connection is reconnect, create dial up init state. +Else create hangup state. + +@exception Leaves if NewL() leaves. +@return a new CDlInInit, CDlUpInit or CDlUpHangUp object. +*/ + { + if((iNdEnv->BaseEnv())->CallBack()) + { + return CDlInInit::NewL(*iSMObserver,*iNdEnv); + } + else if((iNdEnv->BaseEnv())->IsReconnect()) + { + return CDlUpInit::NewL(*iSMObserver,*iNdEnv); + } + else + { + return CDlUpHangUp::NewL(*iSMObserver,*iNdEnv); + } + } +#ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT +void CDlUpOpen::TelFunctionComplete(TInt aError) + { + iTelEvent = ETrue; + JumpToRunl(aError); + } +#endif + +void CDlUpOpen::DoCancel() +/** +Cancels active requests. +*/ + { +#ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT + if(NULL != iNdEnv->TelServPrc()) + { + iNdEnv->TelServPrc()->Cancel(); + } +#endif +// (iNdEnv->BaseEnv())->CompleteState(KErrCancel); + } + +void CDlUpOpen::RunL() +/** +Open completed. +Call UpdateProgress() with ECsdConnectionOpen and KErrNone. +If script is used, close it. +Call ConnectionComplete() with ECsdConnectionOpen and KErrNone. +*/ + { +#ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT + if (iTelEvent) + { + iTelEvent = EFalse; + iSMObserver->Notification(EAgentToNifEventTypeDisableConnection, + reinterpret_cast(KErrDisconnected)); + return; + } +#endif + __ASSERT_DEBUG(iStatus==KErrNone,User::Invariant()); + iSMObserver->UpdateProgress(ECsdConnectionOpen,KErrNone); + __FLOG_STMT(_LIT8(logString,"NetDial:\tConnection Open");) + __FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),logString()); + if (iNdEnv->Script()!=NULL) + iNdEnv->Script()->CloseScript(); + iSMObserver->ConnectionComplete(ECsdConnectionOpen,KErrNone); +#ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT + iNdEnv->TelServPrc()->ListenForStatusChange(*this); +#endif + } + +CDlUpHangUp* CDlUpHangUp::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up HangUp State + +2 phased constructor for CDlUpHangUp, first phase. + +@param aSMObserver a reference to state machine observer. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +@exception Leaves if ConstructL() leaves, or not enough memory is available. +@return a new CDlUpHangUp object. +*/ + { + CDlUpHangUp* r=new(ELeave) CDlUpHangUp(aSMObserver,aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpHangUp::CDlUpHangUp(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CNdCallBackStateBase(aSMObserver),iNdEnv(&aNdEnv) +/** +Private constructor for CDlUpHangUp, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpHangUp::ConstructL() +/** +Instantiate Member variable. +Call base class CNdCallBackStateBase::ConstructL(). + +@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available. +*/ + { + CNdCallBackStateBase::ConstructL(); + } + +CDlUpHangUp::~CDlUpHangUp() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpHangUp::StartState() +/** +Starts dialup hangup state. +Call UpdateProgress() with ECsdStartingHangUp and KErrNone. +If script is used, clean up script. +If dataport is loaned, recover it by calling ReturnCommPortL() from ETel server processor. +If ReturnCommPortL leaves, call JumpToRunl() with the leave error and return. +If call is active, call StartHangUpAfterDialOut() from ETel server processor and set state active. +Else call JumpToRunl() with KErrNone. +*/ + { + iSMObserver->UpdateProgress(ECsdStartingHangUp,KErrNone); + + if (iNdEnv->Script()!=NULL) + { + (iNdEnv->Script())->CleanupScript(); + } + + if (iNdEnv->TelServPrc()->CommPortLoaned()) + { + // returns ownership of the comm port to ETEL + TRAPD(err,(iNdEnv->TelServPrc())->ReturnCommPortL()); + if (err!=KErrNone) + { + JumpToRunl(err); + return; + } + } + + if (iNdEnv->TelServPrc()->CallActive()) + { + (iNdEnv->TelServPrc())->StartHangUpAfterDialOut(*this); + iStatus=KRequestPending; + SetActive(); + } + else + JumpToRunl(KErrNone); + } + +CAgentStateBase* CDlUpHangUp::NextStateL(TBool /*aContinue*/) +/** +Changes to from hangup state to next state. +Next State will always be Disconnect regardless of implementation results + +@exception Leaves if NewL() leaves. +@return a new CDlUpDisconnect object. +*/ + { + return CDlUpDisconnect::NewL(*iSMObserver,*iNdEnv); + } + +void CDlUpHangUp::TelFunctionComplete(TInt aError) + { + TRequestStatus* status=&iStatus; + User::RequestComplete(status,aError); + } + +void CDlUpHangUp::DoCancel() +/** +Cancels active requests. +*/ + { + (iNdEnv->TelServPrc())->Cancel(); + if (iStatus == KRequestPending) + { + TelFunctionComplete(KErrCancel); + } + } + +void CDlUpHangUp::RunL() +/** +Hangup completed. +If there is an error then log it, otherwise advance to closed phase. +Else call UpdateProgress() with ECsdFinishedHangUp and KErrNone. +Call CompleteState() with iStatus.Int(). +*/ + { + //update the log object + iNdEnv->Logger()->LogDataUpdateEvent(R_LOG_CON_DISCONNECTED, KLogDataEventTypeUid); + if(iStatus!=KErrNone) + { +#ifdef __FLOG_ACTIVE + _LIT(logString3,"Hang Up"); + _LIT8(logString2,"NetDial:\tDisconnection Error %d"); +#endif + __FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue(KCompletedPhaseLogString()), &logString3(), iStatus.Int()); + __FLOG_STATIC1(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue(logString2()), iStatus.Int()); + } + else + { + iSMObserver->UpdateProgress(ECsdFinishedHangUp,KErrNone); + } + (iNdEnv->BaseEnv())->CompleteState(iStatus.Int()); + } + +CDlUpDisconnect* CDlUpDisconnect::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up Disconnect State +*/ + { + CDlUpDisconnect* r=new(ELeave) CDlUpDisconnect(aSMObserver,aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpDisconnect::CDlUpDisconnect(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CNdCallBackStateBase(aSMObserver),iNdEnv(&aNdEnv) +/** +Private constructor for CDlUpDisconnect, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpDisconnect::ConstructL() +/** +Instantiate Member variable. +Call base class CNdCallBackStateBase::ConstructL(). + +@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available. +*/ + { + CNdCallBackStateBase::ConstructL(); + } + +CDlUpDisconnect::~CDlUpDisconnect() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpDisconnect::StartState() +/** +Starts dialup disconnect state. +If script is used, clean up script. +If ETel server processor is used, close all ETel call objects. +Call JumpToRunl() with KErrNone. +*/ + { + if ((iNdEnv->Script())!=NULL) + { + (iNdEnv->Script())->CleanupScript(); + } + if ((iNdEnv->TelServPrc())!=NULL) + { + (iNdEnv->TelServPrc())->CloseCall(); + } + // We need to make sure that logging is finished before closing everything. + // forward iStatus to the logger, which will be responsible to complete iStatus when it is finished. + iStatus = KRequestPending; + SetActive(); + iNdEnv->Logger()->LogDataNotifyLastEventUpdate(&iStatus); + } + +CAgentStateBase* CDlUpDisconnect::NextStateL(TBool /*aContinue*/) +/** +Changes to from disconnect state to next state. +Next State will always be Disconnect regardless of implementation results. + +@exception Leaves if NewL() leaves. +@return a new CDlUpDisconnect object. +*/ + { + return CDlUpDisconnect::NewL(*iSMObserver,*iNdEnv); + } + +void CDlUpDisconnect::DoCancel() +/** +Cancels active requests. +*/ + { + } + +void CDlUpDisconnect::RunL() +/** +Disconnect completed. +Call DisconnectComplete(). +*/ + { + __FLOG_STMT(_LIT8(logString,"NetDial:\tDisconnect Complete");) + __FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),logString()); + + iSMObserver->DisconnectComplete(); + } + +CDlUpOpenDataPort* CDlUpOpenDataPort::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) +/** +Dial Up Open Data Port State +*/ + { + CDlUpOpenDataPort* r=new(ELeave) CDlUpOpenDataPort(aSMObserver,aNdEnv); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpOpenDataPort::CDlUpOpenDataPort(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) + : CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv) +/** +Private constructor for CDlUpOpenDataPort, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpOpenDataPort::ConstructL() +/** +Instantiate Member variable. +Call base class CNdCallBackStateBase::ConstructL(). + +@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available. +*/ + { + } + +CDlUpOpenDataPort::~CDlUpOpenDataPort() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpOpenDataPort::StartState() +/** +Starts Dial Up Open Data Port state. +Set up script and initiate creation of channel. +Call JumpToRunl() with KErrNone. +*/ + { + ASSERT(iNdEnv); + __FLOG_STMT(_LIT8(logString,"NetDial:\tOpening Data Port")); + __FLOG_STATIC(KNetDialLogFolder(), KNetDialLogFile(), logString()); + + iSMObserver->UpdateProgress(ECsdScanningScript,KErrNone); + TRAPD(ret,iNdEnv->SetUpScriptL()); + if (ret!=KErrNone) + { + JumpToRunl(ret); + return; + } + + iNdEnv->Script()->CreateChannel(iStatus); + iStatus = KRequestPending; + SetActive(); + } + +CAgentStateBase* CDlUpOpenDataPort::NextStateL(TBool aContinue) +/** +Changes to from Open Data Port state to next state. +Next State will be Hangup on errors or connection start cancellation, else Scan Script. + +@exception Leaves if NewL() leaves. +@return a new CDlUpHangUp or CDlUpOpenDataPort object. +*/ + { + if((!aContinue)||(iStatus!=KErrNone)) + { + return CDlUpHangUp::NewL(*iSMObserver,*iNdEnv); + } + else + { + return CDlUpScanScript::NewL(*iSMObserver, *iNdEnv); + } + } + +void CDlUpOpenDataPort::DoCancel() +/** +Cancels active requests. +*/ + { + iNdEnv->Script()->CancelCreateChannel(); + } + +void CDlUpOpenDataPort::RunL() +/** +Dial Up Open Data Port completed. +Call CompleteState() with KErrNone. +*/ + { + if (iStatus!=KErrNone) + { +#ifdef __FLOG_ACTIVE + _LIT(logString3,"Open Data Port"); +#endif + __FLOG_STATIC2(KNetDialLogFolder(), KNetDialLogFile(), TRefByValue(KCompletedPhaseLogString()), &logString3(), iStatus.Int()); + if (iNdEnv->Script()!=NULL) + iNdEnv->Script()->CloseScript(); + iSMObserver->ConnectionComplete(ECsdScannedScript,iStatus.Int()); + return; + } + + (iNdEnv->BaseEnv())->CompleteState(KErrNone); + } + +CDlUpCloseDataPort* CDlUpCloseDataPort::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv, TInt aError) +/** +Dial Up Close Data Port State +*/ + { + CDlUpCloseDataPort* r=new(ELeave) CDlUpCloseDataPort(aSMObserver,aNdEnv, aError); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CDlUpCloseDataPort::CDlUpCloseDataPort(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv, TInt aError) + : CAgentStateBase(aSMObserver), iNdEnv(&aNdEnv), iError(aError) +/** +Private constructor for CDlUpCloseDataPort, used in the first phase of construction. + +@param aSMObserver a reference to the database accessor. +@param aNdEnv a reference to the Netdial which defines a set of utility functions. +*/ + {} + +void CDlUpCloseDataPort::ConstructL() +/** +Instantiate Member variable. +Call base class CNdCallBackStateBase::ConstructL(). + +@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available. +*/ + { + } + +CDlUpCloseDataPort::~CDlUpCloseDataPort() +/** +Destructor. +Cancel active request. +*/ + { + Cancel(); + } + +void CDlUpCloseDataPort::StartState() +/** +Starts Dial Up Close Data Port state. +Initiate shutdown of data port +*/ + { + ASSERT(iNdEnv); + ASSERT (iNdEnv->Script()); + + __FLOG_STMT(_LIT8(logString,"NetDial:\tClosing Data Port")); + __FLOG_STATIC(KNetDialLogFolder(), KNetDialLogFile(), logString()); + + iNdEnv->Script()->ShutdownChannel(iStatus); + iStatus = KRequestPending; + SetActive(); + } + +CAgentStateBase* CDlUpCloseDataPort::NextStateL(TBool aContinue) +/** +Changes to from Close Data Port state to next state. + +@exception Leaves if NewL() leaves. +@return a new CDlUpCloseDataPort object. +*/ + { + if((!aContinue) || (iError != KErrNone) || (iStatus.Int() != KErrNone)) + { + __FLOG_STMT(_LIT(logString,"NetDial:\tCloseDataPort state cancelling (iError %d, aContinue %d, iStatus %d)");) + __FLOG_STATIC3(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue(logString()), iError, aContinue, iStatus.Int()); + + return CDlUpHangUp::NewL(*iSMObserver,*iNdEnv); + } + else + { + return CDlUpOpen::NewL(*iSMObserver, *iNdEnv); + } + } + +void CDlUpCloseDataPort::DoCancel() +/** +Cancels active requests. +*/ + { + } + +void CDlUpCloseDataPort::RunL() +/** +Close Data Port completed. +Call CompleteState() with KErrNone. +*/ + { + // Note: we assume that if iError != KErrNone then ConnectionComplete() has already been called by + // the failing state (otherwise NIFMAN will panic due to the lack of a ConnectComplete() in response + // to its earlier Connect()). + if (iStatus!=KErrNone) + { +#ifdef __FLOG_ACTIVE + _LIT(logString3,"Close Data Port"); + _LIT8(logstring2,"Saved error = %d"); +#endif + __FLOG_STATIC2(KNetDialLogFolder(), KNetDialLogFile(), TRefByValue(KCompletedPhaseLogString()), &logString3(), iStatus.Int()); + if (iError != KErrNone) + { + __FLOG_STATIC1(KNetDialLogFolder(), KNetDialLogFile(), TRefByValue(logstring2()), iError); + } + else + { + // Only do the ConnectionComplete() due to errors in this state if a previous state has not already done + // so (i.e. iError == KErrNone) otherwise NIFMAN will panic. + iSMObserver->ConnectionComplete(iStatus.Int()); + return; + } + } + (iNdEnv->BaseEnv())->CompleteState(KErrNone); + } +