resolv/res_query.c

   1 /*
   2  * Copyright (c) 1988, 1993
   3  *    The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 /*
  31  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  32  *
  33  * Permission to use, copy, modify, and distribute this software for any
  34  * purpose with or without fee is hereby granted, provided that the above
  35  * copyright notice and this permission notice appear in all copies, and that
  36  * the name of Digital Equipment Corporation not be used in advertising or
  37  * publicity pertaining to distribution of the document or software without
  38  * specific, written prior permission.
  39  *
  40  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  41  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  42  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  43  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  44  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  45  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  46  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  47  * SOFTWARE.
  48  */
  49
  50 /*
  51  * Portions Copyright (c) 1996-1999 by Internet Software Consortium.
  52  *
  53  * Permission to use, copy, modify, and distribute this software for any
  54  * purpose with or without fee is hereby granted, provided that the above
  55  * copyright notice and this permission notice appear in all copies.
  56  *
  57  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
  58  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
  59  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
  60  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  61  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  62  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  63  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  64  * SOFTWARE.
  65  */
  66
  67 #if defined(LIBC_SCCS) && !defined(lint)
  68 static const char sccsid[] = "@(#)res_query.c   8.1 (Berkeley) 6/4/93";
  69 static const char rcsid[] = "$BINDId: res_query.c,v 8.20 2000/02/29 05:39:12 vixie Exp $";
  70 #endif /* LIBC_SCCS and not lint */
  71
  72 #include <assert.h>
  73 #include <sys/types.h>
  74 #include <sys/param.h>
  75 #include <netinet/in.h>
  76 #include <arpa/inet.h>
  77 #include <arpa/nameser.h>
  78 #include <ctype.h>
  79 #include <errno.h>
  80 #include <netdb.h>
  81 #include <resolv.h>
  82 #include <stdio.h>
  83 #include <stdlib.h>
  84 #include <string.h>
  85
  86 /* Options.  Leave them on. */
  87 /* #undef DEBUG */
  88
  89 #if PACKETSZ > 65536
  90 #define MAXPACKET       PACKETSZ
  91 #else
  92 #define MAXPACKET       65536
  93 #endif
  94
  95 #define QUERYSIZE       (HFIXEDSZ + QFIXEDSZ + MAXCDNAME + 1)
  96
  97 static int
  98 __libc_res_nquerydomain(res_state statp, const char *name, const char *domain,
  99                         int class, int type, u_char *answer, int anslen,
 100                         u_char **answerp, u_char **answerp2, int *nanswerp2,
 101                         int *resplen2, int *answerp2_malloced);
 102
 103 /*
 104  * Formulate a normal query, send, and await answer.
 105  * Returned answer is placed in supplied buffer "answer".
 106  * Perform preliminary check of answer, returning success only
 107  * if no error is indicated and the answer count is nonzero.
 108  * Return the size of the response on success, -1 on error.
 109  * Error number is left in H_ERRNO.
 110  *
 111  * Caller must parse answer and determine whether it answers the question.
 112  */
 113 int
 114 __libc_res_nquery(res_state statp,
 115                   const char *name,     /* domain name */
 116                   int class, int type,  /* class and type of query */
 117                   u_char *answer,       /* buffer to put answer */
 118                   int anslen,           /* size of answer buffer */
 119                   u_char **answerp,     /* if buffer needs to be enlarged */
 120                   u_char **answerp2,
 121                   int *nanswerp2,
 122                   int *resplen2,
 123                   int *answerp2_malloced)
 124 {
 125         HEADER *hp = (HEADER *) answer;
 126         HEADER *hp2;
 127         int n, use_malloc = 0;
 128         u_int oflags = statp->_flags;
 129
 130         size_t bufsize = (type == T_UNSPEC ? 2 : 1) * QUERYSIZE;
 131         u_char *buf = alloca (bufsize);
 132         u_char *query1 = buf;
 133         int nquery1 = -1;
 134         u_char *query2 = NULL;
 135         int nquery2 = 0;
 136
 137  again:
 138         hp->rcode = NOERROR;    /* default */
 139
 140 #ifdef DEBUG
 141         if (statp->options & RES_DEBUG)
 142                 printf(";; res_query(%s, %d, %d)\n", name, class, type);
 143 #endif
 144
 145         if (type == T_UNSPEC)
 146           {
 147             n = res_nmkquery(statp, QUERY, name, class, T_A, NULL, 0, NULL,
 148                              query1, bufsize);
 149             if (n > 0)
 150               {
 151                 if ((oflags & RES_F_EDNS0ERR) == 0
 152                     && (statp->options & (RES_USE_EDNS0|RES_USE_DNSSEC)) != 0)
 153                   {
 154                     n = __res_nopt(statp, n, query1, bufsize, anslen / 2);
 155                     if (n < 0)
 156                       goto unspec_nomem;
 157                   }
 158
 159                 nquery1 = n;
 160                 /* Align the buffer.  */
 161                 int npad = ((nquery1 + __alignof__ (HEADER) - 1)
 162                             & ~(__alignof__ (HEADER) - 1)) - nquery1;
 163                 if (n > bufsize - npad)
 164                   {
 165                     n = -1;
 166                     goto unspec_nomem;
 167                   }
 168                 int nused = n + npad;
 169                 query2 = buf + nused;
 170                 n = res_nmkquery(statp, QUERY, name, class, T_AAAA, NULL, 0,
 171                                  NULL, query2, bufsize - nused);
 172                 if (n > 0
 173                     && (oflags & RES_F_EDNS0ERR) == 0
 174                     && (statp->options & (RES_USE_EDNS0|RES_USE_DNSSEC)) != 0)
 175                   n = __res_nopt(statp, n, query2, bufsize - nused - n,
 176                                  anslen / 2);
 177                 nquery2 = n;
 178               }
 179
 180           unspec_nomem:;
 181           }
 182         else
 183           {
 184             n = res_nmkquery(statp, QUERY, name, class, type, NULL, 0, NULL,
 185                              query1, bufsize);
 186
 187             if (n > 0
 188                 && (oflags & RES_F_EDNS0ERR) == 0
 189                 && (statp->options & (RES_USE_EDNS0|RES_USE_DNSSEC)) != 0)
 190               n = __res_nopt(statp, n, query1, bufsize, anslen);
 191
 192             nquery1 = n;
 193           }
 194
 195         if (__builtin_expect (n <= 0, 0) && !use_malloc) {
 196                 /* Retry just in case res_nmkquery failed because of too
 197                    short buffer.  Shouldn't happen.  */
 198                 bufsize = (type == T_UNSPEC ? 2 : 1) * MAXPACKET;
 199                 buf = malloc (bufsize);
 200                 if (buf != NULL) {
 201                         query1 = buf;
 202                         use_malloc = 1;
 203                         goto again;
 204                 }
 205         }
 206         if (__glibc_unlikely (n <= 0))       {
 207                 /* If the query choked with EDNS0, retry without EDNS0.  */
 208                 if ((statp->options & (RES_USE_EDNS0|RES_USE_DNSSEC)) != 0
 209                     && ((oflags ^ statp->_flags) & RES_F_EDNS0ERR) != 0) {
 210                         statp->_flags |= RES_F_EDNS0ERR;
 211 #ifdef DEBUG
 212                         if (statp->options & RES_DEBUG)
 213                                 printf(";; res_nquery: retry without EDNS0\n");
 214 #endif
 215                         goto again;
 216                 }
 217 #ifdef DEBUG
 218                 if (statp->options & RES_DEBUG)
 219                         printf(";; res_query: mkquery failed\n");
 220 #endif
 221                 RES_SET_H_ERRNO(statp, NO_RECOVERY);
 222                 if (use_malloc)
 223                         free (buf);
 224                 return (n);
 225         }
 226         assert (answerp == NULL || (void *) *answerp == (void *) answer);
 227         n = __libc_res_nsend(statp, query1, nquery1, query2, nquery2, answer,
 228                              anslen, answerp, answerp2, nanswerp2, resplen2,
 229                              answerp2_malloced);
 230         if (use_malloc)
 231                 free (buf);
 232         if (n < 0) {
 233 #ifdef DEBUG
 234                 if (statp->options & RES_DEBUG)
 235                         printf(";; res_query: send error\n");
 236 #endif
 237                 RES_SET_H_ERRNO(statp, TRY_AGAIN);
 238                 return (n);
 239         }
 240
 241         if (answerp != NULL)
 242           /* __libc_res_nsend might have reallocated the buffer.  */
 243           hp = (HEADER *) *answerp;
 244
 245         /* We simplify the following tests by assigning HP to HP2 or
 246            vice versa.  It is easy to verify that this is the same as
 247            ignoring all tests of HP or HP2.  */
 248         if (answerp2 == NULL || *resplen2 < (int) sizeof (HEADER))
 249           {
 250             hp2 = hp;
 251           }
 252         else
 253           {
 254             hp2 = (HEADER *) *answerp2;
 255             if (n < (int) sizeof (HEADER))
 256               {
 257                 hp = hp2;
 258               }
 259           }
 260
 261         /* Make sure both hp and hp2 are defined */
 262         assert((hp != NULL) && (hp2 != NULL));
 263
 264         if ((hp->rcode != NOERROR || ntohs(hp->ancount) == 0)
 265             && (hp2->rcode != NOERROR || ntohs(hp2->ancount) == 0)) {
 266 #ifdef DEBUG
 267                 if (statp->options & RES_DEBUG) {
 268                         printf(";; rcode = %d, ancount=%d\n", hp->rcode,
 269                             ntohs(hp->ancount));
 270                         if (hp != hp2)
 271                           printf(";; rcode2 = %d, ancount2=%d\n", hp2->rcode,
 272                                  ntohs(hp2->ancount));
 273                 }
 274 #endif
 275                 switch (hp->rcode == NOERROR ? hp2->rcode : hp->rcode) {
 276                 case NXDOMAIN:
 277                         if ((hp->rcode == NOERROR && ntohs (hp->ancount) != 0)
 278                             || (hp2->rcode == NOERROR
 279                                 && ntohs (hp2->ancount) != 0))
 280                                 goto success;
 281                         RES_SET_H_ERRNO(statp, HOST_NOT_FOUND);
 282                         break;
 283                 case SERVFAIL:
 284                         RES_SET_H_ERRNO(statp, TRY_AGAIN);
 285                         break;
 286                 case NOERROR:
 287                         if (ntohs (hp->ancount) != 0
 288                             || ntohs (hp2->ancount) != 0)
 289                                 goto success;
 290                         RES_SET_H_ERRNO(statp, NO_DATA);
 291                         break;
 292                 case FORMERR:
 293                 case NOTIMP:
 294                         /* Servers must not reply to AAAA queries with
 295                            NOTIMP etc but some of them do.  */
 296                         if ((hp->rcode == NOERROR && ntohs (hp->ancount) != 0)
 297                             || (hp2->rcode == NOERROR
 298                                 && ntohs (hp2->ancount) != 0))
 299                                 goto success;
 300                         /* FALLTHROUGH */
 301                 case REFUSED:
 302                 default:
 303                         RES_SET_H_ERRNO(statp, NO_RECOVERY);
 304                         break;
 305                 }
 306                 return (-1);
 307         }
 308  success:
 309         return (n);
 310 }
 311 libresolv_hidden_def (__libc_res_nquery)
 312
 313 int
 314 res_nquery(res_state statp,
 315            const char *name,    /* domain name */
 316            int class, int type, /* class and type of query */
 317            u_char *answer,      /* buffer to put answer */
 318            int anslen)          /* size of answer buffer */
 319 {
 320         return __libc_res_nquery(statp, name, class, type, answer, anslen,
 321                                  NULL, NULL, NULL, NULL, NULL);
 322 }
 323 libresolv_hidden_def (res_nquery)
 324
 325 /*
 326  * Formulate a normal query, send, and retrieve answer in supplied buffer.
 327  * Return the size of the response on success, -1 on error.
 328  * If enabled, implement search rules until answer or unrecoverable failure
 329  * is detected.  Error code, if any, is left in H_ERRNO.
 330  */
 331 int
 332 __libc_res_nsearch(res_state statp,
 333                    const char *name,    /* domain name */
 334                    int class, int type, /* class and type of query */
 335                    u_char *answer,      /* buffer to put answer */
 336                    int anslen,          /* size of answer */
 337                    u_char **answerp,
 338                    u_char **answerp2,
 339                    int *nanswerp2,
 340                    int *resplen2,
 341                    int *answerp2_malloced)
 342 {
 343         const char *cp, * const *domain;
 344         HEADER *hp = (HEADER *) answer;
 345         char tmp[NS_MAXDNAME];
 346         u_int dots;
 347         int trailing_dot, ret, saved_herrno;
 348         int got_nodata = 0, got_servfail = 0, root_on_list = 0;
 349         int tried_as_is = 0;
 350         int searched = 0;
 351
 352         __set_errno (0);
 353         RES_SET_H_ERRNO(statp, HOST_NOT_FOUND);  /* True if we never query. */
 354
 355         dots = 0;
 356         for (cp = name; *cp != '\0'; cp++)
 357                 dots += (*cp == '.');
 358         trailing_dot = 0;
 359         if (cp > name && *--cp == '.')
 360                 trailing_dot++;
 361
 362         /* If there aren't any dots, it could be a user-level alias. */
 363         if (!dots && (cp = res_hostalias(statp, name, tmp, sizeof tmp))!= NULL)
 364                 return (__libc_res_nquery(statp, cp, class, type, answer,
 365                                           anslen, answerp, answerp2,
 366                                           nanswerp2, resplen2, answerp2_malloced));
 367
 368 #ifdef DEBUG
 369         if (statp->options & RES_DEBUG)
 370                 printf("dots=%d, statp->ndots=%d, trailing_dot=%d, name=%s\n",
 371                        (int)dots,(int)statp->ndots,(int)trailing_dot,name);
 372 #endif
 373
 374         /*
 375          * If there are enough dots in the name, let's just give it a
 376          * try 'as is'. The threshold can be set with the "ndots" option.
 377          * Also, query 'as is', if there is a trailing dot in the name.
 378          */
 379         saved_herrno = -1;
 380         if (dots >= statp->ndots || trailing_dot) {
 381                 ret = __libc_res_nquerydomain(statp, name, NULL, class, type,
 382                                               answer, anslen, answerp,
 383                                               answerp2, nanswerp2, resplen2,
 384                                               answerp2_malloced);
 385                 if (ret > 0 || trailing_dot)
 386                         return (ret);
 387                 saved_herrno = h_errno;
 388                 tried_as_is++;
 389                 if (answerp && *answerp != answer) {
 390                         answer = *answerp;
 391                         anslen = MAXPACKET;
 392                 }
 393                 if (answerp2 && *answerp2_malloced)
 394                   {
 395                     free (*answerp2);
 396                     *answerp2 = NULL;
 397                     *answerp2_malloced = 0;
 398                   }
 399         }
 400
 401         /*
 402          * We do at least one level of search if
 403          *      - there is no dot and RES_DEFNAME is set, or
 404          *      - there is at least one dot, there is no trailing dot,
 405          *        and RES_DNSRCH is set.
 406          */
 407         if ((!dots && (statp->options & RES_DEFNAMES) != 0) ||
 408             (dots && !trailing_dot && (statp->options & RES_DNSRCH) != 0)) {
 409                 int done = 0;
 410
 411                 for (domain = (const char * const *)statp->dnsrch;
 412                      *domain && !done;
 413                      domain++) {
 414                         searched = 1;
 415
 416                         if (domain[0][0] == '\0' ||
 417                             (domain[0][0] == '.' && domain[0][1] == '\0'))
 418                                 root_on_list++;
 419
 420                         ret = __libc_res_nquerydomain(statp, name, *domain,
 421                                                       class, type,
 422                                                       answer, anslen, answerp,
 423                                                       answerp2, nanswerp2,
 424                                                       resplen2, answerp2_malloced);
 425                         if (ret > 0)
 426                                 return (ret);
 427
 428                         if (answerp && *answerp != answer) {
 429                                 answer = *answerp;
 430                                 anslen = MAXPACKET;
 431                         }
 432                         if (answerp2 && *answerp2_malloced)
 433                           {
 434                             free (*answerp2);
 435                             *answerp2 = NULL;
 436                             *answerp2_malloced = 0;
 437                           }
 438
 439                         /*
 440                          * If no server present, give up.
 441                          * If name isn't found in this domain,
 442                          * keep trying higher domains in the search list
 443                          * (if that's enabled).
 444                          * On a NO_DATA error, keep trying, otherwise
 445                          * a wildcard entry of another type could keep us
 446                          * from finding this entry higher in the domain.
 447                          * If we get some other error (negative answer or
 448                          * server failure), then stop searching up,
 449                          * but try the input name below in case it's
 450                          * fully-qualified.
 451                          */
 452                         if (errno == ECONNREFUSED) {
 453                                 RES_SET_H_ERRNO(statp, TRY_AGAIN);
 454                                 return (-1);
 455                         }
 456
 457                         switch (statp->res_h_errno) {
 458                         case NO_DATA:
 459                                 got_nodata++;
 460                                 /* FALLTHROUGH */
 461                         case HOST_NOT_FOUND:
 462                                 /* keep trying */
 463                                 break;
 464                         case TRY_AGAIN:
 465                                 if (hp->rcode == SERVFAIL) {
 466                                         /* try next search element, if any */
 467                                         got_servfail++;
 468                                         break;
 469                                 }
 470                                 /* FALLTHROUGH */
 471                         default:
 472                                 /* anything else implies that we're done */
 473                                 done++;
 474                         }
 475
 476                         /* if we got here for some reason other than DNSRCH,
 477                          * we only wanted one iteration of the loop, so stop.
 478                          */
 479                         if ((statp->options & RES_DNSRCH) == 0)
 480                                 done++;
 481                 }
 482         }
 483
 484         /*
 485          * f the query has not already been tried as is then try it
 486          * unless RES_NOTLDQUERY is set and there were no dots.
 487          */
 488         if ((dots || !searched || (statp->options & RES_NOTLDQUERY) == 0)
 489             && !(tried_as_is || root_on_list)) {
 490                 ret = __libc_res_nquerydomain(statp, name, NULL, class, type,
 491                                               answer, anslen, answerp,
 492                                               answerp2, nanswerp2, resplen2,
 493                                               answerp2_malloced);
 494                 if (ret > 0)
 495                         return (ret);
 496         }
 497
 498         /* if we got here, we didn't satisfy the search.
 499          * if we did an initial full query, return that query's H_ERRNO
 500          * (note that we wouldn't be here if that query had succeeded).
 501          * else if we ever got a nodata, send that back as the reason.
 502          * else send back meaningless H_ERRNO, that being the one from
 503          * the last DNSRCH we did.
 504          */
 505         if (answerp2 && *answerp2_malloced)
 506           {
 507             free (*answerp2);
 508             *answerp2 = NULL;
 509             *answerp2_malloced = 0;
 510           }
 511         if (saved_herrno != -1)
 512                 RES_SET_H_ERRNO(statp, saved_herrno);
 513         else if (got_nodata)
 514                 RES_SET_H_ERRNO(statp, NO_DATA);
 515         else if (got_servfail)
 516                 RES_SET_H_ERRNO(statp, TRY_AGAIN);
 517         return (-1);
 518 }
 519 libresolv_hidden_def (__libc_res_nsearch)
 520
 521 int
 522 res_nsearch(res_state statp,
 523             const char *name,   /* domain name */
 524             int class, int type,        /* class and type of query */
 525             u_char *answer,     /* buffer to put answer */
 526             int anslen)         /* size of answer */
 527 {
 528         return __libc_res_nsearch(statp, name, class, type, answer,
 529                                   anslen, NULL, NULL, NULL, NULL, NULL);
 530 }
 531 libresolv_hidden_def (res_nsearch)
 532
 533 /*
 534  * Perform a call on res_query on the concatenation of name and domain,
 535  * removing a trailing dot from name if domain is NULL.
 536  */
 537 static int
 538 __libc_res_nquerydomain(res_state statp,
 539                         const char *name,
 540                         const char *domain,
 541                         int class, int type,    /* class and type of query */
 542                         u_char *answer,         /* buffer to put answer */
 543                         int anslen,                     /* size of answer */
 544                         u_char **answerp,
 545                         u_char **answerp2,
 546                         int *nanswerp2,
 547                         int *resplen2,
 548                         int *answerp2_malloced)
 549 {
 550         char nbuf[MAXDNAME];
 551         const char *longname = nbuf;
 552         size_t n, d;
 553
 554 #ifdef DEBUG
 555         if (statp->options & RES_DEBUG)
 556                 printf(";; res_nquerydomain(%s, %s, %d, %d)\n",
 557                        name, domain?domain:"<Nil>", class, type);
 558 #endif
 559         if (domain == NULL) {
 560                 /*
 561                  * Check for trailing '.';
 562                  * copy without '.' if present.
 563                  */
 564                 n = strlen(name);
 565
 566                 /* Decrement N prior to checking it against MAXDNAME
 567                    so that we detect a wrap to SIZE_MAX and return
 568                    a reasonable error.  */
 569                 n--;
 570                 if (n >= MAXDNAME - 1) {
 571                         RES_SET_H_ERRNO(statp, NO_RECOVERY);
 572                         return (-1);
 573                 }
 574                 if (name[n] == '.') {
 575                         strncpy(nbuf, name, n);
 576                         nbuf[n] = '\0';
 577                 } else
 578                         longname = name;
 579         } else {
 580                 n = strlen(name);
 581                 d = strlen(domain);
 582                 if (n + d + 1 >= MAXDNAME) {
 583                         RES_SET_H_ERRNO(statp, NO_RECOVERY);
 584                         return (-1);
 585                 }
 586                 sprintf(nbuf, "%s.%s", name, domain);
 587         }
 588         return (__libc_res_nquery(statp, longname, class, type, answer,
 589                                   anslen, answerp, answerp2, nanswerp2,
 590                                   resplen2, answerp2_malloced));
 591 }
 592
 593 int
 594 res_nquerydomain(res_state statp,
 595             const char *name,
 596             const char *domain,
 597             int class, int type,        /* class and type of query */
 598             u_char *answer,             /* buffer to put answer */
 599             int anslen)         /* size of answer */
 600 {
 601         return __libc_res_nquerydomain(statp, name, domain, class, type,
 602                                        answer, anslen, NULL, NULL, NULL, NULL,
 603                                        NULL);
 604 }
 605 libresolv_hidden_def (res_nquerydomain)
 606
 607 const char *
 608 res_hostalias(const res_state statp, const char *name, char *dst, size_t siz) {
 609         char *file, *cp1, *cp2;
 610         char buf[BUFSIZ];
 611         FILE *fp;
 612
 613         if (statp->options & RES_NOALIASES)
 614                 return (NULL);
 615         file = getenv("HOSTALIASES");
 616         if (file == NULL || (fp = fopen(file, "rce")) == NULL)
 617                 return (NULL);
 618         setbuf(fp, NULL);
 619         buf[sizeof(buf) - 1] = '\0';
 620         while (fgets(buf, sizeof(buf), fp)) {
 621                 for (cp1 = buf; *cp1 && !isspace(*cp1); ++cp1)
 622                         ;
 623                 if (!*cp1)
 624                         break;
 625                 *cp1 = '\0';
 626                 if (ns_samename(buf, name) == 1) {
 627                         while (isspace(*++cp1))
 628                                 ;
 629                         if (!*cp1)
 630                                 break;
 631                         for (cp2 = cp1 + 1; *cp2 && !isspace(*cp2); ++cp2)
 632                                 ;
 633                         *cp2 = '\0';
 634                         strncpy(dst, cp1, siz - 1);
 635                         dst[siz - 1] = '\0';
 636                         fclose(fp);
 637                         return (dst);
 638                 }
 639         }
 640         fclose(fp);
 641         return (NULL);
 642 }
 643 libresolv_hidden_def (res_hostalias)