/*
- * 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.
*
struct rwrap_soa_rrdata soa_rec;
char cname_rec[MAXDNAME];
char ptr_rec[MAXDNAME];
+ char txt_rec[MAXDNAME];
} rrdata;
char key[MAXDNAME];
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)
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 = res_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
git.samba.org / resolv_wrapper.git / blobdiff