contrib/ldns/drill/drill.c

   1 /*
   2  * drill.c
   3  * the main file of drill
   4  * (c) 2005-2008 NLnet Labs
   5  *
   6  * See the file LICENSE for the license
   7  *
   8  */
   9
  10 #include "drill.h"
  11 #include <ldns/ldns.h>
  12
  13 #ifdef HAVE_SSL
  14 #include <openssl/err.h>
  15 #endif
  16
  17 #define IP6_ARPA_MAX_LEN 65
  18
  19 /* query debug, 2 hex dumps */
  20 int             verbosity;
  21
  22 static void
  23 usage(FILE *stream, const char *progname)
  24 {
  25         fprintf(stream, "  Usage: %s name [@server] [type] [class]\n", progname);
  26         fprintf(stream, "\t<name>  can be a domain name or an IP address (-x lookups)\n");
  27         fprintf(stream, "\t<type>  defaults to A\n");
  28         fprintf(stream, "\t<class> defaults to IN\n");
  29         fprintf(stream, "\n\targuments may be placed in random order\n");
  30         fprintf(stream, "\n  Options:\n");
  31         fprintf(stream, "\t-D\t\tenable DNSSEC (DO bit)\n");
  32 #ifdef HAVE_SSL
  33         fprintf(stream, "\t-T\t\ttrace from the root down to <name>\n");
  34         fprintf(stream, "\t-S\t\tchase signature(s) from <name> to a know key [*]\n");
  35 #endif /*HAVE_SSL*/
  36         fprintf(stream, "\t-V <number>\tverbosity (0-5)\n");
  37         fprintf(stream, "\t-Q\t\tquiet mode (overrules -V)\n");
  38         fprintf(stream, "\n");
  39         fprintf(stream, "\t-f file\t\tread packet from file and send it\n");
  40         fprintf(stream, "\t-i file\t\tread packet from file and print it\n");
  41         fprintf(stream, "\t-w file\t\twrite answer packet to file\n");
  42         fprintf(stream, "\t-q file\t\twrite query packet to file\n");
  43         fprintf(stream, "\t-h\t\tshow this help\n");
  44         fprintf(stream, "\t-v\t\tshow version\n");
  45         fprintf(stream, "\n  Query options:\n");
  46         fprintf(stream, "\t-4\t\tstay on ip4\n");
  47         fprintf(stream, "\t-6\t\tstay on ip6\n");
  48         fprintf(stream, "\t-a\t\tfallback to EDNS0 and TCP if the answer is truncated\n");
  49         fprintf(stream, "\t-b <bufsize>\tuse <bufsize> as the buffer size (defaults to 512 b)\n");
  50         fprintf(stream, "\t-c <file>\tuse file for rescursive nameserver configuration"
  51                         "\n\t\t\t(/etc/resolv.conf)\n");
  52         fprintf(stream, "\t-k <file>\tspecify a file that contains a trusted DNSSEC key [**]\n");
  53         fprintf(stream, "\t\t\tUsed to verify any signatures in the current answer.\n");
  54         fprintf(stream, "\t\t\tWhen DNSSEC enabled tracing (-TD) or signature\n"
  55                         "\t\t\tchasing (-S) and no key files are given, keys are read\n"
  56                         "\t\t\tfrom: %s\n",
  57                         LDNS_TRUST_ANCHOR_FILE);
  58         fprintf(stream, "\t-o <mnemonic>\tset flags to:"
  59                         "\n\t\t\t[QR|qr][AA|aa][TC|tc][RD|rd][CD|cd][RA|ra][AD|ad]\n");
  60         fprintf(stream, "\t\t\tlowercase: unset bit, uppercase: set bit\n");
  61         fprintf(stream, "\t-p <port>\tuse <port> as remote port number\n");
  62         fprintf(stream, "\t-s\t\tshow the DS RR for each key in a packet\n");
  63         fprintf(stream, "\t-u\t\tsend the query with udp (the default)\n");
  64         fprintf(stream, "\t-x\t\tdo a reverse lookup\n");
  65         fprintf(stream, "\twhen doing a secure trace:\n");
  66         fprintf(stream, "\t-r <file>\tuse file as root servers hint file\n");
  67         fprintf(stream, "\t-t\t\tsend the query with tcp (connected)\n");
  68         fprintf(stream, "\t-d <domain>\tuse domain as the start point for the trace\n");
  69     fprintf(stream, "\t-y <name:key[:algo]>\tspecify named base64 tsig key, and optional an\n\t\t\talgorithm (defaults to hmac-md5.sig-alg.reg.int)\n");
  70         fprintf(stream, "\t-z\t\tdon't randomize the nameservers before use\n");
  71         fprintf(stream, "\n  [*] = enables/implies DNSSEC\n");
  72         fprintf(stream, "  [**] = can be given more than once\n");
  73         fprintf(stream, "\n  ldns-team@nlnetlabs.nl | http://www.nlnetlabs.nl/ldns/\n");
  74 }
  75
  76 /**
  77  * Prints the drill version to stderr
  78  */
  79 static void
  80 version(FILE *stream, const char *progname)
  81 {
  82         fprintf(stream, "%s version %s (ldns version %s)\n", progname, DRILL_VERSION, ldns_version());
  83         fprintf(stream, "Written by NLnet Labs.\n");
  84         fprintf(stream, "\nCopyright (c) 2004-2008 NLnet Labs.\n");
  85         fprintf(stream, "Licensed under the revised BSD license.\n");
  86         fprintf(stream, "There is NO warranty; not even for MERCHANTABILITY or FITNESS\n");
  87         fprintf(stream, "FOR A PARTICULAR PURPOSE.\n");
  88 }
  89
  90
  91 /**
  92  * Main function of drill
  93  * parse the arguments and prepare a query
  94  */
  95 int
  96 main(int argc, char *argv[])
  97 {
  98         ldns_resolver   *res = NULL;
  99         ldns_resolver   *cmdline_res = NULL; /* only used to resolv @name names */
 100         ldns_rr_list    *cmdline_rr_list = NULL;
 101         ldns_rdf        *cmdline_dname = NULL;
 102         ldns_rdf        *qname, *qname_tmp;
 103         ldns_pkt        *pkt;
 104         ldns_pkt        *qpkt;
 105         char            *serv;
 106         const char      *name;
 107         char            *name2;
 108         char            *progname;
 109         char            *query_file = NULL;
 110         char            *answer_file = NULL;
 111         ldns_buffer     *query_buffer = NULL;
 112         ldns_rdf        *serv_rdf;
 113         ldns_rr_type    type;
 114         ldns_rr_class   clas;
 115 #if 0
 116         ldns_pkt_opcode opcode = LDNS_PACKET_QUERY;
 117 #endif
 118         int             i, c;
 119         int             int_type;
 120         int             int_clas;
 121         int             PURPOSE;
 122         char            *tsig_name = NULL;
 123         char            *tsig_data = NULL;
 124         char            *tsig_algorithm = NULL;
 125         size_t          tsig_separator;
 126         size_t          tsig_separator2;
 127         ldns_rr         *axfr_rr;
 128         ldns_status     status;
 129         char *type_str;
 130
 131         /* list of keys used in dnssec operations */
 132         ldns_rr_list    *key_list = ldns_rr_list_new();
 133         /* what key verify the current answer */
 134         ldns_rr_list    *key_verified;
 135
 136         /* resolver options */
 137         uint16_t        qflags;
 138         uint16_t        qbuf;
 139         uint16_t        qport;
 140         uint8_t         qfamily;
 141         bool            qdnssec;
 142         bool            qfallback;
 143         bool            qds;
 144         bool            qusevc;
 145         bool            qrandom;
 146
 147         char            *resolv_conf_file = NULL;
 148
 149         ldns_rdf *trace_start_name = NULL;
 150
 151         int             result = 0;
 152
 153 #ifdef USE_WINSOCK
 154         int r;
 155         WSADATA wsa_data;
 156 #endif
 157
 158         int_type = -1; serv = NULL; type = 0;
 159         int_clas = -1; name = NULL; clas = 0;
 160         qname = NULL;
 161         progname = strdup(argv[0]);
 162
 163 #ifdef USE_WINSOCK
 164         r = WSAStartup(MAKEWORD(2,2), &wsa_data);
 165         if(r != 0) {
 166                 printf("Failed WSAStartup: %d\n", r);
 167                 result = EXIT_FAILURE;
 168                 goto exit;
 169         }
 170 #endif /* USE_WINSOCK */
 171
 172
 173         PURPOSE = DRILL_QUERY;
 174         qflags = LDNS_RD;
 175         qport = LDNS_PORT;
 176         verbosity = 2;
 177         qdnssec = false;
 178         qfamily = LDNS_RESOLV_INETANY;
 179         qfallback = false;
 180         qds = false;
 181         qbuf = 0;
 182         qusevc = false;
 183         qrandom = true;
 184         key_verified = NULL;
 185
 186         ldns_init_random(NULL, 0);
 187
 188         if (argc == 0) {
 189                 usage(stdout, progname);
 190                 result = EXIT_FAILURE;
 191                 goto exit;
 192         }
 193
 194         /* string from orig drill: "i:w:I46Sk:TNp:b:DsvhVcuaq:f:xr" */
 195         /* global first, query opt next, option with parm's last
 196          * and sorted */ /*  "46DITSVQf:i:w:q:achuvxzy:so:p:b:k:" */
 197
 198         while ((c = getopt(argc, argv, "46ab:c:d:Df:hi:Ik:o:p:q:Qr:sStTuvV:w:xy:z")) != -1) {
 199                 switch(c) {
 200                         /* global options */
 201                         case '4':
 202                                 qfamily = LDNS_RESOLV_INET;
 203                                 break;
 204                         case '6':
 205                                 qfamily = LDNS_RESOLV_INET6;
 206                                 break;
 207                         case 'D':
 208                                 qdnssec = true;
 209                                 break;
 210                         case 'I':
 211                                 /* reserved for backward compatibility */
 212                                 break;
 213                         case 'T':
 214                                 if (PURPOSE == DRILL_CHASE) {
 215                                         fprintf(stderr, "-T and -S cannot be used at the same time.\n");
 216                                         exit(EXIT_FAILURE);
 217                                 }
 218                                 PURPOSE = DRILL_TRACE;
 219                                 break;
 220 #ifdef HAVE_SSL
 221                         case 'S':
 222                                 if (PURPOSE == DRILL_TRACE) {
 223                                         fprintf(stderr, "-T and -S cannot be used at the same time.\n");
 224                                         exit(EXIT_FAILURE);
 225                                 }
 226                                 PURPOSE = DRILL_CHASE;
 227                                 break;
 228 #endif /* HAVE_SSL */
 229                         case 'V':
 230                                 if (strtok(optarg, "0123456789") != NULL) {
 231                                         fprintf(stderr, "-V expects an number as an argument.\n");
 232                                         exit(EXIT_FAILURE);
 233                                 }
 234                                 verbosity = atoi(optarg);
 235                                 break;
 236                         case 'Q':
 237                                 verbosity = -1;
 238                                 break;
 239                         case 'f':
 240                                 query_file = optarg;
 241                                 break;
 242                         case 'i':
 243                                 answer_file = optarg;
 244                                 PURPOSE = DRILL_AFROMFILE;
 245                                 break;
 246                         case 'w':
 247                                 answer_file = optarg;
 248                                 break;
 249                         case 'q':
 250                                 query_file = optarg;
 251                                 PURPOSE = DRILL_QTOFILE;
 252                                 break;
 253                         case 'r':
 254                                 if (global_dns_root) {
 255                                         fprintf(stderr, "There was already a series of root servers set\n");
 256                                         exit(EXIT_FAILURE);
 257                                 }
 258                                 global_dns_root = read_root_hints(optarg);
 259                                 if (!global_dns_root) {
 260                                         fprintf(stderr, "Unable to read root hints file %s, aborting\n", optarg);
 261                                         exit(EXIT_FAILURE);
 262                                 }
 263                                 break;
 264                         /* query options */
 265                         case 'a':
 266                                 qfallback = true;
 267                                 break;
 268                         case 'b':
 269                                 qbuf = (uint16_t)atoi(optarg);
 270                                 if (qbuf == 0) {
 271                                         error("%s", "<bufsize> could not be converted");
 272                                 }
 273                                 break;
 274                         case 'c':
 275                                 resolv_conf_file = optarg;
 276                                 break;
 277                         case 't':
 278                                 qusevc = true;
 279                                 break;
 280                         case 'k':
 281                                 status = read_key_file(optarg,
 282                                                 key_list, false);
 283                                 if (status != LDNS_STATUS_OK) {
 284                                         error("Could not parse the key file %s: %s", optarg, ldns_get_errorstr_by_id(status));
 285                                 }
 286                                 qdnssec = true; /* enable that too */
 287                                 break;
 288                         case 'o':
 289                                 /* only looks at the first hit: capital=ON, lowercase=OFF*/
 290                                 if (strstr(optarg, "QR")) {
 291                                         DRILL_ON(qflags, LDNS_QR);
 292                                 }
 293                                 if (strstr(optarg, "qr")) {
 294                                         DRILL_OFF(qflags, LDNS_QR);
 295                                 }
 296                                 if (strstr(optarg, "AA")) {
 297                                         DRILL_ON(qflags, LDNS_AA);
 298                                 }
 299                                 if (strstr(optarg, "aa")) {
 300                                         DRILL_OFF(qflags, LDNS_AA);
 301                                 }
 302                                 if (strstr(optarg, "TC")) {
 303                                         DRILL_ON(qflags, LDNS_TC);
 304                                 }
 305                                 if (strstr(optarg, "tc")) {
 306                                         DRILL_OFF(qflags, LDNS_TC);
 307                                 }
 308                                 if (strstr(optarg, "RD")) {
 309                                         DRILL_ON(qflags, LDNS_RD);
 310                                 }
 311                                 if (strstr(optarg, "rd")) {
 312                                         DRILL_OFF(qflags, LDNS_RD);
 313                                 }
 314                                 if (strstr(optarg, "CD")) {
 315                                         DRILL_ON(qflags, LDNS_CD);
 316                                 }
 317                                 if (strstr(optarg, "cd")) {
 318                                         DRILL_OFF(qflags, LDNS_CD);
 319                                 }
 320                                 if (strstr(optarg, "RA")) {
 321                                         DRILL_ON(qflags, LDNS_RA);
 322                                 }
 323                                 if (strstr(optarg, "ra")) {
 324                                         DRILL_OFF(qflags, LDNS_RA);
 325                                 }
 326                                 if (strstr(optarg, "AD")) {
 327                                         DRILL_ON(qflags, LDNS_AD);
 328                                 }
 329                                 if (strstr(optarg, "ad")) {
 330                                         DRILL_OFF(qflags, LDNS_AD);
 331                                 }
 332                                 break;
 333                         case 'p':
 334                                 qport = (uint16_t)atoi(optarg);
 335                                 if (qport == 0) {
 336                                         error("%s", "<port> could not be converted");
 337                                 }
 338                                 break;
 339                         case 's':
 340                                 qds = true;
 341                                 break;
 342                         case 'u':
 343                                 qusevc = false;
 344                                 break;
 345                         case 'v':
 346                                 version(stdout, progname);
 347                                 result = EXIT_SUCCESS;
 348                                 goto exit;
 349                         case 'x':
 350                                 PURPOSE = DRILL_REVERSE;
 351                                 break;
 352                         case 'y':
 353 #ifdef HAVE_SSL
 354                                 if (strchr(optarg, ':')) {
 355                                         tsig_separator = (size_t) (strchr(optarg, ':') - optarg);
 356                                         if (strchr(optarg + tsig_separator + 1, ':')) {
 357                                                 tsig_separator2 = (size_t) (strchr(optarg + tsig_separator + 1, ':') - optarg);
 358                                                 tsig_algorithm = xmalloc(strlen(optarg) - tsig_separator2);
 359                                                 strncpy(tsig_algorithm, optarg + tsig_separator2 + 1, strlen(optarg) - tsig_separator2);
 360                                                 tsig_algorithm[strlen(optarg) - tsig_separator2 - 1] = '\0';
 361                                         } else {
 362                                                 tsig_separator2 = strlen(optarg);
 363                                                 tsig_algorithm = xmalloc(26);
 364                                                 strncpy(tsig_algorithm, "hmac-md5.sig-alg.reg.int.", 25);
 365                                                 tsig_algorithm[25] = '\0';
 366                                         }
 367                                         tsig_name = xmalloc(tsig_separator + 1);
 368                                         tsig_data = xmalloc(tsig_separator2 - tsig_separator);
 369                                         strncpy(tsig_name, optarg, tsig_separator);
 370                                         strncpy(tsig_data, optarg + tsig_separator + 1, tsig_separator2 - tsig_separator - 1);
 371                                         /* strncpy does not append \0 if source is longer than n */
 372                                         tsig_name[tsig_separator] = '\0';
 373                                         tsig_data[ tsig_separator2 - tsig_separator - 1] = '\0';
 374                                 }
 375 #else
 376                                 fprintf(stderr, "TSIG requested, but SSL is not supported\n");
 377                                 result = EXIT_FAILURE;
 378                                 goto exit;
 379 #endif /* HAVE_SSL */
 380                                 break;
 381                         case 'z':
 382                                 qrandom = false;
 383                                 break;
 384                         case 'd':
 385                                 trace_start_name = ldns_dname_new_frm_str(optarg);
 386                                 if (!trace_start_name) {
 387                                         fprintf(stderr, "Unable to parse argument for -%c\n", c);
 388                                         result = EXIT_FAILURE;
 389                                         goto exit;
 390                                 }
 391                                 break;
 392                         case 'h':
 393                                 version(stdout, progname);
 394                                 usage(stdout, progname);
 395                                 result = EXIT_SUCCESS;
 396                                 goto exit;
 397                                 break;
 398                         default:
 399                                 fprintf(stderr, "Unknown argument: -%c, use -h to see usage\n", c);
 400                                 result = EXIT_FAILURE;
 401                                 goto exit;
 402                 }
 403         }
 404         argc -= optind;
 405         argv += optind;
 406
 407         if ((PURPOSE == DRILL_CHASE || (PURPOSE == DRILL_TRACE && qdnssec)) &&
 408                         ldns_rr_list_rr_count(key_list) == 0) {
 409
 410                 (void) read_key_file(LDNS_TRUST_ANCHOR_FILE, key_list, true);
 411         }
 412         if (ldns_rr_list_rr_count(key_list) > 0) {
 413                 printf(";; Number of trusted keys: %d\n",
 414                                 (int) ldns_rr_list_rr_count(key_list));
 415         }
 416         /* do a secure trace when requested */
 417         if (PURPOSE == DRILL_TRACE && qdnssec) {
 418 #ifdef HAVE_SSL
 419                 if (ldns_rr_list_rr_count(key_list) == 0) {
 420                         warning("%s", "No trusted keys were given. Will not be able to verify authenticity!");
 421                 }
 422                 PURPOSE = DRILL_SECTRACE;
 423 #else
 424                 fprintf(stderr, "ldns has not been compiled with OpenSSL support. Secure trace not available\n");
 425                 exit(1);
 426 #endif /* HAVE_SSL */
 427         }
 428
 429         /* parse the arguments, with multiple arguments, the last argument
 430          * found is used */
 431         for(i = 0; i < argc; i++) {
 432
 433                 /* if ^@ then it's a server */
 434                 if (argv[i][0] == '@') {
 435                         if (strlen(argv[i]) == 1) {
 436                                 warning("%s", "No nameserver given");
 437                                 exit(EXIT_FAILURE);
 438                         }
 439                         serv = argv[i] + 1;
 440                         continue;
 441                 }
 442                 /* if has a dot, it's a name */
 443                 if (strchr(argv[i], '.')) {
 444                         name = argv[i];
 445                         continue;
 446                 }
 447                 /* if it matches a type, it's a type */
 448                 if (int_type == -1) {
 449                         type = ldns_get_rr_type_by_name(argv[i]);
 450                         if (type != 0) {
 451                                 int_type = 0;
 452                                 continue;
 453                         }
 454                 }
 455                 /* if it matches a class, it's a class */
 456                 if (int_clas == -1) {
 457                         clas = ldns_get_rr_class_by_name(argv[i]);
 458                         if (clas != 0) {
 459                                 int_clas = 0;
 460                                 continue;
 461                         }
 462                 }
 463                 /* it all fails assume it's a name */
 464                 name = argv[i];
 465         }
 466         /* act like dig and use for . NS */
 467         if (!name) {
 468                 name = ".";
 469                 int_type = 0;
 470                 type = LDNS_RR_TYPE_NS;
 471         }
 472
 473         /* defaults if not given */
 474         if (int_clas == -1) {
 475                 clas = LDNS_RR_CLASS_IN;
 476         }
 477         if (int_type == -1) {
 478                 if (PURPOSE != DRILL_REVERSE) {
 479                         type = LDNS_RR_TYPE_A;
 480                 } else {
 481                         type = LDNS_RR_TYPE_PTR;
 482                 }
 483         }
 484
 485         /* set the nameserver to use */
 486         if (!serv) {
 487                 /* no server given make a resolver from /etc/resolv.conf */
 488                 status = ldns_resolver_new_frm_file(&res, resolv_conf_file);
 489                 if (status != LDNS_STATUS_OK) {
 490                         warning("Could not create a resolver structure: %s (%s)\n"
 491                                         "Try drill @localhost if you have a resolver running on your machine.",
 492                                     ldns_get_errorstr_by_id(status), resolv_conf_file);
 493                         result = EXIT_FAILURE;
 494                         goto exit;
 495                 }
 496         } else {
 497                 res = ldns_resolver_new();
 498                 if (!res || strlen(serv) <= 0) {
 499                         warning("Could not create a resolver structure");
 500                         result = EXIT_FAILURE;
 501                         goto exit;
 502                 }
 503                 /* add the nameserver */
 504                 serv_rdf = ldns_rdf_new_addr_frm_str(serv);
 505                 if (!serv_rdf) {
 506                         /* try to resolv the name if possible */
 507                         status = ldns_resolver_new_frm_file(&cmdline_res, resolv_conf_file);
 508
 509                         if (status != LDNS_STATUS_OK) {
 510                                 error("%s", "@server ip could not be converted");
 511                         }
 512                         ldns_resolver_set_dnssec(cmdline_res, qdnssec);
 513                         ldns_resolver_set_ip6(cmdline_res, qfamily);
 514                         ldns_resolver_set_fallback(cmdline_res, qfallback);
 515                         ldns_resolver_set_usevc(cmdline_res, qusevc);
 516
 517                         cmdline_dname = ldns_dname_new_frm_str(serv);
 518
 519                         cmdline_rr_list = ldns_get_rr_list_addr_by_name(
 520                                                 cmdline_res,
 521                                                 cmdline_dname,
 522                                                 LDNS_RR_CLASS_IN,
 523                                                 qflags);
 524                         ldns_rdf_deep_free(cmdline_dname);
 525                         if (!cmdline_rr_list) {
 526                                 /* This error msg is not always accurate */
 527                                 error("%s `%s\'", "could not find any address for the name:", serv);
 528                         } else {
 529                                 if (ldns_resolver_push_nameserver_rr_list(
 530                                                 res,
 531                                                 cmdline_rr_list
 532                                         ) != LDNS_STATUS_OK) {
 533                                         error("%s", "pushing nameserver");
 534                                 }
 535                         }
 536                 } else {
 537                         if (ldns_resolver_push_nameserver(res, serv_rdf) != LDNS_STATUS_OK) {
 538                                 error("%s", "pushing nameserver");
 539                         } else {
 540                                 ldns_rdf_deep_free(serv_rdf);
 541                         }
 542                 }
 543         }
 544         /* set the resolver options */
 545         ldns_resolver_set_port(res, qport);
 546         if (verbosity >= 5) {
 547                 ldns_resolver_set_debug(res, true);
 548         } else {
 549                 ldns_resolver_set_debug(res, false);
 550         }
 551         ldns_resolver_set_dnssec(res, qdnssec);
 552 /*      ldns_resolver_set_dnssec_cd(res, qdnssec);*/
 553         ldns_resolver_set_ip6(res, qfamily);
 554         ldns_resolver_set_fallback(res, qfallback);
 555         ldns_resolver_set_usevc(res, qusevc);
 556         ldns_resolver_set_random(res, qrandom);
 557         if (qbuf != 0) {
 558                 ldns_resolver_set_edns_udp_size(res, qbuf);
 559         }
 560
 561         if (!name &&
 562             PURPOSE != DRILL_AFROMFILE &&
 563             !query_file
 564            ) {
 565                 usage(stdout, progname);
 566                 result = EXIT_FAILURE;
 567                 goto exit;
 568         }
 569
 570         if (tsig_name && tsig_data) {
 571                 ldns_resolver_set_tsig_keyname(res, tsig_name);
 572                 ldns_resolver_set_tsig_keydata(res, tsig_data);
 573                 ldns_resolver_set_tsig_algorithm(res, tsig_algorithm);
 574         }
 575
 576         /* main switching part of drill */
 577         switch(PURPOSE) {
 578                 case DRILL_TRACE:
 579                         /* do a trace from the root down */
 580                         if (!global_dns_root) {
 581                                 init_root();
 582                         }
 583                         qname = ldns_dname_new_frm_str(name);
 584                         if (!qname) {
 585                                 error("%s", "parsing query name");
 586                         }
 587                         /* don't care about return packet */
 588                         (void)do_trace(res, qname, type, clas);
 589                         clear_root();
 590                         break;
 591                 case DRILL_SECTRACE:
 592                         /* do a secure trace from the root down */
 593                         if (!global_dns_root) {
 594                                 init_root();
 595                         }
 596                         qname = ldns_dname_new_frm_str(name);
 597                         if (!qname) {
 598                                 error("%s", "making qname");
 599                         }
 600                         /* don't care about return packet */
 601 #ifdef HAVE_SSL
 602                         result = do_secure_trace(res, qname, type, clas, key_list, trace_start_name);
 603 #endif /* HAVE_SSL */
 604                         clear_root();
 605                         break;
 606                 case DRILL_CHASE:
 607                         qname = ldns_dname_new_frm_str(name);
 608                         if (!qname) {
 609                                 error("%s", "making qname");
 610                         }
 611
 612                         ldns_resolver_set_dnssec(res, true);
 613                         ldns_resolver_set_dnssec_cd(res, true);
 614                         /* set dnssec implies udp_size of 4096 */
 615                         ldns_resolver_set_edns_udp_size(res, 4096);
 616                         pkt = ldns_resolver_query(res, qname, type, clas, qflags);
 617
 618                         if (!pkt) {
 619                                 error("%s", "error pkt sending");
 620                                 result = EXIT_FAILURE;
 621                         } else {
 622                                 if (verbosity >= 3) {
 623                                         ldns_pkt_print(stdout, pkt);
 624                                 }
 625
 626                                 if (!ldns_pkt_answer(pkt)) {
 627                                         mesg("No answer in packet");
 628                                 } else {
 629 #ifdef HAVE_SSL
 630                                         ldns_resolver_set_dnssec_anchors(res, ldns_rr_list_clone(key_list));
 631                                         result = do_chase(res, qname, type,
 632                                                           clas, key_list,
 633                                                           pkt, qflags, NULL,
 634                                                                    verbosity);
 635                                         if (result == LDNS_STATUS_OK) {
 636                                                 if (verbosity != -1) {
 637                                                         mesg("Chase successful");
 638                                                 }
 639                                                 result = 0;
 640                                         } else {
 641                                                 if (verbosity != -1) {
 642                                                         mesg("Chase failed.");
 643                                                 }
 644                                         }
 645 #endif /* HAVE_SSL */
 646                                 }
 647                                 ldns_pkt_free(pkt);
 648                         }
 649                         break;
 650                 case DRILL_AFROMFILE:
 651                         pkt = read_hex_pkt(answer_file);
 652                         if (pkt) {
 653                                 if (verbosity != -1) {
 654                                         ldns_pkt_print(stdout, pkt);
 655                                 }
 656                                 ldns_pkt_free(pkt);
 657                         }
 658
 659                         break;
 660                 case DRILL_QTOFILE:
 661                         qname = ldns_dname_new_frm_str(name);
 662                         if (!qname) {
 663                                 error("%s", "making qname");
 664                         }
 665
 666                         status = ldns_resolver_prepare_query_pkt(&qpkt, res, qname, type, clas, qflags);
 667                         if(status != LDNS_STATUS_OK) {
 668                                 error("%s", "making query: %s",
 669                                         ldns_get_errorstr_by_id(status));
 670                         }
 671                         dump_hex(qpkt, query_file);
 672                         ldns_pkt_free(qpkt);
 673                         break;
 674                 case DRILL_NSEC:
 675                         break;
 676                 case DRILL_REVERSE:
 677                         /* ipv4 or ipv6 addr? */
 678                         if (strchr(name, ':')) {
 679                                 if (strchr(name, '.')) {
 680                                         error("Syntax error: both '.' and ':' seen in address\n");
 681                                 }
 682                                 name2 = malloc(IP6_ARPA_MAX_LEN + 20);
 683                                 c = 0;
 684                                 for (i=0; i<(int)strlen(name); i++) {
 685                                         if (i >= IP6_ARPA_MAX_LEN) {
 686                                                 error("%s", "reverse argument to long");
 687                                         }
 688                                         if (name[i] == ':') {
 689                                                 if (i < (int) strlen(name) && name[i + 1] == ':') {
 690                                                         error("%s", ":: not supported (yet)");
 691                                                 } else {
 692                                                         if (i + 2 == (int) strlen(name) || name[i + 2] == ':') {
 693                                                                 name2[c++] = '0';
 694                                                                 name2[c++] = '.';
 695                                                                 name2[c++] = '0';
 696                                                                 name2[c++] = '.';
 697                                                                 name2[c++] = '0';
 698                                                                 name2[c++] = '.';
 699                                                         } else if (i + 3 == (int) strlen(name) || name[i + 3] == ':') {
 700                                                                 name2[c++] = '0';
 701                                                                 name2[c++] = '.';
 702                                                                 name2[c++] = '0';
 703                                                                 name2[c++] = '.';
 704                                                         } else if (i + 4 == (int) strlen(name) || name[i + 4] == ':') {
 705                                                                 name2[c++] = '0';
 706                                                                 name2[c++] = '.';
 707                                                         }
 708                                                 }
 709                                         } else {
 710                                                 name2[c++] = name[i];
 711                                                 name2[c++] = '.';
 712                                         }
 713                                 }
 714                                 name2[c++] = '\0';
 715
 716                                 qname = ldns_dname_new_frm_str(name2);
 717                                 qname_tmp = ldns_dname_reverse(qname);
 718                                 ldns_rdf_deep_free(qname);
 719                                 qname = qname_tmp;
 720                                 qname_tmp = ldns_dname_new_frm_str("ip6.arpa.");
 721                                 status = ldns_dname_cat(qname, qname_tmp);
 722                                 if (status != LDNS_STATUS_OK) {
 723                                         error("%s", "could not create reverse address for ip6: %s\n", ldns_get_errorstr_by_id(status));
 724                                 }
 725                                 ldns_rdf_deep_free(qname_tmp);
 726
 727                                 free(name2);
 728                         } else {
 729                                 qname = ldns_dname_new_frm_str(name);
 730                                 qname_tmp = ldns_dname_reverse(qname);
 731                                 ldns_rdf_deep_free(qname);
 732                                 qname = qname_tmp;
 733                                 qname_tmp = ldns_dname_new_frm_str("in-addr.arpa.");
 734                                 status = ldns_dname_cat(qname, qname_tmp);
 735                                 if (status != LDNS_STATUS_OK) {
 736                                         error("%s", "could not create reverse address for ip4: %s\n", ldns_get_errorstr_by_id(status));
 737                                 }
 738                                 ldns_rdf_deep_free(qname_tmp);
 739                         }
 740                         if (!qname) {
 741                                 error("%s", "-x implies an ip address");
 742                         }
 743
 744                         /* create a packet and set the RD flag on it */
 745                         pkt = ldns_resolver_query(res, qname, type, clas, qflags);
 746                         if (!pkt)  {
 747                                 error("%s", "pkt sending");
 748                                 result = EXIT_FAILURE;
 749                         } else {
 750                                 if (verbosity != -1) {
 751                                         ldns_pkt_print(stdout, pkt);
 752                                 }
 753                                 ldns_pkt_free(pkt);
 754                         }
 755                         break;
 756                 case DRILL_QUERY:
 757                 default:
 758                         if (query_file) {
 759                                 /* this old way, the query packet needed
 760                                    to be parseable, but we want to be able
 761                                    to send mangled packets, so we need
 762                                    to do it directly */
 763                                 #if 0
 764                                 qpkt = read_hex_pkt(query_file);
 765                                 if (qpkt) {
 766                                         status = ldns_resolver_send_pkt(&pkt, res, qpkt);
 767                                         if (status != LDNS_STATUS_OK) {
 768                                                 printf("Error: %s\n", ldns_get_errorstr_by_id(status));
 769                                                 exit(1);
 770                                         }
 771                                 } else {
 772                                         /* qpkt was bogus, reset pkt */
 773                                         pkt = NULL;
 774                                 }
 775                                 #endif
 776                                 query_buffer = read_hex_buffer(query_file);
 777                                 if (query_buffer) {
 778                                         status = ldns_send_buffer(&pkt, res, query_buffer, NULL);
 779                                         ldns_buffer_free(query_buffer);
 780                                         if (status != LDNS_STATUS_OK) {
 781                                                 printf("Error: %s\n", ldns_get_errorstr_by_id(status));
 782                                                 exit(1);
 783                                         }
 784                                 } else {
 785                                         printf("NO BUFFER\n");
 786                                         pkt = NULL;
 787                                 }
 788                         } else {
 789                                 qname = ldns_dname_new_frm_str(name);
 790                                 if (!qname) {
 791                                         error("%s", "error in making qname");
 792                                 }
 793
 794                                 if (type == LDNS_RR_TYPE_AXFR) {
 795                                         status = ldns_axfr_start(res, qname, clas);
 796                                         if(status != LDNS_STATUS_OK) {
 797                                                 error("Error starting axfr: %s",
 798                                                         ldns_get_errorstr_by_id(status));
 799                                         }
 800                                         axfr_rr = ldns_axfr_next(res);
 801                                         if(!axfr_rr) {
 802                                                 fprintf(stderr, "AXFR failed.\n");
 803                                                 ldns_pkt_print(stdout,
 804                                                         ldns_axfr_last_pkt(res));
 805                                                 goto exit;
 806                                         }
 807                                         while (axfr_rr) {
 808                                                 if (verbosity != -1) {
 809                                                         ldns_rr_print(stdout, axfr_rr);
 810                                                 }
 811                                                 ldns_rr_free(axfr_rr);
 812                                                 axfr_rr = ldns_axfr_next(res);
 813                                         }
 814
 815                                         goto exit;
 816                                 } else {
 817                                         /* create a packet and set the RD flag on it */
 818                                         pkt = ldns_resolver_query(res, qname, type, clas, qflags);
 819                                 }
 820                         }
 821
 822                         if (!pkt)  {
 823                                 mesg("No packet received");
 824                                 result = EXIT_FAILURE;
 825                         } else {
 826                                 if (verbosity != -1) {
 827                                         ldns_pkt_print(stdout, pkt);
 828                                         if (ldns_pkt_tc(pkt)) {
 829                                                 fprintf(stdout,
 830                                                         "\n;; WARNING: The answer packet was truncated; you might want to\n");
 831                                                 fprintf(stdout,
 832                                                         ";; query again with TCP (-t argument), or EDNS0 (-b for buffer size)\n");
 833                                         }
 834                                 }
 835                                 if (qds) {
 836                                         if (verbosity != -1) {
 837                                                 print_ds_of_keys(pkt);
 838                                                 printf("\n");
 839                                         }
 840                                 }
 841
 842                                 if (ldns_rr_list_rr_count(key_list) > 0) {
 843                                         /* -k's were given on the cmd line */
 844                                         ldns_rr_list *rrset_verified;
 845                                         uint16_t key_count;
 846
 847                                         rrset_verified = ldns_pkt_rr_list_by_name_and_type(
 848                                                         pkt, qname, type,
 849                                                         LDNS_SECTION_ANY_NOQUESTION);
 850
 851                                         if (type == LDNS_RR_TYPE_ANY) {
 852                                                 /* don't verify this */
 853                                                 break;
 854                                         }
 855
 856                                         if (verbosity != -1) {
 857                                                 printf("; ");
 858                                                 ldns_rr_list_print(stdout, rrset_verified);
 859                                         }
 860
 861                                         /* verify */
 862 #ifdef HAVE_SSL
 863                                         key_verified = ldns_rr_list_new();
 864                                         result = ldns_pkt_verify(pkt, type, qname, key_list, NULL, key_verified);
 865
 866                                         if (result == LDNS_STATUS_ERR) {
 867                                                 /* is the existence denied then? */
 868                                                 result = ldns_verify_denial(pkt, qname, type, NULL, NULL);
 869                                                 if (result == LDNS_STATUS_OK) {
 870                                                         if (verbosity != -1) {
 871                                                                 printf("Existence denied for ");
 872                                                                 ldns_rdf_print(stdout, qname);
 873                                                                 type_str = ldns_rr_type2str(type);
 874                                                                 printf("\t%s\n", type_str);
 875                                                                 LDNS_FREE(type_str);
 876                                                         }
 877                                                 } else {
 878                                                         if (verbosity != -1) {
 879                                                                 printf("Bad data; RR for name and "
 880                                                                        "type not found or failed to "
 881                                                                        "verify, and denial of "
 882                                                                        "existence failed.\n");
 883                                                         }
 884                                                 }
 885                                         } else if (result == LDNS_STATUS_OK) {
 886                                                 for(key_count = 0; key_count < ldns_rr_list_rr_count(key_verified);
 887                                                                 key_count++) {
 888                                                         if (verbosity != -1) {
 889                                                                 printf("; VALIDATED by id = %u, owner = ",
 890                                                                                 (unsigned int)ldns_calc_keytag(
 891                                                                                                       ldns_rr_list_rr(key_verified, key_count)));
 892                                                                 ldns_rdf_print(stdout, ldns_rr_owner(
 893                                                                                         ldns_rr_list_rr(key_list, key_count)));
 894                                                                 printf("\n");
 895                                                         }
 896                                                 }
 897                                         } else {
 898                                                 for(key_count = 0; key_count < ldns_rr_list_rr_count(key_list);
 899                                                                 key_count++) {
 900                                                         if (verbosity != -1) {
 901                                                                 printf("; %s for id = %u, owner = ",
 902                                                                        ldns_get_errorstr_by_id(result),
 903                                                                        (unsigned int)ldns_calc_keytag(
 904                                                                                                       ldns_rr_list_rr(key_list, key_count)));
 905                                                                 ldns_rdf_print(stdout, ldns_rr_owner(
 906
 907                                                                 ldns_rr_list_rr(key_list,
 908                                                                 key_count)));
 909                                                                 printf("\n");
 910                                                         }
 911                                                 }
 912                                         }
 913                                         ldns_rr_list_free(key_verified);
 914 #else
 915                                         (void) key_count;
 916 #endif /* HAVE_SSL */
 917                                 }
 918                                 if (answer_file) {
 919                                         dump_hex(pkt, answer_file);
 920                                 }
 921                                 ldns_pkt_free(pkt);
 922                         }
 923
 924                         break;
 925         }
 926
 927         exit:
 928         ldns_rdf_deep_free(qname);
 929         ldns_resolver_deep_free(res);
 930         ldns_resolver_deep_free(cmdline_res);
 931         ldns_rr_list_deep_free(key_list);
 932         ldns_rr_list_deep_free(cmdline_rr_list);
 933         ldns_rdf_deep_free(trace_start_name);
 934         xfree(progname);
 935         xfree(tsig_name);
 936         xfree(tsig_data);
 937         xfree(tsig_algorithm);
 938
 939 #ifdef HAVE_SSL
 940         ERR_remove_state(0);
 941         CRYPTO_cleanup_all_ex_data();
 942         ERR_free_strings();
 943         EVP_cleanup();
 944 #endif
 945 #ifdef USE_WINSOCK
 946         WSACleanup();
 947 #endif
 948
 949         return result;
 950 }