ip man page on Tru64

Man page or keyword search:  
man Server   12896 pages
apropos Keyword Search (all sections)
Output format
Tru64 logo
[printable version]

ip(7)									 ip(7)

NAME
       ip - Internet Protocol (IPv4 and IPv6)

SYNOPSIS
       #include <sys/socket.h> #include <netinet/in.h>

       The following is the socket call for AF_INET sockets:

       s = socket(AF_INET, SOCK_RAW, proto);

       The following is the socket call for AF_INET6 sockets:

       s = socket(AF_INET6, SOCK_RAW, proto);

DESCRIPTION
       The  Internet Protocol (IP) is the transport layer protocol used by the
       Internet Protocol family.  Options may be set  at  the  IP  level  when
       using  higher-level  protocols that are based on IP (such as the Trans‐
       mission Control Protocol (TCP) and the User  Datagram  Package  (UDP)).
       You  can	 also access the protocol through a raw socket when developing
       new protocols, or special purpose applications.	Both IP version 4  and
       IP version 6 are supported.

       IP-level	 options  are  set with the setsockopt() function and examined
       with the getsockopt() function. Other options supported by the getsock‐
       opt()  and  setsockopt()	 functions  can be found in the <netinet/in.h>
       header file for IPv4 and in the <netinet/in6.h> header file for IPv6.

       Provides IPv4 options to be transmitted in the IPv4 header of each out‐
       going  packet or examines IPv4 header options on incoming packets.  The
       format of IPv4 options to be sent is that specified by the IPv4	speci‐
       fication,  with	one  exception: the list of addresses for Source Route
       options must include the first-hop gateway at the beginning of the list
       of  gateways.  The first-hop gateway address will be extracted from the
       option list and the size adjusted accordingly before use.

	      IPv4 options may be used with any socket type  in	 the  Internet
	      family.	Enables a SOCK_DGRAM socket to receive the destination
	      IPv4 address for a UDP datagram.	Enables a SOCK_DGRAM socket to
	      receive  the IPv4 options for a UDP datagram.  Sets the type-of-
	      service (TOS) field in the IPv4 header for a TCP or UDP  socket.
	      For example:

	      int tos; setsockopt(s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));

	      You  can set the type-of-service to any of the defined constants
	      in <netinet/ip.h>.  Typically used constants  are:  IPTOS_LOWDE‐
	      LAY, IPTOS_THROUGHPUT, and IPTOS_RELIABILITY.

	      To determine the current value for this option, use the getsock‐
	      opt call. For example:

	      int tos; getsockopt(s, IPPROTO_IP, IP_TOS,  &tos,	 sizeof(tos));
	      Sets  the	 time-to-live (TTL) field in the IPv4 header for a TCP
	      or UDP socket, by default the values  are	 60  and  30,  respec‐
	      tively, for example:

	      int ttl; setsockopt(s, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));

	      To determine the current value for this option, use the getsock‐
	      opt call, for example:

	      int ttl; getsockopt(s, IPPROTO_IP, IP_TTL,  &ttl,	 sizeof(ttl));
	      Enables  a  SOCK_RAW socket to receive IPv6 destination options,
	      for example:

	      int on = 1;

	      if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVDSTOPTS,
			  &on, sizeof(on)) == -1)
			      perror("setsockopt IPV6_RECVDSTOPTS"); Enables a
	      SOCK_RAW socket to receive the IPv6 hop limit, for example:

	      int on = 1;

	      if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVHOPLIMIT,
			  &on, sizeof(on)) == -1)
			      perror("setsockopt IPV6_RECVHOPLIMIT");

	      To determine the current value for this option, use the getsock‐
	      opt call.	 Enables a SOCK_RAW socket to receive the IPv6 Hop-by-
	      Hop options header, for example:

	      int on = 1;

	      if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVHOPOPTS,
			  &on, sizeof(on)) == -1)
			      perror("setsockopt IPV6_RECVHOPOPTS"); Enables a
	      SOCK_RAW socket to receive the send and receive  interfaces  and
	      the source and destination addresses, for example:

	      int on = 1;

	      if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO,
			  &on, sizeof(on)) == -1)
			      perror("setsockopt IPV6_RECVPKTINFO"); Enables a
	      SOCK_RAW socket to receive the IPv6 routing header, for example:

	      int on = 1;

	      if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVRTHDR,
			  &on, sizeof(on)) == -1)
			      perror("setsockopt  IPV6_RECVRTHDR");  Sets  the
	      hop  limit  for  all  subsequent	IPv6 unicast packets sent on a
	      specified socket.	 For example:

	      int hoplimit = 10;  if  (setsockopt(s,  IPPROTO_IPV6,  IPV6_UNI‐
	      CAST_HOPS,
			  (char *) &hoplimit, sizeof(hoplimit)) == -1)
			      perror("setsockopt IPV6_UNICAST_HOPS");

	      To determine the current value for this option, use the getsock‐
	      opt call. For example:

	      int hoplimit; size_t len = sizeof(hoplimit);

	      if (getsockopt(s, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
		      (char *) &hoplimit, &len) == -1);
		  perror("getsockopt IPV6_UNICAST_HOPS"); else
		  printf("Using %d for	hop  limit.\n",	 hoplimit);  Specifies
	      whether  to  restrict  AF_INET6 sockets to sending and receiving
	      only IPv6 packets. For example:

	      int on = 1; if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
		      (char *)&on, sizeof(on)) == -1)
		  perror("setsockopt IPV6_V6ONLY"); else
		  printf("IPV6_V6ONLY option set");

	      If set, operations  with	IPv4-mapped  IPv6  addresses  are  not
	      allowed.	 This  is  a  Boolean  option.	 The default (0) is to
	      accept both IPv4 and IPv6 packets.

   MULTICASTING
       IP multicasting is supported on AF_INET and AF_INET6  sockets  of  type
       SOCK_DGRAM  and SOCK_RAW only, and only on networks where the interface
       driver supports multicasting.  By default, if a multicast  datagram  is
       sent to a group to which the sending host itself belongs (on the outgo‐
       ing interface), a copy of the datagram is looped back by the  IP	 layer
       for local delivery.

       A  host must become a member of a multicast group before it can receive
       datagrams sent to the  group.   Memberships  in	multicast  groups  are
       dropped when the socket is closed or the process exits.

   IPv4 Multicasting
       The  following  IPv4  multicasting options are supported: Joins an IPv4
       multicast group, for example:

	      struct ip_mreq mreq;  setsockopt(s,  IPPROTO_IP,	IP_ADD_MEMBER‐
	      SHIP, &mreq, sizeof(mreq));

	      The mreq parameter is the following structure:

	      struct ip_mreq {
		    struct  in_addr  imr_multiaddr; /* multicast group to join
	      */
		    struct in_addr imr_interface; /*  interface	 on  which  to
	      join */ }

	      The  imr_interface  should  be  INADDR_ANY to choose the default
	      multicast interface, or the IPv4 address of a particular	multi‐
	      cast-capable interface if the host is multihomed.	 Membership is
	      associated with a single interface; programs running  on	multi‐
	      homed  hosts  may	 need  to join the same group on more than one
	      interface.  Up to IP_MAX_MEMBERSHIPS (currently  65535)  member‐
	      ships may be added on a single socket.  Drops a membership in an
	      IPv4 multicast group, for example:

	      struct ip_mreq mreq; setsockopt(s,  IPPROTO_IP,  IP_DROP_MEMBER‐
	      SHIP, &mreq, sizeof(mreq));

	      The  mreq	 parameter contains the same values as used to add the
	      membership.  Overrides the default for subsequent IPv4 transmis‐
	      sions  from a given socket.  By default, for hosts with multiple
	      interfaces, each multicast transmission is sent from the primary
	      network interface.

	      struct  in_addr addr; setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF,
	      &addr, sizeof(addr));

	      The addr parameter specifies  the	 local	IPv4  address  of  the
	      desired  interface  or  INADDR_ANY to specify the default inter‐
	      face.  An interface's local IPv4 address and multicast  capabil‐
	      ity  can	be  obtained  through  the SIOCGIFCONF and SIOCGIFLAGS
	      ioctls.  Normal applications should not need to use this option.
	      Specifies	 whether  or  not subsequent IPv6 datagrams are looped
	      back, giving the sender explicit control, for example:

	      u_char loop;    /* 0 = disable, 1 = enable (default) */ setsock‐
	      opt(s, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop));

	      This  option improves performance for applications that may have
	      no more than one instance on a single host  (such	 as  a	router
	      daemon),	by  eliminating	 the  overhead	of receiving their own
	      transmissions.  However, applications for	 which	there  may  be
	      more  than one instance on a single host (such as a conferencing
	      program) or for which the sender does not belong to the destina‐
	      tion  group  (such  as a time-querying program) generally should
	      not use this option.

	      An IPv4 multicast datagram sent with an initial TTL greater than
	      1	 may be delivered to the sending host on a different interface
	      from that on which it was sent, if the host belongs to the  des‐
	      tination	group  on  that other interface.  The loopback control
	      option has no effect on such delivery.  Changes the time-to-live
	      (TTL)  in	 the  header  for outgoing IPv4 multicast datagrams in
	      order to control the scope of the multicasts; for example:

	      u_char ttl;     /* range: 0 to 255, default = 1 */ setsockopt(s,
	      IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));

	      Datagrams	 with  a  TTL  of 1 are not forwarded beyond the local
	      network.	Multicast datagrams with a TTL of 0 will not be trans‐
	      mitted on any network, but may be delivered locally if the send‐
	      ing host belongs to the destination group and if multicast loop‐
	      back  has	 not  been  disabled  on  the  sending socket (see the
	      IP_MULTICAST_LOOP option).  Multicast datagrams with TTL greater
	      than  1 may be forwarded to other networks if a multicast router
	      is attached to the local network.

   IPv6 Multicasting
       The following IPv6 multicasting options are supported:  Joins  an  IPv6
       multicast group on the specified interface, for example:

	      #include <netinet/in.h>

	      struct ipv6_mreq imr6;

	       imr6.ipv6mr_interface = if_index;
	       if (setsockopt(s, IPPROTO_IPV6, IPV6_JOIN_GROUP,
			   (char *)&imr6, sizeof(imr6)) < 0) {
		       perror("setsockopt IPV6_JOIN_GROUP");
	       }

	      The ipv6_mreq parameter is the following structure:

	      struct ipv6_mreq {
		  struct  in6_addr ipv6mr_multiaddr; /* IPv6 multicast address
	      */
		  unsigned int ipv6mr_interface;    /* interface index; 0 =>
					      * pick a default interface
					      * that  supports	IP  multicasts
					 */ };

	      The ipv6mr_interface should be either zero to choose the default
	      multicast interface or  the  interface  index  of	 a  particular
	      interface	 if  the host is multihomed.  Membership is associated
	      with a single interface; programs running	 on  multihomed	 hosts
	      may  need to join the same group on more than one interface.  Up
	      to IPV6_MAX_MEMBERSHIPS (currently 65536) may be added to a sin‐
	      gle socket.

	      IPv4-mapped  IPv6 addresses are supported as parameters for this
	      option.  Drops a membership in  an  IPv6	multicast  group,  for
	      example:

	      #include <netinet/in.h>

	      struct ipv6_mreq imr6;

	      if (setsockopt(s, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
				      (char *)&imr6, sizeof(imr6)) < 0) {
		       perror("setsockopt IPV6_LEAVE_GROUP"); }

	      The  imr6	 parameter contains the same values as used to add the
	      membership. IPv4-mapped IPv6 addresses are  supported  as	 valid
	      parameters  for this option.  Changes the hop limit for outgoing
	      IPv6 multicast packets; for example:

	      int hoplimit = 255; /* range 0 to 255; hop limit = -1 sets the
			       * hoplimit to the default value of 1
			       */ if (setsockopt(s, IPPROTO_IPV6,  IPV6_MULTI‐
	      CAST_HOPS,
			  &hoplimit, sizeof(hoplimit)) < 0) {
			      perror("setsockopt IPV6_MULTICAST_HOPS"); } Sets
	      the interface to use for outgoing IPv6 multicast packets:

	      u_int if_index = 1;

	      if     (setsockopt(s,	 IPPROTO_IPV6,	    IPV6_MULTICAST_IF,
			&if_index, sizeof(ifindex)) < 0)
			   perror("setsockopt IPV6_MULTICAST_IF"); }

	      The  if_index  parameter	specifies  the	interface index of the
	      desired interface or 0 to select a default interface.   You  can
	      use  the	if_nametoindex()  routine to find the interface index.
	      Specifies whether or not subsequent IPv6	datagrams  are	looped
	      back, for example:

	      u_int on = 0; /* 0 = disable, 1 = enable; default = 1 */
		      if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
			  &on, sizeof(on)) < 0){
				      perror("setsockopt   IPV6_MULTICAST_LOOP
	      ");
		      }

	      This option improves performance for applications that may  have
	      no  more	than  one  instance on a single host (such as a router
	      daemon), by eliminating the  overhead  of	 receiving  their  own
	      transmissions.   However,	 applications  for  which there may be
	      more than one instance on a single host (such as a  conferencing
	      program) or for which the sender does not belong to the destina‐
	      tion group (such as a time-querying  program)  generally	should
	      not use this option.

	      An  IPv6	multicast  datagram  sent  with	 an  initial hop limit
	      greater than 1 may be delivered to the sending host on a differ‐
	      ent  interface  from  that  on  which  it	 was sent, if the host
	      belongs to the destination group on that other  interface.   The
	      loopback control option has no effect on such delivery.

   Raw IP Sockets
       Raw  IP	sockets	 are  connectionless,  and  are normally used with the
       sendto() and recvfrom() calls, though the connect() call	 may  also  be
       used  to	 fix  the  destination	for  future packets, in which case the
       read() or recv() and write() or send() functions may be used.

       If proto is 0 (zero), the default protocol IPPROTO_RAW is used for out‐
       going packets, and only incoming packets destined for that protocol are
       received. If proto is nonzero, that protocol number  will  be  used  on
       outgoing packets and to filter incoming packets.

       For IPv4, outgoing packets automatically have an IP header prepended to
       them (based on the destination address  and  the	 protocol  number  the
       socket  is  created  with),  unless  the IP_HDRINCL option is set.  The
       IP_HDRINCL option specifies whether the IP header is  provided  by  the
       sent  packet.  Incoming packets are received with IP header and options
       intact.

ERRORS
       If a socket operation fails, errno may be set to one of	the  following
       values:	An  attempt was made to create a socket with a network address
       for which no network interface exists.	The  socket  is	 already  con‐
       nected.	 This  error  occurs  when trying to establish connection on a
       socket or when trying to send a datagram with the  destination  address
       specified.   The	 system	 ran out of memory for an internal data struc‐
       ture.  The destination address of a datagram was not specified, and the
       socket has not been connected.

       The  following  errors specific to IP may occur when setting or getting
       IP options: An unknown socket option name was given.

	      The IP option field was improperly formed; an option  field  was
	      shorter  than the minimum value or longer than the option buffer
	      provided.

SEE ALSO
       Functions: getsockopt(2), send(2), recv(2)

       Network Information: netintro(7), icmp(7), inet(7), tcp(7)

									 ip(7)
[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Tru64

List of man pages available for Tru64

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net