/*

 * 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;

 	}