diff -r 000000000000 -r 2c201484c85f cryptoservices/certificateandkeymgmt/tpkixcert/Taction_build.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/certificateandkeymgmt/tpkixcert/Taction_build.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,394 @@
+/*
+* 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 "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(AddAddCalls(*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::AddAddCalls(const TDesC& aBuf, TInt& aPos)
+	{
+	TPtrC addCallsBuf = Input::ParseElement(aBuf, KAddCallStart, KAddCallEnd, aPos);
+	if (addCallsBuf != KNullDesC)
+		{
+		CAddCall* addCall = CAddCall::NewL(addCallsBuf);
+		iAddCalls.Append(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;
+	}