#include <config.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <limits.h>

#ifdef HAVE_LOCALE_H

#include <locale.h>

#endif

#ifdef WITH_IDN

#include <idn/result.h>

#include <idn/log.h>

#include <idn/resconf.h>

#include <idn/api.h>

#endif

#include <dns/byaddr.h>

#ifdef DIG_SIGCHASE

#include <dns/callbacks.h>

#include <dns/dnssec.h>

#include <dns/ds.h>

#include <dns/master.h>

#include <dns/nsec.h>

#include <isc/random.h>

#include <ctype.h>

#endif

#include <dns/fixedname.h>

#include <dns/log.h>

#include <dns/message.h>

#include <dns/name.h>

#include <dns/rcode.h>

#include <dns/rdata.h>

#include <dns/rdataclass.h>

#include <dns/rdatalist.h>

#include <dns/rdataset.h>

#include <dns/rdatastruct.h>

#include <dns/rdatatype.h>

#include <dns/result.h>

#include <dns/tsig.h>

#include <dst/dst.h>

#include <dst/result.h>

#include <isc/app.h>

#include <isc/base64.h>

#include <isc/entropy.h>

#include <isc/file.h>

#include <isc/hex.h>

#include <isc/lang.h>

#include <isc/log.h>

#include <isc/netaddr.h>

#include <isc/netdb.h>

#include <isc/parseint.h>

#include <isc/print.h>

#include <isc/random.h>

#include <isc/result.h>

#include <isc/safe.h>

#include <isc/serial.h>

#include <isc/sockaddr.h>

#include <isc/string.h>

#include <isc/task.h>

#include <isc/timer.h>

#include <isc/types.h>

#include <isc/util.h>

#include <pk11/site.h>

#include <isccfg/namedconf.h>

#include <lwres/lwres.h>

#include <lwres/net.h>

#include <bind9/getaddresses.h>

#include <dig/dig.h>

#ifdef PKCS11CRYPTO

#include <pk11/result.h>

#endif

#if ! defined(NS_INADDRSZ)

#define NS_INADDRSZ 4

#endif

#if ! defined(NS_IN6ADDRSZ)

#define NS_IN6ADDRSZ 16

#endif

static lwres_context_t *lwctx = NULL;

static lwres_conf_t *lwconf;

dig_lookuplist_t lookup_list;

dig_serverlist_t server_list;

dig_searchlistlist_t search_list;

check_ra = ISC_FALSE,

have_ipv4 = ISC_FALSE,

have_ipv6 = ISC_FALSE,

specified_source = ISC_FALSE,

free_now = ISC_FALSE,

cancel_now = ISC_FALSE,

usesearch = ISC_FALSE,

showsearch = ISC_FALSE,

qr = ISC_FALSE,

is_dst_up = ISC_FALSE,

keep_open = ISC_FALSE,

verbose = ISC_FALSE;

in_port_t port = 53;

unsigned int timeout = 0;

unsigned int extrabytes;

isc_mem_t *mctx = NULL;

isc_log_t *lctx = NULL;

isc_taskmgr_t *taskmgr = NULL;

isc_task_t *global_task = NULL;

isc_timermgr_t *timermgr = NULL;

isc_socketmgr_t *socketmgr = NULL;

isc_sockaddr_t bind_address;

isc_sockaddr_t bind_any;

int sendcount = 0;

int recvcount = 0;

int sockcount = 0;

int ndots = -1;

int tries = 3;

int lookup_counter = 0;

static char servercookie[256];

#ifdef WITH_IDN

static void initialize_idn(void);

static isc_result_t output_filter(isc_buffer_t *buffer,

unsigned int used_org,

isc_boolean_t absolute);

static idn_result_t append_textname(char *name, const char *origin,

size_t namesize);

static void idn_check_result(idn_result_t r, const char *msg);

#define MAXDLEN 256

int idnoptions = 0;

#endif

isc_socket_t *keep = NULL;

isc_sockaddr_t keepaddr;

int exitcode = 0;

int fatalexit = 0;

char keynametext[MXNAME];

char keyfile[MXNAME] = "";

char keysecret[MXNAME] = "";

unsigned char cookie_secret[33];

unsigned char cookie[8];

dns_name_t *hmacname = NULL;

unsigned int digestbits = 0;

isc_buffer_t *namebuf = NULL;

dns_tsigkey_t *key = NULL;

isc_boolean_t validated = ISC_TRUE;

isc_entropy_t *entp = NULL;

isc_mempool_t *commctx = NULL;

isc_boolean_t debugging = ISC_FALSE;

isc_boolean_t debugtiming = ISC_FALSE;

isc_boolean_t memdebugging = ISC_FALSE;

char *progname = NULL;

isc_mutex_t lookup_lock;

dig_lookup_t *current_lookup = NULL;

#ifdef DIG_SIGCHASE

isc_result_t get_trusted_key(void);

dns_rdataset_t * sigchase_scanname(dns_rdatatype_t type,

dns_rdatatype_t covers,

isc_boolean_t *lookedup,

dns_name_t *rdata_name);

dns_rdataset_t * chase_scanname_section(dns_message_t *msg,

dns_name_t *name,

dns_rdatatype_t type,

dns_rdatatype_t covers,

int section);

isc_result_t advanced_rrsearch(dns_rdataset_t **rdataset,

dns_name_t *name,

dns_rdatatype_t type,

dns_rdatatype_t covers,

isc_boolean_t *lookedup);

isc_result_t sigchase_verify_sig_key(dns_name_t *name,

dns_rdataset_t *rdataset,

dst_key_t* dnsseckey,

dns_rdataset_t *sigrdataset);

isc_result_t sigchase_verify_sig(dns_name_t *name,

dns_rdataset_t *rdataset,

dns_rdataset_t *keyrdataset,

dns_rdataset_t *sigrdataset);

isc_result_t sigchase_verify_ds(dns_name_t *name,

dns_rdataset_t *keyrdataset,

dns_rdataset_t *dsrdataset);

void sigchase(dns_message_t *msg);

void print_rdata(dns_rdata_t *rdata, isc_mem_t *mctx);

void print_rdataset(dns_name_t *name, dns_rdataset_t *rdataset);

void dup_name(dns_name_t *source, dns_name_t* target);

void free_name(dns_name_t *name);

void dump_database(void);

void dump_database_section(dns_message_t *msg, int section);

dns_rdataset_t * search_type(dns_name_t *name, dns_rdatatype_t type,

dns_rdatatype_t covers);

isc_result_t contains_trusted_key(dns_name_t *name,

dns_rdataset_t *rdataset,

dns_rdataset_t *sigrdataset);

void print_type(dns_rdatatype_t type);

isc_result_t prove_nx_domain(dns_message_t * msg,

dns_name_t * name,

dns_name_t * rdata_name,

dns_rdataset_t ** rdataset,

dns_rdataset_t ** sigrdataset);

isc_result_t prove_nx_type(dns_message_t * msg, dns_name_t *name,

dns_rdataset_t *nsec,

dns_rdataclass_t rdclass,

dns_rdatatype_t type,

dns_name_t * rdata_name,

dns_rdataset_t ** rdataset,

dns_rdataset_t ** sigrdataset);

isc_result_t prove_nx(dns_message_t * msg, dns_name_t * name,

dns_rdataclass_t rdclass,

dns_rdatatype_t type,

dns_name_t * rdata_name,

dns_rdataset_t ** rdataset,

dns_rdataset_t ** sigrdataset);

static void nameFromString(const char *str, dns_name_t *p_ret);

int inf_name(dns_name_t * name1, dns_name_t * name2);

isc_result_t removetmpkey(const char *file);

void clean_trustedkey(void);

isc_result_t insert_trustedkey(void *arg, dns_name_t *name,

dns_rdataset_t *rdataset);

#if DIG_SIGCHASE_BU

isc_result_t getneededrr(dns_message_t *msg);

void sigchase_bottom_up(dns_message_t *msg);

void sigchase_bu(dns_message_t *msg);

#endif

#if DIG_SIGCHASE_TD

isc_result_t initialization(dns_name_t *name);

isc_result_t prepare_lookup(dns_name_t *name);

isc_result_t grandfather_pb_test(dns_name_t * zone_name,

dns_rdataset_t *sigrdataset);

isc_result_t child_of_zone(dns_name_t *name,

dns_name_t *zone_name,

dns_name_t *child_name);

void sigchase_td(dns_message_t *msg);

#endif

char trustedkey[MXNAME] = "";

dns_rdataset_t *chase_rdataset = NULL;

dns_rdataset_t *chase_sigrdataset = NULL;

dns_rdataset_t *chase_dsrdataset = NULL;

dns_rdataset_t *chase_sigdsrdataset = NULL;

dns_rdataset_t *chase_keyrdataset = NULL;

dns_rdataset_t *chase_sigkeyrdataset = NULL;

dns_rdataset_t *chase_nsrdataset = NULL;

dns_name_t chase_name; /* the query name */

#if DIG_SIGCHASE_TD

dns_name_t chase_current_name;

dns_name_t chase_authority_name;

#endif

#if DIG_SIGCHASE_BU

dns_name_t chase_signame;

#endif

isc_boolean_t chase_siglookedup = ISC_FALSE;

isc_boolean_t chase_keylookedup = ISC_FALSE;

isc_boolean_t chase_sigkeylookedup = ISC_FALSE;

isc_boolean_t chase_dslookedup = ISC_FALSE;

isc_boolean_t chase_sigdslookedup = ISC_FALSE;

#if DIG_SIGCHASE_TD

isc_boolean_t chase_nslookedup = ISC_FALSE;

isc_boolean_t chase_lookedup = ISC_FALSE;

isc_boolean_t delegation_follow = ISC_FALSE;

isc_boolean_t grandfather_pb = ISC_FALSE;

isc_boolean_t have_response = ISC_FALSE;

isc_boolean_t have_delegation_ns = ISC_FALSE;

dns_message_t * error_message = NULL;

#endif

isc_boolean_t dsvalidating = ISC_FALSE;

isc_boolean_t chase_name_dup = ISC_FALSE;

ISC_LIST(dig_message_t) chase_message_list;

ISC_LIST(dig_message_t) chase_message_list2;

#define MAX_TRUSTED_KEY 5

typedef struct struct_trusted_key_list {

dst_key_t * key[MAX_TRUSTED_KEY];

int nb_tk;

} struct_tk_list;

struct_tk_list tk_list = { {NULL, NULL, NULL, NULL, NULL}, 0};

#endif

#define DIG_MAX_ADDRESSES 20

#define LOCK_LOOKUP {\

debug("lock_lookup %s:%d", __FILE__, __LINE__);\

check_result(isc_mutex_lock((&lookup_lock)), "isc_mutex_lock");\

debug("success");\

}

#define UNLOCK_LOOKUP {\

debug("unlock_lookup %s:%d", __FILE__, __LINE__);\

check_result(isc_mutex_unlock((&lookup_lock)),\

"isc_mutex_unlock");\

}

#ifdef DIG_SIGCHASE

(*dighost_printrdataset)(dns_name_t *owner_name, dns_rdataset_t *rdataset,

isc_buffer_t *target);

#endif

(*dighost_printmessage)(dig_query_t *query, dns_message_t *msg,

isc_boolean_t headers);

(*dighost_received)(int bytes, isc_sockaddr_t *from, dig_query_t *query);

(*dighost_trying)(char *frm, dig_lookup_t *lookup);

(*dighost_shutdown)(void);

static void

cancel_lookup(dig_lookup_t *lookup);

static void

recv_done(isc_task_t *task, isc_event_t *event);

static void

send_udp(dig_query_t *query);

static void

connect_timeout(isc_task_t *task, isc_event_t *event);

static void

launch_next_query(dig_query_t *query, isc_boolean_t include_question);

static void

check_next_lookup(dig_lookup_t *lookup);

static isc_boolean_t

next_origin(dig_lookup_t *oldlookup);

static void *

mem_alloc(void *arg, size_t size) {

return (isc_mem_get(arg, size));

}

static void

mem_free(void *arg, void *mem, size_t size) {

isc_mem_put(arg, mem, size);

}

char *

next_token(char **stringp, const char *delim) {

char *res;

do {

res = strsep(stringp, delim);

if (res == NULL)

break;

} while (*res == '\0');

return (res);

}

static int

count_dots(char *string) {

char *s;

int i = 0;

s = string;

while (*s != '\0') {

if (*s == '.')

i++;

s++;

}

return (i);

}

static void

hex_dump(isc_buffer_t *b) {

unsigned int len, i;

isc_region_t r;

isc_buffer_usedregion(b, &r);

printf("%d bytes\n", r.length);

for (len = 0; len < r.length; len++) {

printf("%02x ", r.base[len]);

if (len % 16 == 15) {

fputs(" ", stdout);

for (i = len - 15; i <= len; i++) {

if (r.base[i] >= '!' && r.base[i] <= '}')

putchar(r.base[i]);

else

putchar('.');

}

printf("\n");

}

}

if (len % 16 != 0) {

for (i = len; (i % 16) != 0; i++)

fputs(" ", stdout);

fputs(" ", stdout);

for (i = ((len>>4)<<4); i < len; i++) {

if (r.base[i] >= '!' && r.base[i] <= '}')

putchar(r.base[i]);

else

putchar('.');

}

printf("\n");

}

}

static isc_result_t

append(const char *text, size_t len, char **p, char *end) {

if (*p + len > end)

return (ISC_R_NOSPACE);

memmove(*p, text, len);

*p += len;

return (ISC_R_SUCCESS);

}

static isc_result_t

reverse_octets(const char *in, char **p, char *end) {

const char *dot = strchr(in, '.');

size_t len;

if (dot != NULL) {

isc_result_t result;

result = reverse_octets(dot + 1, p, end);

if (result != ISC_R_SUCCESS)

return (result);

result = append(".", 1, p, end);

if (result != ISC_R_SUCCESS)

return (result);

len = (int) (dot - in);

} else {

len = (int) strlen(in);

}

return (append(in, len, p, end));

}

get_reverse(char *reverse, size_t len, char *value, isc_boolean_t ip6_int,

isc_boolean_t strict)

{

int r;

isc_result_t result;

isc_netaddr_t addr;

addr.family = AF_INET6;

r = inet_pton(AF_INET6, value, &addr.type.in6);

if (r > 0) {

/* This is a valid IPv6 address. */

dns_fixedname_t fname;

dns_name_t *name;

unsigned int options = 0;

if (ip6_int)

options |= DNS_BYADDROPT_IPV6INT;

dns_fixedname_init(&fname);

name = dns_fixedname_name(&fname);

result = dns_byaddr_createptrname2(&addr, options, name);

if (result != ISC_R_SUCCESS)

return (result);

dns_name_format(name, reverse, (unsigned int)len);

return (ISC_R_SUCCESS);

} else {

/*

char *p = reverse;

char *end = reverse + len;

if (strict && inet_pton(AF_INET, value, &addr.type.in) != 1)

return (DNS_R_BADDOTTEDQUAD);

result = reverse_octets(value, &p, end);

if (result != ISC_R_SUCCESS)

return (result);

/* Append .in-addr.arpa. and a terminating NUL. */

result = append(".in-addr.arpa.", 15, &p, end);

if (result != ISC_R_SUCCESS)

return (result);

return (ISC_R_SUCCESS);

}

}

fatal(const char *format, ...) {

va_list args;

fflush(stdout);

fprintf(stderr, "%s: ", progname);

va_start(args, format);

vfprintf(stderr, format, args);

va_end(args);

fprintf(stderr, "\n");

if (exitcode < 10)

exitcode = 10;

if (fatalexit != 0)

exitcode = fatalexit;

exit(exitcode);

}

debug(const char *format, ...) {

va_list args;

isc_time_t t;

if (debugging) {

fflush(stdout);

if (debugtiming) {

TIME_NOW(&t);

fprintf(stderr, "%d.%06d: ", isc_time_seconds(&t),

isc_time_nanoseconds(&t) / 1000);

}

va_start(args, format);

vfprintf(stderr, format, args);

va_end(args);

fprintf(stderr, "\n");

}

}

check_result(isc_result_t result, const char *msg) {

if (result != ISC_R_SUCCESS) {

fatal("%s: %s", msg, isc_result_totext(result));

}

}

dig_server_t *

make_server(const char *servname, const char *userarg) {

dig_server_t *srv;

REQUIRE(servname != NULL);

debug("make_server(%s)", servname);

srv = isc_mem_allocate(mctx, sizeof(struct dig_server));

if (srv == NULL)

fatal("memory allocation failure in %s:%d",

__FILE__, __LINE__);

strlcpy(srv->servername, servname, MXNAME);

strlcpy(srv->userarg, userarg, MXNAME);

ISC_LINK_INIT(srv, link);

return (srv);

}

static int

addr2af(int lwresaddrtype)

{

int af = 0;

switch (lwresaddrtype) {

case LWRES_ADDRTYPE_V4:

af = AF_INET;

break;

case LWRES_ADDRTYPE_V6:

af = AF_INET6;

break;

}

return (af);

}

static void

copy_server_list(lwres_conf_t *confdata, dig_serverlist_t *dest) {

dig_server_t *newsrv;

char tmp[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255") +

sizeof("%4000000000")];

int af;

int i;

debug("copy_server_list()");

for (i = 0; i < confdata->nsnext; i++) {

af = addr2af(confdata->nameservers[i].family);

if (af == AF_INET && !have_ipv4)

continue;

if (af == AF_INET6 && !have_ipv6)

continue;

lwres_net_ntop(af, confdata->nameservers[i].address,

tmp, sizeof(tmp));

if (af == AF_INET6 && confdata->nameservers[i].zone != 0) {

char buf[sizeof("%4000000000")];

snprintf(buf, sizeof(buf), "%%%u",

confdata->nameservers[i].zone);

strlcat(tmp, buf, sizeof(tmp));

}

newsrv = make_server(tmp, tmp);

ISC_LINK_INIT(newsrv, link);

ISC_LIST_ENQUEUE(*dest, newsrv, link);

}

}

flush_server_list(void) {

dig_server_t *s, *ps;

debug("flush_server_list()");

s = ISC_LIST_HEAD(server_list);

while (s != NULL) {

ps = s;

s = ISC_LIST_NEXT(s, link);

ISC_LIST_DEQUEUE(server_list, ps, link);

isc_mem_free(mctx, ps);

}

}

set_nameserver(char *opt) {

isc_result_t result;

isc_sockaddr_t sockaddrs[DIG_MAX_ADDRESSES];

isc_netaddr_t netaddr;

int count, i;

dig_server_t *srv;

char tmp[ISC_NETADDR_FORMATSIZE];

if (opt == NULL)

return;

result = bind9_getaddresses(opt, 0, sockaddrs,

DIG_MAX_ADDRESSES, &count);

if (result != ISC_R_SUCCESS)

fatal("couldn't get address for '%s': %s",

opt, isc_result_totext(result));

flush_server_list();

for (i = 0; i < count; i++) {

isc_netaddr_fromsockaddr(&netaddr, &sockaddrs[i]);

isc_netaddr_format(&netaddr, tmp, sizeof(tmp));

srv = make_server(tmp, opt);

if (srv == NULL)

fatal("memory allocation failure");

ISC_LIST_APPEND(server_list, srv, link);

}

}

static isc_result_t

add_nameserver(lwres_conf_t *confdata, const char *addr, int af) {

int i = confdata->nsnext;

if (confdata->nsnext >= LWRES_CONFMAXNAMESERVERS)

return (ISC_R_FAILURE);

switch (af) {

case AF_INET:

confdata->nameservers[i].family = LWRES_ADDRTYPE_V4;

confdata->nameservers[i].length = NS_INADDRSZ;

break;

case AF_INET6:

confdata->nameservers[i].family = LWRES_ADDRTYPE_V6;

confdata->nameservers[i].length = NS_IN6ADDRSZ;

break;

default:

return (ISC_R_FAILURE);

}

if (lwres_net_pton(af, addr, &confdata->nameservers[i].address) == 1) {

confdata->nsnext++;

return (ISC_R_SUCCESS);

}

return (ISC_R_FAILURE);

}

clone_server_list(dig_serverlist_t src, dig_serverlist_t *dest) {

dig_server_t *srv, *newsrv;

debug("clone_server_list()");

srv = ISC_LIST_HEAD(src);

while (srv != NULL) {

newsrv = make_server(srv->servername, srv->userarg);

ISC_LINK_INIT(newsrv, link);

ISC_LIST_ENQUEUE(*dest, newsrv, link);

srv = ISC_LIST_NEXT(srv, link);

}

}

dig_lookup_t *

make_empty_lookup(void) {

dig_lookup_t *looknew;

debug("make_empty_lookup()");

INSIST(!free_now);

looknew = isc_mem_allocate(mctx, sizeof(struct dig_lookup));

if (looknew == NULL)

fatal("memory allocation failure in %s:%d",

__FILE__, __LINE__);

looknew->pending = ISC_TRUE;

looknew->textname[0] = 0;

looknew->cmdline[0] = 0;

looknew->rdtype = dns_rdatatype_a;

looknew->qrdtype = dns_rdatatype_a;

looknew->rdclass = dns_rdataclass_in;

looknew->rdtypeset = ISC_FALSE;

looknew->rdclassset = ISC_FALSE;

looknew->sendspace = NULL;

looknew->sendmsg = NULL;

looknew->name = NULL;

looknew->oname = NULL;

looknew->xfr_q = NULL;

looknew->current_query = NULL;

looknew->doing_xfr = ISC_FALSE;

looknew->ixfr_serial = 0;

looknew->trace = ISC_FALSE;

looknew->trace_root = ISC_FALSE;

looknew->identify = ISC_FALSE;

looknew->identify_previous_line = ISC_FALSE;

looknew->ignore = ISC_FALSE;

looknew->servfail_stops = ISC_TRUE;

looknew->besteffort = ISC_TRUE;

looknew->dnssec = ISC_FALSE;

looknew->ednsflags = 0;

looknew->opcode = dns_opcode_query;

looknew->expire = ISC_FALSE;

looknew->nsid = ISC_FALSE;

looknew->header_only = ISC_FALSE;

looknew->sendcookie = ISC_FALSE;

looknew->seenbadcookie = ISC_FALSE;

looknew->badcookie = ISC_TRUE;

#ifdef WITH_IDN

looknew->idnout = ISC_TRUE;

#else

looknew->idnout = ISC_FALSE;

#endif

#ifdef DIG_SIGCHASE

looknew->sigchase = ISC_FALSE;

#if DIG_SIGCHASE_TD

looknew->do_topdown = ISC_FALSE;

looknew->trace_root_sigchase = ISC_FALSE;

looknew->rdtype_sigchaseset = ISC_FALSE;

looknew->rdtype_sigchase = dns_rdatatype_any;

looknew->qrdtype_sigchase = dns_rdatatype_any;

looknew->rdclass_sigchase = dns_rdataclass_in;

looknew->rdclass_sigchaseset = ISC_FALSE;

#endif

#endif

looknew->udpsize = 0;

looknew->edns = -1;

looknew->recurse = ISC_TRUE;

looknew->aaonly = ISC_FALSE;

looknew->adflag = ISC_FALSE;

looknew->cdflag = ISC_FALSE;

looknew->print_unknown_format = ISC_FALSE;

looknew->zflag = ISC_FALSE;

looknew->ns_search_only = ISC_FALSE;

looknew->origin = NULL;

looknew->tsigctx = NULL;

looknew->querysig = NULL;

looknew->retries = tries;

looknew->nsfound = 0;

looknew->tcp_mode = ISC_FALSE;

looknew->tcp_mode_set = ISC_FALSE;

looknew->ip6_int = ISC_FALSE;

looknew->comments = ISC_TRUE;

looknew->stats = ISC_TRUE;

looknew->section_question = ISC_TRUE;

looknew->section_answer = ISC_TRUE;

looknew->section_authority = ISC_TRUE;

looknew->section_additional = ISC_TRUE;

looknew->new_search = ISC_FALSE;

looknew->done_as_is = ISC_FALSE;

looknew->need_search = ISC_FALSE;

looknew->ecs_addr = NULL;

looknew->cookie = NULL;

looknew->ednsopts = NULL;

looknew->ednsoptscnt = 0;

looknew->ednsneg = ISC_TRUE;

looknew->mapped = ISC_TRUE;

looknew->dscp = -1;

dns_fixedname_init(&looknew->fdomain);

ISC_LINK_INIT(looknew, link);

ISC_LIST_INIT(looknew->q);

ISC_LIST_INIT(looknew->connecting);

ISC_LIST_INIT(looknew->my_server_list);

return (looknew);

}

dig_lookup_t *

clone_lookup(dig_lookup_t *lookold, isc_boolean_t servers) {

dig_lookup_t *looknew;

debug("clone_lookup()");

INSIST(!free_now);

looknew = make_empty_lookup();

INSIST(looknew != NULL);

strlcpy(looknew->textname, lookold->textname, MXNAME);

#if DIG_SIGCHASE_TD

strlcpy(looknew->textnamesigchase, lookold->textnamesigchase, MXNAME);

#endif

strlcpy(looknew->cmdline, lookold->cmdline, MXNAME);

looknew->textname[MXNAME-1] = 0;

looknew->rdtype = lookold->rdtype;

looknew->qrdtype = lookold->qrdtype;

looknew->rdclass = lookold->rdclass;

looknew->rdtypeset = lookold->rdtypeset;

looknew->rdclassset = lookold->rdclassset;

looknew->doing_xfr = lookold->doing_xfr;

looknew->ixfr_serial = lookold->ixfr_serial;

looknew->trace = lookold->trace;

looknew->trace_root = lookold->trace_root;

looknew->identify = lookold->identify;

looknew->identify_previous_line = lookold->identify_previous_line;

looknew->ignore = lookold->ignore;

looknew->servfail_stops = lookold->servfail_stops;

looknew->besteffort = lookold->besteffort;

looknew->dnssec = lookold->dnssec;

looknew->ednsflags = lookold->ednsflags;

looknew->opcode = lookold->opcode;

looknew->expire = lookold->expire;

looknew->nsid = lookold->nsid;

looknew->header_only = lookold->header_only;

looknew->sendcookie = lookold->sendcookie;

looknew->seenbadcookie = lookold->seenbadcookie;

looknew->badcookie = lookold->badcookie;

looknew->cookie = lookold->cookie;

looknew->ednsopts = lookold->ednsopts;

looknew->ednsoptscnt = lookold->ednsoptscnt;

looknew->ednsneg = lookold->ednsneg;

looknew->mapped = lookold->mapped;

looknew->idnout = lookold->idnout;

#ifdef DIG_SIGCHASE

looknew->sigchase = lookold->sigchase;

#if DIG_SIGCHASE_TD

looknew->do_topdown = lookold->do_topdown;

looknew->trace_root_sigchase = lookold->trace_root_sigchase;

looknew->rdtype_sigchaseset = lookold->rdtype_sigchaseset;

looknew->rdtype_sigchase = lookold->rdtype_sigchase;

looknew->qrdtype_sigchase = lookold->qrdtype_sigchase;

looknew->rdclass_sigchase = lookold->rdclass_sigchase;

looknew->rdclass_sigchaseset = lookold->rdclass_sigchaseset;

#endif

#endif

looknew->udpsize = lookold->udpsize;

looknew->edns = lookold->edns;

looknew->recurse = lookold->recurse;

looknew->aaonly = lookold->aaonly;

looknew->adflag = lookold->adflag;

looknew->cdflag = lookold->cdflag;

looknew->print_unknown_format = lookold->print_unknown_format;

looknew->zflag = lookold->zflag;

looknew->ns_search_only = lookold->ns_search_only;

looknew->tcp_mode = lookold->tcp_mode;

looknew->tcp_mode_set = lookold->tcp_mode_set;

looknew->comments = lookold->comments;

looknew->stats = lookold->stats;

looknew->section_question = lookold->section_question;

looknew->section_answer = lookold->section_answer;

looknew->section_authority = lookold->section_authority;

looknew->section_additional = lookold->section_additional;

looknew->origin = lookold->origin;

looknew->retries = lookold->retries;

looknew->tsigctx = NULL;

looknew->need_search = lookold->need_search;

looknew->done_as_is = lookold->done_as_is;

looknew->dscp = lookold->dscp;

if (lookold->ecs_addr != NULL) {

size_t len = sizeof(isc_sockaddr_t);

looknew->ecs_addr = isc_mem_allocate(mctx, len);

if (looknew->ecs_addr == NULL)

fatal("out of memory");

memmove(looknew->ecs_addr, lookold->ecs_addr, len);

}

dns_name_copy(dns_fixedname_name(&lookold->fdomain),

dns_fixedname_name(&looknew->fdomain), NULL);

if (servers)

clone_server_list(lookold->my_server_list,

&looknew->my_server_list);

return (looknew);

}

dig_lookup_t *

requeue_lookup(dig_lookup_t *lookold, isc_boolean_t servers) {

dig_lookup_t *looknew;

debug("requeue_lookup()");

lookup_counter++;

if (lookup_counter > LOOKUP_LIMIT)

fatal("too many lookups");

looknew = clone_lookup(lookold, servers);

INSIST(looknew != NULL);

debug("before insertion, init@%p -> %p, new@%p -> %p",

lookold, lookold->link.next, looknew, looknew->link.next);

ISC_LIST_PREPEND(lookup_list, looknew, link);

debug("after insertion, init -> %p, new = %p, new -> %p",

lookold, looknew, looknew->link.next);

return (looknew);

}

setup_text_key(void) {

isc_result_t result;

dns_name_t keyname;

isc_buffer_t secretbuf;

unsigned int secretsize;

unsigned char *secretstore;

debug("setup_text_key()");

result = isc_buffer_allocate(mctx, &namebuf, MXNAME);

check_result(result, "isc_buffer_allocate");

dns_name_init(&keyname, NULL);

check_result(result, "dns_name_init");

isc_buffer_putstr(namebuf, keynametext);

secretsize = (unsigned int) strlen(keysecret) * 3 / 4;

secretstore = isc_mem_allocate(mctx, secretsize);

if (secretstore == NULL)

fatal("memory allocation failure in %s:%d",

__FILE__, __LINE__);

isc_buffer_init(&secretbuf, secretstore, secretsize);

result = isc_base64_decodestring(keysecret, &secretbuf);

if (result != ISC_R_SUCCESS)

goto failure;

secretsize = isc_buffer_usedlength(&secretbuf);

if (hmacname == NULL) {

result = DST_R_UNSUPPORTEDALG;

goto failure;

}

result = dns_name_fromtext(&keyname, namebuf, dns_rootname, 0, namebuf);

if (result != ISC_R_SUCCESS)

goto failure;

result = dns_tsigkey_create(&keyname, hmacname, secretstore,

(int)secretsize, ISC_FALSE, NULL, 0, 0,

mctx, NULL, &key);

failure:

if (result != ISC_R_SUCCESS)

printf(";; Couldn't create key %s: %s\n",

keynametext, isc_result_totext(result));

else

dst_key_setbits(key->key, digestbits);

isc_mem_free(mctx, secretstore);

dns_name_invalidate(&keyname);

isc_buffer_free(&namebuf);

}

static isc_result_t

parse_uint_helper(isc_uint32_t *uip, const char *value, isc_uint32_t max,

const char *desc, int base) {

isc_uint32_t n;

isc_result_t result = isc_parse_uint32(&n, value, base);

if (result == ISC_R_SUCCESS && n > max)

result = ISC_R_RANGE;

if (result != ISC_R_SUCCESS) {

printf("invalid %s '%s': %s\n", desc,

value, isc_result_totext(result));

return (result);

}

*uip = n;

return (ISC_R_SUCCESS);

}

parse_uint(isc_uint32_t *uip, const char *value, isc_uint32_t max,

const char *desc) {

return (parse_uint_helper(uip, value, max, desc, 10));

}

parse_xint(isc_uint32_t *uip, const char *value, isc_uint32_t max,

const char *desc) {

return (parse_uint_helper(uip, value, max, desc, 0));

}

static isc_uint32_t

parse_bits(char *arg, const char *desc, isc_uint32_t max) {

isc_result_t result;

isc_uint32_t tmp;

result = parse_uint(&tmp, arg, max, desc);

if (result != ISC_R_SUCCESS)

fatal("couldn't parse digest bits");

tmp = (tmp + 7) & ~0x7U;

return (tmp);

}

parse_netprefix(isc_sockaddr_t **sap, const char *value) {

isc_result_t result = ISC_R_SUCCESS;

isc_sockaddr_t *sa = NULL;

struct in_addr in4;

struct in6_addr in6;

isc_uint32_t prefix_length = 0xffffffff;

char *slash = NULL;

isc_boolean_t parsed = ISC_FALSE;

isc_boolean_t prefix_parsed = ISC_FALSE;

char buf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:XXX.XXX.XXX.XXX/128")];

REQUIRE(sap != NULL && *sap == NULL);

if (strlcpy(buf, value, sizeof(buf)) >= sizeof(buf))

fatal("invalid prefix '%s'\n", value);

sa = isc_mem_allocate(mctx, sizeof(*sa));

if (sa == NULL)

fatal("out of memory");

memset(sa, 0, sizeof(*sa));

if (strcmp(buf, "0") == 0) {

sa->type.sa.sa_family = AF_UNSPEC;

prefix_length = 0;

goto done;

}

slash = strchr(buf, '/');

if (slash != NULL) {

*slash = '\0';

result = isc_parse_uint32(&prefix_length, slash + 1, 10);

if (result != ISC_R_SUCCESS) {

fatal("invalid prefix length in '%s': %s\n",

value, isc_result_totext(result));

}

prefix_parsed = ISC_TRUE;

}

if (inet_pton(AF_INET6, buf, &in6) == 1) {

parsed = ISC_TRUE;

isc_sockaddr_fromin6(sa, &in6, 0);

if (prefix_length > 128)

prefix_length = 128;

} else if (inet_pton(AF_INET, buf, &in4) == 1) {

parsed = ISC_TRUE;

isc_sockaddr_fromin(sa, &in4, 0);

if (prefix_length > 32)

prefix_length = 32;

} else if (prefix_parsed) {

int i;

for (i = 0; i < 3 && strlen(buf) < sizeof(buf) - 2; i++) {

strlcat(buf, ".0", sizeof(buf));

if (inet_pton(AF_INET, buf, &in4) == 1) {

parsed = ISC_TRUE;

isc_sockaddr_fromin(sa, &in4, 0);

break;

}

}

if (prefix_length > 32)

prefix_length = 32;

}

if (!parsed)

fatal("invalid address '%s'", value);

done:

sa->length = prefix_length;

*sap = sa;

return (ISC_R_SUCCESS);

}

parse_hmac(const char *hmac) {

char buf[20];

size_t len;

REQUIRE(hmac != NULL);

len = strlen(hmac);

if (len >= sizeof(buf))

fatal("unknown key type '%.*s'", (int)len, hmac);

strlcpy(buf, hmac, sizeof(buf));

digestbits = 0;

#ifndef PK11_MD5_DISABLE

if (strcasecmp(buf, "hmac-md5") == 0) {

hmacname = DNS_TSIG_HMACMD5_NAME;

} else if (strncasecmp(buf, "hmac-md5-", 9) == 0) {

hmacname = DNS_TSIG_HMACMD5_NAME;

digestbits = parse_bits(&buf[9], "digest-bits [0..128]", 128);

} else

#endif

if (strcasecmp(buf, "hmac-sha1") == 0) {

hmacname = DNS_TSIG_HMACSHA1_NAME;

digestbits = 0;

} else if (strncasecmp(buf, "hmac-sha1-", 10) == 0) {

hmacname = DNS_TSIG_HMACSHA1_NAME;

digestbits = parse_bits(&buf[10], "digest-bits [0..160]", 160);

} else if (strcasecmp(buf, "hmac-sha224") == 0) {

hmacname = DNS_TSIG_HMACSHA224_NAME;

} else if (strncasecmp(buf, "hmac-sha224-", 12) == 0) {

hmacname = DNS_TSIG_HMACSHA224_NAME;

digestbits = parse_bits(&buf[12], "digest-bits [0..224]", 224);

} else if (strcasecmp(buf, "hmac-sha256") == 0) {

hmacname = DNS_TSIG_HMACSHA256_NAME;

} else if (strncasecmp(buf, "hmac-sha256-", 12) == 0) {

hmacname = DNS_TSIG_HMACSHA256_NAME;

digestbits = parse_bits(&buf[12], "digest-bits [0..256]", 256);

} else if (strcasecmp(buf, "hmac-sha384") == 0) {

hmacname = DNS_TSIG_HMACSHA384_NAME;

} else if (strncasecmp(buf, "hmac-sha384-", 12) == 0) {

hmacname = DNS_TSIG_HMACSHA384_NAME;

digestbits = parse_bits(&buf[12], "digest-bits [0..384]", 384);

} else if (strcasecmp(buf, "hmac-sha512") == 0) {

hmacname = DNS_TSIG_HMACSHA512_NAME;

} else if (strncasecmp(buf, "hmac-sha512-", 12) == 0) {

hmacname = DNS_TSIG_HMACSHA512_NAME;

digestbits = parse_bits(&buf[12], "digest-bits [0..512]", 512);

} else {

fprintf(stderr, ";; Warning, ignoring "

"invalid TSIG algorithm %s\n", buf);

}

}

static isc_result_t

read_confkey(void) {

cfg_parser_t *pctx = NULL;

cfg_obj_t *file = NULL;

const cfg_obj_t *keyobj = NULL;

const cfg_obj_t *secretobj = NULL;

const cfg_obj_t *algorithmobj = NULL;

const char *keyname;

const char *secretstr;

const char *algorithm;

isc_result_t result;

if (! isc_file_exists(keyfile))

return (ISC_R_FILENOTFOUND);

result = cfg_parser_create(mctx, NULL, &pctx);

if (result != ISC_R_SUCCESS)

goto cleanup;

result = cfg_parse_file(pctx, keyfile, &cfg_type_sessionkey,

&file);

if (result != ISC_R_SUCCESS)

goto cleanup;

result = cfg_map_get(file, "key", &keyobj);

if (result != ISC_R_SUCCESS)

goto cleanup;

(void) cfg_map_get(keyobj, "secret", &secretobj);

(void) cfg_map_get(keyobj, "algorithm", &algorithmobj);

if (secretobj == NULL || algorithmobj == NULL)

fatal("key must have algorithm and secret");

keyname = cfg_obj_asstring(cfg_map_getname(keyobj));

secretstr = cfg_obj_asstring(secretobj);

algorithm = cfg_obj_asstring(algorithmobj);

strlcpy(keynametext, keyname, sizeof(keynametext));

strlcpy(keysecret, secretstr, sizeof(keysecret));

parse_hmac(algorithm);

setup_text_key();

cleanup:

if (pctx != NULL) {

if (file != NULL)

cfg_obj_destroy(pctx, &file);

cfg_parser_destroy(&pctx);

}

return (result);

}

setup_file_key(void) {

isc_result_t result;

dst_key_t *dstkey = NULL;

debug("setup_file_key()");

/* Try reading the key from a K* pair */

result = dst_key_fromnamedfile(keyfile, NULL,

DST_TYPE_PRIVATE | DST_TYPE_KEY, mctx,

&dstkey);

/* If that didn't work, try reading it as a session.key keyfile */

if (result != ISC_R_SUCCESS) {

result = read_confkey();

if (result == ISC_R_SUCCESS)

return;

}

if (result != ISC_R_SUCCESS) {

fprintf(stderr, "Couldn't read key from %s: %s\n",

keyfile, isc_result_totext(result));

goto failure;

}

switch (dst_key_alg(dstkey)) {

#ifndef PK11_MD5_DISABLE

case DST_ALG_HMACMD5:

hmacname = DNS_TSIG_HMACMD5_NAME;

break;

#endif

case DST_ALG_HMACSHA1:

hmacname = DNS_TSIG_HMACSHA1_NAME;

break;

case DST_ALG_HMACSHA224:

hmacname = DNS_TSIG_HMACSHA224_NAME;

break;

case DST_ALG_HMACSHA256:

hmacname = DNS_TSIG_HMACSHA256_NAME;

break;

case DST_ALG_HMACSHA384:

hmacname = DNS_TSIG_HMACSHA384_NAME;

break;

case DST_ALG_HMACSHA512:

hmacname = DNS_TSIG_HMACSHA512_NAME;

break;

default:

printf(";; Couldn't create key %s: bad algorithm\n",

keynametext);

goto failure;

}

result = dns_tsigkey_createfromkey(dst_key_name(dstkey), hmacname,

dstkey, ISC_FALSE, NULL, 0, 0,

mctx, NULL, &key);

if (result != ISC_R_SUCCESS) {

printf(";; Couldn't create key %s: %s\n",

keynametext, isc_result_totext(result));

goto failure;

}

failure:

if (dstkey != NULL)

dst_key_free(&dstkey);

}

static dig_searchlist_t *

make_searchlist_entry(char *domain) {

dig_searchlist_t *search;

search = isc_mem_allocate(mctx, sizeof(*search));

if (search == NULL)

fatal("memory allocation failure in %s:%d",

__FILE__, __LINE__);

strlcpy(search->origin, domain, MXNAME);

search->origin[MXNAME-1] = 0;

ISC_LINK_INIT(search, link);

return (search);

}

static void

clear_searchlist(void) {

dig_searchlist_t *search;

while ((search = ISC_LIST_HEAD(search_list)) != NULL) {

ISC_LIST_UNLINK(search_list, search, link);

isc_mem_free(mctx, search);

}

}

static void

create_search_list(lwres_conf_t *confdata) {

int i;

dig_searchlist_t *search;

debug("create_search_list()");

clear_searchlist();

for (i = 0; i < confdata->searchnxt; i++) {

search = make_searchlist_entry(confdata->search[i]);

ISC_LIST_APPEND(search_list, search, link);

}

}

setup_system(isc_boolean_t ipv4only, isc_boolean_t ipv6only) {

dig_searchlist_t *domain = NULL;

lwres_result_t lwresult;

unsigned int lwresflags;

isc_result_t result;

debug("setup_system()");

if (ipv4only) {

if (have_ipv4) {

isc_net_disableipv6();

have_ipv6 = ISC_FALSE;

} else {

fatal("can't find IPv4 networking");

}

}

if (ipv6only) {

if (have_ipv6) {

isc_net_disableipv4();

have_ipv4 = ISC_FALSE;

} else {

fatal("can't find IPv6 networking");

}

}

lwresflags = LWRES_CONTEXT_SERVERMODE;

if (have_ipv4)

lwresflags |= LWRES_CONTEXT_USEIPV4;

if (have_ipv6)

lwresflags |= LWRES_CONTEXT_USEIPV6;

lwresult = lwres_context_create(&lwctx, mctx, mem_alloc, mem_free,

lwresflags);

if (lwresult != LWRES_R_SUCCESS)

fatal("lwres_context_create failed");

lwresult = lwres_conf_parse(lwctx, RESOLV_CONF);

if (lwresult != LWRES_R_SUCCESS && lwresult != LWRES_R_NOTFOUND)

fatal("parse of %s failed", RESOLV_CONF);

lwconf = lwres_conf_get(lwctx);

/* Make the search list */

if (lwconf->searchnxt > 0)

create_search_list(lwconf);

else { /* No search list. Use the domain name if any */

if (lwconf->domainname != NULL) {

domain = make_searchlist_entry(lwconf->domainname);

ISC_LIST_APPEND(search_list, domain, link);

domain = NULL;

}

}

if (lwconf->resdebug) {

verbose = ISC_TRUE;

debug("verbose is on");

}

if (ndots == -1) {

ndots = lwconf->ndots;

debug("ndots is %d.", ndots);

}

if (lwconf->attempts) {

tries = lwconf->attempts + 1;

if (tries < 2)

tries = 2;

debug("tries is %d.", tries);

}

if (lwconf->timeout) {

timeout = lwconf->timeout;

debug("timeout is %d.", timeout);

}

/* If user doesn't specify server use nameservers from resolv.conf. */

if (ISC_LIST_EMPTY(server_list))

copy_server_list(lwconf, &server_list);

/* If we don't find a nameserver fall back to localhost */

if (ISC_LIST_EMPTY(server_list)) {

if (have_ipv4) {

lwresult = add_nameserver(lwconf, "127.0.0.1", AF_INET);

if (lwresult != ISC_R_SUCCESS)

fatal("add_nameserver failed");

}

if (have_ipv6) {

lwresult = add_nameserver(lwconf, "::1", AF_INET6);

if (lwresult != ISC_R_SUCCESS)

fatal("add_nameserver failed");

}

copy_server_list(lwconf, &server_list);

}

#ifdef WITH_IDN

initialize_idn();

#endif

if (keyfile[0] != 0)

setup_file_key();

else if (keysecret[0] != 0)

setup_text_key();

#ifdef DIG_SIGCHASE

/* Setup the list of messages for +sigchase */

ISC_LIST_INIT(chase_message_list);

ISC_LIST_INIT(chase_message_list2);

dns_name_init(&chase_name, NULL);

#if DIG_SIGCHASE_TD

dns_name_init(&chase_current_name, NULL);

dns_name_init(&chase_authority_name, NULL);

#endif

#if DIG_SIGCHASE_BU

dns_name_init(&chase_signame, NULL);

#endif

#endif

result = isc_entropy_getdata(entp, cookie_secret,

sizeof(cookie_secret), NULL, 0);

if (result != ISC_R_SUCCESS)

fatal("unable to generate cookie secret");

}

set_search_domain(char *domain) {

dig_searchlist_t *search;

clear_searchlist();

search = make_searchlist_entry(domain);

ISC_LIST_APPEND(search_list, search, link);

}

setup_libs(void) {

isc_result_t result;

isc_logconfig_t *logconfig = NULL;

debug("setup_libs()");

#ifdef PKCS11CRYPTO

pk11_result_register();

#endif

dns_result_register();

result = isc_net_probeipv4();

if (result == ISC_R_SUCCESS)

have_ipv4 = ISC_TRUE;

result = isc_net_probeipv6();

if (result == ISC_R_SUCCESS)

have_ipv6 = ISC_TRUE;

if (!have_ipv6 && !have_ipv4)

fatal("can't find either v4 or v6 networking");

result = isc_mem_create(0, 0, &mctx);

check_result(result, "isc_mem_create");

isc_mem_setname(mctx, "dig", NULL);

result = isc_log_create(mctx, &lctx, &logconfig);

check_result(result, "isc_log_create");

isc_log_setcontext(lctx);

dns_log_init(lctx);

dns_log_setcontext(lctx);

result = isc_log_usechannel(logconfig, "default_debug", NULL, NULL);

check_result(result, "isc_log_usechannel");

isc_log_setdebuglevel(lctx, 0);

result = isc_taskmgr_create(mctx, 1, 0, &taskmgr);

check_result(result, "isc_taskmgr_create");

result = isc_task_create(taskmgr, 0, &global_task);

check_result(result, "isc_task_create");

isc_task_setname(global_task, "dig", NULL);

result = isc_timermgr_create(mctx, &timermgr);

check_result(result, "isc_timermgr_create");

result = isc_socketmgr_create(mctx, &socketmgr);

check_result(result, "isc_socketmgr_create");

result = isc_entropy_create(mctx, &entp);

check_result(result, "isc_entropy_create");

result = dst_lib_init(mctx, entp, 0);

check_result(result, "dst_lib_init");

is_dst_up = ISC_TRUE;

result = isc_mempool_create(mctx, COMMSIZE, &commctx);

check_result(result, "isc_mempool_create");

isc_mempool_setname(commctx, "COMMPOOL");

/*

isc_mempool_setfreemax(commctx, 6);

isc_mempool_setfillcount(commctx, 2);

result = isc_mutex_init(&lookup_lock);

check_result(result, "isc_mutex_init");

}

#define EDNSOPTS 100U

static dns_ednsopt_t ednsopts[EDNSOPTS];

static unsigned char ednsoptscnt = 0;

typedef struct dig_ednsoptname {

isc_uint32_t code;

const char *name;

} dig_ednsoptname_t;

dig_ednsoptname_t optnames[] = {

{ 3, "NSID" }, /* RFC 5001 */

{ 5, "DAU" }, /* RFC 6975 */

{ 6, "DHU" }, /* RFC 6975 */

{ 7, "N3U" }, /* RFC 6975 */

{ 8, "ECS" }, /* RFC 7871 */

{ 9, "EXPIRE" }, /* RFC 7314 */

{ 10, "COOKIE" }, /* RFC 7873 */

{ 11, "KEEPALIVE" }, /* RFC 7828 */

{ 12, "PADDING" }, /* RFC 7830 */

{ 12, "PAD" }, /* shorthand */

{ 13, "CHAIN" }, /* RFC 7901 */

{ 14, "KEY-TAG" }, /* RFC 8145 */

{ 26946, "DEVICEID" }, /* Brian Hartvigsen */

};

#define N_EDNS_OPTNAMES (sizeof(optnames) / sizeof(optnames[0]))

save_opt(dig_lookup_t *lookup, char *code, char *value) {

isc_result_t result;

isc_uint32_t num;

isc_buffer_t b;

isc_boolean_t found = ISC_FALSE;

unsigned int i;

if (ednsoptscnt == EDNSOPTS)

fatal("too many ednsopts");

for (i = 0; i < N_EDNS_OPTNAMES; i++) {

if (strcasecmp(code, optnames[i].name) == 0) {

num = optnames[i].code;

found = ISC_TRUE;

break;

}

}

if (!found) {

result = parse_uint(&num, code, 65535, "ednsopt");

if (result != ISC_R_SUCCESS)

fatal("bad edns code point: %s", code);

}

ednsopts[ednsoptscnt].code = num;

ednsopts[ednsoptscnt].length = 0;

ednsopts[ednsoptscnt].value = NULL;

if (value != NULL) {

char *buf;

buf = isc_mem_allocate(mctx, strlen(value)/2 + 1);

if (buf == NULL)

fatal("out of memory");

isc_buffer_init(&b, buf, (unsigned int) strlen(value)/2 + 1);

result = isc_hex_decodestring(value, &b);

check_result(result, "isc_hex_decodestring");

ednsopts[ednsoptscnt].value = isc_buffer_base(&b);

ednsopts[ednsoptscnt].length = isc_buffer_usedlength(&b);

}

if (lookup->ednsoptscnt == 0)

lookup->ednsopts = &ednsopts[ednsoptscnt];

lookup->ednsoptscnt++;

ednsoptscnt++;

}

static void

add_opt(dns_message_t *msg, isc_uint16_t udpsize, isc_uint16_t edns,

unsigned int flags, dns_ednsopt_t *opts, size_t count)

{

dns_rdataset_t *rdataset = NULL;

isc_result_t result;

debug("add_opt()");

result = dns_message_buildopt(msg, &rdataset, edns, udpsize, flags,

opts, count);

check_result(result, "dns_message_buildopt");

result = dns_message_setopt(msg, rdataset);

check_result(result, "dns_message_setopt");

}

static void

add_question(dns_message_t *message, dns_name_t *name,

dns_rdataclass_t rdclass, dns_rdatatype_t rdtype)

{

dns_rdataset_t *rdataset;

isc_result_t result;

debug("add_question()");

rdataset = NULL;

result = dns_message_gettemprdataset(message, &rdataset);

check_result(result, "dns_message_gettemprdataset()");

dns_rdataset_makequestion(rdataset, rdclass, rdtype);

ISC_LIST_APPEND(name->list, rdataset, link);

}

static void

check_if_done(void) {

debug("check_if_done()");

debug("list %s", ISC_LIST_EMPTY(lookup_list) ? "empty" : "full");

if (ISC_LIST_EMPTY(lookup_list) && current_lookup == NULL &&

sendcount == 0) {

INSIST(sockcount == 0);

INSIST(recvcount == 0);

debug("shutting down");

dighost_shutdown();

}

}

static void

clear_query(dig_query_t *query) {

dig_lookup_t *lookup;

REQUIRE(query != NULL);

debug("clear_query(%p)", query);

if (query->timer != NULL)

isc_timer_detach(&query->timer);

lookup = query->lookup;

if (lookup->current_query == query)

lookup->current_query = NULL;

if (ISC_LINK_LINKED(query, link))

ISC_LIST_UNLINK(lookup->q, query, link);

if (ISC_LINK_LINKED(query, clink))

ISC_LIST_UNLINK(lookup->connecting, query, clink);

if (ISC_LINK_LINKED(&query->recvbuf, link))

ISC_LIST_DEQUEUE(query->recvlist, &query->recvbuf,

link);

if (ISC_LINK_LINKED(&query->lengthbuf, link))

ISC_LIST_DEQUEUE(query->lengthlist, &query->lengthbuf,

link);

INSIST(query->recvspace != NULL);

if (query->sock != NULL) {

isc_socket_detach(&query->sock);

sockcount--;

debug("sockcount=%d", sockcount);

}

isc_mempool_put(commctx, query->recvspace);

isc_buffer_invalidate(&query->recvbuf);

isc_buffer_invalidate(&query->lengthbuf);

if (query->waiting_senddone)

query->pending_free = ISC_TRUE;

else

isc_mem_free(mctx, query);

}

static isc_boolean_t

try_clear_lookup(dig_lookup_t *lookup) {

dig_query_t *q;

REQUIRE(lookup != NULL);

debug("try_clear_lookup(%p)", lookup);

if (ISC_LIST_HEAD(lookup->q) != NULL ||

ISC_LIST_HEAD(lookup->connecting) != NULL)

{

if (debugging) {

q = ISC_LIST_HEAD(lookup->q);

while (q != NULL) {

debug("query to %s still pending", q->servname);

q = ISC_LIST_NEXT(q, link);

}

q = ISC_LIST_HEAD(lookup->connecting);

while (q != NULL) {

debug("query to %s still connecting",

q->servname);

q = ISC_LIST_NEXT(q, clink);

}

}

return (ISC_FALSE);

}

/*

destroy_lookup(lookup);

return (ISC_TRUE);

}

destroy_lookup(dig_lookup_t *lookup) {

dig_server_t *s;

void *ptr;

debug("destroy");

s = ISC_LIST_HEAD(lookup->my_server_list);

while (s != NULL) {

debug("freeing server %p belonging to %p", s, lookup);

ptr = s;

s = ISC_LIST_NEXT(s, link);

ISC_LIST_DEQUEUE(lookup->my_server_list,

(dig_server_t *)ptr, link);

isc_mem_free(mctx, ptr);

}

if (lookup->sendmsg != NULL)

dns_message_destroy(&lookup->sendmsg);

if (lookup->querysig != NULL) {

debug("freeing buffer %p", lookup->querysig);

isc_buffer_free(&lookup->querysig);

}

if (lookup->sendspace != NULL)

isc_mempool_put(commctx, lookup->sendspace);

if (lookup->tsigctx != NULL)

dst_context_destroy(&lookup->tsigctx);

if (lookup->ecs_addr != NULL)

isc_mem_free(mctx, lookup->ecs_addr);

isc_mem_free(mctx, lookup);

}

start_lookup(void) {

debug("start_lookup()");

if (cancel_now)

return;

/*

INSIST(current_lookup == NULL);

current_lookup = ISC_LIST_HEAD(lookup_list);

/*

if (current_lookup != NULL) {

ISC_LIST_DEQUEUE(lookup_list, current_lookup, link);

#if DIG_SIGCHASE_TD

if (current_lookup->do_topdown &&

!current_lookup->rdtype_sigchaseset) {

dst_key_t *dstkey = NULL;

isc_buffer_t *b = NULL;

isc_region_t r;

isc_result_t result;

dns_name_t query_name;

dns_name_t *key_name;

int i;

result = get_trusted_key();

if (result != ISC_R_SUCCESS) {

printf("\n;; No trusted key, "

"+sigchase option is disabled\n");

current_lookup->sigchase = ISC_FALSE;

goto novalidation;

}

dns_name_init(&query_name, NULL);

nameFromString(current_lookup->textname, &query_name);

for (i = 0; i < tk_list.nb_tk; i++) {

key_name = dst_key_name(tk_list.key[i]);

if (dns_name_issubdomain(&query_name,

key_name) == ISC_TRUE)

dstkey = tk_list.key[i];

/*

}

if (dstkey == NULL) {

printf("\n;; The queried zone: ");

dns_name_print(&query_name, stdout);

printf(" isn't a subdomain of any Trusted Keys"

": +sigchase option is disable\n");

current_lookup->sigchase = ISC_FALSE;

free_name(&query_name);

goto novalidation;

}

free_name(&query_name);

current_lookup->rdtype_sigchase

= current_lookup->rdtype;

current_lookup->rdtype_sigchaseset

= current_lookup->rdtypeset;

current_lookup->rdtype = dns_rdatatype_ns;

current_lookup->qrdtype_sigchase

= current_lookup->qrdtype;

current_lookup->qrdtype = dns_rdatatype_ns;

current_lookup->rdclass_sigchase

= current_lookup->rdclass;

current_lookup->rdclass_sigchaseset

= current_lookup->rdclassset;

current_lookup->rdclass = dns_rdataclass_in;

strlcpy(current_lookup->textnamesigchase,

current_lookup->textname, MXNAME);

current_lookup->trace_root_sigchase = ISC_TRUE;

result = isc_buffer_allocate(mctx, &b, BUFSIZE);

check_result(result, "isc_buffer_allocate");

result = dns_name_totext(dst_key_name(dstkey),

ISC_FALSE, b);

check_result(result, "dns_name_totext");

isc_buffer_usedregion(b, &r);

r.base[r.length] = '\0';

strlcpy(current_lookup->textname, (char*)r.base,

MXNAME);

isc_buffer_free(&b);

nameFromString(current_lookup->textnamesigchase,

&chase_name);

dns_name_init(&chase_authority_name, NULL);

}

novalidation:

#endif

if (setup_lookup(current_lookup))

do_lookup(current_lookup);

else if (next_origin(current_lookup))

check_next_lookup(current_lookup);

} else {

check_if_done();

}

}

static void

check_next_lookup(dig_lookup_t *lookup) {

INSIST(!free_now);

debug("check_next_lookup(%p)", lookup);

if (ISC_LIST_HEAD(lookup->q) != NULL) {

debug("still have a worker");

return;

}

if (try_clear_lookup(lookup)) {

current_lookup = NULL;

start_lookup();

}

}

static int

followup_lookup(dns_message_t *msg, dig_query_t *query, dns_section_t section)

{

dig_lookup_t *lookup = NULL;

dig_server_t *srv = NULL;

dns_rdataset_t *rdataset = NULL;

dns_rdata_t rdata = DNS_RDATA_INIT;

dns_name_t *name = NULL;

isc_result_t result;

isc_boolean_t success = ISC_FALSE;

int numLookups = 0;

int num;

isc_result_t lresult, addresses_result;

char bad_namestr[DNS_NAME_FORMATSIZE];

dns_name_t *domain;

isc_boolean_t horizontal = ISC_FALSE, bad = ISC_FALSE;

INSIST(!free_now);

debug("following up %s", query->lookup->textname);

addresses_result = ISC_R_SUCCESS;

bad_namestr[0] = '\0';

for (result = dns_message_firstname(msg, section);

result == ISC_R_SUCCESS;

result = dns_message_nextname(msg, section)) {

name = NULL;

dns_message_currentname(msg, section, &name);

if (section == DNS_SECTION_AUTHORITY) {

rdataset = NULL;

result = dns_message_findtype(name, dns_rdatatype_soa,

0, &rdataset);

if (result == ISC_R_SUCCESS)

return (0);

}

rdataset = NULL;

result = dns_message_findtype(name, dns_rdatatype_ns, 0,

&rdataset);

if (result != ISC_R_SUCCESS)

continue;

debug("found NS set");

if (query->lookup->trace && !query->lookup->trace_root) {

dns_namereln_t namereln;

unsigned int nlabels;

int order;

domain = dns_fixedname_name(&query->lookup->fdomain);

namereln = dns_name_fullcompare(name, domain,

&order, &nlabels);

if (namereln == dns_namereln_equal) {

if (!horizontal)

printf(";; BAD (HORIZONTAL) REFERRAL\n");

horizontal = ISC_TRUE;

} else if (namereln != dns_namereln_subdomain) {

if (!bad)

printf(";; BAD REFERRAL\n");

bad = ISC_TRUE;

continue;

}

}

for (result = dns_rdataset_first(rdataset);

result == ISC_R_SUCCESS;

result = dns_rdataset_next(rdataset)) {

char namestr[DNS_NAME_FORMATSIZE];

dns_rdata_ns_t ns;

if (query->lookup->trace_root &&

query->lookup->nsfound >= MXSERV)

break;

dns_rdataset_current(rdataset, &rdata);

query->lookup->nsfound++;

result = dns_rdata_tostruct(&rdata, &ns, NULL);

check_result(result, "dns_rdata_tostruct");

dns_name_format(&ns.name, namestr, sizeof(namestr));

dns_rdata_freestruct(&ns);

/* Initialize lookup if we've not yet */

debug("found NS %s", namestr);

if (!success) {

success = ISC_TRUE;

lookup_counter++;

lookup = requeue_lookup(query->lookup,

ISC_FALSE);

cancel_lookup(query->lookup);

lookup->doing_xfr = ISC_FALSE;

if (!lookup->trace_root &&

section == DNS_SECTION_ANSWER)

lookup->trace = ISC_FALSE;

else

lookup->trace = query->lookup->trace;

lookup->ns_search_only =

query->lookup->ns_search_only;

lookup->trace_root = ISC_FALSE;

if (lookup->ns_search_only)

lookup->recurse = ISC_FALSE;

domain = dns_fixedname_name(&lookup->fdomain);

dns_name_copy(name, domain, NULL);

}

debug("adding server %s", namestr);

num = getaddresses(lookup, namestr, &lresult);

if (lresult != ISC_R_SUCCESS) {

printf("couldn't get address for '%s': %s\n",

namestr, isc_result_totext(lresult));

if (addresses_result == ISC_R_SUCCESS) {

addresses_result = lresult;

strlcpy(bad_namestr, namestr,

sizeof(bad_namestr));

}

}

numLookups += num;

dns_rdata_reset(&rdata);

}

}

if (numLookups == 0 && addresses_result != ISC_R_SUCCESS) {

fatal("couldn't get address for '%s': %s",

bad_namestr, isc_result_totext(result));

}

if (lookup == NULL &&

section == DNS_SECTION_ANSWER &&

(query->lookup->trace || query->lookup->ns_search_only))

return (followup_lookup(msg, query, DNS_SECTION_AUTHORITY));

/*

if (numLookups > 1) {

isc_uint32_t i, j;

dig_serverlist_t my_server_list;

dig_server_t *next;

ISC_LIST_INIT(my_server_list);

i = numLookups;

for (srv = ISC_LIST_HEAD(lookup->my_server_list);

srv != NULL;

srv = ISC_LIST_HEAD(lookup->my_server_list)) {

INSIST(i > 0);

isc_random_get(&j);

j %= i;

next = ISC_LIST_NEXT(srv, link);

while (j-- > 0 && next != NULL) {

srv = next;

next = ISC_LIST_NEXT(srv, link);

}

ISC_LIST_DEQUEUE(lookup->my_server_list, srv, link);

ISC_LIST_APPEND(my_server_list, srv, link);

i--;

}

ISC_LIST_APPENDLIST(lookup->my_server_list,

my_server_list, link);

}

return (numLookups);

}

static isc_boolean_t

next_origin(dig_lookup_t *oldlookup) {

dig_lookup_t *newlookup;

dig_searchlist_t *search;

dns_fixedname_t fixed;

dns_name_t *name;

isc_result_t result;

INSIST(!free_now);

debug("next_origin()");

debug("following up %s", oldlookup->textname);

if (!usesearch)

/*

return (ISC_FALSE);

/*

dns_fixedname_init(&fixed);

name = dns_fixedname_name(&fixed);

result = dns_name_fromstring2(name, oldlookup->textname, NULL,

0, NULL);

if (result == ISC_R_SUCCESS &&

(dns_name_isabsolute(name) ||

(int)dns_name_countlabels(name) > ndots))

return (ISC_FALSE);

if (oldlookup->origin == NULL && !oldlookup->need_search)

/*

return (ISC_FALSE);

if (oldlookup->origin == NULL && oldlookup->need_search) {

newlookup = requeue_lookup(oldlookup, ISC_TRUE);

newlookup->origin = ISC_LIST_HEAD(search_list);

newlookup->need_search = ISC_FALSE;

} else {

search = ISC_LIST_NEXT(oldlookup->origin, link);

if (search == NULL && oldlookup->done_as_is)

return (ISC_FALSE);

newlookup = requeue_lookup(oldlookup, ISC_TRUE);

newlookup->origin = search;

}

cancel_lookup(oldlookup);

return (ISC_TRUE);

}

static void

insert_soa(dig_lookup_t *lookup) {

isc_result_t result;

dns_rdata_soa_t soa;

dns_rdata_t *rdata = NULL;

dns_rdatalist_t *rdatalist = NULL;

dns_rdataset_t *rdataset = NULL;

dns_name_t *soaname = NULL;

debug("insert_soa()");

soa.mctx = mctx;

soa.serial = lookup->ixfr_serial;

soa.refresh = 0;

soa.retry = 0;

soa.expire = 0;

soa.minimum = 0;

soa.common.rdclass = lookup->rdclass;

soa.common.rdtype = dns_rdatatype_soa;

dns_name_init(&soa.origin, NULL);

dns_name_init(&soa.contact, NULL);

dns_name_clone(dns_rootname, &soa.origin);

dns_name_clone(dns_rootname, &soa.contact);

isc_buffer_init(&lookup->rdatabuf, lookup->rdatastore,

sizeof(lookup->rdatastore));

result = dns_message_gettemprdata(lookup->sendmsg, &rdata);

check_result(result, "dns_message_gettemprdata");

result = dns_rdata_fromstruct(rdata, lookup->rdclass,

dns_rdatatype_soa, &soa,

&lookup->rdatabuf);

check_result(result, "isc_rdata_fromstruct");

result = dns_message_gettemprdatalist(lookup->sendmsg, &rdatalist);

check_result(result, "dns_message_gettemprdatalist");

result = dns_message_gettemprdataset(lookup->sendmsg, &rdataset);

check_result(result, "dns_message_gettemprdataset");

dns_rdatalist_init(rdatalist);

rdatalist->type = dns_rdatatype_soa;

rdatalist->rdclass = lookup->rdclass;

ISC_LIST_APPEND(rdatalist->rdata, rdata, link);

dns_rdatalist_tordataset(rdatalist, rdataset);

result = dns_message_gettempname(lookup->sendmsg, &soaname);

check_result(result, "dns_message_gettempname");

dns_name_init(soaname, NULL);

dns_name_clone(lookup->name, soaname);

ISC_LIST_INIT(soaname->list);

ISC_LIST_APPEND(soaname->list, rdataset, link);

dns_message_addname(lookup->sendmsg, soaname, DNS_SECTION_AUTHORITY);

}

static void

compute_cookie(unsigned char *clientcookie, size_t len) {

/* XXXMPA need to fix, should be per server. */

INSIST(len >= 8U);

memmove(clientcookie, cookie_secret, 8);

}

setup_lookup(dig_lookup_t *lookup) {

isc_result_t result;

isc_uint32_t id;

unsigned int len;

dig_server_t *serv;

dig_query_t *query;

isc_buffer_t b;

dns_compress_t cctx;

char store[MXNAME];

char ecsbuf[20];

char cookiebuf[256];

#ifdef WITH_IDN

idn_result_t mr;

char utf8_textname[MXNAME], utf8_origin[MXNAME], idn_textname[MXNAME];

#endif

#ifdef WITH_IDN

result = dns_name_settotextfilter(lookup->idnout ?

output_filter : NULL);

check_result(result, "dns_name_settotextfilter");

#endif

REQUIRE(lookup != NULL);

INSIST(!free_now);

debug("setup_lookup(%p)", lookup);

result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER,

&lookup->sendmsg);

check_result(result, "dns_message_create");

if (lookup->new_search) {

debug("resetting lookup counter.");

lookup_counter = 0;

}

if (ISC_LIST_EMPTY(lookup->my_server_list)) {

debug("cloning server list");

clone_server_list(server_list, &lookup->my_server_list);

}

result = dns_message_gettempname(lookup->sendmsg, &lookup->name);

check_result(result, "dns_message_gettempname");

dns_name_init(lookup->name, NULL);

isc_buffer_init(&lookup->namebuf, lookup->name_space,

sizeof(lookup->name_space));

isc_buffer_init(&lookup->onamebuf, lookup->oname_space,

sizeof(lookup->oname_space));

#ifdef WITH_IDN

/*

mr = idn_encodename(IDN_LOCALCONV | IDN_DELIMMAP, lookup->textname,

utf8_textname, sizeof(utf8_textname));

idn_check_result(mr, "convert textname to UTF-8");

#endif

/*

if (lookup->new_search) {

#ifdef WITH_IDN

if ((count_dots(utf8_textname) >= ndots) || !usesearch) {

lookup->origin = NULL; /* Force abs lookup */

lookup->done_as_is = ISC_TRUE;

lookup->need_search = usesearch;

} else if (lookup->origin == NULL && usesearch) {

lookup->origin = ISC_LIST_HEAD(search_list);

lookup->need_search = ISC_FALSE;

}

#else

if ((count_dots(lookup->textname) >= ndots) || !usesearch) {

lookup->origin = NULL; /* Force abs lookup */

lookup->done_as_is = ISC_TRUE;

lookup->need_search = usesearch;

} else if (lookup->origin == NULL && usesearch) {

lookup->origin = ISC_LIST_HEAD(search_list);

lookup->need_search = ISC_FALSE;

}

#endif

}

#ifdef WITH_IDN

if (lookup->origin != NULL) {

mr = idn_encodename(IDN_LOCALCONV | IDN_DELIMMAP,

lookup->origin->origin, utf8_origin,

sizeof(utf8_origin));

idn_check_result(mr, "convert origin to UTF-8");

mr = append_textname(utf8_textname, utf8_origin,

sizeof(utf8_textname));

idn_check_result(mr, "append origin to textname");

}

mr = idn_encodename(idnoptions | IDN_LOCALMAP | IDN_NAMEPREP |

IDN_IDNCONV | IDN_LENCHECK, utf8_textname,

idn_textname, sizeof(idn_textname));

idn_check_result(mr, "convert UTF-8 textname to IDN encoding");

#else

if (lookup->origin != NULL) {

debug("trying origin %s", lookup->origin->origin);

result = dns_message_gettempname(lookup->sendmsg,

&lookup->oname);

check_result(result, "dns_message_gettempname");

dns_name_init(lookup->oname, NULL);

/* XXX Helper funct to conv char* to name? */

len = (unsigned int) strlen(lookup->origin->origin);

isc_buffer_init(&b, lookup->origin->origin, len);

isc_buffer_add(&b, len);

result = dns_name_fromtext(lookup->oname, &b, dns_rootname,

0, &lookup->onamebuf);

if (result != ISC_R_SUCCESS) {

dns_message_puttempname(lookup->sendmsg,

&lookup->name);

dns_message_puttempname(lookup->sendmsg,

&lookup->oname);

fatal("'%s' is not in legal name syntax (%s)",

lookup->origin->origin,

isc_result_totext(result));

}

if (lookup->trace && lookup->trace_root) {

dns_name_clone(dns_rootname, lookup->name);

} else {

dns_fixedname_t fixed;

dns_name_t *name;

dns_fixedname_init(&fixed);

name = dns_fixedname_name(&fixed);

len = (unsigned int) strlen(lookup->textname);

isc_buffer_init(&b, lookup->textname, len);

isc_buffer_add(&b, len);

result = dns_name_fromtext(name, &b, NULL, 0, NULL);

if (result == ISC_R_SUCCESS &&

!dns_name_isabsolute(name))

result = dns_name_concatenate(name,

lookup->oname,

lookup->name,

&lookup->namebuf);

else if (result == ISC_R_SUCCESS)

result = dns_name_copy(name, lookup->name,

&lookup->namebuf);

if (result != ISC_R_SUCCESS) {

dns_message_puttempname(lookup->sendmsg,

&lookup->name);

dns_message_puttempname(lookup->sendmsg,

&lookup->oname);

if (result == DNS_R_NAMETOOLONG)

return (ISC_FALSE);

fatal("'%s' is not in legal name syntax (%s)",

lookup->textname,

isc_result_totext(result));

}

}

dns_message_puttempname(lookup->sendmsg, &lookup->oname);

} else

#endif

{

debug("using root origin");

if (lookup->trace && lookup->trace_root)

dns_name_clone(dns_rootname, lookup->name);

else {

#ifdef WITH_IDN

len = (unsigned int) strlen(idn_textname);

isc_buffer_init(&b, idn_textname, len);

isc_buffer_add(&b, len);

result = dns_name_fromtext(lookup->name, &b,

dns_rootname, 0,

&lookup->namebuf);

#else

len = (unsigned int) strlen(lookup->textname);

isc_buffer_init(&b, lookup->textname, len);

isc_buffer_add(&b, len);

result = dns_name_fromtext(lookup->name, &b,

dns_rootname, 0,

&lookup->namebuf);

#endif

}

if (result != ISC_R_SUCCESS) {

dns_message_puttempname(lookup->sendmsg,

&lookup->name);

fatal("'%s' is not a legal name "

"(%s)", lookup->textname,

isc_result_totext(result));

}

}

dns_name_format(lookup->name, store, sizeof(store));

dighost_trying(store, lookup);

INSIST(dns_name_isabsolute(lookup->name));

isc_random_get(&id);