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

// flow.cpp - IPv6/IPv4 flow information

//

#include <es_mbuf.h>

#include "flow.h"

//

//	COptionValue

//	************

//	(Only used internally in flow.cpp, DO NOT EXPORT! It has somewhat

//	"delicate" constructor requiring the extra allocation been done,

//	not checked... -- sma

//

class COptionValue : public CBase

	{

public:

	COptionValue(TInt aLevel, TInt aName, const TDesC8 &aOption) : iLevel(aLevel), iName(aName), iLength(aOption.Length())

		{

		TPtr8((TUint8 *)this + sizeof(COptionValue), iLength).Copy(aOption);

		}

	inline TPtrC8 Value() { return TPtr8((TUint8 *)this + sizeof(COptionValue), iLength, iLength); }

	COptionValue *iNext;		// Next value or NULL

	const TUint iLevel;			// Option level

	const TUint iName;			// Option name

	const TInt iLength;			// Option value length

	//

	// This is followed by the actual octets of the

	// option value. COptionValue class *CANNOT* be

	// subclassed!!!!

	};

// ************

// RFlowContext

// ************

EXPORT_C TInt RFlowContext::Open(MFlowManager *aManager, TUint aProtocol)

	/**

	* Creates a new empty and unconnected flow context and initialises the handle 

	* to point this context.

	*

	* The handle, which is used to create the flow context

	* through this method, will become the owner of the flow context.

	*

	* @param aManager

	*		Flow manager

	* @param aProtocol

	*		The upper layer protocol associated with the flow.

	*		This is also the value for the IP NextHeader/Protocol field, unless

	*		a hook adds some extension headers. This can also be set later using

	*		RFlowContext::SetProtocol method.

	* @return

	*		KErrNone, if the context was successfully created and attached to the handle.

	*/

	{

	iFlow = 0;

	TRAPD(err, iFlow = aManager->NewFlowL(this, aProtocol));

	return err;

	}

EXPORT_C TInt RFlowContext::ReOpen()

	/**

	* Allocates a new flow context to the handle using the parameters from

	* the existing flow context.

	*

	* If the handle is the only reference to the current context, the context is 

	* deleted after the new context has been created.

	*

	* This function is not for general use.

	*

	* @return

	*		KErrNone on success.

	*/

	{

	CFlowContext *old = iFlow;

	if (old)

		{

		iFlow = NULL;

		TRAPD(err, iFlow = old->iMgr->NewFlowL(this, *old));

		old->Close();

		return err;

		}

	else

		return KErrBadHandle;

	}

EXPORT_C TInt RFlowContext::Clone(const RFlowContext &aFlow)

	/**

	* Creates a new flow with the flow parameters copied from another flow.

	*

	* @param aFlow

	*		a flow to be duplicated

	*

	* @return

	*		System wide error codes

	*/

	{

	//

	// This sequence of actions below tries to do the cloning in

	// such a way, that it is safe even if the this == aFlow (in which

	// case this is same as plain "ReOpen()").

	//

	CFlowContext *old = iFlow;

	iFlow = aFlow.iFlow;

	iFlow->Open();

	TInt ret = ReOpen();

	if (old)

		old->Close();

	return ret;

	}

EXPORT_C TInt RFlowContext::Connect()

	/**

	* Forces a (re)connect on the flow.

	*

	* Connect activates the connection phase of the flow context.

	* Any previous connection is disconnected from the flow.

	*

	* @return

	*		the status of the flow. Any non-zero positive

	*		value indicates "pending" state: a connection

	*		is being setup but not yet ready (for example,

	*		a netdial process may have been activated, but

	*		it is still waiting for the user input).

	*/

	{

	if (iFlow)

		{

		iFlow->Connect();

		return iFlow->iStatus;

		}

	else

		return KErrBadHandle;

	}

EXPORT_C TInt RFlowContext::Open(MFlowManager *aManager, const TSockAddr &aDst,	const TSockAddr &aSrc, TUint aProtocol, TUint aIcmpType, TUint aIcmpCode)

	/**

	* Just a convenience function, which combines Open, SetRemoteAddr, SetLocalAddr, SetIcmpInfo and Connect.

	*

	* @param aManager	Flow Manager

	* @param aDst		Flow's destination address (and port)

	* @param aSrc		Flow's source address (and port)

	* @param aProtocol	The upper layer protocol associated with the flow

	*					(and the value for the IP  NextHeader/Protocol field,

	*					unless some hook adds extension headers)

	* @param aIcmpType	ICMP type (only sensible when protocol is ICMP)

	* @param aIcmpCode	ICMP code (only sensible when protocol is ICMP)

	*

	* @return

	*		current value of CFlowContext::iStatus.

	*/

	{

	TInt ret = Open(aManager, aProtocol);

	if (ret != KErrNone)

		return ret;

	else if (iFlow)

		{

		SetRemoteAddr(aDst);

		SetLocalAddr(aSrc);

		SetIcmpType(aIcmpType, aIcmpCode);

		iFlow->Connect();

		return iFlow->iStatus;

		}

	else

		return KErrBadHandle;

	}

EXPORT_C TInt RFlowContext::Open(RFlowContext &aFlow, RMBufPktInfo *aInfo)

	/**

	* Attaches the flow to a specified packet.

	*

	* This function is used only to attach a copy reference to the flow to an outgoing 

	* packet (RMBufSendInfo::iFlow).

	* This method is very specific and currently used only for attaching a copy reference

	* of the flow to an outgoing packet (iFlow member of the RMBufPacketInfo).

	*

	* The function checks aContext and if there have been no changes to the flow

	* parameters (as recorded by CFlowContext::iChanged) since the last connection,

	* the flow is assumed to be validly connected. Note that this means that if

	* the referenced flow is in an error state and if no flow parameters have been 

	* changed, this attach/open also fails. No reconnect attempt is made in that 

	* case.

	*

	* If the flow parameters have been changed since the last connect, the flow 

	* is reconnected. If there are additional references to the flow context, an 

	* implicit re-open (RFlowContext::ReOpen) is executed for the handle and the

	* flow parameters are copied  from the old flow context.

	* After this, the new flow is connected. Note that 

	* if a new cloned context is created, and if the context had a provider notify 

	* pointer (see RFlowContext::SetNotify()) set through this handle, the pointer

	* is automatically transferred to the new flow context, and removed from the old context. 

	*

	* If, after above processing, the referenced flow is ready to receive outgoing packets,

	* the flow context associated with the referenced handle is attached to the current handle.

	*

	* This design allows simple processing for the upper layers, as they don't need to worry

	* if the old flow is used by some packet still on the way out. Additionally, delaying the

	* "cloning" until actual attach/connect, may avoid unnecessary copying.

	*

	* The opened handle is not the owner of the flow context. This will only create an additional

	* reference to an existing flow context owned by someone else (usually aFlow).

	*

	* @param aFlow

	*		the "source flow" to be attached to the current handle

	* @retval aInfo

	*		An optional information block.

	*		If specified, then on a successful attach, the info members iProtocol,

	*		iSrcAddr and iDstAddr are initialized from the respective selector

	*		fields of the flow.

	* @return

	*		The return value of the Open is in general same as what would be returned

	*		by the Status call. However, when attach causes the actual connection of the flow,

	*		there exists error return codes which do not happen with Status call.

	*/

	{

	// FFS: It should be considered that this method is replaced with something like

	// Attach(aFlow) function in the RMBufSendInfo itself. That would be much cleaner

	// solution.

	iFlow = NULL;

	CFlowContext *flow = aFlow.iFlow;

	if (!flow)

		return KErrBadHandle;

	if (flow->iChanged)

		{

		//

		// The flow parameters have been changed

		//

		if (flow->iRefs > 0)

			{

			//

			// Need to allocate a new flow

			TInt err = aFlow.ReOpen();

			if (err != KErrNone)

				return err;

			flow = aFlow.iFlow;

			}

		// Assume: ConnectFlow will clean out all previous connection state! -- msa

		flow->Connect();

		}

	//

	// ...should this Refresh be done here or not? -- msa

	//

	if (flow->iStatus > EFlow_READY)

		flow->RefreshFlow();

	if (flow->iStatus == EFlow_READY)

		{

		//

		// Attach the flow to this handle

		//

		flow->Open();

		iFlow = flow;

		}

	//

	// Return current address information

	// (even though it in some cases might be random)

	//

	if (aInfo)

		{

		aInfo->iDstAddr = flow->RemoteAddr();

		aInfo->iSrcAddr = flow->LocalAddr();

		aInfo->iProtocol = flow->Protocol();

		}

	return flow->iStatus;

	}

// Help function for address loading, returns

//  = 0, if address did not change

//  = 1, if address has changed

//

static TInt ChangedAddress(TInetAddr &aAddr, const TInetAddr &aNewAddr)

	{

	// "Normalize" new address

	// - convert IPv4 addresess into IPv4 mapped

	// - anything other then KAfInet6 will be set as None

	TInetAddr tmp(aNewAddr);

	if (tmp.Family() == KAfInet)

		{

		tmp.ConvertToV4Mapped();

		tmp.SetScope(0);	// [is already part of "convert" in newer insocks]

		}

	else if (tmp.Family() != KAfInet6)

		tmp.SetAddress(KInet6AddrNone);

	if (tmp.CmpAddr(aAddr) &&				// address and port same?

		tmp.FlowLabel() == aAddr.FlowLabel())

		{

		// If the scope id in new addres is zero, then the

		// scope id is not part the address compare.

		// (this will optimize unconnected sockets where application

		// gives destination without scope -- eliminates unnecessary

		// flow connect operations.

		if (tmp.Scope() == aAddr.Scope() || tmp.Scope() == 0)

			return 0;	// No Change to the previous value

		}

	// Address is being changed

	aAddr = tmp;

	return 1;

	}

/**

* @defgroup	setselectors	Flow selector fields

*

* The selector information currently includes the following:

* @li	local address and port

* @li	remote addresses and port

* @li	IP protocol number

* @li	ICMP (or some other protocol) type and code.

*

* When a method is used to set any of the selector fields, the new and current value are

* compared, and if there is a change, the CFlowContext::iChanged is set.

*

* Although the code does not verify it, changing any of the selector fields should

* be done only by the owner of the flow context.

*

* If the handle is not attached to a flow, all methods will just silently return

* without doing anything.

*

* @{

*/

EXPORT_C void RFlowContext::SetRemoteAddr(const TSockAddr &aAddr)

	/**

	* Sets the flow's remote address and port.

	*

	* @param aAddr

	*	An address and port of the selector.

	*	If an address is given in IPv4 format (KAfInet), it will be automaticly

	*	converted into IPv4 mapped format (KAfInet6) in the flow context.

	*	Note that the flow  itself does not record whether an IPv4 address was specified. 

	*/

	{

	if (iFlow && ChangedAddress(iFlow->iInfo.iRemote, TInetAddr::Cast(aAddr)))

		{

		if (!iFlow->IsLocalSet())

			//

			// If the local address is unspecified by the application,

			// changing the remote address must also reset the local address

			// back to the unspecified state, so that the system will reselect

			// a new local address which will match the new remote address!

			//

			// Due to IPSEC, even changing port may cause destination

			// change, if policy specifies tunneling for certain ports

			// [this None setting may be unnecessary, need to check -- msa]

			iFlow->iInfo.iLocal.SetAddress(KInet6AddrNone);

		iFlow->iChanged = 1;

		}

	}

EXPORT_C void RFlowContext::SetLocalAddr(const TSockAddr &aAddr)

	/**

	* Sets the flow's local address and port

	*

	* @param aAddr

	*	An address and port of the selector.

	*

	*	If an address is given in IPv4 format (KAfInet), it will be converted

	*	into IPv4 mapped format (KAfInet6) in the flow context. If address

	*	is unspecified, the CFlowContext::iLocalSet is cleared, and set otherwise.

	*	See also CFlowContext::IsLocalSet().

	*

	*	Note that the flow  itself does not record whether an IPv4 address

	*	was originally specified in KAfInet or KAfInet6 format.

	*/

	{

	if (iFlow && ChangedAddress(iFlow->iInfo.iLocal, TInetAddr::Cast(aAddr)))

		{

		iFlow->iInfo.iLocalSet = !(iFlow->iInfo.iLocal.IsUnspecified());

		iFlow->iChanged = 1;

		}

	}

EXPORT_C void RFlowContext::SetProtocol(TUint aProtocol)

	/**

	* Sets the flow's protocol.

	* @param aProtocol

	*	The upper layer protocol associated with the flow (and the value for the IP

	*	NextHeader/Protocol field, unless some hook adds extension headers)

	*/

	{

	if (iFlow && iFlow->iInfo.iProtocol != aProtocol)

		{

		iFlow->iInfo.iProtocol = (TUint8)aProtocol;

		if (!iFlow->iInfo.iLocalSet)

			//

			// Need to reset source address to unselected also here...

			//

			// Due to IPSEC, even changing protocol, may cause destination

			// change, if policy specifies tunneling for certain protocols

			// [this None setting may be unnecessary, need to check -- msa]

			iFlow->iInfo.iLocal.SetAddress(KInet6AddrNone);

		iFlow->iChanged = 1;

		}

	}

EXPORT_C void RFlowContext::SetIcmpType(TUint aType, TUint aCode)

	/**

	* Sets the flow's ICMP type and code. Omitted aCode will set ICMP code in the

	* flow as zero.

	*

	* Note: Although this method is designed for ICMP, there are other protocols

	* which do not use ports, but some kind to type/code instead. Despite

	* it's name, this function can be used.

	*

	* @param aType		ICMP type

	* @param aCode		ICMP code

	*/

	{

	if (iFlow && (iFlow->iInfo.iIcmpType != aType || iFlow->iInfo.iIcmpCode != aCode))

		{

		iFlow->iInfo.iIcmpType = (TUint8)aType;

		iFlow->iInfo.iIcmpCode = (TUint8)aCode;

		if (!iFlow->iInfo.iLocalSet)

			//

			// Need to reset source address to unselected also here...

			//

			// Due to IPSEC, changing anything that affects selector,

			// may cause destination change (due tunnel), and thus

			// a new source address..

			// [this None setting may be unnecessary, need to check -- msa]

			iFlow->iInfo.iLocal.SetAddress(KInet6AddrNone);

		iFlow->iChanged = 1;

		}

	}

/** @} */	// End setselectors

EXPORT_C MProviderNotify * RFlowContext::SetNotify(MProviderNotify *aProvider)

	/**

	* Requesting notifications of events on the flow.

	*

	* A provider may request notification callbacks from events affecting the flow

	* by attaching a MProviderNotify instance to a flow context.

	* A flow can only have one such notifier at any time.

	*

	* Only the owner of the flow context is allowed to set this.

	*

	* The receiver of the notifications must implement the MProviderNotify mixin class:

	*

	* MProviderNotify::CanSend() is called when the flow might be ready to change

	* into the EFlow_READY status (this is only called when flow status is HOLD

	* or PENDING).

	*

	* MProviderNotify::Error is called whenever the flow is set into error state.

	* The aMask parameter follows the MSocketNotify (in <es_prot.h>) definitions.

	*

	* These two methods are a subset of the MSocketNotify,

	* and the intention is that, by default the SAP implementation using the flow

	* can just call the equivalent MSocketNotify method from these notifies.

	*

	* @param aProvider

	*		an object to receive the CanSend() or Error() upcalls,

	*		or NULL if cancel notifications

	* @return

	*		the pointer of the previous notifier, if any, is returned

	*		(or, the context was not attached, the method returns the

	*		aProvider).

	*/

	{

	// FFS: The notifier call should be suppressed while

	// iChanged is set, only the CanSend() notify?

	if (iFlow && iFlow->iOwner == this)

		{

		MProviderNotify *n = iFlow->iProvider;

		iFlow->iProvider = aProvider;

		return n;

		}

	else

		return aProvider;

	}

EXPORT_C void RFlowContext::Close()

	/**

	* Closes an open handle.

	*

	* This must be called when the handle is no longer required.

	* Close detaches the actual flow context from this handle.

	* If this handle was the last reference to the context, the context is

	* destroyed.

 	*/

	{

	if (iFlow)

		{

		if (iFlow->iOwner == this)

			iFlow->iProvider = NULL;

		// Do a "safe" close, by removing the flow context

		// reference from the handle before closing.

		CFlowContext &flow = *iFlow;

		iFlow = NULL;

		flow.Close();

		}

	}

EXPORT_C TInt RFlowContext::Status()

	/**

	* Gets the status of the flow.

	*

	* This function attempts to return the current "effective" status

	* of the flow based on current settings. Thus, if the flows parameters

	* have been changed since the last connect, the function does an implicit

	* (re)connect first.

	*

	* For documentation on values, see CFlowContext::Status.

	*

	* @return

	*		KErrBadHandle, if handle is not attached to a flow context. Other returns

	*		are defined by CFlowContext::Status.