rpm/wireshark
SHA256
1
0
Fork 0
forked from pool/wireshark
Code Pull Requests Activity
475c86ebc3
wireshark/wireshark-corosync-packet-dissector.patch
Cristian Rodríguez 475c86ebc3 Accepting request 107780 from home:gladiac:branches:network:utilities 
Add detection for an important flag in NetrServerAutiticate call for MSRPC Netlogon.

OBS-URL: https://build.opensuse.org/request/show/107780
OBS-URL: https://build.opensuse.org/package/show/network:utilities/wireshark?expand=0&rev=50
2012-03-02 16:21:49 +00:00

2787 lines
112 KiB
Diff
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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
View Git Blame Copy Permalink