/*

* Copyright (c) 1997-2002 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: 

*

*/

#if !defined(__IN_SOCK_H__)

#define __IN_SOCK_H__

#if !defined(__ES_SOCK_H__)

#include <es_sock.h>

#endif

// Address family ID

const TUint KAfInet				= 0x0800;

// IP Protocol IDs

const TUint KProtocolInetIcmp	= 1;

const TUint KProtocolInetTcp	= 6;

const TUint KProtocolInetUdp	= 17;

const TUint KProtocolInetIp		= 0x100;	// Psuedo protocol

// Socket option/ioctl levels

const TUint KSolInetIcmp		= 0x101;

const TUint KSolInetTcp			= 0x106;

const TUint KSolInetUdp			= 0x111;

const TUint KSolInetIp			= 0x100;

const TUint KSolInetIfCtrl		= 0x201;

const TUint KSolInetRtCtrl		= 0x202;

const TUint KSolInetDnsCtrl		= 0x204;

// Security specific

const TUint KSolInetSSL			= 0x205;  // SSL setopts/ioctls

// Maximum IPv4 address

const TInt KInetAddrMaxBits         = 32;

// Port constants

const TUint KInetPortAny			= 0x0000;

const TUint KInetPortNone			= 0x0000;

const TUint KInetMinAutoPort		= 1024;

const TUint KInetMaxAutoPort		= 5000;

// Address constants and utilities

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

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

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

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

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

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

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

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

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

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

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

const TUint32 KInetAddrHostMaskA		= ~KInetAddrNetMaskA;

const TInt KInetAddrShiftA				= 24;

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

const TUint32 KInetAddrHostMaskB		= ~KInetAddrNetMaskB;

const TInt KInetAddrShiftB				= 16;

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

const TUint32 KInetAddrHostMaskC		= ~KInetAddrNetMaskC;

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

	{

	EInetClassUnknown = 0,

	EInetClassA,

	EInetClassB,

	EInetClassC,

	EInetClassD,

	EInetClassE,

	EInetMulticast = EInetClassD,

	EInetExperimental = EInetClassE

	};

struct SInetAddr

	{ TUint32 iAddr; };

class TInetAddr : public TSockAddr

	{

public:

	IMPORT_C TInetAddr();

	IMPORT_C TInetAddr(const TSockAddr& anAddr);

	IMPORT_C TInetAddr(TUint aPort);

	IMPORT_C TInetAddr(TUint32 anAddr, TUint aPort);

	//

	IMPORT_C void SetAddress(TUint32 anAddr);

	IMPORT_C TUint32 Address() const;

	//

	IMPORT_C TBool CmpAddr(const TInetAddr& anAddr) const;

	IMPORT_C TBool Match(const TInetAddr& aHost) const;

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

	//

	IMPORT_C void Output(TDes &aBuf) const;

    IMPORT_C TInt Input(const TDesC &aBuf);	// Accepts a, a.b, a.b.c, a.b.c.d or 0xaabbccdd

	//

	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();

	inline TBool IsClassB();

	inline TBool IsClassC();

	inline TBool IsMulticast();

	inline TBool IsBroadcast();	// == 255.255.255.255

	inline TBool IsWildAddr();	// == 0.0.0.0

	inline TBool IsWildPort();	// == 0

	//

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

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

protected:

	inline SInetAddr *Addr4Ptr() const;

	inline static TInt AddrLen();

	};

// Send/Recv Flags (Datagram sockets only)

const TUint KIpDontFragment		= 0x010000;

const TUint KIpHeaderIncluded	= 0x020000;

const TUint KIpDontRoute		= 0x040000;

// Structure returned by KSoInetLastError/KIoctlInetLastError

class TSoInetLastErr

	{

public:

	TInt iStatus;			// ESock error code

	TInt iErrType;			// ICMP type

	TInt iErrCode;			// ICMP code

	TInetAddr iSrcAddr;		// Src of failed datagram

	TInetAddr iDstAddr;		// Dst of failed datagram

	TInetAddr iErrAddr;		// Addr of host that generated the error

	};

// Enumerating & Configuring Interfaces TPckgBuf<TSoInetInterfaceInfo>

// With a level of KSolInetIfCtrl

const TInt KSoInetEnumInterfaces = 0x211;

const TInt KSoInetNextInterface = 0x212;

const TInt KSoInetConfigInterface = 0x213;

enum TIfStatus

	{

	EIfPending,

	EIfUp,

	EIfBusy,

	EIfDown,

	};

class TSoInetInterfaceInfo

	{

public:

	TName iTag;				// Interface tag

	TName iName;			// Interface name

	TIfStatus iState;		// State

	TInt iMtu;				// max transmition size

	TInt iSpeedMetric;		// Metric - bigger is better

	TUint iFeatures;		// Feature flags

	TSockAddr iHwAddr;		// Hardware address (*)

	TInetAddr iAddress;		// Interface IP Address (*)

	TInetAddr iNetMask;		// IP netmask

	TInetAddr iBrdAddr;		// IP broadcast address

	TInetAddr iDefGate;		// IP default gateway or peer address (if known)

	TInetAddr iNameSer1;	// IP Primary name server (if any)

	TInetAddr iNameSer2;	// IP Secondary name server (if any)

	};

// Enumerating & Configuring Routes TPckgBuf<TSoInetRouteInfo>

// With a level of KSolInetRtCtrl

const TInt KSoInetEnumRoutes = 0x221;

const TInt KSoInetNextRoute = 0x222;

const TInt KSoInetAddRoute = 0x223;

const TInt KSoInetDeleteRoute = 0x224;

const TInt KSoInetChangeRoute = 0x225;

enum TRouteState

	{

	ERtNone,

	ERtPending,		// Interface has been started as a dialup, but no info available

	ERtBusy,		// Interface is up but flowed off

	ERtReady,		// Interface is up and ready

	ERtDown		    // Route is down and most likely to stay that way

	};

enum TRouteType

	{

	ERtNormal,		// Created when interface was started

	ERtUser,		// Created by user - ie via SetOpt()

	ERtIcmpAdd,		// Added by ICMP redirect

	ERtIcmpDel		// Replaced by an ICMP redirect

	};

class TSoInetRouteInfo

	{

public:

	TRouteType iType;		// Type of route (normal/icmp generated etc)

	TRouteState iState;		// State of route

	TInt iMetric;			// Smaller is better (less hops and/or faster link)

	TInetAddr iIfAddr;		// IP address of interface used for this route

	TInetAddr iGateway;		// IP address of gateway (might be the interface)

	TInetAddr iDstAddr;		// Destination network or host

	TInetAddr iNetMask;		// Destination mask of network (or host if KInetMaskHost)

	};

// Access to route cache TPckgBuf<TSoInetCachedRouteInfo>, set iDstAddr for required address

// With a level of KSolInetRtCtrl

const TInt KSoInetCachedRouteByDest = 0x225;

class TSoInetCachedRouteInfo : public TSoInetRouteInfo

	{

public:

	TInt iPathMtu;			// Set if used by DF datagram (incl TCP SYN), else 0

	TUint iPathRtt;			// Set if used by TCP, else 0

	};

// Flags returned from DNS records

enum TNameRecordFlags

	{

	EDnsAlias=0x00000001,		// Name is an Alias

	EDnsAuthoritive=0x00000002, // Answer is authoritive 

	EDnsHostsFile=0x00000004,   // Answer is from hosts file

	EDnsServer=0x00000008,      // Answer is from a DNS server

	EDnsHostName=0x00000010,    // Answer is host name for this host

	EDnsCache=0x00000020		// Answer is from the resolver cache

	};

const TUint KSoDnsCacheEnable = 0x600; // Get/Set

const TUint KSoDnsCacheFlush = 0x601; //Set

// TCP specific options and ioctls with a level of KSolInetTcp

// Ioclt

const TUint KIoctlTcpNotifyDataSent = 0x300;

// Options

const TUint KSoTcpSendWinSize = 0x301; // Get/Set before connect

const TUint KSoTcpRecvWinSize = 0x302; // Get/Set before connect

const TUint KSoTcpMaxSegSize = 0x303; // Get/Set before connect

const TUint KSoTcpNoDelay = 0x304; // Get/Set

const TUint KSoTcpKeepAlive = 0x305; // Get/Set

const TUint KSoTcpAsync2MslWait = 0x306; // Get/Set

const TUint KSoTcpSendBytesPending = 0x307; //Get

const TUint KSoTcpReadBytesPending = 0x308; //Get

const TUint KSoTcpListening = 0x309; //Get

const TUint KSoTcpNumSockets = 0x310; //Get

const TUint KSoTcpReadUrgentData = 0x311; //Get

const TUint KSoTcpPeekUrgentData = 0x312; //Get

const TUint KSoTcpRcvAtMark = 0x313; //Get

const TUint KSoTcpNextSendUrgentData = 0x314; //Get/Set

const TUint KSoTcpOobInline = 0x315; //Set

const TUint KSOTcpDebugMode = 0x11110000;

// SECURITY SPECIFIC STUFF

// At level KSolInetSSL

const TUint KSoSecureSocket = 0x400;          // set/clear secure socket

const TUint KSoSSLUnloadTimeout = 0x401;      // set/get SSL dll unload timeout

const TUint KSoCurrentCipherSuite = 0x402;    // set/get current cipher suite

const TUint KSoSSLServerCert = 0x403;	      // get current server cert

const TUint KSoDialogMode = 0x404;            // set/get current dialog mode

const TUint KSoAvailableCipherSuites = 0x405; // set/get supported cipher suites

// For KSoTcpSecureSocket

const TUint KSSLClearSecureStatus = 0x00; // disconnect SSL session

const TUint KSSLSetSecureStatus = 0x01;   // complete connect on SSL connect

// For KSoDialogMode

const TUint KSSLDialogUnattendedMode = 0x00; // dialogs

const TUint KSSLDialogAttendedMode = 0x01;   // no dialogs

// Generic with a level of KSolInetIp

const TUint KSoIpOptions = 0x401; // Set/Get

const TUint KSoRawMode = 0x402; // Set/Get

const TUint KSoHeaderIncluded = 0x403; // Set/Get

const TUint KSoIpTOS = 0x404; // Set/Get

const TUint KSoIpTTL = 0x405; // Set/Get

const TUint KSoReuseAddr = 0x406; //Set/Get

const TUint KSoNoInterfaceError = 0x407; //Set/Get

const TUint KSoInetLastError = 0x200; // Get Last ICMP error TPckgBuf<TSoInetLastErr>

const TUint KIoctlInetLastError = 0x200; // Exactly the same a the GetOpt

// UDP specific with a level of KSolInetUdp

const TUint KSoUdpReceiveICMPError = 0x500; //Set/Get

// Extended error codes

const TInt KErrNetUnreach = -190;

const TInt KErrHostUnreach = -191;

const TInt KErrNoProtocolOpt = -192;

const TInt KErrUrgentData = -193;

inline SInetAddr* TInetAddr::Addr4Ptr() const

	{ return (SInetAddr*)UserPtr(); }

class TInetReserved0

	{

public:

	union

		{

		TUint8  ixxx0[16];

		TUint16 ixxx1[8];

		TUint32 ixxx2[4];

		} uxxx;

	};

struct TInetReserved1

	{

	TInetReserved0 ixxx0;

	TUint32 ixxx1;

	TUint32 ixxx2;

	};

inline TInt TInetAddr::AddrLen()

	{ return sizeof(TInetReserved1); }

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

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

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

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

inline TBool TInetAddr::IsBroadcast()

	{ return Address()==KInetAddrBroadcast; }

inline TBool TInetAddr::IsWildPort()

	{ return Port()==KInetPortNone; }

inline TBool TInetAddr::IsWildAddr()

	{ return Address()==KInetAddrNone; }

inline TBool TInetAddr::IsClassA()

	{ return (Address() & KInetAddrIdMaskA) == KInetAddrIdValA; }

inline TBool TInetAddr::IsClassB()

	{ return (Address() & KInetAddrIdMaskB) == KInetAddrIdValB; }

inline TBool TInetAddr::IsClassC()

	{ return (Address() & KInetAddrIdMaskC) == KInetAddrIdValC; }

inline TBool TInetAddr::IsMulticast()

	{ return (Address() & KInetAddrIdMaskD) == KInetAddrIdValD; }

#endif