diff -r 000000000000 -r bde4ae8d615e os/security/cryptoservices/filebasedcertificateandkeystores/source/keystore/Server/CKeyDataManager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/security/cryptoservices/filebasedcertificateandkeystores/source/keystore/Server/CKeyDataManager.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,860 @@
+/*
+* Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+#include "CKeyDataManager.h"
+#include "fsdatatypes.h"
+#include "fstokencliserv.h"
+#include "fstokenutil.h"
+#include "keystorepassphrase.h"
+
+_LIT(KKeyStoreFilename,"keys.dat");
+
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+#include <e32property.h>
+#include <authserver/aspubsubdefs.h>
+#else
+const TInt KDefaultPassphraseTimeout = 30;
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+//	*********************************************************************
+//	Key store data manager - maintains array of objects representing keys
+//	*********************************************************************
+
+/*static*/ CFileKeyDataManager* CFileKeyDataManager::NewL()
+	{
+	CFileKeyDataManager* self = new (ELeave) CFileKeyDataManager();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CFileKeyDataManager::~CFileKeyDataManager()
+	{
+	if (iFileStore)
+		{
+		CompactStore();
+		delete iFileStore;
+		}
+
+	iFile.Close(); // May already have been closed by store
+	iFs.Close();
+		
+	iKeys.ResetAndDestroy();
+	iKeys.Close();
+	#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	iIdentityId.Close();
+	#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	}
+
+CFileKeyDataManager::CFileKeyDataManager() :
+	iRootStreamId(KNullStreamId),
+	iInfoStreamId(KNullStreamId)
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	,iPassStreamId(KNullStreamId),
+	iTimeoutStreamId(KNullStreamId)
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	{
+	}
+
+void CFileKeyDataManager::ConstructL()
+	{
+	
+	User::LeaveIfError(iFs.Connect());
+	OpenStoreL();
+
+	RStoreReadStream lookupStream;
+	lookupStream.OpenLC(*iFileStore, iInfoStreamId);
+
+	#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	User::LeaveIfError(iIdentityId.Attach(	AuthServer::KAuthServerSecureId,
+											AuthServer::KUidAuthServerAuthChangeEvent));
+	#else
+	iPassStreamId = (TStreamId) lookupStream.ReadUint32L();
+	iTimeoutStreamId = (TStreamId) lookupStream.ReadUint32L();
+	#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+	TInt count = lookupStream.ReadInt32L();
+	for (TInt index = 0; index < count; index++)
+		{
+		CFileKeyData* keyData = CFileKeyData::NewL(lookupStream);
+		CleanupStack::PushL(keyData);
+
+		if (keyData->Handle() > iKeyIdentifier)
+			iKeyIdentifier = keyData->Handle();
+
+		iKeys.AppendL(keyData);
+		CleanupStack::Pop(keyData);
+		}
+	
+	CleanupStack::PopAndDestroy(&lookupStream);
+
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	ReadPassphraseTimeoutL();
+#endif //SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	
+	}
+
+CPassphraseManager* CFileKeyDataManager::CreatePassphraseManagerLC()
+	{
+	CPassphraseManager* result = CPassphraseManager::NewL(*iFileStore);
+	CleanupStack::PushL(result);
+	return result;
+	}
+
+void CFileKeyDataManager::OpenStoreL()
+	{
+	//	Tries to locate a key store file on the default drive and then from ROM
+	//	If it cannot find one, tries to create a file with permanent file store
+	//	inside it In all cases, should initialise iFileStore unless it cannot
+	//	create the file/store/streams
+	
+	__ASSERT_DEBUG(!iFileStore, PanicServer(EPanicStoreInitialised));
+
+	TFileName fullPath;
+	FileUtils::MakePrivateFilenameL(iFs, KKeyStoreFilename, fullPath);
+
+	FileUtils::EnsurePathL(iFs, fullPath);
+	TRAPD(result, OpenStoreInFileL(fullPath));
+
+	if (result == KErrInUse) 
+		{		
+		// Cannot access the file now. Abort server startup rather than wiping the keystore.
+		User::Leave(result); 
+		}
+
+	if (result != KErrNone)
+		{		
+		// Not yet opened a valid store, either no file to be found, or no valid
+		// store in it. Copy the original one stored in the ROM.
+		delete iFileStore;
+		iFileStore = NULL;
+		
+		TFileName romPath;
+		FileUtils::MakePrivateROMFilenameL(iFs, KKeyStoreFilename, romPath);
+
+		if (result != KErrNotFound)
+			{
+			// Wipe the keystore if we can't open it (it's corrupt anyway)
+			User::LeaveIfError(iFs.Delete(fullPath));
+			}
+
+		// Copy data from rom and open it	
+		TRAPD(err,
+			  FileUtils::CopyL(iFs, romPath, fullPath);
+			  OpenStoreInFileL(fullPath)
+			);
+		
+		if (KErrNone != err)
+			{
+			// We tried to copy the keystore from ROM. For some reason this
+			// failed and we still cannot open the file. Create a new one from
+			// scratch.
+			CreateStoreInFileL(fullPath);
+			}
+		}
+
+	__ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised));
+	__ASSERT_DEBUG((KNullStreamId!=iRootStreamId), PanicServer(EPanicRootStreamNotReady));
+	__ASSERT_DEBUG((KNullStreamId!=iInfoStreamId), PanicServer(EPanicManagerStreamNotReady));
+	}
+
+void CFileKeyDataManager::CreateStoreInFileL(const TDesC& aFile)
+	{
+	TInt r = iFs.MkDirAll(aFile);
+	if ( (r!=KErrNone) && (r!=KErrAlreadyExists) )
+		User::Leave(r);
+
+	iFileStore = CPermanentFileStore::ReplaceL(iFs, aFile, EFileRead | EFileWrite | EFileShareExclusive);
+	iFileStore->SetTypeL(KPermanentFileStoreLayoutUid);
+
+	TCleanupItem cleanupStore(RevertStore, iFileStore);
+	CleanupStack::PushL(cleanupStore);
+	
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	// Create timeout stream with default timeout
+	RStoreWriteStream timeoutStream;
+	iTimeoutStreamId = timeoutStream.CreateLC(*iFileStore);
+	timeoutStream.WriteUint32L(KDefaultPassphraseTimeout);
+	timeoutStream.CommitL();
+	CleanupStack::PopAndDestroy(&timeoutStream);
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	
+	// Create info stream - Currently no passphrase created, and no keys
+	RStoreWriteStream infoStream;
+	iInfoStreamId = infoStream.CreateLC(*iFileStore);
+	
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	infoStream.WriteUint32L(KNullStreamId.Value());
+	infoStream.WriteUint32L(iTimeoutStreamId.Value());
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	
+	infoStream.WriteUint32L(0); // Write key count of zero
+	infoStream.CommitL();
+	CleanupStack::PopAndDestroy(&infoStream);
+
+	// Create root stream - just contains id of info stream
+	RStoreWriteStream rootStream;
+	iRootStreamId = rootStream.CreateLC(*iFileStore);
+	iFileStore->SetRootL(iRootStreamId);
+
+	rootStream.WriteUint32L(iInfoStreamId.Value());		
+	rootStream.CommitL();
+	CleanupStack::PopAndDestroy(&rootStream);
+
+	WriteKeysToStoreL();
+	
+	iFileStore->CommitL();
+	CleanupStack::Pop(); // cleanupStore
+	}
+
+void CFileKeyDataManager::OpenStoreInFileL(const TDesC& aFile)
+	{
+	// Make sure the file isn't write protected
+	User::LeaveIfError(iFs.SetAtt(aFile, 0, KEntryAttReadOnly));
+	
+	User::LeaveIfError(iFile.Open(iFs, aFile, EFileRead | EFileWrite | EFileShareExclusive));
+	
+	iFileStore = CPermanentFileStore::FromL(iFile);		
+
+	// Get the salt, root and manager TStreamIds
+	iRootStreamId = iFileStore->Root();
+	if (iRootStreamId == KNullStreamId)
+		{
+		User::Leave(KErrCorrupt);
+		}
+	
+	RStoreReadStream rootStream;
+	rootStream.OpenLC(*iFileStore, iRootStreamId);
+	iInfoStreamId = (TStreamId)(rootStream.ReadUint32L());
+	CleanupStack::PopAndDestroy(&rootStream);
+	}
+
+// Methods dealing with atomic updates to key data file ////////////////////////
+
+// This is a cleanup item that reverts the store
+void CFileKeyDataManager::RevertStore(TAny* aStore)
+{
+	CPermanentFileStore* store = reinterpret_cast<CPermanentFileStore*>(aStore);
+	TRAP_IGNORE(store->RevertL());
+	// We're ignoring the leave code from this becuase there's no way we can
+	// handle this sensibly.  This shouldn't be a problem in practice - this
+	// will leave if for example the file store is on removable which is
+	// unexpectedly remove, and this is never the case for us.
+}
+
+// Rewrites the info stream (ie the array of key data info) to the store
+void CFileKeyDataManager::WriteKeysToStoreL()
+	{
+	RStoreWriteStream lookupStream;
+	lookupStream.ReplaceLC(*iFileStore, iInfoStreamId);
+
+	#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+		lookupStream.WriteUint32L(iPassStreamId.Value());
+		lookupStream.WriteUint32L(iTimeoutStreamId.Value());
+	#endif //SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	
+	TInt keyCount = iKeys.Count();
+	lookupStream.WriteInt32L(keyCount);
+
+	for (TInt index = 0; index < keyCount; index++)
+		{
+		const CFileKeyData* key = iKeys[index];
+		key->ExternalizeL(lookupStream);
+		}
+
+	lookupStream.CommitL();
+	CleanupStack::PopAndDestroy(&lookupStream);
+	}
+
+/**
+ * Add a key to the store.  Assumes that the key data streams (info, public key
+ * and private key) have already been written.
+ */
+void CFileKeyDataManager::AddL(const CFileKeyData* aKeyData)
+	{
+	ASSERT(aKeyData);
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+		ASSERT(aKeyData->PassphraseStreamId() != KNullStreamId);
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+	// Add the key to to the array, rewrite the infostream and 
+	// ONLY THEN commit the store
+	User::LeaveIfError(iKeys.Append(aKeyData));
+
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	TStreamId oldDefaultPassphraseId;
+
+	// Set the default passphrase id if this is the first key
+	oldDefaultPassphraseId = iPassStreamId;
+	if (iKeys.Count() == 1)
+		{
+		iPassStreamId = aKeyData->PassphraseStreamId();
+		}
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	
+	TRAPD(err,UpdateStoreL());
+	
+	if (err != KErrNone)
+		{
+		iKeys.Remove(iKeys.Count() - 1);
+		#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+			iPassStreamId = oldDefaultPassphraseId;
+		#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+		User::Leave(err);
+		}
+	}
+
+void CFileKeyDataManager::UpdateStoreL()
+	{
+	WriteKeysToStoreL();
+
+	// Release ownership of key data and reset default passphrase id if store
+	// can't be written
+	TCleanupItem cleanupStore(RevertStore, iFileStore);
+	CleanupStack::PushL(cleanupStore);
+
+	iFileStore->CommitL();
+	
+	CleanupStack::Pop(); // cleanupStore
+	}
+
+/**
+ * "Transaction safe" key removal - only removes the key in memory and file if
+ * all operations are successful.
+ */
+void CFileKeyDataManager::RemoveL(TInt aObjectId)
+	{
+	TInt index;
+	const CFileKeyData* key = NULL;
+	for (index = 0 ; index < iKeys.Count() ; ++index)
+		{
+		if (iKeys[index]->Handle() == aObjectId)
+			{
+			key = iKeys[index];
+			break;
+			}
+		}
+	
+	if (!key)
+		{
+		User::Leave(KErrNotFound);
+		}
+
+	TCleanupItem cleanupStore(RevertStore, iFileStore);
+	CleanupStack::PushL(cleanupStore);	
+
+	iFileStore->DeleteL(key->PrivateDataStreamId());
+	iFileStore->DeleteL(key->PublicDataStreamId());
+	iFileStore->DeleteL(key->InfoDataStreamId());
+
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	// Remove the passphrase if it's the last key
+	TStreamId oldPassphraseId = iPassStreamId;
+	if (Count() == 1)
+		{
+		iFileStore->DeleteL(iPassStreamId);
+		iPassStreamId = KNullStreamId;
+		}
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	
+	// Remove the key
+	iKeys.Remove(index);
+	
+	TRAPD(res, WriteKeysToStoreL());
+
+	if (res != KErrNone)
+		{
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER		
+		iPassStreamId = oldPassphraseId;
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+		User::LeaveIfError(iKeys.Append(key)); // Put it back, shouldn't leave
+		User::Leave(res);
+		}
+	else 
+		{
+		delete key;   // Cannot leave from the point it's removed to here, so no cleanup stack!
+		}		
+	iFileStore->CommitL();
+
+	CleanupStack::Pop(); // cleanupStore
+	CompactStore();
+}
+
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+TBool CFileKeyDataManager::IsKeyAlreadyInStore(const TDesC& aKeyLabel, AuthServer::TIdentityId aIdentity) const
+	{//	Check each key in the store to determine if aKeyLabel already exists
+	TInt keyCount = iKeys.Count();
+	TBool isInStore = EFalse;
+	for (TInt index = 0; index < keyCount; ++index)
+		{
+		const TDesC& keyLabel = iKeys[index]->Label();
+		if (keyLabel.Compare(aKeyLabel)==0 && (iKeys[index]->Identity() == aIdentity))
+			{
+			isInStore = ETrue;
+			break;
+			}
+		}
+	return (isInStore);
+	}
+
+#else
+TBool CFileKeyDataManager::IsKeyAlreadyInStore(const TDesC& aKeyLabel) const
+{//	Check each key in the store to determine if aKeyLabel already exists
+	TInt keyCount = iKeys.Count();
+	TBool isInStore = EFalse;
+	for (TInt index = 0; index < keyCount; index++)
+	{
+		const TDesC& keyLabel = iKeys[index]->Label();
+		if (keyLabel.Compare(aKeyLabel)==0)
+		{
+			isInStore = ETrue;
+			break;
+		}
+	}
+
+	return (isInStore);
+}
+
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+TInt CFileKeyDataManager::Count() const
+	{
+	return iKeys.Count();
+	}	
+
+const CFileKeyData* CFileKeyDataManager::operator[](TInt aIndex) const
+	{
+	return iKeys[aIndex];
+	}
+
+const CFileKeyData* CFileKeyDataManager::Lookup(TInt aObjectId) const
+	{
+	TInt count = Count();
+	for (TInt i = 0; i < count; ++i)
+		{
+		if ((*this)[i]->Handle() == aObjectId)
+			{
+			return (*this)[i];
+			}
+		}
+	return NULL;
+	}
+
+//	*********************************************************************
+//	Management of file and store therein
+//	*********************************************************************
+
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+const CFileKeyData* CFileKeyDataManager::CreateKeyDataLC(const TDesC& aLabel, AuthServer::TIdentityId aIdentityId)
+	{
+	TInt objectId = ++iKeyIdentifier;
+	TStreamId infoData = CreateWriteStreamL();
+	TStreamId publicKeyData = CreateWriteStreamL();
+	TStreamId privateKeyData = CreateWriteStreamL();
+	return CFileKeyData::NewLC(objectId, aLabel, infoData, publicKeyData, privateKeyData, aIdentityId);
+	}
+
+#else
+const CFileKeyData* CFileKeyDataManager::CreateKeyDataLC(const TDesC& aLabel, TStreamId aPassStreamId)
+	{
+	ASSERT(aPassStreamId != KNullStreamId);
+	TInt objectId = ++iKeyIdentifier;
+	TStreamId infoData = CreateWriteStreamL();
+	TStreamId publicKeyData = CreateWriteStreamL();
+	TStreamId privateKeyData = CreateWriteStreamL();
+	return CFileKeyData::NewLC(objectId, aLabel, infoData, aPassStreamId, publicKeyData, privateKeyData);
+	}
+
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+//	Creates a new write stream in the store (which it then closes)
+//	Returns the TStreamId associated with it
+TStreamId CFileKeyDataManager::CreateWriteStreamL()
+	{
+	__ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised));
+	if (!iFileStore)
+		User::Leave(KErrNotReady);
+
+	RStoreWriteStream newStream;
+	TStreamId result = newStream.CreateLC(*iFileStore);
+	if (KNullStreamId == result)
+		User::Leave(KErrBadHandle);
+
+	newStream.CommitL();
+	CleanupStack::PopAndDestroy(&newStream);
+
+	return result;
+	}
+
+CKeyInfo* CFileKeyDataManager::ReadKeyInfoLC(const CFileKeyData& aKeyData) const
+	{
+	__ASSERT_ALWAYS(iFileStore, PanicServer(EPanicStoreInitialised));
+	RStoreReadStream stream;
+	stream.OpenLC(*iFileStore, aKeyData.InfoDataStreamId());
+	CKeyInfo* info = CKeyInfo::NewL(stream);
+	
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	ReadAuthDetailsL(stream, *info);
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	CleanupStack::PopAndDestroy(&stream);
+	info->CleanupPushL();
+	if (info->Handle() != aKeyData.Handle())
+		{
+		User::Leave(KErrCorrupt); // is this appropriate?
+		}
+	return info;
+	}
+
+void CFileKeyDataManager::WriteKeyInfoL(const CFileKeyData& aKeyData, const CKeyInfo& aKeyInfo)
+	{
+	RStoreWriteStream infoStream;
+	OpenInfoDataStreamLC(aKeyData, infoStream);
+	infoStream << aKeyInfo;
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	WriteAuthDetailsL(infoStream, aKeyInfo);
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	infoStream.CommitL();
+	CleanupStack::PopAndDestroy(&infoStream);
+	}
+
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+void CFileKeyDataManager::WriteAuthDetailsL( RStoreWriteStream& aInfoStream, const CKeyInfo& aKeyInfo )
+	{
+	aInfoStream.WriteInt32L(aKeyInfo.Identity());
+	aInfoStream << aKeyInfo.AuthExpression();
+  	aInfoStream.WriteInt32L(aKeyInfo.Freshness());
+	}
+
+void CFileKeyDataManager::ReadAuthDetailsL( RStoreReadStream& aInfoStream, CKeyInfo& aKeyInfo ) const
+	{
+	aKeyInfo.SetIdentity(aInfoStream.ReadInt32L());
+	HBufC* expression = HBufC::NewLC(aInfoStream, KMaxTInt);
+	aKeyInfo.SetAuthExpressionL(*expression);
+	aKeyInfo.SetFreshness(aInfoStream.ReadInt32L());
+	CleanupStack::PopAndDestroy(expression);
+	}
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+void CFileKeyDataManager::SafeWriteKeyInfoL(const CFileKeyData& aKeyData, const CKeyInfo& aKeyInfo)
+	{
+	TCleanupItem cleanupStore(RevertStore, iFileStore);
+	CleanupStack::PushL(cleanupStore);	
+
+	WriteKeyInfoL(aKeyData, aKeyInfo);
+	iFileStore->CommitL();
+	
+	CleanupStack::Pop(); // cleanupStore	
+	}
+
+void CFileKeyDataManager::OpenInfoDataStreamLC(const CFileKeyData& aKeyData, RStoreWriteStream& aStream)
+	{
+	__ASSERT_ALWAYS(iFileStore, PanicServer(EPanicStoreInitialised));
+	aStream.ReplaceLC(*iFileStore, aKeyData.InfoDataStreamId());
+	}
+
+void CFileKeyDataManager::OpenPublicDataStreamLC(const CFileKeyData& aKeyData, RStoreWriteStream& aStream)
+	{
+	__ASSERT_ALWAYS(iFileStore, PanicServer(EPanicStoreInitialised));
+	aStream.ReplaceLC(*iFileStore, aKeyData.PublicDataStreamId());
+	}
+
+void CFileKeyDataManager::OpenPublicDataStreamLC(const CFileKeyData& aKeyData, RStoreReadStream& aStream) const
+	{
+	__ASSERT_ALWAYS(iFileStore, PanicServer(EPanicStoreInitialised));
+	aStream.OpenLC(*iFileStore, aKeyData.PublicDataStreamId());
+	}
+
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+void CFileKeyDataManager::OpenPrivateDataStreamLC(const CFileKeyData& aKeyData, RStoreWriteStream& aStream) 
+	{
+	__ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised));
+	aStream.ReplaceLC(*iFileStore, aKeyData.PrivateDataStreamId());
+	}
+
+void CFileKeyDataManager::OpenPrivateDataStreamLC(const CFileKeyData& aKeyData, RStoreReadStream& aStream) const
+	{
+	__ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised));
+	aStream.OpenLC(*iFileStore, aKeyData.PrivateDataStreamId());
+	}
+
+#else
+
+void CFileKeyDataManager::OpenPrivateDataStreamLC(const CFileKeyData& aKeyData, CPassphrase& aPassphrase,
+												  RStoreReadStream& aStream) 
+	{
+	__ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised));
+	aStream.OpenLC(aPassphrase.Store(), aKeyData.PrivateDataStreamId());
+	}
+
+void CFileKeyDataManager::OpenPrivateDataStreamLC(const CFileKeyData& aKeyData, CPassphrase& aPassphrase,
+												  RStoreWriteStream& aStream)
+	{
+	__ASSERT_DEBUG(iFileStore, PanicServer(EPanicStoreInitialised));
+	aStream.ReplaceLC(aPassphrase.Store(), aKeyData.PrivateDataStreamId());
+	}
+
+
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+TInt CFileKeyDataManager::GetPassphraseTimeout() const
+	{
+	return iTimeout;
+	}
+
+void CFileKeyDataManager::SetPassphraseTimeoutL(TInt aTimeout)
+	{
+	TInt oldTimeout = iTimeout;
+
+	iTimeout = aTimeout;
+	TRAPD(err, WritePassphraseTimeoutL(); iFileStore->CommitL());
+
+	if (err != KErrNone)
+		{
+		iTimeout = oldTimeout;
+		iFileStore->RevertL(); // shouldn't leave
+		User::Leave(err);
+		}
+	}
+
+void CFileKeyDataManager::ReadPassphraseTimeoutL()
+	{
+	ASSERT(iTimeout == 0); // Only called from ConstructL()
+	
+	RStoreReadStream stream;
+	stream.OpenLC(*iFileStore, iTimeoutStreamId);
+	iTimeout = stream.ReadInt32L();
+	CleanupStack::PopAndDestroy(&stream);
+	}
+
+void CFileKeyDataManager::WritePassphraseTimeoutL()
+	{
+	RStoreWriteStream stream;
+	stream.ReplaceLC(*iFileStore, iTimeoutStreamId);
+	stream.WriteUint32L(iTimeout);	
+	stream.CommitL();
+	CleanupStack::PopAndDestroy(&stream);
+	}
+
+TStreamId CFileKeyDataManager::DefaultPassphraseId() const
+	{
+	ASSERT((iPassStreamId == KNullStreamId) == (Count() == 0));
+	return iPassStreamId;
+	}
+
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+/**
+ * Attempt to compact the store - it doesn't matter if these calls leave, it
+ * will only mean that the store takes up more space than necessary.
+ */
+void CFileKeyDataManager::CompactStore()
+	{
+	ASSERT(iFileStore);
+	TRAP_IGNORE(iFileStore->ReclaimL(); iFileStore->CompactL());
+	}
+
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+TUint32 CFileKeyDataManager::CachedIdentity()
+	{
+	TInt value = 0;
+	iIdentityId.Get(value);
+	return value;
+	}
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+// CFileKeyData ////////////////////////////////////////////////////////////////
+
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+CFileKeyData* CFileKeyData::NewLC(	TInt aObjectId, const TDesC& aLabel, TStreamId aInfoData,
+								  TStreamId aPublicData, TStreamId aPrivateData,
+								  AuthServer::TIdentityId aIdentityId)
+	{
+	CFileKeyData* self = new (ELeave) CFileKeyData(aObjectId, aInfoData, aPublicData, aPrivateData, aIdentityId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aLabel);
+	return self;
+	}
+#else
+CFileKeyData* CFileKeyData::NewLC(TInt aObjectId, const TDesC& aLabel, TStreamId aInfoData,
+								  TStreamId aPassphraseId, TStreamId aPublicData, TStreamId aPrivateData)
+	{
+	CFileKeyData* self = new (ELeave) CFileKeyData(aObjectId, aInfoData, aPassphraseId, aPublicData, aPrivateData);
+	CleanupStack::PushL(self);
+	self->ConstructL(aLabel);
+	return self;
+	}
+
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+CFileKeyData* CFileKeyData::NewL(RStoreReadStream& aReadStream)
+	{
+	CFileKeyData* self = new (ELeave) CFileKeyData();
+	CleanupStack::PushL(self);
+	self->InternalizeL(aReadStream);
+	CleanupStack::Pop(self);
+	return (self);
+	}
+
+CFileKeyData::~CFileKeyData()
+	{
+	delete iLabel;
+	}
+
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+CFileKeyData::CFileKeyData(TInt aObjectId, TStreamId aInfoData,  
+						   TStreamId aPublicData, TStreamId aPrivateData,
+						   AuthServer::TIdentityId aIdentityId) :
+	iObjectId(aObjectId), iInfoData(aInfoData), 
+	iPublicKeyData(aPublicData), iPrivateKeyData(aPrivateData),
+	iIdentityId(aIdentityId)
+	{
+	ASSERT(iObjectId);
+	ASSERT(iInfoData != KNullStreamId);
+	ASSERT(iPublicKeyData != KNullStreamId);
+	ASSERT(iPrivateKeyData != KNullStreamId);
+	ASSERT(iIdentityId);
+	}
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+#ifdef KEYTOOL
+CFileKeyData::CFileKeyData(TInt aObjectId, TStreamId aInfoData,  
+						   TStreamId aPublicData, TStreamId aPrivateData,
+						   AuthServer::TIdentityId aIdentityId) :
+	iObjectId(aObjectId), iInfoData(aInfoData), 
+	iPublicKeyData(aPublicData), iPrivateKeyData(aPrivateData),
+	iIdentityId(aIdentityId)
+	{
+	ASSERT(iObjectId);
+	ASSERT(iInfoData != KNullStreamId);
+	ASSERT(iPublicKeyData != KNullStreamId);
+	ASSERT(iPrivateKeyData != KNullStreamId);
+	ASSERT(iIdentityId);
+	}
+#endif // KEYTOOL
+
+CFileKeyData::CFileKeyData(TInt aObjectId, TStreamId aInfoData, TStreamId aPassphraseId, 
+						   TStreamId aPublicData, TStreamId aPrivateData) :
+	iObjectId(aObjectId), iInfoData(aInfoData), iPassphraseId(aPassphraseId),
+	iPublicKeyData(aPublicData), iPrivateKeyData(aPrivateData)
+	{
+	ASSERT(iObjectId);
+	ASSERT(iInfoData != KNullStreamId);
+	ASSERT(iPassphraseId != KNullStreamId);
+	ASSERT(iPublicKeyData != KNullStreamId);
+	ASSERT(iPrivateKeyData != KNullStreamId);
+	}
+
+CFileKeyData::CFileKeyData()
+	{
+	}
+
+void CFileKeyData::ConstructL(const TDesC& aLabel)
+	{
+	TInt labelLen = aLabel.Length();
+	iLabel = HBufC::NewMaxL(labelLen);
+	TPtr theLabel(iLabel->Des());
+	theLabel.FillZ();
+	theLabel.Copy(aLabel);
+	}
+
+void CFileKeyData::InternalizeL(RReadStream& aReadStream)
+{
+	iObjectId = aReadStream.ReadInt32L();
+	iInfoData.InternalizeL(aReadStream);
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	iPassphraseId.InternalizeL(aReadStream);
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	iPublicKeyData.InternalizeL(aReadStream);
+	iPrivateKeyData.InternalizeL(aReadStream);
+	
+	TInt labelLen = aReadStream.ReadInt32L();
+	iLabel = HBufC::NewMaxL(labelLen);
+	TPtr theLabel((TUint16*)iLabel->Ptr(), labelLen, labelLen);
+	theLabel.FillZ(labelLen);
+	aReadStream.ReadL(theLabel);
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	iIdentityId = aReadStream.ReadInt32L();
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+}
+
+void CFileKeyData::ExternalizeL(RWriteStream& aWriteStream) const
+{
+	aWriteStream.WriteInt32L(iObjectId);
+	iInfoData.ExternalizeL(aWriteStream);
+#ifndef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	iPassphraseId.ExternalizeL(aWriteStream);
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	iPublicKeyData.ExternalizeL(aWriteStream);
+	iPrivateKeyData.ExternalizeL(aWriteStream);
+
+	TInt labelLen = iLabel->Length();
+	aWriteStream.WriteInt32L(labelLen);
+	TPtr theLabel(iLabel->Des());
+	theLabel.SetLength(labelLen);
+	aWriteStream.WriteL(theLabel);
+#ifdef SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+	aWriteStream.WriteInt32L(iIdentityId);
+#endif // SYMBIAN_KEYSTORE_USE_AUTH_SERVER
+
+}
+
+#ifdef KEYTOOL
+
+CFileKeyData* CFileKeyData::CreateOldKeyL(RStoreReadStream& aReadStream)
+	{
+	CFileKeyData* self = new (ELeave) CFileKeyData();
+	CleanupStack::PushL(self);
+	self->InternalizeOldKeyL(aReadStream);
+	CleanupStack::Pop(self);
+	return (self);
+	}
+
+void CFileKeyData::InternalizeOldKeyL(RReadStream& aReadStream)
+	{
+	iObjectId = aReadStream.ReadInt32L();
+	iInfoData.InternalizeL(aReadStream);
+	iPassphraseId.InternalizeL(aReadStream);
+	iPublicKeyData.InternalizeL(aReadStream);
+	iPrivateKeyData.InternalizeL(aReadStream);
+	
+	TInt labelLen = aReadStream.ReadInt32L();
+	iLabel = HBufC::NewMaxL(labelLen);
+	TPtr theLabel((TUint16*)iLabel->Ptr(), labelLen, labelLen);
+	theLabel.FillZ(labelLen);
+	aReadStream.ReadL(theLabel);
+	}
+
+void CFileKeyData::ExternalizeWithAuthL(RWriteStream& aWriteStream) 
+{
+	aWriteStream.WriteInt32L(iObjectId);
+	iInfoData.ExternalizeL(aWriteStream);
+	iPublicKeyData.ExternalizeL(aWriteStream);
+	iPrivateKeyData.ExternalizeL(aWriteStream);
+
+	TInt labelLen = iLabel->Length();
+	aWriteStream.WriteInt32L(labelLen);
+	TPtr theLabel(iLabel->Des());
+	theLabel.SetLength(labelLen);
+	aWriteStream.WriteL(theLabel);
+	aWriteStream.WriteInt32L(iIdentityId);
+}
+
+#endif // KEYTOOL