Default ApplyL. The default ApplyL does nothing to the packets.

• MIp6Hook::BindPostHook() (for outbound posthook chaining)

• MIp6Hook::BindPreHook() (for inbound posthook chaining)

• KProtocolInet6Ip (aProtocol must be network instance)

• KProtocolInetIp (aProtocol must be network instance, deprecated)

This network layer detection is only used in a configuration, where this protocol is bound from the network layer (ip6). Such configuration will keep this protocol module installed whenever the network is loaded.

         [yourposthook]
filename= yourposthook.prt
index= 1
bindfrom= ip6
        

The derived class only needs to override the default implementation if it appears as a target of "bindto" directive in a ESK file of another protocol (except the network layer), and if the implementation needs to store a reference to this protocol. In such case the BindL could be, for example:

         CProtocolBase *iAnother;

	CProtocolDerivedHook::BindL(CProtocolBase *aProtocol, TUint aId)
		{
		if (aId == your_special_binding_protocol)
			{
			// handle your bind
			iAnother = aProtocol;
			}
		// The default should always be called,
		CProtocolPosthook::BindL(aProtocol, aId);
		}
        

If the "bindto" list of this protocol can have other protocols than the network (ip6), then the derived class must implement the support for it. For example

         CProtocolDerivedHook::BindToL(CProtocolBase *aProtocol)
		{
		const TInt id = DoBindToL(aProtocol);
		if (id == (TInt)your_special_protocol)
			{
			//
			if (iBindTo)
				iBindTo->Close();
			iBindTo = aProtocol;
			iBindTo->Open();
			// Destructor must issue Close, if iBindTo is non-NULL
			}
		else if (id != KErrNone)
			User::Leave(KErrNotSupported);
		}
        

This function exists for derived classes that override the default BindToL for their own processing. See BindToL for example.

This function is called when the network layer is detected and attached to this protocol object (NetworkService() returns non-null). The implementation in the derived class can now do the hook specific binds and unbinds using:

         // request inbound packets to my Process()
	NetworkService()->BindL(this, MIp6Hook::BindPreHook());
	// request outbound packets to my Send().
	NetworkService()->BindL(this, MIp6Hook::BindPostHook());
	...
	// stop getting inbound packets to my Process()
	NetworkService()->Unbind(this, MIp6Hook::BindPreHook());
	// stop getting outbound packets to my Send()
	NetworkService()->Unbind(this, MIp6Hook::BindPostHook());
	// ..or, to rip off all my hooks
	NetworkService()->Unbind(this);
        

Process passes the inbound packet to the next pre-processing hook ( iInboundHook ). The derived pre-processing hook can implement own Process. After processing the packet, it would normally call CProtocolPosthook::Process to pass the packet forward (note that the information block is the basic RMBufPktInfo ).

         TInt CProtocolDerivedHook::Process(RMBufChain &aPacket, CProtocolBase *aSrc)
		{
		// Do own packet processing.

		RMBufPktInfo *info = RMBufPacketBase::PeekInfoInChain(aPacket);
		...
		if (packet_is_dropped)
			aPacket.Free();
		else
			CProtocolPosthook::Process(aPacket, aSrc);
		}
        

Hook will receive and pass forward inbound packets only if it has bound as pre-processing hook:

         NetworkService()->BindL(this, MIp6Hook::BindPreHook());
        

Send passes the outbound packet to the next post-processing hook ( iPostHook ). The derived post-processing hook can mplement own Send, After processing the packet, it would normally call CProtocolPosthook::Send to pass the packet forward (note that the information block is RMBufSendInfo and the attached flow context ( RFlowContext ) must be closed , if the packet is deleted):

         TInt CProtocolDerivedHook::Send(RMBufChain &aPacket, CProtocolBase *aSrc)
		{
		...
		// Do own packet processing

		if (packet_is_dropped)
			{
			RMBufSendInfo *info = RMBufSendPacket::PeekInfoInChain(aPacket);
			if (info)
				info->iFlow.Close();
			aPacket.Free();
			return 1;
			}
		else
			return CProtocolPosthook::Send(aPacket, aSrc);
		}
        

Hook will receive and pass forward the outbound packets only if it has a binding to the network layer as a post-processinghook:

         NetworkService()->BindL(this, MIp6Hook::BindPostHook());
        

If hook is configured to receive packets to Send function from some other protocol than the network layer, then it can use the aSrc to detect this and NOT call this default implementation for such packets (unless it intends to inject them to the outbound packet stream).

Pre-condition

RMBufSendPacket::PeekInfoInChain(aPacket).iFlow.IsOpen()

• MIp6Hook::BindPostHook() (for outbound posthook chaining)

• MIp6Hook::BindPreHook() (for inbound posthook chaining)

• KProtocolInet6Ip (for the network intance)

• KProtocolInetIp (for network instance, deprecated)

• 0 (unbind all)

The derived class needs to override the default implementation only if it is bound from another protocol (except the network layer) and if class also overrode the CProtocolPosthook::BindL and saved a pointer to this protocol. For example:

         CProtocolDerivedHook::Unbind(CProtocolBase *aProtocol, TUint aId)
		{
		if (iAnother == aProtocol &&
			(aId == 0 || aId == your_special_binding_protocol))
			{
			// handle your unbind
			iAnotherProtocol = NULL;
			}
		// The default should always be called,
		CProtocolPosthook::Unbind(aProtocol, aId);
		}
        

• if == 1, bindto= ip6 is in the "hook" ESK file. iNetwork has been set by CProtocolPosthook::DoBindToL .

• if == 0, bindto= hook is in the [ip6] section of the TCPIP6.ESK. iNetwork has been set by the CProtocolPosthook::BindL .