/*
* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
*
*/


#include "CCreateKey.h"
#include "tokenserverdebug.h"
#include <bigint.h>
#include <securityerr.h>

//	Wrapper class because we differ from crypto on what a DH key is
class CSimpleDHKey : public CBase
	{
	public:
		static CSimpleDHKey* NewL(TInt aSize);
		~CSimpleDHKey();
	public:
		inline RInteger& DHKey() {return (iKey);};
	private:
		CSimpleDHKey() {};
		void ConstructL(TInt aSize);
	private:
		RInteger iKey;
	};

CSimpleDHKey* CSimpleDHKey::NewL(TInt aSize)
	{
	CSimpleDHKey* me = new (ELeave) CSimpleDHKey();
	CleanupStack::PushL(me);
	me->ConstructL(aSize);
	CleanupStack::Pop(me);
	return (me);
	}

void CSimpleDHKey::ConstructL(TInt aSize)
	{
	iKey = RInteger::NewRandomL(aSize - 1);							
	}

CSimpleDHKey::~CSimpleDHKey()
	{
	iKey.Close();
	}

CKeyCreator::CKeyCreator()
	: CActive(EPriorityStandard), 
	iAction(EIdle)
	{
	CActiveScheduler::Add(this);
	}

CKeyCreator::~CKeyCreator()
	{
	Cancel(); 

	iCreatorThread.LogonCancel(iStatus);
	iCreatorThread.Close();

	delete iCreateData;
	}

//	Spin a thread to create an appropriate key, if successful, left on CleanupStack
void CKeyCreator::DoCreateKeyAsync(CKeyInfo::EKeyAlgorithm aAlgorithm, TInt aSize, TRequestStatus& aStatus)
	{
	iClientStatus = &aStatus;
	*iClientStatus = KRequestPending;
	iStatus = KRequestPending;
		
	TInt err = KErrNone;
	
	if ( (aSize <= 0) ||
		 (aAlgorithm==CKeyInfo::EInvalidAlgorithm) || 
		 ((aAlgorithm!=CKeyInfo::ERSA) && (aAlgorithm!=CKeyInfo::EDSA) && (aAlgorithm!=CKeyInfo::EDH)) )
		{
		err = KErrKeyAlgorithm;
		}
	if(err == KErrNone)
		{
		iCreateData = new CKeyCreatorData(aAlgorithm, aSize);
		if(iCreateData == NULL)
			{
			err = KErrNoMemory;
			}
		}
	else
		{
		User::RequestComplete(iClientStatus, err);
		return;
		}
	
	//	OK, ready to start the async operation...do it in RunL
	iAction = EReadyToCreateKey;
	
	SetActive();
	TRequestStatus* stat = &iStatus;
	User::RequestComplete(stat, err);
	}	

//	HERE'S THE THREAD TO CREATE THE KEY
//	Code cannot leave in here, but not as many traps as it looks
/*static*/ TInt CKeyCreator::CreatorThreadEntryPoint(TAny* aParameters)
	{
	CTrapCleanup* cleanup = CTrapCleanup::New();
	if (!cleanup)
		User::Exit(KErrNoMemory);

#ifdef _DEBUG
	TokenServerDebug::PauseOOMTest();
#endif
	
	ASSERT(aParameters);
	TInt result = KErrNone;
	CKeyCreatorData* createData = static_cast<CKeyCreatorData*>(aParameters);
	switch (createData->iKeyAlgorithm)
		{
		case(CKeyInfo::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 (CKeyInfo::EDSA):
			{
				TRAP(result, createData->iKey.iDSAKey = CDSAKeyPair::NewL(createData->iSize));
			}
			break;
		case (CKeyInfo::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
		TokenServerDebug::ResumeOOMTest();
	#endif
	delete cleanup;
	User::Exit(result);
	return (KErrNone);
	}

CRSAKeyPair* CKeyCreator::GetCreatedRSAKey()
	{
	//	Check algorithm is as expected, return NULL if no key or wrong type
	if ( (!iCreateData) || (CKeyInfo::ERSA!=iCreateData->iKeyAlgorithm) )
		return (NULL);
	else
		return (iCreateData->iKey.iRSAKey);
	}

CDSAKeyPair* CKeyCreator::GetCreatedDSAKey()
	{
	//	Check algorithm is as expected, return NULL if no key or wrong type
	if ( (!iCreateData) || (CKeyInfo::EDSA!=iCreateData->iKeyAlgorithm) )
		return (NULL);
	else
		return (iCreateData->iKey.iDSAKey);
	}

void CKeyCreator::GetCreatedDHKey(RInteger& aDHKey)
	{
	ASSERT(iCreateData);
	ASSERT(CKeyInfo::EDH==iCreateData->iKeyAlgorithm);		
	aDHKey = iCreateData->iKey.iDHKey->DHKey();
	}

void CKeyCreator::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);
	}

void CKeyCreator::RunL()
	{
	ASSERT(iClientStatus);
	User::LeaveIfError(iStatus.Int());
	
	switch (iAction)
		{
		case (EReadyToCreateKey):
			{	
			// Spin off the thread and pass it the parameter data, then stand by
			// INC118634
			// To be safe, we should use anonymous threads because naming a thread means anybody could have opened a handle on the thread,
			// most likely system applications which want to know about panicing threads. So next thread creation will fail with KErrAlreadyExist(-11).
			User::LeaveIfError(iCreatorThread.Create(KNullDesC, 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);
		}
	}

TInt CKeyCreator::RunError(TInt anError)
	{
	if (iClientStatus)
		User::RequestComplete(iClientStatus, anError);

	return (KErrNone);
	}



CKeyCreator::CKeyCreatorData::CKeyCreatorData(CKeyInfo::EKeyAlgorithm aAlgorithm, TInt aSize)
	:iSize(aSize), 
	iKeyAlgorithm(aAlgorithm)
	{}

CKeyCreator::CKeyCreatorData::~CKeyCreatorData()
	{
	if (iKeyAlgorithm==CKeyInfo::ERSA)
		delete iKey.iRSAKey;
	else if (iKeyAlgorithm==CKeyInfo::EDSA)
		delete iKey.iDSAKey;
	else if (iKeyAlgorithm==CKeyInfo::EDH)
		delete iKey.iDHKey;
	}