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