/*

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

* TCERTSTOREOUT.CPP

*

*/

#include "t_certstoreout.h"

X509CertWriter::X509CertWriter(Output& aOut)

	:iOut(aOut)

	{

	}

void X509CertWriter::WriteCert(const CX509Certificate& aCertificate)

	{

#ifdef SHOW_EXTENDED

	ShowSerialNumber(aCertificate.SerialNumber());

	ShowValidityPeriod(aCertificate);

	iOut.writeString(_L("Issuer Name = "));

	iOut.writeNewLine();	

	ShowDN(aCertificate.IssuerName());	

	iOut.writeString(_L("Subject Name = "));

	iOut.writeNewLine();	

	ShowDN(aCertificate.SubjectName());

	ShowSigningAlgorithm(aCertificate.SigningAlgorithm());

	ShowExtensions(aCertificate);

	WriteEncodings(aCertificate);

#endif // SHOW_EXTENDED

	iOut.writeString(_L("\t\tShort Issuer Name = "));

	HBufC* issuer = aCertificate.IssuerL();

	iOut.writeString(*issuer);

	iOut.writeNewLine();

	delete issuer;

	iOut.writeString(_L("\t\tShort Subject Name = "));

	HBufC* subject = aCertificate.SubjectL();

	iOut.writeString(*subject);

	iOut.writeNewLine();

	delete subject;

	}

// The rest of these are only compiled of SHOW_EXTENDED defined - this 

// eliminates warnings from WINS/UREL build

#ifdef SHOW_EXTENDED

void X509CertWriter::ShowSigningAlgorithm(const CSigningAlgorithmIdentifier& aSigningAlgorithm)

	{

	iOut.writeString(_L("Signed using: "));

	iOut.writeNewLine();

	iOut.writeSpaces(4);

	iOut.writeString(_L("Asymmetric algorithm = "));

	const CAlgorithmIdentifier& algId = aSigningAlgorithm.AsymmetricAlgorithm();

	switch(algId.Algorithm())

	{

	case ERSA:

		{

		iOut.writeString(_L("RSA"));

		break;

		}

	case EDSA:

		{

		iOut.writeString(_L("DSA"));

		break;

		}

	case EDH:

		{

		iOut.writeString(_L("DH"));

		break;

		}

	default:

		iOut.writeString(_L("Unknown"));

		break;

	}

	iOut.writeNewLine();

	iOut.writeSpaces(4);

	iOut.writeString(_L("Digest algorithm = "));

	const CAlgorithmIdentifier& digestId = aSigningAlgorithm.DigestAlgorithm();

	switch(digestId.Algorithm())

	{

	case EMD2:

		{

		iOut.writeString(_L("MD2"));

		break;

		}

	case EMD5:

		{

		iOut.writeString(_L("MD5"));

		break;

		}

	case ESHA1:

		{

		iOut.writeString(_L("SHA1"));

		break;

		}

	default:

		iOut.writeString(_L("Unknown"));

	}

	iOut.writeNewLine();

	}

void X509CertWriter::ShowSerialNumber(const TPtrC8& aSerialNumber)

	{

	iOut.writeString(_L("Serial Number = "));

	iOut.writeOctetString(aSerialNumber);

	iOut.writeNewLine();

	}

//dn display code

void X509CertWriter::ShowAVA(const CX520AttributeTypeAndValue& aAva)

	{

	iOut.writeString(aAva.Type());

	HBufC* val = aAva.ValueL();

	CleanupStack::PushL(val);

	iOut.writeString(_L(" = "));

	iOut.writeString(val->Des());

	CleanupStack::PopAndDestroy();

	}

void X509CertWriter::ShowDN(const CX500DistinguishedName& aName)

	{

	TInt count = aName.Count();

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

		{

  		const CX520AttributeTypeAndValue& ava = aName.Element(i);

		iOut.writeSpaces(4);

		ShowAVA(ava);

		iOut.writeNewLine();

		}

	}

void X509CertWriter::ShowAKI(const CX509Certificate& aCert)

	{

	const CX509CertExtension* akiExt = aCert.Extension(KAuthorityKeyId);

	if (akiExt)

		{

		iOut.writeString(_L("Authority Key ID = "));

		iOut.writeNewLine();

		const CX509AuthorityKeyIdExt* ext = CX509AuthorityKeyIdExt::NewLC(akiExt->Data());

		const CArrayPtrFlat<CX509GeneralName>& authorityName = ext->AuthorityName();

		TInt count = authorityName.Count();

		if (count > 0)

			{

			iOut.writeSpaces(4);

			iOut.writeString(_L("Authority name = "));

			iOut.writeNewLine();

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

				{

				ShowGN(*(authorityName.At(i)));

				}

			}

		if (ext->AuthorityCertSerialNumber().Length() > 0)

			{

			iOut.writeSpaces(4);

			iOut.writeString(_L("Authority cert serial no = "));

			iOut.writeOctetString(ext->AuthorityCertSerialNumber());

			iOut.writeNewLine();

			}

		iOut.writeSpaces(4);

		iOut.writeString(_L("Key Id = "));

		iOut.writeOctetString(ext->KeyId());

		iOut.writeNewLine();

		CleanupStack::PopAndDestroy();

		}

	}

void X509CertWriter::ShowSKI(const CX509Certificate& aCert)

	{

	const CX509CertExtension* skiExt = aCert.Extension(KSubjectKeyId);

	if (skiExt)

		{

		iOut.writeString(_L("Subject Key ID = "));

		iOut.writeNewLine();

		const CX509SubjectKeyIdExt* ext = CX509SubjectKeyIdExt::NewLC(skiExt->Data());

		iOut.writeSpaces(4);

		iOut.writeString(_L("Key Id = "));

		iOut.writeOctetString(ext->KeyId());

		iOut.writeNewLine();

		CleanupStack::PopAndDestroy();

		}

	}

void X509CertWriter::ShowGN(const CX509GeneralName& aName)

	{

	iOut.writeSpaces(4);

	switch(aName.Tag())

		{

		case 1:

			{

			//rfc822

			CX509RFC822NameSubtree* email = CX509RFC822NameSubtree::NewLC(aName.Data());

			const RArray<TPtrC>& rep = email->Rep();

			TInt count = rep.Count();

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

				{

				iOut.writeString(rep[i]);

				iOut.writeSpaces(1);

				}

			iOut.writeNewLine();

			CleanupStack::PopAndDestroy();//email

			break;

			}

		case 2:

			{

			//dns name

			CX509DNSNameSubtree* dns = CX509DNSNameSubtree::NewLC(aName.Data());

			const RArray<TPtrC>& rep = dns->Rep();

			TInt count = rep.Count();

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

				{

				iOut.writeString(rep[i]);

				iOut.writeSpaces(1);

				}

			CleanupStack::PopAndDestroy();//dns

			break;

			}

		case 4:

			{

			//DN

			CX500DistinguishedName* dN = CX500DistinguishedName::NewLC(aName.Data());

			ShowDN(*dN);

			CleanupStack::PopAndDestroy();

			break;

			}

		case 6:

			{

			//uri

			CX509IPBasedURI* uri = CX509IPBasedURI::NewLC(aName.Data());

			iOut.writeString(uri->Name());

			iOut.writeNewLine();

			CleanupStack::PopAndDestroy();//uri

			break;

			}

		case 7:

			{

			//ip address//!!!!not done for writing to file yet!!!

			CX509IPSubnetMask* ip = CX509IPSubnetMask::NewLC(aName.Data());

			TPtrC8 pBA(ip->BaseAddress());

			TInt counter;

			counter = pBA.Length();

			TPtrC8 pM(ip->Mask());

			counter = pM.Length();

			CleanupStack::PopAndDestroy();

			break;

			}

		}

	}

void X509CertWriter::ShowFingerprint(const CX509Certificate& aCertificate)

	{

	iOut.writeOctetString(aCertificate.Fingerprint());

	iOut.writeNewLine();

	}

void X509CertWriter::ShowValidityPeriod(const CX509Certificate& aCertificate)

	{

	const CValidityPeriod& vp = aCertificate.ValidityPeriod();

	iOut.writeString(_L("Validity Period = "));

	iOut.writeNewLine();

	const TTime& start = vp.Start();

	const TTime& finish = vp.Finish();

	TBuf<30> dateString1;

	start.FormatL(dateString1,(_L("%H%:1%T:%S %*E%*D %X%*N%Y %1 %2 %3")));

	iOut.writeSpaces(4);

	iOut.writeString(_L("Valid From = "));

	iOut.writeString(dateString1);

	iOut.writeNewLine();

	TBuf<30> dateString2;

	finish.FormatL(dateString2,(_L("%H%:1%T:%S %*E%*D %X%*N%Y %1 %2 %3")));

	iOut.writeSpaces(4);

	iOut.writeString(_L("Valid Until = "));

	iOut.writeString(dateString2);

	iOut.writeNewLine();

	}

//extensions

void X509CertWriter::ShowExtensions(const CX509Certificate& aCertificate)

	{

	const CArrayPtrFlat<CX509CertExtension>& exts = aCertificate.Extensions();

	TInt count = exts.Count();

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

		{

		const CX509CertExtension* ext = exts.At(i);

		iOut.writeString(_L("extension"));

		iOut.writeNum(i);

		if (!(ext->Critical()))

			{

			iOut.writeString(_L(" not"));

			}

		iOut.writeString(_L(" critical"));

		iOut.writeString(_L(" ID = "));

		TPtrC id(ext->Id());

		iOut.writeString(id);

		iOut.writeNewLine();

		if (id == KBasicConstraints)

			{

			ShowBC(*ext);

			}

		if (id == KSubjectAltName)

			{

			iOut.writeString(_L("SubjectAltName: \n"));

			ShowAltName(*ext);

			}

		if (id == KIssuerAltName)

			{

			iOut.writeString(_L("IssuerAltName: \n"));

			ShowAltName(*ext);

			}

		if (id == KKeyUsage)

			{

			ShowKU(*ext);

			}

		if (id == KNameConstraints)

			{

			ShowNC(*ext);

			}

		if (id == KPolicyConstraints)

			{

			ShowPC(*ext);

			}

		if (id == KCertPolicies)

			{

			ShowCP(*ext);

			}

		if (id == KPolicyMapping)

			{

			ShowPM(*ext);

			}

		if (id == KAuthorityKeyId)

			{

			ShowAKI(aCertificate);

			}

		if (id == KSubjectKeyId)

			{

			ShowSKI(aCertificate);

			}

		if (id == KExtendedKeyUsage)

			{

			ShowEKU(*ext);

			}

		}

	}

void X509CertWriter::ShowBC(const CX509CertExtension& aExt)

	{

	iOut.writeString(_L("Basic Constraints:"));

	iOut.writeNewLine();

	CX509BasicConstraintsExt* ext = CX509BasicConstraintsExt::NewLC(aExt.Data());

	if (ext->IsCA())

		{

		iOut.writeSpaces(4);

		iOut.writeString(_L("CA cert"));

		iOut.writeNewLine();

		if (ext->MaxChainLength() < KMaxTInt)

			{

			iOut.writeSpaces(4);

			iOut.writeString(_L("Max Chain Length = "));

			iOut.writeNum(ext->MaxChainLength());

			iOut.writeNewLine();

			}

		}

	else

		{

		iOut.writeSpaces(4);

		iOut.writeString(_L("EE cert"));

		iOut.writeNewLine();

		}

	CleanupStack::PopAndDestroy();

	}

void X509CertWriter::ShowAltName(const CX509CertExtension& aExt)

	{

	CX509AltNameExt* ext = CX509AltNameExt::NewLC(aExt.Data());

	const CArrayPtrFlat<CX509GeneralName>& names = ext->AltName();

	TInt count = names.Count();

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

		{

		ShowGN(*(names.At(i)));

		}

	CleanupStack::PopAndDestroy();

	}

_LIT(KDigSig, "digital signature");

_LIT(KNonRep, "non-repudiation");

_LIT(KKeyEnc, "key encipherment");

_LIT(KDataEnc, "data encipherment");

_LIT(KKeyAgree, "key agreement");

_LIT(KCertSign, "key cert sign");

_LIT(KCRLSign, "crl sign");

_LIT(KEnciph, "encipher only");

_LIT(KDeciph, "decipher only");

void X509CertWriter::ShowKU(const CX509CertExtension& aExt)

	{

	iOut.writeString(_L("Key Usage:"));

	iOut.writeNewLine();

	CX509KeyUsageExt* ext = CX509KeyUsageExt::NewLC(aExt.Data());

		if (ext->IsSet(EX509DigitalSignature))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KDigSig);

			iOut.writeNewLine();

			}

		if (ext->IsSet(EX509NonRepudiation))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KNonRep);

			iOut.writeNewLine();

			}

		if (ext->IsSet(EX509KeyEncipherment))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KKeyEnc);

			iOut.writeNewLine();

			}

		if (ext->IsSet(EX509DataEncipherment))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KDataEnc);

			iOut.writeNewLine();

			}

		if (ext->IsSet(EX509KeyAgreement))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KKeyAgree);

			iOut.writeNewLine();

			}

		if (ext->IsSet(EX509KeyCertSign))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KCertSign);

			iOut.writeNewLine();

			}

		if (ext->IsSet(EX509CRLSign))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KCRLSign);

			iOut.writeNewLine();

			}

		if (ext->IsSet(EX509EncipherOnly))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KEnciph);

			iOut.writeNewLine();

			}

		if (ext->IsSet(EX509DecipherOnly))

			{

			iOut.writeSpaces(4);

			iOut.writeString(KDeciph);

			iOut.writeNewLine();

			}		

	CleanupStack::PopAndDestroy();//ext

	}

void X509CertWriter::ShowSubtrees(const CArrayPtrFlat<CX509GeneralSubtree>& aSubtrees)

	{

	TInt count = aSubtrees.Count();

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

		{

		const CX509GeneralSubtree* subtree = aSubtrees.At(i);

		ShowGN(subtree->Name());

		///!!!!!don't write these outFile either!!

		}

	}

void X509CertWriter::ShowNC(const CX509CertExtension& aExt)

	{//!!!!don't write these outFile

	CX509NameConstraintsExt* ext = CX509NameConstraintsExt::NewLC(aExt.Data());

	ShowSubtrees(ext->ExcludedSubtrees());

	ShowSubtrees(ext->PermittedSubtrees());

	CleanupStack::PopAndDestroy();

	}

void X509CertWriter::ShowPC(const CX509CertExtension& /*aExt*/)

	{//!!!!don't write these outFile

	//CX509PolicyConstraintsExt* ext = CX509PolicyConstraintsExt::NewLC(aExt.Data());

	//TX509PolicyConstraint required = ext->ExplicitPolicyRequired();