f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff

9c3531d72aeaad6c5f01efe6a1c82023e1379e4dDavid Lawrence

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <config.h>

1a69a1a78cfaa86f3b68bbc965232b7876d4da2aDavid Lawrence#include <stdlib.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <unistd.h>

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <netdb.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <string.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <limits.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#if (!(defined(HAVE_ADDRINFO) && defined(HAVE_GETADDRINFO)))

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graffextern int h_errno;

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#endif

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <dns/message.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <dns/name.h>

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <dns/rdata.h>

f1b68725503ff3e46001eee5a1751e29a43a09d1Andreas Gustafsson#include <dns/rdataclass.h>

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <dns/rdatalist.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <dns/rdataset.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <dns/rdatastruct.h>

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <dns/rdatatype.h>

f1b68725503ff3e46001eee5a1751e29a43a09d1Andreas Gustafsson#include <dns/result.h>

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <dns/tsig.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <dst/dst.h>

1a69a1a78cfaa86f3b68bbc965232b7876d4da2aDavid Lawrence

1a69a1a78cfaa86f3b68bbc965232b7876d4da2aDavid Lawrence#include <isc/app.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <isc/base64.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <isc/entropy.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <isc/lang.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <isc/lex.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <isc/netdb.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <isc/result.h>

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <isc/string.h>

f1b68725503ff3e46001eee5a1751e29a43a09d1Andreas Gustafsson#include <isc/task.h>

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <isc/timer.h>

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <isc/types.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff#include <isc/util.h>

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff#include <dig/dig.h>

f1b68725503ff3e46001eee5a1751e29a43a09d1Andreas Gustafsson

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael GraffISC_LIST(dig_lookup_t) lookup_list;

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael GraffISC_LIST(dig_server_t) server_list;

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael GraffISC_LIST(dig_searchlist_t) search_list;

1a69a1a78cfaa86f3b68bbc965232b7876d4da2aDavid Lawrence

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff have_ipv6 = ISC_FALSE,

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff specified_source = ISC_FALSE,

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff free_now = ISC_FALSE,

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff show_details = ISC_FALSE,

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff usesearch = ISC_FALSE,

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff qr = ISC_FALSE,

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graff is_dst_up = ISC_FALSE;

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graff

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graffin_port_t port = 53;

f1b68725503ff3e46001eee5a1751e29a43a09d1Andreas Gustafssonunsigned int timeout = 5;

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graffisc_mem_t *mctx = NULL;

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graffisc_taskmgr_t *taskmgr = NULL;

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graffisc_task_t *global_task = NULL;

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graffisc_timermgr_t *timermgr = NULL;

f1b68725503ff3e46001eee5a1751e29a43a09d1Andreas Gustafssonisc_socketmgr_t *socketmgr = NULL;

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graffisc_sockaddr_t bind_address;

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graffisc_sockaddr_t bind_any;

1a69a1a78cfaa86f3b68bbc965232b7876d4da2aDavid Lawrencechar *rootspace[BUFSIZE];

1a69a1a78cfaa86f3b68bbc965232b7876d4da2aDavid Lawrenceisc_buffer_t rootbuf;

b8ef99c3a7be2835b2395faff2d46e46f5c4adb3Michael Graffint sendcount = 0;

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graffint sockcount = 0;

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graffint ndots = -1;

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graffint tries = 3;

f4ce616539dd81322fa4db9676f42ef2e0a19031Michael Graffint lookup_counter = 0;

char fixeddomain[MXNAME] = "";

int exitcode = 9;

char keynametext[MXNAME];

char keysecret[MXNAME] = "";

dns_name_t keyname;

dns_tsig_keyring_t *keyring = NULL;

isc_buffer_t *namebuf = NULL;

dns_tsigkey_t *key = NULL;

isc_boolean_t validated = ISC_TRUE;

isc_entropy_t *entp = NULL;

extern isc_boolean_t isc_mem_debugging;

isc_boolean_t debugging = ISC_FALSE;

char *progname = NULL;

static isc_boolean_t

cancel_lookup(dig_lookup_t *lookup);

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;

isc_region_t r;

isc_buffer_remainingregion(b, &r);

printf("Printing a buffer with length %d\n", r.length);

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

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

if (len != 0 && len % 16 == 0)

printf("\n");

}

if (len % 16 != 0)

printf("\n");

}

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

va_list args;

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

va_start(args, format);

vfprintf(stderr, format, args);

va_end(args);

fprintf(stderr, "\n");

if (exitcode == 0)

exitcode = 8;

#ifdef NEVER

dighost_shutdown();

free_lists(exitcode);

if (mctx != NULL) {

if (isc_mem_debugging)

isc_mem_stats(mctx, stderr);

isc_mem_destroy(&mctx);

}

#endif

exit(exitcode);

}

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

va_list args;

if (debugging) {

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) {

exitcode = 1;

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

}

}

isclass(char *text) {

/*

const char *classlist[] = { "in", "hs", "chaos" };

const int numclasses = 3;

int i;

for (i = 0; i < numclasses; i++)

if (strcasecmp(text, classlist[i]) == 0)

return (ISC_TRUE);

return (ISC_FALSE);

}

istype(char *text) {

/*

const char *typelist[] = {"a", "ns", "md", "mf", "cname",

"soa", "mb", "mg", "mr", "null",

"wks", "ptr", "hinfo", "minfo",

"mx", "txt", "rp", "afsdb",

"x25", "isdn", "rt", "nsap",

"nsap_ptr", "sig", "key", "px",

"gpos", "aaaa", "loc", "nxt",

"srv", "naptr", "kx", "cert",

"a6", "dname", "opt", "unspec",

"tkey", "tsig", "axfr", "any"};

const int numtypes = 42;

int i;

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

if (strcasecmp(text, typelist[i]) == 0)

return (ISC_TRUE);

}

return (ISC_FALSE);

}

dig_lookup_t *

requeue_lookup(dig_lookup_t *lookold, isc_boolean_t servers) {

dig_lookup_t *looknew;

dig_server_t *s, *srv;

debug("requeue_lookup()");

if (free_now)

return(ISC_R_SUCCESS);

lookup_counter++;

if (lookup_counter > LOOKUP_LIMIT)

fatal("Too many lookups");

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

if (looknew == NULL)

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

__FILE__, __LINE__);

looknew->pending = ISC_FALSE;

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

strncpy(looknew->rttext, lookold-> rttext, 32);

strncpy(looknew->rctext, lookold-> rctext, 32);

looknew->namespace[0] = 0;

looknew->sendspace[0] = 0;

looknew->sendmsg = NULL;

looknew->name = NULL;

looknew->oname = NULL;

looknew->timer = NULL;

looknew->xfr_q = NULL;

looknew->doing_xfr = lookold->doing_xfr;

looknew->ixfr_serial = lookold->ixfr_serial;

looknew->defname = lookold->defname;

looknew->trace = lookold->trace;

looknew->trace_root = lookold->trace_root;

looknew->identify = lookold->identify;

looknew->udpsize = lookold->udpsize;

looknew->recurse = lookold->recurse;

looknew->aaonly = lookold->aaonly;

looknew->adflag = lookold->adflag;

looknew->cdflag = lookold->cdflag;

looknew->ns_search_only = lookold->ns_search_only;

looknew->origin = NULL;

looknew->querysig = NULL;

looknew->retries = tries;

looknew->nsfound = 0;

looknew->tcp_mode = lookold->tcp_mode;

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->new_search = ISC_FALSE;

ISC_LIST_INIT(looknew->my_server_list);

ISC_LIST_INIT(looknew->q);

looknew->use_my_server_list = ISC_FALSE;

if (servers) {

looknew->use_my_server_list = lookold->use_my_server_list;

if (looknew->use_my_server_list) {

s = ISC_LIST_HEAD(lookold->my_server_list);

while (s != NULL) {

srv = isc_mem_allocate(mctx,

sizeof(struct dig_server));

if (srv == NULL)

fatal("Memory allocation failure "

"in %s:%d", __FILE__, __LINE__);

strncpy(srv->servername, s->servername,

MXNAME);

ISC_LIST_ENQUEUE(looknew->my_server_list, srv,

link);

s = ISC_LIST_NEXT(s, link);

}

}

}

debug("before insertion, init@%p "

"-> %p, new@%p -> %p",

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

ISC_LIST_INSERTAFTER(lookup_list, lookold, looknew, link);

debug("after insertion, init -> "

"%p, new = %p, new -> %p",

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

return (looknew);

}

setup_system(void) {

char rcinput[MXNAME];

FILE *fp;

char *ptr;

dig_server_t *srv;

dig_searchlist_t *search;

dig_lookup_t *l;

isc_boolean_t get_servers;

isc_result_t result;

isc_buffer_t secretsrc;

isc_buffer_t secretbuf;

int secretsize;

unsigned char *secretstore;

isc_lex_t *lex = NULL;

isc_stdtime_t now;

debug("setup_system()");

if (fixeddomain[0] != 0) {

debug("using fixed domain %s", fixeddomain);

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

if (search == NULL)

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

__FILE__, __LINE__);

strncpy(search->origin, fixeddomain, MXNAME - 1);

ISC_LIST_PREPEND(search_list, search, link);

}

free_now = ISC_FALSE;

get_servers = ISC_TF(server_list.head == NULL);

fp = fopen(RESOLVCONF, "r");

if (fp != NULL) {

while (fgets(rcinput, MXNAME, fp) != 0) {

ptr = strtok(rcinput, " \t\r\n");

if (ptr != NULL) {

if (get_servers &&

strcasecmp(ptr, "nameserver") == 0) {

debug("got a nameserver line");

ptr = strtok(NULL, " \t\r\n");

if (ptr != NULL) {

srv = isc_mem_allocate(mctx,

sizeof(struct dig_server));

if (srv == NULL)

fatal("Memory "

"allocation "

"failure in "

"%s:%d",

__FILE__,

__LINE__);

strncpy((char *)srv->

servername,

ptr,

MXNAME - 1);

ISC_LIST_APPEND

(server_list,

srv, link);

}

} else if (strcasecmp(ptr, "options") == 0) {

ptr = strtok(NULL, " \t\r\n");

if (ptr != NULL) {

if((strncasecmp(ptr, "ndots:",

6) == 0) &&

(ndots == -1)) {

ndots = atoi(

&ptr[6]);

debug("ndots is "

"%d.",

ndots);

}

}

} else if ((strcasecmp(ptr, "search") == 0)

&& usesearch){

while ((ptr = strtok(NULL, " \t\r\n"))

!= NULL) {

search = isc_mem_allocate(

mctx, sizeof(struct

dig_server));

if (search == NULL)

fatal("Memory "

"allocation "

"failure in %s:"

"%d", __FILE__,

__LINE__);

strncpy(search->

origin,

ptr,

MXNAME - 1);

ISC_LIST_APPEND

(search_list,

search,

link);

}

} else if ((strcasecmp(ptr, "domain") == 0) &&

(fixeddomain[0] == 0 )){

while ((ptr = strtok(NULL, " \t\r\n"))

!= NULL) {

search = isc_mem_allocate(

mctx, sizeof(struct

dig_server));

if (search == NULL)

fatal("Memory "

"allocation "

"failure in %s:"

"%d", __FILE__,

__LINE__);

strncpy(search->

origin,

ptr,

MXNAME - 1);

ISC_LIST_PREPEND

(search_list,

search,

link);

}

}

}

}

fclose(fp);

}

if (ndots == -1)

ndots = 1;

if (server_list.head == NULL) {

srv = isc_mem_allocate(mctx, sizeof(dig_server_t));

if (srv == NULL)

fatal("Memory allocation failure");

strcpy(srv->servername, "127.0.0.1");

ISC_LIST_APPEND(server_list, srv, link);

}

for (l = ISC_LIST_HEAD(lookup_list) ;

l != NULL;

l = ISC_LIST_NEXT(l, link) ) {

l -> origin = ISC_LIST_HEAD(search_list);

}

if (keysecret[0] != 0) {

debug("keyring");

result = dns_tsigkeyring_create(mctx, &keyring);

check_result(result, "dns_tsigkeyring_create");

debug("buffer");

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

check_result(result, "isc_buffer_allocate");

debug("name");

dns_name_init(&keyname, NULL);

check_result(result, "dns_name_init");

isc_buffer_putstr(namebuf, keynametext);

secretsize = strlen(keysecret) * 3 / 4;

debug("secretstore");

secretstore = isc_mem_get(mctx, secretsize);

if (secretstore == NULL)

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

__FILE__, __LINE__);

isc_buffer_init(&secretsrc, keysecret, strlen(keysecret));

isc_buffer_add(&secretsrc, strlen(keysecret));

isc_buffer_init(&secretbuf, secretstore, secretsize);

debug("lex");

result = isc_lex_create(mctx, strlen(keysecret), &lex);

check_result(result, "isc_lex_create");

result = isc_lex_openbuffer(lex, &secretsrc);

check_result(result, "isc_lex_openbuffer");

result = isc_base64_tobuffer(lex, &secretbuf, -1);

if (result != ISC_R_SUCCESS) {

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

keynametext, isc_result_totext(result));

isc_lex_close(lex);

isc_lex_destroy(&lex);

goto SYSSETUP_FAIL;

}

secretsize = isc_buffer_usedlength(&secretbuf);

debug("close");

isc_lex_close(lex);

isc_lex_destroy(&lex);

isc_stdtime_get(&now);

debug("namefromtext");

result = dns_name_fromtext(&keyname, namebuf,

dns_rootname, ISC_FALSE,

namebuf);

if (result != ISC_R_SUCCESS) {

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

keynametext, dns_result_totext(result));

goto SYSSETUP_FAIL;

}

debug("tsigkey");

result = dns_tsigkey_create(&keyname, dns_tsig_hmacmd5_name,

secretstore, secretsize,

ISC_TRUE, NULL, now, now, mctx,

keyring, &key);

if (result != ISC_R_SUCCESS) {

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

keynametext, dns_result_totext(result));

}

isc_mem_put(mctx, secretstore, secretsize);

dns_name_invalidate(&keyname);

isc_buffer_free(&namebuf);

return;

SYSSETUP_FAIL:

isc_mem_put(mctx, secretstore, secretsize);

dns_name_invalidate(&keyname);

isc_buffer_free(&namebuf);

dns_tsigkeyring_destroy(&keyring);

return;

}

}

setup_libs(void) {

isc_result_t result;

debug("setup_libs()");

/*

srandom(getpid() + (int)&setup_libs);

result = isc_app_start();

check_result(result, "isc_app_start");

result = isc_net_probeipv4();

check_result(result, "isc_net_probeipv4");

result = isc_net_probeipv6();

if (result == ISC_R_SUCCESS)

have_ipv6 = ISC_TRUE;

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

check_result(result, "isc_mem_create");

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");

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;

}

static void

add_opt(dns_message_t *msg, isc_uint16_t udpsize) {

dns_rdataset_t *rdataset = NULL;

dns_rdatalist_t *rdatalist = NULL;

dns_rdata_t *rdata = NULL;

isc_result_t result;

debug("add_opt()");

result = dns_message_gettemprdataset(msg, &rdataset);

check_result(result, "dns_message_gettemprdataset");

dns_rdataset_init(rdataset);

result = dns_message_gettemprdatalist(msg, &rdatalist);

check_result(result, "dns_message_gettemprdatalist");

result = dns_message_gettemprdata(msg, &rdata);

check_result(result, "dns_message_gettemprdata");

debug("setting udp size of %d", udpsize);

rdatalist->type = dns_rdatatype_opt;

rdatalist->covers = 0;

rdatalist->rdclass = udpsize;

rdatalist->ttl = 0;

rdata->data = NULL;

rdata->length = 0;

ISC_LIST_INIT(rdatalist->rdata);

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

dns_rdatalist_tordataset(rdatalist, rdataset);

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_init(rdataset);

dns_rdataset_makequestion(rdataset, rdclass, rdtype);

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

}

static isc_boolean_t

check_next_lookup(dig_lookup_t *lookup) {

dig_lookup_t *next;

dig_query_t *query;

isc_boolean_t still_working=ISC_FALSE;

if (free_now)

return (ISC_TRUE);

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

for (query = ISC_LIST_HEAD(lookup->q);

query != NULL;

query = ISC_LIST_NEXT(query, link)) {

if (query->working) {

debug("still have a worker", stderr);

still_working=ISC_TRUE;

}

}

if (still_working)

return (ISC_FALSE);

debug("have %d retries left for %s",

lookup->retries-1, lookup->textname);

debug("lookup %s pending", lookup->pending ? "is" : "is not");

next = ISC_LIST_NEXT(lookup, link);

if (lookup->tcp_mode) {

if (next == NULL) {

debug("shutting down", stderr);

dighost_shutdown();

return (ISC_TRUE);

}

if (next->sendmsg == NULL) {

debug("setting up for TCP");

setup_lookup(next);

do_lookup(next);

}

} else {

if (!lookup->pending) {

if (next == NULL) {

debug("shutting down", stderr);

dighost_shutdown();

return (ISC_TRUE);

}

if (next->sendmsg == NULL) {

debug("setting up for UDP");

setup_lookup(next);

do_lookup(next);

}

} else {

if (lookup->retries > 1) {

debug("retrying");

lookup->retries --;

if (lookup->timer != NULL)

isc_timer_detach(&lookup->timer);

send_udp(lookup);

} else {

debug("cancelling");

return(cancel_lookup(lookup));

}

}

}

return (ISC_FALSE);

}

static void

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_name_t *name = NULL;

isc_result_t result, loopresult;

isc_buffer_t *b = NULL;

isc_region_t r;

isc_boolean_t success = ISC_FALSE;

int len;

debug("followup_lookup()");

if (free_now)

return;

result = dns_message_firstname(msg,section);

if (result != ISC_R_SUCCESS) {

debug("firstname returned %s",

isc_result_totext(result));

if ((section == DNS_SECTION_ANSWER) &&

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

followup_lookup (msg, query, DNS_SECTION_AUTHORITY);

return;

}

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

for (;;) {

name = NULL;

dns_message_currentname(msg, section, &name);

for (rdataset = ISC_LIST_HEAD(name->list);

rdataset != NULL;

rdataset = ISC_LIST_NEXT(rdataset, link)) {

loopresult = dns_rdataset_first(rdataset);

while (loopresult == ISC_R_SUCCESS) {

dns_rdataset_current(rdataset, &rdata);

debug("got rdata with type %d",

rdata.type);

if ((rdata.type == dns_rdatatype_ns) &&

(!query->lookup->trace_root ||

(query->lookup->nsfound < ROOTNS)))

{

query->lookup->nsfound++;

result = isc_buffer_allocate(mctx, &b,

BUFSIZE);

check_result(result,

"isc_buffer_allocate");

result = dns_rdata_totext(&rdata,

NULL,

b);

check_result(result,

"dns_rdata_totext");

isc_buffer_usedregion(b, &r);

len = r.length-1;

if (len >= MXNAME)

len = MXNAME-1;

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

debug("found NS %d %.*s",

(int)r.length, (int)r.length,

(char *)r.base);

if (!success) {

success = ISC_TRUE;

lookup_counter++;

lookup = requeue_lookup

(query->lookup,

ISC_FALSE);

lookup->doing_xfr = ISC_FALSE;

lookup->defname = ISC_FALSE;

lookup->use_my_server_list =

ISC_TRUE;

if (section ==

DNS_SECTION_ANSWER) {

lookup->trace =

ISC_FALSE;

lookup->ns_search_only =

ISC_FALSE;

}

else {

lookup->trace =

query->

lookup->trace;

lookup->ns_search_only =

query->

lookup->ns_search_only;

}

lookup->trace_root = ISC_FALSE;

ISC_LIST_INIT(lookup->

my_server_list);

}

srv = isc_mem_allocate(mctx,

sizeof(struct dig_server));

if (srv == NULL)

fatal("Memory allocation "

"failure in %s:%d",

__FILE__, __LINE__);

strncpy(srv->servername,

(char *)r.base, len);

srv->servername[len] = 0;

debug("adding server %s",

srv->servername);

ISC_LIST_APPEND

(lookup->my_server_list,

srv, link);

isc_buffer_free(&b);

}

loopresult = dns_rdataset_next(rdataset);

}

}

result = dns_message_nextname (msg, section);

if (result != ISC_R_SUCCESS)

break;

}

if ((lookup == NULL) && (section == DNS_SECTION_ANSWER) &&

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

followup_lookup(msg, query, DNS_SECTION_AUTHORITY);

}

static void

next_origin(dns_message_t *msg, dig_query_t *query) {

dig_lookup_t *lookup;

UNUSED(msg);

debug("next_origin()");

if (free_now)

return;

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

if (query->lookup->origin == NULL) {

/*

debug("made it to the root with nowhere to go");

return;

}

lookup = requeue_lookup(query->lookup, ISC_TRUE);

lookup->defname = ISC_FALSE;

lookup->origin = ISC_LIST_NEXT(query->lookup->origin, link);

}

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 = 1;

soa.retry = 1;

soa.expire = 1;

soa.minimum = 1;

soa.common.rdclass = dns_rdataclass_in;

soa.common.rdtype = dns_rdatatype_soa;

dns_name_init(&soa.origin, NULL);

dns_name_init(&soa.mname, NULL);

dns_name_clone(lookup->name, &soa.origin);

dns_name_clone(lookup->name, &soa.mname);

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

MXNAME);

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

check_result(result, "dns_message_gettemprdata");

result = dns_rdata_fromstruct(rdata, dns_rdataclass_in,

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 = dns_rdataclass_in;

rdatalist->covers = dns_rdatatype_soa;

rdatalist->ttl = 1;

ISC_LIST_INIT(rdatalist->rdata);

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

dns_rdataset_init(rdataset);

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);

}

setup_lookup(dig_lookup_t *lookup) {

isc_result_t result, res2;

int len;

dns_rdatatype_t rdtype;

dns_rdataclass_t rdclass;

dig_server_t *serv;

dig_query_t *query;

isc_region_t r;

isc_constregion_t tr;

isc_buffer_t b;

char store[MXNAME];

REQUIRE(lookup != NULL);

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

if (free_now)

return;

debug("setting up for looking up %s @%p->%p",

lookup->textname, lookup,

lookup->link.next);

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;

}

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->namespace,

sizeof(lookup->namespace));

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

sizeof(lookup->onamespace));

if ((count_dots(lookup->textname) >= ndots) || lookup->defname)

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

debug("lookup->origin = %p", lookup->origin);

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);

len = 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,

ISC_FALSE, &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 a legal name syntax (%s)",

lookup->origin->origin,

dns_result_totext(result));

}

if (!lookup->trace_root) {

len = strlen(lookup->textname);

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

isc_buffer_add(&b, len);

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

lookup->oname, ISC_FALSE,

&lookup->namebuf);

} else {

dns_name_clone(dns_rootname, lookup->name);

}

if (result != ISC_R_SUCCESS) {

dns_message_puttempname(lookup->sendmsg,

&lookup->name);

dns_message_puttempname(lookup->sendmsg,

&lookup->oname);

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

lookup->textname, dns_result_totext(result));

}

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

} else {

debug("using root origin");

if (!lookup->trace_root) {

len = strlen(lookup->textname);

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

isc_buffer_add(&b, len);

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

dns_rootname,

ISC_FALSE,

&lookup->namebuf);

} else {

dns_name_clone(dns_rootname, lookup->name);

}

if (result != ISC_R_SUCCESS) {

dns_message_puttempname(lookup->sendmsg,

&lookup->name);

isc_buffer_init(&b, store, MXNAME);

res2 = dns_name_totext(dns_rootname, ISC_FALSE, &b);

check_result(res2, "dns_name_totext");

isc_buffer_usedregion(&b, &r);

fatal("%s/%.*s is not a legal name syntax "

"(%s)", lookup->textname, (int)r.length,

(char *)r.base, dns_result_totext(result));

}

}

isc_buffer_init(&b, store, MXNAME);

dns_name_totext(lookup->name, ISC_FALSE, &b);

isc_buffer_usedregion(&b, &r);

trying((int)r.length, (char *)r.base, lookup);

ENSURE(dns_name_isabsolute(lookup->name));

if (lookup->rctext[0] == 0)

strcpy(lookup->rctext, "IN");

if (lookup->rttext[0] == 0)

strcpy(lookup->rttext, "A");

lookup->sendmsg->id = (unsigned short)(random() & 0xFFFF);

lookup->sendmsg->opcode = dns_opcode_query;

lookup->msgcounter = 0;

/*

if (lookup->recurse && !lookup->trace && !lookup->ns_search_only) {

debug("recursive query");

lookup->sendmsg->flags |= DNS_MESSAGEFLAG_RD;

}

if (lookup->aaonly) {

debug("AA query");

lookup->sendmsg->flags |= DNS_MESSAGEFLAG_AA;

}

if (lookup->adflag) {

debug("AD query");

lookup->sendmsg->flags |= DNS_MESSAGEFLAG_AD;

}

if (lookup->cdflag) {

debug("CD query");

lookup->sendmsg->flags |= DNS_MESSAGEFLAG_CD;

}

dns_message_addname(lookup->sendmsg, lookup->name,

DNS_SECTION_QUESTION);

if (lookup->trace_root) {

debug("doing trace_root");

tr.base = "SOA";

tr.length = 3;

} else {

tr.base = lookup->rttext;

tr.length = strlen(lookup->rttext);

}

debug("data type is %s", lookup->rttext);

result = dns_rdatatype_fromtext(&rdtype, (isc_textregion_t *)&tr);

check_result(result, "dns_rdatatype_fromtext");

if ((rdtype == dns_rdatatype_axfr) ||

(rdtype == dns_rdatatype_ixfr)) {

lookup->doing_xfr = ISC_TRUE;

/*

lookup->tcp_mode = ISC_TRUE;

}

if (lookup->trace_root) {

tr.base = "IN";

tr.length = 2;

} else {

tr.base = lookup->rctext;

tr.length = strlen(lookup->rctext);

}

result = dns_rdataclass_fromtext(&rdclass, (isc_textregion_t *)&tr);

check_result(result, "dns_rdataclass_fromtext");

add_question(lookup->sendmsg, lookup->name, rdclass, rdtype);

if (rdtype == dns_rdatatype_ixfr)

insert_soa(lookup);

if (key != NULL) {

debug("initializing keys");

result = dns_message_settsigkey(lookup->sendmsg, key);

check_result(result, "dns_message_settsigkey");

lookup->tsigctx = NULL;

lookup->querysig = NULL;

}

debug("starting to render the message");

isc_buffer_init(&lookup->sendbuf, lookup->sendspace, COMMSIZE);

result = dns_message_renderbegin(lookup->sendmsg, &lookup->sendbuf);

check_result(result, "dns_message_renderbegin");

if (lookup->udpsize > 0) {

add_opt(lookup->sendmsg, lookup->udpsize);

}

result = dns_message_rendersection(lookup->sendmsg,

DNS_SECTION_QUESTION, 0);

check_result(result, "dns_message_rendersection");

result = dns_message_rendersection(lookup->sendmsg,

DNS_SECTION_AUTHORITY, 0);

check_result(result, "dns_message_rendersection");

result = dns_message_renderend(lookup->sendmsg);

check_result(result, "dns_message_renderend");

debug("done rendering");

lookup->pending = ISC_FALSE;

if (lookup->use_my_server_list)

serv = ISC_LIST_HEAD(lookup->my_server_list);

else

serv = ISC_LIST_HEAD(server_list);

for (; serv != NULL;

serv = ISC_LIST_NEXT(serv, link)) {

query = isc_mem_allocate(mctx, sizeof(dig_query_t));

if (query == NULL)

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

__FILE__, __LINE__);

debug("create query %p linked to lookup %p",

query, lookup);

query->lookup = lookup;

query->working = ISC_FALSE;

query->waiting_connect = ISC_FALSE;

query->first_pass = ISC_TRUE;

query->first_soa_rcvd = ISC_FALSE;

query->second_rr_rcvd = ISC_FALSE;

query->second_rr_serial = 0;

query->servname = serv->servername;

ISC_LIST_INIT(query->sendlist);

ISC_LIST_INIT(query->recvlist);

ISC_LIST_INIT(query->lengthlist);

query->sock = NULL;

isc_buffer_init(&query->recvbuf, query->recvspace, COMMSIZE);

isc_buffer_init(&query->lengthbuf, query->lengthspace, 2);

isc_buffer_init(&query->slbuf, query->slspace, 2);

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

}

if (!ISC_LIST_EMPTY(lookup->q) && qr) {

printmessage(ISC_LIST_HEAD(lookup->q), lookup->sendmsg,

ISC_TRUE);

}

}

static void

send_done(isc_task_t *task, isc_event_t *event) {

UNUSED(task);

isc_event_free(&event);

debug("send_done()");

}

static isc_boolean_t

cancel_lookup(dig_lookup_t *lookup) {

dig_query_t *query = NULL;

debug("cancel_lookup()");

for (query = ISC_LIST_HEAD(lookup->q);

query != NULL;

query = ISC_LIST_NEXT(query, link)) {

if (query->working) {

debug("cancelling a worker");

}

if (query->sock != NULL) {

isc_socket_cancel(query->sock, global_task,

ISC_SOCKCANCEL_ALL);

isc_socket_detach(&query->sock);

sockcount--;

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

}

}

lookup->pending = ISC_FALSE;

lookup->retries = 0;

return(check_next_lookup(lookup));

}

static void

recv_done(isc_task_t *task, isc_event_t *event);

static void

connect_timeout(isc_task_t *task, isc_event_t *event);

send_udp(dig_lookup_t *lookup) {

dig_query_t *query;

isc_result_t result;

debug("send_udp()");

if (timeout != INT_MAX) {

isc_interval_set(&lookup->interval, timeout, 0);

result = isc_timer_create(timermgr, isc_timertype_once, NULL,

&lookup->interval, global_task,

connect_timeout, lookup,

&lookup->timer);

check_result(result, "isc_timer_create");

}

for (query = ISC_LIST_HEAD(lookup->q);

query != NULL;

query = ISC_LIST_NEXT(query, link)) {

debug("working on lookup %p, query %p",

query->lookup, query);

ISC_LIST_ENQUEUE(query->recvlist, &query->recvbuf, link);

query->working = ISC_TRUE;

debug("recving with lookup=%p, query=%p, sock=%p",

query->lookup, query,

query->sock);

result = isc_socket_recvv(query->sock, &query->recvlist, 1,

global_task, recv_done, query);

check_result(result, "isc_socket_recvv");

sendcount++;

debug("sent count number %d", sendcount);

ISC_LIST_ENQUEUE(query->sendlist, &lookup->sendbuf, link);

debug("sending a request");

result = isc_time_now(&query->time_sent);

check_result(result, "isc_time_now");

ENSURE(query->sock != NULL);

result = isc_socket_sendtov(query->sock, &query->sendlist,

global_task, send_done, query,

&query->sockaddr, NULL);

check_result(result, "isc_socket_sendtov");

}

}

static void

connect_timeout(isc_task_t *task, isc_event_t *event) {

dig_lookup_t *lookup=NULL;

dig_query_t *q=NULL;

isc_result_t result;

isc_buffer_t *b=NULL;

isc_region_t r;

REQUIRE(event->ev_type == ISC_TIMEREVENT_IDLE);

debug("connect_timeout()");

lookup = event->ev_arg;

isc_event_free(&event);

debug("buffer allocate connect_timeout");

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

check_result(result, "isc_buffer_allocate");

for (q = ISC_LIST_HEAD(lookup->q);

q != NULL;

q = ISC_LIST_NEXT(q, link)) {

if (q->working) {

if (!free_now) {

isc_buffer_clear(b);

result = isc_sockaddr_totext(&q->sockaddr, b);

check_result(result, "isc_sockaddr_totext");

isc_buffer_usedregion(b, &r);

if (q->lookup->retries > 1)

printf(";; Connection to server %.*s "

"for %s timed out. "

"Retrying %d.\n",

(int)r.length, r.base,

q->lookup->textname,

q->lookup->retries-1);

else {

printf(";; Connection to "

"server %.*s "

"for %s timed out. "

"Giving up.\n",

(int)r.length, r.base,

q->lookup->textname);

}

}

isc_socket_cancel(q->sock, task,

ISC_SOCKCANCEL_ALL);

}

}

ENSURE(lookup->timer != NULL);

isc_timer_detach(&lookup->timer);

isc_buffer_free(&b);

debug("done with connect_timeout()");