/*

* Copyright (c) 2003-2007 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:   Implements a synchronous wrapper for easier use of Symbian's

*                Security Frameworks's API's.

*

*/

// INCLUDE FILES

#include <unifiedcertstore.h>

#include <unifiedkeystore.h>

#include <mctwritablecertstore.h>

#include <x509cert.h>

#include <pkixcertchain.h>

#include "CertmanuiSyncWrapper.h"

#include "CertmanuiCommon.h"

#include "CertManUILogger.h"

// CONSTANTS

_LIT_SECURITY_POLICY_C1( KKeyStoreUsePolicy, ECapabilityReadUserData );

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

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

// CCertManUISyncWrapper::CCertManUISyncWrapper()

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCertManUISyncWrapper::CCertManUISyncWrapper() : CActive( EPriorityStandard ), iCertPtr(0,0)

    {

    CActiveScheduler::Add( this );

    }

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

// CCertManUISyncWrapper::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CCertManUISyncWrapper::ConstructL()

    {

    }

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

// CCertManUISyncWrapper::NewLC

// Two-phased constructor.

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

//

CCertManUISyncWrapper* CCertManUISyncWrapper::NewLC()

    {

    CCertManUISyncWrapper* wrap = new ( ELeave ) CCertManUISyncWrapper();

    CleanupStack::PushL( wrap );

    wrap->ConstructL();

    return wrap;

    }

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

// CCertManUISyncWrapper::NewL

// Two-phased constructor.

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

//

CCertManUISyncWrapper* CCertManUISyncWrapper::NewL()

    {

    CCertManUISyncWrapper* wrap = CCertManUISyncWrapper::NewLC();

    CleanupStack::Pop();

    return wrap;

    }

// Destructor

CCertManUISyncWrapper::~CCertManUISyncWrapper()

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::~CCertManUISyncWrapper()" );

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::~CCertManUISyncWrapper()" );

    }

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

// CCertManUISyncWrapper::DoCancel

// Cancels the ongoing operation if possible.

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

//

void CCertManUISyncWrapper::DoCancel()

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::DoCancel" );

    switch ( iOperation )

        {

        case EOperationInit:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationInit" );

            iStore->CancelInitialize();

            break;

            }

        case EOperationList:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationList" );

            iStore->CancelList();

            break;

            }

        case EGetCertificate:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EGetCertificate" );

            iStore->CancelRetrieve();

            break;

            }

        case EAddCertificate:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EAddCertificate" );

            iStore->Cancel();

            break;

            }

        case ERetriveURLCertificate:

            {

            LOG_WRITE(" CCertManUISyncWrapper::DoCancel ERetriveURLCertificate ");

            iStore->CancelRetrieve();

            break;

            }

        case EOperationDelete:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationDelete" );

            iStore->CancelRemove();

            break;

            }

        case EOperationGetApps:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationGetApps" );

            iStore->CancelApplications();

            break;

            }

        case EOperationValidateX509Root:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationValidateX509Root" );

            iChain->CancelValidate();

            break;

            }

        case EShowErrorNote:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EShowErrorNote" );

            break;

            }

        case EOperationInitKeyStore:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationInitKeyStore" );

            iKeyStore->CancelInitialize();

            break;

            }

        case EOperationKeyList:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationKeyList" );

            iKeyStore->CancelList();

            break;

            }

        case EOperationGetInterface:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationGetInterface" );

            iToken->CancelGetInterface();

            break;

            }

        case EOperationExportKey:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationExportKey" );

            iKeyStore->CancelExportKey();

            break;

            }

        case EOperationImportKey:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationImportKey" );

            iKeyStore->CancelImportKey();

            break;

            }

        case EOperationDeleteKey:

            {

            LOG_WRITE( "CCertManUISyncWrapper::DoCancel EOperationDeleteKey" );

            iKeyStore->CancelDeleteKey();

            break;

            }

        default:

            {

            break;

            }

        }

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::DoCancel" );

    }

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

// CCertManUISyncWrapper::InitStoreL

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

//

TInt CCertManUISyncWrapper::InitStoreL( CUnifiedCertStore*& aStore )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::InitStoreL Certstore" );

    aStore->Initialize( iStatus );

    iOperation = EOperationInit;

    iStore = aStore;

    SetActive();

    iWait.Start();

    HandleErrorL();

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::InitStoreL Certstore" );

    return iStatus.Int();

    }

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

// CCertManUISyncWrapper::InitStoreL

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

//

TInt CCertManUISyncWrapper::InitStoreL( CUnifiedKeyStore*& aStore  )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::InitStoreL Keystore" );

    aStore->Initialize( iStatus );

    iOperation = EOperationInitKeyStore;

    iKeyStore = aStore;

    SetActive();

    iWait.Start();

    HandleErrorL();

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::InitStoreL Keystore" );

    return iStatus.Int();

    }

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

// CCertManUISyncWrapper::ListL

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

//

TInt CCertManUISyncWrapper::ListL(

    CUnifiedCertStore*& aStore,

    RMPointerArray<CCTCertInfo>* aArray,

    const CCertAttributeFilter& aFilter )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::ListL 1" );

    if ( IsActive() )

        {

        // Wrapper is active. Don't go further

        return KErrGeneral;

        }

    aStore->List( *aArray, aFilter, iStatus );

    iOperation = EOperationList;

    iStore = aStore;

    SetActive();

    iWait.Start();

    HandleErrorL();

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::ListL 1" );

    return iStatus.Int();

    }

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

// CCertManUISyncWrapper::ListL

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

//

TInt CCertManUISyncWrapper::ListL(

    CUnifiedCertStore*& aStore,

    RMPointerArray<CCTCertInfo>* aArray,

    const CCertAttributeFilter& aFilter,

    const TUid aTokenUid )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::ListL 2" );

    TInt status( KErrNone );

    if ( IsActive() )

        {

        // Wrapper is active. Don't go further

        return KErrGeneral;

        }

    TInt count = aStore->CertStoreCount();

    for ( TInt ii = 0; ii < count; ii++ )

        {

        MCTCertStore& certstore = aStore->CertStore( ii );

        MCTToken& token = certstore.Token();

        TUid tokenuid = token.Handle().iTokenTypeUid;

        if ( tokenuid == aTokenUid )

            {

            certstore.List( *aArray, aFilter, iStatus );

            iOperation = EOperationList;

            iStore = aStore;

            SetActive();

            iWait.Start();

            HandleErrorL();

            status = iStatus.Int();

            break;

            }

        }

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::ListL 2" );

    return status;

    }

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

// CCertManUISyncWrapper::ListL

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

//

TInt CCertManUISyncWrapper::ListL(

    CUnifiedKeyStore*& aStore,

    RMPointerArray<CCTKeyInfo>* aArray,

    const TCTKeyAttributeFilter& aFilter )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::ListL 3" );

    if ( IsActive() )

        {

        // Wrapper is active. Don't go further

        return KErrGeneral;

        }

    aStore->List( *aArray, aFilter, iStatus );

    iOperation = EOperationKeyList;

    iKeyStore = aStore;

    SetActive();

    iWait.Start();

    HandleErrorL();

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::ListL 3" );

    return iStatus.Int();

    }

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

// CCertManUISyncWrapper::ListL

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

//

TInt CCertManUISyncWrapper::ListL(

    CUnifiedKeyStore*& aStore,

    RMPointerArray<CCTKeyInfo>* aArray,

    const TCTKeyAttributeFilter& aFilter,

    const TUid aTokenUid )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::ListL 4" );

    TInt status( KErrNone );

    if ( IsActive() )

        {

        // Wrapper is active. Don't go further

        return KErrGeneral;

        }

    TInt count = aStore->KeyStoreManagerCount();

    for ( TInt ii = 0; ii < count; ii++ )

        {

        MCTKeyStoreManager& keystoremanager = aStore->KeyStoreManager( ii );

        MCTToken& token = keystoremanager.Token();

        TUid tokenuid = token.Handle().iTokenTypeUid;

        if ( tokenuid == aTokenUid )

            {

            keystoremanager.List( *aArray, aFilter, iStatus );

            iOperation = EOperationKeyList;

            iKeyStore = aStore;

            SetActive();

            iWait.Start();

            HandleErrorL();

            status = iStatus.Int();

            break;

            }

        }

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::ListL 4" );

    return status;

    }

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

// CCertManUISyncWrapper::GetCertificateL

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

//

TInt CCertManUISyncWrapper::GetCertificateL(

    CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo,

    CCertificate*& aCert )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::GetCertificateL 1" );

    aCert = NULL;

    HBufC8* buf = HBufC8::NewLC( KMaxCertificateLength );

    iCertPtr.Set( buf->Des() );

    aStore->Retrieve( aCertInfo, iCertPtr, iStatus);

    iOperation = EGetCertificate;

    iStore = aStore;

    SetActive();

    iWait.Start();

    if ( iStatus.Int() == KErrNone )

        {

        switch ( aCertInfo.CertificateFormat() )

            {

            case EX509Certificate:

                {

                aCert = CX509Certificate::NewL( iCertPtr );

                break;

                }

            case EX509CertificateUrl:

                {

#ifdef  _CERTMANUI_LOG_

                TPtrC8 dump = buf->Des();

                LOG_HEXDUMP(dump);

#endif

                break;

                }

            default:

                {

                break;

                }

            }

        }

    CleanupStack::PopAndDestroy();  // buf

    HandleErrorL();

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::GetCertificateL 1" );

    return iStatus.Int();

    }

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

// CCertManUISyncWrapper::GetUrlCertificateL

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

//

TInt CCertManUISyncWrapper::GetUrlCertificateL(

    CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo,

    TDes8& aUrl )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::GetUrlCertificateL" );

    aStore->Retrieve( aCertInfo, aUrl, iStatus);

    iOperation = ERetriveURLCertificate;

    iStore = aStore;

    SetActive();

    iWait.Start();

    HandleErrorL();

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::GetUrlCertificateL" );

    return iStatus.Int();

    }

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

// CCertManUISyncWrapper::GetCertificateL

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

//

TInt CCertManUISyncWrapper::GetCertificateL( CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo,

    CCertificate*& aCert,

    TUid aTokenUid )

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::GetCertificateL 2 " );

    aCert = NULL;

    TInt status( KErrNone );

    HBufC8* buf = HBufC8::NewLC( KMaxCertificateLength );

    iCertPtr.Set( buf->Des() );

    TInt count = aStore->CertStoreCount();

    for (TInt i = 0; i < count; i++)

        {

        MCTCertStore& certstore = aStore->CertStore( i );

        MCTToken& token = certstore.Token();

        TUid tokenuid = token.Handle().iTokenTypeUid;

        if ( tokenuid == aTokenUid )

            {

            certstore.Retrieve( aCertInfo, iCertPtr, iStatus );

            iOperation = EGetCertificate;

            iStore = aStore;

            SetActive();

            iWait.Start();

            HandleErrorL();

            status = iStatus.Int();

            break;

            }

        }

    if ( status == KErrNone )

        {

        switch ( aCertInfo.CertificateFormat() )

            {

            case EX509Certificate:

                {

                aCert = CX509Certificate::NewL( iCertPtr );

                break;

                }

            case EX509CertificateUrl:

                {

#ifdef  _CERTMANUI_LOG_

                TPtrC8 dump = buf->Des();

                LOG_HEXDUMP( dump );

#endif

                break;

                }

            default:

                {

                break;

                }

            }

        }

    CleanupStack::PopAndDestroy();  // buf

    iOperation = EOperationNone;

    CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::GetCertificateL 2" );

    return status;