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

// ip6_doh.cpp - hooks for IPv6 protocol message options

// Default IPv6 Options Hooks (Hop-by-Hop and Destination Options)

//

#include "ip6_doh.h"

#include <in_pkt.h>

#include <ext_hdr.h>

#include <icmp6_hdr.h>

#include "addr46.h"

#include "inet6log.h"

//

// *NOTE*

//		With the autumn 2000 hook api changes, there is no reason

//		allocate two different objects for DOP and HBH. The same

//		object could handle both and bind for both. This is

//		because aInfo.iProtocol can now be used to differentiate

//		the two, if needed! -- msa [for future cleanup..]

//

// CDestinationOptionsHook::ConstructL

//

void CDestinationOptionsHook::ConstructL()

	{

	iProtocol->BindL((CProtocolBase *)this, BindHookFor(KProtocolInet6DestinationOptions));

	}

//

// CHopOptionsHook::ConstructL

//

void CHopOptionsHook::ConstructL()

	{

	iProtocol->BindL((CProtocolBase *)this, BindHookFor(KProtocolInet6HopOptions));

	}

//

//	CDefaultOptionsHook::ApplyL

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

//	The default Options processing (code shared by Destination Options and

//	Hop-by-Hop Options).

//

TInt CDefaultOptionsHook::ApplyL(RMBufHookPacket &aPacket, RMBufRecvInfo &aInfo)

	{

	if (aInfo.iVersion == 4)

		{

		//

		// Do not process HBH or DOP for IPv4. Returning PASS

		// will cause the main loop eventually to treat this

		// as unknown header, if nothing else handles it.

		//

		return KIp6Hook_PASS;

		}

	for (;;)	// .. just for exits.. not a loop..

		{

		TInet6Packet<TInet6Options> oh(aPacket, aInfo.iOffset);

		if (oh.iHdr == NULL)

			break;	// Bad packet, not enough for even the basic header

		const TInt hdrlen = aInfo.CheckL(oh.iHdr->HeaderLength());

		const TInt next_header = oh.iHdr->NextHeader();

		if (aInfo.iIcmp == 0)

			{

			//

			// Normal Option Header Handling

			//

			TInt count = hdrlen - TInet6Options::O_Options;			// Count of bytes in actual options.

			TInt start = aInfo.iOffset + TInet6Options::O_Options;	// Offset of the first

			//

			// Possibly heavy overhead, brute RMBuf Goto application

			// (but should work always)

			//

			while (count > 0)

				{

				RMBuf *p;

				TInt offset, len;

				TUint8 *ptr, type;

				if (!aPacket.Goto(start, p, offset, len))

					goto drop_packet;

				ptr = p->Buffer() + offset;

				switch ((type = *ptr++))

					{

				case 0:	// Pad1

					count--;

					start++;

					break;

#if 0

				case KDstOptionHomeAddress:

					if (aInfo.iProtocol == STATIC_CAST(TInt, KProtocolInet6DestinationOptions) &&

						// ..just check that there is enough stuff in the buffer

						// for the IPv6 address, so that the following CopyOut

						// does not panic. If not, just fall through. Should

						// do some better validity checking someday -- msa

						STATIC_CAST(TUint, count) >= sizeof(TIp6Addr)+2)

						{

						// This is shared between DOP and HBH, but this option is only

						// accepted in the DestinationOptions. The home address value

						// is simply copied to the aInfo.iDstAddr!

						//

						TIp6Addr home;

						TPtr8 ptr(home.u.iAddr8, sizeof(home.u.iAddr8), sizeof(home.u.iAddr8));

						aPacket.CopyOut(ptr, start+2);

						TInetAddr::Cast(aInfo.iSrcAddr).SetAddress(home);

#ifdef _LOG

							{

							TBuf<70> tmp_src;

							TInetAddr::Cast(aInfo.iSrcAddr).OutputWithScope(tmp_src);

							Log::Printf(_L("CDefaultOptionsHook::ApplyL: HOMEADDRESS src=[%S]\r\n"), &tmp_src);

							}

#endif

						aInfo.iFlags &= ~KIpAddressVerified;		// Request Address Check!

						goto skip_option;

						}

#endif

					// If not handled, fall unknown option handling!

				default:

					//

					// Unknown options

					//

					// 11 - send ICMP only if not Multicast dst

					// 10 - send ICMP

					// 01 - drop without ICMP

					// 00 - skip and continue

					//

					// (use HookValue with keyid=(protocol | (type << 8)) to check if someone else

					// already handled/implemented this option!)

					//

					if ((type & 0xC0) != 0 && aPacket.HookValue(aInfo.iProtocol | (type << 8)) == 0)

						{

						type &= 0xC0;

						if (type == 0xC0)

							{

							if (TIp46Addr::Cast(TInetAddr::Cast(aInfo.iDstAddr).Ip6Address()).IsMulticast())

								goto drop_packet;

							}

						else if (type != 0x80)

							goto drop_packet;

						//

						// Either 11 without multicast or 10, send ICMP6 Parameter Promblem,

						//

						iProtocol->Icmp6Send(aPacket, KInet6ICMP_ParameterProblem, 2, start, 1 /* Allow MC destination */);

						return -1;

						}

					//

					// 00 - Skip Over

					//

					// ** FALL THROUGH TO THE PadN handling, skip option **

				case 1:	// PadN

#if 0

skip_option:

#endif

					--len;

					while (len == 0)	// Should loop only once, but 'while' just in

										// case someone wants RMBuf with zero length...

						{

						p = p->Next();

						if (p == NULL)

							goto drop_packet;

						len = p->Length();

						ptr = p->Ptr();

						}

					count -= 2 + *ptr;

					start += 2 + *ptr;

					break;

					}

				}

			// Fall to "header processed"!

			}

		else if (aInfo.iIcmp == KProtocolInet6Icmp)

			{

			//

			// ICMP6 Problem report for a packet

			//

			const TInt offset = aInfo.iOffset - aInfo.iOffsetIp;	// Relative offset within problem packet

			if (aInfo.iType == KInet6ICMP_ParameterProblem &&	// A parameter problem...

				offset <= (TInt)aInfo.iParameter &&			// after start of this header?

				offset + hdrlen > (TInt)aInfo.iParameter)		// and before end of this header?

				break;		// Drop!

			// Fall to "header processed"!

			}

		else

			{

			//

			// ICMP v4 problem report (or something else)

			//

			// * just drop it for now*

			//

			break;

			}

		//

		// Gets Here only if the header is "processed" successfully

		// Remove options header, pass error processing to the next header

		//

		aInfo.iPrevNextHdr = (TUint16)aInfo.iOffset;	// Dest. Opt next header is at +0

		aInfo.iProtocol = next_header;

		aInfo.iOffset += hdrlen;

		return KIp6Hook_DONE;

		}

	//

	// All breakouts from the above "loop" cause the packet to be dropped

	//

drop_packet:

	aPacket.Free();

	return -1;

	}