/*

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

#include "t_input.h"

#include <ecom/ecom.h>

_LIT(KPath, "");

_LIT(KChainStart, "<chain>");

_LIT(KDateIssuedStart, "<dateissued>");

_LIT(KIOStart, "<io>");

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

		Output& aOut, const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CValidateTest::NewLC(aFs, aConsole, aOut, aTestActionSpec);

	CleanupStack::Pop(self);

	return self;

	}

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

		Output& aOut, const TTestActionSpec& aTestActionSpec)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

void CValidateTest::TestValidation(TRequestStatus& aStatus)

	{

	iOriginalRequestStatus = &aStatus;

	aStatus = KRequestPending;

	iState = EInit;

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

CValidateTest::CValidateTest(RFs& aFs, 

								 CConsoleBase& aConsole,

								 Output& aOut)

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

	{

	}

void CValidateTest::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	iValidationResult = CWTLSValidationResult::NewL();

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

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

	// creates the test chan validation object

	iTestChain = CTestChainValidate::NewL();

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

	iTestChain->AddChainL(chainBuf);

	TPtrC ioDateIssued = Input::ParseElement(*aBody, KDateIssuedStart);

	iTestChain->AddDateIssued(ioDateIssued);

	TPtrC ioBuf = Input::ParseElement(*aBody, KIOStart);

	iTestChain->AddIOL(ioBuf);

	CleanupStack::PopAndDestroy(aBody);

	}

CValidateTest::~CValidateTest()

	{

	delete iTestChain;

	delete iCertUtils;

	delete iValidationResult;

	delete iChain;

	REComSession::FinalClose();

	}

void CValidateTest::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	TInt err = KErrNone;

	switch (iState)

		{

		case EInit:

			iResult = ETrue;

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

			iCertUtils = CCertUtils::NewL(iFs);

			TRAP(err, HandleEInitL(aStatus));

			break;

		case EValidationStoreInitStoreManager1:

			TRAP(err, HandleEValidationInitStoreManager1L(aStatus));

			iActionState = EAction;

			break;		

		case EValidationStoreDepopulateStore1:

		case EValidationStorePopulateStoreRoots:

		case EValidationStorePopulateStoreExtras:

		case EValidationStoreValidate:

		case EValidationStoreValidated:

		case EValidationStoreInitStoreManager2:

		case EValidationStoreDepopulateStore2:

		case EValidationStoreEnd:

		case EValidationSuppliedInit:

		case EValidationSuppliedValidate:

		case EValidationSuppliedValidated:

		case EFinished:

			break;	//	Nothing to do, for compiler

		}

	}

void CValidateTest::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TInt err = KErrNone;

	switch (iState)

		{

	case EInit:

	case EValidationStoreInitStoreManager1:

	case EValidationStoreDepopulateStore1:

	case EValidationStorePopulateStoreRoots:

	case EValidationStorePopulateStoreExtras:

	case EValidationStoreValidate:

	case EValidationStoreValidated:

	case EValidationStoreInitStoreManager2:

	case EValidationStoreDepopulateStore2:

	case EValidationStoreEnd:

		break;	//	Nothing to do, for compiler

	case EValidationSuppliedInit:

			{

			iConsole.Printf(_L("started with supplied certs...\n"));

			iOut.writeString(_L("started with supplied certs..."));

			iOut.writeNewLine();

			iState = EValidationSuppliedValidate;

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, KErrNone);

			}

			break;

		case EValidationSuppliedValidate:

			{

			HBufC8* encodedCerts = ReadFilesLC(*iTestChain->iServerCerts);

			if(!encodedCerts)

				{

				TRequestStatus* status = &aStatus;

				iFinished = ETrue;

				User::RequestComplete(status, KErrNone);

				}

			else

				{

				TInt certCount = iTestChain->iRootCerts->MdcaCount();

				CArrayPtrFlat<CWTLSCertificate>* roots = 

					new(ELeave) CArrayPtrFlat<CWTLSCertificate>(1);

				TCleanupItem cleanup(CleanupCertArray, roots);

				CleanupStack::PushL(cleanup);

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

					{

					// build the root certificates array including all the candidates.

					HBufC8* encCert = 

						ReadFileLC(iTestChain->iRootCerts->MdcaPoint(i));

					CWTLSCertificate* cert = CWTLSCertificate::NewLC(encCert->Des());

					roots->AppendL(cert);

					CleanupStack::Pop();	// cert

					CleanupStack::PopAndDestroy();	// encCert

					}

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

				iChain = CWTLSCertChain::NewL(iFs, *encodedCerts, *roots);

				CleanupStack::PopAndDestroy(2);	// encodedCerts, roots

				TDateTime dt(2000, EJuly, 0, 0, 0, 0, 0);

				if(iTestChain->iDateIssued == 1)

					{

					dt.SetYear(2002);

					}

				iTime = dt;

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

				iState = EValidationSuppliedValidated;

				}

			}

			break;

		case EValidationSuppliedValidated:

			{

			delete iChain;

			iChain = 0;

			TWTLSValidationStatus* expectedStatus = iTestChain->iError;

			const TWTLSValidationStatus& actualStatus = iValidationResult->Error();

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

			WriteError(expectedStatus->iReason);

			iOut.writeNewLine();

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

			WriteError(actualStatus.iReason);

			iOut.writeNewLine();

			TInt wCount = iTestChain->iWarnings->Count();

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

			iOut.writeNewLine();

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

				{

				TWTLSValidationStatus warning = iTestChain->iWarnings->At(i);

				WriteError(warning.iReason);

				iOut.writeNewLine();

				}

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

			iOut.writeNewLine();

			const CArrayFixFlat<TWTLSValidationStatus>& warnings = 

				iValidationResult->Warnings();

			wCount = warnings.Count();

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

				{

				TWTLSValidationStatus warning = warnings.At(j);

				WriteError(warning.iReason);

				iOut.writeNewLine();

				}

			iOut.writeNewLine();

			if(expectedStatus->iReason != actualStatus.iReason)

				{

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

				iOut.writeString(_L("FAILED!!!!"));

				iOut.writeNewLine();

				iResult = EFalse;

				}

			// End of validatewith supplied

			if (err != KErrNone)

				{

				iOut.writeString(_L("Failed: leave code = "));

				iOut.writeNum(err);

				iOut.writeNewLine();

				}

			iState = EFinished;

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, KErrNone);

			}

			break;

		case EFinished:

			{

			TTime end;

			end.HomeTime();

			TTimeIntervalMicroSeconds intervalMS = end.MicroSecondsFrom(iStart);

			iConsole.Printf(_L("Time taken = %d milliseconds\n"), (intervalMS.Int64()/1000));

			TRequestStatus* status = &aStatus;

			iFinished = ETrue;

			User::RequestComplete(status, KErrNone);

			}

			break;

		}

	}

void CValidateTest::PerformAction(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	switch (iState)

		{

		case EValidationStoreDepopulateStore1:

			{

			iCertUtils->RemoveCertsL(aStatus);

			iState = EValidationStorePopulateStoreRoots;

			break;

			}

		case EValidationStorePopulateStoreRoots:

			{

			TUid uid = { 1 };

			TRAP_IGNORE(iCertUtils->RemoveApplicationL(uid));

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

			iCertUtils->AddCACertsL(*iTestChain->iRootCerts, 

				*iTestChain->iRootLabels, EWTLSCertificate, 1, KPath, aStatus);

			iState = EValidationStorePopulateStoreExtras;

			break;

			}

		case EValidationStorePopulateStoreExtras:

			{

			iCertUtils->AddCACertsL(*iTestChain->iExtraCerts, 

				*iTestChain->iExtraLabels, EWTLSCertificate, 2, KPath, aStatus);

			iState = EValidationStoreValidate;

			break;

			}

		case EValidationStoreValidate:

			{

			HBufC8* encodedCerts = ReadFilesLC(*iTestChain->iServerCerts);

			TUid testUid = TUid::Uid(1);

			if(!encodedCerts)

				{

				TRequestStatus* status = &aStatus;

				iFinished = ETrue;

				User::RequestComplete(status, KErrNone);

				}

			else

				{

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

				iChain = CWTLSCertChain::NewL(iFs, *encodedCerts, testUid);

				CleanupStack::PopAndDestroy();	// encodedCerts

				TDateTime dt(2000, EJuly, 0, 0, 0, 0, 0);

				if(iTestChain->iDateIssued == 1)

					{

					dt.SetYear(2002);

					}

				iTime = dt;

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

				iState = EValidationStoreValidated;

				};

			break;

			}

		case EValidationStoreValidated:

			{

			TInt count = iChain->Count();

			if (count > 0)

				{

				iOut.writeString(_L("EE certificate = "));

				const CWTLSCertificate& eeCert = iChain->Cert(0);

				HBufC* eeSubject = eeCert.SubjectL();

				CleanupStack::PushL(eeSubject);

				iOut.writeString(*eeSubject);

				CleanupStack::PopAndDestroy();

				iOut.writeNewLine();

				for (TInt i = 1; i < count - 1; i++)

					{

					iOut.writeString(_L("Intermediate certificate = "));

					const CWTLSCertificate& iCert = iChain->Cert(i);

					HBufC* subject = iCert.SubjectL();

					CleanupStack::PushL(subject);

					iOut.writeString(*subject);

					CleanupStack::PopAndDestroy();

					iOut.writeNewLine();	

					}

				iOut.writeString(_L("Root certificate = "));

				const CWTLSCertificate& rCert = iChain->Cert(count-1);

				HBufC* rSubject = rCert.SubjectL();

				CleanupStack::PushL(rSubject);

				iOut.writeString(*rSubject);

				CleanupStack::PopAndDestroy();

				iOut.writeNewLine();	

				}

			TWTLSValidationStatus* expectedStatus = iTestChain->iError;

			const TWTLSValidationStatus& actualStatus = iValidationResult->Error();

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

			WriteError(expectedStatus->iReason);

			iOut.writeNewLine();

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

			WriteError(actualStatus.iReason);

			iOut.writeNewLine();

			TInt wCount = iTestChain->iWarnings->Count();

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

			iOut.writeNewLine();

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

				{

				TWTLSValidationStatus warning = iTestChain->iWarnings->At(i);

				WriteError(warning.iReason);

				iOut.writeNewLine();

				}

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

			iOut.writeNewLine();

			const CArrayFixFlat<TWTLSValidationStatus>& warnings = 

				iValidationResult->Warnings();

			wCount = warnings.Count();

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

				{

				TWTLSValidationStatus warning = warnings.At(j);

				WriteError(warning.iReason);

				iOut.writeNewLine();

				}

			iOut.writeNewLine();

			if(expectedStatus->iReason != actualStatus.iReason)

				{

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

				iOut.writeString(_L("FAILED!!!!"));

				iOut.writeNewLine();

				iResult = EFalse;

				}

			// End of DoValidate

			iState = EValidationStoreInitStoreManager2;				

			User::RequestComplete(status, KErrNone);

			delete iChain;

			iChain = 0;

			break;

			}

		case EValidationStoreInitStoreManager2:

			{

			User::RequestComplete(status, KErrNone);

			iState = EValidationStoreDepopulateStore2;

			break;

			}

		case EValidationStoreDepopulateStore2:

			{

			iCertUtils->RemoveCertsL(aStatus);

			TUid uid = { 1 };

			iCertUtils->RemoveApplicationL(uid);

			iState = EValidationStoreEnd;

			break;

			}

		case EValidationStoreEnd:

			{

			iState = EValidationSuppliedInit;

			iActionState = EPostrequisite;

			User::RequestComplete(status, KErrNone);

			break;

			}

		case EInit:

		case EValidationStoreInitStoreManager1:

		case EValidationSuppliedInit:

		case EValidationSuppliedValidate:

		case EValidationSuppliedValidated:

		case EFinished:

			break;	//	Nothing to do, for compiler

		}

	}

HBufC8* CValidateTest::ReadFileLC(const TDesC& aFilename)

	{

	RFile file;

	User::LeaveIfError(file.Open(iFs, aFilename, EFileRead));

	CleanupClosePushL(file);

	TInt size;

	file.Size(size);

	CleanupStack::PopAndDestroy(1);//fileClose

	HBufC8* res = HBufC8::NewLC(size);

	TPtr8 p(res->Des());

	p.SetLength(size);

	RFileReadStream stream;

	User::LeaveIfError(stream.Open(iFs, aFilename, EFileStream));

	CleanupClosePushL(stream);

	stream.ReadL(p, size);

	CleanupStack::PopAndDestroy();//streamClose...bleurgh

	return res;

	}

HBufC8* CValidateTest::ReadFilesLC(CDesCArray& aServerCerts)

	{

	TInt count = aServerCerts.MdcaCount();

	TInt totalSize = 0;

	TInt i;

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

		{

		TPtrC filename = aServerCerts.MdcaPoint(i);

		RFile file;

		TRAPD(err, file.Open(iFs, filename, EFileRead));

		if(err != KErrNone)

			{

			HBufC *failedToLoad = filename.AllocLC();

			SetScriptError(EFileNotFound, failedToLoad->Des());

			CleanupStack::PopAndDestroy(2);//fsclose, fileClose	

			return(NULL);

			};

		CleanupClosePushL(file);

		TInt size;

		file.Size(size);

		CleanupStack::PopAndDestroy(1);	//	fileClose