// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <udp_hdr.h>

#include <tcp_hdr.h>

#include <icmp6_hdr.h>

#include <ip4_hdr.h>

#include <ip6_hdr.h>

#include "qos_prot.h"

#include "flowhook.h"

#include "negotiation.h"

#include "qoserr.h"

#include "interface.h"

#include "modules.h"

#include "policy_mgr.h"

#include "qos_channel.h"

#include <es_prot_internal.h>

CFlowHook::CFlowHook(CProtocolQoS& aProtocol, CFlowContext& aContext) : iProtocol(aProtocol), iContext(aContext)

	{

	LOG(Log::Printf(_L("new\tqos HOOK[%u] on FLOW[%u] size=%d"), (TInt)this, (TInt)&aContext, sizeof(CFlowHook)));

	iProtocol.Open();	// The CProtocolQoS cannot be deleted until all flows have been closed!

	iInterface = NULL;

	iRefCount = 0;

	iSession = NULL;

	iFlowStatus = EFlow_READY;

	iChannel = NULL;

	TSoOwnerInfo owner_info;

	TPckg<TSoOwnerInfo> option(owner_info);

	TInt ret = iContext.RetrieveOption(KSOLProvider, KSoOwnerInfo, option);

	if (ret == KErrNone)

		{

		iUid = owner_info.iUid;

		LOG(Log::Printf(_L("\tqos HOOK[%u] Ownerinfo UID [0x%x 0x%x 0x%x]"),

			(TInt)this,

			owner_info.iUid[0].iUid,

			owner_info.iUid[1].iUid,

			owner_info.iUid[2].iUid ));

		}

	// Turn off HeaderMode flag

	// (so that we don't think QoS has changed in ReadyL, if nothing has been specified)

	iQoS.SetHeaderMode(EFalse);

	}

CFlowHook::~CFlowHook()

	{

	iProtocol.Close();	// May trigger final destruction of CProtocolQoS!

	LOG(Log::Printf(_L("~\tqos HOOK[%u] on FLOW[%u] destructor completed"), (TInt)this, (TInt)&iContext));

	}

void CFlowHook::Open()

	{

	iRefCount++;

	}

void CFlowHook::Close()

	{

	if (--iRefCount < 0)

		{

		LOG(Log::Printf(_L("Close\tqos HOOK[%u] on FLOW[%u] closed with refs=0 -- start shutdown"), (TInt)this, (TInt)&iContext));

		CloseQoS();

		iHookLink.Deque();

		delete this;

		}

	}

void CFlowHook::FillFlowInfo(TPfqosMessage& aMsg, pfqos_address& aSrc, pfqos_address& aDst, pfqos_selector& aSel, TInetAddr& aMsk)

	/**

	* Fill in flow specific information for PF_QOS Message.

	*

	* Initialize three extesion (EPfqosExtSrcAddress, EPfqosExtDstAddress and EPfqosExtSelector) into

	* TPfqosMessage. The caller must provide the space for the required extension blocks. This only

	* initializes the blocks and sets the iExt references to the aMsg.

 	*

	*

	* @param aMsg The PF_QOS Message to be used

	* @param aSrc The source address block for the Msg

	* @param aDst The destination address block for the Msg

	* @param aSel The selector block for the Msg.

	* @param aMsk Intialized to IPv6 all-ones mask.

	*/

	{

	// The old QOSLIB expects flow specific events have PF_QOS Message blocks

	// src, dst and sel filled from the policy selector that the flow is using.

	// This is very dubious, but at this point fixing the old QOSLIB is not

	// sensible. Because FLOW SPECIFIC OQS can only be requested through the

	// QOSLIB, implement a special backward compatibility for this, if

	// "selector" is located.

	const CSelectorBase* selector = NULL;

	if (iChannel == NULL)

		if ((selector = Policies().iPolicy) == NULL)

			selector = Policies().iDefault;

	aMsk.PrefixMask(128);	// All ones IPv6 address.

	aDst.pfqos_address_len = ((sizeof(pfqos_address) + sizeof(TInetAddr) + sizeof(TInetAddr) + 7) / 8);

	aDst.pfqos_ext_type = EPfqosExtDstAddress;

	aDst.reserved = 0;

	if (selector)

		{

		// For QOSLIB Only

		aDst.pfqos_port_max = selector->iDstPortMax;

		aMsg.iDstAddr.iAddr = &selector->iDst;

		aMsg.iDstAddr.iPrefix = &selector->iDstMask;

		}

	else

		{

		aDst.pfqos_port_max = Context().RemotePort();

		aMsg.iDstAddr.iAddr = &Context().RemoteAddr();

		aMsg.iDstAddr.iPrefix = &aMsk;

		}

	aMsg.iDstAddr.iExt = &aDst;

	aSrc.pfqos_address_len = ((sizeof(pfqos_address) + sizeof(TInetAddr) + sizeof(TInetAddr) + 7) / 8);

	aSrc.pfqos_ext_type = EPfqosExtSrcAddress;

	aSrc.reserved = 0;

	if (selector)

		{

		// For QOSLIB Only

		aSrc.pfqos_port_max = selector->iSrcPortMax;;

		aMsg.iSrcAddr.iAddr = &selector->iSrc;

		aMsg.iSrcAddr.iPrefix = &selector->iSrcMask;

		}

	else

		{

		aSrc.pfqos_port_max = Context().LocalPort();

		aMsg.iSrcAddr.iAddr = &Context().LocalAddr();

		aMsg.iSrcAddr.iPrefix = &aMsk;

		}

	aMsg.iSrcAddr.iExt = &aSrc;

	if (selector)

		{

		// For QOSLIB Only

		// Brutally run the new constructor for T_pfqos_selector on aSel.

		// (Need to typecast "const" away from selector -- T_pfqos_selector() is misdeclared, argument should be const!)		

		new (&aSel) T_pfqos_selector((CSelectorBase *)selector);

		}

	else

		{

		aSel.pfqos_selector_len = ((sizeof(pfqos_selector) + 7) / 8);

		aSel.pfqos_ext_type = EPfqosExtSelector;

		aSel.protocol = (TUint16)Context().Protocol();

		aSel.uid1 = Uid().UidType()[0].iUid;

		aSel.uid2 = Uid().UidType()[1].iUid;

		aSel.uid3 = Uid().UidType()[2].iUid;

			aSel.iap_id = Interface() ? Interface()->IapId() : 0;

		aSel.policy_type = EPfqosFlowspecPolicy;

		aSel.priority = EPfqosApplicationPriority;

		aSel.reserved = 0;

		aSel.name[0] = 0;

		}

	aMsg.iSelector.iExt = &aSel;

	}

//

// ReadyL() is called when a flow comes to EFlow_READY-state. 

//

TInt CFlowHook::ReadyL(TPacketHead &/*aHead*/)

	{

	// If there is a session going on, the flow is not ready to go!

	LOG(Log::Printf(_L("")));

	if (iSession)

		{

		LOG(Log::Printf(_L("ReadyL\tqos HOOK[%u] on FLOW[%u] pending on session[%u]"), (TInt)this, (TInt)&iContext, (TInt)iSession));

		return EFlow_PENDING;

		}

	LOG(Log::Printf(_L("ReadyL\tqos HOOK[%u] on FLOW[%u]"), (TInt)this, (TInt)&iContext));

	CNifIfBase *const nif = iContext.Interface();

	if (iInterface && nif != iInterface->Nif())

		{

		// ReadyL can be called multiple times. If the interface has

		// changed, everything must be started from the beginning...

		CloseQoS();

		}

	// Set interface and start QoS negotiation

	// When ReadyL is called, then if iContext.Interface() is normally a non-NULL

	// pointer to the attached NIF (CNifIfBase). However, the stack architecture allows

	// also that the final connect could be virtual interface without any NIF. Because such

	// connect requires a special hook to handle the packets, there are no known uses

	// of such at this point. However, the QoS code is not prepared to handle NULL NIF

	// properly and should not do anything with such flows.

	if (nif == NULL)

		{

		ASSERT(iInterface == NULL); // Logically interface cannot be non-NULL here!

		// ...just return READY and assume rest of the QoS does not panic

		// on iInterface being NULL. [Note: currently there are no known

		// configurations in use, which would lead into this branch]

		return EFlow_READY;

		}

	if (iInterface == NULL)

		{

		//?? Combine FindInterface and AddInterfaceL into single LocateInterfaceL?

		iInterface = iProtocol.InterfaceMgr()->FindInterface(nif);

		if (!iInterface)

			{

			iInterface = iProtocol.InterfaceMgr()->AddInterfaceL(nif);

			}

		ASSERT(iInterface);			// ...at this point, the interface must be present.

		// Find policies and load modules

		// Attach channel if flow belongs to such.

		iChannel = iProtocol.ChannelMgr()->AttachChannel(this);

		// Load modules specified in QoS policy

		LoadModulesL();

		// Open flow in modules (interface must be set before this!!)

		OpenModulesL();

		UpdateQoS();		// does nothing if iChannel!

		}

	if (iChannel)

		{

		// Notify Channel

		TInt ret = iChannel->HookReadyL(*this);

		if (ret != 0)

			{

			LOG(Log::Printf(_L("\tqos HOOK[%u] on FLOW[%u] ReadyL returns=%d (channel)"), (TInt)this, (TInt)&iContext, ret));

			return ret;	// Flow not ready or has some fatal error...

			}

		}

	else if (iQoSChanged)

		{

		// Pending QoS change, try to start negotiation (ignore errors)

		(void)Negotiate();

		}

#ifdef _LOG

	if (iSession)

		Log::Printf(_L("\tqos HOOK[%u] on FLOW[%u] ReadyL Returns=1 pending session [%u]"),

			(TInt)this, (TInt)&iContext, (TInt)iSession);

	else

		Log::Printf(_L("\tqos HOOK[%u] on FLOW[%u] ReadyL Returns iFlowStatus=%d"),

			(TInt)this, (TInt)&iContext, iFlowStatus);

#endif

	return iSession ? EFlow_PENDING : iFlowStatus;

	}

TInt CFlowHook::ApplyL(RMBufSendPacket &aPacket, RMBufSendInfo &aInfo)

	{

	LOG(Log::Printf(_L("")));

	LOG(Log::Printf(_L("ApplyL\tqos HOOK[%u] on FLOW[%u]"), (TInt)this, (TInt)&iContext));

	const TInt N = iModuleList.Count();

	//?? Note: ApplyL of the TrafficControl module has not been called before,

	//?? so keep that semantics unchanged. But, is it actually correct by spec?

	//?? (if present, control module is at index 0)

	for (TInt i = iHasControlModule ? 1 : 0; i < N; ++i)

		{

		iModuleList[i]->Module()->ApplyL(aPacket, aInfo);

		}

	return KErrNone;

	}

TInt CFlowHook::Negotiate()

	{

	if (!Interface() || iChannel || iQoSChanged == 0)

		{

		return KErrGeneral;

		}

	// Check if any modules are associated to a policy

	// Send reply msg indicating that no modules are associated to a QoS 

	// policy

	if (iModuleList.Count() == 0)

		{

		iProtocol.Event(KPfqosEventFailure, *this, iQoS, EQoSNoModules);

		return KErrNone;

		}

	// only one QoS negotiation can be active at once

	if (iSession == NULL)

		{

		iQoSChanged = 0;

		return StartPendingRequest(new CNegotiateSession(*this));

		}

	// Busy negotiating something else, start this later...

	return KErrNone;

	}

void CFlowHook::LoadModulesL()

	/**

	* Load modules specified in a QoS policy.

	*/

	{

	ASSERT(iModuleList.Count() == 0);	// The list must be empty before this!

	ASSERT(!iHasControlModule);			// The list is empty, there cannot be control module either!

	RModule* rmodule=NULL;

	if (iInterface->TrafficControl())

		{

		// Interface already has a control module. Make a copy reference

		// to the same module and add to the slot 0 in the module list.

		rmodule = new (ELeave) RModule(*iInterface->TrafficControl());

		if (iModuleList.Append(rmodule) != KErrNone)

			{

			delete rmodule;

			User::Leave(KErrNoMemory);

			}

		iHasControlModule = TRUE;

		}

	Policies().iModules = (CModuleSelector*)iProtocol.PolicyMgr()->FindPolicy(&Context(),

			EPfqosModulespecPolicy, Uid().UidType(), 

			Interface()->IapId(), EPfqosApplicationPriority, Interface()->InterfaceName());

	CModuleSelector*const sel = Policies().iModules;

	if (!sel)

		{

		// No other modules.

		return;

		}

	TDblQueIter<CModuleSpec> iter(sel->GetModuleList());

	CModuleSpec *module;

	while ((module = iter++) != NULL)

		{

		TRAPD(err, rmodule = iProtocol.ModuleMgr()->LoadModuleL(*module, iProtocol.NetworkService()->Protocol()));

		if (err == KErrNone)

			{

			if (rmodule->Flags() & KQoSModuleBindToInterface)

				{

				// If module has to be binded to an interface, the CNifIfBase

				// Name must match with the name specified in modulespec 

				// selector.

				if (iHasControlModule || sel->iName.Compare(iInterface->InterfaceName()) != 0)

					{

					//coverity[leave_without_push]

					delete rmodule;

					}

				else

					{

					iInterface->SetTrafficControl(rmodule);

					LOG(Log::Printf(_L("\t\tCalling module[%S]::InterfaceAttached(IF [%S])"),

						&rmodule->Name(), &iInterface->Name()));

					rmodule->Module()->InterfaceAttached(iInterface->Name(), iInterface->Nif());

					// Make a copy of the control module reference and place it at index 0.

					rmodule = new (ELeave) RModule(*rmodule);

					if (iModuleList.Insert(rmodule, 0) != KErrNone)

						{

						delete rmodule;

						User::Leave(KErrNoMemory);

						}

					iHasControlModule = TRUE;

					}

				}

			else

				{

				if (iModuleList.Append(rmodule) != KErrNone)

					{

					delete rmodule;

					}

				}

			}

		}

	}

void CFlowHook::OpenModulesL()

	{

	ASSERT(Interface() != NULL);

	const TInt N = iModuleList.Count();

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

		{

		RModule* const module = iModuleList[i];

		LOG(Log::Printf(_L("")));

		LOG(Log::Printf(_L("calling\tmodule[%S]::OpenL(FLOW[%u]) for HOOK[%u] on IF [%S])"),

			&module->Name(), (TInt)&iContext, (TInt)this, &iInterface->Name()));

		module->Module()->OpenL(iContext, Interface()->Nif());

		LOG(Log::Printf(_L("<<<\treturns from module[%S] for HOOK[%u]"), &module->Name(), (TInt)this));

		}

	//?? If this leaves half way, someone should close the modules

	//?? that were succesfully opened...? [the flow close will do this,

	//?? but to all modules in the list]

	}

void CFlowHook::CloseQoS()

	/**

	* Close the QoS setup for a flow.

	*

	* Cancel QoS done by the ReadyL. Flow has no QoS resources

	* attached after this.

	*/	

	{

	// Note: iSession is self destructive object, which automaticly destructs

	// after the ClearPendingRequest call. If it has not done that yet, force

	// the destruction here (the session destructor must deal with any pending

	// uncompleted actions in some way!) and not call ClearPendingRequest

	// any more.

	delete iSession;

	iSession = NULL;

	for (TInt i = iModuleList.Count(); --i >= 0; )

		{

		RModule* const module = iModuleList[i];

		LOG(Log::Printf(_L("")));

		LOG(Log::Printf(_L("calling\tmodule[%S]::Close(FLOW[%u]) for HOOK[%u]"), &module->Name(), (TInt)&iContext, (TInt)this));

		module->Module()->Close(Context());

		LOG(Log::Printf(_L("<<<\treturns from module[%S] for HOOK[%u]"), &module->Name(), (TInt)this));

		delete module; 

		}

	iModuleList.Reset();

	iHasControlModule = FALSE;

	// Close channel after Close() to QoS modules

	if (iChannel)

		{

		iChannel->Detach(*this);

		iChannel = NULL;

		}

	iInterface = NULL;

	}

void CFlowHook::RestartQoS()

	/**

	* Restart the QoS for the flow.

	*

	* This function closes the current QoS framework assigned to the

	* flow and requests a rerun of the ReadyL phase.

	*

	* This should be called when the flow is moved between channel

	* and other QoS modes...

	*/

	{

	LOG(Log::Printf(_L("\tqos HOOK[%u] on FLOW[%u] RestartQoS"), (TInt)this, (TInt)&iContext));

	CloseQoS();

	// Force immeadiate call to ReadyL by poking the flow status.

	iContext.SetStatus(EFlow_PENDING);

	LOG(Log::Printf(_L(">>>\tCalling FLOW[%u]::SetStatus(0)"), (TInt)&iContext));

	iFlowStatus = EFlow_READY;

	iContext.SetStatus(EFlow_READY);

	LOG(Log::Printf(_L("<<<\tReturns FLOW[%u]::SetStatus(0)"), (TInt)&iContext));

	//?? The above is somewhat inconvenient, as the SetStatus(EFlow_READY) can

	//?? directly call ReadyL again. Should be careful to avoid infinite

	//?? recursive loops -- it would be better to have a way to trigger

	//?? this in delayed way: either implement a callback here, or hook API

	//?? should have some feature to trigger it.

	}

void CFlowHook::ReleasePolicy(const CPolicySelector* aSel)

	/**

	* The selector has been deleted, remove references

	*/

	{

	ASSERT(aSel);	// should not be called with NULL ...

	if (aSel == NULL)

		return;		// ...but, if it happens, do nothing!

	TInt was_used = 0;

	if (Policies().iPolicy == aSel)

		{

		Policies().iPolicy = NULL;

		was_used = 1;

		}

	if (Policies().iDefault == aSel)

		{

		Policies().iDefault = NULL;

		was_used = 1;

		}

	if (Policies().iOverride == aSel)

		{

		Policies().iOverride = NULL;

		was_used = 1;

		}

	if (was_used)

		UpdateQoS();

	}

void CFlowHook::UpdateQoS()

	{

	// update QoS policy if flow does not belong to a QoS channel

	if (iChannel)

		return;

	Policies().iDefault = (CPolicySelector*)iProtocol.PolicyMgr()->FindPolicy(&Context(),

		EPfqosFlowspecPolicy, Uid().UidType(), 

		Interface()->IapId(), EPfqosDefaultPriority);

	Policies().iPolicy = (CPolicySelector*)iProtocol.PolicyMgr()->FindPolicy(&Context(), 

		EPfqosFlowspecPolicy, Uid().UidType(), 

		Interface()->IapId(), EPfqosApplicationPriority);

	//

	// Combine default and application policies

	//

	TQoSParameters spec;

    //lint -e{961} Missing 'else' is OK

	if (Policies().iDefault && Policies().iPolicy)

		{

		spec = Policies().iPolicy->QoSParameters();

		TPolicyCombine::CombineDefault(Policies().iDefault->QoSParameters(), spec);

		}

	else if (Policies().iDefault)

		{

		spec = Policies().iDefault->QoSParameters();

		}

	else if (Policies().iPolicy)

		{

		spec = Policies().iPolicy->QoSParameters();

		}

	Policies().iOverride = (CPolicySelector*)iProtocol.PolicyMgr()->FindPolicy(&Context(),