0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <config.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <stdlib.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <unistd.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyextern int h_errno;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <isc/app.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <isc/netdb.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <isc/string.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <isc/task.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <isc/timer.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <isc/util.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <dns/message.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <dns/rdata.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <dns/rdataclass.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <dns/rdataset.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <dns/rdatatype.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <dns/result.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony#include <dig/dig.h>

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyISC_LIST(dig_lookup_t) lookup_list;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunISC_LIST(dig_server_t) server_list;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunISC_LIST(dig_searchlist_t) search_list;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunisc_boolean_t tcp_mode = ISC_FALSE, have_ipv6 = ISC_FALSE,

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun free_now = ISC_FALSE, show_details = ISC_FALSE, usesearch=ISC_TRUE;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun#ifdef TWIDDLE

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunisc_boolean_t twiddle = ISC_FALSE;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun#endif

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunin_port_t port = 53;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgununsigned int timeout = 5;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunisc_mem_t *mctx = NULL;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunisc_taskmgr_t *taskmgr = NULL;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyisc_task_t *task = NULL;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyisc_timermgr_t *timermgr = NULL;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyisc_socketmgr_t *socketmgr = NULL;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonydns_messageid_t id;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonychar *rootspace[BUFSIZE];

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunisc_buffer_t rootbuf;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunint sendcount = 0;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunint ndots = -1;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyint tries = 3;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyint lookup_counter = 0;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonychar fixeddomain[MXNAME]="";

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonystatic void

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyfree_lists(void);

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonystatic int

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonycount_dots(char *string) {

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony char *s;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony int i=0;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony s = string;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun while (*s != 0) {

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun if (*s == '.')

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony i++;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun s++;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony }

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony return (i);

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony}

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonystatic void

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctonyhex_dump(isc_buffer_t *b) {

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony unsigned int len;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony isc_region_t r;

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun isc_buffer_remainingregion(b, &r);

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony

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

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

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

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

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun printf("\n");

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony }

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony if (len % 16 != 0)

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony printf("\n");

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony}

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgunfatal(char *format, ...) {

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun va_list args;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun va_start(args, format);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun vfprintf(stderr, format, args);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun va_end(args);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun fprintf(stderr, "\n");

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun#ifdef NEVER

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun isc_app_shutdown();

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun free_lists();

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun if (mctx != NULL) {

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun#ifdef MEMDEBUG

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun isc_mem_stats(mctx, stderr);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun#endif

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun isc_mem_destroy(&mctx);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun }

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun#endif

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun exit(1);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun}

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun#ifdef DEBUG

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgundebug(char *format, ...) {

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun va_list args;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun va_start(args, format);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun vfprintf(stderr, format, args);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun va_end(args);

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun fprintf(stderr, "\n");

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun}

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun#else

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgundebug(char *format, ...) {

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun va_list args;

d4cd628a85e7ba869d3564684abcccd9863a3aafnilgun UNUSED(args);

0f6bc9e2c8229996a73fb57ec6c45841346ebcb1pctony UNUSED(format);

}

#endif

check_result(isc_result_t result, char *msg) {

if (result != ISC_R_SUCCESS)

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

}

isclass(char *text) {

/* Tests if a field is a class, without needing isc libs

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

const int numclasses = 2;

int i;

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

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

return ISC_TRUE;

return ISC_FALSE;

}

istype(char *text) {

/* Tests if a field is a type, without needing isc libs

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;

}

#ifdef TWIDDLE

twiddlebuf(isc_buffer_t buf) {

isc_region_t r;

int len, pos, bit;

unsigned char bitfield;

int i, tw;

hex_dump(&buf);

tw=TWIDDLE;

printf ("Twiddling %d bits: ", tw);

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

isc_buffer_usedregion (&buf, &r);

len = r.length;

pos=(int)random();

pos = pos%len;

bit = (int)random()%8;

bitfield = 1 << bit;

printf ("%d@%03x ", bit, pos);

r.base[pos] ^= bitfield;

}

puts ("");

hex_dump(&buf);

}

#endif

static void

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;

if (fixeddomain[0]!=0) {

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

}

debug ("setup_system()");

id = getpid() << 8;

get_servers = (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);

}

}

static void

setup_libs(void) {

isc_result_t result;

isc_buffer_t b;

debug ("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, &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");

isc_buffer_init(&b, ".", 1);

isc_buffer_add(&b, 1);

}

static void

add_type(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_type()");

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

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)

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

if (lookup_counter >

LOOKUP_LIMIT)

fatal ("Too many "

"lookups.");

lookup = isc_mem_allocate

(mctx,

sizeof(struct

dig_lookup));

if (lookup == NULL)

fatal ("Memory "

"allocation "

"failure in %s:"

"%d", __FILE__,

__LINE__);

lookup->pending = ISC_FALSE;

strncpy (lookup->textname,

query->lookup->

textname, MXNAME);

strncpy (lookup->rttext,

query->lookup->

rttext, 32);

strncpy (lookup->rctext,

query->lookup->

rctext, 32);

lookup->namespace[0]=0;

lookup->sendspace[0]=0;

lookup->sendmsg=NULL;

lookup->name=NULL;

lookup->oname=NULL;

lookup->timer = NULL;

lookup->xfr_q = NULL;

lookup->origin = NULL;

lookup->doing_xfr = ISC_FALSE;

lookup->identify =

query->lookup->identify;

lookup->recurse =

query->lookup->

recurse;

lookup->ns_search_only =

query->lookup->

ns_search_only;

lookup->use_my_server_list =

ISC_TRUE;

if (section ==

DNS_SECTION_ANSWER)

lookup->trace =

ISC_FALSE;

else

lookup->trace =

query->

lookup->trace;

lookup->trace_root = ISC_FALSE;

lookup->retries = tries;

lookup->nsfound = 0;

lookup->comments =

query->lookup->

comments;

lookup->section_question =

query->lookup->

section_question;

lookup->section_answer =

query->lookup->

section_answer;

lookup->section_authority =

query->lookup->

section_authority;

lookup->section_additional =

query->lookup->

section_additional;

ISC_LIST_INIT(lookup->

my_server_list);

ISC_LIST_INIT(lookup->q);

debug ("Before insertion, "

"init@%lx "

"-> %lx, new@%lx "

"-> %lx",

(long int)query->lookup,

(long int)query->

lookup->link.next,

(long int)lookup,

(long int)lookup->

link.next);

ISC_LIST_INSERTAFTER(

lookup_list,

query->lookup,

lookup,

link);

debug ("After insertion, "

"init -> "

"%lx, new = %lx, "

"new -> %lx",

(long int)query->

lookup->link.next,

(long int)lookup,

(long int)lookup->

link.next);

}

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;

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)

followup_lookup(msg, query, DNS_SECTION_AUTHORITY);

}

static void

next_origin(dns_message_t *msg, dig_query_t *query) {

dig_lookup_t *lookup;

dig_server_t *srv;

dig_server_t *s;

UNUSED (msg);

debug ("next_origin()");

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

if (query->lookup->origin == NULL) { /*Then we just did rootorg;

debug ("Made it to the root whith nowhere to go.");

return;

}

lookup_counter++;

if (lookup_counter > LOOKUP_LIMIT)

fatal ("Too many lookups.");

lookup = isc_mem_allocate

(mctx, sizeof(struct dig_lookup));

if (lookup == NULL)

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

__FILE__, __LINE__);

lookup->pending = ISC_FALSE;

strncpy (lookup->textname, query->lookup-> textname, MXNAME);

strncpy (lookup->rttext, query->lookup-> rttext, 32);

strncpy (lookup->rctext, query->lookup-> rctext, 32);

lookup->namespace[0]=0;

lookup->sendspace[0]=0;

lookup->sendmsg=NULL;

lookup->name=NULL;

lookup->oname=NULL;

lookup->timer = NULL;

lookup->xfr_q = NULL;

lookup->doing_xfr = ISC_FALSE;

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

lookup->trace_root = query->lookup->trace_root;

lookup->identify = query->lookup->identify;

lookup->recurse = query->lookup->recurse;

lookup->ns_search_only = query->lookup->ns_search_only;

lookup->use_my_server_list = query->lookup->use_my_server_list;

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

lookup->retries = tries;

lookup->nsfound = 0;

lookup->comments = query->lookup->comments;

lookup->section_question = query->lookup->section_question;

lookup->section_answer = query->lookup->section_answer;

lookup->section_authority = query->lookup->section_authority;

lookup->section_additional = query->lookup->section_additional;

ISC_LIST_INIT(lookup->my_server_list);

ISC_LIST_INIT(lookup->q);

if (lookup->use_my_server_list) {

s = ISC_LIST_HEAD(query->lookup->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(lookup->my_server_list, srv,

link);

s = ISC_LIST_NEXT(s, link);

}

}

debug ("Before insertion, init@%ld "

"-> %ld, new@%ld "

"-> %ld", (long int)query->lookup,

(long int)query->lookup->link.next,

(long int)lookup, (long int)lookup->

link.next);

ISC_LIST_INSERTAFTER(lookup_list, query->

lookup, lookup,

link);

debug ("After insertion, init -> "

"%ld, new = %ld, "

"new -> %ld", (long int)query->

lookup->link.next,

(long int)lookup, (long int)lookup->

link.next);

}

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_textregion_t tr;

isc_buffer_t b;

char store[MXNAME];

debug("setup_lookup()");

debug("Setting up for looking up %s @%lx->%lx",

lookup->textname, (long int)lookup,

(long int)lookup->link.next);

result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER,

&lookup->sendmsg);

check_result(result, "dns_message_create");

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

isc_buffer_init(&lookup->onamebuf, lookup->onamespace, BUFSIZE);

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

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

debug ("lookup->origin = %lx", (long int)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("Aborting: %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 {

isc_buffer_init(&b, ". ", 1);

isc_buffer_add(&b, 1);

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

lookup->oname, ISC_FALSE,

&lookup->namebuf);

}

if (result != ISC_R_SUCCESS) {

dns_message_puttempname(lookup->sendmsg,

&lookup->name);

dns_message_puttempname(lookup->sendmsg,

&lookup->oname);

fatal("Aborting: %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 {

isc_buffer_init(&b, ". ", 1);

isc_buffer_add(&b, 1);

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

dns_rootname,

ISC_FALSE,

&lookup->namebuf);

}

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("Aborting: %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);

#ifdef DEBUG

if (dns_name_isabsolute(lookup->name))

debug ("This is an absolute name.");

else

debug ("This is a relative name (which is wrong).");

#endif

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

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

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

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

lookup->sendmsg->id = id++;

lookup->sendmsg->opcode = dns_opcode_query;

/* If this is a trace request, completely disallow recursion, since

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

debug ("Recursive query");

lookup->sendmsg->flags |= DNS_MESSAGEFLAG_RD;

}

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

DNS_SECTION_QUESTION);

if (lookup->trace_root) {

tr.base="SOA";

tr.length=3;

} else {

tr.base=lookup->rttext;

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

}

result = dns_rdatatype_fromtext(&rdtype, &tr);

check_result(result, "dns_rdatatype_fromtext");

if (rdtype == dns_rdatatype_axfr) {

lookup->doing_xfr = ISC_TRUE;

/*

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, &tr);

check_result(result, "dns_rdataclass_fromtext");

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

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

debug ("Starting to render the message");

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

check_result(result, "dns_message_renderbegin");

result = dns_message_rendersection(lookup->sendmsg,

DNS_SECTION_QUESTION, 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__);

query->lookup = lookup;

query->working = ISC_FALSE;

query->waiting_connect = ISC_FALSE;

query->first_pass = ISC_TRUE;

query->first_soa_rcvd = ISC_FALSE;

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

}

}

static void

send_done(isc_task_t *task, isc_event_t *event) {

UNUSED(task);

isc_event_free(&event);

debug("send_done()");

}

static void

cancel_lookup(dig_lookup_t *lookup) {

dig_query_t *query=NULL;

debug("cancel_lookup()");

if (!lookup->pending)

return;

lookup->pending = ISC_FALSE;

lookup->retries = 0;

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

query != NULL;

query = ISC_LIST_NEXT(query, link)) {

if (query->working) {

isc_socket_cancel(query->sock, task,

ISC_SOCKCANCEL_ALL);

}

}

}

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

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

result = isc_timer_create(timermgr, isc_timertype_once, NULL,

&lookup->interval, 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)) {

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

query->working = ISC_TRUE;

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

task, recv_done, query);

check_result(result, "isc_socket_recvv");

sendcount++;

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

#ifdef TWIDDLE

if (twiddle) {

twiddlebuf(lookup->sendbuf);

}

#endif

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

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

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;

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

isc_event_free(&event);

debug ("Done with connect_timeout()");

}

static void

tcp_length_done(isc_task_t *task, isc_event_t *event) {

isc_socketevent_t *sevent;

isc_buffer_t *b=NULL;

isc_region_t r;

isc_result_t result;

dig_query_t *query=NULL;

isc_uint16_t length;

REQUIRE(event->ev_type == ISC_SOCKEVENT_RECVDONE);

UNUSED(task);

debug("tcp_length_done()");

sevent = (isc_socketevent_t *)event;

query = event->ev_arg;

if (sevent->result == ISC_R_CANCELED) {

query->working = ISC_FALSE;

check_next_lookup(query->lookup);

isc_event_free(&event);

return;

}

if (sevent->result != ISC_R_SUCCESS) {

debug ("Buffer Allocate connect_timeout");

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

check_result(result, "isc_buffer_allocate");

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

check_result(result, "isc_sockaddr_totext");

isc_buffer_usedregion(b, &r);

printf("%.*s: %s\n", (int)r.length, r.base,

isc_result_totext(sevent->result));

isc_buffer_free(&b);

query->working = ISC_FALSE;

isc_socket_detach(&query->sock);

check_next_lookup(query->lookup);

isc_event_free(&event);

return;

}

b = ISC_LIST_HEAD(sevent->bufferlist);

ISC_LIST_DEQUEUE(sevent->bufferlist, &query->lengthbuf, link);

length = isc_buffer_getuint16(b);

if (length > COMMSIZE) {

isc_event_free (&event);

fatal ("Length of %X was longer than I can handle!",

length);

}

/*

isc_buffer_invalidate(&query->recvbuf);

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

ENSURE(ISC_LIST_EMPTY(query->recvlist));

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

result = isc_socket_recvv(query->sock, &query->recvlist, length, task,

recv_done, query);

check_result(result, "isc_socket_recvv");

debug("Resubmitted recv request with length %d", length);

isc_event_free(&event);

}

static void

launch_next_query(dig_query_t *query, isc_boolean_t include_question) {

isc_result_t result;

debug("launch_next_query()");

if (!query->lookup->pending) {

debug("Ignoring launch_next_query because !pending.");

isc_socket_detach(&query->sock);

query->working = ISC_FALSE;

query->waiting_connect = ISC_FALSE;

check_next_lookup(query->lookup);

return;

}

isc_buffer_clear(&query->slbuf);

isc_buffer_clear(&query->lengthbuf);

isc_buffer_putuint16(&query->slbuf, query->lookup->sendbuf.used);

ISC_LIST_ENQUEUE(query->sendlist, &query->slbuf, link);

if (include_question) {

#ifdef TWIDDLE

if (twiddle) {

twiddlebuf(query->lookup->sendbuf);

}

#endif

ISC_LIST_ENQUEUE(query->sendlist, &query->lookup->sendbuf,

link);

}

ISC_LIST_ENQUEUE(query->lengthlist, &query->lengthbuf, link);

result = isc_socket_recvv(query->sock, &query->lengthlist, 0, task,

tcp_length_done, query);

check_result(result, "isc_socket_recvv");

sendcount++;

if (!query->first_soa_rcvd) {

debug("Sending a request.");

result = isc_time_now(&query->time_sent);

check_result(result, "isc_time_now");

result = isc_socket_sendv(query->sock, &query->sendlist, task,

send_done, query);

check_result(result, "isc_socket_recvv");

}

query->waiting_connect = ISC_FALSE;

check_next_lookup(query->lookup);

return;

}

static void

connect_done(isc_task_t *task, isc_event_t *event) {

isc_result_t result;

isc_socketevent_t *sevent=NULL;

dig_query_t *query=NULL;

isc_buffer_t *b=NULL;

isc_region_t r;

UNUSED(task);

REQUIRE(event->ev_type == ISC_SOCKEVENT_CONNECT);

sevent = (isc_socketevent_t *)event;

query = sevent->ev_arg;

REQUIRE(query->waiting_connect);

query->waiting_connect = ISC_FALSE;

debug("connect_done()");

if (sevent->result != ISC_R_SUCCESS) {

debug ("Buffer Allocate connect_timeout");

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

check_result(result, "isc_buffer_allocate");

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

check_result(result, "isc_sockaddr_totext");

isc_buffer_usedregion(b, &r);

printf(";; Connection to server %.*s for %s failed: %s.\n",

(int)r.length, r.base, query->lookup->textname,

isc_result_totext(sevent->result));

isc_buffer_free(&b);

query->working = ISC_FALSE;

query->waiting_connect = ISC_FALSE;

check_next_lookup(query->lookup);

isc_event_free(&event);

return;

}

isc_event_free(&event);

launch_next_query(query, ISC_TRUE);

}

static isc_boolean_t

msg_contains_soa(dns_message_t *msg, dig_query_t *query) {

isc_result_t result;

dns_name_t *name=NULL;

debug("msg_contains_soa()");

result = dns_message_findname(msg, DNS_SECTION_ANSWER,

query->lookup->name, dns_rdatatype_soa,

0, &name, NULL);

if (result == ISC_R_SUCCESS) {

debug("Found SOA", stderr);

return (ISC_TRUE);

} else {

debug("Didn't find SOA, result=%d:%s",

result, dns_result_totext(result));

return (ISC_FALSE);

}

}

static void

recv_done(isc_task_t *task, isc_event_t *event) {

isc_socketevent_t *sevent = NULL;

dig_query_t *query = NULL;

isc_buffer_t *b = NULL;

dns_message_t *msg = NULL;

isc_result_t result;

isc_buffer_t ab;

char abspace[MXNAME];

isc_region_t r;

UNUSED (task);

debug("recv_done()");

if (free_now) {

debug("Bailing out, since freeing now.");

isc_event_free (&event);

return;

}

sendcount--;

debug("In recv_done, counter down to %d", sendcount);

REQUIRE(event->ev_type == ISC_SOCKEVENT_RECVDONE);

sevent = (isc_socketevent_t *)event;

query = event->ev_arg;

if (!query->lookup->pending && !query->lookup->ns_search_only) {

debug("No longer pending. Got %s",

isc_result_totext(sevent->result));

query->working = ISC_FALSE;

query->waiting_connect = ISC_FALSE;

cancel_lookup(query->lookup);

check_next_lookup(query->lookup);

isc_event_free(&event);

return;

}

if (sevent->result == ISC_R_SUCCESS) {

b = ISC_LIST_HEAD(sevent->bufferlist);

ISC_LIST_DEQUEUE(sevent->bufferlist, &query->recvbuf, link);

result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE,

&msg);

check_result(result, "dns_message_create");

result = dns_message_parse(msg, b, ISC_TRUE);

if (result != ISC_R_SUCCESS)

hex_dump(b);

check_result(result, "dns_message_parse");

if (query->lookup->xfr_q == NULL)

query->lookup->xfr_q = query;

if (query->lookup->xfr_q == query) {

if (query->lookup->trace) {

if (show_details || ((dns_message_firstname

(msg, DNS_SECTION_ANSWER)==

ISC_R_SUCCESS) &&

!query->lookup->trace_root)) {

printmessage(query, msg, ISC_TRUE);

}

if ((msg->rcode != 0) &&

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

next_origin(msg, query);

} else {

result = dns_message_firstname

(msg,DNS_SECTION_ANSWER);

if ((result != ISC_R_SUCCESS) ||

query->lookup->trace_root)

followup_lookup(msg, query,

DNS_SECTION_AUTHORITY);

}

} else if ((msg->rcode != 0) &&

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

next_origin(msg, query);

if (show_details) {

printmessage(query, msg, ISC_TRUE);

}

} else {

if (query->first_soa_rcvd &&

query->lookup->doing_xfr)

printmessage(query, msg, ISC_FALSE);

else

printmessage(query, msg, ISC_TRUE);

}

} else if (( dns_message_firstname(msg, DNS_SECTION_ANSWER)

== ISC_R_SUCCESS) &&

query->lookup->ns_search_only &&

!query->lookup->trace_root ) {

printmessage (query, msg, ISC_TRUE);

}

#ifdef DEBUG

if (query->lookup->pending)

debug("Still pending.");

#endif

if (query->lookup->doing_xfr) {

if (!query->first_soa_rcvd) {

debug("Not yet got first SOA");

if (!msg_contains_soa(msg, query)) {

puts("; Transfer failed. "

"Didn't start with SOA answer.");

query->working = ISC_FALSE;

cancel_lookup(query->lookup);

check_next_lookup (query->lookup);

isc_event_free (&event);

dns_message_destroy (&msg);

return;

}

else {