/*
* Copyright (c) 2005-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 "x509constraintext.h"
#include "extensiontest.h"
#include "t_input.h"

_LIT(KFileNameStart, "<filename>");
_LIT(KExpectedDeviceIdList, "<device_id_list>");
_LIT(KExpectedDevice, "<device_id>");
_LIT(KExpectedSidList, "<sid_list>");
_LIT(KExpectedSid, "<sid>");
_LIT(KExpectedVidList, "<vid_list>");
_LIT(KExpectedVid, "<vid>");
_LIT(KExpectedCapabilities, "<capabilities>");
_LIT(KCorrupt, "<corrupt>");
_LIT(KMatch, "<match>");

CTestAction* CExtensionTest::NewL(RFs& aFs, CConsoleBase& aConsole, 
	Output& aOut, const TTestActionSpec& aTestActionSpec)
	{
	CTestAction* self = CExtensionTest::NewLC(aFs, aConsole, aOut, aTestActionSpec);
	CleanupStack::Pop(self);
	return self;
	}

CTestAction* CExtensionTest::NewLC(RFs& aFs, CConsoleBase& aConsole, 
	Output& aOut, const TTestActionSpec& aTestActionSpec)
	{
	CExtensionTest* self = new(ELeave) CExtensionTest(aFs, aConsole, aOut);
	CleanupStack::PushL(self);
	self->ConstructL(aTestActionSpec);
	return self;
	}

CExtensionTest::CExtensionTest(RFs& aFs, CConsoleBase& aConsole, Output& aOut)
	: CTestAction(aConsole, aOut), 
	iFs(aFs)
	{
	}

CExtensionTest::~CExtensionTest()
	{	
	iExpectedDeviceIdList.ResetAndDestroy();
	iExpectedDeviceIdList.Close();		
	iExpectedSidList.Close();
	iExpectedVidList.Close();
	}	

void CExtensionTest::ConstructL(const TTestActionSpec& aTestActionSpec)
	{
	CTestAction::ConstructL(aTestActionSpec);
	TInt startPos = 0;
	TInt err = 0;
	
	HBufC* aBody = HBufC::NewLC(aTestActionSpec.iActionBody.Length());	
	aBody->Des().Copy(aTestActionSpec.iActionBody);
	
	// Filename of the certificate file
	TPtrC fileNameStart = Input::ParseElement(*aBody, KFileNameStart);
	iCertFileName.Copy(fileNameStart);

	// Whether we expect at least on of the extensions to be corrupt
	TPtrC corruptStart = Input::ParseElement(*aBody, KCorrupt);	
	if (corruptStart.CompareF(_L("True")) == 0)
		{
		iExpectedCorrupt = ETrue;
		}				
		
	// We expect the certificate to match the constraints
	TPtrC matchStart = Input::ParseElement(*aBody, KMatch);	
	if (matchStart.CompareF(_L("True")) == 0)
		{
		iExpectedMatch = ETrue;
		}						

	// Extract the lists of constraints that are expected to be present 		
	startPos = 0;
	TPtrC deviceListStart = Input::ParseElement(*aBody, KExpectedDeviceIdList, startPos, err);
	if (err >= 0)
		{
		BuildStringListL(iExpectedDeviceIdList, deviceListStart, KExpectedDevice);
		iDeviceIdsPresent = ETrue;		
		}

	startPos = 0;
	TPtrC sidListStart = Input::ParseElement(*aBody, KExpectedSidList, startPos, err);
	if (err >= 0)
		{
		BuildIntList(iExpectedSidList, sidListStart, KExpectedSid);
		iSidsPresent = ETrue;
		}	

	startPos = 0;
	TPtrC vidListStart = Input::ParseElement(*aBody, KExpectedVidList, startPos, err);
	if (err >= 0)
		{
		BuildIntList(iExpectedVidList, vidListStart, KExpectedVid);
		iVidsPresent = ETrue;
		}	
		
	startPos = 0;
	TPtrC capabilities = Input::ParseElement(*aBody, KExpectedCapabilities, startPos, err);
	if (err >= 0)
		{
		BuildCapabilitySet(iExpectedCapabilities, capabilities);
		iCapabilitiesPresent = ETrue;
		}	
	
	CleanupStack::PopAndDestroy(aBody);
	}	

void CExtensionTest::BuildStringListL(RPointerArray<HBufC>& aStrings, const TDesC& aBuf, const TDesC& aTag)
	{
	TInt pos = 0;
	TInt err = 0;	
	do
		{			
		// Find next value for the specified tag and add it to the string array
		// if it exists.
		TPtrC str = Input::ParseElement(aBuf, aTag, pos, err);
		if (err >= 0)
			{
			HBufC* string = str.AllocLC();			
			aStrings.AppendL(string);
			CleanupStack::Pop(string);
			}								
		}
	while (err >= 0);
	}

void CExtensionTest::BuildIntList(RArray<TInt>& aInts, const TDesC& aBuf, const TDesC& aTag)
	{	
	TInt pos = 0;
	TInt err = 0;	
	do
		{			
		// Attempt to convert the contents of val to an int and store in  
		// the aInts array if it is a valid integer.
		TInt n = Input::ParseIntElement(aBuf, aTag, pos, err);
		if (err >= 0)
			{
			// This append should not fail as the parsing went fine. 
			// So, ignoring the leave just to satisfy non leaving method convention.
			TRAP_IGNORE(aInts.AppendL(n));
			}								
		}
	while (err >= 0);
	}

void CExtensionTest::BuildCapabilitySet(TCapabilitySet& aCapabilitySet, const TDesC& aBuf)	
	{
	aCapabilitySet.SetEmpty();
	TUint length = aBuf.Length();
	for (TUint i = 0; i < length && i < ECapability_Limit; i++) 
		{
		if (aBuf[i] == '1')
			{
			aCapabilitySet.AddCapability(static_cast<TCapability>(i));
			}			
		}
	}
			
void CExtensionTest::PerformAction(TRequestStatus& aStatus)
	{
	HBufC8* buf = NULL;
	TInt err = KErrNone;
	
	TRAP(err, buf = Input::ReadFileL(iCertFileName, iFs));
	if (err == KErrNotFound)
		{
		iResult = EFalse;
		iFinished = ETrue;
		SetScriptError(EFileNotFound, iCertFileName);
		TRequestStatus* status = &aStatus;
		iActionState = EPostrequisite;
		User::RequestComplete(status, KErrNone);
		return;
		}
	else if (err != KErrNone)
		{
		User::Leave(err);
		}
		
	CleanupStack::PushL(buf);
	CX509Certificate* cert = CX509Certificate::NewLC(buf->Des());

	Print(_L("Checking certificate extensions in file "));
	PrintLine(iCertFileName);
	
	TBool match = EFalse;
	TBool corrupt = EFalse;
	CheckExtensionsL(*cert, match, corrupt);
	if (corrupt)
		{
		iResult = iExpectedCorrupt;
		if (!iResult)
			{
			Print(_L("Found unexpected corrupt extension."));
			}
		}
	else 
		{
		// no error. test whether the certificate matched the
		// test script.
		iResult = (match == iExpectedMatch);
		}
	CleanupStack::PopAndDestroy(2, buf); // cert, buf	

	TRequestStatus* status = &aStatus;
	iActionState = EPostrequisite;
	User::RequestComplete(status, KErrNone);
	}	
	
void CExtensionTest::CheckExtensionsL(const CX509Certificate& cert, 
	TBool& match, TBool& corrupt)
	{
	TInt err = KErrNone;
	
	match = ETrue;
	corrupt = EFalse;

	TRAP(err, match &= CheckDeviceIdListL(cert));
	if (err == KErrArgument)
		{		
		PrintLine(_L("The device id constraint is corrupt."));
		corrupt = ETrue;
		}
	else if (err != KErrNone) 
		{
		User::Leave(err);
		}	
				
	TRAP(err, match &= CheckSidListL(cert));
	if (err == KErrArgument)
		{		
		PrintLine(_L("The secure id constraint is corrupt."));
		corrupt = ETrue;
		}
	else if (err != KErrNone) 
		{
		User::Leave(err);
		}
		
	TRAP(err, match &= CheckVidListL(cert));
	if (err == KErrArgument)
		{		
		PrintLine(_L("The vendor id constraint is corrupt."));
		corrupt = ETrue;
		}
	else if (err != KErrNone) 
		{
		User::Leave(err);
		}		
		
	TRAP(err, match &= CheckCapabilitiesL(cert));
	if (err == KErrArgument)
		{		
		PrintLine(_L("The capabilities constraint is corrupt."));
		corrupt = ETrue;
		}
	else if (err != KErrNone) 
		{
		User::Leave(err);
		}				
	}
	
TBool CExtensionTest::CheckDeviceIdListL(const CX509Certificate& cert) 
	{
	TBool match = ETrue;
	const CX509CertExtension* ext = cert.Extension(KDeviceIdListConstraint);	
	if (ext)
		{
		// use NewL because this covers NewLC as well
		CX509Utf8StringListExt* stringListExt = CX509Utf8StringListExt::NewL(ext->Data());	
		CleanupStack::PushL(stringListExt);
		if (! IsEqual(stringListExt->StringArray(), iExpectedDeviceIdList))
			{
			PrintLine(_L("Device Id list is different."));
			match = EFalse;
			}
		CleanupStack::PopAndDestroy(stringListExt);		
		}	
	else if (iDeviceIdsPresent) 
		{
		PrintLine(_L("Device Id constraint is missing."));
		match = EFalse;
		}	
	return match;
	}
	
TBool CExtensionTest::CheckSidListL(const CX509Certificate& cert) 
	{
	const CX509CertExtension* ext = cert.Extension(KSidListConstraint);
	TBool match = ETrue;
	if (ext)
		{				
		// use NewL because this covers NewLC as well
		CX509IntListExt* intListExt = CX509IntListExt::NewL(ext->Data());
		CleanupStack::PushL(intListExt);
		if (! IsEqual(intListExt->IntArray(), iExpectedSidList))
			{
			PrintLine(_L("SID list is different"));
			match = EFalse;
			}
		CleanupStack::PopAndDestroy(intListExt);		
		}	
	else if (iSidsPresent) 
		{
			PrintLine(_L("SID constraint is missing."));
			match = EFalse;
		}
	return match;	
	}
	
TBool CExtensionTest::CheckVidListL(const CX509Certificate& cert) 
	{
	const CX509CertExtension* ext = cert.Extension(KVidListConstraint);
	TBool match = ETrue;
	if (ext)
		{
		// use NewL because this covers NewLC as well
		CX509IntListExt* intListExt = CX509IntListExt::NewL(ext->Data());
		CleanupStack::PushL(intListExt);
								
		if (! IsEqual(intListExt->IntArray(), iExpectedVidList))
			{
			PrintLine(_L("VID list is different"));
			match = EFalse;
			}
		CleanupStack::PopAndDestroy(intListExt);		
		}	
	else if (iVidsPresent) 
		{
		PrintLine(_L("VID constraint is missing."));
		match = EFalse;
		}	
	return match;
	}	
	
TBool CExtensionTest::CheckCapabilitiesL(const CX509Certificate& cert) 
	{
	const CX509CertExtension* ext = cert.Extension(KCapabilitiesConstraint);
	TBool match = ETrue;
	if (ext)
		{		
		// use NewL because this covers NewLC as well
		CX509CapabilitySetExt* capabilitySetExt = CX509CapabilitySetExt::NewL(ext->Data());		
		CleanupStack::PushL(capabilitySetExt);
		
		const TCapabilitySet& capabilitySet = capabilitySetExt->CapabilitySet();		

		if (! (capabilitySet.HasCapabilities(iExpectedCapabilities)
			&& iExpectedCapabilities.HasCapabilities(capabilitySet)))
			{
			PrintLine(_L("Capability constraints are different."));
			match = EFalse;
			}
		CleanupStack::PopAndDestroy(capabilitySetExt);		
		}	
	else if (iCapabilitiesPresent) 
		{
		PrintLine(_L("Capability constraint is missing."));
		match = EFalse;
		}	
	return match;		
	}

TBool CExtensionTest::IsEqual(const RArray<TInt>& aArray1, const RArray<TInt>& aArray2) 
	{			
	if (aArray1.Count() == aArray2.Count())
		{
		TInt count = aArray1.Count();				
		for (TInt i = 0; i < count; i++)
			{
			if (aArray1[i] != aArray2[i])
				{
				return EFalse;
				}
			}
		return ETrue;
		}	
	return EFalse;
	}

TBool CExtensionTest::IsEqual(const RPointerArray<HBufC>& aArray1, const RPointerArray<HBufC>& aArray2) 
	{			
	if (aArray1.Count() == aArray2.Count())
		{
		TInt count = aArray1.Count();				
		for (TInt i = 0; i < count; i++)
			{
			if (aArray1[i]->Compare(*aArray2[i]) != 0)
				{
				return EFalse;
				}
			}
		return ETrue;
		}	
	return EFalse;
	}
	
void CExtensionTest::DoReportAction() 
	{	
	}
	
void CExtensionTest::DoCheckResult(TInt /*aError*/)
	{
	}

void CExtensionTest::Print(const TDesC& aText)
	{
	iConsole.Printf(aText);
	iOut.writeString(aText);			
	}
void CExtensionTest::PrintLine(const TDesC& aText)
	{
	iConsole.Printf(aText);
	iConsole.Printf(_L("\n"));
	
	iOut.writeString(aText);			
	iOut.writeNewLine();					
	}