|
1 /* |
|
2 * Copyright (c) 2006 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: Implementation of DevCertKeyDataManager |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #include "DevCertKeyDataManager.h" |
|
21 #include "DevTokenDataTypes.h" |
|
22 #include "DevTokenCliServ.h" |
|
23 #include "DevTokenUtil.h" |
|
24 |
|
25 _LIT(KDevCertKeyStoreFilename,"DevCertKeys.dat"); |
|
26 |
|
27 |
|
28 // ======== MEMBER FUNCTIONS ======== |
|
29 |
|
30 // --------------------------------------------------------------------------- |
|
31 // CDevCertKeyDataManager::NewL() |
|
32 // Key store data manager - maintains array of objects representing keys |
|
33 // --------------------------------------------------------------------------- |
|
34 // |
|
35 CDevCertKeyDataManager* CDevCertKeyDataManager::NewL() |
|
36 { |
|
37 CDevCertKeyDataManager* self = new (ELeave) CDevCertKeyDataManager(); |
|
38 CleanupStack::PushL(self); |
|
39 self->ConstructL(); |
|
40 CleanupStack::Pop(self); |
|
41 return self; |
|
42 } |
|
43 |
|
44 |
|
45 // --------------------------------------------------------------------------- |
|
46 // CDevCertKeyDataManager::~CDevCertKeyDataManager() |
|
47 // --------------------------------------------------------------------------- |
|
48 // |
|
49 CDevCertKeyDataManager::~CDevCertKeyDataManager() |
|
50 { |
|
51 if (iFileStore) |
|
52 { |
|
53 CompactStore(); |
|
54 delete iFileStore; |
|
55 } |
|
56 |
|
57 iFile.Close(); // May already have been closed by store |
|
58 iFs.Close(); |
|
59 |
|
60 iKeys.ResetAndDestroy(); |
|
61 iKeys.Close(); |
|
62 } |
|
63 |
|
64 |
|
65 // --------------------------------------------------------------------------- |
|
66 // CDevCertKeyDataManager::CDevCertKeyDataManager() |
|
67 // --------------------------------------------------------------------------- |
|
68 // |
|
69 CDevCertKeyDataManager::CDevCertKeyDataManager() : |
|
70 iRootStreamId(KNullStreamId), |
|
71 iInfoStreamId(KNullStreamId) |
|
72 { |
|
73 } |
|
74 |
|
75 |
|
76 // --------------------------------------------------------------------------- |
|
77 // CDevCertKeyDataManager::ConstructL() |
|
78 // --------------------------------------------------------------------------- |
|
79 // |
|
80 void CDevCertKeyDataManager::ConstructL() |
|
81 { |
|
82 User::LeaveIfError(iFs.Connect()); |
|
83 OpenStoreL(); |
|
84 |
|
85 RStoreReadStream lookupStream; |
|
86 lookupStream.OpenLC(*iFileStore, iInfoStreamId); |
|
87 |
|
88 TInt count = lookupStream.ReadInt32L(); |
|
89 for (TInt index = 0; index < count; index++) |
|
90 { |
|
91 const CDevCertKeyData* keyData = CDevCertKeyData::NewL(lookupStream); |
|
92 |
|
93 if (keyData->Handle() > iKeyIdentifier) |
|
94 iKeyIdentifier = keyData->Handle(); |
|
95 |
|
96 iKeys.Append(keyData); |
|
97 } |
|
98 |
|
99 CleanupStack::PopAndDestroy(&lookupStream); |
|
100 } |
|
101 |
|
102 |
|
103 // --------------------------------------------------------------------------- |
|
104 // CDevCertKeyDataManager::OpenStoreL() |
|
105 // --------------------------------------------------------------------------- |
|
106 // |
|
107 void CDevCertKeyDataManager::OpenStoreL() |
|
108 { |
|
109 // Tries to locate a key store file on the default drive and then from ROM |
|
110 // If it cannot find one, tries to create a file with permanent file store |
|
111 // inside it In all cases, should initialise iFileStore unless it cannot |
|
112 // create the file/store/streams |
|
113 |
|
114 __ASSERT_DEBUG(!iFileStore, PanicServer(EPanicStoreInitialised)); |
|
115 |
|
116 TFileName fullPath; |
|
117 FileUtils::MakePrivateFilenameL(iFs, KDevCertKeyStoreFilename, fullPath); |
|
118 |
|
119 FileUtils::EnsurePathL(iFs, fullPath); |
|
120 TRAPD(result, OpenStoreInFileL(fullPath)); |
|
121 |
|
122 if (result == KErrInUse) |
|
123 { |
|
124 // Cannot access the file now. Abort server startup rather than wiping the keystore. |
|
125 User::Leave(result); |
|
126 } |
|
127 |
|
128 if (result != KErrNone) |
|
129 { |
|
130 // Not yet opened a valid store, either no file to be found, or no valid |
|
131 // store in it. Copy the original one stored in the ROM. |
|
132 delete iFileStore; |
|
133 iFileStore = NULL; |
|
134 |
|
135 TFileName romPath; |
|
136 FileUtils::MakePrivateROMFilenameL(iFs, KDevCertKeyStoreFilename, romPath); |
|
137 |
|
138 if (result != KErrNotFound) |
|
139 { |
|
140 // Wipe the keystore if we can't open it (it's corrupt anyway) |
|
141 User::LeaveIfError(iFs.Delete(fullPath)); |
|
142 } |
|
143 |
|
144 // Copy data from rom and open it |
|
145 TRAPD(err, |
|
146 FileUtils::CopyL(iFs, romPath, fullPath); |
|
147 OpenStoreInFileL(fullPath) |
|
148 ); |
|
149 |
|
150 if (KErrNone != err) |
|
151 { |
|
152 // We tried to copy the keystore from ROM. For some reason this |
|
153 // failed and we still cannot open the file. Create a new one from |
|
154 // scratch. |
|
155 CreateStoreInFileL(fullPath); |
|
156 } |
|
157 } |
|
158 |
|
159 __ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised)); |
|
160 __ASSERT_DEBUG((KNullStreamId!=iRootStreamId), PanicServer(EPanicRootStreamNotReady)); |
|
161 __ASSERT_DEBUG((KNullStreamId!=iInfoStreamId), PanicServer(EPanicManagerStreamNotReady)); |
|
162 } |
|
163 |
|
164 |
|
165 // --------------------------------------------------------------------------- |
|
166 // CDevCertKeyDataManager::CreateStoreInFileL() |
|
167 // --------------------------------------------------------------------------- |
|
168 // |
|
169 void CDevCertKeyDataManager::CreateStoreInFileL(const TDesC& aFile) |
|
170 { |
|
171 TInt r = iFs.MkDirAll(aFile); |
|
172 if ( (r!=KErrNone) && (r!=KErrAlreadyExists) ) |
|
173 User::Leave(r); |
|
174 |
|
175 iFileStore = CPermanentFileStore::ReplaceL(iFs, aFile, EFileRead | EFileWrite | EFileShareExclusive); |
|
176 iFileStore->SetTypeL(KPermanentFileStoreLayoutUid); |
|
177 |
|
178 TCleanupItem cleanupStore(RevertStore, iFileStore); |
|
179 CleanupStack::PushL(cleanupStore); |
|
180 |
|
181 // Create info stream - Currently no passphrase created, and no keys |
|
182 RStoreWriteStream managerStream; |
|
183 iInfoStreamId = managerStream.CreateLC(*iFileStore); |
|
184 managerStream.WriteUint32L(0); // Write key count of zero |
|
185 managerStream.CommitL(); |
|
186 CleanupStack::PopAndDestroy(&managerStream); |
|
187 |
|
188 // Create root stream - just contains id of info stream |
|
189 RStoreWriteStream rootStream; |
|
190 iRootStreamId = rootStream.CreateLC(*iFileStore); |
|
191 iFileStore->SetRootL(iRootStreamId); |
|
192 rootStream.WriteUint32L(iInfoStreamId.Value()); |
|
193 rootStream.CommitL(); |
|
194 CleanupStack::PopAndDestroy(&rootStream); |
|
195 |
|
196 WriteKeysToStoreL(); |
|
197 |
|
198 iFileStore->CommitL(); |
|
199 CleanupStack::Pop(); // cleanupStore |
|
200 } |
|
201 |
|
202 |
|
203 // --------------------------------------------------------------------------- |
|
204 // CDevCertKeyDataManager::OpenStoreInFileL() |
|
205 // --------------------------------------------------------------------------- |
|
206 // |
|
207 void CDevCertKeyDataManager::OpenStoreInFileL(const TDesC& aFile) |
|
208 { |
|
209 // Make sure the file isn't write protected |
|
210 User::LeaveIfError(iFs.SetAtt(aFile, 0, KEntryAttReadOnly)); |
|
211 |
|
212 User::LeaveIfError(iFile.Open(iFs, aFile, EFileRead | EFileWrite | EFileShareExclusive)); |
|
213 |
|
214 iFileStore = CPermanentFileStore::FromL(iFile); |
|
215 |
|
216 // Get the salt, root and manager TStreamIds |
|
217 iRootStreamId = iFileStore->Root(); |
|
218 if (iRootStreamId == KNullStreamId) |
|
219 { |
|
220 User::Leave(KErrCorrupt); |
|
221 } |
|
222 |
|
223 RStoreReadStream rootStream; |
|
224 rootStream.OpenLC(*iFileStore, iRootStreamId); |
|
225 iInfoStreamId = (TStreamId)(rootStream.ReadUint32L()); |
|
226 CleanupStack::PopAndDestroy(&rootStream); |
|
227 } |
|
228 |
|
229 |
|
230 // Methods dealing with atomic updates to key data file |
|
231 |
|
232 // --------------------------------------------------------------------------- |
|
233 // CDevCertKeyDataManager::RevertStore() |
|
234 // This is a cleanup item that reverts the store |
|
235 // --------------------------------------------------------------------------- |
|
236 // |
|
237 void CDevCertKeyDataManager::RevertStore(TAny* aStore) |
|
238 { |
|
239 CPermanentFileStore* store = reinterpret_cast<CPermanentFileStore*>(aStore); |
|
240 TRAP_IGNORE(store->RevertL()); |
|
241 // We're ignoring the leave code from this becuase there's no way we can |
|
242 // handle this sensibly. This shouldn't be a problem in practice - this |
|
243 // will leave if for example the file store is on removable which is |
|
244 // unexpectedly remove, and this is never the case for us. |
|
245 } |
|
246 |
|
247 |
|
248 // --------------------------------------------------------------------------- |
|
249 // CDevCertKeyDataManager::RevertStore() |
|
250 // Rewrites the info stream (ie the array of key data info) to the store |
|
251 // --------------------------------------------------------------------------- |
|
252 // |
|
253 void CDevCertKeyDataManager::WriteKeysToStoreL() |
|
254 { |
|
255 RStoreWriteStream lookupStream; |
|
256 lookupStream.ReplaceLC(*iFileStore, iInfoStreamId); |
|
257 |
|
258 TInt keyCount = iKeys.Count(); |
|
259 lookupStream.WriteInt32L(keyCount); |
|
260 |
|
261 for (TInt index = 0; index < keyCount; index++) |
|
262 { |
|
263 const CDevCertKeyData* key = iKeys[index]; |
|
264 key->ExternalizeL(lookupStream); |
|
265 } |
|
266 |
|
267 lookupStream.CommitL(); |
|
268 CleanupStack::PopAndDestroy(&lookupStream); |
|
269 } |
|
270 |
|
271 |
|
272 // --------------------------------------------------------------------------- |
|
273 // CDevCertKeyDataManager::AddL() |
|
274 // Add a key to the store. Assumes that the key data streams (info, public key |
|
275 // and private key) have already been written. |
|
276 // --------------------------------------------------------------------------- |
|
277 // |
|
278 void CDevCertKeyDataManager::AddL(const CDevCertKeyData* aKeyData) |
|
279 { |
|
280 ASSERT(aKeyData); |
|
281 |
|
282 // Add the key to to the array, rewrite the infostream and |
|
283 // ONLY THEN commit the store |
|
284 User::LeaveIfError(iKeys.Append(aKeyData)); |
|
285 |
|
286 TRAPD(err, WriteKeysToStoreL()); |
|
287 |
|
288 // Release ownership of key data and reset default passphrase id if store |
|
289 // can't be written |
|
290 TCleanupItem cleanupStore(RevertStore, iFileStore); |
|
291 CleanupStack::PushL(cleanupStore); |
|
292 |
|
293 if (err != KErrNone) |
|
294 { |
|
295 iKeys.Remove(iKeys.Count() - 1); |
|
296 User::Leave(err); |
|
297 } |
|
298 |
|
299 iFileStore->CommitL(); |
|
300 |
|
301 CleanupStack::Pop(); // cleanupStore |
|
302 } |
|
303 |
|
304 |
|
305 // --------------------------------------------------------------------------- |
|
306 // CDevCertKeyDataManager::RemoveL() |
|
307 // "Transaction safe" key removal - only removes the key in memory and file if |
|
308 // all operations are successful. |
|
309 // --------------------------------------------------------------------------- |
|
310 // |
|
311 void CDevCertKeyDataManager::RemoveL(TInt aObjectId) |
|
312 { |
|
313 TInt index; |
|
314 const CDevCertKeyData* key = NULL; |
|
315 for (index = 0 ; index < iKeys.Count() ; ++index) |
|
316 { |
|
317 if (iKeys[index]->Handle() == aObjectId) |
|
318 { |
|
319 key = iKeys[index]; |
|
320 break; |
|
321 } |
|
322 } |
|
323 |
|
324 if (!key) |
|
325 { |
|
326 User::Leave(KErrNotFound); |
|
327 } |
|
328 |
|
329 TCleanupItem cleanupStore(RevertStore, iFileStore); |
|
330 CleanupStack::PushL(cleanupStore); |
|
331 |
|
332 iFileStore->DeleteL(key->PrivateDataStreamId()); |
|
333 iFileStore->DeleteL(key->PublicDataStreamId()); |
|
334 iFileStore->DeleteL(key->InfoDataStreamId()); |
|
335 |
|
336 // Remove the key |
|
337 iKeys.Remove(index); |
|
338 |
|
339 TRAPD(res, WriteKeysToStoreL()); |
|
340 if (res != KErrNone) |
|
341 { |
|
342 User::LeaveIfError(iKeys.Append(key)); // Put it back, shouldn't leave |
|
343 User::Leave(res); |
|
344 } |
|
345 else |
|
346 { |
|
347 delete key; // Cannot leave from the point it's removed to here, so no cleanup stack! |
|
348 } |
|
349 iFileStore->CommitL(); |
|
350 |
|
351 CleanupStack::Pop(); // cleanupStore |
|
352 CompactStore(); |
|
353 } |
|
354 |
|
355 |
|
356 // --------------------------------------------------------------------------- |
|
357 // CDevCertKeyDataManager::IsKeyAlreadyInStore(). |
|
358 // --------------------------------------------------------------------------- |
|
359 // |
|
360 TBool CDevCertKeyDataManager::IsKeyAlreadyInStore(const TDesC& aKeyLabel) const |
|
361 {// Check each key in the store to determine if aKeyLabel already exists |
|
362 TInt keyCount = iKeys.Count(); |
|
363 TBool isInStore = EFalse; |
|
364 for (TInt index = 0; index < keyCount; index++) |
|
365 { |
|
366 const TDesC& keyLabel = iKeys[index]->Label(); |
|
367 if (keyLabel.Compare(aKeyLabel)==0) |
|
368 { |
|
369 isInStore = ETrue; |
|
370 break; |
|
371 } |
|
372 } |
|
373 |
|
374 return (isInStore); |
|
375 } |
|
376 |
|
377 |
|
378 // --------------------------------------------------------------------------- |
|
379 // CDevCertKeyDataManager::Count(). |
|
380 // --------------------------------------------------------------------------- |
|
381 // |
|
382 TInt CDevCertKeyDataManager::Count() const |
|
383 { |
|
384 return iKeys.Count(); |
|
385 } |
|
386 |
|
387 |
|
388 // --------------------------------------------------------------------------- |
|
389 // CDevCertKeyDataManager:::operator[](TInt aIndex) const |
|
390 // --------------------------------------------------------------------------- |
|
391 // |
|
392 const CDevCertKeyData* CDevCertKeyDataManager::operator[](TInt aIndex) const |
|
393 { |
|
394 return iKeys[aIndex]; |
|
395 } |
|
396 |
|
397 |
|
398 // --------------------------------------------------------------------------- |
|
399 // CDevCertKeyDataManager:::Lookup() |
|
400 // --------------------------------------------------------------------------- |
|
401 // |
|
402 const CDevCertKeyData* CDevCertKeyDataManager::Lookup(TInt aObjectId) const |
|
403 { |
|
404 TInt count = Count(); |
|
405 for (TInt i = 0; i < count; ++i) |
|
406 { |
|
407 if ((*this)[i]->Handle() == aObjectId) |
|
408 { |
|
409 return (*this)[i]; |
|
410 } |
|
411 } |
|
412 return NULL; |
|
413 } |
|
414 |
|
415 |
|
416 // Management of file and store therein |
|
417 |
|
418 // --------------------------------------------------------------------------- |
|
419 // CDevCertKeyDataManager:::CreateKeyDataLC() |
|
420 // --------------------------------------------------------------------------- |
|
421 // |
|
422 const CDevCertKeyData* CDevCertKeyDataManager::CreateKeyDataLC( const TDesC& aLabel ) |
|
423 { |
|
424 TInt objectId = ++iKeyIdentifier; |
|
425 TStreamId infoData = CreateWriteStreamL(); |
|
426 TStreamId publicKeyData = CreateWriteStreamL(); |
|
427 TStreamId privateKeyData = CreateWriteStreamL(); |
|
428 return CDevCertKeyData::NewLC(objectId, aLabel, infoData, publicKeyData, privateKeyData); |
|
429 } |
|
430 |
|
431 |
|
432 // --------------------------------------------------------------------------- |
|
433 // CDevCertKeyDataManager:::CreateWriteStreamL() |
|
434 // Creates a new write stream in the store (which it then closes) |
|
435 // Returns the TStreamId associated with it |
|
436 // --------------------------------------------------------------------------- |
|
437 // |
|
438 TStreamId CDevCertKeyDataManager::CreateWriteStreamL() |
|
439 { |
|
440 __ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised)); |
|
441 if (!iFileStore) |
|
442 User::Leave(KErrNotReady); |
|
443 |
|
444 RStoreWriteStream newStream; |
|
445 TStreamId result = newStream.CreateLC(*iFileStore); |
|
446 if (KNullStreamId == result) |
|
447 User::Leave(KErrBadHandle); |
|
448 |
|
449 newStream.CommitL(); |
|
450 CleanupStack::PopAndDestroy(&newStream); |
|
451 |
|
452 return result; |
|
453 } |
|
454 |
|
455 |
|
456 // --------------------------------------------------------------------------- |
|
457 // CDevCertKeyDataManager:::ReadKeyInfoLC() |
|
458 // --------------------------------------------------------------------------- |
|
459 // |
|
460 CDevTokenKeyInfo* CDevCertKeyDataManager::ReadKeyInfoLC(const CDevCertKeyData& aKeyData) const |
|
461 { |
|
462 __ASSERT_ALWAYS(iFileStore, PanicServer(EPanicStoreInitialised)); |
|
463 RStoreReadStream stream; |
|
464 stream.OpenLC(*iFileStore, aKeyData.InfoDataStreamId()); |
|
465 CDevTokenKeyInfo* info = CDevTokenKeyInfo::NewL(stream); |
|
466 CleanupStack::PopAndDestroy(&stream); |
|
467 info->CleanupPushL(); |
|
468 if (info->Handle() != aKeyData.Handle()) |
|
469 { |
|
470 User::Leave(KErrCorrupt); // is this appropriate? |
|
471 } |
|
472 return info; |
|
473 } |
|
474 |
|
475 |
|
476 // --------------------------------------------------------------------------- |
|
477 // CDevCertKeyDataManager:::WriteKeyInfoL() |
|
478 // --------------------------------------------------------------------------- |
|
479 // |
|
480 void CDevCertKeyDataManager::WriteKeyInfoL(const CDevCertKeyData& aKeyData, const CDevTokenKeyInfo& aKeyInfo) |
|
481 { |
|
482 RStoreWriteStream infoStream; |
|
483 OpenInfoDataStreamLC(aKeyData, infoStream); |
|
484 infoStream << aKeyInfo; |
|
485 infoStream.CommitL(); |
|
486 CleanupStack::PopAndDestroy(&infoStream); |
|
487 } |
|
488 |
|
489 |
|
490 // --------------------------------------------------------------------------- |
|
491 // CDevCertKeyDataManager:::SafeWriteKeyInfoL() |
|
492 // --------------------------------------------------------------------------- |
|
493 // |
|
494 void CDevCertKeyDataManager::SafeWriteKeyInfoL(const CDevCertKeyData& aKeyData, const CDevTokenKeyInfo& aKeyInfo) |
|
495 { |
|
496 TCleanupItem cleanupStore(RevertStore, iFileStore); |
|
497 CleanupStack::PushL(cleanupStore); |
|
498 |
|
499 WriteKeyInfoL(aKeyData, aKeyInfo); |
|
500 iFileStore->CommitL(); |
|
501 |
|
502 CleanupStack::Pop(); // cleanupStore |
|
503 } |
|
504 |
|
505 |
|
506 // --------------------------------------------------------------------------- |
|
507 // CDevCertKeyDataManager:::OpenInfoDataStreamLC() |
|
508 // --------------------------------------------------------------------------- |
|
509 // |
|
510 void CDevCertKeyDataManager::OpenInfoDataStreamLC(const CDevCertKeyData& aKeyData, RStoreWriteStream& aStream) |
|
511 { |
|
512 __ASSERT_ALWAYS(iFileStore, PanicServer(EPanicStoreInitialised)); |
|
513 aStream.ReplaceLC(*iFileStore, aKeyData.InfoDataStreamId()); |
|
514 } |
|
515 |
|
516 |
|
517 // --------------------------------------------------------------------------- |
|
518 // CDevCertKeyDataManager:::OpenPublicDataStreamLC() |
|
519 // --------------------------------------------------------------------------- |
|
520 // |
|
521 void CDevCertKeyDataManager::OpenPublicDataStreamLC(const CDevCertKeyData& aKeyData, RStoreWriteStream& aStream) |
|
522 { |
|
523 __ASSERT_ALWAYS(iFileStore, PanicServer(EPanicStoreInitialised)); |
|
524 aStream.ReplaceLC(*iFileStore, aKeyData.PublicDataStreamId()); |
|
525 } |
|
526 |
|
527 |
|
528 // --------------------------------------------------------------------------- |
|
529 // CDevCertKeyDataManager:::OpenPublicDataStreamLC() |
|
530 // --------------------------------------------------------------------------- |
|
531 // |
|
532 void CDevCertKeyDataManager::OpenPublicDataStreamLC(const CDevCertKeyData& aKeyData, RStoreReadStream& aStream) const |
|
533 { |
|
534 __ASSERT_ALWAYS(iFileStore, PanicServer(EPanicStoreInitialised)); |
|
535 aStream.OpenLC(*iFileStore, aKeyData.PublicDataStreamId()); |
|
536 } |
|
537 |
|
538 |
|
539 // --------------------------------------------------------------------------- |
|
540 // CDevCertKeyDataManager:::OpenPrivateDataStreamLC() |
|
541 // --------------------------------------------------------------------------- |
|
542 // |
|
543 void CDevCertKeyDataManager::OpenPrivateDataStreamLC(const CDevCertKeyData& aKeyData, |
|
544 RStoreWriteStream& aStream) |
|
545 { |
|
546 __ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised)); |
|
547 aStream.ReplaceLC(*iFileStore, aKeyData.PrivateDataStreamId()); |
|
548 } |
|
549 |
|
550 |
|
551 // --------------------------------------------------------------------------- |
|
552 // CDevCertKeyDataManager:::OpenPrivateDataStreamLC() |
|
553 // --------------------------------------------------------------------------- |
|
554 // |
|
555 void CDevCertKeyDataManager::OpenPrivateDataStreamLC(const CDevCertKeyData& aKeyData, |
|
556 RStoreReadStream& aStream) |
|
557 { |
|
558 __ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised)); |
|
559 aStream.OpenLC(*iFileStore, aKeyData.PrivateDataStreamId()); |
|
560 } |
|
561 |
|
562 |
|
563 // --------------------------------------------------------------------------- |
|
564 // CDevCertKeyDataManager:::CompactStore() |
|
565 // Attempt to compact the store - it doesn't matter if these calls leave, it |
|
566 // will only mean that the store takes up more space than necessary. |
|
567 // --------------------------------------------------------------------------- |
|
568 // |
|
569 void CDevCertKeyDataManager::CompactStore() |
|
570 { |
|
571 ASSERT(iFileStore); |
|
572 TRAP_IGNORE(iFileStore->ReclaimL(); iFileStore->CompactL()); |
|
573 } |
|
574 |
|
575 |
|
576 // CDevCertKeyData |
|
577 |
|
578 // --------------------------------------------------------------------------- |
|
579 // CDevCertKeyData::NewLC() |
|
580 // --------------------------------------------------------------------------- |
|
581 // |
|
582 CDevCertKeyData* CDevCertKeyData::NewLC(TInt aObjectId, const TDesC& aLabel, TStreamId aInfoData, |
|
583 TStreamId aPublicData, TStreamId aPrivateData) |
|
584 { |
|
585 CDevCertKeyData* self = new (ELeave) CDevCertKeyData(aObjectId, aInfoData, aPublicData, aPrivateData); |
|
586 CleanupStack::PushL(self); |
|
587 self->ConstructL(aLabel); |
|
588 return self; |
|
589 } |
|
590 |
|
591 |
|
592 // --------------------------------------------------------------------------- |
|
593 // CDevCertKeyData::NewL() |
|
594 // --------------------------------------------------------------------------- |
|
595 // |
|
596 CDevCertKeyData* CDevCertKeyData::NewL(RStoreReadStream& aReadStream) |
|
597 { |
|
598 CDevCertKeyData* self = new (ELeave) CDevCertKeyData(); |
|
599 CleanupStack::PushL(self); |
|
600 self->InternalizeL(aReadStream); |
|
601 CleanupStack::Pop(self); |
|
602 return (self); |
|
603 } |
|
604 |
|
605 |
|
606 // --------------------------------------------------------------------------- |
|
607 // CDevCertKeyData::~CDevCertKeyData() |
|
608 // --------------------------------------------------------------------------- |
|
609 // |
|
610 CDevCertKeyData::~CDevCertKeyData() |
|
611 { |
|
612 delete iLabel; |
|
613 } |
|
614 |
|
615 |
|
616 // --------------------------------------------------------------------------- |
|
617 // CDevCertKeyData::CDevCertKeyData() |
|
618 // --------------------------------------------------------------------------- |
|
619 // |
|
620 CDevCertKeyData::CDevCertKeyData(TInt aObjectId, TStreamId aInfoData, |
|
621 TStreamId aPublicData, TStreamId aPrivateData) : |
|
622 iObjectId(aObjectId), iInfoData(aInfoData), |
|
623 iPublicKeyData(aPublicData), iPrivateKeyData(aPrivateData) |
|
624 { |
|
625 ASSERT(iObjectId); |
|
626 ASSERT(iInfoData != KNullStreamId); |
|
627 ASSERT(iPublicKeyData != KNullStreamId); |
|
628 ASSERT(iPrivateKeyData != KNullStreamId); |
|
629 } |
|
630 |
|
631 |
|
632 // --------------------------------------------------------------------------- |
|
633 // CDevCertKeyData::CDevCertKeyData() |
|
634 // --------------------------------------------------------------------------- |
|
635 // |
|
636 CDevCertKeyData::CDevCertKeyData() |
|
637 { |
|
638 } |
|
639 |
|
640 |
|
641 // --------------------------------------------------------------------------- |
|
642 // CDevCertKeyData::ConstructL() |
|
643 // --------------------------------------------------------------------------- |
|
644 // |
|
645 void CDevCertKeyData::ConstructL(const TDesC& aLabel) |
|
646 { |
|
647 TInt labelLen = aLabel.Length(); |
|
648 iLabel = HBufC::NewMaxL(labelLen); |
|
649 TPtr theLabel(iLabel->Des()); |
|
650 theLabel.FillZ(); |
|
651 theLabel.Copy(aLabel); |
|
652 } |
|
653 |
|
654 |
|
655 // --------------------------------------------------------------------------- |
|
656 // CDevCertKeyData::InternalizeL() |
|
657 // --------------------------------------------------------------------------- |
|
658 // |
|
659 void CDevCertKeyData::InternalizeL(RReadStream& aReadStream) |
|
660 { |
|
661 iObjectId = aReadStream.ReadInt32L(); |
|
662 iInfoData.InternalizeL(aReadStream); |
|
663 iPublicKeyData.InternalizeL(aReadStream); |
|
664 iPrivateKeyData.InternalizeL(aReadStream); |
|
665 |
|
666 TInt labelLen = aReadStream.ReadInt32L(); |
|
667 iLabel = HBufC::NewMaxL(labelLen); |
|
668 TPtr theLabel((TUint16*)iLabel->Ptr(), labelLen, labelLen); |
|
669 theLabel.FillZ(labelLen); |
|
670 aReadStream.ReadL(theLabel); |
|
671 } |
|
672 |
|
673 |
|
674 // --------------------------------------------------------------------------- |
|
675 // CDevCertKeyData::ExternalizeL() |
|
676 // --------------------------------------------------------------------------- |
|
677 // |
|
678 void CDevCertKeyData::ExternalizeL(RWriteStream& aWriteStream) const |
|
679 { |
|
680 aWriteStream.WriteInt32L(iObjectId); |
|
681 iInfoData.ExternalizeL(aWriteStream); |
|
682 iPublicKeyData.ExternalizeL(aWriteStream); |
|
683 iPrivateKeyData.ExternalizeL(aWriteStream); |
|
684 |
|
685 TInt labelLen = iLabel->Length(); |
|
686 aWriteStream.WriteInt32L(labelLen); |
|
687 TPtr theLabel(iLabel->Des()); |
|
688 theLabel.SetLength(labelLen); |
|
689 aWriteStream.WriteL(theLabel); |
|
690 } |
|
691 |
|
692 //EOF |
|
693 |