--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/networkcontrol/ipscpr/src/ipscpr.cpp Thu Jul 22 16:48:06 2010 +0100
@@ -0,0 +1,2006 @@
+// 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 "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:
+// Implementation file for the IP SubConnection Provider and its basic version.
+//
+//
+
+/**
+ @file ipscpr.cpp
+*/
+
+#include <e32std.h>
+#include <e32test.h>
+#include <ecom/ecom.h>
+#include <implementationproxy.h>
+#include <es_prot.h>
+#include <cs_subconevents.h>
+#include <cs_subconparams.h>
+#include "ipscpr.h"
+#include "ipscprlog.h"
+#include "sblpextn.h"
+#include <ip_subconparams.h>
+
+#ifndef BASIC_IPSCPR
+#include "pfqos_stream.h"
+#include "ipscprlog.h"
+#include <ip_subconparams.h>
+#include "qos_msg.h"
+#include "pfqoslib.h"
+#include <networking/qoserr.h>
+
+#ifdef SYMBIAN_NETWORKING_UMTSR5
+#include <networking/imsextn.h>
+#include <networking/sblpextn.h>
+#include <networking/umtsextn.h>
+#else
+#include <networking/umtsapi.h>
+#include <networking/sblpapi.h>
+#endif
+// SYMBIAN_NETWORKING_UMTSR5
+
+#endif
+
+#ifndef SYMBIAN_NETWORKING_3GPPDEFAULTQOS
+// need to ensure the original TUid of the factory class is used for implementions in this component
+#undef KSubConIPParamsUid
+#endif
+
+
+/**
+Data required for instantiating ECOM Plugin
+*/
+const TImplementationProxy ImplementationTable[] =
+ {
+ IMPLEMENTATION_PROXY_ENTRY(KSubConnectionProviderImplementationUid, CIpSubConnectionProviderFactory::NewL),
+ IMPLEMENTATION_PROXY_ENTRY(KSubConIPParamsUid, CSubConIPExtensionParamsFactory::NewL)
+ };
+
+
+/**
+ECOM Implementation Factory
+*/
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+ {
+ aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+ return ImplementationTable;
+ }
+
+
+/**
+Plugin Implementation
+*/
+
+
+CIpSubConnectionProviderFactory* CIpSubConnectionProviderFactory::NewL(TAny* aConstructionParameters)
+/**
+Constructs a IP Connection Provider Factory
+
+@param aConstructionParameters construction data passed by ECOM
+
+@return pointer to a constructed factory
+*/
+ {
+ CIpSubConnectionProviderFactory* ptr = new (ELeave) CIpSubConnectionProviderFactory(KIPConnectionProviderFactoryId, *(reinterpret_cast<CSubConnectionFactoryContainer*>(aConstructionParameters)));
+ return ptr;
+ }
+
+
+CIpSubConnectionProviderFactory::CIpSubConnectionProviderFactory(TUint aFactoryId, CSubConnectionFactoryContainer& aParentContainer)
+ : CSubConnectionProviderFactoryBase(aFactoryId, aParentContainer)
+/**
+IP SubConnection Provider Factory Constructor
+
+@param aFactoryId ECOM Implementation Id
+@param aParentContainer Object Owner
+*/
+ {
+ }
+
+
+CIpSubConnectionProviderFactory::~CIpSubConnectionProviderFactory()
+/**
+IP SubConnection Provider Factory Destructor
+*/
+ {
+ }
+
+
+CSubConnectionProviderBase* CIpSubConnectionProviderFactory::DoCreateProviderL(CConnectionProviderBase& aConnProvider, RSubConnection::TSubConnType aType)
+/**
+Factory Function that either creates a new SubConnection Provider or attaches
+to the default Provider. The type of creation can be either RSubConnection::ECreateNew
+or RSubConnection::EAttachToDefault.
+
+Use of other types will cause the factory to leave with KErrNotSupported.
+
+@param aConnProvider Associated Connection Provider
+@param aType Type of SubConnection Provider Creation.
+*/
+ {
+ CSubConnectionProviderBase* p = NULL;
+ switch (aType)
+ {
+#ifdef SYMBIAN_NETWORKING_3GPPDEFAULTQOS
+ case RSubConnection::EAttachToDefault:
+ p = new(ELeave)CDefaultSubConnectionProvider(*this, aConnProvider, aType);
+ break;
+#ifdef BASIC_IPSCPR
+ case RSubConnection::ECreateNew:
+ // The Basic IPSCPR, itself, by definition, doesn't support secondary contexts.
+ // Ideally it should defer to the transport layer provider as for primary contexts...
+ //
+ User::Leave(KErrNotSupported);
+ break;
+#else
+ case RSubConnection::ECreateNew:
+ p = CIpSubConnectionProvider::NewL(*this, aConnProvider);
+ break;
+#endif // BASIC_IPSCPR
+#else
+ case RSubConnection::ECreateNew:
+ p = CIpSubConnectionProvider::NewL(*this, aConnProvider);
+ break;
+ case RSubConnection::EAttachToDefault:
+ p = new(ELeave)CDefaultSubConnectionProvider(*this, aConnProvider);
+ break;
+#endif // SYMBIAN_NETWORKING_3GPPDEFAULTQOS
+ default:
+ {
+ User::Leave(KErrNotSupported);
+ }
+ };
+ return p;
+ }
+
+
+#ifndef BASIC_IPSCPR
+
+/**
+Provider Implementation
+*/
+
+
+CIpSubConnectionProvider* CIpSubConnectionProvider::NewL(CIpSubConnectionProviderFactory& aFactory, CConnectionProviderBase& aConnProvider)
+/**
+Construct a new IP SubConnection Provider Object
+
+@param aFactory factory that create this object
+@param aConnProvider Connection Provider associated with this object
+*/
+ {
+ CIpSubConnectionProvider* ptr = new (ELeave) CIpSubConnectionProvider(aFactory, aConnProvider);
+
+ CleanupStack::PushL(ptr);
+ ptr->ConstructL();
+ CleanupStack::Pop();
+
+ return ptr;
+ }
+
+
+CIpSubConnectionProvider::CIpSubConnectionProvider(CIpSubConnectionProviderFactory& aFactory, CConnectionProviderBase& aConnProvider)
+ : CEmptySubConnectionProvider(aFactory, aConnProvider)
+ , iChannelId(-1)
+ , iPrtExtensions(_FOFF(CExtensionBase,iLink))
+ , iParametersSet(EFalse)
+/**
+IP SubConnection Provider Constructor
+
+@param aFactory factory that create this object
+@param aConnProvider Connection Provider associated with this object
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider [this=%08x]:\tCIpSubConnectionProvider() [MConnectionDataClient=%08x]"),
+ this, (MConnectionDataClient*)this));
+ }
+
+
+CIpSubConnectionProvider::~CIpSubConnectionProvider()
+/**
+IP SubConnection Provider Destructor
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::Destruct [%08x]"), this));
+
+ if( iChannelId >= 0 ) // Only send a Close if have opened a channel
+ {
+ TRAPD(ret,SendCloseL());
+ if( ret != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("SendCloseL left with error: %d"), ret));
+ }
+ }
+
+ if( iWriter )
+ {
+ iWriter->Cancel();
+ delete iWriter;
+ iWriter = NULL;
+ }
+
+ if( iReader )
+ {
+ iReader->Cancel();
+ delete iReader;
+ iReader = NULL;
+ }
+
+ delete iPrtParameters;
+ delete iAsyncWriter;
+ ResetPrtExtensions();
+
+ iSocket.Close();
+ }
+
+
+void CIpSubConnectionProvider::ConstructL()
+/**
+IP SubConnection Provider Second Phase Constructor
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::Construct [%08x]"), this));
+
+ // Open a connection to the QoS PRT
+ _LIT(KDescPfqos, "pfqos");
+
+#ifdef SYMBIAN_NETWORKING_3GPPDEFAULTQOS
+ // If we couldn't open pipe to QoS framework then it is not supported
+ TInt ret = iSocket.Open(KDescPfqos);
+ if(ret == KErrNotFound)
+ {
+ User::Leave(KErrNotSupported);
+ }
+ else if (ret != KErrNone)
+ {
+ User::Leave(ret);
+ }
+#else
+ User::LeaveIfError(iSocket.Open(KDescPfqos));
+#endif
+ iUid = RProcess().Type();
+
+ iReader = CQoSMsgReader::NewL(this, iSocket);
+ iWriter = CQoSMsgWriter::NewL(this, iSocket);
+ iAsyncWriter = CAsyncWriter::NewL(iWriter);
+
+ /** Create the CQoSParameters to hold the Qos
+ * and Extension Parameters. The values will initially
+ be set to default
+ */
+ iPrtParameters = new (ELeave) CQoSParameters;
+ // Set Default Uplink Parameters
+ iPrtParameters->SetUpLinkMaximumBurstSize(3000); // for TokenBucketSizeUplink
+ iPrtParameters->SetUpLinkMaximumPacketSize(1500); // for MaxPacketSizeUplink
+ iPrtParameters->SetUplinkBandwidth(1500); // for TokenRateUplink
+ iPrtParameters->SetUpLinkAveragePacketSize(1500); // for MinimumPolicedUnitUplink
+ iPrtParameters->SetUpLinkPriority(KQoSLowestPriority); // for PriorityUplink
+ iPrtParameters->SetUpLinkDelay(0); // for DelayUplink
+ // Set Default Downlink parameters
+ iPrtParameters->SetDownLinkMaximumBurstSize(3000); // for TokenBucketSizeDownlink
+ iPrtParameters->SetDownLinkMaximumPacketSize(1500); // for MaxPacketSizeDownlink
+ iPrtParameters->SetDownlinkBandwidth(1500); // for TokenRateDownlink
+ iPrtParameters->SetDownLinkAveragePacketSize(1500); // for MinimumPolicedUnitDownlink
+ iPrtParameters->SetDownLinkPriority(KQoSLowestPriority); // for PriorityDownlonk
+ iPrtParameters->SetDownLinkDelay(0); // for DelayDownlink
+
+ iPrtParameters->SetAdaptMode(EFalse);
+// iPrtParameters->SetHeaderMode(???);
+// User::LeaveIfError(iPrtParameters->SetName(name));
+ }
+
+
+TAny* CIpSubConnectionProvider::FetchInterfaceInstanceL(CSubConnectionProviderBase& /*aProvider*/, const STypeId& aTid)
+ {
+ return (aTid == STypeId::CreateSTypeId(KConnectionClientExtUid,EConnectionEnumerateClients)) ? static_cast<MConnectionEnumerateClients*>(this) : NULL;
+ }
+
+void CIpSubConnectionProvider::DoDataClientJoiningL(MSubConnectionDataClient& aDataClient)
+/**
+Function called by Connection Provider when a socket is to be added to a QoS Flow
+
+@param aDataClient Data Client to add to the QoS Channel
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider [this=%08x]:\tDoDataClientJoiningL() [iDataClients.Count=%d] [aDataClient=%08x]"), this, iDataClients.Count(), &aDataClient));
+
+ // Can only join to a channel once it has been successfully routed
+ // Can only open/create/join the channel once the connection has been established
+ const TSockAddr* srcAddr = NULL;
+ const TSockAddr* dstAddr = NULL;
+ const TDesC8* connInfo;
+ if(aDataClient.ReadAddressInformation(srcAddr, dstAddr, connInfo) == KErrNone)
+ {
+ if( srcAddr == NULL || srcAddr->Family() == KAFUnspec )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Source Address not defined")));
+ User::Leave( KErrNotReady );
+ }
+
+ if( dstAddr == NULL || dstAddr->Family() == KAFUnspec )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Destination Address not defined")));
+ User::Leave( KErrNotReady );
+ }
+
+ if( connInfo == NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Connection Information not defined")));
+ User::Leave( KErrNotReady );
+ }
+
+ TConnectionInfoBuf* connInfoBuf = (TConnectionInfoBuf*)connInfo->Ptr();
+ TUint32 iapId = (*connInfoBuf)().iIapId;
+
+ if( iChannelId >= 0 )
+ {
+ SendJoinL((TInetAddr)*srcAddr, (TInetAddr)*dstAddr, iapId, aDataClient.ProtocolId());
+ }
+ else
+ {
+ SendCreateL((TInetAddr)*srcAddr, (TInetAddr)*dstAddr, iapId, aDataClient.ProtocolId());
+ }
+ }
+ }
+
+
+void CIpSubConnectionProvider::DoDataClientLeaving(MSubConnectionDataClient& aDataClient)
+/**
+Function called by Connection Provider when a socket is to be removed from a QoS Flow
+
+@param aDataClient Data Client to remove from the QoS Channel
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider [this=%08x]:\tDoDataClientLeaving() [iDataClients.Count=%d] [aDataClient=%08x]"), this, iDataClients.Count(), &aDataClient));
+
+ // Can only leave on a routed conection that has been successfully
+ // attached to a QoS Channel. Otherwise we cannot leave
+ const TSockAddr* srcAddr = NULL;
+ const TSockAddr* dstAddr = NULL;
+ const TDesC8* connInfo;
+ TInt err = aDataClient.ReadAddressInformation(srcAddr, dstAddr, connInfo);
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Unable to read Address Information")));
+ return;
+ }
+
+ if( srcAddr == NULL || srcAddr->Family() == KAFUnspec )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Source Address not defined")));
+ return;
+ }
+
+ if( dstAddr == NULL || dstAddr->Family() == KAFUnspec )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Destination Address not defined")));
+ return;
+ }
+
+ if( connInfo == NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Connection Information not defined")));
+ return;
+ }
+
+ TConnectionInfoBuf* connInfoBuf = (TConnectionInfoBuf*)connInfo->Ptr();
+ TUint32 iapId = (*connInfoBuf)().iIapId;
+
+ if( iChannelId >= 0 )
+ {
+ TRAPD(ret, SendLeaveL((TInetAddr)*srcAddr, (TInetAddr)*dstAddr, iapId, aDataClient.ProtocolId()));
+ if (ret != KErrNone)
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("SendLeaveL left with err=%d"), ret));
+ }
+ }
+ else
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Attempted to leave on an unconnected channel")));
+ }
+ }
+
+
+void CIpSubConnectionProvider::DoSourceAddressUpdate(MSubConnectionDataClient& /*aDataClient*/, const TSockAddr& /*aSource*/)
+/**
+Function called by Connection Provider when the source address on a data client is set
+
+@param aDataClient Data Client affected
+@param aSource Source Address
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoSourceAddressUpdate [%08x]"), this));
+ // Not Interested in either souce or destination updates; wait until connected
+ }
+
+
+void CIpSubConnectionProvider::DoDestinationAddressUpdate(MSubConnectionDataClient& /*aDataClient*/, const TSockAddr& /*aDestination*/)
+/**
+Function called by Connection Provider when the destination address on a data client is set
+
+@param aDataClient Data Client affected
+@param aDestination Destination Address
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoDestinationAddressUpdate [%08x]"), this));
+ // Not Interested in either souce or destination updates; wait until connected
+ }
+
+
+void CIpSubConnectionProvider::DoDataClientRouted(MSubConnectionDataClient& aDataClient, const TSockAddr& aSource, const TSockAddr& aDestination, const TDesC8& aConnectionInfo)
+/**
+Function called by Connection Provider when the connection has been established
+
+@param aDataClient Data Client affected
+@param aSource Source Address
+@param aDestination Destination Address
+@param aConnectionInfo Connection Data
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoDestinationAddressUpdate [%08x]"), this));
+
+ TConnectionInfoBuf* connInfo = (TConnectionInfoBuf*)aConnectionInfo.Ptr();
+ TUint32 iapId = (*connInfo)().iIapId;
+
+ if( aSource.Family() != KAFUnspec && aDestination.Family() != KAFUnspec)
+ {
+ // If already have a open channel add this socket. o/w create a new channel
+ if( iChannelId >= 0 )
+ {
+ TRAPD(ret,SendJoinL((TInetAddr)aSource, (TInetAddr)aDestination, iapId, aDataClient.ProtocolId()));
+ if( ret != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("SendJoinL left with error: %d"), ret));
+ }
+ }
+ else
+ {
+ TRAPD(ret,SendCreateL((TInetAddr)aSource, (TInetAddr)aDestination, iapId, aDataClient.ProtocolId()));
+ if( ret != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("SendCreateL left with error: %d"), ret));
+ }
+ }
+ }
+ else
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Data Client Routed contains invalid source or dest address")));
+ }
+ }
+
+
+void CIpSubConnectionProvider::DoParametersAboutToBeSetL(CSubConParameterBundle& aParameterBundle)
+/**
+Function called by the Connection Provider before the QoS Parameters are set by the client
+
+@param aParameterBundle Container holding pending QoS Parameters
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoParametersAboutToBeSetL [%08x]"), this));
+
+ iParameterRelease = KParameterRelInvalid;
+ ConvertParametersFromESockL( aParameterBundle );
+ iParametersSet = ETrue;
+
+ if(iChannelId >= 0)
+ {
+ SendSetQoSL();
+ }
+ }
+
+
+TInt CIpSubConnectionProvider::DoControl(TUint /*aOptionLevel*/, TUint /*aOptionName*/, TDes8& /*aOption*/)
+/**
+@param aOptionLevel
+@param aOptionName
+@param aOption
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoControl [%08x]"), this));
+
+ return KErrNotSupported;
+ }
+
+
+void CIpSubConnectionProvider::DoStartL()
+ {
+ }
+
+void CIpSubConnectionProvider::DoStop()
+ {
+ }
+
+CSubConnectionProviderBase* CIpSubConnectionProvider::DoNextLayer()
+ {
+ return NULL;
+ }
+
+CConnDataTransfer& CIpSubConnectionProvider::DoDataTransferL()
+ {
+ User::Leave(KErrNotSupported);
+ //unreachable code
+ return iNextLayer->DataTransferL();
+// return *((CConnDataTransfer*)this);
+ }
+
+//MConnectionDataClient
+void CIpSubConnectionProvider::ConnectionGoingDown(CConnectionProviderBase& /*aConnProvider*/)
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ConnectionGoingDown [%08x]"), this));
+ iConnectionProvider = NULL;
+ DeleteMeNow();
+ }
+
+void CIpSubConnectionProvider::Notify(TNotify /*aNotifyType*/, CConnectionProviderBase* /*aConnProvider*/, TInt /*aError*/, const CConNotificationEvent* /*aConNotificationEvent*/)
+ {
+ }
+
+void CIpSubConnectionProvider::AttachToNext(CSubConnectionProviderBase* /*aSubConnProvider*/)
+ {
+ }
+
+
+
+void CIpSubConnectionProvider::SendOpenExistingL(const TInetAddr &aSrcAddr, const TInetAddr &aDstAddr, TUint32 aIapId, TUint32 aProtocolId)
+/**
+Sends a Message to QoS PRT to open a QoS Channel
+
+@param aSrcAddr Source Address
+@param aDstAddr Destination Address
+@param aIapId IAP Id
+@param aProtocolId Protocol Id
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosOpenExistingChannel")));
+
+ CQoSMsg* msg = CQoSMsg::NewL(EPfqosOpenExistingChannel);
+ msg->AddConnInfo(aProtocolId, iUid, aIapId);
+ msg->AddSrcAddr(aSrcAddr);
+ msg->AddDstAddr(aDstAddr);
+ msg->AddChannel(0);
+
+ iWriter->Send(msg);
+ }
+
+
+void CIpSubConnectionProvider::SendCreateL(const TInetAddr &aSrcAddr, const TInetAddr &aDstAddr, TUint32 aIapId, TUint32 aProtocolId)
+/**
+Sends a Message to QoS PRT to create a QoS Channel
+
+@param aSrcAddr Source Address
+@param aDstAddr Destination Address
+@param aIapId IAP Id
+@param aProtocolId Protocol Id
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosCreateChannel")));
+
+ CQoSMsg* msg = CQoSMsg::NewL(EPfqosCreateChannel);
+ msg->AddConnInfo(aProtocolId, iUid, aIapId);
+ msg->AddSrcAddr(aSrcAddr);
+ msg->AddDstAddr(aDstAddr);
+ msg->AddChannel(0);
+
+ TQoSParameters qosParams;
+ ConvertCQoSIntoTQoSParamsL(qosParams);
+ msg->AddQoSParameters(qosParams);
+ msg->AddExtensionPolicy(iPrtExtensions);
+ //Now we need to write to the qos.prt asynchronously. This becuase the TCP/IP stack in CIp6Flow::Connect() calls Bearer() before RefreshFlow()
+ iAsyncWriter->Send(msg);
+ }
+
+
+void CIpSubConnectionProvider::SendCloseL()
+/**
+Sends a Message to QoS PRT to close a QoS Channel
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosDeleteChannel")));
+
+ CQoSMsg* msg = CQoSMsg::NewL(EPfqosDeleteChannel);
+ msg->AddChannel(iChannelId);
+
+ iWriter->Send(msg);
+ }
+
+
+void CIpSubConnectionProvider::SendJoinL(const TInetAddr &aSrcAddr, const TInetAddr &aDstAddr, TUint32 aIapId, TUint32 aProtocolId)
+/**
+Sends a Message to QoS PRT to add a socket to a QoS Channel
+
+@param aSrcAddr Source Address
+@param aDstAddr Destination Address
+@param aIapId IAP Id
+@param aProtocolId Protocol Id
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosJoin")));
+
+ CQoSMsg* msg = CQoSMsg::NewL(EPfqosJoin);
+ msg->AddConnInfo(aProtocolId, iUid, aIapId);
+ msg->AddSrcAddr(aSrcAddr);
+ msg->AddDstAddr(aDstAddr);
+ msg->AddChannel(iChannelId);
+
+ iWriter->Send(msg);
+ }
+
+
+void CIpSubConnectionProvider::SendLeaveL(const TInetAddr &aSrcAddr, const TInetAddr &aDstAddr, TUint32 aIapId, TUint32 aProtocolId)
+/**
+Sends a Message to QoS PRT to remove a socket from a QoS Channel
+
+@param aSrcAddr Source Address
+@param aDstAddr Destination Address
+@param aIapId IAP Id
+@param aProtocolId Protocol Id
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosLeave")));
+
+ CQoSMsg* msg = CQoSMsg::NewL(EPfqosLeave);
+ msg->AddConnInfo(aProtocolId, iUid, aIapId);
+ msg->AddSrcAddr(aSrcAddr);
+ msg->AddDstAddr(aDstAddr);
+ msg->AddChannel(iChannelId);
+
+ iWriter->Send(msg);
+ }
+
+
+
+void CIpSubConnectionProvider::SendSetQoSL()
+/**
+Sends Message to QoS PRT to update the parameters for a QoS Channel
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosConfigChannel")));
+
+ CQoSMsg* msg = CQoSMsg::NewL(EPfqosConfigChannel);
+ msg->AddChannel(iChannelId);
+
+ TQoSParameters qosParams;
+ ConvertCQoSIntoTQoSParamsL(qosParams);
+ msg->AddQoSParameters(qosParams);
+ msg->AddExtensionPolicy(iPrtExtensions);
+
+ iWriter->Send(msg);
+ }
+
+
+void CIpSubConnectionProvider::ProcessPRTMsg(TPfqosMessage& aMsg)
+/**
+Process Messages sent from the PRT to the SubConnection Provider
+Messages are either replies or events
+
+@param aMsg the message from the PRT
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ProcessPRTMsg [%08x]"), this));
+
+ if( aMsg.iBase.iMsg == NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received malformed message from PRT")));
+ }
+ else
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Msg: %d"), aMsg.iBase.iMsg->pfqos_msg_type));
+ switch(aMsg.iBase.iMsg->pfqos_msg_type)
+ {
+ case EPfqosEvent:
+ {
+ TRAPD(ret, ProcessPRTEventL(aMsg) );
+ if( ret != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("ProcessPRTEventL left with error: %d"), ret));
+ }
+ }
+ break;
+
+ case EPfqosUpdate:
+ case EPfqosDelete:
+ case EPfqosAdd:
+ case EPfqosGet:
+ case EPfqosReject:
+ case EPfqosDump:
+ case EPfqosConfigure:
+ case EPfqosJoin:
+ case EPfqosLeave:
+ case EPfqosCreateChannel:
+ case EPfqosOpenExistingChannel:
+ case EPfqosDeleteChannel:
+ case EPfqosConfigChannel:
+ case EPfqosLoadFile:
+ case EPfqosUnloadFile:
+ {
+ TRAPD(ret, ProcessPRTReplyL(aMsg) );
+ if( ret != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("ProcessPRTReplyL left with error: %d"), ret));
+ }
+ }
+ break;
+
+ default:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received Unknown PRT Msg: %d"), aMsg.iBase.iMsg->pfqos_msg_type));
+ break;
+ }
+ }
+ }
+
+
+void CIpSubConnectionProvider::ProcessPRTEventL(TPfqosMessage& aMsg)
+/**
+Process Events sent from the PRT to the SubConnection Provider
+
+@param aMsg the message from the PRT
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ProcessPRTEventL [%08x]"), this));
+
+ // Only interested in Channel Events
+ if (aMsg.iEvent.iExt == NULL || aMsg.iFlowSpec.iExt == NULL || aMsg.iChannel.iExt == NULL)
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received malformed event message from PRT")));
+ return;
+ }
+
+ MSubConnectionDataClient* client = NULL;
+ TInt ret = DetermineClient(aMsg, client);
+ if( ret != KErrNone || client == NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Could not determine DataClient from message. Error=%d"), ret));
+ }
+
+ switch (aMsg.iEvent.iExt->event_type)
+ {
+ case KPfqosEventFailure:
+ {
+/*
+ EQoSOk,
+ EQoSPolicyExists = -5119, //< -5119 Policy exists in database
+ EQoSNoModules, //< -5118 No QoS modules available
+ EQoSInterface, //< -5117 Flows are using different interfaces
+ EQoSModules, //< -5116 Flows use different QoS modules
+ EQoSModuleLoadFailed, //< -5115 Loading of QoS module failed
+ EQoSMessageCorrupt, //< -5114 Pfqos message corrupted
+ EQoSJoinFailure, //< -5113 Join to QoS channel failed
+ EQoSLeaveFailure, //< -5112 Leave from QoS channel failed
+ EQoSNoInterface, //< -5111 Network interface deleted
+ EQoSChannelDeleted, //< -5110 QoS channel deleted
+ EQoSDowngradeForced //< -5109 QoS parameters downgraded by administrative policy
+*/
+ CSubConNotificationEvent* event = NULL;
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventFailure. Error=%d"),aMsg.iBase.iMsg->pfqos_msg_errno));
+
+#if defined(QOS_ERROR_REPORTING) //Awaiting code delivery for qos and guqos to support this functionality
+ switch(aMsg.iBase.iMsg->pfqos_msg_errno)
+ {
+ case EQoSJoinFailure:
+
+ if( client )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Join failed Event")));
+ client->JoinFailed(*this,aMsg.iBase.iMsg->pfqos_msg_errno);
+ }
+ break;
+
+ case EQoSLeaveFailure:
+ if( client )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Leave failed Event")));
+ //We don't particularly care that it failed - just pretend that it was successful
+ client->LeaveComplete(*this);
+ }
+ break;
+ case EQoSNoInterface:
+ case EQoSChannelDeleted:
+ {
+ CSubConGenEventSubConDown* scde = CSubConGenEventSubConDown::NewL();
+ scde->SetError(aMsg.iBase.iMsg->pfqos_msg_errno);
+ event = scde;
+ iChannelId = -1;
+ break;
+ }
+ case EQoSDowngradeForced:
+ {
+ event = CSubConGenEventParamsChanged::NewL();
+ break;
+ }
+
+ case EQoSChannelFailed:
+ if( client )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Join failed Event")));
+ client->JoinFailed(*this,aMsg.iBase.iMsg->pfqos_msg_errno);
+ }
+ // no break here we want to continue into the next case statement;
+ case EQoSParamsRejected:
+ {
+ CSubConGenEventParamsRejected* scde = CSubConGenEventParamsRejected::NewL();
+ scde->SetError(aMsg.iBase.iMsg->pfqos_msg_errno);
+ scde->SetFamilyId(KSubConQoSFamily);
+ event = scde;
+ break;
+ }
+
+ default:
+ __IPCPRLOG(IpCprLog::Printf(_L("Unknown event sent ")));
+ };
+#else
+ if( client )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Join failed Event")));
+ client->JoinFailed(*this,aMsg.iBase.iMsg->pfqos_msg_errno);
+ CSubConGenEventParamsRejected* scde = CSubConGenEventParamsRejected::NewL();
+ /**
+ There can be two set of parameters that are sent to QOS either as KSubConQoSFamily
+ or as KSubConAuthorisationFamily. Here we should differentiate, the QOS is rejected
+ because of which parameter family.
+ At present there is no indication comes from the lower layer why the QOS has failed, and in
+ all the case the member *aMsg.iBase.iMsg->pfqos_msg_type* will return *EPfQoSReject*.
+
+ At the time of writing this code any differentiation method was not available to differentiate
+ between events. i.e whether the event is SBLP or UMTS events. So this has not been done.
+ This needs to be done when the TPfqosMessage will have the differentiation
+ */
+ scde->SetError(aMsg.iBase.iMsg->pfqos_msg_errno);
+ scde->SetFamilyId(KSubConQoSFamily);
+ event = scde;
+ }
+#endif
+
+ // Setting QoS Parameters Failed
+ /**
+ There can be two set of parameters that are sent to QOS either as KSubConQoSFamily
+ or as KSubConAuthorisationFamily. Here we should differentiate, the QOS is rejected
+ because of which parameter family.
+ At present there is no indication comes from the lower layer why the QOS has failed, and in
+ all the case the member *aMsg.iBase.iMsg->pfqos_msg_type* will return *EPfQoSReject*.
+
+ At the time of writing this code any differentiation method was not available to differentiate
+ between events. i.e whether the event is SBLP or UMTS events. So this has not been done.
+ This needs to be done when the TPfqosMessage will have the differentiation
+ */
+ if (event)
+ {
+
+ NotifyClientEvent(*event);
+ delete event;
+ }
+ }
+ break;
+
+ case KPfqosEventConfirm:
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventConfirm")));
+
+ // Setting QoS Parameters OK
+ CSubConGenEventParamsGranted* event = CSubConGenEventParamsGranted::NewL();
+ ConvertParametersFromQOSL(aMsg, event);
+
+ NotifyClientEvent(*event);
+ delete event;
+
+ if( client != NULL )
+ {
+ client->JoinComplete(*this);
+ }
+ }
+ break;
+
+ case KPfqosEventAdapt:
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventAdapt")));
+
+ // Available QoS Changed
+ CSubConGenEventParamsChanged* event = CSubConGenEventParamsChanged::NewL();
+ event->SetError(aMsg.iBase.iMsg->pfqos_msg_errno);
+ ConvertParametersFromQOSL(aMsg, event);
+
+ NotifyClientEvent(*event);
+ delete event;
+ }
+ break;
+
+ case KPfqosEventJoin:
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventJoin")));
+ if (aMsg.iBase.iMsg->pfqos_msg_errno)
+ {
+ ProcessPRTError( aMsg, aMsg.iBase.iMsg->pfqos_msg_errno );
+ return;
+ }
+
+
+ CSubConGenEventDataClientJoined* event = CSubConGenEventDataClientJoined::NewL();
+
+ if( client )
+ {
+ const TSockAddr* SrcAddr = NULL;
+ const TSockAddr* DstAddr = NULL;
+ const TDesC8* connInfo;
+ client->ReadAddressInformation(SrcAddr, DstAddr, connInfo); // return can be would have errored above
+
+ TConnectionInfoBuf* connInfoBuf = (TConnectionInfoBuf*)connInfo->Ptr();
+ TUint32 iapId = (*connInfoBuf)().iIapId;
+
+ event->SetSourceAddress( *SrcAddr );
+ event->SetDestAddress( *DstAddr );
+ event->SetIap( iapId );
+
+ client->JoinComplete(*this);
+ }
+
+ NotifyClientEvent(*event);
+ delete event;
+ }
+ break;
+
+ case KPfqosEventLeave:
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventLeave")));
+
+ CSubConGenEventDataClientLeft* event = CSubConGenEventDataClientLeft::NewL();
+
+ if( client )
+ {
+ const TSockAddr* SrcAddr = NULL;
+ const TSockAddr* DstAddr = NULL;
+ const TDesC8* connInfo;
+ client->ReadAddressInformation(SrcAddr, DstAddr, connInfo); // return can be would have errored above
+
+ TConnectionInfoBuf* connInfoBuf = (TConnectionInfoBuf*)connInfo->Ptr();
+ TUint32 iapId = (*connInfoBuf)().iIapId;
+
+ event->SetSourceAddress( *SrcAddr );
+ event->SetDestAddress( *DstAddr );
+ event->SetIap( iapId );
+ }
+
+ NotifyClientEvent(*event);
+ delete event;
+
+ if( client != NULL )
+ {
+ client->LeaveComplete(*this);
+ }
+ }
+ break;
+
+ default:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: Unknown - %d"), aMsg.iEvent.iExt->event_type));
+ break;
+ }
+ }
+
+void CIpSubConnectionProvider::ProcessPRTReplyL(TPfqosMessage& aMsg)
+/**
+Process Replies sent from the PRT to the SubConnection Provider
+
+@param aMsg the message from the PRT
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ProcessPRTReplyL [%08x]"), this));
+
+ if( aMsg.iChannel.iExt == NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received malformed reply message from PRT")));
+ }
+ else if( aMsg.iBase.iMsg->pfqos_msg_errno != KErrNone )
+ {
+ ProcessPRTError( aMsg, aMsg.iBase.iMsg->pfqos_msg_errno );
+ }
+ else
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Reply: %d"), aMsg.iBase.iMsg->pfqos_msg_type));
+
+ MSubConnectionDataClient* client = NULL;
+ TInt ret = DetermineClient(aMsg, client);
+ if( ret != KErrNone || client == NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Could not determine DataClient from message. Error=%d"),ret));
+ }
+
+ switch (aMsg.iBase.iMsg->pfqos_msg_type)
+ {
+ case EPfqosOpenExistingChannel:
+ iChannelId = aMsg.iChannel.iExt->channel_id;
+ __IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosOpenExistingChannel")));
+ break;
+
+ case EPfqosCreateChannel:
+ iChannelId = aMsg.iChannel.iExt->channel_id;
+ __IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosCreateChannel")));
+ //Now you will expect to complete the join here. This will not work becuase
+ //qos.prt send a reply before finishing the join down to the nif level
+ //we will have to delay the response until the event is received
+ break;
+
+ case EPfqosJoin:
+ __IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosJoin")));
+ //Now you will expect to complete the join here. This will not work becuase
+ //qos.prt send a reply before finishing the join down to the nif level
+ //we will have to delay the response until the event is received
+ break;
+
+ case EPfqosLeave:
+ __IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosLeave")));
+ break;
+
+ case EPfqosConfigChannel:
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosConfigChannel")));
+ }
+ break;
+
+ case EPfqosDeleteChannel:
+ iChannelId = -1;
+ __IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosDeleteChannel")));
+ break;
+
+ default:
+ __IPCPRLOG(IpCprLog::Printf(_L("Ignoring Reply for unknown message: %d"), aMsg.iBase.iMsg->pfqos_msg_type));
+ break;
+ }
+ }
+
+ __IPCPRLOG(IpCprLog::Printf(_L("Provider=0x%x Channel=%d"), this, iChannelId));
+ }
+
+
+#ifdef _DEBUG
+void CIpSubConnectionProvider::ProcessPRTError(TInt aMsgType, TInt __IPCPRLOG(aError))
+/**
+Process Errors that occur in communicating between the PRT and the
+SubConnection Provider
+
+@param aMsgType the type of message that encountered the error
+@param aError the error ththas occurred
+*/
+ {
+ switch (aMsgType)
+ {
+ case EPfqosOpenExistingChannel:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosOpenExistingChannel"), aError));
+ break;
+
+ case EPfqosCreateChannel:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosCreateChannel"), aError));
+ break;
+
+ case EPfqosDeleteChannel:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosDeleteChannel"), aError));
+ break;
+
+ case EPfqosJoin:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosJoin"), aError));
+ break;
+
+ case EPfqosLeave:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosLeave"), aError));
+ break;
+
+ case EPfqosConfigChannel:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosConfigChannel"), aError));
+ break;
+
+ case EPfqosEvent:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosEvent"), aError));
+ break;
+
+ default:
+ __IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on Unknown Message"), aError));
+ break;
+ }
+ }
+#endif
+
+
+void CIpSubConnectionProvider::ProcessPRTError(TPfqosMessage& aMsg, TInt aError)
+/**
+Process Errors that occur in communicating between the PRT and the
+SubConnection Provider
+
+@param aMsg the message from the PRT
+@param aError the error ththas occurred
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ProcessPRTError [%08x]"), this));
+
+ if( aError != KErrNone)
+ {
+ TInt msgType = aMsg.iBase.iMsg->pfqos_msg_type;
+
+#ifdef _DEBUG
+ ProcessPRTError(msgType, aError);
+#endif
+
+ MSubConnectionDataClient* client = NULL;
+ TInt ret = DetermineClient(aMsg, client);
+ if( ret != KErrNone || client == NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Could not determine DataClient from message. Error=%d"),ret));
+ }
+
+ if( msgType == EPfqosJoin ||
+ msgType == EPfqosOpenExistingChannel ||
+ msgType == EPfqosCreateChannel ||
+ (msgType == EPfqosEvent && aMsg.iBase.iMsg->pfqos_msg_errno == EQoSJoinFailure))
+ {
+ if( client )
+ {
+ client->JoinFailed(*this,aError);
+ }
+ }
+ else if( msgType == EPfqosConfigChannel )
+ {
+ //This will send an error only if ECom successfuly constructs the event object
+ CSubConGenEventParamsRejected* event = NULL;
+ TRAP_IGNORE(event = CSubConGenEventParamsRejected::NewL());
+ if (event)
+ {
+ /**
+ comments give in case of *KPfqosEventFailure* in function *ProcessPRTEventL*
+ will also applicable here
+ */
+ if (aMsg.iBase.iMsg->pfqos_msg_errno == RPacketContext::EEtelPcktPolicyControlRejectionCode)
+ {
+ event->SetFamilyId(KSubConAuthorisationFamily);
+ }
+ else
+ {
+ event->SetFamilyId(KSubConQoSFamily);
+ }
+
+ event->SetError(aError);
+
+ NotifyClientEvent(*event);
+ delete event;
+ }
+ }
+ else if( msgType == EPfqosLeave ||
+ (msgType == EPfqosEvent && aMsg.iBase.iMsg->pfqos_msg_errno == EQoSLeaveFailure))
+ {
+ // Not Interested in whether the leave was successful. Inform client regardless
+ if( client != NULL )
+ {
+ client->LeaveComplete(*this);
+ }
+ }
+ else
+ {
+ if( client )
+ {
+ client->SubConnectionError(*this, MSubConnectionDataClient::ESubConnection, aError);
+ }
+ }
+ }
+ }
+
+
+TInt CIpSubConnectionProvider::DetermineClient(const TPfqosMessage& aMsg, MSubConnectionDataClient*& aDataClient)
+/**
+Determines which Data Client a message from the QoS PRT is for based upon source and destination
+address; and Protocol Id.
+
+@param aMsg QoS PRT Response Message
+@param aDataClient Output Variable as Data Client that matches reponse.
+
+@return KErrNone on finding the required client. Client passed back as argument.
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DetermineClient [%08x]"), this));
+
+ aDataClient = NULL;
+
+ const TInetAddr* msgSrcAddr = aMsg.iSrcAddr.iAddr;
+ const TInetAddr* msgDstAddr = aMsg.iDstAddr.iAddr;
+
+ if( msgSrcAddr == NULL || msgDstAddr == NULL || aMsg.iSelector.iExt == NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Received malformed message from PRT")););
+ }
+ else
+ {
+ TUint32 msgProtocol = aMsg.iSelector.iExt->protocol;
+
+ __IPCPRLOG(
+ THostName srcName;
+ msgSrcAddr->OutputWithScope(srcName);
+ THostName dstName;
+ msgDstAddr->OutputWithScope(dstName);
+ IpCprLog::Printf(_L("Msg SAddr[%S][%d] DAddr[%S][%d] Prot[%d]"), &srcName, msgSrcAddr->Port(), &dstName, msgDstAddr->Port(), msgProtocol);
+ );
+
+ // Compare message parameters with those from each client finding the one required
+ TInt numClients = iDataClients.Count();
+ for( TInt index=0; index<numClients; index++ )
+ {
+ MSubConnectionDataClient* client = iDataClients[index];
+ if( client != NULL )
+ {
+ const TSockAddr* cliSrcAddr = NULL;
+ const TSockAddr* cliDstAddr = NULL;
+ const TDesC8* connInfo;
+ TInt err = client->ReadAddressInformation(cliSrcAddr, cliDstAddr, connInfo);
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Unable to read Address Information")));
+ continue;
+ }
+
+ if( cliSrcAddr != NULL && cliDstAddr != NULL && connInfo != NULL )
+ {
+ TUint32 cliProtocol = client->ProtocolId();
+
+ TInetAddr srcInetAddr(*cliSrcAddr);
+ TInetAddr dstInetAddr(*cliDstAddr);
+
+ if (dstInetAddr.Family() == KAfInet)
+ {
+ dstInetAddr.ConvertToV4Mapped();
+ }
+
+ __IPCPRLOG(
+ srcInetAddr.OutputWithScope(srcName);
+ dstInetAddr.OutputWithScope(dstName);
+ IpCprLog::Printf(_L("Cli SAddr[%S][%d] DAddr[%S][%d] Prot[%d]"), &srcName, srcInetAddr.Port(), &dstName, dstInetAddr.Port(), cliProtocol);
+ );
+
+ if( (msgSrcAddr->Port() == srcInetAddr.Port() &&
+ (msgDstAddr->CmpAddr(dstInetAddr) && msgDstAddr->Port() == dstInetAddr.Port())) &&
+ msgProtocol == cliProtocol )
+ {
+ // Have our required client
+ __IPCPRLOG(IpCprLog::Printf(_L("Client Matched [%08x]"), client));
+ aDataClient = client;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if( aDataClient != NULL )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Client Found")));
+ }
+ else
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Client Not Found!")));
+ }
+
+ return aDataClient != NULL ? KErrNone : KErrNotFound;
+ }
+
+
+void CIpSubConnectionProvider::MapGenericParamsFromESockToPRTL(const CSubConQosGenericParamSet& generic) const
+/**
+Mapping function to map the generic parameters from the ESock to QoS PRT equivalent
+@param Generic Input structure contains the generic parameters
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::MapGenericParamsFromESockToPRTL")));
+ /**
+ Get and Set Uplink Parameters
+ */
+ iPrtParameters->SetUpLinkMaximumBurstSize(generic.GetUpLinkMaximumBurstSize());
+ iPrtParameters->SetUpLinkMaximumPacketSize(generic.GetUpLinkMaximumPacketSize());
+ iPrtParameters->SetUplinkBandwidth(generic.GetUplinkBandwidth());
+ iPrtParameters->SetUpLinkAveragePacketSize(generic.GetUpLinkAveragePacketSize());
+ iPrtParameters->SetUpLinkPriority(generic.GetUpLinkPriority());
+ iPrtParameters->SetUpLinkDelay(generic.GetUpLinkDelay());
+ /**
+ Get and Set Downlink Parameters
+ */
+ iPrtParameters->SetDownLinkMaximumBurstSize(generic.GetDownLinkMaximumBurstSize());
+ iPrtParameters->SetDownLinkMaximumPacketSize(generic.GetDownLinkMaximumPacketSize());
+ iPrtParameters->SetDownlinkBandwidth(generic.GetDownlinkBandwidth());
+ iPrtParameters->SetDownLinkAveragePacketSize(generic.GetDownLinkAveragePacketSize());
+ iPrtParameters->SetDownLinkPriority(generic.GetDownLinkPriority());
+ iPrtParameters->SetDownLinkDelay(generic.GetDownLinkDelay());
+ /**
+ Get and Set rest of the Parameters
+ */
+ iPrtParameters->SetHeaderMode(generic.GetHeaderMode());
+ TName name = generic.GetName();
+ iPrtParameters->SetName(name);
+ }
+
+void CIpSubConnectionProvider::MapGenericParamsFromPRTToESockL(CSubConQosGenericParamSet& generic) const
+/**
+Map generic parameters from QoS PRT to the ESock Equivalents
+
+@param params input structure that contains the QoS PRT generic parameters
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::MapGenericParamsFromPRTToESockL")));
+ /**
+ Get and Set Uplink Parameters
+ */
+ generic.SetUpLinkMaximumBurstSize(iPrtParameters->GetUpLinkMaximumBurstSize());
+ generic.SetUpLinkMaximumPacketSize(iPrtParameters->GetUpLinkMaximumPacketSize());
+ generic.SetUplinkBandwidth(iPrtParameters->GetUplinkBandwidth());
+ generic.SetUpLinkAveragePacketSize(iPrtParameters->GetUpLinkAveragePacketSize());
+ generic.SetUpLinkPriority(iPrtParameters->GetUpLinkPriority());
+ generic.SetUpLinkDelay(iPrtParameters->GetUpLinkDelay());
+ /**
+ Get and Set Downlink Parameters
+ */
+ generic.SetDownLinkMaximumBurstSize(iPrtParameters->GetDownLinkMaximumBurstSize());
+ generic.SetDownLinkMaximumPacketSize(iPrtParameters->GetDownLinkMaximumPacketSize());
+ generic.SetDownlinkBandwidth(iPrtParameters->GetDownlinkBandwidth());
+ generic.SetDownLinkAveragePacketSize(iPrtParameters->GetDownLinkAveragePacketSize());
+ generic.SetDownLinkPriority(iPrtParameters->GetDownLinkPriority());
+ generic.SetDownLinkDelay(iPrtParameters->GetDownLinkDelay());
+ /**
+ Get and Set rest of the Parameters
+ */
+ generic.SetHeaderMode(iPrtParameters->GetHeaderMode());
+ TName name = iPrtParameters->GetName();
+ generic.SetName(name);
+ }
+
+void CIpSubConnectionProvider::ConvertTQoSIntoCQoSParamsL(const TQoSParameters& aParameters)
+/**
+This function will copy the aParameters into the class CQoSParameters
+using member access functions
+@param aParameters input parameters that needs to be copied
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ConvertTQoSIntoCQoSParamsL")));
+ /**
+ Get and Set Uplink Parameters
+ */
+ iPrtParameters->SetUplinkBandwidth(aParameters.GetUplinkBandwidth());
+ iPrtParameters->SetUpLinkMaximumBurstSize(aParameters.GetUpLinkMaximumBurstSize());
+ iPrtParameters->SetUpLinkMaximumPacketSize(aParameters.GetUpLinkMaximumPacketSize());
+ iPrtParameters->SetUpLinkAveragePacketSize(aParameters.GetUpLinkAveragePacketSize());
+ iPrtParameters->SetUpLinkDelay(aParameters.GetUpLinkDelay());
+ iPrtParameters->SetUpLinkPriority(aParameters.GetUpLinkPriority());
+ /**
+ Get and Set Downlink Parameters
+ */
+ iPrtParameters->SetDownlinkBandwidth(aParameters.GetDownlinkBandwidth());
+ iPrtParameters->SetDownLinkMaximumBurstSize(aParameters.GetDownLinkMaximumBurstSize());
+ iPrtParameters->SetDownLinkMaximumPacketSize(aParameters.GetDownLinkMaximumPacketSize());
+ iPrtParameters->SetDownLinkAveragePacketSize(aParameters.GetDownLinkAveragePacketSize());
+ iPrtParameters->SetDownLinkDelay(aParameters.GetDownLinkDelay());
+ iPrtParameters->SetDownLinkPriority(aParameters.GetDownLinkPriority());
+
+ iPrtParameters->SetAdaptMode(aParameters.AdaptMode());
+ iPrtParameters->SetHeaderMode(aParameters.GetHeaderMode());
+ const TName name = aParameters.GetName();
+ iPrtParameters->SetName(name);
+ }
+
+void CIpSubConnectionProvider::ConvertCQoSIntoTQoSParamsL(TQoSParameters& aParameters) const
+/**
+This function will copy the iParameters (CQoSParameters) into aParameters
+using member access functions
+@param aParameters output parameters that iParameters will be copied into
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ConvertCQoSIntoTQoSParamsL")));
+ /**
+ Get and Set Uplink Parameters
+ */
+ aParameters.SetUplinkBandwidth(iPrtParameters->GetUplinkBandwidth());
+ aParameters.SetUpLinkMaximumBurstSize(iPrtParameters->GetUpLinkMaximumBurstSize());
+ aParameters.SetUpLinkMaximumPacketSize(iPrtParameters->GetUpLinkMaximumPacketSize());
+ aParameters.SetUpLinkAveragePacketSize(iPrtParameters->GetUpLinkAveragePacketSize());
+ aParameters.SetUpLinkDelay(iPrtParameters->GetUpLinkDelay());
+ aParameters.SetUpLinkPriority(iPrtParameters->GetUpLinkPriority());
+
+ /**
+ Get and Set Downlink Parameters
+ */
+ aParameters.SetDownlinkBandwidth(iPrtParameters->GetDownlinkBandwidth());
+ aParameters.SetDownLinkMaximumBurstSize(iPrtParameters->GetDownLinkMaximumBurstSize());
+ aParameters.SetDownLinkMaximumPacketSize(iPrtParameters->GetDownLinkMaximumPacketSize());
+ aParameters.SetDownLinkAveragePacketSize(iPrtParameters->GetDownLinkAveragePacketSize());
+ aParameters.SetDownLinkDelay(iPrtParameters->GetDownLinkDelay());
+ aParameters.SetDownLinkPriority(iPrtParameters->GetDownLinkPriority());
+
+ aParameters.SetAdaptMode(iPrtParameters->AdaptMode());
+ aParameters.SetHeaderMode(iPrtParameters->GetHeaderMode());
+ const TName name = iPrtParameters->GetName();
+ aParameters.SetName(name);
+ }
+
+
+void CIpSubConnectionProvider::MapExtensionParamsFromESockToPRTL(const CSubConQosIPLinkR99ParamSet& extension, TUmtsQoSParameters& params)
+/**
+Map extension parameters from QoS PRT to the ESock Equivalents
+
+@param extension input structure that contains the ESock extension parameters
+@param params structure updated to contains the equivalent QoS PRT extension parameters
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("MapExtensionParamsFromESockToPRTL")));
+
+ RPacketQoS::TTrafficClass trafficClass = extension.GetTrafficClass();
+ User::LeaveIfError(params.SetTrafficClass((TUmtsTrafficClass)trafficClass));
+
+ RPacketQoS::TDeliveryOrder deliveryOrder = extension.GetDeliveryOrder();
+ User::LeaveIfError(params.SetDeliveryOrder((TUmtsDeliveryOrder)deliveryOrder));
+
+ RPacketQoS::TErroneousSDUDelivery sduDelivery = extension.GetErroneousSDUDelivery();
+ User::LeaveIfError(params.SetDeliveryOfErroneusSdu((TUmtsErroneousSDUDelivery)sduDelivery));
+
+ RPacketQoS::TBitErrorRatio bitErrorRate = extension.GetResidualBitErrorRatio();
+ User::LeaveIfError(params.SetResidualBer((TUmtsBitErrorRatio)bitErrorRate));
+
+ RPacketQoS::TSDUErrorRatio sduErrorRatio = extension.GetSDUErrorRatio();
+ User::LeaveIfError(params.SetErrorRatio((TUmtsSDUErrorRatio)sduErrorRatio));
+
+ RPacketQoS::TTrafficHandlingPriority trafficHandlingPriority = extension.GetTrafficHandlingPriority();
+ User::LeaveIfError(params.SetPriority((TUmtsTrafficHandlingPriority)trafficHandlingPriority));
+
+ TInt transferDelay = extension.GetTransferDelay();
+ User::LeaveIfError(params.SetTransferDelay(transferDelay));
+
+ TInt maxSduSize = extension.GetMaxSduSize();
+ User::LeaveIfError(params.SetMaxSduSize(maxSduSize));
+
+ TInt maxBitRateUp = extension.GetMaxBitrateUplink();
+ User::LeaveIfError(params.SetMaxBitrateUplink(maxBitRateUp));
+
+ TInt maxBitRateDown = extension.GetMaxBitrateDownlink();
+ User::LeaveIfError(params.SetMaxBitrateDownlink(maxBitRateDown));
+
+ TInt guaBitRateUp = extension.GetGuaBitrateUplink();
+ User::LeaveIfError(params.SetGuaranteedBitrateUplink(guaBitRateUp));
+
+ TInt guaBitRateDown = extension.GetGuaBitrateDownlink();
+ User::LeaveIfError(params.SetGuaranteedBitrateDownlink(guaBitRateDown));
+
+ iParameterRelease = KParameterRel4Rel99;
+ }
+
+void CIpSubConnectionProvider::MapExtensionParamsFromESockToPRTL(const CSubConSBLPR5ExtensionParamSet& extension, CSblpParameters& params) const
+ {
+ TAuthToken authToken = extension.GetMAT();
+ params.SetMAT(authToken);
+
+ /**
+ Get Flow Identifires And store that into the RArray of Flow Ids
+ of SBLP Paramters
+ */
+ RArray<CSblpParameters::TFlowIdentifier> arrFlowIds;
+ CleanupClosePushL(arrFlowIds);
+
+ TInt nrOfFlows = extension.GetNumberOfFlowIds();
+ for ( TInt i = 0; i < nrOfFlows; i ++ )
+ {
+ const TFlowId & Fid = extension.GetFlowIdAt(i);
+ CSblpParameters::TFlowIdentifier FlowId;
+ FlowId.iMediaComponentNumber = Fid.GetMediaComponentNumber();
+ FlowId.iIPFlowNumber = Fid.GetIPFlowNumber();
+ arrFlowIds.AppendL(FlowId);
+ }
+ params.SetFlowIds(arrFlowIds);
+ CleanupStack::Pop(&arrFlowIds);
+ arrFlowIds.Close();
+ }
+
+void MapExtensionParamsFromPRTToESockL(TUmtsQoSParameters& params, CSubConQosIPLinkR99ParamSet& extension)
+/**
+Map extension parameters from ESock to the QoS PRT Equivalents
+
+@param params input structure that contains the QoS PRT extension parameters
+@param extension structure updated to contain the ESock equivalent extension parameters
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("MapExtensionParamsFromPRTToESockL")));
+
+ TUmtsTrafficClass trafficClass = params.TrafficClass();
+ extension.SetTrafficClass((RPacketQoS::TTrafficClass) trafficClass);
+
+ TUmtsDeliveryOrder deliveryOrder = params.DeliveryOrder();
+ extension.SetDeliveryOrder((RPacketQoS::TDeliveryOrder) deliveryOrder);
+
+ TUmtsErroneousSDUDelivery deliveryOfErroneusSdu = params.DeliveryOfErroneusSdu();
+ extension.SetErroneousSDUDelivery((RPacketQoS::TErroneousSDUDelivery) deliveryOfErroneusSdu);
+
+ TUmtsBitErrorRatio residualBer = params.ResidualBer();
+ extension.SetResidualBitErrorRatio((RPacketQoS::TBitErrorRatio) residualBer);
+
+ TUmtsSDUErrorRatio errorRatio = params.ErrorRatio();
+ extension.SetSDUErrorRatio((RPacketQoS::TSDUErrorRatio) errorRatio);
+
+ TUmtsTrafficHandlingPriority priority = params.Priority();
+ extension.SetTrafficHandlingPriority((RPacketQoS::TTrafficHandlingPriority) priority);
+
+ TInt transferDelay = params.TransferDelay();
+ extension.SetTransferDelay(transferDelay);
+
+ TInt maxSduSize = params.MaxSduSize();
+ extension.SetMaxSduSize(maxSduSize);
+
+ TInt maxBitrateUplink = params.MaxBitrateUplink();
+ extension.SetMaxBitrateUplink(maxBitrateUplink);
+
+ TInt maxBitrateDownlink = params.MaxBitrateDownlink();
+ extension.SetMaxBitrateDownlink(maxBitrateDownlink);
+
+ TInt guaBitrateUplink = params.GuaranteedBitrateUplink();
+ extension.SetGuaBitrateUplink(guaBitrateUplink);
+
+ TInt guaBitrateDownlink = params.GuaranteedBitrateDownlink();
+ extension.SetGuaBitrateDownlink(guaBitrateDownlink);
+ }
+
+
+#ifdef SYMBIAN_NETWORKING_UMTSR5
+void CIpSubConnectionProvider::MapExtensionParamsFromESockToPRTL(const CSubConQosR5ParamSet& aExtension, TUmtsR5QoSParameters& aParams)
+/**
+Map extension parameters from QoS PRT to the ESock Equivalents
+
+@param extension input structure that contains the ESock extension parameters
+@param params structure updated to contains the equivalent QoS PRT extension parameters
+*/
+ {
+
+ __IPCPRLOG(IpCprLog::Printf(_L("MapExtensionParamsFromESockToPRTL")));
+
+ MapExtensionParamsFromESockToPRTL(static_cast<const CSubConQosIPLinkR99ParamSet&>(aExtension), static_cast<TUmtsQoSParameters&>(aParams));
+
+ TBool signallingIndicator = aExtension.GetSignallingIndicator();
+ User::LeaveIfError(aParams.SetSignallingIndicator(signallingIndicator));
+
+ RPacketQoS::TSourceStatisticsDescriptor sourceStatisticsDescriptor = aExtension.GetSourceStatisticsDescriptor();
+ User::LeaveIfError(aParams.SetSourceStatisticsDescriptor(reinterpret_cast<TUmtsSourceStatisticsDescriptor&>(sourceStatisticsDescriptor)));
+
+ iParameterRelease = KParameterRel5;
+ }
+
+void MapExtensionParamsFromPRTToESockL(TUmtsR5QoSParameters& aParams, CSubConQosR5ParamSet& aExtension)
+/**
+Map extension parameters from ESock to the QoS PRT Equivalents
+
+@param params input structure that contains the QoS PRT extension parameters
+@param extension structure updated to contain the ESock equivalent extension parameters
+*/
+ {
+
+ __IPCPRLOG(IpCprLog::Printf(_L("MapExtensionParamsFromPRTToESockL")));
+
+ MapExtensionParamsFromPRTToESockL(static_cast<TUmtsQoSParameters&>(aParams),static_cast<CSubConQosIPLinkR99ParamSet&>(aExtension));
+
+ TBool signallingprtIndicator = aParams.SignallingIndicator();
+ aExtension.SetSignallingIndicator(signallingprtIndicator);
+
+ TUmtsSourceStatisticsDescriptor sourceStatisticsprtDescriptor = aParams.SourceStatisticsDescriptor();
+ aExtension.SetSourceStatisticsDescriptor(reinterpret_cast<RPacketQoS::TSourceStatisticsDescriptor&>(sourceStatisticsprtDescriptor));
+
+ }
+
+void CIpSubConnectionProvider::MapExtensionParamsFromESockToPRTL(const CSubConImsExtParamSet& aExtension, TImsParameter& aParams)
+/**
+Map extension parameters from QoS PRT to the ESock Equivalents
+
+@param extension input structure that contains the ESock extension parameters
+@param params structure updated to contains the equivalent QoS PRT extension parameters
+*/
+ {
+
+
+ __IPCPRLOG(IpCprLog::Printf(_L("MapExtensionParamsFromESockToPRTL")));
+
+ TBool IMSSignallingIndicator = aExtension.GetImsSignallingIndicator();
+ aParams.SetIMSSigallingIndicator(IMSSignallingIndicator);
+
+ }
+
+void MapExtensionParamsFromPRTToESockL(TImsParameter& aParams, CSubConImsExtParamSet& aExtension)
+/**
+Map extension parameters from ESock to the QoS PRT Equivalents
+
+@param params input structure that contains the QoS PRT extension parameters
+@param extension structure updated to contain the ESock equivalent extension parameters
+*/
+ {
+
+ __IPCPRLOG(IpCprLog::Printf(_L("MapExtensionParamsFromPRTToESockL")));
+
+ TBool IMSSignallingIndicator = aParams.GetIMSSigallingIndicator();
+ aExtension.SetImsSignallingIndicator(IMSSignallingIndicator);
+
+ }
+
+#endif
+// SYMBIAN_NETWORKING_UMTSR5
+
+void CIpSubConnectionProvider::ResetPrtExtensions()
+ {
+ TQoSExtensionQueueIter iter(iPrtExtensions);
+ CExtensionBase *ext;
+ ext = iter++;
+ while (ext)
+ {
+ delete ext;
+ ext = iter++;
+ }
+ iPrtExtensions.Reset();
+ }
+
+void CIpSubConnectionProvider::ConvertParametersFromESockL(CSubConParameterBundle& aParameterBundle)
+/**
+Covert QoS Parameters sent from ESock to QoS PRT values and cache the values
+
+@param aParameterBundle the bundle that contains all of ESock's QoS Variables
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ConvertParametersFromESockL [%08x]"), this));
+
+ ResetPrtExtensions();
+
+ CSubConParameterFamily* family = aParameterBundle.FindFamily(KSubConQoSFamily);
+ if(family)
+ {
+ CUmtsQoSPolicy* policy = CUmtsQoSPolicy::NewL();
+ CleanupStack::PushL(policy);
+ TBool policySet = EFalse;
+
+ // Map Requested Generic Parameters from ESock to PRT Values
+ CSubConQosGenericParamSet* generic = (CSubConQosGenericParamSet*)family->GetGenericSet(CSubConParameterFamily::ERequested);
+ if(generic)
+ {
+ TRAPD(err, MapGenericParamsFromESockToPRTL(*generic));
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Failed to convert from ESock to PRT Generic Parameters (Requested) with Error: %d"),err));
+ }
+ }
+
+ // Map Requested UMTS Parameters from ESock to PRT values
+ CSubConQosIPLinkR99ParamSet* extension = (CSubConQosIPLinkR99ParamSet*)family->FindExtensionSet(
+ STypeId::CreateSTypeId(KSubConIPParamsUid,KSubConQosIPLinkR99ParamsType), CSubConParameterFamily::ERequested);
+ if(extension)
+ {
+ TUmtsQoSParameters params;
+
+ TRAPD(err, MapExtensionParamsFromESockToPRTL(*extension, params));
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Failed to convert from ESock to PRT Extension Parameters (Requested) with Error: %d"),err));
+ }
+
+ policy->SetQoSRequested(params);
+ policySet = ETrue;
+ }
+
+ // Map Minimum UMTS Parameters from ESock to PRT values
+ extension = (CSubConQosIPLinkR99ParamSet*)family->FindExtensionSet(
+ STypeId::CreateSTypeId(KSubConIPParamsUid,KSubConQosIPLinkR99ParamsType), CSubConParameterFamily::EAcceptable);
+ if(extension)
+ {
+ TUmtsQoSParameters params;
+ TRAPD(err, MapExtensionParamsFromESockToPRTL(*extension,params));
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Failed to convert from ESock to PRT Extension Parameters (Minimum) with Error: %d"),err));
+ }
+
+ policy->SetQoSMinimum(params);
+ policySet = ETrue;
+ }
+
+ if(policySet)
+ {
+ iPrtExtensions.AddFirst(*policy);
+ CleanupStack::Pop();
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(policy);
+ }
+
+#ifdef SYMBIAN_NETWORKING_UMTSR5
+
+ CUmtsR5QoSPolicy* policyR5 = CUmtsR5QoSPolicy::NewL();
+ CleanupStack::PushL(policyR5);
+ TBool policySetR5 = EFalse;
+ // Map Requested UMTS Parameters from ESock to PRT values
+ CSubConQosR5ParamSet* extensionR5 = static_cast<CSubConQosR5ParamSet*>(family->FindExtensionSet(STypeId::CreateSTypeId(KSubConIPParamsUid,KSubConQosR5ParamsType), CSubConParameterFamily::ERequested));
+ if(extensionR5)
+ {
+ TUmtsR5QoSParameters paramsR5;
+ TRAPD(err, MapExtensionParamsFromESockToPRTL(*extensionR5, paramsR5));
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Failed to convert from ESock to PRT Extension Parameters (Requested) with Error: %d"),err));
+ }
+
+ policyR5->SetQoSRequested(paramsR5);
+ policySetR5 = ETrue;
+ }
+ // Map Minimum UMTS Parameters from ESock to PRT values
+ extensionR5 = static_cast<CSubConQosR5ParamSet*>(family->FindExtensionSet(STypeId::CreateSTypeId(KSubConIPParamsUid,KSubConQosR5ParamsType), CSubConParameterFamily::EAcceptable));
+ if(extensionR5)
+ {
+ TUmtsR5QoSParameters paramsR5;
+ TRAPD(err, MapExtensionParamsFromESockToPRTL(*extensionR5,paramsR5));
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Failed to convert from ESock to PRT Extension Parameters (Minimum) with Error: %d"),err));
+ }
+
+ policyR5->SetQoSMinimum(paramsR5);
+ policySetR5 = ETrue;
+ }
+
+ if(policySetR5)
+ {
+ iPrtExtensions.AddFirst(*policyR5);
+ CleanupStack::Pop();
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(policyR5);
+ }
+
+
+ CImsPolicy* policyIms = CImsPolicy ::NewL();
+ CleanupStack::PushL(policyIms);
+ TBool policySetIms = EFalse;
+ // Map Requested UMTS IMS Parameters from ESock to PRT values
+ CSubConImsExtParamSet* extensionIms = static_cast<CSubConImsExtParamSet*>(family->FindExtensionSet(STypeId::CreateSTypeId(KSubConIPParamsUid,KSubConImsExtParamsType), CSubConParameterFamily::ERequested));
+ if(extensionIms)
+ {
+ TImsParameter paramsIms;
+
+ TRAPD(err, MapExtensionParamsFromESockToPRTL(*extensionIms, paramsIms));
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Failed to convert from ESock to PRT Extension Parameters (Requested) with Error: %d"),err));
+ }
+
+ policyIms->SetImsParameter(paramsIms);
+ policySetIms = ETrue;
+ }
+
+ if(policySetIms)
+ {
+ iPrtExtensions.AddFirst(*policyIms);
+ CleanupStack::Pop();
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(policyIms);
+ }
+
+#endif
+// SYMBIAN_NETWORKING_UMTSR5
+
+ }
+
+ // Convert SBLP set if present
+ // Check for the presence of the family in the bundle
+ CSubConParameterFamily* sblpFamily = aParameterBundle.FindFamily(KSubConAuthorisationFamily);
+ if (sblpFamily)
+ {
+ CSblpPolicy* policy = CSblpPolicy::NewL();
+ CleanupStack::PushL(policy);
+ TBool policySet = EFalse;
+
+ /**
+ Extract the generic and extension Parmaters of the Family. At present the generic
+ parameters will just contains a dummy , and will not be used. The code is commented
+ and can be enabled sometimes when any parameter varification at the code is required
+ */
+ // CSubConAuthorisationGenericParamSet* generic = (CSubConAuthorisationGenericParamSet*)SblpFamily->GetGenericSet(CSubConParameterFamily::ERequested);
+ /**
+ There can be more than one extension set containing multiple MATs, as a requirement for the R6.
+ currently the APIs in CSubConParameterFamily is not able to extract multiple parameters. once this
+ is done, the code below must be changed to run on a loop on number of extensions
+ */
+
+ // Map Requested UMTS Parameters from ESock to PRT values
+ CSubConSBLPR5ExtensionParamSet* extension = (CSubConSBLPR5ExtensionParamSet*)sblpFamily->FindExtensionSet(
+ STypeId::CreateSTypeId(KSubConIPParamsUid,KSubConnSBLPR5ExtensionParamsType), CSubConParameterFamily::ERequested);
+ if(extension)
+ {
+ CSblpParameters* params = new (ELeave)CSblpParameters;
+ CleanupStack::PushL(params);
+ TRAPD(err, MapExtensionParamsFromESockToPRTL(*extension,*params));
+ if( err != KErrNone )
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("Failed to convert from ESock to PRT Extension Parameters (Requested) with Error: %d"),err));
+ }
+
+ policy->SetSblpParameters(*params); //does a bitwise copy therefore we must still delete params afterwards
+ policySet = ETrue;
+ CleanupStack::Pop(params);
+ delete params;
+ }
+
+ if( policySet )
+ {
+ iPrtExtensions.AddFirst(*policy);
+ CleanupStack::Pop();
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(policy);
+ }
+ }
+ }
+
+
+void CIpSubConnectionProvider::ConvertParametersFromQOSL(TPfqosMessage& aMsg, CSubConGenEventParamsGranted* aEvent)
+/**
+Convert parameters from a PRT response to ESock equivalents. PRT parameters are cached
+
+@param aMsg QoS PRT Response Message
+@param aEvent ESock event to contain changed QoS Parameters
+*/
+ {
+ __IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ConvertParametersFromQOSL [%08x]"), this));
+
+ /** Changed as per usase of CQosParamaters instead of
+ TQoSParameter
+ */
+
+ TQoSParameters qosParams;
+ aMsg.SetQoSParameters(qosParams);
+
+ // Copy qosParams into the iPrtParameters
+ ConvertTQoSIntoCQoSParamsL(qosParams);
+ aEvent->SetFamily(KSubConQoSFamily);
+
+ CSubConQosGenericParamSet* generic = CSubConQosGenericParamSet::NewL();
+ MapGenericParamsFromPRTToESockL(*generic);
+ aEvent->SetGenericSet(generic);
+
+
+
+ TSglQueIter<CPfqosPolicyData> iter(aMsg.iExtensions);
+ CPfqosPolicyData* data = NULL;
+
+ // for each pfqos extension that exists in aMsg
+ while ((data = iter++) != NULL)
+ {
+ const TUint8 *p = data->Data().Ptr();
+ TInt length = data->Data().Length();
+ const struct pfqos_configure* pfqosExtConfig = reinterpret_cast<const struct pfqos_configure*>(p);
+
+ if (length > (TInt)sizeof(pfqos_configure) &&
+ pfqosExtConfig->pfqos_configure_len * 8 == length &&
+ pfqosExtConfig->pfqos_ext_type == EPfqosExtExtension)
+ {
+
+ // pfqos_extension struct is located straight after pfqos_configure struct
+ p += sizeof(struct pfqos_configure);
+ const struct pfqos_extension* pfqosExtension = reinterpret_cast<const struct pfqos_extension*>(p);
+ TInt extType = pfqosExtension->pfqos_extension_type;
+
+ CExtensionBase* scPfqosExtension = NULL;
+ TQoSExtensionQueueIter iter2(iPrtExtensions);
+
+ // for each pfqos extension that has been configured in this subconnection
+ while ((scPfqosExtension = iter2++) != NULL)
+ {
+ if (scPfqosExtension->Type() == extType)
+ {
+ // the extension in the message matches an extension that is configured on the
+ // subconnection, now we can parse it
+ scPfqosExtension->ParseMessage(data->Data());
+
+ CSubConExtensionParameterSet* extension = NULL;
+#ifdef SYMBIAN_NETWORKING_UMTSR5
+ switch (extType)
+ {
+ case KPfqosExtensionUmts:
+#endif
+ {
+ CUmtsQoSPolicy *policy = static_cast<CUmtsQoSPolicy*>(scPfqosExtension);
+ TNegotiatedUmtsQoSParameters grantedQoS;
+ policy->GetQoSNegotiated(grantedQoS);
+ extension = CSubConQosIPLinkR99ParamSet::NewL();
+ CleanupStack::PushL(extension);
+ MapExtensionParamsFromPRTToESockL(grantedQoS,*static_cast<CSubConQosIPLinkR99ParamSet*>(extension));
+#ifdef SYMBIAN_NETWORKING_UMTSR5
+ break;
+ }
+ case KPfqosR5ExtensionUmts:
+ extension = MapFromUmtsR5ExtensionL(static_cast<CUmtsR5QoSPolicy*>(scPfqosExtension));
+ CleanupStack::PushL(extension);
+ break;
+
+ case KPfqosExtensionIMS:
+ extension = MapFromImsExtensionL(static_cast<CImsPolicy*>(scPfqosExtension));
+ CleanupStack::PushL(extension);
+ break;
+#endif
+ }
+
+ if (extension)
+ {
+ // Need to add it to the cleanup stack so we don't lose the ptr
+ // in the event that AddExtensionSetL leaves
+ aEvent->AddExtensionSetL(extension);
+ CleanupStack::Pop(extension);
+ }
+
+ // Next extension from aMsg
+ break;
+ }
+ }
+ }
+ }
+ }
+
+
+
+#ifdef SYMBIAN_NETWORKING_UMTSR5
+CSubConExtensionParameterSet* CIpSubConnectionProvider::MapFromUmtsR5ExtensionL (const CUmtsR5QoSPolicy* aPolicy)
+ {
+ ASSERT(aPolicy);
+
+ TNegotiatedUmtsR5QoSParameters grantedR5QoS;
+ aPolicy->GetQoSNegotiated(grantedR5QoS);
+
+ CSubConExtensionParameterSet* paramSet;
+
+ switch (iParameterRelease)
+ {
+ case KParameterRel5:
+ paramSet = CSubConQosR5ParamSet::NewL();
+ CleanupStack::PushL(paramSet);
+ MapExtensionParamsFromPRTToESockL(static_cast<TUmtsR5QoSParameters&>(grantedR5QoS),
+ *static_cast<CSubConQosR5ParamSet*>(paramSet));
+ CleanupStack::Pop(paramSet);
+ break;
+
+ case KParameterRel4Rel99:
+ paramSet = CSubConQosR99ParamSet::NewL();
+ CleanupStack::PushL(paramSet);
+ MapExtensionParamsFromPRTToESockL(static_cast<TUmtsQoSParameters&>(grantedR5QoS),
+ *static_cast<CSubConQosR99ParamSet*>(paramSet));
+ CleanupStack::Pop(paramSet);
+ break;
+
+ default:
+ // Break in debug builds
+ ASSERT(EFalse);
+ return NULL;
+ }
+
+ return paramSet;
+ }
+
+
+CSubConExtensionParameterSet* CIpSubConnectionProvider::MapFromImsExtensionL (const CImsPolicy* aPolicy)
+ {
+ ASSERT(aPolicy);
+
+ TImsParameter grantedImsQoS;
+ aPolicy->GetImsParameter(grantedImsQoS);
+
+ CSubConImsExtParamSet* extensionIms = CSubConImsExtParamSet::NewL();
+ CleanupStack::PushL(extensionIms);
+ MapExtensionParamsFromPRTToESockL(grantedImsQoS, *extensionIms);
+ CleanupStack::Pop(extensionIms);
+
+ return extensionIms;
+ }
+#endif
+// SYMBIAN_NETWORKING_UMTSR5
+
+#endif
+// BASIC_IPSCPR
+