// Copyright (c) 2006-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:

// udp.cpp - UDP protocol for IPv6/IPv4

//

#include "udp.h"

#include <icmp6_hdr.h>

#include <ip4_hdr.h>

#include <in6_if.h>

#include "tcpip_ini.h"

#include "inet6log.h"

#define SYMBIAN_NETWORKING_UPS

//

// UDP Protocol Description

//

void CProtocolUDP6::Describe(TServerProtocolDesc &aDesc)

	{

	aDesc.iName		  = _S("udp");

	aDesc.iAddrFamily	  = KAfInet;

	aDesc.iSockType	  = KSockDatagram;

	aDesc.iProtocol	  = KProtocolInetUdp;

	aDesc.iVersion	  = TVersion(KInet6MajorVersionNumber,

								KInet6MinorVersionNumber,

								KInet6BuildVersionNumber);

	aDesc.iByteOrder	  = EBigEndian;

	aDesc.iServiceInfo	  = KSIConnectionLess | KSIDatagram |

							KSIGracefulClose | KSIPeekData |

							KSIRequiresOwnerInfo;

	aDesc.iNamingServices	  = KNSNameResolution | KNSRequiresConnectionStartup;

	aDesc.iSecurity	  = KSocketNoSecurity;

	aDesc.iMessageSize	  = 65536-128; /*KSocketMessageSizeUndefined;*/

	aDesc.iServiceTypeInfo  = ESocketSupport | ETransport |

							EPreferMBufChains | ENeedMBufs |

							EUseCanSend;

	aDesc.iNumSockets	  = KUnlimitedSockets;

	}

CProtocolUDP6::CProtocolUDP6()

	{

	__DECLARE_NAME(_S("CProtocolUDP6"));

	}

CProtocolUDP6::~CProtocolUDP6()

	{

	}

CServProviderBase* CProtocolUDP6::NewSAPL(TUint aSockType)

	{

	LOG(Log::Printf(_L("NewSAPL\tudp SockType=%d"), aSockType));

	if (aSockType!=KSockDatagram)

		User::Leave(KErrNotSupported);

	CProviderUDP6 *sap = new (ELeave) CProviderUDP6(this);

	CleanupStack::PushL(sap);

	sap->InitL();

	CleanupStack::Pop();

	LOG(Log::Printf(_L("NewSAPL\tudp SAP[%u] OK"), (TUint)sap));

	return sap;

	}

void CProtocolUDP6::InitL(TDesC& aTag)

	{

	CProtocolInet6Transport::InitL(aTag);

	}

void CProtocolUDP6::StartL()

	{

	CProtocolInet6Transport::StartL();

	iRecvBuf = GetIniValue(TCPIP_INI_UDP, TCPIP_INI_UDP_RECV_BUF, KUdpDefaultRecvBuf, 1, KMaxTInt);

	// Flags on by default

	iWaitNif = GetIniValue(TCPIP_INI_UDP, TCPIP_INI_UDP_WAIT_NIF, 1, 0, 1);

	}

void CProtocolUDP6::Identify(TServerProtocolDesc *aInfo) const

	{

	Describe(*aInfo);

	}

TInt CProtocolUDP6::Send(RMBufChain& aPacket,CProtocolBase* /*aSourceProtocol=NULL*/)

	{

	LOG(Log::Printf(_L("\tudp Send(%d bytes)"), RMBufSendPacket::PeekInfoInChain(aPacket)->iLength));

	return iNetwork->Send(aPacket);

	}

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

	{

	RMBufRecvPacket datagram;

	datagram.Assign(aPacket);

	RMBufRecvInfo* info = datagram.Unpack();

	TInet6PacketUDP pkt(datagram, info->iOffset);

	TInet6Packet<TInet6HeaderIP4> ip4;

	TInet6Packet<TInet6HeaderIP>  ip6;

	TInt err = KErrNone;

	TInt version(0);

	CProviderUDP6 *sap = NULL;

	TInetAddr icmpSender;

#ifdef _LOG

	TBuf<50> src, dst;

	LOG(Log::Printf(_L("\tudp Process(%d bytes)"), datagram.Length()));

#endif

	ASSERT(info->iLength == datagram.Length());

	//

	// Preliminary checking for both UDP and ICMP

	//

	switch (info->iProtocol)

		{

	case KProtocolInetUdp:

		// Sanity checking

		if (!pkt.iHdr)

			{

			LOG(Log::Printf(_L("\tudp Process() Runt packet discarded")));

			datagram.Free();

			return;

			}

#ifdef _LOGx

		TInetAddr(info->iSrcAddr).OutputWithScope(src); TInetAddr(info->iDstAddr).OutputWithScope(dst);

		LOG(Log::Printf(_L("\tudp Process(%d bytes) {%S,%d} -> {%S,%d}"),

			datagram.Length(), &src, pkt.iHdr->SrcPort(), &dst, pkt.iHdr->DstPort()));

#endif

		// More sanity checking.

		if (pkt.iHdr->SrcPort() == KInetPortNone || pkt.iHdr->DstPort() == KInetPortNone)

			{

			LOG(Log::Printf(_L("\tudp Process() Zero port. Packet discarded.")));

			datagram.Free();

			return;

			}

		break;

	default:

		LOG(Log::Printf(_L("\tudp Process() Unknown protocol. Packet discarded.")));

		datagram.Free();

		return;

		}

	switch (info->iIcmp)

		{

	case 0:

		// Check source address

		if (!TInetAddr::Cast(info->iSrcAddr).IsUnicast() && !TInetAddr::Cast(info->iSrcAddr).IsUnspecified())

			{

			LOG(Log::Printf(_L("\tudp Process() Invalid source address. Packet discarded.")));

			datagram.Free();

			break;

			}

		// Sanity checking

		if (info->iLength != info->iOffset + pkt.iHdr->Length())

			{

			LOG(Log::Printf(_L("\tudp Process() Size mismatch. Packet discarded.")));

			datagram.Free();

			break;

			}

		// Process UDP checksum. Check for no checksum (legal in UDP/IPv4)

		if (pkt.iHdr->Checksum() ? !pkt.VerifyChecksum(datagram, info, info->iOffset) : info->iVersion != 4)

			{

			LOG(Log::Printf(_L("\tudp Process() Bad checksum. Packet discarded.")));

			datagram.Free();

			return;

			}

		//LOG(Log::Printf(_L("Verified UDP checksum %04x."), pkt.iHdr->Checksum()));

		// Get port numbers from header

		info->iSrcAddr.SetPort(pkt.iHdr->SrcPort());

		info->iDstAddr.SetPort(pkt.iHdr->DstPort());

#ifdef _LOG

		TInetAddr(info->iSrcAddr).OutputWithScope(src); TInetAddr(info->iDstAddr).OutputWithScope(dst);

		LOG(Log::Printf(_L("\tudp Process() UDP datagram {%S,%d} -> {%S,%d}"),

			&src, info->iSrcAddr.Port(), &dst, info->iDstAddr.Port()));

#endif

		// Advance iOffset over the UDP header

		info->iOffset += pkt.iHdr->HeaderLength();

		//

		// Replicate packets to all receivers.

		// If there is only a single receiver,

		// no extra packet copies will be made.

		//

		CProviderUDP6 *s;

		version = info->iVersion == 4 ? KAfInet : KAfInet6;

		// Locate hash bucket and traverse hash chain

		s = (CProviderUDP6*)CProtocolInet6Base::LocateProvider(info->iDstAddr.Port());

		// Locate best match if exists

	    if (s)

	    	{

	    	if (!s->iNextSAP) // only one possible receiver in hash entry

	    		{

				// Locate best match

#ifndef SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

				sap = (CProviderUDP6*)LocateSap(EMatchServerUnspecAddr,

					version, info->iDstAddr, info->iSrcAddr, s);	    		

#else

				sap = (CProviderUDP6*)LocateSap(EMatchServerUnspecAddr,

					version, info->iDstAddr, info->iSrcAddr, s,info->iInterfaceIndex);	    		

#endif //SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

	    		}

	    	else // Multiple possible receivers in hash entry

	    		{

#ifndef SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

				sap = (CProviderUDP6*)LocateSap(EMatchServerSpecAddr, //Since this is UDP we are only interested in the dst Ip addr

					version, info->iDstAddr, info->iSrcAddr, s);

#else

				sap = (CProviderUDP6*)LocateSap(EMatchServerSpecAddr, //Since this is UDP we are only interested in the dst Ip addr

					version, info->iDstAddr, info->iSrcAddr, s,info->iInterfaceIndex);

#endif //SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

				if (!sap) // no explicit connections

					{

					for (; s != NULL; s = (CProviderUDP6*)s->iNextSAP)

						{

						// Locate next match

#ifndef SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

						s = (CProviderUDP6*)LocateSap(EMatchServerUnspecAddr,

							version, info->iDstAddr, info->iSrcAddr, s);

#else

						s = (CProviderUDP6*)LocateSap(EMatchServerUnspecAddr,

							version, info->iDstAddr, info->iSrcAddr, s,info->iInterfaceIndex);

#endif //SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

						// No match?

						if (s == NULL)

							break;

#ifdef SYMBIAN_NETWORKING_UPS

						if (!s->HasNetworkServices() && (!s->ConnectionInfoSet())&& (info->iFlags & KIpLoopbackPacket) == 0)

#else

						if (!s->HasNetworkServices() && (info->iFlags & KIpLoopbackPacket) == 0)

#endif

							{

							LOG(Log::Printf(_L("\tudp SAP[%u] Not allowed to receive external packets"), (TInt)s));

							continue;

							}

						// More than one receiver found? Copy the packet.

						if (sap != NULL)

							{

							RMBufRecvPacket copy;

							TRAPD(err, datagram.CopyL(copy);datagram.CopyInfoL(copy));

							if (err == KErrNone)

								{

								copy.Pack();

								sap->Process(copy);

								}

							copy.Free();

							}

						// Remember last match

						sap = s;

						}

					}

	    		}

	    	}

		// No match? Respond with ICMP

		if (sap == NULL)

			{

            /* From RFC1122:

			If a datagram arrives addressed to a UDP port for which

			there is no pending LISTEN call, UDP SHOULD send an ICMP

			Port Unreachable message.*/

			LOG(LogProviders(info->iDstAddr.Port()));

			// Include UDP header in ICMP payload

			info->iOffset -= pkt.iHdr->HeaderLength();

			if (info->iVersion == 4)

				iNetwork->Icmp4Send(datagram, KInet4ICMP_Unreachable, 3 /* port unreachable*/);

			else

				iNetwork->Icmp6Send(datagram, KInet6ICMP_Unreachable, 4 /* port unreachable*/);

			}

		else

			{

#ifdef SYMBIAN_NETWORKING_UPS

			if (!sap->HasNetworkServices() && (!sap->ConnectionInfoSet()) && (info->iFlags & KIpLoopbackPacket) == 0)

#else

			if (!sap->HasNetworkServices() && (info->iFlags & KIpLoopbackPacket) == 0)

#endif

				{

				LOG(Log::Printf(_L("\tudp SAP[%u] Not allowed to receive external packets"), (TInt)sap));

				datagram.Free();

				break;

				}

			const TInt iface = info->iOriginalIndex;

			// Punt the packet to the SAP

			datagram.Pack();

			sap->Process(datagram);

			// Reset idle timers

			Interfacer()->PacketAccepted(iface);

			}

		break;

	case KProtocolInetIcmp:

	case KProtocolInet6Icmp:

		// Get port numbers from header

		info->iSrcAddr.SetPort(pkt.iHdr->SrcPort());

		info->iDstAddr.SetPort(pkt.iHdr->DstPort());

#ifdef _LOG

		TInetAddr(info->iSrcAddr).OutputWithScope(src); TInetAddr(info->iDstAddr).OutputWithScope(dst);

		LOG(Log::Printf(_L("\tudp Process() ICMP reply to UDP datagram {%S,%d} -> {%S,%d}"),

			&src, info->iSrcAddr.Port(), &dst, info->iDstAddr.Port()));

		LOG(Log::Printf(_L("\tudp Process() ICMP type=%d code=%d param=%d received."),

			info->iType, info->iCode, info->iParameter));

#endif

		sap = (CProviderUDP6*)LocateSap(EMatchServerUnspecAddr,

			info->iVersion == 4 ? KAfInet : KAfInet6,

			info->iSrcAddr, info->iDstAddr);

		if (sap == NULL)

			{

			LOG(Log::Printf(_L("\tudp Process() No socket. Discarding ICMP message.")));

			datagram.Free();

			break;

			}

		err = KErrUnknown;

		if (info->iIcmp == KProtocolInetIcmp)

			{

			//

			// ICMPv4 message processing

			//

			ip4.Set(datagram, 0, TInet6HeaderIP4::MinHeaderLength());

			if (!ip4.iHdr)

				{

				LOG(Log::Printf(_L("\tudp Process() Invalid IPv4 header in ICMP.")));

				datagram.Free();

				break;

				}

			icmpSender.SetAddress(ip4.iHdr->SrcAddr());

			switch (info->iType)

				{

			case KInet4ICMP_Unreachable:

/*

   Code           0 = net unreachable

                  1 = host unreachable

                  2 = protocol unreachable

                  3 = port unreachable

                  4 = fragmentation needed and DF set

                  5 = source route failed

                  6 = destination network unknown

                  7 = destination host unknown

                  8 = source host isolated

                  9 = communication with destination network administratively prohibited

                 10 = communication with destination host administratively prohibited

                 11 = network unreachable for type of service

                 12 = host unreachable for type of service

				*/

				switch (info->iCode)

					{

				case 2:

					err = KErrNoProtocolOpt;

					break;

				case 3:

					err = KErrCouldNotConnect;

					break;

				case 4:

					err = KErrTooBig;

					break;

				case 0:

				case 5:

				case 6:

				case 8:

				case 9:

				case 11:

					err = KErrNetUnreach;

					break;

				case 1:

				case 7:

				case 10:

				case 12:

					err = KErrHostUnreach;

					break;

				default:

					break;

					}

				break;

			case KInet4ICMP_SourceQuench:

				break;

			case KInet4ICMP_TimeExceeded:

				err = KErrTimedOut;

				break;

			case KInet4ICMP_ParameterProblem:

				err = KErrArgument;

				break;

			default:

				break;

				}

			}

		else

			{

			//

			// ICMPv6 message processing

			//

			ip6.Set(datagram, 0, TInet6HeaderIP::MinHeaderLength());

			if (!ip6.iHdr)

				{

				LOG(Log::Printf(_L("\tudp  Process() Invalid IPv6 header in ICMP.")));

				datagram.Free();

				break;

				}

			icmpSender.SetAddress(ip6.iHdr->SrcAddr());

			switch (info->iType)

				{

			case KInet6ICMP_Unreachable:

/*

   Code           0 - no route to destination

                  1 - communication with destination administratively prohibited

                  2 - (not assigned)

                  3 - address unreachable

                  4 - port unreachable

				*/

				switch (info->iCode)

					{

				case 3:

					err = KErrHostUnreach;

					break;

				case 4:

					err = KErrCouldNotConnect;

					break;

				default:

					err = KErrNetUnreach;

					break;

					}

				break;

			case KInet6ICMP_PacketTooBig:

				err = KErrTooBig;

				break;

			case KInet6ICMP_TimeExceeded:

/*

   Code           0 - hop limit exceeded in transit

                  1 - fragment reassembly time exceeded

				*/

				err = KErrTimedOut;

				break;

			case KInet6ICMP_ParameterProblem:

/*

   Code           0 - erroneous header field encountered

                  1 - unrecognized Next Header type encountered

                  2 - unrecognized IPv6 option encountered

				*/

				err = KErrArgument;

				break;

			default:

				break;

				}

			}

		// Store and report

		sap->IcmpError(err, MSocketNotify::EErrorSend|MSocketNotify::EErrorRecv,

			info->iType, info->iCode,

			TInetAddr::Cast(info->iSrcAddr),

			TInetAddr::Cast(info->iDstAddr),

			TInetAddr::Cast(icmpSender));

		datagram.Free();

		break;

	default:

		datagram.Free();

		break;

		}

	}