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

// ip6.cpp - IPv6 protocol

//

#include "inet6log.h"

#include <ip6_hdr.h>

#include <ip4_hdr.h>

#include <icmp6_hdr.h>

#include <udp_hdr.h>

#include <in_pkt.h>

#include <in_chk.h>

#include <in6_if.h>	// only for KIpBroadcastOnLink

#include "ip6.h"

#include <ip6_hook.h>

#include <ip6_iprt.h>

#include "ip6_rth.h"

#include "ip6_doh.h"

#include "ip6_frag.h"

#include "in_flow.h"

#include "iface.h"

#include "in_net.h"

#include <ext_hdr.h>

#include <inet6err.h>

#include "loop6.h"

#include "res.h"	// only for KProtocolInet6Res

#include "addr46.h"

#include "tcpip_ini.h"

#include <comms-infras/nifif_internal.h>

// The preprocessor symbol: ARP

// ----------------------------

// Add code for doing IPv4 Address Resolution Protocol (ARP) on

// IPv4 interfaces that specify "NeedNd". (also needed in ïface.cpp)

#ifdef ARP

#include <arp_hdr.h>

#endif

static const TLitC8<sizeof(TInt)> KInetOptionDisable = {sizeof(TInt), {0}};

//

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

//	TUpperLayerSnoop

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

//	A simple class to map the first 4 bytes of the packet into

//	ports or icmp type/code. This is used to snoop the upper

//	layer information. (The use of "real" upper layer header

//	classes directly would complicate things: each protocol

//	would need to have a separate mapping)

//

class TUpperLayerSnoop

	{

	public:

		//

		// Basic

		//

		inline static TInt MinHeaderLength() {return 4; }

		inline static TInt MaxHeaderLength() {return 4; }

		union

			{

			//

			// The same mapping will do for both TCP and UDP,

			// as only port fields are really accessed.

			//

			TInet6HeaderUDP udp;

			TInet6HeaderICMP icmp;

			};

	};

//

//

//	CProtocolIP6

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

//	The implementation and even the class definition of CProtocolIP6 is

//	totally internal to ip6.cpp. No other module needs to know any of the

//	internals. Thus, all declarations of the CProtocolIP6 are included here

//

//

class CHookEntry;

class THookList

	{

	friend class CProtocolIP;

	friend class CProtocolIP4;

	friend class CProtocolIP6;

	void AddL(CProtocolBase *aProtocol);

	void AddL(CIp6Hook *aHook, TInt aPriority);

	TInt AddByOrderListL(CIp6Hook *aHook,  const TDesC &aName, const TDesC &aOrdering, const TInt aPriority);

	TInt Remove(const CProtocolBase *const aProtocol);

	TInt Remove(const CIp6Hook *const aHook);

	TInt Remove(const TAny *const any);

	TInt RemoveAll();

	void StartSending(CProtocolBase *aSource);

	void StartSending(CProtocolBase *aIface, CProtocolBase *aSrc);

	void Error(TInt aError, CProtocolBase *aSource);

	void Error(TInt aError, CProtocolBase *aIface, CProtocolBase *aSrc);

	void InterfaceAttached(const TDesC &aName, CNifIfBase *aIf);

	void InterfaceDetached(const TDesC &aName, CNifIfBase *aIf);

private:

	void Delink(CHookEntry *p, CHookEntry *h);

	void Link(CHookEntry *p, CHookEntry *h);

	CHookEntry *iHead;

	TUint iChainId;

	};

//

//	TBoundHookEntry

//	---------------

//		Bookkeeping entry for the protocols that are bound via

//		esock.ini directive to the IP6 instance

//

class TBoundHookEntry

	{

public:

	CProtocolBaseUnbind *iProtocol;	// Bound protocol, always non-NULL!

	CNifIfBase *iInterface;			// Interface, non-NULL for a special "interface protocol"

	};

//

//	TIcmpThrottle

//	-------------

//

class TIcmpThrottle

	{

public:

	TIcmpThrottle() :

//		iMask((TUint32)(~((1 << 26) - 1))),	// mask matching about 67 seconds

		iMask((TUint32)(~((1 << 23) - 1))),	// mask matching about 8 seconds

		iStamp(0)

		{}

	TInt Suppress();

	inline void SetMax(TInt aMax) { iMax = aMax; }

private:

	const TUint32 iMask;

	TUint32 iStamp;

	TInt iMax, iCount;

	};

TInt TIcmpThrottle::Suppress()

	{

	TTime now;

	//

	// The idea is to have a low overhead throttle test by

	// defining the interval as a 2**N of microseconds

	// (2**23 ~ 8 seconds), and just using the remaining

	// high order bits as a time stamp, which when changed

	// allows more to send... (this will allow a burst of

	// of iMax messages, in the beginning of time interval!)

	//

	now.UniversalTime();

#ifdef I64LOW

	TUint ref = (TUint)I64LOW(now.Int64()) & iMask;

#else

	TUint ref = now.Int64().Low() & iMask;

#endif

	if (ref != iStamp)

		{

		iStamp = ref;

		iCount = 0;

		}

	return ++iCount > iMax;

	}

// TPacketContextItem

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

class TPacketContextItem

	{

public:

	TUint32 iKey, iValue;

	};

class CProtocolIP : public CProtocolInet6Network, public MNetworkServiceExtension, public MPacketContext

	{

	friend class IP6;

public:

	CProtocolIP(CIfManager *aInterfacer, TInt aProtocol);

	~CProtocolIP();

	void InitL(TDesC& aTag);

	CServProviderBase* NewSAPL(TUint aSockType);

	void BindToL(CProtocolBase *protocol);

	void BindL(CProtocolBase *protocol, TUint id);

	void StartL(void);

	void Process(RMBufChain &aPacket, CProtocolBase* aInterface);

	void Unbind(CProtocolBase *protocol, TUint id = 0);

	void Identify(TServerProtocolDesc *) const;

	TInt GetOption(TUint level,TUint name,TDes8 &option,CProtocolBase* aSourceProtocol);

	TInt SetOption(TUint level, TUint aName,const TDesC8 &option,CProtocolBase* aSourceProtocol);

	//

	// Active users tracking is done by the interface manager,

	// just pass the following directly.

	//

	void IncUsers() { iInterfacer->IncUsers(); }

	void DecUsers() { iInterfacer->DecUsers(); }

	void Error(TInt aError, CProtocolBase* aSrc);

	void StartSending(CProtocolBase* aSrc);

	//

	// Network service (MNetworkService)

	//

	CProtocolInet6Binder *Protocol() const;

	MInterfaceManager *Interfacer() const;

	TInt Send(RMBufChain &aPacket, CProtocolBase* aSrc = NULL);

	void Icmp4Send(RMBufRecvPacket &aPacket, TInt aType, TInt aCode, TUint32 aParameter, TInt aMC = 0);

	void Icmp6Send(RMBufRecvPacket &aPacket, TInt aType, TInt aCode, TUint32 aParameter, TInt aMC = 0);

	void IcmpWrap(RMBufChain &aPacket, const TIcmpTypeCode aIcmp, const TUint32 aParameter = 0, const TInt aMC = 0);

	TBool Fragment(RMBufSendPacket &aPacket, RMBufSendInfo &aInfo, TInt aMtu, RMBufPktQ &aFragments);

	CHostResolvProvdBase *NewHostResolverL();

	CServiceResolvProvdBase *NewServiceResolverL();

	CNetDBProvdBase *NewNetDatabaseL();

	//

	// Network service extension (additional methods MNetworkServiceExtension)

	//

	void InterfaceAttached(const TDesC &aName, CNifIfBase *aIf);

	void InterfaceDetached(const TDesC &aName, CNifIfBase *aIf);

	//

	// The Flow Manager section (MFlowManager)

	//

	CFlowContext *NewFlowL(const void *aOwner, TUint aProtocol);

	CFlowContext *NewFlowL(const void *aOwner, CFlowContext &aFlow);

	TInt SetChanged() const;

	TInt FlowSetupHooks(CFlowInternalContext &aFlow);

	void FlowStartRefresh(CFlowInternalContext &aFlow);

	TInt GetFlowOption(TUint aLevel, TUint aName, TDes8 &aOption, const CFlowContext &aFlow) const;

	TInt SetFlowOption(TUint aLevel, TUint aName, const TDesC8 &aOption, CFlowContext &aFlow);

	//

	// The Packet Context (MPacketContext)

	//

	TInt SetHookValue(const TUint32 aId, const TUint32 aValue);

	TUint32 HookValue(const TUint32 aId) const;

	TBool DoSwitchL(RMBufHookPacket &aPacket);

	void PostProcess(RMBufChain &aPacket, CProtocolBase *aSrc);

private:

	void DoProcess();

	void IcmpEcho(RMBufPacketBase &aPacket, RMBufRecvInfo *aInfo);

	void IcmpSend(TInt aProtocol, RMBufRecvPacket &aPacket, TInt aType, TInt aCode, TUint32 aParameter, TInt aMC);

	TPtrC HookOrdering(const TDesC &aOrderKey) const;

	static TInt RecvCallBack(TAny* aProtocol);

protected:

	TInt IcmpHandlerL(RMBufHookPacket &aPacket, RMBufRecvInfo &aInfo, CProtocolBase *aFinal);

	void UnbindAll(TAny *aProtocol);

	TInt DoBuild(RMBufPacketBase &aPacket,  RMBufPktInfo &aInfo, TPacketHead &aHead);

	void DoSendOnePacket(RMBufSendPacket &aPacket);

	void DoProcessOnePacketL(RMBufHookPacket &aPacket);

	CIfManager *const iInterfacer;

	// Resolver instance

	CProtocolBase *iResolver;

	// IPv4 "slave" instance, if NON-NULL (catched in BindToL,

	// not "reference counted"!).

	CProtocolIP *iSlavedIP4;

	//

	// Protocol "identity", the following members contain either

	//	(KProtocolInetIp,KProtocolInetIcmp) for IPv4

	// or

	//	(KProtocolInet6Ip, KProtocolInet6Icmp) for IPv4

	// Both of these could always be deduced from the iProtocol of

	// TServerProtocolDesc, but this way makes some shared code

	// simpler to write.

	const TInt iProtocol, iIcmpProtocol;

	//

	// A brute force protocol switch array (will possibly get revised,

	// later if needed).This array is directly indexed by the next header

	// value of the IP packet.

	//

	// Every element of the array will always have a valid pointer value

	// assigned (iNullProtocol). At run time, there is never need to verify

	// against a NULL pointer.

	//

	// Also, a pointer in iSwitch does not mean that CProtocolIP6 class

	// owns that instance, the objects pointed by this array are NOT

	// deleted when IP6 instance is destroyed.

	//

	MNifIfUser *iNifUser;	// Defined when protocol is registered with the interfacer

	THookList iSwitch[KIp6Hook_ANY+1];

	TUint SwitchSize() {return sizeof(iSwitch) / sizeof(iSwitch[0]); }

	CHookEntry *iNullHook;

	CFragmentHeaderHook *iFragmentHeader;

	CNifIfBase	*iLoopback4;	// "Hardcoded" IPv4 loopback interface

	CNifIfBase	*iLoopback6;	// "Hardcoded" IPv6 loopback interface

	//

	// State information used by the ICMP "throttle"

	//

	TIcmpThrottle iIcmpThrottle;

	// iBindCount counts how many non-NULL protocols are currently

	// stored in iSwitch. This variably is purely for debugging

	// purposes. It *should* be zero when this protocol instance is

	// destroyed!

	//

	TInt iBindCount;

	//

	// List of hooks that are interested in peeking at the outbound packets

	//

	THookList iOutbound;

	//

	// List of hooks that are intrested in packets that got received by

	// the stack, but which apparently are not addresses to this host

	// (e.g. packets that may need forwarding).

	//

	THookList iForwardHooks;

	//

	// List of hooks that want to peek complete packets just before they

	// are sent to the interface. These hooks must be aware of the iFlow

	// in the info block, and are responsible to actully passing the packet

	// to the interface. These hooks receive complete packets through the

	// Send (Outbound) and Process (Inboud) interfaces.

	//

	THookList iPostInbound;

	THookList iPostOutbound;

	CIp6Hook *iPostTerminator;

	//

	// Some hooks may be installed by using the 'bindto'-directive of ESOCK.INI

	// on IP6 instance. This will call BindtoL of IP6 to call Bind()+Open() to the

	// indicated protocol. Need to keep track of these protocols and issue matching

	// Close() calls in case IP6 is deleted. (NOTE: protocol bound in this way

	// cannot "die" until IP6 releases them). iBoundHooks tracks these.

	//

	CArrayFixFlat<TBoundHookEntry> *iBoundHooks;

	//

	// Identification for the IPv4 header field

	//

	TInt iId;

	//

	// Packet forwarding section

	//

	TUint iForwardFlowSize;			// Max Number of entries in the array

	TUint iForwardFlowCount;			// Current number of forward flow contexts.

	RFlowContext *iForwardFlow;		// Array of RFlowContext handles

	TUint iForwardHits;				// Packets forwarded without resetting a flow

	TUint iForwardMiss;				// Packets forwarded with resetting a flow

	const TUint iSwitchSize;             

	//

	// Work space for maintaining inbound packet context (during DoSwitch())

	// (fixed allocation now, implement something else later if needed)

	//

	TInt iPacketContextCount;		// Number of used entries

	// .. the max number of slots is automaticly determined by the

	// .. size of the array iPacketContext (see SetHookValue).

	TPacketContextItem iPacketContext[8];

	TUint32 iPacketId;				// Packet sequence number (used as packet id).

	//

	// The queue for the received packets from the NIF's.

	//

	RMBufAsyncPktQ iRecvQ;

	};

class CProtocolIP6 : public CProtocolIP

	{

	friend class IP6;

public:

	CProtocolIP6(CIfManager *aInterfacer);

	~CProtocolIP6();

	void InitL(TDesC& aTag);

private:

	CRoutingHeaderHook *iRoutingHeader;

	CDestinationOptionsHook *iDestinationOptions;

	CHopOptionsHook *iHopOptions;

	};

class CProtocolIP4 : public CProtocolIP

	{

	friend class IP6;

public:

	CProtocolIP4(CIfManager *aInterfacer);

	~CProtocolIP4();

	void InitL(TDesC& aTag);

	};

//

//	IP6 Class Implementation

//

void IP6::Identify(TServerProtocolDesc &aEntry, TInt aVersion)

	{

	if (aVersion == STATIC_CAST(TInt, KProtocolInetIp))

		{

		aEntry.iName=_S("ip");

		aEntry.iAddrFamily=KAfInet;

		aEntry.iProtocol=KProtocolInetIp;

		// message size is absolute upper limit, not guaranteed to work

		aEntry.iMessageSize=0xffff-TInet6HeaderIP4::MinHeaderLength();

		}

	else

		{

		aEntry.iName=_S("ip6");

		aEntry.iAddrFamily=KAfInet6;

		aEntry.iProtocol=KProtocolInet6Ip;

		// message size is absolute upper limit, not guaranteed to work

		aEntry.iMessageSize=0xffff-TInet6HeaderIP::MinHeaderLength();

		}

	aEntry.iSockType=KSockDatagram;

	aEntry.iVersion=TVersion(KInet6MajorVersionNumber, KInet6MinorVersionNumber, KInet6BuildVersionNumber);

	aEntry.iByteOrder=EBigEndian;

	aEntry.iServiceInfo=KIP6ServiceInfo;

	aEntry.iNamingServices=KIP6NameServiceInfo;

	aEntry.iSecurity=KSocketNoSecurity;

	aEntry.iServiceTypeInfo=KIP6ServiceTypeInfo;

	aEntry.iNumSockets=KUnlimitedSockets;

	}

CProtocolBase *IP6::NewL(CIfManager *aInterfacer, TInt aVersion)

	{

	CProtocolBase *prt;

	if (aVersion == STATIC_CAST(TInt, KProtocolInetIp))

		prt = new (ELeave) CProtocolIP4(aInterfacer);

	else

		prt = new (ELeave) CProtocolIP6(aInterfacer);

	return prt;

	}

//

//	THookList

//		The implementation of this is totally internal to this IP6

//		protocol module. Thus, all declaratations and implementation

//		is here. No outside module needs to know how this works!

//

class CHookEntry : public CBase

	{

	friend class THookList;

	friend class CProtocolIP;

	friend class CProtocolIP4;

	friend class CProtocolIP6;

	CHookEntry(CProtocolBase *aProtocol, CHookEntry *aNext) : iType(0), iNext(aNext)

		/** Construct upper layer protocol entry. */

		{ iProtocol = aProtocol; }

	CHookEntry(CIp6Hook *aHook, CHookEntry *aNext, TInt aPriority) : iType(aPriority), iNext(aNext)

		/** Construct a hook entry. */

		{ iHook = aHook; }

	inline TBool IsHook() const { return iType != 0; }

	inline TBool IsProtocol() const { return iType == 0; }

private:

	TInt iType;

	union

		{

			CProtocolBase *iProtocol;	//< if iType == 0,

			CIp6Hook *iHook;			//< if iType != 0, for inbound packet hook

		};

	class CHookEntry *iNext;

	};

void THookList::AddL(CProtocolBase *aProtocol)

	/**

	* Adds an upper layer protocol handler.

	*

	* Override the current protocol handler with a new

	* protocol binding. The previous binding (if any) is not

	* removed, but is hidden behind this new one until it unbinds.

	*

	* The new element is added in front of the old one.

	*

	* @param aProtocol	The protocol

	*/

	{

	CHookEntry *p = NULL;

	CHookEntry *h, **head = &iHead;

	//

	// Skip over possible hook mode handlers

	//

	while ((h = *head) != NULL && h->IsHook())

		{

		p = h;

		head = &h->iNext;

		}

	//

	// 'h' points the current first protocol (if it exists), just insert

	// this new protocol in front of it and "hide" the previous one

	//

	// coverity[alloc_fn] coverity[assign]	

	*head = new (ELeave) CHookEntry(aProtocol, h);

	Link(p, *head);

	// coverity[memory_leak]  

	}

void THookList::AddL(CIp6Hook *aHook, TInt aPriority)

	/**

	* Add a new hook handler into the list.

	*

	* @param aHook		The hook

	* @param aPriority	The priority (must be > 0)

	*/

	{

	if (aPriority > 0)

		{

		CHookEntry *p = NULL;

		CHookEntry *h, **head = &iHead;

		while ((h = *head) != NULL && h->iType > 0 && h->iType > aPriority)

			{

			p = h;

			head = &h->iNext;

			}

		// coverity[alloc_fn] coverity[assign]	

		*head = new (ELeave) CHookEntry(aHook, h, aPriority);

		Link(p, *head);

		}

	// coverity[memory_leak]  

	}

// THookList::AddByOrderList

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

// Add protocol to list based on the ordering.

//

// The priority is computed by (bigger is better):

//

// (10000 - hook position in the list) * 256 + aPriority

//

// If the protocol is mentioned more than once in the aOrdering,