mirror of
https://github.com/samba-team/samba.git
synced 2024-12-22 13:34:15 +03:00
429bf5ce23
res_randomid() is marked as deprecated in newer glibc. Signed-off-by: Andreas Schneider <asn@samba.org> Reviewed-by: Jeremy Allison <jra@samba.org> Autobuild-User(master): Jeremy Allison <jra@samba.org> Autobuild-Date(master): Wed Dec 21 21:28:42 UTC 2022 on sn-devel-184
2227 lines
50 KiB
C
2227 lines
50 KiB
C
/*
|
|
* Copyright (c) 2014-2018 Andreas Schneider <asn@samba.org>
|
|
* Copyright (c) 2014-2016 Jakub Hrozek <jakub.hrozek@posteo.se>
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the author nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <errno.h>
|
|
#include <arpa/inet.h>
|
|
#ifdef HAVE_ARPA_NAMESER_H
|
|
#include <arpa/nameser.h>
|
|
#endif /* HAVE_ARPA_NAMESER_H */
|
|
#include <netinet/in.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/types.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
|
|
#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)))
|
|
#else
|
|
#define PRINTF_ATTRIBUTE(a,b)
|
|
#endif /* HAVE_ATTRIBUTE_PRINTF_FORMAT */
|
|
|
|
#ifdef HAVE_DESTRUCTOR_ATTRIBUTE
|
|
#define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
|
|
#else
|
|
#define DESTRUCTOR_ATTRIBUTE
|
|
#endif /* HAVE_DESTRUCTOR_ATTRIBUTE */
|
|
|
|
#ifndef RWRAP_DEFAULT_FAKE_TTL
|
|
#define RWRAP_DEFAULT_FAKE_TTL 600
|
|
#endif /* RWRAP_DEFAULT_FAKE_TTL */
|
|
|
|
#ifndef HAVE_NS_NAME_COMPRESS
|
|
#define ns_name_compress dn_comp
|
|
#endif
|
|
|
|
#define ns_t_uri 256
|
|
|
|
enum rwrap_dbglvl_e {
|
|
RWRAP_LOG_ERROR = 0,
|
|
RWRAP_LOG_WARN,
|
|
RWRAP_LOG_NOTICE,
|
|
RWRAP_LOG_DEBUG,
|
|
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__)
|
|
|
|
static void rwrap_log(enum rwrap_dbglvl_e dbglvl,
|
|
const char *func,
|
|
const char *format, ...)
|
|
{
|
|
char buffer[1024];
|
|
va_list va;
|
|
const char *d;
|
|
unsigned int lvl = 0;
|
|
const char *prefix = NULL;
|
|
const char *progname = NULL;
|
|
|
|
d = getenv("RESOLV_WRAPPER_DEBUGLEVEL");
|
|
if (d != NULL) {
|
|
lvl = atoi(d);
|
|
}
|
|
|
|
if (lvl < dbglvl) {
|
|
return;
|
|
}
|
|
|
|
va_start(va, format);
|
|
vsnprintf(buffer, sizeof(buffer), format, va);
|
|
va_end(va);
|
|
|
|
switch (dbglvl) {
|
|
case RWRAP_LOG_ERROR:
|
|
prefix = "RWRAP_ERROR";
|
|
break;
|
|
case RWRAP_LOG_WARN:
|
|
prefix = "RWRAP_WARN";
|
|
break;
|
|
case RWRAP_LOG_NOTICE:
|
|
prefix = "RWRAP_NOTICE";
|
|
break;
|
|
case RWRAP_LOG_DEBUG:
|
|
prefix = "RWRAP_DEBUG";
|
|
break;
|
|
case RWRAP_LOG_TRACE:
|
|
prefix = "RWRAP_TRACE";
|
|
break;
|
|
}
|
|
|
|
progname = getprogname();
|
|
if (progname == NULL) {
|
|
progname = "<unknown>";
|
|
}
|
|
|
|
fprintf(stderr,
|
|
"%s[%s (%u)] - %s: %s\n",
|
|
prefix,
|
|
progname,
|
|
(unsigned int)getpid(),
|
|
func,
|
|
buffer);
|
|
}
|
|
|
|
#ifndef SAFE_FREE
|
|
#define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
|
|
#endif
|
|
|
|
#define NEXT_KEY(buf, key) do { \
|
|
(key) = (buf) ? strpbrk((buf), " \t") : NULL; \
|
|
if ((key) != NULL) { \
|
|
(key)[0] = '\0'; \
|
|
(key)++; \
|
|
} \
|
|
while ((key) != NULL \
|
|
&& (isblank((int)(key)[0]))) { \
|
|
(key)++; \
|
|
} \
|
|
} while(0);
|
|
|
|
#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
|
|
*/
|
|
#define DFL_SRV_PRIO 1
|
|
#define DFL_SRV_WEIGHT 100
|
|
#define DFL_URI_PRIO 1
|
|
#define DFL_URI_WEIGHT 100
|
|
|
|
struct rwrap_srv_rrdata {
|
|
uint16_t port;
|
|
uint16_t prio;
|
|
uint16_t weight;
|
|
char hostname[MAXDNAME];
|
|
};
|
|
|
|
struct rwrap_uri_rrdata {
|
|
uint16_t prio;
|
|
uint16_t weight;
|
|
char uri[MAXDNAME];
|
|
};
|
|
|
|
struct rwrap_soa_rrdata {
|
|
uint32_t serial;
|
|
uint32_t refresh;
|
|
uint32_t retry;
|
|
uint32_t expire;
|
|
uint32_t minimum;
|
|
char nameserver[MAXDNAME];
|
|
char mailbox[MAXDNAME];
|
|
};
|
|
|
|
struct rwrap_fake_rr {
|
|
union fake_rrdata {
|
|
struct in_addr a_rec;
|
|
struct in6_addr aaaa_rec;
|
|
struct rwrap_srv_rrdata srv_rec;
|
|
struct rwrap_uri_rrdata uri_rec;
|
|
struct rwrap_soa_rrdata soa_rec;
|
|
char cname_rec[MAXDNAME];
|
|
char ptr_rec[MAXDNAME];
|
|
char txt_rec[MAXDNAME];
|
|
} rrdata;
|
|
|
|
char key[MAXDNAME];
|
|
int type; /* ns_t_* */
|
|
};
|
|
|
|
static void rwrap_fake_rr_init(struct rwrap_fake_rr *rr, size_t len)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
rr[i].type = ns_t_invalid;
|
|
}
|
|
}
|
|
|
|
static int rwrap_create_fake_a_rr(const char *key,
|
|
const char *value,
|
|
struct rwrap_fake_rr *rr)
|
|
{
|
|
int ok;
|
|
|
|
ok = inet_pton(AF_INET, value, &rr->rrdata.a_rec);
|
|
if (!ok) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Failed to convert [%s] to binary\n", value);
|
|
return -1;
|
|
}
|
|
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
rr->type = ns_t_a;
|
|
return 0;
|
|
}
|
|
|
|
static int rwrap_create_fake_aaaa_rr(const char *key,
|
|
const char *value,
|
|
struct rwrap_fake_rr *rr)
|
|
{
|
|
int ok;
|
|
|
|
ok = inet_pton(AF_INET6, value, &rr->rrdata.aaaa_rec);
|
|
if (!ok) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Failed to convert [%s] to binary\n", value);
|
|
return -1;
|
|
}
|
|
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
rr->type = ns_t_aaaa;
|
|
return 0;
|
|
}
|
|
static int rwrap_create_fake_ns_rr(const char *key,
|
|
const char *value,
|
|
struct rwrap_fake_rr *rr)
|
|
{
|
|
memcpy(rr->rrdata.srv_rec.hostname, value, strlen(value) + 1);
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
rr->type = ns_t_ns;
|
|
return 0;
|
|
}
|
|
|
|
static int rwrap_create_fake_srv_rr(const char *key,
|
|
const char *value,
|
|
struct rwrap_fake_rr *rr)
|
|
{
|
|
char *str_prio;
|
|
char *str_weight;
|
|
char *str_port;
|
|
const char *hostname;
|
|
|
|
/* parse the value into priority, weight, port and hostname
|
|
* and check the validity */
|
|
hostname = value;
|
|
NEXT_KEY(hostname, str_port);
|
|
NEXT_KEY(str_port, str_prio);
|
|
NEXT_KEY(str_prio, str_weight);
|
|
if (str_port == NULL || hostname == NULL) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Malformed SRV entry [%s]\n", value);
|
|
return -1;
|
|
}
|
|
|
|
if (str_prio) {
|
|
rr->rrdata.srv_rec.prio = atoi(str_prio);
|
|
} else {
|
|
rr->rrdata.srv_rec.prio = DFL_SRV_PRIO;
|
|
}
|
|
if (str_weight) {
|
|
rr->rrdata.srv_rec.weight = atoi(str_weight);
|
|
} else {
|
|
rr->rrdata.srv_rec.weight = DFL_SRV_WEIGHT;
|
|
}
|
|
rr->rrdata.srv_rec.port = atoi(str_port);
|
|
memcpy(rr->rrdata.srv_rec.hostname , hostname, strlen(hostname) + 1);
|
|
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
rr->type = ns_t_srv;
|
|
return 0;
|
|
}
|
|
|
|
static int rwrap_create_fake_uri_rr(const char *key,
|
|
const char *value,
|
|
struct rwrap_fake_rr *rr)
|
|
{
|
|
char *str_prio;
|
|
char *str_weight;
|
|
const char *uri;
|
|
|
|
/* parse the value into priority, weight, and uri
|
|
* and check the validity */
|
|
uri = value;
|
|
NEXT_KEY(uri, str_prio);
|
|
NEXT_KEY(str_prio, str_weight);
|
|
if (uri == NULL) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Malformed URI entry [<null>]\n");
|
|
return -1;
|
|
}
|
|
|
|
if (str_prio) {
|
|
rr->rrdata.uri_rec.prio = atoi(str_prio);
|
|
} else {
|
|
rr->rrdata.uri_rec.prio = DFL_URI_PRIO;
|
|
}
|
|
if (str_weight) {
|
|
rr->rrdata.uri_rec.weight = atoi(str_weight);
|
|
} else {
|
|
rr->rrdata.uri_rec.weight = DFL_URI_WEIGHT;
|
|
}
|
|
memcpy(rr->rrdata.uri_rec.uri, uri, strlen(uri) + 1);
|
|
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
rr->type = ns_t_uri;
|
|
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)
|
|
{
|
|
const char *nameserver;
|
|
char *mailbox;
|
|
char *str_serial;
|
|
char *str_refresh;
|
|
char *str_retry;
|
|
char *str_expire;
|
|
char *str_minimum;
|
|
|
|
/* parse the value into nameserver, mailbox, serial, refresh,
|
|
* retry, expire, minimum and check the validity
|
|
*/
|
|
nameserver = value;
|
|
NEXT_KEY(nameserver, mailbox);
|
|
NEXT_KEY(mailbox, str_serial);
|
|
NEXT_KEY(str_serial, str_refresh);
|
|
NEXT_KEY(str_refresh, str_retry);
|
|
NEXT_KEY(str_retry, str_expire);
|
|
NEXT_KEY(str_expire, str_minimum);
|
|
if (nameserver == NULL || mailbox == NULL || str_serial == NULL ||
|
|
str_refresh == NULL || str_retry == NULL || str_expire == NULL ||
|
|
str_minimum == NULL) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Malformed SOA entry [%s]\n", value);
|
|
return -1;
|
|
}
|
|
|
|
memcpy(rr->rrdata.soa_rec.nameserver, nameserver, strlen(nameserver)+1);
|
|
memcpy(rr->rrdata.soa_rec.mailbox, mailbox, strlen(mailbox)+1);
|
|
|
|
rr->rrdata.soa_rec.serial = atoi(str_serial);
|
|
rr->rrdata.soa_rec.refresh = atoi(str_refresh);
|
|
rr->rrdata.soa_rec.retry = atoi(str_retry);
|
|
rr->rrdata.soa_rec.expire = atoi(str_expire);
|
|
rr->rrdata.soa_rec.minimum = atoi(str_minimum);
|
|
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
rr->type = ns_t_soa;
|
|
return 0;
|
|
}
|
|
|
|
static int rwrap_create_fake_cname_rr(const char *key,
|
|
const char *value,
|
|
struct rwrap_fake_rr *rr)
|
|
{
|
|
memcpy(rr->rrdata.cname_rec , value, strlen(value) + 1);
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
rr->type = ns_t_cname;
|
|
return 0;
|
|
}
|
|
|
|
static int rwrap_create_fake_ptr_rr(const char *key,
|
|
const char *value,
|
|
struct rwrap_fake_rr *rr)
|
|
{
|
|
memcpy(rr->rrdata.ptr_rec , value, strlen(value) + 1);
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
rr->type = ns_t_ptr;
|
|
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)
|
|
{
|
|
union {
|
|
uint8_t *blob;
|
|
HEADER *header;
|
|
} h;
|
|
|
|
if (remaining < NS_HFIXEDSZ) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small!\n");
|
|
return -1;
|
|
}
|
|
|
|
h.blob = *header_blob;
|
|
memset(h.blob, 0, NS_HFIXEDSZ);
|
|
|
|
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.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 */
|
|
|
|
/* move past the header */
|
|
*header_blob = h.blob += NS_HFIXEDSZ;
|
|
|
|
return NS_HFIXEDSZ;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_question(const char *question,
|
|
uint16_t type,
|
|
uint8_t **question_ptr,
|
|
size_t remaining)
|
|
{
|
|
uint8_t *qb = *question_ptr;
|
|
int n;
|
|
|
|
n = ns_name_compress(question, qb, remaining, NULL, NULL);
|
|
if (n < 0) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Failed to compress [%s]\n", question);
|
|
return -1;
|
|
}
|
|
|
|
qb += n;
|
|
remaining -= n;
|
|
|
|
if (remaining < 2 * sizeof(uint16_t)) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small!\n");
|
|
return -1;
|
|
}
|
|
|
|
NS_PUT16(type, qb);
|
|
NS_PUT16(ns_c_in, qb);
|
|
|
|
*question_ptr = qb;
|
|
return n + 2 * sizeof(uint16_t);
|
|
}
|
|
|
|
static ssize_t rwrap_fake_rdata_common(uint16_t type,
|
|
size_t rdata_size,
|
|
const char *key,
|
|
size_t remaining,
|
|
uint8_t **rdata_ptr)
|
|
{
|
|
uint8_t *rd = *rdata_ptr;
|
|
ssize_t written = 0;
|
|
|
|
written = ns_name_compress(key, rd, remaining, NULL, NULL);
|
|
if (written < 0) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Failed to compress [%s]\n", key);
|
|
return -1;
|
|
}
|
|
rd += written;
|
|
remaining -= written;
|
|
|
|
if (remaining < 3 * sizeof(uint16_t) + sizeof(uint32_t)) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small\n");
|
|
return -1;
|
|
}
|
|
|
|
NS_PUT16(type, rd);
|
|
NS_PUT16(ns_c_in, rd);
|
|
NS_PUT32(RWRAP_DEFAULT_FAKE_TTL, rd);
|
|
NS_PUT16(rdata_size, rd);
|
|
|
|
if (remaining < rdata_size) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small\n");
|
|
return -1;
|
|
}
|
|
|
|
*rdata_ptr = rd;
|
|
return written + 3 * sizeof(uint16_t) + sizeof(uint32_t) + rdata_size;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_a(struct rwrap_fake_rr *rr,
|
|
uint8_t *answer_ptr,
|
|
size_t anslen)
|
|
{
|
|
uint8_t *a = answer_ptr;
|
|
ssize_t resp_size;
|
|
|
|
if (rr->type != ns_t_a) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
|
|
return -1;
|
|
}
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Adding A RR");
|
|
|
|
resp_size = rwrap_fake_rdata_common(ns_t_a, sizeof(struct in_addr), rr->key,
|
|
anslen, &a);
|
|
if (resp_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
memcpy(a, &rr->rrdata.a_rec, sizeof(struct in_addr));
|
|
|
|
return resp_size;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_aaaa(struct rwrap_fake_rr *rr,
|
|
uint8_t *answer,
|
|
size_t anslen)
|
|
{
|
|
uint8_t *a = answer;
|
|
ssize_t resp_size;
|
|
|
|
if (rr->type != ns_t_aaaa) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
|
|
return -1;
|
|
}
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Adding AAAA RR");
|
|
|
|
resp_size = rwrap_fake_rdata_common(ns_t_aaaa, sizeof(struct in6_addr),
|
|
rr->key, anslen, &a);
|
|
if (resp_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
memcpy(a, &rr->rrdata.aaaa_rec, sizeof(struct in6_addr));
|
|
|
|
return resp_size;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_ns(struct rwrap_fake_rr *rr,
|
|
uint8_t *answer,
|
|
size_t anslen)
|
|
{
|
|
uint8_t *a = answer;
|
|
ssize_t resp_size = 0;
|
|
size_t rdata_size;
|
|
unsigned char hostname_compressed[MAXDNAME];
|
|
ssize_t compressed_len;
|
|
|
|
if (rr->type != ns_t_ns) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
|
|
return -1;
|
|
}
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Adding NS RR");
|
|
|
|
/* Prepare the data to write */
|
|
compressed_len = ns_name_compress(rr->rrdata.srv_rec.hostname,
|
|
hostname_compressed,
|
|
MAXDNAME,
|
|
NULL,
|
|
NULL);
|
|
if (compressed_len < 0) {
|
|
return -1;
|
|
}
|
|
|
|
/* Is this enough? */
|
|
rdata_size = compressed_len;
|
|
|
|
resp_size = rwrap_fake_rdata_common(ns_t_ns, rdata_size,
|
|
rr->key, anslen, &a);
|
|
if (resp_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
memcpy(a, hostname_compressed, compressed_len);
|
|
|
|
return resp_size;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_srv(struct rwrap_fake_rr *rr,
|
|
uint8_t *answer,
|
|
size_t anslen)
|
|
{
|
|
uint8_t *a = answer;
|
|
ssize_t resp_size;
|
|
size_t rdata_size;
|
|
unsigned char hostname_compressed[MAXDNAME];
|
|
ssize_t compressed_len;
|
|
|
|
if (rr->type != ns_t_srv) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
|
|
return -1;
|
|
}
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Adding SRV RR");
|
|
rdata_size = 3 * sizeof(uint16_t);
|
|
|
|
/* Prepare the data to write */
|
|
compressed_len = ns_name_compress(rr->rrdata.srv_rec.hostname,
|
|
hostname_compressed, MAXDNAME,
|
|
NULL, NULL);
|
|
if (compressed_len < 0) {
|
|
return -1;
|
|
}
|
|
rdata_size += compressed_len;
|
|
|
|
resp_size = rwrap_fake_rdata_common(ns_t_srv, rdata_size,
|
|
rr->key, anslen, &a);
|
|
if (resp_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
NS_PUT16(rr->rrdata.srv_rec.prio, a);
|
|
NS_PUT16(rr->rrdata.srv_rec.weight, a);
|
|
NS_PUT16(rr->rrdata.srv_rec.port, a);
|
|
memcpy(a, hostname_compressed, compressed_len);
|
|
|
|
return resp_size;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_uri(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 uri_len;
|
|
|
|
if (rr->type != ns_t_uri) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
|
|
return -1;
|
|
}
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Adding URI RR");
|
|
rdata_size = 3 * sizeof(uint16_t);
|
|
uri_len = strlen(rr->rrdata.uri_rec.uri) + 1;
|
|
rdata_size += uri_len;
|
|
|
|
resp_size = rwrap_fake_rdata_common(ns_t_uri, rdata_size,
|
|
rr->key, anslen, &a);
|
|
if (resp_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
NS_PUT16(rr->rrdata.uri_rec.prio, a);
|
|
NS_PUT16(rr->rrdata.uri_rec.weight, a);
|
|
memcpy(a, rr->rrdata.uri_rec.uri, uri_len);
|
|
|
|
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)
|
|
{
|
|
uint8_t *a = answer;
|
|
ssize_t resp_size;
|
|
size_t rdata_size;
|
|
unsigned char nameser_compressed[MAXDNAME];
|
|
ssize_t compressed_ns_len;
|
|
unsigned char mailbox_compressed[MAXDNAME];
|
|
ssize_t compressed_mb_len;
|
|
|
|
if (rr->type != ns_t_soa) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
|
|
return -1;
|
|
}
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Adding SOA RR");
|
|
rdata_size = 5 * sizeof(uint16_t);
|
|
|
|
compressed_ns_len = ns_name_compress(rr->rrdata.soa_rec.nameserver,
|
|
nameser_compressed,
|
|
MAXDNAME, NULL, NULL);
|
|
if (compressed_ns_len < 0) {
|
|
return -1;
|
|
}
|
|
rdata_size += compressed_ns_len;
|
|
|
|
compressed_mb_len = ns_name_compress(rr->rrdata.soa_rec.mailbox,
|
|
mailbox_compressed,
|
|
MAXDNAME, NULL, NULL);
|
|
if (compressed_mb_len < 0) {
|
|
return -1;
|
|
}
|
|
rdata_size += compressed_mb_len;
|
|
|
|
resp_size = rwrap_fake_rdata_common(ns_t_soa, rdata_size,
|
|
rr->key, anslen, &a);
|
|
if (resp_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
memcpy(a, nameser_compressed, compressed_ns_len);
|
|
a += compressed_ns_len;
|
|
memcpy(a, mailbox_compressed, compressed_mb_len);
|
|
a += compressed_mb_len;
|
|
NS_PUT32(rr->rrdata.soa_rec.serial, a);
|
|
NS_PUT32(rr->rrdata.soa_rec.refresh, a);
|
|
NS_PUT32(rr->rrdata.soa_rec.retry, a);
|
|
NS_PUT32(rr->rrdata.soa_rec.expire, a);
|
|
NS_PUT32(rr->rrdata.soa_rec.minimum, a);
|
|
|
|
return resp_size;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_cname(struct rwrap_fake_rr *rr,
|
|
uint8_t *answer,
|
|
size_t anslen)
|
|
{
|
|
uint8_t *a = answer;
|
|
ssize_t resp_size;
|
|
unsigned char hostname_compressed[MAXDNAME];
|
|
ssize_t rdata_size;
|
|
|
|
if (rr->type != ns_t_cname) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
|
|
return -1;
|
|
}
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Adding CNAME RR");
|
|
|
|
/* Prepare the data to write */
|
|
rdata_size = ns_name_compress(rr->rrdata.cname_rec,
|
|
hostname_compressed, MAXDNAME,
|
|
NULL, NULL);
|
|
if (rdata_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
resp_size = rwrap_fake_rdata_common(ns_t_cname, rdata_size,
|
|
rr->key, anslen, &a);
|
|
if (resp_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
memcpy(a, hostname_compressed, rdata_size);
|
|
|
|
return resp_size;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_ptr(struct rwrap_fake_rr *rr,
|
|
uint8_t *answer,
|
|
size_t anslen)
|
|
{
|
|
uint8_t *a = answer;
|
|
ssize_t rdata_size;
|
|
ssize_t resp_size;
|
|
unsigned char hostname_compressed[MAXDNAME];
|
|
|
|
if (rr->type != ns_t_ptr) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
|
|
return -1;
|
|
}
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Adding PTR RR");
|
|
|
|
/* Prepare the data to write */
|
|
rdata_size = ns_name_compress(rr->rrdata.ptr_rec,
|
|
hostname_compressed, MAXDNAME,
|
|
NULL, NULL);
|
|
if (rdata_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
resp_size = rwrap_fake_rdata_common(ns_t_ptr, rdata_size,
|
|
rr->key, anslen, &a);
|
|
if (resp_size < 0) {
|
|
return -1;
|
|
}
|
|
|
|
memcpy(a, hostname_compressed, rdata_size);
|
|
|
|
return resp_size;
|
|
}
|
|
|
|
#define RESOLV_MATCH(line, name) \
|
|
(strncmp(line, name, sizeof(name) - 1) == 0 && \
|
|
(line[sizeof(name) - 1] == ' ' || \
|
|
line[sizeof(name) - 1] == '\t'))
|
|
|
|
#define TYPE_MATCH(type, ns_type, rec_type, str_type, key, query) \
|
|
((type) == (ns_type) && \
|
|
(strncmp((rec_type), (str_type), sizeof(str_type)) == 0) && \
|
|
(strcasecmp(key, query)) == 0)
|
|
|
|
|
|
static int rwrap_get_record(const char *hostfile, unsigned recursion,
|
|
const char *query, int type,
|
|
struct rwrap_fake_rr *rr);
|
|
|
|
static int rwrap_uri_recurse(const char *hostfile, unsigned recursion,
|
|
const char *query, struct rwrap_fake_rr *rr)
|
|
{
|
|
int rc;
|
|
|
|
rc = rwrap_get_record(hostfile, recursion, query, ns_t_uri, rr);
|
|
if (rc == ENOENT) {
|
|
rc = 0;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int rwrap_srv_recurse(const char *hostfile, unsigned recursion,
|
|
const char *query, struct rwrap_fake_rr *rr)
|
|
{
|
|
int rc;
|
|
|
|
rc = rwrap_get_record(hostfile, recursion, query, ns_t_a, rr);
|
|
if (rc == 0) return 0;
|
|
|
|
rc = rwrap_get_record(hostfile, recursion, query, ns_t_aaaa, rr);
|
|
if (rc == ENOENT) rc = 0;
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int rwrap_cname_recurse(const char *hostfile, unsigned recursion,
|
|
const char *query, struct rwrap_fake_rr *rr)
|
|
{
|
|
int rc;
|
|
|
|
rc = rwrap_get_record(hostfile, recursion, query, ns_t_a, rr);
|
|
if (rc == 0) return 0;
|
|
|
|
rc = rwrap_get_record(hostfile, recursion, query, ns_t_aaaa, rr);
|
|
if (rc == 0) return 0;
|
|
|
|
rc = rwrap_get_record(hostfile, recursion, query, ns_t_cname, rr);
|
|
if (rc == ENOENT) rc = 0;
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int rwrap_get_record(const char *hostfile, unsigned recursion,
|
|
const char *query, int type,
|
|
struct rwrap_fake_rr *rr)
|
|
{
|
|
FILE *fp = NULL;
|
|
char buf[BUFSIZ];
|
|
char *key = NULL;
|
|
char *value = NULL;
|
|
int rc = ENOENT;
|
|
unsigned num_uris = 0;
|
|
|
|
if (recursion >= RWRAP_MAX_RECURSION) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Recursed too deep!\n");
|
|
return -1;
|
|
}
|
|
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"Searching in fake hosts file %s for %s:%d\n", hostfile,
|
|
query, type);
|
|
|
|
fp = fopen(hostfile, "r");
|
|
if (fp == NULL) {
|
|
RWRAP_LOG(RWRAP_LOG_WARN,
|
|
"Opening %s failed: %s",
|
|
hostfile, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
while (fgets(buf, sizeof(buf), fp) != NULL) {
|
|
char *rec_type;
|
|
char *q;
|
|
|
|
rec_type = buf;
|
|
key = value = NULL;
|
|
|
|
NEXT_KEY(rec_type, key);
|
|
NEXT_KEY(key, value);
|
|
|
|
if (key == NULL || value == NULL) {
|
|
RWRAP_LOG(RWRAP_LOG_WARN,
|
|
"Malformed line: not enough parts, use \"rec_type key data\n"
|
|
"For example \"A cwrap.org 10.10.10.10\"");
|
|
continue;
|
|
}
|
|
|
|
q = value;
|
|
while(q[0] != '\n' && q[0] != '\0') {
|
|
q++;
|
|
}
|
|
q[0] = '\0';
|
|
|
|
if (type == ns_t_uri && recursion > 0) {
|
|
/* Skip non-URI records. */
|
|
if (!TYPE_MATCH(type, ns_t_uri, rec_type, "URI", key, query)) {
|
|
continue;
|
|
}
|
|
/* Skip previous records based on the recurse depth. */
|
|
num_uris++;
|
|
if (num_uris <= recursion) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (TYPE_MATCH(type, ns_t_a, rec_type, "A", key, query)) {
|
|
rc = rwrap_create_fake_a_rr(key, value, rr);
|
|
break;
|
|
} else if (TYPE_MATCH(type, ns_t_aaaa,
|
|
rec_type, "AAAA", key, query)) {
|
|
rc = rwrap_create_fake_aaaa_rr(key, value, rr);
|
|
break;
|
|
} else if (TYPE_MATCH(type, ns_t_ns,
|
|
rec_type, "NS", key, query)) {
|
|
rc = rwrap_create_fake_ns_rr(key, value, rr);
|
|
break;
|
|
} else if (TYPE_MATCH(type, ns_t_srv,
|
|
rec_type, "SRV", key, query)) {
|
|
rc = rwrap_create_fake_srv_rr(key, value, rr);
|
|
if (rc == 0) {
|
|
rc = rwrap_srv_recurse(hostfile, recursion+1,
|
|
rr->rrdata.srv_rec.hostname,
|
|
rr + 1);
|
|
}
|
|
break;
|
|
} else if (TYPE_MATCH(type, ns_t_uri,
|
|
rec_type, "URI", key, query)) {
|
|
rc = rwrap_create_fake_uri_rr(key, value, rr);
|
|
if (rc == 0) {
|
|
/* Recurse to collect multiple URI answers under a single key. */
|
|
rc = rwrap_uri_recurse(hostfile, recursion + 1, key, rr + 1);
|
|
}
|
|
break;
|
|
} else if (TYPE_MATCH(type, ns_t_soa,
|
|
rec_type, "SOA", key, query)) {
|
|
rc = rwrap_create_fake_soa_rr(key, value, rr);
|
|
break;
|
|
} else if (TYPE_MATCH(type, ns_t_cname,
|
|
rec_type, "CNAME", key, query)) {
|
|
rc = rwrap_create_fake_cname_rr(key, value, rr);
|
|
if (rc == 0) {
|
|
rc = rwrap_cname_recurse(hostfile, recursion+1,
|
|
value, rr + 1);
|
|
}
|
|
break;
|
|
} else if (TYPE_MATCH(type, ns_t_a, rec_type, "CNAME", key, query)) {
|
|
rc = rwrap_create_fake_cname_rr(key, value, rr);
|
|
if (rc == 0) {
|
|
rc = rwrap_cname_recurse(hostfile, recursion+1,
|
|
value, rr + 1);
|
|
}
|
|
break;
|
|
} else if (TYPE_MATCH(type, ns_t_ptr,
|
|
rec_type, "PTR", key, query)) {
|
|
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) {
|
|
RWRAP_LOG(RWRAP_LOG_TRACE, "Record for [%s] not found\n", query);
|
|
memcpy(rr->key, key, strlen(key) + 1);
|
|
}
|
|
|
|
fclose(fp);
|
|
return rc;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_empty(int type,
|
|
const char *question,
|
|
uint8_t *answer,
|
|
size_t anslen)
|
|
{
|
|
ssize_t resp_data;
|
|
size_t remaining = anslen;
|
|
|
|
resp_data = rwrap_fake_header(&answer, remaining, 0, 0);
|
|
if (resp_data < 0) {
|
|
return -1;
|
|
}
|
|
remaining -= resp_data;
|
|
|
|
resp_data += rwrap_fake_question(question, type, &answer, remaining);
|
|
if (resp_data < 0) {
|
|
return -1;
|
|
}
|
|
remaining -= resp_data;
|
|
|
|
resp_data += rwrap_fake_rdata_common(type, 0, question,
|
|
remaining, &answer);
|
|
if (resp_data < 0) {
|
|
return -1;
|
|
}
|
|
|
|
return resp_data;
|
|
}
|
|
|
|
static inline bool rwrap_known_type(int type)
|
|
{
|
|
switch (type) {
|
|
case ns_t_a:
|
|
case ns_t_aaaa:
|
|
case ns_t_ns:
|
|
case ns_t_srv:
|
|
case ns_t_uri:
|
|
case ns_t_soa:
|
|
case ns_t_cname:
|
|
case ns_t_ptr:
|
|
case ns_t_txt:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static int rwrap_ancount(struct rwrap_fake_rr *rrs, int qtype)
|
|
{
|
|
int i;
|
|
int ancount = 0;
|
|
|
|
/* For URI return the number of URIs. */
|
|
if (qtype == ns_t_uri) {
|
|
for (i = 0; i < RWRAP_MAX_RECURSION; i++) {
|
|
if (rwrap_known_type(rrs[i].type) &&
|
|
rrs[i].type == qtype) {
|
|
ancount++;
|
|
}
|
|
}
|
|
return ancount;
|
|
}
|
|
|
|
/* Include all RRs in the stack until the sought type
|
|
* in the answer section. This is the case i.e. when looking
|
|
* up an A record but the name points to a CNAME
|
|
*/
|
|
for (i = 0; i < RWRAP_MAX_RECURSION; i++) {
|
|
ancount++;
|
|
|
|
if (rwrap_known_type(rrs[i].type) &&
|
|
rrs[i].type == qtype) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Return 0 records if the sought type wasn't in the stack */
|
|
return i < RWRAP_MAX_RECURSION ? ancount : 0;
|
|
}
|
|
|
|
static int rwrap_arcount(struct rwrap_fake_rr *rrs, int ancount)
|
|
{
|
|
int i;
|
|
int arcount = 0;
|
|
|
|
/* start from index ancount */
|
|
for (i = ancount; i < RWRAP_MAX_RECURSION; i++) {
|
|
if (rwrap_known_type(rrs[i].type)) {
|
|
arcount++;
|
|
}
|
|
}
|
|
|
|
return arcount;
|
|
}
|
|
|
|
static ssize_t rwrap_add_rr(struct rwrap_fake_rr *rr,
|
|
uint8_t *answer,
|
|
size_t anslen)
|
|
{
|
|
ssize_t resp_data;
|
|
|
|
if (rr == NULL) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Internal error!\n");
|
|
return -1;
|
|
}
|
|
|
|
switch (rr->type) {
|
|
case ns_t_a:
|
|
resp_data = rwrap_fake_a(rr, answer, anslen);
|
|
break;
|
|
case ns_t_aaaa:
|
|
resp_data = rwrap_fake_aaaa(rr, answer, anslen);
|
|
break;
|
|
case ns_t_ns:
|
|
resp_data = rwrap_fake_ns(rr, answer, anslen);
|
|
break;
|
|
case ns_t_srv:
|
|
resp_data = rwrap_fake_srv(rr, answer, anslen);
|
|
break;
|
|
case ns_t_uri:
|
|
resp_data = rwrap_fake_uri(rr, answer, anslen);
|
|
break;
|
|
case ns_t_soa:
|
|
resp_data = rwrap_fake_soa(rr, answer, anslen);
|
|
break;
|
|
case ns_t_cname:
|
|
resp_data = rwrap_fake_cname(rr, answer, anslen);
|
|
break;
|
|
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;
|
|
}
|
|
|
|
return resp_data;
|
|
}
|
|
|
|
static ssize_t rwrap_fake_answer(struct rwrap_fake_rr *rrs,
|
|
int type,
|
|
uint8_t *answer,
|
|
size_t anslen)
|
|
|
|
{
|
|
ssize_t resp_data;
|
|
ssize_t rrlen;
|
|
size_t remaining = anslen;
|
|
int ancount;
|
|
int arcount;
|
|
int i;
|
|
|
|
ancount = rwrap_ancount(rrs, type);
|
|
arcount = rwrap_arcount(rrs, ancount);
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"Got %d answers and %d additional records\n", ancount, arcount);
|
|
|
|
resp_data = rwrap_fake_header(&answer, remaining, ancount, arcount);
|
|
if (resp_data < 0) {
|
|
return -1;
|
|
}
|
|
remaining -= resp_data;
|
|
|
|
resp_data += rwrap_fake_question(rrs->key, rrs->type, &answer, remaining);
|
|
if (resp_data < 0) {
|
|
return -1;
|
|
}
|
|
remaining -= resp_data;
|
|
|
|
/* answer */
|
|
for (i = 0; i < ancount; i++) {
|
|
rrlen = rwrap_add_rr(&rrs[i], answer, remaining);
|
|
if (rrlen < 0) {
|
|
return -1;
|
|
}
|
|
remaining -= rrlen;
|
|
answer += rrlen;
|
|
resp_data += rrlen;
|
|
}
|
|
|
|
/* add authoritative NS here? */
|
|
|
|
/* additional records */
|
|
for (i = ancount; i < ancount + arcount; i++) {
|
|
rrlen = rwrap_add_rr(&rrs[i], answer, remaining);
|
|
if (rrlen < 0) {
|
|
return -1;
|
|
}
|
|
remaining -= rrlen;
|
|
answer += rrlen;
|
|
resp_data += rrlen;
|
|
}
|
|
|
|
return resp_data;
|
|
}
|
|
|
|
/* Reads in a file in the following format:
|
|
* TYPE RDATA
|
|
*
|
|
* Malformed entries are silently skipped.
|
|
* Allocates answer buffer of size anslen that has to be freed after use.
|
|
*/
|
|
static int rwrap_res_fake_hosts(const char *hostfile,
|
|
const char *query,
|
|
int type,
|
|
unsigned char *answer,
|
|
size_t anslen)
|
|
{
|
|
int rc = ENOENT;
|
|
char *query_name = NULL;
|
|
size_t qlen = strlen(query);
|
|
struct rwrap_fake_rr rrs[RWRAP_MAX_RECURSION];
|
|
ssize_t resp_size;
|
|
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"Searching in fake hosts file %s\n", hostfile);
|
|
|
|
if (qlen > 0 && query[qlen-1] == '.') {
|
|
qlen--;
|
|
}
|
|
|
|
query_name = strndup(query, qlen);
|
|
if (query_name == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
rwrap_fake_rr_init(rrs, RWRAP_MAX_RECURSION);
|
|
|
|
rc = rwrap_get_record(hostfile, 0, query_name, type, rrs);
|
|
switch (rc) {
|
|
case 0:
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"Found record for [%s]\n", query_name);
|
|
resp_size = rwrap_fake_answer(rrs, type, answer, anslen);
|
|
break;
|
|
case ENOENT:
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"No record for [%s]\n", query_name);
|
|
resp_size = rwrap_fake_empty(type, rrs->key, answer, anslen);
|
|
break;
|
|
default:
|
|
RWRAP_LOG(RWRAP_LOG_NOTICE,
|
|
"Searching for [%s] did not return any results\n",
|
|
query_name);
|
|
free(query_name);
|
|
return -1;
|
|
}
|
|
|
|
switch (resp_size) {
|
|
case -1:
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Error faking answer for [%s]\n", query_name);
|
|
break;
|
|
default:
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"Successfully faked answer for [%s]\n",
|
|
query_name);
|
|
break;
|
|
}
|
|
|
|
free(query_name);
|
|
return resp_size;
|
|
}
|
|
|
|
/*********************************************************
|
|
* RWRAP LOADING LIBC FUNCTIONS
|
|
*********************************************************/
|
|
|
|
#include <dlfcn.h>
|
|
|
|
typedef int (*__libc_res_ninit)(struct __res_state *state);
|
|
typedef int (*__libc___res_ninit)(struct __res_state *state);
|
|
typedef void (*__libc_res_nclose)(struct __res_state *state);
|
|
typedef void (*__libc___res_nclose)(struct __res_state *state);
|
|
typedef int (*__libc_res_nquery)(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen);
|
|
typedef int (*__libc___res_nquery)(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen);
|
|
typedef int (*__libc_res_nsearch)(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen);
|
|
typedef int (*__libc___res_nsearch)(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen);
|
|
|
|
#define RWRAP_SYMBOL_ENTRY(i) \
|
|
union { \
|
|
__libc_##i f; \
|
|
void *obj; \
|
|
} _libc_##i
|
|
|
|
struct rwrap_libc_symbols {
|
|
RWRAP_SYMBOL_ENTRY(res_ninit);
|
|
RWRAP_SYMBOL_ENTRY(__res_ninit);
|
|
RWRAP_SYMBOL_ENTRY(res_nclose);
|
|
RWRAP_SYMBOL_ENTRY(__res_nclose);
|
|
RWRAP_SYMBOL_ENTRY(res_nquery);
|
|
RWRAP_SYMBOL_ENTRY(__res_nquery);
|
|
RWRAP_SYMBOL_ENTRY(res_nsearch);
|
|
RWRAP_SYMBOL_ENTRY(__res_nsearch);
|
|
};
|
|
#undef RWRAP_SYMBOL_ENTRY
|
|
|
|
struct rwrap {
|
|
struct {
|
|
void *handle;
|
|
struct rwrap_libc_symbols symbols;
|
|
} libc;
|
|
|
|
struct {
|
|
void *handle;
|
|
struct rwrap_libc_symbols symbols;
|
|
} libresolv;
|
|
|
|
bool initialised;
|
|
bool enabled;
|
|
|
|
char *socket_dir;
|
|
};
|
|
|
|
static struct rwrap rwrap;
|
|
|
|
enum rwrap_lib {
|
|
RWRAP_LIBC,
|
|
RWRAP_LIBRESOLV
|
|
};
|
|
|
|
static const char *rwrap_str_lib(enum rwrap_lib lib)
|
|
{
|
|
switch (lib) {
|
|
case RWRAP_LIBC:
|
|
return "libc";
|
|
case RWRAP_LIBRESOLV:
|
|
return "libresolv";
|
|
}
|
|
|
|
/* Compiler would warn us about unhandled enum value if we get here */
|
|
return "unknown";
|
|
}
|
|
|
|
static void *rwrap_load_lib_handle(enum rwrap_lib lib)
|
|
{
|
|
int flags = RTLD_LAZY;
|
|
void *handle = NULL;
|
|
int i;
|
|
|
|
#ifdef 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) {
|
|
case RWRAP_LIBRESOLV:
|
|
#ifdef HAVE_LIBRESOLV
|
|
handle = rwrap.libresolv.handle;
|
|
if (handle == NULL) {
|
|
for (i = 10; i >= 0; i--) {
|
|
char soname[256] = {0};
|
|
|
|
snprintf(soname, sizeof(soname), "libresolv.so.%d", i);
|
|
handle = dlopen(soname, flags);
|
|
if (handle != NULL) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
rwrap.libresolv.handle = handle;
|
|
}
|
|
break;
|
|
#endif
|
|
/* FALL TROUGH */
|
|
case RWRAP_LIBC:
|
|
handle = rwrap.libc.handle;
|
|
#ifdef LIBC_SO
|
|
if (handle == NULL) {
|
|
handle = dlopen(LIBC_SO, flags);
|
|
|
|
rwrap.libc.handle = handle;
|
|
}
|
|
#endif
|
|
if (handle == NULL) {
|
|
for (i = 10; i >= 0; i--) {
|
|
char soname[256] = {0};
|
|
|
|
snprintf(soname, sizeof(soname), "libc.so.%d", i);
|
|
handle = dlopen(soname, flags);
|
|
if (handle != NULL) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
rwrap.libc.handle = handle;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (handle == NULL) {
|
|
#ifdef RTLD_NEXT
|
|
handle = rwrap.libc.handle = rwrap.libresolv.handle = RTLD_NEXT;
|
|
#else
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Failed to dlopen library: %s\n",
|
|
dlerror());
|
|
exit(-1);
|
|
#endif
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
static void *_rwrap_bind_symbol(enum rwrap_lib lib, const char *fn_name)
|
|
{
|
|
void *handle;
|
|
void *func;
|
|
|
|
handle = rwrap_load_lib_handle(lib);
|
|
|
|
func = dlsym(handle, fn_name);
|
|
if (func == NULL) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Failed to find %s: %s\n",
|
|
fn_name, dlerror());
|
|
exit(-1);
|
|
}
|
|
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"Loaded %s from %s",
|
|
fn_name, rwrap_str_lib(lib));
|
|
return func;
|
|
}
|
|
|
|
#define rwrap_bind_symbol_libc(sym_name) \
|
|
if (rwrap.libc.symbols._libc_##sym_name.obj == NULL) { \
|
|
rwrap.libc.symbols._libc_##sym_name.obj = \
|
|
_rwrap_bind_symbol(RWRAP_LIBC, #sym_name); \
|
|
}
|
|
|
|
#define rwrap_bind_symbol_libresolv(sym_name) \
|
|
if (rwrap.libresolv.symbols._libc_##sym_name.obj == NULL) { \
|
|
rwrap.libresolv.symbols._libc_##sym_name.obj = \
|
|
_rwrap_bind_symbol(RWRAP_LIBRESOLV, #sym_name); \
|
|
}
|
|
|
|
/*
|
|
* IMPORTANT
|
|
*
|
|
* Functions especially from libc need to be loaded individually, you can't load
|
|
* all at once or gdb will segfault at startup. The same applies to valgrind and
|
|
* has probably something todo with with the linker.
|
|
* So we need load each function at the point it is called the first time.
|
|
*/
|
|
|
|
static int libc_res_ninit(struct __res_state *state)
|
|
{
|
|
#if !defined(res_ninit) && defined(HAVE_RES_NINIT)
|
|
rwrap_bind_symbol_libresolv(res_ninit);
|
|
|
|
return rwrap.libresolv.symbols._libc_res_ninit.f(state);
|
|
#elif defined(HAVE___RES_NINIT)
|
|
rwrap_bind_symbol_libresolv(__res_ninit);
|
|
|
|
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)
|
|
rwrap_bind_symbol_libresolv(res_nclose);
|
|
|
|
rwrap.libresolv.symbols._libc_res_nclose.f(state);
|
|
return;
|
|
#elif defined(HAVE___RES_NCLOSE)
|
|
rwrap_bind_symbol_libresolv(__res_nclose);
|
|
|
|
rwrap.libresolv.symbols._libc___res_nclose.f(state);
|
|
#else
|
|
#error "No res_nclose function"
|
|
#endif
|
|
}
|
|
|
|
static int libc_res_nquery(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
{
|
|
#if !defined(res_nquery) && defined(HAVE_RES_NQUERY)
|
|
rwrap_bind_symbol_libresolv(res_nquery);
|
|
|
|
return rwrap.libresolv.symbols._libc_res_nquery.f(state,
|
|
dname,
|
|
class,
|
|
type,
|
|
answer,
|
|
anslen);
|
|
#elif defined(HAVE___RES_NQUERY)
|
|
rwrap_bind_symbol_libresolv(__res_nquery);
|
|
|
|
return rwrap.libresolv.symbols._libc___res_nquery.f(state,
|
|
dname,
|
|
class,
|
|
type,
|
|
answer,
|
|
anslen);
|
|
#else
|
|
#error "No res_nquery function"
|
|
#endif
|
|
}
|
|
|
|
static int libc_res_nsearch(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
{
|
|
#if !defined(res_nsearch) && defined(HAVE_RES_NSEARCH)
|
|
rwrap_bind_symbol_libresolv(res_nsearch);
|
|
|
|
return rwrap.libresolv.symbols._libc_res_nsearch.f(state,
|
|
dname,
|
|
class,
|
|
type,
|
|
answer,
|
|
anslen);
|
|
#elif defined(HAVE___RES_NSEARCH)
|
|
rwrap_bind_symbol_libresolv(__res_nsearch);
|
|
|
|
return rwrap.libresolv.symbols._libc___res_nsearch.f(state,
|
|
dname,
|
|
class,
|
|
type,
|
|
answer,
|
|
anslen);
|
|
#else
|
|
#error "No res_nsearch 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];
|
|
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_WARN,
|
|
"Opening %s failed: %s",
|
|
resolv_conf, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
while(fgets(buf, sizeof(buf), fp) != NULL) {
|
|
char *p;
|
|
|
|
/* Ignore comments */
|
|
if (buf[0] == '#' || buf[0] == ';') {
|
|
continue;
|
|
}
|
|
|
|
if (RESOLV_MATCH(buf, "nameserver") && nserv < MAXNS) {
|
|
struct in_addr a;
|
|
struct in6_addr a6;
|
|
char *q;
|
|
int ok;
|
|
|
|
p = buf + strlen("nameserver");
|
|
|
|
/* Skip spaces and tabs */
|
|
while(isblank((int)p[0])) {
|
|
p++;
|
|
}
|
|
|
|
q = p;
|
|
while(q[0] != '\n' && q[0] != '\0') {
|
|
q++;
|
|
}
|
|
q[0] = '\0';
|
|
|
|
ok = inet_pton(AF_INET, p, &a);
|
|
if (ok) {
|
|
nsaddrs[nserv] = (union rwrap_sockaddr) {
|
|
.in = {
|
|
.sin_family = AF_INET,
|
|
.sin_addr = a,
|
|
.sin_port = htons(53),
|
|
.sin_zero = { 0 },
|
|
},
|
|
};
|
|
|
|
nserv++;
|
|
continue;
|
|
}
|
|
|
|
ok = inet_pton(AF_INET6, p, &a6);
|
|
if (ok) {
|
|
#ifdef HAVE_RESOLV_IPV6_NSADDRS
|
|
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 */
|
|
RWRAP_LOG(RWRAP_LOG_WARN,
|
|
"resolve_wrapper does not support "
|
|
"IPv6 on this platform");
|
|
continue;
|
|
#endif
|
|
}
|
|
|
|
RWRAP_LOG(RWRAP_LOG_ERROR, "Malformed DNS server[%s]", p);
|
|
continue;
|
|
} /* TODO: match other keywords */
|
|
}
|
|
|
|
if (ferror(fp)) {
|
|
RWRAP_LOG(RWRAP_LOG_ERROR,
|
|
"Reading from %s failed",
|
|
resolv_conf);
|
|
fclose(fp);
|
|
return -1;
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
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);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* RES_NINIT
|
|
***************************************************************************/
|
|
|
|
static int rwrap_res_ninit(struct __res_state *state)
|
|
{
|
|
int rc;
|
|
|
|
rc = libc_res_ninit(state);
|
|
if (rc == 0) {
|
|
const char *resolv_conf = getenv("RESOLV_WRAPPER_CONF");
|
|
|
|
if (resolv_conf != NULL) {
|
|
rc = rwrap_parse_resolv_conf(state, resolv_conf);
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
#if !defined(res_ninit) && defined(HAVE_RES_NINIT)
|
|
int res_ninit(struct __res_state *state)
|
|
#elif defined(HAVE___RES_NINIT)
|
|
int __res_ninit(struct __res_state *state)
|
|
#endif
|
|
{
|
|
return rwrap_res_ninit(state);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* RES_INIT
|
|
***************************************************************************/
|
|
|
|
static struct __res_state rwrap_res_state;
|
|
|
|
static int rwrap_res_init(void)
|
|
{
|
|
int rc;
|
|
|
|
rc = rwrap_res_ninit(&rwrap_res_state);
|
|
|
|
return rc;
|
|
}
|
|
|
|
#if !defined(res_ninit) && defined(HAVE_RES_INIT)
|
|
int res_init(void)
|
|
#elif defined(HAVE___RES_INIT)
|
|
int __res_init(void)
|
|
#endif
|
|
{
|
|
return rwrap_res_init();
|
|
}
|
|
|
|
/****************************************************************************
|
|
* RES_NCLOSE
|
|
***************************************************************************/
|
|
|
|
static void rwrap_res_nclose(struct __res_state *state)
|
|
{
|
|
rwrap_reset_nameservers(state);
|
|
libc_res_nclose(state);
|
|
}
|
|
|
|
#if !defined(res_nclose) && defined(HAVE_RES_NCLOSE)
|
|
void res_nclose(struct __res_state *state)
|
|
#elif defined(HAVE___RES_NCLOSE)
|
|
void __res_nclose(struct __res_state *state)
|
|
#endif
|
|
{
|
|
rwrap_res_nclose(state);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* RES_CLOSE
|
|
***************************************************************************/
|
|
|
|
static void rwrap_res_close(void)
|
|
{
|
|
rwrap_res_nclose(&rwrap_res_state);
|
|
}
|
|
|
|
#if defined(HAVE_RES_CLOSE)
|
|
void res_close(void)
|
|
#elif defined(HAVE___RES_CLOSE)
|
|
void __res_close(void)
|
|
#endif
|
|
{
|
|
rwrap_res_close();
|
|
}
|
|
|
|
/****************************************************************************
|
|
* RES_NQUERY
|
|
***************************************************************************/
|
|
|
|
static int rwrap_res_nquery(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
{
|
|
int rc;
|
|
const char *fake_hosts;
|
|
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"Resolve the domain name [%s] - class=%d, type=%d",
|
|
dname, class, type);
|
|
rwrap_log_nameservers(RWRAP_LOG_TRACE, __func__, state);
|
|
|
|
fake_hosts = getenv("RESOLV_WRAPPER_HOSTS");
|
|
if (fake_hosts != NULL) {
|
|
rc = rwrap_res_fake_hosts(fake_hosts, dname, type, answer, anslen);
|
|
} else {
|
|
rc = libc_res_nquery(state, dname, class, type, answer, anslen);
|
|
}
|
|
|
|
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"The returned response length is: %d",
|
|
rc);
|
|
|
|
return rc;
|
|
}
|
|
|
|
#if !defined(res_nquery) && defined(HAVE_RES_NQUERY)
|
|
int res_nquery(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
#elif defined(HAVE___RES_NQUERY)
|
|
int __res_nquery(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
#endif
|
|
{
|
|
return rwrap_res_nquery(state, dname, class, type, answer, anslen);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* RES_QUERY
|
|
***************************************************************************/
|
|
|
|
static int rwrap_res_query(const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
{
|
|
int rc;
|
|
|
|
rc = rwrap_res_ninit(&rwrap_res_state);
|
|
if (rc != 0) {
|
|
return rc;
|
|
}
|
|
|
|
rc = rwrap_res_nquery(&rwrap_res_state,
|
|
dname,
|
|
class,
|
|
type,
|
|
answer,
|
|
anslen);
|
|
|
|
return rc;
|
|
}
|
|
|
|
#if !defined(res_query) && defined(HAVE_RES_QUERY)
|
|
int res_query(const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
#elif defined(HAVE___RES_QUERY)
|
|
int __res_query(const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
#endif
|
|
{
|
|
return rwrap_res_query(dname, class, type, answer, anslen);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* RES_NSEARCH
|
|
***************************************************************************/
|
|
|
|
static int rwrap_res_nsearch(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
{
|
|
int rc;
|
|
const char *fake_hosts;
|
|
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"Resolve the domain name [%s] - class=%d, type=%d",
|
|
dname, class, type);
|
|
rwrap_log_nameservers(RWRAP_LOG_TRACE, __func__, state);
|
|
|
|
fake_hosts = getenv("RESOLV_WRAPPER_HOSTS");
|
|
if (fake_hosts != NULL) {
|
|
rc = rwrap_res_fake_hosts(fake_hosts, dname, type, answer, anslen);
|
|
} else {
|
|
rc = libc_res_nsearch(state, dname, class, type, answer, anslen);
|
|
}
|
|
|
|
RWRAP_LOG(RWRAP_LOG_TRACE,
|
|
"The returned response length is: %d",
|
|
rc);
|
|
|
|
return rc;
|
|
}
|
|
|
|
#if !defined(res_nsearch) && defined(HAVE_RES_NSEARCH)
|
|
int res_nsearch(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
#elif defined(HAVE___RES_NSEARCH)
|
|
int __res_nsearch(struct __res_state *state,
|
|
const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
#endif
|
|
{
|
|
return rwrap_res_nsearch(state, dname, class, type, answer, anslen);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* RES_SEARCH
|
|
***************************************************************************/
|
|
|
|
static int rwrap_res_search(const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
{
|
|
int rc;
|
|
|
|
rc = rwrap_res_ninit(&rwrap_res_state);
|
|
if (rc != 0) {
|
|
return rc;
|
|
}
|
|
|
|
rc = rwrap_res_nsearch(&rwrap_res_state,
|
|
dname,
|
|
class,
|
|
type,
|
|
answer,
|
|
anslen);
|
|
|
|
return rc;
|
|
}
|
|
|
|
#if !defined(res_search) && defined(HAVE_RES_SEARCH)
|
|
int res_search(const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
#elif defined(HAVE___RES_SEARCH)
|
|
int __res_search(const char *dname,
|
|
int class,
|
|
int type,
|
|
unsigned char *answer,
|
|
int anslen)
|
|
#endif
|
|
{
|
|
return rwrap_res_search(dname, class, type, answer, anslen);
|
|
}
|