/*
* Copyright (c) 2006-2009 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: 
* CPinPluginDB pin plugin data store implementation
*
*/


/**
 @file 
*/

#include "pinplugindb.h"

_LIT(KPluginStoreName, "plugin.store");
_LIT(KFileDrive, "c:");

using namespace AuthServer;

CPinPluginDB* CPinPluginDB::NewL()
	{
	CPinPluginDB* self = CPinPluginDB::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CPinPluginDB* CPinPluginDB::NewLC()
	{
	CPinPluginDB* self = new(ELeave) CPinPluginDB();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}
	
CPinPluginDB::CPinPluginDB() :
	iRootStreamId(KNullStreamId),
	iIdentityStreamId(KNullStreamId)
	{
	}

CPinPluginDB::~CPinPluginDB()
	{
	if (iFileStore)
		{
		CompactStore();
		delete iFileStore;
		}

	iFile.Close(); 
	iFs.Close();

	iId.Reset();
	iId.Close();
	iIdKeyHash.ResetAndDestroy();
	iIdKeyHash.Close();
	}
	
		
void CPinPluginDB::ConstructL()
	{
	User::LeaveIfError(iFs.Connect());
	
	TFileName privatePath;
	iFs.PrivatePath(privatePath);
	iPluginDBName.Copy(KFileDrive);
	iPluginDBName.Append(privatePath);
	iPluginDBName.Append(KPluginStoreName);
	OpenStoreL();
	
	ReadIdKeysFromStoreL();
	}


void CPinPluginDB::AddPinL(const TIdentityId& aId, const TDesC8& aIdentityKeyHash)
	{
	if(IdIndex(aId) == KErrNotFound && IsUniquePin(aIdentityKeyHash))
		{
		// Add the IdentityId to the array, rewrite the identitystream and 
		// Only then commit the store
		HBufC8* keyHash = aIdentityKeyHash.AllocLC();
		TInt err = KErrNone;
		iIdKeyHash.AppendL(keyHash);
		err = iId.Append(aId);
		if(err != KErrNone)
			{
			iIdKeyHash.Remove(iIdKeyHash.Count() - 1);
			User::Leave(err);
			}
		TCleanupItem cleanupStore(RevertStore, iFileStore);
		// write the idkeys to the store.
		TRAP(err,
			CleanupStack::PushL(cleanupStore);
			WriteIdKeysToStoreL();
			CleanupStack::Pop(iFileStore));

		if (err != KErrNone)
			{
			iId.Remove(iId.Count() - 1);
			iIdKeyHash.Remove(iIdKeyHash.Count() - 1);
			User::Leave(err);
			}
		CleanupStack::Pop(keyHash); 
		}
	else
		{
		User::Leave(KErrAlreadyExists);
		}
 	}

void CPinPluginDB::UpdatePinL(const TIdentityId& aId, const TDesC8& aIdentityKeyHash)
	{
	if(IdIndex(aId) != KErrNotFound)
		{
		// Get the index of the existing id and key hash
		TInt index = IdIndex(aId);
		TInt err = KErrNone;
		HBufC8* keyHash = aIdentityKeyHash.AllocLC();
		// delete the old keyHash and store the new keyHash to the index
		delete iIdKeyHash[index];
		iIdKeyHash[index] = keyHash;

		TCleanupItem cleanupStore(RevertStore, iFileStore);
		// write the idkeys to the store.
		TRAP(err ,
			CleanupStack::PushL(cleanupStore);
			WriteIdKeysToStoreL();
			CleanupStack::Pop(iFileStore));
		if (err!= KErrNone)
			{
			CleanupStack::Pop(keyHash);
			ReadIdKeysFromStoreL();
			User::Leave(err);
			}
		CleanupStack::Pop(keyHash);
		}
	else
		{
		User::Leave(KErrNotFound);
		}
	}
	
void CPinPluginDB::RemovePinL(const TIdentityId& aId)
	{
	if(IdIndex(aId) != KErrNotFound)
		{
		TInt err = KErrNone;
		TInt index = IdIndex(aId);

		// Delete the IdentityId from the array, rewrite the identitystream and 
	   	// Only then commit the store
		delete iIdKeyHash[index];
  		iIdKeyHash.Remove(index);
   		iId.Remove(index);
 
		TCleanupItem cleanupStore(RevertStore, iFileStore);
		// write the idkeys to the store.
		TRAP(err, 
			CleanupStack::PushL(cleanupStore);
			WriteIdKeysToStoreL();
			CleanupStack::Pop(iFileStore));
		if(err != KErrNone)
			{
			ReadIdKeysFromStoreL();
   			User::Leave(err);
			}
		}
	else
		{
		User::Leave(KErrNotFound);
		}
	}
	
TBool CPinPluginDB::IsUniquePin(const TDesC8& aIdentityKeyHash) const
	{
	//	Check each iIdKeyHash in the store to determine if aIdentityId already exists
	TInt count = iIdKeyHash.Count();
	TBool isUnique = ETrue;
	for (TInt index = 0; index < count; ++index)
		{
		if (aIdentityKeyHash.CompareF(*iIdKeyHash[index]) == 0)
			{
			isUnique = EFalse;
			break;
			}
		}
	return isUnique;
	}
	
TInt CPinPluginDB::IdIndex(const TIdentityId& aId) const
	{
	TInt count = iId.Count();
	for (TInt index = 0; index < count; ++index)
		{
		if (aId == iId[index])
			{
			return index;
			}
		}
	return KErrNotFound;
	}
	
TIdentityId CPinPluginDB::IdFromPin(const TDesC8& aIdentityKeyHash) const
	{
	TInt count = iIdKeyHash.Count();
	for (TInt index = 0; index < count; ++index)
		{
		if (aIdentityKeyHash.CompareF(*iIdKeyHash[index]) == 0)
			{
			return iId[index];
			}
		}
	return KUnknownIdentity;
	}
	
void CPinPluginDB::OpenStoreL()
	{
	//	Tries to Open a plugin store file on the private path of the process. 
	//	If it cannot find one, create a file with permanent file store
	//	it should initialise iFileStore unless it cannot
	//	create the file/store/streams
	
	TRAPD(result, OpenStoreInFileL(iPluginDBName));

	if (result == KErrNotFound || result == KErrPathNotFound) 
		{		
		// Not yet opened a valid store, either no file to be found, or no valid
		// store in it.
		CreateStoreInFileL(iPluginDBName);
		}
	else if (result != KErrNone)
		{
		// DB gets corrupted or File may be in use. Abort startup.
		User::Leave(result);
		}
	}


void CPinPluginDB::CreateStoreInFileL(const TDesC& aFile)
	{
	TInt r = iFs.MkDirAll(aFile);
	if ((r!=KErrNone) && (r!=KErrAlreadyExists))
		{
		User::Leave(r);
		}
	
	delete iFileStore;
	iFileStore = NULL;

	iFileStore = CPermanentFileStore::ReplaceL(iFs, aFile, EFileRead | EFileWrite | EFileStream | EFileShareExclusive);
	iFileStore->SetTypeL(KPermanentFileStoreLayoutUid);

	TCleanupItem cleanupStore(RevertStore, iFileStore);
	CleanupStack::PushL(cleanupStore);
	
	// Create Identity stream - Currently no Identity created, and no IdentityKeyHash
	RStoreWriteStream identityStream;
	iIdentityStreamId = identityStream.CreateLC(*iFileStore);
	identityStream.WriteUint32L(KNullStreamId.Value()); //contains the id of dataStream
	identityStream.WriteUint32L(0); // Write IdentityId count of zero
	identityStream.CommitL();
	CleanupStack::PopAndDestroy(&identityStream);

	// Create root stream - just contains id of Identity stream
	RStoreWriteStream rootStream;
	iRootStreamId = rootStream.CreateLC(*iFileStore);
	iFileStore->SetRootL(iRootStreamId);
	rootStream.WriteUint32L(iIdentityStreamId.Value());		
	rootStream.CommitL();
	CleanupStack::PopAndDestroy(&rootStream);
	
	iFileStore->CommitL();
	CleanupStack::Pop(iFileStore); 
	}

void CPinPluginDB::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 | EFileStream | EFileShareExclusive));
	
	delete iFileStore;
	iFileStore = NULL;

	iFileStore = CPermanentFileStore::FromL(iFile);		

	// Get the root StreamId
	iRootStreamId = iFileStore->Root();
	if (iRootStreamId == KNullStreamId)
		{
		User::Leave(KErrCorrupt);
		}
	
	RStoreReadStream rootStream;
	rootStream.OpenLC(*iFileStore, iRootStreamId);
	iIdentityStreamId = (TStreamId)(rootStream.ReadUint32L());
	CleanupStack::PopAndDestroy(&rootStream);
	}

// Rewrites the Identity stream (ie the array of IdentityId) to the store
void CPinPluginDB::WriteIdKeysToStoreL()
	{
	TInt count = iId.Count();
	TInt hashCount = iIdKeyHash.Count();
	if (count != hashCount)
		{
		User::Leave(KErrCorrupt);
		}
	
	TStreamId dataStreamId = KNullStreamId;
	if (count > 0)
		{
		RStoreWriteStream dataStream;
		dataStreamId = dataStream.CreateLC(*iFileStore);
		//write the Identity Id key to a data stream
		for (TInt index = 0; index < count; ++index)
			{
			dataStream.WriteUint32L(iId[index]);
			dataStream.WriteUint32L((*iIdKeyHash[index]).Length());
			dataStream.WriteL(*iIdKeyHash[index]);
			}
		dataStream.CommitL();
		CleanupStack::PopAndDestroy(&dataStream); 	
		}
	RStoreReadStream readStream;
	readStream.OpenLC(*iFileStore, iIdentityStreamId);
	TStreamId oldDataStreamId = (TStreamId)(readStream.ReadInt32L());
	CleanupStack::PopAndDestroy(&readStream);
		
	iFileStore->DeleteL(oldDataStreamId);
	
	RStoreWriteStream writeStream;
	writeStream.OpenLC(*iFileStore, iIdentityStreamId);
	writeStream.WriteUint32L(dataStreamId.Value());
	writeStream.WriteInt32L(count);
	writeStream.CommitL();
	CleanupStack::PopAndDestroy(&writeStream); 	
	iFileStore->CommitL();
	CompactStore();
	}
	
void CPinPluginDB::ReadIdKeysFromStoreL()
	{
	iId.Reset();
	iIdKeyHash.ResetAndDestroy();
	
	RStoreReadStream readStream;
	readStream.OpenLC(*iFileStore, iIdentityStreamId);
	TStreamId dataStreamId = (TStreamId)(readStream.ReadInt32L());
	TInt count = readStream.ReadInt32L();
	CleanupStack::PopAndDestroy(&readStream);
	
	if (count > 0)
		{
		RStoreReadStream dataStream;
		dataStream.OpenLC(*iFileStore, dataStreamId);
		for (TInt index = 0; index < count; ++index)
			{
			TIdentityId identityId = (TIdentityId)(dataStream.ReadInt32L());
			iId.AppendL(identityId);
			TInt length = dataStream.ReadInt32L();
			HBufC8* idKeyHash = HBufC8::NewMaxLC(length);
			TPtr8 idKeyHashPtr = idKeyHash->Des();
			dataStream.ReadL(idKeyHashPtr, length);
			iIdKeyHash.AppendL(idKeyHash);
			CleanupStack::Pop(idKeyHash);
			}
		CleanupStack::PopAndDestroy(&dataStream);
		}
	}

void CPinPluginDB::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.
	}


void CPinPluginDB::CompactStore()
	{
	ASSERT(iFileStore);
	TRAP_IGNORE(iFileStore->ReclaimL(); iFileStore->CompactL());
	}