contrib/tcpdump-3.9/print-domain.c

   1 /*
   2  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  */
  21
  22 #ifndef lint
  23 static const char rcsid[] _U_ =
  24     "@(#) $Header: /tcpdump/master/tcpdump/print-domain.c,v 1.89.2.3 2006/04/07 08:58:43 guy Exp $ (LBL)";
  25 #endif
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <tcpdump-stdinc.h>
  32
  33 #include "nameser.h"
  34
  35 #include <stdio.h>
  36 #include <string.h>
  37
  38 #include "interface.h"
  39 #include "addrtoname.h"
  40 #include "extract.h"                    /* must come after interface.h */
  41
  42 static const char *ns_ops[] = {
  43         "", " inv_q", " stat", " op3", " notify", " update", " op6", " op7",
  44         " op8", " updataA", " updateD", " updateDA",
  45         " updateM", " updateMA", " zoneInit", " zoneRef",
  46 };
  47
  48 static const char *ns_resp[] = {
  49         "", " FormErr", " ServFail", " NXDomain",
  50         " NotImp", " Refused", " YXDomain", " YXRRSet",
  51         " NXRRSet", " NotAuth", " NotZone", " Resp11",
  52         " Resp12", " Resp13", " Resp14", " NoChange",
  53 };
  54
  55 /* skip over a domain name */
  56 static const u_char *
  57 ns_nskip(register const u_char *cp)
  58 {
  59         register u_char i;
  60
  61         if (!TTEST2(*cp, 1))
  62                 return (NULL);
  63         i = *cp++;
  64         while (i) {
  65                 if ((i & INDIR_MASK) == INDIR_MASK)
  66                         return (cp + 1);
  67                 if ((i & INDIR_MASK) == EDNS0_MASK) {
  68                         int bitlen, bytelen;
  69
  70                         if ((i & ~INDIR_MASK) != EDNS0_ELT_BITLABEL)
  71                                 return(NULL); /* unknown ELT */
  72                         if (!TTEST2(*cp, 1))
  73                                 return (NULL);
  74                         if ((bitlen = *cp++) == 0)
  75                                 bitlen = 256;
  76                         bytelen = (bitlen + 7) / 8;
  77                         cp += bytelen;
  78                 } else
  79                         cp += i;
  80                 if (!TTEST2(*cp, 1))
  81                         return (NULL);
  82                 i = *cp++;
  83         }
  84         return (cp);
  85 }
  86
  87 /* print a <domain-name> */
  88 static const u_char *
  89 blabel_print(const u_char *cp)
  90 {
  91         int bitlen, slen, b;
  92         const u_char *bitp, *lim;
  93         char tc;
  94
  95         if (!TTEST2(*cp, 1))
  96                 return(NULL);
  97         if ((bitlen = *cp) == 0)
  98                 bitlen = 256;
  99         slen = (bitlen + 3) / 4;
 100         lim = cp + 1 + slen;
 101
 102         /* print the bit string as a hex string */
 103         printf("\\[x");
 104         for (bitp = cp + 1, b = bitlen; bitp < lim && b > 7; b -= 8, bitp++) {
 105                 TCHECK(*bitp);
 106                 printf("%02x", *bitp);
 107         }
 108         if (b > 4) {
 109                 TCHECK(*bitp);
 110                 tc = *bitp++;
 111                 printf("%02x", tc & (0xff << (8 - b)));
 112         } else if (b > 0) {
 113                 TCHECK(*bitp);
 114                 tc = *bitp++;
 115                 printf("%1x", ((tc >> 4) & 0x0f) & (0x0f << (4 - b)));
 116         }
 117         printf("/%d]", bitlen);
 118         return lim;
 119 trunc:
 120         printf(".../%d]", bitlen);
 121         return NULL;
 122 }
 123
 124 static int
 125 labellen(const u_char *cp)
 126 {
 127         register u_int i;
 128
 129         if (!TTEST2(*cp, 1))
 130                 return(-1);
 131         i = *cp;
 132         if ((i & INDIR_MASK) == EDNS0_MASK) {
 133                 int bitlen, elt;
 134                 if ((elt = (i & ~INDIR_MASK)) != EDNS0_ELT_BITLABEL) {
 135                         printf("<ELT %d>", elt);
 136                         return(-1);
 137                 }
 138                 if (!TTEST2(*(cp + 1), 1))
 139                         return(-1);
 140                 if ((bitlen = *(cp + 1)) == 0)
 141                         bitlen = 256;
 142                 return(((bitlen + 7) / 8) + 1);
 143         } else
 144                 return(i);
 145 }
 146
 147 static const u_char *
 148 ns_nprint(register const u_char *cp, register const u_char *bp)
 149 {
 150         register u_int i, l;
 151         register const u_char *rp = NULL;
 152         register int compress = 0;
 153         int chars_processed;
 154         int elt;
 155         int data_size = snapend - bp;
 156
 157         if ((l = labellen(cp)) == (u_int)-1)
 158                 return(NULL);
 159         if (!TTEST2(*cp, 1))
 160                 return(NULL);
 161         chars_processed = 1;
 162         if (((i = *cp++) & INDIR_MASK) != INDIR_MASK) {
 163                 compress = 0;
 164                 rp = cp + l;
 165         }
 166
 167         if (i != 0)
 168                 while (i && cp < snapend) {
 169                         if ((i & INDIR_MASK) == INDIR_MASK) {
 170                                 if (!compress) {
 171                                         rp = cp + 1;
 172                                         compress = 1;
 173                                 }
 174                                 if (!TTEST2(*cp, 1))
 175                                         return(NULL);
 176                                 cp = bp + (((i << 8) | *cp) & 0x3fff);
 177                                 if ((l = labellen(cp)) == (u_int)-1)
 178                                         return(NULL);
 179                                 if (!TTEST2(*cp, 1))
 180                                         return(NULL);
 181                                 i = *cp++;
 182                                 chars_processed++;
 183
 184                                 /*
 185                                  * If we've looked at every character in
 186                                  * the message, this pointer will make
 187                                  * us look at some character again,
 188                                  * which means we're looping.
 189                                  */
 190                                 if (chars_processed >= data_size) {
 191                                         printf("<LOOP>");
 192                                         return (NULL);
 193                                 }
 194                                 continue;
 195                         }
 196                         if ((i & INDIR_MASK) == EDNS0_MASK) {
 197                                 elt = (i & ~INDIR_MASK);
 198                                 switch(elt) {
 199                                 case EDNS0_ELT_BITLABEL:
 200                                         if (blabel_print(cp) == NULL)
 201                                                 return (NULL);
 202                                         break;
 203                                 default:
 204                                         /* unknown ELT */
 205                                         printf("<ELT %d>", elt);
 206                                         return(NULL);
 207                                 }
 208                         } else {
 209                                 if (fn_printn(cp, l, snapend))
 210                                         return(NULL);
 211                         }
 212
 213                         cp += l;
 214                         chars_processed += l;
 215                         putchar('.');
 216                         if ((l = labellen(cp)) == (u_int)-1)
 217                                 return(NULL);
 218                         if (!TTEST2(*cp, 1))
 219                                 return(NULL);
 220                         i = *cp++;
 221                         chars_processed++;
 222                         if (!compress)
 223                                 rp += l + 1;
 224                 }
 225         else
 226                 putchar('.');
 227         return (rp);
 228 }
 229
 230 /* print a <character-string> */
 231 static const u_char *
 232 ns_cprint(register const u_char *cp)
 233 {
 234         register u_int i;
 235
 236         if (!TTEST2(*cp, 1))
 237                 return (NULL);
 238         i = *cp++;
 239         if (fn_printn(cp, i, snapend))
 240                 return (NULL);
 241         return (cp + i);
 242 }
 243
 244 /* http://www.iana.org/assignments/dns-parameters */
 245 struct tok ns_type2str[] = {
 246         { T_A,          "A" },                  /* RFC 1035 */
 247         { T_NS,         "NS" },                 /* RFC 1035 */
 248         { T_MD,         "MD" },                 /* RFC 1035 */
 249         { T_MF,         "MF" },                 /* RFC 1035 */
 250         { T_CNAME,      "CNAME" },              /* RFC 1035 */
 251         { T_SOA,        "SOA" },                /* RFC 1035 */
 252         { T_MB,         "MB" },                 /* RFC 1035 */
 253         { T_MG,         "MG" },                 /* RFC 1035 */
 254         { T_MR,         "MR" },                 /* RFC 1035 */
 255         { T_NULL,       "NULL" },               /* RFC 1035 */
 256         { T_WKS,        "WKS" },                /* RFC 1035 */
 257         { T_PTR,        "PTR" },                /* RFC 1035 */
 258         { T_HINFO,      "HINFO" },              /* RFC 1035 */
 259         { T_MINFO,      "MINFO" },              /* RFC 1035 */
 260         { T_MX,         "MX" },                 /* RFC 1035 */
 261         { T_TXT,        "TXT" },                /* RFC 1035 */
 262         { T_RP,         "RP" },                 /* RFC 1183 */
 263         { T_AFSDB,      "AFSDB" },              /* RFC 1183 */
 264         { T_X25,        "X25" },                /* RFC 1183 */
 265         { T_ISDN,       "ISDN" },               /* RFC 1183 */
 266         { T_RT,         "RT" },                 /* RFC 1183 */
 267         { T_NSAP,       "NSAP" },               /* RFC 1706 */
 268         { T_NSAP_PTR,   "NSAP_PTR" },
 269         { T_SIG,        "SIG" },                /* RFC 2535 */
 270         { T_KEY,        "KEY" },                /* RFC 2535 */
 271         { T_PX,         "PX" },                 /* RFC 2163 */
 272         { T_GPOS,       "GPOS" },               /* RFC 1712 */
 273         { T_AAAA,       "AAAA" },               /* RFC 1886 */
 274         { T_LOC,        "LOC" },                /* RFC 1876 */
 275         { T_NXT,        "NXT" },                /* RFC 2535 */
 276         { T_EID,        "EID" },                /* Nimrod */
 277         { T_NIMLOC,     "NIMLOC" },             /* Nimrod */
 278         { T_SRV,        "SRV" },                /* RFC 2782 */
 279         { T_ATMA,       "ATMA" },               /* ATM Forum */
 280         { T_NAPTR,      "NAPTR" },              /* RFC 2168, RFC 2915 */
 281         { T_KX,         "KX" },                 /* RFC 2230 */
 282         { T_CERT,       "CERT" },               /* RFC 2538 */
 283         { T_A6,         "A6" },                 /* RFC 2874 */
 284         { T_DNAME,      "DNAME" },              /* RFC 2672 */
 285         { T_SINK,       "SINK" },
 286         { T_OPT,        "OPT" },                /* RFC 2671 */
 287         { T_APL,        "APL" },                /* RFC 3123 */
 288         { T_DS,         "DS" },                 /* RFC 4034 */
 289         { T_SSHFP,      "SSHFP" },              /* RFC 4255 */
 290         { T_IPSECKEY,   "IPSECKEY" },           /* RFC 4025 */
 291         { T_RRSIG,      "RRSIG" },              /* RFC 4034 */
 292         { T_NSEC,       "NSEC" },               /* RFC 4034 */
 293         { T_DNSKEY,     "DNSKEY" },             /* RFC 4034 */
 294         { T_SPF,        "SPF" },                /* RFC-schlitt-spf-classic-02.txt */
 295         { T_UINFO,      "UINFO" },
 296         { T_UID,        "UID" },
 297         { T_GID,        "GID" },
 298         { T_UNSPEC,     "UNSPEC" },
 299         { T_UNSPECA,    "UNSPECA" },
 300         { T_TKEY,       "TKEY" },               /* RFC 2930 */
 301         { T_TSIG,       "TSIG" },               /* RFC 2845 */
 302         { T_IXFR,       "IXFR" },               /* RFC 1995 */
 303         { T_AXFR,       "AXFR" },               /* RFC 1035 */
 304         { T_MAILB,      "MAILB" },              /* RFC 1035 */
 305         { T_MAILA,      "MAILA" },              /* RFC 1035 */
 306         { T_ANY,        "ANY" },
 307         { 0,            NULL }
 308 };
 309
 310 struct tok ns_class2str[] = {
 311         { C_IN,         "IN" },         /* Not used */
 312         { C_CHAOS,      "CHAOS" },
 313         { C_HS,         "HS" },
 314         { C_ANY,        "ANY" },
 315         { 0,            NULL }
 316 };
 317
 318 /* print a query */
 319 static const u_char *
 320 ns_qprint(register const u_char *cp, register const u_char *bp, int is_mdns)
 321 {
 322         register const u_char *np = cp;
 323         register u_int i;
 324
 325         cp = ns_nskip(cp);
 326
 327         if (cp == NULL || !TTEST2(*cp, 4))
 328                 return(NULL);
 329
 330         /* print the qtype and qclass (if it's not IN) */
 331         i = EXTRACT_16BITS(cp);
 332         cp += 2;
 333         printf(" %s", tok2str(ns_type2str, "Type%d", i));
 334         i = EXTRACT_16BITS(cp);
 335         cp += 2;
 336         if (is_mdns && i == (C_IN|C_CACHE_FLUSH))
 337                 printf(" (Cache flush)");
 338         else if (i != C_IN)
 339                 printf(" %s", tok2str(ns_class2str, "(Class %d)", i));
 340
 341         fputs("? ", stdout);
 342         cp = ns_nprint(np, bp);
 343         return(cp ? cp + 4 : NULL);
 344 }
 345
 346 /* print a reply */
 347 static const u_char *
 348 ns_rprint(register const u_char *cp, register const u_char *bp, int is_mdns)
 349 {
 350         register u_int class, opt_flags = 0;
 351         register u_short typ, len;
 352         register const u_char *rp;
 353
 354         if (vflag) {
 355                 putchar(' ');
 356                 if ((cp = ns_nprint(cp, bp)) == NULL)
 357                         return NULL;
 358         } else
 359                 cp = ns_nskip(cp);
 360
 361         if (cp == NULL || !TTEST2(*cp, 10))
 362                 return (snapend);
 363
 364         /* print the type/qtype and class (if it's not IN) */
 365         typ = EXTRACT_16BITS(cp);
 366         cp += 2;
 367         class = EXTRACT_16BITS(cp);
 368         cp += 2;
 369         if (is_mdns && class == (C_IN|C_CACHE_FLUSH))
 370                 printf(" (Cache flush)");
 371         else if (class != C_IN && typ != T_OPT)
 372                 printf(" %s", tok2str(ns_class2str, "(Class %d)", class));
 373
 374         /* ignore ttl */
 375         cp += 2;
 376         /* if T_OPT, save opt_flags */
 377         if (typ == T_OPT)
 378                 opt_flags = EXTRACT_16BITS(cp);
 379         /* ignore rest of ttl */
 380         cp += 2;
 381
 382         len = EXTRACT_16BITS(cp);
 383         cp += 2;
 384
 385         rp = cp + len;
 386
 387         printf(" %s", tok2str(ns_type2str, "Type%d", typ));
 388         if (rp > snapend)
 389                 return(NULL);
 390
 391         switch (typ) {
 392         case T_A:
 393                 if (!TTEST2(*cp, sizeof(struct in_addr)))
 394                         return(NULL);
 395                 printf(" %s", ipaddr_string(cp));
 396                 break;
 397
 398         case T_NS:
 399         case T_CNAME:
 400         case T_PTR:
 401 #ifdef T_DNAME
 402         case T_DNAME:
 403 #endif
 404                 putchar(' ');
 405                 if (ns_nprint(cp, bp) == NULL)
 406                         return(NULL);
 407                 break;
 408
 409         case T_SOA:
 410                 if (!vflag)
 411                         break;
 412                 putchar(' ');
 413                 if ((cp = ns_nprint(cp, bp)) == NULL)
 414                         return(NULL);
 415                 putchar(' ');
 416                 if ((cp = ns_nprint(cp, bp)) == NULL)
 417                         return(NULL);
 418                 if (!TTEST2(*cp, 5 * 4))
 419                         return(NULL);
 420                 printf(" %u", EXTRACT_32BITS(cp));
 421                 cp += 4;
 422                 printf(" %u", EXTRACT_32BITS(cp));
 423                 cp += 4;
 424                 printf(" %u", EXTRACT_32BITS(cp));
 425                 cp += 4;
 426                 printf(" %u", EXTRACT_32BITS(cp));
 427                 cp += 4;
 428                 printf(" %u", EXTRACT_32BITS(cp));
 429                 cp += 4;
 430                 break;
 431         case T_MX:
 432                 putchar(' ');
 433                 if (!TTEST2(*cp, 2))
 434                         return(NULL);
 435                 if (ns_nprint(cp + 2, bp) == NULL)
 436                         return(NULL);
 437                 printf(" %d", EXTRACT_16BITS(cp));
 438                 break;
 439
 440         case T_TXT:
 441                 while (cp < rp) {
 442                         printf(" \"");
 443                         cp = ns_cprint(cp);
 444                         if (cp == NULL)
 445                                 return(NULL);
 446                         putchar('"');
 447                 }
 448                 break;
 449
 450         case T_SRV:
 451                 putchar(' ');
 452                 if (!TTEST2(*cp, 6))
 453                         return(NULL);
 454                 if (ns_nprint(cp + 6, bp) == NULL)
 455                         return(NULL);
 456                 printf(":%d %d %d", EXTRACT_16BITS(cp + 4),
 457                         EXTRACT_16BITS(cp), EXTRACT_16BITS(cp + 2));
 458                 break;
 459
 460 #ifdef INET6
 461         case T_AAAA:
 462                 if (!TTEST2(*cp, sizeof(struct in6_addr)))
 463                         return(NULL);
 464                 printf(" %s", ip6addr_string(cp));
 465                 break;
 466
 467         case T_A6:
 468             {
 469                 struct in6_addr a;
 470                 int pbit, pbyte;
 471
 472                 if (!TTEST2(*cp, 1))
 473                         return(NULL);
 474                 pbit = *cp;
 475                 pbyte = (pbit & ~7) / 8;
 476                 if (pbit > 128) {
 477                         printf(" %u(bad plen)", pbit);
 478                         break;
 479                 } else if (pbit < 128) {
 480                         if (!TTEST2(*(cp + 1), sizeof(a) - pbyte))
 481                                 return(NULL);
 482                         memset(&a, 0, sizeof(a));
 483                         memcpy(&a.s6_addr[pbyte], cp + 1, sizeof(a) - pbyte);
 484                         printf(" %u %s", pbit, ip6addr_string(&a));
 485                 }
 486                 if (pbit > 0) {
 487                         putchar(' ');
 488                         if (ns_nprint(cp + 1 + sizeof(a) - pbyte, bp) == NULL)
 489                                 return(NULL);
 490                 }
 491                 break;
 492             }
 493 #endif /*INET6*/
 494
 495         case T_OPT:
 496                 printf(" UDPsize=%u", class);
 497                 if (opt_flags & 0x8000)
 498                         printf(" OK");
 499                 break;
 500
 501         case T_UNSPECA:         /* One long string */
 502                 if (!TTEST2(*cp, len))
 503                         return(NULL);
 504                 if (fn_printn(cp, len, snapend))
 505                         return(NULL);
 506                 break;
 507
 508         case T_TSIG:
 509             {
 510                 if (cp + len > snapend)
 511                         return(NULL);
 512                 if (!vflag)
 513                         break;
 514                 putchar(' ');
 515                 if ((cp = ns_nprint(cp, bp)) == NULL)
 516                         return(NULL);
 517                 cp += 6;
 518                 if (!TTEST2(*cp, 2))
 519                         return(NULL);
 520                 printf(" fudge=%u", EXTRACT_16BITS(cp));
 521                 cp += 2;
 522                 if (!TTEST2(*cp, 2))
 523                         return(NULL);
 524                 printf(" maclen=%u", EXTRACT_16BITS(cp));
 525                 cp += 2 + EXTRACT_16BITS(cp);
 526                 if (!TTEST2(*cp, 2))
 527                         return(NULL);
 528                 printf(" origid=%u", EXTRACT_16BITS(cp));
 529                 cp += 2;
 530                 if (!TTEST2(*cp, 2))
 531                         return(NULL);
 532                 printf(" error=%u", EXTRACT_16BITS(cp));
 533                 cp += 2;
 534                 if (!TTEST2(*cp, 2))
 535                         return(NULL);
 536                 printf(" otherlen=%u", EXTRACT_16BITS(cp));
 537                 cp += 2;
 538             }
 539         }
 540         return (rp);            /* XXX This isn't always right */
 541 }
 542
 543 void
 544 ns_print(register const u_char *bp, u_int length, int is_mdns)
 545 {
 546         register const HEADER *np;
 547         register int qdcount, ancount, nscount, arcount;
 548         register const u_char *cp;
 549         u_int16_t b2;
 550
 551         np = (const HEADER *)bp;
 552         TCHECK(*np);
 553         /* get the byte-order right */
 554         qdcount = EXTRACT_16BITS(&np->qdcount);
 555         ancount = EXTRACT_16BITS(&np->ancount);
 556         nscount = EXTRACT_16BITS(&np->nscount);
 557         arcount = EXTRACT_16BITS(&np->arcount);
 558
 559         if (DNS_QR(np)) {
 560                 /* this is a response */
 561                 printf(" %d%s%s%s%s%s%s",
 562                         EXTRACT_16BITS(&np->id),
 563                         ns_ops[DNS_OPCODE(np)],
 564                         ns_resp[DNS_RCODE(np)],
 565                         DNS_AA(np)? "*" : "",
 566                         DNS_RA(np)? "" : "-",
 567                         DNS_TC(np)? "|" : "",
 568                         DNS_AD(np)? "$" : "");
 569
 570                 if (qdcount != 1)
 571                         printf(" [%dq]", qdcount);
 572                 /* Print QUESTION section on -vv */
 573                 cp = (const u_char *)(np + 1);
 574                 while (qdcount--) {
 575                         if (qdcount < EXTRACT_16BITS(&np->qdcount) - 1)
 576                                 putchar(',');
 577                         if (vflag > 1) {
 578                                 fputs(" q:", stdout);
 579                                 if ((cp = ns_qprint(cp, bp, is_mdns)) == NULL)
 580                                         goto trunc;
 581                         } else {
 582                                 if ((cp = ns_nskip(cp)) == NULL)
 583                                         goto trunc;
 584                                 cp += 4;        /* skip QTYPE and QCLASS */
 585                         }
 586                 }
 587                 printf(" %d/%d/%d", ancount, nscount, arcount);
 588                 if (ancount--) {
 589                         if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 590                                 goto trunc;
 591                         while (cp < snapend && ancount--) {
 592                                 putchar(',');
 593                                 if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 594                                         goto trunc;
 595                         }
 596                 }
 597                 if (ancount > 0)
 598                         goto trunc;
 599                 /* Print NS and AR sections on -vv */
 600                 if (vflag > 1) {
 601                         if (cp < snapend && nscount--) {
 602                                 fputs(" ns:", stdout);
 603                                 if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 604                                         goto trunc;
 605                                 while (cp < snapend && nscount--) {
 606                                         putchar(',');
 607                                         if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 608                                                 goto trunc;
 609                                 }
 610                         }
 611                         if (nscount > 0)
 612                                 goto trunc;
 613                         if (cp < snapend && arcount--) {
 614                                 fputs(" ar:", stdout);
 615                                 if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 616                                         goto trunc;
 617                                 while (cp < snapend && arcount--) {
 618                                         putchar(',');
 619                                         if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 620                                                 goto trunc;
 621                                 }
 622                         }
 623                         if (arcount > 0)
 624                                 goto trunc;
 625                 }
 626         }
 627         else {
 628                 /* this is a request */
 629                 printf(" %d%s%s%s", EXTRACT_16BITS(&np->id), ns_ops[DNS_OPCODE(np)],
 630                     DNS_RD(np) ? "+" : "",
 631                     DNS_CD(np) ? "%" : "");
 632
 633                 /* any weirdness? */
 634                 b2 = EXTRACT_16BITS(((u_short *)np)+1);
 635                 if (b2 & 0x6cf)
 636                         printf(" [b2&3=0x%x]", b2);
 637
 638                 if (DNS_OPCODE(np) == IQUERY) {
 639                         if (qdcount)
 640                                 printf(" [%dq]", qdcount);
 641                         if (ancount != 1)
 642                                 printf(" [%da]", ancount);
 643                 }
 644                 else {
 645                         if (ancount)
 646                                 printf(" [%da]", ancount);
 647                         if (qdcount != 1)
 648                                 printf(" [%dq]", qdcount);
 649                 }
 650                 if (nscount)
 651                         printf(" [%dn]", nscount);
 652                 if (arcount)
 653                         printf(" [%dau]", arcount);
 654
 655                 cp = (const u_char *)(np + 1);
 656                 if (qdcount--) {
 657                         cp = ns_qprint(cp, (const u_char *)np, is_mdns);
 658                         if (!cp)
 659                                 goto trunc;
 660                         while (cp < snapend && qdcount--) {
 661                                 cp = ns_qprint((const u_char *)cp,
 662                                                (const u_char *)np,
 663                                                is_mdns);
 664                                 if (!cp)
 665                                         goto trunc;
 666                         }
 667                 }
 668                 if (qdcount > 0)
 669                         goto trunc;
 670
 671                 /* Print remaining sections on -vv */
 672                 if (vflag > 1) {
 673                         if (ancount--) {
 674                                 if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 675                                         goto trunc;
 676                                 while (cp < snapend && ancount--) {
 677                                         putchar(',');
 678                                         if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 679                                                 goto trunc;
 680                                 }
 681                         }
 682                         if (ancount > 0)
 683                                 goto trunc;
 684                         if (cp < snapend && nscount--) {
 685                                 fputs(" ns:", stdout);
 686                                 if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 687                                         goto trunc;
 688                                 while (nscount-- && cp < snapend) {
 689                                         putchar(',');
 690                                         if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 691                                                 goto trunc;
 692                                 }
 693                         }
 694                         if (nscount > 0)
 695                                 goto trunc;
 696                         if (cp < snapend && arcount--) {
 697                                 fputs(" ar:", stdout);
 698                                 if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 699                                         goto trunc;
 700                                 while (cp < snapend && arcount--) {
 701                                         putchar(',');
 702                                         if ((cp = ns_rprint(cp, bp, is_mdns)) == NULL)
 703                                                 goto trunc;
 704                                 }
 705                         }
 706                         if (arcount > 0)
 707                                 goto trunc;
 708                 }
 709         }
 710         printf(" (%d)", length);
 711         return;
 712
 713   trunc:
 714         printf("[|domain]");
 715         return;
 716 }