Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 1 | /* $NetBSD: res_query.c,v 1.7 2006/01/24 17:41:25 christos Exp $ */ |
| 2 | |
| 3 | /* |
| 4 | * Copyright (c) 1988, 1993 |
| 5 | * The Regents of the University of California. All rights reserved. |
| 6 | * |
| 7 | * Redistribution and use in source and binary forms, with or without |
| 8 | * modification, are permitted provided that the following conditions |
| 9 | * are met: |
| 10 | * 1. Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * 2. Redistributions in binary form must reproduce the above copyright |
| 13 | * notice, this list of conditions and the following disclaimer in the |
| 14 | * documentation and/or other materials provided with the distribution. |
| 15 | * 3. All advertising materials mentioning features or use of this software |
| 16 | * must display the following acknowledgement: |
| 17 | * This product includes software developed by the University of |
| 18 | * California, Berkeley and its contributors. |
| 19 | * 4. Neither the name of the University nor the names of its contributors |
| 20 | * may be used to endorse or promote products derived from this software |
| 21 | * without specific prior written permission. |
| 22 | * |
| 23 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| 24 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 25 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 26 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 27 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 28 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 29 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 30 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 31 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 32 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 33 | * SUCH DAMAGE. |
| 34 | */ |
| 35 | |
| 36 | /* |
| 37 | * Portions Copyright (c) 1993 by Digital Equipment Corporation. |
| 38 | * |
| 39 | * Permission to use, copy, modify, and distribute this software for any |
| 40 | * purpose with or without fee is hereby granted, provided that the above |
| 41 | * copyright notice and this permission notice appear in all copies, and that |
| 42 | * the name of Digital Equipment Corporation not be used in advertising or |
| 43 | * publicity pertaining to distribution of the document or software without |
| 44 | * specific, written prior permission. |
| 45 | * |
| 46 | * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL |
| 47 | * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES |
| 48 | * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT |
| 49 | * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| 50 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| 51 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS |
| 52 | * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
| 53 | * SOFTWARE. |
| 54 | */ |
| 55 | |
| 56 | /* |
| 57 | * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC") |
| 58 | * Portions Copyright (c) 1996-1999 by Internet Software Consortium. |
| 59 | * |
| 60 | * Permission to use, copy, modify, and distribute this software for any |
| 61 | * purpose with or without fee is hereby granted, provided that the above |
| 62 | * copyright notice and this permission notice appear in all copies. |
| 63 | * |
| 64 | * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES |
| 65 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| 66 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR |
| 67 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 68 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| 69 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| 70 | * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| 71 | */ |
| 72 | |
Ken Chen | 5471dca | 2019-04-15 15:25:35 +0800 | [diff] [blame] | 73 | #define LOG_TAG "resolv" |
Bernie Innocenti | 3952ccc | 2019-03-03 19:39:53 +0900 | [diff] [blame] | 74 | |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 75 | #include <arpa/inet.h> |
| 76 | #include <arpa/nameser.h> |
| 77 | #include <ctype.h> |
| 78 | #include <errno.h> |
| 79 | #include <netdb.h> |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 80 | #include <netinet/in.h> |
| 81 | #include <sys/param.h> |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 82 | #include <stdlib.h> |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 83 | #include <string.h> |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 84 | #include <unistd.h> |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 85 | |
chenbruce | acb832c | 2019-02-20 19:45:50 +0800 | [diff] [blame] | 86 | #include <android-base/logging.h> |
| 87 | |
Mike Yu | 34433c6 | 2019-08-20 20:17:36 +0800 | [diff] [blame] | 88 | #include "res_debug.h" |
Bernie Innocenti | ac18b12 | 2018-10-01 23:10:18 +0900 | [diff] [blame] | 89 | #include "resolv_cache.h" |
| 90 | #include "resolv_private.h" |
| 91 | |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 92 | /* |
| 93 | * Formulate a normal query, send, and await answer. |
| 94 | * Returned answer is placed in supplied buffer "answer". |
| 95 | * Perform preliminary check of answer, returning success only |
| 96 | * if no error is indicated and the answer count is nonzero. |
| 97 | * Return the size of the response on success, -1 on error. |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 98 | * Error number is left in *herrno. |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 99 | * |
| 100 | * Caller must parse answer and determine whether it answers the question. |
| 101 | */ |
Mike Yu | bfb1b34 | 2018-11-06 15:42:36 +0800 | [diff] [blame] | 102 | int res_nquery(res_state statp, const char* name, // domain name |
| 103 | int cl, int type, // class and type of query |
chenbruce | c51f121 | 2019-09-12 16:59:33 +0800 | [diff] [blame] | 104 | uint8_t* answer, // buffer to put answer |
Mike Yu | bfb1b34 | 2018-11-06 15:42:36 +0800 | [diff] [blame] | 105 | int anslen, // size of answer buffer |
Hungming Chen | 947aab0 | 2018-12-27 18:33:19 +0800 | [diff] [blame] | 106 | int* herrno) // legacy and extended h_errno |
| 107 | // NETD_RESOLV_H_ERRNO_EXT_* |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 108 | { |
chenbruce | c51f121 | 2019-09-12 16:59:33 +0800 | [diff] [blame] | 109 | uint8_t buf[MAXPACKET]; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 110 | HEADER* hp = (HEADER*) (void*) answer; |
| 111 | int n; |
Mike Yu | bfb1b34 | 2018-11-06 15:42:36 +0800 | [diff] [blame] | 112 | int rcode = NOERROR; |
Ken Chen | 0a01553 | 2019-01-02 14:59:38 +0800 | [diff] [blame] | 113 | bool retried = false; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 114 | |
| 115 | again: |
chenbruce | d8cbb9b | 2019-06-20 18:25:28 +0800 | [diff] [blame] | 116 | hp->rcode = NOERROR; // default |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 117 | |
Ken Chen | ffc224a | 2019-03-19 17:41:28 +0800 | [diff] [blame] | 118 | LOG(DEBUG) << __func__ << ": (" << cl << ", " << type << ")"; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 119 | |
Bernie Innocenti | 0848711 | 2019-10-11 21:14:13 +0900 | [diff] [blame] | 120 | n = res_nmkquery(QUERY, name, cl, type, /*data=*/nullptr, 0, buf, sizeof(buf), |
| 121 | statp->netcontext_flags); |
chenbruce | d8cbb9b | 2019-06-20 18:25:28 +0800 | [diff] [blame] | 122 | if (n > 0 && |
| 123 | (statp->netcontext_flags & |
| 124 | (NET_CONTEXT_FLAG_USE_DNS_OVER_TLS | NET_CONTEXT_FLAG_USE_EDNS)) && |
| 125 | !retried) |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 126 | n = res_nopt(statp, n, buf, sizeof(buf), anslen); |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 127 | if (n <= 0) { |
Ken Chen | ffc224a | 2019-03-19 17:41:28 +0800 | [diff] [blame] | 128 | LOG(DEBUG) << __func__ << ": mkquery failed"; |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 129 | *herrno = NO_RECOVERY; |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 130 | return n; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 131 | } |
Luke Huang | ba7bef9 | 2018-12-26 16:53:03 +0800 | [diff] [blame] | 132 | n = res_nsend(statp, buf, n, answer, anslen, &rcode, 0); |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 133 | if (n < 0) { |
chenbruce | d8cbb9b | 2019-06-20 18:25:28 +0800 | [diff] [blame] | 134 | // If the query choked with EDNS0, retry without EDNS0 that when the server |
| 135 | // has no response, resovler won't retry and do nothing. Even fallback to UDP, |
| 136 | // we also has the same symptom if EDNS is enabled. |
| 137 | if ((statp->netcontext_flags & |
| 138 | (NET_CONTEXT_FLAG_USE_DNS_OVER_TLS | NET_CONTEXT_FLAG_USE_EDNS)) && |
Ken Chen | 0a01553 | 2019-01-02 14:59:38 +0800 | [diff] [blame] | 139 | (statp->_flags & RES_F_EDNS0ERR) && !retried) { |
Ken Chen | ffc224a | 2019-03-19 17:41:28 +0800 | [diff] [blame] | 140 | LOG(DEBUG) << __func__ << ": retry without EDNS0"; |
Ken Chen | 0a01553 | 2019-01-02 14:59:38 +0800 | [diff] [blame] | 141 | retried = true; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 142 | goto again; |
| 143 | } |
Ken Chen | ffc224a | 2019-03-19 17:41:28 +0800 | [diff] [blame] | 144 | LOG(DEBUG) << __func__ << ": send error"; |
chenbruce | acb832c | 2019-02-20 19:45:50 +0800 | [diff] [blame] | 145 | |
Hungming Chen | 947aab0 | 2018-12-27 18:33:19 +0800 | [diff] [blame] | 146 | // Note that rcodes SERVFAIL, NOTIMP, REFUSED may cause res_nquery() to return a general |
| 147 | // error code EAI_AGAIN, but mapping the error code from rcode as res_queryN() does for |
| 148 | // getaddrinfo(). Different rcodes trigger different behaviors: |
| 149 | // |
| 150 | // - SERVFAIL, NOTIMP, REFUSED |
| 151 | // These result in send_dg() returning 0, causing res_nsend() to try the next |
| 152 | // nameserver. After all nameservers failed, res_nsend() returns -ETIMEDOUT, causing |
| 153 | // res_nquery() to return EAI_AGAIN here regardless of the rcode from the DNS response. |
| 154 | // |
| 155 | // - NXDOMAIN, FORMERR |
| 156 | // These rcodes may cause res_nsend() to return successfully (i.e. the result is a |
| 157 | // positive integer). In this case, res_nquery() returns error number by referring |
| 158 | // the rcode from the DNS response. |
| 159 | switch (rcode) { |
| 160 | case RCODE_TIMEOUT: // Not defined in RFC. |
| 161 | // DNS metrics monitors DNS query timeout. |
| 162 | *herrno = NETD_RESOLV_H_ERRNO_EXT_TIMEOUT; // extended h_errno. |
| 163 | break; |
| 164 | default: |
| 165 | *herrno = TRY_AGAIN; |
| 166 | break; |
| 167 | } |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 168 | return n; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 169 | } |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 170 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 171 | if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) { |
Ken Chen | ffc224a | 2019-03-19 17:41:28 +0800 | [diff] [blame] | 172 | LOG(DEBUG) << __func__ << ": rcode = (" << p_rcode(hp->rcode) |
chenbruce | acb832c | 2019-02-20 19:45:50 +0800 | [diff] [blame] | 173 | << "), counts = an:" << ntohs(hp->ancount) << " ns:" << ntohs(hp->nscount) |
| 174 | << " ar:" << ntohs(hp->arcount); |
| 175 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 176 | switch (hp->rcode) { |
| 177 | case NXDOMAIN: |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 178 | *herrno = HOST_NOT_FOUND; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 179 | break; |
| 180 | case SERVFAIL: |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 181 | *herrno = TRY_AGAIN; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 182 | break; |
| 183 | case NOERROR: |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 184 | *herrno = NO_DATA; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 185 | break; |
| 186 | case FORMERR: |
| 187 | case NOTIMP: |
| 188 | case REFUSED: |
| 189 | default: |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 190 | *herrno = NO_RECOVERY; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 191 | break; |
| 192 | } |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 193 | return -1; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 194 | } |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 195 | return n; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | /* |
| 199 | * Formulate a normal query, send, and retrieve answer in supplied buffer. |
| 200 | * Return the size of the response on success, -1 on error. |
| 201 | * If enabled, implement search rules until answer or unrecoverable failure |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 202 | * is detected. Error code, if any, is left in *herrno. |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 203 | */ |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 204 | int res_nsearch(res_state statp, const char* name, /* domain name */ |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 205 | int cl, int type, /* class and type of query */ |
chenbruce | c51f121 | 2019-09-12 16:59:33 +0800 | [diff] [blame] | 206 | uint8_t* answer, /* buffer to put answer */ |
Mike Yu | bfb1b34 | 2018-11-06 15:42:36 +0800 | [diff] [blame] | 207 | int anslen, /* size of answer */ |
Hungming Chen | 947aab0 | 2018-12-27 18:33:19 +0800 | [diff] [blame] | 208 | int* herrno) /* legacy and extended |
| 209 | h_errno NETD_RESOLV_H_ERRNO_EXT_* */ |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 210 | { |
Luke Huang | 2dac438 | 2019-06-24 13:28:44 +0800 | [diff] [blame] | 211 | const char* cp; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 212 | HEADER* hp = (HEADER*) (void*) answer; |
chenbruce | c51f121 | 2019-09-12 16:59:33 +0800 | [diff] [blame] | 213 | uint32_t dots; |
chenbruce | 018fdb2 | 2019-06-12 18:08:04 +0800 | [diff] [blame] | 214 | int ret, saved_herrno; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 215 | int got_nodata = 0, got_servfail = 0, root_on_list = 0; |
| 216 | int tried_as_is = 0; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 217 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 218 | errno = 0; |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 219 | *herrno = HOST_NOT_FOUND; /* True if we never query. */ |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 220 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 221 | dots = 0; |
| 222 | for (cp = name; *cp != '\0'; cp++) dots += (*cp == '.'); |
chenbruce | 018fdb2 | 2019-06-12 18:08:04 +0800 | [diff] [blame] | 223 | const bool trailing_dot = (cp > name && *--cp == '.') ? true : false; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 224 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 225 | /* |
| 226 | * If there are enough dots in the name, let's just give it a |
| 227 | * try 'as is'. The threshold can be set with the "ndots" option. |
| 228 | * Also, query 'as is', if there is a trailing dot in the name. |
| 229 | */ |
| 230 | saved_herrno = -1; |
| 231 | if (dots >= statp->ndots || trailing_dot) { |
Hungming Chen | 947aab0 | 2018-12-27 18:33:19 +0800 | [diff] [blame] | 232 | ret = res_nquerydomain(statp, name, NULL, cl, type, answer, anslen, herrno); |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 233 | if (ret > 0 || trailing_dot) return ret; |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 234 | saved_herrno = *herrno; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 235 | tried_as_is++; |
| 236 | } |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 237 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 238 | /* |
| 239 | * We do at least one level of search if |
chenbruce | 018fdb2 | 2019-06-12 18:08:04 +0800 | [diff] [blame] | 240 | * - there is no dot, or |
| 241 | * - there is at least one dot and there is no trailing dot. |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 242 | */ |
chenbruce | 018fdb2 | 2019-06-12 18:08:04 +0800 | [diff] [blame] | 243 | if ((!dots) || (dots && !trailing_dot)) { |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 244 | int done = 0; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 245 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 246 | /* Unfortunately we need to load network-specific info |
| 247 | * (dns servers, search domains) before |
| 248 | * the domain stuff is tried. Will have a better |
| 249 | * fix after thread pools are used as this will |
| 250 | * be loaded once for the thread instead of each |
| 251 | * time a query is tried. |
| 252 | */ |
Mike Yu | 021c3e1 | 2019-10-08 17:29:34 +0800 | [diff] [blame] | 253 | resolv_populate_res_for_net(statp); |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 254 | |
Luke Huang | 2dac438 | 2019-06-24 13:28:44 +0800 | [diff] [blame] | 255 | for (const auto& domain : statp->search_domains) { |
| 256 | if (domain == "." || domain == "") ++root_on_list; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 257 | |
Luke Huang | 2dac438 | 2019-06-24 13:28:44 +0800 | [diff] [blame] | 258 | ret = res_nquerydomain(statp, name, domain.c_str(), cl, type, answer, anslen, herrno); |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 259 | if (ret > 0) return ret; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 260 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 261 | /* |
| 262 | * If no server present, give up. |
| 263 | * If name isn't found in this domain, |
| 264 | * keep trying higher domains in the search list |
| 265 | * (if that's enabled). |
| 266 | * On a NO_DATA error, keep trying, otherwise |
| 267 | * a wildcard entry of another type could keep us |
| 268 | * from finding this entry higher in the domain. |
| 269 | * If we get some other error (negative answer or |
| 270 | * server failure), then stop searching up, |
| 271 | * but try the input name below in case it's |
| 272 | * fully-qualified. |
| 273 | */ |
| 274 | if (errno == ECONNREFUSED) { |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 275 | *herrno = TRY_AGAIN; |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 276 | return -1; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 277 | } |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 278 | |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 279 | switch (*herrno) { |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 280 | case NO_DATA: |
| 281 | got_nodata++; |
Bernie Innocenti | 3a4002e | 2018-10-12 21:27:45 +0900 | [diff] [blame] | 282 | break; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 283 | case HOST_NOT_FOUND: |
| 284 | /* keep trying */ |
| 285 | break; |
| 286 | case TRY_AGAIN: |
| 287 | if (hp->rcode == SERVFAIL) { |
| 288 | /* try next search element, if any */ |
| 289 | got_servfail++; |
| 290 | break; |
| 291 | } |
Bernie Innocenti | f40b3bd | 2018-10-10 22:30:12 +0900 | [diff] [blame] | 292 | [[fallthrough]]; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 293 | default: |
| 294 | /* anything else implies that we're done */ |
| 295 | done++; |
| 296 | } |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 297 | } |
| 298 | } |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 299 | |
chenbruce | 018fdb2 | 2019-06-12 18:08:04 +0800 | [diff] [blame] | 300 | // if we have not already tried the name "as is", do that now. |
| 301 | // note that we do this regardless of how many dots were in the |
| 302 | // name or whether it ends with a dot. |
| 303 | if (!tried_as_is && !root_on_list) { |
Hungming Chen | 947aab0 | 2018-12-27 18:33:19 +0800 | [diff] [blame] | 304 | ret = res_nquerydomain(statp, name, NULL, cl, type, answer, anslen, herrno); |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 305 | if (ret > 0) return ret; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 306 | } |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 307 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 308 | /* if we got here, we didn't satisfy the search. |
| 309 | * if we did an initial full query, return that query's H_ERRNO |
| 310 | * (note that we wouldn't be here if that query had succeeded). |
| 311 | * else if we ever got a nodata, send that back as the reason. |
| 312 | * else send back meaningless H_ERRNO, that being the one from |
| 313 | * the last DNSRCH we did. |
| 314 | */ |
| 315 | if (saved_herrno != -1) |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 316 | *herrno = saved_herrno; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 317 | else if (got_nodata) |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 318 | *herrno = NO_DATA; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 319 | else if (got_servfail) |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 320 | *herrno = TRY_AGAIN; |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 321 | return -1; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | /* |
| 325 | * Perform a call on res_query on the concatenation of name and domain, |
| 326 | * removing a trailing dot from name if domain is NULL. |
| 327 | */ |
Mike Yu | bfb1b34 | 2018-11-06 15:42:36 +0800 | [diff] [blame] | 328 | int res_nquerydomain(res_state statp, const char* name, const char* domain, int cl, |
chenbruce | c51f121 | 2019-09-12 16:59:33 +0800 | [diff] [blame] | 329 | int type, /* class and type of query */ |
| 330 | uint8_t* answer, /* buffer to put answer */ |
| 331 | int anslen, /* size of answer */ |
| 332 | int* herrno) /* legacy and extended h_errno NETD_RESOLV_H_ERRNO_EXT_* */ |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 333 | { |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 334 | char nbuf[MAXDNAME]; |
| 335 | const char* longname = nbuf; |
| 336 | int n, d; |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 337 | |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 338 | if (domain == NULL) { |
Ken Chen | ffc224a | 2019-03-19 17:41:28 +0800 | [diff] [blame] | 339 | LOG(DEBUG) << __func__ << ": (null, " << cl << ", " << type << ")"; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 340 | /* |
| 341 | * Check for trailing '.'; |
| 342 | * copy without '.' if present. |
| 343 | */ |
| 344 | n = strlen(name); |
| 345 | if (n >= MAXDNAME) { |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 346 | *herrno = NO_RECOVERY; |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 347 | return -1; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 348 | } |
| 349 | n--; |
| 350 | if (n >= 0 && name[n] == '.') { |
| 351 | strncpy(nbuf, name, (size_t) n); |
| 352 | nbuf[n] = '\0'; |
| 353 | } else |
| 354 | longname = name; |
| 355 | } else { |
Ken Chen | ffc224a | 2019-03-19 17:41:28 +0800 | [diff] [blame] | 356 | LOG(DEBUG) << __func__ << ": (" << cl << ", " << type << ")"; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 357 | n = strlen(name); |
| 358 | d = strlen(domain); |
| 359 | if (n + d + 1 >= MAXDNAME) { |
Hungming Chen | 6c84a3d | 2018-12-26 16:14:17 +0800 | [diff] [blame] | 360 | *herrno = NO_RECOVERY; |
Bernie Innocenti | 9c57593 | 2018-09-07 21:10:25 +0900 | [diff] [blame] | 361 | return -1; |
Bernie Innocenti | 8ad893f | 2018-08-31 14:09:46 +0900 | [diff] [blame] | 362 | } |
| 363 | snprintf(nbuf, sizeof(nbuf), "%s.%s", name, domain); |
| 364 | } |
Hungming Chen | 947aab0 | 2018-12-27 18:33:19 +0800 | [diff] [blame] | 365 | return res_nquery(statp, longname, cl, type, answer, anslen, herrno); |
Bernie Innocenti | 318ed2d | 2018-08-30 04:05:20 +0900 | [diff] [blame] | 366 | } |