/*
* 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:  Helper class to construct certificate list
*
*/

#include "advsecsettingscertlistbuilder_symbian.h"
#include "advsecsettingslabeledcertinfo_symbian.h"
#include "advsecsettingsstoreuids.h"    // KAdvSecSettingsDeviceCertStore
#include <x509cert.h>                   // CX509Certificate
#include <ccertattributefilter.h>       // CCertAttributeFilter
#include <X509CertNameParser.h>         // X509CertNameParser::PrimaryAndSecondaryNameL
#include <stl/_auto_ptr.h>              // std::auto_ptr

_LIT(KNameSeparator, " ");

// implemented in advsecsettingssecuritymodulemodel_symbian_p.cpp
QString CopyStringL(const TDesC16 &aDes16);


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

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::NewL()
// ---------------------------------------------------------------------------
//
CAdvSecSettingsCertListBuilder *CAdvSecSettingsCertListBuilder::NewL(
    RFs &aFs, CUnifiedCertStore &aCertStore)
{
    CAdvSecSettingsCertListBuilder *self = new(ELeave) CAdvSecSettingsCertListBuilder(
        aFs, aCertStore);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::~CAdvSecSettingsCertListBuilder()
// ---------------------------------------------------------------------------
//
CAdvSecSettingsCertListBuilder::~CAdvSecSettingsCertListBuilder()
{
    Cancel();
    iLabeledCertInfos.ResetAndDestroy();
    delete iCertificate;
    delete iCertAttributeFilter;
    iCertInfoArray.Close();
    iCertList = NULL;
    iClientInfoArray = NULL;
    iClientStatus = NULL;
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::GetCertificateList()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::GetCertificateList(
    QList<AdvSecSettingsCertificate*> &certList,
    RMPointerArray<CCTCertInfo> &aCertInfoArray,
    TRequestStatus &aStatus)
{
    aStatus = KRequestPending;
    if (!IsActive() && (iState == EIdle)) {
        iClientStatus = &aStatus;
        iCertList = &certList;
        iClientInfoArray = &aCertInfoArray;

        iCertInfoArray.Close();
        ResetCertAttributeFilter();
        iCertStore.List(iCertInfoArray, *iCertAttributeFilter, iStatus);
        iState = EListingCerts;
        SetActive();
   } else {
        TRequestStatus *status = &aStatus;
        User::RequestComplete(status, KErrInUse);
    }
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::DoCancel()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::DoCancel()
{
    switch (iState) {
    case EListingCerts:
        iCertStore.CancelList();
        break;
    case ERetrievingCert:
        iCertStore.CancelRetrieve();
        break;
    case EProcessingCert:
        // nothing to do
        break;
    default:
        break;
    }
    User::RequestComplete(iClientStatus, KErrCancel);
    iClientStatus = NULL;
    iState = EIdle;
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::RunL()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::RunL()
{
    User::LeaveIfError(iStatus.Int());
    switch (iState) {
    case EListingCerts:
        ProcessFirstCertificateL();
        break;
    case ERetrievingCert:
        ProcessNextCertificateL();
        break;
    case EProcessingCert:
        ProcessNextCertificateL();
        break;
    default:
        ASSERT(EFalse);
        break;
    }
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::RunError()
// ---------------------------------------------------------------------------
//
TInt CAdvSecSettingsCertListBuilder::RunError(TInt aError)
{
    User::RequestComplete(iClientStatus, aError);
    iClientStatus = NULL;
    iState = EIdle;
    return KErrNone;
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::CAdvSecSettingsCertListBuilder()
// ---------------------------------------------------------------------------
//
CAdvSecSettingsCertListBuilder::CAdvSecSettingsCertListBuilder(RFs &aFs,
    CUnifiedCertStore &aCertStore) : CActive(CActive::EPriorityLow),
    iFs(aFs), iCertStore(aCertStore), iCertPtr(0,0)
{
    CActiveScheduler::Add(this);
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::ConstructL()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::ConstructL()
{
    iCertAttributeFilter = CCertAttributeFilter::NewL();
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::ResetCertAttributeFilter()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::ResetCertAttributeFilter()
{
    ASSERT(iCertAttributeFilter);
    iCertAttributeFilter->iLabelIsSet = EFalse;
    iCertAttributeFilter->iUidIsSet = EFalse;
    iCertAttributeFilter->iFormatIsSet = EFalse;
    iCertAttributeFilter->iKeyUsage = EX509UsageAll;
    iCertAttributeFilter->iOwnerTypeIsSet = EFalse;
    iCertAttributeFilter->iSubjectKeyIdIsSet = EFalse;
    iCertAttributeFilter->iIssuerKeyIdIsSet = EFalse;
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::ProcessFirstCertificateL()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::ProcessFirstCertificateL()
{
    iCertInfoIndex = 0;
    StartProcessingCertificateL();
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::ProcessNextCertificateL()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::ProcessNextCertificateL()
{
    CompleteProcessingCertificateL();
    ++iCertInfoIndex;
    StartProcessingCertificateL();
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::StartProcessingCertificateL()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::StartProcessingCertificateL()
{
    if (iCertInfoIndex < iCertInfoArray.Count()) {
        CCTCertInfo *certInfo = iCertInfoArray[iCertInfoIndex];

        if ((certInfo->CertificateOwnerType() == ECACertificate) &&
            (certInfo->CertificateFormat() == EX509Certificate)) {
            // Have to retrieve the cert to add parts of subject
            // to certificate label. For example, all Java certs
            // have the same label by default.
            if (iCertificate) {
                delete iCertificate;
                iCertificate = NULL;
            }
            iCertificate = HBufC8::NewL(certInfo->Size());
            iCertPtr.Set(iCertificate->Des());
            iCertStore.Retrieve(*certInfo, iCertPtr, iStatus);
            iState = ERetrievingCert;
            SetActive();
        } else {
            // Certificate label can be used as such.
            TRequestStatus *status = &iStatus;
            User::RequestComplete(status, KErrNone);
            iState = EProcessingCert;
            SetActive();
        }

    } else {
        ReturnCertificateListL();

        User::RequestComplete(iClientStatus, KErrNone);
        iClientStatus = NULL;
        iState = EIdle;
    }
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::CompleteProcessingCertificateL()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::CompleteProcessingCertificateL()
{
    ASSERT(iCertInfoIndex < iCertInfoArray.Count());
    CCTCertInfo *certInfo = iCertInfoArray[iCertInfoIndex];

    CAdvSecSettingsLabeledCertInfo *labeledCertInfo =
        new(ELeave) CAdvSecSettingsLabeledCertInfo(*certInfo);
    CleanupStack::PushL(labeledCertInfo);
    labeledCertInfo->SetLabelL(certInfo->Label());

    if (iCertificate) {
        CX509Certificate *cert = CX509Certificate::NewL(*iCertificate);
        CleanupStack::PushL(cert);

        HBufC *primaryName = NULL;
        HBufC *secondaryName = NULL;
        TInt err = X509CertNameParser::PrimaryAndSecondaryNameL(*cert,
            primaryName, secondaryName, certInfo->Label());
        if (!err) {
            if (primaryName && primaryName->Length()) {
                labeledCertInfo->AppendLabelL(KNameSeparator, *primaryName);
            } else {
                if (secondaryName && secondaryName->Length()) {
                    labeledCertInfo->AppendLabelL(KNameSeparator, *secondaryName);
                }
            }
        }

        CleanupStack::PopAndDestroy(cert);
        delete iCertificate;
        iCertificate = NULL;
    }

    iLabeledCertInfos.AppendL(labeledCertInfo);
    CleanupStack::Pop(labeledCertInfo);
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::ReturnCertificateListL()
// ---------------------------------------------------------------------------
//
void CAdvSecSettingsCertListBuilder::ReturnCertificateListL()
{
    TLinearOrder<CAdvSecSettingsLabeledCertInfo> order( CAdvSecSettingsLabeledCertInfo::Compare );
    iLabeledCertInfos.Sort( order );

    iCertList->clear();
    iClientInfoArray->Reset();
    TInt count = iLabeledCertInfos.Count();
    for (TInt index = 0; index < count; index++) {
        const CCTCertInfo &certInfo = iLabeledCertInfos[index]->CertInfo();
        iClientInfoArray->AppendL(&certInfo);

        std::auto_ptr<AdvSecSettingsCertificate> cert(new(ELeave) AdvSecSettingsCertificate);
        cert->setModelIndex(index);
        cert->setCertType(CertType(certInfo));
        cert->setLabel(CopyStringL(iLabeledCertInfos[index]->Label()));
        iCertList->append(cert.release());
    }
    iLabeledCertInfos.ResetAndDestroy();
    iCertInfoArray.Reset();
}

// ---------------------------------------------------------------------------
// CAdvSecSettingsCertListBuilder::CertType()
// ---------------------------------------------------------------------------
//
AdvSecSettingsCertificate::CertificateType CAdvSecSettingsCertListBuilder::CertType(
    const CCTCertInfo &aCertInfo)
{
    AdvSecSettingsCertificate::CertificateType type =
        AdvSecSettingsCertificate::NotDefined;
    TUid storeType;
    switch (aCertInfo.CertificateOwnerType()) {
    case ECACertificate:
        type = AdvSecSettingsCertificate::AuthorityCertificate;
        break;
    case EUserCertificate:
        storeType = aCertInfo.Handle().iTokenHandle.iTokenTypeUid;
        if (storeType.iUid == KAdvSecSettingsDeviceCertStore) {
            type = AdvSecSettingsCertificate::DeviceCertificate;
        } else {
            type = AdvSecSettingsCertificate::PersonalCertificate;
        }
        break;
    case EPeerCertificate:
        type = AdvSecSettingsCertificate::TrustedSiteCertificate;
        break;
    default:
        break;
    }
    return type;
}