proto_icmpv6.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Copyright 2012 Markus Amend <markus@netsniff-ng.org>, Deutsche Flugsicherung GmbH
   4  * Subject to the GPL, version 2.
   5  *
   6  * ICMPv6 described in RFC4443, RFC2710, RFC4861, RFC2894,
   7  * RFC4620, RFC3122, RFC3810, RFC3775, RFC3971, RFC4065
   8  * RFC4286
   9  * Look also for an good overview:
  10  * http://www.iana.org/assignments/icmpv6-parameters
  11  */
  12
  13 #include <inttypes.h>
  14 #include <stdio.h>
  15 #include <stdint.h>
  16 #include <netinet/in.h>
  17 #include <arpa/inet.h>
  18 #include <asm/byteorder.h>
  19
  20 #include "proto.h"
  21 #include "protos.h"
  22 #include "pkt_buff.h"
  23 #include "built_in.h"
  24
  25 #define icmpv6_code_range_valid(code, sarr)     ((size_t) (code) < array_size((sarr)))
  26
  27 struct icmpv6_general_hdr {
  28         uint8_t h_type;
  29         uint8_t h_code;
  30         uint16_t h_chksum;
  31 } __packed;
  32
  33 /* for type 0x01 and 0x03 */
  34 struct icmpv6_type_1_3 {
  35         uint32_t unused;
  36         uint8_t invoking_pkt[0];
  37 } __packed;
  38
  39 struct icmpv6_type_2 {
  40         uint32_t MTU;
  41         uint8_t invoking_pkt[0];
  42 } __packed;
  43
  44 struct icmpv6_type_4 {
  45         uint32_t pointer;
  46         uint8_t invoking_pkt[0];
  47 } __packed;
  48
  49 struct icmpv6_type_128_129 {
  50         uint16_t id;
  51         uint16_t sn;
  52         uint8_t data[0];
  53 } __packed;
  54
  55 /* MLDv1 msg */
  56 struct icmpv6_type_130_131_132 {
  57         uint16_t maxrespdel;
  58         uint16_t res;
  59         struct in6_addr ipv6_addr;
  60 } __packed;
  61 /* end MLDv1 msg */
  62
  63 struct icmpv6_type_130_mldv2 {
  64         uint8_t resv_S_QRV;
  65         uint8_t QQIC;
  66         uint16_t nr_src;
  67         struct in6_addr ipv6_addr[0];
  68 } __packed;
  69
  70 /* Neighbor Discovery msg */
  71 struct icmpv6_type_133_141_142 {
  72         uint32_t res;
  73         uint8_t ops[0];
  74 } __packed;
  75
  76 struct icmpv6_type_134 {
  77         uint8_t cur_hop_limit;
  78         uint8_t m_o_res;
  79         uint16_t router_lifetime;
  80         uint32_t reachable_time;
  81         uint32_t retrans_timer;
  82         uint8_t ops[0];
  83 } __packed;
  84
  85 struct icmpv6_type_135 {
  86         uint32_t res;
  87         struct in6_addr ipv6_addr;
  88         uint8_t ops[0];
  89 } __packed;
  90
  91 struct icmpv6_type_136 {
  92         uint32_t r_s_o_res;
  93         struct in6_addr ipv6_addr;
  94         uint8_t ops[0];
  95 } __packed;
  96
  97 struct icmpv6_type_137 {
  98         uint32_t res;
  99         struct in6_addr ipv6_targ_addr;
 100         struct in6_addr ipv6_dest_addr;
 101         uint8_t ops[0];
 102 } __packed;
 103
 104 struct icmpv6_neighb_disc_ops_general {
 105         uint8_t type;
 106         uint8_t len;
 107         uint8_t ops[0];
 108 } __packed;
 109
 110 struct icmpv6_neighb_disc_ops_type_1_2 {
 111         uint8_t link_lay_addr[0];
 112 } __packed;
 113
 114 struct icmpv6_neighb_disc_ops_type_3 {
 115         uint8_t prefix_len;
 116         uint8_t l_a_res1;
 117         uint32_t valid_lifetime;
 118         uint32_t preferred_lifetime;
 119         uint32_t res2;
 120         struct in6_addr prefix;
 121 } __packed;
 122
 123 struct icmpv6_neighb_disc_ops_type_4 {
 124         uint16_t res1;
 125         uint32_t res2;
 126         uint8_t ip_hdr_data[0];
 127 } __packed;
 128
 129 struct icmpv6_neighb_disc_ops_type_5 {
 130         uint16_t res1;
 131         uint32_t MTU;
 132 } __packed;
 133
 134 struct icmpv6_neighb_disc_ops_type_9_10 {
 135         uint16_t res1;
 136         uint32_t res2;
 137         uint8_t ip_hdr_data[0];
 138 } __packed;
 139
 140 struct icmpv6_neighb_disc_ops_type_15 {
 141         uint8_t name_type;
 142         size_t pad_len;
 143         char name[0];
 144         uint8_t pad[0];
 145 } __packed;
 146
 147 struct icmpv6_neighb_disc_ops_type_16 {
 148         uint8_t cert_type;
 149         uint8_t res;
 150         uint8_t cert[0];
 151         uint8_t pad[0];
 152 } __packed;
 153
 154 struct icmpv6_neighb_disc_ops_type_17 {
 155         uint8_t opt_code;
 156         uint8_t prefix_len;
 157         uint8_t data[0];
 158 } __packed;
 159
 160 struct icmpv6_neighb_disc_ops_type_17_1 {
 161         uint32_t res;
 162         struct in6_addr ipv6_addr;
 163 } __packed;
 164
 165 struct icmpv6_neighb_disc_ops_type_17_2 {
 166         struct in6_addr ipv6_addr;
 167 } __packed;
 168
 169 struct icmpv6_neighb_disc_ops_type_19 {
 170         uint8_t opt_code;
 171         uint8_t lla[0];
 172 } __packed;
 173 /* end Neighbor Discovery msg */
 174
 175 struct icmpv6_type_138 {
 176         uint32_t seq_nr;
 177         uint8_t seg_nr;
 178         uint8_t flags;
 179         uint16_t maxdelay;
 180         uint32_t res;
 181 } __packed;
 182
 183 /* Node Information Queries */
 184 struct icmpv6_type_139_140 {
 185         uint16_t qtype;
 186         uint16_t flags;
 187         uint64_t nonce;
 188         uint8_t data[0];
 189 } __packed;
 190 /* end Node Information Queries */
 191
 192 /* MLDv2 report */
 193 struct icmpv6_type_143 {
 194         uint16_t res;
 195         uint16_t nr_rec;
 196         uint8_t addr_rec[0];
 197 } __packed;
 198
 199 struct icmpv6_mldv2_addr_rec {
 200         uint8_t rec_type;
 201         uint8_t aux_data_len;
 202         uint16_t nr_src;
 203         struct in6_addr multic_addr;
 204         struct in6_addr src_addr[0];
 205 } __packed;
 206 /* end MLDv2 report */
 207
 208 /* ICMP Mobility Support */
 209 struct icmpv6_type_144_146 {
 210         uint16_t id;
 211         uint16_t res;
 212 } __packed;
 213
 214 struct icmpv6_type_145 {
 215         uint16_t id;
 216         uint16_t res;
 217         struct in6_addr home_agent_addr[0];
 218 } __packed;
 219
 220 struct icmpv6_type_147 {
 221         uint16_t id;
 222         uint16_t m_o_res;
 223         uint8_t ops[0];
 224 } __packed;
 225 /* end ICMP Mobility Support */
 226
 227 /* SEcure Neighbor Discovery */
 228 struct icmpv6_type_148 {
 229         uint16_t id;
 230         uint16_t comp;
 231         uint8_t ops[0];
 232 } __packed;
 233
 234 struct icmpv6_type_149 {
 235         uint16_t id;
 236         uint16_t all_comp;
 237         uint16_t comp;
 238         uint16_t res;
 239         uint8_t ops[0];
 240 } __packed;
 241 /* end SEcure Neighbor Discovery */
 242
 243 struct icmpv6_type_150 {
 244         union {
 245                 uint32_t subtype_res;
 246                 struct {
 247 #if defined(__LITTLE_ENDIAN_BITFIELD)
 248                         uint32_t res     :24,
 249                                  subtype :8;
 250 #elif defined(__BIG_ENDIAN_BITFIELD)
 251                         uint32_t subtype :8,
 252                                  res     :24;
 253 #else
 254 # error "Please fix <asm/byteorder.h>"
 255 #endif
 256                 };
 257         };
 258         uint8_t ops[0];
 259 } __packed;
 260
 261 /* Multicast Router Discovery */
 262 struct icmpv6_type_151 {
 263         uint16_t query_intv;
 264         uint16_t rob_var;
 265 } __packed;
 266
 267 struct icmpv6_type_152 {
 268         uint8_t null[0];
 269 } __packed;
 270
 271 struct icmpv6_type_153 {
 272         uint8_t null[0];
 273 } __packed;
 274 /* end Multicast Router Discovery */
 275
 276 struct icmpv6_type_154 {
 277         uint8_t subtype;
 278         uint8_t res;
 279         uint16_t id;
 280         uint8_t ops[0];
 281 } __packed;
 282
 283 static int8_t print_ipv6_addr_list(struct pkt_buff *pkt, uint8_t nr_addr)
 284 {
 285         char address[INET6_ADDRSTRLEN];
 286         struct in6_addr *addr;
 287
 288         while (nr_addr--) {
 289             addr = (struct in6_addr *) pkt_pull(pkt, sizeof(*addr));
 290             if (addr == NULL)
 291                     return 0;
 292
 293             tprintf("\n\t   Address: %s",
 294                     inet_ntop(AF_INET6, addr, address,
 295                               sizeof(address)));
 296         }
 297
 298         return 1;
 299 }
 300
 301 static const char *icmpv6_mcast_rec_types[] = {
 302         "MODE_IS_INCLUDE",
 303         "MODE_IS_EXCLUDE",
 304         "CHANGE_TO_INCLUDE_MODE",
 305         "CHANGE_TO_EXCLUDE_MODE",
 306         "ALLOW_NEW_SOURCES",
 307         "BLOCK_OLD_SOURCES",
 308 };
 309
 310 static int8_t dissect_icmpv6_mcast_rec(struct pkt_buff *pkt,
 311                                        uint16_t nr_rec)
 312 {
 313         uint16_t nr_src, aux_data_len_bytes;
 314         char address[INET6_ADDRSTRLEN];
 315         struct icmpv6_mldv2_addr_rec *addr_rec;
 316
 317         while (nr_rec--) {
 318                 addr_rec = (struct icmpv6_mldv2_addr_rec *)
 319                       pkt_pull(pkt,sizeof(*addr_rec));
 320                 if (addr_rec == NULL)
 321                         return 0;
 322                 aux_data_len_bytes = addr_rec->aux_data_len * 4;
 323                 nr_src = ntohs(addr_rec->nr_src);
 324
 325                 tprintf(", Rec Type %s (%u)",
 326                         icmpv6_code_range_valid(addr_rec->rec_type - 1,
 327                         icmpv6_mcast_rec_types) ?
 328                         icmpv6_mcast_rec_types[addr_rec->rec_type - 1]
 329                         : "Unknown", addr_rec->rec_type);
 330                 if (aux_data_len_bytes > pkt_len(pkt)) {
 331                         tprintf(", Aux Data Len (%u, %u bytes) %s",
 332                               addr_rec->aux_data_len,
 333                               aux_data_len_bytes,
 334                               colorize_start_full(black, red) "invalid"
 335                               colorize_end());
 336                         return 0;
 337                 }
 338                 tprintf(", Aux Data Len (%u, %u bytes)",addr_rec->aux_data_len,
 339                         aux_data_len_bytes);
 340                 tprintf(", Nr. of Sources (%u)",nr_src);
 341                 tprintf(", Address: %s",
 342                         inet_ntop(AF_INET6, &addr_rec->multic_addr,
 343                                   address, sizeof(address)));
 344
 345                 if(!print_ipv6_addr_list(pkt, nr_src))
 346                         return 0;
 347
 348                 if (aux_data_len_bytes > pkt_len(pkt)) {
 349                         tprintf("\nAux Data Len %s",
 350                               colorize_start_full(black, red) "invalid"
 351                               colorize_end());
 352                         return 0;
 353                 }
 354
 355                 tprintf(", Aux Data: ");
 356                 while (aux_data_len_bytes--) {
 357                         uint8_t *data = pkt_pull(pkt, 1);
 358
 359                         if (data == NULL) {
 360                                 tprintf("%sINVALID%s", colorize_start_full(black, red),
 361                                         colorize_end());
 362                                 return 0;
 363                         }
 364
 365                         tprintf("%x", *data);
 366                 }
 367         }
 368
 369         return 1;
 370 }
 371
 372 static int8_t dissect_neighb_disc_ops_1(struct pkt_buff *pkt,
 373                                         ssize_t len)
 374 {
 375         struct icmpv6_neighb_disc_ops_type_1_2 *icmp_neighb_disc_1;
 376
 377         icmp_neighb_disc_1 = (struct icmpv6_neighb_disc_ops_type_1_2 *)
 378                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_1));
 379         if (icmp_neighb_disc_1 == NULL)
 380                         return 0;
 381         len -= sizeof(*icmp_neighb_disc_1);
 382         if (len < 0)
 383               return 0;
 384
 385         tprintf("Address 0x");
 386
 387         while (len--) {
 388                 uint8_t *data = pkt_pull(pkt, 1);
 389
 390                 if (data == NULL) {
 391                         tprintf("%sINVALID%s", colorize_start_full(black, red),
 392                                 colorize_end());
 393                         return 0;
 394                 }
 395
 396                 tprintf("%x", *data);
 397         }
 398
 399         return 1;
 400 }
 401
 402 static int8_t dissect_neighb_disc_ops_2(struct pkt_buff *pkt,
 403                                         ssize_t len)
 404 {
 405         return dissect_neighb_disc_ops_1(pkt, len);
 406 }
 407
 408 static int8_t dissect_neighb_disc_ops_3(struct pkt_buff *pkt,
 409                                         ssize_t len)
 410 {
 411         char address[INET6_ADDRSTRLEN];
 412         struct icmpv6_neighb_disc_ops_type_3 *icmp_neighb_disc_3;
 413
 414         icmp_neighb_disc_3 = (struct icmpv6_neighb_disc_ops_type_3 *)
 415                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_3));
 416         if (icmp_neighb_disc_3 == NULL)
 417                         return 0;
 418         len -= sizeof(*icmp_neighb_disc_3);
 419         if (len < 0)
 420               return 0;
 421
 422         tprintf("Prefix Len (%u) ",icmp_neighb_disc_3->prefix_len);
 423         tprintf("L (%u) A (%u) Res1 (0x%x) ",icmp_neighb_disc_3->l_a_res1 >> 7,
 424                                 (icmp_neighb_disc_3->l_a_res1 >> 7) & 0x1,
 425                                 icmp_neighb_disc_3->l_a_res1 & 0x3F);
 426         tprintf("Valid Lifetime (%us) ",
 427                                 ntohl(icmp_neighb_disc_3->valid_lifetime));
 428         tprintf("Preferred Lifetime (%us) ",
 429                                 ntohl(icmp_neighb_disc_3->preferred_lifetime));
 430         tprintf("Reserved2 (0x%x) ",
 431                                 ntohl(icmp_neighb_disc_3->res2));
 432         tprintf("Prefix: %s ",
 433                                 inet_ntop(AF_INET6,&icmp_neighb_disc_3->prefix,
 434                                 address, sizeof(address)));
 435
 436         return 1;
 437 }
 438
 439 static int8_t dissect_neighb_disc_ops_4(struct pkt_buff *pkt,
 440                                         ssize_t len)
 441 {
 442         struct icmpv6_neighb_disc_ops_type_4 *icmp_neighb_disc_4;
 443
 444         icmp_neighb_disc_4 = (struct icmpv6_neighb_disc_ops_type_4 *)
 445                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_4));
 446         if (icmp_neighb_disc_4 == NULL)
 447                         return 0;
 448         len -= sizeof(*icmp_neighb_disc_4);
 449         if (len < 0)
 450               return 0;
 451
 452         tprintf("Reserved 1 (0x%x) ", ntohs(icmp_neighb_disc_4->res1));
 453         tprintf("Reserved 2 (0x%x) ", ntohl(icmp_neighb_disc_4->res2));
 454         tprintf("IP header + data ");
 455
 456         while (len--) {
 457                 uint8_t *data = pkt_pull(pkt, 1);
 458
 459                 if (data == NULL) {
 460                         tprintf("%sINVALID%s", colorize_start_full(black, red),
 461                                 colorize_end());
 462                         return 0;
 463                 }
 464
 465                 tprintf("%x", *data);
 466         }
 467
 468         return 1;
 469 }
 470
 471 static int8_t dissect_neighb_disc_ops_5(struct pkt_buff *pkt,
 472                                         ssize_t len)
 473 {
 474         struct icmpv6_neighb_disc_ops_type_5 *icmp_neighb_disc_5;
 475
 476         icmp_neighb_disc_5 = (struct icmpv6_neighb_disc_ops_type_5 *)
 477                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_5));
 478         if (icmp_neighb_disc_5 == NULL)
 479                         return 0;
 480         len -= sizeof(*icmp_neighb_disc_5);
 481         if (len < 0)
 482               return 0;
 483
 484         tprintf("Reserved (0x%x) ", ntohs(icmp_neighb_disc_5->res1));
 485         tprintf("MTU (%u)", ntohl(icmp_neighb_disc_5->MTU));
 486
 487         return 1;
 488 }
 489
 490 static int8_t dissect_neighb_disc_ops_9(struct pkt_buff *pkt,
 491                                         ssize_t len)
 492 {
 493         struct icmpv6_neighb_disc_ops_type_9_10 *icmp_neighb_disc_9;
 494
 495         icmp_neighb_disc_9 = (struct icmpv6_neighb_disc_ops_type_9_10 *)
 496                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_9));
 497         if (icmp_neighb_disc_9 == NULL)
 498                         return 0;
 499         len -= sizeof(*icmp_neighb_disc_9);
 500         if (len < 0)
 501               return 0;
 502
 503         tprintf("Reserved 1 (0x%x) ", ntohs(icmp_neighb_disc_9->res1));
 504         tprintf("Reserved 2 (0x%x) ", ntohl(icmp_neighb_disc_9->res2));
 505
 506         return print_ipv6_addr_list(pkt, len / sizeof(struct in6_addr));
 507 }
 508
 509 static int8_t dissect_neighb_disc_ops_10(struct pkt_buff *pkt,
 510                                          ssize_t len)
 511 {
 512         return dissect_neighb_disc_ops_9(pkt, len);
 513 }
 514
 515 static const char *icmpv6_neighb_disc_ops_15_name[] = {
 516         "DER Encoded X.501 Name",
 517         "FQDN",
 518 };
 519
 520 static int8_t dissect_neighb_disc_ops_15(struct pkt_buff *pkt,
 521                                          ssize_t len)
 522 {
 523         size_t pad_len;
 524         ssize_t name_len;
 525         struct icmpv6_neighb_disc_ops_type_15 *icmp_neighb_disc_15;
 526
 527         icmp_neighb_disc_15 = (struct icmpv6_neighb_disc_ops_type_15 *)
 528                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_15));
 529         if (icmp_neighb_disc_15 == NULL)
 530                         return 0;
 531         len -= sizeof(*icmp_neighb_disc_15);
 532         if (len < 0)
 533               return 0;
 534         pad_len = icmp_neighb_disc_15->pad_len;
 535
 536         tprintf("Name Type %s (%u) ",
 537                 icmpv6_code_range_valid(icmp_neighb_disc_15->name_type - 1,
 538                 icmpv6_neighb_disc_ops_15_name) ?
 539                 icmpv6_neighb_disc_ops_15_name[
 540                 icmp_neighb_disc_15->name_type - 1] : "Unknown",
 541                 icmp_neighb_disc_15->name_type);
 542         if (pad_len > (size_t) len) {
 543                 tprintf("Pad Len (%zu, invalid)\n%s", pad_len,
 544                         colorize_start_full(black, red)
 545                         "Skip Option" colorize_end());
 546                 pkt_pull(pkt, len);
 547                 return 1;
 548         }
 549         else
 550                 tprintf("Pad Len (%zu) ", pad_len);
 551
 552         name_len = len - pad_len;
 553
 554         tprintf("Name (");
 555         while (name_len--) {
 556                 uint8_t *data = pkt_pull(pkt, 1);
 557
 558                 if (data == NULL) {
 559                         tprintf("%sINVALID%s", colorize_start_full(black, red),
 560                                 colorize_end());
 561                         return 0;
 562                 }
 563
 564                 tprintf("%c", *data);
 565         }
 566         tprintf(") ");
 567
 568         tprintf("Padding (");
 569
 570         while (pad_len--) {
 571                 uint8_t *data = pkt_pull(pkt, 1);
 572
 573                 if (data == NULL) {
 574                         tprintf("%sINVALID%s", colorize_start_full(black, red),
 575                                 colorize_end());
 576                         break;
 577                 }
 578
 579                 tprintf("%x", *data);
 580         }
 581         tprintf(")");
 582
 583         return 1;
 584 }
 585
 586 static const char *icmpv6_neighb_disc_ops_16_cert[] = {
 587         "X.509v3 Certificate",
 588 };
 589
 590 static int8_t dissect_neighb_disc_ops_16(struct pkt_buff *pkt,
 591                                          ssize_t len)
 592 {
 593         struct icmpv6_neighb_disc_ops_type_16 *icmp_neighb_disc_16;
 594
 595         icmp_neighb_disc_16 = (struct icmpv6_neighb_disc_ops_type_16 *)
 596                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_16));
 597         if (icmp_neighb_disc_16 == NULL)
 598                         return 0;
 599         len -= sizeof(*icmp_neighb_disc_16);
 600         if (len < 0)
 601               return 0;
 602
 603         tprintf("Cert Type %s (%u) ",
 604                 icmpv6_code_range_valid(icmp_neighb_disc_16->cert_type - 1,
 605                 icmpv6_neighb_disc_ops_16_cert) ?
 606                 icmpv6_neighb_disc_ops_16_cert[
 607                 icmp_neighb_disc_16->cert_type - 1] : "Unknown",
 608                 icmp_neighb_disc_16->cert_type);
 609         tprintf("Res (0x%x) ", icmp_neighb_disc_16->res);
 610
 611         tprintf("Certificate + Padding (");
 612         while (len--) {
 613                 uint8_t *data = pkt_pull(pkt, 1);
 614
 615                 if (data == NULL) {
 616                         tprintf("%sINVALID%s", colorize_start_full(black, red),
 617                                 colorize_end());
 618                         break;
 619                 }
 620
 621                 tprintf("%x", *data);
 622         }
 623         tprintf(") ");
 624
 625         return 1;
 626 }
 627
 628 static const char *icmpv6_neighb_disc_ops_17_codes[] = {
 629         "Old Care-of Address",
 630         "New Care-of Address",
 631         "NAR's IP address",
 632         "NAR's Prefix",
 633 };
 634
 635 static int8_t dissect_neighb_disc_ops_17(struct pkt_buff *pkt,
 636                                          ssize_t len)
 637 {
 638         char address[INET6_ADDRSTRLEN];
 639         struct icmpv6_neighb_disc_ops_type_17 *icmp_neighb_disc_17;
 640
 641         icmp_neighb_disc_17 = (struct icmpv6_neighb_disc_ops_type_17 *)
 642                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_17));
 643         if (icmp_neighb_disc_17 == NULL)
 644                         return 0;
 645         len -= sizeof(*icmp_neighb_disc_17);
 646         if (len < 0)
 647               return 0;
 648
 649         tprintf("Opt Code %s (%u) ",
 650                 icmpv6_code_range_valid(icmp_neighb_disc_17->opt_code - 1,
 651                 icmpv6_neighb_disc_ops_17_codes) ?
 652                 icmpv6_neighb_disc_ops_17_codes[
 653                 icmp_neighb_disc_17->opt_code - 1] : "Unknown",
 654                 icmp_neighb_disc_17->opt_code);
 655         tprintf("Prefix Len (%u) ", icmp_neighb_disc_17->prefix_len);
 656
 657         if (len == sizeof(struct icmpv6_neighb_disc_ops_type_17_1)) {
 658                     struct icmpv6_neighb_disc_ops_type_17_1
 659                                                       *icmp_neighb_disc_17_1;
 660
 661                     icmp_neighb_disc_17_1 =
 662                                   (struct icmpv6_neighb_disc_ops_type_17_1 *)
 663                                   pkt_pull(pkt,sizeof(*icmp_neighb_disc_17_1));
 664                     if (icmp_neighb_disc_17_1 == NULL)
 665                                   return 0;
 666                     len -= sizeof(*icmp_neighb_disc_17_1);
 667                     if (len < 0)
 668                           return 0;
 669
 670                     tprintf("Res (0x%x) ",icmp_neighb_disc_17_1->res);
 671                     tprintf("Addr: %s ",
 672                           inet_ntop(AF_INET6,&icmp_neighb_disc_17_1->ipv6_addr,
 673                           address, sizeof(address)));
 674         }
 675         else if (len == sizeof(struct icmpv6_neighb_disc_ops_type_17_2)) {
 676                     struct icmpv6_neighb_disc_ops_type_17_2
 677                                                       *icmp_neighb_disc_17_2;
 678
 679                     icmp_neighb_disc_17_2 =
 680                                   (struct icmpv6_neighb_disc_ops_type_17_2 *)
 681                                   pkt_pull(pkt,sizeof(*icmp_neighb_disc_17_2));
 682                     if (icmp_neighb_disc_17_2 == NULL)
 683                                   return 0;
 684                     len -= sizeof(*icmp_neighb_disc_17_2);
 685                     if (len < 0)
 686                           return 0;
 687
 688                     tprintf("Addr: %s ",
 689                           inet_ntop(AF_INET6,&icmp_neighb_disc_17_2->ipv6_addr,
 690                           address, sizeof(address)));
 691         }
 692         else {
 693                     tprintf("%s (", colorize_start_full(black, red)
 694                               "Error Wrong Length. Skip Option" colorize_end());
 695                     while (len--) {
 696                         uint8_t *data = pkt_pull(pkt, 1);
 697
 698                         if (data == NULL) {
 699                                 tprintf("%sINVALID%s", colorize_start_full(black, red),
 700                                         colorize_end());
 701                                 break;
 702                         }
 703
 704                         tprintf("%x", *data);
 705                     }
 706                     tprintf(") ");
 707         }
 708
 709         return 1;
 710 }
 711
 712 static const char *icmpv6_neighb_disc_ops_19_codes[] = {
 713         "Wildcard requesting resolution for all nearby access points",
 714         "Link-Layer Address of the New Access Point",
 715         "Link-Layer Address of the MN",
 716         "Link-Layer Address of the NAR",
 717         "Link-Layer Address of the source of RtSolPr or PrRtAdv \
 718          message",
 719         "The access point identified by the LLA belongs to the \
 720          current interface of the router",
 721         "No prefix information available for the access point \
 722          identified by the LLA",
 723         "No fast handover support available for the access point \
 724          identified by the LLA",
 725 };
 726
 727 static int8_t dissect_neighb_disc_ops_19(struct pkt_buff *pkt,
 728                                          ssize_t len)
 729 {
 730         struct icmpv6_neighb_disc_ops_type_19 *icmp_neighb_disc_19;
 731
 732         icmp_neighb_disc_19 = (struct icmpv6_neighb_disc_ops_type_19 *)
 733                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc_19));
 734         if (icmp_neighb_disc_19 == NULL)
 735                         return 0;
 736         len -= sizeof(*icmp_neighb_disc_19);
 737         if (len < 0)
 738               return 0;
 739
 740         tprintf("Opt Code %s (%u) ",
 741                 icmpv6_code_range_valid(icmp_neighb_disc_19->opt_code,
 742                 icmpv6_neighb_disc_ops_19_codes) ?
 743                 icmpv6_neighb_disc_ops_19_codes[
 744                 icmp_neighb_disc_19->opt_code] : "Unknown",
 745                 icmp_neighb_disc_19->opt_code);
 746
 747         tprintf("LLA (");
 748         while(len--) {
 749                 uint8_t *data = pkt_pull(pkt, 1);
 750
 751                 if (data == NULL) {
 752                         tprintf("%sINVALID%s", colorize_start_full(black, red),
 753                                 colorize_end());
 754                         return 0;
 755                 }
 756
 757                 tprintf("%x", *data);
 758         }
 759         tprintf(") ");
 760
 761         return 1;
 762 }
 763
 764 static inline char *icmpv6_neighb_disc_ops(uint8_t code) {
 765         switch (code) {
 766         case  1: return "Source Link-Layer Address";
 767         case  2: return "Target Link-Layer Address";
 768         case  3: return "Prefix Information";
 769         case  4: return "Redirected Header";
 770         case  5: return "MTU";
 771         case  6: return "NBMA Shortcut Limit Option";
 772         case  7: return "Advertisement Interval Option";
 773         case  8: return "Home Agent Information Option";
 774         case  9: return "Source Address List";
 775         case 10: return "Target Address List";
 776         case 11: return "CGA option";
 777         case 12: return "RSA Signature option";
 778         case 13: return "Timestamp option";
 779         case 14: return "Nonce option";
 780         case 15: return "Trust Anchor option";
 781         case 16: return "Certificate option";
 782         case 17: return "IP Address/Prefix Option";
 783         case 18: return "New Router Prefix Information Option";
 784         case 19: return "Link-layer Address Option";
 785         case 20: return "Neighbor Advertisement Acknowledgment Option";
 786
 787         case 23: return "Prefix Information";
 788         case 24: return "Redirected Header";
 789         case 25: return "MTU";
 790         case 26: return "NBMA Shortcut Limit Option";
 791         case 27: return "Advertisement Interval Option";
 792         case 28: return "Home Agent Information Option";
 793         case 29: return "Source Address List";
 794         case 30: return "Target Address List";
 795         case 31: return "DNS Search List Option";
 796         case 32: return "Proxy Signature (PS)";
 797
 798         case 138: return "CARD Request option";
 799         case 139: return "CARD Reply option";
 800
 801         case 253: return "RFC3692-style Experiment 1";
 802         case 254: return "RFC3692-style Experiment 2";
 803         }
 804
 805         return NULL;
 806 };
 807
 808 static int8_t dissect_neighb_disc_ops(struct pkt_buff *pkt)
 809 {
 810         size_t pad_bytes;
 811         uint16_t ops_total_len;
 812         ssize_t ops_payl_len;
 813         struct icmpv6_neighb_disc_ops_general *icmp_neighb_disc;
 814
 815         while(pkt_len(pkt)) {
 816                 icmp_neighb_disc = (struct icmpv6_neighb_disc_ops_general *)
 817                                 pkt_pull(pkt,sizeof(*icmp_neighb_disc));
 818                 if (icmp_neighb_disc == NULL)
 819                         return 0;
 820
 821                 ops_total_len = icmp_neighb_disc->len * 8;
 822                 pad_bytes = (size_t) (ops_total_len % 8);
 823                 ops_payl_len = ops_total_len - sizeof(*icmp_neighb_disc) -
 824                                                                 pad_bytes;
 825
 826                 tprintf("\n\tOption %s (%u) ",
 827                           icmpv6_neighb_disc_ops(icmp_neighb_disc->type) ?
 828                           icmpv6_neighb_disc_ops(icmp_neighb_disc->type)
 829                           : "Type Unknown", icmp_neighb_disc->type);
 830                 if (ops_payl_len > pkt_len(pkt) || ops_payl_len < 0) {
 831                         tprintf("Length (%u, %u bytes, %s%s%s) ",
 832                                           icmp_neighb_disc->len,
 833                                           ops_total_len,
 834                                           colorize_start_full(black, red),
 835                                           "invalid", colorize_end());
 836                         return 0;
 837                 }
 838
 839                 tprintf("Length (%u, %u bytes) ",icmp_neighb_disc->len,
 840                                                  ops_total_len);
 841
 842                 switch (icmp_neighb_disc->type) {
 843                 case 1:
 844                         if (!dissect_neighb_disc_ops_1(pkt, ops_payl_len))
 845                               return 0;
 846                         break;
 847                 case 2:
 848                         if (!dissect_neighb_disc_ops_2(pkt, ops_payl_len))
 849                               return 0;
 850                         break;
 851                 case 3:
 852                         if (!dissect_neighb_disc_ops_3(pkt, ops_payl_len))
 853                               return 0;
 854                         break;
 855                 case 4:
 856                         if (!dissect_neighb_disc_ops_4(pkt, ops_payl_len))
 857                               return 0;
 858                         break;
 859                 case 5:
 860                         if (!dissect_neighb_disc_ops_5(pkt, ops_payl_len))
 861                               return 0;
 862                         break;
 863                 /* Type 9 and 10 defined in
 864                  * http://tools.ietf.org/html/rfc3122#section-3.1
 865                  */
 866                 case 9:
 867                         if (!dissect_neighb_disc_ops_9(pkt, ops_payl_len))
 868                               return 0;
 869                         break;
 870                 case 10:
 871                         if (!dissect_neighb_disc_ops_10(pkt, ops_payl_len))
 872                               return 0;
 873                         break;
 874                 /* Type 15 and 16 defined in
 875                  * http://tools.ietf.org/html/rfc3971#section-6.4.3
 876                  * http://tools.ietf.org/html/rfc3971#section-6.4.4
 877                  */
 878                 case 15:
 879                         if (!dissect_neighb_disc_ops_15(pkt, ops_payl_len))
 880                               return 0;
 881                         break;
 882                 case 16:
 883                         if (!dissect_neighb_disc_ops_16(pkt, ops_payl_len))
 884                               return 0;
 885                         break;
 886                 /* Type 17 and 19 defined in
 887                  * http://tools.ietf.org/html/rfc5568#section-6.4
 888                  */
 889                 case 17:
 890                         if (!dissect_neighb_disc_ops_17(pkt, ops_payl_len))
 891                               return 0;
 892                         break;
 893                 case 19:
 894                         if (!dissect_neighb_disc_ops_19(pkt, ops_payl_len))
 895                               return 0;
 896                         break;
 897                 default:
 898                         pkt_pull(pkt, ops_payl_len);
 899                 }
 900
 901                 /* Skip Padding Bytes */
 902                 if (pad_bytes > pkt_len(pkt)) {
 903                         tprintf(" %s",colorize_start_full(black, red)
 904                         "Invalid Padding" colorize_end());
 905                         return 0;
 906                 }
 907                 pkt_pull(pkt, pad_bytes);
 908         }
 909
 910         return 1;
 911 }
 912
 913 static const char *icmpv6_type_1_codes[] = {
 914         "No route to destination",
 915         "Communication with destination administratively prohibited",
 916         "Beyond scope of source address",
 917         "Address unreachable",
 918         "Port unreachable",
 919         "Source address failed ingress/egress policy",
 920         "Reject route to destination",
 921         "Error in Source Routing Header",
 922 };
 923
 924 static int8_t dissect_icmpv6_type1(struct pkt_buff *pkt)
 925 {
 926         struct icmpv6_type_1_3 *icmp_1;
 927
 928         icmp_1 = (struct icmpv6_type_1_3 *) pkt_pull(pkt,sizeof(*icmp_1));
 929         if (icmp_1 == NULL)
 930                 return 0;
 931
 932         tprintf(", Unused (0x%x)",ntohl(icmp_1->unused));
 933         tprintf(" Payload include as much of invoking packet");
 934
 935         return 1;
 936 }
 937
 938 static int8_t dissect_icmpv6_type2(struct pkt_buff *pkt)
 939 {
 940         struct icmpv6_type_2 *icmp_2;
 941
 942         icmp_2 = (struct icmpv6_type_2 *) pkt_pull(pkt,sizeof(*icmp_2));
 943         if (icmp_2 == NULL)
 944                 return 0;
 945
 946         tprintf(", MTU (0x%x)",ntohl(icmp_2->MTU));
 947         tprintf(" Payload include as much of invoking packet");
 948
 949         return 1;
 950 }
 951
 952 static const char *icmpv6_type_3_codes[] = {
 953         "Hop limit exceeded in transit",
 954         "Fragment reassembly time exceeded",
 955 };
 956
 957 static int8_t dissect_icmpv6_type3(struct pkt_buff *pkt)
 958 {
 959         struct icmpv6_type_1_3 *icmp_3;
 960
 961         icmp_3 = (struct icmpv6_type_1_3 *) pkt_pull(pkt,sizeof(*icmp_3));
 962         if (icmp_3 == NULL)
 963                 return 0;
 964
 965         tprintf(", Unused (0x%x)",ntohl(icmp_3->unused));
 966         tprintf(" Payload include as much of invoking packet");
 967
 968         return 1;
 969 }
 970
 971 static const char *icmpv6_type_4_codes[] = {
 972         "Erroneous header field encountered",
 973         "Unrecognized Next Header type encountered",
 974         "Unrecognized IPv6 option encountered",
 975 };
 976
 977 static int8_t dissect_icmpv6_type4(struct pkt_buff *pkt)
 978 {
 979         struct icmpv6_type_4 *icmp_4;
 980
 981         icmp_4 = (struct icmpv6_type_4 *) pkt_pull(pkt,sizeof(*icmp_4));
 982         if (icmp_4 == NULL)
 983                 return 0;
 984
 985         tprintf(", Pointer (0x%x)",ntohl(icmp_4->pointer));
 986         tprintf(" Payload include as much of invoking packet");
 987
 988         return 1;
 989 }
 990
 991 static int8_t dissect_icmpv6_type128(struct pkt_buff *pkt)
 992 {
 993         struct icmpv6_type_128_129 *icmp_128;
 994
 995         icmp_128 = (struct icmpv6_type_128_129 *)
 996                       pkt_pull(pkt,sizeof(*icmp_128));
 997         if (icmp_128 == NULL)
 998                 return 0;
 999
1000         tprintf(", ID (0x%x)",ntohs(icmp_128->id));
1001         tprintf(", Seq. Nr. (%u)",ntohs(icmp_128->sn));
1002         tprintf(" Payload include Data");
1003
1004         return 1;
1005 }
1006
1007 static int8_t dissect_icmpv6_type129(struct pkt_buff *pkt)
1008 {
1009         struct icmpv6_type_128_129 *icmp_129;
1010
1011         icmp_129 = (struct icmpv6_type_128_129 *)
1012                       pkt_pull(pkt,sizeof(*icmp_129));
1013         if (icmp_129 == NULL)
1014                 return 0;
1015
1016         tprintf(", ID (0x%x)",ntohs(icmp_129->id));
1017         tprintf(", Seq. Nr. (%u)",ntohs(icmp_129->sn));
1018         tprintf(" Payload include Data");
1019
1020         return 1;
1021 }
1022
1023 static int8_t dissect_icmpv6_type130(struct pkt_buff *pkt)
1024 {
1025         char address[INET6_ADDRSTRLEN];
1026         uint16_t nr_src, maxrespdel;
1027         uint8_t switch_mldv2 = 0;
1028         struct icmpv6_type_130_131_132 *icmp_130;
1029
1030         icmp_130 = (struct icmpv6_type_130_131_132 *)
1031                       pkt_pull(pkt,sizeof(*icmp_130));
1032         if (icmp_130 == NULL)
1033                 return 0;
1034         maxrespdel = ntohs(icmp_130->maxrespdel);
1035
1036         if(pkt_len(pkt) >= sizeof(struct icmpv6_type_130_mldv2))
1037                   switch_mldv2 = 1;
1038
1039         if(switch_mldv2)
1040                 tprintf(", MLDv2, Max Resp Delay (%ums)", maxrespdel >> 15 ?
1041                         (((maxrespdel & 0xFFF) | 0x1000) <<
1042                         (((maxrespdel >> 12) & 0x3) + 3)) : maxrespdel);
1043         else
1044                 tprintf(", Max Resp Delay (%ums)",maxrespdel);
1045         tprintf(", Res (0x%x)",ntohs(icmp_130->res));
1046         tprintf(", Address: %s",
1047                         inet_ntop(AF_INET6, &icmp_130->ipv6_addr,
1048                                   address, sizeof(address)));
1049
1050         if(switch_mldv2) {
1051                 struct icmpv6_type_130_mldv2 *icmp_130_mldv2;
1052
1053                 icmp_130_mldv2 = (struct icmpv6_type_130_mldv2 *)
1054                               pkt_pull(pkt,sizeof(*icmp_130_mldv2));
1055                 if (icmp_130_mldv2 == NULL)
1056                         return 0;
1057
1058                 nr_src = ntohs(icmp_130_mldv2->nr_src);
1059
1060                 tprintf(", Resv (0x%x)",icmp_130_mldv2->resv_S_QRV >> 4);
1061                 tprintf(", S (%u)",(icmp_130_mldv2->resv_S_QRV >> 3) & 0x1);
1062                 tprintf(", QRV (0x%x)",icmp_130_mldv2->resv_S_QRV & 0x3);
1063                 tprintf(", QQIC (%u)",icmp_130_mldv2->QQIC);
1064                 tprintf(", Nr Src (%u)",nr_src);
1065
1066                 return print_ipv6_addr_list(pkt, nr_src);
1067         }
1068
1069         return 1;
1070 }
1071
1072 static int8_t dissect_icmpv6_type131(struct pkt_buff *pkt)
1073 {
1074         char address[INET6_ADDRSTRLEN];
1075         struct icmpv6_type_130_131_132 *icmp_131;
1076
1077         icmp_131 = (struct icmpv6_type_130_131_132 *)
1078                       pkt_pull(pkt,sizeof(*icmp_131));
1079         if (icmp_131 == NULL)
1080                 return 0;
1081
1082         tprintf(", Max Resp Delay (%ums)",ntohs(icmp_131->maxrespdel));
1083         tprintf(", Res (0x%x)",ntohs(icmp_131->res));
1084         tprintf(", Address: %s",
1085                         inet_ntop(AF_INET6, &icmp_131->ipv6_addr,
1086                                   address, sizeof(address)));
1087
1088         return 1;
1089 }
1090
1091 static inline int8_t dissect_icmpv6_type132(struct pkt_buff *pkt)
1092 {
1093         return dissect_icmpv6_type131(pkt);
1094 }
1095
1096 static int8_t dissect_icmpv6_type133(struct pkt_buff *pkt)
1097 {
1098         struct icmpv6_type_133_141_142 *icmp_133;
1099
1100         icmp_133 = (struct icmpv6_type_133_141_142 *)
1101                       pkt_pull(pkt,sizeof(*icmp_133));
1102         if (icmp_133 == NULL)
1103                 return 0;
1104
1105         tprintf(", Reserved (0x%x)",ntohl(icmp_133->res));
1106
1107         return dissect_neighb_disc_ops(pkt);
1108 }
1109
1110 static int8_t dissect_icmpv6_type134(struct pkt_buff *pkt)
1111 {
1112         struct icmpv6_type_134 *icmp_134;
1113
1114         icmp_134 = (struct icmpv6_type_134 *)
1115                       pkt_pull(pkt,sizeof(*icmp_134));
1116         if (icmp_134 == NULL)
1117                 return 0;
1118
1119         tprintf(", Cur Hop Limit (%u)",icmp_134->cur_hop_limit);
1120         tprintf(", M (%u) O (%u)",icmp_134->m_o_res >> 7,
1121                 (icmp_134->m_o_res >> 6) & 0x1);
1122         tprintf(", Router Lifetime (%us)",ntohs(icmp_134->router_lifetime));
1123         tprintf(", Reachable Time (%ums)",ntohl(icmp_134->reachable_time));
1124         tprintf(", Retrans Timer (%ums)",ntohl(icmp_134->retrans_timer));
1125
1126         return dissect_neighb_disc_ops(pkt);
1127 }
1128
1129 static int8_t dissect_icmpv6_type135(struct pkt_buff *pkt)
1130 {
1131         char address[INET6_ADDRSTRLEN];
1132         struct icmpv6_type_135 *icmp_135;
1133
1134         icmp_135 = (struct icmpv6_type_135 *)
1135                       pkt_pull(pkt,sizeof(*icmp_135));
1136         if (icmp_135 == NULL)
1137                 return 0;
1138
1139         tprintf(", Reserved (0x%x)",ntohl(icmp_135->res));
1140         tprintf(", Target Address: %s",
1141                         inet_ntop(AF_INET6, &icmp_135->ipv6_addr,
1142                                   address, sizeof(address)));
1143
1144         return dissect_neighb_disc_ops(pkt);
1145 }
1146
1147 static int8_t dissect_icmpv6_type136(struct pkt_buff *pkt)
1148 {
1149         char address[INET6_ADDRSTRLEN];
1150         uint32_t r_s_o_res;
1151         struct icmpv6_type_136 *icmp_136;
1152
1153         icmp_136 = (struct icmpv6_type_136 *)
1154                       pkt_pull(pkt,sizeof(*icmp_136));
1155         if (icmp_136 == NULL)
1156                 return 0;
1157         r_s_o_res = ntohl(icmp_136->r_s_o_res);
1158
1159         tprintf(", R (%u) S (%u) O (%u) Reserved (0x%x)", r_s_o_res >> 31,
1160                 (r_s_o_res >> 30) & 0x1, (r_s_o_res >> 29) & 0x1,
1161                 r_s_o_res & 0x1FFFFFFF);
1162         tprintf(", Target Address: %s",
1163                         inet_ntop(AF_INET6, &icmp_136->ipv6_addr,
1164                                   address, sizeof(address)));
1165
1166         return dissect_neighb_disc_ops(pkt);
1167 }
1168
1169 static int8_t dissect_icmpv6_type137(struct pkt_buff *pkt)
1170 {
1171         char address[INET6_ADDRSTRLEN];
1172         struct icmpv6_type_137 *icmp_137;
1173
1174         icmp_137 = (struct icmpv6_type_137 *)
1175                       pkt_pull(pkt,sizeof(*icmp_137));
1176         if (icmp_137 == NULL)
1177                 return 0;
1178
1179         tprintf(", Reserved (0x%x)",icmp_137->res);
1180         tprintf(", Target Address: %s",
1181                         inet_ntop(AF_INET6, &icmp_137->ipv6_targ_addr,
1182                                   address, sizeof(address)));
1183         tprintf(", Dest Address: %s",
1184                         inet_ntop(AF_INET6, &icmp_137->ipv6_dest_addr,
1185                                   address, sizeof(address)));
1186
1187         return dissect_neighb_disc_ops(pkt);
1188 }
1189
1190 static void dissect_icmpv6_rr_body(struct pkt_buff *pkt)
1191 {
1192          /*
1193           * Upgrade Dissector for Message Body
1194           * from http://tools.ietf.org/html/rfc2894#section-3.2
1195           */
1196          if(pkt_len(pkt))
1197                 tprintf(" Message Body recognized");
1198 }
1199
1200 static inline char *icmpv6_type_138_codes(uint8_t code) {
1201         switch (code) {
1202         case   1: return "Router Renumbering Command";
1203         case   2: return "Router Renumbering Result";
1204         case 255: return "Sequence Number Reset";
1205         }
1206
1207         return NULL;
1208 };
1209
1210 static int8_t dissect_icmpv6_type138(struct pkt_buff *pkt)
1211 {
1212         struct icmpv6_type_138 *icmp_138;
1213
1214         icmp_138 = (struct icmpv6_type_138 *)
1215                       pkt_pull(pkt,sizeof(*icmp_138));
1216         if (icmp_138 == NULL)
1217                 return 0;
1218
1219         tprintf(", Sequence Nr. (%u)",ntohl(icmp_138->seq_nr));
1220         tprintf(", Segment Nr. (%u)",icmp_138->seg_nr);
1221         tprintf(", T (%u) R (%u) A (%u) S (%u) P (%u) Res \
1222                 (0x%x) ",icmp_138->flags >> 7, (icmp_138->flags >> 6) & 1,
1223                 (icmp_138->flags >> 5) & 1, (icmp_138->flags >> 4) & 1,
1224                 (icmp_138->flags >> 3) & 1, icmp_138->flags & 7);
1225         tprintf(", Max Delay (%ums)", ntohs(icmp_138->maxdelay));
1226         tprintf(", Res (0x%x)", ntohl(icmp_138->res));
1227
1228         dissect_icmpv6_rr_body(pkt);
1229
1230         return 1;
1231 }
1232
1233 static void dissect_icmpv6_node_inf_data(struct pkt_buff *pkt)
1234 {
1235          /*
1236           * Upgrade Dissector for Data field
1237           * http://tools.ietf.org/html/rfc4620#section-4
1238           */
1239          if(pkt_len(pkt))
1240                 tprintf(" Data recognized");
1241 }
1242
1243 static const char *icmpv6_node_inf_qtypes[] = {
1244         "NOOP",
1245         "unused",
1246         "Node Name",
1247         "Node Addresses",
1248         "IPv4 Addresses ",
1249 };
1250
1251 static const char *icmpv6_type_139_codes[] = {
1252         "Data contains IPv6 Address",
1253         "Data contains Name or nothing",
1254         "Data contains IPv4 Address",
1255 };
1256
1257 static int8_t dissect_icmpv6_type139(struct pkt_buff *pkt)
1258 {
1259         const char *qtype_name = "Unknown";
1260         uint16_t qtype_nr;
1261         struct icmpv6_type_139_140 *icmp_139;
1262
1263         icmp_139 = (struct icmpv6_type_139_140 *)
1264                       pkt_pull(pkt,sizeof(*icmp_139));
1265         if (icmp_139 == NULL)
1266                 return 0;
1267
1268         qtype_nr = ntohs(icmp_139->qtype);
1269         if (icmpv6_code_range_valid(qtype_nr, icmpv6_node_inf_qtypes))
1270                         qtype_name = icmpv6_node_inf_qtypes[qtype_nr];
1271
1272         tprintf(", Qtype %s (%u)", qtype_name, qtype_nr);
1273         tprintf(", Flags (0x%x)", ntohs(icmp_139->flags));
1274         tprintf(", Nonce (0x%"PRIx64")", ntohll(icmp_139->nonce));
1275
1276         dissect_icmpv6_node_inf_data(pkt);
1277
1278         return 1;
1279 }
1280
1281 static char *icmpv6_type_140_codes[] = {
1282         "Successful reply",
1283         "Responder refuses answer",
1284         "Qtype is unknown to the Responder",
1285 };
1286
1287 static inline int8_t dissect_icmpv6_type140(struct pkt_buff *pkt)
1288 {
1289         return dissect_icmpv6_type139(pkt);
1290 }
1291
1292 static inline int8_t dissect_icmpv6_type141(struct pkt_buff *pkt)
1293 {
1294         return dissect_icmpv6_type133(pkt);
1295 }
1296
1297 static inline int8_t dissect_icmpv6_type142(struct pkt_buff *pkt)
1298 {
1299         return dissect_icmpv6_type133(pkt);
1300 }
1301
1302 static int8_t dissect_icmpv6_type143(struct pkt_buff *pkt)
1303 {
1304         uint16_t nr_rec;
1305         struct icmpv6_type_143 *icmp_143;
1306
1307         icmp_143 = (struct icmpv6_type_143 *)
1308                       pkt_pull(pkt,sizeof(*icmp_143));
1309         if (icmp_143 == NULL)
1310                 return 0;
1311         nr_rec = ntohs(icmp_143->nr_rec);
1312
1313         tprintf(", Res (0x%x)",ntohs(icmp_143->res));
1314         tprintf(", Nr. Mcast Addr Records (%u)",nr_rec);
1315
1316         return dissect_icmpv6_mcast_rec(pkt, nr_rec);
1317 }
1318
1319 static int8_t dissect_icmpv6_type144(struct pkt_buff *pkt)
1320 {
1321         struct icmpv6_type_144_146 *icmp_144;
1322
1323         icmp_144 = (struct icmpv6_type_144_146 *)
1324                       pkt_pull(pkt,sizeof(*icmp_144));
1325         if (icmp_144 == NULL)
1326                 return 0;
1327
1328         tprintf(", ID (%u)",ntohs(icmp_144->id));
1329         tprintf(", Res (0x%x)",ntohs(icmp_144->res));
1330
1331         return 1;
1332 }
1333
1334 static int8_t dissect_icmpv6_type145(struct pkt_buff *pkt)
1335 {
1336         struct icmpv6_type_145 *icmp_145;
1337
1338         icmp_145 = (struct icmpv6_type_145 *)
1339                       pkt_pull(pkt,sizeof(*icmp_145));
1340         if (icmp_145 == NULL)
1341                 return 0;
1342
1343         tprintf(", ID (%u)",ntohs(icmp_145->id));
1344         tprintf(", Res (0x%x)",ntohs(icmp_145->res));
1345
1346         return print_ipv6_addr_list(pkt, pkt_len(pkt) /
1347                                         sizeof(struct in6_addr));
1348 }
1349
1350 static inline int8_t dissect_icmpv6_type146(struct pkt_buff *pkt)
1351 {
1352         return dissect_icmpv6_type144(pkt);
1353 }
1354
1355 static int8_t dissect_icmpv6_type147(struct pkt_buff *pkt)
1356 {
1357         uint16_t m_o_res;
1358         struct icmpv6_type_147 *icmp_147;
1359
1360         icmp_147 = (struct icmpv6_type_147 *)
1361                       pkt_pull(pkt,sizeof(*icmp_147));
1362         if (icmp_147 == NULL)
1363                 return 0;
1364         m_o_res = ntohs(icmp_147->m_o_res);
1365
1366         tprintf(", ID (%u)",ntohs(icmp_147->id));
1367         tprintf(", M (%u) O (%u) Res (0x%x)",m_o_res >> 15,
1368                       (m_o_res >> 14) & 1, m_o_res & 0x3FFF);
1369
1370         return dissect_neighb_disc_ops(pkt);
1371 }
1372
1373 static int8_t dissect_icmpv6_type148(struct pkt_buff *pkt)
1374 {
1375         struct icmpv6_type_148 *icmp_148;
1376
1377         icmp_148 = (struct icmpv6_type_148 *)
1378                       pkt_pull(pkt,sizeof(*icmp_148));
1379         if (icmp_148 == NULL)
1380                 return 0;
1381
1382         tprintf(", ID (%u)",ntohs(icmp_148->id));
1383         tprintf(", Component (%u)",ntohs(icmp_148->comp));
1384
1385         return dissect_neighb_disc_ops(pkt);
1386 }
1387
1388 static int8_t dissect_icmpv6_type149(struct pkt_buff *pkt)
1389 {
1390         struct icmpv6_type_149 *icmp_149;
1391
1392         icmp_149 = (struct icmpv6_type_149 *)
1393                       pkt_pull(pkt,sizeof(*icmp_149));
1394         if (icmp_149 == NULL)
1395                 return 0;
1396
1397         tprintf(", ID (%u)",ntohs(icmp_149->id));
1398         tprintf(", All Components (%u)",ntohs(icmp_149->all_comp));
1399         tprintf(", Component (%u)",ntohs(icmp_149->comp));
1400         tprintf(", Res (0x%x)",ntohs(icmp_149->res));
1401
1402         return dissect_neighb_disc_ops(pkt);
1403 }
1404
1405 static int8_t dissect_icmpv6_type150(struct pkt_buff *pkt)
1406 {
1407         struct icmpv6_type_150 *icmp_150;
1408
1409         icmp_150 = (struct icmpv6_type_150 *)
1410                       pkt_pull(pkt,sizeof(*icmp_150));
1411         if (icmp_150 == NULL)
1412                 return 0;
1413
1414         tprintf(", Subtype (%u)",icmp_150->subtype);
1415         tprintf(", Res (0x%x)",icmp_150->res);
1416         tprintf(", Options in Payload");
1417
1418         return 1;
1419 }
1420
1421 static int8_t dissect_icmpv6_type151(struct pkt_buff *pkt)
1422 {
1423         struct icmpv6_type_151 *icmp_151;
1424
1425         icmp_151 = (struct icmpv6_type_151 *)
1426                       pkt_pull(pkt,sizeof(*icmp_151));
1427         if (icmp_151 == NULL)
1428                 return 0;
1429
1430         tprintf(", Query Interval (%us)",ntohs(icmp_151->query_intv));
1431         tprintf(", Robustness Variable  (%u)",ntohs(icmp_151->rob_var));
1432
1433         return 1;
1434 }
1435
1436 static int8_t dissect_icmpv6_type152(struct pkt_buff *pkt)
1437 {
1438         struct icmpv6_type_152 *icmp_152;
1439
1440         icmp_152 = (struct icmpv6_type_152 *)
1441                       pkt_pull(pkt,sizeof(*icmp_152));
1442         if (icmp_152 == NULL)
1443                 return 0;
1444
1445         return 1;
1446 }
1447
1448 static int8_t dissect_icmpv6_type153(struct pkt_buff *pkt)
1449 {
1450         struct icmpv6_type_153 *icmp_153;
1451
1452         icmp_153 = (struct icmpv6_type_153 *)
1453                       pkt_pull(pkt,sizeof(*icmp_153));
1454         if (icmp_153 == NULL)
1455                 return 0;
1456
1457         return 1;
1458 }
1459
1460 static int8_t dissect_icmpv6_type154(struct pkt_buff *pkt)
1461 {
1462         struct icmpv6_type_154 *icmp_154;
1463
1464         icmp_154 = (struct icmpv6_type_154 *)
1465                       pkt_pull(pkt,sizeof(*icmp_154));
1466         if (icmp_154 == NULL)
1467                 return 0;
1468
1469         tprintf(", Subtype (%u)",icmp_154->subtype);
1470         tprintf(", Res (0x%x)",icmp_154->res);
1471         tprintf(", ID (%u)",ntohs(icmp_154->id));
1472
1473         return dissect_neighb_disc_ops(pkt);
1474 }
1475
1476 static inline char *icmpv6_type_155_codes(uint8_t code) {
1477         switch (code) {
1478         case 0x00: return "DODAG Information Solicitation";
1479         case 0x01: return "DODAG Information Object";
1480         case 0x02: return "Destination Advertisement Object";
1481         case 0x03: return "Destination Advertisement Object Acknowledgment";
1482         case 0x80: return "Secure DODAG Information Solicitation";
1483         case 0x81: return "Secure DODAG Information Object";
1484         case 0x82: return "Secure Destination Advertisement Object";
1485         case 0x83: return "Secure Destination Advertisement Object Acknowledgment";
1486         case 0x8A: return "Consistency Check";
1487         }
1488
1489         return NULL;
1490 };
1491
1492 static void icmpv6_process(struct icmpv6_general_hdr *icmp, const char **type,
1493                            const char **code, int8_t (**optional)(struct pkt_buff *pkt))
1494 {
1495         *type = "Unknown Type";
1496         *code = "Unknown Code";
1497
1498         switch (icmp->h_type) {
1499         case 1:
1500                 *type = "Destination Unreachable";
1501                 if (icmpv6_code_range_valid(icmp->h_code, icmpv6_type_1_codes))
1502                         *code = icmpv6_type_1_codes[icmp->h_code];
1503                 *optional = dissect_icmpv6_type1;
1504                 return;
1505         case 2:
1506                 *type = "Packet Too Big";
1507                 *optional = dissect_icmpv6_type2;
1508                 return;
1509         case 3:
1510                 *type = "Time Exceeded";
1511                 if (icmpv6_code_range_valid(icmp->h_code, icmpv6_type_3_codes))
1512                         *code = icmpv6_type_3_codes[icmp->h_code];
1513                 *optional = dissect_icmpv6_type3;
1514                 return;
1515         case 4:
1516                 *type = "Parameter Problem";
1517                 if (icmpv6_code_range_valid(icmp->h_code, icmpv6_type_4_codes))
1518                         *code = icmpv6_type_4_codes[icmp->h_code];
1519                 *optional = dissect_icmpv6_type4;
1520                 return;
1521         case 100:
1522                 *type = "Private experimation";
1523                 return;
1524         case 101:
1525                 *type = "Private experimation";
1526                 return;
1527         case 127:
1528                 *type = "Reserved for expansion of ICMPv6 error messages";
1529                 return;
1530         case 128:
1531                 *type = "Echo Request";
1532                 *optional = dissect_icmpv6_type128;
1533                 return;
1534         case 129:
1535                 *type = "Echo Reply";
1536                 *optional = dissect_icmpv6_type129;
1537                 return;
1538         case 130:
1539                 *type = "Multicast Listener Query";
1540                 *optional = dissect_icmpv6_type130;
1541                 return;
1542         case 131:
1543                 *type = "Multicast Listener Report";
1544                 *optional = dissect_icmpv6_type131;
1545                 return;
1546         case 132:
1547                 *type = "Multicast Listener Done";
1548                 *optional = dissect_icmpv6_type132;
1549                 return;
1550         case 133:
1551                 *type = "Router Solicitation";
1552                 *optional = dissect_icmpv6_type133;
1553                 return;
1554         case 134:
1555                 *type = "Router Advertisement";
1556                 *optional = dissect_icmpv6_type134;
1557                 return;
1558         case 135:
1559                 *type = "Neighbor Solicitation";
1560                 *optional = dissect_icmpv6_type135;
1561                 return;
1562         case 136:
1563                 *type = "Neighbor Advertisement";
1564                 *optional = dissect_icmpv6_type136;
1565                 return;
1566         case 137:
1567                 *type = "Redirect Message";
1568                 *optional = dissect_icmpv6_type137;
1569                 return;
1570         case 138:
1571                 *type = "Router Renumbering";
1572                 if(icmpv6_type_138_codes(icmp->h_code))
1573                         *code = icmpv6_type_138_codes(icmp->h_code);
1574                 *optional = dissect_icmpv6_type138;
1575                 return;
1576         case 139:
1577                 *type = "ICMP Node Information Query";
1578                 if (icmpv6_code_range_valid(icmp->h_code,
1579                                           icmpv6_type_139_codes))
1580                         *code = icmpv6_type_139_codes[icmp->h_code];
1581                 *optional = dissect_icmpv6_type139;
1582                 return;
1583         case 140:
1584                 *type = "ICMP Node Information Response";
1585                 if (icmpv6_code_range_valid(icmp->h_code,
1586                                           icmpv6_type_140_codes))
1587                         *code = icmpv6_type_140_codes[icmp->h_code];
1588                 *optional = dissect_icmpv6_type140;
1589                 return;
1590         case 141:
1591                 *type = "Inverse Neighbor Discovery Solicitation Message";
1592                 *optional = dissect_icmpv6_type141;
1593                 return;
1594         case 142:
1595                 *type = "Inverse Neighbor Discovery Advertisement Message";
1596                 *optional = dissect_icmpv6_type142;
1597                 return;
1598         case 143:
1599                 *type = "Multicast Listener Report v2";
1600                 *optional = dissect_icmpv6_type143;
1601                 return;
1602         case 144:
1603                 *type = "Home Agent Address Discovery Request Message";
1604                 *optional = dissect_icmpv6_type144;
1605                 return;
1606         case 145:
1607                 *type = "Home Agent Address Discovery Reply Message";
1608                 *optional = dissect_icmpv6_type145;
1609                 return;
1610         case 146:
1611                 *type = "Mobile Prefix Solicitation";
1612                 *optional = dissect_icmpv6_type146;
1613                 return;
1614         case 147:
1615                 *type = "Mobile Prefix Advertisement";
1616                 *optional = dissect_icmpv6_type147;
1617                 return;
1618         case 148:
1619                 *type = "Certification Path Solicitation";
1620                 *optional = dissect_icmpv6_type148;
1621                 return;
1622         case 149:
1623                 *type = "Certification Path Advertisement";
1624                 *optional = dissect_icmpv6_type149;
1625                 return;
1626         case 150:
1627                 *type = "ICMP messages utilized by experimental mobility "
1628                         "protocols such as Seamoby";
1629                 *optional = dissect_icmpv6_type150;
1630                 return;
1631         case 151:
1632                 *type = "Multicast Router Advertisement";
1633                 *code = "Ad. Interval";
1634                 *optional = dissect_icmpv6_type151;
1635                 return;
1636         case 152:
1637                 *type = "Multicast Router Solicitation";
1638                 *code = "Reserved";
1639                 *optional = dissect_icmpv6_type152;
1640                 return;
1641         case 153:
1642                 *type = "Multicast Router Termination";
1643                 *code = "Reserved";
1644                 *optional = dissect_icmpv6_type153;
1645                 return;
1646         case 154:
1647                 *type = "FMIPv6 Messages";
1648                 *optional = dissect_icmpv6_type154;
1649                 return;
1650         case 155:
1651                 *type = "RPL Control Message";
1652                 if(icmpv6_type_155_codes(icmp->h_code))
1653                         *code = icmpv6_type_155_codes(icmp->h_code);
1654                 return;
1655         case 200:
1656                 *type = "Private experimation";
1657                 return;
1658         case 201:
1659                 *type = "Private experimation";
1660                 return;
1661         case 255:
1662                 *type = "Reserved for expansion of ICMPv6 error messages";
1663                 return;
1664         }
1665 }
1666
1667 static void icmpv6(struct pkt_buff *pkt)
1668 {
1669         const char *type = NULL, *code = NULL;
1670         int8_t (*optional)(struct pkt_buff *pkt) = NULL;
1671         struct icmpv6_general_hdr *icmp =
1672                 (struct icmpv6_general_hdr *) pkt_pull(pkt, sizeof(*icmp));
1673
1674         if (icmp == NULL)
1675                 return;
1676
1677         icmpv6_process(icmp, &type, &code, &optional);
1678
1679         tprintf(" [ ICMPv6 ");
1680         tprintf("%s (%u), ", type, icmp->h_type);
1681         tprintf("%s (%u), ", code, icmp->h_code);
1682         tprintf("Chks (0x%x)", ntohs(icmp->h_chksum));
1683         if (optional)
1684                 if (!((*optional) (pkt)))
1685                       tprintf("\n%s%s%s", colorize_start_full(black, red),
1686                             "Failed to dissect Message", colorize_end());
1687         tprintf(" ]\n");
1688 }
1689
1690 static void icmpv6_less(struct pkt_buff *pkt)
1691 {
1692         struct icmpv6_general_hdr *icmp =
1693                 (struct icmpv6_general_hdr *) pkt_pull(pkt, sizeof(*icmp));
1694
1695         if (icmp == NULL)
1696                 return;
1697
1698         tprintf(" ICMPv6 Type (%u) Code (%u)", icmp->h_type, icmp->h_code);
1699 }
1700
1701 struct protocol icmpv6_ops = {
1702         .key = 0x3A,
1703         .print_full = icmpv6,
1704         .print_less = icmpv6_less,
1705 };