/*

* 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 move certificates

*

*/

#include "advsecsettingscertmover_symbian.h"

#include "advsecsettingsstoreuids.h"

#include <unifiedcertstore.h>           // CUnifiedCertStore

#include <unifiedkeystore.h>            // CUnifiedKeyStore

#include <cctcertinfo.h>                // CCTCertInfo

#include <mctwritablecertstore.h>       // MCTWritableCertStore

#include <mctkeystoremanager.h>         // MCTKeyStoreManager

const TInt KMaxBufferLength = 0x3000;   // 12kB, for keys and certificates

_LIT_SECURITY_POLICY_C1( KKeyStoreUsePolicy, ECapabilityReadUserData );

// TODO: replace with proper logging

#ifdef _DEBUG

#define TRACE(x)        RDebug::Printf(x)

#define TRACE1(x, y)    RDebug::Printf((x), (y))

#define TRACE2(x, y, z) RDebug::Printf((x), (y), (z))

#else

#define TRACE(x)

#define TRACE1(x, y)

#define TRACE2(x, y, z)

#endif

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

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

// CAdvSecSettingsCertMover::NewL()

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

//

CAdvSecSettingsCertMover *CAdvSecSettingsCertMover::NewL(RFs &aFs)

{

    TRACE("CAdvSecSettingsCertMover::NewL()");

    CAdvSecSettingsCertMover* self = new( ELeave ) CAdvSecSettingsCertMover(aFs);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

// CAdvSecSettingsCertMover::~CAdvSecSettingsCertMover()

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

//

CAdvSecSettingsCertMover::~CAdvSecSettingsCertMover()

{

    TRACE("CAdvSecSettingsCertMover::~CAdvSecSettingsCertMover()");

    Cancel();

    delete iCertStore;

    iTargetCertStore = NULL;

    delete iCertFilter;

    iCerts.Close();

    delete iKeyStore;

    iSourceKeyStore = NULL;

    iTargetKeyStore = NULL;

    delete iKeyFilter;

    iKeys.Close();

    if (iSavedKeyInfo) {

        iSavedKeyInfo->Release();

    }

    delete iDataBuffer;

    iClientStatus = NULL;

    iCertInfo = NULL;

}

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

// CAdvSecSettingsCertMover::Move()

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

//

void CAdvSecSettingsCertMover::Move(const CCTCertInfo &aCert,

    TInt aSourceCertStoreTokenId, TInt aTargetCertStoreTokenId,

    TRequestStatus &aStatus)

{

    TRACE("CAdvSecSettingsCertMover::Move()");

    aStatus = KRequestPending;

    if (!iClientStatus) {

        iClientStatus = &aStatus;

        iCertInfo = &aCert;

        iSourceCertStoreTokenId = aSourceCertStoreTokenId;

        iTargetCertStoreTokenId = aTargetCertStoreTokenId;

        if (iState <= EIdle) {

            // Start move operation if initializations are complete.

            if (iState == EIdle) {

                TRAPD(err, StartMoveOperationL());

                if (err) {

                    TRACE1("CAdvSecSettingsCertMover::Move(), error %d", err);

                    User::RequestComplete(iClientStatus, err);

                    iClientStatus = NULL;

                }

            }

            // If initializations are not complete yet, then moving

            // starts in RunL() after initializations are completed.

        } else {

            // Possibly initializations have failed.

            TRACE("CAdvSecSettingsCertMover::Move(), RequestComplete KErrGeneral");

            User::RequestComplete(iClientStatus, KErrGeneral);

            iClientStatus = NULL;

        }

    } else {

        TRACE("CAdvSecSettingsCertMover::Move(), RequestComplete KErrInUse");

        TRequestStatus* status = &aStatus;

        User::RequestComplete(status, KErrInUse);

    }

}

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

// CAdvSecSettingsCertMover::DoCancel()

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

//

void CAdvSecSettingsCertMover::DoCancel()

{

    TRACE("CAdvSecSettingsCertMover::DoCancel()");

    switch (iState) {

    case EInitializingCertStore:

        iCertStore->CancelInitialize();

        iState = ENotInitialized;

        break;

    case EInitializingKeyStore:

        iKeyStore->CancelInitialize();

        iState = ENotInitialized;

        break;

    case EMovingKeyListingKeys:

        iKeyStore->CancelList();

        iState = EIdle;

        break;

    case EMovingKeyExportingKeys:

        iSourceKeyStore->CancelExportKey();

        iState = EIdle;

        break;

    case EMovingKeyImportingKeys:

        iTargetKeyStore->CancelImportKey();

        iState = EIdle;

        break;

    case EMovingKeyDeletingOriginal:

        iSourceKeyStore->CancelDeleteKey();

        iState = EIdle;

        break;

    case EMovingCertListingCerts:

        iCertStore->CancelList();

        iState = EIdle;

        break;

    case EMovingCertRetrievingCerts:

        iSourceCertStore->CancelRetrieve();

        iState = EIdle;

        break;

    case EMovingCertAddingCerts:

        iTargetCertStore->CancelAdd();

        iState = EIdle;

        break;

    case EMovingCertDeletingOriginal:

        iSourceCertStore->CancelRemove();

        iState = EIdle;

        break;

    default:

        break;

    }

    if (iClientStatus) {

        TRACE("CAdvSecSettingsCertMover::DoCancel(), RequestComplete KErrCancel");

        User::RequestComplete(iClientStatus, KErrCancel);

        iClientStatus = NULL;

    }

}

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

// CAdvSecSettingsCertMover::RunL()

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

//

void CAdvSecSettingsCertMover::RunL()

{

    TRACE2("CAdvSecSettingsCertMover::RunL(), iState=%d, iStatus.Int()=%d", iState, iStatus.Int());

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

    switch (iState) {

    case EInitializingCertStore:

        iKeyStore->Initialize(iStatus);

        iState = EInitializingKeyStore;

        SetActive();

        break;

    case EInitializingKeyStore:

        iState = EIdle;

        if (iClientStatus) {

            StartMoveOperationL();

        }

        break;

    case EMovingKeyListingKeys:

        ExportFirstKeyL();

        break;

    case EMovingKeyExportingKeys:

        SaveExportedKeyL();

        break;

    case EMovingKeyImportingKeys:

        DeleteOriginalKeyL();

        break;

    case EMovingKeyDeletingOriginal:

        ExportNextKeyL();

        break;

    case EMovingCertListingCerts:

        RetrieveFirstCertL();

        break;

    case EMovingCertRetrievingCerts:

        SaveRetrievedCertL();

        break;

    case EMovingCertAddingCerts:

        DeleteOriginalCertL();

        break;

    case EMovingCertDeletingOriginal:

        RetrieveNextCertL();

        break;

    default:

        ASSERT(EFalse);

        break;

    }

}

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

// CAdvSecSettingsCertMover::RunError()

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

//

TInt CAdvSecSettingsCertMover::RunError(TInt aError)

{

    TRACE1("CAdvSecSettingsCertMover::RunError(), aError=%d", aError);

    if (iClientStatus) {

        TRACE1("CAdvSecSettingsCertMover::RunError(), RequestComplete %d", aError);

        User::RequestComplete(iClientStatus, aError);

        iClientStatus = NULL;

    }

    if (iState < EIdle) {

        iState = EFailed;

    } else {

        iState = EIdle;

    }

    return KErrNone;

}

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

// CAdvSecSettingsCertMover::CAdvSecSettingsCertMover()

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

//

CAdvSecSettingsCertMover::CAdvSecSettingsCertMover(RFs &aFs) :

    CActive(CActive::EPriorityLow), iFs(aFs), iDataPtr(0,0)

{

    CActiveScheduler::Add(this);

}

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

// CAdvSecSettingsCertMover::ConstructL()

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

//

void CAdvSecSettingsCertMover::ConstructL()

{

    TRACE("CAdvSecSettingsCertMover::ConstructL()");

    const TBool KWriteMode = ETrue;

    iCertStore = CUnifiedCertStore::NewL(iFs, KWriteMode);

    iKeyStore = CUnifiedKeyStore::NewL(iFs);

    iDataBuffer = HBufC8::New(KMaxBufferLength);

    iDataPtr.Set(iDataBuffer->Des());

    iCertStore->Initialize(iStatus);

    iState = EInitializingCertStore;

    SetActive();

}

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

// CAdvSecSettingsCertMover::StartMoveOperationL()

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

//

void CAdvSecSettingsCertMover::StartMoveOperationL()

{

    TRACE("CAdvSecSettingsCertMover::StartMoveOperationL()");

    FindSourceAndTargetKeyStoresL();

    FindSourceAndTargetCertStoreL();

    StartMovingKeysL();

}

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

// CAdvSecSettingsCertMover::FindSourceAndTargetKeyStoresL()

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

//

void CAdvSecSettingsCertMover::FindSourceAndTargetKeyStoresL()

{

    TRACE("CAdvSecSettingsCertMover::FindSourceAndTargetKeyStoresL()");

    TInt keyStoreSourceTokenId = CorrespondingKeyStoreTokenId(iSourceCertStoreTokenId);

    TInt keyStoreTargetTokenId = CorrespondingKeyStoreTokenId(iTargetCertStoreTokenId);

    TInt keyStoreSourceIndex = KErrNotFound;

    TInt keyStoreTargetIndex = KErrNotFound;

    TInt count = iKeyStore->KeyStoreManagerCount();

    for (TInt index = 0; index < count; index++) {

        MCTKeyStoreManager& keystoremanager = iKeyStore->KeyStoreManager(index);

        MCTToken& token = keystoremanager.Token();

        TUid tokenTypeUid = token.Handle().iTokenTypeUid;

        if (tokenTypeUid.iUid == keyStoreSourceTokenId) {

            keyStoreSourceIndex = index;

        }

        if (tokenTypeUid.iUid == keyStoreTargetTokenId) {

            keyStoreTargetIndex = index;

        }

    }

    if (keyStoreSourceIndex == KErrNotFound || keyStoreTargetIndex == KErrNotFound) {

        User::Leave(KErrNotFound);

    }

    iSourceKeyStore = &( iKeyStore->KeyStoreManager(keyStoreSourceIndex) );

    iTargetKeyStore = &( iKeyStore->KeyStoreManager(keyStoreTargetIndex) );

}

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

// CAdvSecSettingsCertMover::FindSourceAndTargetCertStoreL()

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

//

void CAdvSecSettingsCertMover::FindSourceAndTargetCertStoreL()

{

    TRACE("CAdvSecSettingsCertMover::FindSourceAndTargetCertStoreL()");

    TInt certStoreSourceIndex = KErrNotFound;

    TInt certStoreTargetIndex = KErrNotFound;

    TInt count = iCertStore->WritableCertStoreCount();

    for (TInt index = 0; index < count; index++) {

        MCTWritableCertStore& writablestore = iCertStore->WritableCertStore(index);

        MCTToken& token = writablestore.Token();

        TUid tokenTypeUid = token.Handle().iTokenTypeUid;

        if (tokenTypeUid.iUid == iSourceCertStoreTokenId) {

            certStoreSourceIndex = index;

        }

        if (tokenTypeUid.iUid == iTargetCertStoreTokenId) {

            certStoreTargetIndex = index;

        }

    }

    if (certStoreSourceIndex == KErrNotFound || certStoreTargetIndex == KErrNotFound) {

        User::Leave(KErrNotFound);

    }

    iSourceCertStore = &( iCertStore->WritableCertStore(certStoreSourceIndex) );

    iTargetCertStore = &( iCertStore->WritableCertStore(certStoreTargetIndex) );

}

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

// CAdvSecSettingsCertMover::CorrespondingKeyStoreTokenId()

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

//

TInt CAdvSecSettingsCertMover::CorrespondingKeyStoreTokenId(TInt aCertStoreTokenId)

{

    TInt keyStoreTokenId = KErrNotFound;

    switch (aCertStoreTokenId) {

    case KAdvSecSettingsFileCertStore:

        keyStoreTokenId = KAdvSecSettingsFileKeyStore;

        break;

    case KAdvSecSettingsDeviceCertStore:

        keyStoreTokenId = KAdvSecSettingsDeviceKeyStore;

        break;

    default:

        ASSERT(EFalse);     // Unsupported cert store token id used

        break;

    }

    return keyStoreTokenId;

}

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

// CAdvSecSettingsCertMover::StartMovingKeysL()

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

//

void CAdvSecSettingsCertMover::StartMovingKeysL()

{

    TRACE("CAdvSecSettingsCertMover::StartMovingKeysL()");

    if (iKeyFilter) {

        delete iKeyFilter;

        iKeyFilter = NULL;

    }

    iKeyFilter = new( ELeave ) TCTKeyAttributeFilter;

    iKeyFilter->iKeyId = iCertInfo->SubjectKeyId();

    iKeyFilter->iPolicyFilter =  TCTKeyAttributeFilter::EAllKeys;

    iKeyStore->List(iKeys, *iKeyFilter, iStatus);

    iState = EMovingKeyListingKeys;

    SetActive();

}

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

// CAdvSecSettingsCertMover::ExportFirstKeyL()

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

//

void CAdvSecSettingsCertMover::ExportFirstKeyL()

{

    TRACE1("CAdvSecSettingsCertMover::ExportFirstKeyL(), iKeys.Count()=%d", iKeys.Count());

    iKeyIndex = 0;

    ExportOneKeyL();

}

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

// CAdvSecSettingsCertMover::ExportOneKeyL()

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

//

void CAdvSecSettingsCertMover::ExportOneKeyL()

{

    TRACE("CAdvSecSettingsCertMover::ExportOneKeyL()");

    if (iKeyIndex < iKeys.Count()) {

        const CCTKeyInfo& keyInfo = *(iKeys[iKeyIndex]);

        iSourceKeyStore->ExportKey(keyInfo.Handle(), iDataBuffer, iStatus);

        iState = EMovingKeyExportingKeys;

        SetActive();

    } else {

        TRACE("CAdvSecSettingsCertMover::ExportOneKeyL(), all done");

        StartMovingCertificatesL();

    }

}

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

// CAdvSecSettingsCertMover::ExportNextKeyL()

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

//

void CAdvSecSettingsCertMover::ExportNextKeyL()

{

    TRACE("CAdvSecSettingsCertMover::ExportNextKeyL()");

    ++iKeyIndex;

    ExportOneKeyL();

}

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

// CAdvSecSettingsCertMover::SaveExportedKeyL()

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

//

void CAdvSecSettingsCertMover::SaveExportedKeyL()

{

    TRACE("CAdvSecSettingsCertMover::SaveExportedKeyL()");

    const CCTKeyInfo& keyInfo = *(iKeys[iKeyIndex]);

    iSourceKeyHandle = keyInfo.Handle();

    // TODO: is this needed? should iSavedKeyInfo be always used?

    // Keys having CCTKeyInfo::ELocal access type cannot be imported.

    // Workaround is to create almost identical copy of CCTKeyInfo without

    // ELocal access type flag. UsePolicy is also updated.

    TInt accessType = keyInfo.AccessType();

    if (accessType & CCTKeyInfo::ELocal) {

        accessType ^= CCTKeyInfo::ELocal;

        HBufC* label = keyInfo.Label().AllocLC();

        if (iSavedKeyInfo) {

            iSavedKeyInfo->Release();

            iSavedKeyInfo = NULL;

        }

        iSavedKeyInfo = CCTKeyInfo::NewL( keyInfo.ID(), keyInfo.Usage(),

            keyInfo.Size(), NULL, label, keyInfo.Token(), keyInfo.HandleID(),

            KKeyStoreUsePolicy, keyInfo.ManagementPolicy(),keyInfo.Algorithm(),

            keyInfo.AccessType(), keyInfo.Native(), keyInfo.StartDate(),

            keyInfo.EndDate() );

        CleanupStack::Pop(label);

        iTargetKeyStore->ImportKey(*iDataBuffer, iSavedKeyInfo, iStatus);

    } else {

        iTargetKeyStore->ImportKey(*iDataBuffer, iKeys[iKeyIndex], iStatus);

    }

    iState = EMovingKeyImportingKeys;

    SetActive();

}

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

// CAdvSecSettingsCertMover::DeleteOriginalKeyL()

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

//

void CAdvSecSettingsCertMover::DeleteOriginalKeyL()

{

    TRACE("CAdvSecSettingsCertMover::DeleteOriginalKeyL()");

    iSourceKeyStore->DeleteKey(iSourceKeyHandle, iStatus);

    iState = EMovingKeyDeletingOriginal;

    SetActive();

}

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

// CAdvSecSettingsCertMover::StartMovingCertificatesL()

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

//

void CAdvSecSettingsCertMover::StartMovingCertificatesL()

{

    TRACE("CAdvSecSettingsCertMover::StartMovingCertificatesL()");

    if (iCertFilter) {

        delete iCertFilter;

        iCertFilter = NULL;

    }

    iCertFilter = CCertAttributeFilter::NewL();

    iCertFilter->SetOwnerType(EUserCertificate);

    iCertFilter->SetSubjectKeyId(iCertInfo->SubjectKeyId());

    iCertStore->List(iCerts, *iCertFilter, iStatus);

    iState = EMovingCertListingCerts;

    SetActive();

}

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

// CAdvSecSettingsCertMover::RetrieveFirstCertL()

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

//

void CAdvSecSettingsCertMover::RetrieveFirstCertL()

{

    TRACE1("CAdvSecSettingsCertMover::RetrieveFirstCertL(), iCerts.Count()=%d", iCerts.Count());

    iCertIndex = 0;

    RetrieveOneCertL();

}

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

// CAdvSecSettingsCertMover::RetrieveOneCertL()

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

//

void CAdvSecSettingsCertMover::RetrieveOneCertL()

{

    TRACE("CAdvSecSettingsCertMover::RetrieveOneCertL()");

    if (iCertIndex < iCerts.Count()) {

        const CCTCertInfo& certInfo = *(iCerts[iCertIndex]);