GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libc/asr/getaddrinfo_async.c Lines: 0 358 0.0 %
Date: 2017-11-13 Branches: 0 295 0.0 %

Line Branch Exec Source
1
/*	$OpenBSD: getaddrinfo_async.c,v 1.54 2017/02/27 10:44:46 jca 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 <sys/uio.h>
21
#include <netinet/in.h>
22
#include <arpa/nameser.h>
23
#include <net/if.h>
24
#include <netdb.h>
25
26
#include <asr.h>
27
#include <errno.h>
28
#include <ifaddrs.h>
29
#include <resolv.h>
30
#include <stdlib.h>
31
#include <string.h>
32
#include <unistd.h>
33
#include <limits.h>
34
35
#include "asr_private.h"
36
37
struct match {
38
	int family;
39
	int socktype;
40
	int protocol;
41
};
42
43
static int getaddrinfo_async_run(struct asr_query *, struct asr_result *);
44
static int get_port(const char *, const char *, int);
45
static int iter_family(struct asr_query *, int);
46
static int addrinfo_add(struct asr_query *, const struct sockaddr *, const char *);
47
static int addrinfo_from_file(struct asr_query *, int,  FILE *);
48
static int addrinfo_from_pkt(struct asr_query *, char *, size_t);
49
static int addrconfig_setup(struct asr_query *);
50
51
static const struct match matches[] = {
52
	{ PF_INET,	SOCK_DGRAM,	IPPROTO_UDP	},
53
	{ PF_INET,	SOCK_STREAM,	IPPROTO_TCP	},
54
	{ PF_INET,	SOCK_RAW,	0		},
55
	{ PF_INET6,	SOCK_DGRAM,	IPPROTO_UDP	},
56
	{ PF_INET6,	SOCK_STREAM,	IPPROTO_TCP	},
57
	{ PF_INET6,	SOCK_RAW,	0		},
58
	{ -1,		0,		0,		},
59
};
60
61
#define MATCH_FAMILY(a, b) ((a) == matches[(b)].family || (a) == PF_UNSPEC)
62
#define MATCH_PROTO(a, b) ((a) == matches[(b)].protocol || (a) == 0 || matches[(b)].protocol == 0)
63
/* Do not match SOCK_RAW unless explicitely specified */
64
#define MATCH_SOCKTYPE(a, b) ((a) == matches[(b)].socktype || ((a) == 0 && \
65
				matches[(b)].socktype != SOCK_RAW))
66
67
enum {
68
	DOM_INIT,
69
	DOM_DOMAIN,
70
	DOM_DONE
71
};
72
73
struct asr_query *
74
getaddrinfo_async(const char *hostname, const char *servname,
75
	const struct addrinfo *hints, void *asr)
76
{
77
	struct asr_ctx		*ac;
78
	struct asr_query	*as;
79
80
	if (hints == NULL || (hints->ai_flags & AI_NUMERICHOST) == 0)
81
		ac = _asr_use_resolver(asr);
82
	else
83
		ac = _asr_no_resolver();
84
	if ((as = _asr_async_new(ac, ASR_GETADDRINFO)) == NULL)
85
		goto abort; /* errno set */
86
	as->as_run = getaddrinfo_async_run;
87
88
	if (hostname) {
89
		if ((as->as.ai.hostname = strdup(hostname)) == NULL)
90
			goto abort; /* errno set */
91
	}
92
	if (servname && (as->as.ai.servname = strdup(servname)) == NULL)
93
		goto abort; /* errno set */
94
	if (hints)
95
		memmove(&as->as.ai.hints, hints, sizeof *hints);
96
	else {
97
		memset(&as->as.ai.hints, 0, sizeof as->as.ai.hints);
98
		as->as.ai.hints.ai_family = PF_UNSPEC;
99
		as->as.ai.hints.ai_flags = AI_ADDRCONFIG;
100
	}
101
102
	_asr_ctx_unref(ac);
103
	return (as);
104
    abort:
105
	if (as)
106
		_asr_async_free(as);
107
	_asr_ctx_unref(ac);
108
	return (NULL);
109
}
110
DEF_WEAK(getaddrinfo_async);
111
112
static int
113
getaddrinfo_async_run(struct asr_query *as, struct asr_result *ar)
114
{
115
	char		 fqdn[MAXDNAME];
116
	const char	*str;
117
	struct addrinfo	*ai;
118
	int		 i, family, r;
119
	FILE		*f;
120
	union {
121
		struct sockaddr		sa;
122
		struct sockaddr_in	sain;
123
		struct sockaddr_in6	sain6;
124
	} sa;
125
126
    next:
127
	switch (as->as_state) {
128
129
	case ASR_STATE_INIT:
130
131
		/*
132
		 * First, make sure the parameters are valid.
133
		 */
134
135
		as->as_count = 0;
136
137
		if (as->as.ai.hostname == NULL &&
138
		    as->as.ai.servname == NULL) {
139
			ar->ar_gai_errno = EAI_NONAME;
140
			async_set_state(as, ASR_STATE_HALT);
141
			break;
142
		}
143
144
		if (as->as.ai.hostname && as->as.ai.hostname[0] == '\0') {
145
			ar->ar_gai_errno = EAI_NODATA;
146
			async_set_state(as, ASR_STATE_HALT);
147
			break;
148
		}
149
150
		ai = &as->as.ai.hints;
151
152
		if (ai->ai_addrlen ||
153
		    ai->ai_canonname ||
154
		    ai->ai_addr ||
155
		    ai->ai_next) {
156
			ar->ar_gai_errno = EAI_BADHINTS;
157
			async_set_state(as, ASR_STATE_HALT);
158
			break;
159
		}
160
161
		if (ai->ai_flags & ~AI_MASK ||
162
		    (ai->ai_flags & AI_CANONNAME && ai->ai_flags & AI_FQDN)) {
163
			ar->ar_gai_errno = EAI_BADFLAGS;
164
			async_set_state(as, ASR_STATE_HALT);
165
			break;
166
		}
167
168
		if (ai->ai_family != PF_UNSPEC &&
169
		    ai->ai_family != PF_INET &&
170
		    ai->ai_family != PF_INET6) {
171
			ar->ar_gai_errno = EAI_FAMILY;
172
			async_set_state(as, ASR_STATE_HALT);
173
			break;
174
		}
175
176
		if (ai->ai_socktype &&
177
		    ai->ai_socktype != SOCK_DGRAM  &&
178
		    ai->ai_socktype != SOCK_STREAM &&
179
		    ai->ai_socktype != SOCK_RAW) {
180
			ar->ar_gai_errno = EAI_SOCKTYPE;
181
			async_set_state(as, ASR_STATE_HALT);
182
			break;
183
		}
184
185
		if (ai->ai_socktype == SOCK_RAW &&
186
		    get_port(as->as.ai.servname, NULL, 1) != 0) {
187
			ar->ar_gai_errno = EAI_SERVICE;
188
			async_set_state(as, ASR_STATE_HALT);
189
			break;
190
		}
191
192
		/* Restrict result set to configured address families */
193
		if (ai->ai_flags & AI_ADDRCONFIG) {
194
			if (addrconfig_setup(as) == -1) {
195
				ar->ar_errno = errno;
196
				ar->ar_gai_errno = EAI_SYSTEM;
197
				async_set_state(as, ASR_STATE_HALT);
198
				break;
199
			}
200
		}
201
202
		/* Make sure there is at least a valid combination */
203
		for (i = 0; matches[i].family != -1; i++)
204
			if (MATCH_FAMILY(ai->ai_family, i) &&
205
			    MATCH_SOCKTYPE(ai->ai_socktype, i) &&
206
			    MATCH_PROTO(ai->ai_protocol, i))
207
				break;
208
		if (matches[i].family == -1) {
209
			ar->ar_gai_errno = EAI_BADHINTS;
210
			async_set_state(as, ASR_STATE_HALT);
211
			break;
212
		}
213
214
		if (ai->ai_protocol == 0 || ai->ai_protocol == IPPROTO_UDP)
215
			as->as.ai.port_udp = get_port(as->as.ai.servname, "udp",
216
			    as->as.ai.hints.ai_flags & AI_NUMERICSERV);
217
		if (ai->ai_protocol == 0 || ai->ai_protocol == IPPROTO_TCP)
218
			as->as.ai.port_tcp = get_port(as->as.ai.servname, "tcp",
219
			    as->as.ai.hints.ai_flags & AI_NUMERICSERV);
220
		if (as->as.ai.port_tcp == -2 || as->as.ai.port_udp == -2 ||
221
		    (as->as.ai.port_tcp == -1 && as->as.ai.port_udp == -1) ||
222
		    (ai->ai_protocol && (as->as.ai.port_udp == -1 ||
223
					 as->as.ai.port_tcp == -1))) {
224
			ar->ar_gai_errno = EAI_SERVICE;
225
			async_set_state(as, ASR_STATE_HALT);
226
			break;
227
		}
228
229
		ar->ar_gai_errno = 0;
230
231
		/* If hostname is NULL, use local address */
232
		if (as->as.ai.hostname == NULL) {
233
			for (family = iter_family(as, 1);
234
			    family != -1;
235
			    family = iter_family(as, 0)) {
236
				/*
237
				 * We could use statically built sockaddrs for
238
				 * those, rather than parsing over and over.
239
				 */
240
				if (family == PF_INET)
241
					str = (ai->ai_flags & AI_PASSIVE) ? \
242
						"0.0.0.0" : "127.0.0.1";
243
				else /* PF_INET6 */
244
					str = (ai->ai_flags & AI_PASSIVE) ? \
245
						"::" : "::1";
246
				 /* This can't fail */
247
				_asr_sockaddr_from_str(&sa.sa, family, str);
248
				if ((r = addrinfo_add(as, &sa.sa, NULL))) {
249
					ar->ar_gai_errno = r;
250
					break;
251
				}
252
			}
253
			if (ar->ar_gai_errno == 0 && as->as_count == 0) {
254
				ar->ar_gai_errno = EAI_NODATA;
255
			}
256
			async_set_state(as, ASR_STATE_HALT);
257
			break;
258
		}
259
260
		/* Try numeric addresses first */
261
		for (family = iter_family(as, 1);
262
		    family != -1;
263
		    family = iter_family(as, 0)) {
264
265
			if (_asr_sockaddr_from_str(&sa.sa, family,
266
			    as->as.ai.hostname) == -1)
267
				continue;
268
269
			if ((r = addrinfo_add(as, &sa.sa, NULL)))
270
				ar->ar_gai_errno = r;
271
			break;
272
		}
273
		if (ar->ar_gai_errno || as->as_count) {
274
			async_set_state(as, ASR_STATE_HALT);
275
			break;
276
		}
277
278
		if (ai->ai_flags & AI_NUMERICHOST) {
279
			ar->ar_gai_errno = EAI_NONAME;
280
			async_set_state(as, ASR_STATE_HALT);
281
			break;
282
		}
283
284
		async_set_state(as, ASR_STATE_NEXT_DB);
285
		break;
286
287
	case ASR_STATE_NEXT_DB:
288
		if (_asr_iter_db(as) == -1) {
289
			async_set_state(as, ASR_STATE_NOT_FOUND);
290
			break;
291
		}
292
		as->as_family_idx = 0;
293
		async_set_state(as, ASR_STATE_SAME_DB);
294
		break;
295
296
	case ASR_STATE_NEXT_FAMILY:
297
		as->as_family_idx += 1;
298
		if (as->as.ai.hints.ai_family != AF_UNSPEC ||
299
		    AS_FAMILY(as) == -1) {
300
			/* The family was specified, or we have tried all
301
			 * families with this DB.
302
			 */
303
			if (as->as_count) {
304
				ar->ar_gai_errno = 0;
305
				async_set_state(as, ASR_STATE_HALT);
306
			} else
307
				async_set_state(as, ASR_STATE_NEXT_DOMAIN);
308
			break;
309
		}
310
		async_set_state(as, ASR_STATE_SAME_DB);
311
		break;
312
313
	case ASR_STATE_NEXT_DOMAIN:
314
		/* domain search is only for dns */
315
		if (AS_DB(as) != ASR_DB_DNS) {
316
			async_set_state(as, ASR_STATE_NEXT_DB);
317
			break;
318
		}
319
		as->as_family_idx = 0;
320
321
		free(as->as.ai.fqdn);
322
		as->as.ai.fqdn = NULL;
323
		r = _asr_iter_domain(as, as->as.ai.hostname, fqdn, sizeof(fqdn));
324
		if (r == -1) {
325
			async_set_state(as, ASR_STATE_NEXT_DB);
326
			break;
327
		}
328
		if (r == 0) {
329
			ar->ar_gai_errno = EAI_FAIL;
330
			async_set_state(as, ASR_STATE_HALT);
331
			break;
332
		}
333
		as->as.ai.fqdn = strdup(fqdn);
334
		if (as->as.ai.fqdn == NULL) {
335
			ar->ar_gai_errno = EAI_MEMORY;
336
			async_set_state(as, ASR_STATE_HALT);
337
			break;
338
		}
339
340
		async_set_state(as, ASR_STATE_SAME_DB);
341
		break;
342
343
	case ASR_STATE_SAME_DB:
344
		/* query the current DB again */
345
		switch (AS_DB(as)) {
346
		case ASR_DB_DNS:
347
			if (as->as.ai.fqdn == NULL) {
348
				/* First try, initialize domain iteration */
349
				as->as_dom_flags = 0;
350
				as->as_dom_step = DOM_INIT;
351
				async_set_state(as, ASR_STATE_NEXT_DOMAIN);
352
				break;
353
			}
354
355
			family = (as->as.ai.hints.ai_family == AF_UNSPEC) ?
356
			    AS_FAMILY(as) : as->as.ai.hints.ai_family;
357
358
			if (family == AF_INET &&
359
			    as->as_flags & ASYNC_NO_INET) {
360
				async_set_state(as, ASR_STATE_NEXT_FAMILY);
361
				break;
362
			} else if (family == AF_INET6 &&
363
			    as->as_flags & ASYNC_NO_INET6) {
364
				async_set_state(as, ASR_STATE_NEXT_FAMILY);
365
				break;
366
			}
367
368
			as->as_subq = _res_query_async_ctx(as->as.ai.fqdn,
369
			    C_IN, (family == AF_INET6) ? T_AAAA : T_A,
370
			    as->as_ctx);
371
372
			if (as->as_subq == NULL) {
373
				if (errno == ENOMEM)
374
					ar->ar_gai_errno = EAI_MEMORY;
375
				else
376
					ar->ar_gai_errno = EAI_FAIL;
377
				async_set_state(as, ASR_STATE_HALT);
378
				break;
379
			}
380
			async_set_state(as, ASR_STATE_SUBQUERY);
381
			break;
382
383
		case ASR_DB_FILE:
384
			f = fopen(_PATH_HOSTS, "re");
385
			if (f == NULL) {
386
				async_set_state(as, ASR_STATE_NEXT_DB);
387
				break;
388
			}
389
			family = (as->as.ai.hints.ai_family == AF_UNSPEC) ?
390
			    AS_FAMILY(as) : as->as.ai.hints.ai_family;
391
392
			r = addrinfo_from_file(as, family, f);
393
			if (r == -1) {
394
				if (errno == ENOMEM)
395
					ar->ar_gai_errno = EAI_MEMORY;
396
				else
397
					ar->ar_gai_errno = EAI_FAIL;
398
				async_set_state(as, ASR_STATE_HALT);
399
			} else
400
				async_set_state(as, ASR_STATE_NEXT_FAMILY);
401
			fclose(f);
402
			break;
403
404
		default:
405
			async_set_state(as, ASR_STATE_NEXT_DB);
406
		}
407
		break;
408
409
	case ASR_STATE_SUBQUERY:
410
		if ((r = asr_run(as->as_subq, ar)) == ASYNC_COND)
411
			return (ASYNC_COND);
412
413
		as->as_subq = NULL;
414
415
		if (ar->ar_datalen == -1) {
416
			async_set_state(as, ASR_STATE_NEXT_FAMILY);
417
			break;
418
		}
419
420
		r = addrinfo_from_pkt(as, ar->ar_data, ar->ar_datalen);
421
		if (r == -1) {
422
			if (errno == ENOMEM)
423
				ar->ar_gai_errno = EAI_MEMORY;
424
			else
425
				ar->ar_gai_errno = EAI_FAIL;
426
			async_set_state(as, ASR_STATE_HALT);
427
		} else
428
			async_set_state(as, ASR_STATE_NEXT_FAMILY);
429
		free(ar->ar_data);
430
		break;
431
432
	case ASR_STATE_NOT_FOUND:
433
		/* No result found. Maybe we can try again. */
434
		if (as->as_flags & ASYNC_AGAIN)
435
			ar->ar_gai_errno = EAI_AGAIN;
436
		else
437
			ar->ar_gai_errno = EAI_NODATA;
438
		async_set_state(as, ASR_STATE_HALT);
439
		break;
440
441
	case ASR_STATE_HALT:
442
		if (ar->ar_gai_errno == 0) {
443
			ar->ar_count = as->as_count;
444
			ar->ar_addrinfo = as->as.ai.aifirst;
445
			as->as.ai.aifirst = NULL;
446
		} else {
447
			ar->ar_count = 0;
448
			ar->ar_addrinfo = NULL;
449
		}
450
		return (ASYNC_DONE);
451
452
	default:
453
		ar->ar_errno = EOPNOTSUPP;
454
		ar->ar_gai_errno = EAI_SYSTEM;
455
		async_set_state(as, ASR_STATE_HALT);
456
		break;
457
	}
458
	goto next;
459
}
460
461
/*
462
 * Retreive the port number for the service name "servname" and
463
 * the protocol "proto".
464
 */
465
static int
466
get_port(const char *servname, const char *proto, int numonly)
467
{
468
	struct servent		se;
469
	struct servent_data	sed;
470
	int			port, r;
471
	const char		*e;
472
473
	if (servname == NULL)
474
		return (0);
475
476
	e = NULL;
477
	port = strtonum(servname, 0, USHRT_MAX, &e);
478
	if (e == NULL)
479
		return (port);
480
	if (errno == ERANGE)
481
		return (-2); /* invalid */
482
	if (numonly)
483
		return (-2);
484
485
	memset(&sed, 0, sizeof(sed));
486
	r = getservbyname_r(servname, proto, &se, &sed);
487
	port = ntohs(se.s_port);
488
	endservent_r(&sed);
489
490
	if (r == -1)
491
		return (-1); /* not found */
492
493
	return (port);
494
}
495
496
/*
497
 * Iterate over the address families that are to be queried. Use the
498
 * list on the async context, unless a specific family was given in hints.
499
 */
500
static int
501
iter_family(struct asr_query *as, int first)
502
{
503
	if (first) {
504
		as->as_family_idx = 0;
505
		if (as->as.ai.hints.ai_family != PF_UNSPEC)
506
			return as->as.ai.hints.ai_family;
507
		return AS_FAMILY(as);
508
	}
509
510
	if (as->as.ai.hints.ai_family != PF_UNSPEC)
511
		return (-1);
512
513
	as->as_family_idx++;
514
515
	return AS_FAMILY(as);
516
}
517
518
/*
519
 * Use the sockaddr at "sa" to extend the result list on the "as" context,
520
 * with the specified canonical name "cname". This function adds one
521
 * entry per protocol/socktype match.
522
 */
523
static int
524
addrinfo_add(struct asr_query *as, const struct sockaddr *sa, const char *cname)
525
{
526
	struct addrinfo		*ai;
527
	int			 i, port, proto;
528
529
	for (i = 0; matches[i].family != -1; i++) {
530
		if (matches[i].family != sa->sa_family ||
531
		    !MATCH_SOCKTYPE(as->as.ai.hints.ai_socktype, i) ||
532
		    !MATCH_PROTO(as->as.ai.hints.ai_protocol, i))
533
			continue;
534
535
		proto = as->as.ai.hints.ai_protocol;
536
		if (!proto)
537
			proto = matches[i].protocol;
538
539
		if (proto == IPPROTO_TCP)
540
			port = as->as.ai.port_tcp;
541
		else if (proto == IPPROTO_UDP)
542
			port = as->as.ai.port_udp;
543
		else
544
			port = 0;
545
546
		/* servname specified, but not defined for this protocol */
547
		if (port == -1)
548
			continue;
549
550
		ai = calloc(1, sizeof(*ai) + sa->sa_len);
551
		if (ai == NULL)
552
			return (EAI_MEMORY);
553
		ai->ai_family = sa->sa_family;
554
		ai->ai_socktype = matches[i].socktype;
555
		ai->ai_protocol = proto;
556
		ai->ai_flags = as->as.ai.hints.ai_flags;
557
		ai->ai_addrlen = sa->sa_len;
558
		ai->ai_addr = (void *)(ai + 1);
559
		if (cname &&
560
		    as->as.ai.hints.ai_flags & (AI_CANONNAME | AI_FQDN)) {
561
			if ((ai->ai_canonname = strdup(cname)) == NULL) {
562
				free(ai);
563
				return (EAI_MEMORY);
564
			}
565
		}
566
		memmove(ai->ai_addr, sa, sa->sa_len);
567
		if (sa->sa_family == PF_INET)
568
			((struct sockaddr_in *)ai->ai_addr)->sin_port =
569
			    htons(port);
570
		else if (sa->sa_family == PF_INET6)
571
			((struct sockaddr_in6 *)ai->ai_addr)->sin6_port =
572
			    htons(port);
573
574
		if (as->as.ai.aifirst == NULL)
575
			as->as.ai.aifirst = ai;
576
		if (as->as.ai.ailast)
577
			as->as.ai.ailast->ai_next = ai;
578
		as->as.ai.ailast = ai;
579
		as->as_count += 1;
580
	}
581
582
	return (0);
583
}
584
585
static int
586
addrinfo_from_file(struct asr_query *as, int family, FILE *f)
587
{
588
	char		*tokens[MAXTOKEN], *c, buf[BUFSIZ + 1];
589
	int		 n, i;
590
	union {
591
		struct sockaddr		sa;
592
		struct sockaddr_in	sain;
593
		struct sockaddr_in6	sain6;
594
	} u;
595
596
	for (;;) {
597
		n = _asr_parse_namedb_line(f, tokens, MAXTOKEN, buf, sizeof(buf));
598
		if (n == -1)
599
			break; /* ignore errors reading the file */
600
601
		for (i = 1; i < n; i++) {
602
			if (strcasecmp(as->as.ai.hostname, tokens[i]))
603
				continue;
604
			if (_asr_sockaddr_from_str(&u.sa, family, tokens[0]) == -1)
605
				continue;
606
			break;
607
		}
608
		if (i == n)
609
			continue;
610
611
		if (as->as.ai.hints.ai_flags & (AI_CANONNAME | AI_FQDN))
612
			c = tokens[1];
613
		else
614
			c = NULL;
615
616
		if (addrinfo_add(as, &u.sa, c))
617
			return (-1); /* errno set */
618
	}
619
	return (0);
620
}
621
622
static int
623
addrinfo_from_pkt(struct asr_query *as, char *pkt, size_t pktlen)
624
{
625
	struct asr_unpack	 p;
626
	struct asr_dns_header	 h;
627
	struct asr_dns_query	 q;
628
	struct asr_dns_rr	 rr;
629
	int			 i;
630
	union {
631
		struct sockaddr		sa;
632
		struct sockaddr_in	sain;
633
		struct sockaddr_in6	sain6;
634
	} u;
635
	char		 buf[MAXDNAME], *c;
636
637
	_asr_unpack_init(&p, pkt, pktlen);
638
	_asr_unpack_header(&p, &h);
639
	for (; h.qdcount; h.qdcount--)
640
		_asr_unpack_query(&p, &q);
641
642
	for (i = 0; i < h.ancount; i++) {
643
		_asr_unpack_rr(&p, &rr);
644
		if (rr.rr_type != q.q_type ||
645
		    rr.rr_class != q.q_class)
646
			continue;
647
648
		memset(&u, 0, sizeof u);
649
		if (rr.rr_type == T_A) {
650
			u.sain.sin_len = sizeof u.sain;
651
			u.sain.sin_family = AF_INET;
652
			u.sain.sin_addr = rr.rr.in_a.addr;
653
			u.sain.sin_port = 0;
654
		} else if (rr.rr_type == T_AAAA) {
655
			u.sain6.sin6_len = sizeof u.sain6;
656
			u.sain6.sin6_family = AF_INET6;
657
			u.sain6.sin6_addr = rr.rr.in_aaaa.addr6;
658
			u.sain6.sin6_port = 0;
659
		} else
660
			continue;
661
662
		if (as->as.ai.hints.ai_flags & AI_CANONNAME) {
663
			_asr_strdname(rr.rr_dname, buf, sizeof buf);
664
			buf[strlen(buf) - 1] = '\0';
665
			c = res_hnok(buf) ? buf : NULL;
666
		} else if (as->as.ai.hints.ai_flags & AI_FQDN)
667
			c = as->as.ai.fqdn;
668
		else
669
			c = NULL;
670
671
		if (addrinfo_add(as, &u.sa, c))
672
			return (-1); /* errno set */
673
	}
674
	return (0);
675
}
676
677
static int
678
addrconfig_setup(struct asr_query *as)
679
{
680
	struct ifaddrs		*ifa, *ifa0;
681
	struct sockaddr_in	*sinp;
682
	struct sockaddr_in6	*sin6p;
683
684
	if (getifaddrs(&ifa0) == -1)
685
		return (-1);
686
687
	as->as_flags |= ASYNC_NO_INET | ASYNC_NO_INET6;
688
689
	for (ifa = ifa0; ifa != NULL; ifa = ifa->ifa_next) {
690
		if (ifa->ifa_addr == NULL)
691
			continue;
692
693
		switch (ifa->ifa_addr->sa_family) {
694
		case PF_INET:
695
			sinp = (struct sockaddr_in *)ifa->ifa_addr;
696
697
			if (sinp->sin_addr.s_addr == htonl(INADDR_LOOPBACK))
698
				continue;
699
700
			as->as_flags &= ~ASYNC_NO_INET;
701
			break;
702
		case PF_INET6:
703
			sin6p = (struct sockaddr_in6 *)ifa->ifa_addr;
704
705
			if (IN6_IS_ADDR_LOOPBACK(&sin6p->sin6_addr))
706
				continue;
707
708
			if (IN6_IS_ADDR_LINKLOCAL(&sin6p->sin6_addr))
709
				continue;
710
711
			as->as_flags &= ~ASYNC_NO_INET6;
712
			break;
713
		}
714
	}
715
716
	freeifaddrs(ifa0);
717
718
	return (0);
719
}