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