/*

* 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 <x509certchain.h>

EXPORT_C TValidationStatus::TValidationStatus(const TValidationError aError, const TInt aCert)

	:iReason(aError), iCert(aCert)

	{

	}

//x509 cert chain

/**

* If the certificate has decoded the members from TeletexString then the return value 

* may be incorrect because TeletexString type is not fully supported by this library.

* Instead the decode methods perform a direct conversion from 8 to 16bits by adding 

* null characters in the second byte of each character. This will work as expected 

* for cases where the string contains ASCII data.

*/

EXPORT_C CArrayPtrFlat<CX509Certificate>* CX509CertChain::DecodeCertsL(const TDesC8& aBinaryData)

	{

	CArrayPtrFlat<CX509Certificate>* temp = new(ELeave) CArrayPtrFlat<CX509Certificate> (1);

	TCleanupItem cleanupCerts(CleanupCertArray, temp);

	CleanupStack::PushL(cleanupCerts);

	TInt pos = 0;//start at the start

	while (pos < aBinaryData.Length())

		{

		CX509Certificate* cert = CX509Certificate::NewLC(aBinaryData, pos);

		temp->AppendL(cert);

		CleanupStack::Pop();

		}

	CleanupStack::Pop();//temp

	return temp;

	}

EXPORT_C CX509CertChain::~CX509CertChain()

	{

	if (iChain)

		{

		iChain->ResetAndDestroy();

		delete iChain;

		}

	}

EXPORT_C TInt CX509CertChain::Count() const

	{

	return iChain->Count();

	}

EXPORT_C const CX509Certificate& CX509CertChain::Cert(TInt aIndex) const

	{

	return *(iChain->At(aIndex));

	}

EXPORT_C TBool CX509CertChain::IsEqualL(const CX509CertChain& aOther) const

	{

	TInt num1 = Count();

	TInt num2 = aOther.Count();

	if (num1 != num2)

		{

		return EFalse;

		}

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

		{

		const CX509Certificate& cert1 = Cert(i);

		const CX509Certificate& cert2 = aOther.Cert(i);

		if (!cert1.IsEqualL(cert2))

			{

			return EFalse;

			}

		}

	return ETrue;

	}

void CX509CertChain::CleanupCertArray(TAny* aArray)

	{

	CArrayPtrFlat<CX509Certificate>* array = REINTERPRET_CAST(CArrayPtrFlat<CX509Certificate>*, aArray);

	array->ResetAndDestroy();

	delete array;

	}

// x509 certificate warning

EXPORT_C CCertificateValidationWarnings* CCertificateValidationWarnings::NewL(TInt aIndex)

	{

	CCertificateValidationWarnings* self = CCertificateValidationWarnings::NewLC(aIndex);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CCertificateValidationWarnings* CCertificateValidationWarnings::NewLC(TInt aIndex)

	{

	CCertificateValidationWarnings* self = new(ELeave) CCertificateValidationWarnings(aIndex);

	CleanupStack::PushL(self);

	return self;

	}

CCertificateValidationWarnings::CCertificateValidationWarnings(TInt aIndex)

	: iCertIndex(aIndex)

	{

	}

EXPORT_C CCertificateValidationWarnings::~CCertificateValidationWarnings()

	{

	iWarnings.Reset();

	iCriticalExtsFound.ResetAndDestroy();

	}

EXPORT_C const RPointerArray<TDesC>& CCertificateValidationWarnings::CriticalExtensionsFound() const

	{

	return iCriticalExtsFound;

	}

EXPORT_C const RArray<TValidationStatus>& CCertificateValidationWarnings::Warnings() const

	{

	return iWarnings;

	}

EXPORT_C TInt CCertificateValidationWarnings::CertIndex() const

	{

	return iCertIndex;

	}

EXPORT_C CCertificateValidationWarnings* CCertificateValidationWarnings::InternalizeL(RReadStream& aStream)

	{

	// iCertIndex

	TInt certIndex = aStream.ReadInt32L();

	// create a cert warning using the cert index and ref cert

	CCertificateValidationWarnings* certWarning = CCertificateValidationWarnings::NewLC(certIndex);

	// iWarnings

	TInt32 count = aStream.ReadInt32L();

	for (TInt x=0; x<count; ++x)

		{

		TValidationStatus warning(EValidatedOK,0);

		TPckg<TValidationStatus> pckg(warning);

		aStream.ReadL(pckg);

		certWarning->AppendWarningL(warning);	

		}

	// iCriticalExtsFound

	count = aStream.ReadInt32L();

	for (TInt x=0; x<count; ++x)

		{

		TInt length = aStream.ReadInt32L();

		HBufC* oid = HBufC::NewLC(length);

		TPtr oidPtr = oid->Des();

		aStream.ReadL(oidPtr, length);

		certWarning->AppendCriticalExtensionWarningL(*oid);	

		CleanupStack::Pop(oid);

		}	

	CleanupStack::Pop(certWarning);

	return certWarning;

	}

EXPORT_C void CCertificateValidationWarnings::ExternalizeL(RWriteStream& aStream) const

	{

	// iCertIndex;

	aStream.WriteInt32L(iCertIndex);

	// iWarnings;

	TInt x;

	aStream.WriteInt32L(iWarnings.Count());

	for (x=0; x<iWarnings.Count(); ++x)

		{

		aStream.WriteL(TPckgC<TValidationStatus>(iWarnings[x]));

		}	

	// iCriticalExtsFound;

	aStream.WriteInt32L(iCriticalExtsFound.Count());

	for (x=0; x<iCriticalExtsFound.Count(); ++x)

		{

		aStream.WriteInt32L((*iCriticalExtsFound[x]).Length());

		aStream.WriteL(*iCriticalExtsFound[x]);

		}

	}

EXPORT_C void CCertificateValidationWarnings::AppendWarningL(TValidationStatus aWarning)

	{

	iWarnings.AppendL(aWarning);

	}

EXPORT_C void CCertificateValidationWarnings::AppendCriticalExtensionWarningL(TDesC& aCriticalExt)

	{

	iCriticalExtsFound.AppendL(&aCriticalExt);

	}