Hazelcast 2.5 (and probably newer) Wireshark packet dissector patch.

wireshark-packet-hazelcast25.patch

diff --git a/epan/dissectors/packet-hazelcast.c b/epan/dissectors/packet-hazelcast.c
index 841ef56..f059f65 100644
--- a/epan/dissectors/packet-hazelcast.c
+++ b/epan/dissectors/packet-hazelcast.c
@@ -6,7 +6,7 @@
  * Website: http://www.hazelcast.com/
  *
  * reversed from this code:
- * http://code.google.com/p/hazelcast/source/browse/branches/1.9.4/hazelcast/src/main/java/com/hazelcast/nio/Packet.java
+ * https://github.com/hazelcast/hazelcast/blob/02c48a533c6398303eb526481af15dd444fb0a21/hazelcast/src/main/java/com/hazelcast/nio/Packet.java
  *
  * Wireshark - Network traffic analyzer
  * By Gerald Combs <gerald@wireshark.org>
@@ -56,8 +56,10 @@ static int hf_hazelcast_txnID = -1;
 static int hf_hazelcast_longValue = -1;
 static int hf_hazelcast_version = -1;
 static int hf_hazelcast_lockCount = -1;
-static int hf_hazelcast_lockAddrIP = -1;
+static int hf_hazelcast_lockAddrHost = -1;
 static int hf_hazelcast_lockAddrPort = -1;
+static int hf_hazelcast_lockAddrType = -1;
+static int hf_hazelcast_lockAddrLength = -1;
 static int hf_hazelcast_callID = -1;
 static int hf_hazelcast_responseType = -1;
 static int hf_hazelcast_nameLength = -1;
@@ -98,127 +100,150 @@ static gboolean hazelcast_desegment = TRUE;
 static guint gPORT_PREF = 5701;
 
 static const value_string operationTypes[] = {
-    {0,   "NONE"},
-    {1,   "RESPONSE"},
-    {2,   "LOG"},
-    {3,   "HEARTBEAT"},
-    {4,   "JOIN_CHECK"},
-    {5,   "REMOTELY_PROCESS"},
-    {6,   "REMOTELY_PROCESS_AND_RESPOND"},
-    {7,   "REMOTELY_CALLABLE_BOOLEAN"},
-    {8,   "REMOTELY_CALLABLE_OBJECT"},
-    {9,   "EVENT"},
-    {10,  "EXECUTE"},
-    {11,  "CANCEL_EXECUTION"},
-    {12,  "ADD_LISTENER"},
-    {13,  "ADD_LISTENER_NO_RESPONSE"},
-    {14,  "REMOVE_LISTENER"},
-    {15,  "BLOCKING_ADD_KEY"},
-    {16,  "BLOCKING_REMOVE_KEY"},
-    {17,  "BLOCKING_OFFER_KEY"},
-    {18,  "BLOCKING_GENERATE_KEY"},
-    {19,  "BLOCKING_ITERATE"},
-    {20,  "BLOCKING_SIZE"},
-    {21,  "BLOCKING_TAKE_KEY"},
-    {22,  "BLOCKING_CANCEL_TAKE_KEY"},
-    {23,  "BLOCKING_SET"},
-    {24,  "BLOCKING_PEEK_KEY"},
-    {25,  "BLOCKING_GET_KEY_BY_INDEX"},
-    {26,  "BLOCKING_GET_INDEX_BY_KEY"},
-    {27,  "BLOCKING_QUEUE_POLL"},
-    {28,  "BLOCKING_QUEUE_OFFER"},
-    {29,  "BLOCKING_QUEUE_SIZE"},
-    {30,  "BLOCKING_QUEUE_PEEK"},
-    {31,  "BLOCKING_QUEUE_REMOVE"},
-    {32,  "TOPIC_PUBLISH"},
-    {33,  "ATOMIC_NUMBER_ADD_AND_GET"},
-    {34,  "ATOMIC_NUMBER_GET_AND_ADD"},
-    {35,  "ATOMIC_NUMBER_GET_AND_SET"},
-    {36,  "ATOMIC_NUMBER_COMPARE_AND_SET"},
-    {37,  "CONCURRENT_MAP_PUT"},
-    {38,  "CONCURRENT_MAP_PUT_ALL"},
-    {39,  "CONCURRENT_MAP_PUT_TRANSIENT"},
-    {40,  "CONCURRENT_MAP_SET"},
-    {41,  "CONCURRENT_MAP_MERGE"},
-    {42,  "CONCURRENT_MAP_ASYNC_MERGE"},
-    {43,  "CONCURRENT_MAP_WAN_MERGE"},
-    {44,  "CONCURRENT_MAP_TRY_PUT"},
-    {45,  "CONCURRENT_MAP_PUT_AND_UNLOCK"},
-    {46,  "CONCURRENT_MAP_GET"},
-    {47,  "CONCURRENT_MAP_GET_ALL"},
-    {48,  "CONCURRENT_MAP_REMOVE"},
-    {49,  "CONCURRENT_MAP_TRY_REMOVE"},
-    {50,  "CONCURRENT_MAP_REMOVE_ITEM"},
-    {51,  "CONCURRENT_MAP_GET_MAP_ENTRY"},
-    {52,  "CONCURRENT_MAP_GET_DATA_RECORD_ENTRY"},
-    {53,  "CONCURRENT_MAP_BLOCK_INFO"},
-    {54,  "CONCURRENT_MAP_BLOCK_MIGRATION_CHECK"},
-    {55,  "CONCURRENT_MAP_SIZE"},
-    {56,  "CONCURRENT_MAP_CONTAINS_KEY"},
-    {57,  "CONCURRENT_MAP_CONTAINS_ENTRY"},
-    {58,  "CONCURRENT_MAP_ITERATE_ENTRIES"},
-    {59,  "CONCURRENT_MAP_ITERATE_KEYS"},
-    {60,  "CONCURRENT_MAP_ITERATE_KEYS_ALL"},
-    {61,  "CONCURRENT_MAP_ITERATE_VALUES"},
-    {62,  "CONCURRENT_MAP_LOCK"},
-    {63,  "CONCURRENT_MAP_LOCK_MAP"},
-    {64,  "CONCURRENT_MAP_UNLOCK"},
-    {65,  "CONCURRENT_MAP_FORCE_UNLOCK"},
-    {66,  "CONCURRENT_MAP_UNLOCK_MAP"},
-    {67,  "CONCURRENT_MAP_BLOCKS"},
-    {68,  "CONCURRENT_MAP_CONTAINS_VALUE"},
-    {69,  "CONCURRENT_MAP_PUT_IF_ABSENT"},
-    {70,  "CONCURRENT_MAP_REMOVE_IF_SAME"},
-    {71,  "CONCURRENT_MAP_REPLACE_IF_NOT_NULL"},
-    {72,  "CONCURRENT_MAP_REPLACE_IF_SAME"},
-    {73,  "CONCURRENT_MAP_TRY_LOCK_AND_GET"},
-    {74,  "CONCURRENT_MAP_ADD_TO_LIST"},
-    {75,  "CONCURRENT_MAP_ADD_TO_SET"},
-    {76,  "CONCURRENT_MAP_MIGRATE_RECORD"},
-    {77,  "CONCURRENT_MAP_PUT_MULTI"},
-    {78,  "CONCURRENT_MAP_REMOVE_MULTI"},
-    {79,  "CONCURRENT_MAP_VALUE_COUNT"},
-    {80,  "CONCURRENT_MAP_BACKUP_PUT"},
-    {81,  "CONCURRENT_MAP_BACKUP_REMOVE"},
-    {82,  "CONCURRENT_MAP_BACKUP_REMOVE_MULTI"},
-    {83,  "CONCURRENT_MAP_BACKUP_LOCK"},
-    {84,  "CONCURRENT_MAP_BACKUP_ADD"},
-    {85,  "CONCURRENT_MAP_INVALIDATE"},
-    {86,  "CONCURRENT_MAP_EVICT"},
-    {87,  "CONCURRENT_MAP_FLUSH"},
-    {88,  "TRANSACTION_BEGIN"},
-    {89,  "TRANSACTION_COMMIT"},
-    {90,  "TRANSACTION_ROLLBACK"},
-    {91,  "DESTROY"},
-    {92,  "GET_ID"},
-    {93,  "NEW_ID"},
-    {94,  "ADD_INDEX"},
-    {95,  "GET_INSTANCES"},
-    {96,  "GET_MEMBERS"},
-    {97,  "GET_CLUSTER_TIME"},
-    {98,  "CLIENT_AUTHENTICATE"},
-    {99,  "CLIENT_ADD_INSTANCE_LISTENER"},
-    {100, "CLIENT_GET_PARTITIONS"},
-    {101, "BLOCKING_QUEUE_REMAINING_CAPACITY"},
-    {102, "BLOCKING_QUEUE_ENTRIES"},
-    {103, "COUNT_DOWN_LATCH_AWAIT"},
-    {104, "COUNT_DOWN_LATCH_COUNT_DOWN"},
-    {105, "COUNT_DOWN_LATCH_DESTROY"},
-    {106, "COUNT_DOWN_LATCH_GET_COUNT"},
-    {107, "COUNT_DOWN_LATCH_GET_OWNER"},
-    {108, "COUNT_DOWN_LATCH_SET_COUNT"},
-    {109, "SEMAPHORE_ATTACH_DETACH_PERMITS"},
-    {110, "SEMAPHORE_CANCEL_ACQUIRE"},
-    {111, "SEMAPHORE_DESTROY"},
-    {112, "SEMAPHORE_DRAIN_PERMITS"},
-    {113, "SEMAPHORE_GET_ATTACHED_PERMITS"},
-    {114, "SEMAPHORE_GET_AVAILABLE_PERMITS"},
-    {115, "SEMAPHORE_REDUCE_PERMITS"},
-    {116, "SEMAPHORE_RELEASE"},
-    {117, "SEMAPHORE_TRY_ACQUIRE"},
-    {118, "LOCK_LOCK"},
-    {119, "LOCK_UNLOCK"},
-    {120, "LOCK_FORCE_UNLOCK"},
+    /* GENERAL */
+    {0,	"NONE"},
+    {1,	"RESPONSE"},
+    {2,	"LOG"},
+    {3,	"HEARTBEAT"},
+    {4,	"JOIN_CHECK"},
+    /* EXECUTOR */
+    {7,	"REMOTELY_PROCESS"},
+    {8,	"REMOTELY_PROCESS_AND_RESPOND"},
+    {9,	"REMOTELY_CALLABLE_BOOLEAN"},
+    {10,	"REMOTELY_CALLABLE_OBJECT"},
+    {12,	"EVENT"},
+    {13,	"EXECUTE"},
+    {14,	"CANCEL_EXECUTION"},
+    /* EVENT LISTENER */
+    {17,	"ADD_LISTENER"},
+    {18,	"ADD_LISTENER_NO_RESPONSE"},
+    {19,	"REMOVE_LISTENER"},
+    /* BLOCKING QUEUE */
+    {21,	"BLOCKING_ADD_KEY"},
+    {22,	"BLOCKING_REMOVE_KEY"},
+    {23,	"BLOCKING_OFFER_KEY"},
+    {24,	"BLOCKING_GENERATE_KEY"},
+    {25,	"BLOCKING_ITERATE"},
+    {26,	"BLOCKING_SIZE"},
+    {27,	"BLOCKING_TAKE_KEY"},
+    {28,	"BLOCKING_CANCEL_TAKE_KEY"},
+    {29,	"BLOCKING_SET"},
+    {30,	"BLOCKING_PEEK_KEY"},
+    {31,	"BLOCKING_GET_KEY_BY_INDEX"},
+    {32,	"BLOCKING_GET_INDEX_BY_KEY"},
+    {33,	"BLOCKING_QUEUE_POLL"},
+    {34,	"BLOCKING_QUEUE_OFFER"},
+    {35,	"BLOCKING_QUEUE_SIZE"},
+    {36,	"BLOCKING_QUEUE_PEEK"},
+    {37,	"BLOCKING_QUEUE_REMOVE"},
+    {38,	"BLOCKING_QUEUE_REMAINING_CAPACITY"},
+    {39,	"BLOCKING_QUEUE_ENTRIES"},
+    /* CONCURRENT_MAP */
+    {50,	"CONCURRENT_MAP_PUT"},
+    {51,	"CONCURRENT_MAP_PUT_ALL"},
+    {52,	"CONCURRENT_MAP_PUT_TRANSIENT"},
+    {175,	"CONCURRENT_MAP_PUT_FROM_LOAD"},
+    {53,	"CONCURRENT_MAP_SET"},
+    {54,	"CONCURRENT_MAP_MERGE"},
+    {55,	"CONCURRENT_MAP_ASYNC_MERGE"},
+    {56,	"CONCURRENT_MAP_WAN_MERGE"},
+    {57,	"CONCURRENT_MAP_TRY_PUT"},
+    {58,	"CONCURRENT_MAP_PUT_AND_UNLOCK"},
+    {59,	"CONCURRENT_MAP_GET"},
+    {60,	"CONCURRENT_MAP_GET_ALL"},
+    {61,	"CONCURRENT_MAP_REMOVE"},
+    {62,	"CONCURRENT_MAP_TRY_REMOVE"},
+    {63,	"CONCURRENT_MAP_REMOVE_ITEM"},
+    {64,	"CONCURRENT_MAP_GET_MAP_ENTRY"},
+    {65,	"CONCURRENT_MAP_GET_DATA_RECORD_ENTRY"},
+    {66,	"CONCURRENT_MAP_BLOCK_INFO"},
+    {67,	"CONCURRENT_MAP_BLOCK_MIGRATION_CHECK"},
+    {68,	"CONCURRENT_MAP_SIZE"},
+    {69,	"CONCURRENT_MAP_CONTAINS_KEY"},
+    {70,	"CONCURRENT_MAP_CONTAINS_ENTRY"},
+    {71,	"CONCURRENT_MAP_ITERATE_ENTRIES"},
+    {72,	"CONCURRENT_MAP_ITERATE_KEYS"},
+    {73,	"CONCURRENT_MAP_ITERATE_KEYS_ALL"},
+    {74,	"CONCURRENT_MAP_ITERATE_VALUES"},
+    {75,	"CONCURRENT_MAP_LOCK"},
+    {173,	"CONCURRENT_MAP_IS_KEY_LOCKED"},
+    {76,	"CONCURRENT_MAP_LOCK_MAP"},
+    {77,	"CONCURRENT_MAP_UNLOCK"},
+    {78,	"CONCURRENT_MAP_FORCE_UNLOCK"},
+    {79,	"CONCURRENT_MAP_UNLOCK_MAP"},
+    {80,	"CONCURRENT_MAP_BLOCKS"},
+    {81,	"CONCURRENT_MAP_CONTAINS_VALUE"},
+    {82,	"CONCURRENT_MAP_PUT_IF_ABSENT"},
+    {83,	"CONCURRENT_MAP_REMOVE_IF_SAME"},
+    {84,	"CONCURRENT_MAP_REPLACE_IF_NOT_NULL"},
+    {85,	"CONCURRENT_MAP_REPLACE_IF_SAME"},
+    {86,	"CONCURRENT_MAP_TRY_LOCK_AND_GET"},
+    {87,	"CONCURRENT_MAP_ADD_TO_LIST"},
+    {88,	"CONCURRENT_MAP_ADD_TO_SET"},
+    {89,	"CONCURRENT_MAP_MIGRATE_RECORD"},
+    {90,	"CONCURRENT_MAP_PUT_MULTI"},
+    {91,	"CONCURRENT_MAP_REMOVE_MULTI"},
+    {92,	"CONCURRENT_MAP_VALUE_COUNT"},
+    {93,	"CONCURRENT_MAP_BACKUP_PUT"},
+    {94,	"CONCURRENT_MAP_BACKUP_REMOVE"},
+    {95,	"CONCURRENT_MAP_BACKUP_REMOVE_MULTI"},
+    {96,	"CONCURRENT_MAP_BACKUP_LOCK"},
+    {97,	"CONCURRENT_MAP_BACKUP_ADD"},
+    {98,	"CONCURRENT_MAP_INVALIDATE"},
+    {99,	"CONCURRENT_MAP_EVICT"},
+    {100,	"CONCURRENT_MAP_FLUSH"},
+    {101,	"CONCURRENT_MAP_BACKUP_PUT_AND_UNLOCK"},
+    {102,	"CONCURRENT_MAP_CLEAR_QUICK"},
+    /* TOPIC */
+    {111,	"TOPIC_PUBLISH"},
+    /* ATOMIC NUMBER */
+    {112,	"ATOMIC_NUMBER_ADD_AND_GET"},
+    {113,	"ATOMIC_NUMBER_GET_AND_ADD"},
+    {114,	"ATOMIC_NUMBER_GET_AND_SET"},
+    {115,	"ATOMIC_NUMBER_COMPARE_AND_SET"},
+    /* TRANSACTION */
+    {120,	"TRANSACTION_BEGIN"},
+    {121,	"TRANSACTION_COMMIT"},
+    {122,	"TRANSACTION_ROLLBACK"},
+    {125,	"DESTROY"},
+    /* ID GEN */
+    {126,	"GET_ID"},
+    {127,	"NEW_ID"},
+    /* INDEX */
+    {128,	"ADD_INDEX"},
+    /* CLUSTER */
+    {130,	"GET_INSTANCES"},
+    {131,	"GET_MEMBERS"},
+    {132,	"GET_CLUSTER_TIME"},
+    {133,	"GET_CONFIG"},
+    /* CLIENT */
+    {135,	"CLIENT_AUTHENTICATE"},
+    {136,	"CLIENT_ADD_INSTANCE_LISTENER"},
+    {137,	"CLIENT_GET_PARTITIONS"},
+    /* COUNT DOWN LATCH */
+    {140,	"COUNT_DOWN_LATCH_AWAIT"},
+    {141,	"COUNT_DOWN_LATCH_COUNT_DOWN"},
+    {142,	"COUNT_DOWN_LATCH_DESTROY"},
+    {143,	"COUNT_DOWN_LATCH_GET_COUNT"},
+    {144,	"COUNT_DOWN_LATCH_GET_OWNER"},
+    {145,	"COUNT_DOWN_LATCH_SET_COUNT"},
+    /* SEMAPHORE */
+    {150,	"SEMAPHORE_ATTACH_DETACH_PERMITS"},
+    {151,	"SEMAPHORE_CANCEL_ACQUIRE"},
+    {152,	"SEMAPHORE_DESTROY"},
+    {153,	"SEMAPHORE_DRAIN_PERMITS"},
+    {154,	"SEMAPHORE_GET_ATTACHED_PERMITS"},
+    {155,	"SEMAPHORE_GET_AVAILABLE_PERMITS"},
+    {156,	"SEMAPHORE_REDUCE_PERMITS"},
+    {157,	"SEMAPHORE_RELEASE"},
+    {158,	"SEMAPHORE_TRY_ACQUIRE"},
+    /* LOCK */
+    {170,	"LOCK_LOCK"},
+    {171,	"LOCK_UNLOCK"},
+    {172,	"LOCK_FORCE_UNLOCK"},
+    /* {173,	"CONCURRENT_MAP_IS_KEY_LOCKED"}, see above */
+    {174,	"LOCK_IS_LOCKED"},
+    /* {175,	"CONCURRENT_MAP_PUT_FROM_LOAD"}, see above */
     {0  , NULL}
 };
 static value_string_ext operationTypes_ext = VALUE_STRING_EXT_INIT(operationTypes);
@@ -260,7 +285,7 @@ static int dissect_hazelcast_message(tvbuff_t *tvb, packet_info *pinfo _U_, prot
     guint8  version;
 
     guint8  flags;
-    guint8  operation;
+    guint16  operation;
 
     guint8  lockCountFlag;
     guint8  timeoutFlag;
@@ -272,6 +297,7 @@ static int dissect_hazelcast_message(tvbuff_t *tvb, packet_info *pinfo _U_, prot
 
     guint32 nameLength;
     guint32 keyLength;
+    guint32 lockAddrLength;
     guint32 valueLength;
     gint    offset = 0;
 
@@ -297,7 +323,7 @@ static int dissect_hazelcast_message(tvbuff_t *tvb, packet_info *pinfo _U_, prot
     }
 
     version = tvb_get_guint8(tvb, 12);
-    if ( version != 6 ) {
+    if ( version != 8 ) {
         col_set_str(pinfo->cinfo, COL_INFO, "Hazelcast unsupported version");
         return 12;
     }
@@ -314,10 +340,10 @@ static int dissect_hazelcast_message(tvbuff_t *tvb, packet_info *pinfo _U_, prot
     offset += 1;
 
 
-    proto_tree_add_item(hcast_tree, hf_hazelcast_operation, tvb, offset, 1, ENC_BIG_ENDIAN);
-    operation = tvb_get_guint8(tvb, offset);
+    proto_tree_add_item(hcast_tree, hf_hazelcast_operation, tvb, offset, 2, ENC_BIG_ENDIAN);
+    operation = tvb_get_ntohs(tvb, offset);
     col_add_fstr(pinfo->cinfo, COL_INFO, "%s", val_to_str(operation, operationTypes, "Unknown (0x%02x)"));
-    offset += 1;
+    offset += 2;
 
     proto_tree_add_item(hcast_tree, hf_hazelcast_blockID, tvb, offset, 4, ENC_BIG_ENDIAN);
     offset += 4;
@@ -382,10 +408,18 @@ static int dissect_hazelcast_message(tvbuff_t *tvb, packet_info *pinfo _U_, prot
     }
 
     if ( lockAddrNullFlag == 0 ) {
-        proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrIP, tvb, offset, 4, ENC_BIG_ENDIAN);
-        offset += 4;
         proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrPort, tvb, offset, 4, ENC_BIG_ENDIAN);
         offset += 4;
+	proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrType, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset += 1;
+        proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrLength, tvb, offset, 4, ENC_BIG_ENDIAN);
+	lockAddrLength = tvb_get_ntohl(tvb, offset);
+        offset += 4;
+
+	if ( lockAddrLength > 0 ) {
+	    proto_tree_add_item(hcast_tree, hf_hazelcast_lockAddrHost, tvb, offset, lockAddrLength, ENC_ASCII|ENC_NA);
+	    offset += lockAddrLength;
+	}
     }
 
     proto_tree_add_item(hcast_tree, hf_hazelcast_callID, tvb, offset, 8, ENC_BIG_ENDIAN);
@@ -507,11 +541,17 @@ void proto_register_hazelcast(void) {
         { &hf_hazelcast_lockCount,
           { "hazelcast lockCount", "hazelcast.lockCount", FT_UINT32, BASE_DEC, NULL, 0x0, "lockCount", HFILL }
         },
-        { &hf_hazelcast_lockAddrIP,
-          { "hazelcast lock address IP", "hazelcast.lockaddr.ip", FT_IPv4, BASE_NONE, NULL, 0x0, "lockAddrIP", HFILL }
+        { &hf_hazelcast_lockAddrType,
+          { "hazelcast lock address type", "hazelcast.lockaddr.type", FT_UINT8, BASE_DEC, NULL, 0x0, "lockAddrType", HFILL }
+        },
+        { &hf_hazelcast_lockAddrHost,
+          { "hazelcast lock address host", "hazelcast.lockaddr.host", FT_STRING, BASE_NONE, NULL, 0x0, "lockAddrHost", HFILL }
         },
         { &hf_hazelcast_lockAddrPort,
-          { "hazelcast lock address Port", "hazelcast.lockaddr.port", FT_UINT32, BASE_DEC, NULL, 0x0, "lockAddrPort", HFILL }
+          { "hazelcast lock address port", "hazelcast.lockaddr.port", FT_UINT32, BASE_DEC, NULL, 0x0, "lockAddrPort", HFILL }
+        },
+        { &hf_hazelcast_lockAddrLength,
+          { "hazelcast lock address length", "hazelcast.lockaddr.length", FT_UINT32, BASE_DEC, NULL, 0x0, "lockAddrLenght", HFILL }
         },
         { &hf_hazelcast_callID,
           { "hazelcast callID", "hazelcast.callID", FT_INT64, BASE_DEC, NULL, 0x0, "callID", HFILL }

Awesome! That made my day thank you!
I was using hz 2.4
I know it's a rather old patch but would you consider contributing it upstream?
It applied nicely on wireshark 2.4.6 and will probably be useful to others