/*
* 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);
	}