diff -r 000000000000 -r 3553901f7fa8 telephonyprotocols/csdagt/src/ND_DIRECTSTATES.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyprotocols/csdagt/src/ND_DIRECTSTATES.CPP	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1246 @@
+// 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:
+// Direct Connection States
+// 
+//
+
+/**
+ @file Nd_directstates.cpp 
+*/
+
+#include "ND_DIRCT.H"
+#include "ND_SCR.H"
+#include "ND_DBACC.H"
+#include "ND_STD.H"
+#include "SLOGGER.H"
+#include "ND_DIRECTSTATES.H"
+
+CDirCtInit* CDirCtInit::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection Initial State
+2 phased constructor for CDirCtInit, 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 CDirCtInit object.
+*/
+	{
+	CDirCtInit* r=new(ELeave) CDirCtInit(aSMObserver, aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtInit::CDirCtInit(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv)
+/**
+Private constructor for CDirCtInit, 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 CDirCtInit::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+CDirCtInit::~CDirCtInit()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtInit::StartState()
+/**
+Starts direct connection init state.
+If connection is reconnect and used script is not NULL, reconfigure and cancel COMM-port and delete script.
+Call JumpToRunl with KErrNone.
+*/
+	{
+	JumpToRunl(KErrNone);
+	}
+
+CAgentStateBase* CDirCtInit::NextStateL(TBool aContinue)
+/**
+Changes to from init state to next state.
+If connection is not continued, create disconnect state.
+Else create scan script state.
+
+@exception Leaves if NewL() leaves.
+@return a new CDirCtDisconnect or CDirCtScanScript object.
+*/
+	{
+	if(!aContinue)
+		{
+		return CDirCtDisconnect::NewL(*iSMObserver,*iNdEnv);
+		}
+	else  //Usual SM route. If no connection cancel next state scans the script
+		{
+		if (((iNdEnv->BaseEnv())->IsReconnect()) && (iNdEnv->Script()!=NULL))
+			{
+			return CDirCtReConfigureCommPort::NewL(*iSMObserver,*iNdEnv,ETrue);
+			}
+		else
+			{
+			return CDirCtOpenDataPort::NewL(*iSMObserver,*iNdEnv);
+			}
+		}
+	}
+
+void CDirCtInit::DoCancel()
+/**
+Cancels active requests.
+*/
+	{
+	}
+
+void CDirCtInit::RunL()
+/**
+Direct connection init completed.
+Call CompleteState() with KErrNone.
+*/
+	{
+	__ASSERT_DEBUG(iStatus==KErrNone, User::Invariant());	// should just have come from JumpToRunl(KErrNone)
+	(iNdEnv->BaseEnv())->CompleteState(KErrNone);
+	}
+
+CDirCtScanScript* CDirCtScanScript::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection Scan Script State
+
+2 phased constructor for CDirCtScanScript, 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 CDirCtScanScript object.
+*/
+	{
+	CDirCtScanScript* r=new(ELeave) CDirCtScanScript(aSMObserver, aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtScanScript::CDirCtScanScript(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) 
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv)
+/**
+Private constructor for CDirCtScanScript, 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 CDirCtScanScript::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+CDirCtScanScript::~CDirCtScanScript()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtScanScript::StartState()
+/**
+Scan "login" script for READ command.
+Call UpdateProgress() with EScanningScript and KErrNone.
+Call SetUpScriptL() to setup the script. If call leaves, trap it
+and call JumpToRunl().
+If script should be used, start scanning script and set state active.
+Else call JumpToRunl().
+*/
+	{
+	iSMObserver->UpdateProgress(ECsdScanningScript,KErrNone);
+
+	if (iNdEnv->UseScript())
+		{
+		iStatus=KRequestPending;
+		SetActive();
+		iNdEnv->Script()->Scan(*this);
+		}
+	else
+		{
+		JumpToRunl(KErrNone);
+		}
+	}
+
+CAgentStateBase* CDirCtScanScript::NextStateL(TBool aContinue)
+/**
+Changes to from scan script state to next state.
+If connection is not continued or iStatus is not KErrNone, create disconnect state.
+Else create get login info state.
+
+@param aContinue indicates whether connection should continue.
+@exception Leaves if NewL() leaves.
+@return a new CDirCtDisconnect or CDirCtGetLoginInfo object.
+*/
+	{ 
+	if((!aContinue)||(iStatus!=KErrNone))
+		{
+		return CDirCtCloseDataPort::NewL(*iSMObserver,*iNdEnv,iStatus.Int());
+		}
+	else //succesful run of state
+		{
+		return CDirCtGetLoginInfo::NewL(*iSMObserver,*iNdEnv);
+		}
+	}
+
+void CDirCtScanScript::DoCancel()
+/**
+Cancels active requests.
+*/
+	{	
+	if (iNdEnv->Script()!=NULL)
+		{
+		(iNdEnv->Script())->Cancel();
+		}
+	if (iStatus == KRequestPending)
+		{
+		ScriptFunctionComplete(KErrCancel);
+		}
+	}
+
+void CDirCtScanScript::RunL()
+/**
+Scan completed (should not complete if connection cancelled).
+If there is an error then signal it, otherwise advance the phase to connect.
+Call ServiceStarted() if not a reconnect.
+*/
+	{
+	if(iStatus!=KErrNone)
+		{
+		__FLOG_STMT(_LIT(logString3,"Scan Script");)
+		__FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),KCompletedPhaseLogString(), &logString3(), iStatus.Int());
+		if (iNdEnv->Script()!=NULL)
+			iNdEnv->Script()->CloseScript();
+		iSMObserver->ConnectionComplete(ECsdScannedScript,iStatus.Int());
+		return;
+		}
+
+	iSMObserver->UpdateProgress(ECsdScannedScript,iStatus.Int());
+	if (!(iNdEnv->BaseEnv())->IsReconnect())
+		{
+		__FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),KServiceStartedLogString());
+		}
+	else
+		{			
+		__FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),KServiceStartedReconnLogString());
+		}
+	//iSMObserver->ServiceStarted();
+	(iNdEnv->BaseEnv())->CompleteState(KErrNone);
+	}
+
+void CDirCtScanScript::ScriptFunctionComplete(TInt aError)
+/**
+Script complete. Complete request.
+*/
+	{
+	TRequestStatus* status=&iStatus;
+	User::RequestComplete(status,aError);
+	}
+
+CDirCtGetLoginInfo* CDirCtGetLoginInfo::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection Get Login Info State
+
+2 phased constructor for CDirCtGetLoginInfo, 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 CDirCtInit object.
+*/
+	{
+	CDirCtGetLoginInfo* r=new(ELeave) CDirCtGetLoginInfo(aSMObserver,aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtGetLoginInfo::CDirCtGetLoginInfo(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+	: CGetLoginInfo(aSMObserver,aNdEnv)
+/**
+Private constructor for CDirCtGetLoginInfo, 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 CDirCtGetLoginInfo::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+CDirCtGetLoginInfo::~CDirCtGetLoginInfo()
+/**
+Destructor.
+*/
+	{
+	}
+
+CAgentStateBase* CDirCtGetLoginInfo::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 connect state.
+
+@param aContinue indicates whether connection should continue.
+@exception Leaves if NewL() leaves.
+@return a new CDirCtHangUp or CDirCtConnect object.
+*/
+	{ 
+	if((!aContinue)||(iStatus!=KErrNone))
+		{
+		return CDirCtHangUp::NewL(*iSMObserver,*iNdEnv);
+		}
+	else //succesful run of state
+		{
+		return CDirCtConfigureCommPort::NewL(*iSMObserver,*iNdEnv);
+		}
+	}
+
+CDirCtConnect* CDirCtConnect::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection Connect State
+
+2 phased constructor for CDirCtConnect, 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 CDirCtInit object.
+*/
+	{
+	CDirCtConnect* r=new(ELeave) CDirCtConnect(aSMObserver, aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtConnect::CDirCtConnect(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) 
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv)
+/**
+Private constructor for CDirCtConnect, 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 CDirCtConnect::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+CDirCtConnect::~CDirCtConnect()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtConnect::StartState()
+/**
+Starts direct connection connect state.
+Call UpdateProgress() with ECsdStartingConnect and KErrNone.
+Configure comm port and execute script.
+*/
+	{
+	TRAPD(ret,DoStartStateL());
+	if (ret!=KErrNone)
+		JumpToRunl(ret);
+	}
+
+CAgentStateBase* CDirCtConnect::NextStateL(TBool aContinue)
+/**
+Changes to from connect state to next state.
+If connection is not continued or iStatus is not KErrNone, create hangup state.
+Else create open state.
+
+@param aContinue indicates whether connection should continue.
+@exception Leaves if NewL() leaves.
+@return a new CDirCtHangUp or CDirCtOpen object.
+*/
+	{
+	if((!aContinue)||(iStatus!=KErrNone))
+		{
+		return CDirCtHangUp::NewL(*iSMObserver,*iNdEnv);
+		}
+	else
+		{
+		return CDirCtOpen::NewL(*iSMObserver,*iNdEnv);
+		}
+	}
+
+void CDirCtConnect::DoCancel()
+/**
+Cancels active requests and calls ScriptFunctionComplete() with KErrCancel.
+*/
+	{
+	if (iNdEnv->Script()!=NULL)
+		{
+		(iNdEnv->Script())->Cancel();
+		}
+	if (!IsActive())
+		SetActive();
+	ScriptFunctionComplete(KErrCancel);
+	}
+
+void CDirCtConnect::RunL()
+/**
+Connect completed (should not complete if connection cancelled).
+If there is an error then signal it.
+Call UpdateProgress() with ECsdFinishedConnect and KErrNone.
+Call PreventConnectionRetries().
+Complete connect state with KErrNone.
+*/
+	{
+	if(iStatus!=KErrNone)
+		{
+		__FLOG_STMT(_LIT(logString3,"Execute Script");)
+		__FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),KCompletedPhaseLogString(), &logString3(), iStatus.Int());
+		if (iNdEnv->Script()!=NULL)
+			iNdEnv->Script()->CloseScript();
+		iSMObserver->ConnectionComplete(ECsdFinishedConnect,iStatus.Int());
+		return;
+		}
+	
+	iSMObserver->UpdateProgress(ECsdFinishedConnect,KErrNone);
+	iSMObserver->PreventConnectionRetries();
+	(iNdEnv->BaseEnv())->CompleteState(KErrNone);
+	}
+
+void CDirCtConnect::ScriptFunctionComplete(TInt aError)
+/**
+Completes direct connect state with aError parameter.
+
+@param aError is error code to be used with request completition.
+*/
+	{
+	TRequestStatus* status=&iStatus;
+	User::RequestComplete(status,aError);
+	}
+
+void CDirCtConnect::DoStartStateL()
+/**
+Executes script if used.  If script is not used, calls JumpToRunl() with KErrNone.
+
+@exception Leaves if ExecuteL() leaves.
+*/
+	{
+	if (iNdEnv->UseScript())
+		{
+		__FLOG_STMT(_LIT8(logString,"NetDial:\tExecuting Script");)
+		__FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),logString());
+
+		(iNdEnv->Script())->ExecuteL(*this);
+		iStatus=KRequestPending;
+		SetActive();
+		}
+	else
+		{
+		JumpToRunl(KErrNone);
+		}
+	}
+
+CDirCtOpen* CDirCtOpen::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection Open State
+
+2 phased constructor for CDirCtOpen, 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 CDirCtInit object.
+*/
+	{
+	CDirCtOpen* r=new(ELeave) CDirCtOpen(aSMObserver, aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtOpen::CDirCtOpen(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) 
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv)
+/**
+Private constructor for CDirCtOpen, 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 CDirCtOpen::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+CDirCtOpen::~CDirCtOpen()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtOpen::StartState()
+/**
+Starts direct connection open state.
+Calls JumpToRunl. When connection completed, tell NifMan.
+*/
+	{
+	JumpToRunl(KErrNone);
+	}
+
+CAgentStateBase* CDirCtOpen::NextStateL(TBool /*aContinue*/)
+/**
+Jumps to direct init or hangup state.
+If there should be reconnection, create init state.
+Else create hangup state.
+
+@param aContinue not used.
+@exception Leaves if NewL() leaves.
+@return a new CDirCtInit or CDirCtHangUp object.
+*/
+	{
+	if((iNdEnv->BaseEnv())->IsReconnect())
+		{
+		return CDirCtInit::NewL(*iSMObserver,*iNdEnv);
+		}
+	else
+		{
+		return CDirCtHangUp::NewL(*iSMObserver, *iNdEnv);
+		}
+	}
+
+void CDirCtOpen::DoCancel()
+/**
+Cancels active requests.
+*/
+	{
+	}
+
+void CDirCtOpen::RunL()
+/**
+Direct connection open completed.
+Call UpdateProgress() with ECsdConnectionOpen and KErrNone.
+If script is used, close script.
+*/
+	{
+	__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);
+	}
+
+CDirCtHangUp* CDirCtHangUp::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection HangUp State
+
+2 phased constructor for CDirCtHangUp, 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 CDirCtInit object.
+*/
+	{
+	CDirCtHangUp* r=new(ELeave) CDirCtHangUp(aSMObserver, aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+ 
+CDirCtHangUp::CDirCtHangUp(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv)
+/**
+Private constructor for CDirCtHangUp, 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.
+*/
+	{}
+
+CDirCtHangUp::~CDirCtHangUp()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtHangUp::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+void CDirCtHangUp::StartState()
+/**
+Starts direct connection hangup state.
+Call UpdateProgress() with ECsdStartingHangUp and KErrNone.
+Hang-up - just drop DTR.
+Calls JumpToRunl.
+Only need this to be asynchronous for PPP else we could do a synchronous disconnect.
+*/
+	{
+	iSMObserver->UpdateProgress(ECsdStartingHangUp,KErrNone);
+	iStatus = KRequestPending;
+	SetActive();
+	(iNdEnv->Script())->DropDTR(&iStatus);
+	}
+
+CAgentStateBase* CDirCtHangUp::NextStateL(TBool /*aContinue*/)
+/**
+Next state from hangup will always be CDirCtDisconnect
+
+@exception Leaves if NewL() leaves.
+@return a new CDirCtDisconnect object.
+*/
+	{
+	return CDirCtReConfigureCommPort::NewL(*iSMObserver,*iNdEnv,EFalse);
+	}
+
+void CDirCtHangUp::DoCancel()
+/**
+Cancels active requests.
+*/
+	{
+	}
+
+void CDirCtHangUp::RunL()
+/**
+Direct connection hangup completed.
+Call UpdateProgress() with ECsdFinishedHangUp and KErrNone.
+Complete hangup state.
+*/
+	{
+	__FLOG_STMT(_LIT(logString3,"Hang Up");)
+	if(iStatus!=KErrNone)
+		{
+		__FLOG_STMT(_LIT8(logString2,"NetDial:\tDisconnection Error %d");)
+		__FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue<const TDesC>(KCompletedPhaseLogString()), &logString3(), iStatus.Int());
+		__FLOG_STATIC1(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue<const TDesC8>(logString2()), iStatus.Int());
+		}
+	__FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),logString3());
+	iSMObserver->UpdateProgress(ECsdFinishedHangUp,iStatus.Int());
+	(iNdEnv->BaseEnv())->CompleteState(iStatus.Int());
+	}
+
+CDirCtDisconnect* CDirCtDisconnect::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection Disconnect State
+
+2 phased constructor for CDirCtDisconnect, 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 CDirCtInit object.
+*/
+	{
+	CDirCtDisconnect* r=new(ELeave) CDirCtDisconnect(aSMObserver, aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtDisconnect::CDirCtDisconnect(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) 
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv)
+/**
+Private constructor for CDirCtDisconnect, 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.
+*/
+	{}
+
+CDirCtDisconnect::~CDirCtDisconnect()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtDisconnect::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+void CDirCtDisconnect::StartState()
+/**
+Starts direct connection disconnect state.
+If script is used, clean up script.
+Calls JumpToRunl().
+*/
+	{
+	if ((iNdEnv->Script())!=NULL)
+		(iNdEnv->Script())->CleanupScript();
+	JumpToRunl(KErrNone);
+	}
+
+CAgentStateBase* CDirCtDisconnect::NextStateL(TBool /*aContinue*/)
+/**
+Returns the same disconnect state.
+
+@exception Leaves if NewL() leaves.
+@return a new CDirCtDisconnect object.
+*/
+	{
+	return CDirCtDisconnect::NewL(*iSMObserver,*iNdEnv);
+	}
+
+void CDirCtDisconnect::DoCancel()
+/**
+Cancels active requests.
+*/
+	{
+	}
+
+void CDirCtDisconnect::RunL()
+/**
+Direct connection disconnect completed.
+If script is used, call ReConfigureAndCancelCommPort().
+Call DisconnectComplete().
+*/
+	{
+	__FLOG_STMT(_LIT8(logString,"NetDial:\tDisconnect Complete");)
+	__FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),logString());
+
+	iSMObserver->DisconnectComplete();
+	}
+
+CDirCtOpenDataPort* CDirCtOpenDataPort::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection Open Data Port State
+
+@exception Leaves if NewL() leaves.
+@return a new CDirCtOpenDataPort object.
+*/
+	{
+	CDirCtOpenDataPort* r=new(ELeave) CDirCtOpenDataPort(aSMObserver,aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtOpenDataPort::CDirCtOpenDataPort(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv)
+/**
+Private constructor for CDirCtOpenDataPort, 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 CDirCtOpenDataPort::ConstructL()
+/**
+Instantiate Member variable.
+Call base class CNdCallBackStateBase::ConstructL().
+
+@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available.
+*/
+	{
+	}
+
+CDirCtOpenDataPort::~CDirCtOpenDataPort()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtOpenDataPort::StartState()
+/**
+Starts direct connection open data port state.
+If script is used, clean up script.
+Initiate creation of data port channel.
+Call JumpToRunl() with KErrNone.
+*/
+	{
+	ASSERT(iNdEnv);
+	TRAPD(ret,iNdEnv->SetUpScriptL());
+	if (ret!=KErrNone)
+		{
+		JumpToRunl(ret);
+		return;
+		}
+
+	iStatus = KRequestPending;
+	SetActive();
+	iNdEnv->Script()->CreateChannel(iStatus);
+	}
+
+CAgentStateBase* CDirCtOpenDataPort::NextStateL(TBool aContinue)
+/**
+Changes to to next state.  Next state depends on whether open data
+port was successful and whether connection start has been cancelled
+or not (aContinue).
+*/
+	{
+	if (iStatus != KErrNone)
+		{
+		// Open unsuccessful
+		return CDirCtDisconnect::NewL(*iSMObserver,*iNdEnv);
+		}
+	else
+	if (!aContinue)
+		{
+		// Open successful, but connect shouldn't continue.
+		return CDirCtCloseDataPort::NewL(*iSMObserver,*iNdEnv, KErrNone);
+		}
+	else
+		{
+		// Open successful, connect should continue
+		return CDirCtScanScript::NewL(*iSMObserver, *iNdEnv);
+		}
+	}
+
+void CDirCtOpenDataPort::DoCancel()
+/**
+Cancels active requests.
+*/
+	{
+	iNdEnv->Script()->CancelCreateChannel();
+	}
+
+void CDirCtOpenDataPort::RunL()
+/**
+Open data port completed.
+Call CompleteState() with any error.
+*/
+	{
+	(iNdEnv->BaseEnv())->CompleteState(iStatus.Int());
+	}
+
+//
+// CDirCtConfigureCommPort
+//
+
+CDirCtConfigureCommPort* CDirCtConfigureCommPort::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv)
+/**
+Direct Connection Configure Comm Port State
+
+2 phased constructor for CDirCtConfigureCommPort, 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 CDirCtInit object.
+*/
+	{
+	CDirCtConfigureCommPort* r=new(ELeave) CDirCtConfigureCommPort(aSMObserver, aNdEnv);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtConfigureCommPort::CDirCtConfigureCommPort(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv) 
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv)
+/**
+Private constructor for CDirCtConfigureCommPort, 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 CDirCtConfigureCommPort::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+CDirCtConfigureCommPort::~CDirCtConfigureCommPort()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtConfigureCommPort::StartState()
+/**
+Starts direct connection configure comm port state.
+Call UpdateProgress() with ECsdStartingConnect and KErrNone.
+Initiate asynchronous configuration of data port.
+*/
+	{
+	iSMObserver->UpdateProgress(ECsdStartingConnect,KErrNone);
+	TRAPD(ret,DoStartStateL());
+	if (ret!=KErrNone)
+		{
+		__FLOG_STMT(_LIT8(logString, "NetDial:\tError %d Configuring Comm Port");)
+		__FLOG_STATIC1(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue<const TDesC8>(logString()), ret);
+		JumpToRunl(ret);
+		}
+	}
+
+CAgentStateBase* CDirCtConfigureCommPort::NextStateL(TBool aContinue)
+/**
+Changes to from configure comm port state to next state.
+If connection is not continued or iStatus is not KErrNone, create hangup state.
+Else create connect state.
+
+@param aContinue indicates whether connection should continue.
+@exception Leaves if NewL() leaves.
+@return a new CDirCtHangUp or CDirCtConnect object.
+*/
+	{
+	if((!aContinue) || (iStatus!=KErrNone))
+		{
+		return CDirCtHangUp::NewL(*iSMObserver,*iNdEnv);
+		}
+	else
+		{
+		return CDirCtConnect::NewL(*iSMObserver,*iNdEnv);
+		}
+	}
+
+void CDirCtConfigureCommPort::DoCancel()
+/**
+Cancels active requests
+*/
+	{
+	__FLOG_STMT(_LIT8(logString, "NetDial:\tCancel Configure Comm Port");)
+	__FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),TRefByValue<const TDesC8>(logString()));
+
+	(iNdEnv->Script())->CancelConfigureCommPort();
+	}
+
+void CDirCtConfigureCommPort::RunL()
+/**
+Configure comm port completed (should not complete if connection cancelled).
+If there is an error then close script and signal it.
+Complete configure comm port state with KErrNone.
+*/
+	{
+	if(iStatus!=KErrNone)
+		{
+		__FLOG_STMT(_LIT(logString3,"Configuring Comm Port");)
+		__FLOG_STATIC2(KNetDialLogFolder(),KNetDialLogFile(),KCompletedPhaseLogString(), &logString3(), iStatus.Int());
+		if (iNdEnv->Script()!=NULL)
+			iNdEnv->Script()->CloseScript();
+		iSMObserver->ConnectionComplete(ECsdFinishedConnect,iStatus.Int());
+		return;
+		}
+	
+	(iNdEnv->BaseEnv())->CompleteState(KErrNone);
+	}
+
+void CDirCtConfigureCommPort::DoStartStateL()
+/**
+Retrieves Comm Port configuration parameters from CommsDat and initiates configuration.
+
+@exception Leaves if GetCommConfigForDirectConnectL() leaves.
+*/
+	{
+	__FLOG_STMT(_LIT8(logString1,"NetDial:\tConfiguring Comm Port");)
+	__FLOG_STATIC(KNetDialLogFolder(),KNetDialLogFile(),logString1());
+	(iNdEnv->NetDialDb())->GetCommConfigForDirectConnectL(iConfigPckg);
+
+	iStatus = KRequestPending;
+	SetActive();
+	(iNdEnv->Script())->ConfigureCommPort(iStatus, iConfigPckg);
+	}
+
+//
+// CDirCtReConfigureCommPort
+//
+
+CDirCtReConfigureCommPort* CDirCtReConfigureCommPort::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv, TBool aReConnect)
+/**
+Direct Connection ReConfigure Comm Port State
+2 phased constructor for CDirCtReConfigureCommPort, 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 CDirCtReConfigureCommPort object.
+*/
+	{
+	CDirCtReConfigureCommPort* r=new(ELeave) CDirCtReConfigureCommPort(aSMObserver, aNdEnv, aReConnect);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtReConfigureCommPort::CDirCtReConfigureCommPort(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv, TBool aReConnect)
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv),iReConnect(aReConnect)
+/**
+Private constructor for CDirCtReConfigureCommPort, 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 CDirCtReConfigureCommPort::ConstructL()
+/**
+Instantiate Member variable.
+*/
+	{}
+
+CDirCtReConfigureCommPort::~CDirCtReConfigureCommPort()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtReConfigureCommPort::StartState()
+/**
+Starts direct connection reconfigure comm port state.
+Reconfigure port to allow signals to be dropped.
+*/
+	{
+	__FLOG_STMT(_LIT8(logString, "NetDial:\tReconfiguring Comm Port");)
+	__FLOG_STATIC(KNetDialLogFolder(), KNetDialLogFile(), logString());
+	iStatus = KRequestPending;
+	SetActive();
+	// Reconfigure the Comm Port to allow the signals to be set.
+	(iNdEnv->Script())->ReConfigureAndCancelCommPort(iStatus);
+	}
+
+CAgentStateBase* CDirCtReConfigureCommPort::NextStateL(TBool aContinue)
+/**
+Changes to from reconfigure comm port state to next state.
+If not a reconnection, create close data port state.
+Else create disconnect or open data port state depending on whether
+connection startup has been cancelled or not.
+
+@exception Leaves if NewL() leaves.
+@return a new CDirCtDisconnect, CDirCtOpenDataPort or CDirCtCloseDataPort object.
+*/
+	{
+	if (iReConnect)
+		{
+		if(!aContinue)
+			{
+			return CDirCtDisconnect::NewL(*iSMObserver,*iNdEnv);
+			}
+		else
+			{
+			return CDirCtOpenDataPort::NewL(*iSMObserver,*iNdEnv);
+			}
+		}
+	else
+		{
+		// Don't treat errors in this state as fatal.  KErrCompletion is a (simple but hacky) way to prevent
+		// CDirCtCloseDataPort from issuing a ConnectionComplete() if it fails (we have already issued
+		// a ConnectionComplete(), and a second one will cause a NIFMAN panic).
+		return CDirCtCloseDataPort::NewL(*iSMObserver,*iNdEnv,KErrCompletion);
+		}
+	}
+
+void CDirCtReConfigureCommPort::DoCancel()
+/**
+Cancels active requests.
+*/
+	{
+	// Used to cancel both ReConfigureAndCancelCommPort() and DropSignals()
+	if (iNdEnv->Script())
+		{
+		(iNdEnv->Script())->CancelConfigureCommPort();
+		}
+	}
+
+void CDirCtReConfigureCommPort::RunL()
+/**
+Direct connection reconfigure comm port completed.
+Call CompleteState() with KErrNone.
+*/
+	{
+	// Note: we aren't acting on errors here as it may be worth continuing even if we can't configure the
+	// Comm Port or drop the control signals.  The configuration here is only to allow the control signals
+	// to drop, not to set up the final Comm Port properly.  The final Comm Port configuration will take
+	// place in CDirCtConfigureCommPort.
+	if (!iDropping)
+		{
+		// ReConfigureAndCancelCommPort() has completed to allow us to drop the Comm Port signals.
+		__FLOG_STMT(_LIT8(logString, "NetDial:\tDropping Signals");)
+		__FLOG_STATIC(KNetDialLogFolder(), KNetDialLogFile(), logString());
+
+		iDropping = ETrue;
+		iStatus = KRequestPending;
+		SetActive();
+		(iNdEnv->Script())->DropSignals(iStatus);
+		return;			// don't advance to the next state before when DropSignals() completes
+		}
+	else
+		{
+		// DropSignals() has completed, so delete the script (for reconnects) and move to the next state.
+		if (iReConnect)
+			{
+			iNdEnv->DeleteScript();
+			}
+		}
+	(iNdEnv->BaseEnv())->CompleteState(KErrNone);
+	}
+
+//
+// CDirCtCloseDataPort
+//
+
+CDirCtCloseDataPort* CDirCtCloseDataPort::NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv, TInt aError)
+/**
+Direct Connection Close Data Port State
+*/
+	{
+	CDirCtCloseDataPort* r=new(ELeave) CDirCtCloseDataPort(aSMObserver,aNdEnv, aError);
+	CleanupStack::PushL(r);
+	r->ConstructL();
+	CleanupStack::Pop();
+	return r;
+	}
+
+CDirCtCloseDataPort::CDirCtCloseDataPort(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv, TInt aError)
+	: CAgentStateBase(aSMObserver),iNdEnv(&aNdEnv),iError(aError)
+/**
+Private constructor for CDirCtCloseDataPort, 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 CDirCtCloseDataPort::ConstructL()
+/**
+Instantiate Member variable.
+Call base class CNdCallBackStateBase::ConstructL().
+
+@exception Leaves if CNdCallBackStateBase::ConstructL() leaves, or not enough memory is available.
+*/
+	{
+	}
+
+CDirCtCloseDataPort::~CDirCtCloseDataPort()
+/**
+Destructor.
+Cancel active request.
+*/
+	{
+	Cancel();
+	}
+
+void CDirCtCloseDataPort::StartState()
+/**
+Starts direct connection close data port state.
+Initiate shutdown of data port.
+Call JumpToRunl() with KErrNone.
+*/
+	{
+	ASSERT(iNdEnv);
+	ASSERT (iNdEnv->Script());
+	iStatus = KRequestPending;
+	SetActive();
+	iNdEnv->Script()->ShutdownChannel(iStatus);
+	}
+
+CAgentStateBase* CDirCtCloseDataPort::NextStateL(TBool /*aContinue*/)
+/**
+Changes to from close data port state to next state.
+Next State will always be Disconnect regardless of implementation results.
+
+@exception Leaves if NewL() leaves.
+@return a new CDirCtCloseDataPort object.
+*/
+	{
+	return CDirCtDisconnect::NewL(*iSMObserver,*iNdEnv);
+	}
+
+void CDirCtCloseDataPort::DoCancel()
+/**
+Cancels active requests.
+*/
+	{
+	}
+
+void CDirCtCloseDataPort::RunL()
+/**
+Direct Connection close data port completed.
+Call CompleteState() with KErrNone.
+*/
+	{
+	// Note: we assume that if iError != KErrNone then ConnectionComplete(error) or CompleteState(error) 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()).  Consequently, we can't call either method with an error argument
+	// for a second time (otherwise NIFMAN will panic due to too many ConnectComplete() responses).
+	if (iStatus!=KErrNone)
+		{
+#ifdef __FLOG_ACTIVE
+		_LIT(logString3,"Close Data Port");
+		_LIT8(logstring2,"Saved error = %d");
+#endif
+		__FLOG_STATIC2(KNetDialLogFolder(), KNetDialLogFile(), TRefByValue<const TDesC>(KCompletedPhaseLogString()), &logString3(), iStatus.Int());
+		if (iError != KErrNone)
+			{
+			__FLOG_STATIC1(KNetDialLogFolder(), KNetDialLogFile(), TRefByValue<const TDesC8>(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);
+	}
+