/*
* unbound.c - unbound validating resolver public API implementation
*
* Copyright (c) 2007, NLnet Labs. All rights reserved.
*
* This software is open source.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 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.
*
* Neither the name of the NLNET LABS 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 COPYRIGHT HOLDERS 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 COPYRIGHT
* HOLDER 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.
*/

/**
* \file
*
* This file contains functions to resolve DNS queries and
* validate the answers. Synchronously and asynchronously.
*
*/

/* include the public api first, it should be able to stand alone */
#include "libunbound/unbound.h"
#include "libunbound/unbound-event.h"
#include "config.h"
#include <ctype.h>
#include "libunbound/context.h"
#include "libunbound/libworker.h"
#include "util/locks.h"
#include "util/config_file.h"
#include "util/alloc.h"
#include "util/module.h"
#include "util/regional.h"
#include "util/log.h"
#include "util/random.h"
#include "util/net_help.h"
#include "util/tube.h"
#include "util/ub_event.h"
#include "util/edns.h"
#include "services/modstack.h"
#include "services/localzone.h"
#include "services/cache/infra.h"
#include "services/cache/rrset.h"
#include "services/authzone.h"
#include "services/listen_dnsport.h"
#include "sldns/sbuffer.h"
#include "iterator/iter_fwd.h"
#include "iterator/iter_hints.h"
#ifdef HAVE_PTHREAD
#include <signal.h>
#endif
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#ifdef HAVE_TIME_H
#include <time.h>
#endif

#if defined(UB_ON_WINDOWS) && defined (HAVE_WINDOWS_H)
#include <windows.h>
#include <iphlpapi.h>
#endif /* UB_ON_WINDOWS */

/** store that the logfile has a debug override */
int ctx_logfile_overridden = 0;

/** create context functionality, but no pipes */
static struct ub_ctx* ub_ctx_create_nopipe(void)
{
       struct ub_ctx* ctx;
#ifdef USE_WINSOCK
       int r;
       WSADATA wsa_data;
#endif

       checklock_start();
       if(!ctx_logfile_overridden)
               log_init(NULL, 0, NULL); /* logs to stderr */
       log_ident_set("libunbound");
#ifdef USE_WINSOCK
       if((r = WSAStartup(MAKEWORD(2,2), &wsa_data)) != 0) {
               log_err("could not init winsock. WSAStartup: %s",
                       wsa_strerror(r));
               return NULL;
       }
#endif
       verbosity = NO_VERBOSE; /* errors only */
       checklock_start();
       ctx = (struct ub_ctx*)calloc(1, sizeof(*ctx));
       if(!ctx) {
               errno = ENOMEM;
               return NULL;
       }
       alloc_init(&ctx->superalloc, NULL, 0);
       if(!(ctx->seed_rnd = ub_initstate(NULL))) {
               ub_randfree(ctx->seed_rnd);
               free(ctx);
               errno = ENOMEM;
               return NULL;
       }
       lock_basic_init(&ctx->qqpipe_lock);
       lock_basic_init(&ctx->rrpipe_lock);
       lock_basic_init(&ctx->cfglock);
       ctx->env = (struct module_env*)calloc(1, sizeof(*ctx->env));
       if(!ctx->env) {
               ub_randfree(ctx->seed_rnd);
               free(ctx);
               errno = ENOMEM;
               return NULL;
       }
       ctx->env->cfg = config_create_forlib();
       if(!ctx->env->cfg) {
               free(ctx->env);
               ub_randfree(ctx->seed_rnd);
               free(ctx);
               errno = ENOMEM;
               return NULL;
       }
       /* init edns_known_options */
       if(!edns_known_options_init(ctx->env)) {
               config_delete(ctx->env->cfg);
               free(ctx->env);
               ub_randfree(ctx->seed_rnd);
               free(ctx);
               errno = ENOMEM;
               return NULL;
       }
       ctx->env->auth_zones = auth_zones_create();
       if(!ctx->env->auth_zones) {
               edns_known_options_delete(ctx->env);
               config_delete(ctx->env->cfg);
               free(ctx->env);
               ub_randfree(ctx->seed_rnd);
               free(ctx);
               errno = ENOMEM;
               return NULL;
       }
       ctx->env->edns_strings = edns_strings_create();
       if(!ctx->env->edns_strings) {
               auth_zones_delete(ctx->env->auth_zones);
               edns_known_options_delete(ctx->env);
               config_delete(ctx->env->cfg);
               free(ctx->env);
               ub_randfree(ctx->seed_rnd);
               free(ctx);
               errno = ENOMEM;
               return NULL;
       }

       ctx->env->alloc = &ctx->superalloc;
       ctx->env->worker = NULL;
       ctx->env->need_to_validate = 0;
       modstack_init(&ctx->mods);
       ctx->env->modstack = &ctx->mods;
       rbtree_init(&ctx->queries, &context_query_cmp);
       return ctx;
}

struct ub_ctx*
ub_ctx_create(void)
{
       struct ub_ctx* ctx = ub_ctx_create_nopipe();
       if(!ctx)
               return NULL;
       if((ctx->qq_pipe = tube_create()) == NULL) {
               int e = errno;
               ub_randfree(ctx->seed_rnd);
               config_delete(ctx->env->cfg);
               modstack_call_deinit(&ctx->mods, ctx->env);
               modstack_call_destartup(&ctx->mods, ctx->env);
               modstack_free(&ctx->mods);
               listen_desetup_locks();
               edns_known_options_delete(ctx->env);
               edns_strings_delete(ctx->env->edns_strings);
               free(ctx->env);
               free(ctx);
               errno = e;
               return NULL;
       }
       if((ctx->rr_pipe = tube_create()) == NULL) {
               int e = errno;
               tube_delete(ctx->qq_pipe);
               ub_randfree(ctx->seed_rnd);
               config_delete(ctx->env->cfg);
               modstack_call_deinit(&ctx->mods, ctx->env);
               modstack_call_destartup(&ctx->mods, ctx->env);
               modstack_free(&ctx->mods);
               listen_desetup_locks();
               edns_known_options_delete(ctx->env);
               edns_strings_delete(ctx->env->edns_strings);
               free(ctx->env);
               free(ctx);
               errno = e;
               return NULL;
       }
       return ctx;
}

struct ub_ctx*
ub_ctx_create_ub_event(struct ub_event_base* ueb)
{
       struct ub_ctx* ctx = ub_ctx_create_nopipe();
       if(!ctx)
               return NULL;
       /* no pipes, but we have the locks to make sure everything works */
       ctx->created_bg = 0;
       ctx->dothread = 1; /* the processing is in the same process,
               makes ub_cancel and ub_ctx_delete do the right thing */
       ctx->event_base = ueb;
       return ctx;
}

struct ub_ctx*
ub_ctx_create_event(struct event_base* eb)
{
       struct ub_ctx* ctx = ub_ctx_create_nopipe();
       if(!ctx)
               return NULL;
       /* no pipes, but we have the locks to make sure everything works */
       ctx->created_bg = 0;
       ctx->dothread = 1; /* the processing is in the same process,
               makes ub_cancel and ub_ctx_delete do the right thing */
       ctx->event_base = ub_libevent_event_base(eb);
       if (!ctx->event_base) {
               ub_ctx_delete(ctx);
               return NULL;
       }
       ctx->event_base_malloced = 1;
       return ctx;
}

/** delete q */
static void
delq(rbnode_type* n, void* ATTR_UNUSED(arg))
{
       struct ctx_query* q = (struct ctx_query*)n;
       context_query_delete(q);
}

/** stop the bg thread */
static void ub_stop_bg(struct ub_ctx* ctx)
{
       /* stop the bg thread */
       lock_basic_lock(&ctx->cfglock);
       if(ctx->created_bg) {
               uint8_t* msg;
               uint32_t len;
               uint32_t cmd = UB_LIBCMD_QUIT;
               lock_basic_unlock(&ctx->cfglock);
               lock_basic_lock(&ctx->qqpipe_lock);
               (void)tube_write_msg(ctx->qq_pipe, (uint8_t*)&cmd,
                       (uint32_t)sizeof(cmd), 0);
               lock_basic_unlock(&ctx->qqpipe_lock);
               lock_basic_lock(&ctx->rrpipe_lock);
               while(tube_read_msg(ctx->rr_pipe, &msg, &len, 0)) {
                       /* discard all results except a quit confirm */
                       if(context_serial_getcmd(msg, len) == UB_LIBCMD_QUIT) {
                               free(msg);
                               break;
                       }
                       free(msg);
               }
               lock_basic_unlock(&ctx->rrpipe_lock);

               /* if bg worker is a thread, wait for it to exit, so that all
                * resources are really gone. */
               lock_basic_lock(&ctx->cfglock);
               if(ctx->dothread) {
                       lock_basic_unlock(&ctx->cfglock);
                       ub_thread_join(ctx->bg_tid);
               } else {
                       lock_basic_unlock(&ctx->cfglock);
#ifndef UB_ON_WINDOWS
                       if(waitpid(ctx->bg_pid, NULL, 0) == -1) {
                               if(verbosity > 2)
                                       log_err("waitpid: %s", strerror(errno));
                       }
#endif
               }
       }
       else {
               lock_basic_unlock(&ctx->cfglock);
       }
}

void
ub_ctx_delete(struct ub_ctx* ctx)
{
       struct alloc_cache* a, *na;
       int do_stop = 1;
       if(!ctx) return;

       /* if the delete is called but it has forked, and before the fork
        * the context was finalized, then the bg worker is not stopped
        * from here. There is one worker, but two contexts that refer to
        * it and only one should clean up, the one with getpid == pipe_pid.*/
       if(ctx->created_bg && ctx->pipe_pid != getpid()) {
               do_stop = 0;
#ifndef USE_WINSOCK
               /* Stop events from getting deregistered, if the backend is
                * epoll, the epoll fd is the same as the other process.
                * That process should deregister them. */
               if(ctx->qq_pipe->listen_com)
                       ctx->qq_pipe->listen_com->event_added = 0;
               if(ctx->qq_pipe->res_com)
                       ctx->qq_pipe->res_com->event_added = 0;
               if(ctx->rr_pipe->listen_com)
                       ctx->rr_pipe->listen_com->event_added = 0;
               if(ctx->rr_pipe->res_com)
                       ctx->rr_pipe->res_com->event_added = 0;
#endif
       }
       /* see if bg thread is created and if threads have been killed */
       /* no locks, because those may be held by terminated threads */
       /* for processes the read pipe is closed and we see that on read */
#ifdef HAVE_PTHREAD
       if(ctx->created_bg && ctx->dothread && do_stop) {
               if(pthread_kill(ctx->bg_tid, 0) == ESRCH) {
                       /* thread has been killed */
                       do_stop = 0;
               }
       }
#endif /* HAVE_PTHREAD */
       if(do_stop)
               ub_stop_bg(ctx);
       if(ctx->created_bg && ctx->pipe_pid != getpid() && ctx->thread_worker) {
               /* This delete is happening from a different process. Delete
                * the thread worker from this process memory space. The
                * thread is not there to do so, so it is freed here. */
               struct ub_event_base* evbase = comm_base_internal(
                       ctx->thread_worker->base);
               libworker_delete_event(ctx->thread_worker);
               ctx->thread_worker = NULL;
#ifdef USE_MINI_EVENT
               ub_event_base_free(evbase);
#else
               /* cannot event_base_free, because the epoll_fd cleanup
                * in libevent could stop the original event_base in the
                * other process from working. */
               free(evbase);
#endif
       }
       libworker_delete_event(ctx->event_worker);

       modstack_call_deinit(&ctx->mods, ctx->env);
       modstack_call_destartup(&ctx->mods, ctx->env);
       modstack_free(&ctx->mods);
       a = ctx->alloc_list;
       while(a) {
               na = a->super;
               a->super = &ctx->superalloc;
               alloc_clear(a);
               free(a);
               a = na;
       }
       local_zones_delete(ctx->local_zones);
       lock_basic_destroy(&ctx->qqpipe_lock);
       lock_basic_destroy(&ctx->rrpipe_lock);
       lock_basic_destroy(&ctx->cfglock);
       tube_delete(ctx->qq_pipe);
       tube_delete(ctx->rr_pipe);
       if(ctx->env) {
               slabhash_delete(ctx->env->msg_cache);
               rrset_cache_delete(ctx->env->rrset_cache);
               infra_delete(ctx->env->infra_cache);
               config_delete(ctx->env->cfg);
               edns_known_options_delete(ctx->env);
               edns_strings_delete(ctx->env->edns_strings);
               forwards_delete(ctx->env->fwds);
               hints_delete(ctx->env->hints);
               auth_zones_delete(ctx->env->auth_zones);
               free(ctx->env);
       }
       ub_randfree(ctx->seed_rnd);
       alloc_clear(&ctx->superalloc);
       listen_desetup_locks();
       traverse_postorder(&ctx->queries, delq, NULL);
       if(ctx_logfile_overridden) {
               log_file(NULL);
               ctx_logfile_overridden = 0;
       }
       if(ctx->event_base_malloced)
               free(ctx->event_base);
       free(ctx);
#ifdef USE_WINSOCK
       WSACleanup();
#endif
}

int
ub_ctx_set_option(struct ub_ctx* ctx, const char* opt, const char* val)
{
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_AFTERFINAL;
       }
       if(!config_set_option(ctx->env->cfg, opt, val)) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_SYNTAX;
       }
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_ctx_get_option(struct ub_ctx* ctx, const char* opt, char** str)
{
       int r;
       lock_basic_lock(&ctx->cfglock);
       r = config_get_option_collate(ctx->env->cfg, opt, str);
       lock_basic_unlock(&ctx->cfglock);
       if(r == 0) r = UB_NOERROR;
       else if(r == 1) r = UB_SYNTAX;
       else if(r == 2) r = UB_NOMEM;
       return r;
}

int
ub_ctx_config(struct ub_ctx* ctx, const char* fname)
{
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_AFTERFINAL;
       }
       if(!config_read(ctx->env->cfg, fname, NULL)) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_SYNTAX;
       }
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_ctx_add_ta(struct ub_ctx* ctx, const char* ta)
{
       char* dup = strdup(ta);
       if(!dup) return UB_NOMEM;
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               free(dup);
               return UB_AFTERFINAL;
       }
       if(!cfg_strlist_insert(&ctx->env->cfg->trust_anchor_list, dup)) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOMEM;
       }
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_ctx_add_ta_file(struct ub_ctx* ctx, const char* fname)
{
       char* dup = strdup(fname);
       if(!dup) return UB_NOMEM;
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               free(dup);
               return UB_AFTERFINAL;
       }
       if(!cfg_strlist_insert(&ctx->env->cfg->trust_anchor_file_list, dup)) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOMEM;
       }
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int ub_ctx_add_ta_autr(struct ub_ctx* ctx, const char* fname)
{
       char* dup = strdup(fname);
       if(!dup) return UB_NOMEM;
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               free(dup);
               return UB_AFTERFINAL;
       }
       if(!cfg_strlist_insert(&ctx->env->cfg->auto_trust_anchor_file_list,
               dup)) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOMEM;
       }
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_ctx_trustedkeys(struct ub_ctx* ctx, const char* fname)
{
       char* dup = strdup(fname);
       if(!dup) return UB_NOMEM;
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               free(dup);
               return UB_AFTERFINAL;
       }
       if(!cfg_strlist_insert(&ctx->env->cfg->trusted_keys_file_list, dup)) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOMEM;
       }
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_ctx_debuglevel(struct ub_ctx* ctx, int d)
{
       lock_basic_lock(&ctx->cfglock);
       verbosity = d;
       ctx->env->cfg->verbosity = d;
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int ub_ctx_debugout(struct ub_ctx* ctx, void* out)
{
       lock_basic_lock(&ctx->cfglock);
       log_file((FILE*)out);
       ctx_logfile_overridden = 1;
       ctx->logfile_override = 1;
       ctx->log_out = out;
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_ctx_async(struct ub_ctx* ctx, int dothread)
{
#ifdef THREADS_DISABLED
       if(dothread) /* cannot do threading */
               return UB_NOERROR;
#endif
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               return UB_AFTERFINAL;
       }
       ctx->dothread = dothread;
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_poll(struct ub_ctx* ctx)
{
       /* no need to hold lock while testing for readability. */
       return tube_poll(ctx->rr_pipe);
}

int
ub_fd(struct ub_ctx* ctx)
{
       return tube_read_fd(ctx->rr_pipe);
}

/** process answer from bg worker */
static int
process_answer_detail(struct ub_ctx* ctx, uint8_t* msg, uint32_t len,
       ub_callback_type* cb, void** cbarg, int* err,
       struct ub_result** res)
{
       struct ctx_query* q;
       if(context_serial_getcmd(msg, len) != UB_LIBCMD_ANSWER) {
               log_err("error: bad data from bg worker %d",
                       (int)context_serial_getcmd(msg, len));
               return 0;
       }

       lock_basic_lock(&ctx->cfglock);
       q = context_deserialize_answer(ctx, msg, len, err);
       if(!q) {
               lock_basic_unlock(&ctx->cfglock);
               /* probably simply the lookup that failed, i.e.
                * response returned before cancel was sent out, so noerror */
               return 1;
       }
       log_assert(q->async);

       /* grab cb while locked */
       if(q->cancelled) {
               *cb = NULL;
               *cbarg = NULL;
       } else {
               *cb = q->cb;
               *cbarg = q->cb_arg;
       }
       if(*err) {
               *res = NULL;
               ub_resolve_free(q->res);
       } else {
               /* parse the message, extract rcode, fill result */
               sldns_buffer* buf = sldns_buffer_new(q->msg_len);
               struct regional* region = regional_create();
               *res = q->res;
               (*res)->rcode = LDNS_RCODE_SERVFAIL;
               if(region && buf) {
                       sldns_buffer_clear(buf);
                       sldns_buffer_write(buf, q->msg, q->msg_len);
                       sldns_buffer_flip(buf);
                       libworker_enter_result(*res, buf, region,
                               q->msg_security);
               }
               (*res)->answer_packet = q->msg;
               (*res)->answer_len = (int)q->msg_len;
               q->msg = NULL;
               sldns_buffer_free(buf);
               regional_destroy(region);
       }
       q->res = NULL;
       /* delete the q from list */
       (void)rbtree_delete(&ctx->queries, q->node.key);
       ctx->num_async--;
       context_query_delete(q);
       lock_basic_unlock(&ctx->cfglock);

       if(*cb) return 2;
       ub_resolve_free(*res);
       return 1;
}

/** process answer from bg worker */
static int
process_answer(struct ub_ctx* ctx, uint8_t* msg, uint32_t len)
{
       int err;
       ub_callback_type cb;
       void* cbarg;
       struct ub_result* res;
       int r;

       r = process_answer_detail(ctx, msg, len, &cb, &cbarg, &err, &res);

       /* no locks held while calling callback, so that library is
        * re-entrant. */
       if(r == 2)
               (*cb)(cbarg, err, res);

       return r;
}

int
ub_process(struct ub_ctx* ctx)
{
       int r;
       uint8_t* msg;
       uint32_t len;
       while(1) {
               msg = NULL;
               lock_basic_lock(&ctx->rrpipe_lock);
               r = tube_read_msg(ctx->rr_pipe, &msg, &len, 1);
               lock_basic_unlock(&ctx->rrpipe_lock);
               if(r == 0)
                       return UB_PIPE;
               else if(r == -1)
                       break;
               if(!process_answer(ctx, msg, len)) {
                       free(msg);
                       return UB_PIPE;
               }
               free(msg);
       }
       return UB_NOERROR;
}

int
ub_wait(struct ub_ctx* ctx)
{
       int err;
       ub_callback_type cb;
       void* cbarg;
       struct ub_result* res;
       int r;
       uint8_t* msg;
       uint32_t len;
       /* this is basically the same loop as _process(), but with changes.
        * holds the rrpipe lock and waits with tube_wait */
       while(1) {
               lock_basic_lock(&ctx->rrpipe_lock);
               lock_basic_lock(&ctx->cfglock);
               if(ctx->num_async == 0) {
                       lock_basic_unlock(&ctx->cfglock);
                       lock_basic_unlock(&ctx->rrpipe_lock);
                       break;
               }
               lock_basic_unlock(&ctx->cfglock);

               /* keep rrpipe locked, while
                *      o waiting for pipe readable
                *      o parsing message
                *      o possibly decrementing num_async
                * do callback without lock
                */
               r = tube_wait(ctx->rr_pipe);
               if(r) {
                       r = tube_read_msg(ctx->rr_pipe, &msg, &len, 1);
                       if(r == 0) {
                               lock_basic_unlock(&ctx->rrpipe_lock);
                               return UB_PIPE;
                       }
                       if(r == -1) {
                               lock_basic_unlock(&ctx->rrpipe_lock);
                               continue;
                       }
                       r = process_answer_detail(ctx, msg, len,
                               &cb, &cbarg, &err, &res);
                       lock_basic_unlock(&ctx->rrpipe_lock);
                       free(msg);
                       if(r == 0)
                               return UB_PIPE;
                       if(r == 2)
                               (*cb)(cbarg, err, res);
               } else {
                       lock_basic_unlock(&ctx->rrpipe_lock);
               }
       }
       return UB_NOERROR;
}

int
ub_resolve(struct ub_ctx* ctx, const char* name, int rrtype,
       int rrclass, struct ub_result** result)
{
       struct ctx_query* q;
       int r;
       *result = NULL;

       lock_basic_lock(&ctx->cfglock);
       if(!ctx->finalized) {
               r = context_finalize(ctx);
               if(r) {
                       lock_basic_unlock(&ctx->cfglock);
                       return r;
               }
       }
       /* create new ctx_query and attempt to add to the list */
       lock_basic_unlock(&ctx->cfglock);
       q = context_new(ctx, name, rrtype, rrclass, NULL, NULL, NULL);
       if(!q)
               return UB_NOMEM;
       /* become a resolver thread for a bit */

       r = libworker_fg(ctx, q);
       if(r) {
               lock_basic_lock(&ctx->cfglock);
               (void)rbtree_delete(&ctx->queries, q->node.key);
               context_query_delete(q);
               lock_basic_unlock(&ctx->cfglock);
               return r;
       }
       q->res->answer_packet = q->msg;
       q->res->answer_len = (int)q->msg_len;
       q->msg = NULL;
       *result = q->res;
       q->res = NULL;

       lock_basic_lock(&ctx->cfglock);
       (void)rbtree_delete(&ctx->queries, q->node.key);
       context_query_delete(q);
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_resolve_event(struct ub_ctx* ctx, const char* name, int rrtype,
       int rrclass, void* mydata, ub_event_callback_type callback,
       int* async_id)
{
       struct ctx_query* q;
       int r;

       if(async_id)
               *async_id = 0;
       lock_basic_lock(&ctx->cfglock);
       if(!ctx->finalized) {
               r = context_finalize(ctx);
               if(r) {
                       lock_basic_unlock(&ctx->cfglock);
                       return r;
               }
       }
       lock_basic_unlock(&ctx->cfglock);
       if(!ctx->event_worker) {
               ctx->event_worker = libworker_create_event(ctx,
                       ctx->event_base);
               if(!ctx->event_worker) {
                       return UB_INITFAIL;
               }
       }

       /* set time in case answer comes from cache */
       ub_comm_base_now(ctx->event_worker->base);

       /* create new ctx_query and attempt to add to the list */
       q = context_new(ctx, name, rrtype, rrclass, NULL, callback, mydata);
       if(!q)
               return UB_NOMEM;

       /* attach to mesh */
       if((r=libworker_attach_mesh(ctx, q, async_id)) != 0)
               return r;
       return UB_NOERROR;
}


int
ub_resolve_async(struct ub_ctx* ctx, const char* name, int rrtype,
       int rrclass, void* mydata, ub_callback_type callback, int* async_id)
{
       struct ctx_query* q;
       uint8_t* msg = NULL;
       uint32_t len = 0;

       if(async_id)
               *async_id = 0;
       lock_basic_lock(&ctx->cfglock);
       if(!ctx->finalized) {
               int r = context_finalize(ctx);
               if(r) {
                       lock_basic_unlock(&ctx->cfglock);
                       return r;
               }
       }
       if(!ctx->created_bg) {
               int r;
               ctx->created_bg = 1;
               lock_basic_unlock(&ctx->cfglock);
               r = libworker_bg(ctx);
               if(r) {
                       lock_basic_lock(&ctx->cfglock);
                       ctx->created_bg = 0;
                       lock_basic_unlock(&ctx->cfglock);
                       return r;
               }
       } else {
               lock_basic_unlock(&ctx->cfglock);
       }

       /* create new ctx_query and attempt to add to the list */
       q = context_new(ctx, name, rrtype, rrclass, callback, NULL, mydata);
       if(!q)
               return UB_NOMEM;

       /* write over pipe to background worker */
       lock_basic_lock(&ctx->cfglock);
       msg = context_serialize_new_query(q, &len);
       if(!msg) {
               (void)rbtree_delete(&ctx->queries, q->node.key);
               ctx->num_async--;
               context_query_delete(q);
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOMEM;
       }
       if(async_id)
               *async_id = q->querynum;
       lock_basic_unlock(&ctx->cfglock);

       lock_basic_lock(&ctx->qqpipe_lock);
       if(!tube_write_msg(ctx->qq_pipe, msg, len, 0)) {
               lock_basic_unlock(&ctx->qqpipe_lock);
               free(msg);
               return UB_PIPE;
       }
       lock_basic_unlock(&ctx->qqpipe_lock);
       free(msg);
       return UB_NOERROR;
}

int
ub_cancel(struct ub_ctx* ctx, int async_id)
{
       struct ctx_query* q;
       uint8_t* msg = NULL;
       uint32_t len = 0;
       lock_basic_lock(&ctx->cfglock);
       q = (struct ctx_query*)rbtree_search(&ctx->queries, &async_id);
       if(!q || !q->async) {
               /* it is not there, so nothing to do */
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOID;
       }
       log_assert(q->async);
       q->cancelled = 1;

       /* delete it */
       if(!ctx->dothread) { /* if forked */
               (void)rbtree_delete(&ctx->queries, q->node.key);
               ctx->num_async--;
               msg = context_serialize_cancel(q, &len);
               context_query_delete(q);
               lock_basic_unlock(&ctx->cfglock);
               if(!msg) {
                       return UB_NOMEM;
               }
               /* send cancel to background worker */
               lock_basic_lock(&ctx->qqpipe_lock);
               if(!tube_write_msg(ctx->qq_pipe, msg, len, 0)) {
                       lock_basic_unlock(&ctx->qqpipe_lock);
                       free(msg);
                       return UB_PIPE;
               }
               lock_basic_unlock(&ctx->qqpipe_lock);
               free(msg);
       } else {
               lock_basic_unlock(&ctx->cfglock);
       }
       return UB_NOERROR;
}

void
ub_resolve_free(struct ub_result* result)
{
       char** p;
       if(!result) return;
       free(result->qname);
       if(result->canonname != result->qname)
               free(result->canonname);
       if(result->data)
               for(p = result->data; *p; p++)
                       free(*p);
       free(result->data);
       free(result->len);
       free(result->answer_packet);
       free(result->why_bogus);
       free(result);
}

const char*
ub_strerror(int err)
{
       switch(err) {
               case UB_NOERROR: return "no error";
               case UB_SOCKET: return "socket io error";
               case UB_NOMEM: return "out of memory";
               case UB_SYNTAX: return "syntax error";
               case UB_SERVFAIL: return "server failure";
               case UB_FORKFAIL: return "could not fork";
               case UB_INITFAIL: return "initialization failure";
               case UB_AFTERFINAL: return "setting change after finalize";
               case UB_PIPE: return "error in pipe communication with async";
               case UB_READFILE: return "error reading file";
               case UB_NOID: return "error async_id does not exist";
               default: return "unknown error";
       }
}

int
ub_ctx_set_fwd(struct ub_ctx* ctx, const char* addr)
{
       struct sockaddr_storage storage;
       socklen_t stlen;
       struct config_stub* s;
       char* dupl;
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               errno=EINVAL;
               return UB_AFTERFINAL;
       }
       if(!addr) {
               /* disable fwd mode - the root stub should be first. */
               if(ctx->env->cfg->forwards &&
                       (ctx->env->cfg->forwards->name &&
                       strcmp(ctx->env->cfg->forwards->name, ".") == 0)) {
                       s = ctx->env->cfg->forwards;
                       ctx->env->cfg->forwards = s->next;
                       s->next = NULL;
                       config_delstubs(s);
               }
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOERROR;
       }
       lock_basic_unlock(&ctx->cfglock);

       /* check syntax for addr */
       if(!extstrtoaddr(addr, &storage, &stlen, UNBOUND_DNS_PORT)) {
               errno=EINVAL;
               return UB_SYNTAX;
       }

       /* it parses, add root stub in front of list */
       lock_basic_lock(&ctx->cfglock);
       if(!ctx->env->cfg->forwards ||
               (ctx->env->cfg->forwards->name &&
               strcmp(ctx->env->cfg->forwards->name, ".") != 0)) {
               s = calloc(1, sizeof(*s));
               if(!s) {
                       lock_basic_unlock(&ctx->cfglock);
                       errno=ENOMEM;
                       return UB_NOMEM;
               }
               s->name = strdup(".");
               if(!s->name) {
                       free(s);
                       lock_basic_unlock(&ctx->cfglock);
                       errno=ENOMEM;
                       return UB_NOMEM;
               }
               s->next = ctx->env->cfg->forwards;
               ctx->env->cfg->forwards = s;
       } else {
               log_assert(ctx->env->cfg->forwards);
               log_assert(ctx->env->cfg->forwards->name);
               s = ctx->env->cfg->forwards;
       }
       dupl = strdup(addr);
       if(!dupl) {
               lock_basic_unlock(&ctx->cfglock);
               errno=ENOMEM;
               return UB_NOMEM;
       }
       if(!cfg_strlist_insert(&s->addrs, dupl)) {
               lock_basic_unlock(&ctx->cfglock);
               errno=ENOMEM;
               return UB_NOMEM;
       }
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int ub_ctx_set_tls(struct ub_ctx* ctx, int tls)
{
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               errno=EINVAL;
               return UB_AFTERFINAL;
       }
       ctx->env->cfg->ssl_upstream = tls;
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int ub_ctx_set_stub(struct ub_ctx* ctx, const char* zone, const char* addr,
       int isprime)
{
       char* a;
       struct config_stub **prev, *elem;

       /* check syntax for zone name */
       if(zone) {
               uint8_t* nm;
               int nmlabs;
               size_t nmlen;
               if(!parse_dname(zone, &nm, &nmlen, &nmlabs)) {
                       errno=EINVAL;
                       return UB_SYNTAX;
               }
               free(nm);
       } else {
               zone = ".";
       }

       /* check syntax for addr (if not NULL) */
       if(addr) {
               struct sockaddr_storage storage;
               socklen_t stlen;
               if(!extstrtoaddr(addr, &storage, &stlen, UNBOUND_DNS_PORT)) {
                       errno=EINVAL;
                       return UB_SYNTAX;
               }
       }

       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               errno=EINVAL;
               return UB_AFTERFINAL;
       }

       /* arguments all right, now find or add the stub */
       prev = &ctx->env->cfg->stubs;
       elem = cfg_stub_find(&prev, zone);
       if(!elem && !addr) {
               /* not found and we want to delete, nothing to do */
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOERROR;
       } else if(elem && !addr) {
               /* found, and we want to delete */
               *prev = elem->next;
               config_delstub(elem);
               lock_basic_unlock(&ctx->cfglock);
               return UB_NOERROR;
       } else if(!elem) {
               /* not found, create the stub entry */
               elem=(struct config_stub*)calloc(1, sizeof(struct config_stub));
               if(elem) elem->name = strdup(zone);
               if(!elem || !elem->name) {
                       free(elem);
                       lock_basic_unlock(&ctx->cfglock);
                       errno = ENOMEM;
                       return UB_NOMEM;
               }
               elem->next = ctx->env->cfg->stubs;
               ctx->env->cfg->stubs = elem;
       }

       /* add the address to the list and set settings */
       elem->isprime = isprime;
       a = strdup(addr);
       if(!a) {
               lock_basic_unlock(&ctx->cfglock);
               errno = ENOMEM;
               return UB_NOMEM;
       }
       if(!cfg_strlist_insert(&elem->addrs, a)) {
               lock_basic_unlock(&ctx->cfglock);
               errno = ENOMEM;
               return UB_NOMEM;
       }
       lock_basic_unlock(&ctx->cfglock);
       return UB_NOERROR;
}

int
ub_ctx_resolvconf(struct ub_ctx* ctx, const char* fname)
{
       FILE* in;
       int numserv = 0;
       char buf[1024];
       char* parse, *addr;
       int r;

       if(fname == NULL) {
#if !defined(UB_ON_WINDOWS) || !defined(HAVE_WINDOWS_H)
               fname = "/etc/resolv.conf";
#else
               FIXED_INFO *info;
               ULONG buflen = sizeof(*info);
               IP_ADDR_STRING *ptr;

               info = (FIXED_INFO *) malloc(sizeof (FIXED_INFO));
               if (info == NULL)
                       return UB_READFILE;

               if (GetNetworkParams(info, &buflen) == ERROR_BUFFER_OVERFLOW) {
                       free(info);
                       info = (FIXED_INFO *) malloc(buflen);
                       if (info == NULL)
                               return UB_READFILE;
               }

               if (GetNetworkParams(info, &buflen) == NO_ERROR) {
                       int retval=0;
                       ptr = &(info->DnsServerList);
                       while (ptr) {
                               numserv++;
                               if((retval=ub_ctx_set_fwd(ctx,
                                       ptr->IpAddress.String))!=0) {
                                       free(info);
                                       return retval;
                               }
                               ptr = ptr->Next;
                       }
                       free(info);
                       if (numserv==0)
                               return UB_READFILE;
                       return UB_NOERROR;
               }
               free(info);
               return UB_READFILE;
#endif /* WINDOWS */
       }
       in = fopen(fname, "r");
       if(!in) {
               /* error in errno! perror(fname) */
               return UB_READFILE;
       }
       while(fgets(buf, (int)sizeof(buf), in)) {
               buf[sizeof(buf)-1] = 0;
               parse=buf;
               while(*parse == ' ' || *parse == '\t')
                       parse++;
               if(strncmp(parse, "nameserver", 10) == 0) {
                       numserv++;
                       parse += 10; /* skip 'nameserver' */
                       /* skip whitespace */
                       while(*parse == ' ' || *parse == '\t')
                               parse++;
                       addr = parse;
                       /* skip [0-9a-fA-F.:]*, i.e. IP4 and IP6 address */
                       while(isxdigit((unsigned char)*parse) || *parse=='.' || *parse==':')
                               parse++;
                       /* terminate after the address, remove newline */
                       *parse = 0;

                       if((r = ub_ctx_set_fwd(ctx, addr)) != UB_NOERROR) {
                               fclose(in);
                               return r;
                       }
               }
       }
       fclose(in);
       if(numserv == 0) {
               /* from resolv.conf(5) if none given, use localhost */
               return ub_ctx_set_fwd(ctx, "127.0.0.1");
       }
       return UB_NOERROR;
}

int
ub_ctx_hosts(struct ub_ctx* ctx, const char* fname)
{
       FILE* in;
       char buf[1024], ldata[2048];
       char* parse, *addr, *name, *ins;
       lock_basic_lock(&ctx->cfglock);
       if(ctx->finalized) {
               lock_basic_unlock(&ctx->cfglock);
               errno=EINVAL;
               return UB_AFTERFINAL;
       }
       lock_basic_unlock(&ctx->cfglock);
       if(fname == NULL) {
#if defined(UB_ON_WINDOWS) && defined(HAVE_WINDOWS_H)
               /*
                * If this is Windows NT/XP/2K it's in
                * %WINDIR%\system32\drivers\etc\hosts.
                * If this is Windows 95/98/Me it's in %WINDIR%\hosts.
                */
               name = getenv("WINDIR");
               if (name != NULL) {
                       int retval=0;
                       snprintf(buf, sizeof(buf), "%s%s", name,
                               "\\system32\\drivers\\etc\\hosts");
                       if((retval=ub_ctx_hosts(ctx, buf)) !=0 ) {
                               snprintf(buf, sizeof(buf), "%s%s", name,
                                       "\\hosts");
                               retval=ub_ctx_hosts(ctx, buf);
                       }
                       return retval;
               }
               return UB_READFILE;
#else
               fname = "/etc/hosts";
#endif /* WIN32 */
       }
       in = fopen(fname, "r");
       if(!in) {
               /* error in errno! perror(fname) */
               return UB_READFILE;
       }
       while(fgets(buf, (int)sizeof(buf), in)) {
               buf[sizeof(buf)-1] = 0;
               parse=buf;
               while(*parse == ' ' || *parse == '\t')
                       parse++;
               if(*parse == '#')
                       continue; /* skip comment */
               /* format: <addr> spaces <name> spaces <name> ... */
               addr = parse;
               /* skip addr */
               while(isxdigit((unsigned char)*parse) || *parse == '.' || *parse == ':')
                       parse++;
               if(*parse == '\r')
                       parse++;
               if(*parse == '\n' || *parse == 0)
                       continue;
               if(*parse == '%')
                       continue; /* ignore macOSX fe80::1%lo0 localhost */
               if(*parse != ' ' && *parse != '\t') {
                       /* must have whitespace after address */
                       fclose(in);
                       errno=EINVAL;
                       return UB_SYNTAX;
               }
               *parse++ = 0; /* end delimiter for addr ... */
               /* go to names and add them */
               while(*parse) {
                       while(*parse == ' ' || *parse == '\t' || *parse=='\n'
                               || *parse=='\r')
                               parse++;
                       if(*parse == 0 || *parse == '#')
                               break;
                       /* skip name, allows (too) many printable characters */
                       name = parse;
                       while('!' <= *parse && *parse <= '~')
                               parse++;
                       if(*parse)
                               *parse++ = 0; /* end delimiter for name */
                       snprintf(ldata, sizeof(ldata), "%s %s %s",
                               name, str_is_ip6(addr)?"AAAA":"A", addr);
                       ins = strdup(ldata);
                       if(!ins) {
                               /* out of memory */
                               fclose(in);
                               errno=ENOMEM;
                               return UB_NOMEM;
                       }
                       lock_basic_lock(&ctx->cfglock);
                       if(!cfg_strlist_insert(&ctx->env->cfg->local_data,
                               ins)) {
                               lock_basic_unlock(&ctx->cfglock);
                               fclose(in);
                               errno=ENOMEM;
                               return UB_NOMEM;
                       }
                       lock_basic_unlock(&ctx->cfglock);
               }
       }
       fclose(in);
       return UB_NOERROR;
}

/** finalize the context, if not already finalized */
static int ub_ctx_finalize(struct ub_ctx* ctx)
{
       int res = 0;
       lock_basic_lock(&ctx->cfglock);
       if (!ctx->finalized) {
               res = context_finalize(ctx);
       }
       lock_basic_unlock(&ctx->cfglock);
       return res;
}

/* Print local zones and RR data */
int ub_ctx_print_local_zones(struct ub_ctx* ctx)
{
       int res = ub_ctx_finalize(ctx);
       if (res) return res;

       local_zones_print(ctx->local_zones);

       return UB_NOERROR;
}

/* Add a new zone */
int ub_ctx_zone_add(struct ub_ctx* ctx, const char *zone_name,
       const char *zone_type)
{
       enum localzone_type t;
       struct local_zone* z;
       uint8_t* nm;
       int nmlabs;
       size_t nmlen;

       int res = ub_ctx_finalize(ctx);
       if (res) return res;

       if(!local_zone_str2type(zone_type, &t)) {
               return UB_SYNTAX;
       }

       if(!parse_dname(zone_name, &nm, &nmlen, &nmlabs)) {
               return UB_SYNTAX;
       }

       lock_rw_wrlock(&ctx->local_zones->lock);
       if((z=local_zones_find(ctx->local_zones, nm, nmlen, nmlabs,
               LDNS_RR_CLASS_IN))) {
               /* already present in tree */
               lock_rw_wrlock(&z->lock);
               z->type = t; /* update type anyway */
               lock_rw_unlock(&z->lock);
               lock_rw_unlock(&ctx->local_zones->lock);
               free(nm);
               return UB_NOERROR;
       }
       if(!local_zones_add_zone(ctx->local_zones, nm, nmlen, nmlabs,
               LDNS_RR_CLASS_IN, t)) {
               lock_rw_unlock(&ctx->local_zones->lock);
               return UB_NOMEM;
       }
       lock_rw_unlock(&ctx->local_zones->lock);
       return UB_NOERROR;
}

/* Remove zone */
int ub_ctx_zone_remove(struct ub_ctx* ctx, const char *zone_name)
{
       struct local_zone* z;
       uint8_t* nm;
       int nmlabs;
       size_t nmlen;

       int res = ub_ctx_finalize(ctx);
       if (res) return res;

       if(!parse_dname(zone_name, &nm, &nmlen, &nmlabs)) {
               return UB_SYNTAX;
       }

       lock_rw_wrlock(&ctx->local_zones->lock);
       if((z=local_zones_find(ctx->local_zones, nm, nmlen, nmlabs,
               LDNS_RR_CLASS_IN))) {
               /* present in tree */
               local_zones_del_zone(ctx->local_zones, z);
       }
       lock_rw_unlock(&ctx->local_zones->lock);
       free(nm);
       return UB_NOERROR;
}

/* Add new RR data */
int ub_ctx_data_add(struct ub_ctx* ctx, const char *data)
{
       int res = ub_ctx_finalize(ctx);
       if (res) return res;

       res = local_zones_add_RR(ctx->local_zones, data);
       return (!res) ? UB_NOMEM : UB_NOERROR;
}

/* Remove RR data */
int ub_ctx_data_remove(struct ub_ctx* ctx, const char *data)
{
       uint8_t* nm;
       int nmlabs;
       size_t nmlen;
       int res = ub_ctx_finalize(ctx);
       if (res) return res;

       if(!parse_dname(data, &nm, &nmlen, &nmlabs))
               return UB_SYNTAX;

       local_zones_del_data(ctx->local_zones, nm, nmlen, nmlabs,
               LDNS_RR_CLASS_IN);

       free(nm);
       return UB_NOERROR;
}

const char* ub_version(void)
{
       return PACKAGE_VERSION;
}

int
ub_ctx_set_event(struct ub_ctx* ctx, struct event_base* base) {
       struct ub_event_base* new_base;

       if (!ctx || !ctx->event_base || !base) {
               return UB_INITFAIL;
       }
       if (ub_libevent_get_event_base(ctx->event_base) == base) {
               /* already set */
               return UB_NOERROR;
       }

       lock_basic_lock(&ctx->cfglock);
       /* destroy the current worker - safe to pass in NULL */
       libworker_delete_event(ctx->event_worker);
       ctx->event_worker = NULL;
       new_base = ub_libevent_event_base(base);
       if (new_base)
               ctx->event_base = new_base;
       ctx->created_bg = 0;
       ctx->dothread = 1;
       lock_basic_unlock(&ctx->cfglock);
       return new_base ? UB_NOERROR : UB_INITFAIL;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.