diff -r 000000000000 -r 2c201484c85f cryptoservices/certificateandkeymgmt/twtlscert/CertWriter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/certificateandkeymgmt/twtlscert/CertWriter.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,406 @@
+/*
+* 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: 
+* TWTLSOUT.CPP
+*
+*/
+
+
+#include "CertWriter.h"
+
+WTLSCertWriter::WTLSCertWriter(Output* aOut)
+	:iOut(aOut)
+	{
+	}
+
+void WTLSCertWriter::SetOut(Output* aOut)
+	{
+	iOut = aOut;
+	}
+
+void WTLSCertWriter::WriteCert(const CWTLSCertificate& aCertificate)
+	{
+	CWTLSCertificate* cert = CWTLSCertificate::NewL(aCertificate);
+	CleanupStack::PushL(cert);
+	WriteEncodings(*cert);
+	iOut->writeNewLine();
+	iOut->writeString(_L("Version = "));
+	iOut->writeNum(cert->Version());	
+	iOut->writeNewLine();	
+	ShowValidityPeriod(*cert);
+	iOut->writeString(_L("Issuer Name = "));
+	iOut->writeNewLine();	
+	ShowName(cert->IssuerName());	
+	iOut->writeNewLine();	
+	iOut->writeString(_L("Subject Name = "));
+	iOut->writeNewLine();	
+	ShowName(cert->SubjectName());
+	iOut->writeNewLine();	
+	ShowSigningAlgorithm(cert->SigningAlgorithm());
+	ShowPublicKey(aCertificate);
+
+	iOut->writeString(_L("Short Issuer Name = "));
+	HBufC* issuer = cert->IssuerL();
+	iOut->writeString(*issuer);
+	iOut->writeNewLine();
+	delete issuer;
+
+	iOut->writeString(_L("Short Subject Name = "));
+	HBufC* subject = cert->SubjectL();
+	iOut->writeString(*subject);
+	iOut->writeNewLine();
+	delete subject;
+
+	iOut->writeString(_L("Full structured issuer & subject names"));
+	iOut->writeNewLine();
+	CWTLSStructuredText* sIssuer = NULL;
+	TRAPD(err, sIssuer = CWTLSStructuredText::NewL(cert->IssuerName().NameData()));
+	if (err != KErrNone)
+		{
+		if (err == KErrNoMemory)
+			{
+			User::Leave(err);
+			}
+		}
+	else
+		{
+		const TWTLSStructuredTextField* field = sIssuer->FieldByName(KWTLSCountryName);
+		if (field)
+			{
+			iOut->writeString(field->Type());
+			iOut->writeString(_L(" = "));
+			iOut->writeString(field->Value());
+			iOut->writeNewLine();
+			__ASSERT_ALWAYS((field->Value() == sIssuer->Country()),User::Panic(_L("CERT"),0));
+			}
+
+		field = sIssuer->FieldByName(KWTLSOrganizationName);
+		if (field)
+			{
+			iOut->writeString(field->Type());
+			iOut->writeString(_L(" = "));
+			iOut->writeString(field->Value());
+			iOut->writeNewLine();
+			__ASSERT_ALWAYS((field->Value() == sIssuer->Organization()),User::Panic(_L("CERT"),0));
+			}
+		field = sIssuer->FieldByName(KWTLSServiceName);
+		if (field)
+			{
+			iOut->writeString(field->Type());
+			iOut->writeString(_L(" = "));
+			iOut->writeString(field->Value());
+			iOut->writeNewLine();
+			__ASSERT_ALWAYS((field->Value() == sIssuer->ServiceName()),User::Panic(_L("CERT"),0));
+			}
+		field = sIssuer->FieldByName(KWTLSTitle);
+		if (field)
+			{
+			iOut->writeString(field->Type());
+			iOut->writeString(_L(" = "));
+			iOut->writeString(field->Value());
+			iOut->writeNewLine();
+			}
+		field = sIssuer->FieldByName(KWTLSCommonName);
+		if (field)
+			{
+			iOut->writeString(field->Type());
+			iOut->writeString(_L(" = "));
+			iOut->writeString(field->Value());
+			iOut->writeNewLine();
+			}
+		delete sIssuer;
+		}
+
+	CWTLSStructuredText* sSubject = NULL;
+	TRAP(err, sSubject = CWTLSStructuredText::NewL(cert->SubjectName().NameData()));
+	if (err != KErrNone)
+		{
+		if (err == KErrNoMemory)
+			{
+			User::Leave(err);
+			}
+		}
+	else
+		{
+		TInt count = sSubject->Count();
+		for (TInt i = 0; i < count; i++)
+			{
+			const TWTLSStructuredTextField& field = sSubject->FieldByIndex(i);
+			iOut->writeString(field.Type());
+			iOut->writeString(_L(" = "));
+			iOut->writeString(field.Value());
+			iOut->writeNewLine();
+			}
+		delete sSubject;
+		}
+
+	if (cert->IsSelfSignedL())
+		{
+		const CWTLSName& subject = cert->SubjectName();
+		const CWTLSName& issuer = cert->IssuerName();
+		if ((subject.NameType() == EWTLSText) && (issuer.NameType() == EWTLSText))
+			{
+			CWTLSText* sText = CWTLSText::NewLC(subject.NameData());
+			CWTLSText* iText = CWTLSText::NewLC(issuer.NameData());
+			__ASSERT_ALWAYS((sText->ExactMatchL(*iText)),User::Panic(_L("CERT"),0));
+			CleanupStack::PopAndDestroy(2);
+			}
+
+		}
+
+
+	CleanupStack::PopAndDestroy();
+	}
+
+void WTLSCertWriter::ShowName(const CWTLSName& aName)
+	{
+	if (aName.NameType() == EWTLSText)
+		{
+		CWTLSText* text = CWTLSText::NewL(aName.NameData());
+		CleanupStack::PushL(text);
+		iOut->writeString(_L("Char set = "));
+		iOut->writeNum(text->CharacterSet());
+		iOut->writeNewLine();
+		iOut->writeString(_L("Text = "));
+		iOut->writeString(text->Name());
+		iOut->writeNewLine();	
+		CleanupStack::PopAndDestroy();
+		}
+//	iOut->writeString(aName.Name());
+//	iOut->writeNewLine();
+	iOut->writeOctetStringL(aName.NameData());
+	}
+
+void WTLSCertWriter::ShowPublicKey(const CWTLSCertificate& aCertificate)
+	{
+	const CSubjectPublicKeyInfo& spki = aCertificate.PublicKey();
+	switch(spki.AlgorithmId())
+		{
+		case ERSA:
+			{
+			ShowRSAKey(spki);
+			break;
+			}
+		default:
+			//ignore any other algorithm
+			break;
+		}
+	}
+
+void WTLSCertWriter::ShowRSAKey(const CSubjectPublicKeyInfo& aSpki)
+	{
+	CRSAPublicKey* key = CWTLSRSAPublicKey::NewLC(aSpki.KeyData());
+	iOut->writeString(_L("RSA Key:"));
+	iOut->writeNewLine();
+	iOut->writeSpaces(4);
+	iOut->writeString(_L("Modulus = "));
+	iOut->writeNewLine();
+	const TInteger& mod = key->N();
+	HBufC8* mBuf = mod.BufferLC();
+	iOut->writeOctetStringL(mBuf->Des());
+	iOut->writeNewLine();	
+
+	iOut->writeSpaces(4);
+	iOut->writeString(_L("Exponent = "));
+	iOut->writeNewLine();
+	const TInteger& exp = key->E();
+	HBufC8* eBuf = exp.BufferLC();
+	iOut->writeOctetString(eBuf->Des());
+	iOut->writeNewLine();	
+	CleanupStack::PopAndDestroy(3);
+	}
+
+void WTLSCertWriter::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"));
+		break;
+		}
+	}
+	iOut->writeNewLine();
+	}
+
+void WTLSCertWriter::ShowSerialNumber(const TPtrC8& aSerialNumber)
+	{
+	iOut->writeString(_L("Serial Number = "));
+	iOut->writeOctetString(aSerialNumber);
+	iOut->writeNewLine();
+	}
+
+void WTLSCertWriter::ShowFingerprint(const CWTLSCertificate& aCertificate)
+	{
+	iOut->writeOctetString(aCertificate.Fingerprint());
+	iOut->writeNewLine();
+	}
+
+void WTLSCertWriter::ShowValidityPeriod(const CWTLSCertificate& 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();
+	}
+
+void WTLSCertWriter::WriteEncodings(const CWTLSCertificate& aCertificate)
+	{
+	iOut->writeString(_L("Version:"));
+	iOut->writeNewLine();
+	const TPtrC8* encoding = Encoding(aCertificate, CWTLSCertificate::EVersionNumber);
+	if (encoding)
+		{
+		iOut->writeOctetString(*encoding);
+		}
+	iOut->writeNewLine();
+
+	iOut->writeString(_L("Algorithm:"));
+	iOut->writeNewLine();
+	encoding = Encoding(aCertificate, CWTLSCertificate::EAlgorithmId);
+	if (encoding)
+		{
+		CWTLSSigningAlgorithmIdentifier* algId = CWTLSSigningAlgorithmIdentifier::NewL(*encoding);
+		CleanupStack::PushL(algId);
+		__ASSERT_ALWAYS((*algId==aCertificate.SigningAlgorithm()),User::Panic(_L("CERT"),0));
+		iOut->writeOctetString(*encoding);
+		CleanupStack::PopAndDestroy();
+		}
+	iOut->writeNewLine();
+
+	iOut->writeString(_L("Issuer:"));
+	iOut->writeNewLine();
+	encoding = Encoding(aCertificate, CWTLSCertificate::EIssuerName);
+	if (encoding)
+		{
+		CWTLSName* name = CWTLSName::NewL(*encoding);
+		CleanupStack::PushL(name);
+		__ASSERT_ALWAYS(	(name->ExactMatchL(aCertificate.IssuerName())	),User::Panic(_L("CERT"),0));
+		iOut->writeOctetStringL(*encoding);
+		CleanupStack::PopAndDestroy();
+		}
+	iOut->writeNewLine();
+
+	iOut->writeString(_L("Validity:"));
+	iOut->writeNewLine();
+	encoding = Encoding(aCertificate, CWTLSCertificate::EValidityPeriod);
+	if (encoding)
+		{
+		CValidityPeriod* val  = CWTLSValidityPeriod::NewL(*encoding);
+		CleanupStack::PushL(val);
+		__ASSERT_ALWAYS(((val->Start() == aCertificate.ValidityPeriod().Start()) && (val->Finish() == aCertificate.ValidityPeriod().Finish())),User::Panic(_L("CERT"),0));
+		iOut->writeOctetString(*encoding);
+		CleanupStack::PopAndDestroy();
+		}
+	iOut->writeNewLine();
+
+	iOut->writeString(_L("Subject:"));
+	iOut->writeNewLine();
+	encoding = Encoding(aCertificate, CWTLSCertificate::ESubjectName);
+	if (encoding)
+		{
+		CWTLSName* name = CWTLSName::NewL(*encoding);
+		CleanupStack::PushL(name);
+		__ASSERT_ALWAYS(	(name->ExactMatchL(aCertificate.SubjectName())	),User::Panic(_L("CERT"),0));
+		iOut->writeOctetStringL(*encoding);
+		CleanupStack::PopAndDestroy();
+		}
+	iOut->writeNewLine();
+
+	iOut->writeString(_L("Public Key:"));
+	iOut->writeNewLine();
+	encoding = Encoding(aCertificate, CWTLSCertificate::ESubjectPublicKeyInfo);
+	if (encoding)
+		{
+		CSubjectPublicKeyInfo* info  = CWTLSSubjectPublicKeyInfo::NewL(*encoding);
+		CleanupStack::PushL(info);
+		__ASSERT_ALWAYS((info->KeyData() == aCertificate.PublicKey().KeyData()),User::Panic(_L("CERT"),0));
+		iOut->writeOctetStringL(*encoding);
+		CleanupStack::PopAndDestroy();
+		}
+	iOut->writeNewLine();
+	}
+
+const TPtrC8* WTLSCertWriter::Encoding(const CWTLSCertificate& aCertificate, const TUint aIndex)
+	{
+	if (aCertificate.DataElementEncoding(aIndex))
+		{
+		return aCertificate.DataElementEncoding(aIndex);
+		}
+	return NULL;
+	}