Mon May 13 23:45:29 1996 David Mosberger-Tang <davidm@AZStarNet.com>
authorroland <roland>
Thu, 23 May 1996 02:31:30 +0000 (02:31 +0000)
committerroland <roland>
Thu, 23 May 1996 02:31:30 +0000 (02:31 +0000)
* resolv/res_hconf.c, resolv/res_hconf.h: New files.
        Implementation of reading /etc/host.conf.

resolv/res_hconf.c [new file with mode: 0644]
resolv/res_hconf.h [new file with mode: 0644]

diff --git a/resolv/res_hconf.c b/resolv/res_hconf.c
new file mode 100644 (file)
index 0000000..b08dd3c
--- /dev/null
@@ -0,0 +1,566 @@
+/* Copyright (C) 1993, 1995, 1996 Free Software Foundation, Inc.
+   Contributed by David Mosberger (davidm@azstarnet.com).
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+/* This file provides a Linux /etc/host.conf compatible front end to
+the various name resolvers (/etc/hosts, named, NIS server, etc.).
+Though mostly compatibly, the following differences exist compared
+to the original implementation:
+
+       - new command "spoof" takes an arguments like RESOLV_SPOOF_CHECK
+         environment variable (i.e., `off', `nowarn', or `warn').
+
+       - line comments can appear anywhere (not just at the beginning of
+         a line)
+*/
+#include <ctype.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "res_hconf.h"
+
+#define _PATH_HOSTCONF "/etc/host.conf"
+
+/* Environment vars that all user to override default behavior:  */
+#define ENV_HOSTCONF   "RESOLV_HOST_CONF"
+#define ENV_SERVORDER  "RESOLV_SERV_ORDER"
+#define ENV_SPOOF      "RESOLV_SPOOF_CHECK"
+#define ENV_TRIM_OVERR "RESOLV_OVERRIDE_TRIM_DOMAINS"
+#define ENV_TRIM_ADD   "RESOLV_ADD_TRIM_DOMAINS"
+#define ENV_MULTI      "RESOLV_MULTI"
+#define ENV_REORDER    "RESOLV_REORDER"
+
+static const char * arg_service_list (const char *, int, const char *,
+                                     unsigned);
+static const char * arg_trimdomain_list (const char *, int, const char *,
+                                        unsigned);
+static const char * arg_spoof (const char *, int, const char *, unsigned);
+static const char * arg_bool (const char *, int, const char *, unsigned);
+
+static struct cmd {
+  const char * name;
+  const char * (*parse_args)(const char * filename, int line_num,
+                             const char * args, unsigned arg);
+  unsigned     arg;;
+} cmd[] = {
+  {"order",            arg_service_list,       0},
+  {"trim",             arg_trimdomain_list,    0},
+  {"spoof",            arg_spoof,              0},
+  {"multi",            arg_bool,               HCONF_FLAG_MULTI},
+  {"nospoof",          arg_bool,               HCONF_FLAG_SPOOF},
+  {"spoofalert",       arg_bool,               HCONF_FLAG_SPOOFALERT},
+  {"reorder",          arg_bool,               HCONF_FLAG_REORDER}
+};
+
+
+/*
+ * Why isn't this in stdlib?
+ */
+char *
+strndup (const char * s, size_t n)
+{
+  char * retval;
+
+  retval = malloc (n + 1);
+  if (!retval)
+    return retval;
+
+  memcpy (retval, s, n);
+  retval[n] = '\0';            /* ensure return value is terminated */
+  return retval;
+}
+
+
+/* Skip white space.  */
+static const char *
+skip_ws (const char * str)
+{
+  while (isspace (*str)) ++str;
+  return str;
+}
+
+
+/* Skip until whitespace, comma, end of line, or comment character.  */
+static const char *
+skip_string (const char * str)
+{
+  while (*str && !isspace (*str) && *str != '#' && *str != ',') ++str;
+  return str;
+}
+
+
+static const char *
+arg_service_list (const char * fname, int line_num, const char * args,
+                 unsigned arg)
+{
+  enum Name_Service service;
+  const char * start;
+  size_t len;
+  int i;
+  static struct {
+    const char *       name;
+    enum Name_Service  service;
+  } svcs[] = {
+    {"bind",   SERVICE_BIND},
+    {"hosts",  SERVICE_HOSTS},
+    {"nis",    SERVICE_NIS},
+  };
+
+  do
+    {
+      start = args;
+      args = skip_string (args);
+      len = args - start;
+
+      service = SERVICE_NONE;
+      for (i = 0; i < sizeof (svcs) / sizeof (svcs[0]); ++i)
+       {
+         if (strncasecmp (start, svcs[i].name, len) == 0
+             && len == strlen (svcs[i].name))
+         {
+           service = svcs[i].service;
+           break;
+         }
+      }
+      if (service == SERVICE_NONE)
+       {
+         fprintf (stderr, "%s: line %d: expected service, found `%s'\n",
+                  fname, line_num, start);
+         return 0;
+       }
+      if (_res_hconf.num_services >= SERVICE_MAX)
+       {
+         fprintf (stderr, "%s: line %d: cannot specify more than %d services",
+                  fname, line_num, SERVICE_MAX);
+         return 0;
+       }
+      _res_hconf.service[_res_hconf.num_services++] = service;
+
+      args = skip_ws (args);
+      switch (*args)
+       {
+       case ',': case ';': case ':':
+         args = skip_ws (++args);
+         if (!*args || *args == '#')
+           {
+             fprintf (stderr,
+                      "%s: line %d: list delimiter not followed by keyword",
+                      fname, line_num);
+             return 0;
+           }
+       default:
+         break;
+       }
+    }
+  while (*args && *args != '#');
+  return args;
+}
+
+
+static const char *
+arg_trimdomain_list (const char * fname, int line_num, const char * args,
+                    unsigned flag)
+{
+  const char * start;
+  size_t len;
+
+  do
+    {
+      start = args;
+      args = skip_string (args);
+      len = args - start;
+
+      if (_res_hconf.num_trimdomains >= TRIMDOMAINS_MAX)
+       {
+         fprintf (stderr,
+                  "%s: line %d: cannot specify more than %d trim domains",
+                  fname, line_num, TRIMDOMAINS_MAX);
+         return 0;
+       }
+      _res_hconf.trimdomain[_res_hconf.num_trimdomains++] =
+       strndup (start, len);
+      args = skip_ws (args);
+      switch (*args)
+       {
+       case ',': case ';': case ':':
+         args = skip_ws (++args);
+         if (!*args || *args == '#')
+           {
+             fprintf (stderr,
+                      "%s: line %d: list delimiter not followed by domain",
+                      fname, line_num);
+             return 0;
+           }
+       default:
+         break;
+       }
+    }
+  while (*args && *args != '#');
+  return args;
+}
+
+
+static const char *
+arg_spoof (const char * fname, int line_num, const char * args, unsigned flag)
+{
+  const char * start = args;
+  size_t len;
+
+  args = skip_string (args);
+  len = args - start;
+
+  if (len == 3 && strncasecmp (start, "off", len) == 0)
+    _res_hconf.flags &= ~(HCONF_FLAG_SPOOF | HCONF_FLAG_SPOOFALERT);
+  else
+    {
+      _res_hconf.flags |= (HCONF_FLAG_SPOOF | HCONF_FLAG_SPOOFALERT);
+      if ((len == 6 && strncasecmp (start, "nowarn", len) == 0)
+         || !(len == 4 && strncasecmp (start, "warn", len) == 0))
+       _res_hconf.flags &= ~HCONF_FLAG_SPOOFALERT;
+    }
+  return args;
+}
+
+
+static const char *
+arg_bool (const char * fname, int line_num, const char * args, unsigned flag)
+{
+  if (strncasecmp (args, "on", 2) == 0)
+    {
+      args += 2;
+      _res_hconf.flags |= flag;
+    }
+  else if (strncasecmp (args, "off", 3) == 0)
+    {
+      args += 3;
+      _res_hconf.flags &= ~flag;
+    }
+  else
+    {
+      fprintf (stderr, "%s: line %d: expected `on' or `off', found `%s'\n",
+              fname, line_num, args);
+      return 0;
+    }
+  return args;
+}
+
+
+static void
+parse_line (const char * fname, int line_num, const char * str)
+{
+  const char * start;
+  struct cmd * c = 0;
+  size_t len;
+  int i;
+
+  str = skip_ws (str);
+
+  if (*str == '#') return;             /* skip line comment */
+
+  start = str;
+  str = skip_string (str);
+  len = str - start;
+
+  for (i = 0; i < sizeof (cmd) / sizeof (cmd[0]); ++i)
+    {
+      if (strncasecmp (start, cmd[i].name, len) == 0
+         && strlen (cmd[i].name) == len)
+       {
+         c = &cmd[i];
+         break;
+       }
+    }
+  if (!c)
+    {
+      fprintf (stderr, "%s: line %d: bad command `%s'\n",
+              fname, line_num, start);
+      return;
+    }
+
+  /* process args: */
+  str = skip_ws (str);
+  str = (*c->parse_args) (fname, line_num, str, c->arg);
+  if (!str)
+    return;
+
+  /* rest of line must contain white space or comment only: */
+  while (*str)
+    {
+      if (!isspace (*str)) {
+       if (*str != '#')
+         fprintf (stderr, "%s: line %d: ignoring trailing garbage `%s'\n",
+                  fname, line_num, str);
+       break;
+      }
+      ++str;
+    }
+}
+
+
+/* Initialize hconf datastructure by reading host.conf file and
+   environment variables.  */
+void
+_res_hconf_init (void)
+{
+  const char * hconf_name;
+  int line_num = 0;
+  char buf[256], * end, * envval;
+  FILE * fp;
+
+  memset (&_res_hconf, 0, sizeof (_res_hconf));
+
+  hconf_name = getenv (ENV_HOSTCONF);
+  if (!hconf_name)
+    hconf_name = _PATH_HOSTCONF;
+
+  fp = fopen (hconf_name, "r");
+  if (!fp)
+    /* make up something reasonable: */
+    _res_hconf.service[_res_hconf.num_services++] = SERVICE_BIND;
+  else
+    {
+      while (fgets (buf, sizeof (buf), fp))
+       {
+         ++line_num;
+         end = strchr (buf, '\n');
+         if (end)
+           *end = '\0';
+         parse_line (hconf_name, line_num, buf);
+       }
+      fclose (fp);
+    }
+
+  envval = getenv (ENV_SERVORDER);
+  if (envval)
+    {
+      _res_hconf.num_services = 0;
+      arg_service_list (ENV_SERVORDER, 1, envval, 0);
+    }
+
+  envval = getenv (ENV_SPOOF);
+  if (envval)
+    arg_spoof (ENV_SPOOF, 1, envval, 0);
+
+  envval = getenv (ENV_MULTI);
+  if (envval)
+    arg_bool (ENV_MULTI, 1, envval, HCONF_FLAG_MULTI);
+
+  envval = getenv (ENV_REORDER);
+  if (envval)
+    arg_bool (ENV_REORDER, 1, envval, HCONF_FLAG_REORDER);
+
+  envval = getenv (ENV_TRIM_ADD);
+  if (envval)
+    arg_trimdomain_list (ENV_TRIM_ADD, 1, envval, 0);
+
+  envval = getenv (ENV_TRIM_OVERR);
+  if (envval)
+    {
+      _res_hconf.num_trimdomains = 0;
+      arg_trimdomain_list (ENV_TRIM_OVERR, 1, envval, 0);
+    }
+}
+
+
+/* Reorder addresses returned in a hostent such that the first address
+   is an address on the local subnet, if there is such an address.
+   Otherwise, nothing is changed.  */
+
+void
+_res_hconf_reorder_addrs (struct hostent * hp)
+{
+#if defined (SIOCGIFCONF) && defined (SIOCGIFNETMASK)
+  static int num_ifs = -1;     /* number of interfaces */
+  static struct netaddr {
+    int addrtype;
+    union {
+      struct {
+       u_int32_t       addr;
+       u_int32_t       mask;
+      } ipv4
+    } u;
+  } * ifaddrs;
+
+  if (hp->h_addrtype != AF_INET)
+    return;    /* can't deal with anything but IPv4 for now... */
+
+  if (num_ifs <= 0)
+    {
+      struct ifconf ifs;
+      struct ifreq * ifr;
+      size_t size, num;
+      int sd;
+
+      /* initialize interface table: */
+
+      num_ifs = 0;
+
+      sd = socket (AF_INET, SOCK_DGRAM, 0);
+      if (sd < 0)
+       return;
+
+      /* Now get list of interfaces.  Since we don't know how many
+        interfaces there are, we keep increasing the buffer size
+        until we have at least sizeof(struct ifreq) too many bytes.
+        That implies that the ioctl() return because it ran out of
+        interfaces, not memory */
+      size = 0;
+      ifs.ifc_buf = 0;
+      do {
+       size += 4 * sizeof (struct ifreq);
+       ifs.ifc_buf = realloc (ifs.ifs_buf, size);
+       if (!ifs.ifc_buf)
+         {
+           close (sd);
+           return;
+         }
+       ifs.ifc_len = size;
+       if (ioctl (sd, SIOCGIFCONF, &ifs) < 0)
+         goto cleanup;
+      } while (size - ifs.ifc_len < sizeof (struct ifreq));
+
+      num = ifs.ifc_len / sizeof (struct ifreq);
+
+      ifaddrs = malloc (num * sizeof (ifaddrs[0]));
+      if (!ifaddrs)
+       goto cleanup;
+
+      ifr = ifs.ifc_req;
+      for (i = 0; i < num; ++i) {
+       if (ifr->ifr_addr.sa_family != AF_INET)
+         continue;
+       ifaddrs[num_ifs].addrtype = AF_INET;
+
+       memcpy (&ifaddrs[num_ifs].u.ipv4.addr,
+               &((struct sockaddr_in *)ifr->ifr_addr)->sin_addr, 4);
+
+       if (ioctl (sd, SIOCGIFNETMASK, if) < 0)
+         continue;
+       memcpy (&ifaddrs[num_ifs].u.ipv4.mask,
+               ((struct sockaddr_in *)ifr->ifr_mask)->sin_addr, 4);
+
+       ++num_ifs;      /* now we're committed to this entry */
+      }
+      /* just keep enough memory to hold all the interfaces we want: */
+      ifaddrs = realloc (ifaddrs, num_ifs * sizeof (ifaddrs[0]));
+
+    cleanup:
+      close (sd);
+      free (ifs.ifc_buf);
+    }
+
+  if (num_ifs == 0)
+    return;
+
+  /* find an address for which we have a direct connection: */
+  for (i = 0; hp->h_addr_list[i]; ++i)
+    {
+      h_addr = (struct in_addr *) hp->h_addr_list[i];
+
+      for (j = 0; j < num_ifs; ++j)
+       {
+         if_addr    = ifaddrs[j].u.ipv4.addr;
+         if_netmask = ifaddrs[j].u.ipv4.mask;
+
+         if (((h_addr->s_addr ^ if_addr) & if_netmask) == 0)
+           {
+             void * tmp;
+
+             tmp                = hp->h_addr_list[i];
+             hp->h_addr_list[i] = hp->h_addr_list[0];
+             hp->h_addr_list[0] = tmp;
+             return;
+           }
+       }
+    }
+#endif /* defined(SIOCGIFCONF) && ... */
+}
+
+
+/* If HOSTNAME has a postfix matching any of the trimdomains, trim away
+   that postfix.  Notice that HOSTNAME is modified inplace.  Also, the
+   original code applied all trimdomains in order, meaning that the
+   same domainname could be trimmed multiple times.  I believe this
+   was unintentional.  */
+void
+_res_hconf_trim_domain (char * hostname)
+{
+  size_t hostname_len, trim_len;
+  int i;
+
+  hostname_len = strlen(hostname);
+
+  for (i = 0; i < _res_hconf.num_trimdomains; ++i)
+    {
+      const char * trim = _res_hconf.trimdomain[i];
+
+      trim_len = strlen(trim);
+      if (hostname_len > trim_len
+         && strcasecmp(&hostname[hostname_len - trim_len], trim) == 0)
+       {
+         hostname[hostname_len - trim_len] = '\0';
+         break;
+       }
+    }
+}
+
+
+/* Trim all hostnames/aliases in HP according to the trimdomain list.
+   Notice that HP is modified inplace!  */
+void
+_res_hconf_trim_domains (struct hostent * hp)
+{
+  int i;
+
+  if (_res_hconf.num_trimdomains == 0)
+    return;
+
+  _res_hconf_trim_domain (hp->h_name);
+  for (i = 0; hp->h_aliases[i]; ++i)
+    _res_hconf_trim_domain (hp->h_aliases[i]);
+}
+
+
+#if 0
+
+struct hostent *
+_hconf_gethostent (void)
+{
+}
+
+
+struct hostent *
+_hconf_gethostbyname (const char * name)
+{
+
+}
+
+
+struct hostent *
+_hconf_gethostbyaddr (const char * addr, int len, int type)
+{
+}
+
+
+struct hostent *
+_hconf_gethtbyname (const char * name)
+{
+}
+
+#endif
diff --git a/resolv/res_hconf.h b/resolv/res_hconf.h
new file mode 100644 (file)
index 0000000..2165e40
--- /dev/null
@@ -0,0 +1,50 @@
+/* Copyright (C) 1993, 1995, 1996 Free Software Foundation, Inc.
+   Contributed by David Mosberger (davidm@azstarnet.com).
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef _RES_HCONF_H_
+#define _RES_HCONF_H_
+
+#include <netdb.h>
+
+#define TRIMDOMAINS_MAX        4
+
+enum Name_Service {
+  SERVICE_NONE = 0,
+  SERVICE_BIND, SERVICE_HOSTS, SERVICE_NIS,
+  SERVICE_MAX
+};
+
+struct hconf {
+  int                  num_services;
+  enum Name_Service    service[SERVICE_MAX];
+  int                  num_trimdomains;
+  const char *         trimdomain[TRIMDOMAINS_MAX];
+  unsigned             flags;
+#  define HCONF_FLAG_INITED    (1 << 0) /* initialized? */
+#  define HCONF_FLAG_SPOOF     (1 << 1) /* refuse spoofed addresses */
+#  define HCONF_FLAG_SPOOFALERT        (1 << 2) /* syslog warning of spoofed */
+#  define HCONF_FLAG_REORDER   (1 << 3) /* list best address first */
+#  define HCONF_FLAG_MULTI     (1 << 4) /* see comments for gethtbyname() */
+} _res_hconf;
+
+extern void    _res_hconf_init (void);
+extern void    _res_hconf_trim_domain (char * domain);
+extern void    _res_hconf_trim_domains (struct hostent * hp);
+extern void    _res_hconf_reorder_addrs (struct hostent * hp);
+
+#endif /* _RES_HCONF_H_ */