7da2d7b495
Copy from home:tserong:branches:network:utilities/wireshark via accept of submit request 41036 revision 4. Request was accepted with message: Reviewed ok OBS-URL: https://build.opensuse.org/request/show/41036 OBS-URL: https://build.opensuse.org/package/show/network:utilities/wireshark?expand=0&rev=19
2787 lines
112 KiB
Diff
2787 lines
112 KiB
Diff
Index: wireshark-1.2.8/epan/dissectors/Makefile.common
|
||
===================================================================
|
||
--- wireshark-1.2.8.orig/epan/dissectors/Makefile.common
|
||
+++ wireshark-1.2.8/epan/dissectors/Makefile.common
|
||
@@ -293,6 +293,8 @@ DISSECTOR_SRC = \
|
||
packet-cmpp.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.2.8/epan/dissectors/packet-corosync-totemnet.c
|
||
===================================================================
|
||
--- /dev/null
|
||
+++ wireshark-1.2.8/epan/dissectors/packet-corosync-totemnet.c
|
||
@@ -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.2.8/epan/dissectors/packet-corosync-totemsrp.c
|
||
===================================================================
|
||
--- /dev/null
|
||
+++ wireshark-1.2.8/epan/dissectors/packet-corosync-totemsrp.c
|
||
@@ -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.2.8/epan/dissectors/packet-corosync-totemsrp.h
|
||
===================================================================
|
||
--- /dev/null
|
||
+++ wireshark-1.2.8/epan/dissectors/packet-corosync-totemsrp.h
|
||
@@ -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.2.8/epan/dissectors/Makefile.in
|
||
===================================================================
|
||
--- wireshark-1.2.8.orig/epan/dissectors/Makefile.in
|
||
+++ wireshark-1.2.8/epan/dissectors/Makefile.in
|
||
@@ -215,6 +215,8 @@ am__objects_4 = libdissectors_la-packet-
|
||
libdissectors_la-packet-cmpp.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 \
|
||
@@ -1391,6 +1393,8 @@ DISSECTOR_SRC = \
|
||
packet-cmpp.c \
|
||
packet-componentstatus.c \
|
||
packet-cops.c \
|
||
+ packet-corosync-totemnet.c \
|
||
+ packet-corosync-totemsrp.c \
|
||
packet-cosine.c \
|
||
packet-cpfi.c \
|
||
packet-cpha.c \
|
||
@@ -2618,6 +2622,8 @@ distclean-compile:
|
||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdissectors_la-packet-cms.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@
|
||
@@ -4124,6 +4130,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
|