/*

* 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 class that provides a decrypt operation.

*

*/

#include "pkiservicedecryptor.h"

#include "logonservices.h"

#include "pkiserviceconstants.h"

#include "pkiserviceassert.h"

CPkiServiceDecryptor* CPkiServiceDecryptor::NewL(CLogonServices& aLogonServices)

    {

    CPkiServiceDecryptor* self = new (ELeave)CPkiServiceDecryptor(aLogonServices);

    return self;

    }

CPkiServiceDecryptor::CPkiServiceDecryptor(CLogonServices& aLogonServices)

:CActive(EPriorityStandard), iLogonServices(aLogonServices)

    {

    CActiveScheduler::Add(this);

    }

CPkiServiceDecryptor::~CPkiServiceDecryptor()

    {

    Cancel();

    }

void CPkiServiceDecryptor::Decrypt(const TPKIKeyIdentifier& aKeyId,

                                   const TDesC8& aEncryptedData,

                                   TPtr8& aPlainTextData,

                                   CUnifiedKeyStore& aUnifiedKeyStore,

                                   TInt aUsedKeyStore, 

                                   TRequestStatus& aClientStatus)

    {

    PKISERVICE_ASSERT(iKeyStore == NULL);

    PKISERVICE_ASSERT(iInput == NULL);    

    PKISERVICE_ASSERT(iDecryptor == NULL);

    PKISERVICE_ASSERT(iKeysList.Count() == 0);

    PKISERVICE_ASSERT(iState == EDecryptorIdle);

    iState = EDecryptorGettingKey;

    iInput = &aEncryptedData;

    iPlainText = &aPlainTextData;

    iKeyStore = &aUnifiedKeyStore;      

    iUsedKeyStore = aUsedKeyStore;

    aClientStatus = KRequestPending;

    iClientStatus = &aClientStatus;

    TCTKeyAttributeFilter filter;

    filter.iKeyId = aKeyId;

    iKeyStore->List(iKeysList, filter, iStatus);

    SetActive();        

    }

void CPkiServiceDecryptor::RunL()

    {

    if (iStatus == KErrNone)

        {

        switch(iState)

            {

            case EDecryptorGettingKey:                

                iState = EDecryptorIdle;

                TInt keyIndex;

                for (keyIndex = 0; keyIndex < iKeysList.Count(); keyIndex++)

                    {

                    if (iUsedKeyStore == STORETYPE_ANY_KEY_ID ||

                        iUsedKeyStore == iKeysList[keyIndex]->Token().TokenType().Type().iUid)

                        {

                        break;

                        }

                    }

                if (keyIndex < iKeysList.Count())

                    {

                    iKeyInfo = iKeysList[keyIndex];

                    TCTTokenObjectHandle tokeHandle = iKeyInfo->Handle();

                    iState = EDecryptorOpeningDecryptor;

                    iKeyStore->Open(tokeHandle, iDecryptor, iStatus);

                    SetActive();

                    }

                else

                    {

                    Cleanup();

                    User::RequestComplete(iClientStatus, KPKIErrNotFound);                

                    }

                break;

            case EDecryptorOpeningDecryptor:

                iState = EDecryptorDecrypting;                                

                iDecryptor->Decrypt(*iInput, *iPlainText, iStatus);

                SetActive();                

                break;

            case EDecryptorDecrypting:                            

                iState = EDecryptorIdle;

                if (iKeyInfo->Protector() != NULL)

                    {

                    //authObject is NULL for device store

                    iLogonServices.SetAuthenticationObject(iKeyInfo->Protector());

                    }

                Cleanup();  

                User::RequestComplete(iClientStatus, KErrNone);

                break;

            default:

                PKISERVICE_INVARIANT();

                break;            

            }        

        }

    else

        {

        iState = EDecryptorIdle;        

        Cleanup();

        User::RequestComplete(iClientStatus, iStatus.Int());

        }

    }

void CPkiServiceDecryptor::DoCancel()

    {

    switch(iState)

        {

        case EDecryptorGettingKey:

            iKeyStore->CancelList();

            break;

        case EDecryptorOpeningDecryptor:

            iKeyStore->CancelOpen();

            break;

        case EDecryptorDecrypting:

            iDecryptor->CancelDecrypt();

            break;

        default:

            PKISERVICE_INVARIANT();

            break;            

        }

    Cleanup();        

    iState = EDecryptorIdle;    

    User::RequestComplete(iClientStatus, KErrCancel);

    }

void CPkiServiceDecryptor::Cleanup()

    {

    if (iDecryptor != NULL)

        {        

        iDecryptor->Release();

        iDecryptor = NULL;

        }

    iKeyInfo = NULL;

    iKeysList.Close();    

    iInput = NULL;

    iKeyStore = NULL;

    }