epan/dissectors/packet-lbttcp.c

   1 /* packet-lbttcp.c
   2  * Routines for LBM TCP Packet dissection
   3  *
   4  * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved.
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * SPDX-License-Identifier: GPL-2.0-or-later
  11  */
  12
  13 #include "config.h"
  14
  15 #include <epan/packet.h>
  16 #include <epan/prefs.h>
  17 #include <epan/uat.h>
  18 #include <epan/to_str.h>
  19 #include "packet-tcp.h"
  20 #include "packet-lbm.h"
  21 #include "packet-lbttcp.h"
  22
  23 void proto_register_lbttcp(void);
  24 void proto_reg_handoff_lbttcp(void);
  25
  26 /* Protocol handle */
  27 static int proto_lbttcp;
  28
  29 /* Dissector handle */
  30 static dissector_handle_t lbttcp_dissector_handle;
  31
  32 /*----------------------------------------------------------------------------*/
  33 /* LBT-TCP protocol management.                                               */
  34 /*----------------------------------------------------------------------------*/
  35
  36 typedef struct
  37 {
  38     wmem_tree_t * frame_tree;
  39     wmem_tree_t * session_tree;
  40 } lbttcp_transport_conv_data_t;
  41
  42 static const address lbttcp_null_address = ADDRESS_INIT_NONE;
  43
  44 lbttcp_transport_t * lbttcp_transport_find(const address * source_address, uint16_t source_port, uint32_t session_id, uint32_t frame)
  45 {
  46     lbttcp_transport_t * entry = NULL;
  47     conversation_t * conv = NULL;
  48     lbttcp_transport_conv_data_t * conv_data = NULL;
  49
  50     conv = find_conversation(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
  51     if (conv != NULL)
  52     {
  53         conv_data = (lbttcp_transport_conv_data_t *) conversation_get_proto_data(conv, proto_lbttcp);
  54         if (conv_data != NULL)
  55         {
  56             entry = (lbttcp_transport_t *) wmem_tree_lookup32(conv_data->session_tree, session_id);
  57         }
  58     }
  59     return (entry);
  60 }
  61
  62 static lbttcp_transport_t * lbttcp_transport_create(const address * source_address, uint16_t source_port, uint32_t session_id)
  63 {
  64     lbttcp_transport_t * transport = NULL;
  65
  66     transport = wmem_new(wmem_file_scope(), lbttcp_transport_t);
  67     copy_address_wmem(wmem_file_scope(), &(transport->source_address), source_address);
  68     transport->source_port = source_port;
  69     transport->session_id = session_id;
  70     transport->channel = lbm_channel_assign(LBM_CHANNEL_TRANSPORT_LBTTCP);
  71     transport->next_client_id = 1;
  72     transport->client_list = wmem_list_new(wmem_file_scope());
  73     return (transport);
  74 }
  75
  76 lbttcp_transport_t * lbttcp_transport_add(const address * source_address, uint16_t source_port, uint32_t session_id, uint32_t frame)
  77 {
  78     lbttcp_transport_t * entry = NULL;
  79     conversation_t * conv = NULL;
  80     lbttcp_transport_conv_data_t * conv_data = NULL;
  81
  82     conv = find_conversation(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
  83     if (conv == NULL)
  84     {
  85         conv = conversation_new(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
  86     }
  87     conv_data = (lbttcp_transport_conv_data_t *) conversation_get_proto_data(conv, proto_lbttcp);
  88     if (conv_data == NULL)
  89     {
  90         conv_data = wmem_new(wmem_file_scope(), lbttcp_transport_conv_data_t);
  91         conv_data->frame_tree = wmem_tree_new(wmem_file_scope());
  92         conv_data->session_tree = wmem_tree_new(wmem_file_scope());
  93         conversation_add_proto_data(conv, proto_lbttcp, (void *) conv_data);
  94     }
  95     entry = (lbttcp_transport_t *) wmem_tree_lookup32(conv_data->session_tree, session_id);
  96     if (entry != NULL)
  97     {
  98         return (entry);
  99     }
 100     entry = lbttcp_transport_create(source_address, source_port, session_id);
 101     wmem_tree_insert32(conv_data->session_tree, session_id, (void *) entry);
 102     wmem_tree_insert32(conv_data->frame_tree, frame, (void *) entry);
 103     return (entry);
 104 }
 105
 106 static lbttcp_client_transport_t * lbttcp_client_transport_find(lbttcp_transport_t * transport, const address * receiver_address, uint16_t receiver_port, uint32_t frame)
 107 {
 108     lbttcp_client_transport_t * entry = NULL;
 109     conversation_t * client_conv = NULL;
 110
 111     if (transport == NULL)
 112     {
 113         return (NULL);
 114     }
 115     client_conv = find_conversation(frame, &(transport->source_address), receiver_address, CONVERSATION_TCP, transport->source_port, receiver_port, 0);
 116     if (client_conv != NULL)
 117     {
 118         wmem_tree_t * session_tree = NULL;
 119
 120         session_tree = (wmem_tree_t *) conversation_get_proto_data(client_conv, proto_lbttcp);
 121         if (session_tree != NULL)
 122         {
 123             entry = (lbttcp_client_transport_t *) wmem_tree_lookup32(session_tree, transport->session_id);
 124         }
 125     }
 126     return (entry);
 127 }
 128
 129 static lbttcp_client_transport_t * lbttcp_client_transport_add(lbttcp_transport_t * transport, const address * receiver_address, uint16_t receiver_port, uint32_t frame)
 130 {
 131     lbttcp_client_transport_t * entry;
 132     conversation_t * client_conv = NULL;
 133     wmem_tree_t * session_tree = NULL;
 134
 135     if (transport == NULL)
 136     {
 137         return (NULL);
 138     }
 139     entry = lbttcp_client_transport_find(transport, receiver_address, receiver_port, frame);
 140     if (entry != NULL)
 141     {
 142         return (entry);
 143     }
 144     entry = wmem_new(wmem_file_scope(), lbttcp_client_transport_t);
 145     copy_address_wmem(wmem_file_scope(), &(entry->receiver_address), receiver_address);
 146     entry->receiver_port = receiver_port;
 147     entry->id = transport->next_client_id++;
 148
 149     /* See if a conversation for this address/port pair exists. */
 150     client_conv = find_conversation(frame, &(transport->source_address), receiver_address, CONVERSATION_TCP, transport->source_port, receiver_port, 0);
 151     if (client_conv == NULL)
 152     {
 153         client_conv = conversation_new(frame, &(transport->source_address), receiver_address, CONVERSATION_TCP, transport->source_port, receiver_port, 0);
 154         session_tree = wmem_tree_new(wmem_file_scope());
 155         conversation_add_proto_data(client_conv, proto_lbttcp, (void *) session_tree);
 156     }
 157     session_tree = (wmem_tree_t *) conversation_get_proto_data(client_conv, proto_lbttcp);
 158     if (session_tree == NULL)
 159     {
 160         session_tree = wmem_tree_new(wmem_file_scope());
 161         conversation_add_proto_data(client_conv, proto_lbttcp, (void *) session_tree);
 162     }
 163     wmem_tree_insert32(session_tree, transport->session_id, (void *) entry);
 164
 165     /* Add this client to the transport. */
 166     wmem_list_append(transport->client_list, (void *) entry);
 167     return (entry);
 168 }
 169
 170 char * lbttcp_transport_source_string(const address * source_address, uint16_t source_port, uint32_t session_id)
 171 {
 172     char * bufptr = NULL;
 173
 174     if (session_id == 0)
 175     {
 176         bufptr = wmem_strdup_printf(wmem_file_scope(), "TCP:%s:%" PRIu16, address_to_str(wmem_packet_scope(), source_address), source_port);
 177     }
 178     else
 179     {
 180         bufptr = wmem_strdup_printf(wmem_file_scope(), "TCP:%s:%" PRIu16 ":%08x", address_to_str(wmem_packet_scope(), source_address), source_port, session_id);
 181     }
 182     return (bufptr);
 183 }
 184
 185 bool lbttcp_transport_sid_find(const address * source_address, uint16_t source_port, uint32_t frame, uint32_t * session_id)
 186 {
 187     conversation_t * conv = NULL;
 188     lbttcp_transport_conv_data_t * conv_data = NULL;
 189     lbttcp_transport_t * transport = NULL;
 190
 191     conv = find_conversation(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
 192     if (conv == NULL)
 193     {
 194         return false;
 195     }
 196     conv_data = (lbttcp_transport_conv_data_t *) conversation_get_proto_data(conv, proto_lbttcp);
 197     if (conv_data == NULL)
 198     {
 199         return false;
 200     }
 201     if (conv_data->frame_tree == NULL)
 202     {
 203         return false;
 204     }
 205     transport = (lbttcp_transport_t *)wmem_tree_lookup32_le(conv_data->frame_tree, frame);
 206     if (transport == NULL)
 207     {
 208         return false;
 209     }
 210     *session_id = transport->session_id;
 211     return true;
 212 }
 213
 214 void lbttcp_transport_sid_add(const address * source_address, uint16_t source_port, uint32_t frame, uint32_t session_id)
 215 {
 216     conversation_t * conv = NULL;
 217     lbttcp_transport_conv_data_t * conv_data = NULL;
 218     lbttcp_transport_t * transport = NULL;
 219
 220     conv = find_conversation(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
 221     if (conv == NULL)
 222     {
 223         conv = conversation_new(frame, source_address, &lbttcp_null_address, CONVERSATION_TCP, source_port, 0, 0);
 224     }
 225     conv_data = (lbttcp_transport_conv_data_t *) conversation_get_proto_data(conv, proto_lbttcp);
 226     if (conv_data == NULL)
 227     {
 228         conv_data = wmem_new(wmem_file_scope(), lbttcp_transport_conv_data_t);
 229         conv_data->frame_tree = wmem_tree_new(wmem_file_scope());
 230         conv_data->session_tree = wmem_tree_new(wmem_file_scope());
 231         conversation_add_proto_data(conv, proto_lbttcp, (void *) conv_data);
 232     }
 233     /* Lookup by frame */
 234     transport = (lbttcp_transport_t *) wmem_tree_lookup32_le(conv_data->frame_tree, frame);
 235     if (transport != NULL)
 236     {
 237         if (transport->session_id != session_id)
 238         {
 239             transport = NULL;
 240         }
 241     }
 242     if (transport == NULL)
 243     {
 244         transport = lbttcp_transport_create(source_address, source_port, session_id);
 245         wmem_tree_insert32(conv_data->session_tree, session_id, (void *) transport);
 246         wmem_tree_insert32(conv_data->frame_tree, frame, (void *) transport);
 247     }
 248 }
 249
 250 /*----------------------------------------------------------------------------*/
 251 /* Preferences.                                                               */
 252 /*----------------------------------------------------------------------------*/
 253
 254 /* Preferences default values. */
 255 #define LBTTCP_DEFAULT_SOURCE_PORT_LOW 14371
 256 #define LBTTCP_DEFAULT_SOURCE_PORT_HIGH 14390
 257 #define LBTTCP_DEFAULT_REQUEST_PORT_LOW 14391
 258 #define LBTTCP_DEFAULT_REQUEST_PORT_HIGH 14395
 259 #define LBTTCP_DEFAULT_STORE_PORT_LOW 0
 260 #define LBTTCP_DEFAULT_STORE_PORT_HIGH 0
 261
 262 /* Global preferences variables (altered by the preferences dialog). */
 263 static uint32_t global_lbttcp_source_port_low = LBTTCP_DEFAULT_SOURCE_PORT_LOW;
 264 static uint32_t global_lbttcp_source_port_high  = LBTTCP_DEFAULT_SOURCE_PORT_HIGH;
 265 static uint32_t global_lbttcp_request_port_low = LBTTCP_DEFAULT_REQUEST_PORT_LOW;
 266 static uint32_t global_lbttcp_request_port_high = LBTTCP_DEFAULT_REQUEST_PORT_HIGH;
 267 static uint32_t global_lbttcp_store_port_low = LBTTCP_DEFAULT_STORE_PORT_LOW;
 268 static uint32_t global_lbttcp_store_port_high = LBTTCP_DEFAULT_STORE_PORT_HIGH;
 269 static bool global_lbttcp_use_tag;
 270
 271 /* Local preferences variables (used by the dissector). */
 272 static uint32_t lbttcp_source_port_low = LBTTCP_DEFAULT_SOURCE_PORT_LOW;
 273 static uint32_t lbttcp_source_port_high = LBTTCP_DEFAULT_SOURCE_PORT_HIGH;
 274 static uint32_t lbttcp_request_port_low = LBTTCP_DEFAULT_REQUEST_PORT_LOW;
 275 static uint32_t lbttcp_request_port_high = LBTTCP_DEFAULT_REQUEST_PORT_HIGH;
 276 static uint32_t lbttcp_store_port_low = LBTTCP_DEFAULT_STORE_PORT_LOW;
 277 static uint32_t lbttcp_store_port_high = LBTTCP_DEFAULT_STORE_PORT_HIGH;
 278 static bool lbttcp_use_tag;
 279
 280 /* Tag definitions. */
 281 typedef struct
 282 {
 283     char * name;
 284     uint32_t source_port_low;
 285     uint32_t source_port_high;
 286     uint32_t request_port_low;
 287     uint32_t request_port_high;
 288     uint32_t store_port_low;
 289     uint32_t store_port_high;
 290 } lbttcp_tag_entry_t;
 291
 292 static lbttcp_tag_entry_t * lbttcp_tag_entry;
 293 static unsigned lbttcp_tag_count;
 294
 295 UAT_CSTRING_CB_DEF(lbttcp_tag, name, lbttcp_tag_entry_t)
 296 UAT_DEC_CB_DEF(lbttcp_tag, source_port_low, lbttcp_tag_entry_t)
 297 UAT_DEC_CB_DEF(lbttcp_tag, source_port_high, lbttcp_tag_entry_t)
 298 UAT_DEC_CB_DEF(lbttcp_tag, request_port_low, lbttcp_tag_entry_t)
 299 UAT_DEC_CB_DEF(lbttcp_tag, request_port_high, lbttcp_tag_entry_t)
 300 UAT_DEC_CB_DEF(lbttcp_tag, store_port_low, lbttcp_tag_entry_t)
 301 UAT_DEC_CB_DEF(lbttcp_tag, store_port_high, lbttcp_tag_entry_t)
 302 static uat_field_t lbttcp_tag_array[] =
 303 {
 304     UAT_FLD_CSTRING(lbttcp_tag, name, "Tag name", "Tag name"),
 305     UAT_FLD_DEC(lbttcp_tag, source_port_low, "Source port low", "Source port low"),
 306     UAT_FLD_DEC(lbttcp_tag, source_port_high, "Source port high", "Source port high"),
 307     UAT_FLD_DEC(lbttcp_tag, request_port_low, "Request port low", "Request port low"),
 308     UAT_FLD_DEC(lbttcp_tag, request_port_high, "Request port high", "Request port high"),
 309     UAT_FLD_DEC(lbttcp_tag, store_port_low, "Store port low", "Store port low"),
 310     UAT_FLD_DEC(lbttcp_tag, store_port_high, "Store port high", "Store port high"),
 311     UAT_END_FIELDS
 312 };
 313
 314 /*----------------------------------------------------------------------------*/
 315 /* UAT callback functions.                                                    */
 316 /*----------------------------------------------------------------------------*/
 317 static bool lbttcp_tag_update_cb(void * record, char * * error_string)
 318 {
 319     lbttcp_tag_entry_t * tag = (lbttcp_tag_entry_t *)record;
 320
 321     if (tag->name == NULL)
 322     {
 323         *error_string = g_strdup("Tag name can't be empty");
 324         return false;
 325     }
 326     else
 327     {
 328         g_strstrip(tag->name);
 329         if (tag->name[0] == 0)
 330         {
 331             *error_string = g_strdup("Tag name can't be empty");
 332             return false;
 333         }
 334     }
 335     return true;
 336 }
 337
 338 static void * lbttcp_tag_copy_cb(void * destination, const void * source, size_t length _U_)
 339 {
 340     const lbttcp_tag_entry_t * src = (const lbttcp_tag_entry_t *)source;
 341     lbttcp_tag_entry_t * dest = (lbttcp_tag_entry_t *)destination;
 342
 343     dest->name = g_strdup(src->name);
 344     dest->source_port_low = src->source_port_low;
 345     dest->source_port_high = src->source_port_high;
 346     dest->request_port_low = src->request_port_low;
 347     dest->request_port_high = src->request_port_high;
 348     dest->store_port_low = src->store_port_low;
 349     dest->store_port_high = src->store_port_high;
 350     return (dest);
 351 }
 352
 353 static void lbttcp_tag_free_cb(void * record)
 354 {
 355     lbttcp_tag_entry_t * tag = (lbttcp_tag_entry_t *)record;
 356
 357     if (tag->name != NULL)
 358     {
 359         g_free(tag->name);
 360         tag->name = NULL;
 361     }
 362 }
 363
 364 static const lbttcp_tag_entry_t * lbttcp_tag_locate(packet_info * pinfo)
 365 {
 366     unsigned idx;
 367     const lbttcp_tag_entry_t * tag = NULL;
 368
 369     if (!lbttcp_use_tag)
 370     {
 371         return (NULL);
 372     }
 373
 374     for (idx = 0; idx < lbttcp_tag_count; ++idx)
 375     {
 376         tag = &(lbttcp_tag_entry[idx]);
 377         if (((pinfo->srcport >= tag->source_port_low) && (pinfo->srcport <= tag->source_port_high))
 378             || ((pinfo->destport >= tag->source_port_low) && (pinfo->destport <= tag->source_port_high))
 379             || ((pinfo->srcport >= tag->request_port_low) && (pinfo->srcport <= tag->request_port_high))
 380             || ((pinfo->destport >= tag->request_port_low) && (pinfo->destport <= tag->request_port_high))
 381             || ((pinfo->srcport >= tag->store_port_low) && (pinfo->srcport <= tag->store_port_high))
 382             || ((pinfo->destport >= tag->store_port_low) && (pinfo->destport <= tag->store_port_high)))
 383         {
 384             return (tag);
 385         }
 386     }
 387     return (NULL);
 388 }
 389
 390 static char * lbttcp_tag_find(packet_info * pinfo)
 391 {
 392     const lbttcp_tag_entry_t * tag = NULL;
 393
 394     if (!lbttcp_use_tag)
 395     {
 396         return (NULL);
 397     }
 398
 399     tag = lbttcp_tag_locate(pinfo);
 400     if (tag != NULL)
 401     {
 402         return tag->name;
 403     }
 404     return (NULL);
 405 }
 406
 407 /*----------------------------------------------------------------------------*/
 408 /* Handles of all types.                                                      */
 409 /*----------------------------------------------------------------------------*/
 410
 411 /* Dissector tree handles */
 412 static int ett_lbttcp;
 413 static int ett_lbttcp_channel;
 414
 415 /* Dissector field handles */
 416 static int hf_lbttcp_tag;
 417 static int hf_lbttcp_channel;
 418 static int hf_lbttcp_channel_id;
 419 static int hf_lbttcp_channel_client;
 420
 421 static bool lbttcp_packet_is_transport_source(packet_info * pinfo, const lbttcp_tag_entry_t * tag)
 422 {
 423     bool is_transport_source_packet = false;
 424
 425     if (tag == NULL)
 426     {
 427         if ((pinfo->srcport >= lbttcp_source_port_low) && (pinfo->srcport <= lbttcp_source_port_high))
 428         {
 429             is_transport_source_packet = true;
 430         }
 431     }
 432     else
 433     {
 434         if ((pinfo->srcport >= tag->source_port_low) && (pinfo->srcport <= tag->source_port_high))
 435         {
 436             is_transport_source_packet = true;
 437         }
 438     }
 439     return (is_transport_source_packet);
 440 }
 441
 442 static bool lbttcp_packet_is_transport_client(packet_info * pinfo, const lbttcp_tag_entry_t * tag)
 443 {
 444     bool is_transport_client_packet = false;
 445
 446     if (tag == NULL)
 447     {
 448         if ((pinfo->destport >= lbttcp_source_port_low) && (pinfo->destport <= lbttcp_source_port_high))
 449         {
 450             is_transport_client_packet = true;
 451         }
 452     }
 453     else
 454     {
 455         if ((pinfo->destport >= tag->source_port_low) && (pinfo->destport <= tag->source_port_high))
 456         {
 457             is_transport_client_packet = true;
 458         }
 459     }
 460     return (is_transport_client_packet);
 461 }
 462
 463 static unsigned get_lbttcp_pdu_length(packet_info * pinfo _U_, tvbuff_t * tvb,
 464                                    int offset, void *data _U_)
 465 {
 466     return lbmc_get_message_length(tvb, offset);
 467 }
 468
 469 static int dissect_lbttcp_pdu(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * dissector_data _U_)
 470 {
 471     proto_tree * lbttcp_tree = NULL;
 472     proto_item * ti = NULL;
 473     char * tag_name = NULL;
 474     int len_dissected;
 475     const lbttcp_tag_entry_t * tag = NULL;
 476     uint64_t channel = LBM_CHANNEL_NO_CHANNEL;
 477     uint32_t client_id = 0;
 478     bool from_source = false;
 479     bool transport_packet = false;
 480
 481     if (lbttcp_use_tag)
 482     {
 483         tag = lbttcp_tag_locate(pinfo);
 484         tag_name = lbttcp_tag_find(pinfo);
 485     }
 486     if (tag_name != NULL)
 487     {
 488         ti = proto_tree_add_protocol_format(tree, proto_lbttcp, tvb, 0, -1, "LBT-TCP Protocol (Tag: %s)", tag_name);
 489     }
 490     else
 491     {
 492         ti = proto_tree_add_protocol_format(tree, proto_lbttcp, tvb, 0, -1, "LBT-TCP Protocol");
 493     }
 494     lbttcp_tree = proto_item_add_subtree(ti, ett_lbttcp);
 495     if (tag_name != NULL)
 496     {
 497         proto_item * item = NULL;
 498
 499         item = proto_tree_add_string(lbttcp_tree, hf_lbttcp_tag, tvb, 0, 0, tag_name);
 500         proto_item_set_generated(item);
 501     }
 502     if (lbttcp_packet_is_transport_source(pinfo, tag))
 503     {
 504         from_source = true;
 505         transport_packet = true;
 506     }
 507     else if (lbttcp_packet_is_transport_client(pinfo, tag))
 508     {
 509         from_source = false;
 510         transport_packet = true;
 511     }
 512     if (transport_packet)
 513     {
 514         address source_address;
 515         address client_address;
 516         uint16_t srcport;
 517         uint16_t clntport;
 518         uint32_t sid = 0;
 519         lbttcp_transport_t * transport = NULL;
 520         lbttcp_client_transport_t * client = NULL;
 521
 522         if (from_source)
 523         {
 524             copy_address_shallow(&source_address, &(pinfo->src));
 525             srcport = pinfo->srcport;
 526             copy_address_shallow(&client_address, &(pinfo->dst));
 527             clntport = pinfo->destport;
 528         }
 529         else
 530         {
 531             copy_address_shallow(&source_address, &(pinfo->dst));
 532             srcport = pinfo->destport;
 533             copy_address_shallow(&client_address, &(pinfo->src));
 534             clntport = pinfo->srcport;
 535         }
 536         /* See if we have a matching transport with no session ID. */
 537         transport = lbttcp_transport_find(&source_address, srcport, sid, pinfo->num);
 538         if (transport == NULL)
 539         {
 540             /* See if we know about a SID */
 541             if (lbttcp_transport_sid_find(&source_address, srcport, pinfo->num, &sid))
 542             {
 543                 transport = lbttcp_transport_find(&source_address, srcport, sid, pinfo->num);
 544             }
 545         }
 546         if (transport != NULL)
 547         {
 548             channel = transport->channel;
 549             /* See if we already know about this client */
 550             client = lbttcp_client_transport_find(transport, &client_address, clntport, pinfo->num);
 551             if (client == NULL)
 552             {
 553                 /* No - add it. */
 554                 client = lbttcp_client_transport_add(transport, &client_address, clntport, pinfo->num);
 555             }
 556             if (client != NULL)
 557             {
 558                 client_id = client->id;
 559             }
 560         }
 561         else
 562         {
 563             if (PINFO_FD_VISITED(pinfo))
 564             {
 565                 /* No TIR and no session ID seen, so create the transport */
 566                 transport = lbttcp_transport_add(&source_address, srcport, 0, pinfo->num);
 567                 if (transport != NULL)
 568                 {
 569                     channel = transport->channel;
 570                     client = lbttcp_client_transport_add(transport, &client_address, clntport, pinfo->num);
 571                     if (client != NULL)
 572                     {
 573                         client_id = client->id;
 574                     }
 575                 }
 576             }
 577             else
 578             {
 579                 /* Defer determining the channel. */
 580                 if (from_source)
 581                 {
 582                     channel = lbm_channel_assign_unknown_transport_source_lbttcp();
 583                 }
 584                 else
 585                 {
 586                     channel = lbm_channel_assign_unknown_transport_client_lbttcp();
 587                 }
 588             }
 589         }
 590     }
 591     else
 592     {
 593         channel = lbm_channel_assign_unknown_stream_tcp();
 594     }
 595     if (lbm_channel_is_known(channel))
 596     {
 597         proto_item * channel_item = NULL;
 598         proto_tree * channel_tree = NULL;
 599
 600         channel_item = proto_tree_add_item(lbttcp_tree, hf_lbttcp_channel, tvb, 0, 0, ENC_NA);
 601         proto_item_set_generated(channel_item);
 602         channel_tree = proto_item_add_subtree(channel_item, ett_lbttcp_channel);
 603         channel_item = proto_tree_add_uint64(channel_tree, hf_lbttcp_channel_id, tvb, 0, 0, channel);
 604         proto_item_set_generated(channel_item);
 605         channel_item = proto_tree_add_uint(channel_tree, hf_lbttcp_channel_client, tvb, 0, 0, client_id);
 606         proto_item_set_generated(channel_item);
 607     }
 608     len_dissected = lbmc_dissect_lbmc_packet(tvb, 0, pinfo, tree, tag_name, channel);
 609     return (len_dissected);
 610 }
 611
 612 /*
 613  * dissect_lbttcp_real - The "common" dissection for LBT-TCP
 614  */
 615 static int dissect_lbttcp_real(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data _U_)
 616 {
 617     char * tag_name = NULL;
 618
 619     col_set_str(pinfo->cinfo, COL_PROTOCOL, "LBT-TCP");
 620     col_clear(pinfo->cinfo, COL_INFO);
 621     if (lbttcp_use_tag)
 622     {
 623         tag_name = lbttcp_tag_find(pinfo);
 624     }
 625     if (tag_name != NULL)
 626     {
 627         col_add_fstr(pinfo->cinfo, COL_INFO, "[Tag: %s]", tag_name);
 628     }
 629     col_set_fence(pinfo->cinfo, COL_INFO);
 630     tcp_dissect_pdus(tvb, pinfo, tree, true, lbmc_get_minimum_length(), /* Need at least the msglen */
 631         get_lbttcp_pdu_length, dissect_lbttcp_pdu, NULL);
 632
 633     return tvb_captured_length(tvb);
 634 }
 635
 636 /*
 637  * dissect_lbttcp - The dissector for LBT-TCP
 638  */
 639 static int dissect_lbttcp(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data)
 640 {
 641     if (!lbmc_test_lbmc_header(tvb, 0))
 642         return 0;
 643
 644     return dissect_lbttcp_real(tvb, pinfo, tree, data);
 645 }
 646
 647 static bool test_lbttcp_packet(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data)
 648 {
 649     /* Destination address must be IPV4 and 4 bytes in length. */
 650     if ((pinfo->dst.type != AT_IPv4) || (pinfo->dst.len != 4))
 651     {
 652         return false;
 653     }
 654
 655     if (lbttcp_use_tag)
 656     {
 657         if (lbttcp_tag_find(pinfo) != NULL)
 658         {
 659             dissect_lbttcp_real(tvb, pinfo, tree, data);
 660             return true;
 661         }
 662         else
 663         {
 664             return false;
 665         }
 666     }
 667
 668     /*
 669         Source port or destination port must be in the source port range, or destination port must be in
 670         the request port range, or either port in the UME store port range.
 671     */
 672     if (!(((pinfo->srcport >= lbttcp_source_port_low) && (pinfo->srcport <= lbttcp_source_port_high))
 673           || ((pinfo->destport >= lbttcp_source_port_low) && (pinfo->destport <= lbttcp_source_port_high))
 674           || ((pinfo->srcport >= lbttcp_request_port_low) && (pinfo->srcport <= lbttcp_request_port_high))
 675           || ((pinfo->destport >= lbttcp_request_port_low) && (pinfo->destport <= lbttcp_request_port_high))
 676           || ((pinfo->srcport >= lbttcp_store_port_low) && (pinfo->srcport <= lbttcp_store_port_high))
 677           || ((pinfo->destport >= lbttcp_store_port_low) && (pinfo->destport <= lbttcp_store_port_high))))
 678     {
 679         return false;
 680     }
 681
 682     if (!lbmc_test_lbmc_header(tvb, 0))
 683         return false;
 684
 685     /* One of ours. Probably. */
 686     dissect_lbttcp_real(tvb, pinfo, tree, data);
 687     return true;
 688 }
 689
 690 /* Register all the bits needed with the filtering engine */
 691 void proto_register_lbttcp(void)
 692 {
 693     static hf_register_info hf[] =
 694     {
 695         { &hf_lbttcp_tag,
 696             { "Tag", "lbttcp.tag", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
 697         { &hf_lbttcp_channel,
 698             { "Channel", "lbttcp.channel", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
 699         { &hf_lbttcp_channel_id,
 700             { "Channel ID", "lbttcp.channel.channel", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } },
 701         { &hf_lbttcp_channel_client,
 702             { "Channel Client", "lbttcp.channel.client", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
 703     };
 704     static int * ett[] =
 705     {
 706         &ett_lbttcp,
 707         &ett_lbttcp_channel
 708     };
 709     module_t * lbttcp_module;
 710     uat_t * tag_uat;
 711
 712     proto_lbttcp = proto_register_protocol("LBT TCP Protocol", "LBT-TCP", "lbttcp");
 713
 714     proto_register_field_array(proto_lbttcp, hf, array_length(hf));
 715     proto_register_subtree_array(ett, array_length(ett));
 716
 717     lbttcp_dissector_handle = register_dissector("lbttcp", dissect_lbttcp, proto_lbttcp);
 718
 719     lbttcp_module = prefs_register_protocol_subtree("29West", proto_lbttcp, proto_reg_handoff_lbttcp);
 720     prefs_register_uint_preference(lbttcp_module,
 721         "source_port_low",
 722         "Source port range low (default " MAKESTRING(LBTTCP_DEFAULT_SOURCE_PORT_LOW)")",
 723         "Set the low end of the LBT-TCP source TCP port range (context transport_tcp_port_low)",
 724         10,
 725         &global_lbttcp_source_port_low);
 726
 727     prefs_register_uint_preference(lbttcp_module,
 728         "source_port_high",
 729         "Source port range high (default " MAKESTRING(LBTTCP_DEFAULT_SOURCE_PORT_HIGH)")",
 730         "Set the high end of the LBT-TCP source TCP port range (context transport_tcp_port_high)",
 731         10,
 732         &global_lbttcp_source_port_high);
 733
 734     prefs_register_uint_preference(lbttcp_module,
 735         "request_port_low",
 736         "Request port range low (default " MAKESTRING(LBTTCP_DEFAULT_REQUEST_PORT_LOW)")",
 737         "Set the low end of the LBT-TCP request TCP port range (context request_tcp_port_low)",
 738         10,
 739         &global_lbttcp_request_port_low);
 740
 741     prefs_register_uint_preference(lbttcp_module,
 742         "request_port_high",
 743         "Request port range high (default " MAKESTRING(LBTTCP_DEFAULT_REQUEST_PORT_HIGH)")",
 744         "Set the high end of the LBT-TCP request TCP port range (context request_tcp_port_high)",
 745         10,
 746         &global_lbttcp_request_port_high);
 747
 748     prefs_register_uint_preference(lbttcp_module,
 749         "store_port_low",
 750         "UME Store port range low (default " MAKESTRING(LBTTCP_DEFAULT_STORE_PORT_LOW)")",
 751         "Set the low end of the LBT-TCP UME Store TCP port range",
 752         10,
 753         &global_lbttcp_store_port_low);
 754
 755     prefs_register_uint_preference(lbttcp_module,
 756         "store_port_high",
 757         "UME Store port range high (default " MAKESTRING(LBTTCP_DEFAULT_STORE_PORT_HIGH)")",
 758         "Set the high end of the LBT-TCP UME Store TCP port range",
 759         10,
 760         &global_lbttcp_store_port_high);
 761
 762     prefs_register_bool_preference(lbttcp_module,
 763         "use_lbttcp_domain",
 764         "Use LBT-TCP tag table",
 765         "Use table of LBT-TCP tags to decode the packet instead of above values",
 766         &global_lbttcp_use_tag);
 767     tag_uat = uat_new("LBT-TCP tag definitions",
 768         sizeof(lbttcp_tag_entry_t),
 769         "lbttcp_domains",
 770         true,
 771         (void * *)&lbttcp_tag_entry,
 772         &lbttcp_tag_count,
 773         UAT_AFFECTS_DISSECTION,
 774         NULL,
 775         lbttcp_tag_copy_cb,
 776         lbttcp_tag_update_cb,
 777         lbttcp_tag_free_cb,
 778         NULL,
 779         NULL,
 780         lbttcp_tag_array);
 781     prefs_register_uat_preference(lbttcp_module,
 782         "tnw_lbttcp_tags",
 783         "LBT-TCP Tags",
 784         "A table to define LBT-TCP tags",
 785         tag_uat);
 786 }
 787
 788 /* The registration hand-off routine */
 789 void proto_reg_handoff_lbttcp(void)
 790 {
 791     static bool already_registered = false;
 792
 793     if (!already_registered)
 794     {
 795         dissector_add_for_decode_as_with_preference("tcp.port", lbttcp_dissector_handle);
 796         heur_dissector_add("tcp", test_lbttcp_packet, "LBT over TCP", "lbttcp_tcp", proto_lbttcp, HEURISTIC_ENABLE);
 797     }
 798
 799     /* Make sure the source port low is <= the source port high. If not, don't change them. */
 800     if (global_lbttcp_source_port_low <= global_lbttcp_source_port_high)
 801     {
 802         lbttcp_source_port_low = global_lbttcp_source_port_low;
 803         lbttcp_source_port_high = global_lbttcp_source_port_high;
 804     }
 805
 806     /* Make sure the request port low is <= the request port high. If not, don't change them. */
 807     if (global_lbttcp_request_port_low <= global_lbttcp_request_port_high)
 808     {
 809         lbttcp_request_port_low = global_lbttcp_request_port_low;
 810         lbttcp_request_port_high = global_lbttcp_request_port_high;
 811     }
 812
 813     /* Make sure the store port low is <= the store port high. If not, don't change them. */
 814     if (global_lbttcp_store_port_low <= global_lbttcp_store_port_high)
 815     {
 816         lbttcp_store_port_low = global_lbttcp_store_port_low;
 817         lbttcp_store_port_high = global_lbttcp_store_port_high;
 818     }
 819
 820     lbttcp_use_tag = global_lbttcp_use_tag;
 821
 822     already_registered = true;
 823 }
 824
 825 /*
 826  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 827  *
 828  * Local variables:
 829  * c-basic-offset: 4
 830  * tab-width: 8
 831  * indent-tabs-mode: nil
 832  * End:
 833  *
 834  * vi: set shiftwidth=4 tabstop=8 expandtab:
 835  * :indentSize=4:tabSize=8:noTabs=true:
 836  */