693d70f96fc2b3c1830580edcc29146afd6a9f61Mark Andrews

693d70f96fc2b3c1830580edcc29146afd6a9f61Mark Andrews

693d70f96fc2b3c1830580edcc29146afd6a9f61Mark Andrews#include <config.h>

693d70f96fc2b3c1830580edcc29146afd6a9f61Mark Andrews#include <stdlib.h>

693d70f96fc2b3c1830580edcc29146afd6a9f61Mark Andrews#include <time.h>

693d70f96fc2b3c1830580edcc29146afd6a9f61Mark Andrews#include <ctype.h>

693d70f96fc2b3c1830580edcc29146afd6a9f61Mark Andrews

693d70f96fc2b3c1830580edcc29146afd6a9f61Mark Andrews#include <isc/app.h>

#include <isc/netaddr.h>

#include <isc/parseint.h>

#include <isc/print.h>

#include <isc/string.h>

#include <isc/util.h>

#include <isc/task.h>

#include <dns/byaddr.h>

#include <dns/fixedname.h>

#include <dns/masterdump.h>

#include <dns/message.h>

#include <dns/name.h>

#include <dns/rdata.h>

#include <dns/rdataset.h>

#include <dns/rdatatype.h>

#include <dns/rdataclass.h>

#include <dns/result.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_ipv4, 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 int sendcount;

extern int ndots;

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_boolean_t debugging, memdebugging;

static char *batchname = NULL;

static FILE *batchfp = NULL;

static char *argv0;

static char domainopt[DNS_NAME_MAXTEXT];

static isc_boolean_t short_form = ISC_FALSE, printcmd = ISC_TRUE,

ip6_int = ISC_FALSE, plusquest = ISC_FALSE, pluscomm = ISC_FALSE,

multiline = ISC_FALSE, nottl = ISC_FALSE, noclass = 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",

"NOTIMP",

"REFUSED",

"YXDOMAIN",

"YXRRSET",

"NXRRSET",

"NOTAUTH",

"NOTZONE",

"RESERVED11",

"RESERVED12",

"RESERVED13",

"RESERVED14",

"RESERVED15",

"BADVERS"

};

extern char *progname;

static void

print_usage(FILE *fp) {

fputs(

" [ host [@local-server] {local-d-opt} [...]]\n", fp);

}

static void

usage(void) {

print_usage(stderr);

fputs("\nUse \"dig -h\" (or \"dig -h | more\") "

"for complete list of options\n", stderr);

exit(1);

}

static void

version(void) {

fputs("DiG " VERSION "\n", stderr);

}

static void

help(void) {

print_usage(stdout);

fputs(

" -v (print version and exit)\n",

stdout);

}

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

isc_uint64_t diff;

isc_time_t now;

time_t tnow;

char fromtext[ISC_SOCKADDR_FORMATSIZE];

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

TIME_NOW(&now);

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

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: %u records (messages %u)\n",

query->rr_count, query->msg_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(char *frm, dig_lookup_t *lookup) {

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

TIME_NOW(&now);

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_result_t result;

dns_messagetextflag_t flags;

isc_buffer_t *buf = NULL;

unsigned int len = OUTPUTBUF;

dns_master_style_t *style = NULL;

unsigned int styleflags = 0;

styleflags |= DNS_STYLEFLAG_REL_OWNER;

if (nottl)

styleflags |= DNS_STYLEFLAG_NO_TTL;

if (noclass)

styleflags |= DNS_STYLEFLAG_NO_CLASS;

if (multiline) {

styleflags |= DNS_STYLEFLAG_OMIT_OWNER;

styleflags |= DNS_STYLEFLAG_OMIT_CLASS;

styleflags |= DNS_STYLEFLAG_REL_DATA;

styleflags |= DNS_STYLEFLAG_OMIT_TTL;

styleflags |= DNS_STYLEFLAG_TTL;

styleflags |= DNS_STYLEFLAG_MULTILINE;

styleflags |= DNS_STYLEFLAG_COMMENT;

}

if (multiline || (nottl && noclass))

result = dns_master_stylecreate(&style, styleflags,

24, 24, 24, 32, 80, 8, mctx);

else if (nottl || noclass)

result = dns_master_stylecreate(&style, styleflags,

24, 24, 32, 40, 80, 8, mctx);

else

result = dns_master_stylecreate(&style, styleflags,

24, 32, 40, 48, 80, 8, mctx);

check_result(result, "dns_master_stylecreate");

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

if (!short_form)

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

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

printf(" aa");

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

printf(" tc");

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

printf(" rd");

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

printf(" ra");

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

printf(" ad");

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

printf(" cd");

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

}

}

repopulate_buffer:

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

{

result = dns_message_pseudosectiontotext(msg,

DNS_PSEUDOSECTION_OPT,

style, flags, buf);

if (result == ISC_R_NOSPACE) {

buftoosmall:

len += OUTPUTBUF;

isc_buffer_free(&buf);

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

if (result == ISC_R_SUCCESS)

goto repopulate_buffer;

else

goto cleanup;

}

check_result(result,

"dns_message_pseudosectiontotext");

}

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

if (!short_form) {

result = dns_message_sectiontotext(msg,

DNS_SECTION_QUESTION,

style, flags, buf);

if (result == ISC_R_NOSPACE)

goto buftoosmall;

check_result(result, "dns_message_sectiontotext");

}

}

if (query->lookup->section_answer) {

if (!short_form) {

result = dns_message_sectiontotext(msg,

DNS_SECTION_ANSWER,

style, flags, buf);

if (result == ISC_R_NOSPACE)

goto buftoosmall;

check_result(result, "dns_message_sectiontotext");

} else {

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

if (result == ISC_R_NOSPACE)

goto buftoosmall;

check_result(result, "short_answer");

}

}

if (query->lookup->section_authority) {

if (!short_form) {

result = dns_message_sectiontotext(msg,

DNS_SECTION_AUTHORITY,

style, flags, buf);

if (result == ISC_R_NOSPACE)

goto buftoosmall;

check_result(result, "dns_message_sectiontotext");

}

}

if (query->lookup->section_additional) {

if (!short_form) {

result = dns_message_sectiontotext(msg,

DNS_SECTION_ADDITIONAL,

style, flags, buf);

if (result == ISC_R_NOSPACE)

goto buftoosmall;

check_result(result, "dns_message_sectiontotext");

/*

if (headers) {

result = dns_message_pseudosectiontotext(

msg,

DNS_PSEUDOSECTION_TSIG,

style, flags, buf);

if (result == ISC_R_NOSPACE)

goto buftoosmall;

check_result(result,

"dns_message_pseudosectiontotext");

result = dns_message_pseudosectiontotext(

msg,

DNS_PSEUDOSECTION_SIG0,

style, flags, buf);

if (result == ISC_R_NOSPACE)

goto buftoosmall;

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

cleanup:

if (style != NULL)

dns_master_styledestroy(&style, mctx);

return (result);

}

static void

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

int i;

int remaining;

static isc_boolean_t first = ISC_TRUE;

char append[MXNAME];

if (printcmd) {

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

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

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

first?"\n":"");

i = 1;

while (i < argc) {

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

remaining = sizeof(lookup->cmdline) -

strlen(lookup->cmdline) - 1;

strncat(lookup->cmdline, append, remaining);

}

remaining = sizeof(lookup->cmdline) -

strlen(lookup->cmdline) - 1;

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

if (first) {

snprintf(append, sizeof(append),

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

short_form ? "short_form" : "",

printcmd ? "printcmd" : "");

first = ISC_FALSE;

remaining = sizeof(lookup->cmdline) -

strlen(lookup->cmdline) - 1;

strncat(lookup->cmdline, append, remaining);

}

}

}

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_uint(char *arg, const char *desc, isc_uint32_t max) {

isc_result_t result;

isc_uint32_t tmp;

result = isc_parse_uint32(&tmp, arg, 10);

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

result = ISC_R_RANGE;

if (result != ISC_R_SUCCESS)

fatal("%s '%s': %s", desc, arg, isc_result_totext(result));

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;

}

#define FULLCHECK(A) \

do { \

size_t _l = strlen(cmd); \

if (_l >= sizeof(A) || strncasecmp(cmd, A, _l) != 0) \

goto invalid_option; \

} while (0)

#define FULLCHECK2(A, B) \

do { \

size_t _l = strlen(cmd); \

if ((_l >= sizeof(A) || strncasecmp(cmd, A, _l) != 0) && \

(_l >= sizeof(B) || strncasecmp(cmd, B, _l) != 0)) \

goto invalid_option; \

} while (0)

switch (cmd[0]) {

case 'a':

switch (cmd[1]) {

case 'a': /* aaflag */

FULLCHECK("aaflag");

lookup->aaonly = state;

break;

case 'd':

switch (cmd[2]) {

case 'd': /* additional */

FULLCHECK("additional");

lookup->section_additional = state;

break;

case 'f': /* adflag */

FULLCHECK("adflag");

lookup->adflag = state;

break;

default:

goto invalid_option;

}

break;

case 'l': /* all */

FULLCHECK("all");

lookup->section_question = state;

lookup->section_authority = state;

lookup->section_answer = state;

lookup->section_additional = state;

lookup->comments = state;

lookup->stats = state;

printcmd = state;

break;

case 'n': /* answer */

FULLCHECK("answer");

lookup->section_answer = state;

break;

case 'u': /* authority */

FULLCHECK("authority");

lookup->section_authority = state;

break;

default:

goto invalid_option;

}

break;

case 'b':

switch (cmd[1]) {

case 'e':/* besteffort */

FULLCHECK("besteffort");

lookup->besteffort = state;

break;

case 'u':/* bufsize */

FULLCHECK("bufsize");

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

lookup->udpsize = (isc_uint16_t) parse_uint(value,

"buffer size", COMMSIZE);

if (lookup->udpsize > COMMSIZE)

lookup->udpsize = COMMSIZE;

break;

default:

goto invalid_option;

}

break;

case 'c':

switch (cmd[1]) {

case 'd':/* cdflag */

FULLCHECK("cdflag");

lookup->cdflag = state;

break;

case 'l': /* cl */

FULLCHECK("cl");

noclass = !state;

break;

case 'm': /* cmd */

FULLCHECK("cmd");

printcmd = state;

break;

case 'o': /* comments */

FULLCHECK("comments");

lookup->comments = state;

if (lookup == default_lookup)

pluscomm = state;

break;

default:

goto invalid_option;

}

break;

case 'd':

switch (cmd[1]) {

case 'e': /* defname */

FULLCHECK("defname");

usesearch = state;

break;

case 'n': /* dnssec */

FULLCHECK("dnssec");

lookup->dnssec = state;

break;

case 'o': /* domain */

FULLCHECK("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 */

FULLCHECK("fail");

lookup->servfail_stops = state;

break;

case 'i':

switch (cmd[1]) {

case 'd': /* identify */

FULLCHECK("identify");

lookup->identify = state;

break;

case 'g': /* ignore */

default: /* Inherets default for compatibility */

FULLCHECK("ignore");

lookup->ignore = ISC_TRUE;

}

break;

case 'm': /* multiline */

FULLCHECK("multiline");

multiline = state;

break;

case 'n':

switch (cmd[1]) {

case 'd': /* ndots */

FULLCHECK("ndots");

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

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

break;

case 's': /* nssearch */

FULLCHECK("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_ns;

lookup->rdtypeset = ISC_TRUE;

short_form = ISC_TRUE;

}

break;

default:

goto invalid_option;

}

break;

case 'q':

switch (cmd[1]) {

case 'r': /* qr */

FULLCHECK("qr");

qr = state;

break;

case 'u': /* question */

FULLCHECK("question");

lookup->section_question = state;

if (lookup == default_lookup)

plusquest = state;

break;

default:

goto invalid_option;

}

break;

case 'r':

switch (cmd[1]) {

case 'e':

switch (cmd[2]) {

case 'c': /* recurse */

FULLCHECK("recurse");

lookup->recurse = state;

break;

case 't': /* retry / retries */

FULLCHECK2("retry", "retries");

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

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

MAXTRIES - 1);

lookup->retries++;

break;

default:

goto invalid_option;

}

break;

default:

goto invalid_option;

}

break;

case 's':

switch (cmd[1]) {

case 'e': /* search */

FULLCHECK("search");

usesearch = state;

break;

case 'h': /* short */

FULLCHECK("short");

short_form = state;

if (state) {

printcmd = ISC_FALSE;

lookup->section_additional = ISC_FALSE;

lookup->section_answer = ISC_TRUE;

lookup->section_authority = ISC_FALSE;

lookup->section_question = ISC_FALSE;

lookup->comments = ISC_FALSE;

lookup->stats = ISC_FALSE;

}

break;

case 't': /* stats */

FULLCHECK("stats");

lookup->stats = state;

break;

default:

goto invalid_option;

}

break;

case 't':

switch (cmd[1]) {

case 'c': /* tcp */

FULLCHECK("tcp");

if (!is_batchfile)

lookup->tcp_mode = state;

break;

case 'i': /* timeout */

FULLCHECK("timeout");

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

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

if (timeout == 0)

timeout = 1;

break;

case 'r':

switch (cmd[2]) {

case 'a': /* trace */

FULLCHECK("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 */

FULLCHECK("tries");

if (value == NULL)

goto need_value;

if (!state)

goto invalid_option;

lookup->retries = parse_uint(value, "tries",

MAXTRIES);

if (lookup->retries == 0)

lookup->retries = 1;

break;

default:

goto invalid_option;

}

break;

case 't': /* ttlid */

FULLCHECK("ttlid");

nottl = !state;

break;

default:

goto invalid_option;

}

break;

case 'v':

FULLCHECK("vc");

if (!is_batchfile)

lookup->tcp_mode = state;

break;

default:

invalid_option:

need_value:

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

option);

usage();

}

return;

}

static isc_boolean_t

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

isc_boolean_t *open_type_class,

isc_boolean_t *firstarg,

int argc, char **argv)

{

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

struct in_addr in4;

struct in6_addr in6;

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':

help();

exit(0);

break;

case 'i':

ip6_int = ISC_TRUE;

return (ISC_FALSE);

case 'm': /* memdebug */

/* memdebug is handled in preparse_args() */

return (ISC_FALSE);

case 'n':

/* deprecated */

return (ISC_FALSE);

case 'v':

version();

exit(0);

break;

}

if (value == NULL)

goto invalid_option;

switch (cmd) {

case 'b':

if (have_ipv6 && inet_pton(AF_INET6, value, &in6) == 1)

isc_sockaddr_fromin6(&bind_address, &in6, 0);

else if (have_ipv4 && inet_pton(AF_INET, value, &in4) == 1)

isc_sockaddr_fromin(&bind_address, &in4, 0);

else

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

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 = (in_port_t) parse_uint(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 &&

rdtype == dns_rdatatype_ixfr)

{

result = DNS_R_UNKNOWN;

}

}

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_uint(&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) {

usage();

}

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

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

ptr = next_token(&value, "");

if (ptr == NULL)

usage();

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

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

return (value_from_next);

case 'x':

*lookup = clone_lookup(default_lookup, ISC_TRUE);

if (get_reverse(textname, value, ip6_int, ISC_FALSE)

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

if (!(*lookup)->rdtypeset)

(*lookup)->rdtype = dns_rdatatype_ptr;

if (!(*lookup)->rdclassset)

(*lookup)->rdclass = dns_rdataclass_in;

(*lookup)->new_search = ISC_TRUE;

if (*lookup && *firstarg)

{

printgreeting(argc, argv, *lookup);

*firstarg = ISC_FALSE;

}

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

usage();

}

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

/*

INSIST(batchfp == NULL);

homedir = getenv("HOME");

if (homedir != NULL) {

unsigned int n;

n = snprintf(rcfile, sizeof(rcfile), "%s/.digrc",

homedir);

if (n < sizeof(rcfile))

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,

&firstarg, argc, argv)) {

rc--;

rv++;

}

} else {

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

&lookup, &open_type_class,

&firstarg, argc, argv)) {

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