|
1 /* |
|
2 * Copyright (c) 2002 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: Policy Management DM Adapter |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 /* |
|
20 |
|
21 ./PolicyMgmt ---+--> PolicySets -+-> <X> * -+-> Policies ----> <X> * --+--> Policy |
|
22 | | |
|
23 | |-> PolicySets --> <X> * --+--> PolicySet |
|
24 | | |
|
25 | |-> ID |
|
26 | | |
|
27 | |-> Data |
|
28 | | |
|
29 | |-> Description |
|
30 | |
|
31 |--> Policies -+-> <X> * --+-> ID |
|
32 | | |
|
33 | |-> Data |
|
34 | | |
|
35 | |-> Description |
|
36 | | |
|
37 | |-> Rules --> <X> * --+--> Rule |
|
38 | |
|
39 |--> Rules -+----> <X> * --+-> ID |
|
40 | | |
|
41 | |-> Data |
|
42 | | |
|
43 | |-> Description |
|
44 | |
|
45 |--> Delivery -+-> Sink |
|
46 | |
|
47 |--> LastStatus |
|
48 |
|
49 ./PolicyMgmt/PolicySets/DynamicSets/X mapping contains the ElementID |
|
50 ./PolicyMgmt/PolicySets/DynamicSets/X/Policies/X mapping contains itself |
|
51 ./PolicyMgmt/PolicySets/DynamicSets/X/Policies/X/Policy mapping contains the data (URL to policy) |
|
52 ./PolicyMgmt/PolicySets/DynamicSets/X/PolicySets/X mapping contains itself |
|
53 ./PolicyMgmt/PolicySets/DynamicSets/X/PolicySets/X/PolicySet mapping contains the data (URL to policy set) |
|
54 ./PolicyMgmt/Policies/X mapping contains the ElementID |
|
55 |
|
56 |
|
57 ./PolicyMgmt/PolicySets/MetaSet mapping contains the data (URL to policy set) |
|
58 ./PolicyMgmt/PolicySets/Settings mapping contains the data (URL to policy set) |
|
59 */ |
|
60 |
|
61 |
|
62 #include <badesca.h> |
|
63 #include <fbs.h> |
|
64 #include <imcvcodc.h> |
|
65 #include "nsmldmuri.h" |
|
66 #include "pmadapter.h" |
|
67 #include <implementationproxy.h> // For TImplementationProxy definition |
|
68 #include <f32file.h> |
|
69 |
|
70 #include <centralrepository.h> |
|
71 #include "PMUtilInternalCRKeys.h" |
|
72 |
|
73 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
74 #include <dmtreenode.h> |
|
75 #include <devman.h> |
|
76 #include <e32property.h> |
|
77 _LIT8( KSinkLeaf, "/PolicyMgmt/Delivery/Sink" ); |
|
78 const TUid KUidSmlSyncAgentCategory = { 0x10009F46 }; // temporary |
|
79 const TUint KHttpsServerCertificateKey = 1234; // temporary |
|
80 #else |
|
81 _LIT8( KSinkLeaf, "PolicyMgmt/Delivery/Sink" ); |
|
82 #endif |
|
83 #include "debug.h" |
|
84 |
|
85 //#define __TEST_NO_ENGINE__ // causes Policy engine errors to be ignored |
|
86 |
|
87 _LIT( KTestFileName, "c:\\test.txt" ); |
|
88 |
|
89 const TInt KFeatchLeafObjectBufferSize = 32; |
|
90 const TInt KFeatchChildUriListBufferSize = 128; |
|
91 const TInt KFeatchLeafObjectSize = 128; |
|
92 const TInt KMaxLengthOf32bitInteger = 10; //10 = max length of 32bit integer |
|
93 |
|
94 #define __LO_TEST__ // Large object test node "TEST" |
|
95 |
|
96 // ------------------------------------------------------------------------------------------------ |
|
97 // CPmAdapter* CPmAdapter::NewL( ) |
|
98 // ------------------------------------------------------------------------------------------------ |
|
99 CPmAdapter* CPmAdapter::NewL( MSmlDmCallback* aDmCallback ) |
|
100 { |
|
101 RDEBUG("CPmAdapter::NewL(): begin"); |
|
102 |
|
103 CPmAdapter* self = NewLC( aDmCallback ); |
|
104 CleanupStack::Pop( self ); |
|
105 RDEBUG("CPmAdapter::NewL(): end"); |
|
106 return self; |
|
107 } |
|
108 |
|
109 // ------------------------------------------------------------------------------------------------ |
|
110 // CPmAdapter* CPmAdapter::NewLC( ) |
|
111 // ------------------------------------------------------------------------------------------------ |
|
112 CPmAdapter* CPmAdapter::NewLC( MSmlDmCallback* aDmCallback ) |
|
113 { |
|
114 CPmAdapter* self = new ( ELeave ) CPmAdapter(aDmCallback); |
|
115 CleanupStack::PushL( self ); |
|
116 self->ConstructL(); |
|
117 return self; |
|
118 } |
|
119 |
|
120 // ------------------------------------------------------------------------------------------------ |
|
121 // CPmAdapter::CPmAdapter() |
|
122 // ------------------------------------------------------------------------------------------------ |
|
123 CPmAdapter::CPmAdapter(TAny* aEcomArguments) : CSmlDmAdapter(aEcomArguments) |
|
124 { |
|
125 } |
|
126 |
|
127 // ------------------------------------------------------------------------------------------------ |
|
128 // CPmAdapter::ConstructL() |
|
129 // ------------------------------------------------------------------------------------------------ |
|
130 void CPmAdapter::ConstructL() |
|
131 { |
|
132 RDEBUG("CPmAdapter::ConstructL(): begin"); |
|
133 #ifndef __TEST_NO_ENGINE__ |
|
134 RDEBUG("CPmAdapter::ConstructL() -> connecting RPolicyEngine ... "); |
|
135 TInt err = iEngine.Connect(); |
|
136 User::LeaveIfError( err ); |
|
137 RDEBUG("CPmAdapter::ConstructL() -> connecting RPolicyEngine ... DONE!"); |
|
138 RDEBUG("CPmAdapter::ConstructL() -> opening RPolicyManagement ... "); |
|
139 User::LeaveIfError( iManagement.Open( iEngine ) ); |
|
140 RDEBUG("CPmAdapter::ConstructL() -> opening RPolicyManagement ... DONE!"); |
|
141 CheckAndAddCertL(); |
|
142 #else |
|
143 #endif |
|
144 RDEBUG("CPmAdapter::ConstructL(): end"); |
|
145 } |
|
146 |
|
147 // ------------------------------------------------------------------------------------------------ |
|
148 // CPmAdapter::CheckAndAddCertL() |
|
149 // ------------------------------------------------------------------------------------------------ |
|
150 void CPmAdapter::CheckAndAddCertL() |
|
151 { |
|
152 RDEBUG("CPmAdapter::CheckAndAddCertL()"); |
|
153 TInt errx = KErrNone; |
|
154 |
|
155 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
156 // nothing |
|
157 #else |
|
158 CRepository *re = NULL; |
|
159 TRAP( errx, re = CRepository::NewL ( KCRUidPolicyManagementUtilInternalKeys ) ); |
|
160 #endif |
|
161 |
|
162 if (errx == KErrNone ) |
|
163 { |
|
164 TCertInfo info ; |
|
165 TPckg<TCertInfo> pcert( info ); |
|
166 TInt len( 0 ); |
|
167 |
|
168 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
169 errx = RProperty::Get( KUidSmlSyncAgentCategory, KHttpsServerCertificateKey, pcert ); |
|
170 len = pcert.Length(); |
|
171 #else |
|
172 errx = re->Get( KSyncMLSessionCertificate, pcert, len ) ; |
|
173 #endif |
|
174 |
|
175 if ( errx == KErrNone ) |
|
176 { |
|
177 if ( len > 0 ) |
|
178 { |
|
179 RDEBUG_3("CPmAdapter::CheckAndAddCertL() : Got reposotry key len %d: %S", pcert.Length(), &pcert ); |
|
180 |
|
181 TInt err( iManagement.AddSessionTrust( info ) ); |
|
182 if ( err == KErrNone ) |
|
183 { |
|
184 RDEBUG("CPmAdapter::CheckAndAddCertL() : Trust added!" ); |
|
185 } |
|
186 else |
|
187 { |
|
188 RDEBUG_2("CPmAdapter::CheckAndAddCertL() : WARNING Failed to add trust %d", err ); |
|
189 } |
|
190 } |
|
191 else |
|
192 { |
|
193 RDEBUG("CPmAdapter::CheckAndAddCertL() : WARNING certificate length is 0 or less - it doesnt exist" ); |
|
194 } |
|
195 } |
|
196 else |
|
197 { |
|
198 if ( errx != KErrNotFound ) |
|
199 { |
|
200 RDEBUG_2("CPmAdapter::CheckAndAddCertL() : ERROR Failed to get repository key %d", errx ); |
|
201 } |
|
202 else |
|
203 { |
|
204 RDEBUG_2("CPmAdapter::CheckAndAddCertL() : WARNING certificate key not found: %d", errx ); |
|
205 } |
|
206 } |
|
207 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
208 // nothing |
|
209 #else |
|
210 delete re ; |
|
211 #endif |
|
212 } |
|
213 else |
|
214 { |
|
215 RDEBUG_2("CPmAdapter::CheckAndAddCertL() : WARNING could not create repository: %d", errx ); |
|
216 } |
|
217 } |
|
218 |
|
219 |
|
220 // ------------------------------------------------------------------------------------------------ |
|
221 // CPmAdapter::~CPmAdapter() |
|
222 // ------------------------------------------------------------------------------------------------ |
|
223 CPmAdapter::~CPmAdapter() |
|
224 { |
|
225 RDEBUG("CPmAdapter::~CPmAdapter()"); |
|
226 delete iLastStatus ; |
|
227 iManagement.Close(); |
|
228 iEngine.Close(); |
|
229 iAtomiced.ResetAndDestroy(); |
|
230 } |
|
231 |
|
232 // ------------------------------------------------------------------------------------------------ |
|
233 // CPmAdapter::DDFVersionL( CBufBase& aDDFVersion ) |
|
234 // ------------------------------------------------------------------------------------------------ |
|
235 void CPmAdapter::DDFVersionL( CBufBase& aDDFVersion ) |
|
236 { |
|
237 aDDFVersion.InsertL( 0, KNSmlPMDDFVersion ); |
|
238 } |
|
239 |
|
240 |
|
241 // ------------------------------------------------------------------------------------------------ |
|
242 // CPmAdapter::DDFStructureL( MSmlDmDDFObject& aDDF ) |
|
243 // ------------------------------------------------------------------------------------------------ |
|
244 void CPmAdapter::DDFStructureL( MSmlDmDDFObject& aDDF ) |
|
245 { |
|
246 RDEBUG( "CPmAdapter::DDFStructureL(): begin" ); |
|
247 |
|
248 TSmlDmAccessTypes accessTypesGet; |
|
249 accessTypesGet.SetGet(); |
|
250 |
|
251 /* |
|
252 Node: ./PolicyMgmt |
|
253 Management object is recognized by node next to root named PolicyMgmt. |
|
254 Support: Mandatory |
|
255 Occurs: One |
|
256 Format: Node |
|
257 Access Types: Get |
|
258 Values: N/A |
|
259 */ |
|
260 MSmlDmDDFObject& pmNode = aDDF.AddChildObjectL( KNSmlPMNodeName ); |
|
261 FillNodeInfoL(pmNode, accessTypesGet, MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
262 MSmlDmDDFObject::ENode, KNSmlPMDescription ); |
|
263 |
|
264 #ifdef __LO_TEST__ |
|
265 TSmlDmAccessTypes accessTypesGetReplace; |
|
266 accessTypesGetReplace.SetGet(); |
|
267 /* |
|
268 Node: ./PolicyMgmt/TEST |
|
269 Management object is recognized by node next to root named PolicyMgmt. |
|
270 Support: Mandatory |
|
271 Occurs: One |
|
272 Format: Node |
|
273 Access Types: Get, Replace |
|
274 Values: N/A |
|
275 */ |
|
276 MSmlDmDDFObject& testNode = pmNode.AddChildObjectL( KTestNodeName() ); |
|
277 FillNodeInfoL( testNode, accessTypesGetReplace, MSmlDmDDFObject::EOne, |
|
278 MSmlDmDDFObject::EPermanent, |
|
279 MSmlDmDDFObject::EChr, KNSmlPMDescription ); |
|
280 #endif |
|
281 |
|
282 /* |
|
283 Node: ./PolicyMgmt/PolicySets |
|
284 This node is root for all policy sets. |
|
285 The return value is as usual with Nodes (i.e. the list of names of child nodes in practice.) |
|
286 Status: Required |
|
287 Occurs: One |
|
288 Format: Node |
|
289 Access Types: Get |
|
290 Values: N/A |
|
291 */ |
|
292 MSmlDmDDFObject& policySetsNode = pmNode.AddChildObjectL( KNSmlPMPolicySetsNodeName ); |
|
293 FillNodeInfoL( policySetsNode, accessTypesGet, MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
294 MSmlDmDDFObject::ENode, KNSmlPMPolicySetsNodeDescription ); |
|
295 |
|
296 /* |
|
297 Node: ./PolicyMgmt/PolicySets/<X> |
|
298 This dynamic node is placeholder for policy sets. |
|
299 Policy set consists of other policy set references, policy references, id, description and data. Add command requires policy set data (XACML) in data parameter. |
|
300 Support: Mandatory |
|
301 Occurs: ZeroOrMore |
|
302 Format: Node |
|
303 Access Types: Get |
|
304 Values: N/A |
|
305 */ |
|
306 MSmlDmDDFObject& dynamicSetsDynaNode = policySetsNode.AddChildObjectGroupL(); |
|
307 FillNodeInfoL( dynamicSetsDynaNode, accessTypesGet, MSmlDmDDFObject::EZeroOrMore, |
|
308 MSmlDmDDFObject::EDynamic, |
|
309 MSmlDmDDFObject::ENode, KNSmlPMDynamicSetsDynamicNodeDescription ); |
|
310 |
|
311 /* |
|
312 Node: ./PolicyMgmt/PolicySets/<X>/Policies |
|
313 This node is root for policy references inside a policy set. |
|
314 Support: Mandatory |
|
315 Occurs: One |
|
316 Format: Node |
|
317 Access Types: Get |
|
318 Values: N/A |
|
319 */ |
|
320 MSmlDmDDFObject& dynamicSetsPoliciesNode = |
|
321 dynamicSetsDynaNode.AddChildObjectL( KNSmlPMPolicySetPoliciesNodeName ); |
|
322 FillNodeInfoL( dynamicSetsPoliciesNode, accessTypesGet, MSmlDmDDFObject::EOne, |
|
323 MSmlDmDDFObject::EPermanent, |
|
324 MSmlDmDDFObject::ENode, KNSmlPMPolicySetPoliciesNodeDescription ); |
|
325 |
|
326 /* |
|
327 Node: ./PolicyMgmt/PolicySets/<X>/Policies/<X> |
|
328 This dynamic node is placeholder for policy references. |
|
329 Support: Mandatory |
|
330 Occurs: ZeroOrMore |
|
331 Format: Node |
|
332 Access Types: Get |
|
333 Values: N/A |
|
334 */ |
|
335 MSmlDmDDFObject& dynamicSetsPoliciesDynaNode = |
|
336 dynamicSetsPoliciesNode.AddChildObjectGroupL();//( KNSmlPMDynamicNode() ); |
|
337 FillNodeInfoL( dynamicSetsPoliciesDynaNode, accessTypesGet, |
|
338 MSmlDmDDFObject::EZeroOrMore, MSmlDmDDFObject::EDynamic, |
|
339 MSmlDmDDFObject::ENode, KNSmlPMPolicySetPoliciesDynamicNodeDescription ); |
|
340 |
|
341 /* |
|
342 Node: ./PolicyMgmt/PolicySets/<X>/Policies/<X>/Policy |
|
343 This leaf holds a URI reference to actual policy in the management tree. |
|
344 Support: Mandatory |
|
345 Occurs: One |
|
346 Format: Chr |
|
347 Access Types: Get |
|
348 Values: Valid url to policy ids in PolicyMgmt/Policies/<X>/ |
|
349 |
|
350 Example value refers to policy 3sdxA, which is random imaginary policy node name. |
|
351 ./PolicyMgmt/Policies/3sdxA/ |
|
352 |
|
353 */ |
|
354 MSmlDmDDFObject& dynamicSetsPoliciesPolicyNode = |
|
355 dynamicSetsPoliciesDynaNode.AddChildObjectL( KNSmlPMPolicySetPoliciesPolicyNodeName ); |
|
356 FillNodeInfoL( dynamicSetsPoliciesPolicyNode, accessTypesGet, |
|
357 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
358 MSmlDmDDFObject::EChr, KNSmlPMPolicySetPoliciesPolicyNodeDescription ); |
|
359 |
|
360 /* |
|
361 Node: ./PolicyMgmt/PolicySets/<X>/PolicySets |
|
362 This node is root for policy set references inside a policy set. |
|
363 Support: Mandatory |
|
364 Occurs: One |
|
365 Format: Node |
|
366 Access Types: Get |
|
367 Values: N/A |
|
368 |
|
369 */ |
|
370 MSmlDmDDFObject& dynamicSetsPolicySetsNode = |
|
371 dynamicSetsDynaNode.AddChildObjectL( KNSmlPMPolicySetPolicySetsNodeName ); |
|
372 FillNodeInfoL( dynamicSetsPolicySetsNode, accessTypesGet, |
|
373 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
374 MSmlDmDDFObject::ENode, KNSmlPMPolicySetPolicySetsNodeDescription ); |
|
375 |
|
376 /* |
|
377 Node: ./PolicyMgmt/PolicySets/<X>/PolicySets/<X> |
|
378 This dynamic node is placeholder for policy set references. |
|
379 Support: Mandatory |
|
380 Occurs: ZeroOrMore |
|
381 Format: Node |
|
382 Access Types: Get |
|
383 Values: N/A |
|
384 |
|
385 */ |
|
386 MSmlDmDDFObject& dynamicSetsPolicySetsDynaNode = |
|
387 dynamicSetsPolicySetsNode.AddChildObjectGroupL();// KNSmlPMDynamicNode ); |
|
388 FillNodeInfoL( dynamicSetsPolicySetsDynaNode, accessTypesGet, |
|
389 MSmlDmDDFObject::EZeroOrMore, MSmlDmDDFObject::EDynamic, |
|
390 MSmlDmDDFObject::ENode, KNSmlPMPolicySetPolicySetsDynamicNodeDescription ); |
|
391 |
|
392 /* |
|
393 Node: ./PolicyMgmt/PolicySets/<X>/PolicySets/<X>/PolicySet |
|
394 This is URI of actual policy set in the management tree, i.e. PolicyMgmt/PolicySets/<X>. |
|
395 Support: Mandatory |
|
396 Occurs: One |
|
397 Format: chr |
|
398 Access Types: Get |
|
399 Values: Valid url to policy set ids in ./PolicyMgmt/PolicySets/<X>/ |
|
400 |
|
401 Example value references to policy set SetX10: |
|
402 ./PolicyMgmt/PolicySets/SetX10/ |
|
403 */ |
|
404 MSmlDmDDFObject& dynamicSetsPolicySetsPolicySetNode = |
|
405 dynamicSetsPolicySetsDynaNode.AddChildObjectL( |
|
406 KNSmlPMPolicySetPolicySetsPolicySetNodeName ); |
|
407 FillNodeInfoL( dynamicSetsPolicySetsPolicySetNode, accessTypesGet, |
|
408 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
409 MSmlDmDDFObject::EChr, KNSmlPMPolicySetPolicySetsPolicySetNodeDescription ); |
|
410 |
|
411 /* |
|
412 Node: ./PolicyMgmt/PolicySets/<X>/ID |
|
413 ID of the policy set from the original XACML file. |
|
414 Support: Mandatory |
|
415 Occurs: One |
|
416 Format: Chr |
|
417 Access Types: Get |
|
418 Values: N/A |
|
419 */ |
|
420 MSmlDmDDFObject& policySetIdNode = |
|
421 dynamicSetsDynaNode.AddChildObjectL( KNSmlPMPolicySetIDNodeName ); |
|
422 FillNodeInfoL( policySetIdNode, accessTypesGet, |
|
423 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
424 MSmlDmDDFObject::EChr, KNSmlPMPolicySetIDNodeDescription ); |
|
425 |
|
426 /* |
|
427 Node: ./PolicyMgmt/PolicySets/<X>/Data |
|
428 |
|
429 Data of the policy set in XACML format. |
|
430 Support: Mandatory |
|
431 Occurs: One |
|
432 Format: Xml |
|
433 Access Types: Get |
|
434 Values: N/A |
|
435 */ |
|
436 MSmlDmDDFObject& policySetDataNode = |
|
437 dynamicSetsDynaNode.AddChildObjectL( KNSmlPMPolicySetDataNodeName ); |
|
438 FillNodeInfoL( policySetDataNode, accessTypesGet, |
|
439 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
440 MSmlDmDDFObject::EXml, KNSmlPMPolicySetDataNodeDescription ); |
|
441 |
|
442 /* |
|
443 Node: ./PolicyMgmt/PolicySets/<X>/Description |
|
444 |
|
445 Description of policy set from the original XACML file is reflected in this leaf. |
|
446 Support: Optional |
|
447 Occurs: One |
|
448 Format: Chr |
|
449 Access Types: Get |
|
450 Values: N/A |
|
451 */ |
|
452 MSmlDmDDFObject& policySetDescNode = |
|
453 dynamicSetsDynaNode.AddChildObjectL( KNSmlPMPolicySetDescriptionNodeName ); |
|
454 FillNodeInfoL( policySetDescNode, accessTypesGet, |
|
455 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
456 MSmlDmDDFObject::EChr, KNSmlPMPolicySetDescriptionNodeDescription ); |
|
457 |
|
458 /* |
|
459 Node: ./PolicyMgmt/Policies |
|
460 This node is root for all policies in system. |
|
461 Support: Mandatory |
|
462 Occurs: One |
|
463 Format: Node |
|
464 Access Types: Get |
|
465 Values: N/A |
|
466 */ |
|
467 MSmlDmDDFObject& policiesNode = pmNode.AddChildObjectL( KNSmlPMPoliciesNodeName ); |
|
468 FillNodeInfoL( policiesNode, accessTypesGet, |
|
469 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
470 MSmlDmDDFObject::ENode, KNSmlPMPoliciesNodeDescription ); |
|
471 |
|
472 /* |
|
473 Node: ./PolicyMgmt/Policies/<X> |
|
474 This dynamic node is placeholder for policies. Policy consists of id, description and data. |
|
475 Support: Mandatory |
|
476 Occurs: One |
|
477 Format: Chr |
|
478 Access Types: Get |
|
479 Values: N/A |
|
480 */ |
|
481 MSmlDmDDFObject& policiesDynaNode = policiesNode.AddChildObjectGroupL();// KNSmlPMDynamicNode ); |
|
482 FillNodeInfoL( policiesDynaNode, accessTypesGet, |
|
483 MSmlDmDDFObject::EZeroOrMore, MSmlDmDDFObject::EDynamic, |
|
484 MSmlDmDDFObject::ENode, KNSmlPMPoliciesDynaNodeDescription ); |
|
485 |
|
486 /* |
|
487 Node: ./PolicyMgmt/Policies/<X>/ID |
|
488 This leaf node holds the ID of the policy. |
|
489 Support: Mandatory |
|
490 Occurs: One |
|
491 Format: Chr |
|
492 Access Types: Get |
|
493 Values: N/A |
|
494 */ |
|
495 MSmlDmDDFObject& policiesIDNode = |
|
496 policiesDynaNode.AddChildObjectL( KNSmlPMPoliciesIDNodeName ); |
|
497 FillNodeInfoL( policiesIDNode, accessTypesGet, |
|
498 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
499 MSmlDmDDFObject::EChr, KNSmlPMPoliciesIDNodeDescription ); |
|
500 |
|
501 /* |
|
502 Node: ./PolicyMgmt/Policies/<X>/Data |
|
503 This leaf node gives access to the data of the policy in XACML format. |
|
504 Status: Optional |
|
505 Occurs: One |
|
506 Format: Chr |
|
507 Access Types: Get |
|
508 Values: N/A |
|
509 */ |
|
510 MSmlDmDDFObject& policiesDataNode = |
|
511 policiesDynaNode.AddChildObjectL( KNSmlPMPoliciesDataNodeName ); |
|
512 FillNodeInfoL( policiesDataNode, accessTypesGet, |
|
513 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
514 MSmlDmDDFObject::EChr, KNSmlPMPoliciesDataNodeDescription ); |
|
515 |
|
516 /* |
|
517 Node: ./PolicyMgmt/Policies/<X>/Description |
|
518 Description of policy from the original XACML file is reflected in this leaf. |
|
519 Status: Optional |
|
520 Occurs: One |
|
521 Format: Chr |
|
522 Access Types: Get |
|
523 Values: N/A |
|
524 */ |
|
525 MSmlDmDDFObject& policiesDescNode = |
|
526 policiesDynaNode.AddChildObjectL( KNSmlPMPoliciesDescNodeName ); |
|
527 FillNodeInfoL( policiesDescNode, accessTypesGet, |
|
528 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
529 MSmlDmDDFObject::EChr, KNSmlPMPoliciesDescNodeDescription ); |
|
530 |
|
531 /* |
|
532 Node: ./PolicyMgmt/Policies/<X>/Rules |
|
533 This node is root for rule references inside a policy. |
|
534 Support: Mandatory |
|
535 Occurs: One |
|
536 Format: Node |
|
537 Access Types: Get |
|
538 Values: N/A |
|
539 */ |
|
540 MSmlDmDDFObject& policiesRulesNode = |
|
541 policiesDynaNode.AddChildObjectL( KNSmlPMPoliciesRulesNodeName ); |
|
542 FillNodeInfoL( policiesRulesNode, accessTypesGet, |
|
543 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
544 MSmlDmDDFObject::ENode, KNSmlPMPoliciesRulesNodeDescription ); |
|
545 |
|
546 /* |
|
547 Node: ./PolicyMgmt/Policies/<X>/Rules/<X> |
|
548 This dynamic node is placeholder for rule references. |
|
549 Support: Mandatory |
|
550 Occurs: ZeroOrMore |
|
551 Format: Node |
|
552 Access Types: Get |
|
553 Values: N/A |
|
554 */ |
|
555 MSmlDmDDFObject& policiesRulesDynaNode = |
|
556 policiesRulesNode.AddChildObjectGroupL();// KNSmlPMDynamicNode() ); |
|
557 FillNodeInfoL( policiesRulesDynaNode, accessTypesGet, |
|
558 MSmlDmDDFObject::EZeroOrMore, MSmlDmDDFObject::EDynamic, |
|
559 MSmlDmDDFObject::ENode, KNSmlPMPoliciesRulesDynaNodeDescription ); |
|
560 |
|
561 /* |
|
562 Node: ./PolicyMgmt/Policies/<X>/Rules/<X>/Rule |
|
563 This leaf holds a URI reference to actual rule in the management tree. |
|
564 Status: Mandatory |
|
565 Occurs: One |
|
566 Format: Chr |
|
567 Access Types: Get |
|
568 Values: N/A |
|
569 */ |
|
570 MSmlDmDDFObject& policiesRuleRef = |
|
571 policiesRulesDynaNode.AddChildObjectL( KNSmlPMPoliciesRulesRuleNodeName ); |
|
572 FillNodeInfoL( policiesRuleRef, accessTypesGet, |
|
573 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
574 MSmlDmDDFObject::EChr, KNSmlPMPoliciesRulesRuleNodeDescription ); |
|
575 |
|
576 /* |
|
577 Node: ./PolicyMgmt/Rules |
|
578 This node is root for all rules in system. |
|
579 Support: Mandatory |
|
580 Occurs: One |
|
581 Format: Node |
|
582 Access Types: Get |
|
583 Values: N/A |
|
584 */ |
|
585 MSmlDmDDFObject& rulesNode = |
|
586 pmNode.AddChildObjectL( KNSmlPMRulesNodeName ); |
|
587 FillNodeInfoL( rulesNode, accessTypesGet, |
|
588 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
589 MSmlDmDDFObject::ENode, KNSmlPMRulesNodeDescription ); |
|
590 |
|
591 /* |
|
592 Node: ./PolicyMgmt/Rules/<X> |
|
593 This dynamic node is placeholder for rules. Rule consists of id, description and data. |
|
594 Support: Mandatory |
|
595 Occurs: One |
|
596 Format: Chr |
|
597 Access Types: Get |
|
598 Values: N/A |
|
599 */ |
|
600 MSmlDmDDFObject& rulesDynaNode = |
|
601 rulesNode.AddChildObjectGroupL();// KNSmlPMDynamicNode ); |
|
602 FillNodeInfoL( rulesDynaNode, accessTypesGet, |
|
603 MSmlDmDDFObject::EZeroOrMore, MSmlDmDDFObject::EDynamic, |
|
604 MSmlDmDDFObject::ENode, KNSmlPMRulesDynaNodeDescription ); |
|
605 |
|
606 /* |
|
607 Node: ./PolicyMgmt/Policies/<X>/ID |
|
608 This leaf node holds the ID of the rules. |
|
609 Support: Mandatory |
|
610 Occurs: One |
|
611 Format: Chr |
|
612 Access Types: Get |
|
613 Values: N/A |
|
614 */ |
|
615 MSmlDmDDFObject& rulesIDNode = |
|
616 rulesDynaNode.AddChildObjectL( KNSmlPMRulesIDNodeName ); |
|
617 FillNodeInfoL( rulesIDNode, accessTypesGet, |
|
618 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
619 MSmlDmDDFObject::EChr, KNSmlPMRulesIDNodeDescription ); |
|
620 |
|
621 /* |
|
622 Node: ./PolicyMgmt/Rules/<X>/Data |
|
623 This leaf node gives access to the data of the rule in XACML format. |
|
624 Status: Optional |
|
625 Occurs: One |
|
626 Format: Chr |
|
627 Access Types: Get |
|
628 Values: N/A |
|
629 */ |
|
630 MSmlDmDDFObject& rulesDataNode = |
|
631 rulesDynaNode.AddChildObjectL( KNSmlPMRulesDataNodeName ); |
|
632 FillNodeInfoL( rulesDataNode, accessTypesGet, |
|
633 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
634 MSmlDmDDFObject::EChr, KNSmlPMRulesDataNodeDescription ); |
|
635 |
|
636 /* |
|
637 Node: ./PolicyMgmt/Rules/<X>/Description |
|
638 Description of rule from the original XACML file is reflected in this leaf. |
|
639 Status: Optional |
|
640 Occurs: One |
|
641 Format: Chr |
|
642 Access Types: Get |
|
643 Values: N/A |
|
644 */ |
|
645 MSmlDmDDFObject& rulesDescNode = |
|
646 rulesDynaNode.AddChildObjectL( KNSmlPMRulesDescNodeName ); |
|
647 FillNodeInfoL( rulesDescNode, accessTypesGet, |
|
648 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
649 MSmlDmDDFObject::EChr, KNSmlPMRulesDescNodeDescription ); |
|
650 |
|
651 TSmlDmAccessTypes accessTypesExec; |
|
652 accessTypesExec.SetExec(); |
|
653 |
|
654 /* |
|
655 Node: ./PolicyMgmt/Delivery |
|
656 This node holds the nodes that let DM Server to bring PolicyManagement |
|
657 command packages to device and observe status of such action. |
|
658 Support: Mandatory |
|
659 Occurs: One |
|
660 Format: Node |
|
661 Access Types: Get |
|
662 Values: N/A |
|
663 */ |
|
664 MSmlDmDDFObject& pdNode = |
|
665 pmNode.AddChildObjectL( KNSmlPMPolicyDeliveryNodeName ); |
|
666 FillNodeInfoL( pdNode, accessTypesGet, |
|
667 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
668 MSmlDmDDFObject::ENode, KNSmlPMPolicyDeliveryNodeDescription ); |
|
669 |
|
670 /* |
|
671 Node: PolicyMgmt/Delivery/Sink |
|
672 This node is used by DM Server to bring PolicyManagement |
|
673 command packages to device. |
|
674 The packages are delivered in XML. |
|
675 Support: Mandatory |
|
676 Occurs: One |
|
677 Format: Xml |
|
678 Access Types: Exec |
|
679 Values: N/A |
|
680 */ |
|
681 MSmlDmDDFObject& sinkNode = pdNode.AddChildObjectL( KNSmlPMDeliverySinkNodeName ); |
|
682 FillNodeInfoL( sinkNode, accessTypesExec, |
|
683 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
684 MSmlDmDDFObject::EXml, KNSmlPMDeliverySinkNodeDescription ); |
|
685 |
|
686 /* |
|
687 Node: ./PolicyMgmt/Delivery/LastStatus |
|
688 This node stores status of last executed delivery command. |
|
689 |
|
690 Support: Mandatory |
|
691 Occurs: One |
|
692 Format: chr |
|
693 Access Types: Get |
|
694 Values: See below |
|
695 */ |
|
696 MSmlDmDDFObject& ldsNode = |
|
697 pdNode.AddChildObjectL( KNSmlPMLastDeliveryStatusNodeName ); |
|
698 FillNodeInfoL( ldsNode, accessTypesGet, |
|
699 MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent, |
|
700 MSmlDmDDFObject::EChr, KNSmlPMLastDeliveryStatusNodeDescription ); |
|
701 |
|
702 RDEBUG( "CPmAdapter::DDFStructureL(): end" ); |
|
703 } |
|
704 |
|
705 // ------------------------------------------------------------------------------------------------ |
|
706 // CPmAdapter::UpdateLeafObjectL() |
|
707 // ------------------------------------------------------------------------------------------------ |
|
708 void CPmAdapter::UpdateLeafObjectL( const TDesC8& aURI, const TDesC8& /*aLUID*/, |
|
709 const TDesC8& /*aObject*/, |
|
710 const TDesC8& /*aType*/, TInt aStatusRef ) |
|
711 { |
|
712 RDEBUG_2("CPmAdapter::UpdateLeafObjectL(): '%S' begin - WARNING No nodes with A or R access", &aURI ); |
|
713 TError ret( EError ); |
|
714 Callback().SetStatusL( aStatusRef, ret ); |
|
715 RDEBUG("CPmAdapter::UpdateLeafObjectL(): end"); |
|
716 } |
|
717 |
|
718 // ------------------------------------------------------------------------------------------------ |
|
719 // CPmAdapter::DeleteObjectL( const TDesC8& aURI, const TDesC8& aLUID, TInt aStatusRef) |
|
720 // ------------------------------------------------------------------------------------------------ |
|
721 void CPmAdapter::DeleteObjectL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, TInt aStatusRef) |
|
722 { |
|
723 RDEBUG( "CPmAdapter::DeleteObjectL(): ERROR Delete NOT SUPPORTED" ); |
|
724 TError ret( EError ); |
|
725 Callback().SetStatusL( aStatusRef, ret ); |
|
726 } |
|
727 |
|
728 // ------------------------------------------------------------------------------------------------ |
|
729 // CPmAdapter::FetchLeafObjectL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC& aType, |
|
730 // CBufBase& aObject, TInt aResultsRef, TInt aStatusRef ) |
|
731 // ------------------------------------------------------------------------------------------------ |
|
732 void CPmAdapter::FetchLeafObjectL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& aType, |
|
733 TInt aResultsRef, TInt aStatusRef ) |
|
734 { |
|
735 RDEBUG8_3("CPmAdapter::FetchLeafObjectL('%S','%S'): begin", &aURI, &aLUID); |
|
736 |
|
737 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
738 TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash(aURI); |
|
739 TInt cnt( NSmlDmURI::NumOfURISegs( uriPtrc ) ); |
|
740 TPtrC8 mapping( NSmlDmURI::LastURISeg( uriPtrc ) ); |
|
741 #else |
|
742 TInt cnt( NSmlDmURI::NumOfURISegs( aURI ) ); |
|
743 TPtrC8 mapping( NSmlDmURI::LastURISeg( aURI ) ); |
|
744 #endif |
|
745 |
|
746 TError ret( EOk ); |
|
747 CBufBase* object = CBufFlat::NewL( KFeatchLeafObjectBufferSize ); |
|
748 CleanupStack::PushL( object ); |
|
749 switch ( cnt ) |
|
750 { |
|
751 case 1: |
|
752 case 2: |
|
753 { |
|
754 RDEBUG( "CPmAdapter::FetchLeafObjectL(): WARNING Nonexisting Level 1 or 2 leaf requested" ); |
|
755 ret = EError ; |
|
756 #ifdef __LO_TEST__ |
|
757 if ( mapping == KTestNodeName ) |
|
758 { |
|
759 RFs fs ; |
|
760 User::LeaveIfError( fs.Connect() ) ; |
|
761 CleanupClosePushL( fs ); |
|
762 RFile file ; |
|
763 User::LeaveIfError( file.Open( fs, KTestFileName, EFileRead ) ); |
|
764 CleanupClosePushL( file ); |
|
765 TInt size; |
|
766 User::LeaveIfError( file.Size( size ) ); |
|
767 HBufC8 *data = HBufC8::NewLC( size ); |
|
768 |
|
769 TPtr8 ptr( data->Des() ); |
|
770 User::LeaveIfError( file.Read( ptr ) ); |
|
771 TImCodecB64 B64Coder; |
|
772 HBufC8 *target = HBufC8::NewLC( ( size * 6 ) / 3 ); |
|
773 TPtr8 targetPtr( target->Des() ); |
|
774 B64Coder.Encode( *data, targetPtr ); |
|
775 object->InsertL( 0, ptr ); |
|
776 CleanupStack::PopAndDestroy( 3, &fs ); |
|
777 ret = EOk; |
|
778 } |
|
779 #endif |
|
780 break; |
|
781 } |
|
782 case 3: |
|
783 { |
|
784 if ( mapping == KNSmlPMLastDeliveryStatusNodeName ) |
|
785 { |
|
786 object->InsertL( 0, ((iLastStatus == NULL) ? KNullDesC8() : *iLastStatus) ); |
|
787 } |
|
788 else |
|
789 { |
|
790 RDEBUG ( "CPmAdapter::FetchLeafObjectL(): WARNING Nonexisting Level 3 leaf requested" ); |
|
791 ret = EError ; |
|
792 } |
|
793 break; |
|
794 } |
|
795 case 4: |
|
796 { |
|
797 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
798 TPtrC8 parent( NSmlDmURI::RemoveLastSeg ( uriPtrc ) ); |
|
799 #else |
|
800 TPtrC8 parent( NSmlDmURI::RemoveLastSeg ( aURI ) ); |
|
801 #endif |
|
802 TPtrC8 parentMapping ( NSmlDmURI::LastURISeg( parent ) ); |
|
803 GetElementInfoL( parentMapping, mapping, object, ret ); |
|
804 break; |
|
805 } |
|
806 case 5: |
|
807 { |
|
808 RDEBUG ( "CPmAdapter::FetchLeafObjectL(): WARNING Nonexisting Level 5 leaf requested" ); |
|
809 ret = EError ; |
|
810 break; |
|
811 } |
|
812 case 6: |
|
813 { |
|
814 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
815 TPtrC8 parent( NSmlDmURI::RemoveLastSeg ( uriPtrc ) ); |
|
816 #else |
|
817 TPtrC8 parent( NSmlDmURI::RemoveLastSeg ( aURI ) ); |
|
818 #endif |
|
819 TPtrC8 parentMapping ( NSmlDmURI::LastURISeg( parent ) ); |
|
820 ret = EOk ; |
|
821 |
|
822 if ( mapping == KNSmlPMPolicySetPoliciesPolicyNodeName ) |
|
823 { |
|
824 object->InsertL( 0, parentMapping ) ; |
|
825 } |
|
826 else if ( mapping == KNSmlPMPolicySetPolicySetsPolicySetNodeName ) |
|
827 { |
|
828 object->InsertL( 0, parentMapping ) ; |
|
829 } |
|
830 else if ( mapping == KNSmlPMPoliciesRulesRuleNodeName ) |
|
831 { |
|
832 object->InsertL( 0, parentMapping ) ; |
|
833 } |
|
834 else |
|
835 { |
|
836 ret = EError ; |
|
837 } |
|
838 break; |
|
839 } |
|
840 default: |
|
841 { |
|
842 RDEBUG_2("CPmAdapter::FetchLeafObjectL(): WARNING Nonexisting Level %d leaf requested", cnt ); |
|
843 ret = EError ; |
|
844 break; |
|
845 } |
|
846 } |
|
847 if ( ret == EOk ) |
|
848 { |
|
849 Callback().SetResultsL( aResultsRef, *object, aType ); |
|
850 } |
|
851 Callback().SetStatusL( aStatusRef, ret ); |
|
852 CleanupStack::PopAndDestroy( object ) ; |
|
853 RDEBUG("CPmAdapter::FetchLeafObjectL(): end"); |
|
854 } |
|
855 |
|
856 |
|
857 // ------------------------------------------------------------------------------------------------ |
|
858 // MSmlDmAdapter::TError CPmAdapter::InsertIfFoundL( const TDesC8 &aElementId, |
|
859 // const TDesC8& aData, CBufBase &aObject ) |
|
860 // ------------------------------------------------------------------------------------------------ |
|
861 MSmlDmAdapter::TError CPmAdapter::InsertIfFoundL( const TDesC8 &aElementId, const TDesC8& aData, |
|
862 CBufBase &aObject ) |
|
863 { |
|
864 RDEBUG8_3("CPmAdapter::InsertIfFoundL, elementID= %S, Data= %S", &aElementId, &aData ); |
|
865 TError ret(EError); |
|
866 TElementInfo info( aElementId ); |
|
867 TInt err( iManagement.GetElementL( info ) ); |
|
868 if ( err == KErrNone ) |
|
869 { |
|
870 aObject.InsertL( 0, aData ); |
|
871 ret = EOk; |
|
872 } |
|
873 else if ( err == KErrNotFound ) |
|
874 { |
|
875 ret = ENotFound; |
|
876 } |
|
877 return ret; |
|
878 } |
|
879 |
|
880 // ------------------------------------------------------------------------------------------------ |
|
881 // CPmAdapter::GetElementInfoL(const TDesC8 &aElementId, |
|
882 // const TDesC8 &aType, CBufBase* aObject, TError &aRet) |
|
883 // ------------------------------------------------------------------------------------------------ |
|
884 TInt CPmAdapter::GetElementInfoL(const TDesC8 &aElementId, |
|
885 const TDesC8 &aType, CBufBase* aObject, TError &aRet) |
|
886 { |
|
887 RDEBUG8_2("CPmAdapter::GetElementInfoL, ElementID= %S", &aElementId ); |
|
888 aRet = EError ; |
|
889 TElementInfo info( aElementId ); |
|
890 TInt err( iManagement.GetElementL( info ) ); |
|
891 if ( err == KErrNone ) |
|
892 { |
|
893 if ( aType == KNSmlPMPolicySetIDNodeName ) |
|
894 { |
|
895 aObject->InsertL( 0, info.GetElementId() ); |
|
896 aRet = EOk; |
|
897 } |
|
898 else if ( aType == KNSmlPMPolicySetDataNodeName ) |
|
899 { |
|
900 err = iManagement.GetXACMLDescriptionL( info ); |
|
901 if ( err == KErrNone ) |
|
902 { |
|
903 aObject->InsertL( 0, info.GetXACML() ) ; |
|
904 aRet = EOk; |
|
905 } |
|
906 else |
|
907 { |
|
908 RDEBUG_3("CPmAdapter::GetElementInfoL(): FAILED to get XACML element!! 0x%X (%d)", err, err ); |
|
909 } |
|
910 } |
|
911 else if ( aType == KNSmlPMPolicySetDescriptionNodeName ) |
|
912 { |
|
913 aObject->InsertL( 0, info.GetDescription() ); |
|
914 aRet = EOk; |
|
915 } |
|
916 else |
|
917 { |
|
918 RDEBUG_2("CPmAdapter::GetElementInfoL(): ERROR Unknown attribute askedt!! '%S'", &aType ); |
|
919 } |
|
920 } |
|
921 else |
|
922 { |
|
923 RDEBUG_2("CPmAdapter::GetElementInfoL(): GetElementL FAILED to get policy set element!! %d", err ); |
|
924 } |
|
925 return err ; |
|
926 } |
|
927 |
|
928 // ------------------------------------------------------------------------------------------------ |
|
929 // CPmAdapter::GetElementAndAddToResponseL( const TDesC8 &aParentMapping, CBufBase &aObject, |
|
930 // MSmlDmAdapter::TError &ret ) |
|
931 // ------------------------------------------------------------------------------------------------ |
|
932 void CPmAdapter::GetElementAndAddToResponseL( const TDesC8 &aParentMapping, CBufBase &aObject, |
|
933 MSmlDmAdapter::TError &ret ) |
|
934 { |
|
935 RDEBUG("CPmAdapter::GetElementAndAddToResponseL"); |
|
936 TElementInfo info( aParentMapping ); |
|
937 TInt err( iManagement.GetElementL( info ) ); |
|
938 if ( err == KErrNone ) |
|
939 { |
|
940 ArrayToDMResponseL( info.GetChildElementArray(), aObject ); |
|
941 } |
|
942 else |
|
943 { |
|
944 RDEBUG_3("CPmAdapter::GetElementAndAddToResponseL(): WARNING Failed get element %S: %d" , |
|
945 &aParentMapping, err ); |
|
946 ret = EError; |
|
947 } |
|
948 } |
|
949 |
|
950 // ------------------------------------------------------------------------------------------------ |
|
951 // CPmAdapter::ArrayToDMResponseL( const RElementIdArray &aArray, CBufBase &aObject) |
|
952 // ------------------------------------------------------------------------------------------------ |
|
953 void CPmAdapter::ArrayToDMResponseL( const RElementIdArray &aArray, CBufBase &aObject) |
|
954 { |
|
955 RDEBUG("CPmAdapter::ArrayToDMResponseL"); |
|
956 TInt count( aArray.Count() ); |
|
957 for( TInt i( 0 ); i < count; i++ ) |
|
958 { |
|
959 HBufC8 *el = aArray[i]; |
|
960 aObject.InsertL( aObject.Size(), *el ); |
|
961 if ( i + 1 < count ) |
|
962 { |
|
963 aObject.InsertL( aObject.Size(), KNSmlPMSeparator8 ); |
|
964 } |
|
965 } |
|
966 } |
|
967 |
|
968 // ------------------------------------------------------------------------------------------------ |
|
969 // CPmAdapter::ChildURIListL( const TDesC8& aURI, const TDesC& aParentLUID, |
|
970 // const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList, |
|
971 // CArrayFix<TPtrC>& aCurrentURISegmentList ) |
|
972 // ------------------------------------------------------------------------------------------------ |
|
973 void CPmAdapter::ChildURIListL( const TDesC8& aURI, const TDesC8& /*aLUID*/, |
|
974 const CArrayFix<TSmlDmMappingInfo>& /*aPreviousURISegmentList*/, |
|
975 TInt aResultsRef, TInt aStatusRef ) |
|
976 { |
|
977 RDEBUG8_2("CPmAdapter::ChildURIListL(): begin %S", &aURI); |
|
978 |
|
979 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
980 TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash(aURI); |
|
981 TInt cnt( NSmlDmURI::NumOfURISegs( uriPtrc ) ); |
|
982 #else |
|
983 TInt cnt( NSmlDmURI::NumOfURISegs( aURI ) ); |
|
984 #endif |
|
985 |
|
986 TError ret( EOk ); |
|
987 CBufBase *object = CBufFlat::NewL( KFeatchChildUriListBufferSize ); |
|
988 CleanupStack::PushL( object ); |
|
989 |
|
990 switch ( cnt ) |
|
991 { |
|
992 case 1: |
|
993 { |
|
994 |
|
995 if ( NSmlDmURI::LastURISeg( aURI ) == KNSmlPMNodeName ) |
|
996 { |
|
997 object->InsertL( 0, KNSmlPMListOfLeafs ); |
|
998 } |
|
999 else |
|
1000 { |
|
1001 RDEBUG ( "CPmAdapter::ChildURIListL(): WARNING Level 1 invalid mapping " ); |
|
1002 ret = EInvalidObject ; |
|
1003 } |
|
1004 break; |
|
1005 } |
|
1006 case 2: |
|
1007 { |
|
1008 |
|
1009 TPtrC8 mapping ( NSmlDmURI::LastURISeg( aURI ) ) ; |
|
1010 TElementType type ; |
|
1011 TBool ok( ETrue ) ; |
|
1012 if ( mapping == KNSmlPMPolicySetsNodeName ) |
|
1013 { |
|
1014 type = EPolicySets; |
|
1015 } |
|
1016 else if ( mapping == KNSmlPMPoliciesNodeName ) |
|
1017 { |
|
1018 |
|
1019 type = EPolicies; |
|
1020 } |
|
1021 else if ( mapping == KNSmlPMRulesNodeName ) |
|
1022 { |
|
1023 type = ERules; |
|
1024 } |
|
1025 else if ( mapping == KNSmlPMPolicyDeliveryNodeName ) |
|
1026 { |
|
1027 object->InsertL( 0, KNullDesC8() ) ; |
|
1028 RDEBUG ( "CPmAdapter::ChildURIListL(): Asking policydelivery node childs" ); |
|
1029 ok = EFalse; |
|
1030 } |
|
1031 else |
|
1032 { |
|
1033 RDEBUG ( "CPmAdapter::ChildURIListL(): WARNING Level 2 invalid mapping " ); |
|
1034 ok = EFalse; |
|
1035 ret = EInvalidObject; |
|
1036 } |
|
1037 if ( ok ) |
|
1038 { |
|
1039 RElementIdArray array; |
|
1040 CleanupClosePushL( array ); |
|
1041 |
|
1042 TInt err( iManagement.GetElementListL( type, array ) ); |
|
1043 if ( err == KErrNone ) |
|
1044 { |
|
1045 ArrayToDMResponseL( array, *object ); |
|
1046 ret = EOk; |
|
1047 } |
|
1048 else |
|
1049 { |
|
1050 RDEBUG_2("CPmAdapter::ChildURIListL(): ERROR Policy engine error: %d", err) ; |
|
1051 ret = EError; |
|
1052 } |
|
1053 CleanupStack::PopAndDestroy( &array ); |
|
1054 } |
|
1055 break; |
|
1056 } |
|
1057 case 3: |
|
1058 { |
|
1059 |
|
1060 TPtrC8 mapping ( NSmlDmURI::LastURISeg ( NSmlDmURI::RemoveLastSeg( aURI ) ) ) ; |
|
1061 if ( mapping == KNSmlPMPolicySetsNodeName ) |
|
1062 { |
|
1063 ret = InsertIfFoundL( NSmlDmURI::LastURISeg( aURI ), |
|
1064 KNSmlPMListOfDynamicSetsDynaLeafs, *object ); |
|
1065 } |
|
1066 else if ( mapping == KNSmlPMPoliciesNodeName ) |
|
1067 { |
|
1068 ret = InsertIfFoundL( NSmlDmURI::LastURISeg( aURI ), |
|
1069 KNSmlPMListOfPoliciesDynaLeafs, *object ); |
|
1070 } |
|
1071 else if ( mapping == KNSmlPMRulesNodeName ) |
|
1072 { |
|
1073 |
|
1074 ret = InsertIfFoundL( NSmlDmURI::LastURISeg( aURI ), |
|
1075 KNSmlPMListOfRulesDynaLeafs, *object ); |
|
1076 } |
|
1077 else if ( mapping == KNSmlPMLastDeliveryStatusNodeName ) |
|
1078 { |
|
1079 |
|
1080 object->InsertL( 0, KNullDesC8() ) ; |
|
1081 RDEBUG ( "CPmAdapter::ChildURIListL(): Asking laststatus node childs" ); |
|
1082 ret = EError; |
|
1083 } |
|
1084 else |
|
1085 { |
|
1086 RDEBUG ( "CPmAdapter::ChildURIListL(): WARNING Level 3 Unknown parent " ); |
|
1087 ret = EError ; |
|
1088 } |
|
1089 break; |
|
1090 } |
|
1091 case 4: |
|
1092 { |
|
1093 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
1094 TPtrC8 mapping( NSmlDmURI::LastURISeg( uriPtrc ) ); |
|
1095 TPtrC8 parent( NSmlDmURI::RemoveLastSeg( uriPtrc ) ); |
|
1096 #else |
|
1097 TPtrC8 mapping( NSmlDmURI::LastURISeg( aURI ) ); |
|
1098 TPtrC8 parent( NSmlDmURI::RemoveLastSeg( aURI ) ); |
|
1099 #endif |
|
1100 |
|
1101 TPtrC8 parentMapping ( NSmlDmURI::LastURISeg( parent ) ); |
|
1102 TPtrC8 grandParent ( NSmlDmURI::RemoveLastSeg( parent ) ) ; |
|
1103 TPtrC8 grandParentMapping( NSmlDmURI::LastURISeg( grandParent ) ); |
|
1104 |
|
1105 if ( grandParentMapping == KNSmlPMPolicySetsNodeName ) |
|
1106 { |
|
1107 if ( mapping == KNSmlPMPolicySetPoliciesNodeName |
|
1108 || mapping == KNSmlPMPolicySetPolicySetsNodeName) |
|
1109 { |
|
1110 GetElementAndAddToResponseL( parentMapping, *object, ret ); |
|
1111 } |
|
1112 else |
|
1113 { |
|
1114 RDEBUG("CPmAdapter::ChildURIListL(): WARNING Level 4 Asks children although there are none" ); |
|
1115 object->InsertL( 0, KNullDesC8 ); |
|
1116 } |
|
1117 } |
|
1118 else if ( grandParentMapping == KNSmlPMPoliciesNodeName ) |
|
1119 { |
|
1120 if ( mapping == KNSmlPMPoliciesRulesNodeName ) |
|
1121 { |
|
1122 GetElementAndAddToResponseL( parentMapping, *object, ret ); |
|
1123 } |
|
1124 else |
|
1125 { |
|
1126 RDEBUG("CPmAdapter::ChildURIListL(): WARNING Level 4 Asks (Policies) leaf children although there are none"); |
|
1127 object->InsertL( 0, KNullDesC8 ); |
|
1128 } |
|
1129 } |
|
1130 else if ( grandParentMapping == KNSmlPMRulesNodeName ) |
|
1131 { |
|
1132 RDEBUG("CPmAdapter::ChildURIListL(): WARNING Level 4 Asks Rules leaf children although there are none"); |
|
1133 object->InsertL( 0, KNullDesC8 ); |
|
1134 } |
|
1135 else |
|
1136 { |
|
1137 RDEBUG("CPmAdapter::ChildURIListL(): WARNING Level 4 Unknown parent " ); |
|
1138 ret = EInvalidObject ; |
|
1139 } |
|
1140 break; |
|
1141 } |
|
1142 case 5: |
|
1143 { |
|
1144 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
1145 TPtrC8 parent( NSmlDmURI::RemoveLastSeg( uriPtrc ) ); |
|
1146 #else |
|
1147 TPtrC8 parent( NSmlDmURI::RemoveLastSeg( aURI ) ); |
|
1148 #endif |
|
1149 |
|
1150 if ( parent == KNSmlPMPolicySetPoliciesNodeName ) |
|
1151 { |
|
1152 |
|
1153 ret = InsertIfFoundL( NSmlDmURI::LastURISeg( aURI ), |
|
1154 KNSmlPMPolicySetPoliciesPolicyNodeName, *object ); |
|
1155 } |
|
1156 else if ( parent == KNSmlPMPolicySetPolicySetsNodeName ) |
|
1157 { |
|
1158 |
|
1159 ret = InsertIfFoundL( NSmlDmURI::LastURISeg( aURI ), |
|
1160 KNSmlPMPolicySetPolicySetsPolicySetNodeName, *object ); |
|
1161 } |
|
1162 else if ( parent == KNSmlPMPoliciesRulesNodeName ) |
|
1163 { |
|
1164 |
|
1165 ret = InsertIfFoundL( NSmlDmURI::LastURISeg( aURI ), |
|
1166 KNSmlPMPoliciesRulesRuleNodeName, *object ); |
|
1167 } |
|
1168 else |
|
1169 { |
|
1170 RDEBUG ( "CPmAdapter::ChildURIListL(): WARNING Level 5 Unkown parent " ); |
|
1171 ret = ENotFound; |
|
1172 } |
|
1173 break; |
|
1174 } |
|
1175 case 6: |
|
1176 { |
|
1177 RDEBUG ( "CPmAdapter::ChildURIListL(): WARNING Level 6 " ); |
|
1178 ret = EInvalidObject ; |
|
1179 break; |
|
1180 } |
|
1181 default: |
|
1182 { |
|
1183 RDEBUG ( "CPmAdapter::ChildURIListL(): WARNING Unknown Level" ); |
|
1184 ret = EError ; |
|
1185 } |
|
1186 } |
|
1187 |
|
1188 Callback().SetStatusL( aStatusRef, ret ); |
|
1189 |
|
1190 if( ret==CSmlDmAdapter::EOk ) |
|
1191 { |
|
1192 Callback().SetResultsL( aResultsRef, *object, KNullDesC8 ); |
|
1193 } |
|
1194 CleanupStack::PopAndDestroy( object ); |
|
1195 RDEBUG("CPmAdapter::ChildURIListL(): end"); |
|
1196 } |
|
1197 |
|
1198 // ------------------------------------------------------------------------------------------------ |
|
1199 // CPmAdapter::ExecuteCommandL( const TDesC8& aURI, const TDesC8& /*aLUID*/, |
|
1200 // const TDesC8& aArgument, const TDesC8& /*aType*/, |
|
1201 // TInt aStatusRef ) |
|
1202 // ------------------------------------------------------------------------------------------------ |
|
1203 void CPmAdapter::ExecuteCommandL( const TDesC8& aURI, const TDesC8& /*aLUID*/, |
|
1204 const TDesC8& aArgument, const TDesC8& /*aType*/, |
|
1205 TInt aStatusRef ) |
|
1206 { |
|
1207 RDEBUG8_2("CPmAdapter::ExecuteCommandL(): begin '%S'", &aURI ); |
|
1208 |
|
1209 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
1210 TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash(aURI); |
|
1211 TInt cnt( NSmlDmURI::NumOfURISegs( uriPtrc ) ); |
|
1212 #else |
|
1213 TInt cnt( NSmlDmURI::NumOfURISegs( aURI ) ); |
|
1214 #endif |
|
1215 |
|
1216 CSmlDmAdapter::TError ret ( CSmlDmAdapter::EInvalidObject ); |
|
1217 |
|
1218 if ( cnt == 3 ) |
|
1219 { |
|
1220 // SymbianConvergency, KSinkLeaf modified -> should be ok to use aURI directly... |
|
1221 if ( aURI == KSinkLeaf ) |
|
1222 { |
|
1223 TElementId id ; |
|
1224 TParserResponse resp ; |
|
1225 |
|
1226 #ifdef __TEST_NO_ENGINE__ |
|
1227 TInt err( KErrNone ); |
|
1228 #else |
|
1229 TInt err( iManagement.ExecuteOperation( aArgument, resp ) ); |
|
1230 #endif |
|
1231 |
|
1232 if ( err == KErrNone ) |
|
1233 { |
|
1234 RDEBUG8_2(" -> ExecuteOperation OK: %S", &resp.GetReturnMessage() ); |
|
1235 SetLastStatusL( resp.GetReturnMessage() ); |
|
1236 if ( iInAtomic ) |
|
1237 { |
|
1238 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
1239 iAtomiced.AppendL( CPmCommand::NewL( aStatusRef, uriPtrc, aArgument ) ); |
|
1240 #else |
|
1241 iAtomiced.AppendL( CPmCommand::NewL( aStatusRef, aURI, aArgument ) ); |
|
1242 #endif |
|
1243 } |
|
1244 ret = EOk ; |
|
1245 RDEBUG8_2("CPmAdapter::ExecuteCommandL(): SUCCESS adding policy or set or rule!! '%S'", &resp.GetReturnMessage() ); |
|
1246 } |
|
1247 else |
|
1248 { |
|
1249 RDEBUG_2(" -> Execute operation NOT OK: %d", err ); |
|
1250 RDEBUG8_2(" -> Execute operation NOT OK: %S", &resp.GetReturnMessage() ); |
|
1251 SetLastStatusL( resp.GetReturnMessage() ); |
|
1252 RDEBUG_2("CPmAdapter::ExecuteCommandL(): FAILED adding policy or set or rule!! %d", err ); |
|
1253 ret = EError ; |
|
1254 } |
|
1255 } |
|
1256 else |
|
1257 { |
|
1258 RDEBUG("CPmAdapter::ExecuteCommandL(): ERROR leaf!!" ); |
|
1259 ret = EError ; |
|
1260 } |
|
1261 } |
|
1262 else |
|
1263 { |
|
1264 RDEBUG(" CPmAdapter::ExecuteCommandL(): ERROR unsupported command target!" ); |
|
1265 } |
|
1266 Callback().SetStatusL( aStatusRef, ret); |
|
1267 |
|
1268 |
|
1269 RDEBUG("CPmAdapter::ExecuteCommandL(): end" ); |
|
1270 } |
|
1271 |
|
1272 // ------------------------------------------------------------------------------------------------ |
|
1273 // CPmAdapter::ExecuteCommandL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, |
|
1274 // RWriteStream*& /*aStream*/, const TDesC8& /*aType*/, |
|
1275 // TInt /*aStatusRef*/ ) |
|
1276 // ------------------------------------------------------------------------------------------------ |
|
1277 void CPmAdapter::ExecuteCommandL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, |
|
1278 RWriteStream*& /*aStream*/, const TDesC8& /*aType*/, |
|
1279 TInt /*aStatusRef*/ ) |
|
1280 { |
|
1281 RDEBUG("CPmAdapter::ExecuteCommandL() (stream): begin ( not supported - leaving )"); |
|
1282 User::Leave( KErrNotSupported ) ; |
|
1283 } |
|
1284 |
|
1285 // ------------------------------------------------------------------------------------------------ |
|
1286 // CPmAdapter::UpdateLeafObjectL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, |
|
1287 // RWriteStream*& /*aStream*/, const TDesC8& /*aType*/, |
|
1288 // TInt /*aStatusRef*/ ) |
|
1289 // ------------------------------------------------------------------------------------------------ |
|
1290 void CPmAdapter::UpdateLeafObjectL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, |
|
1291 RWriteStream*& /*aStream*/, const TDesC8& /*aType*/, |
|
1292 TInt /*aStatusRef*/ ) |
|
1293 { |
|
1294 RDEBUG("CPmAdapter::UpdateLeafObjectL() (stream): begin ( not supported - leaving )"); |
|
1295 User::Leave( KErrNotSupported ) ; |
|
1296 } |
|
1297 |
|
1298 // ------------------------------------------------------------------------------------------------ |
|
1299 // CPmAdapter::CopyCommandL( const TDesC8& /*aTargetURI*/, const TDesC8& /*aTargetLUID*/, |
|
1300 // const TDesC8& /*aSourceURI*/, const TDesC8& /*aSourceLUID*/, |
|
1301 // const TDesC8& /*aType*/, TInt /*aStatusRef*/ ) |
|
1302 // ------------------------------------------------------------------------------------------------ |
|
1303 void CPmAdapter::CopyCommandL( const TDesC8& /*aTargetURI*/, const TDesC8& /*aTargetLUID*/, |
|
1304 const TDesC8& /*aSourceURI*/, const TDesC8& /*aSourceLUID*/, |
|
1305 const TDesC8& /*aType*/, TInt /*aStatusRef*/ ) |
|
1306 { |
|
1307 RDEBUG("CPmAdapter::CopyCommandL(): begin ( not supported - leaving )"); |
|
1308 User::Leave( KErrNotSupported ) ; |
|
1309 } |
|
1310 |
|
1311 // ------------------------------------------------------------------------------------------------ |
|
1312 // CPmAdapter::StartAtomicL() |
|
1313 // ------------------------------------------------------------------------------------------------ |
|
1314 void CPmAdapter::StartAtomicL() |
|
1315 { |
|
1316 RDEBUG("CPmAdapter::StartAtomicL(): begin"); |
|
1317 iInAtomic = ETrue ; |
|
1318 RDEBUG("CPmAdapter::StartAtomicL(): end"); |
|
1319 } |
|
1320 |
|
1321 // ------------------------------------------------------------------------------------------------ |
|
1322 // CPmAdapter::CommitAtomicL() |
|
1323 // ------------------------------------------------------------------------------------------------ |
|
1324 void CPmAdapter::CommitAtomicL() |
|
1325 { |
|
1326 RDEBUG("CPmAdapter::CommitAtomicL(): begin"); |
|
1327 iInAtomic = EFalse ; |
|
1328 RDEBUG("CPmAdapter::CommitAtomicL(): end"); |
|
1329 } |
|
1330 |
|
1331 // ------------------------------------------------------------------------------------------------ |
|
1332 // CPmAdapter::RollbackAtomicL() |
|
1333 // ------------------------------------------------------------------------------------------------ |
|
1334 void CPmAdapter::RollbackAtomicL() |
|
1335 { |
|
1336 RDEBUG("CPmAdapter::RollbackAtomicL(): begin"); |
|
1337 TInt count( iAtomiced.Count() ); |
|
1338 for ( TInt i(0); i < count; i++ ) |
|
1339 { |
|
1340 CPmCommand *pm = iAtomiced[i]; |
|
1341 if( pm ) |
|
1342 { |
|
1343 Callback().SetStatusL( pm->StatusRef(), ERollbackFailed ); |
|
1344 } |
|
1345 } |
|
1346 RDEBUG("CPmAdapter::RollbackAtomicL(): end"); |
|
1347 } |
|
1348 |
|
1349 // ------------------------------------------------------------------------------------------------ |
|
1350 // CPmAdapter::StreamingSupport( TInt& /*aItemSize*/ ) |
|
1351 // ------------------------------------------------------------------------------------------------ |
|
1352 TBool CPmAdapter::StreamingSupport( TInt& /*aItemSize*/ ) |
|
1353 { |
|
1354 RDEBUG("CPmAdapter::StreamingSupport(): (no streaming support)"); |
|
1355 return EFalse; |
|
1356 } |
|
1357 |
|
1358 // ------------------------------------------------------------------------------------------------ |
|
1359 // CPmAdapter::StreamCommittedL() |
|
1360 // ------------------------------------------------------------------------------------------------ |
|
1361 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
1362 void CPmAdapter::StreamCommittedL( RWriteStream& /*aStream*/ ) |
|
1363 #else |
|
1364 void CPmAdapter::StreamCommittedL() |
|
1365 #endif |
|
1366 { |
|
1367 RDEBUG("CPmAdapter::StreamCommittedL(): begin"); |
|
1368 RDEBUG("CPmAdapter::StreamCommittedL(): end"); |
|
1369 } |
|
1370 |
|
1371 // ------------------------------------------------------------------------------------------------ |
|
1372 // CPmAdapter::CompleteOutstandingCmdsL() |
|
1373 // ------------------------------------------------------------------------------------------------ |
|
1374 void CPmAdapter::CompleteOutstandingCmdsL() |
|
1375 { |
|
1376 RDEBUG("CPmAdapter::CompleteOutstandingCmdsL(): begin"); |
|
1377 RDEBUG("CPmAdapter::CompleteOutstandingCmdsL(): end"); |
|
1378 } |
|
1379 |
|
1380 // ------------------------------------------------------------------------------------------------ |
|
1381 // CPmAdapter::AddNodeObjectL( const TDesC8& aURI, const TDesC& aParentLUID, TInt aStatusRef ) |
|
1382 // ------------------------------------------------------------------------------------------------ |
|
1383 void CPmAdapter::AddNodeObjectL( const TDesC8& /*aURI*/, const TDesC8& /*aParentLUID*/, TInt aStatusRef ) |
|
1384 { |
|
1385 RDEBUG("CPmAdapter::AddNodeObjectL(): begin"); |
|
1386 TError ret( EError ); |
|
1387 RDEBUG("CPmAdapter::AddNodeObjectL(): ERROR Add method not supported by any node or leaf!!"); |
|
1388 Callback().SetStatusL( aStatusRef, ret ); |
|
1389 RDEBUG("CPmAdapter::AddNodeObjectL(): end"); |
|
1390 } |
|
1391 |
|
1392 // ------------------------------------------------------------------------------------------------ |
|
1393 // CPmAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, const TDesC8& aLUID, |
|
1394 // const TDesC8& aType, TInt aResultsRef, |
|
1395 // TInt aStatusRef ) |
|
1396 // ------------------------------------------------------------------------------------------------ |
|
1397 void CPmAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, const TDesC8& /*aLUID*/, |
|
1398 const TDesC8& aType, TInt aResultsRef, |
|
1399 TInt aStatusRef ) |
|
1400 { |
|
1401 RDEBUG8_2("CPmAdapter::FetchLeafObjectSizeL(): begin '%S'", &aURI ); |
|
1402 |
|
1403 #ifdef __TARM_SYMBIAN_CONVERGENCY |
|
1404 TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash(aURI); |
|
1405 TPtrC8 mapping( NSmlDmURI::LastURISeg( uriPtrc ) ); |
|
1406 TPtrC8 parent( NSmlDmURI::RemoveLastSeg( uriPtrc ) ); |
|
1407 #else |
|
1408 TPtrC8 mapping( NSmlDmURI::LastURISeg( aURI ) ); |
|
1409 TPtrC8 parent( NSmlDmURI::RemoveLastSeg( aURI ) ); |
|
1410 #endif |
|
1411 |
|
1412 TError ret( EError ); |
|
1413 TPtrC8 parentMapping ( NSmlDmURI::LastURISeg( parent ) ); |
|
1414 CBufBase *object = CBufFlat::NewL( KFeatchLeafObjectSize ); |
|
1415 GetElementInfoL( parentMapping, mapping, object, ret ); |
|
1416 if ( ret == EOk ) |
|
1417 { |
|
1418 HBufC8 *size = IntToDes8LC( object->Size() ); |
|
1419 object->Reset(); |
|
1420 object->InsertL( 0, *size ); |
|
1421 CleanupStack::PopAndDestroy( size ); |
|
1422 Callback().SetResultsL( aResultsRef, *object, aType ); |
|
1423 } |
|
1424 Callback().SetStatusL( aStatusRef, ret ); |
|
1425 RDEBUG("CPmAdapter::FetchLeafObjectSizeL(): end" ); |
|
1426 } |
|
1427 |
|
1428 // ------------------ |
|
1429 // |
|
1430 // ----------------------------------------------------------------------------------------------- |
|
1431 const TImplementationProxy ImplementationTable[] = |
|
1432 { |
|
1433 // |
|
1434 IMPLEMENTATION_PROXY_ENTRY( KNSmlDMPMAdapterImplUid, CPmAdapter::NewL ) |
|
1435 }; |
|
1436 |
|
1437 // ------------------------------------------------------------------------------------------------ |
|
1438 // ImplementationGroupProxy( TInt& aTableCount ) |
|
1439 // ------------------------------------------------------------------------------------------------ |
|
1440 EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount ) |
|
1441 { |
|
1442 aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy ); |
|
1443 return ImplementationTable; |
|
1444 } |
|
1445 |
|
1446 // ------------------------------------------------------------------------------------------------ |
|
1447 // CPmAdapter::IntToDes8LC( const TInt aLuid ) |
|
1448 // ------------------------------------------------------------------------------------------------ |
|
1449 HBufC8* CPmAdapter::IntToDes8LC( const TInt aLuid ) |
|
1450 { |
|
1451 HBufC8* buf = HBufC8::NewLC( KMaxLengthOf32bitInteger ); //10 = max length of 32bit integer |
|
1452 TPtr8 ptrBuf = buf->Des(); |
|
1453 ptrBuf.Num( aLuid ); |
|
1454 return buf; |
|
1455 } |
|
1456 |
|
1457 // ------------------------------------------------------------------------------------- |
|
1458 // CPmAdapter::SetLastStatusL( const TDesC8 &aStatus ) |
|
1459 // ------------------------------------------------------------------------------------- |
|
1460 void CPmAdapter::SetLastStatusL( const TDesC8 &aStatus ) |
|
1461 { |
|
1462 delete iLastStatus; |
|
1463 iLastStatus = NULL ; |
|
1464 iLastStatus = aStatus.AllocL(); |
|
1465 } |
|
1466 |
|
1467 // ------------------------------------------------------------------------------------- |
|
1468 // CPmAdapter::FillNodeInfoL() |
|
1469 // Fills the node info in ddf structure |
|
1470 // ------------------------------------------------------------------------------------- |
|
1471 void CPmAdapter::FillNodeInfoL( MSmlDmDDFObject& aNode,TSmlDmAccessTypes aAccTypes, |
|
1472 MSmlDmDDFObject::TOccurence aOccurrence, |
|
1473 MSmlDmDDFObject::TScope aScope, |
|
1474 MSmlDmDDFObject::TDFFormat aFormat, |
|
1475 const TDesC8& aDescription) |
|
1476 { |
|
1477 aNode.SetAccessTypesL( aAccTypes ); |
|
1478 aNode.SetOccurenceL( aOccurrence ); |
|
1479 aNode.SetScopeL( aScope ); |
|
1480 aNode.SetDFFormatL( aFormat ); |
|
1481 if( aFormat != MSmlDmDDFObject::ENode ) |
|
1482 { |
|
1483 aNode.AddDFTypeMimeTypeL( KNSmlPMTextPlain ); |
|
1484 } |
|
1485 aNode.SetDescriptionL( aDescription ); |
|
1486 } |
|
1487 |
|
1488 // ------------------------------------------------------------------------------------- |
|
1489 // CPmAdapter::ConstructL( const TDesC8 &aArgument ) |
|
1490 // ------------------------------------------------------------------------------------- |
|
1491 void CPmCommand::ConstructL( const TDesC8 &aArgument ) |
|
1492 { |
|
1493 iArgument = aArgument.AllocL(); |
|
1494 } |
|
1495 |
|
1496 // ------------------------------------------------------------------------------------- |
|
1497 // CPmAdapter::~CPmCommand() |
|
1498 // ------------------------------------------------------------------------------------- |
|
1499 CPmCommand::~CPmCommand() |
|
1500 { |
|
1501 delete iArgument; |
|
1502 } |
|
1503 |
|
1504 // ------------------------------------------------------------------------------------- |
|
1505 // CPmAdapter::NewL( TInt aStatusRef, const TDesC8& aURI, const TDesC8 &aArgument ) |
|
1506 // ------------------------------------------------------------------------------------- |
|
1507 CPmCommand *CPmCommand::NewL( TInt aStatusRef, const TDesC8& aURI, const TDesC8 &aArgument ) |
|
1508 { |
|
1509 CPmCommand *self = new ( ELeave ) CPmCommand( aStatusRef, aURI ); |
|
1510 self->ConstructL( aArgument ); |
|
1511 return self ; |
|
1512 } |
|
1513 |
|
1514 |
|
1515 |
|
1516 |
|
1517 // End of File |