/*

* Copyright (c) 2006 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 DevCertKeyStoreConduit

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mctkeystoreuids.h>

#endif

#include "DevCertKeyStoreConduit.h"

#include "DevCertKeyStoreServer.h"

#include "DevCertKeyStoreSession.h"

#include "DevCertOpenedKeysSrv.h"

#include "DevTokenDataTypes.h"

#include "DevTokenMarshaller.h"

#include "DevTokenUtil.h"

#include <asymmetric.h>

#include <mctkeystoremanager.h>

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

// CDevCertKeyStoreConduit

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

// CDevCertKeyStoreConduit::NewL()

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

// 

CDevCertKeyStoreConduit* CDevCertKeyStoreConduit::NewL(CDevCertKeyStoreServer& aServer)

    {

    CDevCertKeyStoreConduit* self = new (ELeave) CDevCertKeyStoreConduit(aServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CDevCertKeyStoreConduit::~CDevCertKeyStoreConduit()

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

// 

CDevCertKeyStoreConduit::~CDevCertKeyStoreConduit()

    {

    Cancel();

    }

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

// CDevCertKeyStoreConduit::CDevCertKeyStoreConduit()

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

// 

CDevCertKeyStoreConduit::CDevCertKeyStoreConduit(CDevCertKeyStoreServer& aServer)

  : CActive(EPriorityHigh), iServer(aServer), iCurrentRequest(iStatus)

    {

    }

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

// CDevCertKeyStoreConduit::ConstructL()

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

//

void CDevCertKeyStoreConduit::ConstructL()

    {

    CActiveScheduler::Add(this);

    }

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

// CDevCertKeyStoreConduit::ServiceRequestL()

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

//

void CDevCertKeyStoreConduit::ServiceRequestL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession)

    {

    TDevTokenMessages request = static_cast<TDevTokenMessages>(aMessage.Function());

    if (iCurrentRequest.OutstandingRequest()!=EIdle)

        {

        //  There is currently a request outstanding, only allow this one if it's a cancel

        if ( (request!=ECancelCreateKey) &&

        (request!=ECancelImportKey) &&

        (request!=ECancelImportEncryptedKey) &&

        (request!=ECancelExportKey) &&

        (request!=ECancelRSASign) &&

        (request!=ECancelDSASign) &&

        (request!=ECancelDecrypt) )

            {

            User::Leave(KErrServerBusy);

            }

        }

    switch (request)

        {

        case EListKeys:

            ListL(aMessage);

            break;

        case EGetKeyInfo:

            GetKeyInfoL(aMessage);

            break;

        case ECreateKey:

            CreateKeyL(aMessage);

            break;

        case ECancelCreateKey:

            CancelCreateKey(aMessage);

            break;

        case EImportKey:

        case EImportEncryptedKey:

            ImportKeyL(aMessage);

            break;

        case ECancelImportKey:

        case ECancelImportEncryptedKey:

            CancelImportKey(aMessage);

            break;

        case EExportKey:

            ExportKeyL(aMessage);

            break;

        case ECancelExportKey:

            CancelExportKey(aMessage);

            break;

        case EExportPublic:

            ExportPublicL(aMessage);

            break;

        case EGetKeyLength:

            GetKeyLengthL(aMessage);

            break;

        case EDeleteKey:

            DeleteKeyL(aMessage);

            break;

        case ESetUsePolicy:

            SetUsePolicyL(aMessage);

            break;

        case ESetManagementPolicy:

            SetManagementPolicyL(aMessage);

            break;

        case EOpenKeyRepudiableRSASign:

            OpenKeyL(aMessage, aSession, KRSARepudiableSignerUID);

            break;

        case EOpenKeyRepudiableDSASign:

            OpenKeyL(aMessage, aSession, KDSARepudiableSignerUID);

            break;

        case EOpenKeyDecrypt:

            OpenKeyL(aMessage, aSession, KPrivateDecryptorUID);

            break;

        case EOpenKeyAgree:

            OpenKeyL(aMessage, aSession, KKeyAgreementUID);

            break;

        case ECloseObject:

            CloseObjectL(aMessage, aSession);

            break;

        case ERepudiableDSASign:

            RepudiableDSASignL(aMessage, aSession);

            break;

        case ECancelDSASign:

            CancelDSASign(aMessage);

            break;         

        case ERepudiableRSASign:

            RepudiableRSASignL(aMessage, aSession);

            break;

        case ECancelRSASign:

            CancelRSASign(aMessage);

            break;         

        case EDecryptText:

            DecryptL(aMessage, aSession);

            break;

        case ECancelDecrypt:

            CancelDecrypt(aMessage);

            break;         

        case EDHPublicKey:

            DHPublicKeyL(aMessage, aSession);

            break;

        case EDHAgree:

            DHAgreeL(aMessage, aSession);

            break;

        case ECancelDH:

            CancelDH(aMessage);

            break;         

        default:  //  Should not reach here

            __ASSERT_DEBUG(EFalse, PanicServer(EPanicInvalidRequest));

            User::Leave(KErrNotSupported);

        }

    }

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

// CDevCertKeyStoreConduit::ListL()

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

//

void CDevCertKeyStoreConduit::ListL(const RMessage2& aMessage)

    {

    //  p[0] has the filter to use

    RCPointerArray<CDevTokenKeyInfo> keyInfos;

    CleanupClosePushL(keyInfos);

    TPckgBuf<TCTKeyAttributeFilter> filter;

    aMessage.ReadL(0, filter);

    iServer.ListL(filter(), keyInfos);

    TInt bufSize = User::LeaveIfError(aMessage.GetDesMaxLength(2)); 

    TInt reqdSize = DevTokenDataMarshaller::Size(keyInfos);

    if (bufSize >= reqdSize)

        {

        HBufC8* buffer = HBufC8::NewMaxLC(reqdSize);

        TPtr8 thePtr(buffer->Des());

        DevTokenDataMarshaller::Write(keyInfos, thePtr);

        aMessage.WriteL(2, thePtr);

        CleanupStack::PopAndDestroy(buffer);

        }

    else

        {

        TPckg<TInt> sizePckg(reqdSize);

        aMessage.WriteL(2, sizePckg);

        User::Leave(KErrOverflow);

        }

    CleanupStack::PopAndDestroy(&keyInfos); // keyInfos

    aMessage.Complete(KErrNone);

    }

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

// CDevCertKeyStoreConduit::GetKeyInfoL()

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

//

void CDevCertKeyStoreConduit::GetKeyInfoL(const RMessage2& aMessage)

    {

    //  Token object to delete is in p[0]

    TInt objectId = aMessage.Int0();

    CDevTokenKeyInfo* info = NULL;

    iServer.GetKeyInfoL(objectId, info);

    info->CleanupPushL();

    TInt bufferSize = User::LeaveIfError(aMessage.GetDesMaxLength(2));

    TInt requiredSize = DevTokenDataMarshaller::Size(*info);

    if (bufferSize >= requiredSize)

        {

        HBufC8* buffer = HBufC8::NewMaxLC(requiredSize);

        TPtr8 thePtr(buffer->Des());

        DevTokenDataMarshaller::Write(*info, thePtr);

        aMessage.WriteL(2, thePtr);

        CleanupStack::PopAndDestroy(buffer);

        }

    else

        {

        TPckg<TInt> theSize(requiredSize);

        aMessage.WriteL(2, theSize);

        User::Leave(KErrOverflow);

        }

    CleanupStack::PopAndDestroy(info);

    aMessage.Complete(KErrNone);

    }

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

// CDevCertKeyStoreConduit::GetClientUidL()

// Work out the UID of the client process.

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

//

TUid CDevCertKeyStoreConduit::GetClientUidL(const RMessage2& aMessage) const

    {

    RThread clientThread;

    User::LeaveIfError(aMessage.Client(clientThread));

    CleanupClosePushL(clientThread);  

    RProcess clientProcess;

    User::LeaveIfError(clientThread.Process(clientProcess));

    CleanupClosePushL(clientProcess);

    TUid uid = clientProcess.Type()[2];

    CleanupStack::PopAndDestroy(2); // clientProcess, clientThread

    return uid;

    }

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

// CDevCertKeyStoreConduit::CreateKeyL()

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

//

void CDevCertKeyStoreConduit::CreateKeyL(const RMessage2& aMessage)

    {

    ASSERT(!iKeyInfo);

    //  p[0] has the length of the buffer. Check our buffer is big

    //  enough, to cope with requests for keys with very long labels.

    TInt bufLength = User::LeaveIfError(aMessage.GetDesLength(1));

    HBufC8* keyInfoBuf = HBufC8::NewMaxLC(bufLength);

    //  p[1] has the CDevTokenKeyInfo structure required to create a key

    //  Read it and convert from descriptor back to a CDevTokenKeyInfo

    TPtr8 thePtr(keyInfoBuf->Des());

    thePtr.FillZ();

    aMessage.ReadL(1, thePtr);

    DevTokenDataMarshaller::ReadL(*keyInfoBuf, iKeyInfo);

    CleanupStack::PopAndDestroy(keyInfoBuf);

    iCurrentRequest.Set(ECreateKey, aMessage);

    iStatus = KRequestPending;

    SetActive();

    iServer.CreateKey(*iKeyInfo, iStatus);

    }

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

// CDevCertKeyStoreConduit::CancelCreateKey()

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

//

void CDevCertKeyStoreConduit::CancelCreateKey(const RMessage2& aMessage)

    {

    if (iCurrentRequest.OutstandingRequest() == ECreateKey)

        {

        Cancel();

        }

    aMessage.Complete(KErrNone);

    }

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

// CDevCertKeyStoreConduit::ImportKeyL()

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

//

void CDevCertKeyStoreConduit::ImportKeyL(const RMessage2& aMessage)

    {

    ASSERT(!iImportKey);

    ASSERT(!iKeyInfo);

    // p[0] has the descriptor containing the PKCS8 object (not be encrypted)

    TInt keyLen = User::LeaveIfError(aMessage.GetDesLength(0));

    HBufC8* importBuf = HBufC8::NewMaxLC(keyLen);

    TPtr8 theKeyData(importBuf->Des());

    theKeyData.FillZ();

    aMessage.ReadL(0, theKeyData);

    TInt bufLen = User::LeaveIfError(aMessage.GetDesLength(1));

    HBufC8* keyInfoBuf = HBufC8::NewMaxLC(bufLen);

    // p[1] has the CDevTokenKeyInfo structure required to create a key

    // Read it and convert from descriptor back to a CDevTokenKeyInfo

    TPtr8 thePtr(keyInfoBuf->Des());

    thePtr.FillZ();

    aMessage.ReadL(1, thePtr);

    DevTokenDataMarshaller::ReadL(*keyInfoBuf, iKeyInfo);

    CleanupStack::PopAndDestroy(keyInfoBuf);

    iImportKey = importBuf;

    CleanupStack::Pop(importBuf);

    iCurrentRequest.Set(static_cast<TDevTokenMessages>(aMessage.Function()), aMessage);

    iStatus = KRequestPending;

    SetActive();

    TBool isEncrypted = (aMessage.Function() == EImportEncryptedKey);

	iServer.ImportKey(*iImportKey, *iKeyInfo, isEncrypted, iStatus);

    }

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

// CDevCertKeyStoreConduit::CancelImportKey()

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

//

void CDevCertKeyStoreConduit::CancelImportKey(const RMessage2& aMessage)

    {

    if (iCurrentRequest.OutstandingRequest() == EImportKey ||

		iCurrentRequest.OutstandingRequest() == EImportEncryptedKey)

        {

        Cancel();

        }

    aMessage.Complete(KErrNone); 

    }

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

// CDevCertKeyStoreConduit::GetKeyLengthL()

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

//

void CDevCertKeyStoreConduit::GetKeyLengthL(const RMessage2& aMessage)

    {

    TInt length = iServer.GetKeyLengthL(aMessage.Int0());

    ASSERT(length > 0);

    aMessage.Complete(length);    

    }

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

// CDevCertKeyStoreConduit::CancelExportKey()

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

//

void CDevCertKeyStoreConduit::CancelExportKey(const RMessage2& aMessage)

    {

    if (iCurrentRequest.OutstandingRequest() == EExportKey ||

        iCurrentRequest.OutstandingRequest() == EImportEncryptedKey)

        {

        Cancel();

        }

    aMessage.Complete(KErrNone);

    }

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

// CDevCertKeyStoreConduit::ExportKeyL()

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

//

void CDevCertKeyStoreConduit::ExportKeyL(const RMessage2& aMessage)

    {

    ASSERT(!iExportBuf);

    TInt objectId = aMessage.Int0();

    TInt bufLen = User::LeaveIfError(aMessage.GetDesMaxLength(1));  // #1 IPC argument is the request Ptr

    HBufC8* exportBuf =  HBufC8::NewMaxLC(bufLen);

    TPtr8 temp(exportBuf->Des());

    temp.FillZ();

    // No more leaves

    iExportBuf = exportBuf;

    CleanupStack::Pop(exportBuf);

    iCurrentRequest.Set(static_cast<TDevTokenMessages>(aMessage.Function()), aMessage); 

    iStatus = KRequestPending;

    SetActive();    

    if (aMessage.Function() == EExportKey) 

        {

        iServer.ExportKey(objectId, temp, iStatus);

        }    

    }

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

// CDevCertKeyStoreConduit::ExportPublicL()

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

//

void CDevCertKeyStoreConduit::ExportPublicL(const RMessage2& aMessage)

    {

    TInt objectId = aMessage.Int0();

    TInt bufLen = User::LeaveIfError(aMessage.GetDesMaxLength(1));

    HBufC8* exportBuf = HBufC8::NewMaxLC(bufLen);

    TPtr8 ptr(exportBuf->Des());

    ptr.FillZ();

    iServer.ExportPublicL(objectId, ptr);

    aMessage.WriteL(1, ptr);

    CleanupStack::PopAndDestroy(exportBuf);

    aMessage.Complete(KErrNone);

    }

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

// CDevCertKeyStoreConduit::DeleteKeyL()

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

//

void CDevCertKeyStoreConduit::DeleteKeyL(const RMessage2& aMessage)

    {

    TInt objectId = aMessage.Int0();

    iServer.DeleteKeyL(objectId);

    aMessage.Complete(KErrNone);

    }

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

// CDevCertKeyStoreConduit::SetUsePolicyL()

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

//

void CDevCertKeyStoreConduit::SetUsePolicyL(const RMessage2& aMessage)

    {

    TInt objectId = aMessage.Int0();

    TSecurityPolicyBuf policyBuf;

    aMessage.ReadL(1, policyBuf);

    iServer.SetUsePolicyL(objectId, policyBuf());

    aMessage.Complete(KErrNone);

    }

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

// CDevCertKeyStoreConduit::SetManagementPolicyL()

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

//

void CDevCertKeyStoreConduit::SetManagementPolicyL(const RMessage2& aMessage)

    {

    TInt objectId = aMessage.Int0();

    TSecurityPolicyBuf policyBuf;

    aMessage.ReadL(1, policyBuf);

    iServer.SetManagementPolicyL(objectId, policyBuf());

    aMessage.Complete(KErrNone);

    }

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

// CDevCertKeyStoreConduit::OpenKeyL()

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

//

void CDevCertKeyStoreConduit::OpenKeyL(const RMessage2& aMessage, 

                                       CDevCertKeyStoreSession& aSession, 

                                       TUid aType)

    { 

    CDevCertOpenedKeySrv* openedKey = iServer.OpenKeyL(aMessage.Int0(), aType);

    CleanupStack::PushL(openedKey);

    const TDesC& label = openedKey->Label();

    TInt writeBufLen = User::LeaveIfError(aMessage.GetDesMaxLength(3));

    TInt reqdLength = label.Length();

    if (writeBufLen < reqdLength)

        {

        // We're writing into a TDes16 so we can't use TPckg<TInt>

        TPtrC sizePtr(reinterpret_cast<TUint16*>(&reqdLength), 2);

        aMessage.WriteL(3, sizePtr);

        User::Leave(KErrOverflow);