/*

* 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;

	}