/*

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

#include "t_inputextra.h"

_LIT(KRoot, "build\\CA3_root.crt");

_LIT(KCA2, "build\\CA2.crt");

_LIT(KCA1, "build\\CA1.crt");

_LIT(KEE, "build\\EE.crt");

_LIT(KRootStart, "<root>");

_LIT(KRootEnd, "</root>");

_LIT(KCertificateStart, "<certificate>");

_LIT(KCertificateEnd, "</certificate>");

_LIT(KLabelStart, "<label>");

_LIT(KLabelEnd, "</label>");

_LIT(KExtraStart, "<extra>");

_LIT(KExtraEnd, "</extra>");

_LIT(KInitStart, "<init>");

_LIT(KInitEnd, "</init>");

_LIT(KAddCallStart, "<addcall>");

_LIT(KAddCallEnd, "</addcall>");

_LIT(KAddCertStart, "<addcert>");

_LIT(KAddCertEnd, "</addcert>");

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

CAddCall* CAddCall::NewL(const TDesC& aBuf)

	{

	CAddCall* self = CAddCall::NewLC(aBuf);

	CleanupStack::Pop();

	return self;

	}

CAddCall* CAddCall::NewLC(const TDesC& aBuf)

	{

	CAddCall* self = new(ELeave) CAddCall;

	CleanupStack::PushL(self);

	self->ConstructL(aBuf);

	return self;

	}

CAddCall::~CAddCall()

	{

	delete iCertsToAdd;

	}

CAddCall::CAddCall()

	{

	}

void CAddCall::ConstructL(const TDesC& aBuf)

	{

	iCertsToAdd = new(ELeave) CDesCArrayFlat (1);

	TInt pos = 0;

	while(AddCert(aBuf, KAddCertStart, KAddCertEnd, pos, *iCertsToAdd))

		{

		}	

	}

TBool CAddCall::AddCert(const TDesC& aBuf, const TDesC& aStart, const TDesC& aEnd, TInt& aPos, CDesCArray& aCerts)

	{

	TPtrC certBuf = Input::ParseElement(aBuf, aStart, aEnd, aPos);

	if (certBuf != KNullDesC)

		{

		aCerts.AppendL(certBuf);

		return ETrue;

		}

	return EFalse;

	} 

CTestAction* CTestActionBuild::NewL(RFs& aFs,

										 CConsoleBase& aConsole,

										 Output& aOut, 

										 const TTestActionSpec& aTestActionSpec)

	{

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

		aOut, aTestActionSpec);

	CleanupStack::Pop(self);

	return self;

	}

CTestAction* CTestActionBuild::NewLC(RFs& aFs,

										  CConsoleBase& aConsole,

										  Output& aOut,

										  const TTestActionSpec& aTestActionSpec)

	{

	CTestActionBuild* self = new(ELeave) CTestActionBuild(aFs, aConsole, 

		aOut);

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CTestActionBuild::~CTestActionBuild()

	{

	delete iUnifiedCertStore;

	delete iCertUtils;

	delete iChain;

	delete iExtraCertsFileName;

	delete iExtraCertsLabel;

	delete iInitCertsFileName;

	delete iInitCertsLabel;

	iAddCalls.ResetAndDestroy();

	iAddCalls.Close();

	delete iValidationResult;

	}

CTestActionBuild::CTestActionBuild(RFs& aFs, 

								   CConsoleBase& aConsole,

								   Output& aOut)

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

	{

	}

void CTestActionBuild::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	TInt pos = 0;

	TInt err = KErrNone;

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

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

	TPtrC rootCert(Input::ParseElement(*aBody,

		KRootStart, KRootEnd, pos, err));

	TInt dummyPos = 0;

	iRootCertFileName = Input::ParseElement(rootCert, KCertificateStart,

		KCertificateEnd, dummyPos);

	iRootCertLabel = Input::ParseElement(rootCert, KLabelStart,

		KLabelEnd, dummyPos);

	iExtraCertsFileName = new(ELeave) CDesCArrayFlat(1);

	iExtraCertsLabel = new(ELeave) CDesCArrayFlat(1);

	while(AddCert(*aBody, KExtraStart, KExtraEnd, pos, *iExtraCertsFileName, 

		*iExtraCertsLabel))

		{

		}	

	iInitCertsFileName = new(ELeave) CDesCArrayFlat(1);

	iInitCertsLabel = new(ELeave) CDesCArrayFlat(1);

	while(AddCert(*aBody, KInitStart, KInitEnd, pos, *iInitCertsFileName,

		*iInitCertsLabel))

		{

		}

	while(AddAddCallsL(*aBody, pos))

		{

		}

	iValidationResult = CPKIXValidationResult::NewL();

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName driveName(sysDrive.Name());

	iCertPath.Copy(driveName);

	iCertPath.Append(KCertPath);

	CleanupStack::PopAndDestroy(aBody);

	}

void CTestActionBuild::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	iActionState = EAction;

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

void CTestActionBuild::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

void CTestActionBuild::PerformAction(TRequestStatus& aStatus)

	{

	switch (iState)

		{

		case EInitCertStoreManager1:

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

			iUnifiedCertStore = CUnifiedCertStore::NewL(iFs, ETrue);	// We open the store for writing

			iUnifiedCertStore->Initialize(aStatus);

			iState = ERemoveCertsBeforeTest;

			break;

		case ERemoveCertsBeforeTest:

			// A new iCertUtils is created and destroyed for each test because

			// we need to close before validating as the chain won't be able to

			// open the store manager if it is already open for write elsewhere

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

			iCertUtils = CCertUtils::NewL(iFs);

			iCertUtils->RemoveCertsL(*iUnifiedCertStore, 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->AddCert(iRootCertLabel, EX509Certificate, ECACertificate,

				1, iCertPath, iRootCertFileName, *iUnifiedCertStore, aStatus);//1 is trusted for our use

			iState = EAddIntermediateCerts;

			}

			break;

		case EAddIntermediateCerts:

			iCertUtils->AddCACertsL(*iExtraCertsFileName,

				*iExtraCertsLabel, EX509Certificate,

				2, iCertPath, *iUnifiedCertStore, aStatus);	// 2 not trusted for our use

			iState = EDoBuildTestStart;

			break;

		case EDoBuildTestStart:

			{

			// We have to close the store manager because it is open for write

			// and CPKIXCertChain won't be able to open it if we don't close it

			// iCertUtils muts also be deleted since it uses this store manager

			delete iCertUtils;

			iCertUtils = 0;

			delete iUnifiedCertStore;

			iUnifiedCertStore = 0;

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

			HBufC8* initCerts = 

				InputExtra::ReadFilesLC(*iInitCertsFileName, iCertPath, iFs);

			TUid testUid = TUid::Uid(1);

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

			CleanupStack::PopAndDestroy(initCerts);	// initCerts

			TInt addCount = iAddCalls.Count();	

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

				{

				const CAddCall* addCall = iAddCalls[i];

				HBufC8* addCerts = InputExtra::ReadFilesLC(*(addCall->iCertsToAdd),

					iCertPath, iFs);

				// the root of the chain is set when the certificate chain is getting created through the CPKIXCertChainAO

				// via CPKIXChainBuilder. If the chain has the root certificate then the iChainHasRoot is set which is returned

				// through this method. If the corresponding certificate does not have the issuer certificate in the chain then 

				// the extra certificates provided in the test script would be added for completing the chain.

				if (!(iChain->ChainHasRoot()))

					{

					iChain->AddCertL(*addCerts);

					}

				CleanupStack::PopAndDestroy();	// addCerts

				}

			iTime.HomeTime();

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

			iState = EDoBuildTestFinished;

			}

			break;

		case EDoBuildTestFinished:

			{

			iResult = CompareChainsL(*iChain);

			delete iChain;

			iChain = 0;

			iState = EInitCertStoreManager2;

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, KErrNone);

			}

			break;

		case EInitCertStoreManager2:

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

			//TRAP(err, HandleEDoBuildTests_SingleTest_InitCertStoreManager2L());

			iUnifiedCertStore = CUnifiedCertStore::NewL(iFs, ETrue);	// We open the store for writing

			iUnifiedCertStore->Initialize(aStatus);

			iState = ERemoveCertsAfterTest;

			break;

		case ERemoveCertsAfterTest:

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

			iCertUtils = CCertUtils::NewL(iFs);

			iCertUtils->RemoveCertsL(*iUnifiedCertStore, aStatus);

			iState = EEnd;

			break;

		case EEnd:

			{

			delete iCertUtils;

			iCertUtils = 0;

			delete iUnifiedCertStore;

			iUnifiedCertStore = 0;

			TRequestStatus* status = &aStatus;

			iFinished = ETrue;

			User::RequestComplete(status, KErrNone);

			}

			break;

		}

	}

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

	{

	return 0;

	}

void CTestActionBuild::PerformCancel()

	{

	}

void CTestActionBuild::Reset()

	{

	}

void CTestActionBuild::DoReportAction()

	{

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

	}

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

	{

	}

TBool CTestActionBuild::AddCert(const TDesC& aBuf, 

								const TDesC& aStart,

								const TDesC& aEnd, TInt& aPos, 

								CDesCArray& aCertsFileName,

								CDesCArray& aCertsLabel)

	{

	TPtrC certBuf = Input::ParseElement(aBuf, aStart, aEnd, aPos);

	TInt dummyPos = 0;

	if (certBuf != KNullDesC)

		{

		aCertsFileName.AppendL(Input::ParseElement(certBuf, KCertificateStart,

			KCertificateEnd, dummyPos));

		aCertsLabel.AppendL(Input::ParseElement(certBuf, KLabelStart,

			KLabelEnd, dummyPos));

		return ETrue;

		}

	return EFalse;

	} 

TBool CTestActionBuild::AddAddCallsL(const TDesC& aBuf, TInt& aPos)

	{

	TPtrC addCallsBuf = Input::ParseElement(aBuf, KAddCallStart, KAddCallEnd, aPos);

	if (addCallsBuf != KNullDesC)

		{

		CAddCall* addCall = CAddCall::NewLC(addCallsBuf);		

		iAddCalls.AppendL(addCall);

		CleanupStack::Pop(addCall);

		return ETrue;

		}

	return EFalse;

	}

TBool CTestActionBuild::CompareChainsL(const CPKIXCertChain& aChain)

	{

	if (aChain.Count() != 4)

		{

		return EFalse;

		}

	if (	(!CompareCertL(aChain.Cert(0), KEE))		||

			(!CompareCertL(aChain.Cert(1), KCA1))	||

			(!CompareCertL(aChain.Cert(2), KCA2))	||

			(!CompareCertL(aChain.Cert(3), KRoot))	)

		{

		return EFalse;

		}

	else

		{

		return ETrue;

		}

	}

TBool CTestActionBuild::CompareCertL(const CX509Certificate& aCert, const TDesC& aFilename)

	{

	HBufC8* correct = Input::ReadFileLC(aFilename, iCertPath, iFs);

	TBool res = (correct->Des() == aCert.Encoding());

	CleanupStack::PopAndDestroy();

	return res;

	}