// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// in6_opt.h - new socket options and MEventService data e.g.

// for accessing the network interface and route

// information.

// New socket options and MEventService data e.g. for accessing the network interface

// and route information.

//

/**

 @file in6_opt.h

 @publishedAll

 @released

*/

#ifndef __INSOCK_IN6_ROUTE_H__

#define __INSOCK_IN6_ROUTE_H__

#include <in_sock.h>

// PS: I'm declaring the following rule:

// ** Use socket option names above 0x1000 for all options defined in this file **

// (don't want to accidentally collide with in_sock.h, even though the probability is

// small considering the number of different sockopt levels)

// -- Socket option level: KSolInetIp --

/**

Controls the use of Explicit Congestion Notification. Values:

@li 0 = ECN disabled

@li 1 = ECN enabled with ECT(1)

@li 2 = ECN enabled with ECT(0) (recommended over ECT(1), because some implementations may

not implement ECT(1))

See RFC 3168 for more information.

@publishedAll

*/

const TUint KSoIpEcn = 0x1010;

/**

Next hop route selection.

Set forces the next hop route selection on the flow.

The option parameter is not used in set.

Get returns information about the current next hop

selection. The option parameter is TInetRouteInfo.

If the link layer is using addresses, the information

refers to neighbor cache entry. If the interface is not

using link layer addresses, the returned information just

describes the currently attached route entry.

To be successful, the flow must be assigned to the

interface and the source address must be set at the

time of the call.

This option is provided for hook implementations, for

example ISATAP tunneling hook can use this¨to force

next hop selection on the virtual interface to find the

actual link layer address (= outer IPv4 address).

*/

const TUint KSoNextHop = 0x1011;

// -- Socket option level: KSolInetTcp --

/**

If set, only full-sized TCP segments are sent before closing the connection. This is like

Nagle, but stricter.

@publishedAll

*/

const TUint KSoTcpCork = 0x1020;

/**

Send only full-sized TCP segments. Separate option in addition to KSoTcpCork is needed for

BSD compatibility.

@publishedAll

*/

const TUint KSoTcpNoPush = 0x1021;

/**

Do not return from close immediately, but linger for given maximum time to wait that the

send buffers are emptied. Socket option parameter is TSoTcpLingerOpt struct.

@publishedAll

*/

const TUint KSoTcpLinger = 0x1022;

/**

Parameter struct for KSoTcpLinger socket option. The following combinations are possible:

@li <b>iOnOff == 0</b>: Close() call returns immediately, but TCP still

		tries to transmit the data remaining in its send buffers.

@li <b>iOnOff == 1, iLinger == 0</b>: Close() returns immediately, and the TCP sender discards

		all data in its send buffers. TCP RST is sent to the other end. Note: the TCP sender

		avoids the TIME_WAIT state.

@li <b>iOnOff == 1, iLinger > 0</b>: Close() call blocks until the data in TCP send buffers

		is succesfully transmitted and the connection is graciously terminated.

		If the sender cannot transmit all data before the linger time expires,

		the Close() call wakes up, but the stack continues towards terminating the

		connection as usual.

A similar structure is used in BSD Unix sockets, hence porting Unix apps using linger option

should be straight forward.

@publishedAll

*/

class TSoTcpLingerOpt

	{

public:

	};

// -- Socket option level: KSolInetIfQuery --

// The options below are on KSolInetIfQuery level, although they use different option format

// than the rest of the options.

// There are no incoming parameters for these queries

/**

Return array of TInetInterfaceInfo objects as the response of GetOptions call.

@publishedAll

*/

const TUint KSoInetInterfaceInfo = 0x1001;

/**

Return array of TInetAddressInfo objects as the response of GetOptions call.

@publishedAll

*/

const TUint KSoInetAddressInfo = 0x1002;

/**

Return array of TInetRouteInfo objects as the response of GetOptions call.

@publishedAll

*/

const TUint KSoInetRouteInfo = 0x1003;

/**

Information of an address attached to interface.

Used by the event service (EClassAddress events) and KSoInetAddressInfo socket option.

@publishedAll

*/

class TInetAddressInfo

	{

public:

	enum TFlags

		{

		};

	enum TAddressState

		{

		};

	enum TAddressType

		{

		};

	};

/**

Information of a network interface.

Used by event service (EClassInterface events) and KSoInetInterfaceInfo socket option.

@publishedAll

*/

class TInetInterfaceInfo

	{

public:

	TUint32	    iIndex;

	enum

		{

	    IfState_HOLD    = 2

		};

	};

/**

Information of a route entry in IP stack.

Used by event service (EClassRoute events) and KSoInetRouteInfo socket option.

@publishedAll

*/

class TInetRouteInfo

	{

public:

	enum

		{ 

		};

	enum TState

	  	{

	    EIncomplete = 0,

	    ELoopback = 1,

	    EOnlink = 2,

	    EGateway = 3,

	    EAnycast = 5,

	    ERedirect = 7,

	    EReachable = 8,

	    EStale = 16

	 	 };

	};

/**

Information on a neighbour cache entry in the IP stack.

Used by event service (EClassNeighbour events).

@released

*/

class TInetNeighbourInfo

	{

public:

	TBuf8<KMaxSockAddrSize>	iHwAddr;

	};

/**

For building an array on top of TDes8. This is like casting a TDes8 data pointer to an array, but

it provides protection against array boundary violations, and some small helpful utilities.

The motivation of this class is to help in handling the information accessed by MNetworkInfo

interface.

@publishedAll

*/

template<class T> class TOverlayArray

	{

public:

	inline TOverlayArray(TDes8& aDes) : iDes(aDes)

	{ }

	/**

	* Returns pointer to the given element location in the array. If the index exceeds the

	* maximum length of the array, NULL is returned.

	*/

	inline T* IndexPtr(TInt aIndex)

	{ if (aIndex >= MaxLength()) return NULL; else return &((T*)iDes.Ptr())[aIndex]; }

	/**

	* Return the given element of the array. No boundary checking.

	*/

	inline T& operator[](TInt aIndex)

	{ return ((T*)iDes.Ptr())[aIndex]; }

	/**

	* Returns the maximum length of the array in the number of array elements.

	*/

	inline TInt MaxLength()

	{ return (iDes.MaxLength() / sizeof(T)); }

	/**

	* Returns the current length of the array in the number of array elements.

	* The length information is based

	* on the current underlaying descriptor length, which may not always be the desired result.

	*/

	inline TInt Length()

	{ return (iDes.Length() / sizeof(T)); }

	/**

	* Set the length of the underlaying descriptor. The parameter is given in the number of array

	* elements, which is then multiplied by a length of one element to determine the needed

	* descriptor length.

	*/

	inline void SetLength(TInt aLength)

	{ iDes.SetLength(aLength * sizeof(T)); }

private:

	TDes8&	  iDes;

	};

/**

Information of a multicast group joined by the IP stack. This class is not currently

used by socket options, only EClassMulticast events.

@publishedAll

*/

class TInetMulticastInfo

	{

public:

	};

// -- Socket option level: KSolInetIfCtrl --

/**

Control the use of link-local addresses per interface.

Argument: TSoInetIpv4LinkLocalInfo  (SetOpt only).

@publishedAll

@capability ECapabilityNetworkControl Configuring IPv4 Link-local addresses is restricted.

@ref RSocket::SetOpt()

*/

const TUint KSoIpv4LinkLocal = 0x1001;

/**

Used as a parameter in KSoIpv4LinkLocal.

@publishedAll

*/

class TSoInetIpv4LinkLocalInfo

	{

public:

	};

#endif  // __INSOCK_IN6_ROUTE_H__