/*

 * Copyright (c) 2005-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: 

 *

 */

 #include "CSWICertStoreImpl.h"

 #include "CSWICertStoreEntryList.h"

 #include "CSWICertStoreEntry.h"

 #include "CSWICertStoreTokenType.h"

 #include "CSWICertStoreToken.h"

 #include "unifiedcertstore.h"

 #include "log.h"

 #include <certstorepatchdata.h>

 #include <ccertattributefilter.h>

 #include <f32file.h>

 #include <u32hal.h> 

 #include <e32svr.h>

 _LIT(KSWICertStoreZFilename,"z:\\resource\\swicertstore.dat");

 _LIT(KSWIWritableCertStorePath,"!:\\resource\\swicertstore\\dat\\");

 _LIT(KSWIROMCertStoreFilenamePattern,"z:\\resource\\swicertstore*.dat");

 /////////////////////////////////////////////////////////////////////////////////////////

 //CFSCertStoreServer

 /////////////////////////////////////////////////////////////////////////////////////////

 CSWICertStoreImpl* CSWICertStoreImpl::NewL(MCTToken& aToken, RFs& aFs)

 	{

 	CSWICertStoreImpl* self = new (ELeave) CSWICertStoreImpl(aToken, aFs);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CSWICertStoreImpl::CSWICertStoreImpl(MCTToken& aToken, RFs& aFs) :

         CActive(EPriorityStandard), iToken(aToken), iFs(aFs)

 	{

 	CActiveScheduler::Add(this);

 	}

 void CSWICertStoreImpl::ConstructL()

 	{

 	TInt err = iSwicertstoreProperty.Attach(KUnifiedCertStorePropertyCat,

 											EUnifiedCertStoreFlag, EOwnerThread);

 	User::LeaveIfError(err);

 	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		

 	// if patchable constant is enabled

 	if(iPatchableConst)

 		{

 		// Setup composite ROM Certstore

 		SetupCompositeROMCertStoreL();

 		}

 	else

 		{

 		// Setup the ROM CertStore

 		SetupROMCertStoreL();		

 		}

 	// Setup the Writable CertStore

 	// Bear in mind we need to trap NewL(), OpenLC() etc.

 	// Any error occurs, it should still setup the z:\ certstore

 	TRAP_IGNORE(SetupWritableCertStoreL());

 	// aggregate ROM composite certstore and writable certstore if patchable constant is enabled

 	if(iPatchableConst)

 		{

 		if(iCEntryList)

 			{

 			// ETrue to indicate that we are passing 'iZEntryList'.

 			// This action will remove duplicate entries from 'iZEntryList'.

 			MergeCertificateEntryListsL(*iZEntryList, ETrue);	

 			}

 		}

 	// Subscribe to the Property

 	iSwicertstoreProperty.Subscribe(iStatus);

 	SetActive();

 	}

 void CSWICertStoreImpl::DoCancel()

 	{

 	// Cancel outstanding request

     iSwicertstoreProperty.Cancel();

 	}

 void CSWICertStoreImpl::RunL()

 	{

 	// Resubscribe before processing new value to prevent missing updates

 	iSwicertstoreProperty.Subscribe(iStatus);

 	SetActive();

 	// Bear in mind we need to trap NewL(), OpenLC() etc.

 	TRAP_IGNORE(SetupWritableCertStoreL());

 	}

 void CSWICertStoreImpl::SetupWritableCertStoreL()

 	{

 	TInt err = KErrNone;

  	delete iCEntryList;

 	iCEntryList = NULL;

 	// The attached file will be freed as well.

 	delete iCStore;

 	iCStore = NULL;

  	do

  		{

  		// Open the store if it is there

  		RFile file;

  		CDir* entryList = NULL;

 		TPath writableSwiCertStorePath(KSWIWritableCertStorePath);

 		TChar systemDriveChar = RFs::GetSystemDriveChar();

 		writableSwiCertStorePath[0] = systemDriveChar;

 		if (KErrNone == iFs.GetDir (writableSwiCertStorePath, KEntryAttNormal,

 		 	ESortByName|EDirsFirst, entryList))

 				{

 				if (entryList)

 		                {

 						CleanupStack::PushL(entryList);

 						TFileName certstoreFile;

 						TInt count = entryList->Count();

 						if (count > 0)

 					            {

 								// Get the highest version certstore file

 							 	const TEntry& entry = (*entryList)[count - 1];

 							 	certstoreFile.Append(writableSwiCertStorePath);

 							 	certstoreFile.Append(entry.iName);

 							 	CleanupStack::PopAndDestroy(1, entryList);

 							 	}

 						else

 					            {

 								CleanupStack::PopAndDestroy(1, entryList);

 							 	// No certstore in this directory

 							 	// Currently there should not have any directory in this path

 							 	return;

 							 	}

 						err = file.Open(iFs, certstoreFile, EFileShareReadersOnly);

 						if (err != KErrNone && err != KErrNotFound)

 								{

 								// Log the error to the system file.

 								DEBUG_PRINTF2(_L8("Error Opening SWI writable certstore: %S."), &certstoreFile);

 							 	return;

 							 	}

 						 if (err == KErrNone)

 					            {

 							 	// File exist

 							 	CleanupClosePushL(file);

 							 	TRAP_IGNORE(iCStore = CPermanentFileStore::FromL(file));

 							 	if (iCStore)

 							    		{

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

 										// Read id of cert list stream

 								 		TStreamId streamId;

 								 		RStoreReadStream stream;

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

 										stream >> streamId;

 										CleanupStack::PopAndDestroy(&stream);

 										// Read the certificate list

 										RStoreReadStream entryStream;

 										entryStream.OpenLC(*iCStore, streamId);

 										iCEntryList = CSWICertStoreEntryList::NewL(entryStream, iToken, iCertIndex);

 								 		CleanupStack::PopAndDestroy(&entryStream);

 								 		// Record the writable certstore index

 								 		// The index will then be used to set the tokenId in the

 								 		// in handle, so to make the handle unique.

 								 		iCertIndex += iCEntryList->Count();

 								 		}

 						 		else

 							         	{

 										// The file format might not comply to the CPermanentFileStore format

 										CleanupStack::PopAndDestroy(&file);

 								 		// Log the error to the system file.

 								 		DEBUG_PRINTF2(_L8("Error Opening SWI writable certstore: %S."), &certstoreFile);

 								 		return;

 							         	}   

 					            }

 		                }

 				}

  		}while (err == KErrNotFound);  // There is a very slight chance that the file has been deleted

 	}

 void CSWICertStoreImpl::MergeCertificateEntryListsL(const CSWICertStoreEntryList& aSourceList, TBool aIsZEntryList)

 	{

 	ASSERT(iPatchableConst);

 	// if patchable constant is enabled

 	TInt sourceCount = aSourceList.Count();

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

 		{

 		if(!aIsZEntryList)

 			{

 			if (!iZEntryList->LabelExists(aSourceList.GetByIndex(i).CertInfo().Label()))

 				{

 				// Aggregation: Append this entry in the ROM composite list 

 				const CSWICertStoreEntry& entry = aSourceList.GetByIndex(i);

 				CSWICertStoreEntry* newEntry = CSWICertStoreEntry::NewL(entry.CertInfo(),

 																entry.CertificateApps(),

 																entry.Trusted(),

 																entry.DataStreamId(),

 																entry.CertMetaInfo(), 

 																entry.StoreIndex());

 				CleanupStack::PushL(newEntry);

 				iZEntryList->AppendL(newEntry);

 				// iZEntryList has taken ownership

 				CleanupStack::Pop(newEntry); 

 				}

 			// Eclipsing: Higher order store certificates with same labels take precedence over lower order store certificates.

 			// therefore the later are not included in the composite certificate entry list.

 			// N.B iCertIndex will not give total count of certificates because of Eclipsing mechanism.

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

 			}

 		else

 			{

 			// remove duplicate label entries from the 'iZEntryList'

 			if (iCEntryList->LabelExists(aSourceList.GetByIndex(i).CertInfo().Label()))

 				{

 				// Remove entries from iZEntryList having same labels as in iCEntryList.

 				iZEntryList->Remove(i);

 				}

 			}

 		}

 	}

 void CSWICertStoreImpl::SetupCompositeROMCertStoreL()

 	{

 	ASSERT(iPatchableConst);

 	// Collect the file present in ROM certstore private directory.

 	//The files in this list will be in descending order by name.

 	CDir* filenameList = NULL;

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

 	CleanupStack::PushL(filenameList);

 	TInt count = filenameList->Count();

 	TStreamId streamId;

 	// make full path to the certstore files residing on ROM drive	

 	// N.B filenameList will contain filenames in descending order.

 	RFile file;

 	RStoreReadStream stream;

 	// create an empty list, this will be the composite certificate entry list

 	iZEntryList = CSWICertStoreEntryList::NewL();

 	// the 'corruptCount' is used for proper correctly referencing valid certstores   

 	TInt corruptCount=0;

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

 		{

 		RBuf romFile;

 		romFile.CreateL(KMaxFileName);

 		CleanupClosePushL(romFile);

 		romFile.Append(_L("z:\\resource\\"));

 		romFile.Append(((*filenameList)[i]).iName);

 		User::LeaveIfError(file.Open(iFs,romFile,EFileShareReadersOnly));

 		CleanupClosePushL(file);

 		// open and append the store in array of stores

 		CPermanentFileStore* store = NULL;

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

 		// aggregation and proceed with aggregating remaining stores.

 		// ownership is transfered to 'iZArrayOfStores' 

 		TRAPD(err, store = CPermanentFileStore::FromL(file));

 		if(err != KErrNone)

 			{

 			corruptCount++;

 			//cleanup file and romFile.

 			CleanupStack::PopAndDestroy(2, &romFile);

 			continue;

 			}

 		iZArrayOfStores.AppendL(store);

 		TInt index = i - corruptCount;

 		// open the root stream containing the streamId of info stream.

 		stream.OpenLC(*(iZArrayOfStores)[index],(iZArrayOfStores[index])->Root());

 		stream >> streamId;

 		CleanupStack::PopAndDestroy(&stream);

 		// re-open the info stream containing the certificates entry list.

 		stream.OpenLC(*(iZArrayOfStores)[index],streamId);

 		// store index for these entries will be 'index'.

 		// iCertIndex will be 0 for the first certificate entry list passed.

 		CSWICertStoreEntryList* temp_list = CSWICertStoreEntryList::NewL(stream, iToken,iCertIndex,index);

 		// increment to have unique certificate Ids allocation.

 		iCertIndex += temp_list->Count();

 		CleanupStack::PushL(temp_list);

 		MergeCertificateEntryListsL(*temp_list);

 		//temp_list, stream, file and romFile.

 		CleanupStack::PopAndDestroy(4, &romFile);

 		} 

 	CleanupStack::PopAndDestroy(filenameList);

 	}

 void CSWICertStoreImpl::SetupROMCertStoreL()

 	{

 	// Open the store

 	RFile file;

 	User::LeaveIfError(file.Open(iFs, KSWICertStoreZFilename, EFileShareReadersOnly));

 	CleanupClosePushL(file);

 	iZStore = CPermanentFileStore::FromL(file);

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

 	// Read id of cert list stream

 	TStreamId streamId;

 	RStoreReadStream stream;

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

 	stream >> streamId;

 	CleanupStack::PopAndDestroy(&stream);

 	// Read the certificate list

 	RStoreReadStream entryStream;

 	entryStream.OpenLC(*iZStore, streamId);

 	iZEntryList = CSWICertStoreEntryList::NewL(entryStream, iToken);

 	CleanupStack::PopAndDestroy(&entryStream);

 	// set the valid indexes of writable certstore

 	iCertIndex = iZEntryList->Count();

 	}

 CSWICertStoreImpl::~CSWICertStoreImpl()

 	{

 	Cancel();

 	iSwicertstoreProperty.Close();

 	delete iCEntryList;

 	delete iZEntryList;

 	delete iCStore;

 	delete iZStore;

 	iZArrayOfStores.ResetAndDestroy();

 	}

 void CSWICertStoreImpl::ListL(RMPointerArray<CCTCertInfo>& aCerts,

 			      const CCertAttributeFilter& aFilter)

 	{

 	if (iCEntryList)

 	        {

 			FilterCertificateListL(aCerts, aFilter, *iCEntryList);

 			}

 	FilterCertificateListL(aCerts, aFilter, *iZEntryList);

 	}

 CCTCertInfo* CSWICertStoreImpl::GetCertL(const TCTTokenObjectHandle& aHandle)

 	{

 	TBool isCEntryHandle = EFalse;

 	const CSWICertStoreEntry* entry = GetCSWICertStoreEntryL(aHandle, isCEntryHandle);	

 	return CCTCertInfo::NewL(entry->CertInfo());

 	}

 void CSWICertStoreImpl::ApplicationsL(const TCTTokenObjectHandle& aHandle, RArray<TUid>& aApplications)

 	{

 	TBool isCEntryHandle = EFalse;

 	const CSWICertStoreEntry* entry = GetCSWICertStoreEntryL(aHandle, isCEntryHandle);

 	const RArray<TUid>& apps = entry->CertificateApps();

 	TInt count = apps.Count();

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

 		{

 		User::LeaveIfError(aApplications.Append(apps[i]));

 		}

 	}

 TBool CSWICertStoreImpl::IsApplicableL(const TCTTokenObjectHandle& aHandle, TUid aApplication)

 	{

 	TBool isCEntryHandle = EFalse;

 	const CSWICertStoreEntry* entry = GetCSWICertStoreEntryL(aHandle, isCEntryHandle);

 	return entry->IsApplicable(aApplication);

 	}

 TBool CSWICertStoreImpl::TrustedL(const TCTTokenObjectHandle& aHandle)

 	{

 	TBool isCEntryHandle = EFalse;	

 	const CSWICertStoreEntry* entry = GetCSWICertStoreEntryL(aHandle, isCEntryHandle);

 	return entry->Trusted();

 	}

 void CSWICertStoreImpl::RetrieveL(const TCTTokenObjectHandle& aHandle, TDes8& aEncodedCert)

 	{

 	TBool isCEntryHandle = EFalse;

 	const CSWICertStoreEntry* entry = GetCSWICertStoreEntryL(aHandle, isCEntryHandle);

 	RStoreReadStream stream;

 	if (iCEntryList && isCEntryHandle)

 		{

 		stream.OpenLC(*iCStore, entry->DataStreamId());

 		}

 	else

 	    {

 	    // if patchable constant is enabled

 	    if (iPatchableConst)

 	    	{

 	    	stream.OpenLC(*(iZArrayOfStores[entry->StoreIndex()]), entry->DataStreamId());

 	    	}

 	    else

 	    	{

 	    	stream.OpenLC(*iZStore, entry->DataStreamId());

 	    	}

 		}

 	TInt size = entry->CertInfo().Size();

 	if (aEncodedCert.MaxLength() < size)

 			{

 			User::Leave(KErrOverflow);

 			}

 	stream.ReadL(aEncodedCert, size);

 	CleanupStack::PopAndDestroy(&stream);

 	}

 const TCertMetaInfo& CSWICertStoreImpl::CertMetaInfoL(const TCTTokenObjectHandle& aHandle) const

 	{

 	TBool isCEntryHandle = EFalse;

 	const CSWICertStoreEntry* entry = GetCSWICertStoreEntryL(aHandle, isCEntryHandle);

 	return entry->CertMetaInfo(); 

 	}

 const CSWICertStoreEntry* CSWICertStoreImpl::GetCSWICertStoreEntryL(const TCTTokenObjectHandle& aHandle, TBool& aCEntryHandle) const

 	{

 	if (iCEntryList)

 	        {

 			const CSWICertStoreEntry* entry = NULL;

 			TRAPD (retCode, entry = &(iCEntryList->GetByHandleL(aHandle)));

 			if (entry && (retCode == KErrNone))

 			        {

 			        aCEntryHandle = ETrue;

 					return entry;

 					}

 			}

 	return &iZEntryList->GetByHandleL(aHandle);

 	}

 void CSWICertStoreImpl::AddIfMatchesFilterL(RMPointerArray<CCTCertInfo>& aCerts, const CCertAttributeFilter& aFilter, const CSWICertStoreEntry& aEntry)

 	{

 	const CCTCertInfo& certInfo = aEntry.CertInfo();

 	TBool accept = ETrue;

 	if (aFilter.iUidIsSet)

 		{

 		accept = aEntry.IsApplicable(aFilter.iUid);

 		}

 	if (aFilter.iFormatIsSet && accept)

 		{

 		accept = (aFilter.iFormat == certInfo.CertificateFormat());

 		}

 	if (aFilter.iOwnerTypeIsSet && accept)

 		{

 		accept = (aFilter.iOwnerType == certInfo.CertificateOwnerType());

 		}

 	if (aFilter.iSubjectKeyIdIsSet && accept)

 		{

 		accept = (aFilter.iSubjectKeyId == certInfo.SubjectKeyId());

 		}

 	if (aFilter.iLabelIsSet && accept)

 		{

 		accept = (aFilter.iLabel == certInfo.Label());

 		}

 	if (accept)

 		{

 		CCTCertInfo* newCertInfo = CCTCertInfo::NewLC(certInfo);

 		User::LeaveIfError(aCerts.Append(newCertInfo));

 		CleanupStack::Pop(newCertInfo);

 		}

 	}

 void CSWICertStoreImpl::FilterCertificateListL(RMPointerArray<CCTCertInfo>& aCerts,

 			   const CCertAttributeFilter& aFilter, const CSWICertStoreEntryList& aEntryList)

 	{

 	TInt count = aEntryList.Count();

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

 		{

 		const CSWICertStoreEntry& entry = aEntryList.GetByIndex(index);

 		AddIfMatchesFilterL(aCerts, aFilter, entry);

 		}

 	}