From 7da2d7b4954b30b89ebbc2a0d4a061c0df5db9e2d8a8d5120e2a0395ad75f6cf Mon Sep 17 00:00:00 2001 From: Pavol Rusnak Date: Fri, 4 Jun 2010 00:29:28 +0000 Subject: [PATCH 1/2] Accepting request 41036 from home:tserong:branches:network:utilities 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 --- corosync-packet-dissector.patch | 2786 +++++++++++++++++++++++++++++++ wireshark.changes | 8 + wireshark.spec | 2 + 3 files changed, 2796 insertions(+) create mode 100644 corosync-packet-dissector.patch diff --git a/corosync-packet-dissector.patch b/corosync-packet-dissector.patch new file mode 100644 index 0000000..0e7784c --- /dev/null +++ b/corosync-packet-dissector.patch @@ -0,0 +1,2786 @@ +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 ++ * Copyright (c) 2010 Red Hat, Inc. ++ * ++ * $Id:$ ++ * ++ * Wireshark - Network traffic analyzer ++ * By Gerald Combs ++ * 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 ++#include ++#include ++#include ++ ++#include ++ ++#include ++#include ++#include ++ ++#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 ++ * Copyright (c) 2010 Red Hat, Inc. ++ * ++ * $Id$ ++ * ++ * Wireshark - Network traffic analyzer ++ * By Gerald Combs ++ * 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 ++#include ++#include ++ ++#include ++ ++#include ++ ++#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 ++ * Copyright (c) 2010 Red Hat, Inc. ++ * ++ * $Id$ ++ * ++ * Wireshark - Network traffic analyzer ++ * By Gerald Combs ++ * 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 ++ ++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 diff --git a/wireshark.changes b/wireshark.changes index 3149d66..e16f2d8 100644 --- a/wireshark.changes +++ b/wireshark.changes @@ -1,3 +1,11 @@ +------------------------------------------------------------------- +Thu Jun 3 06:41:23 UTC 2010 - tserong@novell.com + +- Added corosync packet dissector (patch 4724 from + https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=3232, + minus "private key" setting, which doesn't work with + nice random binary keys in /etc/corosync/authkey) + ------------------------------------------------------------------- Fri May 14 12:48:53 CEST 2010 - prusnak@suse.cz diff --git a/wireshark.spec b/wireshark.spec index 5c5f517..1147f84 100644 --- a/wireshark.spec +++ b/wireshark.spec @@ -35,6 +35,7 @@ Patch1: %{name}-1.2.0-disable-warning-dialog.patch Patch2: %{name}-1.2.0-asneeded.patch # PATCH-FEATURE-OPENSUSE wireshark-1.2.0-geoip.patch prusnak@suse.cz -- search in /var/lib/GeoIP if user hasn't set any GeoIP folders Patch3: %{name}-1.2.0-geoip.patch +Patch4: corosync-packet-dissector.patch BuildRoot: %{_tmppath}/%{name}-%{version}-build Requires: xdg-utils Provides: ethereal = %{version} @@ -97,6 +98,7 @@ view the reconstructed stream of a TCP session. %patch1 %patch2 %patch3 +%patch4 -p1 %build %configure From 1c3de9ec885cd82f36e15cd36f976e4709e20175e079116b8e94db855349139e Mon Sep 17 00:00:00 2001 From: OBS User autobuild Date: Fri, 4 Jun 2010 13:06:22 +0000 Subject: [PATCH 2/2] Accepting request 41072 from network:utilities checked in (request 41072) OBS-URL: https://build.opensuse.org/request/show/41072 OBS-URL: https://build.opensuse.org/package/show/network:utilities/wireshark?expand=0&rev=20 --- wireshark.spec | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/wireshark.spec b/wireshark.spec index 1147f84..a01a292 100644 --- a/wireshark.spec +++ b/wireshark.spec @@ -23,7 +23,7 @@ License: GPLv2+ Group: Productivity/Networking/Diagnostic Summary: A Network Traffic Analyser Version: 1.2.8 -Release: 1 +Release: 2 Url: http://www.wireshark.org/ Source: http://www.wireshark.org/download/src/%{name}-%{version}.tar.bz2 Source1: include.filelist @@ -35,7 +35,7 @@ Patch1: %{name}-1.2.0-disable-warning-dialog.patch Patch2: %{name}-1.2.0-asneeded.patch # PATCH-FEATURE-OPENSUSE wireshark-1.2.0-geoip.patch prusnak@suse.cz -- search in /var/lib/GeoIP if user hasn't set any GeoIP folders Patch3: %{name}-1.2.0-geoip.patch -Patch4: corosync-packet-dissector.patch +Patch4: corosync-packet-dissector.patch BuildRoot: %{_tmppath}/%{name}-%{version}-build Requires: xdg-utils Provides: ethereal = %{version}