--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/simtsy/src/CSimContextHelper.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,704 @@
+// 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);
+ }
+ else
+ {
+ configParam.iProtocolConfigOption.iId = id;
+ }
+
+
+ //Get the Additional Params List
+
+ //Create buffer to hold the TLV structure
+ RPacketContext::TMiscProtocolBuffer miscBuffer;
+ miscBuffer.Zero();
+
+
+ //Get the number of items in the Additional Params List
+ if (aTag == KSetContextConfigRel99)
+ {
+ delimiterField = 12;
+ }
+ else
+ {
+ delimiterField = 14;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,delimiterField,numAdditionalParams);
+
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("ProtocolConfigOption::numAdditionalParams",ret,delimiterField,&aTag);
+ }
+ else
+ {
+ TInt nestedItemNumber;
+ TUint16 digit, format;
+ const CTestConfigItem* item2;
+
+ TPtr8 pcoPtr(const_cast<TUint8*>(miscBuffer.Ptr()),
+ RPacketContext::KMiscProtocolBufferLength);
+
+ // Attach TTlv to the buffer
+ TTlvStruct<RPacketContext::TPcoId,RPacketContext::TPcoItemDataLength> theTLV(pcoPtr,0);
+
+ for(nestedItemNumber=itemOffSet; nestedItemNumber<itemOffSet+numAdditionalParams; nestedItemNumber++)
+ {
+
+ // Get the relevant Additional Param Item
+
+ // Find the correct tag
+ if (aTag == KSetContextConfigRel5)
+ {
+ item2 = aCfgFile->Item(KAdditionalParamItem, nestedItemNumber);
+ }
+ else if (aTag == KSetContextConfigGPRS)
+ {
+ item2 = aCfgFile->Item(KAdditionalParamItemGPRS, nestedItemNumber);
+ }
+ else
+ {
+ // Otherwise it is KSetContextConfigRel99
+ item2 = aCfgFile->Item(KAdditionalParamItemRel99, nestedItemNumber);
+ }
+
+ if(!item2)
+ {
+ break;
+ }
+
+ TPtrC8 additionalParamId, additionalParamData, additionalParamDataFormat;
+
+ // Get TPcoProtocolId
+ ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,0,additionalParamId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("AdditionalParamItem::additionalParamId",ret,0,&aTag);
+ continue;
+ }
+ else
+ {
+ if(AsciiToNum(additionalParamId, digit) == KErrNone)
+ {
+ pcoId.SetId(digit);
+ }
+ else
+ {
+ LOGPARSERR("AdditionalParamItem::additionalParamId",KErrArgument,0,&aTag);
+ continue;
+ }
+ }
+
+ // Read AdditionalParamDataFormat field to find out how
+ // to interpret data in the AdditionalParamData field
+ ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,2,additionalParamDataFormat);
+ if (ret != KErrNone)
+ {
+ // AdditionalParamDataFormat not been specified,
+ // default to plain ASCII
+ LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",ret,2,&aTag);
+ format = EConfigDataFormatAscii;
+ }
+ else
+ {
+ if (AsciiToNum(additionalParamDataFormat, format) != KErrNone)
+ {
+ LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",KErrArgument,2,&aTag);
+ format = EConfigDataFormatAscii;
+ }
+
+ // Check that the AdditionalParamDataFormat value
+ // specified in the config file is a valid one,
+ // default to ASCII if not.
+ if (format >= EMaxConfigDataFormat)
+ {
+ LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",KErrArgument,2,&aTag);
+ format = EConfigDataFormatAscii;
+ }
+ }
+
+ // Read AdditionalParamData
+ ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,1,additionalParamData);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("AdditionalParamItem::additionalParamContent",ret,1,&aTag);
+ continue;
+ }
+ else
+ {
+ // Add AdditionalParamData to PCO buffer depending on format
+ switch (format)
+ {
+ case EConfigDataFormatMixedBinaryAndAscii:
+ {
+ // Parse the string here
+ // Will store the parsed data when algorithm has completed
+ TBuf8<RPacketContext::KMiscProtocolBufferLength> additionalParamDataBuffer;
+ additionalParamDataBuffer.Copy (additionalParamData);
+
+ if (ParseMixedBinaryAsciiDataL(additionalParamDataBuffer) != KErrNone)
+ {
+ LOGPARSERR("AdditionalParamItem::additionalParamContent",KErrArgument,1,&aTag);
+ SimPanic(EInvalidParameterFormatInConfigFile);
+ }
+ TPtr8 additionalParamDataPtr(const_cast<TUint8*>(additionalParamDataBuffer.Ptr()),
+ additionalParamDataBuffer.Length(), additionalParamDataBuffer.Length());
+ theTLV.AppendItemL(pcoId,additionalParamDataPtr);
+ miscBuffer.SetLength(pcoPtr.Length());
+ } // case EAdditionalParamDataFormatMixedBinaryAndAscii
+ break;
+ case EConfigDataFormatAscii:
+ default:
+ // No string handling required for plain ASCII.
+ TPtr8 additionalParamDataPtr(const_cast<TUint8*>(additionalParamData.Ptr()),
+ additionalParamData.Length(), additionalParamData.Length());
+ theTLV.AppendItemL(pcoId,additionalParamDataPtr);
+ miscBuffer.SetLength(pcoPtr.Length());
+ break;
+ } // switch (format)
+ } // End else
+ } // End for loop
+
+ configParam.iProtocolConfigOption.iMiscBuffer = miscBuffer;
+ itemOffSet= itemOffSet + numAdditionalParams;
+ }
+
+
+ //Get if the context is valid from the config file.
+ if(aTag == KSetContextConfigRel99)
+ {
+ delimiterField = 13;
+ }
+ else
+ {
+ delimiterField = 15;
+ }
+
+ aContextConfigParams->AppendL(configParam);
+ }
+ }