1999-10-13 06:47:49 +00:00
|
|
|
/* packet-pim.c
|
|
|
|
* Routines for PIM disassembly
|
|
|
|
* (c) Copyright Jun-ichiro itojun Hagino <itojun@itojun.org>
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
1999-10-13 06:47:49 +00:00
|
|
|
*
|
|
|
|
* Ethereal - Network traffic analyzer
|
2001-04-23 17:51:37 +00:00
|
|
|
* By Gerald Combs <gerald@ethereal.com>
|
1999-10-13 06:47:49 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-10-13 06:47:49 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-10-13 06:47:49 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-10-13 06:47:49 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
2000-08-11 13:37:21 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
2000-08-11 13:37:21 +00:00
|
|
|
# include "config.h"
|
|
|
|
#endif
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-05-07 20:26:25 +00:00
|
|
|
#include <stddef.h> /* For offsetof */
|
2000-11-17 21:00:40 +00:00
|
|
|
#include <string.h>
|
2000-08-11 13:37:21 +00:00
|
|
|
#include <glib.h>
|
|
|
|
|
1999-10-14 01:39:47 +00:00
|
|
|
#ifdef NEED_SNPRINTF_H
|
|
|
|
# include "snprintf.h"
|
|
|
|
#endif
|
|
|
|
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2004-09-29 00:52:45 +00:00
|
|
|
#include <epan/ipproto.h>
|
|
|
|
#include <epan/afn.h>
|
2001-05-07 20:26:25 +00:00
|
|
|
#include "packet-ipv6.h"
|
2004-09-28 00:06:32 +00:00
|
|
|
#include <epan/in_cksum.h>
|
2005-08-02 04:31:42 +00:00
|
|
|
#include "packet-pim.h"
|
1999-10-13 06:47:49 +00:00
|
|
|
|
|
|
|
#define PIM_TYPE(x) ((x) & 0x0f)
|
|
|
|
#define PIM_VER(x) (((x) & 0xf0) >> 4)
|
|
|
|
|
|
|
|
enum pimv2_addrtype {
|
|
|
|
pimv2_unicast, pimv2_group, pimv2_source
|
|
|
|
};
|
|
|
|
|
|
|
|
static int proto_pim = -1;
|
1999-10-15 13:14:43 +00:00
|
|
|
static int hf_pim_version = -1;
|
|
|
|
static int hf_pim_type = -1;
|
2001-07-02 09:42:40 +00:00
|
|
|
static int hf_pim_code = -1;
|
1999-10-15 13:14:43 +00:00
|
|
|
static int hf_pim_cksum = -1;
|
1999-10-13 06:47:49 +00:00
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint ett_pim = -1;
|
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
static dissector_handle_t ip_handle;
|
2001-04-23 03:56:57 +00:00
|
|
|
static dissector_handle_t ipv6_handle;
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
|
2001-07-02 09:23:02 +00:00
|
|
|
/*
|
|
|
|
* For PIM v1, see the PDF slides at
|
|
|
|
*
|
|
|
|
* http://www.mbone.de/training/Module3.pdf
|
|
|
|
*
|
|
|
|
* Is it documented anywhere else?
|
|
|
|
*/
|
|
|
|
static const char *
|
|
|
|
dissect_pimv1_addr(tvbuff_t *tvb, int offset) {
|
|
|
|
static char buf[512];
|
|
|
|
guint16 flags_masklen;
|
|
|
|
|
|
|
|
flags_masklen = tvb_get_ntohs(tvb, offset);
|
|
|
|
if (flags_masklen & 0x0180) {
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf, sizeof(buf),
|
2001-07-02 09:23:02 +00:00
|
|
|
"(%s%s%s) ",
|
|
|
|
flags_masklen & 0x0100 ? "S" : "",
|
|
|
|
flags_masklen & 0x0080 ? "W" : "",
|
|
|
|
flags_masklen & 0x0040 ? "R" : "");
|
|
|
|
} else
|
|
|
|
buf[0] = '\0';
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%s/%u",
|
2001-07-02 09:23:02 +00:00
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset + 2, 4)), flags_masklen & 0x3f);
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2001-07-02 09:42:40 +00:00
|
|
|
static const value_string type1vals[] = {
|
|
|
|
{ 0, "Query" },
|
|
|
|
{ 1, "Register" },
|
|
|
|
{ 2, "Register-stop" },
|
|
|
|
{ 3, "Join/Prune" },
|
|
|
|
{ 4, "RP-Reachable" },
|
|
|
|
{ 5, "Assert" },
|
|
|
|
{ 6, "Graft" },
|
|
|
|
{ 7, "Graft-Ack" },
|
|
|
|
{ 8, "Mode" },
|
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
2001-07-02 09:23:02 +00:00
|
|
|
/* This function is only called from the IGMP dissector */
|
|
|
|
int
|
|
|
|
dissect_pimv1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
|
|
int offset) {
|
|
|
|
guint8 pim_type;
|
|
|
|
guint8 pim_ver;
|
|
|
|
guint length, pim_length;
|
|
|
|
guint16 pim_cksum, computed_cksum;
|
|
|
|
vec_t cksum_vec[1];
|
|
|
|
proto_tree *pim_tree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *ti;
|
2001-07-02 09:23:02 +00:00
|
|
|
proto_tree *pimopt_tree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *tiopt;
|
2001-07-02 09:23:02 +00:00
|
|
|
|
2003-11-16 23:17:27 +00:00
|
|
|
if (!proto_is_protocol_enabled(find_protocol_by_id(proto_pim))) {
|
2001-07-02 09:23:02 +00:00
|
|
|
/*
|
|
|
|
* We are not enabled; skip entire packet to be nice to the
|
|
|
|
* IGMP layer (so clicking on IGMP will display the data).
|
|
|
|
*/
|
|
|
|
return offset+tvb_length_remaining(tvb, offset);
|
|
|
|
}
|
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIMv1");
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_clear(pinfo->cinfo, COL_INFO);
|
2001-07-02 09:23:02 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2002-01-24 09:20:54 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, FALSE);
|
2001-07-02 09:23:02 +00:00
|
|
|
pim_tree = proto_item_add_subtree(ti, ett_pim);
|
|
|
|
|
2001-07-02 09:42:40 +00:00
|
|
|
/* Put IGMP type, 0x14, into the tree */
|
|
|
|
proto_tree_add_text(pim_tree, tvb, offset, 1,
|
|
|
|
"Type: PIM (0x14)");
|
2001-07-02 09:23:02 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
pim_type = tvb_get_guint8(tvb, offset);
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_str(pinfo->cinfo, COL_INFO,
|
2001-07-02 09:42:40 +00:00
|
|
|
val_to_str(pim_type, type1vals, "Unknown (%u)"));
|
2001-07-02 09:23:02 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2001-07-02 09:42:40 +00:00
|
|
|
proto_tree_add_uint(pim_tree, hf_pim_code, tvb, offset, 1, pim_type);
|
2001-07-02 09:23:02 +00:00
|
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
pim_cksum = tvb_get_ntohs(tvb, offset);
|
|
|
|
pim_ver = PIM_VER(tvb_get_guint8(tvb, offset + 2));
|
|
|
|
if (pim_ver != 1) {
|
|
|
|
/*
|
|
|
|
* Not PIMv1 - what gives?
|
|
|
|
*/
|
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_uint(pim_tree, hf_pim_cksum, tvb,
|
|
|
|
offset, 2, pim_cksum);
|
|
|
|
}
|
|
|
|
offset += 2;
|
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(pim_tree, hf_pim_version, tvb, offset, 1, pim_ver);
|
|
|
|
return offset+tvb_length_remaining(tvb, offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Well, it's PIM v1, so we can check whether this is a
|
|
|
|
* Register message, and thus can figure out how much to
|
|
|
|
* checksum and whether to make the columns read-only.
|
|
|
|
*/
|
|
|
|
length = tvb_length(tvb);
|
|
|
|
if (pim_type == 1) {
|
|
|
|
/*
|
|
|
|
* Register message - the PIM header is 8 bytes long.
|
|
|
|
* Also set the columns non-writable. Otherwise the IPv4 or
|
|
|
|
* IPv6 dissector for the encapsulated packet that caused
|
|
|
|
* this register will overwrite the PIM info in the columns.
|
|
|
|
*/
|
|
|
|
pim_length = 8;
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_writable(pinfo->cinfo, FALSE);
|
2001-07-02 09:23:02 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Other message - checksum the entire packet.
|
|
|
|
*/
|
|
|
|
pim_length = tvb_reported_length(tvb);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
if (!pinfo->fragmented && length >= pim_length) {
|
|
|
|
/*
|
|
|
|
* The packet isn't part of a fragmented datagram and isn't
|
|
|
|
* truncated, so we can checksum it.
|
|
|
|
*/
|
|
|
|
cksum_vec[0].ptr = tvb_get_ptr(tvb, 0, pim_length);
|
|
|
|
cksum_vec[0].len = pim_length;
|
|
|
|
computed_cksum = in_cksum(&cksum_vec[0], 1);
|
|
|
|
if (computed_cksum == 0) {
|
|
|
|
proto_tree_add_uint_format(pim_tree, hf_pim_cksum, tvb,
|
|
|
|
offset, 2, pim_cksum,
|
2005-07-08 22:11:13 +00:00
|
|
|
"Checksum: 0x%04x [correct]",
|
2001-07-02 09:23:02 +00:00
|
|
|
pim_cksum);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_uint_format(pim_tree, hf_pim_cksum, tvb,
|
|
|
|
offset, 2, pim_cksum,
|
2005-07-08 22:11:13 +00:00
|
|
|
"Checksum: 0x%04x [incorrect, should be 0x%04x]",
|
2001-07-02 09:23:02 +00:00
|
|
|
pim_cksum, in_cksum_shouldbe(pim_cksum, computed_cksum));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
proto_tree_add_uint(pim_tree, hf_pim_cksum, tvb,
|
|
|
|
offset, 2, pim_cksum);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
offset += 2;
|
|
|
|
|
|
|
|
if (tree)
|
|
|
|
proto_tree_add_uint(pim_tree, hf_pim_version, tvb, offset, 1, pim_ver);
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
offset += 3; /* skip reserved stuff */
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0) {
|
2002-02-01 07:06:32 +00:00
|
|
|
tiopt = proto_tree_add_text(pim_tree, tvb, offset, -1,
|
|
|
|
"PIM parameters");
|
2001-07-02 09:23:02 +00:00
|
|
|
pimopt_tree = proto_item_add_subtree(tiopt, ett_pim);
|
|
|
|
} else
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* version 1 decoder */
|
|
|
|
switch (pim_type) {
|
|
|
|
case 0: /* query */
|
|
|
|
{
|
|
|
|
guint8 mode;
|
|
|
|
guint16 holdtime;
|
|
|
|
static const value_string pimv1_modevals[] = {
|
|
|
|
{ 0, "Dense" },
|
|
|
|
{ 1, "Sparse" },
|
|
|
|
{ 2, "Sparse-Dense" },
|
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
mode = tvb_get_guint8(tvb, offset) >> 4;
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"Mode: %s",
|
|
|
|
val_to_str(mode, pimv1_modevals, "Unknown (%u)"));
|
|
|
|
offset += 2;
|
|
|
|
holdtime = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 2,
|
|
|
|
"Holdtime: %u%s", holdtime,
|
|
|
|
holdtime == 0xffff ? " (infty)" : "");
|
|
|
|
offset += 2;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 1: /* register */
|
|
|
|
{
|
|
|
|
guint8 v_hl;
|
|
|
|
tvbuff_t *next_tvb;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The rest of the packet is a multicast data packet.
|
|
|
|
*/
|
|
|
|
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It's an IP packet - determine whether it's IPv4 or IPv6.
|
|
|
|
*/
|
|
|
|
v_hl = tvb_get_guint8(tvb, offset);
|
|
|
|
switch((v_hl & 0xf0) >> 4) {
|
|
|
|
case 0: /* Null-Register dummy header.
|
|
|
|
* Has the same address family as the encapsulating PIM packet,
|
|
|
|
* e.g. an IPv6 data packet is encapsulated in IPv6 PIM packet.
|
|
|
|
*/
|
|
|
|
if (pinfo->src.type == AT_IPv4) {
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, -1,
|
2001-07-02 09:23:02 +00:00
|
|
|
"IPv4 dummy header");
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset + 12, 4,
|
|
|
|
"Source: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset + 12, 4)));
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset + 16, 4,
|
|
|
|
"Group: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset + 16, 4)));
|
|
|
|
} else if (pinfo->src.type == AT_IPv6) {
|
|
|
|
struct ip6_hdr ip6_hdr;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)&ip6_hdr, offset,
|
2002-02-01 07:06:32 +00:00
|
|
|
sizeof ip6_hdr);
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, -1,
|
2001-07-02 09:23:02 +00:00
|
|
|
"IPv6 dummy header");
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb,
|
|
|
|
offset + offsetof(struct ip6_hdr, ip6_src), 16,
|
|
|
|
"Source: %s",
|
|
|
|
ip6_to_str(&ip6_hdr.ip6_src));
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb,
|
|
|
|
offset + offsetof(struct ip6_hdr, ip6_dst), 16,
|
|
|
|
"Group: %s",
|
|
|
|
ip6_to_str(&ip6_hdr.ip6_dst));
|
|
|
|
} else
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, -1,
|
2001-07-02 09:23:02 +00:00
|
|
|
"Dummy header for an unknown protocol");
|
|
|
|
break;
|
|
|
|
case 4: /* IPv4 */
|
|
|
|
#if 0
|
|
|
|
call_dissector(ip_handle, next_tvb, pinfo, tree);
|
|
|
|
#else
|
|
|
|
call_dissector(ip_handle, next_tvb, pinfo, pimopt_tree);
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
case 6: /* IPv6 */
|
|
|
|
#if 0
|
|
|
|
call_dissector(ipv6_handle, next_tvb, pinfo, tree);
|
|
|
|
#else
|
|
|
|
call_dissector(ipv6_handle, next_tvb, pinfo, pimopt_tree);
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
default:
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, -1,
|
2001-07-02 09:23:02 +00:00
|
|
|
"Unknown IP version %d", (v_hl & 0xf0) >> 4);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 2: /* register-stop */
|
|
|
|
{
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Group: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Source: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 3: /* join/prune */
|
|
|
|
case 6: /* graft */
|
|
|
|
case 7: /* graft-ack */
|
|
|
|
{
|
|
|
|
int off;
|
|
|
|
const char *s;
|
|
|
|
int ngroup, i, njoin, nprune, j;
|
|
|
|
guint16 holdtime;
|
|
|
|
guint8 mask_len;
|
|
|
|
guint8 adr_len;
|
|
|
|
proto_tree *grouptree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *tigroup;
|
2001-07-02 09:23:02 +00:00
|
|
|
proto_tree *subtree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *tisub;
|
2001-07-02 09:23:02 +00:00
|
|
|
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Upstream-neighbor: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
offset += 2; /* skip reserved stuff */
|
|
|
|
|
|
|
|
holdtime = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 2,
|
|
|
|
"Holdtime: %u%s", holdtime,
|
|
|
|
holdtime == 0xffff ? " (infty)" : "");
|
|
|
|
offset += 2;
|
|
|
|
|
|
|
|
offset += 1; /* skip reserved stuff */
|
|
|
|
|
|
|
|
mask_len = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"Mask length: %u", mask_len);
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
adr_len = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"Address length: %u", adr_len);
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
ngroup = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"Groups: %u", ngroup);
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
for (i = 0; i < ngroup; i++) {
|
2005-04-20 21:55:14 +00:00
|
|
|
/*
|
|
|
|
* XXX - does the group address have the length "adr_len"
|
|
|
|
* and the group mask the length "mask_len"?
|
|
|
|
*/
|
2001-07-02 09:23:02 +00:00
|
|
|
tigroup = proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Group %d: %s", i,
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
grouptree = proto_item_add_subtree(tigroup, ett_pim);
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
proto_tree_add_text(grouptree, tvb, offset, 4,
|
|
|
|
"Group %d Mask: %s", i,
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
njoin = tvb_get_ntohs(tvb, offset);
|
|
|
|
nprune = tvb_get_ntohs(tvb, offset + 2);
|
|
|
|
|
|
|
|
tisub = proto_tree_add_text(grouptree, tvb, offset, 2,
|
|
|
|
"Join: %d", njoin);
|
|
|
|
subtree = proto_item_add_subtree(tisub, ett_pim);
|
|
|
|
off = offset + 4;
|
|
|
|
for (j = 0; j < njoin; j++) {
|
|
|
|
s = dissect_pimv1_addr(tvb, off);
|
|
|
|
proto_tree_add_text(subtree, tvb, off, 6,
|
|
|
|
"IP address: %s", s);
|
|
|
|
off += 6;
|
|
|
|
}
|
|
|
|
|
|
|
|
tisub = proto_tree_add_text(grouptree, tvb, offset + 2, 2,
|
|
|
|
"Prune: %d", nprune);
|
|
|
|
subtree = proto_item_add_subtree(tisub, ett_pim);
|
|
|
|
for (j = 0; j < nprune; j++) {
|
|
|
|
s = dissect_pimv1_addr(tvb, off);
|
|
|
|
proto_tree_add_text(subtree, tvb, off, 6,
|
|
|
|
"IP address: %s", s);
|
|
|
|
off += 6;
|
|
|
|
}
|
2002-12-27 22:55:40 +00:00
|
|
|
offset = off;
|
2001-07-02 09:23:02 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 4: /* rp-reachability */
|
|
|
|
{
|
|
|
|
guint16 holdtime;
|
|
|
|
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Group Address: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Group Mask: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"RP Address: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
offset += 2; /* skip reserved stuff */
|
|
|
|
|
|
|
|
holdtime = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 2,
|
|
|
|
"Holdtime: %u%s", holdtime,
|
|
|
|
holdtime == 0xffff ? " (infty)" : "");
|
|
|
|
offset += 2;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 5: /* assert */
|
|
|
|
{
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Group Address: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Group Mask: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset, 4)));
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1, "%s",
|
|
|
|
decode_boolean_bitfield(tvb_get_guint8(tvb, offset), 0x80, 8,
|
|
|
|
"RP Tree", "Not RP Tree"));
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Preference: %u",
|
|
|
|
tvb_get_ntohl(tvb, offset) & 0x7fffffff);
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Metric: %u",
|
|
|
|
tvb_get_ntohl(tvb, offset));
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
done:;
|
|
|
|
|
|
|
|
return offset+tvb_length_remaining(tvb, offset);
|
|
|
|
}
|
|
|
|
|
1999-10-13 06:47:49 +00:00
|
|
|
static const char *
|
2001-01-13 06:34:35 +00:00
|
|
|
dissect_pim_addr(tvbuff_t *tvb, int offset, enum pimv2_addrtype at,
|
1999-10-13 06:47:49 +00:00
|
|
|
int *advance) {
|
|
|
|
static char buf[512];
|
2001-01-13 06:34:35 +00:00
|
|
|
guint8 af;
|
|
|
|
guint8 et;
|
|
|
|
guint8 flags;
|
|
|
|
guint8 mask_len;
|
1999-10-13 06:47:49 +00:00
|
|
|
int len = 0;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
af = tvb_get_guint8(tvb, offset);
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
if (af != AFNUM_INET && af != AFNUM_INET6) {
|
2001-01-13 06:34:35 +00:00
|
|
|
/*
|
|
|
|
* We don't handle the other formats, and addresses don't include
|
|
|
|
* a length field, so we can't even show them as raw bytes.
|
|
|
|
*/
|
1999-10-13 06:47:49 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
et = tvb_get_guint8(tvb, offset + 1);
|
|
|
|
if (et != 0) {
|
|
|
|
/*
|
|
|
|
* The only defined encoding type is 0, for the native encoding;
|
|
|
|
* again, as addresses don't include a length field, we can't
|
|
|
|
* even show addresses with a different encoding type as raw
|
|
|
|
* bytes.
|
|
|
|
*/
|
1999-10-13 06:47:49 +00:00
|
|
|
return NULL;
|
2001-01-13 06:34:35 +00:00
|
|
|
}
|
1999-10-13 06:47:49 +00:00
|
|
|
|
|
|
|
switch (at) {
|
|
|
|
case pimv2_unicast:
|
2001-01-13 06:34:35 +00:00
|
|
|
switch (af) {
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
case AFNUM_INET:
|
1999-10-13 06:47:49 +00:00
|
|
|
len = 4;
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf, sizeof(buf), "%s",
|
2001-01-13 06:34:35 +00:00
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset + 2, len)));
|
|
|
|
break;
|
|
|
|
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
case AFNUM_INET6:
|
1999-10-13 06:47:49 +00:00
|
|
|
len = 16;
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf, sizeof(buf), "%s",
|
2002-12-02 23:43:30 +00:00
|
|
|
ip6_to_str((const struct e_in6_addr *)tvb_get_ptr(tvb, offset + 2, len)));
|
2001-01-13 06:34:35 +00:00
|
|
|
break;
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
|
|
|
if (advance)
|
|
|
|
*advance = 2 + len;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pimv2_group:
|
2001-01-13 06:34:35 +00:00
|
|
|
mask_len = tvb_get_guint8(tvb, offset + 3);
|
|
|
|
switch (af) {
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
case AFNUM_INET:
|
1999-10-13 06:47:49 +00:00
|
|
|
len = 4;
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf, sizeof(buf), "%s/%u",
|
2001-01-13 06:34:35 +00:00
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset + 4, len)), mask_len);
|
|
|
|
break;
|
|
|
|
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
case AFNUM_INET6:
|
1999-10-13 06:47:49 +00:00
|
|
|
len = 16;
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf, sizeof(buf), "%s/%u",
|
2002-12-02 23:43:30 +00:00
|
|
|
ip6_to_str((const struct e_in6_addr *)tvb_get_ptr(tvb, offset + 4, len)), mask_len);
|
2001-01-13 06:34:35 +00:00
|
|
|
break;
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
|
|
|
if (advance)
|
|
|
|
*advance = 4 + len;
|
|
|
|
break;
|
2001-01-13 06:34:35 +00:00
|
|
|
|
1999-10-13 06:47:49 +00:00
|
|
|
case pimv2_source:
|
2001-01-13 06:34:35 +00:00
|
|
|
flags = tvb_get_guint8(tvb, offset + 2);
|
|
|
|
mask_len = tvb_get_guint8(tvb, offset + 3);
|
|
|
|
switch (af) {
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
case AFNUM_INET:
|
1999-10-13 06:47:49 +00:00
|
|
|
len = 4;
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf, sizeof(buf), "%s/%u",
|
2001-01-13 06:34:35 +00:00
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset + 4, len)), mask_len);
|
|
|
|
break;
|
|
|
|
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
case AFNUM_INET6:
|
1999-10-13 06:47:49 +00:00
|
|
|
len = 16;
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf, sizeof(buf), "%s/%u",
|
2002-12-02 23:43:30 +00:00
|
|
|
ip6_to_str((const struct e_in6_addr *)tvb_get_ptr(tvb, offset + 4, len)), mask_len);
|
2001-01-13 06:34:35 +00:00
|
|
|
break;
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
2001-01-13 06:34:35 +00:00
|
|
|
if (flags) {
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
|
1999-10-13 06:47:49 +00:00
|
|
|
" (%s%s%s)",
|
2001-01-13 06:34:35 +00:00
|
|
|
flags & 0x04 ? "S" : "",
|
|
|
|
flags & 0x02 ? "W" : "",
|
|
|
|
flags & 0x01 ? "R" : "");
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
|
|
|
if (advance)
|
|
|
|
*advance = 4 + len;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2001-07-02 09:42:40 +00:00
|
|
|
static const value_string type2vals[] = {
|
|
|
|
{ 0, "Hello" },
|
|
|
|
{ 1, "Register" },
|
|
|
|
{ 2, "Register-stop" },
|
|
|
|
{ 3, "Join/Prune" },
|
|
|
|
{ 4, "Bootstrap" },
|
|
|
|
{ 5, "Assert" },
|
|
|
|
{ 6, "Graft" },
|
|
|
|
{ 7, "Graft-Ack" },
|
|
|
|
{ 8, "Candidate-RP-Advertisement" },
|
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
2001-10-30 10:11:00 +00:00
|
|
|
/*
|
|
|
|
* For PIM v2, see RFC 2362, and draft-ietf-pim-sm-v2-new-03 (when PIM
|
|
|
|
* is run over IPv6, the rules for computing the PIM checksum from the
|
|
|
|
* draft in question, not from RFC 2362, should be used).
|
|
|
|
*/
|
2002-08-28 21:04:11 +00:00
|
|
|
static void
|
2001-01-13 06:34:35 +00:00
|
|
|
dissect_pim(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
|
|
|
int offset = 0;
|
|
|
|
guint8 pim_typever;
|
2001-02-08 08:38:58 +00:00
|
|
|
guint length, pim_length;
|
|
|
|
guint16 pim_cksum, computed_cksum;
|
2001-10-30 10:11:00 +00:00
|
|
|
vec_t cksum_vec[4];
|
|
|
|
guint32 phdr[2];
|
2005-06-26 19:56:52 +00:00
|
|
|
const char *typestr;
|
1999-10-13 06:47:49 +00:00
|
|
|
proto_tree *pim_tree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *ti;
|
1999-10-13 06:47:49 +00:00
|
|
|
proto_tree *pimopt_tree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *tiopt;
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIM");
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_clear(pinfo->cinfo, COL_INFO);
|
2001-01-13 06:34:35 +00:00
|
|
|
|
|
|
|
pim_typever = tvb_get_guint8(tvb, 0);
|
|
|
|
|
|
|
|
switch (PIM_VER(pim_typever)) {
|
1999-10-13 06:47:49 +00:00
|
|
|
case 2:
|
2001-07-02 09:42:40 +00:00
|
|
|
typestr = val_to_str(PIM_TYPE(pim_typever), type2vals, "Unknown (%u)");
|
1999-10-14 03:50:51 +00:00
|
|
|
break;
|
2001-07-02 09:23:02 +00:00
|
|
|
case 1: /* PIMv1 - we should never see this */
|
1999-10-14 03:50:51 +00:00
|
|
|
default:
|
|
|
|
typestr = "Unknown";
|
1999-10-13 06:47:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL)) {
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "PIMv%d",
|
2001-01-13 06:34:35 +00:00
|
|
|
PIM_VER(pim_typever));
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
2002-08-28 21:04:11 +00:00
|
|
|
col_add_str(pinfo->cinfo, COL_INFO, typestr);
|
1999-10-13 06:47:49 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2002-01-24 09:20:54 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, FALSE);
|
1999-11-16 11:44:20 +00:00
|
|
|
pim_tree = proto_item_add_subtree(ti, ett_pim);
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_uint(pim_tree, hf_pim_version, tvb, offset, 1,
|
2002-08-28 21:04:11 +00:00
|
|
|
PIM_VER(pim_typever));
|
2001-07-02 09:42:40 +00:00
|
|
|
proto_tree_add_uint(pim_tree, hf_pim_type, tvb, offset, 1,
|
2002-08-28 21:04:11 +00:00
|
|
|
PIM_TYPE(pim_typever));
|
2001-01-13 06:34:35 +00:00
|
|
|
|
|
|
|
pim_cksum = tvb_get_ntohs(tvb, offset + 2);
|
2001-02-08 08:38:58 +00:00
|
|
|
length = tvb_length(tvb);
|
|
|
|
if (PIM_VER(pim_typever) == 2) {
|
|
|
|
/*
|
|
|
|
* Well, it's PIM v2, so we can check whether this is a Register
|
2001-05-07 20:26:25 +00:00
|
|
|
* message, and thus can figure out how much to checksum and
|
|
|
|
* whether to make the columns read-only.
|
2001-02-08 08:38:58 +00:00
|
|
|
*/
|
|
|
|
if (PIM_TYPE(pim_typever) == 1) {
|
|
|
|
/*
|
|
|
|
* Register message - the PIM header is 8 bytes long.
|
2001-05-07 20:26:25 +00:00
|
|
|
* Also set the columns non-writable. Otherwise the IPv4 or
|
|
|
|
* IPv6 dissector for the encapsulated packet that caused
|
|
|
|
* this register will overwrite the PIM info in the columns.
|
2001-02-08 08:38:58 +00:00
|
|
|
*/
|
|
|
|
pim_length = 8;
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_writable(pinfo->cinfo, FALSE);
|
2001-02-08 08:38:58 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Other message - checksum the entire packet.
|
|
|
|
*/
|
|
|
|
pim_length = tvb_reported_length(tvb);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We don't know what type of message this is, so say that
|
|
|
|
* the length is 0, to force it not to be checksummed.
|
|
|
|
*/
|
|
|
|
pim_length = 0;
|
|
|
|
}
|
|
|
|
if (!pinfo->fragmented && length >= pim_length) {
|
|
|
|
/*
|
|
|
|
* The packet isn't part of a fragmented datagram and isn't
|
|
|
|
* truncated, so we can checksum it.
|
|
|
|
*/
|
2001-10-30 10:11:00 +00:00
|
|
|
|
|
|
|
switch (pinfo->src.type) {
|
|
|
|
case AT_IPv4:
|
|
|
|
cksum_vec[0].ptr = tvb_get_ptr(tvb, 0, pim_length);
|
|
|
|
cksum_vec[0].len = pim_length;
|
|
|
|
computed_cksum = in_cksum(&cksum_vec[0], 1);
|
|
|
|
break;
|
|
|
|
case AT_IPv6:
|
|
|
|
/* Set up the fields of the pseudo-header. */
|
|
|
|
cksum_vec[0].ptr = pinfo->src.data;
|
|
|
|
cksum_vec[0].len = pinfo->src.len;
|
|
|
|
cksum_vec[1].ptr = pinfo->dst.data;
|
|
|
|
cksum_vec[1].len = pinfo->dst.len;
|
|
|
|
cksum_vec[2].ptr = (const guint8 *)&phdr;
|
2002-08-02 23:36:07 +00:00
|
|
|
phdr[0] = g_htonl(pim_length);
|
|
|
|
phdr[1] = g_htonl(IP_PROTO_PIM);
|
2001-10-30 10:11:00 +00:00
|
|
|
cksum_vec[2].len = 8;
|
|
|
|
cksum_vec[3].ptr = tvb_get_ptr(tvb, 0, pim_length);
|
|
|
|
cksum_vec[3].len = pim_length;
|
|
|
|
computed_cksum = in_cksum(&cksum_vec[0], 4);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* PIM is available for IPv4 and IPv6 right now */
|
2001-10-30 10:15:53 +00:00
|
|
|
computed_cksum = 0; /* squelch GCC complaints */
|
2005-06-10 18:28:22 +00:00
|
|
|
DISSECTOR_ASSERT_NOT_REACHED();
|
2001-10-30 10:11:00 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-02-08 08:38:58 +00:00
|
|
|
if (computed_cksum == 0) {
|
|
|
|
proto_tree_add_uint_format(pim_tree, hf_pim_cksum, tvb,
|
|
|
|
offset + 2, 2, pim_cksum,
|
2005-07-08 22:11:13 +00:00
|
|
|
"Checksum: 0x%04x [correct]",
|
2001-02-08 08:38:58 +00:00
|
|
|
pim_cksum);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_uint_format(pim_tree, hf_pim_cksum, tvb,
|
|
|
|
offset + 2, 2, pim_cksum,
|
2005-07-08 22:11:13 +00:00
|
|
|
"Checksum: 0x%04x [incorrect, should be 0x%04x]",
|
2001-02-08 08:38:58 +00:00
|
|
|
pim_cksum, in_cksum_shouldbe(pim_cksum, computed_cksum));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
proto_tree_add_uint(pim_tree, hf_pim_cksum, tvb,
|
|
|
|
offset + 2, 2, pim_cksum);
|
|
|
|
}
|
2001-01-13 06:34:35 +00:00
|
|
|
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0) {
|
2002-01-24 09:20:54 +00:00
|
|
|
tiopt = proto_tree_add_text(pim_tree, tvb, offset, -1,
|
|
|
|
"PIM parameters");
|
1999-11-16 11:44:20 +00:00
|
|
|
pimopt_tree = proto_item_add_subtree(tiopt, ett_pim);
|
1999-10-13 06:47:49 +00:00
|
|
|
} else
|
|
|
|
goto done;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
if (PIM_VER(pim_typever) != 2)
|
1999-10-13 06:47:49 +00:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* version 2 decoder */
|
2001-01-13 06:34:35 +00:00
|
|
|
switch (PIM_TYPE(pim_typever)) {
|
1999-10-13 06:47:49 +00:00
|
|
|
case 0: /*hello*/
|
|
|
|
{
|
2001-01-13 06:34:35 +00:00
|
|
|
while (tvb_reported_length_remaining(tvb, offset) >= 2) {
|
2002-04-22 07:41:33 +00:00
|
|
|
guint16 hello_opt, opt_len;
|
|
|
|
guint16 holdtime;
|
|
|
|
guint16 lan_delay;
|
|
|
|
guint16 override_interval;
|
|
|
|
guint32 priority;
|
|
|
|
guint32 opt_value = 0;
|
|
|
|
|
|
|
|
hello_opt = tvb_get_ntohs(tvb, offset);
|
|
|
|
opt_len = tvb_get_ntohs(tvb, offset + 2);
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-04-22 07:41:33 +00:00
|
|
|
if(opt_len == 2)
|
|
|
|
opt_value = tvb_get_ntohs(tvb, offset + 4);
|
|
|
|
if(opt_len == 4)
|
|
|
|
opt_value = tvb_get_ntohl(tvb, offset + 4);
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-04-22 07:41:33 +00:00
|
|
|
switch(hello_opt) {
|
|
|
|
case 1: /* holdtime */
|
|
|
|
holdtime = opt_value;
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
|
2003-12-12 21:17:54 +00:00
|
|
|
"Holdtime (%u): %us %s", hello_opt, holdtime,
|
2002-04-22 07:41:33 +00:00
|
|
|
holdtime == 0xffff ? " (infty)" : "");
|
|
|
|
break;
|
2003-12-12 21:17:54 +00:00
|
|
|
case 2: /* LAN prune delay
|
|
|
|
*
|
|
|
|
* 0 1 2 3
|
|
|
|
* 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
|
|
|
|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
* | Type = 2 | Length = 4 |
|
|
|
|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
* |T| LAN Prune Delay | Override Interval |
|
|
|
|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
*/
|
2002-04-22 07:41:33 +00:00
|
|
|
{
|
|
|
|
proto_tree *sub_tree = NULL;
|
|
|
|
proto_item *landelay_option;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2003-12-12 21:17:54 +00:00
|
|
|
landelay_option = proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
|
|
|
|
"LAN Prune Delay (%u)", hello_opt);
|
2002-04-22 07:41:33 +00:00
|
|
|
sub_tree = proto_item_add_subtree(landelay_option, ett_pim);
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2003-12-12 21:17:54 +00:00
|
|
|
lan_delay = (opt_value & 0x7fff0000) >> 16;
|
|
|
|
override_interval = opt_value & 0x0000ffff;
|
|
|
|
proto_tree_add_text(sub_tree, tvb, offset + 4, 1,
|
2002-04-22 07:41:33 +00:00
|
|
|
"T bit is %s",
|
|
|
|
opt_value & 0x8000 ? "set" : "not set");
|
2003-12-12 21:17:54 +00:00
|
|
|
proto_tree_add_text(sub_tree, tvb, offset + 4, 2,
|
|
|
|
"LAN Delay: %ums", lan_delay);
|
|
|
|
proto_tree_add_text(sub_tree, tvb, offset + 6, 2,
|
|
|
|
"Override Interval: %ums", override_interval);
|
2002-04-22 07:41:33 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 19: /* priority */
|
|
|
|
priority = opt_value;
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
|
2003-12-12 21:17:54 +00:00
|
|
|
"DR Priority (%u): %u", hello_opt, priority);
|
2002-04-22 07:41:33 +00:00
|
|
|
break;
|
|
|
|
case 20: /* generation ID */
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
|
2003-12-12 21:17:54 +00:00
|
|
|
"Generation ID (%u): %d", hello_opt, opt_value);
|
2002-04-22 07:41:33 +00:00
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2003-10-17 21:27:34 +00:00
|
|
|
case 24: /* address list */
|
|
|
|
case 65001: /* address list (old implementations) */
|
|
|
|
{
|
|
|
|
int i;
|
2004-07-06 19:44:56 +00:00
|
|
|
proto_tree *sub_tree = NULL;
|
|
|
|
proto_item *addrlist_option;
|
|
|
|
|
|
|
|
addrlist_option = proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
|
2003-12-12 21:17:54 +00:00
|
|
|
"%sAddress List (%u)",
|
|
|
|
hello_opt == 65001 ? "old " : "",
|
|
|
|
hello_opt);
|
2004-07-06 19:44:56 +00:00
|
|
|
sub_tree = proto_item_add_subtree(addrlist_option, ett_pim);
|
|
|
|
|
2003-10-17 21:27:34 +00:00
|
|
|
for (i = offset + 4; i < offset + 4 + opt_len; ) {
|
|
|
|
int advance;
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
s = dissect_pim_addr(tvb, i, pimv2_unicast, &advance);
|
|
|
|
if (s == NULL)
|
|
|
|
break;
|
2004-07-06 19:44:56 +00:00
|
|
|
proto_tree_add_text(sub_tree, tvb, offset,
|
2003-10-17 21:27:34 +00:00
|
|
|
advance, "Address: %s", s);
|
|
|
|
i += advance;
|
|
|
|
}
|
2004-07-06 19:44:56 +00:00
|
|
|
break;
|
2003-10-17 21:27:34 +00:00
|
|
|
}
|
2002-04-22 07:41:33 +00:00
|
|
|
default:
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4 + opt_len,
|
2003-12-12 21:17:54 +00:00
|
|
|
"Unknown option (%u), length: %u, value: 0x%x",
|
2002-04-22 07:41:33 +00:00
|
|
|
hello_opt, opt_len, opt_value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset += 4 + opt_len;
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 1: /* register */
|
|
|
|
{
|
2001-01-13 06:34:35 +00:00
|
|
|
guint32 flags;
|
|
|
|
guint8 v_hl;
|
|
|
|
tvbuff_t *next_tvb;
|
1999-10-13 06:47:49 +00:00
|
|
|
proto_tree *flag_tree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *tiflag;
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
flags = tvb_get_ntohl(tvb, offset);
|
|
|
|
tiflag = proto_tree_add_text(pimopt_tree, tvb, offset, 4,
|
|
|
|
"Flags: 0x%08x", flags);
|
1999-11-16 11:44:20 +00:00
|
|
|
flag_tree = proto_item_add_subtree(tiflag, ett_pim);
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(flag_tree, tvb, offset, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags, 0x80000000, 32,
|
1999-10-13 06:47:49 +00:00
|
|
|
"Border", "Not border"));
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(flag_tree, tvb, offset, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags, 0x40000000, 32,
|
1999-10-13 06:47:49 +00:00
|
|
|
"Null-Register", "Not Null-Register"));
|
2001-01-13 06:34:35 +00:00
|
|
|
offset += 4;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
/*
|
|
|
|
* The rest of the packet is a multicast data packet.
|
|
|
|
*/
|
|
|
|
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It's an IP packet - determine whether it's IPv4 or IPv6.
|
|
|
|
*/
|
|
|
|
v_hl = tvb_get_guint8(tvb, offset);
|
|
|
|
switch((v_hl & 0xf0) >> 4) {
|
2001-05-07 20:26:25 +00:00
|
|
|
case 0: /* Null-Register dummy header.
|
|
|
|
* Has the same address family as the encapsulating PIM packet,
|
|
|
|
* e.g. an IPv6 data packet is encapsulated in IPv6 PIM packet.
|
|
|
|
*/
|
|
|
|
if (pinfo->src.type == AT_IPv4) {
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, -1,
|
2001-05-07 20:26:25 +00:00
|
|
|
"IPv4 dummy header");
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset + 12, 4,
|
|
|
|
"Source: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset + 12, 4)));
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset + 16, 4,
|
|
|
|
"Group: %s",
|
|
|
|
ip_to_str(tvb_get_ptr(tvb, offset + 16, 4)));
|
|
|
|
} else if (pinfo->src.type == AT_IPv6) {
|
|
|
|
struct ip6_hdr ip6_hdr;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)&ip6_hdr, offset,
|
2002-02-01 07:06:32 +00:00
|
|
|
sizeof ip6_hdr);
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, -1,
|
2001-05-07 20:26:25 +00:00
|
|
|
"IPv6 dummy header");
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb,
|
|
|
|
offset + offsetof(struct ip6_hdr, ip6_src), 16,
|
|
|
|
"Source: %s",
|
|
|
|
ip6_to_str(&ip6_hdr.ip6_src));
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb,
|
|
|
|
offset + offsetof(struct ip6_hdr, ip6_dst), 16,
|
|
|
|
"Group: %s",
|
|
|
|
ip6_to_str(&ip6_hdr.ip6_dst));
|
|
|
|
} else
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, -1,
|
2001-05-07 20:26:25 +00:00
|
|
|
"Dummy header for an unknown protocol");
|
|
|
|
break;
|
1999-10-13 06:47:49 +00:00
|
|
|
case 4: /* IPv4 */
|
1999-10-15 13:14:43 +00:00
|
|
|
#if 0
|
2001-01-13 06:34:35 +00:00
|
|
|
call_dissector(ip_handle, next_tvb, pinfo, tree);
|
1999-10-21 15:06:02 +00:00
|
|
|
#else
|
2001-01-13 06:34:35 +00:00
|
|
|
call_dissector(ip_handle, next_tvb, pinfo, pimopt_tree);
|
1999-10-15 13:14:43 +00:00
|
|
|
#endif
|
1999-10-13 06:47:49 +00:00
|
|
|
break;
|
|
|
|
case 6: /* IPv6 */
|
1999-10-15 13:14:43 +00:00
|
|
|
#if 0
|
2001-04-23 03:56:57 +00:00
|
|
|
call_dissector(ipv6_handle, next_tvb, pinfo, tree);
|
1999-10-21 15:06:02 +00:00
|
|
|
#else
|
2001-04-23 03:56:57 +00:00
|
|
|
call_dissector(ipv6_handle, next_tvb, pinfo, pimopt_tree);
|
1999-10-15 13:14:43 +00:00
|
|
|
#endif
|
1999-10-13 06:47:49 +00:00
|
|
|
break;
|
|
|
|
default:
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, -1,
|
2001-01-13 06:34:35 +00:00
|
|
|
"Unknown IP version %d", (v_hl & 0xf0) >> 4);
|
1999-10-13 06:47:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 2: /* register-stop */
|
|
|
|
{
|
|
|
|
int advance;
|
|
|
|
const char *s;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
break;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Group: %s", s);
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += advance;
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
break;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Source: %s", s);
|
1999-10-13 06:47:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 3: /* join/prune */
|
|
|
|
case 6: /* graft */
|
|
|
|
case 7: /* graft-ack */
|
|
|
|
{
|
|
|
|
int advance;
|
|
|
|
int off;
|
|
|
|
const char *s;
|
|
|
|
int ngroup, i, njoin, nprune, j;
|
2001-01-13 06:34:35 +00:00
|
|
|
guint16 holdtime;
|
1999-10-13 06:47:49 +00:00
|
|
|
proto_tree *grouptree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *tigroup;
|
1999-10-13 06:47:49 +00:00
|
|
|
proto_tree *subtree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *tisub;
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
if (PIM_TYPE(pim_typever) != 7) {
|
1999-10-13 06:47:49 +00:00
|
|
|
/* not graft-ack */
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
break;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, advance,
|
1999-10-13 06:47:49 +00:00
|
|
|
"Upstream-neighbor: %s", s);
|
|
|
|
offset += advance;
|
|
|
|
}
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
offset += 1; /* skip reserved field */
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
ngroup = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"Groups: %u", ngroup);
|
|
|
|
offset += 1;
|
|
|
|
|
|
|
|
if (PIM_TYPE(pim_typever) != 7) {
|
1999-10-13 06:47:49 +00:00
|
|
|
/* not graft-ack */
|
2001-01-13 06:34:35 +00:00
|
|
|
holdtime = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 2,
|
|
|
|
"Holdtime: %u%s", holdtime,
|
|
|
|
holdtime == 0xffff ? " (infty)" : "");
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
|
|
|
offset += 2;
|
|
|
|
|
|
|
|
for (i = 0; i < ngroup; i++) {
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
goto breakbreak3;
|
2001-01-13 06:34:35 +00:00
|
|
|
tigroup = proto_tree_add_text(pimopt_tree, tvb, offset, advance,
|
1999-10-13 06:47:49 +00:00
|
|
|
"Group %d: %s", i, s);
|
1999-11-16 11:44:20 +00:00
|
|
|
grouptree = proto_item_add_subtree(tigroup, ett_pim);
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += advance;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
njoin = tvb_get_ntohs(tvb, offset);
|
|
|
|
nprune = tvb_get_ntohs(tvb, offset + 2);
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
tisub = proto_tree_add_text(grouptree, tvb, offset, 2,
|
1999-10-13 06:47:49 +00:00
|
|
|
"Join: %d", njoin);
|
1999-11-16 11:44:20 +00:00
|
|
|
subtree = proto_item_add_subtree(tisub, ett_pim);
|
1999-10-13 06:47:49 +00:00
|
|
|
off = offset + 4;
|
2001-05-07 20:26:25 +00:00
|
|
|
for (j = 0; j < njoin; j++) {
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, off, pimv2_source,
|
1999-10-13 06:47:49 +00:00
|
|
|
&advance);
|
|
|
|
if (s == NULL)
|
|
|
|
goto breakbreak3;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(subtree, tvb, off, advance,
|
1999-10-13 06:47:49 +00:00
|
|
|
"IP address: %s", s);
|
|
|
|
off += advance;
|
|
|
|
}
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
tisub = proto_tree_add_text(grouptree, tvb, offset + 2, 2,
|
1999-10-13 06:47:49 +00:00
|
|
|
"Prune: %d", nprune);
|
1999-11-16 11:44:20 +00:00
|
|
|
subtree = proto_item_add_subtree(tisub, ett_pim);
|
1999-10-13 06:47:49 +00:00
|
|
|
for (j = 0; j < nprune; j++) {
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, off, pimv2_source,
|
1999-10-13 06:47:49 +00:00
|
|
|
&advance);
|
|
|
|
if (s == NULL)
|
|
|
|
goto breakbreak3;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(subtree, tvb, off, advance,
|
1999-10-13 06:47:49 +00:00
|
|
|
"IP address: %s", s);
|
|
|
|
off += advance;
|
|
|
|
}
|
2002-12-27 22:55:40 +00:00
|
|
|
offset = off;
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
|
|
|
breakbreak3:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 4: /* bootstrap */
|
|
|
|
{
|
|
|
|
const char *s;
|
|
|
|
int advance;
|
|
|
|
int i, j;
|
|
|
|
int frpcnt;
|
2001-01-13 06:34:35 +00:00
|
|
|
guint16 holdtime;
|
1999-10-13 06:47:49 +00:00
|
|
|
proto_tree *grouptree = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_item *tigroup;
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 2,
|
|
|
|
"Fragment tag: 0x%04x", tvb_get_ntohs(tvb, offset));
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += 2;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"Hash mask len: %u", tvb_get_guint8(tvb, offset));
|
|
|
|
offset += 1;
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"BSR priority: %u", tvb_get_guint8(tvb, offset));
|
|
|
|
offset += 1;
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
break;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, advance, "BSR: %s", s);
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += advance;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
for (i = 0; tvb_reported_length_remaining(tvb, offset) > 0; i++) {
|
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
goto breakbreak4;
|
2001-01-13 06:34:35 +00:00
|
|
|
tigroup = proto_tree_add_text(pimopt_tree, tvb, offset, advance,
|
1999-10-13 06:47:49 +00:00
|
|
|
"Group %d: %s", i, s);
|
1999-11-16 11:44:20 +00:00
|
|
|
grouptree = proto_item_add_subtree(tigroup, ett_pim);
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += advance;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(grouptree, tvb, offset, 1,
|
|
|
|
"RP count: %u", tvb_get_guint8(tvb, offset));
|
|
|
|
offset += 1;
|
|
|
|
frpcnt = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(grouptree, tvb, offset, 1,
|
|
|
|
"FRP count: %u", frpcnt);
|
|
|
|
offset += 3;
|
|
|
|
|
|
|
|
for (j = 0; j < frpcnt; j++) {
|
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
goto breakbreak4;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(grouptree, tvb, offset, advance,
|
1999-10-13 06:47:49 +00:00
|
|
|
"RP %d: %s", j, s);
|
|
|
|
offset += advance;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
holdtime = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(grouptree, tvb, offset, 2,
|
|
|
|
"Holdtime: %u%s", holdtime,
|
|
|
|
holdtime == 0xffff ? " (infty)" : "");
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_text(grouptree, tvb, offset, 1,
|
|
|
|
"Priority: %u", tvb_get_guint8(tvb, offset));
|
|
|
|
offset += 2; /* also skips reserved field */
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
breakbreak4:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 5: /* assert */
|
|
|
|
{
|
|
|
|
const char *s;
|
|
|
|
int advance;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
break;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Group: %s", s);
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += advance;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
break;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, advance, "Source: %s", s);
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += advance;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1, "%s",
|
|
|
|
decode_boolean_bitfield(tvb_get_guint8(tvb, offset), 0x80, 8,
|
1999-10-13 06:47:49 +00:00
|
|
|
"RP Tree", "Not RP Tree"));
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Preference: %u",
|
|
|
|
tvb_get_ntohl(tvb, offset) & 0x7fffffff);
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += 4;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 4, "Metric: %u",
|
|
|
|
tvb_get_ntohl(tvb, offset));
|
1999-10-13 06:47:49 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 8: /* Candidate-RP-Advertisement */
|
|
|
|
{
|
|
|
|
const char *s;
|
|
|
|
int advance;
|
|
|
|
int pfxcnt;
|
2001-01-13 06:34:35 +00:00
|
|
|
guint16 holdtime;
|
1999-10-13 06:47:49 +00:00
|
|
|
int i;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
pfxcnt = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"Prefix-count: %u", pfxcnt);
|
|
|
|
offset += 1;
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 1,
|
|
|
|
"Priority: %u", tvb_get_guint8(tvb, offset));
|
|
|
|
offset += 1;
|
|
|
|
holdtime = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, 2,
|
|
|
|
"Holdtime: %u%s", holdtime,
|
|
|
|
holdtime == 0xffff ? " (infty)" : "");
|
|
|
|
offset += 2;
|
1999-10-13 06:47:49 +00:00
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_unicast, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
break;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, advance, "RP: %s", s);
|
1999-10-13 06:47:49 +00:00
|
|
|
offset += advance;
|
|
|
|
|
2001-01-13 06:34:35 +00:00
|
|
|
for (i = 0; i < pfxcnt; i++) {
|
|
|
|
s = dissect_pim_addr(tvb, offset, pimv2_group, &advance);
|
1999-10-13 06:47:49 +00:00
|
|
|
if (s == NULL)
|
|
|
|
goto breakbreak8;
|
2001-01-13 06:34:35 +00:00
|
|
|
proto_tree_add_text(pimopt_tree, tvb, offset, advance,
|
1999-10-13 06:47:49 +00:00
|
|
|
"Group %d: %s", i, s);
|
|
|
|
offset += advance;
|
|
|
|
}
|
|
|
|
breakbreak8:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
done:;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
proto_register_pim(void)
|
|
|
|
{
|
1999-10-15 13:14:43 +00:00
|
|
|
static hf_register_info hf[] = {
|
|
|
|
{ &hf_pim_version,
|
|
|
|
{ "Version", "pim.version",
|
2001-06-18 02:18:27 +00:00
|
|
|
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
1999-10-15 13:14:43 +00:00
|
|
|
{ &hf_pim_type,
|
2001-07-02 09:42:40 +00:00
|
|
|
{ "Type", "pim.type",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(type2vals), 0x0, "", HFILL }},
|
|
|
|
{ &hf_pim_code,
|
|
|
|
{ "Code", "pim.code",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(type1vals), 0x0, "", HFILL }},
|
1999-10-15 13:14:43 +00:00
|
|
|
{ &hf_pim_cksum,
|
|
|
|
{ "Checksum", "pim.cksum",
|
2001-06-18 02:18:27 +00:00
|
|
|
FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
|
1999-10-15 13:14:43 +00:00
|
|
|
};
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_pim,
|
|
|
|
};
|
1999-10-15 13:14:43 +00:00
|
|
|
|
1999-10-13 06:47:49 +00:00
|
|
|
proto_pim = proto_register_protocol("Protocol Independent Multicast",
|
2001-01-03 06:56:03 +00:00
|
|
|
"PIM", "pim");
|
1999-10-15 13:14:43 +00:00
|
|
|
proto_register_field_array(proto_pim, hf, array_length(hf));
|
1999-11-16 11:44:20 +00:00
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
1999-10-13 06:47:49 +00:00
|
|
|
}
|
2000-04-16 22:46:25 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_pim(void)
|
|
|
|
{
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_handle_t pim_handle;
|
|
|
|
|
|
|
|
pim_handle = create_dissector_handle(dissect_pim, proto_pim);
|
|
|
|
dissector_add("ip.proto", IP_PROTO_PIM, pim_handle);
|
2000-04-16 22:46:25 +00:00
|
|
|
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
/*
|
2001-04-23 03:56:57 +00:00
|
|
|
* Get handles for the IPv4 and IPv6 dissectors.
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
*/
|
|
|
|
ip_handle = find_dissector("ip");
|
2001-04-23 03:56:57 +00:00
|
|
|
ipv6_handle = find_dissector("ipv6");
|
Tvbuffify the IP, ICMP, TCP, UDP, OSI CLNP, OSI COTP, OSI CLTP, and OSI
ESIS dissectors.
Register the IP dissector and have dissectors that call it directly
(rather than through a port table) call it through a handle.
Add a routine "tvb_set_reported_length()" which a dissector can use if
it was handed a tvbuff that contains more data than is actually in its
part of the packet - for example, handing a padded Ethernet frame to IP;
the routine sets the reported length of the tvbuff (and also adjusts the
actual length, as appropriate). Then use it in IP.
Given that, "ethertype()" can determine how much of the Ethernet frame
was actually part of an IP datagram (and can do the same for other
protocols under Ethernet that use "tvb_set_reported_length()"; have it
return the actual length, and have "dissect_eth()" and "dissect_vlan()"
use that to mark trailer data in Ethernet II frames as well as in 802.3
frames.
svn path=/trunk/; revision=2658
2000-11-18 10:38:33 +00:00
|
|
|
}
|