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

//

#include "CSimContextHelper.h"

#include "CSimPacketContext.h"

#include "Simlog.h"

                                                                                                                   //const RPacketContext::TContextConfigGPRS&  aContextConfigV1        

void CSimContextHelper::SetTContextConfigParamFromTContextConfigGPRS( TContextConfigParam& aContextConfigToSet, const RPacketContext::TContextConfigGPRS&  aContextConfigV1 )

	{		

	aContextConfigToSet.iProtocolType = aContextConfigV1.iPdpType;

	aContextConfigToSet.iGsnAddress.Set(aContextConfigV1.iAccessPointName);

	aContextConfigToSet.iProtocolAddress.Set(aContextConfigV1.iPdpAddress);

	aContextConfigToSet.iAnonymousAccess = aContextConfigV1.iAnonymousAccessReqd;

	aContextConfigToSet.iUseEdge = aContextConfigV1.iUseEdge;

	aContextConfigToSet.iProtocolConfigOption.iAuthProtocol = aContextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol;

	aContextConfigToSet.iProtocolConfigOption.iUsername.Set(aContextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername);

	aContextConfigToSet.iProtocolConfigOption.iPassword.Set(aContextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword);

	aContextConfigToSet.iProtocolConfigOption.iChallenge.Set(aContextConfigV1.iProtocolConfigOption.iChallenge);

	aContextConfigToSet.iProtocolConfigOption.iResponse.Set(aContextConfigV1.iProtocolConfigOption.iResponse);

	aContextConfigToSet.iProtocolConfigOption.iPrimaryDNS.Set(aContextConfigV1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);

	aContextConfigToSet.iProtocolConfigOption.iSecondaryDNS.Set(aContextConfigV1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);

	aContextConfigToSet.iProtocolConfigOption.iId = aContextConfigV1.iProtocolConfigOption.iId;

	aContextConfigToSet.iProtocolConfigOption.iMiscBuffer = aContextConfigV1.iProtocolConfigOption.iMiscBuffer;

	if((aContextConfigV1.iPdpCompression & RPacketContext::KPdpHeaderCompression) != 0)

		{

		aContextConfigToSet.iPdpHeaderCompression = RPacketContext::EManufacturerDefaultHeaderCompression;

		}

	else

		{

		aContextConfigToSet.iPdpHeaderCompression = RPacketContext::ENoHeaderCompression;

		}

	if((aContextConfigV1.iPdpCompression & RPacketContext::KPdpDataCompression) != 0)

		{

		aContextConfigToSet.iPdpDataCompression = RPacketContext::EManufacturerDefaultDataCompression;

		}

	else

		{

		aContextConfigToSet.iPdpDataCompression = RPacketContext::ENoDataCompression;

		}	

	}

void CSimContextHelper::SetTContextConfigParamFromTContextConfigR99_R4( TContextConfigParam& aContextConfigToSet, const RPacketContext::TContextConfigR99_R4& aContextConfigV1 )

	{			

	aContextConfigToSet.iProtocolType = aContextConfigV1.iPdpType;

	aContextConfigToSet.iGsnAddress.Set(aContextConfigV1.iAccessPointName);

	aContextConfigToSet.iProtocolAddress.Set(aContextConfigV1.iPdpAddress);

	aContextConfigToSet.iAnonymousAccess = 0; /*RPacketContext::TAnonymousAccess::ENotApplicable;*/

	aContextConfigToSet.iUseEdge = aContextConfigV1.iUseEdge;

	aContextConfigToSet.iProtocolConfigOption.iAuthProtocol = aContextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol;

	aContextConfigToSet.iProtocolConfigOption.iUsername.Set(aContextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername);

	aContextConfigToSet.iProtocolConfigOption.iPassword.Set(aContextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword);

	aContextConfigToSet.iProtocolConfigOption.iChallenge.Set(aContextConfigV1.iProtocolConfigOption.iChallenge);

	aContextConfigToSet.iProtocolConfigOption.iResponse.Set(aContextConfigV1.iProtocolConfigOption.iResponse);

	aContextConfigToSet.iProtocolConfigOption.iPrimaryDNS.Set(aContextConfigV1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);

	aContextConfigToSet.iProtocolConfigOption.iSecondaryDNS.Set(aContextConfigV1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);

	aContextConfigToSet.iProtocolConfigOption.iId = aContextConfigV1.iProtocolConfigOption.iId;

	aContextConfigToSet.iPdpHeaderCompression = RPacketContext::ENoHeaderCompression;

	aContextConfigToSet.iPdpDataCompression = RPacketContext::ENoDataCompression;

	aContextConfigToSet.iProtocolConfigOption.iMiscBuffer = aContextConfigV1.iProtocolConfigOption.iMiscBuffer;

	}

void CSimContextHelper::SetTContextConfigParamFromTContextConfig_R5(TContextConfigParam& aContextConfigToSet,const RPacketContext::TContextConfig_R5& aContextConfigV1 )

	{

	aContextConfigToSet.iProtocolType = aContextConfigV1.iPdpType;

	aContextConfigToSet.iGsnAddress.Set(aContextConfigV1.iAccessPointName);

	aContextConfigToSet.iProtocolAddress.Set(aContextConfigV1.iPdpAddress);

	aContextConfigToSet.iAnonymousAccess = 0; /*RPacketContext::TAnonymousAccess::ENotApplicable;*/

	aContextConfigToSet.iUseEdge = aContextConfigV1.iUseEdge;

	aContextConfigToSet.iProtocolConfigOption.iAuthProtocol = aContextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol;

	aContextConfigToSet.iProtocolConfigOption.iUsername.Set(aContextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername);

	aContextConfigToSet.iProtocolConfigOption.iPassword.Set(aContextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword);

	aContextConfigToSet.iProtocolConfigOption.iChallenge.Set(aContextConfigV1.iProtocolConfigOption.iChallenge);

	aContextConfigToSet.iProtocolConfigOption.iResponse.Set(aContextConfigV1.iProtocolConfigOption.iResponse);

	aContextConfigToSet.iProtocolConfigOption.iPrimaryDNS.Set(aContextConfigV1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);

	aContextConfigToSet.iProtocolConfigOption.iSecondaryDNS.Set(aContextConfigV1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);

	aContextConfigToSet.iProtocolConfigOption.iId = aContextConfigV1.iProtocolConfigOption.iId;

	aContextConfigToSet.iPdpHeaderCompression = aContextConfigV1.iPdpHeaderCompression;

	aContextConfigToSet.iPdpDataCompression = aContextConfigV1.iPdpDataCompression;

	aContextConfigToSet.iProtocolConfigOption.iMiscBuffer = aContextConfigV1.iProtocolConfigOption.iMiscBuffer;

	}

TBool CSimContextHelper::EqualTContextConfigParam(const TContextConfigParam& aContextConfigLHS, const TContextConfigParam& aContextConfigRHS )

	{

	if((aContextConfigLHS.iProtocolType != aContextConfigRHS.iProtocolType) ||

		(aContextConfigLHS.iGsnAddress.Compare(aContextConfigRHS.iGsnAddress) != 0 ) ||

		(aContextConfigLHS.iAnonymousAccess != aContextConfigRHS.iAnonymousAccess) ||

		(aContextConfigLHS.iUseEdge != aContextConfigRHS.iUseEdge) ||

		(aContextConfigLHS.iProtocolConfigOption.iAuthProtocol != aContextConfigRHS.iProtocolConfigOption.iAuthProtocol) ||

		(aContextConfigLHS.iProtocolConfigOption.iUsername.Compare(aContextConfigRHS.iProtocolConfigOption.iUsername) != 0) ||

		(aContextConfigLHS.iProtocolConfigOption.iPassword.Compare(aContextConfigRHS.iProtocolConfigOption.iPassword) != 0) ||

		(aContextConfigLHS.iProtocolConfigOption.iChallenge.Compare(aContextConfigRHS.iProtocolConfigOption.iChallenge) != 0) ||

		(aContextConfigLHS.iProtocolConfigOption.iResponse.Compare(aContextConfigRHS.iProtocolConfigOption.iResponse) != 0) ||

		// These line are commented as these parameters currently are usually returned by the network and not required for

		// setting the context configuration

		//		(aContextConfigLHS.iProtocolConfigOption.iPrimaryDNS.Compare(aContextConfigRHS.iProtocolConfigOption.iPrimaryDNS) != 0) ||

		//		(aContextConfigLHS.iProtocolConfigOption.iSecondaryDNS.Compare(aContextConfigRHS.iProtocolConfigOption.iSecondaryDNS) != 0) ||

		(aContextConfigLHS.iProtocolConfigOption.iId != aContextConfigRHS.iProtocolConfigOption.iId) ||

		(aContextConfigLHS.iPdpHeaderCompression != aContextConfigRHS.iPdpHeaderCompression) ||

		(aContextConfigLHS.iPdpDataCompression != aContextConfigRHS.iPdpDataCompression))

		{

		return EFalse;

		}

		// else considered equal.

	return ETrue;

	}

void CSimContextHelper::ConvertConfigParams(const TContextConfigParam& aInputConfig, RPacketContext::TContextConfigGPRS& aOutputConfig)

	{

	aOutputConfig.iPdpType = static_cast<RPacketContext::TProtocolType>(aInputConfig.iProtocolType);

	aOutputConfig.iAccessPointName.Copy(aInputConfig.iGsnAddress);

	aOutputConfig.iPdpAddress.Copy(aInputConfig.iProtocolAddress);

	//Translate the R5 SIMTSY internal representation of PDP Data/Header into the GPRS representation

	TUint pdpCompressionParam = 0;

	if(aInputConfig.iPdpDataCompression != static_cast<TUint>(RPacketContext::ENoDataCompression))

		{

		pdpCompressionParam = (pdpCompressionParam | RPacketContext::KPdpDataCompression);

		}

	if(aInputConfig.iPdpHeaderCompression != RPacketContext::ENoHeaderCompression)

		{

		pdpCompressionParam = (pdpCompressionParam | RPacketContext::KPdpHeaderCompression);

		}

	aOutputConfig.iPdpCompression = pdpCompressionParam;

	aOutputConfig.iAnonymousAccessReqd = static_cast<RPacketContext::TAnonymousAccess>(aInputConfig.iAnonymousAccess);		

	aOutputConfig.iUseEdge = static_cast<TBool>(aInputConfig.iUseEdge);

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iProtocol = static_cast<RPacketContext::TAuthProtocol>(aInputConfig.iProtocolConfigOption.iAuthProtocol);

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iUsername.Copy(aInputConfig.iProtocolConfigOption.iUsername);

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iPassword.Copy(aInputConfig.iProtocolConfigOption.iPassword);

	aOutputConfig.iProtocolConfigOption.iChallenge.Copy(aInputConfig.iProtocolConfigOption.iChallenge);

	aOutputConfig.iProtocolConfigOption.iResponse.Copy(aInputConfig.iProtocolConfigOption.iResponse);

	aOutputConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(aInputConfig.iProtocolConfigOption.iPrimaryDNS);

	aOutputConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(aInputConfig.iProtocolConfigOption.iSecondaryDNS);

	aOutputConfig.iProtocolConfigOption.iId = static_cast<TUint8>(aInputConfig.iProtocolConfigOption.iId);

	aOutputConfig.iProtocolConfigOption.iMiscBuffer.Copy(aInputConfig.iProtocolConfigOption.iMiscBuffer);

	}

void CSimContextHelper::ConvertConfigParams(const TContextConfigParam& aInputConfig, RPacketContext::TContextConfigR99_R4& aOutputConfig)

	{

	aOutputConfig.iPdpType = static_cast<RPacketContext::TProtocolType>(aInputConfig.iProtocolType);

	aOutputConfig.iAccessPointName.Copy(aInputConfig.iGsnAddress);

	aOutputConfig.iPdpAddress.Copy(aInputConfig.iProtocolAddress);

	aOutputConfig.iUseEdge = aInputConfig.iUseEdge;

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iProtocol = static_cast<RPacketContext::TAuthProtocol>(aInputConfig.iProtocolConfigOption.iAuthProtocol);

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iUsername.Copy(aInputConfig.iProtocolConfigOption.iUsername);

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iPassword.Copy(aInputConfig.iProtocolConfigOption.iPassword);

	aOutputConfig.iProtocolConfigOption.iChallenge.Copy(aInputConfig.iProtocolConfigOption.iChallenge);

	aOutputConfig.iProtocolConfigOption.iResponse.Copy(aInputConfig.iProtocolConfigOption.iResponse);

	aOutputConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(aInputConfig.iProtocolConfigOption.iPrimaryDNS);

	aOutputConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(aInputConfig.iProtocolConfigOption.iSecondaryDNS);

	aOutputConfig.iProtocolConfigOption.iId = static_cast<TUint8>(aInputConfig.iProtocolConfigOption.iId);

	aOutputConfig.iProtocolConfigOption.iMiscBuffer.Copy(aInputConfig.iProtocolConfigOption.iMiscBuffer);

	}

void CSimContextHelper::ConvertConfigParams(const TContextConfigParam& aInputConfig, RPacketContext::TContextConfig_R5& aOutputConfig)

	{

	aOutputConfig.iPdpType = static_cast<RPacketContext::TProtocolType>(aInputConfig.iProtocolType);

	aOutputConfig.iAccessPointName.Copy(aInputConfig.iGsnAddress);

	aOutputConfig.iPdpAddress.Copy(aInputConfig.iProtocolAddress);

	aOutputConfig.iUseEdge = aInputConfig.iUseEdge;

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iProtocol = static_cast<RPacketContext::TAuthProtocol>(aInputConfig.iProtocolConfigOption.iAuthProtocol);

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iUsername.Copy(aInputConfig.iProtocolConfigOption.iUsername);

	aOutputConfig.iProtocolConfigOption.iAuthInfo.iPassword.Copy(aInputConfig.iProtocolConfigOption.iPassword);

	aOutputConfig.iProtocolConfigOption.iChallenge.Copy(aInputConfig.iProtocolConfigOption.iChallenge);

	aOutputConfig.iProtocolConfigOption.iResponse.Copy(aInputConfig.iProtocolConfigOption.iResponse);

	aOutputConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(aInputConfig.iProtocolConfigOption.iPrimaryDNS);

	aOutputConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(aInputConfig.iProtocolConfigOption.iSecondaryDNS);

	aOutputConfig.iProtocolConfigOption.iId = static_cast<TUint8>(aInputConfig.iProtocolConfigOption.iId);

	aOutputConfig.iPdpDataCompression = static_cast<RPacketContext::TDataCompression>(aInputConfig.iPdpDataCompression);

	aOutputConfig.iPdpHeaderCompression = static_cast<RPacketContext::THeaderCompression>(aInputConfig.iPdpHeaderCompression);

	aOutputConfig.iProtocolConfigOption.iMiscBuffer.Copy(aInputConfig.iProtocolConfigOption.iMiscBuffer);

	}

void CSimContextHelper::GetContextConfigParamSettingsL( const CTestConfigSection* const aCfgFile, const TPtrC8 aTag, 

													   CArrayFixFlat<TContextConfigParam>* aContextConfigParams )

	{

	TContextConfigParam configParam;

	TInt protocolType, pdpCompression, anonymousAccess, useEdge, protocol, id;

	TInt pdpDataCompression, pdpHeaderCompression, numAdditionalParams;

	TPtrC8 gsnAddress, protocolAddress, username, password, challenge;

	TPtrC8 response, primaryDNS, secondaryDNS;

	configParam.iProtocolConfigOption.iMiscBuffer.Zero();

	RPacketContext::TPcoId pcoId;

	TUint itemOffSet = 0; //Used for nested Addional Param items

	TInt delimiterField;

	TInt count = aCfgFile->ItemCount(aTag);

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

		{

		const CTestConfigItem* item = aCfgFile->Item(aTag,i);

		if(!item)

			break;

		//Get the Protocol Type from the config file

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("ContextConfigParams::protocolType",ret,0,&aTag);

			continue;

			}

		else

			{

			configParam.iProtocolType = protocolType;	

			}

		//Get the GGSN Address from the config file

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("ContextConfigParams::gsnAddress",ret,1,&aTag);

			continue;

			}

		else

			{

			configParam.iGsnAddress.Set(gsnAddress);

			}

		//Get the ProtocolAddress from the config file

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("ContextConfigParams::protocolAddress",ret,2,&aTag);

			continue;

			}

		else

			{

			configParam.iProtocolAddress.Set(protocolAddress);

			}

		//Get the pdpCompression from the config file 

		//If the tag is a GPRS config tag, map the GPRS configuration to the R5 format used internally in SIMTSY

		if(aTag == KSetContextConfigGPRS)

			{

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

			if(ret!=KErrNone)

				{

				LOGPARSERR("ContextConfigParams::pdpCompression",ret,3,&aTag);

				continue;

				}

			else

				{

				//Set the GPRS PDP compression Config params

				//configParam.iPdpCompression = pdpCompression;

				//Set the R5 PDP header compression config params based on GPRS params

				if((pdpCompression & RPacketContext::KPdpHeaderCompression) != 0)

					{

					configParam.iPdpHeaderCompression = RPacketContext::EManufacturerDefaultHeaderCompression;

					}

				else

					{

					configParam.iPdpHeaderCompression = RPacketContext::ENoHeaderCompression;

					}

				if((pdpCompression & RPacketContext::KPdpDataCompression) != 0)

					{

					configParam.iPdpDataCompression = RPacketContext::EManufacturerDefaultDataCompression;

					}

				else

					{

					configParam.iPdpDataCompression = RPacketContext::ENoDataCompression;

					}

				}

			}

		else if(aTag == KSetContextConfigRel5)

			{

			//Get the PDP Header Compression params

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,pdpHeaderCompression);

			if(ret!=KErrNone)

				{

				LOGPARSERR("ContextConfigParams::pdpHeaderCompression",ret,12,&aTag);

				continue;

				}

			else

				{

				configParam.iPdpHeaderCompression = pdpHeaderCompression;

				}

			//Get the PDP Data compression params

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,pdpDataCompression);

			if(ret!=KErrNone)

				{

				LOGPARSERR("ContextConfigParams::pdpDataCompression",ret,13,&aTag);

				continue;

				}

			else

				{

				configParam.iPdpDataCompression = pdpDataCompression;

				}			

			}

		else

			{

			configParam.iPdpHeaderCompression = RPacketContext::ENoHeaderCompression;

			configParam.iPdpDataCompression = RPacketContext::ENoDataCompression;	

			}

		//Get the Anonymous Access param if this is a GPRS PDP context config param tag

		if(aTag == KSetContextConfigGPRS)

			{

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

			if(ret!=KErrNone)

				{

				LOGPARSERR("ContextConfigParams::anonymousAccess",ret,4,&aTag);

				continue;

				}

			else

				{

				configParam.iAnonymousAccess = anonymousAccess;

				}

			}

		else

			{

			configParam.iAnonymousAccess = 0; /*RPacketContext::TAnonymousAccess::ENotApplicable;*/

			}

		//Get the UseEdge config param from the config file

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 5;

			}

		else

			{

			delimiterField = 3;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,useEdge);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ContextConfigParams::useEdge",ret,delimiterField,&aTag);

			continue;

			}

		else

			{

			configParam.iUseEdge = useEdge;	

			}

		//Get the Autorisation Protocol config param from the config file

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 6;

			}

		else

			{

			delimiterField = 4;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,protocol);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ProtocolConfigOption::protocol",ret,delimiterField,&aTag);

			}

		else

			{

			configParam.iProtocolConfigOption.iAuthProtocol = protocol;	

			}

		//Get the Username config param from the config file

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 7;

			}

		else

			{

			delimiterField = 5;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,username);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ProtocolConfigOption::username",ret,delimiterField,&aTag);

			}

		else

			{

			configParam.iProtocolConfigOption.iUsername.Set(username);	

			}

		//Get the password config param from the config file

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 8;

			}

		else

			{

			delimiterField = 6;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,password);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ProtocolConfigOption::password",ret,delimiterField,&aTag);

			}

		else

			{

			configParam.iProtocolConfigOption.iPassword.Set(password);	

			}

		//Get the Challenge config param from the config file

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 9;

			}

		else

			{

			delimiterField = 7;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,challenge);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ProtocolConfigOption::challenge",ret,delimiterField,&aTag);

			}

		else

			{

			configParam.iProtocolConfigOption.iChallenge.Set(challenge);	

			}

		//Get the Response config param from the config file

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 10;

			}

		else

			{

			delimiterField = 8;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,response);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ProtocolConfigOption::response",ret,delimiterField,&aTag);

			}

		else

			{

			configParam.iProtocolConfigOption.iResponse.Set(response);	

			}

		//Get the Primary DNS config param from the config file

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 11;

			}

		else

			{

			delimiterField = 9;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,primaryDNS);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ProtocolConfigOption::primaryDNS",ret,delimiterField,&aTag);

			}

		else

			{

			configParam.iProtocolConfigOption.iPrimaryDNS.Set(primaryDNS);	

			}

		//Get the Secondary DNS config param from the config file

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 12;

			}

		else

			{

			delimiterField = 10;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,secondaryDNS);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ProtocolConfigOption::secondaryDNS",ret,delimiterField,&aTag);

			}

		else

			{

			configParam.iProtocolConfigOption.iSecondaryDNS.Set(secondaryDNS);	

			}

		//Get the ID config param from the config file.

		if(aTag == KSetContextConfigGPRS)

			{

			delimiterField = 13;

			}

		else

			{

			delimiterField = 11;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,id);

		if(ret!=KErrNone)

			{

			LOGPARSERR("ProtocolConfigOption::id",ret,delimiterField,&aTag);

			}