2017-07-04 02:31:23 +08:00
|
|
|
/* Extended resolver state separate from struct __res_state.
|
2021-01-03 03:32:25 +08:00
|
|
|
Copyright (C) 2017-2021 Free Software Foundation, Inc.
|
2017-07-04 02:31:23 +08:00
|
|
|
This file is part of the GNU C Library.
|
|
|
|
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
|
|
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
|
|
|
|
Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
|
|
License along with the GNU C Library; if not, see
|
Prefer https to http for gnu.org and fsf.org URLs
Also, change sources.redhat.com to sourceware.org.
This patch was automatically generated by running the following shell
script, which uses GNU sed, and which avoids modifying files imported
from upstream:
sed -ri '
s,(http|ftp)(://(.*\.)?(gnu|fsf|sourceware)\.org($|[^.]|\.[^a-z])),https\2,g
s,(http|ftp)(://(.*\.)?)sources\.redhat\.com($|[^.]|\.[^a-z]),https\2sourceware.org\4,g
' \
$(find $(git ls-files) -prune -type f \
! -name '*.po' \
! -name 'ChangeLog*' \
! -path COPYING ! -path COPYING.LIB \
! -path manual/fdl-1.3.texi ! -path manual/lgpl-2.1.texi \
! -path manual/texinfo.tex ! -path scripts/config.guess \
! -path scripts/config.sub ! -path scripts/install-sh \
! -path scripts/mkinstalldirs ! -path scripts/move-if-change \
! -path INSTALL ! -path locale/programs/charmap-kw.h \
! -path po/libc.pot ! -path sysdeps/gnu/errlist.c \
! '(' -name configure \
-execdir test -f configure.ac -o -f configure.in ';' ')' \
! '(' -name preconfigure \
-execdir test -f preconfigure.ac ';' ')' \
-print)
and then by running 'make dist-prepare' to regenerate files built
from the altered files, and then executing the following to cleanup:
chmod a+x sysdeps/unix/sysv/linux/riscv/configure
# Omit irrelevant whitespace and comment-only changes,
# perhaps from a slightly-different Autoconf version.
git checkout -f \
sysdeps/csky/configure \
sysdeps/hppa/configure \
sysdeps/riscv/configure \
sysdeps/unix/sysv/linux/csky/configure
# Omit changes that caused a pre-commit check to fail like this:
# remote: *** error: sysdeps/powerpc/powerpc64/ppc-mcount.S: trailing lines
git checkout -f \
sysdeps/powerpc/powerpc64/ppc-mcount.S \
sysdeps/unix/sysv/linux/s390/s390-64/syscall.S
# Omit change that caused a pre-commit check to fail like this:
# remote: *** error: sysdeps/sparc/sparc64/multiarch/memcpy-ultra3.S: last line does not end in newline
git checkout -f sysdeps/sparc/sparc64/multiarch/memcpy-ultra3.S
2019-09-07 13:40:42 +08:00
|
|
|
<https://www.gnu.org/licenses/>. */
|
2017-07-04 02:31:23 +08:00
|
|
|
|
|
|
|
#include <resolv_conf.h>
|
|
|
|
|
|
|
|
#include <alloc_buffer.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <libc-lock.h>
|
|
|
|
#include <resolv-internal.h>
|
2017-07-04 03:06:23 +08:00
|
|
|
#include <sys/stat.h>
|
2018-06-22 21:28:47 +08:00
|
|
|
#include <libc-symbols.h>
|
2020-01-21 23:52:33 +08:00
|
|
|
#include <file_change_detection.h>
|
2017-07-04 02:31:23 +08:00
|
|
|
|
|
|
|
/* _res._u._ext.__glibc_extension_index is used as an index into a
|
|
|
|
struct resolv_conf_array object. The intent of this construction
|
|
|
|
is to make reasonably sure that even if struct __res_state objects
|
|
|
|
are copied around and patched by applications, we can still detect
|
2017-07-03 21:01:34 +08:00
|
|
|
accesses to stale extended resolver state. The array elements are
|
|
|
|
either struct resolv_conf * pointers (if the LSB is cleared) or
|
|
|
|
free list entries (if the LSB is set). The free list is used to
|
|
|
|
speed up finding available entries in the array. */
|
2017-07-04 02:31:23 +08:00
|
|
|
#define DYNARRAY_STRUCT resolv_conf_array
|
2017-07-03 21:01:34 +08:00
|
|
|
#define DYNARRAY_ELEMENT uintptr_t
|
2017-07-04 02:31:23 +08:00
|
|
|
#define DYNARRAY_PREFIX resolv_conf_array_
|
|
|
|
#define DYNARRAY_INITIAL_SIZE 0
|
|
|
|
#include <malloc/dynarray-skeleton.c>
|
|
|
|
|
|
|
|
/* A magic constant for XORing the extension index
|
|
|
|
(_res._u._ext.__glibc_extension_index). This makes it less likely
|
|
|
|
that a valid index is created by accident. In particular, a zero
|
|
|
|
value leads to an invalid index. */
|
|
|
|
#define INDEX_MAGIC 0x26a8fa5e48af8061ULL
|
|
|
|
|
|
|
|
/* Global resolv.conf-related state. */
|
|
|
|
struct resolv_conf_global
|
|
|
|
{
|
|
|
|
/* struct __res_state objects contain the extension index
|
|
|
|
(_res._u._ext.__glibc_extension_index ^ INDEX_MAGIC), which
|
|
|
|
refers to an element of this array. When a struct resolv_conf
|
|
|
|
object (extended resolver state) is associated with a struct
|
|
|
|
__res_state object (legacy resolver state), its reference count
|
|
|
|
is increased and added to this array. Conversely, if the
|
|
|
|
extended state is detached from the basic state (during
|
|
|
|
reinitialization or deallocation), the index is decremented, and
|
|
|
|
the array element is overwritten with NULL. */
|
|
|
|
struct resolv_conf_array array;
|
|
|
|
|
2017-07-04 17:18:34 +08:00
|
|
|
/* Start of the free list in the array. Zero if the free list is
|
|
|
|
empty. Otherwise, free_list_start >> 1 is the first element of
|
|
|
|
the free list (and the free list entries all have their LSB set
|
|
|
|
and are shifted one to the left). */
|
2017-07-03 21:01:34 +08:00
|
|
|
uintptr_t free_list_start;
|
|
|
|
|
2017-07-04 03:06:23 +08:00
|
|
|
/* Cached current configuration object for /etc/resolv.conf. */
|
|
|
|
struct resolv_conf *conf_current;
|
|
|
|
|
2020-01-21 23:52:33 +08:00
|
|
|
/* File system identification for /etc/resolv.conf. */
|
|
|
|
struct file_change_detection file_resolve_conf;
|
2017-07-04 02:31:23 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Lazily allocated storage for struct resolv_conf_global. */
|
|
|
|
static struct resolv_conf_global *global;
|
|
|
|
|
|
|
|
/* The lock synchronizes access to global and *global. It also
|
|
|
|
protects the __refcount member of struct resolv_conf. */
|
|
|
|
__libc_lock_define_initialized (static, lock);
|
|
|
|
|
|
|
|
/* Ensure that GLOBAL is allocated and lock it. Return NULL if
|
|
|
|
memory allocation failes. */
|
|
|
|
static struct resolv_conf_global *
|
|
|
|
get_locked_global (void)
|
|
|
|
{
|
|
|
|
__libc_lock_lock (lock);
|
|
|
|
/* Use relaxed MO through because of load outside the lock in
|
|
|
|
__resolv_conf_detach. */
|
|
|
|
struct resolv_conf_global *global_copy = atomic_load_relaxed (&global);
|
|
|
|
if (global_copy == NULL)
|
|
|
|
{
|
|
|
|
global_copy = calloc (1, sizeof (*global));
|
|
|
|
if (global_copy == NULL)
|
|
|
|
return NULL;
|
|
|
|
atomic_store_relaxed (&global, global_copy);
|
|
|
|
resolv_conf_array_init (&global_copy->array);
|
|
|
|
}
|
|
|
|
return global_copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Relinquish the lock acquired by get_locked_global. */
|
|
|
|
static void
|
|
|
|
put_locked_global (struct resolv_conf_global *global_copy)
|
|
|
|
{
|
|
|
|
__libc_lock_unlock (lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Decrement the reference counter. The caller must acquire the lock
|
|
|
|
around the function call. */
|
|
|
|
static void
|
|
|
|
conf_decrement (struct resolv_conf *conf)
|
|
|
|
{
|
|
|
|
assert (conf->__refcount > 0);
|
|
|
|
if (--conf->__refcount == 0)
|
|
|
|
free (conf);
|
|
|
|
}
|
|
|
|
|
2017-07-04 03:06:23 +08:00
|
|
|
struct resolv_conf *
|
|
|
|
__resolv_conf_get_current (void)
|
|
|
|
{
|
2020-01-21 23:52:33 +08:00
|
|
|
struct file_change_detection initial;
|
2020-02-18 20:44:48 +08:00
|
|
|
if (!__file_change_detection_for_path (&initial, _PATH_RESCONF))
|
2020-01-21 23:52:33 +08:00
|
|
|
return NULL;
|
2017-07-04 03:06:23 +08:00
|
|
|
|
|
|
|
struct resolv_conf_global *global_copy = get_locked_global ();
|
|
|
|
if (global_copy == NULL)
|
|
|
|
return NULL;
|
|
|
|
struct resolv_conf *conf;
|
|
|
|
if (global_copy->conf_current != NULL
|
2020-02-18 20:44:48 +08:00
|
|
|
&& __file_is_unchanged (&initial, &global_copy->file_resolve_conf))
|
2017-07-04 03:06:23 +08:00
|
|
|
/* We can reuse the cached configuration object. */
|
|
|
|
conf = global_copy->conf_current;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Parse configuration while holding the lock. This avoids
|
|
|
|
duplicate work. */
|
2020-01-22 00:38:15 +08:00
|
|
|
struct file_change_detection after_load;
|
|
|
|
conf = __resolv_conf_load (NULL, &after_load);
|
2017-07-04 03:06:23 +08:00
|
|
|
if (conf != NULL)
|
|
|
|
{
|
|
|
|
if (global_copy->conf_current != NULL)
|
|
|
|
conf_decrement (global_copy->conf_current);
|
|
|
|
global_copy->conf_current = conf; /* Takes ownership. */
|
|
|
|
|
2020-01-22 00:38:15 +08:00
|
|
|
/* Update file change detection data, but only if it matches
|
|
|
|
the initial measurement. This avoids an ABA race in case
|
|
|
|
/etc/resolv.conf is temporarily replaced while the file
|
|
|
|
is read (after the initial measurement), and restored to
|
|
|
|
the initial version later. */
|
2020-02-18 20:44:48 +08:00
|
|
|
if (__file_is_unchanged (&initial, &after_load))
|
2020-01-22 00:38:15 +08:00
|
|
|
global_copy->file_resolve_conf = after_load;
|
|
|
|
else
|
|
|
|
/* If there is a discrepancy, trigger a reload during the
|
|
|
|
next use. */
|
|
|
|
global_copy->file_resolve_conf.size = -1;
|
2017-07-04 03:06:23 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (conf != NULL)
|
|
|
|
{
|
|
|
|
/* Return an additional reference. */
|
|
|
|
assert (conf->__refcount > 0);
|
|
|
|
++conf->__refcount;
|
|
|
|
assert (conf->__refcount > 0);
|
|
|
|
}
|
|
|
|
put_locked_global (global_copy);
|
|
|
|
return conf;
|
|
|
|
}
|
|
|
|
|
2017-07-04 02:31:23 +08:00
|
|
|
/* Internal implementation of __resolv_conf_get, without validation
|
|
|
|
against *RESP. */
|
|
|
|
static struct resolv_conf *
|
|
|
|
resolv_conf_get_1 (const struct __res_state *resp)
|
|
|
|
{
|
|
|
|
/* Not initialized, and therefore no assoicated context. */
|
|
|
|
if (!(resp->options & RES_INIT))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
struct resolv_conf_global *global_copy = get_locked_global ();
|
|
|
|
if (global_copy == NULL)
|
|
|
|
/* A memory allocation failure here means that no associated
|
|
|
|
contexts exists, so returning NULL is correct. */
|
|
|
|
return NULL;
|
|
|
|
size_t index = resp->_u._ext.__glibc_extension_index ^ INDEX_MAGIC;
|
2017-07-03 21:01:34 +08:00
|
|
|
struct resolv_conf *conf = NULL;
|
2017-07-04 02:31:23 +08:00
|
|
|
if (index < resolv_conf_array_size (&global_copy->array))
|
|
|
|
{
|
2017-07-03 21:01:34 +08:00
|
|
|
uintptr_t *slot = resolv_conf_array_at (&global_copy->array, index);
|
|
|
|
if (!(*slot & 1))
|
|
|
|
{
|
|
|
|
conf = (struct resolv_conf *) *slot;
|
|
|
|
assert (conf->__refcount > 0);
|
|
|
|
++conf->__refcount;
|
|
|
|
}
|
2017-07-04 02:31:23 +08:00
|
|
|
}
|
|
|
|
put_locked_global (global_copy);
|
|
|
|
return conf;
|
|
|
|
}
|
|
|
|
|
2017-07-01 02:19:10 +08:00
|
|
|
/* Return true if both IPv4 addresses are equal. */
|
|
|
|
static bool
|
|
|
|
same_address_v4 (const struct sockaddr_in *left,
|
|
|
|
const struct sockaddr_in *right)
|
|
|
|
{
|
|
|
|
return left->sin_addr.s_addr == right->sin_addr.s_addr
|
|
|
|
&& left->sin_port == right->sin_port;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true if both IPv6 addresses are equal. This ignores the
|
|
|
|
flow label. */
|
|
|
|
static bool
|
|
|
|
same_address_v6 (const struct sockaddr_in6 *left,
|
|
|
|
const struct sockaddr_in6 *right)
|
|
|
|
{
|
|
|
|
return memcmp (&left->sin6_addr, &right->sin6_addr,
|
|
|
|
sizeof (left->sin6_addr)) == 0
|
|
|
|
&& left->sin6_port == right->sin6_port
|
|
|
|
&& left->sin6_scope_id == right->sin6_scope_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
same_address (const struct sockaddr *left, const struct sockaddr *right)
|
|
|
|
{
|
|
|
|
if (left->sa_family != right->sa_family)
|
|
|
|
return false;
|
|
|
|
switch (left->sa_family)
|
|
|
|
{
|
|
|
|
case AF_INET:
|
|
|
|
return same_address_v4 ((const struct sockaddr_in *) left,
|
|
|
|
(const struct sockaddr_in *) right);
|
|
|
|
case AF_INET6:
|
|
|
|
return same_address_v6 ((const struct sockaddr_in6 *) left,
|
|
|
|
(const struct sockaddr_in6 *) right);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-07-04 02:31:23 +08:00
|
|
|
/* Check that *RESP and CONF match. Used by __resolv_conf_get. */
|
|
|
|
static bool
|
|
|
|
resolv_conf_matches (const struct __res_state *resp,
|
|
|
|
const struct resolv_conf *conf)
|
|
|
|
{
|
2017-07-01 02:19:10 +08:00
|
|
|
/* NB: Do not compare the options, retrans, retry, ndots. These can
|
|
|
|
be changed by applicaiton. */
|
|
|
|
|
|
|
|
/* Check that the name servers in *RESP have not been modified by
|
|
|
|
the application. */
|
|
|
|
{
|
|
|
|
size_t nserv = conf->nameserver_list_size;
|
|
|
|
if (nserv > MAXNS)
|
|
|
|
nserv = MAXNS;
|
|
|
|
/* _ext.nscount is 0 until initialized by res_send.c. */
|
|
|
|
if (resp->nscount != nserv
|
2017-07-04 20:47:29 +08:00
|
|
|
|| (resp->_u._ext.nscount != 0 && resp->_u._ext.nscount != nserv))
|
2017-07-01 02:19:10 +08:00
|
|
|
return false;
|
|
|
|
for (size_t i = 0; i < nserv; ++i)
|
|
|
|
{
|
|
|
|
if (resp->nsaddr_list[i].sin_family == 0)
|
|
|
|
{
|
|
|
|
if (resp->_u._ext.nsaddrs[i]->sin6_family != AF_INET6)
|
|
|
|
return false;
|
|
|
|
if (!same_address ((struct sockaddr *) resp->_u._ext.nsaddrs[i],
|
|
|
|
conf->nameserver_list[i]))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else if (resp->nsaddr_list[i].sin_family != AF_INET)
|
|
|
|
return false;
|
|
|
|
else if (!same_address ((struct sockaddr *) &resp->nsaddr_list[i],
|
|
|
|
conf->nameserver_list[i]))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-01 06:53:05 +08:00
|
|
|
/* Check that the search list in *RESP has not been modified by the
|
|
|
|
application. */
|
|
|
|
{
|
2017-07-04 20:47:29 +08:00
|
|
|
if (resp->dnsrch[0] == NULL)
|
|
|
|
{
|
|
|
|
/* Empty search list. No default domain name. */
|
|
|
|
return conf->search_list_size == 0 && resp->defdname[0] == '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (resp->dnsrch[0] != resp->defdname)
|
|
|
|
/* If the search list is not empty, it must start with the
|
|
|
|
default domain name. */
|
|
|
|
return false;
|
|
|
|
|
|
|
|
size_t nsearch;
|
|
|
|
for (nsearch = 0; nsearch < MAXDNSRCH; ++nsearch)
|
|
|
|
if (resp->dnsrch[nsearch] == NULL)
|
|
|
|
break;
|
|
|
|
if (nsearch > MAXDNSRCH)
|
|
|
|
/* Search list is not null-terminated. */
|
2017-07-01 06:53:05 +08:00
|
|
|
return false;
|
2017-07-04 20:47:29 +08:00
|
|
|
|
2017-07-01 06:53:05 +08:00
|
|
|
size_t search_list_size = 0;
|
|
|
|
for (size_t i = 0; i < conf->search_list_size; ++i)
|
|
|
|
{
|
|
|
|
if (resp->dnsrch[i] != NULL)
|
|
|
|
{
|
|
|
|
search_list_size += strlen (resp->dnsrch[i]) + 1;
|
|
|
|
if (strcmp (resp->dnsrch[i], conf->search_list[i]) != 0)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* resp->dnsrch is truncated if the number of elements
|
|
|
|
exceeds MAXDNSRCH, or if the combined storage space for
|
|
|
|
the search list exceeds what can be stored in
|
|
|
|
resp->defdname. */
|
|
|
|
if (i == MAXDNSRCH || search_list_size > sizeof (resp->dnsrch))
|
|
|
|
break;
|
|
|
|
/* Otherwise, a mismatch indicates a match failure. */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-07-01 02:19:10 +08:00
|
|
|
|
|
|
|
/* Check that the sort list has not been modified. */
|
|
|
|
{
|
|
|
|
size_t nsort = conf->sort_list_size;
|
|
|
|
if (nsort > MAXRESOLVSORT)
|
|
|
|
nsort = MAXRESOLVSORT;
|
2017-07-04 20:47:29 +08:00
|
|
|
if (resp->nsort != nsort)
|
|
|
|
return false;
|
2017-07-01 02:19:10 +08:00
|
|
|
for (size_t i = 0; i < nsort; ++i)
|
|
|
|
if (resp->sort_list[i].addr.s_addr != conf->sort_list[i].addr.s_addr
|
|
|
|
|| resp->sort_list[i].mask != conf->sort_list[i].mask)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-07-04 02:31:23 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct resolv_conf *
|
|
|
|
__resolv_conf_get (struct __res_state *resp)
|
|
|
|
{
|
|
|
|
struct resolv_conf *conf = resolv_conf_get_1 (resp);
|
|
|
|
if (conf == NULL)
|
|
|
|
return NULL;
|
|
|
|
if (resolv_conf_matches (resp, conf))
|
|
|
|
return conf;
|
|
|
|
__resolv_conf_put (conf);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
__resolv_conf_put (struct resolv_conf *conf)
|
|
|
|
{
|
|
|
|
if (conf == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
__libc_lock_lock (lock);
|
|
|
|
conf_decrement (conf);
|
|
|
|
__libc_lock_unlock (lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct resolv_conf *
|
|
|
|
__resolv_conf_allocate (const struct resolv_conf *init)
|
|
|
|
{
|
2017-07-01 02:19:10 +08:00
|
|
|
/* Allocate in decreasing order of alignment. */
|
|
|
|
_Static_assert (__alignof__ (const char *const *)
|
|
|
|
<= __alignof__ (struct resolv_conf), "alignment");
|
|
|
|
_Static_assert (__alignof__ (struct sockaddr_in6)
|
|
|
|
<= __alignof__ (const char *const *), "alignment");
|
|
|
|
_Static_assert (__alignof__ (struct sockaddr_in)
|
|
|
|
== __alignof__ (struct sockaddr_in6), "alignment");
|
|
|
|
_Static_assert (__alignof__ (struct resolv_sortlist_entry)
|
|
|
|
<= __alignof__ (struct sockaddr_in), "alignment");
|
|
|
|
|
|
|
|
/* Space needed by the nameserver addresses. */
|
|
|
|
size_t address_space = 0;
|
|
|
|
for (size_t i = 0; i < init->nameserver_list_size; ++i)
|
|
|
|
if (init->nameserver_list[i]->sa_family == AF_INET)
|
|
|
|
address_space += sizeof (struct sockaddr_in);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert (init->nameserver_list[i]->sa_family == AF_INET6);
|
|
|
|
address_space += sizeof (struct sockaddr_in6);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Space needed by the search list strings. */
|
2017-07-01 06:53:05 +08:00
|
|
|
size_t string_space = 0;
|
|
|
|
for (size_t i = 0; i < init->search_list_size; ++i)
|
|
|
|
string_space += strlen (init->search_list[i]) + 1;
|
|
|
|
|
2017-07-04 02:31:23 +08:00
|
|
|
/* Allocate the buffer. */
|
|
|
|
void *ptr;
|
|
|
|
struct alloc_buffer buffer = alloc_buffer_allocate
|
2017-07-01 06:53:05 +08:00
|
|
|
(sizeof (struct resolv_conf)
|
2017-07-01 02:19:10 +08:00
|
|
|
+ init->nameserver_list_size * sizeof (init->nameserver_list[0])
|
|
|
|
+ address_space
|
2017-07-01 06:53:05 +08:00
|
|
|
+ init->search_list_size * sizeof (init->search_list[0])
|
2017-07-01 02:19:10 +08:00
|
|
|
+ init->sort_list_size * sizeof (init->sort_list[0])
|
2017-07-01 06:53:05 +08:00
|
|
|
+ string_space,
|
2017-07-04 02:31:23 +08:00
|
|
|
&ptr);
|
|
|
|
struct resolv_conf *conf
|
|
|
|
= alloc_buffer_alloc (&buffer, struct resolv_conf);
|
|
|
|
if (conf == NULL)
|
|
|
|
/* Memory allocation failure. */
|
|
|
|
return NULL;
|
|
|
|
assert (conf == ptr);
|
|
|
|
|
|
|
|
/* Initialize the contents. */
|
|
|
|
conf->__refcount = 1;
|
2017-07-01 02:19:10 +08:00
|
|
|
conf->retrans = init->retrans;
|
|
|
|
conf->retry = init->retry;
|
|
|
|
conf->options = init->options;
|
|
|
|
conf->ndots = init->ndots;
|
2017-07-04 02:31:23 +08:00
|
|
|
|
2017-07-01 02:19:10 +08:00
|
|
|
/* Allocate the arrays with pointers. These must come first because
|
|
|
|
they have the highets alignment. */
|
|
|
|
conf->nameserver_list_size = init->nameserver_list_size;
|
|
|
|
const struct sockaddr **nameserver_array = alloc_buffer_alloc_array
|
|
|
|
(&buffer, const struct sockaddr *, init->nameserver_list_size);
|
|
|
|
conf->nameserver_list = nameserver_array;
|
|
|
|
|
|
|
|
conf->search_list_size = init->search_list_size;
|
|
|
|
const char **search_array = alloc_buffer_alloc_array
|
|
|
|
(&buffer, const char *, init->search_list_size);
|
|
|
|
conf->search_list = search_array;
|
|
|
|
|
|
|
|
/* Fill the name server list array. */
|
|
|
|
for (size_t i = 0; i < init->nameserver_list_size; ++i)
|
|
|
|
if (init->nameserver_list[i]->sa_family == AF_INET)
|
|
|
|
{
|
|
|
|
struct sockaddr_in *sa = alloc_buffer_alloc
|
|
|
|
(&buffer, struct sockaddr_in);
|
|
|
|
*sa = *(struct sockaddr_in *) init->nameserver_list[i];
|
|
|
|
nameserver_array[i] = (struct sockaddr *) sa;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
struct sockaddr_in6 *sa = alloc_buffer_alloc
|
|
|
|
(&buffer, struct sockaddr_in6);
|
|
|
|
*sa = *(struct sockaddr_in6 *) init->nameserver_list[i];
|
|
|
|
nameserver_array[i] = (struct sockaddr *) sa;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate and fill the sort list array. */
|
|
|
|
{
|
|
|
|
conf->sort_list_size = init->sort_list_size;
|
|
|
|
struct resolv_sortlist_entry *array = alloc_buffer_alloc_array
|
|
|
|
(&buffer, struct resolv_sortlist_entry, init->sort_list_size);
|
|
|
|
conf->sort_list = array;
|
|
|
|
for (size_t i = 0; i < init->sort_list_size; ++i)
|
|
|
|
array[i] = init->sort_list[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill the search list array. This must come last because the
|
|
|
|
strings are the least aligned part of the allocation. */
|
2017-07-01 06:53:05 +08:00
|
|
|
{
|
|
|
|
for (size_t i = 0; i < init->search_list_size; ++i)
|
2017-07-01 02:19:10 +08:00
|
|
|
search_array[i] = alloc_buffer_copy_string
|
|
|
|
(&buffer, init->search_list[i]);
|
2017-07-01 06:53:05 +08:00
|
|
|
}
|
|
|
|
|
2017-07-04 02:31:23 +08:00
|
|
|
assert (!alloc_buffer_has_failed (&buffer));
|
|
|
|
return conf;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update *RESP from the extended state. */
|
|
|
|
static __attribute__ ((nonnull (1, 2), warn_unused_result)) bool
|
|
|
|
update_from_conf (struct __res_state *resp, const struct resolv_conf *conf)
|
|
|
|
{
|
2017-07-01 02:19:10 +08:00
|
|
|
resp->defdname[0] = '\0';
|
|
|
|
resp->pfcode = 0;
|
|
|
|
resp->_vcsock = -1;
|
|
|
|
resp->_flags = 0;
|
|
|
|
resp->ipv6_unavail = false;
|
|
|
|
resp->__glibc_unused_qhook = NULL;
|
|
|
|
resp->__glibc_unused_rhook = NULL;
|
|
|
|
|
|
|
|
resp->retrans = conf->retrans;
|
|
|
|
resp->retry = conf->retry;
|
|
|
|
resp->options = conf->options;
|
|
|
|
resp->ndots = conf->ndots;
|
|
|
|
|
|
|
|
/* Copy the name server addresses. */
|
|
|
|
{
|
|
|
|
resp->nscount = 0;
|
|
|
|
resp->_u._ext.nscount = 0;
|
|
|
|
size_t nserv = conf->nameserver_list_size;
|
|
|
|
if (nserv > MAXNS)
|
|
|
|
nserv = MAXNS;
|
|
|
|
for (size_t i = 0; i < nserv; i++)
|
|
|
|
{
|
|
|
|
if (conf->nameserver_list[i]->sa_family == AF_INET)
|
|
|
|
{
|
|
|
|
resp->nsaddr_list[i]
|
|
|
|
= *(struct sockaddr_in *)conf->nameserver_list[i];
|
|
|
|
resp->_u._ext.nsaddrs[i] = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert (conf->nameserver_list[i]->sa_family == AF_INET6);
|
|
|
|
resp->nsaddr_list[i].sin_family = 0;
|
|
|
|
/* Make a defensive copy of the name server address, in
|
|
|
|
case the application overwrites it. */
|
|
|
|
struct sockaddr_in6 *sa = malloc (sizeof (*sa));
|
|
|
|
if (sa == NULL)
|
|
|
|
{
|
|
|
|
for (size_t j = 0; j < i; ++j)
|
|
|
|
free (resp->_u._ext.nsaddrs[j]);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*sa = *(struct sockaddr_in6 *)conf->nameserver_list[i];
|
|
|
|
resp->_u._ext.nsaddrs[i] = sa;
|
|
|
|
}
|
|
|
|
resp->_u._ext.nssocks[i] = -1;
|
|
|
|
}
|
|
|
|
resp->nscount = nserv;
|
|
|
|
/* Leave resp->_u._ext.nscount at 0. res_send.c handles this. */
|
|
|
|
}
|
|
|
|
|
2017-07-01 06:53:05 +08:00
|
|
|
/* Fill in the prefix of the search list. It is truncated either at
|
|
|
|
MAXDNSRCH, or if reps->defdname has insufficient space. */
|
|
|
|
{
|
|
|
|
struct alloc_buffer buffer
|
|
|
|
= alloc_buffer_create (resp->defdname, sizeof (resp->defdname));
|
|
|
|
size_t size = conf->search_list_size;
|
|
|
|
size_t i;
|
|
|
|
for (i = 0; i < size && i < MAXDNSRCH; ++i)
|
|
|
|
{
|
|
|
|
resp->dnsrch[i] = alloc_buffer_copy_string
|
|
|
|
(&buffer, conf->search_list[i]);
|
|
|
|
if (resp->dnsrch[i] == NULL)
|
|
|
|
/* No more space in resp->defdname. Truncate. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
resp->dnsrch[i] = NULL;
|
|
|
|
}
|
|
|
|
|
2017-07-01 02:19:10 +08:00
|
|
|
/* Copy the sort list. */
|
|
|
|
{
|
|
|
|
size_t nsort = conf->sort_list_size;
|
|
|
|
if (nsort > MAXRESOLVSORT)
|
|
|
|
nsort = MAXRESOLVSORT;
|
|
|
|
for (size_t i = 0; i < nsort; ++i)
|
|
|
|
{
|
|
|
|
resp->sort_list[i].addr = conf->sort_list[i].addr;
|
|
|
|
resp->sort_list[i].mask = conf->sort_list[i].mask;
|
|
|
|
}
|
|
|
|
resp->nsort = nsort;
|
|
|
|
}
|
|
|
|
|
2017-07-04 02:31:23 +08:00
|
|
|
/* The overlapping parts of both configurations should agree after
|
|
|
|
initialization. */
|
|
|
|
assert (resolv_conf_matches (resp, conf));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Decrement the configuration object at INDEX and free it if the
|
|
|
|
reference counter reaches 0. *GLOBAL_COPY must be locked and
|
|
|
|
remains so. */
|
|
|
|
static void
|
|
|
|
decrement_at_index (struct resolv_conf_global *global_copy, size_t index)
|
|
|
|
{
|
|
|
|
if (index < resolv_conf_array_size (&global_copy->array))
|
|
|
|
{
|
2017-07-03 21:01:34 +08:00
|
|
|
/* Index found. */
|
|
|
|
uintptr_t *slot = resolv_conf_array_at (&global_copy->array, index);
|
|
|
|
/* Check that the slot is not already part of the free list. */
|
|
|
|
if (!(*slot & 1))
|
2017-07-04 02:31:23 +08:00
|
|
|
{
|
2017-07-03 21:01:34 +08:00
|
|
|
struct resolv_conf *conf = (struct resolv_conf *) *slot;
|
2017-07-04 02:31:23 +08:00
|
|
|
conf_decrement (conf);
|
2017-07-03 21:01:34 +08:00
|
|
|
/* Put the slot onto the free list. */
|
2017-07-04 17:18:34 +08:00
|
|
|
*slot = global_copy->free_list_start;
|
2017-07-03 21:01:34 +08:00
|
|
|
global_copy->free_list_start = (index << 1) | 1;
|
2017-07-04 02:31:23 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
__resolv_conf_attach (struct __res_state *resp, struct resolv_conf *conf)
|
|
|
|
{
|
|
|
|
assert (conf->__refcount > 0);
|
|
|
|
|
|
|
|
struct resolv_conf_global *global_copy = get_locked_global ();
|
|
|
|
if (global_copy == NULL)
|
2017-09-06 21:32:43 +08:00
|
|
|
return false;
|
2017-07-04 02:31:23 +08:00
|
|
|
|
|
|
|
/* Try to find an unused index in the array. */
|
|
|
|
size_t index;
|
|
|
|
{
|
2017-07-03 21:01:34 +08:00
|
|
|
if (global_copy->free_list_start & 1)
|
2017-07-04 02:31:23 +08:00
|
|
|
{
|
2017-07-03 21:01:34 +08:00
|
|
|
/* Unlink from the free list. */
|
|
|
|
index = global_copy->free_list_start >> 1;
|
|
|
|
uintptr_t *slot = resolv_conf_array_at (&global_copy->array, index);
|
|
|
|
global_copy->free_list_start = *slot;
|
2017-07-04 17:18:34 +08:00
|
|
|
assert (global_copy->free_list_start == 0
|
|
|
|
|| global_copy->free_list_start & 1);
|
2017-07-03 21:01:34 +08:00
|
|
|
/* Install the configuration pointer. */
|
|
|
|
*slot = (uintptr_t) conf;
|
2017-07-04 02:31:23 +08:00
|
|
|
}
|
2017-07-03 21:01:34 +08:00
|
|
|
else
|
2017-07-04 02:31:23 +08:00
|
|
|
{
|
2017-07-03 21:01:34 +08:00
|
|
|
size_t size = resolv_conf_array_size (&global_copy->array);
|
2017-07-04 02:31:23 +08:00
|
|
|
/* No usable index found. Increase the array size. */
|
2017-07-03 21:01:34 +08:00
|
|
|
resolv_conf_array_add (&global_copy->array, (uintptr_t) conf);
|
2017-07-04 02:31:23 +08:00
|
|
|
if (resolv_conf_array_has_failed (&global_copy->array))
|
|
|
|
{
|
|
|
|
put_locked_global (global_copy);
|
|
|
|
__set_errno (ENOMEM);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
/* The new array element was added at the end. */
|
|
|
|
index = size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We have added a new reference to the object. */
|
|
|
|
++conf->__refcount;
|
|
|
|
assert (conf->__refcount > 0);
|
|
|
|
put_locked_global (global_copy);
|
|
|
|
|
|
|
|
if (!update_from_conf (resp, conf))
|
|
|
|
{
|
|
|
|
/* Drop the reference we acquired. Reacquire the lock. The
|
|
|
|
object has already been allocated, so it cannot be NULL this
|
|
|
|
time. */
|
|
|
|
global_copy = get_locked_global ();
|
|
|
|
decrement_at_index (global_copy, index);
|
|
|
|
put_locked_global (global_copy);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
resp->_u._ext.__glibc_extension_index = index ^ INDEX_MAGIC;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
__resolv_conf_detach (struct __res_state *resp)
|
|
|
|
{
|
|
|
|
if (atomic_load_relaxed (&global) == NULL)
|
|
|
|
/* Detach operation after a shutdown, or without any prior
|
|
|
|
attachment. We cannot free the data (and there might not be
|
|
|
|
anything to free anyway). */
|
|
|
|
return;
|
|
|
|
|
|
|
|
struct resolv_conf_global *global_copy = get_locked_global ();
|
|
|
|
size_t index = resp->_u._ext.__glibc_extension_index ^ INDEX_MAGIC;
|
|
|
|
decrement_at_index (global_copy, index);
|
|
|
|
|
|
|
|
/* Clear the index field, so that accidental reuse is less
|
|
|
|
likely. */
|
|
|
|
resp->_u._ext.__glibc_extension_index = 0;
|
|
|
|
|
|
|
|
put_locked_global (global_copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Deallocate the global data. */
|
2018-06-26 21:13:54 +08:00
|
|
|
libc_freeres_fn (freeres)
|
2017-07-04 02:31:23 +08:00
|
|
|
{
|
|
|
|
/* No locking because this function is supposed to be called when
|
|
|
|
the process has turned single-threaded. */
|
|
|
|
if (global == NULL)
|
|
|
|
return;
|
|
|
|
|
2017-07-04 03:06:23 +08:00
|
|
|
if (global->conf_current != NULL)
|
|
|
|
{
|
|
|
|
conf_decrement (global->conf_current);
|
|
|
|
global->conf_current = NULL;
|
|
|
|
}
|
|
|
|
|
2017-07-04 02:31:23 +08:00
|
|
|
/* Note that this frees only the array itself. The pointed-to
|
|
|
|
configuration objects should have been deallocated by res_nclose
|
|
|
|
and per-thread cleanup functions. */
|
|
|
|
resolv_conf_array_free (&global->array);
|
|
|
|
|
|
|
|
free (global);
|
|
|
|
|
|
|
|
/* Stop potential future __resolv_conf_detach calls from accessing
|
|
|
|
deallocated memory. */
|
|
|
|
global = NULL;
|
|
|
|
}
|