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 #ifdef HAVE_CONFIG_H 31 #include "config.h" 32 #endif 33 34 #include <sys/time.h> 35 36 #include <netinet/in.h> 37 38 #ifdef NOERROR 39 #undef NOERROR /* Solaris sucks */ 40 #endif 41 #ifdef NOERROR 42 #undef T_UNSPEC /* SINIX does too */ 43 #endif 44 #include "nameser.h" 45 46 #include <stdio.h> 47 #include <string.h> 48 #include <stdlib.h> 49 #include <resolv.h> /* for b64_ntop() proto */ 50 51 #include "interface.h" 52 #include "addrtoname.h" 53 #include "extract.h" /* must come after interface.h */ 54 55 /* BIND9 lib/lwres/include/lwres */ 56 typedef u_int32_t lwres_uint32_t; 57 typedef u_int16_t lwres_uint16_t; 58 typedef u_int8_t lwres_uint8_t; 59 60 struct lwres_lwpacket { 61 lwres_uint32_t length; 62 lwres_uint16_t version; 63 lwres_uint16_t pktflags; 64 lwres_uint32_t serial; 65 lwres_uint32_t opcode; 66 lwres_uint32_t result; 67 lwres_uint32_t recvlength; 68 lwres_uint16_t authtype; 69 lwres_uint16_t authlength; 70 }; 71 72 #define LWRES_LWPACKETFLAG_RESPONSE 0x0001U /* if set, pkt is a response */ 73 74 #define LWRES_LWPACKETVERSION_0 0 75 76 #define LWRES_FLAG_TRUSTNOTREQUIRED 0x00000001U 77 #define LWRES_FLAG_SECUREDATA 0x00000002U 78 79 /* 80 * no-op 81 */ 82 #define LWRES_OPCODE_NOOP 0x00000000U 83 84 typedef struct { 85 /* public */ 86 lwres_uint16_t datalength; 87 /* data follows */ 88 } lwres_nooprequest_t; 89 90 typedef struct { 91 /* public */ 92 lwres_uint16_t datalength; 93 /* data follows */ 94 } lwres_noopresponse_t; 95 96 /* 97 * get addresses by name 98 */ 99 #define LWRES_OPCODE_GETADDRSBYNAME 0x00010001U 100 101 typedef struct lwres_addr lwres_addr_t; 102 103 struct lwres_addr { 104 lwres_uint32_t family; 105 lwres_uint16_t length; 106 /* address folows */ 107 }; 108 109 typedef struct { 110 /* public */ 111 lwres_uint32_t flags; 112 lwres_uint32_t addrtypes; 113 lwres_uint16_t namelen; 114 /* name follows */ 115 } lwres_gabnrequest_t; 116 117 typedef struct { 118 /* public */ 119 lwres_uint32_t flags; 120 lwres_uint16_t naliases; 121 lwres_uint16_t naddrs; 122 lwres_uint16_t realnamelen; 123 /* aliases follows */ 124 /* addrs follows */ 125 /* realname follows */ 126 } lwres_gabnresponse_t; 127 128 /* 129 * get name by address 130 */ 131 #define LWRES_OPCODE_GETNAMEBYADDR 0x00010002U 132 typedef struct { 133 /* public */ 134 lwres_uint32_t flags; 135 lwres_addr_t addr; 136 /* addr body follows */ 137 } lwres_gnbarequest_t; 138 139 typedef struct { 140 /* public */ 141 lwres_uint32_t flags; 142 lwres_uint16_t naliases; 143 lwres_uint16_t realnamelen; 144 /* aliases follows */ 145 /* realname follows */ 146 } lwres_gnbaresponse_t; 147 148 /* 149 * get rdata by name 150 */ 151 #define LWRES_OPCODE_GETRDATABYNAME 0x00010003U 152 153 typedef struct { 154 /* public */ 155 lwres_uint32_t flags; 156 lwres_uint16_t rdclass; 157 lwres_uint16_t rdtype; 158 lwres_uint16_t namelen; 159 /* name follows */ 160 } lwres_grbnrequest_t; 161 162 typedef struct { 163 /* public */ 164 lwres_uint32_t flags; 165 lwres_uint16_t rdclass; 166 lwres_uint16_t rdtype; 167 lwres_uint32_t ttl; 168 lwres_uint16_t nrdatas; 169 lwres_uint16_t nsigs; 170 /* realname here (len + name) */ 171 /* rdata here (len + name) */ 172 /* signatures here (len + name) */ 173 } lwres_grbnresponse_t; 174 175 #define LWRDATA_VALIDATED 0x00000001 176 177 #define LWRES_ADDRTYPE_V4 0x00000001U /* ipv4 */ 178 #define LWRES_ADDRTYPE_V6 0x00000002U /* ipv6 */ 179 180 #define LWRES_MAX_ALIASES 16 /* max # of aliases */ 181 #define LWRES_MAX_ADDRS 64 /* max # of addrs */ 182 183 struct tok opcode[] = { 184 { LWRES_OPCODE_NOOP, "noop", }, 185 { LWRES_OPCODE_GETADDRSBYNAME, "getaddrsbyname", }, 186 { LWRES_OPCODE_GETNAMEBYADDR, "getnamebyaddr", }, 187 { LWRES_OPCODE_GETRDATABYNAME, "getrdatabyname", }, 188 { 0, NULL, }, 189 }; 190 191 /* print-domain.c */ 192 extern struct tok ns_type2str[]; 193 extern struct tok ns_class2str[]; 194 195 static int lwres_printname(size_t, const char *); 196 static int lwres_printnamelen(const char *); 197 /* static int lwres_printbinlen(const char *); */ 198 static int lwres_printb64len(const char *); 199 static int lwres_printaddr(lwres_addr_t *); 200 201 static int 202 lwres_printname(size_t l, const char *p0) 203 { 204 const char *p; 205 int i; 206 207 p = p0; 208 /* + 1 for terminating \0 */ 209 if (p + l + 1 > (const char *)snapend) 210 goto trunc; 211 212 printf(" "); 213 for (i = 0; i < l; i++) 214 safeputchar(*p++); 215 p++; /* skip terminating \0 */ 216 217 return p - p0; 218 219 trunc: 220 return -1; 221 } 222 223 static int 224 lwres_printnamelen(const char *p) 225 { 226 u_int16_t l; 227 int advance; 228 229 if (p + 2 > (const char *)snapend) 230 goto trunc; 231 l = EXTRACT_16BITS(p); 232 advance = lwres_printname(l, p + 2); 233 if (advance < 0) 234 goto trunc; 235 return 2 + advance; 236 237 trunc: 238 return -1; 239 } 240 241 #if 0 242 static int 243 lwres_printbinlen(const char *p0) 244 { 245 u_int8_t *p; 246 u_int16_t l; 247 int i; 248 249 p = (u_int8_t *)p0; 250 if (p + 2 > (u_int8_t *)snapend) 251 goto trunc; 252 l = EXTRACT_16BITS(p); 253 if (p + 2 + l > (u_int8_t *)snapend) 254 goto trunc; 255 p += 2; 256 for (i = 0; i < l; i++) 257 printf("%02x", *p++); 258 return p - (u_int8_t *)p0; 259 260 trunc: 261 return -1; 262 } 263 #endif 264 265 static int 266 lwres_printb64len(const char *p0) 267 { 268 u_int8_t *p; 269 u_int16_t l; 270 char *dbuf, *b64buf; 271 int i; 272 273 p = (u_int8_t *)p0; 274 if (p + 2 > (u_int8_t *)snapend) 275 goto trunc; 276 l = EXTRACT_16BITS(p); 277 if (p + 2 + l > (u_int8_t *)snapend) 278 goto trunc; 279 280 dbuf = malloc(l + 1); 281 if (!dbuf) 282 return -1; 283 284 b64buf = malloc((l + 2) * 4 / 3); 285 if (!b64buf) 286 { 287 free(dbuf); 288 return -1; 289 } 290 291 memcpy(dbuf, p, l); 292 *(dbuf + l) = (char)0; 293 294 i = b64_ntop (dbuf, l, b64buf, (l + 2) * 4 / 3); 295 b64buf[i] = (char)0; 296 printf ("%s", b64buf); 297 298 free (dbuf); 299 free (b64buf); 300 301 return l + 2; 302 303 trunc: 304 return -1; 305 } 306 307 static int 308 lwres_printaddr(lwres_addr_t *ap) 309 { 310 u_int16_t l; 311 const char *p; 312 int i; 313 314 TCHECK(ap->length); 315 l = ntohs(ap->length); 316 /* XXX ap points to packed struct */ 317 p = (const char *)&ap->length + sizeof(ap->length); 318 if (p + l > (const char *)snapend) 319 goto trunc; 320 321 switch (ntohl(ap->family)) { 322 case 1: /* IPv4 */ 323 printf(" %s", ipaddr_string(p)); 324 p += sizeof(struct in_addr); 325 break; 326 case 2: /* IPv6 */ 327 printf(" %s", ip6addr_string(p)); 328 p += sizeof(struct in6_addr); 329 break; 330 default: 331 printf(" %lu/", (unsigned long)ntohl(ap->family)); 332 for (i = 0; i < l; i++) 333 printf("%02x", *p++); 334 } 335 336 return p - (const char *)ap; 337 338 trunc: 339 return -1; 340 } 341 342 void 343 lwres_print(const u_char *bp, u_int length) 344 { 345 const struct lwres_lwpacket *np; 346 u_int32_t v; 347 const char *s; 348 int response; 349 int advance; 350 int unsupported = 0; 351 352 np = (const struct lwres_lwpacket *)bp; 353 TCHECK(np->authlength); 354 355 printf("lwres"); 356 v = ntohs(np->version); 357 if (vflag || v != LWRES_LWPACKETVERSION_0) 358 printf(" v%u", v); 359 if (v != LWRES_LWPACKETVERSION_0) { 360 s = (const char *)np + ntohl(np->length); 361 goto tail; 362 } 363 364 response = ntohs(np->pktflags) & LWRES_LWPACKETFLAG_RESPONSE; 365 366 /* opcode and pktflags */ 367 v = (u_int32_t)ntohl(np->opcode); 368 s = tok2str(opcode, "#0x%x", v); 369 printf(" %s%s", s, response ? "" : "?"); 370 371 /* pktflags */ 372 v = ntohs(np->pktflags); 373 if (v & ~LWRES_LWPACKETFLAG_RESPONSE) 374 printf("[0x%x]", v); 375 376 if (vflag > 1) { 377 printf(" ("); /*)*/ 378 printf("serial:0x%lx", (unsigned long)ntohl(np->serial)); 379 printf(" result:0x%lx", (unsigned long)ntohl(np->result)); 380 printf(" recvlen:%lu", (unsigned long)ntohl(np->recvlength)); 381 /* BIND910: not used */ 382 if (vflag > 2) { 383 printf(" authtype:0x%x", ntohs(np->authtype)); 384 printf(" authlen:%u", ntohs(np->authlength)); 385 } 386 /*(*/ 387 printf(")"); 388 } 389 390 /* per-opcode content */ 391 if (!response) { 392 /* 393 * queries 394 */ 395 lwres_gabnrequest_t *gabn; 396 lwres_gnbarequest_t *gnba; 397 lwres_grbnrequest_t *grbn; 398 u_int32_t l; 399 400 gabn = NULL; 401 gnba = NULL; 402 grbn = NULL; 403 404 switch (ntohl(np->opcode)) { 405 case LWRES_OPCODE_NOOP: 406 break; 407 case LWRES_OPCODE_GETADDRSBYNAME: 408 gabn = (lwres_gabnrequest_t *)(np + 1); 409 TCHECK(gabn->namelen); 410 /* XXX gabn points to packed struct */ 411 s = (const char *)&gabn->namelen + 412 sizeof(gabn->namelen); 413 l = ntohs(gabn->namelen); 414 415 /* BIND910: not used */ 416 if (vflag > 2) { 417 printf(" flags:0x%lx", 418 (unsigned long)ntohl(gabn->flags)); 419 } 420 421 v = (u_int32_t)ntohl(gabn->addrtypes); 422 switch (v & (LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6)) { 423 case LWRES_ADDRTYPE_V4: 424 printf(" IPv4"); 425 break; 426 case LWRES_ADDRTYPE_V6: 427 printf(" IPv6"); 428 break; 429 case LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6: 430 printf(" IPv4/6"); 431 break; 432 } 433 if (v & ~(LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6)) 434 printf("[0x%x]", v); 435 436 advance = lwres_printname(l, s); 437 if (advance < 0) 438 goto trunc; 439 s += advance; 440 break; 441 case LWRES_OPCODE_GETNAMEBYADDR: 442 gnba = (lwres_gnbarequest_t *)(np + 1); 443 TCHECK(gnba->addr); 444 445 /* BIND910: not used */ 446 if (vflag > 2) { 447 printf(" flags:0x%lx", 448 (unsigned long)ntohl(gnba->flags)); 449 } 450 451 s = (const char *)&gnba->addr; 452 453 advance = lwres_printaddr(&gnba->addr); 454 if (advance < 0) 455 goto trunc; 456 s += advance; 457 break; 458 default: 459 unsupported++; 460 break; 461 } 462 } else { 463 /* 464 * responses 465 */ 466 lwres_gabnresponse_t *gabn; 467 lwres_gnbaresponse_t *gnba; 468 lwres_grbnresponse_t *grbn; 469 u_int32_t l, na; 470 int i; 471 472 gabn = NULL; 473 gnba = NULL; 474 grbn = NULL; 475 476 switch (ntohl(np->opcode)) { 477 case LWRES_OPCODE_NOOP: 478 break; 479 case LWRES_OPCODE_GETADDRSBYNAME: 480 gabn = (lwres_gabnresponse_t *)(np + 1); 481 TCHECK(gabn->realnamelen); 482 /* XXX gabn points to packed struct */ 483 s = (const char *)&gabn->realnamelen + 484 sizeof(gabn->realnamelen); 485 l = ntohs(gabn->realnamelen); 486 487 /* BIND910: not used */ 488 if (vflag > 2) { 489 printf(" flags:0x%lx", 490 (unsigned long)ntohl(gabn->flags)); 491 } 492 493 printf(" %u/%u", ntohs(gabn->naliases), 494 ntohs(gabn->naddrs)); 495 496 advance = lwres_printname(l, s); 497 if (advance < 0) 498 goto trunc; 499 s += advance; 500 501 /* aliases */ 502 na = ntohs(gabn->naliases); 503 for (i = 0; i < na; i++) { 504 advance = lwres_printnamelen(s); 505 if (advance < 0) 506 goto trunc; 507 s += advance; 508 } 509 510 /* addrs */ 511 na = ntohs(gabn->naddrs); 512 for (i = 0; i < na; i++) { 513 advance = lwres_printaddr((lwres_addr_t *)s); 514 if (advance < 0) 515 goto trunc; 516 s += advance; 517 } 518 break; 519 case LWRES_OPCODE_GETNAMEBYADDR: 520 gnba = (lwres_gnbaresponse_t *)(np + 1); 521 TCHECK(gnba->realnamelen); 522 /* XXX gnba points to packed struct */ 523 s = (const char *)&gnba->realnamelen + 524 sizeof(gnba->realnamelen); 525 l = ntohs(gnba->realnamelen); 526 527 /* BIND910: not used */ 528 if (vflag > 2) { 529 printf(" flags:0x%lx", 530 (unsigned long)ntohl(gnba->flags)); 531 } 532 533 printf(" %u", ntohs(gnba->naliases)); 534 535 advance = lwres_printname(l, s); 536 if (advance < 0) 537 goto trunc; 538 s += advance; 539 540 /* aliases */ 541 na = ntohs(gnba->naliases); 542 for (i = 0; i < na; i++) { 543 advance = lwres_printnamelen(s); 544 if (advance < 0) 545 goto trunc; 546 s += advance; 547 } 548 break; 549 case LWRES_OPCODE_GETRDATABYNAME: 550 /* XXX no trace, not tested */ 551 grbn = (lwres_grbnresponse_t *)(np + 1); 552 TCHECK(grbn->nsigs); 553 554 /* BIND910: not used */ 555 if (vflag > 2) { 556 printf(" flags:0x%lx", 557 (unsigned long)ntohl(grbn->flags)); 558 } 559 560 printf(" %s", tok2str(ns_type2str, "Type%d", 561 ntohs(grbn->rdtype))); 562 if (ntohs(grbn->rdclass) != C_IN) 563 printf(" %s", tok2str(ns_class2str, "Class%d", 564 ntohs(grbn->rdclass))); 565 printf(" TTL "); 566 relts_print(ntohl(grbn->ttl)); 567 printf(" %u/%u", ntohs(grbn->nrdatas), 568 ntohs(grbn->nsigs)); 569 570 /* XXX grbn points to packed struct */ 571 s = (const char *)&grbn->nsigs+ sizeof(grbn->nsigs); 572 573 advance = lwres_printnamelen(s); 574 if (advance < 0) 575 goto trunc; 576 s += advance; 577 578 /* rdatas */ 579 na = ntohs(grbn->nrdatas); 580 if (na > 0) 581 printf(" "); 582 583 for (i = 0; i < na; i++) { 584 /* XXX should decode resource data */ 585 advance = lwres_printb64len(s); 586 if (advance < 0) 587 goto trunc; 588 s += advance; 589 } 590 591 /* sigs */ 592 na = ntohs(grbn->nsigs); 593 if (na > 0) 594 printf(" "); 595 596 for (i = 0; i < na; i++) { 597 /* XXX how should we print it? */ 598 advance = lwres_printb64len(s); 599 if (advance < 0) 600 goto trunc; 601 s += advance; 602 } 603 break; 604 default: 605 unsupported++; 606 break; 607 } 608 } 609 610 tail: 611 /* length mismatch */ 612 if (ntohl(np->length) != length) { 613 printf(" [len: %lu != %u]", (unsigned long)ntohl(np->length), 614 length); 615 } 616 if (!unsupported && s < (const char *)np + ntohl(np->length)) 617 printf("[extra]"); 618 return; 619 620 trunc: 621 printf("[|lwres]"); 622 return; 623 } 624