/*

* Copyright (c) 2005-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 "cfskeystoreclient.h"

#include "CFStokenclient.h"

#include "fsmarshaller.h"

#include "fsdatatypes.h"

#include "ClientOpenedKeys.h"

#include "clientutils.h"

#include <mctauthobject.h>

#include <asymmetrickeys.h>

#include <pbedata.h>

#include <ct/logger.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;

/**

 * A class that wraps an array of key info pointers.

 *

 * Implements the MKeyInfoArray interface required for marshalling key info

 * arrays.  The reason for all this is that we want to be able to use either an

 * array of CCTKeyInfo pointers or an array of MCTTokenObjects interchangably -

 * but the array classes are implemented as templates, so there is no

 * inheritance relation between Array\<A\> and Array\<B\> even if B is derived from

 * A.

 */

template <class KeyInfoT> class TKeyInfoArray : public MKeyInfoArray

	{

 public:

	TKeyInfoArray(RMPointerArray<KeyInfoT>& aArray) : iArray(aArray) { }

	virtual TInt Count() { return iArray.Count(); }

	virtual CCTKeyInfo* operator[](TInt aIndex) { return static_cast<CCTKeyInfo*>(iArray[aIndex]); }

	virtual TInt Append(CCTKeyInfo* aInfo) { return iArray.Append(aInfo); }

	virtual void Close() { iArray.Close(); }

 private:

	RMPointerArray<KeyInfoT>& iArray;

	};

/*static*/ MCTTokenInterface* CFSKeyStoreClient::NewKeyStoreUserInterfaceL(MCTToken& aToken, RFileStoreClientSession& aClient)

	{

	//	Destroyed by MCTTokenInterface::DoRelease() 

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

														   aToken, 

														   aClient);

	CleanupStack::PushL(me);

	me->ConstructL();

	CleanupStack::Pop(me);

	return (me);

	}

/*static*/ MCTTokenInterface* CFSKeyStoreClient::NewKeyStoreManagerInterfaceL(MCTToken& aToken, RFileStoreClientSession& aClient)

	{

	//	Destroyed by MCTTokenInterface::DoRelease()

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

														   aToken, 

														   aClient);

	CleanupStack::PushL(me);

	me->ConstructL();

	CleanupStack::Pop(me);

	return (me);

	}

CFSKeyStoreClient::CFSKeyStoreClient(TInt aUID, MCTToken& aToken, RFileStoreClientSession& aClient)

	: CFSClient(aUID, aToken, aClient),

	  // Reference count starts at one as we're always created and returned by a GetInterface() call on the token

	  iRefCount(1)

	{

	LOG(_L("CFSKeyStoreClient::CFSKeyStoreClient: keystore client interface created"));

	}

void CFSKeyStoreClient::ConstructL()

	{

	CActiveScheduler::Add(this);

	iAuthObject = CKeyStoreAuthObject::NewL(*this);

	iAuthObject->AddRef();

	}

CFSKeyStoreClient::~CFSKeyStoreClient()

	{

	LOG(_L("CFSKeyStoreClient::~CFSKeyStoreClient"));

	LOG_INC_INDENT();

	Cleanup();

	if (iAuthObject)

		{

		iAuthObject->Release();

		}

	LOG_DEC_INDENT();

	}

MCTToken& CFSKeyStoreClient::Token()

	{

	return iToken;

	}

void CFSKeyStoreClient::AddRef()

	{

	++iRefCount;

	LOG1(_L("CFSKeyStoreClient::AddRef: keystore client interface referenced, refcount = %d"), iRefCount);

	LOG_INC_INDENT();

	iToken.AddRef();

	LOG_DEC_INDENT();

	}

void CFSKeyStoreClient::DoRelease()

	{

	--iRefCount;

	LOG1(_L("CFSKeyStoreClient::DoRelease: keystore client interface released, refcount = %d"), iRefCount);

	LOG_INC_INDENT();

	ASSERT(iRefCount >= 0);

	if (iRefCount == 0)

		{

		MCTTokenInterface::DoRelease();

		}

	LOG_DEC_INDENT();

	}

void CFSKeyStoreClient::ReleaseObject(const TCTTokenObjectHandle& aHandle)

	{

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

	}

void CFSKeyStoreClient::FreeKeyBuffer()

	{

	delete iKey; 

	iKey = NULL;

	}

TInt CFSKeyStoreClient::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;

}

//	*********************************************************************************

//	CActive implementation

//	*********************************************************************************

/**

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

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

 */

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

		case EDHAgree:

			{

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

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

			ptr.FillZ();

			ptr.Copy(iRequestPtr);

			break;

			}

		case ERepudiableDSASign:

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

			break;

		case ERepudiableRSASign:

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

			break;

		case EDecryptText:

			iClientPtr.iDecryptedText->Copy(iRequestPtr);		

			break;

		case EChangePassphrase:

		case EAuthOpen:

			// Nothing to do for these operations

			break;

		case EDHPublicKey:

			{

			ASSERT(iDHParams);

			RInteger n = iDHParams->TakeN();

			CleanupStack::PushL(n);

			RInteger g = iDHParams->TakeG();

			CleanupStack::PushL(g);

			RInteger X;

			TokenDataMarshaller::ReadL(iRequestPtr, X);

			CleanupStack::PushL(X);

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

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

			break;

			}

		default:

			__ASSERT_DEBUG(EFalse, FSTokenPanic(EInvalidRequest));

		}

	Cleanup();

	iCurrentRequest.Complete(KErrNone);	

	}

/// Clean up internal state

void CFSKeyStoreClient::Cleanup()

	{

	FreeRequestBuffer();

	FreeKeyBuffer();

	delete iPbeParamsBuf;

	iPbeParamsBuf = NULL;	

	// Zero client pointers

	iClientPtr.iAny = NULL;

	delete iDHParams;

	iDHParams = NULL;

	delete iText;

	iText=NULL;

	}

TInt CFSKeyStoreClient::RunError(TInt aError)

	{

	Cleanup();

	return CFSClient::RunError(aError);

	}

void CFSKeyStoreClient::DoCancel()

	{

	TFSTokenMessages 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;

		case EExportEncryptedKey:

			message = ECancelExportEncryptedKey;

			break;

		case EChangePassphrase:

			message = ECancelChangePassphrase;

			break;

		case EAuthOpen:

			message = ECancelAuthOpen;

			break;

		default:

			// Nothing to do

			break;

		}

	if (message != EIdle)

		{

		iClient.SendRequest(message, TIpcArgs());

		}

	Cleanup();	

	CFSClient::DoCancel();	

	}

//	*********************************************************************************

//	MKeyStore

//	*********************************************************************************

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

	{

	LOG(_L("CFSKeyStoreClient::List: list keys"));

	LOG_INC_INDENT();

	TKeyInfoArray<CCTKeyInfo> array(aKeys);

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

	FreeRequestBuffer();

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	LOG_DEC_INDENT();

	}

void CFSKeyStoreClient::DoListL(const TCTKeyAttributeFilter& aFilter, MKeyInfoArray& aOut)

	{

	TInt startOfNew = aOut.Count();

	ASSERT(iAuthObject);

	TPckg<TCTKeyAttributeFilter> filterPckg(aFilter);

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

	CleanupClosePushL(aOut);

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

	for (TInt index = startOfNew ; index < aOut.Count() ; ++index)

		{		

		iAuthObject->AddRef();

		LOG1(_L("CFSKeyStoreClient::DoListL: adding keyinfo %08x."), aOut[index]);

		aOut[index]->SetProtector(*iAuthObject);

		}

	CleanupStack::Pop(&aOut);

	}

void CFSKeyStoreClient::CancelList()

	{

	// synchronous, nothing to do

	}

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

								   TRequestStatus& aStatus)

	{

	LOG(_L("CFSKeyStoreClient::GetKeyInfo: get key info"));

	LOG_INC_INDENT();

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

	LOG2(_L("Got key info %08x with protector %08x"), aInfo, aInfo->Protector());

	FreeRequestBuffer();

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	LOG_DEC_INDENT();

	}

void CFSKeyStoreClient::DoGetKeyInfoL(TCTTokenObjectHandle aHandle, CCTKeyInfo*& aInfo)

	{

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

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

	}

void CFSKeyStoreClient::CancelGetKeyInfo()

	{

	// synchronous, nothing to do

	}

void CFSKeyStoreClient::Open(const TCTTokenObjectHandle& aHandle, 

							 MRSASigner*& aSigner, 

							 TRequestStatus& aStatus)

	{

	LOG(_L("CFSKeyStoreClient::Open: open rsa signer"));

	LOG_INC_INDENT();

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

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

	if (err == KErrNone)

		{

		aSigner = signer;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	LOG_DEC_INDENT();

	}

void CFSKeyStoreClient::Open(const TCTTokenObjectHandle& aHandle, 

							 MCTSigner<CDSASignature*>*& aSigner, 

							 TRequestStatus& aStatus)

	{

	LOG(_L("CFSKeyStoreClient::Open: open dsa signer"));

	LOG_INC_INDENT();

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

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

	if (err == KErrNone)

		{

		aSigner = signer;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	LOG_DEC_INDENT();

	}

void CFSKeyStoreClient::Open(const TCTTokenObjectHandle& aHandle, 

							 MCTDecryptor*& aDecryptor,

							 TRequestStatus& aStatus)

	{

	LOG(_L("CFSKeyStoreClient::Open: open rsa decryptor"));

	LOG_INC_INDENT();

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

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

	if (err == KErrNone)

		{

		aDecryptor = decryptor;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	LOG_DEC_INDENT();

	}

void CFSKeyStoreClient::Open(const TCTTokenObjectHandle& aHandle, 

							 MCTDH*& aDH, TRequestStatus& aStatus)

	{

	LOG(_L("CFSKeyStoreClient::Open: open dh agreement"));

	LOG_INC_INDENT();

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

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

	if (err == KErrNone)

		{

		aDH = dh;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	LOG_DEC_INDENT();

	}

TInt CFSKeyStoreClient::DoOpenKey(TFSTokenMessages aMessage,

								  const TCTTokenObjectHandle& aHandle,

								  COpenedKey* 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;

		}

	TPtr labelPtr(label->Des());

	TIpcArgs args(aHandle.iObjectId, &handlePckg, 0, &labelPtr);

	TInt err = iClient.SendRequest(aMessage, args);

	if (err == KErrOverflow)

		{

		TInt sizeReqd = 0;

		TPckg<TInt> theSize(sizeReqd);

		TPtrC8 sizePtr(reinterpret_cast<const TUint8*>(label->Ptr()), 4);

		theSize.Copy(sizePtr);	

		delete label;

		label = HBufC::NewMax(sizeReqd);

		if (label)

			{

			labelPtr.Set(label->Des());		

			err = iClient.SendRequest(aMessage, args);

			}

		else

			{

			err = KErrNoMemory;

			}

		}

	if (err != KErrNone)

		{

		aOpenedKey->Release();

		delete label;