1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // COREPRACTIVITIES.CPP

    15 // Core PR Activities

    16 // THIS API IS INTERNAL TO NETWORKING AND IS SUBJECT TO CHANGE AND NOT FOR EXTERNAL USE

    17 //

    18 //

    19 

    20 /**

    21  @file

    22  @internalComponent

    23 */

    24 

    25 #define SYMBIAN_NETWORKING_UPS

    26 

    27 #include "ss_corepractivities.h"

    28 

    29 

    30 #include <comms-infras/ss_log.h>

    31 #include "ss_internal_activities.h"

    32 #include <comms-infras/ss_coreprstates.h>

    33 #include <comms-infras/ss_subconnprov.h>

    34 #include <comms-infras/ss_mcprnodemessages.h>

    35 

    36 #include <comms-infras/ss_protocolparameterset.h>

    37 #include <ss_glob.h>

    38 

    39 

    40 #include <elements/nm_messages_child.h>

    41 #include <elements/nm_messages_peer.h>

    42 #include <elements/nm_messages_errorrecovery.h>

    43 #include "ss_nodemessages_dataclient.h"

    44 #include "ss_nodemessages_serviceprovider.h"

    45 #include <comms-infras/ss_nodemessages_rejoiningprovider.h>

    46 #include <comms-infras/ss_nodemessages_flow.h>

    47 #include "ss_nodemessages_factory.h"

    48 #include <comms-infras/ss_nodemessages_internal_esock.h>

    49 

    50 

    51 #ifdef _DEBUG

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

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

    54 _LIT(KSpecAssert_ESockCrStaCPRAC, "ESockCrStaCPRAC");

    55 #endif

    56 

    57 #if defined __CFLOG_ACTIVE || defined ESOCK_EXTLOG_ACTIVE

    58 	#define KCoreProviderStatesTag KESockCoreProviderTag

    59 	_LIT8(KCoreProviderStatesSubTag, "coreprovstate");

    60 #endif

    61 

    62 using namespace NetStateMachine;

    63 using namespace CoreStates;

    64 using namespace CoreNetStates;

    65 using namespace PRStates;

    66 using namespace PRActivities;

    67 using namespace CoreActivities;

    68 using namespace ESock;

    69 using namespace CorePanics;

    70 using namespace Elements;

    71 using namespace Messages;

    72 using namespace MeshMachine;

    73 using namespace Factories;

    74 

    75 

    76 #ifdef _DEBUG

    77 _LIT (KCorePrPanic,"CorePrPanic");

    78 #endif

    79 

    80 namespace CoreErrorActivity

    81 { //Special parallel activity, must be started as the last one

    82 DEFINE_EXPORT_CUSTOM_NODEACTIVITY(ECFActivityError, CoreError, TEBase::TError, CErrorActivity::NewL)

    83 	FIRST_NODEACTIVITY_ENTRY(CErrorActivity::TCFAwaitingError, MeshMachine::TNoTag)

    84 	NODEACTIVITY_ENTRY(KNoTag, CErrorActivity::TSendErrorRecoveryReq, MeshMachine::TAwaitingMessageState<TEErrorRecovery::TErrorRecoveryResponse>, MeshMachine::TNoTag)

    85 	LAST_NODEACTIVITY_ENTRY(KNoTag, CErrorActivity::TDoErrorRecovery)

    86 NODEACTIVITY_END()

    87 }

    88 

    89 namespace PRProvisionActivity

    90 {

    91 DECLARE_DEFINE_NODEACTIVITY(ECFActivityStoreProvision, PrProvision, TCFDataClient::TProvisionConfig)

    92 	NODEACTIVITY_ENTRY(KNoTag, PRStates::TStoreProvision, CoreNetStates::TAwaitingProvision, MeshMachine::TNoTag)

    93 NODEACTIVITY_END()

    94 }

    95 

    96 namespace PRControlClientJoinActivity

    97 {

    98 DEFINE_EXPORT_NODEACTIVITY(ECFActivityClientJoin, PRControlClientJoin, TNodeSignal::TNullMessageId) //May be waiting for both messages

    99 	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TAddControlClientAndSendJoinCompleteIfRequest, CoreNetStates::TAwaitingControlClientJoin, MeshMachine::TNoTag)

   100 NODEACTIVITY_END()

   101 }

   102 

   103 namespace PRDataClientJoinActivity

   104 { //This activity needs the activity object (& it can fail on AddClientL, so no point converting)

   105 DEFINE_EXPORT_NODEACTIVITY(ECFActivityDataClientJoin, PRDataClientJoin, TCFPeer::TJoinRequest)

   106 	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingDataClientJoinRequest, MeshMachine::TNoTag)

   107 	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TAddDataClientAndRespond)

   108 NODEACTIVITY_END()

   109 }

   110 

   111 namespace PRClientLeaveActivity

   112 {//This activity will wait for ECFActivityBinderRequest to complete

   113 DEFINE_EXPORT_NODEACTIVITY(ECFActivityClientLeave, PRClientLeave, TNodeSignal::TNullMessageId) //May be waiting for both messages

   114 NODEACTIVITY_ENTRY(KNoTag, PRStates::TProcessClientLeave, CoreStates::TAwaitingClientLeave, MeshMachine::TNoTag)

   115 NODEACTIVITY_END()

   116 }

   117 

   118 namespace PRDataClientIdleActivity

   119 {

   120 DEFINE_EXPORT_NODEACTIVITY(ECFActivityDataClientIdle, PRDataClientIdle, TCFControlProvider::TIdle)

   121     NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::THandleDataClientIdle, CoreNetStates::TAwaitingDataClientIdle, MeshMachine::TNoTag)

   122 NODEACTIVITY_END()

   123 }

   124 

   125 namespace PRDataClientActiveActivity

   126 {

   127 DEFINE_EXPORT_NODEACTIVITY(ECFActivityDataClientActive, PRDataClientActive, TCFControlProvider::TActive)

   128 	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, CoreNetStates::TAwaitingDataClientActive, MeshMachine::TNoTag)

   129 NODEACTIVITY_END()

   130 }

   131 

   132 namespace PRDestroyActivity

   133 {

   134 //The generic Destroy activity. Carries out the node's goodbye handshake.

   135 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityDestroy, PRDestroy, TEChild::TDestroy, CoreActivities::CDestroyActivity::New)

   136 	FIRST_NODEACTIVITY_ENTRY(MeshMachine::TAwaitingDestroy, CoreActivities::CDestroyActivity::TNoTagBlockedByActivitiesOrLeavingDataClient)

   137 

   138     //Stop self first

   139     NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientStopped, CoreStates::TNoTagOrNoClients)

   140 

   141     //The node mustn't go out of scope with clients present. The node must get rid of them first.

   142 	NODEACTIVITY_ENTRY(KNoTag, CoreActivities::CDestroyActivity::TMakeClientsLeaveOrProcessClientLeave, CoreStates::TAwaitingClientLeave,  CDestroyActivity::TNoTagOrNoTagBackwards)

   143 	THROUGH_NODEACTIVITY_ENTRY(KNoTag, CoreActivities::CDestroyActivity::TProcessClientLeave, TTag<KNoClients>)

   144 

   145  	THROUGH_NODEACTIVITY_ENTRY(KNoClients, PRStates::TProcessDestroy, MeshMachine::TNoTag)

   146  	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, MeshMachine::TAwaitingLeaveComplete, CoreActivities::CDestroyActivity::TNoTagOrNoTagBackwards)

   147  	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendClientLeavingAndRemoveControlProvider)

   148 NODEACTIVITY_END()

   149 }

   150 

   151 namespace PRSetParamsRequest

   152 {

   153 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   154 DEFINE_EXPORT_NODEACTIVITY(ECFActivityParamRequest, PRSetParams, TCFScpr::TSetParamsRequest)

   155 	FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingParamRequest, CoreNetStates::TNoTagOrBearerPresent)

   156 	NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, PRStates::TPassToServiceProvider, CoreNetStates::TAwaitingParamResponse, MeshMachine::TTag<CoreNetStates::KBearerPresent>)

   157 	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, PRStates::TStoreParamsAndPostToOriginators)

   158 	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TStoreAndRespondWithCurrentParams)

   159 NODEACTIVITY_END()

   160 #else

   161 DEFINE_EXPORT_NODEACTIVITY(ECFActivityParamRequest, PRSetParams, TNodeSignal::TNullMessageId)

   162 NODEACTIVITY_END()

   163 #endif

   164 }

   165 

   166 // no Store in case of GetParamsRequest

   167 namespace PRGetParamsRequest

   168 {

   169 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   170 DEFINE_EXPORT_NODEACTIVITY(ECFActivityParamRequest, PRGetParams, TCFScpr::TGetParamsRequest)

   171 	FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingParamRequest, CoreNetStates::TNoTagOrBearerPresent)

   172 	NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, PRStates::TPassToServiceProvider, CoreNetStates::TAwaitingParamResponse, MeshMachine::TTag<CoreNetStates::KBearerPresent>)

   173 	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, CoreStates::TPostToOriginators)

   174 	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TRespondWithRetrievedParams)

   175 NODEACTIVITY_END()

   176 #else

   177 DEFINE_EXPORT_NODEACTIVITY(ECFActivityParamRequest, PRGetParams, TNodeSignal::TNullMessageId)

   178 NODEACTIVITY_END()

   179 #endif

   180 }

   181 

   182 namespace PRBindToActivity

   183 {

   184 //PRBindToActivity is responsible for handling TCFDataClient::TBindTo;

   185 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityBindTo, PRBindTo, TCFDataClient::TBindTo, CBindToActivity::NewL)

   186 	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingBindTo, CBindToActivity::TNoTagOrBearerReady)

   187     //TBindTo can hold:

   188     //[KNoTag] 		 - a valid serviceProvider cookie that this node isn't bound to;

   189     //[KBearerReady] - a valid serviceProvider cookie that this node is already bound to;

   190     //[KBearerReady] - a NULL serviceProvider (this node is at the stack's bottom);

   191 

   192 	  //{ JOINING NEW SERVICE PROVIDER

   193 		//a valid serviceProvider supplied, new to this node, let's join it;

   194 	    NODEACTIVITY_ENTRY(KNoTag, CBindToActivity::TSendControlClientJoinRequest, CoreStates::TAwaitingJoinComplete, TTag<KBearerReady>)

   195 	  //}

   196 

   197 	//serviceProvider provisionally joined. Now the activity needs to propagate iteslf (TBindTo) to its dataclients.

   198 	//The dataclients are either present or not. If not this activity will assume this is the layer construction phase

   199 	//and will attempt to construct a default dataclient.

   200 	THROUGH_NODEACTIVITY_ENTRY(KBearerReady, MeshMachine::TDoNothing, CBindToActivity::TNoTagOrDataClientReady)

   201 

   202 	  //{ DATA CLIENT CREATION

   203 		//No dataclients present, assume this is the layer creation phase. Attempt to create a dataclient.

   204 		NODEACTIVITY_ENTRY(KNoTag, CBindToActivity::TCreateDataClient, TAcceptErrorState<CoreNetStates::TAwaitingDataClientJoin>, MeshMachine::TErrorTagOr<CBindToActivity::TNoTagOrBindToComplete>)

   205 	    //BindTo activity is the pre-start layer builder, hence it always requests the dataclient from the factory.

   206 	    //The factory (being aware of the phase) may decide to:

   207 	    //1. create a new dataclient          -> process dataclient creation            [KNoTag]

   208 	    //2. return a preexisting dataclient  -> bind the client                        [KDataClientReady]

   209 	    //3. not to create a dataclient       -> send TBindToComplete to the originator [KBindToComplete]

   210 		THROUGH_NODEACTIVITY_ENTRY(KNoTag, PRStates::TProcessDataClientCreation, TTag<KDataClientReady>)

   211 	  //}

   212 

   213     THROUGH_NODEACTIVITY_ENTRY(KDataClientReady, MeshMachine::TDoNothing, CBindToActivity::TNoTagOrBearerReadyOrBindToComplete)

   214       //{ BINDING DATACLIENTS LOOP

   215 	    //Dataclient(s) is/are ready. Depending on whether the node has the lower layer or not,

   216 	    //we will [KNoTag] or will not [KNoBearer] need to request a binder for the dataclient.

   217 

   218 		  //{SERVICE PROVIDER PRESENT

   219 			NODEACTIVITY_ENTRY(KNoTag, CBindToActivity::TRequestCommsBinder, TAcceptErrorState<CoreNetStates::TAwaitingBinderResponse>, TErrorTagOr<TTag<KBearerReady> >)

   220 	      //}

   221 		NODEACTIVITY_ENTRY(KBearerReady, PRActivities::CBindToActivity::TSendBindTo, CBindToActivity::TAwaitingBindToCompleteOrError,

   222 																					 TErrorTagOr<TTag<KDataClientReady | NetStateMachine::EBackward> >)

   223 	  //}

   224 

   225 	//Binding is finished. If this is not autocommit (see TCFDataClient::TBindTo), the activity will reply TCFDataClient::TBindToComplete

   226 	//to the sender await for the confirmation (TCFDataClient::TCommitBindTo) or cancelation (TBase::TCancel) from the sender.

   227 	//If this is autommit, the activity will skip awaiting for TCFDataClient::TCommitBindTo and commit itself.

   228 	THROUGH_NODEACTIVITY_ENTRY(KBindToComplete, CBindToActivity::TSendBindToComplete, CBindToActivity::TNoTagOrCommit)

   229 	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, MeshMachine::TAwaitingMessageState<TCFDataClient::TCommitBindTo>, TErrorTagOr<TTag<KCommit> >)

   230 

   231 	//commiting (either implicit or explicit).

   232 	NODEACTIVITY_ENTRY(KCommit, CBindToActivity::TCommit, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

   233 

   234 	//This is not autocommit and the sender has just explicitly cancelled. Alternativelly this is an error path.

   235 	//Cancelling/processing error entiles sending TCancel to all dataclients awaiting confirmation

   236 	//as well as it entiles leaving the new service provider.

   237 	NODEACTIVITY_ENTRY(KErrorTag, CBindToActivity::TCancel, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

   238 

   239 	LAST_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing)

   240 NODEACTIVITY_END()

   241 }

   242 

   243 namespace PRStartActivity

   244 {

   245 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStart, PRStart, TCFServiceProvider::TStart, PRActivities::CStartActivity::NewL)

   246     FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingStart, CoreNetStates::TNoTagOrBearerPresentBlockedByStop)

   247 	NODEACTIVITY_ENTRY(KBearerPresent, CoreNetStates::TBindSelfToPresentBearer, CoreNetStates::TAwaitingBindToComplete, TTag<KBearerPresent>)

   248 	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendNoBearer, MeshMachine::TAwaitingMessageState<TCFControlProvider::TBearer>, CoreNetStates::TNoTagOrBearerPresentOrErrorTag)

   249 

   250 	//Start the service provider, use the default cancellation.

   251 	//Forward TCancel to the service provider, wait for TStarted or TError (via the Error Activity)

   252 	//When TStarted arrives after TCancel the activity will move to the nearest KErrorTag

   253 	NODEACTIVITY_ENTRY(KBearerPresent, CoreNetStates::TStartServiceProviderRetry, CoreNetStates::TAwaitingStarted, MeshMachine::TNoTagOrErrorTag)

   254 	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TDoNothing)

   255 	//Start data clients, use the default cancellation.

   256 	//Forward TCancel to the self, wait for TCFDataClient::TStarted or TError (via the Error Activity)

   257 	//When TCFDataClient::TStarted arrives after TCancel the activity will move to the nearest KErrorTag

   258 	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TStartSelf, CoreNetStates::TAwaitingDataClientStarted, MeshMachine::TNoTagOrErrorTag)

   259 	NODEACTIVITY_ENTRY(KErrorTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientStopped, MeshMachine::TErrorTag)

   260 	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TRaiseAndClearActivityError)

   261 	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendStarted)

   262 NODEACTIVITY_END()

   263 }

   264 

   265 namespace PRStopActivity

   266 {

   267 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStop, PRStop, TCFServiceProvider::TStop, MeshMachine::CNodeRetryActivity::NewL)

   268 	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingStop, TActiveOrNoTagBlockedByBindTo)

   269 	THROUGH_NODEACTIVITY_ENTRY(KActiveTag, CoreNetStates::TCancelDataClientStart, MeshMachine::TNoTag)

   270 	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientStopped, CoreNetStates::TNoTagOrNoBearer)

   271 	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendStop, CoreNetStates::TAwaitingStopped, MeshMachine::TNoTag)

   272 	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendClientLeavingRequestToServiceProvider, MeshMachine::TAwaitingLeaveComplete, TTag<CoreNetStates::KNoBearer>)

   273 	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KNoBearer, PRStates::TSendStoppedAndGoneDown)

   274 NODEACTIVITY_END()

   275 }

   276 

   277 namespace PRDataClientStartActivity

   278 {

   279 DECLARE_DEFINE_NODEACTIVITY(ECFActivityStartDataClient, PRDataClientStart, TCFDataClient::TStart)

   280     FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingDataClientStart, CoreNetStates::TNoTagOrNoDataClients)

   281 	NODEACTIVITY_ENTRY(KNoTag, PRStates::TStartDataClients, TAcceptErrorState<CoreNetStates::TAwaitingDataClientsStarted>, MeshMachine::TErrorTagOr<MeshMachine::TTag<CoreNetStates::KNoDataClients> >)

   282 	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KNoDataClients, PRStates::TSendDataClientStarted)

   283 

   284 	NODEACTIVITY_ENTRY(KErrorTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientsStopped, MeshMachine::TErrorTag)

   285 	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TRaiseAndClearActivityError)

   286 NODEACTIVITY_END()

   287 }

   288 

   289 namespace PRDataClientStopActivity

   290 {

   291 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStopDataClient, PRDataClientStop, TCFDataClient::TStop, MeshMachine::CNodeRetryActivity::NewL)

   292 	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingDataClientStop, MeshMachine::TNoTag)

   293 	THROUGH_NODEACTIVITY_ENTRY(KNoTag, PRStates::TProcessDataClientStop, CoreNetStates::TNoTagOrDataClientsToStopBlockedByStarting)

   294 

   295 	NODEACTIVITY_ENTRY(CoreNetStates::KDataClientsToStop, CoreNetStates::TStopDataClients, CoreNetStates::TAwaitingDataClientsStopped, MeshMachine::TNoTag)

   296 	THROUGH_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, CoreNetStates::TNoTagOrUnbindOnStop)

   297 

   298 	NODEACTIVITY_ENTRY(CoreNetStates::KUnbind, CoreNetStates::TSendClientLeavingRequestToServiceProvider, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

   299 	THROUGH_NODEACTIVITY_ENTRY(KNoTag, PRStates::TDestroyOrphanedDataClients, MeshMachine::TNoTag)

   300 	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TSendDataClientStopped)

   301 NODEACTIVITY_END()

   302 }

   303 

   304 

   305 namespace PRForwardStateChangeActivity

   306 {

   307 DECLARE_DEFINE_NODEACTIVITY(ECFActivityForwardStateChange, PRForwardStateChange, TCFMessage::TStateChange)

   308 	NODEACTIVITY_ENTRY(KNoTag, PRStates::TForwardStateChange, MeshMachine::TAwaitingMessageState<TCFMessage::TStateChange>, MeshMachine::TNoTag)

   309 NODEACTIVITY_END()

   310 }

   311 

   312 namespace PRDataClientStatusChangeActivity

   313 {

   314 DECLARE_DEFINE_NODEACTIVITY(ECFActivityDataClientStatusChange, PRDataClientStatusChange, TCFControlProvider::TDataClientStatusChange)

   315 	NODEACTIVITY_ENTRY(KNoTag, PRStates::THandleDataClientStatusChangeAndDestroyOrphans, CoreNetStates::TAwaitingDataClientStatusChange, MeshMachine::TNoTag)

   316 NODEACTIVITY_END()

   317 }

   318 

   319 namespace PRGoneDownActivity

   320 {

   321 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityGoneDown, PRGoneDown, TCFControlClient::TGoneDown, CGoneDownActivity::NewL)

   322 	// Our Service Provider has gone down unexpectedly (we haven't issued a TStop)

   323 	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingGoneDown, MeshMachine::TNoTag)

   324 	THROUGH_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TCancelAndCloseZone0ClientExtIfaces, MeshMachine::TNoTag)

   325 	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendClientLeavingRequestToServiceProvider, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

   326 	NODEACTIVITY_ENTRY(KNoTag, CGoneDownActivity::TSendErrorRecoveryReq, MeshMachine::TAwaitingErrorRecoveryResponseOrError, CoreStates::TRetryOrIgnoreOrPropagate)

   327 	THROUGH_NODEACTIVITY_ENTRY(CoreStates::KRetry, MeshMachine::TDoNothing, CGoneDownActivity::TIgnoreOrPropagate)

   328 	LAST_NODEACTIVITY_ENTRY(CoreStates::KIgnore, MeshMachine::TDoNothing)

   329 	NODEACTIVITY_ENTRY(CoreStates::KPropagate, CoreNetStates::TCancelStartAndStopSelf, CoreNetStates::TAwaitingDataClientStopped, MeshMachine::TNoTag)

   330 	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TSendGoneDown)

   331 NODEACTIVITY_END()

   332 }

   333 

   334 

   335 namespace PRGoneUpActivity

   336 {

   337 // This Activity forward the TGoneUp event to the Control Clients nodes that are

   338 // not in the originator lis

   339 

   340 DECLARE_DEFINE_NODEACTIVITY(ECFActivityGoneUp, PRGoneUp, TCFControlClient::TGoneUp)

   341 	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingGoneUp, MeshMachine::TNoTag)

   342     LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendGoneUp)

   343 NODEACTIVITY_END()

   344 }

   345 

   346 namespace PRLegacyRMessage2HandlerActivity

   347 {

   348 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityLegacyRMessage2Handler, PRLegacyRMessage2Handler, TNodeSignal::TNullMessageId, MeshMachine::CNodeParallelMessageStoreActivityBase::NewL)

   349 	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingLegacyRMessage2Ext, MeshMachine::TNoTag)

   350 	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TProcessOrForwardRMessage2Ext, CoreNetStates::TAwaitingRMessage2Processed, MeshMachine::TNoTag)

   351     LAST_NODEACTIVITY_ENTRY(KNoTag, CoreStates::TPostToOriginators)

   352 NODEACTIVITY_END()

   353 }

   354 

   355 

   356 namespace CoreActivities

   357 {

   358 DECLARE_DEFINE_ACTIVITY_MAP(coreActivitiesAll)

   359 	ACTIVITY_MAP_ENTRY(CoreErrorActivity, CoreError) //Must be first in the table

   360 ACTIVITY_MAP_END()

   361 

   362 //-=========================================================

   363 //

   364 //Error Activity

   365 //

   366 //-=========================================================

   367 MeshMachine::CNodeActivityBase* CErrorActivity::NewL( const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode )

   368     {

   369 	TUint c = GetNextActivityCountL(aActivitySig,aNode);

   370     return new(ELeave)CErrorActivity(aActivitySig, aNode, c);

   371     }

   372 

   373 CErrorActivity::CErrorActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TUint aActivitiesCount)

   374 	:	MeshMachine::CNodeParallelActivityBase(aActivitySig, aNode, aActivitiesCount), iErroredActivityId(MeshMachine::KActivityNull)

   375 	{

   376 	}

   377 

   378 CErrorActivity::~CErrorActivity()

   379 	{

   380 	if (Error() != KErrNone)

   381 		{

   382 		CNodeActivityBase* a = iNode.FindActivityById(iErroredActivityId);

   383 		if (a)

   384 			{

   385 			a->SetError(Error());

   386 			a->SetIdle();

   387 			}

   388     	}

   389     SetError(KErrNone);

   390     }

   391 

   392 TBool CErrorActivity::IsIdle() const

   393 	{

   394 	return NetStateMachine::ACore::IsIdle();

   395 	}

   396 

   397 void CErrorActivity::StartL(TNodeContextBase& aContext, const Messages::XNodePeerId& /*aOriginator*/, const TStateTriple& aFirst)

   398 	{

   399 	__ASSERT_DEBUG(IsIdle(), User::Panic(KSpecAssert_ESockCrStaCPRAC, 1));

   400   	MESH_LOG_ACTIVITY_EXT(KESockMeshMachine, this, &aContext, (_L8("CErrorActivity %08x:\tStartL->starting activity"), this));

   401 

   402 	NetStateMachine::ACore::Start(&aContext, aFirst);

   403 

   404     MESH_LOG_ACTIVITY_EXT(KESockMeshMachine, this, &aContext, (_L8("CErrorActivity %08x:\tStartL->activity started"),this));

   405 	}

   406 

   407 TBool CErrorActivity::Next(TNodeContextBase& aContext)

   408 	{

   409 	TBool ret = EFalse;

   410 

   411 

   412 	if (aContext.iMessage.IsMessage<TEBase::TCancel>())

   413 		{

   414 		CNodeActivityBase* a = iNode.FindActivityById(iErroredActivityId);

   415 		//Special handling for TCancel.

   416 		if (a && a->FindOriginator(aContext.iSender) != KErrNotFound)

   417 			{

   418 			ret = ETrue;

   419 			//iActiviy could have handled it, but chose not to.

   420 			Cancel(aContext);

   421 			//consume the message, otherwise the iActivity will get idled and iActivity reference

   422 			//will become invalid.

   423 			aContext.iMessage.ClearMessageId();

   424 			}

   425 		}

   426 	else

   427 		{

   428 		//If we have sent TErrorRecoveryRequest, we had to have set PostedToId() to the recipient (ControlProvider)

   429 		//as otherwise there would be no path for propagating the potential TCancel.

   430 		//The response however (TErrorRecoveryResponse or TError) will not necesserily come from that recipient (CP)

   431 		//(for example it could be coming from the MCpr and we could be the SCpr).

   432 		//Normally this would be a problem because any unrelated TError message arriving to the node

   433 		//and presented to the awaiting state would easily be confused with the response (TError == no recovery on the MCpr == EPropagate).

   434 		//We avoid the problem by checking all arriving  messages if they are adressed to our activity (but we don't

   435 		//check the sender.

   436 	    const TNodeCtxId* recipient = address_cast<const TNodeCtxId>(&aContext.iRecipient);

   437 		if (recipient && (ActivityId() == recipient->NodeCtx()))

   438 			{

   439 			ret = ACore::Next(&aContext);

   440 			if(ret)

   441 				{

   442 		    	MESH_LOG_ACTIVITY_EXT(KMeshMachineSubTag, this, &aContext, (_L8("CNodeActivityBase %08x:\tNext->transition"), this));

   443 				}

   444 			}

   445 		}

   446 	return ret;

   447   	}

   448 

   449 EXPORT_DEFINE_SMELEMENT(CErrorActivity::TAwaitingError, NetStateMachine::MState, CErrorActivity::TContext)

   450 EXPORT_C TBool CErrorActivity::TAwaitingError::Accept()

   451     {

   452 	if (! iContext.iMessage.IsMessage<TEBase::TError>())

   453 		{

   454 		return EFalse;

   455 		}

   456 

   457 	TEBase::TError& errorMessage = message_cast<TEBase::TError>(iContext.iMessage);

   458 

   459 	//Diagnostic panic only. TError message should not be travelling around with KErrNone.

   460 	//If you see this panic, please send a proper error code.

   461 	__ASSERT_DEBUG(errorMessage.iValue != KErrNone, User::Panic(KSpecAssert_ESockCrStaCPRAC, 2));

   462 

   463     MeshMachine::CNodeActivityBase* aa = iContext.Node().FindAddressedActivity(iContext);

   464 

   465     //TError is always a response. If there is no activity addressed by the TError,

   466     //then we assume the activity hasn't bothered waiting for the result.

   467     //We hence ignore the error.

   468     if (aa)

   469     	{

   470         aa->SetError(errorMessage.iValue);

   471     	aa->SetIdle();

   472     	}

   473     errorMessage.ClearMessageId();

   474     return EFalse;

   475     }

   476 

   477 DEFINE_SMELEMENT(CErrorActivity::TCFAwaitingError, NetStateMachine::MState, CErrorActivity::TContext)

   478 EXPORT_C TBool CErrorActivity::TCFAwaitingError::Accept()

   479     {

   480 	if (! iContext.iMessage.IsMessage<TEBase::TError>())

   481 		{

   482 		return EFalse;

   483 		}

   484 

   485 	TEBase::TError& errorMessage = message_cast<TEBase::TError>(iContext.iMessage);

   486 

   487 	//Diagnostic panic only. TError message should not be travelling around with KErrNone.

   488 	//If you see this panic, please send a proper error code.

   489 	__ASSERT_DEBUG(errorMessage.iValue != KErrNone, User::Panic(KSpecAssert_ESockCrStaCPRAC, 3));

   490 

   491 	RNodeInterface* client = iContext.Node().FindClient(iContext.iSender);

   492 	if (client &&

   493 		client->Type() & TCFClientType::EServProvider &&

   494 		iContext.Node().ControlProvider() != NULL &&

   495 		iContext.Node().CountActivities(ECFActivityDestroy) == 0)

   496 		{

   497 		//this is the only way out into the activity and into error recovery steps

   498 		//that error activity is responsible for doing.

   499 		return ETrue;

   500 		}

   501 

   502     return CErrorActivity::TAwaitingError::Accept();

   503     }

   504 

   505 //Simply leaving from this DoL will NOT have the effect of sending TError to originators

   506 //of the Errored activity! iContext.iNodeActivity is the Error activity.

   507 //Reassign iContext.iNodeActivity before leaving or handle the error.

   508 EXPORT_DEFINE_SMELEMENT(CErrorActivity::TSendErrorRecoveryReq, NetStateMachine::MStateTransition, CErrorActivity::TContext)

   509 EXPORT_C void CErrorActivity::TSendErrorRecoveryReq::DoL()

   510     {

   511 	//Find matching activity, if any

   512     MeshMachine::CNodeActivityBase* aa = iContext.Node().FindAddressedActivity(iContext);

   513     //we are started based on the fact the the last message iContext.Node()'s received is TError

   514     TEBase::TError& errmsg = message_cast<TEBase::TError>(iContext.iMessage);

   515 

   516 	//The error comes from someone else than our Data Client (or we wouldn't be here).

   517 	//It may be our Service Provider or it can be some other node which has originated

   518 	//an activity on us (in which case the errored activity must be present).

   519     if (aa==NULL)

   520     	{

   521         __CFLOG_VAR((KCoreProviderStatesTag, KCoreProviderStatesSubTag, _L8("ASendErrorRecoveryReq::DoL - TError but no addressed activity - ignoring")));

   522 #ifdef SYMBIAN_NETWORKING_UPS

   523 		// Terminate the error activity (not UPS specific).

   524         iContext.iNodeActivity->SetIdle();

   525 #endif //SYMBIAN_NETWORKING_UPS

   526         return;

   527     	}

   528 

   529 	 AContextStore* intf = NULL;

   530      if (aa->SupportsExtInterface(AContextStore::KInterfaceId))

   531     	{

   532     	//FetchExtInterfaceL below can never leave because it is being checked few lines above in the "if"

   533 	    intf = reinterpret_cast<AContextStore*>(aa->FetchExtInterfaceL(AContextStore::KInterfaceId));

   534     	}

   535 

   536     //Check if there is any point in sending Error Recovery Request

   537     if (intf==NULL || !intf->IsStored() || !iContext.Node().ControlProvider())

   538         {

   539         __CFLOG_VAR((KCoreProviderStatesTag, KCoreProviderStatesSubTag, _L8("ERROR: ASendErrorRecoveryReq::DoL - KErrNotSupported")));

   540         iContext.iNodeActivity->SetIdle();

   541         aa->SetError(errmsg.iValue);

   542     	aa->SetIdle();

   543     	return;

   544         }

   545 

   546 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

   547     CoreActivities::CErrorActivity& activity = static_cast<CoreActivities::CErrorActivity&>(*iContext.iNodeActivity);

   548     __ASSERT_DEBUG(activity.iErroredActivityId==MeshMachine::KActivityNull, User::Panic(KSpecAssert_ESockCrStaCPRAC, 4));

   549 	// Save a reference to the activity and a point

   550 	// Each time we use the activity, query it from the node, because the activity may have gone away (originator left node etc)

   551 	activity.iErroredActivityId = aa->ActivityId();

   552 

   553     activity.SetError(errmsg.iValue);

   554     activity.iMessageId = errmsg.iMsgId;

   555 

   556     TErrContext ctx(iContext.NodeId(), errmsg.iMsgId, aa->ActivitySigId(), TStateChange(0, errmsg.iValue));

   557 	TEErrorRecovery::TErrorRecoveryRequest msg(ctx);

   558 

   559     activity.PostRequestTo(

   560     	*iContext.Node().ControlProvider(),//ControlProvider() verified above

   561     	TCFSafeMessage::TRequestCarrierEast<TEErrorRecovery::TErrorRecoveryRequest>(msg).CRef()

   562     	);

   563 

   564     //The original activiy might have set 'sent to', but that's surely

   565     //not meaningful anymore (we've just received a response from that 'sent to').

   566     //We could have pretended that the orginal activity knows it's sent

   567     //error recovery to the control provider but it's best just to clear

   568     //'sent to' (and handle TCancel from here (CErrorActivity::Next()).

   569     aa->ClearPostedTo();

   570     }

   571 

   572 EXPORT_DEFINE_SMELEMENT(CErrorActivity::TDoErrorRecovery, NetStateMachine::MStateTransition, CErrorActivity::TContext)

   573 EXPORT_C void CErrorActivity::TDoErrorRecovery::DoL()

   574     {

   575     __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

   576     CoreActivities::CErrorActivity* act = static_cast<CoreActivities::CErrorActivity*>(iContext.iNodeActivity);

   577 	CNodeActivityBase* a = iContext.Node().FindActivityById(act->iErroredActivityId);

   578     if (a == NULL)

   579 		{

   580 		iContext.iNodeActivity->SetIdle();

   581 		return;

   582 		}

   583 

   584 	if (iContext.iMessage.IsMessage<TEErrorRecovery::TErrorRecoveryResponse>())

   585 		{

   586 		TErrResponse& resp = message_cast<TEErrorRecovery::TErrorRecoveryResponse>(iContext.iMessage).iErrResponse;

   587 		if (resp.iAction == TErrResponse::ERetry)

   588 			{ //rerun current transition

   589 			__CFLOG_VAR((KCoreProviderStatesTag, KCoreProviderStatesSubTag, _L8("ADoErrorRecovery::DoL - instructed to retry")));

   590 			__ASSERT_DEBUG(a->SupportsExtInterface(AContextStore::KInterfaceId), User::Panic(KCorePrPanic, KPanicExtInterfaceNotSupported));

   591 

   592 			AContextStore* intf = reinterpret_cast<AContextStore*>(a->FetchExtInterfaceL(AContextStore::KInterfaceId));

   593 			__ASSERT_DEBUG(intf->IsStored(), User::Panic(KSpecAssert_ESockCrStaCPRAC, 5));

   594 			intf->Retry(*a,iContext);

   595 			if (iContext.iReturn == KErrNone)

   596 				{ //retry succeded

   597 				act->SetError(KErrNone);

   598 				}

   599 			//if Retry had failed, then the d'tor of act will raise the error on

   600 			//and terminate act->iActivity,

   601 			}

   602 		else if (resp.iAction == TErrResponse::EPropagate)

   603 			{ //set new error values and fall through

   604 			__CFLOG_VAR((KCoreProviderStatesTag, KCoreProviderStatesSubTag, _L8("ADoErrorRecovery::DoL - instructed to propagate the error")));

   605 			act->iMessageId = resp.iMessageId;

   606 			a->SetError(resp.iError);

   607 			}

   608 		else //if (resp.iAction == TErrResponse::EIgnore)

   609 			{

   610 			__CFLOG_VAR((KCoreProviderStatesTag, KCoreProviderStatesSubTag,

   611 			_L8("WARNING: ADoErrorRecovery::DoL() - instructed to ignore the error!")));

   612 			}

   613 		}

   614 	}

   615 

   616 

   617 //-=========================================================

   618 //

   619 //Destroy Activity - will delete the node when destructed

   620 //

   621 //-=========================================================

   622 

   623 EXPORT_C MeshMachine::CNodeActivityBase* CDestroyActivity::New(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)

   624 	{

   625 	TAny* space = BorrowPreallocatedSpace(aNode, sizeof(CDestroyActivity));

   626 	CDestroyActivity* self = new (space) CDestroyActivity(aActivitySig, aNode);

   627 	self->InsertPreallocatedDestroyActivity(); //Destructing preallocated activity

   628 	return self;

   629 	}

   630 

   631 CDestroyActivity::CDestroyActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)

   632 :	CNodeRetryActivity(aActivitySig, aNode),

   633 	APreallocatedOriginators<1>(iOriginators)

   634 	{

   635 	//Mark the provider for deletion, so that it's not served by the factory from now on.

   636     static_cast<ESock::CMMCommsProviderBase&>(iNode).MarkMeForDeletion();

   637 	}

   638 

   639 void CDestroyActivity::Destroy()

   640 	{

   641 	ReturnPreallocatedSpace(this);

   642 	this->~CDestroyActivity(); //Run the destructor

   643 

   644 	//Delete the provider.

   645 	static_cast<ESock::CMMCommsProviderBase&>(iNode).DeleteMeNow();

   646 	}

   647 

   648 TBool CDestroyActivity::Next(TNodeContextBase& aContext)

   649     {

   650     if (aContext.iMessage.IsMessage<TEBase::TCancel>())

   651         {  

   652         return ETrue;

   653         }

   654     else

   655         return CNodeActivityBase::Next(aContext);

   656     }

   657 

   658 EXPORT_DEFINE_SMELEMENT(CDestroyActivity::TNoTagOrNoTagBackwards, NetStateMachine::MStateFork, PRStates::TContext)

   659 EXPORT_C TInt CDestroyActivity::TNoTagOrNoTagBackwards::TransitionTag()

   660     {

   661 	if (iContext.iMessage.IsMessage<TEChild::TLeft>())

   662 		{

   663 		TClientIter<TDefaultClientMatchPolicy> iter = iContext.Node().GetClientIter<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EData|TCFClientType::ECtrl));

   664 		__ASSERT_DEBUG(iter[0], User::Panic(KSpecAssert_ESockCrStaCPRAC, 7)); //One leaving client must still be there.

   665 		return iter[1] == NULL ?  MeshMachine::KNoTag : MeshMachine::KNoTag | NetStateMachine::EBackward;

   666 		}

   667 	else if (iContext.iMessage.IsMessage<TEPeer::TLeaveComplete>())

   668 		{

   669 		__ASSERT_DEBUG(iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::ECtrl|TCFClientType::EData))==NULL,

   670 		User::Panic(KCorePrPanic, KPanicClientsStillPresent));

   671 		if (iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EServProvider))==NULL)

   672 			{

   673 			return NetStateMachine::EForward | MeshMachine::KNoTag;

   674 			}

   675 		return NetStateMachine::EBackward | MeshMachine::KNoTag; //Loop back to the same triple (& remove the peer)

   676 		}

   677 	__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockCrStaCPRAC, 8));

   678 	return KNoTag;

   679 	}

   680 

   681 EXPORT_DEFINE_SMELEMENT(CDestroyActivity::TMakeClientsLeaveOrProcessClientLeave, NetStateMachine::MStateTransition, PRStates::TContext)

   682 EXPORT_C void CDestroyActivity::TMakeClientsLeaveOrProcessClientLeave::DoL()

   683 	{

   684 	if (iContext.iMessage.IsMessage<TEChild::TLeft>())

   685 		{

   686 		ProcessClientLeaveL();

   687 		}

   688 	else

   689 		{

   690 		MakeClientsLeaveL();

   691 		}

   692 	}

   693 

   694 void CDestroyActivity::TMakeClientsLeaveOrProcessClientLeave::MakeClientsLeaveL()

   695     {

   696     __ASSERT_DEBUG(iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::ECtrl))==NULL,

   697     	User::Panic(KCorePrPanic, KPanicClientsStillPresent));

   698 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

   699 	iContext.iNodeActivity->ClearPostedTo();

   700 

   701 	//MZTODO: this asserion may need to be changed since TDestroy can

   702 	//come while data client is active etc.

   703     __ASSERT_DEBUG(iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EData, TCFClientType::EActive|TCFClientType::EActivating|TCFClientType::EStarting|TCFClientType::EStarted))==NULL,

   704     	User::Panic(KCorePrPanic, KPanicClientsStillPresent));

   705 

   706    	TClientIter<TDefaultClientMatchPolicy> dciter = iContext.Node().GetClientIter<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EData),	TClientType(0, TCFClientType::ELeaving));

   707    	RNodeInterface* dc = NULL;

   708     while ((dc = dciter[0]) != NULL) //always inspect the first elem as we're invalidating the iterator with each hit.

   709         {

   710 		dc->PostMessage(iContext.NodeId(), TEChild::TDestroy().CRef());

   711 		dc->SetFlags(TCFClientType::ELeaving);

   712         }

   713 	}

   714 

   715 void CDestroyActivity::TMakeClientsLeaveOrProcessClientLeave::ProcessClientLeaveL()

   716     {

   717     CDestroyActivity::TProcessClientLeave processClientLeave(iContext);

   718     processClientLeave.DoL();

   719     }

   720 

   721 

   722 //-=========================================================

   723 //

   724 //Loppin Activity

   725 //

   726 //-=========================================================

   727 EXPORT_C ACountLoopActivity::~ACountLoopActivity()

   728     {

   729     }

   730 

   731 

   732 EXPORT_C MeshMachine::CNodeActivityBase* CCountLoopActivityBase::NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)

   733     {

   734     return new (ELeave) CCountLoopActivityBase(aActivitySig, aNode);

   735     }

   736 

   737 EXPORT_C CCountLoopActivityBase::CCountLoopActivityBase(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)

   738 :	MeshMachine::CNodeActivityBase(aActivitySig, aNode),

   739     TIfStaticFetcherNearestInHierarchy(this)

   740     {

   741 	}

   742 

   743 EXPORT_C CCountLoopActivityBase::~CCountLoopActivityBase()

   744     {

   745     }

   746 

   747 EXPORT_DEFINE_SMELEMENT(ACountLoopActivity::TNoTagOrNoTagBackwards, NetStateMachine::MStateFork, PRStates::TContext)

   748 EXPORT_C TInt ACountLoopActivity::TNoTagOrNoTagBackwards::TransitionTag()

   749 	{

   750 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

   751 	__ASSERT_DEBUG(iContext.iNodeActivity->SupportsExtInterface(ACountLoopActivity::KInterfaceId),User::Panic(KCorePrPanic, KPanicInterfaceNotSupported));

   752 	ACountLoopActivity* countLoopActivity = static_cast<ACountLoopActivity*>(iContext.iNodeActivity->FetchExtInterface(ACountLoopActivity::KInterfaceId));

   753  	if (countLoopActivity->DecCount() > 0)

   754  		{

   755         return KNoTag | NetStateMachine::EBackward;

   756      	}

   757  	return KNoTag | NetStateMachine::EForward;

   758  	}

   759 

   760 

   761 

   762 

   763 

   764 //-=========================================================

   765 //

   766 //

   767 //Binding Activity

   768 //

   769 //

   770 //-=========================================================

   771 EXPORT_C ABindingActivity::~ABindingActivity()

   772 	{

   773     //Handle premature termination of the ABindingActivity object

   774     //by responding to the originator

   775 	//If the originator has not been replied to yet, reply now with an error code

   776 	if (IsBinding())

   777 		{

   778 		ReplyToOriginator(KErrAbort);

   779 		}

   780 	}

   781 

   782 EXPORT_C void ABindingActivity::StoreOriginator(const TRuntimeCtxId& aNodeCtxId)

   783     {

   784     //Check if the originator wasn't set before. If it was, it must be replied to before storing ths new one.

   785     __ASSERT_DEBUG(iOriginator.IsNull(), User::Panic(KSpecAssert_ESockCrStaCPRAC, 9));

   786     iOriginator = aNodeCtxId;

   787     }

   788 

   789 EXPORT_C void ABindingActivity::ReplyToOriginator(TInt aError)

   790     {

   791     //NOTE: Please do not make this diagnostic panic conditional.

   792     //Please allow it to server everyone equally.

   793     //Please handle the error conditions properly so that you obey this API's semantics.

   794     //If you are not providing a clean error handling solution for your activity,

   795     //please use IsBinding() before calling this API!

   796     __ASSERT_DEBUG(!iOriginator.IsNull(), User::Panic(KSpecAssert_ESockCrStaCPRAC, 10)); //The iOriginator must be set.

   797     RClientInterface::OpenPostMessageClose(iOurNode, iOriginator, TCFDataClient::TBindToComplete(aError).CRef());

   798     iOriginator.SetNull();

   799     }

   800 

   801 EXPORT_DEFINE_SMELEMENT(ABindingActivity::TSendBindToComplete, NetStateMachine::MStateTransition, CoreStates::TContext)

   802 EXPORT_C void ABindingActivity::TSendBindToComplete::DoL()

   803 	{

   804     __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

   805     __ASSERT_DEBUG(iContext.iNodeActivity->SupportsExtInterface(ABindingActivity::KInterfaceId), User::Panic(KSpecAssert_ESockCrStaCPRAC, 11));

   806     ABindingActivity* bindingActivity = reinterpret_cast<ABindingActivity*>(iContext.iNodeActivity->FetchExtInterfaceL(ABindingActivity::KInterfaceId));

   807     bindingActivity->ReplyToOriginator(iContext.iNodeActivity->Error());

   808 	}

   809 

   810 EXPORT_DEFINE_SMELEMENT(ABindingActivity::TSendBindToCompleteIfExpected, NetStateMachine::MStateTransition, CoreStates::TContext)

   811 EXPORT_C void ABindingActivity::TSendBindToCompleteIfExpected::DoL()

   812 	{

   813     __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

   814     __ASSERT_DEBUG(iContext.iNodeActivity->SupportsExtInterface(ABindingActivity::KInterfaceId), User::Panic(KSpecAssert_ESockCrStaCPRAC, 12));

   815     ABindingActivity* bindingActivity = reinterpret_cast<ABindingActivity*>(iContext.iNodeActivity->FetchExtInterfaceL(ABindingActivity::KInterfaceId));

   816     if (bindingActivity->IsBinding())

   817 	    {

   818 		bindingActivity->ReplyToOriginator(iContext.iNodeActivity->Error());

   819 	    }

   820 	}

   821 

   822 void ABindingActivity::FinalReplyToOriginator(TInt aError)

   823 /**

   824 Intended to be called from derived class destructors to arrange for a TBindToComplete reply to be sent

   825 before any other messages in those derived class destructors (for example TDestroy).

   826 */

   827 	{

   828 	if (IsBinding())

   829 		{

   830 		ReplyToOriginator(aError);

   831 		// Ensure that we don't send another reply in ~ABindingActivity.

   832 		iOriginator = Messages::TNodeCtxId();

   833 		}

   834 	}

   835 

   836 } // CoreActivities

   837 

   838 

   839 namespace PRActivities

   840 {

   841 DECLARE_DEFINE_ACTIVITY_MAP(coreActivitiesPR)

   842 	ACTIVITY_MAP_ENTRY(PRDataClientJoinActivity, PRDataClientJoin)

   843 	ACTIVITY_MAP_ENTRY(PRControlClientJoinActivity, PRControlClientJoin)

   844 	ACTIVITY_MAP_ENTRY(PRClientLeaveActivity, PRClientLeave)

   845 	ACTIVITY_MAP_ENTRY(PRForwardStateChangeActivity, PRForwardStateChange)

   846 	ACTIVITY_MAP_ENTRY(PRBindToActivity, PRBindTo)

   847 ACTIVITY_MAP_END_BASE(CoreActivities,coreActivitiesAll)

   848 

   849 //Activity Map provided by CorePr to be used by SCprs.

   850 //(it is further extended in CoreSCpr).

   851 DEFINE_EXPORT_ACTIVITY_MAP(coreActivitiesSCpr)

   852 	ACTIVITY_MAP_ENTRY(PRProvisionActivity, PrProvision)

   853     ACTIVITY_MAP_ENTRY(PRStartActivity, PRStart)

   854     ACTIVITY_MAP_ENTRY(PRStopActivity, PRStop)

   855 	ACTIVITY_MAP_ENTRY(PRDataClientStartActivity, PRDataClientStart)

   856 	ACTIVITY_MAP_ENTRY(PRDataClientStopActivity, PRDataClientStop)

   857 	ACTIVITY_MAP_ENTRY(PRDataClientIdleActivity, PRDataClientIdle)

   858 	ACTIVITY_MAP_ENTRY(PRDataClientActiveActivity, PRDataClientActive)

   859 	ACTIVITY_MAP_ENTRY(PRDestroyActivity, PRDestroy)

   860 	ACTIVITY_MAP_ENTRY(PRGoneDownActivity, PRGoneDown)

   861 	ACTIVITY_MAP_ENTRY(PRGoneUpActivity, PRGoneUp) //robertomaro

   862 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   863 	ACTIVITY_MAP_ENTRY(PRSetParamsRequest, PRSetParams)

   864 	ACTIVITY_MAP_ENTRY(PRGetParamsRequest, PRGetParams)

   865 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   866     ACTIVITY_MAP_ENTRY(PRLegacyRMessage2HandlerActivity, PRLegacyRMessage2Handler)

   867 ACTIVITY_MAP_END_BASE(PRActivities,coreActivitiesPR)

   868 

   869 //Activity Map provided by CorePr to be used by Cprs.

   870 //(it is further extended in CoreCpr).

   871 DEFINE_EXPORT_ACTIVITY_MAP(coreActivitiesCpr)

   872 	ACTIVITY_MAP_ENTRY(PRProvisionActivity, PrProvision)

   873     ACTIVITY_MAP_ENTRY(PRStartActivity, PRStart)

   874     ACTIVITY_MAP_ENTRY(PRStopActivity, PRStop)

   875 	ACTIVITY_MAP_ENTRY(PRDataClientStartActivity, PRDataClientStart)

   876 	ACTIVITY_MAP_ENTRY(PRDataClientStopActivity, PRDataClientStop)

   877 	ACTIVITY_MAP_ENTRY(PRDataClientIdleActivity, PRDataClientIdle)

   878 	ACTIVITY_MAP_ENTRY(PRDataClientActiveActivity, PRDataClientActive)

   879 	ACTIVITY_MAP_ENTRY(PRDestroyActivity, PRDestroy)

   880 	ACTIVITY_MAP_ENTRY(PRGoneDownActivity, PRGoneDown)

   881 	ACTIVITY_MAP_ENTRY(PRGoneUpActivity, PRGoneUp) //robertomaro

   882     ACTIVITY_MAP_ENTRY(PRDataClientStatusChangeActivity, PRDataClientStatusChange)

   883 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   884     ACTIVITY_MAP_ENTRY(PRSetParamsRequest, PRSetParams)

   885     ACTIVITY_MAP_ENTRY(PRGetParamsRequest, PRGetParams)

   886 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   887     ACTIVITY_MAP_ENTRY(PRLegacyRMessage2HandlerActivity, PRLegacyRMessage2Handler)

   888 ACTIVITY_MAP_END_BASE(PRActivities,coreActivitiesPR)

   889 

   890 //Activity Map provided by CorePr to be used by MCprs.

   891 //(it is further extended in CoreMCpr).

   892 DEFINE_EXPORT_ACTIVITY_MAP(coreActivitiesMCpr)

   893 	ACTIVITY_MAP_ENTRY(PRDataClientIdleActivity, PRDataClientIdle)

   894 	ACTIVITY_MAP_ENTRY(PRDataClientActiveActivity, PRDataClientActive)

   895     ACTIVITY_MAP_ENTRY(PRDataClientStatusChangeActivity, PRDataClientStatusChange)

   896     ACTIVITY_MAP_ENTRY(PRLegacyRMessage2HandlerActivity, PRLegacyRMessage2Handler)

   897 ACTIVITY_MAP_END_BASE(PRActivities,coreActivitiesPR)

   898 

   899 //Activity Map provided by CorePr to be used by TMs.

   900 //(it is further extended in CoreTM).

   901 DEFINE_EXPORT_ACTIVITY_MAP(coreActivitiesTM)

   902 ACTIVITY_MAP_END_BASE(PRActivities,coreActivitiesPR)

   903 

   904 

   905 

   906 

   907 //-=========================================================

   908 //

   909 //CBindToActivity

   910 //

   911 //-=========================================================

   912 EXPORT_C CBindToActivity::CBindToActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TInt aNextActivityCount)

   913 	:	MeshMachine::CNodeParallelActivityBase(aActivitySig, aNode, aNextActivityCount),

   914 		CoreActivities::ABindingActivity(aNode.Id()),

   915 	    TIfStaticFetcherNearestInHierarchy(this)

   916 		{

   917 		}

   918 

   919 EXPORT_C MeshMachine::CNodeActivityBase* CBindToActivity::NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)

   920     {

   921      //there can be only one BindTo activity running at a time.

   922     TUint c = GetNextActivityCountL(aActivitySig,aNode);

   923 	__ASSERT_DEBUG(c == 1,User::Panic(KCorePrPanic, KPanicPeerMisbehaving));

   924     if (c > 1)

   925         {

   926         User::Leave(KErrInUse);

   927         }

   928     return new (ELeave) CBindToActivity(aActivitySig, aNode, c);

   929     }

   930 

   931 EXPORT_C CBindToActivity::~CBindToActivity()

   932     {

   933     //If the activity is aborted then no cleanup will be performed (the destroy activity will do

   934     //that for us) so we should not assert that iSuccessfulDataClients is empty or iNewServiceProvider

   935     //is null.

   936 

   937     //CBindToActivity::TCommit or CBindToActivity::TCancel should have been executed

   938     //and rendered iSuccessfulDataClients empty.

   939 	//__ASSERT_DEBUG(iSuccessfulDataClients.Count() == 0, User::Panic(KCorePrPanic, KPanicIncorrectState));

   940 

   941 	//CBindToActivity::iNewServiceProvider should have been cleared by CBindToActivity::TCommit or CBindToActivity::TCancel

   942 	//__ASSERT_DEBUG(iNewServiceProvider == NULL, User::Panic(KCorePrPanic, KPanicIncorrectState));

   943 

   944     iSuccessfulDataClients.Close();

   945     }

   946 

   947 Messages::RNodeInterface* CBindToActivity::NextDataClient()

   948 	{

   949 	TClientIter<TDefaultClientMatchPolicy> iter = iNode.GetClientIter<TDefaultClientMatchPolicy>(

   950 												/*include*/TClientType(TCFClientType::EData),

   951 												/*exclude*/TClientType(0, TCFClientType::ELeaving | TCFClientType::EConfigAccessPoint));

   952     iCurrentDataClient = iter++;

   953     while (iCurrentDataClient && (iSuccessfulDataClients.Find(iCurrentDataClient) != KErrNotFound))

   954     	{

   955         iCurrentDataClient = iter++;

   956         };

   957     return iCurrentDataClient;

   958 	}

   959 

   960 TBool CBindToActivity::DataClientsAutocommit()

   961  	{

   962  	TInt nonLeavingDataClients = iNode.CountClients<TDefaultClientMatchPolicy>(

   963  								/*include*/TClientType(TCFClientType::EData),

   964  								/*exclude*/TClientType(0, TCFClientType::ELeaving | TCFClientType::EConfigAccessPoint));

   965  	return nonLeavingDataClients <=1 && IsAutocommit();

   966  	}

   967 

   968 

   969 void CBindToActivity::AddClientAsSuccessfulL(Messages::RNodeInterface* aDataClient)

   970 	{

   971 	__ASSERT_DEBUG(aDataClient, User::Panic(KCorePrPanic, KPanicDataClient));

   972 	__ASSERT_DEBUG(iSuccessfulDataClients.Find(aDataClient) == KErrNotFound, User::Panic(KCorePrPanic, KPanicIncorrectState));

   973 	iSuccessfulDataClients.Append(aDataClient);

   974 	}

   975 

   976 void CBindToActivity::RemoveClientFromSuccessful(Messages::RNodeInterface* aDataClient)

   977 	{

   978 	TInt index = iSuccessfulDataClients.Find(aDataClient);

   979 	__ASSERT_DEBUG(index >= 0, User::Panic(KCorePrPanic, KPanicDataClient));

   980 	iSuccessfulDataClients.Remove(index);

   981 	}

   982 

   983 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TSendControlClientJoinRequest, NetStateMachine::MStateTransition, CBindToActivity::TContext)

   984 void CBindToActivity::TSendControlClientJoinRequest::DoL()

   985     {

   986 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

   987     CBindToActivity& activity = static_cast<CBindToActivity&>(*iContext.iNodeActivity);

   988 	const TCFDataClient::TBindTo& bindToMsg(message_cast<const TCFDataClient::TBindTo>(iContext.iMessage));

   989 

   990 	__ASSERT_DEBUG(!bindToMsg.iNodeId.IsNull(), User::Panic(KCorePrPanic, KPanicNoServiceProvider));

   991     RNodeInterface* newServiceProvider = iContext.Node().AddClientL(bindToMsg.iNodeId,

   992                             TClientType(TCFClientType::EServProvider, TCFClientType::EActivating));

   993     __ASSERT_DEBUG(newServiceProvider, User::Panic(KCorePrPanic, KPanicNoServiceProvider));

   994     activity.iNewServiceProvider = bindToMsg.iNodeId;

   995     //Join the new service provider

   996     iContext.Activity()->PostRequestTo(*newServiceProvider,

   997                             TCFControlClient::TJoinRequest(iContext.NodeId(), TClientType(TCFClientType::ECtrl)).CRef());

   998     }

   999 

  1000 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TAwaitingBindToCompleteOrError, NetStateMachine::MState, CRejoinDataClientActivity::TContext)

  1001 TBool CBindToActivity::TAwaitingBindToCompleteOrError::Accept()

  1002     {

  1003 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

  1004     CBindToActivity& activity = static_cast<CBindToActivity&>(*iContext.iNodeActivity);

  1005     if (CoreNetStates::TAwaitingBindToComplete(iContext).Accept())

  1006 	    {

  1007 	    if (activity.IsBinding())

  1008 	    	{

  1009 	    	//Activity is binding (i.e.: we havent received TBindToComplete as a response

  1010 	    	//to null-carrying TBindTo.

  1011 		    activity.ReplyToOriginator(KErrNone);

  1012 	    	}

  1013 	    activity.ResetCurrentDataClient();

  1014 	    return ETrue;

  1015 	    }

  1016     else if (iContext.iMessage.IsMessage<TEBase::TError>())

  1017     	{

  1018 	    activity.ReplyToOriginator(message_cast<TEBase::TError>(iContext.iMessage).iValue);

  1019     	activity.RemoveClientFromSuccessful(activity.CurrentDataClient());

  1020     	activity.ResetCurrentDataClient();

  1021     	return ETrue;

  1022     	}

  1023 	return EFalse;

  1024     }

  1025 

  1026 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TNoTagOrDataClientReady, NetStateMachine::MStateFork, CBindToActivity::TContext)

  1027 TInt CBindToActivity::TNoTagOrDataClientReady::TransitionTag()

  1028     {

  1029     //Any non-leaving dataclients already present?

  1030     if (iContext.Node().CountClients<TDefaultClientMatchPolicy>(

  1031     	/*include*/TClientType(TCFClientType::EData),

  1032     	/*exclude*/TClientType(0, TCFClientType::ELeaving | TCFClientType::EConfigAccessPoint)))

  1033 	    {

  1034 	    return KDataClientReady;

  1035 	    }

  1036 	return KNoTag;

  1037     }

  1038 

  1039 

  1040 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TRequestCommsBinder, NetStateMachine::MStateTransition, CBindToActivity::TContext)

  1041 void CBindToActivity::TRequestCommsBinder::DoL()

  1042     {

  1043 	__ASSERT_DEBUG(iContext.Node().CountClients<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EData)),User::Panic(KCorePrPanic, KPanicDataClient));

  1044 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

  1045   	CBindToActivity& activity = static_cast<CBindToActivity&>(*iContext.iNodeActivity);

  1046 

  1047   	//The service provider has been joined already and must be found here

  1048     __ASSERT_DEBUG(!activity.iNewServiceProvider.IsNull(), User::Panic(KCorePrPanic, KPanicNoServiceProvider));

  1049     RNodeInterface* newServiceProvider = iContext.Node().FindClient(activity.iNewServiceProvider);

  1050     __ASSERT_DEBUG(newServiceProvider, User::Panic(KCorePrPanic, KPanicNoServiceProvider));

  1051     //We must not be in this transition if dc was not found

  1052     __ASSERT_DEBUG(activity.CurrentDataClient(), User::Panic(KCorePrPanic, KPanicDataClient));

  1053 

  1054     // Also if it is not so common to have multiple DataClient (except

  1055     // 	for the relation "SCPR<-CPR"), there are situation where it happens

  1056     // 	and where only one of them is marked as Default.

  1057     // So, we check if this is the case and, in case the

  1058     //	Originator of this activity is NOT a Default one, send ECreateNew.

  1059 

  1060     // If the Current DC is marked as Default, we ask to the lower layer

  1061     //	to "AttachToDefault". If it is not, we ask "CreateNew".

  1062     TInt subConnOpenType = (activity.CurrentDataClient()->Flags() & TCFClientType::EDefault) ?

  1063    			TSubConnOpen::EAttachToDefault : TSubConnOpen::ECreateNew;

  1064 

  1065     // --- WORKAROUND START ---

  1066     // [399TODO] There are situation were we don't have any DataClient marked

  1067     //	as Default, but, asking for ECreateNew, the lower layer doesn't

  1068     //	manage the request very well.

  1069     //	This is a WORKAROUND and need fixing (see DEF113154).

  1070     //	In the meanwhile, we count the number of "DefaultDataClient" and,

  1071     //	if the result is "0", we ask the lower layer "AttachToDefault"

  1072     TInt numberOfDefaultDataClient = iContext.Node().CountClients<TDefaultClientMatchPolicy>(

  1073     		TClientType(TCFClientType::EData, TCFClientType::EDefault)

  1074     		);

  1075     if (numberOfDefaultDataClient == 0)

  1076     	{

  1077     	subConnOpenType = TSubConnOpen::EAttachToDefault;

  1078     	}

  1079     // --- WORKAROUND END ---

  1080 

  1081     // Send "TCommsBinderRequest" to the Current ServiceProvider

  1082    	activity.PostRequestTo(

  1083    			*newServiceProvider,

  1084    			TCFServiceProvider::TCommsBinderRequest(subConnOpenType).CRef()

  1085    			);

  1086     }

  1087 

  1088 

  1089 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TCreateDataClient, NetStateMachine::MStateTransition, CBindToActivity::TContext)

  1090 void CBindToActivity::TCreateDataClient::DoL()

  1091     {

  1092 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

  1093 

  1094 	IssuePeerCreationRequestL ();

  1095     }

  1096 

  1097 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TSendBindTo, NetStateMachine::MStateTransition, CBindToActivity::TContext)

  1098 void CBindToActivity::TSendBindTo::DoL()

  1099     {

  1100 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

  1101 	CBindToActivity& bindToActivity = static_cast<CBindToActivity&>(*iContext.iNodeActivity);

  1102 

  1103 	//Provisionally stash the current dataclient as successful. If it fails to bind, we'll unstash it

  1104 	//We're doing this now, as stashing may fail and we don't want that to be the sole reason for

  1105 	//unrolling.

  1106 	bindToActivity.AddClientAsSuccessfulL(bindToActivity.CurrentDataClient());

  1107 

  1108 	TCFServiceProvider::TCommsBinderResponse* commsBinderResponse = message_cast<TCFServiceProvider::TCommsBinderResponse>(&iContext.iMessage);

  1109 	Messages::TNodeId commsBinder = commsBinderResponse ? commsBinderResponse->iNodeId : Messages::TNodeId::NullId();

  1110 

  1111 	bindToActivity.PostRequestTo(*bindToActivity.CurrentDataClient(),

  1112 			TCFDataClient::TBindTo(commsBinder, !bindToActivity.DataClientsAutocommit()).CRef());

  1113     }

  1114 

  1115 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TSendBindToComplete, NetStateMachine::MStateTransition, CBindToActivity::TContext)

  1116 void CBindToActivity::TSendBindToComplete::DoL()

  1117     {

  1118 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

  1119 	iContext.iNodeActivity->PostToOriginators(TCFDataClient::TBindToComplete().CRef());

  1120     }

  1121 

  1122 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TNoTagOrCommit, NetStateMachine::MStateFork, CBindToActivity::TContext)

  1123 TInt CBindToActivity::TNoTagOrCommit::TransitionTag()

  1124     {

  1125 	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KCorePrPanic, KPanicNoActivity));

  1126 	CBindToActivity& bindToActivity = static_cast<CBindToActivity&>(*iContext.iNodeActivity);

  1127 	if (bindToActivity.IsAutocommit())

  1128 		{

  1129 		return KCommit;

  1130 		}

  1131 	return KNoTag;

  1132     }

  1133 

  1134 EXPORT_DEFINE_SMELEMENT(CBindToActivity::TNoTagOrBindToComplete, NetStateMachine::MStateFork, CBindToActivity::TContext)