// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Defines the CSimSmartCardEap class componenet

// 

//

/**

 @file

*/

#include <testconfigfileparser.h>

#include "csimsmartcardeap.h"

#include "etelext.h"

// CSimSmartCardEapManager implementation; related to CSimSmartCardEap //

/**

Default constructor to initialise Ptrs.

*/

TEapChngResp::TEapChngResp()

: iChallenge(NULL), iResp(NULL),

  iAuthStatus(RMobileSmartCardEap::ENoAuthStarted)

	{

	}

/**

Default constructor to initialise Ptrs.

*/

TEapProcedureData::TEapProcedureData()

: iEapKey(NULL), iEapExtKey(NULL), iEapId(NULL), iEapPsId(NULL)

	{

	}

/**

Factory constructor.

*/

CSimSmartCardEapManager* CSimSmartCardEapManager::NewL(CSimPhone *aPhone)

	{

	CSimSmartCardEapManager* phone = new(ELeave) CSimSmartCardEapManager(aPhone);

	CleanupStack::PushL(phone);

	phone->ConstructL();

	CleanupStack::Pop();

	return phone;

	}

/**

Default constructor, initialises a pointer to the owner phone object.

*/

CSimSmartCardEapManager::CSimSmartCardEapManager(CSimPhone *aPhone)

: iPhone(aPhone)

	{

	}

/**

Second-phase constructor.

*/

void CSimSmartCardEapManager::ConstructL()

	{

	ParseEapInfoL();

	}

/**

If this is destroyed then so should all EAP sub-session objects.

*/

CSimSmartCardEapManager::~CSimSmartCardEapManager()

	{

	for (TInt jj = iSubSessionObjs.Count()-1; jj >= 0; jj--)

		{

		delete iSubSessionObjs[jj];

		}

	iSubSessionObjs.Close();

	ClearParsedData();

	}

void CSimSmartCardEapManager::ClearParsedData()

	{

	// Cleanup remaining unused parsed EAP procedure data

	for (TInt jjj = 0; jjj < iEapProcData.Count(); jjj++)

		{

		for (TInt aa = 0; aa < iEapProcData[jjj].iChResp.Count(); aa++)

			{

			TEapChngResp& temp = iEapProcData[jjj].iChResp[aa];

			delete (temp.iChallenge);

			delete (temp.iResp);

			temp.iChallenge = NULL;

			temp.iResp = NULL;

			}

		iEapProcData[jjj].iChResp.Close();

		delete iEapProcData[jjj].iEapKey;

		delete iEapProcData[jjj].iEapExtKey;

		delete iEapProcData[jjj].iEapId;

		delete iEapProcData[jjj].iEapPsId;

		iEapProcData[jjj].iEapKey = NULL;

		iEapProcData[jjj].iEapExtKey = NULL;

		iEapProcData[jjj].iEapId = NULL;

		iEapProcData[jjj].iEapPsId = NULL;

		}

	iEapProcData.Close();

	iDiscardedProcedure.Close();

	}

/**

Returns a pointer to the selected config.txt file section.

*/

const CTestConfigSection* CSimSmartCardEapManager::CfgFile()

	{

	return iPhone->CfgFile();

	}

/**

Parses the UICC App EAP specific settings from the config.txt.

*/

void CSimSmartCardEapManager::ParseEapInfoL()

	{

	CTestConfigItem* item = NULL;

	TInt count = CfgFile()->ItemCount(KScEapProcedures);

	// Used in parsing to keep track of the nested items

	TInt nestedKeyTag = 0;

	TInt nestedExtKeyTag = 0;

	TInt nestedIdTag = 0;

	TInt nestedPsIdTag = 0;

	TInt nestedChlTag = 0;

	// Counts of the total number of tags (considered as nested tags)

	TInt countKey = CfgFile()->ItemCount(KScEapKeyMSK);

	TInt countExtKey = CfgFile()->ItemCount(KScEapKeyEMSK);

	TInt countId = CfgFile()->ItemCount(KScEapIdentity);

	TInt countPsId = CfgFile()->ItemCount(KScEapPsIdentity);

	TInt countChl = CfgFile()->ItemCount(KScEapChallenge);

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

		{

		item = const_cast<CTestConfigItem*>(CfgFile()->Item(KScEapProcedures, index));

		if(item == NULL)

			{

			continue;

			}

		TInt dataFrmt = 0;

		TInt numChallenges = 0;

		TInt ret = KErrNone;

		TPtrC8 appId, eapType;

		// To be populated and appended to iEapProcData later

		TEapProcedureData procInfo;

		// Get AID; convert to bin if required

		ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 0, appId);

		if(ret != KErrNone)

			{

			continue;

			}

		else

			{

			procInfo.iAID = appId;

			// AID is always in binary format (because of the RMobileSmartCardEap::Open construction)

			ParseMixedBinaryAsciiDataL(procInfo.iAID);

			}

		// Get eap type

		ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 1, eapType);

		if(ret != KErrNone)

			{

			continue;

			}

		else

			{

			// EAP type is always in ASCII

			procInfo.iEapType = eapType;

			}

		// Find number of challenges

		ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 2, numChallenges);

		if(ret != KErrNone)

			{

			continue;

			}

		else if (numChallenges > (countChl - nestedChlTag))

			{

			continue;

			}

		else if (numChallenges < 0)

			{

			continue;

			}

		// Get optional data format; this format is used for all data of this parsed procedure

		ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 3, dataFrmt);

		if(ret != KErrNone)

			{

			}

		else if (dataFrmt >= EMaxConfigDataFormat)

			{

			dataFrmt = EConfigDataFormatAscii;

			}

		TPtrC8 ptr;

		TPtr8 tempPtr(NULL,0);

		HBufC8* startData = NULL;

		// Get MSK

		if (nestedKeyTag < countKey)

			{

			item = const_cast<CTestConfigItem*>(CfgFile()->Item(KScEapKeyMSK, nestedKeyTag++));

			// parse delay and key

			if (item == NULL)

				{

				}

			else

				{

				ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 0, ptr);

				if (ret != KErrNone)

					{

					}

				else

					{

					TRAPD(kAllocErr, startData = ptr.AllocL());

					if (kAllocErr != KErrNone)

						{

						}

					else

						{

						tempPtr.Set(startData->Des());

						switch (dataFrmt)

							{

						case EConfigDataFormatMixedBinaryAndAscii:

							ParseMixedBinaryAsciiDataL(tempPtr);

							break;

						//case EConfigDataFormatAscii: // Do nothing

						//default:

							}

						// need to re-copy because converting to binary changes size

						TRAP(kAllocErr, procInfo.iEapKey = tempPtr.AllocL());

						if (kAllocErr != KErrNone)

							{

							}

						delete startData;

						startData = NULL;

						}

					}

				}

			}

		else

			{

			}

		// Get EMSK

		if (nestedExtKeyTag < countExtKey)

			{

			item = const_cast<CTestConfigItem*>(CfgFile()->Item(KScEapKeyEMSK, nestedExtKeyTag++));

			// parse key

			if (item == NULL)

				{

				}

			else

				{

				ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 0, ptr);

				if (ret != KErrNone)

					{

					}

				else

					{

					TRAPD(kAllocErr, startData = ptr.AllocL());

					if (kAllocErr != KErrNone)

						{

						}

					else

						{

						tempPtr.Set(startData->Des());

						switch (dataFrmt)

							{

						case EConfigDataFormatMixedBinaryAndAscii:

							ParseMixedBinaryAsciiDataL(tempPtr);

							break;

						//case EConfigDataFormatAscii: // Do nothing

						//default:

							}

						// need to re-copy because converting to binary changes size

						TRAP(kAllocErr, procInfo.iEapExtKey = tempPtr.AllocL());

						if (kAllocErr != KErrNone)

							{

							}

						delete startData;

						startData = NULL;

						}

					}

				}

			}

		else

			{

			}

		// Get Permanent Identity

		if (nestedIdTag < countId)

			{

			item = const_cast<CTestConfigItem*>(CfgFile()->Item(KScEapIdentity, nestedIdTag++));

			// parse id

			if (item == NULL)

				{

				}

			else

				{

				ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 0, ptr);

				if (ret != KErrNone)

					{

					}

				else

					{

					TRAPD(idAllocErr, startData = ptr.AllocL());

					if (idAllocErr != KErrNone)

						{

						}

					else

						{

						TPtr8 tempPtr(NULL,0);

						tempPtr.Set(startData->Des());

						switch (dataFrmt)

							{

						case EConfigDataFormatMixedBinaryAndAscii:

							ParseMixedBinaryAsciiDataL(tempPtr);

							break;

						//case EConfigDataFormatAscii: // Do nothing

						//default:

							}

						// need to re-copy because converting to binary changes size

						TRAP(idAllocErr, procInfo.iEapId = tempPtr.AllocL());

						if (idAllocErr != KErrNone)

							{

							}

						delete startData;

						startData = NULL;

						}

					}

				}

			}

		else

			{

			}

		// Get Pseudonym Identity

		if (nestedPsIdTag < countPsId)

			{

			item = const_cast<CTestConfigItem*>(CfgFile()->Item(KScEapPsIdentity, nestedPsIdTag++));

			// parse id

			if (item == NULL)

				{

				}

			else

				{

				ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 0, ptr);

				if (ret != KErrNone)

					{

					}

				else

					{

					TRAPD(idAllocErr, startData = ptr.AllocL());

					if (idAllocErr != KErrNone)

						{

						}

					else

						{

						TPtr8 tempPtr(NULL,0);

						tempPtr.Set(startData->Des());

						switch (dataFrmt)

							{

						case EConfigDataFormatMixedBinaryAndAscii:

							ParseMixedBinaryAsciiDataL(tempPtr);

							break;

						//case EConfigDataFormatAscii: // Do nothing

						//default:

							}

						// need to re-copy because converting to binary changes size

						TRAP(idAllocErr, procInfo.iEapPsId = tempPtr.AllocL());

						if (idAllocErr != KErrNone)

							{

							}

						delete startData;

						startData = NULL;

						}

					}

				}

			}

		else

			{

			}

		// Get challenges

		// numChallenges is what is parsed from config.txt and will be

		//    decremented in loop till zero is reached.

		// nestedChlTag keeps track of the current KScEapChallenge tag

		//    being read of the total; i.e. not just nested.

		// countChl is the total number of KScEapChallenge found.

		while (numChallenges != 0)

			{

			if (nestedChlTag >= countChl)

				{

				break;

				}

			item = const_cast<CTestConfigItem*>(CfgFile()->Item(KScEapChallenge, nestedChlTag++));

			numChallenges--;

			// parse delay and challenge/response and auth status

			if (item == NULL)

				{

				continue;

				}

			// Parse challenge

			ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 0, ptr);

			if (ret != KErrNone)

				{

				continue;

				}

			TRAPD(leaveErr, startData = ptr.AllocL());

			if (leaveErr != KErrNone)

				{

				continue;

				}

			tempPtr.Set(startData->Des());

			switch (dataFrmt)

				{

			case EConfigDataFormatMixedBinaryAndAscii:

				ParseMixedBinaryAsciiDataL(tempPtr);

				break;

			//case EConfigDataFormatAscii: // Do nothing

			//default:

				}

			TEapChngResp newChRespData;

			TRAP(leaveErr, newChRespData.iChallenge = tempPtr.AllocL());

			if (leaveErr != KErrNone)

				{

				}

			delete startData;

			startData = NULL;

			// Parse response

			ret = CTestConfig::GetElement(item->Value(), KStdDelimiter, 1, ptr);

			if (ret != KErrNone)

				{

				continue;

				}