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

// IPv6/IPv4 socket library public header 

// 

//

/**

 @file in_sock.h

 @publishedAll

 @released

*/

#ifndef __IN_SOCK_H__

#define __IN_SOCK_H__

#ifndef __ES_SOCK_H__

#include <es_sock.h>

#endif

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <in_sock_internal.h>

#endif

/**

* @name TCP/IP Protocol and address family

*

* The TCP/IP stack supports two different address formats

* in the TInetAddr: KAfInet for plain IPv4 addresses (for

* backward compatibility), and KAfInet6 for both IPv6 and

* IPv4 addresses.

*

* Only the KAfInet is used as a <em>protocol family</em> constant

* for the TCP/IP protocol family, when sockets are opened

* (RSocket::Open() and RHostResolver::Open() ).

*

* KAfInet6 is only <em>address family</em>, and can only appear

* as a family constant in TSockAddr class.

*

* @since 7.0

*/

//@{

/** Identifies the TCP/IP protocol family and v4 address family.

*

* @see TInetAddr

*/

const TUint KAfInet				= 0x0800;

/** Identifies the TCP/IP v6 address family.

*

* @see TInetAddr

* @since 7.0

*/

const TUint KAfInet6			= 0x0806;

//@}

/**

* @name IP protocol IDs 

* @ingroup ip_packet_formats

*/

//@{

/** 

* Identifies the ICMP protocol.

*

* @capability NetworkServices	Required for opening 'icmp' sockets.

* @ref RSocket::Open()

*/

const TUint KProtocolInetIcmp	= 1;

/**

* Identifies the TCP protocol.

*

* @capability NetworkServices	Required for opening 'tcp' sockets.

* @ref RSocket::Open()

*/

const TUint KProtocolInetTcp	= 6;

/**

* Identifies the UDP protocol.

*

* @capability NetworkServices	Required for opening 'udp' sockets.

* @ref RSocket::Open()

*/

const TUint KProtocolInetUdp	= 17;

/** IPv6 inside IP (v4 or v6). @since 7.0 */

const TUint KProtocolInet6Ipip	= 41;

/** Identifies the ICMPv6 protocol.

*

* @since 7.0

* @capability NetworkServices	Required for opening 'icmp6' sockets.

* @ref RSocket::Open()

*/

const TUint KProtocolInet6Icmp	= 58;

//@}

/**

* @name Internal Protocol IDs

* Internal protocol id's do not appear in real

* packets. An internal id only identifies a protocol

* instance.

* @{

*/

/**

* Identifies the IP (v4) protocol module.

*

* @capability NetworkControl		Required for opening 'ip' sockets.

* @ref RSocket::Open()

*/

const TUint KProtocolInetIp		= 0x100;

/**

* Identifies the IP (v6) protocol module.

*

* @since 7.0

* @capability NetworkControl		Required for opening 'ip6' sockets.

* @ref RSocket::Open()

*/

const TUint KProtocolInet6Ip	= 0xF00;

/** Unknown Protocol ID. @deprecated (never use in anything that binds to IP) */

const TUint KProtocolUnknown = 0xdead;

//@}

/**  @name Socket option/ioctl levels */

//@{

/** ICMP socket option level (no options). */

const TUint KSolInetIcmp		= 0x101;

/** TCP socket options level. */

const TUint KSolInetTcp			= 0x106;

/** UDP socket options  level. */

const TUint KSolInetUdp			= 0x111;

/** IP socket options  level. */

const TUint KSolInetIp			= 0x100;

/** Interface control socket options level. */

const TUint KSolInetIfCtrl		= 0x201;

/** Route control socket options level.  */

const TUint KSolInetRtCtrl		= 0x202;

/** DNS control socket options level. @removed */

const TUint KSolInetDnsCtrl		= 0x204;

/** Interface query socket options level. @since 7.0 */

const TUint KSolInetIfQuery		= 0x206;

#ifdef SYMBIAN_DNS_PUNYCODE

/** DNS set options level. */

/**using a new constant instead of KSolInetDnsCtrl

 */

const TUint KSolInetDns			= 0x208;

#endif //SYMBIAN_DNS_PUNYCODE

//@}

/** Maximum IPv4 address length (bits). */

const TInt KInetAddrMaxBits         = 32;

/** Maximum IPv6 address length (bits). */

const TInt KInet6AddrMaxBits        = 128;

/** @name Port constants */

//@{

/** Any port flag (0). */

const TUint KInetPortAny			= 0x0000; 

/** No port flag (0). */

const TUint KInetPortNone			= 0x0000;

/** Minimum value of an automatically allocated port. */

const TUint KInetMinAutoPort		= 32768;

/** Maximum value of an automatically allocated port. */

const TUint KInetMaxAutoPort		= 60999;

//@}

/**  @name IPv4 address constants and definitions */

//@{

/** 

* Forms a 32-bit integer IPv4 address from the normal dotted-decimal representation. 

* 

* The four arguments are the four parts of the IPv4 address.

* 

* Example:

* @code

* TInetAddr addr;

* const TUint32 KInetAddr = INET_ADDR(194,129,2,54);

* addr.SetAddress(KInetAddr);

* @endcode 

*/

#define INET_ADDR(a,b,c,d) (TUint32)((((TUint32)(a))<<24)|((b)<<16)|((c)<<8)|(d))

/** Any address flag (0.0.0.0). */

const TUint32 KInetAddrAny				= INET_ADDR(0,0,0,0);

/** No address flag (0.0.0.0). */

const TUint32 KInetAddrNone				= INET_ADDR(0,0,0,0);

/** All addresses mask (255.255.255.255). */

const TUint32 KInetAddrAll				= INET_ADDR(255,255,255,255);

/** Broadcast address (255.255.255.255). */

const TUint32 KInetAddrBroadcast		= INET_ADDR(255,255,255,255);

/** Loopback address (127.0.0.1). */

const TUint32 KInetAddrLoop				= INET_ADDR(127,0,0,1);

/** Group address range start. */

const TUint32 KInetAddrGroupUnspec		= INET_ADDR(224,0,0,0);

/** All hosts address (224.0.0.1). */

const TUint32 KInetAddrGroupAllHosts	= INET_ADDR(224,0,0,1);

/** Link-local net number. @since 7.0s */

const TUint32 KInetAddrLinkLocalNet		= INET_ADDR(169,254,0,0);

/** Link-local net mask.  @since 7.0s */

const TUint32 KInetAddrLinkLocalNetMask	= INET_ADDR(255,255,0,0);

/** All addresses mask (0.0.0.0). */

const TUint32 KInetAddrMaskAll			= INET_ADDR(0,0,0,0);

/** All bits mask (255.255.255.255). */

const TUint32 KInetAddrMaskHost			= INET_ADDR(255,255,255,255);

/** Class A net mask (255.0.0.0). */

const TUint32 KInetAddrNetMaskA			= INET_ADDR(255,0,0,0);

/** Class A host mask (0.255.255.255). */

const TUint32 KInetAddrHostMaskA		= ~KInetAddrNetMaskA;

/** Number of bits to right-shift a Class A address to obtain the network number. */

const TInt KInetAddrShiftA				= 24;

/** Class B net mask (255.255.0.0). */

const TUint32 KInetAddrNetMaskB 		= INET_ADDR(255,255,0,0);

/** Class B host mask (0.0.255.255). */

const TUint32 KInetAddrHostMaskB		= ~KInetAddrNetMaskB;

/** Number of bits to right-shift a Class B address to obtain the network number. */

const TInt KInetAddrShiftB				= 16;

/** Class C net mask (255.255.255.0). */

const TUint32 KInetAddrNetMaskC 		= INET_ADDR(255,255,255,0);

/** Class C host mask (0.0.0.255). */

const TUint32 KInetAddrHostMaskC		= ~KInetAddrNetMaskC;

/** Number of bits to right-shift a Class C address to obtain the network number. */

const TInt KInetAddrShiftC				= 8;

/** . */

const TUint32 KInetAddrIdMaskA			= 0x80000000;

/** . */

const TUint32 KInetAddrIdValA			= 0x00000000;

/** . */

const TUint32 KInetAddrIdMaskB			= 0xc0000000;

/** . */

const TUint32 KInetAddrIdValB			= 0x80000000;

/** . */

const TUint32 KInetAddrIdMaskC			= 0xe0000000;

/** . */

const TUint32 KInetAddrIdValC			= 0xc0000000;

/** . */

const TUint32 KInetAddrIdMaskD			= 0xf0000000;

/** . */

const TUint32 KInetAddrIdValD			= 0xe0000000;

/** . */

const TUint32 KInetAddrIdMaskE			= 0xf8000000;

/** . */

const TUint32 KInetAddrIdValE			= 0xf0000000;

enum TInetAddrClass

/**

* @publishedAll

* @released

*/

	{

	EInetClassUnknown = 0,

	EInetClassA,

	EInetClassB,

	EInetClassC,

	EInetClassD,

	EInetClassE,

	EInetMulticast = EInetClassD,

	EInetExperimental = EInetClassE

	};

//@}

struct SInetAddr

/**

* IPv4 socket address.

*

* This exists for backward compatibility. SInet6Addr is

* the preferred format for both IPv4 and IPv6 addresses

* in TInetAddr.

*

* @publishedAll

* @released

*/

	{

	/** Plain IPv4 address */

	TUint32 iAddr;

	};

class TIp6Addr

/**

* The 128 bits of IPv6 or IPv4 address stored in network byte order.

*

* IPv4 addresses are stored in IPv4 mapped format.

*

* @publishedAll

* @released

* @since 7.0

*/

	{

public:

	IMPORT_C TBool IsUnicast() const;

	IMPORT_C TBool IsMulticast() const;

	IMPORT_C TBool IsLoopback() const;

	IMPORT_C TBool IsUnspecified() const;

	IMPORT_C TBool IsLinkLocal() const;

	IMPORT_C TBool IsSiteLocal() const;

	IMPORT_C TBool IsV4Compat() const;

	IMPORT_C TBool IsV4Mapped() const;

	IMPORT_C TBool IsEqual(const TIp6Addr &aAddr) const;

	IMPORT_C TInt Match(const TIp6Addr &aAddr) const;

	IMPORT_C TInt Scope() const;

	union

		{

		TUint8  iAddr8[16];

		TUint16 iAddr16[8];

		TUint32 iAddr32[4];

		} u;

	};

struct SInet6Addr

/**

* IPv4 and IPv6 socket address.

*

* Defines the address information inside the TInetAddr.

*

* @publishedAll

* @released

*

* @sa SInetAddr

* @since 7.0

*/

	{

	/** 16 bytes of IP6/IP4 address (128 bits) */

	TIp6Addr iAddr;

	/** 4 bytes of Flow Id */

	TUint32 iFlow;

	/**  4 bytes of Scope Id. */

	TUint32 iScope;

	};

/**

* @name IPv6 address constants..

* @since 7.0

*/

//@{

/** Node-local scope level (RFC-2373 2.7). */

const TInt KIp6AddrScopeNodeLocal = 0x01;

/** Link-local scope level (RFC-2373 2.7). */

const TInt KIp6AddrScopeLinkLocal = 0x02;

/** Site-local scope level (RFC-2373 2.7). */

const TInt KIp6AddrScopeSiteLocal = 0x05;

/** Organisation-local scope level (RFC-2373 2.7). */

const TInt KIp6AddrScopeOrganization = 0x08;

/** Global scope level (RFC-2373 2.7). */

const TInt KIp6AddrScopeGlobal = 0x0E;

/** Network scope level (non-standard value, used internally) */

const TInt KIp6AddrScopeNetwork = 0x10;

/** No address (all 0s). */

const TIp6Addr KInet6AddrNone = {{{0}}};

/** Loopback address (::1). */

const TIp6Addr KInet6AddrLoop = {{{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}}};

/** Link-local address (prefix fe80::). */

const TIp6Addr KInet6AddrLinkLocal = {{{0xfe, 0x80, }}};

//@}

class TInetAddr : public TSockAddr

/**

* This class specialises the generic socket server address class

* TSockAddr for the TCP/IP protocol family. It represents an IP

* address and stores either an IPv4 or an IPv6 address in its buffer

* after the generic data defined by TSockAddr. The protocol family

* field provided by the TSockAddr base class can be set to KAfInet,

* KAfInet6 or KAFUnspec.

*

* The address family defines the format of the stored address:

*

* @li #KAfInet

*	is for plain 32 bits IPv4 address presented as SInetAddr

*	structure.

* @li #KAfInet6

*	is for both IPv4 and IPv6 addresses (IPv4 addresses

*	are in IPv4 mapped format). The content is presented as

*	SInet6Addr structure, which includes the scope id

*	and flow label, in addition to the 128 address bits.

* @li KAFUnspec

*	does not contain any addresses and works in most

*	contexts as unspecified address, This is better than

*	placing explicit IPv4 "0.0.0.0" or IPv6 "::", which

*	in certain situations may limit the connections to either

*	IPv4 or IPv6, but not both.

*

* The flow label and scope id fields exist only in KAfInet6

* format. However, the access functions TInetAddr::FlowLabel

* and TInetAddr::Scope will also work for other address formats

* by always returning 0.

*

* Any function which sets or changes the address bits, will

* always reset the scope id and flow label to 0 (the

* TInetAddr::Init is always called internally). These are

* reasonable defaults, and normal application user does not

* normally need to worry about flow label or scope id.

*

* When address is returned from the stack, it will often

* be in KAfInet6 format, and may contain non-zero values

* for flow label and scope id fields. When copying addresses,

* the full TInetAddr (or at least SInet6Addr) should be

* copied to preserve these fields.

*

* @publishedAll

* @released

* @since 7.0

*	The IPv4 only portion is backward compatible with

*	older versions. In 7.0s some functions have additional

*	features.

*/

	{

public:

	IMPORT_C TInetAddr();

	IMPORT_C TInetAddr(const TSockAddr& aAddr);

	IMPORT_C TInetAddr(TUint aPort);

	IMPORT_C TInetAddr(const TIp6Addr &aAddr, TUint aPort);

	IMPORT_C TInetAddr(TUint32 aAddr, TUint aPort);

	IMPORT_C void SetAddress(TUint32 aAddr);

	IMPORT_C void SetAddress(const TIp6Addr &aAddr);

	IMPORT_C void SetV4CompatAddress(TUint32 aAddr);

	IMPORT_C void SetV4MappedAddress(TUint32 aAddr);

	IMPORT_C void SetFlowLabel(TInt aLabel);

	IMPORT_C TInt FlowLabel() const;

	IMPORT_C const TIp6Addr &Ip6Address() const;

	IMPORT_C void ConvertToV4Compat();

	IMPORT_C void ConvertToV4Mapped();

	IMPORT_C void ConvertToV4();

	IMPORT_C TBool CmpAddr(const TInetAddr& aAddr) const;

	IMPORT_C TBool Match(const TInetAddr& aHost) const;

	IMPORT_C TBool Match(const TInetAddr& aNet, const TInetAddr& aMask) const;

	IMPORT_C TBool Match(const TInetAddr& aNet, TInt aPrefixLen) const;

	IMPORT_C void PrefixMask(TInt aPrefixLen);

	IMPORT_C void Prefix(const TInetAddr& aAddr, TInt aPrefixLen);

	IMPORT_C void Output(TDes &aBuf) const;

	IMPORT_C TInt Input(const TDesC &aBuf);

	inline static TInetAddr& Cast(const TSockAddr& aAddr);

	inline static TInetAddr& Cast(const TSockAddr* aAddr);

	IMPORT_C TBool IsUnicast() const;

	IMPORT_C TBool IsMulticast() const;

	IMPORT_C TBool IsLoopback() const;

	IMPORT_C TBool IsUnspecified() const;

	IMPORT_C TBool IsLinkLocal() const;

	IMPORT_C TBool IsSiteLocal() const;

	IMPORT_C TBool IsV4Compat() const;

	IMPORT_C TBool IsV4Mapped() const;

	IMPORT_C TUint32 Address() const;

	IMPORT_C void NetMask(const TInetAddr& aAddr);

	IMPORT_C void Net(const TInetAddr& aAddr);

	IMPORT_C void NetBroadcast(const TInetAddr& aAddr);

	IMPORT_C void SubNet(const TInetAddr& aAddr, const TInetAddr& aMask);

	IMPORT_C void SubNetBroadcast(const TInetAddr& aAddr, const TInetAddr& aMask);

	inline TBool IsClassA() const;

	inline TBool IsClassB() const;

	inline TBool IsClassC() const;

	inline TBool IsBroadcast() const;

	inline TBool IsWildAddr() const;

	inline TBool IsWildPort() const;

	IMPORT_C void SetScope(TUint32 aScope);

	IMPORT_C TUint32 Scope() const;

	IMPORT_C void Init(TUint aFamily);

	IMPORT_C void OutputWithScope(TDes &aBuf) const;

protected:

	inline SInetAddr *Addr4Ptr() const;

	inline SInet6Addr *AddrPtr() const;

	inline static TInt AddrLen();

private:

	TInt Ipv4Input(const TDesC& aDes);

	TInt Ipv6Input(const TDesC& aDes);

	};

inline SInet6Addr* TInetAddr::AddrPtr() const

	/** Returns a pointer to #KAfInet6 content format. */

	{ return (SInet6Addr*)UserPtr(); }

inline TInt TInetAddr::AddrLen()

	/** Returns the size of the #KAfInet6 content format. */

	{ return sizeof(SInet6Addr); }

inline TInetAddr& TInetAddr::Cast(const TSockAddr& aAddr)

	/**

	* Casts a TSockAddr to a TInetAddr reference.

	*

	* The cast is only safe if the object being referenced is actually aTInetAddr. 

	*

	* @param aAddr  TSockAddr to cast

	* @return Casted reference to a TInetAddr. 

	*/

	{ return *((TInetAddr*)&aAddr); }

inline TInetAddr& TInetAddr::Cast(const TSockAddr* aAddr)

	/**

	* Casts a TSockAddr to a TInetAddr reference.

	*

	* The cast is only safe if the object being referenced is actually aTInetAddr. 

	*

	* @param aAddr  TSockAddr to cast

	* @return Casted pointer to a TInetAddr. 

	*/

	{ return *((TInetAddr*)aAddr); }

inline SInetAddr* TInetAddr::Addr4Ptr() const

	/** Returns a pointer to #KAfInet content format  */

	{ return (SInetAddr*)UserPtr(); }

inline TBool TInetAddr::IsBroadcast() const

	/**

	* Tests if the IP address is a limited broadcast address (255.255.255.255).

	*

	* @return ETrue if the IPv4 address value is a limited broadcast address; otherwise, EFalse

	*/

	{ return Address() == KInetAddrBroadcast; }