diff -r 000000000000 -r 164170e6151a pkiutilities/CertmanUi/SRC/CertmanuiSyncWrapper.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pkiutilities/CertmanUi/SRC/CertmanuiSyncWrapper.cpp Tue Jan 26 15:20:08 2010 +0200 @@ -0,0 +1,1012 @@ +/* +* 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 +#include +#include +#include +#include +#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* 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* 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* 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* 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; + } + + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::DeleteCertL +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::DeleteCertL( CUnifiedCertStore*& aStore, + const CCTCertInfo& aCertInfo ) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::DeleteCertL 1" ); + + aStore->Remove( aCertInfo, iStatus ); + iOperation = EOperationDelete; + iStore = aStore; + SetActive(); + iWait.Start(); + HandleErrorL(); + iOperation = EOperationNone; + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::DeleteCertL 1" ); + return iStatus.Int(); + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::DeleteCertL +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::DeleteCertL( CUnifiedCertStore*& aStore, + const CCTCertInfo& aCertInfo, + TUid aTokenUid ) + { + TInt status( KErrNone ); + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::DeleteCertL 2" ); + + 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(); + HandleErrorL(); + status = iStatus.Int(); + break; + } + } + + iOperation = EOperationNone; + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::DeleteCertL 2" ); + return status; + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::GetApplicationsL +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::GetApplicationsL( CUnifiedCertStore*& aStore, + const CCTCertInfo& aCertInfo, RArray& aApps ) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::GetApplicationsL" ); + + aStore->Applications( aCertInfo, aApps, iStatus ); + iOperation = EOperationGetApps; + iStore = aStore; + SetActive(); + iWait.Start(); + HandleErrorL(); + iOperation = EOperationNone; + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::GetApplicationsL" ); + return iStatus.Int(); + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::IsApplicableL +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::IsApplicableL( CUnifiedCertStore*& aStore, + const CCTCertInfo& aCertInfo, TUid aApplication, + TBool& aIsApplicable ) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::IsApplicableL" ); + + aStore->IsApplicable( aCertInfo, aApplication, aIsApplicable, iStatus ); + iOperation = EOperationIsApplicable; + iStore = aStore; + SetActive(); + iWait.Start(); + HandleErrorL(); + iOperation = EOperationNone; + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::IsApplicableL" ); + return iStatus.Int(); + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::IsTrustedL +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::IsTrustedL( CUnifiedCertStore*& aStore, + const CCTCertInfo& aCertInfo, TBool& aTrusted ) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::IsTrustedL" ); + + aStore->Trusted( aCertInfo, aTrusted, iStatus ); + iOperation = EOperationIsTrusted; + iStore = aStore; + SetActive(); + iWait.Start(); + HandleErrorL(); + iOperation = EOperationNone; + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::IsTrustedL" ); + return iStatus.Int(); + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::SetApplicabilityL +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::SetApplicabilityL( CUnifiedCertStore*& aStore, + const CCTCertInfo& aCertInfo, + RArray& aApplications ) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::SetApplicabilityL" ); + + aStore->SetApplicability( aCertInfo, aApplications, iStatus ); + iOperation = EOperationSetApplicability; + iStore = aStore; + SetActive(); + iWait.Start(); + + if ( !(iStatus.Int()) ) + { + aStore->SetTrust( aCertInfo, ETrue, iStatus ); + iOperation = EOperationSetToTrusted; + SetActive(); + iWait.Start(); + } + HandleErrorL(); + iOperation = EOperationNone; + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::SetApplicabilityL" ); + return iStatus.Int(); + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::MoveKeyL +// ----------------------------------------------------------------------------- +// +void CCertManUISyncWrapper::MoveKeyL( + CUnifiedKeyStore*& aStore, + const TCTKeyAttributeFilter& aFilter, + const TUid aSourceTokenId, + const TUid aTargetTokenId ) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::MoveKeyL" ); + + TInt sourceIndex(-1); + TInt targetIndex(-1); + + // Find the index of key stores + 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 == aSourceTokenId ) + { + sourceIndex = ii; + } + + if ( tokenuid == aTargetTokenId ) + { + targetIndex = ii; + } + } + + if (( sourceIndex == -1 ) || ( targetIndex == -1 )) + { + // Key store(s) doesn't exist + User::Leave( KErrNotFound ); + } + + RMPointerArray keyEntries; + + MCTKeyStoreManager& sourcekeystore = + aStore->KeyStoreManager( sourceIndex ); + + MCTKeyStoreManager& targetkeystore = + aStore->KeyStoreManager( targetIndex ); + + + ListL( aStore, &keyEntries, aFilter, aSourceTokenId ); + + // Go through all matching keys and move them to + // target store + for ( TInt ii = 0; ii < keyEntries.Count(); ii++ ) + { + HBufC8* keyData = HBufC8::NewLC( KMaxKeyLength ); + + // Retrieve key from source key store + sourcekeystore.ExportKey( (*keyEntries[ii]).Handle(), keyData, iStatus ); + iOperation = EOperationExportKey; + SetActive(); + iWait.Start(); + User::LeaveIfError( iStatus.Int() ); + + TCTTokenObjectHandle sourceKeyHandle = (*keyEntries[ii]).Handle(); + + // Import key to target key store + + // If key info access type indicates that key is local, then importing is + // not possible. The following is the workarround. Almost identical + // copy of keyinfo is created without CCTKeyInfo::ELocal access type flag. + // UsePolicy is also updated + TInt accessType = (*keyEntries[ii]).AccessType(); + if ( accessType & CCTKeyInfo::ELocal ) + { + // CCTKeyInfo::ELocal is set in key info + HBufC* label = (*keyEntries[ii]).Label().AllocLC(); + + // The following XOR operation will clear local bit if it is on. + accessType ^= CCTKeyInfo::ELocal; + + CCTKeyInfo* keyInfo = CCTKeyInfo::NewL( (*keyEntries[ii]).ID(), + (*keyEntries[ii]).Usage(), + (*keyEntries[ii]).Size(), + NULL, + label, + (*keyEntries[ii]).Token(), + (*keyEntries[ii]).HandleID(), + KKeyStoreUsePolicy, + (*keyEntries[ii]).ManagementPolicy(), + (*keyEntries[ii]).Algorithm(), + accessType, + (*keyEntries[ii]).Native(), + (*keyEntries[ii]).StartDate(), + (*keyEntries[ii]).EndDate() ); + + CleanupStack::Pop(label); + targetkeystore.ImportKey( *keyData, keyInfo, iStatus ); + } + else + { + targetkeystore.ImportKey( *keyData, keyEntries[ii], iStatus ); + } + + iOperation = EOperationImportKey; + SetActive(); + iWait.Start(); + User::LeaveIfError( iStatus.Int() ); + + // Delete key from source key store + sourcekeystore.DeleteKey( sourceKeyHandle, iStatus ); + iOperation = EOperationDeleteKey; + SetActive(); + iWait.Start(); + User::LeaveIfError( iStatus.Int() ); + + CleanupStack::PopAndDestroy(); // keyData + } + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::MoveKeyL" ); + } + + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::MoveCertL +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::MoveCertL( + CUnifiedCertStore*& aStore, + const CCTCertInfo& aCertInfo, + const TUid aSourceTokenId, + const TUid aTargetTokenId ) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::MoveCertL" ); + + TInt sourceIndex(-1); + TInt targetIndex(-1); + TInt certCount (0); + + // Find the index of certificate stores + TInt count = aStore->WritableCertStoreCount(); + for (TInt ii = 0; ii < count; ii++) + { + MCTWritableCertStore& writablestore = aStore->WritableCertStore( ii ); + MCTToken& token = writablestore.Token(); + TUid tokenuid = token.Handle().iTokenTypeUid; + + if ( tokenuid == aSourceTokenId ) + { + sourceIndex = ii; + } + + if ( tokenuid == aTargetTokenId ) + { + targetIndex = ii; + } + } + + if (( sourceIndex == -1 ) || ( targetIndex == -1 )) + { + // Certificate store(s) doesn't exist + User::Leave( KErrNotFound ); + } + + + MCTWritableCertStore& sourcewritablestore = + aStore->WritableCertStore( sourceIndex ); + + // All of the certificates that are associated with same + // private key will be moved to target certificate store. + CCertAttributeFilter* filter = CCertAttributeFilter::NewL(); + filter->SetOwnerType( EUserCertificate ); + filter->SetSubjectKeyId( aCertInfo.SubjectKeyId() ); + RMPointerArray certEntries; + + // List certificates from source certificate store + ListL( aStore, &certEntries, *filter, aSourceTokenId ); + + delete filter; + + for ( TInt ii = 0; ii < certEntries.Count(); ii++ ) + { + // Retrieve certificate from source certificate store + HBufC8* buf = HBufC8::NewLC( KMaxCertificateLength ); + iCertPtr.Set( buf->Des() ); + sourcewritablestore.Retrieve( *certEntries[ii], iCertPtr, iStatus ); + iOperation = EGetCertificate; + SetActive(); + iWait.Start(); + User::LeaveIfError( iStatus.Int() ); + + // Add certificate to target certificate store + MCTWritableCertStore& targetwritablestore = + aStore->WritableCertStore( targetIndex ); + + targetwritablestore.Add( (*certEntries[ii]).Label(), EX509Certificate, + EUserCertificate, &((*certEntries[ii]).SubjectKeyId()), + &((*certEntries[ii]).IssuerKeyId()), *buf, iStatus ); + + iOperation = EAddCertificate; + SetActive(); + iWait.Start(); + User::LeaveIfError( iStatus.Int() ); + + // Delete certificate from source certificate store + sourcewritablestore.Remove( *certEntries[ii], iStatus ); + iOperation = EOperationDelete; + iStore = aStore; + SetActive(); + iWait.Start(); + HandleErrorL(); + iOperation = EOperationNone; + User::LeaveIfError( iStatus.Int() ); + certCount++; + + CleanupStack::PopAndDestroy(); // buf + } + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::MoveCertL" ); + return certCount; + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::ValidateX509RootCertificateL +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::ValidateX509RootCertificateL( + CPKIXValidationResult*& aValidationResult, + const TTime& aValidationTime, CPKIXCertChain* aChain ) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::ValidateX509RootCertificateL" ); + + aChain->ValidateL( *aValidationResult, aValidationTime, iStatus ); + iOperation = EOperationValidateX509Root; + iChain = aChain; + SetActive(); + iWait.Start(); + iOperation = EOperationNone; + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::ValidateX509RootCertificateL" ); + return iStatus.Int(); + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::GetInterface +// ----------------------------------------------------------------------------- +// +TInt CCertManUISyncWrapper::GetInterface( + TUid aRequiredInterface, MCTToken& aToken, + MCTTokenInterface*& aReturnedInterface) + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::GetInterface" ); + + iToken = &aToken; + aToken.GetInterface( aRequiredInterface, aReturnedInterface, iStatus ); + iOperation = EOperationGetInterface; + SetActive(); + iWait.Start(); + iOperation = EOperationNone; + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::GetInterface" ); + return iStatus.Int(); + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::RunL +// If no errors happened, stop. Show an error note if needed. +// ----------------------------------------------------------------------------- +// + +void CCertManUISyncWrapper::RunL() + { + CERTMANUILOGGER_ENTERFN("CCertManUISyncWrapper::RunL"); + + if ( iWait.IsStarted() ) + { + iWait.AsyncStop(); + } + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::RunL" ); + } + +// ----------------------------------------------------------------------------- +// CCertManUISyncWrapper::HandleErrorL +// Shows an error note according to status of operation, +// ----------------------------------------------------------------------------- +// +void CCertManUISyncWrapper::HandleErrorL() + { + CERTMANUILOGGER_ENTERFN( "CCertManUISyncWrapper::HandleErrorL" ); + + TInt status = iStatus.Int(); + switch ( status ) + { + case KErrNone: + { + LOG_WRITE( "No error" ); + break; + } + case KErrCancel: + { + LOG_WRITE( "HandleErrorL : KErrCancel" ); + // Up to caller decide if note is needed. No error note shown. + break; + } + case KErrNoMemory: + case KErrBadHandle: + case KErrAlreadyExists: + case KErrNotSupported: + case EShowErrorNote: + { + LOG_WRITE_FORMAT( "HandleErrorL LEAVE : error code %i", status ); + User::Leave( iStatus.Int() ); + break; + } + default: + { + LOG_WRITE_FORMAT( "HandleErrorL LEAVE (default) : error code %i", status ); + break; + } + } + + CERTMANUILOGGER_LEAVEFN( "CCertManUISyncWrapper::HandleErrorL" ); + } + + +// End of File +