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