bin/dig/host.c

	host.c revision ec5347e2c775f027573ce5648b910361aa926c01
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews/*
a134177ed9f82189504191d90f3ed9e97c2b47cbTinderbox User * Copyright (C) 2004-2007  Internet Systems Consortium, Inc. ("ISC")
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews * Copyright (C) 2000-2003  Internet Software Consortium.
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews *
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews * Permission to use, copy, modify, and/or distribute this software for any
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews * purpose with or without fee is hereby granted, provided that the above
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews * copyright notice and this permission notice appear in all copies.
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews *
28a8f5b0de57d269cf2845c69cb6abe18cbd3b3aMark Andrews * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
058e44186b74531402c1f99088eb9dbe4926f8daMark Andrews * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews * PERFORMANCE OF THIS SOFTWARE.
12ff7274fe2ea531ecca6a71fb9f7e1ae92da389Mark Andrews */
12ff7274fe2ea531ecca6a71fb9f7e1ae92da389Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews/* $Id: host.c,v 1.114 2007/06/18 23:47:17 tbox Exp $ */
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews/*! \file */
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews#include <config.h>
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews#include <stdlib.h>
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt#include <limits.h>
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#ifdef HAVE_LOCALE_H
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews#include <locale.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#endif
0da29be670f6fa5b2a6320d9d843bc8b802c153aMark Andrews
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews#ifdef WITH_IDN
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <idn/result.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <idn/log.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <idn/resconf.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <idn/api.h>
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews#endif
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <isc/app.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <isc/commandline.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <isc/netaddr.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <isc/print.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <isc/string.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <isc/util.h>
1676408640d8283c9f17eec0b183e1302ea7fd70Mark Andrews#include <isc/task.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <isc/stdlib.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <dns/byaddr.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <dns/fixedname.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <dns/message.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <dns/name.h>
0da29be670f6fa5b2a6320d9d843bc8b802c153aMark Andrews#include <dns/rdata.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <dns/rdataclass.h>
0da29be670f6fa5b2a6320d9d843bc8b802c153aMark Andrews#include <dns/rdataset.h>
0da29be670f6fa5b2a6320d9d843bc8b802c153aMark Andrews#include <dns/rdatatype.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <dns/rdatastruct.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#include <dig/dig.h>
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
058e44186b74531402c1f99088eb9dbe4926f8daMark Andrewsstatic isc_boolean_t short_form = ISC_TRUE, listed_server = ISC_FALSE;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstatic isc_boolean_t default_lookups = ISC_TRUE;
058e44186b74531402c1f99088eb9dbe4926f8daMark Andrewsstatic int seen_error = -1;
058e44186b74531402c1f99088eb9dbe4926f8daMark Andrewsstatic isc_boolean_t list_addresses = ISC_TRUE;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstatic dns_rdatatype_t list_type = dns_rdatatype_a;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstatic isc_boolean_t printed_server = ISC_FALSE;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstatic const char *opcodetext[] = {
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "QUERY",
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "IQUERY",
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    "STATUS",
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "RESERVED3",
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "NOTIFY",
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    "UPDATE",
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "RESERVED6",
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt    "RESERVED7",
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "RESERVED8",
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "RESERVED9",
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "RESERVED10",
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt    "RESERVED11",
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews    "RESERVED12",
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews    "RESERVED13",
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews    "RESERVED14",
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews    "RESERVED15"
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews};
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrewsstatic const char *rcodetext[] = {
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    "NOERROR",
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    "FORMERR",
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    "SERVFAIL",
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    "NXDOMAIN",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "NOTIMP",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "REFUSED",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "YXDOMAIN",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "YXRRSET",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "NXRRSET",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "NOTAUTH",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "NOTZONE",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "RESERVED11",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "RESERVED12",
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    "RESERVED13",
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    "RESERVED14",
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    "RESERVED15",
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    "BADVERS"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews};
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstruct rtype {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    unsigned int type;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    const char *text;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews};
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstruct rtype rtypes[] = {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 1,    "has address" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 2,    "name server" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 5,    "is an alias for" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 11,   "has well known services" },
ad1317338af79edad878c9c3e4361798503310baMark Andrews    { 12,   "domain name pointer" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 13,   "host information" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 15,   "mail is handled by" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 16,   "descriptive text" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 19,   "x25 address" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 20,   "ISDN address" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 24,   "has signature" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 25,   "has key" },
ad1317338af79edad878c9c3e4361798503310baMark Andrews    { 28,   "has IPv6 address" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 29,   "location" },
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    { 0, NULL }
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews};
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstatic void
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsshow_usage(void) {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    fputs(
ad1317338af79edad878c9c3e4361798503310baMark Andrews"Usage: host [-aCdlriTwv] [-c class] [-N ndots] [-t type] [-W time]\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"            [-R number] [-m flag] hostname [server]\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -a is equivalent to -v -t ANY\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -c specifies query class for non-IN data\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -C compares SOA records on authoritative nameservers\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -d is equivalent to -v\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -l lists all hosts in a domain, using AXFR\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -i IP6.INT reverse lookups\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -N changes the number of dots allowed before root lookup is done\n"
75ae74f8fd0847817bce2db7c868b179db67f019Mark Andrews"       -r disables recursive processing\n"
75ae74f8fd0847817bce2db7c868b179db67f019Mark Andrews"       -R specifies number of retries for UDP packets\n"
75ae74f8fd0847817bce2db7c868b179db67f019Mark Andrews"       -s a SERVFAIL response should stop query\n"
75ae74f8fd0847817bce2db7c868b179db67f019Mark Andrews"       -t specifies the query type\n"
75ae74f8fd0847817bce2db7c868b179db67f019Mark Andrews"       -T enables TCP/IP mode\n"
75ae74f8fd0847817bce2db7c868b179db67f019Mark Andrews"       -v enables verbose output\n"
21c8938824a2445bc750ba9c395a0d857f50ad72Tinderbox User"       -w specifies to wait forever for a reply\n"
75ae74f8fd0847817bce2db7c868b179db67f019Mark Andrews"       -W specifies how long to wait for a reply\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -4 use IPv4 query transport only\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -6 use IPv6 query transport only\n"
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews"       -m set memory debugging flag (trace|record|usage)\n", stderr);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    exit(1);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews}
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrewsvoid
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsdighost_shutdown(void) {
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    isc_app_shutdown();
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews}
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrewsvoid
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrewsreceived(int bytes, isc_sockaddr_t *from, dig_query_t *query) {
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    isc_time_t now;
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    int diff;
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    if (!short_form) {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        char fromtext[ISC_SOCKADDR_FORMATSIZE];
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        isc_sockaddr_format(from, fromtext, sizeof(fromtext));
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        TIME_NOW(&now);
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        diff = (int) isc_time_microdiff(&now, &query->time_sent);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        printf("Received %u bytes from %s in %d ms\n",
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews               bytes, fromtext, diff/1000);
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    }
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews}
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrewsvoid
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrewstrying(char *frm, dig_lookup_t *lookup) {
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    UNUSED(lookup);
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    if (!short_form)
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews        printf("Trying \"%s\"\n", frm);
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt}
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrewsstatic void
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Huntsay_message(dns_name_t *name, const char *msg, dns_rdata_t *rdata,
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews        dig_query_t *query)
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews{
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_buffer_t *b = NULL;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    char namestr[DNS_NAME_FORMATSIZE];
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    isc_region_t r;
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    isc_result_t result;
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    unsigned int bufsize = BUFSIZ;
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    dns_name_format(name, namestr, sizeof(namestr));
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews retry:
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    result = isc_buffer_allocate(mctx, &b, bufsize);
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    check_result(result, "isc_buffer_allocate");
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    result = dns_rdata_totext(rdata, NULL, b);
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt    if (result == ISC_R_NOSPACE) {
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews        isc_buffer_free(&b);
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews        bufsize *= 2;
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt        goto retry;
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews    }
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews    check_result(result, "dns_rdata_totext");
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    isc_buffer_usedregion(b, &r);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    if (query->lookup->identify_previous_line) {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        printf("Nameserver %s:\n\t",
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews            query->servname);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    }
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    printf("%s %s %.*s", namestr,
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews           msg, (int)r.length, (char *)r.base);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    if (query->lookup->identify) {
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews        printf(" on server %s", query->servname);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    }
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    printf("\n");
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    isc_buffer_free(&b);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews}
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews#ifdef DIG_SIGCHASE
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews/* Just for compatibility : not use in host program */
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsisc_result_t
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsprintrdataset(dns_name_t *owner_name, dns_rdataset_t *rdataset,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews          isc_buffer_t *target)
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman{
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews  UNUSED(owner_name);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews  UNUSED(rdataset);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews  UNUSED(target);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews  return(ISC_FALSE);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews}
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#endif
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstatic isc_result_t
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsprintsection(dns_message_t *msg, dns_section_t sectionid,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews         const char *section_name, isc_boolean_t headers,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews         dig_query_t *query)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews{
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    dns_name_t *name, *print_name;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    dns_rdataset_t *rdataset;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    dns_rdata_t rdata = DNS_RDATA_INIT;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_buffer_t target;
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman    isc_result_t result, loopresult;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_region_t r;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    dns_name_t empty_name;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    char t[4096];
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_boolean_t first;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_boolean_t no_rdata;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    if (sectionid == DNS_SECTION_QUESTION)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        no_rdata = ISC_TRUE;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    else
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews        no_rdata = ISC_FALSE;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    if (headers)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        printf(";; %s SECTION:\n", section_name);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    dns_name_init(&empty_name, NULL);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    result = dns_message_firstname(msg, sectionid);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews    if (result == ISC_R_NOMORE)
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews        return (ISC_R_SUCCESS);
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    else if (result != ISC_R_SUCCESS)
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews        return (result);
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews    for (;;) {
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews        name = NULL;
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews        dns_message_currentname(msg, sectionid, &name);
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt        isc_buffer_init(&target, t, sizeof(t));
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews        first = ISC_TRUE;
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews        print_name = name;
37dee1ff94960a61243f611c0f87f8c316815c53Mark Andrews
ba751492fcc4f161a18b983d4f018a1a52938cb9Evan Hunt        for (rdataset = ISC_LIST_HEAD(name->list);
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews             rdataset != NULL;
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews             rdataset = ISC_LIST_NEXT(rdataset, link)) {
aaaf8d4f4873d21e55c3ffb4f656203d08339865Mark Andrews            if (query->lookup->rdtype == dns_rdatatype_axfr &&
394f4aec2189750d7f861d00f97fe28ffcd9f659Mark Andrews                !((!list_addresses &&
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                   (list_type == dns_rdatatype_any ||
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    rdataset->type == list_type)) ||
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                  (list_addresses &&
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                   (rdataset->type == dns_rdatatype_a ||
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    rdataset->type == dns_rdatatype_aaaa ||
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                rdataset->type == dns_rdatatype_ns ||
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                rdataset->type == dns_rdatatype_ptr))))
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                continue;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews            if (!short_form) {
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                result = dns_rdataset_totext(rdataset,
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                                 print_name,
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                                 ISC_FALSE,
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                                 no_rdata,
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                                 &target);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                if (result != ISC_R_SUCCESS)
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                    return (result);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews#ifdef USEINITALWS
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                if (first) {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    print_name = &empty_name;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    first = ISC_FALSE;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                }
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews#else
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                UNUSED(first); /* Shut up compiler. */
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews#endif
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews            } else {
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                loopresult = dns_rdataset_first(rdataset);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                while (loopresult == ISC_R_SUCCESS) {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    struct rtype *t;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    const char *rtt;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    char typebuf[DNS_RDATATYPE_FORMATSIZE];
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    char typebuf2[DNS_RDATATYPE_FORMATSIZE
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                             + 20];
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    dns_rdataset_current(rdataset, &rdata);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    for (t = rtypes; t->text != NULL; t++) {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                        if (t->type == rdata.type) {
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                            rtt = t->text;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                            goto found;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                        }
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    }
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    dns_rdatatype_format(rdata.type,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                                 typebuf,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                                 sizeof(typebuf));
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                    snprintf(typebuf2, sizeof(typebuf2),
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                         "has %s record", typebuf);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                    rtt = typebuf2;
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                found:
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                    say_message(print_name, rtt,
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                            &rdata, query);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                    dns_rdata_reset(&rdata);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                    loopresult =
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                        dns_rdataset_next(rdataset);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews                }
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews            }
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews        }
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews        if (!short_form) {
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews            isc_buffer_usedregion(&target, &r);
3dd63ba00f91f4d54ba45ba1831375950758c0a7Mark Andrews            if (no_rdata)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                printf(";%.*s", (int)r.length,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                       (char *)r.base);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews            else
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                printf("%.*s", (int)r.length, (char *)r.base);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        }
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        result = dns_message_nextname(msg, sectionid);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        if (result == ISC_R_NOMORE)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews            break;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        else if (result != ISC_R_SUCCESS)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews            return (result);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    }
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    return (ISC_R_SUCCESS);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews}
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsstatic isc_result_t
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaramanprintrdata(dns_message_t *msg, dns_rdataset_t *rdataset, dns_name_t *owner,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews       const char *set_name, isc_boolean_t headers)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews{
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_buffer_t target;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_result_t result;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_region_t r;
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    char t[4096];
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    UNUSED(msg);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    if (headers)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        printf(";; %s SECTION:\n", set_name);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_buffer_init(&target, t, sizeof(t));
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    result = dns_rdataset_totext(rdataset, owner, ISC_FALSE, ISC_FALSE,
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews                     &target);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    if (result != ISC_R_SUCCESS)
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews        return (result);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    isc_buffer_usedregion(&target, &r);
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrews    printf("%.*s", (int)r.length, (char *)r.base);
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews    return (ISC_R_SUCCESS);
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews}
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrewsstatic void
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrewschase_cnamechain(dns_message_t *msg, dns_name_t *qname) {
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews    isc_result_t result;
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews    dns_rdataset_t *rdataset;
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews    dns_rdata_cname_t cname;
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews    dns_rdata_t rdata = DNS_RDATA_INIT;
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews    unsigned int i = msg->counts[DNS_SECTION_ANSWER];
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews    while (i-- > 0) {
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        rdataset = NULL;
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        result = dns_message_findname(msg, DNS_SECTION_ANSWER, qname,
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews                          dns_rdatatype_cname, 0, NULL,
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman                          &rdataset);
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        if (result != ISC_R_SUCCESS)
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews            return;
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        result = dns_rdataset_first(rdataset);
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        check_result(result, "dns_rdataset_first");
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        dns_rdata_reset(&rdata);
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        dns_rdataset_current(rdataset, &rdata);
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        result = dns_rdata_tostruct(&rdata, &cname, NULL);
2047977ce2dfcfe3a0fa2d638c3242841310fad3Mark Andrews        check_result(result, "dns_rdata_tostruct");
3d17a3ba61a303d5c4d9867068d0fbe9f24d2988Mark Andrews        dns_name_copy(&cname.cname, qname, NULL);
3d17a3ba61a303d5c4d9867068d0fbe9f24d2988Mark Andrews        dns_rdata_freestruct(&cname);
3d17a3ba61a303d5c4d9867068d0fbe9f24d2988Mark Andrews    }
3d17a3ba61a303d5c4d9867068d0fbe9f24d2988Mark Andrews}
3d17a3ba61a303d5c4d9867068d0fbe9f24d2988Mark Andrews
0b09763c354ec91fb352b6b4cea383bd0195b2d8Mark Andrewsisc_result_t
printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
    isc_boolean_t did_flag = ISC_FALSE;
    dns_rdataset_t *opt, *tsig = NULL;
    dns_name_t *tsigname;
    isc_result_t result = ISC_R_SUCCESS;
    int force_error;

    UNUSED(headers);

    /*
     * We get called multiple times.
     * Preserve any existing error status.
     */
    force_error = (seen_error == 1) ? 1 : 0;
    seen_error = 1;
    if (listed_server && !printed_server) {
        char sockstr[ISC_SOCKADDR_FORMATSIZE];

        printf("Using domain server:\n");
        printf("Name: %s\n", query->userarg);
        isc_sockaddr_format(&query->sockaddr, sockstr,
                    sizeof(sockstr));
        printf("Address: %s\n", sockstr);
        printf("Aliases: \n\n");
        printed_server = ISC_TRUE;
    }

    if (msg->rcode != 0) {
        char namestr[DNS_NAME_FORMATSIZE];
        dns_name_format(query->lookup->name, namestr, sizeof(namestr));
        printf("Host %s not found: %d(%s)\n",
               (msg->rcode != dns_rcode_nxdomain) ? namestr :
               query->lookup->textname, msg->rcode,
               rcodetext[msg->rcode]);
        return (ISC_R_SUCCESS);
    }

    if (default_lookups && query->lookup->rdtype == dns_rdatatype_a) {
        char namestr[DNS_NAME_FORMATSIZE];
        dig_lookup_t *lookup;
        dns_fixedname_t fixed;
        dns_name_t *name;

        /* Add AAAA and MX lookups. */
        dns_fixedname_init(&fixed);
        name = dns_fixedname_name(&fixed);
        dns_name_copy(query->lookup->name, name, NULL);
        chase_cnamechain(msg, name);
        dns_name_format(name, namestr, sizeof(namestr));
        lookup = clone_lookup(query->lookup, ISC_FALSE);
        if (lookup != NULL) {
            strncpy(lookup->textname, namestr,
                sizeof(lookup->textname));
            lookup->textname[sizeof(lookup->textname)-1] = 0;
            lookup->rdtype = dns_rdatatype_aaaa;
                        lookup->rdtypeset = ISC_TRUE;
            lookup->origin = NULL;
            lookup->retries = tries;
            ISC_LIST_APPEND(lookup_list, lookup, link);
        }
        lookup = clone_lookup(query->lookup, ISC_FALSE);
        if (lookup != NULL) {
            strncpy(lookup->textname, namestr,
                sizeof(lookup->textname));
            lookup->textname[sizeof(lookup->textname)-1] = 0;
            lookup->rdtype = dns_rdatatype_mx;
                        lookup->rdtypeset = ISC_TRUE;
            lookup->origin = NULL;
            lookup->retries = tries;
            ISC_LIST_APPEND(lookup_list, lookup, link);
        }
    }

    if (!short_form) {
        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]);
        opt = dns_message_getopt(msg);
        if (opt != NULL)
            printf(";; EDNS: version: %u, udp=%u\n",
                   (unsigned int)((opt->ttl & 0x00ff0000) >> 16),
                   (unsigned int)opt->rdclass);
        tsigname = NULL;
        tsig = dns_message_gettsig(msg, &tsigname);
        if (tsig != NULL)
            printf(";; PSEUDOSECTIONS: TSIG\n");
    }
    if (! ISC_LIST_EMPTY(msg->sections[DNS_SECTION_QUESTION]) &&
        !short_form) {
        printf("\n");
        result = printsection(msg, DNS_SECTION_QUESTION, "QUESTION",
                      ISC_TRUE, query);
        if (result != ISC_R_SUCCESS)
            return (result);
    }
    if (! ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER])) {
        if (!short_form)
            printf("\n");
        result = printsection(msg, DNS_SECTION_ANSWER, "ANSWER",
                      ISC_TF(!short_form), query);
        if (result != ISC_R_SUCCESS)
            return (result);
    }

    if (! ISC_LIST_EMPTY(msg->sections[DNS_SECTION_AUTHORITY]) &&
        !short_form) {
        printf("\n");
        result = printsection(msg, DNS_SECTION_AUTHORITY, "AUTHORITY",
                      ISC_TRUE, query);
        if (result != ISC_R_SUCCESS)
            return (result);
    }
    if (! ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ADDITIONAL]) &&
        !short_form) {
        printf("\n");
        result = printsection(msg, DNS_SECTION_ADDITIONAL,
                      "ADDITIONAL", ISC_TRUE, query);
        if (result != ISC_R_SUCCESS)
            return (result);
    }
    if ((tsig != NULL) && !short_form) {
        printf("\n");
        result = printrdata(msg, tsig, tsigname,
                    "PSEUDOSECTION TSIG", ISC_TRUE);
        if (result != ISC_R_SUCCESS)
            return (result);
    }
    if (!short_form)
        printf("\n");

    if (short_form && !default_lookups &&
        ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER])) {
        char namestr[DNS_NAME_FORMATSIZE];
        char typestr[DNS_RDATATYPE_FORMATSIZE];
        dns_name_format(query->lookup->name, namestr, sizeof(namestr));
        dns_rdatatype_format(query->lookup->rdtype, typestr,
                     sizeof(typestr));
        printf("%s has no %s record\n", namestr, typestr);
    }
    seen_error = force_error;
    return (result);
}

static const char * optstring = "46ac:dilnm:rst:vwCDN:R:TW:";

static void
pre_parse_args(int argc, char **argv) {
    int c;

    while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) {
        switch (c) {
        case 'm':
            if (strcasecmp("trace", isc_commandline_argument) == 0)
                isc_mem_debugging |= ISC_MEM_DEBUGTRACE;
            else if (!strcasecmp("record",
                         isc_commandline_argument) == 0)
                isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
            else if (strcasecmp("usage",
                        isc_commandline_argument) == 0)
                isc_mem_debugging |= ISC_MEM_DEBUGUSAGE;
            break;

        case '4': break;
        case '6': break;
        case 'a': break;
        case 'c': break;
        case 'd': break;
        case 'i': break;
        case 'l': break;
        case 'n': break;
        case 'r': break;
        case 's': break;
        case 't': break;
        case 'v': break;
        case 'w': break;
        case 'C': break;
        case 'D': break;
        case 'N': break;
        case 'R': break;
        case 'T': break;
        case 'W': break;
        default:
            show_usage();
        }
    }
    isc_commandline_reset = ISC_TRUE;
    isc_commandline_index = 1;
}

static void
parse_args(isc_boolean_t is_batchfile, int argc, char **argv) {
    char hostname[MXNAME];
    dig_lookup_t *lookup;
    int c;
    char store[MXNAME];
    isc_textregion_t tr;
    isc_result_t result = ISC_R_SUCCESS;
    dns_rdatatype_t rdtype;
    dns_rdataclass_t rdclass;
    isc_uint32_t serial = 0;

    UNUSED(is_batchfile);

    lookup = make_empty_lookup();

    lookup->servfail_stops = ISC_FALSE;
    lookup->comments = ISC_FALSE;

    while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) {
        switch (c) {
        case 'l':
            lookup->tcp_mode = ISC_TRUE;
            lookup->rdtype = dns_rdatatype_axfr;
            lookup->rdtypeset = ISC_TRUE;
            fatalexit = 3;
            break;
        case 'v':
        case 'd':
            short_form = ISC_FALSE;
            break;
        case 'r':
            lookup->recurse = ISC_FALSE;
            break;
        case 't':
            if (strncasecmp(isc_commandline_argument,
                    "ixfr=", 5) == 0) {
                rdtype = dns_rdatatype_ixfr;
                /* XXXMPA add error checking */
                serial = strtoul(isc_commandline_argument + 5,
                         NULL, 10);
                result = ISC_R_SUCCESS;
            } else {
                tr.base = isc_commandline_argument;
                tr.length = strlen(isc_commandline_argument);
                result = dns_rdatatype_fromtext(&rdtype,
                           (isc_textregion_t *)&tr);
            }

            if (result != ISC_R_SUCCESS) {
                fatalexit = 2;
                fatal("invalid type: %s\n",
                      isc_commandline_argument);
            }
            if (!lookup->rdtypeset ||
                lookup->rdtype != dns_rdatatype_axfr)
                lookup->rdtype = rdtype;
            lookup->rdtypeset = ISC_TRUE;
#ifdef WITH_IDN
            idnoptions = 0;
#endif
            if (rdtype == dns_rdatatype_axfr) {
                /* -l -t any -v */
                list_type = dns_rdatatype_any;
                short_form = ISC_FALSE;
                lookup->tcp_mode = ISC_TRUE;
            } else if (rdtype == dns_rdatatype_ixfr) {
                lookup->ixfr_serial = serial;
                list_type = rdtype;
#ifdef WITH_IDN
            } else if (rdtype == dns_rdatatype_a ||
                   rdtype == dns_rdatatype_aaaa ||
                   rdtype == dns_rdatatype_mx) {
                idnoptions = IDN_ASCCHECK;
                list_type = rdtype;
#endif
            } else
                list_type = rdtype;
            list_addresses = ISC_FALSE;
            default_lookups = ISC_FALSE;
            break;
        case 'c':
            tr.base = isc_commandline_argument;
            tr.length = strlen(isc_commandline_argument);
            result = dns_rdataclass_fromtext(&rdclass,
                           (isc_textregion_t *)&tr);

            if (result != ISC_R_SUCCESS) {
                fatalexit = 2;
                fatal("invalid class: %s\n",
                      isc_commandline_argument);
            } else {
                lookup->rdclass = rdclass;
                lookup->rdclassset = ISC_TRUE;
            }
            default_lookups = ISC_FALSE;
            break;
        case 'a':
            if (!lookup->rdtypeset ||
                lookup->rdtype != dns_rdatatype_axfr)
                lookup->rdtype = dns_rdatatype_any;
            list_type = dns_rdatatype_any;
            list_addresses = ISC_FALSE;
            lookup->rdtypeset = ISC_TRUE;
            short_form = ISC_FALSE;
            default_lookups = ISC_FALSE;
            break;
        case 'i':
            lookup->ip6_int = ISC_TRUE;
            break;
        case 'n':
            /* deprecated */
            break;
        case 'm':
            /* Handled by pre_parse_args(). */
            break;
        case 'w':
            /*
             * The timer routines are coded such that
             * timeout==MAXINT doesn't enable the timer
             */
            timeout = INT_MAX;
            break;
        case 'W':
            timeout = atoi(isc_commandline_argument);
            if (timeout < 1)
                timeout = 1;
            break;
        case 'R':
            tries = atoi(isc_commandline_argument) + 1;
            if (tries < 2)
                tries = 2;
            break;
        case 'T':
            lookup->tcp_mode = ISC_TRUE;
            break;
        case 'C':
            debug("showing all SOAs");
            lookup->rdtype = dns_rdatatype_ns;
            lookup->rdtypeset = ISC_TRUE;
            lookup->rdclass = dns_rdataclass_in;
            lookup->rdclassset = ISC_TRUE;
            lookup->ns_search_only = ISC_TRUE;
            lookup->trace_root = ISC_TRUE;
            lookup->identify_previous_line = ISC_TRUE;
            default_lookups = ISC_FALSE;
            break;
        case 'N':
            debug("setting NDOTS to %s",
                  isc_commandline_argument);
            ndots = atoi(isc_commandline_argument);
            break;
        case 'D':
            debugging = ISC_TRUE;
            break;
        case '4':
            if (have_ipv4) {
                isc_net_disableipv6();
                have_ipv6 = ISC_FALSE;
            } else
                fatal("can't find IPv4 networking");
            break;
        case '6':
            if (have_ipv6) {
                isc_net_disableipv4();
                have_ipv4 = ISC_FALSE;
            } else
                fatal("can't find IPv6 networking");
            break;
        case 's':
            lookup->servfail_stops = ISC_TRUE;
            break;
        }
    }

    lookup->retries = tries;

    if (isc_commandline_index >= argc)
        show_usage();

    strncpy(hostname, argv[isc_commandline_index], sizeof(hostname));
    hostname[sizeof(hostname)-1]=0;
    if (argc > isc_commandline_index + 1) {
        set_nameserver(argv[isc_commandline_index+1]);
        debug("server is %s", argv[isc_commandline_index+1]);
        listed_server = ISC_TRUE;
    } else
        check_ra = ISC_TRUE;

    lookup->pending = ISC_FALSE;
    if (get_reverse(store, sizeof(store), hostname,
            lookup->ip6_int, ISC_TRUE) == ISC_R_SUCCESS) {
        strncpy(lookup->textname, store, sizeof(lookup->textname));
        lookup->textname[sizeof(lookup->textname)-1] = 0;
        lookup->rdtype = dns_rdatatype_ptr;
        lookup->rdtypeset = ISC_TRUE;
        default_lookups = ISC_FALSE;
    } else {
        strncpy(lookup->textname, hostname, sizeof(lookup->textname));
        lookup->textname[sizeof(lookup->textname)-1]=0;
    }
    lookup->new_search = ISC_TRUE;
    ISC_LIST_APPEND(lookup_list, lookup, link);

    usesearch = ISC_TRUE;
}

int
main(int argc, char **argv) {
    isc_result_t result;

    tries = 2;

    ISC_LIST_INIT(lookup_list);
    ISC_LIST_INIT(server_list);
    ISC_LIST_INIT(search_list);

    fatalexit = 1;
#ifdef WITH_IDN
    idnoptions = IDN_ASCCHECK;
#endif

    debug("main()");
    progname = argv[0];
    pre_parse_args(argc, argv);
    result = isc_app_start();
    check_result(result, "isc_app_start");
    setup_libs();
    parse_args(ISC_FALSE, argc, argv);
    setup_system();
    result = isc_app_onrun(mctx, global_task, onrun_callback, NULL);
    check_result(result, "isc_app_onrun");
    isc_app_run();
    cancel_all();
    destroy_libs();
    isc_app_finish();
    return ((seen_error == 0) ? 0 : 1);
}