// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

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

// This file contains the implementation of the Similator TSY Packet Context functionality.  

// 

//

/**

 @file

*/

#include "Simlog.h"

#include "CSimPhone.h"

#include "CSimPacketContext.h"

#include "CSimPacketService.h"

#include "CSimPacketQoS.h"

#include "utils.h"

#include "CSimContextHelper.h"

const TInt KUnsetInteger = 0;

CPcktListReadAllAttempt* CPcktListReadAllAttempt::NewL(TClientId& aId, TTsyReqHandle aReqHandle)

/**

 * Standard two phase constructor.

 * @param aId The client ID (session and sub-session handles) that uniquely identifies a client performing a two phase read.

 * @param aReqHandle The TSY request handle of the client request associated with a two phase read.

 * @return CPcktListReadAllAttempt* The newly created object.

 */

	{

	CPcktListReadAllAttempt* read=new(ELeave) CPcktListReadAllAttempt(aId, aReqHandle);

	CleanupStack::PushL(read);

	read->ConstructL();

	CleanupStack::Pop();

	return read;

	}

CPcktListReadAllAttempt::CPcktListReadAllAttempt(TClientId& aId, TTsyReqHandle aReqHandle)

		: iReqHandle(aReqHandle)

/**

 * Trivial first phase constructor.

 * @param aId The client ID (session and sub-session handles) that uniquely identifies a client performing a two phase read.

 * @param aReqHandle The TSY request handle of the client request associated with a two phase read.

 */

	{

	iClient.iSessionHandle=aId.iSessionHandle;

	iClient.iSubSessionHandle=aId.iSubSessionHandle;

	}

void CPcktListReadAllAttempt::ConstructL()

/**

 * Trivial second phase constructor.

 */

	{

	User::LeaveIfError(iListBuf!=NULL);

	}

CPcktListReadAllAttempt::~CPcktListReadAllAttempt()

/**

 * Trivial destructor.

 */

	{

	delete iListBuf;

	}

CSimPacketContext* CSimPacketContext::NewL(CSimPhone* aPhone, CSimPacketService* aPacketService, const TDesC& aContextName)

/**

* Standard two phase constructor

*

* @param aPacketService Pointer to the Packet Service object (CSimPacketService)

* @param aContextName name  for this packet context

* @return CSimPacketContext pointer to the packet context object created.

* @leave Leaves if no memory or object is not created for any reason.

*/

	{

	CSimPacketContext* packetContext = new(ELeave) CSimPacketContext(aPhone, aPacketService, aContextName);

	CleanupStack::PushL(packetContext);

	packetContext->ConstructL();

	CleanupStack::Pop();

	return packetContext;

	}

void CSimPacketContext::Init()

	{}

CSimPacketContext::CSimPacketContext(CSimPhone* aPhone, CSimPacketService* aPacketService, const TName& aContextName)

	: iPhone(aPhone), iDeleted(EFalse),iIsActive(EFalse),iPacketService(aPacketService),iContextName(aContextName),

	  iTFTCreated(EFalse), iNumTFTsCreated(-1), iNumFiltersAdded(0),

      iContextConfigParamsIndex(0), iCommPortLoaned(EFalse),iQoSObjectCount(0),

      iNotifyContextConfigChangeArray(NULL), iSetConfigData(NULL), iSetConfigCallCount(0), iTFTChangeBool(0),

      iNotifyContextStatusChangeIndex(0),iState(RPacketContext::EStatusInactive)

/**

* Trivial Constructor.  Initialises all the data members

*

* @param aPacketService Pointer to the Packet Service object (CSimPacketService)

* @param aContextName name  for this packet context

*/

	{

	iNotifyStatusChange.iNotifyPending = EFalse;

	iNotifyConfigGPRS.iNotifyPending= EFalse;

	iNotifyConfigR99.iNotifyPending= EFalse;

	iNotifyConfigR5.iNotifyPending= EFalse;

	}

void CSimPacketContext::ConstructL()

/**

* Second phase of the 2-phase constructor.

* Constructs all the member data and retrieves all the data from the config file specific to this class.

*

* @leave Leaves no memory or any data member does not construct for any reason.

*/

	{

	LOGPACKET1("CSimPacketContext: Entered constructor");

	iSetConfigData = new (ELeave) CArrayFixFlat<TSetConfigData>(1);

	iNotifyContextConfigChangeArray = new (ELeave) CArrayFixFlat<TNotifyContextConfigChangeData>(1);

	iContextConfigParams = new (ELeave) CArrayFixFlat<TContextConfigParam>(KNumberofConfigs);

	iAuthorizationTokenResponse = new (ELeave) CArrayFixFlat<TAuthorizationTokenResponse>(KNumberofConfigs);

	iMediaAuthorization = new (ELeave) CArrayFixFlat<RPacketContext::CTFTMediaAuthorizationV3>(KNumberofConfigs);

	iNtRas = CSimNtRas::NewL(iPhone);

	iTimer = CSimTimer::NewL(iPhone);

	iNotifyContextStatusChangeTimer = CSimTimer::NewL(iPhone);

	iSetConfigTimer = CSimTimer::NewL(iPhone);

	iInitContextTimer = CSimTimer::NewL(iPhone);

	iCreateTftTimer = CSimTimer::NewL(iPhone);

	iNotifyContextConfigChangeTimer= CSimTimer::NewL(iPhone);

	iContextStatusChange = CSimPubSubChange::NewL(this, CSimPubSub::TPubSubProperty(KUidPSSimTsyCategory, KPSSimtsyPacketContextStatusChange, KPSSimtsyPacketContextStatusChangeKeyType));

	LOGPACKET1("Starting to Load and Parse Packet Context the Config File");

	GetCommSetupSettingsL();

	GetContextConfigParamSettingsL(KSetContextConfigGPRS());

	GetContextConfigParamSettingsL(KSetContextConfigRel99());

	GetContextConfigParamSettingsL(KSetContextConfigRel5());

	GetActivateSettings();

	GetSetConfigSettings();

	GetPacketFilterSettings();

	GetContextConfigRel99SettingsL();

	ConstructPacketFiltersL();

	GetContextStatusChangeSettingsL();

	GetContextConfigChangeSettingsL();

	TInt nestedItemNumber; // used for nested loop

	const CTestConfigItem* item2; // used for nested items

	TUint count = CfgFile()->ItemCount(KAuthorizationToken);		

	TUint itemPosition = 0;

	TUint itemOffSet = 0;

	for(TInt i=0;i<count;i++)							// set up AuthorizationToken info

		{

		const CTestConfigItem *item = CfgFile()->Item(KAuthorizationToken,i);

		if(!item)

			break;

		RPacketContext::CTFTMediaAuthorizationV3* mediaAuthorization = RPacketContext::CTFTMediaAuthorizationV3::NewL();

        CleanupStack::PushL(mediaAuthorization);		

		TAuthorizationTokenResponse authorizationTokenResponse;

		TPtrC8 authorizationToken;

		TInt desiredResponse;

		TInt numberOfFlowIds;

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("CTFTMediaAuthorizationV3::authorizationToken",ret,0,&KAuthorizationToken);

            CleanupStack::PopAndDestroy(mediaAuthorization);			

			continue;

			}

		else

			{

			mediaAuthorization->iAuthorizationToken.Copy(authorizationToken); // Set up for media authorization

			authorizationTokenResponse.iAuthorizationToken.Copy(authorizationToken); // Set up for token response

			}

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

		if(ret!=KErrNone || desiredResponse > 0)

			{

			LOGPARSERR("desiredResponse",ret,1,&KAuthorizationToken);

	        CleanupStack::PopAndDestroy(mediaAuthorization);

			continue;

			}

		else

			{

			authorizationTokenResponse.iResponse = desiredResponse;

			}

		iAuthorizationTokenResponse->AppendL(authorizationTokenResponse);

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

		for(nestedItemNumber=itemPosition+itemOffSet;nestedItemNumber<itemOffSet+numberOfFlowIds;nestedItemNumber++)

			{

			item2 = CfgFile()->Item(KFlowIdentifier,nestedItemNumber);

			if(!item2)

				break;

			RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier iFlowIdentifier;

			TInt mediaComponentNumber;

			TInt IPFlowNumber;

			ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,0,mediaComponentNumber);

			if(ret!=KErrNone || mediaComponentNumber < 0)

				{

				LOGPARSERR("CTFTMediaAuthorizationV3::mediaComponentNumber",ret,0,&KFlowIdentifier);

				continue;

				}

			else

				{

				iFlowIdentifier.iMediaComponentNumber = mediaComponentNumber;

				}

			ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,1,IPFlowNumber);

			if(ret!=KErrNone || IPFlowNumber < 0)

				{

				LOGPARSERR("CTFTMediaAuthorizationV3::IPFlowNumber",ret,1,&KFlowIdentifier);

				continue;

				}

			else

				{

				iFlowIdentifier.iIPFlowNumber = IPFlowNumber;

				}

			mediaAuthorization->iFlowIds.Append(iFlowIdentifier);

			}

		itemOffSet+=numberOfFlowIds;

		iMediaAuthorization->AppendL(*mediaAuthorization); // Add completed media authorization to array

        CleanupStack::Pop(mediaAuthorization);		

		}

	LOGPACKET1("...Finished parsing Packet Context config parameters...");

	}	

void CSimPacketContext::GetCommSetupSettingsL()

	{

	iCommSetupArray = new (ELeave) CArrayFixFlat<TCommSetupItem>(KNumberofConfigs);

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

	if(count==0)

		{

		TCommSetupItem comm;

		comm.iCsyName.Copy(KDefaultCsyName);

		comm.iPortName.Copy(KDefaultPortName);

		comm.iConfig.iRate=KDefaultCommPortRate;

		comm.iConfig.iHandshake=KDefaultHandshake;	

		comm.iContextName=KDefaultSetting;

		comm.iCommReset = EFalse;

		comm.iNumInitializeFailures = 0;

		comm.iErrorCode = KErrNone;

		comm.iDelay = 0;

		iCommSetupArray->AppendL(comm);

		}

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

		{

		const CTestConfigItem* item = CfgFile()->Item(KCommSetup,i);

		if(item)

			{

			TCommSetupItem comm;

			TPtrC8 portName,csyName,contextName;

			TInt commReset, numInitializeFailures, errorCode, delay;

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

			if(ret!=KErrNone)

				{

				LOGPARSERR("CommSetUp::csyName",ret,0,&KCommSetup);

				comm.iCsyName.Copy(KDefaultCsyName);

				}

			else

				comm.iCsyName.Copy(csyName);

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

			if(ret!=KErrNone)

				{

				LOGPARSERR("CommSetUp::portName",ret,1,&KCommSetup);

				comm.iPortName.Copy(KDefaultPortName);

				}

			else

				comm.iPortName.Copy(portName);

			TInt dataRate,handshake;

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

			if(ret!=KErrNone)

				{

				LOGPARSERR("CommSetUp::dataRate",ret,2,&KCommSetup);

				comm.iConfig.iRate=KDefaultCommPortRate;

				}

			else

				comm.iConfig.iRate=(TBps)dataRate;

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

			if(ret!=KErrNone)

				{

				LOGPARSERR("CommSetUp::handShake",ret,3,&KCommSetup);

				comm.iConfig.iHandshake=KDefaultHandshake;

				}

			else

				comm.iConfig.iHandshake=(TUint)handshake;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,contextName);

			if(ret!=KErrNone)

				{

				LOGPARSERR("CommSetUp::contextName",ret,4,&KCommSetup);

				comm.iContextName=KDefaultSetting;

				}

			else

				comm.iContextName.Copy(contextName);

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,commReset);

			if(ret!=KErrNone)

				{

				LOGPARSERR("CommSetUp::commReset",ret,5,&KCommSetup);

				comm.iCommReset=EFalse;

				}

			else

				comm.iCommReset = commReset;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,numInitializeFailures);

			if(ret!=KErrNone)

				{

				comm.iNumInitializeFailures = 0;

				}

			else

				comm.iNumInitializeFailures = numInitializeFailures;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,errorCode);

			if(ret!=KErrNone)

				{

				comm.iErrorCode = KErrNone;

				}

			else

				comm.iErrorCode = errorCode;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,delay);

			if(ret!=KErrNone)

				{

				comm.iDelay = 0;

				}

			else

				comm.iDelay = delay;

			iCommSetupArray->AppendL(comm);

			}

		}

	}

void CSimPacketContext::GetContextConfigParamSettingsL(TPtrC8 aTag)

	{		

	CSimContextHelper::GetContextConfigParamSettingsL( CfgFile(), aTag, iContextConfigParams );		

	}

void CSimPacketContext::GetActivateSettings()

	{

	TInt ret;

	const CTestConfigItem* item=CfgFile()->Item(KActivatePauseDuration); //< Find the Activate data item

	if(item)

		{										//< then retrieve the activation pause

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

		if(ret!=KErrNone)

			iActivatePause = KDefaultPauseDuration;

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

		if(ret==KErrNotFound)

			iActivateFail = KErrNone;

		}

	item=CfgFile()->Item(KDeactivatePauseDuration);	//< Find the Deactivate data item

	if(item)

		{											//< then retrieve the deactivation pause

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

		if(ret!=KErrNone)

			iDeactivatePause = KDefaultPauseDuration;

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

		if(ret==KErrNotFound)

			iDeactivateFail = KErrNone;

		}

	item=CfgFile()->Item(KDeletePauseDuration);	//< Find the Delete data item

	if(item)

		{										//< then retrieve the delete pause

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

		if(ret!=KErrNone)

			iDeletePause = KDefaultPauseDuration;

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

		if(ret==KErrNotFound)

			iDeleteFail = KErrNone;

		}

	}

void CSimPacketContext::GetSetConfigSettings()

	{

	iSetConfigDelay = 0;

	const CTestConfigItem* item=iPacketService->CfgFile()->Item(KSetConfigDelay);

	if(item)

		{

		TInt delay = 0;

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

		if(ret != KErrNone || delay < 0)

			{

			LOGPARSERR("SetConfigDelay",ret,0,&KSetConfigDelay);

			}

		else

			{

			iSetConfigDelay = delay;

			}

		}

	item=iPacketService->CfgFile()->Item(KSetConfigFail);	// Set the SetConfigFail struct

	if(item)

		{

		TPtrC8 contextName, numberOfTimes, failErrorCode;

		TInt32 digit = 0;

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("SetConfigFail::contextName",ret,0,&KSetConfigFail);

			}

		else

			{

				iSetConfigFail.iContextName.Copy(contextName);

			}

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("SetConfigFail::numberOfTimes",ret,1,&KSetConfigFail);

			}

		else

			{

				if(AsciiToNum(numberOfTimes, digit)==KErrNone)

					iSetConfigFail.iNumberOfTimes = digit;

			}

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("SetConfigFail::failErrorCode",ret,2,&KSetConfigFail);

			}

		else

			{

				if(AsciiToNum(failErrorCode, digit)==KErrNone)

					iSetConfigFail.iFailErrorCode = digit;

			}

		}

	}

void CSimPacketContext::GetContextConfigChangeSettingsL()

	{

	TNotifyContextConfigChangeData configChangeData;

	TUint count = CfgFile()->ItemCount(KNotifyContextConfigChange);

	TInt index;

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

		{

		const CTestConfigItem *item = 

			CfgFile()->Item(KNotifyContextConfigChange,index);

		if(!item)

			{

			break;

			}

		//Get the Notify Context Config Change Delay value

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

					configChangeData.iDelay);

		if(ret!=KErrNone)

			{

			LOGPARSERR("NotifyContextConfigChange::delay",ret,0,&KNotifyContextConfigChange);

			continue;

			}

		//Get the Notify Context Config Change, config index value

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

					configChangeData.iNewContextConfigIndex);

		if(ret!=KErrNone)

			{

			LOGPARSERR("NotifyContextConfigChange::NewContextConfigIndex",

						ret,0,&KNotifyContextConfigChange);

			continue;		

			}

		iNotifyContextConfigChangeArray->AppendL(configChangeData);

		}

	}

void CSimPacketContext::GetPacketFilterSettings()

	{

	TInt ret;

	const CTestConfigItem* item=iPacketService->CfgFile()->Item(KDeleteTftFail);

	if(item)

	{

		TPtrC8 contextName, numberOfTimes, failErrorCode;

		TInt32 digit = 0;

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("SetConfigFail::contextName",ret,0,&KDeleteTftFail);

			}

		else

			{

			iDeleteTftFail.iContextName.Copy(contextName);