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

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
GETADDRINFO(3)	       FreeBSD Library Functions Manual		GETADDRINFO(3)

NAME
     getaddrinfo, freeaddrinfo,	gai_strerror --	nodename-to-address transla-
     tion in protocol-independent manner

LIBRARY
     Standard C	Library	(libc, -lc)

SYNOPSIS
     #include <sys/types.h>
     #include <sys/socket.h>
     #include <netdb.h>

     int
     getaddrinfo(const char *nodename, const char *servname,
	 const struct addrinfo *hints, struct addrinfo **res);

     void
     freeaddrinfo(struct addrinfo *ai);

     char *
     gai_strerror(int ecode);

DESCRIPTION
     The getaddrinfo() function	is defined for protocol-independent nodename-
     to-address	translation.  It performs the functionality of
     gethostbyname(3) and getservbyname(3), but	in a more sophisticated	man-
     ner.

     The addrinfo structure is defined as a result of including	the <netdb.h>
     header:

     struct addrinfo {
	  int	  ai_flags;	/* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
	  int	  ai_family;	/* PF_xxx */
	  int	  ai_socktype;	/* SOCK_xxx */
	  int	  ai_protocol;	/* 0 or	IPPROTO_xxx for	IPv4 and IPv6 */
	  size_t  ai_addrlen;	/* length of ai_addr */
	  char	 *ai_canonname;	/* canonical name for nodename */
	  struct sockaddr  *ai_addr; /*	binary address */
	  struct addrinfo  *ai_next; /*	next structure in linked list */
     };

     The nodename and servname arguments are pointers to null-terminated
     strings or	NULL.  One or both of these two	arguments must be a non-NULL
     pointer.  In the normal client scenario, both the nodename	and servname
     are specified.  In	the normal server scenario, only the servname is spec-
     ified.  A non-NULL	nodename string	can be either a	node name or a numeric
     host address string (i.e.,	a dotted-decimal IPv4 address or an IPv6 hex
     address).	A non-NULL servname string can be either a service name	or a
     decimal port number.

     The caller	can optionally pass an addrinfo	structure, pointed to by the
     third argument, to	provide	hints concerning the type of socket that the
     caller supports.  In this hints structure all members other than
     ai_flags, ai_family, ai_socktype, and ai_protocol must be zero or a NULL
     pointer.  A value of PF_UNSPEC for	ai_family means	the caller will	accept
     any protocol family.  A value of 0	for ai_socktype	means the caller will
     accept any	socket type.  A	value of 0 for ai_protocol means the caller
     will accept any protocol.	For example, if	the caller handles only	TCP
     and not UDP, then the ai_socktype member of the hints structure should be
     set to SOCK_STREAM	when getaddrinfo() is called.  If the caller handles
     only IPv4 and not IPv6, then the ai_family	member of the hints structure
     should be set to PF_INET when getaddrinfo() is called.  If	the third
     argument to getaddrinfo() is a NULL pointer, this is the same as if the
     caller had	filled in an addrinfo structure	initialized to zero with
     ai_family set to PF_UNSPEC.

     Upon successful return a pointer to a linked list of one or more addrinfo
     structures	is returned through the	final argument.	 The caller can
     process each addrinfo structure in	this list by following the ai_next
     pointer, until a NULL pointer is encountered.  In each returned addrinfo
     structure the three members ai_family, ai_socktype, and ai_protocol are
     the corresponding arguments for a call to the socket() function.  In each
     addrinfo structure	the ai_addr member points to a filled-in socket
     address structure whose length is specified by the	ai_addrlen member.

     If	the AI_PASSIVE bit is set in the ai_flags member of the	hints struc-
     ture, then	the caller plans to use	the returned socket address structure
     in	a call to bind().  In this case, if the	nodename argument is a NULL
     pointer, then the IP address portion of the socket	address	structure will
     be	set to INADDR_ANY for an IPv4 address or IN6ADDR_ANY_INIT for an IPv6
     address.

     If	the AI_PASSIVE bit is not set in the ai_flags member of	the hints
     structure,	then the returned socket address structure will	be ready for a
     call to connect() (for a connection-oriented protocol) or either
     connect(),	sendto(), or sendmsg() (for a connectionless protocol).	 In
     this case,	if the nodename	argument is a NULL pointer, then the IP
     address portion of	the socket address structure will be set to the	loop-
     back address.

     If	the AI_CANONNAME bit is	set in the ai_flags member of the hints	struc-
     ture, then	upon successful	return the ai_canonname	member of the first
     addrinfo structure	in the linked list will	point to a null-terminated
     string containing the canonical name of the specified nodename.

     If	the AI_NUMERICHOST bit is set in the ai_flags member of	the hints
     structure,	then a non-NULL	nodename string	must be	a numeric host address
     string.  Otherwise	an error of EAI_NONAME is returned.  This flag pre-
     vents any type of name resolution service (e.g., the DNS) from being
     called.

     The arguments to getaddrinfo() must be sufficiently consistent and	unam-
     biguous.  Here are	some problem cases you may encounter:

     +o	 The getaddrinfo() function will fail if the members in	the hints
	 structure are not consistent.	For example, for internet address fam-
	 ilies,	getaddrinfo() will fail	if you specify SOCK_STREAM to
	 ai_socktype while you specify IPPROTO_UDP to ai_protocol.

     +o	 If you	specify	a servname which is defined only for certain
	 ai_socktype, getaddrinfo() will fail because the arguments are	not
	 consistent.  For example, getaddrinfo() will return an	error if you
	 ask for ``tftp'' service on SOCK_STREAM.

     +o	 For internet address families,	if you specify servname	while you set
	 ai_socktype to	SOCK_RAW, getaddrinfo()	will fail, because service
	 names are not defined for the internet	SOCK_RAW space.

     +o	 If you	specify	numeric	servname, while	leaving	ai_socktype and
	 ai_protocol unspecified, getaddrinfo()	will fail.  This is because
	 the numeric servname does not identify	any socket type, and
	 getaddrinfo() is not allowed to glob the argument in such case.

     All of the	information returned by	getaddrinfo() is dynamically allo-
     cated: the	addrinfo structures, the socket	address	structures, and	canon-
     ical node name strings pointed to by the addrinfo structures.  To return
     this information to the system the	function freeaddrinfo()	is called.
     The addrinfo structure pointed to by the ai argument is freed, along with
     any dynamic storage pointed to by the structure.  This operation is
     repeated until a NULL ai_next pointer is encountered.

     To	aid applications in printing error messages based on the EAI_xxx codes
     returned by getaddrinfo(),	gai_strerror() is defined.  The	argument is
     one of the	EAI_xxx	values defined earlier and the return value points to
     a string describing the error.  If	the argument is	not one	of the EAI_xxx
     values, the function still	returns	a pointer to a string whose contents
     indicate an unknown error.

EXTENSIONS
     This implementation supports numeric IPv6 address notation	with the
     experimental scope	identifier.  By	appending a percent sign and scope
     identifier	to the address,	you can	specify	the value of the sin6_scope_id
     field of the socket address.  This	makes management of scoped address
     easier, and allows	cut-and-paste input of scoped addresses.

     At	the moment the code supports only link-local addresses in this format.
     The scope identifier is hardcoded to name of hardware interface associ-
     ated with the link, (such as ne0).	 For example, ``fe80::1%ne0'', which
     means ``fe80::1 on	the link associated with the ne0 interface''.

     This implementation is still very experimental and	non-standard.  The
     current implementation assumes a one-to-one relationship between inter-
     faces and links, which is not necessarily true according to the specifi-
     cation.

EXAMPLES
     The following code	tries to connect to ``www.kame.net'' service ``http''.
     via stream	socket.	 It loops through all the addresses available, regard-
     less of the address family.  If the destination resolves to an IPv4
     address, it will use an AF_INET socket.  Similarly, if it resolves	to
     IPv6, an AF_INET6 socket is used.	Observe	that there is no hardcoded
     reference to particular address family.  The code works even if
     getaddrinfo() returns addresses that are not IPv4/v6.

	   struct addrinfo hints, *res,	*res0;
	   int error;
	   int s;
	   const char *cause = NULL;

	   memset(&hints, 0, sizeof(hints));
	   hints.ai_family = PF_UNSPEC;
	   hints.ai_socktype = SOCK_STREAM;
	   error = getaddrinfo("www.kame.net", "http", &hints, &res0);
	   if (error) {
		   errx(1, "%s", gai_strerror(error));
		   /*NOTREACHED*/
	   }
	   s = -1;
	   cause = "no addresses";
	   errno = EADDRNOTAVAIL;
	   for (res = res0; res; res = res->ai_next) {
		   s = socket(res->ai_family, res->ai_socktype,
		       res->ai_protocol);
		   if (s < 0) {
			   cause = "socket";
			   continue;
		   }

		   if (connect(s, res->ai_addr,	res->ai_addrlen) < 0) {
			   cause = "connect";
			   close(s);
			   s = -1;
			   continue;
		   }

		   break;  /* okay we got one */
	   }
	   if (s < 0) {
		   err(1, cause);
		   /*NOTREACHED*/
	   }
	   freeaddrinfo(res0);

     The following example tries to open a wildcard listening socket onto ser-
     vice ``http'', for	all the	address	families available.

	   struct addrinfo hints, *res,	*res0;
	   int error;
	   int s[MAXSOCK];
	   int nsock;
	   const char *cause = NULL;

	   memset(&hints, 0, sizeof(hints));
	   hints.ai_family = PF_UNSPEC;
	   hints.ai_socktype = SOCK_STREAM;
	   hints.ai_flags = AI_PASSIVE;
	   error = getaddrinfo(NULL, "http", &hints, &res0);
	   if (error) {
		   errx(1, "%s", gai_strerror(error));
		   /*NOTREACHED*/
	   }
	   nsock = 0;
	   for (res = res0; res	&& nsock < MAXSOCK; res	= res->ai_next)	{
		   s[nsock] = socket(res->ai_family, res->ai_socktype,
		       res->ai_protocol);
		   if (s[nsock]	< 0) {
			   cause = "socket";
			   continue;
		   }

		   if (bind(s[nsock], res->ai_addr, res->ai_addrlen) < 0) {
			   cause = "bind";
			   close(s[nsock]);
			   continue;
		   }

		   if (listen(s[nsock],	SOMAXCONN) < 0)	{
			   cause = "listen";
			   close(s[nsock]);
			   continue;
		   }

		   nsock++;
	   }
	   if (nsock ==	0) {
		   err(1, cause);
		   /*NOTREACHED*/
	   }
	   freeaddrinfo(res0);

FILES
     /etc/hosts
     /etc/nsswitch.conf
     /etc/resolv.conf

DIAGNOSTICS
     Error return status from getaddrinfo() is zero on success and non-zero on
     errors.  Non-zero error codes are defined in <netdb.h>, and as follows:

     EAI_AGAIN	     Temporary failure in name resolution.
     EAI_BADFLAGS    Invalid value for ai_flags.
     EAI_FAIL	     Non-recoverable failure in	name resolution.
     EAI_FAMILY	     The ai_family address family is not supported.
     EAI_MEMORY	     Memory allocation failure.
     EAI_NONAME	     Neither nodename nor servname provided, or	not known.
     EAI_SERVICE     The servname service name is not supported	for
		     ai_socktype.
     EAI_SOCKTYPE    The ai_socktype socket type is not	supported.
     EAI_SYSTEM	     System error returned in errno.
     EAI_BADHINTS    Invalid value for hints.
     EAI_PROTOCOL    Resolved protocol is unknown.
     EAI_MAX	     Unknown error.

     If	called with an appropriate argument, gai_strerror() returns a pointer
     to	a string describing the	given error code.  If the argument is not one
     of	the EAI_xxx values, the	function still returns a pointer to a string
     whose contents indicate an	unknown	error.

SEE ALSO
     gethostbyname(3), getnameinfo(3), getservbyname(3), hosts(5),
     resolv.conf(5), services(5), hostname(7), named(8)

     R.	Gilligan, S. Thomson, J. Bound,	and W. Stevens,	Basic Socket Interface
     Extensions	for IPv6, RFC2553, March 1999.

     Tatsuya Jinmei and	Atsushi	Onoe, An Extension of Format for IPv6 Scoped
     Addresses,	internet draft,	draft-ietf-ipngwg-scopedaddr-format-02.txt,
     work in progress material.

     Craig Metz, "Protocol Independence	Using the Sockets API",	Proceedings of
     the freenix track:	2000 USENIX annual technical conference, June 2000.

HISTORY
     The implementation	first appeared in WIDE Hydrangea IPv6 protocol stack
     kit.

STANDARDS
     The getaddrinfo() function	is defined in IEEE Std 1003.1g-2000
     (``POSIX.1''), and	documented in ``Basic Socket Interface Extensions for
     IPv6'' (RFC2553).

BUGS
     Though the	current	implementation should be thread-safe, using
     getaddrinfo() in conjunction with gethostby*() breaks thread-safeness.

     The text was shamelessly copied from RFC2553.

FreeBSD	10.2			 May 25, 1995			  FreeBSD 10.2

NAME | LIBRARY | SYNOPSIS | DESCRIPTION | EXTENSIONS | EXAMPLES | FILES | DIAGNOSTICS | SEE ALSO | HISTORY | STANDARDS | BUGS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=getaddrinfo&manpath=FreeBSD+5.2-RELEASE+and+Ports>

home | help