/*

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

#include "pkixcertchainao.h"

#include "pkixCons.h"

#include "pkixcertstate.h"

#include "pkixcerts.h"

//**********************************************************************************//

EXPORT_C CPKIXCertChainBase* CPKIXCertChainBase::NewL(MCertStore& aCertStore,

													  const TPtrC8& aEncodedCerts, 

													  const TUid aClient)

	{

	CPKIXCertChainBase* self = CPKIXCertChainBase::NewLC(aCertStore, aEncodedCerts, aClient);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CPKIXCertChainBase* CPKIXCertChainBase::NewLC(MCertStore& aCertStore,

													   const TPtrC8& aEncodedCerts,

													   const TUid aClient)

	{

	CPKIXCertChainBase* self = new(ELeave) CPKIXCertChainBase();

	CleanupStack::PushL(self);

	self->ConstructL(aCertStore, aEncodedCerts, aClient);

	return self;

	}

EXPORT_C CPKIXCertChainBase* CPKIXCertChainBase::NewL(MCertStore& aCertStore,

													  const TPtrC8& aEncodedCerts,

													  const RPointerArray<CX509Certificate>& aRootCerts)

	{

	CPKIXCertChainBase* self = CPKIXCertChainBase::NewLC(aCertStore, aEncodedCerts, aRootCerts);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CPKIXCertChainBase* CPKIXCertChainBase::NewLC(MCertStore& aCertStore,

													   const TPtrC8& aEncodedCerts,

													   const RPointerArray<CX509Certificate>& aRootCerts)

	{

	CPKIXCertChainBase* self = new(ELeave) CPKIXCertChainBase();

	CleanupStack::PushL(self);

	self->ConstructL(aCertStore, aEncodedCerts, aRootCerts);

	return self;

	}

EXPORT_C CPKIXCertChainBase::~CPKIXCertChainBase()

	{

	iIntermediateCerts.ResetAndDestroy();

	iIntermediateCerts.Close();

	iSupportedCriticalExts.Close();

	delete iActiveObject;

	}

//end of ctors & dtor

EXPORT_C void CPKIXCertChainBase::ValidateL(CPKIXValidationResultBase& aValidationResult,

										const TTime& aValidationTime,

										TRequestStatus& aStatus)

	{

	iActiveObject->ValidateL(aValidationResult, aValidationTime, NULL, aStatus);

	}

EXPORT_C void CPKIXCertChainBase::ValidateL(CPKIXValidationResultBase& aValidationResult,

										const TTime& aValidationTime,								 

										const CArrayPtr<HBufC>& aInitialPolicies,

										TRequestStatus& aStatus)

	{

	iActiveObject->ValidateL(aValidationResult, aValidationTime, &aInitialPolicies, aStatus);

	}

EXPORT_C void CPKIXCertChainBase::CancelValidate()

	{

	iActiveObject->CancelValidate();

	}

EXPORT_C TBool CPKIXCertChainBase::ChainHasRoot() const

	{

	return iChainHasRoot;

	}

EXPORT_C void CPKIXCertChainBase::AddCertL(const TPtrC8& aEncodedCerts)

	{

	AddIntermediateCertsL(aEncodedCerts);

	}

EXPORT_C const RPointerArray<TDesC>& CPKIXCertChainBase::SupportedCriticalExtensions() const

	{

	return iSupportedCriticalExts;

	}

EXPORT_C void CPKIXCertChainBase::AddSupportedCriticalExtensionsL(const RPointerArray<TDesC>& aCriticalExtOids)

	{

	TBool notPresent;

	TInt count = aCriticalExtOids.Count();

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

		{

		notPresent = ETrue;

		for (TInt y=0; y < iSupportedCriticalExts.Count(); ++y)

			{

			if (*aCriticalExtOids[x] == *iSupportedCriticalExts[y])

				{

				notPresent = EFalse;

				break;

				}

			}

		if (notPresent)

			{

			iSupportedCriticalExts.AppendL(aCriticalExtOids[x]);

			}

		}

	}

EXPORT_C void CPKIXCertChainBase::RemoveSupportedCriticalExtensions(const RPointerArray<TDesC>& aCriticalExtOids)

	{

	TInt count = iSupportedCriticalExts.Count();

	TInt newCount = aCriticalExtOids.Count();

	if (count > 0)

		{

		for (TInt x=count - 1; x >= 0; --x)

			{

			for (TInt y=0; y < newCount; ++y)

				{

				if (*aCriticalExtOids[y] == *iSupportedCriticalExts[x])

					{

					iSupportedCriticalExts.Remove(x);

					break;

					}

				}

			}

		}

	}

EXPORT_C void CPKIXCertChainBase::SetSupportedCriticalExtensionsL(const RPointerArray<TDesC>& aCriticalExtOids)

	{

	iSupportedCriticalExts.Reset();

	AddSupportedCriticalExtensionsL(aCriticalExtOids);

	}

EXPORT_C void CPKIXCertChainBase::ResetSupportedCriticalExtsToDefaultL()

	{

	iSupportedCriticalExts.Reset();

	// standard X.509 extensions

	iSupportedCriticalExts.AppendL(&KExtendedKeyUsage);

	iSupportedCriticalExts.AppendL(&KPolicyMapping);		// RFC - MUST be non-critical

	iSupportedCriticalExts.AppendL(&KSubjectAltName);

	iSupportedCriticalExts.AppendL(&KKeyUsage);	

	iSupportedCriticalExts.AppendL(&KBasicConstraints);

	iSupportedCriticalExts.AppendL(&KNameConstraints);

	iSupportedCriticalExts.AppendL(&KPolicyConstraints);

	iSupportedCriticalExts.AppendL(&KCertPolicies);	

	iSupportedCriticalExts.AppendL(&KInhibitAnyPolicy);

	// Symbian critical extensions

	iSupportedCriticalExts.AppendL(&KDeviceIdListConstraint);

	iSupportedCriticalExts.AppendL(&KSidListConstraint);

	iSupportedCriticalExts.AppendL(&KVidListConstraint);

	iSupportedCriticalExts.AppendL(&KCapabilitiesConstraint);

	}

EXPORT_C void CPKIXCertChainBase::SetValidityPeriodCheckFatal(TBool aIsFatal)

	{

	iDateTimeCheckFatal = aIsFatal;

	}

EXPORT_C TBool CPKIXCertChainBase::ValidityPeriodCheckFatal() const

	{

	return iDateTimeCheckFatal;

	}

//private functions

//************************************************************************//

EXPORT_C CPKIXCertChainBase::CPKIXCertChainBase()

	: iChainHasRoot(EFalse), iDateTimeCheckFatal(ETrue)

	{

	}

EXPORT_C void CPKIXCertChainBase::ConstructL(MCertStore& aCertStore, const TPtrC8& aEncodedCerts, 

											 TUid aClient)

	{

	iActiveObject = CPKIXCertChainAO::NewL(aCertStore, *this, aClient);

	DoConstructL(aEncodedCerts);

	}

/**

 * Second-phase constructor

 * This constructor takes a set of root certificates we trust. We don't take into account 

 * the certificates in the certificate store because we are not interested in the

 * trust model of that store (where each certificates comes with a set of uid of the 

 * applications that trust this certificate)

 * this is consistent with the fact that in FindIssuer, we only look for non-root

 * certs in the store

 */

EXPORT_C void CPKIXCertChainBase::ConstructL(MCertStore& aCertStore, const TPtrC8& aEncodedCerts,

											 const RPointerArray<CX509Certificate>& aRootCerts)

	{

	iActiveObject = CPKIXCertChainAO::NewL(aCertStore, *this, aRootCerts);

	DoConstructL(aEncodedCerts);

	}

void CPKIXCertChainBase::DoConstructL(const TPtrC8& aEncodedCerts)

	{

	iChain = new(ELeave) CArrayPtrFlat<CX509Certificate> (1);

	TInt pos = 0;

	CX509Certificate* eeCert = CX509Certificate::NewLC(aEncodedCerts, pos);

	iChain->AppendL(eeCert);

	CleanupStack::Pop(eeCert);

	AddIntermediateCertsL(aEncodedCerts);

	ResetSupportedCriticalExtsToDefaultL();

	}

void CPKIXCertChainBase::AddIntermediateCertsL(const TPtrC8& aEncodedCerts)

	{

//decode aEncodedCerts, and add any that aren't self-signed

	TInt pos = 0;

	TInt end = aEncodedCerts.Length();

	while (pos < end)

		{

		CX509Certificate* decoded = CX509Certificate::NewLC(aEncodedCerts, pos);

		if (decoded->IsSelfSignedL())

			{

			// Then it's no use to us because it cannot be part of a chain with a

			// root certificate we trust.

			CleanupStack::PopAndDestroy(decoded);

			}

		else

			{

			User::LeaveIfError(iIntermediateCerts.Append(decoded));

			CleanupStack::Pop(decoded);

			}

		}

	}

void CPKIXCertChainBase::RemoveLastCerts(TInt aNumberOfCertsToRemove)

	{

	__ASSERT_DEBUG(iChain->Count() >= aNumberOfCertsToRemove,

		User::Panic(_L("CPKIXCertChain"), 1));

	// We don't have to change i because it is the count of the array that decreases

	for (TInt i = iChain->Count() - aNumberOfCertsToRemove; i < iChain->Count(); )

		{

		delete (*iChain)[i];

		iChain->Delete(i);

		}

	}

CArrayPtrFlat<CX509Certificate>& CPKIXCertChainBase::Chain()

	{

	__ASSERT_ALWAYS(iChain, User::Panic(_L("CPKICCertChainBase"), 1));

	return *iChain;

	}

const RPointerArray<CX509Certificate>& CPKIXCertChainBase::IntermediateCerts()

	{

	return iIntermediateCerts;

	}

TBool CPKIXCertChainBase::ChainHasRoot()

	{

	return iChainHasRoot;

	}

void CPKIXCertChainBase::SetChainHasRoot(TBool aHasRoot)

	{

	iChainHasRoot = aHasRoot;

	}