/*
* Copyright (c) 2007-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: 
* crypto plugins loader implementation
* crypto spi state implementation
*
*/


/**
 @file
*/

#include <cryptospi/cryptocharacteristics.h>
#include <cryptospi/cryptospidef.h>
#include "cryptospiutil.h"
#include <cryptospi/extendedcharacteristics.h>


using namespace CryptoSpi;


//
// Implementation of CCharacteristics
//
CCharacteristics::CCharacteristics()
	{
	}
	
CCharacteristics::~CCharacteristics()
	{
	iCreatorName.Close();
	iAlgorithmName.Close();
	}
	
void CCharacteristics::InternalizeL(RReadStream& aStream)
	{
	iInterfaceUid=aStream.ReadInt32L();
	iAlgorithmUid=aStream.ReadInt32L();
	iImplementationUid=aStream.ReadInt32L();
	iCreatorName.CreateL(aStream, KMaxFileName);
	iIsFIPSApproved=aStream.ReadInt8L();
	iIsHardwareSupported=aStream.ReadInt8L();
	iMaxConcurrencySupported=aStream.ReadUint32L();
	iAlgorithmName.CreateL(aStream, KMaxFileName);
	iLatency=aStream.ReadInt32L();
	iThroughput=aStream.ReadInt32L();
	}

//
// Implementation of CHashCharacteristics
//
CHashCharacteristics* CHashCharacteristics::NewL()
	{
	CHashCharacteristics* self=CHashCharacteristics::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CHashCharacteristics* CHashCharacteristics::NewLC()
	{
	CHashCharacteristics* self=new(ELeave) CHashCharacteristics();
	CleanupStack::PushL(self);
	return self;
	}

CHashCharacteristics::~CHashCharacteristics()
	{
	iSupportedOperationModes.Close();
	}

CHashCharacteristics::CHashCharacteristics()
	{
	}

void CHashCharacteristics::InternalizeL(RReadStream& aStream)
	{
	CCharacteristics::InternalizeL(aStream);
	iBlockSize=aStream.ReadUint32L();
	iOutputSize=aStream.ReadUint32L();
	TUint32 count=aStream.ReadUint32L();
	for (TUint i=0;i<count;i++)
		{
		TInt32 mode=aStream.ReadInt32L();
		iSupportedOperationModes.AppendL(mode);
		}
	}

TBool CHashCharacteristics::IsOperationModeSupported(TUid aOperationMode) const	
	{
	// Sanity check to catch incorrect casts of characteristics classes
	ASSERT(iInterfaceUid == KHashInterface);
	
	TInt count(iSupportedOperationModes.Count());
	TBool supported(EFalse);
	
	for (TInt i = 0; i < count; ++i)
		{
		if (iSupportedOperationModes[i] == aOperationMode.iUid)
			{
			supported = ETrue;
			break;
			}
		}
		
	return supported;
	}

#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT		
//
// Implementation of CMacCharacteristics
//
CMacCharacteristics* CMacCharacteristics::NewL()
	{
	CMacCharacteristics* self=CMacCharacteristics::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CMacCharacteristics* CMacCharacteristics::NewLC()
	{
	CMacCharacteristics* self=new(ELeave) CMacCharacteristics();
	CleanupStack::PushL(self);
	return self;
	}

CMacCharacteristics::~CMacCharacteristics()
	{
	delete iAlgorithmChar;
	}

CMacCharacteristics::CMacCharacteristics()
	{
	}

void CMacCharacteristics::InternalizeL(RReadStream& aStream)
	{
	CCharacteristics::InternalizeL(aStream);
	iMacMode = aStream.ReadUint32L();
	if(iMacMode == KHmacMode)
		{
		iAlgorithmChar = CHashCharacteristics::NewL();
		}
	else if (iMacMode == KSymmetricCipherMode)
		{
		iAlgorithmChar = CSymmetricCipherCharacteristics::NewL();
		}
	User::LeaveIfNull(iAlgorithmChar);
	iAlgorithmChar->InternalizeL(aStream);
	}
#endif
//
// Implementation of CRandomCharacteristics
//
CRandomCharacteristics* CRandomCharacteristics::NewL()
	{
	CRandomCharacteristics* self=CRandomCharacteristics::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CRandomCharacteristics* CRandomCharacteristics::NewLC()
	{
	CRandomCharacteristics* self=new(ELeave) CRandomCharacteristics();
	CleanupStack::PushL(self);
	return self;
	}

CRandomCharacteristics::~CRandomCharacteristics()
	{
	}

CRandomCharacteristics::CRandomCharacteristics()
	{
	}

void CRandomCharacteristics::InternalizeL(RReadStream& aStream)
	{
	CCharacteristics::InternalizeL(aStream);
	iBlockingMode=aStream.ReadUint32L();
	}
	
//
// Implementation of CSymmetricCipherCharacteristics
//
CSymmetricCipherCharacteristics* CSymmetricCipherCharacteristics::NewL()
	{
	CSymmetricCipherCharacteristics* self=CSymmetricCipherCharacteristics::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CSymmetricCipherCharacteristics* CSymmetricCipherCharacteristics::NewLC()
	{
	CSymmetricCipherCharacteristics* self=new(ELeave) CSymmetricCipherCharacteristics();
	CleanupStack::PushL(self);
	return self;
	}

CSymmetricCipherCharacteristics::~CSymmetricCipherCharacteristics()
	{
	iSupportedPaddingModes.Close();
	iSupportedOperationModes.Close();
	}

CSymmetricCipherCharacteristics::CSymmetricCipherCharacteristics()
	{
	}

void CSymmetricCipherCharacteristics::InternalizeL(RReadStream& aStream)
	{
	CCharacteristics::InternalizeL(aStream);
	iMaximumKeyLength=aStream.ReadUint32L();
	iBlockSize=aStream.ReadUint32L();
	TUint32 count=aStream.ReadUint32L();
	for (TUint i=0;i<count;i++)
		{
		TInt32 mode=aStream.ReadInt32L();
		iSupportedPaddingModes.AppendL(mode);
		}
	
	count=aStream.ReadUint32L();
	for (TUint j=0;j<count;j++)
		{
		TInt32 mode=aStream.ReadInt32L();
		iSupportedOperationModes.AppendL(mode);
		}
	iKeySupportMode=aStream.ReadInt32L();
	}

TBool CSymmetricCipherCharacteristics::IsOperationModeSupported(TUid aOperationMode) const
	{
	// Sanity check to catch incorrect casts of characteristics classes
	ASSERT(iInterfaceUid == KSymmetricCipherInterface);
	
	TBool supported(EFalse);
	TInt count(iSupportedOperationModes.Count());

	for (TInt i = 0; i < count; ++i)
		{
		if (iSupportedOperationModes[i] == aOperationMode.iUid)
			{
			supported = ETrue;
			break;
			}
		}
	return supported;
	}

TBool CSymmetricCipherCharacteristics::IsPaddingModeSupported(TUid aPaddingMode) const	
	{
	// Sanity check to catch incorrect casts of characteristics classes
	ASSERT(iInterfaceUid == KSymmetricCipherInterface);
	
	TBool supported(EFalse);
	TInt count(iSupportedPaddingModes.Count());
	
	for (TInt i = 0; i < count; ++i)
		{
		if (iSupportedPaddingModes[i] == aPaddingMode.iUid)
			{
			supported = ETrue;
			break;
			}
		}
	return supported;		
	}
	
//
// Implementation of CAsymmetricCipherCharacteristics
//		
CAsymmetricCipherCharacteristics* CAsymmetricCipherCharacteristics::NewL()
	{
	CAsymmetricCipherCharacteristics* self=CAsymmetricCipherCharacteristics::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CAsymmetricCipherCharacteristics* CAsymmetricCipherCharacteristics::NewLC()
	{
	CAsymmetricCipherCharacteristics* self=new(ELeave) CAsymmetricCipherCharacteristics();
	CleanupStack::PushL(self);
	return self;
	}

CAsymmetricCipherCharacteristics::~CAsymmetricCipherCharacteristics()
	{
	iSupportedPaddingModes.Close();
	}

CAsymmetricCipherCharacteristics::CAsymmetricCipherCharacteristics()
	{
	}

void CAsymmetricCipherCharacteristics::InternalizeL(RReadStream& aStream)
	{
	CCharacteristics::InternalizeL(aStream);
	iMaximumKeyLength=aStream.ReadUint32L();
	TUint32 count=aStream.ReadUint32L();
	
	for (TUint i=0;i<count;i++)
		{
		TInt32 mode=aStream.ReadInt32L();
		iSupportedPaddingModes.AppendL(mode);
		}
	iKeySupportMode=aStream.ReadInt32L();
	}
		
TBool CAsymmetricCipherCharacteristics::IsPaddingModeSupported(TUid aPaddingMode) const	
	{
	// Sanity check to catch incorrect casts of characteristics classes
	ASSERT(iInterfaceUid == KAsymmetricCipherInterface);
	
	TBool supported(EFalse);
	TInt count(iSupportedPaddingModes.Count());
	
	for (TInt i = 0; i < count; ++i)
		{
		if (iSupportedPaddingModes[i] == aPaddingMode.iUid)
			{
			supported = ETrue;
			break;
			}
		}
	return supported;
	}
		
//
// Implementation of CAsymmetricSignatureCharacteristics
//
CAsymmetricSignatureCharacteristics* CAsymmetricSignatureCharacteristics::NewL()
	{
	CAsymmetricSignatureCharacteristics* self=CAsymmetricSignatureCharacteristics::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CAsymmetricSignatureCharacteristics* CAsymmetricSignatureCharacteristics::NewLC()
	{
	CAsymmetricSignatureCharacteristics* self=new(ELeave) CAsymmetricSignatureCharacteristics();
	CleanupStack::PushL(self);
	return self;
	}

CAsymmetricSignatureCharacteristics::~CAsymmetricSignatureCharacteristics()
	{
	iSupportedPaddingModes.Close();
	}

CAsymmetricSignatureCharacteristics::CAsymmetricSignatureCharacteristics()
	{
	}

void CAsymmetricSignatureCharacteristics::InternalizeL(RReadStream& aStream)
	{
	CCharacteristics::InternalizeL(aStream);
	iMaximumKeyLength=aStream.ReadUint32L();
	TUint32 count=aStream.ReadUint32L();
	for (TUint i=0;i<count;i++)
		{
		TInt32 mode=aStream.ReadInt32L();
		iSupportedPaddingModes.AppendL(mode);
		}
	iKeySupportMode=aStream.ReadInt32L();
	}

TBool CAsymmetricSignatureCharacteristics::IsPaddingModeSupported(TUid aPaddingMode) const	
	{
	// Sanity check to catch incorrect casts of characteristics classes
	ASSERT(iInterfaceUid == KSignerInterface || iInterfaceUid == KVerifierInterface);
	
	TBool supported(EFalse);
	TInt count(iSupportedPaddingModes.Count());

	for (TInt i = 0; i < count; ++i)
		{
		if (iSupportedPaddingModes[i] == aPaddingMode.iUid)
			{
			supported = ETrue;
			break;
			}
		}
	return supported;		
	}
	
//
// Implementation of CKeyAgreementCharacteristics
//
CKeyAgreementCharacteristics* CKeyAgreementCharacteristics::NewL()
	{
	CKeyAgreementCharacteristics* self=CKeyAgreementCharacteristics::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CKeyAgreementCharacteristics* CKeyAgreementCharacteristics::NewLC()
	{
	CKeyAgreementCharacteristics* self=new(ELeave) CKeyAgreementCharacteristics();
	CleanupStack::PushL(self);
	return self;
	}

CKeyAgreementCharacteristics::~CKeyAgreementCharacteristics()
	{
	}

CKeyAgreementCharacteristics::CKeyAgreementCharacteristics()
	{
	}

void CKeyAgreementCharacteristics::InternalizeL(RReadStream& aStream)
	{
	CCharacteristics::InternalizeL(aStream);
	}
	
//
// Implementation of CKeypairGeneratorCharacteristics
//
CKeypairGeneratorCharacteristics* CKeypairGeneratorCharacteristics::NewL()
	{
	CKeypairGeneratorCharacteristics* self=CKeypairGeneratorCharacteristics::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

CKeypairGeneratorCharacteristics* CKeypairGeneratorCharacteristics::NewLC()
	{
	CKeypairGeneratorCharacteristics* self=new(ELeave) CKeypairGeneratorCharacteristics();
	CleanupStack::PushL(self);
	return self;
	}

CKeypairGeneratorCharacteristics::~CKeypairGeneratorCharacteristics()
	{
	}

CKeypairGeneratorCharacteristics::CKeypairGeneratorCharacteristics()
	{
	}

void CKeypairGeneratorCharacteristics::InternalizeL(RReadStream& aStream)
	{
	CCharacteristics::InternalizeL(aStream);
	iMaximumKeyLength=aStream.ReadUint32L();
	}

//
// Implementation of CCharacteristicsAndPluginName
//
CCharacteristicsAndPluginName* CCharacteristicsAndPluginName::NewL(TInt32 aInterface)
	{
	CCharacteristicsAndPluginName* self=CCharacteristicsAndPluginName::NewLC(aInterface);
	CleanupStack::Pop(self);
	return self;		
	}

CCharacteristicsAndPluginName* CCharacteristicsAndPluginName::NewLC(TInt32 aInterface)
	{
	CCharacteristicsAndPluginName* self=new(ELeave) CCharacteristicsAndPluginName();
	CleanupStack::PushL(self);
	self->ConstructL(aInterface);
	return self;		
	}
	
CCharacteristicsAndPluginName::CCharacteristicsAndPluginName()
	{
	}

CCharacteristicsAndPluginName::~CCharacteristicsAndPluginName()
	{
	delete iCharacteristic;
	if (iExtendedCharacteristic)
		{
		delete iExtendedCharacteristic;	
		}
	}

void CCharacteristicsAndPluginName::ConstructL(TInt32 aInterface)
	{
	iCharacteristic=CryptoSpiUtil::CreateCharacteristicsL(aInterface);
	}

void CCharacteristicsAndPluginName::InternalizeL(RReadStream& aStream)
	{
	iCharacteristic->InternalizeL(aStream);
	TInt index=aStream.ReadInt8L();
	CryptoSpiUtil::DllIndexToName(index, iDllName);
	}