1 /* $NetBSD: getaddrinfo.c,v 1.82 2006/03/25 12:09:40 rpaulo Exp $ */
2 /* $KAME: getaddrinfo.c,v 1.29 2000/08/31 17:26:57 itojun Exp $ */
3
4 /*
5 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the project nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33 /*
34 * Issues to be discussed:
35 * - Thread safe-ness must be checked.
36 * - Return values. There are nonstandard return values defined and used
37 * in the source code. This is because RFC2553 is silent about which error
38 * code must be returned for which situation.
39 * - IPv4 classful (shortened) form. RFC2553 is silent about it. XNET 5.2
40 * says to use inet_aton() to convert IPv4 numeric to binary (alows
41 * classful form as a result).
42 * current code - disallow classful form for IPv4 (due to use of inet_pton).
43 * - freeaddrinfo(NULL). RFC2553 is silent about it. XNET 5.2 says it is
44 * invalid.
45 * current code - SEGV on freeaddrinfo(NULL)
46 * Note:
47 * - We use getipnodebyname() just for thread-safeness. There's no intent
48 * to let it do PF_UNSPEC (actually we never pass PF_UNSPEC to
49 * getipnodebyname().
50 * - The code filters out AFs that are not supported by the kernel,
51 * when globbing NULL hostname (to loopback, or wildcard). Is it the right
52 * thing to do? What is the relationship with post-RFC2553 AI_ADDRCONFIG
53 * in ai_flags?
54 * - (post-2553) semantics of AI_ADDRCONFIG itself is too vague.
55 * (1) what should we do against numeric hostname (2) what should we do
56 * against NULL hostname (3) what is AI_ADDRCONFIG itself. AF not ready?
57 * non-loopback address configured? global address configured?
58 * - To avoid search order issue, we have a big amount of code duplicate
59 * from gethnamaddr.c and some other places. The issues that there's no
60 * lower layer function to lookup "IPv4 or IPv6" record. Calling
61 * gethostbyname2 from getaddrinfo will end up in wrong search order, as
62 * follows:
63 * - The code makes use of following calls when asked to resolver with
64 * ai_family = PF_UNSPEC:
65 * getipnodebyname(host, AF_INET6);
66 * getipnodebyname(host, AF_INET);
67 * This will result in the following queries if the node is configure to
68 * prefer /etc/hosts than DNS:
69 * lookup /etc/hosts for IPv6 address
70 * lookup DNS for IPv6 address
71 * lookup /etc/hosts for IPv4 address
72 * lookup DNS for IPv4 address
73 * which may not meet people's requirement.
74 * The right thing to happen is to have underlying layer which does
75 * PF_UNSPEC lookup (lookup both) and return chain of addrinfos.
76 * This would result in a bit of code duplicate with _dns_ghbyname() and
77 * friends.
78 */
79
80 #include <fcntl.h>
81 #include <sys/cdefs.h>
82 #include <sys/types.h>
83 #include <sys/stat.h>
84 #include <sys/param.h>
85 #include <sys/socket.h>
86 #include <sys/un.h>
87 #include <net/if.h>
88 #include <netinet/in.h>
89 #include <arpa/inet.h>
90 #include "arpa_nameser.h"
91 #include <assert.h>
92 #include <ctype.h>
93 #include <errno.h>
94 #include <netdb.h>
95 #include "resolv_private.h"
96 #include <stddef.h>
97 #include <stdio.h>
98 #include <stdlib.h>
99 #include <string.h>
100 #include <strings.h>
101 #include <unistd.h>
102
103 #include <syslog.h>
104 #include <stdarg.h>
105 #include "nsswitch.h"
106
107 #ifdef ANDROID_CHANGES
108 #include <sys/system_properties.h>
109 #endif /* ANDROID_CHANGES */
110
111 typedef union sockaddr_union {
112 struct sockaddr generic;
113 struct sockaddr_in in;
114 struct sockaddr_in6 in6;
115 } sockaddr_union;
116
117 #define SUCCESS 0
118 #define ANY 0
119 #define YES 1
120 #define NO 0
121
122 static const char in_addrany[] = { 0, 0, 0, 0 };
123 static const char in_loopback[] = { 127, 0, 0, 1 };
124 #ifdef INET6
125 static const char in6_addrany[] = {
126 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
127 };
128 static const char in6_loopback[] = {
129 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
130 };
131 #endif
132
133 static const struct afd {
134 int a_af;
135 int a_addrlen;
136 int a_socklen;
137 int a_off;
138 const char *a_addrany;
139 const char *a_loopback;
140 int a_scoped;
141 } afdl [] = {
142 #ifdef INET6
143 {PF_INET6, sizeof(struct in6_addr),
144 sizeof(struct sockaddr_in6),
145 offsetof(struct sockaddr_in6, sin6_addr),
146 in6_addrany, in6_loopback, 1},
147 #endif
148 {PF_INET, sizeof(struct in_addr),
149 sizeof(struct sockaddr_in),
150 offsetof(struct sockaddr_in, sin_addr),
151 in_addrany, in_loopback, 0},
152 {0, 0, 0, 0, NULL, NULL, 0},
153 };
154
155 struct explore {
156 int e_af;
157 int e_socktype;
158 int e_protocol;
159 const char *e_protostr;
160 int e_wild;
161 #define WILD_AF(ex) ((ex)->e_wild & 0x01)
162 #define WILD_SOCKTYPE(ex) ((ex)->e_wild & 0x02)
163 #define WILD_PROTOCOL(ex) ((ex)->e_wild & 0x04)
164 };
165
166 static const struct explore explore[] = {
167 #if 0
168 { PF_LOCAL, 0, ANY, ANY, NULL, 0x01 },
169 #endif
170 #ifdef INET6
171 { PF_INET6, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
172 { PF_INET6, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
173 { PF_INET6, SOCK_RAW, ANY, NULL, 0x05 },
174 #endif
175 { PF_INET, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
176 { PF_INET, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
177 { PF_INET, SOCK_RAW, ANY, NULL, 0x05 },
178 { PF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
179 { PF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
180 { PF_UNSPEC, SOCK_RAW, ANY, NULL, 0x05 },
181 { -1, 0, 0, NULL, 0 },
182 };
183
184 #ifdef INET6
185 #define PTON_MAX 16
186 #else
187 #define PTON_MAX 4
188 #endif
189
190 static const ns_src default_dns_files[] = {
191 { NSSRC_FILES, NS_SUCCESS },
192 { NSSRC_DNS, NS_SUCCESS },
193 { 0, 0 }
194 };
195
196 #define MAXPACKET (64*1024)
197
198 typedef union {
199 HEADER hdr;
200 u_char buf[MAXPACKET];
201 } querybuf;
202
203 struct res_target {
204 struct res_target *next;
205 const char *name; /* domain name */
206 int qclass, qtype; /* class and type of query */
207 u_char *answer; /* buffer to put answer */
208 int anslen; /* size of answer buffer */
209 int n; /* result length */
210 };
211
212 static int str2number(const char *);
213 static int explore_fqdn(const struct addrinfo *, const char *,
214 const char *, struct addrinfo **);
215 static int explore_null(const struct addrinfo *,
216 const char *, struct addrinfo **);
217 static int explore_numeric(const struct addrinfo *, const char *,
218 const char *, struct addrinfo **, const char *);
219 static int explore_numeric_scope(const struct addrinfo *, const char *,
220 const char *, struct addrinfo **);
221 static int get_canonname(const struct addrinfo *,
222 struct addrinfo *, const char *);
223 static struct addrinfo *get_ai(const struct addrinfo *,
224 const struct afd *, const char *);
225 static int get_portmatch(const struct addrinfo *, const char *);
226 static int get_port(const struct addrinfo *, const char *, int);
227 static const struct afd *find_afd(int);
228 #ifdef INET6
229 static int ip6_str2scopeid(char *, struct sockaddr_in6 *, u_int32_t *);
230 #endif
231
232 static struct addrinfo *getanswer(const querybuf *, int, const char *, int,
233 const struct addrinfo *);
234 static int _dns_getaddrinfo(void *, void *, va_list);
235 static void _sethtent(FILE **);
236 static void _endhtent(FILE **);
237 static struct addrinfo *_gethtent(FILE **, const char *,
238 const struct addrinfo *);
239 static int _files_getaddrinfo(void *, void *, va_list);
240
241 static int res_queryN(const char *, struct res_target *, res_state);
242 static int res_searchN(const char *, struct res_target *, res_state);
243 static int res_querydomainN(const char *, const char *,
244 struct res_target *, res_state);
245
246 static const char * const ai_errlist[] = {
247 "Success",
248 "Address family for hostname not supported", /* EAI_ADDRFAMILY */
249 "Temporary failure in name resolution", /* EAI_AGAIN */
250 "Invalid value for ai_flags", /* EAI_BADFLAGS */
251 "Non-recoverable failure in name resolution", /* EAI_FAIL */
252 "ai_family not supported", /* EAI_FAMILY */
253 "Memory allocation failure", /* EAI_MEMORY */
254 "No address associated with hostname", /* EAI_NODATA */
255 "hostname nor servname provided, or not known", /* EAI_NONAME */
256 "servname not supported for ai_socktype", /* EAI_SERVICE */
257 "ai_socktype not supported", /* EAI_SOCKTYPE */
258 "System error returned in errno", /* EAI_SYSTEM */
259 "Invalid value for hints", /* EAI_BADHINTS */
260 "Resolved protocol is unknown", /* EAI_PROTOCOL */
261 "Argument buffer overflow", /* EAI_OVERFLOW */
262 "Unknown error", /* EAI_MAX */
263 };
264
265 /* XXX macros that make external reference is BAD. */
266
267 #define GET_AI(ai, afd, addr) \
268 do { \
269 /* external reference: pai, error, and label free */ \
270 (ai) = get_ai(pai, (afd), (addr)); \
271 if ((ai) == NULL) { \
272 error = EAI_MEMORY; \
273 goto free; \
274 } \
275 } while (/*CONSTCOND*/0)
276
277 #define GET_PORT(ai, serv) \
278 do { \
279 /* external reference: error and label free */ \
280 error = get_port((ai), (serv), 0); \
281 if (error != 0) \
282 goto free; \
283 } while (/*CONSTCOND*/0)
284
285 #define GET_CANONNAME(ai, str) \
286 do { \
287 /* external reference: pai, error and label free */ \
288 error = get_canonname(pai, (ai), (str)); \
289 if (error != 0) \
290 goto free; \
291 } while (/*CONSTCOND*/0)
292
293 #define ERR(err) \
294 do { \
295 /* external reference: error, and label bad */ \
296 error = (err); \
297 goto bad; \
298 /*NOTREACHED*/ \
299 } while (/*CONSTCOND*/0)
300
301 #define MATCH_FAMILY(x, y, w) \
302 ((x) == (y) || (/*CONSTCOND*/(w) && ((x) == PF_UNSPEC || \
303 (y) == PF_UNSPEC)))
304 #define MATCH(x, y, w) \
305 ((x) == (y) || (/*CONSTCOND*/(w) && ((x) == ANY || (y) == ANY)))
306
307 const char *
gai_strerror(int ecode)308 gai_strerror(int ecode)
309 {
310 if (ecode < 0 || ecode > EAI_MAX)
311 ecode = EAI_MAX;
312 return ai_errlist[ecode];
313 }
314
315 void
freeaddrinfo(struct addrinfo * ai)316 freeaddrinfo(struct addrinfo *ai)
317 {
318 struct addrinfo *next;
319
320 assert(ai != NULL);
321
322 do {
323 next = ai->ai_next;
324 if (ai->ai_canonname)
325 free(ai->ai_canonname);
326 /* no need to free(ai->ai_addr) */
327 free(ai);
328 ai = next;
329 } while (ai);
330 }
331
332 static int
str2number(const char * p)333 str2number(const char *p)
334 {
335 char *ep;
336 unsigned long v;
337
338 assert(p != NULL);
339
340 if (*p == '\0')
341 return -1;
342 ep = NULL;
343 errno = 0;
344 v = strtoul(p, &ep, 10);
345 if (errno == 0 && ep && *ep == '\0' && v <= UINT_MAX)
346 return v;
347 else
348 return -1;
349 }
350
351 /*
352 * Connect a UDP socket to a given unicast address. This will cause no network
353 * traffic, but will fail fast if the system has no or limited reachability to
354 * the destination (e.g., no IPv4 address, no IPv6 default route, ...).
355 */
356 static int
_test_connect(int pf,struct sockaddr * addr,size_t addrlen)357 _test_connect(int pf, struct sockaddr *addr, size_t addrlen) {
358 int s = socket(pf, SOCK_DGRAM, IPPROTO_UDP);
359 if (s < 0)
360 return 0;
361 int ret;
362 do {
363 ret = connect(s, addr, addrlen);
364 } while (ret < 0 && errno == EINTR);
365 int success = (ret == 0);
366 do {
367 ret = close(s);
368 } while (ret < 0 && errno == EINTR);
369 return success;
370 }
371
372 /*
373 * The following functions determine whether IPv4 or IPv6 connectivity is
374 * available in order to implement AI_ADDRCONFIG.
375 *
376 * Strictly speaking, AI_ADDRCONFIG should not look at whether connectivity is
377 * available, but whether addresses of the specified family are "configured
378 * on the local system". However, bionic doesn't currently support getifaddrs,
379 * so checking for connectivity is the next best thing.
380 */
381 static int
_have_ipv6()382 _have_ipv6() {
383 static const struct sockaddr_in6 sin6_test = {
384 .sin6_family = AF_INET6,
385 .sin6_addr.s6_addr = { // 2000::
386 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
387 };
388 sockaddr_union addr = { .in6 = sin6_test };
389 return _test_connect(PF_INET6, &addr.generic, sizeof(addr.in6));
390 }
391
392 static int
_have_ipv4()393 _have_ipv4() {
394 static const struct sockaddr_in sin_test = {
395 .sin_family = AF_INET,
396 .sin_addr.s_addr = __constant_htonl(0x08080808L) // 8.8.8.8
397 };
398 sockaddr_union addr = { .in = sin_test };
399 return _test_connect(PF_INET, &addr.generic, sizeof(addr.in));
400 }
401
402 // Returns 0 on success, else returns non-zero on error (in which case
403 // getaddrinfo should continue as normal)
404 static int
android_getaddrinfo_proxy(const char * hostname,const char * servname,const struct addrinfo * hints,struct addrinfo ** res)405 android_getaddrinfo_proxy(
406 const char *hostname, const char *servname,
407 const struct addrinfo *hints, struct addrinfo **res)
408 {
409 int sock;
410 const int one = 1;
411 struct sockaddr_un proxy_addr;
412 const char* cache_mode = getenv("ANDROID_DNS_MODE");
413 FILE* proxy = NULL;
414 int success = 0;
415
416 // Clear this at start, as we use its non-NULLness later (in the
417 // error path) to decide if we have to free up any memory we
418 // allocated in the process (before failing).
419 *res = NULL;
420
421 if (cache_mode != NULL && strcmp(cache_mode, "local") == 0) {
422 // Don't use the proxy in local mode. This is used by the
423 // proxy itself.
424 return -1;
425 }
426
427 // Temporary cautious hack to disable the DNS proxy for processes
428 // requesting special treatment. Ideally the DNS proxy should
429 // accomodate these apps, though.
430 char propname[PROP_NAME_MAX];
431 char propvalue[PROP_VALUE_MAX];
432 snprintf(propname, sizeof(propname), "net.dns1.%d", getpid());
433 if (__system_property_get(propname, propvalue) > 0) {
434 return -1;
435 }
436
437 // Bogus things we can't serialize. Don't use the proxy.
438 if ((hostname != NULL &&
439 strcspn(hostname, " \n\r\t^'\"") != strlen(hostname)) ||
440 (servname != NULL &&
441 strcspn(servname, " \n\r\t^'\"") != strlen(servname))) {
442 return -1;
443 }
444
445 sock = socket(AF_UNIX, SOCK_STREAM, 0);
446 if (sock < 0) {
447 return -1;
448 }
449
450 setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
451 memset(&proxy_addr, 0, sizeof(proxy_addr));
452 proxy_addr.sun_family = AF_UNIX;
453 strlcpy(proxy_addr.sun_path, "/dev/socket/dnsproxyd",
454 sizeof(proxy_addr.sun_path));
455 if (TEMP_FAILURE_RETRY(connect(sock,
456 (const struct sockaddr*) &proxy_addr,
457 sizeof(proxy_addr))) != 0) {
458 close(sock);
459 return -1;
460 }
461
462 // Send the request.
463 proxy = fdopen(sock, "r+");
464 if (fprintf(proxy, "getaddrinfo %s %s %d %d %d %d",
465 hostname == NULL ? "^" : hostname,
466 servname == NULL ? "^" : servname,
467 hints == NULL ? -1 : hints->ai_flags,
468 hints == NULL ? -1 : hints->ai_family,
469 hints == NULL ? -1 : hints->ai_socktype,
470 hints == NULL ? -1 : hints->ai_protocol) < 0) {
471 goto exit;
472 }
473 // literal NULL byte at end, required by FrameworkListener
474 if (fputc(0, proxy) == EOF ||
475 fflush(proxy) != 0) {
476 goto exit;
477 }
478
479 int remote_rv;
480 if (fread(&remote_rv, sizeof(int), 1, proxy) != 1) {
481 goto exit;
482 }
483
484 if (remote_rv != 0) {
485 goto exit;
486 }
487
488 struct addrinfo* ai = NULL;
489 struct addrinfo** nextres = res;
490 while (1) {
491 uint32_t addrinfo_len;
492 if (fread(&addrinfo_len, sizeof(addrinfo_len),
493 1, proxy) != 1) {
494 break;
495 }
496 addrinfo_len = ntohl(addrinfo_len);
497 if (addrinfo_len == 0) {
498 success = 1;
499 break;
500 }
501
502 if (addrinfo_len < sizeof(struct addrinfo)) {
503 break;
504 }
505 struct addrinfo* ai = calloc(1, addrinfo_len +
506 sizeof(struct sockaddr_storage));
507 if (ai == NULL) {
508 break;
509 }
510
511 if (fread(ai, addrinfo_len, 1, proxy) != 1) {
512 // Error; fall through.
513 break;
514 }
515
516 // Zero out the pointer fields we copied which aren't
517 // valid in this address space.
518 ai->ai_addr = NULL;
519 ai->ai_canonname = NULL;
520 ai->ai_next = NULL;
521
522 // struct sockaddr
523 uint32_t addr_len;
524 if (fread(&addr_len, sizeof(addr_len), 1, proxy) != 1) {
525 break;
526 }
527 addr_len = ntohl(addr_len);
528 if (addr_len != 0) {
529 if (addr_len > sizeof(struct sockaddr_storage)) {
530 // Bogus; too big.
531 break;
532 }
533 struct sockaddr* addr = (struct sockaddr*)(ai + 1);
534 if (fread(addr, addr_len, 1, proxy) != 1) {
535 break;
536 }
537 ai->ai_addr = addr;
538 }
539
540 // cannonname
541 uint32_t name_len;
542 if (fread(&name_len, sizeof(name_len), 1, proxy) != 1) {
543 break;
544 }
545 name_len = ntohl(name_len);
546 if (name_len != 0) {
547 ai->ai_canonname = (char*) malloc(name_len);
548 if (fread(ai->ai_canonname, name_len, 1, proxy) != 1) {
549 break;
550 }
551 if (ai->ai_canonname[name_len - 1] != '\0') {
552 // The proxy should be returning this
553 // NULL-terminated.
554 break;
555 }
556 }
557
558 *nextres = ai;
559 nextres = &ai->ai_next;
560 ai = NULL;
561 }
562
563 if (ai != NULL) {
564 // Clean up partially-built addrinfo that we never ended up
565 // attaching to the response.
566 freeaddrinfo(ai);
567 }
568 exit:
569 if (proxy != NULL) {
570 fclose(proxy);
571 }
572
573 if (success) {
574 return 0;
575 }
576
577 // Proxy failed; fall through to local
578 // resolver case. But first clean up any
579 // memory we might've allocated.
580 if (*res) {
581 freeaddrinfo(*res);
582 *res = NULL;
583 }
584 return -1;
585 }
586
587 int
getaddrinfo(const char * hostname,const char * servname,const struct addrinfo * hints,struct addrinfo ** res)588 getaddrinfo(const char *hostname, const char *servname,
589 const struct addrinfo *hints, struct addrinfo **res)
590 {
591 struct addrinfo sentinel;
592 struct addrinfo *cur;
593 int error = 0;
594 struct addrinfo ai;
595 struct addrinfo ai0;
596 struct addrinfo *pai;
597 const struct explore *ex;
598
599 /* hostname is allowed to be NULL */
600 /* servname is allowed to be NULL */
601 /* hints is allowed to be NULL */
602 assert(res != NULL);
603
604 memset(&sentinel, 0, sizeof(sentinel));
605 cur = &sentinel;
606 pai = &ai;
607 pai->ai_flags = 0;
608 pai->ai_family = PF_UNSPEC;
609 pai->ai_socktype = ANY;
610 pai->ai_protocol = ANY;
611 pai->ai_addrlen = 0;
612 pai->ai_canonname = NULL;
613 pai->ai_addr = NULL;
614 pai->ai_next = NULL;
615
616 if (hostname == NULL && servname == NULL)
617 return EAI_NONAME;
618 if (hints) {
619 /* error check for hints */
620 if (hints->ai_addrlen || hints->ai_canonname ||
621 hints->ai_addr || hints->ai_next)
622 ERR(EAI_BADHINTS); /* xxx */
623 if (hints->ai_flags & ~AI_MASK)
624 ERR(EAI_BADFLAGS);
625 switch (hints->ai_family) {
626 case PF_UNSPEC:
627 case PF_INET:
628 #ifdef INET6
629 case PF_INET6:
630 #endif
631 break;
632 default:
633 ERR(EAI_FAMILY);
634 }
635 memcpy(pai, hints, sizeof(*pai));
636
637 /*
638 * if both socktype/protocol are specified, check if they
639 * are meaningful combination.
640 */
641 if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) {
642 for (ex = explore; ex->e_af >= 0; ex++) {
643 if (pai->ai_family != ex->e_af)
644 continue;
645 if (ex->e_socktype == ANY)
646 continue;
647 if (ex->e_protocol == ANY)
648 continue;
649 if (pai->ai_socktype == ex->e_socktype
650 && pai->ai_protocol != ex->e_protocol) {
651 ERR(EAI_BADHINTS);
652 }
653 }
654 }
655 }
656
657 /*
658 * check for special cases. (1) numeric servname is disallowed if
659 * socktype/protocol are left unspecified. (2) servname is disallowed
660 * for raw and other inet{,6} sockets.
661 */
662 if (MATCH_FAMILY(pai->ai_family, PF_INET, 1)
663 #ifdef PF_INET6
664 || MATCH_FAMILY(pai->ai_family, PF_INET6, 1)
665 #endif
666 ) {
667 ai0 = *pai; /* backup *pai */
668
669 if (pai->ai_family == PF_UNSPEC) {
670 #ifdef PF_INET6
671 pai->ai_family = PF_INET6;
672 #else
673 pai->ai_family = PF_INET;
674 #endif
675 }
676 error = get_portmatch(pai, servname);
677 if (error)
678 ERR(error);
679
680 *pai = ai0;
681 }
682
683 ai0 = *pai;
684
685 /* NULL hostname, or numeric hostname */
686 for (ex = explore; ex->e_af >= 0; ex++) {
687 *pai = ai0;
688
689 /* PF_UNSPEC entries are prepared for DNS queries only */
690 if (ex->e_af == PF_UNSPEC)
691 continue;
692
693 if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))
694 continue;
695 if (!MATCH(pai->ai_socktype, ex->e_socktype, WILD_SOCKTYPE(ex)))
696 continue;
697 if (!MATCH(pai->ai_protocol, ex->e_protocol, WILD_PROTOCOL(ex)))
698 continue;
699
700 if (pai->ai_family == PF_UNSPEC)
701 pai->ai_family = ex->e_af;
702 if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
703 pai->ai_socktype = ex->e_socktype;
704 if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
705 pai->ai_protocol = ex->e_protocol;
706
707 if (hostname == NULL)
708 error = explore_null(pai, servname, &cur->ai_next);
709 else
710 error = explore_numeric_scope(pai, hostname, servname,
711 &cur->ai_next);
712
713 if (error)
714 goto free;
715
716 while (cur->ai_next)
717 cur = cur->ai_next;
718 }
719
720 /*
721 * XXX
722 * If numeric representation of AF1 can be interpreted as FQDN
723 * representation of AF2, we need to think again about the code below.
724 */
725 if (sentinel.ai_next)
726 goto good;
727
728 if (hostname == NULL)
729 ERR(EAI_NODATA);
730 if (pai->ai_flags & AI_NUMERICHOST)
731 ERR(EAI_NONAME);
732
733 /*
734 * BEGIN ANDROID CHANGES; proxying to the cache
735 */
736 if (android_getaddrinfo_proxy(hostname, servname, hints, res) == 0) {
737 return 0;
738 }
739
740 /*
741 * hostname as alphabetical name.
742 * we would like to prefer AF_INET6 than AF_INET, so we'll make a
743 * outer loop by AFs.
744 */
745 for (ex = explore; ex->e_af >= 0; ex++) {
746 *pai = ai0;
747
748 /* require exact match for family field */
749 if (pai->ai_family != ex->e_af)
750 continue;
751
752 if (!MATCH(pai->ai_socktype, ex->e_socktype,
753 WILD_SOCKTYPE(ex))) {
754 continue;
755 }
756 if (!MATCH(pai->ai_protocol, ex->e_protocol,
757 WILD_PROTOCOL(ex))) {
758 continue;
759 }
760
761 if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
762 pai->ai_socktype = ex->e_socktype;
763 if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
764 pai->ai_protocol = ex->e_protocol;
765
766 error = explore_fqdn(pai, hostname, servname,
767 &cur->ai_next);
768
769 while (cur && cur->ai_next)
770 cur = cur->ai_next;
771 }
772
773 /* XXX */
774 if (sentinel.ai_next)
775 error = 0;
776
777 if (error)
778 goto free;
779 if (error == 0) {
780 if (sentinel.ai_next) {
781 good:
782 *res = sentinel.ai_next;
783 return SUCCESS;
784 } else
785 error = EAI_FAIL;
786 }
787 free:
788 bad:
789 if (sentinel.ai_next)
790 freeaddrinfo(sentinel.ai_next);
791 *res = NULL;
792 return error;
793 }
794
795 /*
796 * FQDN hostname, DNS lookup
797 */
798 static int
explore_fqdn(const struct addrinfo * pai,const char * hostname,const char * servname,struct addrinfo ** res)799 explore_fqdn(const struct addrinfo *pai, const char *hostname,
800 const char *servname, struct addrinfo **res)
801 {
802 struct addrinfo *result;
803 struct addrinfo *cur;
804 int error = 0;
805 static const ns_dtab dtab[] = {
806 NS_FILES_CB(_files_getaddrinfo, NULL)
807 { NSSRC_DNS, _dns_getaddrinfo, NULL }, /* force -DHESIOD */
808 NS_NIS_CB(_yp_getaddrinfo, NULL)
809 { 0, 0, 0 }
810 };
811
812 assert(pai != NULL);
813 /* hostname may be NULL */
814 /* servname may be NULL */
815 assert(res != NULL);
816
817 result = NULL;
818
819 /*
820 * if the servname does not match socktype/protocol, ignore it.
821 */
822 if (get_portmatch(pai, servname) != 0)
823 return 0;
824
825 switch (nsdispatch(&result, dtab, NSDB_HOSTS, "getaddrinfo",
826 default_dns_files, hostname, pai)) {
827 case NS_TRYAGAIN:
828 error = EAI_AGAIN;
829 goto free;
830 case NS_UNAVAIL:
831 error = EAI_FAIL;
832 goto free;
833 case NS_NOTFOUND:
834 error = EAI_NODATA;
835 goto free;
836 case NS_SUCCESS:
837 error = 0;
838 for (cur = result; cur; cur = cur->ai_next) {
839 GET_PORT(cur, servname);
840 /* canonname should be filled already */
841 }
842 break;
843 }
844
845 *res = result;
846
847 return 0;
848
849 free:
850 if (result)
851 freeaddrinfo(result);
852 return error;
853 }
854
855 /*
856 * hostname == NULL.
857 * passive socket -> anyaddr (0.0.0.0 or ::)
858 * non-passive socket -> localhost (127.0.0.1 or ::1)
859 */
860 static int
explore_null(const struct addrinfo * pai,const char * servname,struct addrinfo ** res)861 explore_null(const struct addrinfo *pai, const char *servname,
862 struct addrinfo **res)
863 {
864 int s;
865 const struct afd *afd;
866 struct addrinfo *cur;
867 struct addrinfo sentinel;
868 int error;
869
870 assert(pai != NULL);
871 /* servname may be NULL */
872 assert(res != NULL);
873
874 *res = NULL;
875 sentinel.ai_next = NULL;
876 cur = &sentinel;
877
878 /*
879 * filter out AFs that are not supported by the kernel
880 * XXX errno?
881 */
882 s = socket(pai->ai_family, SOCK_DGRAM, 0);
883 if (s < 0) {
884 if (errno != EMFILE)
885 return 0;
886 } else
887 close(s);
888
889 /*
890 * if the servname does not match socktype/protocol, ignore it.
891 */
892 if (get_portmatch(pai, servname) != 0)
893 return 0;
894
895 afd = find_afd(pai->ai_family);
896 if (afd == NULL)
897 return 0;
898
899 if (pai->ai_flags & AI_PASSIVE) {
900 GET_AI(cur->ai_next, afd, afd->a_addrany);
901 /* xxx meaningless?
902 * GET_CANONNAME(cur->ai_next, "anyaddr");
903 */
904 GET_PORT(cur->ai_next, servname);
905 } else {
906 GET_AI(cur->ai_next, afd, afd->a_loopback);
907 /* xxx meaningless?
908 * GET_CANONNAME(cur->ai_next, "localhost");
909 */
910 GET_PORT(cur->ai_next, servname);
911 }
912 cur = cur->ai_next;
913
914 *res = sentinel.ai_next;
915 return 0;
916
917 free:
918 if (sentinel.ai_next)
919 freeaddrinfo(sentinel.ai_next);
920 return error;
921 }
922
923 /*
924 * numeric hostname
925 */
926 static int
explore_numeric(const struct addrinfo * pai,const char * hostname,const char * servname,struct addrinfo ** res,const char * canonname)927 explore_numeric(const struct addrinfo *pai, const char *hostname,
928 const char *servname, struct addrinfo **res, const char *canonname)
929 {
930 const struct afd *afd;
931 struct addrinfo *cur;
932 struct addrinfo sentinel;
933 int error;
934 char pton[PTON_MAX];
935
936 assert(pai != NULL);
937 /* hostname may be NULL */
938 /* servname may be NULL */
939 assert(res != NULL);
940
941 *res = NULL;
942 sentinel.ai_next = NULL;
943 cur = &sentinel;
944
945 /*
946 * if the servname does not match socktype/protocol, ignore it.
947 */
948 if (get_portmatch(pai, servname) != 0)
949 return 0;
950
951 afd = find_afd(pai->ai_family);
952 if (afd == NULL)
953 return 0;
954
955 switch (afd->a_af) {
956 #if 0 /*X/Open spec*/
957 case AF_INET:
958 if (inet_aton(hostname, (struct in_addr *)pton) == 1) {
959 if (pai->ai_family == afd->a_af ||
960 pai->ai_family == PF_UNSPEC /*?*/) {
961 GET_AI(cur->ai_next, afd, pton);
962 GET_PORT(cur->ai_next, servname);
963 if ((pai->ai_flags & AI_CANONNAME)) {
964 /*
965 * Set the numeric address itself as
966 * the canonical name, based on a
967 * clarification in rfc2553bis-03.
968 */
969 GET_CANONNAME(cur->ai_next, canonname);
970 }
971 while (cur && cur->ai_next)
972 cur = cur->ai_next;
973 } else
974 ERR(EAI_FAMILY); /*xxx*/
975 }
976 break;
977 #endif
978 default:
979 if (inet_pton(afd->a_af, hostname, pton) == 1) {
980 if (pai->ai_family == afd->a_af ||
981 pai->ai_family == PF_UNSPEC /*?*/) {
982 GET_AI(cur->ai_next, afd, pton);
983 GET_PORT(cur->ai_next, servname);
984 if ((pai->ai_flags & AI_CANONNAME)) {
985 /*
986 * Set the numeric address itself as
987 * the canonical name, based on a
988 * clarification in rfc2553bis-03.
989 */
990 GET_CANONNAME(cur->ai_next, canonname);
991 }
992 while (cur->ai_next)
993 cur = cur->ai_next;
994 } else
995 ERR(EAI_FAMILY); /*xxx*/
996 }
997 break;
998 }
999
1000 *res = sentinel.ai_next;
1001 return 0;
1002
1003 free:
1004 bad:
1005 if (sentinel.ai_next)
1006 freeaddrinfo(sentinel.ai_next);
1007 return error;
1008 }
1009
1010 /*
1011 * numeric hostname with scope
1012 */
1013 static int
explore_numeric_scope(const struct addrinfo * pai,const char * hostname,const char * servname,struct addrinfo ** res)1014 explore_numeric_scope(const struct addrinfo *pai, const char *hostname,
1015 const char *servname, struct addrinfo **res)
1016 {
1017 #if !defined(SCOPE_DELIMITER) || !defined(INET6)
1018 return explore_numeric(pai, hostname, servname, res, hostname);
1019 #else
1020 const struct afd *afd;
1021 struct addrinfo *cur;
1022 int error;
1023 char *cp, *hostname2 = NULL, *scope, *addr;
1024 struct sockaddr_in6 *sin6;
1025
1026 assert(pai != NULL);
1027 /* hostname may be NULL */
1028 /* servname may be NULL */
1029 assert(res != NULL);
1030
1031 /*
1032 * if the servname does not match socktype/protocol, ignore it.
1033 */
1034 if (get_portmatch(pai, servname) != 0)
1035 return 0;
1036
1037 afd = find_afd(pai->ai_family);
1038 if (afd == NULL)
1039 return 0;
1040
1041 if (!afd->a_scoped)
1042 return explore_numeric(pai, hostname, servname, res, hostname);
1043
1044 cp = strchr(hostname, SCOPE_DELIMITER);
1045 if (cp == NULL)
1046 return explore_numeric(pai, hostname, servname, res, hostname);
1047
1048 /*
1049 * Handle special case of <scoped_address><delimiter><scope id>
1050 */
1051 hostname2 = strdup(hostname);
1052 if (hostname2 == NULL)
1053 return EAI_MEMORY;
1054 /* terminate at the delimiter */
1055 hostname2[cp - hostname] = '\0';
1056 addr = hostname2;
1057 scope = cp + 1;
1058
1059 error = explore_numeric(pai, addr, servname, res, hostname);
1060 if (error == 0) {
1061 u_int32_t scopeid;
1062
1063 for (cur = *res; cur; cur = cur->ai_next) {
1064 if (cur->ai_family != AF_INET6)
1065 continue;
1066 sin6 = (struct sockaddr_in6 *)(void *)cur->ai_addr;
1067 if (ip6_str2scopeid(scope, sin6, &scopeid) == -1) {
1068 free(hostname2);
1069 return(EAI_NODATA); /* XXX: is return OK? */
1070 }
1071 sin6->sin6_scope_id = scopeid;
1072 }
1073 }
1074
1075 free(hostname2);
1076
1077 return error;
1078 #endif
1079 }
1080
1081 static int
get_canonname(const struct addrinfo * pai,struct addrinfo * ai,const char * str)1082 get_canonname(const struct addrinfo *pai, struct addrinfo *ai, const char *str)
1083 {
1084
1085 assert(pai != NULL);
1086 assert(ai != NULL);
1087 assert(str != NULL);
1088
1089 if ((pai->ai_flags & AI_CANONNAME) != 0) {
1090 ai->ai_canonname = strdup(str);
1091 if (ai->ai_canonname == NULL)
1092 return EAI_MEMORY;
1093 }
1094 return 0;
1095 }
1096
1097 static struct addrinfo *
get_ai(const struct addrinfo * pai,const struct afd * afd,const char * addr)1098 get_ai(const struct addrinfo *pai, const struct afd *afd, const char *addr)
1099 {
1100 char *p;
1101 struct addrinfo *ai;
1102
1103 assert(pai != NULL);
1104 assert(afd != NULL);
1105 assert(addr != NULL);
1106
1107 ai = (struct addrinfo *)malloc(sizeof(struct addrinfo)
1108 + (afd->a_socklen));
1109 if (ai == NULL)
1110 return NULL;
1111
1112 memcpy(ai, pai, sizeof(struct addrinfo));
1113 ai->ai_addr = (struct sockaddr *)(void *)(ai + 1);
1114 memset(ai->ai_addr, 0, (size_t)afd->a_socklen);
1115
1116 #ifdef HAVE_SA_LEN
1117 ai->ai_addr->sa_len = afd->a_socklen;
1118 #endif
1119
1120 ai->ai_addrlen = afd->a_socklen;
1121 #if defined (__alpha__) || (defined(__i386__) && defined(_LP64)) || defined(__sparc64__)
1122 ai->__ai_pad0 = 0;
1123 #endif
1124 ai->ai_addr->sa_family = ai->ai_family = afd->a_af;
1125 p = (char *)(void *)(ai->ai_addr);
1126 memcpy(p + afd->a_off, addr, (size_t)afd->a_addrlen);
1127 return ai;
1128 }
1129
1130 static int
get_portmatch(const struct addrinfo * ai,const char * servname)1131 get_portmatch(const struct addrinfo *ai, const char *servname)
1132 {
1133
1134 assert(ai != NULL);
1135 /* servname may be NULL */
1136
1137 return get_port(ai, servname, 1);
1138 }
1139
1140 static int
get_port(const struct addrinfo * ai,const char * servname,int matchonly)1141 get_port(const struct addrinfo *ai, const char *servname, int matchonly)
1142 {
1143 const char *proto;
1144 struct servent *sp;
1145 int port;
1146 int allownumeric;
1147
1148 assert(ai != NULL);
1149 /* servname may be NULL */
1150
1151 if (servname == NULL)
1152 return 0;
1153 switch (ai->ai_family) {
1154 case AF_INET:
1155 #ifdef AF_INET6
1156 case AF_INET6:
1157 #endif
1158 break;
1159 default:
1160 return 0;
1161 }
1162
1163 switch (ai->ai_socktype) {
1164 case SOCK_RAW:
1165 return EAI_SERVICE;
1166 case SOCK_DGRAM:
1167 case SOCK_STREAM:
1168 allownumeric = 1;
1169 break;
1170 case ANY:
1171 #if 1 /* ANDROID-SPECIFIC CHANGE TO MATCH GLIBC */
1172 allownumeric = 1;
1173 #else
1174 allownumeric = 0;
1175 #endif
1176 break;
1177 default:
1178 return EAI_SOCKTYPE;
1179 }
1180
1181 port = str2number(servname);
1182 if (port >= 0) {
1183 if (!allownumeric)
1184 return EAI_SERVICE;
1185 if (port < 0 || port > 65535)
1186 return EAI_SERVICE;
1187 port = htons(port);
1188 } else {
1189 if (ai->ai_flags & AI_NUMERICSERV)
1190 return EAI_NONAME;
1191
1192 switch (ai->ai_socktype) {
1193 case SOCK_DGRAM:
1194 proto = "udp";
1195 break;
1196 case SOCK_STREAM:
1197 proto = "tcp";
1198 break;
1199 default:
1200 proto = NULL;
1201 break;
1202 }
1203
1204 if ((sp = getservbyname(servname, proto)) == NULL)
1205 return EAI_SERVICE;
1206 port = sp->s_port;
1207 }
1208
1209 if (!matchonly) {
1210 switch (ai->ai_family) {
1211 case AF_INET:
1212 ((struct sockaddr_in *)(void *)
1213 ai->ai_addr)->sin_port = port;
1214 break;
1215 #ifdef INET6
1216 case AF_INET6:
1217 ((struct sockaddr_in6 *)(void *)
1218 ai->ai_addr)->sin6_port = port;
1219 break;
1220 #endif
1221 }
1222 }
1223
1224 return 0;
1225 }
1226
1227 static const struct afd *
find_afd(int af)1228 find_afd(int af)
1229 {
1230 const struct afd *afd;
1231
1232 if (af == PF_UNSPEC)
1233 return NULL;
1234 for (afd = afdl; afd->a_af; afd++) {
1235 if (afd->a_af == af)
1236 return afd;
1237 }
1238 return NULL;
1239 }
1240
1241 #ifdef INET6
1242 /* convert a string to a scope identifier. XXX: IPv6 specific */
1243 static int
ip6_str2scopeid(char * scope,struct sockaddr_in6 * sin6,u_int32_t * scopeid)1244 ip6_str2scopeid(char *scope, struct sockaddr_in6 *sin6, u_int32_t *scopeid)
1245 {
1246 u_long lscopeid;
1247 struct in6_addr *a6;
1248 char *ep;
1249
1250 assert(scope != NULL);
1251 assert(sin6 != NULL);
1252 assert(scopeid != NULL);
1253
1254 a6 = &sin6->sin6_addr;
1255
1256 /* empty scopeid portion is invalid */
1257 if (*scope == '\0')
1258 return -1;
1259
1260 if (IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6)) {
1261 /*
1262 * We currently assume a one-to-one mapping between links
1263 * and interfaces, so we simply use interface indices for
1264 * like-local scopes.
1265 */
1266 *scopeid = if_nametoindex(scope);
1267 if (*scopeid == 0)
1268 goto trynumeric;
1269 return 0;
1270 }
1271
1272 /* still unclear about literal, allow numeric only - placeholder */
1273 if (IN6_IS_ADDR_SITELOCAL(a6) || IN6_IS_ADDR_MC_SITELOCAL(a6))
1274 goto trynumeric;
1275 if (IN6_IS_ADDR_MC_ORGLOCAL(a6))
1276 goto trynumeric;
1277 else
1278 goto trynumeric; /* global */
1279
1280 /* try to convert to a numeric id as a last resort */
1281 trynumeric:
1282 errno = 0;
1283 lscopeid = strtoul(scope, &ep, 10);
1284 *scopeid = (u_int32_t)(lscopeid & 0xffffffffUL);
1285 if (errno == 0 && ep && *ep == '\0' && *scopeid == lscopeid)
1286 return 0;
1287 else
1288 return -1;
1289 }
1290 #endif
1291
1292 /* code duplicate with gethnamaddr.c */
1293
1294 static const char AskedForGot[] =
1295 "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
1296
1297 static struct addrinfo *
getanswer(const querybuf * answer,int anslen,const char * qname,int qtype,const struct addrinfo * pai)1298 getanswer(const querybuf *answer, int anslen, const char *qname, int qtype,
1299 const struct addrinfo *pai)
1300 {
1301 struct addrinfo sentinel, *cur;
1302 struct addrinfo ai;
1303 const struct afd *afd;
1304 char *canonname;
1305 const HEADER *hp;
1306 const u_char *cp;
1307 int n;
1308 const u_char *eom;
1309 char *bp, *ep;
1310 int type, class, ancount, qdcount;
1311 int haveanswer, had_error;
1312 char tbuf[MAXDNAME];
1313 int (*name_ok) (const char *);
1314 char hostbuf[8*1024];
1315
1316 assert(answer != NULL);
1317 assert(qname != NULL);
1318 assert(pai != NULL);
1319
1320 memset(&sentinel, 0, sizeof(sentinel));
1321 cur = &sentinel;
1322
1323 canonname = NULL;
1324 eom = answer->buf + anslen;
1325 switch (qtype) {
1326 case T_A:
1327 case T_AAAA:
1328 case T_ANY: /*use T_ANY only for T_A/T_AAAA lookup*/
1329 name_ok = res_hnok;
1330 break;
1331 default:
1332 return NULL; /* XXX should be abort(); */
1333 }
1334 /*
1335 * find first satisfactory answer
1336 */
1337 hp = &answer->hdr;
1338 ancount = ntohs(hp->ancount);
1339 qdcount = ntohs(hp->qdcount);
1340 bp = hostbuf;
1341 ep = hostbuf + sizeof hostbuf;
1342 cp = answer->buf + HFIXEDSZ;
1343 if (qdcount != 1) {
1344 h_errno = NO_RECOVERY;
1345 return (NULL);
1346 }
1347 n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
1348 if ((n < 0) || !(*name_ok)(bp)) {
1349 h_errno = NO_RECOVERY;
1350 return (NULL);
1351 }
1352 cp += n + QFIXEDSZ;
1353 if (qtype == T_A || qtype == T_AAAA || qtype == T_ANY) {
1354 /* res_send() has already verified that the query name is the
1355 * same as the one we sent; this just gets the expanded name
1356 * (i.e., with the succeeding search-domain tacked on).
1357 */
1358 n = strlen(bp) + 1; /* for the \0 */
1359 if (n >= MAXHOSTNAMELEN) {
1360 h_errno = NO_RECOVERY;
1361 return (NULL);
1362 }
1363 canonname = bp;
1364 bp += n;
1365 /* The qname can be abbreviated, but h_name is now absolute. */
1366 qname = canonname;
1367 }
1368 haveanswer = 0;
1369 had_error = 0;
1370 while (ancount-- > 0 && cp < eom && !had_error) {
1371 n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
1372 if ((n < 0) || !(*name_ok)(bp)) {
1373 had_error++;
1374 continue;
1375 }
1376 cp += n; /* name */
1377 type = _getshort(cp);
1378 cp += INT16SZ; /* type */
1379 class = _getshort(cp);
1380 cp += INT16SZ + INT32SZ; /* class, TTL */
1381 n = _getshort(cp);
1382 cp += INT16SZ; /* len */
1383 if (class != C_IN) {
1384 /* XXX - debug? syslog? */
1385 cp += n;
1386 continue; /* XXX - had_error++ ? */
1387 }
1388 if ((qtype == T_A || qtype == T_AAAA || qtype == T_ANY) &&
1389 type == T_CNAME) {
1390 n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
1391 if ((n < 0) || !(*name_ok)(tbuf)) {
1392 had_error++;
1393 continue;
1394 }
1395 cp += n;
1396 /* Get canonical name. */
1397 n = strlen(tbuf) + 1; /* for the \0 */
1398 if (n > ep - bp || n >= MAXHOSTNAMELEN) {
1399 had_error++;
1400 continue;
1401 }
1402 strlcpy(bp, tbuf, (size_t)(ep - bp));
1403 canonname = bp;
1404 bp += n;
1405 continue;
1406 }
1407 if (qtype == T_ANY) {
1408 if (!(type == T_A || type == T_AAAA)) {
1409 cp += n;
1410 continue;
1411 }
1412 } else if (type != qtype) {
1413 if (type != T_KEY && type != T_SIG)
1414 syslog(LOG_NOTICE|LOG_AUTH,
1415 "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
1416 qname, p_class(C_IN), p_type(qtype),
1417 p_type(type));
1418 cp += n;
1419 continue; /* XXX - had_error++ ? */
1420 }
1421 switch (type) {
1422 case T_A:
1423 case T_AAAA:
1424 if (strcasecmp(canonname, bp) != 0) {
1425 syslog(LOG_NOTICE|LOG_AUTH,
1426 AskedForGot, canonname, bp);
1427 cp += n;
1428 continue; /* XXX - had_error++ ? */
1429 }
1430 if (type == T_A && n != INADDRSZ) {
1431 cp += n;
1432 continue;
1433 }
1434 if (type == T_AAAA && n != IN6ADDRSZ) {
1435 cp += n;
1436 continue;
1437 }
1438 if (type == T_AAAA) {
1439 struct in6_addr in6;
1440 memcpy(&in6, cp, IN6ADDRSZ);
1441 if (IN6_IS_ADDR_V4MAPPED(&in6)) {
1442 cp += n;
1443 continue;
1444 }
1445 }
1446 if (!haveanswer) {
1447 int nn;
1448
1449 canonname = bp;
1450 nn = strlen(bp) + 1; /* for the \0 */
1451 bp += nn;
1452 }
1453
1454 /* don't overwrite pai */
1455 ai = *pai;
1456 ai.ai_family = (type == T_A) ? AF_INET : AF_INET6;
1457 afd = find_afd(ai.ai_family);
1458 if (afd == NULL) {
1459 cp += n;
1460 continue;
1461 }
1462 cur->ai_next = get_ai(&ai, afd, (const char *)cp);
1463 if (cur->ai_next == NULL)
1464 had_error++;
1465 while (cur && cur->ai_next)
1466 cur = cur->ai_next;
1467 cp += n;
1468 break;
1469 default:
1470 abort();
1471 }
1472 if (!had_error)
1473 haveanswer++;
1474 }
1475 if (haveanswer) {
1476 if (!canonname)
1477 (void)get_canonname(pai, sentinel.ai_next, qname);
1478 else
1479 (void)get_canonname(pai, sentinel.ai_next, canonname);
1480 h_errno = NETDB_SUCCESS;
1481 return sentinel.ai_next;
1482 }
1483
1484 h_errno = NO_RECOVERY;
1485 return NULL;
1486 }
1487
1488 struct addrinfo_sort_elem {
1489 struct addrinfo *ai;
1490 int has_src_addr;
1491 sockaddr_union src_addr;
1492 int original_order;
1493 };
1494
1495 /*ARGSUSED*/
1496 static int
_get_scope(const struct sockaddr * addr)1497 _get_scope(const struct sockaddr *addr)
1498 {
1499 if (addr->sa_family == AF_INET6) {
1500 const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
1501 if (IN6_IS_ADDR_MULTICAST(&addr6->sin6_addr)) {
1502 return IPV6_ADDR_MC_SCOPE(&addr6->sin6_addr);
1503 } else if (IN6_IS_ADDR_LOOPBACK(&addr6->sin6_addr) ||
1504 IN6_IS_ADDR_LINKLOCAL(&addr6->sin6_addr)) {
1505 /*
1506 * RFC 4291 section 2.5.3 says loopback is to be treated as having
1507 * link-local scope.
1508 */
1509 return IPV6_ADDR_SCOPE_LINKLOCAL;
1510 } else if (IN6_IS_ADDR_SITELOCAL(&addr6->sin6_addr)) {
1511 return IPV6_ADDR_SCOPE_SITELOCAL;
1512 } else {
1513 return IPV6_ADDR_SCOPE_GLOBAL;
1514 }
1515 } else if (addr->sa_family == AF_INET) {
1516 const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr;
1517 unsigned long int na = ntohl(addr4->sin_addr.s_addr);
1518
1519 if (IN_LOOPBACK(na) || /* 127.0.0.0/8 */
1520 (na & 0xffff0000) == 0xa9fe0000) { /* 169.254.0.0/16 */
1521 return IPV6_ADDR_SCOPE_LINKLOCAL;
1522 } else {
1523 /*
1524 * According to draft-ietf-6man-rfc3484-revise-01 section 2.3,
1525 * it is best not to treat the private IPv4 ranges
1526 * (10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16) as being
1527 * in a special scope, so we don't.
1528 */
1529 return IPV6_ADDR_SCOPE_GLOBAL;
1530 }
1531 } else {
1532 /*
1533 * This should never happen.
1534 * Return a scope with low priority as a last resort.
1535 */
1536 return IPV6_ADDR_SCOPE_NODELOCAL;
1537 }
1538 }
1539
1540 /* These macros are modelled after the ones in <netinet/in6.h>. */
1541
1542 /* RFC 4380, section 2.6 */
1543 #define IN6_IS_ADDR_TEREDO(a) \
1544 ((*(const uint32_t *)(const void *)(&(a)->s6_addr[0]) == ntohl(0x20010000)))
1545
1546 /* RFC 3056, section 2. */
1547 #define IN6_IS_ADDR_6TO4(a) \
1548 (((a)->s6_addr[0] == 0x20) && ((a)->s6_addr[1] == 0x02))
1549
1550 /* 6bone testing address area (3ffe::/16), deprecated in RFC 3701. */
1551 #define IN6_IS_ADDR_6BONE(a) \
1552 (((a)->s6_addr[0] == 0x3f) && ((a)->s6_addr[1] == 0xfe))
1553
1554 /*
1555 * Get the label for a given IPv4/IPv6 address.
1556 * RFC 3484, section 2.1, plus changes from draft-ietf-6man-rfc3484-revise-01.
1557 */
1558
1559 /*ARGSUSED*/
1560 static int
_get_label(const struct sockaddr * addr)1561 _get_label(const struct sockaddr *addr)
1562 {
1563 if (addr->sa_family == AF_INET) {
1564 return 3;
1565 } else if (addr->sa_family == AF_INET6) {
1566 const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
1567 if (IN6_IS_ADDR_LOOPBACK(&addr6->sin6_addr)) {
1568 return 0;
1569 } else if (IN6_IS_ADDR_ULA(&addr6->sin6_addr)) {
1570 return 1;
1571 } else if (IN6_IS_ADDR_V4MAPPED(&addr6->sin6_addr)) {
1572 return 3;
1573 } else if (IN6_IS_ADDR_6TO4(&addr6->sin6_addr)) {
1574 return 4;
1575 } else if (IN6_IS_ADDR_TEREDO(&addr6->sin6_addr)) {
1576 return 5;
1577 } else if (IN6_IS_ADDR_V4COMPAT(&addr6->sin6_addr)) {
1578 return 10;
1579 } else if (IN6_IS_ADDR_SITELOCAL(&addr6->sin6_addr)) {
1580 return 11;
1581 } else if (IN6_IS_ADDR_6BONE(&addr6->sin6_addr)) {
1582 return 12;
1583 } else {
1584 return 2;
1585 }
1586 } else {
1587 /*
1588 * This should never happen.
1589 * Return a semi-random label as a last resort.
1590 */
1591 return 1;
1592 }
1593 }
1594
1595 /*
1596 * Get the precedence for a given IPv4/IPv6 address.
1597 * RFC 3484, section 2.1, plus changes from draft-ietf-6man-rfc3484-revise-01.
1598 */
1599
1600 /*ARGSUSED*/
1601 static int
_get_precedence(const struct sockaddr * addr)1602 _get_precedence(const struct sockaddr *addr)
1603 {
1604 if (addr->sa_family == AF_INET) {
1605 return 30;
1606 } else if (addr->sa_family == AF_INET6) {
1607 const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
1608 if (IN6_IS_ADDR_LOOPBACK(&addr6->sin6_addr)) {
1609 return 60;
1610 } else if (IN6_IS_ADDR_ULA(&addr6->sin6_addr)) {
1611 return 50;
1612 } else if (IN6_IS_ADDR_V4MAPPED(&addr6->sin6_addr)) {
1613 return 30;
1614 } else if (IN6_IS_ADDR_6TO4(&addr6->sin6_addr)) {
1615 return 20;
1616 } else if (IN6_IS_ADDR_TEREDO(&addr6->sin6_addr)) {
1617 return 10;
1618 } else if (IN6_IS_ADDR_V4COMPAT(&addr6->sin6_addr) ||
1619 IN6_IS_ADDR_SITELOCAL(&addr6->sin6_addr) ||
1620 IN6_IS_ADDR_6BONE(&addr6->sin6_addr)) {
1621 return 1;
1622 } else {
1623 return 40;
1624 }
1625 } else {
1626 return 1;
1627 }
1628 }
1629
1630 /*
1631 * Find number of matching initial bits between the two addresses a1 and a2.
1632 */
1633
1634 /*ARGSUSED*/
1635 static int
_common_prefix_len(const struct in6_addr * a1,const struct in6_addr * a2)1636 _common_prefix_len(const struct in6_addr *a1, const struct in6_addr *a2)
1637 {
1638 const char *p1 = (const char *)a1;
1639 const char *p2 = (const char *)a2;
1640 unsigned i;
1641
1642 for (i = 0; i < sizeof(*a1); ++i) {
1643 int x, j;
1644
1645 if (p1[i] == p2[i]) {
1646 continue;
1647 }
1648 x = p1[i] ^ p2[i];
1649 for (j = 0; j < CHAR_BIT; ++j) {
1650 if (x & (1 << (CHAR_BIT - 1))) {
1651 return i * CHAR_BIT + j;
1652 }
1653 x <<= 1;
1654 }
1655 }
1656 return sizeof(*a1) * CHAR_BIT;
1657 }
1658
1659 /*
1660 * Compare two source/destination address pairs.
1661 * RFC 3484, section 6.
1662 */
1663
1664 /*ARGSUSED*/
1665 static int
_rfc3484_compare(const void * ptr1,const void * ptr2)1666 _rfc3484_compare(const void *ptr1, const void* ptr2)
1667 {
1668 const struct addrinfo_sort_elem *a1 = (const struct addrinfo_sort_elem *)ptr1;
1669 const struct addrinfo_sort_elem *a2 = (const struct addrinfo_sort_elem *)ptr2;
1670 int scope_src1, scope_dst1, scope_match1;
1671 int scope_src2, scope_dst2, scope_match2;
1672 int label_src1, label_dst1, label_match1;
1673 int label_src2, label_dst2, label_match2;
1674 int precedence1, precedence2;
1675 int prefixlen1, prefixlen2;
1676
1677 /* Rule 1: Avoid unusable destinations. */
1678 if (a1->has_src_addr != a2->has_src_addr) {
1679 return a2->has_src_addr - a1->has_src_addr;
1680 }
1681
1682 /* Rule 2: Prefer matching scope. */
1683 scope_src1 = _get_scope(&a1->src_addr.generic);
1684 scope_dst1 = _get_scope(a1->ai->ai_addr);
1685 scope_match1 = (scope_src1 == scope_dst1);
1686
1687 scope_src2 = _get_scope(&a2->src_addr.generic);
1688 scope_dst2 = _get_scope(a2->ai->ai_addr);
1689 scope_match2 = (scope_src2 == scope_dst2);
1690
1691 if (scope_match1 != scope_match2) {
1692 return scope_match2 - scope_match1;
1693 }
1694
1695 /*
1696 * Rule 3: Avoid deprecated addresses.
1697 * TODO(sesse): We don't currently have a good way of finding this.
1698 */
1699
1700 /*
1701 * Rule 4: Prefer home addresses.
1702 * TODO(sesse): We don't currently have a good way of finding this.
1703 */
1704
1705 /* Rule 5: Prefer matching label. */
1706 label_src1 = _get_label(&a1->src_addr.generic);
1707 label_dst1 = _get_label(a1->ai->ai_addr);
1708 label_match1 = (label_src1 == label_dst1);
1709
1710 label_src2 = _get_label(&a2->src_addr.generic);
1711 label_dst2 = _get_label(a2->ai->ai_addr);
1712 label_match2 = (label_src2 == label_dst2);
1713
1714 if (label_match1 != label_match2) {
1715 return label_match2 - label_match1;
1716 }
1717
1718 /* Rule 6: Prefer higher precedence. */
1719 precedence1 = _get_precedence(a1->ai->ai_addr);
1720 precedence2 = _get_precedence(a2->ai->ai_addr);
1721 if (precedence1 != precedence2) {
1722 return precedence2 - precedence1;
1723 }
1724
1725 /*
1726 * Rule 7: Prefer native transport.
1727 * TODO(sesse): We don't currently have a good way of finding this.
1728 */
1729
1730 /* Rule 8: Prefer smaller scope. */
1731 if (scope_dst1 != scope_dst2) {
1732 return scope_dst1 - scope_dst2;
1733 }
1734
1735 /*
1736 * Rule 9: Use longest matching prefix.
1737 * We implement this for IPv6 only, as the rules in RFC 3484 don't seem
1738 * to work very well directly applied to IPv4. (glibc uses information from
1739 * the routing table for a custom IPv4 implementation here.)
1740 */
1741 if (a1->has_src_addr && a1->ai->ai_addr->sa_family == AF_INET6 &&
1742 a2->has_src_addr && a2->ai->ai_addr->sa_family == AF_INET6) {
1743 const struct sockaddr_in6 *a1_src = &a1->src_addr.in6;
1744 const struct sockaddr_in6 *a1_dst = (const struct sockaddr_in6 *)a1->ai->ai_addr;
1745 const struct sockaddr_in6 *a2_src = &a2->src_addr.in6;
1746 const struct sockaddr_in6 *a2_dst = (const struct sockaddr_in6 *)a2->ai->ai_addr;
1747 prefixlen1 = _common_prefix_len(&a1_src->sin6_addr, &a1_dst->sin6_addr);
1748 prefixlen2 = _common_prefix_len(&a2_src->sin6_addr, &a2_dst->sin6_addr);
1749 if (prefixlen1 != prefixlen2) {
1750 return prefixlen2 - prefixlen1;
1751 }
1752 }
1753
1754 /*
1755 * Rule 10: Leave the order unchanged.
1756 * We need this since qsort() is not necessarily stable.
1757 */
1758 return a1->original_order - a2->original_order;
1759 }
1760
1761 /*
1762 * Find the source address that will be used if trying to connect to the given
1763 * address. src_addr must be large enough to hold a struct sockaddr_in6.
1764 *
1765 * Returns 1 if a source address was found, 0 if the address is unreachable,
1766 * and -1 if a fatal error occurred. If 0 or 1, the contents of src_addr are
1767 * undefined.
1768 */
1769
1770 /*ARGSUSED*/
1771 static int
_find_src_addr(const struct sockaddr * addr,struct sockaddr * src_addr)1772 _find_src_addr(const struct sockaddr *addr, struct sockaddr *src_addr)
1773 {
1774 int sock;
1775 int ret;
1776 socklen_t len;
1777
1778 switch (addr->sa_family) {
1779 case AF_INET:
1780 len = sizeof(struct sockaddr_in);
1781 break;
1782 case AF_INET6:
1783 len = sizeof(struct sockaddr_in6);
1784 break;
1785 default:
1786 /* No known usable source address for non-INET families. */
1787 return 0;
1788 }
1789
1790 sock = socket(addr->sa_family, SOCK_DGRAM, IPPROTO_UDP);
1791 if (sock == -1) {
1792 if (errno == EAFNOSUPPORT) {
1793 return 0;
1794 } else {
1795 return -1;
1796 }
1797 }
1798
1799 do {
1800 ret = connect(sock, addr, len);
1801 } while (ret == -1 && errno == EINTR);
1802
1803 if (ret == -1) {
1804 close(sock);
1805 return 0;
1806 }
1807
1808 if (getsockname(sock, src_addr, &len) == -1) {
1809 close(sock);
1810 return -1;
1811 }
1812 close(sock);
1813 return 1;
1814 }
1815
1816 /*
1817 * Sort the linked list starting at sentinel->ai_next in RFC3484 order.
1818 * Will leave the list unchanged if an error occurs.
1819 */
1820
1821 /*ARGSUSED*/
1822 static void
_rfc3484_sort(struct addrinfo * list_sentinel)1823 _rfc3484_sort(struct addrinfo *list_sentinel)
1824 {
1825 struct addrinfo *cur;
1826 int nelem = 0, i;
1827 struct addrinfo_sort_elem *elems;
1828
1829 cur = list_sentinel->ai_next;
1830 while (cur) {
1831 ++nelem;
1832 cur = cur->ai_next;
1833 }
1834
1835 elems = (struct addrinfo_sort_elem *)malloc(nelem * sizeof(struct addrinfo_sort_elem));
1836 if (elems == NULL) {
1837 goto error;
1838 }
1839
1840 /*
1841 * Convert the linked list to an array that also contains the candidate
1842 * source address for each destination address.
1843 */
1844 for (i = 0, cur = list_sentinel->ai_next; i < nelem; ++i, cur = cur->ai_next) {
1845 int has_src_addr;
1846 assert(cur != NULL);
1847 elems[i].ai = cur;
1848 elems[i].original_order = i;
1849
1850 has_src_addr = _find_src_addr(cur->ai_addr, &elems[i].src_addr.generic);
1851 if (has_src_addr == -1) {
1852 goto error;
1853 }
1854 elems[i].has_src_addr = has_src_addr;
1855 }
1856
1857 /* Sort the addresses, and rearrange the linked list so it matches the sorted order. */
1858 qsort((void *)elems, nelem, sizeof(struct addrinfo_sort_elem), _rfc3484_compare);
1859
1860 list_sentinel->ai_next = elems[0].ai;
1861 for (i = 0; i < nelem - 1; ++i) {
1862 elems[i].ai->ai_next = elems[i + 1].ai;
1863 }
1864 elems[nelem - 1].ai->ai_next = NULL;
1865
1866 error:
1867 free(elems);
1868 }
1869
1870 /*ARGSUSED*/
1871 static int
_dns_getaddrinfo(void * rv,void * cb_data,va_list ap)1872 _dns_getaddrinfo(void *rv, void *cb_data, va_list ap)
1873 {
1874 struct addrinfo *ai;
1875 querybuf *buf, *buf2;
1876 const char *name;
1877 const struct addrinfo *pai;
1878 struct addrinfo sentinel, *cur;
1879 struct res_target q, q2;
1880 res_state res;
1881
1882 name = va_arg(ap, char *);
1883 pai = va_arg(ap, const struct addrinfo *);
1884 //fprintf(stderr, "_dns_getaddrinfo() name = '%s'\n", name);
1885
1886 memset(&q, 0, sizeof(q));
1887 memset(&q2, 0, sizeof(q2));
1888 memset(&sentinel, 0, sizeof(sentinel));
1889 cur = &sentinel;
1890
1891 buf = malloc(sizeof(*buf));
1892 if (buf == NULL) {
1893 h_errno = NETDB_INTERNAL;
1894 return NS_NOTFOUND;
1895 }
1896 buf2 = malloc(sizeof(*buf2));
1897 if (buf2 == NULL) {
1898 free(buf);
1899 h_errno = NETDB_INTERNAL;
1900 return NS_NOTFOUND;
1901 }
1902
1903 switch (pai->ai_family) {
1904 case AF_UNSPEC:
1905 /* prefer IPv6 */
1906 q.name = name;
1907 q.qclass = C_IN;
1908 q.answer = buf->buf;
1909 q.anslen = sizeof(buf->buf);
1910 int query_ipv6 = 1, query_ipv4 = 1;
1911 if (pai->ai_flags & AI_ADDRCONFIG) {
1912 query_ipv6 = _have_ipv6();
1913 query_ipv4 = _have_ipv4();
1914 if (query_ipv6 == 0 && query_ipv4 == 0) {
1915 // Both our IPv4 and IPv6 connectivity probes failed, which indicates
1916 // that we have neither an IPv4 or an IPv6 default route (and thus no
1917 // global IPv4 or IPv6 connectivity). We might be in a walled garden.
1918 // Throw up our arms and ask for both A and AAAA.
1919 query_ipv6 = query_ipv4 = 1;
1920 }
1921 }
1922 if (query_ipv6) {
1923 q.qtype = T_AAAA;
1924 if (query_ipv4) {
1925 q.next = &q2;
1926 q2.name = name;
1927 q2.qclass = C_IN;
1928 q2.qtype = T_A;
1929 q2.answer = buf2->buf;
1930 q2.anslen = sizeof(buf2->buf);
1931 }
1932 } else if (query_ipv4) {
1933 q.qtype = T_A;
1934 } else {
1935 free(buf);
1936 free(buf2);
1937 return NS_NOTFOUND;
1938 }
1939 break;
1940 case AF_INET:
1941 q.name = name;
1942 q.qclass = C_IN;
1943 q.qtype = T_A;
1944 q.answer = buf->buf;
1945 q.anslen = sizeof(buf->buf);
1946 break;
1947 case AF_INET6:
1948 q.name = name;
1949 q.qclass = C_IN;
1950 q.qtype = T_AAAA;
1951 q.answer = buf->buf;
1952 q.anslen = sizeof(buf->buf);
1953 break;
1954 default:
1955 free(buf);
1956 free(buf2);
1957 return NS_UNAVAIL;
1958 }
1959
1960 res = __res_get_state();
1961 if (res == NULL) {
1962 free(buf);
1963 free(buf2);
1964 return NS_NOTFOUND;
1965 }
1966
1967 if (res_searchN(name, &q, res) < 0) {
1968 __res_put_state(res);
1969 free(buf);
1970 free(buf2);
1971 return NS_NOTFOUND;
1972 }
1973 ai = getanswer(buf, q.n, q.name, q.qtype, pai);
1974 if (ai) {
1975 cur->ai_next = ai;
1976 while (cur && cur->ai_next)
1977 cur = cur->ai_next;
1978 }
1979 if (q.next) {
1980 ai = getanswer(buf2, q2.n, q2.name, q2.qtype, pai);
1981 if (ai)
1982 cur->ai_next = ai;
1983 }
1984 free(buf);
1985 free(buf2);
1986 if (sentinel.ai_next == NULL) {
1987 __res_put_state(res);
1988 switch (h_errno) {
1989 case HOST_NOT_FOUND:
1990 return NS_NOTFOUND;
1991 case TRY_AGAIN:
1992 return NS_TRYAGAIN;
1993 default:
1994 return NS_UNAVAIL;
1995 }
1996 }
1997
1998 _rfc3484_sort(&sentinel);
1999
2000 __res_put_state(res);
2001
2002 *((struct addrinfo **)rv) = sentinel.ai_next;
2003 return NS_SUCCESS;
2004 }
2005
2006 static void
_sethtent(FILE ** hostf)2007 _sethtent(FILE **hostf)
2008 {
2009
2010 if (!*hostf)
2011 *hostf = fopen(_PATH_HOSTS, "r" );
2012 else
2013 rewind(*hostf);
2014 }
2015
2016 static void
_endhtent(FILE ** hostf)2017 _endhtent(FILE **hostf)
2018 {
2019
2020 if (*hostf) {
2021 (void) fclose(*hostf);
2022 *hostf = NULL;
2023 }
2024 }
2025
2026 static struct addrinfo *
_gethtent(FILE ** hostf,const char * name,const struct addrinfo * pai)2027 _gethtent(FILE **hostf, const char *name, const struct addrinfo *pai)
2028 {
2029 char *p;
2030 char *cp, *tname, *cname;
2031 struct addrinfo hints, *res0, *res;
2032 int error;
2033 const char *addr;
2034 char hostbuf[8*1024];
2035
2036 // fprintf(stderr, "_gethtent() name = '%s'\n", name);
2037 assert(name != NULL);
2038 assert(pai != NULL);
2039
2040 if (!*hostf && !(*hostf = fopen(_PATH_HOSTS, "r" )))
2041 return (NULL);
2042 again:
2043 if (!(p = fgets(hostbuf, sizeof hostbuf, *hostf)))
2044 return (NULL);
2045 if (*p == '#')
2046 goto again;
2047 if (!(cp = strpbrk(p, "#\n")))
2048 goto again;
2049 *cp = '\0';
2050 if (!(cp = strpbrk(p, " \t")))
2051 goto again;
2052 *cp++ = '\0';
2053 addr = p;
2054 /* if this is not something we're looking for, skip it. */
2055 cname = NULL;
2056 while (cp && *cp) {
2057 if (*cp == ' ' || *cp == '\t') {
2058 cp++;
2059 continue;
2060 }
2061 if (!cname)
2062 cname = cp;
2063 tname = cp;
2064 if ((cp = strpbrk(cp, " \t")) != NULL)
2065 *cp++ = '\0';
2066 // fprintf(stderr, "\ttname = '%s'", tname);
2067 if (strcasecmp(name, tname) == 0)
2068 goto found;
2069 }
2070 goto again;
2071
2072 found:
2073 hints = *pai;
2074 hints.ai_flags = AI_NUMERICHOST;
2075 error = getaddrinfo(addr, NULL, &hints, &res0);
2076 if (error)
2077 goto again;
2078 for (res = res0; res; res = res->ai_next) {
2079 /* cover it up */
2080 res->ai_flags = pai->ai_flags;
2081
2082 if (pai->ai_flags & AI_CANONNAME) {
2083 if (get_canonname(pai, res, cname) != 0) {
2084 freeaddrinfo(res0);
2085 goto again;
2086 }
2087 }
2088 }
2089 return res0;
2090 }
2091
2092 /*ARGSUSED*/
2093 static int
_files_getaddrinfo(void * rv,void * cb_data,va_list ap)2094 _files_getaddrinfo(void *rv, void *cb_data, va_list ap)
2095 {
2096 const char *name;
2097 const struct addrinfo *pai;
2098 struct addrinfo sentinel, *cur;
2099 struct addrinfo *p;
2100 FILE *hostf = NULL;
2101
2102 name = va_arg(ap, char *);
2103 pai = va_arg(ap, struct addrinfo *);
2104
2105 // fprintf(stderr, "_files_getaddrinfo() name = '%s'\n", name);
2106 memset(&sentinel, 0, sizeof(sentinel));
2107 cur = &sentinel;
2108
2109 _sethtent(&hostf);
2110 while ((p = _gethtent(&hostf, name, pai)) != NULL) {
2111 cur->ai_next = p;
2112 while (cur && cur->ai_next)
2113 cur = cur->ai_next;
2114 }
2115 _endhtent(&hostf);
2116
2117 *((struct addrinfo **)rv) = sentinel.ai_next;
2118 if (sentinel.ai_next == NULL)
2119 return NS_NOTFOUND;
2120 return NS_SUCCESS;
2121 }
2122
2123 /* resolver logic */
2124
2125 /*
2126 * Formulate a normal query, send, and await answer.
2127 * Returned answer is placed in supplied buffer "answer".
2128 * Perform preliminary check of answer, returning success only
2129 * if no error is indicated and the answer count is nonzero.
2130 * Return the size of the response on success, -1 on error.
2131 * Error number is left in h_errno.
2132 *
2133 * Caller must parse answer and determine whether it answers the question.
2134 */
2135 static int
res_queryN(const char * name,struct res_target * target,res_state res)2136 res_queryN(const char *name, /* domain name */ struct res_target *target,
2137 res_state res)
2138 {
2139 u_char buf[MAXPACKET];
2140 HEADER *hp;
2141 int n;
2142 struct res_target *t;
2143 int rcode;
2144 int ancount;
2145
2146 assert(name != NULL);
2147 /* XXX: target may be NULL??? */
2148
2149 rcode = NOERROR;
2150 ancount = 0;
2151
2152 for (t = target; t; t = t->next) {
2153 int class, type;
2154 u_char *answer;
2155 int anslen;
2156
2157 hp = (HEADER *)(void *)t->answer;
2158 hp->rcode = NOERROR; /* default */
2159
2160 /* make it easier... */
2161 class = t->qclass;
2162 type = t->qtype;
2163 answer = t->answer;
2164 anslen = t->anslen;
2165 #ifdef DEBUG
2166 if (res->options & RES_DEBUG)
2167 printf(";; res_nquery(%s, %d, %d)\n", name, class, type);
2168 #endif
2169
2170 n = res_nmkquery(res, QUERY, name, class, type, NULL, 0, NULL,
2171 buf, sizeof(buf));
2172 #ifdef RES_USE_EDNS0
2173 if (n > 0 && (res->options & RES_USE_EDNS0) != 0)
2174 n = res_nopt(res, n, buf, sizeof(buf), anslen);
2175 #endif
2176 if (n <= 0) {
2177 #ifdef DEBUG
2178 if (res->options & RES_DEBUG)
2179 printf(";; res_nquery: mkquery failed\n");
2180 #endif
2181 h_errno = NO_RECOVERY;
2182 return n;
2183 }
2184 n = res_nsend(res, buf, n, answer, anslen);
2185 #if 0
2186 if (n < 0) {
2187 #ifdef DEBUG
2188 if (res->options & RES_DEBUG)
2189 printf(";; res_query: send error\n");
2190 #endif
2191 h_errno = TRY_AGAIN;
2192 return n;
2193 }
2194 #endif
2195
2196 if (n < 0 || hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
2197 rcode = hp->rcode; /* record most recent error */
2198 #ifdef DEBUG
2199 if (res->options & RES_DEBUG)
2200 printf(";; rcode = %u, ancount=%u\n", hp->rcode,
2201 ntohs(hp->ancount));
2202 #endif
2203 continue;
2204 }
2205
2206 ancount += ntohs(hp->ancount);
2207
2208 t->n = n;
2209 }
2210
2211 if (ancount == 0) {
2212 switch (rcode) {
2213 case NXDOMAIN:
2214 h_errno = HOST_NOT_FOUND;
2215 break;
2216 case SERVFAIL:
2217 h_errno = TRY_AGAIN;
2218 break;
2219 case NOERROR:
2220 h_errno = NO_DATA;
2221 break;
2222 case FORMERR:
2223 case NOTIMP:
2224 case REFUSED:
2225 default:
2226 h_errno = NO_RECOVERY;
2227 break;
2228 }
2229 return -1;
2230 }
2231 return ancount;
2232 }
2233
2234 /*
2235 * Formulate a normal query, send, and retrieve answer in supplied buffer.
2236 * Return the size of the response on success, -1 on error.
2237 * If enabled, implement search rules until answer or unrecoverable failure
2238 * is detected. Error code, if any, is left in h_errno.
2239 */
2240 static int
res_searchN(const char * name,struct res_target * target,res_state res)2241 res_searchN(const char *name, struct res_target *target, res_state res)
2242 {
2243 const char *cp, * const *domain;
2244 HEADER *hp;
2245 u_int dots;
2246 int trailing_dot, ret, saved_herrno;
2247 int got_nodata = 0, got_servfail = 0, tried_as_is = 0;
2248
2249 assert(name != NULL);
2250 assert(target != NULL);
2251
2252 hp = (HEADER *)(void *)target->answer; /*XXX*/
2253
2254 errno = 0;
2255 h_errno = HOST_NOT_FOUND; /* default, if we never query */
2256 dots = 0;
2257 for (cp = name; *cp; cp++)
2258 dots += (*cp == '.');
2259 trailing_dot = 0;
2260 if (cp > name && *--cp == '.')
2261 trailing_dot++;
2262
2263
2264 //fprintf(stderr, "res_searchN() name = '%s'\n", name);
2265
2266 /*
2267 * if there aren't any dots, it could be a user-level alias
2268 */
2269 if (!dots && (cp = __hostalias(name)) != NULL) {
2270 ret = res_queryN(cp, target, res);
2271 return ret;
2272 }
2273
2274 /*
2275 * If there are dots in the name already, let's just give it a try
2276 * 'as is'. The threshold can be set with the "ndots" option.
2277 */
2278 saved_herrno = -1;
2279 if (dots >= res->ndots) {
2280 ret = res_querydomainN(name, NULL, target, res);
2281 if (ret > 0)
2282 return (ret);
2283 saved_herrno = h_errno;
2284 tried_as_is++;
2285 }
2286
2287 /*
2288 * We do at least one level of search if
2289 * - there is no dot and RES_DEFNAME is set, or
2290 * - there is at least one dot, there is no trailing dot,
2291 * and RES_DNSRCH is set.
2292 */
2293 if ((!dots && (res->options & RES_DEFNAMES)) ||
2294 (dots && !trailing_dot && (res->options & RES_DNSRCH))) {
2295 int done = 0;
2296
2297 for (domain = (const char * const *)res->dnsrch;
2298 *domain && !done;
2299 domain++) {
2300
2301 ret = res_querydomainN(name, *domain, target, res);
2302 if (ret > 0)
2303 return ret;
2304
2305 /*
2306 * If no server present, give up.
2307 * If name isn't found in this domain,
2308 * keep trying higher domains in the search list
2309 * (if that's enabled).
2310 * On a NO_DATA error, keep trying, otherwise
2311 * a wildcard entry of another type could keep us
2312 * from finding this entry higher in the domain.
2313 * If we get some other error (negative answer or
2314 * server failure), then stop searching up,
2315 * but try the input name below in case it's
2316 * fully-qualified.
2317 */
2318 if (errno == ECONNREFUSED) {
2319 h_errno = TRY_AGAIN;
2320 return -1;
2321 }
2322
2323 switch (h_errno) {
2324 case NO_DATA:
2325 got_nodata++;
2326 /* FALLTHROUGH */
2327 case HOST_NOT_FOUND:
2328 /* keep trying */
2329 break;
2330 case TRY_AGAIN:
2331 if (hp->rcode == SERVFAIL) {
2332 /* try next search element, if any */
2333 got_servfail++;
2334 break;
2335 }
2336 /* FALLTHROUGH */
2337 default:
2338 /* anything else implies that we're done */
2339 done++;
2340 }
2341 /*
2342 * if we got here for some reason other than DNSRCH,
2343 * we only wanted one iteration of the loop, so stop.
2344 */
2345 if (!(res->options & RES_DNSRCH))
2346 done++;
2347 }
2348 }
2349
2350 /*
2351 * if we have not already tried the name "as is", do that now.
2352 * note that we do this regardless of how many dots were in the
2353 * name or whether it ends with a dot.
2354 */
2355 if (!tried_as_is) {
2356 ret = res_querydomainN(name, NULL, target, res);
2357 if (ret > 0)
2358 return ret;
2359 }
2360
2361 /*
2362 * if we got here, we didn't satisfy the search.
2363 * if we did an initial full query, return that query's h_errno
2364 * (note that we wouldn't be here if that query had succeeded).
2365 * else if we ever got a nodata, send that back as the reason.
2366 * else send back meaningless h_errno, that being the one from
2367 * the last DNSRCH we did.
2368 */
2369 if (saved_herrno != -1)
2370 h_errno = saved_herrno;
2371 else if (got_nodata)
2372 h_errno = NO_DATA;
2373 else if (got_servfail)
2374 h_errno = TRY_AGAIN;
2375 return -1;
2376 }
2377
2378 /*
2379 * Perform a call on res_query on the concatenation of name and domain,
2380 * removing a trailing dot from name if domain is NULL.
2381 */
2382 static int
res_querydomainN(const char * name,const char * domain,struct res_target * target,res_state res)2383 res_querydomainN(const char *name, const char *domain,
2384 struct res_target *target, res_state res)
2385 {
2386 char nbuf[MAXDNAME];
2387 const char *longname = nbuf;
2388 size_t n, d;
2389
2390 assert(name != NULL);
2391 /* XXX: target may be NULL??? */
2392
2393 #ifdef DEBUG
2394 if (res->options & RES_DEBUG)
2395 printf(";; res_querydomain(%s, %s)\n",
2396 name, domain?domain:"<Nil>");
2397 #endif
2398 if (domain == NULL) {
2399 /*
2400 * Check for trailing '.';
2401 * copy without '.' if present.
2402 */
2403 n = strlen(name);
2404 if (n + 1 > sizeof(nbuf)) {
2405 h_errno = NO_RECOVERY;
2406 return -1;
2407 }
2408 if (n > 0 && name[--n] == '.') {
2409 strncpy(nbuf, name, n);
2410 nbuf[n] = '\0';
2411 } else
2412 longname = name;
2413 } else {
2414 n = strlen(name);
2415 d = strlen(domain);
2416 if (n + 1 + d + 1 > sizeof(nbuf)) {
2417 h_errno = NO_RECOVERY;
2418 return -1;
2419 }
2420 snprintf(nbuf, sizeof(nbuf), "%s.%s", name, domain);
2421 }
2422 return res_queryN(longname, target, res);
2423 }
2424