Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/asr/gethostnamadr_async.c	Lines:	0	278	0.0 %
Date:	2017-11-13	Branches:	0	188	0.0 %


/*	$OpenBSD: gethostnamadr_async.c,v 1.43 2017/02/23 17:04:02 eric Exp $	*/
/*
 * Copyright (c) 2012 Eric Faurot <eric@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

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

#include <asr.h>
#include <ctype.h>
#include <errno.h>
#include <resolv.h> /* for res_hnok */
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

#include "asr_private.h"

#define MAXALIASES	35
#define MAXADDRS	35

struct hostent_ext {
	struct hostent	 h;
	char		*aliases[MAXALIASES + 1];
	char		*addrs[MAXADDRS + 1];
	char		*end;
	char		*pos;
};

static int gethostnamadr_async_run(struct asr_query *, struct asr_result *);
static struct hostent_ext *hostent_alloc(int);
static int hostent_set_cname(struct hostent_ext *, const char *, int);
static int hostent_add_alias(struct hostent_ext *, const char *, int);
static int hostent_add_addr(struct hostent_ext *, const void *, size_t);
static struct hostent_ext *hostent_from_addr(int, const char *, const char *);
static struct hostent_ext *hostent_file_match(FILE *, int, int, const char *,
    int);
static struct hostent_ext *hostent_from_packet(int, int, char *, size_t);

struct asr_query *
gethostbyname_async(const char *name, void *asr)
{
	return gethostbyname2_async(name, AF_INET, asr);
}
DEF_WEAK(gethostbyname_async);

struct asr_query *
gethostbyname2_async(const char *name, int af, void *asr)
{
	struct asr_ctx	 *ac;
	struct asr_query *as;

	/* the original segfaults */
	if (name == NULL) {
		errno = EINVAL;
		return (NULL);
	}

	ac = _asr_use_resolver(asr);
	if ((as = _asr_async_new(ac, ASR_GETHOSTBYNAME)) == NULL)
		goto abort; /* errno set */
	as->as_run = gethostnamadr_async_run;

	as->as.hostnamadr.family = af;
	if (af == AF_INET)
		as->as.hostnamadr.addrlen = INADDRSZ;
	else if (af == AF_INET6)
		as->as.hostnamadr.addrlen = IN6ADDRSZ;
	as->as.hostnamadr.name = strdup(name);
	if (as->as.hostnamadr.name == NULL)
		goto abort; /* errno set */

	_asr_ctx_unref(ac);
	return (as);

    abort:
	if (as)
		_asr_async_free(as);
	_asr_ctx_unref(ac);
	return (NULL);
}
DEF_WEAK(gethostbyname2_async);

struct asr_query *
gethostbyaddr_async(const void *addr, socklen_t len, int af, void *asr)
{
	struct asr_ctx	 *ac;
	struct asr_query *as;

	ac = _asr_use_resolver(asr);
	as = _gethostbyaddr_async_ctx(addr, len, af, ac);
	_asr_ctx_unref(ac);

	return (as);
}
DEF_WEAK(gethostbyaddr_async);

struct asr_query *
_gethostbyaddr_async_ctx(const void *addr, socklen_t len, int af,
    struct asr_ctx *ac)
{
	struct asr_query *as;

	if ((as = _asr_async_new(ac, ASR_GETHOSTBYADDR)) == NULL)
		goto abort; /* errno set */
	as->as_run = gethostnamadr_async_run;

	as->as.hostnamadr.family = af;
	as->as.hostnamadr.addrlen = len;
	if (len > 0)
		memmove(as->as.hostnamadr.addr, addr, (len > 16) ? 16 : len);

	return (as);

    abort:
	if (as)
		_asr_async_free(as);
	return (NULL);
}

static int
gethostnamadr_async_run(struct asr_query *as, struct asr_result *ar)
{
	struct hostent_ext	*h;
	int			 r, type, saved_errno;
	FILE			*f;
	char			 name[MAXDNAME], *data, addr[16], *c;

    next:
	switch (as->as_state) {

	case ASR_STATE_INIT:

		if (as->as.hostnamadr.family != AF_INET &&
		    as->as.hostnamadr.family != AF_INET6) {
			ar->ar_h_errno = NETDB_INTERNAL;
			ar->ar_errno = EAFNOSUPPORT;
			async_set_state(as, ASR_STATE_HALT);
			break;
		}

		if ((as->as.hostnamadr.family == AF_INET &&
		     as->as.hostnamadr.addrlen != INADDRSZ) ||
		    (as->as.hostnamadr.family == AF_INET6 &&
		     as->as.hostnamadr.addrlen != IN6ADDRSZ)) {
			ar->ar_h_errno = NETDB_INTERNAL;
			ar->ar_errno = EINVAL;
			async_set_state(as, ASR_STATE_HALT);
			break;
		}

		if (as->as_type == ASR_GETHOSTBYNAME) {

			if (as->as.hostnamadr.name[0] == '\0') {
				ar->ar_h_errno = NO_DATA;
				async_set_state(as, ASR_STATE_HALT);
				break;
			}

			/* Name might be an IP address string */
			for (c = as->as.hostnamadr.name; *c; c++)
				if (!isdigit((unsigned char)*c) &&
				     *c != '.' && *c != ':')
					break;
			if (*c == 0 &&
			    inet_pton(as->as.hostnamadr.family,
			    as->as.hostnamadr.name, addr) == 1) {
				h = hostent_from_addr(as->as.hostnamadr.family,
				    as->as.hostnamadr.name, addr);
				if (h == NULL) {
					ar->ar_errno = errno;
					ar->ar_h_errno = NETDB_INTERNAL;
				}
				else {
					ar->ar_hostent = &h->h;
					ar->ar_h_errno = NETDB_SUCCESS;
				}
				async_set_state(as, ASR_STATE_HALT);
				break;
			}
		}
		async_set_state(as, ASR_STATE_NEXT_DB);
		break;

	case ASR_STATE_NEXT_DB:

		if (_asr_iter_db(as) == -1) {
			async_set_state(as, ASR_STATE_NOT_FOUND);
			break;
		}

		switch (AS_DB(as)) {

		case ASR_DB_DNS:

			/* Create a subquery to do the DNS lookup */

			if (as->as_type == ASR_GETHOSTBYNAME) {
				type = (as->as.hostnamadr.family == AF_INET) ?
				    T_A : T_AAAA;
				as->as_subq = _res_search_async_ctx(
				    as->as.hostnamadr.name,
				    C_IN, type, as->as_ctx);
			} else {
				_asr_addr_as_fqdn(as->as.hostnamadr.addr,
				    as->as.hostnamadr.family,
				    name, sizeof(name));
				as->as_subq = _res_query_async_ctx(
				    name, C_IN, T_PTR, as->as_ctx);
			}

			if (as->as_subq == NULL) {
				ar->ar_errno = errno;
				ar->ar_h_errno = NETDB_INTERNAL;
				async_set_state(as, ASR_STATE_HALT);
				break;
			}

			async_set_state(as, ASR_STATE_SUBQUERY);
			break;

		case ASR_DB_FILE:

			/* Try to find a match in the host file */

			if ((f = fopen(_PATH_HOSTS, "re")) == NULL)
				break;

			if (as->as_type == ASR_GETHOSTBYNAME)
				data = as->as.hostnamadr.name;
			else
				data = as->as.hostnamadr.addr;

			h = hostent_file_match(f, as->as_type,
			    as->as.hostnamadr.family, data,
			    as->as.hostnamadr.addrlen);
			saved_errno = errno;
			fclose(f);
			errno = saved_errno;

			if (h == NULL) {
				if (errno) {
					ar->ar_errno = errno;
					ar->ar_h_errno = NETDB_INTERNAL;
					async_set_state(as, ASR_STATE_HALT);
				}
				/* otherwise not found */
				break;
			}
			ar->ar_hostent = &h->h;
			ar->ar_h_errno = NETDB_SUCCESS;
			async_set_state(as, ASR_STATE_HALT);
			break;
		}
		break;

	case ASR_STATE_SUBQUERY:

		/* Run the DNS subquery. */

		if ((r = asr_run(as->as_subq, ar)) == ASYNC_COND)
			return (ASYNC_COND);

		/* Done. */
		as->as_subq = NULL;

		if (ar->ar_datalen == -1) {
			async_set_state(as, ASR_STATE_NEXT_DB);
			break;
		}

		/* If we got a packet but no anwser, use the next DB. */
		if (ar->ar_count == 0) {
			free(ar->ar_data);
			as->as.hostnamadr.subq_h_errno = ar->ar_h_errno;
			async_set_state(as, ASR_STATE_NEXT_DB);
			break;
		}

		/* Read the hostent from the packet. */

		h = hostent_from_packet(as->as_type,
		    as->as.hostnamadr.family, ar->ar_data, ar->ar_datalen);
		free(ar->ar_data);
		if (h == NULL) {
			ar->ar_errno = errno;
			ar->ar_h_errno = NETDB_INTERNAL;
			async_set_state(as, ASR_STATE_HALT);
			break;
		}

		if (as->as_type == ASR_GETHOSTBYADDR) {
			if (hostent_add_addr(h, as->as.hostnamadr.addr,
			    as->as.hostnamadr.addrlen) == -1) {
				free(h);
				ar->ar_errno = errno;
				ar->ar_h_errno = NETDB_INTERNAL;
				async_set_state(as, ASR_STATE_HALT);
				break;
			}
		}

		/*
		 * No valid hostname or address found in the dns packet.
		 * Ignore it.
		 */
		if ((as->as_type == ASR_GETHOSTBYNAME &&
		     h->h.h_addr_list[0] == NULL) ||
		    h->h.h_name == NULL) {
			free(h);
			async_set_state(as, ASR_STATE_NEXT_DB);
			break;
		}

		ar->ar_hostent = &h->h;
		ar->ar_h_errno = NETDB_SUCCESS;
		async_set_state(as, ASR_STATE_HALT);
		break;

	case ASR_STATE_NOT_FOUND:
		ar->ar_errno = 0;
		if (as->as.hostnamadr.subq_h_errno)
			ar->ar_h_errno = as->as.hostnamadr.subq_h_errno;
		else
			ar->ar_h_errno = HOST_NOT_FOUND;
		async_set_state(as, ASR_STATE_HALT);
		break;

	case ASR_STATE_HALT:
		if (ar->ar_h_errno)
			ar->ar_hostent = NULL;
		else
			ar->ar_errno = 0;
		return (ASYNC_DONE);

	default:
		ar->ar_errno = EOPNOTSUPP;
		ar->ar_h_errno = NETDB_INTERNAL;
		ar->ar_gai_errno = EAI_SYSTEM;
		async_set_state(as, ASR_STATE_HALT);
		break;
	}
	goto next;
}

/*
 * Create a hostent from a numeric address string.
 */
static struct hostent_ext *
hostent_from_addr(int family, const char *name, const char *addr)
{
	struct	 hostent_ext *h;

	if ((h = hostent_alloc(family)) == NULL)
		return (NULL);
	if (hostent_set_cname(h, name, 0) == -1)
		goto fail;
	if (hostent_add_addr(h, addr, h->h.h_length) == -1)
		goto fail;
	return (h);
fail:
	free(h);
	return (NULL);
}

/*
 * Lookup the first matching entry in the hostfile, either by address or by
 * name depending on reqtype, and build a hostent from the line.
 */
static struct hostent_ext *
hostent_file_match(FILE *f, int reqtype, int family, const char *data,
    int datalen)
{
	char	*tokens[MAXTOKEN], addr[16], buf[BUFSIZ + 1];
	struct	 hostent_ext *h;
	int	 n, i;

	for (;;) {
		n = _asr_parse_namedb_line(f, tokens, MAXTOKEN, buf, sizeof(buf));
		if (n == -1) {
			errno = 0; /* ignore errors reading the file */
			return (NULL);
		}

		/* there must be an address and at least one name */
		if (n < 2)
			continue;

		if (reqtype == ASR_GETHOSTBYNAME) {
			for (i = 1; i < n; i++) {
				if (strcasecmp(data, tokens[i]))
					continue;
				if (inet_pton(family, tokens[0], addr) == 1)
					goto found;
			}
		} else {
			if (inet_pton(family, tokens[0], addr) == 1 &&
			    memcmp(addr, data, datalen) == 0)
				goto found;
		}
	}

found:
	if ((h = hostent_alloc(family)) == NULL)
		return (NULL);
	if (hostent_set_cname(h, tokens[1], 0) == -1)
		goto fail;
	for (i = 2; i < n; i ++)
		if (hostent_add_alias(h, tokens[i], 0) == -1)
			goto fail;
	if (hostent_add_addr(h, addr, h->h.h_length) == -1)
		goto fail;
	return (h);
fail:
	free(h);
	return (NULL);
}

/*
 * Fill the hostent from the given DNS packet.
 */
static struct hostent_ext *
hostent_from_packet(int reqtype, int family, char *pkt, size_t pktlen)
{
	struct hostent_ext	*h;
	struct asr_unpack	 p;
	struct asr_dns_header	 hdr;
	struct asr_dns_query	 q;
	struct asr_dns_rr	 rr;
	char			 dname[MAXDNAME];

	if ((h = hostent_alloc(family)) == NULL)
		return (NULL);

	_asr_unpack_init(&p, pkt, pktlen);
	_asr_unpack_header(&p, &hdr);
	for (; hdr.qdcount; hdr.qdcount--)
		_asr_unpack_query(&p, &q);
	strlcpy(dname, q.q_dname, sizeof(dname));

	for (; hdr.ancount; hdr.ancount--) {
		_asr_unpack_rr(&p, &rr);
		if (rr.rr_class != C_IN)
			continue;
		switch (rr.rr_type) {

		case T_CNAME:
			if (reqtype == ASR_GETHOSTBYNAME) {
				if (hostent_add_alias(h, rr.rr_dname, 1) == -1)
					goto fail;
			} else {
				if (strcasecmp(rr.rr_dname, dname) == 0)
					strlcpy(dname, rr.rr.cname.cname,
					    sizeof(dname));
			}
			break;

		case T_PTR:
			if (reqtype != ASR_GETHOSTBYADDR)
				break;
			if (strcasecmp(rr.rr_dname, dname) != 0)
				continue;
			if (hostent_set_cname(h, rr.rr.ptr.ptrname, 1) == -1)
				hostent_add_alias(h, rr.rr.ptr.ptrname, 1);
			break;

		case T_A:
			if (reqtype != ASR_GETHOSTBYNAME)
				break;
			if (family != AF_INET)
				break;
			if (hostent_set_cname(h, rr.rr_dname, 1) == -1)
				;
			if (hostent_add_addr(h, &rr.rr.in_a.addr, 4) == -1)
				goto fail;
			break;

		case T_AAAA:
			if (reqtype != ASR_GETHOSTBYNAME)
				break;
			if (family != AF_INET6)
				break;
			if (hostent_set_cname(h, rr.rr_dname, 1) == -1)
				;
			if (hostent_add_addr(h, &rr.rr.in_aaaa.addr6, 16) == -1)
				goto fail;
			break;
		}
	}

	return (h);
fail:
	free(h);
	return (NULL);
}

static struct hostent_ext *
hostent_alloc(int family)
{
	struct hostent_ext	*h;
	size_t			alloc;

	alloc = sizeof(*h) + 1024;
	if ((h = calloc(1, alloc)) == NULL)
		return (NULL);

	h->h.h_addrtype = family;
	h->h.h_length = (family == AF_INET) ? 4 : 16;
	h->h.h_aliases = h->aliases;
	h->h.h_addr_list = h->addrs;
	h->pos = (char *)(h) + sizeof(*h);
	h->end = h->pos + 1024;

	return (h);
}

static int
hostent_set_cname(struct hostent_ext *h, const char *name, int isdname)
{
	char	buf[MAXDNAME];
	size_t	n;

	if (h->h.h_name)
		return (-1);

	if (isdname) {
		_asr_strdname(name, buf, sizeof buf);
		buf[strlen(buf) - 1] = '\0';
		if (!res_hnok(buf))
			return (-1);
		name = buf;
	}

	n = strlen(name) + 1;
	if (h->pos + n >= h->end)
		return (-1);

	h->h.h_name = h->pos;
	memmove(h->pos, name, n);
	h->pos += n;
	return (0);
}

static int
hostent_add_alias(struct hostent_ext *h, const char *name, int isdname)
{
	char	buf[MAXDNAME];
	size_t	i, n;

	for (i = 0; i < MAXALIASES; i++)
		if (h->aliases[i] == NULL)
			break;
	if (i == MAXALIASES)
		return (0);

	if (isdname) {
		_asr_strdname(name, buf, sizeof buf);
		buf[strlen(buf)-1] = '\0';
		if (!res_hnok(buf))
			return (-1);
		name = buf;
	}

	n = strlen(name) + 1;
	if (h->pos + n >= h->end)
		return (0);

	h->aliases[i] = h->pos;
	memmove(h->pos, name, n);
	h->pos += n;
	return (0);
}

static int
hostent_add_addr(struct hostent_ext *h, const void *addr, size_t size)
{
	int	i;

	for (i = 0; i < MAXADDRS; i++)
		if (h->addrs[i] == NULL)
			break;
	if (i == MAXADDRS)
		return (0);

	if (h->pos + size >= h->end)
		return (0);

	h->addrs[i] = h->pos;
	memmove(h->pos, addr, size);
	h->pos += size;
	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: gethostnamadr_async.c,v 1.43 2017/02/23 17:04:02 eric Exp $ */
2			/*
3			* Copyright (c) 2012 Eric Faurot <eric@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/types.h>
19			#include <sys/socket.h>
20			#include <netinet/in.h>
21			#include <arpa/inet.h>
22			#include <arpa/nameser.h>
23			#include <netdb.h>
24
25			#include <asr.h>
26			#include <ctype.h>
27			#include <errno.h>
28			#include <resolv.h> /* for res_hnok */
29			#include <stdlib.h>
30			#include <string.h>
31			#include <unistd.h>
32			#include <limits.h>
33
34			#include "asr_private.h"
35
36			#define MAXALIASES 35
37			#define MAXADDRS 35
38
39			struct hostent_ext {
40			struct hostent h;
41			char *aliases[MAXALIASES + 1];
42			char *addrs[MAXADDRS + 1];
43			char *end;
44			char *pos;
45			};
46
47			static int gethostnamadr_async_run(struct asr_query , struct asr_result );
48			static struct hostent_ext *hostent_alloc(int);
49			static int hostent_set_cname(struct hostent_ext , const char , int);
50			static int hostent_add_alias(struct hostent_ext , const char , int);
51			static int hostent_add_addr(struct hostent_ext , const void , size_t);
52			static struct hostent_ext hostent_from_addr(int, const char , const char *);
53			static struct hostent_ext hostent_file_match(FILE , int, int, const char *,
54			int);
55			static struct hostent_ext hostent_from_packet(int, int, char , size_t);
56
57			struct asr_query *
58			gethostbyname_async(const char name, void asr)
59			{
60			return gethostbyname2_async(name, AF_INET, asr);
61			}
62			DEF_WEAK(gethostbyname_async);
63
64			struct asr_query *
65			gethostbyname2_async(const char name, int af, void asr)
66			{
67			struct asr_ctx *ac;
68			struct asr_query *as;
69
70			/* the original segfaults */
71			if (name == NULL) {
72			errno = EINVAL;
73			return (NULL);
74			}
75
76			ac = _asr_use_resolver(asr);
77			if ((as = _asr_async_new(ac, ASR_GETHOSTBYNAME)) == NULL)
78			goto abort; /* errno set */
79			as->as_run = gethostnamadr_async_run;
80
81			as->as.hostnamadr.family = af;
82			if (af == AF_INET)
83			as->as.hostnamadr.addrlen = INADDRSZ;
84			else if (af == AF_INET6)
85			as->as.hostnamadr.addrlen = IN6ADDRSZ;
86			as->as.hostnamadr.name = strdup(name);
87			if (as->as.hostnamadr.name == NULL)
88			goto abort; /* errno set */
89
90			_asr_ctx_unref(ac);
91			return (as);
92
93			abort:
94			if (as)
95			_asr_async_free(as);
96			_asr_ctx_unref(ac);
97			return (NULL);
98			}
99			DEF_WEAK(gethostbyname2_async);
100
101			struct asr_query *
102			gethostbyaddr_async(const void addr, socklen_t len, int af, void asr)
103			{
104			struct asr_ctx *ac;
105			struct asr_query *as;
106
107			ac = _asr_use_resolver(asr);
108			as = _gethostbyaddr_async_ctx(addr, len, af, ac);
109			_asr_ctx_unref(ac);
110
111			return (as);
112			}
113			DEF_WEAK(gethostbyaddr_async);
114
115			struct asr_query *
116			_gethostbyaddr_async_ctx(const void *addr, socklen_t len, int af,
117			struct asr_ctx *ac)
118			{
119			struct asr_query *as;
120
121			if ((as = _asr_async_new(ac, ASR_GETHOSTBYADDR)) == NULL)
122			goto abort; /* errno set */
123			as->as_run = gethostnamadr_async_run;
124
125			as->as.hostnamadr.family = af;
126			as->as.hostnamadr.addrlen = len;
127			if (len > 0)
128			memmove(as->as.hostnamadr.addr, addr, (len > 16) ? 16 : len);
129
130			return (as);
131
132			abort:
133			if (as)
134			_asr_async_free(as);
135			return (NULL);
136			}
137
138			static int
139			gethostnamadr_async_run(struct asr_query as, struct asr_result ar)
140			{
141			struct hostent_ext *h;
142			int r, type, saved_errno;
143			FILE *f;
144			char name[MAXDNAME], data, addr[16], c;
145
146			next:
147			switch (as->as_state) {
148
149			case ASR_STATE_INIT:
150
151			if (as->as.hostnamadr.family != AF_INET &&
152			as->as.hostnamadr.family != AF_INET6) {
153			ar->ar_h_errno = NETDB_INTERNAL;
154			ar->ar_errno = EAFNOSUPPORT;
155			async_set_state(as, ASR_STATE_HALT);
156			break;
157			}
158
159			if ((as->as.hostnamadr.family == AF_INET &&
160			as->as.hostnamadr.addrlen != INADDRSZ) \|\|
161			(as->as.hostnamadr.family == AF_INET6 &&
162			as->as.hostnamadr.addrlen != IN6ADDRSZ)) {
163			ar->ar_h_errno = NETDB_INTERNAL;
164			ar->ar_errno = EINVAL;
165			async_set_state(as, ASR_STATE_HALT);
166			break;
167			}
168
169			if (as->as_type == ASR_GETHOSTBYNAME) {
170
171			if (as->as.hostnamadr.name[0] == '\0') {
172			ar->ar_h_errno = NO_DATA;
173			async_set_state(as, ASR_STATE_HALT);
174			break;
175			}
176
177			/* Name might be an IP address string */
178			for (c = as->as.hostnamadr.name; *c; c++)
179			if (!isdigit((unsigned char)*c) &&
180			c != '.' && c != ':')
181			break;
182			if (*c == 0 &&
183			inet_pton(as->as.hostnamadr.family,
184			as->as.hostnamadr.name, addr) == 1) {
185			h = hostent_from_addr(as->as.hostnamadr.family,
186			as->as.hostnamadr.name, addr);
187			if (h == NULL) {
188			ar->ar_errno = errno;
189			ar->ar_h_errno = NETDB_INTERNAL;
190			}
191			else {
192			ar->ar_hostent = &h->h;
193			ar->ar_h_errno = NETDB_SUCCESS;
194			}
195			async_set_state(as, ASR_STATE_HALT);
196			break;
197			}
198			}
199			async_set_state(as, ASR_STATE_NEXT_DB);
200			break;
201
202			case ASR_STATE_NEXT_DB:
203
204			if (_asr_iter_db(as) == -1) {
205			async_set_state(as, ASR_STATE_NOT_FOUND);
206			break;
207			}
208
209			switch (AS_DB(as)) {
210
211			case ASR_DB_DNS:
212
213			/* Create a subquery to do the DNS lookup */
214
215			if (as->as_type == ASR_GETHOSTBYNAME) {
216			type = (as->as.hostnamadr.family == AF_INET) ?
217			T_A : T_AAAA;
218			as->as_subq = _res_search_async_ctx(
219			as->as.hostnamadr.name,
220			C_IN, type, as->as_ctx);
221			} else {
222			_asr_addr_as_fqdn(as->as.hostnamadr.addr,
223			as->as.hostnamadr.family,
224			name, sizeof(name));
225			as->as_subq = _res_query_async_ctx(
226			name, C_IN, T_PTR, as->as_ctx);
227			}
228
229			if (as->as_subq == NULL) {
230			ar->ar_errno = errno;
231			ar->ar_h_errno = NETDB_INTERNAL;
232			async_set_state(as, ASR_STATE_HALT);
233			break;
234			}
235
236			async_set_state(as, ASR_STATE_SUBQUERY);
237			break;
238
239			case ASR_DB_FILE:
240
241			/* Try to find a match in the host file */
242
243			if ((f = fopen(_PATH_HOSTS, "re")) == NULL)
244			break;
245
246			if (as->as_type == ASR_GETHOSTBYNAME)
247			data = as->as.hostnamadr.name;
248			else
249			data = as->as.hostnamadr.addr;
250
251			h = hostent_file_match(f, as->as_type,
252			as->as.hostnamadr.family, data,
253			as->as.hostnamadr.addrlen);
254			saved_errno = errno;
255			fclose(f);
256			errno = saved_errno;
257
258			if (h == NULL) {
259			if (errno) {
260			ar->ar_errno = errno;
261			ar->ar_h_errno = NETDB_INTERNAL;
262			async_set_state(as, ASR_STATE_HALT);
263			}
264			/* otherwise not found */
265			break;
266			}
267			ar->ar_hostent = &h->h;
268			ar->ar_h_errno = NETDB_SUCCESS;
269			async_set_state(as, ASR_STATE_HALT);
270			break;
271			}
272			break;
273
274			case ASR_STATE_SUBQUERY:
275
276			/* Run the DNS subquery. */
277
278			if ((r = asr_run(as->as_subq, ar)) == ASYNC_COND)
279			return (ASYNC_COND);
280
281			/* Done. */
282			as->as_subq = NULL;
283
284			if (ar->ar_datalen == -1) {
285			async_set_state(as, ASR_STATE_NEXT_DB);
286			break;
287			}
288
289			/* If we got a packet but no anwser, use the next DB. */
290			if (ar->ar_count == 0) {
291			free(ar->ar_data);
292			as->as.hostnamadr.subq_h_errno = ar->ar_h_errno;
293			async_set_state(as, ASR_STATE_NEXT_DB);
294			break;
295			}
296
297			/* Read the hostent from the packet. */
298
299			h = hostent_from_packet(as->as_type,
300			as->as.hostnamadr.family, ar->ar_data, ar->ar_datalen);
301			free(ar->ar_data);
302			if (h == NULL) {
303			ar->ar_errno = errno;
304			ar->ar_h_errno = NETDB_INTERNAL;
305			async_set_state(as, ASR_STATE_HALT);
306			break;
307			}
308
309			if (as->as_type == ASR_GETHOSTBYADDR) {
310			if (hostent_add_addr(h, as->as.hostnamadr.addr,
311			as->as.hostnamadr.addrlen) == -1) {
312			free(h);
313			ar->ar_errno = errno;
314			ar->ar_h_errno = NETDB_INTERNAL;
315			async_set_state(as, ASR_STATE_HALT);
316			break;
317			}
318			}
319
320			/*
321			* No valid hostname or address found in the dns packet.
322			* Ignore it.
323			*/
324			if ((as->as_type == ASR_GETHOSTBYNAME &&
325			h->h.h_addr_list[0] == NULL) \|\|
326			h->h.h_name == NULL) {
327			free(h);
328			async_set_state(as, ASR_STATE_NEXT_DB);
329			break;
330			}
331
332			ar->ar_hostent = &h->h;
333			ar->ar_h_errno = NETDB_SUCCESS;
334			async_set_state(as, ASR_STATE_HALT);
335			break;
336
337			case ASR_STATE_NOT_FOUND:
338			ar->ar_errno = 0;
339			if (as->as.hostnamadr.subq_h_errno)
340			ar->ar_h_errno = as->as.hostnamadr.subq_h_errno;
341			else
342			ar->ar_h_errno = HOST_NOT_FOUND;
343			async_set_state(as, ASR_STATE_HALT);
344			break;
345
346			case ASR_STATE_HALT:
347			if (ar->ar_h_errno)
348			ar->ar_hostent = NULL;
349			else
350			ar->ar_errno = 0;
351			return (ASYNC_DONE);
352
353			default:
354			ar->ar_errno = EOPNOTSUPP;
355			ar->ar_h_errno = NETDB_INTERNAL;
356			ar->ar_gai_errno = EAI_SYSTEM;
357			async_set_state(as, ASR_STATE_HALT);
358			break;
359			}
360			goto next;
361			}
362
363			/*
364			* Create a hostent from a numeric address string.
365			*/
366			static struct hostent_ext *
367			hostent_from_addr(int family, const char name, const char addr)
368			{
369			struct hostent_ext *h;
370
371			if ((h = hostent_alloc(family)) == NULL)
372			return (NULL);
373			if (hostent_set_cname(h, name, 0) == -1)
374			goto fail;
375			if (hostent_add_addr(h, addr, h->h.h_length) == -1)
376			goto fail;
377			return (h);
378			fail:
379			free(h);
380			return (NULL);
381			}
382
383			/*
384			* Lookup the first matching entry in the hostfile, either by address or by
385			* name depending on reqtype, and build a hostent from the line.
386			*/
387			static struct hostent_ext *
388			hostent_file_match(FILE f, int reqtype, int family, const char data,
389			int datalen)
390			{
391			char *tokens[MAXTOKEN], addr[16], buf[BUFSIZ + 1];
392			struct hostent_ext *h;
393			int n, i;
394
395			for (;;) {
396			n = _asr_parse_namedb_line(f, tokens, MAXTOKEN, buf, sizeof(buf));
397			if (n == -1) {
398			errno = 0; /* ignore errors reading the file */
399			return (NULL);
400			}
401
402			/* there must be an address and at least one name */
403			if (n < 2)
404			continue;
405
406			if (reqtype == ASR_GETHOSTBYNAME) {
407			for (i = 1; i < n; i++) {
408			if (strcasecmp(data, tokens[i]))
409			continue;
410			if (inet_pton(family, tokens[0], addr) == 1)
411			goto found;
412			}
413			} else {
414			if (inet_pton(family, tokens[0], addr) == 1 &&
415			memcmp(addr, data, datalen) == 0)
416			goto found;
417			}
418			}
419
420			found:
421			if ((h = hostent_alloc(family)) == NULL)
422			return (NULL);
423			if (hostent_set_cname(h, tokens[1], 0) == -1)
424			goto fail;
425			for (i = 2; i < n; i ++)
426			if (hostent_add_alias(h, tokens[i], 0) == -1)
427			goto fail;
428			if (hostent_add_addr(h, addr, h->h.h_length) == -1)
429			goto fail;
430			return (h);
431			fail:
432			free(h);
433			return (NULL);
434			}
435
436			/*
437			* Fill the hostent from the given DNS packet.
438			*/
439			static struct hostent_ext *
440			hostent_from_packet(int reqtype, int family, char *pkt, size_t pktlen)
441			{
442			struct hostent_ext *h;
443			struct asr_unpack p;
444			struct asr_dns_header hdr;
445			struct asr_dns_query q;
446			struct asr_dns_rr rr;
447			char dname[MAXDNAME];
448
449			if ((h = hostent_alloc(family)) == NULL)
450			return (NULL);
451
452			_asr_unpack_init(&p, pkt, pktlen);
453			_asr_unpack_header(&p, &hdr);
454			for (; hdr.qdcount; hdr.qdcount--)
455			_asr_unpack_query(&p, &q);
456			strlcpy(dname, q.q_dname, sizeof(dname));
457
458			for (; hdr.ancount; hdr.ancount--) {
459			_asr_unpack_rr(&p, &rr);
460			if (rr.rr_class != C_IN)
461			continue;
462			switch (rr.rr_type) {
463
464			case T_CNAME:
465			if (reqtype == ASR_GETHOSTBYNAME) {
466			if (hostent_add_alias(h, rr.rr_dname, 1) == -1)
467			goto fail;
468			} else {
469			if (strcasecmp(rr.rr_dname, dname) == 0)
470			strlcpy(dname, rr.rr.cname.cname,
471			sizeof(dname));
472			}
473			break;
474
475			case T_PTR:
476			if (reqtype != ASR_GETHOSTBYADDR)
477			break;
478			if (strcasecmp(rr.rr_dname, dname) != 0)
479			continue;
480			if (hostent_set_cname(h, rr.rr.ptr.ptrname, 1) == -1)
481			hostent_add_alias(h, rr.rr.ptr.ptrname, 1);
482			break;
483
484			case T_A:
485			if (reqtype != ASR_GETHOSTBYNAME)
486			break;
487			if (family != AF_INET)
488			break;
489			if (hostent_set_cname(h, rr.rr_dname, 1) == -1)
490			;
491			if (hostent_add_addr(h, &rr.rr.in_a.addr, 4) == -1)
492			goto fail;
493			break;
494
495			case T_AAAA:
496			if (reqtype != ASR_GETHOSTBYNAME)
497			break;
498			if (family != AF_INET6)
499			break;
500			if (hostent_set_cname(h, rr.rr_dname, 1) == -1)
501			;
502			if (hostent_add_addr(h, &rr.rr.in_aaaa.addr6, 16) == -1)
503			goto fail;
504			break;
505			}
506			}
507
508			return (h);
509			fail:
510			free(h);
511			return (NULL);
512			}
513
514			static struct hostent_ext *
515			hostent_alloc(int family)
516			{
517			struct hostent_ext *h;
518			size_t alloc;
519
520			alloc = sizeof(*h) + 1024;
521			if ((h = calloc(1, alloc)) == NULL)
522			return (NULL);
523
524			h->h.h_addrtype = family;
525			h->h.h_length = (family == AF_INET) ? 4 : 16;
526			h->h.h_aliases = h->aliases;
527			h->h.h_addr_list = h->addrs;
528			h->pos = (char )(h) + sizeof(h);
529			h->end = h->pos + 1024;
530
531			return (h);
532			}
533
534			static int
535			hostent_set_cname(struct hostent_ext h, const char name, int isdname)
536			{
537			char buf[MAXDNAME];
538			size_t n;
539
540			if (h->h.h_name)
541			return (-1);
542
543			if (isdname) {
544			_asr_strdname(name, buf, sizeof buf);
545			buf[strlen(buf) - 1] = '\0';
546			if (!res_hnok(buf))
547			return (-1);
548			name = buf;
549			}
550
551			n = strlen(name) + 1;
552			if (h->pos + n >= h->end)
553			return (-1);
554
555			h->h.h_name = h->pos;
556			memmove(h->pos, name, n);
557			h->pos += n;
558			return (0);
559			}
560
561			static int
562			hostent_add_alias(struct hostent_ext h, const char name, int isdname)
563			{
564			char buf[MAXDNAME];
565			size_t i, n;
566
567			for (i = 0; i < MAXALIASES; i++)
568			if (h->aliases[i] == NULL)
569			break;
570			if (i == MAXALIASES)
571			return (0);
572
573			if (isdname) {
574			_asr_strdname(name, buf, sizeof buf);
575			buf[strlen(buf)-1] = '\0';
576			if (!res_hnok(buf))
577			return (-1);
578			name = buf;
579			}
580
581			n = strlen(name) + 1;
582			if (h->pos + n >= h->end)
583			return (0);
584
585			h->aliases[i] = h->pos;
586			memmove(h->pos, name, n);
587			h->pos += n;
588			return (0);
589			}
590
591			static int
592			hostent_add_addr(struct hostent_ext h, const void addr, size_t size)
593			{
594			int i;
595
596			for (i = 0; i < MAXADDRS; i++)
597			if (h->addrs[i] == NULL)
598			break;
599			if (i == MAXADDRS)
600			return (0);
601
602			if (h->pos + size >= h->end)
603			return (0);
604
605			h->addrs[i] = h->pos;
606			memmove(h->pos, addr, size);
607			h->pos += size;
608			return (0);
609			}