/*

* Copyright (c) 2006-2009 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:   Implementation of DevCertKeyStore

*

*/

#include <asymmetrickeys.h>

#include <e32debug.h>

#include <mctkeystoreuids.h>            // KInterfaceKeyStore

#include "DevCertKeyStore.h"

#include "DevToken.h"

#include "DevCertOpenedKeys.h"

#include "DevTokenUtils.h"

#include "DevTokenImplementationUID.hrh"

#include "DevTokenMarshaller.h"

#include "DevTokenCliServ.h"

#include "DevTokenKeyInfoArray.h" //TDevTokenKeyInfoArray

#include "DevtokenLog.h"

// When retrieving data from the server we sometimes make a guess at the size of

// the data that will be returned so we can allocate a buffer for it.  If it's

// not big enough, the server tells us the required size and we retry.  These

// values are the initial guesses at buffer size:

const TInt KInitialBufSizeList = 1024;

const TInt KInitialBufSizeOpen = 64;

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

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

// CDevCertKeyStore::NewKeyStoreUserInterfaceL()

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

//

MCTTokenInterface* CDevCertKeyStore::NewKeyStoreUserInterfaceL(

                            MCTToken& aToken, 

                            RDevTokenClientSession& aClient)

    {

    //  Destroyed by MCTTokenInterface::DoRelease() 

    CDevCertKeyStore* me = new (ELeave) CDevCertKeyStore(KInterfaceKeyStore, 

                                             aToken, 

                                             aClient);                   

    CleanupStack::PushL(me);

    me->ConstructL();

    CleanupStack::Pop(me);

    return (me);

    }

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

// CDevCertKeyStore::NewKeyStoreManagerInterfaceL()

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

//

MCTTokenInterface* CDevCertKeyStore::NewKeyStoreManagerInterfaceL(MCTToken& aToken, RDevTokenClientSession& aClient)

    {

    //  Destroyed by MCTTokenInterface::DoRelease()

    TRACE_PRINT("CDevCertKeyStore::NewKeyStoreManagerInterfaceL -->1")

    CDevCertKeyStore* me = new (ELeave) CDevCertKeyStore(KInterfaceKeyStoreManager, 

                                                         aToken, 

                                                         aClient);

    CleanupStack::PushL(me);

    me->ConstructL();

    TRACE_PRINT("CDevCertKeyStore::NewKeyStoreManagerInterfaceL -->2")

    CleanupStack::Pop(me);

    return (me);

    }

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

// CDevCertKeyStore::CDevCertKeyStore()

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

//

CDevCertKeyStore::CDevCertKeyStore(TInt aUID, MCTToken& aToken, RDevTokenClientSession& aClient)

    : CDTClient(aUID, aToken, aClient),

    // Reference count starts at one as we're always created and 

    // returned by a GetInterface() call on the token

    iRefCount(1)

    {

    TRACE_PRINT("CDevCertKeyStore::CDevCertKeyStore: keystore client interface created");

    }

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

// CDevCertKeyStore::ConstructL()

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

//

void CDevCertKeyStore::ConstructL()

    {

    TRACE_PRINT("CDevCertKeyStore::ConstructL -->1")

    CActiveScheduler::Add(this);

    TRACE_PRINT("CDevCertKeyStore::ConstructL -->2")

    }

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

// CDevCertKeyStore::~CDevCertKeyStore()

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

//

CDevCertKeyStore::~CDevCertKeyStore()

    {

    Cleanup();

    }

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

// CDevCertKeyStore::Token()

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

//

MCTToken& CDevCertKeyStore::Token()

    {

    return iToken;

    }

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

// CDevCertKeyStore::AddRef()

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

//

void CDevCertKeyStore::AddRef()

    {

    ++iRefCount;

    iToken.AddRef();

    }

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

// CDevCertKeyStore::DoRelease()

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

//

void CDevCertKeyStore::DoRelease()

    {

    --iRefCount;

    ASSERT( iRefCount >= 0 );

    if ( iRefCount == 0 )

        {

        MCTTokenInterface::DoRelease();

        }

    }

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

// CDevCertKeyStore::ReleaseObject()

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

//

void CDevCertKeyStore::ReleaseObject(const TCTTokenObjectHandle& aHandle)

    {

    iClientSession.SendRequest(ECloseObject, TIpcArgs(aHandle.iObjectId));

    }

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

// CDevCertKeyStore::FreeKeyBuffer()

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

//

void CDevCertKeyStore::FreeKeyBuffer()

    {

    delete iKey; 

    iKey = NULL;

    }

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

// CDevCertKeyStore::AllocKeyBuffer()

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

//

TInt CDevCertKeyStore::AllocKeyBuffer(TInt aReqdSize)

    {

    ASSERT(aReqdSize > 0);

    TInt result = KErrNoMemory;

    FreeKeyBuffer();

    iKey = HBufC8::NewMax(aReqdSize);

    if ( iKey )

        {

        TPtr8 thePtr(iKey->Des());

        thePtr.FillZ();

        result = KErrNone;

        }

    return result;

    }

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

// CDevCertKeyStore::RunL()

// Called when the server completes an asynchronous request.  Unmarshalls the

// data from the server and passes it back to the caller.

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

// 

void CDevCertKeyStore::RunL()

    {

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

    switch ( iCurrentRequest.OutstandingRequest() )

        {

        case ECreateKey:

        case EImportKey:

        case EImportEncryptedKey:

        // Unmarshal the created key data and create CCTKeyInfo 

        // to pass back to caller

            UpdateKey();

            break;

        case EExportKey:

        case EDHAgree:

            {

            *iClientPtr.iBuffer = HBufC8::NewL(iRequestPtr.Length());

            TPtr8 ptr((*iClientPtr.iBuffer)->Des());

            ptr.FillZ();

            ptr.Copy(iRequestPtr);

            break;

            }

        case ERepudiableDSASign:

            DevTokenDataMarshaller::ReadL(iRequestPtr, *iClientPtr.iDSASignature);

            break;

        case ERepudiableRSASign:

            DevTokenDataMarshaller::ReadL(iRequestPtr, *iClientPtr.iRSASignature);

            break;

        case EDecryptText:

           iClientPtr.iDecryptedText->Copy(iRequestPtr);   

           break;

        case EDHPublicKey:

           {

           ASSERT(iDHParams);

           RInteger n = iDHParams->TakeN();

           CleanupStack::PushL(n);

           RInteger g = iDHParams->TakeG();

           CleanupStack::PushL(g);

           RInteger X;

           DevTokenDataMarshaller::ReadL(iRequestPtr, X);

           CleanupStack::PushL(X);

           *iClientPtr.iDHPublicKey = CDHPublicKey::NewL(n, g, X);

           CleanupStack::Pop(3); // X, g, n

           break;

           }

        default:

            __ASSERT_DEBUG(EFalse, DevTokenPanic(EInvalidRequest));

        }

    Cleanup();

    iCurrentRequest.Complete(KErrNone); 

    }

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

// CDevCertKeyStore::Cleanup()

// Clean up internal state

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

// 

void CDevCertKeyStore::Cleanup()

    {

    FreeRequestBuffer();

    FreeKeyBuffer();

    // Zero client pointers

    iClientPtr.iAny = NULL;

    delete iDHParams;

    iDHParams = NULL;

    delete iText;

    iText=NULL;

    }

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

// CDevCertKeyStore::RunError()

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

// 

TInt CDevCertKeyStore::RunError(TInt aError)

    {

    Cleanup();

    return CDTClient::RunError(aError);

    }

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

// CDevCertKeyStore::DoCancel()

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

//

void CDevCertKeyStore::DoCancel()

    {

    TDevTokenMessages message = EIdle;

    switch (iCurrentRequest.OutstandingRequest())

        {

        case ECreateKey:

            message = ECancelCreateKey;

            break;

        case ERepudiableRSASign:

            message = ECancelRSASign;

            break;

        case ERepudiableDSASign:

            message = ECancelDSASign;

            break;

        case EDecryptText:

            message = ECancelDecrypt;

            break;

        case EDHPublicKey:

        case EDHAgree:

            message = ECancelDH;

            break;      

        case EImportKey:

            message = ECancelImportKey;

            break;

        case EImportEncryptedKey:

			message = ECancelImportEncryptedKey;

			break;

        case EExportKey:

            message = ECancelExportKey;

            break;

        default:

            // Nothing to do

            break;

        }

    if ( message != EIdle )

        {

        iClientSession.SendRequest(message, TIpcArgs());

        }

    Cleanup();  

    CDTClient::DoCancel();  

    }

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

// CDevCertKeyStore::List()

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

//

void CDevCertKeyStore::List(RMPointerArray<CCTKeyInfo>& aKeys, const TCTKeyAttributeFilter& aFilter, TRequestStatus& aStatus)

    {

    TDevTokenKeyInfoArray array(aKeys);

    TRAPD(err, DoListL(aFilter, array));

    FreeRequestBuffer();

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, err); 

    }

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

// CDevCertKeyStore::DoList()

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

//

void CDevCertKeyStore::DoListL(const TCTKeyAttributeFilter& aFilter, MDevTokenKeyInfoArray& aOut)

    {

    //ASSERT(aOut.Count() == 0);

    TPckg<TCTKeyAttributeFilter> filterPckg(aFilter);

    SendSyncRequestAndHandleOverflowL(EListKeys, KInitialBufSizeList, TIpcArgs(&filterPckg, 0, &iRequestPtr));

    CleanupClosePushL(aOut);

    DevTokenDataMarshaller::ReadL(iRequestPtr, iToken, aOut);

    CleanupStack::Pop(&aOut);

    }

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

// CDevCertKeyStore::CancelList()

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

//

void CDevCertKeyStore::CancelList()

    {

    // synchronous, nothing to do

    }

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

// CDevCertKeyStore::GetKeyInfo()

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

//

void CDevCertKeyStore::GetKeyInfo(TCTTokenObjectHandle aHandle, CCTKeyInfo*& aInfo, 

                   TRequestStatus& aStatus)

    {

    TRAPD(err, DoGetKeyInfoL(aHandle, aInfo));

    FreeRequestBuffer();

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, err);

    }

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

// CDevCertKeyStore::DoGetKeyInfoL()

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

//

void CDevCertKeyStore::DoGetKeyInfoL(TCTTokenObjectHandle aHandle, 

                                     CCTKeyInfo*& aInfo)

    {

    SendSyncRequestAndHandleOverflowL(EGetKeyInfo, KInitialBufSizeList, TIpcArgs(aHandle.iObjectId, 0, &iRequestPtr));

    DevTokenDataMarshaller::ReadL(iRequestPtr, iToken, aInfo);

    }

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

// CDevCertKeyStore::CancelGetKeyInfo()

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

//

void CDevCertKeyStore::CancelGetKeyInfo()

    {

    // synchronous, nothing to do

    }

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

// CDevCertKeyStore::Open()

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

//

void CDevCertKeyStore::Open(const TCTTokenObjectHandle& aHandle, 

               MRSASigner*& aSigner, 

               TRequestStatus& aStatus)

    {

    CDevCertRSARepudiableSigner* signer = CDevCertRSARepudiableSigner::New(this);

    TInt err = DoOpenKey(EOpenKeyRepudiableRSASign, aHandle, signer);

    if ( err == KErrNone )

        {

        aSigner = signer;

        }

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, err);

    }

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

// CDevCertKeyStore::Open()

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

//

void CDevCertKeyStore::Open(const TCTTokenObjectHandle& aHandle, 

               MCTSigner<CDSASignature*>*& aSigner, 

               TRequestStatus& aStatus)

    { 

    CDevCertDSARepudiableSigner* signer = CDevCertDSARepudiableSigner::New(this);

    TInt err = DoOpenKey(EOpenKeyRepudiableDSASign, aHandle, signer);

    if ( err == KErrNone )

        {

        aSigner = signer;

        }

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, err);

    }

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

// CDevCertKeyStore::Open()

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

//

void CDevCertKeyStore::Open(const TCTTokenObjectHandle& aHandle, 

               MCTDecryptor*& aDecryptor,

               TRequestStatus& aStatus)

    {

    CDevCertRSADecryptor* decryptor = CDevCertRSADecryptor::New(this);

    TInt err = DoOpenKey(EOpenKeyDecrypt, aHandle, decryptor);

    if ( err == KErrNone )

        {

        aDecryptor = decryptor;

        }

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, err);

    }

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

// CDevCertKeyStore::Open()

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

//

void CDevCertKeyStore::Open(const TCTTokenObjectHandle& aHandle, 

               MCTDH*& aDH, TRequestStatus& aStatus)

    {

    CDevCertDHAgreement* dh = CDevCertDHAgreement::New(this);

    TInt err = DoOpenKey(EOpenKeyAgree, aHandle, dh);

    if ( err == KErrNone )

        {

        aDH = dh;

        }

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, err);

    }

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

// CDevCertKeyStore::DoOpenKey()

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

//

TInt CDevCertKeyStore::DoOpenKey(TDevTokenMessages aMessage,

                  const TCTTokenObjectHandle& aHandle,

                  CDevCertOpenedKey* aOpenedKey)

    {

    if ( !aOpenedKey )

        {

        return KErrNoMemory;

        }

    // This is similar to SendSyncRequestAndHandleOverflowL, 

    //but we're returning data in iLabel

    TInt handle;

    TPckg<TInt> handlePckg(handle);

    HBufC* label = HBufC::NewMax(KInitialBufSizeOpen);

    if ( !label )

        {

        aOpenedKey->Release();

        return KErrNoMemory;

        }