int unbound_init(struct ub_ctx *dnsctx)
{
int ugh;
/* create unbound resolver context */
dnsctx = ub_ctx_create();
if(!dnsctx) {
libreswan_log("error: could not create unbound context\n");
return 0;
}
DBG(DBG_DNS,
ub_ctx_debuglevel(dnsctx,5);
DBG_log("unbound context created - setting debug level to 5\n"));
/* lookup from /etc/hosts before DNS lookups as people expect that */
if( (ugh=ub_ctx_hosts(dnsctx, "/etc/hosts")) != 0) {
libreswan_log("error reading hosts: %s: %s\n",
ub_strerror(ugh), strerror(errno));
return 0;
}
DBG(DBG_DNS, DBG_log("/etc/hosts lookups activated\n"));
/*
* Use /etc/resolv.conf as forwarding cache - we expect people to reconfigure this
* file if they need to work around DHCP DNS obtained servers
*/
if( (ugh=ub_ctx_resolvconf(dnsctx, "/etc/resolv.conf")) != 0) {
libreswan_log("error reading resolv.conf: %s: %s\n",
ub_strerror(ugh), strerror(errno));
return 0;
}
DBG(DBG_DNS, DBG_log("/etc/resolv.conf usage activated\n"));
/* add trust anchors to libunbound context - make this configurable later */
DBG(DBG_DNS, DBG_log("Loading root key:%s\n",rootanchor));
ugh = ub_ctx_add_ta(dnsctx, rootanchor);
if(ugh != 0) {
libreswan_log("error adding the DNSSEC root key: %s: %s\n", ub_strerror(ugh), strerror(errno));
return 0;
}
/* Enable DLV */
DBG(DBG_DNS, DBG_log("Loading dlv key:%s\n",dlvanchor));
ugh = ub_ctx_set_option(dnsctx, "dlv-anchor:",dlvanchor);
if(ugh != 0) {
libreswan_log("error adding the DLV key: %s: %s\n", ub_strerror(ugh), strerror(errno));
return 0;
}
return 1;
}
/** print result from lookup nicely */
static void
print_result(struct lookinfo* info)
{
char buf[100];
if(info->err) /* error (from libunbound) */
printf("%s: error %s\n", info->name,
ub_strerror(info->err));
else if(!info->result)
printf("%s: cancelled\n", info->name);
else if(info->result->havedata)
printf("%s: %s\n", info->name,
inet_ntop(AF_INET, info->result->data[0],
buf, (socklen_t)sizeof(buf)));
else {
/* there is no data, why that? */
if(info->result->rcode == 0 /*noerror*/ ||
info->result->nxdomain)
printf("%s: no data %s\n", info->name,
info->result->nxdomain?"(no such host)":
"(no IP4 address)");
else /* some error (from the server) */
printf("%s: DNS error %d\n", info->name,
info->result->rcode);
}
}
/** check error, if bad, exit with error message */
static void
checkerr(const char* desc, int err)
{
if(err != 0) {
printf("%s error: %s\n", desc, ub_strerror(err));
exit(1);
}
}
/** print error if any */
static void
check_ub_res(int r)
{
if(r != 0) {
fprintf(stderr, "error: %s\n", ub_strerror(r));
exit(1);
}
}
/*
* Even when run in asyncronous mode, callbacks sent to libunbound still
* must be run in an application-side thread (via ub_process.) This is
* probably to keep the API usage consistent across threaded and forked
* embedded client modes. This callback function lets an event loop call
* ub_process when the instance's file descriptor becomes ready.
*/
static void ub_fd_handler(UNUSED fr_event_list_t *el, UNUSED int sock, UNUSED int flags, void *ctx)
{
rlm_unbound_t *inst = ctx;
int err;
err = ub_process(inst->ub);
if (err) {
ERROR("Async ub_process: %s", ub_strerror(err));
}
}
struct ub_result * unbify_resolve(const char *hostname) {
/*@only@*/ static struct ub_ctx * u = NULL;
struct ub_result * r = NULL;
int ub_err;
assert(hostname != NULL);
if ( u == NULL ) {
if ( (u = ub_ctx_create()) == NULL ) {
unbify_log_error("ub_ctx_create() error");
return NULL;
}
if ( (ub_err = ub_ctx_config(u, UNBOUND_CONFIG_FILE)) != 0 ) {
/*@-mustfreefresh@*/
unbify_log_error(ub_strerror(ub_err));
/*@=mustfreefresh@*/
ub_ctx_delete(u);
u = NULL;
return NULL;
}
}
/*@-unrecog@*/
if ( (ub_err = ub_resolve(u, (char*)hostname, LDNS_RR_TYPE_A, LDNS_RR_CLASS_IN, &r)) != 0 ) {
/*@=unrecog -mustfreefresh@*/
unbify_log_error(ub_strerror(ub_err));
/*@=mustfreefresh@*/
if (r) {
ub_resolve_free(r);
return NULL;
}
}
return r;
}
/** perform a lookup and printout return if domain existed */
static int
dnslook(struct ub_ctx* ctx, char* q, int t, int c, int docname)
{
int ret;
struct ub_result* result;
ret = ub_resolve(ctx, q, t, c, &result);
if(ret != 0) {
fprintf(stderr, "resolve error: %s\n", ub_strerror(ret));
exit(1);
}
pretty_output(q, t, c, result, docname);
ret = result->nxdomain;
ub_resolve_free(result);
return ret;
}
/*
* Callback sent to libunbound for xlat functions. Simply links the
* new ub_result via a pointer that has been allocated from the heap.
* This pointer has been pre-initialized to a magic value.
*/
static void link_ubres(void *my_arg, int err, struct ub_result *result)
{
struct ub_result **ubres = (struct ub_result **)my_arg;
/*
* Note that while result will be NULL on error, we are explicit
* here because that is actually a behavior that is suboptimal
* and only documented in the examples. It could change.
*/
if (err) {
ERROR("%s", ub_strerror(err));
*ubres = NULL;
} else {
*ubres = result;
}
}
/** lookup data */
static struct ub_result*
do_lookup(struct ub_ctx* ctx, char* domain)
{
struct ub_result* result = NULL;
int r;
r = ub_resolve(ctx, domain, LDNS_RR_TYPE_DNSKEY, LDNS_RR_CLASS_IN,
&result);
if(r) {
printf("failed to lookup %s\n", ub_strerror(r));
fatal("ub_resolve failed");
}
if(!result->havedata && (result->rcode == LDNS_RCODE_SERVFAIL ||
result->rcode == LDNS_RCODE_REFUSED))
return NULL; /* probably no internet connection */
if(!result->havedata) fatal("result has no data");
if(!result->secure) fatal("result is not secure");
return result;
}
static int ub_common_wait(rlm_unbound_t const *inst, REQUEST *request,
char const *name, struct ub_result **ub, int async_id)
{
useconds_t iv, waited;
iv = inst->timeout > 64 ? 64000 : inst->timeout * 1000;
ub_process(inst->ub);
for (waited = 0; (void const *)*ub == (void const *)inst; waited += iv, iv *= 2) {
if (waited + iv > (useconds_t)inst->timeout * 1000) {
usleep(inst->timeout * 1000 - waited);
ub_process(inst->ub);
break;
}
usleep(iv);
/* Check if already handled by event loop */
if ((void const *)*ub != (void const *)inst) {
break;
}
/* In case we are running single threaded */
ub_process(inst->ub);
}
if ((void const *)*ub == (void const *)inst) {
int res;
REDEBUG2("%s - DNS took too long", name);
res = ub_cancel(inst->ub, async_id);
if (res) {
REDEBUG("%s - ub_cancel: %s", name, ub_strerror(res));
}
return -1;
}
return 0;
}
/*
* synchronous blocking resolving - simple replacement of ttoaddr()
* src_len == 0 means "apply strlen"
* af == AF_UNSPEC means "try both families"
*/
bool unbound_resolve(char *src, size_t srclen, int af, ip_address *ipaddr)
{
/* 28 = AAAA record, 1 = A record */
const int qtype = (af == AF_INET6) ? 28 : 1;
struct ub_result *result;
passert(dns_ctx != NULL);
if (srclen == 0) {
srclen = strlen(src);
if (srclen == 0) {
libreswan_log("empty hostname in host lookup");
return FALSE;
}
}
{
int ugh = ub_resolve(dns_ctx, src, qtype, 1 /* CLASS IN */,
&result);
if (ugh != 0) {
libreswan_log("unbound error: %s", ub_strerror(ugh));
ub_resolve_free(result);
return FALSE;
}
}
if (result->bogus) {
libreswan_log("ERROR: %s failed DNSSEC validation!",
result->qname);
ub_resolve_free(result);
return FALSE;
}
if (!result->havedata) {
if (result->secure) {
DBG(DBG_DNS,
DBG_log("Validated reply proves '%s' does not exist",
src);
);
} else {
/** update domain to file */
static int
do_update(char* domain, char* file)
{
struct ub_ctx* ctx;
struct ub_result* result;
int r;
printf("updating %s to %s\n", domain, file);
ctx = ub_ctx_create();
if(!ctx) fatal("ub_ctx_create failed");
if((r=ub_ctx_add_ta_file(ctx, file))) {
printf("%s\n", ub_strerror(r));
fatal("ub_ctx_add_ta_file failed");
}
if(!(result=do_lookup(ctx, domain))) {
ub_ctx_delete(ctx);
return 1;
}
ub_ctx_delete(ctx);
do_print(result, file);
ub_resolve_free(result);
return 0;
}
int main(void)
{
struct ub_ctx* ctx;
volatile int qlen = 0;
int retval;
char qname[QNAME_MAX];
char *moredata, *nl;
/* basic checks */
if(QUEUE_MAX < 1) {
printf("error: queue length must be >0\n");
return 1;
}
/* create context */
ctx = ub_ctx_create();
if(!ctx) {
printf("error: could not create unbound context\n");
return 1;
}
fprintf(stderr, "HOST;ERR;RCODE;DATA;NXDOMAIN\n");
/* we keep running, lets do something while waiting */
moredata = (char*)-1;
do {
/* queue has room && more data on stdin? */
if(qlen < QUEUE_MAX && moredata) {
/* read and prepare qname from stdin */
moredata = fgets(qname, QNAME_MAX, stdin);
if(moredata != NULL) {
nl = strrchr(qname, '\n');
if(nl) *nl = '\0';
if((int)nl == (int)&qname)
{
printf("empty input\n");
continue;
}
/* add async query to queue */
retval = ub_resolve_async(ctx, qname,
1,
1,
(void*)&qlen, mycallback, NULL);
if(retval != 0) {
printf("resolve error for %s: %s\n", qname, ub_strerror(retval));
continue;
}
qlen++;
}
usleep(50000); /* wait 1/50 of a second */
} else {
/* queue is full || eof stdin reached */
usleep(100000); /* wait 1/10 of a second */
retval = ub_process(ctx);
if(retval != 0) {
printf("resolve error: %s\n", ub_strerror(retval));
return 1;
}
}
} while(qlen || moredata);
ub_ctx_delete(ctx);
return 0;
}
/* synchronous blocking resolving - simple replacement of ttoaddr()
* src_len 0 means "apply strlen"
* af 0 means "try both families
*/
int unbound_resolve(struct ub_ctx *dnsctx, char *src, size_t srclen, int af, ip_address *ipaddr)
{
const int qtype = (af == AF_INET6) ? 28 : 1; /* 28 = AAAA record, 1 = A record */
struct ub_result *result;
passert(dnsctx != NULL);
if (srclen == 0) {
srclen = strlen(src);
if (srclen == 0) {
libreswan_log("empty hostname in host lookup\n");
ub_resolve_free(result);
return 0;
}
}
{
int ugh = ub_resolve(dnsctx, src, qtype, 1 /* CLASS IN */, &result);
if(ugh != 0) {
libreswan_log("unbound error: %s", ub_strerror(ugh));
ub_resolve_free(result);
return 0;
}
}
if(result->bogus) {
libreswan_log("ERROR: %s failed DNSSEC valdation!\n", result->qname);
ub_resolve_free(result);
return 0;
}
if(!result->havedata) {
if(result->secure) {
DBG(DBG_DNS,DBG_log("Validated reply proves '%s' does not exist\n", src));
} else {
DBG(DBG_DNS,DBG_log("Failed to resolve '%s' (%s)\n", src, (result->bogus) ? "BOGUS" : "insecure"));
}
ub_resolve_free(result);
return 0;
} else if(!result->bogus) {
if(!result->secure) {
DBG(DBG_DNS,DBG_log("warning: %s lookup was not protected by DNSSEC!\n", result->qname));
}
}
#if 0
{
int i = 0;
DBG_log("The result has:\n");
DBG_log("qname: %s\n", result->qname);
DBG_log("qtype: %d\n", result->qtype);
DBG_log("qclass: %d\n", result->qclass);
if(result->canonname)
DBG_log("canonical name: %s\n", result->canonname);
DBG_log("DNS rcode: %d\n", result->rcode);
for(i=0; result->data[i] != NULL; i++) {
DBG_log("result data element %d has length %d\n",
i, result->len[i]);
}
DBG_log("result has %d data element(s)\n", i);
}
#endif
/* XXX: for now pick the first one and return that */
passert(result->data[0] != NULL);
{
char dst[INET6_ADDRSTRLEN];
err_t err = tnatoaddr(inet_ntop(af, result->data[0], dst
, (af==AF_INET) ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN)
, 0, af, ipaddr);
ub_resolve_free(result);
if(err == NULL) {
DBG(DBG_DNS,DBG_log("success for %s lookup", (af==AF_INET) ? "IPv4" : "IPv6"));
return 1;
} else {
libreswan_log("tnatoaddr failed in unbound_resolve()");
return 0;
}
}
}
/** main program for asynclook */
int main(int argc, char** argv)
{
int c;
struct ub_ctx* ctx;
struct lookinfo* lookups;
int i, r, cancel=0, blocking=0, ext=0;
/* init log now because solaris thr_key_create() is not threadsafe */
log_init(0,0,0);
/* lock debug start (if any) */
checklock_start();
/* create context */
ctx = ub_ctx_create();
if(!ctx) {
printf("could not create context, %s\n", strerror(errno));
return 1;
}
/* command line options */
if(argc == 1) {
usage(argv);
}
while( (c=getopt(argc, argv, "bcdf:hH:r:tx")) != -1) {
switch(c) {
case 'd':
r = ub_ctx_debuglevel(ctx, 3);
checkerr("ub_ctx_debuglevel", r);
break;
case 't':
r = ub_ctx_async(ctx, 1);
checkerr("ub_ctx_async", r);
break;
case 'c':
cancel = 1;
break;
case 'b':
blocking = 1;
break;
case 'r':
r = ub_ctx_resolvconf(ctx, optarg);
if(r != 0) {
printf("ub_ctx_resolvconf "
"error: %s : %s\n",
ub_strerror(r),
strerror(errno));
return 1;
}
break;
case 'H':
r = ub_ctx_hosts(ctx, optarg);
if(r != 0) {
printf("ub_ctx_hosts "
"error: %s : %s\n",
ub_strerror(r),
strerror(errno));
return 1;
}
break;
case 'f':
r = ub_ctx_set_fwd(ctx, optarg);
checkerr("ub_ctx_set_fwd", r);
break;
case 'x':
ext = 1;
break;
case 'h':
case '?':
default:
usage(argv);
}
}
argc -= optind;
argv += optind;
if(ext)
return ext_test(ctx, argc, argv);
/* allocate array for results. */
lookups = (struct lookinfo*)calloc((size_t)argc,
sizeof(struct lookinfo));
if(!lookups) {
printf("out of memory\n");
return 1;
}
/* perform asynchronous calls */
num_wait = argc;
for(i=0; i<argc; i++) {
lookups[i].name = argv[i];
if(blocking) {
fprintf(stderr, "lookup %s\n", argv[i]);
r = ub_resolve(ctx, argv[i], LDNS_RR_TYPE_A,
LDNS_RR_CLASS_IN, &lookups[i].result);
checkerr("ub_resolve", r);
} else {
fprintf(stderr, "start async lookup %s\n", argv[i]);
r = ub_resolve_async(ctx, argv[i], LDNS_RR_TYPE_A,
LDNS_RR_CLASS_IN, &lookups[i], &lookup_is_done,
&lookups[i].async_id);
checkerr("ub_resolve_async", r);
}
}
if(blocking)
num_wait = 0;
else if(cancel) {
for(i=0; i<argc; i++) {
fprintf(stderr, "cancel %s\n", argv[i]);
r = ub_cancel(ctx, lookups[i].async_id);
if(r != UB_NOID)
checkerr("ub_cancel", r);
}
num_wait = 0;
}
/* wait while the hostnames are looked up. Do something useful here */
if(num_wait > 0)
for(i=0; i<1000; i++) {
usleep(100000);
fprintf(stderr, "%g seconds passed\n", 0.1*(double)i);
r = ub_process(ctx);
checkerr("ub_process", r);
if(num_wait == 0)
break;
}
if(i>=999) {
printf("timed out\n");
return 0;
}
printf("lookup complete\n");
/* print lookup results */
for(i=0; i<argc; i++) {
print_result(&lookups[i]);
ub_resolve_free(lookups[i].result);
}
ub_ctx_delete(ctx);
free(lookups);
checklock_stop();
return 0;
}
int main(int argc, char **argv)
{
struct ub_ctx* ctx;
struct ub_result* result;
int retval;
int i;
struct timeval starttime, endtime;
int number = 100000;
if (argc > 1) {
number = atoi(argv[1]);
}
/* create context */
ctx = ub_ctx_create();
if(!ctx) {
printf("error: could not create unbound context\n");
return 1;
}
/* read /etc/resolv.conf for DNS proxy settings (from DHCP) */
if( (retval=ub_ctx_resolvconf(ctx, "resolv.conf")) != 0) {
printf("error reading resolv.conf: %s. errno says: %s\n",
ub_strerror(retval), strerror(errno));
return 1;
}
/* read /etc/hosts for locally supplied host addresses */
if( (retval=ub_ctx_hosts(ctx, "hosts")) != 0) {
printf("error reading hosts: %s. errno says: %s\n",
ub_strerror(retval), strerror(errno));
return 1;
}
/* read public keys for DNSSEC verification */
if( (retval=ub_ctx_add_ta_file(ctx, "keys")) != 0) {
printf("error adding keys: %s\n", ub_strerror(retval));
return 1;
}
/* query for webserver */
retval = ub_resolve(ctx, LOOKUP_NAME, 1, 1, &result);
if(retval != 0) {
printf("resolve error: %s\n", ub_strerror(retval));
return 1;
}
/* show first result */
if(result->havedata)
printf("The address is %s\n",
inet_ntoa(*(struct in_addr*)result->data[0]));
/* show security status */
if(!result->secure) {
fprintf(stderr, "something very wrong; not validated response returned\n");
exit(1);
}
fprintf(stderr, "validated response returned\n");
// Note: this is without proper memory freeing
fprintf(stderr, "starting %d queries without context....\n", number);
gettimeofday(&starttime, NULL);
for (i = 0; i < number; i++) {
retval = ub_resolve(ctx, LOOKUP_NAME, 1, 1, &result);
}
gettimeofday(&endtime, NULL);
fprintf(stderr, "time elapsed (ms) for %d queries: %d\n", number, timeofday_diff(&starttime, &endtime));
ub_resolve_free(result);
ub_ctx_delete(ctx);
return 0;
}
int ifconf_acquire_addresses(const char *name,
struct address **_list, unsigned *_n_list) {
struct {
struct nlmsghdr hdr;
struct rtgenmsg gen;
} req;
struct rtgenmsg *gen;
int fd, r, on = 1;
uint32_t seq = 4711;
struct address *list = NULL;
unsigned n_list = 0;
struct ub_ctx* ctx;
struct ub_result* result;
int retval, i;
char *server = "127.0.0.1:8080";
char url[3000];
fprintf(stderr, "ifconf_acquire_addresses \n");
URL *curl;
CURLcode res;
curl = curl_easy_init();
if(curl) {
sprintf(url, "http://%s/address/%s", server, name);
curl_easy_setopt(curl, CURLOPT_URL,url);
/* send all data to this function */
//curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_data);
fprintf(stderr, "Sending http request\n");
res = curl_easy_perform(curl);
//printf("read:%s\n", reply);
/* always cleanup */
curl_easy_cleanup(curl);
}
ctx = ub_ctx_create();
if(!ctx) {
printf("error: could not create unbound context\n");
retval = -1;
goto finish;
}
//ub_ctx_debuglevel(ctx, 10);
//requesting ip address from signpost
/* read /etc/resolv.conf for DNS proxy settings (from DHCP) */
if( (retval=ub_ctx_resolvconf(ctx, "/etc/resolv.conf")) != 0) {
fprintf(stderr, "error reading resolv.conf: %s. errno says: %s\n",
ub_strerror(retval), strerror(errno));
//retval = errno;
//goto finish;
}
/* read /etc/hosts for locally supplied host addresses */
if( (retval=ub_ctx_hosts(ctx, "/etc/hosts")) != 0) {
fprintf(stderr, "error reading hosts: %s. errno says: %s\n",
ub_strerror(retval), strerror(errno));
//retval = errno;
//goto finish;
}
/* query for webserver */
retval = ub_resolve(ctx, name,
1 /* TYPE A (IPv4 address) */,
1 /* CLASS IN (internet) */, &result);
if(retval != 0) {
fprintf(stderr, "error resolving: %s. errno says: %s\n",
ub_strerror(retval), strerror(errno));
retval = -ENOENT;
goto finish;
}
if(!result->havedata) {
//fprintf(stderr, "no response found\n");
retval = -ENOENT;
goto finish;
}
while(result->data[n_list]) {
list = realloc(list, (n_list+1) * sizeof(struct address));
if (!list) {
retval = -ENOMEM;
goto finish;
}
struct in_addr in;
in.s_addr = *(uint32_t *)result->data[n_list];
fprintf(stderr, "found ip %s\n", inet_ntoa(in));
list[n_list].family = AF_INET;
list[n_list].scope = 1; //ifaddrmsg->ifa_scope;
memcpy(list[n_list].address, result->data[n_list], 4);
list[n_list].ifindex = 1; //ifaddrmsg->ifa_index;
n_list++;
}
r= n_list;
goto finish;
finish:
close(fd);
ub_resolve_free(result);
ub_ctx_delete(ctx);
if (r < 0)
free(list);
else {
qsort(list, n_list, sizeof(struct address), address_compare);
*_list = list;
*_n_list = n_list;
}
//fprintf(stderr, "returned %d addr\n", n_list);
return r;
}
static int mod_instantiate(void *instance, CONF_SECTION *conf)
{
rlm_unbound_t *inst = instance;
int res;
char *optval;
fr_log_dst_t log_dst;
int log_level;
int log_fd = -1;
char k[64]; /* To silence const warns until newer unbound in distros */
/*
* @todo - move this to the thread-instantiate function
*/
inst->el = fr_global_event_list();
inst->log_pipe_stream[0] = NULL;
inst->log_pipe_stream[1] = NULL;
inst->log_fd = -1;
inst->log_pipe_in_use = false;
inst->ub = ub_ctx_create();
if (!inst->ub) {
cf_log_err(conf, "ub_ctx_create failed");
return -1;
}
/*
* Note unbound threads WILL happen with -s option, if it matters.
* We cannot tell from here whether that option is in effect.
*/
res = ub_ctx_async(inst->ub, 1);
if (res) goto error;
/* Glean some default settings to match the main server. */
/* TODO: debug_level can be changed at runtime. */
/* TODO: log until fork when stdout or stderr and !rad_debug_lvl. */
log_level = 0;
if (rad_debug_lvl > 0) {
log_level = rad_debug_lvl;
} else if (main_config->debug_level > 0) {
log_level = main_config->debug_level;
}
switch (log_level) {
/* TODO: This will need some tweaking */
case 0:
case 1:
break;
case 2:
log_level = 1;
break;
case 3:
case 4:
log_level = 2; /* mid-to-heavy levels of output */
break;
case 5:
case 6:
case 7:
case 8:
log_level = 3; /* Pretty crazy amounts of output */
break;
default:
log_level = 4; /* Insane amounts of output including crypts */
break;
}
res = ub_ctx_debuglevel(inst->ub, log_level);
if (res) goto error;
switch (default_log.dst) {
case L_DST_STDOUT:
if (!rad_debug_lvl) {
log_dst = L_DST_NULL;
break;
}
log_dst = L_DST_STDOUT;
log_fd = dup(STDOUT_FILENO);
break;
case L_DST_STDERR:
if (!rad_debug_lvl) {
log_dst = L_DST_NULL;
break;
}
log_dst = L_DST_STDOUT;
log_fd = dup(STDERR_FILENO);
break;
case L_DST_FILES:
if (main_config->log_file) {
char *log_file;
strcpy(k, "logfile:");
/* 3rd argument isn't const'd in libunbounds API */
memcpy(&log_file, &main_config->log_file, sizeof(log_file));
res = ub_ctx_set_option(inst->ub, k, log_file);
if (res) {
goto error;
}
log_dst = L_DST_FILES;
break;
}
/* FALL-THROUGH */
case L_DST_NULL:
log_dst = L_DST_NULL;
break;
default:
log_dst = L_DST_SYSLOG;
break;
}
/* Now load the config file, which can override gleaned settings. */
{
char *file;
memcpy(&file, &inst->filename, sizeof(file));
res = ub_ctx_config(inst->ub, file);
if (res) goto error;
}
/*
* Check if the config file tried to use syslog. Unbound
* does not share syslog gracefully.
*/
strcpy(k, "use-syslog");
res = ub_ctx_get_option(inst->ub, k, &optval);
if (res || !optval) goto error;
if (!strcmp(optval, "yes")) {
char v[3];
free(optval);
WARN("Overriding syslog settings");
strcpy(k, "use-syslog:");
strcpy(v, "no");
res = ub_ctx_set_option(inst->ub, k, v);
if (res) goto error;
if (log_dst == L_DST_FILES) {
char *log_file;
/* Reinstate the log file name JIC */
strcpy(k, "logfile:");
/* 3rd argument isn't const'd in libunbounds API */
memcpy(&log_file, &main_config->log_file, sizeof(log_file));
res = ub_ctx_set_option(inst->ub, k, log_file);
if (res) goto error;
}
} else {
if (optval) free(optval);
strcpy(k, "logfile");
res = ub_ctx_get_option(inst->ub, k, &optval);
if (res) goto error;
if (optval && strlen(optval)) {
log_dst = L_DST_FILES;
/*
* We open log_fd early in the process,
* so that libunbound doesn't close
* stdout / stderr on us (grrr, stupid
* software). But if the config say to
* use files, we now have to close the
* dup'd FD.
*/
if (log_fd >= 0) {
close(log_fd);
log_fd = -1;
}
} else if (!rad_debug_lvl) {
log_dst = L_DST_NULL;
}
if (optval) free(optval);
}
switch (log_dst) {
case L_DST_STDOUT:
/*
* We have an fd to log to. And we've already attempted to
* dup it so libunbound doesn't close it on us.
*/
if (log_fd == -1) {
cf_log_err(conf, "Could not dup fd");
goto error_nores;
}
inst->log_stream = fdopen(log_fd, "w");
if (!inst->log_stream) {
cf_log_err(conf, "error setting up log stream");
goto error_nores;
}
res = ub_ctx_debugout(inst->ub, inst->log_stream);
if (res) goto error;
break;
case L_DST_FILES:
/* We gave libunbound a filename. It is on its own now. */
break;
case L_DST_NULL:
/* We tell libunbound not to log at all. */
res = ub_ctx_debugout(inst->ub, NULL);
if (res) goto error;
break;
case L_DST_SYSLOG:
/*
* Currently this wreaks havoc when running threaded, so just
* turn logging off until that gets figured out.
*/
res = ub_ctx_debugout(inst->ub, NULL);
if (res) goto error;
break;
default:
break;
}
/*
* Now we need to finalize the context.
*
* There's no clean API to just finalize the context made public
* in libunbound. But we can trick it by trying to delete data
* which as it happens fails quickly and quietly even though the
* data did not exist.
*/
strcpy(k, "notar33lsite.foo123.nottld A 127.0.0.1");
ub_ctx_data_remove(inst->ub, k);
inst->log_fd = ub_fd(inst->ub);
if (inst->log_fd >= 0) {
if (fr_event_fd_insert(inst, inst->el, inst->log_fd,
ub_fd_handler,
NULL,
NULL,
inst) < 0) {
cf_log_err(conf, "could not insert async fd");
inst->log_fd = -1;
goto error_nores;
}
}
return 0;
error:
cf_log_err(conf, "%s", ub_strerror(res));
error_nores:
if (log_fd > -1) close(log_fd);
return -1;
}
static void unbound_ctx_config(bool do_dnssec, const char *rootfile, const char *trusted)
{
int ugh;
if (DBGP(DBG_DNS)) {
ub_ctx_debuglevel(dns_ctx, 5);
DBG_log("unbound context created - setting debug level to 5");
};
/* lookup from /etc/hosts before DNS lookups as people expect that */
ugh = ub_ctx_hosts(dns_ctx, "/etc/hosts");
if (ugh != 0) {
loglog(RC_LOG_SERIOUS, "error reading hosts: %s: %s",
ub_strerror(ugh), strerror(errno));
} else {
DBG(DBG_DNS, DBG_log("/etc/hosts lookups activated"));
}
/*
* Use /etc/resolv.conf as forwarding cache - we expect people
* to reconfigure this file if they need to work around DHCP DNS
* obtained servers.
*/
/*
* ??? ub_ctx_resolvconf is not currently documented to set errno.
* Private communications with W.C.A. Wijngaards 2017 October:
* "Is errno is meaningful after a failed call to libunbound?"
* "Yes it is. Specifically for the error-to-read-file case.
* Not other cases (eg. socket errors happen too far away in the code)."
*/
errno = 0;
ugh = ub_ctx_resolvconf(dns_ctx, "/etc/resolv.conf");
if (ugh != 0) {
int e = errno; /* protect value from ub_strerror */
loglog(RC_LOG_SERIOUS, "error reading /etc/resolv.conf: %s: [errno: %s]",
ub_strerror(ugh), strerror(e));
} else {
DBG(DBG_DNS, DBG_log("/etc/resolv.conf usage activated"));
}
if (!do_dnssec) {
/* No DNSSEC - nothing more to configure */
DBG(DBG_DNS, DBG_log("dnssec validation disabled by configuration"));
}
if (rootfile == NULL) {
if (trusted != NULL) {
loglog(RC_LOG_SERIOUS, "dnssec-enable=yes but no dnssec-rootkey-file or trust anchors specified.");
loglog(RC_LOG_SERIOUS, "WARNING: DNSSEC validation disabled");
}
} else {
DBG(DBG_DNS, DBG_log("Loading dnssec root key from:%s", rootfile));
/* the cast is there for unbound < 1.4.12 */
/* ??? ub_ctx_add_ta_autr is not documented to set errno */
errno = 0;
ugh = ub_ctx_add_ta_autr(dns_ctx, (char *) rootfile);
if (ugh != 0) {
int e = errno; /* protect value from ub_strerror */
loglog(RC_LOG_SERIOUS, "error adding dnssec root key: %s [errno: %s]",
ub_strerror(ugh), strerror(e));
loglog(RC_LOG_SERIOUS, "WARNING: DNSSEC validation likely broken!");
}
}
if (trusted == NULL) {
DBG(DBG_DNS,DBG_log("No additional dnssec trust anchors defined via dnssec-trusted= option"));
} else {
glob_t globbuf;
char **fnp;
int r = glob(trusted, GLOB_ERR, globugh_ta, &globbuf);
switch (r) {
case 0: /* success */
for (fnp = globbuf.gl_pathv; fnp != NULL && *fnp != NULL; fnp++) {
ugh = ub_ctx_add_ta_file(dns_ctx, *fnp);
if (ugh != 0) {
loglog(RC_LOG_SERIOUS, "Ignored trusted key file %s: %s",
*fnp, ub_strerror(ugh));
} else {
DBG(DBG_DNS, DBG_log("Added contents of trusted key file %s to unbound resolver context",
*fnp));
}
}
break;
case GLOB_NOSPACE:
loglog(RC_LOG_SERIOUS, "out of space processing dnssec-trusted= argument: %s",
trusted);
break;
case GLOB_ABORTED:
/* already logged by globugh_ta */
break;
case GLOB_NOMATCH:
loglog(RC_LOG_SERIOUS, "no trust anchor files matched '%s'", trusted);
break;
default:
loglog(RC_LOG_SERIOUS, "trusted key file '%s': unknown glob error %d",
trusted, r);
break;
}
globfree(&globbuf);
}
}
int dane_verify_cb(int ok, X509_STORE_CTX *store) {
struct ub_result *dns_result;
struct ub_ctx* ctx;
char dns_name[256];
X509 *cert;
SSL *con;
typedef struct {
int verbose_mode;
int verify_depth;
int always_continue;
} mydata_t;
int mydata_index;
mydata_t *mydata;
int retval, err, depth;
if (b_err == NULL)
b_err=BIO_new_fp(stderr,BIO_NOCLOSE);
cert = X509_STORE_CTX_get_current_cert(store);
err = X509_STORE_CTX_get_error(store);
depth = X509_STORE_CTX_get_error_depth(ctx);
int ssl_idx = SSL_get_ex_data_X509_STORE_CTX_idx();
if (ssl_idx < 0) {
BIO_printf(b_err, "DANE failed to find SSL index: %d\n", ssl_idx);
return -1;
}
con = X509_STORE_CTX_get_ex_data(store, SSL_get_ex_data_X509_STORE_CTX_idx());
mydata = SSL_get_ex_data(con, mydata_index);
int peerfd;
peerfd = SSL_get_fd(con);
socklen_t len;
struct sockaddr_storage addr;
char ipstr[INET6_ADDRSTRLEN];
char node[NI_MAXHOST];
int port;
len = sizeof addr;
getpeername(peerfd, (struct sockaddr*)&addr, &len);
// deal with both IPv4 and IPv6:
if (addr.ss_family == AF_INET) {
struct sockaddr_in *s = (struct sockaddr_in *)&addr;
port = ntohs(s->sin_port);
inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof ipstr);
struct sockaddr_in sa;
sa.sin_family = AF_INET;
inet_pton(AF_INET, ipstr, &sa.sin_addr);
int res = getnameinfo((struct sockaddr*)&sa, sizeof(sa), node, sizeof(node), NULL, 0, 0);
} else { // AF_INET6
struct sockaddr_in6 *s = (struct sockaddr_in6 *)&addr;
port = ntohs(s->sin6_port);
inet_ntop(AF_INET6, &s->sin6_addr, ipstr, sizeof ipstr);
}
BIO_printf(b_err, "Peer IP address: %s\n", ipstr);
BIO_printf(b_err, "Peer port : %d\n", port);
BIO_printf(b_err, "Peer hostname : %s\n", node);
ctx = ub_ctx_create();
if(!ctx) {
printf("error: could not create unbound context\n");
return -1;
}
if( (retval=ub_ctx_resolvconf(ctx, "/etc/resolv.conf")) != 0) {
printf("error reading resolv.conf: %s. errno says: %s\n",
ub_strerror(retval), strerror(errno));
return -1;
}
if( (retval=ub_ctx_hosts(ctx, "/etc/hosts")) != 0) {
printf("error reading hosts: %s. errno says: %s\n",
ub_strerror(retval), strerror(errno));
return -1;
}
retval = sprintf(dns_name, "_%d._tcp.%s", port, node);
if(retval < 0) {
printf("failure to create dns name\n");
return -1;
}
BIO_printf(b_err,"DANE dane_verify_cb() dns name: %s\n", dns_name);
retval = ub_resolve(ctx, dns_name, 65534, 1, &dns_result);
if(retval != 0) {
BIO_printf(b_err, "resolve error: %s\n", ub_strerror(retval));
return -1;
}
if(dns_result->havedata) {
int i;
for (i = 0; dns_result->data[i] != NULL; i++) {
unsigned char usage, selector, matching_type;
unsigned char *tlsa_bytes;
if (dns_result->len[i] < 35) {
// must have at least 1+1+1+32 bytes for the SHA-256 case
BIO_printf(b_err, "DANE: Not enough data: %d available\n",
dns_result->len[i]);
return -1;
}
unsigned char *rdata = (unsigned char *)dns_result->data[i];
usage = (char) *rdata++;
selector = (char) *rdata++;
matching_type = (char) *rdata++;
tlsa_bytes = (unsigned char *) rdata;
X509 *tlsa_cert;
tlsa_cert = d2i_X509(NULL, &tlsa_bytes, dns_result->len[i]-3);
BIO_printf(b_err, "DANE: Usage %d Selector %d Matching Type %d\n",
usage, selector, matching_type);
if (selector != 0)
continue;
if (matching_type != 0)
continue;
if (usage == 0 || usage == 2) {
int retval;
retval = ca_constraint(con, tlsa_cert, usage);
if (retval == 0)
BIO_printf(b_err, "DANE dane_verify_cb() Passed validation for usage %d\n", usage);
else
BIO_printf(b_err, "DANE dane_verify_cb() Failed validation for usage %d\n", usage);
return retval;
}
if (usage == 1) {
int retval;
retval = service_cert_constraint(cert, tlsa_cert);
if (retval == 0)
BIO_printf(b_err, "DANE dane_verify_cb() Passed validation for usage %d\n", usage);
else
BIO_printf(b_err, "DANE dane_verify_cb() Failed validation for usage %d\n", usage);
return retval;
}
}
}
return ok;
}
