|
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 <comms-infras/ss_nodemessages_factory.h> |
|
23 #include <ss_glob.h> |
|
24 #include <httpstringconstants.h> |
|
25 #include <http/thttptable.h> |
|
26 #include <upnp/tupnptable.h> |
|
27 #include <inetprottextutils.h> |
|
28 #include "upnpdescriptionschema.h" |
|
29 #include <httperr.h> |
|
30 #include <rmemchunk.h> |
|
31 |
|
32 //Local Includes |
|
33 #include "upnpservicescpractivities.h" |
|
34 #include "upnpservicescprstates.h" |
|
35 #include "upnpctrlscprstates.h" |
|
36 #include "upnpstatemachine.h" |
|
37 #include "upnpuuid.h" |
|
38 #include "upnpserverconstants.h" |
|
39 #include "upnplog.h" |
|
40 |
|
41 using namespace UPnPServiceSCprActivities; |
|
42 using namespace ESock; |
|
43 using namespace MeshMachine; |
|
44 using namespace CoreNetStates; |
|
45 using namespace CoreStates; |
|
46 using namespace CorePanics; |
|
47 using namespace PRActivities; |
|
48 using namespace CoreActivities; |
|
49 using namespace UPnPStateMachine; |
|
50 using namespace UPnPServiceSCprStates; |
|
51 |
|
52 __FLOG_STMT(_LIT8(KComponent,"UPnPSPScpr");) |
|
53 const TUint KHttpDefaultPort = 80; |
|
54 |
|
55 namespace UPnPServiceSCprParamRequestActivity |
|
56 { |
|
57 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW |
|
58 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityParamRequest, UPnPServiceSCprParamRequest, TCFScpr::TSetParamsRequest ) |
|
59 FIRST_NODEACTIVITY_ENTRY ( TAwaitingSetParamRequest, TNoTag ) |
|
60 LAST_NODEACTIVITY_ENTRY ( KNoTag, UPnPServiceSCprStates::TStoreParamsAndSendResponse ) |
|
61 NODEACTIVITY_END ( ) |
|
62 #else |
|
63 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityParamRequest, UPnPServiceSCprParamRequest, TCFScpr::TParamsRequest ) |
|
64 FIRST_NODEACTIVITY_ENTRY ( TAwaitingSetParamRequest, TNoTag ) |
|
65 LAST_NODEACTIVITY_ENTRY ( KNoTag, UPnPServiceSCprStates::TStoreParamsAndSendResponse ) |
|
66 NODEACTIVITY_END ( ) |
|
67 #endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW |
|
68 } |
|
69 |
|
70 namespace UPnPServiceSCprApplyRequestActivity |
|
71 { |
|
72 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW |
|
73 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityApplyChanges, UPnPServiceSCprApplyRequest, TCFScpr::TApplyRequest ) |
|
74 FIRST_NODEACTIVITY_ENTRY ( PRStates::TAwaitingApplyRequest, TNoTag ) |
|
75 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, UPnPServiceSCprStates::TInitiateActivities, TNoTag ) |
|
76 LAST_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TSendApplyResponse ) |
|
77 NODEACTIVITY_END ( ) |
|
78 #else |
|
79 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityApplyChanges, UPnPServiceSCprApplyRequest, TCFScpr::TApplyRequest ) |
|
80 FIRST_NODEACTIVITY_ENTRY ( SCprStates::TAwaitingApplyRequest, TNoTag ) |
|
81 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, UPnPServiceSCprStates::TInitiateActivities, TNoTag ) |
|
82 LAST_NODEACTIVITY_ENTRY ( KNoTag, SCprStates::TSendApplyResponse ) |
|
83 NODEACTIVITY_END ( ) |
|
84 #endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW |
|
85 } |
|
86 |
|
87 //Activity to create UPnP Server Flow for RSocket used in UPnP Control Phase |
|
88 namespace UPnPServiceSCprBinderRequestActivity |
|
89 { |
|
90 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( ECFActivityBinderRequest, UPnPServiceSCprBinderRequest, TCFServiceProvider::TCommsBinderRequest, CCommsBinderActivity::NewL ) |
|
91 FIRST_NODEACTIVITY_ENTRY ( CoreNetStates::TAwaitingBinderRequest, CCommsBinderActivity::TNoTagOrUseExistingBlockedByBinderRequest ) |
|
92 |
|
93 NODEACTIVITY_ENTRY ( KNoTag, TCreateServerFlow<EControl>, CoreNetStates::TAwaitingDataClientJoin, TNoTag ) |
|
94 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CCommsBinderActivity::TProcessDataClientCreation, TNoTag ) |
|
95 |
|
96 NODEACTIVITY_ENTRY ( KNoTag, TSendDataClientStart, CoreNetStates::TAwaitingDataClientStarted, TTag<KUseExisting> ) |
|
97 NODEACTIVITY_ENTRY ( CoreStates::KUseExisting, CCommsBinderActivity::TSendBinderResponse, CCommsBinderActivity::TAwaitingBindToComplete, TNoTagOrErrorTag ) |
|
98 LAST_NODEACTIVITY_ENTRY ( KNoTag, TDoNothing ) |
|
99 |
|
100 LAST_NODEACTIVITY_ENTRY ( KErrorTag, TClearError ) |
|
101 NODEACTIVITY_END ( ) |
|
102 } |
|
103 |
|
104 // Note! Handle DataClientIdle from UPnP Flow created for RSocket used in UPnP CONTROL Phase |
|
105 namespace UPnPServiceSCprDataClientIdleActivity |
|
106 { |
|
107 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityDataClientIdle, UPnPServiceSCprDataClientIdle, TCFControlProvider::TIdle ) |
|
108 NODEACTIVITY_ENTRY ( KNoTag, UPnPStateMachine::THandleControlChannelDataClientIdle, CoreNetStates::TAwaitingDataClientIdle, TNoTag ) |
|
109 NODEACTIVITY_END ( ) |
|
110 } |
|
111 |
|
112 |
|
113 namespace UPnPServiceSCprClientLeaveActivity |
|
114 { |
|
115 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityClientLeave, UPnPServiceSCprClientLeave, TNodeSignal::TNullMessageId ) //May be waiting for both messages |
|
116 FIRST_NODEACTIVITY_ENTRY ( CoreStates::TAwaitingClientLeave, TNoTag ) |
|
117 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, UPnPServiceSCprStates::TProcessClientLeave, TTag<KDataClientIdle> ) |
|
118 LAST_NODEACTIVITY_ENTRY ( KDataClientIdle, TSendDataClientIdleOrUnregister ) |
|
119 NODEACTIVITY_END ( ) |
|
120 } |
|
121 |
|
122 |
|
123 namespace UPnPServiceSCprDataClientStopActivity |
|
124 { |
|
125 DECLARE_DEFINE_NODEACTIVITY ( ECFActivityStopDataClient, UPnPServiceSCprDataClientStop, TCFDataClient::TStop ) |
|
126 FIRST_NODEACTIVITY_ENTRY ( CoreNetStates::TAwaitingDataClientStop, CoreNetStates::TNoTagOrDataClientsToStop ) |
|
127 |
|
128 NODEACTIVITY_ENTRY ( CoreNetStates::KDataClientsToStop, UPnPServiceSCprStates::TProcessDataClientStop, CoreNetStates::TAwaitingDataClientsStopped, TNoTag ) |
|
129 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, TDoNothing, CoreNetStates::TNoTagOrUnbindOnStop ) |
|
130 |
|
131 NODEACTIVITY_ENTRY ( CoreNetStates::KUnbind, CoreNetStates::TSendClientLeavingRequestToServiceProvider, CoreStates::TAwaitingLeaveComplete, TNoTag ) |
|
132 |
|
133 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, UPnPStateMachine::TDestroyDataClients, TNoTag ) |
|
134 LAST_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TSendDataClientStopped ) |
|
135 NODEACTIVITY_END ( ) |
|
136 } |
|
137 |
|
138 namespace UPnPServiceSCprDestroyActivity |
|
139 { |
|
140 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( ECFActivityDestroy, UPnPServiceSCprDestroy, TEChild::TDestroy, CoreActivities::CDestroyActivity::New ) |
|
141 FIRST_NODEACTIVITY_ENTRY ( TAwaitingDestroy, UPnPStateMachine::TBlockedByAllActivitiesStopped ) |
|
142 |
|
143 //Stop self first |
|
144 NODEACTIVITY_ENTRY ( KNoTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientStopped, TNoTag ) |
|
145 |
|
146 LAST_NODEACTIVITY_ENTRY ( KNoTag, CoreNetStates::TSendClientLeavingAndRemoveControlProvider ) |
|
147 NODEACTIVITY_END() |
|
148 } |
|
149 |
|
150 |
|
151 namespace UPnPServiceScprServiceRegistrationActivity |
|
152 { |
|
153 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityServiceRegistration, UPnPServiceSCprServiceRegistration, TUpnpMessage::TServiceRegistration, CUpnpServiceRegistrationActivity::NewL ) |
|
154 FIRST_NODEACTIVITY_ENTRY ( CUpnpServiceRegistrationActivity::TAwaitingServiceRegistration, TNoTag ) |
|
155 |
|
156 NODEACTIVITY_ENTRY ( KNoTag, CUpnpServiceRegistrationActivity::TRequestServiceJoin, TAwaitingServiceValidated, TErrorTagOr<TTag<KNoTag> > ) |
|
157 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CUpnpServiceRegistrationActivity::TBuildPublishAndServiceInfo, TNoTag ) |
|
158 NODEACTIVITY_ENTRY ( KNoTag, CUpnpServiceRegistrationActivity::TRegisterServiceInfoWithCPR, TAwaitingServiceRegisteredFromCpr, TErrorTagOr<TTag<KNoTag> > ) |
|
159 |
|
160 NODEACTIVITY_ENTRY ( KNoTag, TFindOrCreateUdpClientFlow, CoreNetStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > ) |
|
161 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, UPnPServiceSCprStates::TStoreUdpClientAndSendRequest ) |
|
162 NODEACTIVITY_ENTRY ( KSendRequest, TSendDataClientStart, CoreNetStates::TAwaitingDataClientStarted, TNoTag ) |
|
163 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CUpnpServiceRegistrationActivity::TSendPublishRequest, TNoTag ) |
|
164 // sendpublish request should be written as utility |
|
165 |
|
166 NODEACTIVITY_ENTRY ( KNoTag, TFindOrCreateUdpServerFlow, CoreNetStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > ) |
|
167 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, UPnPServiceSCprStates::TStoreUdpServer ) |
|
168 NODEACTIVITY_ENTRY ( KNoTag, TSendDataClientStart, CoreNetStates::TAwaitingDataClientStarted, TNoTag ) |
|
169 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CUpnpServiceRegistrationActivity::TRegisterSsdpInfoWithServer, TNoTag ) |
|
170 |
|
171 LAST_NODEACTIVITY_ENTRY ( KNoTag, CUpnpServiceRegistrationActivity::TInitiateTcpFlowCreation ) |
|
172 // makes use of activity.Error ( ) && activity destruction clears error |
|
173 LAST_NODEACTIVITY_ENTRY ( KErrorTag, TSendPublishResponseToClient ) |
|
174 NODEACTIVITY_END ( ) |
|
175 } |
|
176 |
|
177 namespace UPnPServiceScprDeviceRegistrationActivity |
|
178 { |
|
179 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityDeviceRegistration, UPnPServiceSCprDeviceRegistration, TUpnpMessage::TDeviceRegistration, CUpnpDeviceRegistrationActivity::NewL ) |
|
180 FIRST_NODEACTIVITY_ENTRY ( CUpnpDeviceRegistrationActivity::TAwaitingDeviceRegistration, TNoTag ) |
|
181 |
|
182 NODEACTIVITY_ENTRY ( KNoTag, CUpnpDeviceRegistrationActivity::TRequestDeviceJoin, TAwaitingServiceValidated, TErrorTagOr<TTag<KNoTag> > ) |
|
183 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CUpnpDeviceRegistrationActivity::TBuildPublishAndDeviceInfo, TNoTag ) |
|
184 NODEACTIVITY_ENTRY ( KNoTag, CUpnpDeviceRegistrationActivity::TRegisterDeviceInfoWithCPR, TAwaitingServiceRegisteredFromCpr, TErrorTagOr<TTag<KNoTag> > ) |
|
185 |
|
186 NODEACTIVITY_ENTRY ( KNoTag, TFindOrCreateUdpClientFlow, CoreNetStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > ) |
|
187 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, UPnPServiceSCprStates::TStoreUdpClientAndSendRequest ) |
|
188 NODEACTIVITY_ENTRY ( KSendRequest, TSendDataClientStart, CoreNetStates::TAwaitingDataClientStarted, TNoTag ) |
|
189 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CUpnpDeviceRegistrationActivity::TSendPublishRequest, TNoTag ) |
|
190 // sendpublish request should be written as utility |
|
191 |
|
192 NODEACTIVITY_ENTRY ( KNoTag, TFindOrCreateUdpServerFlow, CoreNetStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > ) |
|
193 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, UPnPServiceSCprStates::TStoreUdpServer ) |
|
194 NODEACTIVITY_ENTRY ( KNoTag, TSendDataClientStart, CoreNetStates::TAwaitingDataClientStarted, TNoTag ) |
|
195 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, CUpnpDeviceRegistrationActivity::TRegisterSsdpInfoWithServer, CUpnpDeviceRegistrationActivity::TIconCreateOrNoTag ) |
|
196 |
|
197 NODEACTIVITY_ENTRY ( KCreateIconTag, CUpnpDeviceRegistrationActivity::TCreateIconFlow, CoreNetStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KIconCreatedTag> > ) |
|
198 NODEACTIVITY_ENTRY ( KIconCreatedTag, TProcessServerFlowCreation, CoreNetStates::TAwaitingDataClientStarted, CUpnpDeviceRegistrationActivity::TIconOrNoTag ) |
|
199 |
|
200 LAST_NODEACTIVITY_ENTRY ( KNoTag, TSendPublishResponseToClient ) |
|
201 // activity destruction clears error |
|
202 LAST_NODEACTIVITY_ENTRY ( KErrorTag, TSendPublishResponseToClient ) |
|
203 // no TCP flows for embedded device scpr |
|
204 NODEACTIVITY_END ( ) |
|
205 } |
|
206 |
|
207 namespace UPnPServiceSCprFlowCreationActivity |
|
208 { |
|
209 DECLARE_DEFINE_NODEACTIVITY ( TUpnpMessage::EActivityCreateServerFlow, UPnPServiceSCprFlowCreation, TUpnpMessage::TCreateServerFlow ) |
|
210 FIRST_NODEACTIVITY_ENTRY ( TAwaitingServerFlowRequest, TNoTag ) |
|
211 NODEACTIVITY_ENTRY ( KNoTag, TCreateServerFlow<EDescription>, CoreNetStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > ) |
|
212 NODEACTIVITY_ENTRY ( KNoTag, TProcessServerFlowCreation, CoreNetStates::TAwaitingDataClientStarted, TNoTag ) |
|
213 NODEACTIVITY_ENTRY ( KNoTag, TCreateServerFlow<ESubscription>, CoreNetStates::TAwaitingDataClientJoin, TErrorTagOr<TTag<KNoTag> > ) |
|
214 NODEACTIVITY_ENTRY ( KNoTag, TProcessServerFlowCreation, CoreNetStates::TAwaitingDataClientStarted, TNoTag ) |
|
215 |
|
216 LAST_NODEACTIVITY_ENTRY ( KNoTag, TSendPublishResponseToClient ) |
|
217 THROUGH_NODEACTIVITY_ENTRY ( KErrorTag, TSendPublishResponseToClient, TNoTag ) |
|
218 LAST_NODEACTIVITY_ENTRY ( KNoTag, TClearError ) |
|
219 NODEACTIVITY_END ( ) |
|
220 } |
|
221 |
|
222 namespace UPnPSerivceSearchResponseActivity |
|
223 { |
|
224 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivitySearchResponse, UPnPServiceSearchResponse, TUpnpMessage::TUPnPSearchRequest, CNodeParallelActivityBase::NewL ) |
|
225 FIRST_NODEACTIVITY_ENTRY ( UPnPStateMachine::TAwaitingSearchRequest, UPnPServiceSCprStates::TNoTagOrIgnoreTag ) |
|
226 LAST_NODEACTIVITY_ENTRY ( KNoTag, UPnPServiceSCprStates::TValidateAndSendResponse ) |
|
227 LAST_NODEACTIVITY_ENTRY ( CoreStates::KIgnore, UPnPStateMachine::TDiscardSearchRequestData ) |
|
228 NODEACTIVITY_END ( ) |
|
229 } |
|
230 |
|
231 namespace UpnpServiceRequestInfoActivity |
|
232 { |
|
233 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityRequestInfo, UpnpServiceRequestInfo, TUpnpMessage::TUPnPRequestInfo, CUpnpSPRequestInfoActivity::NewL ) |
|
234 FIRST_NODEACTIVITY_ENTRY ( TAwaitingUpnpRequestInfo, UPnPStateMachine::TRequestOrIgnoreTag ) |
|
235 |
|
236 LAST_NODEACTIVITY_ENTRY ( UPnPStateMachine::KDescribeRequest, CUpnpSPRequestInfoActivity::TSendDescribeResponse ) |
|
237 LAST_NODEACTIVITY_ENTRY ( UPnPStateMachine::KSubscribeRequest, CUpnpSPRequestInfoActivity::TSendSubscribeResponse ) |
|
238 LAST_NODEACTIVITY_ENTRY ( UPnPStateMachine::KUnsubscribeRequest, CUpnpSPRequestInfoActivity::TSendUnsubscribeResponse ) |
|
239 |
|
240 LAST_NODEACTIVITY_ENTRY ( CoreStates::KIgnore, UPnPStateMachine::TSendIgnoreResponse ) |
|
241 NODEACTIVITY_END ( ) |
|
242 } |
|
243 |
|
244 |
|
245 namespace UpnpServiceClientFlowCreationActivity |
|
246 { |
|
247 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityFindOrCreateFlow, FindOrCreateFlow, TUpnpMessage::TCreateNotifyFlow, CNotifyFlowFinder::NewL ) |
|
248 FIRST_NODEACTIVITY_ENTRY ( CNotifyFlowFinder::TAwaitingFlowCreationRequest, TNoTag ) |
|
249 |
|
250 NODEACTIVITY_ENTRY ( KNoTag, CNotifyFlowFinder::TFindOrCreateFlow, CoreNetStates::TAwaitingDataClientJoin, TNoTag ) |
|
251 THROUGH_NODEACTIVITY_ENTRY ( KNoTag, PRStates::TProcessDataClientCreation, TNoTag ) |
|
252 NODEACTIVITY_ENTRY ( KNoTag, TSendDataClientStart, CoreNetStates::TAwaitingDataClientStarted, TNoTag ) |
|
253 |
|
254 LAST_NODEACTIVITY_ENTRY ( KNoTag, CNotifyFlowFinder::TProcessDataClient ) |
|
255 NODEACTIVITY_END ( ) |
|
256 } |
|
257 |
|
258 namespace UpnpEventNotificationActivity |
|
259 { |
|
260 DECLARE_DEFINE_CUSTOM_NODEACTIVITY ( TUpnpMessage::EActivityNotifyRequest, UpnpEventNotification, TUpnpMessage::TNotifyRequest, CUpnpEventNotificationActivity::NewL ) |
|
261 FIRST_NODEACTIVITY_ENTRY ( CUpnpEventNotificationActivity::TAwaitingNotifyRequest, TNoTag ) |
|
262 NODEACTIVITY_ENTRY ( KNoTag, CUpnpEventNotificationActivity::TSendRequest, CUpnpEventNotificationActivity::TAwaitingErrorOrResponse, TNoTag ) |
|
263 LAST_NODEACTIVITY_ENTRY ( KNoTag, TClearError ) |
|
264 NODEACTIVITY_END ( ) |
|
265 } |
|
266 |
|
267 |
|
268 namespace UPnPServiceSCprActivities |
|
269 { |
|
270 DEFINE_ACTIVITY_MAP ( activityMap ) |
|
271 ACTIVITY_MAP_ENTRY ( UPnPServiceSCprParamRequestActivity, UPnPServiceSCprParamRequest ) |
|
272 ACTIVITY_MAP_ENTRY ( UPnPServiceSCprApplyRequestActivity, UPnPServiceSCprApplyRequest ) |
|
273 ACTIVITY_MAP_ENTRY ( UPnPServiceSCprBinderRequestActivity, UPnPServiceSCprBinderRequest ) |
|
274 ACTIVITY_MAP_ENTRY ( UPnPServiceSCprDataClientIdleActivity, UPnPServiceSCprDataClientIdle ) |
|
275 ACTIVITY_MAP_ENTRY ( UPnPServiceSCprClientLeaveActivity, UPnPServiceSCprClientLeave ) |
|
276 ACTIVITY_MAP_ENTRY ( UPnPServiceSCprDataClientStopActivity, UPnPServiceSCprDataClientStop ) |
|
277 ACTIVITY_MAP_ENTRY ( UPnPServiceSCprDestroyActivity, UPnPServiceSCprDestroy ) |
|
278 ACTIVITY_MAP_ENTRY ( UPnPServiceScprServiceRegistrationActivity, UPnPServiceSCprServiceRegistration ) |
|
279 ACTIVITY_MAP_ENTRY ( UPnPServiceScprDeviceRegistrationActivity, UPnPServiceSCprDeviceRegistration ) |
|
280 ACTIVITY_MAP_ENTRY ( UPnPServiceSCprFlowCreationActivity, UPnPServiceSCprFlowCreation ) |
|
281 ACTIVITY_MAP_ENTRY ( UPnPSerivceSearchResponseActivity, UPnPServiceSearchResponse ) |
|
282 ACTIVITY_MAP_ENTRY ( UpnpServiceRequestInfoActivity, UpnpServiceRequestInfo ) |
|
283 ACTIVITY_MAP_ENTRY ( UpnpServiceClientFlowCreationActivity, FindOrCreateFlow ) |
|
284 ACTIVITY_MAP_ENTRY ( UpnpEventNotificationActivity, UpnpEventNotification ) |
|
285 ACTIVITY_MAP_END_BASE ( SCprActivities, coreSCprActivities ) |
|
286 } |
|
287 |
|
288 |
|
289 //-------------------------Service Registration Activity------------------------------------- |
|
290 CNodeActivityBase* CUpnpServiceRegistrationActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode ) |
|
291 { |
|
292 return new ( ELeave ) CUpnpServiceRegistrationActivity ( aActivitySig, aNode ) ; |
|
293 } |
|
294 |
|
295 |
|
296 CUpnpServiceRegistrationActivity::CUpnpServiceRegistrationActivity ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode ) |
|
297 : CNodeActivityBase ( aActivitySig, aNode ) |
|
298 { |
|
299 } |
|
300 |
|
301 CUpnpServiceRegistrationActivity::~CUpnpServiceRegistrationActivity ( ) |
|
302 { |
|
303 SetError ( KErrNone ); |
|
304 delete iParamSet; |
|
305 } |
|
306 |
|
307 DEFINE_SMELEMENT ( CUpnpServiceRegistrationActivity::TRequestServiceJoin, NetStateMachine::MStateTransition, CUpnpServiceRegistrationActivity::TContext ) |
|
308 void CUpnpServiceRegistrationActivity::TRequestServiceJoin::DoL ( ) |
|
309 { |
|
310 LOG(ESockLogExternal::Printf(KSubsysSPSrvcRegActivity, KComponent, _L8("CUpnpServiceRegistrationActivity::TRequestServiceJoin::DoL"))); |
|
311 TUpnpMessage::TServiceRegistration& msg = message_cast<TUpnpMessage::TServiceRegistration>( iContext.iMessage ); |
|
312 |
|
313 CUpnpServiceRegistrationActivity& activity = static_cast<CUpnpServiceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
314 activity.iParamSet = static_cast<CUPnPServiceRegisterParamSet*> ( msg.iParamSet ); |
|
315 |
|
316 LOG(ESockLogExternal::Printf(KSubsysSPSrvcRegActivity, KComponent, _L8("CUpnpServiceRegistrationActivity::TRequestServiceJoin::DoL - Posting message TUpnpMessage::TServiceJoinRequest"))); |
|
317 activity.PostRequestTo ( iContext.Node ().ControlProvider ()->RecipientId (), TUpnpMessage::TServiceJoinRequest ( activity.iParamSet ).CRef () ); |
|
318 } |
|
319 |
|
320 DEFINE_SMELEMENT ( CUpnpServiceRegistrationActivity::TBuildPublishAndServiceInfo, NetStateMachine::MStateTransition, CUpnpServiceRegistrationActivity::TContext ) |
|
321 void CUpnpServiceRegistrationActivity::TBuildPublishAndServiceInfo::DoL ( ) |
|
322 { |
|
323 LOG(ESockLogExternal::Printf(KSubsysSPSrvcRegActivity, KComponent, _L8("CUpnpServiceRegistrationActivity::TBuildPublishAndServiceInfo::DoL"))); |
|
324 CUpnpServiceRegistrationActivity& activity = static_cast<CUpnpServiceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
325 |
|
326 CStringPoolManager& stringPoolMgr = iContext.Node ().ConnectionProvider ().StringPoolManager (); |
|
327 RStringPool& sp = stringPoolMgr.StringPool ( ); |
|
328 |
|
329 CUPnPPublishInfoElement* publishInfo = CUPnPPublishInfoElement::NewL ( ); |
|
330 CleanupStack::PushL ( publishInfo ); |
|
331 |
|
332 publishInfo->SetUuidL( activity.iParamSet->DeviceUid( ) ); |
|
333 publishInfo->SetSearchTargetL( activity.iParamSet->Uri( ) ) ; |
|
334 publishInfo->SetServiceDescriptionL( activity.iParamSet->ServiceDescription( ) ); |
|
335 publishInfo->SetCacheControlL( activity.iParamSet->CacheControlData( ) ) ; |
|
336 publishInfo->SetTimeOut( activity.iParamSet->SubscriptionDuration() ); |
|
337 |
|
338 const CUPnPSubscribeInfoContainer* subContainer = iContext.Node ( ).GetSubscribeInfoContainer ( ); |
|
339 subContainer->SetEventDataL( activity.iParamSet->InitialMessage( ) ); |
|
340 |
|
341 //Set USN |
|
342 RBuf8 resultUrl; |
|
343 TInt length = activity.iParamSet->DeviceUid( ).Length ( ) |
|
344 + activity.iParamSet->Uri( ).Length ( ) |
|
345 + KSeperator ( ).Length ( ); |
|
346 resultUrl.CreateL ( length ); |
|
347 CleanupClosePushL ( resultUrl ); |
|
348 resultUrl.Copy ( activity.iParamSet->DeviceUid( ) ); |
|
349 resultUrl.Append ( KSeperator ); |
|
350 resultUrl.Append ( activity.iParamSet->Uri( ) ); |
|
351 publishInfo->SetUsnL( resultUrl ); |
|
352 CleanupStack::PopAndDestroy ( &resultUrl ); |
|
353 |
|
354 activity.iServiceInfo = CUPnPServiceInfo::NewL ( ); |
|
355 activity.iServiceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EServiceType, stringPoolMgr.GetUPnPTable() ), activity.iParamSet->Uri( ) ); |
|
356 |
|
357 // construct serviceid |
|
358 RBuf8 serviceId; |
|
359 activity.GenerateServiceIdL ( stringPoolMgr, activity.iParamSet->Uri( ), serviceId ); |
|
360 CleanupClosePushL ( serviceId ); |
|
361 activity.iServiceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EServiceId, stringPoolMgr.GetUPnPTable() ), serviceId ); |
|
362 |
|
363 |
|
364 // SCPD Url |
|
365 activity.CreateRelativeUrlL ( serviceId, |
|
366 sp.String ( UPNPDESCRIPTIONXMLTAGS::EScpdUrl, stringPoolMgr.GetUPnPTable()).DesC ( ), |
|
367 resultUrl ); |
|
368 CleanupClosePushL ( resultUrl ); |
|
369 activity.iServiceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EScpdUrl, stringPoolMgr.GetUPnPTable ( ) ), resultUrl ); |
|
370 //Note! result url is a relative url that starts with '/', avoid this in scpr properties, bare url will take care |
|
371 TPtr8 urlPtr = resultUrl.MidTPtr ( 1 ); |
|
372 publishInfo->SetKeyL( urlPtr ); |
|
373 iContext.Node ( ).SetKeyL ( urlPtr ); |
|
374 |
|
375 CleanupStack::PopAndDestroy ( &resultUrl ); |
|
376 |
|
377 // ControlUrl |
|
378 activity.CreateRelativeUrlL ( serviceId, |
|
379 sp.String ( UPNPDESCRIPTIONXMLTAGS::EContorlUrl, stringPoolMgr.GetUPnPTable() ).DesC ( ), |
|
380 resultUrl ); |
|
381 CleanupClosePushL ( resultUrl ); |
|
382 activity.iServiceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EContorlUrl, stringPoolMgr.GetUPnPTable() ), resultUrl ); |
|
383 urlPtr.Set ( resultUrl.MidTPtr ( 1 ) ); |
|
384 iContext.Node ( ).SetControlUrlL ( urlPtr ); |
|
385 CleanupStack::PopAndDestroy ( &resultUrl ); |
|
386 |
|
387 // EventSubUrl |
|
388 activity.CreateRelativeUrlL ( serviceId, |
|
389 sp.String ( UPNPDESCRIPTIONXMLTAGS::EEventSubUrl, stringPoolMgr.GetUPnPTable() ).DesC ( ), |
|
390 resultUrl ); |
|
391 CleanupClosePushL ( resultUrl ); |
|
392 activity.iServiceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EEventSubUrl, stringPoolMgr.GetUPnPTable() ), resultUrl ); |
|
393 urlPtr.Set ( resultUrl.MidTPtr ( 1 ) ); |
|
394 iContext.Node ( ).SetEventUrlL ( urlPtr ); |
|
395 CleanupStack::PopAndDestroy ( &resultUrl ); |
|
396 |
|
397 |
|
398 CleanupStack::PopAndDestroy ( &serviceId ); |
|
399 CleanupStack::Pop ( publishInfo ); |
|
400 |
|
401 iContext.Node ( ).SetPublishInfo ( publishInfo ); |
|
402 } |
|
403 |
|
404 void CUpnpServiceRegistrationActivity::GenerateServiceIdL ( CStringPoolManager& aStringPoolMgr, const TDesC8& aUri, RBuf8& aServiceId ) |
|
405 { |
|
406 TLex8 parser ( aUri ); |
|
407 TChar ch = ':'; |
|
408 parser.Mark ( ); |
|
409 while ( !parser.Eos ( ) && parser.Peek ( ) != ch ) |
|
410 parser.Inc ( ); |
|
411 |
|
412 parser.Inc ( ); |
|
413 while ( !parser.Eos ( ) && parser.Peek ( ) != ch ) |
|
414 parser.Inc ( ); |
|
415 |
|
416 TPtrC8 schemaType = parser.MarkedToken ( ); |
|
417 |
|
418 if ( schemaType.Compare ( KUrnSchema ( ) ) == 0 ) |
|
419 { |
|
420 // Standard Upnp devices |
|
421 aServiceId.CreateL ( KUrnService ); |
|
422 } |
|
423 else |
|
424 { |
|
425 RStringPool& sp = aStringPoolMgr.StringPool ( ); |
|
426 |
|
427 // Vendor specific devices |
|
428 aServiceId.CreateL ( schemaType ); |
|
429 aServiceId.ReAllocL ( aServiceId.Length ( ) |
|
430 + sp.String ( UPNPDESCRIPTIONXMLTAGS::EServiceId, aStringPoolMgr.GetUPnPTable() ).DesC ( ).Length ( ) |
|
431 + KColon ( ).Length ( ) * 2 ); |
|
432 |
|
433 aServiceId.Append ( KColon ( ) ); |
|
434 aServiceId.Append ( sp.String ( UPNPDESCRIPTIONXMLTAGS::EServiceId, aStringPoolMgr.GetUPnPTable() ).DesC ( ) ); |
|
435 aServiceId.Append ( KColon ( ) ); |
|
436 } |
|
437 |
|
438 parser.Inc ( ); |
|
439 |
|
440 while ( !parser.Eos ( ) && parser.Peek ( ) != ch ) |
|
441 parser.Inc ( ); |
|
442 |
|
443 parser.Inc ( ); |
|
444 parser.Mark ( ); |
|
445 |
|
446 while ( !parser.Eos ( ) && parser.Peek ( ) != ch ) |
|
447 parser.Inc ( ); |
|
448 |
|
449 TPtrC8 serviceType = parser.MarkedToken ( ); |
|
450 |
|
451 RBuf8 uniqueId; |
|
452 UpnpUuid::GenerateUuidL ( uniqueId ); |
|
453 CleanupClosePushL ( uniqueId ); |
|
454 |
|
455 aServiceId.ReAllocL ( aServiceId.Length ( ) + serviceType.Length ( ) + uniqueId.Length ( ) ); |
|
456 aServiceId.Append ( serviceType ); |
|
457 aServiceId.Append ( uniqueId ); |
|
458 |
|
459 CleanupStack::PopAndDestroy ( &uniqueId ); |
|
460 } |
|
461 |
|
462 |
|
463 |
|
464 void CUpnpServiceRegistrationActivity::CreateRelativeUrlL ( const TDesC8& aServiceId, const TDesC8& aUri, RBuf8& aResultUrl ) |
|
465 { |
|
466 _LIT8 ( KForwardSlash, "/" ); |
|
467 RBuf8 tempUrl; |
|
468 TInt length = KForwardSlash ().Length () + aServiceId.Length ( ) |
|
469 + KUnderScore ( ).Length ( ) |
|
470 + aUri.Length ( ); |
|
471 |
|
472 tempUrl.CreateL ( length ); |
|
473 tempUrl.Copy ( KForwardSlash ); |
|
474 tempUrl.Append ( aServiceId ); |
|
475 tempUrl.Append ( KUnderScore ); |
|
476 tempUrl.Append ( aUri ); |
|
477 aResultUrl.Assign ( tempUrl ); |
|
478 } |
|
479 |
|
480 |
|
481 DEFINE_SMELEMENT ( CUpnpServiceRegistrationActivity::TRegisterServiceInfoWithCPR, NetStateMachine::MStateTransition, CUpnpServiceRegistrationActivity::TContext ) |
|
482 void CUpnpServiceRegistrationActivity::TRegisterServiceInfoWithCPR::DoL ( ) |
|
483 { |
|
484 LOG(ESockLogExternal::Printf(KSubsysSPSrvcRegActivity, KComponent, _L8("CUpnpServiceRegistrationActivity::TRegisterServiceInfoWithCPR::DoL"))); |
|
485 CUpnpServiceRegistrationActivity& activity = static_cast<CUpnpServiceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
486 activity.PostRequestTo ( iContext.Node ().ControlProvider ()->RecipientId (), TUpnpMessage::TRegisterService ( activity.iParamSet, activity.iServiceInfo ).CRef () ); |
|
487 } |
|
488 |
|
489 DEFINE_SMELEMENT ( CUpnpServiceRegistrationActivity::TSendPublishRequest, NetStateMachine::MStateTransition, CUpnpServiceRegistrationActivity::TContext ) |
|
490 void CUpnpServiceRegistrationActivity::TSendPublishRequest::DoL ( ) |
|
491 { |
|
492 LOG(ESockLogExternal::Printf(KSubsysSPSrvcRegActivity, KComponent, _L8("CUpnpServiceRegistrationActivity::TSendPublishRequest::DoL"))); |
|
493 CUPnPPublishInfoElement* publishInfo = iContext.Node ( ).PublishInfo ( ); |
|
494 |
|
495 // Publish once for uuid:device-UUID::urn:domain-name-service:serviceType:v |
|
496 iContext.Node ( ).DoPublishL ( publishInfo->SearchTarget ( ), publishInfo->Usn ( ), publishInfo->CacheControl ( ) ); |
|
497 } |
|
498 |
|
499 |
|
500 DEFINE_SMELEMENT ( CUpnpServiceRegistrationActivity::TRegisterSsdpInfoWithServer, NetStateMachine::MStateTransition, CUpnpServiceRegistrationActivity::TContext ) |
|
501 void CUpnpServiceRegistrationActivity::TRegisterSsdpInfoWithServer::DoL ( ) |
|
502 { |
|
503 LOG(ESockLogExternal::Printf(KSubsysSPSrvcRegActivity, KComponent, _L8("CUpnpServiceRegistrationActivity::TRegisterSsdpInfoWithServer::DoL"))); |
|
504 CUPnPPublishInfoElement* publishInfo = iContext.Node ( ).PublishInfo ( ); |
|
505 |
|
506 RMemChunk stBuf; |
|
507 stBuf.CreateL ( publishInfo->SearchTarget ( ), iContext.Node ( ).ConnectionProvider().MemoryAllocator() ); |
|
508 |
|
509 LOG(ESockLogExternal::Printf(KSubsysSPSrvcRegActivity, KComponent, _L8("CUpnpServiceRegistrationActivity::TInitiateTcpFlowCreation::DoL - Posting message TUpnpMessage::TUPnPPublishRegistration"))); |
|
510 TSsdpInfo ssdpInfo ( stBuf ); |
|
511 RClientInterface::OpenPostMessageClose ( TNodeCtxId ( MeshMachine::KActivityNull, iContext.NodeId () ), iContext.Node ().UdpServerFlow (), TUpnpMessage::TUPnPPublishRegistration ( ssdpInfo ).CRef () ); |
|
512 } |
|
513 |
|
514 |
|
515 DEFINE_SMELEMENT ( CUpnpServiceRegistrationActivity::TInitiateTcpFlowCreation, NetStateMachine::MStateTransition, CUpnpServiceRegistrationActivity::TContext ) |
|
516 void CUpnpServiceRegistrationActivity::TInitiateTcpFlowCreation::DoL ( ) |
|
517 { |
|
518 // kickoff self activity to create tcp server flows |
|
519 LOG(ESockLogExternal::Printf(KSubsysSPSrvcRegActivity, KComponent, _L8("CUpnpServiceRegistrationActivity::TInitiateTcpFlowCreation::DoL - Posting message TUpnpMessage::TCreateServerFlow"))); |
|
520 RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.NodeId (), TUpnpMessage::TCreateServerFlow ().CRef () ); |
|
521 } |
|
522 |
|
523 |
|
524 //-------------------------Embedded Device Session Registration Activity------------------------------------- |
|
525 CNodeActivityBase* CUpnpDeviceRegistrationActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode ) |
|
526 { |
|
527 return new ( ELeave ) CUpnpDeviceRegistrationActivity ( aActivitySig, aNode ) ; |
|
528 } |
|
529 |
|
530 |
|
531 CUpnpDeviceRegistrationActivity::CUpnpDeviceRegistrationActivity ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode ) |
|
532 : CNodeActivityBase ( aActivitySig, aNode ), iIconUrlIdx ( 0 ) |
|
533 { |
|
534 } |
|
535 |
|
536 CUpnpDeviceRegistrationActivity::~CUpnpDeviceRegistrationActivity ( ) |
|
537 { |
|
538 SetError ( KErrNone ); |
|
539 delete iParamSet; |
|
540 iIconUrl.Close (); |
|
541 } |
|
542 |
|
543 DEFINE_SMELEMENT ( CUpnpDeviceRegistrationActivity::TRequestDeviceJoin, NetStateMachine::MStateTransition, CUpnpDeviceRegistrationActivity::TContext ) |
|
544 void CUpnpDeviceRegistrationActivity::TRequestDeviceJoin::DoL ( ) |
|
545 { |
|
546 LOG(ESockLogExternal::Printf(KSubsysSPDeviceRegActivity, KComponent, _L8("CUpnpDeviceRegistrationActivity::TRequestDeviceJoin::DoL"))); |
|
547 TUpnpMessage::TDeviceRegistration& msg = message_cast<TUpnpMessage::TDeviceRegistration>( iContext.iMessage ); |
|
548 |
|
549 CUpnpDeviceRegistrationActivity& activity = static_cast<CUpnpDeviceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
550 activity.iParamSet = static_cast<CUPnPDeviceRegisterParamSet*> ( msg.iParamSet ); |
|
551 |
|
552 LOG(ESockLogExternal::Printf(KSubsysSPDeviceRegActivity, KComponent, _L8("CUpnpDeviceRegistrationActivity::TRequestDeviceJoin::DoL - Posting message TUpnpMessage::TDeviceJoinRequest"))); |
|
553 activity.PostRequestTo ( iContext.Node ().ControlProvider ()->RecipientId (), TUpnpMessage::TDeviceJoinRequest ( activity.iParamSet ).CRef () ); |
|
554 } |
|
555 |
|
556 DEFINE_SMELEMENT ( CUpnpDeviceRegistrationActivity::TBuildPublishAndDeviceInfo, NetStateMachine::MStateTransition, CUpnpDeviceRegistrationActivity::TContext ) |
|
557 void CUpnpDeviceRegistrationActivity::TBuildPublishAndDeviceInfo::DoL ( ) |
|
558 { |
|
559 LOG(ESockLogExternal::Printf(KSubsysSPDeviceRegActivity, KComponent, _L8("CUpnpDeviceRegistrationActivity::TBuildPublishAndDeviceInfo::DoL"))); |
|
560 CUpnpDeviceRegistrationActivity& activity = static_cast<CUpnpDeviceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
561 |
|
562 CUPnPPublishInfoElement* publishInfo = CUPnPPublishInfoElement::NewL ( ); |
|
563 CleanupStack::PushL ( publishInfo ); |
|
564 |
|
565 publishInfo->SetUuidL( activity.iParamSet->UDN( ) ); |
|
566 publishInfo->SetSearchTargetL( activity.iParamSet->Uri( ) ) ; |
|
567 publishInfo->SetCacheControlL( activity.iParamSet->CacheControlData( ) ) ; |
|
568 // for an embedded device both key and UDN are same, so...it can key can be used |
|
569 // for deregistering embedded device. |
|
570 publishInfo->SetKeyL( activity.iParamSet->UDN( ) ); |
|
571 |
|
572 //Set USN |
|
573 RBuf8 tempUrl; |
|
574 TInt length = activity.iParamSet->UDN( ).Length ( ) |
|
575 + activity.iParamSet->Uri( ).Length ( ) |
|
576 + KSeperator ( ).Length ( ); |
|
577 |
|
578 tempUrl.CreateMaxL ( length ); |
|
579 CleanupClosePushL ( tempUrl ); |
|
580 |
|
581 tempUrl.Copy ( activity.iParamSet->UDN( ) ); |
|
582 tempUrl.Append ( KSeperator ); |
|
583 tempUrl.Append ( activity.iParamSet->Uri( ) ); |
|
584 publishInfo->SetUsnL( tempUrl ); |
|
585 |
|
586 activity.iDeviceInfo = CUPnPDevice::NewL ( ); |
|
587 |
|
588 CStringPoolManager& stringPoolMgr = iContext.Node ().ConnectionProvider ().StringPoolManager (); |
|
589 RStringPool& sp = stringPoolMgr.StringPool ( ); |
|
590 |
|
591 // set device info |
|
592 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EPresentationUrl, stringPoolMgr.GetUPnPTable() ), activity.iParamSet->PresentationUri( ) ); |
|
593 // set the device attributes |
|
594 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EDeviceType, stringPoolMgr.GetUPnPTable() ), activity.iParamSet->Uri( ) ); |
|
595 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EFriendlyName, stringPoolMgr.GetUPnPTable() ),activity.iParamSet->FriendlyName( ) ); |
|
596 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EUdn,stringPoolMgr.GetUPnPTable()), activity.iParamSet->UDN( ) ); |
|
597 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EUpc, stringPoolMgr.GetUPnPTable()), activity.iParamSet->UPC( ) ); |
|
598 |
|
599 // set manufacturer attributes |
|
600 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EManufacturer, stringPoolMgr.GetUPnPTable() ), activity.iParamSet->Manufacturer( ) ); |
|
601 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EManufacturerUrl, stringPoolMgr.GetUPnPTable() ), activity.iParamSet->ManufacturerUrl( ) ); |
|
602 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::ESerialNumber, stringPoolMgr.GetUPnPTable() ), activity.iParamSet->SerialNumber( ) ); |
|
603 |
|
604 // set device model attributes |
|
605 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EModelName, stringPoolMgr.GetUPnPTable() ), activity.iParamSet->ModelName( ) ); |
|
606 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EModelDescription,stringPoolMgr.GetUPnPTable() ), activity.iParamSet->ModelDesc( ) ); |
|
607 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EModelNumber, stringPoolMgr.GetUPnPTable()), activity.iParamSet->ModelNumber( ) ); |
|
608 activity.iDeviceInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EModel,stringPoolMgr.GetUPnPTable() ), activity.iParamSet->ModelUri( ) ); |
|
609 |
|
610 for (TInt i = 0; i < activity.iParamSet->IconList ().Count (); i++ ) |
|
611 { |
|
612 CUPnPIconParams* iconParams = activity.iParamSet->IconList ()[i]; |
|
613 CUPnPIconInfo* iconInfo = CUPnPIconInfo::NewL (); |
|
614 CleanupStack::PushL ( iconInfo ); |
|
615 iconInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EMimeType, stringPoolMgr.GetUPnPTable() ), iconParams->MimeType () ); |
|
616 iconInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EWidth,stringPoolMgr.GetUPnPTable() ), iconParams->Width () ); |
|
617 iconInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EHeight, stringPoolMgr.GetUPnPTable()), iconParams->Height () ); |
|
618 iconInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EDepth,stringPoolMgr.GetUPnPTable() ), iconParams->Depth () ); |
|
619 iconInfo->SetPropertyL( sp.String ( UPNPDESCRIPTIONXMLTAGS::EUrl,stringPoolMgr.GetUPnPTable() ), iconParams->Url () ); |
|
620 |
|
621 activity.iDeviceInfo->AppendToIconInfoTableL ( iconInfo ); |
|
622 CleanupStack::Pop ( iconInfo ); |
|
623 } |
|
624 |
|
625 CleanupStack::PopAndDestroy ( &tempUrl ); |
|
626 CleanupStack::Pop ( publishInfo ); |
|
627 |
|
628 iContext.Node ( ).SetPublishInfo ( publishInfo ); |
|
629 iContext.Node ( ). SetDevice ( ETrue ); |
|
630 } |
|
631 |
|
632 DEFINE_SMELEMENT ( CUpnpDeviceRegistrationActivity::TRegisterDeviceInfoWithCPR, NetStateMachine::MStateTransition, CUpnpDeviceRegistrationActivity::TContext ) |
|
633 void CUpnpDeviceRegistrationActivity::TRegisterDeviceInfoWithCPR::DoL ( ) |
|
634 { |
|
635 CUpnpDeviceRegistrationActivity& activity = static_cast<CUpnpDeviceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
636 LOG(ESockLogExternal::Printf(KSubsysSPDeviceRegActivity, KComponent, _L8("CUpnpDeviceRegistrationActivity::TRegisterDeviceInfoWithCPR::DoL - Posting message TUpnpMessage::TRegisterDevice"))); |
|
637 activity.PostRequestTo ( iContext.Node ().ControlProvider ()->RecipientId (), TUpnpMessage::TRegisterDevice ( activity.iParamSet, activity.iDeviceInfo ).CRef () ); |
|
638 } |
|
639 |
|
640 DEFINE_SMELEMENT ( CUpnpDeviceRegistrationActivity::TSendPublishRequest, NetStateMachine::MStateTransition, CUpnpDeviceRegistrationActivity::TContext ) |
|
641 void CUpnpDeviceRegistrationActivity::TSendPublishRequest::DoL ( ) |
|
642 { |
|
643 LOG(ESockLogExternal::Printf(KSubsysSPDeviceRegActivity, KComponent, _L8("CUpnpDeviceRegistrationActivity::TSendPublishRequest::DoL"))); |
|
644 CUPnPPublishInfoElement* publishInfo = iContext.Node ( ).PublishInfo ( ); |
|
645 |
|
646 // Publish once for uuid:device-UUID |
|
647 iContext.Node ( ).DoPublishL ( publishInfo->Uuid ( ), publishInfo->Uuid ( ), publishInfo->CacheControl ( ) ); |
|
648 |
|
649 // Publish once for uuid:device-UUID::urn:domain-name-device:deviceType:v |
|
650 iContext.Node ( ).DoPublishL ( publishInfo->SearchTarget ( ), publishInfo->Usn ( ), publishInfo->CacheControl ( ) ); |
|
651 } |
|
652 |
|
653 DEFINE_SMELEMENT ( CUpnpDeviceRegistrationActivity::TRegisterSsdpInfoWithServer, NetStateMachine::MStateTransition, CUpnpDeviceRegistrationActivity::TContext ) |
|
654 void CUpnpDeviceRegistrationActivity::TRegisterSsdpInfoWithServer::DoL ( ) |
|
655 { |
|
656 LOG(ESockLogExternal::Printf(KSubsysSPDeviceRegActivity, KComponent, _L8("CUpnpDeviceRegistrationActivity::TRegisterSsdpInfoWithServer::DoL"))); |
|
657 CUPnPPublishInfoElement* publishInfo = iContext.Node ( ).PublishInfo ( ); |
|
658 |
|
659 // Register once for uuid:device-UUID |
|
660 RegisterForMSearchL ( publishInfo->Uuid ( ) ); |
|
661 |
|
662 // Register once for uuid:device-UUID::urn:domain-name-device:deviceType:v |
|
663 RegisterForMSearchL ( publishInfo->SearchTarget ( ) ); |
|
664 } |
|
665 |
|
666 void CUpnpDeviceRegistrationActivity::TRegisterSsdpInfoWithServer::RegisterForMSearchL ( const TDesC8& aSearchTarget ) |
|
667 { |
|
668 LOG(ESockLogExternal::Printf(KSubsysSPDeviceRegActivity, KComponent, _L8("CUpnpDeviceRegistrationActivity::TRegisterSsdpInfoWithServer::DoL"))); |
|
669 RMemChunk stBuf; |
|
670 stBuf.CreateL ( aSearchTarget, iContext.Node ( ).ConnectionProvider().MemoryAllocator() ); |
|
671 |
|
672 LOG(ESockLogExternal::Printf(KSubsysSPDeviceRegActivity, KComponent, _L8("CUpnpDeviceRegistrationActivity::TRegisterSsdpInfoWithServer::DoL - Posting message TUpnpMessage::TUPnPPublishRegistration"))); |
|
673 TSsdpInfo ssdpInfo ( stBuf ); |
|
674 RClientInterface::OpenPostMessageClose ( TNodeCtxId ( MeshMachine::KActivityNull, iContext.NodeId () ), iContext.Node ().UdpServerFlow () , TUpnpMessage::TUPnPPublishRegistration ( ssdpInfo ).CRef () ); |
|
675 } |
|
676 |
|
677 DEFINE_SMELEMENT ( CUpnpDeviceRegistrationActivity::TCreateIconFlow, NetStateMachine::MStateTransition, CUpnpDeviceRegistrationActivity::TContext ) |
|
678 void CUpnpDeviceRegistrationActivity::TCreateIconFlow::DoL () |
|
679 { |
|
680 CUpnpDeviceRegistrationActivity& activity = static_cast<CUpnpDeviceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
681 activity.iIconUrl.Close (); |
|
682 |
|
683 const TDesC8& rootLoc = iContext.Node ().ConnectionProvider ().RootDeviceLocation (); |
|
684 const TDesC8& url = activity.iParamSet->IconList()[activity.iIconUrlIdx]->Url (); |
|
685 if ( url[0] == TChar ('/') ) |
|
686 { |
|
687 activity.iIconUrl.CreateL ( rootLoc.Length () + ( url.Length () - 1 ) ); |
|
688 activity.iIconUrl.Copy ( rootLoc ); |
|
689 activity.iIconUrl.Append ( url.Mid (1) ); |
|
690 } |
|
691 else |
|
692 { |
|
693 activity.iIconUrl.CreateL ( rootLoc.Length () + url.Length () ); |
|
694 activity.iIconUrl.Copy ( rootLoc ); |
|
695 activity.iIconUrl.Append ( url ); |
|
696 } |
|
697 |
|
698 const TUint8* uriPtr = activity.iIconUrl.Ptr (); |
|
699 TUint size = activity.iIconUrl.Size (); |
|
700 const TUid requestedUid = { CUPnPFlowFactory::iUid }; |
|
701 THttpServerFlowQuery flowQuery ( uriPtr, |
|
702 size, |
|
703 iContext.NodeId (), |
|
704 EHttpServerFlow ); |
|
705 |
|
706 ESock::TCFFactory::TFindOrCreatePeer msg ( TCFPlayerRole::EDataPlane, requestedUid, &flowQuery ); |
|
707 |
|
708 TCFPlayerRole playerRole ( TCFPlayerRole::EDataPlane ); |
|
709 Messages::TNodeId factoryContainer = SockManGlobals::Get()->GetPlaneFC( playerRole ); |
|
710 activity.PostRequestTo( factoryContainer, msg ); |
|
711 } |
|
712 |
|
713 DEFINE_SMELEMENT ( CUpnpDeviceRegistrationActivity::TIconCreateOrNoTag, NetStateMachine::MStateFork, CUpnpDeviceRegistrationActivity::TContext ) |
|
714 TInt CUpnpDeviceRegistrationActivity::TIconCreateOrNoTag::TransitionTag () |
|
715 { |
|
716 CUpnpDeviceRegistrationActivity& activity = static_cast<CUpnpDeviceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
717 return activity.iParamSet->IconList ().Count () != 0 ? KCreateIconTag : KNoTag; |
|
718 } |
|
719 |
|
720 DEFINE_SMELEMENT ( CUpnpDeviceRegistrationActivity::TIconOrNoTag, NetStateMachine::MStateFork, CUpnpDeviceRegistrationActivity::TContext ) |
|
721 TInt CUpnpDeviceRegistrationActivity::TIconOrNoTag::TransitionTag () |
|
722 { |
|
723 CUpnpDeviceRegistrationActivity& activity = static_cast<CUpnpDeviceRegistrationActivity&> ( *iContext.iNodeActivity ); |
|
724 |
|
725 activity.iIconUrlIdx++; |
|
726 if ( activity.iParamSet->IconList ().Count () != activity.iIconUrlIdx ) |
|
727 { |
|
728 return NetStateMachine::EBackward | KCreateIconTag; |
|
729 } |
|
730 |
|
731 return NetStateMachine::EForward | KNoTag; |
|
732 } |
|
733 |
|
734 // -------------- Request Info Activity-------------------------------------------------- |
|
735 |
|
736 CNodeActivityBase* CUpnpSPRequestInfoActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode ) |
|
737 { |
|
738 return ( new ( ELeave ) CUpnpSPRequestInfoActivity ( aActivitySig, aNode ) ); |
|
739 } |
|
740 |
|
741 CUpnpSPRequestInfoActivity::~CUpnpSPRequestInfoActivity ( ) |
|
742 { |
|
743 SetError ( KErrNone ); |
|
744 } |
|
745 |
|
746 // Transitions |
|
747 DEFINE_SMELEMENT ( CUpnpSPRequestInfoActivity::TSendDescribeResponse, NetStateMachine::MStateTransition, CUpnpSPRequestInfoActivity::TContext ) |
|
748 void CUpnpSPRequestInfoActivity::TSendDescribeResponse::DoL ( ) |
|
749 { |
|
750 LOG(ESockLogExternal::Printf(KSubsysSPServiceReqInfoActivity, KComponent, _L8("CUpnpSPRequestInfoActivity::TSendDescribeResponse::DoL"))); |
|
751 |
|
752 TUpnpMessage::TUPnPRequestInfo& requestMsg = message_cast< TUpnpMessage::TUPnPRequestInfo > ( iContext.iMessage ); |
|
753 CTransaction* transaction = static_cast<CTransaction*> ( requestMsg.iPtr ); |
|
754 TInt statusCode; |
|
755 RMemoryAllocator allocator = iContext.Node ( ).ConnectionProvider().MemoryAllocator(); |
|
756 |
|
757 if ( transaction->Request()->URI()->Uri().UriDes().Compare ( iContext.Node ().Key () ) == 0 ) |
|
758 { |
|
759 RMemChunk dataChian; |
|
760 dataChian.CreateL( iContext.Node ( ).SCPDData ( ), allocator ); |
|
761 transaction->AddBodyPart( dataChian ); |
|
762 statusCode = HTTPStatus::EOk; |
|
763 } |
|
764 else |
|
765 { |
|
766 CUPnPUtils::FindAndSendIconDataL ( transaction, statusCode, allocator ); |
|
767 } |
|
768 |
|
769 RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.iSender, |
|
770 TUpnpMessage::TUPnPResponseInfo ( transaction, statusCode, NULL ).CRef () ); |
|
771 } |
|
772 |
|
773 |
|
774 DEFINE_SMELEMENT ( CUpnpSPRequestInfoActivity::TSendSubscribeResponse, NetStateMachine::MStateTransition, CUpnpSPRequestInfoActivity::TContext ) |
|
775 void CUpnpSPRequestInfoActivity::TSendSubscribeResponse::DoL ( ) |
|
776 { |
|
777 LOG(ESockLogExternal::Printf(KSubsysSPServiceReqInfoActivity, KComponent, _L8("CUpnpSPRequestInfoActivity::TSendSubscribeResponse::DoL"))); |
|
778 CUpnpSPRequestInfoActivity& activity = static_cast< CUpnpSPRequestInfoActivity& > ( *iContext.iNodeActivity ); |
|
779 |
|
780 TUpnpMessage::TUPnPRequestInfo& requestMsg = message_cast< TUpnpMessage::TUPnPRequestInfo > ( iContext.iMessage ); |
|
781 CTransaction* transaction = static_cast<CTransaction*> ( requestMsg.iPtr ); |
|
782 |
|
783 TInt statusCode; |
|
784 TSubsribeResponseInfo subscribeResponse; |
|
785 |
|
786 THTTPHdrVal fieldVal; |
|
787 CUPnPPublishInfoElement* publishInfo = iContext.Node().PublishInfo(); |
|
788 if ( KErrNotFound == activity.GetHeaderValue ( *transaction->Request( ), UPnP::ESID, fieldVal, TUPnPTable::Table() ) ) |
|
789 { |
|
790 statusCode = activity.HandleSubscribeRequestL ( *transaction->Request( ), subscribeResponse, *publishInfo ); |
|
791 |
|
792 if ( statusCode == HTTPStatus::EOk && IsFirstSubscription ( ) ) |
|
793 { |
|
794 // trigger CPR to start subscription timer |
|
795 RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.Node ().ControlProvider ()->RecipientId (), |
|
796 TUpnpMessage::TStartTimer ().CRef () ); |
|
797 } |
|
798 } |
|
799 else |
|
800 { |
|
801 statusCode = activity.HandleResubscribeRequestL ( *transaction->Request( ), subscribeResponse, *publishInfo ); |
|
802 } |
|
803 RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.iSender, |
|
804 TUpnpMessage::TUPnPResponseInfo ( transaction, statusCode, &subscribeResponse ).CRef () ); |
|
805 } |
|
806 |
|
807 TInt CUpnpSPRequestInfoActivity::HandleSubscribeRequestL ( CRequest& aRequest, TSubsribeResponseInfo& aSubscribeResponse, CUPnPPublishInfoElement& aPublishInfo ) |
|
808 { |
|
809 TInt statusCode = HTTPStatus::EOk; |
|
810 // Note! as of now there is no limitation on subscribers or else send 5xx status code |
|
811 // Note! duration is accepted what ever the client is requesting |
|
812 |
|
813 THTTPHdrVal timeOutField; |
|
814 TInt err = GetHeaderValue ( aRequest, UPnP::ETimeout, timeOutField, TUPnPTable::Table() ); |
|
815 TInt timeout = aPublishInfo.TimeOut(); |
|
816 |
|
817 // If the SUBSCRIBE request doesn't have the Timeout header, |
|
818 // assume the standard DLNA specified value of 300 seconds. |
|
819 if(err != KErrNotFound) |
|
820 { |
|
821 if(timeOutField.Int() < aPublishInfo.TimeOut()) |
|
822 timeout = timeOutField.Int ( ); |
|
823 } |
|
824 |
|
825 THTTPHdrVal callbackField; |
|
826 err = GetHeaderValue ( aRequest, UPnP::ECallback, callbackField, TUPnPTable::Table() ); |
|
827 __ASSERT_DEBUG ( err != KErrNotFound, User::Invariant ( ) ); |
|
828 const TDesC8& callBackUrl = callbackField.StrF ( ).DesC ( ); |
|
829 |
|
830 // construct the subscribeinfoelement |
|
831 CUPnPSubscribeInfoElement* newSubscription = CUPnPSubscribeInfoElement::NewL ( ); |
|
832 newSubscription->SetEventKey ( 0 ); // initial value |
|
833 |
|
834 newSubscription->SetSubscriptionDuration ( timeout ); |
|
835 |
|
836 RBuf8 uuid; |
|
837 CleanupClosePushL ( uuid ); |
|
838 UpnpUuid::GenerateUuidL ( uuid ); |
|
839 newSubscription->SetSubscriptionIdentifierL ( uuid ); |
|
840 |
|
841 // extract and cache callback urls |
|
842 ProcessCallBackUrlL ( callBackUrl, newSubscription ); |
|
843 |
|
844 // append element in subscription container list |
|
845 CUPnPServiceSubConnectionProvider& subConn = static_cast<CUPnPServiceSubConnectionProvider&> ( iNode ); |
|
846 const CUPnPSubscribeInfoContainer* container = subConn.GetSubscribeInfoContainer ( ); |
|
847 container->AppendSubscribeInfoElementL( newSubscription ); |
|
848 |
|
849 // construct the response; |
|
850 aSubscribeResponse.iTimeout = timeout; |
|
851 aSubscribeResponse.iSid.CreateL ( uuid, subConn.ConnectionProvider().MemoryAllocator() ); |
|
852 CleanupStack::PopAndDestroy ( &uuid ); |
|
853 |
|
854 // send a message find or create a flow. |
|
855 // NOTE: This will also send the intial notify message and add it into the container. |
|
856 RClientInterface::OpenPostMessageClose ( iNode.Id(), iNode.Id (), |
|
857 TUpnpMessage::TCreateNotifyFlow ( newSubscription ).CRef () ); |
|
858 return statusCode; |
|
859 } |
|
860 |
|
861 |
|
862 void CUpnpSPRequestInfoActivity::ProcessCallBackUrlL ( const TDesC8& aUrl, CUPnPSubscribeInfoElement* aSubscribeElement ) |
|
863 { |
|
864 // extract the ip address and flow and add it to the info element |
|
865 aSubscribeElement->SetCallBackUrlL( aUrl ); |
|
866 |
|
867 TUriParser8 parsedUri; |
|
868 parsedUri.Parse ( aUrl ); |
|
869 |
|
870 TInt ip = 0; |
|
871 InetProtTextUtils::ConvertDescriptorToInt ( parsedUri.Extract ( EUriHost ), ip ); |
|
872 |
|
873 TInt port = KHttpDefaultPort; |
|
874 if ( parsedUri.IsPresent ( EUriPort ) ) |
|
875 { |
|
876 InetProtTextUtils::ConvertDescriptorToInt ( parsedUri.Extract ( EUriPort ), port ); |
|
877 } |
|
878 |
|
879 TAppProtAddr addr ( ip, port ); |
|
880 aSubscribeElement->SetRemoteAddr ( addr ); |
|
881 } |
|
882 |
|
883 |
|
884 TBool CUpnpSPRequestInfoActivity::TSendSubscribeResponse::IsFirstSubscription ( ) |
|
885 { |
|
886 const CUPnPSubscribeInfoContainer* container = iContext.Node ( ).GetSubscribeInfoContainer ( ); |
|
887 return container->CountOfSubscribeInfoElementArray( ) == 1 ? ETrue : EFalse; |
|
888 } |
|
889 |
|
890 |
|
891 TInt CUpnpSPRequestInfoActivity::HandleResubscribeRequestL ( CRequest& aRequest, TSubsribeResponseInfo& aSubscribeResponse, CUPnPPublishInfoElement& aPublishInfo ) |
|
892 { |
|
893 CUPnPServiceSubConnectionProvider& provider = static_cast<CUPnPServiceSubConnectionProvider&> ( iNode ); |
|
894 |
|
895 // Note! as of now there is no limitation on subscribers or else send 5xx status code |
|
896 // Note! duration is accepted what ever the client is requesting |
|
897 TInt statusCode = HTTPStatus::EOk; |
|
898 THTTPHdrVal timeOutField; |
|
899 TInt err = GetHeaderValue ( aRequest, UPnP::ETimeout, timeOutField, TUPnPTable::Table() ); |
|
900 TInt timeout = aPublishInfo.TimeOut(); |
|
901 |
|
902 // If the Re-SUBSCRIBE request doesn't have the Timeout header, |
|
903 // assume the standard DLNA specified value of 300 seconds. |
|
904 if(err != KErrNotFound) |
|
905 { |
|
906 if(timeOutField.Int() < aPublishInfo.TimeOut()) |
|
907 timeout = timeOutField.Int ( ); |
|
908 } |
|
909 |
|
910 THTTPHdrVal sidField; |
|
911 err = GetHeaderValue ( aRequest, UPnP::ESID, sidField, TUPnPTable::Table() ); |
|
912 __ASSERT_DEBUG ( err != KErrNotFound, User::Invariant ( ) ); |
|
913 |
|
914 const CUPnPSubscribeInfoContainer* container = provider.GetSubscribeInfoContainer ( ); |
|
915 CUPnPSubscribeInfoElement* element = container->GetSubscribeInfoBySid ( sidField.StrF ( ).DesC ( ) ); |
|
916 |
|
917 if ( element == NULL ) |
|
918 { |
|
919 // susbscription is expired send 412 error condition |
|
920 statusCode = HTTPStatus::EPreconditionFailed; |
|
921 } |
|
922 else |
|
923 { |
|
924 element->SetSubscriptionDuration ( timeout ); |
|
925 |
|
926 // construct the response; |
|
927 aSubscribeResponse.iTimeout = timeout; |
|
928 aSubscribeResponse.iSid.CreateL ( element->SubscriptionIdentifier( ), provider.ConnectionProvider().MemoryAllocator() ); |
|
929 } |
|
930 |
|
931 return statusCode; |
|
932 } |
|
933 |
|
934 |
|
935 DEFINE_SMELEMENT ( CUpnpSPRequestInfoActivity::TSendUnsubscribeResponse, NetStateMachine::MStateTransition, CUpnpSPRequestInfoActivity::TContext ) |
|
936 void CUpnpSPRequestInfoActivity::TSendUnsubscribeResponse::DoL ( ) |
|
937 { |
|
938 LOG(ESockLogExternal::Printf(KSubsysSPServiceReqInfoActivity, KComponent, _L8("CUpnpSPRequestInfoActivity::TSendUnsubscribeResponse::DoL"))); |
|
939 |
|
940 TUpnpMessage::TUPnPRequestInfo& requestMsg = message_cast< TUpnpMessage::TUPnPRequestInfo > ( iContext.iMessage ); |
|
941 CTransaction* transaction = static_cast<CTransaction*> ( requestMsg.iPtr ); |
|
942 |
|
943 |
|
944 CUpnpSPRequestInfoActivity& activity = static_cast< CUpnpSPRequestInfoActivity& > ( *iContext.iNodeActivity ); |
|
945 THTTPHdrVal sidField; |
|
946 TInt err = activity.GetHeaderValue ( *transaction->Request( ), UPnP::ESID, sidField, TUPnPTable::Table() ); |
|
947 __ASSERT_DEBUG ( err != KErrNotFound, User::Invariant ( ) ); |
|
948 |
|
949 |
|
950 CUPnPSubscribeInfoContainer* container = iContext.Node ( ).GetSubscribeInfoContainer ( ); |
|
951 CUPnPSubscribeInfoElement* element = container->GetSubscribeInfoBySid( sidField.StrF ( ).DesC ( ) ); |
|
952 |
|
953 TInt statusCode = HTTPStatus::EOk; |
|
954 if ( element == NULL ) |
|
955 { |
|
956 // susbscription is expired send 412 error condition |
|
957 statusCode = HTTPStatus::EPreconditionFailed; |
|
958 } |
|
959 else |
|
960 { |
|
961 container->DeleteSubscribeInfoElement(element); |
|
962 } |
|
963 if ( IsLastSubscription ( ) ) |
|
964 { |
|
965 // trigger CPR to stop subscription timer |
|
966 RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.Node ().ControlProvider ()->RecipientId (), |
|
967 TUpnpMessage::TStopTimer ().CRef () ); |
|
968 } |
|
969 RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.iSender, |
|
970 TUpnpMessage::TUPnPResponseInfo ( transaction, statusCode, NULL ).CRef () ); |
|
971 } |
|
972 |
|
973 |
|
974 TBool CUpnpSPRequestInfoActivity::TSendUnsubscribeResponse::IsLastSubscription ( ) |
|
975 { |
|
976 const CUPnPSubscribeInfoContainer* container = iContext.Node ( ).GetSubscribeInfoContainer ( ); |
|
977 return container->CountOfSubscribeInfoElementArray( ) == 0 ? ETrue : EFalse; |
|
978 } |
|
979 |
|
980 |
|
981 TInt CUpnpSPRequestInfoActivity::GetHeaderValue ( CRequest& aRequest, TInt aFieldIndex, THTTPHdrVal& aFieldVal, const TStringTable& aTable ) |
|
982 { |
|
983 RRequest request = aRequest.Handle ( ); |
|
984 RHTTPHeaders headers = request.GetHeaderCollection ( ); |
|
985 RStringF fieldStr = aRequest.StringPool ( ).StringF ( aFieldIndex , aTable ); |
|
986 return headers.GetField ( fieldStr, 0, aFieldVal ); |
|
987 } |
|
988 |
|
989 // -----------------------Client Flow Creation--------------------------------------------- |
|
990 CNodeActivityBase* CNotifyFlowFinder::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode ) |
|
991 { |
|
992 TUint activityId = GetNextActivityCountL ( aActivitySig, aNode ); |
|
993 return ( new ( ELeave ) CNotifyFlowFinder ( aActivitySig, aNode, activityId ) ); |
|
994 } |
|
995 |
|
996 |
|
997 CNotifyFlowFinder::~CNotifyFlowFinder ( ) |
|
998 { |
|
999 SetError( KErrNone ); |
|
1000 } |
|
1001 |
|
1002 |
|
1003 CNotifyFlowFinder::CNotifyFlowFinder ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode, TUint aActivityCount ) |
|
1004 :CNodeParallelActivityBase ( aActivitySig, aNode, aActivityCount ) |
|
1005 { |
|
1006 } |
|
1007 |
|
1008 DEFINE_SMELEMENT ( CNotifyFlowFinder::TFindOrCreateFlow, NetStateMachine::MStateTransition, CNotifyFlowFinder::TContext ) |
|
1009 void CNotifyFlowFinder::TFindOrCreateFlow::DoL ( ) |
|
1010 { |
|
1011 LOG(ESockLogExternal::Printf(KSubsysSPClntFlowCreationActivity, KComponent, _L8("CNotifyFlowFinder::TFindOrCreateFlow::DoL"))); |
|
1012 CNotifyFlowFinder& activity = static_cast< CNotifyFlowFinder& > ( *iContext.iNodeActivity ); |
|
1013 |
|
1014 TUpnpMessage::TCreateNotifyFlow& createFlowMsg = message_cast< TUpnpMessage::TCreateNotifyFlow > ( iContext.iMessage ); |
|
1015 activity.iSubscribeInfo = static_cast< CUPnPSubscribeInfoElement* > ( createFlowMsg.iPtr ); |
|
1016 |
|
1017 TNodeId factoryContainer = SockManGlobals::Get( )->GetPlaneFC( TCFPlayerRole ( TCFPlayerRole::EDataPlane ) ); |
|
1018 |
|
1019 const TUid requestedUid = { CUPnPFlowFactory::iUid }; |
|
1020 THttpClientFlowQuery flowQuery ( activity.iSubscribeInfo->RemoteAddr( ), iContext.NodeId (), EHttpClientFlow, THttpClientFlowQuery::EUseExisting ); |
|
1021 |
|
1022 activity.PostRequestTo ( factoryContainer, TCFFactory::TFindOrCreatePeer ( TCFPlayerRole::EDataPlane, requestedUid, &flowQuery ).CRef () ); |
|
1023 } |
|
1024 |
|
1025 |
|
1026 DEFINE_SMELEMENT ( CNotifyFlowFinder::TProcessDataClient, NetStateMachine::MStateTransition, CNotifyFlowFinder::TContext ) |
|
1027 void CNotifyFlowFinder::TProcessDataClient::DoL ( ) |
|
1028 { |
|
1029 LOG(ESockLogExternal::Printf(KSubsysSPClntFlowCreationActivity, KComponent, _L8("CNotifyFlowFinder::TProcessDataClient::DoL"))); |
|
1030 CNotifyFlowFinder& activity = static_cast< CNotifyFlowFinder& > ( *iContext.iNodeActivity ); |
|
1031 |
|
1032 //TNodeId dataClient = ( message_cast<TCFDataClient::TDataClientStarted> ( iContext.iMessage ) ).iSender; |
|
1033 activity.iSubscribeInfo->SetFlowId ( address_cast<TNodeId> ( iContext.iSender ) ); |
|
1034 |
|
1035 if ( !iContext.Node ( ).IsClosing ( ) ) |
|
1036 { |
|
1037 // send the intial notify message |
|
1038 RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.NodeId (), TUpnpMessage::TNotifyRequest ( activity.iSubscribeInfo ).CRef () ); |
|
1039 } |
|
1040 } |
|
1041 |
|
1042 |
|
1043 //---------------------Event Notification Activity------------------------------------- |
|
1044 CNodeActivityBase* CUpnpEventNotificationActivity::NewL ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode ) |
|
1045 { |
|
1046 TUint activityId = GetNextActivityCountL ( aActivitySig, aNode ); |
|
1047 return ( new ( ELeave ) CUpnpEventNotificationActivity ( aActivitySig, aNode, activityId ) ); |
|
1048 } |
|
1049 |
|
1050 |
|
1051 CUpnpEventNotificationActivity::CUpnpEventNotificationActivity ( const TNodeActivity& aActivitySig, AMMNodeBase& aNode, TUint aActivitiesCount ) |
|
1052 :CNodeParallelActivityBase ( aActivitySig, aNode, aActivitiesCount ) |
|
1053 { |
|
1054 } |
|
1055 |
|
1056 // Transitions |
|
1057 DEFINE_SMELEMENT ( CUpnpEventNotificationActivity::TSendRequest, NetStateMachine::MStateTransition, CUpnpEventNotificationActivity::TContext ) |
|
1058 void CUpnpEventNotificationActivity::TSendRequest::DoL ( ) |
|
1059 { |
|
1060 LOG(ESockLogExternal::Printf(KSubsysSPEventNotifyActivity, KComponent, _L8("CUpnpEventNotificationActivity::TSendRequest::DoL"))); |
|
1061 CUpnpEventNotificationActivity& activity = static_cast< CUpnpEventNotificationActivity& > ( *iContext.iNodeActivity ); |
|
1062 |
|
1063 RMemoryAllocator allocator = iContext.Node ( ).ConnectionProvider().MemoryAllocator(); |
|
1064 |
|
1065 const CUPnPSubscribeInfoContainer* cont = iContext.Node ( ).GetSubscribeInfoContainer ( ); |
|
1066 |
|
1067 TUpnpMessage::TNotifyRequest& msg = message_cast< TUpnpMessage::TNotifyRequest > ( iContext.iMessage ); |
|
1068 CUPnPSubscribeInfoElement* subscribeInfo = static_cast< CUPnPSubscribeInfoElement* > ( msg.iPtr );; |
|
1069 |
|
1070 RMemChunk uriBuf; |
|
1071 uriBuf.CreateL( subscribeInfo->CallBackUrl( ), allocator ); |
|
1072 TCleanupItem item ( &UPnPStateMachine::CUPnPUtils::CleanupMBufChain, &uriBuf ); |
|
1073 CleanupStack::PushL ( item ); |
|
1074 |
|
1075 RMemChunk bodyBuf; |
|
1076 bodyBuf.CreateL( cont->EventData(), allocator ); |
|
1077 TCleanupItem item1 ( &UPnPStateMachine::CUPnPUtils::CleanupMBufChain, &bodyBuf ); |
|
1078 CleanupStack::PushL ( item1 ); |
|
1079 |
|
1080 TEventNotifyRequestInfo notifyRequest; |
|
1081 RMemChunk sid; |
|
1082 notifyRequest.iSid.CreateL( subscribeInfo->SubscriptionIdentifier(), allocator ); |
|
1083 notifyRequest.iSeqKey = subscribeInfo->EventKey(); |
|
1084 |
|
1085 activity.PostRequestTo( subscribeInfo->FlowId(), |
|
1086 TUpnpMessage::TUPnPClientRequestInfo ( UPnP::ENotify, uriBuf, bodyBuf, ¬ifyRequest ).CRef () ); |
|
1087 |
|
1088 CleanupStack::Pop ( ); // item |
|
1089 CleanupStack::Pop ( ); // item1 |
|
1090 } |