-/* Copyright (C) 1993, 95, 96, 97, 98, 99 Free Software Foundation, Inc.
+/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
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.
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 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.
+ Lesser 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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
/* 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').
+ the various name resolvers (/etc/hosts, named, NIS server, etc.).
+ Though mostly compatibly, the following differences exist compared
+ to the original implementation:
- line comments can appear anywhere (not just at the beginning of
a line)
*/
+
+#include <assert.h>
+#include <errno.h>
#include <ctype.h>
+#include <libintl.h>
#include <memory.h>
#include <stdio.h>
+#include <stdio_ext.h>
#include <stdlib.h>
#include <string.h>
#include <net/if.h>
-
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <libc-lock.h>
+#include "ifreq.h"
#include "res_hconf.h"
+#include <wchar.h>
+#include <atomic.h>
+
+#if IS_IN (libc)
+# define fgets_unlocked __fgets_unlocked
+#endif
#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 int);
-static const char *arg_trimdomain_list (const char *, int, const char *,
- unsigned int);
-static const char *arg_spoof (const char *, int, const char *, unsigned int);
-static const char *arg_bool (const char *, int, const char *, unsigned int);
+enum parse_cbs
+ {
+ CB_none,
+ CB_arg_trimdomain_list,
+ CB_arg_bool
+ };
-static struct cmd
+static const struct cmd
{
- const char *name;
- const char *(*parse_args) (const char * filename, int line_num,
- const char * args, unsigned int arg);
+ const char name[11];
+ uint8_t cb;
unsigned int 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}
+ {"order", CB_none, 0},
+ {"trim", CB_arg_trimdomain_list, 0},
+ {"multi", CB_arg_bool, HCONF_FLAG_MULTI},
+ {"reorder", CB_arg_bool, HCONF_FLAG_REORDER}
};
/* Structure containing the state. */
static const char *
-arg_service_list (const char *fname, int line_num, const char *args,
- unsigned int arg)
+arg_trimdomain_list (const char *fname, int line_num, const char *args)
{
- enum Name_Service service;
- const char *start;
+ 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
{
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)
+ if (_res_hconf.num_trimdomains >= TRIMDOMAINS_MAX)
{
- 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;
-}
+ char *buf;
+ if (__asprintf (&buf, _("\
+%s: line %d: cannot specify more than %d trim domains"),
+ fname, line_num, TRIMDOMAINS_MAX) < 0)
+ return 0;
-static const char *
-arg_trimdomain_list (const char *fname, int line_num, const char *args,
- unsigned int flag)
-{
- const char * start;
- size_t len;
+ __fxprintf (NULL, "%s", buf);
- 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);
+ free (buf);
return 0;
}
_res_hconf.trimdomain[_res_hconf.num_trimdomains++] =
args = skip_ws (++args);
if (!*args || *args == '#')
{
- fprintf (stderr,
- "%s: line %d: list delimiter not followed by domain",
- fname, line_num);
+ char *buf;
+
+ if (__asprintf (&buf, _("\
+%s: line %d: list delimiter not followed by domain"),
+ fname, line_num) < 0)
+ return 0;
+
+ __fxprintf (NULL, "%s", buf);
+
+ free (buf);
return 0;
}
default:
}
-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)
{
}
else
{
- fprintf (stderr, "%s: line %d: expected `on' or `off', found `%s'\n",
- fname, line_num, args);
+ char *buf;
+
+ if (__asprintf (&buf,
+ _("%s: line %d: expected `on' or `off', found `%s'\n"),
+ fname, line_num, args) < 0)
+ return 0;
+
+ __fxprintf (NULL, "%s", buf);
+
+ free (buf);
return 0;
}
return args;
parse_line (const char *fname, int line_num, const char *str)
{
const char *start;
- struct cmd *c = 0;
+ const struct cmd *c = 0;
size_t len;
- int i;
+ size_t i;
str = skip_ws (str);
for (i = 0; i < sizeof (cmd) / sizeof (cmd[0]); ++i)
{
- if (strncasecmp (start, cmd[i].name, len) == 0
+ if (__strncasecmp (start, cmd[i].name, len) == 0
&& strlen (cmd[i].name) == len)
{
c = &cmd[i];
}
if (c == NULL)
{
- fprintf (stderr, "%s: line %d: bad command `%s'\n",
- fname, line_num, start);
+ char *buf;
+
+ if (__asprintf (&buf, _("%s: line %d: bad command `%s'\n"),
+ fname, line_num, start) < 0)
+ return;
+
+ __fxprintf (NULL, "%s", buf);
+
+ free (buf);
return;
}
/* process args: */
str = skip_ws (str);
- str = (*c->parse_args) (fname, line_num, str, c->arg);
+
+ if (c->cb == CB_arg_trimdomain_list)
+ str = arg_trimdomain_list (fname, line_num, str);
+ else if (c->cb == CB_arg_bool)
+ str = arg_bool (fname, line_num, str, c->arg);
+ else
+ /* Ignore the line. */
+ return;
+
if (!str)
return;
{
if (!isspace (*str)) {
if (*str != '#')
- fprintf (stderr, "%s: line %d: ignoring trailing garbage `%s'\n",
- fname, line_num, str);
+ {
+ char *buf;
+
+ if (__asprintf (&buf,
+ _("%s: line %d: ignoring trailing garbage `%s'\n"),
+ fname, line_num, str) < 0)
+ break;
+
+ __fxprintf (NULL, "%s", buf);
+
+ free (buf);
+ }
break;
}
++str;
}
-/* Initialize hconf datastructure by reading host.conf file and
- environment variables. */
-void
-_res_hconf_init (void)
+static void
+do_init (void)
{
const char *hconf_name;
int line_num = 0;
char buf[256], *envval;
FILE *fp;
- if (_res_hconf.initialized)
- return;
-
memset (&_res_hconf, '\0', sizeof (_res_hconf));
- hconf_name = __secure_getenv (ENV_HOSTCONF);
+ hconf_name = getenv (ENV_HOSTCONF);
if (hconf_name == NULL)
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
+ fp = fopen (hconf_name, "rce");
+ if (fp)
{
+ /* No threads using this stream. */
+ __fsetlocking (fp, FSETLOCKING_BYCALLER);
+
while (fgets_unlocked (buf, sizeof (buf), fp))
{
++line_num;
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_TRIM_ADD);
if (envval)
- arg_trimdomain_list (ENV_TRIM_ADD, 1, envval, 0);
+ arg_trimdomain_list (ENV_TRIM_ADD, 1, envval);
envval = getenv (ENV_TRIM_OVERR);
if (envval)
{
_res_hconf.num_trimdomains = 0;
- arg_trimdomain_list (ENV_TRIM_OVERR, 1, envval, 0);
+ arg_trimdomain_list (ENV_TRIM_OVERR, 1, envval);
}
- _res_hconf.initialized = 1;
+ /* See comments on the declaration of _res_hconf. */
+ atomic_store_release (&_res_hconf.initialized, 1);
}
+/* Initialize hconf datastructure by reading host.conf file and
+ environment variables. */
+void
+_res_hconf_init (void)
+{
+ __libc_once_define (static, once);
+
+ __libc_once (once, do_init);
+}
+
+
+#if IS_IN (libc)
+# if defined SIOCGIFCONF && defined SIOCGIFNETMASK
+/* List of known interfaces. */
+libc_freeres_ptr (
+static struct netaddr
+{
+ int addrtype;
+ union
+ {
+ struct
+ {
+ uint32_t addr;
+ uint32_t mask;
+ } ipv4;
+ } u;
+} *ifaddrs);
+# endif
+
/* 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. */
+ Otherwise, nothing is changed.
+
+ Note that this function currently only handles IPv4 addresses. */
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;
+ int i, j;
+ /* Number of interfaces. Also serves as a flag for the
+ double-checked locking idiom. */
+ static int num_ifs = -1;
+ /* Local copy of num_ifs, for non-atomic access. */
+ int num_ifs_local;
+ /* We need to protect the dynamic buffer handling. The lock is only
+ acquired during initialization. Afterwards, a positive num_ifs
+ value indicates completed initialization. */
+ __libc_lock_define_initialized (static, lock);
+
+ /* Only reorder if we're supposed to. */
+ if ((_res_hconf.flags & HCONF_FLAG_REORDER) == 0)
+ return;
+ /* Can't deal with anything but IPv4 for now... */
if (hp->h_addrtype != AF_INET)
- return; /* can't deal with anything but IPv4 for now... */
+ return;
- if (num_ifs <= 0)
+ /* This load synchronizes with the release MO store in the
+ initialization block below. */
+ num_ifs_local = atomic_load_acquire (&num_ifs);
+ if (num_ifs_local <= 0)
{
- struct ifconf ifs;
- struct ifreq *ifr;
- size_t size, num;
- int sd;
+ struct ifreq *ifr, *cur_ifr;
+ int sd, num, i;
+ /* Save errno. */
+ int save = errno;
- /* initialize interface table: */
+ /* Initialize interface table. */
- num_ifs = 0;
-
- sd = __socket (AF_INET, SOCK_DGRAM, 0);
+ /* The SIOCGIFNETMASK ioctl will only work on an AF_INET socket. */
+ sd = __socket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 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
+ /* Get lock. */
+ __libc_lock_lock (lock);
+
+ /* Recheck, somebody else might have done the work by now. No
+ ordering is required for the load because we have the lock,
+ and num_ifs is only updated under the lock. Also see (3) in
+ the analysis below. */
+ num_ifs_local = atomic_load_relaxed (&num_ifs);
+ if (num_ifs_local <= 0)
{
- size += 4 * sizeof (struct ifreq);
- ifs.ifc_buf = realloc (ifs.ifs_buf, size);
- if (ifs.ifc_buf == NULL)
- {
- close (sd);
- return;
- }
- ifs.ifc_len = size;
- if (__ioctl (sd, SIOCGIFCONF, &ifs) < 0)
+ /* This is the only block which writes to num_ifs. It can
+ be executed several times (sequentially) if
+ initialization does not yield any interfaces, and num_ifs
+ remains zero. However, once we stored a positive value
+ in num_ifs below, this block cannot be entered again due
+ to the condition above. */
+ int new_num_ifs = 0;
+
+ /* Get a list of interfaces. */
+ __ifreq (&ifr, &num, sd);
+ if (!ifr)
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 cleanup1;
- ifaddrs = malloc (num * sizeof (ifaddrs[0]));
- if (!ifaddrs)
- goto cleanup;
+ /* Copy usable interfaces in ifaddrs structure. */
+ for (cur_ifr = ifr, i = 0; i < num;
+ cur_ifr = __if_nextreq (cur_ifr), ++i)
+ {
+ union
+ {
+ struct sockaddr sa;
+ struct sockaddr_in sin;
+ } ss;
- 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;
+ if (cur_ifr->ifr_addr.sa_family != AF_INET)
+ continue;
- memcpy (&ifaddrs[num_ifs].u.ipv4.addr,
- &((struct sockaddr_in *)ifr->ifr_addr)->sin_addr, 4);
+ ifaddrs[new_num_ifs].addrtype = AF_INET;
+ ss.sa = cur_ifr->ifr_addr;
+ ifaddrs[new_num_ifs].u.ipv4.addr = ss.sin.sin_addr.s_addr;
- if (__ioctl (sd, SIOCGIFNETMASK, if) < 0)
- continue;
- memcpy (&ifaddrs[num_ifs].u.ipv4.mask,
- ((struct sockaddr_in *)ifr->ifr_mask)->sin_addr, 4);
+ if (__ioctl (sd, SIOCGIFNETMASK, cur_ifr) < 0)
+ continue;
- ++num_ifs; /* now we're committed to this entry */
+ ss.sa = cur_ifr->ifr_netmask;
+ ifaddrs[new_num_ifs].u.ipv4.mask = ss.sin.sin_addr.s_addr;
+
+ /* Now we're committed to this entry. */
+ ++new_num_ifs;
+ }
+ /* Just keep enough memory to hold all the interfaces we want. */
+ ifaddrs = realloc (ifaddrs, new_num_ifs * sizeof (ifaddrs[0]));
+ assert (ifaddrs != NULL);
+
+ cleanup1:
+ __if_freereq (ifr, num);
+
+ cleanup:
+ /* Release lock, preserve error value, and close socket. */
+ errno = save;
+
+ /* Advertise successful initialization if new_num_ifs is
+ positive (and no updates to ifaddrs are permitted after
+ that). Otherwise, num_ifs remains unchanged, at zero.
+ This store synchronizes with the initial acquire MO
+ load. */
+ atomic_store_release (&num_ifs, new_num_ifs);
+ /* Keep the local copy current, to save another load. */
+ num_ifs_local = new_num_ifs;
}
- /* 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);
+ __libc_lock_unlock (lock);
+
+ __close (sd);
}
- if (num_ifs == 0)
+ /* num_ifs_local cannot be negative because the if statement above
+ covered this case. It can still be zero if we just performed
+ initialization, but could not find any interfaces. */
+ if (num_ifs_local == 0)
return;
- /* find an address for which we have a direct connection: */
+ /* The code below accesses ifaddrs, so we need to ensure that the
+ initialization happens-before this point.
+
+ The actual initialization is sequenced-before the release store
+ to num_ifs, and sequenced-before the end of the critical section.
+
+ This means there are three possible executions:
+
+ (1) The thread that initialized the data also uses it, so
+ sequenced-before is sufficient to ensure happens-before.
+
+ (2) The release MO store of num_ifs synchronizes-with the acquire
+ MO load, and the acquire MO load is sequenced before the use
+ of the initialized data below.
+
+ (3) We enter the critical section, and the relaxed MO load of
+ num_ifs yields a positive value. The write to ifaddrs is
+ sequenced-before leaving the critical section. Leaving the
+ critical section happens-before we entered the critical
+ section ourselves, which means that the write to ifaddrs
+ happens-before this point.
+
+ Consequently, all potential writes to ifaddrs (and the data it
+ points to) happens-before this point. */
+
+ /* 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];
+ struct in_addr *haddr = (struct in_addr *) hp->h_addr_list[i];
- for (j = 0; j < num_ifs; ++j)
+ for (j = 0; j < num_ifs_local; ++j)
{
- if_addr = ifaddrs[j].u.ipv4.addr;
- if_netmask = ifaddrs[j].u.ipv4.mask;
+ uint32_t if_addr = ifaddrs[j].u.ipv4.addr;
+ uint32_t if_netmask = ifaddrs[j].u.ipv4.mask;
- if (((h_addr->s_addr ^ if_addr) & if_netmask) == 0)
+ if (((haddr->s_addr ^ if_addr) & if_netmask) == 0)
{
void *tmp;
for (i = 0; hp->h_aliases[i]; ++i)
_res_hconf_trim_domain (hp->h_aliases[i]);
}
+#endif
projects / thirdparty / glibc.git / blobdiff