--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/networkprotocols/iphook/inhook6/include/in_bind.h	Tue Jan 26 15:23:49 2010 +0200
@@ -0,0 +1,974 @@
+// 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_bind.h - services provided by the IP layer of the stack
+// services provided by the IP layer of the stack
+//
+
+
+
+/**
+ @file in_bind.h
+ @publishedPartner
+ @released
+*/
+
+#ifndef __IN_BIND_H__
+#define __IN_BIND_H__
+
+#include <es_sock.h>
+#include <es_prot.h>
+
+#include "ip6_hook.h"
+#include "apibase.h"
+
+class CProtocolInet6Binder;
+
+// MInterface
+// **********
+class MInterface : public MInetBase
+	/**
+	* Public services from the interface instance.
+	*
+	* @note
+	* The MInterface reference must not be stored
+	* into any member variables. The reference may become
+	* invalid, if thread change occurs.
+	* @since v7.0s
+	* @publishedPartner
+	* @released
+	*/
+	{
+public:
+	/**
+	* @return the interface index of the interface. Always > 0.
+	*/
+	virtual TUint32 Index() const = 0;
+	/**
+	* @return a reference to the name of the interface.
+	*/
+	virtual const TDesC &Name() const = 0;
+	/**
+	* Query the value of the specied scope id.
+	*
+	* @param aType (0..15), select the scope id to be queried
+	* @return The scope id value.
+	*/
+	virtual TUint32 Scope(const TScopeType aType) const = 0;
+	};
+
+/**
+* @name AddRouteL flags
+*
+* The flags define the type of the "route" entry and some optional
+* processing instructions for the MInterfaceManager::AddRouteL.
+*
+* The diagram represents 32 bit host order integer.
+@verbatim
+
+    |       |       |       |       |       |       |       |       |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+MSB |        Reserved                   |P|U|H|R|O|S| Type Ext  |Typ| LSB
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+Typ     Major type of the entry (type).
+
+Type Ext
+        For some route types, the stack uses additional qualifiers
+        to track the route state. Should be zeroed.
+
+S       Solicited bit from Neighbor discovery (only used when type = 0).
+
+O       Override bit from Neighbor discovery (only used when type = 0).
+
+R       Neighbor cache for router (only used when type = 0). Change to Router.
+
+H       Neighbor cache for host (only used when type = 0). Change to Host.
+
+U       Update Only (do not create entry, if it does not exist).
+
+P       Probing only.
+
+Reserved
+        Must be zero.
+
+@endverbatim
+*/
+//@{
+/**
+* type=0, Neighbor cache entry. The "prefix" length is always
+* 128 bits. This type of entry stores the link layer address
+* for a neighbor on the link.
+*
+* @note
+*	This type is automaticly managaged by the IPv6 neighbor
+*	discovery process, or by the IPv4 ARP protocol.
+*/
+const TUint KRouteAdd_NEIGHBOR	= 0;
+/**
+* type=1, My own prefix or address entry. This is also used for
+* joined multicast groups. The prefix is always 128 bits for
+* IPv4 addressess (entry contains the full IPv4 address in
+* IPv4 mapped format), for configured specific IPv6 addresses,
+* or when entry is used to represent joined multicast group.
+*
+* The prefix is shorter (usually 64) when
+* the entry is used to present IPv6 address prefix that has
+* been received via router advertisement (with address
+* configuration bit A set).
+*
+* @note
+*	This type is mostly handled automaticly via IPv6 or IPv4
+*	configuration. Additionally, for example, joining a multicast
+*	group on the interface, adds an entry of this type automaticly.
+*/
+const TUint KRouteAdd_MYPREFIX	= 1;
+/**
+* type=2, Onlink route.
+*/
+const TUint KRouteAdd_ONLINK	= 2;
+/**
+* type=3, Gateway route, destination offlink, behind the indicated gateway
+*/
+const TUint KRouteAdd_GATEWAY	= 3;
+
+/**
+* Mask (0x3), extracts the main type of the "route" entry (NEIGHBOR, MYPREFIX, ONLINK, GATEWAY)
+*/
+const TUint KRouteAdd_TYPEMASK	= 0x003;
+/**
+* Mask (0xff), extracts bits of the route state. System uses internally more states than the four main types.
+*/
+const TUint KRouteAdd_STATEMASK	= 0x0ff;
+//
+// - for a host route (= neighbor cache entry), four additional bits can be present
+//   (these bits are ignored for the other route types). (Leave 8 bits room for
+//   internal state, and start assigning flags from bit 8!)
+//
+/**
+* Usually set from ND solicited bit (usually marks host as reachable).  NEIGHBOR only.
+*/
+const TUint KRouteAdd_SOLICITED	= 0x0100;
+/**
+* Update the link layer address. NEIGHBOR only.
+*/
+const TUint KRouteAdd_OVERRIDE	= 0x0200;
+/**
+* This host is now a router (not host). NEIGHBOR only.
+*/
+const TUint KRouteAdd_ISROUTER	= 0x0400;
+/**
+* This host is now a host (not router). NEIGHBOR only.
+*/
+const TUint KRouteAdd_ISHOST	= 0x0800;
+//
+//   When set, it also prevents the processing of ISROUTER/ISHOST, iff entry is
+//   in incomplete state, link needs addresses and no link address is specifified
+//   (see. CIp6Route::Update). [this subtly implements the NA dropping rule in
+//   RFC 2461, 7.2.5 and still passes redirect target on-link route installs,
+//   don't mess with this]
+//
+/**
+* Do not create route entry, if it does not exist previously.
+*
+* By default, AddRouteL always creates a new route entry, if no matching
+* route is found. Setting UPDATEONLY flag prevents this.
+*/
+const TUint KRouteAdd_UPDATEONLY= 0x1000;
+/**
+* If route is created, mark it as "probing only".
+*
+* When a route has "probing only" flag set, it is prevented from
+* being selected bind "find route". Only useful for Neighbor Cache
+* entries. The flag is automaticly cleared, if route state changes
+* from Incomplete to some other state.
+*/
+const TUint KRouteAdd_PROBINGONLY = 0x2000;
+//@}
+
+//
+// MInterfaceManager
+// *****************
+// Public services from Interface Manager
+class MInterfaceManager : public MInetBase
+	/** Provides an interface to the IPv6 protocol module's interface manager.
+	*
+	* The functions of the MInterfaceManager define the externally visible
+	* services of the interface manager.
+	*
+	* @publishedPartner
+	* @released
+	*/
+	{
+public:
+	/**
+	* Adds or modifies routes.
+	*
+	* AddRouteL adds the specified (aAddr/aPrefix) route pointing to the interface (aName).
+	* If the interface with this name does not exist,
+	* an empty interface instance is created for it.
+	*
+	* @note The route table can also be manipulated using socket options.
+	*
+	* AddRouteL succeeds always, and the leave condition is only invoked
+	* when it fails to allocate the necessary objects to store the information.
+	* 
+	* The current route management is almost fully automatic,
+	* based on information that is retrieved from the active interfaces
+	* and from router advertisements.
+	*
+	* The current implementation uses the route table also for neighbor
+	* cache, multicast group membership and stores IPv6 address generation
+	* prefixes into route table.
+	*
+	* The aFlags arguments defines the type of the route entry and
+	* some additional processing instructions. The type is one of the
+	* following:
+	* @li	#KRouteAdd_NEIGHBOR (neighbor cache entry)
+	* @li	#KRouteAdd_MYPREFIX (own address/prefix/multicast entry)
+	* @li	#KRouteAdd_ONLINK ("traditional" route entry)
+	* @li	#KRouteAdd_GATEWAY ("traditional" route entry)
+	*
+	* Some modifiers can ored with the base type. The following
+	* are effective <b>ONLY</b> with KRouteAdd_NEIGHBOR (and used
+	* internally):
+	* @li	#KRouteAdd_SOLICITED
+	* @li	#KRouteAdd_OVERRIDE
+	* @li	#KRouteAdd_ISROUTER
+	* @li	#KRouteAdd_ISHOST
+	*
+	* #KRouteAdd_UPDATEONLY can be combined with any route type. It prevents
+	* creation of the route entry, if it does not already exist.
+	*
+	* Type of KRouteAdd_NEIGHBOR routes are generated automaticly by the
+	* neighbor discovery process. Careless use of this type
+	* may disrupt the neighbor discovery processes.
+	* 
+	* @param aAddr Address part of the route prefix
+	* @param aPrefix The number of bits in the prefix  (aAddr)
+	* @param aName The interface name
+	* @param aFlags Type of the route entry (KRouteAdd_MYPREFIX or KRouteAdd_ONLINK) and some other flags.
+	* @param aGateway (ptr to) a gateway or link layer address depending on the type of route (GATEWAY/NEIGHBOR)
+	* @param aLifetime (ptr to) the lifetime of the route in seconds (if zero, route is deleted) 
+	*/
+	virtual void AddRouteL(const TIp6Addr &aAddr, TInt aPrefix, const TDesC &aName,
+		TUint aFlags = KRouteAdd_ONLINK, const TSockAddr *const aGateway = NULL, const TUint32 *const aLifetime = NULL) = 0;
+	/** Tests if a route and source address exist for a given address.	
+	* 
+	* @param aAddr		Address to check
+	* @param aScopeid	Address scope
+	* @param aSrc		On return, the source address
+	* @return 			KErrNone if the route exists, otherwise KErrNotFound
+	*
+	* @deprecated
+	*/
+	virtual TInt CheckRoute(const TIp6Addr &aAddr, const TUint32 aScopeid, TIp6Addr &aSrc) const = 0; 
+
+	/**
+	* Tests whether the address is usable as a source address within a
+	* subset of interfaces limited by the <aLockType, aLock>.
+	* 
+	* @param aAddr The address (IPv6 or IPv4) to be tested in IPv6 format. IPv4
+	* addresses are in IPv4 mapped format.
+	* @param aLock The scope identifier for limiting the interfaces
+	* @param aLockType The type of the scope identifier
+	* @return NON-ZERO scope identifier which matches the tested address, if
+	* address is a valid source address for the host. If address is not usable,
+	* returns ZERO.
+	*/
+	virtual TUint32 LocalScope(const TIp6Addr &aAddr, const TUint32 aLock, const TScopeType aLockType) const = 0;
+	/**
+	* Finds the scope id for the remote address.
+	*
+	* Returns ZERO, if scope id cannot be determined.
+	*
+	* @param aAddr The address (IPv6 or IPv4) to be tested in IPv6 format. IPv4
+	* addresses are in IPv4 mapped format.
+	* @param aLock The scope identifier for limiting the interfaces
+	* @param aLockType The type of the scope identifier
+	* @return NON-ZERO scope identifier which matches the tested address, if
+	* it can be determined (suitable route exists), and ZERO otherwise
+	*/
+	virtual TUint32 RemoteScope(const TIp6Addr &aAddr, const TUint32 aLock, const TScopeType aLockType) const = 0;
+	/**
+	* Tests whether a packet having a specified destination address should be processed 
+	* by the current host.
+	*
+	* Suitable addresses include the source addresses covered by the IsMyAddress(), 
+	* and also the applicable multicast and broadcast addresses.
+	*
+	* This method is mainly used by the IP layer.
+	* 
+	* @param aAddr The address (IPv6 or IPv4) to be tested (in network byte order)
+	* @param aInterfaceIndex The source interface (the originating interface is
+	* required for accurate determination of link local or multicast addresses)
+	* @return NON-ZERO interface index, if destination applies to current node.
+	*/
+	virtual TUint32 IsForMeAddress(const TIp6Addr &aAddr, const TUint32 aInterfaceIndex) const = 0;
+
+	/**
+	* Finds MInterface by CNIfIfBase.
+	*
+	* Searches the internal inteface descriptions and looks for an interface
+	* which is currently bound to the speficied NIF instance. The interface
+	* manager does not prevent the situation where the same NIF is attached
+	* to multiple internal interfaces. If such configuration is created, the
+	* interface which is returned is always the first matching one.
+	*
+	* @param aIf	The NIF to be searched.
+	* @return MInterface or NULL, if NIF not found.
+	*/
+	virtual const MInterface* Interface(const CNifIfBase *const aIf) const = 0;
+	/**
+	* Finds MInterface by name.
+	*
+	* Searches the internal interface descriptions and looks for an interface
+	* with the specified name. The returned interface, if found, can be up
+	* or down. There cannot be two interfaces with the same name, the name
+	* is always a unique identifier of an interface.
+	*
+	* @param aName	The name to be searched.
+	* @return MInterface or NULL, if NIF not found.
+	*/
+	virtual const MInterface* Interface(const TDesC &aName) const = 0;
+	/**
+	* Finds MInterface by interface index.
+	*
+	* Searches the internal interface descriptions and looks for an interface
+	* with the specified index. The returned interface, if found, can be up
+	* or down. Each interface is assigned a unique index, the index is always
+	* a unique indentifier of an interface.
+	*
+	* @param aInterfaceIndex The index value to be searched.
+	* @return MInterface or NULL, if NIF not found.
+	*/
+	virtual const MInterface* Interface(const TUint32 aInterfaceIndex) const = 0;
+	/**
+	* Enumerates interface information.
+	*
+	* This function gets information about the next interface after the interface 
+	* identified by the input parameter aIndex.
+	* 
+	* To start, call first with aIndex=0, and after that always give the previously 
+	* returned value as a parameter. When the return value is 0, all interfaces 
+	* have been listed.
+	* 
+	* A single "real" interface has one index value for each possible source address. 
+	* TSoInetInterfaceInfo::iName can be used to determine the "real" interface. 
+	*
+	* Note that TSoInetInterfaceInfo is the structure used by the Symbian OS v6.1 
+	* IPv4 stack. The IPv6 interfaces do not provide automatic information about 
+	* the name servers or gateways. Some of the information comes from the neighbor 
+	* discovery or service location protocols.
+	*
+	* @param aIndex
+	*	previous index value, use ZERO to restart scan from beginning. <b>Note</b>: This
+	*	is not same as "interface index", which identifies a interface in the system.
+	* @retval aInfo
+	*	returns the information about the interface.
+	* @return
+	*	index of the current aInfo, or ZERO if there were no more entries to return.
+	*/
+	virtual TUint InterfaceInfo(TUint aIndex, TSoInetInterfaceInfo &aInfo) const = 0;
+	/**
+	* Enumerates route information.
+	* 
+	* This function returns information about the next route after the route identified 
+	* by the input parameter aIndex. To start, call first with aIndex=0, and after 
+	* that always give the previously returned value as a parameter. When the return 
+	* is 0, all routes have been listed. 
+	* 
+	* The returned information is described by TSoInetRouteInfo,
+	* which is the structure used by the Symbian OS v6.1 
+	* IPv4 stack.
+	* 
+	* @param aIndex
+	*	previous index, use ZERO to restart scan from beginning.
+	* @retval aInfo
+	*	returns the information about the route
+	* @return
+	*	index of the current aInfo, or ZERO if there were no more entries to return.
+	*/
+	virtual TUint RouteInfo(TUint aIndex, TSoInetRouteInfo &aInfo) const = 0;
+	/**
+	* Gets an option value.
+	*
+	* Implements some of the options at levels:
+	* @li	KSOLInterface
+	* @li	KSolInetIfQuery
+	*
+	* <b>note</b>: Does not necessarily implement all options on those
+	* levels, just some.
+	*
+	* @param aLevel		Option level
+	* @param aName		Option name
+	* @retval aOption	On return, an option value
+	* @return 			System-wide error code
+	*/
+	virtual TInt GetOption(TUint aLevel, TUint aName, TDes8 &aOption) const = 0;
+	/**
+	* Sets an option value.
+	*
+	* Implement some of the options at levels:
+	* @li	KSolInetIfCtrl
+	* @li	KSOLInterface
+	* @li	KSolInetIfQuery
+	* @li	KSolInetIp
+	* @li	KSolInetRtCtrl
+	*
+	* <b>note</b>: Does not necessarily implement all options on those
+	* levels, just some.
+	*
+	* @param aLevel 	Option level
+	* @param aName 		Option name
+	* @param aOption	An option value
+	* @return 			System-wide error code
+	*/
+	virtual TInt SetOption(TUint aLevel, TUint aName, const TDesC8 &aOption) = 0;
+	/**
+	* Increments the "users" counter.
+	*
+	* The "users" count decides when the network/IP
+	* has no users and the shutdown can be activated. It is
+	* up to the upper layers to decide what exactly is counted as a
+	* "user" in this sense. By default, any socket opened by an
+	* application should count as one user.
+	*
+	* See also #KSoUserSocket socket option. The built-in protocols of the
+	* TCPIP stack (UDP, TCP, ICMP, etc.) support this socket option. Other
+	* protocols, which provide sockets to applications, should also support
+	* this.
+	*
+	* When this count is non-ZERO, the "daemons" (as specified in tcpip.ini)
+	* are running. When count becomes ZERO, the stack kills the daemon
+	* processes.
+	*/
+	virtual void IncUsers() = 0;
+	/**
+	* Decrements the "users" counter.
+	*
+	* For details, see IncUsers().
+	*/
+	virtual void DecUsers() = 0;
+	/**
+	* Gets an string variable setting from the network configuration file (such 
+	* as tcpip.ini).
+	*
+	* The function accesses tcpip.ini using the CESockIniData.
+	*
+	* @param aSection
+	*	the section of INI file to be checked (the string inside
+	*	the brackets in the INI file). Do not include brackets in
+	*	call.
+	* @param aVarName
+	*	the variable within section. CEsockIniData is kludgy, it will
+	*	search for "name=", so beware of using short variable names,
+	*	which are part of the ending of another longer name!
+	* @retval aResult
+	*	returns the pointer to the buffer containing the requested value.
+	*	The returned value must not be stored in any member or other long
+	*	term variable.
+	* @return
+	* @li	TRUE, if value found (aResult has been initialized)
+	* @li	FALSE, if value not found
+	*/
+	virtual TBool FindVar(const TDesC &aSection,const TDesC &aVarName,TPtrC &aResult) = 0;
+	/**
+	* Gets an integer variable setting from the network configuration file (such 
+	* as tcpip.ini).
+	*
+	* The function accesses tcpip.ini using the CESockIniData.
+	*
+	* @param aSection
+	*	the section of INI file to be checked (the string inside
+	*	the brackets in the INI file). Do not include brackets in
+	*	call.
+	* @param aVarName
+	*	the variable within section. CEsockIniData is kludgy, it will
+	*	search for "name=", so beware of using short variable names,
+	*	which are part of the ending of another longer name!
+	* @retval aResult
+	*	returns the value as an integer.
+	* @return
+	* @li	TRUE, if value found (aResult has been initialized)
+	* @li	FALSE, if value not found
+	*/
+	virtual TBool FindVar(const TDesC &aSection,const TDesC &aVarName,TInt &aResult) = 0;
+	/**
+	* Reports a packet has been accepted by some upper layer service provider.
+	*
+	* An upper layer may call this function to ensure that the incoming interface
+	* is not shut down due to lack of traffic. The intention is that only accepted
+	* packet traffic can keep the interface up, and only the upper layer protocol
+	* can know whether packet is accepted or not. The call is important, if the
+	* protocol does not send any packets out to that interface (either because
+	* it's a receive only application, or because outbound packets are routed via
+	* another interface).
+	*
+	* @note
+	*	The interface index should be the value from the RMBufRecvInfo::iOriginalIndex
+	*	field, which represents the real incoming interface.
+	*
+	* @param aInterfaceIndex The index of the interface from which packet originated
+	* @return KErrNotFound, if no such interface, and KErrNone otherwise.
+	*/
+	virtual TInt PacketAccepted(const TUint32 aInterfaceIndex) = 0;
+	/**
+	* Gets an option value.
+	*
+	* Implements some of the options at levels:
+	* @li	KSOLInterface
+	* @li	KSolInetIfQuery
+	*
+	* <b>note</b>: Does not necessarily implement all options on those
+	* levels, just some.
+	*
+	* @param aLevel		Option level
+	* @param aName		Option name
+	* @retval aOption	On return, an option value
+	* @param aChecker	The policy checker
+	* @return 			System-wide error code
+	*/
+	virtual TInt GetOption(TUint aLevel, TUint aName, TDes8 &aOption, MProvdSecurityChecker &aChecker) const = 0;
+	/**
+	* Sets an option value.
+	*
+	* Implement some of the options at levels:
+	* @li	KSolInetIfCtrl
+	* @li	KSOLInterface
+	* @li	KSolInetIfQuery
+	* @li	KSolInetIp
+	* @li	KSolInetRtCtrl
+	*
+	* <b>note</b>: Does not necessarily implement all options on those
+	* levels, just some.
+	*
+	* @param aLevel 	Option level
+	* @param aName 		Option name
+	* @param aOption	An option value
+	* @param aChecker	The policy checker
+	* @return 			System-wide error code
+	*/
+	virtual TInt SetOption(TUint aLevel, TUint aName, const TDesC8 &aOption, MProvdSecurityChecker &aChecker) = 0;
+	};
+
+
+// MNetworkService
+// ***************
+// Basic services provided by the network layer
+//
+class MNetworkService : public MFlowManager
+	/**
+	* Represents the network layer (ip6) of the stack.
+	*
+	* In addition to own functions, the interface encapsulates some often-used
+	* CProtocolBase functions. For other functions, Protocol() gets the real
+	* CProtocolBase-derived object, which can be used for other basic functions
+	* when required. 
+	* @since v7.0
+	* @publishedPartner
+	* @released
+	*/
+	{
+public:
+	/**
+	* Gets the underlying protocol object for the network layer (ip6) of the stack.
+	* @return Protocol object
+	*/
+	virtual CProtocolInet6Binder *Protocol() const = 0;
+	/**
+	* Gets the interface manager for the network layer (ip6) of the stack.
+	* @return Interface manager
+	*/
+	virtual MInterfaceManager *Interfacer() const = 0;
+
+	/**
+	* Sends outgoing packet.
+	*
+	* This is a direct access to the IP layer CProtocolBase::Send function.
+	*
+	* @param aPacket	The packet
+	* @param aSource	Protocol sending the data.
+	*
+	* The IP layer CProtocolBase::Send is the function used by upper layer
+	* protocols to feed in packet to the IP layer. This packet
+	* does not normally have the IPv6 or IPv4 headers (unless the
+	* #KIpHeaderIncluded flag is set the iFlags), and the packet begins
+	* directly with the upper layer protocol header (for example
+	* TInet6HeaderUDP or TInet6HeaderTCP).
+	*
+	* The information block is RMBufSendInfo, which extends the basic
+	* RMBufPktInfo by RFlowContext member. This must be correctly
+	* initialized. The three alternatives are
+@code
+	RFlowContext flow;			// some existing flow
+	MNetworkService *manager;
+	RMBufSendPacket packet;		// unpacked state.
+	RMBufSendInfo *info = packet.Info();
+	TInt res = KErrNone;
+
+	// 1. No flow context (avoid this if you can)
+	info->iFlow = RFlowContext();
+
+	// 2. A new flow context (assuming the base part of info is already set).
+	res = info->iFlow.Open(manager, info->iDstAddr, info->iSrcAddr,
+			info->iProtocol, icmp_type, icmp_code);
+
+	// 3. A reference to existing opened flow (this will load the base part
+	// of the info from the attached flow).
+	res = info->iFlow.Open(flow, info);
+
+	// sending the packet.
+	if (res == KErrNone)
+		{
+		aPacket.Pack();
+		manager->Send(aPacket);
+		}
+	else
+		{
+		// creation failed (res < 0) or is blocked (res > 0)
+		info->iFlow.Close();
+		}
+	aPacket.Free();
+@endcode
+	* The first two are inefficient. They require a full flow open/close sequence
+	* for each packet. The third alternative is the most efficient, because the
+	* same flow is re-used for multiple packets. This also enables the use of
+	* RFlowContext::SetNotify for asynchronous detection of unblocking or error
+	* on the flow.
+	*
+	* The packet goes through the following steps:
+	* -# if a flow context is missing, allocate and connect a new flow
+	* context for the packet. The flow selectors are based on address
+	* and protocol fields of the RMBufPktInfo (alternative 2. in above).
+	* -# if the packet does not have #KIpHeaderIncluded flag set in iFlags
+	* of the info, an IPv4 or IPv6 header is added (based on the value of
+	* CFlowContext::iHead.ip6.Version()). The content of CFlowContext::iHead.iPacket
+	* is copied after the IP header.
+	* -# the packet is passed through the MFlowHook::ApplyL function of
+	* all attached outbound flow hooks.
+	* -# if the packet is longer than the path MTU, it is fragmented. Unless
+	* #KIpDontFragment is set. In that case the stack generates an ICMP error
+	* message "packet too big".
+	* -# the packet (or fragments) are passed through all outbound post
+	* hooks (for example, CProtocolPosthook::Send).
+	* -# the terminator post hook finally passes the packet(s) to the
+	* CFlowContext::Send function, which eventually passes the packet to
+	* the CNifIfBase::Send (the packet may need to be queued for a while
+	* due to neighbor discovery, or just because NIF is blocked).
+	* (see also @ref nif_outbound_packets
+	* )
+	*/
+	virtual TInt Send(RMBufChain &aPacket, CProtocolBase* aSource = NULL) = 0;
+	/**
+	* Processes incoming packet.
+	*
+	* This is a direct accesss to the IP layer CProtocolBase::Process function.
+	*
+	* @param aPacket	The packet
+	* @param aSource	The source of the packet (a NIF)
+	*
+	* The IP layer CProtocolBase::Process is the function used by NIFs to feed
+	* in packets from the link layer. The aSource must be a CNifIfBase derived
+	* object and known to the interface manager of the stack. Otherwise the
+	* IP layer will not accept the packet. The passed packet must follow the rules
+	* as described in @ref nif_inbound_packets
+	* .
+	*
+	* The packet goes through the following process:
+	* -# the packet is pushed through the inbound posthooks as is
+	*	(for example, see CProtocolPosthook::Process), and then queued
+	*	for IP processing.
+	* -# the packet from the queue is processed as an IP packet and
+	*	extension headers are processed by inbound hooks (MIp6Hook::ApplyL)
+	* -# the packet is passed to the upper layer protcool (CProtocolBase::Process)
+	*
+	* If any hook or protocol in the inbound path decides to use this
+	* function to re-inject a (modified) packet back to the system,
+	* then it must remove the packet from the current inbound processing
+	* path.
+	*/
+	virtual void Process(RMBufChain &aPacket, CProtocolBase* aSource = NULL) = 0;
+	/**
+	* Binds a protocol or hook to the network layer.
+	*
+	* This is the same as CProtocolBase::BindL implemented in the
+	* ip6 protocol.
+	*
+	* This is the primary method of installing a upper layer (or some hook)
+	* to the IP layer. The aId determines the type of binding
+	* -	aId == 0, invalid
+	* -	0 < aId <= 255, upper layer bind. The aId is the protocol number
+	*	as defined for the IPv4 (protocol in TInet6HeaderIP4) or IPv6
+	*	(next header in TInet6HeaderIP) header.
+	*	The bind registers aProtocol as an upper layer receiver of all
+	*	packets of this protocol. The receiver protocol must be derived
+	*	from CProtocolBase (but see also CProtocolInet6Binder, which
+	*	can make interfacing easier).
+	* - aid > 255, hook bind. The aId determines the type of binding. The
+	*	bind registers aProtocol as a hook. The hook protocol must be
+	*	derived from CIp6Hook (but, see CProtocolPosthook, which is
+	*	derived from CIp6Hook and provides some automatic support
+	*	for the hook attachment).
+	*
+	* See also @ref bindl_interface
+	* for more information.
+	*
+	* @param aProtocol
+	*	The protocol or hook requesting the bind
+	* @param aId
+	*	The bind id.
+	*/
+	virtual void BindL(CProtocolBase* aProtocol, TUint aId) =  0;
+
+	/**
+	* Sends an ICMP (v4) error message based on a received IP packet.
+	*
+	* This function is used to send an ICMP error message based on
+	* received IP packet (stored in aPacket). aPacket must begin
+	* with the received IP header (either IPv4 or IPv6)
+	* at offset 0.
+	*
+	* The aPacket must be in "unpacked state" for the info block
+	* (assume RMBufRecvPacket::Unpack() has been called).
+	*
+	* The info block is assumed to be RMBufRecvInfo. But, only the
+	* following data is significant:
+	*
+	* @li RMBufPktInfo::iFlags
+	*	only KIpNeverIcmpError flag is tested, and if non-zero, then
+	*	no ICMP error will be generated, and packet is just dropped.
+	* @li RMBufRecvInfo::iIcmp
+	*	must be ZERO. If non-zero, no ICMP error will be generated, and
+	*	packet is just dropped. A non-zero iIcmp indicates that the
+	*	received packet itself is being processed as an ICMP error
+	*	message, and no ICMP error should be generated from ICMP error.
+	* @li RMBufRecvInfo::iInterfaceIndex
+	*	identifies the interface of the received packet. The ICMP error
+	*	message is normally sent to the incoming interface. For any
+	*	received packet, this field is properly initialized and should
+	*	not be touched. If an ICMP error is to be generated from an
+	*	outgoing packet for which no source interface is known,
+	*	one can use ZERO here.
+	* @li all other fields are ignored.
+	*	The source and destination addresses for the ICMP error message
+	*	are constructed from the IP header of the packet. The addresses
+	*	in the info block are ignored.
+	*
+	* @param aPacket
+	*	The received packet for which the ICMP error is being
+	*	generated. This must start with correct IP header (either
+	*	IPv4 or IPv6) at offset 0. (The RMbufRecvInfo::iOffset is
+	*	ignored, and has no significance). The buffer is "consumed"
+	*	by the call, caller does not need to call Free() for the
+	*	Packet.
+	* @param aType
+	*	The type of the ICMP [0..255]
+	* @param aCode
+	*	The code of the ICMP [0..255]
+	* @param aParameter
+	*	The parameter value of the ICMP.
+	* @param aMC
+	*	If non-zero, send ICMP even if the original packet was
+	*	sent to a multicast or broadcast address. Normally,
+	*	ICMP error messages are not generated from multicast packets.
+	*/
+	virtual void Icmp4Send(
+		RMBufRecvPacket &aPacket,	// The problem packet
+		TInt aType,					// ICMP Type
+		TInt aCode = 0,				// ICMP Code
+		TUint32 aParameter = 0,		// (Depends on Type and Code)
+		TInt aMC = 0				// Allow ICMP even if destination was Multicast (if non-zero)
+		) = 0;
+	/**
+	* Sends an ICMP (v6) error message based on a received IP packet.
+	*
+	* See documentation on the MNetworkService::Icmp4Send method
+	* for the parameters.
+	*/
+	virtual void Icmp6Send(
+		RMBufRecvPacket &aPacket,	// The problem packet
+		TInt aType,					// ICMP Type
+		TInt aCode = 0,				// ICMP Code
+		TUint32 aParameter = 0,		// (Depends on Type and Code)
+		TInt aMC = 0				// Allow ICMP even if destination was Multicast (if non-zero)
+		) = 0;
+	//
+	// Default Name services
+	//
+	/**
+	* Gets the default name services provider from the network layer.
+	*
+	* The network layer (IP) provides a gateway to the name
+	* resolver implementation for DNS.
+	*
+	* In EPOC, each protocol is responsible for implementing it's own
+	* name resolution. Any protocol wishing to support RhostResolver
+	* can get the full DNS support from the network layer by just
+	* delegating the call via this method.
+	*
+	* @return Default name services provider
+	*/
+	virtual CHostResolvProvdBase *NewHostResolverL() = 0;
+	/**
+	* Gets the default service resolver provider from the network layer.
+	* Not supported, always leaves.
+	* @return Default service resolver provider
+	*/
+	virtual CServiceResolvProvdBase *NewServiceResolverL() = 0;
+	/**
+	* Gets the default net database provider from the network layer.
+	* Not supported, always leaves.
+	* @return Default net database provider
+	*/
+	virtual CNetDBProvdBase *NewNetDatabaseL() = 0;
+	};
+
+//
+// CProtocolInet6Binder
+// ********************
+class CProtocolInet6Binder : public CProtocolBaseUnbind
+	/**
+	* Base class for protocols that bind to the network layer (IPv6 instance).
+	*
+	* It provides default BindToL() processing, name services, and a pathway to 
+	* the IP layer and interface manager through the MNetworkService class.
+	*
+	* This class was designed for upper layer protocols and the implementation
+	* assumes thet the TServerProtocolDesc::iProtocol contains the id of the
+	* implemented protocol (for example, the id is 6 for TCP and 17 for UDP).
+	* Upper layer protocols can also be implemented using other base classes,
+	* for example CProtocolPosthook. The iProtocol field value is also the
+	* protocol parameter in RSocket::Open function. This, and the address family
+	* determine the protocol module to which the socket is created.
+	*
+	* @note This is also the base class of the IP protocol instance. A hook 
+	* or protocol that binds to or is bound from IP layer, and recognizes it as 
+	* being instance of IP layer, can cast the CProtocolBase into this class and 
+	* then use the NetworkService() to get full access to the network layer. 
+	* @since v7.0
+	* @publishedPartner
+	* @released
+	*/
+	{
+public:
+	IMPORT_C virtual ~CProtocolInet6Binder();
+	IMPORT_C virtual void BindToL(CProtocolBase *aProtocol);
+	IMPORT_C virtual CHostResolvProvdBase *NewHostResolverL();
+	IMPORT_C virtual CServiceResolvProvdBase *NewServiceResolverL();
+	IMPORT_C virtual CNetDBProvdBase *NewNetDatabaseL();
+
+	/**
+	* Gets the network layer (IPv6) of the stack.
+	* @return Network layer (IPv6) of the stack
+	*/
+ 	inline MNetworkService *NetworkService() const
+		/**
+		* Gets the network layer (IPv6) of the stack.
+		* @return Network layer (IPv6) of the stack
+		*/
+		{ return iNetwork; }
+
+protected:
+	IMPORT_C TInt DoBindTo(CProtocolBase *aProtocol);
+
+	/**
+	* Network instance, if non-NULL.
+	*
+	* Initialized and maintained by DoBindTo, The pointer value
+	* should be considered as "read-only" by the derived class.
+	*/
+	MNetworkService *iNetwork;
+	};
+
+
+class MNetworkInfo : public MInetBase
+	/** Interface for getting information on interfaces and routes from IP stack.
+	@publishedPartner
+	@released
+	*/
+	{
+public:
+	/**
+	* Report all interfaces in a single response.
+	*
+	* Fill the given memory block by an array of TInetInterfaceInfo objects
+	* (Note: different from the old socket option structure).
+	*
+	* @param aBuffer Buffer where the data is written
+	*
+	* @return KErrNone (==0) if all interfaces were succesfully written in buffer. If the buffer
+	*	  was too small for all interfaces, return the number of interface blocks that didn't
+	*	  fit in the buffer. In order to get all interfaces, the caller should probably
+	*	  try again with a buffer that is (N * sizeof(TInetInterfaceInfo)) larger. Negative
+	*	  return value indicates some other error.
+	*/
+	virtual TInt GetInterfaces(TDes8& aBuffer) const = 0;
+
+	/**
+	* Report all addresses in a single response.
+	*
+	* Fill the given memory block by an array of TInetAddressInfo objects
+	* (Note: different from the old socket option structure).
+	*
+	* @param aBuffer Buffer where the data is written
+	*
+	* @return KErrNone (==0) if all addresses were succesfully written in buffer. If the buffer
+	*	  was too small for all addresses, return the number of address blocks that didn't
+	*	  fit in the buffer. In order to get all addresses, the caller should probably
+	*	  try again with a buffer that is (N * sizeof(TInetAddressInfo)) larger. Negative
+	*	  return value indicates some other error.
+	*/
+	virtual TInt GetAddresses(TDes8& aBuffer) const = 0;
+
+	/**
+	* Report all routes in a single response. Usage is similar to GetInterfaces and GetAddresses.
+	* Data format is an array of TInetRouteInfo structures.
+	*/
+	virtual TInt GetRoutes(TDes8& aBuffer) const = 0;
+	};
+
+const TUint KApiVer_MNetworkInfo = 2;
+
+
+// Definitions for event service instance used by the tcpip6 stack
+
+/** Number of MEventService event classes used by IP stack. */
+const TUint KNumClassesTcpIp6 = 5;
+
+/** MEventService event classes used by the tcpip6 stack.
+@publishedPartner
+@released
+*/
+enum
+	{
+	EClassRoute = 1,	//< Event on routing table. Data: TInetRouteInfo
+	EClassAddress,		//< Address event on interface. Data: TInetAddressInfo
+	EClassInterface,	//< Interface added or removed. Data: TInetInterfaceInfo
+	EClassMulticast,	//< System has joined or left multicast group. Data: TInetMulticastInfo
+	EClassNeighbour		//< Events on neighbour cache entries. Data: TInetNeighbourInfo
+	};
+
+
+/** MEventService event types used by the tcpip6 stack.
+@publishedPartner
+@released
+*/
+enum
+	{
+	EventTypeAdd = 1,//< Route or IPv6 address (prefix or id) added on an interface.
+	EventTypeDelete,  //< Route or address deleted.
+	EventTypeModify  //< Some parameter of an existing Route or address changed
+	};
+
+#endif