/* packet-openwire.c

 * Routines for ActiveMQ OpenWire protocol

 *

 * metatech <metatechbe@gmail.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

/*

    OpenWire has two wire formats :

    - "loose" : more verbose, less CPU-intensive, less network-intensive (1-pass)

    - "tight" : more compact, more CPU-intensive, more network-intensive (2-pass)

    This dissector only supports the "loose" syntax, which is not the default.

    This dissector only supports version 6 of the protocol.

    It can be changed on the broker in the activemq.xml file by specifying "tightEncodingEnabled=false" :

    <transportConnectors>

        <transportConnector name="tcp-connector" uri="tcp://0.0.0.0:61616?wireFormat.tightEncodingEnabled=false&amp;wireFormat.cacheEnabled=false"/>

    </transportConnectors>

    Note : The WIREFORMAT_INFO command is always sent in "loose" format.

*/

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/prefs.h>

#include <epan/expert.h>

#include "packet-tcp.h"

void proto_register_openwire(void);

void proto_reg_handoff_openwire(void);

static int proto_openwire;

static int hf_openwire_none;

static int hf_openwire_length;

static int hf_openwire_command;

static int hf_openwire_command_id;

static int hf_openwire_command_response_required;

static int hf_openwire_response_correlationid;

static int hf_openwire_dataresponse_data;

static int hf_openwire_exceptionresponse_exception;

static int hf_openwire_connectionerror_exception;

static int hf_openwire_connectionerror_connectionid;

static int hf_openwire_controlcommand_command;

static int hf_openwire_wireformatinfo_magic;

static int hf_openwire_wireformatinfo_version;

static int hf_openwire_wireformatinfo_data;

static int hf_openwire_wireformatinfo_length;

static int hf_openwire_sessioninfo_sessionid;

static int hf_openwire_connectioninfo_connectionid;

static int hf_openwire_connectioninfo_clientid;

static int hf_openwire_connectioninfo_password;

static int hf_openwire_connectioninfo_username;

static int hf_openwire_connectioninfo_brokerpath;

static int hf_openwire_connectioninfo_brokermasterconnector;

static int hf_openwire_connectioninfo_manageable;

static int hf_openwire_connectioninfo_clientmaster;

static int hf_openwire_connectioninfo_faulttolerant;

static int hf_openwire_connectioninfo_failoverreconnect;

static int hf_openwire_destinationinfo_connectionid;

static int hf_openwire_destinationinfo_destination;

static int hf_openwire_destinationinfo_operationtype;

static int hf_openwire_destinationinfo_timeout;

static int hf_openwire_destinationinfo_brokerpath;

static int hf_openwire_brokerinfo_brokerid;

static int hf_openwire_brokerinfo_brokerurl;

static int hf_openwire_brokerinfo_peerbrokerinfos;

static int hf_openwire_brokerinfo_brokername;

static int hf_openwire_brokerinfo_slavebroker;

static int hf_openwire_brokerinfo_masterbroker;

static int hf_openwire_brokerinfo_faulttolerantconfiguration;

static int hf_openwire_brokerinfo_duplexconnection;

static int hf_openwire_brokerinfo_networkconnection;

static int hf_openwire_brokerinfo_connectionid;

static int hf_openwire_brokerinfo_brokeruploadurl;

static int hf_openwire_brokerinfo_networkproperties;

static int hf_openwire_connectioncontrol_close;

static int hf_openwire_connectioncontrol_exit;

static int hf_openwire_connectioncontrol_faulttolerant;

static int hf_openwire_connectioncontrol_resume;

static int hf_openwire_connectioncontrol_suspend;

static int hf_openwire_connectioncontrol_connectedbrokers;

static int hf_openwire_connectioncontrol_reconnectto;

static int hf_openwire_connectioncontrol_rebalanceconnection;

static int hf_openwire_consumercontrol_destination;

static int hf_openwire_consumercontrol_close;

static int hf_openwire_consumercontrol_consumerid;

static int hf_openwire_consumercontrol_prefetch;

static int hf_openwire_consumercontrol_flush;

static int hf_openwire_consumercontrol_start;

static int hf_openwire_consumercontrol_stop;

static int hf_openwire_consumerinfo_consumerid;

static int hf_openwire_consumerinfo_browser;

static int hf_openwire_consumerinfo_destination;

static int hf_openwire_consumerinfo_prefetchsize;

static int hf_openwire_consumerinfo_maximumpendingmessagelimit;

static int hf_openwire_consumerinfo_dispatchasync;

static int hf_openwire_consumerinfo_selector;

static int hf_openwire_consumerinfo_subscriptionname;

static int hf_openwire_consumerinfo_nolocal;

static int hf_openwire_consumerinfo_exclusive;

static int hf_openwire_consumerinfo_retroactive;

static int hf_openwire_consumerinfo_priority;

static int hf_openwire_consumerinfo_brokerpath;

static int hf_openwire_consumerinfo_additionalpredicate;

static int hf_openwire_consumerinfo_networksubscription;

static int hf_openwire_consumerinfo_optimizedacknowledge;

static int hf_openwire_consumerinfo_norangeacks;

static int hf_openwire_consumerinfo_networkconsumerpath;

static int hf_openwire_producerinfo_producerid;

static int hf_openwire_producerinfo_destination;

static int hf_openwire_producerinfo_brokerpath;

static int hf_openwire_producerinfo_dispatchasync;

static int hf_openwire_producerinfo_windowsize;

static int hf_openwire_removeinfo_objectid;

static int hf_openwire_removeinfo_lastdeliveredsequenceid;

static int hf_openwire_removesubscriptioninfo_connectionid;

static int hf_openwire_removesubscriptioninfo_subscriptionname;

static int hf_openwire_removesubscriptioninfo_clientid;

static int hf_openwire_transactioninfo_connectionid;

static int hf_openwire_transactioninfo_transactionid;

static int hf_openwire_transactioninfo_type;

static int hf_openwire_producerack_producerid;

static int hf_openwire_producerack_size;

static int hf_openwire_messagedispatch_consumerid;

static int hf_openwire_messagedispatch_destination;

static int hf_openwire_messagedispatch_message;

static int hf_openwire_messagedispatch_redeliverycounter;

static int hf_openwire_messageack_destination;

static int hf_openwire_messageack_transactionid;

static int hf_openwire_messageack_consumerid;

static int hf_openwire_messageack_acktype;

static int hf_openwire_messageack_firstmessageid;

static int hf_openwire_messageack_lastmessageid;

static int hf_openwire_messageack_messagecount;

static int hf_openwire_messagepull_consumerid;

static int hf_openwire_messagepull_destinationid;

static int hf_openwire_messagepull_timeout;

static int hf_openwire_messagepull_correlationid;

static int hf_openwire_messagepull_messageid;

static int hf_openwire_message_producerid;

static int hf_openwire_message_destination;

static int hf_openwire_message_transactionid;

static int hf_openwire_message_originaldestination;

static int hf_openwire_message_messageid;

static int hf_openwire_message_originaldestinationid;

static int hf_openwire_message_groupid;

static int hf_openwire_message_groupsequence;

static int hf_openwire_message_correlationid;

static int hf_openwire_message_persistent;

static int hf_openwire_message_expiration;

static int hf_openwire_message_priority;

static int hf_openwire_message_replyto;

static int hf_openwire_message_timestamp;

static int hf_openwire_message_type;

static int hf_openwire_message_body;

static int hf_openwire_message_properties;

static int hf_openwire_message_datastructure;

static int hf_openwire_message_targetconsumerid;

static int hf_openwire_message_compressed;

static int hf_openwire_message_redeliverycount;

static int hf_openwire_message_brokerpath;

static int hf_openwire_message_arrival;

static int hf_openwire_message_userid;

static int hf_openwire_message_receivedbydfbridge;

static int hf_openwire_message_droppable;

static int hf_openwire_message_cluster;

static int hf_openwire_message_brokerintime;

static int hf_openwire_message_brokerouttime;

static int hf_openwire_producerid_connectionid;

static int hf_openwire_producerid_value;

static int hf_openwire_producerid_sessionid;

static int hf_openwire_consumerid_connectionid;

static int hf_openwire_consumerid_value;

static int hf_openwire_consumerid_sessionid;

static int hf_openwire_destination_name;

static int hf_openwire_messageid_producerid;

static int hf_openwire_messageid_producersequenceid;

static int hf_openwire_messageid_brokersequenceid;

static int hf_openwire_connectionid_value;

static int hf_openwire_sessionid_connectionid;

static int hf_openwire_sessionid_value;

static int hf_openwire_brokerid_value;

static int hf_openwire_localtransactionid_value;

static int hf_openwire_localtransactionid_connectionid;

static int hf_openwire_xatransactionid_formatid;

static int hf_openwire_xatransactionid_globaltransactionid;

static int hf_openwire_xatransactionid_branchqualifier;

static int hf_openwire_map_length;

static int hf_openwire_map_key;

static int hf_openwire_map_entry;

static int hf_openwire_throwable_class;

static int hf_openwire_throwable_message;

static int hf_openwire_throwable_element;

static int hf_openwire_throwable_classname;

static int hf_openwire_throwable_methodname;

static int hf_openwire_throwable_filename;

static int hf_openwire_throwable_linenumber;

static int hf_openwire_type_integer;

static int hf_openwire_type_short;

static int hf_openwire_type_string;

static int hf_openwire_type_bytes;

static int hf_openwire_type_boolean;

static int hf_openwire_type_byte;

static int hf_openwire_type_char;

static int hf_openwire_type_notnull;

static int hf_openwire_type_long;

static int hf_openwire_type_float;

static int hf_openwire_type_double;

static int hf_openwire_type_object;

static int hf_openwire_type;

static int hf_openwire_cached_inlined;

static int hf_openwire_cached_id;

static int hf_openwire_cached_enabled;

static int ett_openwire;

static int ett_openwire_type;

static expert_field ei_openwire_tight_encoding_not_supported;

static expert_field ei_openwire_encoding_not_supported;

static expert_field ei_openwire_type_not_supported;

static expert_field ei_openwire_command_not_supported;

static expert_field ei_openwire_body_type_not_supported;

static dissector_handle_t openwire_tcp_handle;

static bool openwire_desegment = true;

static bool openwire_verbose_type;

#define OPENWIRE_PORT_TCP    61616

#define OPENWIRE_MAGIC_PART_1    0x41637469 /* "Acti" */

#define OPENWIRE_MAGIC_PART_2    0x76654D51 /* "veMQ" */

#define OPENWIRE_WIREFORMAT_INFO                 1

#define OPENWIRE_BROKER_INFO                     2

#define OPENWIRE_CONNECTION_INFO                 3

#define OPENWIRE_SESSION_INFO                    4

#define OPENWIRE_CONSUMER_INFO                   5

#define OPENWIRE_PRODUCER_INFO                   6

#define OPENWIRE_TRANSACTION_INFO                7

#define OPENWIRE_DESTINATION_INFO                8

#define OPENWIRE_REMOVE_SUBSCRIPTION_INFO        9

#define OPENWIRE_KEEP_ALIVE_INFO                10

#define OPENWIRE_SHUTDOWN_INFO                  11

#define OPENWIRE_REMOVE_INFO                    12

#define OPENWIRE_CONTROL_COMMAND                14

#define OPENWIRE_FLUSH_COMMAND                  15

#define OPENWIRE_CONNECTION_ERROR               16

#define OPENWIRE_CONSUMER_CONTROL               17

#define OPENWIRE_CONNECTION_CONTROL             18

#define OPENWIRE_PRODUCER_ACK                   19

#define OPENWIRE_MESSAGE_PULL                   20

#define OPENWIRE_MESSAGE_DISPATCH               21

#define OPENWIRE_MESSAGE_ACK                    22

#define OPENWIRE_ACTIVEMQ_MESSAGE               23

#define OPENWIRE_ACTIVEMQ_BYTES_MESSAGE         24

#define OPENWIRE_ACTIVEMQ_MAP_MESSAGE           25

#define OPENWIRE_ACTIVEMQ_OBJECT_MESSAGE        26

#define OPENWIRE_ACTIVEMQ_STREAM_MESSAGE        27

#define OPENWIRE_ACTIVEMQ_TEXT_MESSAGE          28

#define OPENWIRE_ACTIVEMQ_BLOB_MESSAGE          29

#define OPENWIRE_RESPONSE                       30

#define OPENWIRE_EXCEPTION_RESPONSE             31

#define OPENWIRE_DATA_RESPONSE                  32

#define OPENWIRE_DATA_ARRAY_RESPONSE            33

#define OPENWIRE_INTEGER_RESPONSE               34

#define OPENWIRE_DISCOVERY_EVENT                40

#define OPENWIRE_JOURNAL_ACK                    50

#define OPENWIRE_JOURNAL_REMOVE                 52

#define OPENWIRE_JOURNAL_TRACE                  53

#define OPENWIRE_JOURNAL_TRANSACTION            54

#define OPENWIRE_DURABLE_SUBSCRIPTION_INFO      55

#define OPENWIRE_PARTIAL_COMMAND                60

#define OPENWIRE_PARTIAL_LAST_COMMAND           61

#define OPENWIRE_REPLAY                         65

#define OPENWIRE_BYTE_TYPE                      70

#define OPENWIRE_CHAR_TYPE                      71

#define OPENWIRE_SHORT_TYPE                     72

#define OPENWIRE_INTEGER_TYPE                   73

#define OPENWIRE_LONG_TYPE                      74

#define OPENWIRE_DOUBLE_TYPE                    75

#define OPENWIRE_FLOAT_TYPE                     76

#define OPENWIRE_STRING_TYPE                    77

#define OPENWIRE_BOOLEAN_TYPE                   78

#define OPENWIRE_BYTE_ARRAY_TYPE                79

#define OPENWIRE_MESSAGE_DISPATCH_NOTIFICATION  90

#define OPENWIRE_NETWORK_BRIDGE_FILTER          91

#define OPENWIRE_ACTIVEMQ_QUEUE                100

#define OPENWIRE_ACTIVEMQ_TOPIC                101

#define OPENWIRE_ACTIVEMQ_TEMP_QUEUE           102

#define OPENWIRE_ACTIVEMQ_TEMP_TOPIC           103

#define OPENWIRE_MESSAGE_ID                    110

#define OPENWIRE_ACTIVEMQ_LOCAL_TRANSACTION_ID 111

#define OPENWIRE_ACTIVEMQ_XA_TRANSACTION_ID    112

#define OPENWIRE_CONNECTION_ID                 120

#define OPENWIRE_SESSION_ID                    121

#define OPENWIRE_CONSUMER_ID                   122

#define OPENWIRE_PRODUCER_ID                   123

#define OPENWIRE_BROKER_ID                     124

static const value_string openwire_opcode_vals[] = {

    { OPENWIRE_WIREFORMAT_INFO,               "WireFormatInfo" },

    { OPENWIRE_BROKER_INFO,                   "BrokerInfo" },

    { OPENWIRE_CONNECTION_INFO,               "ConnectionInfo" },

    { OPENWIRE_SESSION_INFO,                  "SessionInfo" },

    { OPENWIRE_CONSUMER_INFO,                 "ConsumerInfo" },

    { OPENWIRE_PRODUCER_INFO,                 "ProducerInfo" },

    { OPENWIRE_TRANSACTION_INFO,              "TransactionInfo" },

    { OPENWIRE_DESTINATION_INFO,              "DestinationInfo" },

    { OPENWIRE_REMOVE_SUBSCRIPTION_INFO,      "RemoveSubscriptionInfo" },

    { OPENWIRE_KEEP_ALIVE_INFO,               "KeepAliveInfo" },

    { OPENWIRE_SHUTDOWN_INFO,                 "ShutdownInfo" },

    { OPENWIRE_REMOVE_INFO,                   "RemoveInfo" },

    { OPENWIRE_CONTROL_COMMAND,               "ControlCommand" },

    { OPENWIRE_FLUSH_COMMAND,                 "FlushCommand" },

    { OPENWIRE_CONNECTION_ERROR,              "ConnectionError" },

    { OPENWIRE_CONSUMER_CONTROL,              "ConsumerControl" },

    { OPENWIRE_CONNECTION_CONTROL,            "ConnectionControl" },

    { OPENWIRE_PRODUCER_ACK,                  "ProducerAck" },

    { OPENWIRE_MESSAGE_PULL,                  "MessagePull" },

    { OPENWIRE_MESSAGE_DISPATCH,              "MessageDispatch" },

    { OPENWIRE_MESSAGE_ACK,                   "MessageAck" },

    { OPENWIRE_ACTIVEMQ_MESSAGE,              "ActiveMQMessage" },

    { OPENWIRE_ACTIVEMQ_BYTES_MESSAGE,        "ActiveMQBytesMessage" },

    { OPENWIRE_ACTIVEMQ_MAP_MESSAGE,          "ActiveMQMapMessage" },

    { OPENWIRE_ACTIVEMQ_OBJECT_MESSAGE,       "ActiveMQObjectMessage" },

    { OPENWIRE_ACTIVEMQ_STREAM_MESSAGE,       "ActiveMQStreamMessage" },

    { OPENWIRE_ACTIVEMQ_TEXT_MESSAGE,         "ActiveMQTextMessage" },

    { OPENWIRE_ACTIVEMQ_BLOB_MESSAGE,         "ActiveMQBlobMessage" },

    { OPENWIRE_RESPONSE,                      "Response" },

    { OPENWIRE_EXCEPTION_RESPONSE,            "ExceptionResponse" },

    { OPENWIRE_DATA_RESPONSE,                 "DataResponse" },

    { OPENWIRE_DATA_ARRAY_RESPONSE,           "DataArrayResponse" },

    { OPENWIRE_INTEGER_RESPONSE,              "IntegerResponse" },

    { OPENWIRE_DISCOVERY_EVENT,               "DiscoveryEvent" },

    { OPENWIRE_JOURNAL_ACK,                   "JournalTopicAck" },

    { OPENWIRE_JOURNAL_REMOVE,                "JournalQueueAck" },

    { OPENWIRE_JOURNAL_TRACE,                 "JournalTrace" },

    { OPENWIRE_JOURNAL_TRANSACTION,           "JournalTransaction" },

    { OPENWIRE_DURABLE_SUBSCRIPTION_INFO,     "SubscriptionInfo" },

    { OPENWIRE_PARTIAL_COMMAND,               "PartialCommand" },

    { OPENWIRE_PARTIAL_LAST_COMMAND,          "LastPartialCommand" },

    { OPENWIRE_REPLAY,                        "ReplayCommand" },

    { OPENWIRE_BYTE_TYPE,                     "Byte" },

    { OPENWIRE_CHAR_TYPE,                     "Char" },

    { OPENWIRE_SHORT_TYPE,                    "Short" },

    { OPENWIRE_INTEGER_TYPE,                  "Integer" },

    { OPENWIRE_LONG_TYPE,                     "Long" },

    { OPENWIRE_DOUBLE_TYPE,                   "Double" },

    { OPENWIRE_FLOAT_TYPE,                    "Float" },

    { OPENWIRE_STRING_TYPE,                   "String" },

    { OPENWIRE_BOOLEAN_TYPE,                  "Boolean" },

    { OPENWIRE_BYTE_ARRAY_TYPE,               "ByteArray" },

    { OPENWIRE_MESSAGE_DISPATCH_NOTIFICATION, "MessageDispatchNotification" },

    { OPENWIRE_NETWORK_BRIDGE_FILTER,         "NetworkBridgeFilter" },

    { OPENWIRE_ACTIVEMQ_QUEUE,                "ActiveMQQueue" },

    { OPENWIRE_ACTIVEMQ_TOPIC,                "ActiveMQTopic" },

    { OPENWIRE_ACTIVEMQ_TEMP_QUEUE,           "ActiveMQTempQueue" },

    { OPENWIRE_ACTIVEMQ_TEMP_TOPIC,           "ActiveMQTempTopic" },

    { OPENWIRE_MESSAGE_ID,                    "MessageId" },

    { OPENWIRE_ACTIVEMQ_LOCAL_TRANSACTION_ID, "LocalTransactionId" },

    { OPENWIRE_ACTIVEMQ_XA_TRANSACTION_ID,    "XATransactionId" },

    { OPENWIRE_CONNECTION_ID,                 "ConnectionId" },

    { OPENWIRE_SESSION_ID,                    "SessionId" },

    { OPENWIRE_CONSUMER_ID,                   "ConsumerId" },

    { OPENWIRE_PRODUCER_ID,                   "ProducerId" },

    { OPENWIRE_BROKER_ID,                     "BrokerId" },

    { 0,          NULL }

};

static value_string_ext openwire_opcode_vals_ext = VALUE_STRING_EXT_INIT(openwire_opcode_vals);

#define OPENWIRE_COMMAND_INNER        -5

#define OPENWIRE_TYPE_OBJECT_ARRAY    -4

#define OPENWIRE_TYPE_CACHED          -3

#define OPENWIRE_TYPE_NESTED          -2

#define OPENWIRE_TYPE_THROWABLE       -1

#define OPENWIRE_TYPE_NULL             0

#define OPENWIRE_TYPE_BOOLEAN          1

#define OPENWIRE_TYPE_BYTE             2

#define OPENWIRE_TYPE_CHAR             3

#define OPENWIRE_TYPE_SHORT            4

#define OPENWIRE_TYPE_INTEGER          5

#define OPENWIRE_TYPE_LONG             6

#define OPENWIRE_TYPE_DOUBLE           7

#define OPENWIRE_TYPE_FLOAT            8

#define OPENWIRE_TYPE_STRING           9

#define OPENWIRE_TYPE_BYTE_ARRAY      10

#define OPENWIRE_TYPE_MAP             11

#define OPENWIRE_TYPE_LIST            12

#define OPENWIRE_TYPE_BIG_STRING      13

static const value_string openwire_type_vals[] = {

    { OPENWIRE_TYPE_NULL,                      "Null" },

    { OPENWIRE_TYPE_BOOLEAN,                   "Boolean" },

    { OPENWIRE_TYPE_BYTE,                      "Byte" },

    { OPENWIRE_TYPE_CHAR,                      "Char" },

    { OPENWIRE_TYPE_SHORT,                     "Short" },

    { OPENWIRE_TYPE_INTEGER,                   "Integer" },

    { OPENWIRE_TYPE_LONG,                      "Long" },

    { OPENWIRE_TYPE_DOUBLE,                    "Double" },

    { OPENWIRE_TYPE_FLOAT,                     "Float" },

    { OPENWIRE_TYPE_STRING,                    "String" },

    { OPENWIRE_TYPE_BYTE_ARRAY,                "ByteArray" },

    { OPENWIRE_TYPE_MAP,                       "Map" },

    { OPENWIRE_TYPE_LIST,                      "List" },

    { OPENWIRE_TYPE_BIG_STRING,                "BigString" },

    { OPENWIRE_ACTIVEMQ_MESSAGE,               "ActiveMQMessage" },

    { OPENWIRE_ACTIVEMQ_BYTES_MESSAGE,         "ActiveMQBytesMessage" },

    { OPENWIRE_ACTIVEMQ_MAP_MESSAGE,           "ActiveMQMapMessage" },

    { OPENWIRE_ACTIVEMQ_OBJECT_MESSAGE,        "ActiveMQObjectMessage" },

    { OPENWIRE_ACTIVEMQ_STREAM_MESSAGE,        "ActiveMQStreamMessage" },

    { OPENWIRE_ACTIVEMQ_TEXT_MESSAGE,          "ActiveMQTextMessage" },

    { OPENWIRE_ACTIVEMQ_BLOB_MESSAGE,          "ActiveMQBlobMessage" },

    { OPENWIRE_ACTIVEMQ_QUEUE,                 "ActiveMQQueue" },

    { OPENWIRE_ACTIVEMQ_TOPIC,                 "ActiveMQTopic" },

    { OPENWIRE_ACTIVEMQ_TEMP_QUEUE,            "ActiveMQTempQueue" },

    { OPENWIRE_ACTIVEMQ_TEMP_TOPIC,            "ActiveMQTempTopic" },

    { OPENWIRE_MESSAGE_ID,                     "MessageId" },

    { OPENWIRE_ACTIVEMQ_LOCAL_TRANSACTION_ID,  "LocalTransactionId" },

    { OPENWIRE_ACTIVEMQ_XA_TRANSACTION_ID,     "XATransactionId" },

    { OPENWIRE_CONNECTION_ID,                  "ConnectionId" },

    { OPENWIRE_SESSION_ID,                     "SessionId" },

    { OPENWIRE_CONSUMER_ID,                    "ConsumerId" },

    { OPENWIRE_PRODUCER_ID,                    "ProducerId" },

    { OPENWIRE_BROKER_ID,                      "BrokerId" },

    { OPENWIRE_TYPE_OBJECT_ARRAY,              "ObjectArray" },

    { OPENWIRE_TYPE_THROWABLE,                 "Throwable" },

    { 0,                                        NULL }

};

static value_string_ext openwire_type_vals_ext = VALUE_STRING_EXT_INIT(openwire_type_vals);

#define OPENWIRE_TRANSACTIONTYPE_BEGIN              0

#define OPENWIRE_TRANSACTIONTYPE_PREPARE            1

#define OPENWIRE_TRANSACTIONTYPE_COMMIT_ONE_PHASE   2

#define OPENWIRE_TRANSACTIONTYPE_COMMIT_TWO_PHASE   3

#define OPENWIRE_TRANSACTIONTYPE_ROLLBACK           4

#define OPENWIRE_TRANSACTIONTYPE_RECOVER            5

#define OPENWIRE_TRANSACTIONTYPE_FORGET             6

#define OPENWIRE_TRANSACTIONTYPE_END                7

static const value_string openwire_transaction_type_vals[] = {

    { OPENWIRE_TRANSACTIONTYPE_BEGIN,                "Begin" },

    { OPENWIRE_TRANSACTIONTYPE_PREPARE,              "Prepare" },

    { OPENWIRE_TRANSACTIONTYPE_COMMIT_ONE_PHASE,     "CommitOnePhase" },

    { OPENWIRE_TRANSACTIONTYPE_COMMIT_TWO_PHASE,     "CommitTwoPhase" },

    { OPENWIRE_TRANSACTIONTYPE_ROLLBACK,             "Rollback" },

    { OPENWIRE_TRANSACTIONTYPE_RECOVER,              "Recover" },

    { OPENWIRE_TRANSACTIONTYPE_FORGET,               "Forget" },

    { OPENWIRE_TRANSACTIONTYPE_END,                  "End" },

    { 0,                                             NULL }

};

static value_string_ext openwire_transaction_type_vals_ext = VALUE_STRING_EXT_INIT(openwire_transaction_type_vals);

#define OPENWIRE_MESSAGE_ACK_TYPE_DELIVERED       0

#define OPENWIRE_MESSAGE_ACK_TYPE_POISON          1

#define OPENWIRE_MESSAGE_ACK_TYPE_STANDARD        2

#define OPENWIRE_MESSAGE_ACK_TYPE_REDELIVERED     3

#define OPENWIRE_MESSAGE_ACK_TYPE_INDIVIDUAL      4

#define OPENWIRE_MESSAGE_ACK_TYPE_UNMATCHED       5

static const value_string openwire_message_ack_type_vals[] = {

    { OPENWIRE_MESSAGE_ACK_TYPE_DELIVERED,         "Delivered" },

    { OPENWIRE_MESSAGE_ACK_TYPE_POISON,            "Poison" },

    { OPENWIRE_MESSAGE_ACK_TYPE_STANDARD,          "Standard" },

    { OPENWIRE_MESSAGE_ACK_TYPE_REDELIVERED,       "Redelivered" },

    { OPENWIRE_MESSAGE_ACK_TYPE_INDIVIDUAL,        "Individual" },

    { OPENWIRE_MESSAGE_ACK_TYPE_UNMATCHED,         "Unmatched" },

    { 0,                                           NULL }

};

#define OPENWIRE_OPERATION_TYPE_ADD       0

#define OPENWIRE_OPERATION_TYPE_REMOVE    1

static const value_string openwire_operation_type_vals[] = {

    { OPENWIRE_OPERATION_TYPE_ADD,          "Add" },

    { OPENWIRE_OPERATION_TYPE_REMOVE,       "Remove" },

    { 0,                                    NULL }

};

typedef struct openwire_conv_data {

    bool caching;

    bool tight;

} openwire_conv_data;

static void

validate_boolean(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree _U_, int offset, proto_item *boolean_item)

{

    /* Sanity check of boolean : must be 0x00 or 0x01 */

    uint8_t booleanByte;

    booleanByte = tvb_get_uint8(tvb, offset);

    if (booleanByte != false && booleanByte != true)

    {

        expert_add_info(pinfo, boolean_item, &ei_openwire_encoding_not_supported);

    }

}

static int

particularize(int specificField, int genericField)

{

    return (specificField == hf_openwire_none ? genericField : specificField);

}

static void

detect_protocol_options(tvbuff_t *tvb, packet_info *pinfo, int offset, int iCommand)

{

    /* This function is level-2 heuristic to detect the protocol options, after the level-1 heuristic to detect the protocol.

       The WireFormatInfo structure reliably declares whether tight encoding and/or caching are used.

       However, only the response must be used, which is the result of the "negotiation" handshake with the server.

       However, if the capture is started after the connection initial handshake, it must be deduced in a heuristic way.

       For the sake of generality, we do not consider the handshake, but only the heuristic way.

    */

    if (tvb_captured_length_remaining(tvb, offset) >= 12)

    {

        /* Only check commands which start with a "OPENWIRE_TYPE_CACHED" object */

        if (iCommand == OPENWIRE_SESSION_INFO

            || iCommand == OPENWIRE_DESTINATION_INFO

            || iCommand == OPENWIRE_CONNECTION_INFO

            || iCommand == OPENWIRE_CONSUMER_INFO

            || iCommand == OPENWIRE_PRODUCER_INFO

            || iCommand == OPENWIRE_BROKER_INFO

            || iCommand == OPENWIRE_TRANSACTION_INFO

            || iCommand == OPENWIRE_REMOVE_SUBSCRIPTION_INFO

            || iCommand == OPENWIRE_MESSAGE_DISPATCH

            || iCommand == OPENWIRE_MESSAGE_ACK

            || iCommand == OPENWIRE_MESSAGE_PULL)

        {

            conversation_t *conv = NULL;

            openwire_conv_data *cd = NULL;

            conv = find_or_create_conversation(pinfo);

            cd = (openwire_conv_data*)conversation_get_proto_data(conv, proto_openwire);

            if (!cd)

            {

                uint8_t present, type;

                int command_id = 0;

                present = tvb_get_uint8(tvb, offset + 10);

                type = tvb_get_uint8(tvb, offset + 11);

                command_id = tvb_get_ntohl(tvb, offset + 5);

                cd = wmem_new(wmem_file_scope(), openwire_conv_data);

                cd->caching = false;

                cd->tight = false;

                if (command_id > (1 << 24))

                {

                    /* If "tight" encoding is enabled, the command_id first byte is non-zero.

                       This can be misdetected with "loose" encoding if the capture is started after 16 millions commands on the connection,

                       which we will assume that it happens very rarely.  */

                    cd->tight = true;

                }

                else

                {

                    if (present == true && type == OPENWIRE_TYPE_NULL)

                    {

                        /* If a cached object is not-null, it should be the "NULL" object.

                           This can be misdetected with "loose" encoding if the capture is started after 256 cached objects on the connection,

                           which we will assume that it happens rarely.  */

                        cd->caching = true;

                    }

                }

                conversation_add_proto_data(conv, proto_openwire, cd);

            }

        }

    }

    else if ((tvb_get_uint8(tvb, 4) == OPENWIRE_KEEP_ALIVE_INFO)

            && (tvb_captured_length(tvb) == 11))

    {

        /* If the capture is started after a long-lived connection is started,

           a keep-alive command of 11 bytes detects tight encoding (not caching stays unknown).

        */

        conversation_t *conv = NULL;

        openwire_conv_data *cd = NULL;

        conv = find_or_create_conversation(pinfo);

        cd = (openwire_conv_data*)conversation_get_proto_data(conv, proto_openwire);

        if (!cd)

        {

            cd = wmem_new(wmem_file_scope(), openwire_conv_data);

            cd->tight = true;

            cd->caching = false; /* Dummy value */

            conversation_add_proto_data(conv, proto_openwire, cd);

        }

    }

}

static bool

retrieve_caching(packet_info *pinfo)

{

    conversation_t     *conv;

    openwire_conv_data *cd;

    conv = find_or_create_conversation(pinfo);

    cd = (openwire_conv_data*)conversation_get_proto_data(conv, proto_openwire);

    if (cd) return cd->caching;

    /* Default : non-caching is recommended */

    return false;

}

static bool

retrieve_tight(packet_info *pinfo)

{

    conversation_t     *conv;

    openwire_conv_data *cd;

    conv = find_or_create_conversation(pinfo);

    cd = (openwire_conv_data*)conversation_get_proto_data(conv, proto_openwire);

    if (cd && cd->tight) return true;

    return false;

}

static int

dissect_openwire_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, int parentType);

static unsigned

// NOLINTNEXTLINE(misc-no-recursion)

dissect_openwire_type(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset, int field, int type, int parentType, bool nullable)

{

    unsigned    startOffset  = offset;

    proto_item *boolean_item = NULL;

    const char *cache_str = "";

    if (type == OPENWIRE_TYPE_CACHED && retrieve_caching(pinfo) == true && tvb_reported_length_remaining(tvb, offset) >= 3)

    {

        uint8_t inlined = 0;

        int cachedID = 0;

        proto_item * cached_item = NULL;

        inlined = tvb_get_uint8(tvb, offset + 0) == true ? true : false;

        cachedID = tvb_get_ntohs(tvb, offset + 1);

        cache_str = wmem_strdup_printf(pinfo->pool, " (CachedID: %d)", cachedID);

        if (openwire_verbose_type)

        {

            proto_tree_add_item(tree, hf_openwire_cached_inlined, tvb, offset, 1, ENC_BIG_ENDIAN);

        }

        cached_item  = proto_tree_add_item(tree, hf_openwire_cached_id, tvb, offset + 1, 2, ENC_BIG_ENDIAN);

        if (!openwire_verbose_type)

        {

            /* Hide it but allow it in search filters */

            proto_item_set_hidden(cached_item);

        }

        if (inlined == false)

        {

            proto_item    *ti;

            ti = proto_tree_add_item(tree, particularize(field, hf_openwire_type_object), tvb, startOffset, 3, ENC_NA);

            proto_item_append_text(ti, "%s", cache_str);

            return 3;

        }

        else

        {

            offset += 3;

        }

    }

    if (nullable == true && (type == OPENWIRE_TYPE_NESTED || type == OPENWIRE_TYPE_CACHED || type == OPENWIRE_COMMAND_INNER) && tvb_reported_length_remaining(tvb, offset) >= 1)

    {

        nullable = tvb_get_uint8(tvb, offset + 0) == false ? true : false;

        if (openwire_verbose_type)

        {

            boolean_item = proto_tree_add_item(tree, hf_openwire_type_notnull, tvb, offset, 1, ENC_BIG_ENDIAN);

        }

        validate_boolean(tvb, pinfo, tree, offset, boolean_item);

        if (nullable == true)

        {

            proto_tree_add_item(tree, particularize(field, hf_openwire_none), tvb, offset, 1, ENC_NA);

            return offset - startOffset + 1;

        }

        offset += 1;

    }

    if (type == OPENWIRE_COMMAND_INNER && tvb_reported_length_remaining(tvb, offset) >= 1)

    {

        proto_item * inner_item = NULL;

        proto_tree * object_tree = NULL;

        uint8_t iCommand = parentType;

        iCommand = tvb_get_uint8(tvb, offset + 0);

        inner_item = proto_tree_add_item(tree, particularize(field, hf_openwire_none), tvb, startOffset, -1, ENC_NA);

        proto_item_append_text(inner_item, ": %s", val_to_str_ext(pinfo->pool, iCommand, &openwire_opcode_vals_ext, "Unknown (0x%02x)"));

        object_tree = proto_item_add_subtree(inner_item, ett_openwire_type);

        increment_dissection_depth(pinfo);

        int command_offset = 1 + dissect_openwire_command(tvb, pinfo, object_tree, offset, parentType);

        decrement_dissection_depth(pinfo);

        return command_offset;

    }

    if ((type == OPENWIRE_TYPE_NESTED || type == OPENWIRE_TYPE_CACHED) && tvb_reported_length_remaining(tvb, offset) >= 1)

    {

        type = tvb_get_uint8(tvb, offset + 0);

        if (openwire_verbose_type)

        {

            proto_tree_add_item(tree, hf_openwire_type, tvb, offset, 1, ENC_BIG_ENDIAN);

        }

        offset += 1;

    }

    if (nullable == true && tvb_reported_length_remaining(tvb, offset) >= 1)

    {

        nullable = tvb_get_uint8(tvb, offset + 0) == false ? true : false;

        if (openwire_verbose_type)

        {

            boolean_item = proto_tree_add_item(tree, hf_openwire_type_notnull, tvb, offset, 1, ENC_BIG_ENDIAN);

        }

        validate_boolean(tvb, pinfo, tree, offset, boolean_item);

        if (nullable == true)

        {

            proto_tree_add_item(tree, particularize(field, hf_openwire_none), tvb, offset, 1, ENC_NA);

            return offset - startOffset + 1;

        }

        offset += 1;

    }

    /* First check for primitives types */

    if (type == OPENWIRE_TYPE_NULL)

    {

        offset += 0;

    }

    else if (type == OPENWIRE_TYPE_INTEGER && tvb_reported_length_remaining(tvb, offset) >= 4)

    {

        proto_tree_add_item(tree, particularize(field, hf_openwire_type_integer), tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

    }

    else if (type == OPENWIRE_TYPE_SHORT && tvb_reported_length_remaining(tvb, offset) >= 2)

    {

        proto_tree_add_item(tree, particularize(field, hf_openwire_type_short), tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

    }

    else if (type == OPENWIRE_TYPE_LONG && tvb_reported_length_remaining(tvb, offset) >= 8)

    {

        proto_tree_add_item(tree, particularize(field, hf_openwire_type_long), tvb, offset, 8, ENC_BIG_ENDIAN);

        offset += 8;

    }

    else if (type == OPENWIRE_TYPE_BOOLEAN && tvb_reported_length_remaining(tvb, offset) >= 1)

    {

        boolean_item = proto_tree_add_item(tree, particularize(field, hf_openwire_type_boolean), tvb, offset, 1, ENC_BIG_ENDIAN);

        validate_boolean(tvb, pinfo, tree, offset, boolean_item);

        offset += 1;

    }

    else if (type == OPENWIRE_TYPE_BYTE && tvb_reported_length_remaining(tvb, offset) >= 1)

    {

        proto_tree_add_item(tree, particularize(field, hf_openwire_type_byte), tvb, offset, 1, ENC_NA);

        offset += 1;

    }

    else if (type == OPENWIRE_TYPE_CHAR && tvb_reported_length_remaining(tvb, offset) >= 2)

    {

        proto_tree_add_item(tree, particularize(field, hf_openwire_type_char), tvb, offset, 2, ENC_NA);

        offset += 2;

    }

    else if (type == OPENWIRE_TYPE_FLOAT && tvb_reported_length_remaining(tvb, offset) >= 4)

    {

        proto_tree_add_item(tree, particularize(field, hf_openwire_type_float), tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

    }

    else if (type == OPENWIRE_TYPE_DOUBLE && tvb_reported_length_remaining(tvb, offset) >= 8)

    {

        proto_tree_add_item(tree, particularize(field, hf_openwire_type_double), tvb, offset, 8, ENC_BIG_ENDIAN);

        offset += 8;

    }

    else if (type == OPENWIRE_TYPE_STRING && tvb_reported_length_remaining(tvb, offset) >= 2)

    {

        unsigned iStringLength = 0;

        iStringLength = tvb_get_ntohs(tvb, offset);

        if (openwire_verbose_type)

        {

            proto_tree_add_item(tree, hf_openwire_type_short, tvb, offset, 2, ENC_BIG_ENDIAN);

        }

        offset += 2;

        if (tvb_reported_length_remaining(tvb, offset) >= iStringLength)

        {

            proto_tree_add_item(tree, particularize(field, hf_openwire_type_string), tvb, offset, iStringLength, ENC_NA);

            offset += iStringLength;

        }

    }

    else if (type == OPENWIRE_TYPE_BIG_STRING && tvb_reported_length_remaining(tvb, offset) >= 4)

    {

        unsigned iStringLength = 0;

        iStringLength = tvb_get_ntohl(tvb, offset);

        if (openwire_verbose_type)

        {

            proto_tree_add_item(tree, hf_openwire_type_integer, tvb, offset, 4, ENC_BIG_ENDIAN);

        }

        offset += 4;

        if (tvb_reported_length_remaining(tvb, offset) >= iStringLength)

        {

            proto_tree_add_item(tree, particularize(field, hf_openwire_type_string), tvb, offset, iStringLength, ENC_NA);

            offset += iStringLength;

        }

    }

    else if (type == OPENWIRE_TYPE_BYTE_ARRAY && tvb_reported_length_remaining(tvb, offset) >= 4)

    {

        unsigned iArrayLength = 0;

        iArrayLength = tvb_get_ntohl(tvb, offset);

        if (openwire_verbose_type)

        {

            proto_tree_add_item(tree, hf_openwire_type_integer, tvb, offset, 4, ENC_BIG_ENDIAN);

        }

        offset += 4;

        if (tvb_reported_length_remaining(tvb, offset) >= iArrayLength)

        {

            proto_item * array_item = NULL;

            proto_tree * object_tree = NULL;

            array_item = proto_tree_add_item(tree, particularize(field, hf_openwire_type_bytes), tvb, offset, iArrayLength, ENC_NA);

            object_tree = proto_item_add_subtree(array_item, ett_openwire_type);

            if (field == hf_openwire_message_body)

            {

                tvbuff_t* next_tvb = NULL;

                if (parentType == OPENWIRE_ACTIVEMQ_TEXT_MESSAGE)

                {

                    dissect_openwire_type(tvb, pinfo, object_tree, offset, hf_openwire_none, OPENWIRE_TYPE_BIG_STRING, type, false);

                    next_tvb = tvb_new_subset_length(tvb, offset, iArrayLength);

                    add_new_data_source(pinfo, next_tvb, "Body");

                }

                else if (parentType == OPENWIRE_ACTIVEMQ_MAP_MESSAGE)

                {

                    dissect_openwire_type(tvb, pinfo, object_tree, offset, hf_openwire_none, OPENWIRE_TYPE_MAP, type, false);

                }

                else if (parentType == OPENWIRE_ACTIVEMQ_STREAM_MESSAGE)

                {

                    next_tvb = tvb_new_subset_length(tvb, offset, iArrayLength);

                    unsigned streamOffset = 0;

                    while (tvb_reported_length_remaining(next_tvb, streamOffset))

                    {

                        streamOffset += dissect_openwire_type(next_tvb, pinfo, object_tree, streamOffset, hf_openwire_none, OPENWIRE_TYPE_NESTED, type, false);

                    }

                }

                else if (parentType == OPENWIRE_ACTIVEMQ_BYTES_MESSAGE

                    || parentType == OPENWIRE_ACTIVEMQ_OBJECT_MESSAGE

                    || parentType == OPENWIRE_ACTIVEMQ_BLOB_MESSAGE)

                {

                    next_tvb = tvb_new_subset_length(tvb, offset, iArrayLength);

                    add_new_data_source(pinfo, next_tvb, "Body");

                    expert_add_info(pinfo, array_item, &ei_openwire_body_type_not_supported);

                }

            }

            else if (field == hf_openwire_message_properties)

            {

                dissect_openwire_type(tvb, pinfo, object_tree, offset, hf_openwire_none, OPENWIRE_TYPE_MAP, type, false);

            }

            offset += iArrayLength;

        }

    }

    else if (tvb_reported_length_remaining(tvb, offset) >= 1)

    {

        /* Check for complex types */

        proto_tree    *object_tree;

        proto_item    *ti;

        ti = proto_tree_add_item(tree, particularize(field, hf_openwire_type_object), tvb, startOffset, -1, ENC_NA);

        proto_item_append_text(ti, ": %s", val_to_str_ext(pinfo->pool, type, &openwire_type_vals_ext, "Unknown (0x%02x)"));

        proto_item_append_text(ti, "%s", cache_str);

        object_tree = proto_item_add_subtree(ti, ett_openwire_type);

        if (type == OPENWIRE_TYPE_OBJECT_ARRAY && tvb_reported_length_remaining(tvb, offset) >= 2)

        {

            unsigned iArrayLength;

            iArrayLength = tvb_get_ntohs(tvb, offset);

            if (openwire_verbose_type)

            {

                proto_tree_add_item(object_tree, hf_openwire_type_short, tvb, offset + 0, 2, ENC_BIG_ENDIAN);

            }

            proto_item_append_text(ti, " (Size : %d)", iArrayLength);

            offset += 2;

            for (unsigned iArrayItem = 0; iArrayItem < iArrayLength; iArrayItem++)

            {

                offset += dissect_openwire_type(tvb, pinfo, object_tree, offset, hf_openwire_none, OPENWIRE_TYPE_NESTED, type, true);

            }

        }

        else if (type == OPENWIRE_TYPE_MAP && tvb_reported_length_remaining(tvb, offset) >= 4)

        {

            unsigned iMapLength = 0;

            iMapLength = tvb_get_ntohl(tvb, offset);

            if (openwire_verbose_type)

            {

                proto_tree_add_item(object_tree, hf_openwire_map_length, tvb, offset, 4, ENC_BIG_ENDIAN);

            }

            proto_item_append_text(ti, " (Size : %d)", iMapLength);

            offset += 4;

            for (unsigned iMapItem = 0; (iMapItem < iMapLength) && (tvb_reported_length_remaining(tvb, offset) > 0); iMapItem++)

            {

                proto_item * map_entry;

                proto_tree * entry_tree;

                int entryStartOffset = offset;

                map_entry = proto_tree_add_item(object_tree, hf_openwire_map_entry, tvb, offset, 0, ENC_NA);

                entry_tree = proto_item_add_subtree(map_entry, ett_openwire_type);

                /* Key */

                offset += dissect_openwire_type(tvb, pinfo, entry_tree, offset, hf_openwire_map_key, OPENWIRE_TYPE_STRING, type, false);

                /* Value */

                offset += dissect_openwire_type(tvb, pinfo, entry_tree, offset, hf_openwire_none, OPENWIRE_TYPE_NESTED, type, false);

                proto_item_set_len(map_entry, offset - entryStartOffset);

            }

        }

        else if (type == OPENWIRE_TYPE_THROWABLE && tvb_reported_length_remaining(tvb, offset) >= 2)

        {

            unsigned iStackTraceDepth;

            offset += dissect_openwire_type(tvb, pinfo, object_tree, offset, hf_openwire_throwable_class, OPENWIRE_TYPE_STRING, type, true);

            offset += dissect_openwire_type(tvb, pinfo, object_tree, offset, hf_openwire_throwable_message, OPENWIRE_TYPE_STRING, type, true);

            iStackTraceDepth = tvb_get_ntohs(tvb, offset);

            if (openwire_verbose_type)

            {

                proto_tree_add_item(tree, hf_openwire_type_short, tvb, offset, 2, ENC_BIG_ENDIAN);

            }

            offset += 2;

            if (iStackTraceDepth  > 0)

            {

                for (unsigned iStackTraceItem = 0; iStackTraceItem < iStackTraceDepth; iStackTraceItem++)

                {

                    proto_item    *element;