contrib/tcpdump/print-icmp6.c

   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 /* \summary: IPv6 Internet Control Message Protocol (ICMPv6) printer */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 #include <netdissect-stdinc.h>
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32
  33 #include "netdissect.h"
  34 #include "addrtoname.h"
  35 #include "addrtostr.h"
  36 #include "extract.h"
  37
  38 #include "ip6.h"
  39 #include "ipproto.h"
  40
  41 #include "udp.h"
  42 #include "ah.h"
  43
  44 /*      NetBSD: icmp6.h,v 1.13 2000/08/03 16:30:37 itojun Exp   */
  45 /*      $KAME: icmp6.h,v 1.22 2000/08/03 15:25:16 jinmei Exp $  */
  46
  47 /*
  48  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  49  * All rights reserved.
  50  *
  51  * Redistribution and use in source and binary forms, with or without
  52  * modification, are permitted provided that the following conditions
  53  * are met:
  54  * 1. Redistributions of source code must retain the above copyright
  55  *    notice, this list of conditions and the following disclaimer.
  56  * 2. Redistributions in binary form must reproduce the above copyright
  57  *    notice, this list of conditions and the following disclaimer in the
  58  *    documentation and/or other materials provided with the distribution.
  59  * 3. Neither the name of the project nor the names of its contributors
  60  *    may be used to endorse or promote products derived from this software
  61  *    without specific prior written permission.
  62  *
  63  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  64  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  65  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  66  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  67  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  68  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  69  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  70  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  71  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  72  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  73  * SUCH DAMAGE.
  74  */
  75
  76 struct icmp6_hdr {
  77         uint8_t         icmp6_type;     /* type field */
  78         uint8_t         icmp6_code;     /* code field */
  79         uint16_t        icmp6_cksum;    /* checksum field */
  80         union {
  81                 uint32_t        icmp6_un_data32[1]; /* type-specific field */
  82                 uint16_t        icmp6_un_data16[2]; /* type-specific field */
  83                 uint8_t         icmp6_un_data8[4];  /* type-specific field */
  84         } icmp6_dataun;
  85 };
  86
  87 #define icmp6_data32    icmp6_dataun.icmp6_un_data32
  88 #define icmp6_data16    icmp6_dataun.icmp6_un_data16
  89 #define icmp6_data8     icmp6_dataun.icmp6_un_data8
  90 #define icmp6_pptr      icmp6_data32[0]         /* parameter prob */
  91 #define icmp6_mtu       icmp6_data32[0]         /* packet too big */
  92 #define icmp6_id        icmp6_data16[0]         /* echo request/reply */
  93 #define icmp6_seq       icmp6_data16[1]         /* echo request/reply */
  94 #define icmp6_maxdelay  icmp6_data16[0]         /* mcast group membership */
  95
  96 #define ICMP6_DST_UNREACH               1       /* dest unreachable, codes: */
  97 #define ICMP6_PACKET_TOO_BIG            2       /* packet too big */
  98 #define ICMP6_TIME_EXCEEDED             3       /* time exceeded, code: */
  99 #define ICMP6_PARAM_PROB                4       /* ip6 header bad */
 100
 101 #define ICMP6_ECHO_REQUEST              128     /* echo service */
 102 #define ICMP6_ECHO_REPLY                129     /* echo reply */
 103 #define ICMP6_MEMBERSHIP_QUERY          130     /* group membership query */
 104 #define MLD6_LISTENER_QUERY             130     /* multicast listener query */
 105 #define ICMP6_MEMBERSHIP_REPORT         131     /* group membership report */
 106 #define MLD6_LISTENER_REPORT            131     /* multicast listener report */
 107 #define ICMP6_MEMBERSHIP_REDUCTION      132     /* group membership termination */
 108 #define MLD6_LISTENER_DONE              132     /* multicast listener done */
 109
 110 #define ND_ROUTER_SOLICIT               133     /* router solicitation */
 111 #define ND_ROUTER_ADVERT                134     /* router advertisement */
 112 #define ND_NEIGHBOR_SOLICIT             135     /* neighbor solicitation */
 113 #define ND_NEIGHBOR_ADVERT              136     /* neighbor advertisement */
 114 #define ND_REDIRECT                     137     /* redirect */
 115
 116 #define ICMP6_ROUTER_RENUMBERING        138     /* router renumbering */
 117
 118 #define ICMP6_WRUREQUEST                139     /* who are you request */
 119 #define ICMP6_WRUREPLY                  140     /* who are you reply */
 120 #define ICMP6_FQDN_QUERY                139     /* FQDN query */
 121 #define ICMP6_FQDN_REPLY                140     /* FQDN reply */
 122 #define ICMP6_NI_QUERY                  139     /* node information request */
 123 #define ICMP6_NI_REPLY                  140     /* node information reply */
 124 #define IND_SOLICIT                     141     /* inverse neighbor solicitation */
 125 #define IND_ADVERT                      142     /* inverse neighbor advertisement */
 126
 127 #define ICMP6_V2_MEMBERSHIP_REPORT      143     /* v2 membership report */
 128 #define MLDV2_LISTENER_REPORT           143     /* v2 multicast listener report */
 129 #define ICMP6_HADISCOV_REQUEST          144
 130 #define ICMP6_HADISCOV_REPLY            145
 131 #define ICMP6_MOBILEPREFIX_SOLICIT      146
 132 #define ICMP6_MOBILEPREFIX_ADVERT       147
 133
 134 #define MLD6_MTRACE_RESP                200     /* mtrace response(to sender) */
 135 #define MLD6_MTRACE                     201     /* mtrace messages */
 136
 137 #define ICMP6_MAXTYPE                   201
 138
 139 #define ICMP6_DST_UNREACH_NOROUTE       0       /* no route to destination */
 140 #define ICMP6_DST_UNREACH_ADMIN         1       /* administratively prohibited */
 141 #define ICMP6_DST_UNREACH_NOTNEIGHBOR   2       /* not a neighbor(obsolete) */
 142 #define ICMP6_DST_UNREACH_BEYONDSCOPE   2       /* beyond scope of source address */
 143 #define ICMP6_DST_UNREACH_ADDR          3       /* address unreachable */
 144 #define ICMP6_DST_UNREACH_NOPORT        4       /* port unreachable */
 145
 146 #define ICMP6_TIME_EXCEED_TRANSIT       0       /* ttl==0 in transit */
 147 #define ICMP6_TIME_EXCEED_REASSEMBLY    1       /* ttl==0 in reass */
 148
 149 #define ICMP6_PARAMPROB_HEADER          0       /* erroneous header field */
 150 #define ICMP6_PARAMPROB_NEXTHEADER      1       /* unrecognized next header */
 151 #define ICMP6_PARAMPROB_OPTION          2       /* unrecognized option */
 152
 153 #define ICMP6_INFOMSG_MASK              0x80    /* all informational messages */
 154
 155 #define ICMP6_NI_SUBJ_IPV6      0       /* Query Subject is an IPv6 address */
 156 #define ICMP6_NI_SUBJ_FQDN      1       /* Query Subject is a Domain name */
 157 #define ICMP6_NI_SUBJ_IPV4      2       /* Query Subject is an IPv4 address */
 158
 159 #define ICMP6_NI_SUCCESS        0       /* node information successful reply */
 160 #define ICMP6_NI_REFUSED        1       /* node information request is refused */
 161 #define ICMP6_NI_UNKNOWN        2       /* unknown Qtype */
 162
 163 #define ICMP6_ROUTER_RENUMBERING_COMMAND  0     /* rr command */
 164 #define ICMP6_ROUTER_RENUMBERING_RESULT   1     /* rr result */
 165 #define ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET   255     /* rr seq num reset */
 166
 167 /* Used in kernel only */
 168 #define ND_REDIRECT_ONLINK      0       /* redirect to an on-link node */
 169 #define ND_REDIRECT_ROUTER      1       /* redirect to a better router */
 170
 171 /*
 172  * Multicast Listener Discovery
 173  */
 174 struct mld6_hdr {
 175         struct icmp6_hdr        mld6_hdr;
 176         struct in6_addr         mld6_addr; /* multicast address */
 177 };
 178
 179 #define mld6_type       mld6_hdr.icmp6_type
 180 #define mld6_code       mld6_hdr.icmp6_code
 181 #define mld6_cksum      mld6_hdr.icmp6_cksum
 182 #define mld6_maxdelay   mld6_hdr.icmp6_data16[0]
 183 #define mld6_reserved   mld6_hdr.icmp6_data16[1]
 184
 185 #define MLD_MINLEN      24
 186 #define MLDV2_MINLEN    28
 187
 188 /*
 189  * Neighbor Discovery
 190  */
 191
 192 struct nd_router_solicit {      /* router solicitation */
 193         struct icmp6_hdr        nd_rs_hdr;
 194         /* could be followed by options */
 195 };
 196
 197 #define nd_rs_type      nd_rs_hdr.icmp6_type
 198 #define nd_rs_code      nd_rs_hdr.icmp6_code
 199 #define nd_rs_cksum     nd_rs_hdr.icmp6_cksum
 200 #define nd_rs_reserved  nd_rs_hdr.icmp6_data32[0]
 201
 202 struct nd_router_advert {       /* router advertisement */
 203         struct icmp6_hdr        nd_ra_hdr;
 204         uint32_t                nd_ra_reachable;        /* reachable time */
 205         uint32_t                nd_ra_retransmit;       /* retransmit timer */
 206         /* could be followed by options */
 207 };
 208
 209 #define nd_ra_type              nd_ra_hdr.icmp6_type
 210 #define nd_ra_code              nd_ra_hdr.icmp6_code
 211 #define nd_ra_cksum             nd_ra_hdr.icmp6_cksum
 212 #define nd_ra_curhoplimit       nd_ra_hdr.icmp6_data8[0]
 213 #define nd_ra_flags_reserved    nd_ra_hdr.icmp6_data8[1]
 214 #define ND_RA_FLAG_MANAGED      0x80
 215 #define ND_RA_FLAG_OTHER        0x40
 216 #define ND_RA_FLAG_HOME_AGENT   0x20
 217
 218 /*
 219  * Router preference values based on draft-draves-ipngwg-router-selection-01.
 220  * These are non-standard definitions.
 221  */
 222 #define ND_RA_FLAG_RTPREF_MASK  0x18 /* 00011000 */
 223
 224 #define ND_RA_FLAG_RTPREF_HIGH  0x08 /* 00001000 */
 225 #define ND_RA_FLAG_RTPREF_MEDIUM        0x00 /* 00000000 */
 226 #define ND_RA_FLAG_RTPREF_LOW   0x18 /* 00011000 */
 227 #define ND_RA_FLAG_RTPREF_RSV   0x10 /* 00010000 */
 228
 229 #define nd_ra_router_lifetime   nd_ra_hdr.icmp6_data16[1]
 230
 231 struct nd_neighbor_solicit {    /* neighbor solicitation */
 232         struct icmp6_hdr        nd_ns_hdr;
 233         struct in6_addr         nd_ns_target;   /*target address */
 234         /* could be followed by options */
 235 };
 236
 237 #define nd_ns_type              nd_ns_hdr.icmp6_type
 238 #define nd_ns_code              nd_ns_hdr.icmp6_code
 239 #define nd_ns_cksum             nd_ns_hdr.icmp6_cksum
 240 #define nd_ns_reserved          nd_ns_hdr.icmp6_data32[0]
 241
 242 struct nd_neighbor_advert {     /* neighbor advertisement */
 243         struct icmp6_hdr        nd_na_hdr;
 244         struct in6_addr         nd_na_target;   /* target address */
 245         /* could be followed by options */
 246 };
 247
 248 #define nd_na_type              nd_na_hdr.icmp6_type
 249 #define nd_na_code              nd_na_hdr.icmp6_code
 250 #define nd_na_cksum             nd_na_hdr.icmp6_cksum
 251 #define nd_na_flags_reserved    nd_na_hdr.icmp6_data32[0]
 252
 253 #define ND_NA_FLAG_ROUTER               0x80000000
 254 #define ND_NA_FLAG_SOLICITED            0x40000000
 255 #define ND_NA_FLAG_OVERRIDE             0x20000000
 256
 257 struct nd_redirect {            /* redirect */
 258         struct icmp6_hdr        nd_rd_hdr;
 259         struct in6_addr         nd_rd_target;   /* target address */
 260         struct in6_addr         nd_rd_dst;      /* destination address */
 261         /* could be followed by options */
 262 };
 263
 264 #define nd_rd_type              nd_rd_hdr.icmp6_type
 265 #define nd_rd_code              nd_rd_hdr.icmp6_code
 266 #define nd_rd_cksum             nd_rd_hdr.icmp6_cksum
 267 #define nd_rd_reserved          nd_rd_hdr.icmp6_data32[0]
 268
 269 struct nd_opt_hdr {             /* Neighbor discovery option header */
 270         uint8_t         nd_opt_type;
 271         uint8_t         nd_opt_len;
 272         /* followed by option specific data*/
 273 };
 274
 275 #define ND_OPT_SOURCE_LINKADDR          1
 276 #define ND_OPT_TARGET_LINKADDR          2
 277 #define ND_OPT_PREFIX_INFORMATION       3
 278 #define ND_OPT_REDIRECTED_HEADER        4
 279 #define ND_OPT_MTU                      5
 280 #define ND_OPT_ADVINTERVAL              7
 281 #define ND_OPT_HOMEAGENT_INFO           8
 282 #define ND_OPT_ROUTE_INFO               24      /* RFC4191 */
 283 #define ND_OPT_RDNSS                    25
 284 #define ND_OPT_DNSSL                    31
 285
 286 struct nd_opt_prefix_info {     /* prefix information */
 287         nd_uint8_t              nd_opt_pi_type;
 288         nd_uint8_t              nd_opt_pi_len;
 289         nd_uint8_t              nd_opt_pi_prefix_len;
 290         nd_uint8_t              nd_opt_pi_flags_reserved;
 291         nd_uint32_t             nd_opt_pi_valid_time;
 292         nd_uint32_t             nd_opt_pi_preferred_time;
 293         nd_uint32_t             nd_opt_pi_reserved2;
 294         struct in6_addr nd_opt_pi_prefix;
 295 };
 296
 297 #define ND_OPT_PI_FLAG_ONLINK           0x80
 298 #define ND_OPT_PI_FLAG_AUTO             0x40
 299 #define ND_OPT_PI_FLAG_ROUTER           0x20    /*2292bis*/
 300
 301 struct nd_opt_rd_hdr {         /* redirected header */
 302         uint8_t         nd_opt_rh_type;
 303         uint8_t         nd_opt_rh_len;
 304         uint16_t        nd_opt_rh_reserved1;
 305         uint32_t        nd_opt_rh_reserved2;
 306         /* followed by IP header and data */
 307 };
 308
 309 struct nd_opt_mtu {             /* MTU option */
 310         uint8_t         nd_opt_mtu_type;
 311         uint8_t         nd_opt_mtu_len;
 312         uint16_t        nd_opt_mtu_reserved;
 313         uint32_t        nd_opt_mtu_mtu;
 314 };
 315
 316 struct nd_opt_rdnss {           /* RDNSS RFC 6106 5.1 */
 317         uint8_t         nd_opt_rdnss_type;
 318         uint8_t         nd_opt_rdnss_len;
 319         uint16_t        nd_opt_rdnss_reserved;
 320         uint32_t        nd_opt_rdnss_lifetime;
 321         struct in6_addr nd_opt_rdnss_addr[1];   /* variable-length */
 322 };
 323
 324 struct nd_opt_dnssl {           /* DNSSL RFC 6106 5.2 */
 325         uint8_t  nd_opt_dnssl_type;
 326         uint8_t  nd_opt_dnssl_len;
 327         uint16_t nd_opt_dnssl_reserved;
 328         uint32_t nd_opt_dnssl_lifetime;
 329         /* followed by list of DNS search domains, variable-length */
 330 };
 331
 332 struct nd_opt_advinterval {     /* Advertisement interval option */
 333         uint8_t         nd_opt_adv_type;
 334         uint8_t         nd_opt_adv_len;
 335         uint16_t        nd_opt_adv_reserved;
 336         uint32_t        nd_opt_adv_interval;
 337 };
 338
 339 struct nd_opt_homeagent_info {  /* Home Agent info */
 340         uint8_t         nd_opt_hai_type;
 341         uint8_t         nd_opt_hai_len;
 342         uint16_t        nd_opt_hai_reserved;
 343         int16_t         nd_opt_hai_preference;
 344         uint16_t        nd_opt_hai_lifetime;
 345 };
 346
 347 struct nd_opt_route_info {      /* route info */
 348         uint8_t         nd_opt_rti_type;
 349         uint8_t         nd_opt_rti_len;
 350         uint8_t         nd_opt_rti_prefixlen;
 351         uint8_t         nd_opt_rti_flags;
 352         uint32_t        nd_opt_rti_lifetime;
 353         /* prefix follows */
 354 };
 355
 356 /*
 357  * icmp6 namelookup
 358  */
 359
 360 struct icmp6_namelookup {
 361         struct icmp6_hdr        icmp6_nl_hdr;
 362         uint8_t         icmp6_nl_nonce[8];
 363         int32_t         icmp6_nl_ttl;
 364 #if 0
 365         uint8_t         icmp6_nl_len;
 366         uint8_t         icmp6_nl_name[3];
 367 #endif
 368         /* could be followed by options */
 369 };
 370
 371 /*
 372  * icmp6 node information
 373  */
 374 struct icmp6_nodeinfo {
 375         struct icmp6_hdr icmp6_ni_hdr;
 376         uint8_t icmp6_ni_nonce[8];
 377         /* could be followed by reply data */
 378 };
 379
 380 #define ni_type         icmp6_ni_hdr.icmp6_type
 381 #define ni_code         icmp6_ni_hdr.icmp6_code
 382 #define ni_cksum        icmp6_ni_hdr.icmp6_cksum
 383 #define ni_qtype        icmp6_ni_hdr.icmp6_data16[0]
 384 #define ni_flags        icmp6_ni_hdr.icmp6_data16[1]
 385
 386 #define NI_QTYPE_NOOP           0 /* NOOP  */
 387 #define NI_QTYPE_SUPTYPES       1 /* Supported Qtypes */
 388 #define NI_QTYPE_FQDN           2 /* FQDN (draft 04) */
 389 #define NI_QTYPE_DNSNAME        2 /* DNS Name */
 390 #define NI_QTYPE_NODEADDR       3 /* Node Addresses */
 391 #define NI_QTYPE_IPV4ADDR       4 /* IPv4 Addresses */
 392
 393 /* network endian */
 394 #define NI_SUPTYPE_FLAG_COMPRESS        ((uint16_t)htons(0x1))
 395 #define NI_FQDN_FLAG_VALIDTTL           ((uint16_t)htons(0x1))
 396
 397 /* network endian */
 398 #define NI_NODEADDR_FLAG_TRUNCATE       ((uint16_t)htons(0x1))
 399 #define NI_NODEADDR_FLAG_ALL            ((uint16_t)htons(0x2))
 400 #define NI_NODEADDR_FLAG_COMPAT         ((uint16_t)htons(0x4))
 401 #define NI_NODEADDR_FLAG_LINKLOCAL      ((uint16_t)htons(0x8))
 402 #define NI_NODEADDR_FLAG_SITELOCAL      ((uint16_t)htons(0x10))
 403 #define NI_NODEADDR_FLAG_GLOBAL         ((uint16_t)htons(0x20))
 404 #define NI_NODEADDR_FLAG_ANYCAST        ((uint16_t)htons(0x40)) /* just experimental. not in spec */
 405
 406 struct ni_reply_fqdn {
 407         uint32_t ni_fqdn_ttl;   /* TTL */
 408         uint8_t ni_fqdn_namelen; /* length in octets of the FQDN */
 409         uint8_t ni_fqdn_name[3]; /* XXX: alignment */
 410 };
 411
 412 /*
 413  * Router Renumbering. as router-renum-08.txt
 414  */
 415 struct icmp6_router_renum {     /* router renumbering header */
 416         struct icmp6_hdr        rr_hdr;
 417         uint8_t         rr_segnum;
 418         uint8_t         rr_flags;
 419         uint16_t        rr_maxdelay;
 420         uint32_t        rr_reserved;
 421 };
 422 #define ICMP6_RR_FLAGS_TEST             0x80
 423 #define ICMP6_RR_FLAGS_REQRESULT        0x40
 424 #define ICMP6_RR_FLAGS_FORCEAPPLY       0x20
 425 #define ICMP6_RR_FLAGS_SPECSITE         0x10
 426 #define ICMP6_RR_FLAGS_PREVDONE         0x08
 427
 428 #define rr_type         rr_hdr.icmp6_type
 429 #define rr_code         rr_hdr.icmp6_code
 430 #define rr_cksum        rr_hdr.icmp6_cksum
 431 #define rr_seqnum       rr_hdr.icmp6_data32[0]
 432
 433 struct rr_pco_match {           /* match prefix part */
 434         uint8_t         rpm_code;
 435         uint8_t         rpm_len;
 436         uint8_t         rpm_ordinal;
 437         uint8_t         rpm_matchlen;
 438         uint8_t         rpm_minlen;
 439         uint8_t         rpm_maxlen;
 440         uint16_t        rpm_reserved;
 441         struct  in6_addr        rpm_prefix;
 442 };
 443
 444 #define RPM_PCO_ADD             1
 445 #define RPM_PCO_CHANGE          2
 446 #define RPM_PCO_SETGLOBAL       3
 447 #define RPM_PCO_MAX             4
 448
 449 struct rr_pco_use {             /* use prefix part */
 450         uint8_t         rpu_uselen;
 451         uint8_t         rpu_keeplen;
 452         uint8_t         rpu_ramask;
 453         uint8_t         rpu_raflags;
 454         uint32_t        rpu_vltime;
 455         uint32_t        rpu_pltime;
 456         uint32_t        rpu_flags;
 457         struct  in6_addr rpu_prefix;
 458 };
 459 #define ICMP6_RR_PCOUSE_RAFLAGS_ONLINK  0x80
 460 #define ICMP6_RR_PCOUSE_RAFLAGS_AUTO    0x40
 461
 462 /* network endian */
 463 #define ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME     ((uint32_t)htonl(0x80000000))
 464 #define ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME     ((uint32_t)htonl(0x40000000))
 465
 466 struct rr_result {              /* router renumbering result message */
 467         uint16_t        rrr_flags;
 468         uint8_t         rrr_ordinal;
 469         uint8_t         rrr_matchedlen;
 470         uint32_t        rrr_ifid;
 471         struct  in6_addr rrr_prefix;
 472 };
 473 /* network endian */
 474 #define ICMP6_RR_RESULT_FLAGS_OOB               ((uint16_t)htons(0x0002))
 475 #define ICMP6_RR_RESULT_FLAGS_FORBIDDEN         ((uint16_t)htons(0x0001))
 476
 477 static const char *get_rtpref(u_int);
 478 static const char *get_lifetime(uint32_t);
 479 static void print_lladdr(netdissect_options *ndo, const u_char *, size_t);
 480 static void icmp6_opt_print(netdissect_options *ndo, const u_char *, int);
 481 static void mld6_print(netdissect_options *ndo, const u_char *);
 482 static void mldv2_report_print(netdissect_options *ndo, const u_char *, u_int);
 483 static void mldv2_query_print(netdissect_options *ndo, const u_char *, u_int);
 484 static const struct udphdr *get_upperlayer(netdissect_options *ndo, const u_char *, u_int *);
 485 static void dnsname_print(netdissect_options *ndo, const u_char *, const u_char *);
 486 static void icmp6_nodeinfo_print(netdissect_options *ndo, u_int, const u_char *, const u_char *);
 487 static void icmp6_rrenum_print(netdissect_options *ndo, const u_char *, const u_char *);
 488
 489 #ifndef abs
 490 #define abs(a)  ((0 < (a)) ? (a) : -(a))
 491 #endif
 492
 493 #include "rpl.h"
 494
 495 static const struct tok icmp6_type_values[] = {
 496     { ICMP6_DST_UNREACH, "destination unreachable"},
 497     { ICMP6_PACKET_TOO_BIG, "packet too big"},
 498     { ICMP6_TIME_EXCEEDED, "time exceeded in-transit"},
 499     { ICMP6_PARAM_PROB, "parameter problem"},
 500     { ICMP6_ECHO_REQUEST, "echo request"},
 501     { ICMP6_ECHO_REPLY, "echo reply"},
 502     { MLD6_LISTENER_QUERY, "multicast listener query"},
 503     { MLD6_LISTENER_REPORT, "multicast listener report"},
 504     { MLD6_LISTENER_DONE, "multicast listener done"},
 505     { ND_ROUTER_SOLICIT, "router solicitation"},
 506     { ND_ROUTER_ADVERT, "router advertisement"},
 507     { ND_NEIGHBOR_SOLICIT, "neighbor solicitation"},
 508     { ND_NEIGHBOR_ADVERT, "neighbor advertisement"},
 509     { ND_REDIRECT, "redirect"},
 510     { ICMP6_ROUTER_RENUMBERING, "router renumbering"},
 511     { IND_SOLICIT, "inverse neighbor solicitation"},
 512     { IND_ADVERT, "inverse neighbor advertisement"},
 513     { MLDV2_LISTENER_REPORT, "multicast listener report v2"},
 514     { ICMP6_HADISCOV_REQUEST, "ha discovery request"},
 515     { ICMP6_HADISCOV_REPLY, "ha discovery reply"},
 516     { ICMP6_MOBILEPREFIX_SOLICIT, "mobile router solicitation"},
 517     { ICMP6_MOBILEPREFIX_ADVERT, "mobile router advertisement"},
 518     { ICMP6_WRUREQUEST, "who-are-you request"},
 519     { ICMP6_WRUREPLY, "who-are-you reply"},
 520     { ICMP6_NI_QUERY, "node information query"},
 521     { ICMP6_NI_REPLY, "node information reply"},
 522     { MLD6_MTRACE, "mtrace message"},
 523     { MLD6_MTRACE_RESP, "mtrace response"},
 524     { ND_RPL_MESSAGE,   "RPL"},
 525     { 0,        NULL }
 526 };
 527
 528 static const struct tok icmp6_dst_unreach_code_values[] = {
 529     { ICMP6_DST_UNREACH_NOROUTE, "unreachable route" },
 530     { ICMP6_DST_UNREACH_ADMIN, " unreachable prohibited"},
 531     { ICMP6_DST_UNREACH_BEYONDSCOPE, "beyond scope"},
 532     { ICMP6_DST_UNREACH_ADDR, "unreachable address"},
 533     { ICMP6_DST_UNREACH_NOPORT, "unreachable port"},
 534     { 0,        NULL }
 535 };
 536
 537 static const struct tok icmp6_opt_pi_flag_values[] = {
 538     { ND_OPT_PI_FLAG_ONLINK, "onlink" },
 539     { ND_OPT_PI_FLAG_AUTO, "auto" },
 540     { ND_OPT_PI_FLAG_ROUTER, "router" },
 541     { 0,        NULL }
 542 };
 543
 544 static const struct tok icmp6_opt_ra_flag_values[] = {
 545     { ND_RA_FLAG_MANAGED, "managed" },
 546     { ND_RA_FLAG_OTHER, "other stateful"},
 547     { ND_RA_FLAG_HOME_AGENT, "home agent"},
 548     { 0,        NULL }
 549 };
 550
 551 static const struct tok icmp6_nd_na_flag_values[] = {
 552     { ND_NA_FLAG_ROUTER, "router" },
 553     { ND_NA_FLAG_SOLICITED, "solicited" },
 554     { ND_NA_FLAG_OVERRIDE, "override" },
 555     { 0,        NULL }
 556 };
 557
 558
 559 static const struct tok icmp6_opt_values[] = {
 560    { ND_OPT_SOURCE_LINKADDR, "source link-address"},
 561    { ND_OPT_TARGET_LINKADDR, "destination link-address"},
 562    { ND_OPT_PREFIX_INFORMATION, "prefix info"},
 563    { ND_OPT_REDIRECTED_HEADER, "redirected header"},
 564    { ND_OPT_MTU, "mtu"},
 565    { ND_OPT_RDNSS, "rdnss"},
 566    { ND_OPT_DNSSL, "dnssl"},
 567    { ND_OPT_ADVINTERVAL, "advertisement interval"},
 568    { ND_OPT_HOMEAGENT_INFO, "homeagent information"},
 569    { ND_OPT_ROUTE_INFO, "route info"},
 570    { 0, NULL }
 571 };
 572
 573 /* mldv2 report types */
 574 static const struct tok mldv2report2str[] = {
 575         { 1,    "is_in" },
 576         { 2,    "is_ex" },
 577         { 3,    "to_in" },
 578         { 4,    "to_ex" },
 579         { 5,    "allow" },
 580         { 6,    "block" },
 581         { 0,    NULL }
 582 };
 583
 584 static const char *
 585 get_rtpref(u_int v)
 586 {
 587         static const char *rtpref_str[] = {
 588                 "medium",               /* 00 */
 589                 "high",                 /* 01 */
 590                 "rsv",                  /* 10 */
 591                 "low"                   /* 11 */
 592         };
 593
 594         return rtpref_str[((v & ND_RA_FLAG_RTPREF_MASK) >> 3) & 0xff];
 595 }
 596
 597 static const char *
 598 get_lifetime(uint32_t v)
 599 {
 600         static char buf[20];
 601
 602         if (v == (uint32_t)~0UL)
 603                 return "infinity";
 604         else {
 605                 snprintf(buf, sizeof(buf), "%us", v);
 606                 return buf;
 607         }
 608 }
 609
 610 static void
 611 print_lladdr(netdissect_options *ndo, const uint8_t *p, size_t l)
 612 {
 613         const uint8_t *ep, *q;
 614
 615         q = p;
 616         ep = p + l;
 617         while (l > 0 && q < ep) {
 618                 if (q > p)
 619                         ND_PRINT((ndo,":"));
 620                 ND_PRINT((ndo,"%02x", *q++));
 621                 l--;
 622         }
 623 }
 624
 625 static int icmp6_cksum(netdissect_options *ndo, const struct ip6_hdr *ip6,
 626         const struct icmp6_hdr *icp, u_int len)
 627 {
 628         return nextproto6_cksum(ndo, ip6, (const uint8_t *)(const void *)icp, len, len,
 629                                 IPPROTO_ICMPV6);
 630 }
 631
 632 static const struct tok rpl_mop_values[] = {
 633         { RPL_DIO_NONSTORING,         "nonstoring"},
 634         { RPL_DIO_STORING,            "storing"},
 635         { RPL_DIO_NONSTORING_MULTICAST, "nonstoring-multicast"},
 636         { RPL_DIO_STORING_MULTICAST,  "storing-multicast"},
 637         { 0, NULL},
 638 };
 639
 640 static const struct tok rpl_subopt_values[] = {
 641         { RPL_OPT_PAD0, "pad0"},
 642         { RPL_OPT_PADN, "padN"},
 643         { RPL_DIO_METRICS, "metrics"},
 644         { RPL_DIO_ROUTINGINFO, "routinginfo"},
 645         { RPL_DIO_CONFIG,    "config"},
 646         { RPL_DAO_RPLTARGET, "rpltarget"},
 647         { RPL_DAO_TRANSITINFO, "transitinfo"},
 648         { RPL_DIO_DESTPREFIX, "destprefix"},
 649         { RPL_DAO_RPLTARGET_DESC, "rpltargetdesc"},
 650         { 0, NULL},
 651 };
 652
 653 static void
 654 rpl_dio_printopt(netdissect_options *ndo,
 655                  const struct rpl_dio_genoption *opt,
 656                  u_int length)
 657 {
 658         if(length < RPL_DIO_GENOPTION_LEN) return;
 659         length -= RPL_DIO_GENOPTION_LEN;
 660
 661         ND_TCHECK(opt->rpl_dio_len);
 662
 663         while((opt->rpl_dio_type == RPL_OPT_PAD0 &&
 664                (const u_char *)opt < ndo->ndo_snapend) ||
 665               ND_TTEST2(*opt,(opt->rpl_dio_len+2))) {
 666
 667                 unsigned int optlen = opt->rpl_dio_len+2;
 668                 if(opt->rpl_dio_type == RPL_OPT_PAD0) {
 669                         optlen = 1;
 670                         ND_PRINT((ndo, " opt:pad0"));
 671                 } else {
 672                         ND_PRINT((ndo, " opt:%s len:%u ",
 673                                   tok2str(rpl_subopt_values, "subopt:%u", opt->rpl_dio_type),
 674                                   optlen));
 675                         if(ndo->ndo_vflag > 2) {
 676                                 unsigned int paylen = opt->rpl_dio_len;
 677                                 if(paylen > length) paylen = length;
 678                                 hex_print(ndo,
 679                                           " ",
 680                                           ((const uint8_t *)opt) + RPL_DIO_GENOPTION_LEN,  /* content of DIO option */
 681                                           paylen);
 682                         }
 683                 }
 684                 opt = (const struct rpl_dio_genoption *)(((const char *)opt) + optlen);
 685                 length -= optlen;
 686         }
 687         return;
 688 trunc:
 689         ND_PRINT((ndo," [|truncated]"));
 690         return;
 691 }
 692
 693 static void
 694 rpl_dio_print(netdissect_options *ndo,
 695               const u_char *bp, u_int length)
 696 {
 697         const struct nd_rpl_dio *dio = (const struct nd_rpl_dio *)bp;
 698         const char *dagid_str;
 699
 700         ND_TCHECK(*dio);
 701         dagid_str = ip6addr_string (ndo, dio->rpl_dagid);
 702
 703         ND_PRINT((ndo, " [dagid:%s,seq:%u,instance:%u,rank:%u,%smop:%s,prf:%u]",
 704                   dagid_str,
 705                   dio->rpl_dtsn,
 706                   dio->rpl_instanceid,
 707                   EXTRACT_16BITS(&dio->rpl_dagrank),
 708                   RPL_DIO_GROUNDED(dio->rpl_mopprf) ? "grounded,":"",
 709                   tok2str(rpl_mop_values, "mop%u", RPL_DIO_MOP(dio->rpl_mopprf)),
 710                   RPL_DIO_PRF(dio->rpl_mopprf)));
 711
 712         if(ndo->ndo_vflag > 1) {
 713                 const struct rpl_dio_genoption *opt = (const struct rpl_dio_genoption *)&dio[1];
 714                 rpl_dio_printopt(ndo, opt, length);
 715         }
 716         return;
 717 trunc:
 718         ND_PRINT((ndo," [|truncated]"));
 719         return;
 720 }
 721
 722 static void
 723 rpl_dao_print(netdissect_options *ndo,
 724               const u_char *bp, u_int length)
 725 {
 726         const struct nd_rpl_dao *dao = (const struct nd_rpl_dao *)bp;
 727         const char *dagid_str = "<elided>";
 728
 729         ND_TCHECK(*dao);
 730         if (length < ND_RPL_DAO_MIN_LEN)
 731                 goto tooshort;
 732
 733         bp += ND_RPL_DAO_MIN_LEN;
 734         length -= ND_RPL_DAO_MIN_LEN;
 735         if(RPL_DAO_D(dao->rpl_flags)) {
 736                 ND_TCHECK2(dao->rpl_dagid, DAGID_LEN);
 737                 if (length < DAGID_LEN)
 738                         goto tooshort;
 739                 dagid_str = ip6addr_string (ndo, dao->rpl_dagid);
 740                 bp += DAGID_LEN;
 741                 length -= DAGID_LEN;
 742         }
 743
 744         ND_PRINT((ndo, " [dagid:%s,seq:%u,instance:%u%s%s,%02x]",
 745                   dagid_str,
 746                   dao->rpl_daoseq,
 747                   dao->rpl_instanceid,
 748                   RPL_DAO_K(dao->rpl_flags) ? ",acK":"",
 749                   RPL_DAO_D(dao->rpl_flags) ? ",Dagid":"",
 750                   dao->rpl_flags));
 751
 752         if(ndo->ndo_vflag > 1) {
 753                 const struct rpl_dio_genoption *opt = (const struct rpl_dio_genoption *)bp;
 754                 rpl_dio_printopt(ndo, opt, length);
 755         }
 756         return;
 757
 758 trunc:
 759         ND_PRINT((ndo," [|truncated]"));
 760         return;
 761
 762 tooshort:
 763         ND_PRINT((ndo," [|length too short]"));
 764         return;
 765 }
 766
 767 static void
 768 rpl_daoack_print(netdissect_options *ndo,
 769                  const u_char *bp, u_int length)
 770 {
 771         const struct nd_rpl_daoack *daoack = (const struct nd_rpl_daoack *)bp;
 772         const char *dagid_str = "<elided>";
 773
 774         ND_TCHECK2(*daoack, ND_RPL_DAOACK_MIN_LEN);
 775         if (length < ND_RPL_DAOACK_MIN_LEN)
 776                 goto tooshort;
 777
 778         bp += ND_RPL_DAOACK_MIN_LEN;
 779         length -= ND_RPL_DAOACK_MIN_LEN;
 780         if(RPL_DAOACK_D(daoack->rpl_flags)) {
 781                 ND_TCHECK2(daoack->rpl_dagid, DAGID_LEN);
 782                 if (length < DAGID_LEN)
 783                         goto tooshort;
 784                 dagid_str = ip6addr_string (ndo, daoack->rpl_dagid);
 785                 bp += DAGID_LEN;
 786                 length -= DAGID_LEN;
 787         }
 788
 789         ND_PRINT((ndo, " [dagid:%s,seq:%u,instance:%u,status:%u]",
 790                   dagid_str,
 791                   daoack->rpl_daoseq,
 792                   daoack->rpl_instanceid,
 793                   daoack->rpl_status));
 794
 795         /* no officially defined options for DAOACK, but print any we find */
 796         if(ndo->ndo_vflag > 1) {
 797                 const struct rpl_dio_genoption *opt = (const struct rpl_dio_genoption *)bp;
 798                 rpl_dio_printopt(ndo, opt, length);
 799         }
 800         return;
 801
 802 trunc:
 803         ND_PRINT((ndo," [|dao-truncated]"));
 804         return;
 805
 806 tooshort:
 807         ND_PRINT((ndo," [|dao-length too short]"));
 808         return;
 809 }
 810
 811 static void
 812 rpl_print(netdissect_options *ndo,
 813           const struct icmp6_hdr *hdr,
 814           const u_char *bp, u_int length)
 815 {
 816         int secured = hdr->icmp6_code & 0x80;
 817         int basecode= hdr->icmp6_code & 0x7f;
 818
 819         if(secured) {
 820                 ND_PRINT((ndo, ", (SEC) [worktodo]"));
 821                 /* XXX
 822                  * the next header pointer needs to move forward to
 823                  * skip the secure part.
 824                  */
 825                 return;
 826         } else {
 827                 ND_PRINT((ndo, ", (CLR)"));
 828         }
 829
 830         switch(basecode) {
 831         case ND_RPL_DAG_IS:
 832                 ND_PRINT((ndo, "DODAG Information Solicitation"));
 833                 if(ndo->ndo_vflag) {
 834                 }
 835                 break;
 836         case ND_RPL_DAG_IO:
 837                 ND_PRINT((ndo, "DODAG Information Object"));
 838                 if(ndo->ndo_vflag) {
 839                         rpl_dio_print(ndo, bp, length);
 840                 }
 841                 break;
 842         case ND_RPL_DAO:
 843                 ND_PRINT((ndo, "Destination Advertisement Object"));
 844                 if(ndo->ndo_vflag) {
 845                         rpl_dao_print(ndo, bp, length);
 846                 }
 847                 break;
 848         case ND_RPL_DAO_ACK:
 849                 ND_PRINT((ndo, "Destination Advertisement Object Ack"));
 850                 if(ndo->ndo_vflag) {
 851                         rpl_daoack_print(ndo, bp, length);
 852                 }
 853                 break;
 854         default:
 855                 ND_PRINT((ndo, "RPL message, unknown code %u",hdr->icmp6_code));
 856                 break;
 857         }
 858         return;
 859
 860 #if 0
 861 trunc:
 862         ND_PRINT((ndo," [|truncated]"));
 863         return;
 864 #endif
 865
 866 }
 867
 868
 869 void
 870 icmp6_print(netdissect_options *ndo,
 871             const u_char *bp, u_int length, const u_char *bp2, int fragmented)
 872 {
 873         const struct icmp6_hdr *dp;
 874         const struct ip6_hdr *ip;
 875         const struct ip6_hdr *oip;
 876         const struct udphdr *ouh;
 877         int dport;
 878         const u_char *ep;
 879         u_int prot;
 880
 881         dp = (const struct icmp6_hdr *)bp;
 882         ip = (const struct ip6_hdr *)bp2;
 883         oip = (const struct ip6_hdr *)(dp + 1);
 884         /* 'ep' points to the end of available data. */
 885         ep = ndo->ndo_snapend;
 886
 887         ND_TCHECK(dp->icmp6_cksum);
 888
 889         if (ndo->ndo_vflag && !fragmented) {
 890                 uint16_t sum, udp_sum;
 891
 892                 if (ND_TTEST2(bp[0], length)) {
 893                         udp_sum = EXTRACT_16BITS(&dp->icmp6_cksum);
 894                         sum = icmp6_cksum(ndo, ip, dp, length);
 895                         if (sum != 0)
 896                                 ND_PRINT((ndo,"[bad icmp6 cksum 0x%04x -> 0x%04x!] ",
 897                                                 udp_sum,
 898                                                 in_cksum_shouldbe(udp_sum, sum)));
 899                         else
 900                                 ND_PRINT((ndo,"[icmp6 sum ok] "));
 901                 }
 902         }
 903
 904         ND_PRINT((ndo,"ICMP6, %s", tok2str(icmp6_type_values,"unknown icmp6 type (%u)",dp->icmp6_type)));
 905
 906         /* display cosmetics: print the packet length for printer that use the vflag now */
 907         if (ndo->ndo_vflag && (dp->icmp6_type == ND_ROUTER_SOLICIT ||
 908                       dp->icmp6_type == ND_ROUTER_ADVERT ||
 909                       dp->icmp6_type == ND_NEIGHBOR_ADVERT ||
 910                       dp->icmp6_type == ND_NEIGHBOR_SOLICIT ||
 911                       dp->icmp6_type == ND_REDIRECT ||
 912                       dp->icmp6_type == ICMP6_HADISCOV_REPLY ||
 913                       dp->icmp6_type == ICMP6_MOBILEPREFIX_ADVERT ))
 914                 ND_PRINT((ndo,", length %u", length));
 915
 916         switch (dp->icmp6_type) {
 917         case ICMP6_DST_UNREACH:
 918                 ND_TCHECK(oip->ip6_dst);
 919                 ND_PRINT((ndo,", %s", tok2str(icmp6_dst_unreach_code_values,"unknown unreach code (%u)",dp->icmp6_code)));
 920                 switch (dp->icmp6_code) {
 921
 922                 case ICMP6_DST_UNREACH_NOROUTE: /* fall through */
 923                 case ICMP6_DST_UNREACH_ADMIN:
 924                 case ICMP6_DST_UNREACH_ADDR:
 925                         ND_PRINT((ndo," %s",ip6addr_string(ndo, &oip->ip6_dst)));
 926                         break;
 927                 case ICMP6_DST_UNREACH_BEYONDSCOPE:
 928                         ND_PRINT((ndo," %s, source address %s",
 929                                ip6addr_string(ndo, &oip->ip6_dst),
 930                                   ip6addr_string(ndo, &oip->ip6_src)));
 931                         break;
 932                 case ICMP6_DST_UNREACH_NOPORT:
 933                         if ((ouh = get_upperlayer(ndo, (const u_char *)oip, &prot))
 934                             == NULL)
 935                                 goto trunc;
 936
 937                         dport = EXTRACT_16BITS(&ouh->uh_dport);
 938                         switch (prot) {
 939                         case IPPROTO_TCP:
 940                                 ND_PRINT((ndo,", %s tcp port %s",
 941                                         ip6addr_string(ndo, &oip->ip6_dst),
 942                                           tcpport_string(ndo, dport)));
 943                                 break;
 944                         case IPPROTO_UDP:
 945                                 ND_PRINT((ndo,", %s udp port %s",
 946                                         ip6addr_string(ndo, &oip->ip6_dst),
 947                                           udpport_string(ndo, dport)));
 948                                 break;
 949                         default:
 950                                 ND_PRINT((ndo,", %s protocol %d port %d unreachable",
 951                                         ip6addr_string(ndo, &oip->ip6_dst),
 952                                           oip->ip6_nxt, dport));
 953                                 break;
 954                         }
 955                         break;
 956                 default:
 957                   if (ndo->ndo_vflag <= 1) {
 958                     print_unknown_data(ndo, bp,"\n\t",length);
 959                     return;
 960                   }
 961                     break;
 962                 }
 963                 break;
 964         case ICMP6_PACKET_TOO_BIG:
 965                 ND_TCHECK(dp->icmp6_mtu);
 966                 ND_PRINT((ndo,", mtu %u", EXTRACT_32BITS(&dp->icmp6_mtu)));
 967                 break;
 968         case ICMP6_TIME_EXCEEDED:
 969                 ND_TCHECK(oip->ip6_dst);
 970                 switch (dp->icmp6_code) {
 971                 case ICMP6_TIME_EXCEED_TRANSIT:
 972                         ND_PRINT((ndo," for %s",
 973                                   ip6addr_string(ndo, &oip->ip6_dst)));
 974                         break;
 975                 case ICMP6_TIME_EXCEED_REASSEMBLY:
 976                         ND_PRINT((ndo," (reassembly)"));
 977                         break;
 978                 default:
 979                         ND_PRINT((ndo,", unknown code (%u)", dp->icmp6_code));
 980                         break;
 981                 }
 982                 break;
 983         case ICMP6_PARAM_PROB:
 984                 ND_TCHECK(oip->ip6_dst);
 985                 switch (dp->icmp6_code) {
 986                 case ICMP6_PARAMPROB_HEADER:
 987                         ND_PRINT((ndo,", erroneous - octet %u", EXTRACT_32BITS(&dp->icmp6_pptr)));
 988                         break;
 989                 case ICMP6_PARAMPROB_NEXTHEADER:
 990                         ND_PRINT((ndo,", next header - octet %u", EXTRACT_32BITS(&dp->icmp6_pptr)));
 991                         break;
 992                 case ICMP6_PARAMPROB_OPTION:
 993                         ND_PRINT((ndo,", option - octet %u", EXTRACT_32BITS(&dp->icmp6_pptr)));
 994                         break;
 995                 default:
 996                         ND_PRINT((ndo,", code-#%d",
 997                                   dp->icmp6_code));
 998                         break;
 999                 }
1000                 break;
1001         case ICMP6_ECHO_REQUEST:
1002         case ICMP6_ECHO_REPLY:
1003                 ND_TCHECK(dp->icmp6_seq);
1004                 ND_PRINT((ndo,", seq %u", EXTRACT_16BITS(&dp->icmp6_seq)));
1005                 break;
1006         case ICMP6_MEMBERSHIP_QUERY:
1007                 if (length == MLD_MINLEN) {
1008                         mld6_print(ndo, (const u_char *)dp);
1009                 } else if (length >= MLDV2_MINLEN) {
1010                         ND_PRINT((ndo," v2"));
1011                         mldv2_query_print(ndo, (const u_char *)dp, length);
1012                 } else {
1013                         ND_PRINT((ndo," unknown-version (len %u) ", length));
1014                 }
1015                 break;
1016         case ICMP6_MEMBERSHIP_REPORT:
1017                 mld6_print(ndo, (const u_char *)dp);
1018                 break;
1019         case ICMP6_MEMBERSHIP_REDUCTION:
1020                 mld6_print(ndo, (const u_char *)dp);
1021                 break;
1022         case ND_ROUTER_SOLICIT:
1023 #define RTSOLLEN 8
1024                 if (ndo->ndo_vflag) {
1025                         icmp6_opt_print(ndo, (const u_char *)dp + RTSOLLEN,
1026                                         length - RTSOLLEN);
1027                 }
1028                 break;
1029         case ND_ROUTER_ADVERT:
1030 #define RTADVLEN 16
1031                 if (ndo->ndo_vflag) {
1032                         const struct nd_router_advert *p;
1033
1034                         p = (const struct nd_router_advert *)dp;
1035                         ND_TCHECK(p->nd_ra_retransmit);
1036                         ND_PRINT((ndo,"\n\thop limit %u, Flags [%s]" \
1037                                   ", pref %s, router lifetime %us, reachable time %us, retrans time %us",
1038                                   (u_int)p->nd_ra_curhoplimit,
1039                                   bittok2str(icmp6_opt_ra_flag_values,"none",(p->nd_ra_flags_reserved)),
1040                                   get_rtpref(p->nd_ra_flags_reserved),
1041                                   EXTRACT_16BITS(&p->nd_ra_router_lifetime),
1042                                   EXTRACT_32BITS(&p->nd_ra_reachable),
1043                                   EXTRACT_32BITS(&p->nd_ra_retransmit)));
1044
1045                         icmp6_opt_print(ndo, (const u_char *)dp + RTADVLEN,
1046                                         length - RTADVLEN);
1047                 }
1048                 break;
1049         case ND_NEIGHBOR_SOLICIT:
1050             {
1051                 const struct nd_neighbor_solicit *p;
1052                 p = (const struct nd_neighbor_solicit *)dp;
1053                 ND_TCHECK(p->nd_ns_target);
1054                 ND_PRINT((ndo,", who has %s", ip6addr_string(ndo, &p->nd_ns_target)));
1055                 if (ndo->ndo_vflag) {
1056 #define NDSOLLEN 24
1057                         icmp6_opt_print(ndo, (const u_char *)dp + NDSOLLEN,
1058                                         length - NDSOLLEN);
1059                 }
1060             }
1061                 break;
1062         case ND_NEIGHBOR_ADVERT:
1063             {
1064                 const struct nd_neighbor_advert *p;
1065
1066                 p = (const struct nd_neighbor_advert *)dp;
1067                 ND_TCHECK(p->nd_na_target);
1068                 ND_PRINT((ndo,", tgt is %s",
1069                           ip6addr_string(ndo, &p->nd_na_target)));
1070                 if (ndo->ndo_vflag) {
1071                         ND_PRINT((ndo,", Flags [%s]",
1072                                   bittok2str(icmp6_nd_na_flag_values,
1073                                              "none",
1074                                              EXTRACT_32BITS(&p->nd_na_flags_reserved))));
1075 #define NDADVLEN 24
1076                         icmp6_opt_print(ndo, (const u_char *)dp + NDADVLEN,
1077                                         length - NDADVLEN);
1078 #undef NDADVLEN
1079                 }
1080             }
1081                 break;
1082         case ND_REDIRECT:
1083 #define RDR(i) ((const struct nd_redirect *)(i))
1084                          ND_TCHECK(RDR(dp)->nd_rd_dst);
1085                          ND_PRINT((ndo,", %s", ip6addr_string(ndo, &RDR(dp)->nd_rd_dst)));
1086                 ND_TCHECK(RDR(dp)->nd_rd_target);
1087                 ND_PRINT((ndo," to %s",
1088                           ip6addr_string(ndo, &RDR(dp)->nd_rd_target)));
1089 #define REDIRECTLEN 40
1090                 if (ndo->ndo_vflag) {
1091                         icmp6_opt_print(ndo, (const u_char *)dp + REDIRECTLEN,
1092                                         length - REDIRECTLEN);
1093                 }
1094                 break;
1095 #undef REDIRECTLEN
1096 #undef RDR
1097         case ICMP6_ROUTER_RENUMBERING:
1098                 icmp6_rrenum_print(ndo, bp, ep);
1099                 break;
1100         case ICMP6_NI_QUERY:
1101         case ICMP6_NI_REPLY:
1102                 icmp6_nodeinfo_print(ndo, length, bp, ep);
1103                 break;
1104         case IND_SOLICIT:
1105         case IND_ADVERT:
1106                 break;
1107         case ICMP6_V2_MEMBERSHIP_REPORT:
1108                 mldv2_report_print(ndo, (const u_char *) dp, length);
1109                 break;
1110         case ICMP6_MOBILEPREFIX_SOLICIT: /* fall through */
1111         case ICMP6_HADISCOV_REQUEST:
1112                 ND_TCHECK(dp->icmp6_data16[0]);
1113                 ND_PRINT((ndo,", id 0x%04x", EXTRACT_16BITS(&dp->icmp6_data16[0])));
1114                 break;
1115         case ICMP6_HADISCOV_REPLY:
1116                 if (ndo->ndo_vflag) {
1117                         const struct in6_addr *in6;
1118                         const u_char *cp;
1119
1120                         ND_TCHECK(dp->icmp6_data16[0]);
1121                         ND_PRINT((ndo,", id 0x%04x", EXTRACT_16BITS(&dp->icmp6_data16[0])));
1122                         cp = (const u_char *)dp + length;
1123                         in6 = (const struct in6_addr *)(dp + 1);
1124                         for (; (const u_char *)in6 < cp; in6++) {
1125                                 ND_TCHECK(*in6);
1126                                 ND_PRINT((ndo,", %s", ip6addr_string(ndo, in6)));
1127                         }
1128                 }
1129                 break;
1130         case ICMP6_MOBILEPREFIX_ADVERT:
1131                 if (ndo->ndo_vflag) {
1132                         ND_TCHECK(dp->icmp6_data16[0]);
1133                         ND_PRINT((ndo,", id 0x%04x", EXTRACT_16BITS(&dp->icmp6_data16[0])));
1134                         if (dp->icmp6_data16[1] & 0xc0)
1135                                 ND_PRINT((ndo," "));
1136                         if (dp->icmp6_data16[1] & 0x80)
1137                                 ND_PRINT((ndo,"M"));
1138                         if (dp->icmp6_data16[1] & 0x40)
1139                                 ND_PRINT((ndo,"O"));
1140 #define MPADVLEN 8
1141                         icmp6_opt_print(ndo, (const u_char *)dp + MPADVLEN,
1142                                         length - MPADVLEN);
1143                 }
1144                 break;
1145         case ND_RPL_MESSAGE:
1146                 /* plus 4, because struct icmp6_hdr contains 4 bytes of icmp payload */
1147                 rpl_print(ndo, dp, &dp->icmp6_data8[0], length-sizeof(struct icmp6_hdr)+4);
1148                 break;
1149         default:
1150                 ND_PRINT((ndo,", length %u", length));
1151                 if (ndo->ndo_vflag <= 1)
1152                         print_unknown_data(ndo, bp,"\n\t", length);
1153                 return;
1154         }
1155         if (!ndo->ndo_vflag)
1156                 ND_PRINT((ndo,", length %u", length));
1157         return;
1158 trunc:
1159         ND_PRINT((ndo, "[|icmp6]"));
1160 }
1161
1162 static const struct udphdr *
1163 get_upperlayer(netdissect_options *ndo, const u_char *bp, u_int *prot)
1164 {
1165         const u_char *ep;
1166         const struct ip6_hdr *ip6 = (const struct ip6_hdr *)bp;
1167         const struct udphdr *uh;
1168         const struct ip6_hbh *hbh;
1169         const struct ip6_frag *fragh;
1170         const struct ah *ah;
1171         u_int nh;
1172         int hlen;
1173
1174         /* 'ep' points to the end of available data. */
1175         ep = ndo->ndo_snapend;
1176
1177         if (!ND_TTEST(ip6->ip6_nxt))
1178                 return NULL;
1179
1180         nh = ip6->ip6_nxt;
1181         hlen = sizeof(struct ip6_hdr);
1182
1183         while (bp < ep) {
1184                 bp += hlen;
1185
1186                 switch(nh) {
1187                 case IPPROTO_UDP:
1188                 case IPPROTO_TCP:
1189                         uh = (const struct udphdr *)bp;
1190                         if (ND_TTEST(uh->uh_dport)) {
1191                                 *prot = nh;
1192                                 return(uh);
1193                         }
1194                         else
1195                                 return(NULL);
1196                         /* NOTREACHED */
1197
1198                 case IPPROTO_HOPOPTS:
1199                 case IPPROTO_DSTOPTS:
1200                 case IPPROTO_ROUTING:
1201                         hbh = (const struct ip6_hbh *)bp;
1202                         if (!ND_TTEST(hbh->ip6h_len))
1203                                 return(NULL);
1204                         nh = hbh->ip6h_nxt;
1205                         hlen = (hbh->ip6h_len + 1) << 3;
1206                         break;
1207
1208                 case IPPROTO_FRAGMENT: /* this should be odd, but try anyway */
1209                         fragh = (const struct ip6_frag *)bp;
1210                         if (!ND_TTEST(fragh->ip6f_offlg))
1211                                 return(NULL);
1212                         /* fragments with non-zero offset are meaningless */
1213                         if ((EXTRACT_16BITS(&fragh->ip6f_offlg) & IP6F_OFF_MASK) != 0)
1214                                 return(NULL);
1215                         nh = fragh->ip6f_nxt;
1216                         hlen = sizeof(struct ip6_frag);
1217                         break;
1218
1219                 case IPPROTO_AH:
1220                         ah = (const struct ah *)bp;
1221                         if (!ND_TTEST(ah->ah_len))
1222                                 return(NULL);
1223                         nh = ah->ah_nxt;
1224                         hlen = (ah->ah_len + 2) << 2;
1225                         break;
1226
1227                 default:        /* unknown or undecodable header */
1228                         *prot = nh; /* meaningless, but set here anyway */
1229                         return(NULL);
1230                 }
1231         }
1232
1233         return(NULL);           /* should be notreached, though */
1234 }
1235
1236 static void
1237 icmp6_opt_print(netdissect_options *ndo, const u_char *bp, int resid)
1238 {
1239         const struct nd_opt_hdr *op;
1240         const struct nd_opt_prefix_info *opp;
1241         const struct nd_opt_mtu *opm;
1242         const struct nd_opt_rdnss *oprd;
1243         const struct nd_opt_dnssl *opds;
1244         const struct nd_opt_advinterval *opa;
1245         const struct nd_opt_homeagent_info *oph;
1246         const struct nd_opt_route_info *opri;
1247         const u_char *cp, *ep, *domp;
1248         struct in6_addr in6;
1249         const struct in6_addr *in6p;
1250         size_t l;
1251         u_int i;
1252
1253 #define ECHECK(var) if ((const u_char *)&(var) > ep - sizeof(var)) return
1254
1255         cp = bp;
1256         /* 'ep' points to the end of available data. */
1257         ep = ndo->ndo_snapend;
1258
1259         while (cp < ep) {
1260                 op = (const struct nd_opt_hdr *)cp;
1261
1262                 ECHECK(op->nd_opt_len);
1263                 if (resid <= 0)
1264                         return;
1265                 if (op->nd_opt_len == 0)
1266                         goto trunc;
1267                 if (cp + (op->nd_opt_len << 3) > ep)
1268                         goto trunc;
1269
1270                 ND_PRINT((ndo,"\n\t  %s option (%u), length %u (%u): ",
1271                           tok2str(icmp6_opt_values, "unknown", op->nd_opt_type),
1272                           op->nd_opt_type,
1273                           op->nd_opt_len << 3,
1274                           op->nd_opt_len));
1275
1276                 switch (op->nd_opt_type) {
1277                 case ND_OPT_SOURCE_LINKADDR:
1278                         l = (op->nd_opt_len << 3) - 2;
1279                         print_lladdr(ndo, cp + 2, l);
1280                         break;
1281                 case ND_OPT_TARGET_LINKADDR:
1282                         l = (op->nd_opt_len << 3) - 2;
1283                         print_lladdr(ndo, cp + 2, l);
1284                         break;
1285                 case ND_OPT_PREFIX_INFORMATION:
1286                         opp = (const struct nd_opt_prefix_info *)op;
1287                         ND_TCHECK(opp->nd_opt_pi_prefix);
1288                         ND_PRINT((ndo,"%s/%u%s, Flags [%s], valid time %s",
1289                                   ip6addr_string(ndo, &opp->nd_opt_pi_prefix),
1290                                   opp->nd_opt_pi_prefix_len,
1291                                   (op->nd_opt_len != 4) ? "badlen" : "",
1292                                   bittok2str(icmp6_opt_pi_flag_values, "none", opp->nd_opt_pi_flags_reserved),
1293                                   get_lifetime(EXTRACT_32BITS(&opp->nd_opt_pi_valid_time))));
1294                         ND_PRINT((ndo,", pref. time %s", get_lifetime(EXTRACT_32BITS(&opp->nd_opt_pi_preferred_time))));
1295                         break;
1296                 case ND_OPT_REDIRECTED_HEADER:
1297                         print_unknown_data(ndo, bp,"\n\t    ",op->nd_opt_len<<3);
1298                         /* xxx */
1299                         break;
1300                 case ND_OPT_MTU:
1301                         opm = (const struct nd_opt_mtu *)op;
1302                         ND_TCHECK(opm->nd_opt_mtu_mtu);
1303                         ND_PRINT((ndo," %u%s",
1304                                EXTRACT_32BITS(&opm->nd_opt_mtu_mtu),
1305                                   (op->nd_opt_len != 1) ? "bad option length" : "" ));
1306                         break;
1307                 case ND_OPT_RDNSS:
1308                         oprd = (const struct nd_opt_rdnss *)op;
1309                         l = (op->nd_opt_len - 1) / 2;
1310                         ND_PRINT((ndo," lifetime %us,",
1311                                   EXTRACT_32BITS(&oprd->nd_opt_rdnss_lifetime)));
1312                         for (i = 0; i < l; i++) {
1313                                 ND_TCHECK(oprd->nd_opt_rdnss_addr[i]);
1314                                 ND_PRINT((ndo," addr: %s",
1315                                           ip6addr_string(ndo, &oprd->nd_opt_rdnss_addr[i])));
1316                         }
1317                         break;
1318                 case ND_OPT_DNSSL:
1319                         opds = (const struct nd_opt_dnssl *)op;
1320                         ND_PRINT((ndo," lifetime %us, domain(s):",
1321                                   EXTRACT_32BITS(&opds->nd_opt_dnssl_lifetime)));
1322                         domp = cp + 8; /* domain names, variable-sized, RFC1035-encoded */
1323                         while (domp < cp + (op->nd_opt_len << 3) && *domp != '\0')
1324                         {
1325                                 ND_PRINT((ndo, " "));
1326                                 if ((domp = ns_nprint (ndo, domp, bp)) == NULL)
1327                                         goto trunc;
1328                         }
1329                         break;
1330                 case ND_OPT_ADVINTERVAL:
1331                         opa = (const struct nd_opt_advinterval *)op;
1332                         ND_TCHECK(opa->nd_opt_adv_interval);
1333                         ND_PRINT((ndo," %ums", EXTRACT_32BITS(&opa->nd_opt_adv_interval)));
1334                         break;
1335                 case ND_OPT_HOMEAGENT_INFO:
1336                         oph = (const struct nd_opt_homeagent_info *)op;
1337                         ND_TCHECK(oph->nd_opt_hai_lifetime);
1338                         ND_PRINT((ndo," preference %u, lifetime %u",
1339                                   EXTRACT_16BITS(&oph->nd_opt_hai_preference),
1340                                   EXTRACT_16BITS(&oph->nd_opt_hai_lifetime)));
1341                         break;
1342                 case ND_OPT_ROUTE_INFO:
1343                         opri = (const struct nd_opt_route_info *)op;
1344                         ND_TCHECK(opri->nd_opt_rti_lifetime);
1345                         memset(&in6, 0, sizeof(in6));
1346                         in6p = (const struct in6_addr *)(opri + 1);
1347                         switch (op->nd_opt_len) {
1348                         case 1:
1349                                 break;
1350                         case 2:
1351                                 ND_TCHECK2(*in6p, 8);
1352                                 memcpy(&in6, opri + 1, 8);
1353                                 break;
1354                         case 3:
1355                                 ND_TCHECK(*in6p);
1356                                 memcpy(&in6, opri + 1, sizeof(in6));
1357                                 break;
1358                         default:
1359                                 goto trunc;
1360                         }
1361                         ND_PRINT((ndo," %s/%u", ip6addr_string(ndo, &in6),
1362                                   opri->nd_opt_rti_prefixlen));
1363                         ND_PRINT((ndo,", pref=%s", get_rtpref(opri->nd_opt_rti_flags)));
1364                         ND_PRINT((ndo,", lifetime=%s",
1365                                   get_lifetime(EXTRACT_32BITS(&opri->nd_opt_rti_lifetime))));
1366                         break;
1367                 default:
1368                         if (ndo->ndo_vflag <= 1) {
1369                                 print_unknown_data(ndo,cp+2,"\n\t  ", (op->nd_opt_len << 3) - 2); /* skip option header */
1370                             return;
1371                         }
1372                         break;
1373                 }
1374                 /* do we want to see an additional hexdump ? */
1375                 if (ndo->ndo_vflag> 1)
1376                         print_unknown_data(ndo, cp+2,"\n\t    ", (op->nd_opt_len << 3) - 2); /* skip option header */
1377
1378                 cp += op->nd_opt_len << 3;
1379                 resid -= op->nd_opt_len << 3;
1380         }
1381         return;
1382
1383  trunc:
1384         ND_PRINT((ndo, "[ndp opt]"));
1385         return;
1386 #undef ECHECK
1387 }
1388
1389 static void
1390 mld6_print(netdissect_options *ndo, const u_char *bp)
1391 {
1392         const struct mld6_hdr *mp = (const struct mld6_hdr *)bp;
1393         const u_char *ep;
1394
1395         /* 'ep' points to the end of available data. */
1396         ep = ndo->ndo_snapend;
1397
1398         if ((const u_char *)mp + sizeof(*mp) > ep)
1399                 return;
1400
1401         ND_PRINT((ndo,"max resp delay: %d ", EXTRACT_16BITS(&mp->mld6_maxdelay)));
1402         ND_PRINT((ndo,"addr: %s", ip6addr_string(ndo, &mp->mld6_addr)));
1403 }
1404
1405 static void
1406 mldv2_report_print(netdissect_options *ndo, const u_char *bp, u_int len)
1407 {
1408     const struct icmp6_hdr *icp = (const struct icmp6_hdr *) bp;
1409     u_int group, nsrcs, ngroups;
1410     u_int i, j;
1411
1412     /* Minimum len is 8 */
1413     if (len < 8) {
1414             ND_PRINT((ndo," [invalid len %d]", len));
1415             return;
1416     }
1417
1418     ND_TCHECK(icp->icmp6_data16[1]);
1419     ngroups = EXTRACT_16BITS(&icp->icmp6_data16[1]);
1420     ND_PRINT((ndo,", %d group record(s)", ngroups));
1421     if (ndo->ndo_vflag > 0) {
1422         /* Print the group records */
1423         group = 8;
1424         for (i = 0; i < ngroups; i++) {
1425             /* type(1) + auxlen(1) + numsrc(2) + grp(16) */
1426             if (len < group + 20) {
1427                     ND_PRINT((ndo," [invalid number of groups]"));
1428                     return;
1429             }
1430             ND_TCHECK2(bp[group + 4], sizeof(struct in6_addr));
1431             ND_PRINT((ndo," [gaddr %s", ip6addr_string(ndo, &bp[group + 4])));
1432             ND_PRINT((ndo," %s", tok2str(mldv2report2str, " [v2-report-#%d]",
1433                                          bp[group])));
1434             nsrcs = (bp[group + 2] << 8) + bp[group + 3];
1435             /* Check the number of sources and print them */
1436             if (len < group + 20 + (nsrcs * sizeof(struct in6_addr))) {
1437                     ND_PRINT((ndo," [invalid number of sources %d]", nsrcs));
1438                     return;
1439             }
1440             if (ndo->ndo_vflag == 1)
1441                     ND_PRINT((ndo,", %d source(s)", nsrcs));
1442             else {
1443                 /* Print the sources */
1444                     ND_PRINT((ndo," {"));
1445                 for (j = 0; j < nsrcs; j++) {
1446                     ND_TCHECK2(bp[group + 20 + j * sizeof(struct in6_addr)],
1447                             sizeof(struct in6_addr));
1448                     ND_PRINT((ndo," %s", ip6addr_string(ndo, &bp[group + 20 + j * sizeof(struct in6_addr)])));
1449                 }
1450                 ND_PRINT((ndo," }"));
1451             }
1452             /* Next group record */
1453             group += 20 + nsrcs * sizeof(struct in6_addr);
1454             ND_PRINT((ndo,"]"));
1455         }
1456     }
1457     return;
1458 trunc:
1459     ND_PRINT((ndo,"[|icmp6]"));
1460     return;
1461 }
1462
1463 static void
1464 mldv2_query_print(netdissect_options *ndo, const u_char *bp, u_int len)
1465 {
1466     const struct icmp6_hdr *icp = (const struct icmp6_hdr *) bp;
1467     u_int mrc;
1468     int mrt, qqi;
1469     u_int nsrcs;
1470     register u_int i;
1471
1472     /* Minimum len is 28 */
1473     if (len < 28) {
1474             ND_PRINT((ndo," [invalid len %d]", len));
1475         return;
1476     }
1477     ND_TCHECK(icp->icmp6_data16[0]);
1478     mrc = EXTRACT_16BITS(&icp->icmp6_data16[0]);
1479     if (mrc < 32768) {
1480         mrt = mrc;
1481     } else {
1482         mrt = ((mrc & 0x0fff) | 0x1000) << (((mrc & 0x7000) >> 12) + 3);
1483     }
1484     if (ndo->ndo_vflag) {
1485             ND_PRINT((ndo," [max resp delay=%d]", mrt));
1486     }
1487     ND_TCHECK2(bp[8], sizeof(struct in6_addr));
1488     ND_PRINT((ndo," [gaddr %s", ip6addr_string(ndo, &bp[8])));
1489
1490     if (ndo->ndo_vflag) {
1491         ND_TCHECK(bp[25]);
1492         if (bp[24] & 0x08) {
1493                 ND_PRINT((ndo," sflag"));
1494         }
1495         if (bp[24] & 0x07) {
1496                 ND_PRINT((ndo," robustness=%d", bp[24] & 0x07));
1497         }
1498         if (bp[25] < 128) {
1499                 qqi = bp[25];
1500         } else {
1501                 qqi = ((bp[25] & 0x0f) | 0x10) << (((bp[25] & 0x70) >> 4) + 3);
1502         }
1503         ND_PRINT((ndo," qqi=%d", qqi));
1504     }
1505
1506     ND_TCHECK2(bp[26], 2);
1507     nsrcs = EXTRACT_16BITS(&bp[26]);
1508     if (nsrcs > 0) {
1509         if (len < 28 + nsrcs * sizeof(struct in6_addr))
1510             ND_PRINT((ndo," [invalid number of sources]"));
1511         else if (ndo->ndo_vflag > 1) {
1512             ND_PRINT((ndo," {"));
1513             for (i = 0; i < nsrcs; i++) {
1514                 ND_TCHECK2(bp[28 + i * sizeof(struct in6_addr)],
1515                         sizeof(struct in6_addr));
1516                 ND_PRINT((ndo," %s", ip6addr_string(ndo, &bp[28 + i * sizeof(struct in6_addr)])));
1517             }
1518             ND_PRINT((ndo," }"));
1519         } else
1520                 ND_PRINT((ndo,", %d source(s)", nsrcs));
1521     }
1522     ND_PRINT((ndo,"]"));
1523     return;
1524 trunc:
1525     ND_PRINT((ndo,"[|icmp6]"));
1526     return;
1527 }
1528
1529 static void
1530 dnsname_print(netdissect_options *ndo, const u_char *cp, const u_char *ep)
1531 {
1532         int i;
1533
1534         /* DNS name decoding - no decompression */
1535         ND_PRINT((ndo,", \""));
1536         while (cp < ep) {
1537                 i = *cp++;
1538                 if (i) {
1539                         if (i > ep - cp) {
1540                                 ND_PRINT((ndo,"???"));
1541                                 break;
1542                         }
1543                         while (i-- && cp < ep) {
1544                                 safeputchar(ndo, *cp);
1545                                 cp++;
1546                         }
1547                         if (cp + 1 < ep && *cp)
1548                                 ND_PRINT((ndo,"."));
1549                 } else {
1550                         if (cp == ep) {
1551                                 /* FQDN */
1552                                 ND_PRINT((ndo,"."));
1553                         } else if (cp + 1 == ep && *cp == '\0') {
1554                                 /* truncated */
1555                         } else {
1556                                 /* invalid */
1557                                 ND_PRINT((ndo,"???"));
1558                         }
1559                         break;
1560                 }
1561         }
1562         ND_PRINT((ndo,"\""));
1563 }
1564
1565 static void
1566 icmp6_nodeinfo_print(netdissect_options *ndo, u_int icmp6len, const u_char *bp, const u_char *ep)
1567 {
1568         const struct icmp6_nodeinfo *ni6;
1569         const struct icmp6_hdr *dp;
1570         const u_char *cp;
1571         size_t siz, i;
1572         int needcomma;
1573
1574         if (ep < bp)
1575                 return;
1576         dp = (const struct icmp6_hdr *)bp;
1577         ni6 = (const struct icmp6_nodeinfo *)bp;
1578         siz = ep - bp;
1579
1580         switch (ni6->ni_type) {
1581         case ICMP6_NI_QUERY:
1582                 if (siz == sizeof(*dp) + 4) {
1583                         /* KAME who-are-you */
1584                         ND_PRINT((ndo," who-are-you request"));
1585                         break;
1586                 }
1587                 ND_PRINT((ndo," node information query"));
1588
1589                 ND_TCHECK2(*dp, sizeof(*ni6));
1590                 ni6 = (const struct icmp6_nodeinfo *)dp;
1591                 ND_PRINT((ndo," ("));   /*)*/
1592                 switch (EXTRACT_16BITS(&ni6->ni_qtype)) {
1593                 case NI_QTYPE_NOOP:
1594                         ND_PRINT((ndo,"noop"));
1595                         break;
1596                 case NI_QTYPE_SUPTYPES:
1597                         ND_PRINT((ndo,"supported qtypes"));
1598                         i = EXTRACT_16BITS(&ni6->ni_flags);
1599                         if (i)
1600                                 ND_PRINT((ndo," [%s]", (i & 0x01) ? "C" : ""));
1601                         break;
1602                 case NI_QTYPE_FQDN:
1603                         ND_PRINT((ndo,"DNS name"));
1604                         break;
1605                 case NI_QTYPE_NODEADDR:
1606                         ND_PRINT((ndo,"node addresses"));
1607                         i = ni6->ni_flags;
1608                         if (!i)
1609                                 break;
1610                         /* NI_NODEADDR_FLAG_TRUNCATE undefined for query */
1611                         ND_PRINT((ndo," [%s%s%s%s%s%s]",
1612                             (i & NI_NODEADDR_FLAG_ANYCAST) ? "a" : "",
1613                             (i & NI_NODEADDR_FLAG_GLOBAL) ? "G" : "",
1614                             (i & NI_NODEADDR_FLAG_SITELOCAL) ? "S" : "",
1615                             (i & NI_NODEADDR_FLAG_LINKLOCAL) ? "L" : "",
1616                             (i & NI_NODEADDR_FLAG_COMPAT) ? "C" : "",
1617                             (i & NI_NODEADDR_FLAG_ALL) ? "A" : ""));
1618                         break;
1619                 default:
1620                         ND_PRINT((ndo,"unknown"));
1621                         break;
1622                 }
1623
1624                 if (ni6->ni_qtype == NI_QTYPE_NOOP ||
1625                     ni6->ni_qtype == NI_QTYPE_SUPTYPES) {
1626                         if (siz != sizeof(*ni6))
1627                                 if (ndo->ndo_vflag)
1628                                         ND_PRINT((ndo,", invalid len"));
1629                         /*(*/
1630                         ND_PRINT((ndo,")"));
1631                         break;
1632                 }
1633
1634
1635                 /* XXX backward compat, icmp-name-lookup-03 */
1636                 if (siz == sizeof(*ni6)) {
1637                         ND_PRINT((ndo,", 03 draft"));
1638                         /*(*/
1639                         ND_PRINT((ndo,")"));
1640                         break;
1641                 }
1642
1643                 switch (ni6->ni_code) {
1644                 case ICMP6_NI_SUBJ_IPV6:
1645                         if (!ND_TTEST2(*dp,
1646                             sizeof(*ni6) + sizeof(struct in6_addr)))
1647                                 break;
1648                         if (siz != sizeof(*ni6) + sizeof(struct in6_addr)) {
1649                                 if (ndo->ndo_vflag)
1650                                         ND_PRINT((ndo,", invalid subject len"));
1651                                 break;
1652                         }
1653                         ND_PRINT((ndo,", subject=%s",
1654                                   ip6addr_string(ndo, ni6 + 1)));
1655                         break;
1656                 case ICMP6_NI_SUBJ_FQDN:
1657                         ND_PRINT((ndo,", subject=DNS name"));
1658                         cp = (const u_char *)(ni6 + 1);
1659                         if (cp[0] == ep - cp - 1) {
1660                                 /* icmp-name-lookup-03, pascal string */
1661                                 if (ndo->ndo_vflag)
1662                                         ND_PRINT((ndo,", 03 draft"));
1663                                 cp++;
1664                                 ND_PRINT((ndo,", \""));
1665                                 while (cp < ep) {
1666                                         safeputchar(ndo, *cp);
1667                                         cp++;
1668                                 }
1669                                 ND_PRINT((ndo,"\""));
1670                         } else
1671                                 dnsname_print(ndo, cp, ep);
1672                         break;
1673                 case ICMP6_NI_SUBJ_IPV4:
1674                         if (!ND_TTEST2(*dp, sizeof(*ni6) + sizeof(struct in_addr)))
1675                                 break;
1676                         if (siz != sizeof(*ni6) + sizeof(struct in_addr)) {
1677                                 if (ndo->ndo_vflag)
1678                                         ND_PRINT((ndo,", invalid subject len"));
1679                                 break;
1680                         }
1681                         ND_PRINT((ndo,", subject=%s",
1682                                   ipaddr_string(ndo, ni6 + 1)));
1683                         break;
1684                 default:
1685                         ND_PRINT((ndo,", unknown subject"));
1686                         break;
1687                 }
1688
1689                 /*(*/
1690                 ND_PRINT((ndo,")"));
1691                 break;
1692
1693         case ICMP6_NI_REPLY:
1694                 if (icmp6len > siz) {
1695                         ND_PRINT((ndo,"[|icmp6: node information reply]"));
1696                         break;
1697                 }
1698
1699                 needcomma = 0;
1700
1701                 ni6 = (const struct icmp6_nodeinfo *)dp;
1702                 ND_PRINT((ndo," node information reply"));
1703                 ND_PRINT((ndo," ("));   /*)*/
1704                 switch (ni6->ni_code) {
1705                 case ICMP6_NI_SUCCESS:
1706                         if (ndo->ndo_vflag) {
1707                                 ND_PRINT((ndo,"success"));
1708                                 needcomma++;
1709                         }
1710                         break;
1711                 case ICMP6_NI_REFUSED:
1712                         ND_PRINT((ndo,"refused"));
1713                         needcomma++;
1714                         if (siz != sizeof(*ni6))
1715                                 if (ndo->ndo_vflag)
1716                                         ND_PRINT((ndo,", invalid length"));
1717                         break;
1718                 case ICMP6_NI_UNKNOWN:
1719                         ND_PRINT((ndo,"unknown"));
1720                         needcomma++;
1721                         if (siz != sizeof(*ni6))
1722                                 if (ndo->ndo_vflag)
1723                                         ND_PRINT((ndo,", invalid length"));
1724                         break;
1725                 }
1726
1727                 if (ni6->ni_code != ICMP6_NI_SUCCESS) {
1728                         /*(*/
1729                         ND_PRINT((ndo,")"));
1730                         break;
1731                 }
1732
1733                 switch (EXTRACT_16BITS(&ni6->ni_qtype)) {
1734                 case NI_QTYPE_NOOP:
1735                         if (needcomma)
1736                                 ND_PRINT((ndo,", "));
1737                         ND_PRINT((ndo,"noop"));
1738                         if (siz != sizeof(*ni6))
1739                                 if (ndo->ndo_vflag)
1740                                         ND_PRINT((ndo,", invalid length"));
1741                         break;
1742                 case NI_QTYPE_SUPTYPES:
1743                         if (needcomma)
1744                                 ND_PRINT((ndo,", "));
1745                         ND_PRINT((ndo,"supported qtypes"));
1746                         i = EXTRACT_16BITS(&ni6->ni_flags);
1747                         if (i)
1748                                 ND_PRINT((ndo," [%s]", (i & 0x01) ? "C" : ""));
1749                         break;
1750                 case NI_QTYPE_FQDN:
1751                         if (needcomma)
1752                                 ND_PRINT((ndo,", "));
1753                         ND_PRINT((ndo,"DNS name"));
1754                         cp = (const u_char *)(ni6 + 1) + 4;
1755                         if (cp[0] == ep - cp - 1) {
1756                                 /* icmp-name-lookup-03, pascal string */
1757                                 if (ndo->ndo_vflag)
1758                                         ND_PRINT((ndo,", 03 draft"));
1759                                 cp++;
1760                                 ND_PRINT((ndo,", \""));
1761                                 while (cp < ep) {
1762                                         safeputchar(ndo, *cp);
1763                                         cp++;
1764                                 }
1765                                 ND_PRINT((ndo,"\""));
1766                         } else
1767                                 dnsname_print(ndo, cp, ep);
1768                         if ((EXTRACT_16BITS(&ni6->ni_flags) & 0x01) != 0)
1769                                 ND_PRINT((ndo," [TTL=%u]", EXTRACT_32BITS(ni6 + 1)));
1770                         break;
1771                 case NI_QTYPE_NODEADDR:
1772                         if (needcomma)
1773                                 ND_PRINT((ndo,", "));
1774                         ND_PRINT((ndo,"node addresses"));
1775                         i = sizeof(*ni6);
1776                         while (i < siz) {
1777                                 if (i + sizeof(struct in6_addr) + sizeof(int32_t) > siz)
1778                                         break;
1779                                 ND_PRINT((ndo," %s", ip6addr_string(ndo, bp + i)));
1780                                 i += sizeof(struct in6_addr);
1781                                 ND_PRINT((ndo,"(%d)", (int32_t)EXTRACT_32BITS(bp + i)));
1782                                 i += sizeof(int32_t);
1783                         }
1784                         i = ni6->ni_flags;
1785                         if (!i)
1786                                 break;
1787                         ND_PRINT((ndo," [%s%s%s%s%s%s%s]",
1788                                   (i & NI_NODEADDR_FLAG_ANYCAST) ? "a" : "",
1789                                   (i & NI_NODEADDR_FLAG_GLOBAL) ? "G" : "",
1790                                   (i & NI_NODEADDR_FLAG_SITELOCAL) ? "S" : "",
1791                                   (i & NI_NODEADDR_FLAG_LINKLOCAL) ? "L" : "",
1792                                   (i & NI_NODEADDR_FLAG_COMPAT) ? "C" : "",
1793                                   (i & NI_NODEADDR_FLAG_ALL) ? "A" : "",
1794                                   (i & NI_NODEADDR_FLAG_TRUNCATE) ? "T" : ""));
1795                         break;
1796                 default:
1797                         if (needcomma)
1798                                 ND_PRINT((ndo,", "));
1799                         ND_PRINT((ndo,"unknown"));
1800                         break;
1801                 }
1802
1803                 /*(*/
1804                 ND_PRINT((ndo,")"));
1805                 break;
1806         }
1807         return;
1808
1809 trunc:
1810         ND_PRINT((ndo, "[|icmp6]"));
1811 }
1812
1813 static void
1814 icmp6_rrenum_print(netdissect_options *ndo, const u_char *bp, const u_char *ep)
1815 {
1816         const struct icmp6_router_renum *rr6;
1817         const char *cp;
1818         const struct rr_pco_match *match;
1819         const struct rr_pco_use *use;
1820         char hbuf[NI_MAXHOST];
1821         int n;
1822
1823         if (ep < bp)
1824                 return;
1825         rr6 = (const struct icmp6_router_renum *)bp;
1826         cp = (const char *)(rr6 + 1);
1827
1828         ND_TCHECK(rr6->rr_reserved);
1829         switch (rr6->rr_code) {
1830         case ICMP6_ROUTER_RENUMBERING_COMMAND:
1831                 ND_PRINT((ndo,"router renum: command"));
1832                 break;
1833         case ICMP6_ROUTER_RENUMBERING_RESULT:
1834                 ND_PRINT((ndo,"router renum: result"));
1835                 break;
1836         case ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET:
1837                 ND_PRINT((ndo,"router renum: sequence number reset"));
1838                 break;
1839         default:
1840                 ND_PRINT((ndo,"router renum: code-#%d", rr6->rr_code));
1841                 break;
1842         }
1843
1844         ND_PRINT((ndo,", seq=%u", EXTRACT_32BITS(&rr6->rr_seqnum)));
1845
1846         if (ndo->ndo_vflag) {
1847 #define F(x, y) ((rr6->rr_flags) & (x) ? (y) : "")
1848                 ND_PRINT((ndo,"["));    /*]*/
1849                 if (rr6->rr_flags) {
1850                         ND_PRINT((ndo,"%s%s%s%s%s,", F(ICMP6_RR_FLAGS_TEST, "T"),
1851                                   F(ICMP6_RR_FLAGS_REQRESULT, "R"),
1852                                   F(ICMP6_RR_FLAGS_FORCEAPPLY, "A"),
1853                                   F(ICMP6_RR_FLAGS_SPECSITE, "S"),
1854                                   F(ICMP6_RR_FLAGS_PREVDONE, "P")));
1855                 }
1856                 ND_PRINT((ndo,"seg=%u,", rr6->rr_segnum));
1857                 ND_PRINT((ndo,"maxdelay=%u", EXTRACT_16BITS(&rr6->rr_maxdelay)));
1858                 if (rr6->rr_reserved)
1859                         ND_PRINT((ndo,"rsvd=0x%x", EXTRACT_32BITS(&rr6->rr_reserved)));
1860                 /*[*/
1861                 ND_PRINT((ndo,"]"));
1862 #undef F
1863         }
1864
1865         if (rr6->rr_code == ICMP6_ROUTER_RENUMBERING_COMMAND) {
1866                 match = (const struct rr_pco_match *)cp;
1867                 cp = (const char *)(match + 1);
1868
1869                 ND_TCHECK(match->rpm_prefix);
1870
1871                 if (ndo->ndo_vflag > 1)
1872                         ND_PRINT((ndo,"\n\t"));
1873                 else
1874                         ND_PRINT((ndo," "));
1875                 ND_PRINT((ndo,"match("));       /*)*/
1876                 switch (match->rpm_code) {
1877                 case RPM_PCO_ADD:       ND_PRINT((ndo,"add")); break;
1878                 case RPM_PCO_CHANGE:    ND_PRINT((ndo,"change")); break;
1879                 case RPM_PCO_SETGLOBAL: ND_PRINT((ndo,"setglobal")); break;
1880                 default:                ND_PRINT((ndo,"#%u", match->rpm_code)); break;
1881                 }
1882
1883                 if (ndo->ndo_vflag) {
1884                         ND_PRINT((ndo,",ord=%u", match->rpm_ordinal));
1885                         ND_PRINT((ndo,",min=%u", match->rpm_minlen));
1886                         ND_PRINT((ndo,",max=%u", match->rpm_maxlen));
1887                 }
1888                 if (addrtostr6(&match->rpm_prefix, hbuf, sizeof(hbuf)))
1889                         ND_PRINT((ndo,",%s/%u", hbuf, match->rpm_matchlen));
1890                 else
1891                         ND_PRINT((ndo,",?/%u", match->rpm_matchlen));
1892                 /*(*/
1893                 ND_PRINT((ndo,")"));
1894
1895                 n = match->rpm_len - 3;
1896                 if (n % 4)
1897                         goto trunc;
1898                 n /= 4;
1899                 while (n-- > 0) {
1900                         use = (const struct rr_pco_use *)cp;
1901                         cp = (const char *)(use + 1);
1902
1903                         ND_TCHECK(use->rpu_prefix);
1904
1905                         if (ndo->ndo_vflag > 1)
1906                                 ND_PRINT((ndo,"\n\t"));
1907                         else
1908                                 ND_PRINT((ndo," "));
1909                         ND_PRINT((ndo,"use(")); /*)*/
1910                         if (use->rpu_flags) {
1911 #define F(x, y) ((use->rpu_flags) & (x) ? (y) : "")
1912                                 ND_PRINT((ndo,"%s%s,",
1913                                           F(ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME, "V"),
1914                                           F(ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME, "P")));
1915 #undef F
1916                         }
1917                         if (ndo->ndo_vflag) {
1918                                 ND_PRINT((ndo,"mask=0x%x,", use->rpu_ramask));
1919                                 ND_PRINT((ndo,"raflags=0x%x,", use->rpu_raflags));
1920                                 if (~use->rpu_vltime == 0)
1921                                         ND_PRINT((ndo,"vltime=infty,"));
1922                                 else
1923                                         ND_PRINT((ndo,"vltime=%u,",
1924                                                   EXTRACT_32BITS(&use->rpu_vltime)));
1925                                 if (~use->rpu_pltime == 0)
1926                                         ND_PRINT((ndo,"pltime=infty,"));
1927                                 else
1928                                         ND_PRINT((ndo,"pltime=%u,",
1929                                                   EXTRACT_32BITS(&use->rpu_pltime)));
1930                         }
1931                         if (addrtostr6(&use->rpu_prefix, hbuf, sizeof(hbuf)))
1932                                 ND_PRINT((ndo,"%s/%u/%u", hbuf, use->rpu_uselen,
1933                                           use->rpu_keeplen));
1934                         else
1935                                 ND_PRINT((ndo,"?/%u/%u", use->rpu_uselen,
1936                                           use->rpu_keeplen));
1937                         /*(*/
1938                         ND_PRINT((ndo,")"));
1939                 }
1940         }
1941
1942         return;
1943
1944 trunc:
1945         ND_PRINT((ndo,"[|icmp6]"));
1946 }
1947
1948 /*
1949  * Local Variables:
1950  * c-style: whitesmith
1951  * c-basic-offset: 8
1952  * End:
1953  */