|
1 /* |
|
2 * Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Device Management NAT-FW Traversal Adapter |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <utf.h> |
|
21 #include <sysutil.h> |
|
22 #include <f32file.h> |
|
23 #include <shareddataclient.h> |
|
24 #include "nsmldmnatfwtraversaladapter.h" |
|
25 #include "nsmldmiapmatcher.h" |
|
26 #include "natfwdomainentry.h" |
|
27 #include "natfwiapentry.h" |
|
28 #include "natfwdefaults.h" // Default values. |
|
29 |
|
30 #ifdef VOIP_TRACE_ENABLED |
|
31 #include <voip_trace.h> |
|
32 #endif // VOIP_TRACE_ENABLED |
|
33 |
|
34 // Central Repository keys for NAT-FW Traversal settings |
|
35 #include "centralrepository.h" |
|
36 #include <unsafprotocolscrkeys.h> |
|
37 |
|
38 // Following lines are for enabling debug prints. |
|
39 #ifdef _DEBUG |
|
40 #define DBG_PRINT( p ) RDebug::Print( _L( p ) ) |
|
41 #define DBG_PRINT_2( p,i ) RDebug::Print ( _L( p ), i ) |
|
42 #else |
|
43 #define DBG_PRINT( p ) |
|
44 #define DBG_PRINT_2( p,i ) |
|
45 #endif // _DEBUG |
|
46 |
|
47 // LOCAL CONSTANTS |
|
48 |
|
49 const TInt KNSmlNATFWMaxUriLength = 256; |
|
50 const TInt KNSmlNATFWMaxResultLength = 256; |
|
51 const TInt KDefaultResultSize = 64; |
|
52 const TInt KOneSeg = 1; |
|
53 const TInt KTwoSegs = 2; |
|
54 const TInt KThreeSegs = 3; |
|
55 const TInt KFourSegs = 4; |
|
56 const TInt KFiveSegs = 5; |
|
57 const TInt KSixSegs = 6; |
|
58 const TInt KSevenSegs = 7; |
|
59 const TInt KLUIDMaxLength = 256; |
|
60 |
|
61 // Reference: OMA_Device_Management_DDF_for_NAT-FW_v1.0.doc |
|
62 _LIT8( KNSmlDMNATFWDDFVersion, "1.0" ); |
|
63 _LIT8( KNSmlDMNATFWNodeName, "NATFW" ); |
|
64 |
|
65 // Domain specific settings |
|
66 _LIT8( KNSmlDMDomainSpecificNodeName, "DomainSpecific" ); |
|
67 _LIT8( KNSmlDMDomain, "Domain" ); |
|
68 _LIT8( KNSmlDMSTUNSrvAddr, "STUNSrvAddr" ); |
|
69 _LIT8( KNSmlDMSTUNSrvPort, "STUNSrvPort" ); |
|
70 _LIT8( KNSmlDMDomainNATRefreshTCP, "NATRefreshTCP" ); |
|
71 _LIT8( KNSmlDMDomainNATRefreshUDP, "NATRefreshUDP" ); |
|
72 _LIT8( KNSmlDMDomainEnableCRLFRefresh, "EnableCRLFRefresh" ); |
|
73 |
|
74 // IAP specific settings |
|
75 _LIT8( KNSmlDMIAPSpecificNodeName, "IAPSpecific" ); |
|
76 _LIT8( KNSmlDMNATPrefConRef, "PrefConRef" ); |
|
77 _LIT8( KNSmlDMNATRefreshTCP, "NATRefreshTCP" ); |
|
78 _LIT8( KNSmlDMNATRefreshUDP, "NATRefreshUDP" ); |
|
79 _LIT8( KNSmlDMSTUNRetransmit, "STUNRetransmit" ); |
|
80 |
|
81 // Domain specific settings. |
|
82 _LIT8( KNSmlDMSTUNUsername, "STUNUsername" ); |
|
83 _LIT8( KNSmlDMSTUNPassword, "STUNPassword" ); |
|
84 _LIT8( KNSmlDMSTUNSharedSecret, "STUNSharedSecret" ); |
|
85 _LIT8( KNSmlDMPortPoolStart, "PortPoolStartPort" ); |
|
86 _LIT8( KNSmlDMPortPoolEnd, "PortPoolEndPort" ); |
|
87 _LIT8( KNSmlDMUsedNatProtocol, "UsedNATProtocol" ); |
|
88 // Domain / STUN specific settings. |
|
89 _LIT8( KNSmlDMAdditionalSTUNNodeName, "AdditionalSTUNServer" ); |
|
90 // Domain / ICE specific settings. |
|
91 _LIT8( KNSmlDMICESpecificNodeName, "ICESpecific" ); |
|
92 _LIT8( KNSmlDMNatUtilities, "NATUtilities" ); |
|
93 _LIT8( KNSmlDMHostPref, "HostPreference" ); |
|
94 _LIT8( KNSmlDMServerReflexPref, "ServerReflexivePreference" ); |
|
95 _LIT8( KNSmlDMRelayPref, "RelayPreference" ); |
|
96 _LIT8( KNSmlDMPeerReflexPref, "PeerReflexivePreference" ); |
|
97 _LIT8( KNSmlDMIPv4Pref, "IPv4Preference" ); |
|
98 _LIT8( KNSmlDMIPv6Pref, "IPv6Preference" ); |
|
99 _LIT8( KNSmlDMVpnPref, "VPNPreference" ); |
|
100 _LIT8( KNSmlDMUdpPref, "UDPPreference" ); |
|
101 _LIT8( KNSmlDMTcpPref, "TCPPreference" ); |
|
102 _LIT8( KNSmlDMTcpActivePref, "TCPActivePreference" ); |
|
103 _LIT8( KNSmlDMTcpPassivePref, "TCPPassivePreference" ); |
|
104 _LIT8( KNSmlDMTcpSimultPref, "TCPSimultaneousPreference" ); |
|
105 // Domain / TURN specific settings. |
|
106 _LIT8( KNSmlDMTURNSpecificNodeName, "TURNSpecific" ); |
|
107 _LIT8( KNSmlDMTURNServerNodeName, "TURNServer" ); |
|
108 _LIT8( KNSmlDMTURNSrvAddr, "TURNSrvAddr" ); |
|
109 _LIT8( KNSmlDMTURNSrvPort, "TURNSrvPort" ); |
|
110 _LIT8( KNSmlDMTURNUsername, "TURNUsername" ); |
|
111 _LIT8( KNSmlDMTURNPassword, "TURNPassword" ); |
|
112 |
|
113 // Explanations of settings |
|
114 _LIT8( KNSmlDMNATFWNodeNameExp, |
|
115 "node for NAT-FW Traversal settings" ); |
|
116 _LIT8( KNSmlDMDomainSpecificNodeNameExp, |
|
117 "Domain Specific settings node" ); |
|
118 _LIT8( KNSmlDMDomainSpecificDynamicNodeExp, |
|
119 "placeholder for all domain specific settings" ); |
|
120 _LIT8( KNSmlDMDomainExp, |
|
121 "Domain field" ); |
|
122 _LIT8( KNSmlDMSTUNSrvAddrExp, |
|
123 "STUN server address" ); |
|
124 _LIT8( KNSmlDMSTUNSrvPortExp, |
|
125 "STUN server port" ); |
|
126 _LIT8( KNSmlDMDomainNATRefreshTCPExp, |
|
127 "NAT refresh interval for TCP in domain settings" ); |
|
128 _LIT8( KNSmlDMDomainNATRefreshUDPExp, |
|
129 "NAT refresh interval for UDP in domain settings" ); |
|
130 _LIT8( KNSmlDMDomainEnableCRLFRefreshExp, |
|
131 "For enabling CRLF-based NAT binding refresh" ); |
|
132 _LIT8( KNSmlDMIAPSpecificNodeNameExp, |
|
133 "Access Point Specific settings node" ); |
|
134 _LIT8( KNSmlDMIAPSpecificDynamicNodeExp, |
|
135 "placeholder for all IAP specific settings" ); |
|
136 _LIT8( KNSmlDMNATPrefConRefExp, |
|
137 "Link to IAP" ); |
|
138 _LIT8( KNSmlDMNATRefreshTCPExp, |
|
139 "NAT refresh interval for TCP" ); |
|
140 _LIT8( KNSmlDMNATRefreshUDPExp, |
|
141 "NAT refresh interval for UDP" ); |
|
142 _LIT8( KNSmlDMSTUNRetransmitExp, |
|
143 "STUN request retransmit timer" ); |
|
144 |
|
145 // Domain |
|
146 _LIT8( KNSmlDMSTUNUsernameExp, |
|
147 "STUN server username" ); |
|
148 _LIT8( KNSmlDMSTUNPasswordExp, |
|
149 "STUN server password" ); |
|
150 _LIT8( KNSmlDMSTUNSharedSecretExp, |
|
151 "STUN shared secret mechanism used or not" ); |
|
152 _LIT8( KNSmlDMPortPoolStartExp, |
|
153 "Start port of port pool" ); |
|
154 _LIT8( KNSmlDMPortPoolEndExp, |
|
155 "End port of port pool" ); |
|
156 _LIT8( KNSmlDMUsedNatProtocolExp, |
|
157 "Used NAT protocol" ); |
|
158 // AdditionalSTUNServer |
|
159 _LIT8( KNSmlDMAdditionalSTUNNodeNameExp, |
|
160 "Additional STUN server settings" ); |
|
161 _LIT8( KNSmlDMAdditionalSTUNDynamicNodeExp, |
|
162 "placeholder for additional STUN server settings" ); |
|
163 // ICE |
|
164 _LIT8( KNSmlDMICESpecificNodeNameExp, |
|
165 "ICE specific settings node" ); |
|
166 _LIT8( KNSmlDMNatUtilitiesExp, |
|
167 "NAT utilities to be used by ICE" ); |
|
168 _LIT8( KNSmlDMHostPrefExp, |
|
169 "HostPreference" ); |
|
170 _LIT8( KNSmlDMServerReflexPrefExp, |
|
171 "ServerReflexivePreference" ); |
|
172 _LIT8( KNSmlDMRelayPrefExp, |
|
173 "RelayPreference" ); |
|
174 _LIT8( KNSmlDMPeerReflexPrefExp, |
|
175 "PeerReflexivePreference" ); |
|
176 _LIT8( KNSmlDMIPv4PrefExp, |
|
177 "IPv4Preference" ); |
|
178 _LIT8( KNSmlDMIPv6PrefExp, |
|
179 "IPv6Preference" ); |
|
180 _LIT8( KNSmlDMVpnPrefExp, |
|
181 "VPNPreference" ); |
|
182 _LIT8( KNSmlDMUdpPrefExp, |
|
183 "UDPPreference" ); |
|
184 _LIT8( KNSmlDMTcpPrefExp, |
|
185 "TCPPreference" ); |
|
186 _LIT8( KNSmlDMTcpActivePrefExp, |
|
187 "TCPActivePreference" ); |
|
188 _LIT8( KNSmlDMTcpPassivePrefExp, |
|
189 "TCPPassivePreference" ); |
|
190 _LIT8( KNSmlDMTcpSimultPrefExp, |
|
191 "TCPSimultaneousPreference" ); |
|
192 // TURN |
|
193 _LIT8( KNSmlDMTURNSpecificNodeNameExp, |
|
194 "TURN specific settings node" ); |
|
195 _LIT8( KNSmlDMTURNServerNodeNameExp, |
|
196 "TURN server settings node" ); |
|
197 _LIT8( KNSmlDMTURNServerDynamicNodeExp, |
|
198 "placeholder for TURN server settings" ); |
|
199 _LIT8( KNSmlDMTURNSrvAddrExp, |
|
200 "TURN server address" ); |
|
201 _LIT8( KNSmlDMTURNSrvPortExp, |
|
202 "TURN server port" ); |
|
203 _LIT8( KNSmlDMTURNUsernameExp, |
|
204 "TURN username" ); |
|
205 _LIT8( KNSmlDMTURNPasswordExp, |
|
206 "TURN password" ); |
|
207 |
|
208 // Other |
|
209 _LIT8( KNSmlDMNATFWValueTrue, "True" ); |
|
210 _LIT8( KNSmlDMNATFWValueFalse, "False" ); |
|
211 _LIT8( KNSmlDMNATFWValueNotSet, "NotSet" ); |
|
212 _LIT8( KNSmlDMNATFWTextPlain, "text/plain" ); |
|
213 _LIT8( KNSmlDMNATFWSeparator, "/" ); |
|
214 _LIT8( KNSmlDMNATFWUriDotSlash, "./" ); |
|
215 //MACROS |
|
216 const TUint8 KDMNATFWSeparator = '/'; |
|
217 |
|
218 // ======== LOCAL FUNCTIONS ======== |
|
219 |
|
220 // ======== MEMBER FUNCTIONS ======== |
|
221 |
|
222 // --------------------------------------------------------------------------- |
|
223 // CNSmlDmNATFWTraversalAdapter* CNSmlDmNATFWTraversalAdapter::NewL |
|
224 // |
|
225 // --------------------------------------------------------------------------- |
|
226 // |
|
227 CNSmlDmNATFWTraversalAdapter* CNSmlDmNATFWTraversalAdapter::NewL( |
|
228 MSmlDmCallback* aDmCallback ) |
|
229 { |
|
230 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::NewL(): begin"); |
|
231 CNSmlDmNATFWTraversalAdapter* self = NewLC( aDmCallback ); // CS:1 |
|
232 CleanupStack::Pop( self ); // CS:0 |
|
233 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::NewL(): end"); |
|
234 return self; |
|
235 } |
|
236 |
|
237 // --------------------------------------------------------------------------- |
|
238 // CNSmlDmNATFWTraversalAdapter* CNSmlDmNATFWTraversalAdapter::NewLC |
|
239 // |
|
240 // --------------------------------------------------------------------------- |
|
241 // |
|
242 CNSmlDmNATFWTraversalAdapter* CNSmlDmNATFWTraversalAdapter::NewLC( |
|
243 MSmlDmCallback* aDmCallback ) |
|
244 { |
|
245 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::NewLC(): begin"); |
|
246 CNSmlDmNATFWTraversalAdapter* self = |
|
247 new ( ELeave ) CNSmlDmNATFWTraversalAdapter( aDmCallback ); |
|
248 CleanupStack::PushL( self ); // CS:1 |
|
249 self->iDmCallback = aDmCallback; |
|
250 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::NewLC(): end"); |
|
251 return self; |
|
252 } |
|
253 |
|
254 // --------------------------------------------------------------------------- |
|
255 // CNSmlDmNATFWTraversalAdapter::~CNSmlDmNATFWTraversalAdapter |
|
256 // |
|
257 // --------------------------------------------------------------------------- |
|
258 // |
|
259 CNSmlDmNATFWTraversalAdapter::~CNSmlDmNATFWTraversalAdapter() |
|
260 { |
|
261 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::~CNSmlDmNATFWTraversalAdapter():\ |
|
262 begin"); |
|
263 if ( iNATFWDomainEntries ) |
|
264 { |
|
265 iNATFWDomainEntries->ResetAndDestroy(); |
|
266 delete iNATFWDomainEntries; |
|
267 } |
|
268 if ( iNATFWIAPEntries ) |
|
269 { |
|
270 iNATFWIAPEntries->ResetAndDestroy(); |
|
271 delete iNATFWIAPEntries; |
|
272 } |
|
273 iNATFWCommandBuffer.Close(); |
|
274 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::~CNSmlDmNATFWTraversalAdapter():\ |
|
275 end"); |
|
276 } |
|
277 |
|
278 // --------------------------------------------------------------------------- |
|
279 // CNSmlDmNATFWTraversalAdapter::CNSmlDmNATFWTraversalAdapter |
|
280 // |
|
281 // --------------------------------------------------------------------------- |
|
282 // |
|
283 CNSmlDmNATFWTraversalAdapter::CNSmlDmNATFWTraversalAdapter( |
|
284 TAny* aEcomArguments ) : CSmlDmAdapter( aEcomArguments ) |
|
285 { |
|
286 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::CNSmlDmNATFWTraversalAdapter( \ |
|
287 aEcomArguments ): begin"); |
|
288 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::CNSmlDmNATFWTraversalAdapter( \ |
|
289 aEcomArguments ): end"); |
|
290 } |
|
291 |
|
292 // --------------------------------------------------------------------------- |
|
293 // CNSmlDmNATFWTraversalAdapter::DDFVersionL |
|
294 // Inserts DDF version of the adapter to aDDFVersion |
|
295 // --------------------------------------------------------------------------- |
|
296 // |
|
297 void CNSmlDmNATFWTraversalAdapter::DDFVersionL( |
|
298 CBufBase& aDDFVersion ) |
|
299 { |
|
300 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DDFVersionL(TDes& aDDFVersion):\ |
|
301 begin"); |
|
302 aDDFVersion.InsertL( 0, KNSmlDMNATFWDDFVersion ); |
|
303 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DDFVersionL(TDes& aDDFVersion):\ |
|
304 end"); |
|
305 } |
|
306 |
|
307 // --------------------------------------------------------------------------- |
|
308 // CNSmlDmNATFWTraversalAdapter::DDFStructureL |
|
309 // Builds the DDF structure of adapter |
|
310 // --------------------------------------------------------------------------- |
|
311 // |
|
312 void CNSmlDmNATFWTraversalAdapter::DDFStructureL( MSmlDmDDFObject& aDDF ) |
|
313 { |
|
314 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DDFStructureL(): begin"); |
|
315 |
|
316 // Default access types. |
|
317 TSmlDmAccessTypes accessTypesGet; |
|
318 accessTypesGet.SetGet(); |
|
319 |
|
320 TSmlDmAccessTypes accessTypesGetAdd; |
|
321 accessTypesGetAdd.SetGet(); |
|
322 accessTypesGetAdd.SetAdd(); |
|
323 |
|
324 TSmlDmAccessTypes accessTypesGetReplaceAdd; |
|
325 accessTypesGetReplaceAdd.SetGet(); |
|
326 accessTypesGetReplaceAdd.SetReplace(); |
|
327 accessTypesGetReplaceAdd.SetAdd(); |
|
328 |
|
329 TSmlDmAccessTypes accessTypesAll; |
|
330 accessTypesAll.SetGet(); |
|
331 accessTypesAll.SetDelete(); |
|
332 accessTypesAll.SetAdd(); |
|
333 accessTypesAll.SetReplace(); |
|
334 |
|
335 TSmlDmAccessTypes accessTypesNoDelete; |
|
336 accessTypesNoDelete.SetGet(); |
|
337 accessTypesNoDelete.SetAdd(); |
|
338 accessTypesNoDelete.SetReplace(); |
|
339 |
|
340 // NATFWTraversal (./NATFW) |
|
341 MSmlDmDDFObject& natFwTraversal = aDDF.AddChildObjectL( |
|
342 KNSmlDMNATFWNodeName ); |
|
343 natFwTraversal.SetAccessTypesL( accessTypesGetAdd ); |
|
344 natFwTraversal.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
345 natFwTraversal.SetScopeL( MSmlDmDDFObject::EPermanent ); |
|
346 natFwTraversal.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
347 natFwTraversal.SetDescriptionL( KNSmlDMNATFWNodeNameExp ); |
|
348 |
|
349 // DomainSpecific (./NATFW/DomainSpecific) |
|
350 MSmlDmDDFObject& domainSpecific = natFwTraversal.AddChildObjectL( |
|
351 KNSmlDMDomainSpecificNodeName ); |
|
352 domainSpecific.SetAccessTypesL( accessTypesGetAdd ); |
|
353 domainSpecific.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
354 domainSpecific.SetScopeL( MSmlDmDDFObject::EPermanent ); |
|
355 domainSpecific.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
356 domainSpecific.SetDescriptionL( KNSmlDMDomainSpecificNodeNameExp ); |
|
357 |
|
358 // dynamic settings ID node ( ./NATFW/DomainSpecific/<x> ) |
|
359 MSmlDmDDFObject& dynamicDomainNode = |
|
360 domainSpecific.AddChildObjectGroupL(); |
|
361 dynamicDomainNode.SetAccessTypesL( accessTypesAll ); |
|
362 dynamicDomainNode.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore ); |
|
363 dynamicDomainNode.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
364 dynamicDomainNode.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
365 dynamicDomainNode.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
366 dynamicDomainNode.SetDescriptionL( KNSmlDMDomainSpecificDynamicNodeExp ); |
|
367 |
|
368 // DomainSpecific/<x>/Domain |
|
369 MSmlDmDDFObject& domain = dynamicDomainNode.AddChildObjectL( |
|
370 KNSmlDMDomain ); |
|
371 domain.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
372 domain.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
373 domain.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
374 domain.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
375 domain.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
376 domain.SetDescriptionL( KNSmlDMDomainExp ); |
|
377 |
|
378 // DomainSpecific/<x>/STUNSrvAddr |
|
379 MSmlDmDDFObject& stunSrvAddr = dynamicDomainNode.AddChildObjectL( |
|
380 KNSmlDMSTUNSrvAddr ); |
|
381 stunSrvAddr.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
382 stunSrvAddr.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
383 stunSrvAddr.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
384 stunSrvAddr.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
385 stunSrvAddr.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
386 stunSrvAddr.SetDescriptionL( KNSmlDMSTUNSrvAddrExp ); |
|
387 |
|
388 // DomainSpecific/<x>/STUNSrvPort |
|
389 MSmlDmDDFObject& stunSrvPort = dynamicDomainNode.AddChildObjectL( |
|
390 KNSmlDMSTUNSrvPort ); |
|
391 stunSrvPort.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
392 stunSrvPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
393 stunSrvPort.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
394 stunSrvPort.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
395 stunSrvPort.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
396 stunSrvPort.SetDescriptionL( KNSmlDMSTUNSrvPortExp ); |
|
397 |
|
398 // DomainSpecific/<x>/NATRefreshTCP |
|
399 MSmlDmDDFObject& domainRefreshTCP = dynamicDomainNode.AddChildObjectL( |
|
400 KNSmlDMDomainNATRefreshTCP ); |
|
401 domainRefreshTCP.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
402 domainRefreshTCP.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
403 domainRefreshTCP.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
404 domainRefreshTCP.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
405 domainRefreshTCP.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
406 domainRefreshTCP.SetDescriptionL( KNSmlDMDomainNATRefreshTCPExp ); |
|
407 |
|
408 // DomainSpecific/<x>/NATRefreshUDP |
|
409 MSmlDmDDFObject& domainRefreshUDP = dynamicDomainNode.AddChildObjectL( |
|
410 KNSmlDMDomainNATRefreshUDP ); |
|
411 domainRefreshUDP.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
412 domainRefreshUDP.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
413 domainRefreshUDP.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
414 domainRefreshUDP.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
415 domainRefreshUDP.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
416 domainRefreshUDP.SetDescriptionL( KNSmlDMDomainNATRefreshUDPExp ); |
|
417 |
|
418 // DomainSpecific/<x>/EnableCRLFRefresh |
|
419 MSmlDmDDFObject& enableCRLF = dynamicDomainNode.AddChildObjectL( |
|
420 KNSmlDMDomainEnableCRLFRefresh ); |
|
421 enableCRLF.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
422 enableCRLF.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
423 enableCRLF.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
424 enableCRLF.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
425 enableCRLF.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
426 enableCRLF.SetDescriptionL( KNSmlDMDomainEnableCRLFRefreshExp ); |
|
427 |
|
428 // DomainSpecific/<x>/STUNUsername |
|
429 MSmlDmDDFObject& stunUsername = dynamicDomainNode.AddChildObjectL( |
|
430 KNSmlDMSTUNUsername ); |
|
431 stunUsername.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
432 stunUsername.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
433 stunUsername.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
434 stunUsername.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
435 stunUsername.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
436 stunUsername.SetDescriptionL( KNSmlDMSTUNUsernameExp ); |
|
437 |
|
438 // DomainSpecific/<x>/STUNPassword |
|
439 MSmlDmDDFObject& stunPassword = dynamicDomainNode.AddChildObjectL( |
|
440 KNSmlDMSTUNPassword ); |
|
441 stunPassword.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
442 stunPassword.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
443 stunPassword.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
444 stunPassword.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
445 stunPassword.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
446 stunPassword.SetDescriptionL( KNSmlDMSTUNPasswordExp ); |
|
447 |
|
448 // DomainSpecific/<x>/AdditionalSTUNServer |
|
449 MSmlDmDDFObject& stunSrv = dynamicDomainNode.AddChildObjectL( |
|
450 KNSmlDMAdditionalSTUNNodeName ); |
|
451 stunSrv.SetAccessTypesL( accessTypesGetAdd ); |
|
452 stunSrv.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
453 stunSrv.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
454 stunSrv.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
455 stunSrv.SetDescriptionL( KNSmlDMAdditionalSTUNNodeNameExp ); |
|
456 |
|
457 // DomainSpecific/<x>/AdditionalSTUNServer/<x> |
|
458 MSmlDmDDFObject& dynStunSrv = stunSrv.AddChildObjectGroupL(); |
|
459 dynStunSrv.SetAccessTypesL( accessTypesAll ); |
|
460 dynStunSrv.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore ); |
|
461 dynStunSrv.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
462 dynStunSrv.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
463 dynStunSrv.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
464 dynStunSrv.SetDescriptionL( KNSmlDMAdditionalSTUNDynamicNodeExp ); |
|
465 |
|
466 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNSrvAddr |
|
467 MSmlDmDDFObject& addStunSrvAddr = dynStunSrv.AddChildObjectL( |
|
468 KNSmlDMSTUNSrvAddr ); |
|
469 addStunSrvAddr.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
470 addStunSrvAddr.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
471 addStunSrvAddr.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
472 addStunSrvAddr.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
473 addStunSrvAddr.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
474 addStunSrvAddr.SetDescriptionL( KNSmlDMSTUNSrvAddrExp ); |
|
475 |
|
476 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNSrvPort |
|
477 MSmlDmDDFObject& addStunSrvPort = dynStunSrv.AddChildObjectL( |
|
478 KNSmlDMSTUNSrvPort ); |
|
479 addStunSrvPort.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
480 addStunSrvPort.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
481 addStunSrvPort.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
482 addStunSrvPort.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
483 addStunSrvPort.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
484 addStunSrvPort.SetDescriptionL( KNSmlDMSTUNSrvPortExp ); |
|
485 |
|
486 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNUsername |
|
487 MSmlDmDDFObject& addStunUsername = dynStunSrv.AddChildObjectL( |
|
488 KNSmlDMSTUNUsername ); |
|
489 addStunUsername.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
490 addStunUsername.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
491 addStunUsername.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
492 addStunUsername.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
493 addStunUsername.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
494 addStunUsername.SetDescriptionL( KNSmlDMSTUNUsernameExp ); |
|
495 |
|
496 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNPassword |
|
497 MSmlDmDDFObject& addStunPassword = dynStunSrv.AddChildObjectL( |
|
498 KNSmlDMSTUNPassword ); |
|
499 addStunPassword.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
500 addStunPassword.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
501 addStunPassword.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
502 addStunPassword.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
503 addStunPassword.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
504 addStunPassword.SetDescriptionL( KNSmlDMSTUNPasswordExp ); |
|
505 |
|
506 // DomainSpecific/<x>/STUNSharedSecret |
|
507 MSmlDmDDFObject& stunSharedSecret = dynamicDomainNode.AddChildObjectL( |
|
508 KNSmlDMSTUNSharedSecret ); |
|
509 stunSharedSecret.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
510 stunSharedSecret.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
511 stunSharedSecret.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
512 stunSharedSecret.SetDFFormatL( MSmlDmDDFObject::EBool ); |
|
513 stunSharedSecret.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
514 stunSharedSecret.SetDescriptionL( KNSmlDMSTUNSharedSecretExp ); |
|
515 |
|
516 // DomainSpecific/<x>/PortPoolStartPort |
|
517 MSmlDmDDFObject& startPort = dynamicDomainNode.AddChildObjectL( |
|
518 KNSmlDMPortPoolStart ); |
|
519 startPort.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
520 startPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
521 startPort.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
522 startPort.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
523 startPort.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
524 startPort.SetDescriptionL( KNSmlDMPortPoolStartExp ); |
|
525 |
|
526 // DomainSpecific/<x>/PortPoolEndPort |
|
527 MSmlDmDDFObject& endPort = dynamicDomainNode.AddChildObjectL( |
|
528 KNSmlDMPortPoolEnd ); |
|
529 endPort.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
530 endPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
531 endPort.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
532 endPort.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
533 endPort.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
534 endPort.SetDescriptionL( KNSmlDMPortPoolEndExp ); |
|
535 |
|
536 // DomainSpecific/<x>/UsedNATProtocol |
|
537 MSmlDmDDFObject& natProtocol = dynamicDomainNode.AddChildObjectL( |
|
538 KNSmlDMUsedNatProtocol ); |
|
539 natProtocol.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
540 natProtocol.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
541 natProtocol.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
542 natProtocol.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
543 natProtocol.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
544 natProtocol.SetDescriptionL( KNSmlDMUsedNatProtocolExp ); |
|
545 |
|
546 // DomainSpecific/<x>/ICESpecific |
|
547 MSmlDmDDFObject& iceSpecific = dynamicDomainNode.AddChildObjectL( |
|
548 KNSmlDMICESpecificNodeName ); |
|
549 iceSpecific.SetAccessTypesL( accessTypesGetAdd ); |
|
550 iceSpecific.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
551 iceSpecific.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
552 iceSpecific.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
553 iceSpecific.SetDescriptionL( KNSmlDMICESpecificNodeNameExp ); |
|
554 |
|
555 // DomainSpecific/<x>/ICESpecific/NATUtilities |
|
556 MSmlDmDDFObject& natUtils = iceSpecific.AddChildObjectL( |
|
557 KNSmlDMNatUtilities ); |
|
558 natUtils.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
559 natUtils.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
560 natUtils.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
561 natUtils.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
562 natUtils.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
563 natUtils.SetDescriptionL( KNSmlDMNatUtilitiesExp ); |
|
564 |
|
565 // DomainSpecific/<x>/ICESpecific/HostPreference |
|
566 MSmlDmDDFObject& hostPref = iceSpecific.AddChildObjectL( |
|
567 KNSmlDMHostPref ); |
|
568 hostPref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
569 hostPref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
570 hostPref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
571 hostPref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
572 hostPref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
573 hostPref.SetDescriptionL( KNSmlDMHostPrefExp ); |
|
574 |
|
575 // DomainSpecific/<x>/ICESpecific/ServerReflexivePreference |
|
576 MSmlDmDDFObject& serverReflexPref = iceSpecific.AddChildObjectL( |
|
577 KNSmlDMServerReflexPref ); |
|
578 serverReflexPref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
579 serverReflexPref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
580 serverReflexPref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
581 serverReflexPref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
582 serverReflexPref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
583 serverReflexPref.SetDescriptionL( KNSmlDMServerReflexPrefExp ); |
|
584 |
|
585 // DomainSpecific/<x>/ICESpecific/RelayPreference |
|
586 MSmlDmDDFObject& relayPref = iceSpecific.AddChildObjectL( |
|
587 KNSmlDMRelayPref ); |
|
588 relayPref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
589 relayPref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
590 relayPref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
591 relayPref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
592 relayPref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
593 relayPref.SetDescriptionL( KNSmlDMRelayPrefExp ); |
|
594 |
|
595 // DomainSpecific/<x>/ICESpecific/PeerReflexivePreference |
|
596 MSmlDmDDFObject& peerReflexPref = iceSpecific.AddChildObjectL( |
|
597 KNSmlDMPeerReflexPref ); |
|
598 peerReflexPref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
599 peerReflexPref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
600 peerReflexPref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
601 peerReflexPref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
602 peerReflexPref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
603 peerReflexPref.SetDescriptionL( KNSmlDMPeerReflexPrefExp ); |
|
604 |
|
605 // DomainSpecific/<x>/ICESpecific/IPv4Preference |
|
606 MSmlDmDDFObject& ipv4Pref = iceSpecific.AddChildObjectL( |
|
607 KNSmlDMIPv4Pref ); |
|
608 ipv4Pref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
609 ipv4Pref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
610 ipv4Pref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
611 ipv4Pref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
612 ipv4Pref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
613 ipv4Pref.SetDescriptionL( KNSmlDMIPv4PrefExp ); |
|
614 |
|
615 // DomainSpecific/<x>/ICESpecific/IPv6Preference |
|
616 MSmlDmDDFObject& ipv6Pref = iceSpecific.AddChildObjectL( |
|
617 KNSmlDMIPv6Pref ); |
|
618 ipv6Pref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
619 ipv6Pref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
620 ipv6Pref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
621 ipv6Pref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
622 ipv6Pref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
623 ipv6Pref.SetDescriptionL( KNSmlDMIPv6PrefExp ); |
|
624 |
|
625 // DomainSpecific/<x>/ICESpecific/VPNPreference |
|
626 MSmlDmDDFObject& vpnPref = iceSpecific.AddChildObjectL( |
|
627 KNSmlDMVpnPref ); |
|
628 vpnPref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
629 vpnPref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
630 vpnPref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
631 vpnPref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
632 vpnPref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
633 vpnPref.SetDescriptionL( KNSmlDMVpnPrefExp ); |
|
634 |
|
635 // DomainSpecific/<x>/ICESpecific/UDPPreference |
|
636 MSmlDmDDFObject& updPref = iceSpecific.AddChildObjectL( |
|
637 KNSmlDMUdpPref ); |
|
638 updPref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
639 updPref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
640 updPref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
641 updPref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
642 updPref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
643 updPref.SetDescriptionL( KNSmlDMUdpPrefExp ); |
|
644 |
|
645 // DomainSpecific/<x>/ICESpecific/TCPPreference |
|
646 MSmlDmDDFObject& tcpPref = iceSpecific.AddChildObjectL( |
|
647 KNSmlDMTcpPref ); |
|
648 tcpPref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
649 tcpPref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
650 tcpPref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
651 tcpPref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
652 tcpPref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
653 tcpPref.SetDescriptionL( KNSmlDMTcpPrefExp ); |
|
654 |
|
655 // DomainSpecific/<x>/ICESpecific/TCPActivePreference |
|
656 MSmlDmDDFObject& tcpActivePref = iceSpecific.AddChildObjectL( |
|
657 KNSmlDMTcpActivePref ); |
|
658 tcpActivePref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
659 tcpActivePref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
660 tcpActivePref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
661 tcpActivePref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
662 tcpActivePref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
663 tcpActivePref.SetDescriptionL( KNSmlDMTcpActivePrefExp ); |
|
664 |
|
665 // DomainSpecific/<x>/ICESpecific/TCPPassivePreference |
|
666 MSmlDmDDFObject& tcpPassivePref = iceSpecific.AddChildObjectL( |
|
667 KNSmlDMTcpPassivePref ); |
|
668 tcpPassivePref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
669 tcpPassivePref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
670 tcpPassivePref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
671 tcpPassivePref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
672 tcpPassivePref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
673 tcpPassivePref.SetDescriptionL( KNSmlDMTcpPassivePrefExp ); |
|
674 |
|
675 // DomainSpecific/<x>/ICESpecific/TCPSimultaneousPreference |
|
676 MSmlDmDDFObject& tcpSimultPref = iceSpecific.AddChildObjectL( |
|
677 KNSmlDMTcpSimultPref ); |
|
678 tcpSimultPref.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
679 tcpSimultPref.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
680 tcpSimultPref.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
681 tcpSimultPref.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
682 tcpSimultPref.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
683 tcpSimultPref.SetDescriptionL( KNSmlDMTcpSimultPrefExp ); |
|
684 |
|
685 // DomainSpecific/<x>/TURNSpecific |
|
686 MSmlDmDDFObject& turnSpecific = dynamicDomainNode.AddChildObjectL( |
|
687 KNSmlDMTURNSpecificNodeName ); |
|
688 turnSpecific.SetAccessTypesL( accessTypesGetAdd ); |
|
689 turnSpecific.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
690 turnSpecific.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
691 turnSpecific.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
692 turnSpecific.SetDescriptionL( KNSmlDMTURNSpecificNodeNameExp ); |
|
693 |
|
694 // DomainSpecific/<x>/TURNSpecific/TURNServer |
|
695 MSmlDmDDFObject& turnServer = turnSpecific.AddChildObjectL( |
|
696 KNSmlDMTURNServerNodeName ); |
|
697 turnServer.SetAccessTypesL( accessTypesGetAdd ); |
|
698 turnServer.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
699 turnServer.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
700 turnServer.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
701 turnServer.SetDescriptionL( KNSmlDMTURNServerNodeNameExp ); |
|
702 |
|
703 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x> |
|
704 MSmlDmDDFObject& dynTurnServer = turnServer.AddChildObjectGroupL(); |
|
705 dynTurnServer.SetAccessTypesL( accessTypesAll ); |
|
706 dynTurnServer.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore ); |
|
707 dynTurnServer.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
708 dynTurnServer.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
709 dynTurnServer.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
710 dynTurnServer.SetDescriptionL( KNSmlDMTURNServerDynamicNodeExp ); |
|
711 |
|
712 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/TURNSrvAddr |
|
713 MSmlDmDDFObject& turnSrvAddr = dynTurnServer.AddChildObjectL( |
|
714 KNSmlDMTURNSrvAddr ); |
|
715 turnSrvAddr.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
716 turnSrvAddr.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
717 turnSrvAddr.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
718 turnSrvAddr.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
719 turnSrvAddr.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
720 turnSrvAddr.SetDescriptionL( KNSmlDMTURNSrvAddrExp ); |
|
721 |
|
722 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/TURNSrvPort |
|
723 MSmlDmDDFObject& turnSrvPort = dynTurnServer.AddChildObjectL( |
|
724 KNSmlDMTURNSrvPort ); |
|
725 turnSrvPort.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
726 turnSrvPort.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
727 turnSrvPort.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
728 turnSrvPort.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
729 turnSrvPort.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
730 turnSrvPort.SetDescriptionL( KNSmlDMTURNSrvPortExp ); |
|
731 |
|
732 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/TURNUsername |
|
733 MSmlDmDDFObject& turnUsername = dynTurnServer.AddChildObjectL( |
|
734 KNSmlDMTURNUsername ); |
|
735 turnUsername.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
736 turnUsername.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
737 turnUsername.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
738 turnUsername.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
739 turnUsername.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
740 turnUsername.SetDescriptionL( KNSmlDMTURNUsernameExp ); |
|
741 |
|
742 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/TURNPassword |
|
743 MSmlDmDDFObject& turnPassword = dynTurnServer.AddChildObjectL( |
|
744 KNSmlDMTURNPassword ); |
|
745 turnPassword.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
746 turnPassword.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
747 turnPassword.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
748 turnPassword.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
749 turnPassword.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
750 turnPassword.SetDescriptionL( KNSmlDMTURNPasswordExp ); |
|
751 |
|
752 // IAPSpecific ( ./NATFW/IAPSpecific ) |
|
753 MSmlDmDDFObject& iapSpecific = natFwTraversal.AddChildObjectL( |
|
754 KNSmlDMIAPSpecificNodeName ); |
|
755 iapSpecific.SetAccessTypesL( accessTypesGetAdd ); |
|
756 iapSpecific.SetOccurenceL( MSmlDmDDFObject::EOne ); |
|
757 iapSpecific.SetScopeL( MSmlDmDDFObject::EPermanent ); |
|
758 iapSpecific.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
759 iapSpecific.SetDescriptionL( KNSmlDMIAPSpecificNodeNameExp ); |
|
760 |
|
761 // dynamic IAP specific settings ID node ( ./NATFW/IAPSpecific/<x> ) |
|
762 MSmlDmDDFObject& dynIAPNode = iapSpecific.AddChildObjectGroupL(); |
|
763 dynIAPNode.SetAccessTypesL( accessTypesAll ); |
|
764 dynIAPNode.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore ); |
|
765 dynIAPNode.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
766 dynIAPNode.SetDFFormatL( MSmlDmDDFObject::ENode ); |
|
767 dynIAPNode.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
768 dynIAPNode.SetDescriptionL( KNSmlDMIAPSpecificDynamicNodeExp ); |
|
769 |
|
770 // IAPSpecific/<x>/PrefConRef |
|
771 MSmlDmDDFObject& prefConRef = dynIAPNode.AddChildObjectL( |
|
772 KNSmlDMNATPrefConRef ); |
|
773 prefConRef.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
774 prefConRef.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
775 prefConRef.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
776 prefConRef.SetDFFormatL( MSmlDmDDFObject::EChr ); |
|
777 prefConRef.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
778 prefConRef.SetDescriptionL( KNSmlDMNATPrefConRefExp ); |
|
779 |
|
780 // IAPSpecific/<x>/NATRefreshTCP |
|
781 MSmlDmDDFObject& natRefreshTCP = dynIAPNode.AddChildObjectL( |
|
782 KNSmlDMNATRefreshTCP ); |
|
783 natRefreshTCP.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
784 natRefreshTCP.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
785 natRefreshTCP.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
786 natRefreshTCP.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
787 natRefreshTCP.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
788 natRefreshTCP.SetDescriptionL( KNSmlDMNATRefreshTCPExp ); |
|
789 |
|
790 // IAPSpecific/<x>/NATRefreshUDP |
|
791 MSmlDmDDFObject& natRefreshUDP = dynIAPNode.AddChildObjectL( |
|
792 KNSmlDMNATRefreshUDP ); |
|
793 natRefreshUDP.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
794 natRefreshUDP.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
795 natRefreshUDP.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
796 natRefreshUDP.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
797 natRefreshUDP.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
798 natRefreshUDP.SetDescriptionL( KNSmlDMNATRefreshUDPExp ); |
|
799 |
|
800 // IAPSpecific/<x>/STUNRetransmit |
|
801 MSmlDmDDFObject& stunRetransmit = dynIAPNode.AddChildObjectL( |
|
802 KNSmlDMSTUNRetransmit ); |
|
803 stunRetransmit.SetAccessTypesL( accessTypesGetReplaceAdd ); |
|
804 stunRetransmit.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); |
|
805 stunRetransmit.SetScopeL( MSmlDmDDFObject::EDynamic ); |
|
806 stunRetransmit.SetDFFormatL( MSmlDmDDFObject::EInt ); |
|
807 stunRetransmit.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain ); |
|
808 stunRetransmit.SetDescriptionL( KNSmlDMSTUNRetransmitExp ); |
|
809 |
|
810 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DDFStructureL(): end"); |
|
811 } |
|
812 |
|
813 // --------------------------------------------------------------------------- |
|
814 // CNSmlDmNATFWTraversalAdapter::UpdateLeafObjectL |
|
815 // Updates value of a leaf object |
|
816 // --------------------------------------------------------------------------- |
|
817 // |
|
818 void CNSmlDmNATFWTraversalAdapter::UpdateLeafObjectL( |
|
819 const TDesC8& aURI, |
|
820 const TDesC8& aLUID, |
|
821 const TDesC8& aObject, |
|
822 const TDesC8& /*aType*/, |
|
823 const TInt aStatusRef ) |
|
824 { |
|
825 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::UpdateLeafObjectL(): begin"); |
|
826 |
|
827 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
828 |
|
829 CSmlDmAdapter::TError status = EOk; |
|
830 |
|
831 if ( aLUID.Length() <= 0 ) |
|
832 { |
|
833 status = CSmlDmAdapter::ENotFound; |
|
834 iDmCallback->SetStatusL( aStatusRef, status ); |
|
835 return; |
|
836 } |
|
837 |
|
838 // Load profile information if not loaded yet. |
|
839 if ( !iNATFWDomainEntries || !iNATFWIAPEntries ) |
|
840 { |
|
841 LoadProfilesL(); |
|
842 } |
|
843 |
|
844 TInt uriSegs = NumOfURISegs( aURI ); |
|
845 |
|
846 // ============================== |
|
847 // DomainSpecific node |
|
848 // ============================== |
|
849 // |
|
850 if ( KErrNotFound != aURI.Find( KNSmlDMDomainSpecificNodeName() ) |
|
851 && ( KFourSegs == uriSegs || KFiveSegs == uriSegs |
|
852 ) ) |
|
853 { |
|
854 status = UpdateDomainSpecificObjectL( aURI, aLUID, aObject, |
|
855 aStatusRef ); |
|
856 } |
|
857 |
|
858 // ============================== |
|
859 // IAPSpecific/<x>/ |
|
860 // ============================== |
|
861 // |
|
862 else if ( KErrNotFound != aURI.Find( KNSmlDMIAPSpecificNodeName() ) |
|
863 && KFourSegs == NumOfURISegs( aURI ) ) |
|
864 { |
|
865 status = UpdateIAPSpecificObjectL( aURI, aLUID, aObject, aStatusRef ); |
|
866 } |
|
867 |
|
868 // =========================================== |
|
869 // DomainSpecific/<x>/AdditionalSTUNServer/<x> |
|
870 // =========================================== |
|
871 // |
|
872 else if ( KErrNotFound != aURI.Find( KNSmlDMAdditionalSTUNNodeName() ) |
|
873 && KSixSegs == uriSegs && KFourSegs == NumOfURISegs( aLUID ) ) |
|
874 { |
|
875 status = UpdateAdditionalSTUNServerObjectL( aURI, aLUID, aObject, |
|
876 aStatusRef ); |
|
877 } |
|
878 |
|
879 // ============================================== |
|
880 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x> |
|
881 // ============================================== |
|
882 // |
|
883 else if ( KErrNotFound != aURI.Find( KNSmlDMTURNServerNodeName() ) |
|
884 && KErrNotFound != aURI.Find( KNSmlDMTURNSpecificNodeName() ) |
|
885 && KSevenSegs == uriSegs && KFiveSegs == NumOfURISegs( aLUID ) ) |
|
886 { |
|
887 status = UpdateTURNServerObjectL( aURI, aLUID, aObject, aStatusRef ); |
|
888 } |
|
889 |
|
890 else |
|
891 { |
|
892 // No node found under NATFW. |
|
893 status = CSmlDmAdapter::ENotFound; |
|
894 } |
|
895 |
|
896 // We can return status right away if something went wrong. |
|
897 if ( EOk != status ) |
|
898 { |
|
899 iDmCallback->SetStatusL( aStatusRef, status ); |
|
900 } |
|
901 |
|
902 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::UpdateLeafObjectL(): end"); |
|
903 } |
|
904 |
|
905 // --------------------------------------------------------------------------- |
|
906 // CNSmlDmNATFWTraversalAdapter::DeleteObjectL |
|
907 // Deletes NAT-FW settings. |
|
908 // --------------------------------------------------------------------------- |
|
909 // |
|
910 void CNSmlDmNATFWTraversalAdapter::DeleteObjectL( |
|
911 const TDesC8& aURI, |
|
912 const TDesC8& aLUID, |
|
913 const TInt aStatusRef ) |
|
914 { |
|
915 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DeleteObjectL(): begin"); |
|
916 |
|
917 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
918 |
|
919 // Load profile information if not loaded yet |
|
920 if ( !iNATFWDomainEntries || ! iNATFWIAPEntries ) |
|
921 { |
|
922 LoadProfilesL(); |
|
923 } |
|
924 CSmlDmAdapter::TError status = EOk; |
|
925 TPtrC8 uriTmp = RemoveLastURISeg( aURI ); |
|
926 TPtrC8 secondLastUriSeg = LastURISeg( uriTmp ); |
|
927 |
|
928 // ============================== |
|
929 // IAPSpecific/<x>/ |
|
930 // ============================== |
|
931 // |
|
932 if ( KNSmlDMIAPSpecificNodeName() == secondLastUriSeg |
|
933 && aLUID.Find( KNSmlDMIAPSpecificNodeName ) != KErrNotFound ) |
|
934 { |
|
935 TInt iapLoc( 0 ); |
|
936 iapLoc = FindIAPLocation( aLUID ); |
|
937 |
|
938 // Set status info for buffered delete command. |
|
939 TDMNATFWStatusInfo statusInfo; |
|
940 statusInfo.iKeyId = iNATFWIAPEntries->At( iapLoc )->GetIAPKey(); |
|
941 statusInfo.iStatusRef = aStatusRef; |
|
942 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMDeleteIAP; |
|
943 |
|
944 // Internal IPA entry can be deleted already. |
|
945 delete iNATFWIAPEntries->At( iapLoc ); |
|
946 iNATFWIAPEntries->At( iapLoc ) = NULL; |
|
947 iNATFWIAPEntries->Delete( iapLoc ); |
|
948 iNATFWIAPEntries->Compress(); |
|
949 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
950 } |
|
951 |
|
952 // ============================== |
|
953 // DomainSpecific/<x>/ |
|
954 // ============================== |
|
955 // |
|
956 else if ( KNSmlDMDomainSpecificNodeName() == secondLastUriSeg |
|
957 && aLUID.Find( KNSmlDMDomainSpecificNodeName ) != KErrNotFound ) |
|
958 { |
|
959 |
|
960 TInt domainLoc ( 0 ); |
|
961 domainLoc = FindDomainLocation( aLUID ); |
|
962 |
|
963 // Set status info for buffered delete command. |
|
964 TDMNATFWStatusInfo statusInfo; |
|
965 statusInfo.iKeyId = iNATFWDomainEntries->At( |
|
966 domainLoc )->GetDomainKey(); |
|
967 statusInfo.iStatusRef = aStatusRef; |
|
968 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMDeleteDomain; |
|
969 |
|
970 // Internal Domain entry can be deleted already. |
|
971 delete iNATFWDomainEntries->At( domainLoc ); |
|
972 iNATFWDomainEntries->At( domainLoc ) = NULL; |
|
973 iNATFWDomainEntries->Delete( domainLoc ); |
|
974 iNATFWDomainEntries->Compress(); |
|
975 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
976 } |
|
977 |
|
978 // =========================================== |
|
979 // DomainSpecific/<x>/AdditionalSTUNServer/<x> |
|
980 // =========================================== |
|
981 // |
|
982 else if ( KNSmlDMAdditionalSTUNNodeName() == secondLastUriSeg |
|
983 && aLUID.Find( KNSmlDMAdditionalSTUNNodeName ) != KErrNotFound ) |
|
984 { |
|
985 // STUNSrvAddrKey is used as LUID. |
|
986 TUint32 stunKey = DesToInt( LastURISeg( aLUID ) ); |
|
987 |
|
988 // STUN key is zero, i.e. false LUID |
|
989 if ( KErrNone == stunKey ) |
|
990 { |
|
991 status = CSmlDmAdapter::ENotFound; |
|
992 iDmCallback->SetStatusL( aStatusRef, status ); |
|
993 return; |
|
994 } |
|
995 |
|
996 TPtrC8 tmpLuid = RemoveLastURISeg( aLUID ); |
|
997 TPtrC8 domainLuid = RemoveLastURISeg( tmpLuid ); |
|
998 TInt domainLoc = FindDomainLocation( domainLuid ); |
|
999 |
|
1000 if ( KErrNotFound == domainLoc ) |
|
1001 { |
|
1002 status = CSmlDmAdapter::ENotFound; |
|
1003 iDmCallback->SetStatusL( aStatusRef, status ); |
|
1004 return; |
|
1005 } |
|
1006 |
|
1007 TUint32 domainKey = iNATFWDomainEntries->At( domainLoc )-> |
|
1008 GetDomainKey(); |
|
1009 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
1010 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
1011 RArray<TUint32> stunKeys; |
|
1012 CleanupClosePushL( stunKeys ); // CS:1 |
|
1013 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:2 |
|
1014 rep->FindL( domainKey|KUNSAFProtocolsSTUNAddressMask, |
|
1015 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
1016 CleanupStack::PopAndDestroy( rep ); // CS:1 |
|
1017 TInt stunLoc( KErrNotFound ); |
|
1018 const TInt stunCount( stunKeys.Count() ); |
|
1019 for ( TInt counter = 0; counter < stunCount; counter++ ) |
|
1020 { |
|
1021 if ( stunKey == stunKeys[counter] ) |
|
1022 { |
|
1023 stunLoc = counter; |
|
1024 } |
|
1025 } |
|
1026 stunKeys.Close(); |
|
1027 CleanupStack::PopAndDestroy( &stunKeys ); // CS:0 |
|
1028 |
|
1029 // STUN key was not in CentRep. |
|
1030 if ( KErrNotFound == stunLoc ) |
|
1031 { |
|
1032 status = CSmlDmAdapter::ENotFound; |
|
1033 iDmCallback->SetStatusL( aStatusRef, status ); |
|
1034 return; |
|
1035 } |
|
1036 // STUN key was in CentRep index 0 which is reserved for STUN |
|
1037 // settings directly under DomainSpecific node. |
|
1038 else if ( KErrNone == stunLoc ) |
|
1039 { |
|
1040 status = CSmlDmAdapter::EError; |
|
1041 iDmCallback->SetStatusL( aStatusRef, status ); |
|
1042 return; |
|
1043 } |
|
1044 else |
|
1045 { |
|
1046 // Remove the deleted settings from internal arrays. |
|
1047 iNATFWDomainEntries->At( domainLoc )->RemoveStunSrvAddr( |
|
1048 stunLoc ); |
|
1049 iNATFWDomainEntries->At( domainLoc )->RemoveStunSrvPort( |
|
1050 stunLoc ); |
|
1051 iNATFWDomainEntries->At( domainLoc )->RemoveStunUsername( |
|
1052 stunLoc ); |
|
1053 iNATFWDomainEntries->At( domainLoc )->RemoveStunPassword( |
|
1054 stunLoc ); |
|
1055 |
|
1056 // Set status info for buffered delete command. |
|
1057 TDMNATFWStatusInfo statusInfo; |
|
1058 statusInfo.iKeyId = stunKey; |
|
1059 statusInfo.iStatusRef = aStatusRef; |
|
1060 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMDeleteSTUN; |
|
1061 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
1062 } |
|
1063 } |
|
1064 |
|
1065 // ============================================== |
|
1066 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x> |
|
1067 // ============================================== |
|
1068 // |
|
1069 else if ( KNSmlDMTURNServerNodeName() == secondLastUriSeg |
|
1070 && KErrNotFound != aURI.Find( KNSmlDMTURNSpecificNodeName() ) |
|
1071 && KErrNotFound != aLUID.Find( KNSmlDMTURNSpecificNodeName ) ) |
|
1072 { |
|
1073 // TURNSpecific key is used as LUID. |
|
1074 TUint32 turnKey = DesToInt( LastURISeg( aLUID ) ); |
|
1075 |
|
1076 // key is zero, i.e. false LUID |
|
1077 if ( KErrNone == turnKey ) |
|
1078 { |
|
1079 status = CSmlDmAdapter::ENotFound; |
|
1080 iDmCallback->SetStatusL( aStatusRef, status ); |
|
1081 return; |
|
1082 } |
|
1083 |
|
1084 TPtrC8 tmpLuid = RemoveLastURISeg( aLUID ); |
|
1085 TPtrC8 domainLuid = RemoveLastURISeg( RemoveLastURISeg( tmpLuid ) ); |
|
1086 TInt domainLoc = FindDomainLocation( domainLuid ); |
|
1087 |
|
1088 if ( KErrNotFound == domainLoc ) |
|
1089 { |
|
1090 status = CSmlDmAdapter::ENotFound; |
|
1091 iDmCallback->SetStatusL( aStatusRef, status ); |
|
1092 return; |
|
1093 } |
|
1094 |
|
1095 TUint32 domainKey = iNATFWDomainEntries->At( domainLoc )-> |
|
1096 GetDomainKey(); |
|
1097 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
1098 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
1099 RArray<TUint32> turnKeys; |
|
1100 CleanupClosePushL( turnKeys ); // CS:1 |
|
1101 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:2 |
|
1102 rep->FindL( domainKey|KUNSAFProtocolsTURNAddressMask, |
|
1103 KUNSAFProtocolsSubTableFieldTypeMask, turnKeys ); |
|
1104 CleanupStack::PopAndDestroy( rep ); // CS:1 |
|
1105 TInt turnLoc( KErrNotFound ); |
|
1106 const TInt turnCount( turnKeys.Count() ); |
|
1107 for ( TInt counter = 0; counter < turnCount; counter++ ) |
|
1108 { |
|
1109 if ( turnKey == turnKeys[counter] ) |
|
1110 { |
|
1111 turnLoc = counter; |
|
1112 } |
|
1113 } |
|
1114 turnKeys.Close(); |
|
1115 CleanupStack::PopAndDestroy( &turnKeys ); // CS:0 |
|
1116 |
|
1117 // TURN key was not in CentRep. |
|
1118 if ( KErrNotFound == turnLoc ) |
|
1119 { |
|
1120 status = CSmlDmAdapter::ENotFound; |
|
1121 iDmCallback->SetStatusL( aStatusRef, status ); |
|
1122 return; |
|
1123 } |
|
1124 else |
|
1125 { |
|
1126 // Remove the deleted settings from internal arrays. |
|
1127 iNATFWDomainEntries->At( domainLoc )->RemoveTurnSrvAddr( |
|
1128 turnLoc ); |
|
1129 iNATFWDomainEntries->At( domainLoc )->RemoveTurnSrvPort( |
|
1130 turnLoc ); |
|
1131 iNATFWDomainEntries->At( domainLoc )->RemoveTurnUsername( |
|
1132 turnLoc ); |
|
1133 iNATFWDomainEntries->At( domainLoc )->RemoveTurnPassword( |
|
1134 turnLoc ); |
|
1135 |
|
1136 // Set status info for buffered delete command. |
|
1137 TDMNATFWStatusInfo statusInfo; |
|
1138 statusInfo.iKeyId = turnKey; |
|
1139 statusInfo.iStatusRef = aStatusRef; |
|
1140 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMDeleteTURN; |
|
1141 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
1142 } |
|
1143 } |
|
1144 |
|
1145 else |
|
1146 { |
|
1147 status = EInvalidObject; |
|
1148 iDmCallback->SetStatusL( aStatusRef, status ); |
|
1149 } |
|
1150 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DeleteObjectL(): end"); |
|
1151 } |
|
1152 |
|
1153 // --------------------------------------------------------------------------- |
|
1154 // CNSmlDmNATFWTraversalAdapter::FetchLeafObjectL |
|
1155 // Fetches the values of leaf objects. |
|
1156 // --------------------------------------------------------------------------- |
|
1157 // |
|
1158 void CNSmlDmNATFWTraversalAdapter::FetchLeafObjectL( |
|
1159 const TDesC8& aURI, |
|
1160 const TDesC8& aLUID, |
|
1161 const TDesC8& aType, |
|
1162 const TInt aResultsRef, |
|
1163 const TInt aStatusRef ) |
|
1164 { |
|
1165 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::FetchLeafObjectL(): begin"); |
|
1166 |
|
1167 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
1168 |
|
1169 CBufBase *result = CBufFlat::NewL( KDefaultResultSize ); |
|
1170 CleanupStack::PushL( result ); // CS:1 |
|
1171 CSmlDmAdapter::TError status = FetchObjectL( aURI, aLUID, *result ); |
|
1172 |
|
1173 if ( status == CSmlDmAdapter::EOk ) |
|
1174 { |
|
1175 iDmCallback->SetResultsL( aResultsRef, *result, aType ); |
|
1176 } |
|
1177 iDmCallback->SetStatusL( aStatusRef, status ); |
|
1178 |
|
1179 CleanupStack::PopAndDestroy( result ); // CS:0 |
|
1180 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::FetchLeafObjectL(): end"); |
|
1181 } |
|
1182 |
|
1183 // --------------------------------------------------------------------------- |
|
1184 // CNSmlDmNATFWTraversalAdapter::FetchLeafObjectSizeL |
|
1185 // Fetches size of a leaf object |
|
1186 // --------------------------------------------------------------------------- |
|
1187 // |
|
1188 void CNSmlDmNATFWTraversalAdapter::FetchLeafObjectSizeL( |
|
1189 const TDesC8& aURI, |
|
1190 const TDesC8& aLUID, |
|
1191 const TDesC8& aType, |
|
1192 const TInt aResultsRef, |
|
1193 const TInt aStatusRef ) |
|
1194 { |
|
1195 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::FetchLeafObjectSizeL(): begin"); |
|
1196 |
|
1197 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
1198 |
|
1199 CBufBase *object = CBufFlat::NewL( 1 ); |
|
1200 CleanupStack::PushL( object ); // CS:1 |
|
1201 CSmlDmAdapter::TError retValue = FetchObjectL( aURI, aLUID, *object ); |
|
1202 |
|
1203 TInt objSizeInBytes = object->Size(); |
|
1204 TBuf8<16> stringObjSizeInBytes; |
|
1205 stringObjSizeInBytes.Num( objSizeInBytes ); |
|
1206 object->Reset(); |
|
1207 object->InsertL( 0, stringObjSizeInBytes ); |
|
1208 |
|
1209 iDmCallback->SetStatusL( aStatusRef, retValue ); |
|
1210 iDmCallback->SetResultsL( aResultsRef, *object, aType ); |
|
1211 CleanupStack::PopAndDestroy( object ); // CS:0 |
|
1212 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::FetchLeafObjectSizeL(): end"); |
|
1213 } |
|
1214 |
|
1215 // --------------------------------------------------------------------------- |
|
1216 // CNSmlDmNATFWTraversalAdapter::ChildURIListL |
|
1217 // Asks for the list of children objects of the node |
|
1218 // --------------------------------------------------------------------------- |
|
1219 // |
|
1220 void CNSmlDmNATFWTraversalAdapter::ChildURIListL( |
|
1221 const TDesC8& aURI, |
|
1222 const TDesC8& aLUID, |
|
1223 const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList, |
|
1224 const TInt aResultsRef, |
|
1225 const TInt aStatusRef ) |
|
1226 { |
|
1227 DBG_PRINT( "CNSmlDmNATFWTraversalAdapter::ChildURIListL(): begin" ); |
|
1228 |
|
1229 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
1230 |
|
1231 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
1232 |
|
1233 // load profile information in not loaded yet |
|
1234 if ( !iNATFWDomainEntries || ! iNATFWIAPEntries ) |
|
1235 { |
|
1236 LoadProfilesL(); |
|
1237 } |
|
1238 |
|
1239 CBufBase *currentURISegmentList = CBufFlat::NewL( KDefaultResultSize ); |
|
1240 CleanupStack::PushL( currentURISegmentList ); // CS:1 |
|
1241 TBuf8<KNSmlNATFWMaxUriLength> mappingInfo( KNullDesC8 ); |
|
1242 |
|
1243 // get last URI segment. |
|
1244 TBuf8<KSmlMaxURISegLen> segment = LastURISeg( aURI ); |
|
1245 TBuf8<KSmlMaxURISegLen> segmentName; |
|
1246 |
|
1247 // ============================== |
|
1248 // NATFW/ |
|
1249 // ============================== |
|
1250 // |
|
1251 if ( KOneSeg == NumOfURISegs( aURI ) && |
|
1252 KNSmlDMNATFWNodeName() == segment ) |
|
1253 { |
|
1254 segmentName.Copy( KNSmlDMDomainSpecificNodeName ); |
|
1255 currentURISegmentList->InsertL( currentURISegmentList-> |
|
1256 Size(), segmentName ); |
|
1257 currentURISegmentList->InsertL( currentURISegmentList-> |
|
1258 Size(), KNSmlDMNATFWSeparator ); |
|
1259 |
|
1260 segmentName.Copy( KNSmlDMIAPSpecificNodeName ); |
|
1261 currentURISegmentList->InsertL( currentURISegmentList-> |
|
1262 Size(), segmentName ); |
|
1263 currentURISegmentList->InsertL( currentURISegmentList-> |
|
1264 Size(), KNSmlDMNATFWSeparator ); |
|
1265 } |
|
1266 |
|
1267 // ============================== |
|
1268 // DomainSpecific/ etc |
|
1269 // ============================== |
|
1270 // |
|
1271 if ( aURI.Find( KNSmlDMDomainSpecificNodeName ) != KErrNotFound ) |
|
1272 { |
|
1273 retValue = DomainChildURIListL( aURI, aLUID, currentURISegmentList, |
|
1274 aPreviousURISegmentList ); |
|
1275 } |
|
1276 |
|
1277 // ================================== |
|
1278 // IAPSpecific/ and IAPSpecific/<x>/ |
|
1279 // ================================== |
|
1280 // |
|
1281 else if ( aURI.Find( KNSmlDMIAPSpecificNodeName ) != KErrNotFound && |
|
1282 KThreeSegs == NumOfURISegs( aURI ) || |
|
1283 KTwoSegs == NumOfURISegs( aURI ) ) |
|
1284 { |
|
1285 retValue = IAPChildURIListL( aURI, aLUID, currentURISegmentList, |
|
1286 aPreviousURISegmentList ); |
|
1287 } |
|
1288 else |
|
1289 { |
|
1290 // If none of asked nodes were found, return error. |
|
1291 retValue = CSmlDmAdapter::ENotFound; |
|
1292 } |
|
1293 |
|
1294 iDmCallback->SetStatusL( aStatusRef, retValue ); |
|
1295 if ( EOk == retValue ) |
|
1296 { |
|
1297 iDmCallback->SetResultsL( aResultsRef, |
|
1298 *currentURISegmentList, KNullDesC8 ); |
|
1299 } |
|
1300 CleanupStack::PopAndDestroy( currentURISegmentList ); // CS:0 |
|
1301 |
|
1302 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::ChildURIListL(): end"); |
|
1303 } |
|
1304 |
|
1305 // --------------------------------------------------------------------------- |
|
1306 // CNSmlDmNATFWTraversalAdapter::AddNodeObjectL |
|
1307 // Adds a new NAT-FW Traversal setting |
|
1308 // --------------------------------------------------------------------------- |
|
1309 // |
|
1310 void CNSmlDmNATFWTraversalAdapter::AddNodeObjectL( |
|
1311 const TDesC8& aURI, |
|
1312 const TDesC8& aParentLUID, |
|
1313 const TInt aStatusRef ) |
|
1314 { |
|
1315 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::AddNodeObjectL(): begin"); |
|
1316 CSmlDmAdapter::TError retValue = EOk; |
|
1317 |
|
1318 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
1319 |
|
1320 // Load profile information if not loaded yet |
|
1321 if ( !iNATFWDomainEntries || ! iNATFWIAPEntries ) |
|
1322 { |
|
1323 LoadProfilesL(); |
|
1324 } |
|
1325 |
|
1326 // Find profile from array, profile deleted from elsewhere if not found. |
|
1327 if ( aParentLUID.Length() > 0 ) |
|
1328 { |
|
1329 TInt iapLoc = FindIAPLocation( aParentLUID ); |
|
1330 TInt domainLoc = FindDomainLocation( aParentLUID ); |
|
1331 if ( KErrNotFound == iapLoc && KErrNotFound == domainLoc ) |
|
1332 { |
|
1333 retValue = CSmlDmAdapter::ENotFound; |
|
1334 } |
|
1335 } |
|
1336 |
|
1337 // Get last URI segment. |
|
1338 TBuf8<KNSmlNATFWMaxUriLength> uri = aURI; |
|
1339 TBuf8<KNSmlNATFWMaxUriLength> mappingInfo( KNullDesC8 ); |
|
1340 TPtrC8 lastUriSeg = LastURISeg( aURI ); |
|
1341 TPtrC8 uriTmp = RemoveLastURISeg( aURI ); |
|
1342 TPtrC8 secondLastUriSeg = LastURISeg( uriTmp ); |
|
1343 |
|
1344 // Profile already exists if LUID exists, profile is not deleted from |
|
1345 // elsewhere and node to be set is not a new AdditionalSTUNServer node or |
|
1346 // a new STUNServer node. |
|
1347 if ( EOk == retValue && 0 < aParentLUID.Length() |
|
1348 && KNSmlDMAdditionalSTUNNodeName() != secondLastUriSeg |
|
1349 && KNSmlDMTURNServerNodeName() != secondLastUriSeg ) |
|
1350 { |
|
1351 uri.Copy( aParentLUID ); |
|
1352 retValue = CSmlDmAdapter::EAlreadyExists; |
|
1353 iDmCallback->SetStatusL( aStatusRef, retValue ); |
|
1354 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::AddNodeObjectL(): end \ |
|
1355 (profile already exists)"); |
|
1356 return; |
|
1357 } |
|
1358 |
|
1359 // ============================== |
|
1360 // IAPSpecific/x/ |
|
1361 // ============================== |
|
1362 // |
|
1363 if ( KNSmlDMIAPSpecificNodeName() == secondLastUriSeg |
|
1364 && aParentLUID.Find( KNSmlDMIAPSpecificNodeName ) == KErrNotFound ) |
|
1365 { |
|
1366 // Central Repository for NAT-FW Traversal settings |
|
1367 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
1368 RArray<TUint32> keys; |
|
1369 CleanupClosePushL( keys ); // CS:2 |
|
1370 rep->FindL( KUNSAFProtocolsIAPIdMask, |
|
1371 KUNSAFProtocolsFieldTypeMask, keys ); |
|
1372 TInt keyCount = keys.Count(); |
|
1373 |
|
1374 CNATFWIAPEntry* entry = CNATFWIAPEntry::NewLC(); // CS:3 |
|
1375 TUint32 tmp ( 0 ); |
|
1376 if ( keyCount > 0 ) |
|
1377 { |
|
1378 tmp = keys[keys.Count() - 1] + 1; |
|
1379 } |
|
1380 else |
|
1381 { |
|
1382 tmp = KUNSAFProtocolsIAPTableMask; |
|
1383 } |
|
1384 entry->SetIAPKey( tmp|KUNSAFProtocolsIAPIdMask ); |
|
1385 iNATFWIAPEntries->AppendL( entry ); |
|
1386 CleanupStack::Pop( entry ); // CS:2 |
|
1387 |
|
1388 // Set status info for buffered command. |
|
1389 TDMNATFWStatusInfo statusInfo; |
|
1390 statusInfo.iKeyId = tmp|KUNSAFProtocolsIAPIdMask; |
|
1391 statusInfo.iStatusRef = aStatusRef; |
|
1392 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMAddIAP; |
|
1393 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
1394 |
|
1395 // Set mapping info. |
|
1396 mappingInfo.Copy( KNSmlDMIAPSpecificNodeName ); |
|
1397 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1398 mappingInfo.AppendNum( entry->GetIAPKey() ); |
|
1399 iDmCallback->SetMappingL( aURI, mappingInfo ); |
|
1400 keys.Close(); |
|
1401 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
1402 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
1403 SaveProfilesL(); |
|
1404 retValue = CSmlDmAdapter::EOk; |
|
1405 } |
|
1406 |
|
1407 // ============================== |
|
1408 // DomainSpecific/x/ |
|
1409 // ============================== |
|
1410 // |
|
1411 if ( KNSmlDMDomainSpecificNodeName() == secondLastUriSeg |
|
1412 && aParentLUID.Find( KNSmlDMDomainSpecificNodeName ) == KErrNotFound ) |
|
1413 { |
|
1414 // Central Repository for NAT-FW Traversal settings |
|
1415 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
1416 RArray<TUint32> keys; |
|
1417 CleanupClosePushL( keys ); // CS:2 |
|
1418 rep->FindL( KUNSAFProtocolsDomainMask, |
|
1419 KUNSAFProtocolsFieldTypeMask, keys ); |
|
1420 TInt keyCount = keys.Count(); |
|
1421 |
|
1422 // Add settings to domain entry. |
|
1423 CNATFWDomainEntry* entry = CNATFWDomainEntry::NewLC(); // CS:3 |
|
1424 |
|
1425 // Add new key ID and domain to entry. |
|
1426 TUint32 tmp ( 0 ); |
|
1427 if ( keyCount > 0 ) |
|
1428 { |
|
1429 tmp = keys[keyCount - 1] + 1; |
|
1430 } |
|
1431 else |
|
1432 { |
|
1433 tmp = KUNSAFProtocolsDomainTableMask; |
|
1434 } |
|
1435 entry->SetDomainKey( tmp|KUNSAFProtocolsDomainMask ); |
|
1436 entry->SetDomainL( lastUriSeg ); |
|
1437 |
|
1438 // Add STUN server settings with values "not set" / "not found" to |
|
1439 // internal array. These values will not be used when saving settings. |
|
1440 entry->AddStunSrvAddrL( KNSmlDMNATFWValueNotSet ); |
|
1441 entry->AddStunSrvPortL( KErrNotFound ); |
|
1442 entry->AddStunUsernameL( KNSmlDMNATFWValueNotSet ); |
|
1443 entry->AddStunPasswordL( KNSmlDMNATFWValueNotSet ); |
|
1444 |
|
1445 // Append new domain settings to buffered entries. |
|
1446 iNATFWDomainEntries->AppendL( entry ); |
|
1447 CleanupStack::Pop( entry ); // CS:2 |
|
1448 |
|
1449 // Set status info for buffered command. |
|
1450 TDMNATFWStatusInfo statusInfo; |
|
1451 |
|
1452 // Set temporary buffer for save profiles. |
|
1453 statusInfo.iKeyId = tmp|KUNSAFProtocolsDomainMask; |
|
1454 statusInfo.iStatusRef = aStatusRef; |
|
1455 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMAddDomain; |
|
1456 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
1457 |
|
1458 // Set mapping information to newly added settings. |
|
1459 mappingInfo.Copy( KNSmlDMDomainSpecificNodeName ); |
|
1460 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1461 mappingInfo.AppendNum( tmp|KUNSAFProtocolsDomainMask ); |
|
1462 iDmCallback->SetMappingL( aURI, mappingInfo ); |
|
1463 keys.Close(); |
|
1464 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
1465 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
1466 SaveProfilesL(); |
|
1467 retValue = CSmlDmAdapter::EOk; |
|
1468 } |
|
1469 |
|
1470 // ============================================ |
|
1471 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/ |
|
1472 // ============================================ |
|
1473 // |
|
1474 if ( KNSmlDMAdditionalSTUNNodeName() == secondLastUriSeg |
|
1475 && aParentLUID.Find( KNSmlDMAdditionalSTUNNodeName ) == KErrNotFound ) |
|
1476 { |
|
1477 // If no parent LUID, no DomainSpecific profile and no |
|
1478 // AdditionalSTUNServer nodes. |
|
1479 if ( !( aParentLUID.Length() ) ) |
|
1480 { |
|
1481 retValue = CSmlDmAdapter::ENotFound; |
|
1482 iDmCallback->SetStatusL( aStatusRef, retValue ); |
|
1483 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::AddNodeObjectL(): end \ |
|
1484 (no parent LUID)"); |
|
1485 return; |
|
1486 } |
|
1487 |
|
1488 TInt domainLoc( FindDomainLocation( aParentLUID ) ); |
|
1489 // Domain settings to be updated are deleted from somewhere else. |
|
1490 if ( KErrNotFound == domainLoc ) |
|
1491 { |
|
1492 retValue = CSmlDmAdapter::ENotFound; |
|
1493 iDmCallback->SetStatusL( aStatusRef, retValue ); |
|
1494 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::AddNodeObjectL(): end \ |
|
1495 (domain settings deleted from somewhere else)"); |
|
1496 return; |
|
1497 } |
|
1498 TUint32 domainKey( iNATFWDomainEntries->At( domainLoc )-> |
|
1499 GetDomainKey() ); |
|
1500 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
1501 RArray<TUint32> stunKeys; |
|
1502 CleanupClosePushL( stunKeys ); // CS:2 |
|
1503 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
1504 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
1505 |
|
1506 rep->FindL( domainKey|KUNSAFProtocolsSTUNAddressMask, |
|
1507 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
1508 TInt stunCount = stunKeys.Count(); |
|
1509 |
|
1510 TUint32 tmp( 0 ); |
|
1511 if ( stunCount > 0 ) |
|
1512 { |
|
1513 tmp = stunKeys[stunCount - 1]; |
|
1514 tmp = tmp|KUNSAFProtocolsSubTableFieldTypeMask; |
|
1515 tmp++; |
|
1516 tmp |= KUNSAFProtocolsSubTableFieldTypeMask; |
|
1517 tmp = tmp^KUNSAFProtocolsSubTableFieldTypeMask|domainKey; |
|
1518 // STUNAddressMask is used as LUID so let's add it to tmp now. |
|
1519 tmp |= KUNSAFProtocolsSTUNAddressMask; |
|
1520 } |
|
1521 else |
|
1522 { |
|
1523 // If there are no STUN keys in CentRep, an AdditionalSTUNServer |
|
1524 // node cannot be added since the first CentRep STUN key is |
|
1525 // reserved to STUN settings directly under DomainSpecific node. |
|
1526 stunKeys.Close(); |
|
1527 CleanupStack::PopAndDestroy( &stunKeys ); // CS:1 |
|
1528 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
1529 retValue = CSmlDmAdapter::EError; |
|
1530 iDmCallback->SetStatusL( aStatusRef, retValue ); |
|
1531 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::AddNodeObjectL(): end \ |
|
1532 (no STUN keys in Centrep)"); |
|
1533 return; |
|
1534 } |
|
1535 stunKeys.Close(); |
|
1536 CleanupStack::PopAndDestroy( &stunKeys ); // CS:1 |
|
1537 |
|
1538 // Add AdditionalSTUNServer settings with values "not set" or |
|
1539 // "not found" to internal arrays. These values will not be used when |
|
1540 // saving settings. |
|
1541 iNATFWDomainEntries->At( domainLoc )->AddStunSrvAddrL( |
|
1542 KNSmlDMNATFWValueNotSet ); |
|
1543 iNATFWDomainEntries->At( domainLoc )->AddStunSrvPortL( |
|
1544 KErrNotFound ); |
|
1545 iNATFWDomainEntries->At( domainLoc )->AddStunUsernameL( |
|
1546 KNSmlDMNATFWValueNotSet ); |
|
1547 iNATFWDomainEntries->At( domainLoc )->AddStunPasswordL( |
|
1548 KNSmlDMNATFWValueNotSet ); |
|
1549 |
|
1550 // Set status info for buffered command. |
|
1551 TDMNATFWStatusInfo statusInfo; |
|
1552 statusInfo.iKeyId = tmp; |
|
1553 statusInfo.iStatusRef = aStatusRef; |
|
1554 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMAddSTUN; |
|
1555 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
1556 |
|
1557 // Set mapping info. |
|
1558 mappingInfo.Copy( KNSmlDMDomainSpecificNodeName ); |
|
1559 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1560 mappingInfo.AppendNum( iNATFWDomainEntries->At( domainLoc )-> |
|
1561 GetDomainKey() ); |
|
1562 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1563 mappingInfo.Append( KNSmlDMAdditionalSTUNNodeName ); |
|
1564 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1565 mappingInfo.AppendNum( tmp ); |
|
1566 iDmCallback->SetMappingL( aURI, mappingInfo ); |
|
1567 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
1568 SaveProfilesL(); |
|
1569 retValue = CSmlDmAdapter::EOk; |
|
1570 } |
|
1571 |
|
1572 // ================================================ |
|
1573 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/ |
|
1574 // ================================================ |
|
1575 // |
|
1576 if ( KNSmlDMTURNServerNodeName() == secondLastUriSeg && |
|
1577 KErrNotFound != aURI.Find( KNSmlDMTURNSpecificNodeName() ) && |
|
1578 aParentLUID.Find( KNSmlDMTURNServerNodeName ) == KErrNotFound ) |
|
1579 { |
|
1580 // If no parent LUID, no DomainSpecific profile and no |
|
1581 // TURNSpecific/TURNServer nodes. |
|
1582 if ( !( aParentLUID.Length() ) ) |
|
1583 { |
|
1584 retValue = CSmlDmAdapter::ENotFound; |
|
1585 iDmCallback->SetStatusL( aStatusRef, retValue ); |
|
1586 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::AddNodeObjectL(): end \ |
|
1587 (no parent LUID)"); |
|
1588 return; |
|
1589 } |
|
1590 |
|
1591 TInt domainLoc( FindDomainLocation( aParentLUID ) ); |
|
1592 // Domain settings to be updated are deleted from somewhere else. |
|
1593 if ( KErrNotFound == domainLoc ) |
|
1594 { |
|
1595 retValue = CSmlDmAdapter::ENotFound; |
|
1596 iDmCallback->SetStatusL( aStatusRef, retValue ); |
|
1597 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::AddNodeObjectL(): end \ |
|
1598 (domain settings deleted from somewhere else)"); |
|
1599 return; |
|
1600 } |
|
1601 TUint32 domainKey( iNATFWDomainEntries->At( domainLoc )-> |
|
1602 GetDomainKey() ); |
|
1603 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
1604 RArray<TUint32> turnKeys; |
|
1605 CleanupClosePushL( turnKeys ); // CS:2 |
|
1606 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
1607 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
1608 |
|
1609 rep->FindL( domainKey|KUNSAFProtocolsTURNAddressMask, |
|
1610 KUNSAFProtocolsSubTableFieldTypeMask, turnKeys ); |
|
1611 TInt turnCount = turnKeys.Count(); |
|
1612 |
|
1613 TUint32 tmp( 0 ); |
|
1614 if ( turnCount > 0 ) |
|
1615 { |
|
1616 tmp = turnKeys[turnCount - 1]; |
|
1617 tmp = tmp|KUNSAFProtocolsSubTableFieldTypeMask; |
|
1618 tmp++; |
|
1619 tmp |= KUNSAFProtocolsSubTableFieldTypeMask; |
|
1620 tmp = tmp^KUNSAFProtocolsSubTableFieldTypeMask|domainKey; |
|
1621 } |
|
1622 else |
|
1623 { |
|
1624 TUint32 currentNewKey = domainKey; |
|
1625 currentNewKey |= KUNSAFProtocolsFieldTypeMask; |
|
1626 currentNewKey ^= KUNSAFProtocolsFieldTypeMask; |
|
1627 |
|
1628 tmp = KUNSAFProtocolsSubTableFieldTypeMask + 1; |
|
1629 tmp |= KUNSAFProtocolsSubTableFieldTypeMask; |
|
1630 tmp = tmp^KUNSAFProtocolsSubTableFieldTypeMask|currentNewKey; |
|
1631 } |
|
1632 |
|
1633 // TURNAddressMask is used as LUID so let's add it to tmp now. |
|
1634 tmp |= KUNSAFProtocolsTURNAddressMask; |
|
1635 |
|
1636 turnKeys.Close(); |
|
1637 CleanupStack::PopAndDestroy( &turnKeys ); // CS:1 |
|
1638 |
|
1639 // Add TURNSpecific/TURNServer settings with values "not set" or |
|
1640 // "not found" to internal arrays. These values will not be used when |
|
1641 // saving settings. |
|
1642 iNATFWDomainEntries->At( domainLoc )->AddTurnSrvAddrL( |
|
1643 KNSmlDMNATFWValueNotSet ); |
|
1644 iNATFWDomainEntries->At( domainLoc )->AddTurnSrvPortL( |
|
1645 KErrNotFound ); |
|
1646 iNATFWDomainEntries->At( domainLoc )->AddTurnUsernameL( |
|
1647 KNSmlDMNATFWValueNotSet ); |
|
1648 iNATFWDomainEntries->At( domainLoc )->AddTurnPasswordL( |
|
1649 KNSmlDMNATFWValueNotSet ); |
|
1650 |
|
1651 // Set status info for buffered command. |
|
1652 TDMNATFWStatusInfo statusInfo; |
|
1653 statusInfo.iKeyId = tmp; |
|
1654 statusInfo.iStatusRef = aStatusRef; |
|
1655 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMAddTURN; |
|
1656 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
1657 |
|
1658 // Set mapping info. |
|
1659 mappingInfo.Copy( KNSmlDMDomainSpecificNodeName ); |
|
1660 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1661 mappingInfo.AppendNum( iNATFWDomainEntries->At( domainLoc )-> |
|
1662 GetDomainKey() ); |
|
1663 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1664 mappingInfo.Append( KNSmlDMTURNSpecificNodeName ); |
|
1665 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1666 mappingInfo.Append( KNSmlDMTURNServerNodeName ); |
|
1667 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
1668 mappingInfo.AppendNum( tmp ); |
|
1669 iDmCallback->SetMappingL( aURI, mappingInfo ); |
|
1670 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
1671 SaveProfilesL(); |
|
1672 retValue = CSmlDmAdapter::EOk; |
|
1673 } |
|
1674 |
|
1675 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::AddNodeObjectL(): end"); |
|
1676 } |
|
1677 |
|
1678 // --------------------------------------------------------------------------- |
|
1679 // CNSmlDmNATFWTraversalAdapter::ExecuteCommandL |
|
1680 // (Not supported, see smldmadapter.h) |
|
1681 // --------------------------------------------------------------------------- |
|
1682 // |
|
1683 void CNSmlDmNATFWTraversalAdapter::ExecuteCommandL( |
|
1684 const TDesC8& /*aURI*/, |
|
1685 const TDesC8& /*aLUID*/, |
|
1686 const TDesC8& /*aArgument*/, |
|
1687 const TDesC8& /*aType*/, |
|
1688 const TInt aStatusRef ) |
|
1689 { |
|
1690 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::ExecuteCommandL(): begin"); |
|
1691 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
1692 iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError ); |
|
1693 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::ExecuteCommandL(): end"); |
|
1694 } |
|
1695 |
|
1696 // --------------------------------------------------------------------------- |
|
1697 // CNSmlDmNATFWTraversalAdapter::ExecuteCommandL |
|
1698 // (Not supported, see smldmadapter.h) |
|
1699 // --------------------------------------------------------------------------- |
|
1700 // |
|
1701 void CNSmlDmNATFWTraversalAdapter::ExecuteCommandL( |
|
1702 const TDesC8& /*aURI*/, |
|
1703 const TDesC8& /*aParentLUID*/, |
|
1704 RWriteStream*& /*aStream*/, |
|
1705 const TDesC8& /*aType*/, |
|
1706 const TInt aStatusRef ) |
|
1707 { |
|
1708 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::ExecuteCommandL(): stream: begin"); |
|
1709 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
1710 iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError ); |
|
1711 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::ExecuteCommandL(): stream: end"); |
|
1712 } |
|
1713 |
|
1714 // --------------------------------------------------------------------------- |
|
1715 // CNSmlDmNATFWTraversalAdapter::CopyCommandL |
|
1716 // (Not supported, see smldmadapter.h) |
|
1717 // --------------------------------------------------------------------------- |
|
1718 // |
|
1719 void CNSmlDmNATFWTraversalAdapter::CopyCommandL( |
|
1720 const TDesC8& /*aTargetURI*/, |
|
1721 const TDesC8& /*aTargetLUID*/, |
|
1722 const TDesC8& /*aSourceURI*/, |
|
1723 const TDesC8& /*aSourceLUID*/, |
|
1724 const TDesC8& /*aType*/, |
|
1725 TInt aStatusRef ) |
|
1726 { |
|
1727 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::CopyCommandL(): begin"); |
|
1728 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
1729 iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError ); |
|
1730 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::CopyCommandL(): end"); |
|
1731 } |
|
1732 |
|
1733 // --------------------------------------------------------------------------- |
|
1734 // CNSmlDmNATFWTraversalAdapter::StartAtomicL |
|
1735 // (Not supported, see smldmadapter.h) |
|
1736 // --------------------------------------------------------------------------- |
|
1737 // |
|
1738 void CNSmlDmNATFWTraversalAdapter::StartAtomicL() |
|
1739 { |
|
1740 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::StartAtomicL(): begin"); |
|
1741 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::StartAtomicL(): end"); |
|
1742 } |
|
1743 |
|
1744 // --------------------------------------------------------------------------- |
|
1745 // CNSmlDmNATFWTraversalAdapter::CommitAtomicL |
|
1746 // (Not supported, see smldmadapter.h) |
|
1747 // --------------------------------------------------------------------------- |
|
1748 // |
|
1749 void CNSmlDmNATFWTraversalAdapter::CommitAtomicL() |
|
1750 { |
|
1751 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::CommitAtomicL(): begin"); |
|
1752 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::CommitAtomicL(): end"); |
|
1753 } |
|
1754 |
|
1755 // --------------------------------------------------------------------------- |
|
1756 // CNSmlDmNATFWTraversalAdapter::RollbackAtomicL |
|
1757 // (Not supported, see smldmadapter.h) |
|
1758 // --------------------------------------------------------------------------- |
|
1759 // |
|
1760 void CNSmlDmNATFWTraversalAdapter::RollbackAtomicL() |
|
1761 { |
|
1762 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::RollbackAtomicL(): begin"); |
|
1763 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::RollbackAtomicL(): end"); |
|
1764 } |
|
1765 |
|
1766 // --------------------------------------------------------------------------- |
|
1767 // CNSmlDmNATFWTraversalAdapter::StreamingSupport |
|
1768 // (Not supported, see smldmadapter.h) |
|
1769 // --------------------------------------------------------------------------- |
|
1770 // |
|
1771 TBool CNSmlDmNATFWTraversalAdapter::StreamingSupport( TInt& /*aItemSize*/ ) |
|
1772 { |
|
1773 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::StreamingSupport(): begin"); |
|
1774 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::StreamingSupport(): end"); |
|
1775 return EFalse; |
|
1776 } |
|
1777 |
|
1778 // --------------------------------------------------------------------------- |
|
1779 // CNSmlDmNATFWTraversalAdapter::StreamCommittedL |
|
1780 // (Not supported, see smldmadapter.h) |
|
1781 // --------------------------------------------------------------------------- |
|
1782 // |
|
1783 void CNSmlDmNATFWTraversalAdapter::StreamCommittedL() |
|
1784 { |
|
1785 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::StreamCommittedL(): begin"); |
|
1786 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::StreamCommittedL(): end"); |
|
1787 } |
|
1788 |
|
1789 // --------------------------------------------------------------------------- |
|
1790 // CNSmlDmNATFWTraversalAdapter::CompleteOutstandingCmdsL |
|
1791 // Saves modified profiles back to permanent store |
|
1792 // --------------------------------------------------------------------------- |
|
1793 // |
|
1794 void CNSmlDmNATFWTraversalAdapter::CompleteOutstandingCmdsL() |
|
1795 { |
|
1796 SaveProfilesL(); |
|
1797 } |
|
1798 |
|
1799 // --------------------------------------------------------------------------- |
|
1800 // CNSmlDmNATFWTraversalAdapter::UpdateLeafObjectL |
|
1801 // (Not supported, see smldmadapter.h) |
|
1802 // --------------------------------------------------------------------------- |
|
1803 // |
|
1804 void CNSmlDmNATFWTraversalAdapter::UpdateLeafObjectL( |
|
1805 const TDesC8& /*aURI*/, |
|
1806 const TDesC8& /*aLUID*/, |
|
1807 RWriteStream*& /*aStream*/, |
|
1808 const TDesC8& /*aType*/, |
|
1809 const TInt aStatusRef ) |
|
1810 { |
|
1811 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::UpdateLeafObjectL(): stream: begin"); |
|
1812 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
1813 iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError ); |
|
1814 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::UpdateLeafObjectL(): stream: end"); |
|
1815 } |
|
1816 |
|
1817 // --------------------------------------------------------------------------- |
|
1818 // CNSmlDmNATFWTraversalAdapter::UpdateDomainSpecificObjectL |
|
1819 // |
|
1820 // --------------------------------------------------------------------------- |
|
1821 // |
|
1822 CSmlDmAdapter::TError |
|
1823 CNSmlDmNATFWTraversalAdapter::UpdateDomainSpecificObjectL( |
|
1824 const TDesC8& aURI, |
|
1825 const TDesC8& aLUID, |
|
1826 const TDesC8& aObject, |
|
1827 const TInt aStatusRef ) |
|
1828 { |
|
1829 CSmlDmAdapter::TError status = EOk; |
|
1830 |
|
1831 TInt domainLoc = FindDomainLocation( aLUID ); |
|
1832 if ( KErrNotFound == domainLoc ) |
|
1833 { |
|
1834 status = CSmlDmAdapter::ENotFound; |
|
1835 return status; |
|
1836 } |
|
1837 TDMNATFWStatusInfo statusInfo; |
|
1838 statusInfo.iKeyId = iNATFWDomainEntries-> |
|
1839 At( domainLoc )->GetDomainKey(); |
|
1840 statusInfo.iStatusRef = aStatusRef; |
|
1841 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMUpdateDomain; |
|
1842 |
|
1843 TInt uriSegs = NumOfURISegs( aURI ); |
|
1844 |
|
1845 TBool iceSpecific( EFalse ); |
|
1846 if ( KErrNotFound != aURI.Find( KNSmlDMICESpecificNodeName() ) |
|
1847 && KFiveSegs == uriSegs ) |
|
1848 { |
|
1849 iceSpecific = ETrue; |
|
1850 } |
|
1851 TInt err( KErrNone ); |
|
1852 TPtrC8 lastURISeg = LastURISeg( aURI ); |
|
1853 |
|
1854 // DomainSpecific/<x>/Domain |
|
1855 if ( KNSmlDMDomain() == lastURISeg ) |
|
1856 { |
|
1857 iNATFWDomainEntries->At( domainLoc )->SetDomainL( aObject ); |
|
1858 } |
|
1859 // DomainSpecific/<x>/STUNSrvAddr |
|
1860 else if ( KNSmlDMSTUNSrvAddr() == lastURISeg && KFourSegs == uriSegs ) |
|
1861 { |
|
1862 iNATFWDomainEntries->At( domainLoc )-> |
|
1863 SetSTUNServerAddrL( aObject ); |
|
1864 |
|
1865 // STUN server settings directly under DomainSpecific node go to |
|
1866 // array index 0. |
|
1867 err = iNATFWDomainEntries->At( domainLoc )-> |
|
1868 UpdateStunSrvAddrL( 0, aObject ); |
|
1869 } |
|
1870 // DomainSpecific/<x>/STUNSrvPort |
|
1871 else if ( KNSmlDMSTUNSrvPort() == lastURISeg && KFourSegs == uriSegs ) |
|
1872 { |
|
1873 iNATFWDomainEntries->At( domainLoc )-> |
|
1874 SetSTUNServerPort( DesToInt( aObject ) ); |
|
1875 |
|
1876 err = iNATFWDomainEntries->At( domainLoc )-> |
|
1877 UpdateStunSrvPort( 0, DesToInt( aObject ) ); |
|
1878 } |
|
1879 |
|
1880 // DomainSpecific/<x>/STUNUsername |
|
1881 else if ( KNSmlDMSTUNUsername() == lastURISeg && KFourSegs == uriSegs ) |
|
1882 { |
|
1883 iNATFWDomainEntries->At( domainLoc )-> |
|
1884 SetSTUNUsernameL( aObject ); |
|
1885 err = iNATFWDomainEntries->At( domainLoc )-> |
|
1886 UpdateStunUsernameL( 0, aObject ); |
|
1887 } |
|
1888 // DomainSpecific/<x>/STUNPassword |
|
1889 else if ( KNSmlDMSTUNPassword() == lastURISeg && KFourSegs == uriSegs ) |
|
1890 { |
|
1891 iNATFWDomainEntries->At( domainLoc )-> |
|
1892 SetSTUNPasswordL( aObject ); |
|
1893 err = iNATFWDomainEntries->At( domainLoc )-> |
|
1894 UpdateStunPasswordL( 0, aObject ); |
|
1895 } |
|
1896 |
|
1897 // DomainSpecific/<x>/NATRefreshTCP |
|
1898 else if ( KNSmlDMDomainNATRefreshTCP() == lastURISeg |
|
1899 && KFourSegs == uriSegs ) |
|
1900 { |
|
1901 iNATFWDomainEntries->At( domainLoc )-> |
|
1902 SetNATRefreshTCP( DesToInt( aObject ) ); |
|
1903 } |
|
1904 // DomainSpecific/<x>/NATRefreshUDP |
|
1905 else if ( KNSmlDMDomainNATRefreshUDP() == lastURISeg |
|
1906 && KFourSegs == uriSegs ) |
|
1907 { |
|
1908 iNATFWDomainEntries->At( domainLoc )-> |
|
1909 SetNATRefreshUDP( DesToInt( aObject ) ); |
|
1910 } |
|
1911 // DomainSpecific/<x>/EnableCRLFRefresh |
|
1912 else if ( KNSmlDMDomainEnableCRLFRefresh() == lastURISeg |
|
1913 && KFourSegs == uriSegs ) |
|
1914 { |
|
1915 if ( KNSmlDMNATFWValueTrue() == aObject ) |
|
1916 { |
|
1917 iNATFWDomainEntries->At( domainLoc )-> |
|
1918 SetEnableCRLFRefresh( ETrue ); |
|
1919 } |
|
1920 else if ( KNSmlDMNATFWValueFalse() == aObject ) |
|
1921 { |
|
1922 iNATFWDomainEntries->At( domainLoc )-> |
|
1923 SetEnableCRLFRefresh( EFalse ); |
|
1924 } |
|
1925 else |
|
1926 { |
|
1927 status = CSmlDmAdapter::EInvalidObject; |
|
1928 } |
|
1929 } |
|
1930 |
|
1931 // DomainSpecific/<x>/STUNSharedSecret |
|
1932 else if ( KNSmlDMSTUNSharedSecret() == lastURISeg |
|
1933 && KFourSegs == uriSegs ) |
|
1934 { |
|
1935 if ( KNSmlDMNATFWValueTrue() == aObject ) |
|
1936 { |
|
1937 // The CentRep key is for not using STUN shared secret |
|
1938 // so we must change the value from true to false. |
|
1939 iNATFWDomainEntries->At( domainLoc )-> |
|
1940 SetDisableStunSharedSecret( EFalse ); |
|
1941 } |
|
1942 else if ( KNSmlDMNATFWValueFalse() == aObject ) |
|
1943 { |
|
1944 iNATFWDomainEntries->At( domainLoc )-> |
|
1945 SetDisableStunSharedSecret( ETrue ); |
|
1946 } |
|
1947 else |
|
1948 { |
|
1949 status = CSmlDmAdapter::EInvalidObject; |
|
1950 } |
|
1951 } |
|
1952 // DomainSpecific/<x>/PortPoolStartPort |
|
1953 else if ( KNSmlDMPortPoolStart() == lastURISeg |
|
1954 && KFourSegs == uriSegs ) |
|
1955 { |
|
1956 iNATFWDomainEntries->At( domainLoc )-> |
|
1957 SetStartPortRange( DesToInt( aObject ) ); |
|
1958 } |
|
1959 // DomainSpecific/<x>/PortPoolEndPort |
|
1960 else if ( KNSmlDMPortPoolEnd() == lastURISeg |
|
1961 && KFourSegs == uriSegs ) |
|
1962 { |
|
1963 iNATFWDomainEntries->At( domainLoc )-> |
|
1964 SetEndPortRange( DesToInt( aObject ) ); |
|
1965 } |
|
1966 // DomainSpecific/<x>/UsedNATProtocol |
|
1967 else if ( KNSmlDMUsedNatProtocol() == lastURISeg |
|
1968 && KFourSegs == uriSegs ) |
|
1969 { |
|
1970 iNATFWDomainEntries->At( domainLoc )-> |
|
1971 SetNatProtocolL( aObject ); |
|
1972 } |
|
1973 |
|
1974 // DomainSpecific/<x>/ICESpecific/NATUtilities |
|
1975 else if ( KNSmlDMNatUtilities() == lastURISeg |
|
1976 && iceSpecific ) |
|
1977 { |
|
1978 iNATFWDomainEntries->At( domainLoc )-> |
|
1979 SetNatUtilitiesL( aObject ); |
|
1980 } |
|
1981 // DomainSpecific/<x>/ICESpecific/HostPreference |
|
1982 else if ( KNSmlDMHostPref() == lastURISeg |
|
1983 && iceSpecific ) |
|
1984 { |
|
1985 iNATFWDomainEntries->At( domainLoc )-> |
|
1986 SetHostPref( DesToInt( aObject ) ); |
|
1987 } |
|
1988 |
|
1989 // DomainSpecific/<x>/ICESpecific/ServerReflexivePreference |
|
1990 else if ( KNSmlDMServerReflexPref() == lastURISeg |
|
1991 && iceSpecific ) |
|
1992 { |
|
1993 iNATFWDomainEntries->At( domainLoc )-> |
|
1994 SetServerReflexPref( DesToInt( aObject ) ); |
|
1995 } |
|
1996 |
|
1997 // DomainSpecific/<x>/ICESpecific/RelayPreference |
|
1998 else if ( KNSmlDMRelayPref() == lastURISeg |
|
1999 && iceSpecific ) |
|
2000 { |
|
2001 iNATFWDomainEntries->At( domainLoc )-> |
|
2002 SetRelayPref( DesToInt( aObject ) ); |
|
2003 } |
|
2004 |
|
2005 // DomainSpecific/<x>/ICESpecific/PeerReflexivePreference |
|
2006 else if ( KNSmlDMPeerReflexPref() == lastURISeg |
|
2007 && iceSpecific ) |
|
2008 { |
|
2009 iNATFWDomainEntries->At( domainLoc )-> |
|
2010 SetPeerReflexPref( DesToInt( aObject ) ); |
|
2011 } |
|
2012 |
|
2013 // DomainSpecific/<x>/ICESpecific/IPv4Preference |
|
2014 else if ( KNSmlDMIPv4Pref() == lastURISeg |
|
2015 && iceSpecific ) |
|
2016 { |
|
2017 iNATFWDomainEntries->At( domainLoc )-> |
|
2018 SetIPv4Pref( DesToInt( aObject ) ); |
|
2019 } |
|
2020 |
|
2021 // DomainSpecific/<x>/ICESpecific/IPv6Preference |
|
2022 else if ( KNSmlDMIPv6Pref() == lastURISeg |
|
2023 && iceSpecific ) |
|
2024 { |
|
2025 iNATFWDomainEntries->At( domainLoc )-> |
|
2026 SetIPv6Pref( DesToInt( aObject ) ); |
|
2027 } |
|
2028 |
|
2029 // DomainSpecific/<x>/ICESpecific/VPNPreference |
|
2030 else if ( KNSmlDMVpnPref() == lastURISeg |
|
2031 && iceSpecific ) |
|
2032 { |
|
2033 iNATFWDomainEntries->At( domainLoc )-> |
|
2034 SetVpnPref( DesToInt( aObject ) ); |
|
2035 } |
|
2036 |
|
2037 // DomainSpecific/<x>/ICESpecific/UDPPreference |
|
2038 else if ( KNSmlDMUdpPref() == lastURISeg |
|
2039 && iceSpecific ) |
|
2040 { |
|
2041 iNATFWDomainEntries->At( domainLoc )-> |
|
2042 SetUdpPref( DesToInt( aObject ) ); |
|
2043 } |
|
2044 |
|
2045 // DomainSpecific/<x>/ICESpecific/TCPPreference |
|
2046 else if ( KNSmlDMTcpPref() == lastURISeg |
|
2047 && iceSpecific ) |
|
2048 { |
|
2049 iNATFWDomainEntries->At( domainLoc )-> |
|
2050 SetTcpPref( DesToInt( aObject ) ); |
|
2051 } |
|
2052 |
|
2053 // DomainSpecific/<x>/ICESpecific/TCPActivePreference |
|
2054 else if ( KNSmlDMTcpActivePref() == lastURISeg |
|
2055 && iceSpecific ) |
|
2056 { |
|
2057 iNATFWDomainEntries->At( domainLoc )-> |
|
2058 SetTcpActivePref( DesToInt( aObject ) ); |
|
2059 } |
|
2060 |
|
2061 // DomainSpecific/<x>/ICESpecific/TCPPassivePreference |
|
2062 else if ( KNSmlDMTcpPassivePref() == lastURISeg |
|
2063 && iceSpecific ) |
|
2064 { |
|
2065 iNATFWDomainEntries->At( domainLoc )-> |
|
2066 SetTcpPassivePref( DesToInt( aObject ) ); |
|
2067 } |
|
2068 |
|
2069 // DomainSpecific/<x>/ICESpecific/TCPSimultaneousPreference |
|
2070 else if ( KNSmlDMTcpSimultPref() == lastURISeg |
|
2071 && iceSpecific ) |
|
2072 { |
|
2073 iNATFWDomainEntries->At( domainLoc )-> |
|
2074 SetTcpSimultPref( DesToInt( aObject ) ); |
|
2075 } |
|
2076 |
|
2077 else |
|
2078 { |
|
2079 status = CSmlDmAdapter::ENotFound; |
|
2080 } |
|
2081 |
|
2082 if ( KErrNone != err ) |
|
2083 { |
|
2084 status = CSmlDmAdapter::EError; |
|
2085 } |
|
2086 |
|
2087 // append command to buffered commands if it was made ok |
|
2088 if ( EOk == status ) |
|
2089 { |
|
2090 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
2091 } |
|
2092 |
|
2093 return status; |
|
2094 } |
|
2095 |
|
2096 // --------------------------------------------------------------------------- |
|
2097 // CNSmlDmNATFWTraversalAdapter::UpdateIAPSpecificObjectL |
|
2098 // |
|
2099 // --------------------------------------------------------------------------- |
|
2100 // |
|
2101 CSmlDmAdapter::TError CNSmlDmNATFWTraversalAdapter::UpdateIAPSpecificObjectL( |
|
2102 const TDesC8& aURI, |
|
2103 const TDesC8& aLUID, |
|
2104 const TDesC8& aObject, |
|
2105 const TInt aStatusRef ) |
|
2106 { |
|
2107 CSmlDmAdapter::TError status = EOk; |
|
2108 |
|
2109 TInt iapLoc = FindIAPLocation( aLUID ); |
|
2110 if ( KErrNotFound == iapLoc ) |
|
2111 { |
|
2112 status = CSmlDmAdapter::ENotFound; |
|
2113 return status; |
|
2114 } |
|
2115 |
|
2116 TDMNATFWStatusInfo statusInfo; |
|
2117 statusInfo.iKeyId = iNATFWIAPEntries->At( iapLoc )->GetIAPKey(); |
|
2118 statusInfo.iStatusRef = aStatusRef; |
|
2119 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMUpdateIAP; |
|
2120 |
|
2121 TPtrC8 lastURISeg = LastURISeg( aURI ); |
|
2122 |
|
2123 // PrefConRef |
|
2124 if ( KNSmlDMNATPrefConRef() == lastURISeg ) |
|
2125 { |
|
2126 |
|
2127 // IAP-nbr from CommsDB |
|
2128 TInt lIAPId = SetConRefL( aObject, iapLoc ); |
|
2129 if ( KErrNotFound != lIAPId ) |
|
2130 { |
|
2131 status = CSmlDmAdapter::EOk; |
|
2132 } |
|
2133 else |
|
2134 { |
|
2135 status = CSmlDmAdapter::EInvalidObject; |
|
2136 } |
|
2137 } |
|
2138 else if ( KNSmlDMNATRefreshTCP() == lastURISeg ) |
|
2139 { |
|
2140 iNATFWIAPEntries->At( iapLoc )-> |
|
2141 SetIntervalTCP( DesToInt( aObject ) ); |
|
2142 } |
|
2143 else if ( KNSmlDMNATRefreshUDP() == lastURISeg ) |
|
2144 { |
|
2145 iNATFWIAPEntries->At( iapLoc )-> |
|
2146 SetIntervalUDP( DesToInt( aObject ) ); |
|
2147 } |
|
2148 else if ( KNSmlDMSTUNRetransmit() == lastURISeg ) |
|
2149 { |
|
2150 iNATFWIAPEntries->At( iapLoc )-> |
|
2151 SetSTUNRetransmitTimer( DesToInt( aObject ) ); |
|
2152 } |
|
2153 else |
|
2154 { |
|
2155 // none of iap specific settings found |
|
2156 status = CSmlDmAdapter::ENotFound; |
|
2157 } |
|
2158 |
|
2159 // append command to buffered commands if it was made ok |
|
2160 if ( EOk == status ) |
|
2161 { |
|
2162 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
2163 } |
|
2164 |
|
2165 return status; |
|
2166 } |
|
2167 |
|
2168 // --------------------------------------------------------------------------- |
|
2169 // CNSmlDmNATFWTraversalAdapter::UpdateAdditionalSTUNServerObjectL |
|
2170 // |
|
2171 // --------------------------------------------------------------------------- |
|
2172 // |
|
2173 CSmlDmAdapter::TError |
|
2174 CNSmlDmNATFWTraversalAdapter::UpdateAdditionalSTUNServerObjectL( |
|
2175 const TDesC8& aURI, |
|
2176 const TDesC8& aLUID, |
|
2177 const TDesC8& aObject, |
|
2178 const TInt aStatusRef ) |
|
2179 { |
|
2180 CSmlDmAdapter::TError status = EOk; |
|
2181 |
|
2182 TUint32 stunKey = DesToInt( LastURISeg( aLUID ) ); |
|
2183 |
|
2184 // STUN key is zero, i.e. false LUID |
|
2185 if ( KErrNone == stunKey ) |
|
2186 { |
|
2187 status = CSmlDmAdapter::ENotFound; |
|
2188 iDmCallback->SetStatusL( aStatusRef, status ); |
|
2189 return status; |
|
2190 } |
|
2191 |
|
2192 TBuf8<KLUIDMaxLength> luid( aLUID ); |
|
2193 TPtrC8 tmpLuid = RemoveLastURISeg( luid ); |
|
2194 TPtrC8 domainLuid = RemoveLastURISeg( tmpLuid ); |
|
2195 TInt domainLoc = FindDomainLocation( domainLuid ); |
|
2196 |
|
2197 if ( KErrNotFound == domainLoc ) |
|
2198 { |
|
2199 status = CSmlDmAdapter::ENotFound; |
|
2200 return status; |
|
2201 } |
|
2202 |
|
2203 TDMNATFWStatusInfo statusInfo; |
|
2204 statusInfo.iKeyId = stunKey; |
|
2205 statusInfo.iStatusRef = aStatusRef; |
|
2206 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMUpdateSTUN; |
|
2207 statusInfo.iLocation = domainLoc; |
|
2208 |
|
2209 TUint32 domainKey = iNATFWDomainEntries->At( domainLoc )-> |
|
2210 GetDomainKey(); |
|
2211 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
2212 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
2213 RArray<TUint32> stunKeys; |
|
2214 CleanupClosePushL( stunKeys ); // CS:1 |
|
2215 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:2 |
|
2216 rep->FindL( domainKey|KUNSAFProtocolsSTUNAddressMask, |
|
2217 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
2218 CleanupStack::PopAndDestroy( rep ); // CS:1 |
|
2219 TInt stunLoc( KErrNotFound ); |
|
2220 TInt stunCount( stunKeys.Count() ); |
|
2221 for ( TInt counter = 0; counter < stunCount; counter++ ) |
|
2222 { |
|
2223 if ( stunKey == stunKeys[counter] ) |
|
2224 { |
|
2225 stunLoc = counter; |
|
2226 } |
|
2227 } |
|
2228 stunKeys.Close(); |
|
2229 CleanupStack::PopAndDestroy( &stunKeys ); // CS:0 |
|
2230 |
|
2231 TPtrC8 lastURISeg = LastURISeg( aURI ); |
|
2232 |
|
2233 // STUN key was not in CentRep. |
|
2234 if ( KErrNotFound == stunLoc ) |
|
2235 { |
|
2236 status = CSmlDmAdapter::ENotFound; |
|
2237 } |
|
2238 // STUN key was in CentRep index 0 which is reserved for STUN |
|
2239 // settings directly under DomainSpecific node. |
|
2240 else if ( KErrNone == stunLoc ) |
|
2241 { |
|
2242 status = CSmlDmAdapter::EError; |
|
2243 } |
|
2244 // Update values. |
|
2245 else |
|
2246 { |
|
2247 TInt err( KErrNone ); |
|
2248 |
|
2249 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNSrvAddr |
|
2250 if ( KNSmlDMSTUNSrvAddr() == lastURISeg ) |
|
2251 { |
|
2252 err = iNATFWDomainEntries->At( domainLoc )-> |
|
2253 UpdateStunSrvAddrL( stunLoc, aObject ); |
|
2254 } |
|
2255 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNSrvPort |
|
2256 else if ( KNSmlDMSTUNSrvPort() == lastURISeg ) |
|
2257 { |
|
2258 err = iNATFWDomainEntries->At( domainLoc )-> |
|
2259 UpdateStunSrvPort( stunLoc, DesToInt( aObject ) ); |
|
2260 } |
|
2261 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNUsername |
|
2262 else if ( KNSmlDMSTUNUsername() == lastURISeg ) |
|
2263 { |
|
2264 err = iNATFWDomainEntries->At( domainLoc )-> |
|
2265 UpdateStunUsernameL( stunLoc, aObject ); |
|
2266 } |
|
2267 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNPassword |
|
2268 else if ( KNSmlDMSTUNPassword() == lastURISeg ) |
|
2269 { |
|
2270 err = iNATFWDomainEntries->At( domainLoc )-> |
|
2271 UpdateStunPasswordL( stunLoc, aObject ); |
|
2272 } |
|
2273 else |
|
2274 { |
|
2275 // None of AdditionalSTUNServer settings found. |
|
2276 status = CSmlDmAdapter::ENotFound; |
|
2277 } |
|
2278 |
|
2279 if ( KErrNone != err ) |
|
2280 { |
|
2281 status = CSmlDmAdapter::EError; |
|
2282 } |
|
2283 } |
|
2284 |
|
2285 // Append command to buffered commands if it was made ok. |
|
2286 if ( EOk == status ) |
|
2287 { |
|
2288 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
2289 } |
|
2290 |
|
2291 return status; |
|
2292 } |
|
2293 |
|
2294 // --------------------------------------------------------------------------- |
|
2295 // CNSmlDmNATFWTraversalAdapter::UpdateTURNServerObjectL |
|
2296 // |
|
2297 // --------------------------------------------------------------------------- |
|
2298 // |
|
2299 CSmlDmAdapter::TError |
|
2300 CNSmlDmNATFWTraversalAdapter::UpdateTURNServerObjectL( |
|
2301 const TDesC8& aURI, |
|
2302 const TDesC8& aLUID, |
|
2303 const TDesC8& aObject, |
|
2304 const TInt aStatusRef ) |
|
2305 { |
|
2306 CSmlDmAdapter::TError status = EOk; |
|
2307 |
|
2308 TUint32 turnKey = DesToInt( LastURISeg( aLUID ) ); |
|
2309 |
|
2310 // TURN key is zero, i.e. false LUID |
|
2311 if ( KErrNone == turnKey ) |
|
2312 { |
|
2313 status = CSmlDmAdapter::ENotFound; |
|
2314 return status; |
|
2315 } |
|
2316 |
|
2317 TBuf8<KLUIDMaxLength> luid( aLUID ); |
|
2318 TPtrC8 tmpLuid = RemoveLastURISeg( luid ); |
|
2319 TPtrC8 domainLuid = RemoveLastURISeg( RemoveLastURISeg( tmpLuid ) ); |
|
2320 TInt domainLoc = FindDomainLocation( domainLuid ); |
|
2321 |
|
2322 if ( KErrNotFound == domainLoc ) |
|
2323 { |
|
2324 status = CSmlDmAdapter::ENotFound; |
|
2325 return status; |
|
2326 } |
|
2327 |
|
2328 TDMNATFWStatusInfo statusInfo; |
|
2329 statusInfo.iKeyId = turnKey; |
|
2330 statusInfo.iStatusRef = aStatusRef; |
|
2331 statusInfo.iCommandType = TDMNATFWStatusInfo::EDMUpdateTURN; |
|
2332 statusInfo.iLocation = domainLoc; |
|
2333 |
|
2334 TUint32 domainKey = iNATFWDomainEntries->At( domainLoc )-> |
|
2335 GetDomainKey(); |
|
2336 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
2337 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
2338 RArray<TUint32> turnKeys; |
|
2339 CleanupClosePushL( turnKeys ); // CS:1 |
|
2340 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:2 |
|
2341 rep->FindL( domainKey|KUNSAFProtocolsTURNAddressMask, |
|
2342 KUNSAFProtocolsSubTableFieldTypeMask, turnKeys ); |
|
2343 CleanupStack::PopAndDestroy( rep ); // CS:1 |
|
2344 TInt turnLoc( KErrNotFound ); |
|
2345 TInt turnCount( turnKeys.Count() ); |
|
2346 for ( TInt counter = 0; counter < turnCount; counter++ ) |
|
2347 { |
|
2348 if ( turnKey == turnKeys[counter] ) |
|
2349 { |
|
2350 turnLoc = counter; |
|
2351 } |
|
2352 } |
|
2353 turnKeys.Close(); |
|
2354 CleanupStack::PopAndDestroy( &turnKeys ); // CS:0 |
|
2355 |
|
2356 TPtrC8 lastURISeg = LastURISeg( aURI ); |
|
2357 |
|
2358 // TURN key was not in CentRep. |
|
2359 if ( KErrNotFound == turnLoc ) |
|
2360 { |
|
2361 status = CSmlDmAdapter::ENotFound; |
|
2362 } |
|
2363 // Update values. |
|
2364 else |
|
2365 { |
|
2366 TInt err( KErrNone ); |
|
2367 |
|
2368 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/TURNSrvAddr |
|
2369 if ( KNSmlDMTURNSrvAddr() == lastURISeg ) |
|
2370 { |
|
2371 err = iNATFWDomainEntries->At( domainLoc )-> |
|
2372 UpdateTurnSrvAddrL( turnLoc, aObject ); |
|
2373 } |
|
2374 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/TURNSrvPort |
|
2375 else if ( KNSmlDMTURNSrvPort() == lastURISeg ) |
|
2376 { |
|
2377 err = iNATFWDomainEntries->At( domainLoc )-> |
|
2378 UpdateTurnSrvPort( turnLoc, DesToInt( aObject ) ); |
|
2379 } |
|
2380 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/TURNUsername |
|
2381 else if ( KNSmlDMTURNUsername() == lastURISeg ) |
|
2382 { |
|
2383 err = iNATFWDomainEntries->At( domainLoc )-> |
|
2384 UpdateTurnUsernameL( turnLoc, aObject ); |
|
2385 } |
|
2386 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/TURNPassword |
|
2387 else if ( KNSmlDMTURNPassword() == lastURISeg ) |
|
2388 { |
|
2389 err = iNATFWDomainEntries->At( domainLoc )-> |
|
2390 UpdateTurnPasswordL( turnLoc, aObject ); |
|
2391 } |
|
2392 else |
|
2393 { |
|
2394 // None of TURNServer settings found. |
|
2395 status = CSmlDmAdapter::ENotFound; |
|
2396 } |
|
2397 |
|
2398 if ( KErrNone != err ) |
|
2399 { |
|
2400 status = CSmlDmAdapter::EError; |
|
2401 } |
|
2402 } |
|
2403 |
|
2404 // Append command to buffered commands if it was made ok. |
|
2405 if ( EOk == status ) |
|
2406 { |
|
2407 iNATFWCommandBuffer.AppendL( statusInfo ); |
|
2408 } |
|
2409 |
|
2410 return status; |
|
2411 } |
|
2412 |
|
2413 // --------------------------------------------------------------------------- |
|
2414 // CNSmlDmNATFWTraversalAdapter::DomainChildURIListL |
|
2415 // Lists the Domain specific children of the node. |
|
2416 // --------------------------------------------------------------------------- |
|
2417 // |
|
2418 CSmlDmAdapter::TError CNSmlDmNATFWTraversalAdapter::DomainChildURIListL( |
|
2419 const TDesC8& aURI, |
|
2420 const TDesC8& aLUID, |
|
2421 CBufBase* const aURISegmentList, |
|
2422 const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList ) |
|
2423 { |
|
2424 __ASSERT_ALWAYS( aURISegmentList != NULL, User::Leave( KErrArgument ) ); |
|
2425 |
|
2426 // get needed URI segments. |
|
2427 TBuf8<KSmlMaxURISegLen> segment = LastURISeg( aURI ); |
|
2428 TBuf8<KSmlMaxURISegLen> segmentName; |
|
2429 TPtrC8 uriTmp = RemoveLastURISeg( aURI ); |
|
2430 TPtrC8 secondLastUriSeg = LastURISeg( uriTmp ); |
|
2431 |
|
2432 TBuf8<KNSmlNATFWMaxUriLength> mappingInfo( KNullDesC8 ); |
|
2433 TBuf8<KNSmlNATFWMaxUriLength> uri = aURI; |
|
2434 |
|
2435 // Central Repository for NAT-FW Traversal settings |
|
2436 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
2437 |
|
2438 if ( KNSmlDMDomainSpecificNodeName() == segment ) |
|
2439 { |
|
2440 TInt domainCount( 0 ); |
|
2441 if ( iNATFWDomainEntries ) |
|
2442 { |
|
2443 domainCount = iNATFWDomainEntries->Count(); |
|
2444 } |
|
2445 for ( TInt counter = 0; counter < domainCount ; counter++ ) |
|
2446 { |
|
2447 TBool inList = EFalse; |
|
2448 TInt currentline = 0; |
|
2449 TUint32 ddId ( iNATFWDomainEntries->At( |
|
2450 counter )->GetDomainKey() ); |
|
2451 while ( !inList && currentline < aPreviousURISegmentList.Count() ) |
|
2452 { |
|
2453 TInt profileLocation = FindDomainLocation ( DesToInt( |
|
2454 LastURISeg( aPreviousURISegmentList. |
|
2455 At( currentline ).iURISegLUID ) ) ); |
|
2456 if ( profileLocation != KErrNotFound ) |
|
2457 { |
|
2458 TUint32 profileID ( iNATFWDomainEntries-> |
|
2459 At( profileLocation )->GetDomainKey() ); |
|
2460 if ( profileID == ddId ) |
|
2461 { |
|
2462 inList = ETrue; |
|
2463 break; |
|
2464 } |
|
2465 } |
|
2466 currentline++; |
|
2467 } |
|
2468 if ( !inList ) |
|
2469 { |
|
2470 |
|
2471 // Use domain key as run-time node. |
|
2472 segmentName.Num( iNATFWDomainEntries-> |
|
2473 At( counter )->GetDomainKey() ); |
|
2474 aURISegmentList->InsertL( aURISegmentList-> |
|
2475 Size(), segmentName ); |
|
2476 aURISegmentList->InsertL( aURISegmentList-> |
|
2477 Size(), KNSmlDMNATFWSeparator ); |
|
2478 |
|
2479 // Set LUID mapping to DM module. |
|
2480 mappingInfo.Copy( KNSmlDMDomainSpecificNodeName ); |
|
2481 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
2482 mappingInfo.AppendNum( iNATFWDomainEntries-> |
|
2483 At( counter )->GetDomainKey() ); |
|
2484 uri.Copy( KNSmlDMNATFWNodeName ); |
|
2485 uri.Append( KNSmlDMNATFWSeparator ); |
|
2486 uri.Append( KNSmlDMDomainSpecificNodeName ); |
|
2487 uri.Append( KNSmlDMNATFWSeparator ); |
|
2488 uri.AppendNum( iNATFWDomainEntries-> |
|
2489 At( counter )->GetDomainKey() ); |
|
2490 iDmCallback->SetMappingL( uri, mappingInfo ); |
|
2491 } |
|
2492 else |
|
2493 { // Add those in PreviousList which are on database. |
|
2494 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
2495 aPreviousURISegmentList.At( currentline ).iURISeg ); |
|
2496 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
2497 KNSmlDMNATFWSeparator ); |
|
2498 } |
|
2499 } |
|
2500 } |
|
2501 |
|
2502 // ============================== |
|
2503 // DomainSpecific/<x>/ |
|
2504 // ============================== |
|
2505 // |
|
2506 else if ( KThreeSegs == NumOfURISegs( aURI ) && |
|
2507 KNSmlDMDomainSpecificNodeName() == secondLastUriSeg |
|
2508 && aLUID.Length() ) |
|
2509 { |
|
2510 segmentName.Copy( KNSmlDMDomain ); |
|
2511 aURISegmentList->InsertL( aURISegmentList-> |
|
2512 Size(), segmentName ); |
|
2513 aURISegmentList->InsertL( aURISegmentList-> |
|
2514 Size(), KNSmlDMNATFWSeparator ); |
|
2515 |
|
2516 segmentName.Copy( KNSmlDMSTUNSrvAddr ); |
|
2517 aURISegmentList->InsertL( aURISegmentList-> |
|
2518 Size(), segmentName ); |
|
2519 aURISegmentList->InsertL( aURISegmentList-> |
|
2520 Size(), KNSmlDMNATFWSeparator ); |
|
2521 |
|
2522 segmentName.Copy( KNSmlDMSTUNSrvPort ); |
|
2523 aURISegmentList->InsertL( aURISegmentList-> |
|
2524 Size(), segmentName ); |
|
2525 aURISegmentList->InsertL( aURISegmentList-> |
|
2526 Size(), KNSmlDMNATFWSeparator ); |
|
2527 |
|
2528 segmentName.Copy( KNSmlDMSTUNUsername ); |
|
2529 aURISegmentList->InsertL( aURISegmentList-> |
|
2530 Size(), segmentName ); |
|
2531 aURISegmentList->InsertL( aURISegmentList-> |
|
2532 Size(), KNSmlDMNATFWSeparator ); |
|
2533 |
|
2534 segmentName.Copy( KNSmlDMSTUNPassword ); |
|
2535 aURISegmentList->InsertL( aURISegmentList-> |
|
2536 Size(), segmentName ); |
|
2537 aURISegmentList->InsertL( aURISegmentList-> |
|
2538 Size(), KNSmlDMNATFWSeparator ); |
|
2539 |
|
2540 segmentName.Copy( KNSmlDMDomainNATRefreshTCP ); |
|
2541 aURISegmentList->InsertL( aURISegmentList-> |
|
2542 Size(), segmentName ); |
|
2543 aURISegmentList->InsertL( aURISegmentList-> |
|
2544 Size(), KNSmlDMNATFWSeparator ); |
|
2545 |
|
2546 segmentName.Copy( KNSmlDMDomainNATRefreshUDP ); |
|
2547 aURISegmentList->InsertL( aURISegmentList-> |
|
2548 Size(), segmentName ); |
|
2549 aURISegmentList->InsertL( aURISegmentList-> |
|
2550 Size(), KNSmlDMNATFWSeparator ); |
|
2551 |
|
2552 segmentName.Copy( KNSmlDMDomainEnableCRLFRefresh ); |
|
2553 aURISegmentList->InsertL( aURISegmentList-> |
|
2554 Size(), segmentName ); |
|
2555 aURISegmentList->InsertL( aURISegmentList-> |
|
2556 Size(), KNSmlDMNATFWSeparator ); |
|
2557 |
|
2558 segmentName.Copy( KNSmlDMAdditionalSTUNNodeName ); |
|
2559 aURISegmentList->InsertL( aURISegmentList-> |
|
2560 Size(), segmentName ); |
|
2561 aURISegmentList->InsertL( aURISegmentList-> |
|
2562 Size(), KNSmlDMNATFWSeparator ); |
|
2563 |
|
2564 segmentName.Copy( KNSmlDMSTUNSharedSecret ); |
|
2565 aURISegmentList->InsertL( aURISegmentList-> |
|
2566 Size(), segmentName ); |
|
2567 aURISegmentList->InsertL( aURISegmentList-> |
|
2568 Size(), KNSmlDMNATFWSeparator ); |
|
2569 |
|
2570 segmentName.Copy( KNSmlDMPortPoolStart ); |
|
2571 aURISegmentList->InsertL( aURISegmentList-> |
|
2572 Size(), segmentName ); |
|
2573 aURISegmentList->InsertL( aURISegmentList-> |
|
2574 Size(), KNSmlDMNATFWSeparator ); |
|
2575 |
|
2576 segmentName.Copy( KNSmlDMPortPoolEnd ); |
|
2577 aURISegmentList->InsertL( aURISegmentList-> |
|
2578 Size(), segmentName ); |
|
2579 aURISegmentList->InsertL( aURISegmentList-> |
|
2580 Size(), KNSmlDMNATFWSeparator ); |
|
2581 |
|
2582 segmentName.Copy( KNSmlDMUsedNatProtocol ); |
|
2583 aURISegmentList->InsertL( aURISegmentList-> |
|
2584 Size(), segmentName ); |
|
2585 aURISegmentList->InsertL( aURISegmentList-> |
|
2586 Size(), KNSmlDMNATFWSeparator ); |
|
2587 |
|
2588 segmentName.Copy( KNSmlDMICESpecificNodeName ); |
|
2589 aURISegmentList->InsertL( aURISegmentList-> |
|
2590 Size(), segmentName ); |
|
2591 aURISegmentList->InsertL( aURISegmentList-> |
|
2592 Size(), KNSmlDMNATFWSeparator ); |
|
2593 |
|
2594 segmentName.Copy( KNSmlDMTURNSpecificNodeName ); |
|
2595 aURISegmentList->InsertL( aURISegmentList-> |
|
2596 Size(), segmentName ); |
|
2597 aURISegmentList->InsertL( aURISegmentList-> |
|
2598 Size(), KNSmlDMNATFWSeparator ); |
|
2599 } |
|
2600 |
|
2601 // ============================== |
|
2602 // AdditionalSTUNServer |
|
2603 // ============================== |
|
2604 // |
|
2605 else if ( KFourSegs == NumOfURISegs( aURI ) && |
|
2606 KNSmlDMAdditionalSTUNNodeName() == segment |
|
2607 && aLUID.Length() ) |
|
2608 { |
|
2609 TInt domainLoc( KErrNotFound ); |
|
2610 |
|
2611 if ( KFourSegs == NumOfURISegs( aLUID ) ) |
|
2612 { |
|
2613 TPtrC8 tmpLuid = RemoveLastURISeg( aLUID ); |
|
2614 TPtrC8 domainLuid = RemoveLastURISeg( tmpLuid ); |
|
2615 domainLoc = FindDomainLocation( domainLuid ); |
|
2616 } |
|
2617 else if ( KTwoSegs == NumOfURISegs( aLUID ) ) |
|
2618 { |
|
2619 domainLoc = FindDomainLocation( aLUID ); |
|
2620 } |
|
2621 |
|
2622 if ( KErrNotFound == domainLoc ) |
|
2623 { |
|
2624 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
2625 return ENotFound; |
|
2626 } |
|
2627 |
|
2628 RArray<TUint32> stunKeys; |
|
2629 CleanupClosePushL( stunKeys ); // CS:2 |
|
2630 |
|
2631 TUint32 domainKey = iNATFWDomainEntries->At( |
|
2632 domainLoc )->GetDomainKey(); |
|
2633 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
2634 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
2635 rep->FindL( KUNSAFProtocolsSTUNAddressMask|domainKey, |
|
2636 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
2637 |
|
2638 const TInt stunServerCount( stunKeys.Count() ); |
|
2639 |
|
2640 // First CentRep key is reserved for STUN settings directly under |
|
2641 // DomainSpecific node so counter starts from 1. |
|
2642 for ( TInt counter = 1; counter < stunServerCount; counter++ ) |
|
2643 { |
|
2644 TInt prevUriSegListCount( aPreviousURISegmentList.Count() ); |
|
2645 TBool inList( EFalse ); |
|
2646 TInt currentLine( 0 ); |
|
2647 while ( !inList && currentLine < prevUriSegListCount ) |
|
2648 { |
|
2649 TUint32 lastSeg = DesToInt( LastURISeg( |
|
2650 aPreviousURISegmentList.At( currentLine ).iURISegLUID ) ); |
|
2651 if ( lastSeg == stunKeys[counter] ) |
|
2652 { |
|
2653 inList = ETrue; |
|
2654 break; |
|
2655 } |
|
2656 currentLine++; |
|
2657 } |
|
2658 if ( !inList ) |
|
2659 { |
|
2660 // Use AdditionalSTUNServer/STUNSrvAddr key as run-time node. |
|
2661 segmentName.Num( stunKeys[counter] ); |
|
2662 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
2663 segmentName ); |
|
2664 aURISegmentList->InsertL( aURISegmentList-> |
|
2665 Size(), KNSmlDMNATFWSeparator ); |
|
2666 |
|
2667 // Set LUID mapping to DM module. |
|
2668 mappingInfo.Copy( KNSmlDMDomainSpecificNodeName ); |
|
2669 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
2670 mappingInfo.AppendNum( domainKey|KUNSAFProtocolsDomainMask ); |
|
2671 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
2672 mappingInfo.Append( KNSmlDMAdditionalSTUNNodeName ); |
|
2673 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
2674 // STUNSrvAddr key is used as LUID. |
|
2675 mappingInfo.AppendNum( stunKeys[counter] ); |
|
2676 uri.Copy( aURI ); |
|
2677 uri.Append( KNSmlDMNATFWSeparator ); |
|
2678 uri.AppendNum ( stunKeys[counter] ); |
|
2679 iDmCallback->SetMappingL( uri, mappingInfo ); |
|
2680 } |
|
2681 else |
|
2682 { |
|
2683 // Add the one in aPreviousURISegmentList into |
|
2684 // aURISegmentList. |
|
2685 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
2686 aPreviousURISegmentList.At( currentLine ).iURISeg ); |
|
2687 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
2688 KNSmlDMNATFWSeparator ); |
|
2689 } |
|
2690 } |
|
2691 stunKeys.Close(); |
|
2692 CleanupStack::PopAndDestroy( &stunKeys ); // CS:1 |
|
2693 } |
|
2694 |
|
2695 // ============================== |
|
2696 // AdditionalSTUNServer/<x> |
|
2697 // ============================== |
|
2698 // |
|
2699 else if ( KFiveSegs == NumOfURISegs( aURI ) && |
|
2700 KNSmlDMAdditionalSTUNNodeName() == secondLastUriSeg |
|
2701 && aLUID.Length() ) |
|
2702 { |
|
2703 segmentName.Copy( KNSmlDMSTUNSrvAddr ); |
|
2704 aURISegmentList->InsertL( aURISegmentList-> |
|
2705 Size(), segmentName ); |
|
2706 aURISegmentList->InsertL( aURISegmentList-> |
|
2707 Size(), KNSmlDMNATFWSeparator ); |
|
2708 |
|
2709 segmentName.Copy( KNSmlDMSTUNSrvPort ); |
|
2710 aURISegmentList->InsertL( aURISegmentList-> |
|
2711 Size(), segmentName ); |
|
2712 aURISegmentList->InsertL( aURISegmentList-> |
|
2713 Size(), KNSmlDMNATFWSeparator ); |
|
2714 |
|
2715 segmentName.Copy( KNSmlDMSTUNUsername ); |
|
2716 aURISegmentList->InsertL( aURISegmentList-> |
|
2717 Size(), segmentName ); |
|
2718 aURISegmentList->InsertL( aURISegmentList-> |
|
2719 Size(), KNSmlDMNATFWSeparator ); |
|
2720 |
|
2721 segmentName.Copy( KNSmlDMSTUNPassword ); |
|
2722 aURISegmentList->InsertL( aURISegmentList-> |
|
2723 Size(), segmentName ); |
|
2724 aURISegmentList->InsertL( aURISegmentList-> |
|
2725 Size(), KNSmlDMNATFWSeparator ); |
|
2726 |
|
2727 } |
|
2728 |
|
2729 // ============================== |
|
2730 // ICESpecific |
|
2731 // ============================== |
|
2732 // |
|
2733 else if ( KFourSegs == NumOfURISegs( aURI ) && |
|
2734 KNSmlDMICESpecificNodeName() == segment |
|
2735 && aLUID.Length() ) |
|
2736 { |
|
2737 segmentName.Copy( KNSmlDMNatUtilities ); |
|
2738 aURISegmentList->InsertL( aURISegmentList-> |
|
2739 Size(), segmentName ); |
|
2740 aURISegmentList->InsertL( aURISegmentList-> |
|
2741 Size(), KNSmlDMNATFWSeparator ); |
|
2742 |
|
2743 segmentName.Copy( KNSmlDMHostPref ); |
|
2744 aURISegmentList->InsertL( aURISegmentList-> |
|
2745 Size(), segmentName ); |
|
2746 aURISegmentList->InsertL( aURISegmentList-> |
|
2747 Size(), KNSmlDMNATFWSeparator ); |
|
2748 |
|
2749 segmentName.Copy( KNSmlDMServerReflexPref ); |
|
2750 aURISegmentList->InsertL( aURISegmentList-> |
|
2751 Size(), segmentName ); |
|
2752 aURISegmentList->InsertL( aURISegmentList-> |
|
2753 Size(), KNSmlDMNATFWSeparator ); |
|
2754 |
|
2755 segmentName.Copy( KNSmlDMRelayPref ); |
|
2756 aURISegmentList->InsertL( aURISegmentList-> |
|
2757 Size(), segmentName ); |
|
2758 aURISegmentList->InsertL( aURISegmentList-> |
|
2759 Size(), KNSmlDMNATFWSeparator ); |
|
2760 |
|
2761 segmentName.Copy( KNSmlDMPeerReflexPref ); |
|
2762 aURISegmentList->InsertL( aURISegmentList-> |
|
2763 Size(), segmentName ); |
|
2764 aURISegmentList->InsertL( aURISegmentList-> |
|
2765 Size(), KNSmlDMNATFWSeparator ); |
|
2766 |
|
2767 segmentName.Copy( KNSmlDMIPv4Pref ); |
|
2768 aURISegmentList->InsertL( aURISegmentList-> |
|
2769 Size(), segmentName ); |
|
2770 aURISegmentList->InsertL( aURISegmentList-> |
|
2771 Size(), KNSmlDMNATFWSeparator ); |
|
2772 |
|
2773 segmentName.Copy( KNSmlDMIPv6Pref ); |
|
2774 aURISegmentList->InsertL( aURISegmentList-> |
|
2775 Size(), segmentName ); |
|
2776 aURISegmentList->InsertL( aURISegmentList-> |
|
2777 Size(), KNSmlDMNATFWSeparator ); |
|
2778 |
|
2779 segmentName.Copy( KNSmlDMVpnPref ); |
|
2780 aURISegmentList->InsertL( aURISegmentList-> |
|
2781 Size(), segmentName ); |
|
2782 aURISegmentList->InsertL( aURISegmentList-> |
|
2783 Size(), KNSmlDMNATFWSeparator ); |
|
2784 |
|
2785 segmentName.Copy( KNSmlDMUdpPref ); |
|
2786 aURISegmentList->InsertL( aURISegmentList-> |
|
2787 Size(), segmentName ); |
|
2788 aURISegmentList->InsertL( aURISegmentList-> |
|
2789 Size(), KNSmlDMNATFWSeparator ); |
|
2790 |
|
2791 segmentName.Copy( KNSmlDMTcpPref ); |
|
2792 aURISegmentList->InsertL( aURISegmentList-> |
|
2793 Size(), segmentName ); |
|
2794 aURISegmentList->InsertL( aURISegmentList-> |
|
2795 Size(), KNSmlDMNATFWSeparator ); |
|
2796 |
|
2797 segmentName.Copy( KNSmlDMTcpActivePref ); |
|
2798 aURISegmentList->InsertL( aURISegmentList-> |
|
2799 Size(), segmentName ); |
|
2800 aURISegmentList->InsertL( aURISegmentList-> |
|
2801 Size(), KNSmlDMNATFWSeparator ); |
|
2802 |
|
2803 segmentName.Copy( KNSmlDMTcpPassivePref ); |
|
2804 aURISegmentList->InsertL( aURISegmentList-> |
|
2805 Size(), segmentName ); |
|
2806 aURISegmentList->InsertL( aURISegmentList-> |
|
2807 Size(), KNSmlDMNATFWSeparator ); |
|
2808 |
|
2809 segmentName.Copy( KNSmlDMTcpSimultPref ); |
|
2810 aURISegmentList->InsertL( aURISegmentList-> |
|
2811 Size(), segmentName ); |
|
2812 aURISegmentList->InsertL( aURISegmentList-> |
|
2813 Size(), KNSmlDMNATFWSeparator ); |
|
2814 } |
|
2815 |
|
2816 // ============================== |
|
2817 // TURNSpecific |
|
2818 // ============================== |
|
2819 // |
|
2820 else if ( KFourSegs == NumOfURISegs( aURI ) && |
|
2821 KNSmlDMTURNSpecificNodeName() == segment |
|
2822 && aLUID.Length() ) |
|
2823 { |
|
2824 segmentName.Copy( KNSmlDMTURNServerNodeName ); |
|
2825 aURISegmentList->InsertL( aURISegmentList-> |
|
2826 Size(), segmentName ); |
|
2827 aURISegmentList->InsertL( aURISegmentList-> |
|
2828 Size(), KNSmlDMNATFWSeparator ); |
|
2829 } |
|
2830 |
|
2831 // ============================== |
|
2832 // TURNSpecific/TURNServer |
|
2833 // ============================== |
|
2834 // |
|
2835 else if ( KFiveSegs == NumOfURISegs( aURI ) && |
|
2836 KNSmlDMTURNServerNodeName() == segment |
|
2837 && aLUID.Length() ) |
|
2838 { |
|
2839 TInt domainLoc( KErrNotFound ); |
|
2840 |
|
2841 if ( KFourSegs == NumOfURISegs( aLUID ) ) |
|
2842 { |
|
2843 TPtrC8 tmpLuid = RemoveLastURISeg( aLUID ); |
|
2844 TPtrC8 domainLuid = RemoveLastURISeg( tmpLuid ); |
|
2845 domainLoc = FindDomainLocation( domainLuid ); |
|
2846 } |
|
2847 else if ( KTwoSegs == NumOfURISegs( aLUID ) ) |
|
2848 { |
|
2849 domainLoc = FindDomainLocation( aLUID ); |
|
2850 } |
|
2851 |
|
2852 if ( KErrNotFound == domainLoc ) |
|
2853 { |
|
2854 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
2855 return ENotFound; |
|
2856 } |
|
2857 |
|
2858 RArray<TUint32> turnKeys; |
|
2859 CleanupClosePushL( turnKeys ); // CS:2 |
|
2860 |
|
2861 TUint32 domainKey = iNATFWDomainEntries->At( |
|
2862 domainLoc )->GetDomainKey(); |
|
2863 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
2864 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
2865 rep->FindL( KUNSAFProtocolsTURNAddressMask|domainKey, |
|
2866 KUNSAFProtocolsSubTableFieldTypeMask, turnKeys ); |
|
2867 |
|
2868 const TInt turnServerCount( turnKeys.Count() ); |
|
2869 |
|
2870 for ( TInt counter = 0; counter < turnServerCount; counter++ ) |
|
2871 { |
|
2872 TInt prevUriSegListCount( aPreviousURISegmentList.Count() ); |
|
2873 TBool inList( EFalse ); |
|
2874 TInt currentLine( 0 ); |
|
2875 while ( !inList && currentLine < prevUriSegListCount ) |
|
2876 { |
|
2877 TUint32 lastSeg = DesToInt( LastURISeg( |
|
2878 aPreviousURISegmentList.At( currentLine ).iURISegLUID ) ); |
|
2879 if ( lastSeg == turnKeys[counter] ) |
|
2880 { |
|
2881 inList = ETrue; |
|
2882 break; |
|
2883 } |
|
2884 currentLine++; |
|
2885 } |
|
2886 if ( !inList ) |
|
2887 { |
|
2888 // Use TURNSpecific/TURNServer/TURNSrvAddr key as run-time node. |
|
2889 segmentName.Num( turnKeys[counter] ); |
|
2890 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
2891 segmentName ); |
|
2892 aURISegmentList->InsertL( aURISegmentList-> |
|
2893 Size(), KNSmlDMNATFWSeparator ); |
|
2894 |
|
2895 // Set LUID mapping to DM module. |
|
2896 mappingInfo.Copy( KNSmlDMDomainSpecificNodeName ); |
|
2897 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
2898 mappingInfo.AppendNum( domainKey|KUNSAFProtocolsDomainMask ); |
|
2899 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
2900 mappingInfo.Append( KNSmlDMTURNSpecificNodeName ); |
|
2901 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
2902 mappingInfo.Append( KNSmlDMTURNServerNodeName ); |
|
2903 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
2904 // TURNSrvAddr key is used as LUID. |
|
2905 mappingInfo.AppendNum( turnKeys[counter] ); |
|
2906 uri.Copy( aURI ); |
|
2907 uri.Append( KNSmlDMNATFWSeparator ); |
|
2908 uri.AppendNum ( turnKeys[counter] ); |
|
2909 iDmCallback->SetMappingL( uri, mappingInfo ); |
|
2910 } |
|
2911 else |
|
2912 { |
|
2913 // Add the one in aPreviousURISegmentList into |
|
2914 // aURISegmentList. |
|
2915 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
2916 aPreviousURISegmentList.At( currentLine ).iURISeg ); |
|
2917 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
2918 KNSmlDMNATFWSeparator ); |
|
2919 } |
|
2920 } |
|
2921 turnKeys.Close(); |
|
2922 CleanupStack::PopAndDestroy( &turnKeys ); // CS:1 |
|
2923 } |
|
2924 |
|
2925 // ============================== |
|
2926 // TURNSpecific/TURNServer/<x> |
|
2927 // ============================== |
|
2928 // |
|
2929 else if ( KSixSegs == NumOfURISegs( aURI ) && |
|
2930 KNSmlDMTURNServerNodeName() == secondLastUriSeg && |
|
2931 KErrNotFound != aURI.Find( KNSmlDMTURNSpecificNodeName() ) && |
|
2932 aLUID.Length() ) |
|
2933 { |
|
2934 segmentName.Copy( KNSmlDMTURNSrvAddr ); |
|
2935 aURISegmentList->InsertL( aURISegmentList-> |
|
2936 Size(), segmentName ); |
|
2937 aURISegmentList->InsertL( aURISegmentList-> |
|
2938 Size(), KNSmlDMNATFWSeparator ); |
|
2939 |
|
2940 segmentName.Copy( KNSmlDMTURNSrvPort ); |
|
2941 aURISegmentList->InsertL( aURISegmentList-> |
|
2942 Size(), segmentName ); |
|
2943 aURISegmentList->InsertL( aURISegmentList-> |
|
2944 Size(), KNSmlDMNATFWSeparator ); |
|
2945 |
|
2946 segmentName.Copy( KNSmlDMTURNUsername ); |
|
2947 aURISegmentList->InsertL( aURISegmentList-> |
|
2948 Size(), segmentName ); |
|
2949 aURISegmentList->InsertL( aURISegmentList-> |
|
2950 Size(), KNSmlDMNATFWSeparator ); |
|
2951 |
|
2952 segmentName.Copy( KNSmlDMTURNPassword ); |
|
2953 aURISegmentList->InsertL( aURISegmentList-> |
|
2954 Size(), segmentName ); |
|
2955 aURISegmentList->InsertL( aURISegmentList-> |
|
2956 Size(), KNSmlDMNATFWSeparator ); |
|
2957 } |
|
2958 |
|
2959 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
2960 |
|
2961 // no errors |
|
2962 return EOk; |
|
2963 } |
|
2964 |
|
2965 // --------------------------------------------------------------------------- |
|
2966 // CNSmlDmNATFWTraversalAdapter::IAPChildURIListL |
|
2967 // Lists the IAP specific children of the node. |
|
2968 // --------------------------------------------------------------------------- |
|
2969 // |
|
2970 CSmlDmAdapter::TError CNSmlDmNATFWTraversalAdapter::IAPChildURIListL( |
|
2971 const TDesC8& aURI, |
|
2972 const TDesC8& aLUID, |
|
2973 CBufBase* const aURISegmentList, |
|
2974 const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList ) |
|
2975 { |
|
2976 __ASSERT_ALWAYS( aURISegmentList != NULL, User::Leave( KErrArgument ) ); |
|
2977 |
|
2978 CSmlDmAdapter::TError retValue = EOk; |
|
2979 |
|
2980 // get needed URI segments. |
|
2981 TBuf8<KSmlMaxURISegLen> segment = LastURISeg( aURI ); |
|
2982 TBuf8<KSmlMaxURISegLen> segmentName; |
|
2983 TPtrC8 uriTmp = RemoveLastURISeg( aURI ); |
|
2984 TPtrC8 secondLastUriSeg = LastURISeg( uriTmp ); |
|
2985 |
|
2986 TBuf8<KNSmlNATFWMaxUriLength> mappingInfo( KNullDesC8 ); |
|
2987 TBuf8<KNSmlNATFWMaxUriLength> uri = aURI; |
|
2988 |
|
2989 // IAPSpecific/ |
|
2990 if ( KNSmlDMIAPSpecificNodeName() == segment ) |
|
2991 { |
|
2992 TInt iapCount( 0 ); |
|
2993 if ( iNATFWIAPEntries ) |
|
2994 { |
|
2995 iapCount = iNATFWIAPEntries->Count(); |
|
2996 } |
|
2997 |
|
2998 for ( TInt counter = 0; counter < iapCount ; counter++ ) |
|
2999 { |
|
3000 TBool inList = EFalse; |
|
3001 TInt currentline = 0; |
|
3002 TUint32 ddId ( iNATFWIAPEntries->At( counter )->GetIAPKey() ); |
|
3003 while ( !inList && currentline < aPreviousURISegmentList.Count() ) |
|
3004 { |
|
3005 TInt profileLocation = FindIAPLocation ( |
|
3006 aPreviousURISegmentList.At( currentline ).iURISegLUID ); |
|
3007 if ( profileLocation != KErrNotFound ) |
|
3008 { |
|
3009 TUint32 profileID ( iNATFWIAPEntries-> |
|
3010 At( profileLocation )->GetIAPKey() ); |
|
3011 if ( profileID == ddId ) |
|
3012 { |
|
3013 inList = ETrue; |
|
3014 break; |
|
3015 } |
|
3016 } |
|
3017 currentline++; |
|
3018 } |
|
3019 if ( !inList ) |
|
3020 { |
|
3021 segmentName.Num( iNATFWIAPEntries->At( counter )-> |
|
3022 GetIAPKey() ); |
|
3023 aURISegmentList->InsertL( aURISegmentList-> |
|
3024 Size(), segmentName ); |
|
3025 aURISegmentList->InsertL( aURISegmentList-> |
|
3026 Size(), KNSmlDMNATFWSeparator ); |
|
3027 |
|
3028 // set luid mapping to dm-module |
|
3029 mappingInfo.Copy( KNSmlDMIAPSpecificNodeName ); |
|
3030 mappingInfo.Append( KNSmlDMNATFWSeparator ); |
|
3031 mappingInfo.AppendNum( iNATFWIAPEntries-> |
|
3032 At( counter )->GetIAPKey() ); |
|
3033 uri.Copy( KNSmlDMNATFWNodeName ); |
|
3034 uri.Append( KNSmlDMNATFWSeparator ); |
|
3035 uri.Append( KNSmlDMIAPSpecificNodeName ); |
|
3036 uri.Append( KNSmlDMNATFWSeparator ); |
|
3037 uri.AppendNum( iNATFWIAPEntries->At( counter )->GetIAPKey() ); |
|
3038 iDmCallback->SetMappingL( uri, mappingInfo ); |
|
3039 } |
|
3040 else |
|
3041 { // Add those in PreviousList which are on database |
|
3042 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
3043 aPreviousURISegmentList.At( currentline ).iURISeg ); |
|
3044 aURISegmentList->InsertL( aURISegmentList->Size(), |
|
3045 KNSmlDMNATFWSeparator ); |
|
3046 } |
|
3047 } |
|
3048 } |
|
3049 |
|
3050 // IAPSpecific/<x>/ |
|
3051 else if ( KThreeSegs == NumOfURISegs( aURI ) && |
|
3052 KNSmlDMIAPSpecificNodeName() == secondLastUriSeg |
|
3053 && aLUID.Length() ) |
|
3054 { |
|
3055 segmentName.Copy( KNSmlDMNATPrefConRef ); |
|
3056 aURISegmentList->InsertL( aURISegmentList-> |
|
3057 Size(), segmentName ); |
|
3058 aURISegmentList->InsertL( aURISegmentList-> |
|
3059 Size(), KNSmlDMNATFWSeparator ); |
|
3060 |
|
3061 segmentName.Copy( KNSmlDMNATRefreshTCP ); |
|
3062 aURISegmentList->InsertL( aURISegmentList-> |
|
3063 Size(), segmentName ); |
|
3064 aURISegmentList->InsertL( aURISegmentList-> |
|
3065 Size(), KNSmlDMNATFWSeparator ); |
|
3066 |
|
3067 segmentName.Copy( KNSmlDMNATRefreshUDP ); |
|
3068 aURISegmentList->InsertL( aURISegmentList-> |
|
3069 Size(), segmentName ); |
|
3070 aURISegmentList->InsertL( aURISegmentList-> |
|
3071 Size(), KNSmlDMNATFWSeparator ); |
|
3072 |
|
3073 segmentName.Copy( KNSmlDMSTUNRetransmit ); |
|
3074 aURISegmentList->InsertL( aURISegmentList-> |
|
3075 Size(), segmentName ); |
|
3076 aURISegmentList->InsertL( aURISegmentList-> |
|
3077 Size(), KNSmlDMNATFWSeparator ); |
|
3078 } |
|
3079 else |
|
3080 { |
|
3081 retValue = ENotFound; |
|
3082 } |
|
3083 |
|
3084 return retValue; |
|
3085 } |
|
3086 |
|
3087 |
|
3088 // --------------------------------------------------------------------------- |
|
3089 // CNSmlDmNATFWTraversalAdapter::LoadProfilesL |
|
3090 // Loads all nat-fw settings information to memory. |
|
3091 // --------------------------------------------------------------------------- |
|
3092 // |
|
3093 void CNSmlDmNATFWTraversalAdapter::LoadProfilesL() |
|
3094 { |
|
3095 // Central Repository for NAT-FW Traversal settings |
|
3096 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
3097 |
|
3098 // Load domain specific data |
|
3099 RArray<TUint32> keys; |
|
3100 CleanupClosePushL( keys ); // CS:2 |
|
3101 rep->FindL( KUNSAFProtocolsDomainMask, |
|
3102 KUNSAFProtocolsFieldTypeMask, keys ); |
|
3103 iNATFWDomainEntries = new (ELeave) CArrayPtrFlat<CNATFWDomainEntry>( |
|
3104 keys.Count() + 1 ); |
|
3105 for ( TInt counter = 0; counter < keys.Count(); counter++ ) |
|
3106 { |
|
3107 CNATFWDomainEntry* domainEntry = CNATFWDomainEntry::NewLC(); |
|
3108 // CS:3 |
|
3109 GetDomainSettingsL( keys[counter], *domainEntry ); |
|
3110 iNATFWDomainEntries->AppendL( domainEntry ); |
|
3111 CleanupStack::Pop( domainEntry ); // CS:2 |
|
3112 } |
|
3113 keys.Reset(); |
|
3114 |
|
3115 // Load IAP specific data |
|
3116 rep->FindL( KUNSAFProtocolsIAPIdMask, |
|
3117 KUNSAFProtocolsFieldTypeMask, keys ); |
|
3118 iNATFWIAPEntries = new (ELeave) CArrayPtrFlat<CNATFWIAPEntry>( |
|
3119 keys.Count() + 1 ); |
|
3120 |
|
3121 for ( TInt counter = 0; counter < keys.Count(); counter++ ) |
|
3122 { |
|
3123 CNATFWIAPEntry* iapEntry = CNATFWIAPEntry::NewLC(); // CS:3 |
|
3124 GetIAPSettingsL( keys[counter], *iapEntry ); |
|
3125 iNATFWIAPEntries->AppendL( iapEntry ); |
|
3126 CleanupStack::Pop( iapEntry ); // CS:2 |
|
3127 } |
|
3128 |
|
3129 keys.Close(); |
|
3130 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
3131 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
3132 } |
|
3133 |
|
3134 // --------------------------------------------------------------------------- |
|
3135 // CNSmlDmNATFWTraversalAdapter::SaveProfilesL |
|
3136 // Saves all nat-fw settings information back to persistent memory. |
|
3137 // Buffered commands are executed here. |
|
3138 // --------------------------------------------------------------------------- |
|
3139 // |
|
3140 void CNSmlDmNATFWTraversalAdapter::SaveProfilesL() |
|
3141 { |
|
3142 __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) ); |
|
3143 |
|
3144 // Central Repository for NAT-FW Traversal settings |
|
3145 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
3146 |
|
3147 if ( iNATFWDomainEntries && iNATFWIAPEntries ) |
|
3148 { |
|
3149 // ============================== |
|
3150 // Add commands first |
|
3151 // ============================== |
|
3152 // |
|
3153 AddSettingsL( rep ); |
|
3154 |
|
3155 // ============================== |
|
3156 // Delete commands |
|
3157 // ============================== |
|
3158 // |
|
3159 DeleteSettingsL( rep ); |
|
3160 |
|
3161 // ============================== |
|
3162 // Update commands, whole entry. |
|
3163 // ============================== |
|
3164 // |
|
3165 UpdateSettingsL( rep ); |
|
3166 } |
|
3167 |
|
3168 iNATFWCommandBuffer.Reset(); |
|
3169 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
3170 } |
|
3171 |
|
3172 // --------------------------------------------------------------------------- |
|
3173 // CNSmlDmNATFWTraversalAdapter::AddSettingsL |
|
3174 // Adds NAT-FW settings. |
|
3175 // --------------------------------------------------------------------------- |
|
3176 // |
|
3177 void CNSmlDmNATFWTraversalAdapter::AddSettingsL( CRepository* aRep ) |
|
3178 { |
|
3179 __ASSERT_ALWAYS( aRep != NULL, User::Leave( KErrArgument ) ); |
|
3180 |
|
3181 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
3182 counter++ ) |
|
3183 { |
|
3184 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
3185 TDMNATFWStatusInfo::EDMAddDomain ) |
|
3186 { |
|
3187 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
3188 RArray<TUint32> keys; |
|
3189 CleanupClosePushL( keys ); // CS:2 |
|
3190 aRep->FindL( KUNSAFProtocolsDomainMask, |
|
3191 KUNSAFProtocolsFieldTypeMask, keys ); |
|
3192 TUint32 currentKey = iNATFWCommandBuffer[counter].iKeyId; |
|
3193 TInt domainLocation = FindDomainLocation( currentKey ); |
|
3194 TInt err( KErrNone ); |
|
3195 |
|
3196 currentKey &= KUNSAFProtocolsKeyMask; |
|
3197 // create keys |
|
3198 err = aRep->Create( currentKey|KUNSAFProtocolsDomainMask, |
|
3199 iNATFWDomainEntries->At( domainLocation )->GetDomain() ); |
|
3200 |
|
3201 if ( KErrNone == err ) |
|
3202 { |
|
3203 err = aRep->Create( |
|
3204 KUNSAFProtocolsSTUNServerMask|currentKey, |
|
3205 KDefaultSTUNSrvAddr ); |
|
3206 } |
|
3207 if ( KErrNone == err ) |
|
3208 { |
|
3209 err = aRep->Create( |
|
3210 KUNSAFProtocolsSTUNServerPortMask|currentKey, |
|
3211 KDefaultSTUNPort ); |
|
3212 } |
|
3213 if ( KErrNone == err ) |
|
3214 { |
|
3215 err = aRep->Create( |
|
3216 KUNSAFProtocolsDomainIntervalUDPMask|currentKey, |
|
3217 KDefaultUDPRefreshInterval ); |
|
3218 } |
|
3219 if ( KErrNone == err ) |
|
3220 { |
|
3221 err = aRep->Create( |
|
3222 KUNSAFProtocolsDomainIntervalTCPMask|currentKey, |
|
3223 KDefaultTCPRefreshInterval ); |
|
3224 } |
|
3225 if ( KErrNone == err ) |
|
3226 { |
|
3227 err = aRep->Create( |
|
3228 KUNSAFProtocolsDomainEnableCRLFRefresh| |
|
3229 currentKey, KDefaultSTUNRetransmitTimer ); |
|
3230 } |
|
3231 |
|
3232 TUint32 currentNewKey = currentKey; |
|
3233 currentNewKey |= KUNSAFProtocolsFieldTypeMask; |
|
3234 currentNewKey ^= KUNSAFProtocolsFieldTypeMask; |
|
3235 |
|
3236 TUint32 stunKey; |
|
3237 stunKey = KUNSAFProtocolsSubTableFieldTypeMask + 1; |
|
3238 stunKey |= KUNSAFProtocolsSubTableFieldTypeMask; |
|
3239 stunKey = stunKey^KUNSAFProtocolsSubTableFieldTypeMask| |
|
3240 currentNewKey; |
|
3241 |
|
3242 // DomainSpecific/<x>/STUNSrvAddr |
|
3243 if ( KErrNone == err ) |
|
3244 { |
|
3245 err = aRep->Create( |
|
3246 KUNSAFProtocolsSTUNAddressMask|stunKey, |
|
3247 KDefaultSTUNSrvAddr ); |
|
3248 } |
|
3249 // DomainSpecific/<x>/STUNSrvPort |
|
3250 if ( KErrNone == err ) |
|
3251 { |
|
3252 err = aRep->Create( |
|
3253 KUNSAFProtocolsSTUNPortMask|stunKey, |
|
3254 KDefaultSTUNPort ); |
|
3255 } |
|
3256 // DomainSpecific/<x>/STUNSharedSecret |
|
3257 if ( KErrNone == err ) |
|
3258 { |
|
3259 err = aRep->Create( currentNewKey| |
|
3260 KUNSAFProtocolsDomainSharedSecretNotSupported, |
|
3261 KDefaultDisableStunSharedSecret ); |
|
3262 } |
|
3263 // DomainSpecific/<x>/PortPoolStartPort |
|
3264 if ( KErrNone == err ) |
|
3265 { |
|
3266 err = aRep->Create( |
|
3267 KUNSAFProtocolsPortPoolStartPortMask|currentNewKey, |
|
3268 KDefaultStartPort ); |
|
3269 } |
|
3270 // DomainSpecific/<x>/PortPoolEndPort |
|
3271 if ( KErrNone == err ) |
|
3272 { |
|
3273 err = aRep->Create( |
|
3274 KUNSAFProtocolsPortPoolEndPortMask|currentNewKey, |
|
3275 KDefaultEndPort ); |
|
3276 } |
|
3277 // DomainSpecific/<x>/UsedNATProtocol |
|
3278 if ( KErrNone == err ) |
|
3279 { |
|
3280 err = aRep->Create( |
|
3281 KUNSAFProtocolsUsedNATProtocolMask|currentNewKey, |
|
3282 KDefaultNatProtocol ); |
|
3283 } |
|
3284 |
|
3285 // DomainSpecific/<x>/ICESpecific/NATUtilities |
|
3286 if ( KErrNone == err ) |
|
3287 { |
|
3288 err = aRep->Create( |
|
3289 KUNSAFProtocolsNATUtilities|currentNewKey, |
|
3290 KDefaultNatUtilities ); |
|
3291 } |
|
3292 // DomainSpecific/<x>/ICESpecific/HostPreference |
|
3293 if ( KErrNone == err ) |
|
3294 { |
|
3295 err = aRep->Create( |
|
3296 KUNSAFProtocolsHostPref|currentNewKey, |
|
3297 KDefaultHostPref ); |
|
3298 } |
|
3299 // DomainSpecific/<x>/ICESpecific/ServerReflexivePreference |
|
3300 if ( KErrNone == err ) |
|
3301 { |
|
3302 err = aRep->Create( |
|
3303 KUNSAFProtocolsServerRefPref|currentNewKey, |
|
3304 KDefaultServerReflexivePref ); |
|
3305 } |
|
3306 // DomainSpecific/<x>/ICESpecific/RelayPreference |
|
3307 if ( KErrNone == err ) |
|
3308 { |
|
3309 err = aRep->Create( |
|
3310 KUNSAFProtocolsRelayPref|currentNewKey, |
|
3311 KDefaultRelayPref ); |
|
3312 } |
|
3313 // DomainSpecific/<x>/ICESpecific/PeerReflexivePreference |
|
3314 if ( KErrNone == err ) |
|
3315 { |
|
3316 err = aRep->Create( |
|
3317 KUNSAFProtocolsPeerRefPref|currentNewKey, |
|
3318 KDefaultPeerReflexivePref ); |
|
3319 } |
|
3320 // DomainSpecific/<x>/ICESpecific/IPv4Preference |
|
3321 if ( KErrNone == err ) |
|
3322 { |
|
3323 err = aRep->Create( |
|
3324 KUNSAFProtocolsIPV4Pref|currentNewKey, |
|
3325 KDefaultIPv4Pref ); |
|
3326 } |
|
3327 // DomainSpecific/<x>/ICESpecific/IPv6Preference |
|
3328 if ( KErrNone == err ) |
|
3329 { |
|
3330 err = aRep->Create( |
|
3331 KUNSAFProtocolsIPV6Pref|currentNewKey, |
|
3332 KDefaultIPv6Pref ); |
|
3333 } |
|
3334 // DomainSpecific/<x>/ICESpecific/VPNPreference |
|
3335 if ( KErrNone == err ) |
|
3336 { |
|
3337 err = aRep->Create( |
|
3338 KUNSAFProtocolsVPNPref|currentNewKey, |
|
3339 KDefaultVPNPref ); |
|
3340 } |
|
3341 // DomainSpecific/<x>/ICESpecific/UDPPreference |
|
3342 if ( KErrNone == err ) |
|
3343 { |
|
3344 err = aRep->Create( |
|
3345 KUNSAFProtocolsUDPPref|currentNewKey, |
|
3346 KDefaultUDPPref ); |
|
3347 } |
|
3348 // DomainSpecific/<x>/ICESpecific/TCPPreference |
|
3349 if ( KErrNone == err ) |
|
3350 { |
|
3351 err = aRep->Create( |
|
3352 KUNSAFProtocolsTCPPref|currentNewKey, |
|
3353 KDefaultTCPPref ); |
|
3354 } |
|
3355 // DomainSpecific/<x>/ICESpecific/TCPActivePreference |
|
3356 if ( KErrNone == err ) |
|
3357 { |
|
3358 err = aRep->Create( |
|
3359 KUNSAFProtocolsTCPActivePref|currentNewKey, |
|
3360 KDefaultTCPActivePref ); |
|
3361 } |
|
3362 // DomainSpecific/<x>/ICESpecific/TCPPassivePreference |
|
3363 if ( KErrNone == err ) |
|
3364 { |
|
3365 err = aRep->Create( |
|
3366 KUNSAFProtocolsTCPPassivePref|currentNewKey, |
|
3367 KDefaultTCPPassivePref ); |
|
3368 } |
|
3369 // DomainSpecific/<x>/ICESpecific/TCPSimultaneousPreference |
|
3370 if ( KErrNone == err ) |
|
3371 { |
|
3372 err = aRep->Create( |
|
3373 KUNSAFProtocolsTCPSimultPref|currentNewKey, |
|
3374 KDefaultTCPSimultaneousPref ); |
|
3375 } |
|
3376 |
|
3377 if ( KErrNone == err ) |
|
3378 { |
|
3379 retValue = EOk; |
|
3380 } |
|
3381 else |
|
3382 { |
|
3383 retValue = EError; |
|
3384 } |
|
3385 iDmCallback->SetStatusL( |
|
3386 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
3387 keys.Close(); |
|
3388 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
3389 } |
|
3390 } |
|
3391 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
3392 counter++ ) |
|
3393 { |
|
3394 // IAPSpecific/x/ add commands |
|
3395 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
3396 TDMNATFWStatusInfo::EDMAddIAP ) |
|
3397 { |
|
3398 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
3399 RArray<TUint32> keys; |
|
3400 CleanupClosePushL( keys ); // CS:2 |
|
3401 TInt err = aRep->FindL( KUNSAFProtocolsIAPIdMask, |
|
3402 KUNSAFProtocolsFieldTypeMask, keys ); |
|
3403 TUint32 currentKey = iNATFWCommandBuffer[counter].iKeyId; |
|
3404 TInt iapLocation = FindIAPLocation( currentKey ); |
|
3405 currentKey &= KUNSAFProtocolsKeyMask; |
|
3406 |
|
3407 // Create keys. |
|
3408 err = aRep->Create( currentKey|KUNSAFProtocolsIAPIdMask, |
|
3409 (TInt)iNATFWIAPEntries->At( iapLocation )->GetIAPId() ); |
|
3410 if ( KErrNone == err ) |
|
3411 { |
|
3412 err = aRep->Create( |
|
3413 KUNSAFProtocolsIntervalUDPMask|currentKey, |
|
3414 KDefaultUDPRefreshInterval ); |
|
3415 |
|
3416 if ( KErrNone == err ) |
|
3417 { |
|
3418 err = aRep->Create( |
|
3419 KUNSAFProtocolsIntervalTCPMask|currentKey, |
|
3420 KDefaultTCPRefreshInterval ); |
|
3421 } |
|
3422 |
|
3423 if ( KErrNone == err ) |
|
3424 { |
|
3425 err = aRep->Create( |
|
3426 KUNSAFProtocolsSTUNRetransmitTimerMask| |
|
3427 currentKey, KDefaultSTUNRetransmitTimer ); |
|
3428 } |
|
3429 if ( KErrNone == err ) |
|
3430 { |
|
3431 retValue = EOk; |
|
3432 } |
|
3433 else |
|
3434 { |
|
3435 retValue = EError; |
|
3436 } |
|
3437 iDmCallback->SetStatusL( |
|
3438 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
3439 } |
|
3440 keys.Close(); |
|
3441 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
3442 } |
|
3443 } |
|
3444 |
|
3445 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
3446 counter++ ) |
|
3447 { |
|
3448 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/ add commands |
|
3449 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
3450 TDMNATFWStatusInfo::EDMAddSTUN ) |
|
3451 { |
|
3452 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
3453 TUint32 stunKey = iNATFWCommandBuffer[counter].iKeyId; |
|
3454 // Stored key is for STUNSrvAddr so we must remove |
|
3455 // STUNSrvAddr mask. |
|
3456 stunKey ^= KUNSAFProtocolsSTUNAddressMask; |
|
3457 TInt err = aRep->Create( |
|
3458 KUNSAFProtocolsSTUNAddressMask|stunKey, |
|
3459 KDefaultSTUNSrvAddr ); |
|
3460 if ( KErrNone == err ) |
|
3461 { |
|
3462 err = aRep->Create( |
|
3463 KUNSAFProtocolsSTUNPortMask|stunKey, |
|
3464 KDefaultSTUNPort ); |
|
3465 } |
|
3466 // STUN username and password won't be created. |
|
3467 if ( KErrNone == err ) |
|
3468 { |
|
3469 retValue = EOk; |
|
3470 } |
|
3471 else |
|
3472 { |
|
3473 retValue = EError; |
|
3474 } |
|
3475 iDmCallback->SetStatusL( |
|
3476 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
3477 } |
|
3478 } |
|
3479 |
|
3480 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); counter++ ) |
|
3481 { |
|
3482 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/ add commands |
|
3483 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
3484 TDMNATFWStatusInfo::EDMAddTURN ) |
|
3485 { |
|
3486 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
3487 TUint32 turnKey = iNATFWCommandBuffer[counter].iKeyId; |
|
3488 |
|
3489 TInt err = aRep->Create( |
|
3490 KUNSAFProtocolsTURNAddressMask|turnKey, |
|
3491 KDefaultTURNSrvAddr ); |
|
3492 if ( KErrNone == err ) |
|
3493 { |
|
3494 err = aRep->Create( |
|
3495 KUNSAFProtocolsTURNPortMask|turnKey, |
|
3496 KDefaultTURNSrvPort ); |
|
3497 } |
|
3498 // TURN username and password won't be created. |
|
3499 |
|
3500 if ( KErrNone == err ) |
|
3501 { |
|
3502 retValue = EOk; |
|
3503 } |
|
3504 else |
|
3505 { |
|
3506 retValue = EError; |
|
3507 } |
|
3508 iDmCallback->SetStatusL( |
|
3509 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
3510 } |
|
3511 } |
|
3512 } |
|
3513 |
|
3514 // --------------------------------------------------------------------------- |
|
3515 // CNSmlDmNATFWTraversalAdapter::UpdateSettings |
|
3516 // Updates NAT-FW settings. |
|
3517 // --------------------------------------------------------------------------- |
|
3518 // |
|
3519 void CNSmlDmNATFWTraversalAdapter::UpdateSettingsL( CRepository* aRep ) |
|
3520 { |
|
3521 __ASSERT_ALWAYS( aRep != NULL, User::Leave( KErrArgument ) ); |
|
3522 |
|
3523 // Update Domain entry. |
|
3524 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
3525 counter++ ) |
|
3526 { |
|
3527 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
3528 TDMNATFWStatusInfo::EDMUpdateDomain ) |
|
3529 { |
|
3530 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
3531 RArray<TUint32> keys; |
|
3532 CleanupClosePushL( keys ); // CS:2 |
|
3533 aRep->FindL( KUNSAFProtocolsDomainMask, |
|
3534 KUNSAFProtocolsFieldTypeMask, keys ); |
|
3535 TInt32 currentKey = iNATFWCommandBuffer[counter].iKeyId; |
|
3536 TInt domainLocation = FindDomainLocation( currentKey ); |
|
3537 TInt err( KErrNone ); |
|
3538 currentKey &= KUNSAFProtocolsKeyMask; |
|
3539 |
|
3540 // Update keys. Set domain. |
|
3541 |
|
3542 // DomainSpecific/<x>/Domain |
|
3543 if ( iNATFWDomainEntries->At( domainLocation )-> |
|
3544 GetDomain() != KNSmlDMNATFWValueNotSet ) |
|
3545 { |
|
3546 err = aRep->Set( |
|
3547 KUNSAFProtocolsDomainMask|currentKey, |
|
3548 iNATFWDomainEntries->At( domainLocation )-> |
|
3549 GetDomain() ); |
|
3550 } |
|
3551 |
|
3552 // DomainSpecific/<x>/StunSrvAddr |
|
3553 if ( KErrNone == err && iNATFWDomainEntries-> |
|
3554 At( domainLocation )->GetSTUNAddr() != |
|
3555 KNSmlDMNATFWValueNotSet ) |
|
3556 { |
|
3557 err = aRep->Set( |
|
3558 KUNSAFProtocolsSTUNServerMask|currentKey, |
|
3559 iNATFWDomainEntries->At( domainLocation )-> |
|
3560 GetSTUNAddr() ); |
|
3561 if ( KErrNotFound == err ) |
|
3562 { |
|
3563 err = aRep->Create( |
|
3564 KUNSAFProtocolsSTUNServerMask|currentKey, |
|
3565 iNATFWDomainEntries->At( domainLocation )-> |
|
3566 GetSTUNAddr() ); |
|
3567 } |
|
3568 } |
|
3569 // DomainSpecific/<x>/StunSrvPort |
|
3570 if ( KErrNone == err && iNATFWDomainEntries-> |
|
3571 At( domainLocation )->GetSTUNPort() != KErrNotFound ) |
|
3572 { |
|
3573 err = aRep->Set( |
|
3574 KUNSAFProtocolsSTUNServerPortMask|currentKey, |
|
3575 ( TInt ) iNATFWDomainEntries->At( domainLocation )-> |
|
3576 GetSTUNPort() ); |
|
3577 if ( KErrNotFound == err ) |
|
3578 { |
|
3579 err = aRep->Create( |
|
3580 KUNSAFProtocolsSTUNServerPortMask|currentKey, |
|
3581 ( TInt ) iNATFWDomainEntries->At( domainLocation )-> |
|
3582 GetSTUNPort() ); |
|
3583 } |
|
3584 } |
|
3585 |
|
3586 // DomainSpecific/<x>/StunUsername |
|
3587 if ( KErrNone == err && iNATFWDomainEntries-> |
|
3588 At( domainLocation )->GetSTUNUsername() != |
|
3589 KNSmlDMNATFWValueNotSet ) |
|
3590 { |
|
3591 err = aRep->Set( |
|
3592 KUNSAFProtocolsSTUNUsernameMask|currentKey, |
|
3593 iNATFWDomainEntries->At( domainLocation )-> |
|
3594 GetSTUNUsername() ); |
|
3595 if ( KErrNotFound == err ) |
|
3596 { |
|
3597 err = aRep->Create( |
|
3598 KUNSAFProtocolsSTUNUsernameMask|currentKey, |
|
3599 iNATFWDomainEntries->At( domainLocation )-> |
|
3600 GetSTUNUsername() ); |
|
3601 } |
|
3602 } |
|
3603 // DomainSpecific/<x>/StunPassword |
|
3604 if ( KErrNone == err && iNATFWDomainEntries-> |
|
3605 At( domainLocation )->GetSTUNPassword() != |
|
3606 KNSmlDMNATFWValueNotSet ) |
|
3607 { |
|
3608 err = aRep->Set( |
|
3609 KUNSAFProtocolsSTUNPasswordMask|currentKey, |
|
3610 iNATFWDomainEntries->At( domainLocation )-> |
|
3611 GetSTUNPassword() ); |
|
3612 if ( KErrNotFound == err ) |
|
3613 { |
|
3614 err = aRep->Create( |
|
3615 KUNSAFProtocolsSTUNPasswordMask|currentKey, |
|
3616 iNATFWDomainEntries->At( domainLocation )-> |
|
3617 GetSTUNPassword() ); |
|
3618 } |
|
3619 } |
|
3620 |
|
3621 // DomainSpecific/<x>/NATRefreshUDP |
|
3622 if ( KErrNone == err && iNATFWDomainEntries-> |
|
3623 At( domainLocation )->GetNATRefreshUDP() != KErrNotFound ) |
|
3624 { |
|
3625 err = aRep->Set( |
|
3626 KUNSAFProtocolsDomainIntervalUDPMask|currentKey, |
|
3627 iNATFWDomainEntries->At( domainLocation )-> |
|
3628 GetNATRefreshUDP() ); |
|
3629 if ( KErrNotFound == err ) |
|
3630 { |
|
3631 err = aRep->Create( |
|
3632 KUNSAFProtocolsDomainIntervalUDPMask|currentKey, |
|
3633 iNATFWDomainEntries->At( domainLocation )-> |
|
3634 GetNATRefreshUDP() ); |
|
3635 } |
|
3636 } |
|
3637 // DomainSpecific/<x>/NATRefreshTCP |
|
3638 if ( KErrNone == err && iNATFWDomainEntries-> |
|
3639 At( domainLocation )->GetNATRefreshTCP() != KErrNotFound ) |
|
3640 { |
|
3641 err = aRep->Set( |
|
3642 KUNSAFProtocolsDomainIntervalTCPMask|currentKey, |
|
3643 iNATFWDomainEntries->At( domainLocation )-> |
|
3644 GetNATRefreshTCP() ); |
|
3645 if ( KErrNotFound == err ) |
|
3646 { |
|
3647 err = aRep->Create( |
|
3648 KUNSAFProtocolsDomainIntervalTCPMask|currentKey, |
|
3649 iNATFWDomainEntries->At( domainLocation )-> |
|
3650 GetNATRefreshTCP() ); |
|
3651 } |
|
3652 } |
|
3653 // DomainSpecific/<x>/EnableCRLFRefresh |
|
3654 if ( KErrNone == err && iNATFWDomainEntries-> |
|
3655 At( domainLocation )->GetEnableCRLFRefresh() != KErrNotFound ) |
|
3656 { |
|
3657 err = aRep->Set( |
|
3658 KUNSAFProtocolsDomainEnableCRLFRefresh|currentKey, |
|
3659 iNATFWDomainEntries->At( domainLocation )-> |
|
3660 GetEnableCRLFRefresh() ); |
|
3661 if ( KErrNotFound == err ) |
|
3662 { |
|
3663 err = aRep->Create( |
|
3664 KUNSAFProtocolsDomainEnableCRLFRefresh|currentKey, |
|
3665 iNATFWDomainEntries->At( domainLocation )-> |
|
3666 GetEnableCRLFRefresh() ); |
|
3667 } |
|
3668 } |
|
3669 |
|
3670 TUint32 currentNewKey = currentKey; |
|
3671 currentNewKey |= KUNSAFProtocolsFieldTypeMask; |
|
3672 currentNewKey ^= KUNSAFProtocolsFieldTypeMask; |
|
3673 |
|
3674 RArray<TUint32> stunKeys; |
|
3675 CleanupClosePushL( stunKeys ); // CS:3 |
|
3676 err = aRep->FindL( |
|
3677 currentNewKey|KUNSAFProtocolsSTUNAddressMask, |
|
3678 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
3679 |
|
3680 // STUN server keys directly under DomainSpecific node are in |
|
3681 // CentRep table index 0, i.e. stunKeys[0]. We must remove |
|
3682 // STUN server address mask from the key. |
|
3683 TUint32 stunKey( 0 ); |
|
3684 if ( KErrNone == err ) |
|
3685 { |
|
3686 stunKey = KUNSAFProtocolsSTUNAddressMask^stunKeys[0]; |
|
3687 } |
|
3688 stunKeys.Close(); |
|
3689 CleanupStack::PopAndDestroy( &stunKeys ); // CS:2 |
|
3690 |
|
3691 // DomainSpecific/<x>/STUNSrvAddr |
|
3692 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
3693 domainLocation )->StunSrvAddrL( 0 ) != |
|
3694 KNSmlDMNATFWValueNotSet ) |
|
3695 { |
|
3696 err = aRep->Set( stunKey|KUNSAFProtocolsSTUNAddressMask, |
|
3697 iNATFWDomainEntries->At( domainLocation )-> |
|
3698 StunSrvAddrL( 0 ) ); |
|
3699 if ( KErrNotFound == err ) |
|
3700 { |
|
3701 err = aRep->Create( |
|
3702 stunKey|KUNSAFProtocolsSTUNAddressMask, |
|
3703 iNATFWDomainEntries->At( domainLocation )-> |
|
3704 StunSrvAddrL( 0 ) ); |
|
3705 } |
|
3706 } |
|
3707 |
|
3708 // DomainSpecific/<x>/STUNSrvPort |
|
3709 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
3710 domainLocation )->StunSrvPort( 0 ) != KErrNotFound ) |
|
3711 { |
|
3712 err = aRep->Set( stunKey|KUNSAFProtocolsSTUNPortMask, |
|
3713 iNATFWDomainEntries->At( domainLocation )-> |
|
3714 StunSrvPort( 0 ) ); |
|
3715 if ( KErrNotFound == err ) |
|
3716 { |
|
3717 err = aRep->Create( stunKey|KUNSAFProtocolsSTUNPortMask, |
|
3718 iNATFWDomainEntries->At( domainLocation )-> |
|
3719 StunSrvPort( 0 ) ); |
|
3720 } |
|
3721 } |
|
3722 |
|
3723 // DomainSpecific/<x>/STUNUsername |
|
3724 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
3725 domainLocation )->StunUsernameL( 0 ) != |
|
3726 KNSmlDMNATFWValueNotSet ) |
|
3727 { |
|
3728 err = aRep->Set( stunKey|KUNSAFProtocolsSTUNUsernameMask, |
|
3729 iNATFWDomainEntries->At( domainLocation )-> |
|
3730 StunUsernameL( 0 ) ); |
|
3731 if ( KErrNotFound == err ) |
|
3732 { |
|
3733 err = aRep->Create( |
|
3734 stunKey|KUNSAFProtocolsSTUNUsernameMask, |
|
3735 iNATFWDomainEntries->At( domainLocation )-> |
|
3736 StunUsernameL( 0 ) ); |
|
3737 } |
|
3738 } |
|
3739 |
|
3740 // DomainSpecific/<x>/STUNPassword |
|
3741 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
3742 domainLocation )->StunPasswordL( 0 ) != |
|
3743 KNSmlDMNATFWValueNotSet ) |
|
3744 { |
|
3745 err = aRep->Set( stunKey|KUNSAFProtocolsSTUNPasswordMask, |
|
3746 iNATFWDomainEntries->At( domainLocation )-> |
|
3747 StunPasswordL( 0 ) ); |
|
3748 if ( KErrNotFound == err ) |
|
3749 { |
|
3750 err = aRep->Create( |
|
3751 stunKey|KUNSAFProtocolsSTUNPasswordMask, |
|
3752 iNATFWDomainEntries->At( domainLocation )-> |
|
3753 StunPasswordL( 0 ) ); |
|
3754 } |
|
3755 } |
|
3756 |
|
3757 // DomainSpecific/<x>/STUNSharedSecret |
|
3758 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3759 At( domainLocation )->DisableStunSharedSecret() ) |
|
3760 { |
|
3761 err = aRep->Set( currentNewKey| |
|
3762 KUNSAFProtocolsDomainSharedSecretNotSupported, |
|
3763 iNATFWDomainEntries->At( domainLocation )-> |
|
3764 DisableStunSharedSecret() ); |
|
3765 if ( KErrNotFound == err ) |
|
3766 { |
|
3767 err = aRep->Create( currentNewKey| |
|
3768 KUNSAFProtocolsDomainSharedSecretNotSupported, |
|
3769 iNATFWDomainEntries->At( domainLocation )-> |
|
3770 DisableStunSharedSecret() ); |
|
3771 } |
|
3772 } |
|
3773 |
|
3774 // DomainSpecific/<x>/PortPoolStartPort |
|
3775 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3776 At( domainLocation )->StartPortRange() ) |
|
3777 { |
|
3778 err = aRep->Set( |
|
3779 KUNSAFProtocolsPortPoolStartPortMask|currentNewKey, |
|
3780 iNATFWDomainEntries->At( domainLocation )-> |
|
3781 StartPortRange() ); |
|
3782 if ( KErrNotFound == err ) |
|
3783 { |
|
3784 err = aRep->Create( |
|
3785 KUNSAFProtocolsPortPoolStartPortMask|currentNewKey, |
|
3786 iNATFWDomainEntries->At( domainLocation )-> |
|
3787 StartPortRange() ); |
|
3788 } |
|
3789 } |
|
3790 |
|
3791 // DomainSpecific/<x>/PortPoolEndPort |
|
3792 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3793 At( domainLocation )->EndPortRange() ) |
|
3794 { |
|
3795 err = aRep->Set( |
|
3796 KUNSAFProtocolsPortPoolEndPortMask|currentNewKey, |
|
3797 iNATFWDomainEntries->At( domainLocation )-> |
|
3798 EndPortRange() ); |
|
3799 if ( KErrNotFound == err ) |
|
3800 { |
|
3801 err = aRep->Create( |
|
3802 KUNSAFProtocolsPortPoolEndPortMask|currentNewKey, |
|
3803 iNATFWDomainEntries->At( domainLocation )-> |
|
3804 EndPortRange() ); |
|
3805 } |
|
3806 } |
|
3807 |
|
3808 // DomainSpecific/<x>/UsedNATProtocol |
|
3809 if ( KErrNone == err && KNSmlDMNATFWValueNotSet() != |
|
3810 iNATFWDomainEntries->At( domainLocation )->UsedNatProtocol() ) |
|
3811 { |
|
3812 err = aRep->Set( |
|
3813 KUNSAFProtocolsUsedNATProtocolMask|currentNewKey, |
|
3814 iNATFWDomainEntries->At( domainLocation )-> |
|
3815 UsedNatProtocol() ); |
|
3816 if ( KErrNotFound == err ) |
|
3817 { |
|
3818 err = aRep->Create( |
|
3819 KUNSAFProtocolsUsedNATProtocolMask|currentNewKey, |
|
3820 iNATFWDomainEntries->At( domainLocation )-> |
|
3821 UsedNatProtocol() ); |
|
3822 } |
|
3823 } |
|
3824 |
|
3825 // DomainSpecific/<x>/ICESpecific/NATUtilities |
|
3826 if ( KErrNone == err && KNSmlDMNATFWValueNotSet() != |
|
3827 iNATFWDomainEntries->At( domainLocation )->NatUtilities() ) |
|
3828 { |
|
3829 err = aRep->Set( |
|
3830 KUNSAFProtocolsNATUtilities|currentNewKey, |
|
3831 iNATFWDomainEntries->At( domainLocation )-> |
|
3832 NatUtilities() ); |
|
3833 if ( KErrNotFound == err ) |
|
3834 { |
|
3835 err = aRep->Create( |
|
3836 KUNSAFProtocolsNATUtilities|currentNewKey, |
|
3837 iNATFWDomainEntries->At( domainLocation )-> |
|
3838 NatUtilities() ); |
|
3839 } |
|
3840 } |
|
3841 |
|
3842 // DomainSpecific/<x>/ICESpecific/HostPreference |
|
3843 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3844 At( domainLocation )->HostPref() ) |
|
3845 { |
|
3846 err = aRep->Set( |
|
3847 KUNSAFProtocolsHostPref|currentNewKey, |
|
3848 iNATFWDomainEntries->At( domainLocation )-> |
|
3849 HostPref() ); |
|
3850 if ( KErrNotFound == err ) |
|
3851 { |
|
3852 err = aRep->Create( |
|
3853 KUNSAFProtocolsHostPref|currentNewKey, |
|
3854 iNATFWDomainEntries->At( domainLocation )-> |
|
3855 HostPref() ); |
|
3856 } |
|
3857 } |
|
3858 // DomainSpecific/<x>/ICESpecific/ServerReflexivePreference |
|
3859 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3860 At( domainLocation )->ServerReflexPref() ) |
|
3861 { |
|
3862 err = aRep->Set( |
|
3863 KUNSAFProtocolsServerRefPref|currentNewKey, |
|
3864 iNATFWDomainEntries->At( domainLocation )-> |
|
3865 ServerReflexPref() ); |
|
3866 if ( KErrNotFound == err ) |
|
3867 { |
|
3868 err = aRep->Create( |
|
3869 KUNSAFProtocolsServerRefPref|currentNewKey, |
|
3870 iNATFWDomainEntries->At( domainLocation )-> |
|
3871 ServerReflexPref() ); |
|
3872 } |
|
3873 } |
|
3874 // DomainSpecific/<x>/ICESpecific/RelayPreference |
|
3875 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3876 At( domainLocation )->RelayPref() ) |
|
3877 { |
|
3878 err = aRep->Set( |
|
3879 KUNSAFProtocolsRelayPref|currentNewKey, |
|
3880 iNATFWDomainEntries->At( domainLocation )-> |
|
3881 RelayPref() ); |
|
3882 if ( KErrNotFound == err ) |
|
3883 { |
|
3884 err = aRep->Create( |
|
3885 KUNSAFProtocolsRelayPref|currentNewKey, |
|
3886 iNATFWDomainEntries->At( domainLocation )-> |
|
3887 RelayPref() ); |
|
3888 } |
|
3889 } |
|
3890 // DomainSpecific/<x>/ICESpecific/PeerReflexivePreference |
|
3891 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3892 At( domainLocation )->PeerReflexPref() ) |
|
3893 { |
|
3894 err = aRep->Set( |
|
3895 KUNSAFProtocolsPeerRefPref|currentNewKey, |
|
3896 iNATFWDomainEntries->At( domainLocation )-> |
|
3897 PeerReflexPref() ); |
|
3898 if ( KErrNotFound == err ) |
|
3899 { |
|
3900 err = aRep->Create( |
|
3901 KUNSAFProtocolsPeerRefPref|currentNewKey, |
|
3902 iNATFWDomainEntries->At( domainLocation )-> |
|
3903 PeerReflexPref() ); |
|
3904 } |
|
3905 } |
|
3906 // DomainSpecific/<x>/ICESpecific/IPv4Preference |
|
3907 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3908 At( domainLocation )->IPv4Pref() ) |
|
3909 { |
|
3910 err = aRep->Set( |
|
3911 KUNSAFProtocolsIPV4Pref|currentNewKey, |
|
3912 iNATFWDomainEntries->At( domainLocation )-> |
|
3913 IPv4Pref() ); |
|
3914 if ( KErrNotFound == err ) |
|
3915 { |
|
3916 err = aRep->Create( |
|
3917 KUNSAFProtocolsIPV4Pref|currentNewKey, |
|
3918 iNATFWDomainEntries->At( domainLocation )-> |
|
3919 IPv4Pref() ); |
|
3920 } |
|
3921 } |
|
3922 // DomainSpecific/<x>/ICESpecific/IPv6Preference |
|
3923 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3924 At( domainLocation )->IPv6Pref() ) |
|
3925 { |
|
3926 err = aRep->Set( |
|
3927 KUNSAFProtocolsIPV6Pref|currentNewKey, |
|
3928 iNATFWDomainEntries->At( domainLocation )-> |
|
3929 IPv6Pref() ); |
|
3930 if ( KErrNotFound == err ) |
|
3931 { |
|
3932 err = aRep->Create( |
|
3933 KUNSAFProtocolsIPV6Pref|currentNewKey, |
|
3934 iNATFWDomainEntries->At( domainLocation )-> |
|
3935 IPv6Pref() ); |
|
3936 } |
|
3937 } |
|
3938 // DomainSpecific/<x>/ICESpecific/VPNPreference |
|
3939 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3940 At( domainLocation )->VpnPref() ) |
|
3941 { |
|
3942 err = aRep->Set( |
|
3943 KUNSAFProtocolsVPNPref|currentNewKey, |
|
3944 iNATFWDomainEntries->At( domainLocation )-> |
|
3945 VpnPref() ); |
|
3946 if ( KErrNotFound == err ) |
|
3947 { |
|
3948 err = aRep->Create( |
|
3949 KUNSAFProtocolsVPNPref|currentNewKey, |
|
3950 iNATFWDomainEntries->At( domainLocation )-> |
|
3951 VpnPref() ); |
|
3952 } |
|
3953 } |
|
3954 // DomainSpecific/<x>/ICESpecific/UDPPreference |
|
3955 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3956 At( domainLocation )->UdpPref() ) |
|
3957 { |
|
3958 err = aRep->Set( |
|
3959 KUNSAFProtocolsUDPPref|currentNewKey, |
|
3960 iNATFWDomainEntries->At( domainLocation )-> |
|
3961 UdpPref() ); |
|
3962 if ( KErrNotFound == err ) |
|
3963 { |
|
3964 err = aRep->Create( |
|
3965 KUNSAFProtocolsUDPPref|currentNewKey, |
|
3966 iNATFWDomainEntries->At( domainLocation )-> |
|
3967 UdpPref() ); |
|
3968 } |
|
3969 } |
|
3970 // DomainSpecific/<x>/ICESpecific/TCPPreference |
|
3971 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3972 At( domainLocation )->TcpPref() ) |
|
3973 { |
|
3974 err = aRep->Set( |
|
3975 KUNSAFProtocolsTCPPref|currentNewKey, |
|
3976 iNATFWDomainEntries->At( domainLocation )-> |
|
3977 TcpPref() ); |
|
3978 if ( KErrNotFound == err ) |
|
3979 { |
|
3980 err = aRep->Create( |
|
3981 KUNSAFProtocolsTCPPref|currentNewKey, |
|
3982 iNATFWDomainEntries->At( domainLocation )-> |
|
3983 TcpPref() ); |
|
3984 } |
|
3985 } |
|
3986 // DomainSpecific/<x>/ICESpecific/TCPActivePreference |
|
3987 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
3988 At( domainLocation )->TcpActivePref() ) |
|
3989 { |
|
3990 err = aRep->Set( |
|
3991 KUNSAFProtocolsTCPActivePref|currentNewKey, |
|
3992 iNATFWDomainEntries->At( domainLocation )-> |
|
3993 TcpActivePref() ); |
|
3994 if ( KErrNotFound == err ) |
|
3995 { |
|
3996 err = aRep->Create( |
|
3997 KUNSAFProtocolsTCPActivePref|currentNewKey, |
|
3998 iNATFWDomainEntries->At( domainLocation )-> |
|
3999 TcpActivePref() ); |
|
4000 } |
|
4001 } |
|
4002 // DomainSpecific/<x>/ICESpecific/TCPPassivePreference |
|
4003 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
4004 At( domainLocation )->TcpPassivePref() ) |
|
4005 { |
|
4006 err = aRep->Set( |
|
4007 KUNSAFProtocolsTCPPassivePref|currentNewKey, |
|
4008 iNATFWDomainEntries->At( domainLocation )-> |
|
4009 TcpPassivePref() ); |
|
4010 if ( KErrNotFound == err ) |
|
4011 { |
|
4012 err = aRep->Create( |
|
4013 KUNSAFProtocolsTCPPassivePref|currentNewKey, |
|
4014 iNATFWDomainEntries->At( domainLocation )-> |
|
4015 TcpPassivePref() ); |
|
4016 } |
|
4017 } |
|
4018 // DomainSpecific/<x>/ICESpecific/TCPSimultaneousPreference |
|
4019 if ( KErrNone == err && KErrNotFound != iNATFWDomainEntries-> |
|
4020 At( domainLocation )->TcpSimultPref() ) |
|
4021 { |
|
4022 err = aRep->Set( |
|
4023 KUNSAFProtocolsTCPSimultPref|currentNewKey, |
|
4024 iNATFWDomainEntries->At( domainLocation )-> |
|
4025 TcpSimultPref() ); |
|
4026 if ( KErrNotFound == err ) |
|
4027 { |
|
4028 err = aRep->Create( |
|
4029 KUNSAFProtocolsTCPSimultPref|currentNewKey, |
|
4030 iNATFWDomainEntries->At( domainLocation )-> |
|
4031 TcpSimultPref() ); |
|
4032 } |
|
4033 } |
|
4034 |
|
4035 if ( KErrNone == err ) |
|
4036 { |
|
4037 retValue = EOk; |
|
4038 } |
|
4039 else |
|
4040 { |
|
4041 retValue = EError; |
|
4042 } |
|
4043 iDmCallback->SetStatusL( |
|
4044 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
4045 keys.Close(); |
|
4046 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
4047 } |
|
4048 } |
|
4049 |
|
4050 // Update IAP specific entry. |
|
4051 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
4052 counter++ ) |
|
4053 { |
|
4054 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
4055 TDMNATFWStatusInfo::EDMUpdateIAP ) |
|
4056 { |
|
4057 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
4058 RArray<TUint32> keys; |
|
4059 CleanupClosePushL( keys ); // CS:2 |
|
4060 aRep->FindL( KUNSAFProtocolsIAPIdMask, |
|
4061 KUNSAFProtocolsFieldTypeMask, keys ); |
|
4062 TInt32 currentKey = iNATFWCommandBuffer[counter].iKeyId; |
|
4063 TInt iapLocation = FindIAPLocation( currentKey ); |
|
4064 currentKey &= KUNSAFProtocolsKeyMask; |
|
4065 |
|
4066 // Update keys. Only keys with changed values are created/updated. |
|
4067 TInt err ( 0 ); |
|
4068 if ( iNATFWIAPEntries->At( iapLocation )->GetIAPId() |
|
4069 != KErrNone ) |
|
4070 { |
|
4071 err = aRep->Set( currentKey|KUNSAFProtocolsIAPIdMask, |
|
4072 (TInt)iNATFWIAPEntries->At( |
|
4073 iapLocation )->GetIAPId() ); |
|
4074 if ( KErrNotFound == err ) |
|
4075 { |
|
4076 err = aRep->Create( currentKey|KUNSAFProtocolsIAPIdMask, |
|
4077 (TInt)iNATFWIAPEntries->At( |
|
4078 iapLocation )->GetIAPId() ); |
|
4079 } |
|
4080 } |
|
4081 if ( KErrNone == err && iNATFWIAPEntries->At( iapLocation )-> |
|
4082 GetIntervalUDP() != KErrNotFound ) |
|
4083 { |
|
4084 err = aRep->Set( KUNSAFProtocolsIntervalUDPMask|currentKey, |
|
4085 iNATFWIAPEntries->At( |
|
4086 iapLocation )->GetIntervalUDP() ); |
|
4087 if ( KErrNotFound == err ) |
|
4088 { |
|
4089 err = aRep->Create( |
|
4090 KUNSAFProtocolsIntervalUDPMask|currentKey, |
|
4091 iNATFWIAPEntries->At( |
|
4092 iapLocation )->GetIntervalUDP() ); |
|
4093 } |
|
4094 } |
|
4095 if ( KErrNone == err && iNATFWIAPEntries->At( iapLocation )-> |
|
4096 GetIntervalTCP() != KErrNotFound ) |
|
4097 { |
|
4098 err = aRep->Set( KUNSAFProtocolsIntervalTCPMask|currentKey, |
|
4099 iNATFWIAPEntries->At( |
|
4100 iapLocation )->GetIntervalTCP() ); |
|
4101 if ( KErrNotFound == err ) |
|
4102 { |
|
4103 err = aRep->Create( |
|
4104 KUNSAFProtocolsIntervalTCPMask|currentKey, |
|
4105 iNATFWIAPEntries->At( |
|
4106 iapLocation )->GetIntervalTCP() ); |
|
4107 } |
|
4108 } |
|
4109 if ( KErrNone == err && iNATFWIAPEntries->At( iapLocation )-> |
|
4110 GetSTUNRetransmitTimer() != KErrNotFound ) |
|
4111 { |
|
4112 err = aRep->Set( |
|
4113 KUNSAFProtocolsSTUNRetransmitTimerMask|currentKey, |
|
4114 iNATFWIAPEntries->At( |
|
4115 iapLocation )->GetSTUNRetransmitTimer() ); |
|
4116 if ( KErrNotFound == err ) |
|
4117 { |
|
4118 err = aRep->Create( |
|
4119 KUNSAFProtocolsSTUNRetransmitTimerMask|currentKey, |
|
4120 iNATFWIAPEntries->At( |
|
4121 iapLocation )->GetSTUNRetransmitTimer() ); |
|
4122 } |
|
4123 } |
|
4124 if ( KErrNone == err ) |
|
4125 { |
|
4126 retValue = EOk; |
|
4127 } |
|
4128 iDmCallback->SetStatusL( |
|
4129 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
4130 keys.Close(); |
|
4131 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
4132 } |
|
4133 } |
|
4134 |
|
4135 // Update AdditionalSTUNServer node. |
|
4136 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
4137 counter++ ) |
|
4138 { |
|
4139 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
4140 TDMNATFWStatusInfo::EDMUpdateSTUN ) |
|
4141 { |
|
4142 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EError; |
|
4143 TInt32 stunKey = iNATFWCommandBuffer[counter].iKeyId; |
|
4144 TInt domainLoc = iNATFWCommandBuffer[counter].iLocation; |
|
4145 TUint32 domainKey = iNATFWDomainEntries->At( domainLoc )-> |
|
4146 GetDomainKey(); |
|
4147 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
4148 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
4149 RArray<TUint32> stunKeys; |
|
4150 CleanupClosePushL( stunKeys ); // CS:2 |
|
4151 TInt err = aRep->FindL( |
|
4152 domainKey|KUNSAFProtocolsSTUNAddressMask, |
|
4153 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
4154 TInt stunCount( stunKeys.Count() ); |
|
4155 TInt stunLoc( KErrNotFound ); |
|
4156 |
|
4157 for ( TInt stunCounter = 0; stunCounter < stunCount; |
|
4158 stunCounter++ ) |
|
4159 { |
|
4160 if ( stunKey == stunKeys[stunCounter] ) |
|
4161 { |
|
4162 stunLoc = stunCounter; |
|
4163 } |
|
4164 } |
|
4165 stunKeys.Close(); |
|
4166 CleanupStack::PopAndDestroy( &stunKeys ); // CS:1 |
|
4167 |
|
4168 // Matching key not found, set status to not found. |
|
4169 if ( KErrNotFound == stunLoc ) |
|
4170 { |
|
4171 retValue = ENotFound; |
|
4172 } |
|
4173 // STUN settings location starts from index 1 for |
|
4174 // AdditionalSTUNServer node. |
|
4175 else if ( KErrNone == stunLoc ) |
|
4176 { |
|
4177 retValue = EError; |
|
4178 } |
|
4179 // Update keys. |
|
4180 else |
|
4181 { |
|
4182 // Remove STUN server address mask from the key. |
|
4183 stunKey ^= KUNSAFProtocolsSTUNAddressMask; |
|
4184 |
|
4185 // AdditionalSTUNServer/<x>/STUNSrvAddr |
|
4186 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
4187 domainLoc )->StunSrvAddrL( stunLoc ) != |
|
4188 KNSmlDMNATFWValueNotSet ) |
|
4189 { |
|
4190 err = aRep->Set( |
|
4191 stunKey|KUNSAFProtocolsSTUNAddressMask, |
|
4192 iNATFWDomainEntries->At( domainLoc )-> |
|
4193 StunSrvAddrL( stunLoc ) ); |
|
4194 if ( KErrNotFound == err ) |
|
4195 { |
|
4196 err = aRep->Create( |
|
4197 stunKey|KUNSAFProtocolsSTUNAddressMask, |
|
4198 iNATFWDomainEntries->At( domainLoc )-> |
|
4199 StunSrvAddrL( stunLoc ) ); |
|
4200 } |
|
4201 } |
|
4202 |
|
4203 // AdditionalSTUNServer/<x>/STUNSrvPort |
|
4204 if ( KErrNone == err && KErrNotFound != |
|
4205 iNATFWDomainEntries->At( domainLoc )-> |
|
4206 StunSrvPort( stunLoc ) ) |
|
4207 { |
|
4208 err = aRep->Set( stunKey|KUNSAFProtocolsSTUNPortMask, |
|
4209 iNATFWDomainEntries->At( domainLoc )-> |
|
4210 StunSrvPort( stunLoc ) ); |
|
4211 if ( KErrNotFound == err ) |
|
4212 { |
|
4213 err = aRep->Create( |
|
4214 stunKey|KUNSAFProtocolsSTUNPortMask, |
|
4215 iNATFWDomainEntries->At( domainLoc )-> |
|
4216 StunSrvPort( stunLoc ) ); |
|
4217 } |
|
4218 } |
|
4219 |
|
4220 // AdditionalSTUNServer/<x>/STUNUsername |
|
4221 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
4222 domainLoc )->StunUsernameL( stunLoc ) != |
|
4223 KNSmlDMNATFWValueNotSet ) |
|
4224 { |
|
4225 err = aRep->Set( |
|
4226 stunKey|KUNSAFProtocolsSTUNUsernameMask, |
|
4227 iNATFWDomainEntries->At( domainLoc )-> |
|
4228 StunUsernameL( stunLoc ) ); |
|
4229 if ( KErrNotFound == err ) |
|
4230 { |
|
4231 err = aRep->Create( |
|
4232 stunKey|KUNSAFProtocolsSTUNUsernameMask, |
|
4233 iNATFWDomainEntries->At( domainLoc )-> |
|
4234 StunUsernameL( stunLoc ) ); |
|
4235 } |
|
4236 } |
|
4237 |
|
4238 // AdditionalSTUNServer/<x>/STUNPassword |
|
4239 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
4240 domainLoc )->StunPasswordL( stunLoc ) != |
|
4241 KNSmlDMNATFWValueNotSet ) |
|
4242 { |
|
4243 err = aRep->Set( |
|
4244 stunKey|KUNSAFProtocolsSTUNPasswordMask, |
|
4245 iNATFWDomainEntries->At( domainLoc )-> |
|
4246 StunPasswordL( stunLoc ) ); |
|
4247 if ( KErrNotFound == err ) |
|
4248 { |
|
4249 err = aRep->Create( |
|
4250 stunKey|KUNSAFProtocolsSTUNPasswordMask, |
|
4251 iNATFWDomainEntries->At( domainLoc )-> |
|
4252 StunPasswordL( stunLoc ) ); |
|
4253 } |
|
4254 } |
|
4255 |
|
4256 if ( KErrNone == err ) |
|
4257 { |
|
4258 retValue = EOk; |
|
4259 } |
|
4260 } |
|
4261 iDmCallback->SetStatusL( |
|
4262 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
4263 } |
|
4264 } |
|
4265 |
|
4266 // Update TURNSpecific/TURNServer node. |
|
4267 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
4268 counter++ ) |
|
4269 { |
|
4270 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
4271 TDMNATFWStatusInfo::EDMUpdateTURN ) |
|
4272 { |
|
4273 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EError; |
|
4274 TInt32 turnKey = iNATFWCommandBuffer[counter].iKeyId; |
|
4275 TInt domainLoc = iNATFWCommandBuffer[counter].iLocation; |
|
4276 TUint32 domainKey = iNATFWDomainEntries->At( domainLoc )-> |
|
4277 GetDomainKey(); |
|
4278 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
4279 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
4280 RArray<TUint32> turnKeys; |
|
4281 CleanupClosePushL( turnKeys ); // CS:2 |
|
4282 TInt err = aRep->FindL( |
|
4283 domainKey|KUNSAFProtocolsTURNAddressMask, |
|
4284 KUNSAFProtocolsSubTableFieldTypeMask, turnKeys ); |
|
4285 TInt turnCount( turnKeys.Count() ); |
|
4286 TInt turnLoc( KErrNotFound ); |
|
4287 |
|
4288 for ( TInt turnCounter = 0; turnCounter < turnCount; |
|
4289 turnCounter++ ) |
|
4290 { |
|
4291 if ( turnKey == turnKeys[turnCounter] ) |
|
4292 { |
|
4293 turnLoc = turnCounter; |
|
4294 } |
|
4295 } |
|
4296 turnKeys.Close(); |
|
4297 CleanupStack::PopAndDestroy( &turnKeys ); // CS:1 |
|
4298 |
|
4299 // Matching key not found, set status to not found. |
|
4300 if ( KErrNotFound == turnLoc ) |
|
4301 { |
|
4302 retValue = ENotFound; |
|
4303 } |
|
4304 // Update keys. |
|
4305 else |
|
4306 { |
|
4307 // Remove TURN server address mask from the key. |
|
4308 turnKey ^= KUNSAFProtocolsTURNAddressMask; |
|
4309 |
|
4310 // TURNSpecific/TURNServer/<x>/TURNSrvAddr |
|
4311 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
4312 domainLoc )->TurnSrvAddrL( turnLoc ) != |
|
4313 KNSmlDMNATFWValueNotSet ) |
|
4314 { |
|
4315 err = aRep->Set( |
|
4316 turnKey|KUNSAFProtocolsTURNAddressMask, |
|
4317 iNATFWDomainEntries->At( domainLoc )-> |
|
4318 TurnSrvAddrL( turnLoc ) ); |
|
4319 if ( KErrNotFound == err ) |
|
4320 { |
|
4321 err = aRep->Create( |
|
4322 turnKey|KUNSAFProtocolsTURNAddressMask, |
|
4323 iNATFWDomainEntries->At( domainLoc )-> |
|
4324 TurnSrvAddrL( turnLoc ) ); |
|
4325 } |
|
4326 } |
|
4327 |
|
4328 // TURNSpecific/TURNServer/<x>/TURNSrvPort |
|
4329 if ( KErrNone == err && KErrNotFound != |
|
4330 iNATFWDomainEntries->At( domainLoc )-> |
|
4331 TurnSrvPort( turnLoc ) ) |
|
4332 { |
|
4333 err = aRep->Set( turnKey|KUNSAFProtocolsTURNPortMask, |
|
4334 iNATFWDomainEntries->At( domainLoc )-> |
|
4335 TurnSrvPort( turnLoc ) ); |
|
4336 if ( KErrNotFound == err ) |
|
4337 { |
|
4338 err = aRep->Create( |
|
4339 turnKey|KUNSAFProtocolsTURNPortMask, |
|
4340 iNATFWDomainEntries->At( domainLoc )-> |
|
4341 TurnSrvPort( turnLoc ) ); |
|
4342 } |
|
4343 } |
|
4344 |
|
4345 // TURNSpecific/TURNServer/<x>/TURNUsername |
|
4346 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
4347 domainLoc )->TurnUsernameL( turnLoc ) != |
|
4348 KNSmlDMNATFWValueNotSet ) |
|
4349 { |
|
4350 err = aRep->Set( |
|
4351 turnKey|KUNSAFProtocolsTURNUsernameMask, |
|
4352 iNATFWDomainEntries->At( domainLoc )-> |
|
4353 TurnUsernameL( turnLoc ) ); |
|
4354 if ( KErrNotFound == err ) |
|
4355 { |
|
4356 err = aRep->Create( |
|
4357 turnKey|KUNSAFProtocolsTURNUsernameMask, |
|
4358 iNATFWDomainEntries->At( domainLoc )-> |
|
4359 TurnUsernameL( turnLoc ) ); |
|
4360 } |
|
4361 } |
|
4362 |
|
4363 // TURNSpecific/TURNServer/<x>/TURNPassword |
|
4364 if ( KErrNone == err && iNATFWDomainEntries->At( |
|
4365 domainLoc )->TurnPasswordL( turnLoc ) != |
|
4366 KNSmlDMNATFWValueNotSet ) |
|
4367 { |
|
4368 err = aRep->Set( |
|
4369 turnKey|KUNSAFProtocolsTURNPasswordMask, |
|
4370 iNATFWDomainEntries->At( domainLoc )-> |
|
4371 TurnPasswordL( turnLoc ) ); |
|
4372 if ( KErrNotFound == err ) |
|
4373 { |
|
4374 err = aRep->Create( |
|
4375 turnKey|KUNSAFProtocolsTURNPasswordMask, |
|
4376 iNATFWDomainEntries->At( domainLoc )-> |
|
4377 TurnPasswordL( turnLoc ) ); |
|
4378 } |
|
4379 } |
|
4380 |
|
4381 if ( KErrNone == err ) |
|
4382 { |
|
4383 retValue = EOk; |
|
4384 } |
|
4385 } |
|
4386 iDmCallback->SetStatusL( |
|
4387 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
4388 } |
|
4389 } |
|
4390 } |
|
4391 |
|
4392 // --------------------------------------------------------------------------- |
|
4393 // CNSmlDmNATFWTraversalAdapter::DeleteSettings |
|
4394 // Deletes NAT-FW settings. |
|
4395 // --------------------------------------------------------------------------- |
|
4396 // |
|
4397 void CNSmlDmNATFWTraversalAdapter::DeleteSettingsL( CRepository* aRep ) |
|
4398 { |
|
4399 __ASSERT_ALWAYS( aRep != NULL, User::Leave( KErrArgument ) ); |
|
4400 |
|
4401 // DomainSpecific/<x>/ delete commands. |
|
4402 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
4403 counter++ ) |
|
4404 { |
|
4405 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
4406 TDMNATFWStatusInfo::EDMDeleteDomain ) |
|
4407 { |
|
4408 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
4409 RArray<TUint32> keys; |
|
4410 CleanupClosePushL( keys ); // CS:2 |
|
4411 aRep->FindL( KUNSAFProtocolsDomainMask, |
|
4412 KUNSAFProtocolsFieldTypeMask, keys ); |
|
4413 TInt32 currentKey = iNATFWCommandBuffer[counter].iKeyId; |
|
4414 TInt err( KErrNone ); |
|
4415 currentKey &= KUNSAFProtocolsKeyMask; |
|
4416 |
|
4417 // DomainSpecific/<x>/Domain |
|
4418 err = aRep->Delete( |
|
4419 KUNSAFProtocolsDomainMask|currentKey ); |
|
4420 |
|
4421 // DomainSpecific/<x>/STUNSrvAddr |
|
4422 if ( KErrNone == err ) |
|
4423 { |
|
4424 err = aRep->Delete( |
|
4425 KUNSAFProtocolsSTUNServerMask|currentKey ); |
|
4426 } |
|
4427 // DomainSpecific/<x>/STUNSrvPort |
|
4428 if ( KErrNone == err ) |
|
4429 { |
|
4430 err = aRep->Delete( |
|
4431 KUNSAFProtocolsSTUNServerPortMask|currentKey ); |
|
4432 } |
|
4433 // DomainSpecific/<x>/STUNUsername |
|
4434 if ( KErrNone == err ) |
|
4435 { |
|
4436 err = aRep->Delete( |
|
4437 KUNSAFProtocolsSTUNUsernameMask|currentKey ); |
|
4438 } |
|
4439 // DomainSpecific/<x>/StunPassword |
|
4440 if ( KErrNone == err ) |
|
4441 { |
|
4442 err = aRep->Delete( |
|
4443 KUNSAFProtocolsSTUNPasswordMask|currentKey ); |
|
4444 } |
|
4445 // DomainSpecific/<x>/NATRefreshUDP |
|
4446 if ( KErrNone == err ) |
|
4447 { |
|
4448 err = aRep->Delete( |
|
4449 KUNSAFProtocolsDomainIntervalUDPMask|currentKey ); |
|
4450 } |
|
4451 // DomainSpecific/<x>/NATRefreshTCP |
|
4452 if ( KErrNone == err ) |
|
4453 { |
|
4454 err = aRep->Delete( |
|
4455 KUNSAFProtocolsDomainIntervalTCPMask|currentKey ); |
|
4456 } |
|
4457 // DomainSpecific/<x>/EnableCRLFRefresh |
|
4458 if ( KErrNone == err ) |
|
4459 { |
|
4460 err = aRep->Delete( |
|
4461 KUNSAFProtocolsDomainEnableCRLFRefresh|currentKey ); |
|
4462 } |
|
4463 |
|
4464 TUint32 currentNewKey = currentKey; |
|
4465 currentNewKey |= KUNSAFProtocolsFieldTypeMask; |
|
4466 currentNewKey ^= KUNSAFProtocolsFieldTypeMask; |
|
4467 |
|
4468 // When deleting a DomainSpecific node, we must also delete |
|
4469 // all STUN server settings under it. |
|
4470 RArray<TUint32> stunKeys; |
|
4471 CleanupClosePushL( stunKeys ); // CS:3 |
|
4472 aRep->FindL( |
|
4473 currentNewKey|KUNSAFProtocolsSTUNAddressMask, |
|
4474 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
4475 TInt stunKeyCount( stunKeys.Count() ); |
|
4476 |
|
4477 for ( TInt stunCounter = 0; stunCounter < stunKeyCount; |
|
4478 stunCounter++ ) |
|
4479 { |
|
4480 // Remove STUN address mask. |
|
4481 TUint32 key = KUNSAFProtocolsSTUNAddressMask^ |
|
4482 stunKeys[stunCounter]; |
|
4483 |
|
4484 // STUNSrvAddr |
|
4485 err = aRep->Delete( key|KUNSAFProtocolsSTUNAddressMask ); |
|
4486 |
|
4487 // STUNSrvPort |
|
4488 if ( KErrNone == err || KErrNotFound == err ) |
|
4489 { |
|
4490 err = aRep->Delete( key|KUNSAFProtocolsSTUNPortMask ); |
|
4491 } |
|
4492 |
|
4493 // STUNUsername |
|
4494 if ( KErrNone == err || KErrNotFound == err ) |
|
4495 { |
|
4496 err = aRep->Delete( key|KUNSAFProtocolsSTUNUsernameMask ); |
|
4497 } |
|
4498 |
|
4499 // STUNPassword |
|
4500 if ( KErrNone == err || KErrNotFound == err ) |
|
4501 { |
|
4502 err = aRep->Delete( key|KUNSAFProtocolsSTUNPasswordMask ); |
|
4503 } |
|
4504 } |
|
4505 stunKeys.Close(); |
|
4506 CleanupStack::PopAndDestroy( &stunKeys ); // CS:2 |
|
4507 |
|
4508 // DomainSpecific/<x>/STUNSharedSecret |
|
4509 if ( KErrNone == err || KErrNotFound == err ) |
|
4510 { |
|
4511 err = aRep->Delete( currentNewKey| |
|
4512 KUNSAFProtocolsDomainSharedSecretNotSupported ); |
|
4513 } |
|
4514 |
|
4515 // DomainSpecific/<x>/PortPoolStartPort |
|
4516 if ( KErrNone == err || KErrNotFound == err ) |
|
4517 { |
|
4518 err = aRep->Delete( |
|
4519 KUNSAFProtocolsPortPoolStartPortMask|currentNewKey ); |
|
4520 } |
|
4521 |
|
4522 // DomainSpecific/<x>/PortPoolEndPort |
|
4523 if ( KErrNone == err || KErrNotFound == err ) |
|
4524 { |
|
4525 err = aRep->Delete( |
|
4526 KUNSAFProtocolsPortPoolEndPortMask|currentNewKey ); |
|
4527 } |
|
4528 |
|
4529 // DomainSpecific/<x>/UsedNATProtocol |
|
4530 if ( KErrNone == err || KErrNotFound == err ) |
|
4531 { |
|
4532 err = aRep->Delete( |
|
4533 KUNSAFProtocolsUsedNATProtocolMask|currentNewKey ); |
|
4534 } |
|
4535 |
|
4536 // DomainSpecific/<x>/ICESpecific/NATUtilities |
|
4537 if ( KErrNone == err || KErrNotFound == err ) |
|
4538 { |
|
4539 err = aRep->Delete( |
|
4540 KUNSAFProtocolsNATUtilities|currentNewKey ); |
|
4541 } |
|
4542 |
|
4543 // DomainSpecific/<x>/ICESpecific/HostPreference |
|
4544 if ( KErrNone == err || KErrNotFound == err ) |
|
4545 { |
|
4546 err = aRep->Delete( |
|
4547 KUNSAFProtocolsHostPref|currentNewKey ); |
|
4548 } |
|
4549 // DomainSpecific/<x>/ICESpecific/ServerReflexivePreference |
|
4550 if ( KErrNone == err || KErrNotFound == err ) |
|
4551 { |
|
4552 err = aRep->Delete( |
|
4553 KUNSAFProtocolsServerRefPref|currentNewKey ); |
|
4554 } |
|
4555 // DomainSpecific/<x>/ICESpecific/RelayPreference |
|
4556 if ( KErrNone == err || KErrNotFound == err ) |
|
4557 { |
|
4558 err = aRep->Delete( |
|
4559 KUNSAFProtocolsRelayPref|currentNewKey ); |
|
4560 } |
|
4561 // DomainSpecific/<x>/ICESpecific/PeerReflexivePreference |
|
4562 if ( KErrNone == err || KErrNotFound == err ) |
|
4563 { |
|
4564 err = aRep->Delete( |
|
4565 KUNSAFProtocolsPeerRefPref|currentNewKey ); |
|
4566 } |
|
4567 // DomainSpecific/<x>/ICESpecific/IPv4Preference |
|
4568 if ( KErrNone == err || KErrNotFound == err ) |
|
4569 { |
|
4570 err = aRep->Delete( |
|
4571 KUNSAFProtocolsIPV4Pref|currentNewKey ); |
|
4572 } |
|
4573 // DomainSpecific/<x>/ICESpecific/IPv6Preference |
|
4574 if ( KErrNone == err || KErrNotFound == err ) |
|
4575 { |
|
4576 err = aRep->Delete( |
|
4577 KUNSAFProtocolsIPV6Pref|currentNewKey ); |
|
4578 } |
|
4579 // DomainSpecific/<x>/ICESpecific/VPNPreference |
|
4580 if ( KErrNone == err || KErrNotFound == err ) |
|
4581 { |
|
4582 err = aRep->Delete( |
|
4583 KUNSAFProtocolsVPNPref|currentNewKey ); |
|
4584 } |
|
4585 // DomainSpecific/<x>/ICESpecific/UDPPreference |
|
4586 if ( KErrNone == err || KErrNotFound == err ) |
|
4587 { |
|
4588 err = aRep->Delete( |
|
4589 KUNSAFProtocolsUDPPref|currentNewKey ); |
|
4590 } |
|
4591 // DomainSpecific/<x>/ICESpecific/TCPPreference |
|
4592 if ( KErrNone == err || KErrNotFound == err ) |
|
4593 { |
|
4594 err = aRep->Delete( |
|
4595 KUNSAFProtocolsTCPPref|currentNewKey ); |
|
4596 } |
|
4597 // DomainSpecific/<x>/ICESpecific/TCPActivePreference |
|
4598 if ( KErrNone == err || KErrNotFound == err ) |
|
4599 { |
|
4600 err = aRep->Delete( |
|
4601 KUNSAFProtocolsTCPActivePref|currentNewKey ); |
|
4602 } |
|
4603 // DomainSpecific/<x>/ICESpecific/TCPPassivePreference |
|
4604 if ( KErrNone == err || KErrNotFound == err ) |
|
4605 { |
|
4606 err = aRep->Delete( |
|
4607 KUNSAFProtocolsTCPPassivePref|currentNewKey ); |
|
4608 } |
|
4609 // DomainSpecific/<x>/ICESpecific/TCPSimultaneousPreference |
|
4610 if ( KErrNone == err || KErrNotFound == err ) |
|
4611 { |
|
4612 err = aRep->Delete( |
|
4613 KUNSAFProtocolsTCPSimultPref|currentNewKey ); |
|
4614 } |
|
4615 |
|
4616 if ( KErrNone == err || KErrNotFound == err ) |
|
4617 { |
|
4618 retValue = EOk; |
|
4619 } |
|
4620 else |
|
4621 { |
|
4622 retValue = EError; |
|
4623 } |
|
4624 iDmCallback->SetStatusL( |
|
4625 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
4626 keys.Close(); |
|
4627 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
4628 } |
|
4629 } |
|
4630 |
|
4631 // IAPSpecific/x/ delete commands |
|
4632 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
4633 counter++ ) |
|
4634 { |
|
4635 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
4636 TDMNATFWStatusInfo::EDMDeleteIAP ) |
|
4637 { |
|
4638 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
4639 RArray<TUint32> keys; |
|
4640 CleanupClosePushL( keys ); // CS:2 |
|
4641 aRep->FindL( KUNSAFProtocolsIAPIdMask, |
|
4642 KUNSAFProtocolsFieldTypeMask, keys ); |
|
4643 TInt32 currentKey = iNATFWCommandBuffer[counter].iKeyId; |
|
4644 currentKey &= KUNSAFProtocolsKeyMask; |
|
4645 |
|
4646 // Delete keys. |
|
4647 TInt err = aRep->Delete( |
|
4648 KUNSAFProtocolsIAPIdMask|currentKey ); |
|
4649 if ( KErrNone == err ) |
|
4650 { |
|
4651 err = aRep->Delete( |
|
4652 KUNSAFProtocolsIntervalUDPMask|currentKey ); |
|
4653 } |
|
4654 if ( KErrNone == err ) |
|
4655 { |
|
4656 err = aRep->Delete( |
|
4657 KUNSAFProtocolsIntervalTCPMask|currentKey ); |
|
4658 } |
|
4659 if ( KErrNone == err ) |
|
4660 { |
|
4661 err = aRep->Delete( |
|
4662 KUNSAFProtocolsSTUNRetransmitTimerMask|currentKey ); |
|
4663 } |
|
4664 if ( KErrNone == err ) |
|
4665 { |
|
4666 retValue = EOk; |
|
4667 } |
|
4668 else |
|
4669 { |
|
4670 retValue = EError; |
|
4671 } |
|
4672 iDmCallback->SetStatusL( |
|
4673 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
4674 keys.Close(); |
|
4675 CleanupStack::PopAndDestroy( &keys ); // CS:1 |
|
4676 } |
|
4677 } |
|
4678 |
|
4679 // DomainSpecific/<x>/AdditionalSTUNServer/<x>/ delete commands |
|
4680 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
4681 counter++ ) |
|
4682 { |
|
4683 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
4684 TDMNATFWStatusInfo::EDMDeleteSTUN ) |
|
4685 { |
|
4686 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
4687 |
|
4688 TUint32 stunKey = iNATFWCommandBuffer[counter].iKeyId; |
|
4689 // Remove STUN server address mask from key. |
|
4690 stunKey ^= KUNSAFProtocolsSTUNAddressMask; |
|
4691 |
|
4692 TInt err = aRep->Delete( |
|
4693 KUNSAFProtocolsSTUNAddressMask|stunKey ); |
|
4694 if ( KErrNone == err ) |
|
4695 { |
|
4696 err = aRep->Delete( |
|
4697 KUNSAFProtocolsSTUNPortMask|stunKey ); |
|
4698 } |
|
4699 if ( KErrNone == err ) |
|
4700 { |
|
4701 retValue = EOk; |
|
4702 } |
|
4703 else |
|
4704 { |
|
4705 retValue = EError; |
|
4706 } |
|
4707 iDmCallback->SetStatusL( |
|
4708 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
4709 } |
|
4710 } |
|
4711 |
|
4712 // DomainSpecific/<x>/TURNSpecific/TURNServer/<x>/ delete commands |
|
4713 for ( TInt counter = 0; counter < iNATFWCommandBuffer.Count(); |
|
4714 counter++ ) |
|
4715 { |
|
4716 if ( iNATFWCommandBuffer[counter].iCommandType == |
|
4717 TDMNATFWStatusInfo::EDMDeleteTURN ) |
|
4718 { |
|
4719 CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; |
|
4720 |
|
4721 TUint32 turnKey = iNATFWCommandBuffer[counter].iKeyId; |
|
4722 // Remove TURN server address mask from key. |
|
4723 turnKey ^= KUNSAFProtocolsTURNAddressMask; |
|
4724 |
|
4725 TInt err = aRep->Delete( |
|
4726 KUNSAFProtocolsTURNAddressMask|turnKey ); |
|
4727 if ( KErrNone == err ) |
|
4728 { |
|
4729 err = aRep->Delete( |
|
4730 KUNSAFProtocolsTURNPortMask|turnKey ); |
|
4731 } |
|
4732 if ( KErrNone == err ) |
|
4733 { |
|
4734 err = aRep->Delete( |
|
4735 KUNSAFProtocolsTURNUsernameMask|turnKey ); |
|
4736 } |
|
4737 if ( KErrNone == err ) |
|
4738 { |
|
4739 err = aRep->Delete( |
|
4740 KUNSAFProtocolsTURNPasswordMask|turnKey ); |
|
4741 } |
|
4742 |
|
4743 if ( KErrNone == err ) |
|
4744 { |
|
4745 retValue = EOk; |
|
4746 } |
|
4747 else |
|
4748 { |
|
4749 retValue = EError; |
|
4750 } |
|
4751 iDmCallback->SetStatusL( |
|
4752 iNATFWCommandBuffer[counter].iStatusRef, retValue ); |
|
4753 } |
|
4754 } |
|
4755 } |
|
4756 |
|
4757 // --------------------------------------------------------------------------- |
|
4758 // CNSmlDmNATFWTraversalAdapter::GetDomainSettingsL |
|
4759 // Gets one domain settings entry. |
|
4760 // --------------------------------------------------------------------------- |
|
4761 // |
|
4762 void CNSmlDmNATFWTraversalAdapter::GetDomainSettingsL( TUint32 aDomainKeyId, |
|
4763 CNATFWDomainEntry& aEntry ) |
|
4764 { |
|
4765 // Central Repository for NAT-FW Traversal settings. |
|
4766 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
4767 |
|
4768 // Select domain. |
|
4769 TUint32 key = 0; |
|
4770 key = ( KUNSAFProtocolsDomainMask^( aDomainKeyId ) ); |
|
4771 key |= KUNSAFProtocolsDomainTableMask; |
|
4772 |
|
4773 // Set key ID to entry. |
|
4774 aEntry.SetDomainKey( aDomainKeyId ); |
|
4775 |
|
4776 // Set Domain to entry. |
|
4777 TInt actualLength = 0; |
|
4778 TBuf8<1> tmp; |
|
4779 rep->Get( KUNSAFProtocolsDomainMask|key, tmp, actualLength ); |
|
4780 |
|
4781 if ( actualLength > 0 ) |
|
4782 { |
|
4783 HBufC8* domainName = HBufC8::NewLC( actualLength ); // CS:2 |
|
4784 TPtr8 ptr( domainName->Des() ); |
|
4785 TInt err = rep->Get( KUNSAFProtocolsDomainMask|key, ptr ); |
|
4786 if ( KErrNone == err ) |
|
4787 { |
|
4788 aEntry.SetDomainL( domainName->Des() ); |
|
4789 } |
|
4790 else |
|
4791 { |
|
4792 aEntry.SetDomainL( KNSmlDMNATFWValueNotSet ); |
|
4793 } |
|
4794 CleanupStack::PopAndDestroy( domainName ); // CS:1 |
|
4795 actualLength = 0; |
|
4796 } |
|
4797 else |
|
4798 { |
|
4799 aEntry.SetDomainL( KNSmlDMNATFWValueNotSet ); |
|
4800 } |
|
4801 |
|
4802 // Set STUN server address to entry. |
|
4803 rep->Get( KUNSAFProtocolsSTUNServerMask|key, tmp, actualLength ); |
|
4804 |
|
4805 if ( actualLength > 0 ) |
|
4806 { |
|
4807 HBufC8* stunServerAddr = HBufC8::NewLC( actualLength ); // CS:2 |
|
4808 TPtr8 ptr ( stunServerAddr->Des() ); |
|
4809 TInt err = rep->Get( KUNSAFProtocolsSTUNServerMask|key, ptr ); |
|
4810 if ( err == KErrNone ) |
|
4811 { |
|
4812 aEntry.SetSTUNServerAddrL( stunServerAddr->Des() ); |
|
4813 } |
|
4814 else |
|
4815 { |
|
4816 aEntry.SetSTUNServerAddrL( KNSmlDMNATFWValueNotSet ); |
|
4817 } |
|
4818 CleanupStack::PopAndDestroy( stunServerAddr ); // CS:1 |
|
4819 } |
|
4820 else |
|
4821 { |
|
4822 aEntry.SetSTUNServerAddrL( KNSmlDMNATFWValueNotSet ); |
|
4823 } |
|
4824 |
|
4825 // STUN server port. |
|
4826 TInt tmpValue( KErrNotFound ); |
|
4827 rep->Get( KUNSAFProtocolsSTUNServerPortMask|key, tmpValue ); |
|
4828 aEntry.SetSTUNServerPort( tmpValue ); |
|
4829 |
|
4830 // STUN server username. |
|
4831 rep->Get( KUNSAFProtocolsSTUNUsernameMask|key, tmp, actualLength ); |
|
4832 |
|
4833 if ( actualLength > 0 ) |
|
4834 { |
|
4835 HBufC8* stunUsername = HBufC8::NewLC( actualLength ); // CS:2 |
|
4836 TPtr8 ptr ( stunUsername->Des() ); |
|
4837 TInt err = rep->Get( KUNSAFProtocolsSTUNUsernameMask|key, ptr ); |
|
4838 if ( err == KErrNone ) |
|
4839 { |
|
4840 aEntry.SetSTUNUsernameL( stunUsername->Des() ); |
|
4841 } |
|
4842 else |
|
4843 { |
|
4844 aEntry.SetSTUNUsernameL( KNSmlDMNATFWValueNotSet ); |
|
4845 } |
|
4846 CleanupStack::PopAndDestroy( stunUsername ); // CS:1 |
|
4847 } |
|
4848 else |
|
4849 { |
|
4850 aEntry.SetSTUNUsernameL( KNSmlDMNATFWValueNotSet ); |
|
4851 } |
|
4852 |
|
4853 // STUN server password. |
|
4854 rep->Get( KUNSAFProtocolsSTUNPasswordMask|key, tmp, actualLength ); |
|
4855 |
|
4856 if ( actualLength > 0 ) |
|
4857 { |
|
4858 HBufC8* stunPassword = HBufC8::NewLC( actualLength ); // CS:2 |
|
4859 TPtr8 ptr ( stunPassword->Des() ); |
|
4860 TInt err = rep->Get( KUNSAFProtocolsSTUNPasswordMask|key, ptr ); |
|
4861 if ( err == KErrNone ) |
|
4862 { |
|
4863 aEntry.SetSTUNPasswordL( stunPassword->Des() ); |
|
4864 } |
|
4865 else |
|
4866 { |
|
4867 aEntry.SetSTUNPasswordL( KNSmlDMNATFWValueNotSet ); |
|
4868 } |
|
4869 CleanupStack::PopAndDestroy( stunPassword ); // CS:1 |
|
4870 } |
|
4871 else |
|
4872 { |
|
4873 aEntry.SetSTUNPasswordL( KNSmlDMNATFWValueNotSet ); |
|
4874 } |
|
4875 |
|
4876 // NAT refresh interval for UDP |
|
4877 tmpValue = KErrNotFound; |
|
4878 rep->Get( KUNSAFProtocolsDomainIntervalUDPMask|key, tmpValue ); |
|
4879 aEntry.SetNATRefreshUDP( tmpValue ); |
|
4880 |
|
4881 // NAT refresh interval for TCP |
|
4882 tmpValue = KErrNotFound; |
|
4883 rep->Get( KUNSAFProtocolsDomainIntervalTCPMask|key, tmpValue ); |
|
4884 aEntry.SetNATRefreshTCP( tmpValue ); |
|
4885 |
|
4886 // CRLF-based NAT binding refresh |
|
4887 tmpValue = KErrNotFound; |
|
4888 rep->Get( KUNSAFProtocolsDomainEnableCRLFRefresh|key, tmpValue ); |
|
4889 aEntry.SetEnableCRLFRefresh( tmpValue ); |
|
4890 |
|
4891 RArray<TUint32> stunKeys; |
|
4892 CleanupClosePushL( stunKeys ); // CS:2 |
|
4893 rep->FindL( key|KUNSAFProtocolsSTUNAddressMask, |
|
4894 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
4895 TInt stunKeyCount = stunKeys.Count(); |
|
4896 for ( TInt counter = 0; counter < stunKeyCount; counter++ ) |
|
4897 { |
|
4898 // Remove STUN server address mask from key. |
|
4899 TUint32 tmpKey = KUNSAFProtocolsSTUNAddressMask^stunKeys[counter]; |
|
4900 |
|
4901 // STUNSrvAddr |
|
4902 actualLength = 0; |
|
4903 rep->Get( tmpKey|KUNSAFProtocolsSTUNAddressMask, tmp, actualLength ); |
|
4904 if ( actualLength > 0 ) |
|
4905 { |
|
4906 HBufC8* stunSrvAddr = HBufC8::NewLC( actualLength ); // CS:3 |
|
4907 TPtr8 ptr( stunSrvAddr->Des() ); |
|
4908 TInt err = rep->Get( tmpKey|KUNSAFProtocolsSTUNAddressMask, |
|
4909 ptr ); |
|
4910 if ( KErrNone == err ) |
|
4911 { |
|
4912 aEntry.AddStunSrvAddrL( stunSrvAddr->Des() ); |
|
4913 } |
|
4914 else |
|
4915 { |
|
4916 aEntry.AddStunSrvAddrL( KNSmlDMNATFWValueNotSet ); |
|
4917 } |
|
4918 CleanupStack::PopAndDestroy( stunSrvAddr ); // CS:2 |
|
4919 } |
|
4920 else |
|
4921 { |
|
4922 aEntry.AddStunSrvAddrL( KNSmlDMNATFWValueNotSet ); |
|
4923 } |
|
4924 |
|
4925 // STUNSrvPort |
|
4926 tmpValue = KErrNotFound; |
|
4927 rep->Get( tmpKey|KUNSAFProtocolsSTUNPortMask, tmpValue ); |
|
4928 aEntry.AddStunSrvPortL( tmpValue ); |
|
4929 |
|
4930 // STUNUsername |
|
4931 actualLength = 0; |
|
4932 rep->Get( tmpKey|KUNSAFProtocolsSTUNUsernameMask, tmp, actualLength ); |
|
4933 if ( actualLength > 0 ) |
|
4934 { |
|
4935 HBufC8* stunUsername = HBufC8::NewLC( actualLength ); // CS:3 |
|
4936 TPtr8 ptr( stunUsername->Des() ); |
|
4937 TInt err = rep->Get( tmpKey|KUNSAFProtocolsSTUNUsernameMask, |
|
4938 ptr ); |
|
4939 if ( KErrNone == err ) |
|
4940 { |
|
4941 aEntry.AddStunUsernameL( stunUsername->Des() ); |
|
4942 } |
|
4943 else |
|
4944 { |
|
4945 aEntry.AddStunUsernameL( KNSmlDMNATFWValueNotSet ); |
|
4946 } |
|
4947 CleanupStack::PopAndDestroy( stunUsername ); // CS:2 |
|
4948 } |
|
4949 else |
|
4950 { |
|
4951 aEntry.AddStunUsernameL( KNSmlDMNATFWValueNotSet ); |
|
4952 } |
|
4953 |
|
4954 // STUNPassword |
|
4955 actualLength = 0; |
|
4956 rep->Get( tmpKey|KUNSAFProtocolsSTUNPasswordMask, tmp, actualLength ); |
|
4957 if ( actualLength > 0 ) |
|
4958 { |
|
4959 HBufC8* stunPassword = HBufC8::NewLC( actualLength ); // CS:3 |
|
4960 TPtr8 ptr( stunPassword->Des() ); |
|
4961 TInt err = rep->Get( tmpKey|KUNSAFProtocolsSTUNPasswordMask, |
|
4962 ptr ); |
|
4963 if ( KErrNone == err ) |
|
4964 { |
|
4965 aEntry.AddStunPasswordL( stunPassword->Des() ); |
|
4966 } |
|
4967 else |
|
4968 { |
|
4969 aEntry.AddStunPasswordL( KNSmlDMNATFWValueNotSet ); |
|
4970 } |
|
4971 CleanupStack::PopAndDestroy( stunPassword ); // CS:2 |
|
4972 } |
|
4973 else |
|
4974 { |
|
4975 aEntry.AddStunSrvAddrL( KNSmlDMNATFWValueNotSet ); |
|
4976 } |
|
4977 } |
|
4978 stunKeys.Close(); |
|
4979 CleanupStack::PopAndDestroy( &stunKeys ); // CS:1 |
|
4980 |
|
4981 // STUNSharedSecret |
|
4982 tmpValue = KErrNotFound; |
|
4983 rep->Get( key|KUNSAFProtocolsDomainSharedSecretNotSupported, |
|
4984 tmpValue ); |
|
4985 aEntry.SetDisableStunSharedSecret( tmpValue ); |
|
4986 |
|
4987 // PortPoolStartPort |
|
4988 tmpValue = KErrNotFound; |
|
4989 rep->Get( key|KUNSAFProtocolsPortPoolStartPortMask, tmpValue ); |
|
4990 aEntry.SetStartPortRange( tmpValue ); |
|
4991 |
|
4992 // PortPoolEndPort |
|
4993 tmpValue = KErrNotFound; |
|
4994 rep->Get( key|KUNSAFProtocolsPortPoolEndPortMask, tmpValue ); |
|
4995 aEntry.SetEndPortRange( tmpValue ); |
|
4996 |
|
4997 // UsedNATProtocol |
|
4998 rep->Get( KUNSAFProtocolsUsedNATProtocolMask|key, tmp, actualLength ); |
|
4999 if ( actualLength > 0 ) |
|
5000 { |
|
5001 HBufC8* natProtocol = HBufC8::NewLC( actualLength ); // CS:2 |
|
5002 TPtr8 ptr ( natProtocol->Des() ); |
|
5003 TInt err = rep->Get( KUNSAFProtocolsUsedNATProtocolMask|key, ptr ); |
|
5004 if ( err == KErrNone ) |
|
5005 { |
|
5006 aEntry.SetNatProtocolL( natProtocol->Des() ); |
|
5007 } |
|
5008 else |
|
5009 { |
|
5010 aEntry.SetNatProtocolL( KNSmlDMNATFWValueNotSet ); |
|
5011 } |
|
5012 CleanupStack::PopAndDestroy( natProtocol ); // CS:1 |
|
5013 } |
|
5014 else |
|
5015 { |
|
5016 aEntry.SetNatProtocolL( KNSmlDMNATFWValueNotSet ); |
|
5017 } |
|
5018 |
|
5019 // ICESpecific/NATUtilities |
|
5020 rep->Get( KUNSAFProtocolsNATUtilities|key, tmp, actualLength ); |
|
5021 if ( actualLength > 0 ) |
|
5022 { |
|
5023 HBufC8* natUtils = HBufC8::NewLC( actualLength ); // CS:2 |
|
5024 TPtr8 ptr ( natUtils->Des() ); |
|
5025 TInt err = rep->Get( KUNSAFProtocolsNATUtilities|key, ptr ); |
|
5026 if ( err == KErrNone ) |
|
5027 { |
|
5028 aEntry.SetNatUtilitiesL( natUtils->Des() ); |
|
5029 } |
|
5030 else |
|
5031 { |
|
5032 aEntry.SetNatUtilitiesL( KNSmlDMNATFWValueNotSet ); |
|
5033 } |
|
5034 CleanupStack::PopAndDestroy( natUtils ); // CS:1 |
|
5035 } |
|
5036 else |
|
5037 { |
|
5038 aEntry.SetNatProtocolL( KNSmlDMNATFWValueNotSet ); |
|
5039 } |
|
5040 |
|
5041 // ICESpecific/HostPreference |
|
5042 tmpValue = KErrNotFound; |
|
5043 rep->Get( key|KUNSAFProtocolsHostPref, tmpValue ); |
|
5044 aEntry.SetHostPref( tmpValue ); |
|
5045 |
|
5046 // ICESpecific/ServerReflexivePreference |
|
5047 tmpValue = KErrNotFound; |
|
5048 rep->Get( key|KUNSAFProtocolsServerRefPref, tmpValue ); |
|
5049 aEntry.SetServerReflexPref( tmpValue ); |
|
5050 |
|
5051 // ICESpecific/RelayPreference |
|
5052 tmpValue = KErrNotFound; |
|
5053 rep->Get( key|KUNSAFProtocolsRelayPref, tmpValue ); |
|
5054 aEntry.SetRelayPref( tmpValue ); |
|
5055 |
|
5056 // ICESpecific/PeerReflexivePreference |
|
5057 tmpValue = KErrNotFound; |
|
5058 rep->Get( key|KUNSAFProtocolsPeerRefPref, tmpValue ); |
|
5059 aEntry.SetPeerReflexPref( tmpValue ); |
|
5060 |
|
5061 // ICESpecific/IPv4Preference |
|
5062 tmpValue = KErrNotFound; |
|
5063 rep->Get( key|KUNSAFProtocolsIPV4Pref, tmpValue ); |
|
5064 aEntry.SetIPv4Pref( tmpValue ); |
|
5065 |
|
5066 // ICESpecific/IPv6Preference |
|
5067 tmpValue = KErrNotFound; |
|
5068 rep->Get( key|KUNSAFProtocolsIPV6Pref, tmpValue ); |
|
5069 aEntry.SetIPv6Pref( tmpValue ); |
|
5070 |
|
5071 // ICESpecific/VPNPreference |
|
5072 tmpValue = KErrNotFound; |
|
5073 rep->Get( key|KUNSAFProtocolsVPNPref, tmpValue ); |
|
5074 aEntry.SetVpnPref( tmpValue ); |
|
5075 |
|
5076 // ICESpecific/UDPPreference |
|
5077 tmpValue = KErrNotFound; |
|
5078 rep->Get( key|KUNSAFProtocolsUDPPref, tmpValue ); |
|
5079 aEntry.SetUdpPref( tmpValue ); |
|
5080 |
|
5081 // ICESpecific/TCPPreference |
|
5082 tmpValue = KErrNotFound; |
|
5083 rep->Get( key|KUNSAFProtocolsTCPPref, tmpValue ); |
|
5084 aEntry.SetTcpPref( tmpValue ); |
|
5085 |
|
5086 // ICESpecific/TCPActivePreference |
|
5087 tmpValue = KErrNotFound; |
|
5088 rep->Get( key|KUNSAFProtocolsTCPActivePref, tmpValue ); |
|
5089 aEntry.SetTcpActivePref( tmpValue ); |
|
5090 |
|
5091 // ICESpecific/TCPPassivePreference |
|
5092 tmpValue = KErrNotFound; |
|
5093 rep->Get( key|KUNSAFProtocolsTCPPassivePref, tmpValue ); |
|
5094 aEntry.SetTcpPassivePref( tmpValue ); |
|
5095 |
|
5096 // ICESpecific/TCPSimultaneousPreference |
|
5097 tmpValue = KErrNotFound; |
|
5098 rep->Get( key|KUNSAFProtocolsTCPSimultPref, tmpValue ); |
|
5099 aEntry.SetTcpSimultPref( tmpValue ); |
|
5100 |
|
5101 // TURNSpecific/TURNServer/<x>/ |
|
5102 RArray<TUint32> turnKeys; |
|
5103 CleanupClosePushL( turnKeys ); // CS:2 |
|
5104 rep->FindL( key|KUNSAFProtocolsTURNAddressMask, |
|
5105 KUNSAFProtocolsSubTableFieldTypeMask, turnKeys ); |
|
5106 TInt turnKeyCount = turnKeys.Count(); |
|
5107 for ( TInt counter = 0; counter < turnKeyCount; counter++ ) |
|
5108 { |
|
5109 // Remove TURN server address mask from key. |
|
5110 TUint32 tmpKey = KUNSAFProtocolsTURNAddressMask^turnKeys[counter]; |
|
5111 |
|
5112 // TURNSrvAddr |
|
5113 actualLength = 0; |
|
5114 rep->Get( tmpKey|KUNSAFProtocolsTURNAddressMask, tmp, actualLength ); |
|
5115 if ( actualLength > 0 ) |
|
5116 { |
|
5117 HBufC8* turnSrvAddr = HBufC8::NewLC( actualLength ); // CS:3 |
|
5118 TPtr8 ptr( turnSrvAddr->Des() ); |
|
5119 TInt err = rep->Get( tmpKey|KUNSAFProtocolsTURNAddressMask, |
|
5120 ptr ); |
|
5121 if ( KErrNone == err ) |
|
5122 { |
|
5123 aEntry.AddTurnSrvAddrL( turnSrvAddr->Des() ); |
|
5124 } |
|
5125 else |
|
5126 { |
|
5127 aEntry.AddTurnSrvAddrL( KNSmlDMNATFWValueNotSet ); |
|
5128 } |
|
5129 CleanupStack::PopAndDestroy( turnSrvAddr ); // CS:2 |
|
5130 } |
|
5131 else |
|
5132 { |
|
5133 aEntry.AddTurnSrvAddrL( KNSmlDMNATFWValueNotSet ); |
|
5134 } |
|
5135 |
|
5136 // TURNSrvPort |
|
5137 tmpValue = KErrNotFound; |
|
5138 rep->Get( tmpKey|KUNSAFProtocolsTURNPortMask, tmpValue ); |
|
5139 aEntry.AddTurnSrvPortL( tmpValue ); |
|
5140 |
|
5141 // TURNUsername |
|
5142 actualLength = 0; |
|
5143 rep->Get( tmpKey|KUNSAFProtocolsTURNUsernameMask, tmp, actualLength ); |
|
5144 if ( actualLength > 0 ) |
|
5145 { |
|
5146 HBufC8* turnUsername = HBufC8::NewLC( actualLength ); // CS:3 |
|
5147 TPtr8 ptr( turnUsername->Des() ); |
|
5148 TInt err = rep->Get( tmpKey|KUNSAFProtocolsTURNUsernameMask, |
|
5149 ptr ); |
|
5150 if ( KErrNone == err ) |
|
5151 { |
|
5152 aEntry.AddTurnUsernameL( turnUsername->Des() ); |
|
5153 } |
|
5154 else |
|
5155 { |
|
5156 aEntry.AddTurnUsernameL( KNSmlDMNATFWValueNotSet ); |
|
5157 } |
|
5158 CleanupStack::PopAndDestroy( turnUsername ); // CS:2 |
|
5159 } |
|
5160 else |
|
5161 { |
|
5162 aEntry.AddTurnUsernameL( KNSmlDMNATFWValueNotSet ); |
|
5163 } |
|
5164 |
|
5165 // TURNPassword |
|
5166 actualLength = 0; |
|
5167 rep->Get( tmpKey|KUNSAFProtocolsTURNPasswordMask, tmp, actualLength ); |
|
5168 if ( actualLength > 0 ) |
|
5169 { |
|
5170 HBufC8* turnPassword = HBufC8::NewLC( actualLength ); // CS:3 |
|
5171 TPtr8 ptr( turnPassword->Des() ); |
|
5172 TInt err = rep->Get( tmpKey|KUNSAFProtocolsTURNPasswordMask, |
|
5173 ptr ); |
|
5174 if ( KErrNone == err ) |
|
5175 { |
|
5176 aEntry.AddTurnPasswordL( turnPassword->Des() ); |
|
5177 } |
|
5178 else |
|
5179 { |
|
5180 aEntry.AddTurnPasswordL( KNSmlDMNATFWValueNotSet ); |
|
5181 } |
|
5182 CleanupStack::PopAndDestroy( turnPassword ); // CS:2 |
|
5183 } |
|
5184 else |
|
5185 { |
|
5186 aEntry.AddTurnPasswordL( KNSmlDMNATFWValueNotSet ); |
|
5187 } |
|
5188 } |
|
5189 turnKeys.Close(); |
|
5190 CleanupStack::PopAndDestroy( &turnKeys ); // CS:1 |
|
5191 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
5192 } |
|
5193 |
|
5194 // --------------------------------------------------------------------------- |
|
5195 // CNSmlDmNATFWTraversalAdapter::GetIAPSettingsL |
|
5196 // Gets one IAP settings entry. |
|
5197 // --------------------------------------------------------------------------- |
|
5198 // |
|
5199 void CNSmlDmNATFWTraversalAdapter::GetIAPSettingsL( TUint32 aIAPKey, |
|
5200 CNATFWIAPEntry& aEntry ) |
|
5201 { |
|
5202 // Central Repository for NAT-FW Traversal settings. |
|
5203 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
5204 |
|
5205 TUint32 key( KErrNone ); |
|
5206 // Select IAP. |
|
5207 key = ( KUNSAFProtocolsIAPIdMask^( aIAPKey ) ); |
|
5208 key |= KUNSAFProtocolsIAPTableMask; |
|
5209 |
|
5210 // Set key ID. |
|
5211 aEntry.SetIAPKey( aIAPKey ); |
|
5212 TInt tmp( KErrNotFound ); |
|
5213 rep->Get( KUNSAFProtocolsIAPIdMask|key, tmp ); |
|
5214 aEntry.SetIAPId( tmp ); |
|
5215 tmp = KErrNotFound; |
|
5216 rep->Get( KUNSAFProtocolsIntervalUDPMask|key, tmp ); |
|
5217 aEntry.SetIntervalUDP( tmp ); |
|
5218 tmp = KErrNotFound; |
|
5219 rep->Get( KUNSAFProtocolsIntervalTCPMask|key, tmp ); |
|
5220 aEntry.SetIntervalTCP( tmp ); |
|
5221 tmp = KErrNotFound; |
|
5222 rep->Get( KUNSAFProtocolsSTUNRetransmitTimerMask|key, tmp ); |
|
5223 aEntry.SetSTUNRetransmitTimer( tmp ); |
|
5224 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
5225 } |
|
5226 |
|
5227 // --------------------------------------------------------------------------- |
|
5228 // CNSmlDmNATFWTraversalAdapter::FindDomainLocation |
|
5229 // |
|
5230 // --------------------------------------------------------------------------- |
|
5231 // |
|
5232 TInt CNSmlDmNATFWTraversalAdapter::FindDomainLocation( const TDesC8& aLUID ) |
|
5233 { |
|
5234 for ( TInt counter = 0; counter < iNATFWDomainEntries->Count(); counter++ ) |
|
5235 { |
|
5236 if ( iNATFWDomainEntries->At( counter )->GetDomainKey() == |
|
5237 DesToInt( LastURISeg( aLUID ) ) ) |
|
5238 { |
|
5239 return counter; |
|
5240 } |
|
5241 } |
|
5242 return KErrNotFound; |
|
5243 } |
|
5244 |
|
5245 // --------------------------------------------------------------------------- |
|
5246 // CNSmlDmNATFWTraversalAdapter::FindDomainLocation |
|
5247 // |
|
5248 // --------------------------------------------------------------------------- |
|
5249 // |
|
5250 TInt CNSmlDmNATFWTraversalAdapter::FindDomainLocation( |
|
5251 const TUint32 aDomainKey ) |
|
5252 { |
|
5253 for ( TInt counter = 0; counter < iNATFWDomainEntries->Count(); counter++ ) |
|
5254 { |
|
5255 if ( iNATFWDomainEntries->At( counter )->GetDomainKey() |
|
5256 == aDomainKey ) |
|
5257 { |
|
5258 return counter; |
|
5259 } |
|
5260 } |
|
5261 return KErrNotFound; |
|
5262 } |
|
5263 |
|
5264 // --------------------------------------------------------------------------- |
|
5265 // CNSmlDmNATFWTraversalAdapter::FindIAPLocation |
|
5266 // |
|
5267 // --------------------------------------------------------------------------- |
|
5268 // |
|
5269 TInt CNSmlDmNATFWTraversalAdapter::FindIAPLocation( const TDesC8& aLUID ) |
|
5270 { |
|
5271 for ( TInt counter = 0; counter < iNATFWIAPEntries->Count(); counter++ ) |
|
5272 { |
|
5273 if ( iNATFWIAPEntries->At( counter )->GetIAPKey() == DesToTUint( |
|
5274 LastURISeg( aLUID ) ) ) |
|
5275 { |
|
5276 return counter; |
|
5277 } |
|
5278 } |
|
5279 return KErrNotFound; |
|
5280 } |
|
5281 |
|
5282 // --------------------------------------------------------------------------- |
|
5283 // CNSmlDmNATFWTraversalAdapter::FindIAPLocation |
|
5284 // |
|
5285 // --------------------------------------------------------------------------- |
|
5286 // |
|
5287 TInt CNSmlDmNATFWTraversalAdapter::FindIAPLocation( const TUint32 aIAPKey ) |
|
5288 { |
|
5289 for ( TInt counter = 0; counter < iNATFWIAPEntries->Count(); counter++ ) |
|
5290 { |
|
5291 if ( iNATFWIAPEntries->At( counter )->GetIAPKey() == aIAPKey ) |
|
5292 { |
|
5293 return counter; |
|
5294 } |
|
5295 } |
|
5296 return KErrNotFound; |
|
5297 } |
|
5298 |
|
5299 // --------------------------------------------------------------------------- |
|
5300 // CNSmlDmNATFWTraversalAdapter::SetConRefL |
|
5301 // Set conref value. |
|
5302 // --------------------------------------------------------------------------- |
|
5303 // |
|
5304 TInt CNSmlDmNATFWTraversalAdapter::SetConRefL( const TDesC8& aObject, |
|
5305 TInt aProfileLoc ) |
|
5306 { |
|
5307 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::SetConRefL() : begin"); |
|
5308 CNSmlDMIAPMatcher* iapmatch = CNSmlDMIAPMatcher::NewL( iDmCallback ); |
|
5309 CleanupStack::PushL( iapmatch ); // CS:1 |
|
5310 TInt lIAPid = iapmatch->IAPIdFromURIL( aObject ); |
|
5311 if ( KErrNotFound != lIAPid ) |
|
5312 { |
|
5313 iNATFWIAPEntries->At( aProfileLoc )->SetIAPId( ( TUint32 )lIAPid ); |
|
5314 } |
|
5315 CleanupStack::PopAndDestroy( iapmatch ); // CS:0 |
|
5316 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::SetConRefL() : end"); |
|
5317 return lIAPid; |
|
5318 } |
|
5319 |
|
5320 // --------------------------------------------------------------------------- |
|
5321 // CNSmlDmNATFWTraversalAdapter::GetConRefL |
|
5322 // Get URI for given accesspoint ID. |
|
5323 // Returns: TBool: True if connection reference found |
|
5324 // --------------------------------------------------------------------------- |
|
5325 // |
|
5326 TBool CNSmlDmNATFWTraversalAdapter::GetConRefL( CBufBase& aObject, |
|
5327 TInt aProfileLoc ) |
|
5328 { |
|
5329 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::GetConRefL() : begin"); |
|
5330 TBool found = EFalse; |
|
5331 |
|
5332 CNSmlDMIAPMatcher* iapmatch = CNSmlDMIAPMatcher::NewL( iDmCallback ); |
|
5333 CleanupStack::PushL( iapmatch ); // CS:1 |
|
5334 |
|
5335 // Get current access point ID. |
|
5336 TUint32 profIAPid; |
|
5337 profIAPid = iNATFWIAPEntries->At( aProfileLoc )->GetIAPId(); |
|
5338 |
|
5339 HBufC8* uri8 = iapmatch->URIFromIAPIdL( profIAPid ); |
|
5340 CleanupStack::PushL( uri8 ); // CS:2 |
|
5341 if ( uri8 ) |
|
5342 { |
|
5343 aObject.InsertL( aObject.Size(), uri8->Des() ); |
|
5344 found = ETrue; |
|
5345 } |
|
5346 CleanupStack::PopAndDestroy( uri8 ); // CS:1 |
|
5347 CleanupStack::PopAndDestroy( iapmatch ); // CS:0 |
|
5348 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::GetConRefL() : end"); |
|
5349 return found; |
|
5350 } |
|
5351 |
|
5352 // --------------------------------------------------------------------------- |
|
5353 // CNSmlDmNATFWTraversalAdapter::DesToTUint |
|
5354 // Converts a 8bit descriptor to TUint. |
|
5355 // Returns: TUint: |
|
5356 // --------------------------------------------------------------------------- |
|
5357 TUint CNSmlDmNATFWTraversalAdapter::DesToTUint( const TDesC8& aDes ) |
|
5358 { |
|
5359 TLex8 lex( aDes ); |
|
5360 TUint value = 0; |
|
5361 lex.Val( value ); |
|
5362 return value; |
|
5363 } |
|
5364 |
|
5365 // --------------------------------------------------------------------------- |
|
5366 // CNSmlDmNATFWTraversalAdapter::FetchObjectL |
|
5367 // Fetches the values of leaf objects. |
|
5368 // --------------------------------------------------------------------------- |
|
5369 // |
|
5370 CSmlDmAdapter::TError CNSmlDmNATFWTraversalAdapter::FetchObjectL( |
|
5371 const TDesC8& aURI, |
|
5372 const TDesC8& aLUID, |
|
5373 CBufBase& aObject ) |
|
5374 { |
|
5375 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::FetchLeafObjectL(): begin"); |
|
5376 CSmlDmAdapter::TError status = CSmlDmAdapter::EOk; |
|
5377 TBuf8< KNSmlNATFWMaxResultLength > segmentResult; |
|
5378 |
|
5379 // Load profile information if not loaded yet. |
|
5380 if ( !iNATFWDomainEntries || ! iNATFWIAPEntries ) |
|
5381 { |
|
5382 LoadProfilesL(); |
|
5383 } |
|
5384 |
|
5385 // ============================== |
|
5386 // DomainSpecific node |
|
5387 // ============================== |
|
5388 // |
|
5389 if ( KErrNotFound != aURI.Find( KNSmlDMDomainSpecificNodeName() ) |
|
5390 && ( KFourSegs == NumOfURISegs( aURI ) |
|
5391 || KFiveSegs == NumOfURISegs( aURI ) |
|
5392 ) ) |
|
5393 { |
|
5394 status = FetchDomainObjectL( aURI, aLUID, segmentResult ); |
|
5395 } |
|
5396 |
|
5397 // ============================== |
|
5398 // IAPSpecific/x/ |
|
5399 // ============================== |
|
5400 // |
|
5401 else if ( KErrNotFound != aURI.Find( KNSmlDMIAPSpecificNodeName() ) |
|
5402 && KFourSegs == NumOfURISegs( aURI ) ) |
|
5403 { |
|
5404 status = FetchIAPObjectL( aURI, aLUID, segmentResult, aObject ); |
|
5405 } |
|
5406 |
|
5407 // ============================== |
|
5408 // AdditionalSTUNServer/<x>/ |
|
5409 // ============================== |
|
5410 // |
|
5411 else if ( KErrNotFound != aURI.Find( KNSmlDMAdditionalSTUNNodeName() ) |
|
5412 && KSixSegs == NumOfURISegs( aURI ) |
|
5413 && KFourSegs == NumOfURISegs( aLUID ) ) |
|
5414 { |
|
5415 status = FetchAdditionalSTUNServerObjectL( aURI, aLUID, |
|
5416 segmentResult ); |
|
5417 } |
|
5418 |
|
5419 // ============================== |
|
5420 // TURNSpecific/TURNServer/<x>/ |
|
5421 // ============================== |
|
5422 // |
|
5423 else if ( KErrNotFound != aURI.Find( KNSmlDMTURNServerNodeName() ) |
|
5424 && KErrNotFound != aURI.Find( KNSmlDMTURNSpecificNodeName() ) |
|
5425 && KSevenSegs == NumOfURISegs( aURI ) |
|
5426 && KFiveSegs == NumOfURISegs( aLUID ) ) |
|
5427 { |
|
5428 status = FetchTURNServerObjectL( aURI, aLUID, |
|
5429 segmentResult ); |
|
5430 } |
|
5431 |
|
5432 else |
|
5433 { |
|
5434 // No node under NATFW found. |
|
5435 status = CSmlDmAdapter::ENotFound; |
|
5436 } |
|
5437 |
|
5438 if ( CSmlDmAdapter::EOk == status ) |
|
5439 { |
|
5440 aObject.InsertL( aObject.Size(), segmentResult ); |
|
5441 } |
|
5442 |
|
5443 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::FetchLeafObjectL(): end"); |
|
5444 return status; |
|
5445 } |
|
5446 |
|
5447 // --------------------------------------------------------------------------- |
|
5448 // CNSmlDmNATFWTraversalAdapter::FetchDomainObjectL |
|
5449 // Fetches the values of Domain specific leaf objects. |
|
5450 // --------------------------------------------------------------------------- |
|
5451 // |
|
5452 CSmlDmAdapter::TError CNSmlDmNATFWTraversalAdapter::FetchDomainObjectL( |
|
5453 const TDesC8& aURI, |
|
5454 const TDesC8& aLUID, |
|
5455 TDes8& aSegmentResult ) |
|
5456 { |
|
5457 CSmlDmAdapter::TError status = EOk; |
|
5458 TBuf8<KSmlMaxURISegLen> lastURISeg = LastURISeg( aURI ); |
|
5459 |
|
5460 TInt domainLoc = FindDomainLocation( aLUID ); |
|
5461 if ( KErrNotFound == domainLoc ) |
|
5462 { |
|
5463 status = CSmlDmAdapter::ENotFound; |
|
5464 return status; |
|
5465 } |
|
5466 |
|
5467 TBool iceSpecific( EFalse ); |
|
5468 TInt uriSegs = NumOfURISegs( aURI ); |
|
5469 if ( KErrNotFound != aURI.Find( KNSmlDMICESpecificNodeName() ) |
|
5470 && KFiveSegs == uriSegs ) |
|
5471 { |
|
5472 iceSpecific = ETrue; |
|
5473 } |
|
5474 |
|
5475 // Domain |
|
5476 if ( KNSmlDMDomain() == lastURISeg ) |
|
5477 { |
|
5478 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5479 At( domainLoc )->GetDomain() ); |
|
5480 } |
|
5481 // STUNSrvAddr |
|
5482 else if ( KNSmlDMSTUNSrvAddr() == lastURISeg ) |
|
5483 { |
|
5484 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5485 At( domainLoc )->GetSTUNAddr() ); |
|
5486 } |
|
5487 // STUNSrvPort |
|
5488 else if ( KNSmlDMSTUNSrvPort() == lastURISeg ) |
|
5489 { |
|
5490 aSegmentResult.Num( iNATFWDomainEntries-> |
|
5491 At( domainLoc )->GetSTUNPort() ); |
|
5492 } |
|
5493 |
|
5494 // STUNUsername |
|
5495 else if ( KNSmlDMSTUNUsername() == lastURISeg ) |
|
5496 { |
|
5497 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5498 At( domainLoc )->GetSTUNUsername() ); |
|
5499 } |
|
5500 // STUNPassword |
|
5501 else if ( KNSmlDMSTUNPassword() == lastURISeg ) |
|
5502 { |
|
5503 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5504 At( domainLoc )->GetSTUNPassword() ); |
|
5505 } |
|
5506 |
|
5507 // NATRefreshTCP |
|
5508 else if ( KNSmlDMDomainNATRefreshTCP() == lastURISeg ) |
|
5509 { |
|
5510 aSegmentResult.Num( iNATFWDomainEntries-> |
|
5511 At( domainLoc )->GetNATRefreshTCP() ); |
|
5512 } |
|
5513 // NATRefreshUDP |
|
5514 else if ( KNSmlDMDomainNATRefreshUDP() == lastURISeg ) |
|
5515 { |
|
5516 aSegmentResult.Num( iNATFWDomainEntries-> |
|
5517 At( domainLoc )->GetNATRefreshUDP() ); |
|
5518 } |
|
5519 // CRLFRefresh |
|
5520 else if ( KNSmlDMDomainEnableCRLFRefresh() == lastURISeg ) |
|
5521 { |
|
5522 if ( iNATFWDomainEntries->At( domainLoc )-> |
|
5523 GetEnableCRLFRefresh() == 1 ) |
|
5524 { |
|
5525 aSegmentResult.Copy( KNSmlDMNATFWValueTrue ); |
|
5526 } |
|
5527 else if ( iNATFWDomainEntries->At( domainLoc )-> |
|
5528 GetEnableCRLFRefresh() == 0 ) |
|
5529 { |
|
5530 aSegmentResult.Copy( KNSmlDMNATFWValueFalse ); |
|
5531 } |
|
5532 else |
|
5533 { |
|
5534 status = CSmlDmAdapter::EInvalidObject; |
|
5535 } |
|
5536 } |
|
5537 |
|
5538 // STUNSharedSecret |
|
5539 else if ( KNSmlDMSTUNSharedSecret() == lastURISeg ) |
|
5540 { |
|
5541 // CentRep key is for "STUN shared secret not supported" so |
|
5542 // we must reverse its value. |
|
5543 if ( TInt( ETrue ) == iNATFWDomainEntries->At( domainLoc )-> |
|
5544 DisableStunSharedSecret() ) |
|
5545 { |
|
5546 aSegmentResult.Copy( KNSmlDMNATFWValueFalse ); |
|
5547 } |
|
5548 else if ( TInt( EFalse ) == iNATFWDomainEntries->At( domainLoc )-> |
|
5549 DisableStunSharedSecret() ) |
|
5550 { |
|
5551 aSegmentResult.Copy( KNSmlDMNATFWValueTrue ); |
|
5552 } |
|
5553 else |
|
5554 { |
|
5555 status = CSmlDmAdapter::EInvalidObject; |
|
5556 } |
|
5557 } |
|
5558 // PortPoolStartPort |
|
5559 else if ( KNSmlDMPortPoolStart() == lastURISeg ) |
|
5560 { |
|
5561 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5562 StartPortRange() ); |
|
5563 } |
|
5564 // PortPoolEndPort |
|
5565 else if ( KNSmlDMPortPoolEnd() == lastURISeg ) |
|
5566 { |
|
5567 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5568 EndPortRange() ); |
|
5569 } |
|
5570 // UsedNATProtocol |
|
5571 else if ( KNSmlDMUsedNatProtocol() == lastURISeg ) |
|
5572 { |
|
5573 aSegmentResult.Copy( iNATFWDomainEntries->At( domainLoc )-> |
|
5574 UsedNatProtocol() ); |
|
5575 } |
|
5576 |
|
5577 // ICESpecific/NATUtilities |
|
5578 else if ( KNSmlDMNatUtilities() == lastURISeg |
|
5579 && iceSpecific ) |
|
5580 { |
|
5581 aSegmentResult.Copy( iNATFWDomainEntries->At( domainLoc )-> |
|
5582 NatUtilities() ); |
|
5583 } |
|
5584 // ICESpecific/HostPreference |
|
5585 else if ( KNSmlDMHostPref() == lastURISeg |
|
5586 && iceSpecific ) |
|
5587 { |
|
5588 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5589 HostPref() ); |
|
5590 } |
|
5591 // ICESpecific/ServerReflexivePreference |
|
5592 else if ( KNSmlDMServerReflexPref() == lastURISeg |
|
5593 && iceSpecific ) |
|
5594 { |
|
5595 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5596 ServerReflexPref() ); |
|
5597 } |
|
5598 // ICESpecific/RelayPreference |
|
5599 else if ( KNSmlDMRelayPref() == lastURISeg |
|
5600 && iceSpecific ) |
|
5601 { |
|
5602 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5603 RelayPref() ); |
|
5604 } |
|
5605 // ICESpecific/PeerReflexivePreference |
|
5606 else if ( KNSmlDMPeerReflexPref() == lastURISeg |
|
5607 && iceSpecific ) |
|
5608 { |
|
5609 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5610 PeerReflexPref() ); |
|
5611 } |
|
5612 // ICESpecific/IPv4Preference |
|
5613 else if ( KNSmlDMIPv4Pref() == lastURISeg |
|
5614 && iceSpecific ) |
|
5615 { |
|
5616 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5617 IPv4Pref() ); |
|
5618 } |
|
5619 // ICESpecific/IPv6Preference |
|
5620 else if ( KNSmlDMIPv6Pref() == lastURISeg |
|
5621 && iceSpecific ) |
|
5622 { |
|
5623 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5624 IPv6Pref() ); |
|
5625 } |
|
5626 // ICESpecific/VPNPreference |
|
5627 else if ( KNSmlDMVpnPref() == lastURISeg |
|
5628 && iceSpecific ) |
|
5629 { |
|
5630 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )->VpnPref() ); |
|
5631 } |
|
5632 // ICESpecific/UDPPreference |
|
5633 else if ( KNSmlDMUdpPref() == lastURISeg |
|
5634 && iceSpecific ) |
|
5635 { |
|
5636 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )->UdpPref() ); |
|
5637 } |
|
5638 // ICESpecific/TCPPreference |
|
5639 else if ( KNSmlDMTcpPref() == lastURISeg |
|
5640 && iceSpecific ) |
|
5641 { |
|
5642 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )->TcpPref() ); |
|
5643 } |
|
5644 // ICESpecific/TCPActivePreference |
|
5645 else if ( KNSmlDMTcpActivePref() == lastURISeg |
|
5646 && iceSpecific ) |
|
5647 { |
|
5648 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5649 TcpActivePref() ); |
|
5650 } |
|
5651 // ICESpecific/TCPPassivePreference |
|
5652 else if ( KNSmlDMTcpPassivePref() == lastURISeg |
|
5653 && iceSpecific ) |
|
5654 { |
|
5655 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5656 TcpPassivePref() ); |
|
5657 } |
|
5658 // ICESpecific/TCPSimultaneousPreference |
|
5659 else if ( KNSmlDMTcpSimultPref() == lastURISeg |
|
5660 && iceSpecific ) |
|
5661 { |
|
5662 aSegmentResult.Num( iNATFWDomainEntries->At( domainLoc )-> |
|
5663 TcpSimultPref() ); |
|
5664 } |
|
5665 else |
|
5666 { |
|
5667 status = CSmlDmAdapter::ENotFound; |
|
5668 } |
|
5669 |
|
5670 return status; |
|
5671 } |
|
5672 |
|
5673 |
|
5674 // --------------------------------------------------------------------------- |
|
5675 // CNSmlDmNATFWTraversalAdapter::FetchIAPObjectL |
|
5676 // Fetches the values of IAP specific leaf objects. |
|
5677 // --------------------------------------------------------------------------- |
|
5678 // |
|
5679 CSmlDmAdapter::TError CNSmlDmNATFWTraversalAdapter::FetchIAPObjectL( |
|
5680 const TDesC8& aURI, |
|
5681 const TDesC8& aLUID, |
|
5682 TDes8& aSegmentResult, |
|
5683 CBufBase& aResult ) |
|
5684 { |
|
5685 CSmlDmAdapter::TError status = EOk; |
|
5686 TBuf8< KSmlMaxURISegLen> lastURISeg = LastURISeg( aURI ); |
|
5687 |
|
5688 TInt iapLoc = FindIAPLocation ( aLUID ); |
|
5689 if ( KErrNotFound == iapLoc ) |
|
5690 { |
|
5691 status = CSmlDmAdapter::ENotFound; |
|
5692 return status; |
|
5693 } |
|
5694 |
|
5695 // PrefConRef |
|
5696 if ( KNSmlDMNATPrefConRef() == lastURISeg ) |
|
5697 { |
|
5698 TBool conref = GetConRefL( aResult, iapLoc ); |
|
5699 if ( !conref ) |
|
5700 { |
|
5701 aResult.Reset(); |
|
5702 status = CSmlDmAdapter::ENotFound; |
|
5703 DBG_PRINT("CNSmlDmNATFWTraversalAdapter::FetchLeafObjectL(): PrefConRef not found end"); |
|
5704 return status; |
|
5705 } |
|
5706 } |
|
5707 else if ( KNSmlDMNATRefreshTCP() == lastURISeg ) |
|
5708 { |
|
5709 aSegmentResult.Num( iNATFWIAPEntries-> |
|
5710 At( iapLoc )->GetIntervalTCP() ); |
|
5711 } |
|
5712 else if ( KNSmlDMNATRefreshUDP() == lastURISeg ) |
|
5713 { |
|
5714 aSegmentResult.Num( iNATFWIAPEntries-> |
|
5715 At( iapLoc )->GetIntervalUDP() ); |
|
5716 } |
|
5717 else if ( KNSmlDMSTUNRetransmit() == lastURISeg ) |
|
5718 { |
|
5719 aSegmentResult.Num( iNATFWIAPEntries-> |
|
5720 At( iapLoc )->GetSTUNRetransmitTimer() ); |
|
5721 } |
|
5722 else |
|
5723 { |
|
5724 // None of IAP specific settings found. |
|
5725 status = CSmlDmAdapter::ENotFound; |
|
5726 } |
|
5727 |
|
5728 return status; |
|
5729 } |
|
5730 |
|
5731 // --------------------------------------------------------------------------- |
|
5732 // CNSmlDmNATFWTraversalAdapter::FetchAdditionalSTUNServerObjectL |
|
5733 // Fetches the values of AdditionalSTUNServer/<x>/ leaf objects. |
|
5734 // --------------------------------------------------------------------------- |
|
5735 // |
|
5736 CSmlDmAdapter::TError |
|
5737 CNSmlDmNATFWTraversalAdapter::FetchAdditionalSTUNServerObjectL( |
|
5738 const TDesC8& aURI, |
|
5739 const TDesC8& aLUID, |
|
5740 TDes8& aSegmentResult ) |
|
5741 { |
|
5742 CSmlDmAdapter::TError status = EOk; |
|
5743 TBuf8<KSmlMaxURISegLen> lastURISeg = LastURISeg( aURI ); |
|
5744 |
|
5745 TUint32 stunKey = DesToInt( LastURISeg( aLUID ) ); |
|
5746 if ( KErrNone == stunKey ) |
|
5747 { |
|
5748 status = CSmlDmAdapter::ENotFound; |
|
5749 return status; |
|
5750 } |
|
5751 |
|
5752 TPtrC8 tmpLuid = RemoveLastURISeg( aLUID ); |
|
5753 TPtrC8 domainLuid = RemoveLastURISeg( tmpLuid ); |
|
5754 TInt domainLoc = FindDomainLocation( domainLuid ); |
|
5755 |
|
5756 if ( KErrNotFound == domainLoc ) |
|
5757 { |
|
5758 status = CSmlDmAdapter::ENotFound; |
|
5759 return status; |
|
5760 } |
|
5761 |
|
5762 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
5763 RArray<TUint32> stunKeys; |
|
5764 CleanupClosePushL( stunKeys ); // CS:2 |
|
5765 TUint32 domainKey = iNATFWDomainEntries->At( domainLoc )-> |
|
5766 GetDomainKey(); |
|
5767 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
5768 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
5769 rep->FindL( domainKey|KUNSAFProtocolsSTUNAddressMask, |
|
5770 KUNSAFProtocolsSubTableFieldTypeMask, stunKeys ); |
|
5771 TInt stunCount( stunKeys.Count() ); |
|
5772 TInt stunLoc( KErrNotFound ); |
|
5773 |
|
5774 for ( TInt counter = 0; counter < stunCount; counter++ ) |
|
5775 { |
|
5776 if ( stunKey == stunKeys[counter] ) |
|
5777 { |
|
5778 stunLoc = counter; |
|
5779 } |
|
5780 } |
|
5781 stunKeys.Close(); |
|
5782 CleanupStack::PopAndDestroy( &stunKeys ); // CS:1 |
|
5783 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
5784 // STUN key was not in CentRep. |
|
5785 if ( KErrNotFound == stunLoc ) |
|
5786 { |
|
5787 status = CSmlDmAdapter::ENotFound; |
|
5788 return status; |
|
5789 } |
|
5790 // STUN key was in CentRep index 0 which is reserved for STUN |
|
5791 // settings directly under DomainSpecific node. |
|
5792 else if ( KErrNone == stunLoc ) |
|
5793 { |
|
5794 status = CSmlDmAdapter::EError; |
|
5795 return status; |
|
5796 } |
|
5797 // Fetch values. |
|
5798 else |
|
5799 { |
|
5800 // STUNSrvAddr |
|
5801 if ( KNSmlDMSTUNSrvAddr() == lastURISeg ) |
|
5802 { |
|
5803 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5804 At( domainLoc )->StunSrvAddrL( stunLoc ) ); |
|
5805 } |
|
5806 // STUNSrvPort |
|
5807 else if ( KNSmlDMSTUNSrvPort() == lastURISeg ) |
|
5808 { |
|
5809 aSegmentResult.Num( iNATFWDomainEntries-> |
|
5810 At( domainLoc )->StunSrvPort( stunLoc ) ); |
|
5811 } |
|
5812 // STUNUsername |
|
5813 else if ( KNSmlDMSTUNUsername() == lastURISeg ) |
|
5814 { |
|
5815 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5816 At( domainLoc )->StunUsernameL( stunLoc ) ); |
|
5817 } |
|
5818 // STUNPassword |
|
5819 else if ( KNSmlDMSTUNPassword() == lastURISeg ) |
|
5820 { |
|
5821 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5822 At( domainLoc )->StunPasswordL( stunLoc ) ); |
|
5823 } |
|
5824 else |
|
5825 { |
|
5826 // None of STUN specific settings found. |
|
5827 status = CSmlDmAdapter::ENotFound; |
|
5828 } |
|
5829 } |
|
5830 |
|
5831 return status; |
|
5832 } |
|
5833 |
|
5834 // --------------------------------------------------------------------------- |
|
5835 // CNSmlDmNATFWTraversalAdapter::FetchTURNServerObjectL |
|
5836 // Fetches the values of TURNSpecific/TURNServer/<x>/ leaf objects. |
|
5837 // --------------------------------------------------------------------------- |
|
5838 // |
|
5839 CSmlDmAdapter::TError |
|
5840 CNSmlDmNATFWTraversalAdapter::FetchTURNServerObjectL( |
|
5841 const TDesC8& aURI, |
|
5842 const TDesC8& aLUID, |
|
5843 TDes8& aSegmentResult ) |
|
5844 { |
|
5845 CSmlDmAdapter::TError status = EOk; |
|
5846 TBuf8<KSmlMaxURISegLen> lastURISeg = LastURISeg( aURI ); |
|
5847 |
|
5848 TUint32 turnKey = DesToInt( LastURISeg( aLUID ) ); |
|
5849 if ( KErrNone == turnKey ) |
|
5850 { |
|
5851 status = CSmlDmAdapter::ENotFound; |
|
5852 return status; |
|
5853 } |
|
5854 |
|
5855 TPtrC8 tmpLuid = RemoveLastURISeg( aLUID ); |
|
5856 TPtrC8 domainLuid = RemoveLastURISeg( RemoveLastURISeg( tmpLuid ) ); |
|
5857 TInt domainLoc = FindDomainLocation( domainLuid ); |
|
5858 |
|
5859 if ( KErrNotFound == domainLoc ) |
|
5860 { |
|
5861 status = CSmlDmAdapter::ENotFound; |
|
5862 return status; |
|
5863 } |
|
5864 |
|
5865 CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols ); // CS:1 |
|
5866 RArray<TUint32> turnKeys; |
|
5867 CleanupClosePushL( turnKeys ); // CS:2 |
|
5868 TUint32 domainKey = iNATFWDomainEntries->At( domainLoc )-> |
|
5869 GetDomainKey(); |
|
5870 domainKey |= KUNSAFProtocolsFieldTypeMask; |
|
5871 domainKey ^= KUNSAFProtocolsFieldTypeMask; |
|
5872 rep->FindL( domainKey|KUNSAFProtocolsTURNAddressMask, |
|
5873 KUNSAFProtocolsSubTableFieldTypeMask, turnKeys ); |
|
5874 TInt turnCount( turnKeys.Count() ); |
|
5875 TInt turnLoc( KErrNotFound ); |
|
5876 |
|
5877 for ( TInt counter = 0; counter < turnCount; counter++ ) |
|
5878 { |
|
5879 if ( turnKey == turnKeys[counter] ) |
|
5880 { |
|
5881 turnLoc = counter; |
|
5882 } |
|
5883 } |
|
5884 turnKeys.Close(); |
|
5885 CleanupStack::PopAndDestroy( &turnKeys ); // CS:1 |
|
5886 CleanupStack::PopAndDestroy( rep ); // CS:0 |
|
5887 // TURN key was not in CentRep. |
|
5888 if ( KErrNotFound == turnLoc ) |
|
5889 { |
|
5890 status = CSmlDmAdapter::ENotFound; |
|
5891 return status; |
|
5892 } |
|
5893 // Fetch values. |
|
5894 else |
|
5895 { |
|
5896 // TURNSrvAddr |
|
5897 if ( KNSmlDMTURNSrvAddr() == lastURISeg ) |
|
5898 { |
|
5899 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5900 At( domainLoc )->TurnSrvAddrL( turnLoc ) ); |
|
5901 } |
|
5902 // TURNSrvPort |
|
5903 else if ( KNSmlDMTURNSrvPort() == lastURISeg ) |
|
5904 { |
|
5905 aSegmentResult.Num( iNATFWDomainEntries-> |
|
5906 At( domainLoc )->TurnSrvPort( turnLoc ) ); |
|
5907 } |
|
5908 // TURNUsername |
|
5909 else if ( KNSmlDMTURNUsername() == lastURISeg ) |
|
5910 { |
|
5911 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5912 At( domainLoc )->TurnUsernameL( turnLoc ) ); |
|
5913 } |
|
5914 // TURNPassword |
|
5915 else if ( KNSmlDMTURNPassword() == lastURISeg ) |
|
5916 { |
|
5917 aSegmentResult.Copy( iNATFWDomainEntries-> |
|
5918 At( domainLoc )->TurnPasswordL( turnLoc ) ); |
|
5919 } |
|
5920 else |
|
5921 { |
|
5922 // None of TURN server settings found. |
|
5923 status = CSmlDmAdapter::ENotFound; |
|
5924 } |
|
5925 } |
|
5926 |
|
5927 return status; |
|
5928 } |
|
5929 |
|
5930 // --------------------------------------------------------------------------- |
|
5931 // CNSmlDmNATFWTraversalAdapter::DesToInt |
|
5932 // Converts a 8 bit descriptor to int. |
|
5933 // --------------------------------------------------------------------------- |
|
5934 // |
|
5935 TInt CNSmlDmNATFWTraversalAdapter::DesToInt( |
|
5936 const TDesC8& aDes ) |
|
5937 { |
|
5938 TLex8 lex( aDes ); |
|
5939 TInt value = 0; |
|
5940 lex.Val( value ); |
|
5941 return value; |
|
5942 } |
|
5943 |
|
5944 // --------------------------------------------------------------------------- |
|
5945 // CNSmlDmNATFWTraversalAdapter::RemoveLastURISeg |
|
5946 // Returns parent URI, i.e. removes last uri segment. |
|
5947 // --------------------------------------------------------------------------- |
|
5948 // |
|
5949 TPtrC8 CNSmlDmNATFWTraversalAdapter::RemoveLastURISeg( |
|
5950 const TDesC8& aURI ) |
|
5951 { |
|
5952 TInt counter ( 0 ); |
|
5953 |
|
5954 // Check that aURI exists |
|
5955 if ( 0 < aURI.Length() ) |
|
5956 { |
|
5957 for ( counter = aURI.Length() - 1; counter >= 0; counter-- ) |
|
5958 { |
|
5959 if ( KDMNATFWSeparator == aURI[counter] ) |
|
5960 { |
|
5961 break; |
|
5962 } |
|
5963 } |
|
5964 } |
|
5965 return aURI.Left( counter ); |
|
5966 } |
|
5967 |
|
5968 // --------------------------------------------------------------------------- |
|
5969 // CNSmlDmNATFWTraversalAdapter::NumOfURISegs |
|
5970 // For getting the number of URI segs. |
|
5971 // --------------------------------------------------------------------------- |
|
5972 // |
|
5973 TInt CNSmlDmNATFWTraversalAdapter::NumOfURISegs( const TDesC8& aURI ) |
|
5974 { |
|
5975 TInt numOfURISegs ( KOneSeg ); |
|
5976 for ( TInt counter = 0; counter < aURI.Length(); counter++ ) |
|
5977 { |
|
5978 if ( KDMNATFWSeparator == aURI[counter] ) |
|
5979 { |
|
5980 numOfURISegs++; |
|
5981 } |
|
5982 } |
|
5983 return numOfURISegs; |
|
5984 } |
|
5985 |
|
5986 // --------------------------------------------------------------------------- |
|
5987 // CNSmlDmNATFWTraversalAdapter::LastURISeg |
|
5988 // Returns only the last URI segment. |
|
5989 // --------------------------------------------------------------------------- |
|
5990 // |
|
5991 TPtrC8 CNSmlDmNATFWTraversalAdapter::LastURISeg( const TDesC8& aURI ) |
|
5992 { |
|
5993 TInt counter ( 0 ); |
|
5994 |
|
5995 // Check that aURI exists |
|
5996 if ( 0 < aURI.Length() ) |
|
5997 { |
|
5998 for ( counter = aURI.Length() - 1; counter >= 0; counter-- ) |
|
5999 { |
|
6000 if ( KDMNATFWSeparator == aURI[counter] ) |
|
6001 { |
|
6002 break; |
|
6003 } |
|
6004 } |
|
6005 } |
|
6006 if ( 0 == counter ) |
|
6007 { |
|
6008 return aURI; |
|
6009 } |
|
6010 else |
|
6011 { |
|
6012 return aURI.Mid( counter + 1 ); |
|
6013 } |
|
6014 } |
|
6015 |
|
6016 // --------------------------------------------------------------------------- |
|
6017 // CNSmlDmNATFWTraversalAdapter::RemoveDotSlash |
|
6018 // Return URI without dot and slash in start. |
|
6019 // --------------------------------------------------------------------------- |
|
6020 // |
|
6021 TPtrC8 CNSmlDmNATFWTraversalAdapter::RemoveDotSlash( const TDesC8& aURI ) |
|
6022 { |
|
6023 if ( 0 == aURI.Find( KNSmlDMNATFWUriDotSlash ) ) |
|
6024 { |
|
6025 return aURI.Right( aURI.Length()-KNSmlDMNATFWUriDotSlash().Length() ); |
|
6026 } |
|
6027 else |
|
6028 { |
|
6029 return aURI; |
|
6030 } |
|
6031 } |