/*

* 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 "CFSCertAppsServer.h"

#include "CCertAppsSession.h"

#include "CCertAppsConduit.h"

#include "fstokencliserv.h"

#include "fstokenutil.h"

#include <certstorepatchdata.h>

#include <certificateapps.h>

#include <u32hal.h> 

#include <e32svr.h>

// Filename where all data is stored

_LIT(KCertAppsFilename,"certclients.dat");

_LIT(KCertAppsFile,"certclients*.dat");

CFSCertAppsServer* CFSCertAppsServer::NewL()

	{

	CFSCertAppsServer* self = new (ELeave) CFSCertAppsServer();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CFSCertAppsServer::CFSCertAppsServer()

	{

	}

void CFSCertAppsServer::ConstructL()

	{

	iConduit = CCertAppsConduit::NewL(*this);

	// Connect to the filesystem

	User::LeaveIfError(iFs.Connect());

	iPatchableConst = KAggregateCertStore;

	#ifdef __WINS__

		// For the emulator allow the constant to be patched via epoc.ini

		UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty,

		(TAny*)"KAggregateCertStore", &iPatchableConst); // read emulator property (if present)

	#endif		

	// Retrieves the store

	OpenStoreL();

	}

CFSCertAppsServer::~CFSCertAppsServer()

	{

	delete iStore;

 	iFs.Close();

	iClients.Close();

	delete iConduit;

	}

CCertAppsSession* CFSCertAppsServer::CreateSessionL()

	{

	return CCertAppsSession::NewL(*iConduit); 

	}

void CFSCertAppsServer::AddL(const TCertificateAppInfo& aClient)

	{

	// see if application already exists. If so, then leave

	if (FindApplication(aClient.Id()))

		{

		User::Leave(KErrAlreadyExists);

		}

	User::LeaveIfError(iClients.Append(aClient));

	TRAPD(err, ReplaceAndCommitL(-1));

	if (err != KErrNone)

		{

		// We must remove the client from iClients if we didn't manage 

		// to add it to the store

		iClients.Remove(iClients.Count() - 1);

		User::Leave(err);

		}

	}

void CFSCertAppsServer::RemoveL(const TUid& aUid)

	{

	// Make sure the application for that uid exists

	TInt i;

	if (!FindApplication(aUid, &i))

		{

		User::Leave(KErrNotFound);

		}

	ReplaceAndCommitL(i);

	// We managed to remove it from the store, so we remove it from the

	// iClients array

	iClients.Remove(i);

	}

TInt CFSCertAppsServer::ApplicationCountL() const

	{

	return iClients.Count();

	}

void CFSCertAppsServer::ApplicationsL(RArray<TCertificateAppInfo>& aAppArray) const

	{

	// Make a copy of the array

	TInt count = iClients.Count();

	for (TInt i = 0; i < count; ++i)

		{

		}

	}

void CFSCertAppsServer::ApplicationL(const TUid& aUid, TCertificateAppInfo& aInfo) const

	{

	const TCertificateAppInfo* app = FindApplication(aUid);

	// leave if not found

	if (!app)

		{

		User::Leave(KErrNotFound);

		}

	// make a copy and return to client

	aInfo = *app;

	}

const TCertificateAppInfo* CFSCertAppsServer::FindApplication(const TUid& aUid, TInt* aIndex) const

	{

	// This helper function tries to find an application with the given

	// Uid. It returns NULL if not found. aIndex returns the index into

	// the array successful

	const TCertificateAppInfo* retVal = NULL;

	TInt end = iClients.Count();

	for (TInt i = 0; i < end; ++i)

		{

		if (iClients[i].Id() == aUid)

			{

			// check if an index is required to be returned

			if (aIndex)

				{

				*aIndex = i;

				}

			retVal = &iClients[i];

			break;

			}

		}

	return retVal;

	}

void CFSCertAppsServer::AggregateStoreFileL(const TDesC& aFile)

	{

	ASSERT(iPatchableConst);

	// if patchable constant is enabled

	// 1. open read-only permanent file store on each file.

	// 2. open certificate client entry list of each store.

	// 3. aggregate the entries.

	RFile file;

	User::LeaveIfError(file.Open(iFs, aFile, EFileRead));

	CleanupClosePushL(file);

	CPermanentFileStore* store = CPermanentFileStore::FromL(file);

	// now owned by store

	CleanupStack::Pop(&file); 

	CleanupStack::PushL(store);

	// Read id of cert list stream

	TStreamId streamId;

	RStoreReadStream stream;

	stream.OpenLC(*store, store->Root());

	stream >> streamId;

	CleanupStack::PopAndDestroy(&stream);

	// Read the certificate's clients entry list

	stream.OpenLC(*store, streamId);

	TInt count = stream.ReadInt32L();

	RArray<TCertificateAppInfo> entryList;

	for (TInt i = 0 ; i < count ; i++)

		{

		TCertificateAppInfo clientInfo;

		stream >> clientInfo;

		entryList.AppendL(clientInfo);

		}

	CleanupStack::PopAndDestroy(&stream);

	CleanupClosePushL(entryList);

	MergeCertificateEntryListL(entryList);

	// cleanup entryList and store instances.

	CleanupStack::PopAndDestroy(2,store);		

	}

TBool CFSCertAppsServer::FindUid(const TUid& aUid)

	{

	TInt end = iClients.Count();

	for (TInt i = 0; i < end; ++i)

		{

		if (iClients[i].Id() == aUid)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

void CFSCertAppsServer::MergeCertificateEntryListL(const RArray<TCertificateAppInfo>& aSourceList)

	{

	ASSERT(iPatchableConst);

	// if patchable constant is enabled

	TInt sourceCount = aSourceList.Count();

	for(TInt i = 0; i < sourceCount; i++)

		{

		// compare if the uid pre-exists in the composite list.

		if (!FindUid(aSourceList[i].Id()))

			{

			// Aggregation: append this entry to the composite list.

			iClients.AppendL(aSourceList[i]);

			}

		// Eclipsing: Higher order store cert client entries with same UIDs take precedence over lower order  

		// store cert client entries therefore the later are not included in the composite cert client entry list.

		// Higher order store client entries are ones which are aggregated prior to other client entries. 

		}

	}

void CFSCertAppsServer::OpenCompositeStoreL(const TDesC& aFilename)

	{

	ASSERT(iPatchableConst);

	// 1. create a new empty certstore file under system drive with the name 'certclients.dat'. 

	// 2. this will be the composite store and the instances 'iEntryList' and 'iStore' will be initialized with this.

	// 3. make private rom drive path where certstore files are located.

	// 4. collect the certstore file names in a list.

	// 5. make private rom drive path on each file.

	// 6. populate the composite store with certificate client entries present in rom drive certstores.

	// create a new empty certstore file 'certclients.dat' under system drive.

	CreateStoreL(aFilename);	

	// restore permanent store on it 

	// this will be the composite store after complete aggregation. 

	ReadStoreContentsL(aFilename);

	RBuf romFilename;

	romFilename.CreateL(KMaxFilenameLength);

	CleanupClosePushL(romFilename);

	FileUtils::MakePrivateROMFilenameL(iFs, KCertAppsFile, romFilename);

	CDir* filenameList = NULL;

	User::LeaveIfError(iFs.GetDir(romFilename, KEntryAttNormal, ESortByName|EDescending, filenameList));

	CleanupStack::PopAndDestroy(&romFilename);

	CleanupStack::PushL(filenameList);

	TInt count = filenameList->Count();

	// aggregate ROM stores iteratively 

	for(TInt index = 0; index < count; index++)		

		{

		RBuf fileName;

		fileName.CreateL(KMaxFileName);

		CleanupClosePushL(fileName);	

		FileUtils::MakePrivateROMFilenameL(iFs, ((*filenameList)[index]).iName, fileName);

		// if there is any corrupt certstore present then we will simply ignore its

		// aggregation and proceed with aggregating remaining stores.

		TRAP_IGNORE(AggregateStoreFileL(fileName));

		CleanupStack::PopAndDestroy(&fileName);	

		}

	// write the 'iClients' to the composite store.	

	ReplaceAndCommitL(-1);	

	CleanupStack::PopAndDestroy(filenameList);

	}

// this logic should be handled by a superclass or mixin

void CFSCertAppsServer::OpenStoreL()

	{

	RBuf filename;

	filename.CreateL(KMaxFilenameLength);

	CleanupClosePushL(filename);		

	FileUtils::MakePrivateFilenameL(iFs, KCertAppsFilename, filename);

	// Attempt to open the store

	// need to test opening corrupt store

	TRAPD(err, ReadStoreContentsL(filename));

	if (err == KErrNoMemory || err == KErrInUse)

		{

		User::Leave(err);

		}

	if (err != KErrNone)

		{

		// Couldn't open RAM based store, copy from ROM	

		FileUtils::EnsurePathL(iFs, filename);		

		if(iPatchableConst)

			{

			OpenCompositeStoreL(filename);

			}

		else

			{

			RBuf romFilename;

			romFilename.CreateL(KMaxFilenameLength);

			CleanupClosePushL(romFilename);			

			FileUtils::MakePrivateROMFilenameL(iFs, KCertAppsFilename, romFilename);

			if (FileUtils::ExistsL(iFs, romFilename))

				{

				FileUtils::CopyL(iFs, romFilename, filename);

				}

			else

				{

				CreateStoreL(filename);

				}

			CleanupStack::PopAndDestroy(&romFilename);

			//Retry open, and leave on failure

			ReadStoreContentsL(filename);			

			}

		}

	CleanupStack::PopAndDestroy(&filename);

	ASSERT(iStore);

	}

void CFSCertAppsServer::ReadStoreContentsL(const TDesC& aFilename)

	{

	// Make sure the store is not read-only

	User::LeaveIfError(iFs.SetAtt(aFilename, KEntryAttNormal, KEntryAttReadOnly));

	RFile file;

	User::LeaveIfError(file.Open(iFs, aFilename, EFileRead | EFileWrite));

	CleanupClosePushL(file);

	CPermanentFileStore* store = CPermanentFileStore::FromL(file);

	CleanupStack::Pop(&file);

	CleanupStack::PushL(store);

	// now read the root stream to get the id of our main stream

	RStoreReadStream readStream;

	readStream.OpenLC(*store, store->Root());

	readStream >> iId;	// This can leave

	CleanupStack::PopAndDestroy(&readStream);

	// finally, restore the stream which contains the client arrays.

	// First long is the number of entries, then each entry 

	readStream.OpenLC(*store, iId);

	TInt count = readStream.ReadInt32L();

	for (TInt i = 0; i < count; ++i)

		{

		TCertificateAppInfo clientInfo;

		readStream >> clientInfo;

		User::LeaveIfError(iClients.Append(clientInfo));

		}

	CleanupStack::PopAndDestroy(&readStream);

	ASSERT(!iStore);

	iStore = store;

	CleanupStack::Pop(store);

	}

void CFSCertAppsServer::CreateStoreL(const TDesC& aFilename)

	{

	// If for some reason we can't complete the creation of the store, we want

	// to be sure that we don't leave a half-constructed store on the device

	// as we will then be in trouble when we try to open the store

	TCleanupItem deleteStoreFile(DeleteStoreFile, this);

	CleanupStack::PushL(deleteStoreFile);

	iFs.Delete(aFilename); // ignore errors

	RFile file;

	User::LeaveIfError(file.Create(iFs, aFilename, EFileWrite));

	CleanupClosePushL(file);

	CPermanentFileStore* store = CPermanentFileStore::NewL(file);

	CleanupStack::Pop(&file); // now owned by store

	CleanupStack::PushL(store);

	store->SetTypeL(KPermanentFileStoreLayoutUid);

	RStoreWriteStream clientsStream;

	TStreamId id = clientsStream.CreateLC(*store);

	WriteClientArrayL(clientsStream);

	CleanupStack::PopAndDestroy(&clientsStream);

	RStoreWriteStream rootStream;

	TStreamId rootId = rootStream.CreateLC(*store);

	rootStream << id;

	rootStream.CommitL();

	CleanupStack::PopAndDestroy(&rootStream);

	store->SetRootL(rootId);

	store->CommitL();

	CleanupStack::PopAndDestroy(store);

	CleanupStack::Pop(); // deleteStoreFile

	}

void CFSCertAppsServer::RevertStore(TAny* aStore)

	{

	// this is a CleanupItem

	__ASSERT_DEBUG(aStore, PanicServer(EPanicNotInitialised));

	CPermanentFileStore* store = reinterpret_cast<CPermanentFileStore *>(aStore);

	store->Revert();

	}

void CFSCertAppsServer::DeleteStoreFile(TAny *aThis)

	{

	__ASSERT_DEBUG(aThis, PanicServer(EPanicNotInitialised));

	// should call non-static member

	CFSCertAppsServer* self = reinterpret_cast<CFSCertAppsServer*>(aThis);

	// Something strange has occurred if we can't get the ramStorePath.

	// Since we can't leave we have to ignore the error

	TFileName ramStorePath;

	TRAPD(err, FileUtils::MakePrivateFilenameL(self->iFs, KCertAppsFilename, ramStorePath));

	if (!err)

		{

		self->iFs.Delete(ramStorePath);

		}

	}

void CFSCertAppsServer::ReplaceAndCommitL(TInt aExcludedIndex)

	{

	TCleanupItem cleanupStore(RevertStore, iStore);

	CleanupStack::PushL(cleanupStore);

	// compact the store 

	iStore->ReclaimL(); // do we need to reclaim

	iStore->CompactL();

	RStoreWriteStream outputStream;

	outputStream.ReplaceLC(*iStore, iId);

	WriteClientArrayL(outputStream, aExcludedIndex);

	CleanupStack::PopAndDestroy(&outputStream);

	iStore->CommitL();

	CleanupStack::Pop(); // cleanupStore

	}

void CFSCertAppsServer::WriteClientArrayL(RWriteStream& stream, TInt aExcludedIndex) const

	{

	// the count of elements to be written is the arraycount - 1 if we exclude 

	// something, otherwise the arraycount

	TInt arrayEnd = iClients.Count();

	TInt count = (aExcludedIndex < 0) ? (arrayEnd) : (arrayEnd - 1);

	stream.WriteInt32L(count);

	for (TInt i = 0; i < arrayEnd; ++i)

		{

		if (i != aExcludedIndex)

			{

			stream << iClients[i];	// This can leave

			}

		}

	stream.CommitL();

	}