diff -r 000000000000 -r bde4ae8d615e os/security/cryptoservices/certificateandkeymgmt/tcertstore/t_certstoreout.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/security/cryptoservices/certificateandkeymgmt/tcertstore/t_certstoreout.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,668 @@
+/*
+* 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();
+	//TX509PolicyConstraint mapping = ext->InhibitPolicyMapping();
+	//CleanupStack::PopAndDestroy();
+	}
+
+void X509CertWriter::ShowCP(const CX509CertExtension& aExt)
+	{
+	iOut.writeString(_L("Cert Policies = "));
+	iOut.writeNewLine();
+
+	CX509CertPoliciesExt* ext = CX509CertPoliciesExt::NewLC(aExt.Data());
+	const CArrayPtrFlat<CX509CertPolicyInfo>& policies = ext->Policies();
+	TInt count = policies.Count();
+	for (TInt i = 0; i < count; i++)
+		{
+		const CX509CertPolicyInfo* policy = policies.At(i);
+		
+		iOut.writeSpaces(4);
+		iOut.writeString(_L("Policy ID = "));
+		iOut.writeString(policy->Id());
+		iOut.writeNewLine();
+		const CArrayPtrFlat<CX509PolicyQualifierInfo>& qualifiers = policy->Qualifiers();
+		TInt qCount = qualifiers.Count();
+
+		if (qCount > 0)
+			{
+
+			iOut.writeSpaces(4);
+			iOut.writeString(_L("Qualified by: "));
+			iOut.writeNewLine();
+			}
+
+		for (TInt i = 0; i < qCount; i++)
+			{
+			CX509PolicyQualifierInfo* qualifier = qualifiers.At(i);
+
+			iOut.writeSpaces(8);
+			iOut.writeString(_L("Qualifier ID = "));
+			iOut.writeString(qualifier->Id());
+			iOut.writeNewLine();
+			}
+		}
+	CleanupStack::PopAndDestroy();//ext
+	}
+
+void X509CertWriter::ShowPM(const CX509CertExtension& aExt)
+	{//!!!!we don't write this one outFile either 
+	CX509PolicyMappingExt* ext = CX509PolicyMappingExt::NewLC(aExt.Data());
+	const CArrayPtrFlat<CX509PolicyMapping>& mappings = ext->Mappings();
+	TInt count = mappings.Count();
+	for (TInt i = 0; i < count; i++)
+		{
+		//const CX509PolicyMapping* mapping = mappings.At(i);
+		}
+	CleanupStack::PopAndDestroy();
+	}
+
+
+void X509CertWriter::ShowEKU(const CX509CertExtension& aExt)
+	{
+	iOut.writeString(_L("Extended Key Usage = "));
+	iOut.writeNewLine();
+
+	CX509ExtendedKeyUsageExt* ext = CX509ExtendedKeyUsageExt::NewLC(aExt.Data());
+	const CArrayPtrFlat<HBufC>& usages = ext->KeyUsages();
+	TInt count = usages.Count();
+	for (TInt i = 0; i < count; i++)
+		{
+		iOut.writeSpaces(4);
+		iOut.writeString(usages.At(i)->Des());
+		iOut.writeNewLine();
+		}
+	CleanupStack::PopAndDestroy();
+	}
+
+void X509CertWriter::ShowSignature(const CX509Certificate& /*aCert*/)
+	{
+/*	HBufC8* sig = aCert.SignatureL();
+	CleanupStack::PushL(sig);
+	User::LeaveIfError(outFile.Write(sig->Des()));
+	User::LeaveIfError(outFile.Flush()); // Commit data
+	CleanupStack::PopAndDestroy();*/
+	}
+
+void X509CertWriter::WriteEncodings(const CX509Certificate& aCertificate)
+	{
+	iOut.writeString(_L("Version:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::EVersionNumber);
+	iOut.writeNewLine();
+
+	iOut.writeString(_L("Serial Number:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::ESerialNumber);
+	iOut.writeNewLine();
+
+	iOut.writeString(_L("Algorithm:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::EAlgorithmId);
+	iOut.writeNewLine();
+
+	iOut.writeString(_L("Issuer:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::EIssuerName);
+	iOut.writeNewLine();
+
+	iOut.writeString(_L("Validity:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::EValidityPeriod);
+	iOut.writeNewLine();
+
+	iOut.writeString(_L("Subject:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::ESubjectName);
+	iOut.writeNewLine();
+
+	iOut.writeString(_L("Public Key:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::ESubjectPublicKeyInfo);
+	iOut.writeNewLine();
+
+	iOut.writeString(_L("Issuer ID:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::EIssuerUID);
+	iOut.writeNewLine();
+	
+	iOut.writeString(_L("Subject ID:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::ESubjectUID);
+	iOut.writeNewLine();
+
+	iOut.writeString(_L("Extensions:"));
+	iOut.writeNewLine();
+	WriteEncoding(aCertificate, CX509Certificate::EExtensionList);
+	iOut.writeNewLine();
+	}
+
+void X509CertWriter::WriteEncoding(const CX509Certificate& aCertificate, const TUint aIndex)
+	{
+	if (aCertificate.DataElementEncoding(aIndex))
+		{
+		iOut.writeOctetString(*(aCertificate.DataElementEncoding(aIndex)));
+		}
+	}
+
+#endif // SHOW_EXTENDED
+
+/**********************************************************/
+
+WTLSCertWriter::WTLSCertWriter(Output& aOut)
+	:iOut(aOut)
+	{
+	}
+
+void WTLSCertWriter::WriteCert(const CWTLSCertificate& aCertificate)
+	{
+	iOut.writeString(_L("\t\tIssuer Name = "));
+	HBufC* issuer = aCertificate.IssuerL();
+	iOut.writeString(*issuer);
+	delete issuer;
+	iOut.writeNewLine();
+	iOut.writeString(_L("\t\tSubject Name = "));
+	HBufC* subject = aCertificate.SubjectL();
+	iOut.writeString(*subject);
+	delete subject;
+	iOut.writeNewLine();
+	}
+
+void WTLSCertWriter::ShowName(const CWTLSName& /*aName*/)
+	{
+//	iOut.writeString(aName.Name());
+	}
+
+