/*

 * Copyright (c) 2005-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: 

 * This file is used for the verification function of the pkcs12 file

 *

 */

 /**

  @file 

  @internalTechnology

 */

 // System Include

 #include <test/testexecutelog.h>

 //User Include 

 #include "tpkcs12libteststep.h"

 #include "tpkcs12data.h"

 #include "tpkcs12common.h"

 using namespace PKCS12;

 const TInt KBagDataLength = 7;

 const TInt KContentInfoLength = 11;

 /**

 Description:constructor:used for initialization of the variables declared      

 @test

 @internalTechnology

 */

 CPKCS12LibTestStep::CPKCS12LibTestStep()

 	{

 	iActualResult=ETrue;

 	iUnitTest=EFalse;

 	iUnitTestContinueFlag = ETrue;

 	iExpectedError = ETrue;

 	iExpectedResult=KPositiveTest;

 	}

 /**

 Description:Destructor

 @test

 @internalTechnology

 */

 CPKCS12LibTestStep::~CPKCS12LibTestStep()

 	{

 	iFileSession.Close();

 	delete iParser;	

 	iPrivacyPassword.ResetAndDestroy();	

 	}

 /**

 Function is intended to parse the pkcs12 file, compare the results and 

 log the same

 @internalTechnology:

 @return:TVerdict -returns EFail if there is a failure else EPass

 @test

 @leave:- if memory allocation fails

 */

 TVerdict CPKCS12LibTestStep::doTestStepL()

 	{

 	//__UHEAP_MARK;

 	TPtrC integrityMode(KNullDesC);

 	TPtrC integrityPassword(KNullDesC);

 	TPtrC privacyPassword(KNullDesC);

 	TPtrC dataPath(KNullDesC);

 	TBool flagReturn=ETrue;

 	if(iFileSession.Connect())

 		{

 		INFO_PRINTF1(_L("File server session failed"));

 		flagReturn=EFalse;

 		}

 	if(flagReturn)	

 		{

 		if((!GetStringFromConfig(KMainSec,KFilePath,dataPath)) ||

 		   !GetStringFromConfig(KMainSec,KIntegrityMode,integrityMode))

 			{

 			SetTestStepResult(EAbort);

 			ERR_PRINTF1(_L("Input Data not found in ini file"));

 			flagReturn=EFalse;

 			}	

 		}

 	//Check the input

 	if(flagReturn)

 		{

 		if(!GetBoolFromConfig(KMainSec,KUnitTest,iUnitTest))

 			{

 			iUnitTest=EFalse;

 			}

 		//Password Integrity Mode	

 		if(integrityMode.CompareF(KPassword)==0)

 			{

 			if(!GetStringFromConfig(KMainSec,KIntegrityPassword,integrityPassword))

 				{

 				ERR_PRINTF1(_L("Problem in the Main section of the ini file"));

 				SetTestStepResult(EFail);

 				flagReturn=EFalse;

 				}

 			else

 				{

 				iParser	= CPkcs12Parser::NewL();

 				// set the integrity password 

 				iParser->SetIntegrityPasswordL(integrityPassword);

 				// set the datapath

 				iParser->SetDataL(dataPath);

 				//set the privacy password

 				ParsePrivacyPwdL();

 				//parse the pkcs12 file

 				iParser->ParseL();

 				if(!GetBoolFromConfig(KMainSec,KIntegrityValid,iExpectedResult))

 					{

 					WARN_PRINTF1(_L("Integrity valid not found in ini file"));

 					iExpectedResult=KPositiveTest;

 					}

 				if(!VerifyMainSecL())

 					{

 					ERR_PRINTF1(_L("Main section failed"));

 					flagReturn=EFalse;

 					}

 				else if(!iUnitTestContinueFlag)

 					{

 					SetTestStepResult(EPass);

 					delete iParser;

 					iParser = NULL;

 					flagReturn = EFalse;

 					}

 				}

 			}

 		else if(integrityMode.CompareF(KPublicIntegrity)==0)

 			{

 			//public Integrity Mode	

 			}

 		else

 			{

 			ERR_PRINTF1(_L("Integrity pwd not known in ini file"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			}

 		}

 	if(flagReturn)

 		{

 		//Check the Authenticated safe section	

 		if(!VerifyAuthSafe())

 			{

 			ERR_PRINTF1(_L("Authenticated safe section failed"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			}

 		else if(!iUnitTestContinueFlag )

 			{

 			SetTestStepResult(EPass);

 			delete iParser;

 			iParser = NULL;

 			flagReturn = EFalse;

 			}

 		}

 	if(flagReturn)	

 		{

 		//calculate the totalsafebags in the pkcs12 file	

 		TInt totalsafebags = iParser->PfxHeader().TotalSafeBagCount();

 		//calculate the totalbags(including the safecontentsbag) in the pkcs12 file						

 		TInt totalbags = totalsafebags + iParser->PfxHeader().SafecontentBagCount();

 		//Check the BagData section	

 		if(!ChkBagDataL(totalsafebags,totalbags))

 			{

 			ERR_PRINTF1(_L("Bag Data section failed"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			}

 		else if(!iUnitTestContinueFlag)

 			{

 			delete iParser;

 			iParser = NULL;

 			flagReturn = EFalse;

 			}

 		}

 	if(flagReturn)

 		{

 		SetTestStepResult(EPass);		

 		}

 	//__UHEAP_MARKEND; 

 	return TestStepResult();

 	}

 /**

 Function is intended to verify the expected error in each section of the ini file

 @internalTechnology:

 @return:TBool:returns EFalse if there is a failure else ETrue

 @test:

 */

 TBool CPKCS12LibTestStep::VerifyExpectedError(const TDesC& aSecName)

 	{

 	TBool flagReturn = ETrue;

 	if ( iUnitTest ) 

 		{

 		if(GetIntFromConfig(aSecName,KExpectedError,iExpectedError)==EFalse)

 			{

 			INFO_PRINTF1(_L("ExpectedError not found in INI File"));

 			}	

 		// Checks the error returned by the library with the expected error read 

 		// from the INI file.

 		TInt actualError = 0;

 		if ( (!aSecName.Compare(KMainSec) || !aSecName.Compare(KAuthSafeSec) ||

 		     !aSecName.Compare(_L("MacData")) || (!aSecName.Left(KBagDataLength).Compare(KBagDataSec)) ||

 		     (!aSecName.Left(KContentInfoLength).CompareF(KContentInfoKey))) && !iExpectedResult )

 			{

 			actualError = iParser->PfxHeader().Pkcs12ActualError();

 			}	

 		if (actualError == iExpectedError)

 			{

 			INFO_PRINTF1(_L("ExpectedError matchs"));

 			iUnitTestContinueFlag = EFalse;

 			iExpectedResult = ETrue;

 			}

 		}

 	if(iExpectedResult!=iActualResult)

 		{

 		SetTestStepResult(EFail);

 		flagReturn= EFalse;

 		}

 	iActualResult = ETrue;

 	return flagReturn;	

 	}

 /**

 Function is intended to set the privacy passwords of the contentinfotype

 @internalTechnology:

 @test:

 @leave: if leave occurs if memory allocation fails

 */		

 void CPKCS12LibTestStep::ParsePrivacyPwdL()

 	{

 	TPtrC pass(KNullDesC);

 	//to append the number to get the actual key value

 	TInt count=0;

 	//return value

 	TBool privacyPwdPresent=EFalse;

 	//Put all the content info privacy passwords in an array 

 	do

 		{

 		TBuf<KPrivacyPwdStrLen> privacyPwdBuf(KPrivacyPassword);

 		pass.Set(KNullDesC);

 		count++;

 		//appending the count to the Keyvalue

 		privacyPwdBuf.AppendNum(count);

 		privacyPwdPresent=GetStringFromConfig(KMainSec,privacyPwdBuf,pass);

 		if(privacyPwdPresent)

 			{

 			HBufC *temp=pass.AllocLC();

 			iPrivacyPassword.AppendL(temp);

 			CleanupStack::Pop(temp);

 			}

 		}while(privacyPwdPresent);

 	iParser->SetPrivacyPassword(iPrivacyPassword);	

 	}

 /**

 Function is intended to parse the main section of the ini file

 @internalTechnology:

 @return:returns EFalse if there is a failure else ETrue

 @test:

 */			

 TBool CPKCS12LibTestStep::VerifyMainSecL()

 	{

 	TBool mac=EFalse;

 	TBool flagReturn=ETrue;

 	//retrieve the expected result:PositiveTest/NegativeTest	

 	if(!GetBoolFromConfig(KMainSec,KExpectedResult,iExpectedResult))

 		{

 		WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 		iExpectedResult=KPositiveTest;

 		}

 	if(!GetBoolFromConfig(KMainSec,KMacPresent,mac))

 		{

 		WARN_PRINTF1(_L("Mac present not found in ini file"));

 		//default only integration test

 		mac=EFalse;

 		}

 	else if(mac && iUnitTest)

 		{

 		//call the mac data function and check for all the macdata section values

 		iActualResult=ChkMacValueL();

 		if (!iUnitTestContinueFlag)	

 			{

 			return flagReturn;

 			}

 		}

 	if(!VerifyExpectedError(KMainSec))

 		{

 		SetTestStepResult(EFail);

 		flagReturn = EFalse;

 		}

 	return flagReturn;	

 	}

 /**

 Function is intended to parse the AuthSafe section of the ini file

 @internalTechnology:

 @return:returns EFalse if there is a failure else ETrue

 @test:

 */			

 TBool CPKCS12LibTestStep::VerifyAuthSafe()

 	{

 	TInt contentInfoCount=0;

 	TPtrC contentSection(KNullDesC);

 	TInt contentIndex=0;

 	TBool flagReturn=ETrue;

 	if(!GetIntFromConfig(KAuthSafeSec,KContentInfoNum,contentInfoCount))

 		{

 		ERR_PRINTF1(_L("Count not available in the inifile"));

 		SetTestStepResult(EFail);

 		flagReturn=EFalse;

 		}

 	//retrieve the expected result:PositiveTest/NegativeTest	

 	if(GetIntFromConfig(KAuthSafeSec,KExpectedResult,iExpectedResult)==EFalse)

 		{

 		INFO_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 		}

 	//verify positive or negative test

 	if(!VerifyExpectedError(KAuthSafeSec()))

 		{

 		INFO_PRINTF1(_L("Content Info Failure"));

 		SetTestStepResult(EFail);

 		flagReturn = EFalse;

 		}

 	else if(!iUnitTestContinueFlag)

 		{

 		return flagReturn;

 		}

 	for(TInt i=1;i<=contentInfoCount;i++)

 		{

 		TBuf<KContentInfoBufLen> contentBuf(KContentInfoKey);

 		//Append the counter to the keyname		

 		contentBuf.AppendNum(i);

 		if(!GetStringFromConfig(KAuthSafeSec,contentBuf,contentSection))

 			{

 			ERR_PRINTF1(_L("ContentSection not available in the inifile"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			break;

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(GetIntFromConfig(contentSection,KExpectedResult,iExpectedResult)==EFalse)

 			{

 			INFO_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 			iExpectedResult=KPositiveTest;

 			}

 		// Verify before calling array to access the data.

 		if(!VerifyExpectedError(contentSection))

 			{

 			INFO_PRINTF1(_L("Content Info Failure"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			break;

 			}

 		else if(!iUnitTestContinueFlag)

 			{

 			flagReturn = ETrue;

 			break;

 			}

 		//Call the function for checking the contentinfo,pass the contntsction as parameter

 		iBagData=iParser->ArraySafeBagData()[contentIndex];

 		contentIndex++;

 		//Check the contentinfo type

 		iActualResult=ChkCIType(contentSection,*iBagData);

 		}

 	return flagReturn;

 	}

 /**

 Function is intended to parse the BagData section of the ini file

 @param-aTotalsafebags:total number of safebags

 @param-aTotalbags:total number of bags including the safecontentbags

 @internalTechnology:

 @return:returns EFalse if  there is a failure else return ETrue

 @test:

 @leave: if leave occurs at the ChkBagValL function

 */			

 TBool CPKCS12LibTestStep::ChkBagDataL(TInt aTotalsafebags,TInt aTotalbags)	

 	{

 	TInt bagType=0;

 	TInt safeContentIndex=0;

 	TInt safeBagIndex=0;

 	CSafeContentBag* safeContentBag;

 	TBool flagReturn=ETrue;

 	TInt totalSafeContentsBag = iParser->PfxHeader().SafecontentBagCount();

 	//loop for the totalbags

 	for(TInt bags=0;bags<aTotalbags;bags++)

 		{

 		TBuf<KBagDataSecBufLen> bagSection(KBagDataSec);

 		//Append the bags to the sectionname :BagData1

 		bagSection.AppendNum(bags+1);

 		if(!GetIntFromConfig(bagSection,KBagType,bagType))

 			{

 			ERR_PRINTF1(_L("Not able to get the BagType from the ini file"));

 			flagReturn=EFalse;

 			break;

 			}

 		if(bagType == CDecPkcs12SafeBag::ESafeContentsBag && flagReturn)

 			{

 			//loop for the safecontents bags

 			while(safeContentIndex < totalSafeContentsBag && flagReturn)

 				{

 				safeContentBag=iParser->ArraySafeContentBag()[safeContentIndex];

 				if(!ChkSafeContsBagData(bagSection,*safeContentBag))

 					{

 					ERR_PRINTF1(_L("SafeContent Bag Failed"));

 					flagReturn=EFalse;

 					}

 				safeContentIndex++;

 				break;

 				} 

 			}

 		else

 			{

 			while(safeBagIndex < aTotalsafebags && flagReturn)

 				{

 				//retrieve the safebag sructure pointer

 				iBagData=iParser->ArraySafeBagData()[safeBagIndex];

 				//Chk the BagType

 				if(!ChkBagType(bagSection,*iBagData,bagType))

 					{

 					ERR_PRINTF1(_L("Bag Type does not match"));

 					flagReturn=EFalse;

 					break;

 					}

 				if(!iUnitTestContinueFlag)

 					{

 					break;

 					}

 				iBagAttrNumVal=0;	

 				if(!ChkBagAttbutesL(bagSection,*iBagData))

 					{

 					ERR_PRINTF1(_L("Failure in Attributes"));

 					flagReturn=EFalse;

 					break;

 					}	

 				switch(bagType)

 					{

 					case CDecPkcs12SafeBag::ECertBag:

 						{

 						//check the bagvalue

 						if(!ChkBagValL(bagSection,*iBagData))

 							{

 							flagReturn=EFalse;

 							ERR_PRINTF1(_L("Certificate Bag Value comparison Failed"));

 							}

 						//check the certificate type

 						if(flagReturn)	

 							{

 							if(!ChkCertId(bagSection,*iBagData))

 								{

 								flagReturn=EFalse;

 								ERR_PRINTF1(_L("Certificate Bag certID comparison Failed"));

 								}

 							}	

 						break;	

 						}

 					case  CDecPkcs12SafeBag::EKeyBag:

 						{

 						if(!ChkBagValL(bagSection,*iBagData))

 							{

 							flagReturn = EFalse;

 							ERR_PRINTF1(_L("Key Bag Failed"));

 							}	

 						break;		

 						}

 					case CDecPkcs12SafeBag::EShroudedKeyBag:

 						{

 							if(!ChkEncodedBagValL(bagSection,*iBagData))

 							{

 							flagReturn = EFalse;

 							ERR_PRINTF1(_L("Shrouded Bag Failed"));

 							}	

 						break;	

 						}

 					case CDecPkcs12SafeBag::ECrlBag:

 						{

 						break;		

 						}

 					case CDecPkcs12SafeBag::ESecretBag:

 						{

 						break;	

 						}

 					}

 					if(flagReturn)

 						{

 						safeBagIndex++;	

 						break;			

 						}

 				}

 			}

 		}

 	return flagReturn;

 	}

 /**

 Function is intended to check the safecontents bag

 @param-aSec:BagData Section

 @param-aSfContBag:safecontent class pointer

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 */		

 TBool CPKCS12LibTestStep::ChkSafeContsBagData(TDesC& aSec,CSafeContentBag &aSfContBag)

 	{

 	TInt safeContentsCount=0;

 	TBool flagReturn=ETrue;

 	//retrieve the safecontentsbag count from ini file

 	if(!GetIntFromConfig(aSec,KSafeBagsCount,safeContentsCount)) 		

 		{

 		ERR_PRINTF1(_L("SafeContent Bags count not found in INI file"));

 		SetTestStepResult(EFail);

 		flagReturn=EFalse;

 		}

 	//compare the data with the ini file data	

 	if(safeContentsCount != aSfContBag.SafeBagCount() && flagReturn)

 		{

 		ERR_PRINTF1(_L("Number of Bags in the safecontent bag is different"));

 		iActualResult=EFalse;

 		}

 	//retrieve the expected result:PositiveTest/NegativeTest	

 	if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))

 		{

 		INFO_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 		iExpectedResult=KPositiveTest;

 		}	

 	//check whether its a positive or a negative test	

 	if(flagReturn)

 		{

 		//check whether its a positive or a negative test	

 		if(!VerifyExpectedError(aSec))

 			{

 			INFO_PRINTF1(_L("SafeContentsBag Failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}	

 		}

 	return flagReturn;

 	}

 /**

 Function is intended to check the content info type

 @param-aSecName:BagData Section

 @param-aBagData:safebag class pointer

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 */		

 TBool CPKCS12LibTestStep::ChkCIType(TDesC &aSecName,CSafeBagData &aBagData)

 	{

 	TInt contentType=0;

 	TBool flagReturn=ETrue;

 	//retrieve the contentype from the ini file

 	if(!GetIntFromConfig(aSecName,KContentInfoType,contentType))

 		{

 		ERR_PRINTF1(_L("ContentInfoType value not found in INI file"));

 		SetTestStepResult(EFail);

 		flagReturn=EFalse;

 		}

 	//compare the contentype with the ini file data

 	if(flagReturn)

 		{

 		if(aBagData.ContentInfoType() != contentType)

 			{

 			iActualResult=EFalse;

 			INFO_PRINTF1(_L("ContentType Comparison Failed"));

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))

 			{

 			WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 			iExpectedResult=KPositiveTest;

 			}

 		//check whether its a positive or a negative test	

 		if(!VerifyExpectedError(aSecName))

 			{

 			INFO_PRINTF1(_L("ContentInfo Failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}				

 		}

 	return flagReturn;

 	}

 /**

 Function is intended to check the bag type

 @param-aSec:BagData Section

 @param-aBgDta:safebag class pointer

 @param-aId:Bag ID

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 */	

 TBool CPKCS12LibTestStep::ChkBagType(TDesC &aSec,CSafeBagData &aBagData,TInt aId)

 	{

 	TBool flagReturn=ETrue;

 	//check for the bagid	

 	if(aId != aBagData.BagType())

 		{

 		iActualResult=EFalse;

 	   	INFO_PRINTF1(_L("BagType Comparision Failed"));

 		}

 	//retrieve the expected result:PositiveTest/NegativeTest	

 	if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))

 		{

 		WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 		iExpectedResult=KPositiveTest;

 		}	

 	//check whether its a positive or a negative test		

 	if(!VerifyExpectedError(aSec))

 		{

 		INFO_PRINTF1(_L("BagType Failed"));

 		SetTestStepResult(EFail);

 		flagReturn = EFalse;

 		}		

 	return flagReturn;

 	}

 /**

 Function is intended to check the bag attributes

 @param-aSec:BagData Section

 @param-aBagData:safebag class pointer

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 */

 TBool CPKCS12LibTestStep::ChkBagAttbutesL(TDesC &aSec,CSafeBagData &aBagData)

 	{

 	TInt numAttr=0;

 	TInt count=0;

 	TPtrC attrSec(KNullDesC);

 	TBool flagReturn=ETrue;

 	//retrieve the number of attributes

 	if(!GetIntFromConfig(aSec,KBagAttributesNum,numAttr))

 		{

 		WARN_PRINTF1(_L("Number of attributes not found in INI file"));

 		}

 	for(TInt attrindex=0;attrindex < numAttr;attrindex++)	

 		{

 		TBuf<KAttributeBufLen> attrBuf(KBagAttributesKey);

 		//increment the attr counter

 		count++;

 		//appending to get the attr key from the ini file

 		attrBuf.AppendNum(count);

 		if(!GetStringFromConfig(aSec,attrBuf,attrSec))

 			{

 			ERR_PRINTF1(_L("Number of attributes not found in INI file"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			break;

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))

 			{

 			WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 			iExpectedResult=KPositiveTest;

 			}

 		//check whether its a positive or a negative test		

 		if(!VerifyExpectedError(aSec))

 			{

 			INFO_PRINTF1(_L("BagAttributes Failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}		

 		else if(!iUnitTestContinueFlag)

 			{

 			flagReturn = ETrue;

 			break;

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))

 			{

 			WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 			iExpectedResult=KPositiveTest;

 			}

 		//check whether its a positive or a negative test		

 		if(!VerifyExpectedError(aSec))

 			{

 			INFO_PRINTF1(_L("BagAttributes Failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}		

 		else if(!iUnitTestContinueFlag)

 			{

 			flagReturn = ETrue;

 			break;

 			}

 		//Check the BagAttribute section

 		if(!ChkAtrSecL(attrSec,aBagData,attrindex))

 			{

 			ERR_PRINTF1(_L("Attributes comparison failed"));

 			flagReturn=EFalse;

 			break;

 			}

 		}

 	return flagReturn;

 	}

 /**

 Function is intended to check the attribute section

 @param-aSec:BagData Section

 @param-aBgDta:safebag class pointer

 @param-aIndx:attribute index

 @param-aAttrindex:attribute index

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 @leave: if leave occurs if ChkAtrValL fails

 */

 TBool CPKCS12LibTestStep::ChkAtrSecL(TDesC &aSec,CSafeBagData &aBagData,TInt aIndex)

 	{

 	TPtrC attrId(KNullDesC);

 	TInt numVal=0;

 	CSafeBagAttribute *bagAttr;

 	TPtrC friendlyName(KFriendlyNameOid);

 	TPtrC localKey(KLocalKeyOid);

 	TBool flagReturn=ETrue;

 	//retrieve the attribute id

 	if(!GetStringFromConfig(aSec,KBagAttributesID,attrId))

 		{

 		ERR_PRINTF1(_L("attribute id not found in INI file"));

 		SetTestStepResult(EFail);

 		flagReturn=EFalse;

 		}

 	if(flagReturn)

 		{

 		//retrieve the number of values	

 		if(!GetIntFromConfig(aSec,KBagAttributeValuesNum,numVal))

 			{

 			ERR_PRINTF1(_L("total number of attribute values not found in INI file"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			}	

 		}

 	if(flagReturn)

 		{

 		bagAttr = aBagData.iAttributeIDs[aIndex];

 		//increment the Number of BagAttrValues

 		iBagAttrNumVal+=numVal;

 		 //compare the attrval count and the attrid

 		if((bagAttr->AttributeValueCount()!=numVal) || 

 		 (attrId.CompareF((bagAttr->AttributeId()))!=0))

 		 	{

 		 	iActualResult=EFalse;

 			}

 		else if((friendlyName.CompareF((bagAttr->AttributeId()))==0) ||

 				(localKey.CompareF((bagAttr->AttributeId()))==0))

 			{

 			//Check for BagAttribute values 

 			if(!ChkAtrValL(aSec,aBagData,numVal))

 				{

 				iActualResult=EFalse;

 				}

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))

 			{

 			WARN_PRINTF1(_L("ExpectedResult not found in INI file"));

 			iExpectedResult=KPositiveTest;

 			}	

 		//check for positive or negative test	

 		if(!VerifyExpectedError(aSec))

 			{

 			INFO_PRINTF1(_L("Attributes Comparison Test Case failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}	

 		}

 	//retrieve the bag attribute structure pointer

 	return flagReturn;

 	}

 /**

 Function is intended to check the attribute values

 @param-aSec:BagData Section

 @param-aBgDta:safebag class pointer

 @param-aNum:Bagattribute value count

 @param-aAtr:Bagattribute ID

 @param-aNumVal:Bagattribute value count

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 @leave: if memory allocation of buffer fails

 */

 TBool CPKCS12LibTestStep::ChkAtrValL(TDesC &aSec,CSafeBagData &aBagData,TInt aNum)

 	{

 	TInt start=iBagAttrNumVal - aNum;

 	TInt end=iBagAttrNumVal + aNum;

 	TBool flagReturn=ETrue;

 	TInt index=0;

 	TPtrC value(KNullDesC);

 	HBufC8 *bufferVal;

 	//loop till the total number of values

 	do	

 		{

 		TBuf<KBagValBufLen> bagVal(KBagAttributeValue);

 		//increment the index to append the count

 		index++;

 		//append the value

 		bagVal.AppendNum(index);

 		//retrieve the value from the ini file

 		if(!GetStringFromConfig(aSec,bagVal,value))

 			{

 			ERR_PRINTF1(_L("Bag Value not found in the ini file"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			break;

 			}

 		for(TInt startIndex=start;startIndex<end;startIndex++)

 			{

 			bufferVal=aBagData.iAttributeValues[startIndex];

 			//check the local key value

 			if(!CompareFileDataL(value,*bufferVal))

 				{

 				ERR_PRINTF1(_L("Bag Attribute Value comparison failed"));

 				iActualResult=EFalse;

 				break;	

 				}

 			else

 				{

 				iActualResult=ETrue;

 				break;

 				}

 			}

 			//retrieve the expected result:PositiveTest/NegativeTest	

 			if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))

 				{

 				WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 				iExpectedResult=KPositiveTest;

 				}	

 			//check for positive or negative test

 			if(!VerifyExpectedError(aSec))

 				{

 				INFO_PRINTF1(_L("Bag Value Test failed"));

 				SetTestStepResult(EFail);

 				flagReturn = EFalse;

 				break;

 				}

 			else if(!iUnitTestContinueFlag)

 				{

 				break;

 				}		

 		}while(index<aNum);

 	return flagReturn;

 	}

 /**

 Function is intended to check the value.

 @param-aPValue:filepath containing the path of the file 

 			   retrieved from the ini file

 @param-aBufferVal:Value retrieved after parsing the pkcs12 file

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 @leave: if leave occurs if openfile fails or allocation to buffer fails

 */	

 TBool CPKCS12LibTestStep::CompareFileDataL(TDesC &aPValue,TDesC8 &aBufferVal)

 	{

 	RFile file;

 	TInt fileSize=0;

 	TBool flagReturn=ETrue;

 	// Negative Test: If mac/ macSalt is not present.

 	if (&aBufferVal)

 		{

 		//open the file

 		User::LeaveIfError(file.Open(iFileSession,aPValue,EFileRead));

 		User::LeaveIfError(file.Size(fileSize));

 		//raw data for reading the bagvalue

 		HBufC8 *rawData=HBufC8::NewMaxLC(fileSize);

 		//converting the HBufC8 to TPtr8

 		TPtr8 data(rawData->Des());

 		//read the contents of the file

 		User::LeaveIfError(file.Read(data));

 		//compare the value

 		if(rawData->CompareF(aBufferVal)!=0)

 			{

 			ERR_PRINTF1(_L("comparison failed"));

 			flagReturn=EFalse;

 			}

 		//closes the data file

 		file.Close();

 		CleanupStack::PopAndDestroy(rawData); 	

 		}

 	return flagReturn;

 	}

 /**

 Function is intended to check the algorithm id

 @param-aSecName:BagData Section

 @param-aBagData:safebagdata class pointer

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 */

 TBool CPKCS12LibTestStep::ChkAlgId(TDesC &aSecName,CSafeBagData &aBagData)

 	{

 	TPtrC algorithm(KNullDesC);

 	TBool flagReturn=ETrue;

 	//retrieve the algorithm section name

 	if(!GetStringFromConfig(aSecName,_L("Algorithm"),algorithm))

 		{

 		ERR_PRINTF1(_L("AlgorithmID value not found in INI file"));

 		SetTestStepResult(EFail);

 		flagReturn=EFalse;

 		}

 	if(flagReturn)	

 		{

 		if(algorithm.CompareF((aBagData.AlgorithmId()))!=0)

 			{

 			iActualResult=EFalse;

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))

 			{

 			WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 			iExpectedResult=KPositiveTest;

 			}	

 		//check for positive oor negative test	

 		if(!VerifyExpectedError(aSecName))

 			{

 			INFO_PRINTF1(_L("Algorithm Comparison Test Case failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}			

 		}

 	return flagReturn;	

 	}

 /**

 Function is intended to check the certificate type

 @param-aSecName:BagData Section

 @param-aBagData:safebagdata class pointer

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 */

 TBool CPKCS12LibTestStep::ChkCertId(TDesC &aSecName,CSafeBagData &aBagData)

 	{

 	TPtrC certid(KNullDesC);

 	TBool flagReturn=ETrue;

 	//retrieve the cert name from ini file

 	if(!GetStringFromConfig(aSecName,KCertType,certid))

 		{

 		ERR_PRINTF1(_L("certificateID value not found in INI file"));

 		SetTestStepResult(EFail);

 		flagReturn= EFalse;

 		}

 	if(flagReturn)

 		{

 		if(certid.CompareF((aBagData.CertificateId()))!=0)

 			{

 			INFO_PRINTF1(_L("certificateID comparision Failed"));

 			iActualResult=EFalse;

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))

 			{

 			WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 			iExpectedResult=KPositiveTest;

 			}	

 		//check for positive or negative test	

 		if(!VerifyExpectedError(aSecName))

 			{

 			INFO_PRINTF1(_L("Certificate Comparison Test Case failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}				

 		}

 	return flagReturn;

 	}

 /**

 Function is intended to check for the bag value

 @param-aSecName:BagData Section

 @param-aBagData:safebag class pointer

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 */

 TBool CPKCS12LibTestStep::ChkBagValL(TDesC &aSecName,CSafeBagData &aBagData)

 	{

 	TPtrC certBagPath(KNullDesC);

 	TBool flagReturn=ETrue;

 	//retrieve the certificate bag value

 	if(!GetStringFromConfig(aSecName,KBagValue,certBagPath))

 		{

 		ERR_PRINTF1(_L("Not able to get the CertBagValue from the ini file"));

 		SetTestStepResult(EFail);

 	  	flagReturn=EFalse;

 	  	}

 	TInt fileReturn=0; 	

 	RFile file;

 	if(flagReturn)

 		{

 		fileReturn=file.Open(iFileSession,certBagPath,EFileRead);

 		if(fileReturn)

 			{

 			ERR_PRINTF1(_L("CertBagValue:Not able to open the file"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			}	

 		}

 	//raw data for reading the bagvalue

 	HBufC8 *rawData=NULL;

 	TInt filesize=0;	

 	if(flagReturn)

 		{

 		User::LeaveIfError(file.Size(filesize));

 		rawData=HBufC8::NewMaxLC(filesize);

 		TPtr8 data(rawData->Des());

 		if(file.Read(data))

 			{

 			ERR_PRINTF1(_L("CertBagValue:Not able to Read the file"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			}

 		}

 	if(flagReturn)

 		{

 	  	//compare the data

 		if(rawData->CompareF(aBagData.BagValue())!=0)

 			{

 			iActualResult=EFalse;

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))

 			{

 			WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 			iExpectedResult=KPositiveTest;

 			}			

 		//check for positive or negative test	

 		if(!VerifyExpectedError(aSecName))

 			{

 			INFO_PRINTF1(_L("BagValue Failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}			

 		}

 	if(rawData!=NULL)	

 		{

 		CleanupStack::PopAndDestroy(rawData); 	

 		}

 	if(!fileReturn)

 		{

 		file.Close();	

 		}

 	return flagReturn;

 	}

 /**

 Function is intended to check for the mac value

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 @leave: if leave occurs at the CompareFileDataL function

 */	

 TBool CPKCS12LibTestStep::ChkMacValueL()	

 	{

 	TPtrC mac(KNullDesC);

 	TPtrC macSalt(KNullDesC);

 	TPtrC secName(_S("MacData"));

 	TPtrC expectedError(KNullDesC);

 	TInt itCount=0;

 	TBool flagReturn=ETrue;

 	//retrieve the macid,macsalt and iteration count 

 	if((!GetStringFromConfig(secName,KMac,mac)) || 

 	   (!GetStringFromConfig(secName,KMacSalt,macSalt)) ||

 	   (!GetIntFromConfig(secName,KIterationCount,itCount)))

 		{

 		ERR_PRINTF1(_L("Not able to access the mac values from ini file"));

 		SetTestStepResult(EFail);

 		flagReturn=EFalse;

 		}

 	//comapre the data with the ini file

 	if((CompareFileDataL(mac,iParser->PfxHeader().MacId()) ==0)||

 	   (CompareFileDataL(macSalt,iParser->PfxHeader().MacSalt()) == 0)||

 	   (itCount!=iParser->PfxHeader().IterationCount()))

 		{

 		WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 		flagReturn=EFalse;

 		}

 	//retrieve the expected result:PositiveTest/NegativeTest	

 	if(!GetBoolFromConfig(secName,KExpectedResult,iExpectedResult))

 		{

 		WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 		iExpectedResult=KPositiveTest;

 		}	

 	if(!VerifyExpectedError(secName))

 		{

 		SetTestStepResult(EFail);

 		flagReturn = EFalse;

 		}	

 	return flagReturn;

 	}

 CTPKCS12OOMStep::CTPKCS12OOMStep()

 	{

 	}

 CTPKCS12OOMStep::~CTPKCS12OOMStep()

 	{

 	delete iRawData;

 	delete iAuthSafeData;

 	iFs.Close();

 	}

 /**

 Function is intended to do the OOM test.

 @internalTechnology:

 @return:TVerdict -returns EFail if there is a failure else EPass

 @leave:- if memory allocation fails

 @test

 */	

 TVerdict CTPKCS12OOMStep::doTestStepL()

 	{

 	TInt OOMTest;

 	GetIntFromConfig(ConfigSection(),_L("OOMTest"),OOMTest);

 	__UHEAP_MARK;

 	switch(OOMTest)

 		{

 		case 1:

 			{

 			CDecPkcs12* theTest = NULL;

 			theTest = CDecPkcs12::NewL(iRawData->Des());

 			delete theTest;

 			}

 			break;

 		// File Stream

 		case 2:	

 			{

 			TPtrC fileName;

 			GetStringFromConfig(ConfigSection(), _L("File"), fileName);

 			RFile file;

 			User::LeaveIfError(file.Open(iFs, fileName, EFileRead) );

 			TInt size;

 			file.Size(size);

 			file.Close();

 			HBufC8* res = HBufC8::NewLC(size);

 			TPtr8 p(res->Des());

 			p.SetLength(size);

 			RFileReadStream stream;

 			User::LeaveIfError(stream.Open(iFs, fileName, EFileStream));

 			CleanupClosePushL(stream);

 			stream.ReadL(p, size);

 			CDecPkcs12* theTest = NULL;

 			theTest = CDecPkcs12::NewL(stream);

 			delete theTest;			

 			CleanupStack::PopAndDestroy(2,res); // stream

 			}

 			break;

 		// MacData

 		case 3:

 			{	

 			CDecPkcs12MacData* theTest = NULL;

 			theTest = CDecPkcs12MacData::NewL(iRawData->Des(),iAuthSafeData->Des());

 			delete theTest;

 			}

 			break;

 		// Attribute

 		case 4:

 			{

 			CDecPkcs12Attribute* theTest = NULL;

 			theTest = CDecPkcs12Attribute::NewL(iRawData->Des());

 			delete theTest;

 			}

 			break;

 		// ShroudedBag

 		case 5:

 			{

 			CDecPkcs12ShroudedKeyBag* theTest = NULL;

 			theTest = CDecPkcs12ShroudedKeyBag::NewL(iRawData->Des());

 			delete theTest;

 			}

 			break;

 		// CertBag

 		case 6:

 			{

 			CDecPkcs12CertBag* theTest = NULL;

 			theTest = CDecPkcs12CertBag::NewL(iRawData->Des());

 			delete theTest;

 			}

 			break;

 		// KeyBag

 		case 7:

 			{

 			CDecPkcs12KeyBag* theTest = NULL;

 			theTest = CDecPkcs12KeyBag::NewL(iRawData->Des());

 			delete theTest;

 			}

 			break;

 		// SafeContentsBag

 		case 8:

 			{

 			CDecPkcs12SafeContentsBag* theTest = NULL;

 			theTest = CDecPkcs12SafeContentsBag::NewL(iRawData->Des());

 			delete theTest;

 			}	

 			break;

 		// Safebag/CRL bag

 		case 9:

 			{

 			CDecPkcs12SafeBag* theTest = NULL;

 			theTest = CDecPkcs12SafeBag::NewL(iRawData->Des());

 			delete theTest;

 			}

 			break;

 		// SafeContentsData / SafeContentsEncryptedData

 		case 10:

 			{

 			CDecPkcs12* p12 = NULL;

 			p12 = CDecPkcs12::NewL(iRawData->Des());

 			CleanupStack::PushL(p12);

 			const RPointerArray<CPKCS7ContentInfo>& contentInfos = p12->AuthenticatedSafeContents();

 			TInt contentInfoCount = contentInfos.Count();

 			for ( TInt index = 0; index < contentInfoCount; index++ )

 				{

 				TInt contentType = contentInfos[index]->ContentType();

 				CDecPkcs12SafeContents* pkcs12SafeContents ;	

 				TInt contentTypeData;

 				GetIntFromConfig(ConfigSection(),_L("ContentTypeData"),contentTypeData);

 				TInt contentTypeEncryptedData;

 				GetIntFromConfig(ConfigSection(),_L("ContentTypeEncryptedData"),contentTypeEncryptedData);

 				if ( contentType == contentTypeEncryptedData )

 					{

 					TPtrC expectedPassword(KNullDesC());

 					GetStringFromConfig(ConfigSection(), _L("Password"), expectedPassword);

 					pkcs12SafeContents = CDecPkcs12SafeContents::NewL(*contentInfos[index],expectedPassword);

 					delete pkcs12SafeContents;

 					}

 				else if ( contentType == contentTypeData )

 					{

 					pkcs12SafeContents = CDecPkcs12SafeContents::NewL(*contentInfos[index]);

 					delete pkcs12SafeContents;

 					}

 				}

 				CleanupStack::PopAndDestroy(p12);

 			break;

 			}

 		}

  	__UHEAP_MARKEND;

  	return TestStepResult();

 	}

 /**

 Function is intended to read the data from the specified path.

 @param-aPValue:filepath containing the path of the file 

 			   retrieved from the ini file.

 @internalTechnology:

 @return:returns data retrieved after reading from the file.

 @test:

 */	

 HBufC8* CTPKCS12OOMStep::ReadFileDataL(TPtrC tag)

 	{

 	TPtrC fileName;

 	if (!GetStringFromConfig(ConfigSection(), tag, fileName))

 		{

 		return NULL;

 		}

 	RFile file;

 	if (file.Open(iFs, fileName, EFileRead))

 		{

 		INFO_PRINTF2(_L("Cannot open file %S for reading"), &fileName);

 		return NULL;

 		}

 	CleanupClosePushL(file);

 	TInt fileSize = 0;

 	User::LeaveIfError(file.Size(fileSize));

 	HBufC8* result = HBufC8::NewL(fileSize);

 	result->Des().SetLength(fileSize);

 	TPtr8 rawDataPtr(result->Des());

 	rawDataPtr.SetLength(fileSize);

 	file.Read (rawDataPtr);

 	CleanupStack::PopAndDestroy (&file);

 	INFO_PRINTF3(_L("Read %d octets from %S"), result->Size(), &fileName);

 	return result;

 	}

 TVerdict CTPKCS12OOMStep::doTestStepPreambleL()

 	{

 	User::LeaveIfError (iFs.Connect());

 	SetTestStepResult(EPass);

 	iRawData = ReadFileDataL(_L("File"));

 	if (iRawData == NULL)

 		{

 		INFO_PRINTF1(_L("Failed to read 'File' section of script"));

 		SetTestStepResult(ETestSuiteError);

 		}

 	iAuthSafeData = ReadFileDataL(_L("AuthSafe"));

 	if (iAuthSafeData == NULL)

 		{

 		INFO_PRINTF1(_L("authsafedata file is not required"));

 		}

 	return TestStepResult();

 	}

 /**

 Function is intended to check for the re encoded shrouded key

 @param-aSecName:BagData Section

 @param-aBagData:safebag class pointer

 @internalTechnology:

 @return:returns EFalse if there is a failure else return ETrue

 @test:

 */

 TBool CPKCS12LibTestStep::ChkEncodedBagValL(TDesC &aSecName,CSafeBagData &aBagData)

 	{

 	TPtrC bagPath(KNullDesC);

 	TBool flagReturn=ETrue;

 	//retrieve the shrouded bag value

 	if(!GetStringFromConfig(aSecName,KEncBagValue,bagPath))

 		{

 		ERR_PRINTF1(_L("Not able to get the EncBagValue from the ini file"));

 		SetTestStepResult(EFail);

 	  	flagReturn=EFalse;

 	  	}

 	TInt fileReturn=0; 	

 	RFile file;

 	if(flagReturn)

 		{

 		fileReturn=file.Open(iFileSession,bagPath,EFileRead);

 		if(fileReturn)

 			{

 			ERR_PRINTF1(_L("BagValue:Not able to open the file"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			}	

 		}

 	CleanupClosePushL(file);

 	//raw data for reading the bagvalue

 	HBufC8 *rawData=NULL;

 	TInt filesize=0;	

 	if(flagReturn)

 		{

 		User::LeaveIfError(file.Size(filesize));

 		rawData=HBufC8::NewMaxLC(filesize);

 		TPtr8 data(rawData->Des());

 		if(file.Read(data))

 			{

 			ERR_PRINTF1(_L("BagValue:Not able to Read the file"));

 			SetTestStepResult(EFail);

 			flagReturn=EFalse;

 			}

 		}

 	if(flagReturn)

 		{

 	  	//compare the data

 	  	if(rawData->CompareC(aBagData.EncodedShroudedKey())!=0)

 			{

 			iActualResult=EFalse;

 			}

 		//retrieve the expected result:PositiveTest/NegativeTest	

 		if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))

 			{

 			WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));

 			iExpectedResult=KPositiveTest;

 			}			

 		//check for positive or negative test	

 		if(!VerifyExpectedError(aSecName))

 			{

 			INFO_PRINTF1(_L("BagValue Failed"));

 			SetTestStepResult(EFail);

 			flagReturn = EFalse;

 			}			

 		}

 	if(rawData!=NULL)	

 		{

 		CleanupStack::PopAndDestroy(rawData); 	

 		}

 	if(!fileReturn)

 		{

 		file.Close();	

 		}

 	CleanupStack::PopAndDestroy(&file);

 	return flagReturn;

 	}