/*
* Copyright (c) 2008 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: A task que to serialize the key operations among session.
*
*/
#include "keyoperationqueue.h"
#include "pkiserviceclientservercommon.h"
#include "keyoperationprovider.h"
#include "PKIMapper.h"
#include "pkisession.h"
#include "pkiserviceassert.h"
#include "log_r6.h"
CKeyOperationQueue::TKeyOperation::TKeyOperation(CPKISession& aOwner,
const RMessage2& aMessage,
TInt aUsedKeyStore,
TPkiServiceStoreType aUsedCertStore)
:iOwner(aOwner), iMessage(aMessage), iUsedKeyStore(aUsedKeyStore), iUsedCertStore(aUsedCertStore)
{
}
CKeyOperationQueue* CKeyOperationQueue::NewL(CPKIMapper& aMapper)
{
CKeyOperationQueue* self = new (ELeave) CKeyOperationQueue(aMapper);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
CKeyOperationQueue::CKeyOperationQueue(CPKIMapper& aMapper)
:iMapper(aMapper)
{
}
void CKeyOperationQueue::ConstructL()
{
iKeyOperationProvider = CKeyPairOperationProvider::NewL(*this);
}
CKeyOperationQueue::~CKeyOperationQueue()
{
PKISERVICE_ASSERT(iOperationQue.Count() == 0);
PKISERVICE_ASSERT(iCurrentOperation == NULL);
delete iKeyOperationProvider;
iOperationQue.Close();
}
void CKeyOperationQueue::AddOperationL(CPKISession& aOwner,
const RMessage2& aMessage,
TInt aUsedKeyStore,
TPkiServiceStoreType aUsedCertStore)
{
TKeyOperation* operation = new (ELeave) TKeyOperation(aOwner, aMessage,
aUsedKeyStore, aUsedCertStore);
CleanupDeletePushL(operation);
User::LeaveIfError(iOperationQue.Append(operation));
CleanupStack::Pop(operation);
if (iCurrentOperation == NULL)
{
PKISERVICE_ASSERT(iOperationQue.Count() == 1);
//No operations in progress.
//Handle the new one.
StartNextOperation();
}
}
void CKeyOperationQueue::StartNextOperation()
{
PKISERVICE_ASSERT(iOperationQue.Count() > 0);
PKISERVICE_ASSERT(iCurrentOperation == NULL);
iCurrentOperation = iOperationQue[0];
iOperationQue.Remove(0);
TRAPD(err, ServiceL(*iCurrentOperation));
if (err != KErrNone)
{
iCurrentOperation->iMessage.Complete(err);
iCurrentOperation = NULL;
if (iOperationQue.Count() > 0)
{
StartNextOperation();
}
}
}
void CKeyOperationQueue::ServiceL(TKeyOperation& aOperation)
{
switch(aOperation.iMessage.Function())
{
case PkiService::EInitialize:
iKeyOperationProvider->Initialize();
break;
case PkiService::EKeyCount:
{
TPKIKeyIdentifier keyId;
keyId.Zero();
iKeyOperationProvider->GetKeyPairList(keyId, aOperation.iUsedKeyStore);
}
break;
case PkiService::EGetKeyDetails:
{
TPKIKeyIdentifier keyId;
aOperation.iMessage.ReadL(1, keyId);
iKeyOperationProvider->GetKeyPairList(keyId, aOperation.iUsedKeyStore);
}
break;
case PkiService::EDecrypt:
{
TPKIKeyIdentifier keyId;
aOperation.iMessage.ReadL(0, keyId);
if (keyId.Length() > 0)
{
HBufC8* encryptedData = HBufC8::NewLC(aOperation.iMessage.GetDesLength(1));
TPtr8 encryptedDataPtr = encryptedData->Des();
aOperation.iMessage.ReadL(1, encryptedDataPtr);
CleanupStack::Pop(encryptedData);
//Transfer the ownership of the encryptedData
TInt outputBufferMaxLength = aOperation.iMessage.GetDesMaxLength(2);
User::LeaveIfError(outputBufferMaxLength);
iKeyOperationProvider->Decrypt(keyId, aOperation.iUsedKeyStore, encryptedData,
outputBufferMaxLength);
}
else
{
CompleteCurrentOperation(KPKIErrNotFound);
}
}
break;
case PkiService::ESignWithKeyId:
{
TPKIKeyIdentifier keyId;
aOperation.iMessage.ReadL(0, keyId);
if (keyId.Length() > 0)
{
HBufC8* dataIn = HBufC8::NewLC(aOperation.iMessage.GetDesLength(1));
TPtr8 dataInPtr = dataIn->Des();
aOperation.iMessage.ReadL(1, dataInPtr);
//transfers the dataIn buffer ownership
CleanupStack::Pop(dataIn);
iKeyOperationProvider->Sign(keyId, aOperation.iUsedKeyStore, dataIn);
}
else
{
CompleteCurrentOperation(KPKIErrNotFound);
}
}
break;
case PkiService::ESignWithCert:
{
TSecurityObjectDescriptor *securityObjectDesc = new (ELeave) TSecurityObjectDescriptor;
CleanupDeletePushL(securityObjectDesc);
TPckg<TSecurityObjectDescriptor> securityObjectDescPacketBuffer(*securityObjectDesc);
aOperation.iMessage.ReadL(0, securityObjectDescPacketBuffer);
TPKIKeyIdentifier keyId;
iMapper.GetCertificateKeyIdL(*securityObjectDesc, keyId,
aOperation.iUsedCertStore);
CleanupStack::PopAndDestroy(securityObjectDesc);
if (keyId.Length() > 0)
{
HBufC8* dataIn = HBufC8::NewLC(aOperation.iMessage.GetDesLength(1));
TPtr8 dataInPtr = dataIn->Des();
aOperation.iMessage.ReadL(1, dataInPtr);
//transfers the dataIn buffer ownership
CleanupStack::Pop(dataIn);
iKeyOperationProvider->Sign(keyId, aOperation.iUsedKeyStore, dataIn);
}
else
{
CompleteCurrentOperation(KPKIErrNotFound);
}
}
break;
case PkiService::EReadPublicKey:
{
TPKIKeyIdentifier keyId;
aOperation.iMessage.ReadL(0, keyId);
if (keyId.Length() > 0)
{
iKeyOperationProvider->GetPublicKey(keyId, aOperation.iUsedKeyStore);
}
else
{
CompleteCurrentOperation(KPKIErrNotFound);
}
}
break;
case PkiService::ELogon:
iKeyOperationProvider->Logon();
break;
case PkiService::ELogoff:
iKeyOperationProvider->Logoff();
break;
case PkiService::EChangePassword:
iKeyOperationProvider->ChangePassword();
break;
case PkiService::ERemoveKeypair:
{
TPKIKeyIdentifier keyId;
aOperation.iMessage.ReadL(0, keyId);
if (keyId.Length() > 0)
{
iKeyOperationProvider->RemoveKeyPair(keyId, aOperation.iUsedKeyStore);
}
else
{
CompleteCurrentOperation(KPKIErrNotFound);
}
}
break;
case PkiService::EGenerateKeypair:
{
TUint keySize = aOperation.iMessage.Int1();
TPKIKeyAlgorithm keyAlgorithm = static_cast<TPKIKeyAlgorithm>(aOperation.iMessage.Int2());
iKeyOperationProvider->GenerateKeyPair(keySize, keyAlgorithm, aOperation.iUsedKeyStore);
}
break;
case PkiService::EStoreKeypair:
{
HBufC8* keyData = HBufC8::NewLC(aOperation.iMessage.GetDesLength(1));
TPtr8 keyDataPtr = keyData->Des();
aOperation.iMessage.ReadL(1, keyDataPtr);
CleanupStack::Pop(keyData);
iKeyOperationProvider->ImportKeyPair(keyData, aOperation.iUsedKeyStore);
}
break;
default:
PKISERVICE_INVARIANT();
break;
}
}
void CKeyOperationQueue::CompleteCurrentOperation(TInt aStatus)
{
TKeyOperation* operation = iCurrentOperation;
iCurrentOperation = NULL;
operation->iMessage.Complete(aStatus);
delete operation;
if (iOperationQue.Count() > 0)
{
StartNextOperation();
}
}
void CKeyOperationQueue::KeyStoreInitComplete(TInt aStatus)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::EInitialize);
if (aStatus == KErrNone)
{
TRAPD(err, iCurrentOperation->iOwner.InitializeWrapperL(iCurrentOperation->iMessage));
if (err != KErrNone && iCurrentOperation->iMessage.Handle() != NULL)
{
CompleteCurrentOperation(err);
}
else
{
delete iCurrentOperation;
iCurrentOperation = NULL;
if (iOperationQue.Count() > 0)
{
StartNextOperation();
}
}
}
else
{
CompleteCurrentOperation(aStatus);
}
}
void CKeyOperationQueue::KeyPairListComplete(TInt aStatus, CArrayFixFlat<TKeyListEntry>* aKeyList)
{
PKISERVICE_ASSERT((aStatus == KErrNone && aKeyList != NULL) ||
(aStatus != KErrNone && aKeyList == NULL));
if (iCurrentOperation->iMessage.Function() == PkiService::EKeyCount)
{
//If we are getting key count, we save the
//iKeyList, because the next call will be the list
//retrieve.
if (aStatus == KErrNone)
{
iCurrentOperation->iOwner.SetKeyList(aKeyList);
CompleteCurrentOperation(aKeyList->Count());
}
else
{
CompleteCurrentOperation(aStatus);
}
}
else
{
//If we are just retrieving a key details.
//We can clean up the key list at the end.
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::EGetKeyDetails);
if (aStatus == KErrNone)
{
if (aKeyList->Count() > 0)
{
const TKeyListEntry& entry = (*aKeyList)[0];
const TPckg<TKeyListEntry> listEntryBuf(entry);
TInt err = iCurrentOperation->iMessage.Write(0, listEntryBuf);
//We should newer get overflow,
//because API knows the length of the result.
__ASSERT_DEBUG(err != KErrOverflow, User::Invariant());
CompleteCurrentOperation(err);
}
else
{
CompleteCurrentOperation(KPKIErrNotFound);
}
}
else
{
CompleteCurrentOperation(aStatus);
}
delete aKeyList;
}
}
void CKeyOperationQueue::DecryptComplete(TInt aStatus, HBufC8* aDecryptedData)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::EDecrypt);
PKISERVICE_ASSERT((aStatus == KErrNone && aDecryptedData != NULL) ||
(aStatus != KErrNone && aDecryptedData == NULL));
if (aDecryptedData != NULL)
{
aStatus = iCurrentOperation->iMessage.Write(2, *aDecryptedData);
if (aStatus == KErrOverflow)
{
iCurrentOperation->iOwner.SetRequiredBufferSize(aDecryptedData->Length());
aStatus = KPKIErrBufferTooShort;
}
delete aDecryptedData;
}
CompleteCurrentOperation(aStatus);
}
void CKeyOperationQueue::SignComplete(TInt aStatus, HBufC8* aSignedData)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::ESignWithKeyId ||
iCurrentOperation->iMessage.Function() == PkiService::ESignWithCert);
PKISERVICE_ASSERT((aStatus == KErrNone && aSignedData != NULL) ||
(aStatus != KErrNone && aSignedData == NULL));
if (aSignedData != NULL)
{
aStatus = iCurrentOperation->iMessage.Write(2, *aSignedData);
if (aStatus == KErrOverflow)
{
iCurrentOperation->iOwner.SetRequiredBufferSize(aSignedData->Length());
aStatus = KPKIErrBufferTooShort;
}
delete aSignedData;
}
CompleteCurrentOperation(aStatus);
}
void CKeyOperationQueue::GetPublicKeyCompleted(TInt aStatus, HBufC8* aPublicKeyData)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::EReadPublicKey);
PKISERVICE_ASSERT((aStatus == KErrNone && aPublicKeyData != NULL) ||
(aStatus != KErrNone && aPublicKeyData == NULL));
if (aPublicKeyData != NULL)
{
aStatus = iCurrentOperation->iMessage.Write(1, *aPublicKeyData);
if (aStatus == KErrOverflow)
{
iCurrentOperation->iOwner.SetRequiredBufferSize(aPublicKeyData->Length());
aStatus = KPKIErrBufferTooShort;
}
delete aPublicKeyData;
}
CompleteCurrentOperation(aStatus);
}
void CKeyOperationQueue::LogonCompleted(TInt aStatus)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::ELogon);
CompleteCurrentOperation(aStatus);
}
void CKeyOperationQueue::LogoffCompleted(TInt aStatus)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::ELogoff);
CompleteCurrentOperation(aStatus);
}
void CKeyOperationQueue::PasswordChangeCompleted(TInt aStatus)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::EChangePassword);
CompleteCurrentOperation(aStatus);
}
void CKeyOperationQueue::KeyPairRemoveCompleted(TInt aStatus)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::ERemoveKeypair);
CompleteCurrentOperation(aStatus);
}
void CKeyOperationQueue::KeyGenerationCompleted(TInt aStatus, TPKIKeyIdentifier& aKeyId)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::EGenerateKeypair);
if (aStatus == KErrNone)
{
aStatus = iCurrentOperation->iMessage.Write(0, aKeyId);
if (aStatus == KErrOverflow)
{
iCurrentOperation->iOwner.SetRequiredBufferSize(aKeyId.Length());
aStatus = KPKIErrBufferTooShort;
}
}
CompleteCurrentOperation(aStatus);
}
void CKeyOperationQueue::StoreKeyPairCompleted(TInt aStatus, TPKIKeyIdentifier& aKeyId)
{
PKISERVICE_ASSERT(iCurrentOperation != NULL);
PKISERVICE_ASSERT(iCurrentOperation->iMessage.Function() == PkiService::EStoreKeypair);
if (aStatus == KErrNone)
{
aStatus = iCurrentOperation->iMessage.Write(0, aKeyId);
if (aStatus == KErrOverflow)
{
iCurrentOperation->iOwner.SetRequiredBufferSize(aKeyId.Length());
aStatus = KPKIErrBufferTooShort;
}
}
CompleteCurrentOperation(aStatus);
}