wireshark/wireshark-corosync-packet-dissector.patch

2787 lines
112 KiB
Diff
Raw Normal View History

Index: wireshark-1.6.5/epan/dissectors/Makefile.common
===================================================================
--- wireshark-1.6.5.orig/epan/dissectors/Makefile.common 2012-01-10 20:08:58.000000000 +0100
+++ wireshark-1.6.5/epan/dissectors/Makefile.common 2012-03-02 14:27:44.059540118 +0100
@@ -320,6 +320,8 @@ DISSECTOR_SRC = \
packet-collectd.c \
packet-componentstatus.c \
packet-cops.c \
+ packet-corosync-totemnet.c \
+ packet-corosync-totemsrp.c \
packet-cosine.c \
packet-cpfi.c \
packet-cpha.c \
Index: wireshark-1.6.5/epan/dissectors/packet-corosync-totemnet.c
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ wireshark-1.6.5/epan/dissectors/packet-corosync-totemnet.c 2012-03-02 14:27:44.060540120 +0100
@@ -0,0 +1,1274 @@
+/* packet-corosync-totemnet.c
+ * Routines for the lowest level(encryption/decryption) protocol used in Corosync cluster engine
+ * Copyright 2009 2010 Masatake YAMATO <yamato@redhat.com>
+ * Copyright (c) 2010 Red Hat, Inc.
+ *
+ * $Id:$
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include <epan/packet.h>
+#include <epan/prefs.h>
+#include <epan/crypt/crypt-sha1.h>
+
+#include "packet-corosync-totemsrp.h"
+
+/* This dissector deals packets defined in totemnet.c of corosync
+ cluster engine. In the totemnet.c the packet is encrypted and decrypted
+ with LibTomCrypt. This dissector tries decrypting the packet with
+ the library and sha1 functions in wireshark. */
+
+
+/* crypto.h */
+
+/* About LibTomCrypt:
+ * ---------------------------------------------------------------------
+ * LibTomCrypt, modular cryptographic library -- Tom St Denis
+ *
+ * LibTomCrypt is a library that provides various cryptographic
+ * algorithms in a highly modular and flexible manner.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://libtomcrypt.com
+ */
+
+/*
+ * Modifications in packet-corosync-totemnet.c done by Masatake YAMATO
+ * ---------------------------------------------------------------------
+ *
+ * - added `corocrypto' as symbol prefix to some symbols, and
+ * - added `static' modifier to functions and symbols to narrow the scope.
+ *
+ */
+struct sober128_prng {
+ unsigned long R[17], /* Working storage for the shift register */
+ initR[17], /* saved register contents */
+ konst, /* key dependent constant */
+ sbuf; /* partial word encryption buffer */
+
+ int nbuf, /* number of part-word stream bits buffered */
+ flag, /* first add_entropy call or not? */
+ set; /* did we call add_entropy to set key? */
+
+};
+
+static int corocrypto_sober128_start(struct sober128_prng *prng);
+static int corocrypto_sober128_add_entropy(const unsigned char *buf, unsigned long len, struct sober128_prng *prng);
+static unsigned long corocrypto_sober128_read(unsigned char *buf, unsigned long len, struct sober128_prng *prng);
+
+
+/*
+ * Dissector body
+ */
+
+#define PORT_COROSYNC_TOTEMNET 5405
+
+/* Forward declaration we need below */
+void proto_reg_handoff_corosync_totemnet(void);
+
+/* Initialize the protocol and registered fields */
+static int proto_corosync_totemnet = -1;
+
+/* field of struct security_header */
+static int hf_corosync_totemnet_security_header_hash_digest = -1;
+static int hf_corosync_totemnet_security_header_salt = -1;
+
+/* configurable parameters */
+static guint corosync_totemnet_port = PORT_COROSYNC_TOTEMNET;
+static gchar* corosync_totemnet_private_key = NULL;
+
+/* Initialize the subtree pointers */
+static gint ett_corosync_totemnet_security_header = -1;
+
+
+#define HMAC_HASH_SIZE 20
+#define SALT_SIZE 16
+
+
+
+static int
+dissect_corosync_totemnet_security_header(tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *parent_tree)
+{
+ proto_item *item;
+ proto_tree *tree;
+
+
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "COROSYNC/TOTEMNET");
+
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_clear(pinfo->cinfo, COL_INFO);
+
+ if (parent_tree)
+ {
+ item = proto_tree_add_item(parent_tree, proto_corosync_totemnet, tvb, 0,
+ -1, FALSE);
+ tree = proto_item_add_subtree(item, ett_corosync_totemnet_security_header);
+
+ proto_tree_add_item(tree,
+ hf_corosync_totemnet_security_header_hash_digest,
+ tvb, 0, HMAC_HASH_SIZE, FALSE);
+ proto_tree_add_item(tree,
+ hf_corosync_totemnet_security_header_salt,
+ tvb, HMAC_HASH_SIZE, SALT_SIZE, FALSE);
+
+ }
+ return HMAC_HASH_SIZE + SALT_SIZE;
+}
+
+/* About totemnet.c of corosync cluster engine:
+ *
+ * dissect_corosynec_totemnet_with_decryption() is derived from
+ * totemnet.c in corosync.
+ *
+ * ---------------------------------------------------------------------
+ * Copyright (c) 2005 MontaVista Software, Inc.
+ * Copyright (c) 2006-2007 Red Hat, Inc.
+ * Copyright (c) 2006 Sun Microsystems, Inc.
+ *
+ * All rights reserved.
+ *
+ * Author: Steven Dake (sdake@redhat.com)
+
+ * This software licensed under BSD license, the text of which follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * - Neither the name of the MontaVista Software, Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+static int
+dissect_corosynec_totemnet_with_decryption(tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *parent_tree)
+{
+ unsigned char keys[48];
+ struct sober128_prng keygen_prng_state;
+ struct sober128_prng stream_prng_state;
+ unsigned char *hmac_key = &keys[32];
+ unsigned char *cipher_key = &keys[16];
+ unsigned char *initial_vector = &keys[0];
+ unsigned char digest_comparison[HMAC_HASH_SIZE];
+
+
+ guint8 *io_base;
+ guint io_len;
+
+#define PRIVATE_KEY_LEN_MAX 256
+ gchar private_key[PRIVATE_KEY_LEN_MAX];
+ unsigned int private_key_len;
+ unsigned char* hash_digest;
+ unsigned char* salt;
+
+
+ io_len = tvb_length(tvb);
+ if (io_len < HMAC_HASH_SIZE + SALT_SIZE)
+ return 0;
+
+ io_base = tvb_memdup(tvb, 0, io_len);
+ hash_digest = io_base;
+ salt = io_base + HMAC_HASH_SIZE;
+
+
+ memset(private_key, 0, sizeof(private_key));
+
+ private_key_len = (strlen(corosync_totemnet_private_key)+4) & 0xFC;
+ if (private_key_len > PRIVATE_KEY_LEN_MAX)
+ private_key_len = PRIVATE_KEY_LEN_MAX;
+ g_strlcpy(private_key, corosync_totemnet_private_key, private_key_len);
+
+
+ /*
+ * Generate MAC, CIPHER, IV keys from private key
+ */
+ memset (keys, 0, sizeof(keys));
+ corocrypto_sober128_start (&keygen_prng_state);
+ corocrypto_sober128_add_entropy(private_key,
+ private_key_len, &keygen_prng_state);
+ corocrypto_sober128_add_entropy (salt, SALT_SIZE, &keygen_prng_state);
+ corocrypto_sober128_read (keys, sizeof (keys), &keygen_prng_state);
+
+ /*
+ * Setup stream cipher
+ */
+ corocrypto_sober128_start (&stream_prng_state);
+ corocrypto_sober128_add_entropy (cipher_key, 16, &stream_prng_state);
+ corocrypto_sober128_add_entropy (initial_vector, 16, &stream_prng_state);
+
+ /*
+ * Authenticate contents of message
+ */
+ sha1_hmac(hmac_key, 16,
+ io_base + HMAC_HASH_SIZE, io_len - HMAC_HASH_SIZE,
+ digest_comparison);
+
+ if (memcmp (digest_comparison, hash_digest, HMAC_HASH_SIZE) != 0)
+ {
+ g_free(io_base);
+ return 0;
+ }
+
+
+ /*
+ * Decrypt the contents of the message with the cipher key
+ */
+
+ corocrypto_sober128_read (io_base + HMAC_HASH_SIZE + SALT_SIZE,
+ io_len - (HMAC_HASH_SIZE + SALT_SIZE),
+ &stream_prng_state);
+
+
+ /*
+ * Dissect the decrypted data
+ */
+ {
+ tvbuff_t *decrypted_tvb;
+ tvbuff_t *next_tvb;
+
+
+ decrypted_tvb = tvb_new_real_data(io_base, io_len, io_len);
+ tvb_set_free_cb(decrypted_tvb, g_free);
+
+ tvb_set_child_real_data_tvbuff(tvb, decrypted_tvb);
+ add_new_data_source(pinfo, decrypted_tvb, "Decrypted Data");
+
+
+ dissect_corosync_totemnet_security_header(decrypted_tvb, pinfo, parent_tree);
+
+ next_tvb = tvb_new_subset(decrypted_tvb,
+ HMAC_HASH_SIZE + SALT_SIZE,
+ io_len - (HMAC_HASH_SIZE + SALT_SIZE),
+ io_len - (HMAC_HASH_SIZE + SALT_SIZE));
+
+
+ return dissect_corosync_totemsrp(next_tvb, pinfo, parent_tree) + HMAC_HASH_SIZE + SALT_SIZE;
+ }
+}
+
+static int
+dissect_corosynec_totemnet(tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *parent_tree)
+{
+ if (corosync_totemnet_private_key)
+ {
+ int r;
+
+ r = dissect_corosynec_totemnet_with_decryption(tvb, pinfo, parent_tree);
+
+ if (r > 0)
+ return r;
+ }
+ return dissect_corosync_totemsrp(tvb, pinfo, parent_tree);
+}
+
+
+void
+proto_register_corosync_totemnet(void)
+{
+ module_t *corosync_totemnet_module;
+
+ static hf_register_info hf[] = {
+ { &hf_corosync_totemnet_security_header_hash_digest,
+ { "Hash digest", "corosync_totemnet.security_header_hash_digest",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+ { &hf_corosync_totemnet_security_header_salt,
+ { "Salt", "corosync_totemnet.security_header_salt",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+ };
+
+ static gint *ett_corosync_totemnet[] = {
+ &ett_corosync_totemnet_security_header,
+ };
+
+ proto_corosync_totemnet = proto_register_protocol("Totemnet Layer of Corosync Cluster Engine",
+ "COROSYNC/TOTEMNET", "corosync_totemnet");
+ proto_register_field_array(proto_corosync_totemnet, hf, array_length(hf));
+ proto_register_subtree_array(ett_corosync_totemnet, array_length(ett_corosync_totemnet));
+
+ corosync_totemnet_module = prefs_register_protocol(proto_corosync_totemnet,
+ proto_reg_handoff_corosync_totemnet);
+
+ prefs_register_uint_preference(corosync_totemnet_module, "udp.port",
+ "UDP Port",
+ "Set the UDP port for totem ring protocol implemented in corosync cluster engine",
+ 10,
+ &corosync_totemnet_port);
+ /* tserong@novell.com: private key as a string doesn't work for
+ * secauth with /etc/corosync/authkey, so leaving this out until
+ * we come up with a better solution
+ prefs_register_string_preference(corosync_totemnet_module, "private_key",
+ "Private key",
+ "Key to decrypt the communications on corosync cluster engine",
+ (const gchar **)&corosync_totemnet_private_key);
+ */
+}
+
+void
+proto_reg_handoff_corosync_totemnet(void)
+{
+ static gboolean register_dissector = FALSE;
+
+ static int port = 0;
+
+ static dissector_handle_t corosync_totemnet_handle;
+
+ if (register_dissector)
+ {
+ dissector_delete("udp.port", port, corosync_totemnet_handle);
+ }
+ else
+ {
+ corosync_totemnet_handle = new_create_dissector_handle(dissect_corosynec_totemnet,
+ proto_corosync_totemnet);
+ register_dissector = TRUE;
+ }
+
+ port = corosync_totemnet_port;
+ dissector_add("udp.port", port, corosync_totemnet_handle);
+}
+
+
+
+/* crypto.c */
+
+/* About LibTomCrypt:
+ * ---------------------------------------------------------------------
+ * LibTomCrypt, modular cryptographic library -- Tom St Denis
+ *
+ * LibTomCrypt is a library that provides various cryptographic
+ * algorithms in a highly modular and flexible manner.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://libtomcrypt.com
+ */
+#define CONST64(n) n ## ULL
+
+typedef unsigned long ulong32;
+typedef unsigned long long ulong64;
+
+#ifdef WORDS_BIGENDIAN
+#define ENDIAN_BIG
+#else
+#define ENDIAN_LITTLE
+#endif
+
+#if defined(__WORDSIZE)
+#if __WORDSIZE == 64
+#define ENDIAN_64BITWORD
+#endif
+#if __WORDSIZE == 32
+#define ENDIAN_32BITWORD
+#endif
+#else
+/* XXX need to find a better default
+ */
+#define ENDIAN_32BITWORD
+#endif
+
+/* ---- HELPER MACROS ---- */
+#ifdef ENDIAN_NEUTRAL
+
+#define STORE32L(x, y) \
+ { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD32L(x, y) \
+ { x = ((unsigned long)((y)[3] & 255)<<24) | \
+ ((unsigned long)((y)[2] & 255)<<16) | \
+ ((unsigned long)((y)[1] & 255)<<8) | \
+ ((unsigned long)((y)[0] & 255)); }
+
+#define STORE64L(x, y) \
+ { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
+ (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
+ (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD64L(x, y) \
+ { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
+ (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
+ (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
+ (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
+
+#define STORE32H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \
+ (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); }
+
+#define LOAD32H(x, y) \
+ { x = ((unsigned long)((y)[0] & 255)<<24) | \
+ ((unsigned long)((y)[1] & 255)<<16) | \
+ ((unsigned long)((y)[2] & 255)<<8) | \
+ ((unsigned long)((y)[3] & 255)); }
+
+#define STORE64H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
+ (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
+ (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
+ (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); }
+
+#define LOAD64H(x, y) \
+ { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
+ (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
+ (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
+ (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); }
+
+#endif /* ENDIAN_NEUTRAL */
+
+#ifdef ENDIAN_LITTLE
+
+#define STORE32H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \
+ (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); }
+
+#define LOAD32H(x, y) \
+ { x = ((unsigned long)((y)[0] & 255)<<24) | \
+ ((unsigned long)((y)[1] & 255)<<16) | \
+ ((unsigned long)((y)[2] & 255)<<8) | \
+ ((unsigned long)((y)[3] & 255)); }
+
+#define STORE64H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
+ (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
+ (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
+ (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); }
+
+#define LOAD64H(x, y) \
+ { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
+ (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
+ (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
+ (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); }
+
+#ifdef ENDIAN_32BITWORD
+
+#define STORE32L(x, y) \
+ { unsigned long __t = (x); memcpy(y, &__t, 4); }
+
+#define LOAD32L(x, y) \
+ memcpy(&(x), y, 4);
+
+#define STORE64L(x, y) \
+ { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
+ (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
+ (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD64L(x, y) \
+ { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
+ (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
+ (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
+ (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
+
+#else /* 64-bit words then */
+
+#define STORE32L(x, y) \
+ { unsigned long __t = (x); memcpy(y, &__t, 4); }
+
+#define LOAD32L(x, y) \
+ { memcpy(&(x), y, 4); x &= 0xFFFFFFFF; }
+
+#define STORE64L(x, y) \
+ { ulong64 __t = (x); memcpy(y, &__t, 8); }
+
+#define LOAD64L(x, y) \
+ { memcpy(&(x), y, 8); }
+
+#endif /* ENDIAN_64BITWORD */
+
+#endif /* ENDIAN_LITTLE */
+
+#ifdef ENDIAN_BIG
+#define STORE32L(x, y) \
+ { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD32L(x, y) \
+ { x = ((unsigned long)((y)[3] & 255)<<24) | \
+ ((unsigned long)((y)[2] & 255)<<16) | \
+ ((unsigned long)((y)[1] & 255)<<8) | \
+ ((unsigned long)((y)[0] & 255)); }
+
+#define STORE64L(x, y) \
+ { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
+ (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
+ (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD64L(x, y) \
+ { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48) | \
+ (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32) | \
+ (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16) | \
+ (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
+
+#ifdef ENDIAN_32BITWORD
+
+#define STORE32H(x, y) \
+ { unsigned long __t = (x); memcpy(y, &__t, 4); }
+
+#define LOAD32H(x, y) \
+ memcpy(&(x), y, 4);
+
+#define STORE64H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
+ (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
+ (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
+ (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); }
+
+#define LOAD64H(x, y) \
+ { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48)| \
+ (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32)| \
+ (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16)| \
+ (((ulong64)((y)[6] & 255))<<8)| (((ulong64)((y)[7] & 255))); }
+
+#else /* 64-bit words then */
+
+#define STORE32H(x, y) \
+ { unsigned long __t = (x); memcpy(y, &__t, 4); }
+
+#define LOAD32H(x, y) \
+ { memcpy(&(x), y, 4); x &= 0xFFFFFFFF; }
+
+#define STORE64H(x, y) \
+ { ulong64 __t = (x); memcpy(y, &__t, 8); }
+
+#define LOAD64H(x, y) \
+ { memcpy(&(x), y, 8); }
+
+#endif /* ENDIAN_64BITWORD */
+#endif /* ENDIAN_BIG */
+
+#define BSWAP(x) ( ((x>>24)&0x000000FFUL) | ((x<<24)&0xFF000000UL) | \
+ ((x>>8)&0x0000FF00UL) | ((x<<8)&0x00FF0000UL) )
+
+#if defined(__GNUC__) && defined(__i386__) && !defined(INTEL_CC)
+
+static inline unsigned long ROL(unsigned long word, int i)
+{
+ __asm__("roll %%cl,%0"
+ :"=r" (word)
+ :"0" (word),"c" (i));
+ return word;
+}
+
+static inline unsigned long ROR(unsigned long word, int i)
+{
+ __asm__("rorl %%cl,%0"
+ :"=r" (word)
+ :"0" (word),"c" (i));
+ return word;
+}
+
+#else
+
+/* rotates the hard way */
+#define ROL(x, y) ( (((unsigned long)(x)<<(unsigned long)((y)&31)) | (((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
+#define ROR(x, y) ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
+
+#endif
+
+#define ROL64(x, y) \
+ ( (((x)<<((ulong64)(y)&63)) | \
+ (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)64-((y)&63)))) & CONST64(0xFFFFFFFFFFFFFFFF))
+
+#define ROR64(x, y) \
+ ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \
+ ((x)<<((ulong64)(64-((y)&CONST64(63)))))) & CONST64(0xFFFFFFFFFFFFFFFF))
+
+#undef MAX
+#undef MIN
+#define MAX(x, y) ( ((x)>(y))?(x):(y) )
+#define MIN(x, y) ( ((x)<(y))?(x):(y) )
+
+/* extract a byte portably */
+#define byte(x, n) (((x) >> (8 * (n))) & 255)
+
+#define CONST64(n) n ## ULL
+
+
+/*
+ * The mycrypt_macros.h file
+ */
+
+/* ---- HELPER MACROS ---- */
+#ifdef ENDIAN_NEUTRAL
+
+#define STORE32L(x, y) \
+ { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD32L(x, y) \
+ { x = ((unsigned long)((y)[3] & 255)<<24) | \
+ ((unsigned long)((y)[2] & 255)<<16) | \
+ ((unsigned long)((y)[1] & 255)<<8) | \
+ ((unsigned long)((y)[0] & 255)); }
+
+#define STORE64L(x, y) \
+ { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
+ (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
+ (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD64L(x, y) \
+ { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
+ (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
+ (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
+ (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
+
+#define STORE32H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \
+ (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); }
+
+#define LOAD32H(x, y) \
+ { x = ((unsigned long)((y)[0] & 255)<<24) | \
+ ((unsigned long)((y)[1] & 255)<<16) | \
+ ((unsigned long)((y)[2] & 255)<<8) | \
+ ((unsigned long)((y)[3] & 255)); }
+
+#define STORE64H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
+ (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
+ (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
+ (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); }
+
+#define LOAD64H(x, y) \
+ { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
+ (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
+ (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
+ (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); }
+
+#endif /* ENDIAN_NEUTRAL */
+
+#ifdef ENDIAN_LITTLE
+
+#define STORE32H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \
+ (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); }
+
+#define LOAD32H(x, y) \
+ { x = ((unsigned long)((y)[0] & 255)<<24) | \
+ ((unsigned long)((y)[1] & 255)<<16) | \
+ ((unsigned long)((y)[2] & 255)<<8) | \
+ ((unsigned long)((y)[3] & 255)); }
+
+#define STORE64H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
+ (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
+ (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
+ (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); }
+
+#define LOAD64H(x, y) \
+ { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
+ (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
+ (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
+ (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); }
+
+#ifdef ENDIAN_32BITWORD
+
+#define STORE32L(x, y) \
+ { unsigned long __t = (x); memcpy(y, &__t, 4); }
+
+#define LOAD32L(x, y) \
+ memcpy(&(x), y, 4);
+
+#define STORE64L(x, y) \
+ { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
+ (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
+ (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD64L(x, y) \
+ { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
+ (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
+ (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
+ (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
+
+#else /* 64-bit words then */
+
+#define STORE32L(x, y) \
+ { unsigned long __t = (x); memcpy(y, &__t, 4); }
+
+#define LOAD32L(x, y) \
+ { memcpy(&(x), y, 4); x &= 0xFFFFFFFF; }
+
+#define STORE64L(x, y) \
+ { ulong64 __t = (x); memcpy(y, &__t, 8); }
+
+#define LOAD64L(x, y) \
+ { memcpy(&(x), y, 8); }
+
+#endif /* ENDIAN_64BITWORD */
+
+#endif /* ENDIAN_LITTLE */
+
+#ifdef ENDIAN_BIG
+#define STORE32L(x, y) \
+ { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD32L(x, y) \
+ { x = ((unsigned long)((y)[3] & 255)<<24) | \
+ ((unsigned long)((y)[2] & 255)<<16) | \
+ ((unsigned long)((y)[1] & 255)<<8) | \
+ ((unsigned long)((y)[0] & 255)); }
+
+#define STORE64L(x, y) \
+ { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
+ (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
+ (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
+ (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
+
+#define LOAD64L(x, y) \
+ { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48) | \
+ (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32) | \
+ (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16) | \
+ (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
+
+#ifdef ENDIAN_32BITWORD
+
+#define STORE32H(x, y) \
+ { unsigned long __t = (x); memcpy(y, &__t, 4); }
+
+#define LOAD32H(x, y) \
+ memcpy(&(x), y, 4);
+
+#define STORE64H(x, y) \
+ { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
+ (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
+ (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
+ (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); }
+
+#define LOAD64H(x, y) \
+ { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48)| \
+ (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32)| \
+ (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16)| \
+ (((ulong64)((y)[6] & 255))<<8)| (((ulong64)((y)[7] & 255))); }
+
+#else /* 64-bit words then */
+
+#define STORE32H(x, y) \
+ { unsigned long __t = (x); memcpy(y, &__t, 4); }
+
+#define LOAD32H(x, y) \
+ { memcpy(&(x), y, 4); x &= 0xFFFFFFFF; }
+
+#define STORE64H(x, y) \
+ { ulong64 __t = (x); memcpy(y, &__t, 8); }
+
+#define LOAD64H(x, y) \
+ { memcpy(&(x), y, 8); }
+
+#endif /* ENDIAN_64BITWORD */
+#endif /* ENDIAN_BIG */
+
+#define BSWAP(x) ( ((x>>24)&0x000000FFUL) | ((x<<24)&0xFF000000UL) | \
+ ((x>>8)&0x0000FF00UL) | ((x<<8)&0x00FF0000UL) )
+
+
+#define ROL64(x, y) \
+ ( (((x)<<((ulong64)(y)&63)) | \
+ (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)64-((y)&63)))) & CONST64(0xFFFFFFFFFFFFFFFF))
+
+#define ROR64(x, y) \
+ ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \
+ ((x)<<((ulong64)(64-((y)&CONST64(63)))))) & CONST64(0xFFFFFFFFFFFFFFFF))
+
+#undef MAX
+#undef MIN
+#define MAX(x, y) ( ((x)>(y))?(x):(y) )
+#define MIN(x, y) ( ((x)<(y))?(x):(y) )
+
+/* extract a byte portably */
+#define byte(x, n) (((x) >> (8 * (n))) & 255)
+
+/* $Id: s128multab.h 213 2003-12-16 04:27:12Z ggr $ */
+/* @(#)TuringMultab.h 1.3 (QUALCOMM) 02/09/03 */
+/* Multiplication table for Turing using 0xD02B4367 */
+
+static const ulong32 Multab[256] = {
+ 0x00000000, 0xD02B4367, 0xED5686CE, 0x3D7DC5A9,
+ 0x97AC41D1, 0x478702B6, 0x7AFAC71F, 0xAAD18478,
+ 0x631582EF, 0xB33EC188, 0x8E430421, 0x5E684746,
+ 0xF4B9C33E, 0x24928059, 0x19EF45F0, 0xC9C40697,
+ 0xC62A4993, 0x16010AF4, 0x2B7CCF5D, 0xFB578C3A,
+ 0x51860842, 0x81AD4B25, 0xBCD08E8C, 0x6CFBCDEB,
+ 0xA53FCB7C, 0x7514881B, 0x48694DB2, 0x98420ED5,
+ 0x32938AAD, 0xE2B8C9CA, 0xDFC50C63, 0x0FEE4F04,
+ 0xC154926B, 0x117FD10C, 0x2C0214A5, 0xFC2957C2,
+ 0x56F8D3BA, 0x86D390DD, 0xBBAE5574, 0x6B851613,
+ 0xA2411084, 0x726A53E3, 0x4F17964A, 0x9F3CD52D,
+ 0x35ED5155, 0xE5C61232, 0xD8BBD79B, 0x089094FC,
+ 0x077EDBF8, 0xD755989F, 0xEA285D36, 0x3A031E51,
+ 0x90D29A29, 0x40F9D94E, 0x7D841CE7, 0xADAF5F80,
+ 0x646B5917, 0xB4401A70, 0x893DDFD9, 0x59169CBE,
+ 0xF3C718C6, 0x23EC5BA1, 0x1E919E08, 0xCEBADD6F,
+ 0xCFA869D6, 0x1F832AB1, 0x22FEEF18, 0xF2D5AC7F,
+ 0x58042807, 0x882F6B60, 0xB552AEC9, 0x6579EDAE,
+ 0xACBDEB39, 0x7C96A85E, 0x41EB6DF7, 0x91C02E90,
+ 0x3B11AAE8, 0xEB3AE98F, 0xD6472C26, 0x066C6F41,
+ 0x09822045, 0xD9A96322, 0xE4D4A68B, 0x34FFE5EC,
+ 0x9E2E6194, 0x4E0522F3, 0x7378E75A, 0xA353A43D,
+ 0x6A97A2AA, 0xBABCE1CD, 0x87C12464, 0x57EA6703,
+ 0xFD3BE37B, 0x2D10A01C, 0x106D65B5, 0xC04626D2,
+ 0x0EFCFBBD, 0xDED7B8DA, 0xE3AA7D73, 0x33813E14,
+ 0x9950BA6C, 0x497BF90B, 0x74063CA2, 0xA42D7FC5,
+ 0x6DE97952, 0xBDC23A35, 0x80BFFF9C, 0x5094BCFB,
+ 0xFA453883, 0x2A6E7BE4, 0x1713BE4D, 0xC738FD2A,
+ 0xC8D6B22E, 0x18FDF149, 0x258034E0, 0xF5AB7787,
+ 0x5F7AF3FF, 0x8F51B098, 0xB22C7531, 0x62073656,
+ 0xABC330C1, 0x7BE873A6, 0x4695B60F, 0x96BEF568,
+ 0x3C6F7110, 0xEC443277, 0xD139F7DE, 0x0112B4B9,
+ 0xD31DD2E1, 0x03369186, 0x3E4B542F, 0xEE601748,
+ 0x44B19330, 0x949AD057, 0xA9E715FE, 0x79CC5699,
+ 0xB008500E, 0x60231369, 0x5D5ED6C0, 0x8D7595A7,
+ 0x27A411DF, 0xF78F52B8, 0xCAF29711, 0x1AD9D476,
+ 0x15379B72, 0xC51CD815, 0xF8611DBC, 0x284A5EDB,
+ 0x829BDAA3, 0x52B099C4, 0x6FCD5C6D, 0xBFE61F0A,
+ 0x7622199D, 0xA6095AFA, 0x9B749F53, 0x4B5FDC34,
+ 0xE18E584C, 0x31A51B2B, 0x0CD8DE82, 0xDCF39DE5,
+ 0x1249408A, 0xC26203ED, 0xFF1FC644, 0x2F348523,
+ 0x85E5015B, 0x55CE423C, 0x68B38795, 0xB898C4F2,
+ 0x715CC265, 0xA1778102, 0x9C0A44AB, 0x4C2107CC,
+ 0xE6F083B4, 0x36DBC0D3, 0x0BA6057A, 0xDB8D461D,
+ 0xD4630919, 0x04484A7E, 0x39358FD7, 0xE91ECCB0,
+ 0x43CF48C8, 0x93E40BAF, 0xAE99CE06, 0x7EB28D61,
+ 0xB7768BF6, 0x675DC891, 0x5A200D38, 0x8A0B4E5F,
+ 0x20DACA27, 0xF0F18940, 0xCD8C4CE9, 0x1DA70F8E,
+ 0x1CB5BB37, 0xCC9EF850, 0xF1E33DF9, 0x21C87E9E,
+ 0x8B19FAE6, 0x5B32B981, 0x664F7C28, 0xB6643F4F,
+ 0x7FA039D8, 0xAF8B7ABF, 0x92F6BF16, 0x42DDFC71,
+ 0xE80C7809, 0x38273B6E, 0x055AFEC7, 0xD571BDA0,
+ 0xDA9FF2A4, 0x0AB4B1C3, 0x37C9746A, 0xE7E2370D,
+ 0x4D33B375, 0x9D18F012, 0xA06535BB, 0x704E76DC,
+ 0xB98A704B, 0x69A1332C, 0x54DCF685, 0x84F7B5E2,
+ 0x2E26319A, 0xFE0D72FD, 0xC370B754, 0x135BF433,
+ 0xDDE1295C, 0x0DCA6A3B, 0x30B7AF92, 0xE09CECF5,
+ 0x4A4D688D, 0x9A662BEA, 0xA71BEE43, 0x7730AD24,
+ 0xBEF4ABB3, 0x6EDFE8D4, 0x53A22D7D, 0x83896E1A,
+ 0x2958EA62, 0xF973A905, 0xC40E6CAC, 0x14252FCB,
+ 0x1BCB60CF, 0xCBE023A8, 0xF69DE601, 0x26B6A566,
+ 0x8C67211E, 0x5C4C6279, 0x6131A7D0, 0xB11AE4B7,
+ 0x78DEE220, 0xA8F5A147, 0x958864EE, 0x45A32789,
+ 0xEF72A3F1, 0x3F59E096, 0x0224253F, 0xD20F6658,
+};
+
+/* $Id: s128sbox.h 213 2003-12-16 04:27:12Z ggr $ */
+/* Sbox for SOBER-128 */
+/*
+ * This is really the combination of two SBoxes; the least significant
+ * 24 bits comes from:
+ * 8->32 Sbox generated by Millan et. al. at Queensland University of
+ * Technology. See: E. Dawson, W. Millan, L. Burnett, G. Carter,
+ * "On the Design of 8*32 S-boxes". Unpublished report, by the
+ * Information Systems Research Centre,
+ * Queensland University of Technology, 1999.
+ *
+ * The most significant 8 bits are the Skipjack "F table", which can be
+ * found at http://csrc.nist.gov/CryptoToolkit/skipjack/skipjack.pdf .
+ * In this optimised table, though, the intent is to XOR the word from
+ * the table selected by the high byte with the input word. Thus, the
+ * high byte is actually the Skipjack F-table entry XORED with its
+ * table index.
+ */
+static const ulong32 Sbox[256] = {
+ 0xa3aa1887, 0xd65e435c, 0x0b65c042, 0x800e6ef4,
+ 0xfc57ee20, 0x4d84fed3, 0xf066c502, 0xf354e8ae,
+ 0xbb2ee9d9, 0x281f38d4, 0x1f829b5d, 0x735cdf3c,
+ 0x95864249, 0xbc2e3963, 0xa1f4429f, 0xf6432c35,
+ 0xf7f40325, 0x3cc0dd70, 0x5f973ded, 0x9902dc5e,
+ 0xda175b42, 0x590012bf, 0xdc94d78c, 0x39aab26b,
+ 0x4ac11b9a, 0x8c168146, 0xc3ea8ec5, 0x058ac28f,
+ 0x52ed5c0f, 0x25b4101c, 0x5a2db082, 0x370929e1,
+ 0x2a1843de, 0xfe8299fc, 0x202fbc4b, 0x833915dd,
+ 0x33a803fa, 0xd446b2de, 0x46233342, 0x4fcee7c3,
+ 0x3ad607ef, 0x9e97ebab, 0x507f859b, 0xe81f2e2f,
+ 0xc55b71da, 0xd7e2269a, 0x1339c3d1, 0x7ca56b36,
+ 0xa6c9def2, 0xb5c9fc5f, 0x5927b3a3, 0x89a56ddf,
+ 0xc625b510, 0x560f85a7, 0xace82e71, 0x2ecb8816,
+ 0x44951e2a, 0x97f5f6af, 0xdfcbc2b3, 0xce4ff55d,
+ 0xcb6b6214, 0x2b0b83e3, 0x549ea6f5, 0x9de041af,
+ 0x792f1f17, 0xf73b99ee, 0x39a65ec0, 0x4c7016c6,
+ 0x857709a4, 0xd6326e01, 0xc7b280d9, 0x5cfb1418,
+ 0xa6aff227, 0xfd548203, 0x506b9d96, 0xa117a8c0,
+ 0x9cd5bf6e, 0xdcee7888, 0x61fcfe64, 0xf7a193cd,
+ 0x050d0184, 0xe8ae4930, 0x88014f36, 0xd6a87088,
+ 0x6bad6c2a, 0x1422c678, 0xe9204de7, 0xb7c2e759,
+ 0x0200248e, 0x013b446b, 0xda0d9fc2, 0x0414a895,
+ 0x3a6cc3a1, 0x56fef170, 0x86c19155, 0xcf7b8a66,
+ 0x551b5e69, 0xb4a8623e, 0xa2bdfa35, 0xc4f068cc,
+ 0x573a6acd, 0x6355e936, 0x03602db9, 0x0edf13c1,
+ 0x2d0bb16d, 0x6980b83c, 0xfeb23763, 0x3dd8a911,
+ 0x01b6bc13, 0xf55579d7, 0xf55c2fa8, 0x19f4196e,
+ 0xe7db5476, 0x8d64a866, 0xc06e16ad, 0xb17fc515,
+ 0xc46feb3c, 0x8bc8a306, 0xad6799d9, 0x571a9133,
+ 0x992466dd, 0x92eb5dcd, 0xac118f50, 0x9fafb226,
+ 0xa1b9cef3, 0x3ab36189, 0x347a19b1, 0x62c73084,
+ 0xc27ded5c, 0x6c8bc58f, 0x1cdde421, 0xed1e47fb,
+ 0xcdcc715e, 0xb9c0ff99, 0x4b122f0f, 0xc4d25184,
+ 0xaf7a5e6c, 0x5bbf18bc, 0x8dd7c6e0, 0x5fb7e420,
+ 0x521f523f, 0x4ad9b8a2, 0xe9da1a6b, 0x97888c02,
+ 0x19d1e354, 0x5aba7d79, 0xa2cc7753, 0x8c2d9655,
+ 0x19829da1, 0x531590a7, 0x19c1c149, 0x3d537f1c,
+ 0x50779b69, 0xed71f2b7, 0x463c58fa, 0x52dc4418,
+ 0xc18c8c76, 0xc120d9f0, 0xafa80d4d, 0x3b74c473,
+ 0xd09410e9, 0x290e4211, 0xc3c8082b, 0x8f6b334a,
+ 0x3bf68ed2, 0xa843cc1b, 0x8d3c0ff3, 0x20e564a0,
+ 0xf8f55a4f, 0x2b40f8e7, 0xfea7f15f, 0xcf00fe21,
+ 0x8a6d37d6, 0xd0d506f1, 0xade00973, 0xefbbde36,
+ 0x84670fa8, 0xfa31ab9e, 0xaedab618, 0xc01f52f5,
+ 0x6558eb4f, 0x71b9e343, 0x4b8d77dd, 0x8cb93da6,
+ 0x740fd52d, 0x425412f8, 0xc5a63360, 0x10e53ad0,
+ 0x5a700f1c, 0x8324ed0b, 0xe53dc1ec, 0x1a366795,
+ 0x6d549d15, 0xc5ce46d7, 0xe17abe76, 0x5f48e0a0,
+ 0xd0f07c02, 0x941249b7, 0xe49ed6ba, 0x37a47f78,
+ 0xe1cfffbd, 0xb007ca84, 0xbb65f4da, 0xb59f35da,
+ 0x33d2aa44, 0x417452ac, 0xc0d674a7, 0x2d61a46a,
+ 0xdc63152a, 0x3e12b7aa, 0x6e615927, 0xa14fb118,
+ 0xa151758d, 0xba81687b, 0xe152f0b3, 0x764254ed,
+ 0x34c77271, 0x0a31acab, 0x54f94aec, 0xb9e994cd,
+ 0x574d9e81, 0x5b623730, 0xce8a21e8, 0x37917f0b,
+ 0xe8a9b5d6, 0x9697adf8, 0xf3d30431, 0x5dcac921,
+ 0x76b35d46, 0xaa430a36, 0xc2194022, 0x22bca65e,
+ 0xdaec70ba, 0xdfaea8cc, 0x777bae8b, 0x242924d5,
+ 0x1f098a5a, 0x4b396b81, 0x55de2522, 0x435c1cb8,
+ 0xaeb8fe1d, 0x9db3c697, 0x5b164f83, 0xe0c16376,
+ 0xa319224c, 0xd0203b35, 0x433ac0fe, 0x1466a19a,
+ 0x45f0b24f, 0x51fda998, 0xc0d52d71, 0xfa0896a8,
+ 0xf9e6053f, 0xa4b0d300, 0xd499cbcc, 0xb95e3d40,
+};
+
+
+/* Implementation of SOBER-128 by Tom St Denis.
+ * Based on s128fast.c reference code supplied by Greg Rose of QUALCOMM.
+ */
+
+/* don't change these... */
+#define N 17
+#define FOLD N /* how many iterations of folding to do */
+#define INITKONST 0x6996c53a /* value of KONST to use during key loading */
+#define KEYP 15 /* where to insert key words */
+#define FOLDP 4 /* where to insert non-linear feedback */
+
+#define B(x,i) ((unsigned char)(((x) >> (8*i)) & 0xFF))
+
+static ulong32 BYTE2WORD(unsigned char *b)
+{
+ ulong32 t;
+ LOAD32L(t, b);
+ return t;
+}
+
+#define WORD2BYTE(w, b) STORE32L(b, w)
+
+static void XORWORD(ulong32 w, unsigned char *b)
+{
+ ulong32 t;
+ LOAD32L(t, b);
+ t ^= w;
+ STORE32L(t, b);
+}
+
+/* give correct offset for the current position of the register,
+ * where logically R[0] is at position "zero".
+ */
+#define OFF(zero, i) (((zero)+(i)) % N)
+
+/* step the LFSR */
+/* After stepping, "zero" moves right one place */
+#define STEP(R,z) \
+ R[OFF(z,0)] = R[OFF(z,15)] ^ R[OFF(z,4)] ^ (R[OFF(z,0)] << 8) ^ Multab[(R[OFF(z,0)] >> 24) & 0xFF];
+
+static void cycle(ulong32 *R)
+{
+ ulong32 t;
+ int i;
+
+ STEP(R,0);
+ t = R[0];
+ for (i = 1; i < N; ++i) {
+ R[i-1] = R[i];
+ }
+ R[N-1] = t;
+}
+
+/* Return a non-linear function of some parts of the register.
+ */
+#define NLFUNC(c,z) \
+{ \
+ t = c->R[OFF(z,0)] + c->R[OFF(z,16)]; \
+ t ^= Sbox[(t >> 24) & 0xFF]; \
+ t = ROR(t, 8); \
+ t = ((t + c->R[OFF(z,1)]) ^ c->konst) + c->R[OFF(z,6)]; \
+ t ^= Sbox[(t >> 24) & 0xFF]; \
+ t = t + c->R[OFF(z,13)]; \
+}
+
+static ulong32 nltap(struct sober128_prng *c)
+{
+ ulong32 t;
+ NLFUNC(c, 0);
+ return t;
+}
+
+/* initialise to known state
+ */
+int corocrypto_sober128_start(struct sober128_prng *c)
+{
+ int i;
+
+ /* Register initialised to Fibonacci numbers */
+ c->R[0] = 1;
+ c->R[1] = 1;
+ for (i = 2; i < N; ++i) {
+ c->R[i] = c->R[i-1] + c->R[i-2];
+ }
+ c->konst = INITKONST;
+
+ /* next add_entropy will be the key */
+ c->flag = 1;
+ c->set = 0;
+
+ return 0;
+}
+
+/* Save the current register state
+ */
+static void s128_savestate(struct sober128_prng *c)
+{
+ int i;
+ for (i = 0; i < N; ++i) {
+ c->initR[i] = c->R[i];
+ }
+}
+
+/* initialise to previously saved register state
+ */
+static void s128_reloadstate(struct sober128_prng *c)
+{
+ int i;
+
+ for (i = 0; i < N; ++i) {
+ c->R[i] = c->initR[i];
+ }
+}
+
+/* Initialise "konst"
+ */
+static void s128_genkonst(struct sober128_prng *c)
+{
+ ulong32 newkonst;
+
+ do {
+ cycle(c->R);
+ newkonst = nltap(c);
+ } while ((newkonst & 0xFF000000) == 0);
+ c->konst = newkonst;
+}
+
+/* Load key material into the register
+ */
+#define ADDKEY(k) \
+ c->R[KEYP] += (k);
+
+#define XORNL(nl) \
+ c->R[FOLDP] ^= (nl);
+
+/* nonlinear diffusion of register for key */
+#define DROUND(z) STEP(c->R,z); NLFUNC(c,(z+1)); c->R[OFF((z+1),FOLDP)] ^= t;
+static void s128_diffuse(struct sober128_prng *c)
+{
+ ulong32 t;
+ /* relies on FOLD == N == 17! */
+ DROUND(0);
+ DROUND(1);
+ DROUND(2);
+ DROUND(3);
+ DROUND(4);
+ DROUND(5);
+ DROUND(6);
+ DROUND(7);
+ DROUND(8);
+ DROUND(9);
+ DROUND(10);
+ DROUND(11);
+ DROUND(12);
+ DROUND(13);
+ DROUND(14);
+ DROUND(15);
+ DROUND(16);
+}
+
+static int corocrypto_sober128_add_entropy(const unsigned char *buf, unsigned long len, struct sober128_prng *c)
+{
+ ulong32 i, k;
+
+
+ if (c->flag == 1) {
+ /* this is the first call to the add_entropy so this input is the key */
+ /* len must be multiple of 4 bytes */
+ assert ((len & 3) == 0);
+
+ for (i = 0; i < len; i += 4) {
+ k = BYTE2WORD((unsigned char *)&buf[i]);
+ ADDKEY(k);
+ cycle(c->R);
+ XORNL(nltap(c));
+ }
+
+ /* also fold in the length of the key */
+ ADDKEY(len);
+
+ /* now diffuse */
+ s128_diffuse(c);
+
+ s128_genkonst(c);
+ s128_savestate(c);
+ c->nbuf = 0;
+ c->flag = 0;
+ c->set = 1;
+ } else {
+ /* ok we are adding an IV then... */
+ s128_reloadstate(c);
+
+ /* len must be multiple of 4 bytes */
+ assert ((len & 3) == 0);
+
+ for (i = 0; i < len; i += 4) {
+ k = BYTE2WORD((unsigned char *)&buf[i]);
+ ADDKEY(k);
+ cycle(c->R);
+ XORNL(nltap(c));
+ }
+
+ /* also fold in the length of the key */
+ ADDKEY(len);
+
+ /* now diffuse */
+ s128_diffuse(c);
+ c->nbuf = 0;
+ }
+
+ return 0;
+}
+
+/* XOR pseudo-random bytes into buffer
+ */
+#define SROUND(z) STEP(c->R,z); NLFUNC(c,(z+1)); XORWORD(t, buf+(z*4));
+
+static unsigned long corocrypto_sober128_read(unsigned char *buf, unsigned long nbytes, struct sober128_prng *c)
+{
+ ulong32 t, tlen;
+
+ t = 0;
+ tlen = nbytes;
+
+ /* handle any previously buffered bytes */
+ while (c->nbuf != 0 && nbytes != 0) {
+ *buf++ ^= c->sbuf & 0xFF;
+ c->sbuf >>= 8;
+ c->nbuf -= 8;
+ --nbytes;
+ }
+
+#ifndef SMALL_CODE
+ /* do lots at a time, if there's enough to do */
+ while (nbytes >= N*4) {
+ SROUND(0);
+ SROUND(1);
+ SROUND(2);
+ SROUND(3);
+ SROUND(4);
+ SROUND(5);
+ SROUND(6);
+ SROUND(7);
+ SROUND(8);
+ SROUND(9);
+ SROUND(10);
+ SROUND(11);
+ SROUND(12);
+ SROUND(13);
+ SROUND(14);
+ SROUND(15);
+ SROUND(16);
+ buf += 4*N;
+ nbytes -= 4*N;
+ }
+#endif
+
+ /* do small or odd size buffers the slow way */
+ while (4 <= nbytes) {
+ cycle(c->R);
+ t = nltap(c);
+ XORWORD(t, buf);
+ buf += 4;
+ nbytes -= 4;
+ }
+
+ /* handle any trailing bytes */
+ if (nbytes != 0) {
+ cycle(c->R);
+ c->sbuf = nltap(c);
+ c->nbuf = 32;
+ while (c->nbuf != 0 && nbytes != 0) {
+ *buf++ ^= c->sbuf & 0xFF;
+ c->sbuf >>= 8;
+ c->nbuf -= 8;
+ --nbytes;
+ }
+ }
+
+ return tlen;
+}
+
+/* packet-corosync-totemnet.c ends here */
Index: wireshark-1.6.5/epan/dissectors/packet-corosync-totemsrp.c
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ wireshark-1.6.5/epan/dissectors/packet-corosync-totemsrp.c 2012-03-02 14:27:44.061540123 +0100
@@ -0,0 +1,1379 @@
+/* packet-corosync-totemsrp.c
+ * Dissectors for totem single ring protocol implementated in corosync cluster engine
+ * Copyright 2007 2009 2010 Masatake YAMATO <yamato@redhat.com>
+ * Copyright (c) 2010 Red Hat, Inc.
+ *
+ * $Id$
+ *
+ * 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
+
+ 1. "The Totem Single-Ring Ordering and Membership Protocol"
+ Y.AMIR, L.E.MOSER, P.M.MELLIAR-SMITH, D.A.AGARWAL, P.CIARFELLA */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include <epan/packet.h>
+
+#include "packet-corosync-totemsrp.h"
+
+
+/* Forward declaration we need below */
+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, "multicast message" },
+ { 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[] = {
+ { AF_INET, "AF_INET" },
+ { AF_INET6, "AF_INET6" },
+ { 0, NULL }
+};
+
+static guint16 corosync_totemsrp_get_guint16(tvbuff_t* tvb, gint offset, gboolean little_endian);
+
+static guint32 corosync_totemsrp_get_guint32(tvbuff_t* tvb, gint offset, gboolean little_endian);
+static gint32 corosync_totemsrp_get_gint32 (tvbuff_t* tvb, gint offset, gboolean little_endian);
+
+
+#define COROSYNC_TOTEMSRP_ENDIAN_LOCAL {0xff, 0x22}
+
+
+#define COROSYNC_TOTEMSRP_SRP_ADDR_INTERFACE_MAX 2
+
+struct corosync_totemsrp_info {
+ void* original_private_data;
+ gboolean little_endian;
+ proto_tree* master_tree;
+};
+
+static int
+dissect_corosync_totemsrp_ip_address(tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *parent_tree,
+ guint length, int offset,
+ gboolean little_endian,
+ gboolean print_interface,
+ guint interface,
+ guint *nodeid)
+{
+ int original_offset;
+ proto_tree *tree;
+ proto_item *item;
+
+ guint16 family;
+ gint hf;
+ gint len;
+
+ if ((length - offset) < corosync_totemsrp_ip_address_length)
+ return 0;
+ original_offset = offset;
+
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_ip_address, tvb, offset,
+ corosync_totemsrp_ip_address_length, little_endian);
+ 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);
+
+
+ offset += 0;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_ip_address_nodeid,
+ tvb, offset, 4, little_endian);
+ {
+ guint nid;
+
+ nid = corosync_totemsrp_get_guint32(tvb, offset, little_endian);
+ proto_item_append_text(item, "node: %u", nid);
+ if (nodeid)
+ *nodeid = nid;
+ }
+ proto_item_append_text(item, ")");
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_ip_address_family,
+ tvb, offset, 2, little_endian);
+ family = corosync_totemsrp_get_guint16(tvb, offset, little_endian);
+
+ offset += 2;
+ switch (family)
+ {
+ case AF_INET:
+ hf = hf_corosync_totemsrp_ip_address_addr4;
+ len = 4;
+ break;
+ case AF_INET6:
+ hf = hf_corosync_totemsrp_ip_address_addr6;
+ len = COROSYNC_TOTEMSRP_IP_ADDRLEN;
+ break;
+ default:
+ hf = hf_corosync_totemsrp_ip_address_addr;
+ len = COROSYNC_TOTEMSRP_IP_ADDRLEN;
+ break;
+ }
+ proto_tree_add_item(tree,
+ hf,
+ tvb, offset, len, FALSE);
+ offset += len;
+
+ if (len != COROSYNC_TOTEMSRP_IP_ADDRLEN) {
+ gint padding_len;
+
+ padding_len = (COROSYNC_TOTEMSRP_IP_ADDRLEN - len);
+ proto_tree_add_item (tree,
+ hf_corosync_totemsrp_ip_address_addr4_padding,
+ tvb, offset, padding_len, FALSE);
+ offset += padding_len;
+ }
+
+
+ return offset - original_offset;
+
+ pinfo = pinfo;
+}
+
+static int
+dissect_corosync_totemsrp_memb_ring_id(tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *parent_tree,
+ guint length, int offset,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+ guint nodeid;
+
+ if ((length - offset) < corosync_totemsrp_memb_ring_id_length) {
+ fprintf(stderr, "We have: %d, expected: %lu\n",
+ (length - offset),
+ corosync_totemsrp_memb_ring_id_length);
+ return 0;
+ }
+ original_offset = offset;
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_ring_id, tvb, offset,
+ corosync_totemsrp_memb_ring_id_length, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_ring_id);
+
+ offset += 0;
+ sub_length = dissect_corosync_totemsrp_ip_address(tvb, pinfo, tree,
+ length, offset,
+ little_endian,
+ FALSE, -1,
+ &nodeid);
+
+ if (sub_length == 0)
+ goto out;
+ proto_item_append_text(item, " (node: %u)", nodeid);
+
+
+ offset += sub_length;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_ring_id_seq,
+ tvb, offset, 8, little_endian);
+
+ offset += 8;
+out:
+ 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,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+#define corosync_totemsrp_rtr_list_length (corosync_totemsrp_memb_ring_id_length + 4)
+ if ((length - offset) < corosync_totemsrp_rtr_list_length)
+ return 0;
+ original_offset = offset;
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_rtr_item, tvb, offset,
+ corosync_totemsrp_rtr_list_length, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_rtr_item);
+
+ offset += 0;
+ sub_length = dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_rtr_item_seq,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+out:
+ 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,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+ gint32 rtr_list_entries;
+ gint32 i;
+
+#define corosync_totemsrp_orf_token_length ( 4 \
+ + 4 \
+ + 4 \
+ + 4 \
+ + corosync_totemsrp_memb_ring_id_length \
+ + 4 \
+ + 4 \
+ + 4 \
+ + 4)
+ if ((length - offset) < corosync_totemsrp_orf_token_length)
+ return 0;
+ original_offset = offset;
+
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_orf_token, tvb, offset,
+ -1, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_orf_token);
+
+ offset += 0;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_orf_token_seq,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_orf_token_token_seq,
+ tvb, offset, 4, little_endian);
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_orf_token_aru,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_orf_token_aru_addr,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ sub_length = dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_orf_token_backlog,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_orf_token_fcc,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_orf_token_retrnas_flg,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_orf_token_rtr_list_entries,
+ tvb, offset, 4, little_endian);
+
+
+
+ rtr_list_entries = corosync_totemsrp_get_gint32(tvb, offset, little_endian);
+ if ((length - offset) < (rtr_list_entries * corosync_totemsrp_rtr_list_length) )
+ goto out;
+
+ offset += 4;
+ for (i = 0; i < rtr_list_entries; i++) {
+ sub_length = dissect_corosync_totemsrp_rtr_list(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+ offset += sub_length;
+ }
+out:
+ return offset - original_offset;
+
+ pinfo = pinfo;
+}
+
+static int
+dissect_corosync_totemsrp_srp_addr(tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *parent_tree,
+ guint length, int offset,
+ int hf,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+#define corosync_totemsrp_srp_addr_length (corosync_totemsrp_ip_address_length * COROSYNC_TOTEMSRP_SRP_ADDR_INTERFACE_MAX)
+ if ((length - offset) < corosync_totemsrp_srp_addr_length)
+ return 0;
+ original_offset = offset;
+
+ item = proto_tree_add_item(parent_tree, hf? hf: hf_corosync_totemsrp_srp_addr, tvb, offset,
+ corosync_totemsrp_srp_addr_length, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_srp_addr);
+
+ offset += 0;
+ sub_length = dissect_corosync_totemsrp_ip_address(tvb, pinfo, tree,
+ length, offset,
+ little_endian,
+ TRUE, 0,
+ NULL);
+ if (sub_length == 0)
+ goto out;
+
+
+ offset += sub_length;
+ sub_length = dissect_corosync_totemsrp_ip_address(tvb, pinfo, tree,
+ length, offset,
+ little_endian,
+ TRUE, 1,
+ NULL);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+out:
+ return (offset - original_offset);
+}
+
+static int
+dissect_corosync_totemsrp_mcast (tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *parent_tree,
+ guint length, int offset,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+
+#define corosync_totemsrp_mcast_length (corosync_totemsrp_srp_addr_length \
+ + 4 \
+ + 4 \
+ + corosync_totemsrp_memb_ring_id_length \
+ + 4 \
+ + 4)
+ if ((length - offset) < corosync_totemsrp_mcast_length) {
+ return 0;
+ }
+ original_offset = offset;
+
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_mcast, tvb, offset,
+ -1, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_mcast);
+
+ offset += 0;
+ sub_length = dissect_corosync_totemsrp_srp_addr(tvb, pinfo, tree,
+ length, offset,
+ hf_corosync_totemsrp_mcast_system_from,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_mcast_seq,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_mcast_this_seqno,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ sub_length = dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_mcast_node_id,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_mcast_guarantee,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+
+ {
+ gint len, reported_len;
+ tvbuff_t *next_tvb;
+ struct corosync_totemsrp_info* info;
+
+ len = tvb_length_remaining(tvb, offset);
+ reported_len = tvb_reported_length_remaining(tvb, offset);
+
+ next_tvb = tvb_new_subset(tvb, offset, len, reported_len);
+
+ info = (struct corosync_totemsrp_info*)pinfo->private_data;
+ if (dissector_try_heuristic(heur_subdissector_list,
+ next_tvb,
+ pinfo,
+ info->master_tree))
+ offset = length ;
+ }
+
+out:
+ 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,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+#define corosync_totemsrp_memb_merge_detect_length (corosync_totemsrp_srp_addr_length + corosync_totemsrp_memb_ring_id_length)
+ if ((length - offset) < corosync_totemsrp_memb_merge_detect_length) {
+ return 0;
+ }
+ original_offset = offset;
+
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_merge_detect, tvb, offset,
+ -1, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_merge_detect);
+
+ offset += 0;
+ sub_length = dissect_corosync_totemsrp_srp_addr(tvb, pinfo, tree,
+ length, offset,
+ 0,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+ sub_length = dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+out:
+ 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,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+ guint32 proc_list_entries;
+ proto_tree *proc_tree;
+ proto_item *proc_item;
+
+ guint32 failed_list_entries;
+ proto_tree *failed_tree;
+ proto_item *failed_item;
+
+ guint i;
+
+
+#define corosync_totemsrp_memb_join_length ( corosync_totemsrp_srp_addr_length \
+ + 4 \
+ + 4 \
+ + 8)
+ if ((length - offset) < corosync_totemsrp_memb_join_length)
+ return 0;
+
+ original_offset = offset;
+
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_join, tvb, offset,
+ -1, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_join);
+
+
+ offset += 0;
+ sub_length = dissect_corosync_totemsrp_srp_addr(tvb, pinfo, tree,
+ length, offset,
+ 0,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+ proc_item = proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_join_proc_list_entries,
+ tvb, offset, 4, little_endian);
+ proc_list_entries = corosync_totemsrp_get_guint32(tvb, offset, little_endian);
+
+ offset += 4;
+ failed_item = proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_join_failed_list_entries,
+ tvb, offset, 4, little_endian);
+ failed_list_entries = corosync_totemsrp_get_guint32(tvb, offset, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_join_ring_seq,
+ tvb, offset, 8, little_endian);
+
+ offset += 8;
+ proc_tree = proto_item_add_subtree(proc_item, ett_corosync_totemsrp_memb_join_proc_list);
+ for (i = 0; i < proc_list_entries; i++) {
+ sub_length = dissect_corosync_totemsrp_srp_addr(tvb, pinfo, proc_tree,
+ length, offset,
+ 0,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+ offset += sub_length;
+ }
+
+ failed_tree = proto_item_add_subtree(failed_item, ett_corosync_totemsrp_memb_join_failed_list);
+ for (i = 0; i < failed_list_entries; i++) {
+ sub_length = dissect_corosync_totemsrp_srp_addr(tvb, pinfo, failed_tree,
+ length, offset,
+ 0,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+ offset += sub_length;
+ }
+
+out:
+ 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,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+
+#define corosync_totemsrp_memb_commit_token_memb_entry_length ( corosync_totemsrp_memb_ring_id_length \
+ + 4 \
+ + 4 \
+ + 4 )
+ if ((length - offset) < corosync_totemsrp_memb_commit_token_memb_entry_length)
+ return 0;
+ original_offset = offset;
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_commit_token_memb_entry,
+ tvb, offset,
+ corosync_totemsrp_memb_commit_token_memb_entry_length, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_commit_token_memb_entry);
+
+
+ offset += 0;
+ sub_length = dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_commit_token_memb_entry_aru,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_commit_token_memb_entry_high_delivered,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_commit_token_memb_entry_received_flg,
+ tvb, offset, 4, little_endian);
+
+
+ offset += 4;
+out:
+ 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,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+ gint32 addr_entries;
+ gint i;
+
+#define corosync_totemsrp_memb_commit_token_length ( 4 \
+ + corosync_totemsrp_memb_ring_id_length \
+ + 4 \
+ + 4 \
+ + 4)
+ if ((length - offset) < corosync_totemsrp_memb_commit_token_length)
+ return 0;
+
+ original_offset = offset;
+
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_memb_commit_token,
+ tvb, offset, -1, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_memb_commit_token);
+
+
+ offset += 0;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_commit_token_token_seq,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ sub_length = dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_commit_token_retrans_flg,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_commit_token_memb_index,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_memb_commit_token_addr_entries,
+ tvb, offset, 4, little_endian);
+ addr_entries = corosync_totemsrp_get_gint32(tvb, offset, little_endian);
+
+
+ offset += 4;
+ if ((length - offset) < ((corosync_totemsrp_srp_addr_length
+ * addr_entries)
+ + (corosync_totemsrp_memb_commit_token_memb_entry_length
+ * addr_entries)))
+ goto out;
+
+ for (i = 0; i < addr_entries; i++) {
+ sub_length = dissect_corosync_totemsrp_srp_addr(tvb, pinfo, tree,
+ length, offset,
+ 0,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+ offset += sub_length;
+ }
+
+ for (i = 0; i < addr_entries; i++) {
+ sub_length = dissect_corosync_totemsrp_memb_commit_token_memb_entry(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+ offset += sub_length;
+ }
+
+out:
+ 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,
+ gboolean little_endian)
+{
+ int original_offset;
+ int sub_length;
+ proto_tree *tree;
+ proto_item *item;
+
+#define corosync_totemsrp_token_hold_cancel_length ( corosync_totemsrp_memb_ring_id_length )
+ if ((length - offset) < corosync_totemsrp_token_hold_cancel_length)
+ return 0;
+
+ original_offset = offset;
+
+
+ item = proto_tree_add_item(parent_tree, hf_corosync_totemsrp_token_hold_cancel, tvb, offset,
+ -1, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp_token_hold_cancel);
+
+
+ offset += 0;
+ sub_length = dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, tree,
+ length, offset,
+ little_endian);
+ if (sub_length == 0)
+ goto out;
+
+ offset += sub_length;
+out:
+ return (offset - original_offset);
+}
+
+int
+dissect_corosync_totemsrp(tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *parent_tree)
+{
+ proto_item *item;
+ proto_tree *tree;
+ guint length;
+ int offset;
+
+
+ guint8 message_header__type;
+ guint8 message_header__encapsulated;
+
+ union EndianDetector {
+ guint16 f;
+ guint8 b[2];
+ } message_header__endian_detector;
+ guint8 endian_expect[2] = COROSYNC_TOTEMSRP_ENDIAN_LOCAL;
+
+ gboolean little_endian;
+
+ struct corosync_totemsrp_info info;
+
+
+
+ /* Check that there's enough data */
+ length = tvb_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);
+ if (
+ /*
+ There is a version of corosync which encapsulated is not initialized.
+ The packet sent from the version of corosync, this dissector could not
+ recognize it as corosync packet. So I put special condition here:
+ don't check encapsulated field if the packet type is MESSAGE_TYPE_TOKEN_HOLD_CANCEL.
+
+ ------------------------------------------------------------------------
+ r2660 | sdake | 2010-02-19 05:08:39 +0900 (Fri, 19 Feb 2010) | 3 lines
+
+ Patch to set unset value in token hold cancel structure as to not crash
+ wireshark.
+
+ ------------------------------------------------------------------------
+ Index: exec/totemsrp.c
+ ===================================================================
+ --- exec/totemsrp.c (revision 2659)
+ +++ exec/totemsrp.c (revision 2660)
+ @@ -2627,6 +2627,7 @@
+
+ token_hold_cancel.header.type = MESSAGE_TYPE_TOKEN_HOLD_CANCEL;
+ token_hold_cancel.header.endian_detector = ENDIAN_LOCAL;
+ + token_hold_cancel.header.encapsulated = 0;
+ token_hold_cancel.header.nodeid = instance->my_id.addr[0].nodeid;
+ memcpy (&token_hold_cancel.ring_id, &instance->my_ring_id,
+ sizeof (struct memb_ring_id));
+ */
+ (message_header__type != COROSYNC_TOTEMSRP_MESSAGE_TYPE_TOKEN_HOLD_CANCEL)
+ && message_header__encapsulated > 2)
+ return 0;
+
+ /* message_header -- byte order checking */
+ tvb_memcpy(tvb, &message_header__endian_detector.f, 2, 2);
+
+ if ((message_header__endian_detector.b[0] == endian_expect[1])
+ && (message_header__endian_detector.b[1] == endian_expect[0]))
+ little_endian = TRUE;
+ else if ((message_header__endian_detector.b[0] == endian_expect[0])
+ && (message_header__endian_detector.b[1] == endian_expect[1]))
+ little_endian = FALSE;
+ else
+ return 0;
+
+ info.little_endian = little_endian;
+ info.original_private_data = pinfo->private_data;
+ info.master_tree = parent_tree;
+ pinfo->private_data = &info;
+
+
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "COROSYNC/TOTEMSRP");
+
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_clear(pinfo->cinfo, COL_INFO);
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_set_str(pinfo->cinfo, COL_INFO,
+ "COROSYNC/TOTEMSRP");
+
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_set_str(pinfo->cinfo, COL_INFO,
+ val_to_str(message_header__type,
+ corosync_totemsrp_message_header_type,
+ "packet-corosync-totemsrp.c internal bug"));
+
+ if (parent_tree) {
+ offset = 0;
+
+ item = proto_tree_add_item(parent_tree, proto_corosync_totemsrp, tvb, offset,
+ -1, little_endian);
+ tree = proto_item_add_subtree(item, ett_corosync_totemsrp);
+
+ offset += 0;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_message_header_type,
+ tvb, offset, 1, little_endian);
+ offset += 1;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_message_header_encapsulated,
+ tvb, offset, 1, little_endian);
+
+ offset += 1;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_message_header_endian_detector,
+ tvb, offset, 2, little_endian);
+
+ offset += 2;
+ proto_tree_add_item(tree,
+ hf_corosync_totemsrp_message_header_nodeid,
+ tvb, offset, 4, little_endian);
+
+ offset += 4;
+
+ switch (message_header__type) {
+ case COROSYNC_TOTEMSRP_MESSAGE_TYPE_ORF_TOKEN:
+ dissect_corosync_totemsrp_orf_token(tvb, pinfo, tree, length, offset,
+ little_endian);
+ break;
+ case COROSYNC_TOTEMSRP_MESSAGE_TYPE_MCAST:
+ dissect_corosync_totemsrp_mcast(tvb, pinfo, tree, length, offset,
+ little_endian);
+ break;
+ case COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_MERGE_DETECT:
+ dissect_corosync_totemsrp_memb_merge_detect(tvb, pinfo, tree, length, offset,
+ little_endian);
+ break;
+ case COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_JOIN:
+ dissect_corosync_totemsrp_memb_join(tvb, pinfo, tree, length, offset,
+ little_endian);
+ break;
+ case COROSYNC_TOTEMSRP_MESSAGE_TYPE_MEMB_COMMIT_TOKEN:
+ dissect_corosync_totemsrp_memb_commit_token(tvb, pinfo, tree, length, offset,
+ little_endian);
+ break;
+ case COROSYNC_TOTEMSRP_MESSAGE_TYPE_TOKEN_HOLD_CANCEL:
+ dissect_corosync_totemsrp_token_hold_cancel(tvb, pinfo, tree, length, offset,
+ little_endian);
+ break;
+ default:
+ break;
+ }
+ }
+
+ pinfo->private_data = info.original_private_data;
+ return tvb_length(tvb);
+}
+
+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,
+ { "Sequnce 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,
+ { "Squence 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,
+ {"Sequnce 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));
+
+ register_heur_dissector_list("corosync_totemsrp.mcast", &heur_subdissector_list);
+}
+
+
+/* Some code copyed from packet-dlm3.c. */
+void
+proto_reg_handoff_corosync_totemsrp(void)
+{
+ /* Nothing to be done.
+ dissect_corosync_totemsrp is directly called from corosync_totemnet dissector. */
+}
+
+
+
+static guint16
+corosync_totemsrp_get_guint16(tvbuff_t* tvb, gint offset, gboolean little_endian)
+{
+ return (little_endian? tvb_get_letohs: tvb_get_ntohs)(tvb, offset);
+}
+
+
+static guint32
+corosync_totemsrp_get_guint32(tvbuff_t* tvb, gint offset, gboolean little_endian)
+{
+ return (little_endian? tvb_get_letohl: tvb_get_ntohl)(tvb, offset);
+}
+
+static gint32
+corosync_totemsrp_get_gint32 (tvbuff_t* tvb, gint offset, gboolean little_endian)
+{
+ union {
+ guint32 u;
+ gint32 i;
+ } v;
+
+ v.u = corosync_totemsrp_get_guint32(tvb, offset, little_endian);
+ return v.i;
+}
+
+
+
+
+gboolean
+corosync_totemsrp_is_little_endian(packet_info *pinfo)
+{
+ struct corosync_totemsrp_info* info;
+
+
+ info = (struct corosync_totemsrp_info*)pinfo->private_data;
+ return info->little_endian;
+}
+
+int
+corosync_totemsrp_dissect_memb_ring_id(tvbuff_t *tvb,
+ packet_info *pinfo,
+ proto_tree *parent_tree,
+ guint length, int offset)
+{
+ return dissect_corosync_totemsrp_memb_ring_id(tvb, pinfo, parent_tree,
+ length, offset,
+ corosync_totemsrp_is_little_endian(pinfo));
+}
+
Index: wireshark-1.6.5/epan/dissectors/packet-corosync-totemsrp.h
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ wireshark-1.6.5/epan/dissectors/packet-corosync-totemsrp.h 2012-03-02 14:27:44.061540123 +0100
@@ -0,0 +1,53 @@
+/* packet-corosync-totemsrp.h
+ * Dissectors for totem single ring protocol implemented in corosync cluster engine
+ * Copyright 2007 2009 2010 Masatake YAMATO <yamato@redhat.com>
+ * Copyright (c) 2010 Red Hat, Inc.
+ *
+ * $Id$
+ *
+ * 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.
+ */
+
+#ifndef __PACKET_COROSYNC_TOTEMSRP_H__
+#define __PACKET_COROSYNC_TOTEMSRP_H__
+
+#include <netinet/in.h>
+
+extern int dissect_corosync_totemsrp (tvbuff_t *tvb,
+ packet_info *pinfo,
+ proto_tree *parent_tree);
+
+
+/* subdissectors for corosync_totemsrp can know the endian information
+ embedded in totemsrp packet header. */
+extern gboolean corosync_totemsrp_is_little_endian(packet_info *pinfo);
+
+
+#define COROSYNC_TOTEMSRP_IP_ADDRLEN (sizeof(struct in6_addr))
+#define corosync_totemsrp_ip_address_length ( 4 + 2 + COROSYNC_TOTEMSRP_IP_ADDRLEN )
+#define corosync_totemsrp_memb_ring_id_length ( 8 + corosync_totemsrp_ip_address_length )
+
+extern int corosync_totemsrp_dissect_memb_ring_id(tvbuff_t *tvb,
+ packet_info *pinfo,
+ proto_tree *parent_tree,
+ guint length,
+ int offset);
+
+
+#endif /* packet-totemsrp.h */
Index: wireshark-1.6.5/epan/dissectors/Makefile.in
===================================================================
--- wireshark-1.6.5.orig/epan/dissectors/Makefile.in 2012-01-10 20:09:44.000000000 +0100
+++ wireshark-1.6.5/epan/dissectors/Makefile.in 2012-03-02 14:27:44.065540133 +0100
@@ -231,6 +231,8 @@ am__objects_3 = libdissectors_la-packet-
libdissectors_la-packet-collectd.lo \
libdissectors_la-packet-componentstatus.lo \
libdissectors_la-packet-cops.lo \
+ libdissectors_la-packet-corosync-totemnet.lo \
+ libdissectors_la-packet-corosync-totemsrp.lo \
libdissectors_la-packet-cosine.lo \
libdissectors_la-packet-cpfi.lo \
libdissectors_la-packet-cpha.lo \
@@ -1555,6 +1557,8 @@ DISSECTOR_SRC = \
packet-collectd.c \
packet-componentstatus.c \
packet-cops.c \
+ packet-corosync-totemnet.c \
+ packet-corosync-totemsrp.c \
packet-cosine.c \
packet-cpfi.c \
packet-cpha.c \
@@ -2890,6 +2894,8 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-collectd.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-componentstatus.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-cops.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-corosync-totemnet.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-corosync-totemsrp.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-cosine.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-cpfi.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-cpha.Plo@am__quote@
@@ -4611,6 +4617,20 @@ libdissectors_la-packet-cops.lo: packet-
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libdissectors_la_CFLAGS) $(CFLAGS) -c -o libdissectors_la-packet-cops.lo `test -f 'packet-cops.c' || echo '$(srcdir)/'`packet-cops.c
+libdissectors_la-packet-corosync-totemnet.lo: packet-corosync-totemnet.c
+@am__fastdepCC_TRUE@ if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libdissectors_la_CFLAGS) $(CFLAGS) -MT libdissectors_la-packet-corosync-totemnet.lo -MD -MP -MF "$(DEPDIR)/libdissectors_la-packet-corosync-totemnet.Tpo" -c -o libdissectors_la-packet-corosync-totemnet.lo `test -f 'packet-corosync-totemnet.c' || echo '$(srcdir)/'`packet-corosync-totemnet.c; \
+@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/libdissectors_la-packet-corosync-totemnet.Tpo" "$(DEPDIR)/libdissectors_la-packet-corosync-totemnet.Plo"; else rm -f "$(DEPDIR)/libdissectors_la-packet-corosync-totemnet.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='packet-corosync-totemnet.c' object='libdissectors_la-packet-corosync-totemnet.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libdissectors_la_CFLAGS) $(CFLAGS) -c -o libdissectors_la-packet-corosync-totemnet.lo `test -f 'packet-corosync-totemnet.c' || echo '$(srcdir)/'`packet-corosync-totemnet.c
+
+libdissectors_la-packet-corosync-totemsrp.lo: packet-corosync-totemsrp.c
+@am__fastdepCC_TRUE@ if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libdissectors_la_CFLAGS) $(CFLAGS) -MT libdissectors_la-packet-corosync-totemsrp.lo -MD -MP -MF "$(DEPDIR)/libdissectors_la-packet-corosync-totemsrp.Tpo" -c -o libdissectors_la-packet-corosync-totemsrp.lo `test -f 'packet-corosync-totemsrp.c' || echo '$(srcdir)/'`packet-corosync-totemsrp.c; \
+@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/libdissectors_la-packet-corosync-totemsrp.Tpo" "$(DEPDIR)/libdissectors_la-packet-corosync-totemsrp.Plo"; else rm -f "$(DEPDIR)/libdissectors_la-packet-corosync-totemsrp.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='packet-corosync-totemsrp.c' object='libdissectors_la-packet-corosync-totemsrp.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libdissectors_la_CFLAGS) $(CFLAGS) -c -o libdissectors_la-packet-corosync-totemsrp.lo `test -f 'packet-corosync-totemsrp.c' || echo '$(srcdir)/'`packet-corosync-totemsrp.c
+
libdissectors_la-packet-cosine.lo: packet-cosine.c
@am__fastdepCC_TRUE@ if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libdissectors_la_CFLAGS) $(CFLAGS) -MT libdissectors_la-packet-cosine.lo -MD -MP -MF "$(DEPDIR)/libdissectors_la-packet-cosine.Tpo" -c -o libdissectors_la-packet-cosine.lo `test -f 'packet-cosine.c' || echo '$(srcdir)/'`packet-cosine.c; \
@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/libdissectors_la-packet-cosine.Tpo" "$(DEPDIR)/libdissectors_la-packet-cosine.Plo"; else rm -f "$(DEPDIR)/libdissectors_la-packet-cosine.Tpo"; exit 1; fi