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

// icmp.cpp - dual IPv4/IPv6 ICMP protocol

// This implements two separate protocol modules (icmp and

// icmp6). Unlike other transport layers (tcp and udp), ICMP has

// different protocol identifier in IPv4 and IPv4. Thus, two separate

// protocol instances is a requirement.

//

#include "inet6log.h"

#include "icmp6.h"

#include "in_net.h"

#include <icmp6_hdr.h>

#include <in_pkt.h>

_LIT(KIcmpName, "icmp");

_LIT(KIcmp6Name, "icmp6");

//

//	CProtocolICMP

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

//	The implementation and methods of the CProtocolICMP4/6 is totally internal

//	to this module. No other module needs to be aware of this.

//	Thus the class definition is included here.

//

class CProtocolICMP : public CProtocolInet6Network

	{

public:

	CProtocolICMP(TInt aProtocol);

	virtual ~CProtocolICMP();

	virtual CServProviderBase *NewSAPL(TUint aProtocol);

	virtual void Process(RMBufChain &aPacket,CProtocolBase* aSourceProtocol=NULL);

	virtual TInt Send(RMBufChain &aPacket,CProtocolBase* aSourceProtocol=NULL);

	virtual void Identify(TServerProtocolDesc *) const;

protected:

	const TInt iProtocol;

	};

//	*****

//	ICMP6

//	*****

CProtocolBase *ICMP6::NewL(TInt aVersion)

	{

	return new (ELeave) CProtocolICMP(aVersion);

	}

void ICMP6::Identify(TServerProtocolDesc &aEntry, TInt aVersion)

	{

	if (aVersion == STATIC_CAST(TInt, KProtocolInetIcmp))

		{

		aEntry.iName = KIcmpName;

		aEntry.iProtocol=KProtocolInetIcmp;

		}

	else

		{

		aEntry.iName = KIcmp6Name;

		aEntry.iProtocol=KProtocolInet6Icmp;

		}

	aEntry.iAddrFamily=KAfInet;

	aEntry.iSockType=KSockDatagram;

	aEntry.iVersion=TVersion(KInet6MajorVersionNumber, KInet6MinorVersionNumber, KInet6BuildVersionNumber);

	aEntry.iByteOrder=EBigEndian;

	aEntry.iServiceInfo=KICMP6ServiceInfo;

	aEntry.iNamingServices=KICMP6NameServiceInfo;

	aEntry.iSecurity=KSocketNoSecurity;

	aEntry.iMessageSize=KICMP6MaxDatagramSize;

	aEntry.iServiceTypeInfo=KICMP6ServiceTypeInfo;

	aEntry.iNumSockets=KICMP6MaxSockets;

	}

//

//

//	CProtocolICMP* constructors and destructors

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

CProtocolICMP::CProtocolICMP(TInt aId) : iProtocol(aId)

	{

	__DECLARE_NAME(_S("CProtocolICMP"));

	}

CProtocolICMP::~CProtocolICMP()

	{

	}

//

// CProtocolICMP::NewSAPL

//	Create a new instance of a CServProviderBase (SAP) for the

//	socket manager. The caller is responsible for the bookkeeping

//	and destruction of this created object!

//

CServProviderBase* CProtocolICMP::NewSAPL(TUint aSockType)

	{

	return ICMP6::NewSAPL(aSockType, this, iProtocol);

	}

void CProtocolICMP::Identify(TServerProtocolDesc *aInfo) const

	{

	ICMP6::Identify(*aInfo, iProtocol);

	}

//

// CProtocolICMP::Send()

//

//	Pass the packet as is to the IP layer. This method is

//	supposed to be used by the ICMP Service provider modules

//	to forward their packets down the stack.

//

//	ICMP makes no checks on validity or format of the packet

//

TInt CProtocolICMP::Send(RMBufChain &aPacket,CProtocolBase* /*aSourceProtocol*/)

	{

	return iNetwork->Send(aPacket);

	}

void CProtocolICMP::Process(RMBufChain &aPacket,CProtocolBase * /*aSourceProtocol*/)

	{

	RMBufRecvPacket packet;

	packet.Assign(aPacket);

	for (;;) // ONLY FOR NEAT BREAK EXITS -- NOT A LOOP

		{

		RMBufRecvInfo *const info = packet.Unpack();

		if (info == NULL)

			break;

		LOG(Log::Printf(_L("\t%S Process(%d bytes)"), &ProtocolName(), info->iLength));

		if (info->iIcmp)

			{

			// This packet is actually an ICMP error report to an ICMP sent by

			// this host. The iOffset points to "inner" ICMP, but tradionally

			// ICMP applications expect the outer RAW ICMP's, thus, change

			// the iOffset and other fields accordingly

			info->iOffset = info->iOffsetIp - 8 /* 8 = ICMP header size*/;

			info->iProtocol = info->iIcmp;

			// *NOTE*

			//	The following assumes that outer IP tunnels have been removed

			//	from the packet. Then, it can be assumed that the IP header

			//	related to ICMP error is at the beginning of the packet (offset=0).

			info->iOffsetIp = 0;

			const MInterface *const mi = NetworkService()->Interfacer()->Interface(info->iInterfaceIndex);

			if (mi == NULL)

				break;

			TIpHeader *const ip = ((RMBufPacketPeek &)packet).GetIpHeader();

			if (ip == NULL)

				break;

			TInetAddr &src = TInetAddr::Cast(info->iSrcAddr);

			TInetAddr &dst = TInetAddr::Cast(info->iDstAddr);

			if (ip->ip4.Version() == 4)

				{

				src.SetV4MappedAddress(ip->ip4.SrcAddr());

				dst.SetV4MappedAddress(ip->ip4.DstAddr());

				}

			else

				{

				src.SetAddress(ip->ip6.SrcAddr());

				dst.SetAddress(ip->ip6.DstAddr());

				}

			const TIp6Addr &src_ip = src.Ip6Address();

			const TIp6Addr &dst_ip = dst.Ip6Address();

			src.SetScope(mi->Scope((TScopeType)(src_ip.Scope()-1)));

			dst.SetScope(mi->Scope((TScopeType)(dst_ip.Scope()-1)));

			}

		// Check "payload length", and don't even try delivering truncated ICMP packets.

		if (info->iLength - info->iOffset < TInet6HeaderICMP::MinHeaderLength())

			break;

		Deliver(packet);

		// *ALWAYS BREAK OUT FROM LOOP*

		break;

		}

	packet.Free();

	}