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

// IP Shim Flow Base class.

// This class is derived from by the separate IP4 and IP6 shim flow classes.

// 

//

/**

 @file flow.cpp

*/

#include <e32std.h>

#include <e32test.h>

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <comms-infras/ss_metaconnprov.h>

#include <comms-infras/ss_subconnflow.h>

#include "flow.h"

#include "nif.h"

#include "panic.h"

#include "ItfInfoConfigExt.h"

#include "IPProtoMessages.h"	// TCFIPProtoMessage

#include "IPProtoCPR.h"

#include "idletimer.h"

#include <networking/ipaddrinfoparams.h>

#include "IPProtoDeMux.h"

#include <comms-infras/ss_log.h>

#include <es_prot_internal.h>

using namespace Messages;

using namespace MeshMachine;

using namespace ESock;

using namespace IpProtoCpr;

//

// CIPShimSubConnectionFlow

//

CIPShimSubConnectionFlow::CIPShimSubConnectionFlow(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf)

: CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf), iCleanupError(KErrUnknown),

  iAsyncBinderClose(*this)

	{

	LOG_NODE_CREATE(KIPProtoTag1, CIPShimSubConnectionFlow);

	}

CIPShimSubConnectionFlow::~CIPShimSubConnectionFlow()

	{

	ASSERT(iBinderList.Count() == 0);

    iConnectionInfo.Close();

	// iIntf doesn't need to be deleted explicitly, as it will be deleted

	// when the last Close() is issued on it (i.e. either by us or by the TCP/IP

	// stack).  At the time of writing, our call to Close() is the last one and

	// will delete it.

	LOG_NODE_DESTROY(KIPProtoTag1, CIPShimSubConnectionFlow);

	}

MFlowBinderControl* CIPShimSubConnectionFlow::DoGetBinderControlL()

	{

	return this;

	}

void CIPShimSubConnectionFlow::InitialiseDataMonitoringL(CIPShimIfBase* intf)

	{

	const TPacketActivity* packetActivity =

		static_cast<const TPacketActivity*>(AccessPointConfig().FindExtension(TPacketActivity::TypeId()));

	if (packetActivity)

		{

		intf->ShimNotify()->SetPacketActivityFlag(packetActivity->iPacketActivity);

		}

	else

		{

		__CFLOG_VAR((KIPProtoTag1, KIPProtoTag2, _L8("Packet activity provisioning information missing")));

    	User::Leave(KErrNotReady);

		}

	const TDataMonitoringConnProvisioningInfo* connProvisioningInfo =

		static_cast<const TDataMonitoringConnProvisioningInfo*>(AccessPointConfig().FindExtension(STypeId::CreateSTypeId(TDataMonitoringConnProvisioningInfo::iUid, TDataMonitoringConnProvisioningInfo::iId)));

	const TDataMonitoringSubConnProvisioningInfo* subConnProvisioningInfo =

		static_cast<const TDataMonitoringSubConnProvisioningInfo*>(AccessPointConfig().FindExtension(STypeId::CreateSTypeId(TDataMonitoringSubConnProvisioningInfo::iUid, TDataMonitoringSubConnProvisioningInfo::iId)));

    if(connProvisioningInfo && subConnProvisioningInfo)

    	{

		intf->ShimNotify()->SetDataVolumePtrs(connProvisioningInfo->iDataVolumesPtr, subConnProvisioningInfo->iDataVolumesPtr);

		intf->ShimNotify()->SetNotificationThresholdPtrs(connProvisioningInfo->iThresholdsPtr, subConnProvisioningInfo->iThresholdsPtr);

    	}

    else

    	{

		__CFLOG_VAR((KIPProtoTag1, KIPProtoTag2, _L8("Data monitoring provisioning information missing")));

    	User::Leave(KErrNotReady);

    	}

	}

// ============================================================================

//

// from Messages::ANode

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

/**

Receive function for incoming messages from SCPR.

@param aCFMessage message from SCPR

*/

    {

	CSubConnectionFlowBase::ReceivedL(aSender, aRecipient, aMessage);

	if(aMessage.IsMessage<TEBase::TCancel>())

		{

		if (iStarting )

			{

			StopFlow(KErrCancel);

			}

		}

	else if(aMessage.IsMessage<TEChild::TDestroy>())

		{

		Destroy();

		}

	else if(aMessage.IsMessage<TCFDataClient::TBindTo>())

		{

		TCFDataClient::TBindTo& msg = message_cast<TCFDataClient::TBindTo>(aMessage);

		BindToL(msg.iNodeId);

		ASSERT(iSubConnectionProvider == aSender);

		iSubConnectionProvider.PostMessage(Id(), TCFDataClient::TBindToComplete().CRef());

		}

	else if(aMessage.IsMessage<TCFDataClient::TStart>())

		{

		StartFlowL();

		}

	else if(aMessage.IsMessage<TCFDataClient::TStop>())

		{

		StopFlow(static_cast<TCFDataClient::TStop&>(aMessage).iValue);

		}

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

		{

		iAccessPointConfig.Close();		

		iAccessPointConfig.Open(static_cast<TCFDataClient::TProvisionConfig&>(aMessage).iConfig);

		ProcessProvisionConfigL();

		}

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	else if(aMessage.IsMessage<TCFScpr::TSetParamsRequest>())

		{

		UpdateIpAddressInfoL(static_cast<TCFScpr::TSetParamsRequest&>(aMessage));

		}

#else

	else if(aMessage.IsMessage<TCFScpr::TParamsRequest>())

		{

		UpdateIpAddressInfoL(static_cast<TCFScpr::TParamsRequest&>(aMessage));

		}

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	else

		{

		Panic(EUnexpectedSubConnectionMsg);

		}

    }

//

// Dispatch functions for messages from SCPR

//

__CFLOG_STMT

(

void LOG_ADDRESS(TSockAddr addr)

	{

	TBuf<KMaxSockAddrSize> buff;

	TInetAddr iaddr(addr);

	iaddr.Output(buff);

	__CFLOG_VAR((KIPProtoTag1, KIPProtoTag2, _L("CIPShimSubConnectionFlow::UpdateIpAddressInfoL %S %d"), &buff, addr.Port()));

	}

)

//helper function

CIPProtoBinder * FindBinderForProtocol(const TDesC8& proto, RPointerArray<CIPProtoBinder> &array)

	{

	TInt count= array.Count();

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

		{

		if (array[i]->ProtocolName().Compare(proto) == 0)

			{

			return array[i];

			}

		}

	return 0;

	}

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

void CIPShimSubConnectionFlow::UpdateIpAddressInfoL(TCFScpr::TSetParamsRequest& aParamReq)

#else

void CIPShimSubConnectionFlow::UpdateIpAddressInfoL(TCFScpr::TParamsRequest& aParamReq)

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	{

	//[401TODO] DL: deal with the granted also.

	const RCFParameterFamilyBundleC& newParamBundle = aParamReq.iFamilyBundle;

	CSubConIPAddressInfoParamSet* IPAddressInfoSet;

	RParameterFamily family = newParamBundle.FindFamily(KSubConIPAddressInfoFamily);

	if ( family.IsNull() )

		{

		 IPAddressInfoSet = NULL;

		}

    else

    	{

    	 IPAddressInfoSet = static_cast<CSubConIPAddressInfoParamSet*>

		 	(family.FindParameterSet(

		 			STypeId::CreateSTypeId(CSubConIPAddressInfoParamSet::EUid,

				 		CSubConIPAddressInfoParamSet::ETypeId)

						 ,RParameterFamily::ERequested));

		}

	if (IPAddressInfoSet)

        {

		TUint aParamSetNum = IPAddressInfoSet->GetParamNum();

		/** TODO: It should be only one in the queue, so remove the loop */

		for (TUint i=0; i<aParamSetNum; ++i)

			{

			CSubConIPAddressInfoParamSet::TSubConIPAddressInfo paramInfo(IPAddressInfoSet->GetParamInfoL(i));

			//The only protocol we are going to deal with is TCP/IP

			//as the flow association gets lost in when it goes through the current stack.

			if (paramInfo.iCliDstAddr.Family() == KAfInet6 ||

				paramInfo.iCliDstAddr.Family() == KAfInet)

				{

				__CFLOG_STMT(LOG_ADDRESS(paramInfo.iCliDstAddr);)

				__CFLOG_STMT(LOG_ADDRESS(paramInfo.iCliSrcAddr);)

				TInetAddr addr(paramInfo.iCliDstAddr);

				TUint32 ipv4Addr = addr.Address();

				if (iBinderList.Count())

					{

					CIPShimIfBase* nif = iBinderList[0]->iNif;

					ASSERT(nif);

					CIPProtoBinder *binder = 0;

					if(ipv4Addr)

						{

						//find ip4 binder

						binder = FindBinderForProtocol(KProtocolIp, iBinderList);

						}

					else

						{

						//find ip6 binder

						binder = FindBinderForProtocol(KProtocolIp6, iBinderList);

						}

					if (IPAddressInfoSet->GetOperationCode() == CSubConIPAddressInfoParamSet::EDelete)

						{

						nif->RemoveIpAddrInfo(binder, paramInfo);

						}

					else

						{

						nif->AddIpAddrInfoL(binder, paramInfo);

						}

					}

				}

			}

        }

	}

class TCleanupNifPair {

public:

	TCleanupNifPair(CIPShimIfBase* aNif) : iNif(aNif), iBinder(NULL) {}

	void Cleanup();

	static void CleanupReleaseNif(TAny* aThis);

	CIPShimIfBase* iNif;

	CIPProtoBinder* iBinder;

	};

void TCleanupNifPair::Cleanup()

	{

	ASSERT(iNif);

	if (iBinder)

		{

		iNif->UnbindFrom(iBinder);

		iBinder->UnbindFromLowerFlow();

		}

	iNif->Release(KErrAbort);

	}

void TCleanupNifPair::CleanupReleaseNif(TAny* aThis)

	{

	TCleanupNifPair* pair = static_cast<TCleanupNifPair*>(aThis);

	pair->Cleanup();

	}

void CIPShimSubConnectionFlow::BindToL(const Messages::TNodeId& aCommsBinder)

	{

	// Assumption that TCommsBinder object contains pointer to Flow

    if (aCommsBinder.IsNull())

     	{

     	User::Leave(KErrNotSupported);

     	}

	ANode& mcfNode = aCommsBinder.Node();

#if !defined(__GCCXML__)

	CSubConnectionFlowBase& flow = mcfnode_cast<CSubConnectionFlowBase>(mcfNode);

#else

	CSubConnectionFlowBase& flow = reinterpret_cast<CSubConnectionFlowBase&>(mcfNode);

#endif

	__CFLOG_VAR((KIPProtoTag1, KIPProtoTag2, _L8("CIPShimSubConnectionFlow %08x:\tBindToL(): flow 0x%08x, protocol list '%S'"),

 				this, &flow, &iProtocolList));

	MFlowBinderControl* binderControl = flow.GetBinderControlL();

	ASSERT(binderControl);

	// Loop through all the protocols in the list and create binders for them

	TPtrC8 protoList(iProtocolList);

	TPtrC8 proto;

	TInt pos = KErrNotFound;

	do

		{

		pos = protoList.LocateF(',');

		if (pos == KErrNotFound)

			{

			proto.Set(protoList);

			}

		else

			{

			proto.Set(protoList.Left(pos));

			protoList.Set(protoList.Mid(pos + 1));

			}

		if (proto.Length() > 0)

			{

			}

		}

	while (pos != KErrNotFound);

	NM_LOG((KIPProtoTag1, _L8("CIPShimSubConnectionFlow %08x:\tSynchronous call: From=%08x To=%08x Func=BindToL"), this, static_cast<Messages::ANode*>(this), &mcfNode));

	TInt binderCount = iBinderList.Count();

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

		{

		iBinderList[i]->StartL();

		}

	}

void CIPShimSubConnectionFlow::StartFlowL()

/**

Message from SCPR to start.

*/

	{

	ASSERT(!iStarting);

	iStarting = ETrue;

	PostDataClientStartedIfReady();

	}

void CIPShimSubConnectionFlow::StopFlow(TInt aError)

/**

Message from SCPR to stop.

The aError reason code is stored to be passed to the TCP/IP stack via IfUserInterfaceDown().

@param aError Reason code.

*/

	{

	ASSERT(aError != KErrNone);

	iStopCode = aError;

	for(TInt i =0; i < iBinderList.Count(); i++)

		{

		MarkBinderForClosure(iBinderList[i]);

		}

	CloseMarkedBinders();

	PostDataClientStoppedIfReady();

	}

void CIPShimSubConnectionFlow::ProcessProvisionConfigL()

/**

Message from SCPR providing configuration information.

*/

	{

    const TItfInfoConfigExt* ext = static_cast<const TItfInfoConfigExt*>(AccessPointConfig().FindExtension(

    		STypeId::CreateSTypeId(KIpProtoConfigExtUid, EItfInfoConfigExt)));

    if (ext)

        {

        TInt err = SetConnectionInfo(ext->iConnectionInfo);

		if (err == KErrNone)

			{

			err = SetProtocolList(ext->iProtocolList);

			}

        if (err != KErrNone)

            {

    	    User::Leave(err);

            }

	    }

	}

TInt CIPShimSubConnectionFlow::SetProtocolList(const TDesC8& aProtocolList)

/**

Save a pointer to the protocol list string in the provisioning information

*/

	{

	if (aProtocolList.Length() > 0)

		{

		iProtocolList.Set(aProtocolList);

		return KErrNone;

		}

	else

		{

		return KErrArgument;

		}

	}

void CIPShimSubConnectionFlow::Destroy()

/**

Message from SCPR to self destruct.

*/

	{

	// No-one should be bound to us from above if we are about to disappear.

	ASSERT(iBindCallCount == 0);

	MarkAllBindersForClosure();

	if (iAsyncBinderClose.IsActive())

		{

		// Can't destroy ourselves whilst an asynchronous binder close is pending.

		// Arrange for it to close all binders and initiate the destroy.

		//

		// Note that the async binder close may have been originally invoked with

		// just a single binder marked for closure, and we are now marking them all

		// for closure and requesting a destroy.  This is the main reason for using

		// the "marked for closure" flag - to deal with events that require further

		// binders to be closed whilst the async binder close is still pending.

		iDestroyPending = ETrue;

		}

	else

		{

		// No async binder close pending - close binders and destroy ourselves here.

		CloseMarkedBinders();

		DeleteThisFlow();

		}

	}

//

// Utility functions for sending messages to SCPR

//

void CIPShimSubConnectionFlow::PostDataClientStartedIfReady()

	{

	if (iBinderReady && iStarting)

    	{

    	iSubConnectionProvider.PostMessage(Id(), TCFDataClient::TStarted().CRef());

    	iStarting = EFalse;

    	iStarted = ETrue;

    	}

	}

void CIPShimSubConnectionFlow::PostDataClientStoppedIfReady()

	{

	if (iStopCode != KErrNone)

    	{

    	iSubConnectionProvider.PostMessage(Id(), TCFDataClient::TStopped(iStopCode).CRef());

    	iStopCode = KErrNone;

    	iStarted = EFalse;