resolv/res_hconf.c

   1 /* Copyright (C) 1993, 1995-2001, 2002 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by David Mosberger (davidm@azstarnet.com).
   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 /* This file provides a Linux /etc/host.conf compatible front end to
  21    the various name resolvers (/etc/hosts, named, NIS server, etc.).
  22    Though mostly compatibly, the following differences exist compared
  23    to the original implementation:
  24
  25         - new command "spoof" takes an arguments like RESOLV_SPOOF_CHECK
  26           environment variable (i.e., `off', `nowarn', or `warn').
  27
  28         - line comments can appear anywhere (not just at the beginning of
  29           a line)
  30 */
  31
  32 #include <errno.h>
  33 #include <ctype.h>
  34 #include <libintl.h>
  35 #include <memory.h>
  36 #include <stdio.h>
  37 #include <stdio_ext.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <net/if.h>
  41 #include <sys/ioctl.h>
  42 #include <unistd.h>
  43 #include <netinet/in.h>
  44 #include <bits/libc-lock.h>
  45 #include "ifreq.h"
  46 #include "res_hconf.h"
  47 #ifdef USE_IN_LIBIO
  48 # include <wchar.h>
  49 #endif
  50
  51 #define _PATH_HOSTCONF  "/etc/host.conf"
  52
  53 /* Environment vars that all user to override default behavior:  */
  54 #define ENV_HOSTCONF    "RESOLV_HOST_CONF"
  55 #define ENV_SERVORDER   "RESOLV_SERV_ORDER"
  56 #define ENV_SPOOF       "RESOLV_SPOOF_CHECK"
  57 #define ENV_TRIM_OVERR  "RESOLV_OVERRIDE_TRIM_DOMAINS"
  58 #define ENV_TRIM_ADD    "RESOLV_ADD_TRIM_DOMAINS"
  59 #define ENV_MULTI       "RESOLV_MULTI"
  60 #define ENV_REORDER     "RESOLV_REORDER"
  61
  62 static const char *arg_service_list (const char *, int, const char *,
  63                                      unsigned int);
  64 static const char *arg_trimdomain_list (const char *, int, const char *,
  65                                         unsigned int);
  66 static const char *arg_spoof (const char *, int, const char *, unsigned int);
  67 static const char *arg_bool (const char *, int, const char *, unsigned int);
  68
  69 static struct cmd
  70 {
  71   const char *name;
  72   const char *(*parse_args) (const char * filename, int line_num,
  73                              const char * args, unsigned int arg);
  74   unsigned int arg;
  75 } cmd[] =
  76 {
  77   {"order",             arg_service_list,       0},
  78   {"trim",              arg_trimdomain_list,    0},
  79   {"spoof",             arg_spoof,              0},
  80   {"multi",             arg_bool,               HCONF_FLAG_MULTI},
  81   {"nospoof",           arg_bool,               HCONF_FLAG_SPOOF},
  82   {"spoofalert",        arg_bool,               HCONF_FLAG_SPOOFALERT},
  83   {"reorder",           arg_bool,               HCONF_FLAG_REORDER}
  84 };
  85
  86 /* Structure containing the state.  */
  87 struct hconf _res_hconf;
  88
  89 /* Skip white space.  */
  90 static const char *
  91 skip_ws (const char *str)
  92 {
  93   while (isspace (*str)) ++str;
  94   return str;
  95 }
  96
  97
  98 /* Skip until whitespace, comma, end of line, or comment character.  */
  99 static const char *
 100 skip_string (const char *str)
 101 {
 102   while (*str && !isspace (*str) && *str != '#' && *str != ',')
 103     ++str;
 104   return str;
 105 }
 106
 107
 108 static const char *
 109 arg_service_list (const char *fname, int line_num, const char *args,
 110                   unsigned int arg)
 111 {
 112   enum Name_Service service;
 113   const char *start;
 114   size_t len;
 115   size_t i;
 116   static struct
 117   {
 118     const char * name;
 119     enum Name_Service service;
 120   } svcs[] =
 121     {
 122       {"bind",  SERVICE_BIND},
 123       {"hosts", SERVICE_HOSTS},
 124       {"nis",   SERVICE_NIS},
 125     };
 126
 127   do
 128     {
 129       start = args;
 130       args = skip_string (args);
 131       len = args - start;
 132
 133       service = SERVICE_NONE;
 134       for (i = 0; i < sizeof (svcs) / sizeof (svcs[0]); ++i)
 135         {
 136           if (__strncasecmp (start, svcs[i].name, len) == 0
 137               && len == strlen (svcs[i].name))
 138           {
 139             service = svcs[i].service;
 140             break;
 141           }
 142       }
 143       if (service == SERVICE_NONE)
 144         {
 145           char *buf;
 146
 147           __asprintf (&buf, _("%s: line %d: expected service, found `%s'\n"),
 148                       fname, line_num, start);
 149
 150 #ifdef USE_IN_LIBIO
 151           if (_IO_fwide (stderr, 0) > 0)
 152             __fwprintf (stderr, L"%s", buf);
 153           else
 154 #endif
 155             fputs (buf, stderr);
 156
 157           free (buf);
 158           return 0;
 159         }
 160       if (_res_hconf.num_services >= SERVICE_MAX)
 161         {
 162           char *buf;
 163
 164           __asprintf (&buf,
 165                       _("%s: line %d: cannot specify more than %d services"),
 166                       fname, line_num, SERVICE_MAX);
 167
 168 #ifdef USE_IN_LIBIO
 169           if (_IO_fwide (stderr, 0) > 0)
 170             __fwprintf (stderr, L"%s", buf);
 171           else
 172 #endif
 173             fputs (buf, stderr);
 174
 175           free (buf);
 176           return 0;
 177         }
 178       _res_hconf.service[_res_hconf.num_services++] = service;
 179
 180       args = skip_ws (args);
 181       switch (*args)
 182         {
 183         case ',':
 184         case ';':
 185         case ':':
 186           args = skip_ws (++args);
 187           if (!*args || *args == '#')
 188             {
 189               char *buf;
 190
 191               __asprintf (&buf, _("\
 192 %s: line %d: list delimiter not followed by keyword"),
 193                           fname, line_num);
 194
 195 #ifdef USE_IN_LIBIO
 196               if (_IO_fwide (stderr, 0) > 0)
 197                 __fwprintf (stderr, L"%s", buf);
 198               else
 199 #endif
 200                 fputs (buf, stderr);
 201
 202               free (buf);
 203               return 0;
 204             }
 205         default:
 206           break;
 207         }
 208     }
 209   while (*args && *args != '#');
 210   return args;
 211 }
 212
 213
 214 static const char *
 215 arg_trimdomain_list (const char *fname, int line_num, const char *args,
 216                      unsigned int flag)
 217 {
 218   const char * start;
 219   size_t len;
 220
 221   do
 222     {
 223       start = args;
 224       args = skip_string (args);
 225       len = args - start;
 226
 227       if (_res_hconf.num_trimdomains >= TRIMDOMAINS_MAX)
 228         {
 229           char *buf;
 230
 231           __asprintf (&buf, _("\
 232 %s: line %d: cannot specify more than %d trim domains"),
 233                       fname, line_num, TRIMDOMAINS_MAX);
 234
 235 #ifdef USE_IN_LIBIO
 236               if (_IO_fwide (stderr, 0) > 0)
 237                 __fwprintf (stderr, L"%s", buf);
 238               else
 239 #endif
 240                 fputs (buf, stderr);
 241
 242               free (buf);
 243           return 0;
 244         }
 245       _res_hconf.trimdomain[_res_hconf.num_trimdomains++] =
 246         __strndup (start, len);
 247       args = skip_ws (args);
 248       switch (*args)
 249         {
 250         case ',': case ';': case ':':
 251           args = skip_ws (++args);
 252           if (!*args || *args == '#')
 253             {
 254               char *buf;
 255
 256               __asprintf (&buf, _("\
 257 %s: line %d: list delimiter not followed by domain"),
 258                           fname, line_num);
 259
 260 #ifdef USE_IN_LIBIO
 261               if (_IO_fwide (stderr, 0) > 0)
 262                 __fwprintf (stderr, L"%s", buf);
 263               else
 264 #endif
 265                 fputs (buf, stderr);
 266
 267               free (buf);
 268               return 0;
 269             }
 270         default:
 271           break;
 272         }
 273     }
 274   while (*args && *args != '#');
 275   return args;
 276 }
 277
 278
 279 static const char *
 280 arg_spoof (const char *fname, int line_num, const char *args, unsigned flag)
 281 {
 282   const char *start = args;
 283   size_t len;
 284
 285   args = skip_string (args);
 286   len = args - start;
 287
 288   if (len == 3 && __strncasecmp (start, "off", len) == 0)
 289     _res_hconf.flags &= ~(HCONF_FLAG_SPOOF | HCONF_FLAG_SPOOFALERT);
 290   else
 291     {
 292       _res_hconf.flags |= (HCONF_FLAG_SPOOF | HCONF_FLAG_SPOOFALERT);
 293       if ((len == 6 && __strncasecmp (start, "nowarn", len) == 0)
 294           || !(len == 4 && __strncasecmp (start, "warn", len) == 0))
 295         _res_hconf.flags &= ~HCONF_FLAG_SPOOFALERT;
 296     }
 297   return args;
 298 }
 299
 300
 301 static const char *
 302 arg_bool (const char *fname, int line_num, const char *args, unsigned flag)
 303 {
 304   if (__strncasecmp (args, "on", 2) == 0)
 305     {
 306       args += 2;
 307       _res_hconf.flags |= flag;
 308     }
 309   else if (__strncasecmp (args, "off", 3) == 0)
 310     {
 311       args += 3;
 312       _res_hconf.flags &= ~flag;
 313     }
 314   else
 315     {
 316       char *buf;
 317
 318       __asprintf (&buf,
 319                   _("%s: line %d: expected `on' or `off', found `%s'\n"),
 320                   fname, line_num, args);
 321
 322 #ifdef USE_IN_LIBIO
 323       if (_IO_fwide (stderr, 0) > 0)
 324         __fwprintf (stderr, L"%s", buf);
 325       else
 326 #endif
 327         fputs (buf, stderr);
 328
 329       free (buf);
 330       return 0;
 331     }
 332   return args;
 333 }
 334
 335
 336 static void
 337 parse_line (const char *fname, int line_num, const char *str)
 338 {
 339   const char *start;
 340   struct cmd *c = 0;
 341   size_t len;
 342   size_t i;
 343
 344   str = skip_ws (str);
 345
 346   /* skip line comment and empty lines: */
 347   if (*str == '\0' || *str == '#') return;
 348
 349   start = str;
 350   str = skip_string (str);
 351   len = str - start;
 352
 353   for (i = 0; i < sizeof (cmd) / sizeof (cmd[0]); ++i)
 354     {
 355       if (__strncasecmp (start, cmd[i].name, len) == 0
 356           && strlen (cmd[i].name) == len)
 357         {
 358           c = &cmd[i];
 359           break;
 360         }
 361     }
 362   if (c == NULL)
 363     {
 364       char *buf;
 365
 366       __asprintf (&buf, _("%s: line %d: bad command `%s'\n"),
 367                   fname, line_num, start);
 368
 369 #ifdef USE_IN_LIBIO
 370       if (_IO_fwide (stderr, 0) > 0)
 371         __fwprintf (stderr, L"%s", buf);
 372       else
 373 #endif
 374         fputs (buf, stderr);
 375
 376       free (buf);
 377       return;
 378     }
 379
 380   /* process args: */
 381   str = skip_ws (str);
 382   str = (*c->parse_args) (fname, line_num, str, c->arg);
 383   if (!str)
 384     return;
 385
 386   /* rest of line must contain white space or comment only: */
 387   while (*str)
 388     {
 389       if (!isspace (*str)) {
 390         if (*str != '#')
 391           {
 392             char *buf;
 393
 394             __asprintf (&buf,
 395                         _("%s: line %d: ignoring trailing garbage `%s'\n"),
 396                         fname, line_num, str);
 397
 398 #ifdef USE_IN_LIBIO
 399             if (_IO_fwide (stderr, 0) > 0)
 400               __fwprintf (stderr, L"%s", buf);
 401             else
 402 #endif
 403               fputs (buf, stderr);
 404
 405             free (buf);
 406           }
 407         break;
 408       }
 409       ++str;
 410     }
 411 }
 412
 413
 414 static void
 415 do_init (void)
 416 {
 417   const char *hconf_name;
 418   int line_num = 0;
 419   char buf[256], *envval;
 420   FILE *fp;
 421
 422   memset (&_res_hconf, '\0', sizeof (_res_hconf));
 423
 424   hconf_name = getenv (ENV_HOSTCONF);
 425   if (hconf_name == NULL)
 426     hconf_name = _PATH_HOSTCONF;
 427
 428   fp = fopen (hconf_name, "r");
 429   if (!fp)
 430     /* make up something reasonable: */
 431     _res_hconf.service[_res_hconf.num_services++] = SERVICE_BIND;
 432   else
 433     {
 434       /* No threads using this stream.  */
 435       __fsetlocking (fp, FSETLOCKING_BYCALLER);
 436
 437       while (fgets_unlocked (buf, sizeof (buf), fp))
 438         {
 439           ++line_num;
 440           *__strchrnul (buf, '\n') = '\0';
 441           parse_line (hconf_name, line_num, buf);
 442         }
 443       fclose (fp);
 444     }
 445
 446   envval = getenv (ENV_SERVORDER);
 447   if (envval)
 448     {
 449       _res_hconf.num_services = 0;
 450       arg_service_list (ENV_SERVORDER, 1, envval, 0);
 451     }
 452
 453   envval = getenv (ENV_SPOOF);
 454   if (envval)
 455     arg_spoof (ENV_SPOOF, 1, envval, 0);
 456
 457   envval = getenv (ENV_MULTI);
 458   if (envval)
 459     arg_bool (ENV_MULTI, 1, envval, HCONF_FLAG_MULTI);
 460
 461   envval = getenv (ENV_REORDER);
 462   if (envval)
 463     arg_bool (ENV_REORDER, 1, envval, HCONF_FLAG_REORDER);
 464
 465   envval = getenv (ENV_TRIM_ADD);
 466   if (envval)
 467     arg_trimdomain_list (ENV_TRIM_ADD, 1, envval, 0);
 468
 469   envval = getenv (ENV_TRIM_OVERR);
 470   if (envval)
 471     {
 472       _res_hconf.num_trimdomains = 0;
 473       arg_trimdomain_list (ENV_TRIM_OVERR, 1, envval, 0);
 474     }
 475
 476   _res_hconf.initialized = 1;
 477 }
 478
 479
 480 /* Initialize hconf datastructure by reading host.conf file and
 481    environment variables.  */
 482 void
 483 _res_hconf_init (void)
 484 {
 485   __libc_once_define (static, once);
 486
 487   __libc_once (once, do_init);
 488 }
 489
 490
 491 /* List of known interfaces.  */
 492 libc_freeres_ptr (
 493 static struct netaddr
 494 {
 495   int addrtype;
 496   union
 497   {
 498     struct
 499     {
 500       u_int32_t addr;
 501       u_int32_t mask;
 502     } ipv4;
 503   } u;
 504 } *ifaddrs);
 505
 506 /* We need to protect the dynamic buffer handling.  */
 507 __libc_lock_define_initialized (static, lock);
 508
 509 /* Reorder addresses returned in a hostent such that the first address
 510    is an address on the local subnet, if there is such an address.
 511    Otherwise, nothing is changed.
 512
 513    Note that this function currently only handles IPv4 addresses.  */
 514
 515 void
 516 _res_hconf_reorder_addrs (struct hostent *hp)
 517 {
 518 #if defined SIOCGIFCONF && defined SIOCGIFNETMASK
 519   int i, j;
 520   /* Number of interfaces.  */
 521   static int num_ifs = -1;
 522
 523   /* Only reorder if we're supposed to.  */
 524   if ((_res_hconf.flags & HCONF_FLAG_REORDER) == 0)
 525     return;
 526
 527   /* Can't deal with anything but IPv4 for now...  */
 528   if (hp->h_addrtype != AF_INET)
 529     return;
 530
 531   if (num_ifs <= 0)
 532     {
 533       struct ifreq *ifr, *cur_ifr;
 534       int sd, num, i;
 535       /* Save errno.  */
 536       int save = errno;
 537
 538       /* Initialize interface table.  */
 539
 540       num_ifs = 0;
 541
 542       /* The SIOCGIFNETMASK ioctl will only work on an AF_INET socket.  */
 543       sd = __socket (AF_INET, SOCK_DGRAM, 0);
 544       if (sd < 0)
 545         return;
 546
 547       /* Get lock.  */
 548       __libc_lock_lock (lock);
 549
 550       /* Get a list of interfaces.  */
 551       __ifreq (&ifr, &num, sd);
 552       if (!ifr)
 553         goto cleanup;
 554
 555       ifaddrs = malloc (num * sizeof (ifaddrs[0]));
 556       if (!ifaddrs)
 557         goto cleanup1;
 558
 559       /* Copy usable interfaces in ifaddrs structure.  */
 560       for (cur_ifr = ifr, i = 0; i < num; cur_ifr = __if_nextreq (cur_ifr), ++i)
 561         {
 562           if (cur_ifr->ifr_addr.sa_family != AF_INET)
 563             continue;
 564
 565           ifaddrs[num_ifs].addrtype = AF_INET;
 566           ifaddrs[num_ifs].u.ipv4.addr =
 567             ((struct sockaddr_in *) &cur_ifr->ifr_addr)->sin_addr.s_addr;
 568
 569           if (__ioctl (sd, SIOCGIFNETMASK, cur_ifr) < 0)
 570             continue;
 571
 572           ifaddrs[num_ifs].u.ipv4.mask =
 573             ((struct sockaddr_in *) &cur_ifr->ifr_netmask)->sin_addr.s_addr;
 574
 575           /* Now we're committed to this entry.  */
 576           ++num_ifs;
 577         }
 578       /* Just keep enough memory to hold all the interfaces we want.  */
 579       ifaddrs = realloc (ifaddrs, num_ifs * sizeof (ifaddrs[0]));
 580
 581     cleanup1:
 582       __if_freereq (ifr, num);
 583
 584     cleanup:
 585       /* Release lock, preserve error value, and close socket.  */
 586       save = errno;
 587       __libc_lock_unlock (lock);
 588       __close (sd);
 589     }
 590
 591   if (num_ifs == 0)
 592     return;
 593
 594   /* Find an address for which we have a direct connection.  */
 595   for (i = 0; hp->h_addr_list[i]; ++i)
 596     {
 597       struct in_addr *haddr = (struct in_addr *) hp->h_addr_list[i];
 598
 599       for (j = 0; j < num_ifs; ++j)
 600         {
 601           u_int32_t if_addr    = ifaddrs[j].u.ipv4.addr;
 602           u_int32_t if_netmask = ifaddrs[j].u.ipv4.mask;
 603
 604           if (((haddr->s_addr ^ if_addr) & if_netmask) == 0)
 605             {
 606               void *tmp;
 607
 608               tmp = hp->h_addr_list[i];
 609               hp->h_addr_list[i] = hp->h_addr_list[0];
 610               hp->h_addr_list[0] = tmp;
 611               return;
 612             }
 613         }
 614     }
 615 #endif /* defined(SIOCGIFCONF) && ... */
 616 }
 617
 618
 619 /* If HOSTNAME has a postfix matching any of the trimdomains, trim away
 620    that postfix.  Notice that HOSTNAME is modified inplace.  Also, the
 621    original code applied all trimdomains in order, meaning that the
 622    same domainname could be trimmed multiple times.  I believe this
 623    was unintentional.  */
 624 void
 625 _res_hconf_trim_domain (char *hostname)
 626 {
 627   size_t hostname_len, trim_len;
 628   int i;
 629
 630   hostname_len = strlen (hostname);
 631
 632   for (i = 0; i < _res_hconf.num_trimdomains; ++i)
 633     {
 634       const char *trim = _res_hconf.trimdomain[i];
 635
 636       trim_len = strlen (trim);
 637       if (hostname_len > trim_len
 638           && __strcasecmp (&hostname[hostname_len - trim_len], trim) == 0)
 639         {
 640           hostname[hostname_len - trim_len] = '\0';
 641           break;
 642         }
 643     }
 644 }
 645
 646
 647 /* Trim all hostnames/aliases in HP according to the trimdomain list.
 648    Notice that HP is modified inplace!  */
 649 void
 650 _res_hconf_trim_domains (struct hostent *hp)
 651 {
 652   int i;
 653
 654   if (_res_hconf.num_trimdomains == 0)
 655     return;
 656
 657   _res_hconf_trim_domain (hp->h_name);
 658   for (i = 0; hp->h_aliases[i]; ++i)
 659     _res_hconf_trim_domain (hp->h_aliases[i]);
 660 }