summaryrefslogtreecommitdiff
path: root/resolv/res_hconf.c
diff options
context:
space:
mode:
Diffstat (limited to 'resolv/res_hconf.c')
-rw-r--r--resolv/res_hconf.c566
1 files changed, 566 insertions, 0 deletions
diff --git a/resolv/res_hconf.c b/resolv/res_hconf.c
new file mode 100644
index 0000000000..b08dd3ced7
--- /dev/null
+++ b/resolv/res_hconf.c
@@ -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
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-04 20:21:30 +0000