/*

* 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 DevCertKeyDataManager

*

*/

#include <bigint.h>

#include "DevCertCreateKey.h"

#include "DevTokenServerDebug.h"

#include "SimpleDHKey.h"

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

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

// CSimpleDHKey::NewL()

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

//

CSimpleDHKey* CSimpleDHKey::NewL(TInt aSize)

    {

    CSimpleDHKey* me = new (ELeave) CSimpleDHKey();

    CleanupStack::PushL(me);

    me->ConstructL(aSize);

    CleanupStack::Pop(me);

    return (me);

    }

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

// CSimpleDHKey::ConstructL()

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

//

void CSimpleDHKey::ConstructL(TInt aSize)

    {

    iKey = RInteger::NewRandomL(aSize - 1);             

    }

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

// CSimpleDHKey::~CSimpleDHKey()

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

//

CSimpleDHKey::~CSimpleDHKey()

    {

    iKey.Close();

    }

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

// CDevCertKeyCreator::CDevCertKeyCreator()

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

//

CDevCertKeyCreator::CDevCertKeyCreator()

: CActive(EPriorityStandard), iAction(EIdle)

    {

    CActiveScheduler::Add(this);

    }

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

// CDevCertKeyCreator::~CDevCertKeyCreator()

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

//

CDevCertKeyCreator::~CDevCertKeyCreator()

    {

    Cancel(); 

    iCreatorThread.LogonCancel(iStatus);

    iCreatorThread.Close();

    delete iCreateData;

    }

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

// CDevCertKeyCreator::DoCreateKeyAsyncL()

//  Spin a thread to create an appropriate key, if successful, 

// left on CleanupStack

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

//

void CDevCertKeyCreator::DoCreateKeyAsyncL(CDevTokenKeyInfo::EKeyAlgorithm aAlgorithm, TInt aSize, TRequestStatus& aStatus)

    {

    if ( (aSize <= 0) ||

    (aAlgorithm==CDevTokenKeyInfo::EInvalidAlgorithm) || 

    ((aAlgorithm!=CDevTokenKeyInfo::ERSA) && (aAlgorithm!=CDevTokenKeyInfo::EDSA) && (aAlgorithm!=CDevTokenKeyInfo::EDH)) )

    User::Leave(KErrArgument);

    iClientStatus = &aStatus;

    *iClientStatus = KRequestPending;

    iCreateData = new (ELeave) CDevCertKeyCreatorData(aAlgorithm, aSize);

    //  OK, ready to start the async operation...do it in RunL

    iAction = EReadyToCreateKey;

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus* stat = &iStatus;

    User::RequestComplete(stat, KErrNone);

    }

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

// CDevCertKeyCreator::CreatorThreadEntryPoint()

// HERE'S THE THREAD TO CREATE THE KEY

// Code cannot leave in here, but not as many traps as it looks

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

//

TInt CDevCertKeyCreator::CreatorThreadEntryPoint(TAny* aParameters)

    {

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if (!cleanup)

    User::Exit(KErrNoMemory);

    #ifdef _DEBUG

    DevTokenServerDebug::PauseOOMTest();

    #endif

    ASSERT(aParameters);

    TInt result = KErrNone;

    CDevCertKeyCreatorData* createData = static_cast<CDevCertKeyCreatorData*>(aParameters);

    switch (createData->iKeyAlgorithm)

        {

        case(CDevTokenKeyInfo::ERSA):

            {// Currently, CRT signing is not supported, in case the key is to be used

            //  for such, create a standard (private) key as part of the pair

            TRAP(result, createData->iKey.iRSAKey = CRSAKeyPair::NewL(createData->iSize));

            }

        break;

        case (CDevTokenKeyInfo::EDSA):

            {

            TRAP(result, createData->iKey.iDSAKey = CDSAKeyPair::NewL(createData->iSize));

            }

        break;

        case (CDevTokenKeyInfo::EDH):

            {// Generate a number that's less than N. The snag is that

            //  we don't know what N is. We do know that it'll be of a

            //  particular size, so we can safely generate any number

            //  with less than iSize digits

            TRAP(result, createData->iKey.iDHKey = CSimpleDHKey::NewL(createData->iSize));        

            }

        break;

        default:

        ASSERT(EFalse);

        result = KErrArgument;

        }

    #ifdef _DEBUG

    DevTokenServerDebug::ResumeOOMTest();

    #endif

    delete cleanup;

    User::Exit(result);

    return (KErrNone);

    }

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

// CDevCertKeyCreator::GetCreatedRSAKey()

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

//

CRSAKeyPair* CDevCertKeyCreator::GetCreatedRSAKey()

    {// Check algorithm is as expected, return NULL if no key or wrong type

    if ( (!iCreateData) || (CDevTokenKeyInfo::ERSA!=iCreateData->iKeyAlgorithm) )

    return (NULL);

    else

    return (iCreateData->iKey.iRSAKey);

    }

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

// CDevCertKeyCreator::GetCreatedDSAKey()

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

//

CDSAKeyPair* CDevCertKeyCreator::GetCreatedDSAKey()

    {// Check algorithm is as expected, return NULL if no key or wrong type

    if ( (!iCreateData) || (CDevTokenKeyInfo::EDSA!=iCreateData->iKeyAlgorithm) )

    return (NULL);

    else

    return (iCreateData->iKey.iDSAKey);

    }

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

// CDevCertKeyCreator::GetCreatedDHKey()

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

//

void CDevCertKeyCreator::GetCreatedDHKey(RInteger& aDHKey)

    {

    ASSERT(iCreateData);

    ASSERT(CDevTokenKeyInfo::EDH==iCreateData->iKeyAlgorithm);    

    aDHKey = iCreateData->iKey.iDHKey->DHKey();

    }

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

// CDevCertKeyCreator::DoCancel()

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

//

void CDevCertKeyCreator::DoCancel()

    {// Only do the cancel if in the middle of creating a key.  Kill the thread.

    if (iAction!=EIdle)

        {

        TExitType exitType = iCreatorThread.ExitType();

        if (EExitPending==exitType) //  Still alive, so kill it

        iCreatorThread.Kill(KErrCancel);

        iAction = EIdle;

        }

    ASSERT(iClientStatus);

    User::RequestComplete(iClientStatus, KErrCancel);

    }

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

// CDevCertKeyCreator::RunL()

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

//

void CDevCertKeyCreator::RunL()

    {

    ASSERT(iClientStatus);

    switch (iAction)

        {

        case (EReadyToCreateKey):

            {// Spin off the thread and pass it the parameter data, then stand by

            User::LeaveIfError(iCreatorThread.Create(KCreateKeyName, CreatorThreadEntryPoint, KDefaultStackSize, NULL, (TAny*)iCreateData));

            iStatus = KRequestPending;

            iCreatorThread.Logon(iStatus);

            iAction = ECreatedKey;

            SetActive();

            iCreatorThread.Resume();

            }

        break;

        case (ECreatedKey):

            {// Notify the caller

            ASSERT(iClientStatus);

            // May be OOM creating logon, in which case we should kill thread

            if (iStatus.Int() == KErrNoMemory)

                {

                TExitType exitType = iCreatorThread.ExitType();

                if (EExitPending==exitType) //  Still alive, so kill it

                iCreatorThread.Kill(KErrNone);

                }

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

            iAction = EIdle;

            }

        break;

        default:

        ASSERT(EFalse);

        }

    }

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

// CDevCertKeyCreator::RunError()

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

//

TInt CDevCertKeyCreator::RunError(TInt anError)

    {

    if (iClientStatus)

        {

        User::RequestComplete(iClientStatus, anError);

        }

    return (KErrNone);

    }

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

// CDevCertKeyCreator::CDevCertKeyCreatorData::CDevCertKeyCreatorData()

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

//

CDevCertKeyCreator::CDevCertKeyCreatorData::CDevCertKeyCreatorData(CDevTokenKeyInfo::EKeyAlgorithm aAlgorithm, TInt aSize)

: iSize(aSize), iKeyAlgorithm(aAlgorithm)

    {}

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

// CDevCertKeyCreator::CDevCertKeyCreatorData::~CDevCertKeyCreatorData()

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

//

CDevCertKeyCreator::CDevCertKeyCreatorData::~CDevCertKeyCreatorData()

    {

    if (iKeyAlgorithm==CDevTokenKeyInfo::ERSA)

        {

    	delete iKey.iRSAKey;

        }

    else if (iKeyAlgorithm==CDevTokenKeyInfo::EDSA)

        {

        delete iKey.iDSAKey;	

        }

    else if (iKeyAlgorithm==CDevTokenKeyInfo::EDH)

        {

    	delete iKey.iDHKey;

        }

    }

//EOF