resolv/nss_dns/dns-host.c

   1 /* Copyright (C) 1996-2003, 2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Extended from original form by Ulrich Drepper <drepper@cygnus.com>, 1996.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 /* Parts of this file are plain copies of the file `gethtnamadr.c' from
  21    the bind package and it has the following copyright.  */
  22
  23 /*
  24  * ++Copyright++ 1985, 1988, 1993
  25  * -
  26  * Copyright (c) 1985, 1988, 1993
  27  *    The Regents of the University of California.  All rights reserved.
  28  *
  29  * Redistribution and use in source and binary forms, with or without
  30  * modification, are permitted provided that the following conditions
  31  * are met:
  32  * 1. Redistributions of source code must retain the above copyright
  33  *    notice, this list of conditions and the following disclaimer.
  34  * 2. Redistributions in binary form must reproduce the above copyright
  35  *    notice, this list of conditions and the following disclaimer in the
  36  *    documentation and/or other materials provided with the distribution.
  37  * 4. Neither the name of the University nor the names of its contributors
  38  *    may be used to endorse or promote products derived from this software
  39  *    without specific prior written permission.
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  * -
  53  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  54  *
  55  * Permission to use, copy, modify, and distribute this software for any
  56  * purpose with or without fee is hereby granted, provided that the above
  57  * copyright notice and this permission notice appear in all copies, and that
  58  * the name of Digital Equipment Corporation not be used in advertising or
  59  * publicity pertaining to distribution of the document or software without
  60  * specific, written prior permission.
  61  *
  62  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  63  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  64  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  65  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  66  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  67  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  68  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  69  * SOFTWARE.
  70  * -
  71  * --Copyright--
  72  */
  73
  74 #include <ctype.h>
  75 #include <errno.h>
  76 #include <netdb.h>
  77 #include <stdio.h>
  78 #include <stdlib.h>
  79 #include <stddef.h>
  80 #include <string.h>
  81 #include <sys/syslog.h>
  82
  83 #include "nsswitch.h"
  84
  85 /* Get implementation for some internal functions.  */
  86 #include <resolv/mapv4v6addr.h>
  87 #include <resolv/mapv4v6hostent.h>
  88
  89 #define RESOLVSORT
  90
  91 /* Maximum number of aliases we allow.  */
  92 #define MAX_NR_ALIASES  48
  93 #define MAX_NR_ADDRS    48
  94
  95 #if PACKETSZ > 65536
  96 # define MAXPACKET      PACKETSZ
  97 #else
  98 # define MAXPACKET      65536
  99 #endif
 100 /* As per RFC 1034 and 1035 a host name cannot exceed 255 octets in length.  */
 101 #ifdef MAXHOSTNAMELEN
 102 # undef MAXHOSTNAMELEN
 103 #endif
 104 #define MAXHOSTNAMELEN 256
 105
 106 static const char AskedForGot[] = "\
 107 gethostby*.getanswer: asked for \"%s\", got \"%s\"";
 108
 109
 110 /* We need this time later.  */
 111 typedef union querybuf
 112 {
 113   HEADER hdr;
 114   u_char buf[MAXPACKET];
 115 } querybuf;
 116
 117 /* These functions are defined in res_comp.c.  */
 118 #define NS_MAXCDNAME    255     /* maximum compressed domain name */
 119 extern int __ns_name_ntop (const u_char *, char *, size_t);
 120 extern int __ns_name_unpack (const u_char *, const u_char *,
 121                              const u_char *, u_char *, size_t);
 122
 123
 124 static enum nss_status getanswer_r (const querybuf *answer, int anslen,
 125                                     const char *qname, int qtype,
 126                                     struct hostent *result, char *buffer,
 127                                     size_t buflen, int *errnop, int *h_errnop,
 128                                     int map);
 129
 130 enum nss_status
 131 _nss_dns_gethostbyname2_r (const char *name, int af, struct hostent *result,
 132                            char *buffer, size_t buflen, int *errnop,
 133                            int *h_errnop)
 134 {
 135   union
 136   {
 137     querybuf *buf;
 138     u_char *ptr;
 139   } host_buffer;
 140   querybuf *orig_host_buffer;
 141   char tmp[NS_MAXDNAME];
 142   int size, type, n;
 143   const char *cp;
 144   int map = 0;
 145   int olderr = errno;
 146   enum nss_status status;
 147
 148   if ((_res.options & RES_INIT) == 0 && __res_ninit (&_res) == -1)
 149     return NSS_STATUS_UNAVAIL;
 150
 151   switch (af) {
 152   case AF_INET:
 153     size = INADDRSZ;
 154     type = T_A;
 155     break;
 156   case AF_INET6:
 157     size = IN6ADDRSZ;
 158     type = T_AAAA;
 159     break;
 160   default:
 161     *h_errnop = NO_DATA;
 162     *errnop = EAFNOSUPPORT;
 163     return NSS_STATUS_UNAVAIL;
 164   }
 165
 166   result->h_addrtype = af;
 167   result->h_length = size;
 168
 169   /*
 170    * if there aren't any dots, it could be a user-level alias.
 171    * this is also done in res_query() since we are not the only
 172    * function that looks up host names.
 173    */
 174   if (strchr (name, '.') == NULL
 175       && (cp = res_hostalias (&_res, name, tmp, sizeof (tmp))) != NULL)
 176     name = cp;
 177
 178   host_buffer.buf = orig_host_buffer = (querybuf *) alloca (1024);
 179
 180   n = __libc_res_nsearch (&_res, name, C_IN, type, host_buffer.buf->buf,
 181                           1024, &host_buffer.ptr);
 182   if (n < 0)
 183     {
 184       enum nss_status status = (errno == ECONNREFUSED
 185                                 ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND);
 186       *h_errnop = h_errno;
 187       if (h_errno == TRY_AGAIN)
 188         *errnop = EAGAIN;
 189       else
 190         __set_errno (olderr);
 191
 192       /* If we are looking for a IPv6 address and mapping is enabled
 193          by having the RES_USE_INET6 bit in _res.options set, we try
 194          another lookup.  */
 195       if (af == AF_INET6 && (_res.options & RES_USE_INET6))
 196         n = __libc_res_nsearch (&_res, name, C_IN, T_A, host_buffer.buf->buf,
 197                                 host_buffer.buf != orig_host_buffer
 198                                 ? MAXPACKET : 1024, &host_buffer.ptr);
 199
 200       if (n < 0)
 201         {
 202           if (host_buffer.buf != orig_host_buffer)
 203             free (host_buffer.buf);
 204           return status;
 205         }
 206
 207       map = 1;
 208
 209       result->h_addrtype = AF_INET;
 210       result->h_length = INADDRSZ;;
 211     }
 212
 213   status = getanswer_r (host_buffer.buf, n, name, type, result, buffer, buflen,
 214                         errnop, h_errnop, map);
 215   if (host_buffer.buf != orig_host_buffer)
 216     free (host_buffer.buf);
 217   return status;
 218 }
 219
 220
 221 enum nss_status
 222 _nss_dns_gethostbyname_r (const char *name, struct hostent *result,
 223                           char *buffer, size_t buflen, int *errnop,
 224                           int *h_errnop)
 225 {
 226   enum nss_status status = NSS_STATUS_NOTFOUND;
 227
 228   if (_res.options & RES_USE_INET6)
 229     status = _nss_dns_gethostbyname2_r (name, AF_INET6, result, buffer,
 230                                         buflen, errnop, h_errnop);
 231   if (status == NSS_STATUS_NOTFOUND)
 232     status = _nss_dns_gethostbyname2_r (name, AF_INET, result, buffer,
 233                                         buflen, errnop, h_errnop);
 234
 235   return status;
 236 }
 237
 238
 239 enum nss_status
 240 _nss_dns_gethostbyaddr_r (const void *addr, socklen_t len, int af,
 241                           struct hostent *result, char *buffer, size_t buflen,
 242                           int *errnop, int *h_errnop)
 243 {
 244   static const u_char mapped[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };
 245   static const u_char tunnelled[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 };
 246   static const u_char v6local[] = { 0,0, 0,1 };
 247   const u_char *uaddr = (const u_char *)addr;
 248   struct host_data
 249   {
 250     char *aliases[MAX_NR_ALIASES];
 251     unsigned char host_addr[16];        /* IPv4 or IPv6 */
 252     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
 253     char linebuffer[0];
 254   } *host_data = (struct host_data *) buffer;
 255   union
 256   {
 257     querybuf *buf;
 258     u_char *ptr;
 259   } host_buffer;
 260   querybuf *orig_host_buffer;
 261   char qbuf[MAXDNAME+1], *qp = NULL;
 262   size_t size;
 263   int n, status;
 264   int olderr = errno;
 265
 266   if ((_res.options & RES_INIT) == 0 && __res_ninit (&_res) == -1)
 267     return NSS_STATUS_UNAVAIL;
 268
 269   if (af == AF_INET6 && len == IN6ADDRSZ
 270       && (memcmp (uaddr, mapped, sizeof mapped) == 0
 271           || (memcmp (uaddr, tunnelled, sizeof tunnelled) == 0
 272               && memcmp (&uaddr[sizeof tunnelled], v6local, sizeof v6local))))
 273     {
 274       /* Unmap. */
 275       addr += sizeof mapped;
 276       uaddr += sizeof mapped;
 277       af = AF_INET;
 278       len = INADDRSZ;
 279     }
 280
 281   switch (af)
 282     {
 283     case AF_INET:
 284       size = INADDRSZ;
 285       break;
 286     case AF_INET6:
 287       size = IN6ADDRSZ;
 288       break;
 289     default:
 290       *errnop = EAFNOSUPPORT;
 291       *h_errnop = NETDB_INTERNAL;
 292       return NSS_STATUS_UNAVAIL;
 293     }
 294   if (size > len)
 295     {
 296       *errnop = EAFNOSUPPORT;
 297       *h_errnop = NETDB_INTERNAL;
 298       return NSS_STATUS_UNAVAIL;
 299     }
 300
 301   host_buffer.buf = orig_host_buffer = (querybuf *) alloca (1024);
 302
 303   switch (af)
 304     {
 305     case AF_INET:
 306       sprintf (qbuf, "%u.%u.%u.%u.in-addr.arpa", (uaddr[3] & 0xff),
 307                (uaddr[2] & 0xff), (uaddr[1] & 0xff), (uaddr[0] & 0xff));
 308       break;
 309     case AF_INET6:
 310       /* Only lookup with the byte string format if the user wants it.  */
 311       if (__builtin_expect (_res.options & RES_USEBSTRING, 0))
 312         {
 313           qp = stpcpy (qbuf, "\\[x");
 314           for (n = 0; n < IN6ADDRSZ; ++n)
 315             qp += sprintf (qp, "%02hhx", uaddr[n]);
 316           strcpy (qp, "].ip6.arpa");
 317           n = __libc_res_nquery (&_res, qbuf, C_IN, T_PTR,
 318                                  host_buffer.buf->buf, 1024, &host_buffer.ptr);
 319           if (n >= 0)
 320             goto got_it_already;
 321         }
 322       qp = qbuf;
 323       for (n = IN6ADDRSZ - 1; n >= 0; n--)
 324         {
 325           static const char nibblechar[16] = "0123456789abcdef";
 326           *qp++ = nibblechar[uaddr[n] & 0xf];
 327           *qp++ = '.';
 328           *qp++ = nibblechar[(uaddr[n] >> 4) & 0xf];
 329           *qp++ = '.';
 330         }
 331       strcpy(qp, "ip6.arpa");
 332       break;
 333     default:
 334       /* Cannot happen.  */
 335       break;
 336     }
 337
 338   n = __libc_res_nquery (&_res, qbuf, C_IN, T_PTR, host_buffer.buf->buf,
 339                          1024, &host_buffer.ptr);
 340   if (n < 0 && af == AF_INET6)
 341     {
 342       strcpy (qp, "ip6.int");
 343       n = __libc_res_nquery (&_res, qbuf, C_IN, T_PTR, host_buffer.buf->buf,
 344                              host_buffer.buf != orig_host_buffer
 345                              ? MAXPACKET : 1024, &host_buffer.ptr);
 346     }
 347   if (n < 0)
 348     {
 349       *h_errnop = h_errno;
 350       __set_errno (olderr);
 351       if (host_buffer.buf != orig_host_buffer)
 352         free (host_buffer.buf);
 353       return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
 354     }
 355
 356  got_it_already:
 357   status = getanswer_r (host_buffer.buf, n, qbuf, T_PTR, result, buffer, buflen,
 358                         errnop, h_errnop, 0 /* XXX */);
 359   if (host_buffer.buf != orig_host_buffer)
 360     free (host_buffer.buf);
 361   if (status != NSS_STATUS_SUCCESS)
 362     {
 363       *h_errnop = h_errno;
 364       *errnop = errno;
 365       return status;
 366     }
 367
 368 #ifdef SUNSECURITY
 369   This is not implemented because it is not possible to use the current
 370   source from bind in a multi-threaded program.
 371 #endif
 372
 373   result->h_addrtype = af;
 374   result->h_length = len;
 375   memcpy (host_data->host_addr, addr, len);
 376   host_data->h_addr_ptrs[0] = (char *) host_data->host_addr;
 377   host_data->h_addr_ptrs[1] = NULL;
 378 #if 0
 379   /* XXX I think this is wrong.  Why should an IPv4 address be
 380      converted to IPv6 if the user explicitly asked for IPv4?  */
 381   if (af == AF_INET && (_res.options & RES_USE_INET6))
 382     {
 383       map_v4v6_address ((char *) host_data->host_addr,
 384                         (char *) host_data->host_addr);
 385       result->h_addrtype = AF_INET6;
 386       result->h_length = IN6ADDRSZ;
 387     }
 388 #endif
 389   *h_errnop = NETDB_SUCCESS;
 390   return NSS_STATUS_SUCCESS;
 391 }
 392
 393 #ifdef RESOLVSORT
 394 static void addrsort (char **ap, int num);
 395
 396 static void
 397 addrsort (char **ap, int num)
 398 {
 399   int i, j;
 400   char **p;
 401   short aval[MAX_NR_ADDRS];
 402   int needsort = 0;
 403
 404   p = ap;
 405   if (num > MAX_NR_ADDRS)
 406     num = MAX_NR_ADDRS;
 407   for (i = 0; i < num; i++, p++)
 408     {
 409       for (j = 0 ; (unsigned)j < _res.nsort; j++)
 410         if (_res.sort_list[j].addr.s_addr ==
 411             (((struct in_addr *)(*p))->s_addr & _res.sort_list[j].mask))
 412           break;
 413       aval[i] = j;
 414       if (needsort == 0 && i > 0 && j < aval[i-1])
 415         needsort = i;
 416     }
 417   if (!needsort)
 418     return;
 419
 420   while (needsort++ < num)
 421     for (j = needsort - 2; j >= 0; j--)
 422       if (aval[j] > aval[j+1])
 423         {
 424           char *hp;
 425
 426           i = aval[j];
 427           aval[j] = aval[j+1];
 428           aval[j+1] = i;
 429
 430           hp = ap[j];
 431           ap[j] = ap[j+1];
 432           ap[j+1] = hp;
 433         }
 434       else
 435         break;
 436 }
 437 #endif
 438
 439 static enum nss_status
 440 getanswer_r (const querybuf *answer, int anslen, const char *qname, int qtype,
 441              struct hostent *result, char *buffer, size_t buflen,
 442              int *errnop, int *h_errnop, int map)
 443 {
 444   struct host_data
 445   {
 446     char *aliases[MAX_NR_ALIASES];
 447     unsigned char host_addr[16];        /* IPv4 or IPv6 */
 448     char *h_addr_ptrs[0];
 449   } *host_data = (struct host_data *) buffer;
 450   int linebuflen = buflen - sizeof (struct host_data);
 451   register const HEADER *hp;
 452   const u_char *end_of_message, *cp;
 453   int n, ancount, qdcount;
 454   int haveanswer, had_error;
 455   char *bp, **ap, **hap;
 456   char tbuf[MAXDNAME];
 457   const char *tname;
 458   int (*name_ok) (const char *);
 459   u_char packtmp[NS_MAXCDNAME];
 460   int have_to_map = 0;
 461
 462   if (__builtin_expect (linebuflen, 0) < 0)
 463     {
 464       /* The buffer is too small.  */
 465     too_small:
 466       *errnop = ERANGE;
 467       *h_errnop = NETDB_INTERNAL;
 468       return NSS_STATUS_TRYAGAIN;
 469     }
 470
 471   tname = qname;
 472   result->h_name = NULL;
 473   end_of_message = answer->buf + anslen;
 474   switch (qtype)
 475     {
 476     case T_A:
 477     case T_AAAA:
 478       name_ok = res_hnok;
 479       break;
 480     case T_PTR:
 481       name_ok = res_dnok;
 482       break;
 483     default:
 484       *errnop = ENOENT;
 485       return NSS_STATUS_UNAVAIL;  /* XXX should be abort(); */
 486     }
 487
 488   /*
 489    * find first satisfactory answer
 490    */
 491   hp = &answer->hdr;
 492   ancount = ntohs (hp->ancount);
 493   qdcount = ntohs (hp->qdcount);
 494   cp = answer->buf + HFIXEDSZ;
 495   if (__builtin_expect (qdcount, 1) != 1)
 496     {
 497       *h_errnop = NO_RECOVERY;
 498       return NSS_STATUS_UNAVAIL;
 499     }
 500   if (sizeof (struct host_data) + (ancount + 1) * sizeof (char *) >= buflen)
 501     goto too_small;
 502   bp = (char *) &host_data->h_addr_ptrs[ancount + 1];
 503   linebuflen -= (ancount + 1) * sizeof (char *);
 504
 505   n = __ns_name_unpack (answer->buf, end_of_message, cp,
 506                         packtmp, sizeof packtmp);
 507   if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
 508     {
 509       if (__builtin_expect (errno, 0) == EMSGSIZE)
 510         goto too_small;
 511
 512       n = -1;
 513     }
 514
 515   if (n > 0 && bp[0] == '.')
 516     bp[0] = '\0';
 517
 518   if (n < 0 || (*name_ok) (bp) == 0)
 519     {
 520       *errnop = errno;
 521       *h_errnop = NO_RECOVERY;
 522       return NSS_STATUS_UNAVAIL;
 523     }
 524   cp += n + QFIXEDSZ;
 525
 526   if (qtype == T_A || qtype == T_AAAA)
 527     {
 528       /* res_send() has already verified that the query name is the
 529        * same as the one we sent; this just gets the expanded name
 530        * (i.e., with the succeeding search-domain tacked on).
 531        */
 532       n = strlen (bp) + 1;             /* for the \0 */
 533       if (n >= MAXHOSTNAMELEN)
 534         {
 535           *h_errnop = NO_RECOVERY;
 536           *errnop = ENOENT;
 537           return NSS_STATUS_TRYAGAIN;
 538         }
 539       result->h_name = bp;
 540       bp += n;
 541       linebuflen -= n;
 542       if (linebuflen < 0)
 543         goto too_small;
 544       /* The qname can be abbreviated, but h_name is now absolute. */
 545       qname = result->h_name;
 546     }
 547
 548   ap = host_data->aliases;
 549   *ap = NULL;
 550   result->h_aliases = host_data->aliases;
 551   hap = host_data->h_addr_ptrs;
 552   *hap = NULL;
 553   result->h_addr_list = host_data->h_addr_ptrs;
 554   haveanswer = 0;
 555   had_error = 0;
 556
 557   while (ancount-- > 0 && cp < end_of_message && had_error == 0)
 558     {
 559       int type, class;
 560
 561       n = __ns_name_unpack (answer->buf, end_of_message, cp,
 562                             packtmp, sizeof packtmp);
 563       if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
 564         {
 565           if (__builtin_expect (errno, 0) == EMSGSIZE)
 566             goto too_small;
 567
 568           n = -1;
 569         }
 570
 571       if (n < 0 || (*name_ok) (bp) == 0)
 572         {
 573           ++had_error;
 574           continue;
 575         }
 576       cp += n;                          /* name */
 577       type = ns_get16 (cp);
 578       cp += INT16SZ;                    /* type */
 579       class = ns_get16 (cp);
 580       cp += INT16SZ + INT32SZ;          /* class, TTL */
 581       n = ns_get16 (cp);
 582       cp += INT16SZ;                    /* len */
 583       if (class != C_IN)
 584         {
 585           /* XXX - debug? syslog? */
 586           cp += n;
 587           continue;                     /* XXX - had_error++ ? */
 588         }
 589
 590       if ((qtype ==T_A || qtype == T_AAAA) && type == T_CNAME)
 591         {
 592           if (ap >= &host_data->aliases[MAX_NR_ALIASES - 1])
 593             continue;
 594           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
 595           if (n < 0 || (*name_ok) (tbuf) == 0)
 596             {
 597               ++had_error;
 598               continue;
 599             }
 600           cp += n;
 601           /* Store alias.  */
 602           *ap++ = bp;
 603           n = strlen (bp) + 1;          /* For the \0.  */
 604           if (__builtin_expect (n, 0) >= MAXHOSTNAMELEN)
 605             {
 606               ++had_error;
 607               continue;
 608             }
 609           bp += n;
 610           linebuflen -= n;
 611           /* Get canonical name.  */
 612           n = strlen (tbuf) + 1;        /* For the \0.  */
 613           if (__builtin_expect (n > linebuflen, 0))
 614             goto too_small;
 615           if (__builtin_expect (n, 0) >= MAXHOSTNAMELEN)
 616             {
 617               ++had_error;
 618               continue;
 619             }
 620           result->h_name = bp;
 621           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
 622           linebuflen -= n;
 623           continue;
 624         }
 625
 626       if (qtype == T_PTR && type == T_CNAME)
 627         {
 628           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
 629           if (n < 0 || res_dnok (tbuf) == 0)
 630             {
 631               ++had_error;
 632               continue;
 633             }
 634           cp += n;
 635           /* Get canonical name.  */
 636           n = strlen (tbuf) + 1;   /* For the \0.  */
 637           if (__builtin_expect (n > linebuflen, 0))
 638             goto too_small;
 639           if (__builtin_expect (n, 0) >= MAXHOSTNAMELEN)
 640             {
 641               ++had_error;
 642               continue;
 643             }
 644           tname = bp;
 645           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
 646           linebuflen -= n;
 647           continue;
 648         }
 649       if (__builtin_expect (type == T_SIG, 0)
 650           || __builtin_expect (type == T_KEY, 0)
 651           || __builtin_expect (type == T_NXT, 0))
 652         {
 653           /* We don't support DNSSEC yet.  For now, ignore the record
 654              and send a low priority message to syslog.  */
 655           syslog (LOG_DEBUG | LOG_AUTH,
 656                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
 657                   qname, p_class (C_IN), p_type(qtype), p_type (type));
 658           cp += n;
 659           continue;
 660         }
 661
 662       if (type == T_A && qtype == T_AAAA && map)
 663         have_to_map = 1;
 664       else if (__builtin_expect (type != qtype, 0))
 665         {
 666           syslog (LOG_NOTICE | LOG_AUTH,
 667                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
 668                   qname, p_class (C_IN), p_type (qtype), p_type (type));
 669           cp += n;
 670           continue;                     /* XXX - had_error++ ? */
 671         }
 672
 673       switch (type)
 674         {
 675         case T_PTR:
 676           if (__strcasecmp (tname, bp) != 0)
 677             {
 678               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, qname, bp);
 679               cp += n;
 680               continue;                 /* XXX - had_error++ ? */
 681             }
 682
 683           n = __ns_name_unpack (answer->buf, end_of_message, cp,
 684                                 packtmp, sizeof packtmp);
 685           if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
 686             {
 687               if (__builtin_expect (errno, 0) == EMSGSIZE)
 688                 goto too_small;
 689
 690               n = -1;
 691             }
 692
 693           if (n < 0 || res_hnok (bp) == 0)
 694             {
 695               ++had_error;
 696               break;
 697             }
 698 #if MULTI_PTRS_ARE_ALIASES
 699           cp += n;
 700           if (haveanswer == 0)
 701             result->h_name = bp;
 702           else if (ap < &host_data->aliases[MAXALIASES-1])
 703             *ap++ = bp;
 704           else
 705             n = -1;
 706           if (n != -1)
 707             {
 708               n = strlen (bp) + 1;      /* for the \0 */
 709               if (__builtin_expect (n, 0) >= MAXHOSTNAMELEN)
 710                 {
 711                   ++had_error;
 712                   break;
 713                 }
 714               bp += n;
 715               linebuflen -= n;
 716             }
 717           break;
 718 #else
 719           result->h_name = bp;
 720           if (have_to_map)
 721             {
 722               n = strlen (bp) + 1;      /* for the \0 */
 723               if (n >= MAXHOSTNAMELEN)
 724                 {
 725                   ++had_error;
 726                   break;
 727                 }
 728               bp += n;
 729               linebuflen -= n;
 730               map_v4v6_hostent (result, &bp, &linebuflen);
 731             }
 732           *h_errnop = NETDB_SUCCESS;
 733           return NSS_STATUS_SUCCESS;
 734 #endif
 735         case T_A:
 736         case T_AAAA:
 737           if (__builtin_expect (strcasecmp (result->h_name, bp), 0) != 0)
 738             {
 739               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, result->h_name, bp);
 740               cp += n;
 741               continue;                 /* XXX - had_error++ ? */
 742             }
 743           if (n != result->h_length)
 744             {
 745               cp += n;
 746               continue;
 747             }
 748           if (!haveanswer)
 749             {
 750               register int nn;
 751
 752               result->h_name = bp;
 753               nn = strlen (bp) + 1;     /* for the \0 */
 754               bp += nn;
 755               linebuflen -= nn;
 756             }
 757
 758           linebuflen -= sizeof (align) - ((u_long) bp % sizeof (align));
 759           bp += sizeof (align) - ((u_long) bp % sizeof (align));
 760
 761           if (__builtin_expect (n > linebuflen, 0))
 762             goto too_small;
 763           bp = __mempcpy (*hap++ = bp, cp, n);
 764           cp += n;
 765           linebuflen -= n;
 766           break;
 767         default:
 768           abort ();
 769         }
 770       if (had_error == 0)
 771         ++haveanswer;
 772     }
 773
 774   if (haveanswer > 0)
 775     {
 776       *ap = NULL;
 777       *hap = NULL;
 778 #if defined RESOLVSORT
 779       /*
 780        * Note: we sort even if host can take only one address
 781        * in its return structures - should give it the "best"
 782        * address in that case, not some random one
 783        */
 784       if (_res.nsort && haveanswer > 1 && qtype == T_A)
 785         addrsort (host_data->h_addr_ptrs, haveanswer);
 786 #endif /*RESOLVSORT*/
 787
 788       if (result->h_name == NULL)
 789         {
 790           n = strlen (qname) + 1;       /* For the \0.  */
 791           if (n > linebuflen)
 792             goto too_small;
 793           if (n >= MAXHOSTNAMELEN)
 794             goto no_recovery;
 795           result->h_name = bp;
 796           bp = __mempcpy (bp, qname, n);        /* Cannot overflow.  */
 797           linebuflen -= n;
 798         }
 799
 800       if (have_to_map)
 801         map_v4v6_hostent (result, &bp, &linebuflen);
 802       *h_errnop = NETDB_SUCCESS;
 803       return NSS_STATUS_SUCCESS;
 804     }
 805  no_recovery:
 806   *h_errnop = NO_RECOVERY;
 807   *errnop = ENOENT;
 808   return NSS_STATUS_TRYAGAIN;
 809 }