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

// in_pkt.h - packet handling routines

// Generic packet handling utility for mapping packet handling to the RMBufChain.

//

/**

 @file in_pkt.h

 @publishedAll

 @released

*/

#ifndef __IN_PKT_H__

#define __IN_PKT_H__

#include "ip6_hdr.h"	// ..should eventually be <inet/ip6_hdr.h>? -- msa

#include "ip4_hdr.h"

#define TPACKETHEAD_FRAGMENT	1	//< Enable iFragment in TPacketHead

/**

 TScopeType is only provided so that "magic" constants can be

 avoided in the source code. However, the max value cannot be changed

 to anything from 0xF. The scope type is assumed to be 4 bits long

 in many occasions.

 The value of the scope type is directly bound the the IPv6 Scope

 level - 1. This can be done, as IPv6 Scope level 0 is not legal

 (or usable) in any context within the stack.

 This allows our non-standard network scope (= 0x10) to

 be coded internally in 4 bits (as 0xF).

 @publishedAll

 @released

 @since v7.0s

*/

enum TScopeType

	{

	EScopeType_IF	= 0x0,	//< (= #KIp6AddrScopeNodeLocal - 1), id is interface index

	EScopeType_IAP	= 0x1,	//< (= #KIp6AddrScopeLinkLocal - 1). id is IAP number

	EScopeType_GLOBAL = 0xD,//< (= #KIp6AddrScopeGlobal - 1). id is global scope id

	//

	// no symbols defined for types 2..14 (they are also valid)

	//

	EScopeType_NET	= 0xF	//< (= #KIp6AddrScopeNetwork - 1), id is network number (must be the last entry)

	};

//

//	TIpHeader

//	*********

class TIpHeader

	/**

	A simple help class that uses a union to merge handling of either an IPv4 or 

	an IPv6 header. 

	@since v7.0

	@publishedAll

	@released

	*/

	{

public:

	/**

	Gets the minimum header length.

	IPv6 header is longer than minimum IPv4 header, thus

	returned value is for IPv4. This function only defined

	because it is required when this class is used as template

	parameter in TInet6Packet.

	@return Minimum IPv4 header length

	*/

	inline static TInt MinHeaderLength() {return TInet6HeaderIP4::MinHeaderLength(); }

	/**

	Gets the maximum header length.

	IPv6 header always shorter than maximum IPv4 header, thus

	returned value is for IPv4. This function is only defined

	because "header mapping" classes are expected to have it.

	@return Maximum IPv4 header length

	*/

	inline static TInt MaxHeaderLength() {return TInet6HeaderIP4::MaxHeaderLength(); }

	union

		{

		TInet6HeaderIP4 ip4;

		TInet6HeaderIP ip6;

		};

	};

class TInet6PacketBase

	/**

	* Thin base class for the TInet6Packet.

	*/

	{

public:

	enum TAlign

		{

		EAlign1 = 0,	//< Align to byte (no align requirement)

		EAlign2 = 1,	//< Align to 2 byte unit (even address)

		EAlign4 = 3,	//< Align to 4 byte unit

		EAlign8 = 7		//< Align to 8 byte unit

		};

	/**

	Constructor.

	@param aAlign	The align requirement.

	*/

	TInet6PacketBase(TAlign aAlign) : iLength(0), iAlign(aAlign) {}

	/**

	Length of the mapped region.

	The real mapped length as computed by the Access function.

	If access returned non-NULL, the following is always TRUE:

	@li	aMin <= iLength

	*/

	TInt iLength;

	IMPORT_C TUint8 *Access(RMBufChain &aPacket, TInt aOffset, TInt aSize, TInt aMin);

	inline void SetAlign(TAlign aAlign)

		/**

		* Changes the align requirement.

		*

		* @param aAlign The new align requirement.

		*/

		{

		iAlign = aAlign;

		}

protected:

	/**

	The align requirement.

	*/

	TAlign iAlign;

	};

// TInet6Packet template

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

template <class T>

class TInet6Packet : public TInet6PacketBase

	/**

	Encapsulates an IPv6 packet header as a section of an RMBufChain.

	The T template parameter should represent a packet header type. It should 

	support static functions MaxHeaderLength() and MinHeaderLength() that return 

	TInt values for maximum and minimum header lengths respectively.

	@publishedAll

	@released

	@since v7.0

	*/

	{

public:

	TInet6Packet(TAlign aAlign = EAlign4) : TInet6PacketBase(aAlign), iHdr(NULL)

		/**

		Default constructor.

		Construct an empty mapping. To be usable, the Set() function

		must be used.

		*/

		{}

	TInet6Packet(RMBufChain &aPacket) : TInet6PacketBase(EAlign4)

		/**

		Constructor specifying a RMBufChain object.

		Verify and arrange it so that a class T can be mapped

		to a contiguous octets from the beginning of the RMBufChain

		content, and set iHdr to point this area.

		If this is not possible, iHdr is initialized to NULL.

		@param	aPacket

			Packet containing the header T at offset = 0

		*/

		{

		iHdr = (T *)Access(aPacket, 0, T::MaxHeaderLength(), T::MinHeaderLength());

		}

	TInet6Packet(RMBufChain &aPacket, TInt aOffset, TAlign aAlign = EAlign4) : TInet6PacketBase(aAlign)

		/**

		Constructor specifying a RMBufChain object and an offset.

		Verify and arrange it so that a class T can be mapped

		to a contiguous octets starting at specified offset of

		the RMBufChain content, and set iHdr to point this area.

		If this is not possible, iHdr is initialized to NULL.

		@param aPacket

			Packet containing the header T at aOffset

		@param aOffset

			Offset of the header to be mapped.

		@param aAlign

			The alignement requirement.

		*/

		{

		iHdr = (T *)Access(aPacket, aOffset, T::MaxHeaderLength(), T::MinHeaderLength());

		}

	void Set(RMBufChain &aPacket, TInt aOffset, TInt aSize)

		/**

		Sets the packet header from a specified RMBufChain object.

		Verify and arrange it so that a aSize octets can be mapped

		to a contiguous octets starting at specified offset of

		the RMBufChain content, and set iHdr to point this area.

		If this is not possible, iHdr is initialized to NULL.

		Note that this differs from the contructors: the required

		size is a parameter, and not determined by the T::MinHeaderLength().

		However, the "T* iHdr" is set to point the start of the requested

		area. It's a responsibility of the user of this method to know

		whether using this pointer is safe with the specified size parameter.

		@param	aPacket

			Packet containing the header T at aOffset

		@param	aOffset

			Offset (position) of the header to be mapped

		@param	aSize

			Length of required contiguous memory

		*/

		{

		iHdr = (T *)Access(aPacket, aOffset, aSize, aSize);

		}

	inline T& operator()()

		{

		return *iHdr;

		}

	/**

	The pointer to the mapped region (if non-NULL). If NULL,

	then there is no mapping, and iLength == 0.

	*/

	T *iHdr;

	};

#endif