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, int32_t *ttlp, char **canonp);
 129
 130 extern enum nss_status _nss_dns_gethostbyname3_r (const char *name, int af,
 131                                                   struct hostent *result,
 132                                                   char *buffer, size_t buflen,
 133                                                   int *errnop, int *h_errnop,
 134                                                   int32_t *ttlp,
 135                                                   char **canonp);
 136 hidden_proto (_nss_dns_gethostbyname3_r)
 137
 138 enum nss_status
 139 _nss_dns_gethostbyname3_r (const char *name, int af, struct hostent *result,
 140                            char *buffer, size_t buflen, int *errnop,
 141                            int *h_errnop, int32_t *ttlp, char **canonp)
 142 {
 143   union
 144   {
 145     querybuf *buf;
 146     u_char *ptr;
 147   } host_buffer;
 148   querybuf *orig_host_buffer;
 149   char tmp[NS_MAXDNAME];
 150   int size, type, n;
 151   const char *cp;
 152   int map = 0;
 153   int olderr = errno;
 154   enum nss_status status;
 155
 156   if (__res_maybe_init (&_res, 0) == -1)
 157     return NSS_STATUS_UNAVAIL;
 158
 159   switch (af) {
 160   case AF_INET:
 161     size = INADDRSZ;
 162     type = T_A;
 163     break;
 164   case AF_INET6:
 165     size = IN6ADDRSZ;
 166     type = T_AAAA;
 167     break;
 168   default:
 169     *h_errnop = NO_DATA;
 170     *errnop = EAFNOSUPPORT;
 171     return NSS_STATUS_UNAVAIL;
 172   }
 173
 174   result->h_addrtype = af;
 175   result->h_length = size;
 176
 177   /*
 178    * if there aren't any dots, it could be a user-level alias.
 179    * this is also done in res_query() since we are not the only
 180    * function that looks up host names.
 181    */
 182   if (strchr (name, '.') == NULL
 183       && (cp = res_hostalias (&_res, name, tmp, sizeof (tmp))) != NULL)
 184     name = cp;
 185
 186   host_buffer.buf = orig_host_buffer = (querybuf *) alloca (1024);
 187
 188   n = __libc_res_nsearch (&_res, name, C_IN, type, host_buffer.buf->buf,
 189                           1024, &host_buffer.ptr);
 190   if (n < 0)
 191     {
 192       enum nss_status status = (errno == ECONNREFUSED
 193                                 ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND);
 194       *h_errnop = h_errno;
 195       if (h_errno == TRY_AGAIN)
 196         *errnop = EAGAIN;
 197       else
 198         __set_errno (olderr);
 199
 200       /* If we are looking for a IPv6 address and mapping is enabled
 201          by having the RES_USE_INET6 bit in _res.options set, we try
 202          another lookup.  */
 203       if (af == AF_INET6 && (_res.options & RES_USE_INET6))
 204         n = __libc_res_nsearch (&_res, name, C_IN, T_A, host_buffer.buf->buf,
 205                                 host_buffer.buf != orig_host_buffer
 206                                 ? MAXPACKET : 1024, &host_buffer.ptr);
 207
 208       if (n < 0)
 209         {
 210           if (host_buffer.buf != orig_host_buffer)
 211             free (host_buffer.buf);
 212           return status;
 213         }
 214
 215       map = 1;
 216
 217       result->h_addrtype = AF_INET;
 218       result->h_length = INADDRSZ;;
 219     }
 220
 221   status = getanswer_r (host_buffer.buf, n, name, type, result, buffer, buflen,
 222                         errnop, h_errnop, map, ttlp, canonp);
 223   if (host_buffer.buf != orig_host_buffer)
 224     free (host_buffer.buf);
 225   return status;
 226 }
 227 hidden_def (_nss_dns_gethostbyname3_r)
 228
 229
 230 enum nss_status
 231 _nss_dns_gethostbyname2_r (const char *name, int af, struct hostent *result,
 232                            char *buffer, size_t buflen, int *errnop,
 233                            int *h_errnop)
 234 {
 235   return _nss_dns_gethostbyname3_r (name, af, result, buffer, buflen, errnop,
 236                                     h_errnop, NULL, NULL);
 237 }
 238
 239
 240 enum nss_status
 241 _nss_dns_gethostbyname_r (const char *name, struct hostent *result,
 242                           char *buffer, size_t buflen, int *errnop,
 243                           int *h_errnop)
 244 {
 245   enum nss_status status = NSS_STATUS_NOTFOUND;
 246
 247   if (_res.options & RES_USE_INET6)
 248     status = _nss_dns_gethostbyname3_r (name, AF_INET6, result, buffer,
 249                                         buflen, errnop, h_errnop, NULL, NULL);
 250   if (status == NSS_STATUS_NOTFOUND)
 251     status = _nss_dns_gethostbyname3_r (name, AF_INET, result, buffer,
 252                                         buflen, errnop, h_errnop, NULL, NULL);
 253
 254   return status;
 255 }
 256
 257
 258 enum nss_status
 259 _nss_dns_gethostbyaddr_r (const void *addr, socklen_t len, int af,
 260                           struct hostent *result, char *buffer, size_t buflen,
 261                           int *errnop, int *h_errnop)
 262 {
 263   static const u_char mapped[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };
 264   static const u_char tunnelled[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 };
 265   static const u_char v6local[] = { 0,0, 0,1 };
 266   const u_char *uaddr = (const u_char *)addr;
 267   struct host_data
 268   {
 269     char *aliases[MAX_NR_ALIASES];
 270     unsigned char host_addr[16];        /* IPv4 or IPv6 */
 271     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
 272     char linebuffer[0];
 273   } *host_data = (struct host_data *) buffer;
 274   union
 275   {
 276     querybuf *buf;
 277     u_char *ptr;
 278   } host_buffer;
 279   querybuf *orig_host_buffer;
 280   char qbuf[MAXDNAME+1], *qp = NULL;
 281   size_t size;
 282   int n, status;
 283   int olderr = errno;
 284
 285   if (__res_maybe_init (&_res, 0) == -1)
 286     return NSS_STATUS_UNAVAIL;
 287
 288   if (af == AF_INET6 && len == IN6ADDRSZ
 289       && (memcmp (uaddr, mapped, sizeof mapped) == 0
 290           || (memcmp (uaddr, tunnelled, sizeof tunnelled) == 0
 291               && memcmp (&uaddr[sizeof tunnelled], v6local, sizeof v6local))))
 292     {
 293       /* Unmap. */
 294       addr += sizeof mapped;
 295       uaddr += sizeof mapped;
 296       af = AF_INET;
 297       len = INADDRSZ;
 298     }
 299
 300   switch (af)
 301     {
 302     case AF_INET:
 303       size = INADDRSZ;
 304       break;
 305     case AF_INET6:
 306       size = IN6ADDRSZ;
 307       break;
 308     default:
 309       *errnop = EAFNOSUPPORT;
 310       *h_errnop = NETDB_INTERNAL;
 311       return NSS_STATUS_UNAVAIL;
 312     }
 313   if (size > len)
 314     {
 315       *errnop = EAFNOSUPPORT;
 316       *h_errnop = NETDB_INTERNAL;
 317       return NSS_STATUS_UNAVAIL;
 318     }
 319
 320   host_buffer.buf = orig_host_buffer = (querybuf *) alloca (1024);
 321
 322   switch (af)
 323     {
 324     case AF_INET:
 325       sprintf (qbuf, "%u.%u.%u.%u.in-addr.arpa", (uaddr[3] & 0xff),
 326                (uaddr[2] & 0xff), (uaddr[1] & 0xff), (uaddr[0] & 0xff));
 327       break;
 328     case AF_INET6:
 329       /* Only lookup with the byte string format if the user wants it.  */
 330       if (__builtin_expect (_res.options & RES_USEBSTRING, 0))
 331         {
 332           qp = stpcpy (qbuf, "\\[x");
 333           for (n = 0; n < IN6ADDRSZ; ++n)
 334             qp += sprintf (qp, "%02hhx", uaddr[n]);
 335           strcpy (qp, "].ip6.arpa");
 336           n = __libc_res_nquery (&_res, qbuf, C_IN, T_PTR,
 337                                  host_buffer.buf->buf, 1024, &host_buffer.ptr);
 338           if (n >= 0)
 339             goto got_it_already;
 340         }
 341       qp = qbuf;
 342       for (n = IN6ADDRSZ - 1; n >= 0; n--)
 343         {
 344           static const char nibblechar[16] = "0123456789abcdef";
 345           *qp++ = nibblechar[uaddr[n] & 0xf];
 346           *qp++ = '.';
 347           *qp++ = nibblechar[(uaddr[n] >> 4) & 0xf];
 348           *qp++ = '.';
 349         }
 350       strcpy(qp, "ip6.arpa");
 351       break;
 352     default:
 353       /* Cannot happen.  */
 354       break;
 355     }
 356
 357   n = __libc_res_nquery (&_res, qbuf, C_IN, T_PTR, host_buffer.buf->buf,
 358                          1024, &host_buffer.ptr);
 359   if (n < 0 && af == AF_INET6 && (_res.options & RES_NOIP6DOTINT) == 0)
 360     {
 361       strcpy (qp, "ip6.int");
 362       n = __libc_res_nquery (&_res, qbuf, C_IN, T_PTR, host_buffer.buf->buf,
 363                              host_buffer.buf != orig_host_buffer
 364                              ? MAXPACKET : 1024, &host_buffer.ptr);
 365     }
 366   if (n < 0)
 367     {
 368       *h_errnop = h_errno;
 369       __set_errno (olderr);
 370       if (host_buffer.buf != orig_host_buffer)
 371         free (host_buffer.buf);
 372       return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
 373     }
 374
 375  got_it_already:
 376   status = getanswer_r (host_buffer.buf, n, qbuf, T_PTR, result, buffer, buflen,
 377                         errnop, h_errnop, 0 /* XXX */, NULL, NULL);
 378   if (host_buffer.buf != orig_host_buffer)
 379     free (host_buffer.buf);
 380   if (status != NSS_STATUS_SUCCESS)
 381     {
 382       *h_errnop = h_errno;
 383       *errnop = errno;
 384       return status;
 385     }
 386
 387 #ifdef SUNSECURITY
 388   This is not implemented because it is not possible to use the current
 389   source from bind in a multi-threaded program.
 390 #endif
 391
 392   result->h_addrtype = af;
 393   result->h_length = len;
 394   memcpy (host_data->host_addr, addr, len);
 395   host_data->h_addr_ptrs[0] = (char *) host_data->host_addr;
 396   host_data->h_addr_ptrs[1] = NULL;
 397 #if 0
 398   /* XXX I think this is wrong.  Why should an IPv4 address be
 399      converted to IPv6 if the user explicitly asked for IPv4?  */
 400   if (af == AF_INET && (_res.options & RES_USE_INET6))
 401     {
 402       map_v4v6_address ((char *) host_data->host_addr,
 403                         (char *) host_data->host_addr);
 404       result->h_addrtype = AF_INET6;
 405       result->h_length = IN6ADDRSZ;
 406     }
 407 #endif
 408   *h_errnop = NETDB_SUCCESS;
 409   return NSS_STATUS_SUCCESS;
 410 }
 411
 412 #ifdef RESOLVSORT
 413 static void addrsort (char **ap, int num);
 414
 415 static void
 416 addrsort (char **ap, int num)
 417 {
 418   int i, j;
 419   char **p;
 420   short aval[MAX_NR_ADDRS];
 421   int needsort = 0;
 422
 423   p = ap;
 424   if (num > MAX_NR_ADDRS)
 425     num = MAX_NR_ADDRS;
 426   for (i = 0; i < num; i++, p++)
 427     {
 428       for (j = 0 ; (unsigned)j < _res.nsort; j++)
 429         if (_res.sort_list[j].addr.s_addr ==
 430             (((struct in_addr *)(*p))->s_addr & _res.sort_list[j].mask))
 431           break;
 432       aval[i] = j;
 433       if (needsort == 0 && i > 0 && j < aval[i-1])
 434         needsort = i;
 435     }
 436   if (!needsort)
 437     return;
 438
 439   while (needsort++ < num)
 440     for (j = needsort - 2; j >= 0; j--)
 441       if (aval[j] > aval[j+1])
 442         {
 443           char *hp;
 444
 445           i = aval[j];
 446           aval[j] = aval[j+1];
 447           aval[j+1] = i;
 448
 449           hp = ap[j];
 450           ap[j] = ap[j+1];
 451           ap[j+1] = hp;
 452         }
 453       else
 454         break;
 455 }
 456 #endif
 457
 458 static enum nss_status
 459 getanswer_r (const querybuf *answer, int anslen, const char *qname, int qtype,
 460              struct hostent *result, char *buffer, size_t buflen,
 461              int *errnop, int *h_errnop, int map, int32_t *ttlp, char **canonp)
 462 {
 463   struct host_data
 464   {
 465     char *aliases[MAX_NR_ALIASES];
 466     unsigned char host_addr[16];        /* IPv4 or IPv6 */
 467     char *h_addr_ptrs[0];
 468   } *host_data = (struct host_data *) buffer;
 469   int linebuflen = buflen - sizeof (struct host_data);
 470   register const HEADER *hp;
 471   const u_char *end_of_message, *cp;
 472   int n, ancount, qdcount;
 473   int haveanswer, had_error;
 474   char *bp, **ap, **hap;
 475   char tbuf[MAXDNAME];
 476   const char *tname;
 477   int (*name_ok) (const char *);
 478   u_char packtmp[NS_MAXCDNAME];
 479   int have_to_map = 0;
 480   int32_t ttl = 0;
 481
 482   if (__builtin_expect (linebuflen, 0) < 0)
 483     {
 484       /* The buffer is too small.  */
 485     too_small:
 486       *errnop = ERANGE;
 487       *h_errnop = NETDB_INTERNAL;
 488       return NSS_STATUS_TRYAGAIN;
 489     }
 490
 491   tname = qname;
 492   result->h_name = NULL;
 493   end_of_message = answer->buf + anslen;
 494   switch (qtype)
 495     {
 496     case T_A:
 497     case T_AAAA:
 498       name_ok = res_hnok;
 499       break;
 500     case T_PTR:
 501       name_ok = res_dnok;
 502       break;
 503     default:
 504       *errnop = ENOENT;
 505       return NSS_STATUS_UNAVAIL;  /* XXX should be abort(); */
 506     }
 507
 508   /*
 509    * find first satisfactory answer
 510    */
 511   hp = &answer->hdr;
 512   ancount = ntohs (hp->ancount);
 513   qdcount = ntohs (hp->qdcount);
 514   cp = answer->buf + HFIXEDSZ;
 515   if (__builtin_expect (qdcount, 1) != 1)
 516     {
 517       *h_errnop = NO_RECOVERY;
 518       return NSS_STATUS_UNAVAIL;
 519     }
 520   if (sizeof (struct host_data) + (ancount + 1) * sizeof (char *) >= buflen)
 521     goto too_small;
 522   bp = (char *) &host_data->h_addr_ptrs[ancount + 1];
 523   linebuflen -= (ancount + 1) * sizeof (char *);
 524
 525   n = __ns_name_unpack (answer->buf, end_of_message, cp,
 526                         packtmp, sizeof packtmp);
 527   if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
 528     {
 529       if (__builtin_expect (errno, 0) == EMSGSIZE)
 530         goto too_small;
 531
 532       n = -1;
 533     }
 534
 535   if (n > 0 && bp[0] == '.')
 536     bp[0] = '\0';
 537
 538   if (n < 0 || (*name_ok) (bp) == 0)
 539     {
 540       *errnop = errno;
 541       *h_errnop = NO_RECOVERY;
 542       return NSS_STATUS_UNAVAIL;
 543     }
 544   cp += n + QFIXEDSZ;
 545
 546   if (qtype == T_A || qtype == T_AAAA)
 547     {
 548       /* res_send() has already verified that the query name is the
 549        * same as the one we sent; this just gets the expanded name
 550        * (i.e., with the succeeding search-domain tacked on).
 551        */
 552       n = strlen (bp) + 1;             /* for the \0 */
 553       if (n >= MAXHOSTNAMELEN)
 554         {
 555           *h_errnop = NO_RECOVERY;
 556           *errnop = ENOENT;
 557           return NSS_STATUS_TRYAGAIN;
 558         }
 559       result->h_name = bp;
 560       bp += n;
 561       linebuflen -= n;
 562       if (linebuflen < 0)
 563         goto too_small;
 564       /* The qname can be abbreviated, but h_name is now absolute. */
 565       qname = result->h_name;
 566     }
 567
 568   ap = host_data->aliases;
 569   *ap = NULL;
 570   result->h_aliases = host_data->aliases;
 571   hap = host_data->h_addr_ptrs;
 572   *hap = NULL;
 573   result->h_addr_list = host_data->h_addr_ptrs;
 574   haveanswer = 0;
 575   had_error = 0;
 576
 577   while (ancount-- > 0 && cp < end_of_message && had_error == 0)
 578     {
 579       int type, class;
 580
 581       n = __ns_name_unpack (answer->buf, end_of_message, cp,
 582                             packtmp, sizeof packtmp);
 583       if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
 584         {
 585           if (__builtin_expect (errno, 0) == EMSGSIZE)
 586             goto too_small;
 587
 588           n = -1;
 589         }
 590
 591       if (n < 0 || (*name_ok) (bp) == 0)
 592         {
 593           ++had_error;
 594           continue;
 595         }
 596       cp += n;                          /* name */
 597       type = ns_get16 (cp);
 598       cp += INT16SZ;                    /* type */
 599       class = ns_get16 (cp);
 600       cp += INT16SZ;                    /* class */
 601       ttl = ns_get32 (cp);
 602       cp += INT32SZ;                    /* TTL */
 603       n = ns_get16 (cp);
 604       cp += INT16SZ;                    /* len */
 605       if (class != C_IN)
 606         {
 607           /* XXX - debug? syslog? */
 608           cp += n;
 609           continue;                     /* XXX - had_error++ ? */
 610         }
 611
 612       if ((qtype ==T_A || qtype == T_AAAA) && type == T_CNAME)
 613         {
 614           if (ap >= &host_data->aliases[MAX_NR_ALIASES - 1])
 615             continue;
 616           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
 617           if (n < 0 || (*name_ok) (tbuf) == 0)
 618             {
 619               ++had_error;
 620               continue;
 621             }
 622           cp += n;
 623           /* Store alias.  */
 624           *ap++ = bp;
 625           n = strlen (bp) + 1;          /* For the \0.  */
 626           if (__builtin_expect (n, 0) >= MAXHOSTNAMELEN)
 627             {
 628               ++had_error;
 629               continue;
 630             }
 631           bp += n;
 632           linebuflen -= n;
 633           /* Get canonical name.  */
 634           n = strlen (tbuf) + 1;        /* For the \0.  */
 635           if (__builtin_expect (n > linebuflen, 0))
 636             goto too_small;
 637           if (__builtin_expect (n, 0) >= MAXHOSTNAMELEN)
 638             {
 639               ++had_error;
 640               continue;
 641             }
 642           result->h_name = bp;
 643           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
 644           linebuflen -= n;
 645           continue;
 646         }
 647
 648       if (qtype == T_PTR && type == T_CNAME)
 649         {
 650           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
 651           if (n < 0 || res_dnok (tbuf) == 0)
 652             {
 653               ++had_error;
 654               continue;
 655             }
 656           cp += n;
 657           /* Get canonical name.  */
 658           n = strlen (tbuf) + 1;   /* For the \0.  */
 659           if (__builtin_expect (n > linebuflen, 0))
 660             goto too_small;
 661           if (__builtin_expect (n, 0) >= MAXHOSTNAMELEN)
 662             {
 663               ++had_error;
 664               continue;
 665             }
 666           tname = bp;
 667           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
 668           linebuflen -= n;
 669           continue;
 670         }
 671       if (__builtin_expect (type == T_SIG, 0)
 672           || __builtin_expect (type == T_KEY, 0)
 673           || __builtin_expect (type == T_NXT, 0))
 674         {
 675           /* We don't support DNSSEC yet.  For now, ignore the record
 676              and send a low priority message to syslog.  */
 677           syslog (LOG_DEBUG | LOG_AUTH,
 678                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
 679                   qname, p_class (C_IN), p_type(qtype), p_type (type));
 680           cp += n;
 681           continue;
 682         }
 683
 684       if (type == T_A && qtype == T_AAAA && map)
 685         have_to_map = 1;
 686       else if (__builtin_expect (type != qtype, 0))
 687         {
 688           syslog (LOG_NOTICE | LOG_AUTH,
 689                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
 690                   qname, p_class (C_IN), p_type (qtype), p_type (type));
 691           cp += n;
 692           continue;                     /* XXX - had_error++ ? */
 693         }
 694
 695       switch (type)
 696         {
 697         case T_PTR:
 698           if (__strcasecmp (tname, bp) != 0)
 699             {
 700               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, qname, bp);
 701               cp += n;
 702               continue;                 /* XXX - had_error++ ? */
 703             }
 704
 705           n = __ns_name_unpack (answer->buf, end_of_message, cp,
 706                                 packtmp, sizeof packtmp);
 707           if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
 708             {
 709               if (__builtin_expect (errno, 0) == EMSGSIZE)
 710                 goto too_small;
 711
 712               n = -1;
 713             }
 714
 715           if (n < 0 || res_hnok (bp) == 0)
 716             {
 717               ++had_error;
 718               break;
 719             }
 720 #if MULTI_PTRS_ARE_ALIASES
 721           cp += n;
 722           if (haveanswer == 0)
 723             result->h_name = bp;
 724           else if (ap < &host_data->aliases[MAXALIASES-1])
 725             *ap++ = bp;
 726           else
 727             n = -1;
 728           if (n != -1)
 729             {
 730               n = strlen (bp) + 1;      /* for the \0 */
 731               if (__builtin_expect (n, 0) >= MAXHOSTNAMELEN)
 732                 {
 733                   ++had_error;
 734                   break;
 735                 }
 736               bp += n;
 737               linebuflen -= n;
 738             }
 739           break;
 740 #else
 741           result->h_name = bp;
 742           if (have_to_map)
 743             {
 744               n = strlen (bp) + 1;      /* for the \0 */
 745               if (n >= MAXHOSTNAMELEN)
 746                 {
 747                   ++had_error;
 748                   break;
 749                 }
 750               bp += n;
 751               linebuflen -= n;
 752               map_v4v6_hostent (result, &bp, &linebuflen);
 753             }
 754           *h_errnop = NETDB_SUCCESS;
 755           return NSS_STATUS_SUCCESS;
 756 #endif
 757         case T_A:
 758         case T_AAAA:
 759           if (__builtin_expect (strcasecmp (result->h_name, bp), 0) != 0)
 760             {
 761               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, result->h_name, bp);
 762               cp += n;
 763               continue;                 /* XXX - had_error++ ? */
 764             }
 765           if (n != result->h_length)
 766             {
 767               cp += n;
 768               continue;
 769             }
 770           if (!haveanswer)
 771             {
 772               register int nn;
 773
 774               if (ttlp != NULL && ttl != 0)
 775                 *ttlp = ttl;
 776               if (canonp != NULL)
 777                 *canonp = bp;
 778               result->h_name = bp;
 779               nn = strlen (bp) + 1;     /* for the \0 */
 780               bp += nn;
 781               linebuflen -= nn;
 782             }
 783
 784           linebuflen -= sizeof (align) - ((u_long) bp % sizeof (align));
 785           bp += sizeof (align) - ((u_long) bp % sizeof (align));
 786
 787           if (__builtin_expect (n > linebuflen, 0))
 788             goto too_small;
 789           bp = __mempcpy (*hap++ = bp, cp, n);
 790           cp += n;
 791           linebuflen -= n;
 792           break;
 793         default:
 794           abort ();
 795         }
 796       if (had_error == 0)
 797         ++haveanswer;
 798     }
 799
 800   if (haveanswer > 0)
 801     {
 802       *ap = NULL;
 803       *hap = NULL;
 804 #if defined RESOLVSORT
 805       /*
 806        * Note: we sort even if host can take only one address
 807        * in its return structures - should give it the "best"
 808        * address in that case, not some random one
 809        */
 810       if (_res.nsort && haveanswer > 1 && qtype == T_A)
 811         addrsort (host_data->h_addr_ptrs, haveanswer);
 812 #endif /*RESOLVSORT*/
 813
 814       if (result->h_name == NULL)
 815         {
 816           n = strlen (qname) + 1;       /* For the \0.  */
 817           if (n > linebuflen)
 818             goto too_small;
 819           if (n >= MAXHOSTNAMELEN)
 820             goto no_recovery;
 821           result->h_name = bp;
 822           bp = __mempcpy (bp, qname, n);        /* Cannot overflow.  */
 823           linebuflen -= n;
 824         }
 825
 826       if (have_to_map)
 827         map_v4v6_hostent (result, &bp, &linebuflen);
 828       *h_errnop = NETDB_SUCCESS;
 829       return NSS_STATUS_SUCCESS;
 830     }
 831  no_recovery:
 832   *h_errnop = NO_RECOVERY;
 833   *errnop = ENOENT;
 834   return NSS_STATUS_TRYAGAIN;
 835 }