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