Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/asr/getnetnamadr_async.c	Lines:	0	209	0.0 %
Date:	2017-11-07	Branches:	0	129	0.0 %


/*	$OpenBSD: getnetnamadr_async.c,v 1.25 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 <errno.h>
#include <resolv.h> /* for res_hnok */
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "asr_private.h"

#define MAXALIASES	16

struct netent_ext {
	struct netent	 n;
	char		*aliases[MAXALIASES + 1];
	char		*end;
	char		*pos;
};

static int getnetnamadr_async_run(struct asr_query *, struct asr_result *);
static struct netent_ext *netent_alloc(int);
static int netent_set_cname(struct netent_ext *, const char *, int);
static int netent_add_alias(struct netent_ext *, const char *, int);
static struct netent_ext *netent_file_match(FILE *, int, const char *);
static struct netent_ext *netent_from_packet(int, char *, size_t);

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

	/* The current resolver segfaults. */
	if (name == NULL) {
		errno = EINVAL;
		return (NULL);
	}

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

	as->as.netnamadr.family = AF_INET;
	as->as.netnamadr.name = strdup(name);
	if (as->as.netnamadr.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(getnetbyname_async);

struct asr_query *
getnetbyaddr_async(in_addr_t net, int family, void *asr)
{
	struct asr_ctx	 *ac;
	struct asr_query *as;

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

	as->as.netnamadr.family = family;
	as->as.netnamadr.addr = net;

	_asr_ctx_unref(ac);
	return (as);

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

static int
getnetnamadr_async_run(struct asr_query *as, struct asr_result *ar)
{
	struct netent_ext	*n;
	int			 r, type, saved_errno;
	FILE			*f;
	char			 dname[MAXDNAME], *name, *data;
	in_addr_t		 in;

    next:
	switch (as->as_state) {

	case ASR_STATE_INIT:

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

		if (as->as_type == ASR_GETNETBYNAME &&
		    as->as.netnamadr.name[0] == '\0') {
			ar->ar_h_errno = NO_DATA;
			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:

			if (as->as_type == ASR_GETNETBYNAME) {
				type = T_A;
				/*
				 * I think we want to do the former, but our
				 * resolver is doing the following, so let's
				 * preserve bugward-compatibility there.
				 */
				type = T_PTR;
				name = as->as.netnamadr.name;
				as->as_subq = _res_search_async_ctx(
				    name, C_IN, type, as->as_ctx);
			} else {
				type = T_PTR;
				name = dname;

				in = htonl(as->as.netnamadr.addr);
				_asr_addr_as_fqdn((char *)&in,
				    as->as.netnamadr.family,
				    dname, sizeof(dname));
				as->as_subq = _res_query_async_ctx(
				    name, C_IN, type, 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:

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

			if (as->as_type == ASR_GETNETBYNAME)
				data = as->as.netnamadr.name;
			else
				data = (void *)&as->as.netnamadr.addr;

			n = netent_file_match(f, as->as_type, data);
			saved_errno = errno;
			fclose(f);
			errno = saved_errno;
			if (n == 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_netent = &n->n;
			ar->ar_h_errno = NETDB_SUCCESS;
			async_set_state(as, ASR_STATE_HALT);
			break;
		}
		break;

	case ASR_STATE_SUBQUERY:

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

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

		/* Got packet, but no answer */
		if (ar->ar_count == 0) {
			free(ar->ar_data);
			async_set_state(as, ASR_STATE_NEXT_DB);
			break;
		}

		n = netent_from_packet(as->as_type, ar->ar_data,
		    ar->ar_datalen);
		free(ar->ar_data);
		if (n == NULL) {
			ar->ar_errno = errno;
			ar->ar_h_errno = NETDB_INTERNAL;
			async_set_state(as, ASR_STATE_HALT);
			break;
		}

		if (as->as_type == ASR_GETNETBYADDR)
			n->n.n_net = as->as.netnamadr.addr;

		/*
		 * No valid hostname or address found in the dns packet.
		 * Ignore it.
		 */
		if ((as->as_type == ASR_GETNETBYNAME && n->n.n_net == 0) ||
		    n->n.n_name == NULL) {
			free(n);
			async_set_state(as, ASR_STATE_NEXT_DB);
			break;
		}

		ar->ar_netent = &n->n;
		ar->ar_h_errno = NETDB_SUCCESS;
		async_set_state(as, ASR_STATE_HALT);
		break;

	case ASR_STATE_NOT_FOUND:

		ar->ar_errno = 0;
		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_netent = 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;
}

static struct netent_ext *
netent_file_match(FILE *f, int reqtype, const char *data)
{
	struct netent_ext	*e;
	char			*tokens[MAXTOKEN], buf[BUFSIZ + 1];
	int			 n, i;
	in_addr_t		 net;

	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_GETNETBYADDR) {
			net = inet_network(tokens[1]);
			if (memcmp(&net, data, sizeof net) == 0)
				goto found;
		} else {
			for (i = 0; i < n; i++) {
				if (i == 1)
					continue;
				if (strcasecmp(data, tokens[i]))
					continue;
				goto found;
			}
		}
	}

found:
	if ((e = netent_alloc(AF_INET)) == NULL)
		return (NULL);
	if (netent_set_cname(e, tokens[0], 0) == -1)
		goto fail;
	for (i = 2; i < n; i ++)
		if (netent_add_alias(e, tokens[i], 0) == -1)
			goto fail;
	e->n.n_net = inet_network(tokens[1]);
	return (e);
fail:
	free(e);
	return (NULL);
}

static struct netent_ext *
netent_from_packet(int reqtype, char *pkt, size_t pktlen)
{
	struct netent_ext	*n;
	struct asr_unpack	 p;
	struct asr_dns_header	 hdr;
	struct asr_dns_query	 q;
	struct asr_dns_rr	 rr;

	if ((n = netent_alloc(AF_INET)) == NULL)
		return (NULL);

	_asr_unpack_init(&p, pkt, pktlen);
	_asr_unpack_header(&p, &hdr);
	for (; hdr.qdcount; hdr.qdcount--)
		_asr_unpack_query(&p, &q);
	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_GETNETBYNAME) {
				if (netent_add_alias(n, rr.rr_dname, 1) == -1)
					goto fail;
			} else {
				if (netent_set_cname(n, rr.rr_dname, 1) == -1)
					goto fail;
			}
			break;

		case T_PTR:
			if (reqtype != ASR_GETNETBYADDR)
				continue;
			if (netent_set_cname(n, rr.rr.ptr.ptrname, 1) == -1)
				goto fail;
			/* XXX See if we need to have MULTI_PTRS_ARE_ALIASES */
			break;

		case T_A:
			if (n->n.n_addrtype != AF_INET)
				break;
			if (netent_set_cname(n, rr.rr_dname, 1) ==  -1)
				goto fail;
			n->n.n_net = ntohl(rr.rr.in_a.addr.s_addr);
			break;
		}
	}

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

static struct netent_ext *
netent_alloc(int family)
{
	struct netent_ext	*n;
	size_t			 alloc;

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

	n->n.n_addrtype = family;
	n->n.n_aliases = n->aliases;
	n->pos = (char *)(n) + sizeof(*n);
	n->end = n->pos + 1024;

	return (n);
}

static int
netent_set_cname(struct netent_ext *n, const char *name, int isdname)
{
	char	buf[MAXDNAME];
	size_t	l;

	if (n->n.n_name)
		return (-1);

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

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

	n->n.n_name = n->pos;
	memmove(n->pos, name, l);
	n->pos += l;

	return (0);
}

static int
netent_add_alias(struct netent_ext *n, const char *name, int isdname)
{
	char	buf[MAXDNAME];
	size_t	i, l;

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

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

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

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


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: getnetnamadr_async.c,v 1.25 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 <errno.h>
27			#include <resolv.h> /* for res_hnok */
28			#include <stdlib.h>
29			#include <string.h>
30			#include <unistd.h>
31
32			#include "asr_private.h"
33
34			#define MAXALIASES 16
35
36			struct netent_ext {
37			struct netent n;
38			char *aliases[MAXALIASES + 1];
39			char *end;
40			char *pos;
41			};
42
43			static int getnetnamadr_async_run(struct asr_query , struct asr_result );
44			static struct netent_ext *netent_alloc(int);
45			static int netent_set_cname(struct netent_ext , const char , int);
46			static int netent_add_alias(struct netent_ext , const char , int);
47			static struct netent_ext netent_file_match(FILE , int, const char *);
48			static struct netent_ext netent_from_packet(int, char , size_t);
49
50			struct asr_query *
51			getnetbyname_async(const char name, void asr)
52			{
53			struct asr_ctx *ac;
54			struct asr_query *as;
55
56			/* The current resolver segfaults. */
57			if (name == NULL) {
58			errno = EINVAL;
59			return (NULL);
60			}
61
62			ac = _asr_use_resolver(asr);
63			if ((as = _asr_async_new(ac, ASR_GETNETBYNAME)) == NULL)
64			goto abort; /* errno set */
65			as->as_run = getnetnamadr_async_run;
66
67			as->as.netnamadr.family = AF_INET;
68			as->as.netnamadr.name = strdup(name);
69			if (as->as.netnamadr.name == NULL)
70			goto abort; /* errno set */
71
72			_asr_ctx_unref(ac);
73			return (as);
74
75			abort:
76			if (as)
77			_asr_async_free(as);
78			_asr_ctx_unref(ac);
79			return (NULL);
80			}
81			DEF_WEAK(getnetbyname_async);
82
83			struct asr_query *
84			getnetbyaddr_async(in_addr_t net, int family, void *asr)
85			{
86			struct asr_ctx *ac;
87			struct asr_query *as;
88
89			ac = _asr_use_resolver(asr);
90			if ((as = _asr_async_new(ac, ASR_GETNETBYADDR)) == NULL)
91			goto abort; /* errno set */
92			as->as_run = getnetnamadr_async_run;
93
94			as->as.netnamadr.family = family;
95			as->as.netnamadr.addr = net;
96
97			_asr_ctx_unref(ac);
98			return (as);
99
100			abort:
101			if (as)
102			_asr_async_free(as);
103			_asr_ctx_unref(ac);
104			return (NULL);
105			}
106			DEF_WEAK(getnetbyaddr_async);
107
108			static int
109			getnetnamadr_async_run(struct asr_query as, struct asr_result ar)
110			{
111			struct netent_ext *n;
112			int r, type, saved_errno;
113			FILE *f;
114			char dname[MAXDNAME], name, data;
115			in_addr_t in;
116
117			next:
118			switch (as->as_state) {
119
120			case ASR_STATE_INIT:
121
122			if (as->as.netnamadr.family != AF_INET) {
123			ar->ar_h_errno = NETDB_INTERNAL;
124			ar->ar_errno = EAFNOSUPPORT;
125			async_set_state(as, ASR_STATE_HALT);
126			break;
127			}
128
129			if (as->as_type == ASR_GETNETBYNAME &&
130			as->as.netnamadr.name[0] == '\0') {
131			ar->ar_h_errno = NO_DATA;
132			async_set_state(as, ASR_STATE_HALT);
133			break;
134			}
135
136			async_set_state(as, ASR_STATE_NEXT_DB);
137			break;
138
139			case ASR_STATE_NEXT_DB:
140
141			if (_asr_iter_db(as) == -1) {
142			async_set_state(as, ASR_STATE_NOT_FOUND);
143			break;
144			}
145
146			switch (AS_DB(as)) {
147			case ASR_DB_DNS:
148
149			if (as->as_type == ASR_GETNETBYNAME) {
150			type = T_A;
151			/*
152			* I think we want to do the former, but our
153			* resolver is doing the following, so let's
154			* preserve bugward-compatibility there.
155			*/
156			type = T_PTR;
157			name = as->as.netnamadr.name;
158			as->as_subq = _res_search_async_ctx(
159			name, C_IN, type, as->as_ctx);
160			} else {
161			type = T_PTR;
162			name = dname;
163
164			in = htonl(as->as.netnamadr.addr);
165			_asr_addr_as_fqdn((char *)&in,
166			as->as.netnamadr.family,
167			dname, sizeof(dname));
168			as->as_subq = _res_query_async_ctx(
169			name, C_IN, type, as->as_ctx);
170			}
171
172			if (as->as_subq == NULL) {
173			ar->ar_errno = errno;
174			ar->ar_h_errno = NETDB_INTERNAL;
175			async_set_state(as, ASR_STATE_HALT);
176			break;
177			}
178			async_set_state(as, ASR_STATE_SUBQUERY);
179			break;
180
181			case ASR_DB_FILE:
182
183			if ((f = fopen(_PATH_NETWORKS, "re")) == NULL)
184			break;
185
186			if (as->as_type == ASR_GETNETBYNAME)
187			data = as->as.netnamadr.name;
188			else
189			data = (void *)&as->as.netnamadr.addr;
190
191			n = netent_file_match(f, as->as_type, data);
192			saved_errno = errno;
193			fclose(f);
194			errno = saved_errno;
195			if (n == NULL) {
196			if (errno) {
197			ar->ar_errno = errno;
198			ar->ar_h_errno = NETDB_INTERNAL;
199			async_set_state(as, ASR_STATE_HALT);
200			}
201			/* otherwise not found */
202			break;
203			}
204
205			ar->ar_netent = &n->n;
206			ar->ar_h_errno = NETDB_SUCCESS;
207			async_set_state(as, ASR_STATE_HALT);
208			break;
209			}
210			break;
211
212			case ASR_STATE_SUBQUERY:
213
214			if ((r = asr_run(as->as_subq, ar)) == ASYNC_COND)
215			return (ASYNC_COND);
216			as->as_subq = NULL;
217
218			if (ar->ar_datalen == -1) {
219			async_set_state(as, ASR_STATE_NEXT_DB);
220			break;
221			}
222
223			/* Got packet, but no answer */
224			if (ar->ar_count == 0) {
225			free(ar->ar_data);
226			async_set_state(as, ASR_STATE_NEXT_DB);
227			break;
228			}
229
230			n = netent_from_packet(as->as_type, ar->ar_data,
231			ar->ar_datalen);
232			free(ar->ar_data);
233			if (n == NULL) {
234			ar->ar_errno = errno;
235			ar->ar_h_errno = NETDB_INTERNAL;
236			async_set_state(as, ASR_STATE_HALT);
237			break;
238			}
239
240			if (as->as_type == ASR_GETNETBYADDR)
241			n->n.n_net = as->as.netnamadr.addr;
242
243			/*
244			* No valid hostname or address found in the dns packet.
245			* Ignore it.
246			*/
247			if ((as->as_type == ASR_GETNETBYNAME && n->n.n_net == 0) \|\|
248			n->n.n_name == NULL) {
249			free(n);
250			async_set_state(as, ASR_STATE_NEXT_DB);
251			break;
252			}
253
254			ar->ar_netent = &n->n;
255			ar->ar_h_errno = NETDB_SUCCESS;
256			async_set_state(as, ASR_STATE_HALT);
257			break;
258
259			case ASR_STATE_NOT_FOUND:
260
261			ar->ar_errno = 0;
262			ar->ar_h_errno = HOST_NOT_FOUND;
263			async_set_state(as, ASR_STATE_HALT);
264			break;
265
266			case ASR_STATE_HALT:
267
268			if (ar->ar_h_errno)
269			ar->ar_netent = NULL;
270			else
271			ar->ar_errno = 0;
272			return (ASYNC_DONE);
273
274			default:
275			ar->ar_errno = EOPNOTSUPP;
276			ar->ar_h_errno = NETDB_INTERNAL;
277			ar->ar_gai_errno = EAI_SYSTEM;
278			async_set_state(as, ASR_STATE_HALT);
279			break;
280			}
281			goto next;
282			}
283
284			static struct netent_ext *
285			netent_file_match(FILE f, int reqtype, const char data)
286			{
287			struct netent_ext *e;
288			char *tokens[MAXTOKEN], buf[BUFSIZ + 1];
289			int n, i;
290			in_addr_t net;
291
292			for (;;) {
293			n = _asr_parse_namedb_line(f, tokens, MAXTOKEN, buf, sizeof(buf));
294			if (n == -1) {
295			errno = 0; /* ignore errors reading the file */
296			return (NULL);
297			}
298
299			/* there must be an address and at least one name */
300			if (n < 2)
301			continue;
302
303			if (reqtype == ASR_GETNETBYADDR) {
304			net = inet_network(tokens[1]);
305			if (memcmp(&net, data, sizeof net) == 0)
306			goto found;
307			} else {
308			for (i = 0; i < n; i++) {
309			if (i == 1)
310			continue;
311			if (strcasecmp(data, tokens[i]))
312			continue;
313			goto found;
314			}
315			}
316			}
317
318			found:
319			if ((e = netent_alloc(AF_INET)) == NULL)
320			return (NULL);
321			if (netent_set_cname(e, tokens[0], 0) == -1)
322			goto fail;
323			for (i = 2; i < n; i ++)
324			if (netent_add_alias(e, tokens[i], 0) == -1)
325			goto fail;
326			e->n.n_net = inet_network(tokens[1]);
327			return (e);
328			fail:
329			free(e);
330			return (NULL);
331			}
332
333			static struct netent_ext *
334			netent_from_packet(int reqtype, char *pkt, size_t pktlen)
335			{
336			struct netent_ext *n;
337			struct asr_unpack p;
338			struct asr_dns_header hdr;
339			struct asr_dns_query q;
340			struct asr_dns_rr rr;
341
342			if ((n = netent_alloc(AF_INET)) == NULL)
343			return (NULL);
344
345			_asr_unpack_init(&p, pkt, pktlen);
346			_asr_unpack_header(&p, &hdr);
347			for (; hdr.qdcount; hdr.qdcount--)
348			_asr_unpack_query(&p, &q);
349			for (; hdr.ancount; hdr.ancount--) {
350			_asr_unpack_rr(&p, &rr);
351			if (rr.rr_class != C_IN)
352			continue;
353			switch (rr.rr_type) {
354			case T_CNAME:
355			if (reqtype == ASR_GETNETBYNAME) {
356			if (netent_add_alias(n, rr.rr_dname, 1) == -1)
357			goto fail;
358			} else {
359			if (netent_set_cname(n, rr.rr_dname, 1) == -1)
360			goto fail;
361			}
362			break;
363
364			case T_PTR:
365			if (reqtype != ASR_GETNETBYADDR)
366			continue;
367			if (netent_set_cname(n, rr.rr.ptr.ptrname, 1) == -1)
368			goto fail;
369			/* XXX See if we need to have MULTI_PTRS_ARE_ALIASES */
370			break;
371
372			case T_A:
373			if (n->n.n_addrtype != AF_INET)
374			break;
375			if (netent_set_cname(n, rr.rr_dname, 1) == -1)
376			goto fail;
377			n->n.n_net = ntohl(rr.rr.in_a.addr.s_addr);
378			break;
379			}
380			}
381
382			return (n);
383			fail:
384			free(n);
385			return (NULL);
386			}
387
388			static struct netent_ext *
389			netent_alloc(int family)
390			{
391			struct netent_ext *n;
392			size_t alloc;
393
394			alloc = sizeof(*n) + 1024;
395			if ((n = calloc(1, alloc)) == NULL)
396			return (NULL);
397
398			n->n.n_addrtype = family;
399			n->n.n_aliases = n->aliases;
400			n->pos = (char )(n) + sizeof(n);
401			n->end = n->pos + 1024;
402
403			return (n);
404			}
405
406			static int
407			netent_set_cname(struct netent_ext n, const char name, int isdname)
408			{
409			char buf[MAXDNAME];
410			size_t l;
411
412			if (n->n.n_name)
413			return (-1);
414
415			if (isdname) {
416			_asr_strdname(name, buf, sizeof buf);
417			buf[strlen(buf) - 1] = '\0';
418			if (!res_hnok(buf))
419			return (-1);
420			name = buf;
421			}
422
423			l = strlen(name) + 1;
424			if (n->pos + l >= n->end)
425			return (-1);
426
427			n->n.n_name = n->pos;
428			memmove(n->pos, name, l);
429			n->pos += l;
430
431			return (0);
432			}
433
434			static int
435			netent_add_alias(struct netent_ext n, const char name, int isdname)
436			{
437			char buf[MAXDNAME];
438			size_t i, l;
439
440			for (i = 0; i < MAXALIASES; i++)
441			if (n->aliases[i] == NULL)
442			break;
443			if (i == MAXALIASES)
444			return (-1);
445
446			if (isdname) {
447			_asr_strdname(name, buf, sizeof buf);
448			buf[strlen(buf)-1] = '\0';
449			if (!res_hnok(buf))
450			return (-1);
451			name = buf;
452			}
453
454			l = strlen(name) + 1;
455			if (n->pos + l >= n->end)
456			return (-1);
457
458			n->aliases[i] = n->pos;
459			memmove(n->pos, name, l);
460			n->pos += l;
461			return (0);
462			}