/*

* 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:   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 <../../inc/cpsecplugins.h>

#include "cpcertmanuisyncwrapper.h"

// CONSTANTS

_LIT_SECURITY_POLICY_C1( KKeyStoreUsePolicy, ECapabilityReadUserData );

// Maximum length of a certificate

const TInt KMaxCertificateLength = 5000;

const TInt KMaxKeyLength = 10000;

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

// CpCertManUISyncWrapper::ListL

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

//

void CpCertManUISyncWrapper::ListL(

    CUnifiedCertStore*& aStore,

    RMPointerArray<CCTCertInfo>* aArray,

    const CCertAttributeFilter& aFilter,

    const TUid aTokenUid )

    {

    RDEBUG("0", 0);

    if ( IsActive() )

        {

        // Wrapper is active. Don't go further

        User::Leave(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();

            User::LeaveIfError( iStatus.Int() );

            break;

            }

        }

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::ListL

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

//

void CpCertManUISyncWrapper::ListL(

    CUnifiedKeyStore*& aStore,

    RMPointerArray<CCTKeyInfo>* aArray,

    const TCTKeyAttributeFilter& aFilter )

    {

    RDEBUG("0", 0);

    if ( IsActive() )

        {

        // Wrapper is active. Don't go further

		User::Leave(KErrGeneral);

        }

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

    iOperation = EOperationKeyList;

    iKeyStore = aStore;

    SetActive();

    iWait.Start();

    User::LeaveIfError( iStatus.Int() );

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::GetCertificateL

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

//

void CpCertManUISyncWrapper::GetCertificateL( CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo,

    CCertificate*& aCert,

    TUid aTokenUid )

    {

    aCert = NULL;

    RDEBUG("0", 0);

    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();

            User::LeaveIfError( iStatus.Int() );

            break;

            }

        }

	switch ( aCertInfo.CertificateFormat() )

		{

		case EX509Certificate:

			{

			aCert = CX509Certificate::NewL( iCertPtr );

			break;

			}

		case EX509CertificateUrl:

			{

			break;

			}

		default:

			{

			break;

			}

		}

    CleanupStack::PopAndDestroy(buf);  

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::DeleteCertL

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

//

void CpCertManUISyncWrapper::DeleteCertL( CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo )

    {

    RDEBUG("0", 0);

    aStore->Remove( aCertInfo, iStatus );

    iOperation = EOperationDelete;

    iStore = aStore;

    SetActive();

    iWait.Start();

    User::LeaveIfError( iStatus.Int() );

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::DeleteCertL

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

//

void CpCertManUISyncWrapper::DeleteCertL( CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo,

    TUid aTokenUid )

    {

    RDEBUG("0", 0);

    TInt count = aStore->WritableCertStoreCount();

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

        {

        MCTWritableCertStore& writablestore = aStore->WritableCertStore( i );

        MCTToken& token = writablestore.Token();

        TUid tokenuid = token.Handle().iTokenTypeUid;

        if ( tokenuid == aTokenUid )

            {

            writablestore.Remove( aCertInfo, iStatus );

            iOperation = EOperationDelete;

            iStore = aStore;

            SetActive();

            iWait.Start();

            User::LeaveIfError( iStatus.Int() );

            break;

            }

        }

    iOperation = EOperationNone;

    }

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

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

// CpCertManUISyncWrapper::CpCertManUISyncWrapper()

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

// might leave.

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

//

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

    {

    CActiveScheduler::Add( this );

    }

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

// CpCertManUISyncWrapper::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CpCertManUISyncWrapper::ConstructL()

    {

    }

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

// CpCertManUISyncWrapper::NewLC

// Two-phased constructor.

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

//

CpCertManUISyncWrapper* CpCertManUISyncWrapper::NewLC()

    {

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

    CleanupStack::PushL( wrap );

    wrap->ConstructL();

    return wrap;

    }

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

// CpCertManUISyncWrapper::NewL

// Two-phased constructor.

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

//

CpCertManUISyncWrapper* CpCertManUISyncWrapper::NewL()

    {

    CpCertManUISyncWrapper* wrap = CpCertManUISyncWrapper::NewLC();

    CleanupStack::Pop(wrap);

    return wrap;

    }

// Destructor

CpCertManUISyncWrapper::~CpCertManUISyncWrapper()

    {

    }

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

// CpCertManUISyncWrapper::RunL

// If no errors happened, stop. Show an error note if needed.

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

//

void CpCertManUISyncWrapper::RunL()

    {

    RDEBUG("0", 0);

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    }

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

// CpCertManUISyncWrapper::DoCancel

// Cancels the ongoing operation if possible.

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

//

void CpCertManUISyncWrapper::DoCancel()

    {

    RDEBUG("iOperation", iOperation);

    switch ( iOperation )

        {

        case EOperationInit:

            {

            iStore->CancelInitialize();

            break;

            }

        case EOperationList:

            {

            iStore->CancelList();

            break;

            }

        case EGetCertificate:

            {

            iStore->CancelRetrieve();

            break;

            }

        case EAddCertificate:

            {

            iStore->Cancel();

            break;

            }

        case ERetriveURLCertificate:

            {

            iStore->CancelRetrieve();

            break;

            }

        case EOperationDelete:

            {

            iStore->CancelRemove();

            break;

            }

        case EOperationGetApps:

            {

            iStore->CancelApplications();

            break;

            }

        case EOperationValidateX509Root:

            {

            iChain->CancelValidate();

            break;

            }

        case EShowErrorNote:

            {

            break;

            }

        case EOperationInitKeyStore:

            {

            iKeyStore->CancelInitialize();

            break;

            }

        case EOperationKeyList:

            {

            iKeyStore->CancelList();

            break;

            }

        case EOperationExportKey:

            {

            iKeyStore->CancelExportKey();

            break;

            }

        case EOperationImportKey:

            {

            iKeyStore->CancelImportKey();

            break;

            }

        case EOperationDeleteKey:

            {

            iKeyStore->CancelDeleteKey();

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CpCertManUISyncWrapper::InitStoreL

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

//

void CpCertManUISyncWrapper::InitStoreL( CUnifiedCertStore*& aStore )

    {

    aStore->Initialize( iStatus );

    iOperation = EOperationInit;

    iStore = aStore;

    SetActive();

    iWait.Start();

    User::LeaveIfError( iStatus.Int() );

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::InitStoreL

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

//

void CpCertManUISyncWrapper::InitStoreL( CUnifiedKeyStore*& aStore  )

    {

    aStore->Initialize( iStatus );

    iOperation = EOperationInitKeyStore;

    iKeyStore = aStore;

    SetActive();

    iWait.Start();

    User::LeaveIfError( iStatus.Int() );

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::ListL

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

//

void CpCertManUISyncWrapper::ListL(

    CUnifiedCertStore*& aStore,

    RMPointerArray<CCTCertInfo>* aArray,

    const CCertAttributeFilter& aFilter )

    {

    if ( IsActive() )

        {

        // Wrapper is active. Don't go further

		User::Leave(KErrGeneral);

        }

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

    iOperation = EOperationList;

    iStore = aStore;

    SetActive();

    iWait.Start();

    User::LeaveIfError( iStatus.Int() );

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::ListL

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

//

void CpCertManUISyncWrapper::ListL(

    CUnifiedKeyStore*& aStore,

    RMPointerArray<CCTKeyInfo>* aArray,

    const TCTKeyAttributeFilter& aFilter,

    const TUid aTokenUid )

    {

    if ( IsActive() )

        {

        // Wrapper is active. Don't go further

		User::Leave(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();

            User::LeaveIfError( iStatus.Int() );

            break;

            }

        }

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::GetCertificateL

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

//

void CpCertManUISyncWrapper::GetCertificateL(

    CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo,

    CCertificate*& aCert )

    {    

    aCert = NULL;

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

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

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

    iOperation = EGetCertificate;

    iStore = aStore;

    SetActive();

    iWait.Start();

    User::LeaveIfError( iStatus.Int() );

	switch ( aCertInfo.CertificateFormat() )

		{

		case EX509Certificate:

			{

			aCert = CX509Certificate::NewL( iCertPtr );

			break;

			}

		case EX509CertificateUrl:

			{

			break;

			}

		default:

			{

			break;

			}

		}

    CleanupStack::PopAndDestroy(buf); 

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::ValidateX509RootCertificateL

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

//

void CpCertManUISyncWrapper::ValidateX509RootCertificateL(

    CPKIXValidationResult*& aValidationResult,

    const TTime& aValidationTime, CPKIXCertChain*& aChain )

    {

    aChain->ValidateL( *aValidationResult, aValidationTime, iStatus );

    iOperation = EOperationValidateX509Root;

    iChain = aChain;

    SetActive();

    iWait.Start();

    iOperation = EOperationNone;

    User::LeaveIfError(iStatus.Int());

    }

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

// CpCertManUISyncWrapper::GetUrlCertificateL

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

//

void CpCertManUISyncWrapper::GetUrlCertificateL(

    CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo,

    TDes8& aUrl )

    {

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

    iOperation = ERetriveURLCertificate;

    iStore = aStore;

    SetActive();

    iWait.Start();

    User::LeaveIfError( iStatus.Int() );

    iOperation = EOperationNone;

    }

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

// CpCertManUISyncWrapper::GetApplicationsL

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

//

void CpCertManUISyncWrapper::GetApplicationsL( CUnifiedCertStore*& aStore,

    const CCTCertInfo& aCertInfo, RArray<TUid>& aApps )

    {

    aStore->Applications( aCertInfo, aApps, iStatus );