adig.c

   1 /* Copyright 1998 by the Massachusetts Institute of Technology.
   2  *
   3  * Permission to use, copy, modify, and distribute this
   4  * software and its documentation for any purpose and without
   5  * fee is hereby granted, provided that the above copyright
   6  * notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting
   8  * documentation, and that the name of M.I.T. not be used in
   9  * advertising or publicity pertaining to distribution of the
  10  * software without specific, written prior permission.
  11  * M.I.T. makes no representations about the suitability of
  12  * this software for any purpose.  It is provided "as is"
  13  * without express or implied warranty.
  14  */
  15
  16 #include "setup.h"
  17 #include <sys/types.h>
  18
  19 #ifdef WIN32
  20 #include "nameser.h"
  21 #else
  22 #include <sys/time.h>
  23 #include <sys/socket.h>
  24 #include <netinet/in.h>
  25 #include <arpa/inet.h>
  26 #include <arpa/nameser.h>
  27 #include <unistd.h>
  28 #include <netdb.h>
  29 #endif
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <ctype.h>
  35 #include <errno.h>
  36 #include "ares.h"
  37 #include "ares_dns.h"
  38
  39 #ifndef INADDR_NONE
  40 #define INADDR_NONE 0xffffffff
  41 #endif
  42
  43 /* Mac OS X portability check */
  44 #ifndef T_SRV
  45 #define T_SRV 33 /* server selection */
  46 #endif
  47
  48 extern int optind;
  49 extern char *optarg;
  50
  51 struct nv {
  52   const char *name;
  53   int value;
  54 };
  55
  56 static const struct nv flags[] = {
  57   { "usevc",            ARES_FLAG_USEVC },
  58   { "primary",          ARES_FLAG_PRIMARY },
  59   { "igntc",            ARES_FLAG_IGNTC },
  60   { "norecurse",        ARES_FLAG_NORECURSE },
  61   { "stayopen",         ARES_FLAG_STAYOPEN },
  62   { "noaliases",        ARES_FLAG_NOALIASES }
  63 };
  64 static const int nflags = sizeof(flags) / sizeof(flags[0]);
  65
  66 static const struct nv classes[] = {
  67   { "IN",       C_IN },
  68   { "CHAOS",    C_CHAOS },
  69   { "HS",       C_HS },
  70   { "ANY",      C_ANY }
  71 };
  72 static const int nclasses = sizeof(classes) / sizeof(classes[0]);
  73
  74 static const struct nv types[] = {
  75   { "A",        T_A },
  76   { "NS",       T_NS },
  77   { "MD",       T_MD },
  78   { "MF",       T_MF },
  79   { "CNAME",    T_CNAME },
  80   { "SOA",      T_SOA },
  81   { "MB",       T_MB },
  82   { "MG",       T_MG },
  83   { "MR",       T_MR },
  84   { "NULL",     T_NULL },
  85   { "WKS",      T_WKS },
  86   { "PTR",      T_PTR },
  87   { "HINFO",    T_HINFO },
  88   { "MINFO",    T_MINFO },
  89   { "MX",       T_MX },
  90   { "TXT",      T_TXT },
  91   { "RP",       T_RP },
  92   { "AFSDB",    T_AFSDB },
  93   { "X25",      T_X25 },
  94   { "ISDN",     T_ISDN },
  95   { "RT",       T_RT },
  96   { "NSAP",     T_NSAP },
  97   { "NSAP_PTR", T_NSAP_PTR },
  98   { "SIG",      T_SIG },
  99   { "KEY",      T_KEY },
 100   { "PX",       T_PX },
 101   { "GPOS",     T_GPOS },
 102   { "AAAA",     T_AAAA },
 103   { "LOC",      T_LOC },
 104   { "SRV",      T_SRV },
 105   { "AXFR",     T_AXFR },
 106   { "MAILB",    T_MAILB },
 107   { "MAILA",    T_MAILA },
 108   { "ANY",      T_ANY }
 109 };
 110 static const int ntypes = sizeof(types) / sizeof(types[0]);
 111
 112 static const char *opcodes[] = {
 113   "QUERY", "IQUERY", "STATUS", "(reserved)", "NOTIFY",
 114   "(unknown)", "(unknown)", "(unknown)", "(unknown)",
 115   "UPDATEA", "UPDATED", "UPDATEDA", "UPDATEM", "UPDATEMA",
 116   "ZONEINIT", "ZONEREF"
 117 };
 118
 119 static const char *rcodes[] = {
 120   "NOERROR", "FORMERR", "SERVFAIL", "NXDOMAIN", "NOTIMP", "REFUSED",
 121   "(unknown)", "(unknown)", "(unknown)", "(unknown)", "(unknown)",
 122   "(unknown)", "(unknown)", "(unknown)", "(unknown)", "NOCHANGE"
 123 };
 124
 125 static void callback(void *arg, int status, unsigned char *abuf, int alen);
 126 static const unsigned char *display_question(const unsigned char *aptr,
 127                                              const unsigned char *abuf,
 128                                              int alen);
 129 static const unsigned char *display_rr(const unsigned char *aptr,
 130                                        const unsigned char *abuf, int alen);
 131 static const char *type_name(int type);
 132 static const char *class_name(int dnsclass);
 133 static void usage(void);
 134
 135 int main(int argc, char **argv)
 136 {
 137   ares_channel channel;
 138   int c, i, optmask = ARES_OPT_FLAGS, dnsclass = C_IN, type = T_A;
 139   int status, nfds, count;
 140   struct ares_options options;
 141   struct hostent *hostent;
 142   fd_set read_fds, write_fds;
 143   struct timeval *tvp, tv;
 144
 145 #ifdef WIN32
 146   WORD wVersionRequested = MAKEWORD(1,1);
 147   WSADATA wsaData;
 148   WSAStartup(wVersionRequested, &wsaData);
 149 #endif
 150
 151   options.flags = ARES_FLAG_NOCHECKRESP;
 152   options.servers = NULL;
 153   options.nservers = 0;
 154   while ((c = getopt(argc, argv, "f:s:c:t:T:U:")) != -1)
 155     {
 156       switch (c)
 157         {
 158         case 'f':
 159           /* Add a flag. */
 160           for (i = 0; i < nflags; i++)
 161             {
 162               if (strcmp(flags[i].name, optarg) == 0)
 163                 break;
 164             }
 165           if (i == nflags)
 166             usage();
 167           options.flags |= flags[i].value;
 168           break;
 169
 170         case 's':
 171           /* Add a server, and specify servers in the option mask. */
 172           hostent = gethostbyname(optarg);
 173           if (!hostent || hostent->h_addrtype != AF_INET)
 174             {
 175               fprintf(stderr, "adig: server %s not found.\n", optarg);
 176               return 1;
 177             }
 178           options.servers = realloc(options.servers, (options.nservers + 1)
 179                                     * sizeof(struct in_addr));
 180           if (!options.servers)
 181             {
 182               fprintf(stderr, "Out of memory!\n");
 183               return 1;
 184             }
 185           memcpy(&options.servers[options.nservers], hostent->h_addr,
 186                  sizeof(struct in_addr));
 187           options.nservers++;
 188           optmask |= ARES_OPT_SERVERS;
 189           break;
 190
 191         case 'c':
 192           /* Set the query class. */
 193           for (i = 0; i < nclasses; i++)
 194             {
 195               if (strcasecmp(classes[i].name, optarg) == 0)
 196                 break;
 197             }
 198           if (i == nclasses)
 199             usage();
 200           dnsclass = classes[i].value;
 201           break;
 202
 203         case 't':
 204           /* Set the query type. */
 205           for (i = 0; i < ntypes; i++)
 206             {
 207               if (strcasecmp(types[i].name, optarg) == 0)
 208                 break;
 209             }
 210           if (i == ntypes)
 211             usage();
 212           type = types[i].value;
 213           break;
 214
 215         case 'T':
 216           /* Set the TCP port number. */
 217           if (!isdigit((unsigned char)*optarg))
 218             usage();
 219           options.tcp_port = strtol(optarg, NULL, 0);
 220           optmask |= ARES_OPT_TCP_PORT;
 221           break;
 222
 223         case 'U':
 224           /* Set the UDP port number. */
 225           if (!isdigit((unsigned char)*optarg))
 226             usage();
 227           options.udp_port = strtol(optarg, NULL, 0);
 228           optmask |= ARES_OPT_UDP_PORT;
 229           break;
 230         }
 231     }
 232   argc -= optind;
 233   argv += optind;
 234   if (argc == 0)
 235     usage();
 236
 237   status = ares_init_options(&channel, &options, optmask);
 238
 239   if (status != ARES_SUCCESS)
 240     {
 241       fprintf(stderr, "ares_init_options: %s\n",
 242               ares_strerror(status));
 243       return 1;
 244     }
 245
 246   /* Initiate the queries, one per command-line argument.  If there is
 247    * only one query to do, supply NULL as the callback argument;
 248    * otherwise, supply the query name as an argument so we can
 249    * distinguish responses for the user when printing them out.
 250    */
 251   if (argc == 1)
 252     ares_query(channel, *argv, dnsclass, type, callback, (char *) NULL);
 253   else
 254     {
 255       for (; *argv; argv++)
 256         ares_query(channel, *argv, dnsclass, type, callback, *argv);
 257     }
 258
 259   /* Wait for all queries to complete. */
 260   while (1)
 261     {
 262       FD_ZERO(&read_fds);
 263       FD_ZERO(&write_fds);
 264       nfds = ares_fds(channel, &read_fds, &write_fds);
 265       if (nfds == 0)
 266         break;
 267       tvp = ares_timeout(channel, NULL, &tv);
 268       count = select(nfds, &read_fds, &write_fds, NULL, tvp);
 269       if (count < 0 && errno != EINVAL)
 270         {
 271           perror("select");
 272           return 1;
 273         }
 274       ares_process(channel, &read_fds, &write_fds);
 275     }
 276
 277   ares_destroy(channel);
 278   return 0;
 279 }
 280
 281 static void callback(void *arg, int status, unsigned char *abuf, int alen)
 282 {
 283   char *name = (char *) arg;
 284   int id, qr, opcode, aa, tc, rd, ra, rcode;
 285   unsigned int qdcount, ancount, nscount, arcount, i;
 286   const unsigned char *aptr;
 287
 288   /* Display the query name if given. */
 289   if (name)
 290     printf("Answer for query %s:\n", name);
 291
 292   /* Display an error message if there was an error, but only stop if
 293    * we actually didn't get an answer buffer.
 294    */
 295   if (status != ARES_SUCCESS)
 296     {
 297       printf("%s\n", ares_strerror(status));
 298       if (!abuf)
 299         return;
 300     }
 301
 302   /* Won't happen, but check anyway, for safety. */
 303   if (alen < HFIXEDSZ)
 304     return;
 305
 306   /* Parse the answer header. */
 307   id = DNS_HEADER_QID(abuf);
 308   qr = DNS_HEADER_QR(abuf);
 309   opcode = DNS_HEADER_OPCODE(abuf);
 310   aa = DNS_HEADER_AA(abuf);
 311   tc = DNS_HEADER_TC(abuf);
 312   rd = DNS_HEADER_RD(abuf);
 313   ra = DNS_HEADER_RA(abuf);
 314   rcode = DNS_HEADER_RCODE(abuf);
 315   qdcount = DNS_HEADER_QDCOUNT(abuf);
 316   ancount = DNS_HEADER_ANCOUNT(abuf);
 317   nscount = DNS_HEADER_NSCOUNT(abuf);
 318   arcount = DNS_HEADER_ARCOUNT(abuf);
 319
 320   /* Display the answer header. */
 321   printf("id: %d\n", id);
 322   printf("flags: %s%s%s%s%s\n",
 323          qr ? "qr " : "",
 324          aa ? "aa " : "",
 325          tc ? "tc " : "",
 326          rd ? "rd " : "",
 327          ra ? "ra " : "");
 328   printf("opcode: %s\n", opcodes[opcode]);
 329   printf("rcode: %s\n", rcodes[rcode]);
 330
 331   /* Display the questions. */
 332   printf("Questions:\n");
 333   aptr = abuf + HFIXEDSZ;
 334   for (i = 0; i < qdcount; i++)
 335     {
 336       aptr = display_question(aptr, abuf, alen);
 337       if (aptr == NULL)
 338         return;
 339     }
 340
 341   /* Display the answers. */
 342   printf("Answers:\n");
 343   for (i = 0; i < ancount; i++)
 344     {
 345       aptr = display_rr(aptr, abuf, alen);
 346       if (aptr == NULL)
 347         return;
 348     }
 349
 350   /* Display the NS records. */
 351   printf("NS records:\n");
 352   for (i = 0; i < nscount; i++)
 353     {
 354       aptr = display_rr(aptr, abuf, alen);
 355       if (aptr == NULL)
 356         return;
 357     }
 358
 359   /* Display the additional records. */
 360   printf("Additional records:\n");
 361   for (i = 0; i < arcount; i++)
 362     {
 363       aptr = display_rr(aptr, abuf, alen);
 364       if (aptr == NULL)
 365         return;
 366     }
 367 }
 368
 369 static const unsigned char *display_question(const unsigned char *aptr,
 370                                              const unsigned char *abuf,
 371                                              int alen)
 372 {
 373   char *name;
 374   int type, dnsclass, status;
 375   long len;
 376
 377   /* Parse the question name. */
 378   status = ares_expand_name(aptr, abuf, alen, &name, &len);
 379   if (status != ARES_SUCCESS)
 380     return NULL;
 381   aptr += len;
 382
 383   /* Make sure there's enough data after the name for the fixed part
 384    * of the question.
 385    */
 386   if (aptr + QFIXEDSZ > abuf + alen)
 387     {
 388       free(name);
 389       return NULL;
 390     }
 391
 392   /* Parse the question type and class. */
 393   type = DNS_QUESTION_TYPE(aptr);
 394   dnsclass = DNS_QUESTION_CLASS(aptr);
 395   aptr += QFIXEDSZ;
 396
 397   /* Display the question, in a format sort of similar to how we will
 398    * display RRs.
 399    */
 400   printf("\t%-15s.\t", name);
 401   if (dnsclass != C_IN)
 402     printf("\t%s", class_name(dnsclass));
 403   printf("\t%s\n", type_name(type));
 404   free(name);
 405   return aptr;
 406 }
 407
 408 static const unsigned char *display_rr(const unsigned char *aptr,
 409                                        const unsigned char *abuf, int alen)
 410 {
 411   const unsigned char *p;
 412   char *name;
 413   int type, dnsclass, ttl, dlen, status;
 414   long len;
 415   struct in_addr addr;
 416
 417   /* Parse the RR name. */
 418   status = ares_expand_name(aptr, abuf, alen, &name, &len);
 419   if (status != ARES_SUCCESS)
 420     return NULL;
 421   aptr += len;
 422
 423   /* Make sure there is enough data after the RR name for the fixed
 424    * part of the RR.
 425    */
 426   if (aptr + RRFIXEDSZ > abuf + alen)
 427     {
 428       free(name);
 429       return NULL;
 430     }
 431
 432   /* Parse the fixed part of the RR, and advance to the RR data
 433    * field. */
 434   type = DNS_RR_TYPE(aptr);
 435   dnsclass = DNS_RR_CLASS(aptr);
 436   ttl = DNS_RR_TTL(aptr);
 437   dlen = DNS_RR_LEN(aptr);
 438   aptr += RRFIXEDSZ;
 439   if (aptr + dlen > abuf + alen)
 440     {
 441       free(name);
 442       return NULL;
 443     }
 444
 445   /* Display the RR name, class, and type. */
 446   printf("\t%-15s.\t%d", name, ttl);
 447   if (dnsclass != C_IN)
 448     printf("\t%s", class_name(dnsclass));
 449   printf("\t%s", type_name(type));
 450   free(name);
 451
 452   /* Display the RR data.  Don't touch aptr. */
 453   switch (type)
 454     {
 455     case T_CNAME:
 456     case T_MB:
 457     case T_MD:
 458     case T_MF:
 459     case T_MG:
 460     case T_MR:
 461     case T_NS:
 462     case T_PTR:
 463       /* For these types, the RR data is just a domain name. */
 464       status = ares_expand_name(aptr, abuf, alen, &name, &len);
 465       if (status != ARES_SUCCESS)
 466         return NULL;
 467       printf("\t%s.", name);
 468       free(name);
 469       break;
 470
 471     case T_HINFO:
 472       /* The RR data is two length-counted character strings. */
 473       p = aptr;
 474       len = *p;
 475       if (p + len + 1 > aptr + dlen)
 476         return NULL;
 477       printf("\t%.*s", len, p + 1);
 478       p += len + 1;
 479       len = *p;
 480       if (p + len + 1 > aptr + dlen)
 481         return NULL;
 482       printf("\t%.*s", len, p + 1);
 483       break;
 484
 485     case T_MINFO:
 486       /* The RR data is two domain names. */
 487       p = aptr;
 488       status = ares_expand_name(p, abuf, alen, &name, &len);
 489       if (status != ARES_SUCCESS)
 490         return NULL;
 491       printf("\t%s.", name);
 492       free(name);
 493       p += len;
 494       status = ares_expand_name(p, abuf, alen, &name, &len);
 495       if (status != ARES_SUCCESS)
 496         return NULL;
 497       printf("\t%s.", name);
 498       free(name);
 499       break;
 500
 501     case T_MX:
 502       /* The RR data is two bytes giving a preference ordering, and
 503        * then a domain name.
 504        */
 505       if (dlen < 2)
 506         return NULL;
 507       printf("\t%d", (aptr[0] << 8) | aptr[1]);
 508       status = ares_expand_name(aptr + 2, abuf, alen, &name, &len);
 509       if (status != ARES_SUCCESS)
 510         return NULL;
 511       printf("\t%s.", name);
 512       free(name);
 513       break;
 514
 515     case T_SOA:
 516       /* The RR data is two domain names and then five four-byte
 517        * numbers giving the serial number and some timeouts.
 518        */
 519       p = aptr;
 520       status = ares_expand_name(p, abuf, alen, &name, &len);
 521       if (status != ARES_SUCCESS)
 522         return NULL;
 523       printf("\t%s.\n", name);
 524       free(name);
 525       p += len;
 526       status = ares_expand_name(p, abuf, alen, &name, &len);
 527       if (status != ARES_SUCCESS)
 528         return NULL;
 529       printf("\t\t\t\t\t\t%s.\n", name);
 530       free(name);
 531       p += len;
 532       if (p + 20 > aptr + dlen)
 533         return NULL;
 534       printf("\t\t\t\t\t\t( %d %d %d %d %d )",
 535              (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3],
 536              (p[4] << 24) | (p[5] << 16) | (p[6] << 8) | p[7],
 537              (p[8] << 24) | (p[9] << 16) | (p[10] << 8) | p[11],
 538              (p[12] << 24) | (p[13] << 16) | (p[14] << 8) | p[15],
 539              (p[16] << 24) | (p[17] << 16) | (p[18] << 8) | p[19]);
 540       break;
 541
 542     case T_TXT:
 543       /* The RR data is one or more length-counted character
 544        * strings. */
 545       p = aptr;
 546       while (p < aptr + dlen)
 547         {
 548           len = *p;
 549           if (p + len + 1 > aptr + dlen)
 550             return NULL;
 551           printf("\t%.*s", len, p + 1);
 552           p += len + 1;
 553         }
 554       break;
 555
 556     case T_A:
 557       /* The RR data is a four-byte Internet address. */
 558       if (dlen != 4)
 559         return NULL;
 560       memcpy(&addr, aptr, sizeof(struct in_addr));
 561       printf("\t%s", inet_ntoa(addr));
 562       break;
 563
 564     case T_WKS:
 565       /* Not implemented yet */
 566       break;
 567
 568     case T_SRV:
 569       /* The RR data is three two-byte numbers representing the
 570        * priority, weight, and port, followed by a domain name.
 571        */
 572
 573       printf("\t%d", DNS__16BIT(aptr));
 574       printf(" %d", DNS__16BIT(aptr + 2));
 575       printf(" %d", DNS__16BIT(aptr + 4));
 576
 577       status = ares_expand_name(aptr + 6, abuf, alen, &name, &len);
 578       if (status != ARES_SUCCESS)
 579         return NULL;
 580       printf("\t%s.", name);
 581       free(name);
 582       break;
 583
 584     default:
 585       printf("\t[Unknown RR; cannot parse]");
 586     }
 587   printf("\n");
 588
 589   return aptr + dlen;
 590 }
 591
 592 static const char *type_name(int type)
 593 {
 594   int i;
 595
 596   for (i = 0; i < ntypes; i++)
 597     {
 598       if (types[i].value == type)
 599         return types[i].name;
 600     }
 601   return "(unknown)";
 602 }
 603
 604 static const char *class_name(int dnsclass)
 605 {
 606   int i;
 607
 608   for (i = 0; i < nclasses; i++)
 609     {
 610       if (classes[i].value == dnsclass)
 611         return classes[i].name;
 612     }
 613   return "(unknown)";
 614 }
 615
 616 static void usage(void)
 617 {
 618   fprintf(stderr, "usage: adig [-f flag] [-s server] [-c class] "
 619           "[-t type] [-p port] name ...\n");
 620   exit(1);
 621 }