|
1 /* |
|
2 * Copyright (c) 2002-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: ddf tree implementation of DmAdPKI |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #include <utf.h> |
|
21 #include <certificateapps.h> |
|
22 |
|
23 #include "dmadddf.h" |
|
24 #include "dmadutil.h" |
|
25 #include "vpnlogger.h" |
|
26 #include "dmadcertxmldefs.h" |
|
27 #include "XwImpl.h" |
|
28 |
|
29 static const TInt KUserStore = 1; |
|
30 static const TInt KDeviceStore = 2; |
|
31 |
|
32 CDmAdDdf* CDmAdDdf::NewL(MDmAdCallBack* aDmAdCallBack, CDmAdStore* aStore) |
|
33 { |
|
34 TRACE("CDmAdDdf::NewL"); |
|
35 |
|
36 CDmAdDdf* self = NewLC(aDmAdCallBack, aStore); |
|
37 CleanupStack::Pop(self); |
|
38 return self; |
|
39 } |
|
40 |
|
41 CDmAdDdf* CDmAdDdf::NewLC(MDmAdCallBack* aDmAdCallBack, CDmAdStore* aStore) |
|
42 { |
|
43 CDmAdDdf* self = new (ELeave) CDmAdDdf(aDmAdCallBack, aStore); |
|
44 CleanupStack::PushL(self); |
|
45 return self; |
|
46 } |
|
47 |
|
48 CDmAdDdf::CDmAdDdf(MDmAdCallBack* aDmAdCallBack, CDmAdStore* aStore) : |
|
49 iCallBack(aDmAdCallBack), iStore(aStore) |
|
50 { |
|
51 TRACE("CDmAdDdf::CDmAdDdf"); |
|
52 } |
|
53 |
|
54 CDmAdDdf::~CDmAdDdf() |
|
55 { |
|
56 TRACE("CDmAdDdf::~CDmAdDdf"); |
|
57 } |
|
58 |
|
59 //=================================================================================================== |
|
60 |
|
61 void CDmAdDdf::BuildDDFVersionL(CBufBase& aDDFVersion) |
|
62 { |
|
63 TRACE("CDmAdDdf::BuildDDFVersionL"); |
|
64 aDDFVersion.InsertL(0, KDmAdDdfVersion); |
|
65 } |
|
66 |
|
67 void CDmAdDdf::BuildDDFStructureL(MSmlDmDDFObject& aDDF) |
|
68 { |
|
69 TRACE("CDmAdDdf::BuildDDFStructureL"); |
|
70 |
|
71 TSmlDmAccessTypes accessTypesExec; |
|
72 accessTypesExec.SetReplace(); // accessTypesExec.SetExec(); |
|
73 |
|
74 TSmlDmAccessTypes accessTypesGet; |
|
75 accessTypesGet.SetGet(); |
|
76 |
|
77 TSmlDmAccessTypes accessTypesAdd; |
|
78 accessTypesAdd.SetAdd(); |
|
79 |
|
80 TSmlDmAccessTypes accessTypesGetAdd; |
|
81 accessTypesGetAdd.SetGet(); |
|
82 accessTypesGetAdd.SetAdd(); |
|
83 |
|
84 TSmlDmAccessTypes accessTypesAll; |
|
85 accessTypesAll.SetGet(); |
|
86 accessTypesAll.SetAdd(); |
|
87 accessTypesAll.SetDelete(); |
|
88 accessTypesAll.SetReplace(); |
|
89 |
|
90 TSmlDmAccessTypes accessTypesNoDelete; |
|
91 accessTypesNoDelete.SetGet(); |
|
92 accessTypesNoDelete.SetAdd(); |
|
93 accessTypesNoDelete.SetReplace(); |
|
94 |
|
95 MSmlDmDDFObject* obj; |
|
96 MSmlDmDDFObject* objNokiaPki; |
|
97 MSmlDmDDFObject* objPkiGeneral; |
|
98 MSmlDmDDFObject* objCert; |
|
99 MSmlDmDDFObject* objCertX; |
|
100 MSmlDmDDFObject* objCertReq; |
|
101 MSmlDmDDFObject* objCertReqX; |
|
102 MSmlDmDDFObject* objPrivKey; |
|
103 MSmlDmDDFObject* objPrivKeyX; |
|
104 MSmlDmDDFObject* objPKCS12; |
|
105 MSmlDmDDFObject* objPKCS12X; |
|
106 |
|
107 |
|
108 //---------------------------------------------------------------- |
|
109 |
|
110 objNokiaPki = &TDmAdUtil::AddChildObjectL(aDDF, KDmAdNodeNokiaPki); |
|
111 TDmAdUtil::FillNodeInfoL(*objNokiaPki, |
|
112 accessTypesGet, |
|
113 MSmlDmDDFObject::EOne, |
|
114 MSmlDmDDFObject::EPermanent, |
|
115 MSmlDmDDFObject::ENode, |
|
116 KDmAdDescNodeNokiaPki, |
|
117 ETrue, |
|
118 KDmAdNokiaPkiRootTypeProperty); |
|
119 |
|
120 //---------------------------------------------------------------- |
|
121 |
|
122 |
|
123 obj = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdLeafLogon); |
|
124 TDmAdUtil::FillNodeInfoL(*obj, |
|
125 accessTypesExec, |
|
126 MSmlDmDDFObject::EOne, |
|
127 MSmlDmDDFObject::EDynamic, |
|
128 MSmlDmDDFObject::ENull, |
|
129 KDmAdDescLeafLogon, |
|
130 EFalse); |
|
131 |
|
132 obj = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdLeafLogoff); |
|
133 TDmAdUtil::FillNodeInfoL(*obj, |
|
134 accessTypesExec, |
|
135 MSmlDmDDFObject::EOne, |
|
136 MSmlDmDDFObject::EDynamic, |
|
137 MSmlDmDDFObject::ENull, |
|
138 KDmAdDescLeafLogoff, |
|
139 EFalse); |
|
140 |
|
141 obj = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdLeafKeyStore); |
|
142 TDmAdUtil::FillNodeInfoL(*obj, |
|
143 accessTypesExec, |
|
144 MSmlDmDDFObject::EOne, |
|
145 MSmlDmDDFObject::EDynamic, |
|
146 MSmlDmDDFObject::EInt, |
|
147 KDmAdDescLeafKeyStore, |
|
148 EFalse); |
|
149 |
|
150 obj = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdLeafCertStore); |
|
151 TDmAdUtil::FillNodeInfoL(*obj, |
|
152 accessTypesExec, |
|
153 MSmlDmDDFObject::EOne, |
|
154 MSmlDmDDFObject::EDynamic, |
|
155 MSmlDmDDFObject::EInt, |
|
156 KDmAdDescLeafCertStore, |
|
157 EFalse); |
|
158 |
|
159 objPkiGeneral = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdNodeGeneral); |
|
160 TDmAdUtil::FillNodeInfoL(*objPkiGeneral, |
|
161 accessTypesGet, |
|
162 MSmlDmDDFObject::EOne, |
|
163 MSmlDmDDFObject::EPermanent, |
|
164 MSmlDmDDFObject::ENode, |
|
165 KDmAdDescNodeGeneral, |
|
166 EFalse, |
|
167 KNullDesC8); |
|
168 |
|
169 obj = &TDmAdUtil::AddChildObjectL(*objPkiGeneral, KDmAdLeafCertApplications); |
|
170 TDmAdUtil::FillNodeInfoL(*obj, |
|
171 accessTypesGet, |
|
172 MSmlDmDDFObject::EOne, |
|
173 MSmlDmDDFObject::EDynamic, |
|
174 MSmlDmDDFObject::EXml, |
|
175 KDmAdDescLeafCertApplications, |
|
176 EFalse); |
|
177 |
|
178 //---------------------------------------------------------------- |
|
179 |
|
180 objCert = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdNodeCert); |
|
181 TDmAdUtil::FillNodeInfoL(*objCert, |
|
182 accessTypesGet, |
|
183 MSmlDmDDFObject::EOne, |
|
184 MSmlDmDDFObject::EPermanent, |
|
185 MSmlDmDDFObject::ENode, |
|
186 KDmAdDescNodeCert, |
|
187 EFalse, |
|
188 KNullDesC8); |
|
189 |
|
190 objCertX = &TDmAdUtil::AddChildObjectL(*objCert, KDmAdNodeRt); |
|
191 TDmAdUtil::FillNodeInfoL(*objCertX, |
|
192 accessTypesAll, |
|
193 MSmlDmDDFObject::EZeroOrMore, |
|
194 MSmlDmDDFObject::EDynamic, |
|
195 MSmlDmDDFObject::ENode, |
|
196 KDmAdDescNodeRt, |
|
197 EFalse, |
|
198 KNullDesC8); |
|
199 |
|
200 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafType); |
|
201 TDmAdUtil::FillNodeInfoL(*obj, |
|
202 accessTypesGetAdd, |
|
203 MSmlDmDDFObject::EOne, |
|
204 MSmlDmDDFObject::EDynamic, |
|
205 MSmlDmDDFObject::EInt, |
|
206 KDmAdDescLeafType, |
|
207 EFalse); |
|
208 |
|
209 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafFormat); |
|
210 TDmAdUtil::FillNodeInfoL(*obj, |
|
211 accessTypesGetAdd, |
|
212 MSmlDmDDFObject::EOne, |
|
213 MSmlDmDDFObject::EDynamic, |
|
214 MSmlDmDDFObject::EInt, |
|
215 KDmAdDescLeafFormat, |
|
216 EFalse); |
|
217 |
|
218 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafSerialNumber); |
|
219 TDmAdUtil::FillNodeInfoL(*obj, |
|
220 accessTypesGet, |
|
221 MSmlDmDDFObject::EOne, |
|
222 MSmlDmDDFObject::EDynamic, |
|
223 MSmlDmDDFObject::EBin, |
|
224 KDmAdDescLeafSerialNumber, |
|
225 EFalse); |
|
226 |
|
227 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafIssuerName); |
|
228 TDmAdUtil::FillNodeInfoL(*obj, |
|
229 accessTypesGet, |
|
230 MSmlDmDDFObject::EOne, |
|
231 MSmlDmDDFObject::EDynamic, |
|
232 MSmlDmDDFObject::EBin, |
|
233 KDmAdDescLeafIssuerName, |
|
234 EFalse); |
|
235 |
|
236 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafFingerprintAlg); |
|
237 TDmAdUtil::FillNodeInfoL(*obj, |
|
238 accessTypesGet, |
|
239 MSmlDmDDFObject::EOne, |
|
240 MSmlDmDDFObject::EDynamic, |
|
241 MSmlDmDDFObject::EInt, |
|
242 KDmAdDescLeafFingerprintAlg, |
|
243 EFalse); |
|
244 |
|
245 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafFingerprintValue); |
|
246 TDmAdUtil::FillNodeInfoL(*obj, |
|
247 accessTypesGet, |
|
248 MSmlDmDDFObject::EOne, |
|
249 MSmlDmDDFObject::EDynamic, |
|
250 MSmlDmDDFObject::EBin, |
|
251 KDmAdDescLeafFingerprintAlg, |
|
252 EFalse); |
|
253 |
|
254 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafValidityBegin); |
|
255 TDmAdUtil::FillNodeInfoL(*obj, |
|
256 accessTypesGet, |
|
257 MSmlDmDDFObject::EOne, |
|
258 MSmlDmDDFObject::EDynamic, |
|
259 MSmlDmDDFObject::EChr, |
|
260 KDmAdDescLeafValidityBegin, |
|
261 EFalse); |
|
262 |
|
263 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafValidityEnd); |
|
264 TDmAdUtil::FillNodeInfoL(*obj, |
|
265 accessTypesGet, |
|
266 MSmlDmDDFObject::EOne, |
|
267 MSmlDmDDFObject::EDynamic, |
|
268 MSmlDmDDFObject::EChr, |
|
269 KDmAdDescLeafValidityEnd, |
|
270 EFalse); |
|
271 |
|
272 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafSubjectName); |
|
273 TDmAdUtil::FillNodeInfoL(*obj, |
|
274 accessTypesGet, |
|
275 MSmlDmDDFObject::EOne, |
|
276 MSmlDmDDFObject::EDynamic, |
|
277 MSmlDmDDFObject::EBin, |
|
278 KDmAdDescLeafSubjectName, |
|
279 EFalse); |
|
280 |
|
281 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafSubjectAltName); |
|
282 TDmAdUtil::FillNodeInfoL(*obj, |
|
283 accessTypesGet, |
|
284 MSmlDmDDFObject::EZeroOrOne, |
|
285 MSmlDmDDFObject::EDynamic, |
|
286 MSmlDmDDFObject::EBin, |
|
287 KDmAdDescLeafSubjectAltName, |
|
288 EFalse); |
|
289 |
|
290 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafKeyURI); |
|
291 TDmAdUtil::FillNodeInfoL(*obj, |
|
292 accessTypesGet, |
|
293 MSmlDmDDFObject::EZeroOrOne, |
|
294 MSmlDmDDFObject::EDynamic, |
|
295 MSmlDmDDFObject::EChr, |
|
296 KDmAdDescLeafKeyUri, |
|
297 EFalse); |
|
298 |
|
299 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafKeyId); |
|
300 TDmAdUtil::FillNodeInfoL(*obj, |
|
301 accessTypesGet, |
|
302 MSmlDmDDFObject::EZeroOrOne, |
|
303 MSmlDmDDFObject::EDynamic, |
|
304 MSmlDmDDFObject::EBin, |
|
305 KDmAdDescLeafKeyId, |
|
306 EFalse); |
|
307 |
|
308 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafKeyUsage); |
|
309 TDmAdUtil::FillNodeInfoL(*obj, |
|
310 accessTypesGet, |
|
311 MSmlDmDDFObject::EZeroOrOne, |
|
312 MSmlDmDDFObject::EDynamic, |
|
313 MSmlDmDDFObject::EChr, |
|
314 KDmAdDescLeafKeyUsage, |
|
315 EFalse); |
|
316 |
|
317 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafDeletable); |
|
318 TDmAdUtil::FillNodeInfoL(*obj, |
|
319 accessTypesGetAdd, |
|
320 MSmlDmDDFObject::EZeroOrOne, |
|
321 MSmlDmDDFObject::EDynamic, |
|
322 MSmlDmDDFObject::EBool, |
|
323 KDmAdDescLeafDeletable, |
|
324 EFalse); |
|
325 |
|
326 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafTrusted); |
|
327 TDmAdUtil::FillNodeInfoL(*obj, |
|
328 accessTypesNoDelete, |
|
329 MSmlDmDDFObject::EZeroOrOne, |
|
330 MSmlDmDDFObject::EDynamic, |
|
331 MSmlDmDDFObject::EBool, |
|
332 KDmAdDescLeafTrusted, |
|
333 EFalse); |
|
334 |
|
335 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafApplicability); |
|
336 TDmAdUtil::FillNodeInfoL(*obj, |
|
337 accessTypesNoDelete, |
|
338 MSmlDmDDFObject::EZeroOrOne, |
|
339 MSmlDmDDFObject::EDynamic, |
|
340 MSmlDmDDFObject::EXml, |
|
341 KDmAdDescLeafApplicability, |
|
342 EFalse); |
|
343 |
|
344 obj = &TDmAdUtil::AddChildObjectL(*objCertX, KDmAdLeafContent); |
|
345 TDmAdUtil::FillNodeInfoL(*obj, |
|
346 accessTypesGetAdd, |
|
347 MSmlDmDDFObject::EOne, |
|
348 MSmlDmDDFObject::EDynamic, |
|
349 MSmlDmDDFObject::EBin, |
|
350 KDmAdDescLeafContent, |
|
351 EFalse); |
|
352 |
|
353 |
|
354 //---------------------------------------------------------------- |
|
355 |
|
356 objCertReq = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdNodeCertReq); |
|
357 TDmAdUtil::FillNodeInfoL(*objCertReq, |
|
358 accessTypesGet, |
|
359 MSmlDmDDFObject::EOne, |
|
360 MSmlDmDDFObject::EPermanent, |
|
361 MSmlDmDDFObject::ENode, |
|
362 KDmAdDescNodeCertReq, |
|
363 EFalse, |
|
364 KNullDesC8); |
|
365 |
|
366 |
|
367 objCertReqX = &TDmAdUtil::AddChildObjectL(*objCertReq, KDmAdNodeRt); |
|
368 TDmAdUtil::FillNodeInfoL(*objCertReqX, |
|
369 accessTypesAll, |
|
370 MSmlDmDDFObject::EZeroOrMore, |
|
371 MSmlDmDDFObject::EDynamic, |
|
372 MSmlDmDDFObject::ENode, |
|
373 KDmAdDescNodeRt, |
|
374 EFalse, |
|
375 KNullDesC8); |
|
376 |
|
377 obj = &TDmAdUtil::AddChildObjectL(*objCertReqX, KDmAdLeafSubjectName); |
|
378 TDmAdUtil::FillNodeInfoL(*obj, |
|
379 accessTypesAdd, |
|
380 MSmlDmDDFObject::EOne, |
|
381 MSmlDmDDFObject::EDynamic, |
|
382 MSmlDmDDFObject::EBin, |
|
383 KDmAdDescLeafSubjectName, |
|
384 EFalse); |
|
385 |
|
386 obj = &TDmAdUtil::AddChildObjectL(*objCertReqX, KDmAdLeafRfc822Name); |
|
387 TDmAdUtil::FillNodeInfoL(*obj, |
|
388 accessTypesAdd, |
|
389 MSmlDmDDFObject::EZeroOrOne, |
|
390 MSmlDmDDFObject::EDynamic, |
|
391 MSmlDmDDFObject::EBin, |
|
392 KDmAdDescLeafRfc822Name, |
|
393 EFalse); |
|
394 |
|
395 obj = &TDmAdUtil::AddChildObjectL(*objCertReqX, KDmAdLeafKeyURI); |
|
396 TDmAdUtil::FillNodeInfoL(*obj, |
|
397 accessTypesAdd, |
|
398 MSmlDmDDFObject::EOne, |
|
399 MSmlDmDDFObject::EDynamic, |
|
400 MSmlDmDDFObject::EChr, |
|
401 KDmAdDescLeafKeyUri, |
|
402 EFalse); |
|
403 |
|
404 obj = &TDmAdUtil::AddChildObjectL(*objCertReqX, KDmAdLeafKeyLength); |
|
405 TDmAdUtil::FillNodeInfoL(*obj, |
|
406 accessTypesAdd, |
|
407 MSmlDmDDFObject::EZeroOrOne, |
|
408 MSmlDmDDFObject::EDynamic, |
|
409 MSmlDmDDFObject::EInt, |
|
410 KDmAdDescLeafKeyLength, |
|
411 EFalse); |
|
412 |
|
413 obj = &TDmAdUtil::AddChildObjectL(*objCertReqX, KDmAdLeafContent); |
|
414 TDmAdUtil::FillNodeInfoL(*obj, |
|
415 accessTypesGet, |
|
416 MSmlDmDDFObject::EZeroOrOne, |
|
417 MSmlDmDDFObject::EDynamic, |
|
418 MSmlDmDDFObject::EBin, |
|
419 KDmAdDescLeafContent, |
|
420 EFalse); |
|
421 |
|
422 //---------------------------------------------------------------- |
|
423 |
|
424 objPrivKey = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdNodePrivKey); |
|
425 TDmAdUtil::FillNodeInfoL(*objPrivKey, |
|
426 accessTypesGet, |
|
427 MSmlDmDDFObject::EOne, |
|
428 MSmlDmDDFObject::EPermanent, |
|
429 MSmlDmDDFObject::ENode, |
|
430 KDmAdDescNodePrivKey, |
|
431 EFalse, |
|
432 KNullDesC8); |
|
433 |
|
434 |
|
435 objPrivKeyX = &TDmAdUtil::AddChildObjectL(*objPrivKey, KDmAdNodeRt); |
|
436 TDmAdUtil::FillNodeInfoL(*objPrivKeyX, |
|
437 accessTypesAll, |
|
438 MSmlDmDDFObject::EZeroOrMore, |
|
439 MSmlDmDDFObject::EDynamic, |
|
440 MSmlDmDDFObject::ENode, |
|
441 KDmAdDescNodeRt, |
|
442 EFalse, |
|
443 KNullDesC8); |
|
444 |
|
445 obj = &TDmAdUtil::AddChildObjectL(*objPrivKeyX, KDmAdLeafKeyType); |
|
446 TDmAdUtil::FillNodeInfoL(*obj, |
|
447 accessTypesGetAdd, |
|
448 MSmlDmDDFObject::EOne, |
|
449 MSmlDmDDFObject::EDynamic, |
|
450 MSmlDmDDFObject::EInt, |
|
451 KDmAdDescLeafKeyType, |
|
452 EFalse); |
|
453 |
|
454 obj = &TDmAdUtil::AddChildObjectL(*objPrivKeyX, KDmAdLeafKeyId); |
|
455 TDmAdUtil::FillNodeInfoL(*obj, |
|
456 accessTypesGet, |
|
457 MSmlDmDDFObject::EOne, |
|
458 MSmlDmDDFObject::EDynamic, |
|
459 MSmlDmDDFObject::EChr, |
|
460 KDmAdDescLeafKeyId, |
|
461 EFalse); |
|
462 |
|
463 obj = &TDmAdUtil::AddChildObjectL(*objPrivKeyX, KDmAdLeafKeyLength); |
|
464 TDmAdUtil::FillNodeInfoL(*obj, |
|
465 accessTypesGetAdd, |
|
466 MSmlDmDDFObject::EOne, |
|
467 MSmlDmDDFObject::EDynamic, |
|
468 MSmlDmDDFObject::EInt, |
|
469 KDmAdDescLeafKeyLength, |
|
470 EFalse); |
|
471 |
|
472 obj = &TDmAdUtil::AddChildObjectL(*objPrivKeyX, KDmAdLeafContent); |
|
473 TDmAdUtil::FillNodeInfoL(*obj, |
|
474 accessTypesAdd, |
|
475 MSmlDmDDFObject::EZeroOrOne, |
|
476 MSmlDmDDFObject::EDynamic, |
|
477 MSmlDmDDFObject::EBin, |
|
478 KDmAdDescLeafContent, |
|
479 EFalse); |
|
480 |
|
481 //------- PKCS#12 Node definitions ----------------- |
|
482 |
|
483 DEBUG_LOG(_L("Adding PKCS#12 definitions")); |
|
484 |
|
485 // PKCS12 root node |
|
486 objPKCS12 = &TDmAdUtil::AddChildObjectL(*objNokiaPki, KDmAdNodePKCS12); |
|
487 TDmAdUtil::FillNodeInfoL(*objPKCS12, |
|
488 accessTypesGet, |
|
489 MSmlDmDDFObject::EOne, |
|
490 MSmlDmDDFObject::EPermanent, |
|
491 MSmlDmDDFObject::ENode, |
|
492 KDmAdDescNodePKCS12, |
|
493 EFalse, |
|
494 KNullDesC8); |
|
495 |
|
496 // PKCS#12/X node |
|
497 objPKCS12X = &TDmAdUtil::AddChildObjectL(*objPKCS12, KDmAdNodeRt); |
|
498 TDmAdUtil::FillNodeInfoL(*objPKCS12X, |
|
499 accessTypesAdd, |
|
500 MSmlDmDDFObject::EZeroOrMore, |
|
501 MSmlDmDDFObject::EDynamic, |
|
502 MSmlDmDDFObject::ENode, |
|
503 KDmAdDescNodeRt, |
|
504 EFalse, |
|
505 KNullDesC8); |
|
506 |
|
507 // PKCS#12/X/Password leaf node |
|
508 obj = &TDmAdUtil::AddChildObjectL(*objPKCS12X, KDmAdLeafPKCS12Password); |
|
509 TDmAdUtil::FillNodeInfoL(*obj, |
|
510 accessTypesAdd, |
|
511 MSmlDmDDFObject::EZeroOrOne, |
|
512 MSmlDmDDFObject::EDynamic, |
|
513 MSmlDmDDFObject::EChr, |
|
514 KDmAdDescLeafPKCS12Password, |
|
515 EFalse); |
|
516 |
|
517 // PKCS#12/X/Deletable leaf node |
|
518 obj = &TDmAdUtil::AddChildObjectL(*objPKCS12X, KDmAdLeafDeletable); |
|
519 TDmAdUtil::FillNodeInfoL(*obj, |
|
520 accessTypesAdd, |
|
521 MSmlDmDDFObject::EZeroOrOne, |
|
522 MSmlDmDDFObject::EDynamic, |
|
523 MSmlDmDDFObject::EBool, |
|
524 KDmAdDescLeafDeletable, |
|
525 EFalse); |
|
526 |
|
527 // PKCS#12/X/Applicability leaf node |
|
528 obj = &TDmAdUtil::AddChildObjectL(*objPKCS12X, KDmAdLeafApplicability); |
|
529 TDmAdUtil::FillNodeInfoL(*obj, |
|
530 accessTypesAdd, |
|
531 MSmlDmDDFObject::EZeroOrOne, |
|
532 MSmlDmDDFObject::EDynamic, |
|
533 MSmlDmDDFObject::EXml, |
|
534 KDmAdDescLeafApplicability, |
|
535 EFalse); |
|
536 |
|
537 // PKCS#12/X/Content leaf node |
|
538 obj = &TDmAdUtil::AddChildObjectL(*objPKCS12X, KDmAdLeafContent); |
|
539 TDmAdUtil::FillNodeInfoL(*obj, |
|
540 accessTypesAdd, |
|
541 MSmlDmDDFObject::EOne, |
|
542 MSmlDmDDFObject::EDynamic, |
|
543 MSmlDmDDFObject::EBin, |
|
544 KDmAdDescLeafContent, |
|
545 EFalse); |
|
546 |
|
547 DEBUG_LOG(_L("Adding PKCS#12 definitions - COMPLETE")); |
|
548 |
|
549 } |
|
550 |
|
551 //--------------------------------------------------------------------------------------- |
|
552 |
|
553 void CDmAdDdf::NotRtNodeAddNodeObjectL(const TDesC8& /*aUri*/, const TDesC8& /*aParentLuid*/, TInt aStatusRef) |
|
554 { |
|
555 TRACE("CDmAdDdf::NotRtNodeAddNodeObjectL"); |
|
556 |
|
557 iCallBack->SetStatusL(aStatusRef, KErrNone); |
|
558 } |
|
559 |
|
560 void CDmAdDdf::NotRtNodeUpdateLeafObjectL(const TDesC8& aUri, const TDesC8& /*aLuid*/, const TDesC8& aObject, const TDesC8& /*aType*/, TInt aStatusRef) |
|
561 { |
|
562 TRACE("CDmAdDdf::NotRtNodeUpdateLeafObjectL"); |
|
563 |
|
564 TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri); |
|
565 if (lastSeg.Compare(KDmAdLeafLogon) == 0) |
|
566 { |
|
567 iStore->PkiLogonL(); |
|
568 } |
|
569 else if (lastSeg.Compare(KDmAdLeafLogoff) == 0) |
|
570 { |
|
571 iStore->PkiLogoffL(); |
|
572 } |
|
573 else if (lastSeg.Compare(KDmAdLeafKeyStore) == 0) |
|
574 { |
|
575 TInt storeFromDm = TDmAdUtil::DesToInt(aObject); |
|
576 TPkiServiceStoreType pkiStoreType = EPkiStoreTypeAny; |
|
577 switch(storeFromDm) |
|
578 { |
|
579 case KUserStore: |
|
580 pkiStoreType = EPkiStoreTypeUser; |
|
581 break; |
|
582 case KDeviceStore: |
|
583 pkiStoreType = EPkiStoreTypeDevice; |
|
584 break; |
|
585 default: |
|
586 User::Leave(KPKIErrNotSupported); |
|
587 break; |
|
588 } |
|
589 iStore->SetStoreTypeL(STORE_KEYSTORE, pkiStoreType); |
|
590 } |
|
591 else if (lastSeg.Compare(KDmAdLeafCertStore) == 0) |
|
592 { |
|
593 TInt storeFromDm = TDmAdUtil::DesToInt(aObject); |
|
594 TPkiServiceStoreType pkiStoreType = EPkiStoreTypeAny; |
|
595 switch(storeFromDm) |
|
596 { |
|
597 case KUserStore: |
|
598 pkiStoreType = EPkiStoreTypeUser; |
|
599 break; |
|
600 case KDeviceStore: |
|
601 pkiStoreType = EPkiStoreTypeDevice; |
|
602 break; |
|
603 default: |
|
604 User::Leave(KPKIErrNotSupported); |
|
605 break; |
|
606 } |
|
607 |
|
608 iStore->SetStoreTypeL(STORE_CERTSTORE, pkiStoreType); |
|
609 } |
|
610 |
|
611 iCallBack->SetStatusL(aStatusRef, KErrNone); |
|
612 } |
|
613 |
|
614 TInt CDmAdDdf::NotRtNodeFetchLeafObjectLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, const TDesC8& /*aType*/, CBufBase*& aObject) |
|
615 { |
|
616 TInt status = KErrNotFound; |
|
617 CBufBase* object = CBufFlat::NewL(32); |
|
618 CleanupStack::PushL(object); |
|
619 |
|
620 TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri); |
|
621 if (lastSeg.Compare(KDmAdLeafCertApplications) == 0) |
|
622 { |
|
623 |
|
624 CCertificateAppInfoManager* appsMan = CCertificateAppInfoManager::NewLC(); |
|
625 |
|
626 const RArray<TCertificateAppInfo>& apps = appsMan->Applications(); |
|
627 TInt count = apps.Count(); |
|
628 CXmlWriter* writer = CXmlWriter::NewL(); |
|
629 CleanupStack::PushL(static_cast<CBase*>(writer)); |
|
630 |
|
631 writer->AddStartTagL(KXmlElemCertApps); |
|
632 for (TInt i=0; i<count; ++i) |
|
633 { |
|
634 const TUid& id = apps[i].Id(); |
|
635 const TName& name = apps[i].Name(); |
|
636 |
|
637 HBufC8* idInt = TDmAdUtil::IntToDes8LC((TInt)id.iUid); |
|
638 HBufC8* name8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(name); |
|
639 CleanupStack::PushL(name8); |
|
640 |
|
641 writer->OpenStartTagL(KXmlElemApp); |
|
642 writer->AddAttributeL(KXmlAttrId, *idInt); |
|
643 writer->AddAttributeL(KXmlAttrName, *name8); |
|
644 writer->CloseStartTagL(ETrue); |
|
645 CleanupStack::PopAndDestroy(2); //name8, idInt |
|
646 } |
|
647 writer->AddEndTagL(KXmlElemCertApps); |
|
648 TPtrC8 docDataPtr(writer->DocPart(0, writer->Length()-1)); |
|
649 object->InsertL(object->Size(), docDataPtr); |
|
650 |
|
651 DEBUG_LOG(_L("popping writer")); |
|
652 CleanupStack::PopAndDestroy(static_cast<CBase*>(writer)); |
|
653 DEBUG_LOG(_L("writer popped")); |
|
654 |
|
655 CleanupStack::PopAndDestroy(appsMan); |
|
656 status = KErrNone; |
|
657 } |
|
658 aObject = object; |
|
659 return status; |
|
660 } |
|
661 |
|
662 void CDmAdDdf::NotRtNodeDeleteObjectL(const TDesC8& /*aUri*/, const TDesC8& /*aLuid*/, TInt aStatusRef) |
|
663 { |
|
664 TRACE("CDmAdDdf::NotRtNodeDeleteObjectL"); |
|
665 |
|
666 iCallBack->SetStatusL(aStatusRef, KErrNone); |
|
667 } |
|
668 |
|
669 //--------------------------------------------------------------------------------------- |
|
670 |
|
671 TBool CDmAdDdf::IsNodeRtNodeL(const TDesC8& aUri) |
|
672 { |
|
673 TRACE("CDmAdDdf::IsNodeRtNodeL"); |
|
674 |
|
675 TBool ret = EFalse; |
|
676 TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri); |
|
677 if (lastSeg.Compare(KDmAdNodeNokiaPki) == 0 || |
|
678 lastSeg.Compare(KDmAdNodeGeneral) == 0 || |
|
679 lastSeg.Compare(KDmAdNodeCert) == 0 || |
|
680 lastSeg.Compare(KDmAdNodeCertReq) == 0 || |
|
681 lastSeg.Compare(KDmAdNodePrivKey) == 0 || |
|
682 lastSeg.Compare(KDmAdNodePKCS12) == 0) // Added |
|
683 { |
|
684 if(lastSeg.Compare(KDmAdNodePKCS12) == 0) // Added |
|
685 { |
|
686 DEBUG_LOG(_L("LastSeg == KDmAdNodePKCS12, ret = FALSE")); |
|
687 } |
|
688 ret = EFalse; |
|
689 } |
|
690 else |
|
691 { |
|
692 if (TDmAdUtil::NumOfURISegs(aUri) < 2) |
|
693 { |
|
694 DEBUG_LOG(_L("Number of URI segments is < 2")); |
|
695 User::Leave(KErrNotFound); |
|
696 } |
|
697 TPtrC8 prevSeg = TDmAdUtil::LastUriSeg(TDmAdUtil::RemoveLastUriSeg(aUri)); |
|
698 if (prevSeg.Compare(KDmAdNodeCert) == 0 || |
|
699 prevSeg.Compare(KDmAdNodeCertReq) == 0 || |
|
700 prevSeg.Compare(KDmAdNodePrivKey) == 0 || |
|
701 prevSeg.Compare(KDmAdNodePKCS12) == 0) // Added |
|
702 { |
|
703 if(prevSeg.Compare(KDmAdNodePKCS12) == 0) // Added |
|
704 { |
|
705 DEBUG_LOG(_L("prevSeg == KDmAdNodePKCS12, ret = TRUE")); |
|
706 } |
|
707 ret = ETrue; |
|
708 } |
|
709 else |
|
710 { |
|
711 DEBUG_LOG(_L("URI segment not found")); |
|
712 User::Leave(KErrNotFound); |
|
713 } |
|
714 } |
|
715 return ret; |
|
716 } |
|
717 |
|
718 TBool CDmAdDdf::IsLeafUnderRtNodeL(const TDesC8& aUri) |
|
719 { |
|
720 TRACE("CDmAdDdf::IsLeafUnderRtNodeL"); |
|
721 |
|
722 TBool ret = EFalse; |
|
723 TPtrC8 nodeUri(TDmAdUtil::RemoveLastUriSeg(aUri)); |
|
724 ret = IsNodeRtNodeL(nodeUri); |
|
725 return ret; |
|
726 } |
|
727 |
|
728 |
|
729 TPtrC8 CDmAdDdf::RtNodeUriForLeafL(const TDesC8& aLeafUri) |
|
730 { |
|
731 TRACE("CDmAdDdf::RtNodeUriForLeafL"); |
|
732 |
|
733 TPtrC8 ret; |
|
734 TPtrC8 nodeUri(TDmAdUtil::RemoveLastUriSeg(aLeafUri)); |
|
735 TPtrC8 prevNodeUri(TDmAdUtil::RemoveLastUriSeg(nodeUri)); |
|
736 TPtrC8 prevNodeUriSeg(TDmAdUtil::LastUriSeg(prevNodeUri)); |
|
737 |
|
738 if (prevNodeUriSeg.Compare(KDmAdNodeCert) == 0 || |
|
739 prevNodeUriSeg.Compare(KDmAdNodeCertReq) == 0 || |
|
740 prevNodeUriSeg.Compare(KDmAdNodePrivKey) == 0 || |
|
741 prevNodeUriSeg.Compare(KDmAdNodePKCS12) == 0) // Added |
|
742 { |
|
743 if (prevNodeUriSeg.Compare(KDmAdNodePKCS12) == 0) |
|
744 { |
|
745 DEBUG_LOG(_L("prevNodeUriSeg == KDmAdNodePKCS12")); |
|
746 } |
|
747 ret.Set(nodeUri); |
|
748 } |
|
749 else |
|
750 { |
|
751 DEBUG_LOG(_L("Unknown URI")); |
|
752 User::Leave(KErrNotFound); |
|
753 } |
|
754 return ret; |
|
755 } |
|
756 |
|
757 TBool CDmAdDdf::IsTopLevelRtNode(const TDesC8& /*aUri*/) |
|
758 { |
|
759 TRACE("CDmAdDdf::IsTopLevelRtNode"); |
|
760 return ETrue; |
|
761 } |
|
762 |
|
763 HBufC8* CDmAdDdf::ParentRtNodeUriForRtNodeLC(const TDesC8& /*aUri*/) |
|
764 { |
|
765 DEBUG_LOG(_L("Method CDmAdDdf::ParentRtNodeUriForRtNodeLC not implemented")); |
|
766 User::Leave(KErrGeneral); |
|
767 return 0; |
|
768 } |
|
769 |
|
770 //--------------------------------------------------------------------------------------- |
|
771 |
|
772 void CDmAdDdf::BuildChildUriListLC(const TDesC8& aUri, const TDesC8& aParentLuid, const CArrayFix<TSmlDmMappingInfo>& aPreviousUriSegmentList, CBufBase*& aCurrentList) |
|
773 { |
|
774 CBufBase *currentList = CBufFlat::NewL(128); |
|
775 CleanupStack::PushL(currentList); |
|
776 |
|
777 TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri); |
|
778 if (lastSeg.Compare(KDmAdNodeNokiaPki) == 0) |
|
779 { |
|
780 currentList->InsertL(0, KDmAdListOfNokiaPkiChildren); |
|
781 } |
|
782 else if (lastSeg.Compare(KDmAdNodeGeneral) == 0) |
|
783 { |
|
784 currentList->InsertL(0, KDmAdListOfPkiGeneralChildren); |
|
785 } |
|
786 else if (lastSeg.Compare(KDmAdNodeCert) == 0 || |
|
787 lastSeg.Compare(KDmAdNodeCertReq) == 0 || |
|
788 lastSeg.Compare(KDmAdNodePrivKey) == 0 || |
|
789 lastSeg.Compare(KDmAdNodePKCS12) == 0) // Added |
|
790 { |
|
791 if (lastSeg.Compare(KDmAdNodePKCS12) == 0) |
|
792 { |
|
793 // Special treatment for PKCS12 nodes |
|
794 DEBUG_LOG(_L("lastSeg == KDmAdNodePKCS12")); |
|
795 TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri); |
|
796 TInt slashcount = 0; |
|
797 TInt urisegcount = aPreviousUriSegmentList.Count(); |
|
798 |
|
799 DEBUG_LOG1(_L(" URI segment count: %d:"), urisegcount); |
|
800 |
|
801 for (TInt i=0; i < urisegcount; i++) |
|
802 { |
|
803 const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i); |
|
804 |
|
805 DEBUG_LOG1(_L(" SetResult URI seg entry %d:"), i); |
|
806 DEBUG_LOG1(_L8(" Uri seg: '%S'"), &(mappingInfo.iURISeg)); |
|
807 DEBUG_LOG_HEX(mappingInfo.iURISegLUID); |
|
808 |
|
809 // Add slash to separate between URIs (no slash after the last one or |
|
810 // before the first one) |
|
811 if ((slashcount > 0) && (slashcount <= urisegcount)) |
|
812 { |
|
813 currentList->InsertL(currentList->Size(), KDmAdSeparator); |
|
814 } |
|
815 |
|
816 currentList->InsertL(currentList->Size(), mappingInfo.iURISeg); |
|
817 slashcount++; |
|
818 } |
|
819 } |
|
820 else |
|
821 { |
|
822 TDmAdUtil::BuildRtNodeChildUriListL(iCallBack, iStore, aUri, aParentLuid, aPreviousUriSegmentList, *currentList); |
|
823 } |
|
824 |
|
825 #if 0 |
|
826 if (currentList->Size() > 0) |
|
827 { |
|
828 currentList->InsertL(currentList->Size(), KDmAdAppendChildSlashExt); |
|
829 } |
|
830 else |
|
831 { |
|
832 currentList->InsertL(currentList->Size(), KDmAdAppendChildExt); |
|
833 } |
|
834 #endif |
|
835 } |
|
836 else |
|
837 { |
|
838 TPtrC8 prevSeg = TDmAdUtil::LastUriSeg(TDmAdUtil::RemoveLastUriSeg(aUri)); |
|
839 if (prevSeg.Compare(KDmAdNodeCert) == 0 || |
|
840 prevSeg.Compare(KDmAdNodeCertReq) == 0 || |
|
841 prevSeg.Compare(KDmAdNodePrivKey) == 0 || |
|
842 prevSeg.Compare(KDmAdNodePKCS12) == 0) // Added |
|
843 { |
|
844 if (prevSeg.Compare(KDmAdNodePKCS12) == 0) |
|
845 { |
|
846 DEBUG_LOG(_L("prevSeg == KDmAdNodePKCS12")); |
|
847 } |
|
848 if (!iStore->FindRtNodeL(aParentLuid, aUri)) |
|
849 { |
|
850 DEBUG_LOG(_L("Node not found")); |
|
851 User::Leave(KErrNotFound); |
|
852 } |
|
853 |
|
854 if (prevSeg.Compare(KDmAdNodeCert) == 0) |
|
855 { |
|
856 currentList->InsertL(0, KDmAdListOfCertXChildren); |
|
857 } |
|
858 else if (prevSeg.Compare(KDmAdNodeCertReq) == 0) |
|
859 { |
|
860 currentList->InsertL(0, KDmAdListOfCertReqXChildren); |
|
861 } |
|
862 else if (prevSeg.Compare(KDmAdNodePrivKey) == 0) |
|
863 { |
|
864 currentList->InsertL(0, KDmAdListOfPrivKeyXChildren); |
|
865 } |
|
866 else if (prevSeg.Compare(KDmAdNodePKCS12) == 0) |
|
867 { |
|
868 DEBUG_LOG(_L("inserting KDmAdListOfPKCS12XChildren to currentList")); |
|
869 |
|
870 // Added handler for pkcs#12 |
|
871 currentList->InsertL(0, KDmAdListOfPKCS12XChildren); |
|
872 } |
|
873 } |
|
874 else |
|
875 { |
|
876 DEBUG_LOG(_L("Unknown URI")); |
|
877 User::Leave(KErrNotFound); |
|
878 } |
|
879 } |
|
880 |
|
881 aCurrentList = currentList; |
|
882 } |