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     //Determine who TErrorRecoveryRequest should be sent to.

   547     //If there is no ControlProvider we send a RecoveryRequest to ourselves to recover from the error,

   548     //otherwise we sned the RecoveryRequest up to our ControlProvider.

   549     //MCPrs typically put all of the error recovery function in a single error recovery activity therefore

   550     //it makes sense even for MCPrs to send TErrorRecoveryRequest to their error recovery function. By

   551     //posting a TErrorRecoveryRequest sub-classes of the MCPrs get a chance to override the default error

   552     //recovery.

   553     RNodeInterface*  errorRecoverer = iContext.Node().ControlProvider() ? iContext.Node().ControlProvider() : &iContext.Node().SelfInterface();

   554 

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

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

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

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

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

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

   561 

   562     activity.SetError(errmsg.iValue);

   563     activity.iMessageId = errmsg.iMsgId;

   564 

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

   566 	TEErrorRecovery::TErrorRecoveryRequest msg(ctx);

   567 

   568     activity.PostRequestTo(

   569     	*errorRecoverer,//ControlProvider() verified above

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

   571     	);

   572 

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

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

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

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

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

   578     aa->ClearPostedTo();

   579     }

   580 

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

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

   583     {

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

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

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

   587     if (a == NULL)

   588 		{

   589 		iContext.iNodeActivity->SetIdle();

   590 		return;

   591 		}

   592 

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

   594 		{

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

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

   597 			{ //rerun current transition

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

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

   600 

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

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

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

   604 			if (iContext.iReturn == KErrNone)

   605 				{ //retry succeded

   606 				act->SetError(KErrNone);

   607 				}

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

   609 			//and terminate act->iActivity,

   610 			}

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

   612 			{ //set new error values and fall through

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

   614 			act->iMessageId = resp.iMessageId;

   615 			a->SetError(resp.iError);

   616 			}

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

   618 			{

   619 			__CFLOG_VAR((KCoreProviderStatesTag, KCoreProviderStatesSubTag,

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

   621 			}

   622 		}

   623 	}

   624 

   625 

   626 //-=========================================================

   627 //

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

   629 //

   630 //-=========================================================

   631 

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

   633 	{

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

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

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

   637 	return self;

   638 	}

   639 

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

   641 :	CNodeRetryActivity(aActivitySig, aNode),

   642 	APreallocatedOriginators<1>(iOriginators)

   643 	{

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

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

   646 	}

   647 

   648 void CDestroyActivity::Destroy()

   649 	{

   650 	ReturnPreallocatedSpace(this);

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

   652 

   653 	//Delete the provider.

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

   655 	}

   656 

   657 TBool CDestroyActivity::Next(TNodeContextBase& aContext)

   658     {

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

   660         {  

   661         return ETrue;

   662         }

   663     else

   664         return CNodeActivityBase::Next(aContext);

   665     }

   666 

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

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

   669     {

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

   671 		{

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

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

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

   675 		}

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

   677 		{

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

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

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

   681 			{

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

   683 			}

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

   685 		}

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

   687 	return KNoTag;

   688 	}

   689 

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

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

   692 	{

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

   694 		{

   695 		ProcessClientLeaveL();

   696 		}

   697 	else

   698 		{

   699 		MakeClientsLeaveL();

   700 		}

   701 	}

   702 

   703 void CDestroyActivity::TMakeClientsLeaveOrProcessClientLeave::MakeClientsLeaveL()

   704     {

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

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

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

   708 	iContext.iNodeActivity->ClearPostedTo();

   709 

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

   711 	//come while data client is active etc.

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

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

   714 

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

   716    	RNodeInterface* dc = NULL;

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

   718         {

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

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

   721         }

   722 	}

   723 

   724 void CDestroyActivity::TMakeClientsLeaveOrProcessClientLeave::ProcessClientLeaveL()

   725     {

   726     CDestroyActivity::TProcessClientLeave processClientLeave(iContext);

   727     processClientLeave.DoL();

   728     }

   729 

   730 

   731 //-=========================================================

   732 //

   733 //Loppin Activity

   734 //

   735 //-=========================================================

   736 EXPORT_C ACountLoopActivity::~ACountLoopActivity()

   737     {

   738     }

   739 

   740 

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

   742     {

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

   744     }

   745 

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

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

   748     TIfStaticFetcherNearestInHierarchy(this)

   749     {

   750 	}

   751 

   752 EXPORT_C CCountLoopActivityBase::~CCountLoopActivityBase()

   753     {

   754     }

   755 

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

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

   758 	{

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

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

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

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

   763  		{

   764         return KNoTag | NetStateMachine::EBackward;

   765      	}

   766  	return KNoTag | NetStateMachine::EForward;

   767  	}

   768 

   769 

   770 

   771 

   772 

   773 //-=========================================================

   774 //

   775 //

   776 //Binding Activity

   777 //

   778 //

   779 //-=========================================================

   780 EXPORT_C ABindingActivity::~ABindingActivity()

   781 	{

   782     //Handle premature termination of the ABindingActivity object

   783     //by responding to the originator

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

   785 	if (IsBinding())

   786 		{

   787 		ReplyToOriginator(KErrAbort);

   788 		}

   789 	}

   790 

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

   792     {

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

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

   795     iOriginator = aNodeCtxId;

   796     }

   797 

   798 EXPORT_C void ABindingActivity::ReplyToOriginator(TInt aError)

   799     {

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

   801     //Please allow it to server everyone equally.

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

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

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

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

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

   807     iOriginator.SetNull();

   808     }

   809 

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

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

   812 	{

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

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

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

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

   817 	}

   818 

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

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

   821 	{

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

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

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

   825     if (bindingActivity->IsBinding())

   826 	    {

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

   828 	    }

   829 	}

   830 

   831 void ABindingActivity::FinalReplyToOriginator(TInt aError)

   832 /**

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

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

   835 */

   836 	{

   837 	if (IsBinding())

   838 		{

   839 		ReplyToOriginator(aError);

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

   841 		iOriginator = Messages::TNodeCtxId();

   842 		}

   843 	}

   844 

   845 } // CoreActivities

   846 

   847 

   848 namespace PRActivities

   849 {

   850 DECLARE_DEFINE_ACTIVITY_MAP(coreActivitiesPR)

   851 	ACTIVITY_MAP_ENTRY(PRDataClientJoinActivity, PRDataClientJoin)

   852 	ACTIVITY_MAP_ENTRY(PRControlClientJoinActivity, PRControlClientJoin)

   853 	ACTIVITY_MAP_ENTRY(PRClientLeaveActivity, PRClientLeave)

   854 	ACTIVITY_MAP_ENTRY(PRForwardStateChangeActivity, PRForwardStateChange)

   855 	ACTIVITY_MAP_ENTRY(PRBindToActivity, PRBindTo)

   856 	ACTIVITY_MAP_ENTRY(PRDataClientStartActivity, PRDataClientStart)

   857 	ACTIVITY_MAP_ENTRY(PRDataClientStopActivity, PRDataClientStop)

   858 ACTIVITY_MAP_END_BASE(CoreActivities,coreActivitiesAll)

   859 

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

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

   862 DEFINE_EXPORT_ACTIVITY_MAP(coreActivitiesSCpr)

   863 	ACTIVITY_MAP_ENTRY(PRProvisionActivity, PrProvision)

   864     ACTIVITY_MAP_ENTRY(PRStartActivity, PRStart)

   865     ACTIVITY_MAP_ENTRY(PRStopActivity, PRStop)

   866 	ACTIVITY_MAP_ENTRY(PRDataClientIdleActivity, PRDataClientIdle)

   867 	ACTIVITY_MAP_ENTRY(PRDataClientActiveActivity, PRDataClientActive)

   868 	ACTIVITY_MAP_ENTRY(PRDestroyActivity, PRDestroy)

   869 	ACTIVITY_MAP_ENTRY(PRGoneDownActivity, PRGoneDown)

   870 	ACTIVITY_MAP_ENTRY(PRGoneUpActivity, PRGoneUp) //robertomaro

   871 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   872 	ACTIVITY_MAP_ENTRY(PRSetParamsRequest, PRSetParams)

   873 	ACTIVITY_MAP_ENTRY(PRGetParamsRequest, PRGetParams)

   874 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   875     ACTIVITY_MAP_ENTRY(PRLegacyRMessage2HandlerActivity, PRLegacyRMessage2Handler)

   876 ACTIVITY_MAP_END_BASE(PRActivities,coreActivitiesPR)

   877 

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

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

   880 DEFINE_EXPORT_ACTIVITY_MAP(coreActivitiesCpr)

   881 	ACTIVITY_MAP_ENTRY(PRProvisionActivity, PrProvision)

   882     ACTIVITY_MAP_ENTRY(PRStartActivity, PRStart)

   883     ACTIVITY_MAP_ENTRY(PRStopActivity, PRStop)

   884 	ACTIVITY_MAP_ENTRY(PRDataClientIdleActivity, PRDataClientIdle)

   885 	ACTIVITY_MAP_ENTRY(PRDataClientActiveActivity, PRDataClientActive)

   886 	ACTIVITY_MAP_ENTRY(PRDestroyActivity, PRDestroy)

   887 	ACTIVITY_MAP_ENTRY(PRGoneDownActivity, PRGoneDown)

   888 	ACTIVITY_MAP_ENTRY(PRGoneUpActivity, PRGoneUp) //robertomaro

   889     ACTIVITY_MAP_ENTRY(PRDataClientStatusChangeActivity, PRDataClientStatusChange)

   890 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   891     ACTIVITY_MAP_ENTRY(PRSetParamsRequest, PRSetParams)

   892     ACTIVITY_MAP_ENTRY(PRGetParamsRequest, PRGetParams)

   893 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   894     ACTIVITY_MAP_ENTRY(PRLegacyRMessage2HandlerActivity, PRLegacyRMessage2Handler)

   895 ACTIVITY_MAP_END_BASE(PRActivities,coreActivitiesPR)

   896 

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

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

   899 DEFINE_EXPORT_ACTIVITY_MAP(coreActivitiesMCpr)

   900 	ACTIVITY_MAP_ENTRY(PRDataClientIdleActivity, PRDataClientIdle)

   901 	ACTIVITY_MAP_ENTRY(PRDataClientActiveActivity, PRDataClientActive)

   902     ACTIVITY_MAP_ENTRY(PRDataClientStatusChangeActivity, PRDataClientStatusChange)

   903     ACTIVITY_MAP_ENTRY(PRLegacyRMessage2HandlerActivity, PRLegacyRMessage2Handler)

   904 ACTIVITY_MAP_END_BASE(PRActivities,coreActivitiesPR)

   905 

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

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

   908 DEFINE_EXPORT_ACTIVITY_MAP(coreActivitiesTM)

   909 ACTIVITY_MAP_END_BASE(PRActivities,coreActivitiesPR)

   910 

   911 

   912 

   913 

   914 //-=========================================================

   915 //

   916 //CBindToActivity

   917 //

   918 //-=========================================================

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

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

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

   922 	    TIfStaticFetcherNearestInHierarchy(this)

   923 		{

   924 		}

   925 

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

   927     {

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

   929     TUint c = GetNextActivityCountL(aActivitySig,aNode);

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

   931     if (c > 1)

   932         {

   933         User::Leave(KErrInUse);

   934         }

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

   936     }

   937 

   938 EXPORT_C CBindToActivity::~CBindToActivity()

   939     {

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

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

   942     //is null.

   943 

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

   945     //and rendered iSuccessfulDataClients empty.

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

   947 

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

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

   950 

   951     iSuccessfulDataClients.Close();

   952     }

   953 

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

   955 	{

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

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

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

   959     iCurrentDataClient = iter++;

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

   961     	{

   962         iCurrentDataClient = iter++;

   963         };

   964     return iCurrentDataClient;

   965 	}

   966 

   967 TBool CBindToActivity::DataClientsAutocommit()

   968  	{

   969  	TInt nonLeavingDataClients = iNode.CountClients<TDefaultClientMatchPolicy>(

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

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

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

   973  	}

   974 

   975 

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

   977 	{

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

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

   980 	iSuccessfulDataClients.Append(aDataClient);

   981 	}

   982 

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

   984 	{

   985 	TInt index = iSuccessfulDataClients.Find(aDataClient);

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

   987 	iSuccessfulDataClients.Remove(index);

   988 	}

   989 

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

   991 void CBindToActivity::TSendControlClientJoinRequest::DoL()

   992     {

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

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

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

   996 

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

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

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

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

  1001     activity.iNewServiceProvider = bindToMsg.iNodeId;

  1002     //Join the new service provider

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

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

  1005     }

  1006 

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

  1008 TBool CBindToActivity::TAwaitingBindToCompleteOrError::Accept()

  1009     {

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

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

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

  1013 	    {

  1014 	    if (activity.IsBinding())

  1015 	    	{

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

  1017 	    	//to null-carrying TBindTo.

  1018 		    activity.ReplyToOriginator(KErrNone);

  1019 	    	}

  1020 	    activity.ResetCurrentDataClient();

  1021 	    return ETrue;

  1022 	    }

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

  1024     	{

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

  1026     	activity.RemoveClientFromSuccessful(activity.CurrentDataClient());

  1027     	activity.ResetCurrentDataClient();

  1028     	return ETrue;

  1029     	}

  1030 	return EFalse;

  1031     }

  1032 

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

  1034 TInt CBindToActivity::TNoTagOrDataClientReady::TransitionTag()

  1035     {

  1036     //Any non-leaving dataclients already present?

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

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

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

  1040 	    {

  1041 	    return KDataClientReady;

  1042 	    }

  1043 	return KNoTag;

  1044     }

  1045 

  1046 

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

  1048 void CBindToActivity::TRequestCommsBinder::DoL()

  1049     {

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

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

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

  1053 

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

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

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

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

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

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

  1060 

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

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

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

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

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

  1066 

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

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

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

  1070    			TSubConnOpen::EAttachToDefault : TSubConnOpen::ECreateNew;

  1071 

  1072     // --- WORKAROUND START ---

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

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

  1075     //	manage the request very well.

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

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

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

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

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

  1081     		);

  1082     if (numberOfDefaultDataClient == 0)

  1083     	{

  1084     	subConnOpenType = TSubConnOpen::EAttachToDefault;

  1085     	}

  1086     // --- WORKAROUND END ---

  1087 

  1088     // Send "TCommsBinderRequest" to the Current ServiceProvider

  1089    	activity.PostRequestTo(

  1090    			*newServiceProvider,

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

  1092    			);

  1093     }

  1094 

  1095 

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

  1097 void CBindToActivity::TCreateDataClient::DoL()

  1098     {

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

  1100 

  1101 	IssuePeerCreationRequestL ();

  1102     }

  1103 

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

  1105 void CBindToActivity::TSendBindTo::DoL()

  1106     {

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

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

  1109 

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

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

  1112 	//unrolling.

  1113 	bindToActivity.AddClientAsSuccessfulL(bindToActivity.CurrentDataClient());

  1114 

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

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

  1117 

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

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

  1120     }

  1121 

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

  1123 void CBindToActivity::TSendBindToComplete::DoL()

  1124     {

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

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

  1127     }

  1128 

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

  1130 TInt CBindToActivity::TNoTagOrCommit::TransitionTag()

  1131     {

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

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

  1134 	if (bindToActivity.IsAutocommit())