1 /* $NetBSD: gethnamaddr.c,v 1.91 2014/06/19 15:08:18 christos Exp $ */
2
3 /*
4 * ++Copyright++ 1985, 1988, 1993
5 * -
6 * Copyright (c) 1985, 1988, 1993
7 * The Regents of the University of California. All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 * -
33 * Portions Copyright (c) 1993 by Digital Equipment Corporation.
34 *
35 * Permission to use, copy, modify, and distribute this software for any
36 * purpose with or without fee is hereby granted, provided that the above
37 * copyright notice and this permission notice appear in all copies, and that
38 * the name of Digital Equipment Corporation not be used in advertising or
39 * publicity pertaining to distribution of the document or software without
40 * specific, written prior permission.
41 *
42 * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
43 * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
44 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
45 * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
46 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
47 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
48 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
49 * SOFTWARE.
50 * -
51 * --Copyright--
52 */
53
54 #define LOG_TAG "resolv"
55
56 #include "gethnamaddr.h"
57
58 #include <android-base/logging.h>
59 #include <arpa/inet.h>
60 #include <arpa/nameser.h>
61 #include <assert.h>
62 #include <ctype.h>
63 #include <errno.h>
64 #include <netdb.h>
65 #include <netinet/in.h>
66 #include <stdarg.h>
67 #include <stdbool.h>
68 #include <stdlib.h>
69 #include <string.h>
70 #include <sys/param.h>
71 #include <sys/socket.h>
72 #include <sys/un.h>
73 #include <unistd.h>
74 #include <functional>
75 #include <vector>
76
77 #include "Experiments.h"
78 #include "hostent.h"
79 #include "netd_resolv/resolv.h"
80 #include "res_comp.h"
81 #include "res_debug.h" // p_class(), p_type()
82 #include "resolv_cache.h"
83 #include "resolv_private.h"
84 #include "stats.pb.h"
85
86 using android::net::NetworkDnsEventReported;
87
88 constexpr int MAXADDRS = 35;
89
90 typedef union {
91 HEADER hdr;
92 uint8_t buf[MAXPACKET];
93 } querybuf;
94
95 static void pad_v4v6_hostent(struct hostent* hp, char** bpp, char* ep);
96 static int dns_gethtbyaddr(const unsigned char* uaddr, int len, int af,
97 const android_net_context* netcontext, getnamaddr* info,
98 NetworkDnsEventReported* event);
99 static int dns_gethtbyname(ResState* res, const char* name, int af, getnamaddr* info);
100
101 #define BOUNDED_INCR(x) \
102 do { \
103 BOUNDS_CHECK(cp, x); \
104 cp += (x); \
105 } while (0)
106
107 #define BOUNDS_CHECK(ptr, count) \
108 do { \
109 if (eom - (ptr) < (count)) goto no_recovery; \
110 } while (0)
111
getanswer(const querybuf * _Nonnull answer,int anslen,const char * _Nonnull qname,int qtype,struct hostent * hent,char * buf,size_t buflen,int * he)112 static struct hostent* getanswer(const querybuf* _Nonnull answer, int anslen,
113 const char* _Nonnull qname, int qtype, struct hostent* hent,
114 char* buf, size_t buflen, int* he) {
115 const HEADER* hp;
116 const uint8_t* cp;
117 int n;
118 size_t qlen;
119 const uint8_t *eom, *erdata;
120 char *bp, **hap, *ep;
121 int ancount, qdcount;
122 int haveanswer, had_error;
123 int toobig = 0;
124 char tbuf[MAXDNAME];
125 char* addr_ptrs[MAXADDRS];
126 const char* tname;
127 std::vector<char*> aliases;
128
129 tname = qname;
130 hent->h_name = NULL;
131 eom = answer->buf + anslen;
132
133 bool (*name_ok)(const char* dn);
134 switch (qtype) {
135 case T_A:
136 case T_AAAA:
137 name_ok = res_hnok;
138 break;
139 case T_PTR:
140 name_ok = res_dnok;
141 break;
142 default:
143 *he = NO_RECOVERY;
144 return NULL; /* XXX should be abort(); */
145 }
146
147 /*
148 * find first satisfactory answer
149 */
150 hp = &answer->hdr;
151 ancount = ntohs(hp->ancount);
152 qdcount = ntohs(hp->qdcount);
153 bp = buf;
154 ep = buf + buflen;
155 cp = answer->buf;
156 BOUNDED_INCR(HFIXEDSZ);
157 if (qdcount != 1) goto no_recovery;
158
159 n = dn_expand(answer->buf, eom, cp, bp, (int) (ep - bp));
160 if ((n < 0) || !name_ok(bp)) goto no_recovery;
161
162 BOUNDED_INCR(n + QFIXEDSZ);
163 if (qtype == T_A || qtype == T_AAAA) {
164 /* res_send() has already verified that the query name is the
165 * same as the one we sent; this just gets the expanded name
166 * (i.e., with the succeeding search-domain tacked on).
167 */
168 n = (int) strlen(bp) + 1; /* for the \0 */
169 if (n >= MAXHOSTNAMELEN) goto no_recovery;
170 hent->h_name = bp;
171 bp += n;
172 /* The qname can be abbreviated, but h_name is now absolute. */
173 qname = hent->h_name;
174 }
175 hent->h_addr_list = hap = addr_ptrs;
176 *hap = NULL;
177 haveanswer = 0;
178 had_error = 0;
179 while (ancount-- > 0 && cp < eom && !had_error) {
180 n = dn_expand(answer->buf, eom, cp, bp, (int) (ep - bp));
181 if ((n < 0) || !name_ok(bp)) {
182 had_error++;
183 continue;
184 }
185 cp += n; /* name */
186 BOUNDS_CHECK(cp, 3 * INT16SZ + INT32SZ);
187 int type = ntohs(*reinterpret_cast<const uint16_t*>(cp));
188 cp += INT16SZ; /* type */
189 int cl = ntohs(*reinterpret_cast<const uint16_t*>(cp));
190 cp += INT16SZ + INT32SZ; /* class, TTL */
191 n = ntohs(*reinterpret_cast<const uint16_t*>(cp));
192 cp += INT16SZ; /* len */
193 BOUNDS_CHECK(cp, n);
194 erdata = cp + n;
195 if (cl != C_IN) {
196 /* XXX - debug? syslog? */
197 cp += n;
198 continue; /* XXX - had_error++ ? */
199 }
200 if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) {
201 n = dn_expand(answer->buf, eom, cp, tbuf, (int) sizeof tbuf);
202 if ((n < 0) || !name_ok(tbuf)) {
203 had_error++;
204 continue;
205 }
206 cp += n;
207 if (cp != erdata) goto no_recovery;
208 /* Store alias. */
209 aliases.push_back(bp);
210 n = (int) strlen(bp) + 1; /* for the \0 */
211 if (n >= MAXHOSTNAMELEN) {
212 had_error++;
213 continue;
214 }
215 bp += n;
216 /* Get canonical name. */
217 n = (int) strlen(tbuf) + 1; /* for the \0 */
218 if (n > ep - bp || n >= MAXHOSTNAMELEN) {
219 had_error++;
220 continue;
221 }
222 strlcpy(bp, tbuf, (size_t)(ep - bp));
223 hent->h_name = bp;
224 bp += n;
225 continue;
226 }
227 if (qtype == T_PTR && type == T_CNAME) {
228 n = dn_expand(answer->buf, eom, cp, tbuf, (int) sizeof tbuf);
229 if (n < 0 || !res_dnok(tbuf)) {
230 had_error++;
231 continue;
232 }
233 cp += n;
234 if (cp != erdata) goto no_recovery;
235 /* Get canonical name. */
236 n = (int) strlen(tbuf) + 1; /* for the \0 */
237 if (n > ep - bp || n >= MAXHOSTNAMELEN) {
238 had_error++;
239 continue;
240 }
241 strlcpy(bp, tbuf, (size_t)(ep - bp));
242 tname = bp;
243 bp += n;
244 continue;
245 }
246 if (type != qtype) {
247 if (type != T_KEY && type != T_SIG)
248 LOG(DEBUG) << __func__ << ": asked for \"" << qname << " " << p_class(C_IN) << " "
249 << p_type(qtype) << "\", got type \"" << p_type(type) << "\"";
250 cp += n;
251 continue; /* XXX - had_error++ ? */
252 }
253 switch (type) {
254 case T_PTR:
255 if (strcasecmp(tname, bp) != 0) {
256 LOG(DEBUG) << __func__ << ": asked for \"" << qname << "\", got \"" << bp
257 << "\"";
258 cp += n;
259 continue; /* XXX - had_error++ ? */
260 }
261 n = dn_expand(answer->buf, eom, cp, bp, (int) (ep - bp));
262 if ((n < 0) || !res_hnok(bp)) {
263 had_error++;
264 break;
265 }
266 cp += n;
267 if (cp != erdata) goto no_recovery;
268 if (!haveanswer)
269 hent->h_name = bp;
270 else
271 aliases.push_back(bp);
272 if (n != -1) {
273 n = (int) strlen(bp) + 1; /* for the \0 */
274 if (n >= MAXHOSTNAMELEN) {
275 had_error++;
276 break;
277 }
278 bp += n;
279 }
280 break;
281 case T_A:
282 case T_AAAA:
283 if (strcasecmp(hent->h_name, bp) != 0) {
284 LOG(DEBUG) << __func__ << ": asked for \"" << hent->h_name << "\", got \"" << bp
285 << "\"";
286 cp += n;
287 continue; /* XXX - had_error++ ? */
288 }
289 if (n != hent->h_length) {
290 cp += n;
291 continue;
292 }
293 if (type == T_AAAA) {
294 struct in6_addr in6;
295 memcpy(&in6, cp, NS_IN6ADDRSZ);
296 if (IN6_IS_ADDR_V4MAPPED(&in6)) {
297 cp += n;
298 continue;
299 }
300 }
301 if (!haveanswer) {
302 int nn;
303
304 hent->h_name = bp;
305 nn = (int) strlen(bp) + 1; /* for the \0 */
306 bp += nn;
307 }
308
309 bp = align_ptr<sizeof(int32_t)>(bp);
310
311 if (bp + n >= ep) {
312 LOG(DEBUG) << __func__ << ": size (" << n << ") too big";
313 had_error++;
314 continue;
315 }
316 if (hap >= &addr_ptrs[MAXADDRS - 1]) {
317 if (!toobig++) {
318 LOG(DEBUG) << __func__ << ": Too many addresses (" << MAXADDRS << ")";
319 }
320 cp += n;
321 continue;
322 }
323 (void) memcpy(*hap++ = bp, cp, (size_t) n);
324 bp += n;
325 cp += n;
326 if (cp != erdata) goto no_recovery;
327 break;
328 default:
329 abort();
330 }
331 if (!had_error) haveanswer++;
332 }
333 if (haveanswer) {
334 *hap = NULL;
335 if (!hent->h_name) {
336 n = (int) strlen(qname) + 1; /* for the \0 */
337 if (n > ep - bp || n >= MAXHOSTNAMELEN) goto no_recovery;
338 strlcpy(bp, qname, (size_t)(ep - bp));
339 hent->h_name = bp;
340 bp += n;
341 }
342 if (hent->h_addrtype == AF_INET) pad_v4v6_hostent(hent, &bp, ep);
343 goto success;
344 }
345 no_recovery:
346 *he = NO_RECOVERY;
347 return NULL;
348 success:
349 bp = align_ptr(bp);
350 aliases.push_back(nullptr);
351 qlen = aliases.size() * sizeof(*hent->h_aliases);
352 if ((size_t)(ep - bp) < qlen) goto nospc;
353 hent->h_aliases = (char**) bp;
354 memcpy(bp, aliases.data(), qlen);
355
356 bp += qlen;
357 n = (int) (hap - addr_ptrs);
358 qlen = (n + 1) * sizeof(*hent->h_addr_list);
359 if ((size_t)(ep - bp) < qlen) goto nospc;
360 hent->h_addr_list = (char**) bp;
361 memcpy(bp, addr_ptrs, qlen);
362 *he = NETDB_SUCCESS;
363 return hent;
364 nospc:
365 errno = ENOSPC;
366 *he = NETDB_INTERNAL;
367 return NULL;
368 }
369
resolv_gethostbyname(const char * name,int af,hostent * hp,char * buf,size_t buflen,const android_net_context * netcontext,hostent ** result,NetworkDnsEventReported * event)370 int resolv_gethostbyname(const char* name, int af, hostent* hp, char* buf, size_t buflen,
371 const android_net_context* netcontext, hostent** result,
372 NetworkDnsEventReported* event) {
373 if (name == nullptr || hp == nullptr) {
374 return EAI_SYSTEM;
375 }
376
377 getnamaddr info;
378 ResState res(netcontext, event);
379
380 setMdnsFlag(name, res.netid, &(res.flags));
381
382 size_t size;
383 switch (af) {
384 case AF_INET:
385 size = NS_INADDRSZ;
386 break;
387 case AF_INET6:
388 size = NS_IN6ADDRSZ;
389 break;
390 default:
391 return EAI_FAMILY;
392 }
393 if (buflen < size) goto nospc;
394
395 hp->h_addrtype = af;
396 hp->h_length = (int) size;
397
398 /*
399 * disallow names consisting only of digits/dots, unless
400 * they end in a dot.
401 */
402 if (isdigit((uint8_t)name[0])) {
403 for (const char* cp = name;; ++cp) {
404 if (!*cp) {
405 if (*--cp == '.') break;
406 /*
407 * All-numeric, no dot at the end.
408 * Fake up a hostent as if we'd actually
409 * done a lookup.
410 */
411 goto fake;
412 }
413 if (!isdigit((uint8_t)*cp) && *cp != '.') break;
414 }
415 }
416 if ((isxdigit((uint8_t)name[0]) && strchr(name, ':') != NULL) || name[0] == ':') {
417 for (const char* cp = name;; ++cp) {
418 if (!*cp) {
419 if (*--cp == '.') break;
420 /*
421 * All-IPv6-legal, no dot at the end.
422 * Fake up a hostent as if we'd actually
423 * done a lookup.
424 */
425 goto fake;
426 }
427 if (!isxdigit((uint8_t)*cp) && *cp != ':' && *cp != '.') break;
428 }
429 }
430
431 info.hp = hp;
432 info.buf = buf;
433 info.buflen = buflen;
434 if (_hf_gethtbyname2(name, af, &info)) {
435 int error = dns_gethtbyname(&res, name, af, &info);
436 if (error != 0) return error;
437 }
438 *result = hp;
439 return 0;
440 nospc:
441 return EAI_MEMORY;
442 fake:
443 HENT_ARRAY(hp->h_addr_list, 1, buf, buflen);
444 HENT_ARRAY(hp->h_aliases, 0, buf, buflen);
445
446 hp->h_aliases[0] = NULL;
447 if (size > buflen) goto nospc;
448
449 if (inet_pton(af, name, buf) <= 0) {
450 return EAI_NODATA;
451 }
452 hp->h_addr_list[0] = buf;
453 hp->h_addr_list[1] = NULL;
454 buf += size;
455 buflen -= size;
456 HENT_SCOPY(hp->h_name, name, buf, buflen);
457 *result = hp;
458 return 0;
459 }
460
resolv_gethostbyaddr(const void * _Nonnull addr,socklen_t len,int af,hostent * hp,char * buf,size_t buflen,const struct android_net_context * netcontext,hostent ** result,NetworkDnsEventReported * event)461 int resolv_gethostbyaddr(const void* _Nonnull addr, socklen_t len, int af, hostent* hp, char* buf,
462 size_t buflen, const struct android_net_context* netcontext,
463 hostent** result, NetworkDnsEventReported* event) {
464 const uint8_t* uaddr = (const uint8_t*)addr;
465 socklen_t size;
466 struct getnamaddr info;
467
468 if (af == AF_INET6 && len == NS_IN6ADDRSZ &&
469 (IN6_IS_ADDR_LINKLOCAL((const struct in6_addr*) addr) ||
470 IN6_IS_ADDR_SITELOCAL((const struct in6_addr*) addr))) {
471 return EAI_NODATA;
472 }
473 if (af == AF_INET6 && len == NS_IN6ADDRSZ &&
474 (IN6_IS_ADDR_V4MAPPED((const struct in6_addr*) addr) ||
475 IN6_IS_ADDR_V4COMPAT((const struct in6_addr*) addr))) {
476 /* Unmap. */
477 uaddr += NS_IN6ADDRSZ - NS_INADDRSZ;
478 addr = uaddr;
479 af = AF_INET;
480 len = NS_INADDRSZ;
481 }
482 switch (af) {
483 case AF_INET:
484 size = NS_INADDRSZ;
485 break;
486 case AF_INET6:
487 size = NS_IN6ADDRSZ;
488 break;
489 default:
490 return EAI_FAMILY;
491 }
492 if (size != len) {
493 // TODO: Consider converting to a private extended EAI_* error code.
494 // Currently, the EAI_* value has no corresponding error code for invalid argument socket
495 // length. In order to not rely on errno, convert the original error code pair, EAI_SYSTEM
496 // and EINVAL, to EAI_FAIL.
497 return EAI_FAIL;
498 }
499 info.hp = hp;
500 info.buf = buf;
501 info.buflen = buflen;
502 if (_hf_gethtbyaddr(uaddr, len, af, &info)) {
503 int error = dns_gethtbyaddr(uaddr, len, af, netcontext, &info, event);
504 if (error != 0) return error;
505 }
506 *result = hp;
507 return 0;
508 }
509
510 // TODO: Consider leaving function without returning error code as _gethtent() does because
511 // the error code of the caller does not currently return to netd.
netbsd_gethostent_r(FILE * hf,struct hostent * hent,char * buf,size_t buflen,int * he)512 struct hostent* netbsd_gethostent_r(FILE* hf, struct hostent* hent, char* buf, size_t buflen,
513 int* he) {
514 char *name;
515 char* cp;
516 int af, len;
517 size_t anum;
518 struct in6_addr host_addr;
519 std::vector<char*> aliases;
520
521 if (hf == NULL) {
522 *he = NETDB_INTERNAL;
523 errno = EINVAL;
524 return NULL;
525 }
526 char* p = NULL;
527
528 // Allocate a new space to read file lines like upstream does.
529 const size_t line_buf_size = MAXPACKET;
530 if ((p = (char*) malloc(line_buf_size)) == NULL) {
531 goto nospc;
532 }
533 for (;;) {
534 if (!fgets(p, line_buf_size, hf)) {
535 free(p);
536 *he = HOST_NOT_FOUND;
537 return NULL;
538 }
539 if (*p == '#') {
540 continue;
541 }
542 if (!(cp = strpbrk(p, "#\n"))) {
543 continue;
544 }
545 *cp = '\0';
546 if (!(cp = strpbrk(p, " \t"))) continue;
547 *cp++ = '\0';
548 if (inet_pton(AF_INET6, p, &host_addr) > 0) {
549 af = AF_INET6;
550 len = NS_IN6ADDRSZ;
551 } else {
552 if (inet_pton(AF_INET, p, &host_addr) <= 0) continue;
553 af = AF_INET;
554 len = NS_INADDRSZ;
555 }
556
557 /* if this is not something we're looking for, skip it. */
558 if (hent->h_addrtype != 0 && hent->h_addrtype != af) continue;
559 if (hent->h_length != 0 && hent->h_length != len) continue;
560
561 while (*cp == ' ' || *cp == '\t') cp++;
562 if ((cp = strpbrk(name = cp, " \t")) != NULL) *cp++ = '\0';
563 while (cp && *cp) {
564 if (*cp == ' ' || *cp == '\t') {
565 cp++;
566 continue;
567 }
568 aliases.push_back(cp);
569 if ((cp = strpbrk(cp, " \t")) != NULL) *cp++ = '\0';
570 }
571 break;
572 }
573 hent->h_length = len;
574 hent->h_addrtype = af;
575 HENT_ARRAY(hent->h_addr_list, 1, buf, buflen);
576 anum = aliases.size();
577 HENT_ARRAY(hent->h_aliases, anum, buf, buflen);
578 HENT_COPY(hent->h_addr_list[0], &host_addr, hent->h_length, buf, buflen);
579 hent->h_addr_list[1] = NULL;
580
581 /* Reserve space for mapping IPv4 address to IPv6 address in place */
582 if (hent->h_addrtype == AF_INET) {
583 HENT_COPY(buf, NAT64_PAD, sizeof(NAT64_PAD), buf, buflen);
584 }
585
586 HENT_SCOPY(hent->h_name, name, buf, buflen);
587 for (size_t i = 0; i < anum; i++) HENT_SCOPY(hent->h_aliases[i], aliases[i], buf, buflen);
588 hent->h_aliases[anum] = NULL;
589 *he = NETDB_SUCCESS;
590 free(p);
591 return hent;
592 nospc:
593 free(p);
594 errno = ENOSPC;
595 *he = NETDB_INTERNAL;
596 return NULL;
597 }
598
599 /* Reserve space for mapping IPv4 address to IPv6 address in place */
pad_v4v6_hostent(struct hostent * _Nonnull hp,char ** _Nonnull bpp,char * _Nonnull ep)600 static void pad_v4v6_hostent(struct hostent* _Nonnull hp, char** _Nonnull bpp, char* _Nonnull ep) {
601 if (hp->h_addrtype != AF_INET || hp->h_length != NS_INADDRSZ) return;
602 for (char** ap = hp->h_addr_list; *ap; ap++) {
603 char* const bp = align_ptr<sizeof(int32_t)>(*bpp);
604
605 if (ep - bp < NS_IN6ADDRSZ) {
606 // Out of space. Truncate address list here.
607 *ap = nullptr;
608 return;
609 }
610 memcpy(bp, *ap, NS_INADDRSZ);
611 memcpy(bp + NS_INADDRSZ, NAT64_PAD, sizeof(NAT64_PAD));
612 *ap = bp;
613 *bpp = bp + NS_IN6ADDRSZ;
614 }
615 }
616
dns_gethtbyname(ResState * res,const char * name,int addr_type,getnamaddr * info)617 static int dns_gethtbyname(ResState* res, const char* name, int addr_type, getnamaddr* info) {
618 int n, type;
619 info->hp->h_addrtype = addr_type;
620
621 switch (info->hp->h_addrtype) {
622 case AF_INET:
623 info->hp->h_length = NS_INADDRSZ;
624 type = T_A;
625 break;
626 case AF_INET6:
627 info->hp->h_length = NS_IN6ADDRSZ;
628 type = T_AAAA;
629 break;
630 default:
631 return EAI_FAMILY;
632 }
633 auto buf = std::make_unique<querybuf>();
634
635 int he;
636 n = res_nsearch(res, name, C_IN, type, {buf->buf, (int)sizeof(buf->buf)}, &he);
637 if (n < 0) {
638 LOG(DEBUG) << __func__ << ": res_nsearch failed (" << n << ")";
639 // Return h_errno (he) to catch more detailed errors rather than EAI_NODATA.
640 // Note that res_nsearch() doesn't set the pair NETDB_INTERNAL and errno.
641 // See also herrnoToAiErrno().
642 return herrnoToAiErrno(he);
643 }
644 hostent* hp = getanswer(buf.get(), n, name, type, info->hp, info->buf, info->buflen, &he);
645 if (hp == NULL) return herrnoToAiErrno(he);
646
647 return 0;
648 }
649
dns_gethtbyaddr(const unsigned char * uaddr,int len,int af,const android_net_context * netcontext,getnamaddr * info,NetworkDnsEventReported * event)650 static int dns_gethtbyaddr(const unsigned char* uaddr, int len, int af,
651 const android_net_context* netcontext, getnamaddr* info,
652 NetworkDnsEventReported* event) {
653 char qbuf[MAXDNAME + 1], *qp, *ep;
654 int n;
655 int advance;
656
657 info->hp->h_length = len;
658 info->hp->h_addrtype = af;
659
660 switch (info->hp->h_addrtype) {
661 case AF_INET:
662 (void) snprintf(qbuf, sizeof(qbuf), "%u.%u.%u.%u.in-addr.arpa", (uaddr[3] & 0xff),
663 (uaddr[2] & 0xff), (uaddr[1] & 0xff), (uaddr[0] & 0xff));
664 break;
665
666 case AF_INET6:
667 qp = qbuf;
668 ep = qbuf + sizeof(qbuf) - 1;
669 for (n = NS_IN6ADDRSZ - 1; n >= 0; n--) {
670 advance = snprintf(qp, (size_t)(ep - qp), "%x.%x.", uaddr[n] & 0xf,
671 ((unsigned int) uaddr[n] >> 4) & 0xf);
672 if (advance > 0 && qp + advance < ep)
673 qp += advance;
674 else {
675 // TODO: Consider converting to a private extended EAI_* error code.
676 // Currently, the EAI_* value has no corresponding error code for an internal
677 // out of buffer space. In order to not rely on errno, convert the original
678 // error code EAI_SYSTEM to EAI_MEMORY.
679 return EAI_MEMORY;
680 }
681 }
682 if (strlcat(qbuf, "ip6.arpa", sizeof(qbuf)) >= sizeof(qbuf)) {
683 // TODO: Consider converting to a private extended EAI_* error code.
684 // Currently, the EAI_* value has no corresponding error code for an internal
685 // out of buffer space. In order to not rely on errno, convert the original
686 // error code EAI_SYSTEM to EAI_MEMORY.
687 return EAI_MEMORY;
688 }
689 break;
690 default:
691 return EAI_FAMILY;
692 }
693
694 auto buf = std::make_unique<querybuf>();
695
696 ResState res(netcontext, event);
697 int he;
698 n = res_nquery(&res, qbuf, C_IN, T_PTR, {buf->buf, (int)sizeof(buf->buf)}, &he);
699 if (n < 0) {
700 LOG(DEBUG) << __func__ << ": res_nquery failed (" << n << ")";
701 // Note that res_nquery() doesn't set the pair NETDB_INTERNAL and errno.
702 // Return h_errno (he) to catch more detailed errors rather than EAI_NODATA.
703 // See also herrnoToAiErrno().
704 return herrnoToAiErrno(he);
705 }
706 hostent* hp = getanswer(buf.get(), n, qbuf, T_PTR, info->hp, info->buf, info->buflen, &he);
707 if (hp == NULL) return herrnoToAiErrno(he);
708
709 char* bf = (char*) (hp->h_addr_list + 2);
710 size_t blen = (size_t)(bf - info->buf);
711 if (blen + info->hp->h_length > info->buflen) goto nospc;
712 hp->h_addr_list[0] = bf;
713 hp->h_addr_list[1] = NULL;
714 memcpy(bf, uaddr, (size_t) info->hp->h_length);
715
716 /* Reserve enough space for mapping IPv4 address to IPv6 address in place */
717 if (info->hp->h_addrtype == AF_INET) {
718 if (blen + NS_IN6ADDRSZ > info->buflen) goto nospc;
719 // Pad zero to the unused address space
720 memcpy(bf + NS_INADDRSZ, NAT64_PAD, sizeof(NAT64_PAD));
721 }
722
723 return 0;
724
725 nospc:
726 return EAI_MEMORY;
727 }
728
herrnoToAiErrno(int he)729 int herrnoToAiErrno(int he) {
730 switch (he) {
731 // extended h_errno
732 case NETD_RESOLV_H_ERRNO_EXT_TIMEOUT:
733 return NETD_RESOLV_TIMEOUT;
734 // legacy h_errno
735 case NETDB_SUCCESS:
736 return 0;
737 case HOST_NOT_FOUND: // TODO: Perhaps convert HOST_NOT_FOUND to EAI_NONAME instead
738 case NO_DATA: // NO_ADDRESS
739 return EAI_NODATA;
740 case TRY_AGAIN:
741 return EAI_AGAIN;
742 case NETDB_INTERNAL:
743 // TODO: Remove ENOSPC and call abort() immediately whenever any allocation fails.
744 if (errno == ENOSPC) return EAI_MEMORY;
745 // Theoretically, this should not happen. Leave this here just in case.
746 // Currently, getanswer() of {gethnamaddr, getaddrinfo}.cpp, res_nsearch() and
747 // res_searchN() use this function to convert error code. Only getanswer()
748 // of gethnamaddr.cpp may return the error code pair, herrno NETDB_INTERNAL and
749 // errno ENOSPC, which has already converted to EAI_MEMORY. The remaining functions
750 // don't set the pair herrno and errno.
751 return EAI_SYSTEM; // see errno for detail
752 case NO_RECOVERY:
753 default:
754 return EAI_FAIL; // TODO: Perhaps convert default to EAI_MAX (unknown error) instead
755 }
756 }
757
setMdnsFlag(std::string_view hostname,unsigned netid,uint32_t * flags)758 void setMdnsFlag(std::string_view hostname, unsigned netid, uint32_t* flags) {
759 if (hostname.ends_with(".local") && is_mdns_supported_network(netid) &&
760 android::net::Experiments::getInstance()->getFlag("mdns_resolution", 1))
761 *flags |= RES_F_MDNS;
762 }
763
isMdnsResolution(uint32_t flags)764 bool isMdnsResolution(uint32_t flags) {
765 return flags & RES_F_MDNS;
766 }
767