Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 836 insertions, 0 deletions

diff --git a/epan/dissectors/packet-lbttcp.c b/epan/dissectors/packet-lbttcp.c
new file mode 100644
index 00000000..41e4b9e7
--- /dev/null
+++ b/epan/dissectors/packet-lbttcp.c
@@ -0,0 +1,836 @@
+/* packet-lbttcp.c
+ * Routines for LBM TCP Packet dissection
+ *
+ * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved.
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "config.h"
+
+#include <epan/packet.h>
+#include <epan/prefs.h>
+#include <epan/uat.h>
+#include <epan/to_str.h>
+#include "packet-tcp.h"
+#include "packet-lbm.h"
+#include "packet-lbttcp.h"
+
+void proto_register_lbttcp(void);
+void proto_reg_handoff_lbttcp(void);
+
+/* Protocol handle */
+static int proto_lbttcp = -1;
+
+/* Dissector handle */
+static dissector_handle_t lbttcp_dissector_handle;
+
+/*----------------------------------------------------------------------------*/
+/* LBT-TCP protocol management.                                               */
+/*----------------------------------------------------------------------------*/
+
+typedef struct
+{
+    wmem_tree_t * frame_tree;
+    wmem_tree_t * session_tree;
+} lbttcp_transport_conv_data_t;
+
+static const address lbttcp_null_address = ADDRESS_INIT_NONE;
+
+lbttcp_transport_t * lbttcp_transport_find(const address * source_address, guint16 source_port, guint32 session_id, guint32 frame)
+{
+    lbttcp_transport_t * entry = NULL;
+    conversation_t * conv = NULL;
+    lbttcp_transport_conv_data_t * conv_data = NULL;
+
+    conv = find_conversation(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
+    if (conv != NULL)
+    {
+        conv_data = (lbttcp_transport_conv_data_t *) conversation_get_proto_data(conv, proto_lbttcp);
+        if (conv_data != NULL)
+        {
+            entry = (lbttcp_transport_t *) wmem_tree_lookup32(conv_data->session_tree, session_id);
+        }
+    }
+    return (entry);
+}
+
+static lbttcp_transport_t * lbttcp_transport_create(const address * source_address, guint16 source_port, guint32 session_id)
+{
+    lbttcp_transport_t * transport = NULL;
+
+    transport = wmem_new(wmem_file_scope(), lbttcp_transport_t);
+    copy_address_wmem(wmem_file_scope(), &(transport->source_address), source_address);
+    transport->source_port = source_port;
+    transport->session_id = session_id;
+    transport->channel = lbm_channel_assign(LBM_CHANNEL_TRANSPORT_LBTTCP);
+    transport->next_client_id = 1;
+    transport->client_list = wmem_list_new(wmem_file_scope());
+    return (transport);
+}
+
+lbttcp_transport_t * lbttcp_transport_add(const address * source_address, guint16 source_port, guint32 session_id, guint32 frame)
+{
+    lbttcp_transport_t * entry = NULL;
+    conversation_t * conv = NULL;
+    lbttcp_transport_conv_data_t * conv_data = NULL;
+
+    conv = find_conversation(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
+    if (conv == NULL)
+    {
+        conv = conversation_new(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
+    }
+    conv_data = (lbttcp_transport_conv_data_t *) conversation_get_proto_data(conv, proto_lbttcp);
+    if (conv_data == NULL)
+    {
+        conv_data = wmem_new(wmem_file_scope(), lbttcp_transport_conv_data_t);
+        conv_data->frame_tree = wmem_tree_new(wmem_file_scope());
+        conv_data->session_tree = wmem_tree_new(wmem_file_scope());
+        conversation_add_proto_data(conv, proto_lbttcp, (void *) conv_data);
+    }
+    entry = (lbttcp_transport_t *) wmem_tree_lookup32(conv_data->session_tree, session_id);
+    if (entry != NULL)
+    {
+        return (entry);
+    }
+    entry = lbttcp_transport_create(source_address, source_port, session_id);
+    wmem_tree_insert32(conv_data->session_tree, session_id, (void *) entry);
+    wmem_tree_insert32(conv_data->frame_tree, frame, (void *) entry);
+    return (entry);
+}
+
+static lbttcp_client_transport_t * lbttcp_client_transport_find(lbttcp_transport_t * transport, const address * receiver_address, guint16 receiver_port, guint32 frame)
+{
+    lbttcp_client_transport_t * entry = NULL;
+    conversation_t * client_conv = NULL;
+
+    if (transport == NULL)
+    {
+        return (NULL);
+    }
+    client_conv = find_conversation(frame, &(transport->source_address), receiver_address, CONVERSATION_TCP, transport->source_port, receiver_port, 0);
+    if (client_conv != NULL)
+    {
+        wmem_tree_t * session_tree = NULL;
+
+        session_tree = (wmem_tree_t *) conversation_get_proto_data(client_conv, proto_lbttcp);
+        if (session_tree != NULL)
+        {
+            entry = (lbttcp_client_transport_t *) wmem_tree_lookup32(session_tree, transport->session_id);
+        }
+    }
+    return (entry);
+}
+
+static lbttcp_client_transport_t * lbttcp_client_transport_add(lbttcp_transport_t * transport, const address * receiver_address, guint16 receiver_port, guint32 frame)
+{
+    lbttcp_client_transport_t * entry;
+    conversation_t * client_conv = NULL;
+    wmem_tree_t * session_tree = NULL;
+
+    if (transport == NULL)
+    {
+        return (NULL);
+    }
+    entry = lbttcp_client_transport_find(transport, receiver_address, receiver_port, frame);
+    if (entry != NULL)
+    {
+        return (entry);
+    }
+    entry = wmem_new(wmem_file_scope(), lbttcp_client_transport_t);
+    copy_address_wmem(wmem_file_scope(), &(entry->receiver_address), receiver_address);
+    entry->receiver_port = receiver_port;
+    entry->id = transport->next_client_id++;
+
+    /* See if a conversation for this address/port pair exists. */
+    client_conv = find_conversation(frame, &(transport->source_address), receiver_address, CONVERSATION_TCP, transport->source_port, receiver_port, 0);
+    if (client_conv == NULL)
+    {
+        client_conv = conversation_new(frame, &(transport->source_address), receiver_address, CONVERSATION_TCP, transport->source_port, receiver_port, 0);
+        session_tree = wmem_tree_new(wmem_file_scope());
+        conversation_add_proto_data(client_conv, proto_lbttcp, (void *) session_tree);
+    }
+    session_tree = (wmem_tree_t *) conversation_get_proto_data(client_conv, proto_lbttcp);
+    if (session_tree == NULL)
+    {
+        session_tree = wmem_tree_new(wmem_file_scope());
+        conversation_add_proto_data(client_conv, proto_lbttcp, (void *) session_tree);
+    }
+    wmem_tree_insert32(session_tree, transport->session_id, (void *) entry);
+
+    /* Add this client to the transport. */
+    wmem_list_append(transport->client_list, (void *) entry);
+    return (entry);
+}
+
+char * lbttcp_transport_source_string(const address * source_address, guint16 source_port, guint32 session_id)
+{
+    char * bufptr = NULL;
+
+    if (session_id == 0)
+    {
+        bufptr = wmem_strdup_printf(wmem_file_scope(), "TCP:%s:%" PRIu16, address_to_str(wmem_packet_scope(), source_address), source_port);
+    }
+    else
+    {
+        bufptr = wmem_strdup_printf(wmem_file_scope(), "TCP:%s:%" PRIu16 ":%08x", address_to_str(wmem_packet_scope(), source_address), source_port, session_id);
+    }
+    return (bufptr);
+}
+
+gboolean lbttcp_transport_sid_find(const address * source_address, guint16 source_port, guint32 frame, guint32 * session_id)
+{
+    conversation_t * conv = NULL;
+    lbttcp_transport_conv_data_t * conv_data = NULL;
+    lbttcp_transport_t * transport = NULL;
+
+    conv = find_conversation(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
+    if (conv == NULL)
+    {
+        return (FALSE);
+    }
+    conv_data = (lbttcp_transport_conv_data_t *) conversation_get_proto_data(conv, proto_lbttcp);
+    if (conv_data == NULL)
+    {
+        return (FALSE);
+    }
+    if (conv_data->frame_tree == NULL)
+    {
+        return (FALSE);
+    }
+    transport = (lbttcp_transport_t *)wmem_tree_lookup32_le(conv_data->frame_tree, frame);
+    if (transport == NULL)
+    {
+        return (FALSE);
+    }
+    *session_id = transport->session_id;
+    return (TRUE);
+}
+
+void lbttcp_transport_sid_add(const address * source_address, guint16 source_port, guint32 frame, guint32 session_id)
+{
+    conversation_t * conv = NULL;
+    lbttcp_transport_conv_data_t * conv_data = NULL;
+    lbttcp_transport_t * transport = NULL;
+
+    conv = find_conversation(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
+    if (conv == NULL)
+    {
+        conv = conversation_new(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
+    }
+    conv_data = (lbttcp_transport_conv_data_t *) conversation_get_proto_data(conv, proto_lbttcp);
+    if (conv_data == NULL)
+    {
+        conv_data = wmem_new(wmem_file_scope(), lbttcp_transport_conv_data_t);
+        conv_data->frame_tree = wmem_tree_new(wmem_file_scope());
+        conv_data->session_tree = wmem_tree_new(wmem_file_scope());
+        conversation_add_proto_data(conv, proto_lbttcp, (void *) conv_data);
+    }
+    /* Lookup by frame */
+    transport = (lbttcp_transport_t *) wmem_tree_lookup32_le(conv_data->frame_tree, frame);
+    if (transport != NULL)
+    {
+        if (transport->session_id != session_id)
+        {
+            transport = NULL;
+        }
+    }
+    if (transport == NULL)
+    {
+        transport = lbttcp_transport_create(source_address, source_port, session_id);
+        wmem_tree_insert32(conv_data->session_tree, session_id, (void *) transport);
+        wmem_tree_insert32(conv_data->frame_tree, frame, (void *) transport);
+    }
+}
+
+/*----------------------------------------------------------------------------*/
+/* Preferences.                                                               */
+/*----------------------------------------------------------------------------*/
+
+/* Preferences default values. */
+#define LBTTCP_DEFAULT_SOURCE_PORT_LOW 14371
+#define LBTTCP_DEFAULT_SOURCE_PORT_HIGH 14390
+#define LBTTCP_DEFAULT_REQUEST_PORT_LOW 14391
+#define LBTTCP_DEFAULT_REQUEST_PORT_HIGH 14395
+#define LBTTCP_DEFAULT_STORE_PORT_LOW 0
+#define LBTTCP_DEFAULT_STORE_PORT_HIGH 0
+
+/* Global preferences variables (altered by the preferences dialog). */
+static guint32 global_lbttcp_source_port_low = LBTTCP_DEFAULT_SOURCE_PORT_LOW;
+static guint32 global_lbttcp_source_port_high  = LBTTCP_DEFAULT_SOURCE_PORT_HIGH;
+static guint32 global_lbttcp_request_port_low = LBTTCP_DEFAULT_REQUEST_PORT_LOW;
+static guint32 global_lbttcp_request_port_high = LBTTCP_DEFAULT_REQUEST_PORT_HIGH;
+static guint32 global_lbttcp_store_port_low = LBTTCP_DEFAULT_STORE_PORT_LOW;
+static guint32 global_lbttcp_store_port_high = LBTTCP_DEFAULT_STORE_PORT_HIGH;
+static gboolean global_lbttcp_use_tag = FALSE;
+
+/* Local preferences variables (used by the dissector). */
+static guint32 lbttcp_source_port_low = LBTTCP_DEFAULT_SOURCE_PORT_LOW;
+static guint32 lbttcp_source_port_high = LBTTCP_DEFAULT_SOURCE_PORT_HIGH;
+static guint32 lbttcp_request_port_low = LBTTCP_DEFAULT_REQUEST_PORT_LOW;
+static guint32 lbttcp_request_port_high = LBTTCP_DEFAULT_REQUEST_PORT_HIGH;
+static guint32 lbttcp_store_port_low = LBTTCP_DEFAULT_STORE_PORT_LOW;
+static guint32 lbttcp_store_port_high = LBTTCP_DEFAULT_STORE_PORT_HIGH;
+static gboolean lbttcp_use_tag = FALSE;
+
+/* Tag definitions. */
+typedef struct
+{
+    char * name;
+    guint32 source_port_low;
+    guint32 source_port_high;
+    guint32 request_port_low;
+    guint32 request_port_high;
+    guint32 store_port_low;
+    guint32 store_port_high;
+} lbttcp_tag_entry_t;
+
+static lbttcp_tag_entry_t * lbttcp_tag_entry = NULL;
+static guint lbttcp_tag_count  = 0;
+
+UAT_CSTRING_CB_DEF(lbttcp_tag, name, lbttcp_tag_entry_t)
+UAT_DEC_CB_DEF(lbttcp_tag, source_port_low, lbttcp_tag_entry_t)
+UAT_DEC_CB_DEF(lbttcp_tag, source_port_high, lbttcp_tag_entry_t)
+UAT_DEC_CB_DEF(lbttcp_tag, request_port_low, lbttcp_tag_entry_t)
+UAT_DEC_CB_DEF(lbttcp_tag, request_port_high, lbttcp_tag_entry_t)
+UAT_DEC_CB_DEF(lbttcp_tag, store_port_low, lbttcp_tag_entry_t)
+UAT_DEC_CB_DEF(lbttcp_tag, store_port_high, lbttcp_tag_entry_t)
+static uat_field_t lbttcp_tag_array[] =
+{
+    UAT_FLD_CSTRING(lbttcp_tag, name, "Tag name", "Tag name"),
+    UAT_FLD_DEC(lbttcp_tag, source_port_low, "Source port low", "Source port low"),
+    UAT_FLD_DEC(lbttcp_tag, source_port_high, "Source port high", "Source port high"),
+    UAT_FLD_DEC(lbttcp_tag, request_port_low, "Request port low", "Request port low"),
+    UAT_FLD_DEC(lbttcp_tag, request_port_high, "Request port high", "Request port high"),
+    UAT_FLD_DEC(lbttcp_tag, store_port_low, "Store port low", "Store port low"),
+    UAT_FLD_DEC(lbttcp_tag, store_port_high, "Store port high", "Store port high"),
+    UAT_END_FIELDS
+};
+
+/*----------------------------------------------------------------------------*/
+/* UAT callback functions.                                                    */
+/*----------------------------------------------------------------------------*/
+static bool lbttcp_tag_update_cb(void * record, char * * error_string)
+{
+    lbttcp_tag_entry_t * tag = (lbttcp_tag_entry_t *)record;
+
+    if (tag->name == NULL)
+    {
+        *error_string = g_strdup("Tag name can't be empty");
+        return FALSE;
+    }
+    else
+    {
+        g_strstrip(tag->name);
+        if (tag->name[0] == 0)
+        {
+            *error_string = g_strdup("Tag name can't be empty");
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+static void * lbttcp_tag_copy_cb(void * destination, const void * source, size_t length _U_)
+{
+    const lbttcp_tag_entry_t * src = (const lbttcp_tag_entry_t *)source;
+    lbttcp_tag_entry_t * dest = (lbttcp_tag_entry_t *)destination;
+
+    dest->name = g_strdup(src->name);
+    dest->source_port_low = src->source_port_low;
+    dest->source_port_high = src->source_port_high;
+    dest->request_port_low = src->request_port_low;
+    dest->request_port_high = src->request_port_high;
+    dest->store_port_low = src->store_port_low;
+    dest->store_port_high = src->store_port_high;
+    return (dest);
+}
+
+static void lbttcp_tag_free_cb(void * record)
+{
+    lbttcp_tag_entry_t * tag = (lbttcp_tag_entry_t *)record;
+
+    if (tag->name != NULL)
+    {
+        g_free(tag->name);
+        tag->name = NULL;
+    }
+}
+
+static const lbttcp_tag_entry_t * lbttcp_tag_locate(packet_info * pinfo)
+{
+    guint idx;
+    const lbttcp_tag_entry_t * tag = NULL;
+
+    if (!lbttcp_use_tag)
+    {
+        return (NULL);
+    }
+
+    for (idx = 0; idx < lbttcp_tag_count; ++idx)
+    {
+        tag = &(lbttcp_tag_entry[idx]);
+        if (((pinfo->srcport >= tag->source_port_low) && (pinfo->srcport <= tag->source_port_high))
+            || ((pinfo->destport >= tag->source_port_low) && (pinfo->destport <= tag->source_port_high))
+            || ((pinfo->srcport >= tag->request_port_low) && (pinfo->srcport <= tag->request_port_high))
+            || ((pinfo->destport >= tag->request_port_low) && (pinfo->destport <= tag->request_port_high))
+            || ((pinfo->srcport >= tag->store_port_low) && (pinfo->srcport <= tag->store_port_high))
+            || ((pinfo->destport >= tag->store_port_low) && (pinfo->destport <= tag->store_port_high)))
+        {
+            return (tag);
+        }
+    }
+    return (NULL);
+}
+
+static char * lbttcp_tag_find(packet_info * pinfo)
+{
+    const lbttcp_tag_entry_t * tag = NULL;
+
+    if (!lbttcp_use_tag)
+    {
+        return (NULL);
+    }
+
+    tag = lbttcp_tag_locate(pinfo);
+    if (tag != NULL)
+    {
+        return tag->name;
+    }
+    return (NULL);
+}
+
+/*----------------------------------------------------------------------------*/
+/* Handles of all types.                                                      */
+/*----------------------------------------------------------------------------*/
+
+/* Dissector tree handles */
+static gint ett_lbttcp = -1;
+static gint ett_lbttcp_channel = -1;
+
+/* Dissector field handles */
+static int hf_lbttcp_tag = -1;
+static int hf_lbttcp_channel = -1;
+static int hf_lbttcp_channel_id = -1;
+static int hf_lbttcp_channel_client = -1;
+
+static gboolean lbttcp_packet_is_transport_source(packet_info * pinfo, const lbttcp_tag_entry_t * tag)
+{
+    gboolean is_transport_source_packet = FALSE;
+
+    if (tag == NULL)
+    {
+        if ((pinfo->srcport >= lbttcp_source_port_low) && (pinfo->srcport <= lbttcp_source_port_high))
+        {
+            is_transport_source_packet = TRUE;
+        }
+    }
+    else
+    {
+        if ((pinfo->srcport >= tag->source_port_low) && (pinfo->srcport <= tag->source_port_high))
+        {
+            is_transport_source_packet = TRUE;
+        }
+    }
+    return (is_transport_source_packet);
+}
+
+static gboolean lbttcp_packet_is_transport_client(packet_info * pinfo, const lbttcp_tag_entry_t * tag)
+{
+    gboolean is_transport_client_packet = FALSE;
+
+    if (tag == NULL)
+    {
+        if ((pinfo->destport >= lbttcp_source_port_low) && (pinfo->destport <= lbttcp_source_port_high))
+        {
+            is_transport_client_packet = TRUE;
+        }
+    }
+    else
+    {
+        if ((pinfo->destport >= tag->source_port_low) && (pinfo->destport <= tag->source_port_high))
+        {
+            is_transport_client_packet = TRUE;
+        }
+    }
+    return (is_transport_client_packet);
+}
+
+static guint get_lbttcp_pdu_length(packet_info * pinfo _U_, tvbuff_t * tvb,
+                                   int offset, void *data _U_)
+{
+    return lbmc_get_message_length(tvb, offset);
+}
+
+static int dissect_lbttcp_pdu(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * dissector_data _U_)
+{
+    proto_tree * lbttcp_tree = NULL;
+    proto_item * ti = NULL;
+    char * tag_name = NULL;
+    int len_dissected;
+    const lbttcp_tag_entry_t * tag = NULL;
+    guint64 channel = LBM_CHANNEL_NO_CHANNEL;
+    guint32 client_id = 0;
+    gboolean from_source = FALSE;
+    gboolean transport_packet = FALSE;
+
+    if (lbttcp_use_tag)
+    {
+        tag = lbttcp_tag_locate(pinfo);
+        tag_name = lbttcp_tag_find(pinfo);
+    }
+    if (tag_name != NULL)
+    {
+        ti = proto_tree_add_protocol_format(tree, proto_lbttcp, tvb, 0, -1, "LBT-TCP Protocol (Tag: %s)", tag_name);
+    }
+    else
+    {
+        ti = proto_tree_add_protocol_format(tree, proto_lbttcp, tvb, 0, -1, "LBT-TCP Protocol");
+    }
+    lbttcp_tree = proto_item_add_subtree(ti, ett_lbttcp);
+    if (tag_name != NULL)
+    {
+        proto_item * item = NULL;
+
+        item = proto_tree_add_string(lbttcp_tree, hf_lbttcp_tag, tvb, 0, 0, tag_name);
+        proto_item_set_generated(item);
+    }
+    if (lbttcp_packet_is_transport_source(pinfo, tag))
+    {
+        from_source = TRUE;
+        transport_packet = TRUE;
+    }
+    else if (lbttcp_packet_is_transport_client(pinfo, tag))
+    {
+        from_source = FALSE;
+        transport_packet = TRUE;
+    }
+    if (transport_packet)
+    {
+        address source_address;
+        address client_address;
+        guint16 srcport;
+        guint16 clntport;
+        guint32 sid = 0;
+        lbttcp_transport_t * transport = NULL;
+        lbttcp_client_transport_t * client = NULL;
+
+        if (from_source)
+        {
+            copy_address_shallow(&source_address, &(pinfo->src));
+            srcport = pinfo->srcport;
+            copy_address_shallow(&client_address, &(pinfo->dst));
+            clntport = pinfo->destport;
+        }
+        else
+        {
+            copy_address_shallow(&source_address, &(pinfo->dst));
+            srcport = pinfo->destport;
+            copy_address_shallow(&client_address, &(pinfo->src));
+            clntport = pinfo->srcport;
+        }
+        /* See if we have a matching transport with no session ID. */
+        transport = lbttcp_transport_find(&source_address, srcport, sid, pinfo->num);
+        if (transport == NULL)
+        {
+            /* See if we know about a SID */
+            if (lbttcp_transport_sid_find(&source_address, srcport, pinfo->num, &sid))
+            {
+                transport = lbttcp_transport_find(&source_address, srcport, sid, pinfo->num);
+            }
+        }
+        if (transport != NULL)
+        {
+            channel = transport->channel;
+            /* See if we already know about this client */
+            client = lbttcp_client_transport_find(transport, &client_address, clntport, pinfo->num);
+            if (client == NULL)
+            {
+                /* No - add it. */
+                client = lbttcp_client_transport_add(transport, &client_address, clntport, pinfo->num);
+            }
+            if (client != NULL)
+            {
+                client_id = client->id;
+            }
+        }
+        else
+        {
+            if (PINFO_FD_VISITED(pinfo))
+            {
+                /* No TIR and no session ID seen, so create the transport */
+                transport = lbttcp_transport_add(&source_address, srcport, 0, pinfo->num);
+                if (transport != NULL)
+                {
+                    channel = transport->channel;
+                    client = lbttcp_client_transport_add(transport, &client_address, clntport, pinfo->num);
+                    if (client != NULL)
+                    {
+                        client_id = client->id;
+                    }
+                }
+            }
+            else
+            {
+                /* Defer determining the channel. */
+                if (from_source)
+                {
+                    channel = lbm_channel_assign_unknown_transport_source_lbttcp();
+                }
+                else
+                {
+                    channel = lbm_channel_assign_unknown_transport_client_lbttcp();
+                }
+            }
+        }
+    }
+    else
+    {
+        channel = lbm_channel_assign_unknown_stream_tcp();
+    }
+    if (lbm_channel_is_known(channel))
+    {
+        proto_item * channel_item = NULL;
+        proto_tree * channel_tree = NULL;
+
+        channel_item = proto_tree_add_item(lbttcp_tree, hf_lbttcp_channel, tvb, 0, 0, ENC_NA);
+        proto_item_set_generated(channel_item);
+        channel_tree = proto_item_add_subtree(channel_item, ett_lbttcp_channel);
+        channel_item = proto_tree_add_uint64(channel_tree, hf_lbttcp_channel_id, tvb, 0, 0, channel);
+        proto_item_set_generated(channel_item);
+        channel_item = proto_tree_add_uint(channel_tree, hf_lbttcp_channel_client, tvb, 0, 0, client_id);
+        proto_item_set_generated(channel_item);
+    }
+    len_dissected = lbmc_dissect_lbmc_packet(tvb, 0, pinfo, tree, tag_name, channel);
+    return (len_dissected);
+}
+
+/*
+ * dissect_lbttcp_real - The "common" dissection for LBT-TCP
+ */
+static int dissect_lbttcp_real(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data _U_)
+{
+    char * tag_name = NULL;
+
+    col_add_str(pinfo->cinfo, COL_PROTOCOL, "LBT-TCP");
+    col_clear(pinfo->cinfo, COL_INFO);
+    if (lbttcp_use_tag)
+    {
+        tag_name = lbttcp_tag_find(pinfo);
+    }
+    if (tag_name != NULL)
+    {
+        col_add_fstr(pinfo->cinfo, COL_INFO, "[Tag: %s]", tag_name);
+    }
+    col_set_fence(pinfo->cinfo, COL_INFO);
+    tcp_dissect_pdus(tvb, pinfo, tree, TRUE, lbmc_get_minimum_length(), /* Need at least the msglen */
+        get_lbttcp_pdu_length, dissect_lbttcp_pdu, NULL);
+
+    return tvb_captured_length(tvb);
+}
+
+/*
+ * dissect_lbttcp - The dissector for LBT-TCP
+ */
+static int dissect_lbttcp(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data)
+{
+    if (!lbmc_test_lbmc_header(tvb, 0))
+        return 0;
+
+    return dissect_lbttcp_real(tvb, pinfo, tree, data);
+}
+
+static gboolean test_lbttcp_packet(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data)
+{
+    /* Destination address must be IPV4 and 4 bytes in length. */
+    if ((pinfo->dst.type != AT_IPv4) || (pinfo->dst.len != 4))
+    {
+        return (FALSE);
+    }
+
+    if (lbttcp_use_tag)
+    {
+        if (lbttcp_tag_find(pinfo) != NULL)
+        {
+            dissect_lbttcp_real(tvb, pinfo, tree, data);
+            return (TRUE);
+        }
+        else
+        {
+            return (FALSE);
+        }
+    }
+
+    /*
+        Source port or destination port must be in the source port range, or destination port must be in
+        the request port range, or either port in the UME store port range.
+    */
+    if (!(((pinfo->srcport >= lbttcp_source_port_low) && (pinfo->srcport <= lbttcp_source_port_high))
+          || ((pinfo->destport >= lbttcp_source_port_low) && (pinfo->destport <= lbttcp_source_port_high))
+          || ((pinfo->srcport >= lbttcp_request_port_low) && (pinfo->srcport <= lbttcp_request_port_high))
+          || ((pinfo->destport >= lbttcp_request_port_low) && (pinfo->destport <= lbttcp_request_port_high))
+          || ((pinfo->srcport >= lbttcp_store_port_low) && (pinfo->srcport <= lbttcp_store_port_high))
+          || ((pinfo->destport >= lbttcp_store_port_low) && (pinfo->destport <= lbttcp_store_port_high))))
+    {
+        return (FALSE);
+    }
+
+    if (!lbmc_test_lbmc_header(tvb, 0))
+        return FALSE;
+
+    /* One of ours. Probably. */
+    dissect_lbttcp_real(tvb, pinfo, tree, data);
+    return (TRUE);
+}
+
+/* Register all the bits needed with the filtering engine */
+void proto_register_lbttcp(void)
+{
+    static hf_register_info hf[] =
+    {
+        { &hf_lbttcp_tag,
+            { "Tag", "lbttcp.tag", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+        { &hf_lbttcp_channel,
+            { "Channel", "lbttcp.channel", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+        { &hf_lbttcp_channel_id,
+            { "Channel ID", "lbttcp.channel.channel", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } },
+        { &hf_lbttcp_channel_client,
+            { "Channel Client", "lbttcp.channel.client", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+    };
+    static gint * ett[] =
+    {
+        &ett_lbttcp,
+        &ett_lbttcp_channel
+    };
+    module_t * lbttcp_module;
+    uat_t * tag_uat;
+
+    proto_lbttcp = proto_register_protocol("LBT TCP Protocol", "LBT-TCP", "lbttcp");
+
+    proto_register_field_array(proto_lbttcp, hf, array_length(hf));
+    proto_register_subtree_array(ett, array_length(ett));
+
+    lbttcp_dissector_handle = register_dissector("lbttcp", dissect_lbttcp, proto_lbttcp);
+
+    lbttcp_module = prefs_register_protocol_subtree("29West", proto_lbttcp, proto_reg_handoff_lbttcp);
+    prefs_register_uint_preference(lbttcp_module,
+        "source_port_low",
+        "Source port range low (default " MAKESTRING(LBTTCP_DEFAULT_SOURCE_PORT_LOW)")",
+        "Set the low end of the LBT-TCP source TCP port range (context transport_tcp_port_low)",
+        10,
+        &global_lbttcp_source_port_low);
+
+    prefs_register_uint_preference(lbttcp_module,
+        "source_port_high",
+        "Source port range high (default " MAKESTRING(LBTTCP_DEFAULT_SOURCE_PORT_HIGH)")",
+        "Set the high end of the LBT-TCP source TCP port range (context transport_tcp_port_high)",
+        10,
+        &global_lbttcp_source_port_high);
+
+    prefs_register_uint_preference(lbttcp_module,
+        "request_port_low",
+        "Request port range low (default " MAKESTRING(LBTTCP_DEFAULT_REQUEST_PORT_LOW)")",
+        "Set the low end of the LBT-TCP request TCP port range (context request_tcp_port_low)",
+        10,
+        &global_lbttcp_request_port_low);
+
+    prefs_register_uint_preference(lbttcp_module,
+        "request_port_high",
+        "Request port range high (default " MAKESTRING(LBTTCP_DEFAULT_REQUEST_PORT_HIGH)")",
+        "Set the high end of the LBT-TCP request TCP port range (context request_tcp_port_high)",
+        10,
+        &global_lbttcp_request_port_high);
+
+    prefs_register_uint_preference(lbttcp_module,
+        "store_port_low",
+        "UME Store port range low (default " MAKESTRING(LBTTCP_DEFAULT_STORE_PORT_LOW)")",
+        "Set the low end of the LBT-TCP UME Store TCP port range",
+        10,
+        &global_lbttcp_store_port_low);
+
+    prefs_register_uint_preference(lbttcp_module,
+        "store_port_high",
+        "UME Store port range high (default " MAKESTRING(LBTTCP_DEFAULT_STORE_PORT_HIGH)")",
+        "Set the high end of the LBT-TCP UME Store TCP port range",
+        10,
+        &global_lbttcp_store_port_high);
+
+    prefs_register_bool_preference(lbttcp_module,
+        "use_lbttcp_domain",
+        "Use LBT-TCP tag table",
+        "Use table of LBT-TCP tags to decode the packet instead of above values",
+        &global_lbttcp_use_tag);
+    tag_uat = uat_new("LBT-TCP tag definitions",
+        sizeof(lbttcp_tag_entry_t),
+        "lbttcp_domains",
+        TRUE,
+        (void * *)&lbttcp_tag_entry,
+        &lbttcp_tag_count,
+        UAT_AFFECTS_DISSECTION,
+        NULL,
+        lbttcp_tag_copy_cb,
+        lbttcp_tag_update_cb,
+        lbttcp_tag_free_cb,
+        NULL,
+        NULL,
+        lbttcp_tag_array);
+    prefs_register_uat_preference(lbttcp_module,
+        "tnw_lbttcp_tags",
+        "LBT-TCP Tags",
+        "A table to define LBT-TCP tags",
+        tag_uat);
+}
+
+/* The registration hand-off routine */
+void proto_reg_handoff_lbttcp(void)
+{
+    static gboolean already_registered = FALSE;
+
+    if (!already_registered)
+    {
+        dissector_add_for_decode_as_with_preference("tcp.port", lbttcp_dissector_handle);
+        heur_dissector_add("tcp", test_lbttcp_packet, "LBT over TCP", "lbttcp_tcp", proto_lbttcp, HEURISTIC_ENABLE);
+    }
+
+    /* Make sure the source port low is <= the source port high. If not, don't change them. */
+    if (global_lbttcp_source_port_low <= global_lbttcp_source_port_high)
+    {
+        lbttcp_source_port_low = global_lbttcp_source_port_low;
+        lbttcp_source_port_high = global_lbttcp_source_port_high;
+    }
+
+    /* Make sure the request port low is <= the request port high. If not, don't change them. */
+    if (global_lbttcp_request_port_low <= global_lbttcp_request_port_high)
+    {
+        lbttcp_request_port_low = global_lbttcp_request_port_low;
+        lbttcp_request_port_high = global_lbttcp_request_port_high;
+    }
+
+    /* Make sure the store port low is <= the store port high. If not, don't change them. */
+    if (global_lbttcp_store_port_low <= global_lbttcp_store_port_high)
+    {
+        lbttcp_store_port_low = global_lbttcp_store_port_low;
+        lbttcp_store_port_high = global_lbttcp_store_port_high;
+    }
+
+    lbttcp_use_tag = global_lbttcp_use_tag;
+
+    already_registered = TRUE;
+}
+
+/*
+ * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */