/*

* 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 CCertManUIKeeper

*                Creates and destroys all the views CertManUI uses.

*                Handles changing CertManUI views.

*

*/

// INCLUDE FILES

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

#include <unifiedcertstore.h>

#include <unifiedkeystore.h>

#include <mctwritablecertstore.h>

#include <X509CertNameParser.h>

#include <certmanui.rsg>

#include <data_caging_path_literals.hrh>

#include "CertmanuiSyncWrapper.h"

#include "CertmanuiCertificateHelper.h"

#include "Certmanuidialogs.h"

#include "CertmanuiKeeper.h"

#include "CertmanuiviewTrust.h"

#include "CertmanuiviewPersonal.h"

#include "CertmanuicontainerAuthority.h"

#include "CertmanuiCommon.h"

#include "CertManUILogger.h"

#include "securityuisvariant.hrh"

// CONSTANTS

_LIT( KNameSeparator, " " );

_LIT( KResourceFile, "z:CertManUi.rsc" );

// ============================= GLOBAL FUNCTIONS ==============================

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

// CloseWaitDialogOnLeave( TAny* aPtr )

// Closes wait dialog when leave happens.

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

void CloseWaitDialogOnLeave( TAny* aPtr )

    {

    CCertManUIKeeper* keeper = reinterpret_cast< CCertManUIKeeper* >( aPtr );

    if( keeper )

        {

        TRAP_IGNORE( keeper->CloseWaitDialogL() );

        }

    }

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

// CleanupCloseWaitDialogPushL( CCertManUIKeeper& aKeeper )

// Helper function for to close wait dialog if leave happens.

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

void CleanupCloseWaitDialogPushL( CCertManUIKeeper& aKeeper )

    {

    CleanupStack::PushL( TCleanupItem( CloseWaitDialogOnLeave, &aKeeper ) );

    }

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

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

// TInt CompareCALabels( const CCTCertInfo& cert1, const CCTCertInfo& cert2 )

// Compares two labels.

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

//

TInt CompareCALabels(

    const CCertManUICertData& cert1,

    const CCertManUICertData& cert2 )

    {

    return ( (cert1.iCAEntryLabel->Des()).

        CompareF( cert2.iCAEntryLabel->Des() ) );

    }

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

// TInt CompareUserLabels( const CCTCertInfo& cert1, const CCTCertInfo& cert2 )

// Compares two labels.

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

//

TInt CompareUserLabels(

    const CCertManUICertData& cert1,

    const CCertManUICertData& cert2 )

    {

    return ( (cert1.iUserEntryLabel->Des()).

        CompareF( cert2.iUserEntryLabel->Des() ) );

    }

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

// TInt ComparePeerLabels( const CCTCertInfo& cert1, const CCTCertInfo& cert2 )

// Compares two labels.

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

//

TInt ComparePeerLabels(

    const CCertManUICertData& cert1,

    const CCertManUICertData& cert2 )

    {

    return ( (cert1.iPeerEntryLabel->Des()).

        CompareF( cert2.iPeerEntryLabel->Des() ) );

    }

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

// TInt CompareDeviceLabels( const CCTCertInfo& cert1, const CCTCertInfo& cert2 )

// Compares two labels.

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

//

TInt CompareDeviceLabels(

    const CCertManUICertData& cert1,

    const CCertManUICertData& cert2 )

    {

    return ( (cert1.iDeviceEntryLabel->Des()).

        CompareF( cert2.iDeviceEntryLabel->Des() ) );

    }

// ================= HELPER CLASS ===========================

// Constructor.

CCertManUICertData::CCertManUICertData()

    {

    }

// Destructor.

CCertManUICertData::~CCertManUICertData()

    {

    delete iCAEntryLabel;

    delete iUserEntryLabel;

    delete iPeerEntryLabel;

    delete iDeviceEntryLabel;

    }

// Releases Certificate entries.

void CCertManUICertData::Release()

    {

    if ( iCAEntry )

        {

        iCAEntry->Release();

        }

    if ( iUserEntry )

        {

        iUserEntry->Release();

        }

    if ( iPeerEntry )

        {

        iPeerEntry->Release();

        }

    if ( iDeviceEntry )

        {

        iDeviceEntry->Release();

        }

    delete this;

    }

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

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

// CCertManUIKeeper::CCertManUIKeeper()

// Constructor with parent

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

//

    {

    CERTMANUILOGGER_CREATE; //lint !e960

    CERTMANUILOGGER_WRITE_TIMESTAMP( "CCertManUIKeeper::CCertManUIKeeper" );

    }

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

// CCertManUIKeeper::~CCertManUIKeeper()

// Destructor

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

//

CCertManUIKeeper::~CCertManUIKeeper()

    {

    CERTMANUILOGGER_WRITE_TIMESTAMP( "CCertManUIKeeper::~CCertManUIKeeper" );

    if ( iWrapper )

        {

        iWrapper->Cancel();

        }

    delete iFilter;

    delete iKeyFilter;

    delete iStore;

    delete iKeyStore;

    delete iWrapper;

    delete iCertificateHelper;

    delete iCertmanUIDialog;

    iCAEntries.Close();

    iCALabelEntries.Close();

    iUserEntries.Close();

    iUserLabelEntries.Close();

    iPeerEntries.Close();

    iPeerLabelEntries.Close();

    iDeviceEntries.Close();

    iDeviceLabelEntries.Close();

    iKeyEntries.Close();

    iRfs.Close();

    CERTMANUILOGGER_DELETE; //lint !e960

    }

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

// CCertManUIKeeper* CCertManUIKeeper::NewL(const TRect& aRect, TUid aViewId)

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

//

CCertManUIKeeper* CCertManUIKeeper::NewL(

    const TRect& aRect, TUid aViewId )

    {

    CCertManUIKeeper* self = new ( ELeave ) CCertManUIKeeper;

    CleanupStack::PushL( self );

    self->ConstructL( aRect, aViewId );

    CleanupStack::Pop();

    return self;

    }

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

// CCertManUIKeeper* CCertManUIKeeper::NewLC(

//      const TRect& aRect, TUid aViewId)

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

//

CCertManUIKeeper* CCertManUIKeeper::NewLC(

    const TRect& aRect, TUid aViewId )

    {

    CCertManUIKeeper* self = new ( ELeave ) CCertManUIKeeper;

    CleanupStack::PushL( self );

    self->ConstructL( aRect, aViewId );

    return self;

    }

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

// CCertManUIKeeper::ConstructL(

 //     const TRect& aRect, TUid aViewId

//

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

//

void CCertManUIKeeper::ConstructL( const TRect& aRect, TUid aViewId )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIKeeper::ConstructL" );

    AddResourceFileL();

    InitializeL( aRect, aViewId );

    CERTMANUILOGGER_LEAVEFN( "CCertManUIKeeper::ConstructL" );

    }

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

// CCertManUIKeeper::InitializeL(

 //     const TRect& aRect, TUid aViewId

//

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

//

void CCertManUIKeeper::InitializeL( const TRect& /*aRect*/, TUid /*aViewId*/)

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIKeeper::InitializeL" );

    iCertmanUIDialog = new ( ELeave ) CCertManUIWaitDialog();

    // Ensure that file server session is succesfully created

    User::LeaveIfError( iRfs.Connect() );

    iCertsDatOK = EFalse;

    // Is this the place where these errors can be handled?

    // iCertsDatOK is set when cert entries are refreshed.

    // Create a R/W interface. Symbian has promised to support

    // up to two simultaneous R/W interfaces.

    TRAPD ( error, iStore = CUnifiedCertStore::NewL( iRfs, ETrue ) );

    if ( error != KErrNone )

        {

        if ( error == KErrNotSupported

           || error == KErrNotReady

           || error == KErrArgument

           || error == KErrNotFound )

            {

            // Something may be wrong with the databases

            iCertsDatOK = EFalse;

            ShowErrorNoteL( error );

            User::Leave( KErrNone );

            }

        else

            {

            User::Leave( error );

            }

        }

    else

        {

        // cacerts.dat file is ok

        iCertsDatOK = ETrue;

        }

    iCertificateHelper = new ( ELeave ) CCertManUICertificateHelper( *this );

    iWrapper = CCertManUISyncWrapper::NewL();

    error = iWrapper->InitStoreL( iStore );

    if ( error )

        {

        LOG_WRITE_FORMAT("InitStoreL returned %i", error);

        }

    iFilter = CCertAttributeFilter::NewL();

    TRAP( error, iKeyStore = CUnifiedKeyStore::NewL( iRfs ) );

    if ( error != KErrNone )

        {

        if (error == KErrNotSupported

            || error == KErrNotReady

            || error == KErrArgument

            || error == KErrNotFound)

            {

            // Something is wrong with key stores

            LOG_WRITE( "Keystore corrupt" );

            ShowErrorNoteL( error );

            User::Leave( KErrNone );

            }

        else

            {

            User::Leave( error );

            }

          }

    LOG_WRITE("Init keystore");

    iWrapper->InitStoreL( iKeyStore );

    iKeyEntries.Close();

    LOG_WRITE_FORMAT("Keys available : %i", iKeyEntries.Count());

    if ( iCertsDatOK ) // == ETrue

        {

        iStartup = ETrue;

        }

    CERTMANUILOGGER_LEAVEFN( "CCertManUIKeeper::InitializeL" );

    }

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

// CCertManUIKeeper::AddResourceFileL()

//

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

//

void CCertManUIKeeper::AddResourceFileL()

    {

    TFileName fileName;

    TParse parse;

    parse.Set( KResourceFile, &KDC_RESOURCE_FILES_DIR, NULL );

    fileName = parse.FullName();

    iResourceLoader.OpenL( fileName );

    }

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

// CCertManUIKeeper::FocusChanged(TDrawNow aDrawNow)

// Added here because FocusChanged need to be included

// in every control derived from CCoeControl that can have listbox

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

//

void CCertManUIKeeper::FocusChanged(TDrawNow aDrawNow)

    {

    if (iListBox)

        {

        iListBox->SetFocus( IsFocused(), aDrawNow );

        }

     }

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

// CCertManUIKeeper::ActivateTitleL(TInt aCurrentTitle)

// Activates the WimTitle and CertManUI Trust Settings title

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

//

void CCertManUIKeeper::ActivateTitleL( TInt aCurrentTitle )

    {

    CERTMANUILOGGER_ENTERFN("CCertManUIKeeper::ActivateTitleL" );

    CEikStatusPane* sp = STATIC_CAST(

        CAknAppUi*, iEikonEnv->EikAppUi())->StatusPane();

    // Fetch pointer to the default title pane control

    CAknTitlePane* title = STATIC_CAST(

        CAknTitlePane*, sp->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ));

    TResourceReader reader;

    if ( aCurrentTitle == KViewTitleCertManUI )

        {

        iCoeEnv->CreateResourceReaderLC( reader, R_CERTMANUI_VIEW_TITLE );

        }

    else if ( aCurrentTitle == KViewTitleCertManUIAuthority )

        {

        iCoeEnv->CreateResourceReaderLC( reader, R_CERTMANUI_VIEW_TITLE_AUTHORITY );

        }

    else if ( aCurrentTitle == KViewTitleCertManUITrustedSite )

        {

        iCoeEnv->CreateResourceReaderLC( reader, R_CERTMANUI_VIEW_TITLE_TRUSTED_SITE );

        }

    else if ( aCurrentTitle == KViewTitleCertManUIPersonal )

        {

        iCoeEnv->CreateResourceReaderLC( reader, R_CERTMANUI_VIEW_TITLE_PERSONAL );

        }

    else if ( aCurrentTitle == KViewTitleCertManUIDevice )

        {

        iCoeEnv->CreateResourceReaderLC( reader, R_CERTMANUI_VIEW_TITLE_DEVICE );

        }

    else  // for lint

        {

        }

    title->SetFromResourceL( reader );

    CleanupStack::PopAndDestroy();  // reader

    CERTMANUILOGGER_LEAVEFN( "CCertManUIKeeper::ActivateTitleL" );

    }

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

// CCertManUIKeeper::HandleControlEventL(

//      CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/)

// Cannot be changed to non-leaving function.

// L-function is required by the class definition, even if empty.

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

//

void CCertManUIKeeper::HandleControlEventL(

    CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/)

    {

    }

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

// CCertManUIKeeper::OfferKeyEventL(

//      const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/)

// Called when a key is pressed.

// Cannot be changed to non-leaving function.

// L-function is required by the class definition, even if empty.

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

//

TKeyResponse CCertManUIKeeper::OfferKeyEventL(

    const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/)

    {

    // Listbox takes all event even if it doesn't use them

    return EKeyWasNotConsumed;

    }

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

// CCertManUIKeeper::CertManager()

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

//

CUnifiedCertStore*& CCertManUIKeeper::CertManager()

    {

    return iStore;

    }

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

// CCertManUIKeeper::KeyManager()

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

//

CUnifiedKeyStore*& CCertManUIKeeper::KeyManager()

    {

    return iKeyStore;

    }

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

// CCertManUIKeeper::RefreshCAEntriesL()

// Checks that cacerts.dat file is not corrupted and

// returns CA certificates from it

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

//

void CCertManUIKeeper::RefreshCAEntriesL()

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIKeeper::RefreshCAEntriesL" );

    iFilter->SetOwnerType( ECACertificate );

    iCAEntries.Close();

    CUnifiedCertStore*& store = CertManager();

    iWrapper->ListL( store, &iCAEntries, *iFilter );

    iCALabelEntries.Close();

    LOG_WRITE_FORMAT("CA entries found: %i", iCAEntries.Count());

    for ( TInt ii = 0; ii < iCAEntries.Count(); ii++ )

        {

        switch ( iCAEntries[ii]->CertificateFormat() )

            {

            case EX509Certificate:

                {

                CCertManUICertData* data = new ( ELeave ) CCertManUICertData();

                data->iCAEntry = CCTCertInfo::NewL( *iCAEntries[ii] );

                CleanupStack::PushL( data );

                HBufC* pri = NULL;

                HBufC* sec = NULL;

                CCertificate* cert;

                TRAPD(err, iWrapper->GetCertificateL( CertManager(), *iCAEntries[ii], cert ));

                if (( err == KErrArgument ) || ( err == KErrCorrupt ))

                    {

                    // This indicates that certificate is not according to X509

                    // specification or it is corrupted. Ignore certificate

                    if(data->iCAEntry)

                       {

                       data->iCAEntry->Release();

                       }

                    CleanupStack::PopAndDestroy( data ); // data

                    continue;

                    }

                else

                    {

                    User::LeaveIfError( err );

                    }

                CleanupStack::PushL( cert );

                X509CertNameParser::PrimaryAndSecondaryNameL