/* * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. * All rights reserved. *  * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. Neither the name of the project nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. *  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. *//* * "#ifdef FAITH" part is local hack for supporting IPv4-v6 translator. * * Issues to be discussed: * - Thread safe-ness must be checked. * - Return values.  There are nonstandard return values defined and used *   in the source code.  This is because RFC2553 is silent about which error *   code must be returned for which situation. * Note: * - We use getipnodebyname() just for thread-safeness.  There's no intent *   to let it do PF_UNSPEC (actually we never pass PF_UNSPEC to *   getipnodebyname(). * - The code filters out AFs that are not supported by the kernel, *   when globbing NULL hostname (to loopback, or wildcard).  Is it the right *   thing to do?  What is the relationship with post-RFC2553 AI_ADDRCONFIG *   in ai_flags? */#ifdef HAVE_CONFIG_H#include <config.h>#endif #ifndef lintstatic const char rcsid[] _U_ =     "@(#) $Header: /tcpdump/master/libpcap/Win32/Src/getaddrinfo.c,v 1.2 2003/11/15 23:24:06 guy Exp $";#endif#include <pcap-stdinc.h>#if 0#include <sys/sysctl.h>#endif#ifndef __MINGW32__#include <arpa/nameser.h>#endif#include <string.h>#include <stdlib.h>#include <stddef.h>#include <ctype.h>#include <stdio.h>#include <errno.h>#ifndef HAVE_PORTABLE_PROTOTYPE#include "cdecl_ext.h"#endif #ifndef HAVE_U_INT32_T#include "bittypes.h"#endif #ifndef HAVE_SOCKADDR_STORAGE#ifndef __MINGW32__#include "sockstorage.h"#endif#endif #ifdef NEED_ADDRINFO_H#include "addrinfo.h"#ifdef WIN32#include "IP6_misc.h"#endif#endif#if defined(__KAME__) && defined(INET6)# define FAITH#endif#define SUCCESS 0#define ANY 0#define YES 1#define NO  0#ifdef FAITHstatic int translate = NO;static struct in6_addr faith_prefix = IN6ADDR_ANY_INIT;#endifstatic const char in_addrany[] = { 0, 0, 0, 0 };static const char in6_addrany[] = {	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};static const char in_loopback[] = { 127, 0, 0, 1 }; static const char in6_loopback[] = {	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};struct sockinet {	u_char	si_len;	u_char	si_family;	u_short	si_port;	u_int32_t si_scope_id;};static const struct afd {	int a_af;	int a_addrlen;	int a_socklen;	int a_off;	const char *a_addrany;	const char *a_loopback;		int a_scoped;} afdl [] = {#ifdef INET6	{PF_INET6, sizeof(struct in6_addr),	 sizeof(struct sockaddr_in6),	 offsetof(struct sockaddr_in6, sin6_addr),	 in6_addrany, in6_loopback, 1},#endif	{PF_INET, sizeof(struct in_addr),	 sizeof(struct sockaddr_in),	 offsetof(struct sockaddr_in, sin_addr),	 in_addrany, in_loopback, 0},	{0, 0, 0, 0, NULL, NULL, 0},};struct explore {	int e_af;	int e_socktype;	int e_protocol;	const char *e_protostr;	int e_wild;#define WILD_AF(ex)		((ex)->e_wild & 0x01)#define WILD_SOCKTYPE(ex)	((ex)->e_wild & 0x02)#define WILD_PROTOCOL(ex)	((ex)->e_wild & 0x04)};static const struct explore explore[] = {#if 0	{ PF_LOCAL, 0, ANY, ANY, NULL, 0x01 },#endif#ifdef INET6	{ PF_INET6, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },	{ PF_INET6, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },	{ PF_INET6, SOCK_RAW, ANY, NULL, 0x05 },#endif	{ PF_INET, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },	{ PF_INET, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },	{ PF_INET, SOCK_RAW, ANY, NULL, 0x05 },	{ -1, 0, 0, NULL, 0 },};#ifdef INET6#define PTON_MAX	16#else#define PTON_MAX	4#endifstatic int str_isnumber __P((const char *));static int explore_fqdn __P((const struct addrinfo *, const char *,	const char *, struct addrinfo **));static int explore_null __P((const struct addrinfo *, const char *,	const char *, struct addrinfo **));static int explore_numeric __P((const struct addrinfo *, const char *,	const char *, struct addrinfo **));static int explore_numeric_scope __P((const struct addrinfo *, const char *,	const char *, struct addrinfo **));static int get_name __P((const char *, const struct afd *, struct addrinfo **,	char *, const struct addrinfo *, const char *));static int get_canonname __P((const struct addrinfo *,	struct addrinfo *, const char *));static struct addrinfo *get_ai __P((const struct addrinfo *,	const struct afd *, const char *));static int get_portmatch __P((const struct addrinfo *, const char *));static int get_port __P((struct addrinfo *, const char *, int));static const struct afd *find_afd __P((int));static char *ai_errlist[] = {	"Success",	"Address family for hostname not supported",	/* EAI_ADDRFAMILY */	"Temporary failure in name resolution",		/* EAI_AGAIN      */	"Invalid value for ai_flags",		       	/* EAI_BADFLAGS   */	"Non-recoverable failure in name resolution", 	/* EAI_FAIL       */	"ai_family not supported",			/* EAI_FAMILY     */	"Memory allocation failure", 			/* EAI_MEMORY     */	"No address associated with hostname", 		/* EAI_NODATA     */	"hostname nor servname provided, or not known",	/* EAI_NONAME     */	"servname not supported for ai_socktype",	/* EAI_SERVICE    */	"ai_socktype not supported", 			/* EAI_SOCKTYPE   */	"System error returned in errno", 		/* EAI_SYSTEM     */	"Invalid value for hints",			/* EAI_BADHINTS	  */	"Resolved protocol is unknown",			/* EAI_PROTOCOL   */	"Unknown error", 				/* EAI_MAX        */};/* XXX macros that make external reference is BAD. */#define GET_AI(ai, afd, addr) \do { \	/* external reference: pai, error, and label free */ \	(ai) = get_ai(pai, (afd), (addr)); \	if ((ai) == NULL) { \		error = EAI_MEMORY; \		goto free; \	} \} while (0)#define GET_PORT(ai, serv) \do { \	/* external reference: error and label free */ \	error = get_port((ai), (serv), 0); \	if (error != 0) \		goto free; \} while (0)#define GET_CANONNAME(ai, str) \do { \	/* external reference: pai, error and label free */ \	error = get_canonname(pai, (ai), (str)); \	if (error != 0) \		goto free; \} while (0)#define ERR(err) \do { \	/* external reference: error, and label bad */ \	error = (err); \	goto bad; \} while (0)#define MATCH_FAMILY(x, y, w) \	((x) == (y) || ((w) && ((x) == PF_UNSPEC || (y) == PF_UNSPEC)))#define MATCH(x, y, w) \	((x) == (y) || ((w) && ((x) == ANY || (y) == ANY)))char *gai_strerror(ecode)	int ecode;{	if (ecode < 0 || ecode > EAI_MAX)		ecode = EAI_MAX;	return ai_errlist[ecode];}voidfreeaddrinfo(ai)	struct addrinfo *ai;{	struct addrinfo *next;	do {		next = ai->ai_next;		if (ai->ai_canonname)			free(ai->ai_canonname);		/* no need to free(ai->ai_addr) */		free(ai);	} while ((ai = next) != NULL);}static intstr_isnumber(p)	const char *p;{	char *q = (char *)p;	while (*q) {		if (! isdigit(*q))			return NO;		q++;	}	return YES;}intgetaddrinfo(hostname, servname, hints, res)	const char *hostname, *servname;	const struct addrinfo *hints;	struct addrinfo **res;{	struct addrinfo sentinel;	struct addrinfo *cur;	int error = 0;	struct addrinfo ai;	struct addrinfo ai0;	struct addrinfo *pai;	const struct afd *afd;	const struct explore *ex;#ifdef FAITH	static int firsttime = 1;	if (firsttime) {		/* translator hack */		char *q = getenv("GAI");		if (q && inet_pton(AF_INET6, q, &faith_prefix) == 1)			translate = YES;		firsttime = 0;	}#endif	sentinel.ai_next = NULL;	cur = &sentinel;	pai = &ai;	pai->ai_flags = 0;	pai->ai_family = PF_UNSPEC;	pai->ai_socktype = ANY;	pai->ai_protocol = ANY;	pai->ai_addrlen = 0;	pai->ai_canonname = NULL;	pai->ai_addr = NULL;	pai->ai_next = NULL;		if (hostname == NULL && servname == NULL)		return EAI_NONAME;	if (hints) {		/* error check for hints */		if (hints->ai_addrlen || hints->ai_canonname ||		    hints->ai_addr || hints->ai_next)			ERR(EAI_BADHINTS); /* xxx */		if (hints->ai_flags & ~AI_MASK)			ERR(EAI_BADFLAGS);		switch (hints->ai_family) {		case PF_UNSPEC:		case PF_INET:#ifdef INET6		case PF_INET6:#endif			break;		default:			ERR(EAI_FAMILY);		}		memcpy(pai, hints, sizeof(*pai));		/*		 * if both socktype/protocol are specified, check if they		 * are meaningful combination.		 */		if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) {			for (ex = explore; ex->e_af >= 0; ex++) {				if (pai->ai_family != ex->e_af)					continue;				if (ex->e_socktype == ANY)					continue;				if (ex->e_protocol == ANY)					continue;				if (pai->ai_socktype == ex->e_socktype				 && pai->ai_protocol != ex->e_protocol) {					ERR(EAI_BADHINTS);				}			}		}	}	/*	 * check for special cases.  (1) numeric servname is disallowed if	 * socktype/protocol are left unspecified. (2) servname is disallowed	 * for raw and other inet{,6} sockets.	 */	if (MATCH_FAMILY(pai->ai_family, PF_INET, 1)#ifdef PF_INET6	 || MATCH_FAMILY(pai->ai_family, PF_INET6, 1)#endif	    ) {		ai0 = *pai;		if (pai->ai_family == PF_UNSPEC) {#ifdef PF_INET6			pai->ai_family = PF_INET6;#else			pai->ai_family = PF_INET;#endif		}		error = get_portmatch(pai, servname);		if (error)			ERR(error);		*pai = ai0;	}	ai0 = *pai;	/* NULL hostname, or numeric hostname */	for (ex = explore; ex->e_af >= 0; ex++) {		*pai = ai0;		if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))			continue;		if (!MATCH(pai->ai_socktype, ex->e_socktype, WILD_SOCKTYPE(ex)))			continue;		if (!MATCH(pai->ai_protocol, ex->e_protocol, WILD_PROTOCOL(ex)))			continue;		if (pai->ai_family == PF_UNSPEC)			pai->ai_family = ex->e_af;		if (pai->ai_socktype == ANY && ex->e_socktype != ANY)			pai->ai_socktype = ex->e_socktype;		if (pai->ai_protocol == ANY && ex->e_protocol != ANY)			pai->ai_protocol = ex->e_protocol;		if (hostname == NULL)			error = explore_null(pai, hostname, servname, &cur->ai_next);		else			error = explore_numeric_scope(pai, hostname, servname, &cur->ai_next);		if (error)			goto free;		while (cur && cur->ai_next)			cur = cur->ai_next;	}	/*	 * XXX	 * If numreic representation of AF1 can be interpreted as FQDN	 * representation of AF2, we need to think again about the code below.	 */	if (sentinel.ai_next)		goto good;	if (pai->ai_flags & AI_NUMERICHOST)		ERR(EAI_NONAME);	if (hostname == NULL)		ERR(EAI_NONAME);	/*	 * hostname as alphabetical name.	 * we would like to prefer AF_INET6 than AF_INET, so we'll make a	 * outer loop by AFs.	 */	for (afd = afdl; afd->a_af; afd++) {		*pai = ai0;		if (!MATCH_FAMILY(pai->ai_family, afd->a_af, 1))			continue;		for (ex = explore; ex->e_af >= 0; ex++) {			*pai = ai0;			if (pai->ai_family == PF_UNSPEC)				pai->ai_family = afd->a_af;			if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))				continue;			if (!MATCH(pai->ai_socktype, ex->e_socktype,					WILD_SOCKTYPE(ex))) {				continue;			}			if (!MATCH(pai->ai_protocol, ex->e_protocol,					WILD_PROTOCOL(ex))) {				continue;			}			if (pai->ai_family == PF_UNSPEC)				pai->ai_family = ex->e_af;			if (pai->ai_socktype == ANY && ex->e_socktype != ANY)				pai->ai_socktype = ex->e_socktype;			if (pai->ai_protocol == ANY && ex->e_protocol != ANY)				pai->ai_protocol = ex->e_protocol;			error = explore_fqdn(pai, hostname, servname,				&cur->ai_next);			while (cur && cur->ai_next)				cur = cur->ai_next;		}	}	/* XXX */	if (sentinel.ai_next)		error = 0;	if (error)		goto free;	if (error == 0) {		if (sentinel.ai_next) { good:			*res = sentinel.ai_next;			return SUCCESS;		} else			error = EAI_FAIL;	} free: bad:	if (sentinel.ai_next)		freeaddrinfo(sentinel.ai_next);	*res = NULL;	return error;}/* * FQDN hostname, DNS lookup */static intexplore_fqdn(pai, hostname, servname, res)	const struct addrinfo *pai;	const char *hostname;	const char *servname;	struct addrinfo **res;{	struct hostent *hp;	int h_error;	int af;	char **aplist = NULL, *apbuf = NULL;	char *ap;	struct addrinfo sentinel, *cur;	int i;#ifndef USE_GETIPNODEBY	int naddrs;#endif	const struct afd *afd;	int error;	*res = NULL;	sentinel.ai_next = NULL;	cur = &sentinel;	/*	 * Do not filter unsupported AFs here.  We need to honor content of	 * databases (/etc/hosts, DNS and others).  Otherwise we cannot	 * replace gethostbyname() by getaddrinfo().	 */	/*	 * if the servname does not match socktype/protocol, ignore it.	 */	if (get_portmatch(pai, servname) != 0)		return 0;	afd = find_afd(pai->ai_family);	/*	 * post-RFC2553: should look at (pai->ai_flags & AI_ADDRCONFIG)	 * rather than hardcoding it.  we may need to add AI_ADDRCONFIG	 * handling code by ourselves in case we don't have getipnodebyname().	 */#ifdef USE_GETIPNODEBY	hp = getipnodebyname(hostname, pai->ai_family, AI_ADDRCONFIG, &h_error);#else#ifdef HAVE_GETHOSTBYNAME2	hp = gethostbyname2(hostname, pai->ai_family);#else	if (pai->ai_family != AF_INET)