1/* 2 * Copyright (C) 2004-2007, 2009-2011 Internet Systems Consortium, Inc. ("ISC") 3 * Copyright (C) 2000-2003 Internet Software Consortium. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH 10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, 12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 15 * PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18/* $Id: host.c,v 1.124.40.3 2011/03/11 06:46:59 marka Exp $ */ 19 20/*! \file */ 21 22#include <config.h> 23#include <stdlib.h> 24#include <limits.h> 25 26#ifdef HAVE_LOCALE_H 27#include <locale.h> 28#endif 29 30#ifdef WITH_IDN 31#include <idn/result.h> 32#include <idn/log.h> 33#include <idn/resconf.h> 34#include <idn/api.h> 35#endif 36 37#include <isc/app.h> 38#include <isc/commandline.h> 39#include <isc/netaddr.h> 40#include <isc/print.h> 41#include <isc/string.h> 42#include <isc/util.h> 43#include <isc/task.h> 44#include <isc/stdlib.h> 45 46#include <dns/byaddr.h> 47#include <dns/fixedname.h> 48#include <dns/message.h> 49#include <dns/name.h> 50#include <dns/rdata.h> 51#include <dns/rdataclass.h> 52#include <dns/rdataset.h> 53#include <dns/rdatatype.h> 54#include <dns/rdatastruct.h> 55 56#include <dig/dig.h> 57 58static isc_boolean_t short_form = ISC_TRUE, listed_server = ISC_FALSE; 59static isc_boolean_t default_lookups = ISC_TRUE; 60static int seen_error = -1; 61static isc_boolean_t list_addresses = ISC_TRUE; 62static dns_rdatatype_t list_type = dns_rdatatype_a; 63static isc_boolean_t printed_server = ISC_FALSE; 64 65static const char *opcodetext[] = { 66 "QUERY", 67 "IQUERY", 68 "STATUS", 69 "RESERVED3", 70 "NOTIFY", 71 "UPDATE", 72 "RESERVED6", 73 "RESERVED7", 74 "RESERVED8", 75 "RESERVED9", 76 "RESERVED10", 77 "RESERVED11", 78 "RESERVED12", 79 "RESERVED13", 80 "RESERVED14", 81 "RESERVED15" 82}; 83 84static const char *rcodetext[] = { 85 "NOERROR", 86 "FORMERR", 87 "SERVFAIL", 88 "NXDOMAIN", 89 "NOTIMP", 90 "REFUSED", 91 "YXDOMAIN", 92 "YXRRSET", 93 "NXRRSET", 94 "NOTAUTH", 95 "NOTZONE", 96 "RESERVED11", 97 "RESERVED12", 98 "RESERVED13", 99 "RESERVED14", 100 "RESERVED15", 101 "BADVERS" 102}; 103 104struct rtype { 105 unsigned int type; 106 const char *text; 107}; 108 109struct rtype rtypes[] = { 110 { 1, "has address" }, 111 { 2, "name server" }, 112 { 5, "is an alias for" }, 113 { 11, "has well known services" }, 114 { 12, "domain name pointer" }, 115 { 13, "host information" }, 116 { 15, "mail is handled by" }, 117 { 16, "descriptive text" }, 118 { 19, "x25 address" }, 119 { 20, "ISDN address" }, 120 { 24, "has signature" }, 121 { 25, "has key" }, 122 { 28, "has IPv6 address" }, 123 { 29, "location" }, 124 { 0, NULL } 125}; 126 127static char * 128rcode_totext(dns_rcode_t rcode) 129{ 130 static char buf[sizeof("?65535")]; 131 union { 132 const char *consttext; 133 char *deconsttext; 134 } totext; 135 136 if (rcode >= (sizeof(rcodetext)/sizeof(rcodetext[0]))) { 137 snprintf(buf, sizeof(buf), "?%u", rcode); 138 totext.deconsttext = buf; 139 } else 140 totext.consttext = rcodetext[rcode]; 141 return totext.deconsttext; 142} 143 144ISC_PLATFORM_NORETURN_PRE static void 145show_usage(void) ISC_PLATFORM_NORETURN_POST; 146 147static void 148show_usage(void) { 149 fputs( 150"Usage: host [-aCdlriTwv] [-c class] [-N ndots] [-t type] [-W time]\n" 151" [-R number] [-m flag] hostname [server]\n" 152" -a is equivalent to -v -t ANY\n" 153" -c specifies query class for non-IN data\n" 154" -C compares SOA records on authoritative nameservers\n" 155" -d is equivalent to -v\n" 156" -l lists all hosts in a domain, using AXFR\n" 157" -i IP6.INT reverse lookups\n" 158" -N changes the number of dots allowed before root lookup is done\n" 159" -r disables recursive processing\n" 160" -R specifies number of retries for UDP packets\n" 161" -s a SERVFAIL response should stop query\n" 162" -t specifies the query type\n" 163" -T enables TCP/IP mode\n" 164" -v enables verbose output\n" 165" -w specifies to wait forever for a reply\n" 166" -W specifies how long to wait for a reply\n" 167" -4 use IPv4 query transport only\n" 168" -6 use IPv6 query transport only\n" 169" -m set memory debugging flag (trace|record|usage)\n", stderr); 170 exit(1); 171} 172 173void 174dighost_shutdown(void) { 175 isc_app_shutdown(); 176} 177 178void 179received(int bytes, isc_sockaddr_t *from, dig_query_t *query) { 180 isc_time_t now; 181 int diff; 182 183 if (!short_form) { 184 char fromtext[ISC_SOCKADDR_FORMATSIZE]; 185 isc_sockaddr_format(from, fromtext, sizeof(fromtext)); 186 TIME_NOW(&now); 187 diff = (int) isc_time_microdiff(&now, &query->time_sent); 188 printf("Received %u bytes from %s in %d ms\n", 189 bytes, fromtext, diff/1000); 190 } 191} 192 193void 194trying(char *frm, dig_lookup_t *lookup) { 195 UNUSED(lookup); 196 197 if (!short_form) 198 printf("Trying \"%s\"\n", frm); 199} 200 201static void 202say_message(dns_name_t *name, const char *msg, dns_rdata_t *rdata, 203 dig_query_t *query) 204{ 205 isc_buffer_t *b = NULL; 206 char namestr[DNS_NAME_FORMATSIZE]; 207 isc_region_t r; 208 isc_result_t result; 209 unsigned int bufsize = BUFSIZ; 210 211 dns_name_format(name, namestr, sizeof(namestr)); 212 retry: 213 result = isc_buffer_allocate(mctx, &b, bufsize); 214 check_result(result, "isc_buffer_allocate"); 215 result = dns_rdata_totext(rdata, NULL, b); 216 if (result == ISC_R_NOSPACE) { 217 isc_buffer_free(&b); 218 bufsize *= 2; 219 goto retry; 220 } 221 check_result(result, "dns_rdata_totext"); 222 isc_buffer_usedregion(b, &r); 223 if (query->lookup->identify_previous_line) { 224 printf("Nameserver %s:\n\t", 225 query->servname); 226 } 227 printf("%s %s %.*s", namestr, 228 msg, (int)r.length, (char *)r.base); 229 if (query->lookup->identify) { 230 printf(" on server %s", query->servname); 231 } 232 printf("\n"); 233 isc_buffer_free(&b); 234} 235#ifdef DIG_SIGCHASE 236/* Just for compatibility : not use in host program */ 237isc_result_t 238printrdataset(dns_name_t *owner_name, dns_rdataset_t *rdataset, 239 isc_buffer_t *target) 240{ 241 UNUSED(owner_name); 242 UNUSED(rdataset); 243 UNUSED(target); 244 return(ISC_FALSE); 245} 246#endif 247static isc_result_t 248printsection(dns_message_t *msg, dns_section_t sectionid, 249 const char *section_name, isc_boolean_t headers, 250 dig_query_t *query) 251{ 252 dns_name_t *name, *print_name; 253 dns_rdataset_t *rdataset; 254 dns_rdata_t rdata = DNS_RDATA_INIT; 255 isc_buffer_t target; 256 isc_result_t result, loopresult; 257 isc_region_t r; 258 dns_name_t empty_name; 259 char t[4096]; 260 isc_boolean_t first; 261 isc_boolean_t no_rdata; 262 263 if (sectionid == DNS_SECTION_QUESTION) 264 no_rdata = ISC_TRUE; 265 else 266 no_rdata = ISC_FALSE; 267 268 if (headers) 269 printf(";; %s SECTION:\n", section_name); 270 271 dns_name_init(&empty_name, NULL); 272 273 result = dns_message_firstname(msg, sectionid); 274 if (result == ISC_R_NOMORE) 275 return (ISC_R_SUCCESS); 276 else if (result != ISC_R_SUCCESS) 277 return (result); 278 279 for (;;) { 280 name = NULL; 281 dns_message_currentname(msg, sectionid, &name); 282 283 isc_buffer_init(&target, t, sizeof(t)); 284 first = ISC_TRUE; 285 print_name = name; 286 287 for (rdataset = ISC_LIST_HEAD(name->list); 288 rdataset != NULL; 289 rdataset = ISC_LIST_NEXT(rdataset, link)) { 290 if (query->lookup->rdtype == dns_rdatatype_axfr && 291 !((!list_addresses && 292 (list_type == dns_rdatatype_any || 293 rdataset->type == list_type)) || 294 (list_addresses && 295 (rdataset->type == dns_rdatatype_a || 296 rdataset->type == dns_rdatatype_aaaa || 297 rdataset->type == dns_rdatatype_ns || 298 rdataset->type == dns_rdatatype_ptr)))) 299 continue; 300 if (!short_form) { 301 result = dns_rdataset_totext(rdataset, 302 print_name, 303 ISC_FALSE, 304 no_rdata, 305 &target); 306 if (result != ISC_R_SUCCESS) 307 return (result); 308#ifdef USEINITALWS 309 if (first) { 310 print_name = &empty_name; 311 first = ISC_FALSE; 312 } 313#else 314 UNUSED(first); /* Shut up compiler. */ 315#endif 316 } else { 317 loopresult = dns_rdataset_first(rdataset); 318 while (loopresult == ISC_R_SUCCESS) { 319 struct rtype *t; 320 const char *rtt; 321 char typebuf[DNS_RDATATYPE_FORMATSIZE]; 322 char typebuf2[DNS_RDATATYPE_FORMATSIZE 323 + 20]; 324 dns_rdataset_current(rdataset, &rdata); 325 326 for (t = rtypes; t->text != NULL; t++) { 327 if (t->type == rdata.type) { 328 rtt = t->text; 329 goto found; 330 } 331 } 332 333 dns_rdatatype_format(rdata.type, 334 typebuf, 335 sizeof(typebuf)); 336 snprintf(typebuf2, sizeof(typebuf2), 337 "has %s record", typebuf); 338 rtt = typebuf2; 339 found: 340 say_message(print_name, rtt, 341 &rdata, query); 342 dns_rdata_reset(&rdata); 343 loopresult = 344 dns_rdataset_next(rdataset); 345 } 346 } 347 } 348 if (!short_form) { 349 isc_buffer_usedregion(&target, &r); 350 if (no_rdata) 351 printf(";%.*s", (int)r.length, 352 (char *)r.base); 353 else 354 printf("%.*s", (int)r.length, (char *)r.base); 355 } 356 357 result = dns_message_nextname(msg, sectionid); 358 if (result == ISC_R_NOMORE) 359 break; 360 else if (result != ISC_R_SUCCESS) 361 return (result); 362 } 363 364 return (ISC_R_SUCCESS); 365} 366 367static isc_result_t 368printrdata(dns_message_t *msg, dns_rdataset_t *rdataset, dns_name_t *owner, 369 const char *set_name, isc_boolean_t headers) 370{ 371 isc_buffer_t target; 372 isc_result_t result; 373 isc_region_t r; 374 char t[4096]; 375 376 UNUSED(msg); 377 if (headers) 378 printf(";; %s SECTION:\n", set_name); 379 380 isc_buffer_init(&target, t, sizeof(t)); 381 382 result = dns_rdataset_totext(rdataset, owner, ISC_FALSE, ISC_FALSE, 383 &target); 384 if (result != ISC_R_SUCCESS) 385 return (result); 386 isc_buffer_usedregion(&target, &r); 387 printf("%.*s", (int)r.length, (char *)r.base); 388 389 return (ISC_R_SUCCESS); 390} 391 392static void 393chase_cnamechain(dns_message_t *msg, dns_name_t *qname) { 394 isc_result_t result; 395 dns_rdataset_t *rdataset; 396 dns_rdata_cname_t cname; 397 dns_rdata_t rdata = DNS_RDATA_INIT; 398 unsigned int i = msg->counts[DNS_SECTION_ANSWER]; 399 400 while (i-- > 0) { 401 rdataset = NULL; 402 result = dns_message_findname(msg, DNS_SECTION_ANSWER, qname, 403 dns_rdatatype_cname, 0, NULL, 404 &rdataset); 405 if (result != ISC_R_SUCCESS) 406 return; 407 result = dns_rdataset_first(rdataset); 408 check_result(result, "dns_rdataset_first"); 409 dns_rdata_reset(&rdata); 410 dns_rdataset_current(rdataset, &rdata); 411 result = dns_rdata_tostruct(&rdata, &cname, NULL); 412 check_result(result, "dns_rdata_tostruct"); 413 dns_name_copy(&cname.cname, qname, NULL); 414 dns_rdata_freestruct(&cname); 415 } 416} 417 418isc_result_t 419printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) { 420 isc_boolean_t did_flag = ISC_FALSE; 421 dns_rdataset_t *opt, *tsig = NULL; 422 dns_name_t *tsigname; 423 isc_result_t result = ISC_R_SUCCESS; 424 int force_error; 425 426 UNUSED(headers); 427 428 /* 429 * We get called multiple times. 430 * Preserve any existing error status. 431 */ 432 force_error = (seen_error == 1) ? 1 : 0; 433 seen_error = 1; 434 if (listed_server && !printed_server) { 435 char sockstr[ISC_SOCKADDR_FORMATSIZE]; 436 437 printf("Using domain server:\n"); 438 printf("Name: %s\n", query->userarg); 439 isc_sockaddr_format(&query->sockaddr, sockstr, 440 sizeof(sockstr)); 441 printf("Address: %s\n", sockstr); 442 printf("Aliases: \n\n"); 443 printed_server = ISC_TRUE; 444 } 445 446 if (msg->rcode != 0) { 447 char namestr[DNS_NAME_FORMATSIZE]; 448 dns_name_format(query->lookup->name, namestr, sizeof(namestr)); 449 printf("Host %s not found: %d(%s)\n", 450 (msg->rcode != dns_rcode_nxdomain) ? namestr : 451 query->lookup->textname, msg->rcode, 452 rcode_totext(msg->rcode)); 453 return (ISC_R_SUCCESS); 454 } 455 456 if (default_lookups && query->lookup->rdtype == dns_rdatatype_a) { 457 char namestr[DNS_NAME_FORMATSIZE]; 458 dig_lookup_t *lookup; 459 dns_fixedname_t fixed; 460 dns_name_t *name; 461 462 /* Add AAAA and MX lookups. */ 463 dns_fixedname_init(&fixed); 464 name = dns_fixedname_name(&fixed); 465 dns_name_copy(query->lookup->name, name, NULL); 466 chase_cnamechain(msg, name); 467 dns_name_format(name, namestr, sizeof(namestr)); 468 lookup = clone_lookup(query->lookup, ISC_FALSE); 469 if (lookup != NULL) { 470 strncpy(lookup->textname, namestr, 471 sizeof(lookup->textname)); 472 lookup->textname[sizeof(lookup->textname)-1] = 0; 473 lookup->rdtype = dns_rdatatype_aaaa; 474 lookup->rdtypeset = ISC_TRUE; 475 lookup->origin = NULL; 476 lookup->retries = tries; 477 ISC_LIST_APPEND(lookup_list, lookup, link); 478 } 479 lookup = clone_lookup(query->lookup, ISC_FALSE); 480 if (lookup != NULL) { 481 strncpy(lookup->textname, namestr, 482 sizeof(lookup->textname)); 483 lookup->textname[sizeof(lookup->textname)-1] = 0; 484 lookup->rdtype = dns_rdatatype_mx; 485 lookup->rdtypeset = ISC_TRUE; 486 lookup->origin = NULL; 487 lookup->retries = tries; 488 ISC_LIST_APPEND(lookup_list, lookup, link); 489 } 490 } 491 492 if (!short_form) { 493 printf(";; ->>HEADER<<- opcode: %s, status: %s, id: %u\n", 494 opcodetext[msg->opcode], rcode_totext(msg->rcode), 495 msg->id); 496 printf(";; flags: "); 497 if ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) { 498 printf("qr"); 499 did_flag = ISC_TRUE; 500 } 501 if ((msg->flags & DNS_MESSAGEFLAG_AA) != 0) { 502 printf("%saa", did_flag ? " " : ""); 503 did_flag = ISC_TRUE; 504 } 505 if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) { 506 printf("%stc", did_flag ? " " : ""); 507 did_flag = ISC_TRUE; 508 } 509 if ((msg->flags & DNS_MESSAGEFLAG_RD) != 0) { 510 printf("%srd", did_flag ? " " : ""); 511 did_flag = ISC_TRUE; 512 } 513 if ((msg->flags & DNS_MESSAGEFLAG_RA) != 0) { 514 printf("%sra", did_flag ? " " : ""); 515 did_flag = ISC_TRUE; 516 } 517 if ((msg->flags & DNS_MESSAGEFLAG_AD) != 0) { 518 printf("%sad", did_flag ? " " : ""); 519 did_flag = ISC_TRUE; 520 } 521 if ((msg->flags & DNS_MESSAGEFLAG_CD) != 0) { 522 printf("%scd", did_flag ? " " : ""); 523 did_flag = ISC_TRUE; 524 POST(did_flag); 525 } 526 printf("; QUERY: %u, ANSWER: %u, " 527 "AUTHORITY: %u, ADDITIONAL: %u\n", 528 msg->counts[DNS_SECTION_QUESTION], 529 msg->counts[DNS_SECTION_ANSWER], 530 msg->counts[DNS_SECTION_AUTHORITY], 531 msg->counts[DNS_SECTION_ADDITIONAL]); 532 opt = dns_message_getopt(msg); 533 if (opt != NULL) 534 printf(";; EDNS: version: %u, udp=%u\n", 535 (unsigned int)((opt->ttl & 0x00ff0000) >> 16), 536 (unsigned int)opt->rdclass); 537 tsigname = NULL; 538 tsig = dns_message_gettsig(msg, &tsigname); 539 if (tsig != NULL) 540 printf(";; PSEUDOSECTIONS: TSIG\n"); 541 } 542 if (! ISC_LIST_EMPTY(msg->sections[DNS_SECTION_QUESTION]) && 543 !short_form) { 544 printf("\n"); 545 result = printsection(msg, DNS_SECTION_QUESTION, "QUESTION", 546 ISC_TRUE, query); 547 if (result != ISC_R_SUCCESS) 548 return (result); 549 } 550 if (! ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER])) { 551 if (!short_form) 552 printf("\n"); 553 result = printsection(msg, DNS_SECTION_ANSWER, "ANSWER", 554 ISC_TF(!short_form), query); 555 if (result != ISC_R_SUCCESS) 556 return (result); 557 } 558 559 if (! ISC_LIST_EMPTY(msg->sections[DNS_SECTION_AUTHORITY]) && 560 !short_form) { 561 printf("\n"); 562 result = printsection(msg, DNS_SECTION_AUTHORITY, "AUTHORITY", 563 ISC_TRUE, query); 564 if (result != ISC_R_SUCCESS) 565 return (result); 566 } 567 if (! ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ADDITIONAL]) && 568 !short_form) { 569 printf("\n"); 570 result = printsection(msg, DNS_SECTION_ADDITIONAL, 571 "ADDITIONAL", ISC_TRUE, query); 572 if (result != ISC_R_SUCCESS) 573 return (result); 574 } 575 if ((tsig != NULL) && !short_form) { 576 printf("\n"); 577 result = printrdata(msg, tsig, tsigname, 578 "PSEUDOSECTION TSIG", ISC_TRUE); 579 if (result != ISC_R_SUCCESS) 580 return (result); 581 } 582 if (!short_form) 583 printf("\n"); 584 585 if (short_form && !default_lookups && 586 ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER])) { 587 char namestr[DNS_NAME_FORMATSIZE]; 588 char typestr[DNS_RDATATYPE_FORMATSIZE]; 589 dns_name_format(query->lookup->name, namestr, sizeof(namestr)); 590 dns_rdatatype_format(query->lookup->rdtype, typestr, 591 sizeof(typestr)); 592 printf("%s has no %s record\n", namestr, typestr); 593 } 594 seen_error = force_error; 595 return (result); 596} 597 598static const char * optstring = "46ac:dilnm:rst:vwCDN:R:TW:"; 599 600static void 601pre_parse_args(int argc, char **argv) { 602 int c; 603 604 while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) { 605 switch (c) { 606 case 'm': 607 memdebugging = ISC_TRUE; 608 if (strcasecmp("trace", isc_commandline_argument) == 0) 609 isc_mem_debugging |= ISC_MEM_DEBUGTRACE; 610 else if (!strcasecmp("record", 611 isc_commandline_argument) == 0) 612 isc_mem_debugging |= ISC_MEM_DEBUGRECORD; 613 else if (strcasecmp("usage", 614 isc_commandline_argument) == 0) 615 isc_mem_debugging |= ISC_MEM_DEBUGUSAGE; 616 break; 617 618 case '4': break; 619 case '6': break; 620 case 'a': break; 621 case 'c': break; 622 case 'd': break; 623 case 'i': break; 624 case 'l': break; 625 case 'n': break; 626 case 'r': break; 627 case 's': break; 628 case 't': break; 629 case 'v': break; 630 case 'w': break; 631 case 'C': break; 632 case 'D': 633 debugging = ISC_TRUE; 634 break; 635 case 'N': break; 636 case 'R': break; 637 case 'T': break; 638 case 'W': break; 639 default: 640 show_usage(); 641 } 642 } 643 isc_commandline_reset = ISC_TRUE; 644 isc_commandline_index = 1; 645} 646 647static void 648parse_args(isc_boolean_t is_batchfile, int argc, char **argv) { 649 char hostname[MXNAME]; 650 dig_lookup_t *lookup; 651 int c; 652 char store[MXNAME]; 653 isc_textregion_t tr; 654 isc_result_t result = ISC_R_SUCCESS; 655 dns_rdatatype_t rdtype; 656 dns_rdataclass_t rdclass; 657 isc_uint32_t serial = 0; 658 659 UNUSED(is_batchfile); 660 661 lookup = make_empty_lookup(); 662 663 lookup->servfail_stops = ISC_FALSE; 664 lookup->comments = ISC_FALSE; 665 666 while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) { 667 switch (c) { 668 case 'l': 669 lookup->tcp_mode = ISC_TRUE; 670 lookup->rdtype = dns_rdatatype_axfr; 671 lookup->rdtypeset = ISC_TRUE; 672 fatalexit = 3; 673 break; 674 case 'v': 675 case 'd': 676 short_form = ISC_FALSE; 677 break; 678 case 'r': 679 lookup->recurse = ISC_FALSE; 680 break; 681 case 't': 682 if (strncasecmp(isc_commandline_argument, 683 "ixfr=", 5) == 0) { 684 rdtype = dns_rdatatype_ixfr; 685 /* XXXMPA add error checking */ 686 serial = strtoul(isc_commandline_argument + 5, 687 NULL, 10); 688 result = ISC_R_SUCCESS; 689 } else { 690 tr.base = isc_commandline_argument; 691 tr.length = strlen(isc_commandline_argument); 692 result = dns_rdatatype_fromtext(&rdtype, 693 (isc_textregion_t *)&tr); 694 } 695 696 if (result != ISC_R_SUCCESS) { 697 fatalexit = 2; 698 fatal("invalid type: %s\n", 699 isc_commandline_argument); 700 } 701 if (!lookup->rdtypeset || 702 lookup->rdtype != dns_rdatatype_axfr) 703 lookup->rdtype = rdtype; 704 lookup->rdtypeset = ISC_TRUE; 705#ifdef WITH_IDN 706 idnoptions = 0; 707#endif 708 if (rdtype == dns_rdatatype_axfr) { 709 /* -l -t any -v */ 710 list_type = dns_rdatatype_any; 711 short_form = ISC_FALSE; 712 lookup->tcp_mode = ISC_TRUE; 713 } else if (rdtype == dns_rdatatype_ixfr) { 714 lookup->ixfr_serial = serial; 715 lookup->tcp_mode = ISC_TRUE; 716 list_type = rdtype; 717#ifdef WITH_IDN 718 } else if (rdtype == dns_rdatatype_a || 719 rdtype == dns_rdatatype_aaaa || 720 rdtype == dns_rdatatype_mx) { 721 idnoptions = IDN_ASCCHECK; 722 list_type = rdtype; 723#endif 724 } else 725 list_type = rdtype; 726 list_addresses = ISC_FALSE; 727 default_lookups = ISC_FALSE; 728 break; 729 case 'c': 730 tr.base = isc_commandline_argument; 731 tr.length = strlen(isc_commandline_argument); 732 result = dns_rdataclass_fromtext(&rdclass, 733 (isc_textregion_t *)&tr); 734 735 if (result != ISC_R_SUCCESS) { 736 fatalexit = 2; 737 fatal("invalid class: %s\n", 738 isc_commandline_argument); 739 } else { 740 lookup->rdclass = rdclass; 741 lookup->rdclassset = ISC_TRUE; 742 } 743 default_lookups = ISC_FALSE; 744 break; 745 case 'a': 746 if (!lookup->rdtypeset || 747 lookup->rdtype != dns_rdatatype_axfr) 748 lookup->rdtype = dns_rdatatype_any; 749 list_type = dns_rdatatype_any; 750 list_addresses = ISC_FALSE; 751 lookup->rdtypeset = ISC_TRUE; 752 short_form = ISC_FALSE; 753 default_lookups = ISC_FALSE; 754 break; 755 case 'i': 756 lookup->ip6_int = ISC_TRUE; 757 break; 758 case 'n': 759 /* deprecated */ 760 break; 761 case 'm': 762 /* Handled by pre_parse_args(). */ 763 break; 764 case 'w': 765 /* 766 * The timer routines are coded such that 767 * timeout==MAXINT doesn't enable the timer 768 */ 769 timeout = INT_MAX; 770 break; 771 case 'W': 772 timeout = atoi(isc_commandline_argument); 773 if (timeout < 1) 774 timeout = 1; 775 break; 776 case 'R': 777 tries = atoi(isc_commandline_argument) + 1; 778 if (tries < 2) 779 tries = 2; 780 break; 781 case 'T': 782 lookup->tcp_mode = ISC_TRUE; 783 break; 784 case 'C': 785 debug("showing all SOAs"); 786 lookup->rdtype = dns_rdatatype_ns; 787 lookup->rdtypeset = ISC_TRUE; 788 lookup->rdclass = dns_rdataclass_in; 789 lookup->rdclassset = ISC_TRUE; 790 lookup->ns_search_only = ISC_TRUE; 791 lookup->trace_root = ISC_TRUE; 792 lookup->identify_previous_line = ISC_TRUE; 793 default_lookups = ISC_FALSE; 794 break; 795 case 'N': 796 debug("setting NDOTS to %s", 797 isc_commandline_argument); 798 ndots = atoi(isc_commandline_argument); 799 break; 800 case 'D': 801 /* Handled by pre_parse_args(). */ 802 break; 803 case '4': 804 if (have_ipv4) { 805 isc_net_disableipv6(); 806 have_ipv6 = ISC_FALSE; 807 } else 808 fatal("can't find IPv4 networking"); 809 break; 810 case '6': 811 if (have_ipv6) { 812 isc_net_disableipv4(); 813 have_ipv4 = ISC_FALSE; 814 } else 815 fatal("can't find IPv6 networking"); 816 break; 817 case 's': 818 lookup->servfail_stops = ISC_TRUE; 819 break; 820 } 821 } 822 823 lookup->retries = tries; 824 825 if (isc_commandline_index >= argc) 826 show_usage(); 827 828 strlcpy(hostname, argv[isc_commandline_index], sizeof(hostname)); 829 830 if (argc > isc_commandline_index + 1) { 831 set_nameserver(argv[isc_commandline_index+1]); 832 debug("server is %s", argv[isc_commandline_index+1]); 833 listed_server = ISC_TRUE; 834 } else 835 check_ra = ISC_TRUE; 836 837 lookup->pending = ISC_FALSE; 838 if (get_reverse(store, sizeof(store), hostname, 839 lookup->ip6_int, ISC_TRUE) == ISC_R_SUCCESS) { 840 strncpy(lookup->textname, store, sizeof(lookup->textname)); 841 lookup->textname[sizeof(lookup->textname)-1] = 0; 842 lookup->rdtype = dns_rdatatype_ptr; 843 lookup->rdtypeset = ISC_TRUE; 844 default_lookups = ISC_FALSE; 845 } else { 846 strncpy(lookup->textname, hostname, sizeof(lookup->textname)); 847 lookup->textname[sizeof(lookup->textname)-1]=0; 848 usesearch = ISC_TRUE; 849 } 850 lookup->new_search = ISC_TRUE; 851 ISC_LIST_APPEND(lookup_list, lookup, link); 852} 853 854int 855main(int argc, char **argv) { 856 isc_result_t result; 857 858 tries = 2; 859 860 ISC_LIST_INIT(lookup_list); 861 ISC_LIST_INIT(server_list); 862 ISC_LIST_INIT(search_list); 863 864 fatalexit = 1; 865#ifdef WITH_IDN 866 idnoptions = IDN_ASCCHECK; 867#endif 868 869 debug("main()"); 870 progname = argv[0]; 871 pre_parse_args(argc, argv); 872 result = isc_app_start(); 873 check_result(result, "isc_app_start"); 874 setup_libs(); 875 parse_args(ISC_FALSE, argc, argv); 876 setup_system(); 877 result = isc_app_onrun(mctx, global_task, onrun_callback, NULL); 878 check_result(result, "isc_app_onrun"); 879 isc_app_run(); 880 cancel_all(); 881 destroy_libs(); 882 isc_app_finish(); 883 return ((seen_error == 0) ? 0 : 1); 884} 885