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).

• RMBufPktInfo::iFlags only KIpNeverIcmpError flag is tested, and if non-zero, then no ICMP error will be generated, and packet is just dropped.

• 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.

• 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.

• 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.

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 nif_inbound_packets The packet goes through the following process:

1. the packet is pushed through the inbound posthooks as is (for example, see CProtocolPosthook::Process), and then queued for IP processing.

2. the packet from the queue is processed as an IP packet and extension headers are processed by inbound hooks (MIp6Hook::ApplyL)

3. the packet is passed to the upper layer protcool (CProtocolBase::Process)

The information block is RMBufSendInfo, which extends the basic RMBufPktInfo by RFlowContext member. This must be correctly initialized. The three alternatives are

	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();

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:

1. 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).

2. 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.

3. the packet is passed through the MFlowHook::ApplyL function of all attached outbound flow hooks.

4. 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".

5. the packet (or fragments) are passed through all outbound post hooks (for example, CProtocolPosthook::Send).

6. 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 nif_outbound_packets )