contrib/tcpdump-3.9/print-lwres.c

   1 /*
   2  * Copyright (C) 2001 WIDE Project.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the project nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #ifndef lint
  31 static const char rcsid[] _U_ =
  32     "@(#) $Header: /tcpdump/master/tcpdump/print-lwres.c,v 1.13 2004/03/24 01:54:29 guy Exp $ (LBL)";
  33 #endif
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include "config.h"
  37 #endif
  38
  39 #include <tcpdump-stdinc.h>
  40
  41 #include "nameser.h"
  42
  43 #include <stdio.h>
  44 #include <string.h>
  45
  46 #include "interface.h"
  47 #include "addrtoname.h"
  48 #include "extract.h"                    /* must come after interface.h */
  49
  50 /* BIND9 lib/lwres/include/lwres */
  51 typedef u_int32_t lwres_uint32_t;
  52 typedef u_int16_t lwres_uint16_t;
  53 typedef u_int8_t lwres_uint8_t;
  54
  55 struct lwres_lwpacket {
  56         lwres_uint32_t          length;
  57         lwres_uint16_t          version;
  58         lwres_uint16_t          pktflags;
  59         lwres_uint32_t          serial;
  60         lwres_uint32_t          opcode;
  61         lwres_uint32_t          result;
  62         lwres_uint32_t          recvlength;
  63         lwres_uint16_t          authtype;
  64         lwres_uint16_t          authlength;
  65 };
  66
  67 #define LWRES_LWPACKETFLAG_RESPONSE     0x0001U /* if set, pkt is a response */
  68
  69 #define LWRES_LWPACKETVERSION_0         0
  70
  71 #define LWRES_FLAG_TRUSTNOTREQUIRED     0x00000001U
  72 #define LWRES_FLAG_SECUREDATA           0x00000002U
  73
  74 /*
  75  * no-op
  76  */
  77 #define LWRES_OPCODE_NOOP               0x00000000U
  78
  79 typedef struct {
  80         /* public */
  81         lwres_uint16_t                  datalength;
  82         /* data follows */
  83 } lwres_nooprequest_t;
  84
  85 typedef struct {
  86         /* public */
  87         lwres_uint16_t                  datalength;
  88         /* data follows */
  89 } lwres_noopresponse_t;
  90
  91 /*
  92  * get addresses by name
  93  */
  94 #define LWRES_OPCODE_GETADDRSBYNAME     0x00010001U
  95
  96 typedef struct lwres_addr lwres_addr_t;
  97
  98 struct lwres_addr {
  99         lwres_uint32_t                  family;
 100         lwres_uint16_t                  length;
 101         /* address folows */
 102 };
 103
 104 typedef struct {
 105         /* public */
 106         lwres_uint32_t                  flags;
 107         lwres_uint32_t                  addrtypes;
 108         lwres_uint16_t                  namelen;
 109         /* name follows */
 110 } lwres_gabnrequest_t;
 111
 112 typedef struct {
 113         /* public */
 114         lwres_uint32_t                  flags;
 115         lwres_uint16_t                  naliases;
 116         lwres_uint16_t                  naddrs;
 117         lwres_uint16_t                  realnamelen;
 118         /* aliases follows */
 119         /* addrs follows */
 120         /* realname follows */
 121 } lwres_gabnresponse_t;
 122
 123 /*
 124  * get name by address
 125  */
 126 #define LWRES_OPCODE_GETNAMEBYADDR      0x00010002U
 127 typedef struct {
 128         /* public */
 129         lwres_uint32_t                  flags;
 130         lwres_addr_t                    addr;
 131         /* addr body follows */
 132 } lwres_gnbarequest_t;
 133
 134 typedef struct {
 135         /* public */
 136         lwres_uint32_t                  flags;
 137         lwres_uint16_t                  naliases;
 138         lwres_uint16_t                  realnamelen;
 139         /* aliases follows */
 140         /* realname follows */
 141 } lwres_gnbaresponse_t;
 142
 143 /*
 144  * get rdata by name
 145  */
 146 #define LWRES_OPCODE_GETRDATABYNAME     0x00010003U
 147
 148 typedef struct {
 149         /* public */
 150         lwres_uint32_t                  flags;
 151         lwres_uint16_t                  rdclass;
 152         lwres_uint16_t                  rdtype;
 153         lwres_uint16_t                  namelen;
 154         /* name follows */
 155 } lwres_grbnrequest_t;
 156
 157 typedef struct {
 158         /* public */
 159         lwres_uint32_t                  flags;
 160         lwres_uint16_t                  rdclass;
 161         lwres_uint16_t                  rdtype;
 162         lwres_uint32_t                  ttl;
 163         lwres_uint16_t                  nrdatas;
 164         lwres_uint16_t                  nsigs;
 165         /* realname here (len + name) */
 166         /* rdata here (len + name) */
 167         /* signatures here (len + name) */
 168 } lwres_grbnresponse_t;
 169
 170 #define LWRDATA_VALIDATED       0x00000001
 171
 172 #define LWRES_ADDRTYPE_V4               0x00000001U     /* ipv4 */
 173 #define LWRES_ADDRTYPE_V6               0x00000002U     /* ipv6 */
 174
 175 #define LWRES_MAX_ALIASES               16              /* max # of aliases */
 176 #define LWRES_MAX_ADDRS                 64              /* max # of addrs */
 177
 178 struct tok opcode[] = {
 179         { LWRES_OPCODE_NOOP,            "noop", },
 180         { LWRES_OPCODE_GETADDRSBYNAME,  "getaddrsbyname", },
 181         { LWRES_OPCODE_GETNAMEBYADDR,   "getnamebyaddr", },
 182         { LWRES_OPCODE_GETRDATABYNAME,  "getrdatabyname", },
 183         { 0,                            NULL, },
 184 };
 185
 186 /* print-domain.c */
 187 extern struct tok ns_type2str[];
 188 extern struct tok ns_class2str[];
 189
 190 static int lwres_printname(size_t, const char *);
 191 static int lwres_printnamelen(const char *);
 192 static int lwres_printbinlen(const char *);
 193 static int lwres_printaddr(lwres_addr_t *);
 194
 195 static int
 196 lwres_printname(size_t l, const char *p0)
 197 {
 198         const char *p;
 199         size_t i;
 200
 201         p = p0;
 202         /* + 1 for terminating \0 */
 203         if (p + l + 1 > (const char *)snapend)
 204                 goto trunc;
 205
 206         printf(" ");
 207         for (i = 0; i < l; i++)
 208                 safeputchar(*p++);
 209         p++;    /* skip terminating \0 */
 210
 211         return p - p0;
 212
 213   trunc:
 214         return -1;
 215 }
 216
 217 static int
 218 lwres_printnamelen(const char *p)
 219 {
 220         u_int16_t l;
 221         int advance;
 222
 223         if (p + 2 > (const char *)snapend)
 224                 goto trunc;
 225         l = EXTRACT_16BITS(p);
 226         advance = lwres_printname(l, p + 2);
 227         if (advance < 0)
 228                 goto trunc;
 229         return 2 + advance;
 230
 231   trunc:
 232         return -1;
 233 }
 234
 235 static int
 236 lwres_printbinlen(const char *p0)
 237 {
 238         const char *p;
 239         u_int16_t l;
 240         int i;
 241
 242         p = p0;
 243         if (p + 2 > (const char *)snapend)
 244                 goto trunc;
 245         l = EXTRACT_16BITS(p);
 246         if (p + 2 + l > (const char *)snapend)
 247                 goto trunc;
 248         p += 2;
 249         for (i = 0; i < l; i++)
 250                 printf("%02x", *p++);
 251         return p - p0;
 252
 253   trunc:
 254         return -1;
 255 }
 256
 257 static int
 258 lwres_printaddr(lwres_addr_t *ap)
 259 {
 260         u_int16_t l;
 261         const char *p;
 262         int i;
 263
 264         TCHECK(ap->length);
 265         l = EXTRACT_16BITS(&ap->length);
 266         /* XXX ap points to packed struct */
 267         p = (const char *)&ap->length + sizeof(ap->length);
 268         TCHECK2(*p, l);
 269
 270         switch (EXTRACT_32BITS(&ap->family)) {
 271         case 1: /* IPv4 */
 272                 if (l < 4)
 273                         return -1;
 274                 printf(" %s", ipaddr_string(p));
 275                 p += sizeof(struct in_addr);
 276                 break;
 277 #ifdef INET6
 278         case 2: /* IPv6 */
 279                 if (l < 16)
 280                         return -1;
 281                 printf(" %s", ip6addr_string(p));
 282                 p += sizeof(struct in6_addr);
 283                 break;
 284 #endif
 285         default:
 286                 printf(" %u/", EXTRACT_32BITS(&ap->family));
 287                 for (i = 0; i < l; i++)
 288                         printf("%02x", *p++);
 289         }
 290
 291         return p - (const char *)ap;
 292
 293   trunc:
 294         return -1;
 295 }
 296
 297 void
 298 lwres_print(register const u_char *bp, u_int length)
 299 {
 300         const struct lwres_lwpacket *np;
 301         u_int32_t v;
 302         const char *s;
 303         int response;
 304         int advance;
 305         int unsupported = 0;
 306
 307         np = (const struct lwres_lwpacket *)bp;
 308         TCHECK(np->authlength);
 309
 310         printf(" lwres");
 311         v = EXTRACT_16BITS(&np->version);
 312         if (vflag || v != LWRES_LWPACKETVERSION_0)
 313                 printf(" v%u", v);
 314         if (v != LWRES_LWPACKETVERSION_0) {
 315                 s = (const char *)np + EXTRACT_32BITS(&np->length);
 316                 goto tail;
 317         }
 318
 319         response = EXTRACT_16BITS(&np->pktflags) & LWRES_LWPACKETFLAG_RESPONSE;
 320
 321         /* opcode and pktflags */
 322         v = EXTRACT_32BITS(&np->opcode);
 323         s = tok2str(opcode, "#0x%x", v);
 324         printf(" %s%s", s, response ? "" : "?");
 325
 326         /* pktflags */
 327         v = EXTRACT_16BITS(&np->pktflags);
 328         if (v & ~LWRES_LWPACKETFLAG_RESPONSE)
 329                 printf("[0x%x]", v);
 330
 331         if (vflag > 1) {
 332                 printf(" (");   /*)*/
 333                 printf("serial:0x%x", EXTRACT_32BITS(&np->serial));
 334                 printf(" result:0x%x", EXTRACT_32BITS(&np->result));
 335                 printf(" recvlen:%u", EXTRACT_32BITS(&np->recvlength));
 336                 /* BIND910: not used */
 337                 if (vflag > 2) {
 338                         printf(" authtype:0x%x", EXTRACT_16BITS(&np->authtype));
 339                         printf(" authlen:%u", EXTRACT_16BITS(&np->authlength));
 340                 }
 341                 /*(*/
 342                 printf(")");
 343         }
 344
 345         /* per-opcode content */
 346         if (!response) {
 347                 /*
 348                  * queries
 349                  */
 350                 lwres_gabnrequest_t *gabn;
 351                 lwres_gnbarequest_t *gnba;
 352                 lwres_grbnrequest_t *grbn;
 353                 u_int32_t l;
 354
 355                 gabn = NULL;
 356                 gnba = NULL;
 357                 grbn = NULL;
 358
 359                 switch (EXTRACT_32BITS(&np->opcode)) {
 360                 case LWRES_OPCODE_NOOP:
 361                         break;
 362                 case LWRES_OPCODE_GETADDRSBYNAME:
 363                         gabn = (lwres_gabnrequest_t *)(np + 1);
 364                         TCHECK(gabn->namelen);
 365                         /* XXX gabn points to packed struct */
 366                         s = (const char *)&gabn->namelen +
 367                             sizeof(gabn->namelen);
 368                         l = EXTRACT_16BITS(&gabn->namelen);
 369
 370                         /* BIND910: not used */
 371                         if (vflag > 2) {
 372                                 printf(" flags:0x%x",
 373                                     EXTRACT_32BITS(&gabn->flags));
 374                         }
 375
 376                         v = EXTRACT_32BITS(&gabn->addrtypes);
 377                         switch (v & (LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6)) {
 378                         case LWRES_ADDRTYPE_V4:
 379                                 printf(" IPv4");
 380                                 break;
 381                         case LWRES_ADDRTYPE_V6:
 382                                 printf(" IPv6");
 383                                 break;
 384                         case LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6:
 385                                 printf(" IPv4/6");
 386                                 break;
 387                         }
 388                         if (v & ~(LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6))
 389                                 printf("[0x%x]", v);
 390
 391                         advance = lwres_printname(l, s);
 392                         if (advance < 0)
 393                                 goto trunc;
 394                         s += advance;
 395                         break;
 396                 case LWRES_OPCODE_GETNAMEBYADDR:
 397                         gnba = (lwres_gnbarequest_t *)(np + 1);
 398                         TCHECK(gnba->addr);
 399
 400                         /* BIND910: not used */
 401                         if (vflag > 2) {
 402                                 printf(" flags:0x%x",
 403                                     EXTRACT_32BITS(&gnba->flags));
 404                         }
 405
 406                         s = (const char *)&gnba->addr;
 407
 408                         advance = lwres_printaddr(&gnba->addr);
 409                         if (advance < 0)
 410                                 goto trunc;
 411                         s += advance;
 412                         break;
 413                 case LWRES_OPCODE_GETRDATABYNAME:
 414                         /* XXX no trace, not tested */
 415                         grbn = (lwres_grbnrequest_t *)(np + 1);
 416                         TCHECK(grbn->namelen);
 417
 418                         /* BIND910: not used */
 419                         if (vflag > 2) {
 420                                 printf(" flags:0x%x",
 421                                     EXTRACT_32BITS(&grbn->flags));
 422                         }
 423
 424                         printf(" %s", tok2str(ns_type2str, "Type%d",
 425                             EXTRACT_16BITS(&grbn->rdtype)));
 426                         if (EXTRACT_16BITS(&grbn->rdclass) != C_IN) {
 427                                 printf(" %s", tok2str(ns_class2str, "Class%d",
 428                                     EXTRACT_16BITS(&grbn->rdclass)));
 429                         }
 430
 431                         /* XXX grbn points to packed struct */
 432                         s = (const char *)&grbn->namelen +
 433                             sizeof(grbn->namelen);
 434                         l = EXTRACT_16BITS(&grbn->namelen);
 435
 436                         advance = lwres_printname(l, s);
 437                         if (advance < 0)
 438                                 goto trunc;
 439                         s += advance;
 440                         break;
 441                 default:
 442                         unsupported++;
 443                         break;
 444                 }
 445         } else {
 446                 /*
 447                  * responses
 448                  */
 449                 lwres_gabnresponse_t *gabn;
 450                 lwres_gnbaresponse_t *gnba;
 451                 lwres_grbnresponse_t *grbn;
 452                 u_int32_t l, na;
 453                 u_int32_t i;
 454
 455                 gabn = NULL;
 456                 gnba = NULL;
 457                 grbn = NULL;
 458
 459                 switch (EXTRACT_32BITS(&np->opcode)) {
 460                 case LWRES_OPCODE_NOOP:
 461                         break;
 462                 case LWRES_OPCODE_GETADDRSBYNAME:
 463                         gabn = (lwres_gabnresponse_t *)(np + 1);
 464                         TCHECK(gabn->realnamelen);
 465                         /* XXX gabn points to packed struct */
 466                         s = (const char *)&gabn->realnamelen +
 467                             sizeof(gabn->realnamelen);
 468                         l = EXTRACT_16BITS(&gabn->realnamelen);
 469
 470                         /* BIND910: not used */
 471                         if (vflag > 2) {
 472                                 printf(" flags:0x%x",
 473                                     EXTRACT_32BITS(&gabn->flags));
 474                         }
 475
 476                         printf(" %u/%u", EXTRACT_16BITS(&gabn->naliases),
 477                             EXTRACT_16BITS(&gabn->naddrs));
 478
 479                         advance = lwres_printname(l, s);
 480                         if (advance < 0)
 481                                 goto trunc;
 482                         s += advance;
 483
 484                         /* aliases */
 485                         na = EXTRACT_16BITS(&gabn->naliases);
 486                         for (i = 0; i < na; i++) {
 487                                 advance = lwres_printnamelen(s);
 488                                 if (advance < 0)
 489                                         goto trunc;
 490                                 s += advance;
 491                         }
 492
 493                         /* addrs */
 494                         na = EXTRACT_16BITS(&gabn->naddrs);
 495                         for (i = 0; i < na; i++) {
 496                                 advance = lwres_printaddr((lwres_addr_t *)s);
 497                                 if (advance < 0)
 498                                         goto trunc;
 499                                 s += advance;
 500                         }
 501                         break;
 502                 case LWRES_OPCODE_GETNAMEBYADDR:
 503                         gnba = (lwres_gnbaresponse_t *)(np + 1);
 504                         TCHECK(gnba->realnamelen);
 505                         /* XXX gnba points to packed struct */
 506                         s = (const char *)&gnba->realnamelen +
 507                             sizeof(gnba->realnamelen);
 508                         l = EXTRACT_16BITS(&gnba->realnamelen);
 509
 510                         /* BIND910: not used */
 511                         if (vflag > 2) {
 512                                 printf(" flags:0x%x",
 513                                     EXTRACT_32BITS(&gnba->flags));
 514                         }
 515
 516                         printf(" %u", EXTRACT_16BITS(&gnba->naliases));
 517
 518                         advance = lwres_printname(l, s);
 519                         if (advance < 0)
 520                                 goto trunc;
 521                         s += advance;
 522
 523                         /* aliases */
 524                         na = EXTRACT_16BITS(&gnba->naliases);
 525                         for (i = 0; i < na; i++) {
 526                                 advance = lwres_printnamelen(s);
 527                                 if (advance < 0)
 528                                         goto trunc;
 529                                 s += advance;
 530                         }
 531                         break;
 532                 case LWRES_OPCODE_GETRDATABYNAME:
 533                         /* XXX no trace, not tested */
 534                         grbn = (lwres_grbnresponse_t *)(np + 1);
 535                         TCHECK(grbn->nsigs);
 536
 537                         /* BIND910: not used */
 538                         if (vflag > 2) {
 539                                 printf(" flags:0x%x",
 540                                     EXTRACT_32BITS(&grbn->flags));
 541                         }
 542
 543                         printf(" %s", tok2str(ns_type2str, "Type%d",
 544                             EXTRACT_16BITS(&grbn->rdtype)));
 545                         if (EXTRACT_16BITS(&grbn->rdclass) != C_IN) {
 546                                 printf(" %s", tok2str(ns_class2str, "Class%d",
 547                                     EXTRACT_16BITS(&grbn->rdclass)));
 548                         }
 549                         printf(" TTL ");
 550                         relts_print(EXTRACT_32BITS(&grbn->ttl));
 551                         printf(" %u/%u", EXTRACT_16BITS(&grbn->nrdatas),
 552                             EXTRACT_16BITS(&grbn->nsigs));
 553
 554                         /* XXX grbn points to packed struct */
 555                         s = (const char *)&grbn->nsigs+ sizeof(grbn->nsigs);
 556
 557                         advance = lwres_printnamelen(s);
 558                         if (advance < 0)
 559                                 goto trunc;
 560                         s += advance;
 561
 562                         /* rdatas */
 563                         na = EXTRACT_16BITS(&grbn->nrdatas);
 564                         for (i = 0; i < na; i++) {
 565                                 /* XXX should decode resource data */
 566                                 advance = lwres_printbinlen(s);
 567                                 if (advance < 0)
 568                                         goto trunc;
 569                                 s += advance;
 570                         }
 571
 572                         /* sigs */
 573                         na = EXTRACT_16BITS(&grbn->nsigs);
 574                         for (i = 0; i < na; i++) {
 575                                 /* XXX how should we print it? */
 576                                 advance = lwres_printbinlen(s);
 577                                 if (advance < 0)
 578                                         goto trunc;
 579                                 s += advance;
 580                         }
 581                         break;
 582                 default:
 583                         unsupported++;
 584                         break;
 585                 }
 586         }
 587
 588   tail:
 589         /* length mismatch */
 590         if (EXTRACT_32BITS(&np->length) != length) {
 591                 printf(" [len: %u != %u]", EXTRACT_32BITS(&np->length),
 592                     length);
 593         }
 594         if (!unsupported && s < (const char *)np + EXTRACT_32BITS(&np->length))
 595                 printf("[extra]");
 596         return;
 597
 598   trunc:
 599         printf("[|lwres]");
 600         return;
 601 }