/*

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

* legacy plugin selector implementation

* Legacy plugin selector implementation

*

*/

/**

 @file

*/

#include "cryptospiutil.h"

#include "cryptospiproperty.h"

#include "e32uid.h"

#include <cryptospi/cryptospidef.h>

#include <e32property.h>

#include "rulecharacteristics.h"

using namespace CryptoSpi;

/**

The name of the executable which set up all the crypto spi

*/

_LIT(KCryptoSpiPropertySetupExe, "z:\\sys\\bin\\cryptospisetup.exe");

void CryptoSpiUtil::RetrieveCharacteristicsL(TInt32 aInterface, RPointerArray<CCharacteristicsAndPluginName>& aList)

	{

	RDesReadStream stream;

	RBuf8 rBuf;

	TInt count=0;

	CleanupClosePushL(rBuf);

	TInt length=RetrieveCharacteristicsL(aInterface, stream, rBuf, count);

	if (length<=4)	

		{

		return;

		}

	//internalize the characteristics and dll index

	for (TInt i=0;i<count;i++)

		{

		CCharacteristicsAndPluginName* temp=CCharacteristicsAndPluginName::NewLC(aInterface);

		temp->InternalizeL(stream);

		aList.AppendL(temp);

		CleanupStack::Pop(temp); //temp

		}

	CleanupStack::PopAndDestroy(&rBuf);

	}

void CryptoSpiUtil::RetrieveCharacteristicsL(TInt32 aInterface, RPointerArray<CRulesCharacteristicsAndPluginName>& aList)

	{

	RDesReadStream stream;

	RBuf8 rBuf;

	TInt count=0;

	CleanupClosePushL(rBuf);

	TInt length=RetrieveCharacteristicsL(aInterface, stream, rBuf, count);

	if (length<=4)	

		{

		return;

		}

	//internalize the characteristics and dll index

	for (TInt i=0;i<count;i++)

		{

		CRulesCharacteristicsAndPluginName* temp=CRulesCharacteristicsAndPluginName::NewLC(aInterface);

		temp->InternalizeL(stream);

		aList.AppendL(temp);

		CleanupStack::Pop(temp); //temp

		}

	CleanupStack::PopAndDestroy(&rBuf);

	}

TInt CryptoSpiUtil::RetrieveCharacteristicsL(TInt32 aInterface, RDesReadStream& aStream, RBuf8& aBuf, TInt& aCount)

	{

	// first we are only trying to retrieve the length of the buffer

	TBuf8<sizeof(TInt32)> buf;

	TInt testResult = RProperty::Get(KCryptoSpiPropertyCat, aInterface, buf);

	if (testResult==KErrNotFound)

		{

		//run the exe to Publish the properties

		RunCryptoSpiPropertySetupExe();

		// testresult would be checked outside the loop

		testResult = RProperty::Get(KCryptoSpiPropertyCat, aInterface, buf);

		}

	// overflow will occur as we are only retrieving the length first.

	// any other error we should leave

	if(testResult != KErrOverflow)

		{

		User::LeaveIfError(testResult);

		}

	//read the length

	RDesReadStream rStream(buf);

	TInt32 len=rStream.ReadInt32L();

	//If the property is empty

	if (len<=4)

		{

		return len;

		}

	//Allocate memory 

	aBuf.CreateMaxL(len);

	User::LeaveIfError(RProperty::Get(KCryptoSpiPropertyCat, aInterface, aBuf));

	//Read the length

	aStream.Open(aBuf);

	len=aStream.ReadInt32L();

	//Read the count of the characteristics

	aCount=aStream.ReadInt16L();

	return len;	

	}

TInt CryptoSpiUtil::DllIndexToName(TInt aDllIndex, TFileName& aName)

	{

	TInt dllCount=0;

	TInt result = RProperty::Get(KCryptoSpiPropertyCat, KPluginsConfigurationKeyCount, dllCount);	

	if (result==KErrNotFound)

		{

		//run the exe to publish the properties

		RunCryptoSpiPropertySetupExe();

		result = RProperty::Get(KCryptoSpiPropertyCat, KPluginsConfigurationKeyCount, dllCount);

		if (result==KErrNotFound)

			{

			return KErrNotFound;

			}

		}

	if (aDllIndex>=dllCount)

		{

		return KErrNotFound;

		}

	TBuf8<KMaxFileName> buf;

	result = RProperty::Get(KCryptoSpiPropertyCat, KPluginsConfigurationKey+aDllIndex, buf);

	if (result==KErrNotFound)

		{

		return KErrNotFound;

		}

	RDesReadStream rStream(buf);

	rStream>>aName;

	return KErrNone;		

	}

void CryptoSpiUtil::LoadPluginDllLC(RLibrary& aLib, TFileName& aFileName)

	{

	User::LeaveIfError(aLib.Load(aFileName));

	CleanupClosePushL(aLib);

	RLibrary plugin=aLib;

	CleanupClosePushL(plugin);

	User::LeaveIfError(aLib.Duplicate(RThread(), EOwnerProcess));

	CleanupStack::PopAndDestroy(&plugin);		

	}

TInt CryptoSpiUtil::RunCryptoSpiPropertySetupExe()

	{

	const TUidType setupExeUidType(KExecutableImageUid, TUid::Null(), KCryptoSpiPropertyCat);

	RProcess setupProc;

	TInt result = setupProc.Create(KCryptoSpiPropertySetupExe, KNullDesC, setupExeUidType);

	if (result != KErrNone)

		{

		return result;

		}

	TRequestStatus setupStatus;

	// request Rendezvous before Resume() to avoid race condition.

	// Also note if request to rendezvous fails (OOM etc.) then setup exe may

	// complete after query code, with feature property possibly undefined

	setupProc.Rendezvous(setupStatus);

	setupProc.Resume();

	setupProc.Close();

	User::WaitForRequest(setupStatus);

	return setupStatus.Int();

	}

CCharacteristics* CryptoSpiUtil::CreateCharacteristicsL(TInt32 aInterface)

	{

	CCharacteristics* character=NULL;

	switch (aInterface)

		{

	case KHashInterface:

	case KAsyncHashInterface:

		character=CHashCharacteristics::NewL();

		break;

#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT				

	case KMacInterface:

	case KAsyncMacInterface:

		character=CMacCharacteristics::NewL();

		break;

#endif		

	case KRandomInterface:

	case KAsyncRandomInterface:

		character=CRandomCharacteristics::NewL();

		break;

	case KSymmetricCipherInterface:

	case KAsyncSymmetricCipherInterface:

		character=CSymmetricCipherCharacteristics::NewL();

		break;

	case KAsymmetricCipherInterface:

	case KAsyncAsymmetricCipherInterface:

		character=CAsymmetricCipherCharacteristics::NewL();

		break;

	case KSignerInterface:

	case KAsyncSignerInterface:

	case KVerifierInterface:

	case KAsyncVerifierInterface:

		character=CAsymmetricSignatureCharacteristics::NewL();

		break;

	case KKeyAgreementInterface:

	case KAsyncKeyAgreementInterface:

		character=CKeyAgreementCharacteristics::NewL();

		break;

	case KKeypairGeneratorInterface:

	case KAsyncKeypairGeneratorInterface:

		character=CKeypairGeneratorCharacteristics::NewL();

		break;

	default:

		User::Leave(KErrNotSupported);

		}

	return character;

	}