1999-03-29 02:21:34 +00:00
|
|
|
/* packet-icmpv6.c
|
2000-10-12 14:58:02 +00:00
|
|
|
* Routines for ICMPv6 packet disassembly
|
1999-03-29 02:21:34 +00:00
|
|
|
*
|
2002-08-28 21:04:11 +00:00
|
|
|
* $Id: packet-icmpv6.c,v 1.67 2002/08/28 21:00:17 jmayer Exp $
|
1999-03-29 02:21:34 +00:00
|
|
|
*
|
|
|
|
* Ethereal - Network traffic analyzer
|
2001-01-23 02:49:55 +00:00
|
|
|
* By Gerald Combs <gerald@ethereal.com>
|
1999-03-29 02:21:34 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
2001-01-23 02:49:55 +00:00
|
|
|
* MobileIPv6 support added by Tomislav Borosa <tomislav.borosa@siemens.hr>
|
2000-10-12 14:58:02 +00:00
|
|
|
*
|
2001-09-04 21:04:52 +00:00
|
|
|
* HMIPv6 support added by Martti Kuparinen <martti.kuparinen@iki.fi>
|
|
|
|
*
|
1999-03-29 02:21:34 +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.
|
2000-10-12 14:58:02 +00:00
|
|
|
*
|
1999-03-29 02:21:34 +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.
|
2000-10-12 14:58:02 +00:00
|
|
|
*
|
1999-03-29 02:21:34 +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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
1999-07-13 02:53:26 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_UNISTD_H
|
1999-03-29 02:21:34 +00:00
|
|
|
#include <unistd.h>
|
1999-07-13 02:53:26 +00:00
|
|
|
#endif
|
|
|
|
|
1999-03-29 02:21:34 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
2000-08-11 13:37:21 +00:00
|
|
|
#include <glib.h>
|
|
|
|
|
1999-03-29 02:24:29 +00:00
|
|
|
#ifdef NEED_SNPRINTF_H
|
|
|
|
# include "snprintf.h"
|
|
|
|
#endif
|
|
|
|
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
1999-03-29 02:21:34 +00:00
|
|
|
#include "packet-ipv6.h"
|
2000-08-22 08:30:00 +00:00
|
|
|
#include "packet-dns.h"
|
2000-12-14 21:45:12 +00:00
|
|
|
#include "in_cksum.h"
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/resolv.h>
|
2001-04-23 17:51:37 +00:00
|
|
|
#include "ipproto.h"
|
1999-03-29 02:21:34 +00:00
|
|
|
|
|
|
|
#ifndef offsetof
|
|
|
|
#define offsetof(type, member) ((size_t)(&((type *)0)->member))
|
|
|
|
#endif
|
|
|
|
|
2002-01-11 09:19:54 +00:00
|
|
|
/*
|
|
|
|
* See, under http://www.ietf.org/internet-drafts/
|
|
|
|
*
|
|
|
|
* draft-ietf-mobileip-ipv6-15.txt
|
|
|
|
*
|
|
|
|
* and
|
|
|
|
*
|
|
|
|
* draft-ietf-ipngwg-icmp-name-lookups-08.txt
|
|
|
|
*
|
|
|
|
* and
|
|
|
|
*
|
|
|
|
* draft-ietf-mobileip-hmipv6-05.txt
|
|
|
|
*/
|
|
|
|
|
1999-07-29 05:47:07 +00:00
|
|
|
static int proto_icmpv6 = -1;
|
1999-10-10 16:09:33 +00:00
|
|
|
static int hf_icmpv6_type = -1;
|
|
|
|
static int hf_icmpv6_code = -1;
|
|
|
|
static int hf_icmpv6_checksum = -1;
|
2001-02-28 19:33:49 +00:00
|
|
|
static int hf_icmpv6_checksum_bad = -1;
|
1999-07-29 05:47:07 +00:00
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint ett_icmpv6 = -1;
|
|
|
|
static gint ett_icmpv6opt = -1;
|
|
|
|
static gint ett_icmpv6flag = -1;
|
2000-08-18 12:05:27 +00:00
|
|
|
static gint ett_nodeinfo_flag = -1;
|
|
|
|
static gint ett_nodeinfo_subject4 = -1;
|
|
|
|
static gint ett_nodeinfo_subject6 = -1;
|
|
|
|
static gint ett_nodeinfo_node4 = -1;
|
|
|
|
static gint ett_nodeinfo_node6 = -1;
|
2000-08-22 08:30:00 +00:00
|
|
|
static gint ett_nodeinfo_nodebitmap = -1;
|
|
|
|
static gint ett_nodeinfo_nodedns = -1;
|
2000-08-18 12:05:27 +00:00
|
|
|
|
2001-04-23 03:56:57 +00:00
|
|
|
static dissector_handle_t ipv6_handle;
|
2001-11-25 22:51:14 +00:00
|
|
|
static dissector_handle_t data_handle;
|
2001-04-23 03:56:57 +00:00
|
|
|
|
2000-08-18 12:05:27 +00:00
|
|
|
static const value_string names_nodeinfo_qtype[] = {
|
|
|
|
{ NI_QTYPE_NOOP, "NOOP" },
|
|
|
|
{ NI_QTYPE_SUPTYPES, "Supported query types" },
|
|
|
|
{ NI_QTYPE_DNSNAME, "DNS name" },
|
|
|
|
{ NI_QTYPE_NODEADDR, "Node addresses" },
|
|
|
|
{ NI_QTYPE_IPV4ADDR, "IPv4 node addresses" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
1999-11-16 11:44:20 +00:00
|
|
|
|
2000-11-09 16:39:59 +00:00
|
|
|
static const value_string names_rrenum_matchcode[] = {
|
|
|
|
{ RPM_PCO_ADD, "Add" },
|
|
|
|
{ RPM_PCO_CHANGE, "Change" },
|
|
|
|
{ RPM_PCO_SETGLOBAL, "Set Global" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2001-06-01 23:53:49 +00:00
|
|
|
static const value_string names_router_pref[] = {
|
2002-08-28 21:04:11 +00:00
|
|
|
{ ND_RA_FLAG_RTPREF_HIGH, "High" },
|
|
|
|
{ ND_RA_FLAG_RTPREF_MEDIUM, "Medium" },
|
|
|
|
{ ND_RA_FLAG_RTPREF_LOW, "Low" },
|
|
|
|
{ ND_RA_FLAG_RTPREF_RSV, "Reserved" },
|
2001-06-01 23:53:49 +00:00
|
|
|
};
|
|
|
|
|
2001-05-27 04:14:53 +00:00
|
|
|
static void
|
|
|
|
dissect_contained_icmpv6(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
tvbuff_t *next_tvb;
|
2002-01-30 22:58:54 +00:00
|
|
|
volatile address save_dl_src;
|
|
|
|
volatile address save_dl_dst;
|
|
|
|
volatile address save_net_src;
|
|
|
|
volatile address save_net_dst;
|
|
|
|
volatile address save_src;
|
|
|
|
volatile address save_dst;
|
Have a flag in the "packet_info" structure, which indicates whether the
stuff currently being dissected is part of a packet included in an error
packet (e.g., an ICMP Unreachable packet). Have the TCP dissector not
bother doing reassembly if the TCP segment is part of an error packet,
rather than an actual TCP transmission; other dissectors might want to
treat those packets specially as well.
Add to the "tcpinfo" structure a flag indicating whether the URG flag
was set, rather than having the zero or non-zero value of the urgent
pointer indicate that. (Yes, at least as I read RFC 793, a zero urgent
pointer value isn't useful, as it means "the stuff before this segment
is urgent", but it's certainly possible to put onto the wire a TCP
segment with URG set and a zero urgent pointer.)
Don't dissect the TCP header by grabbing the entire header with
"tvb_memcpy()" and then pulling stuff out of it - extract stuff with
individual tvbuff calls, and put stuff into the protocol tree and the
Info column as we extract it, so that we can dissect a partial header.
This lets us, for example, get the source and destination ports from the
TCP header of the part of a TCP segment included in a minimum-length
ICMPv4 error packet.
svn path=/trunk/; revision=3986
2001-10-01 08:29:37 +00:00
|
|
|
gboolean save_in_error_pkt;
|
2001-05-27 04:14:53 +00:00
|
|
|
|
|
|
|
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
|
|
|
|
|
|
|
|
/* tiny sanity check */
|
|
|
|
if ((tvb_get_guint8(tvb, offset) & 0xf0) == 0x60) {
|
|
|
|
/* The contained packet is an IPv6 datagram; dissect it.
|
|
|
|
|
|
|
|
Set the columns non-writable, so that the packet list
|
|
|
|
shows this as an ICMPv6 packet, not as the type of packet
|
|
|
|
for which the ICMPv6 packet was generated. */
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_writable(pinfo->cinfo, FALSE);
|
2001-05-27 04:14:53 +00:00
|
|
|
|
|
|
|
/* Also, save the current values of the addresses, and restore
|
|
|
|
them when we're finished dissecting the contained packet, so
|
|
|
|
that the address columns in the summary don't reflect the
|
|
|
|
contained packet, but reflect this packet instead. */
|
|
|
|
save_dl_src = pinfo->dl_src;
|
|
|
|
save_dl_dst = pinfo->dl_dst;
|
|
|
|
save_net_src = pinfo->net_src;
|
|
|
|
save_net_dst = pinfo->net_dst;
|
|
|
|
save_src = pinfo->src;
|
|
|
|
save_dst = pinfo->dst;
|
|
|
|
|
Have a flag in the "packet_info" structure, which indicates whether the
stuff currently being dissected is part of a packet included in an error
packet (e.g., an ICMP Unreachable packet). Have the TCP dissector not
bother doing reassembly if the TCP segment is part of an error packet,
rather than an actual TCP transmission; other dissectors might want to
treat those packets specially as well.
Add to the "tcpinfo" structure a flag indicating whether the URG flag
was set, rather than having the zero or non-zero value of the urgent
pointer indicate that. (Yes, at least as I read RFC 793, a zero urgent
pointer value isn't useful, as it means "the stuff before this segment
is urgent", but it's certainly possible to put onto the wire a TCP
segment with URG set and a zero urgent pointer.)
Don't dissect the TCP header by grabbing the entire header with
"tvb_memcpy()" and then pulling stuff out of it - extract stuff with
individual tvbuff calls, and put stuff into the protocol tree and the
Info column as we extract it, so that we can dissect a partial header.
This lets us, for example, get the source and destination ports from the
TCP header of the part of a TCP segment included in a minimum-length
ICMPv4 error packet.
svn path=/trunk/; revision=3986
2001-10-01 08:29:37 +00:00
|
|
|
/* Save the current value of the "we're inside an error packet"
|
|
|
|
flag, and set that flag; subdissectors may treat packets
|
|
|
|
that are the payload of error packets differently from
|
|
|
|
"real" packets. */
|
|
|
|
save_in_error_pkt = pinfo->in_error_pkt;
|
|
|
|
pinfo->in_error_pkt = TRUE;
|
|
|
|
|
2001-09-27 10:35:40 +00:00
|
|
|
/* Dissect the contained packet.
|
|
|
|
Catch ReportedBoundsError, and do nothing if we see it,
|
|
|
|
because it's not an error if the contained packet is short;
|
Have a flag in the "packet_info" structure, which indicates whether the
stuff currently being dissected is part of a packet included in an error
packet (e.g., an ICMP Unreachable packet). Have the TCP dissector not
bother doing reassembly if the TCP segment is part of an error packet,
rather than an actual TCP transmission; other dissectors might want to
treat those packets specially as well.
Add to the "tcpinfo" structure a flag indicating whether the URG flag
was set, rather than having the zero or non-zero value of the urgent
pointer indicate that. (Yes, at least as I read RFC 793, a zero urgent
pointer value isn't useful, as it means "the stuff before this segment
is urgent", but it's certainly possible to put onto the wire a TCP
segment with URG set and a zero urgent pointer.)
Don't dissect the TCP header by grabbing the entire header with
"tvb_memcpy()" and then pulling stuff out of it - extract stuff with
individual tvbuff calls, and put stuff into the protocol tree and the
Info column as we extract it, so that we can dissect a partial header.
This lets us, for example, get the source and destination ports from the
TCP header of the part of a TCP segment included in a minimum-length
ICMPv4 error packet.
svn path=/trunk/; revision=3986
2001-10-01 08:29:37 +00:00
|
|
|
there's no guarantee that all of it was included.
|
|
|
|
|
|
|
|
XXX - should catch BoundsError, and re-throw it after cleaning
|
|
|
|
up. */
|
2001-09-27 10:35:40 +00:00
|
|
|
TRY {
|
|
|
|
call_dissector(ipv6_handle, next_tvb, pinfo, tree);
|
|
|
|
}
|
|
|
|
CATCH(ReportedBoundsError) {
|
|
|
|
; /* do nothing */
|
|
|
|
}
|
|
|
|
ENDTRY;
|
2001-05-27 04:14:53 +00:00
|
|
|
|
Have a flag in the "packet_info" structure, which indicates whether the
stuff currently being dissected is part of a packet included in an error
packet (e.g., an ICMP Unreachable packet). Have the TCP dissector not
bother doing reassembly if the TCP segment is part of an error packet,
rather than an actual TCP transmission; other dissectors might want to
treat those packets specially as well.
Add to the "tcpinfo" structure a flag indicating whether the URG flag
was set, rather than having the zero or non-zero value of the urgent
pointer indicate that. (Yes, at least as I read RFC 793, a zero urgent
pointer value isn't useful, as it means "the stuff before this segment
is urgent", but it's certainly possible to put onto the wire a TCP
segment with URG set and a zero urgent pointer.)
Don't dissect the TCP header by grabbing the entire header with
"tvb_memcpy()" and then pulling stuff out of it - extract stuff with
individual tvbuff calls, and put stuff into the protocol tree and the
Info column as we extract it, so that we can dissect a partial header.
This lets us, for example, get the source and destination ports from the
TCP header of the part of a TCP segment included in a minimum-length
ICMPv4 error packet.
svn path=/trunk/; revision=3986
2001-10-01 08:29:37 +00:00
|
|
|
/* Restore the "we're inside an error packet" flag. */
|
|
|
|
pinfo->in_error_pkt = save_in_error_pkt;
|
|
|
|
|
2001-05-27 04:14:53 +00:00
|
|
|
/* Restore the addresses. */
|
|
|
|
pinfo->dl_src = save_dl_src;
|
|
|
|
pinfo->dl_dst = save_dl_dst;
|
|
|
|
pinfo->net_src = save_net_src;
|
|
|
|
pinfo->net_dst = save_net_dst;
|
|
|
|
pinfo->src = save_src;
|
|
|
|
pinfo->dst = save_dst;
|
|
|
|
} else
|
2001-11-25 22:51:14 +00:00
|
|
|
call_dissector(data_handle,next_tvb, pinfo, tree);
|
2001-05-27 04:14:53 +00:00
|
|
|
}
|
|
|
|
|
1999-03-29 02:21:34 +00:00
|
|
|
static void
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_icmpv6opt(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
|
1999-03-29 02:21:34 +00:00
|
|
|
{
|
|
|
|
proto_tree *icmp6opt_tree, *field_tree;
|
2001-09-04 21:04:52 +00:00
|
|
|
proto_item *ti, *tf;
|
2001-04-23 03:37:31 +00:00
|
|
|
struct nd_opt_hdr nd_opt_hdr, *opt;
|
1999-03-29 02:21:34 +00:00
|
|
|
int len;
|
|
|
|
char *typename;
|
|
|
|
|
|
|
|
if (!tree)
|
|
|
|
return;
|
|
|
|
|
|
|
|
again:
|
2001-04-23 03:37:31 +00:00
|
|
|
if ((int)tvb_reported_length(tvb) <= offset)
|
2001-06-01 23:53:49 +00:00
|
|
|
return; /* No more options left */
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
opt = &nd_opt_hdr;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)opt, offset, sizeof *opt);
|
1999-03-29 02:21:34 +00:00
|
|
|
len = opt->nd_opt_len << 3;
|
|
|
|
|
2001-06-02 06:10:08 +00:00
|
|
|
/* !!! specify length */
|
|
|
|
ti = proto_tree_add_text(tree, tvb, offset, len, "ICMPv6 options");
|
|
|
|
icmp6opt_tree = proto_item_add_subtree(ti, ett_icmpv6opt);
|
|
|
|
|
2001-06-01 23:53:49 +00:00
|
|
|
if (len == 0) {
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_hdr, nd_opt_len), 1,
|
|
|
|
"Invalid option length: %u",
|
|
|
|
opt->nd_opt_len);
|
|
|
|
return; /* we must not try to decode this */
|
|
|
|
}
|
|
|
|
|
1999-03-29 02:21:34 +00:00
|
|
|
switch (opt->nd_opt_type) {
|
|
|
|
case ND_OPT_SOURCE_LINKADDR:
|
|
|
|
typename = "Source link-layer address";
|
|
|
|
break;
|
|
|
|
case ND_OPT_TARGET_LINKADDR:
|
|
|
|
typename = "Target link-layer address";
|
|
|
|
break;
|
|
|
|
case ND_OPT_PREFIX_INFORMATION:
|
|
|
|
typename = "Prefix information";
|
|
|
|
break;
|
|
|
|
case ND_OPT_REDIRECTED_HEADER:
|
|
|
|
typename = "Redirected header";
|
|
|
|
break;
|
|
|
|
case ND_OPT_MTU:
|
|
|
|
typename = "MTU";
|
|
|
|
break;
|
2001-06-01 23:53:49 +00:00
|
|
|
case ND_OPT_ADVINTERVAL:
|
2001-01-23 02:49:55 +00:00
|
|
|
typename = "Advertisement Interval";
|
|
|
|
break;
|
2001-06-01 23:53:49 +00:00
|
|
|
case ND_OPT_HOMEAGENT_INFO:
|
2001-01-23 02:49:55 +00:00
|
|
|
typename = "Home Agent Information";
|
|
|
|
break;
|
2001-09-04 21:04:52 +00:00
|
|
|
case ND_OPT_MAP:
|
|
|
|
typename = "HMIPv6 MAP option";
|
|
|
|
break;
|
1999-03-29 02:21:34 +00:00
|
|
|
default:
|
|
|
|
typename = "Unknown";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_opt_hdr, nd_opt_type), 1,
|
2001-04-23 03:37:31 +00:00
|
|
|
"Type: %u (%s)", opt->nd_opt_type, typename);
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_opt_hdr, nd_opt_len), 1,
|
2001-04-23 03:37:31 +00:00
|
|
|
"Length: %u bytes (%u)", opt->nd_opt_len << 3, opt->nd_opt_len);
|
1999-03-29 02:21:34 +00:00
|
|
|
|
|
|
|
/* decode... */
|
|
|
|
switch (opt->nd_opt_type) {
|
|
|
|
case ND_OPT_SOURCE_LINKADDR:
|
|
|
|
case ND_OPT_TARGET_LINKADDR:
|
|
|
|
{
|
|
|
|
char *t;
|
2001-04-23 03:37:31 +00:00
|
|
|
int len, i, p;
|
1999-03-29 02:21:34 +00:00
|
|
|
len = (opt->nd_opt_len << 3) - sizeof(*opt);
|
|
|
|
t = (char *)malloc(len * 3);
|
|
|
|
memset(t, 0, len * 3);
|
2001-04-23 03:37:31 +00:00
|
|
|
p = offset + sizeof(*opt);
|
1999-03-29 02:21:34 +00:00
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (i)
|
|
|
|
t[i * 3 - 1] = ':';
|
2001-04-23 03:37:31 +00:00
|
|
|
sprintf(&t[i * 3], "%02x", tvb_get_guint8(tvb, p + i) & 0xff);
|
1999-03-29 02:21:34 +00:00
|
|
|
}
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + sizeof(*opt), len, "Link-layer address: %s", t);
|
2001-06-01 23:53:49 +00:00
|
|
|
free(t);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ND_OPT_PREFIX_INFORMATION:
|
|
|
|
{
|
2001-04-23 03:37:31 +00:00
|
|
|
struct nd_opt_prefix_info nd_opt_prefix_info, *pi;
|
1999-03-29 02:21:34 +00:00
|
|
|
int flagoff;
|
2001-04-23 03:37:31 +00:00
|
|
|
|
|
|
|
pi = &nd_opt_prefix_info;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)pi, offset, sizeof *pi);
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_opt_prefix_info, nd_opt_pi_prefix_len),
|
2001-04-23 03:37:31 +00:00
|
|
|
1, "Prefix length: %u", pi->nd_opt_pi_prefix_len);
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
flagoff = offset + offsetof(struct nd_opt_prefix_info, nd_opt_pi_flags_reserved);
|
|
|
|
tf = proto_tree_add_text(icmp6opt_tree, tvb, flagoff, 1, "Flags: 0x%02x",
|
|
|
|
tvb_get_guint8(tvb, offset + offsetof(struct nd_opt_prefix_info, nd_opt_pi_flags_reserved)));
|
1999-11-16 11:44:20 +00:00
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
1999-03-29 02:21:34 +00:00
|
|
|
decode_boolean_bitfield(pi->nd_opt_pi_flags_reserved,
|
2001-06-01 23:53:49 +00:00
|
|
|
ND_OPT_PI_FLAG_ONLINK, 8, "Onlink", "Not onlink"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
1999-03-29 02:21:34 +00:00
|
|
|
decode_boolean_bitfield(pi->nd_opt_pi_flags_reserved,
|
2001-06-01 23:53:49 +00:00
|
|
|
ND_OPT_PI_FLAG_AUTO, 8, "Auto", "Not auto"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
2001-01-23 02:49:55 +00:00
|
|
|
decode_boolean_bitfield(pi->nd_opt_pi_flags_reserved,
|
2001-06-01 23:53:49 +00:00
|
|
|
ND_OPT_PI_FLAG_ROUTER, 8,
|
|
|
|
"Router Address", "Not router address"));
|
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(pi->nd_opt_pi_flags_reserved,
|
|
|
|
ND_OPT_PI_FLAG_SITEPREF, 8,
|
|
|
|
"Site prefix", "Not site prefix"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_opt_prefix_info, nd_opt_pi_valid_time),
|
|
|
|
4, "Valid lifetime: 0x%08x",
|
|
|
|
pntohl(&pi->nd_opt_pi_valid_time));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_opt_prefix_info, nd_opt_pi_preferred_time),
|
|
|
|
4, "Preferred lifetime: 0x%08x",
|
|
|
|
pntohl(&pi->nd_opt_pi_preferred_time));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_opt_prefix_info, nd_opt_pi_prefix),
|
|
|
|
16, "Prefix: %s", ip6_to_str(&pi->nd_opt_pi_prefix));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ND_OPT_REDIRECTED_HEADER:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + 8, (opt->nd_opt_len << 3) - 8, "Redirected packet");
|
2001-05-27 04:14:53 +00:00
|
|
|
dissect_contained_icmpv6(tvb, offset + 8, pinfo, icmp6opt_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ND_OPT_MTU:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_opt_mtu, nd_opt_mtu_mtu), 4,
|
2001-04-23 03:37:31 +00:00
|
|
|
"MTU: %u", tvb_get_ntohl(tvb, offset + offsetof(struct nd_opt_mtu, nd_opt_mtu_mtu)));
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
2001-06-01 23:53:49 +00:00
|
|
|
case ND_OPT_ADVINTERVAL:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
2001-01-23 02:49:55 +00:00
|
|
|
offset + offsetof(struct nd_opt_adv_int, nd_opt_adv_int_advint), 4,
|
2002-01-11 09:12:26 +00:00
|
|
|
"Advertisement Interval: %u",
|
2001-04-23 03:37:31 +00:00
|
|
|
tvb_get_ntohl(tvb, offset + offsetof(struct nd_opt_adv_int, nd_opt_adv_int_advint)));
|
2001-01-23 02:49:55 +00:00
|
|
|
break;
|
2001-06-01 23:53:49 +00:00
|
|
|
case ND_OPT_HOMEAGENT_INFO:
|
2001-01-23 02:49:55 +00:00
|
|
|
{
|
2001-06-01 23:53:49 +00:00
|
|
|
struct nd_opt_ha_info pibuf, *pi;
|
|
|
|
|
|
|
|
pi = &pibuf;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)pi, offset, sizeof *pi);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
2001-01-23 02:49:55 +00:00
|
|
|
offset + offsetof(struct nd_opt_ha_info, nd_opt_ha_info_ha_pref),
|
|
|
|
2, "Home Agent Preference: %d",
|
2002-01-11 09:12:26 +00:00
|
|
|
(gint16)pntohs(&pi->nd_opt_ha_info_ha_pref));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
2001-01-23 02:49:55 +00:00
|
|
|
offset + offsetof(struct nd_opt_ha_info, nd_opt_ha_info_ha_life),
|
2002-01-11 09:12:26 +00:00
|
|
|
2, "Home Agent Lifetime: %u",
|
2001-01-23 02:49:55 +00:00
|
|
|
pntohs(&pi->nd_opt_ha_info_ha_life));
|
|
|
|
break;
|
|
|
|
}
|
2001-09-04 21:04:52 +00:00
|
|
|
case ND_OPT_MAP:
|
|
|
|
{
|
|
|
|
struct nd_opt_map_info mapbuf, *map;
|
|
|
|
int flagoff;
|
|
|
|
|
|
|
|
map = &mapbuf;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)map, offset, sizeof *map);
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
2002-01-15 20:11:10 +00:00
|
|
|
offset + offsetof(struct nd_opt_map_info, nd_opt_map_dist_and_pref),
|
|
|
|
1, "Distance: %u", (map->nd_opt_map_dist_and_pref >> 4));
|
2001-09-04 21:04:52 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
2002-01-15 20:11:10 +00:00
|
|
|
offset + offsetof(struct nd_opt_map_info, nd_opt_map_dist_and_pref),
|
|
|
|
1, "Preference: %u", (map->nd_opt_map_dist_and_pref & 0x0F));
|
2001-09-04 21:04:52 +00:00
|
|
|
flagoff = offset + offsetof(struct nd_opt_map_info,
|
|
|
|
nd_opt_map_flags);
|
|
|
|
tf = proto_tree_add_text(icmp6opt_tree, tvb, flagoff, 1,
|
|
|
|
"Flags: 0x%02x",
|
|
|
|
tvb_get_guint8(tvb, offset + offsetof(struct nd_opt_map_info,
|
|
|
|
nd_opt_map_flags)));
|
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(map->nd_opt_map_flags,
|
2002-01-09 19:13:03 +00:00
|
|
|
ND_OPT_MAP_FLAG_R, 8, "R", "No R"));
|
2001-09-04 21:04:52 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(map->nd_opt_map_flags,
|
2002-01-09 19:13:03 +00:00
|
|
|
ND_OPT_MAP_FLAG_M, 8, "M", "No M"));
|
2001-09-04 21:04:52 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(map->nd_opt_map_flags,
|
2002-01-09 19:13:03 +00:00
|
|
|
ND_OPT_MAP_FLAG_I, 8, "I", "No I"));
|
2001-09-04 21:04:52 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(map->nd_opt_map_flags,
|
2002-01-09 19:13:03 +00:00
|
|
|
ND_OPT_MAP_FLAG_T, 8, "T", "No T"));
|
2001-09-04 21:04:52 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(map->nd_opt_map_flags,
|
2002-01-09 19:13:03 +00:00
|
|
|
ND_OPT_MAP_FLAG_P, 8, "P", "No P"));
|
2002-01-15 20:11:10 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(map->nd_opt_map_flags,
|
|
|
|
ND_OPT_MAP_FLAG_V, 8, "V", "No V"));
|
2001-09-04 21:04:52 +00:00
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_map_info, nd_opt_map_lifetime),
|
2002-01-10 09:49:35 +00:00
|
|
|
4, "Lifetime: %u", pntohl(&map->nd_opt_map_lifetime));
|
2001-09-04 21:04:52 +00:00
|
|
|
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_map_info, nd_opt_map_address), 16,
|
|
|
|
#ifdef INET6
|
|
|
|
"Address of MAP: %s (%s)",
|
|
|
|
get_hostname6(&map->nd_opt_map_address),
|
|
|
|
#else
|
|
|
|
"Address of MAP: %s",
|
|
|
|
#endif
|
|
|
|
ip6_to_str(&map->nd_opt_map_address));
|
|
|
|
break;
|
|
|
|
}
|
2001-06-01 23:53:49 +00:00
|
|
|
case ND_OPT_ROUTE_INFO:
|
|
|
|
{
|
|
|
|
struct nd_opt_route_info ribuf, *ri;
|
|
|
|
struct e_in6_addr in6;
|
|
|
|
int l;
|
2001-06-02 08:10:02 +00:00
|
|
|
guint32 lifetime;
|
2001-06-01 23:53:49 +00:00
|
|
|
|
|
|
|
ri = &ribuf;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)ri, offset, sizeof *ri);
|
|
|
|
memset(&in6, 0, sizeof(in6));
|
|
|
|
switch (ri->nd_opt_rti_len) {
|
|
|
|
case 1:
|
|
|
|
l = 0;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
tvb_memcpy(tvb, (guint8 *)&in6, offset + sizeof(*ri), l = 8);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
tvb_memcpy(tvb, (guint8 *)&in6, offset + sizeof(*ri), l = 16);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
l = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (l >= 0) {
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_route_info, nd_opt_rti_prefixlen),
|
|
|
|
1, "Prefix length: %u", ri->nd_opt_rti_prefixlen);
|
|
|
|
tf = proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_route_info, nd_opt_rti_flags),
|
|
|
|
1, "Flags: 0x%02x", ri->nd_opt_rti_flags);
|
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
|
|
|
proto_tree_add_text(field_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_route_info, nd_opt_rti_flags),
|
|
|
|
1, "%s",
|
|
|
|
decode_enumerated_bitfield(ri->nd_opt_rti_flags,
|
|
|
|
ND_RA_FLAG_RTPREF_MASK, 8, names_router_pref,
|
|
|
|
"Router preference: %s"));
|
|
|
|
lifetime = pntohl(&ri->nd_opt_rti_lifetime);
|
|
|
|
if (lifetime == 0xffffffff)
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_route_info, nd_opt_rti_lifetime),
|
|
|
|
sizeof(ri->nd_opt_rti_lifetime), "Lifetime: infinity");
|
|
|
|
else
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_route_info, nd_opt_rti_lifetime),
|
|
|
|
sizeof(ri->nd_opt_rti_lifetime), "Lifetime: %u", lifetime);
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + sizeof(*ri), l, "Prefix: %s", ip6_to_str(&in6));
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(icmp6opt_tree, tvb,
|
|
|
|
offset + offsetof(struct nd_opt_hdr, nd_opt_len), 1,
|
|
|
|
"Invalid option length: %u", opt->nd_opt_len);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2000-10-12 14:58:02 +00:00
|
|
|
}
|
|
|
|
|
1999-03-29 02:21:34 +00:00
|
|
|
offset += (opt->nd_opt_len << 3);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
2000-08-18 12:05:27 +00:00
|
|
|
/*
|
2001-04-23 03:37:31 +00:00
|
|
|
* draft-ietf-ipngwg-icmp-name-lookups-07.txt
|
2000-08-18 12:05:27 +00:00
|
|
|
* Note that the packet format was changed several times in the past.
|
|
|
|
*/
|
2000-08-22 08:30:00 +00:00
|
|
|
|
|
|
|
static const char *
|
|
|
|
bitrange0(v, s, buf, buflen)
|
2000-08-22 15:07:33 +00:00
|
|
|
guint32 v;
|
2000-08-22 08:30:00 +00:00
|
|
|
int s;
|
|
|
|
char *buf;
|
|
|
|
int buflen;
|
|
|
|
{
|
2000-08-22 15:07:33 +00:00
|
|
|
guint32 v0;
|
2000-08-22 08:30:00 +00:00
|
|
|
char *p, *ep;
|
|
|
|
int off;
|
|
|
|
int i, l;
|
|
|
|
|
|
|
|
if (buflen < 1)
|
|
|
|
return NULL;
|
|
|
|
if (buflen == 1) {
|
|
|
|
buf[0] = '\0';
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
v0 = v;
|
|
|
|
p = buf;
|
|
|
|
ep = buf + buflen - 1;
|
|
|
|
memset(buf, 0, buflen);
|
|
|
|
off = 0;
|
|
|
|
while (off < 32) {
|
|
|
|
/* shift till we have 0x01 */
|
|
|
|
if ((v & 0x01) == 0) {
|
|
|
|
switch (v & 0x0f) {
|
|
|
|
case 0x00:
|
|
|
|
v >>= 4; off += 4; continue;
|
|
|
|
case 0x08:
|
|
|
|
v >>= 3; off += 3; continue;
|
|
|
|
case 0x04: case 0x0c:
|
|
|
|
v >>= 2; off += 2; continue;
|
|
|
|
default:
|
|
|
|
v >>= 1; off += 1; continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we have 0x01 with us */
|
|
|
|
for (i = 0; i < 32 - off; i++) {
|
|
|
|
if ((v & (0x01 << i)) == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i == 1)
|
|
|
|
l = snprintf(p, ep - p, ",%d", s + off);
|
|
|
|
else {
|
|
|
|
l = snprintf(p, ep - p, ",%d-%d", s + off,
|
|
|
|
s + off + i - 1);
|
|
|
|
}
|
If "snprintf()" can't print all the data because there's not enough
room, it might return -1 in some versions of glibc; check for that, and
quit if that happens.
It might also return the number of characters that would've been printed
had there been enough room; this means that a loop that does
n += snprintf (buf + n, BUF_LENGTH - n, ...);
may end up making "n" bigger than BUF_LENGTH, and "snprintf()" might not
sanely handle being passed a negative length, so if "n" isn't less than
the total length of the string buffer, don't add stuff to it.
The "capabilitiesStart" variable in "add_capabilities()" in the WSP
dissector is an offset into the PDU data; there's no guarantee that said
offet is < 256, and, even if there were, there's no point in making it
an 8-bit variable.
Add some additional buffer overflow checks to the WSP dissector.
svn path=/trunk/; revision=3953
2001-09-25 18:27:35 +00:00
|
|
|
if (l == -1 || l > ep - p) {
|
2000-08-22 08:30:00 +00:00
|
|
|
buf[0] = '\0';
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
v >>= i; off += i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *
|
2001-04-23 03:37:31 +00:00
|
|
|
bitrange(tvbuff_t *tvb, int offset, int l, int s)
|
2000-08-22 08:30:00 +00:00
|
|
|
{
|
|
|
|
static char buf[1024];
|
|
|
|
char *q, *eq;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
q = buf;
|
|
|
|
eq = buf + sizeof(buf) - 1;
|
|
|
|
for (i = 0; i < l; i++) {
|
2001-04-23 03:37:31 +00:00
|
|
|
if (bitrange0(tvb_get_ntohl(tvb, offset + i * 4), s + i * 4, q, eq - q) == NULL) {
|
2000-08-22 08:30:00 +00:00
|
|
|
if (q != buf && q + 5 < buf + sizeof(buf))
|
|
|
|
strncpy(q, ",...", 5);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf + 1;
|
|
|
|
}
|
|
|
|
|
2000-08-18 12:05:27 +00:00
|
|
|
static void
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_nodeinfo(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
|
2000-08-18 12:05:27 +00:00
|
|
|
{
|
|
|
|
proto_tree *field_tree;
|
|
|
|
proto_item *tf;
|
2001-04-23 03:37:31 +00:00
|
|
|
struct icmp6_nodeinfo icmp6_nodeinfo, *ni;
|
2000-08-18 12:05:27 +00:00
|
|
|
int off;
|
2001-04-27 01:27:37 +00:00
|
|
|
unsigned int j;
|
2001-04-23 03:37:31 +00:00
|
|
|
int i, n, l, p;
|
2000-08-18 12:05:27 +00:00
|
|
|
guint16 flags;
|
2000-08-22 08:30:00 +00:00
|
|
|
char dname[MAXDNAME];
|
2001-04-23 03:37:31 +00:00
|
|
|
guint8 ipaddr[4];
|
2000-08-18 12:05:27 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
ni = &icmp6_nodeinfo;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)ni, offset, sizeof *ni);
|
2000-08-18 12:05:27 +00:00
|
|
|
/* flags */
|
|
|
|
flags = pntohs(&ni->ni_flags);
|
2001-04-23 03:37:31 +00:00
|
|
|
tf = proto_tree_add_text(tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "Flags: 0x%04x", flags);
|
|
|
|
field_tree = proto_item_add_subtree(tf, ett_nodeinfo_flag);
|
|
|
|
switch (pntohs(&ni->ni_qtype)) {
|
|
|
|
case NI_QTYPE_SUPTYPES:
|
|
|
|
if (ni->ni_type == ICMP6_NI_QUERY) {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_SUPTYPE_FLAG_COMPRESS, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"Compressed reply supported",
|
|
|
|
"No compressed reply support"));
|
|
|
|
} else {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_SUPTYPE_FLAG_COMPRESS, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"Compressed", "Not compressed"));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NI_QTYPE_DNSNAME:
|
|
|
|
if (ni->ni_type == ICMP6_NI_REPLY) {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_FQDN_FLAG_VALIDTTL, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"Valid TTL field", "Meaningless TTL field"));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NI_QTYPE_NODEADDR:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_NODEADDR_FLAG_GLOBAL, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"Global address",
|
|
|
|
"Not global address"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_NODEADDR_FLAG_SITELOCAL, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"Site-local address",
|
|
|
|
"Not site-local address"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_NODEADDR_FLAG_LINKLOCAL, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"Link-local address",
|
|
|
|
"Not link-local address"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_NODEADDR_FLAG_COMPAT, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"IPv4 compatible/mapped address",
|
|
|
|
"Not IPv4 compatible/mapped address"));
|
|
|
|
/* fall through */
|
|
|
|
case NI_QTYPE_IPV4ADDR:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_NODEADDR_FLAG_ALL, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"All unicast address",
|
|
|
|
"Unicast addresses on the queried interface"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_flags),
|
|
|
|
sizeof(ni->ni_flags), "%s",
|
2000-11-11 10:23:43 +00:00
|
|
|
decode_boolean_bitfield(flags, NI_NODEADDR_FLAG_TRUNCATE, sizeof(flags) * 8,
|
2000-08-18 12:05:27 +00:00
|
|
|
"Truncated", "Not truncated"));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* nonce */
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, icmp6_ni_nonce[0]),
|
|
|
|
sizeof(ni->icmp6_ni_nonce), "Nonce: 0x%08x%08x",
|
|
|
|
pntohl(&ni->icmp6_ni_nonce[0]), pntohl(&ni->icmp6_ni_nonce[4]));
|
|
|
|
|
|
|
|
/* offset for "the rest of data" */
|
|
|
|
off = sizeof(*ni);
|
|
|
|
|
2000-08-22 08:30:00 +00:00
|
|
|
/* rest of data */
|
2001-04-23 03:37:31 +00:00
|
|
|
if (!tvb_bytes_exist(tvb, offset, sizeof(*ni)))
|
2000-08-22 08:30:00 +00:00
|
|
|
goto nodata;
|
2000-08-18 12:05:27 +00:00
|
|
|
if (ni->ni_type == ICMP6_NI_QUERY) {
|
|
|
|
switch (ni->ni_code) {
|
|
|
|
case ICMP6_NI_SUBJ_IPV6:
|
2002-01-24 09:20:54 +00:00
|
|
|
n = tvb_reported_length_remaining(tvb, offset + sizeof(*ni));
|
2000-08-18 12:05:27 +00:00
|
|
|
n /= sizeof(struct e_in6_addr);
|
2001-04-23 03:37:31 +00:00
|
|
|
tf = proto_tree_add_text(tree, tvb,
|
2002-01-24 09:20:54 +00:00
|
|
|
offset + sizeof(*ni), -1, "IPv6 subject addresses");
|
2000-08-18 12:05:27 +00:00
|
|
|
field_tree = proto_item_add_subtree(tf, ett_nodeinfo_subject6);
|
2001-04-23 03:37:31 +00:00
|
|
|
p = offset + sizeof *ni;
|
2000-08-18 12:05:27 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
2001-04-23 03:37:31 +00:00
|
|
|
struct e_in6_addr e_in6_addr;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)&e_in6_addr, p, sizeof e_in6_addr);
|
|
|
|
proto_tree_add_text(field_tree, tvb,
|
|
|
|
p, sizeof(struct e_in6_addr),
|
|
|
|
"%s", ip6_to_str(&e_in6_addr));
|
2000-08-18 12:05:27 +00:00
|
|
|
p += sizeof(struct e_in6_addr);
|
|
|
|
}
|
2001-04-23 03:37:31 +00:00
|
|
|
off = tvb_length_remaining(tvb, offset);
|
2000-08-18 12:05:27 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_NI_SUBJ_FQDN:
|
2001-07-02 07:11:40 +00:00
|
|
|
l = get_dns_name(tvb, offset + sizeof(*ni),
|
|
|
|
offset + sizeof(*ni), dname, sizeof(dname));
|
2001-04-23 03:37:31 +00:00
|
|
|
if (tvb_bytes_exist(tvb, offset + sizeof(*ni) + l, 1) &&
|
|
|
|
tvb_get_guint8(tvb, offset + sizeof(*ni) + l) == 0) {
|
2000-08-22 08:30:00 +00:00
|
|
|
l++;
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset + sizeof(*ni), l,
|
2000-08-22 08:30:00 +00:00
|
|
|
"DNS label: %s (truncated)", dname);
|
|
|
|
} else {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset + sizeof(*ni), l,
|
2000-08-22 08:30:00 +00:00
|
|
|
"DNS label: %s", dname);
|
|
|
|
}
|
2001-04-23 03:37:31 +00:00
|
|
|
off = tvb_length_remaining(tvb, offset + sizeof(*ni) + l);
|
2000-08-18 12:05:27 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_NI_SUBJ_IPV4:
|
2002-01-24 09:20:54 +00:00
|
|
|
n = tvb_reported_length_remaining(tvb, offset + sizeof(*ni));
|
2000-08-18 12:05:27 +00:00
|
|
|
n /= sizeof(guint32);
|
2001-04-23 03:37:31 +00:00
|
|
|
tf = proto_tree_add_text(tree, tvb,
|
2002-01-24 09:20:54 +00:00
|
|
|
offset + sizeof(*ni), -1, "IPv4 subject addresses");
|
2000-08-18 12:05:27 +00:00
|
|
|
field_tree = proto_item_add_subtree(tf, ett_nodeinfo_subject4);
|
2001-04-23 03:37:31 +00:00
|
|
|
p = offset + sizeof *ni;
|
2000-08-18 12:05:27 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
2002-08-28 21:04:11 +00:00
|
|
|
tvb_memcpy(tvb, ipaddr, p, 4);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb,
|
|
|
|
p, sizeof(guint32), "%s", ip_to_str(ipaddr));
|
2000-08-18 12:05:27 +00:00
|
|
|
p += sizeof(guint32);
|
|
|
|
}
|
2001-04-23 03:37:31 +00:00
|
|
|
off = tvb_length_remaining(tvb, offset);
|
2000-08-18 12:05:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
switch (pntohs(&ni->ni_qtype)) {
|
|
|
|
case NI_QTYPE_NOOP:
|
2000-08-22 08:30:00 +00:00
|
|
|
break;
|
2000-08-18 12:05:27 +00:00
|
|
|
case NI_QTYPE_SUPTYPES:
|
2001-04-23 03:37:31 +00:00
|
|
|
p = offset + sizeof *ni;
|
|
|
|
tf = proto_tree_add_text(tree, tvb,
|
2002-01-24 09:20:54 +00:00
|
|
|
offset + sizeof(*ni), -1,
|
2000-08-22 08:30:00 +00:00
|
|
|
"Supported type bitmap%s",
|
|
|
|
(flags & 0x0001) ? ", compressed" : "");
|
|
|
|
field_tree = proto_item_add_subtree(tf,
|
|
|
|
ett_nodeinfo_nodebitmap);
|
|
|
|
n = 0;
|
2001-04-23 03:37:31 +00:00
|
|
|
while (tvb_bytes_exist(tvb, p, sizeof(guint32))) { /* XXXX Check what? */
|
2000-08-22 08:30:00 +00:00
|
|
|
if ((flags & 0x0001) == 0) {
|
2002-01-24 09:20:54 +00:00
|
|
|
l = tvb_reported_length_remaining(tvb, offset + sizeof(*ni));
|
2000-08-22 08:30:00 +00:00
|
|
|
l /= sizeof(guint32);
|
|
|
|
i = 0;
|
|
|
|
} else {
|
2001-04-23 03:37:31 +00:00
|
|
|
l = tvb_get_ntohs(tvb, p);
|
|
|
|
i = tvb_get_ntohs(tvb, p + sizeof(guint16)); /*skip*/
|
2000-08-22 08:30:00 +00:00
|
|
|
}
|
|
|
|
if (n + l * 32 > (1 << 16))
|
|
|
|
break;
|
|
|
|
if (n + (l + i) * 32 > (1 << 16))
|
|
|
|
break;
|
|
|
|
if ((flags & 0x0001) == 0) {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, p,
|
2000-08-22 08:30:00 +00:00
|
|
|
l * 4, "Bitmap (%d to %d): %s", n, n + l * 32 - 1,
|
2001-04-23 03:37:31 +00:00
|
|
|
bitrange(tvb, p, l, n));
|
2000-08-22 08:30:00 +00:00
|
|
|
p += l * 4;
|
|
|
|
} else {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, p,
|
2000-08-22 08:30:00 +00:00
|
|
|
4 + l * 4, "Bitmap (%d to %d): %s", n, n + l * 32 - 1,
|
2001-04-23 03:37:31 +00:00
|
|
|
bitrange(tvb, p + 4, l, n));
|
2000-08-22 08:30:00 +00:00
|
|
|
p += (4 + l * 4);
|
|
|
|
}
|
|
|
|
n += l * 32 + i * 32;
|
|
|
|
}
|
2001-04-23 03:37:31 +00:00
|
|
|
off = tvb_length_remaining(tvb, offset);
|
2000-08-22 08:30:00 +00:00
|
|
|
break;
|
2000-08-18 12:05:27 +00:00
|
|
|
case NI_QTYPE_DNSNAME:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset + sizeof(*ni),
|
|
|
|
sizeof(gint32), "TTL: %d", (gint32)tvb_get_ntohl(tvb, offset + sizeof *ni));
|
|
|
|
tf = proto_tree_add_text(tree, tvb,
|
2002-01-24 09:20:54 +00:00
|
|
|
offset + sizeof(*ni) + sizeof(guint32), -1,
|
2000-08-22 08:30:00 +00:00
|
|
|
"DNS labels");
|
|
|
|
field_tree = proto_item_add_subtree(tf, ett_nodeinfo_nodedns);
|
2001-04-27 01:27:37 +00:00
|
|
|
j = offset + sizeof (*ni) + sizeof(guint32);
|
2002-01-24 09:20:54 +00:00
|
|
|
while (j < tvb_reported_length(tvb)) {
|
2001-07-02 07:11:40 +00:00
|
|
|
l = get_dns_name(tvb, j,
|
|
|
|
offset + sizeof (*ni) + sizeof(guint32),
|
2001-04-23 03:37:31 +00:00
|
|
|
dname,sizeof(dname));
|
2001-07-02 07:11:40 +00:00
|
|
|
if (tvb_bytes_exist(tvb, j + l, 1) &&
|
|
|
|
tvb_get_guint8(tvb, j + l) == 0) {
|
2000-08-22 08:30:00 +00:00
|
|
|
l++;
|
2001-04-27 01:27:37 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, j, l,
|
2000-08-22 08:30:00 +00:00
|
|
|
"DNS label: %s (truncated)", dname);
|
|
|
|
} else {
|
2001-04-27 01:27:37 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, j, l,
|
2000-08-22 08:30:00 +00:00
|
|
|
"DNS label: %s", dname);
|
|
|
|
}
|
2001-04-27 01:27:37 +00:00
|
|
|
j += l;
|
2000-08-22 08:30:00 +00:00
|
|
|
}
|
2001-04-23 03:37:31 +00:00
|
|
|
off = tvb_length_remaining(tvb, offset);
|
2000-08-18 12:05:27 +00:00
|
|
|
break;
|
|
|
|
case NI_QTYPE_NODEADDR:
|
2002-01-24 09:20:54 +00:00
|
|
|
n = tvb_reported_length_remaining(tvb, offset + sizeof(*ni));
|
2001-04-23 03:37:31 +00:00
|
|
|
n /= sizeof(gint32) + sizeof(struct e_in6_addr);
|
|
|
|
tf = proto_tree_add_text(tree, tvb,
|
2002-01-24 09:20:54 +00:00
|
|
|
offset + sizeof(*ni), -1, "IPv6 node addresses");
|
2000-08-18 12:05:27 +00:00
|
|
|
field_tree = proto_item_add_subtree(tf, ett_nodeinfo_node6);
|
2001-04-23 03:37:31 +00:00
|
|
|
p = offset + sizeof (*ni);
|
2000-08-18 12:05:27 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
2001-04-23 03:37:31 +00:00
|
|
|
struct e_in6_addr e_in6_addr;
|
|
|
|
gint32 ttl;
|
|
|
|
ttl = (gint32)tvb_get_ntohl(tvb, p);
|
|
|
|
tvb_memcpy(tvb, (guint8 *)&e_in6_addr, p + sizeof ttl, sizeof e_in6_addr);
|
|
|
|
proto_tree_add_text(field_tree, tvb,
|
|
|
|
p, sizeof(struct e_in6_addr) + sizeof(gint32),
|
|
|
|
"%s (TTL %d)", ip6_to_str(&e_in6_addr), ttl);
|
2000-08-29 14:17:12 +00:00
|
|
|
p += sizeof(struct e_in6_addr) + sizeof(gint32);
|
2000-08-18 12:05:27 +00:00
|
|
|
}
|
2001-04-23 03:37:31 +00:00
|
|
|
off = tvb_length_remaining(tvb, offset);
|
2000-08-18 12:05:27 +00:00
|
|
|
break;
|
|
|
|
case NI_QTYPE_IPV4ADDR:
|
2002-01-24 09:20:54 +00:00
|
|
|
n = tvb_reported_length_remaining(tvb, offset + sizeof(*ni));
|
2001-04-23 03:37:31 +00:00
|
|
|
n /= sizeof(gint32) + sizeof(guint32);
|
|
|
|
tf = proto_tree_add_text(tree, tvb,
|
2002-01-24 09:20:54 +00:00
|
|
|
offset + sizeof(*ni), -1, "IPv4 node addresses");
|
2000-08-18 12:05:27 +00:00
|
|
|
field_tree = proto_item_add_subtree(tf, ett_nodeinfo_node4);
|
2001-04-23 03:37:31 +00:00
|
|
|
p = offset + sizeof *ni;
|
2000-08-18 12:05:27 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
2001-04-23 03:37:31 +00:00
|
|
|
tvb_memcpy(tvb, ipaddr, sizeof(gint32) + p, 4);
|
|
|
|
proto_tree_add_text(field_tree, tvb,
|
|
|
|
p, sizeof(guint32), "%s (TTL %d)", ip_to_str(ipaddr), tvb_get_ntohl(tvb, p));
|
|
|
|
p += sizeof(gint32) + sizeof(guint32);
|
2000-08-18 12:05:27 +00:00
|
|
|
}
|
2001-04-23 03:37:31 +00:00
|
|
|
off = tvb_length_remaining(tvb, offset);
|
2000-08-18 12:05:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2000-08-22 08:30:00 +00:00
|
|
|
nodata:;
|
2000-08-18 12:05:27 +00:00
|
|
|
|
|
|
|
/* the rest of data */
|
2001-11-25 22:51:14 +00:00
|
|
|
call_dissector(data_handle,tvb_new_subset(tvb, offset + off, -1, -1), pinfo, tree);
|
2000-08-18 12:05:27 +00:00
|
|
|
}
|
|
|
|
|
2000-11-09 16:39:59 +00:00
|
|
|
static void
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_rrenum(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
|
2000-11-09 16:39:59 +00:00
|
|
|
{
|
|
|
|
proto_tree *field_tree, *opt_tree;
|
|
|
|
proto_item *tf;
|
2001-04-23 03:37:31 +00:00
|
|
|
struct icmp6_router_renum icmp6_router_renum, *rr;
|
|
|
|
struct rr_pco_match rr_pco_match, *match;
|
|
|
|
struct rr_pco_use rr_pco_use, *use;
|
2001-04-27 01:27:37 +00:00
|
|
|
int flagoff, off;
|
|
|
|
unsigned int l;
|
2001-04-23 03:37:31 +00:00
|
|
|
guint8 flags;
|
2000-11-09 16:39:59 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
rr = &icmp6_router_renum;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)rr, offset, sizeof *rr);
|
|
|
|
proto_tree_add_text(tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
offset + offsetof(struct icmp6_router_renum, rr_seqnum), 4,
|
|
|
|
"Sequence number: 0x%08x", pntohl(&rr->rr_seqnum));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
offset + offsetof(struct icmp6_router_renum, rr_segnum), 1,
|
|
|
|
"Segment number: 0x%02x", rr->rr_segnum);
|
|
|
|
|
|
|
|
flagoff = offset + offsetof(struct icmp6_router_renum, rr_flags);
|
2001-04-23 03:37:31 +00:00
|
|
|
flags = tvb_get_guint8(tvb, flagoff);
|
|
|
|
tf = proto_tree_add_text(tree, tvb, flagoff, 1,
|
|
|
|
"Flags: 0x%02x", flags);
|
2000-11-09 16:39:59 +00:00
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags, 0x80, 8,
|
2000-11-09 16:39:59 +00:00
|
|
|
"Test command", "Not test command"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags, 0x40, 8,
|
2000-11-09 16:39:59 +00:00
|
|
|
"Result requested", "Result not requested"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags, 0x20, 8,
|
2000-11-09 16:39:59 +00:00
|
|
|
"All interfaces", "Not all interfaces"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags, 0x10, 8,
|
2000-11-09 16:39:59 +00:00
|
|
|
"Site specific", "Not site specific"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags, 0x08, 8,
|
2000-11-09 16:39:59 +00:00
|
|
|
"Processed previously", "Complete result"));
|
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
offset + offsetof(struct icmp6_router_renum, rr_maxdelay), 2,
|
|
|
|
"Max delay: 0x%04x", pntohs(&rr->rr_maxdelay));
|
2001-11-25 22:51:14 +00:00
|
|
|
call_dissector(data_handle,tvb_new_subset(tvb, offset + sizeof(*rr), -1, -1), pinfo, tree); /*XXX*/
|
2000-11-09 16:39:59 +00:00
|
|
|
|
|
|
|
if (rr->rr_code == ICMP6_ROUTER_RENUMBERING_COMMAND) {
|
|
|
|
off = offset + sizeof(*rr);
|
2001-04-23 03:37:31 +00:00
|
|
|
match = &rr_pco_match;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)match, off, sizeof *match);
|
|
|
|
tf = proto_tree_add_text(tree, tvb, off, sizeof(*match),
|
2000-11-09 16:39:59 +00:00
|
|
|
"Match-Prefix: %s/%u (%u-%u)", ip6_to_str(&match->rpm_prefix),
|
|
|
|
match->rpm_matchlen, match->rpm_minlen, match->rpm_maxlen);
|
|
|
|
opt_tree = proto_item_add_subtree(tf, ett_icmpv6opt);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_match, rpm_code),
|
2000-11-09 21:57:35 +00:00
|
|
|
sizeof(match->rpm_code), "OpCode: %s (%u)",
|
2002-08-28 21:04:11 +00:00
|
|
|
val_to_str(match->rpm_code, names_rrenum_matchcode, "Unknown"),
|
2000-11-09 16:39:59 +00:00
|
|
|
match->rpm_code);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_match, rpm_len),
|
|
|
|
sizeof(match->rpm_len), "OpLength: %u (%u octets)",
|
|
|
|
match->rpm_len, match->rpm_len * 8);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_match, rpm_ordinal),
|
|
|
|
sizeof(match->rpm_ordinal), "Ordinal: %u", match->rpm_ordinal);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_match, rpm_matchlen),
|
|
|
|
sizeof(match->rpm_matchlen), "MatchLen: %u", match->rpm_matchlen);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_match, rpm_minlen),
|
|
|
|
sizeof(match->rpm_minlen), "MinLen: %u", match->rpm_minlen);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_match, rpm_maxlen),
|
|
|
|
sizeof(match->rpm_maxlen), "MaxLen: %u", match->rpm_maxlen);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_match, rpm_prefix),
|
|
|
|
sizeof(match->rpm_prefix), "MatchPrefix: %s",
|
|
|
|
ip6_to_str(&match->rpm_prefix));
|
|
|
|
|
|
|
|
off += sizeof(*match);
|
2001-04-23 03:37:31 +00:00
|
|
|
use = &rr_pco_use;
|
2000-11-09 16:39:59 +00:00
|
|
|
for (l = match->rpm_len * 8 - sizeof(*match);
|
|
|
|
l >= sizeof(*use); l -= sizeof(*use), off += sizeof(*use)) {
|
2001-04-23 03:37:31 +00:00
|
|
|
tvb_memcpy(tvb, (guint8 *)use, off, sizeof *use);
|
|
|
|
tf = proto_tree_add_text(tree, tvb, off, sizeof(*use),
|
2000-11-09 16:39:59 +00:00
|
|
|
"Use-Prefix: %s/%u (keep %u)", ip6_to_str(&use->rpu_prefix),
|
|
|
|
use->rpu_uselen, use->rpu_keeplen);
|
|
|
|
opt_tree = proto_item_add_subtree(tf, ett_icmpv6opt);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_use, rpu_uselen),
|
|
|
|
sizeof(use->rpu_uselen), "UseLen: %u", use->rpu_uselen);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_use, rpu_keeplen),
|
|
|
|
sizeof(use->rpu_keeplen), "KeepLen: %u", use->rpu_keeplen);
|
2001-04-23 03:37:31 +00:00
|
|
|
tf = proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
flagoff = off + offsetof(struct rr_pco_use, rpu_ramask),
|
|
|
|
sizeof(use->rpu_ramask), "FlagMask: 0x%x", use->rpu_ramask);
|
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
2001-04-23 03:37:31 +00:00
|
|
|
flags = tvb_get_guint8(tvb, flagoff);
|
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags,
|
2000-11-09 16:39:59 +00:00
|
|
|
ICMP6_RR_PCOUSE_RAFLAGS_ONLINK, 8,
|
|
|
|
"Onlink", "Not onlink"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags,
|
2000-11-09 16:39:59 +00:00
|
|
|
ICMP6_RR_PCOUSE_RAFLAGS_AUTO, 8,
|
|
|
|
"Auto", "Not auto"));
|
2001-04-23 03:37:31 +00:00
|
|
|
tf = proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
flagoff = off + offsetof(struct rr_pco_use, rpu_raflags),
|
|
|
|
sizeof(use->rpu_raflags), "RAFlags: 0x%x", use->rpu_raflags);
|
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
2001-04-23 03:37:31 +00:00
|
|
|
flags = tvb_get_guint8(tvb, flagoff);
|
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags,
|
2000-11-09 16:39:59 +00:00
|
|
|
ICMP6_RR_PCOUSE_RAFLAGS_ONLINK, 8,
|
|
|
|
"Onlink", "Not onlink"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_boolean_bitfield(flags,
|
2000-11-09 16:39:59 +00:00
|
|
|
ICMP6_RR_PCOUSE_RAFLAGS_AUTO, 8, "Auto", "Not auto"));
|
|
|
|
if (pntohl(&use->rpu_vltime) == 0xffffffff)
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_use, rpu_vltime),
|
|
|
|
sizeof(use->rpu_vltime), "Valid Lifetime: infinity");
|
|
|
|
else
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_use, rpu_vltime),
|
|
|
|
sizeof(use->rpu_vltime), "Valid Lifetime: %u",
|
|
|
|
pntohl(&use->rpu_vltime));
|
|
|
|
if (pntohl(&use->rpu_pltime) == 0xffffffff)
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_use, rpu_pltime),
|
|
|
|
sizeof(use->rpu_pltime), "Preferred Lifetime: infinity");
|
|
|
|
else
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_use, rpu_pltime),
|
|
|
|
sizeof(use->rpu_pltime), "Preferred Lifetime: %u",
|
|
|
|
pntohl(&use->rpu_pltime));
|
2001-04-23 03:37:31 +00:00
|
|
|
tf = proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
flagoff = off + offsetof(struct rr_pco_use, rpu_flags),
|
|
|
|
sizeof(use->rpu_flags), "Flags: 0x%08x",
|
|
|
|
pntohl(&use->rpu_flags));
|
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
2001-04-23 03:37:31 +00:00
|
|
|
flags = tvb_get_guint8(tvb, flagoff);
|
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 4, "%s",
|
|
|
|
decode_boolean_bitfield(flags,
|
2000-11-09 16:39:59 +00:00
|
|
|
ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME, 32,
|
|
|
|
"Decrement valid lifetime", "No decrement valid lifetime"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 4, "%s",
|
|
|
|
decode_boolean_bitfield(flags,
|
2000-11-09 16:39:59 +00:00
|
|
|
ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME, 32,
|
|
|
|
"Decrement preferred lifetime",
|
|
|
|
"No decrement preferred lifetime"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(opt_tree, tvb,
|
2000-11-09 16:39:59 +00:00
|
|
|
off + offsetof(struct rr_pco_use, rpu_prefix),
|
|
|
|
sizeof(use->rpu_prefix), "UsePrefix: %s",
|
|
|
|
ip6_to_str(&use->rpu_prefix));
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-04-20 07:05:58 +00:00
|
|
|
static void
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_icmpv6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
1999-03-29 02:21:34 +00:00
|
|
|
{
|
|
|
|
proto_tree *icmp6_tree, *field_tree;
|
2000-12-14 21:45:12 +00:00
|
|
|
proto_item *ti, *tf = NULL;
|
2001-04-23 03:37:31 +00:00
|
|
|
struct icmp6_hdr icmp6_hdr, *dp;
|
2000-08-18 12:05:27 +00:00
|
|
|
struct icmp6_nodeinfo *ni = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
char *codename, *typename;
|
2000-08-18 12:05:27 +00:00
|
|
|
char *colcodename, *coltypename;
|
1999-03-29 02:21:34 +00:00
|
|
|
int len;
|
2000-12-14 21:45:12 +00:00
|
|
|
guint length, reported_length;
|
|
|
|
vec_t cksum_vec[4];
|
|
|
|
guint32 phdr[2];
|
|
|
|
guint16 cksum, computed_cksum;
|
2001-04-23 03:37:31 +00:00
|
|
|
int offset;
|
|
|
|
tvbuff_t *next_tvb;
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "ICMPv6");
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_clear(pinfo->cinfo, COL_INFO);
|
2001-05-27 04:14:53 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
offset = 0;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)&icmp6_hdr, offset, sizeof icmp6_hdr);
|
|
|
|
dp = &icmp6_hdr;
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = typename = colcodename = coltypename = "Unknown";
|
1999-03-29 02:21:34 +00:00
|
|
|
len = sizeof(*dp);
|
|
|
|
switch (dp->icmp6_type) {
|
|
|
|
case ICMP6_DST_UNREACH:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Unreachable";
|
1999-03-29 02:21:34 +00:00
|
|
|
switch (dp->icmp6_code) {
|
|
|
|
case ICMP6_DST_UNREACH_NOROUTE:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Route unreachable";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_DST_UNREACH_ADMIN:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Administratively prohibited";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_DST_UNREACH_NOTNEIGHBOR:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Not a neighbor";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_DST_UNREACH_ADDR:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Address unreachable";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_DST_UNREACH_NOPORT:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Port unreachable";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ICMP6_PACKET_TOO_BIG:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Too big";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_TIME_EXCEEDED:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Time exceeded";
|
1999-03-29 02:21:34 +00:00
|
|
|
switch (dp->icmp6_code) {
|
|
|
|
case ICMP6_TIME_EXCEED_TRANSIT:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "In-transit";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_TIME_EXCEED_REASSEMBLY:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Reassembly";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
1999-07-28 02:32:25 +00:00
|
|
|
break;
|
1999-03-29 02:21:34 +00:00
|
|
|
case ICMP6_PARAM_PROB:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Parameter problem";
|
1999-03-29 02:21:34 +00:00
|
|
|
switch (dp->icmp6_code) {
|
|
|
|
case ICMP6_PARAMPROB_HEADER:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Header";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_PARAMPROB_NEXTHEADER:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Next header";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_PARAMPROB_OPTION:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Option";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
1999-07-28 02:32:25 +00:00
|
|
|
break;
|
1999-03-29 02:21:34 +00:00
|
|
|
case ICMP6_ECHO_REQUEST:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Echo request";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_ECHO_REPLY:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Echo reply";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_MEMBERSHIP_QUERY:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Multicast listener query";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_MEMBERSHIP_REPORT:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Multicast listener report";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_MEMBERSHIP_REDUCTION:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Multicast listener done";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ND_ROUTER_SOLICIT:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Router solicitation";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
len = sizeof(struct nd_router_solicit);
|
|
|
|
break;
|
|
|
|
case ND_ROUTER_ADVERT:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Router advertisement";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
len = sizeof(struct nd_router_advert);
|
|
|
|
break;
|
|
|
|
case ND_NEIGHBOR_SOLICIT:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Neighbor solicitation";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
len = sizeof(struct nd_neighbor_solicit);
|
|
|
|
break;
|
|
|
|
case ND_NEIGHBOR_ADVERT:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Neighbor advertisement";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
len = sizeof(struct nd_neighbor_advert);
|
|
|
|
break;
|
|
|
|
case ND_REDIRECT:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Redirect";
|
|
|
|
codename = colcodename = NULL;
|
1999-03-29 02:21:34 +00:00
|
|
|
len = sizeof(struct nd_redirect);
|
|
|
|
break;
|
|
|
|
case ICMP6_ROUTER_RENUMBERING:
|
2000-08-18 12:05:27 +00:00
|
|
|
typename = coltypename = "Router renumbering";
|
1999-03-29 02:21:34 +00:00
|
|
|
switch (dp->icmp6_code) {
|
|
|
|
case ICMP6_ROUTER_RENUMBERING_COMMAND:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Command";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_ROUTER_RENUMBERING_RESULT:
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = colcodename = "Result";
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
2000-11-09 16:39:59 +00:00
|
|
|
case ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET:
|
|
|
|
codename = colcodename = "Sequence number reset";
|
|
|
|
break;
|
1999-03-29 02:21:34 +00:00
|
|
|
}
|
|
|
|
len = sizeof(struct icmp6_router_renum);
|
|
|
|
break;
|
2000-08-18 12:05:27 +00:00
|
|
|
case ICMP6_NI_QUERY:
|
|
|
|
case ICMP6_NI_REPLY:
|
|
|
|
ni = (struct icmp6_nodeinfo *)dp;
|
|
|
|
if (ni->ni_type == ICMP6_NI_QUERY) {
|
|
|
|
typename = coltypename = "Node information query";
|
|
|
|
switch (ni->ni_code) {
|
|
|
|
case ICMP6_NI_SUBJ_IPV6:
|
|
|
|
codename = "Query subject = IPv6 addresses";
|
|
|
|
break;
|
|
|
|
case ICMP6_NI_SUBJ_FQDN:
|
2001-04-23 03:37:31 +00:00
|
|
|
if (tvb_bytes_exist(tvb, offset, sizeof(*ni)))
|
2000-08-18 12:05:27 +00:00
|
|
|
codename = "Query subject = DNS name";
|
|
|
|
else
|
|
|
|
codename = "Query subject = empty";
|
|
|
|
break;
|
|
|
|
case ICMP6_NI_SUBJ_IPV4:
|
|
|
|
codename = "Query subject = IPv4 addresses";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
typename = coltypename = "Node information reply";
|
|
|
|
switch (ni->ni_code) {
|
|
|
|
case ICMP6_NI_SUCCESS:
|
|
|
|
codename = "Successful";
|
|
|
|
break;
|
|
|
|
case ICMP6_NI_REFUSED:
|
|
|
|
codename = "Refused";
|
|
|
|
break;
|
|
|
|
case ICMP6_NI_UNKNOWN:
|
|
|
|
codename = "Unknown query type";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
colcodename = val_to_str(pntohs(&ni->ni_qtype), names_nodeinfo_qtype,
|
|
|
|
"Unknown");
|
|
|
|
len = sizeof(struct icmp6_nodeinfo);
|
|
|
|
break;
|
1999-03-29 02:21:34 +00:00
|
|
|
}
|
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO)) {
|
1999-03-29 02:21:34 +00:00
|
|
|
char typebuf[256], codebuf[256];
|
|
|
|
|
2000-08-18 12:05:27 +00:00
|
|
|
if (coltypename && strcmp(coltypename, "Unknown") == 0) {
|
1999-03-29 02:21:34 +00:00
|
|
|
snprintf(typebuf, sizeof(typebuf), "Unknown (0x%02x)",
|
|
|
|
dp->icmp6_type);
|
2000-08-18 12:05:27 +00:00
|
|
|
coltypename = typebuf;
|
1999-03-29 02:21:34 +00:00
|
|
|
}
|
2000-08-18 12:05:27 +00:00
|
|
|
if (colcodename && strcmp(colcodename, "Unknown") == 0) {
|
1999-03-29 02:21:34 +00:00
|
|
|
snprintf(codebuf, sizeof(codebuf), "Unknown (0x%02x)",
|
|
|
|
dp->icmp6_code);
|
2000-08-18 12:05:27 +00:00
|
|
|
colcodename = codebuf;
|
1999-03-29 02:21:34 +00:00
|
|
|
}
|
2000-08-18 12:05:27 +00:00
|
|
|
if (colcodename) {
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s (%s)", coltypename, colcodename);
|
1999-03-29 02:21:34 +00:00
|
|
|
} else {
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s", coltypename);
|
1999-03-29 02:21:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
/* !!! specify length */
|
2001-04-23 03:37:31 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_icmpv6, tvb, offset, len, FALSE);
|
1999-11-16 11:44:20 +00:00
|
|
|
icmp6_tree = proto_item_add_subtree(ti, ett_icmpv6);
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_uint_format(icmp6_tree, hf_icmpv6_type, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_type), 1,
|
1999-10-10 16:09:33 +00:00
|
|
|
dp->icmp6_type,
|
2001-04-23 03:37:31 +00:00
|
|
|
"Type: %u (%s)", dp->icmp6_type, typename);
|
1999-03-29 02:21:34 +00:00
|
|
|
if (codename) {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_uint_format(icmp6_tree, hf_icmpv6_code, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_code), 1,
|
1999-10-10 16:09:33 +00:00
|
|
|
dp->icmp6_code,
|
2001-04-23 03:37:31 +00:00
|
|
|
"Code: %u (%s)", dp->icmp6_code, codename);
|
2000-08-18 12:05:27 +00:00
|
|
|
} else {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_uint_format(icmp6_tree, hf_icmpv6_code, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_code), 1,
|
|
|
|
dp->icmp6_code,
|
2001-04-23 03:37:31 +00:00
|
|
|
"Code: %u", dp->icmp6_code);
|
1999-03-29 02:21:34 +00:00
|
|
|
}
|
2002-08-02 23:36:07 +00:00
|
|
|
cksum = (guint16)g_htons(dp->icmp6_cksum);
|
2001-04-23 03:37:31 +00:00
|
|
|
length = tvb_length(tvb);
|
|
|
|
reported_length = tvb_reported_length(tvb);
|
|
|
|
if (!pinfo->fragmented && length >= reported_length) {
|
2000-12-14 21:45:12 +00:00
|
|
|
/* The packet isn't part of a fragmented datagram and isn't
|
|
|
|
truncated, so we can checksum it. */
|
|
|
|
|
|
|
|
/* Set up the fields of the pseudo-header. */
|
2001-04-23 03:37:31 +00:00
|
|
|
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;
|
2000-12-14 21:45:12 +00:00
|
|
|
cksum_vec[2].ptr = (const guint8 *)&phdr;
|
2002-08-02 23:36:07 +00:00
|
|
|
phdr[0] = g_htonl(tvb_reported_length(tvb));
|
|
|
|
phdr[1] = g_htonl(IP_PROTO_ICMPV6);
|
2000-12-14 21:45:12 +00:00
|
|
|
cksum_vec[2].len = 8;
|
2001-04-23 03:37:31 +00:00
|
|
|
cksum_vec[3].len = tvb_reported_length(tvb);
|
|
|
|
cksum_vec[3].ptr = tvb_get_ptr(tvb, offset, cksum_vec[3].len);
|
2000-12-14 21:45:12 +00:00
|
|
|
computed_cksum = in_cksum(cksum_vec, 4);
|
|
|
|
if (computed_cksum == 0) {
|
|
|
|
proto_tree_add_uint_format(icmp6_tree, hf_icmpv6_checksum,
|
2001-04-23 03:37:31 +00:00
|
|
|
tvb,
|
2000-12-14 21:45:12 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_cksum), 2,
|
|
|
|
cksum,
|
|
|
|
"Checksum: 0x%04x (correct)", cksum);
|
|
|
|
} else {
|
2001-03-28 21:24:15 +00:00
|
|
|
proto_tree_add_boolean_hidden(icmp6_tree, hf_icmpv6_checksum_bad,
|
2001-04-23 03:37:31 +00:00
|
|
|
tvb,
|
2001-02-28 19:33:49 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_cksum), 2,
|
|
|
|
TRUE);
|
2000-12-14 21:45:12 +00:00
|
|
|
proto_tree_add_uint_format(icmp6_tree, hf_icmpv6_checksum,
|
2001-04-23 03:37:31 +00:00
|
|
|
tvb,
|
2000-12-14 21:45:12 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_cksum), 2,
|
|
|
|
cksum,
|
|
|
|
"Checksum: 0x%04x (incorrect, should be 0x%04x)",
|
|
|
|
cksum, in_cksum_shouldbe(cksum, computed_cksum));
|
|
|
|
}
|
|
|
|
} else {
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_uint(icmp6_tree, hf_icmpv6_checksum, tvb,
|
2000-12-14 21:45:12 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_cksum), 2,
|
|
|
|
cksum);
|
|
|
|
}
|
1999-03-29 02:21:34 +00:00
|
|
|
|
|
|
|
/* decode... */
|
|
|
|
switch (dp->icmp6_type) {
|
|
|
|
case ICMP6_DST_UNREACH:
|
|
|
|
case ICMP6_TIME_EXCEEDED:
|
2001-05-27 04:14:53 +00:00
|
|
|
dissect_contained_icmpv6(tvb, offset + sizeof(*dp), pinfo,
|
|
|
|
icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_PACKET_TOO_BIG:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_mtu), 4,
|
2001-04-23 03:37:31 +00:00
|
|
|
"MTU: %u", pntohl(&dp->icmp6_mtu));
|
2001-05-27 04:14:53 +00:00
|
|
|
dissect_contained_icmpv6(tvb, offset + sizeof(*dp), pinfo,
|
|
|
|
icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_PARAM_PROB:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_pptr), 4,
|
|
|
|
"Problem pointer: 0x%04x", pntohl(&dp->icmp6_pptr));
|
2001-05-27 04:14:53 +00:00
|
|
|
dissect_contained_icmpv6(tvb, offset + sizeof(*dp), pinfo,
|
|
|
|
icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_ECHO_REQUEST:
|
|
|
|
case ICMP6_ECHO_REPLY:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_id), 2,
|
2002-08-02 23:36:07 +00:00
|
|
|
"ID: 0x%04x", (guint16)g_ntohs(dp->icmp6_id));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_seq), 2,
|
2002-08-02 23:36:07 +00:00
|
|
|
"Sequence: 0x%04x", (guint16)g_ntohs(dp->icmp6_seq));
|
2001-05-27 04:14:53 +00:00
|
|
|
next_tvb = tvb_new_subset(tvb, offset + sizeof(*dp), -1, -1);
|
2001-11-25 22:51:14 +00:00
|
|
|
call_dissector(data_handle,next_tvb, pinfo, icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ICMP6_MEMBERSHIP_QUERY:
|
|
|
|
case ICMP6_MEMBERSHIP_REPORT:
|
|
|
|
case ICMP6_MEMBERSHIP_REDUCTION:
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct icmp6_hdr, icmp6_maxdelay), 2,
|
2001-04-23 03:37:31 +00:00
|
|
|
"Maximum response delay: %u",
|
2002-08-02 23:36:07 +00:00
|
|
|
(guint16)g_ntohs(dp->icmp6_maxdelay));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb, offset + sizeof(*dp), 16,
|
1999-03-29 02:21:34 +00:00
|
|
|
"Multicast Address: %s",
|
2001-04-23 03:37:31 +00:00
|
|
|
ip6_to_str((struct e_in6_addr *)(tvb_get_ptr(tvb, offset + sizeof *dp, sizeof (struct e_in6_addr)))));
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ND_ROUTER_SOLICIT:
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_icmpv6opt(tvb, offset + sizeof(*dp), pinfo, icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
case ND_ROUTER_ADVERT:
|
|
|
|
{
|
2001-04-23 03:37:31 +00:00
|
|
|
struct nd_router_advert nd_router_advert, *ra;
|
1999-03-29 02:21:34 +00:00
|
|
|
int flagoff;
|
|
|
|
guint32 ra_flags;
|
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
ra = &nd_router_advert;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)ra, offset, sizeof *ra);
|
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_router_advert, nd_ra_curhoplimit),
|
2001-04-23 03:37:31 +00:00
|
|
|
1, "Cur hop limit: %u", ra->nd_ra_curhoplimit);
|
1999-03-29 02:21:34 +00:00
|
|
|
|
|
|
|
flagoff = offset + offsetof(struct nd_router_advert, nd_ra_flags_reserved);
|
2001-04-23 03:37:31 +00:00
|
|
|
ra_flags = tvb_get_guint8(tvb, flagoff);
|
|
|
|
tf = proto_tree_add_text(icmp6_tree, tvb, flagoff, 1, "Flags: 0x%02x", ra_flags);
|
1999-11-16 11:44:20 +00:00
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
1999-03-29 02:21:34 +00:00
|
|
|
decode_boolean_bitfield(ra_flags,
|
2001-06-01 23:53:49 +00:00
|
|
|
ND_RA_FLAG_MANAGED, 8, "Managed", "Not managed"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
1999-03-29 02:21:34 +00:00
|
|
|
decode_boolean_bitfield(ra_flags,
|
2001-06-01 23:53:49 +00:00
|
|
|
ND_RA_FLAG_OTHER, 8, "Other", "Not other"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
2001-01-23 02:49:55 +00:00
|
|
|
decode_boolean_bitfield(ra_flags,
|
2001-06-01 23:53:49 +00:00
|
|
|
ND_RA_FLAG_HOME_AGENT, 8,
|
2002-08-28 21:04:11 +00:00
|
|
|
"Home Agent", "Not Home Agent"));
|
2001-06-01 23:53:49 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 1, "%s",
|
|
|
|
decode_enumerated_bitfield(ra_flags, ND_RA_FLAG_RTPREF_MASK, 8,
|
|
|
|
names_router_pref, "Router preference: %s"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_router_advert, nd_ra_router_lifetime),
|
2001-04-23 03:37:31 +00:00
|
|
|
2, "Router lifetime: %u",
|
2002-08-02 23:36:07 +00:00
|
|
|
(guint16)g_ntohs(ra->nd_ra_router_lifetime));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_router_advert, nd_ra_reachable), 4,
|
2001-04-23 03:37:31 +00:00
|
|
|
"Reachable time: %u", pntohl(&ra->nd_ra_reachable));
|
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_router_advert, nd_ra_retransmit), 4,
|
2001-04-23 03:37:31 +00:00
|
|
|
"Retrans time: %u", pntohl(&ra->nd_ra_retransmit));
|
|
|
|
dissect_icmpv6opt(tvb, offset + sizeof(struct nd_router_advert), pinfo, icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ND_NEIGHBOR_SOLICIT:
|
|
|
|
{
|
2001-04-23 03:37:31 +00:00
|
|
|
struct nd_neighbor_solicit nd_neighbor_solicit, *ns;
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
ns = &nd_neighbor_solicit;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)ns, offset, sizeof *ns);
|
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_neighbor_solicit, nd_ns_target), 16,
|
|
|
|
#ifdef INET6
|
|
|
|
"Target: %s (%s)",
|
|
|
|
get_hostname6(&ns->nd_ns_target),
|
|
|
|
#else
|
|
|
|
"Target: %s",
|
|
|
|
#endif
|
|
|
|
ip6_to_str(&ns->nd_ns_target));
|
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_icmpv6opt(tvb, offset + sizeof(*ns), pinfo, icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ND_NEIGHBOR_ADVERT:
|
|
|
|
{
|
|
|
|
int flagoff, targetoff;
|
|
|
|
guint32 na_flags;
|
2001-04-23 03:37:31 +00:00
|
|
|
struct e_in6_addr na_target;
|
1999-03-29 02:21:34 +00:00
|
|
|
|
|
|
|
flagoff = offset + offsetof(struct nd_neighbor_advert, nd_na_flags_reserved);
|
2001-04-23 03:37:31 +00:00
|
|
|
na_flags = tvb_get_ntohl(tvb, flagoff);
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
tf = proto_tree_add_text(icmp6_tree, tvb, flagoff, 4, "Flags: 0x%08x", na_flags);
|
1999-11-16 11:44:20 +00:00
|
|
|
field_tree = proto_item_add_subtree(tf, ett_icmpv6flag);
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 4, "%s",
|
1999-03-29 02:21:34 +00:00
|
|
|
decode_boolean_bitfield(na_flags,
|
2000-11-11 10:23:43 +00:00
|
|
|
ND_NA_FLAG_ROUTER, 32, "Router", "Not router"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 4, "%s",
|
1999-03-29 02:21:34 +00:00
|
|
|
decode_boolean_bitfield(na_flags,
|
2000-11-11 10:23:43 +00:00
|
|
|
ND_NA_FLAG_SOLICITED, 32, "Solicited", "Not adverted"));
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(field_tree, tvb, flagoff, 4, "%s",
|
1999-03-29 02:21:34 +00:00
|
|
|
decode_boolean_bitfield(na_flags,
|
2000-11-11 10:23:43 +00:00
|
|
|
ND_NA_FLAG_OVERRIDE, 32, "Override", "Not override"));
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
targetoff = offset + offsetof(struct nd_neighbor_advert, nd_na_target);
|
|
|
|
tvb_memcpy(tvb, (guint8 *)&na_target, targetoff, sizeof na_target);
|
|
|
|
proto_tree_add_text(icmp6_tree, tvb, targetoff, 16,
|
1999-03-29 02:21:34 +00:00
|
|
|
#ifdef INET6
|
|
|
|
"Target: %s (%s)",
|
2001-04-23 03:37:31 +00:00
|
|
|
get_hostname6(&na_target),
|
1999-03-29 02:21:34 +00:00
|
|
|
#else
|
|
|
|
"Target: %s",
|
|
|
|
#endif
|
2001-04-23 03:37:31 +00:00
|
|
|
ip6_to_str(&na_target));
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_icmpv6opt(tvb, offset + sizeof(struct nd_neighbor_advert), pinfo, icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ND_REDIRECT:
|
|
|
|
{
|
2001-04-23 03:37:31 +00:00
|
|
|
struct nd_redirect nd_redirect, *rd;
|
1999-03-29 02:21:34 +00:00
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
rd = &nd_redirect;
|
|
|
|
tvb_memcpy(tvb, (guint8 *)rd, offset, sizeof *rd);
|
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_redirect, nd_rd_target), 16,
|
|
|
|
#ifdef INET6
|
|
|
|
"Target: %s (%s)",
|
|
|
|
get_hostname6(&rd->nd_rd_target),
|
|
|
|
#else
|
|
|
|
"Target: %s",
|
|
|
|
#endif
|
|
|
|
ip6_to_str(&rd->nd_rd_target));
|
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
1999-03-29 02:21:34 +00:00
|
|
|
offset + offsetof(struct nd_redirect, nd_rd_dst), 16,
|
|
|
|
#ifdef INET6
|
|
|
|
"Destination: %s (%s)",
|
|
|
|
get_hostname6(&rd->nd_rd_dst),
|
|
|
|
#else
|
|
|
|
"Destination: %s",
|
|
|
|
#endif
|
|
|
|
ip6_to_str(&rd->nd_rd_dst));
|
|
|
|
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_icmpv6opt(tvb, offset + sizeof(*rd), pinfo, icmp6_tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ICMP6_ROUTER_RENUMBERING:
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_rrenum(tvb, offset, pinfo, icmp6_tree);
|
2000-11-09 14:09:41 +00:00
|
|
|
break;
|
2000-08-18 12:05:27 +00:00
|
|
|
case ICMP6_NI_QUERY:
|
|
|
|
case ICMP6_NI_REPLY:
|
|
|
|
ni = (struct icmp6_nodeinfo *)dp;
|
2001-04-23 03:37:31 +00:00
|
|
|
proto_tree_add_text(icmp6_tree, tvb,
|
2000-08-18 12:05:27 +00:00
|
|
|
offset + offsetof(struct icmp6_nodeinfo, ni_qtype),
|
|
|
|
sizeof(ni->ni_qtype),
|
|
|
|
"Query type: 0x%04x (%s)", pntohs(&ni->ni_qtype),
|
|
|
|
val_to_str(pntohs(&ni->ni_qtype), names_nodeinfo_qtype,
|
|
|
|
"Unknown"));
|
2001-04-23 03:37:31 +00:00
|
|
|
dissect_nodeinfo(tvb, offset, pinfo, icmp6_tree);
|
2000-08-18 12:05:27 +00:00
|
|
|
break;
|
1999-03-29 02:21:34 +00:00
|
|
|
default:
|
2001-05-27 04:14:53 +00:00
|
|
|
next_tvb = tvb_new_subset(tvb, offset + sizeof(*dp), -1, -1);
|
2001-11-25 22:51:14 +00:00
|
|
|
call_dissector(data_handle,next_tvb, pinfo, tree);
|
1999-03-29 02:21:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-07-29 05:47:07 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_register_icmpv6(void)
|
|
|
|
{
|
1999-10-10 16:09:33 +00:00
|
|
|
static hf_register_info hf[] = {
|
|
|
|
{ &hf_icmpv6_type,
|
2001-04-23 03:37:31 +00:00
|
|
|
{ "Type", "icmpv6.type", FT_UINT8, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-10 16:09:33 +00:00
|
|
|
{ &hf_icmpv6_code,
|
2001-04-23 03:37:31 +00:00
|
|
|
{ "Code", "icmpv6.code", FT_UINT8, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-10 16:09:33 +00:00
|
|
|
{ &hf_icmpv6_checksum,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Checksum", "icmpv6.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
2001-02-28 19:33:49 +00:00
|
|
|
{ &hf_icmpv6_checksum_bad,
|
|
|
|
{ "Bad Checksum", "icmpv6.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-10 16:09:33 +00:00
|
|
|
};
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_icmpv6,
|
|
|
|
&ett_icmpv6opt,
|
|
|
|
&ett_icmpv6flag,
|
2000-08-18 12:05:27 +00:00
|
|
|
&ett_nodeinfo_flag,
|
|
|
|
&ett_nodeinfo_subject4,
|
|
|
|
&ett_nodeinfo_subject6,
|
|
|
|
&ett_nodeinfo_node4,
|
|
|
|
&ett_nodeinfo_node6,
|
2000-08-22 08:30:00 +00:00
|
|
|
&ett_nodeinfo_nodebitmap,
|
|
|
|
&ett_nodeinfo_nodedns,
|
1999-11-16 11:44:20 +00:00
|
|
|
};
|
1999-10-10 16:09:33 +00:00
|
|
|
|
|
|
|
proto_icmpv6 = proto_register_protocol("Internet Control Message Protocol v6",
|
2001-01-03 06:56:03 +00:00
|
|
|
"ICMPv6", "icmpv6");
|
1999-10-10 16:09:33 +00:00
|
|
|
proto_register_field_array(proto_icmpv6, hf, array_length(hf));
|
1999-11-16 11:44:20 +00:00
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
1999-07-29 05:47:07 +00:00
|
|
|
}
|
2000-04-20 07:05:58 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_icmpv6(void)
|
|
|
|
{
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_handle_t icmpv6_handle;
|
|
|
|
|
|
|
|
icmpv6_handle = create_dissector_handle(dissect_icmpv6, proto_icmpv6);
|
|
|
|
dissector_add("ip.proto", IP_PROTO_ICMPV6, icmpv6_handle);
|
2001-04-23 03:56:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a handle for the IPv6 dissector.
|
|
|
|
*/
|
|
|
|
ipv6_handle = find_dissector("ipv6");
|
2001-11-25 22:51:14 +00:00
|
|
|
data_handle = find_dissector("data");
|
2000-04-20 07:05:58 +00:00
|
|
|
}
|