|
1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // PDP SubConnection Provider implementation |
|
15 // |
|
16 // |
|
17 |
|
18 /** |
|
19 @file |
|
20 @internalComponent |
|
21 */ |
|
22 |
|
23 |
|
24 #include "PDPSCPRStates.h" |
|
25 #include "PDPDeftSCPR.h" |
|
26 #include "PDPSCPR.h" |
|
27 #include "PDPSCPRFactory.h" |
|
28 #include <comms-infras/ss_log.h> |
|
29 #include <comms-infras/ss_msgintercept.h> |
|
30 #include <comms-infras/agentscprstates.h> |
|
31 #include <comms-infras/agentscpractivities.h> |
|
32 #include <comms-infras/ss_nodemessages_factory.h> |
|
33 |
|
34 #if defined __FLOG_ACTIVE || defined SYMBIAN_TRACE_ENABLE |
|
35 #define KPDPSCprTag KESockSubConnectionTag |
|
36 _LIT8(KPDPSCprSubTag, "pdpscpr"); |
|
37 #endif |
|
38 |
|
39 using namespace Messages; |
|
40 using namespace MeshMachine; |
|
41 using namespace ESock; |
|
42 using namespace NetStateMachine; |
|
43 using namespace Factories; |
|
44 |
|
45 //We reserve space for two preallocated activities that may start concurrently on the SCPR |
|
46 //node: destroy and data client stop. |
|
47 static const TUint KDefaultMaxPreallocatedActivityCount = 2; |
|
48 static const TUint KMaxPreallocatedActivitySize = sizeof(MeshMachine::CNodeRetryParallelActivity) + sizeof(MeshMachine::APreallocatedOriginators<4>); |
|
49 static const TUint KPDPSCPRPreallocatedActivityBufferSize = KDefaultMaxPreallocatedActivityCount * KMaxPreallocatedActivitySize; |
|
50 |
|
51 //-========================================================= |
|
52 // |
|
53 // CPDPSubConnectionProvider Activities |
|
54 // |
|
55 //-========================================================= |
|
56 |
|
57 namespace PDPSCprProvisionActivity |
|
58 { |
|
59 DECLARE_DEFINE_NODEACTIVITY(ECFActivityStoreProvision, provision, TCFDataClient::TProvisionConfig) |
|
60 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TStoreProvisionAndInitSelf, CoreNetStates::TAwaitingProvision, MeshMachine::TNoTag) |
|
61 NODEACTIVITY_END() |
|
62 } |
|
63 |
|
64 namespace PDPSCprStartActivity |
|
65 { |
|
66 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStart, PDPScprStart, TCFServiceProvider::TStart, MeshMachine::CNodeRetryActivity::NewL) |
|
67 FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingStart, CoreNetStates::TNoTagOrBearerPresentBlockedByStop) |
|
68 NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TStartSelf, CoreNetStates::TAwaitingDataClientStarted, MeshMachine::TNoTag) |
|
69 LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendStarted) |
|
70 LAST_NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, CoreStates::TPanic) |
|
71 NODEACTIVITY_END() |
|
72 } |
|
73 |
|
74 namespace PDPSCprDataClientStartActivity |
|
75 { |
|
76 typedef MeshMachine::TAcceptErrorState<CoreNetStates::TAwaitingDataClientStarted> TAwaitingDataClientStartedOrError; |
|
77 |
|
78 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStartDataClient, pdpDataClientStart, TCFDataClient::TStart, PDPSCprStates::CStartActivity::NewL) |
|
79 FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingDataClientStart, MeshMachine::TNoTag) |
|
80 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TCreateSecondaryOrMbmsPDPCtx, PDPSCprStates::TAwaitingPDPCtxCreated, PDPSCprStates::TNoTagOrError) |
|
81 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TSetTFT, PDPSCprStates::TAwaitingTFTSet, PDPSCprStates::TNoTagOrError) |
|
82 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TSetQoS, PDPSCprStates::TAwaitingQoSSet, PDPSCprStates::TNoTagOrError) |
|
83 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TActivatePDPContext, PDPSCprStates::TAwaitingPDPContextActive, PDPSCprStates::TNoTagOrError) |
|
84 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TOverrideProvisionAndStartDataClient, TAwaitingDataClientStartedOrError, MeshMachine::TNoTagOrErrorTag) |
|
85 //This call below is somewhat obscure, but must be performed for the final activation of a pdp context. |
|
86 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TGetNegotiatedQoS, PDPSCprStates::TAwaitingNegotiatedQoSRetrieved, PDPSCprStates::TNoTagOrError) |
|
87 LAST_NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TRaiseParamsGrantedAndSendDataClientStarted) |
|
88 |
|
89 // Cleanup if error occurred |
|
90 THROUGH_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TDoNothing, CoreNetStates::TNoTagOrNoDataClientsToStop) |
|
91 NODEACTIVITY_ENTRY(KNoTag, SCprStates::TStopYourFlows, CoreNetStates::TAwaitingDataClientStopped, MeshMachine::TTag<CoreNetStates::KNoDataClientsToStop>) |
|
92 THROUGH_NODEACTIVITY_ENTRY(CoreNetStates::KNoDataClientsToStop, MeshMachine::TDoNothing, PDPSCprStates::TNoTagOrProviderStopped) |
|
93 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TDestroyPDPContext, PDPSCprStates::TAwaitingPDPContextDestroyed, MeshMachine::TTag<CoreNetStates::KProviderStopped>) |
|
94 THROUGH_NODEACTIVITY_ENTRY(CoreNetStates::KProviderStopped, PRStates::TDestroyOrphanedDataClients, MeshMachine::TTag<CoreNetStates::KProviderStopped>) |
|
95 LAST_NODEACTIVITY_ENTRY(CoreNetStates::KProviderStopped, MeshMachine::TRaiseActivityError) |
|
96 NODEACTIVITY_END() |
|
97 } |
|
98 |
|
99 namespace PDPSCprStopActivity |
|
100 { |
|
101 DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStopDataClient, Stop, TCFDataClient::TStop, MeshMachine::CNodeRetryActivity::NewL) |
|
102 FIRST_NODEACTIVITY_ENTRY(PDPSCprStates::TAwaitingDataClientStopOrCancel, MeshMachine::TNoTag) |
|
103 THROUGH_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, PRDataClientStopActivity::TNoTagOrProviderStoppedBlockedByStart) |
|
104 |
|
105 // stopping |
|
106 NODEACTIVITY_ENTRY(KNoTag, SCprStates::TStopYourFlows, CoreNetStates::TAwaitingDataClientStopped, MeshMachine::TTag<CoreNetStates::KProviderStopped>) |
|
107 THROUGH_NODEACTIVITY_ENTRY(CoreNetStates::KProviderStopped, MeshMachine::TDoNothing, PDPSCprStates::TNoTagOrProviderStopped) |
|
108 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TDestroyPDPContext, PDPSCprStates::TAwaitingPDPContextDestroyed, MeshMachine::TTag<CoreNetStates::KProviderStopped>) |
|
109 THROUGH_NODEACTIVITY_ENTRY(CoreNetStates::KProviderStopped, PRStates::TDestroyOrphanedDataClients, MeshMachine::TTag<CoreNetStates::KProviderStopped>) |
|
110 LAST_NODEACTIVITY_ENTRY(CoreNetStates::KProviderStopped, PDPSCprStates::TSendDataClientStopped) |
|
111 NODEACTIVITY_END() |
|
112 } |
|
113 |
|
114 namespace PDPSCprGoneDownActivity |
|
115 { |
|
116 DECLARE_DEFINE_NODEACTIVITY(ECFActivityGoneDown, goneDown, TPDPFSMMessages::TPDPFSMMessage) |
|
117 FIRST_NODEACTIVITY_ENTRY(PDPSCprStates::TAwaitingPDPContextGoneDown, MeshMachine::TActiveOrNoTag<ECFActivityStartDataClient>) |
|
118 THROUGH_NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TSendGoneDown, CoreNetStates::TNoTagOrNoDataClientsToStop) |
|
119 NODEACTIVITY_ENTRY(KNoTag, SCprStates::TStopYourFlows, CoreNetStates::TAwaitingDataClientStopped, MeshMachine::TTag<CoreNetStates::KNoDataClientsToStop>) |
|
120 |
|
121 LAST_NODEACTIVITY_ENTRY(KActiveTag, CoreNetStates::TCancelDataClientStart) //MZTODO: This triple should wait for TError sent as a response to TCancel |
|
122 LAST_NODEACTIVITY_ENTRY(CoreNetStates::KNoDataClientsToStop, MeshMachine::TClearError) |
|
123 NODEACTIVITY_END() |
|
124 } |
|
125 |
|
126 namespace PDPSCprSetParameters |
|
127 { |
|
128 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW |
|
129 DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, paramRequest, TCFScpr::TSetParamsRequest) |
|
130 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TStoreAndRespondWithCurrentParams, PRStates::TAwaitingParamRequest, MeshMachine::TNoTag) |
|
131 #else |
|
132 DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, paramRequest, TCFScpr::TParamsRequest) |
|
133 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TStoreParamsAndRespond, SCprStates::TAwaitingParamRequest, MeshMachine::TNoTag) |
|
134 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW |
|
135 NODEACTIVITY_END() |
|
136 } |
|
137 |
|
138 namespace PDPSCprApply |
|
139 { |
|
140 DECLARE_DEFINE_NODEACTIVITY(ECFActivityApplyChanges, pdpApplyReq, TCFScpr::TApplyRequest) |
|
141 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW |
|
142 FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingApplyRequest, MeshMachine::TNoTag) |
|
143 #else |
|
144 FIRST_NODEACTIVITY_ENTRY(SCprStates::TAwaitingApplyRequest, MeshMachine::TNoTag) |
|
145 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW |
|
146 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TSetTFT, PDPSCprStates::TAwaitingTFTSet, PDPSCprStates::TNoTagOrError) |
|
147 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TSetQoS, PDPSCprStates::TAwaitingQoSSet, PDPSCprStates::TNoTagOrError) |
|
148 NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TModifyActivePDPContext, PDPSCprStates::TAwaitingActivePDPContextModified, PDPSCprStates::TNoTagOrError) |
|
149 LAST_NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TRaiseParamsGrantedAndSendApplyResponse) |
|
150 LAST_NODEACTIVITY_ENTRY(KErrorTag, PDPSCprStates::TRaiseParamsRejectedL) |
|
151 NODEACTIVITY_END() |
|
152 } |
|
153 |
|
154 namespace PDPSCprParamsChanged |
|
155 { |
|
156 DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, paramsChanged, TPDPFSMMessages::TPDPFSMMessage) |
|
157 FIRST_NODEACTIVITY_ENTRY(PDPSCprStates::TAwaitingParamsChanged, PDPSCprStates::TNoTagOrError) |
|
158 LAST_NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TRaiseParamsChanged) |
|
159 LAST_NODEACTIVITY_ENTRY(KErrorTag, PDPSCprStates::TRaiseParamsRejectedL) |
|
160 NODEACTIVITY_END() |
|
161 } |
|
162 |
|
163 namespace PDPSCprContextBlockedUnblockedActivity |
|
164 { |
|
165 DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, ctxBlockedUnblocked, TPDPFSMMessages::TPDPFSMMessage) |
|
166 FIRST_NODEACTIVITY_ENTRY(PDPSCprStates::TAwaitingContextBlockedOrUnblocked, MeshMachine::TNoTag) |
|
167 THROUGH_NODEACTIVITY_ENTRY(KNoTag, PDPSCprStates::TForwardContextBlockedOrUnblockedToDC, PDPSCprStates::TBlockedOrUnblocked) |
|
168 LAST_NODEACTIVITY_ENTRY(PDPSCprStates::KBlocked, PDPSCprStates::TSendDataTransferTemporarilyBlocked) |
|
169 /** |
|
170 This needs to send DataTransferUnblocked progress, but this needs to be discussed with people in finland |
|
171 when they return. In old world, KLinkLayerOpen was sent in this case, but KLinkLayerOpen has changed and is misused for |
|
172 this purpose. Should be a new, functionallity specific progress . |
|
173 */ |
|
174 LAST_NODEACTIVITY_ENTRY(PDPSCprStates::KUnblocked, PDPSCprStates::TSendDataTransferUnblocked) |
|
175 NODEACTIVITY_END() |
|
176 } |
|
177 |
|
178 namespace PDPSCprStateChangeActivity |
|
179 { |
|
180 DECLARE_DEFINE_NODEACTIVITY(ECFActivityForwardStateChange, forwardStateChange, TCFMessage::TStateChange) |
|
181 //Bin all the progresses received, PDP.SCPR will generate its own ones. |
|
182 NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, MeshMachine::TAwaitingMessageState<TCFMessage::TStateChange>, MeshMachine::TNoTag) |
|
183 NODEACTIVITY_END() |
|
184 } |
|
185 |
|
186 namespace PDPSCprAuthenticationActivity |
|
187 { |
|
188 DECLARE_DEFINE_NODEACTIVITY(ECFActivityAuthentication, PDPSCprAuthentication, TLinkMessage::TAuthenticate) |
|
189 NODEACTIVITY_ENTRY(KNoTag, AgentSCprStates::TSendAuthenticateComplete, AgentSCprStates::TAwaitingAuthenticate, MeshMachine::TNoTag) |
|
190 NODEACTIVITY_END() |
|
191 } |
|
192 |
|
193 namespace PDPSCprActivities |
|
194 { |
|
195 DEFINE_ACTIVITY_MAP(activityMap) |
|
196 ACTIVITY_MAP_ENTRY(PDPSCprProvisionActivity, provision) |
|
197 ACTIVITY_MAP_ENTRY(PDPSCprStartActivity, PDPScprStart) |
|
198 ACTIVITY_MAP_ENTRY(PDPSCprDataClientStartActivity, pdpDataClientStart) |
|
199 ACTIVITY_MAP_ENTRY(PDPSCprSetParameters, paramRequest) |
|
200 ACTIVITY_MAP_ENTRY(PDPSCprParamsChanged, paramsChanged) |
|
201 ACTIVITY_MAP_ENTRY(PDPSCprContextBlockedUnblockedActivity, ctxBlockedUnblocked) |
|
202 ACTIVITY_MAP_ENTRY(PDPSCprApply, pdpApplyReq) |
|
203 ACTIVITY_MAP_ENTRY(PDPSCprStopActivity, Stop) |
|
204 ACTIVITY_MAP_ENTRY(PDPSCprGoneDownActivity, goneDown) |
|
205 ACTIVITY_MAP_ENTRY(PDPSCprStateChangeActivity, forwardStateChange) |
|
206 ACTIVITY_MAP_ENTRY(PDPSCprAuthenticationActivity, PDPSCprAuthentication) |
|
207 ACTIVITY_MAP_END_BASE(SCprActivities, coreSCprActivities) |
|
208 } |
|
209 |
|
210 //-========================================================= |
|
211 // |
|
212 // CPDPSubConnectionProvider methods |
|
213 // |
|
214 //-========================================================= |
|
215 CPDPSubConnectionProvider* CPDPSubConnectionProvider::NewL(CPDPSubConnectionProviderFactory& aFactory) |
|
216 /** |
|
217 Construct a new PDP SubConnection Provider Object |
|
218 |
|
219 @params aFactory factory that create this object |
|
220 @param aConnProvider Connection Provider associated with this object |
|
221 */ |
|
222 { |
|
223 CPDPSubConnectionProvider* ptr = new (ELeave) CPDPSubConnectionProvider(aFactory); |
|
224 CleanupStack::PushL(ptr); |
|
225 ptr->ConstructL(); |
|
226 CleanupStack::Pop(); |
|
227 return ptr; |
|
228 } |
|
229 |
|
230 |
|
231 CPDPSubConnectionProvider::~CPDPSubConnectionProvider() |
|
232 { |
|
233 LOG_NODE_DESTROY(KPDPSCprSubTag, CPDPSubConnectionProvider) |
|
234 __FLOG_CLOSE; |
|
235 if (iPdpFsmInterface) |
|
236 { |
|
237 iPdpFsmInterface->Close(); |
|
238 } |
|
239 } |
|
240 |
|
241 |
|
242 CPDPSubConnectionProvider::CPDPSubConnectionProvider(ESock::CSubConnectionProviderFactoryBase& aFactory) |
|
243 :CCoreSubConnectionProvider(aFactory, PDPSCprActivities::activityMap::Self()), |
|
244 iPDPFsmContextId(EInvalidContextId), |
|
245 iPdpFsmInterface(NULL), |
|
246 iActivityAwaitingResponse(KActivityNull) |
|
247 { |
|
248 LOG_NODE_CREATE1(KPDPSCprSubTag, CPDPSubConnectionProvider, " [factory=%08x]", &aFactory) |
|
249 __FLOG_OPEN(KCFNodeTag, KPDPSCprSubTag); |
|
250 } |
|
251 |
|
252 |
|
253 CPDPSubConnectionProvider::CPDPSubConnectionProvider(ESock::CSubConnectionProviderFactoryBase& aFactory, |
|
254 const MeshMachine::TNodeActivityMap& aActivityMap) |
|
255 :CCoreSubConnectionProvider(aFactory, aActivityMap), |
|
256 iPDPFsmContextId(EInvalidContextId), |
|
257 iPdpFsmInterface(NULL), |
|
258 iActivityAwaitingResponse(KActivityNull), |
|
259 iParamsRelease(MPDPParamMapper::KParameterRelInvalid) |
|
260 { |
|
261 } |
|
262 |
|
263 void CPDPSubConnectionProvider::ConstructL() |
|
264 /** |
|
265 IP SubConnection Provider Second Phase Constructor |
|
266 */ |
|
267 { |
|
268 CCoreSubConnectionProvider::ConstructL(KPDPSCPRPreallocatedActivityBufferSize); |
|
269 } |
|
270 |
|
271 void CPDPSubConnectionProvider::Received(TNodeContextBase& aContext) |
|
272 { |
|
273 Messages::TNodeSignal::TMessageId noPeerIds[] = { |
|
274 TCFFactory::TPeerFoundOrCreated::Id(), |
|
275 TCFPeer::TJoinRequest::Id(), |
|
276 TCFMessage::TStateChange::Id(), |
|
277 Messages::TNodeSignal::TNullMessageId::Id() |
|
278 }; |
|
279 MeshMachine::AMMNodeBase::Received(noPeerIds, aContext); |
|
280 MeshMachine::AMMNodeBase::PostReceived(aContext); |
|
281 } |
|
282 |
|
283 void CPDPSubConnectionProvider::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage) |
|
284 { |
|
285 ESOCK_DEBUG_MESSAGE_INTERCEPT(aSender, aMessage, aRecipient); |
|
286 |
|
287 PDPSCprStates::TContext ctx(*this, aMessage, aSender, aRecipient); |
|
288 CPDPSubConnectionProvider::Received(ctx); |
|
289 User::LeaveIfError(ctx.iReturn); |
|
290 } |
|
291 |
|
292 void CPDPSubConnectionProvider::Event(TInt aEvent, TInt aParam) |
|
293 { |
|
294 TPDPFSMMessages::TPDPFSMMessage msg(aEvent, aParam); |
|
295 |
|
296 RClientInterface::OpenPostMessageClose(TNodeCtxId(iActivityAwaitingResponse, Id()), Id(), msg); |
|
297 iActivityAwaitingResponse = KActivityNull; |
|
298 } |
|
299 |
|
300 void CPDPSubConnectionProvider::LinkUp() |
|
301 { |
|
302 if (iLinkUps++ == 0) |
|
303 { |
|
304 iDefaultSCPR->LinkUp(); |
|
305 } |
|
306 } |
|
307 |
|
308 void CPDPSubConnectionProvider::LinkDown(TInt aCause) |
|
309 { |
|
310 if (--iLinkUps == 0) |
|
311 { |
|
312 iDefaultSCPR->LinkDown(aCause); |
|
313 } |
|
314 } |
|
315 |
|
316 CSubConQosR99ParamSet* CPDPSubConnectionProvider::GrantedQoS() |
|
317 { |
|
318 if(static_cast<CSubConnectionProviderBase*>(this)->GetParameterBundle().IsNull()) |
|
319 { |
|
320 return NULL; |
|
321 } |
|
322 RParameterFamily qosFamily=static_cast<CSubConnectionProviderBase*>(this)->GetParameterBundle().FindFamily(KSubConQoSFamily); |
|
323 if (qosFamily.IsNull()) |
|
324 { |
|
325 return NULL; |
|
326 } |
|
327 CSubConQosR99ParamSet* qosParams = static_cast<CSubConQosR99ParamSet*>(qosFamily.FindParameterSet( |
|
328 STypeId::CreateSTypeId(KSubCon3GPPExtParamsFactoryUid,KSubConQosR99ParamsType), RParameterFamily::EGranted)); |
|
329 if (!qosParams) |
|
330 { |
|
331 qosParams = static_cast<CSubConQosR99ParamSet*>(qosFamily.FindParameterSet( |
|
332 STypeId::CreateSTypeId(KSubCon3GPPExtParamsFactoryUid,KSubConQosR5ParamsType), RParameterFamily::EGranted)); |
|
333 } |
|
334 ASSERT(qosParams); |
|
335 return qosParams; |
|
336 } |
|
337 |
|
338 TInt CPDPSubConnectionProvider::QoSRank() |
|
339 /** |
|
340 This method calculates the qos ranking as specified in 3GPP TS 23.107 Annex C. |
|
341 Magic number usage is deemed justified based on the content of 3GPP TS 23.107. |
|
342 */ |
|
343 { |
|
344 CSubConQosR99ParamSet* qosParams = GrantedQoS(); |
|
345 ASSERT(qosParams); |
|
346 |
|
347 switch (qosParams->GetTrafficClass()) |
|
348 { |
|
349 case RPacketQoS::ETrafficClassConversational: |
|
350 return 2; |
|
351 case RPacketQoS::ETrafficClassStreaming: |
|
352 return 3; |
|
353 case RPacketQoS::ETrafficClassInteractive: |
|
354 { |
|
355 switch (qosParams->GetTrafficHandlingPriority()) |
|
356 { |
|
357 case RPacketQoS::ETrafficPriority1: |
|
358 return 1; |
|
359 case RPacketQoS::ETrafficPriority2: |
|
360 return 4; |
|
361 case RPacketQoS::ETrafficPriority3: |
|
362 return 5; |
|
363 default: |
|
364 ; |
|
365 } |
|
366 break; |
|
367 } |
|
368 case RPacketQoS::ETrafficClassBackground: |
|
369 return 6; |
|
370 default: |
|
371 ; |
|
372 } |
|
373 return 7; |
|
374 } |
|
375 |
|
376 |
|
377 MFactoryQuery::TMatchResult THighestQoSQuery::Match(TFactoryObjectInfo& aSubConnectionInfo) |
|
378 { |
|
379 CPDPSubConnectionProvider* sc = static_cast<CPDPSubConnectionProvider*>(aSubConnectionInfo.iInfo.iFactoryObject); |
|
380 ASSERT(sc && sc->ControlProvider()); |
|
381 if (sc->ControlProvider()->RecipientId() == iCtrlProvider && |
|
382 sc->iPDPFsmContextId != CPDPSubConnectionProvider::EInvalidContextId) |
|
383 { |
|
384 if (NULL == iHighestQoSProvider) |
|
385 { |
|
386 iHighestQoSProvider = sc; |
|
387 } |
|
388 else if (sc->QoSRank() > iHighestQoSProvider->QoSRank()) |
|
389 { |
|
390 iHighestQoSProvider = sc; |
|
391 } |
|
392 } |
|
393 return MFactoryQuery::EContinue; |
|
394 } |
|
395 |
|
396 TTFTInfo CPDPSubConnectionProvider::GetTftInfoL(CSubConIPAddressInfoParamSet* aParamSet) |
|
397 { |
|
398 /** TODO: What to do if there will be second request before ggsn responce back and first one will go to the granted list |
|
399 Assigning of id's is not correct in that case*/ |
|
400 |
|
401 TTFTInfo tft; |
|
402 RPacketContext::TPacketFilterV2 pf; |
|
403 |
|
404 TUint aParamSetNum = aParamSet->GetParamNum(); |
|
405 /** TODO: It should be only one in the queue, so remove the loop */ |
|
406 for (TUint i=0; i<aParamSetNum; ++i) |
|
407 { |
|
408 // TUint8* pfAddr(pf.iSrcAddr); |
|
409 |
|
410 CSubConIPAddressInfoParamSet::TSubConIPAddressInfo paramInfo(aParamSet->GetParamInfoL(i)); |
|
411 |
|
412 TInetAddr addr(paramInfo.iCliDstAddr); |
|
413 TUint32 ipv4Addr = addr.Address(); |
|
414 |
|
415 if(ipv4Addr) |
|
416 { |
|
417 addr.ConvertToV4Mapped(); |
|
418 } |
|
419 |
|
420 TIp6Addr ipv6 = addr.Ip6Address(); |
|
421 Mem::Copy(&pf.iSrcAddr,&ipv6,RPacketContext::KIPAddressSize); |
|
422 |
|
423 pf.iId = FindPacketFilterIdL(paramInfo); |
|
424 Mem::Fill(pf.iSrcAddrSubnetMask, sizeof(pf.iSrcAddrSubnetMask), 0xFF); |
|
425 pf.iSrcPortMin = pf.iSrcPortMax = paramInfo.iCliDstAddr.Port(); |
|
426 pf.iDestPortMin = pf.iDestPortMax = paramInfo.iCliSrcAddr.Port(); |
|
427 pf.iProtocolNumberOrNextHeader = paramInfo.iProtocolId; |
|
428 |
|
429 tft.AddPacketFilter(pf); |
|
430 } |
|
431 |
|
432 return tft; |
|
433 } |
|
434 |
|
435 TTFTOperationCode CPDPSubConnectionProvider::GetOperationCodeL(CSubConIPAddressInfoParamSet* aParamSet) |
|
436 { |
|
437 TTFTOperationCode result(0); |
|
438 TInt count = aParamSet->GetParamNum(); |
|
439 if(count > 0) |
|
440 { |
|
441 CSubConIPAddressInfoParamSet::TSubConIPAddressInfo paramInfo(aParamSet->GetParamInfoL(0)); |
|
442 switch(paramInfo.iState) |
|
443 { |
|
444 case CSubConIPAddressInfoParamSet::TSubConIPAddressInfo::EAdd: |
|
445 result = KAddFilters; |
|
446 break; |
|
447 case CSubConIPAddressInfoParamSet::TSubConIPAddressInfo::ERemove: |
|
448 result = KRemoveFilters; |
|
449 break; |
|
450 case CSubConIPAddressInfoParamSet::TSubConIPAddressInfo::ENone: |
|
451 if(aParamSet->GetOperationCode() == CSubConIPAddressInfoParamSet::EDelete) |
|
452 { |
|
453 result = KDeleteTFT; |
|
454 } |
|
455 break; |
|
456 default: ; |
|
457 /** TODO: What to do with an error */ |
|
458 } |
|
459 } |
|
460 else |
|
461 { |
|
462 /** TODO: Panic? */ |
|
463 } |
|
464 |
|
465 return result; |
|
466 } |
|
467 |
|
468 TUint CPDPSubConnectionProvider::FindPacketFilterIdL(CSubConIPAddressInfoParamSet::TSubConIPAddressInfo aParamInfo) |
|
469 { |
|
470 TUint id = 0; |
|
471 |
|
472 switch(aParamInfo.iState) |
|
473 { |
|
474 case CSubConIPAddressInfoParamSet::TSubConIPAddressInfo::EAdd : |
|
475 { |
|
476 TUint i = 0; |
|
477 TUint mask = 1; |
|
478 |
|
479 // search bitwise for an empty slot |
|
480 while(!(mask & iPacketFilterMaskId) && i<8) |
|
481 { |
|
482 mask <<= 1; |
|
483 ++i; |
|
484 } |
|
485 |
|
486 // if not found assigne the first slot |
|
487 id = (i>=8) ? 1 : i; |
|
488 } |
|
489 break; |
|
490 case CSubConIPAddressInfoParamSet::TSubConIPAddressInfo::ERemove : |
|
491 id = FindIdOfMatchingParamSetL(aParamInfo); |
|
492 break; |
|
493 case CSubConIPAddressInfoParamSet::TSubConIPAddressInfo::ENone : |
|
494 break; |
|
495 default: ; |
|
496 /** TODO: What to do with an error */ |
|
497 } |
|
498 |
|
499 // increase by one since id is starting from 1 |
|
500 return id; |
|
501 } |
|
502 |
|
503 TUint CPDPSubConnectionProvider::FindIdOfMatchingParamSetL(CSubConIPAddressInfoParamSet::TSubConIPAddressInfo aParamInfo) |
|
504 { |
|
505 // check the list of the granted params for an index |
|
506 if(GetParameterBundle().IsNull()) |
|
507 { |
|
508 return 0; |
|
509 } |
|
510 RParameterFamily ipAddressInfoFamily=GetParameterBundle().FindFamily(KSubConIPAddressInfoFamily); |
|
511 if( ipAddressInfoFamily.IsNull() ) |
|
512 { |
|
513 return 0; |
|
514 } |
|
515 |
|
516 CSubConIPAddressInfoParamSet* ipAddressInfoSet = |
|
517 static_cast<CSubConIPAddressInfoParamSet*>( |
|
518 ipAddressInfoFamily.FindParameterSet( |
|
519 STypeId::CreateSTypeId(CSubConIPAddressInfoParamSet::EUid,CSubConIPAddressInfoParamSet::ETypeId), |
|
520 RParameterFamily::EGranted)); |
|
521 if( ipAddressInfoSet == NULL ) |
|
522 { |
|
523 return 0; |
|
524 } |
|
525 TUint count = ipAddressInfoSet->GetParamNum(); |
|
526 |
|
527 TBool found(EFalse); |
|
528 TUint i=0; |
|
529 |
|
530 for(i=0; i<count && !found; ++i) |
|
531 { |
|
532 CSubConIPAddressInfoParamSet::TSubConIPAddressInfo paramInfo(ipAddressInfoSet->GetParamInfoL(i)); |
|
533 |
|
534 found = paramInfo.Compare(aParamInfo); |
|
535 } |
|
536 // use the index against corresponding array of id's |
|
537 return found ? iPacketFilterId[i] : 0; |
|
538 } |
|
539 |
|
540 void CPDPSubConnectionProvider::NewPacketFilterAddedL(CSubConIPAddressInfoParamSet::TSubConIPAddressInfo aParamInfo, TUint aId) |
|
541 { |
|
542 RParameterFamily ipAddressInfoFamily = GetParameterBundle().FindFamily(KSubConIPAddressInfoFamily); |
|
543 if ( ! ipAddressInfoFamily.IsNull()) |
|
544 { |
|
545 CSubConIPAddressInfoParamSet* grantedIPAddressInfo = CSubConIPAddressInfoParamSet::NewL(ipAddressInfoFamily, RParameterFamily::EGranted); |
|
546 |
|
547 if(grantedIPAddressInfo) |
|
548 { |
|
549 grantedIPAddressInfo->AddParamInfo(aParamInfo); |
|
550 |
|
551 iPacketFilterId.Append(aId); |
|
552 iPacketFilterMaskId |= 1 << aId; |
|
553 } |
|
554 else |
|
555 { |
|
556 User::Leave(KErrNotFound); |
|
557 } |
|
558 } |
|
559 } |
|
560 |
|
561 void CPDPSubConnectionProvider::PacketFilterRemovedL(TUint aId) |
|
562 { |
|
563 RParameterFamily ipAddressInfoFamily = GetParameterBundle().FindFamily(KSubConIPAddressInfoFamily); |
|
564 |
|
565 if ( ! ipAddressInfoFamily.IsNull()) |
|
566 { |
|
567 // find an index from given id value |
|
568 //TUint count = iPacketFilterId.Count(); |
|
569 TInt index = iPacketFilterId.Find(aId); |
|
570 |
|
571 //for (index = 0; (index < count) && (iPacketFilterId[index] != aId); ++index){} |
|
572 |
|
573 if(index >= 0) |
|
574 { |
|
575 CSubConIPAddressInfoParamSet* grantedIPAddressInfo = CSubConIPAddressInfoParamSet::NewL(ipAddressInfoFamily, RParameterFamily::EGranted); |
|
576 |
|
577 if(grantedIPAddressInfo) |
|
578 { |
|
579 grantedIPAddressInfo->RemoveParamInfo(index); |
|
580 |
|
581 iPacketFilterId.Remove(index); |
|
582 iPacketFilterMaskId &= !(1 << aId); |
|
583 } |
|
584 else |
|
585 { |
|
586 User::Leave(KErrNotFound); |
|
587 } |
|
588 } |
|
589 else |
|
590 { |
|
591 User::Leave(KErrNotFound); |
|
592 } |
|
593 } |
|
594 } |