/*
* 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: 
* X509CERTEXT.CPP
*
*/


#include <s32strm.h>
#include <x509certext.h>
#include <asn1dec.h>

void CX509ExtensionBase::ConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecGeneric dec(aBinaryData.Right(aBinaryData.Length() - aPos));
	dec.InitL();
	if (dec.Tag() != EASN1OctetString)
		{
		User::Leave(KErrArgument);
		}
	TInt end = aPos + dec.LengthDER();
	aPos += dec.LengthDERHeader();//add on header for octet string here
//pass in binary data with aPos set to start of contents octets of octet string
//we cheat a little here; since we know an octet string is just the contents octets, 
//we just pass in a reference to the contents octets, and save alloc'ing the whole thang
	DoConstructL(aBinaryData, aPos);	
	if (aPos != end)
		{
		User::Leave(KErrArgument);
		}
	}

//1) basic constraints...
EXPORT_C CX509BasicConstraintsExt* CX509BasicConstraintsExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509BasicConstraintsExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509BasicConstraintsExt* CX509BasicConstraintsExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509BasicConstraintsExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509BasicConstraintsExt* CX509BasicConstraintsExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509BasicConstraintsExt* self = CX509BasicConstraintsExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509BasicConstraintsExt* CX509BasicConstraintsExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509BasicConstraintsExt* self = new(ELeave) CX509BasicConstraintsExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509BasicConstraintsExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
//sequence of 2 optional components, a bool and an int
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos);
	TInt count = seq->Count();
	TInt pos = 0;
	if (pos < count)
		{
		TBool doneInt = EFalse;
		TASN1DecGeneric* curr = seq->At(pos);
		pos++;
		if (curr->Tag() == EASN1Boolean)
			{
			TASN1DecBoolean encBool;
			iIsCA = encBool.DecodeDERL(*curr);
			}
		else
			{
			TASN1DecInteger encInt;
			iMaxChainLen = encInt.DecodeDERShortL(*curr);
			doneInt = ETrue;
			}
		if (pos < count)
			{
			if (doneInt)
				{
				User::Leave(KErrArgument);
				}
			curr = seq->At(pos);
			pos++;
			TASN1DecInteger encInt;
			iMaxChainLen = encInt.DecodeDERShortL(*curr);
			if (iMaxChainLen < 0)
				{
				User::Leave(KErrArgument);
				}
			}
		}
	if (pos != count)
		{
		User::Leave(KErrArgument);
		}
	CleanupStack::PopAndDestroy();//seq
	}

CX509BasicConstraintsExt::CX509BasicConstraintsExt()
	:iIsCA(EFalse), iMaxChainLen(KMaxTInt)
	{
	}

CX509BasicConstraintsExt::~CX509BasicConstraintsExt()
	{
	}

EXPORT_C TBool CX509BasicConstraintsExt::IsCA() const
	{
	return iIsCA;
	}

EXPORT_C TInt CX509BasicConstraintsExt::MaxChainLength() const
	{
	return iMaxChainLen;
	}
	
//2) alt name
//#pragma message ("creating empty CX509AltNameExt and destroying it kills process")
EXPORT_C CX509AltNameExt* CX509AltNameExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509AltNameExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509AltNameExt* CX509AltNameExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509AltNameExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509AltNameExt* CX509AltNameExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509AltNameExt* self = CX509AltNameExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509AltNameExt* CX509AltNameExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509AltNameExt* self = new(ELeave) CX509AltNameExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509AltNameExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	// The sequence should have at least 1 name here, previously this was checked
	// but now zero lengths sequences are tolerated.
	//
	// RFC 3280 requires that CAs ensure that the SubjectAltName is not empty if it exists. The 
	// behaviour of the client is undefined if this condition occurs. Since this code will 
	// normally be used as a client (i.e. not the CA) and there should be no need to validate 
	// the SubjectAltName we do not enfore a minimum sequence length.
	// This avoids TLS connections being dropped unecessarily.

	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 0, KMaxTInt);
	TInt count = seq->Count();
	iAuthorityName = new(ELeave) CArrayPtrFlat<CX509GeneralName> (1);
	TASN1DecGeneric* gen;
	for (TInt i = 0; i < count; i++)
		{
		gen = seq->At(i);
		CX509GeneralName* gn = CX509GeneralName::NewLC(gen->Encoding());
		iAuthorityName->AppendL(gn);
		CleanupStack::Pop();//gn
		}
	CleanupStack::PopAndDestroy();
	}

CX509AltNameExt::~CX509AltNameExt()
	{
	if (iAuthorityName != NULL)
		{
		iAuthorityName->ResetAndDestroy();
		delete iAuthorityName;
		}
	}

EXPORT_C const CArrayPtrFlat<CX509GeneralName>& CX509AltNameExt::AltName() const
	{
	return *iAuthorityName;
	}

EXPORT_C TBool CX509AltNameExt::Match(const CX509AltNameExt& aExt) const
	{
	TBool res = EFalse;
	const CArrayPtrFlat<CX509GeneralName>& otherGNs = aExt.AltName();
	TInt otherGNCount = otherGNs.Count();
	TInt thisGNCount = iAuthorityName->Count();
	if (otherGNCount != thisGNCount)
		{
		}
	else
		{
		res = ETrue;
		for (TInt j = 0; j < otherGNCount; j++)
				{
				const CX509GeneralName* otherGN = otherGNs.At(j);
				const CX509GeneralName* thisGN = iAuthorityName->At(j);
				if (!thisGN->ExactMatch(*otherGN))
					{
					res = EFalse;
					}
				}
		}
	return res;
	}

CX509AltNameExt::CX509AltNameExt()
	{
	}

//3) key usage
CX509BitString::~CX509BitString()
	{
	delete iData;
	}

TBool CX509BitString::IsSet(TInt aBit) const
	{
	if (aBit < iLength)//offset from zero
		{
		TPtrC8 d(iData->Des());
		TUint8 oct = d[(aBit/8)];
		TUint mask = (1 << (7-(aBit % 8)));
		return (oct & mask);
		}
	return EFalse;
	}

CX509BitString::CX509BitString(HBufC8* aData, TInt aLength)
	:iData(aData), iLength(aLength)
	{
	}

EXPORT_C CX509KeyUsageExt* CX509KeyUsageExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509KeyUsageExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509KeyUsageExt* CX509KeyUsageExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509KeyUsageExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509KeyUsageExt* CX509KeyUsageExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509KeyUsageExt* self = CX509KeyUsageExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509KeyUsageExt* CX509KeyUsageExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509KeyUsageExt* self = new(ELeave) CX509KeyUsageExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509KeyUsageExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecGeneric gen(aBinaryData.Right(aBinaryData.Length() - aPos));
	gen.InitL();
	if (gen.Tag() != EASN1BitString)
		{
		User::Leave(KErrArgument);
		}
	TPtrC8 p(gen.GetContentDER());
	if (p.Length() < 2)
		{
		User::Leave(KErrArgument);
		}
	TPtrC8 pData(p.Right(p.Length() - 1));
	TInt paddingLength = p[0];
	TInt bitStringLength = (pData.Length() * 8) - paddingLength;
	HBufC8* bitString = pData.AllocL();
	CleanupStack::PushL(bitString);
	iData = new(ELeave) CX509BitString(bitString, bitStringLength);
	CleanupStack::Pop();//bitstring
	aPos += gen.LengthDER();
	}

CX509KeyUsageExt::CX509KeyUsageExt()
	{
	}

CX509KeyUsageExt::~CX509KeyUsageExt()
	{
	delete iData;
	}

EXPORT_C TBool CX509KeyUsageExt::IsSet(TX509KeyUsage aUsage) const
	{
	return iData->IsSet(aUsage);
	}

//4) name constraints
CX509GeneralSubtree* CX509GeneralSubtree::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509GeneralSubtree::NewL(aBinaryData, pos);
	}

CX509GeneralSubtree* CX509GeneralSubtree::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509GeneralSubtree::NewLC(aBinaryData, pos);
	}

CX509GeneralSubtree* CX509GeneralSubtree::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509GeneralSubtree* self = CX509GeneralSubtree::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

CX509GeneralSubtree* CX509GeneralSubtree::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509GeneralSubtree* self = new(ELeave) CX509GeneralSubtree;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509GeneralSubtree::ConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);//(seq here must have at least 1 name)
	TInt count = seq->Count();
	TInt pos = 0;
	TASN1DecGeneric* curr = seq->At(pos);
	pos++;
	iName = CX509GeneralName::NewL(curr->Encoding());
	if (pos < count)
		{
		TBool doneMax = EFalse;
		curr = seq->At(pos);
		pos++;
		if (curr->Class() != EContextSpecific)
				{
				User::Leave(KErrArgument);
				}
			switch(curr->Tag())
				{
				case 0:
					{
					TASN1DecInteger encInt;
					iMinDist = encInt.DecodeDERShortL(*curr);
					break;
					}
				case 1:
					{
					TASN1DecInteger encInt;
					iMaxDist = encInt.DecodeDERShortL(*curr);
					doneMax = ETrue;
					break;
					}
				}
			if (pos < count)
				{
				curr = seq->At(pos);
				if ((doneMax) || (curr->Class() != EContextSpecific) || (curr->Tag() != 1))
					{
					User::Leave(KErrArgument);
					}
				TASN1DecInteger encInt;
				iMaxDist = encInt.DecodeDERShortL(*curr);
				}
		}
	if (pos != count)
		{
		User::Leave(KErrArgument);
		}
	CleanupStack::PopAndDestroy();
	}

CX509GeneralSubtree::~CX509GeneralSubtree()
	{
	delete iName;
	}

EXPORT_C const CX509GeneralName& CX509GeneralSubtree::Name() const
	{
	return *iName;
	}

EXPORT_C TInt CX509GeneralSubtree::MinDistance() const
	{
	return iMinDist;
	}

EXPORT_C TInt CX509GeneralSubtree::MaxDistance() const
	{
	return iMaxDist;
	}

CX509GeneralSubtree::CX509GeneralSubtree()
	:iMaxDist(KMaxTInt), iMinDist(0)
	{
	}

//
EXPORT_C CX509NameConstraintsExt* CX509NameConstraintsExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509NameConstraintsExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509NameConstraintsExt* CX509NameConstraintsExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509NameConstraintsExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509NameConstraintsExt* CX509NameConstraintsExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509NameConstraintsExt* self = CX509NameConstraintsExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509NameConstraintsExt* CX509NameConstraintsExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509NameConstraintsExt* self = new(ELeave) CX509NameConstraintsExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509NameConstraintsExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos);
	TInt count = seq->Count();
	TInt pos = 0;

	iExcludedSubtrees = new(ELeave) CArrayPtrFlat<CX509GeneralSubtree> (1);
	iPermittedSubtrees = new(ELeave) CArrayPtrFlat<CX509GeneralSubtree> (1);
	TBool doneExcluded = EFalse;
	
	if (pos < count)
		{
		TASN1DecGeneric* curr = seq->At(pos);
		pos++;
		if (curr->Class() != EContextSpecific)
			{
			User::Leave(KErrArgument);
			}
		switch (curr->Tag())
			{
			case 0:
				{
				AddSubtreesL(*iPermittedSubtrees, curr->Encoding());
				break;
				}
			case 1:
				{
				AddSubtreesL(*iExcludedSubtrees, curr->Encoding());
				doneExcluded = ETrue;
				break;
				}
			default:
				{
				User::Leave(KErrArgument);
				}
			}
		if (pos < count)
			{
			curr = seq->At(pos);
			pos++;
			if ((curr->Class() != EContextSpecific) || (curr->Tag() != 1) || (doneExcluded))
				{
				User::Leave(KErrArgument);
				}
			AddSubtreesL(*iExcludedSubtrees, curr->Encoding());
			}
		}
	CleanupStack::PopAndDestroy();//seq
	}

void CX509NameConstraintsExt::AddSubtreesL(	CArrayPtrFlat<CX509GeneralSubtree>& aSubtrees,
											const TDesC8& aBinaryData)
	{
	TASN1DecSequence encSeq;
	TInt pos = 0;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, pos, 1, KMaxTInt);
	TInt count = seq->Count();
	TASN1DecGeneric* gen;
	for(TInt i = 0; i < count; i++)
		{
		gen = seq->At(i);
		CX509GeneralSubtree* subtree = CX509GeneralSubtree::NewLC(gen->Encoding());
		aSubtrees.AppendL(subtree);
		CleanupStack::Pop();
		}
	CleanupStack::PopAndDestroy();
	}

EXPORT_C CX509NameConstraintsExt::~CX509NameConstraintsExt()
	{
	if (iExcludedSubtrees != NULL)
		{
		iExcludedSubtrees->ResetAndDestroy();
		delete iExcludedSubtrees;
		}
	if (iPermittedSubtrees != NULL)
		{
		iPermittedSubtrees->ResetAndDestroy();
		delete iPermittedSubtrees;
		}
	}

EXPORT_C const CArrayPtrFlat<CX509GeneralSubtree>& CX509NameConstraintsExt::ExcludedSubtrees() const
	{
	return *iExcludedSubtrees;
	}

EXPORT_C const CArrayPtrFlat<CX509GeneralSubtree>& CX509NameConstraintsExt::PermittedSubtrees() const
	{
	return *iPermittedSubtrees;
	}

CX509NameConstraintsExt::CX509NameConstraintsExt()
	{
	}

//5) policy constraints
TX509PolicyConstraint::TX509PolicyConstraint(TBool aRequired, TInt aCountdown)
	:iRequired(aRequired), iCountdown(aCountdown)
	{
	}

TX509PolicyConstraint::TX509PolicyConstraint()
	:iRequired(EFalse), iCountdown(0)
	{
	}

//
EXPORT_C CX509PolicyConstraintsExt* CX509PolicyConstraintsExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509PolicyConstraintsExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509PolicyConstraintsExt* CX509PolicyConstraintsExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509PolicyConstraintsExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509PolicyConstraintsExt* CX509PolicyConstraintsExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509PolicyConstraintsExt* self = CX509PolicyConstraintsExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509PolicyConstraintsExt* CX509PolicyConstraintsExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509PolicyConstraintsExt* self = new(ELeave) CX509PolicyConstraintsExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509PolicyConstraintsExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos);
	TInt count = seq->Count();
	TInt pos = 0;
	TASN1DecGeneric* curr;
	if (pos < count)
		{
		curr = seq->At(pos);
		pos++;
		if (curr->Class() != EContextSpecific)
			{
			User::Leave(KErrArgument);
			}
		switch (curr->Tag())
			{
			case 0:
				{
				iRequirePolicy.iRequired = ETrue;
				TASN1DecInteger encInt;
				iRequirePolicy.iCountdown = encInt.DecodeDERShortL(*curr);
				break;
				}
			case 1:
				{
				iInhibitPolicyMapping.iRequired = ETrue;
				TASN1DecInteger encInt;
				iInhibitPolicyMapping.iCountdown = encInt.DecodeDERShortL(*curr);
				break;
				}
			default:
				{
				User::Leave(KErrArgument);
				}
			}
		if(pos < count)
			{
			curr = seq->At(pos);
			pos++;
			if ((iInhibitPolicyMapping.iRequired) || (curr->Class() != EContextSpecific) || (curr->Tag() != 1))
				{
				User::Leave(KErrArgument);
				}
			iInhibitPolicyMapping.iRequired = ETrue;
			TASN1DecInteger encInt;
			iInhibitPolicyMapping.iCountdown = encInt.DecodeDERShortL(*curr);
			}
		}
	if (pos != count)
		{
		User::Leave(KErrArgument);
		}
	CleanupStack::PopAndDestroy();
	}

CX509PolicyConstraintsExt::CX509PolicyConstraintsExt()
	{
	}

EXPORT_C CX509PolicyConstraintsExt::~CX509PolicyConstraintsExt()
	{
	}

EXPORT_C TX509PolicyConstraint CX509PolicyConstraintsExt::ExplicitPolicyRequired() const
	{
	return iRequirePolicy;
	}

EXPORT_C TX509PolicyConstraint CX509PolicyConstraintsExt::InhibitPolicyMapping() const
	{
	return iInhibitPolicyMapping;
	}

//6) policies
CX509PolicyQualifierInfo* CX509PolicyQualifierInfo::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509PolicyQualifierInfo::NewL(aBinaryData, pos);
	}

CX509PolicyQualifierInfo* CX509PolicyQualifierInfo::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509PolicyQualifierInfo::NewLC(aBinaryData, pos);
	}

CX509PolicyQualifierInfo* CX509PolicyQualifierInfo::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509PolicyQualifierInfo* self = CX509PolicyQualifierInfo::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

CX509PolicyQualifierInfo* CX509PolicyQualifierInfo::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509PolicyQualifierInfo* self = new(ELeave) CX509PolicyQualifierInfo;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

CX509PolicyQualifierInfo* CX509PolicyQualifierInfo::NewL(const CX509PolicyQualifierInfo& aQualifier)
	{
	CX509PolicyQualifierInfo* self = CX509PolicyQualifierInfo::NewLC(aQualifier);
	CleanupStack::Pop();//self
	return self;
	}

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

CX509PolicyQualifierInfo* CX509PolicyQualifierInfo::NewL(RReadStream& aStream)
	{
	CX509PolicyQualifierInfo* self = CX509PolicyQualifierInfo::NewLC(aStream);
	CleanupStack::Pop();
	return self;
	}

CX509PolicyQualifierInfo* CX509PolicyQualifierInfo::NewLC(RReadStream& aStream)
	{
	CX509PolicyQualifierInfo* self = new(ELeave) CX509PolicyQualifierInfo();
	CleanupStack::PushL(self);
	self->ConstructL(aStream);
	return self;
	}

void CX509PolicyQualifierInfo::ConstructL(RReadStream& aStream)
	{
	InternalizeL(aStream);
	}

void CX509PolicyQualifierInfo::ConstructL(const CX509PolicyQualifierInfo& aQualifier)
	{
	iPolicyQualifierId = aQualifier.iPolicyQualifierId->Des().AllocL();//must be a better way to do this!!
	iData = aQualifier.iData->Des().AllocL();//must be a better way to do this!!
	}

void CX509PolicyQualifierInfo::ConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);
	TInt count = seq->Count();
	TInt pos = 0;
	TASN1DecGeneric* curr = seq->At(pos);
	pos++;
	TASN1DecObjectIdentifier encOID;
	iPolicyQualifierId = encOID.DecodeDERL(*curr);
	if (pos < count)
		{
		iData = curr->Encoding().AllocL();
		pos++;
		}
	else
		{
		iData = HBufC8::NewL(1);
		*iData = KNullDesC8;
		}
	if (pos != count)
		{
		User::Leave(KErrArgument);
		}
	CleanupStack::PopAndDestroy();
	}

CX509PolicyQualifierInfo::CX509PolicyQualifierInfo()
	{
	}

CX509PolicyQualifierInfo::~CX509PolicyQualifierInfo()
	{
	delete iPolicyQualifierId;
	delete iData;
	}

EXPORT_C TPtrC CX509PolicyQualifierInfo::Id() const
	{
	return iPolicyQualifierId->Des();
	}

EXPORT_C TPtrC8 CX509PolicyQualifierInfo::Data() const
	{
	return iData->Des();
	}

void CX509PolicyQualifierInfo::ExternalizeL(RWriteStream& aStream) const
	{
	//iPolicyQualifierId
	aStream << *iPolicyQualifierId;

	//iData
	aStream << *iData;
	}

void CX509PolicyQualifierInfo::InternalizeL(RReadStream& aStream)
	{
	//iPolicyQualifierId
	delete iPolicyQualifierId;
	iPolicyQualifierId=0;
	iPolicyQualifierId=HBufC::NewL(aStream, KMaxTInt);

	//iData
	delete iData;
	iData=0;
	iData=HBufC8::NewL(aStream, KMaxTInt);
	}


CX509CertPolicyInfo* CX509CertPolicyInfo::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509CertPolicyInfo::NewL(aBinaryData, pos);
	}

CX509CertPolicyInfo* CX509CertPolicyInfo::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509CertPolicyInfo::NewLC(aBinaryData, pos);
	}

CX509CertPolicyInfo* CX509CertPolicyInfo::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509CertPolicyInfo* self = CX509CertPolicyInfo::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

CX509CertPolicyInfo* CX509CertPolicyInfo::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509CertPolicyInfo* self = new(ELeave) CX509CertPolicyInfo;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}


EXPORT_C CX509CertPolicyInfo* CX509CertPolicyInfo::NewL(RReadStream& aStream)
	{
	CX509CertPolicyInfo* self = CX509CertPolicyInfo::NewLC(aStream);
	CleanupStack::Pop();
	return self;
	}
 
EXPORT_C CX509CertPolicyInfo* CX509CertPolicyInfo::NewLC(RReadStream& aStream)
	{
	CX509CertPolicyInfo* self = new(ELeave) CX509CertPolicyInfo();
	CleanupStack::PushL(self);
	self->ConstructL(aStream);
	return self;
	}

EXPORT_C CX509CertPolicyInfo* CX509CertPolicyInfo::NewL(const CX509CertPolicyInfo& aInfo)
	{
	CX509CertPolicyInfo* self = CX509CertPolicyInfo::NewLC(aInfo);
	CleanupStack::Pop();//self
	return self;
	}

EXPORT_C CX509CertPolicyInfo* CX509CertPolicyInfo::NewLC(const CX509CertPolicyInfo& aInfo)
	{
	CX509CertPolicyInfo* self = new(ELeave) CX509CertPolicyInfo;
	CleanupStack::PushL(self);
	self->ConstructL(aInfo);
	return self;
	}

void CX509CertPolicyInfo::ConstructL(RReadStream& aStream)
	{
	InternalizeL(aStream);
	}

void CX509CertPolicyInfo::ConstructL(const CX509CertPolicyInfo& aInfo)
	{
	iCertPolicyId = aInfo.iCertPolicyId->Des().AllocL();//must be a better way to do this!!
	iQualifiers = new(ELeave) CArrayPtrFlat<CX509PolicyQualifierInfo> (1);
	TInt count = aInfo.iQualifiers->Count();
	for (TInt i = 0; i < count; i++)
		{
		CX509PolicyQualifierInfo* q = CX509PolicyQualifierInfo::NewLC(*(aInfo.iQualifiers->At(i)));
		iQualifiers->AppendL(q);
		CleanupStack::Pop();//q
		}
	}

void CX509CertPolicyInfo::ConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);
	TInt count = seq->Count();
	TInt pos = 0;
	TASN1DecGeneric* curr = seq->At(pos);
	pos++;

	TASN1DecObjectIdentifier encOID;
	iCertPolicyId = encOID.DecodeDERL(*curr);
	iQualifiers = new(ELeave) CArrayPtrFlat<CX509PolicyQualifierInfo> (1);
	if (pos < count)
		{
		curr = seq->At(pos);
		pos++;
		TASN1DecSequence encSeqQualifier;
		CArrayPtrFlat<TASN1DecGeneric>* seqQualifier = encSeqQualifier.DecodeDERLC(*curr);
		TInt qCount = seqQualifier->Count();
		for(TInt i = 0; i < qCount; i++)
			{
			TASN1DecGeneric* qGen = seqQualifier->At(i);
			CX509PolicyQualifierInfo* qualifier = CX509PolicyQualifierInfo::NewLC(qGen->Encoding());
			iQualifiers->AppendL(qualifier);
			CleanupStack::Pop();//qualifier
			}
		CleanupStack::PopAndDestroy();
		}
	if (pos != count)
		{
		User::Leave(KErrArgument);
		}
	CleanupStack::PopAndDestroy();
	}

CX509CertPolicyInfo::~CX509CertPolicyInfo()
	{
	if (iQualifiers != NULL)
		{
		iQualifiers->ResetAndDestroy();
		delete iQualifiers;
		}
	delete iCertPolicyId;
	}

EXPORT_C const CArrayPtrFlat<CX509PolicyQualifierInfo>& CX509CertPolicyInfo::Qualifiers() const
	{
	return *iQualifiers;
	}

EXPORT_C TPtrC CX509CertPolicyInfo::Id() const
	{
	return iCertPolicyId->Des();
	}

CX509CertPolicyInfo::CX509CertPolicyInfo()
	{
	}

EXPORT_C void CX509CertPolicyInfo::ExternalizeL(RWriteStream& aStream) const
	{
	//iCertPolicyId
 	aStream << *iCertPolicyId;

 	// iQualifiers
	aStream.WriteInt32L(iQualifiers->Count());
	for (TInt32 i=0;i < iQualifiers->Count(); ++i)
		{
		(*iQualifiers)[i]->ExternalizeL(aStream);
		}
	}

EXPORT_C void CX509CertPolicyInfo::InternalizeL(RReadStream& aStream)
	{
	//iCertPolicyId
	delete iCertPolicyId;
	iCertPolicyId=0;
	iCertPolicyId=HBufC::NewL(aStream, KMaxTInt);

	// iQualifiers
	if (iQualifiers != NULL)
		{
		iQualifiers->ResetAndDestroy();
		}
	else
		{
		iQualifiers = new(ELeave) CArrayPtrFlat<CX509PolicyQualifierInfo> (1);
		}

	TInt32 count=aStream.ReadInt32L();
	for (TInt32 i=0;i < count; ++i)
		{
		CX509PolicyQualifierInfo* policyQualifierInfo=CX509PolicyQualifierInfo::NewLC(aStream);
		iQualifiers->AppendL(policyQualifierInfo);
		CleanupStack::Pop(policyQualifierInfo);
		}
	}

EXPORT_C CX509CertPoliciesExt* CX509CertPoliciesExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509CertPoliciesExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509CertPoliciesExt* CX509CertPoliciesExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509CertPoliciesExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509CertPoliciesExt* CX509CertPoliciesExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509CertPoliciesExt* self = CX509CertPoliciesExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509CertPoliciesExt* CX509CertPoliciesExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509CertPoliciesExt* self = new(ELeave) CX509CertPoliciesExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509CertPoliciesExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);
	TInt count = seq->Count();
	iPolicies = new(ELeave) CArrayPtrFlat<CX509CertPolicyInfo> (1);
	TASN1DecGeneric* gen;
	for (TInt i = 0; i < count; i++)
		{
		gen = seq->At(i);
		CX509CertPolicyInfo* policy = CX509CertPolicyInfo::NewLC(gen->Encoding());
		iPolicies->AppendL(policy);
		CleanupStack::Pop();//policy
		}
	CleanupStack::PopAndDestroy();
	}

CX509CertPoliciesExt::~CX509CertPoliciesExt()
	{
	if (iPolicies != NULL)
		{
		iPolicies->ResetAndDestroy();
		delete iPolicies;
		}
	}

EXPORT_C const CArrayPtrFlat<CX509CertPolicyInfo>& CX509CertPoliciesExt::Policies() const
	{
	return *iPolicies;
	}

CX509CertPoliciesExt::CX509CertPoliciesExt()
	{
	}

//7) policy mapping
CX509PolicyMapping* CX509PolicyMapping::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509PolicyMapping::NewL(aBinaryData, pos);
	}

CX509PolicyMapping* CX509PolicyMapping::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509PolicyMapping::NewLC(aBinaryData, pos);
	}

CX509PolicyMapping* CX509PolicyMapping::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509PolicyMapping* self = CX509PolicyMapping::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

CX509PolicyMapping* CX509PolicyMapping::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509PolicyMapping* self = new(ELeave) CX509PolicyMapping;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

EXPORT_C CX509PolicyMapping* CX509PolicyMapping::NewL(const CX509PolicyMapping& aMapping)
	{
	CX509PolicyMapping* self = CX509PolicyMapping::NewLC(aMapping);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509PolicyMapping* CX509PolicyMapping::NewLC(const CX509PolicyMapping& aMapping)
	{
	CX509PolicyMapping* self = new(ELeave) CX509PolicyMapping;
	CleanupStack::PushL(self);
	self->ConstructL(aMapping);
	return self;
	}

void CX509PolicyMapping::ConstructL(const CX509PolicyMapping& aMapping)
	{
	iIssuerPolicy = aMapping.iIssuerPolicy->AllocL();
	iSubjectPolicy = aMapping.iSubjectPolicy->AllocL();
	}

void CX509PolicyMapping::ConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos);
	if (seq->Count() < 2)
		{
		User::Leave(KErrArgument);
		}
	TASN1DecObjectIdentifier encOID;
	iIssuerPolicy = encOID.DecodeDERL(*(seq->At(0)));
	iSubjectPolicy = encOID.DecodeDERL(*(seq->At(1)));
	CleanupStack::PopAndDestroy();
	}

CX509PolicyMapping::~CX509PolicyMapping()
	{
	delete iIssuerPolicy;
	delete iSubjectPolicy;
	}

EXPORT_C TPtrC CX509PolicyMapping::IssuerPolicy() const
	{
	return iIssuerPolicy->Des();
	}

EXPORT_C TPtrC CX509PolicyMapping::SubjectPolicy() const
	{
	return iSubjectPolicy->Des();
	}

CX509PolicyMapping::CX509PolicyMapping()
	{
	}

EXPORT_C CX509PolicyMappingExt* CX509PolicyMappingExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509PolicyMappingExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509PolicyMappingExt* CX509PolicyMappingExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509PolicyMappingExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509PolicyMappingExt* CX509PolicyMappingExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509PolicyMappingExt* self = CX509PolicyMappingExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509PolicyMappingExt* CX509PolicyMappingExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509PolicyMappingExt* self = new(ELeave) CX509PolicyMappingExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509PolicyMappingExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);
	TInt count = seq->Count();

	iPolicies = new(ELeave) CArrayPtrFlat<CX509PolicyMapping> (1);
	TASN1DecGeneric* gen;
	for (TInt i = 0; i < count; i++)
		{
		gen = seq->At(i);
		CX509PolicyMapping* policy = CX509PolicyMapping::NewLC(gen->Encoding());
		iPolicies->AppendL(policy);
		CleanupStack::Pop();//policy
		}
	CleanupStack::PopAndDestroy();
	}

CX509PolicyMappingExt::~CX509PolicyMappingExt()
	{
	if (iPolicies != NULL)
		{
		iPolicies->ResetAndDestroy();
		delete iPolicies;
		}
	}

EXPORT_C const CArrayPtrFlat<CX509PolicyMapping>& CX509PolicyMappingExt::Mappings() const
	{
	return *iPolicies;
	}

CX509PolicyMappingExt::CX509PolicyMappingExt()
	{
	}

//8) authority key ID
EXPORT_C CX509AuthorityKeyIdExt* CX509AuthorityKeyIdExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509AuthorityKeyIdExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509AuthorityKeyIdExt* CX509AuthorityKeyIdExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509AuthorityKeyIdExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509AuthorityKeyIdExt* CX509AuthorityKeyIdExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509AuthorityKeyIdExt* self = CX509AuthorityKeyIdExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509AuthorityKeyIdExt* CX509AuthorityKeyIdExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509AuthorityKeyIdExt* self = new(ELeave) CX509AuthorityKeyIdExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509AuthorityKeyIdExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos);
	TInt count = seq->Count();
	TInt pos = 0;

	iAuthorityName = new(ELeave) CArrayPtrFlat<CX509GeneralName> (1);
	TASN1DecGeneric* curr;
	if (pos < count)
		{
		curr = seq->At(pos);
		pos++;
		if (curr->Class() != EContextSpecific)
			{
			User::Leave(KErrArgument);
			}
		switch(curr->Tag())
			{
			case 0:
				{
				DecodeKeyIdL(curr->Encoding());
				break;
				}
			case 1:
				{
				DecodeNameL(curr->Encoding());
				break;
				}
			case 2:
				{
				DecodeSerialNoL(curr->Encoding());
				break;
				}
			default:
				{
				User::Leave(KErrArgument);
				}
			}
		if (pos < count)
			{
			curr = seq->At(pos);
			pos++;
			if (curr->Class() != EContextSpecific)
				{
				User::Leave(KErrArgument);
				}
			switch(curr->Tag())
				{
				case 1:
					{
					DecodeNameL(curr->Encoding());
					break;
					}
				case 2:
					{
					DecodeSerialNoL(curr->Encoding());
					break;
					}
				default:
					{
					User::Leave(KErrArgument);
					}
				}
			if (pos < count)
				{
				curr = seq->At(pos);
				pos++;
				if ((curr->Class() != EContextSpecific) || (curr->Tag() != 2))
					{
					User::Leave(KErrArgument);
					}
				DecodeSerialNoL(curr->Encoding());
				}
			}
		}
	if (!iKeyIdentifier)
		{
		iKeyIdentifier = HBufC8::NewL(1);
		*iKeyIdentifier = KNullDesC8;
		}
	if (!iAuthorityCertSerialNumber)
		{
		iAuthorityCertSerialNumber = HBufC8::NewL(1);
		*iAuthorityCertSerialNumber = KNullDesC8;
		}
	CleanupStack::PopAndDestroy();
	}

void CX509AuthorityKeyIdExt::DecodeNameL(const TDesC8& aBinaryData)
	{
	TASN1DecSequence encSeq;
	TInt pos = 0;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, pos, 1, KMaxTInt);
	TInt count = seq->Count();
	TASN1DecGeneric* gen;
	for (TInt i = 0; i < count; i++)
		{
		gen = seq->At(i);
		CX509GeneralName* gn = CX509GeneralName::NewLC(gen->Encoding());
		iAuthorityName->AppendL(gn);
		CleanupStack::Pop();//gn
		}
	CleanupStack::PopAndDestroy();
	}

void CX509AuthorityKeyIdExt::DecodeKeyIdL(const TDesC8& aBinaryData)
	{
	TASN1DecGeneric gen(aBinaryData);
	gen.InitL();
	if (iKeyIdentifier != NULL)
		{
		User::Leave(KErrArgument);
		}
	iKeyIdentifier = gen.GetContentDER().AllocL();
	}

void CX509AuthorityKeyIdExt::DecodeSerialNoL(const TDesC8& aBinaryData)
	{
	TASN1DecGeneric gen(aBinaryData);
	gen.InitL();
	if (iAuthorityCertSerialNumber != NULL)
		{
		User::Leave(KErrArgument);
		}
	iAuthorityCertSerialNumber = gen.GetContentDER().AllocL();
	}

CX509AuthorityKeyIdExt::~CX509AuthorityKeyIdExt()
	{
	if (iAuthorityName != NULL)
		{
		iAuthorityName->ResetAndDestroy();
		}
	delete iAuthorityName;
	delete iAuthorityCertSerialNumber;
	delete iKeyIdentifier;
	}

EXPORT_C const CArrayPtrFlat<CX509GeneralName>& CX509AuthorityKeyIdExt::AuthorityName() const
	{
	return *iAuthorityName;
	}

EXPORT_C TPtrC8 CX509AuthorityKeyIdExt::AuthorityCertSerialNumber() const
	{
	return iAuthorityCertSerialNumber->Des();
	}

EXPORT_C TPtrC8 CX509AuthorityKeyIdExt::KeyId() const
	{
	return iKeyIdentifier->Des();
	}

CX509AuthorityKeyIdExt::CX509AuthorityKeyIdExt()
	{
	}

//9) subject key ID
EXPORT_C CX509SubjectKeyIdExt* CX509SubjectKeyIdExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509SubjectKeyIdExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509SubjectKeyIdExt* CX509SubjectKeyIdExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509SubjectKeyIdExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509SubjectKeyIdExt* CX509SubjectKeyIdExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509SubjectKeyIdExt* self = CX509SubjectKeyIdExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509SubjectKeyIdExt* CX509SubjectKeyIdExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509SubjectKeyIdExt* self = new(ELeave) CX509SubjectKeyIdExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509SubjectKeyIdExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecOctetString octetStr;
	iKeyIdentifier = octetStr.DecodeDERL(aBinaryData, aPos);
	}

EXPORT_C CX509SubjectKeyIdExt::~CX509SubjectKeyIdExt()
	{
	delete iKeyIdentifier;
	}

EXPORT_C TPtrC8 CX509SubjectKeyIdExt::KeyId() const
	{
	return iKeyIdentifier->Des();
	}

CX509SubjectKeyIdExt::CX509SubjectKeyIdExt()
	{
	}

//10) extended key usage
EXPORT_C CX509ExtendedKeyUsageExt* CX509ExtendedKeyUsageExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509ExtendedKeyUsageExt::NewL(aBinaryData, pos);
	}

EXPORT_C CX509ExtendedKeyUsageExt* CX509ExtendedKeyUsageExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return CX509ExtendedKeyUsageExt::NewLC(aBinaryData, pos);
	}

EXPORT_C CX509ExtendedKeyUsageExt* CX509ExtendedKeyUsageExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509ExtendedKeyUsageExt* self = CX509ExtendedKeyUsageExt::NewLC(aBinaryData, aPos);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CX509ExtendedKeyUsageExt* CX509ExtendedKeyUsageExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509ExtendedKeyUsageExt* self = new(ELeave) CX509ExtendedKeyUsageExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

void CX509ExtendedKeyUsageExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);
	TInt count = seq->Count();

	iKeyUsages = new(ELeave) CArrayPtrFlat<HBufC> (1);
	TASN1DecGeneric* gen;
	for (TInt i = 0; i < count; i++)
		{
		gen = seq->At(i);
		TASN1DecObjectIdentifier encOID;
		HBufC* usage = encOID.DecodeDERL(*gen);
		CleanupStack::PushL(usage);
		iKeyUsages->AppendL(usage);
		CleanupStack::Pop();
		}
	CleanupStack::PopAndDestroy();
	}

EXPORT_C CX509ExtendedKeyUsageExt::~CX509ExtendedKeyUsageExt()
	{
	if (iKeyUsages != NULL)
		{
		iKeyUsages->ResetAndDestroy();
		delete iKeyUsages;
		}
	}

EXPORT_C const CArrayPtrFlat<HBufC>& CX509ExtendedKeyUsageExt::KeyUsages() const
	{
	return *iKeyUsages;
	}

CX509ExtendedKeyUsageExt::CX509ExtendedKeyUsageExt()
	{
	}

//12) authority information access - CX509AccessDescription

CX509AccessDescription* CX509AccessDescription::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return NewL(aBinaryData, pos);
	}

CX509AccessDescription* CX509AccessDescription::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return NewLC(aBinaryData, pos);
	}

CX509AccessDescription* CX509AccessDescription::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509AccessDescription* self = NewLC(aBinaryData, aPos);
	CleanupStack::Pop(self);
	return self;
	}

CX509AccessDescription* CX509AccessDescription::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509AccessDescription* self = new (ELeave) CX509AccessDescription;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

CX509AccessDescription::CX509AccessDescription()
	{
	// empty
	}

void CX509AccessDescription::ConstructL(const TDesC8& aBinaryData, TInt& aPos)
	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 2, 2);

	TASN1DecGeneric* curr = seq->At(0);
	TASN1DecObjectIdentifier encOID;
	iMethodId = encOID.DecodeDERL(*curr);

	curr = seq->At(1);
	iLocation = CX509GeneralName::NewL(curr->Encoding());	

	CleanupStack::PopAndDestroy(seq);
	}

CX509AccessDescription::~CX509AccessDescription()
	{
	delete iMethodId;
	delete iLocation;
	}

EXPORT_C TPtrC CX509AccessDescription::Method() const
	{
	return *iMethodId;
	}

EXPORT_C const CX509GeneralName& CX509AccessDescription::Location() const
	{
	return *iLocation;
	}

//12) authority information access - CX509AuthInfoAccessExt

EXPORT_C CX509AuthInfoAccessExt* CX509AuthInfoAccessExt::NewL(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return NewL(aBinaryData, pos);
	}

EXPORT_C CX509AuthInfoAccessExt* CX509AuthInfoAccessExt::NewLC(const TDesC8& aBinaryData)
	{
	TInt pos = 0;
	return NewLC(aBinaryData, pos);
	}

EXPORT_C CX509AuthInfoAccessExt* CX509AuthInfoAccessExt::NewL(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509AuthInfoAccessExt* self = NewLC(aBinaryData, aPos);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CX509AuthInfoAccessExt* CX509AuthInfoAccessExt::NewLC(const TDesC8& aBinaryData, TInt& aPos)
	{
	CX509AuthInfoAccessExt* self = new (ELeave) CX509AuthInfoAccessExt;
	CleanupStack::PushL(self);
	self->ConstructL(aBinaryData, aPos);
	return self;
	}

CX509AuthInfoAccessExt::CX509AuthInfoAccessExt()
	{
	// empty
	}

void CX509AuthInfoAccessExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)
 	{
	TASN1DecSequence encSeq;
	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);
	TInt count = seq->Count();

	iAccessDescs = new (ELeave) CArrayPtrFlat<CX509AccessDescription>(1);

	for (TInt i = 0 ; i < count ; ++i)
		{
		TASN1DecGeneric* curr = seq->At(i);
		CX509AccessDescription* desc = CX509AccessDescription::NewLC(curr->Encoding());
		iAccessDescs->AppendL(desc);
		CleanupStack::Pop(desc);
		}

	CleanupStack::PopAndDestroy(seq);
	}

EXPORT_C CX509AuthInfoAccessExt::~CX509AuthInfoAccessExt()
	{
	if (iAccessDescs)
		{
		iAccessDescs->ResetAndDestroy();
		delete iAccessDescs;
		}
	}

EXPORT_C const CArrayPtrFlat<CX509AccessDescription>& CX509AuthInfoAccessExt::AccessDescriptions() const
	{
	return *iAccessDescs;
	}