forked from osmocom/wireshark
![Guy Harris](/assets/img/avatar_default.png)
This allows dissector lists to be looked up by name, so they can be shared by multiple dissectors. (This means that there's no "udplite" heuristic dissector list, but there shouldn't be one - protocols can run atop UDP or UDPLite equally well, and they share a port namespace and uint dissector table, so they should share a heuristic dissector table as well.) Change-Id: Ifb2d2c294938c06d348a159adea7a57db8d770a7 Reviewed-on: https://code.wireshark.org/review/5936 Reviewed-by: Guy Harris <guy@alum.mit.edu>
1187 lines
46 KiB
C
1187 lines
46 KiB
C
/* packet-corosync-totemsrp.c
|
|
* Dissectors for totem single ring protocol implementated in corosync cluster engine
|
|
* Copyright 2007 2009 2010 2014 Masatake YAMATO <yamato@redhat.com>
|
|
* Copyright (c) 2010 2014 Red Hat, Inc.
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 1998 Gerald Combs
|
|
*
|
|
* 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.
|
|
*
|
|
* 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.
|
|
*
|
|
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
/* Fields description are taken from
|
|
|
|
Y.AMIR, L.E.MOSER, P.M.MELLIAR-SMITH, D.A.AGARWAL, P.CIARFELLA.
|
|
"The Totem Single-Ring Ordering and Membership Protocol"*/
|
|
|
|
/*
|
|
* NOTE: the source code at www.corosync.org looks as if it will not
|
|
* work with multiple OSes in a cluster if it uses IPv6, as it appears
|
|
* to use the OS's AF_ values in packets, and the value of AF_INET6
|
|
* is ***NOT*** the same in all OSes.
|
|
*
|
|
* (It'll work with IPv4, because AF_INET came out of 4.2BSD and
|
|
* most if not all OSes just picked up BSD's value of 2.)
|
|
*
|
|
* So we just check for all the AF_INET6 values we know about.
|
|
*
|
|
* We get the AF_ values from epan/aftypes.h, *not* from the OS
|
|
* we happen to be built for.
|
|
*/
|
|
|
|
# include "config.h"
|
|
|
|
#include <epan/packet.h>
|
|
#include <epan/aftypes.h>
|
|
|
|
/*
|
|
* Utilities for subdissectors of corosync_totemsrp.
|
|
*/
|
|
struct corosync_totemsrp_info {
|
|
guint encoding;
|
|
guint nodeid;
|
|
};
|
|
|
|
/* Forward declaration we need below */
|
|
void proto_register_corosync_totemsrp(void);
|
|
void proto_reg_handoff_corosync_totemsrp(void);
|
|
|
|
/* Initialize the protocol and registered fields */
|
|
static int proto_corosync_totemsrp = -1;
|
|
|
|
static heur_dissector_list_t heur_subdissector_list;
|
|
|
|
/* fields for struct message_header */
|
|
static int hf_corosync_totemsrp_message_header_type = -1;
|
|
static int hf_corosync_totemsrp_message_header_encapsulated = -1;
|
|
static int hf_corosync_totemsrp_message_header_endian_detector = -1;
|
|
static int hf_corosync_totemsrp_message_header_nodeid = -1;
|
|
|
|
/* fields for struct orf_token */
|
|
static int hf_corosync_totemsrp_orf_token = -1;
|
|
static int hf_corosync_totemsrp_orf_token_seq = -1;
|
|
static int hf_corosync_totemsrp_orf_token_token_seq = -1;
|
|
static int hf_corosync_totemsrp_orf_token_aru = -1;
|
|
static int hf_corosync_totemsrp_orf_token_aru_addr = -1;
|
|
static int hf_corosync_totemsrp_orf_token_backlog = -1;
|
|
static int hf_corosync_totemsrp_orf_token_fcc = -1;
|
|
static int hf_corosync_totemsrp_orf_token_retrnas_flg = -1;
|
|
static int hf_corosync_totemsrp_orf_token_rtr_list_entries = -1;
|
|
|
|
/* field for struct memb_ring_id */
|
|
static int hf_corosync_totemsrp_memb_ring_id = -1;
|
|
static int hf_corosync_totemsrp_memb_ring_id_seq = -1;
|
|
|
|
/* field for struct totem_ip_address */
|
|
static int hf_corosync_totemsrp_ip_address = -1;
|
|
static int hf_corosync_totemsrp_ip_address_nodeid = -1;
|
|
static int hf_corosync_totemsrp_ip_address_family = -1;
|
|
static int hf_corosync_totemsrp_ip_address_addr = -1;
|
|
static int hf_corosync_totemsrp_ip_address_addr4 = -1;
|
|
static int hf_corosync_totemsrp_ip_address_addr4_padding = -1;
|
|
static int hf_corosync_totemsrp_ip_address_addr6 = -1;
|
|
|
|
/* field of struct mcast */
|
|
static int hf_corosync_totemsrp_mcast = -1;
|
|
static int hf_corosync_totemsrp_mcast_seq = -1;
|
|
static int hf_corosync_totemsrp_mcast_this_seqno = -1;
|
|
static int hf_corosync_totemsrp_mcast_node_id = -1;
|
|
static int hf_corosync_totemsrp_mcast_system_from = -1;
|
|
static int hf_corosync_totemsrp_mcast_guarantee = -1;
|
|
|
|
/* field of struct memb_merge_detect */
|
|
static int hf_corosync_totemsrp_memb_merge_detect = -1;
|
|
|
|
/* field of struct struct srp_addr */
|
|
static int hf_corosync_totemsrp_srp_addr = -1;
|
|
|
|
/* field of struct rtr_item */
|
|
static int hf_corosync_totemsrp_rtr_item = -1;
|
|
static int hf_corosync_totemsrp_rtr_item_seq = -1;
|
|
|
|
/* field of struct memb_join */
|
|
static int hf_corosync_totemsrp_memb_join = -1;
|
|
static int hf_corosync_totemsrp_memb_join_proc_list_entries = -1;
|
|
static int hf_corosync_totemsrp_memb_join_failed_list_entries = -1;
|
|
static int hf_corosync_totemsrp_memb_join_ring_seq = -1;
|
|
|
|
/* field of struct memb_commit_token */
|
|
static int hf_corosync_totemsrp_memb_commit_token = -1;
|
|
static int hf_corosync_totemsrp_memb_commit_token_token_seq = -1;
|
|
static int hf_corosync_totemsrp_memb_commit_token_retrans_flg = -1;
|
|
static int hf_corosync_totemsrp_memb_commit_token_memb_index = -1;
|
|
static int hf_corosync_totemsrp_memb_commit_token_addr_entries = -1;
|
|
|
|
/* field of struct memb_commit_token_memb_entry */
|
|
static int hf_corosync_totemsrp_memb_commit_token_memb_entry = -1;
|
|
static int hf_corosync_totemsrp_memb_commit_token_memb_entry_aru = -1;
|
|
static int hf_corosync_totemsrp_memb_commit_token_memb_entry_high_delivered = -1;
|
|
static int hf_corosync_totemsrp_memb_commit_token_memb_entry_received_flg = -1;
|
|
|
|
/* field of struct token_hold_cancel */
|
|
static int hf_corosync_totemsrp_token_hold_cancel = -1;
|
|
|
|
/* Initialize the subtree pointers */
|
|
static gint ett_corosync_totemsrp = -1;
|
|
static gint ett_corosync_totemsrp_orf_token = -1;
|
|
static gint ett_corosync_totemsrp_memb_ring_id = -1;
|
|
static gint ett_corosync_totemsrp_ip_address = -1;
|
|
static gint ett_corosync_totemsrp_mcast = -1;
|
|
static gint ett_corosync_totemsrp_memb_merge_detect = -1;
|
|
static gint ett_corosync_totemsrp_srp_addr = -1;
|
|
static gint ett_corosync_totemsrp_rtr_item = -1;
|
|
static gint ett_corosync_totemsrp_memb_join = -1;
|
|
static gint ett_corosync_totemsrp_memb_commit_token = -1;
|
|
static gint ett_corosync_totemsrp_memb_commit_token_memb_entry = -1;
|
|
static gint ett_corosync_totemsrp_token_hold_cancel = -1;
|
|
static gint ett_corosync_totemsrp_memb_join_proc_list = -1;
|
|
static gint ett_corosync_totemsrp_memb_join_failed_list = -1;
|
|
|
|
|
|
/*
|
|
* Value strings
|
|
*/
|
|
#define COROSYNC_TOTEMSRP_MESSAGE_TYPE_ORF_TOKEN 0
|
|
#define COROSYNC_TOTEMSRP_MESSAGE_TYPE_MCAST 1
|
|
#define COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_MERGE_DETECT 2
|
|
#define COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_JOIN 3
|
|
#define COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_COMMIT_TOKEN 4
|
|
#define COROSYNC_TOTEMSRP_MESSAGE_TYPE_TOKEN_HOLD_CANCEL 5
|
|
|
|
static const value_string corosync_totemsrp_message_header_type[] = {
|
|
{ COROSYNC_TOTEMSRP_MESSAGE_TYPE_ORF_TOKEN, "orf" },
|
|
{ COROSYNC_TOTEMSRP_MESSAGE_TYPE_MCAST, "mcast" },
|
|
{ COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_MERGE_DETECT, "merge rings" },
|
|
{ COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_JOIN, "join message" },
|
|
{ COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_COMMIT_TOKEN, "commit token" },
|
|
{ COROSYNC_TOTEMSRP_MESSAGE_TYPE_TOKEN_HOLD_CANCEL, "cancel" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
#define COROSYNC_TOTEMSRP_MESSAGE_ENCAPSULATED 1
|
|
#define COROSYNC_TOTEMSRP_MESSAGE_NOT_ENCAPSULATED 2
|
|
|
|
static const value_string corosync_totemsrp_message_header_encapsulated[] = {
|
|
{ 0, "not mcast message" },
|
|
{ COROSYNC_TOTEMSRP_MESSAGE_ENCAPSULATED, "encapsulated" },
|
|
{ COROSYNC_TOTEMSRP_MESSAGE_NOT_ENCAPSULATED, "not encapsulated" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
|
|
static const value_string corosync_totemsrp_ip_address_family[] = {
|
|
{ COMMON_AF_INET, "AF_INET" },
|
|
{ BSD_AF_INET6_BSD, "AF_INET6 (most BSD)" },
|
|
{ BSD_AF_INET6_FREEBSD, "AF_INET6 (FreeBSD)" },
|
|
{ BSD_AF_INET6_DARWIN, "AF_INET6 (OS X and iOS)" },
|
|
{ LINUX_AF_INET6, "AF_INET6 (Linux)" },
|
|
{ SOLARIS_AF_INET6, "AF_INET6 (Solaris)" },
|
|
{ WINSOCK_AF_INET6, "AF_INET6 (Windows)" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static guint16
|
|
corosync_totemsrp_get_guint16(tvbuff_t* tvb, gint offset, const guint encoding)
|
|
{
|
|
if (encoding == ENC_LITTLE_ENDIAN)
|
|
return tvb_get_letohs(tvb, offset);
|
|
|
|
return tvb_get_ntohs(tvb, offset);
|
|
}
|
|
|
|
|
|
static guint32
|
|
corosync_totemsrp_get_guint32(tvbuff_t* tvb, gint offset, const guint encoding)
|
|
{
|
|
if (encoding == ENC_LITTLE_ENDIAN)
|
|
return tvb_get_letohl(tvb, offset);
|
|
|
|
return tvb_get_ntohl(tvb, offset);
|
|
}
|
|
|
|
static guint64
|
|
corosync_totemsrp_get_guint64(tvbuff_t* tvb, gint offset, const guint encoding)
|
|
{
|
|
if (encoding == ENC_LITTLE_ENDIAN)
|
|
return tvb_get_letoh64(tvb, offset);
|
|
|
|
return tvb_get_ntoh64(tvb, offset);
|
|
}
|
|
|
|
|
|
#define COROSYNC_TOTEMSRP_SRP_ADDR_INTERFACE_MAX 2
|
|
|
|
static int dissect_corosync_totemsrp0(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree,
|
|
gboolean encapsulated);
|
|
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_ip_address(tvbuff_t *tvb,
|
|
packet_info *pinfo _U_,
|
|
proto_tree *parent_tree,
|
|
guint length _U_, int offset,
|
|
const guint encoding,
|
|
gboolean print_interface,
|
|
guint interface,
|
|
guint *nodeid)
|
|
{
|
|
guint16 family;
|
|
guint nid;
|
|
int original_offset = offset;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
gint len;
|
|
|
|
nid = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
if (nodeid)
|
|
*nodeid = nid;
|
|
family = corosync_totemsrp_get_guint16(tvb, offset + 4, encoding);
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_ip_address, tvb, offset,
|
|
-1, ENC_NA);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_ip_address);
|
|
|
|
proto_item_append_text(item, " (");
|
|
if (print_interface)
|
|
proto_item_append_text(item, "interface: %u; ", interface);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_ip_address_nodeid,
|
|
tvb, offset, 4, encoding);
|
|
proto_item_append_text(item, "node: %u)", nid);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_ip_address_family,
|
|
tvb, offset, 2, encoding);
|
|
offset += 2;
|
|
|
|
switch (family)
|
|
{
|
|
case COMMON_AF_INET:
|
|
len = 4;
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_ip_address_addr4, tvb, offset, len, ENC_BIG_ENDIAN);
|
|
break;
|
|
case BSD_AF_INET6_BSD:
|
|
case BSD_AF_INET6_FREEBSD:
|
|
case BSD_AF_INET6_DARWIN:
|
|
case LINUX_AF_INET6:
|
|
case SOLARIS_AF_INET6:
|
|
case WINSOCK_AF_INET6:
|
|
len = sizeof(struct e_in6_addr);
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_ip_address_addr6, tvb, offset, len, ENC_NA);
|
|
break;
|
|
default:
|
|
len = sizeof(struct e_in6_addr);
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_ip_address_addr, tvb, offset, len, ENC_NA);
|
|
break;
|
|
}
|
|
|
|
offset += len;
|
|
|
|
if (len != sizeof(struct e_in6_addr)) {
|
|
gint padding_len;
|
|
|
|
padding_len = (gint)(sizeof(struct e_in6_addr) - len);
|
|
proto_tree_add_item (tree, hf_corosync_totemsrp_ip_address_addr4_padding,
|
|
tvb, offset, padding_len, ENC_NA);
|
|
offset += padding_len;
|
|
}
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return offset - original_offset;
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_memb_ring_id(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
const guint encoding,
|
|
guint *node_id,
|
|
guint64 *ring_id)
|
|
{
|
|
int original_offset = offset;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
guint64 rid;
|
|
guint nid;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_ring_id, tvb, offset,
|
|
-1, encoding);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_ring_id);
|
|
|
|
offset += dissect_corosync_totemsrp_ip_address(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
FALSE, -1,
|
|
&nid);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_ring_id_seq,
|
|
tvb, offset, 8, encoding);
|
|
rid = corosync_totemsrp_get_guint64(tvb, offset, encoding);
|
|
offset += 8;
|
|
|
|
proto_item_append_text(item, " (ring: %" G_GINT64_MODIFIER "u)", rid);
|
|
|
|
if (node_id)
|
|
*node_id = nid;
|
|
if (ring_id)
|
|
*ring_id = rid;
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return offset - original_offset;
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_rtr_list(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
const guint encoding)
|
|
{
|
|
int original_offset = offset;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
|
|
guint node_id;
|
|
guint64 ring_id;
|
|
guint32 seq;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_rtr_item, tvb, offset,
|
|
-1, ENC_NA);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_rtr_item);
|
|
|
|
offset += dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
&node_id,
|
|
&ring_id);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_rtr_item_seq,
|
|
tvb, offset, 4, encoding);
|
|
|
|
seq = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
proto_item_append_text(item, " (ring: %" G_GINT64_MODIFIER "u node: %u seq: %u)",
|
|
ring_id, node_id, seq);
|
|
offset += 4;
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return (offset - original_offset);
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_orf_token(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
const guint encoding)
|
|
{
|
|
int original_offset = offset;
|
|
guint32 rtr_list_entries = 0, seq, aru, i;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
guint node_id;
|
|
guint64 ring_id;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_orf_token,
|
|
tvb, offset, -1, ENC_NA);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_orf_token);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_orf_token_seq,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_orf_token_token_seq,
|
|
tvb, offset, 4, encoding);
|
|
seq = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_orf_token_aru,
|
|
tvb, offset, 4, encoding);
|
|
aru = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_orf_token_aru_addr,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
offset += dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
&node_id,
|
|
&ring_id);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_orf_token_backlog,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_orf_token_fcc,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_orf_token_retrnas_flg,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_orf_token_rtr_list_entries,
|
|
tvb, offset, 4, encoding);
|
|
rtr_list_entries = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
offset += 4;
|
|
|
|
for (i = 0; i < rtr_list_entries; i++) {
|
|
offset += dissect_corosync_totemsrp_rtr_list(tvb, pinfo,
|
|
tree,
|
|
length, offset,
|
|
encoding);
|
|
}
|
|
|
|
proto_item_append_text(item, " (ring: %" G_GINT64_MODIFIER "u node: %u nrtr: %d seq: %d au: %u)",
|
|
ring_id, node_id, rtr_list_entries, seq, aru);
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return offset - original_offset;
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_srp_addr(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
int hf,
|
|
const guint encoding)
|
|
{
|
|
int original_offset = offset;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
guint nodeid;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf? hf: hf_corosync_totemsrp_srp_addr, tvb, offset,
|
|
-1, encoding);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_srp_addr);
|
|
|
|
offset += dissect_corosync_totemsrp_ip_address(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
TRUE, 0,
|
|
&nodeid);
|
|
proto_item_append_text(item, " (node: %u)", nodeid);
|
|
|
|
offset += dissect_corosync_totemsrp_ip_address(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
TRUE, 1,
|
|
NULL);
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return (offset - original_offset);
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_mcast(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *tree,
|
|
guint length, int offset,
|
|
guint8 message_header__encapsulated,
|
|
const guint encoding, proto_tree *parent_tree,
|
|
struct corosync_totemsrp_info *totemsrp_info)
|
|
{
|
|
int original_offset = offset;
|
|
proto_tree *mcast_tree;
|
|
|
|
proto_item *item;
|
|
guint node_id;
|
|
guint64 ring_id;
|
|
tvbuff_t *next_tvb;
|
|
|
|
heur_dtbl_entry_t *hdtbl_entry = NULL;
|
|
|
|
item = proto_tree_add_item(tree, hf_corosync_totemsrp_mcast, tvb, offset,
|
|
-1, encoding);
|
|
mcast_tree = proto_item_add_subtree(item, ett_corosync_totemsrp_mcast);
|
|
|
|
offset += dissect_corosync_totemsrp_srp_addr(tvb, pinfo, mcast_tree,
|
|
length, offset,
|
|
hf_corosync_totemsrp_mcast_system_from,
|
|
encoding);
|
|
|
|
proto_tree_add_item(mcast_tree, hf_corosync_totemsrp_mcast_seq,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(mcast_tree, hf_corosync_totemsrp_mcast_this_seqno,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
offset += dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, mcast_tree,
|
|
length, offset,
|
|
encoding,
|
|
&node_id,
|
|
&ring_id);
|
|
|
|
proto_item_append_text(item, " (ring: %" G_GINT64_MODIFIER "u node: %u)",
|
|
ring_id, node_id);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_mcast_node_id,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_mcast_guarantee,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
next_tvb = tvb_new_subset_remaining(tvb, offset);
|
|
|
|
if (message_header__encapsulated == COROSYNC_TOTEMSRP_MESSAGE_ENCAPSULATED)
|
|
{
|
|
offset += dissect_corosync_totemsrp0(next_tvb, pinfo, tree, TRUE);
|
|
}
|
|
else
|
|
{
|
|
if (dissector_try_heuristic(heur_subdissector_list,
|
|
next_tvb,
|
|
pinfo,
|
|
parent_tree,
|
|
&hdtbl_entry,
|
|
totemsrp_info))
|
|
offset = length;
|
|
}
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return (offset - original_offset);
|
|
}
|
|
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_memb_merge_detect(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
const guint encoding)
|
|
{
|
|
int original_offset = offset;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
guint node_id;
|
|
guint64 ring_id;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_merge_detect, tvb, offset,
|
|
-1, ENC_NA);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_merge_detect);
|
|
|
|
offset += dissect_corosync_totemsrp_srp_addr(tvb, pinfo, tree,
|
|
length, offset,
|
|
0,
|
|
encoding);
|
|
|
|
offset += dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
&node_id,
|
|
&ring_id);
|
|
|
|
proto_item_append_text(item, " (ring: %" G_GINT64_MODIFIER "u node: %u)",
|
|
ring_id, node_id);
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return (offset - original_offset);
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_memb_join(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
const guint encoding)
|
|
{
|
|
int original_offset = offset;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
|
|
guint32 proc_list_entries;
|
|
proto_tree *proc_tree;
|
|
|
|
guint32 failed_list_entries;
|
|
proto_tree *failed_tree;
|
|
proto_item *failed_item;
|
|
|
|
guint i;
|
|
|
|
proto_item *proc_item;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_join, tvb, offset,
|
|
-1, encoding);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_join);
|
|
|
|
|
|
offset += dissect_corosync_totemsrp_srp_addr(tvb, pinfo, tree,
|
|
length, offset,
|
|
0,
|
|
encoding);
|
|
|
|
proc_item = proto_tree_add_item(tree, hf_corosync_totemsrp_memb_join_proc_list_entries,
|
|
tvb, offset, 4, encoding);
|
|
proc_list_entries = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
offset += 4;
|
|
|
|
failed_item = proto_tree_add_item(tree, hf_corosync_totemsrp_memb_join_failed_list_entries,
|
|
tvb, offset, 4, encoding);
|
|
failed_list_entries = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_join_ring_seq,
|
|
tvb, offset, 8, encoding);
|
|
offset += 8;
|
|
|
|
proc_tree = proto_item_add_subtree(proc_item, ett_corosync_totemsrp_memb_join_proc_list);
|
|
|
|
proto_item_append_text(item, " (nprocs: %u nfailed: %u)",
|
|
proc_list_entries, failed_list_entries);
|
|
|
|
for (i = 0; i < proc_list_entries; i++) {
|
|
offset += dissect_corosync_totemsrp_srp_addr(tvb, pinfo, proc_tree,
|
|
length, offset,
|
|
0,
|
|
encoding);
|
|
}
|
|
|
|
failed_tree = proto_item_add_subtree(failed_item,
|
|
ett_corosync_totemsrp_memb_join_failed_list);
|
|
|
|
for (i = 0; i < failed_list_entries; i++) {
|
|
offset += dissect_corosync_totemsrp_srp_addr(tvb, pinfo, failed_tree,
|
|
length, offset,
|
|
0,
|
|
encoding);
|
|
}
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return (offset - original_offset);
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_memb_commit_token_memb_entry(tvbuff_t *tvb,
|
|
packet_info *pinfo,
|
|
proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
const guint encoding,
|
|
guint *node_id,
|
|
guint64 *ring_id)
|
|
{
|
|
int original_offset = offset;
|
|
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_commit_token_memb_entry,
|
|
tvb, offset, -1, encoding);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_commit_token_memb_entry);
|
|
|
|
|
|
offset += dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
node_id,
|
|
ring_id);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_commit_token_memb_entry_aru,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_commit_token_memb_entry_high_delivered,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_commit_token_memb_entry_received_flg,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return (offset - original_offset);
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_memb_commit_token(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
const guint encoding)
|
|
{
|
|
int original_offset = offset;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
|
|
guint32 i, addr_entries;
|
|
|
|
guint32 seq;
|
|
guint node_id;
|
|
guint64 ring_id;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_commit_token,
|
|
tvb, offset, -1, ENC_NA);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_commit_token);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_commit_token_token_seq,
|
|
tvb, offset, 4, encoding);
|
|
seq = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
offset += 4;
|
|
|
|
offset += dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
&node_id,
|
|
&ring_id);
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_commit_token_retrans_flg,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_commit_token_memb_index,
|
|
tvb, offset, 4, encoding);
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_corosync_totemsrp_memb_commit_token_addr_entries,
|
|
tvb, offset, 4, encoding);
|
|
addr_entries = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
offset += 4;
|
|
|
|
for (i = 0; i < addr_entries; i++) {
|
|
offset += dissect_corosync_totemsrp_srp_addr(tvb, pinfo, tree,
|
|
length, offset,
|
|
0,
|
|
encoding);
|
|
}
|
|
|
|
for (i = 0; i < addr_entries; i++) {
|
|
offset += dissect_corosync_totemsrp_memb_commit_token_memb_entry(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
NULL,
|
|
NULL);
|
|
}
|
|
|
|
proto_item_append_text(item, " (ring: %" G_GINT64_MODIFIER "u node: %u seq: %u entries: %u)",
|
|
ring_id, node_id, seq, addr_entries);
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return (offset - original_offset);
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp_token_hold_cancel(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *parent_tree,
|
|
guint length, int offset,
|
|
const guint encoding)
|
|
{
|
|
int original_offset = offset;
|
|
proto_tree *tree;
|
|
proto_item *item;
|
|
guint node_id;
|
|
guint64 ring_id;
|
|
|
|
item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_token_hold_cancel, tvb, offset,
|
|
-1, ENC_NA);
|
|
tree = proto_item_add_subtree(item, ett_corosync_totemsrp_token_hold_cancel);
|
|
|
|
offset += dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
|
|
length, offset,
|
|
encoding,
|
|
&node_id,
|
|
&ring_id);
|
|
|
|
proto_item_append_text(item, " (ring: %" G_GINT64_MODIFIER "u node: %u)",
|
|
ring_id, node_id);
|
|
|
|
proto_item_set_len(item, offset - original_offset);
|
|
return (offset - original_offset);
|
|
}
|
|
|
|
static int
|
|
dissect_corosync_totemsrp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void* data _U_)
|
|
{
|
|
return dissect_corosync_totemsrp0(tvb, pinfo, parent_tree, FALSE);
|
|
}
|
|
|
|
#define COROSYNC_TOTEMSRP_TEST_LITTLE_ENDIAN 0x22FF
|
|
#define COROSYNC_TOTEMSRP_TEST_BIG_ENDIAN 0xFF22
|
|
|
|
static int
|
|
dissect_corosync_totemsrp0(tvbuff_t *tvb,
|
|
packet_info *pinfo, proto_tree *tree,
|
|
gboolean encapsulated)
|
|
{
|
|
proto_item *item;
|
|
guint length;
|
|
int offset = 0;
|
|
guint16 endian_test;
|
|
proto_tree *corosync_tree;
|
|
|
|
guint8 message_header__type;
|
|
guint8 message_header__encapsulated;
|
|
|
|
guint encoding;
|
|
struct corosync_totemsrp_info info;
|
|
|
|
/* Check that there's enough data */
|
|
length = tvb_reported_length(tvb);
|
|
if (length < 1 + 1 + 2 + 4)
|
|
return 0;
|
|
|
|
/* message header */
|
|
message_header__type = tvb_get_guint8(tvb, 0);
|
|
if (message_header__type > 5)
|
|
return 0;
|
|
|
|
message_header__encapsulated = tvb_get_guint8(tvb, 1);
|
|
|
|
/* message_header -- byte order checking */
|
|
endian_test = tvb_get_ntohs(tvb, 2);
|
|
if (endian_test == COROSYNC_TOTEMSRP_TEST_LITTLE_ENDIAN)
|
|
encoding = ENC_LITTLE_ENDIAN;
|
|
else if (endian_test == COROSYNC_TOTEMSRP_TEST_BIG_ENDIAN)
|
|
encoding = ENC_BIG_ENDIAN;
|
|
else
|
|
return 0;
|
|
|
|
if (encapsulated == FALSE)
|
|
{
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "COROSYNC/TOTEMSRP");
|
|
col_set_str(pinfo->cinfo, COL_INFO,
|
|
((message_header__type == COROSYNC_TOTEMSRP_MESSAGE_TYPE_MCAST)
|
|
&& (message_header__encapsulated == COROSYNC_TOTEMSRP_MESSAGE_ENCAPSULATED))?
|
|
"ENCAPSULATED":
|
|
val_to_str_const(message_header__type,
|
|
corosync_totemsrp_message_header_type,
|
|
"Unknown"));
|
|
}
|
|
|
|
item = proto_tree_add_item(tree, proto_corosync_totemsrp, tvb, offset, -1, ENC_NA);
|
|
corosync_tree = proto_item_add_subtree(item, ett_corosync_totemsrp);
|
|
|
|
proto_tree_add_item(corosync_tree, hf_corosync_totemsrp_message_header_type,
|
|
tvb, offset, 1, ENC_NA);
|
|
offset += 1;
|
|
|
|
proto_tree_add_item(corosync_tree, hf_corosync_totemsrp_message_header_encapsulated,
|
|
tvb, offset, 1, ENC_NA);
|
|
offset += 1;
|
|
|
|
proto_tree_add_item(corosync_tree, hf_corosync_totemsrp_message_header_endian_detector,
|
|
tvb, offset, 2, encoding);
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(corosync_tree,
|
|
hf_corosync_totemsrp_message_header_nodeid,
|
|
tvb, offset, 4, encoding);
|
|
info.encoding = encoding;
|
|
info.nodeid = corosync_totemsrp_get_guint32(tvb, offset, encoding);
|
|
offset += 4;
|
|
|
|
switch (message_header__type) {
|
|
case COROSYNC_TOTEMSRP_MESSAGE_TYPE_ORF_TOKEN:
|
|
dissect_corosync_totemsrp_orf_token(tvb, pinfo, corosync_tree, length, offset, encoding);
|
|
break;
|
|
case COROSYNC_TOTEMSRP_MESSAGE_TYPE_MCAST:
|
|
dissect_corosync_totemsrp_mcast(tvb, pinfo, corosync_tree, length, offset,
|
|
message_header__encapsulated,
|
|
encoding, tree, &info);
|
|
break;
|
|
case COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_MERGE_DETECT:
|
|
dissect_corosync_totemsrp_memb_merge_detect(tvb, pinfo, corosync_tree, length, offset,
|
|
encoding);
|
|
break;
|
|
case COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_JOIN:
|
|
dissect_corosync_totemsrp_memb_join(tvb, pinfo, corosync_tree, length, offset,
|
|
encoding);
|
|
break;
|
|
case COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_COMMIT_TOKEN:
|
|
dissect_corosync_totemsrp_memb_commit_token(tvb, pinfo, corosync_tree, length, offset,
|
|
encoding);
|
|
break;
|
|
case COROSYNC_TOTEMSRP_MESSAGE_TYPE_TOKEN_HOLD_CANCEL:
|
|
dissect_corosync_totemsrp_token_hold_cancel(tvb, pinfo, corosync_tree, length, offset,
|
|
encoding);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
void
|
|
proto_register_corosync_totemsrp(void)
|
|
{
|
|
static hf_register_info hf[] = {
|
|
/* message_header */
|
|
{ &hf_corosync_totemsrp_message_header_type,
|
|
{ "Type", "corosync_totemsrp.message_header.type",
|
|
FT_INT8, BASE_DEC, VALS(corosync_totemsrp_message_header_type), 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_message_header_encapsulated,
|
|
{ "Encapsulated", "corosync_totemsrp.message_header.encapsulated",
|
|
FT_INT8, BASE_DEC, VALS(corosync_totemsrp_message_header_encapsulated), 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_message_header_endian_detector,
|
|
{ "Endian detector", "corosync_totemsrp.message_header.endian_detector",
|
|
FT_UINT16, BASE_HEX, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_message_header_nodeid,
|
|
{ "Node ID", "corosync_totemsrp.message_header.nodeid",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
/* orf_token */
|
|
{ &hf_corosync_totemsrp_orf_token,
|
|
{ "Ordering, Reliability, Flow (ORF) control Token", "corosync_totemsrp.orf_token",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_orf_token_seq,
|
|
{ "Sequence number allowing recognition of redundant copies of the token", "corosync_totemsrp.orf_token.seq",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_orf_token_token_seq,
|
|
{ "The largest sequence number", "corosync_totemsrp.orf_token.seq",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
"The largest sequence number of any message "
|
|
"that has been broadcast on the ring"
|
|
"[1]" ,
|
|
HFILL }},
|
|
{ &hf_corosync_totemsrp_orf_token_aru,
|
|
{ "Sequence number all received up to", "corosync_totemsrp.orf_token.aru",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_orf_token_aru_addr,
|
|
{ "ID of node setting ARU", "corosync_totemsrp.orf_token.aru_addr",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_orf_token_backlog,
|
|
{ "Backlog", "corosync_totemsrp.orf_token.backlog",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
"The sum of the number of new message waiting to be transmitted by each processor on the ring "
|
|
"at the time at which that processor forwarded the token during the previous rotation"
|
|
"[1]",
|
|
HFILL }},
|
|
{ &hf_corosync_totemsrp_orf_token_fcc,
|
|
{ "FCC",
|
|
"corosync_totemsrp.orf_token.fcc",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
"A count of the number of messages broadcast by all processors "
|
|
"during the previous rotation of the token"
|
|
"[1]",
|
|
HFILL }},
|
|
{ &hf_corosync_totemsrp_orf_token_retrnas_flg,
|
|
{ "Retransmission flag", "corosync_totemsrp.orf_token.retrans_flg",
|
|
FT_INT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_orf_token_rtr_list_entries,
|
|
{ "The number of retransmission list entries", "corosync_totemsrp.orf_token.rtr_list_entries",
|
|
FT_INT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
/* memb_ring_id */
|
|
{ &hf_corosync_totemsrp_memb_ring_id,
|
|
{ "Member ring id", "corosync_totemsrp.memb_ring_id",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_memb_ring_id_seq,
|
|
{ "Sequence in member ring id", "corosync_totemsrp.memb_ring_id.seq",
|
|
FT_UINT64, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
/* totem_ip_address */
|
|
{ &hf_corosync_totemsrp_ip_address,
|
|
{ "Node IP address", "corosync_totemsrp.ip_address",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_ip_address_nodeid,
|
|
{ "Node ID", "corosync_totemsrp.ip_address.nodeid",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_ip_address_family,
|
|
{ "Address family", "corosync_totemsrp.ip_address.family",
|
|
FT_UINT16, BASE_DEC, VALS(corosync_totemsrp_ip_address_family), 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_ip_address_addr,
|
|
{ "Address", "corosync_totemsrp.ip_address.addr",
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_ip_address_addr4,
|
|
{ "Address", "corosync_totemsrp.ip_address.addr4",
|
|
FT_IPv4, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_ip_address_addr4_padding,
|
|
{ "Address padding", "corosync_totemsrp.ip_address.addr4_padding",
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_ip_address_addr6,
|
|
{ "Address", "corosync_totemsrp.ip_address.addr6",
|
|
FT_IPv6, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
/* mcast */
|
|
{ &hf_corosync_totemsrp_mcast,
|
|
{ "ring ordered multicast message", "corosync_totemsrp.mcast",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_mcast_seq,
|
|
{"Multicast sequence number", "corosync_totemsrp.mcast.seq",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_mcast_this_seqno,
|
|
{"This Sequence number", "corosync_totemsrp.mcast.this_seqno",
|
|
FT_INT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_mcast_node_id,
|
|
{"Node id(unused?)", "corosync_totemsrp.mcast.node_id",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_mcast_system_from,
|
|
{"System from address", "corosync_totemsrp.mcast.system_from",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_corosync_totemsrp_mcast_guarantee,
|
|
{"Guarantee", "corosync_totemsrp.mcast.guarantee",
|
|
FT_INT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
/* memb_merge_detect */
|
|
{ &hf_corosync_totemsrp_memb_merge_detect,
|
|
{ "Merge rings if there are available rings", "corosync_totemsrp.memb_merge_detect",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
/* srp_addr */
|
|
{ &hf_corosync_totemsrp_srp_addr,
|
|
{"Single Ring Protocol Address", "corosync_totemsrp.srp_addr",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
/* rtr_item */
|
|
{ &hf_corosync_totemsrp_rtr_item,
|
|
{"Retransmission Item", "corosync_totemsrp.rtr_item",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
{ &hf_corosync_totemsrp_rtr_item_seq,
|
|
{"Sequence of Retransmission Item", "corosync_totemsrp.rtr_item.seq",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
/* memb_join */
|
|
{ &hf_corosync_totemsrp_memb_join,
|
|
{"Membership join message", "corosync_totemsrp.memb_join",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_join_proc_list_entries,
|
|
{"The number of processor list entries", "corosync_totemsrp.memb_join.proc_list_entries",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_join_failed_list_entries,
|
|
{"The number of failed list entries", "corosync_totemsrp.memb_join.failed_list_entries",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_join_ring_seq,
|
|
{"Ring sequence number", "corosync_totemsrp.memb_join.ring_seq",
|
|
FT_UINT64, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
|
|
/* memb_commit_token */
|
|
{ &hf_corosync_totemsrp_memb_commit_token,
|
|
{"Membership commit token", "corosync_totemsrp.memb_commit_token",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_commit_token_token_seq,
|
|
{"Token sequence", "corosync_totemsrp.memb_commit_token.token_seq",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_commit_token_retrans_flg,
|
|
{"Retransmission flag", "corosync_totemsrp.memb_commit_token.retrans_flg",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_commit_token_memb_index,
|
|
{"Member index", "corosync_totemsrp.memb_commit_token.memb_index",
|
|
FT_INT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_commit_token_addr_entries,
|
|
{"The number of address entries", "corosync_totemsrp.memb_commit_token.addr_entries",
|
|
FT_INT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
|
|
/* memb_commit_token_memb_entry */
|
|
{ &hf_corosync_totemsrp_memb_commit_token_memb_entry,
|
|
{ "Membership entry", "corosync_totemsrp.memb_commit_token_memb_entry",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_commit_token_memb_entry_aru,
|
|
{"Sequence number all received up to", "corosync_totemsrp.memb_commit_token_memb_entry.aru",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_commit_token_memb_entry_high_delivered,
|
|
{"High delivered", "corosync_totemsrp.memb_commit_token_memb_entry.high_delivered",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
{ &hf_corosync_totemsrp_memb_commit_token_memb_entry_received_flg,
|
|
{"Received flag", "corosync_totemsrp.memb_commit_token_memb_entry.received_flg",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
|
|
/* token_hold_canel */
|
|
{ &hf_corosync_totemsrp_token_hold_cancel,
|
|
{"Hold cancel token", "corosync_totemsrp.token_hold_canel",
|
|
FT_NONE, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL}},
|
|
};
|
|
|
|
static gint *ett[] = {
|
|
&ett_corosync_totemsrp,
|
|
&ett_corosync_totemsrp_orf_token,
|
|
&ett_corosync_totemsrp_memb_ring_id,
|
|
&ett_corosync_totemsrp_ip_address,
|
|
&ett_corosync_totemsrp_mcast,
|
|
&ett_corosync_totemsrp_memb_merge_detect,
|
|
&ett_corosync_totemsrp_srp_addr,
|
|
&ett_corosync_totemsrp_rtr_item,
|
|
&ett_corosync_totemsrp_memb_join,
|
|
&ett_corosync_totemsrp_memb_commit_token,
|
|
&ett_corosync_totemsrp_memb_commit_token_memb_entry,
|
|
&ett_corosync_totemsrp_token_hold_cancel,
|
|
&ett_corosync_totemsrp_memb_join_proc_list,
|
|
&ett_corosync_totemsrp_memb_join_failed_list
|
|
|
|
};
|
|
|
|
proto_corosync_totemsrp = proto_register_protocol("Totem Single Ring Protocol implemented in Corosync Cluster Engine",
|
|
"COROSYNC/TOTEMSRP", "corosync_totemsrp");
|
|
proto_register_field_array(proto_corosync_totemsrp, hf, array_length(hf));
|
|
proto_register_subtree_array(ett, array_length(ett));
|
|
|
|
heur_subdissector_list = register_heur_dissector_list("corosync_totemsrp.mcast");
|
|
|
|
new_register_dissector( "corosync_totemsrp", dissect_corosync_totemsrp, proto_corosync_totemsrp);
|
|
}
|
|
|
|
void
|
|
proto_reg_handoff_corosync_totemsrp(void)
|
|
{
|
|
/* Nothing to be done.
|
|
dissect_corosync_totemsrp is directly called from corosync_totemnet dissector. */
|
|
}
|
|
|
|
|
|
/*
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
*
|
|
* Local variables:
|
|
* c-basic-offset: 2
|
|
* tab-width: 8
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*
|
|
* vi: set shiftwidth=2 tabstop=8 expandtab:
|
|
* :indentSize=2:tabSize=8:noTabs=true:
|
|
*/
|