// Copyright (c) 2008-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:

// IP SubConnection Provider implementation

// 

//

/**

 @file

 @internalComponent

*/

#include <etelqos.h>

#include "IPSCPRStates.h"

#include "IPSCPR.h"

#include "ipdeftbasescpr.h"

#include "../../iptransportlayer/src/ipscprlog.h"

#include "pfqos_stream.h"

#include "qos_msg.h"

#include <networking/qoserr.h>

#include <networking/sblpextn.h>

#include <comms-infras/ss_log.h>

#include "IPMessages.h"

#include <comms-infras/ss_msgintercept.h>

#include <elements/nm_messages_base.h>

#include <elements/nm_messages_child.h>

#include <elements/nm_messages_peer.h>

#include <comms-infras/ss_nodemessages_factory.h>

//TODO remove this ECFActivityDataClientJoin activity

#include "../../../../commsfw/datacommsserver/esockserver/inc/ss_internal_activities.h"

#if defined __FLOG_ACTIVE || defined SYMBIAN_TRACE_ENABLE

	#define KIPSCprTag KESockSubConnectionTag

	//_LIT8(KIPSCprSubTag, "ipscpr");

#endif

using namespace Messages;

using namespace MeshMachine;

using namespace ESock;

using namespace NetStateMachine;

namespace QoSIPSCprJoinActivity

{ //This activity needs the activity object (& it can fail on AddClientL, so no point converting)

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityDataClientJoin, QoSIpSCprJoin, TCFPeer::TJoinRequest, MeshMachine::CNodeRetryActivity::NewL)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingDataClientJoinRequest, QoSIpSCprStates::TNoTagBlockedByOpenInternalSocket)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TAddDataClientAndRespond)

NODEACTIVITY_END()

}

namespace QoSIPSCprClientLeaveActivity

{ //This activity does not need the activity object and cannot fail

DECLARE_DEFINE_NODEACTIVITY(ECFActivityClientLeave, QoSIpSCprLeave, Messages::TNodeSignal::TNullMessageId)

	NODEACTIVITY_ENTRY(KNoTag, QoSIpSCprStates::TRemoveLeavingClientFromQoSChannel, CoreStates::TAwaitingClientLeave, MeshMachine::TNoTag)

NODEACTIVITY_END()

}

/**

   This activity opens the PfQos internal socket asynchronously.

   Join activity is synchronised on this, so no clients can join until the internal socket has been opened or

   the internal socket opening has failed.

*/

namespace QoSIPSCprOpenInternalSocket

{

DECLARE_DEFINE_NODEACTIVITY(QoSIpSCprActivities::EQoSIpSCprOpenInternalSocket, qosIpScprOpenInternalSocket, TQoSIpSCprMessages::TOpenInternalSocket)

    FIRST_NODEACTIVITY_ENTRY(QoSIpSCprStates::TAwaitingOpenInternalSocket, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, QoSIpSCprStates::TOpenInternalSocket, QoSIpSCprStates::TAwaitingInternalSocketOpened, MeshMachine::TNoTag)

    LAST_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing)

NODEACTIVITY_END()

}

namespace QoSIPSCprSetParameters

{

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityParamRequest, qosIpScprParamRequest, TCFScpr::TSetParamsRequest, MeshMachine::CNodeRetryActivity::NewL)

    FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingParamRequest, QoSIpSCprStates::TNoTagBlockedByOpenInternalSocket)

#else

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityParamRequest, qosIpScprParamRequest, TCFScpr::TParamsRequest, MeshMachine::CNodeRetryActivity::NewL)

    FIRST_NODEACTIVITY_ENTRY(SCprStates::TAwaitingParamRequest, QoSIpSCprStates::TNoTagBlockedByOpenInternalSocket)

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

    LAST_NODEACTIVITY_ENTRY(KNoTag, QoSIpSCprStates::TStoreAndSetParameters)

NODEACTIVITY_END()

}

namespace QoSIPSCprApplyRequest

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityApplyChanges, SCprApplyReq, TCFScpr::TApplyRequest, MeshMachine::CNodeRetryActivity::NewL)

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingApplyRequest, QoSIpSCprStates::TNoTagOrSendApplyResponseBlockedByOpenInternalSocketAndAddressUpdate)

#else

	FIRST_NODEACTIVITY_ENTRY(SCprStates::TAwaitingApplyRequest, QoSIpSCprStates::TNoTagOrSendApplyResponseBlockedByOpenInternalSocketAndAddressUpdate)

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	NODEACTIVITY_ENTRY(SCprStates::KClientsJoining, QoSIpSCprStates::TAddClientToQoSChannel,    QoSIpSCprStates::TAwaitingJoinComplete,  MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(SCprStates::KClientsLeaving, QoSIpSCprStates::TRemoveClientToQoSChannel, QoSIpSCprStates::TAwaitingLeaveComplete, MeshMachine::TNoTag)

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TSendApplyResponse)

#else

	LAST_NODEACTIVITY_ENTRY(KNoTag, SCprStates::TSendApplyResponse)

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

NODEACTIVITY_END()

}

namespace QoSIPSCprAddressUpdate

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(IPDeftSCprBaseActivities::ECFActivityAddressUpdate, QoSIPSCprAddressUpdate, TCFIPMessages::TDataClientRouted, MeshMachine::CNodeRetryActivity::NewL)

    FIRST_NODEACTIVITY_ENTRY(IPBaseSCprStates::TAwaitingAddressUpdate, QoSIpSCprStates::TNoTagBlockedByOpenInternalSocket)

    LAST_NODEACTIVITY_ENTRY(KNoTag, QoSIpSCprStates::TStoreAddressUpdateAndAddClientToQoSChannel)

NODEACTIVITY_END()

}

namespace QoSIPSCprDestroy

{

//This destroy activity is special, it waits for the TBindToRequest to complete should one be started from the

//CIpSubConnectionProvider::ReceivedL()

//Problem is as follows:

//When the requesting ControlClient fails to join this SCpr and responds with TBindToComplete(error), the Cpr

//sends TDestroy to this SCpr. This SCpr will destruct itself not waiting for the TBindToRequest to complete

//which results in (for example) the TDataClientJoined hitting void.

//This is not a proper fix, same as sending TBindToRequest from CIpSubConnectionProvider::ReceivedL() is a hack.

//There should be EAP diagrams present, where are they?

typedef MeshMachine::TActivitiesIdMutex<ESock::ECFActivityStop, ESock::ECFActivityStopDataClient, ESock::ECFActivityDataClientGoneDown, ESock::ECFActivityBindTo> TQosIpSCprActivityMutex;

DECLARE_SERIALIZABLE_STATE(

	TNoTagBlockedByQosIpSCprActivities,

    TQosIpSCprActivityMutex,

    MeshMachine::TNoTag

    )

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityDestroy, QoSIPSCprDestroy, TEChild::TDestroy, CoreActivities::CDestroyActivity::New)

	FIRST_NODEACTIVITY_ENTRY(MeshMachine::TAwaitingDestroy, TNoTagBlockedByQosIpSCprActivities)

    //Stop self first

    NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TStopSelf, CoreNetStates::TAwaitingDataClientStopped, CoreStates::TNoTagOrNoClients)

    //The node mustn't go out of scope with clients present. The node must get rid of them first.

	NODEACTIVITY_ENTRY(KNoTag, CoreActivities::CDestroyActivity::TMakeClientsLeaveOrProcessClientLeave, CoreStates::TAwaitingClientLeave, CoreActivities::CDestroyActivity::TNoTagOrNoTagBackwards)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, CoreActivities::CDestroyActivity::TProcessClientLeave, TTag<CoreNetStates::KNoClients>)

 	THROUGH_NODEACTIVITY_ENTRY(CoreNetStates::KNoClients, PRStates::TProcessDestroy, MeshMachine::TNoTag)

 	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing, MeshMachine::TAwaitingLeaveComplete, CoreActivities::CDestroyActivity::TNoTagOrNoTagBackwards)

 	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendClientLeavingAndRemoveControlProvider)

NODEACTIVITY_END()

}

namespace QoSIPSCprActivities

{

DECLARE_DEFINE_ACTIVITY_MAP(activityMap)

	ACTIVITY_MAP_ENTRY(QoSIPSCprJoinActivity, QoSIpSCprJoin)

	ACTIVITY_MAP_ENTRY(QoSIPSCprClientLeaveActivity, QoSIpSCprLeave)

	ACTIVITY_MAP_ENTRY(QoSIPSCprSetParameters, qosIpScprParamRequest)

    ACTIVITY_MAP_ENTRY(QoSIPSCprApplyRequest, SCprApplyReq)

    ACTIVITY_MAP_ENTRY(QoSIPSCprAddressUpdate, QoSIPSCprAddressUpdate)

    ACTIVITY_MAP_ENTRY(QoSIPSCprDestroy, QoSIPSCprDestroy)

    ACTIVITY_MAP_ENTRY(QoSIPSCprOpenInternalSocket, qosIpScprOpenInternalSocket)

ACTIVITY_MAP_END_BASE(IPDeftBaseSCprActivities, ipdeftbasescprActivityMap)

}

//-=========================================================

//

// CIpSubConnectionProvider methods

//

//-=========================================================

CIpSubConnectionProvider* CIpSubConnectionProvider::NewL(CIpDefaultSubConnectionProviderFactory& aFactory)

/**

Construct a new IP SubConnection Provider Object

@param aFactory factory that create this object

@param aConnProvider Connection Provider associated with this object

*/

	{

	__IPCPRLOG(IpCprLog::Printf(_L("CQoSIpSubConnectionProvider::NewL")));

	CIpSubConnectionProvider* self = new (ELeave) CIpSubConnectionProvider(aFactory);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

	return self;

	}

CIpSubConnectionProvider::~CIpSubConnectionProvider()

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CQoSIpSubConnectionProvider::~CQoSIpSubConnectionProvider [%08x]"), this));

    LOG_NODE_DESTROY(KIPSCprTag, CIpSubConnectionProvider);

	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;

		}

	if (iAsyncWriter)

		{

		iAsyncWriter->Cancel();

		delete iAsyncWriter;

		iAsyncWriter = NULL;

		}

	delete iPrtParameters;

	ResetPrtExtensions();

	iSocket.Close();

    }

CIpSubConnectionProvider::CIpSubConnectionProvider(ESock::CSubConnectionProviderFactoryBase& aFactory)

:CIpSubConnectionProviderBase(aFactory, QoSIPSCprActivities::activityMap::Self()),

 iSocketError(KErrNotReady),

 iWriter(NULL), iReader(NULL),

 iChannelId(-1),

 iPrtExtensions(_FOFF(CExtensionBase,iLink)),

 iParametersSet(EFalse), iAsyncWriter(NULL)

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CQoSIpSubConnectionProvider::CQoSIpSubConnectionProvider [%08x]"), this));

    LOG_NODE_CREATE(KIPSCprTag, CIpSubConnectionProvider);

    }

void CIpSubConnectionProvider::ConstructL()

/**

IP SubConnection Provider Second Phase Constructor

*/

	{

	__IPCPRLOG(IpCprLog::Printf(_L("CQoSIpSubConnectionProvider::Construct [%08x]"), this));

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::Construct [%08x]"), this));

    CIpSubConnectionProviderBase::ConstructL();

    iUid = RProcess().Type();

	/** 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));

	// kick off creation of internal socket

	TNodeCtxId originator(MeshMachine::KActivityNull, Id());

	Messages::RClientInterface::OpenPostMessageClose(originator, Id(), TQoSIpSCprMessages::TOpenInternalSocket().CRef());

	}

RInternalSocket& CIpSubConnectionProvider::InternalSocket()

	{

	return iSocket;

	}

void CIpSubConnectionProvider::InternalSocketOpened(TInt aErr)

	{

	iSocketError = aErr;

	if (iSocketError == KErrNone)

		{

		iReader = CQoSMsgReader::NewL(this,	 iSocket);

		iWriter = CQoSMsgWriter::NewL(this, iSocket);

		iAsyncWriter = CAsyncWriter::NewL(iWriter);

		}

	}

RNodeInterface* CIpSubConnectionProvider::NewClientInterfaceL(const TClientType& aClientType, TAny* /*aClientInfo*/)

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CQoSIpSubConnectionProvider::NewClientInterfaceL [%08x]"), this));

    if (aClientType.Type() & TCFClientType::EData)

        {

        return new (ELeave) RIPDataClientNodeInterface();

        }

    return CCoreSubConnectionProvider::NewClientInterfaceL(aClientType);

    }

void CIpSubConnectionProvider::Received(TNodeContextBase& aContext)

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CQoSIpSubConnectionProvider::ReceivedL [%08x]"), this));

    Messages::TNodeSignal::TMessageId noPeerIds[] = {

        TCFFactory::TPeerFoundOrCreated::Id(),

        TCFPeer::TJoinRequest::Id(),

        Messages::TNodeSignal::TMessageId()

        };

    MeshMachine::AMMNodeBase::Received(noPeerIds, aContext);

	MeshMachine::AMMNodeBase::PostReceived(aContext);

	}

void CIpSubConnectionProvider::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CQoSIpSubConnectionProvider::ReceivedL [%08x]"), this));

	ESOCK_DEBUG_MESSAGE_INTERCEPT(aSender, aMessage, aRecipient);

	if (aMessage.IsMessage<TCFDataClient::TProvisionConfig>())

    	{

        ASSERT(ServiceProvider() == NULL && ControlProvider() != NULL);

        TDefaultSCPRFactoryQuery deftScprQuery(ControlProvider()->RecipientId(), TSubConnOpen::EAttachToDefault);

        ESock::CSubConnectionProviderBase* deftSCPR = static_cast<ESock::CSubConnectionProviderBase*>

        		(static_cast<CSubConnectionProviderFactoryBase&>(Factory()).Find(deftScprQuery));

        ASSERT(deftSCPR && deftSCPR->ServiceProvider());

        RClientInterface::OpenPostMessageClose(Id(), Id(),

        	TCFDataClient::TBindTo(deftSCPR->ServiceProvider()->RecipientId()).CRef());

    	}

	QoSIpSCprStates::TContext ctx(*this, aMessage, aSender, aRecipient);

    CIpSubConnectionProvider::Received(ctx);

    User::LeaveIfError(ctx.iReturn);

	}

void CIpSubConnectionProvider::DataClientJoiningL(RIPDataClientNodeInterface& 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("CQoSIpSubConnectionProvider::DataClientJoiningL [%08x]"), this));

	if( aDataClient.iCliSrcAddr.Family() == KAFUnspec )

		{

		__IPCPRLOG(IpCprLog::Printf(_L("Source Address not defined")));

		User::Leave( KErrNotReady );

		}

	if( aDataClient.iCliDstAddr.Family() == KAFUnspec )

		{

		__IPCPRLOG(IpCprLog::Printf(_L("Destination Address not defined")));

		User::Leave( KErrNotReady );

		}

	if( iChannelId >= 0 )

		{

		SendJoinL(aDataClient.iCliSrcAddr, aDataClient.iCliDstAddr, iIapId, aDataClient.iProtocolId);

		}

	else

		{

		SendCreateL(aDataClient.iCliSrcAddr, aDataClient.iCliDstAddr, iIapId, aDataClient.iProtocolId);

		}

	}

void CIpSubConnectionProvider::DataClientLeaving(RIPDataClientNodeInterface& 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("CQoSIpSubConnectionProvider::DataClientLeaving [%08x]"), this));

	if( aDataClient.iCliSrcAddr.Family() == KAFUnspec )

		{

		__IPCPRLOG(IpCprLog::Printf(_L("Source Address not defined")));

		return;

		}

	if( aDataClient.iCliDstAddr.Family() == KAFUnspec )

		{

		__IPCPRLOG(IpCprLog::Printf(_L("Destination Address not defined")));

		return;

		}

	if( iChannelId >= 0 )

    	{

		TRAPD(ret, SendLeaveL(aDataClient.iCliSrcAddr, aDataClient.iCliDstAddr, iIapId, aDataClient.iProtocolId));

		if (ret != KErrNone)

			{

			__IPCPRLOG(IpCprLog::Printf(_L("SendLeaveL left with err=%d"), ret));

			}

		}

	else

		{

		ASSERT(EFalse);

		__IPCPRLOG(IpCprLog::Printf(_L("Attempted to leave on an unconnected channel")));

		}

	}

void CIpSubConnectionProvider::SetQoSParametersL()

	{

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::SetParameters [%08x]"), this));

	iParameterRelease = KParameterRelInvalid;

	ConvertParametersFromESockL( iParameterBundle );

	iParametersSet = ETrue;

  	if(iChannelId >= 0)

		{

		SendSetQoSL();

		}

	}

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")));

	if (iAsyncWriter == NULL)

		User::Leave(iSocketError);

	// coverity[SYMBIAN.CLEANUP_STACK] coverity [alloc_fn]

    // coverity[SYMBIAN.CLEANUP_STACK] coverity [assign]

    CQoSMsg* msg = CQoSMsg::NewL(EPfqosCreateChannel);

    msg->AddConnInfo(aProtocolId, iUid, aIapId);

    msg->AddSrcAddr(aSrcAddr);

    msg->AddDstAddr(aDstAddr);

    msg->AddChannel(0);

    TQoSParameters qosParams;

    // coverity[SYMBIAN.CLEANUP_STACK] coverity [leave_without_push]

    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")));

	if (iWriter == NULL)

		User::Leave(iSocketError);

    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")));

	if (iWriter == NULL)

		User::Leave(iSocketError);

    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")));

	if (iWriter == NULL)

		User::Leave(iSocketError);

    CQoSMsg* msg = CQoSMsg::NewL(EPfqosLeave);

    msg->AddConnInfo(aProtocolId, iUid, aIapId);

    msg->AddSrcAddr(aSrcAddr);

    msg->AddDstAddr(aDstAddr);

    msg->AddChannel(iChannelId);

    iWriter->Send(msg);