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.47 2003/12/12 21:17:54 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(find_protocol_by_id(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): %us %s", hello_opt, holdtime,
 765                                             holdtime == 0xffff ? " (infty)" : "");
 766                         break;
 767                 case 2: /* LAN prune delay
 768                          *
 769                          * 0                   1                   2                   3
 770                          * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 771                          * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 772                          * |            Type = 2           |           Length = 4          |
 773                          * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 774                          * |T|       LAN Prune Delay       |       Override Interval       |
 775                          * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 776                          */
 777                 {
 778                         proto_tree *sub_tree = NULL;
 779                         proto_item *landelay_option;
 780
 781                         landelay_option = proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 782                                                         "LAN Prune Delay (%u)", hello_opt);
 783                         sub_tree = proto_item_add_subtree(landelay_option, ett_pim);
 784
 785                         lan_delay = (opt_value & 0x7fff0000) >> 16;
 786                         override_interval = opt_value & 0x0000ffff;
 787                         proto_tree_add_text(sub_tree, tvb, offset + 4, 1,
 788                                             "T bit is %s",
 789                                             opt_value & 0x8000 ? "set" : "not set");
 790                         proto_tree_add_text(sub_tree, tvb, offset + 4, 2,
 791                                             "LAN Delay: %ums", lan_delay);
 792                         proto_tree_add_text(sub_tree, tvb, offset + 6, 2,
 793                                             "Override Interval: %ums", override_interval);
 794                         break;
 795                 }
 796                 case 19: /* priority */
 797                         priority = opt_value;
 798                         proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 799                                         "DR Priority (%u): %u", hello_opt, priority);
 800                         break;
 801                 case 20: /* generation ID */
 802                         proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 803                                             "Generation ID (%u): %d", hello_opt, opt_value);
 804                         break;
 805
 806                 case 24: /* address list */
 807                 case 65001: /* address list (old implementations) */
 808                 {
 809                         int i;
 810                         proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 811                                             "%sAddress List (%u)",
 812                                             hello_opt == 65001 ? "old " : "",
 813                                             hello_opt);
 814                         for (i = offset + 4; i < offset + 4 + opt_len; ) {
 815                                 int advance;
 816                                 const char *s;
 817
 818                                 s = dissect_pim_addr(tvb, i, pimv2_unicast, &advance);
 819                                 if (s == NULL)
 820                                         break;
 821                                 proto_tree_add_text(pimopt_tree, tvb, offset,
 822                                                     advance, "Address: %s", s);
 823                                 i += advance;
 824                         }
 825                 }
 826                 default:
 827                         proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
 828                                             "Unknown option (%u), length: %u, value: 0x%x",
 829                                             hello_opt, opt_len, opt_value);
 830                         break;
 831                 }
 832                 offset += 4 + opt_len;
 833             }
 834             break;
 835           }
 836
 837         case 1: /* register */
 838           {
 839             guint32 flags;
 840             guint8 v_hl;
 841             tvbuff_t *next_tvb;
 842             proto_tree *flag_tree = NULL;
 843             proto_item *tiflag;
 844
 845             flags = tvb_get_ntohl(tvb, offset);
 846             tiflag = proto_tree_add_text(pimopt_tree, tvb, offset, 4,
 847                 "Flags: 0x%08x", flags);
 848             flag_tree = proto_item_add_subtree(tiflag, ett_pim);
 849             proto_tree_add_text(flag_tree, tvb, offset, 1, "%s",
 850                 decode_boolean_bitfield(flags, 0x80000000, 32,
 851                     "Border", "Not border"));
 852             proto_tree_add_text(flag_tree, tvb, offset, 1, "%s",
 853                 decode_boolean_bitfield(flags, 0x40000000, 32,
 854                     "Null-Register", "Not Null-Register"));
 855             offset += 4;
 856
 857             /*
 858              * The rest of the packet is a multicast data packet.
 859              */
 860             next_tvb = tvb_new_subset(tvb, offset, -1, -1);
 861
 862             /*
 863              * It's an IP packet - determine whether it's IPv4 or IPv6.
 864              */
 865             v_hl = tvb_get_guint8(tvb, offset);
 866             switch((v_hl & 0xf0) >> 4) {
 867             case 0:     /* Null-Register dummy header.
 868                          * Has the same address family as the encapsulating PIM packet,
 869                          * e.g. an IPv6 data packet is encapsulated in IPv6 PIM packet.
 870                          */
 871                     if (pinfo->src.type == AT_IPv4) {
 872                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 873                                                 "IPv4 dummy header");
 874                             proto_tree_add_text(pimopt_tree, tvb, offset + 12, 4,
 875                                                 "Source: %s",
 876                                                 ip_to_str(tvb_get_ptr(tvb, offset + 12, 4)));
 877                             proto_tree_add_text(pimopt_tree, tvb, offset + 16, 4,
 878                                                 "Group: %s",
 879                                                 ip_to_str(tvb_get_ptr(tvb, offset + 16, 4)));
 880                     } else if (pinfo->src.type == AT_IPv6) {
 881                             struct ip6_hdr ip6_hdr;
 882                             tvb_memcpy(tvb, (guint8 *)&ip6_hdr, offset,
 883                                        sizeof ip6_hdr);
 884                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 885                                                 "IPv6 dummy header");
 886                             proto_tree_add_text(pimopt_tree, tvb,
 887                                                 offset + offsetof(struct ip6_hdr, ip6_src), 16,
 888                                                 "Source: %s",
 889                                                 ip6_to_str(&ip6_hdr.ip6_src));
 890                             proto_tree_add_text(pimopt_tree, tvb,
 891                                                 offset + offsetof(struct ip6_hdr, ip6_dst), 16,
 892                                                 "Group: %s",
 893                                                 ip6_to_str(&ip6_hdr.ip6_dst));
 894                     } else
 895                             proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 896                                                 "Dummy header for an unknown protocol");
 897                     break;
 898             case 4:     /* IPv4 */
 899 #if 0
 900                     call_dissector(ip_handle, next_tvb, pinfo, tree);
 901 #else
 902                     call_dissector(ip_handle, next_tvb, pinfo, pimopt_tree);
 903 #endif
 904                     break;
 905             case 6:     /* IPv6 */
 906 #if 0
 907                     call_dissector(ipv6_handle, next_tvb, pinfo, tree);
 908 #else
 909                     call_dissector(ipv6_handle, next_tvb, pinfo, pimopt_tree);
 910 #endif
 911                     break;
 912             default:
 913                     proto_tree_add_text(pimopt_tree, tvb, offset, -1,
 914                         "Unknown IP version %d", (v_hl & 0xf0) >> 4);
 915                     break;
 916             }
 917             break;
 918           }
 919
 920         case 2: /* register-stop */
 921           {
 922             int advance;
 923             const char *s;
 924
 925             s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
 926             if (s == NULL)
 927                 break;
 928             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Group: %s", s);
 929             offset += advance;
 930             s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
 931             if (s == NULL)
 932                 break;
 933             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Source: %s", s);
 934             break;
 935           }
 936
 937         case 3: /* join/prune */
 938         case 6: /* graft */
 939         case 7: /* graft-ack */
 940           {
 941             int advance;
 942             int off;
 943             const char *s;
 944             int ngroup, i, njoin, nprune, j;
 945             guint16 holdtime;
 946             proto_tree *grouptree = NULL;
 947             proto_item *tigroup;
 948             proto_tree *subtree = NULL;
 949             proto_item *tisub;
 950
 951             if (PIM_TYPE(pim_typever) != 7) {
 952                 /* not graft-ack */
 953                 s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
 954                 if (s == NULL)
 955                     break;
 956                 proto_tree_add_text(pimopt_tree, tvb, offset, advance,
 957                     "Upstream-neighbor: %s", s);
 958                 offset += advance;
 959             }
 960
 961             offset += 1;        /* skip reserved field */
 962
 963             ngroup = tvb_get_guint8(tvb, offset);
 964             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
 965                 "Groups: %u", ngroup);
 966             offset += 1;
 967
 968             if (PIM_TYPE(pim_typever) != 7)     {
 969                 /* not graft-ack */
 970                 holdtime = tvb_get_ntohs(tvb, offset);
 971                 proto_tree_add_text(pimopt_tree, tvb, offset, 2,
 972                     "Holdtime: %u%s", holdtime,
 973                     holdtime == 0xffff ? " (infty)" : "");
 974             }
 975             offset += 2;
 976
 977             for (i = 0; i < ngroup; i++) {
 978                 s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
 979                 if (s == NULL)
 980                     goto breakbreak3;
 981                 tigroup = proto_tree_add_text(pimopt_tree, tvb, offset, advance,
 982                     "Group %d: %s", i, s);
 983                 grouptree = proto_item_add_subtree(tigroup, ett_pim);
 984                 offset += advance;
 985
 986                 njoin = tvb_get_ntohs(tvb, offset);
 987                 nprune = tvb_get_ntohs(tvb, offset + 2);
 988
 989                 tisub = proto_tree_add_text(grouptree, tvb, offset, 2,
 990                     "Join: %d", njoin);
 991                 subtree = proto_item_add_subtree(tisub, ett_pim);
 992                 off = offset + 4;
 993                 for (j = 0; j < njoin; j++) {
 994                     s = dissect_pim_addr(tvb, off, pimv2_source,
 995                         &advance);
 996                     if (s == NULL)
 997                         goto breakbreak3;
 998                     proto_tree_add_text(subtree, tvb, off, advance,
 999                         "IP address: %s", s);
1000                     off += advance;
1001                 }
1002
1003                 tisub = proto_tree_add_text(grouptree, tvb, offset + 2, 2,
1004                     "Prune: %d", nprune);
1005                 subtree = proto_item_add_subtree(tisub, ett_pim);
1006                 for (j = 0; j < nprune; j++) {
1007                     s = dissect_pim_addr(tvb, off, pimv2_source,
1008                         &advance);
1009                     if (s == NULL)
1010                         goto breakbreak3;
1011                     proto_tree_add_text(subtree, tvb, off, advance,
1012                         "IP address: %s", s);
1013                     off += advance;
1014                 }
1015                 offset = off;
1016             }
1017     breakbreak3:
1018             break;
1019           }
1020
1021         case 4: /* bootstrap */
1022           {
1023             const char *s;
1024             int advance;
1025             int i, j;
1026             int frpcnt;
1027             guint16 holdtime;
1028             proto_tree *grouptree = NULL;
1029             proto_item *tigroup;
1030
1031             proto_tree_add_text(pimopt_tree, tvb, offset, 2,
1032                 "Fragment tag: 0x%04x", tvb_get_ntohs(tvb, offset));
1033             offset += 2;
1034
1035             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
1036                 "Hash mask len: %u", tvb_get_guint8(tvb, offset));
1037             offset += 1;
1038             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
1039                 "BSR priority: %u", tvb_get_guint8(tvb, offset));
1040             offset += 1;
1041
1042             s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
1043             if (s == NULL)
1044                 break;
1045             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "BSR: %s", s);
1046             offset += advance;
1047
1048             for (i = 0; tvb_reported_length_remaining(tvb, offset) > 0; i++) {
1049                 s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
1050                 if (s == NULL)
1051                     goto breakbreak4;
1052                 tigroup = proto_tree_add_text(pimopt_tree, tvb, offset, advance,
1053                     "Group %d: %s", i, s);
1054                 grouptree = proto_item_add_subtree(tigroup, ett_pim);
1055                 offset += advance;
1056
1057                 proto_tree_add_text(grouptree, tvb, offset, 1,
1058                     "RP count: %u", tvb_get_guint8(tvb, offset));
1059                 offset += 1;
1060                 frpcnt = tvb_get_guint8(tvb, offset);
1061                 proto_tree_add_text(grouptree, tvb, offset, 1,
1062                     "FRP count: %u", frpcnt);
1063                 offset += 3;
1064
1065                 for (j = 0; j < frpcnt; j++) {
1066                     s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
1067                     if (s == NULL)
1068                         goto breakbreak4;
1069                     proto_tree_add_text(grouptree, tvb, offset, advance,
1070                         "RP %d: %s", j, s);
1071                     offset += advance;
1072
1073                     holdtime = tvb_get_ntohs(tvb, offset);
1074                     proto_tree_add_text(grouptree, tvb, offset, 2,
1075                         "Holdtime: %u%s", holdtime,
1076                         holdtime == 0xffff ? " (infty)" : "");
1077                     offset += 2;
1078                     proto_tree_add_text(grouptree, tvb, offset, 1,
1079                         "Priority: %u", tvb_get_guint8(tvb, offset));
1080                     offset += 2;        /* also skips reserved field */
1081                 }
1082             }
1083
1084     breakbreak4:
1085             break;
1086           }
1087
1088         case 5: /* assert */
1089           {
1090             const char *s;
1091             int advance;
1092
1093             s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
1094             if (s == NULL)
1095                 break;
1096             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Group: %s", s);
1097             offset += advance;
1098
1099             s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
1100             if (s == NULL)
1101                 break;
1102             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Source: %s", s);
1103             offset += advance;
1104
1105             proto_tree_add_text(pimopt_tree, tvb, offset, 1, "%s",
1106                 decode_boolean_bitfield(tvb_get_guint8(tvb, offset), 0x80, 8,
1107                     "RP Tree", "Not RP Tree"));
1108             proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Preference: %u",
1109                 tvb_get_ntohl(tvb, offset) & 0x7fffffff);
1110             offset += 4;
1111
1112             proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Metric: %u",
1113                 tvb_get_ntohl(tvb, offset));
1114
1115             break;
1116           }
1117
1118         case 8: /* Candidate-RP-Advertisement */
1119           {
1120             const char *s;
1121             int advance;
1122             int pfxcnt;
1123             guint16 holdtime;
1124             int i;
1125
1126             pfxcnt = tvb_get_guint8(tvb, offset);
1127             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
1128                 "Prefix-count: %u", pfxcnt);
1129             offset += 1;
1130             proto_tree_add_text(pimopt_tree, tvb, offset, 1,
1131                 "Priority: %u", tvb_get_guint8(tvb, offset));
1132             offset += 1;
1133             holdtime = tvb_get_ntohs(tvb, offset);
1134             proto_tree_add_text(pimopt_tree, tvb, offset, 2,
1135                 "Holdtime: %u%s", holdtime,
1136                 holdtime == 0xffff ? " (infty)" : "");
1137             offset += 2;
1138
1139             s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
1140             if (s == NULL)
1141                 break;
1142             proto_tree_add_text(pimopt_tree, tvb, offset, advance, "RP: %s", s);
1143             offset += advance;
1144
1145             for (i = 0; i < pfxcnt; i++) {
1146                 s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
1147                 if (s == NULL)
1148                     goto breakbreak8;
1149                 proto_tree_add_text(pimopt_tree, tvb, offset, advance,
1150                     "Group %d: %s", i, s);
1151                 offset += advance;
1152             }
1153     breakbreak8:
1154             break;
1155           }
1156
1157         default:
1158             break;
1159         }
1160     }
1161 done:;
1162 }
1163
1164 void
1165 proto_register_pim(void)
1166 {
1167     static hf_register_info hf[] = {
1168       { &hf_pim_version,
1169         { "Version",            "pim.version",
1170                                 FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
1171       { &hf_pim_type,
1172         { "Type",               "pim.type",
1173                                 FT_UINT8, BASE_DEC, VALS(type2vals), 0x0, "", HFILL }},
1174       { &hf_pim_code,
1175         { "Code",               "pim.code",
1176                                 FT_UINT8, BASE_DEC, VALS(type1vals), 0x0, "", HFILL }},
1177       { &hf_pim_cksum,
1178         { "Checksum",           "pim.cksum",
1179                                 FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
1180     };
1181     static gint *ett[] = {
1182         &ett_pim,
1183     };
1184
1185     proto_pim = proto_register_protocol("Protocol Independent Multicast",
1186         "PIM", "pim");
1187     proto_register_field_array(proto_pim, hf, array_length(hf));
1188     proto_register_subtree_array(ett, array_length(ett));
1189 }
1190
1191 void
1192 proto_reg_handoff_pim(void)
1193 {
1194     dissector_handle_t pim_handle;
1195
1196     pim_handle = create_dissector_handle(dissect_pim, proto_pim);
1197     dissector_add("ip.proto", IP_PROTO_PIM, pim_handle);
1198
1199     /*
1200      * Get handles for the IPv4 and IPv6 dissectors.
1201      */
1202     ip_handle = find_dissector("ip");
1203     ipv6_handle = find_dissector("ipv6");
1204 }