1 in_sock.h

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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // IPv6/IPv4 socket library public header 

    15 // 

    16 //

    17 

    18 

    19 

    20 /**

    21  @file in_sock.h

    22  @publishedAll

    23  @released

    24 */

    25 

    26 #ifndef __IN_SOCK_H__

    27 #define __IN_SOCK_H__

    28 

    29 #ifndef __ES_SOCK_H__

    30 #include <es_sock.h>

    31 #endif

    32 

    33 /**

    34 * @name TCP/IP Protocol and address family

    35 *

    36 * The TCP/IP stack supports two different address formats

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

    38 * backward compatibility), and KAfInet6 for both IPv6 and

    39 * IPv4 addresses.

    40 *

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

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

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

    44 *

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

    46 * as a family constant in TSockAddr class.

    47 *

    48 * @since 7.0

    49 */

    50 //@{

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

    52 *

    53 * @see TInetAddr

    54 */

    55 const TUint KAfInet				= 0x0800;

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

    57 *

    58 * @see TInetAddr

    59 * @since 7.0

    60 */

    61 const TUint KAfInet6			= 0x0806;

    62 //@}

    63 

    64 /**

    65 * @name IP protocol IDs 

    66 * @ingroup ip_packet_formats

    67 */

    68 //@{

    69 /** 

    70 * Identifies the ICMP protocol.

    71 *

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

    73 * @ref RSocket::Open()

    74 */

    75 const TUint KProtocolInetIcmp	= 1;

    76 

    77 /**

    78 * Identifies the TCP protocol.

    79 *

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

    81 * @ref RSocket::Open()

    82 */

    83 const TUint KProtocolInetTcp	= 6;

    84 

    85 /**

    86 * Identifies the UDP protocol.

    87 *

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

    89 * @ref RSocket::Open()

    90 */

    91 const TUint KProtocolInetUdp	= 17;

    92 

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

    94 const TUint KProtocolInet6Ipip	= 41;

    95 

    96 /** Identifies the ICMPv6 protocol.

    97 *

    98 * @since 7.0

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

   100 * @ref RSocket::Open()

   101 */

   102 const TUint KProtocolInet6Icmp	= 58;

   103 //@}

   104 

   105 /**

   106 * @name Internal Protocol IDs

   107 * Internal protocol id's do not appear in real

   108 * packets. An internal id only identifies a protocol

   109 * instance.

   110 * @{

   111 */

   112 /**

   113 * Identifies the IP (v4) protocol module.

   114 *

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

   116 * @ref RSocket::Open()

   117 */

   118 const TUint KProtocolInetIp		= 0x100;

   119 

   120 /**

   121 * Identifies the IP (v6) protocol module.

   122 *

   123 * @since 7.0

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

   125 * @ref RSocket::Open()

   126 */

   127 const TUint KProtocolInet6Ip	= 0xF00;

   128 

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

   130 const TUint KProtocolUnknown = 0xdead;

   131 

   132 //@}

   133 

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

   135 //@{

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

   137 const TUint KSolInetIcmp		= 0x101;

   138 /** TCP socket options level. */

   139 const TUint KSolInetTcp			= 0x106;

   140 /** UDP socket options  level. */

   141 const TUint KSolInetUdp			= 0x111;

   142 /** IP socket options  level. */

   143 const TUint KSolInetIp			= 0x100;

   144 /** Interface control socket options level. */

   145 const TUint KSolInetIfCtrl		= 0x201;

   146 /** Route control socket options level.  */

   147 const TUint KSolInetRtCtrl		= 0x202;

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

   149 const TUint KSolInetDnsCtrl		= 0x204;

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

   151 const TUint KSolInetIfQuery		= 0x206;

   152 //@}

   153 

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

   155 const TInt KInetAddrMaxBits         = 32;

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

   157 const TInt KInet6AddrMaxBits        = 128;

   158 

   159 /** @name Port constants */

   160 //@{

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

   162 const TUint KInetPortAny			= 0x0000; 

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

   164 const TUint KInetPortNone			= 0x0000;

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

   166 const TUint KInetMinAutoPort		= 32768;

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

   168 const TUint KInetMaxAutoPort		= 60999;

   169 //@}

   170 

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

   172 //@{

   173 

   174 /** 

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

   176 * 

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

   178 * 

   179 * Example:

   180 * @code

   181 * TInetAddr addr;

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

   183 * addr.SetAddress(KInetAddr);

   184 * @endcode 

   185 */

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

   187 

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

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

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

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

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

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

   194 /** Broadcast address (255.255.255.255). */

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

   196 /** Loopback address (127.0.0.1). */

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

   198 

   199 /** Group address range start. */

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

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

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

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

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

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

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

   207 

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

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

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

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

   212 

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

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

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

   216 const TUint32 KInetAddrHostMaskA		= ~KInetAddrNetMaskA;

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

   218 const TInt KInetAddrShiftA				= 24;

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

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

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

   222 const TUint32 KInetAddrHostMaskB		= ~KInetAddrNetMaskB;

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

   224 const TInt KInetAddrShiftB				= 16;

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

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

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

   228 const TUint32 KInetAddrHostMaskC		= ~KInetAddrNetMaskC;

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

   230 const TInt KInetAddrShiftC				= 8;

   231 

   232 /** . */

   233 const TUint32 KInetAddrIdMaskA			= 0x80000000;

   234 /** . */

   235 const TUint32 KInetAddrIdValA			= 0x00000000;

   236 /** . */

   237 const TUint32 KInetAddrIdMaskB			= 0xc0000000;

   238 /** . */

   239 const TUint32 KInetAddrIdValB			= 0x80000000;

   240 /** . */

   241 const TUint32 KInetAddrIdMaskC			= 0xe0000000;

   242 /** . */

   243 const TUint32 KInetAddrIdValC			= 0xc0000000;

   244 /** . */

   245 const TUint32 KInetAddrIdMaskD			= 0xf0000000;

   246 /** . */

   247 const TUint32 KInetAddrIdValD			= 0xe0000000;

   248 /** . */

   249 const TUint32 KInetAddrIdMaskE			= 0xf8000000;

   250 /** . */

   251 const TUint32 KInetAddrIdValE			= 0xf0000000;

   252 

   253 enum TInetAddrClass

   254 /**

   255 * @publishedAll

   256 * @released

   257 */

   258 	{

   259 	EInetClassUnknown = 0,

   260 	EInetClassA,

   261 	EInetClassB,

   262 	EInetClassC,

   263 	EInetClassD,

   264 	EInetClassE,

   265 	EInetMulticast = EInetClassD,

   266 	EInetExperimental = EInetClassE

   267 	};

   268 //@}

   269 

   270 struct SInetAddr

   271 /**

   272 * IPv4 socket address.

   273 *

   274 * This exists for backward compatibility. SInet6Addr is

   275 * the preferred format for both IPv4 and IPv6 addresses

   276 * in TInetAddr.

   277 *

   278 * @publishedAll

   279 * @released

   280 */

   281 	{

   282 	/** Plain IPv4 address */

   283 	TUint32 iAddr;

   284 	};

   285 

   286 

   287 class TIp6Addr

   288 /**

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

   290 *

   291 * IPv4 addresses are stored in IPv4 mapped format.

   292 *

   293 * @publishedAll

   294 * @released

   295 * @since 7.0

   296 */

   297 	{

   298 public:

   299 	IMPORT_C TBool IsUnicast() const;

   300 	IMPORT_C TBool IsMulticast() const;

   301 	IMPORT_C TBool IsLoopback() const;

   302 	IMPORT_C TBool IsUnspecified() const;

   303 	IMPORT_C TBool IsLinkLocal() const;

   304 	IMPORT_C TBool IsSiteLocal() const;

   305 	IMPORT_C TBool IsV4Compat() const;

   306 	IMPORT_C TBool IsV4Mapped() const;

   307 	IMPORT_C TBool IsEqual(const TIp6Addr &aAddr) const;

   308 	IMPORT_C TInt Match(const TIp6Addr &aAddr) const;

   309 	IMPORT_C TInt Scope() const;

   310 	union

   311 		{

   312 		TUint8  iAddr8[16];

   313 		TUint16 iAddr16[8];

   314 		TUint32 iAddr32[4];

   315 		} u;

   316 	};

   317 

   318 struct SInet6Addr

   319 /**

   320 * IPv4 and IPv6 socket address.

   321 *

   322 * Defines the address information inside the TInetAddr.

   323 *

   324 * @publishedAll

   325 * @released

   326 *

   327 * @sa SInetAddr

   328 * @since 7.0

   329 */

   330 	{

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

   332 	TIp6Addr iAddr;

   333 	/** 4 bytes of Flow Id */

   334 	TUint32 iFlow;

   335 	/**  4 bytes of Scope Id. */

   336 	TUint32 iScope;

   337 	};

   338 

   339 /**

   340 * @name IPv6 address constants..

   341 * @since 7.0

   342 */

   343 //@{

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

   345 const TInt KIp6AddrScopeNodeLocal = 0x01;

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

   347 const TInt KIp6AddrScopeLinkLocal = 0x02;

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

   349 const TInt KIp6AddrScopeSiteLocal = 0x05;

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

   351 const TInt KIp6AddrScopeOrganization = 0x08;

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

   353 const TInt KIp6AddrScopeGlobal = 0x0E;

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

   355 const TInt KIp6AddrScopeNetwork = 0x10;

   356 

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

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

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

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

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

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

   363 //@}

   364 

   365 class TInetAddr : public TSockAddr

   366 /**

   367 * This class specialises the generic socket server address class

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

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

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

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

   372 * KAfInet6 or KAFUnspec.

   373 *

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

   375 *

   376 * @li #KAfInet

   377 *	is for plain 32 bits IPv4 address presented as SInetAddr

   378 *	structure.

   379 * @li #KAfInet6

   380 *	is for both IPv4 and IPv6 addresses (IPv4 addresses

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

   382 *	SInet6Addr structure, which includes the scope id

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

   384 * @li KAFUnspec

   385 *	does not contain any addresses and works in most

   386 *	contexts as unspecified address, This is better than

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

   388 *	in certain situations may limit the connections to either

   389 *	IPv4 or IPv6, but not both.

   390 *

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

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

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

   394 * by always returning 0.

   395 *

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

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

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

   399 * reasonable defaults, and normal application user does not

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

   401 *

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

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

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

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

   406 * copied to preserve these fields.

   407 *

   408 * @publishedAll

   409 * @released

   410 * @since 7.0

   411 *	The IPv4 only portion is backward compatible with

   412 *	older versions. In 7.0s some functions have additional

   413 *	features.

   414 */

   415 	{

   416 public:

   417 	IMPORT_C TInetAddr();

   418 	IMPORT_C TInetAddr(const TSockAddr& aAddr);

   419 	IMPORT_C TInetAddr(TUint aPort);

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

   421 	IMPORT_C TInetAddr(TUint32 aAddr, TUint aPort);

   422 	IMPORT_C void SetAddress(TUint32 aAddr);

   423 	IMPORT_C void SetAddress(const TIp6Addr &aAddr);

   424 	IMPORT_C void SetV4CompatAddress(TUint32 aAddr);

   425 	IMPORT_C void SetV4MappedAddress(TUint32 aAddr);

   426 	IMPORT_C void SetFlowLabel(TInt aLabel);

   427 	IMPORT_C TInt FlowLabel() const;

   428 	IMPORT_C const TIp6Addr &Ip6Address() const;

   429 	IMPORT_C void ConvertToV4Compat();

   430 	IMPORT_C void ConvertToV4Mapped();

   431 	IMPORT_C void ConvertToV4();

   432 	IMPORT_C TBool CmpAddr(const TInetAddr& aAddr) const;

   433 	IMPORT_C TBool Match(const TInetAddr& aHost) const;

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

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

   436 	IMPORT_C void PrefixMask(TInt aPrefixLen);

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

   438 	IMPORT_C void Output(TDes &aBuf) const;

   439 	IMPORT_C TInt Input(const TDesC &aBuf);

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

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

   442 	

   443 	IMPORT_C TBool IsUnicast() const;

   444 	IMPORT_C TBool IsMulticast() const;

   445 	IMPORT_C TBool IsLoopback() const;

   446 	IMPORT_C TBool IsUnspecified() const;

   447 	IMPORT_C TBool IsLinkLocal() const;

   448 	IMPORT_C TBool IsSiteLocal() const;

   449 	IMPORT_C TBool IsV4Compat() const;

   450 	IMPORT_C TBool IsV4Mapped() const;

   451 

   452 	IMPORT_C TUint32 Address() const;

   453 	IMPORT_C void NetMask(const TInetAddr& aAddr);

   454 	IMPORT_C void Net(const TInetAddr& aAddr);

   455 	IMPORT_C void NetBroadcast(const TInetAddr& aAddr);

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

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

   458 

   459 	inline TBool IsClassA() const;

   460 	inline TBool IsClassB() const;

   461 	inline TBool IsClassC() const;

   462 	inline TBool IsBroadcast() const;

   463 	inline TBool IsWildAddr() const;

   464 	inline TBool IsWildPort() const;

   465 

   466 	IMPORT_C void SetScope(TUint32 aScope);

   467 	IMPORT_C TUint32 Scope() const;

   468 

   469 	IMPORT_C void Init(TUint aFamily);

   470 	IMPORT_C void OutputWithScope(TDes &aBuf) const;

   471 protected:

   472 	inline SInetAddr *Addr4Ptr() const;

   473 	inline SInet6Addr *AddrPtr() const;

   474 	inline static TInt AddrLen();

   475 private:

   476 	TInt Ipv4Input(const TDesC& aDes);

   477 	TInt Ipv6Input(const TDesC& aDes);

   478 	};

   479 

   480 inline SInet6Addr* TInetAddr::AddrPtr() const

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

   482 	{ return (SInet6Addr*)UserPtr(); }

   483 

   484 inline TInt TInetAddr::AddrLen()

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

   486 	{ return sizeof(SInet6Addr); }

   487 

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

   489 	/**

   490 	* Casts a TSockAddr to a TInetAddr reference.

   491 	*

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

   493 	*

   494 	* @param aAddr  TSockAddr to cast

   495 	* @return Casted reference to a TInetAddr. 

   496 	*/

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

   498 

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

   500 	/**

   501 	* Casts a TSockAddr to a TInetAddr reference.

   502 	*

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

   504 	*

   505 	* @param aAddr  TSockAddr to cast

   506 	* @return Casted pointer to a TInetAddr. 

   507 	*/

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

   509 

   510 inline SInetAddr* TInetAddr::Addr4Ptr() const

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

   512 	{ return (SInetAddr*)UserPtr(); }

   513 

   514 inline TBool TInetAddr::IsBroadcast() const

   515 	/**

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

   517 	*

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

   519 	*/

   520 	{ return Address() == KInetAddrBroadcast; }

   521 

   522 inline TBool TInetAddr::IsWildPort() const

   523 	/**

   524 	* Tests if the port is zero.

   525 	*

   526 	* @return ETrue if the port is zero; otherwise, EFalse.

   527 	*/

   528 	{ return Port() == KInetPortNone; }

   529 

   530 inline TBool TInetAddr::IsWildAddr() const

   531 	/**

   532 	* Tests if the IP address is unspecified.

   533 	*

   534 	* This is same as IsUnspecified()

   535 	*

   536 	* @return ETrue if the IP address value is unspecified; otherwise, EFalse. 

   537 	*/

   538 	{ return IsUnspecified(); }

   539 

   540 inline TBool TInetAddr::IsClassA() const

   541 	/**

   542 	* Tests if the IP address is Class A.

   543 	*

   544 	* @return ETrue if the IPv4 address value is Class A; otherwise, EFalse

   545 	*

   546 	* @deprecated Works only for IPv4. It assumes the old IPv4 address classes

   547 	* (A, B, C). Applications using this function may not work properly in the

   548 	* current internet environment.

   549 	*/

   550 	{

   551 		return (Family() == KAfInet || IsV4Mapped() || IsV4Compat()) && (Address() & KInetAddrIdMaskA) == KInetAddrIdValA;

   552 	}

   553 

   554 inline TBool TInetAddr::IsClassB() const

   555 	/**

   556 	* Tests if the IP address is Class B.

   557 	*

   558 	* @return ETrue if the IPv4 address value is Class B; otherwise. EFalse

   559 	*

   560 	* @deprecated Works only for IPv4. It assumes the old IPv4 address classes

   561 	* (A, B, C). Applications using this function may not work properly in the

   562 	* current internet environment.

   563 	*/

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

   565 

   566 inline TBool TInetAddr::IsClassC() const

   567 	/**

   568 	* Tests if the IP address is Class C.

   569 	*

   570 	* @return ETrue if the IPv4 address value is Class C; otherwise, EFalse

   571 	* @deprecated Works only for IPv4. It assumes the old IPv4 address classes

   572 	* (A, B, C). Applications using this function may not work properly in the

   573 	* current internet environment.

   574 	*/

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

   576 

   577 /**

   578 * @name Send/Recv flags (datagram sockets only)

   579 */

   580 //@{

   581 /** Don't fragment the packet.

   582 *

   583 * If the packet would require fragmentation due to a small

   584 * maximum transmission unit size (MTU), the packet is dropped

   585 * and an ICMP error message is generated: for ICMPv4 type=3 and code=4

   586 * (#KInet4ICMP_Unreachable); and for ICMPv6 type=2 and code=0

   587 * (#KInet6ICMP_PacketTooBig).

   588 *

   589 * Application must enable #KSoInetLastError to detect this situation.

   590 */

   591 const TUint KIpDontFragment		= 0x010000;

   592 /**

   593 * Packet includes IP or IPv6 header.

   594 *

   595 * When reading, the returned buffer starts with the received

   596 * IP header, which can be either IPv6 (TInet6HeaderIP4) or

   597 * IPv4 (TInet6HeaderIP).

   598 *

   599 * When writing buffers, the buffer must start with the IP

   600 * header and it must be complete. The stack does not

   601 * provide any defaults.

   602 *

   603 * @sa	KSoRawMode, KSoHeaderIncluded

   604 */

   605 const TUint KIpHeaderIncluded	= 0x020000;

   606 /**

   607 * Don't route the packet.

   608 *

   609 * Not supported in Symbian 7.0 and 7.0s.

   610 */

   611 const TUint KIpDontRoute		= 0x040000;

   612 //@}

   613 

   614 

   615 /**

   616 * @name Interface control socket options

   617 *

   618 * Level: #KSolInetIfCtrl

   619 *

   620 * Enumerating & Configuring Interfaces using TSoInetInterfaceInfo and TSoInet6InterfaceInfo.

   621 */ 

   622 //@{

   623 /**

   624 * Begin enumeration of network interfaces. 

   625 * 

   626 * This option should be set before enumerating interfaces with #KSoInetNextInterface. 

   627 * 

   628 * This option is for use with RSocket::SetOpt() only.

   629 */

   630 const TInt KSoInetEnumInterfaces = 0x211;

   631 /**

   632 * Return details of the next interface in an enumeration started by setting the 

   633 * option #KSoInetEnumInterfaces.

   634 *

   635 * This option is for use with RSocket::GetOpt() only.

   636 * 

   637 * Option data type is TSoInetInterfaceInfo.

   638 *

   639 * @note

   640 *	If the interface has multiple addresses, then each address

   641 *	is returned as a separate instance of TSoInetInterfaceInfo

   642 *	(only address information is different each time).

   643 * @note

   644 *	If the interface has no addresses, then one entry

   645 *	with unspecified address is returned.

   646 */

   647 const TInt KSoInetNextInterface = 0x212;

   648 

   649 /**

   650 * Configures the interface.

   651 * 

   652 * This option is for use with RSocket::SetOpt() only.

   653 *

   654 * Option data type is TSoInet6InterfaceInfo.

   655 * 

   656 * The interface is specified by setting the TSoInetInterfaceInfo::iName,

   657 * @since 7.0

   658 *

   659 * @capability NetworkControl Modifying interfaces is allowed for authorized apps only.

   660 * @ref RSocket::SetOpt()

   661 */

   662 const TInt KSoInetConfigInterface = 0x213;

   663 /**

   664 * Deletes the interface.

   665 * 

   666 * This option is for use with RSocket::SetOpt() only.

   667 *

   668 * Option data type is TSoInet6InterfaceInfo.

   669 * 

   670 * The interface is specified by setting the TSoInetInterfaceInfo::iName,

   671 * @since 7.0

   672 *

   673 * @capability NetworkControl Modifying interfaces is allowed for authorized apps only.

   674 * @ref RSocket::SetOpt()

   675 */

   676 const TUint KSoInetDeleteInterface = 0x214;

   677 /**

   678 * Configure the interface details, if it exists.

   679 * 

   680 * Option data type is TSoInet6InterfaceInfo.

   681 * 

   682 * The interface is specified by setting the TSoInetInterfaceInfo::iName,

   683 *

   684 * @note

   685 *	Unlike KSoInetConfigInterface, never creates a new interface

   686 *	entry, if one does not already exist. KSoInetConfigInterface

   687 *	never fails with interface not found, as it always finds or

   688 *	creates one.

   689 * @since 7.0

   690 *

   691 * @capability NetworkControl Modifying interfaces is allowed for authorized apps only.

   692 * @ref RSocket::SetOpt()

   693 */

   694 const TUint KSoInetChangeInterface = 0x215;

   695 /**

   696 * Resets interface to initial state.

   697 *

   698 * Delete all configuration (routes and addresses) from the

   699 * interface. Any sockets (flows) currently using this interface,

   700 * are set to holding state (#KSoNoInterfaceError is not required).

   701 *

   702 * The interface reconfigures, if the NIF driver

   703 * calls CProtocolBase::StartSending(), or if

   704 * #KSoInetStartInterface socket option is used.

   705 *

   706 * Option data type is TSoInet6InterfaceInfo.

   707 * 

   708 * The interface is specified by setting the TSoInetInterfaceInfo::iName,

   709 * No other fields are used.

   710 * @since 7.0s

   711 *

   712 * @capability NetworkControl Modifying interfaces is allowed for authorized apps only.

   713 * @ref RSocket::SetOpt()

   714 */

   715 const TUint KSoInetResetInterface = 0x216;

   716 /**

   717 * Restart interface, auto-reconfigure.

   718 *

   719 * Option data type is TSoInet6InterfaceInfo.

   720 * 

   721 * The interface is specified by setting the TSoInetInterfaceInfo::iName,

   722 * No other fields are used. The selected interface is autoconfigured using the

   723 * information supplied by the attached network driver.

   724 *

   725 * Should normally only be called after #KSoInetResetInterface.

   726 * @since 7.0

   727 *

   728 * @capability NetworkControl Modifying interfaces is allowed for authorized apps only.

   729 * @ref RSocket::SetOpt()

   730 */

   731 const TUint KSoInetStartInterface = 0x217;

   732 

   733 /**

   734 * Trigger link local creation.

   735 *

   736 * Option data type is TSoInet6InterfaceInfo.

   737 * 

   738 * The interface is specified by setting the TSoInetInterfaceInfo::iName and any state

   739 * change required. Called by a configuration deamon to trigger IPv4 zeroconf and link

   740 * local creation if no address server is found.  Does nothing if

   741 * EV4LLConfigDaemonControlled option is not specified for interface.

   742 *

   743 * @since 9.2

   744 *

   745 * @capability NetworkControl Modifying interfaces is allowed for authorized apps only.

   746 * @ref RSocket::SetOpt()

   747 */

   748 const TUint KSoInetCreateIPv4LLOnInterface = 0x226;

   749 

   750 /**

   751 * Describes the state of an interface. 

   752 * 

   753 * It is used as a data member of TSoInetInterfaceInfo.

   754 *

   755 * @note

   756 *	This enumeration is supported only because of backward

   757 *	compatibility. The real interface state uses the system

   758 *	error codes directly. The interface is either up

   759 *	(KErrNone) or down because of some error condition (state

   760 *	is one of the system wide error codes indicating the reason

   761 *	for the down state).

   762 *

   763 * @publishedAll

   764 * @released

   765 */

   766 enum TIfStatus

   767 	{

   768 	/** The interface has been initiated, but is not yet available. */

   769 	EIfPending,

   770 	/** The interface is up and available. */

   771 	EIfUp,

   772 	/** The interface is up, but flowed off. */

   773 	EIfBusy,

   774 	/** The interface is down. */

   775 	EIfDown,

   776 	};

   777 

   778 class TSoInetInterfaceInfo

   779 /**

   780 * Used when listing interfaces with socket option.

   781 *

   782 * Used with interface level #KSolInetIfCtrl option #KSoInetNextInterface.

   783 *

   784 * This is also a base class for the TSoInet6InterfaceInfo,

   785 * which is used in modifying the interface configuration.

   786 *

   787 * @publishedAll

   788 * @released

   789 */

   790 	{

   791 public:

   792 	/** Ignored since 7.0. @removed The field exists, but it is ignored. */

   793 	TName iTag;

   794 	/** Interface name */

   795 	TName iName;

   796 	/** Interface state. */

   797 	TIfStatus iState;

   798 	/** Maximum transmission unit (bytes) */

   799 	TInt iMtu;

   800 	/** An approximation of the interface speed in Kbps. */

   801 	TInt iSpeedMetric;

   802 	/**

   803 	* Feature flags. 

   804 	* 

   805 	* Possible values are defined in in_iface.h.

   806 	*/

   807 	TUint iFeatures;

   808 	/** Hardware address. */

   809 	TSockAddr iHwAddr;

   810 	/** Interface IP address. */

   811 	TInetAddr iAddress;

   812 	/** IP netmask. */

   813 	TInetAddr iNetMask;

   814 	/** IP broadcast address. */

   815 	TInetAddr iBrdAddr;

   816 	/** IP default gateway or peer address (if known). */

   817 	TInetAddr iDefGate;

   818 	/** IP primary name server (if any). */

   819 	TInetAddr iNameSer1;

   820 	/** IP secondary name server (if any). */

   821 	TInetAddr iNameSer2;

   822 	};

   823 

   824 class TSoInet6InterfaceInfo : public TSoInetInterfaceInfo

   825 /**

   826 * Extension for TSoInetInterfaceInfo. Available in Symbian OS v7.0 and later.

   827 *

   828 * Used with the following interface level #KSolInetIfCtrl options:

   829 * @li	#KSoInetConfigInterface

   830 * @li	#KSoInetDeleteInterface

   831 * @li	#KSoInetChangeInterface

   832 * @li	#KSoInetResetInterface

   833 * @li	#KSoInetStartInterface

   834 * @li	#KSoInetCreateIPv4LLOnInterface

   835 *

   836 * The following configuration changes are only activated with

   837 * #KSoInetConfigInterface and #KSoInetChangeInterface options.

   838 * For these two, the extension specifies the details of actions

   839 * to be performed. The extension is a collection of control bits,

   840 * which can be grouped as

   841 *

   842 * @li modifiers (#iDelete and #iAlias)

   843 * @li actions: #iDoState, #iDoId (with subactions #iDoAnycast or #iDoProxy) and #iDoPrefix.

   844 *

   845 * The effect of the modifiers depend on the chosen action (in some

   846 * actions modifiers are ignored).

   847 * The iDoState can be combined with any other actions, but for the

   848 * remaining only the following combinations are valid:

   849 *

   850 * @li

   851 *	no address configuration: iDoId=0, iDoPrefix=0 (iDoProxy,

   852 *	iDoAnycast, iDelete and iAlias are ignored).

   853 * @li

   854 *	configure single IPv6 or IPv4 address:

   855 *	iDoid, iAddress has the address, iNetMask unspecified.

   856 * @li

   857 *	configure IPv6 id part: iDoId, iAddress is IPv6 address

   858 *	(<tt>fe80::id</tt>) and iNetMask defined (for 64 bits, use

   859 *	<tt>ffff:ffff:ffff:ffff::</tt>).

   860 * @li

   861 *	configure IPv4 address and netmask:	iDoId, iNetMask defined.

   862 * @li

   863 *	configure IPv6 or IPv4 anycast address: iDoId, iDoAnycast,

   864 *	iAddress has the address (iNetMask ignored).

   865 * @li

   866 *	configure IPv6 or IPv4 proxy address: iDoId, iDoProxy,

   867 *	iAddress has the address (iNetMask ignored).

   868 * @li

   869 *	configure IPv6 prefix and id part: iDoId, iDoPrefix,

   870 *	iAddress is the IPv6 address (prefix::id) and iNetMask defined

   871 *	(for 64 bits, use <tt>ffff:ffff:ffff:ffff::</tt>).

   872 * @li

   873 *	configure IPv6 prefix: iDoPrefix, iAddress is the prefix (prefix::)

   874 *	and iNetMask defined (for 64 bits, use <tt>ffff:ffff:ffff:ffff::</tt>).

   875 *

   876 * The default route is processed if #iDefGate is specified.

   877 * If the gateway address is an IPv4 address, then it defines IPv4

   878 * default route. Additionally, if the iDefGate is same as iAddress, then

   879 * this is interpreted as a request to treat the default route as

   880 * "onlink route" instead of the normal <em>gateway route</em>. #iDelete modifier

   881 * controls whether default route is added or deleted.

   882 *

   883 * The MTU is updated, if #iMtu has non-zero value.

   884 *

   885 * Available in Symbian OS v9.2 and later.

   886 *

   887 * Used with the following interface level #KSolInetIfCtrl option:

   888 * @li	#KSoInetCreateIPv4LLOnInterface

   889 *

   890 * @li actions: #iDoState.

   891 *

   892 * This configuration acts as a notification from a config daemon to the IP stack

   893 * which controls link local behaviour if the llv4linklocal=ELLV4ConfigDeamonControlled

   894 * TCPIP.ini option is specified for the interface:

   895 *

   896 * @li

   897 *	notification from config daemon (e.g., DHCP) that address assignment terminated

   898 *   so a link local should be created if appropriate TCPIP.ini setting is used:

   899 *	iDoState.

   900 *

   901 * @publishedAll

   902 * @released

   903 * @since 7.0 (some functionality only in 7.0s and >=9.3 for config daemon controlled link local creation)

   904 */

   905 	{

   906 public:

   907 	/**

   908 	* Add or delete modifier.

   909 	* 

   910 	* 0 = add, 1 = delete

   911 	*

   912 	* Modifies the actions for address configuration (#iDoId, #iDoPrefix)

   913 	* and iDefGate processing (see detail descripton above).

   914 	*/

   915 	TUint iDelete:1;

   916 	/**

   917 	* Primary or alias modifier.

   918 	* 

   919 	* 0 = primary, 1 = alias.

   920 	*

   921 	* @note

   922 	*	Always use 1 here (this is a relic, that most likely

   923 	*	should be deprecated, and defaulted to 1 always).

   924 	*/

   925 	TUint iAlias:1;

   926 	/**

   927 	* Prefix action (only for IPv6 addresses).

   928 	* 

   929 	* 0 = don't do prefix, 1 = do the prefix.

   930 	*

   931 	* #iAddress must be specified.

   932 	*

   933 	* If set and iNetMask is defined, then #iNetMask and #iAddress

   934 	* define a prefix for the interface (link). If iNetMask is

   935 	* unspecified, then the iDoPrefix is ignored.

   936 	*

   937 	* @li iDelete=0: 

   938 	*	Acts as if an IPv6 Router Advertisement with prefix option A=1

   939 	*	and L=1 has arrived (e.g. this prefix can be used in address

   940 	*	generation and all addresses with this prefix are onlink on

   941 	*	this interface).

   942 	*

   943 	* @li iDelete=1:

   944 	*	The specified prefix is deleted from the interface (if it

   945 	*	existed before).

   946 	*

   947 	* @note

   948 	*	Current IPv6 specification allows only 64 for the number

   949 	*	of prefix bits.

   950 	*/

   951 	TUint iDoPrefix:1;

   952 	/**

   953 	* Address action.

   954 	* 

   955 	* 0 = don't do address, 1= do the address.

   956 	*

   957 	* #iAddress must be specified.

   958 	*

   959 	* @note

   960 	*	If also either #iDoAnycast or #iDoProxy is set, then

   961 	*	the action is special for them (and the following

   962 	*	does not apply).

   963 	*

   964 	* If #iNetMask is unspecified, then #iAddress defines a single

   965 	* address (either IPv4 or IPv6) which is to be added or removed,

   966 	* depending on the state of the #iDelete modifier. #iAlias

   967 	* is ignored.

   968 	*

   969 	* If #iNetMask is specified, then the following applies:

   970 	*

   971 	* @li iDelete=0 and iAddress is IPv4 address:

   972 	*	iAddress and iNetMask are used to configure additional

   973 	*	IPv4 address and netmask for the interface.

   974 	* @li iDelete=0 and iAddress is IPv6 address

   975 	*	The iNetmask and iAddress define a ID part, which can be

   976 	*	combined with any defined prefix to form a full IPv6 address.

   977 	*	If iAlias is set, then a new ID is added; otherwise whatever

   978 	*	happens to be stored in the primary id slot is overwritten

   979 	*	(always use iAlias=1 to avoid confusion).

   980 	*

   981 	* @li iDelete=1:

   982 	*	The previously configured address or ID is deleted.

   983 	*

   984 	* @note

   985 	*	The IPv4 netmask alone cannot be added or deleted. Use #KSolInetRtCtrl

   986 	*	options.

   987 	*/

   988 	TUint iDoId:1;

   989 	/**

   990 	* Interface state action.

   991 	* 

   992 	* 0 = ignore TSoInetInterfaceInfo::iState,

   993 	*

   994 	* 1 = set interface state based on

   995 	* TSoInetInterfaceInfo::iState as follows:

   996 	* @li EIfDown:

   997 	*	The interface state is set to KErrNotReady.

   998 	* @li EIfUp:

   999 	*	The interface state is set to 0 (KErrNone).

  1000 	* @li

  1001 	*	Attempt to set any other state results failed operation

  1002 	*	with KErrArgument result.

  1003 	*/

  1004 	TUint iDoState:1;

  1005 	/**

  1006 	* Configure address as Anycast.

  1007 	*

  1008 	* The anycast address is defined by #iAddress.

  1009 	*

  1010 	* Anycast address is recognized as own address for incoming

  1011 	* packets, but it cannot be used as a source address for

  1012 	* outgoing packets. IPv6 DAD (or IPv4 ARP duplicate address)

  1013 	* test is not done for anycast addresses. Anycast address is

  1014 	* advertised on the link as an address of this host.

  1015 	*

  1016 	* 1 = configure anycast (#iDoId must also be set, #iDoPrefix is ignored)

  1017 	*

  1018 	* @li iDelete=0:

  1019 	*	Add anycast address.

  1020 	* @li iDelete=1:

  1021 	*	Remove the previously configured anycast address.

  1022 	*

  1023 	* @since 7.0s

  1024 	*/

  1025 	TUint iDoAnycast:1;

  1026 	/**

  1027 	* Confiture address as Proxy.

  1028 	*

  1029 	* The proxy address is defined by #iAddress.

  1030 	*

  1031 	* Proxy address is not recognized as own address for incoming

  1032 	* packets (nor can it be used as own address for outgoing packets).

  1033 	* IPv6 DAD (or IPv4 ARP duplicate address) test is performed for

  1034 	* proxy address. Proxy address is advertised on the link as an

  1035 	* address of this host.

  1036 	*

  1037 	* 1 = configure proxy (#iDoId must also be set, #iDoPrefix is ignored)

  1038 	*

  1039 	* @li iDelete=0:

  1040 	*	Add proxy address.

  1041 	* @li iDelete=1:

  1042 	*	Remove the previously configured proxy address.

  1043 	*

  1044 	* @since 7.0s

  1045 	*/

  1046 	TUint iDoProxy:1;

  1047 	};

  1048 //@}

  1049 

  1050 /**

  1051 * @name Interface query socket options

  1052 *

  1053 * Level: #KSolInetIfQuery

  1054 *

  1055 * Querying information about interfaces using TSoInetIfQuery.

  1056 *

  1057 * @since 7.0 (some additions in 7.0s)

  1058 */

  1059 //@{

  1060 /** Scope Id vector (member of TSoInetIfQuery). @since 7.0s */

  1061 typedef TUint32 TInetScopeIds[16];

  1062 

  1063 class TSoInetIfQuery

  1064 /**

  1065 * Interface query.

  1066 *

  1067 * Used with interface query options:

  1068 * @li	#KSoInetIfQueryByDstAddr

  1069 * @li	#KSoInetIfQueryBySrcAddr

  1070 * @li	#KSoInetIfQueryByIndex

  1071 * @li	#KSoInetIfQueryByName

  1072 *

  1073 * Only GetOption for KSolInetIfQuery is supported. It returns

  1074 * information about the selected interface. The option name

  1075 * determines the input field in the TSoInetIfQuery, which is

  1076 * used as a key for locating the interface.

  1077 *

  1078 * Returns, KErrNotFound, if interface is not found

  1079 *

  1080 * Returns, KErrNone, if interface is located, and fills

  1081 * fields from the interface with following logic

  1082 *

  1083 * @li	iDstAddr: not touched, left as is

  1084 * @li	iSrcAddr is result of the Select Source Address algorithm

  1085 *	    for the interface using the iDstAddr as input. If there

  1086 *		is no valid source address, the value will be KAFUnspec.

  1087 * @li	iIndex is loaded with the interface index of the interface

  1088 * @li	iName is loaded from the name of the interface

  1089 * @li	iIsUp is set 1, if interface has CNifIfBase pointer attached,

  1090 *		and 0 otherwise.

  1091 *

  1092 * For example, if QueryByDstAddr for specified destination address

  1093 * results iIsUp == 1, then there is an interface and route for that

  1094 * destination. iIsUp == 0, means that trying to connect to the address

  1095 * will most likely activate a netdial/interface link startup phase.

  1096 *

  1097 * @publishedAll

  1098 * @released

  1099 */

  1100 	{

  1101 public:

  1102 	/**

  1103 	* Destination address.

  1104 	* @li input:

  1105 	*	If the option is #KSoInetIfQueryByDstAddr, select

  1106 	*	interface by finding a route for this address;

  1107 	*	otherwise, ignored.

  1108 	* @li output: not changed.

  1109 	*

  1110 	* @note

  1111 	*	On returning interface information, regardless of

  1112 	*	the option used, the content of this is used to select

  1113 	*	a matching source address (#iSrcAddr).

  1114 	*/

  1115 	TInetAddr iDstAddr;

  1116 	/**

  1117 	* Source address.

  1118 	* @li input:

  1119 	*	If the option is #KSoInetIfQueryBySrcAddr, select

  1120 	*	interface by source address; otherwise, ignored.

  1121 	* @li output:

  1122 	*	The result of the source address

  1123 	*	selection algorithm based on the content of the

  1124 	*	#iDstAddr.

  1125 	*/

  1126 	TInetAddr iSrcAddr;

  1127 	/**

  1128 	* Interface Index. 

  1129 	*

  1130 	* @li input:

  1131 	*	If the option is #KSoInetIfQueryByIndex, select

  1132 	*	interface by this interface index; otherwise,

  1133 	*	ignored.

  1134 	* @li output: