/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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: Certificate info class for TLS untrusted certificate dialog.
*
*/

#include "untrustedcertificateinfo_symbian.h"
#include <signed.h>                             // TAlgorithmId
#include <x509cert.h>                           // CX509Certificate
#include <QTextStream>


// ======== LOCAL FUNCTIONS ========

// ----------------------------------------------------------------------------
// mapAlgorithm()
// ----------------------------------------------------------------------------
//
UntrustedCertificateInfoBase::Algorithm mapAlgorithm(TAlgorithmId aAlgId)
{
    UntrustedCertificateInfoBase::Algorithm algorithm =
        UntrustedCertificateInfoBase::Unknown;
    switch(aAlgId) {
        case ERSA:
            algorithm = UntrustedCertificateInfoBase::RSA;
            break;
        case EDSA:
            algorithm = UntrustedCertificateInfoBase::DSA;
            break;
        case EDH:
            algorithm = UntrustedCertificateInfoBase::DH;
            break;
        case EMD2:
            algorithm = UntrustedCertificateInfoBase::MD2;
            break;
        case EMD5:
            algorithm = UntrustedCertificateInfoBase::MD5;
            break;
        case ESHA1:
            algorithm = UntrustedCertificateInfoBase::SHA1;
            break;
        case ESHA224:
            algorithm = UntrustedCertificateInfoBase::SHA224;
            break;
        case ESHA256:
            algorithm = UntrustedCertificateInfoBase::SHA256;
            break;
        case ESHA384:
            algorithm = UntrustedCertificateInfoBase::SHA384;
            break;
        case ESHA512:
            algorithm = UntrustedCertificateInfoBase::SHA512;
            break;
        default:
            break;
    }
    return algorithm;
}

// ----------------------------------------------------------------------------
// convertDateTime()
// ----------------------------------------------------------------------------
//
QDateTime convertDateTime(const TTime& aTime)
{
    const TDateTime &symbianDateTime = aTime.DateTime();

    QDateTime dateTime;
    QDate date(symbianDateTime.Year(), symbianDateTime.Month()+1, symbianDateTime.Day()+1);
    QTime time(symbianDateTime.Hour(), symbianDateTime.Minute(), symbianDateTime.Second());
    dateTime.setDate(date);
    dateTime.setTime(time);

    return dateTime;
}


// ======== MEMBER FUNCTIONS ========

// ----------------------------------------------------------------------------
// UntrustedCertificateInfoSymbian::UntrustedCertificateInfoSymbian()
// ----------------------------------------------------------------------------
//
UntrustedCertificateInfoSymbian::UntrustedCertificateInfoSymbian(
    const CX509Certificate& aCert) : UntrustedCertificateInfoBase(), iCert(0)
{
    QT_TRAP_THROWING(ConstructL(aCert));
}

// ----------------------------------------------------------------------------
// UntrustedCertificateInfoSymbian::~UntrustedCertificateInfoSymbian()
// ----------------------------------------------------------------------------
//
UntrustedCertificateInfoSymbian::~UntrustedCertificateInfoSymbian()
{
    delete iCert;
}

// ----------------------------------------------------------------------------
// UntrustedCertificateInfoSymbian::commonNameMatches()
// ----------------------------------------------------------------------------
//
bool UntrustedCertificateInfoSymbian::commonNameMatches(const QString &siteName) const
{
    bool matches = false;
    QT_TRAP_THROWING(matches = CommonNameMatchesL(siteName));
    return matches;
}

// ----------------------------------------------------------------------------
// UntrustedCertificateInfoSymbian::isPermanentAcceptAllowed()
// ----------------------------------------------------------------------------
//
bool UntrustedCertificateInfoSymbian::isPermanentAcceptAllowed() const
{
    return isDateValid();
}

// ----------------------------------------------------------------------------
// UntrustedCertificateInfoSymbian::certificateDetails()
// ----------------------------------------------------------------------------
//
QString UntrustedCertificateInfoSymbian::certificateDetails() const
{
    QString details;
    QTextStream stream(&details);
    // TODO: localised UI strings needed
    stream << tr("Issuer:\n%1\n").arg(issuerName());
    stream << endl;
    stream << tr("Subject:\n%1\n").arg(subjectName());
    stream << endl;
    stream << tr("Valid from:\n%1\n").arg(validFrom().toString());
    stream << endl;
    stream << tr("Valid until:\n%1\n").arg(validTo().toString());
    stream << endl;
    stream << tr("Certificate format:\n%1\n").arg(format());
    stream << endl;
    stream << tr("Algorithm:\n%1\n").arg(combinedAlgorithmName());
    stream << endl;
    stream << tr("Serial number:\n%1\n").arg(formattedSerialNumber());
    stream << endl;
    stream << tr("Fingerprint (SHA1):\n%1\n").arg(formattedFingerprint());
    // TODO: MD5 fingerprint missing
    return details;
}

// ----------------------------------------------------------------------------
// UntrustedCertificateInfoSymbian::ConstructL()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateInfoSymbian::ConstructL(const CX509Certificate& aCert)
{
    ASSERT( iCert == 0 );
    iCert = CX509Certificate::NewL( aCert );

    HBufC16* subjectBuf = iCert->SubjectL();
    mSubjectName = QString::fromUtf16(subjectBuf->Ptr(), subjectBuf->Length());
    delete subjectBuf;

    HBufC16* issuerBuf = iCert->IssuerL();
    mIssuerName = QString::fromUtf16(issuerBuf->Ptr(), issuerBuf->Length());
    delete issuerBuf;

    TPtrC8 fingerprint = iCert->Fingerprint();
    mFingerprint = QByteArray::fromRawData(
        reinterpret_cast<const char*>(fingerprint.Ptr()), fingerprint.Length());

    TPtrC8 serialNumber = iCert->SerialNumber();
    mSerialNumber = QByteArray::fromRawData(
        reinterpret_cast<const char*>(serialNumber.Ptr()), serialNumber.Length());

    const CValidityPeriod& validityPeriod = iCert->ValidityPeriod();
    mValidFrom = convertDateTime(validityPeriod.Start());
    mValidTo = convertDateTime(validityPeriod.Finish());

    mFormat = X509Certificate;

    const CSigningAlgorithmIdentifier& alg = iCert->SigningAlgorithm();
    mDigestAlgorithm = mapAlgorithm(alg.DigestAlgorithm().Algorithm());
    mAsymmetricAlgorithm = mapAlgorithm(alg.AsymmetricAlgorithm().Algorithm());
}

// ----------------------------------------------------------------------------
// UntrustedCertificateInfoSymbian::CommonNameMatchesL()
// ----------------------------------------------------------------------------
//
bool UntrustedCertificateInfoSymbian::CommonNameMatchesL(const QString &siteName) const
{
    bool matches = false;
    const CX500DistinguishedName& distinguishedName = iCert->SubjectName();
    HBufC* commonNameSymbian = distinguishedName.ExtractFieldL( KX520CommonName );
    if (commonNameSymbian) {
        CleanupStack::PushL(commonNameSymbian);
        QString commonName = QString::fromRawData(
            reinterpret_cast<const QChar*>(commonNameSymbian->Ptr()),
            commonNameSymbian->Length());
        matches = ( commonName == siteName );       // TODO: accept '*' chars in commonName?
        CleanupStack::PopAndDestroy(commonNameSymbian);
    }
    return matches;
}