/*
* 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);
		}
	}