/*

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

* Rule-based plugin selector implementation

* Rule-based plugin selector implementation

*

*/

/**

 @file

*/

#include <cryptospi/ruleselector.h>

#include <cryptospi/cryptoparams.h>

#include "cryptospiutil.h"

#include <cryptospi/cryptohashapi.h>

#include <cryptospi/cryptorandomapi.h>

#include <cryptospi/pluginentrydef.h>

#include <cryptospi/hashplugin.h>

#include <cryptospi/randomplugin.h>

#include <cryptospi/cryptospidef.h>

#include "cryptospiproperty.h"

#include "rulecharacteristics.h"

#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT

	#include <cryptospi/cryptomacapi.h>

	#include <cryptospi/macplugin.h>

#endif

using namespace CryptoSpi;

//

// Implementation of a single selection rule content

//

EXPORT_C CSelectionRuleContent* CSelectionRuleContent::NewL(TUid aInterfaceScope,

															TUid aAlgorithmScope,

															CCryptoParam* aCharacteristicValue,

															TRuleOperator aOperator,

															TBool aIsOptional)

	{

	CSelectionRuleContent* self=new (ELeave) CSelectionRuleContent(aInterfaceScope,

																	aAlgorithmScope,

																	aCharacteristicValue,

																	aOperator,

																	aIsOptional);

	return self;

	}

EXPORT_C CSelectionRuleContent::~CSelectionRuleContent()

	{

	delete iCharacteristicValue;

	}

CSelectionRuleContent::CSelectionRuleContent(TUid aInterfaceScope,

											TUid aAlgorithmScope,

											CCryptoParam* aCharacteristicValue,

											TRuleOperator aOperator,

											TBool aIsOptional)

	:iInterfaceScope(aInterfaceScope),

	iAlgorithmScope(aAlgorithmScope),

	iCharacteristicValue(aCharacteristicValue),

	iOperator(aOperator),

	iIsOptional(aIsOptional)

	{

	}

TUid CSelectionRuleContent::GetInterfaceScope()

	{

	return iInterfaceScope;

	}

TUid CSelectionRuleContent::GetAlgorithmScope()

	{

	return iAlgorithmScope;

	}

TInt CSelectionRuleContent::GetOperator()

	{

	return iOperator;

	}

const CCryptoParam* CSelectionRuleContent::GetCharacteristicValue()

	{

	return iCharacteristicValue;

	}

TBool CSelectionRuleContent::IsOptionalRule()

	{

	return iIsOptional;

	}

//

// Impplemetation of selection rule

//

EXPORT_C CSelectionRules* CSelectionRules::NewL()

	{

	CSelectionRules* self=new (ELeave) CSelectionRules();

	return self;

	}

EXPORT_C CSelectionRules::~CSelectionRules()

	{

	iRules.ResetAndDestroy();

	}

EXPORT_C void CSelectionRules::AddSelectionRuleL(CSelectionRuleContent* aSelectionRule)

	{

	TUid charUid = aSelectionRule->GetCharacteristicValue()->Uid();

	TInt operator_r = aSelectionRule->GetOperator();

	TInt type = aSelectionRule->GetCharacteristicValue()->Type();

	switch (charUid.iUid)

		{

		case KInterfaceType:

		case KAlgorithmType:

		case KImplementationType:

			{

			if (type != CCryptoParam::EInt)

				{

				User::Leave(KErrArgument);

				}

			if (operator_r != EOpEqual &&

				operator_r != EOpNotEqual)

				{

				User::Leave(KErrArgument);

				}

			break;

			}

		case KCreatorNameType:

			{

			if (type != CCryptoParam::EDesC16)

				{

				User::Leave(KErrArgument);

				}

			if (operator_r != EOpAscendingSort &&

				operator_r != EOpDescendingSort &&

				operator_r != EOpEqual &&

				operator_r != EOpNotEqual)

				{

				User::Leave(KErrArgument);

				}

			break;

			}

		case KIsFIPSApprovedType:

		case KIsHardwareSupportedType:

			{

			if (type != CCryptoParam::EInt)

				{

				User::Leave(KErrArgument);

				}

			if (operator_r != EOpEqual &&

				operator_r != EOpNotEqual)

				{

				User::Leave(KErrArgument);

				}

			break;

			}

		case KMaxConcurrencySupportedType:

		case KLatencyType:

		case KThroughputType:

			{

			if (type != CCryptoParam::EInt)

				{

				User::Leave(KErrArgument);

				}

			break;

			}

		default:

			{

			break;

			}

		}//switch (charUid.iUid)

	iRules.AppendL(aSelectionRule);

	}

CSelectionRules::CSelectionRules()

	{

	}

RPointerArray<CSelectionRuleContent>& CSelectionRules::GetSelectionRules()

	{

	return iRules;

	}

//

// Implementation of plugin selector

//

EXPORT_C CRuleSelector* CRuleSelector::NewL(CSelectionRules* aRules)

	{

	CRuleSelector* self = CRuleSelector::NewLC(aRules);

	CleanupStack::Pop(self);

	return self;				

	}

EXPORT_C CRuleSelector* CRuleSelector::NewLC(CSelectionRules* aRules)

	{

	CRuleSelector* self=new (ELeave) CRuleSelector();

	CleanupStack::PushL(self);

	self->ConstructL(aRules);

	return self;

	}

EXPORT_C CRuleSelector::~CRuleSelector()

	{

	delete iSelectionRules;

	TInt interfaceCount = sizeof(KInterfacesUids)/sizeof(KInterfacesUids[0]);

	//Loop through each Interface

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

		{

		RPointerArray<CRulesCharacteristicsAndPluginName>** listA = iSelectedInterfaceCharacteristics_MapA.Find(KInterfacesUids[i].iUid);

		RPointerArray<CRulesCharacteristicsAndPluginName>** listB = iSelectedInterfaceCharacteristics_MapB.Find(KInterfacesUids[i].iUid);

		if (listA)

			{

			(*listA)->ResetAndDestroy();

			delete *listA;

			}

		if (listB)

			{

			(*listB)->ResetAndDestroy();

			delete *listB;

			}

		}

	iSelectedInterfaceCharacteristics_MapA.Close();

	iSelectedInterfaceCharacteristics_MapB.Close();

	iNextTryCharacteristicsIndex.Close();

	//Unload the plugin DLLs and release the array

	TInt dllCount=iPluginDllList.Count();

	for (TInt j=0;j<dllCount;j++)

		{

		iPluginDllList[j].Close();

		}

	iPluginDllList.Close();

	}

CRuleSelector::CRuleSelector():

	iUseMapAToFilter(ETrue),

	iToggleUseMap(ETrue)

	{

	}

void CRuleSelector::ConstructL(CSelectionRules* aRules)

	{

	ConstructMapAL();

	TInt interfaceCount = sizeof(KInterfacesUids)/sizeof(KInterfacesUids[0]);

	//Init the next index to try records

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

		{

		iNextTryCharacteristicsIndex.InsertL(KInterfacesUids[i].iUid, 0);

		}

	//Build iSelectedInterfaceCharacteristicsMap according to the rules applied

	PerformFilterL(aRules);

	if (iUseMapAToFilter)

		{

		//NOTE: After each filtering, it will toggle the iUseMapAToFilter for next process

		//Set iActiveInterfaceCharacteristics_Map to use iSelectedInterfaceCharacteristicsMap

		iActiveInterfaceCharacteristics_Map = &iSelectedInterfaceCharacteristics_MapA;

		}

	else

		{

		//Set iActiveInterfaceCharacteristics_Map to use iSelectedInterfaceCharacteristics_MapB

		iActiveInterfaceCharacteristics_Map = &iSelectedInterfaceCharacteristics_MapB;

		}

	iSelectionRules = aRules;

	}

void CRuleSelector::CreateHashL(CHash*& aHash,

								TUid aAlgorithmUid,

								TUid aOperationMode,

								const CKey* aKey,

								const CCryptoParams* aAlgorithmParams)

	{

	TInt found=KErrNone;

	TInt ret=KErrNone;

	SetSearchRecord(KHashInterfaceUid, 0);

	do 

		{

		TUid implUid={0};

		TFileName fileName;

		found=FindPlugin(KHashInterfaceUid, aAlgorithmUid, implUid, fileName);

		if (found==KErrNone)

			{

			//Load the dll and make the handle be sharable in the process

			RLibrary sharedLib;

			CryptoSpiUtil::LoadPluginDllLC(sharedLib, fileName);

			//look for the entry point

			CreateHashFuncL func=(CreateHashFuncL)sharedLib.Lookup(ECreateHashOrdinal);

			if (func)

				{

				//create the plugin

				MHash* hashPlugin=NULL;

				TRAP(ret, (func)(hashPlugin, implUid, aOperationMode, aKey, aAlgorithmParams))

				if (ret!=KErrNone)

					{

					if (ret==KErrNoMemory)

						{

						User::Leave(ret);	

						}

					CleanupStack::PopAndDestroy(&sharedLib); //sharedLib

					}

				else

					{

					CleanupClosePushL(*hashPlugin);

					aHash=CHash::NewL(hashPlugin, sharedLib.Handle());

					CleanupStack::Pop(2, &sharedLib); //hashPlugin, sharedLib

					break;

					}

				}

			else

				{

				CleanupStack::PopAndDestroy(&sharedLib); //sharedLib	

				}

			}

		}

	while (found!=KErrNotFound);

	User::LeaveIfError(ret);

	if (found!=KErrNone)

		{

		User::Leave(KErrNotSupported);

		}

	}

#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT

void CRuleSelector::CreateHashL(CHash*& aHash,

								TUid aAlgorithmUid,

								const CCryptoParams* aAlgorithmParams)

	{

	TInt found=KErrNone;

	TInt ret=KErrNone;

	SetSearchRecord(KHashInterfaceUid, 0);

	do 

		{

		TUid implUid={0};

		TFileName fileName;

		found=FindPlugin(KHashInterfaceUid, aAlgorithmUid, implUid, fileName);

		if (found==KErrNone)

			{

			//Load the dll and make the handle be sharable in the process

			RLibrary sharedLib;

			CryptoSpiUtil::LoadPluginDllLC(sharedLib, fileName);

			//look for the entry point

			CreateHashFuncLv2 func=(CreateHashFuncLv2)sharedLib.Lookup(ECreateHashOrdinalv2);

			if (func)

				{

				//create the plugin

				MHash* hashPlugin=NULL;

				TRAP(ret, (func)(hashPlugin, implUid, aAlgorithmParams))

				if (ret!=KErrNone)

					{

					if (ret==KErrNoMemory)

						{

						User::Leave(ret);	

						}

					CleanupStack::PopAndDestroy(&sharedLib); //sharedLib

					}

				else

					{

					CleanupClosePushL(*hashPlugin);

					aHash=CHash::NewL(hashPlugin, sharedLib.Handle());

					CleanupStack::Pop(2, &sharedLib); //hashPlugin, sharedLib

					break;

					}

				}

			else

				{

				CleanupStack::PopAndDestroy(&sharedLib); //sharedLib	

				}

			}

		}

	while (found!=KErrNotFound);

	User::LeaveIfError(ret);

	if (found!=KErrNone)

		{

		User::Leave(KErrNotSupported);

		}

	}

void CRuleSelector::CreateMacL(CMac*& aMac, const TUid aAlgorithmUid, const CKey& aKey, const CCryptoParams* aAlgorithmParams)

	{

	TInt found=KErrNone;

	TInt ret=KErrNone;

	/**

	 * Reset the search record for the mentioned interface, so that search can start from

	 * index 0.

	 */

	SetSearchRecord(KMacInterfaceUid, 0);

	/**

	 * The following do-while block is a serach mechanism for the right algorithm implementation.

	 * The block logic assumes the case when a user may define a very abstract level rule for 

	 * which there is several matches within an interface and across the interfaces meeting the 

	 * rule (both intra and inter interface match).

	 * The block logic has support to counter attack the ambiguity passed on by the 

	 * user application when defining the rules for the rule based selector.   

	 */

	do 

		{

		TUid implUid={0};

		TFileName fileName;

		/**

		 * Here 'aAlgorithmUid' can be Hash Based or Cipher Based. 

		 * KAlgorithmCipherAesXcbcMac96, KAlgorithmCipherAesXcbcPrf128, KAlgorithmHashMd2 

		 * etc...

		 */

		found=FindPlugin(KMacInterfaceUid, aAlgorithmUid, implUid, fileName);

		if (found==KErrNone)

			{

			//Load the dll and make the handle be sharable in the process

			RLibrary sharedLib;

			CryptoSpiUtil::LoadPluginDllLC(sharedLib, fileName);

			//look for the entry point in the plugin-dll.

			CreateMacFuncL func=(CreateMacFuncL)sharedLib.Lookup(ECreateMacOrdinal);

			if (func)

				{

				/** 

				 * The abstract base class interface to which the MAC implementation

				 * will be plugged in.  

				 */

				MMac* macPlugin=NULL;

				/**

				 * Here 'implUid' will contain the implementation of the Hash Based or

				 * Cipher Base algorithm (aAlgorithmUid) chosen by rule based selector.

				 * One Algorithm can have various implementations provided by different vendors.

				 * The choice of selection of the implementation will be dependent on the rule defined

				 * by the user application which is passed to the rule based selector when initializing.

				 * 

				 * KCryptoPluginMacAesXcbcMac96, KCryptoPluginMacAesXcbcPrf128, KCryptoPluginMacHashMd2

				 * etc... 

				 */

				TRAP(ret, (func)(macPlugin, implUid, aKey, aAlgorithmParams))

				if (ret!=KErrNone)

					{

					if (ret==KErrNoMemory)

						{

						User::Leave(ret);	

						}

					CleanupStack::PopAndDestroy(&sharedLib); //sharedLib

					}

				else

					{

					CleanupClosePushL(*macPlugin);

					/**

					 * Here an empty 'aMac' pointer delegated by the user application to the 

					 * CryptoSpi Framework is filled by the rule based selector.

					 * Rule Based selector is part of the framework.

					 */

					aMac=CMac::NewL(macPlugin, sharedLib.Handle());

					CleanupStack::Pop(2, &sharedLib); //macPlugin, sharedLib

					break;