// Copyright (c) 2005-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 "SS_conn.H"

#include "ss_connstates.h"

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_coreprstates.h>

#include <comms-infras/ss_corepractivities.h>

#include "ss_subconn.h"

#include <comms-infras/ss_mcprnodemessages.h>

#include <elements/sm_core.h>

#include <commdbconnpref.h> //TCommDbConnPref

#include <ss_glob.h> //TCommDbConnPref

#include <connpref.h> //TConnPrefList

#include <etelpckt.h>

#include <comms-infras/metadata.h>

#include <comms-infras/esock_params.h> //TConnAPPref

#include <comms-infras/esock_params_internal.h> //TConnCSRPref

#include <comms-infras/es_connectionservparameterbundle.h> // CConnectionServParameterBundle

#include <comms-infras/es_accesspointstatus.h> // TAccessPointStatusFilter

#include <comms-infras/cs_connservparams.h> // XAccessPointGenericParameterSet

#include <comms-infras/cs_connservparams_internal.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_enum_internal.h>

#include <nifvar_internal.h>

#endif

#include <elements/nm_messages_child.h>

#include <elements/nm_messages_peer.h>

#include <comms-infras/ss_nodemessages_dataclient.h>

#include <comms-infras/ss_nodemessages_legacy.h>

#include <comms-infras/ss_nodemessages_tiermanager.h>

#include <comms-infras/ss_nodemessages_serviceprovider.h>

#include <comms-infras/ss_nodemessages_internal_esock.h>

#include <comms-infras/ss_nodemessages_selector.h>

#include <comms-infras/ss_nodemessages_factory.h>

#include <comms-infras/ss_nodemessages_tiermanagerfactory.h>

#define SYMBIAN_NETWORKING_UPS

#ifdef SYMBIAN_NETWORKING_UPS

#include <comms-infras/ss_upsaccesspointconfigext.h>

#include <comms-infras/upsmessages.h>

#endif

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockSSockscnsts, "ESockSSockscnsts");

#endif

using namespace ESock;

using namespace SubSessActivities;

using namespace NetStateMachine;

using namespace ConnStates;

using namespace ConnActivities;

using namespace ConnectionServ;

using namespace Elements;

using namespace Messages;

using namespace MeshMachine;

//#ifdef LOG

//	#define KESockActivityTag KESockCoreProviderTag

//	_LIT8(KESockActivitySubTag, "esockactivity");

//#endif

_LIT (KCConnectionPanic,"CConnectionPanic");

void ConnPanic(TInt aCode)

	{

	User::Panic(KCConnectionPanic, aCode);

	}

//

//Start

DEFINE_SMELEMENT(ConnStates::TErrorIfAlreadyStartedAttached, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TErrorIfAlreadyStartedAttached::DoL()

	{

	__ASSERT_DEBUG((subsessmessage_cast<ECNStart>(&iContext.iMessage))

		|| (subsessmessage_cast<ECNAttach>(&iContext.iMessage)),

			ConnPanic(KPanicIncorrectMessage));

	RNodeInterface* sp = iContext.Node().ServiceProvider();

	User::LeaveIfError(sp? KErrAlreadyExists : KErrNone);

	}

DEFINE_SMELEMENT(ConnStates::TParseECNStart, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TParseECNStart::DoL()

	{

	__ASSERT_DEBUG((subsessmessage_cast<ECNStart>(&iContext.iMessage)), ConnPanic(KPanicIncorrectMessage));

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	ConnActivities::CStartAttachActivity& ac = static_cast<ConnActivities::CStartAttachActivity&>(*iContext.iNodeActivity);

    if (ac.Function() == ECNSetStartPrefs)

    	{

        //Extract preferences if ECNSetStartPrefs

    	TConnPref prefs;

		ac.ReadL(0, prefs);

   		if(prefs.ExtensionId() != TConnPref::EConnPrefEComList)

  			{

  			ac.SelectionPrefs().SetPrefs(prefs);

  			}

  		else

  			{

  			RBuf8 buffer;

  			TInt length = ac.GetDesLengthL(0);

  			buffer.CreateL(length);

  			CleanupClosePushL(buffer);

  			ac.ReadL(0, buffer);

  			TConnPrefList* prefsList = TConnPrefList::NewL();

  			CleanupStack::PushL(prefsList);

  			TPtrC8 ptr(buffer);

  			TInt ret = prefsList->Load(ptr);

  			User::LeaveIfError(ret);

  			//This loop is used to check that there is no more than 1 instance

  			//of TConnAPPref in the list passed to the CSR. This is not allowed

  			//(as it may have adverse effects in the construction of the stack)

  			//KErrArugment is returned if there is more than 1 instance present

  			TInt instances = 0;

  			for(TInt i=0; i<prefsList->Count(); i++)

  				{

  				TConnAPPref* pref = smetadata_cast<TConnAPPref>((*prefsList)[i]);

  				if(pref)

  				    {

  					instances++;

  				    }

  				}

  			if(instances > 1)

  			    {

  				User::Leave(KErrArgument);

  			    }

  			TConnCSRPref* csr = TConnCSRPref::NewL();

  			CleanupStack::PushL(csr);

  			ac.SetCSRPreferences(csr);

  			csr->SetScope(TSelectionPrefs::EExplicitConnection);

  			prefsList->AppendL(csr);

  			ac.SelectionPrefs().SetPrefs(*prefsList);

    		ac.SetConnPrefList(prefsList);

    		CleanupStack::Pop(csr);

    		CleanupStack::Pop(prefsList);

    		CleanupStack::PopAndDestroy(&buffer);

    		}

		// Complete the ECNSetStartPrefs, activity will be held until the 2nd IPC of the Start with Prefs

   		// call is received. Null iSubSession so that the 2nd IPC can be aquired by the activity.

   		ac.iMessage.Complete(KErrNone);

   		ac.iSubSession = NULL;

		}

    else

        {

		ac.iStartReceived = ETrue;

        ac.SetSelectionScope(TSelectionPrefs::EExplicitConnection);

        }

	}

DEFINE_SMELEMENT(ConnStates::TSendStartingSelectionStateChange, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TSendStartingSelectionStateChange::DoL()

	{

	//Send the relevant progress (don't use ReceivedL or you will warp), also use Null Activity id.

	RNodeInterface::OpenPostMessageClose(iContext.NodeId(), iContext.NodeId(), TCFMessage::TStateChange(TStateChange(KStartingSelection,KErrNone)).CRef());

	}

DEFINE_SMELEMENT(ConnStates::TClearProgressQueue, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TClearProgressQueue::DoL()

	{

	iContext.Node().iProgressQueue.Reset();		// clear progress notification cache

	iContext.Node().ResetLastProgressError();	// clear last progress in error

	// Initialise iLastProgress with an invalid progress rather than 0 (which is actually KConnectionUninitialised)

	// otherwise we can end up unintentionally filtering out a KConnectionUninitialised progress.

	const TInt KInvalidProgress = -1;

	iContext.Node().iLastProgress = TStateChange(KInvalidProgress, 0);

	iContext.Node().iLastProgressError = TStateChange();

	}

DEFINE_SMELEMENT(ConnStates::TRequestCSRCreation, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TRequestCSRCreation::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	__ASSERT_DEBUG(static_cast<ConnActivities::CStartAttachActivity&>(*iContext.iNodeActivity).CSR().IsNull(), ConnPanic(KPanicExpectedNoCSR));

	iContext.iNodeActivity->PostRequestTo(SockManGlobals::Get()->GetPlaneFC(TCFPlayerRole(TCFPlayerRole::ETierMgrPlane)), TCFInternalEsock::TCreateCSR(iContext.Node().iTierId).CRef(), EFalse);

	}

DEFINE_SMELEMENT(ConnStates::TProcessCSRCreation, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TProcessCSRCreation::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	ConnActivities::CStartAttachActivity& ac = static_cast<ConnActivities::CStartAttachActivity&>(*iContext.iNodeActivity);

	__ASSERT_DEBUG(ac.CSR().IsNull(), User::Panic(KSpecAssert_ESockSSockscnsts, 1));

	ac.SetCSR(message_cast<TCFInternalEsock::TCSRCreated>(iContext.iMessage).iNodeId);

	RNodeInterface::OpenPostMessageClose(TNodeCtxId(iContext.ActivityId(), iContext.NodeId()), ac.CSR(),

		TCFMessage::TProvisionConnectionInfo(iContext.Node().ConnectionInfo()).CRef());

	}

DEFINE_SMELEMENT(ConnStates::TSelectMetaPlane, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TSelectMetaPlane::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	ConnActivities::CStartAttachActivity& ac = static_cast<ConnActivities::CStartAttachActivity&>(*iContext.iNodeActivity);

    //Diagnostic only. If attach then it must be ESelectFromExisting

    __ASSERT_DEBUG(!iContext.Node().IsMonitor()

    	|| ac.SelectionPrefs().Scope() & TSelectionPrefs::ESelectFromExisting, User::Panic(KSpecAssert_ESockSSockscnsts, 2));

	if(ac.SelectionPrefs().Prefs().ExtensionId() != TConnPref::EConnPrefEComList)

		{

		ac.SelectionPrefs().SetSubSessionUniqueId(iContext.Node().UniqueId());

		iContext.iNodeActivity->PostRequestTo(

			ac.CSR(),

			TCFSelector::TSimpleSelect(ac.SelectionPrefs()).CRef()

			);

		}

	else

		{

		ac.CSRPreferences()->SetSubSessionUniqueId(iContext.Node().UniqueId());

		RConnPrefList handle;

		handle.Open(ac.ConnPrefList());

		iContext.iNodeActivity->PostRequestTo(

			ac.CSR(),

			TCFSelector::TSelect(handle).CRef()

			);

		}

	}

DEFINE_SMELEMENT(ConnStates::TSendFinishedSelectionStateChange, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TSendFinishedSelectionStateChange::DoL()

	{

	//Send the relevant progress (don't use ReceivedL or you will warp), also use Null Activity id.

	RNodeInterface::OpenPostMessageClose(TNodeCtxId(iContext.ActivityId(), iContext.NodeId()), iContext.NodeId(),

		TCFMessage::TStateChange(TStateChange(KFinishedSelection,KErrNone)).CRef());

	}

DEFINE_SMELEMENT(ConnStates::TJoinReceivedSCpr, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TJoinReceivedSCpr::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	__ASSERT_DEBUG(iContext.iPeer == iContext.Node().ServiceProvider(), ConnPanic(KPanicExpectedNoServiceProvider));

	TCFServiceProvider::TCommsBinderResponse& br = message_cast<TCFServiceProvider::TCommsBinderResponse>(iContext.iMessage);

    RNodeInterface* scpr = iContext.Node().AddClientL(br.iNodeId, TClientType(TCFClientType::EServProvider, TCFClientType::EDefault));

    //If this is attach, we need to see if we are a monitor or not

    TCFClientType clientType(TCFClientType::ECtrl);

    TUint selPrefs = static_cast<ConnActivities::CStartAttachActivity&>(*iContext.iNodeActivity).SelectionPrefs().Flags();

    if (selPrefs & TSelectionPrefs::EMonitor)

    	{

		clientType.SetFlags(TCFClientType::EMonitor);

    	}

	// If it is an attach set the flag cause it is used by NetUPS to check if a JoinRequest comes from an RConnection::Attach

	if (selPrefs & TSelectionPrefs::EAttach)

    	{

		clientType.SetFlags(TCFClientType::EAttach);

    	}

    iContext.iNodeActivity->PostRequestTo(*scpr,

    	TCFServiceProvider::TJoinRequest(iContext.NodeId(), clientType).CRef());

	}

DEFINE_SMELEMENT(ConnStates::TJoinReceivedMcpr, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TJoinReceivedMcpr::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	__ASSERT_DEBUG(iContext.Node().ServiceProvider()==NULL, ConnPanic(KPanicExpectedNoServiceProvider));

	TCFSelector::TSelectComplete& sc = message_cast<TCFSelector::TSelectComplete>(iContext.iMessage);

	RNodeInterface* mcpr = iContext.Node().AddClientL(sc.iNodeId,TClientType(TCFClientType::EServProvider, TCFClientType::EAvailabilityProvider));

	iContext.iNodeActivity->PostRequestTo(*mcpr,

		TCFServiceProvider::TJoinRequest(iContext.NodeId(), TCFClientType(TCFClientType::ECtrl)).CRef());

	}

DEFINE_SMELEMENT(ConnStates::TRequestCommsBinder, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TRequestCommsBinder::DoL()

	{

    __ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

    RNodeInterface* sp = iContext.Node().ServiceProvider();

    __ASSERT_DEBUG(sp, ConnPanic(KPanicNoServiceProvider));

    iContext.iNodeActivity->PostRequestTo(*sp,

    	TCFServiceProvider::TCommsBinderRequest(TSubConnOpen::EAttachToDefault).CRef());

	}

DEFINE_SMELEMENT(ConnStates::TRequestCommsBinderFromMcpr, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TRequestCommsBinderFromMcpr::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	TClientIter<TDefaultClientMatchPolicy> iter = iContext.Node().GetClientIter<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EServProvider, TCFClientType::EAvailabilityProvider));

	RNodeInterface* mcpr = iter[0];

	__ASSERT_DEBUG(mcpr, ConnPanic(KPanicNoAvailabilityProvider));

	iContext.iNodeActivity->PostRequestTo(*mcpr,

		TCFServiceProvider::TCommsBinderRequest().CRef());

	}

DEFINE_SMELEMENT(ConnStates::TProcessBinderResponseForCpr, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TProcessBinderResponseForCpr::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	__ASSERT_DEBUG(iContext.Node().ServiceProvider()==NULL, ConnPanic(KPanicExpectedNoServiceProvider));

	TCFServiceProvider::TCommsBinderResponse& br = message_cast<TCFServiceProvider::TCommsBinderResponse>(iContext.iMessage);

	RNodeInterface* sp = iContext.Node().AddClientL(br.iNodeId, TClientType(TCFClientType::EServProvider, TCFClientType::EActive));

    __ASSERT_DEBUG(iContext.Node().ServiceProvider()==sp, ConnPanic(KPanicNoServiceProvider)); //[RZ] revise this, possibly overdefensive

	//If this is attach, we need to see if we are a monitor or not

	TCFClientType clientType;

	TUint selPrefs = static_cast<ConnActivities::CStartAttachActivity&>(*iContext.iNodeActivity).SelectionPrefs().Flags();

	if (selPrefs & TSelectionPrefs::EMonitor)

		{

		clientType.SetFlags(TCFClientType::EMonitor);

		iContext.Node().iIsMonitor = ETrue;

		}

	if (selPrefs & TSelectionPrefs::EAttach)

		{

		clientType.SetFlags(TCFClientType::EAttach);

		}

	iContext.iNodeActivity->PostRequestTo(*sp,

		TCFServiceProvider::TJoinRequest(iContext.NodeId(), clientType).CRef());

	}

DEFINE_SMELEMENT(ConnStates::TStartConnection, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TStartConnection::DoL()

	{

	RNodeInterface* cpr = iContext.Node().ServiceProvider();

	__ASSERT_DEBUG(cpr, ConnPanic(KPanicNoServiceProvider));

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

    iContext.iNodeActivity->PostRequestTo(*cpr, TCFServiceProvider::TStart().CRef());

	}

DEFINE_SMELEMENT(ConnStates::TErrorOrCancel, NetStateMachine::MStateFork, ConnStates::TContext)

/**

If the activity has been cancelled, return KCancelTag else return KErrorTag

 */

TInt ConnStates::TErrorOrCancel::TransitionTag()

	{

	if (iContext.Activity()->Error() == KErrCancel)

		{

		return ConnActivities::CStartAttachActivity::KCancelTag;

		}

	else

		{

		__ASSERT_DEBUG(iContext.Activity()->Error() != KErrNone, User::Panic(KSpecAssert_ESockSSockscnsts, 3));		// meant to be called in error conditions only

		return KErrorTag;

		}

	}

//

//Attach

DEFINE_SMELEMENT(ConnStates::TParseECNAttach, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TParseECNAttach::DoL()

	{

	__ASSERT_DEBUG((subsessmessage_cast<ECNAttach>(&iContext.iMessage)), ConnPanic(KPanicIncorrectMessage));

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	ConnActivities::CStartAttachActivity& ac = static_cast<ConnActivities::CStartAttachActivity&>(*iContext.iNodeActivity);

	//Read preferences

	const TUint KMaxConnectionInfoLength = 32;

	TBuf8<KMaxConnectionInfoLength> info;

	ac.ReadL(1,info);

	if (info.Length() < KConnInfoPart)

		{

		User::Leave(KErrArgument);

		}

	TUint monitorMode = (RConnection::TConnAttachType)ac.Int0() == RConnection::EAttachTypeMonitor?

		TSelectionPrefs::EMonitor : 0;

	// The attach flag should always be set since it is used by NetUPS to check if a JoinRequest comes from an RConnection::Attach

	ac.SetSelectionFlags(monitorMode | TSelectionPrefs::EAttach);

	TConnArgBase& connInfo = *((TConnArgBase*)&info[0]);

	if (connInfo.Version() < KConnArgVersion3)

		{

        TConnectionInfo& connI = static_cast<TConnectionInfo&>(connInfo);

        TCommDbConnPref pref;

		pref.SetIapId(connI.iIapId);

    	ac.SelectionPrefs().SetPrefs(pref);

    	ac.SetSelectionScope(TSelectionPrefs::ESelectFromExisting | TSelectionPrefs::EExplicitConnection);

		}

	else

		{

		__ASSERT_DEBUG(connInfo.Version() == KConnArgVersion3, User::Panic(KSpecAssert_ESockSSockscnsts, 4)); //Currently no support for > KConnArgVersion3;

		TConnProviderInfo& provinfo = static_cast<TConnProviderInfo&>(connInfo);

		__ASSERT_DEBUG(iContext.Node().iTierId.iUid == provinfo.iInfo[0], User::Panic(KSpecAssert_ESockSSockscnsts, 5));

    	ac.SelectionPrefs().SetPrefs(TConnProviderInfoPref(provinfo));

    	ac.SetSelectionScope(TSelectionPrefs::ESelectFromExisting);

		}

	}

DEFINE_SMELEMENT(ConnStates::TCompleteLegacyAttach, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TCompleteLegacyAttach::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	iContext.Node().iLegacyConnection.CompleteAttachL(static_cast<ConnActivities::CStartAttachActivity&>(*iContext.iNodeActivity).SelectionPrefs());

	}

//

//WaitForIncoming

DEFINE_SMELEMENT(ConnStates::TRequestIncomingConnection, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TRequestIncomingConnection::DoL()

	{

	__ASSERT_DEBUG((subsessmessage_cast<ECNWaitForIncoming>(&iContext.iMessage)), ConnPanic(KPanicIncorrectMessage));

	RNodeInterface* sp = iContext.Node().ServiceProvider();

	User::LeaveIfError(sp ? KErrNone : KErrNotReady);

    iContext.iNodeActivity->PostRequestTo(*sp,

    	TCFServiceProvider::TCommsBinderRequest(TSubConnOpen::EWaitForIncoming).CRef());

	}

DEFINE_SMELEMENT(ConnStates::TProcessIncomingConnection, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TProcessIncomingConnection::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

    CSubConnection* waitingSubConn = iContext.Node().Session()->CSubConnectionFromHandle(static_cast<CESockClientActivityBase&>(*iContext.iNodeActivity).Int0());

	User::LeaveIfError(waitingSubConn != NULL ? KErrNone : KErrCancel);

    RNodeInterface* waitingSubConnPeer = iContext.Node().FindClient(waitingSubConn->Id()); //To my surprise SC is a peer of this (so must use peer handle when talking to it)

    __ASSERT_DEBUG(waitingSubConnPeer, ConnPanic(KPanicNoDataClient));

    TCFServiceProvider::TCommsBinderResponse& binderResp = message_cast<TCFServiceProvider::TCommsBinderResponse>(iContext.iMessage);

    iContext.iNodeActivity->PostRequestTo(*waitingSubConnPeer,

        TCFDataClient::TBindTo(binderResp.iNodeId).CRef());

	}

//

//Stop

DEFINE_SMELEMENT(ConnStates::TSendStopConnection, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TSendStopConnection::DoL()

	{

	__ASSERT_DEBUG((subsessmessage_cast<ECNStop>(&iContext.iMessage)), ConnPanic(KPanicIncorrectMessage));

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	CESockClientActivityBase& ac = static_cast<CESockClientActivityBase&>(*iContext.iNodeActivity);

	//Convert the received enum (the stop type) into an error code that will be passed to the interface clients

	TInt stopCode = KErrCancel;

	switch (ac.Int0())

		{

		case RConnection::EStopNormal:

			stopCode = KErrCancel;

			break;

		case RConnection::EStopAuthoritative:

			stopCode = KErrConnectionTerminated;

			break;

		default:

			__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSockscnsts, 6));

		}

	RNodeInterface* sp = iContext.Node().ServiceProvider();

	if(sp)

		{ // We can only post the 'stop' if we've got a service provider and its not already leaving (e.g., gone down).

		if (!(sp->Flags() & TClientType::ELeaving))

		    {

			sp->PostMessage(TNodeCtxId(iContext.ActivityId(), iContext.NodeId()), TCFServiceProvider::TStop(stopCode).CRef());

		    }

		else

			{

			MESH_LOG((KESockConnectionTag, _L8("ConnStates::TSendStopConnection:\tDoL - IGNORING POST!")));

			}

		}

	else

		{ // Otherwise just set the activity idle and bail out.

		iContext.Activity()->SetIdle();

		}

	}

DEFINE_SMELEMENT(ConnStates::TConnectionSendStopSCPR, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TConnectionSendStopSCPR::DoL()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, ConnPanic(KPanicNoActivity));

	TInt stopCode = 0;

	switch (static_cast<CESockClientActivityBase*>(iContext.iNodeActivity)->Int1())

		{

	case RConnection::EStopNormal:

		stopCode = KErrCancel;

		break;

	case RConnection::EStopAuthoritative:

		stopCode = KErrConnectionTerminated;

		break;

	default:

		__ASSERT_DEBUG( false , User::Panic(KSpecAssert_ESockSSockscnsts, 7)); // CConnection should have verified the parameters before stopping the subconnection

		}

	// Send the stop message to the subconnection.

	RNodeInterface* scpr = static_cast<CConnection&>(iContext.Node()).DefaultSubConnectionServiceProvider();

	__ASSERT_DEBUG( scpr , User::Panic(KSpecAssert_ESockSSockscnsts, 8)); // subconnection must exist or the stop operation should not have been initiated

	scpr->PostMessage(

		TNodeCtxId(iContext.ActivityId(), iContext.NodeId()),

		TCFServiceProvider::TStop(stopCode).CRef()

		);

	}

DEFINE_SMELEMENT(ConnStates::TCancelStartOrAttachConnection, NetStateMachine::MStateTransition, ConnStates::TContext)

void ConnStates::TCancelStartOrAttachConnection::DoL()

	{