1 // Copyright (c) 2008-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 // @file

    15 // @internalComponent

    16 // 

    17 //

    18 

    19 //System Includes

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

    21 #include <comms-infras/ss_corepractivities.h>

    22 #include <ss_glob.h>

    23 #include <upnp/tupnptable.h>

    24 #include <httpstringconstants.h>

    25 #include <httperr.h>

    26 #include <rmemchunk.h>

    27 

    28 //Local Includes

    29 #include "upnpflowbase.h"

    30 #include "upnpctrlscpractivities.h"

    31 #include "upnpctrlscprstates.h"

    32 #include "upnpstatemachine.h"

    33 #include "upnpserverconstants.h"

    34 #include "upnplog.h"

    35 

    36 using namespace MeshMachine;

    37 using namespace CoreNetStates;

    38 using namespace CoreStates;

    39 using namespace UPnPControlSCprActivities;

    40 using namespace PRActivities;

    41 using namespace UPnPStateMachine;

    42 using namespace UPnPControlSCprStates;

    43 

    44 

    45 __FLOG_STMT(_LIT8(KComponent,"UPnPCPActivities");)

    46 

    47 

    48 namespace UPnPControlSCprParamRequestActivity

    49 {

    50 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

    51 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityParamRequest, UPnPControlSCprParamRequest, TCFScpr::TSetParamsRequest )

    52 	FIRST_NODEACTIVITY_ENTRY ( TAwaitingSetParamRequest, TNoTag )

    53 	LAST_NODEACTIVITY_ENTRY ( KNoTag, TStoreParamsAndSendResponse )

    54 NODEACTIVITY_END ()

    55 #else

    56 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityParamRequest, UPnPControlSCprParamRequest, TCFScpr::TParamsRequest )

    57 	FIRST_NODEACTIVITY_ENTRY ( TAwaitingSetParamRequest, TNoTag )

    58 	LAST_NODEACTIVITY_ENTRY ( KNoTag, TStoreParamsAndSendResponse )

    59 NODEACTIVITY_END ()

    60 #endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

    61 }

    62 

    63 namespace UPnPControlSCprApplyRequestActivity

    64 {

    65 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

    66 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityApplyChanges, UPnPControlSCprApplyRequest, TCFScpr::TApplyRequest )

    67 	FIRST_NODEACTIVITY_ENTRY ( PRStates::TAwaitingApplyRequest, TNoTag )

    68 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, TInitiateActivities, TNoTag )

    69 	LAST_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TSendApplyResponse )

    70 NODEACTIVITY_END ()

    71 #else

    72 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityApplyChanges, UPnPControlSCprApplyRequest, TCFScpr::TApplyRequest )

    73 	FIRST_NODEACTIVITY_ENTRY ( SCprStates::TAwaitingApplyRequest, TNoTag )

    74 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, TInitiateActivities, TNoTag )

    75 	LAST_NODEACTIVITY_ENTRY ( KNoTag, SCprStates::TSendApplyResponse )

    76 NODEACTIVITY_END ()

    77 #endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

    78 }

    79 

    80 namespace UPnPControlSCprClientLeaveActivity

    81 {

    82 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityClientLeave, UPnPControlSCprClientLeave, TNodeSignal::TNullMessageId ) //May be waiting for both messages

    83 	FIRST_NODEACTIVITY_ENTRY ( TAwaitingClientLeave, TNoTag )

    84 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CUPnPActivityBase::TProcessClientLeave, TNoTag )

    85 	LAST_NODEACTIVITY_ENTRY ( KNoTag, CoreNetStates::TSendDataClientIdle )

    86 NODEACTIVITY_END ()

    87 }

    88 

    89 namespace UPnPControlSCprDestroyActivity

    90 {

    91 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( ECFActivityDestroy, UPnPControlSCprDestroy, TEChild::TDestroy, CoreActivities::CDestroyActivity::New )

    92 	FIRST_NODEACTIVITY_ENTRY ( TAwaitingDestroy, CUPnPActivityBase::TStopActivityOrStopDataClient)

    93 	NODEACTIVITY_ENTRY ( UPnPStateMachine::KActivityStop, CUPnPActivityBase::TStopCurrentActivities, CUPnPActivityBase::TAwaitingResponseToStopActivities, CUPnPActivityBase::TStopActivityOrStopDataClient )	

    94 	NODEACTIVITY_ENTRY ( CoreNetStates::KDataClientsToStop, UPnPStateMachine::TStopDataClients, UPnPStateMachine::TAwaitingToStopDataClients, TNoTag )

    95 	LAST_NODEACTIVITY_ENTRY ( KNoTag, CoreNetStates::TSendClientLeavingAndRemoveControlProvider )

    96 NODEACTIVITY_END ( )

    97 }

    98 

    99 // Activity to create UPnP Flow for RSocket used in UPnP CONTROL Phase

   100 namespace UPnPControlSCprBinderRequestActivity

   101 {

   102 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( ECFActivityBinderRequest, UPnPControlSCprBinderRequest, TCFServiceProvider::TCommsBinderRequest, CCommsBinderActivity::NewL )

   103 	FIRST_NODEACTIVITY_ENTRY ( CoreNetStates::TAwaitingBinderRequest, CCommsBinderActivity::TNoTagOrUseExistingBlockedByBinderRequest )

   104 	NODEACTIVITY_ENTRY ( KNoTag, TCreateControlDataClient, CoreNetStates::TAwaitingDataClientJoin, TNoTag )

   105 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CCommsBinderActivity::TProcessDataClientCreation, TTag<KUseExisting> )	

   106 	NODEACTIVITY_ENTRY ( KUseExisting, CCommsBinderActivity::TSendBinderResponse, UPnPStateMachine::TAwaitingBindToComplete, TNoTagOrErrorTag )

   107 	LAST_NODEACTIVITY_ENTRY ( KNoTag, TDoNothing )

   108 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, TClearError )

   109 NODEACTIVITY_END ()

   110 }

   111 

   112 // Handle DataClientIdle from UPnP Flow created for RSocket used in UPnP CONTROL Phase

   113 namespace UPnPControlSCprDataClientIdleActivity

   114 {

   115 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityDataClientIdle, UPnPControlSCprDataClientIdle, TCFControlProvider::TIdle )

   116     NODEACTIVITY_ENTRY ( KNoTag, UPnPStateMachine::THandleControlChannelDataClientIdle, CoreNetStates::TAwaitingDataClientIdle, TNoTag )

   117 NODEACTIVITY_END ( )

   118 }

   119 

   120 // UPnP discovery activity

   121 namespace UPnPSearchActivity

   122 {

   123 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivitySearchRequest, UPnPSearchRequest, TUpnpMessage::TSearchRequest, CUPnPSearchActivity::NewL )

   124 	FIRST_NODEACTIVITY_ENTRY ( CUPnPSearchActivity::TAwaitingSearchRequest, UPnPSearchStates::TFindUdpClientFlowOrSendRequest )	

   125 	NODEACTIVITY_ENTRY ( KNoTag, TFindOrCreateUdpClientFlow, UPnPControlSCprStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > )

   126 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, TClearError )

   127 	

   128 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, UPnPSearchStates::TStoreUdpClientFlowAndSendRequest )

   129 	THROUGH_NODEACTIVITY_ENTRY ( KSendRequest, CUPnPSearchActivity::TSendSearchRequest, TTag<KLoopTag> )

   130 	NODEACTIVITY_ENTRY ( KLoopTag, TDoNothing, CUPnPSearchActivity::TAwaitingReceiveSearchResponse, UPnPSearchStates::TCancelSearchOrProcessResponseTag )

   131 	THROUGH_NODEACTIVITY_ENTRY ( KProcessResponse, CUPnPSearchActivity::TProcessResponse, TTag<KLoopTag | NetStateMachine::EBackward> )

   132 	

   133 	THROUGH_NODEACTIVITY_ENTRY ( KCancelTag, CUPnPSearchActivity::TCancelSearchRequest, TTag<KLoopTag> )

   134 	NODEACTIVITY_ENTRY ( KLoopTag, TDoNothing, CUPnPSearchActivity::TAwaitingDataClientStopResponse, UPnPSearchStates::TNoTagOrResponseTag )

   135 	THROUGH_NODEACTIVITY_ENTRY ( KProcessResponse, CUPnPSearchActivity::TCleanupActivity, TTag<KLoopTag | NetStateMachine::EBackward> )

   136 	

   137 	LAST_NODEACTIVITY_ENTRY ( KNoTag, TClearError )

   138 NODEACTIVITY_END ()

   139 }

   140 

   141 // UPnP register notify activity

   142 namespace UPnPRegisterNotifyActivity

   143 {

   144 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityRegisterNotifyRequest, UPnPRegisterNotifyRequest, TUpnpMessage::TRegisterNotifyRequest, CUPnPRegisterNotifyActivity::NewL )

   145 	FIRST_NODEACTIVITY_ENTRY ( CUPnPRegisterNotifyActivity::TAwaitingRegisterNotifyRequest, UPnPRegisterNotifyStates::TFindMUdpFlowOrSendRequest )

   146 	

   147 	NODEACTIVITY_ENTRY ( KNoTag, TFindOrCreateUdpServerFlow, UPnPControlSCprStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > )

   148 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, TClearError )

   149 	

   150 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, UPnPRegisterNotifyStates::TStoreMUdpFlowAndStartServer )	

   151 	NODEACTIVITY_ENTRY ( KNoTag, CUPnPRegisterNotifyActivity::TStartServer, CUPnPRegisterNotifyActivity::TAwaitingServerStarted, TTag<KSendRequest> )

   152 	

   153 	THROUGH_NODEACTIVITY_ENTRY ( KSendRequest, CUPnPRegisterNotifyActivity::TSendRegisterRequest, TTag<KLoopTag> )

   154 	NODEACTIVITY_ENTRY ( KLoopTag, TDoNothing, CUPnPRegisterNotifyActivity::TAwaitingReceiveNotifivation, UPnPRegisterNotifyStates::TCancelRegisterOrProcessResponseTag )

   155 	THROUGH_NODEACTIVITY_ENTRY ( KProcessResponse, CUPnPRegisterNotifyActivity::TProcessNotification, TTag< KLoopTag | NetStateMachine::EBackward > )

   156 

   157 	THROUGH_NODEACTIVITY_ENTRY ( KCancelTag, CUPnPRegisterNotifyActivity::TCancelRegisterRequest, TTag< KLoopTag > )

   158 	NODEACTIVITY_ENTRY ( KLoopTag, TDoNothing, CUPnPRegisterNotifyActivity::TAwaitingDataClientStopResponse, UPnPRegisterNotifyStates::TNoTagOrResponseTag )

   159 	THROUGH_NODEACTIVITY_ENTRY ( KProcessResponse, CUPnPRegisterNotifyActivity::TCleanupActivity, TTag< KLoopTag | NetStateMachine::EBackward > )

   160 	

   161 	LAST_NODEACTIVITY_ENTRY ( KNoTag, TClearError )

   162 NODEACTIVITY_END ()

   163 }    

   164 

   165 // UPnP describe activity

   166 namespace UPnPDescribeActivity

   167 {

   168 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityDescribeRequest, UPnPDescribeRequest, TUpnpMessage::TDescribeRequest, CUpnpDescribeActivity::NewL )

   169 	FIRST_NODEACTIVITY_ENTRY ( CUpnpDescribeActivity::TAwaitingDescribeRequest, UPnPControlSCprStates::TFindHttpClientFlowOrSendRequest )

   170 	

   171 	NODEACTIVITY_ENTRY ( KNoTag, UPnPControlSCprStates::TFindOrCreateHttpClientFlow, UPnPControlSCprStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > )

   172 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, TClearError )

   173 	

   174 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, TNoTag )

   175 	THROUGH_NODEACTIVITY_ENTRY( KNoTag, UPnPControlSCprStates::TProcessHttpDataClient, TTag<KSendRequest> )

   176 	

   177 	NODEACTIVITY_ENTRY ( KSendRequest, CUpnpDescribeActivity::TSendDescribeRequest, CUpnpDescribeActivity::TAwaitingErrorOrResponseOrCancel, UPnPDescribeStates::TCancelDescribeOrProcessResponseTag )

   178 	LAST_NODEACTIVITY_ENTRY ( KProcessResponse, CUpnpDescribeActivity::TProcessResponse )

   179 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, CUpnpDescribeActivity::TReportError )

   180 	

   181 	NODEACTIVITY_ENTRY ( KCancelTag, CUpnpDescribeActivity::TDataClientStop, CUpnpDescribeActivity::TAwaitingDataClientStopResponse, UPnPDescribeStates::TCancelDescribeOrProcessResponseTag )

   182 	LAST_NODEACTIVITY_ENTRY ( KProcessResponse, CUpnpDescribeActivity::TCleanupActivity )

   183 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, TClearError )

   184 	

   185 	LAST_NODEACTIVITY_ENTRY ( KNoTag, TClearError )

   186 NODEACTIVITY_END ( )

   187 }

   188 

   189 //UPnP subscribe activity.

   190 namespace UpnpSubscribeActivity

   191 {

   192 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivitySubscribeRequest, UPnPSubscribeRequest, TUpnpMessage::TSubscribeRequest, CUpnpSubscribeActivity::NewL )

   193 	FIRST_NODEACTIVITY_ENTRY ( CUpnpSubscribeActivity::TAwaitingSubscribeRequest, UPnPControlSCprStates::TFindHttpClientFlowOrSendRequest )

   194 	

   195 	NODEACTIVITY_ENTRY ( KNoTag, UPnPControlSCprStates::TFindOrCreateHttpClientFlow, UPnPControlSCprStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > )

   196 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, TClearError )

   197 	

   198 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, TNoTag )

   199 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, UPnPControlSCprStates::TProcessHttpDataClient, TTag<KSendRequest> )

   200 	

   201 	NODEACTIVITY_ENTRY ( KSendRequest, CUpnpSubscribeActivity::TSendSubscribeRequest, CUpnpSubscribeActivity::TAwaitingErrorOrResponseOrCancel, UPnPSubscribeStates::TErrorOrProcessResponseTag )

   202 	

   203 	// flow responds with TError or TSubscribeResponse

   204 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, CUpnpSubscribeActivity::TReportError )	

   205 	THROUGH_NODEACTIVITY_ENTRY ( KProcessResponse, CUpnpSubscribeActivity::TProcessSubscribeResponse, UPnPSubscribeStates::TNoTagOrCancelSubscribe )

   206 	LAST_NODEACTIVITY_ENTRY ( KNoTag, TDoNothing )

   207 	

   208 	// if node is in closing state, subscription is completed, then perform unsubscription

   209 	NODEACTIVITY_ENTRY ( KCancelTag, CUpnpSubscribeActivity::TSendUnsubscribeRequest, CUpnpUnSubscribeActivity::TAwaitingErrorOrResponse, TNoTag )

   210 	// even if received TError remove the subscription as already closing

   211 	LAST_NODEACTIVITY_ENTRY ( KNoTag, CUpnpSubscribeActivity::TProcessUnsubscribeResponse )

   212 NODEACTIVITY_END ( )

   213 }

   214 

   215 //UPnP unsubscribe activity.

   216 namespace UpnpUnSubscribeActivity

   217 {

   218 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityUnSubscribeRequest, UPnPUnSubscribeRequest, TUpnpMessage::TCancelParamSet, CUpnpUnSubscribeActivity::NewL )

   219 	FIRST_NODEACTIVITY_ENTRY ( CUpnpUnSubscribeActivity::TAwaitingUnSubscribeRequest, TNoTag )

   220 	NODEACTIVITY_ENTRY ( KNoTag, CUpnpUnSubscribeActivity::TSendUnSubscribeRequest, CUpnpUnSubscribeActivity::TAwaitingErrorOrResponse, TNoTag )

   221 	LAST_NODEACTIVITY_ENTRY ( KNoTag, CUpnpUnSubscribeActivity::TProcessResponse )

   222 NODEACTIVITY_END ( )

   223 }

   224 

   225 

   226 //UPnP notification activity.

   227 namespace UpnpNotificationActivity

   228 {

   229 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityEventNotify, UPnPNotifyRequest, TUpnpMessage::TUPnPRequestInfo, CUpnpNotificationActivity::NewL )

   230 	FIRST_NODEACTIVITY_ENTRY ( UPnPStateMachine::TAwaitingUpnpRequestInfo, UPnPStateMachine::TRequestOrIgnoreTag )

   231 	THROUGH_NODEACTIVITY_ENTRY ( UPnPStateMachine::KNotifyRequest, CUpnpNotificationActivity::TProcessNotifyRequest, TNoTag )

   232 	LAST_NODEACTIVITY_ENTRY ( KNoTag, CUpnpNotificationActivity::TSendResponse )

   233 	

   234 	LAST_NODEACTIVITY_ENTRY ( KIgnore, UPnPStateMachine::TSendIgnoreResponse )

   235 NODEACTIVITY_END ( )

   236 }

   237 

   238 // UPnP Flow finder.

   239 namespace UpnpCallbackFlowFinderActivity

   240 	{

   241 DECLARE_DEFINE_NODEACTIVITY ( TUpnpMessage::EActivityFindOrCreateFlow, FindOrCreateFlow, TUpnpMessage::TCreateServerFlow )

   242 	FIRST_NODEACTIVITY_ENTRY ( UPnPStateMachine::TAwaitingServerFlowRequest, TNoTag )

   243 	

   244 	NODEACTIVITY_ENTRY ( KNoTag, UPnPStateMachine::TCreateServerFlow<ECallback>, UPnPControlSCprStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > )

   245 	LAST_NODEACTIVITY_ENTRY ( KErrorTag, UPnPControlSCprStates::TSendActivityStopped )

   246 	

   247 	THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, TNoTag )

   248 	NODEACTIVITY_ENTRY ( KNoTag, UPnPControlSCprStates::TProcessCallbackDataClient , CoreNetStates::TAwaitingDataClientStarted, TNoTag )

   249 	LAST_NODEACTIVITY_ENTRY ( KNoTag, TDoNothing )

   250 NODEACTIVITY_END ( )

   251 	}

   252 

   253 //ActivityMap

   254 namespace UPnPControlSCprActivities

   255 {

   256 DEFINE_ACTIVITY_MAP ( activityMap )

   257 	ACTIVITY_MAP_ENTRY ( UPnPControlSCprParamRequestActivity, UPnPControlSCprParamRequest )

   258 	ACTIVITY_MAP_ENTRY ( UPnPControlSCprApplyRequestActivity, UPnPControlSCprApplyRequest )	

   259 	ACTIVITY_MAP_ENTRY ( UPnPControlSCprBinderRequestActivity, UPnPControlSCprBinderRequest )

   260 	ACTIVITY_MAP_ENTRY ( UPnPControlSCprDataClientIdleActivity, UPnPControlSCprDataClientIdle )

   261 	ACTIVITY_MAP_ENTRY ( UPnPControlSCprClientLeaveActivity, UPnPControlSCprClientLeave )

   262 	ACTIVITY_MAP_ENTRY ( UPnPSearchActivity, UPnPSearchRequest )

   263 	ACTIVITY_MAP_ENTRY ( UPnPRegisterNotifyActivity, UPnPRegisterNotifyRequest )

   264 	ACTIVITY_MAP_ENTRY ( UPnPDescribeActivity, UPnPDescribeRequest )

   265 	ACTIVITY_MAP_ENTRY ( UpnpSubscribeActivity, UPnPSubscribeRequest )

   266 	ACTIVITY_MAP_ENTRY ( UpnpUnSubscribeActivity, UPnPUnSubscribeRequest )

   267 	ACTIVITY_MAP_ENTRY ( UpnpNotificationActivity, UPnPNotifyRequest )

   268 	ACTIVITY_MAP_ENTRY ( UpnpCallbackFlowFinderActivity, FindOrCreateFlow )

   269 	ACTIVITY_MAP_ENTRY ( UPnPControlSCprDestroyActivity, UPnPControlSCprDestroy )

   270 ACTIVITY_MAP_END_BASE ( SCprActivities, coreSCprActivities )

   271 }

   272 

   273 //---------------------------------------Control Point Activity base class-------------------------------------

   274 

   275 CUPnPActivityBase::~CUPnPActivityBase()

   276 	{

   277 	//This is the last upnp activity. Post TActivityStopped

   278 	if ( static_cast<CUPnPControlSubConnectionProvider&>(iNode).IsClosing ( ) 

   279 			&& iNode.CountAllActivities () == 1 ) // only - destroy and no upnp activity is pending

   280 		{

   281 		RClientInterface::OpenPostMessageClose ( iNode.Id (), iNode.Id (), TUpnpMessage::TActivityStopped ().CRef () );

   282 		}

   283 	};

   284 	

   285 TBool CUPnPActivityBase::Next ( TNodeContextBase& aContext )

   286 	{

   287 	if ( aContext.iMessage.IsMessage<TUpnpMessage::TCancelParamSet> () || aContext.iMessage.IsMessage<TUpnpMessage::TCancelRequest> () )

   288         	return ACore::Next ( &aContext );

   289 	return CNodeActivityBase::Next ( aContext );

   290 	}

   291 

   292 DEFINE_SMELEMENT ( CUPnPActivityBase::TAwaitingResponseToStopActivities, NetStateMachine::MState, CUPnPActivityBase::TContext )

   293 TBool CUPnPActivityBase::TAwaitingResponseToStopActivities::Accept ( )

   294 	{

   295 	LOG(ESockLogExternal::Printf(KSubsysBaseActivity, KComponent, _L8("CUPnPActivityBase::TAwaitingResponseToStopActivities::Accept - Message=TActivityStopped")));

   296 	if(iContext.iMessage.IsMessage<TUpnpMessage::TActivityStopped>())

   297 		{

   298 		//Check whether all UPnP activities are closed or not.

   299 		if(iContext.iNode.CountAllActivities() > 1 )

   300 			{

   301 			return EFalse;

   302 			}	

   303 		return ETrue;	

   304 		}

   305 	return 	 EFalse;

   306 	}

   307 

   308 DEFINE_SMELEMENT ( CUPnPActivityBase::TStopCurrentActivities, NetStateMachine::MStateTransition, CUPnPActivityBase::TContext )

   309 void CUPnPActivityBase::TStopCurrentActivities::DoL ( )

   310 	{

   311 	LOG(ESockLogExternal::Printf(KSubsysBaseActivity, KComponent, _L8("CUPnPActivityBase::TStopCurrentActivities::DoL")));

   312 	TInt activityCount = iContext.Node().CountAllActivities();

   313 	//Cancel all activities and allow them to do cleanup 

   314 	for( TInt index = 0; index < activityCount-1; index++ )

   315 		{

   316 		RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.NodeId (), TUpnpMessage::TCancelRequest ().CRef () );

   317 		}		

   318 	}

   319 

   320 DEFINE_SMELEMENT ( CUPnPActivityBase::TStopActivityOrStopDataClient, NetStateMachine::MStateFork, CUPnPActivityBase::TContext )

   321 TInt CUPnPActivityBase::TStopActivityOrStopDataClient::TransitionTag ( )

   322 	{

   323 	if ( iContext.Node().CountAllActivities() > 1 )

   324 		{

   325 		//There are some active data clients

   326 		return UPnPStateMachine::KActivityStop;

   327 		}

   328 	if ( iContext.Node ().CountClients<TDefaultClientMatchPolicy> ( TClientType ( TCFClientType::EData) ) > 0 )

   329 		{

   330 		return CoreNetStates::KDataClientsToStop;

   331 		}

   332 	return KNoTag;

   333 	}

   334 

   335 

   336 //---------------------------------------Control Point Search Request Activity-------------------------------------

   337 CNodeActivityBase* CUPnPSearchActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode )

   338 	{

   339 	TUint activityId = GetNextActivityCountL ( aActivitySig, aNode );

   340 	return ( new ( ELeave ) CUPnPSearchActivity( aActivitySig, aNode, activityId ) );

   341 	}

   342 

   343 CUPnPSearchActivity::~CUPnPSearchActivity ( )

   344 	{

   345 	SetError ( KErrNone );

   346 	delete static_cast<CUPnPDiscoverRequestParamSet*>(iRequestParamSet);

   347 	}

   348 

   349 DEFINE_SMELEMENT (CUPnPSearchActivity::TAwaitingReceiveSearchResponse, NetStateMachine::MState, CUPnPSearchActivity::TContext )

   350 TBool CUPnPSearchActivity::TAwaitingReceiveSearchResponse::Accept ( )

   351 	{

   352 	if(iContext.iMessage.IsMessage<TUpnpMessage::TUPnPSearchResponse>())

   353 		{

   354 		LOG(ESockLogExternal::Printf(KSubsysSearchActivity, KComponent, _L8("CUPnPSearchActivity::TAwaitingReceiveSearchResponse::Accept - Message=TUpnpMessage::TUPnPSearchResponse")));

   355 		return ETrue;

   356 		}

   357 	if(iContext.iMessage.IsMessage<TUpnpMessage::TCancelParamSet>())

   358 		{

   359 		LOG(ESockLogExternal::Printf(KSubsysSearchActivity, KComponent, _L8("CUPnPSearchActivity::TAwaitingReceiveSearchResponse::Accept - Message=TCancelParamSet")));

   360 		CUPnPSearchActivity& activity = static_cast<CUPnPSearchActivity&> ( *iContext.iNodeActivity );

   361 		TUpnpMessage::TCancelParamSet& msg = message_cast< TUpnpMessage::TCancelParamSet > ( iContext.iMessage );

   362 		CUPnPRequestParamSetBase* paramSet = static_cast<CUPnPRequestParamSetBase*>(msg.iParamSet);

   363 		if( activity.iRequestParamSet->Uri().CompareF(paramSet->Uri()) == 0

   364 				&& paramSet->GetTypeId().iType == EUPnPCancelDiscoverParamSet )

   365 			{

   366 			delete static_cast<CUPnPCancelDiscoverParamSet*>(msg.iParamSet);		

   367 			return ETrue;

   368 			}

   369 		}

   370 	if(iContext.iMessage.IsMessage<TUpnpMessage::TCancelRequest>())

   371 		{

   372 		return ETrue;

   373 		}

   374 	return EFalse;

   375 	}

   376 

   377 DEFINE_SMELEMENT ( CUPnPSearchActivity::TProcessResponse, NetStateMachine::MStateTransition, CUPnPSearchActivity::TContext )

   378 void CUPnPSearchActivity::TProcessResponse::DoL ( )

   379 	{

   380 	LOG(ESockLogExternal::Printf(KSubsysSearchActivity, KComponent, _L8("CUPnPSearchActivity::TProcessResponse::DoL")));

   381 	

   382 	TUpnpMessage::TUPnPSearchResponse& msg = message_cast< TUpnpMessage::TUPnPSearchResponse > ( iContext.iMessage );

   383 	

   384 	TUPnPEvent event;

   385 	event.iStatus = TUPnPEvent::ESuccess;

   386 	event.iErrorCode = KErrNone;

   387 	RParameterFamily family ;

   388 	CUPnPDiscoverResponseParamSet* resParamSet = CUPnPDiscoverResponseParamSet::NewL( family );

   389 	CleanupStack::PushL( resParamSet );

   390 	resParamSet->SetUPnPEvent( event );

   391 	

   392 	RBuf8 searchTarget;

   393 	searchTarget.CreateMax(msg.iSsdpInfo.iSearchTarget.Length());

   394 	msg.iSsdpInfo.iSearchTarget.CopyOut(searchTarget);

   395 	msg.iSsdpInfo.iSearchTarget.Free();

   396 	resParamSet->SetUriL(searchTarget);

   397 	

   398 	RBuf8 location;

   399 	location.CreateMax(msg.iSsdpInfo.iLocation.Length());

   400 	msg.iSsdpInfo.iLocation.CopyOut(location);

   401 	msg.iSsdpInfo.iLocation.Free();

   402 	resParamSet->SetDeviceLocationL(location);

   403 	

   404 	resParamSet->SetExpiryTime(msg.iSsdpInfo.iMx);

   405 	

   406 	RBuf8 usn;

   407 	usn.CreateMax(msg.iSsdpInfo.iUsn.Length());

   408 	msg.iSsdpInfo.iUsn.CopyOut(usn);

   409 	msg.iSsdpInfo.iUsn.Free();

   410 	resParamSet->SetUSNL(usn);

   411 	

   412 	iContext.Node().AddResponseParamSetL( resParamSet, EUPnPDiscoverResponseParamSet );

   413 	CleanupStack::Pop( resParamSet );

   414 	}

   415 

   416 DEFINE_SMELEMENT ( CUPnPSearchActivity::TSendSearchRequest, NetStateMachine::MStateTransition, CUPnPSearchActivity::TContext )

   417 void CUPnPSearchActivity::TSendSearchRequest::DoL ( )

   418 	{

   419 	LOG(ESockLogExternal::Printf(KSubsysSearchActivity, KComponent, _L8("CUPnPSearchActivity::TSendSearchRequest::DoL")));

   420 	

   421 	TAppProtAddr protAddr( KSsdpMulticastAddr, KUpnpMCPort );	

   422 	CUPnPSearchActivity& activity = static_cast<CUPnPSearchActivity&> ( *iContext.iNodeActivity );

   423 	activity.iFlowId = iContext.Node ().UdpClientFlow ();

   424 	

   425 	RMemChunk searchTarget;

   426 	searchTarget.CreateL ( static_cast<CUPnPDiscoverRequestParamSet *> ( activity.iRequestParamSet )->Uri (), iContext.Node ( ).ConnectionProvider().MemoryAllocator());

   427 	TSsdpInfo searchInfo ( static_cast<CUPnPDiscoverRequestParamSet *> ( activity.iRequestParamSet )->ResponseTime (), searchTarget);

   428 	

   429 	activity.PostRequestTo ( activity.iFlowId, TUpnpMessage::TUPnPSearchRequest ( searchInfo ).CRef () );

   430 	}

   431 

   432 DEFINE_SMELEMENT ( CUPnPSearchActivity::TCancelSearchRequest, NetStateMachine::MStateTransition, CUPnPRegisterNotifyActivity::TContext )

   433 void CUPnPSearchActivity::TCancelSearchRequest::DoL ( )

   434 	{

   435 	LOG(ESockLogExternal::Printf(KSubsysSearchActivity, KComponent, _L8("CUPnPSearchActivity::TCancelSearchRequest::DoL")));

   436 	

   437 	RClientInterface::OpenPostMessageClose ( TNodeCtxId (  iContext.iNodeActivity->ActivityId (), iContext.NodeId () ), iContext.Node ().UdpClientFlow (),

   438 											 TUpnpMessage::TCancelRequest ().CRef () );

   439 	}

   440 

   441 DEFINE_SMELEMENT ( CUPnPSearchActivity::TCleanupActivity, NetStateMachine::MStateTransition, CUPnPSearchActivity::TContext )

   442 void CUPnPSearchActivity::TCleanupActivity::DoL ( )

   443 	{

   444 	if ( iContext.iMessage.IsMessage<TUpnpMessage::TUPnPSearchResponse> () )

   445 		{

   446 		TUpnpMessage::TUPnPSearchResponse& msg = message_cast< TUpnpMessage::TUPnPSearchResponse > ( iContext.iMessage );

   447 		msg.iSsdpInfo.iLocation.Free ();

   448 		msg.iSsdpInfo.iUsn.Free ();

   449 		}

   450 	}

   451 //---------------------------------------Register Notify Request Activity-------------------------------------

   452 CNodeActivityBase* CUPnPRegisterNotifyActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode )

   453 	{

   454 	TUint activityId = GetNextActivityCountL ( aActivitySig, aNode );

   455 	return ( new ( ELeave ) CUPnPRegisterNotifyActivity( aActivitySig, aNode, activityId ) );

   456 	}

   457 

   458 CUPnPRegisterNotifyActivity::~CUPnPRegisterNotifyActivity ( )

   459 	{

   460 	SetError ( KErrNone );

   461 	delete static_cast<CUPnPRegisterAnnouncementParamSet *>(iRequestParamSet);

   462 	}

   463 

   464 DEFINE_SMELEMENT (CUPnPRegisterNotifyActivity::TAwaitingReceiveNotifivation, NetStateMachine::MState, CUPnPRegisterNotifyActivity::TContext )

   465 TBool CUPnPRegisterNotifyActivity::TAwaitingReceiveNotifivation::Accept ( )

   466 	{

   467 	CUPnPRegisterNotifyActivity& activity = static_cast<CUPnPRegisterNotifyActivity&> ( *iContext.iNodeActivity );

   468 	if( iContext.iMessage.IsMessage<TUpnpMessage::TUPnPPublishAliveRequest>() 

   469 	 	|| iContext.iMessage.IsMessage<TUpnpMessage::TUPnPPublishByeRequest>() )

   470 		{

   471 		LOG(ESockLogExternal::Printf(KSubsysRegNotifyActivity, KComponent, _L8("CUPnPRegisterNotifyActivity::TAwaitingReceiveNotification::Accept - Message=TUpnpMessage::TUPnPPublishAliveRequest")));

   472 		return ETrue;

   473 		}

   474 	if( iContext.iMessage.IsMessage<TUpnpMessage::TCancelParamSet>())

   475 		{

   476 		LOG(ESockLogExternal::Printf(KSubsysRegNotifyActivity, KComponent, _L8("CUPnPRegisterNotifyActivity::TAwaitingReceiveNotification::Accept - Message=TDataClientStop")));

   477 		TUpnpMessage::TCancelParamSet& msg = message_cast< TUpnpMessage::TCancelParamSet > ( iContext.iMessage );

   478 		CUPnPRequestParamSetBase* paramSet = static_cast<CUPnPRequestParamSetBase*>(msg.iParamSet);

   479 		if( activity.iRequestParamSet->Uri().CompareF(paramSet->Uri()) == 0

   480 				&& paramSet->GetTypeId().iType == EUPnPCancelRegisterNotifyParamSet )

   481 			{

   482 			delete static_cast<CUPnPCancelRegisterNotifyParamSet*>(msg.iParamSet);		

   483 			return ETrue;

   484 			}

   485 		}

   486 	if(iContext.iMessage.IsMessage<TUpnpMessage::TCancelRequest>())

   487 		{

   488 		LOG(ESockLogExternal::Printf(KSubsysRegNotifyActivity, KComponent, _L8("CUPnPRegisterNotifyActivity::TAwaitingReceiveNotification::Accept - Message=TUpnpMessage::TCancelRequest")));

   489 		return ETrue;

   490 		}

   491 	return EFalse;

   492 	}

   493 

   494 DEFINE_SMELEMENT ( CUPnPRegisterNotifyActivity::TStartServer, NetStateMachine::MStateTransition, CUPnPRegisterNotifyActivity::TContext )

   495 void CUPnPRegisterNotifyActivity::TStartServer::DoL ( )

   496 	{

   497 	LOG(ESockLogExternal::Printf(KSubsysRegNotifyActivity, KComponent, _L8("CUPnPRegisterNotifyActivity::TStartServer::DoL")));		

   498 	iContext.iNodeActivity->PostRequestTo ( iContext.Node ( ).UdpServerFlow ( ), TCFDataClient::TStart ().CRef () );

   499 	}

   500 

   501 DEFINE_SMELEMENT ( CUPnPRegisterNotifyActivity::TProcessNotification, NetStateMachine::MStateTransition, CUPnPRegisterNotifyActivity::TContext )

   502 void CUPnPRegisterNotifyActivity::TProcessNotification::DoL ( )

   503 	{

   504 	if ( iContext.iMessage.IsMessage<TUpnpMessage::TUPnPPublishAliveRequest> () )

   505 		{

   506 		LOG(ESockLogExternal::Printf(KSubsysRegNotifyActivity, KComponent, _L8("CUPnPRegisterNotifyActivity::TProcessNotification::DoL - Message=TUpnpMessage::TUPnPPublishAliveRequest")));

   507 		TUpnpMessage::TUPnPPublishAliveRequest& notifyMsg = message_cast<TUpnpMessage::TUPnPPublishAliveRequest> ( iContext.iMessage );

   508 		RParameterFamily family ;

   509 	  	CUPnPPresenceAnnouncementParamSet*	notifyMsgParamSet = CUPnPPresenceAnnouncementParamSet::NewL ( family );

   510 	  	CleanupStack::PushL ( notifyMsgParamSet );

   511 

   512 		notifyMsgParamSet->SetDuration ( notifyMsg.iSsdpInfo.iMx );

   513 

   514 		RBuf8 location;

   515 		location.CreateMaxL ( notifyMsg.iSsdpInfo.iLocation.Length () );

   516 		notifyMsg.iSsdpInfo.iLocation.CopyOut ( location );

   517 		notifyMsg.iSsdpInfo.iLocation.Free ();

   518 		notifyMsgParamSet->SetServiceLocationL ( location );

   519 

   520 		RBuf8 usn;

   521 		usn.CreateMaxL ( notifyMsg.iSsdpInfo.iUsn.Length() );

   522 		notifyMsg.iSsdpInfo.iUsn.CopyOut ( usn );

   523 		notifyMsg.iSsdpInfo.iUsn.Free ();

   524 		notifyMsgParamSet->SetUSNL ( usn);

   525 

   526 		RBuf8 searchTarget;

   527 		searchTarget.CreateMaxL ( notifyMsg.iSsdpInfo.iSearchTarget.Length () );

   528 		notifyMsg.iSsdpInfo.iSearchTarget.CopyOut ( searchTarget );

   529 		notifyMsg.iSsdpInfo.iSearchTarget.Free ();

   530 		notifyMsgParamSet->SetUriL ( searchTarget );

   531 		

   532 	  	CleanupStack::Pop ( notifyMsgParamSet );

   533 		iContext.Node ().AddResponseParamSetL ( notifyMsgParamSet, EUPnPPresenceAnnouncementParamSet );

   534 		}

   535 		

   536 	if ( iContext.iMessage.IsMessage<TUpnpMessage::TUPnPPublishByeRequest> () )

   537 		{

   538 		LOG(ESockLogExternal::Printf(KSubsysRegNotifyActivity, KComponent, _L8("CUPnPRegisterNotifyActivity::TProcessNotification::DoL - Message=TUpnpMessage::TUPnPPublishByeRequest")));

   539 		

   540 		TUpnpMessage::TUPnPPublishByeRequest& notifyMsg = message_cast<TUpnpMessage::TUPnPPublishByeRequest> ( iContext.iMessage );

   541 		RParameterFamily family ;

   542 	  	CUPnPAbsenceAnnouncementParamSet* notifyMsgParamSet = CUPnPAbsenceAnnouncementParamSet::NewL ( family );

   543 	  	CleanupStack::PushL ( notifyMsgParamSet );

   544 

   545 		RBuf8 usn;

   546 		usn.CreateMaxL ( ( notifyMsg.iSsdpInfo.iUsn ).Length () );

   547 		notifyMsg.iSsdpInfo.iUsn.CopyOut ( usn );

   548 		notifyMsg.iSsdpInfo.iUsn.Free ();

   549 		notifyMsgParamSet->SetUSNL ( usn);

   550 

   551 		RBuf8 searchTarget;

   552 		searchTarget.CreateMaxL ( ( notifyMsg.iSsdpInfo.iSearchTarget ).Length () );

   553 		notifyMsg.iSsdpInfo.iSearchTarget.CopyOut ( searchTarget );

   554 		notifyMsg.iSsdpInfo.iSearchTarget.Free ();

   555 		notifyMsgParamSet->SetUriL ( searchTarget );

   556 		

   557 	  	CleanupStack::Pop ( notifyMsgParamSet );

   558 		iContext.Node ().AddResponseParamSetL ( notifyMsgParamSet, EUPnPAbsenceAnnouncementParamSet );

   559 		}

   560 		

   561 	}

   562 

   563 DEFINE_SMELEMENT ( CUPnPRegisterNotifyActivity::TCancelRegisterRequest, NetStateMachine::MStateTransition, CUPnPRegisterNotifyActivity::TContext )

   564 void CUPnPRegisterNotifyActivity::TCancelRegisterRequest::DoL ( )

   565 	{

   566 	LOG(ESockLogExternal::Printf(KSubsysRegNotifyActivity, KComponent, _L8("CUPnPRegisterNotifyActivity::TCancelRegisterRequest::DoL")));

   567 	

   568 	RClientInterface::OpenPostMessageClose ( TNodeCtxId (  iContext.iNodeActivity->ActivityId (), iContext.NodeId () ), iContext.Node ().UdpServerFlow (),

   569 											 TUpnpMessage::TCancelRequest ().CRef () );	

   570 	}

   571 

   572 DEFINE_SMELEMENT ( CUPnPRegisterNotifyActivity::TSendRegisterRequest, NetStateMachine::MStateTransition, CUPnPRegisterNotifyActivity::TContext )

   573 void CUPnPRegisterNotifyActivity::TSendRegisterRequest::DoL ( )

   574 	{	

   575 	LOG(ESockLogExternal::Printf(KSubsysRegNotifyActivity, KComponent, _L8("CUPnPRegisterNotifyActivity::TSendRegisterRequest::DoL")));	

   576 	

   577 	CUPnPRegisterNotifyActivity& activity = static_cast<CUPnPRegisterNotifyActivity&> ( *iContext.iNodeActivity );

   578 	activity.iFlowId = iContext.Node().UdpServerFlow();

   579 		

   580 	RMemChunk notifyTarget;

   581 	notifyTarget.CreateL ( activity.iRequestParamSet->Uri (), iContext.Node ( ).ConnectionProvider().MemoryAllocator() );

   582 	TSsdpInfo registerInfo ( notifyTarget );

   583 	

   584 	TAppProtAddr protAddr ( KSsdpMulticastAddr, KUpnpMCPort );		

   585 	activity.PostRequestTo ( activity.iFlowId, TUpnpMessage::TUPnPNotifyRegistration ( registerInfo ).CRef () );

   586 	}

   587 	

   588 DEFINE_SMELEMENT ( CUPnPRegisterNotifyActivity::TCleanupActivity, NetStateMachine::MStateTransition, CUPnPRegisterNotifyActivity::TContext )

   589 void CUPnPRegisterNotifyActivity::TCleanupActivity::DoL ( )

   590 	{

   591 	if ( iContext.iMessage.IsMessage<TUpnpMessage::TUPnPPublishAliveRequest> () )

   592 		{

   593 		TUpnpMessage::TUPnPPublishAliveRequest& notifyMsg = message_cast<TUpnpMessage::TUPnPPublishAliveRequest> ( iContext.iMessage );

   594 		notifyMsg.iSsdpInfo.iLocation.Free ();

   595 		notifyMsg.iSsdpInfo.iUsn.Free ();

   596 		notifyMsg.iSsdpInfo.iSearchTarget.Free ();

   597 		}

   598 	else if ( iContext.iMessage.IsMessage<TUpnpMessage::TUPnPPublishByeRequest> () )

   599 		{

   600 		TUpnpMessage::TUPnPPublishByeRequest& notifyMsg = message_cast<TUpnpMessage::TUPnPPublishByeRequest> ( iContext.iMessage );

   601 		notifyMsg.iSsdpInfo.iUsn.Free ();

   602 		notifyMsg.iSsdpInfo.iSearchTarget.Free ();

   603 		}

   604 	}

   605 

   606 //==================================================Describe request activity==========================================//

   607 

   608 CNodeActivityBase* CUpnpDescribeActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode )

   609 	{

   610 	TUint activityId = GetNextActivityCountL ( aActivitySig, aNode );

   611 	return( new ( ELeave ) CUpnpDescribeActivity ( aActivitySig, aNode, activityId ) );

   612 	}

   613 

   614 CUpnpDescribeActivity::~CUpnpDescribeActivity ( )

   615 	{

   616 	SetError( KErrNone );

   617 	delete static_cast<CUPnPDescribeRequestParamSet *>(iRequestParamSet);	

   618 	}

   619 

   620 // States

   621 DEFINE_SMELEMENT( CUpnpDescribeActivity::TAwaitingErrorOrResponseOrCancel, NetStateMachine::MState, CUpnpDescribeActivity::TContext )

   622 TBool CUpnpDescribeActivity::TAwaitingErrorOrResponseOrCancel::Accept ()

   623 	{

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

   625 		{

   626 		LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TAwaitingErrorOrResponseOrCancel::Accept - Message=TCFMessage::TError")));

   627 		iContext.iNodeActivity->SetError ( message_cast<TEBase::TError> ( iContext.iMessage ).iValue );

   628 		return ETrue;

   629 		}

   630 	if ( iContext.iMessage.IsMessage<TUpnpMessage::TResponse> () )

   631 		{

   632 		LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TAwaitingErrorOrResponseOrCancel::Accept - Message=TUpnpMessage::TResponse")));

   633 		return ETrue;

   634 		}

   635 	if ( iContext.iMessage.IsMessage< TUpnpMessage::TCancelParamSet> () )

   636 		{

   637 		LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TCancelParamSet::Accept - Message=TCancelParamSet")));

   638 

   639 		CUpnpDescribeActivity& activity = static_cast<CUpnpDescribeActivity&> ( *iContext.iNodeActivity );

   640 		TUpnpMessage::TCancelParamSet& msg = message_cast< TUpnpMessage::TCancelParamSet > ( iContext.iMessage );

   641 		CUPnPRequestParamSetBase* paramSet = static_cast<CUPnPRequestParamSetBase*> ( msg.iParamSet );

   642 		if ( activity.iRequestParamSet->Uri ().CompareF ( paramSet->Uri () ) == 0 )

   643 			{

   644 			delete static_cast<CUPnPCancelDescribeParamSet*> ( msg.iParamSet );

   645 			

   646 			iContext.iMessage.ClearMessageId ( );

   647 			return ETrue;

   648 			}

   649 		}

   650 	 if ( iContext.iMessage.IsMessage<TUpnpMessage::TCancelRequest> () )

   651 	 	{

   652 		LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TCancelRequest::Accept - Message=TCancelRequest")));

   653 		return ETrue; 	

   654 	 	}

   655 	

   656 	return EFalse;	

   657 	}

   658 

   659 

   660 DEFINE_SMELEMENT (CUpnpDescribeActivity::TAwaitingDataClientStopResponse, NetStateMachine::MState, CUpnpDescribeActivity::TContext )

   661 TBool CUpnpDescribeActivity::TAwaitingDataClientStopResponse::Accept ( )

   662 	{

   663 	LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TAwaitingDataClientStopResponse::Accept - Message=TDataClientStopped")));

   664 	return ( iContext.iMessage.IsMessage<TCFDataClient::TStopped> () 

   665 			|| iContext.iMessage.IsMessage<TUpnpMessage::TResponse>()

   666 			|| iContext.iMessage.IsMessage<TEBase::TError> () );

   667 	}

   668 

   669 // Transitions 

   670 DEFINE_SMELEMENT( CUpnpDescribeActivity::TSendDescribeRequest, NetStateMachine::MStateTransition, CUpnpDescribeActivity::TContext )

   671 void CUpnpDescribeActivity::TSendDescribeRequest::DoL()

   672 	{

   673 	LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TSendDescribeRequest::DoL")));

   674 	CUpnpDescribeActivity& activity = static_cast< CUpnpDescribeActivity& >( *iContext.iNodeActivity );

   675 	

   676 	RMemChunk bodyBuf;

   677 	RMemChunk uriBuf;

   678 	uriBuf.CreateL ( activity.iRequestParamSet->Uri (), iContext.Node ( ).ConnectionProvider().MemoryAllocator() );		

   679 	activity.PostRequestTo ( activity.iFlowId, TUpnpMessage::TUPnPClientRequestInfo ( HTTP::EGET, uriBuf, bodyBuf, NULL ).CRef () );

   680 	}

   681 

   682 

   683 DEFINE_SMELEMENT( CUpnpDescribeActivity::TProcessResponse, NetStateMachine::MStateTransition, CUpnpDescribeActivity::TContext )

   684 void CUpnpDescribeActivity::TProcessResponse::DoL ()

   685 	{

   686 	LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TProcessResponse::DoL")));

   687 	CUpnpDescribeActivity& activity = static_cast< CUpnpDescribeActivity& > ( *iContext.iNodeActivity );

   688 

   689 	TUpnpMessage::TResponse& msg = message_cast< TUpnpMessage::TResponse > ( iContext.iMessage );

   690 

   691 	TUPnPEvent event;

   692 	event.iStatus = TUPnPEvent::ESuccess;

   693 	event.iErrorCode = KErrNone;

   694 	RParameterFamily family ;

   695 	CUPnPDescribeResponseParamSet* resParamSet = CUPnPDescribeResponseParamSet::NewL ( family );

   696 	CleanupStack::PushL ( resParamSet );

   697 	resParamSet->SetUPnPEvent ( event );

   698 	

   699 	RBuf8 responseBodyData;

   700 	responseBodyData.CreateMax ( msg.iBodyData.Length () );

   701 	responseBodyData.FillZ ( msg.iBodyData.Length () );

   702 	msg.iBodyData.CopyOut ( responseBodyData );	

   703 	resParamSet->SetDescriptionL ( responseBodyData );

   704 	resParamSet->SetUriL ( activity.iRequestParamSet->Uri () );

   705 	responseBodyData.Close ();

   706 	msg.iBodyData.Free ();		

   707 	iContext.Node ().AddResponseParamSetL ( resParamSet, EUPnPDescribeResponseParamSet );

   708 	CleanupStack::Pop ( resParamSet );

   709 	}

   710 

   711 

   712 void CUpnpDescribeActivity::TProcessResponse::Error ( TInt aError )

   713 	{

   714 	LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TProcessResponse::Error")));

   715 	iContext.iNodeActivity->SetError ( aError );

   716 	CUpnpDescribeActivity::TReportError reportError ( iContext );

   717 	TRAP_IGNORE ( reportError.DoL () );

   718 	}

   719 

   720 

   721 DEFINE_SMELEMENT ( CUpnpDescribeActivity::TCleanupActivity, NetStateMachine::MStateTransition, CUpnpDescribeActivity::TContext )

   722 void CUpnpDescribeActivity::TCleanupActivity::DoL ()

   723 	{

   724 	LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TCleanupActivity::DoL")));

   725 	if ( iContext.iMessage.IsMessage<TUpnpMessage::TResponse>() )

   726 		{

   727 		TUpnpMessage::TResponse& msg = message_cast< TUpnpMessage::TResponse > ( iContext.iMessage );

   728 		if( !msg.iBodyData.IsEmpty () )

   729 			{

   730 			msg.iBodyData.Free ();

   731 			}

   732 		}

   733 	}

   734 

   735 DEFINE_SMELEMENT ( CUpnpDescribeActivity::TDataClientStop, NetStateMachine::MStateTransition, CUpnpDescribeActivity::TContext )

   736 void CUpnpDescribeActivity::TDataClientStop::DoL ( )

   737 	{

   738 	LOG(ESockLogExternal::Printf(KSubsysBaseActivity, KComponent, _L8("CUPnPSearchActivity::TDataClientStop::DoL")));

   739 

   740 	CUpnpDescribeActivity& activity = static_cast< CUpnpDescribeActivity& > ( *iContext.iNodeActivity );

   741 	iContext.iNodeActivity->PostRequestTo ( activity.iFlowId, TCFDataClient::TStop ( KErrNone ).CRef () );

   742 	}

   743 

   744 DEFINE_SMELEMENT ( CUpnpDescribeActivity::TReportError, NetStateMachine::MStateTransition, CUpnpDescribeActivity::TContext )

   745 void CUpnpDescribeActivity::TReportError::DoL ()

   746 	{

   747 	LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpDescribeActivity::TReportError::DoL")));

   748 	CUpnpDescribeActivity& activity = static_cast< CUpnpDescribeActivity& > ( *iContext.iNodeActivity );

   749 

   750 	TUPnPEvent event;

   751 	event.iStatus = TUPnPEvent::EFail;

   752 	event.iErrorCode = activity.Error ();

   753 	

   754 	if ( activity.Error() != KErrCancel )

   755 		{

   756 		RParameterFamily family ;

   757 		CUPnPDescribeResponseParamSet* resParamSet = CUPnPDescribeResponseParamSet::NewL ( family );

   758 		CleanupStack::PushL ( resParamSet );

   759 		resParamSet->SetUPnPEvent ( event );

   760 		resParamSet->SetUriL ( activity.iRequestParamSet->Uri () );

   761 		resParamSet->SetDescriptionL ( KNullDesC8 );

   762 		iContext.Node ().AddResponseParamSetL ( resParamSet, EUPnPDescribeResponseParamSet );

   763 		CleanupStack::Pop ( resParamSet );

   764 		}

   765 	}

   766 

   767 

   768 //---------------------------------------Control Point Subscribe Request Activity-------------------------------------

   769 CNodeActivityBase* CUpnpSubscribeActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode )

   770 	{

   771 	TUint activityId = GetNextActivityCountL ( aActivitySig, aNode );

   772 	return ( new ( ELeave ) CUpnpSubscribeActivity ( aActivitySig, aNode, activityId ) );

   773 	}

   774 

   775 CUpnpSubscribeActivity::~CUpnpSubscribeActivity ( )

   776 	{

   777 	SetError ( KErrNone );

   778 	delete static_cast<CUPnPSubscribeRequestParamSet *> ( iRequestParamSet );	

   779 	}

   780 

   781 

   782 // States

   783 DEFINE_SMELEMENT ( CUpnpSubscribeActivity::TAwaitingErrorOrResponseOrCancel, NetStateMachine::MState, CUpnpSubscribeActivity::TContext )

   784 TBool CUpnpSubscribeActivity::TAwaitingErrorOrResponseOrCancel::Accept ()

   785 	{

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

   787 		{

   788 		LOG(ESockLogExternal::Printf(KSubsysSubscribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TAwaitingErrorOrResponseOrCancel::Accept - Message=TCFMessage::TError")));

   789 		iContext.iNodeActivity->SetError ( message_cast<TEBase::TError> ( iContext.iMessage ).iValue );

   790 		return ETrue;

   791 		}

   792 	if ( iContext.iMessage.IsMessage< TUpnpMessage::TSubscribeResponse > () )

   793 		{

   794 		LOG(ESockLogExternal::Printf(KSubsysSubscribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TAwaitingErrorOrResponseOrCancel::Accept - Message=TUpnpMessage::TSubscribeResponse")));

   795 		return ETrue;

   796 		}

   797 	if ( iContext.iMessage.IsMessage< TUpnpMessage::TCancelParamSet > () )

   798 		{

   799 		LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TAwaitingErrorOrResponseOrCancel::Accept - Message=TCancelParamSet")));

   800 

   801 		CUpnpSubscribeActivity& activity = static_cast<CUpnpSubscribeActivity&> ( *iContext.iNodeActivity );

   802 		TUpnpMessage::TCancelParamSet& msg = message_cast< TUpnpMessage::TCancelParamSet > ( iContext.iMessage );

   803 		CUPnPRequestParamSetBase* paramSet = static_cast<CUPnPRequestParamSetBase*> ( msg.iParamSet );

   804 		if ( activity.iRequestParamSet->Uri ().CompareF ( paramSet->Uri () ) == 0 )

   805 			{

   806 			delete static_cast<CUPnPCancelSubscribeParamSet*> ( msg.iParamSet );

   807 			

   808 			// We can't send TCancel to the flow, we better eat the message

   809         	// here and switch the activity into a cancelling mode.

   810         	iContext.iMessage.ClearMessageId ( );

   811         	iContext.iNodeActivity->SetError ( KErrCancel );

   812 			}

   813 		}

   814 	 if ( iContext.iMessage.IsMessage<TUpnpMessage::TCancelRequest> ()

   815 	 		&& iContext.iNodeActivity->Error () != KErrCancel ) // in order to avoid eating more than one TCancelRequest Message

   816 	 	{

   817 		LOG(ESockLogExternal::Printf(KSubsysDescribeActivity, KComponent, _L8("CUpnpSubscribeActivity::AwaitingErrorOrResponseOrCancel::Accept - Message=TCancelRequest")));

   818 		

   819 		// We can't send TCancel to the Flow, we better eat the message

   820         // here and switch the activity into a cancelling mode.

   821         iContext.iMessage.ClearMessageId ( );

   822         iContext.iNodeActivity->SetError ( KErrCancel );

   823 	 	}

   824 	

   825 	return EFalse;

   826 	}

   827 

   828 // Transitions	

   829 DEFINE_SMELEMENT ( CUpnpSubscribeActivity::TSendSubscribeRequest, NetStateMachine::MStateTransition, CUpnpSubscribeActivity::TContext )

   830 void CUpnpSubscribeActivity::TSendSubscribeRequest::DoL ()

   831 	{

   832 	LOG(ESockLogExternal::Printf(KSubsysSubscribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TSendSubscribeRequest::DoL")));

   833 	CUpnpSubscribeActivity& activity = static_cast<CUpnpSubscribeActivity&> ( *iContext.iNodeActivity );

   834 

   835 	RMemChunk callBack;

   836 	RMemChunk bodyBuf;

   837 	RMemChunk uriBuf;

   838 	RMemoryAllocator allocator = iContext.Node ( ).ConnectionProvider().MemoryAllocator();

   839 	

   840 	uriBuf.CreateL ( activity.iRequestParamSet->Uri ( ), allocator );

   841 	TCleanupItem item ( &CUPnPUtils::CleanupMBufChain, &uriBuf );

   842 	CleanupStack::PushL ( item );

   843 	

   844 	callBack.CreateL ( iContext.Node ( ).Callback ( ), allocator);

   845 	TCleanupItem item1 ( &CUPnPUtils::CleanupMBufChain, &callBack );

   846 	CleanupStack::PushL ( item1 );

   847 	

   848 	TSubscribeRequestInfo subscribeRequest;

   849 	subscribeRequest.iTimeOut = static_cast<CUPnPSubscribeRequestParamSet *>(activity.iRequestParamSet)->Duration();

   850 	

   851 	CSubscriptionInfo* subscriptionInfo = iContext.Node ().GetSubscriptionInfoByUrl ( activity.iRequestParamSet->Uri () );

   852 	if ( subscriptionInfo )

   853 		{

   854 		LOG(ESockLogExternal::Printf(KSubsysSubscribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TSendSubscribeRequest::DoL - Re-Subscribe")));

   855 		// Re-Subscribe.

   856 		subscribeRequest.iSid.CreateL ( subscriptionInfo->iSid, allocator );

   857 		}

   858 	else

   859 		{

   860 		subscribeRequest.iCallback = callBack;

   861 		}

   862 		

   863 	activity.PostRequestTo ( activity.iFlowId, TUpnpMessage::TUPnPClientRequestInfo ( UPnP::ESubscribe,  uriBuf, bodyBuf, &subscribeRequest ).CRef () );

   864 	

   865 	CleanupStack::Pop ( ); // item

   866 	CleanupStack::Pop ( ); // item1

   867 	}

   868 

   869 

   870 DEFINE_SMELEMENT ( CUpnpSubscribeActivity::TProcessSubscribeResponse, NetStateMachine::MStateTransition, CUpnpSubscribeActivity::TContext )

   871 void CUpnpSubscribeActivity::TProcessSubscribeResponse::DoL ()

   872 	{

   873 	LOG(ESockLogExternal::Printf(KSubsysSubscribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TProcessResponse::DoL")));

   874 	CUpnpSubscribeActivity& activity = static_cast< CUpnpSubscribeActivity& > ( *iContext.iNodeActivity );

   875 

   876 	TUpnpMessage::TSubscribeResponse& msg = message_cast< TUpnpMessage::TSubscribeResponse > ( iContext.iMessage );	

   877 	

   878 	CSubscriptionInfo* subscriptionInfo = iContext.Node ().GetSubscriptionInfoByUrl ( activity.iRequestParamSet->Uri () );	

   879 	// new subscription is accepted, update elements and create callback flow.

   880 	if ( subscriptionInfo == NULL )

   881 		{

   882 		subscriptionInfo = new ( ELeave ) CSubscriptionInfo ( activity.iFlowId );

   883 		CleanupStack::PushL ( subscriptionInfo );

   884 		subscriptionInfo->SetPublishUrlL ( activity.iRequestParamSet->Uri() );

   885 		subscriptionInfo->SetSidL ( msg.iURN );

   886 		iContext.Node ().AddSubscriptionInfoL ( subscriptionInfo );

   887 		CleanupStack::Pop ( subscriptionInfo );

   888 			

   889 		if ( iContext.iNodeActivity->Error () != KErrCancel && !iContext.Node ( ).iTcpSrvFlowCreateRequested )

   890 			{

   891 			iContext.Node ( ).iTcpSrvFlowCreateRequested = ETrue;

   892 			// intiate flow creation with the call back Url			

   893 			RClientInterface::OpenPostMessageClose ( iContext.NodeId (), TNodeCtxId ( TUpnpMessage::EActivityFindOrCreateFlow, iContext.NodeId () ), 

   894 													TUpnpMessage::TCreateServerFlow ().CRef() );

   895 			}

   896 		}

   897 	

   898 	if ( iContext.iNodeActivity->Error() != KErrCancel )

   899 		{

   900 		RParameterFamily family ;

   901 		CUPnPSubscribeResponseParamSet* resParamSet = CUPnPSubscribeResponseParamSet::NewL ( family );

   902 		CleanupStack::PushL ( resParamSet );

   903 	

   904 		TUPnPEvent event;

   905 		event.iStatus = TUPnPEvent::ESuccess;

   906 		event.iErrorCode = KErrNone;

   907 			

   908 		resParamSet->SetUPnPEvent ( event );

   909 		resParamSet->SetTimerExpiry ( msg.iTimeOut );

   910 		resParamSet->SetUriL ( activity.iRequestParamSet->Uri () );

   911 		iContext.Node ( ).AddResponseParamSetL ( resParamSet, EUPnPSubscribeResponseParamSet );

   912 		CleanupStack::Pop ( resParamSet );

   913 		}

   914 	

   915 	activity.iSubscriptionInfo = subscriptionInfo; // for unsubscription in cancel/destruction phase	

   916 	msg.iURN.Free ( );	

   917 	}

   918 

   919 

   920 void CUpnpSubscribeActivity::TProcessSubscribeResponse::Error( TInt aError )

   921 	{

   922 	LOG(ESockLogExternal::Printf(KSubsysSubscribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TProcessResponse::Error")));

   923 	iContext.iNodeActivity->SetError( aError );

   924 	CUpnpSubscribeActivity::TReportError reportError(iContext);

   925 	TRAP_IGNORE ( reportError.DoL() );

   926 	}

   927 	

   928 DEFINE_SMELEMENT( CUpnpSubscribeActivity::TReportError, NetStateMachine::MStateTransition, CUpnpSubscribeActivity::TContext )

   929 void CUpnpSubscribeActivity::TReportError::DoL()

   930 	{

   931 	LOG(ESockLogExternal::Printf(KSubsysSubscribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TReportError::DoL")));

   932 	CUpnpSubscribeActivity& activity = static_cast< CUpnpSubscribeActivity& > ( *iContext.iNodeActivity );

   933 

   934 	TUPnPEvent event;

   935 	event.iStatus = TUPnPEvent::EFail;

   936 	event.iErrorCode = activity.Error();

   937 	

   938 	CSubscriptionInfo* subscriptionInfo = iContext.Node().GetSubscriptionInfoByUrl(activity.iRequestParamSet->Uri());

   939 	if(subscriptionInfo)

   940 		{

   941 		iContext.Node().RemoveSubscriptionInfo(subscriptionInfo->iSid);

   942 		}

   943 	

   944 	if( activity.Error() != KErrCancel )

   945 		{

   946 		RParameterFamily family ;

   947 		CUPnPSubscribeResponseParamSet* resParamSet = CUPnPSubscribeResponseParamSet::NewL( family );

   948 		CleanupStack::PushL( resParamSet );

   949 		resParamSet->SetUriL( activity.iRequestParamSet->Uri() );

   950 		resParamSet->SetUPnPEvent( event );

   951 		iContext.Node().AddResponseParamSetL( resParamSet, EUPnPSubscribeResponseParamSet );

   952 		CleanupStack::Pop( resParamSet );

   953 		}

   954 	}

   955 	

   956 

   957 DEFINE_SMELEMENT( CUpnpSubscribeActivity::TSendUnsubscribeRequest, NetStateMachine::MStateTransition, CUpnpSubscribeActivity::TContext )

   958 void CUpnpSubscribeActivity::TSendUnsubscribeRequest::DoL()

   959 	{

   960 	LOG(ESockLogExternal::Printf(KSubsysSubscribeActivity, KComponent, _L8("CUpnpSubscribeActivity::TSendUnSubscribeRequest::DoL")));

   961 	CUpnpSubscribeActivity& activity = static_cast< CUpnpSubscribeActivity& > ( *iContext.iNodeActivity );

   962 	RMemoryAllocator allocator = iContext.Node ( ).ConnectionProvider().MemoryAllocator();

   963 	

   964 	TSubscribeRequestInfo subscribeRequest;

   965 	subscribeRequest.iSid.CreateL ( activity.iSubscriptionInfo->iSid, allocator );

   966 	TCleanupItem item ( &CUPnPUtils::CleanupMBufChain, &subscribeRequest.iSid );

   967 	CleanupStack::PushL ( item );

   968 		

   969 	RMemChunk uriBuf;

   970 	uriBuf.CreateL ( activity.iSubscriptionInfo->iPublishUrl, allocator );

   971 	

   972 	RMemChunk bodyBuf;	

   973 	activity.PostRequestTo ( activity.iSubscriptionInfo->iDataClient, 

   974 							TUpnpMessage::TUPnPClientRequestInfo ( UPnP::EUnsubscribe, uriBuf, bodyBuf, &subscribeRequest ).CRef () );

   975 	

   976 	CleanupStack::Pop ( ); // item

   977 	}

   978 

   979 DEFINE_SMELEMENT( CUpnpSubscribeActivity::TProcessUnsubscribeResponse, NetStateMachine::MStateTransition, CUpnpSubscribeActivity::TContext )

   980 void CUpnpSubscribeActivity::TProcessUnsubscribeResponse::DoL()

   981 	{

   982 	LOG(ESockLogExternal::Printf(KSubsysUnSubscribeActivity, KComponent, _L8("CUpnpUnSubscribeActivity::TProcessResponse::DoL")));

   983 	

   984 	CUpnpSubscribeActivity& activity = static_cast< CUpnpSubscribeActivity& >( *iContext.iNodeActivity );	

   985 	iContext.Node().RemoveSubscriptionInfo(activity.iSubscriptionInfo->iSid);

   986 	}

   987 

   988 

   989 //---------------------------------------Control Point UnSubscribe Request Activity-------------------------------------

   990 CNodeActivityBase* CUpnpUnSubscribeActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode )

   991 	{

   992 	TUint activityId = GetNextActivityCountL ( aActivitySig, aNode );

   993 	return ( new ( ELeave ) CUpnpUnSubscribeActivity ( aActivitySig, aNode, activityId ) );

   994 	}

   995 

   996 CUpnpUnSubscribeActivity::~CUpnpUnSubscribeActivity ( )

   997 	{	

   998 	SetError( KErrNone );

   999 	delete static_cast<CUPnPCancelSubscribeParamSet*> ( iRequestParamSet );	

  1000 	}

  1001 

  1002 

  1003 // States

  1004 DEFINE_SMELEMENT( CUpnpUnSubscribeActivity::TAwaitingUnSubscribeRequest, NetStateMachine::MState, CUpnpUnSubscribeActivity::TContext )

  1005 TBool CUpnpUnSubscribeActivity::TAwaitingUnSubscribeRequest::Accept()

  1006 	{

  1007 	LOG(ESockLogExternal::Printf(KSubsysUnSubscribeActivity, KComponent, _L8("CUpnpUnSubscribeActivity::TAwaitingUnSubscribeRequest::Accept - Message=TCancelParamSet")));

  1008 	

  1009 	if ( iContext.iMessage.IsMessage< TUpnpMessage::TCancelParamSet >() )

  1010 		{

  1011 		TUpnpMessage::TCancelParamSet& msg = message_cast< TUpnpMessage::TCancelParamSet > ( iContext.iMessage );	

  1012 		

  1013 		if ( EUPnPCancelSubscribeParamSet == msg.iParamSet->GetTypeId().iType )

  1014 			{

  1015 			CUPnPCancelSubscribeParamSet* paramSet = static_cast<CUPnPCancelSubscribeParamSet*> ( msg.iParamSet );

  1016 			

  1017 			CSubscriptionInfo* info = iContext.Node ().GetSubscriptionInfoByUrl ( paramSet->Uri () );

  1018 			if ( info ) // subscription response is received from network, accept for performing unsubscribe.

  1019 				{

  1020 				return ETrue;

  1021 				}

  1022 			}

  1023 		}

  1024 	

  1025 	return EFalse;	

  1026 	}

  1027 

  1028 // Transitions.

  1029 DEFINE_SMELEMENT( CUpnpUnSubscribeActivity::TSendUnSubscribeRequest, NetStateMachine::MStateTransition, CUpnpUnSubscribeActivity::TContext )

  1030 void CUpnpUnSubscribeActivity::TSendUnSubscribeRequest::DoL()

  1031 	{

  1032 	LOG(ESockLogExternal::Printf(KSubsysUnSubscribeActivity, KComponent, _L8("CUpnpUnSubscribeActivity::TSendUnSubscribeRequest::DoL")));

  1033 	CUpnpUnSubscribeActivity& activity = static_cast< CUpnpUnSubscribeActivity& > ( *iContext.iNodeActivity );

  1034 	TUpnpMessage::TCancelParamSet& msg = message_cast< TUpnpMessage::TCancelParamSet > ( iContext.iMessage );	

  1035 	

  1036 	activity.iRequestParamSet = static_cast<CUPnPCancelSubscribeParamSet*> ( msg.iParamSet );	

  1037 	CSubscriptionInfo* subscriptionInfo = iContext.Node ( ).GetSubscriptionInfoByUrl ( activity.iRequestParamSet->Uri( ) );	

  1038 	activity.iSubscriptionInfo = subscriptionInfo;

  1039 	RMemoryAllocator allocator = iContext.Node ( ).ConnectionProvider().MemoryAllocator();

  1040 	

  1041 	TSubscribeRequestInfo subscribeRequest;

  1042 	subscribeRequest.iSid.CreateL ( subscriptionInfo->iSid, allocator );

  1043 	TCleanupItem item ( &CUPnPUtils::CleanupMBufChain, &subscribeRequest.iSid );

  1044 	CleanupStack::PushL ( item );

  1045 	

  1046 	RMemChunk uriBuf;

  1047 	uriBuf.CreateL ( subscriptionInfo->iPublishUrl, allocator );

  1048 	

  1049 	RMemChunk bodyBuf;	

  1050 	activity.PostRequestTo ( subscriptionInfo->iDataClient, 

  1051 							TUpnpMessage::TUPnPClientRequestInfo ( UPnP::EUnsubscribe,  uriBuf, bodyBuf, &subscribeRequest ).CRef () );

  1052 	

  1053 	CleanupStack::Pop ( ); // item

  1054 	}

  1055 

  1056 

  1057 DEFINE_SMELEMENT( CUpnpUnSubscribeActivity::TProcessResponse, NetStateMachine::MStateTransition, CUpnpUnSubscribeActivity::TContext )

  1058 void CUpnpUnSubscribeActivity::TProcessResponse::DoL()

  1059 	{

  1060 	LOG(ESockLogExternal::Printf(KSubsysUnSubscribeActivity, KComponent, _L8("CUpnpUnSubscribeActivity::TProcessResponse::DoL")));

  1061 	

  1062 	CUpnpUnSubscribeActivity& activity = static_cast< CUpnpUnSubscribeActivity& >( *iContext.iNodeActivity );	

  1063 	iContext.Node().RemoveSubscriptionInfo(activity.iSubscriptionInfo->iSid);

  1064 	}

  1065 

  1066 //---------------------------------------Control Point Notification Activity-------------------------------------

  1067 

  1068 

  1069 // CUpnpNotificationActivity

  1070 CNodeActivityBase* CUpnpNotificationActivity::NewL( const TNodeActivity& aActivitySig, AMMNodeBase& aNode )

  1071 	{

  1072 	TUint activityId = GetNextActivityCountL ( aActivitySig, aNode );

  1073 	return ( new ( ELeave ) CUpnpNotificationActivity ( aActivitySig, aNode, activityId ) );

  1074 	}

  1075 

  1076 

  1077 CUpnpNotificationActivity::~CUpnpNotificationActivity()

  1078 	{

  1079 	iBodyBuf.Close();

  1080 	SetError( KErrNone );

  1081 	}

  1082 

  1083 

  1084 CUpnpNotificationActivity::CUpnpNotificationActivity( const TNodeActivity& aActivitySig, AMMNodeBase& aNode, TUint aActivityCount )

  1085 	:CNodeParallelActivityBase ( aActivitySig, aNode, aActivityCount )

  1086 	{

  1087 	// do nothing.

  1088 	}

  1089 

  1090 // Transitions

  1091 DEFINE_SMELEMENT( CUpnpNotificationActivity::TProcessNotifyRequest, NetStateMachine::MStateTransition, CUpnpNotificationActivity::TContext )

  1092 void CUpnpNotificationActivity::TProcessNotifyRequest::DoL()

  1093 	{

  1094 	LOG(ESockLogExternal::Printf(KSubsysEventNotifyActivity, KComponent, _L8("CUpnpNotificationActivity::TProcessNotifyRequest::DoL")));

  1095 	

  1096 	CUpnpNotificationActivity& activity = static_cast< CUpnpNotificationActivity& > ( *iContext.iNodeActivity );

  1097 	

  1098 	TUpnpMessage::TUPnPRequestInfo& msg = message_cast< TUpnpMessage::TUPnPRequestInfo > ( iContext.iMessage );

  1099 	activity.iTransaction = static_cast<CTransaction*>(msg.iPtr);

  1100 	CRequest* request = activity.iTransaction->Request();

  1101 

  1102 	// Validate request & construct response

  1103 	RStringPool strP = request->StringPool();

  1104 	RHTTPHeaders reqHdrs = request->Handle().GetHeaderCollection();

  1105 	RStringF sid = strP.StringF(UPnP::ESID, TUPnPTable::Table());

  1106 	RStringF nts = strP.StringF(UPnP::ENTS, TUPnPTable::Table());

  1107 	RStringF nt = strP.StringF(UPnP::ENT, TUPnPTable::Table());

  1108 	RStringF seq = strP.StringF(UPnP::ESEQ, TUPnPTable::Table());

  1109 	THTTPHdrVal ntsVal;

  1110 	THTTPHdrVal ntVal;

  1111 	THTTPHdrVal	sidVal;

  1112 	TBool preConditionFailed = ETrue;

  1113 	TBool invalidSequence = ETrue;

  1114 	

  1115 	// Check if the SID header is present.

  1116 	if( reqHdrs.GetField( sid, 0, sidVal ) != KErrNotFound )

  1117 		{

  1118 		CSubscriptionInfo* subscriptionInfo = iContext.Node ().GetSubscriptionInfoBySid( sidVal.StrF().DesC() );

  1119 		if(subscriptionInfo != NULL)

  1120 			{

  1121 			THTTPHdrVal seqVal;

  1122 			if( (reqHdrs.GetField(seq, 0, seqVal) != KErrNotFound) && (seqVal.Int() == subscriptionInfo->iSeqKey+1) )

  1123 				{

  1124 				invalidSequence = EFalse;

  1125 				subscriptionInfo->iSeqKey = seqVal.Int();

  1126 				activity.iPublisherUrl.Set(subscriptionInfo->iPublishUrl.Ptr(),subscriptionInfo->iPublishUrl.Length());

  1127 				}

  1128 			preConditionFailed = EFalse;

  1129 			}

  1130 		else

  1131 			{

  1132 			preConditionFailed = ETrue;

  1133 			}

  1134 		}

  1135 	else