diff -r 000000000000 -r 2c201484c85f cryptoservices/filebasedcertificateandkeystores/test/ttesttools/ttesttoolengine.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/filebasedcertificateandkeystores/test/ttesttools/ttesttoolengine.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,782 @@
+/*
+* Copyright (c) 2007-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 "ttesttoolengine.h"
+#include <ccertattributefilter.h>
+#include <mctcertstore.h>
+#include <mctkeystore.h>
+
+const TInt swinstalluid = 268452523;
+const TInt swinstallocspuid = 268478646;
+const TInt midletinstalluid = 270506792;
+const TInt tlsuid = 268441661;
+const TInt tocspuid = 268477445;
+
+
+_LIT(KSWInstall, "SWInstall");
+_LIT(KSWInstallOCSP, "SWInstallOCSP");
+_LIT(KMidletInstall, "MidletInstall");
+_LIT(KTls, "SSL/TLS");
+_LIT(KTOcsp, "OCSP Test");
+
+_LIT(KCaType, "ca");
+_LIT(KUserType, "user");
+_LIT(KPeerType, "peer");
+
+
+/*static*/ CTestToolEngine* CTestToolEngine::NewLC()
+	{
+	CTestToolEngine* self = new (ELeave) CTestToolEngine();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+	
+CTestToolEngine::CTestToolEngine() : CActive(EPriorityNormal)
+	{
+	iStore = -1;
+	iPolicy =  EFalse;
+	}
+
+CTestToolEngine::~CTestToolEngine()
+	{
+	Cancel();	
+
+	delete iCertStore;		
+	delete iKeyStore;		
+
+	delete iFilter;
+	Cancel();
+	iCertInfos.Close();
+	iFsKeyStore.Close();
+	iFs.Close();
+	iUids.Reset();
+	}
+	
+void CTestToolEngine::ConstructL()
+	{
+	User::LeaveIfError(iFs.Connect());
+	
+	iCertStore = CUnifiedCertStore::NewL(iFs, ETrue);
+	
+	User::LeaveIfError(iFsKeyStore.Connect());	
+	iKeyStore = CUnifiedKeyStore::NewL(iFsKeyStore);
+	
+	// This filter will accept any certificates
+	iFilter = CCertAttributeFilter::NewL();
+	
+	CActiveScheduler::Add(this);	
+	}
+
+void CTestToolEngine::RunL()
+	{
+	if (iStatus.Int() != KErrNone)
+		{
+		User::Leave(iStatus.Int());
+		}
+		
+	switch (iState)
+		{
+		case EInitialiseKeyStore:
+			{
+			// Construct a catch-all filter!
+			iKeyFilter.iKeyAlgorithm = CCTKeyInfo::EInvalidAlgorithm;
+			iKeyFilter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;
+			iKeyFilter.iUsage = EPKCS15UsageAll;
+			if (iStore != -1)
+				{
+				MCTKeyStore& chosen = iKeyStore->KeyStore(iStore);
+				chosen.List(iKeys, iKeyFilter, iStatus);
+				}
+			else
+				{	
+				iKeyStore->List(iKeys, iKeyFilter, iStatus);
+				}
+			if(iPolicy)
+				{
+				iState = EGetPolicy;
+				}
+			else if (iKeysListCount > 0)
+				{
+				iState = EDone;
+				}
+			else
+				{
+				iState = EFilterKey;	
+				}
+			SetActive();
+			}
+			break;
+		case EFilterKey:
+			{
+			TInt index = 0;
+			if (iLabel1.Length())    
+				{
+				iNumCert1 = FilterKeys(iKeys, iLabel1, index);					
+				}
+			if (iLabel2.Length())    
+				{
+				iNumCert2 = FilterKeys(iKeys, iLabel2, index);					
+				}
+			CActiveScheduler::Stop();	
+			}
+			break;	
+		case EInitialise:
+			{
+			if (iStore != -1)
+				{
+				MCTCertStore& chosen = iCertStore->CertStore(iStore);
+				chosen.List(iCertInfos, *iFilter, iStatus);
+				}
+			else
+				{
+				iCertStore->List(iCertInfos, *iFilter, iStatus);			
+				}
+			
+			if(iAppsCount > 0)
+				{
+				iState = EGetApps;
+				}
+			else if (iGetTrust == 1)
+				{
+				iState = EGetTrust;
+				}
+			else if (iCertsCount > 0)
+				{
+				iState = EDone;
+				}
+			else
+				{
+				iState = EFilter;	
+				}
+			SetActive();
+			}
+			break;
+		case EGetPolicy:
+			{
+			FilterKeys(iKeys, iLabel1, iIndex);
+			CActiveScheduler::Stop();	
+			}
+			break;
+		case EGetApps:
+			{
+			TInt index = 0;
+			FilterCerts(iCertInfos, iLabel1, index);	
+			iCertStore->Applications(*iCertInfos[index], iUids, iStatus);
+			CActiveScheduler::Stop();
+			}
+			break;
+		case EGetTrust:
+			{
+			TInt index = 0;
+			FilterCerts(iCertInfos, iLabel1, index);	
+			iCertStore->Trusted(*iCertInfos[index], iActualTrust, iStatus);
+			CActiveScheduler::Stop();
+			}
+			break;
+		case EFilter:
+			{
+			TInt index = 0;
+			TBool filteronly = ETrue;
+			if (iLabel1.Length())    
+				{
+				iNumCert1 = FilterCerts(iCertInfos, iLabel1, index, filteronly);					
+				}
+			if (iLabel2.Length())    
+				{
+				iNumCert2 = FilterCerts(iCertInfos, iLabel2, index, filteronly);					
+				}
+			CActiveScheduler::Stop();
+			}
+			break;
+		case EDone:
+			{
+			CActiveScheduler::Stop();	
+			}
+			break;	
+		default:
+			{
+			User::Panic(_L("Testtool Engine - Illegal state"), 0);
+			}
+		}
+	}
+	
+TInt CTestToolEngine::RunError(TInt /*aError*/)
+	{	
+	CActiveScheduler::Stop();	
+	
+	return KErrNone;
+	}
+
+	
+void CTestToolEngine::DoCancel()
+	{
+	//CActiveScheduler::Stop();
+	}
+
+TVerdict CTestToolEngine::ListCerts(const TDesC& aLabel1, const TInt aExpectedNumLabel)
+	{
+	TVerdict returnValue = EPass;
+	iLabel1.Set(aLabel1);
+	
+	Initilize();
+	if (iNumCert1 != aExpectedNumLabel)
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+
+TVerdict CTestToolEngine::ListCerts(const TDesC& aLabel1, const TDesC& aLabel2, const TInt aExpectedNumLabel)
+	{
+	TVerdict returnValue = EPass;
+	iLabel1.Set(aLabel1);
+	iLabel2.Set(aLabel2);
+	
+	Initilize();
+	if (iNumCert1 != aExpectedNumLabel || iNumCert2 != aExpectedNumLabel)
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+TVerdict CTestToolEngine::ListStore(RPointerArray<HBufC>& aCerts)
+	{
+	TVerdict returnValue = EPass;
+	iCertsCount = aCerts.Count();
+	
+	Initilize();
+	
+	if (!CompareWithExpectedStore(aCerts))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+	
+TVerdict CTestToolEngine::ListCerts(RPointerArray<HBufC>& aCerts)
+	{
+	TVerdict returnValue = EPass;
+	iCertsCount = aCerts.Count();
+	
+	Initilize();
+	
+	if (!CompareWithExpectedCertificates(aCerts))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+TVerdict CTestToolEngine::ListCerts(RPointerArray<HBufC>& aCerts, const TDesC& aLabel)
+	{
+	TVerdict returnValue = EPass;
+	iLabel1.Set(aLabel);
+	iCertsCount = aCerts.Count();
+		
+	Initilize();
+	TCertificateOwnerType owner;
+	if (iLabel1.CompareF(KCaType) == KErrNone) 
+		{
+		owner = ECACertificate;
+		}
+	else if (iLabel1.CompareF(KUserType) == KErrNone) 
+		{
+		owner = EUserCertificate;
+		}
+	else if (iLabel1.CompareF(KPeerType) == KErrNone) 
+		{
+		owner = EPeerCertificate;
+		}
+	FilterCerts(iCertInfos, owner);
+	if (!CompareWithExpectedCertificates(aCerts))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+TVerdict CTestToolEngine::ListCerts(RPointerArray<HBufC>& aCerts, TInt aStore)
+	{
+	TVerdict returnValue = EPass;
+	iStore = aStore;
+	iCertsCount = aCerts.Count();
+	
+	Initilize();
+	if (!CompareWithExpectedCertificates(aCerts))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+	
+TVerdict CTestToolEngine::CheckApps(RPointerArray<HBufC>& aApps, const TDesC& aLabel)
+	{
+	TVerdict returnValue = EPass;
+	iAppsCount = aApps.Count();
+	iLabel1.Set(aLabel);
+	Initilize();
+	if (!VerifyApps(aApps))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+TVerdict CTestToolEngine::CheckTrust(const TDesC& aLabel,TBool aTrust)
+	{
+	TVerdict returnValue = EPass;
+	iLabel1.Set(aLabel);
+	iGetTrust = 1;
+	Initilize();
+	if (!VerifyTrust(aTrust))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+TVerdict CTestToolEngine::ListStoreKey(RPointerArray<HBufC>& aKeys)
+	{
+	TVerdict returnValue = EPass;
+	iKeysListCount = aKeys.Count();
+	
+	KeyInitilize();
+	
+	if (!CompareWithExpectedStoreKey(aKeys))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+	
+TVerdict CTestToolEngine::ListKeys(const TDesC& aLabel1, const TInt aExpectedNumLabel)
+	{
+	TVerdict returnValue = EPass;
+	iLabel1.Set(aLabel1);
+	
+	KeyInitilize();
+	if (iNumCert1 != aExpectedNumLabel)
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+
+TVerdict CTestToolEngine::ListKeys(const TDesC& aLabel1, const TDesC& aLabel2, const TInt aExpectedNumLabel)
+	{
+	TVerdict returnValue = EPass;
+	iLabel1.Set(aLabel1);
+	iLabel2.Set(aLabel2);
+	
+	KeyInitilize();
+	if (iNumCert1 != aExpectedNumLabel || iNumCert2 != aExpectedNumLabel)
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+TVerdict CTestToolEngine::ListKeys(RPointerArray<HBufC>& aKeys, TInt aStore)
+	{
+	TVerdict returnValue = EPass;
+	iStore = aStore;
+	iKeysListCount = aKeys.Count();
+	
+	KeyInitilize();
+	if (!CompareWithExpectedKeys(aKeys))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+
+TVerdict CTestToolEngine::ListKeys(RPointerArray<HBufC>& aKeys)
+	{
+	TVerdict returnValue = EPass;
+	iKeysListCount = aKeys.Count();
+	
+	KeyInitilize();
+	
+	if (!CompareWithExpectedKeys(aKeys))
+		{
+		returnValue = EFail;
+		}
+	return returnValue;
+	}
+
+TVerdict CTestToolEngine::GetPolicy(const TDesC& aLabel1, const TDesC& aLabel2, TInt aUser)
+	{
+	TVerdict returnValue = EPass;
+	iLabel1.Set(aLabel1);
+	iLabel2.Set(aLabel2);
+	iPolicy = ETrue;
+	KeyInitilize();
+	VerifyPolicy(aUser);
+
+	return returnValue;
+	}
+	
+void CTestToolEngine::Initilize()
+	{
+	iState = EInitialise;
+	iCertStore->Initialize(iStatus);	
+	SetActive();
+	CActiveScheduler::Start();
+	}
+	
+void CTestToolEngine::KeyInitilize()
+	{
+	iState = EInitialiseKeyStore;
+	iKeyStore->Initialize(iStatus);	
+	SetActive();
+	CActiveScheduler::Start();
+	}
+
+TBool CTestToolEngine::VerifyApps(RPointerArray<HBufC>& aApps)
+	{
+	TInt uidsCount = iUids.Count();
+	TInt appsCount = aApps.Count();
+	TBool result = ETrue;
+	if ( uidsCount != appsCount)
+		{
+		return EFalse;
+		}
+	for (TInt i = 0; i < uidsCount; i++)
+		{
+		if (iUids[i] == TUid::Uid(swinstalluid))
+			{
+			result = CheckAppForUid(KSWInstall, aApps);
+			}
+		else if (iUids[i] == TUid::Uid(swinstallocspuid))
+			{
+			result = CheckAppForUid(KSWInstallOCSP, aApps);
+			}
+		else if (iUids[i] == TUid::Uid(midletinstalluid))
+			{
+			result = CheckAppForUid(KMidletInstall, aApps);
+			}
+		else if (iUids[i] == TUid::Uid(tlsuid))
+			{
+			result = CheckAppForUid(KTls, aApps);
+			}
+		else if (iUids[i] == TUid::Uid(tocspuid))
+			{
+			result = CheckAppForUid(KTOcsp, aApps);
+			}
+		else
+			{
+			result = EFalse;
+			}
+		if (!result)
+			{
+			break;
+			}
+		}
+	return result;
+	}
+
+TBool CTestToolEngine::CheckAppForUid(const TDesC& aAppName, RPointerArray<HBufC>& aApps)
+	{
+	TBool result = EFalse;
+	for (TInt i = 0; i < aApps.Count();i++)
+		{
+		if (aAppName.CompareF(*aApps[i]) == KErrNone)
+			{
+			result = ETrue;
+			break;
+			}
+		else
+			{
+			result = EFalse;
+			}
+		}
+	return result;
+	}
+
+TBool CTestToolEngine::VerifyPolicy(TInt aUser)
+	{
+	TBool result = EFalse;
+	_LIT(KCab, "WriteDeviceData");
+	TLex lex(iLabel2);
+	TUid secid;
+	lex.Val(secid.iUid);
+	TCompiledSecurityPolicy managementPolicy = iKeys[iIndex]->ManagementPolicy();
+	TCompiledSecurityPolicy usePolicy = iKeys[iIndex]->UsePolicy();
+	TUint32 mSecureid = managementPolicy.SecureId();
+	TUint32 uSecureid = usePolicy.SecureId();
+
+	if (aUser == 2)
+		{
+		if (mSecureid == 0xffffffff)
+			{
+			TCapability cab = managementPolicy.Capability(0);
+			// currently only possible for keyowner other than secure id.
+			if (cab == ECapabilityWriteDeviceData && iLabel2.CompareF(KCab) == KErrNone)
+				{
+				result = ETrue;
+				}
+			else
+				{
+				result = EFalse;
+				}
+			}
+		else
+			{
+			TUid mSecureUid = TUid::Uid(mSecureid);
+			if (mSecureUid == secid)
+				{
+				result = ETrue;
+				}
+			else
+				{
+				result = EFalse;
+				}
+			}
+		}
+	else if (aUser == 1)
+		{
+		if (uSecureid == 0xffffffff)
+			{
+			TSecurityPolicy::TType utype = usePolicy.Type();
+			_LIT(KType, "ALL");
+			// currently only possible for keyuser other than secure id
+			if (utype == TSecurityPolicy::ETypePass && iLabel2.CompareF(KType) == KErrNone)
+				{
+				result = ETrue;
+				}
+			else
+				{
+				result = EFalse;
+				}
+			}
+		else
+			{
+			TUid uSecureUid = TUid::Uid(uSecureid);	
+			if (uSecureUid == secid)
+				{
+				result = ETrue;
+				}
+			else
+				{
+				result = EFalse;
+				}
+			}	
+		}
+	return result;
+	}
+	
+TInt CTestToolEngine::FilterCerts(RMPointerArray<CCTCertInfo>& aCertList, 
+                                TDesC& aLabel, TInt& aIndex, TBool aFilterOnly)
+  	{
+  	TInt j = 0, count = 0;
+  	while (j < aCertList.Count())
+  		{
+  		if ( aCertList[j]->Label().MatchF(aLabel) != KErrNotFound) 
+  			{
+  			count++;
+  			if (count == 1)
+  				{
+  				//first certificate to be selected for retreiving
+  				aIndex = j;
+  				}
+  			j++;
+  			}
+  		else
+  			{
+  			if (!aFilterOnly)
+  				{
+  				CCTCertInfo* tmp = aCertList[j];
+	  			tmp->Release();
+  				aCertList.Remove(j);	
+  				}
+  			else
+  				{
+  				j++;	
+  				}
+  			}
+  		}
+  	return count;
+  	}
+
+void CTestToolEngine::FilterCerts(RMPointerArray<CCTCertInfo>& aCertList, TCertificateOwnerType& aOwnerType)
+	{
+	TInt j = 0;
+  	while (j < aCertList.Count())
+  		{
+  		if ( aCertList[j]->CertificateOwnerType() != aOwnerType) 
+  			{
+  			CCTCertInfo* tmp = aCertList[j];
+  			tmp->Release();
+  			aCertList.Remove(j);
+  			}
+  		else
+  			{
+  			j++;
+  			}	
+  		}
+	}
+  
+  
+TInt CTestToolEngine::FilterKeys(RMPointerArray<CCTKeyInfo>& aKeyList,
+							 TDesC& aLabel, TInt& aIndex)
+  	{
+  	TInt j = 0, count = 0;
+  	while (j < aKeyList.Count())
+  		{
+  		if ( aKeyList[j]->Label().MatchF(aLabel) != KErrNotFound) 
+  			{
+  			count++;
+  			if (count == 1)
+  				{
+  				//first key to be selected for retreiving
+  				aIndex = j;
+  				}
+  			j++;
+  			}
+  		else
+  			{
+			j++;
+  			}	
+  		}
+  	return count;
+  	}
+
+TBool CTestToolEngine::CompareWithExpectedCertificates(RPointerArray<HBufC>& aCerts)
+	{
+	if ( iCertInfos.Count() != aCerts.Count())
+		{
+		return EFalse;
+		}
+	for (TInt i = 0 ; i < iCertInfos.Count(); i++)
+		{
+		const TDesC& label = iCertInfos[i]->Label();
+		TBool found = EFalse;
+		for (TInt j = 0; j < aCerts.Count(); j++)
+			{
+			if (aCerts[j]->CompareF(label) == KErrNone)
+				{
+				found = ETrue;
+				break;
+				}
+			}
+		if (!found)
+			{
+			return EFalse;
+			}
+		}
+	return ETrue;
+	}
+	
+
+TBool CTestToolEngine::CompareWithExpectedKeys(RPointerArray<HBufC>& aKeys)
+	{
+	if ( iKeys.Count() != iKeysListCount)
+		{
+		return EFalse;
+		}
+	for (TInt i = 0 ; i < iKeys.Count(); i++)
+		{
+		const TDesC& label = iKeys[i]->Label();
+		TBool found = EFalse;
+		for (TInt j = 0; j < iKeysListCount; j++)
+			{
+			if (aKeys[j]->CompareF(label) == KErrNone)
+				{
+				found = ETrue;
+				break;
+				}
+			}
+		if (!found)
+			{
+			return EFalse;
+			}
+		}
+	return ETrue;
+	}
+	
+TBool CTestToolEngine::CompareWithExpectedStore(RPointerArray<HBufC>& aCerts)
+	{
+	TBool result = EFalse;
+	TInt storeCount = iCertStore->CertStoreCount();
+ 	for (TInt i = 0; i < storeCount ; i++)
+		{
+		result = EFalse;
+		MCTToken& token = (iCertStore->CertStore(i)).Token();
+		const TDesC& tmp = token.Label();
+		for (TInt j = 0; j < aCerts.Count(); j++)
+			{
+			if (tmp.CompareF(*aCerts[j]) == KErrNone)
+				{
+				result = ETrue;
+				break;
+				}
+			}
+		if (!result)
+			{
+			break;
+			}
+		}
+	return result;
+	}
+	
+	
+TBool CTestToolEngine::CompareWithExpectedStoreKey(RPointerArray<HBufC>& aKeys)
+	{
+	TBool result = EFalse;
+	TInt storeCount = iKeyStore->KeyStoreCount();
+ 	for (TInt i = 0; i < storeCount ; i++)
+		{
+		result = EFalse;
+		MCTToken& token = (iKeyStore->KeyStore(i)).Token();
+		const TDesC& tmp = token.Label();
+		for (TInt j = 0; j < aKeys.Count(); j++)
+			{
+			if (tmp.CompareF(*aKeys[j]) == KErrNone)
+				{
+				result = ETrue;
+				break;
+				}
+			}
+		if (!result)
+			{
+			break;
+			}
+		}
+	return result;
+	}
+	
+
+
+TBool CTestToolEngine::VerifyTrust(TBool aTrust)
+	{
+	TBool result = EFalse;
+	if (aTrust == iActualTrust)
+		{
+		result = ETrue;
+		}
+	else
+		{
+		result = EFalse;
+		}
+	return result;
+	}