1: /* Copyright (C) 1993, 1995-2006, 2007 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 <assert.h>
   33: #include <errno.h>
   34: #include <ctype.h>
   35: #include <libintl.h>
   36: #include <memory.h>
   37: #include <stdio.h>
   38: #include <stdio_ext.h>
   39: #include <stdlib.h>
   40: #include <string.h>
   41: #include <net/if.h>
   42: #include <sys/ioctl.h>
   43: #include <unistd.h>
   44: #include <netinet/in.h>
   45: #include <bits/libc-lock.h>
   46: #include "ifreq.h"
   47: #include "res_hconf.h"
   48: #ifdef USE_IN_LIBIO
   49: # include <wchar.h>
   50: #endif
   51: 
   52: #define _PATH_HOSTCONF  "/etc/host.conf"
   53: 
   54: /* Environment vars that all user to override default behavior:  */
   55: #define ENV_HOSTCONF    "RESOLV_HOST_CONF"
   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: enum parse_cbs
   63:   {
   64:     CB_none,
   65:     CB_arg_trimdomain_list,
   66:     CB_arg_spoof,
   67:     CB_arg_bool
   68:   };
   69: 
   70: static const struct cmd
   71: {
   72:   const char name[11];
   73:   uint8_t cb;
   74:   unsigned int arg;
   75: } cmd[] =
   76: {
   77:   {"order",             CB_none,           0},
   78:   {"trim",              CB_arg_trimdomain_list,     0},
   79:   {"spoof",             CB_arg_spoof,              0},
   80:   {"multi",             CB_arg_bool,               HCONF_FLAG_MULTI},
   81:   {"nospoof",           CB_arg_bool,             HCONF_FLAG_SPOOF},
   82:   {"spoofalert",        CB_arg_bool,           HCONF_FLAG_SPOOFALERT},
   83:   {"reorder",           CB_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_trimdomain_list (const char *fname, int line_num, const char *args)
  110: {
  111:   const char * start;
  112:   size_t len;
  113: 
  114:   do
  115:     {
  116:       start = args;
  117:       args = skip_string (args);
  118:       len = args - start;
  119: 
  120:       if (_res_hconf.num_trimdomains >= TRIMDOMAINS_MAX)
  121:         {
  122:           char *buf;
  123: 
  124:           if (__asprintf (&buf, _("\
  125: %s: line %d: cannot specify more than %d trim domains"),
  126:                           fname, line_num, TRIMDOMAINS_MAX) < 0)
  127:             return 0;
  128: 
  129:           __fxprintf (NULL, "%s", buf);
  130: 
  131:           free (buf);
  132:           return 0;
  133:         }
  134:       _res_hconf.trimdomain[_res_hconf.num_trimdomains++] =
  135:         __strndup (start, len);
  136:       args = skip_ws (args);
  137:       switch (*args)
  138:         {
  139:         case ',': case ';': case ':':
  140:           args = skip_ws (++args);
  141:           if (!*args || *args == '#')
  142:             {
  143:               char *buf;
  144: 
  145:               if (__asprintf (&buf, _("\
  146: %s: line %d: list delimiter not followed by domain"),
  147:                               fname, line_num) < 0)
  148:                 return 0;
  149: 
  150:               __fxprintf (NULL, "%s", buf);
  151: 
  152:               free (buf);
  153:               return 0;
  154:             }
  155:         default:
  156:           break;
  157:         }
  158:     }
  159:   while (*args && *args != '#');
  160:   return args;
  161: }
  162: 
  163: 
  164: static const char *
  165: arg_spoof (const char *fname, int line_num, const char *args)
  166: {
  167:   const char *start = args;
  168:   size_t len;
  169: 
  170:   args = skip_string (args);
  171:   len = args - start;
  172: 
  173:   if (len == 3 && __strncasecmp (start, "off", len) == 0)
  174:     _res_hconf.flags &= ~(HCONF_FLAG_SPOOF | HCONF_FLAG_SPOOFALERT);
  175:   else
  176:     {
  177:       _res_hconf.flags |= (HCONF_FLAG_SPOOF | HCONF_FLAG_SPOOFALERT);
  178:       if ((len == 6 && __strncasecmp (start, "nowarn", len) == 0)
  179:           || !(len == 4 && __strncasecmp (start, "warn", len) == 0))
  180:         _res_hconf.flags &= ~HCONF_FLAG_SPOOFALERT;
  181:     }
  182:   return args;
  183: }
  184: 
  185: 
  186: static const char *
  187: arg_bool (const char *fname, int line_num, const char *args, unsigned flag)
  188: {
  189:   if (__strncasecmp (args, "on", 2) == 0)
  190:     {
  191:       args += 2;
  192:       _res_hconf.flags |= flag;
  193:     }
  194:   else if (__strncasecmp (args, "off", 3) == 0)
  195:     {
  196:       args += 3;
  197:       _res_hconf.flags &= ~flag;
  198:     }
  199:   else
  200:     {
  201:       char *buf;
  202: 
  203:       if (__asprintf (&buf,
  204:                       _("%s: line %d: expected `on' or `off', found `%s'\n"),
  205:                       fname, line_num, args) < 0)
  206:         return 0;
  207: 
  208:       __fxprintf (NULL, "%s", buf);
  209: 
  210:       free (buf);
  211:       return 0;
  212:     }
  213:   return args;
  214: }
  215: 
  216: 
  217: static void
  218: parse_line (const char *fname, int line_num, const char *str)
  219: {
  220:   const char *start;
  221:   const struct cmd *c = 0;
  222:   size_t len;
  223:   size_t i;
  224: 
  225:   str = skip_ws (str);
  226: 
  227:   /* skip line comment and empty lines: */
  228:   if (*str == '\0' || *str == '#') return;
  229: 
  230:   start = str;
  231:   str = skip_string (str);
  232:   len = str - start;
  233: 
  234:   for (i = 0; i < sizeof (cmd) / sizeof (cmd[0]); ++i)
  235:     {
  236:       if (__strncasecmp (start, cmd[i].name, len) == 0
  237:           && strlen (cmd[i].name) == len)
  238:         {
  239:           c = &cmd[i];
  240:           break;
  241:         }
  242:     }
  243:   if (c == NULL)
  244:     {
  245:       char *buf;
  246: 
  247:       if (__asprintf (&buf, _("%s: line %d: bad command `%s'\n"),
  248:                       fname, line_num, start) < 0)
  249:         return;
  250: 
  251:       __fxprintf (NULL, "%s", buf);
  252: 
  253:       free (buf);
  254:       return;
  255:     }
  256: 
  257:   /* process args: */
  258:   str = skip_ws (str);
  259: 
  260:   if (c->cb == CB_arg_trimdomain_list)
  261:     str = arg_trimdomain_list (fname, line_num, str);
  262:   else if (c->cb == CB_arg_spoof)
  263:     str = arg_spoof (fname, line_num, str);
  264:   else if (c->cb == CB_arg_bool)
  265:     str = arg_bool (fname, line_num, str, c->arg);
  266:   else
  267:     /* Ignore the line.  */
  268:     return;
  269: 
  270:   if (!str)
  271:     return;
  272: 
  273:   /* rest of line must contain white space or comment only: */
  274:   while (*str)
  275:     {
  276:       if (!isspace (*str)) {
  277:         if (*str != '#')
  278:           {
  279:             char *buf;
  280: 
  281:             if (__asprintf (&buf,
  282:                             _("%s: line %d: ignoring trailing garbage `%s'\n"),
  283:                             fname, line_num, str) < 0)
  284:               break;
  285: 
  286:             __fxprintf (NULL, "%s", buf);
  287: 
  288:             free (buf);
  289:           }
  290:         break;
  291:       }
  292:       ++str;
  293:     }
  294: }
  295: 
  296: 
  297: static void
  298: do_init (void)
  299: {
  300:   const char *hconf_name;
  301:   int line_num = 0;
  302:   char buf[256], *envval;
  303:   FILE *fp;
  304: 
  305:   memset (&_res_hconf, '\0', sizeof (_res_hconf));
  306: 
  307:   hconf_name = getenv (ENV_HOSTCONF);
  308:   if (hconf_name == NULL)
  309:     hconf_name = _PATH_HOSTCONF;
  310: 
  311:   fp = fopen (hconf_name, "rc");
  312:   if (fp)
  313:     {
  314:       /* No threads using this stream.  */
  315:       __fsetlocking (fp, FSETLOCKING_BYCALLER);
  316: 
  317:       while (fgets_unlocked (buf, sizeof (buf), fp))
  318:         {
  319:           ++line_num;
  320:           *__strchrnul (buf, '\n') = '\0';
  321:           parse_line (hconf_name, line_num, buf);
  322:         }
  323:       fclose (fp);
  324:     }
  325: 
  326:   envval = getenv (ENV_SPOOF);
  327:   if (envval)
  328:     arg_spoof (ENV_SPOOF, 1, envval);
  329: 
  330:   envval = getenv (ENV_MULTI);
  331:   if (envval)
  332:     arg_bool (ENV_MULTI, 1, envval, HCONF_FLAG_MULTI);
  333: 
  334:   envval = getenv (ENV_REORDER);
  335:   if (envval)
  336:     arg_bool (ENV_REORDER, 1, envval, HCONF_FLAG_REORDER);
  337: 
  338:   envval = getenv (ENV_TRIM_ADD);
  339:   if (envval)
  340:     arg_trimdomain_list (ENV_TRIM_ADD, 1, envval);
  341: 
  342:   envval = getenv (ENV_TRIM_OVERR);
  343:   if (envval)
  344:     {
  345:       _res_hconf.num_trimdomains = 0;
  346:       arg_trimdomain_list (ENV_TRIM_OVERR, 1, envval);
  347:     }
  348: 
  349:   _res_hconf.initialized = 1;
  350: }
  351: 
  352: 
  353: /* Initialize hconf datastructure by reading host.conf file and
  354:    environment variables.  */
  355: void
  356: _res_hconf_init (void)
  357: {
  358:   __libc_once_define (static, once);
  359: 
  360:   __libc_once (once, do_init);
  361: }
  362: 
  363: 
  364: #ifndef NOT_IN_libc
  365: /* List of known interfaces.  */
  366: libc_freeres_ptr (
  367: static struct netaddr
  368: {
  369:   int addrtype;
  370:   union
  371:   {
  372:     struct
  373:     {
  374:       u_int32_t addr;
  375:       u_int32_t mask;
  376:     } ipv4;
  377:   } u;
  378: } *ifaddrs);
  379: 
  380: /* We need to protect the dynamic buffer handling.  */
  381: __libc_lock_define_initialized (static, lock);
  382: 
  383: /* Reorder addresses returned in a hostent such that the first address
  384:    is an address on the local subnet, if there is such an address.
  385:    Otherwise, nothing is changed.
  386: 
  387:    Note that this function currently only handles IPv4 addresses.  */
  388: 
  389: void
  390: _res_hconf_reorder_addrs (struct hostent *hp)
  391: {
  392: #if defined SIOCGIFCONF && defined SIOCGIFNETMASK
  393:   int i, j;
  394:   /* Number of interfaces.  */
  395:   static int num_ifs = -1;
  396: 
  397:   /* Only reorder if we're supposed to.  */
  398:   if ((_res_hconf.flags & HCONF_FLAG_REORDER) == 0)
  399:     return;
  400: 
  401:   /* Can't deal with anything but IPv4 for now...  */
  402:   if (hp->h_addrtype != AF_INET)
  403:     return;
  404: 
  405:   if (num_ifs <= 0)
  406:     {
  407:       struct ifreq *ifr, *cur_ifr;
  408:       int sd, num, i;
  409:       /* Save errno.  */
  410:       int save = errno;
  411: 
  412:       /* Initialize interface table.  */
  413: 
  414:       num_ifs = 0;
  415: 
  416:       /* The SIOCGIFNETMASK ioctl will only work on an AF_INET socket.  */
  417:       sd = __socket (AF_INET, SOCK_DGRAM, 0);
  418:       if (sd < 0)
  419:         return;
  420: 
  421:       /* Get lock.  */
  422:       __libc_lock_lock (lock);
  423: 
  424:       /* Get a list of interfaces.  */
  425:       __ifreq (&ifr, &num, sd);
  426:       if (!ifr)
  427:         goto cleanup;
  428: 
  429:       ifaddrs = malloc (num * sizeof (ifaddrs[0]));
  430:       if (!ifaddrs)
  431:         goto cleanup1;
  432: 
  433:       /* Copy usable interfaces in ifaddrs structure.  */
  434:       for (cur_ifr = ifr, i = 0; i < num; cur_ifr = __if_nextreq (cur_ifr), ++i)
  435:         {
  436:           if (cur_ifr->ifr_addr.sa_family != AF_INET)
  437:             continue;
  438: 
  439:           ifaddrs[num_ifs].addrtype = AF_INET;
  440:           ifaddrs[num_ifs].u.ipv4.addr =
  441:             ((struct sockaddr_in *) &cur_ifr->ifr_addr)->sin_addr.s_addr;
  442: 
  443:           if (__ioctl (sd, SIOCGIFNETMASK, cur_ifr) < 0)
  444:             continue;
  445: 
  446:           ifaddrs[num_ifs].u.ipv4.mask =
  447:             ((struct sockaddr_in *) &cur_ifr->ifr_netmask)->sin_addr.s_addr;
  448: 
  449:           /* Now we're committed to this entry.  */
  450:           ++num_ifs;
  451:         }
  452:       /* Just keep enough memory to hold all the interfaces we want.  */
  453:       ifaddrs = realloc (ifaddrs, num_ifs * sizeof (ifaddrs[0]));
  454:       assert (ifaddrs != NULL);
  455: 
  456:     cleanup1:
  457:       __if_freereq (ifr, num);
  458: 
  459:     cleanup:
  460:       /* Release lock, preserve error value, and close socket.  */
  461:       save = errno;
  462:       __libc_lock_unlock (lock);
  463:       __close (sd);
  464:     }
  465: 
  466:   if (num_ifs == 0)
  467:     return;
  468: 
  469:   /* Find an address for which we have a direct connection.  */
  470:   for (i = 0; hp->h_addr_list[i]; ++i)
  471:     {
  472:       struct in_addr *haddr = (struct in_addr *) hp->h_addr_list[i];
  473: 
  474:       for (j = 0; j < num_ifs; ++j)
  475:         {
  476:           u_int32_t if_addr    = ifaddrs[j].u.ipv4.addr;
  477:           u_int32_t if_netmask = ifaddrs[j].u.ipv4.mask;
  478: 
  479:           if (((haddr->s_addr ^ if_addr) & if_netmask) == 0)
  480:             {
  481:               void *tmp;
  482: 
  483:               tmp = hp->h_addr_list[i];
  484:               hp->h_addr_list[i] = hp->h_addr_list[0];
  485:               hp->h_addr_list[0] = tmp;
  486:               return;
  487:             }
  488:         }
  489:     }
  490: #endif /* defined(SIOCGIFCONF) && ... */
  491: }
  492: 
  493: 
  494: /* If HOSTNAME has a postfix matching any of the trimdomains, trim away
  495:    that postfix.  Notice that HOSTNAME is modified inplace.  Also, the
  496:    original code applied all trimdomains in order, meaning that the
  497:    same domainname could be trimmed multiple times.  I believe this
  498:    was unintentional.  */
  499: void
  500: _res_hconf_trim_domain (char *hostname)
  501: {
  502:   size_t hostname_len, trim_len;
  503:   int i;
  504: 
  505:   hostname_len = strlen (hostname);
  506: 
  507:   for (i = 0; i < _res_hconf.num_trimdomains; ++i)
  508:     {
  509:       const char *trim = _res_hconf.trimdomain[i];
  510: 
  511:       trim_len = strlen (trim);
  512:       if (hostname_len > trim_len
  513:           && __strcasecmp (&hostname[hostname_len - trim_len], trim) == 0)
  514:         {
  515:           hostname[hostname_len - trim_len] = '\0';
  516:           break;
  517:         }
  518:     }
  519: }
  520: 
  521: 
  522: /* Trim all hostnames/aliases in HP according to the trimdomain list.
  523:    Notice that HP is modified inplace!  */
  524: void
  525: _res_hconf_trim_domains (struct hostent *hp)
  526: {
  527:   int i;
  528: 
  529:   if (_res_hconf.num_trimdomains == 0)
  530:     return;
  531: 
  532:   _res_hconf_trim_domain (hp->h_name);
  533:   for (i = 0; hp->h_aliases[i]; ++i)
  534:     _res_hconf_trim_domain (hp->h_aliases[i]);
  535: }
  536: #endif