e4bea1f716ba373cce734278c3067746f6a0fd59Mark Andrews

4be63b1fd8c18dbeca1648d6cf22fa14f057a469David Lawrence

4be63b1fd8c18dbeca1648d6cf22fa14f057a469David Lawrence#include <config.h>

ab023a65562e62b85a824509d829b6fad87e00b1Rob Austein#include <stdlib.h>

e4bea1f716ba373cce734278c3067746f6a0fd59Mark Andrews#include <time.h>

ab023a65562e62b85a824509d829b6fad87e00b1Rob Austein#include <ctype.h>

ab023a65562e62b85a824509d829b6fad87e00b1Rob Austein

e4bea1f716ba373cce734278c3067746f6a0fd59Mark Andrews#include <isc/app.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <isc/netaddr.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <isc/print.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <isc/string.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <isc/util.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <isc/task.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <dns/byaddr.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <dns/fixedname.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <dns/message.h>

b186f1ab91faf6d46d102ecbfd55cbdb7e24feeeMark Andrews#include <dns/name.h>

4be63b1fd8c18dbeca1648d6cf22fa14f057a469David Lawrence#include <dns/rdata.h>

4be63b1fd8c18dbeca1648d6cf22fa14f057a469David Lawrence#include <dns/rdataset.h>

#include <dns/rdatatype.h>

#include <dns/rdataclass.h>

#include <dig/dig.h>

extern ISC_LIST(dig_lookup_t) lookup_list;

extern dig_serverlist_t server_list;

extern ISC_LIST(dig_searchlist_t) search_list;

#define ADD_STRING(b, s) { \

if (strlen(s) >= isc_buffer_availablelength(b)) \

return (ISC_R_NOSPACE); \

else \

isc_buffer_putstr(b, s); \

}

extern isc_boolean_t have_ipv6, specified_source,

usesearch, qr;

extern in_port_t port;

extern unsigned int timeout;

extern isc_mem_t *mctx;

extern dns_messageid_t id;

extern char *rootspace[BUFSIZE];

extern isc_buffer_t rootbuf;

extern int sendcount;

extern int ndots;

extern int tries;

extern int lookup_counter;

extern int exitcode;

extern isc_sockaddr_t bind_address;

extern char keynametext[MXNAME];

extern char keyfile[MXNAME];

extern char keysecret[MXNAME];

extern dns_tsigkey_t *key;

extern isc_boolean_t validated;

extern isc_taskmgr_t *taskmgr;

extern isc_task_t *global_task;

extern isc_boolean_t free_now;

dig_lookup_t *default_lookup = NULL;

extern isc_uint32_t rr_limit;

extern isc_boolean_t debugging, memdebugging;

char *batchname = NULL;

FILE *batchfp = NULL;

char *argv0;

char domainopt[DNS_NAME_MAXTEXT];

isc_boolean_t short_form = ISC_FALSE, printcmd = ISC_TRUE,

nibble = ISC_FALSE, plusquest = ISC_FALSE, pluscomm = ISC_FALSE;

isc_uint16_t bufsize = 0;

isc_boolean_t forcecomment = ISC_FALSE;

static const char *opcodetext[] = {

"QUERY",

"IQUERY",

"STATUS",

"RESERVED3",

"NOTIFY",

"UPDATE",

"RESERVED6",

"RESERVED7",

"RESERVED8",

"RESERVED9",

"RESERVED10",

"RESERVED11",

"RESERVED12",

"RESERVED13",

"RESERVED14",

"RESERVED15"

};

static const char *rcodetext[] = {

"NOERROR",

"FORMERR",

"SERVFAIL",

"NXDOMAIN",

"NOTIMPL",

"REFUSED",

"YXDOMAIN",

"YXRRSET",

"NXRRSET",

"NOTAUTH",

"NOTZONE",

"RESERVED11",

"RESERVED12",

"RESERVED13",

"RESERVED14",

"RESERVED15",

"BADVERS"

};

extern char *progname;

static void

show_usage(void) {

fputs(

, stderr);

}

received(int bytes, isc_sockaddr_t *from, dig_query_t *query) {

isc_uint64_t diff;

isc_time_t now;

isc_result_t result;

time_t tnow;

char fromtext[ISC_SOCKADDR_FORMATSIZE];

isc_sockaddr_format(from, fromtext, sizeof(fromtext));

result = isc_time_now(&now);

check_result(result, "isc_time_now");

if (query->lookup->stats) {

diff = isc_time_microdiff(&now, &query->time_sent);

printf(";; Query time: %ld msec\n", (long int)diff/1000);

printf(";; SERVER: %s(%s)\n", fromtext, query->servname);

time(&tnow);

printf(";; WHEN: %s", ctime(&tnow));

if (query->lookup->doing_xfr) {

printf(";; XFR size: %d records\n",

query->rr_count);

} else {

printf(";; MSG SIZE rcvd: %d\n", bytes);

}

if (key != NULL) {

if (!validated)

puts(";; WARNING -- Some TSIG could not "

"be validated");

}

if ((key == NULL) && (keysecret[0] != 0)) {

puts(";; WARNING -- TSIG key was not used.");

}

puts("");

} else if (query->lookup->identify && !short_form) {

diff = isc_time_microdiff(&now, &query->time_sent);

printf(";; Received %u bytes from %s(%s) in %d ms\n\n",

bytes, fromtext, query->servname,

(int)diff/1000);

}

}

trying(int frmsize, char *frm, dig_lookup_t *lookup) {

UNUSED(frmsize);

UNUSED(frm);

UNUSED(lookup);

}

static isc_result_t

say_message(dns_rdata_t *rdata, dig_query_t *query, isc_buffer_t *buf) {

isc_result_t result;

isc_uint64_t diff;

isc_time_t now;

char store[sizeof("12345678901234567890")];

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

result = dns_rdatatype_totext(rdata->type, buf);

if (result != ISC_R_SUCCESS)

return (result);

ADD_STRING(buf, " ");

}

result = dns_rdata_totext(rdata, NULL, buf);

check_result(result, "dns_rdata_totext");

if (query->lookup->identify) {

result = isc_time_now(&now);

if (result != ISC_R_SUCCESS)

return (result);

diff = isc_time_microdiff(&now, &query->time_sent);

ADD_STRING(buf, " from server ");

ADD_STRING(buf, query->servname);

snprintf(store, 19, " in %d ms.", (int)diff/1000);

ADD_STRING(buf, store);

}

ADD_STRING(buf, "\n");

return (ISC_R_SUCCESS);

}

static isc_result_t

short_answer(dns_message_t *msg, dns_messagetextflag_t flags,

isc_buffer_t *buf, dig_query_t *query)

{

dns_name_t *name;

dns_rdataset_t *rdataset;

isc_buffer_t target;

isc_result_t result, loopresult;

dns_name_t empty_name;

char t[4096];

dns_rdata_t rdata = DNS_RDATA_INIT;

UNUSED(flags);

dns_name_init(&empty_name, NULL);

result = dns_message_firstname(msg, DNS_SECTION_ANSWER);

if (result == ISC_R_NOMORE)

return (ISC_R_SUCCESS);

else if (result != ISC_R_SUCCESS)

return (result);

for (;;) {

name = NULL;

dns_message_currentname(msg, DNS_SECTION_ANSWER, &name);

isc_buffer_init(&target, t, sizeof(t));

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

result = say_message(&rdata, query,

buf);

check_result(result, "say_message");

loopresult = dns_rdataset_next(rdataset);

dns_rdata_reset(&rdata);

}

}

result = dns_message_nextname(msg, DNS_SECTION_ANSWER);

if (result == ISC_R_NOMORE)

break;

else if (result != ISC_R_SUCCESS)

return (result);

}

return (ISC_R_SUCCESS);

}

printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {

isc_boolean_t did_flag = ISC_FALSE;

isc_result_t result;

dns_messagetextflag_t flags;

isc_buffer_t *buf = NULL;

unsigned int len = OUTPUTBUF;

if (query->lookup->cmdline[0] != 0) {

fputs(query->lookup->cmdline, stdout);

query->lookup->cmdline[0]=0;

}

debug("printmessage(%s %s %s)", headers ? "headers" : "noheaders",

query->lookup->comments ? "comments" : "nocomments",

short_form ? "short_form" : "long_form");

flags = 0;

if (!headers) {

flags |= DNS_MESSAGETEXTFLAG_NOHEADERS;

flags |= DNS_MESSAGETEXTFLAG_NOCOMMENTS;

}

if (!query->lookup->comments)

flags |= DNS_MESSAGETEXTFLAG_NOCOMMENTS;

result = ISC_R_SUCCESS;

result = isc_buffer_allocate(mctx, &buf, len);

check_result(result, "isc_buffer_allocate");

if (query->lookup->comments && !short_form) {

if (query->lookup->cmdline[0] != 0)

printf("; %s\n", query->lookup->cmdline);

if (msg == query->lookup->sendmsg)

printf(";; Sending:\n");

else

printf(";; Got answer:\n");

if (headers) {

printf(";; ->>HEADER<<- opcode: %s, status: %s, "

"id: %u\n",

opcodetext[msg->opcode], rcodetext[msg->rcode],

msg->id);

printf(";; flags: ");

if ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) {

printf("qr");

did_flag = ISC_TRUE;

}

if ((msg->flags & DNS_MESSAGEFLAG_AA) != 0) {

printf("%saa", did_flag ? " " : "");

did_flag = ISC_TRUE; }

if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) {

printf("%stc", did_flag ? " " : "");

did_flag = ISC_TRUE;

}

if ((msg->flags & DNS_MESSAGEFLAG_RD) != 0) {

printf("%srd", did_flag ? " " : "");

did_flag = ISC_TRUE;

}

if ((msg->flags & DNS_MESSAGEFLAG_RA) != 0) {

printf("%sra", did_flag ? " " : "");

did_flag = ISC_TRUE;

}

if ((msg->flags & DNS_MESSAGEFLAG_AD) != 0) {

printf("%sad", did_flag ? " " : "");

did_flag = ISC_TRUE;

}

if ((msg->flags & DNS_MESSAGEFLAG_CD) != 0) {

printf("%scd", did_flag ? " " : "");

did_flag = ISC_TRUE;

}

printf("; QUERY: %u, ANSWER: %u, "

"AUTHORITY: %u, ADDITIONAL: %u\n",

msg->counts[DNS_SECTION_QUESTION],

msg->counts[DNS_SECTION_ANSWER],

msg->counts[DNS_SECTION_AUTHORITY],

msg->counts[DNS_SECTION_ADDITIONAL]);

}

}

buftoosmall:

if (query->lookup->comments && headers && !short_form)

{

result = dns_message_pseudosectiontotext(msg,

DNS_PSEUDOSECTION_OPT,

flags, buf);

if (result == ISC_R_NOSPACE) {

len += OUTPUTBUF;

isc_buffer_free(&buf);

result = isc_buffer_allocate(mctx, &buf, len);

if (result == ISC_R_SUCCESS)

goto buftoosmall;

}

check_result(result,

"dns_message_pseudosectiontotext");

}

if (query->lookup->section_question && headers) {

if (!short_form) {

result = dns_message_sectiontotext(msg,

DNS_SECTION_QUESTION,

flags, buf);

if (result == ISC_R_NOSPACE) {

len += OUTPUTBUF;

isc_buffer_free(&buf);

result = isc_buffer_allocate(mctx, &buf, len);

if (result == ISC_R_SUCCESS)

goto buftoosmall;

}

check_result(result, "dns_message_sectiontotext");

}

}

if (query->lookup->section_answer) {

if (!short_form) {

result = dns_message_sectiontotext(msg,

DNS_SECTION_ANSWER,

flags, buf);

if (result == ISC_R_NOSPACE) {

len += OUTPUTBUF;

isc_buffer_free(&buf);

result = isc_buffer_allocate(mctx, &buf, len);

if (result == ISC_R_SUCCESS)

goto buftoosmall;

}

check_result(result, "dns_message_sectiontotext");

} else {

result = short_answer(msg, flags, buf, query);

check_result(result, "short_answer");

}

}

if (query->lookup->section_authority) {

if (!short_form) {

result = dns_message_sectiontotext(msg,

DNS_SECTION_AUTHORITY,

flags, buf);

if (result == ISC_R_NOSPACE) {

len += OUTPUTBUF;

isc_buffer_free(&buf);

result = isc_buffer_allocate(mctx, &buf, len);

if (result == ISC_R_SUCCESS)

goto buftoosmall;

}

check_result(result, "dns_message_sectiontotext");

}

}

if (query->lookup->section_additional) {

if (!short_form) {

result = dns_message_sectiontotext(msg,

DNS_SECTION_ADDITIONAL,

flags, buf);

if (result == ISC_R_NOSPACE) {

len += OUTPUTBUF;

isc_buffer_free(&buf);

result = isc_buffer_allocate(mctx, &buf, len);

if (result == ISC_R_SUCCESS)

goto buftoosmall;

}

check_result(result, "dns_message_sectiontotext");

/*

if (headers) {

result = dns_message_pseudosectiontotext(

msg,

DNS_PSEUDOSECTION_TSIG,

flags, buf);

check_result(result,

"dns_message_pseudosectiontotext");

result = dns_message_pseudosectiontotext(

msg,

DNS_PSEUDOSECTION_SIG0,

flags, buf);

check_result(result,

"dns_message_pseudosectiontotext");

}

}

}

if (headers && query->lookup->comments && !short_form)

printf("\n");

printf("%.*s", (int)isc_buffer_usedlength(buf),

(char *)isc_buffer_base(buf));

isc_buffer_free(&buf);

return (result);

}

static void

printgreeting(int argc, char **argv, dig_lookup_t *lookup) {

int i;

static isc_boolean_t first = ISC_TRUE;

char append[MXNAME];

if (printcmd) {

snprintf(lookup->cmdline, sizeof(lookup->cmdline),

"%s; <<>> DiG " VERSION " <<>>",

first?"\n":"");

i = 1;

while (i < argc) {

snprintf(append, sizeof(append), " %s", argv[i++]);

strncat(lookup->cmdline, append,

sizeof (lookup->cmdline));

}

strncat(lookup->cmdline, "\n", sizeof (lookup->cmdline));

if (first) {

snprintf(append, sizeof (append),

";; global options: %s %s\n",

short_form ? "short_form" : "",

printcmd ? "printcmd" : "");

first = ISC_FALSE;

strncat(lookup->cmdline, append,

sizeof (lookup->cmdline));

}

}

}

static void

reorder_args(int argc, char *argv[]) {

int i, j;

char *ptr;

int end;

debug("reorder_args()");

end = argc - 1;

while (argv[end][0] == '@') {

end--;

if (end == 0)

return;

}

debug("arg[end]=%s", argv[end]);

for (i = 1; i < end - 1; i++) {

if (argv[i][0] == '@') {

debug("arg[%d]=%s", i, argv[i]);

ptr = argv[i];

for (j = i + 1; j < end; j++) {

debug("Moving %s to %d", argv[j], j - 1);

argv[j - 1] = argv[j];

}

debug("moving %s to end, %d", ptr, end - 1);

argv[end - 1] = ptr;

end--;

if (end < 1)

return;

}

}

}

static isc_uint32_t

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

char *endp;

isc_uint32_t tmp;

tmp = strtoul(arg, &endp, 10);

if (*endp != '\0')

fatal("%s '%s' must be numeric", desc, arg);

if (tmp > max)

fatal("%s '%s' out of range", desc, arg);

return (tmp);

}

static void

plus_option(char *option, isc_boolean_t is_batchfile,

dig_lookup_t *lookup)

{

char option_store[256];

char *cmd, *value, *ptr;

isc_boolean_t state = ISC_TRUE;

strncpy(option_store, option, sizeof(option_store));

option_store[sizeof(option_store)-1]=0;

ptr = option_store;

cmd=next_token(&ptr,"=");

if (cmd == NULL) {

printf(";; Invalid option %s\n",option_store);

return;

}

value=ptr;

if (strncasecmp(cmd,"no",2)==0) {

cmd += 2;

state = ISC_FALSE;

}

switch (cmd[0]) {

case 'a':

switch (cmd[1]) {

case 'a': /* aaflag */

lookup->aaonly = state;

break;

case 'd':

switch (cmd[2]) {

case 'd': /* additional */

lookup->section_additional = state;

break;

case 'f': /* adflag */

lookup->adflag = state;

break;

default:

goto invalid_option;

}

break;

case 'l': /* all */

lookup->section_question = state;

lookup->section_authority = state;

lookup->section_answer = state;

lookup->section_additional = state;

lookup->comments = state;

break;

case 'n': /* answer */

lookup->section_answer = state;

break;

case 'u': /* authority */

lookup->section_authority = state;

break;

default:

goto invalid_option;

}

break;

case 'b':

switch (cmd[1]) {

case 'e':/* besteffort */

lookup->besteffort = state;

break;

case 'u':/* bufsize */

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

lookup->udpsize = parse_int(value, "buffer size",

COMMSIZE);

if (lookup->udpsize <= 0)

lookup->udpsize = 0;

if (lookup->udpsize > COMMSIZE)

lookup->udpsize = COMMSIZE;

break;

default:

goto invalid_option;

}

break;

case 'c':

switch (cmd[1]) {

case 'd':/* cdflag */

lookup->cdflag = state;

break;

case 'm': /* cmd */

printcmd = state;

break;

case 'o': /* comments */

lookup->comments = state;

if (lookup == default_lookup)

pluscomm = state;

break;

default:

goto invalid_option;

}

break;

case 'd':

switch (cmd[1]) {

case 'e': /* defname */

usesearch = state;

break;

case 'n': /* dnssec */

lookup->dnssec = state;

break;

case 'o': /* domain */

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

strncpy(domainopt, value, sizeof(domainopt));

domainopt[sizeof(domainopt)-1] = '\0';

break;

default:

goto invalid_option;

}

break;

case 'f': /* fail */

lookup->servfail_stops = state;

break;

case 'i':

switch (cmd[1]) {

case 'd': /* identify */

lookup->identify = state;

break;

case 'g': /* ignore */

default: /* Inherets default for compatibility */

lookup->ignore = ISC_TRUE;

}

break;

case 'n':

switch (cmd[1]) {

case 'd': /* ndots */

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

ndots = parse_int(value, "ndots", MAXNDOTS);

if (ndots < 0)

ndots = 0;

break;

case 's': /* nssearch */

lookup->ns_search_only = state;

if (state) {

lookup->trace_root = ISC_TRUE;

lookup->recurse = ISC_FALSE;

lookup->identify = ISC_TRUE;

lookup->stats = ISC_FALSE;

lookup->comments = ISC_FALSE;

lookup->section_additional = ISC_FALSE;

lookup->section_authority = ISC_FALSE;

lookup->section_question = ISC_FALSE;

lookup->rdtype = dns_rdatatype_soa;

lookup->rdtypeset = ISC_TRUE;

short_form = ISC_TRUE;

}

break;

default:

goto invalid_option;

}

break;

case 'q':

switch (cmd[1]) {

case 'r': /* qr */

qr = state;

break;

case 'u': /* question */

lookup->section_question = state;

if (lookup == default_lookup)

plusquest = state;

break;

default:

goto invalid_option;

}

break;

case 'r':

switch (cmd[1]) {

case 'e': /* recurse */

lookup->recurse = state;

break;

case 'r': /* rrlimit */

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

rr_limit = parse_int(value, "rrlimit", MAXRRLIMIT);

break;

default:

goto invalid_option;

}

break;

case 's':

switch (cmd[1]) {

case 'e': /* search */

usesearch = state;

break;

case 'h': /* short */

short_form = state;

if (state) {

printcmd = ISC_FALSE;

lookup->section_additional = ISC_FALSE;

lookup->section_authority = ISC_FALSE;

lookup->section_question = ISC_FALSE;

lookup->comments = ISC_FALSE;

lookup->stats = ISC_FALSE;

}

break;

case 't': /* stats */

lookup->stats = state;

break;

default:

goto invalid_option;

}

break;

case 't':

switch (cmd[1]) {

case 'c': /* tcp */

if (!is_batchfile)

lookup->tcp_mode = state;

break;

case 'i': /* timeout */

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

timeout = parse_int(value, "timeout", MAXTIMEOUT);

if (timeout <= 0)

timeout = 1;

break;

case 'r':

switch (cmd[2]) {

case 'a': /* trace */

lookup->trace = state;

lookup->trace_root = state;

if (state) {

lookup->recurse = ISC_FALSE;

lookup->identify = ISC_TRUE;

lookup->comments = ISC_FALSE;

lookup->stats = ISC_FALSE;

lookup->section_additional = ISC_FALSE;

lookup->section_authority = ISC_TRUE;

lookup->section_question = ISC_FALSE;

}

break;

case 'i': /* tries */

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

lookup->retries = parse_int(value, "retries",

MAXTRIES);

if (lookup->retries <= 0)

lookup->retries = 1;

break;

default:

goto invalid_option;

}

break;

default:

goto invalid_option;

}

break;

case 'v':

#ifdef DNS_OPT_NEWCODES_LIVE

switch (cmd[1]) {

default:

case 'c': /* vc, and default */

#endif /* DNS_OPT_NEWCODES_LIVE */

if (!is_batchfile)

lookup->tcp_mode = state;

break;

#ifdef DNS_OPT_NEWCODES_LIVE

case 'i': /* view */

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

strncpy(lookup->viewname, value, MXNAME);

break;

}

break;

case 'z': /* zone */

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

strncpy(lookup->zonename, value, MXNAME);

break;

#endif /* DNS_OPT_NEWCODES_LIVE */

default:

invalid_option:

need_value:

fprintf(stderr, "Invalid option: +%s\n",

option);

show_usage();

exit(1);

}

return;

}

static isc_boolean_t

dash_option(char *option, char *next, dig_lookup_t **lookup,

isc_boolean_t *open_type_class)

{

char cmd, *value, *ptr;

isc_result_t result;

isc_boolean_t value_from_next;

isc_textregion_t tr;

dns_rdatatype_t rdtype;

dns_rdataclass_t rdclass;

char textname[MXNAME];

isc_boolean_t orig_rdtypeset;

dns_rdatatype_t orig_rdtype;

isc_uint32_t orig_ixfr_serial;

isc_boolean_t orig_section_question;

isc_boolean_t orig_comments;

dns_rdataclass_t orig_rdclass;

isc_boolean_t orig_rdclassset;

cmd = option[0];

if (strlen(option) > 1) {

value_from_next = ISC_FALSE;

value = &option[1];

}

else {

value_from_next = ISC_TRUE;

value = next;

}

switch (cmd) {

case 'd':

debugging = ISC_TRUE;

return (ISC_FALSE);

case 'h':

show_usage();

exit(0);

break;

case 'm': /* memdebug */

/* memdebug is handled in preparse_args() */

return (ISC_FALSE);

case 'n':

nibble = ISC_TRUE;

return (ISC_FALSE);

}

if (value == NULL)

goto invalid_option;

switch (cmd) {

case 'b':

get_address(value, 0, &bind_address);

specified_source = ISC_TRUE;

return (value_from_next);

case 'c':

if ((*lookup)->rdclassset) {

fprintf(stderr, ";; Warning, extra class option\n");

}

*open_type_class = ISC_FALSE;

tr.base = value;

tr.length = strlen(value);

result = dns_rdataclass_fromtext(&rdclass,

(isc_textregion_t *)&tr);

if (result == ISC_R_SUCCESS) {

(*lookup)->rdclass = rdclass;

(*lookup)->rdclassset = ISC_TRUE;

}

else

fprintf(stderr, ";; Warning, ignoring "

"invalid class %s\n",

value);

return (value_from_next);

case 'f':

batchname = value;

return (value_from_next);

case 'k':

strncpy(keyfile, value, sizeof(keyfile));

keyfile[sizeof(keyfile)-1]=0;

return (value_from_next);

case 'p':

port = parse_int(value, "port number", MAXPORT);

return (value_from_next);

case 't':

*open_type_class = ISC_FALSE;

if (strncasecmp(value, "ixfr=", 5) == 0) {

rdtype = dns_rdatatype_ixfr;

result = ISC_R_SUCCESS;

}

else

{

tr.base = value;

tr.length = strlen(value);

result = dns_rdatatype_fromtext(&rdtype,

(isc_textregion_t *)&tr);

}

if (result == ISC_R_SUCCESS) {

if ((*lookup)->rdtypeset) {

fprintf(stderr, ";; Warning, "

"extra type option\n");

}

if (rdtype == dns_rdatatype_ixfr) {

(*lookup)->rdtype = dns_rdatatype_ixfr;

(*lookup)->rdtypeset = ISC_TRUE;

(*lookup)->ixfr_serial =

parse_int(&value[5], "serial number",

MAXSERIAL);

(*lookup)->section_question = plusquest;

(*lookup)->comments = pluscomm;

}

else

{

(*lookup)->rdtype = rdtype;

(*lookup)->rdtypeset = ISC_TRUE;

if (rdtype == dns_rdatatype_axfr) {

(*lookup)->section_question = plusquest;

(*lookup)->comments = pluscomm;

}

(*lookup)->ixfr_serial = ISC_FALSE;

}

} else

fprintf(stderr, ";; Warning, ignoring "

"invalid type %s\n",

value);

return (value_from_next);

case 'y':

ptr = next_token(&value,":");

if (ptr == NULL) {

show_usage();

exit(1);

}

strncpy(keynametext, ptr, sizeof(keynametext));

keynametext[sizeof(keynametext)-1]=0;

ptr = next_token(&value, "");

if (ptr == NULL) {

show_usage();

exit(1);

}

strncpy(keysecret, ptr, sizeof(keysecret));

keysecret[sizeof(keysecret)-1]=0;

return (value_from_next);

case 'x':

orig_rdtypeset = (*lookup)->rdtypeset;

orig_rdtype = (*lookup)->rdtype;

orig_ixfr_serial = (*lookup)->ixfr_serial;

orig_section_question = (*lookup)->section_question;

orig_comments = (*lookup)->comments;

orig_rdclassset = (*lookup)->rdclassset;

orig_rdclass = (*lookup)->rdclass;

*lookup = clone_lookup(default_lookup, ISC_TRUE);

if (get_reverse(textname, value, nibble) == ISC_R_SUCCESS) {

strncpy((*lookup)->textname, textname,

sizeof((*lookup)->textname));

debug("looking up %s", (*lookup)->textname);

(*lookup)->trace_root = ISC_TF((*lookup)->trace ||

(*lookup)->ns_search_only);

(*lookup)->nibble = nibble;

if (!orig_rdtypeset)

(*lookup)->rdtype = dns_rdatatype_ptr;

else

{

(*lookup)->rdtypeset = orig_rdtypeset;

(*lookup)->rdtype = orig_rdtype;

(*lookup)->ixfr_serial = orig_ixfr_serial;

(*lookup)->section_question = orig_section_question;

(*lookup)->comments = orig_comments;

}

if (!orig_rdclassset)

(*lookup)->rdclass = dns_rdataclass_in;

else

{

(*lookup)->rdclassset = orig_rdclassset;

(*lookup)->rdclass = orig_rdclass;

}

(*lookup)->new_search = ISC_TRUE;

ISC_LIST_APPEND(lookup_list, *lookup, link);

} else {

fprintf(stderr, "Invalid IP address %s\n", value);

exit(1);

}

return (value_from_next);

invalid_option:

default:

fprintf(stderr, "Invalid option: -%s\n", option);

show_usage();

exit(1);

}

return (ISC_FALSE);

}

static void

preparse_args(int argc, char **argv) {

int rc;

char **rv;

rc = argc;

rv = argv;

for (rc--, rv++; rc > 0; rc--, rv++) {

if (strcmp(rv[0], "-m") == 0) {

memdebugging = ISC_TRUE;

isc_mem_debugging = ISC_MEM_DEBUGTRACE |

ISC_MEM_DEBUGRECORD;

return;

}

}

}

static void

parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,

int argc, char **argv) {

isc_result_t result;

isc_textregion_t tr;

isc_boolean_t firstarg = ISC_TRUE;

dig_server_t *srv = NULL;

dig_lookup_t *lookup = NULL;

dns_rdatatype_t rdtype;

dns_rdataclass_t rdclass;

isc_boolean_t open_type_class = ISC_TRUE;

char batchline[MXNAME];

int bargc;

char *bargv[64];

int rc;

char **rv;

#ifndef NOPOSIX

char *homedir;

char rcfile[256];

#endif

char *input;

/*

debug("parse_args()");

if (!is_batchfile) {

debug("making new lookup");

default_lookup = make_empty_lookup();

#ifndef NOPOSIX

/*

homedir = getenv("HOME");

if (homedir != NULL)

snprintf(rcfile, sizeof(rcfile), "%s/.digrc", homedir);

else

strcpy(rcfile, ".digrc");

batchfp = fopen(rcfile, "r");

if (batchfp != NULL) {

while (fgets(batchline, sizeof(batchline),

batchfp) != 0) {

debug("config line %s", batchline);

bargc = 1;

input = batchline;

bargv[bargc] = next_token(&input, " \t\r\n");

while ((bargv[bargc] != NULL) &&

(bargc < 62)) {

bargc++;

bargv[bargc] = next_token(&input, " \t\r\n");

}

bargv[0] = argv[0];

argv0 = argv[0];

reorder_args(bargc, (char **)bargv);

parse_args(ISC_TRUE, ISC_TRUE, bargc,

(char **)bargv);

}

fclose(batchfp);

}

#endif

}

lookup = default_lookup;

rc = argc;

rv = argv;

for (rc--, rv++; rc > 0; rc--, rv++) {

debug("main parsing %s", rv[0]);

if (strncmp(rv[0], "%", 1) == 0)

break;

if (strncmp(rv[0], "@", 1) == 0) {

srv = make_server(&rv[0][1]);

ISC_LIST_APPEND(lookup->my_server_list,

srv, link);

} else if (rv[0][0] == '+') {

plus_option(&rv[0][1], is_batchfile,

lookup);

} else if (rv[0][0] == '-') {

if (rc <= 1) {

if (dash_option(&rv[0][1], NULL,

&lookup, &open_type_class)) {

rc--;

rv++;

}

} else {

if (dash_option(&rv[0][1], rv[1],

&lookup, &open_type_class)) {

rc--;

rv++;

}

}

} else {

/*

if (open_type_class) {

if (strncmp(rv[0], "ixfr=", 5) == 0) {

rdtype = dns_rdatatype_ixfr;

result = ISC_R_SUCCESS;

}

else

{

tr.base = rv[0];

tr.length = strlen(rv[0]);

result = dns_rdatatype_fromtext(&rdtype,

(isc_textregion_t *)&tr);

}

if (result == ISC_R_SUCCESS)

{

if (lookup->rdtypeset) {

fprintf(stderr, ";; Warning, "

"extra type option\n");

}

if (rdtype == dns_rdatatype_ixfr) {

lookup->rdtype = dns_rdatatype_ixfr;

lookup->rdtypeset = ISC_TRUE;

lookup->ixfr_serial =

parse_int(&rv[0][5],

"serial number",

MAXSERIAL);

lookup->section_question = plusquest;

lookup->comments = pluscomm;

}

else

{

lookup->rdtype = rdtype;

lookup->rdtypeset = ISC_TRUE;

if (rdtype == dns_rdatatype_axfr) {

lookup->section_question =

plusquest;

lookup->comments = pluscomm;

}

lookup->ixfr_serial = ISC_FALSE;

}

continue;

}

result = dns_rdataclass_fromtext(&rdclass,

(isc_textregion_t *)&tr);

if (result == ISC_R_SUCCESS) {

if (lookup->rdclassset) {

fprintf(stderr, ";; Warning, "

"extra class option\n");

}

lookup->rdclass = rdclass;

lookup->rdclassset = ISC_TRUE;

continue;

}

}

if (!config_only) {

lookup = clone_lookup(default_lookup,

ISC_TRUE);

if (firstarg) {

printgreeting(argc, argv, lookup);

firstarg = ISC_FALSE;

}

strncpy(lookup->textname, rv[0],

sizeof(lookup->textname));

lookup->textname[sizeof(lookup->textname)-1]=0;

lookup->trace_root = ISC_TF(lookup->trace ||

lookup->ns_search_only);

lookup->new_search = ISC_TRUE;

ISC_LIST_APPEND(lookup_list, lookup, link);

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

}

/* XXX Error message */

}

}

/*

if ((batchname != NULL) && !(is_batchfile)) {

if (strcmp(batchname, "-") == 0)

batchfp = stdin;

else

batchfp = fopen(batchname, "r");

if (batchfp == NULL) {