/*

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