/*

 * Copyright (c) 2008-2010 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 "plugincharsmacstep.h"

 #include "plugincharschecker.h"

 #include <cryptospi/cryptomacapi.h>

 #include <cryptospi/keys.h>

 using namespace CryptoSpi;

 CPluginCharsMacStep::~CPluginCharsMacStep()

 	{

 	}

 CPluginCharsMacStep::CPluginCharsMacStep()

 	{

 	SetTestStepName(KPluginCharsMacStep);

 	}

 TVerdict CPluginCharsMacStep::doTestStepPreambleL()

 	{

 	SetTestStepResult(EPass);

 	return TestStepResult();

 	}

 TVerdict CPluginCharsMacStep::doTestStepL()

 	{

 	INFO_PRINTF1(_L("Plugin Characteristics - Mac Chracteristics"));

 	INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());

 	if (TestStepResult()==EPass)

 		{

 		//Assume failure, unless all is successful

 		SetTestStepResult(EFail);

 		TVariantPtrC algorithmUid;

 		TPtrC encryptKey;

 		TVariantPtrC keyType;

 		//Each of the individual parameters required to create the Mac object

 		//are read in from the specified INI configuration file	

 		if (!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||

 			!GetStringFromConfig(ConfigSection(),KConfigEncryptKey,encryptKey) ||

 			!GetStringFromConfig(ConfigSection(),KConfigEncryptKeyType,keyType))

 			{

 			ERR_PRINTF1(_L("** .INI Error: Mac Arguments Not Located **"));

 			SetTestStepResult(EFail);

 			}

 		else

 			{

 			CMac* macImpl = NULL;

 			//Convert encryption key to an 8 Bit Descriptor

 			HBufC8* keyStr = HBufC8::NewLC(encryptKey.Length());

 			TPtr8 keyStrPtr = keyStr->Des();

 			keyStrPtr.Copy(encryptKey);

 			//Create an new CryptoParams object to encapsulate the key type and secret key string

 			CCryptoParams* keyParams = CCryptoParams::NewL();

 			CleanupStack::PushL(keyParams);

 			keyParams->AddL(*keyStr,keyType);

 			//Create Key Object

 			TKeyProperty keyProperty;

 			CKey* key=CKey::NewL(keyProperty,*keyParams);

 			CleanupStack::PushL(key);

 			TRAPD_LOG(err,CMacFactory::CreateMacL(macImpl,

 													algorithmUid,

 													*key,

 													NULL));

 			if (err != KErrNone)

 				{

 				delete macImpl;

 				ERR_PRINTF2(_L("*** FAIL: Failed to Create Mac Object - %d ***"), err);

 				User::Leave(err);

 				}

 			CleanupStack::PushL(macImpl);

 			INFO_PRINTF1(_L("** Successfully Loaded Mac Object **"));

 			//Define a pointer of type TCharacteristics in order to store the hash

 			//cryptographic object's characterisctics	

 			const TCharacteristics* chars(NULL);

 			//Retrieve the characteristics for the hash implementation object

 			TRAP_LOG(err, macImpl->GetCharacteristicsL(chars));

 			//Static cast the characteristics to type TMacCharacteristics

 			const TMacCharacteristics* macChars = static_cast<const TMacCharacteristics*>(chars);

 			//Retrieve all the Common characteristics that are required for all test cases

 			TVariantPtrC exInterfaceUid;

 			TVariantPtrC exAlgorithmUid;

 			TVariantPtrC exImplementationUid;

 			TVariantPtrC exCreatorName;

 			TBool exFIPSApproved;

 			TBool exHardwareSupported;

 			TInt exMaxConcurrencySupported;

 			TVariantPtrC exAlgorithmName;

 			TInt exLatency;

 			TInt exThroughput;

 			//Retrieve all the Mac characteristics that are required for all test cases

 			TVariantPtrC exMacMode;

 			if (!GetStringFromConfig(ConfigSection(),KConfigExInterfaceUid,exInterfaceUid) ||

 				!GetStringFromConfig(ConfigSection(),KConfigExAlgorithmUid,exAlgorithmUid) ||

 				!GetStringFromConfig(ConfigSection(),KConfigExImplementationUid,exImplementationUid) ||

 				!GetStringFromConfig(ConfigSection(),KConfigExCreatorName,exCreatorName) ||

 				!GetBoolFromConfig(ConfigSection(),KConfigExFIPSApproved,exFIPSApproved) ||

 				!GetBoolFromConfig(ConfigSection(),KConfigExHardwareSupport,exHardwareSupported) ||

 				!GetIntFromConfig(ConfigSection(),KConfigExMaxConcurrency,exMaxConcurrencySupported) ||

 				!GetStringFromConfig(ConfigSection(),KConfigExAlgorithmName,exAlgorithmName) ||

 				!GetIntFromConfig(ConfigSection(),KConfigExLatency,exLatency) ||

 				!GetIntFromConfig(ConfigSection(),KConfigExThroughput,exThroughput) ||

 				!GetStringFromConfig(ConfigSection(),KConfigExMacMode,exMacMode))

 				{

 				ERR_PRINTF1(_L("** .INI Error: Expected Mac/Common Characteristic Arguments Not Located **"));

 				SetTestStepResult(EFail);

 				}

 			else

 				{

 				INFO_PRINTF1(_L("** Checking Mac/Common Characteristics.... **"));

 				CPluginCharsChecker* pluginCheck = CPluginCharsChecker::NewLC();

 				//Retrieve the Common Characteristics from TMacCharacteristics 

 				const TCommonCharacteristics* macCommonChars = &macChars->iMacChar;

 				TPtrC errorMessage;

 				//Perform Mac/Common Characteristic Checks

 				if(pluginCheck->checkCommonCharacteristics(macCommonChars,

 											exInterfaceUid,

 											exAlgorithmUid,

 											exImplementationUid,

 											exCreatorName,

 											exFIPSApproved,

 											exHardwareSupported,

 											exMaxConcurrencySupported,

 											exAlgorithmName,

 											exLatency,

 											exThroughput,

 											errorMessage) &&

 					pluginCheck->checkMacCharacteristics(macChars, exMacMode, errorMessage))

 					{

 					INFO_PRINTF1(_L("Mac/Common characteristics successfully match expected values..."));

 					SetTestStepResult(EPass);

 					}

 				else

 					{

 					ERR_PRINTF2(_L("** FAIL: Characteristic Mismatch - %S **"),&errorMessage);	

 					}

 				CleanupStack::PopAndDestroy(pluginCheck);

 				}

 			CleanupStack::PopAndDestroy(macImpl);

 			CleanupStack::PopAndDestroy(key);

 			CleanupStack::PopAndDestroy(keyParams);

 			CleanupStack::PopAndDestroy(keyStr);

 			}

 		}

 	INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());

 	return TestStepResult();

 	}

 TVerdict CPluginCharsMacStep::doTestStepPostambleL()

 	{

 	return TestStepResult();

 	}