*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->OpenBSD man pages -> addr (3)              



NAME    [Toc]    [Back]

     inet_addr, inet_aton, inet_lnaof, inet_makeaddr, inet_netof,
     inet_network, inet_ntoa, inet_ntop, inet_pton - Internet address manipulation

SYNOPSIS    [Toc]    [Back]

     #include <sys/types.h>
     #include <sys/socket.h>
     #include <netinet/in.h>
     #include <arpa/inet.h>

     inet_addr(const char *cp);

     inet_aton(const char *cp, struct in_addr *addr);

     inet_lnaof(struct in_addr in);

     struct in_addr
     inet_makeaddr(in_addr_t net, in_addr_t lna);

     inet_netof(struct in_addr in);

     inet_network(const char *cp);

     char *
     inet_ntoa(struct in_addr in);

     const char *
     inet_ntop(int af, const void *src, char *dst, size_t size);

     inet_pton(int af, const char *src, void *dst);

DESCRIPTION    [Toc]    [Back]

     The routines inet_aton(), inet_addr() and inet_network() interpret character
 strings representing numbers expressed in the Internet
standard `.'
     notation.  The inet_pton() function converts a  presentation
format address
  (that  is,  printable  form  as  held  in a character
string) to network
     format (usually a struct in_addr or some other internal  binary representation,
 in network byte order).  It returns 1 if the address
was valid
     for the specified address family, or 0 if the address wasn't
parseable in
     the specified address family, or -1 if some system error occurred (in
     which case errno will have  been  set).   This  function  is
presently valid
     for  AF_INET  and  AF_INET6.  The inet_aton() routine interprets the specified
 character string as an Internet  address,  placing  the
address into
     the structure provided.  It returns 1 if the string was successfully interpreted,
 or 0 if the string was invalid.  The  inet_addr()
     inet_network()  functions return numbers suitable for use as
Internet addresses
 and Internet network numbers, respectively.

     The function inet_ntop() converts an  address  from  network
format (usually
     a  struct in_addr or some other binary form, in network byte
order) to
     presentation format (suitable for external  display  purposes).  It returns
     NULL  if  a  system  error occurs (in which case, errno will
have been set),
     or it returns a pointer to the destination string.  The routine
     inet_ntoa()  takes  an Internet address and returns an ASCII
string representing
  the  address  in   `.'   notation.    The   routine
inet_makeaddr() takes
     an  Internet  network number and a local network address and
constructs an
     Internet address from it.   The  routines  inet_netof()  and
     break  apart  Internet host addresses, returning the network
number and local
 network address part, respectively.

     All Internet addresses are returned in network order  (bytes
ordered from
     left to right).  All network numbers and local address parts
are returned
     as machine format integer values.


     Values specified using the `.' notation take one of the following forms:


     When four parts are specified, each is interpreted as a byte
of data and
     assigned, from left to right, to the four bytes of an Internet address.
     Note that when an Internet address is viewed as a 32-bit integer quantity
     on a system that uses little-endian byte order (such as  the
Intel 386,
     486  and Pentium processors) the bytes referred to above appear as
     ``d.c.b.a''.  That is, little-endian bytes are ordered  from
right to

     When a three part address is specified, the last part is interpreted as a
     16-bit quantity and placed in the rightmost two bytes of the
network address.
   This makes the three part address format convenient
for specifying
 Class B network addresses as ``128.net.host''.

     When a two part address is supplied, the last part is interpreted as a
     24-bit  quantity  and placed in the rightmost three bytes of
the network
     address.  This makes the two part address format  convenient
for specifying
 Class A network addresses as ``net.host''.

     When only one part is given, the value is stored directly in
the network
     address without any byte rearrangement.

     All numbers supplied as ``parts'' in a `.' notation  may  be
decimal, octal,
 or hexadecimal, as specified in the C language (i.e., a
leading 0x
     or 0X implies hexadecimal; otherwise, a  leading  0  implies
octal; otherwise,
 the number is interpreted as decimal).


     In  order  to  support scoped IPv6 addresses, getaddrinfo(3)
     getnameinfo(3) are recommended  rather  than  the  functions
presented here.

     The  presentation  format of an IPv6 address is given in RFC

     There are three conventional forms for representing IPv6 addresses as
     text strings:

     1.    The  preferred form is x:x:x:x:x:x:x:x, where the 'x's
are the hexadecimal
 values of the eight 16-bit pieces of  the  address.  Examples:


          Note  that it is not necessary to write the leading zeros in an individual
 field, but there must be at least one numeral in
every field
          (except for the case described in 2.).

     2.    Due to the method of allocating certain styles of IPv6
addresses, it
          will be common for addresses to contain long strings of
zero bits.
          In order to make writing addresses containing zero bits
easier, a
          special syntax is available to compress the zeros.  The
use of
          ``::''  indicates  multiple groups of 16 bits of zeros.
The ``::''
          can only appear once in an address.  The ``::'' can also be used to
          compress  the  leading  and/or trailing zeros in an address.

          For example the following addresses:

                1080:0:0:0:8:800:200C:417A  a unicast address
                FF01:0:0:0:0:0:0:43         a multicast address
                0:0:0:0:0:0:0:1             the loopback address
                0:0:0:0:0:0:0:0             the  unspecified  addresses

          may be represented as:

                1080::8:800:200C:417A       a unicast address
                FF01::43                    a multicast address
                ::1                         the loopback address
                ::                           the  unspecified addresses

     3.   An alternative form that is sometimes  more  convenient
when dealing
          with a mixed environment of IPv4 and IPv6 nodes is
          x:x:x:x:x:x:d.d.d.d, where the 'x's are the hexadecimal
values of
          the six high-order 16-bit pieces of  the  address,  and
the 'd's are
          the  decimal  values of the four low-order 8-bit pieces
of the address
          (standard IPv4 representation).  Examples:


          or in compressed form:


DIAGNOSTICS    [Toc]    [Back]

     The constant INADDR_NONE  is  returned  by  inet_addr()  and
     for malformed requests.

SEE ALSO    [Toc]    [Back]

     byteorder(3),  gethostbyname(3),  getnetent(3), inet_net(3),

     IP Version 6 Addressing Architecture, RFC 2373, July 1998.

     Basic Socket Interface Extensions for IPv6, RFC 3493, February 2003.

STANDARDS    [Toc]    [Back]

     The  inet_ntop  and  inet_pton functions conform to the IETF
     and address formatting specifications.  Note that  inet_pton
does not accept
 1-, 2-, or 3-part dotted addresses; all four parts must
be specified.
  This is a narrower input set than  that  accepted  by

HISTORY    [Toc]    [Back]

     The  inet_addr,  inet_network, inet_makeaddr, inet_lnaof and
     functions appeared in 4.2BSD.  The inet_aton  and  inet_ntoa
functions appeared
 in 4.3BSD.  The inet_pton and inet_ntop functions appeared in BIND

BUGS    [Toc]    [Back]

     The value INADDR_NONE (0xffffffff) is a valid broadcast  address, but
     inet_addr()  cannot  return  that  value  without indicating
failure.  Also,
     inet_addr() should have been designed  to  return  a  struct
in_addr.  The
     newer  inet_aton()  function  does not share these problems,
and almost all
     existing code should be modified to use inet_aton() instead.

     The problem of host byte ordering versus network byte ordering is confusing.

     The string returned by inet_ntoa() resides in a static memory area.

OpenBSD      3.6                           June      18,     1997
[ Back ]
 Similar pages
Name OS Title
inet IRIX Internet address manipulation
inet_addr Tru64 Translate an Internet network address string to an Internet address integer
inet_net_pton NetBSD Internet network number manipulation routines
inet_net_pton OpenBSD Internet network number manipulation routines
inet_net FreeBSD Internet network number manipulation routines
inet_net OpenBSD Internet network number manipulation routines
inet_net_ntop FreeBSD Internet network number manipulation routines
inet_net_pton FreeBSD Internet network number manipulation routines
inet_net_ntop OpenBSD Internet network number manipulation routines
inet_net NetBSD Internet network number manipulation routines
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service