/*

* 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 "tactionvalidate.h"

#include "t_inputextra.h"

_LIT(KChainStart, "<chain>");

_LIT(KChainEnd, "</chain>");

_LIT(KIOStart, "<io>");

_LIT(KIOEnd, "</io>");

_LIT(KCertPath, "\\pkixtestdata\\");

CActionValidate::~CActionValidate()

	{

	if (iPolicies)

		{

		iPolicies->ResetAndDestroy();

		delete iPolicies;

		iPolicies = 0;

		}

	delete iValidationResult;

	delete iChain;

	delete iCertUtils;

	delete iTestChain;

	delete iTestIO;

	}

CActionValidate::CActionValidate(RFs& aFs, 

								 CConsoleBase& aConsole,

								 Output& aOut)

: CTestAction(aConsole, aOut), iFs(aFs)

	{

	}

void CActionValidate::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	HBufC* aBody = HBufC::NewLC(aTestActionSpec.iActionBody.Length());

	aBody->Des().Copy(aTestActionSpec.iActionBody);

	TInt pos = 0;

	TInt err = KErrNone;

	TPtrC chainBuf = Input::ParseElement(*aBody, KChainStart, KChainEnd, pos, err);

	iTestChain = CTestChain::NewL(chainBuf);

	if (!AddParametersL(*aBody, pos))

		{

		// There must be at least one IO thing

		User::Leave(KErrNotFound);

		}

	while(AddParametersL(*aBody, pos))

		{

		}

	iValidationResult = CPKIXValidationResult::NewL();

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName driveName(sysDrive.Name());

	iCertPath.Copy(driveName);

	iCertPath.Append(KCertPath);

	CleanupStack::PopAndDestroy(aBody);

	}

void CActionValidate::PerformAction(TRequestStatus& aStatus)

	{

	switch (iState)

		{

		case EDoValidateTestStart:

			{

			__ASSERT_DEBUG(!iChain, User::Panic(_L("CPKIXCertTest"), 1));

			TRAPD(err, CreateChainL());

			iState = EDoValidateTestValidate;

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, err);

			break;

			}

		case EDoValidateTestValidate:

			{

			// 1) write the overall result we expect

			iOut.writeSpaces(4);

			iOut.writeString(_L("Expected result = "));

			iOut.writeString(iTestIO->iError);

			iOut.writeNewLine();

			// 2) now do the validation

			iTime.UniversalTime();

			if (iTestIO->iPolicyInput->Count() > 0)

				{

				__ASSERT_DEBUG(!iPolicies, User::Panic(_L("CPKIXCertTest"), 1));

				__ASSERT_DEBUG(iChain, User::Panic(_L("CPKIXCertTest"), 1));

				iPolicies = new (ELeave) CArrayPtrFlat<HBufC> (1);

				TInt count = iTestIO->iPolicyInput->Count();

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

					{

					TPtrC policy = iTestIO->iPolicyInput->MdcaPoint(i);

					HBufC* pBuf = policy.AllocL();

					CleanupStack::PushL(pBuf);

					iPolicies->AppendL(pBuf);

					CleanupStack::Pop();

					}

				iChain->ValidateL(*iValidationResult, iTime, *iPolicies, aStatus);	

				}

			else

				{

				iChain->ValidateL(*iValidationResult, iTime, aStatus);

				}

			iState = EDoValidateTestValidated;

			}

			break;

		case EDoValidateTestValidated:

			{

			// 3) write the overall result

			iOut.writeSpaces(4);

			iOut.writeString(_L("Actual result = "));

			CCertUtils::WriteError(iValidationResult->Error().iReason, iOut);

			TBuf<128> iActualResult = CCertUtils::MapError(iValidationResult->Error().iReason);

			iOut.writeNewLine();

			iOut.writeNewLine();

			// 4) write the policy info

			TBool checkingPolicies = 

				((iTestIO->iIPoliciesSet) || (iTestIO->iOPoliciesSet));

			if (checkingPolicies)

				{

				if (iTestIO->iIPoliciesSet)

					{

					// 4.1) policies we supplied

					iOut.writeSpaces(4);

					iOut.writeString(_L("Supplied policy set: "));

					iOut.writeNewLine();

					WritePolicies(*(iTestIO->iPolicyInput));

					}

				if (iTestIO->iOPoliciesSet)

					{

					// 4.2) policies we expect

					iOut.writeSpaces(4);

					iOut.writeString(_L("Expected user-constrained policy set: "));

					iOut.writeNewLine();

					WritePolicies(*(iTestIO->iExpectedPolicyOutput));

					}

				// 4.3) policies we collected

				iOut.writeSpaces(4);

				iOut.writeString(_L("Actual user-constrained policy set: "));

				iOut.writeNewLine();

				const CArrayPtrFlat<CX509CertPolicyInfo>& policies = iValidationResult->Policies();

				TInt actualPolicyCount = policies.Count();

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

					{

					iOut.writeSpaces(8);

					iOut.writeString(policies.At(j)->Id());

					iOut.writeNewLine();	

					}

				iOut.writeNewLine();	

			//check expected user-constrained policy set == actual user-constrained policy set

				TBool policyOutputCorrect = ETrue;

				CDesCArray* expectedPolicies = iTestIO->iExpectedPolicyOutput;

				TInt expectedPolicyCount = expectedPolicies->MdcaCount();

				if (expectedPolicyCount == actualPolicyCount)

					{

					for (TInt k = 0; k < expectedPolicyCount; k++)

						{

						TPtrC expectedPolicy = expectedPolicies->MdcaPoint(k);

						TBool policyFound = EFalse;

						for (TInt l = 0; l < actualPolicyCount; l++)

							{

							TPtrC actualPolicy = policies.At(l)->Id();

							if (actualPolicy == expectedPolicy)

								{

								policyFound = ETrue;

								break;

								}

							}

						if (!policyFound)

							{

							policyOutputCorrect = EFalse;

							}	

						}

					}

				else

					{

					policyOutputCorrect = EFalse;

					}

				iResult = (iTestIO->iError == iActualResult) && (policyOutputCorrect);

				}

			else	//! checking policies 

				{

				iResult = (iTestIO->iError == iActualResult);

				}

			iState = EDoValidateTestFinished;

			if (iPolicies)

				{

				iPolicies->ResetAndDestroy();

				delete iPolicies;

				iPolicies = 0;

				}

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, KErrNone);

			}

			break;

		case EDoValidateTestFinished:

			{

			__ASSERT_DEBUG(!iPolicies, User::Panic(_L("CPKIXCertTest"), 1));

			delete iChain;

			iChain = 0;

			iState = ERemoveCertsAfterTest;

			iActionState = EPostrequisite;

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, KErrNone);

			}

			break;

		default:

			break;

		}

	}

TBool CActionValidate::TestResult(TInt /*aError*/)

	{

	return 0;

	}

void CActionValidate::PerformCancel()

	{

	delete iChain;

	iChain = 0;

	}

void CActionValidate::AfterOOMFailure()

	{

	if (iPolicies)

		{

		iPolicies->ResetAndDestroy();

		delete iPolicies;

		iPolicies = 0;

		}

	}

void CActionValidate::Reset()

	{

	iState = EDoValidateTestStart;

	if (iPolicies)

		{

		iPolicies->ResetAndDestroy();

		delete iPolicies;

		iPolicies = 0;

		}

	delete iChain;

	iChain = 0;

	}

void CActionValidate::DoReportAction()

	{

	iConsole.Printf(_L("u"));

	}

void CActionValidate::DoCheckResult(TInt /*aError*/)

	{

	}

TBool CActionValidate::AddParametersL(const TDesC& aBuf, TInt& aPos)

	{

	TPtrC ioBuf = Input::ParseElement(aBuf, KIOStart, KIOEnd, aPos);

	if (ioBuf != KNullDesC)

		{

		iTestIO = CTestParameters::NewL(ioBuf);

		return ETrue;

		}

	return EFalse;

	}

void CActionValidate::WritePolicies(const CDesCArray& aPolicySet)

	{

	TInt count = aPolicySet.Count();

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

		{

		iOut.writeSpaces(8);

		iOut.writeString(aPolicySet.MdcaPoint(i));

		iOut.writeNewLine();

		}

	}

/*

validate using the cert store as a source of root certificates

*/

CTestAction* CActionValidateWithStore::NewL(RFs& aFs, CConsoleBase& aConsole,

		Output& aOut, const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CActionValidateWithStore::NewLC(aFs, aConsole,

		aOut, aTestActionSpec);

	CleanupStack::Pop(self);

	return self;

	}

CTestAction* CActionValidateWithStore::NewLC(RFs& aFs, CConsoleBase& aConsole,

		Output& aOut, const TTestActionSpec& aTestActionSpec)

	{

	CActionValidateWithStore* self = new(ELeave) CActionValidateWithStore(aFs, aConsole, aOut);

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CActionValidateWithStore::CActionValidateWithStore(RFs& aFs, CConsoleBase& aConsole,Output& aOut)

	:CActionValidate(aFs, aConsole, aOut)

	{

	}

void CActionValidateWithStore::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	switch (iState)

		{

		case ERemoveCertsBeforeTest:

			__ASSERT_DEBUG(!iCertUtils, User::Panic(_L("CPKIXCertTest"), 1));

			iCertUtils = CCertUtils::NewL(iFs);

			iCertUtils->RemoveCertsL(aStatus);

			iState = EAddRoot;

			break;

		case EAddRoot:

			{

			TUid uid = { 1 };

			TRAPD(err, iCertUtils->RemoveApplicationL(uid));

			iCertUtils->AddApplicationL(_L("testpkix"), uid);

			TUid uid2 = { 2 };

			TRAP(err, iCertUtils->RemoveApplicationL(uid2));

			iCertUtils->AddApplicationL(_L("testpkix"), uid2);

			iCertUtils->AddCertL(iTestChain->iRootCertLabel,

				EX509Certificate, ECACertificate, 1, iCertPath,

				iTestChain->iRootCertFileName, 

				aStatus);	// 1 is trusted for our use

			iState = EAddIntermediateCerts;

			break;

			}

		case EAddIntermediateCerts:

			{

			iCertUtils->AddCACertsL(*(iTestChain->iIntermediateCertsFileName), 

				*(iTestChain->iIntermediateCertsLabel),

				EX509Certificate, 2, iCertPath, 

				aStatus);	//2 not trusted for our use

			iState = EDoValidateTestStart;

			iActionState = EAction;

			break;

			}

		default:

			break;

		}

	}

void CActionValidateWithStore::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	switch (iState)

		{

		case ERemoveCertsAfterTest:

			iCertUtils->RemoveCertsL(aStatus);

			iState = EEnd;

			break;

		case EEnd:

			{

			delete iCertUtils;

			iCertUtils = 0;

			TRequestStatus* status = &aStatus;

			iFinished = ETrue;

			User::RequestComplete(status, KErrNone);

			}

			break;

		default:

			break;

		}

	}

void CActionValidateWithStore::CreateChainL()

	{

	HBufC8* eeCert = 0;

	TRAPD(err, 

		eeCert = Input::ReadFileL(iTestChain->iEECertFileName,

		iCertPath, iFs));

	if (err != KErrNone)

		{

		iConsole.Printf(_L("Error : couldn't open file "));

		iConsole.Printf(iTestChain->iEECertFileName);

		iConsole.Printf(_L("\n"));

		iOut.writeString(_L("Error : couldn't open file "));

		iOut.writeString(iTestChain->iEECertFileName);

		iOut.writeNewLine();

		User::Leave(err);

		}

	CleanupStack::PushL(eeCert);

	TUid testUid = TUid::Uid(1);

	iChain = CPKIXCertChain::NewL(iFs, *eeCert, testUid);

	CleanupStack::PopAndDestroy(eeCert); 

	}

/*

validate using a set of candidates root certs supplied by the client

*/

CTestAction* CActionValidateWithSuppliedCerts::NewL(RFs& aFs, CConsoleBase& aConsole,

		Output& aOut, const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CActionValidateWithSuppliedCerts::NewLC(aFs, aConsole,

		aOut, aTestActionSpec);

	CleanupStack::Pop(self);

	return self;	

	}

CTestAction* CActionValidateWithSuppliedCerts::NewLC(RFs& aFs, CConsoleBase& aConsole,

		Output& aOut, const TTestActionSpec& aTestActionSpec)

	{

	CActionValidateWithSuppliedCerts* self = new(ELeave) CActionValidateWithSuppliedCerts(aFs, aConsole, aOut);

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CActionValidateWithSuppliedCerts::CActionValidateWithSuppliedCerts(RFs& aFs, CConsoleBase& aConsole,Output& aOut)

	:CActionValidate(aFs, aConsole, aOut)

	{

	}

void CActionValidateWithSuppliedCerts::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CActionValidate::ConstructL(aTestActionSpec);

	iRootCerts = new(ELeave) RPointerArray<CX509Certificate>;

	}

CActionValidateWithSuppliedCerts::~CActionValidateWithSuppliedCerts()

	{

	if (iRootCerts)

		{

		iRootCerts->ResetAndDestroy();

		delete iRootCerts;

		}

	delete iEndEntityAndIntermediateCerts;

	}

void CActionValidateWithSuppliedCerts::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

//initialise the big descriptor containing ee cert followed by all intermediate certs

//and the array of candidate root certs

	HBufC8* eeCert = Input::ReadFileLC(iTestChain->iEECertFileName, iCertPath, iFs);

	HBufC8* inter = InputExtra::ReadFilesLC(*(iTestChain->iIntermediateCertsFileName), iCertPath, iFs);

	TInt totalSize = (eeCert->Size()) + (inter->Size());

	iEndEntityAndIntermediateCerts = HBufC8::NewL(totalSize);

	TPtr8 pRes = iEndEntityAndIntermediateCerts->Des();

	pRes.Append(*eeCert);

	pRes.Append(*inter);

	CleanupStack::PopAndDestroy(2);//eeCert, inter

	HBufC8* rootBuf = Input::ReadFileLC(iTestChain->iRootCertFileName, iCertPath, iFs);

	CX509Certificate* root = CX509Certificate::NewL(*rootBuf);

	CleanupStack::PopAndDestroy(rootBuf);

	CleanupStack::PushL(root);

	User::LeaveIfError(iRootCerts->Append(root));

	CleanupStack::Pop(root);//

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	iState = EDoValidateTestStart;

	iActionState = EAction;

	}

void CActionValidateWithSuppliedCerts::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	delete iCertUtils;

	iCertUtils = NULL;

	TRequestStatus* status = &aStatus;

	iFinished = ETrue;

	User::RequestComplete(status, KErrNone);

	}

void CActionValidateWithSuppliedCerts::CreateChainL()

	{

//create chain object

	iChain = CPKIXCertChain::NewL(iFs, *iEndEntityAndIntermediateCerts, *iRootCerts);

	}