|
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 // |
|
15 |
|
16 #include "UmtsNifControlIf.h" |
|
17 |
|
18 GLDEF_C TInt E32Dll() |
|
19 { |
|
20 return(KErrNone); |
|
21 } |
|
22 |
|
23 // |
|
24 // Fills the strcuture with invalid default values at creation |
|
25 // |
|
26 //lint -e{1927} would want to use inilializer list |
|
27 EXPORT_C TContextParameters::TContextParameters() |
|
28 { |
|
29 iContextType = EContextTypeUnknown; // Default value to indicate invalid |
|
30 iContextInfo.iContextId = (TInt8)-1;// Default value to indicate invalid |
|
31 iContextInfo.iStatus = RPacketContext::EStatusUnknown; |
|
32 iContextConfig.Reset(); |
|
33 iTFTOperationCode = 0; // Default value to indicate invalid |
|
34 iReasonCode = KErrGeneral; |
|
35 } |
|
36 |
|
37 |
|
38 // Class to handle one Traffic Flow Template |
|
39 // Includes 1 - 8 Filters |
|
40 //lint -e{1927} would want to use inilializer list |
|
41 EXPORT_C TTFTInfo::TTFTInfo() |
|
42 { |
|
43 iFilterCount = 0; |
|
44 iLastReturnedFilter = 0; |
|
45 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
46 iIMCNSubsystemflag = 0; |
|
47 #endif |
|
48 |
|
49 for(TUint counter = 0; counter < KMaxNumberOfPacketFilters; counter++) |
|
50 { |
|
51 iFilterSlots[counter] = EFalse; // All free |
|
52 } |
|
53 iSblpParams = NULL; |
|
54 } |
|
55 |
|
56 EXPORT_C TInt TTFTInfo::Set(const TTFTInfo& aInfo) |
|
57 { |
|
58 TUint counter; |
|
59 iFilterCount = aInfo.iFilterCount; |
|
60 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
61 iIMCNSubsystemflag = aInfo.iIMCNSubsystemflag; |
|
62 #endif |
|
63 |
|
64 // Loop© the new set of filters |
|
65 for(counter = 0; counter < KMaxNumberOfPacketFilters; counter++) |
|
66 { |
|
67 iFilterSlots[counter] = aInfo.iFilterSlots[counter]; |
|
68 iPacketFilters[counter] = aInfo.iPacketFilters[counter]; |
|
69 } |
|
70 |
|
71 // Added for Sblp Implementation. Set the SBlP Parameters also |
|
72 if ( NULL == iSblpParams ) |
|
73 { |
|
74 TRAPD(err, iSblpParams = RPacketContext::CTFTMediaAuthorizationV3::NewL()); |
|
75 if(err != KErrNone) |
|
76 { |
|
77 return err; |
|
78 } |
|
79 } |
|
80 // Get The Params |
|
81 aInfo.GetSblpToken(*iSblpParams); |
|
82 |
|
83 return KErrNone; |
|
84 } |
|
85 |
|
86 |
|
87 EXPORT_C TTFTInfo::~TTFTInfo() |
|
88 { |
|
89 // Additional Checking to prevent any accidental memory Leaks |
|
90 delete iSblpParams; |
|
91 } |
|
92 |
|
93 // |
|
94 // Adds a packet filter to the TFT. If a filter already exists with given id, it will |
|
95 // be replaced |
|
96 // |
|
97 EXPORT_C TInt TTFTInfo::AddPacketFilter(RPacketContext::TPacketFilterV2 aFilter) |
|
98 { |
|
99 TUint8 counter; |
|
100 |
|
101 // Search for existing with same ID to replace |
|
102 for(counter = 0; counter < KMaxNumberOfPacketFilters; counter++) |
|
103 { |
|
104 if( iFilterSlots[counter] && |
|
105 iPacketFilters[counter].iId == aFilter.iId) |
|
106 { |
|
107 iPacketFilters[counter] = aFilter; // Replace existing |
|
108 return KErrNone; |
|
109 } |
|
110 } |
|
111 |
|
112 if(iFilterCount == KMaxNumberOfPacketFilters) // Already full |
|
113 { |
|
114 return KErrGeneral; |
|
115 } |
|
116 |
|
117 for(counter = 0; counter < KMaxNumberOfPacketFilters; counter++) |
|
118 if (iFilterSlots[counter] == EFalse) |
|
119 { |
|
120 iFilterSlots[counter] = ETrue; // Reserve filter slot |
|
121 iPacketFilters[counter] = aFilter; |
|
122 iFilterCount++; |
|
123 iLastReturnedFilter = 0; // Resets the iterator |
|
124 return KErrNone; |
|
125 } |
|
126 |
|
127 __ASSERT_DEBUG(counter < KMaxNumberOfPacketFilters, User::Panic(_L("No space for filter"), -1)); |
|
128 |
|
129 return KErrGeneral; |
|
130 } |
|
131 // |
|
132 // Fetch a filter with given id |
|
133 // |
|
134 EXPORT_C TInt TTFTInfo::GetPacketFilter(RPacketContext::TPacketFilterV2& aFilter) |
|
135 { |
|
136 TUint8 counter; |
|
137 for(counter = 0; counter < KMaxNumberOfPacketFilters; counter++) |
|
138 { |
|
139 if( iFilterSlots[counter] && |
|
140 iPacketFilters[counter].iId == aFilter.iId) |
|
141 { |
|
142 aFilter = iPacketFilters[counter]; |
|
143 break; |
|
144 } |
|
145 |
|
146 } |
|
147 |
|
148 if(counter >= KMaxNumberOfPacketFilters) |
|
149 return KErrNotFound; |
|
150 else |
|
151 return KErrNone; |
|
152 } |
|
153 |
|
154 // |
|
155 // Remove a filter with given id |
|
156 // |
|
157 EXPORT_C TInt TTFTInfo::RemovePacketFilter(RPacketContext::TPacketFilterV2 aFilter) |
|
158 { |
|
159 TUint8 counter; |
|
160 for(counter = 0; counter < KMaxNumberOfPacketFilters; counter++) |
|
161 { |
|
162 if( iFilterSlots[counter] && |
|
163 iPacketFilters[counter].iId == aFilter.iId) |
|
164 { |
|
165 iFilterSlots[counter] = EFalse; |
|
166 break; |
|
167 } |
|
168 } |
|
169 |
|
170 if(counter >= KMaxNumberOfPacketFilters) |
|
171 return KErrNotFound; |
|
172 else |
|
173 { |
|
174 iFilterCount--; |
|
175 iLastReturnedFilter = 0; // Resets the iterator |
|
176 |
|
177 return KErrNone; |
|
178 } |
|
179 |
|
180 } |
|
181 // |
|
182 // Iterate the next filter in TFT |
|
183 // |
|
184 EXPORT_C TInt TTFTInfo::NextPacketFilter(RPacketContext::TPacketFilterV2& aFilter) |
|
185 { |
|
186 if(iLastReturnedFilter >= KMaxNumberOfPacketFilters) // Iterator finished |
|
187 return KErrNotFound; |
|
188 |
|
189 TUint8 counter; |
|
190 for(counter = iLastReturnedFilter; counter < KMaxNumberOfPacketFilters; counter++) |
|
191 { |
|
192 if(iFilterSlots[counter]) |
|
193 { |
|
194 iLastReturnedFilter = counter; |
|
195 aFilter = iPacketFilters[counter]; |
|
196 iLastReturnedFilter++; |
|
197 break; |
|
198 } |
|
199 } |
|
200 if(counter == KMaxNumberOfPacketFilters) |
|
201 return KErrNotFound; |
|
202 else |
|
203 return KErrNone; |
|
204 } |
|
205 |
|
206 // |
|
207 // Reset the iterator |
|
208 // |
|
209 EXPORT_C void TTFTInfo::SetToFirst() |
|
210 { |
|
211 iLastReturnedFilter = 0; |
|
212 } |
|
213 |
|
214 // |
|
215 // Reset the iterator |
|
216 // |
|
217 EXPORT_C TUint8 TTFTInfo::FilterCount() |
|
218 { |
|
219 return iFilterCount; |
|
220 } |
|
221 |
|
222 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
223 EXPORT_C TInt TTFTInfo::SetIMCNSubsystemflag(TBool aIMCNSubsystemflag) |
|
224 { |
|
225 iIMCNSubsystemflag = aIMCNSubsystemflag; |
|
226 return KErrNone; |
|
227 } |
|
228 |
|
229 EXPORT_C TInt TTFTInfo::GetIMCNSubsystemflag(TBool &aIMCNSubsystemflag) const |
|
230 { |
|
231 aIMCNSubsystemflag = iIMCNSubsystemflag; |
|
232 return KErrNone; |
|
233 } |
|
234 #endif |
|
235 |
|
236 |
|
237 EXPORT_C TTFTInfo& TTFTInfo::operator=(const TTFTInfo& aTFTInfo) |
|
238 { |
|
239 // Assigning to self is NOP. |
|
240 if (this == &aTFTInfo) |
|
241 return *this; |
|
242 |
|
243 iFilterCount = aTFTInfo.iFilterCount; |
|
244 iLastReturnedFilter = aTFTInfo.iLastReturnedFilter; |
|
245 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
246 iIMCNSubsystemflag = aTFTInfo.iIMCNSubsystemflag; |
|
247 #endif |
|
248 |
|
249 // not using something like Mem::Copy since RPacketContext::TPacketFilterV2 might change in the future |
|
250 for (TUint i = 0; i < KMaxNumberOfPacketFilters; ++i) |
|
251 { |
|
252 iPacketFilters[i] = aTFTInfo.iPacketFilters[i]; |
|
253 iFilterSlots[i] = aTFTInfo.iFilterSlots[i]; |
|
254 } |
|
255 |
|
256 if (aTFTInfo.iSblpParams) |
|
257 { |
|
258 AddSblpToken(aTFTInfo.iSblpParams->iAuthorizationToken,aTFTInfo.iSblpParams->iFlowIds); |
|
259 } |
|
260 |
|
261 return *this; |
|
262 } |
|
263 |
|
264 //coverity[pass_by_value] |
|
265 EXPORT_C TInt TTFTInfo::AddSblpToken(RPacketContext::TAuthorizationToken aAuthorizationToken, |
|
266 RArray<RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier> aFlowIds) |
|
267 { |
|
268 // Check whether memory is allocated to the Member or not |
|
269 if ( NULL == iSblpParams ) |
|
270 { |
|
271 TRAPD(err, iSblpParams = RPacketContext::CTFTMediaAuthorizationV3::NewL()); |
|
272 if(err != KErrNone) |
|
273 { |
|
274 return err; |
|
275 } |
|
276 } |
|
277 |
|
278 iSblpParams->iAuthorizationToken.Copy(aAuthorizationToken); |
|
279 |
|
280 iSblpParams->iFlowIds.Reset(); |
|
281 TInt i; |
|
282 for(i=0; i<aFlowIds.Count();i++) |
|
283 { |
|
284 iSblpParams->iFlowIds.Append(aFlowIds[i]); |
|
285 } |
|
286 |
|
287 return KErrNone; |
|
288 } |
|
289 |
|
290 // Getter Function |
|
291 EXPORT_C TInt TTFTInfo::GetSblpToken ( RPacketContext::CTFTMediaAuthorizationV3 & aSblpParams ) const |
|
292 { |
|
293 // Check whether memory is allocated to the Member or not |
|
294 if ( NULL == iSblpParams ) |
|
295 { |
|
296 return KErrNotFound; |
|
297 } |
|
298 |
|
299 // Copy using the Internalize mechanism of CTFTMediaAuthorisationV3 |
|
300 HBufC8 * externalizeData = NULL; |
|
301 // First Externalize |
|
302 TRAPD(err,iSblpParams->ExternalizeL(externalizeData)); |
|
303 if(err != KErrNone) |
|
304 { |
|
305 return err; |
|
306 } |
|
307 TPtr8 internalizePtr = externalizeData->Des(); |
|
308 TRAPD(err1,aSblpParams.InternalizeL(internalizePtr)); |
|
309 if(err1 != KErrNone) |
|
310 { |
|
311 return err1; |
|
312 } |
|
313 // Cleanup Memory |
|
314 delete externalizeData; |
|
315 |
|
316 return KErrNone; |
|
317 } |
|
318 |
|
319 // removal Function |
|
320 EXPORT_C TInt TTFTInfo::RemovSblpToken () |
|
321 { |
|
322 // delete Sblp Params |
|
323 if (iSblpParams != NULL) |
|
324 { |
|
325 delete iSblpParams; |
|
326 iSblpParams = NULL; |
|
327 } |
|
328 return KErrNone; |
|
329 } |
|
330 |
|
331 |
|
332 EXPORT_C TContextConfig::TContextConfig() |
|
333 { |
|
334 // Current default values for data come from Etel class constructors. |
|
335 // If they need other default values, they should be initialized here. |
|
336 // RPacketContext::TContextConfigGPRS |
|
337 // RPacketQoS::TQoSR99_R4Requested |
|
338 // RPacketQoS::TQoSR99_R4Negotiated |
|
339 // RPacketQos::TQoSR5Requested |
|
340 // RPacketQos::TQoSR5Negotiated |
|
341 } |
|
342 |
|
343 EXPORT_C TContextConfig::~TContextConfig() |
|
344 { |
|
345 } |
|
346 |
|
347 EXPORT_C void TContextConfig::Reset() |
|
348 { |
|
349 TContextConfig temp; |
|
350 Set(temp); |
|
351 } |
|
352 |
|
353 EXPORT_C TInt TContextConfig::Set(const TContextConfig& aConfig) |
|
354 { |
|
355 aConfig.GetUMTSQoSNeg(iUMTSQoS); |
|
356 aConfig.GetUMTSQoSReq(iUMTSQoSReq); |
|
357 aConfig.GetTFTInfo(iTFTInfo); |
|
358 |
|
359 iContextConfig = aConfig.iContextConfig; |
|
360 iContextConfig.iPdpType = aConfig.iContextConfig.iPdpType; |
|
361 iContextConfig.iAccessPointName = aConfig.iContextConfig.iAccessPointName; |
|
362 iContextConfig.iPdpAddress = aConfig.iContextConfig.iPdpAddress; |
|
363 iContextConfig.iPdpCompression = aConfig.iContextConfig.iPdpCompression; |
|
364 |
|
365 return KErrNone; |
|
366 } |
|
367 |
|
368 EXPORT_C TInt TContextConfig::SetPdpType(RPacketContext::TProtocolType aPdpType) |
|
369 { |
|
370 iContextConfig.iPdpType = aPdpType; |
|
371 return KErrNone; |
|
372 } |
|
373 |
|
374 EXPORT_C TInt TContextConfig::SetAccessPointName(const RPacketContext::TGSNAddress& aAccessPointName) |
|
375 { |
|
376 iContextConfig.iAccessPointName = aAccessPointName; |
|
377 return KErrNone; |
|
378 } |
|
379 |
|
380 EXPORT_C TInt TContextConfig::SetPdpAddress(const RPacketContext::TProtocolAddress& aPdpAddress) |
|
381 { |
|
382 iContextConfig.iPdpAddress = aPdpAddress; |
|
383 return KErrNone; |
|
384 } |
|
385 |
|
386 EXPORT_C TInt TContextConfig::SetPdpCompression(TUint aPdpCompression) |
|
387 { |
|
388 iContextConfig.iPdpCompression = aPdpCompression; |
|
389 return KErrNone; |
|
390 } |
|
391 |
|
392 EXPORT_C TInt TContextConfig::SetTFTInfo(const TTFTInfo& aTFTInfo) |
|
393 { |
|
394 iTFTInfo.Set(aTFTInfo); |
|
395 return KErrNone; |
|
396 } |
|
397 |
|
398 EXPORT_C TInt TContextConfig::GetPdpType(RPacketContext::TProtocolType& aPdpType) const |
|
399 { |
|
400 aPdpType = iContextConfig.iPdpType; |
|
401 return KErrNone; |
|
402 } |
|
403 |
|
404 EXPORT_C TInt TContextConfig::GetAccessPointName(RPacketContext::TGSNAddress& aAccessPointName) const |
|
405 { |
|
406 aAccessPointName = iContextConfig.iAccessPointName; |
|
407 return KErrNone; |
|
408 } |
|
409 |
|
410 EXPORT_C TInt TContextConfig::GetPdpAddress(RPacketContext::TProtocolAddress& aPdpAddress) const |
|
411 { |
|
412 aPdpAddress = iContextConfig.iPdpAddress; |
|
413 return KErrNone; |
|
414 } |
|
415 |
|
416 EXPORT_C TInt TContextConfig::GetPdpCompression(TUint& aPdpCompression) const |
|
417 { |
|
418 aPdpCompression = iContextConfig.iPdpCompression; |
|
419 return KErrNone; |
|
420 } |
|
421 |
|
422 EXPORT_C TInt TContextConfig::GetTFTInfo(TTFTInfo& aTFTInfo) const |
|
423 { |
|
424 aTFTInfo.Set(iTFTInfo); |
|
425 return KErrNone; |
|
426 } |
|
427 |
|
428 EXPORT_C TInt TContextConfig::SetUMTSQoSReq(const RPacketQoS::TQoSR99_R4Requested& aUMTSQoSRequest) |
|
429 { |
|
430 iUMTSQoSReq.iReqTrafficClass = aUMTSQoSRequest.iReqTrafficClass; |
|
431 iUMTSQoSReq.iMinTrafficClass = aUMTSQoSRequest.iMinTrafficClass; |
|
432 iUMTSQoSReq.iReqDeliveryOrderReqd = aUMTSQoSRequest.iReqDeliveryOrderReqd; |
|
433 iUMTSQoSReq.iMinDeliveryOrderReqd = aUMTSQoSRequest.iMinDeliveryOrderReqd; |
|
434 iUMTSQoSReq.iReqDeliverErroneousSDU = aUMTSQoSRequest.iReqDeliverErroneousSDU; |
|
435 iUMTSQoSReq.iMinDeliverErroneousSDU = aUMTSQoSRequest.iMinDeliverErroneousSDU; |
|
436 iUMTSQoSReq.iReqMaxSDUSize = aUMTSQoSRequest.iReqMaxSDUSize; |
|
437 iUMTSQoSReq.iMinAcceptableMaxSDUSize = aUMTSQoSRequest.iMinAcceptableMaxSDUSize; |
|
438 iUMTSQoSReq.iReqMaxRate = aUMTSQoSRequest.iReqMaxRate; |
|
439 iUMTSQoSReq.iMinAcceptableMaxRate = aUMTSQoSRequest.iMinAcceptableMaxRate; |
|
440 iUMTSQoSReq.iReqBER = aUMTSQoSRequest.iReqBER; |
|
441 iUMTSQoSReq.iMaxBER = aUMTSQoSRequest.iMaxBER; |
|
442 iUMTSQoSReq.iReqSDUErrorRatio = aUMTSQoSRequest.iReqSDUErrorRatio; |
|
443 iUMTSQoSReq.iMaxSDUErrorRatio = aUMTSQoSRequest.iMaxSDUErrorRatio; |
|
444 iUMTSQoSReq.iReqTrafficHandlingPriority = aUMTSQoSRequest.iReqTrafficHandlingPriority; |
|
445 iUMTSQoSReq.iMinTrafficHandlingPriority = aUMTSQoSRequest.iMinTrafficHandlingPriority; |
|
446 iUMTSQoSReq.iReqTransferDelay = aUMTSQoSRequest.iReqTransferDelay; |
|
447 iUMTSQoSReq.iMaxTransferDelay = aUMTSQoSRequest.iMaxTransferDelay; |
|
448 iUMTSQoSReq.iReqGuaranteedRate = aUMTSQoSRequest.iReqGuaranteedRate; |
|
449 iUMTSQoSReq.iMinGuaranteedRate = aUMTSQoSRequest.iMinGuaranteedRate; |
|
450 |
|
451 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
452 iUMTSQoSReq.iSignallingIndication = 0; |
|
453 iUMTSQoSReq.iSourceStatisticsDescriptor = RPacketQoS::ESourceStatisticsDescriptorUnknown; |
|
454 #endif |
|
455 |
|
456 return KErrNone; |
|
457 } |
|
458 |
|
459 EXPORT_C TInt TContextConfig::GetUMTSQoSReq(RPacketQoS::TQoSR99_R4Requested& aUMTSQoSRequest) const |
|
460 { |
|
461 aUMTSQoSRequest = iUMTSQoSReq; |
|
462 return KErrNone; |
|
463 } |
|
464 |
|
465 EXPORT_C TInt TContextConfig::SetUMTSQoSNeg(const RPacketQoS::TQoSR99_R4Negotiated& aUMTSQoS) |
|
466 { |
|
467 iUMTSQoS.iTrafficClass = aUMTSQoS.iTrafficClass; |
|
468 iUMTSQoS.iDeliveryOrderReqd = aUMTSQoS.iDeliveryOrderReqd; |
|
469 iUMTSQoS.iDeliverErroneousSDU = aUMTSQoS.iDeliverErroneousSDU; |
|
470 iUMTSQoS.iMaxSDUSize = aUMTSQoS.iMaxSDUSize; |
|
471 iUMTSQoS.iMaxRate = aUMTSQoS.iMaxRate; |
|
472 iUMTSQoS.iBER = aUMTSQoS.iBER; |
|
473 iUMTSQoS.iSDUErrorRatio = aUMTSQoS.iSDUErrorRatio; |
|
474 iUMTSQoS.iTrafficHandlingPriority = aUMTSQoS.iTrafficHandlingPriority; |
|
475 iUMTSQoS.iTransferDelay = aUMTSQoS.iTransferDelay; |
|
476 iUMTSQoS.iGuaranteedRate = aUMTSQoS.iGuaranteedRate; |
|
477 |
|
478 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
479 iUMTSQoS.iSignallingIndication = 0; |
|
480 iUMTSQoS.iSourceStatisticsDescriptor = RPacketQoS::ESourceStatisticsDescriptorUnknown; |
|
481 #endif |
|
482 |
|
483 return KErrNone; |
|
484 } |
|
485 |
|
486 EXPORT_C TInt TContextConfig::GetUMTSQoSNeg(RPacketQoS::TQoSR99_R4Negotiated& aUMTSQoS) const |
|
487 { |
|
488 aUMTSQoS = iUMTSQoS; |
|
489 return KErrNone; |
|
490 } |
|
491 |
|
492 EXPORT_C TInt TContextConfig::SetContextConfig(const RPacketContext::TContextConfigGPRS& aContextConfig) |
|
493 { |
|
494 iContextConfig = aContextConfig; |
|
495 return KErrNone; |
|
496 } |
|
497 |
|
498 EXPORT_C TInt TContextConfig::GetContextConfig(RPacketContext::TContextConfigGPRS& aContextConfig) const |
|
499 { |
|
500 aContextConfig = iContextConfig; |
|
501 return KErrNone; |
|
502 } |
|
503 |
|
504 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
505 EXPORT_C TInt TContextConfig::SetUMTSQoSNeg(const RPacketQoS::TQoSR5Negotiated& aR5QoSNeg) |
|
506 { |
|
507 iUMTSQoS = aR5QoSNeg; |
|
508 return KErrNone; |
|
509 } |
|
510 |
|
511 EXPORT_C TInt TContextConfig::GetUMTSQoSNeg(RPacketQoS::TQoSR5Negotiated& aR5QoSNeg) const |
|
512 { |
|
513 aR5QoSNeg = iUMTSQoS; |
|
514 return KErrNone; |
|
515 } |
|
516 |
|
517 EXPORT_C TInt TContextConfig::SetUMTSQoSReq(const RPacketQoS::TQoSR5Requested& aR5QoSReq) |
|
518 { |
|
519 iUMTSQoSReq = aR5QoSReq; |
|
520 return KErrNone; |
|
521 } |
|
522 |
|
523 EXPORT_C TInt TContextConfig::GetUMTSQoSReq(RPacketQoS::TQoSR5Requested& aR5QoSReq) const |
|
524 { |
|
525 aR5QoSReq = iUMTSQoSReq; |
|
526 return KErrNone; |
|
527 } |
|
528 #endif |
|
529 |