/*
- * Copyright (c) 2014 Andreas Schneider <asn@samba.org>
- * Copyright (c) 2014 Jakub Hrozek <jakub.hrozek@posteo.se>
+ * Copyright (c) 2014-2018 Andreas Schneider <asn@samba.org>
+ * Copyright (c) 2014-2016 Jakub Hrozek <jakub.hrozek@posteo.se>
*
* All rights reserved.
*
#include <resolv.h>
+#if defined(HAVE_RES_STATE_U_EXT_NSADDRS) || defined(HAVE_RES_SOCKADDR_UNION_SIN6)
+#define HAVE_RESOLV_IPV6_NSADDRS 1
+#endif
+
/* GCC has printf type attribute check. */
#ifdef HAVE_ATTRIBUTE_PRINTF_FORMAT
#define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
RWRAP_LOG_TRACE
};
+#ifndef HAVE_GETPROGNAME
+static const char *getprogname(void)
+{
+#if defined(HAVE_PROGRAM_INVOCATION_SHORT_NAME)
+ return program_invocation_short_name;
+#elif defined(HAVE_GETEXECNAME)
+ return getexecname();
+#else
+ return NULL;
+#endif /* HAVE_PROGRAM_INVOCATION_SHORT_NAME */
+}
+#endif /* HAVE_GETPROGNAME */
+
static void rwrap_log(enum rwrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
# define RWRAP_LOG(dbglvl, ...) rwrap_log((dbglvl), __func__, __VA_ARGS__)
va_list va;
const char *d;
unsigned int lvl = 0;
- int pid = getpid();
const char *prefix = NULL;
+ const char *progname = NULL;
d = getenv("RESOLV_WRAPPER_DEBUGLEVEL");
if (d != NULL) {
break;
}
+ progname = getprogname();
+ if (progname == NULL) {
+ progname = "<unknown>";
+ }
+
fprintf(stderr,
- "%s(%d) - %s: %s\n",
+ "%s[%s (%u)] - %s: %s\n",
prefix,
- pid,
+ progname,
+ (unsigned int)getpid(),
func,
buffer);
}
#define RWRAP_MAX_RECURSION 64
+union rwrap_sockaddr {
+ struct sockaddr sa;
+ struct sockaddr_in in;
+ struct sockaddr_in6 in6;
+};
+
/* Priority and weight can be omitted from the hosts file, but need to be part
* of the output
*/
struct rwrap_soa_rrdata soa_rec;
char cname_rec[MAXDNAME];
char ptr_rec[MAXDNAME];
+ char txt_rec[MAXDNAME];
} rrdata;
char key[MAXDNAME];
NEXT_KEY(str_prio, str_weight);
if (uri == NULL) {
RWRAP_LOG(RWRAP_LOG_ERROR,
- "Malformed URI entry [%s]\n", value);
+ "Malformed URI entry [<null>]\n");
return -1;
}
return 0;
}
+static int rwrap_create_fake_txt_rr(const char *key,
+ const char *value,
+ struct rwrap_fake_rr *rr)
+{
+ memcpy(rr->rrdata.txt_rec, value, strlen(value) + 1);
+
+ memcpy(rr->key, key, strlen(key) + 1);
+ rr->type = ns_t_txt;
+ return 0;
+}
+
static int rwrap_create_fake_soa_rr(const char *key,
const char *value,
struct rwrap_fake_rr *rr)
return 0;
}
+#define rwrap_randomid() 0xffff & getpid()
+
/* Prepares a fake header with a single response. Advances header_blob */
static ssize_t rwrap_fake_header(uint8_t **header_blob, size_t remaining,
size_t ancount, size_t arcount)
{
- uint8_t *hb;
- HEADER *h;
+ union {
+ uint8_t *blob;
+ HEADER *header;
+ } h;
if (remaining < NS_HFIXEDSZ) {
RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small!\n");
return -1;
}
- hb = *header_blob;
- memset(hb, 0, NS_HFIXEDSZ);
+ h.blob = *header_blob;
+ memset(h.blob, 0, NS_HFIXEDSZ);
- h = (HEADER *) hb;
- h->id = res_randomid(); /* random query ID */
- h->qr = 1; /* response flag */
- h->rd = 1; /* recursion desired */
- h->ra = 1; /* recursion available */
+ h.header->id = rwrap_randomid(); /* random query ID */
+ h.header->qr = 1; /* response flag */
+ h.header->rd = 1; /* recursion desired */
+ h.header->ra = 1; /* recursion available */
- h->qdcount = htons(1); /* no. of questions */
- h->ancount = htons(ancount); /* no. of answers */
- h->arcount = htons(arcount); /* no. of add'tl records */
+ h.header->qdcount = htons(1); /* no. of questions */
+ h.header->ancount = htons(ancount); /* no. of answers */
+ h.header->arcount = htons(arcount); /* no. of add'tl records */
- hb += NS_HFIXEDSZ; /* move past the header */
- *header_blob = hb;
+ /* move past the header */
+ *header_blob = h.blob += NS_HFIXEDSZ;
return NS_HFIXEDSZ;
}
return resp_size;
}
+static ssize_t rwrap_fake_txt(struct rwrap_fake_rr *rr,
+ uint8_t *answer,
+ size_t anslen)
+{
+ uint8_t *a = answer;
+ ssize_t resp_size;
+ size_t rdata_size;
+ size_t txt_len;
+
+ if (rr->type != ns_t_txt) {
+ RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
+ return -1;
+ }
+ RWRAP_LOG(RWRAP_LOG_TRACE, "Adding TXT RR");
+ txt_len = strlen(rr->rrdata.txt_rec) + 1;
+ rdata_size = txt_len;
+
+ resp_size = rwrap_fake_rdata_common(ns_t_txt, rdata_size,
+ rr->key, anslen, &a);
+ if (resp_size < 0) {
+ return -1;
+ }
+
+ memcpy(a, rr->rrdata.txt_rec, txt_len);
+
+ return resp_size;
+}
+
static ssize_t rwrap_fake_soa(struct rwrap_fake_rr *rr,
uint8_t *answer,
size_t anslen)
fp = fopen(hostfile, "r");
if (fp == NULL) {
- RWRAP_LOG(RWRAP_LOG_ERROR,
+ RWRAP_LOG(RWRAP_LOG_WARN,
"Opening %s failed: %s",
hostfile, strerror(errno));
return -1;
rc = rwrap_create_fake_ptr_rr(key, value, rr);
break;
}
+ else if (TYPE_MATCH(type, ns_t_txt,
+ rec_type, "TXT", key, query)) {
+ rc = rwrap_create_fake_txt_rr(key, value, rr);
+ break;
+ }
}
if (rc == ENOENT && recursion == 0 && key != NULL) {
case ns_t_soa:
case ns_t_cname:
case ns_t_ptr:
+ case ns_t_txt:
return true;
}
case ns_t_ptr:
resp_data = rwrap_fake_ptr(rr, answer, anslen);
break;
+ case ns_t_txt:
+ resp_data = rwrap_fake_txt(rr, answer, anslen);
+ break;
default:
return -1;
}
resp_size = rwrap_fake_empty(type, rrs->key, answer, anslen);
break;
default:
- RWRAP_LOG(RWRAP_LOG_ERROR,
- "Error searching for [%s]\n", query_name);
+ RWRAP_LOG(RWRAP_LOG_NOTICE,
+ "Searching for [%s] did not return any results\n",
+ query_name);
free(query_name);
return -1;
}
RWRAP_LIBRESOLV
};
-#ifndef NDEBUG
static const char *rwrap_str_lib(enum rwrap_lib lib)
{
switch (lib) {
/* Compiler would warn us about unhandled enum value if we get here */
return "unknown";
}
-#endif
static void *rwrap_load_lib_handle(enum rwrap_lib lib)
{
int i;
#ifdef RTLD_DEEPBIND
- flags |= RTLD_DEEPBIND;
+ const char *env_preload = getenv("LD_PRELOAD");
+ const char *env_deepbind = getenv("RESOLV_WRAPPER_DISABLE_DEEPBIND");
+ bool enable_deepbind = true;
+
+ /* Don't do a deepbind if we run with libasan */
+ if (env_preload != NULL && strlen(env_preload) < 1024) {
+ const char *p = strstr(env_preload, "libasan.so");
+ if (p != NULL) {
+ enable_deepbind = false;
+ }
+ }
+
+ if (env_deepbind != NULL && strlen(env_deepbind) >= 1) {
+ enable_deepbind = false;
+ }
+
+ if (enable_deepbind) {
+ flags |= RTLD_DEEPBIND;
+ }
#endif
switch (lib) {
static int libc_res_ninit(struct __res_state *state)
{
#if !defined(res_ninit) && defined(HAVE_RES_NINIT)
-
-#if defined(HAVE_RES_NINIT_IN_LIBRESOLV)
rwrap_bind_symbol_libresolv(res_ninit);
return rwrap.libresolv.symbols._libc_res_ninit.f(state);
-#else /* HAVE_RES_NINIT_IN_LIBRESOLV */
- rwrap_bind_symbol_libc(res_ninit);
-
- return rwrap.libc.symbols._libc_res_ninit.f(state);
-#endif /* HAVE_RES_NINIT_IN_LIBRESOLV */
-
#elif defined(HAVE___RES_NINIT)
- rwrap_bind_symbol_libc(__res_ninit);
+ rwrap_bind_symbol_libresolv(__res_ninit);
- return rwrap.libc.symbols._libc___res_ninit.f(state);
+ return rwrap.libresolv.symbols._libc___res_ninit.f(state);
#else
#error "No res_ninit function"
#endif
static void libc_res_nclose(struct __res_state *state)
{
#if !defined(res_close) && defined(HAVE_RES_NCLOSE)
-
-#if defined(HAVE_RES_NCLOSE_IN_LIBRESOLV)
rwrap_bind_symbol_libresolv(res_nclose);
rwrap.libresolv.symbols._libc_res_nclose.f(state);
return;
-#else /* HAVE_RES_NCLOSE_IN_LIBRESOLV */
- rwrap_bind_symbol_libc(res_nclose);
-
- rwrap.libc.symbols._libc_res_nclose.f(state);
- return;
-#endif /* HAVE_RES_NCLOSE_IN_LIBRESOLV */
-
#elif defined(HAVE___RES_NCLOSE)
- rwrap_bind_symbol_libc(__res_nclose);
+ rwrap_bind_symbol_libresolv(__res_nclose);
- rwrap.libc.symbols._libc___res_nclose.f(state);
+ rwrap.libresolv.symbols._libc___res_nclose.f(state);
#else
#error "No res_nclose function"
#endif
* RES_HELPER
***************************************************************************/
+static size_t rwrap_get_nameservers(struct __res_state *state,
+ size_t nserv,
+ union rwrap_sockaddr *nsaddrs)
+{
+#ifdef HAVE_RES_SOCKADDR_UNION_SIN
+ union res_sockaddr_union set[MAXNS];
+ size_t i;
+ int rc;
+
+ memset(set, 0, sizeof(set));
+ memset(nsaddrs, 0, sizeof(*nsaddrs) * nserv);
+
+ if (nserv > MAXNS) {
+ nserv = MAXNS;
+ }
+
+ rc = res_getservers(state, set, nserv);
+ if (rc <= 0) {
+ return 0;
+ }
+ if (rc < nserv) {
+ nserv = rc;
+ }
+
+ for (i = 0; i < nserv; i++) {
+ switch (set[i].sin.sin_family) {
+ case AF_INET:
+ nsaddrs[i] = (union rwrap_sockaddr) {
+ .in = set[i].sin,
+ };
+ break;
+#ifdef HAVE_RES_SOCKADDR_UNION_SIN6
+ case AF_INET6:
+ nsaddrs[i] = (union rwrap_sockaddr) {
+ .in6 = set[i].sin6,
+ };
+ break;
+#endif
+ }
+ }
+
+ return nserv;
+#else /* ! HAVE_RES_SOCKADDR_UNION_SIN */
+ size_t i;
+
+ memset(nsaddrs, 0, sizeof(*nsaddrs) * nserv);
+
+ if (nserv > (size_t)state->nscount) {
+ nserv = (size_t)state->nscount;
+ }
+
+ for (i = 0; i < nserv; i++) {
+#ifdef HAVE_RES_STATE_U_EXT_NSADDRS
+ if (state->_u._ext.nsaddrs[i] != NULL) {
+ nsaddrs[i] = (union rwrap_sockaddr) {
+ .in6 = *state->_u._ext.nsaddrs[i],
+ };
+ } else
+#endif /* HAVE_RES_STATE_U_EXT_NSADDRS */
+ {
+ nsaddrs[i] = (union rwrap_sockaddr) {
+ .in = state->nsaddr_list[i],
+ };
+ }
+ }
+
+ return nserv;
+#endif /* ! HAVE_RES_SOCKADDR_UNION_SIN */
+}
+
+static void rwrap_log_nameservers(enum rwrap_dbglvl_e dbglvl,
+ const char *func,
+ struct __res_state *state)
+{
+ union rwrap_sockaddr nsaddrs[MAXNS];
+ size_t nserv = MAXNS;
+ size_t i;
+
+ memset(nsaddrs, 0, sizeof(nsaddrs));
+ nserv = rwrap_get_nameservers(state, nserv, nsaddrs);
+ for (i = 0; i < nserv; i++) {
+ char ip[INET6_ADDRSTRLEN];
+
+ switch (nsaddrs[i].sa.sa_family) {
+ case AF_INET:
+ inet_ntop(AF_INET, &(nsaddrs[i].in.sin_addr),
+ ip, sizeof(ip));
+ break;
+ case AF_INET6:
+ inet_ntop(AF_INET6, &(nsaddrs[i].in6.sin6_addr),
+ ip, sizeof(ip));
+ break;
+ default:
+ snprintf(ip, sizeof(ip), "<unknown sa_family=%d",
+ nsaddrs[i].sa.sa_family);
+ break;
+ }
+
+ rwrap_log(dbglvl, func,
+ " nameserver: %s",
+ ip);
+ }
+}
+
+static void rwrap_reset_nameservers(struct __res_state *state)
+{
+#ifdef HAVE_RES_SOCKADDR_UNION_SIN
+ res_setservers(state, NULL, 0);
+#else /* ! HAVE_RES_SOCKADDR_UNION_SIN */
+#ifdef HAVE_RES_STATE_U_EXT_NSADDRS
+ size_t i;
+
+ for (i = 0; i < (size_t)state->nscount; i++) {
+ if (state->_u._ext.nssocks[i] != -1) {
+ close(state->_u._ext.nssocks[i]);
+ state->_u._ext.nssocks[i] = -1;
+ }
+ SAFE_FREE(state->_u._ext.nsaddrs[i]);
+ }
+ memset(&state->_u._ext, 0, sizeof(state->_u._ext));
+ for (i = 0; i < MAXNS; i++) {
+ state->_u._ext.nssocks[i] = -1;
+ state->_u._ext.nsmap[i] = MAXNS + 1;
+ }
+ state->ipv6_unavail = false;
+#endif
+ memset(state->nsaddr_list, 0, sizeof(state->nsaddr_list));
+ state->nscount = 0;
+#endif /* ! HAVE_RES_SOCKADDR_UNION_SIN */
+}
+
+static int rwrap_set_nameservers(struct __res_state *state,
+ size_t nserv,
+ const union rwrap_sockaddr *nsaddrs)
+{
+#ifdef HAVE_RES_SOCKADDR_UNION_SIN
+ union res_sockaddr_union set[MAXNS];
+ size_t i;
+
+ memset(set, 0, sizeof(set));
+
+ if (nserv > MAXNS) {
+ nserv = MAXNS;
+ }
+
+ rwrap_reset_nameservers(state);
+
+ for (i = 0; i < nserv; i++) {
+ switch (nsaddrs[i].sa.sa_family) {
+ case AF_INET:
+ set[i] = (union res_sockaddr_union) {
+ .sin = nsaddrs[i].in,
+ };
+ break;
+#ifdef HAVE_RES_SOCKADDR_UNION_SIN6
+ case AF_INET6:
+ set[i] = (union res_sockaddr_union) {
+ .sin6 = nsaddrs[i].in6,
+ };
+ break;
+#endif
+ default:
+ RWRAP_LOG(RWRAP_LOG_ERROR,
+ "Internal error unhandled sa_family=%d",
+ nsaddrs[i].sa.sa_family);
+ errno = ENOSYS;
+ return -1;
+ }
+ }
+
+ res_setservers(state, set, nserv);
+ return 0;
+#else /* ! HAVE_RES_SOCKADDR_UNION_SIN */
+ size_t i;
+
+ if (nserv > MAXNS) {
+ nserv = MAXNS;
+ }
+ rwrap_reset_nameservers(state);
+
+ for (i = 0; i < nserv; i++) {
+ switch (nsaddrs[i].sa.sa_family) {
+ case AF_INET:
+ state->nsaddr_list[i] = nsaddrs[i].in;
+ break;
+#ifdef HAVE_RES_STATE_U_EXT_NSADDRS
+ case AF_INET6:
+ state->_u._ext.nsaddrs[i] = malloc(sizeof(nsaddrs[i].in6));
+ if (state->_u._ext.nsaddrs[i] == NULL) {
+ rwrap_reset_nameservers(state);
+ errno = ENOMEM;
+ return -1;
+ }
+ *state->_u._ext.nsaddrs[i] = nsaddrs[i].in6;
+ state->_u._ext.nssocks[i] = -1;
+ state->_u._ext.nsmap[i] = MAXNS + 1;
+ state->_u._ext.nscount6++;
+ break;
+#endif
+ default:
+ RWRAP_LOG(RWRAP_LOG_ERROR,
+ "Internal error unhandled sa_family=%d",
+ nsaddrs[i].sa.sa_family);
+ rwrap_reset_nameservers(state);
+ errno = ENOSYS;
+ return -1;
+ }
+ }
+
+ /*
+ * note that state->_u._ext.nscount is left as 0,
+ * this matches glibc and allows resolv wrapper
+ * to work with most (maybe all) glibc versions.
+ */
+ state->nscount = i;
+
+ return 0;
+#endif /* ! HAVE_RES_SOCKADDR_UNION_SIN */
+}
+
static int rwrap_parse_resolv_conf(struct __res_state *state,
const char *resolv_conf)
{
FILE *fp;
char buf[BUFSIZ];
- int nserv = 0;
+ size_t nserv = 0;
+ union rwrap_sockaddr nsaddrs[MAXNS];
+
+ memset(nsaddrs, 0, sizeof(nsaddrs));
fp = fopen(resolv_conf, "r");
if (fp == NULL) {
- RWRAP_LOG(RWRAP_LOG_ERROR,
+ RWRAP_LOG(RWRAP_LOG_WARN,
"Opening %s failed: %s",
resolv_conf, strerror(errno));
return -1;
if (RESOLV_MATCH(buf, "nameserver") && nserv < MAXNS) {
struct in_addr a;
+ struct in6_addr a6;
char *q;
int ok;
ok = inet_pton(AF_INET, p, &a);
if (ok) {
- state->nsaddr_list[state->nscount] = (struct sockaddr_in) {
- .sin_family = AF_INET,
- .sin_addr = a,
- .sin_port = htons(53),
- .sin_zero = { 0 },
+ nsaddrs[nserv] = (union rwrap_sockaddr) {
+ .in = {
+ .sin_family = AF_INET,
+ .sin_addr = a,
+ .sin_port = htons(53),
+ .sin_zero = { 0 },
+ },
};
- state->nscount++;
nserv++;
- } else {
+ continue;
+ }
+
+ ok = inet_pton(AF_INET6, p, &a6);
+ if (ok) {
#ifdef HAVE_RESOLV_IPV6_NSADDRS
- /* IPv6 */
- struct in6_addr a6;
- ok = inet_pton(AF_INET6, p, &a6);
- if (ok) {
- struct sockaddr_in6 *sa6;
-
- sa6 = malloc(sizeof(*sa6));
- if (sa6 == NULL) {
- fclose(fp);
- return -1;
- }
-
- sa6->sin6_family = AF_INET6;
- sa6->sin6_port = htons(53);
- sa6->sin6_flowinfo = 0;
- sa6->sin6_addr = a6;
-
- state->_u._ext.nsaddrs[state->_u._ext.nscount] = sa6;
- state->_u._ext.nssocks[state->_u._ext.nscount] = -1;
- state->_u._ext.nsmap[state->_u._ext.nscount] = MAXNS + 1;
-
- state->_u._ext.nscount++;
- nserv++;
- } else {
- RWRAP_LOG(RWRAP_LOG_ERROR,
- "Malformed DNS server");
- continue;
- }
+ nsaddrs[nserv] = (union rwrap_sockaddr) {
+ .in6 = {
+
+ .sin6_family = AF_INET6,
+ .sin6_port = htons(53),
+ .sin6_flowinfo = 0,
+ .sin6_addr = a6,
+ },
+ };
+ nserv++;
+ continue;
#else /* !HAVE_RESOLV_IPV6_NSADDRS */
- /*
- * BSD uses an opaque structure to store the
- * IPv6 addresses. So we can not simply store
- * these addresses the same way as above.
- */
RWRAP_LOG(RWRAP_LOG_WARN,
"resolve_wrapper does not support "
"IPv6 on this platform");
- continue;
+ continue;
#endif
}
+
+ RWRAP_LOG(RWRAP_LOG_ERROR, "Malformed DNS server[%s]", p);
continue;
} /* TODO: match other keywords */
}
}
fclose(fp);
- return 0;
+
+ if (nserv == 0) {
+ RWRAP_LOG(RWRAP_LOG_WARN,
+ "No usable nameservers found in %s",
+ resolv_conf);
+ errno = ESRCH;
+ return -1;
+ }
+
+ return rwrap_set_nameservers(state, nserv, nsaddrs);
}
/****************************************************************************
const char *resolv_conf = getenv("RESOLV_WRAPPER_CONF");
if (resolv_conf != NULL) {
- uint16_t i;
-
- (void)i; /* maybe unused */
-
- /* Delete name servers */
- state->nscount = 0;
- memset(state->nsaddr_list, 0, sizeof(state->nsaddr_list));
-
-#ifdef HAVE_RESOLV_IPV6_NSADDRS
- state->_u._ext.nscount = 0;
- for (i = 0; i < state->_u._ext.nscount; i++) {
- SAFE_FREE(state->_u._ext.nsaddrs[i]);
- }
-#endif
-
rc = rwrap_parse_resolv_conf(state, resolv_conf);
}
}
static void rwrap_res_nclose(struct __res_state *state)
{
-#ifdef HAVE_RESOLV_IPV6_NSADDRS
- int i;
-#endif
-
+ rwrap_reset_nameservers(state);
libc_res_nclose(state);
-
-#ifdef HAVE_RESOLV_IPV6_NSADDRS
- if (state != NULL) {
- for (i = 0; i < state->_u._ext.nscount; i++) {
- SAFE_FREE(state->_u._ext.nsaddrs[i]);
- }
- }
-#endif
}
#if !defined(res_nclose) && defined(HAVE_RES_NCLOSE)
{
int rc;
const char *fake_hosts;
-#ifndef NDEBUG
- int i;
-#endif
RWRAP_LOG(RWRAP_LOG_TRACE,
"Resolve the domain name [%s] - class=%d, type=%d",
dname, class, type);
-#ifndef NDEBUG
- for (i = 0; i < state->nscount; i++) {
- char ip[INET6_ADDRSTRLEN];
-
- inet_ntop(AF_INET, &state->nsaddr_list[i].sin_addr, ip, sizeof(ip));
- RWRAP_LOG(RWRAP_LOG_TRACE,
- " nameserver: %s",
- ip);
- }
-#endif
+ rwrap_log_nameservers(RWRAP_LOG_TRACE, __func__, state);
fake_hosts = getenv("RESOLV_WRAPPER_HOSTS");
if (fake_hosts != NULL) {
{
int rc;
const char *fake_hosts;
-#ifndef NDEBUG
- int i;
-#endif
RWRAP_LOG(RWRAP_LOG_TRACE,
"Resolve the domain name [%s] - class=%d, type=%d",
dname, class, type);
-#ifndef NDEBUG
- for (i = 0; i < state->nscount; i++) {
- char ip[INET6_ADDRSTRLEN];
-
- inet_ntop(AF_INET, &state->nsaddr_list[i].sin_addr, ip, sizeof(ip));
- RWRAP_LOG(RWRAP_LOG_TRACE,
- " nameserver: %s",
- ip);
- }
-#endif
+ rwrap_log_nameservers(RWRAP_LOG_TRACE, __func__, state);
fake_hosts = getenv("RESOLV_WRAPPER_HOSTS");
if (fake_hosts != NULL) {