resolv/nss_dns/dns-host.c

   1 /* Copyright (C) 1996, 1997 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 Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    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    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 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  * 3. All advertising materials mentioning features or use of this software
  38  *    must display the following acknowledgement:
  39  *      This product includes software developed by the University of
  40  *      California, Berkeley and its contributors.
  41  * 4. Neither the name of the University nor the names of its contributors
  42  *    may be used to endorse or promote products derived from this software
  43  *    without specific prior written permission.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  48  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  55  * SUCH DAMAGE.
  56  * -
  57  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  58  *
  59  * Permission to use, copy, modify, and distribute this software for any
  60  * purpose with or without fee is hereby granted, provided that the above
  61  * copyright notice and this permission notice appear in all copies, and that
  62  * the name of Digital Equipment Corporation not be used in advertising or
  63  * publicity pertaining to distribution of the document or software without
  64  * specific, written prior permission.
  65  *
  66  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  67  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  68  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  69  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  70  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  71  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  72  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  73  * SOFTWARE.
  74  * -
  75  * --Copyright--
  76  */
  77
  78 #include <ctype.h>
  79 #include <errno.h>
  80 #include <netdb.h>
  81 #include <stdio.h>
  82 #include <stdlib.h>
  83 #include <stddef.h>
  84 #include <string.h>
  85 #include <sys/syslog.h>
  86
  87 #include "nsswitch.h"
  88
  89 /* Get implementation for some internal functions.  */
  90 #include "../resolv/mapv4v6addr.h"
  91 #include "../resolv/mapv4v6hostent.h"
  92
  93 /* Maximum number of aliases we allow.  */
  94 #define MAX_NR_ALIASES  48
  95 #define MAX_NR_ADDRS    48
  96
  97 #if PACKETSZ > 1024
  98 # define MAXPACKET      PACKETSZ
  99 #else
 100 # define MAXPACKET      1024
 101 #endif
 102
 103 static const char AskedForGot[] = "\
 104 gethostby*.getanswer: asked for \"%s\", got \"%s\"";
 105
 106
 107 /* We need this time later.  */
 108 typedef union querybuf
 109 {
 110   HEADER hdr;
 111   u_char buf[MAXPACKET];
 112 } querybuf;
 113
 114
 115 static enum nss_status getanswer_r (const querybuf *answer, int anslen,
 116                                     const char *qname, int qtype,
 117                                     struct hostent *result, char *buffer,
 118                                     size_t buflen, int *h_errnop);
 119
 120 enum nss_status
 121 _nss_dns_gethostbyname2_r (const char *name, int af, struct hostent *result,
 122                            char *buffer, size_t buflen, int *h_errnop)
 123 {
 124   querybuf host_buffer;
 125   int size, type, n;
 126   const char *cp;
 127
 128   switch (af) {
 129   case AF_INET:
 130     size = INADDRSZ;
 131     type = T_A;
 132     break;
 133   case AF_INET6:
 134     size = IN6ADDRSZ;
 135     type = T_AAAA;
 136     break;
 137   default:
 138     *h_errnop = NETDB_INTERNAL;
 139     __set_errno (EAFNOSUPPORT);
 140     return NSS_STATUS_UNAVAIL;
 141   }
 142
 143   result->h_addrtype = af;
 144   result->h_length = size;
 145
 146   /*
 147    * if there aren't any dots, it could be a user-level alias.
 148    * this is also done in res_query() since we are not the only
 149    * function that looks up host names.
 150    */
 151   if (strchr (name, '.') == NULL && (cp = __hostalias (name)) != NULL)
 152     name = cp;
 153
 154   n = res_search (name, C_IN, type, host_buffer.buf, sizeof (host_buffer.buf));
 155   if (n < 0)
 156     return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
 157
 158   return getanswer_r (&host_buffer, n, name, type, result, buffer, buflen,
 159                       h_errnop);
 160 }
 161
 162
 163 enum nss_status
 164 _nss_dns_gethostbyname_r (const char *name, struct hostent *result,
 165                           char *buffer, size_t buflen, int *h_errnop)
 166 {
 167   enum nss_status status = NSS_STATUS_NOTFOUND;
 168
 169   if (_res.options & RES_USE_INET6)
 170     status = _nss_dns_gethostbyname2_r (name, AF_INET6, result, buffer,
 171                                         buflen, h_errnop);
 172   if (status == NSS_STATUS_NOTFOUND)
 173     status = _nss_dns_gethostbyname2_r (name, AF_INET, result, buffer,
 174                                         buflen, h_errnop);
 175
 176   return status;
 177 }
 178
 179
 180 enum nss_status
 181 _nss_dns_gethostbyaddr_r (const char *addr, int len, int af,
 182                           struct hostent *result, char *buffer, size_t buflen,
 183                           int *h_errnop)
 184 {
 185   static const u_char mapped[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };
 186   static const u_char tunnelled[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 };
 187   const u_char *uaddr = (const u_char *)addr;
 188   struct host_data
 189   {
 190     char *aliases[MAX_NR_ALIASES];
 191     unsigned char host_addr[16];        /* IPv4 or IPv6 */
 192     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
 193     char linebuffer[0];
 194   } *host_data = (struct host_data *) buffer;
 195   querybuf host_buffer;
 196   char qbuf[MAXDNAME+1], *qp;
 197   int size, n, status;
 198
 199   if (af == AF_INET6 && len == IN6ADDRSZ &&
 200       (memcmp (uaddr, mapped, sizeof mapped) == 0
 201        || memcmp (uaddr, tunnelled, sizeof tunnelled) == 0))
 202     {
 203       /* Unmap. */
 204       addr += sizeof mapped;
 205       uaddr += sizeof mapped;
 206       af = AF_INET;
 207       len = INADDRSZ;
 208     }
 209
 210   switch (af)
 211     {
 212     case AF_INET:
 213       size = INADDRSZ;
 214       break;
 215     case AF_INET6:
 216       size = IN6ADDRSZ;
 217       break;
 218     default:
 219       __set_errno (EAFNOSUPPORT);
 220       *h_errnop = NETDB_INTERNAL;
 221       return NSS_STATUS_UNAVAIL;
 222     }
 223   if (size != len)
 224     {
 225       __set_errno (EAFNOSUPPORT);
 226       *h_errnop = NETDB_INTERNAL;
 227       return NSS_STATUS_UNAVAIL;
 228     }
 229
 230   switch (af)
 231     {
 232     case AF_INET:
 233       sprintf (qbuf, "%u.%u.%u.%u.in-addr.arpa", (uaddr[3] & 0xff),
 234                (uaddr[2] & 0xff), (uaddr[1] & 0xff), (uaddr[0] & 0xff));
 235       break;
 236     case AF_INET6:
 237       qp = qbuf;
 238       for (n = IN6ADDRSZ - 1; n >= 0; n--)
 239         qp += sprintf (qp, "%x.%x.", uaddr[n] & 0xf, (uaddr[n] >> 4) & 0xf);
 240       strcpy(qp, "ip6.int");
 241       break;
 242     default:
 243       /* Cannot happen.  */
 244     }
 245
 246   n = res_query (qbuf, C_IN, T_PTR, (u_char *)host_buffer.buf,
 247                  sizeof host_buffer);
 248   if (n < 0)
 249     return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
 250
 251   status = getanswer_r (&host_buffer, n, qbuf, T_PTR, result, buffer, buflen,
 252                         h_errnop);
 253   if (status != NSS_STATUS_SUCCESS)
 254     return status;
 255
 256 #ifdef SUNSECURITY
 257   This is not implemented because it is not possible to use the current
 258   source from bind in a multi-threaded program.
 259 #endif
 260
 261   result->h_addrtype = af;
 262   result->h_length = len;
 263   memcpy (host_data->host_addr, addr, len);
 264   host_data->h_addr_ptrs[0] = (char *) host_data->host_addr;
 265   host_data->h_addr_ptrs[1] = NULL;
 266   if (af == AF_INET && (_res.options & RES_USE_INET6))
 267     {
 268       map_v4v6_address ((char *) host_data->host_addr,
 269                         (char *) host_data->host_addr);
 270       result->h_addrtype = AF_INET6;
 271       result->h_length = IN6ADDRSZ;
 272     }
 273   *h_errnop = NETDB_SUCCESS;
 274   return NSS_STATUS_SUCCESS;
 275 }
 276
 277
 278 static enum nss_status
 279 getanswer_r (const querybuf *answer, int anslen, const char *qname, int qtype,
 280              struct hostent *result, char *buffer, size_t buflen,
 281              int *h_errnop)
 282 {
 283   struct host_data
 284   {
 285     char *aliases[MAX_NR_ALIASES];
 286     unsigned char host_addr[16];        /* IPv4 or IPv6 */
 287     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
 288     char linebuffer[0];
 289   } *host_data = (struct host_data *) buffer;
 290   int linebuflen = buflen - offsetof (struct host_data, linebuffer);
 291   register const HEADER *hp;
 292   const u_char *end_of_message, *cp;
 293   int n, ancount, qdcount;
 294   int haveanswer, had_error;
 295   char *bp, **ap, **hap;
 296   char tbuf[MAXDNAME];
 297   const char *tname;
 298   int (*name_ok) __P ((const char *));
 299
 300   tname = qname;
 301   result->h_name = NULL;
 302   end_of_message = answer->buf + anslen;
 303   switch (qtype)
 304     {
 305     case T_A:
 306     case T_AAAA:
 307       name_ok = res_hnok;
 308       break;
 309     case T_PTR:
 310       name_ok = res_dnok;
 311       break;
 312     default:
 313       return NSS_STATUS_UNAVAIL;  /* XXX should be abort(); */
 314     }
 315
 316   /*
 317    * find first satisfactory answer
 318    */
 319   hp = &answer->hdr;
 320   bp = host_data->linebuffer;
 321   ancount = ntohs (hp->ancount);
 322   qdcount = ntohs (hp->qdcount);
 323   cp = answer->buf + HFIXEDSZ;
 324   if (qdcount != 1)
 325     {
 326       *h_errnop = NO_RECOVERY;
 327       return NSS_STATUS_UNAVAIL;
 328     }
 329
 330   n = dn_expand (answer->buf, end_of_message, cp, bp, linebuflen);
 331   if (n < 0 || (*name_ok) (bp) == 0)
 332     {
 333       *h_errnop = NO_RECOVERY;
 334       return NSS_STATUS_UNAVAIL;
 335     }
 336   cp += n + QFIXEDSZ;
 337
 338   if (qtype == T_A || qtype == T_AAAA)
 339     {
 340       /* res_send() has already verified that the query name is the
 341        * same as the one we sent; this just gets the expanded name
 342        * (i.e., with the succeeding search-domain tacked on).
 343        */
 344       n = strlen (bp) + 1;             /* for the \0 */
 345       if (n >= MAXHOSTNAMELEN)
 346         {
 347           __set_h_errno (NO_RECOVERY);
 348           return NSS_STATUS_TRYAGAIN;
 349         }
 350       result->h_name = bp;
 351       bp += n;
 352       linebuflen -= n;
 353       /* The qname can be abbreviated, but h_name is now absolute. */
 354       qname = result->h_name;
 355     }
 356
 357   ap = host_data->aliases;
 358   *ap = NULL;
 359   result->h_aliases = host_data->aliases;
 360   hap = host_data->h_addr_ptrs;
 361   *hap = NULL;
 362   result->h_addr_list = host_data->h_addr_ptrs;
 363   haveanswer = 0;
 364   had_error = 0;
 365
 366   while (ancount-- > 0 && cp < end_of_message && had_error == 0)
 367     {
 368       int type, class;
 369
 370       n = dn_expand (answer->buf, end_of_message, cp, bp, linebuflen);
 371       if (n < 0 || (*name_ok) (bp) == 0)
 372         {
 373           ++had_error;
 374           continue;
 375         }
 376       cp += n;                          /* name */
 377       type = _getshort (cp);
 378       cp += INT16SZ;                    /* type */
 379       class = _getshort(cp);
 380       cp += INT16SZ + INT32SZ;          /* class, TTL */
 381       n = _getshort(cp);
 382       cp += INT16SZ;                    /* len */
 383       if (class != C_IN)
 384         {
 385           /* XXX - debug? syslog? */
 386           cp += n;
 387           continue;                     /* XXX - had_error++ ? */
 388         }
 389
 390       if ((qtype ==T_A || qtype == T_AAAA) && type == T_CNAME)
 391         {
 392           if (ap >= &host_data->aliases[MAX_NR_ALIASES - 1])
 393             continue;
 394           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
 395           if (n < 0 || (*name_ok) (tbuf) == 0)
 396             {
 397               ++had_error;
 398               continue;
 399             }
 400           cp += n;
 401           /* Store alias.  */
 402           *ap++ = bp;
 403           n = strlen (bp) + 1;          /* For the \0.  */
 404           if (n >= MAXHOSTNAMELEN)
 405             {
 406               ++had_error;
 407               continue;
 408             }
 409           bp += n;
 410           linebuflen -= n;
 411           /* Get canonical name.  */
 412           n = strlen (tbuf) + 1;        /* For the \0.  */
 413           if ((size_t) n > buflen || n >= MAXHOSTNAMELEN)
 414             {
 415               ++had_error;
 416               continue;
 417             }
 418           strcpy (bp, tbuf);            /* Cannot overflow.  */
 419           result->h_name = bp;
 420           bp += n;
 421           linebuflen -= n;
 422           continue;
 423         }
 424
 425       if (qtype == T_PTR && type == T_CNAME)
 426         {
 427           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
 428           if (n < 0 || res_hnok (tbuf) == 0)
 429             {
 430               ++had_error;
 431               continue;
 432             }
 433           cp += n;
 434           /* Get canonical name. */
 435           n = strlen (tbuf) + 1;   /* For the \0.  */
 436           if ((size_t) n > buflen || n >= MAXHOSTNAMELEN)
 437             {
 438               ++had_error;
 439               continue;
 440             }
 441           strcpy (bp, tbuf);            /* Cannot overflow.  */
 442           tname = bp;
 443           bp += n;
 444           linebuflen -= n;
 445           continue;
 446         }
 447       if (type != qtype)
 448         {
 449           syslog (LOG_NOTICE | LOG_AUTH,
 450                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
 451                   qname, p_class (C_IN), p_type (qtype), p_type (type));
 452           cp += n;
 453           continue;                     /* XXX - had_error++ ? */
 454         }
 455
 456       switch (type)
 457         {
 458         case T_PTR:
 459           if (strcasecmp (tname, bp) != 0)
 460             {
 461               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, qname, bp);
 462               cp += n;
 463               continue;                 /* XXX - had_error++ ? */
 464             }
 465           n = dn_expand (answer->buf, end_of_message, cp, bp, linebuflen);
 466           if (n < 0 || res_hnok (bp) == 0)
 467             {
 468               ++had_error;
 469               break;
 470             }
 471 #if MULTI_PTRS_ARE_ALIASES
 472           cp += n;
 473           if (haveanswer == 0)
 474             result->h_name = bp;
 475           else if (ap < &host_data->aliases[MAXALIASES-1])
 476             *ap++ = bp;
 477           else
 478             n = -1;
 479           if (n != -1)
 480             {
 481               n = strlen (bp) + 1;      /* for the \0 */
 482               if (n >= MAXHOSTNAMELEN)
 483                 {
 484                   ++had_error;
 485                   break;
 486                 }
 487               bp += n;
 488               linebuflen -= n;
 489             }
 490           break;
 491 #else
 492           result->h_name = bp;
 493           if (_res.options & RES_USE_INET6)
 494             {
 495               n = strlen (bp) + 1;      /* for the \0 */
 496               if (n >= MAXHOSTNAMELEN)
 497                 {
 498                   ++had_error;
 499                   break;
 500                 }
 501               bp += n;
 502               linebuflen -= n;
 503               map_v4v6_hostent (result, &bp, &linebuflen);
 504             }
 505           *h_errnop = NETDB_SUCCESS;
 506           return NSS_STATUS_SUCCESS;
 507 #endif
 508         case T_A:
 509         case T_AAAA:
 510           if (strcasecmp (result->h_name, bp) != 0)
 511             {
 512               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, result->h_name, bp);
 513               cp += n;
 514               continue;                 /* XXX - had_error++ ? */
 515             }
 516           if (n != result->h_length)
 517             {
 518               cp += n;
 519               continue;
 520             }
 521           if (!haveanswer)
 522             {
 523               register int nn;
 524
 525               result->h_name = bp;
 526               nn = strlen (bp) + 1;     /* for the \0 */
 527               bp += nn;
 528               linebuflen -= nn;
 529             }
 530
 531           bp += sizeof (align) - ((u_long) bp % sizeof (align));
 532
 533           if (n >= linebuflen)
 534             {
 535               ++had_error;
 536               continue;
 537             }
 538           if (hap >= &host_data->h_addr_ptrs[MAX_NR_ADDRS-1])
 539             {
 540               cp += n;
 541               continue;
 542             }
 543           memcpy (*hap++ = bp, cp, n);
 544           bp += n;
 545           cp += n;
 546           linebuflen -= n;
 547           break;
 548         default:
 549           abort ();
 550         }
 551       if (had_error == 0)
 552         ++haveanswer;
 553     }
 554
 555   if (haveanswer > 0)
 556     {
 557       *ap = NULL;
 558       *hap = NULL;
 559 #if defined(RESOLVSORT)
 560       /*
 561        * Note: we sort even if host can take only one address
 562        * in its return structures - should give it the "best"
 563        * address in that case, not some random one
 564        */
 565       if (_res.nsort && haveanswer > 1 && qtype == T_A)
 566         addrsort (host_data->h_addr_ptrs, haveanswer);
 567 #endif /*RESOLVSORT*/
 568
 569       if (result->h_name == NULL)
 570         {
 571           n = strlen (qname) + 1;       /* For the \0.  */
 572           if (n > linebuflen || n >= MAXHOSTNAMELEN)
 573             goto no_recovery;
 574           strcpy (bp, qname);           /* Cannot overflow.  */
 575           result->h_name = bp;
 576           bp += n;
 577           linebuflen -= n;
 578         }
 579
 580       if (_res.options & RES_USE_INET6)
 581         map_v4v6_hostent (result, &bp, &linebuflen);
 582       *h_errnop = NETDB_SUCCESS;
 583       return NSS_STATUS_SUCCESS;
 584     }
 585  no_recovery:
 586   *h_errnop = NO_RECOVERY;
 587   return NSS_STATUS_TRYAGAIN;
 588 }