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


/**
 @file
 @internalTechnology
*/
 
#include "plugincharschecker.h"

using namespace CryptoSpi;

CPluginCharsChecker::~CPluginCharsChecker()
	{
	}

CPluginCharsChecker::CPluginCharsChecker()
	{
	}
	
CPluginCharsChecker* CPluginCharsChecker::NewL()
	{
	CPluginCharsChecker* me = CPluginCharsChecker::NewLC();
	CleanupStack::Pop(me);
	return me;
	}
	
CPluginCharsChecker* CPluginCharsChecker::NewLC()
	{
	CPluginCharsChecker* me = new(ELeave) CPluginCharsChecker();
	CleanupStack::PushL(me);
	return me;
	}
	
	
TBool CPluginCharsChecker::checkCommonCharacteristics(const TCommonCharacteristics* aCharacteristics,
												TVariantPtrC aInterfaceUid,
												TVariantPtrC aAlgorithmUid,
												TVariantPtrC aImplementationUid,
												TVariantPtrC aCreatorName,
												TBool aFIPSApproved,
												TBool aHardwareSupported,
												TInt aMaxConcurrencySupported,
												TVariantPtrC aAlgorithmName,
												TInt aLatency,
												TInt aThroughput,
												TPtrC& aErrorMessage)
	{
	TBool result = ETrue;
	
	TRomLitC16 creatorName = *(aCharacteristics->iCreatorName);
	TRomLitC16 algorithmName = *(aCharacteristics->iAlgorithmName);
	
	if(!(aCharacteristics->iInterfaceUID == aInterfaceUid))
		{
		aErrorMessage.Set(_L("COMMON_INTERFACE_ID"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iAlgorithmUID == aAlgorithmUid))
		{
		aErrorMessage.Set(_L("COMMON_ALGORITHM_ID"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iImplementationUID == aImplementationUid))
		{
		aErrorMessage.Set(_L("COMMON_IMPLEMENTATION_ID"));
		result = EFalse;
		}
		
	if(!(*creatorName == *(static_cast<TRomLitC16>(aCreatorName))))
		{
		aErrorMessage.Set(_L("COMMON_CREATOR_NAME"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iIsFIPSApproved == aFIPSApproved)) 
		{
		aErrorMessage.Set(_L("COMMON_FIPS_APPROVED"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iIsHardwareSupported == aHardwareSupported))
		{
		aErrorMessage.Set(_L("COMMON_HARDWARE_SUPPORTED"));
		result = EFalse;
		}
	
	if(!(aCharacteristics->iMaxConcurrencySupported == aMaxConcurrencySupported))
		{
		aErrorMessage.Set(_L("COMMON_MAXIMUM_CONCURRENCY"));
		result = EFalse;	
		}
	
	if(!(*algorithmName == *(static_cast<TRomLitC16>(aAlgorithmName))))
		{
		aErrorMessage.Set(_L("COMMON_ALGORITHM_NAME"));
		result = EFalse;
		}
	
	if(!(aCharacteristics->iLatency == aLatency))
		{
		aErrorMessage.Set(_L("COMMON_LATENCY"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iThroughput == aThroughput))
		{	
		aErrorMessage.Set(_L("COMMON_THROUGHPUT"));
		result = EFalse;
		}
										
	return result;	
	}
	
	
TBool CPluginCharsChecker::checkSymmetricCharacteristics(const TSymmetricCipherCharacteristics* aCharacteristics,
												TInt aSymmetricMaxKeyLength,
												TInt aSymmetricBlockSize,
												TVariantPtrC aSymmetricPaddingModes,
												TInt aSymmetricPaddingModeNum,
												TVariantPtrC aSymmetricOperationModes,
												TInt aSymmetricOperationModeNum,
												TInt aSymmetricKeySupportMode,
												TPtrC& aErrorMessage)
	{
	TBool result = ETrue;
	
	TInt32 supportedPaddingModes = *(aCharacteristics->iSupportedPaddingModes);
	TInt32 supportedOperationModes = *(aCharacteristics->iSupportedOperationModes);
	
	if(!(aCharacteristics->iMaximumKeyLength == aSymmetricMaxKeyLength)) 
		{
		aErrorMessage.Set(_L("SYMMETRIC_MAXIMUM_KEY_LENGTH"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iBlockSize == aSymmetricBlockSize))
		{
		aErrorMessage.Set(_L("SYMMETRIC_BLOCK_SIZE"));
		result = EFalse;
		}
	
	if(!(supportedPaddingModes == *(static_cast<const TInt32*>(aSymmetricPaddingModes))))
		{
		aErrorMessage.Set(_L("SYMMETRIC_SUPPORTED_PADDING_MODES"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iPaddingModeNum == aSymmetricPaddingModeNum))
		{
		aErrorMessage.Set(_L("SYMMETRIC_PADDING_MODE_NUM"));
		result = EFalse;
		}
		
	if(!(supportedOperationModes == *(static_cast<const TInt32*>(aSymmetricOperationModes)))) 
		{
		aErrorMessage.Set(_L("SYMMETRIC_OPERATION_MODES"));
		result = EFalse;
		}
						
	if(!(aCharacteristics->iOperationModeNum == aSymmetricOperationModeNum))
		{
		aErrorMessage.Set(_L("SYMMETRIC_OPERATION_MODE_NUM"));
		result = EFalse;
		}
	
	if(!(aCharacteristics->iKeySupportMode == aSymmetricKeySupportMode))
		{
		aErrorMessage.Set(_L("SYMMETRIC_KEY_SUPPORT_MODE"));
		result = EFalse;
		}
		
	return result;	
	}

	
TBool CPluginCharsChecker::checkAsymmetricCharacteristics(const TAsymmetricCipherCharacteristics* aCharacteristics,
													TInt aAsymmetricMaxKeyLength,
													TVariantPtrC aAsymmetricPaddingModes,
													TInt aAsymmetricPaddingModeNum,
													TInt aAsymmetricKeySupportMode,
													TPtrC& aErrorMessage)
	{
	TBool result = ETrue;
	
	TInt32 supportedPaddingModes = *(aCharacteristics->iSupportedPaddingModes);
	
	if(!(aCharacteristics->iMaximumKeyLength == aAsymmetricMaxKeyLength)) 
		{
		aErrorMessage.Set(_L("ASYMMETRIC_MAXIMUM_KEY_LENGTH"));
		result = EFalse;
		}
		
	if(!(supportedPaddingModes == *(static_cast<const TInt32*>(aAsymmetricPaddingModes))))
		{
		aErrorMessage.Set(_L("ASYMMETRIC_SUPPORTED_PADDING_MODES"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iPaddingModeNum == aAsymmetricPaddingModeNum))
		{
		aErrorMessage.Set(_L("ASYMMETRIC_PADDING_MODE_NUM"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iKeySupportMode == aAsymmetricKeySupportMode))
		{	
		aErrorMessage.Set(_L("ASYMMETRIC_KEY_SUPPORT_MODE"));
		result = EFalse;
		}
	
	return result;	
	}
	
	
TBool CPluginCharsChecker::checkHashCharacteristics(const THashCharacteristics* aCharacteristics,
													TInt aBlockSize,
													TInt aOutputSize,
													TVariantPtrC aHashOperationModes,
													TInt aHashOperationModeNum,
													TPtrC& aErrorMessage)
	{
	TBool result = ETrue;
	
	TInt32 supportedOperationModes = *(aCharacteristics->iSupportedOperationModes);

	if(!(aCharacteristics->iBlockSize == aBlockSize)) 
		{
		aErrorMessage.Set(_L("HASH_BLOCK_SIZE"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iOutputSize == aOutputSize))
		{
		aErrorMessage.Set(_L("HASH_OUTPUT_SIZE"));
		result = EFalse;
		}
		
	if(!(supportedOperationModes == *(static_cast<const TInt32*>(aHashOperationModes)))) 
		{
		aErrorMessage.Set(_L("HASH_SUPPORTED_OPERATION_MODES"));
		result = EFalse;	
		}
		
	if(!(aCharacteristics->iOperationModeNum == aHashOperationModeNum))
		{
		aErrorMessage.Set(_L("HASH_OPERATION_MODE_NUM"));
		result = EFalse;	
		}
	
	return result;
	}
	
#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
TBool CPluginCharsChecker::checkMacCharacteristics(const TMacCharacteristics* aCharacteristics,
													TVariantPtrC aMacMode,
													TPtrC& aErrorMessage)
	{
	TBool result = ETrue;

	if(!(aCharacteristics->iMacMode == aMacMode)) 
		{
		aErrorMessage.Set(_L("MAC_MODE"));
		result = EFalse;
		}
		
	return result;
	}
#endif

TBool CPluginCharsChecker::checkRandomCharacteristics(const TRandomCharacteristics* aCharacteristics,
														TInt aRandomBlockingMode,
														TPtrC& aErrorMessage)
	{
	TBool result = ETrue;
	
	if(!(aCharacteristics->iBlockingMode == aRandomBlockingMode)) 
		{
		aErrorMessage.Set(_L("RANDOM_BLOCKING_MODE"));
		result = EFalse;
		}
		
	return result;	
	}
	

TBool CPluginCharsChecker::checkAsymSignatureCharacteristics(const TAsymmetricSignatureCharacteristics* aCharacteristics,
															TInt aAsymSignMaxKeyLength,
															TVariantPtrC aAsymSignPaddingModes,
															TInt aAsymSignPaddingModeNum,
															TInt aAsymSignKeySupportMode,
															TPtrC& aErrorMessage)
	{
	TBool result = ETrue;
	
	TInt32 supportedPaddingModes = *(aCharacteristics->iSupportedPaddingModes);
	
	if(!(aCharacteristics->iMaximumKeyLength == aAsymSignMaxKeyLength)) 
		{
		aErrorMessage.Set(_L("ASYMSIGN_MAXIMUM_KEY_LENGTH"));
		result = EFalse;
		}
		
	if(!(supportedPaddingModes == *(static_cast<const TInt32*>(aAsymSignPaddingModes))))
		{
		aErrorMessage.Set(_L("ASYMSIGN_SUPPORTED_PADDING_MODES"));
		result = EFalse;
		}
		
	if(!(aCharacteristics->iPaddingModeNum == aAsymSignPaddingModeNum))
		{
		aErrorMessage.Set(_L("ASYMSIGN_PADDING_MODE_NUM"));
		result = EFalse;
		}

	if(!(aCharacteristics->iKeySupportMode == aAsymSignKeySupportMode))
		{
		aErrorMessage.Set(_L("ASYMSIGN_KEY_SUPPORT_MODE"));
		result = EFalse;
		}
		
	return result;	
	}
	
TBool CPluginCharsChecker::checkAsymKeypairGenCharacteristics(const CryptoSpi::TAsymmetricKeypairGeneratorCharacteristics* aCharacteristics,
																TInt aAsymKeypairGenMaxKeyLength,
																TPtrC& aErrorMessage)
	{
	TBool result = ETrue;
	
	if(!(aCharacteristics->iMaximumKeyLength == aAsymKeypairGenMaxKeyLength)) 
		{
		aErrorMessage.Set(_L("ASYMKEYPAIRGEN_MAX_KEY_LENGTH"));
		result = EFalse;
		}
		
	return result;
	}	

TBool CPluginCharsChecker::checkSelectedPlugin(const TCharacteristics* aCharacteristics,
												TVariantPtrC aAlgorithmUid,
												TVariantPtrC aImplementationUid,
												TPtrC& aErrorMessage)
	{
	TBool result = ETrue;
	
	const TCommonCharacteristics* commonChars = static_cast<const TCommonCharacteristics*>(aCharacteristics);
	
	if(!(commonChars->iAlgorithmUID == aAlgorithmUid))   
		{
		aErrorMessage.Set(_L("COMMON_ALGORITHM_ID"));
		result = EFalse;
		}
		
	if(!(commonChars->iImplementationUID == aImplementationUid))
		{
		aErrorMessage.Set(_L("COMMON_IMPLEMENTATION_ID"));
		result = EFalse;	
		}	
	
	return result;	
	}