packet-pim.c

   1 /* packet-pim.c
   2  * Routines for PIM disassembly
   3  * (c) Copyright Jun-ichiro itojun Hagino <itojun@itojun.org>
   4  *
   5  * $Id: packet-pim.c,v 1.44 2002/12/27 22:55:40 guy Exp $
   6  *
   7  * Ethereal - Network traffic analyzer
   8  * By Gerald Combs <gerald@ethereal.com>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <stddef.h>  /* For offsetof */
  31 #include <string.h>
  32 #include <glib.h>
  33
  34 #ifdef NEED_SNPRINTF_H
  35 # include "snprintf.h"
  36 #endif
  37
  38 #include <epan/packet.h>
  39 #include "ipproto.h"
  40 #include "afn.h"
  41 #include "packet-ipv6.h"
  42 #include "in_cksum.h"
  43
  44 #define PIM_TYPE(x)     ((x) & 0x0f)
  45 #define PIM_VER(x)      (((x) & 0xf0) >> 4)
  46
  47 enum pimv2_addrtype {
  48         pimv2_unicast, pimv2_group, pimv2_source
  49 };
  50
  51 static int proto_pim = -1;
  52 static int hf_pim_version = -1;
  53 static int hf_pim_type = -1;
  54 static int hf_pim_code = -1;
  55 static int hf_pim_cksum = -1;
  56
  57 static gint ett_pim = -1;
  58
  59 static dissector_handle_t ip_handle;
  60 static dissector_handle_t ipv6_handle;
  61
  62 /*
  63  * For PIM v1, see the PDF slides at
  64  *
  65  *      http://www.mbone.de/training/Module3.pdf
  66  *
  67  * Is it documented anywhere else?
  68  */
  69 static const char *
  70 dissect_pimv1_addr(tvbuff_t *tvb, int offset) {
  71     static char buf[512];
  72     guint16 flags_masklen;
  73
  74     flags_masklen = tvb_get_ntohs(tvb, offset);
  75     if (flags_masklen & 0x0180) {
  76         (void)snprintf(buf, sizeof(buf),
  77             "(%s%s%s) ",
  78             flags_masklen & 0x0100 ? "S" : "",
  79             flags_masklen & 0x0080 ? "W" : "",
  80             flags_masklen & 0x0040 ? "R" : "");
  81     } else
  82         buf[0] = '\0';
  83     (void)snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%s/%u",
  84         ip_to_str(tvb_get_ptr(tvb, offset + 2, 4)), flags_masklen & 0x3f);
  85
  86     return buf;
  87 }
  88
  89 static const value_string type1vals[] = {
  90     { 0, "Query" },
  91     { 1, "Register" },
  92     { 2, "Register-stop" },
  93     { 3, "Join/Prune" },
  94     { 4, "RP-Reachable" },
  95     { 5, "Assert" },
  96     { 6, "Graft" },
  97     { 7, "Graft-Ack" },
  98     { 8, "Mode" },
  99     { 0, NULL },
 100 };
 101
 102 /* This function is only called from the IGMP dissector */
 103 int
 104 dissect_pimv1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 105               int offset) {
 106     guint8 pim_type;
 107     guint8 pim_ver;
 108     guint length, pim_length;
 109     guint16 pim_cksum, computed_cksum;
 110     vec_t cksum_vec[1];
 111     proto_tree *pim_tree = NULL;
 112     proto_item *ti;
 113     proto_tree *pimopt_tree = NULL;
 114     proto_item *tiopt;
 115
 116     if (!proto_is_protocol_enabled(proto_pim)) {
 117         /*
 118          * We are not enabled; skip entire packet to be nice to the
 119          * IGMP layer (so clicking on IGMP will display the data).
 120          */
 121         return offset+tvb_length_remaining(tvb, offset);
 122     }
 123
 124     if (check_col(pinfo->cinfo, COL_PROTOCOL))
 125         col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIMv1");
 126     if (check_col(pinfo->cinfo, COL_INFO))
 127         col_clear(pinfo->cinfo, COL_INFO);
 128
 129     if (tree) {
 130         ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, FALSE);
 131         pim_tree = proto_item_add_subtree(ti, ett_pim);
 132
 133         /* Put IGMP type, 0x14, into the tree */
 134         proto_tree_add_text(pim_tree, tvb, offset, 1,
 135             "Type: PIM (0x14)");
 136     }
 137     offset += 1;
 138
 139     pim_type = tvb_get_guint8(tvb, offset);
 140     if (check_col(pinfo->cinfo, COL_INFO))
 141         col_add_str(pinfo->cinfo, COL_INFO,
 142             val_to_str(pim_type, type1vals, "Unknown (%u)"));
 143
 144     if (tree) {
 145         proto_tree_add_uint(pim_tree, hf_pim_code, tvb, offset, 1, pim_type);
 146     }
 147     offset += 1;
 148
 149     pim_cksum = tvb_get_ntohs(tvb, offset);
 150     pim_ver = PIM_VER(tvb_get_guint8(tvb, offset + 2));
 151     if (pim_ver != 1) {
 152         /*
 153          * Not PIMv1 - what gives?
 154          */
 155         if (tree) {
 156             proto_tree_add_uint(pim_tree, hf_pim_cksum, tvb,
 157                     offset, 2, pim_cksum);
 158         }
 159         offset += 2;
 160         if (tree)
 161             proto_tree_add_uint(pim_tree, hf_pim_version, tvb, offset, 1, pim_ver);
 162         return offset+tvb_length_remaining(tvb, offset);
 163     }
 164
 165     /*
 166      * Well, it's PIM v1, so we can check whether this is a
 167      * Register message, and thus can figure out how much to
 168      * checksum and whether to make the columns read-only.
 169      */
 170     length = tvb_length(tvb);
 171     if (pim_type == 1) {
 172         /*
 173          * Register message - the PIM header is 8 bytes long.
 174          * Also set the columns non-writable. Otherwise the IPv4 or
 175          * IPv6 dissector for the encapsulated packet that caused
 176          * this register will overwrite the PIM info in the columns.
 177          */
 178         pim_length = 8;
 179         col_set_writable(pinfo->cinfo, FALSE);
 180     } else {
 181         /*
 182          * Other message - checksum the entire packet.
 183          */
 184         pim_length = tvb_reported_length(tvb);
 185     }
 186
 187     if (tree) {
 188         if (!pinfo->fragmented && length >= pim_length) {
 189             /*
 190              * The packet isn't part of a fragmented datagram and isn't
 191              * truncated, so we can checksum it.
 192              */
 193             cksum_vec[0].ptr = tvb_get_ptr(tvb, 0, pim_length);
 194             cksum_vec[0].len = pim_length;
 195             computed_cksum = in_cksum(&cksum_vec[0], 1);
 196             if (computed_cksum == 0) {
 197                 proto_tree_add_uint_format(pim_tree, hf_pim_cksum, tvb,
 198                             offset, 2, pim_cksum,
 199                             "Checksum: 0x%04x (correct)",
 200                             pim_cksum);
 201             } else {
 202                 proto_tree_add_uint_format(pim_tree, hf_pim_cksum, tvb,
 203                             offset, 2, pim_cksum,
 204                             "Checksum: 0x%04x (incorrect, should be 0x%04x)",
 205                             pim_cksum, in_cksum_shouldbe(pim_cksum, computed_cksum));
 206             }
 207         } else {
 208             proto_tree_add_uint(pim_tree, hf_pim_cksum, tvb,
 209                     offset, 2, pim_cksum);
 210         }
 211     }
 212     offset += 2;
 213
 214     if (tree)
 215         proto_tree_add_uint(pim_tree, hf_pim_version, tvb, offset, 1, pim_ver);
 216     offset += 1;
 217
 218     offset += 3;        /* skip reserved stuff */
 219
 220     if (tree) {
 221         if (tvb_reported_length_remaining(tvb, offset) > 0) {
 222             tiopt = proto_tree_add_text(pim_tree, tvb, offset, -1,
 223                     "PIM parameters");
 224             pimopt_tree = proto_item_add_subtree(tiopt, ett_pim);
 225         } else
 226             goto done;
 227
 228         /* version 1 decoder */
 229         switch (pim_type) {
 230         case 0: /* query */
 231           {
 232             guint8 mode;
 233             guint16 holdtime;
 234             static const value_string pimv1_modevals[] = {
 235                 { 0, "Dense" },
 236                 { 1, "Sparse" },
 237                 { 2, "Sparse-Dense" },
 238                 { 0, NULL },
 239             };
 240
 241             mode = tvb_get_guint8(tvb, offset) >> 4;
 242             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
 243                 "Mode: %s",
 244                 val_to_str(mode, pimv1_modevals, "Unknown (%u)"));
 245             offset += 2;
 246             holdtime = tvb_get_ntohs(tvb, offset);
 247             proto_tree_add_text(pimopt_tree, tvb, offset, 2,
 248                 "Holdtime: %u%s", holdtime,
 249                 holdtime == 0xffff ? " (infty)" : "");
 250             offset += 2;
 251             break;
 252           }
 253
 254         case 1: /* register */
 255           {
 256             guint8 v_hl;
 257             tvbuff_t *next_tvb;
 258
 259             /*
 260              * The rest of the packet is a multicast data packet.
 261              */
 262             next_tvb = tvb_new_subset(tvb, offset, -1, -1);
 263
 264             /*
 265              * It's an IP packet - determine whether it's IPv4 or IPv6.
 266              */
 267             v_hl = tvb_get_guint8(tvb, offset);
 268             switch((v_hl & 0xf0) >> 4) {
 269             case 0:     /* Null-Register dummy header.
 270                          * Has the same address family as the encapsulating PIM packet,
 271                          * e.g. an IPv6 data packet is encapsulated in IPv6 PIM packet.
 272                          */
 273                     if (pinfo->src.type == AT_IPv4) {
 274                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 275                                                 "IPv4 dummy header");
 276                             proto_tree_add_text(pimopt_tree, tvb, offset + 12, 4,
 277                                                 "Source: %s",
 278                                                 ip_to_str(tvb_get_ptr(tvb, offset + 12, 4)));
 279                             proto_tree_add_text(pimopt_tree, tvb, offset + 16, 4,
 280                                                 "Group: %s",
 281                                                 ip_to_str(tvb_get_ptr(tvb, offset + 16, 4)));
 282                     } else if (pinfo->src.type == AT_IPv6) {
 283                             struct ip6_hdr ip6_hdr;
 284                             tvb_memcpy(tvb, (guint8 *)&ip6_hdr, offset,
 285                                        sizeof ip6_hdr);
 286                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 287                                                 "IPv6 dummy header");
 288                             proto_tree_add_text(pimopt_tree, tvb,
 289                                                 offset + offsetof(struct ip6_hdr, ip6_src), 16,
 290                                                 "Source: %s",
 291                                                 ip6_to_str(&ip6_hdr.ip6_src));
 292                             proto_tree_add_text(pimopt_tree, tvb,
 293                                                 offset + offsetof(struct ip6_hdr, ip6_dst), 16,
 294                                                 "Group: %s",
 295                                                 ip6_to_str(&ip6_hdr.ip6_dst));
 296                     } else
 297                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 298                                                 "Dummy header for an unknown protocol");
 299                     break;
 300             case 4:     /* IPv4 */
 301 #if 0
 302                     call_dissector(ip_handle, next_tvb, pinfo, tree);
 303 #else
 304                     call_dissector(ip_handle, next_tvb, pinfo, pimopt_tree);
 305 #endif
 306                     break;
 307             case 6:     /* IPv6 */
 308 #if 0
 309                     call_dissector(ipv6_handle, next_tvb, pinfo, tree);
 310 #else
 311                     call_dissector(ipv6_handle, next_tvb, pinfo, pimopt_tree);
 312 #endif
 313                     break;
 314             default:
 315                     proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 316                         "Unknown IP version %d", (v_hl & 0xf0) >> 4);
 317                     break;
 318             }
 319             break;
 320           }
 321
 322         case 2: /* register-stop */
 323           {
 324             proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 325                 "Group: %s",
 326                 ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 327             offset += 4;
 328             proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 329                 "Source: %s",
 330                 ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 331             offset += 4;
 332             break;
 333           }
 334
 335         case 3: /* join/prune */
 336         case 6: /* graft */
 337         case 7: /* graft-ack */
 338           {
 339             int off;
 340             const char *s;
 341             int ngroup, i, njoin, nprune, j;
 342             guint16 holdtime;
 343             guint8 mask_len;
 344             guint8 adr_len;
 345             proto_tree *grouptree = NULL;
 346             proto_item *tigroup;
 347             proto_tree *subtree = NULL;
 348             proto_item *tisub;
 349
 350             proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 351                 "Upstream-neighbor: %s",
 352                 ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 353             offset += 4;
 354
 355             offset += 2;        /* skip reserved stuff */
 356
 357             holdtime = tvb_get_ntohs(tvb, offset);
 358             proto_tree_add_text(pimopt_tree, tvb, offset, 2,
 359                 "Holdtime: %u%s", holdtime,
 360                 holdtime == 0xffff ? " (infty)" : "");
 361             offset += 2;
 362
 363             offset += 1;        /* skip reserved stuff */
 364
 365             mask_len = tvb_get_guint8(tvb, offset);
 366             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
 367                 "Mask length: %u", mask_len);
 368             offset += 1;
 369
 370             adr_len = tvb_get_guint8(tvb, offset);
 371             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
 372                 "Address length: %u", adr_len);
 373             offset += 1;
 374
 375             ngroup = tvb_get_guint8(tvb, offset);
 376             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
 377                 "Groups: %u", ngroup);
 378             offset += 1;
 379
 380             for (i = 0; i < ngroup; i++) {
 381                 tigroup = proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 382                     "Group %d: %s", i,
 383                     ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 384                 grouptree = proto_item_add_subtree(tigroup, ett_pim);
 385                 offset += 4;
 386
 387                 proto_tree_add_text(grouptree, tvb, offset, 4,
 388                     "Group %d Mask: %s", i,
 389                     ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 390                 offset += 4;
 391
 392                 njoin = tvb_get_ntohs(tvb, offset);
 393                 nprune = tvb_get_ntohs(tvb, offset + 2);
 394
 395                 tisub = proto_tree_add_text(grouptree, tvb, offset, 2,
 396                     "Join: %d", njoin);
 397                 subtree = proto_item_add_subtree(tisub, ett_pim);
 398                 off = offset + 4;
 399                 for (j = 0; j < njoin; j++) {
 400                     s = dissect_pimv1_addr(tvb, off);
 401                     proto_tree_add_text(subtree, tvb, off, 6,
 402                         "IP address: %s", s);
 403                     off += 6;
 404                 }
 405
 406                 tisub = proto_tree_add_text(grouptree, tvb, offset + 2, 2,
 407                     "Prune: %d", nprune);
 408                 subtree = proto_item_add_subtree(tisub, ett_pim);
 409                 for (j = 0; j < nprune; j++) {
 410                     s = dissect_pimv1_addr(tvb, off);
 411                     proto_tree_add_text(subtree, tvb, off, 6,
 412                         "IP address: %s", s);
 413                     off += 6;
 414                 }
 415                 offset = off;
 416             }
 417             break;
 418           }
 419
 420         case 4: /* rp-reachability */
 421           {
 422             guint16 holdtime;
 423
 424             proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 425                 "Group Address: %s",
 426                 ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 427             offset += 4;
 428
 429             proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 430                 "Group Mask: %s",
 431                 ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 432             offset += 4;
 433
 434             proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 435                 "RP Address: %s",
 436                 ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 437             offset += 4;
 438
 439             offset += 2;        /* skip reserved stuff */
 440
 441             holdtime = tvb_get_ntohs(tvb, offset);
 442             proto_tree_add_text(pimopt_tree, tvb, offset, 2,
 443                 "Holdtime: %u%s", holdtime,
 444                 holdtime == 0xffff ? " (infty)" : "");
 445             offset += 2;
 446             break;
 447           }
 448
 449         case 5: /* assert */
 450           {
 451             proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 452                 "Group Address: %s",
 453                 ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 454             offset += 4;
 455
 456             proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 457                 "Group Mask: %s",
 458                 ip_to_str(tvb_get_ptr(tvb, offset, 4)));
 459             offset += 4;
 460
 461             proto_tree_add_text(pimopt_tree, tvb, offset, 1, "%s",
 462                 decode_boolean_bitfield(tvb_get_guint8(tvb, offset), 0x80, 8,
 463                     "RP Tree", "Not RP Tree"));
 464             proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Preference: %u",
 465                 tvb_get_ntohl(tvb, offset) & 0x7fffffff);
 466             offset += 4;
 467
 468             proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Metric: %u",
 469                 tvb_get_ntohl(tvb, offset));
 470
 471             break;
 472           }
 473
 474         default:
 475             break;
 476         }
 477     }
 478 done:;
 479
 480     return offset+tvb_length_remaining(tvb, offset);
 481 }
 482
 483 static const char *
 484 dissect_pim_addr(tvbuff_t *tvb, int offset, enum pimv2_addrtype at,
 485         int *advance) {
 486     static char buf[512];
 487     guint8 af;
 488     guint8 et;
 489     guint8 flags;
 490     guint8 mask_len;
 491     int len = 0;
 492
 493     af = tvb_get_guint8(tvb, offset);
 494     if (af != AFNUM_INET && af != AFNUM_INET6) {
 495         /*
 496          * We don't handle the other formats, and addresses don't include
 497          * a length field, so we can't even show them as raw bytes.
 498          */
 499         return NULL;
 500     }
 501
 502     et = tvb_get_guint8(tvb, offset + 1);
 503     if (et != 0) {
 504         /*
 505          * The only defined encoding type is 0, for the native encoding;
 506          * again, as addresses don't include a length field, we can't
 507          * even show addresses with a different encoding type as raw
 508          * bytes.
 509          */
 510         return NULL;
 511     }
 512
 513     switch (at) {
 514     case pimv2_unicast:
 515         switch (af) {
 516         case AFNUM_INET:
 517             len = 4;
 518             (void)snprintf(buf, sizeof(buf), "%s",
 519                 ip_to_str(tvb_get_ptr(tvb, offset + 2, len)));
 520             break;
 521
 522         case AFNUM_INET6:
 523             len = 16;
 524             (void)snprintf(buf, sizeof(buf), "%s",
 525                 ip6_to_str((const struct e_in6_addr *)tvb_get_ptr(tvb, offset + 2, len)));
 526             break;
 527         }
 528         if (advance)
 529             *advance = 2 + len;
 530         break;
 531
 532     case pimv2_group:
 533         mask_len = tvb_get_guint8(tvb, offset + 3);
 534         switch (af) {
 535         case AFNUM_INET:
 536             len = 4;
 537             (void)snprintf(buf, sizeof(buf), "%s/%u",
 538                 ip_to_str(tvb_get_ptr(tvb, offset + 4, len)), mask_len);
 539             break;
 540
 541         case AFNUM_INET6:
 542             len = 16;
 543             (void)snprintf(buf, sizeof(buf), "%s/%u",
 544                 ip6_to_str((const struct e_in6_addr *)tvb_get_ptr(tvb, offset + 4, len)), mask_len);
 545             break;
 546         }
 547         if (advance)
 548             *advance = 4 + len;
 549         break;
 550
 551     case pimv2_source:
 552         flags = tvb_get_guint8(tvb, offset + 2);
 553         mask_len = tvb_get_guint8(tvb, offset + 3);
 554         switch (af) {
 555         case AFNUM_INET:
 556             len = 4;
 557             (void)snprintf(buf, sizeof(buf), "%s/%u",
 558                 ip_to_str(tvb_get_ptr(tvb, offset + 4, len)), mask_len);
 559             break;
 560
 561         case AFNUM_INET6:
 562             len = 16;
 563             (void)snprintf(buf, sizeof(buf), "%s/%u",
 564                 ip6_to_str((const struct e_in6_addr *)tvb_get_ptr(tvb, offset + 4, len)), mask_len);
 565             break;
 566         }
 567         if (flags) {
 568             (void)snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 569                 " (%s%s%s)",
 570                 flags & 0x04 ? "S" : "",
 571                 flags & 0x02 ? "W" : "",
 572                 flags & 0x01 ? "R" : "");
 573         }
 574         if (advance)
 575             *advance = 4 + len;
 576         break;
 577     default:
 578         return NULL;
 579     }
 580
 581     return buf;
 582 }
 583
 584 static const value_string type2vals[] = {
 585     { 0, "Hello" },
 586     { 1, "Register" },
 587     { 2, "Register-stop" },
 588     { 3, "Join/Prune" },
 589     { 4, "Bootstrap" },
 590     { 5, "Assert" },
 591     { 6, "Graft" },
 592     { 7, "Graft-Ack" },
 593     { 8, "Candidate-RP-Advertisement" },
 594     { 0, NULL },
 595 };
 596
 597 /*
 598  * For PIM v2, see RFC 2362, and draft-ietf-pim-sm-v2-new-03 (when PIM
 599  * is run over IPv6, the rules for computing the PIM checksum from the
 600  * draft in question, not from RFC 2362, should be used).
 601  */
 602 static void
 603 dissect_pim(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
 604     int offset = 0;
 605     guint8 pim_typever;
 606     guint length, pim_length;
 607     guint16 pim_cksum, computed_cksum;
 608     vec_t cksum_vec[4];
 609     guint32 phdr[2];
 610     char *typestr;
 611     proto_tree *pim_tree = NULL;
 612     proto_item *ti;
 613     proto_tree *pimopt_tree = NULL;
 614     proto_item *tiopt;
 615
 616     if (check_col(pinfo->cinfo, COL_PROTOCOL))
 617         col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIM");
 618     if (check_col(pinfo->cinfo, COL_INFO))
 619         col_clear(pinfo->cinfo, COL_INFO);
 620
 621     pim_typever = tvb_get_guint8(tvb, 0);
 622
 623     switch (PIM_VER(pim_typever)) {
 624     case 2:
 625         typestr = val_to_str(PIM_TYPE(pim_typever), type2vals, "Unknown (%u)");
 626         break;
 627     case 1:     /* PIMv1 - we should never see this */
 628     default:
 629         typestr = "Unknown";
 630         break;
 631     }
 632
 633     if (check_col(pinfo->cinfo, COL_PROTOCOL)) {
 634         col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "PIMv%d",
 635             PIM_VER(pim_typever));
 636     }
 637     if (check_col(pinfo->cinfo, COL_INFO))
 638         col_add_str(pinfo->cinfo, COL_INFO, typestr);
 639
 640     if (tree) {
 641         ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, FALSE);
 642         pim_tree = proto_item_add_subtree(ti, ett_pim);
 643
 644         proto_tree_add_uint(pim_tree, hf_pim_version, tvb, offset, 1,
 645             PIM_VER(pim_typever));
 646         proto_tree_add_uint(pim_tree, hf_pim_type, tvb, offset, 1,
 647             PIM_TYPE(pim_typever));
 648
 649         pim_cksum = tvb_get_ntohs(tvb, offset + 2);
 650         length = tvb_length(tvb);
 651         if (PIM_VER(pim_typever) == 2) {
 652             /*
 653              * Well, it's PIM v2, so we can check whether this is a Register
 654              * message, and thus can figure out how much to checksum and
 655              * whether to make the columns read-only.
 656              */
 657             if (PIM_TYPE(pim_typever) == 1) {
 658                 /*
 659                  * Register message - the PIM header is 8 bytes long.
 660                  * Also set the columns non-writable. Otherwise the IPv4 or
 661                  * IPv6 dissector for the encapsulated packet that caused
 662                  * this register will overwrite the PIM info in the columns.
 663                  */
 664                 pim_length = 8;
 665                 col_set_writable(pinfo->cinfo, FALSE);
 666             } else {
 667                 /*
 668                  * Other message - checksum the entire packet.
 669                  */
 670                 pim_length = tvb_reported_length(tvb);
 671             }
 672         } else {
 673             /*
 674              * We don't know what type of message this is, so say that
 675              * the length is 0, to force it not to be checksummed.
 676              */
 677             pim_length = 0;
 678         }
 679         if (!pinfo->fragmented && length >= pim_length) {
 680             /*
 681              * The packet isn't part of a fragmented datagram and isn't
 682              * truncated, so we can checksum it.
 683              */
 684
 685             switch (pinfo->src.type) {
 686             case AT_IPv4:
 687                 cksum_vec[0].ptr = tvb_get_ptr(tvb, 0, pim_length);
 688                 cksum_vec[0].len = pim_length;
 689                 computed_cksum = in_cksum(&cksum_vec[0], 1);
 690                 break;
 691             case AT_IPv6:
 692                 /* Set up the fields of the pseudo-header. */
 693                 cksum_vec[0].ptr = pinfo->src.data;
 694                 cksum_vec[0].len = pinfo->src.len;
 695                 cksum_vec[1].ptr = pinfo->dst.data;
 696                 cksum_vec[1].len = pinfo->dst.len;
 697                 cksum_vec[2].ptr = (const guint8 *)&phdr;
 698                 phdr[0] = g_htonl(pim_length);
 699                 phdr[1] = g_htonl(IP_PROTO_PIM);
 700                 cksum_vec[2].len = 8;
 701                 cksum_vec[3].ptr = tvb_get_ptr(tvb, 0, pim_length);
 702                 cksum_vec[3].len = pim_length;
 703                 computed_cksum = in_cksum(&cksum_vec[0], 4);
 704                 break;
 705             default:
 706                 /* PIM is available for IPv4 and IPv6 right now */
 707                 computed_cksum = 0;     /* squelch GCC complaints */
 708                 g_assert_not_reached();
 709                 break;
 710             }
 711
 712             if (computed_cksum == 0) {
 713                 proto_tree_add_uint_format(pim_tree, hf_pim_cksum, tvb,
 714                         offset + 2, 2, pim_cksum,
 715                         "Checksum: 0x%04x (correct)",
 716                         pim_cksum);
 717             } else {
 718                 proto_tree_add_uint_format(pim_tree, hf_pim_cksum, tvb,
 719                         offset + 2, 2, pim_cksum,
 720                         "Checksum: 0x%04x (incorrect, should be 0x%04x)",
 721                         pim_cksum, in_cksum_shouldbe(pim_cksum, computed_cksum));
 722             }
 723         } else {
 724             proto_tree_add_uint(pim_tree, hf_pim_cksum, tvb,
 725                 offset + 2, 2, pim_cksum);
 726         }
 727
 728         offset += 4;
 729
 730         if (tvb_reported_length_remaining(tvb, offset) > 0) {
 731             tiopt = proto_tree_add_text(pim_tree, tvb, offset, -1,
 732                 "PIM parameters");
 733             pimopt_tree = proto_item_add_subtree(tiopt, ett_pim);
 734         } else
 735             goto done;
 736
 737         if (PIM_VER(pim_typever) != 2)
 738             goto done;
 739
 740         /* version 2 decoder */
 741         switch (PIM_TYPE(pim_typever)) {
 742         case 0: /*hello*/
 743           {
 744             while (tvb_reported_length_remaining(tvb, offset) >= 2) {
 745                 guint16 hello_opt, opt_len;
 746                 guint16 holdtime;
 747                 guint16 lan_delay;
 748                 guint16 override_interval;
 749                 guint32 priority;
 750                 guint32 opt_value = 0;
 751
 752                 hello_opt = tvb_get_ntohs(tvb, offset);
 753                 opt_len = tvb_get_ntohs(tvb, offset + 2);
 754
 755                 if(opt_len == 2)
 756                         opt_value = tvb_get_ntohs(tvb, offset + 4);
 757                 if(opt_len == 4)
 758                         opt_value = tvb_get_ntohl(tvb, offset + 4);
 759
 760                 switch(hello_opt) {
 761                 case 1: /* holdtime */
 762                         holdtime = opt_value;
 763                         proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 764                                             "Holdtime: %u%s", holdtime,
 765                                             holdtime == 0xffff ? " (infty)" : "");
 766                         break;
 767                 case 2: /* LAN prune delay */
 768                 {
 769                         proto_tree *sub_tree = NULL;
 770                         proto_item *landelay_option;
 771
 772                         landelay_option = proto_tree_add_text(pim_tree, tvb, offset, -1,
 773                                                         "LAN Prune Delay");
 774                         sub_tree = proto_item_add_subtree(landelay_option, ett_pim);
 775
 776                         lan_delay = (opt_value & 0x7f00) >> 8;
 777                         override_interval = opt_value & 0xff;
 778                         proto_tree_add_text(sub_tree, tvb, offset, 4 + opt_len,
 779                                             "T bit is %s",
 780                                             opt_value & 0x8000 ? "set" : "not set");
 781                         proto_tree_add_text(sub_tree, tvb, offset, 4 + opt_len,
 782                                             "LAN Delay:  %u", lan_delay);
 783                         proto_tree_add_text(sub_tree, tvb, offset, 4 + opt_len,
 784                                             "Override Interval:  %u", override_interval);
 785                         break;
 786                 }
 787                 case 19: /* priority */
 788                         priority = opt_value;
 789                         proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 790                                         "DR Priority: %u", priority);
 791                         break;
 792                 case 20: /* generation ID */
 793                         proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 794                                             "Generation ID: %d", opt_value);
 795                         break;
 796
 797                 default:
 798                         proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 799                                             "Unknown option: %d  len: %d  value: 0x%x",
 800                                             hello_opt, opt_len, opt_value);
 801                         break;
 802                 }
 803                 offset += 4 + opt_len;
 804             }
 805             break;
 806           }
 807
 808         case 1: /* register */
 809           {
 810             guint32 flags;
 811             guint8 v_hl;
 812             tvbuff_t *next_tvb;
 813             proto_tree *flag_tree = NULL;
 814             proto_item *tiflag;
 815
 816             flags = tvb_get_ntohl(tvb, offset);
 817             tiflag = proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 818                 "Flags: 0x%08x", flags);
 819             flag_tree = proto_item_add_subtree(tiflag, ett_pim);
 820             proto_tree_add_text(flag_tree, tvb, offset, 1, "%s",
 821                 decode_boolean_bitfield(flags, 0x80000000, 32,
 822                     "Border", "Not border"));
 823             proto_tree_add_text(flag_tree, tvb, offset, 1, "%s",
 824                 decode_boolean_bitfield(flags, 0x40000000, 32,
 825                     "Null-Register", "Not Null-Register"));
 826             offset += 4;
 827
 828             /*
 829              * The rest of the packet is a multicast data packet.
 830              */
 831             next_tvb = tvb_new_subset(tvb, offset, -1, -1);
 832
 833             /*
 834              * It's an IP packet - determine whether it's IPv4 or IPv6.
 835              */
 836             v_hl = tvb_get_guint8(tvb, offset);
 837             switch((v_hl & 0xf0) >> 4) {
 838             case 0:     /* Null-Register dummy header.
 839                          * Has the same address family as the encapsulating PIM packet,
 840                          * e.g. an IPv6 data packet is encapsulated in IPv6 PIM packet.
 841                          */
 842                     if (pinfo->src.type == AT_IPv4) {
 843                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 844                                                 "IPv4 dummy header");
 845                             proto_tree_add_text(pimopt_tree, tvb, offset + 12, 4,
 846                                                 "Source: %s",
 847                                                 ip_to_str(tvb_get_ptr(tvb, offset + 12, 4)));
 848                             proto_tree_add_text(pimopt_tree, tvb, offset + 16, 4,
 849                                                 "Group: %s",
 850                                                 ip_to_str(tvb_get_ptr(tvb, offset + 16, 4)));
 851                     } else if (pinfo->src.type == AT_IPv6) {
 852                             struct ip6_hdr ip6_hdr;
 853                             tvb_memcpy(tvb, (guint8 *)&ip6_hdr, offset,
 854                                        sizeof ip6_hdr);
 855                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 856                                                 "IPv6 dummy header");
 857                             proto_tree_add_text(pimopt_tree, tvb,
 858                                                 offset + offsetof(struct ip6_hdr, ip6_src), 16,
 859                                                 "Source: %s",
 860                                                 ip6_to_str(&ip6_hdr.ip6_src));
 861                             proto_tree_add_text(pimopt_tree, tvb,
 862                                                 offset + offsetof(struct ip6_hdr, ip6_dst), 16,
 863                                                 "Group: %s",
 864                                                 ip6_to_str(&ip6_hdr.ip6_dst));
 865                     } else
 866                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 867                                                 "Dummy header for an unknown protocol");
 868                     break;
 869             case 4:     /* IPv4 */
 870 #if 0
 871                     call_dissector(ip_handle, next_tvb, pinfo, tree);
 872 #else
 873                     call_dissector(ip_handle, next_tvb, pinfo, pimopt_tree);
 874 #endif
 875                     break;
 876             case 6:     /* IPv6 */
 877 #if 0
 878                     call_dissector(ipv6_handle, next_tvb, pinfo, tree);
 879 #else
 880                     call_dissector(ipv6_handle, next_tvb, pinfo, pimopt_tree);
 881 #endif
 882                     break;
 883             default:
 884                     proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 885                         "Unknown IP version %d", (v_hl & 0xf0) >> 4);
 886                     break;
 887             }
 888             break;
 889           }
 890
 891         case 2: /* register-stop */
 892           {
 893             int advance;
 894             const char *s;
 895
 896             s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
 897             if (s == NULL)
 898                 break;
 899             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Group: %s", s);
 900             offset += advance;
 901             s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
 902             if (s == NULL)
 903                 break;
 904             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Source: %s", s);
 905             break;
 906           }
 907
 908         case 3: /* join/prune */
 909         case 6: /* graft */
 910         case 7: /* graft-ack */
 911           {
 912             int advance;
 913             int off;
 914             const char *s;
 915             int ngroup, i, njoin, nprune, j;
 916             guint16 holdtime;
 917             proto_tree *grouptree = NULL;
 918             proto_item *tigroup;
 919             proto_tree *subtree = NULL;
 920             proto_item *tisub;
 921
 922             if (PIM_TYPE(pim_typever) != 7) {
 923                 /* not graft-ack */
 924                 s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
 925                 if (s == NULL)
 926                     break;
 927                 proto_tree_add_text(pimopt_tree, tvb, offset, advance,
 928                     "Upstream-neighbor: %s", s);
 929                 offset += advance;
 930             }
 931
 932             offset += 1;        /* skip reserved field */
 933
 934             ngroup = tvb_get_guint8(tvb, offset);
 935             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
 936                 "Groups: %u", ngroup);
 937             offset += 1;
 938
 939             if (PIM_TYPE(pim_typever) != 7)     {
 940                 /* not graft-ack */
 941                 holdtime = tvb_get_ntohs(tvb, offset);
 942                 proto_tree_add_text(pimopt_tree, tvb, offset, 2,
 943                     "Holdtime: %u%s", holdtime,
 944                     holdtime == 0xffff ? " (infty)" : "");
 945             }
 946             offset += 2;
 947
 948             for (i = 0; i < ngroup; i++) {
 949                 s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
 950                 if (s == NULL)
 951                     goto breakbreak3;
 952                 tigroup = proto_tree_add_text(pimopt_tree, tvb, offset, advance,
 953                     "Group %d: %s", i, s);
 954                 grouptree = proto_item_add_subtree(tigroup, ett_pim);
 955                 offset += advance;
 956
 957                 njoin = tvb_get_ntohs(tvb, offset);
 958                 nprune = tvb_get_ntohs(tvb, offset + 2);
 959
 960                 tisub = proto_tree_add_text(grouptree, tvb, offset, 2,
 961                     "Join: %d", njoin);
 962                 subtree = proto_item_add_subtree(tisub, ett_pim);
 963                 off = offset + 4;
 964                 for (j = 0; j < njoin; j++) {
 965                     s = dissect_pim_addr(tvb, off, pimv2_source,
 966                         &advance);
 967                     if (s == NULL)
 968                         goto breakbreak3;
 969                     proto_tree_add_text(subtree, tvb, off, advance,
 970                         "IP address: %s", s);
 971                     off += advance;
 972                 }
 973
 974                 tisub = proto_tree_add_text(grouptree, tvb, offset + 2, 2,
 975                     "Prune: %d", nprune);
 976                 subtree = proto_item_add_subtree(tisub, ett_pim);
 977                 for (j = 0; j < nprune; j++) {
 978                     s = dissect_pim_addr(tvb, off, pimv2_source,
 979                         &advance);
 980                     if (s == NULL)
 981                         goto breakbreak3;
 982                     proto_tree_add_text(subtree, tvb, off, advance,
 983                         "IP address: %s", s);
 984                     off += advance;
 985                 }
 986                 offset = off;
 987             }
 988     breakbreak3:
 989             break;
 990           }
 991
 992         case 4: /* bootstrap */
 993           {
 994             const char *s;
 995             int advance;
 996             int i, j;
 997             int frpcnt;
 998             guint16 holdtime;
 999             proto_tree *grouptree = NULL;
1000             proto_item *tigroup;
1001
1002             proto_tree_add_text(pimopt_tree, tvb, offset, 2,
1003                 "Fragment tag: 0x%04x", tvb_get_ntohs(tvb, offset));
1004             offset += 2;
1005
1006             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
1007                 "Hash mask len: %u", tvb_get_guint8(tvb, offset));
1008             offset += 1;
1009             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
1010                 "BSR priority: %u", tvb_get_guint8(tvb, offset));
1011             offset += 1;
1012
1013             s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
1014             if (s == NULL)
1015                 break;
1016             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "BSR: %s", s);
1017             offset += advance;
1018
1019             for (i = 0; tvb_reported_length_remaining(tvb, offset) > 0; i++) {
1020                 s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
1021                 if (s == NULL)
1022                     goto breakbreak4;
1023                 tigroup = proto_tree_add_text(pimopt_tree, tvb, offset, advance,
1024                     "Group %d: %s", i, s);
1025                 grouptree = proto_item_add_subtree(tigroup, ett_pim);
1026                 offset += advance;
1027
1028                 proto_tree_add_text(grouptree, tvb, offset, 1,
1029                     "RP count: %u", tvb_get_guint8(tvb, offset));
1030                 offset += 1;
1031                 frpcnt = tvb_get_guint8(tvb, offset);
1032                 proto_tree_add_text(grouptree, tvb, offset, 1,
1033                     "FRP count: %u", frpcnt);
1034                 offset += 3;
1035
1036                 for (j = 0; j < frpcnt; j++) {
1037                     s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
1038                     if (s == NULL)
1039                         goto breakbreak4;
1040                     proto_tree_add_text(grouptree, tvb, offset, advance,
1041                         "RP %d: %s", j, s);
1042                     offset += advance;
1043
1044                     holdtime = tvb_get_ntohs(tvb, offset);
1045                     proto_tree_add_text(grouptree, tvb, offset, 2,
1046                         "Holdtime: %u%s", holdtime,
1047                         holdtime == 0xffff ? " (infty)" : "");
1048                     offset += 2;
1049                     proto_tree_add_text(grouptree, tvb, offset, 1,
1050                         "Priority: %u", tvb_get_guint8(tvb, offset));
1051                     offset += 2;        /* also skips reserved field */
1052                 }
1053             }
1054
1055     breakbreak4:
1056             break;
1057           }
1058
1059         case 5: /* assert */
1060           {
1061             const char *s;
1062             int advance;
1063
1064             s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
1065             if (s == NULL)
1066                 break;
1067             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Group: %s", s);
1068             offset += advance;
1069
1070             s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
1071             if (s == NULL)
1072                 break;
1073             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Source: %s", s);
1074             offset += advance;
1075
1076             proto_tree_add_text(pimopt_tree, tvb, offset, 1, "%s",
1077                 decode_boolean_bitfield(tvb_get_guint8(tvb, offset), 0x80, 8,
1078                     "RP Tree", "Not RP Tree"));
1079             proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Preference: %u",
1080                 tvb_get_ntohl(tvb, offset) & 0x7fffffff);
1081             offset += 4;
1082
1083             proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Metric: %u",
1084                 tvb_get_ntohl(tvb, offset));
1085
1086             break;
1087           }
1088
1089         case 8: /* Candidate-RP-Advertisement */
1090           {
1091             const char *s;
1092             int advance;
1093             int pfxcnt;
1094             guint16 holdtime;
1095             int i;
1096
1097             pfxcnt = tvb_get_guint8(tvb, offset);
1098             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
1099                 "Prefix-count: %u", pfxcnt);
1100             offset += 1;
1101             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
1102                 "Priority: %u", tvb_get_guint8(tvb, offset));
1103             offset += 1;
1104             holdtime = tvb_get_ntohs(tvb, offset);
1105             proto_tree_add_text(pimopt_tree, tvb, offset, 2,
1106                 "Holdtime: %u%s", holdtime,
1107                 holdtime == 0xffff ? " (infty)" : "");
1108             offset += 2;
1109
1110             s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
1111             if (s == NULL)
1112                 break;
1113             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "RP: %s", s);
1114             offset += advance;
1115
1116             for (i = 0; i < pfxcnt; i++) {
1117                 s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
1118                 if (s == NULL)
1119                     goto breakbreak8;
1120                 proto_tree_add_text(pimopt_tree, tvb, offset, advance,
1121                     "Group %d: %s", i, s);
1122                 offset += advance;
1123             }
1124     breakbreak8:
1125             break;
1126           }
1127
1128         default:
1129             break;
1130         }
1131     }
1132 done:;
1133 }
1134
1135 void
1136 proto_register_pim(void)
1137 {
1138     static hf_register_info hf[] = {
1139       { &hf_pim_version,
1140         { "Version",            "pim.version",
1141                                 FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
1142       { &hf_pim_type,
1143         { "Type",               "pim.type",
1144                                 FT_UINT8, BASE_DEC, VALS(type2vals), 0x0, "", HFILL }},
1145       { &hf_pim_code,
1146         { "Code",               "pim.code",
1147                                 FT_UINT8, BASE_DEC, VALS(type1vals), 0x0, "", HFILL }},
1148       { &hf_pim_cksum,
1149         { "Checksum",           "pim.cksum",
1150                                 FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
1151     };
1152     static gint *ett[] = {
1153         &ett_pim,
1154     };
1155
1156     proto_pim = proto_register_protocol("Protocol Independent Multicast",
1157         "PIM", "pim");
1158     proto_register_field_array(proto_pim, hf, array_length(hf));
1159     proto_register_subtree_array(ett, array_length(ett));
1160 }
1161
1162 void
1163 proto_reg_handoff_pim(void)
1164 {
1165     dissector_handle_t pim_handle;
1166
1167     pim_handle = create_dissector_handle(dissect_pim, proto_pim);
1168     dissector_add("ip.proto", IP_PROTO_PIM, pim_handle);
1169
1170     /*
1171      * Get handles for the IPv4 and IPv6 dissectors.
1172      */
1173     ip_handle = find_dissector("ip");
1174     ipv6_handle = find_dissector("ipv6");
1175 }