/*
* Copyright (c) 2005-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: 
*
*/




/**
 @file
*/

#include "tpkixcertval.h"
#include "tcertutils.h"
#include "t_input.h"

//tags for elements in specification file
_LIT(KRootStart, "<root>");
_LIT(KRootEnd, "</root>");
_LIT(KCertificateStart, "<certificate>");
_LIT(KCertificateEnd, "</certificate>");
_LIT(KLabelStart, "<label>");
_LIT(KLabelEnd, "</label>");
_LIT(KEEStart, "<ee>");
_LIT(KEEEnd, "</ee>");
_LIT(KInterStart, "<inter>");
_LIT(KInterEnd, "</inter>");
_LIT(KIPoliciesStart, "<ipolicies>");
_LIT(KIPoliciesEnd, "</ipolicies>");
_LIT(KIPolicyStart, "<ipolicy>");
_LIT(KIPolicyEnd, "</ipolicy>");
_LIT(KOResultStart, "<oresult>");
_LIT(KOResultEnd, "</oresult>");
_LIT(KOPoliciesStart, "<opolicies>");
_LIT(KOPoliciesEnd, "</opolicies>");
_LIT(KOPolicyStart, "<opolicy>");
_LIT(KOPolicyEnd, "</opolicy>");

//const TUint KUnicodeMarker = 0xfeff;

//**Cert Chain**//
CTestChain* CTestChain::NewL(const TDesC& aBuf)
	{
	CTestChain* self = CTestChain::NewLC(aBuf);
	CleanupStack::Pop();
	return self;
	}

CTestChain* CTestChain::NewLC(const TDesC& aBuf)
	{
	CTestChain* self = new(ELeave) CTestChain;
	CleanupStack::PushL(self);
	self->ConstructL(aBuf);
	return self;
	}

CTestChain::~CTestChain()
	{
	delete iIntermediateCertsFileName;
	delete iIntermediateCertsLabel;
	}

CTestChain::CTestChain()
	{
	}

void CTestChain::ConstructL(const TDesC& aBuf)
	{
	TInt pos = 0;
	TInt err = KErrNone;
	TPtrC rootCert(Input::ParseElement(aBuf, KRootStart, KRootEnd, pos, err));
	TInt dummyPos = 0;
	iRootCertFileName = Input::ParseElement(rootCert, KCertificateStart, 
		KCertificateEnd, dummyPos, err);
	iRootCertLabel = Input::ParseElement(rootCert, KLabelStart,
		KLabelEnd, dummyPos, err);
	if (iRootCertLabel == KNullDesC)
		{
		User::Leave(KErrNotFound);
		}

	TPtrC EECert(Input::ParseElement(aBuf, KEEStart, KEEEnd, pos));
	dummyPos = 0;
	iEECertFileName = Input::ParseElement(EECert, KCertificateStart,
		KCertificateEnd, dummyPos);
	iEECertLabel = Input::ParseElement(EECert, KLabelStart,
		KLabelEnd, dummyPos);

	iIntermediateCertsFileName = new(ELeave) CDesCArrayFlat(1);
	iIntermediateCertsLabel = new(ELeave) CDesCArrayFlat(1);
	while(AddInter(aBuf, pos))
		{
		}
	}

TBool CTestChain::AddInter(const TDesC& aBuf, TInt& aPos)
	{
	TPtrC interBuf = Input::ParseElement(aBuf, KInterStart, KInterEnd, aPos);
	TInt dummyPos = 0;
	if (interBuf != KNullDesC)
		{
		iIntermediateCertsFileName->AppendL(Input::ParseElement(interBuf, 
			KCertificateStart, KCertificateEnd, dummyPos));
		iIntermediateCertsLabel->AppendL(Input::ParseElement(interBuf,
			KLabelStart, KLabelEnd, dummyPos));
		return ETrue;
		}
	return EFalse;
	}

//**Policy Input/Output**//
CTestParameters* CTestParameters::NewL(const TDesC& aBuf)
	{
	CTestParameters* self = CTestParameters::NewLC(aBuf);
	CleanupStack::Pop();
	return self;
	}

CTestParameters* CTestParameters::NewLC(const TDesC& aBuf)
	{
	CTestParameters* self = new(ELeave) CTestParameters;
	CleanupStack::PushL(self);
	self->ConstructL(aBuf);
	return self;
	}

CTestParameters::~CTestParameters()
	{
	delete iWarnings;
	delete iPolicyInput;
	delete iExpectedPolicyOutput;
	}

CTestParameters::CTestParameters()
	:iIPoliciesSet(ETrue), iOPoliciesSet(ETrue), iOWarningsSet(ETrue)
	{
	}

void CTestParameters::ConstructL(const TDesC& aBuf)
	{
	iWarnings = new(ELeave)CArrayFixFlat<TValidationStatus> (1);
	iPolicyInput = new(ELeave) CDesCArrayFlat (1);
	iExpectedPolicyOutput = new(ELeave) CDesCArrayFlat (1);

	TInt pos = 0;
	TInt err = KErrNone;
	TPtrC iIPolicyBuf = Input::ParseElement(aBuf, KIPoliciesStart, KIPoliciesEnd, pos, err);
	if (err != KErrNone)
		{
		iIPoliciesSet = EFalse;//input policies are optional
		}
	pos = 0;
	while(AddPolicy(iIPolicyBuf, KIPolicyStart, KIPolicyEnd,pos, *iPolicyInput))
		{
		}	
	iError = Input::ParseElement(aBuf, KOResultStart, KOResultEnd, pos);
	TPtrC iOPolicyBuf = Input::ParseElement(aBuf, KOPoliciesStart, KOPoliciesEnd, pos, err);
	if (err != KErrNone)
		{
		iOPoliciesSet = EFalse;//output policies are optional
		}
	pos = 0;
	while(AddPolicy(iOPolicyBuf, KOPolicyStart, KOPolicyEnd, pos, *iExpectedPolicyOutput))
		{
		}	
	}

TBool CTestParameters::AddPolicy(const TDesC& aBuf, const TDesC& aStart, const TDesC& aEnd, TInt& aPos, CDesCArray& aPolicySet)
	{
	TPtrC policyBuf = Input::ParseElement(aBuf, aStart, aEnd, aPos);
	if (policyBuf != KNullDesC)
		{
		aPolicySet.AppendL(policyBuf);
		return ETrue;
		}
	return EFalse;
	}