/*

* Copyright (c) 1998-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 "test1certstore.h"

#include "tadditionalstoremappings.h"

#include <signed.h>

#include <x509cert.h>

#include <wtlscert.h>

#include <x509keys.h>

#include <ecom/implementationproxy.h>

_LIT(KName1, "Test store 1");

_LIT(KName2, "Test store 2");

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

//CFileCertStore

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

CTest1CertStore* CTest1CertStore::NewL(RFs& aFs,

									   CTest1CertStoreToken& aToken, 

									   const TDesC& aFileName,

									   TFileMode aMode)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aFileName, aMode);

	CleanupStack::Pop(self);

	return self;

	}

MCTToken& CTest1CertStore::Token()

	{

	return iToken;

	}

void CTest1CertStore::DoRelease()

	{

	if (iToken.Label() == KName1)

		{

		iToken.iRefCountInterface--;

		if (!iToken.iRefCountInterface)

			{

			delete this;

			}

		}

	else if (iToken.Label() == KName2)

		{

		iToken.iRefCountInterface2--;

		if (!iToken.iRefCountInterface2)

			{

			delete this;

			}

		}

	}

void CTest1CertStore::List(RMPointerArray<CCTCertInfo>& aCertInfos,

						  const CCertAttributeFilter& aFilter,

						  TRequestStatus& aStatus)

	{

	iOriginalRequestStatus = &aStatus;

	aStatus = KRequestPending;

	iCertInfos = &aCertInfos;

	iFilter = &aFilter;

	//Iinitialize the ketstore and then list the key info

	if (iFilter->iKeyUsage != EX509UsageAll)

		{

		// We have to initialize the unified key store

		TRAPD(err, iUnifiedKeyStore = CUnifiedKeyStore::NewL(iFs));

		if (err != KErrNone)

			{

			User::RequestComplete(iOriginalRequestStatus, err);

			iOriginalRequestStatus = 0;

			}

		else

			{

			iUnifiedKeyStore->Initialize(iStatus);

			iState = EGetKeyInfos;

			SetActive();

			}

		}

	else

		{

		iState = EList;

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		SetActive();

		}

	}

void CTest1CertStore::CancelList()

	{

	Cancel();

	}

void CTest1CertStore::GetCert(CCTCertInfo*& aCertInfo,

							 const TCTTokenObjectHandle& aHandle,

							 TRequestStatus& aStatus)

	{

	TInt err = KErrNotFound;

	if ((aHandle.iTokenHandle == iToken.Handle()) &&

		(aHandle.iObjectId < iCerts->Count()))

		{

		TRAP(err, aCertInfo = CCTCertInfo::NewL(iCerts->Entry(aHandle.iObjectId)));

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelGetCert()

	{

	// Nothing to do because GetCert is not asynchronous.

	}

void CTest1CertStore::Applications(const CCTCertInfo& aCertInfo,

								  RArray<TUid>& aApplications,

								  TRequestStatus& aStatus)

	{

	TInt err = KErrNone;

	TInt index = iCerts->Index(aCertInfo);

	if (index != KErrNotFound)

		{

		const RArray<TUid>& apps = iCerts->Mapping(index)->CertificateApps();

		TInt end = apps.Count();

		for (TInt i = 0; (i < end) && (err == KErrNone); i++)

			{

			err = aApplications.Append(apps[i]);

			}

		}

	else

		{

		err = index;

		}

	if (err != KErrNone)

		{

		aApplications.Reset();

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelApplications()

	{

	}

void CTest1CertStore::IsApplicable(const CCTCertInfo& aCertInfo,

								  TUid aApplication, 

								  TBool& aIsApplicable,

								  TRequestStatus& aStatus)

	{

	TInt index = iCerts->Index(aCertInfo);

	if (index != KErrNotFound)

		{

		const RArray<TUid>& apps = iCerts->Mapping(index)->CertificateApps();

		TInt end = apps.Count();

		TInt i;

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

			{

			if (apps[i] == aApplication)

				{

				break;

				}

			}

		if (i == end)

			{

			aIsApplicable = EFalse;

			}

		else

			{

			aIsApplicable = ETrue;

			}

		index = KErrNone;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, index);

	}

void CTest1CertStore::CancelIsApplicable()

	{

	// Nothing to do because IsApplicable is not asynchronous.

	}

void CTest1CertStore::Trusted(const CCTCertInfo& aCertInfo,

							 TBool& aTrusted, 

							 TRequestStatus& aStatus)

	{	

	TInt index = iCerts->Index(aCertInfo);

	if (index != KErrNotFound)

		{

		aTrusted = iCerts->Mapping(index)->Trusted();

		index = KErrNone;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, index);

	}

void CTest1CertStore::CancelTrusted()

	{

	// Nothing to do because Trusted is not asynchronous.

	}

void CTest1CertStore::Retrieve(const CCTCertInfo& aCertInfo,

							  TDes8& aCertificate,

							  TRequestStatus& aStatus)

	{

#ifdef CERTSTORE_SOFTWARE_ASYNCH

	// perform an asynchronous retrieval of the certificate

	iOriginalRequestStatus = &aStatus;

	aStatus = KRequestPending;

	iAsynchCertInfo = &aCertInfo;

	iAsynchCertificate = &aCertificate;

	iState = ERetrieve;

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

#else

	RetrieveNow(aCertInfo,aCertificate,aStatus);

#endif

	}

void CTest1CertStore::RetrieveNow(const CCTCertInfo& aCertInfo,

							  TDes8& aCertificate,

							  TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	TInt err;

	TInt index = iCerts->Index(aCertInfo);

	if (index == KErrNotFound)

		{

		err = KErrNotFound;

		}

	else

		{

		CFileCertStoreMapping* mapping = NULL;

		mapping = iCerts->Mapping(index);

		err = index;

		if (mapping)

			{

			TRAP(err, DoLoadL(aCertificate, *mapping));

			}

		}

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelRetrieve()

	{

	}

void CTest1CertStore::Capabilities(const CCTCertInfo& /*aCertInfo*/, TCapabilitySet& /*aCapbilitiesOut*/,

								  TRequestStatus& aStatus)

	{

	// currently not supported

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNotSupported);

	}

void CTest1CertStore::CancelCapabilities()

	{

	// Nothing to do because Capabilities is not asynchronous.

	}

void CTest1CertStore::IsMandatory(const CCTCertInfo& /*aCertInfo*/, TBool& /*aMandatoryOut*/,

								 TRequestStatus& aStatus)

	{

	// currently not supported

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNotSupported);

	}

void CTest1CertStore::CancelIsMandatory()

	{

	// Nothing to do because IsMandatory is not asynchronous.

	}

void CTest1CertStore::Remove(const CCTCertInfo& aCertInfo, TRequestStatus& aStatus)

	{

	// This removes the certificate from the file store.

	TRAPD(err, DoRemoveL(aCertInfo));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelRemove()

	{

	}

void CTest1CertStore::SetApplicability(const CCTCertInfo& aCertInfo,

									  const RArray<TUid>& aTrusters,

									  TRequestStatus& aStatus)

	{

	TRAPD(err, DoSetApplicabilityL(aCertInfo, aTrusters));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelSetApplicability()

	{

	}

void CTest1CertStore::SetTrust(const CCTCertInfo& aCertInfo, 

							  TBool aTrusted, 

							  TRequestStatus& aStatus)

	{

	TRAPD(err, DoSetTrustL(aCertInfo, aTrusted));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelSetTrust()

	{

	// Nothing to do because SetTrust is not asynchronous.

	}

void CTest1CertStore::SetCapabilities(const CCTCertInfo& /*aCertInfo*/, const TCapabilitySet& /*aCapabilities*/, 

									 TRequestStatus& aStatus)

	{

	// currently not supported

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNotSupported);

	}

void CTest1CertStore::CancelSetCapabilities()

	{

	// Nothing to do because SetCapabilities is not asynchronous.

	}

void CTest1CertStore::SetMandatory(const CCTCertInfo& /*aCertInfo*/, TBool /*aMandatory*/,

								  TRequestStatus& aStatus)

	{

	// currently not supported

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNotSupported);

	}

void CTest1CertStore::CancelSetMandatory()

	{

	// Nothing to do because SetMandatory is not asynchronous.

	}

void CTest1CertStore::RevertStore(TAny* aStore)

	{

	//this is a CleanupItem

	CPermanentFileStore* store = REINTERPRET_CAST(CPermanentFileStore*, aStore);

	store->Revert();

	}

void CTest1CertStore::DeleteFile(TAny* aThis)

	{

	CTest1CertStore* self = REINTERPRET_CAST(CTest1CertStore*, aThis);

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName driveName(sysDrive.Name());

	TBuf<128> certStoreDefaultFullPath (driveName);

	certStoreDefaultFullPath.Append(_L("\\system\\data\\cacerts.dat"));

	self->iFile.Close();

	self->iFs.Delete(certStoreDefaultFullPath);

	}

CTest1CertStore::~CTest1CertStore()

	{

	Cancel();

	if (iStore != NULL)

		{

#ifdef _DEBUG

#else		

		TInt err;

		TRAP(err, iStore->ReclaimL());

		TRAP(err, iStore->CompactL());

		if (err == KErrNone)

			{

			TRAP(err, iStore->CommitL());

			}

#endif

		delete iStore;

		}

	iFile.Close();

	delete iCerts;

	iKeyInfos.Close();

	delete iUnifiedKeyStore;

	}

void CTest1CertStore::DoSetApplicabilityL(const CCTCertInfo& aCertInfo,

										 const RArray<TUid>& aTrusters)

	{

	TInt index = iCerts->Index(aCertInfo);

	if (index == KErrNotFound)

		{

		User::Leave(index);

		}

	CFileCertStoreMapping* mapping = iCerts->Mapping(index);

	const RArray<TUid>& trusters = mapping->CertificateApps(); //oldEntry->Trusters();

	RArray<TUid>* oldTrusters = new(ELeave) RArray<TUid>();

	CleanupStack::PushL(oldTrusters);

	CleanupClosePushL(*oldTrusters);

	TInt iEnd = trusters.Count();

	TInt i;

	for (i = 0; i < iEnd; i++)

		{

		User::LeaveIfError(oldTrusters->Append(trusters[i]));

		}

	RArray<TUid>* newTrusters = new (ELeave) RArray<TUid>;

	CleanupStack::PushL(newTrusters);

	CleanupClosePushL(*newTrusters);

	for (i = 0 ; i < aTrusters.Count() ; ++i)

		{

		User::LeaveIfError(newTrusters->Append(aTrusters[i]));		

		}

	mapping->SetCertificateApps(newTrusters);

	CleanupStack::Pop(2, newTrusters);

	TRAPD(err, UpdateStoreL());

	CleanupStack::Pop(2);	// *oldTrusters, oldTrusters

	if (err != KErrNone)

		{

		// If there is an error, we undo the change in oldEntry

		mapping->SetCertificateApps(oldTrusters);

		}

	else

		{

		oldTrusters->Close();

		delete oldTrusters;

		}

	}

void CTest1CertStore::DoSetTrustL(const CCTCertInfo& aCertInfo,

								 TBool aTrusted)

	{

	TInt index = iCerts->Index(aCertInfo);

	if (index == KErrNotFound)

		{

		User::Leave(index);

		}

	CFileCertStoreMapping* mapping = iCerts->Mapping(index);

	TBool oldValue = mapping->Trusted();

	mapping->SetTrusted(aTrusted);

	TRAPD(err, UpdateStoreL());

	if (err != KErrNone)

		{

		// If there is an error, we undo the change in oldEntry

		mapping->SetTrusted(oldValue);

		}

	}

void CTest1CertStore::Add(const TDesC& aLabel,

						 TCertificateFormat aFormat,

						 TCertificateOwnerType aCertificateOwnerType,

						 const TKeyIdentifier* aSubjectKeyId,

						 const TKeyIdentifier* aIssuerKeyId,

						 const TDesC8& aCert, 

						 TRequestStatus& aStatus)

	{

	TRAPD(err, DoAddL(aLabel, aFormat, aCertificateOwnerType, aSubjectKeyId,

		aIssuerKeyId, aCert));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelAdd()

	{

	Cancel();

	}

void CTest1CertStore::DoAddL(const TDesC& aLabel,

							TCertificateFormat aFormat,

							TCertificateOwnerType aCertificateOwnerType,

							const TKeyIdentifier* aSubjectKeyId,

							const TKeyIdentifier* aIssuerKeyId,

							const TDesC8& aCert)

	{

	TKeyIdentifier subjectKeyId;

	switch (aFormat)

		{

		case EX509Certificate:

			if (!aSubjectKeyId)

				{

				CCertificate* cert = CX509Certificate::NewLC(aCert);

				subjectKeyId = cert->KeyIdentifierL();

				aSubjectKeyId = &subjectKeyId;

				CleanupStack::PopAndDestroy(cert);

				}

			break;

		case EWTLSCertificate:

			if (!aSubjectKeyId)

				{

				CCertificate* cert = CWTLSCertificate::NewLC(aCert);

				subjectKeyId = cert->KeyIdentifierL();

				aSubjectKeyId = &subjectKeyId;

				CleanupStack::PopAndDestroy(cert);

				}

			break;

		case EX509CertificateUrl:

			if (!aSubjectKeyId)

				{

				User::Leave(KErrArgument);

				}

			break;

		default:

			User::Leave(KErrNotSupported);	

			break;

		}

	TInt iend = iCerts->Count();

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

		{

		if (iCerts->Entry(i).Label() == aLabel)

			{

			User::Leave(KErrBadName);

			}

		}

	CCTCertInfo* entry = CCTCertInfo::NewL(aLabel, aFormat, 

		aCertificateOwnerType, aCert.Length(), aSubjectKeyId, aIssuerKeyId, iToken, iCerts->Count());

	// AddCertL takes ownership of entry no matter what happens.

	AddCertL(entry, aCert, *iCerts);

	}

/*void CFileCertStore::AddUserCertL(const CCertificate& aCert, 

								  const TDesC& aLabel,

								  TCertificateFormat aFormat, 

								  const TKeyIdentifier& aIssuerKeyHash, 

								  const TKeyIdentifier& aSubjectKeyHash)

	{

	if (aFormat != EX509Certificate)

		{

		User::Leave(KErrNotSupported);

		}

	TInt iend = iUserCerts->Count();

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

		{

		if (iUserCerts->Entry(i).Label() == aLabel)

			{

			User::Leave(KErrBadName);

			}

		}

	// We compute the subject key hash using the information contained in the certificate

	const CSubjectPublicKeyInfo& key = aCert.PublicKey();

	CX509RSAPublicKey* rsaKey = CX509RSAPublicKey::NewLC(key.KeyData());

#ifdef SYMBIAN_CRYPTO	

	const TInteger& modulus = rsaKey->Modulus();

#else

	const CInteger& modulus = rsaKey->Modulus();

#endif

	HBufC8* modulusBuffer = modulus.BufferLC();

	CSHA1* sha1 = CSHA1::NewL();

	CleanupStack::PushL(sha1);

	TPtrC8 hash = sha1->Hash(*modulusBuffer);

	TKeyIdentifier keyId;

	keyId = hash;

	CleanupStack::PopAndDestroy(3);	// rsaKey, modulusBuffer, sha1

	// If the caller supplied a aSubjectKeyHash, we must compare it with the computed

	// value and ensure they are the same

	if ((aSubjectKeyHash != KNullDesC8) && (aSubjectKeyHash != keyId))

		{

		User::Leave(KErrArgument);

		}

	CCTCertInfo* entry = CCTCertInfo::NewL(aLabel, 

		*this, EX509Certificate, aCert.Encoding().Length(), keyId, aIssuerKeyHash);

	AddCertL(entry, aCert, *iUserCerts);

	}*/

/*void CFileCertStore::AddUserCertURLL(const TDesC8& aCert, 

									 const TDesC& aLabel,

									 const TKeyIdentifier& aIssuerKeyHash, 

									 const TKeyIdentifier& aSubjectKeyHash)

	{

	TInt iEnd = iUserCerts->Count();

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

		{

		if (iUserCerts->Entry(i).Label() == aLabel)

			{

			User::Leave(KErrBadName);

			}

		}

	CCTCertInfo* entry = CCTCertInfo::NewL(aLabel, 

		*this, EX509CertificateUrl, aCert.Length(), aSubjectKeyHash, aIssuerKeyHash);

	AddCertL(entry, aCert, *iUserCerts);

	}*/

void CTest1CertStore::AddCertL(CCTCertInfo* aCertInfo,

							  const TDesC8& aCert,

							  CFileCertStoreMappings& aMappings)

	{

	CleanupReleasePushL(*aCertInfo);

//create the mapping object		

	CFileCertStoreMapping* mapping = CFileCertStoreMapping::NewL();

	mapping->SetEntry(aCertInfo);

	CleanupStack::Pop();//aEntry, mapping has taken ownership

	CleanupStack::PushL(mapping);

	TCleanupItem cleanupStore(CTest1CertStore::RevertStore, iStore);//store will revert() if a leave occurs

	CleanupStack::PushL(cleanupStore);

//store cert

	RStoreWriteStream stream;

	TStreamId certId = stream.CreateLC(*iStore);//stream for cert

	stream.WriteL(aCert);

	stream.CommitL();

	CleanupStack::PopAndDestroy();//stream

	mapping->SetId(certId);

//add mapping to mappings, & store mappings

	aMappings.AddL(mapping); //takes ownership

	CleanupStack::Pop();//mapping; mappings has taken ownership

//Update the mapping. if error, remove the entry.

	TRAPD(err, aMappings.ReplaceL());

	if (err == KErrNone)

		{

		TRAP(err, iStore->CommitL());

		if (err != KErrNone)

			{

			aMappings.Remove(*mapping->Entry());

			User::Leave(err);

			}

		}

	else

		{

		//oom tests pass currently

		aMappings.Remove(*mapping->Entry());

		User::Leave(err);

		}

	CleanupStack::Pop();//revert store

	}

void CTest1CertStore::UpdateStoreL()

	{

//tries to write out the new cacerts to the file

	TCleanupItem cleanupStore(RevertStore, iStore);//store will revert() if a leave occurs

	CleanupStack::PushL(cleanupStore);

	iCerts->ReplaceL();

	iStore->CommitL();

	CleanupStack::Pop();//revert store

	}

void CTest1CertStore::DoLoadL(TDes8& aCertificate, CFileCertStoreMapping& aMapping) const

	{

	RStoreReadStream stream;

	stream.OpenLC(*iStore, aMapping.Id());

	CCTCertInfo* entry = aMapping.Entry();

	stream.ReadL(aCertificate, entry->Size());

	CleanupStack::PopAndDestroy();//stream

	}

void CTest1CertStore::DoRemoveL(const CCTCertInfo& aCertInfo)

	{

	switch(aCertInfo.CertificateFormat())

		{

		case EWTLSCertificate://must be a CA cert

		case EX509CertificateUrl:

		case EX509Certificate:

			User::LeaveIfError(iCerts->SetTempRemove(aCertInfo, ETrue));

			break;

		default:

			{

			User::Leave(KErrNotSupported);

			}

		}

	TRAPD(err, UpdateStoreL());

	if (err != KErrNone)

		{

		User::LeaveIfError(iCerts->SetTempRemove(aCertInfo, EFalse));

		}

	else

		{

		User::LeaveIfError(iCerts->Remove(aCertInfo));	

		}

	}

//private functions

CTest1CertStore::CTest1CertStore(CTest1CertStoreToken& aToken, RFs& aFs)

	: CActive(EPriorityNormal), iToken(aToken), iFs(aFs)

	{

	CActiveScheduler::Add(this);

	}

void CTest1CertStore::ConstructL(const TDesC& aFileName, TFileMode aMode)

	{

	iStore = OpenStoreL(aFileName, aMode);

	RestoreL();

	}

void CTest1CertStore::RestoreL()

	{

	TStreamId caCertEntryStreamId;

	RStoreReadStream stream;

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

	stream >> caCertEntryStreamId;

	CleanupStack::PopAndDestroy();//stream

	iCerts = CFileCertStoreMappings::NewL(caCertEntryStreamId, *iStore);

	RStoreReadStream caCertEntryStream;

	caCertEntryStream.OpenLC(*iStore, caCertEntryStreamId);

	TInt caCount = caCertEntryStream.ReadInt32L();

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

		{

		CFileCertStoreMapping* caCertMapping = CFileCertStoreMapping::NewL();

		CleanupStack::PushL(caCertMapping);

		CCTCertInfo* caCertEntry = CCTCertInfo::NewLC(caCertEntryStream, iToken);

		caCertMapping->SetEntry(caCertEntry);

		CleanupStack::Pop();//caCertEntry

		// Read the CertificateApps uids

		RArray<TUid>* certificateApps = new(ELeave) RArray<TUid>();

		CleanupStack::PushL(certificateApps);

		CleanupClosePushL(*certificateApps);

		TInt count = caCertEntryStream.ReadInt32L();

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

			{

			TUid id;

			caCertEntryStream >> id;

			User::LeaveIfError(certificateApps->Append(id));

			}

		CleanupStack::Pop(2);	// *certificateApps, certificateApps

		caCertMapping->SetCertificateApps(certificateApps);

		TBool trusted = caCertEntryStream.ReadUint8L();

		caCertMapping->SetTrusted(trusted);

		TStreamId caCertStreamId;

		caCertEntryStream >> caCertStreamId;

		caCertMapping->SetId(caCertStreamId);

		iCerts->AddL(caCertMapping);

		CleanupStack::Pop();//caCertMapping

		}

	CleanupStack::PopAndDestroy();//caCertStream

	}

CPermanentFileStore* CTest1CertStore::OpenStoreLC(const TDesC& aFileName, TFileMode aMode)

	{

//this function creates, opens and returns a permanent file store in KCertStorePath,

//on the drive letter passed in, leaving it on the cleanup stack. 

//if the store isn't found it returns NULL

	TInt err = iFile.Open(iFs, aFileName, aMode); 	

    if (err == KErrNone)

		{

		CPermanentFileStore* store = CPermanentFileStore::FromLC(iFile);

		return store;

		}

	else

		{

		User::Leave(err);

		}

	return NULL;

	}

CPermanentFileStore* CTest1CertStore::OpenStoreL(const TDesC& aFileName, TFileMode aMode)

	{

	CPermanentFileStore* store = NULL;

	store = OpenStoreLC(aFileName, aMode);	

	CleanupStack::Pop(store);

	return store;

	}

void CTest1CertStore::RunL()

	{

	switch (iState)

		{

	case EGetKeyInfos:

		iKeyFilter.iUsage = KeyUsageX509ToPKCS15Private(iFilter->iKeyUsage);

		iUnifiedKeyStore->List(iKeyInfos, iKeyFilter, iStatus);

		iState = EList;

		SetActive();

		break;

	case ERetrieve:

		// Asynch Retrieve 

		RetrieveNow(*iAsynchCertInfo,*iAsynchCertificate,*iOriginalRequestStatus);

		break;

	case EList:

		{	

		TInt count = iCerts->Count();

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

			{

			const CCTCertInfo& certInfo = iCerts->Entry(index);

			TBool accept = ETrue;

			if (iFilter->iUidIsSet)

				{

				accept = iCerts->Mapping(index)->IsApplicable(iFilter->iUid);

				}

			if (iFilter->iFormatIsSet && accept)

				{

				accept = (iFilter->iFormat == certInfo.CertificateFormat());

				}

			if (iFilter->iOwnerTypeIsSet && accept)

				{

				accept = (iFilter->iOwnerType == certInfo.CertificateOwnerType());

				}

			if ((iFilter->iSubjectKeyId != KNullDesC8) && accept)

				{

				accept = (iFilter->iSubjectKeyId == certInfo.SubjectKeyId());

				}

			if (accept)

				{

				// Fill in the cert hash.

				// (This returns an incorrect hard-coded value, which allows 

				// the test code to check that the store is being treated

				// correctly as a hardware store, as it'll behave differently

				// to if it returned the correct hashes.)

				_LIT8(KHash, "\x70\xe4\xf4\x54\x5f\x8e\xe6\xf2\xbd\x4e\x76\x2b\x8d\xa1\x83\xd8\xe0\x5d\x4a\x7d");

				CCTCertInfo* copy = CCTCertInfo::NewLC(

					certInfo.Label(), certInfo.CertificateFormat(),

					certInfo.CertificateOwnerType(), certInfo.Size(),

					&certInfo.SubjectKeyId(), &certInfo.IssuerKeyId(),

					certInfo.Token(), certInfo.Handle().iObjectId,

					ETrue, &KHash);

				User::LeaveIfError(iCertInfos->Append(copy));

				CleanupStack::Pop();

				}

			}

		iKeyInfos.Close();

		delete iUnifiedKeyStore;

		iUnifiedKeyStore = 0;

		User::RequestComplete(iOriginalRequestStatus, KErrNone);

		}

		break;

	default:

		// ignore the undefined operations

		break;

		}

	}

void CTest1CertStore::DoCancel()

	{

	if (iUnifiedKeyStore)

		{

		if (iState == EGetKeyInfos)

			{

			iUnifiedKeyStore->CancelInitialize();

			}

		else if (iState == EList)

			{

			iUnifiedKeyStore->CancelList();

			}

		iState = EList;

		iKeyInfos.Close();

		delete iUnifiedKeyStore;

		iUnifiedKeyStore = 0;

		}

	User::RequestComplete(iOriginalRequestStatus, KErrCancel);

	}

const TImplementationProxy ImplementationTable[] =

	{

#ifdef CERTSTORE_SOFTWARE_ASYNCH

		IMPLEMENTATION_PROXY_ENTRY(0x101FF738, CTest1CertStoreTokenType::NewL)

#else

	#ifdef CERTSTORE_HARDWARE_SIM

		IMPLEMENTATION_PROXY_ENTRY(0x10206846, CTest1CertStoreTokenType::NewL)

	#else

		#ifdef CERTSTORE_HARDWARE_WIM

			IMPLEMENTATION_PROXY_ENTRY(0x10206847, CTest1CertStoreTokenType::NewL)

		#else

			#ifdef CERTSTORE_HARDWARE_UICC

				IMPLEMENTATION_PROXY_ENTRY(0x10206848, CTest1CertStoreTokenType::NewL)

 			#else

				#ifdef CERTSTORE_DEVICE_IMMUTABLE

					IMPLEMENTATION_PROXY_ENTRY(0x102077C3, CTest1CertStoreTokenType::NewL)

				#else

					IMPLEMENTATION_PROXY_ENTRY(0x101F5279, CTest1CertStoreTokenType::NewL)

				#endif

 			#endif

		#endif

	#endif

#endif

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;

	}