[d48955b] | 1 | #include <machine/rtems-bsd-user-space.h> |
---|
| 2 | |
---|
[165dd8e] | 3 | /* |
---|
| 4 | * Portions Copyright (C) 2004, 2005, 2008 Internet Systems Consortium, Inc. ("ISC") |
---|
| 5 | * Portions Copyright (C) 1996-2001, 2003 Internet Software Consortium. |
---|
| 6 | * |
---|
| 7 | * Permission to use, copy, modify, and/or distribute this software for any |
---|
| 8 | * purpose with or without fee is hereby granted, provided that the above |
---|
| 9 | * copyright notice and this permission notice appear in all copies. |
---|
| 10 | * |
---|
| 11 | * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH |
---|
| 12 | * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
---|
| 13 | * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, |
---|
| 14 | * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM |
---|
| 15 | * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE |
---|
| 16 | * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
---|
| 17 | * PERFORMANCE OF THIS SOFTWARE. |
---|
| 18 | */ |
---|
| 19 | |
---|
[028aaaf] | 20 | /* |
---|
| 21 | * Copyright (c) 1988, 1993 |
---|
| 22 | * The Regents of the University of California. All rights reserved. |
---|
[165dd8e] | 23 | * |
---|
[028aaaf] | 24 | * Redistribution and use in source and binary forms, with or without |
---|
| 25 | * modification, are permitted provided that the following conditions |
---|
| 26 | * are met: |
---|
| 27 | * 1. Redistributions of source code must retain the above copyright |
---|
| 28 | * notice, this list of conditions and the following disclaimer. |
---|
| 29 | * 2. Redistributions in binary form must reproduce the above copyright |
---|
| 30 | * notice, this list of conditions and the following disclaimer in the |
---|
| 31 | * documentation and/or other materials provided with the distribution. |
---|
| 32 | * 4. Neither the name of the University nor the names of its contributors |
---|
| 33 | * may be used to endorse or promote products derived from this software |
---|
| 34 | * without specific prior written permission. |
---|
[165dd8e] | 35 | * |
---|
[028aaaf] | 36 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
---|
| 37 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
---|
| 38 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
---|
| 39 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
---|
| 40 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
---|
| 41 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
---|
| 42 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
---|
| 43 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
---|
| 44 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
---|
| 45 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
---|
| 46 | * SUCH DAMAGE. |
---|
| 47 | */ |
---|
| 48 | |
---|
| 49 | /* |
---|
| 50 | * Portions Copyright (c) 1993 by Digital Equipment Corporation. |
---|
[165dd8e] | 51 | * |
---|
[028aaaf] | 52 | * Permission to use, copy, modify, and distribute this software for any |
---|
| 53 | * purpose with or without fee is hereby granted, provided that the above |
---|
| 54 | * copyright notice and this permission notice appear in all copies, and that |
---|
| 55 | * the name of Digital Equipment Corporation not be used in advertising or |
---|
| 56 | * publicity pertaining to distribution of the document or software without |
---|
| 57 | * specific, written prior permission. |
---|
[165dd8e] | 58 | * |
---|
[028aaaf] | 59 | * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL |
---|
| 60 | * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES |
---|
| 61 | * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT |
---|
| 62 | * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
---|
| 63 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
---|
| 64 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS |
---|
| 65 | * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
---|
| 66 | * SOFTWARE. |
---|
| 67 | */ |
---|
| 68 | |
---|
| 69 | #if defined(LIBC_SCCS) && !defined(lint) |
---|
| 70 | static const char sccsid[] = "@(#)res_query.c 8.1 (Berkeley) 6/4/93"; |
---|
[165dd8e] | 71 | static const char rcsid[] = "$Id: res_query.c,v 1.11 2008/11/14 02:36:51 marka Exp $"; |
---|
[028aaaf] | 72 | #endif /* LIBC_SCCS and not lint */ |
---|
| 73 | #include <sys/cdefs.h> |
---|
| 74 | __FBSDID("$FreeBSD$"); |
---|
| 75 | |
---|
| 76 | #include "port_before.h" |
---|
[3d1e767] | 77 | #include <sys/types.h> |
---|
[e599318] | 78 | #include <rtems/bsd/sys/param.h> |
---|
[028aaaf] | 79 | #include <netinet/in.h> |
---|
| 80 | #include <arpa/inet.h> |
---|
| 81 | #include <arpa/nameser.h> |
---|
| 82 | #include <ctype.h> |
---|
| 83 | #include <errno.h> |
---|
| 84 | #include <netdb.h> |
---|
| 85 | #include <resolv.h> |
---|
| 86 | #include <stdio.h> |
---|
| 87 | #include <stdlib.h> |
---|
| 88 | #include <string.h> |
---|
| 89 | #include <unistd.h> |
---|
| 90 | #include "port_after.h" |
---|
| 91 | |
---|
| 92 | /* Options. Leave them on. */ |
---|
| 93 | #define DEBUG |
---|
| 94 | |
---|
| 95 | #if PACKETSZ > 1024 |
---|
| 96 | #define MAXPACKET PACKETSZ |
---|
| 97 | #else |
---|
| 98 | #define MAXPACKET 1024 |
---|
| 99 | #endif |
---|
| 100 | |
---|
| 101 | /*% |
---|
| 102 | * Formulate a normal query, send, and await answer. |
---|
| 103 | * Returned answer is placed in supplied buffer "answer". |
---|
| 104 | * Perform preliminary check of answer, returning success only |
---|
| 105 | * if no error is indicated and the answer count is nonzero. |
---|
| 106 | * Return the size of the response on success, -1 on error. |
---|
| 107 | * Error number is left in H_ERRNO. |
---|
| 108 | * |
---|
| 109 | * Caller must parse answer and determine whether it answers the question. |
---|
| 110 | */ |
---|
| 111 | int |
---|
| 112 | res_nquery(res_state statp, |
---|
| 113 | const char *name, /*%< domain name */ |
---|
| 114 | int class, int type, /*%< class and type of query */ |
---|
| 115 | u_char *answer, /*%< buffer to put answer */ |
---|
| 116 | int anslen) /*%< size of answer buffer */ |
---|
| 117 | { |
---|
| 118 | u_char buf[MAXPACKET]; |
---|
| 119 | HEADER *hp = (HEADER *) answer; |
---|
| 120 | u_int oflags; |
---|
| 121 | u_char *rdata; |
---|
| 122 | int n; |
---|
| 123 | |
---|
| 124 | oflags = statp->_flags; |
---|
| 125 | |
---|
| 126 | again: |
---|
| 127 | hp->rcode = NOERROR; /*%< default */ |
---|
| 128 | #ifdef DEBUG |
---|
| 129 | if (statp->options & RES_DEBUG) |
---|
| 130 | printf(";; res_query(%s, %d, %d)\n", name, class, type); |
---|
| 131 | #endif |
---|
| 132 | |
---|
| 133 | n = res_nmkquery(statp, QUERY, name, class, type, NULL, 0, NULL, |
---|
| 134 | buf, sizeof(buf)); |
---|
| 135 | #ifdef RES_USE_EDNS0 |
---|
| 136 | if (n > 0 && (statp->_flags & RES_F_EDNS0ERR) == 0 && |
---|
| 137 | (statp->options & (RES_USE_EDNS0|RES_USE_DNSSEC|RES_NSID))) { |
---|
| 138 | n = res_nopt(statp, n, buf, sizeof(buf), anslen); |
---|
| 139 | rdata = &buf[n]; |
---|
| 140 | if (n > 0 && (statp->options & RES_NSID) != 0U) { |
---|
| 141 | n = res_nopt_rdata(statp, n, buf, sizeof(buf), rdata, |
---|
| 142 | NS_OPT_NSID, 0, NULL); |
---|
| 143 | } |
---|
| 144 | } |
---|
| 145 | #endif |
---|
| 146 | if (n <= 0) { |
---|
| 147 | #ifdef DEBUG |
---|
| 148 | if (statp->options & RES_DEBUG) |
---|
| 149 | printf(";; res_query: mkquery failed\n"); |
---|
| 150 | #endif |
---|
| 151 | RES_SET_H_ERRNO(statp, NO_RECOVERY); |
---|
| 152 | return (n); |
---|
| 153 | } |
---|
| 154 | |
---|
| 155 | n = res_nsend(statp, buf, n, answer, anslen); |
---|
| 156 | if (n < 0) { |
---|
| 157 | #ifdef RES_USE_EDNS0 |
---|
| 158 | /* if the query choked with EDNS0, retry without EDNS0 */ |
---|
| 159 | if ((statp->options & (RES_USE_EDNS0|RES_USE_DNSSEC)) != 0U && |
---|
| 160 | ((oflags ^ statp->_flags) & RES_F_EDNS0ERR) != 0) { |
---|
| 161 | statp->_flags |= RES_F_EDNS0ERR; |
---|
| 162 | if (statp->options & RES_DEBUG) |
---|
| 163 | printf(";; res_nquery: retry without EDNS0\n"); |
---|
| 164 | goto again; |
---|
| 165 | } |
---|
| 166 | #endif |
---|
| 167 | #ifdef DEBUG |
---|
| 168 | if (statp->options & RES_DEBUG) |
---|
| 169 | printf(";; res_query: send error\n"); |
---|
| 170 | #endif |
---|
| 171 | RES_SET_H_ERRNO(statp, TRY_AGAIN); |
---|
| 172 | return (n); |
---|
| 173 | } |
---|
| 174 | |
---|
| 175 | if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) { |
---|
| 176 | #ifdef DEBUG |
---|
| 177 | if (statp->options & RES_DEBUG) |
---|
| 178 | printf(";; rcode = (%s), counts = an:%d ns:%d ar:%d\n", |
---|
| 179 | p_rcode(hp->rcode), |
---|
| 180 | ntohs(hp->ancount), |
---|
| 181 | ntohs(hp->nscount), |
---|
| 182 | ntohs(hp->arcount)); |
---|
| 183 | #endif |
---|
| 184 | switch (hp->rcode) { |
---|
| 185 | case NXDOMAIN: |
---|
| 186 | RES_SET_H_ERRNO(statp, HOST_NOT_FOUND); |
---|
| 187 | break; |
---|
| 188 | case SERVFAIL: |
---|
| 189 | RES_SET_H_ERRNO(statp, TRY_AGAIN); |
---|
| 190 | break; |
---|
| 191 | case NOERROR: |
---|
| 192 | RES_SET_H_ERRNO(statp, NO_DATA); |
---|
| 193 | break; |
---|
| 194 | case FORMERR: |
---|
| 195 | case NOTIMP: |
---|
| 196 | case REFUSED: |
---|
| 197 | default: |
---|
| 198 | RES_SET_H_ERRNO(statp, NO_RECOVERY); |
---|
| 199 | break; |
---|
| 200 | } |
---|
| 201 | return (-1); |
---|
| 202 | } |
---|
| 203 | return (n); |
---|
| 204 | } |
---|
| 205 | |
---|
| 206 | /*% |
---|
| 207 | * Formulate a normal query, send, and retrieve answer in supplied buffer. |
---|
| 208 | * Return the size of the response on success, -1 on error. |
---|
| 209 | * If enabled, implement search rules until answer or unrecoverable failure |
---|
| 210 | * is detected. Error code, if any, is left in H_ERRNO. |
---|
| 211 | */ |
---|
| 212 | int |
---|
| 213 | res_nsearch(res_state statp, |
---|
| 214 | const char *name, /*%< domain name */ |
---|
| 215 | int class, int type, /*%< class and type of query */ |
---|
| 216 | u_char *answer, /*%< buffer to put answer */ |
---|
| 217 | int anslen) /*%< size of answer */ |
---|
| 218 | { |
---|
| 219 | const char *cp, * const *domain; |
---|
| 220 | HEADER *hp = (HEADER *) answer; |
---|
| 221 | char tmp[NS_MAXDNAME]; |
---|
| 222 | u_int dots; |
---|
| 223 | int trailing_dot, ret, saved_herrno; |
---|
| 224 | int got_nodata = 0, got_servfail = 0, root_on_list = 0; |
---|
| 225 | int tried_as_is = 0; |
---|
| 226 | int searched = 0; |
---|
| 227 | |
---|
| 228 | errno = 0; |
---|
| 229 | RES_SET_H_ERRNO(statp, HOST_NOT_FOUND); /*%< True if we never query. */ |
---|
| 230 | dots = 0; |
---|
| 231 | for (cp = name; *cp != '\0'; cp++) |
---|
| 232 | dots += (*cp == '.'); |
---|
| 233 | trailing_dot = 0; |
---|
| 234 | if (cp > name && *--cp == '.') |
---|
| 235 | trailing_dot++; |
---|
| 236 | |
---|
| 237 | /* If there aren't any dots, it could be a user-level alias. */ |
---|
| 238 | if (!dots && (cp = res_hostalias(statp, name, tmp, sizeof tmp))!= NULL) |
---|
| 239 | return (res_nquery(statp, cp, class, type, answer, anslen)); |
---|
| 240 | |
---|
| 241 | /* |
---|
| 242 | * If there are enough dots in the name, let's just give it a |
---|
| 243 | * try 'as is'. The threshold can be set with the "ndots" option. |
---|
| 244 | * Also, query 'as is', if there is a trailing dot in the name. |
---|
| 245 | */ |
---|
| 246 | saved_herrno = -1; |
---|
| 247 | if (dots >= statp->ndots || trailing_dot) { |
---|
| 248 | ret = res_nquerydomain(statp, name, NULL, class, type, |
---|
| 249 | answer, anslen); |
---|
| 250 | if (ret > 0 || trailing_dot) |
---|
| 251 | return (ret); |
---|
| 252 | if (errno == ECONNREFUSED) { |
---|
| 253 | RES_SET_H_ERRNO(statp, TRY_AGAIN); |
---|
| 254 | return (-1); |
---|
| 255 | } |
---|
| 256 | switch (statp->res_h_errno) { |
---|
| 257 | case NO_DATA: |
---|
| 258 | case HOST_NOT_FOUND: |
---|
| 259 | break; |
---|
| 260 | case TRY_AGAIN: |
---|
| 261 | if (hp->rcode == SERVFAIL) |
---|
| 262 | break; |
---|
| 263 | /* FALLTHROUGH */ |
---|
| 264 | default: |
---|
| 265 | return (-1); |
---|
| 266 | } |
---|
| 267 | saved_herrno = statp->res_h_errno; |
---|
| 268 | tried_as_is++; |
---|
| 269 | } |
---|
| 270 | |
---|
| 271 | /* |
---|
| 272 | * We do at least one level of search if |
---|
| 273 | * - there is no dot and RES_DEFNAME is set, or |
---|
| 274 | * - there is at least one dot, there is no trailing dot, |
---|
| 275 | * and RES_DNSRCH is set. |
---|
| 276 | */ |
---|
| 277 | if ((!dots && (statp->options & RES_DEFNAMES) != 0U) || |
---|
| 278 | (dots && !trailing_dot && (statp->options & RES_DNSRCH) != 0U)) { |
---|
| 279 | int done = 0; |
---|
| 280 | |
---|
| 281 | for (domain = (const char * const *)statp->dnsrch; |
---|
| 282 | *domain && !done; |
---|
| 283 | domain++) { |
---|
| 284 | searched = 1; |
---|
| 285 | |
---|
| 286 | if (domain[0][0] == '\0' || |
---|
| 287 | (domain[0][0] == '.' && domain[0][1] == '\0')) |
---|
| 288 | root_on_list++; |
---|
| 289 | |
---|
| 290 | if (root_on_list && tried_as_is) |
---|
| 291 | continue; |
---|
| 292 | |
---|
| 293 | ret = res_nquerydomain(statp, name, *domain, |
---|
| 294 | class, type, |
---|
| 295 | answer, anslen); |
---|
| 296 | if (ret > 0) |
---|
| 297 | return (ret); |
---|
| 298 | |
---|
| 299 | /* |
---|
| 300 | * If no server present, give up. |
---|
| 301 | * If name isn't found in this domain, |
---|
| 302 | * keep trying higher domains in the search list |
---|
| 303 | * (if that's enabled). |
---|
| 304 | * On a NO_DATA error, keep trying, otherwise |
---|
| 305 | * a wildcard entry of another type could keep us |
---|
| 306 | * from finding this entry higher in the domain. |
---|
| 307 | * If we get some other error (negative answer or |
---|
| 308 | * server failure), then stop searching up, |
---|
| 309 | * but try the input name below in case it's |
---|
| 310 | * fully-qualified. |
---|
| 311 | */ |
---|
| 312 | if (errno == ECONNREFUSED) { |
---|
| 313 | RES_SET_H_ERRNO(statp, TRY_AGAIN); |
---|
| 314 | return (-1); |
---|
| 315 | } |
---|
| 316 | |
---|
| 317 | switch (statp->res_h_errno) { |
---|
| 318 | case NO_DATA: |
---|
| 319 | got_nodata++; |
---|
| 320 | /* FALLTHROUGH */ |
---|
| 321 | case HOST_NOT_FOUND: |
---|
| 322 | /* keep trying */ |
---|
| 323 | break; |
---|
| 324 | case TRY_AGAIN: |
---|
| 325 | /* |
---|
| 326 | * This can occur due to a server failure |
---|
| 327 | * (that is, all listed servers have failed), |
---|
| 328 | * or all listed servers have timed out. |
---|
| 329 | * ((HEADER *)answer)->rcode may not be set |
---|
| 330 | * to SERVFAIL in the case of a timeout. |
---|
| 331 | * |
---|
| 332 | * Either way we must return TRY_AGAIN in |
---|
| 333 | * order to avoid non-deterministic |
---|
| 334 | * return codes. |
---|
| 335 | * For example, loaded name servers or races |
---|
| 336 | * against network startup/validation (dhcp, |
---|
| 337 | * ppp, etc) can cause the search to timeout |
---|
| 338 | * on one search element, e.g. 'fu.bar.com', |
---|
| 339 | * and return a definitive failure on the |
---|
| 340 | * next search element, e.g. 'fu.'. |
---|
| 341 | */ |
---|
| 342 | got_servfail++; |
---|
| 343 | if (hp->rcode == SERVFAIL) { |
---|
| 344 | /* try next search element, if any */ |
---|
| 345 | break; |
---|
| 346 | } |
---|
| 347 | /* FALLTHROUGH */ |
---|
| 348 | default: |
---|
| 349 | /* anything else implies that we're done */ |
---|
| 350 | done++; |
---|
| 351 | } |
---|
| 352 | |
---|
| 353 | /* if we got here for some reason other than DNSRCH, |
---|
| 354 | * we only wanted one iteration of the loop, so stop. |
---|
| 355 | */ |
---|
| 356 | if ((statp->options & RES_DNSRCH) == 0U) |
---|
| 357 | done++; |
---|
| 358 | } |
---|
| 359 | } |
---|
| 360 | |
---|
| 361 | switch (statp->res_h_errno) { |
---|
| 362 | case NO_DATA: |
---|
| 363 | case HOST_NOT_FOUND: |
---|
| 364 | break; |
---|
| 365 | case TRY_AGAIN: |
---|
| 366 | if (hp->rcode == SERVFAIL) |
---|
| 367 | break; |
---|
| 368 | /* FALLTHROUGH */ |
---|
| 369 | default: |
---|
| 370 | goto giveup; |
---|
| 371 | } |
---|
| 372 | |
---|
| 373 | /* |
---|
| 374 | * If the query has not already been tried as is then try it |
---|
| 375 | * unless RES_NOTLDQUERY is set and there were no dots. |
---|
| 376 | */ |
---|
| 377 | if ((dots || !searched || (statp->options & RES_NOTLDQUERY) == 0U) && |
---|
| 378 | !(tried_as_is || root_on_list)) { |
---|
| 379 | ret = res_nquerydomain(statp, name, NULL, class, type, |
---|
| 380 | answer, anslen); |
---|
| 381 | if (ret > 0) |
---|
| 382 | return (ret); |
---|
| 383 | } |
---|
| 384 | |
---|
| 385 | /* if we got here, we didn't satisfy the search. |
---|
| 386 | * if we did an initial full query, return that query's H_ERRNO |
---|
| 387 | * (note that we wouldn't be here if that query had succeeded). |
---|
| 388 | * else if we ever got a nodata, send that back as the reason. |
---|
| 389 | * else send back meaningless H_ERRNO, that being the one from |
---|
| 390 | * the last DNSRCH we did. |
---|
| 391 | */ |
---|
| 392 | giveup: |
---|
| 393 | if (saved_herrno != -1) |
---|
| 394 | RES_SET_H_ERRNO(statp, saved_herrno); |
---|
| 395 | else if (got_nodata) |
---|
| 396 | RES_SET_H_ERRNO(statp, NO_DATA); |
---|
| 397 | else if (got_servfail) |
---|
| 398 | RES_SET_H_ERRNO(statp, TRY_AGAIN); |
---|
| 399 | return (-1); |
---|
| 400 | } |
---|
| 401 | |
---|
| 402 | /*% |
---|
| 403 | * Perform a call on res_query on the concatenation of name and domain, |
---|
| 404 | * removing a trailing dot from name if domain is NULL. |
---|
| 405 | */ |
---|
| 406 | int |
---|
| 407 | res_nquerydomain(res_state statp, |
---|
| 408 | const char *name, |
---|
| 409 | const char *domain, |
---|
| 410 | int class, int type, /*%< class and type of query */ |
---|
| 411 | u_char *answer, /*%< buffer to put answer */ |
---|
| 412 | int anslen) /*%< size of answer */ |
---|
| 413 | { |
---|
| 414 | char nbuf[MAXDNAME]; |
---|
| 415 | const char *longname = nbuf; |
---|
| 416 | int n, d; |
---|
| 417 | |
---|
| 418 | #ifdef DEBUG |
---|
| 419 | if (statp->options & RES_DEBUG) |
---|
| 420 | printf(";; res_nquerydomain(%s, %s, %d, %d)\n", |
---|
| 421 | name, domain?domain:"<Nil>", class, type); |
---|
| 422 | #endif |
---|
| 423 | if (domain == NULL) { |
---|
| 424 | /* |
---|
| 425 | * Check for trailing '.'; |
---|
| 426 | * copy without '.' if present. |
---|
| 427 | */ |
---|
| 428 | n = strlen(name); |
---|
| 429 | if (n >= MAXDNAME) { |
---|
| 430 | RES_SET_H_ERRNO(statp, NO_RECOVERY); |
---|
| 431 | return (-1); |
---|
| 432 | } |
---|
| 433 | n--; |
---|
| 434 | if (n >= 0 && name[n] == '.') { |
---|
| 435 | strncpy(nbuf, name, n); |
---|
| 436 | nbuf[n] = '\0'; |
---|
| 437 | } else |
---|
| 438 | longname = name; |
---|
| 439 | } else { |
---|
| 440 | n = strlen(name); |
---|
| 441 | d = strlen(domain); |
---|
| 442 | if (n + d + 1 >= MAXDNAME) { |
---|
| 443 | RES_SET_H_ERRNO(statp, NO_RECOVERY); |
---|
| 444 | return (-1); |
---|
| 445 | } |
---|
| 446 | sprintf(nbuf, "%s.%s", name, domain); |
---|
| 447 | } |
---|
| 448 | return (res_nquery(statp, longname, class, type, answer, anslen)); |
---|
| 449 | } |
---|
| 450 | |
---|
| 451 | const char * |
---|
| 452 | res_hostalias(const res_state statp, const char *name, char *dst, size_t siz) { |
---|
| 453 | char *file, *cp1, *cp2; |
---|
| 454 | char buf[BUFSIZ]; |
---|
| 455 | FILE *fp; |
---|
| 456 | |
---|
| 457 | if (statp->options & RES_NOALIASES) |
---|
| 458 | return (NULL); |
---|
| 459 | if (issetugid()) |
---|
| 460 | return (NULL); |
---|
| 461 | file = getenv("HOSTALIASES"); |
---|
| 462 | if (file == NULL || (fp = fopen(file, "r")) == NULL) |
---|
| 463 | return (NULL); |
---|
| 464 | setbuf(fp, NULL); |
---|
| 465 | buf[sizeof(buf) - 1] = '\0'; |
---|
| 466 | while (fgets(buf, sizeof(buf), fp)) { |
---|
| 467 | for (cp1 = buf; *cp1 && !isspace((unsigned char)*cp1); ++cp1) |
---|
| 468 | ; |
---|
| 469 | if (!*cp1) |
---|
| 470 | break; |
---|
| 471 | *cp1 = '\0'; |
---|
| 472 | if (ns_samename(buf, name) == 1) { |
---|
| 473 | while (isspace((unsigned char)*++cp1)) |
---|
| 474 | ; |
---|
| 475 | if (!*cp1) |
---|
| 476 | break; |
---|
| 477 | for (cp2 = cp1 + 1; *cp2 && |
---|
| 478 | !isspace((unsigned char)*cp2); ++cp2) |
---|
| 479 | ; |
---|
| 480 | *cp2 = '\0'; |
---|
| 481 | strncpy(dst, cp1, siz - 1); |
---|
| 482 | dst[siz - 1] = '\0'; |
---|
| 483 | fclose(fp); |
---|
| 484 | return (dst); |
---|
| 485 | } |
---|
| 486 | } |
---|
| 487 | fclose(fp); |
---|
| 488 | return (NULL); |
---|
| 489 | } |
---|
| 490 | |
---|
| 491 | /*! \file */ |
---|