1 /* 2 * Copyright (c) 1988, 1989, 1990, 1991, 1993, 1994 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[] = 24 "@(#) $Header: /tcpdump/master/tcpdump/print-icmp6.c,v 1.56.4.1 2002/05/31 10:08:31 guy Exp $"; 25 #endif 26 27 #ifdef HAVE_CONFIG_H 28 #include "config.h" 29 #endif 30 31 #ifdef INET6 32 33 #include <ctype.h> 34 35 #include <sys/param.h> 36 #include <sys/time.h> 37 #include <sys/types.h> 38 #include <sys/socket.h> 39 40 41 #include <netinet/in.h> 42 43 #include <arpa/inet.h> 44 45 #include <stdio.h> 46 #include <string.h> 47 #include <netdb.h> 48 49 #include "ip6.h" 50 #include "icmp6.h" 51 52 #include "interface.h" 53 #include "addrtoname.h" 54 55 #include "udp.h" 56 #include "ah.h" 57 58 static const char *get_rtpref(u_int); 59 static const char *get_lifetime(u_int32_t); 60 static void print_lladdr(const u_char *, size_t); 61 void icmp6_opt_print(const u_char *, int); 62 void mld6_print(const u_char *); 63 static struct udphdr *get_upperlayer(u_char *, int *); 64 static void dnsname_print(const u_char *, const u_char *); 65 void icmp6_nodeinfo_print(int, const u_char *, const u_char *); 66 void icmp6_rrenum_print(int, const u_char *, const u_char *); 67 68 #ifndef abs 69 #define abs(a) ((0 < (a)) ? (a) : -(a)) 70 #endif 71 72 static const char * 73 get_rtpref(u_int v) 74 { 75 static const char *rtpref_str[] = { 76 "medium", /* 00 */ 77 "high", /* 01 */ 78 "rsv", /* 10 */ 79 "low" /* 11 */ 80 }; 81 82 return rtpref_str[((v & ND_RA_FLAG_RTPREF_MASK) >> 3) & 0xff]; 83 } 84 85 static const char * 86 get_lifetime(u_int32_t v) 87 { 88 static char buf[20]; 89 90 if (v == (u_int32_t)~0UL) 91 return "infinity"; 92 else { 93 snprintf(buf, sizeof(buf), "%u", v); 94 return buf; 95 } 96 } 97 98 static void 99 print_lladdr(const u_int8_t *p, size_t l) 100 { 101 const u_int8_t *ep, *q; 102 103 q = p; 104 ep = p + l; 105 while (l > 0 && q < ep) { 106 if (q > p) 107 printf(":"); 108 printf("%02x", *q++); 109 l--; 110 } 111 } 112 113 void 114 icmp6_print(const u_char *bp, const u_char *bp2) 115 { 116 const struct icmp6_hdr *dp; 117 const struct ip6_hdr *ip; 118 const char *str; 119 const struct ip6_hdr *oip; 120 const struct udphdr *ouh; 121 int dport; 122 const u_char *ep; 123 char buf[256]; 124 int icmp6len, prot; 125 126 dp = (struct icmp6_hdr *)bp; 127 ip = (struct ip6_hdr *)bp2; 128 oip = (struct ip6_hdr *)(dp + 1); 129 str = buf; 130 /* 'ep' points to the end of available data. */ 131 ep = snapend; 132 if (ip->ip6_plen) 133 icmp6len = (ntohs(ip->ip6_plen) + sizeof(struct ip6_hdr) - 134 (bp - bp2)); 135 else /* XXX: jumbo payload case... */ 136 icmp6len = snapend - bp; 137 138 TCHECK(dp->icmp6_code); 139 switch (dp->icmp6_type) { 140 case ICMP6_DST_UNREACH: 141 TCHECK(oip->ip6_dst); 142 switch (dp->icmp6_code) { 143 case ICMP6_DST_UNREACH_NOROUTE: 144 printf("icmp6: %s unreachable route", 145 ip6addr_string(&oip->ip6_dst)); 146 break; 147 case ICMP6_DST_UNREACH_ADMIN: 148 printf("icmp6: %s unreachable prohibited", 149 ip6addr_string(&oip->ip6_dst)); 150 break; 151 case ICMP6_DST_UNREACH_BEYONDSCOPE: 152 printf("icmp6: %s beyond scope of source address %s", 153 ip6addr_string(&oip->ip6_dst), 154 ip6addr_string(&oip->ip6_src)); 155 break; 156 case ICMP6_DST_UNREACH_ADDR: 157 printf("icmp6: %s unreachable address", 158 ip6addr_string(&oip->ip6_dst)); 159 break; 160 case ICMP6_DST_UNREACH_NOPORT: 161 if ((ouh = get_upperlayer((u_char *)oip, &prot)) 162 == NULL) 163 goto trunc; 164 165 dport = ntohs(ouh->uh_dport); 166 switch (prot) { 167 case IPPROTO_TCP: 168 printf("icmp6: %s tcp port %s unreachable", 169 ip6addr_string(&oip->ip6_dst), 170 tcpport_string(dport)); 171 break; 172 case IPPROTO_UDP: 173 printf("icmp6: %s udp port %s unreachable", 174 ip6addr_string(&oip->ip6_dst), 175 udpport_string(dport)); 176 break; 177 default: 178 printf("icmp6: %s protocol %d port %d unreachable", 179 ip6addr_string(&oip->ip6_dst), 180 oip->ip6_nxt, dport); 181 break; 182 } 183 break; 184 default: 185 printf("icmp6: %s unreachable code-#%d", 186 ip6addr_string(&oip->ip6_dst), 187 dp->icmp6_code); 188 break; 189 } 190 break; 191 case ICMP6_PACKET_TOO_BIG: 192 TCHECK(dp->icmp6_mtu); 193 printf("icmp6: too big %u", (u_int32_t)ntohl(dp->icmp6_mtu)); 194 break; 195 case ICMP6_TIME_EXCEEDED: 196 TCHECK(oip->ip6_dst); 197 switch (dp->icmp6_code) { 198 case ICMP6_TIME_EXCEED_TRANSIT: 199 printf("icmp6: time exceeded in-transit for %s", 200 ip6addr_string(&oip->ip6_dst)); 201 break; 202 case ICMP6_TIME_EXCEED_REASSEMBLY: 203 printf("icmp6: ip6 reassembly time exceeded"); 204 break; 205 default: 206 printf("icmp6: time exceeded code-#%d", 207 dp->icmp6_code); 208 break; 209 } 210 break; 211 case ICMP6_PARAM_PROB: 212 TCHECK(oip->ip6_dst); 213 switch (dp->icmp6_code) { 214 case ICMP6_PARAMPROB_HEADER: 215 printf("icmp6: parameter problem errorneous - octet %u", 216 (u_int32_t)ntohl(dp->icmp6_pptr)); 217 break; 218 case ICMP6_PARAMPROB_NEXTHEADER: 219 printf("icmp6: parameter problem next header - octet %u", 220 (u_int32_t)ntohl(dp->icmp6_pptr)); 221 break; 222 case ICMP6_PARAMPROB_OPTION: 223 printf("icmp6: parameter problem option - octet %u", 224 (u_int32_t)ntohl(dp->icmp6_pptr)); 225 break; 226 default: 227 printf("icmp6: parameter problem code-#%d", 228 dp->icmp6_code); 229 break; 230 } 231 break; 232 case ICMP6_ECHO_REQUEST: 233 printf("icmp6: echo request"); 234 break; 235 case ICMP6_ECHO_REPLY: 236 printf("icmp6: echo reply"); 237 break; 238 case ICMP6_MEMBERSHIP_QUERY: 239 printf("icmp6: multicast listener query "); 240 mld6_print((const u_char *)dp); 241 break; 242 case ICMP6_MEMBERSHIP_REPORT: 243 printf("icmp6: multicast listener report "); 244 mld6_print((const u_char *)dp); 245 break; 246 case ICMP6_MEMBERSHIP_REDUCTION: 247 printf("icmp6: multicast listener done "); 248 mld6_print((const u_char *)dp); 249 break; 250 case ND_ROUTER_SOLICIT: 251 printf("icmp6: router solicitation "); 252 if (vflag) { 253 #define RTSOLLEN 8 254 icmp6_opt_print((const u_char *)dp + RTSOLLEN, 255 icmp6len - RTSOLLEN); 256 } 257 break; 258 case ND_ROUTER_ADVERT: 259 printf("icmp6: router advertisement"); 260 if (vflag) { 261 struct nd_router_advert *p; 262 263 p = (struct nd_router_advert *)dp; 264 TCHECK(p->nd_ra_retransmit); 265 printf("(chlim=%d, ", (int)p->nd_ra_curhoplimit); 266 if (p->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED) 267 printf("M"); 268 if (p->nd_ra_flags_reserved & ND_RA_FLAG_OTHER) 269 printf("O"); 270 if (p->nd_ra_flags_reserved & ND_RA_FLAG_HOME_AGENT) 271 printf("H"); 272 273 if ((p->nd_ra_flags_reserved & ~ND_RA_FLAG_RTPREF_MASK) 274 != 0) 275 printf(" "); 276 277 printf("pref=%s, ", 278 get_rtpref(p->nd_ra_flags_reserved)); 279 280 printf("router_ltime=%d, ", ntohs(p->nd_ra_router_lifetime)); 281 printf("reachable_time=%u, ", 282 (u_int32_t)ntohl(p->nd_ra_reachable)); 283 printf("retrans_time=%u)", 284 (u_int32_t)ntohl(p->nd_ra_retransmit)); 285 #define RTADVLEN 16 286 icmp6_opt_print((const u_char *)dp + RTADVLEN, 287 icmp6len - RTADVLEN); 288 } 289 break; 290 case ND_NEIGHBOR_SOLICIT: 291 { 292 struct nd_neighbor_solicit *p; 293 p = (struct nd_neighbor_solicit *)dp; 294 TCHECK(p->nd_ns_target); 295 printf("icmp6: neighbor sol: who has %s", 296 ip6addr_string(&p->nd_ns_target)); 297 if (vflag) { 298 #define NDSOLLEN 24 299 icmp6_opt_print((const u_char *)dp + NDSOLLEN, 300 icmp6len - NDSOLLEN); 301 } 302 } 303 break; 304 case ND_NEIGHBOR_ADVERT: 305 { 306 struct nd_neighbor_advert *p; 307 308 p = (struct nd_neighbor_advert *)dp; 309 TCHECK(p->nd_na_target); 310 printf("icmp6: neighbor adv: tgt is %s", 311 ip6addr_string(&p->nd_na_target)); 312 if (vflag) { 313 #define ND_NA_FLAG_ALL \ 314 (ND_NA_FLAG_ROUTER|ND_NA_FLAG_SOLICITED|ND_NA_FLAG_OVERRIDE) 315 /* we don't need ntohl() here. see advanced-api-04. */ 316 if (p->nd_na_flags_reserved & ND_NA_FLAG_ALL) { 317 #undef ND_NA_FLAG_ALL 318 u_int32_t flags; 319 320 flags = p->nd_na_flags_reserved; 321 printf("("); 322 if (flags & ND_NA_FLAG_ROUTER) 323 printf("R"); 324 if (flags & ND_NA_FLAG_SOLICITED) 325 printf("S"); 326 if (flags & ND_NA_FLAG_OVERRIDE) 327 printf("O"); 328 printf(")"); 329 } 330 #define NDADVLEN 24 331 icmp6_opt_print((const u_char *)dp + NDADVLEN, 332 icmp6len - NDADVLEN); 333 #undef NDADVLEN 334 } 335 } 336 break; 337 case ND_REDIRECT: 338 #define RDR(i) ((struct nd_redirect *)(i)) 339 TCHECK(RDR(dp)->nd_rd_dst); 340 printf("icmp6: redirect %s", 341 getname6((const u_char *)&RDR(dp)->nd_rd_dst)); 342 printf(" to %s", 343 getname6((const u_char*)&RDR(dp)->nd_rd_target)); 344 #define REDIRECTLEN 40 345 if (vflag) { 346 icmp6_opt_print((const u_char *)dp + REDIRECTLEN, 347 icmp6len - REDIRECTLEN); 348 } 349 break; 350 #undef REDIRECTLEN 351 #undef RDR 352 case ICMP6_ROUTER_RENUMBERING: 353 icmp6_rrenum_print(icmp6len, bp, ep); 354 break; 355 case ICMP6_NI_QUERY: 356 case ICMP6_NI_REPLY: 357 icmp6_nodeinfo_print(icmp6len, bp, ep); 358 break; 359 default: 360 printf("icmp6: type-#%d", dp->icmp6_type); 361 break; 362 } 363 return; 364 trunc: 365 fputs("[|icmp6]", stdout); 366 } 367 368 static struct udphdr * 369 get_upperlayer(u_char *bp, int *prot) 370 { 371 const u_char *ep; 372 struct ip6_hdr *ip6 = (struct ip6_hdr *)bp; 373 struct udphdr *uh; 374 struct ip6_hbh *hbh; 375 struct ip6_frag *fragh; 376 struct ah *ah; 377 int nh, hlen; 378 379 /* 'ep' points to the end of available data. */ 380 ep = snapend; 381 382 if (TTEST(ip6->ip6_nxt) == 0) 383 return NULL; 384 385 nh = ip6->ip6_nxt; 386 hlen = sizeof(struct ip6_hdr); 387 388 while (bp < snapend) { 389 bp += hlen; 390 391 switch(nh) { 392 case IPPROTO_UDP: 393 case IPPROTO_TCP: 394 uh = (struct udphdr *)bp; 395 if (TTEST(uh->uh_dport)) { 396 *prot = nh; 397 return(uh); 398 } 399 else 400 return(NULL); 401 /* NOTREACHED */ 402 403 case IPPROTO_HOPOPTS: 404 case IPPROTO_DSTOPTS: 405 case IPPROTO_ROUTING: 406 hbh = (struct ip6_hbh *)bp; 407 if (TTEST(hbh->ip6h_len) == 0) 408 return(NULL); 409 nh = hbh->ip6h_nxt; 410 hlen = (hbh->ip6h_len + 1) << 3; 411 break; 412 413 case IPPROTO_FRAGMENT: /* this should be odd, but try anyway */ 414 fragh = (struct ip6_frag *)bp; 415 if (TTEST(fragh->ip6f_offlg) == 0) 416 return(NULL); 417 /* fragments with non-zero offset are meaningless */ 418 if ((fragh->ip6f_offlg & IP6F_OFF_MASK) != 0) 419 return(NULL); 420 nh = fragh->ip6f_nxt; 421 hlen = sizeof(struct ip6_frag); 422 break; 423 424 case IPPROTO_AH: 425 ah = (struct ah *)bp; 426 if (TTEST(ah->ah_len) == 0) 427 return(NULL); 428 nh = ah->ah_nxt; 429 hlen = (ah->ah_len + 2) << 2; 430 break; 431 432 default: /* unknown or undecodable header */ 433 *prot = nh; /* meaningless, but set here anyway */ 434 return(NULL); 435 } 436 } 437 438 return(NULL); /* should be notreached, though */ 439 } 440 441 void 442 icmp6_opt_print(const u_char *bp, int resid) 443 { 444 const struct nd_opt_hdr *op; 445 const struct nd_opt_hdr *opl; /* why there's no struct? */ 446 const struct nd_opt_prefix_info *opp; 447 const struct icmp6_opts_redirect *opr; 448 const struct nd_opt_mtu *opm; 449 const struct nd_opt_advinterval *opa; 450 const struct nd_opt_route_info *opri; 451 const u_char *cp, *ep; 452 struct in6_addr in6, *in6p; 453 size_t l; 454 455 #define ECHECK(var) if ((u_char *)&(var) > ep - sizeof(var)) return 456 457 cp = bp; 458 /* 'ep' points to the end of available data. */ 459 ep = snapend; 460 461 while (cp < ep) { 462 op = (struct nd_opt_hdr *)cp; 463 464 ECHECK(op->nd_opt_len); 465 if (resid <= 0) 466 return; 467 if (op->nd_opt_len == 0) 468 goto trunc; 469 if (cp + (op->nd_opt_len << 3) > ep) 470 goto trunc; 471 472 switch (op->nd_opt_type) { 473 case ND_OPT_SOURCE_LINKADDR: 474 opl = (struct nd_opt_hdr *)op; 475 printf("(src lladdr: "); 476 l = (op->nd_opt_len << 3) - 2; 477 print_lladdr(cp + 2, l); 478 /*(*/ 479 printf(")"); 480 break; 481 case ND_OPT_TARGET_LINKADDR: 482 opl = (struct nd_opt_hdr *)op; 483 printf("(tgt lladdr: "); 484 l = (op->nd_opt_len << 3) - 2; 485 print_lladdr(cp + 2, l); 486 /*(*/ 487 printf(")"); 488 break; 489 case ND_OPT_PREFIX_INFORMATION: 490 opp = (struct nd_opt_prefix_info *)op; 491 TCHECK(opp->nd_opt_pi_prefix); 492 printf("(prefix info: "); /*)*/ 493 if (op->nd_opt_len != 4) { 494 printf("badlen"); 495 /*(*/ 496 printf(")"); 497 break; 498 } 499 if (opp->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ONLINK) 500 printf("L"); 501 if (opp->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_AUTO) 502 printf("A"); 503 if (opp->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ROUTER) 504 printf("R"); 505 if (opp->nd_opt_pi_flags_reserved) 506 printf(" "); 507 printf("valid_ltime=%s,", 508 get_lifetime((u_int32_t)ntohl(opp->nd_opt_pi_valid_time))); 509 printf("preferred_ltime=%s,", 510 get_lifetime((u_int32_t)ntohl(opp->nd_opt_pi_preferred_time))); 511 printf("prefix=%s/%d", 512 ip6addr_string(&opp->nd_opt_pi_prefix), 513 opp->nd_opt_pi_prefix_len); 514 if (opp->nd_opt_pi_len != 4) 515 printf("!"); 516 /*(*/ 517 printf(")"); 518 break; 519 case ND_OPT_REDIRECTED_HEADER: 520 opr = (struct icmp6_opts_redirect *)op; 521 printf("(redirect)"); 522 /* xxx */ 523 break; 524 case ND_OPT_MTU: 525 opm = (struct nd_opt_mtu *)op; 526 TCHECK(opm->nd_opt_mtu_mtu); 527 printf("(mtu:"); /*)*/ 528 if (op->nd_opt_len != 1) { 529 printf("badlen"); 530 /*(*/ 531 printf(")"); 532 break; 533 } 534 printf(" mtu=%u", (u_int32_t)ntohl(opm->nd_opt_mtu_mtu)); 535 if (opm->nd_opt_mtu_len != 1) 536 printf("!"); 537 printf(")"); 538 break; 539 case ND_OPT_ADVINTERVAL: 540 opa = (struct nd_opt_advinterval *)op; 541 TCHECK(opa->nd_opt_adv_interval); 542 printf("(advint:"); /*)*/ 543 printf(" advint=%u", 544 (u_int32_t)ntohl(opa->nd_opt_adv_interval)); 545 /*(*/ 546 printf(")"); 547 break; 548 case ND_OPT_ROUTE_INFO: 549 opri = (struct nd_opt_route_info *)op; 550 TCHECK(opri->nd_opt_rti_lifetime); 551 memset(&in6, 0, sizeof(in6)); 552 in6p = (struct in6_addr *)(opri + 1); 553 switch (op->nd_opt_len) { 554 case 1: 555 break; 556 case 2: 557 TCHECK2(*in6p, 8); 558 memcpy(&in6, opri + 1, 8); 559 break; 560 case 3: 561 TCHECK(*in6p); 562 memcpy(&in6, opri + 1, sizeof(in6)); 563 break; 564 default: 565 goto trunc; 566 } 567 printf("(rtinfo:"); /*)*/ 568 printf(" %s/%u", ip6addr_string(&in6), 569 opri->nd_opt_rti_prefixlen); 570 printf(", pref=%s", get_rtpref(opri->nd_opt_rti_flags)); 571 printf(", lifetime=%s", 572 get_lifetime((u_int32_t)ntohl(opri->nd_opt_rti_lifetime))); 573 /*(*/ 574 printf(")"); 575 break; 576 default: 577 printf("(unknown opt_type=%d, opt_len=%d)", 578 op->nd_opt_type, op->nd_opt_len); 579 break; 580 } 581 582 cp += op->nd_opt_len << 3; 583 resid -= op->nd_opt_len << 3; 584 } 585 return; 586 587 trunc: 588 fputs("[ndp opt]", stdout); 589 return; 590 #undef ECHECK 591 } 592 593 void 594 mld6_print(const u_char *bp) 595 { 596 struct mld6_hdr *mp = (struct mld6_hdr *)bp; 597 const u_char *ep; 598 599 /* 'ep' points to the end of available data. */ 600 ep = snapend; 601 602 if ((u_char *)mp + sizeof(*mp) > ep) 603 return; 604 605 printf("max resp delay: %d ", ntohs(mp->mld6_maxdelay)); 606 printf("addr: %s", ip6addr_string(&mp->mld6_addr)); 607 } 608 609 static void 610 dnsname_print(const u_char *cp, const u_char *ep) 611 { 612 int i; 613 614 /* DNS name decoding - no decompression */ 615 printf(", \""); 616 while (cp < ep) { 617 i = *cp++; 618 if (i) { 619 if (i > ep - cp) { 620 printf("???"); 621 break; 622 } 623 while (i-- && cp < ep) { 624 safeputchar(*cp); 625 cp++; 626 } 627 if (cp + 1 < ep && *cp) 628 printf("."); 629 } else { 630 if (cp == ep) { 631 /* FQDN */ 632 printf("."); 633 } else if (cp + 1 == ep && *cp == '\0') { 634 /* truncated */ 635 } else { 636 /* invalid */ 637 printf("???"); 638 } 639 break; 640 } 641 } 642 printf("\""); 643 } 644 645 void 646 icmp6_nodeinfo_print(int icmp6len, const u_char *bp, const u_char *ep) 647 { 648 struct icmp6_nodeinfo *ni6; 649 struct icmp6_hdr *dp; 650 const u_char *cp; 651 int siz, i; 652 int needcomma; 653 654 dp = (struct icmp6_hdr *)bp; 655 ni6 = (struct icmp6_nodeinfo *)bp; 656 siz = ep - bp; 657 658 switch (ni6->ni_type) { 659 case ICMP6_NI_QUERY: 660 if (siz == sizeof(*dp) + 4) { 661 /* KAME who-are-you */ 662 printf("icmp6: who-are-you request"); 663 break; 664 } 665 printf("icmp6: node information query"); 666 667 TCHECK2(*dp, sizeof(*ni6)); 668 ni6 = (struct icmp6_nodeinfo *)dp; 669 printf(" ("); /*)*/ 670 switch (ntohs(ni6->ni_qtype)) { 671 case NI_QTYPE_NOOP: 672 printf("noop"); 673 break; 674 case NI_QTYPE_SUPTYPES: 675 printf("supported qtypes"); 676 i = ntohs(ni6->ni_flags); 677 if (i) 678 printf(" [%s]", (i & 0x01) ? "C" : ""); 679 break; 680 break; 681 case NI_QTYPE_FQDN: 682 printf("DNS name"); 683 break; 684 case NI_QTYPE_NODEADDR: 685 printf("node addresses"); 686 i = ni6->ni_flags; 687 if (!i) 688 break; 689 /* NI_NODEADDR_FLAG_TRUNCATE undefined for query */ 690 printf(" [%s%s%s%s%s%s]", 691 (i & NI_NODEADDR_FLAG_ANYCAST) ? "a" : "", 692 (i & NI_NODEADDR_FLAG_GLOBAL) ? "G" : "", 693 (i & NI_NODEADDR_FLAG_SITELOCAL) ? "S" : "", 694 (i & NI_NODEADDR_FLAG_LINKLOCAL) ? "L" : "", 695 (i & NI_NODEADDR_FLAG_COMPAT) ? "C" : "", 696 (i & NI_NODEADDR_FLAG_ALL) ? "A" : ""); 697 break; 698 default: 699 printf("unknown"); 700 break; 701 } 702 703 if (ni6->ni_qtype == NI_QTYPE_NOOP || 704 ni6->ni_qtype == NI_QTYPE_SUPTYPES) { 705 if (siz != sizeof(*ni6)) 706 if (vflag) 707 printf(", invalid len"); 708 /*(*/ 709 printf(")"); 710 break; 711 } 712 713 714 /* XXX backward compat, icmp-name-lookup-03 */ 715 if (siz == sizeof(*ni6)) { 716 printf(", 03 draft"); 717 /*(*/ 718 printf(")"); 719 break; 720 } 721 722 switch (ni6->ni_code) { 723 case ICMP6_NI_SUBJ_IPV6: 724 if (!TTEST2(*dp, 725 sizeof(*ni6) + sizeof(struct in6_addr))) 726 break; 727 if (siz != sizeof(*ni6) + sizeof(struct in6_addr)) { 728 if (vflag) 729 printf(", invalid subject len"); 730 break; 731 } 732 printf(", subject=%s", 733 getname6((const u_char *)(ni6 + 1))); 734 break; 735 case ICMP6_NI_SUBJ_FQDN: 736 printf(", subject=DNS name"); 737 cp = (const u_char *)(ni6 + 1); 738 if (cp[0] == ep - cp - 1) { 739 /* icmp-name-lookup-03, pascal string */ 740 if (vflag) 741 printf(", 03 draft"); 742 cp++; 743 printf(", \""); 744 while (cp < ep) { 745 safeputchar(*cp); 746 cp++; 747 } 748 printf("\""); 749 } else 750 dnsname_print(cp, ep); 751 break; 752 case ICMP6_NI_SUBJ_IPV4: 753 if (!TTEST2(*dp, sizeof(*ni6) + sizeof(struct in_addr))) 754 break; 755 if (siz != sizeof(*ni6) + sizeof(struct in_addr)) { 756 if (vflag) 757 printf(", invalid subject len"); 758 break; 759 } 760 printf(", subject=%s", 761 getname((const u_char *)(ni6 + 1))); 762 break; 763 default: 764 printf(", unknown subject"); 765 break; 766 } 767 768 /*(*/ 769 printf(")"); 770 break; 771 772 case ICMP6_NI_REPLY: 773 if (icmp6len > siz) { 774 printf("[|icmp6: node information reply]"); 775 break; 776 } 777 778 needcomma = 0; 779 780 ni6 = (struct icmp6_nodeinfo *)dp; 781 printf("icmp6: node information reply"); 782 printf(" ("); /*)*/ 783 switch (ni6->ni_code) { 784 case ICMP6_NI_SUCCESS: 785 if (vflag) { 786 printf("success"); 787 needcomma++; 788 } 789 break; 790 case ICMP6_NI_REFUSED: 791 printf("refused"); 792 needcomma++; 793 if (siz != sizeof(*ni6)) 794 if (vflag) 795 printf(", invalid length"); 796 break; 797 case ICMP6_NI_UNKNOWN: 798 printf("unknown"); 799 needcomma++; 800 if (siz != sizeof(*ni6)) 801 if (vflag) 802 printf(", invalid length"); 803 break; 804 } 805 806 if (ni6->ni_code != ICMP6_NI_SUCCESS) { 807 /*(*/ 808 printf(")"); 809 break; 810 } 811 812 switch (ntohs(ni6->ni_qtype)) { 813 case NI_QTYPE_NOOP: 814 if (needcomma) 815 printf(", "); 816 printf("noop"); 817 if (siz != sizeof(*ni6)) 818 if (vflag) 819 printf(", invalid length"); 820 break; 821 case NI_QTYPE_SUPTYPES: 822 if (needcomma) 823 printf(", "); 824 printf("supported qtypes"); 825 i = ntohs(ni6->ni_flags); 826 if (i) 827 printf(" [%s]", (i & 0x01) ? "C" : ""); 828 break; 829 case NI_QTYPE_FQDN: 830 if (needcomma) 831 printf(", "); 832 printf("DNS name"); 833 cp = (const u_char *)(ni6 + 1) + 4; 834 if (cp[0] == ep - cp - 1) { 835 /* icmp-name-lookup-03, pascal string */ 836 if (vflag) 837 printf(", 03 draft"); 838 cp++; 839 printf(", \""); 840 while (cp < ep) { 841 safeputchar(*cp); 842 cp++; 843 } 844 printf("\""); 845 } else 846 dnsname_print(cp, ep); 847 if ((ntohs(ni6->ni_flags) & 0x01) != 0) 848 printf(" [TTL=%u]", *(u_int32_t *)(ni6 + 1)); 849 break; 850 case NI_QTYPE_NODEADDR: 851 if (needcomma) 852 printf(", "); 853 printf("node addresses"); 854 i = sizeof(*ni6); 855 while (i < siz) { 856 if (i + sizeof(struct in6_addr) + sizeof(int32_t) > siz) 857 break; 858 printf(" %s", getname6(bp + i)); 859 i += sizeof(struct in6_addr); 860 printf("(%d)", (int32_t)ntohl(*(int32_t *)(bp + i))); 861 i += sizeof(int32_t); 862 } 863 i = ni6->ni_flags; 864 if (!i) 865 break; 866 printf(" [%s%s%s%s%s%s%s]", 867 (i & NI_NODEADDR_FLAG_ANYCAST) ? "a" : "", 868 (i & NI_NODEADDR_FLAG_GLOBAL) ? "G" : "", 869 (i & NI_NODEADDR_FLAG_SITELOCAL) ? "S" : "", 870 (i & NI_NODEADDR_FLAG_LINKLOCAL) ? "L" : "", 871 (i & NI_NODEADDR_FLAG_COMPAT) ? "C" : "", 872 (i & NI_NODEADDR_FLAG_ALL) ? "A" : "", 873 (i & NI_NODEADDR_FLAG_TRUNCATE) ? "T" : ""); 874 break; 875 default: 876 if (needcomma) 877 printf(", "); 878 printf("unknown"); 879 break; 880 } 881 882 /*(*/ 883 printf(")"); 884 break; 885 } 886 return; 887 888 trunc: 889 fputs("[|icmp6]", stdout); 890 } 891 892 void 893 icmp6_rrenum_print(int icmp6len, const u_char *bp, const u_char *ep) 894 { 895 struct icmp6_router_renum *rr6; 896 struct icmp6_hdr *dp; 897 size_t siz; 898 const char *cp; 899 struct rr_pco_match *match; 900 struct rr_pco_use *use; 901 char hbuf[NI_MAXHOST]; 902 int n; 903 904 dp = (struct icmp6_hdr *)bp; 905 rr6 = (struct icmp6_router_renum *)bp; 906 siz = ep - bp; 907 cp = (const char *)(rr6 + 1); 908 909 TCHECK(rr6->rr_reserved); 910 switch (rr6->rr_code) { 911 case ICMP6_ROUTER_RENUMBERING_COMMAND: 912 printf("router renum: command"); 913 break; 914 case ICMP6_ROUTER_RENUMBERING_RESULT: 915 printf("router renum: result"); 916 break; 917 case ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET: 918 printf("router renum: sequence number reset"); 919 break; 920 default: 921 printf("router renum: code-#%d", rr6->rr_code); 922 break; 923 } 924 925 printf(", seq=%u", (u_int32_t)ntohl(rr6->rr_seqnum)); 926 927 if (vflag) { 928 #define F(x, y) ((rr6->rr_flags) & (x) ? (y) : "") 929 printf("["); /*]*/ 930 if (rr6->rr_flags) { 931 printf("%s%s%s%s%s,", F(ICMP6_RR_FLAGS_TEST, "T"), 932 F(ICMP6_RR_FLAGS_REQRESULT, "R"), 933 F(ICMP6_RR_FLAGS_FORCEAPPLY, "A"), 934 F(ICMP6_RR_FLAGS_SPECSITE, "S"), 935 F(ICMP6_RR_FLAGS_PREVDONE, "P")); 936 } 937 printf("seg=%u,", rr6->rr_segnum); 938 printf("maxdelay=%u", rr6->rr_maxdelay); 939 if (rr6->rr_reserved) 940 printf("rsvd=0x%x", (u_int16_t)ntohs(rr6->rr_reserved)); 941 /*[*/ 942 printf("]"); 943 #undef F 944 } 945 946 if (rr6->rr_code == ICMP6_ROUTER_RENUMBERING_COMMAND) { 947 match = (struct rr_pco_match *)cp; 948 cp = (const char *)(match + 1); 949 950 TCHECK(match->rpm_prefix); 951 952 if (vflag > 1) 953 printf("\n\t"); 954 else 955 printf(" "); 956 printf("match("); /*)*/ 957 switch (match->rpm_code) { 958 case RPM_PCO_ADD: printf("add"); break; 959 case RPM_PCO_CHANGE: printf("change"); break; 960 case RPM_PCO_SETGLOBAL: printf("setglobal"); break; 961 default: printf("#%u", match->rpm_code); break; 962 } 963 964 if (vflag) { 965 printf(",ord=%u", match->rpm_ordinal); 966 printf(",min=%u", match->rpm_minlen); 967 printf(",max=%u", match->rpm_maxlen); 968 } 969 if (inet_ntop(AF_INET6, &match->rpm_prefix, hbuf, sizeof(hbuf))) 970 printf(",%s/%u", hbuf, match->rpm_matchlen); 971 else 972 printf(",?/%u", match->rpm_matchlen); 973 /*(*/ 974 printf(")"); 975 976 n = match->rpm_len - 3; 977 if (n % 4) 978 goto trunc; 979 n /= 4; 980 while (n-- > 0) { 981 use = (struct rr_pco_use *)cp; 982 cp = (const char *)(use + 1); 983 984 TCHECK(use->rpu_prefix); 985 986 if (vflag > 1) 987 printf("\n\t"); 988 else 989 printf(" "); 990 printf("use("); /*)*/ 991 if (use->rpu_flags) { 992 #define F(x, y) ((use->rpu_flags) & (x) ? (y) : "") 993 printf("%s%s,", 994 F(ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME, "V"), 995 F(ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME, "P")); 996 #undef F 997 } 998 if (vflag) { 999 printf("mask=0x%x,", use->rpu_ramask); 1000 printf("raflags=0x%x,", use->rpu_raflags); 1001 if (~use->rpu_vltime == 0) 1002 printf("vltime=infty,"); 1003 else 1004 printf("vltime=%u,", 1005 (u_int32_t)ntohl(use->rpu_vltime)); 1006 if (~use->rpu_pltime == 0) 1007 printf("pltime=infty,"); 1008 else 1009 printf("pltime=%u,", 1010 (u_int32_t)ntohl(use->rpu_pltime)); 1011 } 1012 if (inet_ntop(AF_INET6, &use->rpu_prefix, hbuf, 1013 sizeof(hbuf))) 1014 printf("%s/%u/%u", hbuf, use->rpu_uselen, 1015 use->rpu_keeplen); 1016 else 1017 printf("?/%u/%u", use->rpu_uselen, 1018 use->rpu_keeplen); 1019 /*(*/ 1020 printf(")"); 1021 } 1022 } 1023 1024 return; 1025 1026 trunc: 1027 fputs("[|icmp6]", stdout); 1028 } 1029 1030 #endif /* INET6 */ 1031