Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
inet(3SOCKET)							 inet(3SOCKET)

NAME
       inet,	inet6,	  inet_ntop,   inet_pton,   inet_addr,	 inet_network,
       inet_makeaddr, inet_lnaof, inet_netof, inet_ntoa	- Internet address ma-
       nipulation

SYNOPSIS
       cc [ flag ... ] file... -lsocket	-lnsl [	library...]
       #include	<sys/types.h>
       #include	<sys/socket.h>
       #include	<netinet/in.h>
       #include	<arpa/inet.h>

       const char *inet_ntop(int af, const void	*addr, char *cp, size_t	size);

       int inet_pton(int af, const char	*cp, void *addr);

       in_addr_t inet_addr(const char *cp);

       in_addr_t inet_network(const char *cp);

       struct in_addr inet_makeaddr(const int net, const int lna);

       int inet_lnaof(const struct in_addr in);

       int inet_netof(const struct in_addr in);

       char *inet_ntoa(const struct in_addr in);

       The  inet_ntop()	and inet_pton()	functions can manipulate both IPv4 and
       IPv6  addresses.	 The  inet_addr(),  inet_network(),   inet_makeaddr(),
       inet_lnaof(),  inet_netof(), and	inet_ntoa() functions can only manipu-
       late IPv4 addresses.

       The inet_ntop() function	converts a numeric address into	a string suit-
       able  for presentation. The af argument specifies the family of the ad-
       dress which can be AF_INET or AF_INET6. The addr	argument points	 to  a
       buffer  that  holds  an IPv4 address if the af argument is AF_INET. The
       addr argument points to a buffer	that holds an IPv6 address if  the  af
       argument	 is  AF_INET6.	The address must be in network byte order. The
       cp argument points to a buffer where the	function stores	the  resulting
       string.	 The application must specify a	non-NULL cp argument. The size
       argument	specifies the size of this buffer.  For	 IPv6  addresses,  the
       buffer must be at least 46-octets.  For IPv4 addresses, the buffer must
       be at least 16-octets. To allow applications to easily declare  buffers
       of the proper size to store IPv4	and IPv6 addresses in string form, the
       following two constants are defined in <netinet/in.h>:

       #define INET_ADDRSTRLEN	  16
       #define INET6_ADDRSTRLEN	  46

       The inet_pton() function	converts the standard text  presentation  form
       of a function to	the numeric binary form. The af	argument specifies the
       family of the address. Currently, the AF_INET and AF_INET6 address fam-
       ilies  are supported. The cp argument points to the string being	passed
       in. The addr argument points to a buffer	where the function stores  the
       numeric	address.  The  calling application must	ensure that the	buffer
       referred	to by addr is large enough to hold  the	 numeric  address,  at
       least 4 bytes for AF_INET or 16 bytes for AF_INET6.

       The   inet_addr()  and  inet_network()  functions  interpret  character
       strings that represent numbers expressed	in the IPv4 standard `.' nota-
       tion,  returning	 numbers  suitable  for	use as IPv4 addresses and IPv4
       network numbers,	respectively. The  inet_makeaddr()  function  uses  an
       IPv4  network  number  and a local network address to construct an IPv4
       address.	The inet_netof() and inet_lnaof() functions break  apart  IPv4
       host  addresses,	 then  return the network number and local network ad-
       dress, respectively.

       The inet_ntoa() function	returns	a pointer to a string in the base  256
       notation	d.d.d.d. See the following section on IPv4 addresses.

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

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

       1.  The preferred form is x:x:x:x:x:x:x:x, where	the 'x's are the hexa-
	   decimal values of the eight 16-bit pieces of	the address. For exam-
	   ple:

	   1080:0:0:0:8:800:200C:417A

	   It is not necessary to write	the leading  zeros  in	an  individual
	   field.   There  must	be at least one	numeral	in every field,	except
	   when	the special syntax described in	the following is used.

       2.  It is common	for addresses to contain long strings of zero bits  in
	   some	 methods  used to allocate certain IPv6	address	styles.	A spe-
	   cial	syntax is available to compress	the zeros. The use of "::" in-
	   dicates multiple groups of 16 bits of zeros.	The :: may only	appear
	   once	in an address. The :: can also be used to compress the leading
	   and trailing	zeros in an address. For example:

	   1080::8:800:200C:417A

       3.  The	alternative  form x:x:x:x:x:x:d.d.d.d is sometimes more	conve-
	   nient when dealing with a mixed environment of IPv4 and IPv6	nodes.
	   The	x's  in	 this form represent the hexadecimal values of the six
	   high-order 16-bit pieces of the address. The	d's represent the dec-
	   imal	values of the four low-order 8-bit pieces of the standard IPv4
	   address. For	example:

	   ::FFFF:129.144.52.38
	   ::129.144.52.38

	   The ::FFFF:d.d.d.d and ::d.d.d.d pieces are the general forms of an
	   IPv4-mapped IPv6 address and	an IPv4-compatible IPv6	address.

	   The	IPv4  portion must be in the d.d.d.d form. The following forms
	   are invalid:

	   ::FFFF:d.d.d
	   ::FFFF:d.d
	   ::d.d.d
	   ::d.d

	   The ::FFFF:d	form is	a valid	but unconventional  representation  of
	   the IPv4-compatible IPv6 address ::255.255.0.d.

	   The	 ::d   form   corresponds   to	 the   general	 IPv6  address
	   0:0:0:0:0:0:0:d.

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

       d.d.d.d
       d.d.d
       d.d
       d

       When four parts are specified, each part	is interpreted as  a  byte  of
       data  and  assigned from	left to	right to the four bytes	of an IPv4 ad-
       dress.

       When a three-part address is specified, the last	part is	interpreted as
       a 16-bit	quantity and placed in the right most two bytes	of the network
       address.	The three part address format  is  convenient  for  specifying
       Class B network addresses such 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 right most three bytes	of the network
       address.	The two	part address format is convenient for specifying Class
       A network addresses such	as net.host.

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

       With the	exception of inet_pton(), numbers supplied as parts in '.' no-
       tation may be decimal, octal, or	hexadecimal, as	specified  in  C  lan-
       guage.  For example, a leading 0x or 0X implies hexadecimal.  A leading
       0 implies octal.	Otherwise, the number is interpreted as	decimal.

       For IPv4	addresses, inet_pton() accepts only a string in	standard  IPv4
       dot notation:

       d.d.d.d

       Each  number has	one to three digits with a decimal value between 0 and
       255.

       The inet_ntop() function	returns	a pointer to the buffer	that  contains
       a  string if the	conversion succeeds. Otherwise,	NULL is	returned. Upon
       failure,	errno is set to	EAFNOSUPPORT if	the af argument	is invalid  or
       ENOSPC if the size of the result	buffer is inadequate.

       The inet_pton() function	returns	1 if the conversion succeeds, 0	if the
       input is	not a valid IPv4 dotted-decimal	string or a  valid   IPv6  ad-
       dress string. The function returns -1 with errno	set to EAFNOSUPPORT if
       the af argument is unknown.

       The value (in_addr_t)(-1) is returned by	inet_addr() and	inet_network()
       for malformed requests.

       The  functions  inet_netof() and	inet_lnaof() break apart IPv4 host ad-
       dresses,	returning the network number and local network	address	 part,
       respectively.

       The  function inet_ntoa() returns a pointer to a	string in the base 256
       notation	d.d.d.d, described in the section on IPv4 addresses.

       See attributes(5) for descriptions of the following attributes:

       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |MT-Level		     |Safe			   |
       +-----------------------------+-----------------------------+

       gethostbyname(3NSL),  getipnodebyname(3SOCKET),	getnetbyname(3SOCKET),
       inet.h(3HEAD), hosts(4),	ipnodes(4), networks(4), attributes(5)

       The return value	from inet_ntoa() points	to a buffer which is overwrit-
       ten on each call. This buffer is	implemented as thread-specific data in
       multithreaded applications.

       The  problem of host byte ordering versus network byte ordering is con-
       fusing.	A simple way to	specify	Class C	network	addresses in a	manner
       similar to that for Class B and Class A is needed.

				  28 Jan 2005			 inet(3SOCKET)

NAME | SYNOPSIS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=inet&sektion=3socket&manpath=SunOS+5.10>

home | help