11325444590

Committed 14 Oct 2024 10:08AM UTC coverage: 91.212% (+0.008%) from 91.204%

Build # 11325444590

Build Type

push

github

Committed by

bradh352

Commit Message

fcntl doesn't take O_CLOEXEC, it takes FD_CLOEXEC

As reported on Android 14, which recently added a fortify check for fcntl
F_SETFD to make sure only FD_CLOEXEC is ever passed:
https://github.com/aosp-mirror/platform_bionic/commit/dfe67d266

We can't pass anything else to it.  Even though on glibc, O_CLOEXEC
and FD_CLOEXEC are the same value, this isn't defined to be
portable in any way.

Fixes #900
Reported-By: Yuki San (@RealYukiSan)
Authored-By: Brad House (@bradh352)

Run Details

22003 of 24123 relevant lines covered (91.21%)

12038.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.56

/src/lib/ares_init.c

/* MIT License
 *
 * Copyright (c) 1998 Massachusetts Institute of Technology
 * Copyright (c) 2007 Daniel Stenberg
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * SPDX-License-Identifier: MIT
 */

#include "ares_private.h"

#ifdef HAVE_SYS_PARAM_H
#  include <sys/param.h>
#endif

#ifdef HAVE_NETINET_IN_H
#  include <netinet/in.h>
#endif

#ifdef HAVE_NETDB_H
#  include <netdb.h>
#endif

#ifdef HAVE_ARPA_INET_H
#  include <arpa/inet.h>
#endif

#include "ares_nameser.h"

#if defined(ANDROID) || defined(__ANDROID__)
#  include <sys/system_properties.h>
#  include "ares_android.h"
/* From the Bionic sources */
#  define DNS_PROP_NAME_PREFIX "net.dns"
#  define MAX_DNS_PROPERTIES   8
#endif

#if defined(CARES_USE_LIBRESOLV)
#  include <resolv.h>
#endif

#if defined(USE_WINSOCK) && defined(HAVE_IPHLPAPI_H)
#  include <iphlpapi.h>
#endif

#include "ares_inet_net_pton.h"
#include "event/ares_event.h"

int ares_init(ares_channel_t **channelptr)
{
  return ares_init_options(channelptr, NULL, 0);
}

static int ares_query_timeout_cmp_cb(const void *arg1, const void *arg2)
{
  const ares_query_t *q1 = arg1;
  const ares_query_t *q2 = arg2;

  if (q1->timeout.sec > q2->timeout.sec) {
    return 1;
  }
  if (q1->timeout.sec < q2->timeout.sec) {
    return -1;
  }

  if (q1->timeout.usec > q2->timeout.usec) {
    return 1;
  }
  if (q1->timeout.usec < q2->timeout.usec) {
    return -1;
  }

  return 0;
}

static int server_sort_cb(const void *data1, const void *data2)
{
  const ares_server_t *s1 = data1;
  const ares_server_t *s2 = data2;

  if (s1->consec_failures < s2->consec_failures) {
    return -1;
  }
  if (s1->consec_failures > s2->consec_failures) {
    return 1;
  }
  if (s1->idx < s2->idx) {
    return -1;
  }
  if (s1->idx > s2->idx) {
    return 1;
  }
  return 0;
}

static void server_destroy_cb(void *data)
{
  if (data == NULL) {
    return; /* LCOV_EXCL_LINE: DefensiveCoding */
  }
  ares_destroy_server(data);
}

static ares_status_t init_by_defaults(ares_channel_t *channel)
{
  char         *hostname = NULL;
  ares_status_t rc       = ARES_SUCCESS;
#ifdef HAVE_GETHOSTNAME
  const char *dot;
#endif
  struct ares_addr addr;
  ares_llist_t    *sconfig = NULL;

  /* Enable EDNS by default */
  if (!(channel->optmask & ARES_OPT_FLAGS)) {
    channel->flags = ARES_FLAG_EDNS;
  }
  if (channel->ednspsz == 0) {
    channel->ednspsz = EDNSPACKETSZ;
  }

  if (channel->timeout == 0) {
    channel->timeout = DEFAULT_TIMEOUT;
  }

  if (channel->tries == 0) {
    channel->tries = DEFAULT_TRIES;
  }

  if (ares_slist_len(channel->servers) == 0) {
    /* Add a default local named server to the channel unless configured not
     * to (in which case return an error).
     */
    if (channel->flags & ARES_FLAG_NO_DFLT_SVR) {
      rc = ARES_ENOSERVER;
      goto error;
    }

    addr.family            = AF_INET;
    addr.addr.addr4.s_addr = htonl(INADDR_LOOPBACK);

    rc = ares_sconfig_append(channel, &sconfig, &addr, 0, 0, NULL);
    if (rc != ARES_SUCCESS) {
      goto error; /* LCOV_EXCL_LINE: OutOfMemory */
    }

    rc = ares_servers_update(channel, sconfig, ARES_FALSE);
    ares_llist_destroy(sconfig);

    if (rc != ARES_SUCCESS) {
      goto error;
    }
  }

  if (channel->ndomains == 0) {
    /* Derive a default domain search list from the kernel hostname,
     * or set it to empty if the hostname isn't helpful.
     */
#ifndef HAVE_GETHOSTNAME
    channel->ndomains = 0; /* default to none */
#else
    size_t len        = 256;
    channel->ndomains = 0; /* default to none */

    hostname = ares_malloc(len);
    if (!hostname) {
      rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
      goto error;       /* LCOV_EXCL_LINE: OutOfMemory */
    }

    if (gethostname(hostname, (GETHOSTNAME_TYPE_ARG2)len) != 0) {
      /* Lets not treat a gethostname failure as critical, since we
       * are ok if gethostname doesn't even exist */
      *hostname = '\0';
    }

    dot = strchr(hostname, '.');
    if (dot) {
      /* a dot was found */
      channel->domains = ares_malloc(sizeof(char *));
      if (!channel->domains) {
        rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
        goto error;       /* LCOV_EXCL_LINE: OutOfMemory */
      }
      channel->domains[0] = ares_strdup(dot + 1);
      if (!channel->domains[0]) {
        rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
        goto error;       /* LCOV_EXCL_LINE: OutOfMemory */
      }
      channel->ndomains = 1;
    }
#endif
  }

  if (channel->nsort == 0) {
    channel->sortlist = NULL;
  }

  if (!channel->lookups) {
    channel->lookups = ares_strdup("fb");
    if (!channel->lookups) {
      rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
    }
  }

  /* Set default fields for server failover behavior */
  if (!(channel->optmask & ARES_OPT_SERVER_FAILOVER)) {
    channel->server_retry_chance = DEFAULT_SERVER_RETRY_CHANCE;
    channel->server_retry_delay  = DEFAULT_SERVER_RETRY_DELAY;
  }

error:
  if (hostname) {
    ares_free(hostname);
  }

  return rc;
}

int ares_init_options(ares_channel_t           **channelptr,
                      const struct ares_options *options, int optmask)
{
  ares_channel_t *channel;
  ares_status_t   status = ARES_SUCCESS;

  if (ares_library_initialized() != ARES_SUCCESS) {
    return ARES_ENOTINITIALIZED; /* LCOV_EXCL_LINE: n/a on non-WinSock */
  }

  channel = ares_malloc_zero(sizeof(*channel));
  if (!channel) {
    *channelptr = NULL;
    return ARES_ENOMEM;
  }

  /* We are in a good state */
  channel->sys_up = ARES_TRUE;

  /* One option where zero is valid, so set default value here */
  channel->ndots = 1;

  status = ares_channel_threading_init(channel);
  if (status != ARES_SUCCESS) {
    goto done;
  }

  /* Generate random key */
  channel->rand_state = ares_init_rand_state();
  if (channel->rand_state == NULL) {
    status = ARES_ENOMEM;
    DEBUGF(fprintf(stderr, "Error: init_id_key failed: %s\n",
                   ares_strerror(status)));
    goto done;
  }

  /* Initialize Server List */
  channel->servers =
    ares_slist_create(channel->rand_state, server_sort_cb, server_destroy_cb);
  if (channel->servers == NULL) {
    status = ARES_ENOMEM;
    goto done;
  }

  /* Initialize our lists of queries */
  channel->all_queries = ares_llist_create(NULL);
  if (channel->all_queries == NULL) {
    status = ARES_ENOMEM;
    goto done;
  }

  channel->queries_by_qid = ares_htable_szvp_create(NULL);
  if (channel->queries_by_qid == NULL) {
    status = ARES_ENOMEM;
    goto done;
  }

  channel->queries_by_timeout =
    ares_slist_create(channel->rand_state, ares_query_timeout_cmp_cb, NULL);
  if (channel->queries_by_timeout == NULL) {
    status = ARES_ENOMEM;
    goto done;
  }

  channel->connnode_by_socket = ares_htable_asvp_create(NULL);
  if (channel->connnode_by_socket == NULL) {
    status = ARES_ENOMEM;
    goto done;
  }

  /* Initialize configuration by each of the four sources, from highest
   * precedence to lowest.
   */

  status = ares_init_by_options(channel, options, optmask);
  if (status != ARES_SUCCESS) {
    DEBUGF(fprintf(stderr, "Error: init_by_options failed: %s\n",
                   ares_strerror(status)));
    /* If we fail to apply user-specified options, fail the whole init process
     */
    goto done;
  }

  /* Go ahead and let it initialize the query cache even if the ttl is 0 and
   * completely unused.  This reduces the number of different code paths that
   * might be followed even if there is a minor performance hit. */
  status = ares_qcache_create(channel->rand_state, channel->qcache_max_ttl,
                              &channel->qcache);
  if (status != ARES_SUCCESS) {
    goto done; /* LCOV_EXCL_LINE: OutOfMemory */
  }

  if (status == ARES_SUCCESS) {
    status = ares_init_by_sysconfig(channel);
    if (status != ARES_SUCCESS) {
      DEBUGF(fprintf(stderr, "Error: init_by_sysconfig failed: %s\n",
                     ares_strerror(status)));
    }
  }

  /*
   * No matter what failed or succeeded, seed defaults to provide
   * useful behavior for things that we missed.
   */
  status = init_by_defaults(channel);
  if (status != ARES_SUCCESS) {
    DEBUGF(fprintf(stderr, "Error: init_by_defaults failed: %s\n",
                   ares_strerror(status)));
    goto done;
  }

  ares_set_socket_functions_def(channel);

  /* Initialize the event thread */
  if (channel->optmask & ARES_OPT_EVENT_THREAD) {
    ares_event_thread_t *e = NULL;

    status = ares_event_thread_init(channel);
    if (status != ARES_SUCCESS) {
      goto done; /* LCOV_EXCL_LINE: UntestablePath */
    }

    /* Initialize monitor for configuration changes.  In some rare cases,
     * ARES_ENOTIMP may occur (OpenWatcom), ignore this. */
    e      = channel->sock_state_cb_data;
    status = ares_event_configchg_init(&e->configchg, e);
    if (status != ARES_SUCCESS && status != ARES_ENOTIMP) {
      goto done; /* LCOV_EXCL_LINE: UntestablePath */
    }
    status = ARES_SUCCESS;
  }

done:
  if (status != ARES_SUCCESS) {
    ares_destroy(channel);
    return (int)status;
  }

  *channelptr = channel;
  return ARES_SUCCESS;
}

static void *ares_reinit_thread(void *arg)
{
  ares_channel_t *channel = arg;
  ares_status_t   status;

  /* ares_init_by_sysconfig() will lock when applying the config, but not
   * when retrieving. */
  status = ares_init_by_sysconfig(channel);
  if (status != ARES_SUCCESS) {
    DEBUGF(fprintf(stderr, "Error: init_by_sysconfig failed: %s\n",
                   ares_strerror(status)));
  }

  ares_channel_lock(channel);

  /* Flush cached queries on reinit */
  if (status == ARES_SUCCESS && channel->qcache) {
    ares_qcache_flush(channel->qcache);
  }

  channel->reinit_pending = ARES_FALSE;
  ares_channel_unlock(channel);

  return NULL;
}

ares_status_t ares_reinit(ares_channel_t *channel)
{
  ares_status_t status = ARES_SUCCESS;

  if (channel == NULL) {
    return ARES_EFORMERR;
  }

  ares_channel_lock(channel);

  /* If a reinit is already in process, lets not do it again. Or if we are
   * shutting down, skip. */
  if (!channel->sys_up || channel->reinit_pending) {
    ares_channel_unlock(channel);
    return ARES_SUCCESS;
  }
  channel->reinit_pending = ARES_TRUE;
  ares_channel_unlock(channel);

  if (ares_threadsafety()) {
    /* clean up the prior reinit process's thread.  We know the thread isn't
     * running since reinit_pending was false */
    if (channel->reinit_thread != NULL) {
      void *rv;
      ares_thread_join(channel->reinit_thread, &rv);
      channel->reinit_thread = NULL;
    }

    /* Spawn a new thread */
    status =
      ares_thread_create(&channel->reinit_thread, ares_reinit_thread, channel);
    if (status != ARES_SUCCESS) {
      /* LCOV_EXCL_START: UntestablePath */
      ares_channel_lock(channel);
      channel->reinit_pending = ARES_FALSE;
      ares_channel_unlock(channel);
      /* LCOV_EXCL_STOP */
    }
  } else {
    /* Threading support not available, call directly */
    ares_reinit_thread(channel);
  }

  return status;
}

/* ares_dup() duplicates a channel handle with all its options and returns a
   new channel handle */
int ares_dup(ares_channel_t **dest, const ares_channel_t *src)
{
  struct ares_options opts;
  ares_status_t       rc;
  int                 optmask;

  if (dest == NULL || src == NULL) {
    return ARES_EFORMERR;
  }

  *dest = NULL; /* in case of failure return NULL explicitly */

  /* First get the options supported by the old ares_save_options() function,
     which is most of them */
  rc = (ares_status_t)ares_save_options(src, &opts, &optmask);
  if (rc != ARES_SUCCESS) {
    ares_destroy_options(&opts);
    goto done;
  }

  /* Then create the new channel with those options */
  rc = (ares_status_t)ares_init_options(dest, &opts, optmask);

  /* destroy the options copy to not leak any memory */
  ares_destroy_options(&opts);

  if (rc != ARES_SUCCESS) {
    goto done;
  }

  ares_channel_lock(src);
  /* Now clone the options that ares_save_options() doesn't support, but are
   * user-provided */
  (*dest)->sock_create_cb            = src->sock_create_cb;
  (*dest)->sock_create_cb_data       = src->sock_create_cb_data;
  (*dest)->sock_config_cb            = src->sock_config_cb;
  (*dest)->sock_config_cb_data       = src->sock_config_cb_data;
  memcpy(&(*dest)->sock_funcs, &(src->sock_funcs), sizeof((*dest)->sock_funcs));
  (*dest)->sock_func_cb_data         = src->sock_func_cb_data;
  (*dest)->legacy_sock_funcs         = src->legacy_sock_funcs;
  (*dest)->legacy_sock_funcs_cb_data = src->legacy_sock_funcs_cb_data;
  (*dest)->server_state_cb           = src->server_state_cb;
  (*dest)->server_state_cb_data      = src->server_state_cb_data;

  ares_strcpy((*dest)->local_dev_name, src->local_dev_name,
              sizeof((*dest)->local_dev_name));
  (*dest)->local_ip4 = src->local_ip4;
  memcpy((*dest)->local_ip6, src->local_ip6, sizeof(src->local_ip6));
  ares_channel_unlock(src);

  /* Servers are a bit unique as ares_init_options() only allows ipv4 servers
   * and not a port per server, but there are other user specified ways, that
   * too will toggle the optmask ARES_OPT_SERVERS to let us know.  If that's
   * the case, pull them in.
   *
   * We don't want to clone system-configuration servers though.
   *
   * We must use the "csv" format to get things like link-local address support
   */

  if (optmask & ARES_OPT_SERVERS) {
    char *csv = ares_get_servers_csv(src);
    if (csv == NULL) {
      /* LCOV_EXCL_START: OutOfMemory */
      ares_destroy(*dest);
      *dest = NULL;
      rc    = ARES_ENOMEM;
      goto done;
      /* LCOV_EXCL_STOP */
    }

    rc = (ares_status_t)ares_set_servers_ports_csv(*dest, csv);
    ares_free_string(csv);
    if (rc != ARES_SUCCESS) {
      /* LCOV_EXCL_START: OutOfMemory */
      ares_destroy(*dest);
      *dest = NULL;
      goto done;
      /* LCOV_EXCL_STOP */
    }
  }

  rc = ARES_SUCCESS;
done:
  return (int)rc; /* everything went fine */
}

void ares_set_local_ip4(ares_channel_t *channel, unsigned int local_ip)
{
  if (channel == NULL) {
    return;
  }
  ares_channel_lock(channel);
  channel->local_ip4 = local_ip;
  ares_channel_unlock(channel);
}

/* local_ip6 should be 16 bytes in length */
void ares_set_local_ip6(ares_channel_t *channel, const unsigned char *local_ip6)
{
  if (channel == NULL) {
    return;
  }
  ares_channel_lock(channel);
  memcpy(&channel->local_ip6, local_ip6, sizeof(channel->local_ip6));
  ares_channel_unlock(channel);
}

/* local_dev_name should be null terminated. */
void ares_set_local_dev(ares_channel_t *channel, const char *local_dev_name)
{
  if (channel == NULL) {
    return;
  }

  ares_channel_lock(channel);
  ares_strcpy(channel->local_dev_name, local_dev_name,
              sizeof(channel->local_dev_name));
  channel->local_dev_name[sizeof(channel->local_dev_name) - 1] = 0;
  ares_channel_unlock(channel);
}

int ares_set_sortlist(ares_channel_t *channel, const char *sortstr)
{
  size_t           nsort    = 0;
  struct apattern *sortlist = NULL;
  ares_status_t    status;

  if (!channel) {
    return ARES_ENODATA;
  }
  ares_channel_lock(channel);

  status = ares_parse_sortlist(&sortlist, &nsort, sortstr);
  if (status == ARES_SUCCESS && sortlist) {
    if (channel->sortlist) {
      ares_free(channel->sortlist);
    }
    channel->sortlist = sortlist;
    channel->nsort    = nsort;

    /* Save sortlist as if it was passed in as an option */
    channel->optmask |= ARES_OPT_SORTLIST;
  }
  ares_channel_unlock(channel);
  return (int)status;
}

1	/* MIT License
2	*
3	* Copyright (c) 1998 Massachusetts Institute of Technology
4	* Copyright (c) 2007 Daniel Stenberg
5	*
6	* Permission is hereby granted, free of charge, to any person obtaining a copy
7	* of this software and associated documentation files (the "Software"), to deal
8	* in the Software without restriction, including without limitation the rights
9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10	* copies of the Software, and to permit persons to whom the Software is
11	* furnished to do so, subject to the following conditions:
12	*
13	* The above copyright notice and this permission notice (including the next
14	* paragraph) shall be included in all copies or substantial portions of the
15	* Software.
16	*
17	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23	* SOFTWARE.
24	*
25	* SPDX-License-Identifier: MIT
26	*/
27
28	#include "ares_private.h"
29
30	#ifdef HAVE_SYS_PARAM_H
31	# include <sys/param.h>
32	#endif
33
34	#ifdef HAVE_NETINET_IN_H
35	# include <netinet/in.h>
36	#endif
37
38	#ifdef HAVE_NETDB_H
39	# include <netdb.h>
40	#endif
41
42	#ifdef HAVE_ARPA_INET_H
43	# include <arpa/inet.h>
44	#endif
45
46	#include "ares_nameser.h"
47
48	#if defined(ANDROID) \|\| defined(__ANDROID__)
49	# include <sys/system_properties.h>
50	# include "ares_android.h"
51	/* From the Bionic sources */
52	# define DNS_PROP_NAME_PREFIX "net.dns"
53	# define MAX_DNS_PROPERTIES 8
54	#endif
55
56	#if defined(CARES_USE_LIBRESOLV)
57	# include <resolv.h>
58	#endif
59
60	#if defined(USE_WINSOCK) && defined(HAVE_IPHLPAPI_H)
61	# include <iphlpapi.h>
62	#endif
63
64	#include "ares_inet_net_pton.h"
65	#include "event/ares_event.h"
66
67	int ares_init(ares_channel_t **channelptr)	51✔
68	{
69	return ares_init_options(channelptr, NULL, 0);	51✔
70	}
71
72	static int ares_query_timeout_cmp_cb(const void arg1, const void arg2)	17,360✔
73	{
74	const ares_query_t *q1 = arg1;	17,360✔
75	const ares_query_t *q2 = arg2;	17,360✔
76
77	if (q1->timeout.sec > q2->timeout.sec) {	17,360✔
78	return 1;	×
79	}
80	if (q1->timeout.sec < q2->timeout.sec) {	17,360✔
81	return -1;	×
82	}
83
84	if (q1->timeout.usec > q2->timeout.usec) {	17,360✔
85	return 1;	17,360✔
86	}
87	if (q1->timeout.usec < q2->timeout.usec) {	×
88	return -1;	×
89	}
90
91	return 0;	×
92	}
93
94	static int server_sort_cb(const void data1, const void data2)	6,530✔
95	{
96	const ares_server_t *s1 = data1;	6,530✔
97	const ares_server_t *s2 = data2;	6,530✔
98
99	if (s1->consec_failures < s2->consec_failures) {	6,530✔
100	return -1;	534✔
101	}
102	if (s1->consec_failures > s2->consec_failures) {	5,996✔
103	return 1;	478✔
104	}
105	if (s1->idx < s2->idx) {	5,518✔
106	return -1;	539✔
107	}
108	if (s1->idx > s2->idx) {	4,979✔
109	return 1;	580✔
110	}
111	return 0;	4,399✔
112	}
113
114	static void server_destroy_cb(void *data)	877✔
115	{
116	if (data == NULL) {	877✔
117	return; /* LCOV_EXCL_LINE: DefensiveCoding */
118	}
119	ares_destroy_server(data);	877✔
120	}
121
122	static ares_status_t init_by_defaults(ares_channel_t *channel)	1,014✔
123	{
124	char *hostname = NULL;	1,014✔
125	ares_status_t rc = ARES_SUCCESS;	1,014✔
126	#ifdef HAVE_GETHOSTNAME
127	const char *dot;
128	#endif
129	struct ares_addr addr;
130	ares_llist_t *sconfig = NULL;	1,014✔
131
132	/* Enable EDNS by default */
133	if (!(channel->optmask & ARES_OPT_FLAGS)) {	1,014✔
134	channel->flags = ARES_FLAG_EDNS;	152✔
135	}
136	if (channel->ednspsz == 0) {	1,014✔
137	channel->ednspsz = EDNSPACKETSZ;	1,011✔
138	}
139
140	if (channel->timeout == 0) {	1,014✔
141	channel->timeout = DEFAULT_TIMEOUT;	161✔
142	}
143
144	if (channel->tries == 0) {	1,014✔
145	channel->tries = DEFAULT_TRIES;	161✔
146	}
147
148	if (ares_slist_len(channel->servers) == 0) {	1,014✔
149	/* Add a default local named server to the channel unless configured not
150	* to (in which case return an error).
151	*/
152	if (channel->flags & ARES_FLAG_NO_DFLT_SVR) {	10✔
153	rc = ARES_ENOSERVER;	1✔
154	goto error;	1✔
155	}
156
157	addr.family = AF_INET;	9✔
158	addr.addr.addr4.s_addr = htonl(INADDR_LOOPBACK);	9✔
159
160	rc = ares_sconfig_append(channel, &sconfig, &addr, 0, 0, NULL);	9✔
161	if (rc != ARES_SUCCESS) {	9✔
162	goto error; /* LCOV_EXCL_LINE: OutOfMemory */
163	}
164
165	rc = ares_servers_update(channel, sconfig, ARES_FALSE);	9✔
166	ares_llist_destroy(sconfig);	9✔
167
168	if (rc != ARES_SUCCESS) {	9✔
169	goto error;	×
170	}
171	}
172
173	if (channel->ndomains == 0) {	1,013✔
174	/* Derive a default domain search list from the kernel hostname,
175	* or set it to empty if the hostname isn't helpful.
176	*/
177	#ifndef HAVE_GETHOSTNAME
178	channel->ndomains = 0; /* default to none */
179	#else
180	size_t len = 256;	10✔
181	channel->ndomains = 0; /* default to none */	10✔
182
183	hostname = ares_malloc(len);	10✔
184	if (!hostname) {	10✔
185	rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
186	goto error; /* LCOV_EXCL_LINE: OutOfMemory */
187	}
188
189	if (gethostname(hostname, (GETHOSTNAME_TYPE_ARG2)len) != 0) {	10✔
190	/* Lets not treat a gethostname failure as critical, since we
191	* are ok if gethostname doesn't even exist */
192	*hostname = '\0';	×
193	}
194
195	dot = strchr(hostname, '.');	10✔
196	if (dot) {	10✔
197	/* a dot was found */
198	channel->domains = ares_malloc(sizeof(char *));	1✔
199	if (!channel->domains) {	1✔
200	rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
201	goto error; /* LCOV_EXCL_LINE: OutOfMemory */
202	}
203	channel->domains[0] = ares_strdup(dot + 1);	1✔
204	if (!channel->domains[0]) {	1✔
205	rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
206	goto error; /* LCOV_EXCL_LINE: OutOfMemory */
207	}
208	channel->ndomains = 1;	1✔
209	}
210	#endif
211	}
212
213	if (channel->nsort == 0) {	1,013✔
214	channel->sortlist = NULL;	1,009✔
215	}
216
217	if (!channel->lookups) {	1,013✔
218	channel->lookups = ares_strdup("fb");	12✔
219	if (!channel->lookups) {	12✔
220	rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
221	}
222	}
223
224	/* Set default fields for server failover behavior */
225	if (!(channel->optmask & ARES_OPT_SERVER_FAILOVER)) {	1,013✔
226	channel->server_retry_chance = DEFAULT_SERVER_RETRY_CHANCE;	997✔
227	channel->server_retry_delay = DEFAULT_SERVER_RETRY_DELAY;	997✔
228	}
229
230	error:	16✔
231	if (hostname) {	1,014✔
232	ares_free(hostname);	10✔
233	}
234
235	return rc;	1,014✔
236	}
237
238	int ares_init_options(ares_channel_t **channelptr,	1,064✔
239	const struct ares_options *options, int optmask)
240	{
241	ares_channel_t *channel;
242	ares_status_t status = ARES_SUCCESS;	1,064✔
243
244	if (ares_library_initialized() != ARES_SUCCESS) {	1,064✔
245	return ARES_ENOTINITIALIZED; /* LCOV_EXCL_LINE: n/a on non-WinSock */
246	}
247
248	channel = ares_malloc_zero(sizeof(*channel));	1,064✔
249	if (!channel) {	1,064✔
250	*channelptr = NULL;	5✔
251	return ARES_ENOMEM;	5✔
252	}
253
254	/* We are in a good state */
255	channel->sys_up = ARES_TRUE;	1,059✔
256
257	/* One option where zero is valid, so set default value here */
258	channel->ndots = 1;	1,059✔
259
260	status = ares_channel_threading_init(channel);	1,059✔
261	if (status != ARES_SUCCESS) {	1,059✔
262	goto done;	8✔
263	}
264
265	/* Generate random key */
266	channel->rand_state = ares_init_rand_state();	1,051✔
267	if (channel->rand_state == NULL) {	1,051✔
268	status = ARES_ENOMEM;	4✔
269	DEBUGF(fprintf(stderr, "Error: init_id_key failed: %s\n",
270	ares_strerror(status)));
271	goto done;	4✔
272	}
273
274	/* Initialize Server List */
275	channel->servers =	1,047✔
276	ares_slist_create(channel->rand_state, server_sort_cb, server_destroy_cb);	1,047✔
277	if (channel->servers == NULL) {	1,047✔
278	status = ARES_ENOMEM;	8✔
279	goto done;	8✔
280	}
281
282	/* Initialize our lists of queries */
283	channel->all_queries = ares_llist_create(NULL);	1,039✔
284	if (channel->all_queries == NULL) {	1,039✔
285	status = ARES_ENOMEM;	4✔
286	goto done;	4✔
287	}
288
289	channel->queries_by_qid = ares_htable_szvp_create(NULL);	1,035✔
290	if (channel->queries_by_qid == NULL) {	1,035✔
291	status = ARES_ENOMEM;	10✔
292	goto done;	10✔
293	}
294
295	channel->queries_by_timeout =	1,025✔
296	ares_slist_create(channel->rand_state, ares_query_timeout_cmp_cb, NULL);	1,025✔
297	if (channel->queries_by_timeout == NULL) {	1,025✔
298	status = ARES_ENOMEM;	2✔
299	goto done;	2✔
300	}
301
302	channel->connnode_by_socket = ares_htable_asvp_create(NULL);	1,023✔
303	if (channel->connnode_by_socket == NULL) {	1,023✔
304	status = ARES_ENOMEM;	3✔
305	goto done;	3✔
306	}
307
308	/* Initialize configuration by each of the four sources, from highest
309	* precedence to lowest.
310	*/
311
312	status = ares_init_by_options(channel, options, optmask);	1,020✔
313	if (status != ARES_SUCCESS) {	1,020✔
314	DEBUGF(fprintf(stderr, "Error: init_by_options failed: %s\n",
315	ares_strerror(status)));
316	/* If we fail to apply user-specified options, fail the whole init process
317	*/
318	goto done;	×
319	}
320
321	/* Go ahead and let it initialize the query cache even if the ttl is 0 and
322	* completely unused. This reduces the number of different code paths that
323	* might be followed even if there is a minor performance hit. */
324	status = ares_qcache_create(channel->rand_state, channel->qcache_max_ttl,	1,020✔
325	&channel->qcache);
326	if (status != ARES_SUCCESS) {	1,020✔
327	goto done; /* LCOV_EXCL_LINE: OutOfMemory */
328	}
329
330	if (status == ARES_SUCCESS) {	1,014✔
331	status = ares_init_by_sysconfig(channel);	1,014✔
332	if (status != ARES_SUCCESS) {
333	DEBUGF(fprintf(stderr, "Error: init_by_sysconfig failed: %s\n",
334	ares_strerror(status)));
335	}
336	}
337
338	/*
339	* No matter what failed or succeeded, seed defaults to provide
340	* useful behavior for things that we missed.
341	*/
342	status = init_by_defaults(channel);	1,014✔
343	if (status != ARES_SUCCESS) {	1,014✔
344	DEBUGF(fprintf(stderr, "Error: init_by_defaults failed: %s\n",
345	ares_strerror(status)));
346	goto done;	1✔
347	}
348
349	ares_set_socket_functions_def(channel);	1,013✔
350
351	/* Initialize the event thread */
352	if (channel->optmask & ARES_OPT_EVENT_THREAD) {	1,013✔
353	ares_event_thread_t *e = NULL;	522✔
354
355	status = ares_event_thread_init(channel);	522✔
356	if (status != ARES_SUCCESS) {	522✔
357	goto done; /* LCOV_EXCL_LINE: UntestablePath */
358	}
359
360	/* Initialize monitor for configuration changes. In some rare cases,
361	* ARES_ENOTIMP may occur (OpenWatcom), ignore this. */
362	e = channel->sock_state_cb_data;	522✔
363	status = ares_event_configchg_init(&e->configchg, e);	522✔
364	if (status != ARES_SUCCESS && status != ARES_ENOTIMP) {	522✔
365	goto done; /* LCOV_EXCL_LINE: UntestablePath */
366	}
367	status = ARES_SUCCESS;	522✔
368	}
369
370	done:	491✔
371	if (status != ARES_SUCCESS) {	1,059✔
372	ares_destroy(channel);	46✔
373	return (int)status;	46✔
374	}
375
376	*channelptr = channel;	1,013✔
377	return ARES_SUCCESS;	1,013✔
378	}
379
380	static void ares_reinit_thread(void arg)	24✔
381	{
382	ares_channel_t *channel = arg;	24✔
383	ares_status_t status;
384
385	/* ares_init_by_sysconfig() will lock when applying the config, but not
386	* when retrieving. */
387	status = ares_init_by_sysconfig(channel);	24✔
388	if (status != ARES_SUCCESS) {
389	DEBUGF(fprintf(stderr, "Error: init_by_sysconfig failed: %s\n",
390	ares_strerror(status)));
391	}
392
393	ares_channel_lock(channel);	24✔
394
395	/* Flush cached queries on reinit */
396	if (status == ARES_SUCCESS && channel->qcache) {	24✔
397	ares_qcache_flush(channel->qcache);	24✔
398	}
399
400	channel->reinit_pending = ARES_FALSE;	24✔
401	ares_channel_unlock(channel);	24✔
402
403	return NULL;	24✔
404	}
405
406	ares_status_t ares_reinit(ares_channel_t *channel)	25✔
407	{
408	ares_status_t status = ARES_SUCCESS;	25✔
409
410	if (channel == NULL) {	25✔
411	return ARES_EFORMERR;	1✔
412	}
413
414	ares_channel_lock(channel);	24✔
415
416	/* If a reinit is already in process, lets not do it again. Or if we are
417	* shutting down, skip. */
418	if (!channel->sys_up \|\| channel->reinit_pending) {	24✔
419	ares_channel_unlock(channel);	×
420	return ARES_SUCCESS;	×
421	}
422	channel->reinit_pending = ARES_TRUE;	24✔
423	ares_channel_unlock(channel);	24✔
424
425	if (ares_threadsafety()) {	24✔
426	/* clean up the prior reinit process's thread. We know the thread isn't
427	* running since reinit_pending was false */
428	if (channel->reinit_thread != NULL) {	24✔
429	void *rv;
430	ares_thread_join(channel->reinit_thread, &rv);	×
431	channel->reinit_thread = NULL;	×
432	}
433
434	/* Spawn a new thread */
435	status =
436	ares_thread_create(&channel->reinit_thread, ares_reinit_thread, channel);	24✔
437	if (status != ARES_SUCCESS) {	24✔
438	/* LCOV_EXCL_START: UntestablePath */
439	ares_channel_lock(channel);
440	channel->reinit_pending = ARES_FALSE;
441	ares_channel_unlock(channel);
442	/* LCOV_EXCL_STOP */
443	}
444	} else {
445	/* Threading support not available, call directly */
446	ares_reinit_thread(channel);	×
447	}
448
449	return status;	24✔
450	}
451
452	/* ares_dup() duplicates a channel handle with all its options and returns a
453	new channel handle */
454	int ares_dup(ares_channel_t *dest, const ares_channel_t src)	22✔
455	{
456	struct ares_options opts;
457	ares_status_t rc;
458	int optmask;
459
460	if (dest == NULL \|\| src == NULL) {	22✔
461	return ARES_EFORMERR;	1✔
462	}
463
464	dest = NULL; / in case of failure return NULL explicitly */	21✔
465
466	/* First get the options supported by the old ares_save_options() function,
467	which is most of them */
468	rc = (ares_status_t)ares_save_options(src, &opts, &optmask);	21✔
469	if (rc != ARES_SUCCESS) {	21✔
470	ares_destroy_options(&opts);	8✔
471	goto done;	8✔
472	}
473
474	/* Then create the new channel with those options */
475	rc = (ares_status_t)ares_init_options(dest, &opts, optmask);	13✔
476
477	/* destroy the options copy to not leak any memory */
478	ares_destroy_options(&opts);	13✔
479
480	if (rc != ARES_SUCCESS) {	13✔
481	goto done;	10✔
482	}
483
484	ares_channel_lock(src);	3✔
485	/* Now clone the options that ares_save_options() doesn't support, but are
486	* user-provided */
487	(*dest)->sock_create_cb = src->sock_create_cb;	3✔
488	(*dest)->sock_create_cb_data = src->sock_create_cb_data;	3✔
489	(*dest)->sock_config_cb = src->sock_config_cb;	3✔
490	(*dest)->sock_config_cb_data = src->sock_config_cb_data;	3✔
491	memcpy(&(dest)->sock_funcs, &(src->sock_funcs), sizeof((dest)->sock_funcs));	3✔
492	(*dest)->sock_func_cb_data = src->sock_func_cb_data;	3✔
493	(*dest)->legacy_sock_funcs = src->legacy_sock_funcs;	3✔
494	(*dest)->legacy_sock_funcs_cb_data = src->legacy_sock_funcs_cb_data;	3✔
495	(*dest)->server_state_cb = src->server_state_cb;	3✔
496	(*dest)->server_state_cb_data = src->server_state_cb_data;	3✔
497
498	ares_strcpy((*dest)->local_dev_name, src->local_dev_name,	3✔
499	sizeof((*dest)->local_dev_name));
500	(*dest)->local_ip4 = src->local_ip4;	3✔
501	memcpy((*dest)->local_ip6, src->local_ip6, sizeof(src->local_ip6));	3✔
502	ares_channel_unlock(src);	3✔
503
504	/* Servers are a bit unique as ares_init_options() only allows ipv4 servers
505	* and not a port per server, but there are other user specified ways, that
506	* too will toggle the optmask ARES_OPT_SERVERS to let us know. If that's
507	* the case, pull them in.
508	*
509	* We don't want to clone system-configuration servers though.
510	*
511	* We must use the "csv" format to get things like link-local address support
512	*/
513
514	if (optmask & ARES_OPT_SERVERS) {	3✔
515	char *csv = ares_get_servers_csv(src);	2✔
516	if (csv == NULL) {	2✔
517	/* LCOV_EXCL_START: OutOfMemory */
518	ares_destroy(*dest);
519	*dest = NULL;
520	rc = ARES_ENOMEM;
521	goto done;
522	/* LCOV_EXCL_STOP */
523	}
524
525	rc = (ares_status_t)ares_set_servers_ports_csv(*dest, csv);	2✔
526	ares_free_string(csv);	2✔
527	if (rc != ARES_SUCCESS) {	2✔
528	/* LCOV_EXCL_START: OutOfMemory */
529	ares_destroy(*dest);
530	*dest = NULL;
531	goto done;
532	/* LCOV_EXCL_STOP */
533	}
534	}
535
536	rc = ARES_SUCCESS;	3✔
537	done:	21✔
538	return (int)rc; /* everything went fine */	21✔
539	}
540
541	void ares_set_local_ip4(ares_channel_t *channel, unsigned int local_ip)	26✔
542	{
543	if (channel == NULL) {	26✔
544	return;	1✔
545	}
546	ares_channel_lock(channel);	25✔
547	channel->local_ip4 = local_ip;	25✔
548	ares_channel_unlock(channel);	25✔
549	}
550
551	/* local_ip6 should be 16 bytes in length */
552	void ares_set_local_ip6(ares_channel_t channel, const unsigned char local_ip6)	26✔
553	{
554	if (channel == NULL) {	26✔
555	return;	1✔
556	}
557	ares_channel_lock(channel);	25✔
558	memcpy(&channel->local_ip6, local_ip6, sizeof(channel->local_ip6));	25✔
559	ares_channel_unlock(channel);	25✔
560	}
561
562	/* local_dev_name should be null terminated. */
563	void ares_set_local_dev(ares_channel_t channel, const char local_dev_name)	26✔
564	{
565	if (channel == NULL) {	26✔
566	return;	1✔
567	}
568
569	ares_channel_lock(channel);	25✔
570	ares_strcpy(channel->local_dev_name, local_dev_name,	25✔
571	sizeof(channel->local_dev_name));
572	channel->local_dev_name[sizeof(channel->local_dev_name) - 1] = 0;	25✔
573	ares_channel_unlock(channel);	25✔
574	}
575
576	int ares_set_sortlist(ares_channel_t channel, const char sortstr)	83✔
577	{
578	size_t nsort = 0;	83✔
579	struct apattern *sortlist = NULL;	83✔
580	ares_status_t status;
581
582	if (!channel) {	83✔
583	return ARES_ENODATA;	1✔
584	}
585	ares_channel_lock(channel);	82✔
586
587	status = ares_parse_sortlist(&sortlist, &nsort, sortstr);	82✔
588	if (status == ARES_SUCCESS && sortlist) {	82✔
589	if (channel->sortlist) {	73✔
590	ares_free(channel->sortlist);	39✔
591	}
592	channel->sortlist = sortlist;	73✔
593	channel->nsort = nsort;	73✔
594
595	/* Save sortlist as if it was passed in as an option */
596	channel->optmask \|= ARES_OPT_SORTLIST;	73✔
597	}
598	ares_channel_unlock(channel);	82✔
599	return (int)status;	82✔
600	}

c-ares / c-ares / 11325444590

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous