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

// in_addr.cpp - IPv6/IPv4 socket library

//

#include <in_sock.h>

#include "in6_opt.h"

//

// DLL entry point

//

const TInt KIPv4AddressPartCount = 4;

//

//

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

//	Primitive methods on raw IPv6 Address

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

//	(some could be inlined later)

//

EXPORT_C TBool TIp6Addr::IsUnicast() const

	/**

	* Tests if the address is IPv6 unicast.

	* @return

	*	ETrue, if the address is unicast (not IPv6 unspecified or multicast);

	*	EFalse, otherwise.

	* @since 7.0

	*/

	{

	return !(IsMulticast() || IsUnspecified());

	}

EXPORT_C TBool TIp6Addr::IsMulticast() const

	/**

	* Tests if the IPv6 address is multicast.

	* @return

	*	ETrue, if the IP address value is IPv6 multicast (<tt>ff00::/8</tt>);

	*	EFalse, otherwise.

	* @since 7.0

	*/

	{

	return u.iAddr8[0] == 0xFF;

	}

EXPORT_C TBool TIp6Addr::IsLoopback() const

	/**

	* Tests if the address is IPv6 loopback. 

	* @return

	*	ETrue, if the address is loopback  (<tt>::1</tt>);

	*	EFalse, otherwise.

	* @since 7.0

	*/

	{

	const union {TUint8 a[4]; TUint32 b;} one = { {0, 0, 0, 1} };

	return

		u.iAddr32[0] == 0 &&

		u.iAddr32[1] == 0 &&

		u.iAddr32[2] == 0 &&

		u.iAddr32[3] == one.b;

	}

EXPORT_C TBool TIp6Addr::IsUnspecified() const

	/**

	* Tests if the address is IPv6 unspecified.

	* @return

	*	ETrue, if the IP address value is zero (= <tt>::</tt>);

	*	EFalse, otherwise.

	* @since 7.0

	*/

	{

	return

		u.iAddr32[0] == 0 &&

		u.iAddr32[1] == 0 &&

		u.iAddr32[2] == 0 &&

		u.iAddr32[3] == 0;

	}

EXPORT_C TBool TIp6Addr::IsLinkLocal() const

	/**

	* Tests if the address is an IPv6 link-local address.

	* @return

	*	ETrue, if this address is an IPv6 link-local address (<tt>fe80::/10</tt>);

	*	EFalse, otherwise.

	* @since 7.0

	*/

	{

	return u.iAddr8[0] == 0xFE && (u.iAddr8[1] & 0xC0) == 0x80;

	}

EXPORT_C TBool TIp6Addr::IsSiteLocal() const

	/**

	* Tests if this address is an IPv6 site-local address (fec0::/10).

	* @return

	*	ETrue, if this is an IPv6 site-local address (<tt>fec0::/10</tt>);

	*	EFalse, otherwise.

	* @since 7.0

	*/

	{

	return u.iAddr8[0] == 0xFE && (u.iAddr8[1] & 0xC0) == 0xC0;

	}

EXPORT_C TBool TIp6Addr::IsV4Compat() const

	/**

	* Tests if this address is an IPv4-compatible address.

	*

	* @note

	*	returns EFalse for <tt>::0.0.0.0</tt> (= <tt>::</tt>) and

	*	<tt>::0.0.0.1</tt> (= <tt>::1</tt>).

	*

	* @return

	*	ETrue, if this is a IPv4-compatible address (<tt>::x.x.x.x</tt>);

	*	EFalse, otherwise.

	* @deprecated

	* @since 7.0

	*/

	{

	// Note: This must return false for true IPv6 "::" and "::1".

	const union {TUint8 a[4]; TUint32 b;} one = { {0, 0, 0, 1} };

	return

		u.iAddr32[0] == 0 &&

		u.iAddr32[1] == 0 &&

		u.iAddr32[2] == 0 &&

                u.iAddr32[3] != 0 &&

                u.iAddr32[3] != one.b;

	}

EXPORT_C TBool TIp6Addr::IsV4Mapped() const

	/**

	* Tests if this address is an IPv4-mapped address.

	* @return

	*	ETrue, if this address is an IPv4-mapped address (<tt>::ffff:x.x.x.x</tt>);

	*	EFalse, otherwise.

	* @since 7.0

	*/

	{

	const union {TUint8 a[4]; TUint32 b;} v4Prefix = { {0, 0, 0xff, 0xff} };

	return

		u.iAddr32[0] == 0 &&

		u.iAddr32[1] == 0 &&

		u.iAddr32[2] == v4Prefix.b;

	}

EXPORT_C TBool TIp6Addr::IsEqual(const TIp6Addr &aAddr) const

	/**

	* Tests if two addresses are equal.

	*

	* @param aAddr

	*	Address to compare with

	* @return

	*	ETrue, if the addresses are equal;

	*	EFalse, otherwise.

	* @since 7.0

	*/

	{

	return

		u.iAddr32[3] == aAddr.u.iAddr32[3] &&

		u.iAddr32[2] == aAddr.u.iAddr32[2] &&

		u.iAddr32[1] == aAddr.u.iAddr32[1] &&

		u.iAddr32[0] == aAddr.u.iAddr32[0];

	}

EXPORT_C TInt TIp6Addr::Match(const TIp6Addr &aAddr) const

	/**

	* Compares two raw IPv6 addresses from left to right and returns

	* the number of bits that match.

	*

	* @param aAddr

	*	Address to compare with

	* @return

	*	The number of bits that match (the common prefix length).

	* @since 7.0

	*/

	{

	TInt i = 0;

	while (u.iAddr32[i] == aAddr.u.iAddr32[i])

		if (++i == 4)

			return 128;

	i <<= 1;

	if (u.iAddr16[i] == aAddr.u.iAddr16[i])

		i++;

	i <<= 1;

	if (u.iAddr8[i] == aAddr.u.iAddr8[i])

		i++;

	TUint8 diff = (TUint8)(u.iAddr8[i] ^ aAddr.u.iAddr8[i]);

	for (i <<= 3; !(diff & 0x80); diff <<= 1)

		i++;

	return i;

    }

EXPORT_C TInt TIp6Addr::Scope() const

	/**

	* Return the scope level of the addres.

	*

	* All IP addresses (IPv4 and IPv6) have a scope level as defined by

	* this function. The scope level is a positive integer in range [1..16].

	*

	* This function may also return 0, which is an invalid level. This can

	* happen only, because IPv6 multicast addresses specify their scope

	* level explicitly.

	*

	* The scope level determines the interpretation of the scope identifier

	* in TInetAddr (see TInetAddr::Scope(), TInetAddr::SetScope()).

	*

	* Each network interface has a vector of 16 scope identifiers. The scope

	* identifier in the destination address selects a subset of the possible

	* interfaces: only the interfaces which have the correct matching scope

	* identifier in the vector entry matching the scope level, are valid

	* destinations for that address.

	*

	* The scope level of an IP address is computed as follows:

	* 

	* @li <tt>ffyz::/10</tt>

	* -- IPv6 multicast addressess, the scope level is extracted from the address (= z)

	* @li <tt>fe80::/10</tt>

	* -- IPv6 link local addresses, return KIp6AddrScopeLinkLocal

	* @li <tt>fec0::/10</tt>

	* -- IPv6 site local addresses, return KIp6AddrScopeSiteLocal

	* @li <tt>::1/128</tt>

	* -- IPv6 loopback address, return KIp6AddrScopeNodeLocal

	* @li <tt>::/128</tt>

	* -- IPv6 unspecified address, return KIp6AddrScopeNodeLocal

	* @li <tt> ::ffff:0.0.0.0</tt>

	* -- IPv4 unspecified address, return KIp6AddrScopeNodeLocal

	* @li <tt>::ffff:169.254.x.x/112</tt>

	* -- IPv4 link local range, return KIp6AddrScopeLinkLocal

	* @li <tt>::ffff:224.0.0.x/120</tt>

	* -- IPv4 link local multicast range, return KIp6AddrScopeLinkLocal

	* @li <tt>::ffff:127.x.x.x/104</tt>

	* -- IPv4 loopback addresses, return KIp6AddrScopeNodeLocal

	* @li <tt>::ffff:0.0.0.0/96</tt>

	* -- all other IPv4 addresses, return KIp6AddrScopeNetwork

	* @li None of the above

	* -- assume global IPv6 addresses, return KIp6AddrScopeGlobal

	*

	* @return

	*	The scope value of the address (e.g. #KIp6AddrScopeNodeLocal,

	*	#KIp6AddrScopeLinkLocal, #KIp6AddrScopeSiteLocal,

	*	#KIp6AddrScopeOrganization, #KIp6AddrScopeGlobal or

	*	#KIp6AddrScopeNetwork).

	* @since 7.0

	*/

	{

	if (u.iAddr8[0] == 0xFF)

		return u.iAddr8[1] & 0x0F;	// Multicast scope is explicit in the address.

	//

	// Other addresses must be mapped "by hand"

	//

	if (u.iAddr8[0] == 0x00)

		{

		const union {TUint8 a[2]; TUint16 b;} ipv4_linklocal = { {169, 254} };

		const union {TUint8 a[4]; TUint32 b;} ipv4_linklocal_mc = { {224, 0, 0, 0} };

		const union {TUint8 a[4]; TUint32 b;} ipv4_linklocal_mc_mask = { {255, 255, 255, 0} };

		if (IsLoopback())

			return KIp6AddrScopeNodeLocal;// Loopback ==> Node Local Scope

		if (IsUnspecified())

			return KIp6AddrScopeNodeLocal;// Return Node Local for unspecified address

		if (IsV4Mapped())

			{

			if (u.iAddr16[6] == ipv4_linklocal.b)

				return KIp6AddrScopeLinkLocal;// IPv4 Link local (169.254/16)

			else if ((u.iAddr32[3] & ipv4_linklocal_mc_mask.b) == ipv4_linklocal_mc.b)

				return KIp6AddrScopeLinkLocal;

			else if (u.iAddr8[12] == 127 || u.iAddr32[3] == 0)

				return KIp6AddrScopeNodeLocal;// IPv4 Loopback (127.0/8) and 0.0.0.0

			return KIp6AddrScopeNetwork;// all other IPv4 addresses

			}

		}

	else if (u.iAddr8[0] == 0xFE)

		{

		if ((u.iAddr8[1] & 0xC0) == 0x80)

			return KIp6AddrScopeLinkLocal;// Link Local ==> Link Local Scope

		else if ((u.iAddr8[1] & 0xC0) == 0xC0)

			return KIp6AddrScopeSiteLocal;// Site Local ==> Site Local Scope

		// Fall through to global scope

		}

	//

	// All rest and unassigned ranges are treated as Global Scope

	//

	return KIp6AddrScopeGlobal;

	}

//

//

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

//	Actual TInetAddr implementation

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

//

EXPORT_C void TInetAddr::Init(TUint aFamily)

	/**

	* Initialises the object properly according to the address family

	* passed in.

	*

	* @param aFamily The address family. Valid values are

	* @li #KAfInet,

	*	plain IPv4 address format

	* @li #KAfInet6,

	*	combined IPv4 and IPv6 format, including fields for the scope id and

	*	flow label.

	* @li anything else,

	*	initialized to KAFUnspec, with empty content.

	*

	* @post

	*	In all above cases, IsUnspecified() returns ETrue after

	*	this function.

	* @since 7.0

	*/

	{

	if (aFamily == KAfInet)

		SetUserLen(sizeof(SInetAddr));

	else if (aFamily == KAfInet6)

		SetUserLen(sizeof(SInet6Addr));

	else

		{

		SetUserLen(0);

		aFamily = KAFUnspec;

		}

	SetFamily(aFamily);

	// Always clear the IPv6 address variant, it is also

	// sufficient for IPv4 (even though a bit overkill).

	// For IPv6 this means that Scope and Flow Label

	// are zeroed.

	Mem::FillZ(UserPtr(), sizeof(SInet6Addr));

	}

EXPORT_C TInetAddr::TInetAddr()

	: TSockAddr(KAFUnspec)

	/** 

	* Constructs a basic TInetAddr object.

	*

	* The port is initialised to 0, and the IP address is unspecified.

	* The resulting address family is KAFUnspec.

	*/

	{

	SetPort(KInetPortNone);

	}

EXPORT_C TInetAddr::TInetAddr(const TSockAddr &aAddr) : TSockAddr(aAddr)

	/** 

	* Constructs a TInetAddr from a TSockAddr.

	*

	* The port and IP address values are copied from aAddr.

	* The resulting address family is same as that of aAddr.

	*

	* The function does a raw copy operation of the TSockAddr.

	* No checks are made at this point.

	* 

	* @param aAddr  TSockAddr to be used as initial content. 

	*/

	{

	}

EXPORT_C TInetAddr::TInetAddr(TUint aPort)

	: TSockAddr(KAFUnspec)

	/**

	* Constructs a TInetAddr and initialises the port to the specified value, 

	* and the IP address is unspecified.

	*

	* The resulting address family is KAFUnspec.

	*

	* @param aPort Value to which to set the port. 

	*/

	{

	SetPort(aPort);

	}

EXPORT_C TInetAddr::TInetAddr(TUint32 aAddr, TUint aPort)

	/**

	* Constructs a TInetAddr and initialise the specified port value

	* to aPort and the IP address to aAddr.

	*

	* The resulting address family is #KAfInet

	*

	* @param aAddr Value to which to set the IP address.

	* @param aPort Value to which to set the port.

	*/

	{

	Init(KAfInet);

	SetPort(aPort);

	Addr4Ptr()->iAddr = aAddr;

	}

EXPORT_C TInetAddr::TInetAddr(const TIp6Addr& aAddr, TUint aPort)

	/**

	* Constructs a TInetAddr and initialises the port to the

	* specified value, and the IPv6 address to aAddr.

	*

	* The resulting address family is #KAfInet6.

	*

	* @param aAddr Value to which to set the IPv6 address.  

	* @param aPort Value to which to set the port.

	* @since 7.0

	*/

	{

	Init(KAfInet6);

	AddrPtr()->iAddr = aAddr;

	SetPort(aPort);

	}

EXPORT_C void TInetAddr::SetAddress(TUint32 aAddr)

	/**

	* Sets the IPv4 address value.

	*

	* @note

	*	An IP address in dotted-decimal form can be converted into

	*	a TUint32 by the INET_ADDR macro.

	*

	* The resulting address family is #KAfInet.

	*

	* @param aAddr Value to which to set the IPv4 address.

	*/

	{

	Init(KAfInet);

	Addr4Ptr()->iAddr = aAddr;

	}

EXPORT_C void TInetAddr::SetAddress(const TIp6Addr &aAddr)

	/**

	* Sets the IPv6 address value. 

	*

	* The resulting address family is #KAfInet6.

	* The scope id and flow label are zeroed.

	*

	* @param aAddr Value to which to set the IPv6 address. 

	* @since 7.0

	*/	

	{

	Init(KAfInet6);

	AddrPtr()->iAddr = aAddr;

	}

EXPORT_C void TInetAddr::SetV4CompatAddress(TUint32 aAddr)

	/**

	* Creates an IPv4-compatible IPv6 address.

	*

	* The <em>IPv4-compatible format</em> is <tt>::x.x.x.x</tt>. 

	*

	* The resulting address family is #KAfInet6.

	* The scope id and flow label are zeroed.

	*

	* @param aAddr IPv4 address from which the IPv6 address is generated.

	*

	* @deprecated This address format is deprecated and should not be used.

	* @since 7.0

	*/

	{

	Init(KAfInet6);

	struct SInet6Addr *const a = AddrPtr();

	a->iAddr.u.iAddr32[0] = 0;

	a->iAddr.u.iAddr32[1] = 0;

	a->iAddr.u.iAddr32[2] = 0;

	a->iAddr.u.iAddr8[12] = (TUint8)(aAddr >> 24);

	a->iAddr.u.iAddr8[13] = (TUint8)(aAddr >> 16);

	a->iAddr.u.iAddr8[14] = (TUint8)(aAddr >>  8);

	a->iAddr.u.iAddr8[15] = (TUint8)aAddr;

	}

EXPORT_C void TInetAddr::SetV4MappedAddress(TUint32 aAddr)

	/**

	* Creates an IPv4-mapped IPv6 address.

	*

	* The <em>IPv4-mapped format</em> is <tt>::ffff:x.x.x.x</tt>. Internally, all

	* IPv4 addresses are stored in this format. 

	*

	* The resulting address family is #KAfInet6.

	* The scope id and flow label are zeroed.

	*

	* @param aAddr IPv4 address from which the IPv6 address is generated.

	* @since 7.0

	*/

	{

	Init(KAfInet6);

	const union {TUint8 a[4]; TUint32 b;} cpatPrefix = { {0, 0, 0xff, 0xff} };

	struct SInet6Addr *const a = AddrPtr();

	a->iAddr.u.iAddr32[0] = 0;

	a->iAddr.u.iAddr32[1] = 0;

	a->iAddr.u.iAddr32[2] = cpatPrefix.b;

	a->iAddr.u.iAddr8[12] = (TUint8)(aAddr >> 24);

	a->iAddr.u.iAddr8[13] = (TUint8)(aAddr >> 16);

	a->iAddr.u.iAddr8[14] = (TUint8)(aAddr >>  8);

	a->iAddr.u.iAddr8[15] = (TUint8)aAddr;

	}

EXPORT_C void TInetAddr::ConvertToV4Compat()

	/**

	* Converts an IPv4 address to an IPv4-compatible IPv6 address. 

	*

	* The function assumes that the previous content is IPv4 address and

	* accesses this using TInetAddr::Address() function. If the previous

	* content was not IPv4 address (in any format), function acts as if

	* the old content was <tt>0.0.0.0</tt>.

	*

	* The <em>IPv4-compatible format</em> is <tt>::x.x.x.x</tt>.

	*

	* The resulting address family is #KAfInet6.

	* The scope id and flow label are zeroed.

	*

	* @deprecated This address format is deprecated and should not be used.

	* @since 7.0

	*/

	{

	SetV4CompatAddress(Address());

	}

EXPORT_C void TInetAddr::ConvertToV4Mapped()