// 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()