/*

* 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 "CKeyStoreConduit.h"

#include "cfskeystoreserver.h"

#include "CKeyStoreSession.h"

#include "OpenedKeys.h"

#include "fsdatatypes.h"

#include "fsmarshaller.h"

#include "fstokenutil.h"

#include <asymmetric.h>

#include <pbedata.h>

#include <mctkeystoremanager.h>

#include "cfskeystoreserver.h"

#include <mctkeystoreuids.h>

// CKeyStoreConduit ////////////////////////////////////////////////////////////

// can keep pointer to session as member

// also, do we need to pass the RMessage everywhere?

/*static*/ CKeyStoreConduit* CKeyStoreConduit::NewL(CFSKeyStoreServer& aServer)

{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

}

CKeyStoreConduit::~CKeyStoreConduit()

	{

	Cancel();

	}

CKeyStoreConduit::CKeyStoreConduit(CFSKeyStoreServer& aServer)

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

	{

	}

void CKeyStoreConduit::ConstructL()

	{

	CActiveScheduler::Add(this);

	}

void CKeyStoreConduit::ServiceRequestL(const RMessage2& aMessage, CKeyStoreSession& aSession)

	{

	TFSTokenMessages request = static_cast<TFSTokenMessages>(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!=ECancelExportEncryptedKey) &&

			 (request!=ECancelRSASign) &&

			 (request!=ECancelDSASign) &&

			 (request!=ECancelDecrypt) &&

			 (request!=ECancelChangePassphrase) &&

			 (request!=ECancelAuthOpen))

			{

			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 EExportEncryptedKey:

		ExportKeyL(aMessage);

		break;

	case ECancelExportEncryptedKey:

		CancelExportEncryptedKey(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, aSession);

		break;			   

	case ERepudiableRSASign:

		RepudiableRSASignL(aMessage, aSession);

		break;

   	case ECancelRSASign:

		CancelRSASign(aMessage, aSession);

		break;			   

	case EDecryptText:

		DecryptL(aMessage, aSession);

		break;

   	case ECancelDecrypt:

		CancelDecrypt(aMessage, aSession);

		break;			   

	case EDHPublicKey:

		DHPublicKeyL(aMessage, aSession);

		break;

   	case EDHAgree:

		DHAgreeL(aMessage, aSession);

		break;

   	case ECancelDH:

		CancelDH(aMessage, aSession);

		break;	

	case EChangePassphrase:

		ChangePassphrase(aMessage);

		break;

	case ECancelChangePassphrase:

		CancelChangePassphrase(aMessage);

		break;

	case EAuthOpen:

		AuthOpen(aMessage);

		break;

	case ECancelAuthOpen:

		CancelAuthOpen(aMessage);

		break;

	case EAuthClose:

		AuthClose(aMessage);

		break;

	case EAuthTimeRemaining:

		GetTimeRemaining(aMessage);

		break;

	case ESetTimeout:

		SetTimeout(aMessage);

		break;

	case EGetTimeout:

		GetTimeout(aMessage);

		break;

	case ERelock:

		Relock(aMessage);

		break;	

	default:	//	Should not reach here

		PanicClient(aMessage,EPanicIllegalFunction);

		break;

		}

	}

void CKeyStoreConduit::ListL(const RMessage2& aMessage)

	{

	//	p[0] has the filter to use

	RCPointerArray<CKeyInfo> keyInfos;

	CleanupClosePushL(keyInfos);

	TPckgBuf<TCTKeyAttributeFilter> filter;

	aMessage.ReadL(0, filter);

	iServer.ListL(filter(), keyInfos);

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

	iServer.CheckRangeL(bufSize);

	TInt reqdSize = TokenDataMarshaller::Size(keyInfos);

	if (bufSize >= reqdSize)

		{

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

		TPtr8 thePtr(buffer->Des());

		TokenDataMarshaller::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);

	}

void CKeyStoreConduit::GetKeyInfoL(const RMessage2& aMessage)

	{

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

	TInt objectId = aMessage.Int0();

	CKeyInfo* info = NULL;

	iServer.GetKeyInfoL(objectId, info);

	info->CleanupPushL();

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

	iServer.CheckRangeL(bufferSize);

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

	if (bufferSize >= requiredSize)

		{

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

		TPtr8 thePtr(buffer->Des());

		TokenDataMarshaller::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);

	}

/** Work out the UID of the client process. */

TUid CKeyStoreConduit::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;

	}

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

	iServer.CheckRangeL(bufLength);

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

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

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

	TPtr8 thePtr(keyInfoBuf->Des());

	thePtr.FillZ();

	aMessage.ReadL(1, thePtr);

	TokenDataMarshaller::ReadL(*keyInfoBuf, iKeyInfo);

	CleanupStack::PopAndDestroy(keyInfoBuf);

	iCurrentRequest.Set(ECreateKey, aMessage);

	iStatus = KRequestPending;

	SetActive();

	iServer.CreateKey(*iKeyInfo, iStatus);

	}

void CKeyStoreConduit::CancelCreateKey(const RMessage2& aMessage)

	{

	if (iCurrentRequest.OutstandingRequest() == ECreateKey)

		{