/*

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

    }