/*

* Copyright (c) 2003-2009 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:   Implementation of class CCertManUICertificateHelper

*

*/

#include <X509CertNameParser.h>

#include <certmanui.rsg>

#include <hash.h>                   // MD5 fingerprint

#include <aknmessagequerydialog.h>

#include <pkixcertchain.h>          // for validation

#include <aknnotewrappers.h>        // for warning & information notes

#include <sysutil.h>

#include <ErrorUI.h>

#include <unifiedkeystore.h>

#include <TrustedSitesStore.h>

#include <x509keys.h>               // TX509KeyFactory

#include <e32math.h>                // Pow

#include "Certmanui.hrh"

#include "CertmanuiCertificateHelper.h"

#include "CertmanuiCommon.h"

#include "CertmanuiSyncWrapper.h"

#include "CertManUILogger.h"

const TInt KFileCertStoreUid( 0x101F501A );

const TInt KTrustedServerCertStoreUid( 0x101FB66F );

const TInt KDeviceCertStoreUid( 0x101FB668 );

const TInt KDeviceKeyStoreUid( 0x101FB66A );

_LIT( KBlockSeparator, " " );

template <class T>

class CleanupResetAndDestroy

    {

public:

    inline static void PushL( T& aRef );

private:

    static void ResetAndDestroy( TAny *aPtr );

    };

template <class T>

inline void CleanupResetAndDestroyPushL( T& aRef );

template <class T>

inline void CleanupResetAndDestroy<T>::PushL( T& aRef )

    {

    CleanupStack::PushL( TCleanupItem( &ResetAndDestroy, &aRef ) );

    }

template <class T>

void CleanupResetAndDestroy<T>::ResetAndDestroy( TAny *aPtr )

    {

    if( aPtr )

        {

        static_cast<T*>( aPtr )->ResetAndDestroy();

        }

    }

template <class T>

inline void CleanupResetAndDestroyPushL( T& aRef )

    {

    CleanupResetAndDestroy<T>::PushL( aRef );

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::CCertManUICertificateHelper()

// Default C++ Constructor

// ---------------------------------------------------------

//

CCertManUICertificateHelper::CCertManUICertificateHelper( CCertManUIKeeper& aKeeper )

: iKeeper(aKeeper)

    {

  }

// ---------------------------------------------------------

// CCertManUICertificateHelper::~CCertManUICertificateHelper()

// Destructor

// ---------------------------------------------------------

//

CCertManUICertificateHelper::~CCertManUICertificateHelper()

    {

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::CutCertificateField(TPtrC aField)

// If CertLabel, Issuer and Owner length is over 80 characters,

// cut it down to 80

// Returns the cut certificate field.

// ---------------------------------------------------------

//

TPtrC CCertManUICertificateHelper::CutCertificateField( TPtrC aField )

    {

    CERTMANUILOGGER_ENTERFN(

         "CCertManUICertificateHelper::CutCertificateField" );

    TInt fieldLength = aField.Length();

    if ( fieldLength >= KMaxLengthTextCertLabelVisible )

        {

        TPtrC cutCertLabel = aField.Mid( 0, KMaxLengthTextCertLabelVisible );

        CERTMANUILOGGER_LEAVEFN(

           "CCertManUICertificateHelper::CutCertificateField" );

        return cutCertLabel;

        }

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::CutCertificateField" );

    return aField;

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::IsCertificateDeletable

// Check whether certificate is deletable

// ---------------------------------------------------------

//

TBool CCertManUICertificateHelper::IsCertificateDeletable( TInt aIndex,

    TInt aType ) const

    {

    CERTMANUILOGGER_ENTERFN(

        "CCertManUICertificateHelper::IsCertificateDeletable" );

    TBool ret = ETrue;

    // If wim has not been enabled and certificate resides in smart card

    // we cannot delete it since we don't have smart card certificate

    // delete functionality in non WIM builds. So in non WIM builds all

    // smart card certificates are marked read-only.

    if( aIndex > -1 )

        {

        CCTCertInfo* entry;

        if ( aType == KCertTypeAuthority )

            {

            entry = iKeeper.iCALabelEntries[ aIndex ]->iCAEntry;

            }

        else if( aType == KCertTypeTrustedSite )

            {

            entry = iKeeper.iPeerLabelEntries[ aIndex ]->iPeerEntry;

            }

        else if( aType == KCertTypeDevice )

            {

            entry = iKeeper.iDeviceLabelEntries[ aIndex ]->iDeviceEntry;

            }

        else

            {

            entry = iKeeper.iUserLabelEntries[ aIndex ]->iUserEntry;

            }

        if ( !entry->IsDeletable() )

            {

            ret = EFalse;

            }

        }

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::IsCertificateDeletable" );

    return ret;

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::IsOneMarkedCertificateDeletable

// Check whether one marked certificate is deletable, or

// if none certificate is marked, check if the highlighted

// certificate is deletable

// ---------------------------------------------------------

//

TBool CCertManUICertificateHelper::IsOneMarkedCertificateDeletable

    ( CEikColumnListBox* aListBox, TInt aType ) const

    {

    CERTMANUILOGGER_ENTERFN(

        "CCertManUICertificateHelper::IsOneMarkedCertificateDeletable" );

    const CArrayFix<TInt>* array  = aListBox->SelectionIndexes();

    TInt markedCount = array->Count();

    TBool oneIsDeletable = EFalse;

    if ( 0 == markedCount )

        {

        TInt currentItem = aListBox->CurrentItemIndex();

        return IsCertificateDeletable( currentItem, aType );

        }

    for ( TInt i = 0; !oneIsDeletable && i < markedCount; i++ )

        {

        oneIsDeletable = IsCertificateDeletable( (*array)[i], aType );

        }

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::IsOneMarkedCertificateDeletable" );

    return oneIsDeletable;

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::MessageQueryViewDetailsL(TInt aIndex)

// Creates the whole of certificate details view

// Appends strings from both resources and CertManAPI to one

// message body text and displays it.

// ---------------------------------------------------------

//

void CCertManUICertificateHelper::MessageQueryViewDetailsL( TInt aIndex,

    TInt aType,

    CEikonEnv* aEikonEnv )

    {

    CERTMANUILOGGER_ENTERFN(

        "CCertManUICertificateHelper::MessageQueryViewDetailsL" );

     LOG_WRITE_FORMAT( "certificate index %i", aIndex );

    iKeeper.StartWaitDialogL( ECertmanUiWaitDialog );

    HBufC* message = HBufC::NewLC( KMaxLengthTextDetailsBody );

    TRAPD( err, CreateMessageBodyTextL( aIndex, aType, aEikonEnv, *message ) );

    iKeeper.CloseWaitDialogL();

    User::LeaveIfError( err );

    if( message->Length() )

        {

        HBufC* header = StringLoader::LoadLC( R_TEXT_RESOURCE_DETAILS_VIEW_HEADER );

        CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( *message );

        dlg->PrepareLC( R_MESSAGE_QUERY_DETAILS_VIEW );

        dlg->QueryHeading()->SetTextL( *header );

        dlg->RunLD();

        CleanupStack::PopAndDestroy( header );

        }

    CleanupStack::PopAndDestroy( message );

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::MessageQueryViewDetailsL" );

    }

// ---------------------------------------------------------

// CCertManUIViewAuthority::ValidateCertificateL(

// Checks if the certificate is corrupted

// Checks the validity period of the certificate

// Display only one warning note, in the following order:

// 1) Expired/Not yet valid

// 2) Corrupted

// 3) Not trusted

// ---------------------------------------------------------

//

void CCertManUICertificateHelper::ValidateCertificateL(

    TInt aIndex, CCertificate* aDetails, const CCTCertInfo& aCertInfo, TInt aType )

    {

    CERTMANUILOGGER_ENTERFN(

        "CCertManUICertificateHelper::ValidateCertificateL" );

    TInt poppableItems = 0;

    // Check allways first the validity period

    // Show Expired/Not yet valid notes

    const CValidityPeriod& validityPeriod = aDetails->ValidityPeriod();

    const TTime& startValue = validityPeriod.Start();

    const TTime& finishValue = validityPeriod.Finish();

    TTime current;

    current.UniversalTime();

    if ( startValue > current )

        {

        // certificate is not valid yet

        HBufC* string = StringLoader::LoadLC(

            R_WARNING_NOTE_TEXT_CERTIFICATE_NOT_VALID_YET );

        DisplayWarningNoteLD(string);

        }

    else if ( finishValue < current )

        {

        // certificate is expired

        HBufC* string = StringLoader::LoadLC(

            R_WARNING_NOTE_TEXT_CERTIFICATE_EXPIRED );

        DisplayWarningNoteLD( string );

        }

    else

        {

        // put here check for certificate status, show warning notes if needed

        TBool noValidationError = ETrue;

        CArrayFixFlat<TValidationError>* status = NULL;

        TCertificateFormat certificateFormat;

        if ( aType == KCertTypeAuthority )

            {

            certificateFormat = iKeeper.iCALabelEntries[aIndex]->

                                        iCAEntry->CertificateFormat();

            }

        else if ( aType == KCertTypeTrustedSite )

            {

            certificateFormat = iKeeper.iPeerLabelEntries[aIndex]->

                                        iPeerEntry->CertificateFormat();

            }

        else if ( aType == KCertTypeDevice )

            {

            certificateFormat = iKeeper.iDeviceLabelEntries[aIndex]->

                                        iDeviceEntry->CertificateFormat();

            }

        else

            {

            certificateFormat = iKeeper.iUserLabelEntries[aIndex]->

                                        iUserEntry->CertificateFormat();

            }

        switch ( certificateFormat )

            {

            case EX509Certificate:

                {

                status = ValidateX509CertificateL(

                    (CX509Certificate*)aDetails );

                break;

                }

            default:

                {

                status = new ( ELeave) CArrayFixFlat<TValidationError>( 1 );

                break;

                }

            }

        CleanupStack::PushL( status );

        poppableItems++;

        TInt errorCount = status->Count();

        TBool ready = EFalse;

        for ( TInt i = 0; i < errorCount && !ready; i++ )

            {

            TValidationError errorType = status->At(i);

            switch ( errorType )

                {

                case EValidatedOK:

                case EChainHasNoRoot:

                case EBadKeyUsage:

                // Ignore these errors

                    LOG_WRITE( "Ignored certificate validation error" );

                    break;

                default:

                // certificate is corrupted

                noValidationError = EFalse;

                HBufC* string = StringLoader::LoadLC(

                    R_WARNING_NOTE_TEXT_CERTIFICATE_CORRUPTED );

                DisplayWarningNoteLD( string );

                ready = ETrue;

                    break;

                }

            }

        if ( noValidationError  && (aType == KCertTypeAuthority ))

        // Check for last if the CA certificate has no clients,

        // ie. the trust state of every client is No

        // For user certificates we don't do the check

            {

            RArray<TUid> trusterUids;

            CleanupClosePushL( trusterUids );

            poppableItems++;

            iKeeper.iWrapper->GetApplicationsL(

                iKeeper.CertManager(), aCertInfo, trusterUids );

            if ( trusterUids.Count() == 0)

                {

                HBufC* string = StringLoader::LoadLC(

                    R_WARNING_NOTE_TEXT_CERTIFICATE_NOT_TRUSTED );

                DisplayWarningNoteLD( string );

                }

            }

        }

    CleanupStack::PopAndDestroy( poppableItems );

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::ValidateCertificateL" );

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::DetailsFieldDynamicL(

// Appends a field that has string from resources and string from CertManAPI

// to the details view message body

// ---------------------------------------------------------

//

void CCertManUICertificateHelper::DetailsFieldDynamicL(

    HBufC& aMessage, TPtrC aValue, TInt aResourceOne, TInt aResourceTwo )

    {

    CERTMANUILOGGER_ENTERFN(

        "CCertManUICertificateHelper::DetailsFieldDynamicL" );

    DetailsResourceL( aMessage, aResourceOne );

    DetailsDynamicL( aMessage, aValue, aResourceTwo );

    aMessage.Des().Append( KCertManUIDetailsViewEnter );

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::DetailsFieldDynamicL" );

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::DetailsResourceL(

// Reads line from resources

// ---------------------------------------------------------

//

void CCertManUICertificateHelper::DetailsResourceL(

    HBufC& aMessage, TInt aResourceOne )

    {

    CERTMANUILOGGER_ENTERFN(

        "CCertManUICertificateHelper::DetailsResourceL" );

    HBufC* stringHolder = StringLoader::LoadLC( aResourceOne );

    aMessage.Des().Append( stringHolder->Des() );

    CleanupStack::PopAndDestroy();  // stringHolder

    aMessage.Des().Append( KCertManUIDetailsViewEnter );

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::DetailsResourceL" );

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::DetailsFieldResourceL(

// Appends a field that has two strings from resources

// to the details view message body

// ---------------------------------------------------------

//

void CCertManUICertificateHelper::DetailsFieldResourceL(

    HBufC& aMessage, TInt aResourceOne,

    TInt aResourceTwo)

    {

    CERTMANUILOGGER_ENTERFN(

        "CCertManUICertificateHelper::DetailsFieldResourceL" );

    DetailsResourceL( aMessage, aResourceOne );

    DetailsResourceL( aMessage, aResourceTwo );

    aMessage.Des().Append( KCertManUIDetailsViewEnter );

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::DetailsFieldResourceL" );

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::DevideToBlocks

// ---------------------------------------------------------

//

void CCertManUICertificateHelper::DevideToBlocks( const TDesC8& aInput, TPtr aOutput )

    {

    const TInt KBlockLength = 2;

    TInt blockIndex = 0;

    for ( TInt j = 0 ; j < aInput.Length() ; j++ )

        {

        if ( blockIndex == KBlockLength )

            {

            aOutput.Append( KBlockSeparator );

            blockIndex = 0;

            }

        aOutput.AppendNumFixedWidthUC( (TUint)(aInput[ j ]), EHex, 2 );

        ++blockIndex;

        }

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::DisplayWarningNoteLD(HBufC* aString)

// Displays the warning note for corrupted/expired/not yet valid certificate

// ---------------------------------------------------------

//

void CCertManUICertificateHelper::DisplayWarningNoteLD( HBufC* aString )

    {

    CERTMANUILOGGER_ENTERFN(

        "CCertManUICertificateHelper::DisplayWarningNoteLD" );

    CAknWarningNote* note = new ( ELeave ) CAknWarningNote( ETrue );

    note->ExecuteLD( *aString );

    CleanupStack::PopAndDestroy();  // aString

    CERTMANUILOGGER_LEAVEFN(

        "CCertManUICertificateHelper::DisplayWarningNoteLD" );

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::ValidateX509CertificateL(CX509Certificate* aDetails)

// Checks if the certificate is corrupted

// Checks the validity period of the certificate

// Display only one warning note, in the following order:

// 1) Expired/Not yet valid

// 2) Corrupted

// 3) Not trusted

// ---------------------------------------------------------

//

CArrayFixFlat<TValidationError>* CCertManUICertificateHelper::

    ValidateX509CertificateL( CX509Certificate* aDetails )

    {

    TInt poppableItems = 0;

    CArrayFixFlat<TValidationError>* status =

        new ( ELeave ) CArrayFixFlat<TValidationError>( 1 );

    CleanupStack::PushL( status ); //This is returned, so it isn't destroyed at the end.

    TTime GMTTime;

    GMTTime.UniversalTime(); // Get Universal Time

    RPointerArray<CX509Certificate> certArray( &aDetails, 1 );

    CPKIXCertChain* chain = CPKIXCertChain::NewLC(

        iKeeper.iRfs, aDetails->Encoding(), certArray );

    poppableItems++;

    CPKIXValidationResult* result = CPKIXValidationResult::NewLC();

    poppableItems++;

    iKeeper.iWrapper->ValidateX509RootCertificateL( result, GMTTime, chain );

    TValidationStatus validationStatus = result->Error();

    //Set reserve space. One for error, other for warnings.

    status->SetReserveL( 1 + result->Warnings().Count() );

    status->AppendL(validationStatus.iReason);

    for ( TUint8 i = 0; i < result->Warnings().Count(); i++ )

        {

        status->AppendL( result->Warnings().At(0).iReason );

        }

    CleanupStack::PopAndDestroy( poppableItems );    //  All but status.

    CleanupStack::Pop();        //  status

    return status;

    }

// ---------------------------------------------------------

// CCertManUICertificateHelper::DetailsDynamicL(

// HBufC& aMessage, TPtrC aValue, TInt aResourceOne)

// Reads dynamic text from CertManAPI, if the string is empty