From 2f4ca9c8d979029e7893f2843045f516e3d0b844 Mon Sep 17 00:00:00 2001 From: Michael Mann Date: Mon, 7 Apr 2014 16:33:51 -0400 Subject: Initial checkin of LBM aka 29West dissectors. See Bug 9718. Change-Id: If8fcfe1971c8863f370e440f64c36eb7566f6852 Reviewed-on: https://code.wireshark.org/review/113 Reviewed-by: Michael Mann --- epan/dissectors/Makefile.common | 17 +- epan/dissectors/packet-lbm.c | 376 + epan/dissectors/packet-lbm.h | 329 + epan/dissectors/packet-lbmc.c | 14178 +++++++++++++++++++++++++++++++++++ epan/dissectors/packet-lbmpdm.c | 1522 ++++ epan/dissectors/packet-lbmpdmtcp.c | 467 ++ epan/dissectors/packet-lbmr.c | 6843 +++++++++++++++++ epan/dissectors/packet-lbtrm.c | 1996 +++++ epan/dissectors/packet-lbtrm.h | 71 + epan/dissectors/packet-lbtru.c | 2002 +++++ epan/dissectors/packet-lbtru.h | 82 + epan/dissectors/packet-lbttcp.c | 844 +++ epan/dissectors/packet-lbttcp.h | 70 + 13 files changed, 28794 insertions(+), 3 deletions(-) create mode 100644 epan/dissectors/packet-lbm.c create mode 100644 epan/dissectors/packet-lbm.h create mode 100644 epan/dissectors/packet-lbmc.c create mode 100644 epan/dissectors/packet-lbmpdm.c create mode 100644 epan/dissectors/packet-lbmpdmtcp.c create mode 100644 epan/dissectors/packet-lbmr.c create mode 100644 epan/dissectors/packet-lbtrm.c create mode 100644 epan/dissectors/packet-lbtrm.h create mode 100644 epan/dissectors/packet-lbtru.c create mode 100644 epan/dissectors/packet-lbtru.h create mode 100644 epan/dissectors/packet-lbttcp.c create mode 100644 epan/dissectors/packet-lbttcp.h (limited to 'epan/dissectors') diff --git a/epan/dissectors/Makefile.common b/epan/dissectors/Makefile.common index cbd2ad30e8..0466716f26 100644 --- a/epan/dissectors/Makefile.common +++ b/epan/dissectors/Makefile.common @@ -787,6 +787,14 @@ DISSECTOR_SRC = \ packet-lapdm.c \ packet-laplink.c \ packet-lapsat.c \ + packet-lbm.c \ + packet-lbmc.c \ + packet-lbmpdm.c \ + packet-lbmpdmtcp.c \ + packet-lbmr.c \ + packet-lbtrm.c \ + packet-lbtru.c \ + packet-lbttcp.c \ packet-ldp.c \ packet-ldss.c \ packet-lg8979.c \ @@ -1482,6 +1490,9 @@ DISSECTOR_INCLUDES = \ packet-kerberos.h \ packet-klm.h \ packet-l2tp.h \ + packet-lbm.h \ + packet-lbtrm.h \ + packet-lbtru.h \ packet-ldap.h \ packet-lcsap.h \ packet-ldp.h \ @@ -1696,9 +1707,9 @@ IPMI_SUBPARSERS = \ # directory, but they're not dissectors themselves, i.e. they're not # used to generate "register.c"). DISSECTOR_SUPPORT_SRC = \ - $(IPMI_SUBPARSERS) \ - packet-dcerpc-nt.c \ - usb.c \ + $(IPMI_SUBPARSERS) \ + packet-dcerpc-nt.c \ + usb.c \ register.c # this target needed for distribution only diff --git a/epan/dissectors/packet-lbm.c b/epan/dissectors/packet-lbm.c new file mode 100644 index 0000000000..bd2c250c2d --- /dev/null +++ b/epan/dissectors/packet-lbm.c @@ -0,0 +1,376 @@ +/* packet-lbm.c + * Routines for LBM Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include +#include +#include +#include +#include "packet-lbm.h" + +/* Protocol handle */ +static int lbm_protocol_handle = -1; + +/*----------------------------------------------------------------------------*/ +/* Value translation tables. */ +/*----------------------------------------------------------------------------*/ + +const true_false_string lbm_ignore_flag = +{ + "May be ignored", + "Must be processed" +}; + +#define LBM_WILDCARD_PATTERN_TYPE_PCRE 1 +#define LBM_WILDCARD_PATTERN_TYPE_REGEX 2 + +const value_string lbm_wildcard_pattern_type[] = +{ + { LBM_WILDCARD_PATTERN_TYPE_PCRE, "Perl Compatible Regular Expression (PCRE)" }, + { LBM_WILDCARD_PATTERN_TYPE_REGEX, "POSIX Extended Regular Expression (REGEX)" }, + { 0x0, NULL } +}; + +const value_string lbm_wildcard_pattern_type_short[] = +{ + { LBM_WILDCARD_PATTERN_TYPE_PCRE, "PCRE" }, + { LBM_WILDCARD_PATTERN_TYPE_REGEX, "REGEX" }, + { 0x0, NULL } +}; + +/* Initialization function, called whenever Wireshark loads a new capture, etc. */ +static void lbm_init(void) +{ + lbm_channel_reset(); +} + +/* The registration hand-off routine */ +void proto_reg_handoff_lbm(void) +{ +} + +/* Register all the bits needed with the filtering engine */ +void proto_register_lbm(void) +{ + lbm_protocol_handle = proto_register_protocol("LBM Protocol", "LBM", "lbm"); + (void)prefs_register_protocol_subtree("29West", lbm_protocol_handle, proto_reg_handoff_lbm); + + register_init_routine(lbm_init); +} + +/*----------------------------------------------------------------------------*/ +/* Channel interface. */ +/*----------------------------------------------------------------------------*/ +/* + lbm_next_channel_value is a counter (akin to tcp_stream_count in packet-tcp.c) used to assign a unique index to an LBM communication + stream or transport session. The actual channel value consists of: + - The lower 52 bits of the counter, shifted left 12 bits + - A 4-bit source/client classification (for unicast channels), shifted left 8 bits + - An 8-bit channel type + + 6 1 1 0 0 0 + 3 2 1 8 7 0 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Counter | S/C | Type | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + The counter wraps at 0x000ffffffffffffe, and is reset to 1 whenever Wireshark invokes any init routines registered via + register_init_routine() (the call to lbm_channel_reset() is in packet-lbm.c). + + Special values are used as placeholders to indicate an as-yet-unknown transport or stream TCP channel. +*/ + +static guint64 lbm_next_channel_value = 1; + +#define LBM_CHANNEL_TYPE_MASK G_GUINT64_CONSTANT(0x00000000000000ff) +#define LBM_CHANNEL_VALUE_LIMIT_MASK G_GUINT64_CONSTANT(0x000ffffffffffffff) +#define LBM_CHANNEL_MAX_VALUE G_GUINT64_CONSTANT(0x000ffffffffffffe) + +#define LBM_CHANNEL_VALUE_UNKNOWN G_GUINT64_CONSTANT(0xfffffffffffff000) +#define LBM_CHANNEL_VALUE_UNKNOWN_SOURCE G_GUINT64_CONSTANT(0xfffffffffffff100) +#define LBM_CHANNEL_VALUE_UNKNOWN_CLIENT G_GUINT64_CONSTANT(0xfffffffffffff200) +#define LBM_CHANNEL_UNKNOWN_TRANSPORT_SOURCE_LBTTCP (LBM_CHANNEL_VALUE_UNKNOWN_SOURCE | LBM_CHANNEL_TRANSPORT_LBTTCP) +#define LBM_CHANNEL_UNKNOWN_TRANSPORT_CLIENT_LBTTCP (LBM_CHANNEL_VALUE_UNKNOWN_CLIENT | LBM_CHANNEL_TRANSPORT_LBTTCP) +#define LBM_CHANNEL_UNKNOWN_STREAM_TCP (LBM_CHANNEL_VALUE_UNKNOWN | LBM_CHANNEL_STREAM_TCP) + +#define LBM_CHANNEL_TYPE(ch) ((guint8)(ch & LBM_CHANNEL_TYPE_MASK)) + +void lbm_channel_reset(void) +{ + lbm_next_channel_value = 1; +} + +guint64 lbm_channel_assign(guint8 channel_type) +{ + guint64 ch; + guint64 ch_counter = lbm_next_channel_value++; + + if (lbm_next_channel_value == LBM_CHANNEL_MAX_VALUE) + { + lbm_next_channel_value = 1; + } + ch = ((guint64)((ch_counter & LBM_CHANNEL_VALUE_LIMIT_MASK) << LBM_CHANNEL_VALUE_SHIFT_COUNT)) | channel_type; + return (ch); +} + +gboolean lbm_channel_is_transport(guint64 channel) +{ + guint8 ch_type; + + ch_type = LBM_CHANNEL_TYPE(channel); + switch (ch_type) + { + case LBM_CHANNEL_TRANSPORT_LBTTCP: + case LBM_CHANNEL_TRANSPORT_LBTRU: + case LBM_CHANNEL_TRANSPORT_LBTRM: + case LBM_CHANNEL_TRANSPORT_LBTIPC: + case LBM_CHANNEL_TRANSPORT_LBTRDMA: + case LBM_CHANNEL_TRANSPORT_LBTSMX: + return (TRUE); + break; + default: + break; + } + return (FALSE); +} + +guint8 lbm_channel_type(guint64 channel) +{ + guint8 ch_type; + + ch_type = LBM_CHANNEL_TYPE(channel); + return (ch_type); +} + +guint64 lbm_channel_assign_unknown_transport_source_lbttcp(void) +{ + return (LBM_CHANNEL_UNKNOWN_TRANSPORT_SOURCE_LBTTCP); +} + +guint64 lbm_channel_assign_unknown_transport_client_lbttcp(void) +{ + return (LBM_CHANNEL_UNKNOWN_TRANSPORT_CLIENT_LBTTCP); +} + +guint64 lbm_channel_assign_unknown_stream_tcp(void) +{ + return (LBM_CHANNEL_UNKNOWN_STREAM_TCP); +} + +gboolean lbm_channel_is_unknown_transport_lbttcp(guint64 channel) +{ + return (lbm_channel_is_unknown_transport_source_lbttcp(channel) || lbm_channel_is_unknown_transport_client_lbttcp(channel)); +} + +gboolean lbm_channel_is_unknown_transport_source_lbttcp(guint64 channel) +{ + if (channel == LBM_CHANNEL_UNKNOWN_TRANSPORT_SOURCE_LBTTCP) + { + return (TRUE); + } + return (FALSE); +} + +gboolean lbm_channel_is_unknown_transport_client_lbttcp(guint64 channel) +{ + if (channel == LBM_CHANNEL_UNKNOWN_TRANSPORT_CLIENT_LBTTCP) + { + return (TRUE); + } + return (FALSE); +} + +gboolean lbm_channel_is_unknown_stream_tcp(guint64 channel) +{ + if (channel == LBM_CHANNEL_UNKNOWN_STREAM_TCP) + { + return (TRUE); + } + return (FALSE); +} + +gboolean lbm_channel_is_known(guint64 channel) +{ + return (!lbm_channel_is_unknown_transport_lbttcp(channel) && !lbm_channel_is_unknown_stream_tcp(channel)); +} + +guint64 lbm_channel_id(guint64 channel) +{ + guint64 id; + + id = (channel & LBM_CHANNEL_VALUE_MASK) >> LBM_CHANNEL_VALUE_SHIFT_COUNT; + return (id); +} + +/*----------------------------------------------------------------------------*/ +/* Frame/SQN interface. */ +/*----------------------------------------------------------------------------*/ +lbm_transport_frame_t * lbm_transport_frame_add(wmem_tree_t * list, guint8 type, guint32 frame, guint32 sqn, gboolean retransmission) +{ + lbm_transport_frame_t * frame_entry = NULL; + + /* Locate the frame. */ + frame_entry = (lbm_transport_frame_t *) wmem_tree_lookup32(list, frame); + if (frame_entry != NULL) + { + return (frame_entry); + } + frame_entry = wmem_new(wmem_file_scope(), lbm_transport_frame_t); + frame_entry->frame = frame; + frame_entry->type = type; + frame_entry->sqn = sqn; + frame_entry->previous_frame = 0; + frame_entry->previous_type_frame = 0; + frame_entry->next_frame = 0; + frame_entry->next_type_frame = 0; + frame_entry->retransmission = retransmission; + frame_entry->sqn_gap = 0; + frame_entry->ooo_gap = 0; + frame_entry->duplicate = FALSE; + wmem_tree_insert32(list, frame, (void *) frame_entry); + return (frame_entry); +} + +lbm_transport_sqn_t * lbm_transport_sqn_add(wmem_tree_t * list, lbm_transport_frame_t * frame) +{ + lbm_transport_sqn_t * sqn_entry = NULL; + lbm_transport_sqn_frame_t * frame_entry = NULL; + + /* Locate the SQN. */ + sqn_entry = (lbm_transport_sqn_t *) wmem_tree_lookup32(list, frame->sqn); + if (sqn_entry == NULL) + { + sqn_entry = wmem_new(wmem_file_scope(), lbm_transport_sqn_t); + sqn_entry->sqn = frame->sqn; + sqn_entry->frame_count = 0; + sqn_entry->frame = wmem_tree_new(wmem_file_scope()); + wmem_tree_insert32(list, frame->sqn, (void *) sqn_entry); + } + /* Add this frame to the list of frames this SQN appears in. */ + frame_entry = wmem_new(wmem_file_scope(), lbm_transport_sqn_frame_t); + frame_entry->frame = frame->frame; + frame_entry->retransmission = frame->retransmission; + wmem_tree_insert32(sqn_entry->frame, frame->frame, (void *) frame_entry); + sqn_entry->frame_count++; + return (sqn_entry); +} + +/*----------------------------------------------------------------------------*/ +/* Topic interface. */ +/*----------------------------------------------------------------------------*/ +static wmem_tree_t * lbm_topic_table = NULL; + +#define LBM_TOPIC_KEY_ELEMENT_COUNT 3 +#define LBM_TOPIC_KEY_ELEMENT_CHANNEL_HIGH 0 +#define LBM_TOPIC_KEY_ELEMENT_CHANNEL_LOW 1 +#define LBM_TOPIC_KEY_ELEMENT_TOPIC_INDEX 2 + +struct lbm_topic_t_stct; +typedef struct lbm_topic_t_stct lbm_topic_t; + +typedef struct +{ + guint64 channel; + guint32 topic_idx; + lbm_topic_t * topic; +} lbm_topic_key_t; + +struct lbm_topic_t_stct +{ + lbm_topic_key_t key; + char * topic; +}; + +void lbm_topic_init(void) +{ + lbm_topic_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); +} + +static void lbm_topic_build_key(guint32 * key_value, wmem_tree_key_t * key, guint64 channel, guint32 topic_index) +{ + key_value[LBM_TOPIC_KEY_ELEMENT_CHANNEL_HIGH] = (guint32) ((channel >> 32) & 0xffffffff); + key_value[LBM_TOPIC_KEY_ELEMENT_CHANNEL_LOW] = (guint32) ((channel & 0xffffffff) >> 32); + key_value[LBM_TOPIC_KEY_ELEMENT_TOPIC_INDEX] = topic_index; + key[0].length = LBM_TOPIC_KEY_ELEMENT_COUNT; + key[0].key = key_value; + key[1].length = 0; + key[1].key = NULL; +} + +static lbm_topic_t * lbm_topic_locate(guint64 channel, guint32 topic_index) +{ + lbm_topic_t * entry = NULL; + guint32 keyval[LBM_TOPIC_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + lbm_topic_build_key(keyval, tkey, channel, topic_index); + entry = (lbm_topic_t *) wmem_tree_lookup32_array(lbm_topic_table, tkey); + return (entry); +} + +const char * lbm_topic_find(guint64 channel, guint32 topic_index) +{ + lbm_topic_t * entry = NULL; + const char * topic = NULL; + + entry = lbm_topic_locate(channel, topic_index); + if (entry != NULL) + { + topic = entry->topic; + } + return (topic); +} + +void lbm_topic_add(guint64 channel, guint32 topic_index, const char * name) +{ + lbm_topic_t * entry; + guint32 keyval[LBM_TOPIC_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbm_topic_locate(channel, topic_index); + if (entry != NULL) + { + return; + } + entry = wmem_new(wmem_file_scope(), lbm_topic_t); + entry->key.channel = channel; + entry->key.topic_idx = topic_index; + entry->key.topic = entry; + entry->topic = wmem_strdup(wmem_file_scope(), name); + lbm_topic_build_key(keyval, tkey, channel, topic_index); + wmem_tree_insert32_array(lbm_topic_table, tkey, (void *) entry); +} + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbm.h b/epan/dissectors/packet-lbm.h new file mode 100644 index 0000000000..1757129edc --- /dev/null +++ b/epan/dissectors/packet-lbm.h @@ -0,0 +1,329 @@ +/* packet-lbm.h + * Definitions for LBM packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef PACKET_LBM_H_INCLUDED +#define PACKET_LBM_H_INCLUDED + +#include "config.h" +#include +#include +#if HAVE_NETINET_IN_H + #include +#endif +#include +#include +#include +#include +#include +#include + +typedef guint8 lbm_uint8_t; +typedef guint16 lbm_uint16_t; +typedef guint32 lbm_uint32_t; +typedef guint64 lbm_uint64_t; +#define SIZEOF(TYPE, MEMBER) (gint)(sizeof(((TYPE *)0)->MEMBER)) +#define OFFSETOF(TYPE, MEMBER) (gint)((size_t) &((TYPE *)0)->MEMBER) +#define STRINGIZE(a) #a +#define MAKESTRING(a) STRINGIZE(a) +#define LBM_OTID_BLOCK_SZ 32 +#define LBM_CONTEXT_INSTANCE_BLOCK_SZ 8 +#define LBM_HMAC_BLOCK_SZ 20 + +/* UAT macros for IPV4 fields. */ +#define UAT_IPV4_CB_DEF(basename,field_name,rec_t) \ + static gboolean basename ## _ ## field_name ## _chk_cb(void * u1 _U_, const char * strptr, unsigned len _U_, const void * u2 _U_, const void * u3 _U_, const char ** err) \ + { \ + struct in_addr addr; \ + if (inet_aton(strptr, &addr) == 0) \ + { \ + *err = "invalid address"; \ + return (FALSE); \ + } \ + return (TRUE); \ + } \ + static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, unsigned len, const void* u1 _U_, const void* u2 _U_) \ + { \ + struct in_addr addr; \ + char* new_buf = g_strndup(buf,len); \ + g_free((((rec_t*)rec)->field_name)); \ + (((rec_t*)rec)->field_name) = new_buf; \ + inet_aton(new_buf, &addr); \ + (((rec_t*)rec)->field_name ## _val_h) = g_ntohl(addr.s_addr); \ + } \ + static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* u1 _U_, const void* u2 _U_) \ + {\ + if (((rec_t*)rec)->field_name ) \ + { \ + *out_ptr = (((rec_t*)rec)->field_name); \ + *out_len = (unsigned)strlen((((rec_t*)rec)->field_name)); \ + } \ + else \ + { \ + *out_ptr = ""; \ + *out_len = 0; \ + } \ + } + +#define UAT_FLD_IPV4(basename,field_name,title,desc) \ + {#field_name, title, PT_TXTMOD_STRING,{basename ## _ ## field_name ## _chk_cb,basename ## _ ## field_name ## _set_cb,basename ## _ ## field_name ## _tostr_cb},{0,0,0},0,desc,FLDFILL} + +/* UAT macros for IPV4 Multicast fields. */ +#define UAT_IPV4_MC_CB_DEF(basename,field_name,rec_t) \ + static gboolean basename ## _ ## field_name ## _chk_cb(void * u1 _U_, const char * strptr, unsigned len _U_, const void * u2 _U_, const void * u3 _U_, const char ** err) \ + { \ + struct in_addr addr; \ + if (inet_aton(strptr, &addr) == 0) \ + { \ + *err = "invalid address"; \ + return (FALSE); \ + } \ + if (!IN_MULTICAST(g_ntohl(addr.s_addr)) && (g_ntohl(addr.s_addr) != 0)) \ + { \ + *err = "invalid multicast address"; \ + return (FALSE); \ + } \ + return (TRUE); \ + } \ + static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, unsigned len, const void* u1 _U_, const void* u2 _U_) \ + { \ + struct in_addr addr; \ + char* new_buf = g_strndup(buf,len); \ + g_free((((rec_t*)rec)->field_name)); \ + (((rec_t*)rec)->field_name) = new_buf; \ + inet_aton(new_buf, &addr); \ + (((rec_t*)rec)->field_name ## _val_h) = g_ntohl(addr.s_addr); \ + } \ + static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* u1 _U_, const void* u2 _U_) \ + {\ + if (((rec_t*)rec)->field_name ) \ + { \ + *out_ptr = (((rec_t*)rec)->field_name); \ + *out_len = (unsigned)strlen((((rec_t*)rec)->field_name)); \ + } \ + else \ + { \ + *out_ptr = ""; \ + *out_len = 0; \ + } \ + } + +#define UAT_FLD_IPV4_MC(basename,field_name,title,desc) \ + {#field_name, title, PT_TXTMOD_STRING,{basename ## _ ## field_name ## _chk_cb,basename ## _ ## field_name ## _set_cb,basename ## _ ## field_name ## _tostr_cb},{0,0,0},0,desc,FLDFILL} + +typedef struct +{ + guint32 domain; + address addr; + guint16 port; +} lbm_uim_stream_destination_t; + +typedef struct +{ + guint8 ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbm_uim_stream_ctxinst_t; + +typedef enum +{ + lbm_uim_instance_stream, + lbm_uim_domain_stream +} lbm_uim_stream_type_t; + +typedef struct +{ + lbm_uim_stream_type_t type; + union + { + lbm_uim_stream_destination_t dest; + lbm_uim_stream_ctxinst_t ctxinst; + } stream_info; +} lbm_uim_stream_endpoint_t; + +typedef struct +{ + guint64 channel; + guint32 sqn; + lbm_uim_stream_endpoint_t endpoint_a; + lbm_uim_stream_endpoint_t endpoint_b; + const gchar * description; +} lbm_uim_stream_info_t; + +typedef struct +{ + guint64 channel; + guint32 substream_id; + guint32 bytes; + lbm_uim_stream_endpoint_t endpoint_a; + lbm_uim_stream_endpoint_t endpoint_b; +} lbm_uim_stream_tap_info_t; + +typedef struct +{ + gchar * transport; + guint8 type; + gboolean retransmission; + guint32 sqn; + guint8 ncf_reason; + guint16 num_sqns; + guint32 * sqns; +} lbm_lbtrm_tap_info_t; + +typedef struct +{ + gchar * transport; + guint8 type; + gboolean retransmission; + guint32 sqn; + guint8 ncf_reason; + guint16 num_sqns; + guint16 creq_type; + guint16 rst_type; + guint32 * sqns; +} lbm_lbtru_tap_info_t; + +#define LBM_TOPIC_OPT_EXFUNC_FFLAG_LJ 0x00000001 +#define LBM_TOPIC_OPT_EXFUNC_FFLAG_UME 0x00000002 +#define LBM_TOPIC_OPT_EXFUNC_FFLAG_UMQ 0x00000004 +#define LBM_TOPIC_OPT_EXFUNC_FFLAG_ULB 0x00000008 + +/* LBT-RM packet types */ +#define LBTRM_PACKET_TYPE_DATA 0x00 +#define LBTRM_PACKET_TYPE_SM 0x02 +#define LBTRM_PACKET_TYPE_NAK 0x03 +#define LBTRM_PACKET_TYPE_NCF 0x04 + +/* LBT-RM NCF reason types */ +#define LBTRM_NCF_REASON_NO_RETRY 0x0 +#define LBTRM_NCF_REASON_IGNORED 0x1 +#define LBTRM_NCF_REASON_RX_DELAY 0x2 +#define LBTRM_NCF_REASON_SHED 0x3 + +/* LBT-RU packet types */ +#define LBTRU_PACKET_TYPE_DATA 0x00 +#define LBTRU_PACKET_TYPE_SM 0x02 +#define LBTRU_PACKET_TYPE_NAK 0x03 +#define LBTRU_PACKET_TYPE_NCF 0x04 +#define LBTRU_PACKET_TYPE_ACK 0x05 +#define LBTRU_PACKET_TYPE_CREQ 0x06 +#define LBTRU_PACKET_TYPE_RST 0x07 + +gboolean lbmc_test_lbmc_header(tvbuff_t * tvb, int offset); +int lbmc_dissect_lbmc_packet(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, const char * tag_name, guint64 channel); +int lbmc_get_minimum_length(void); +guint16 lbmc_get_message_length(tvbuff_t * tvb, int offset); +gboolean lbmpdm_verify_payload(tvbuff_t * tvb, int offset, int * encoding, int * length); +int lbmpdm_dissect_lbmpdm_payload(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, guint64 channel); +int lbmpdm_get_minimum_length(void); +int lbmr_dissect_umq_qmgmt(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree); + +extern const true_false_string lbm_ignore_flag; +extern const value_string lbm_wildcard_pattern_type[]; +extern const value_string lbm_wildcard_pattern_type_short[]; + +/*----------------------------------------------------------------------------*/ +/* Channel interface. */ +/*----------------------------------------------------------------------------*/ +#define LBM_CHANNEL_NO_CHANNEL (~((guint64) 0)) + +#define LBM_CHANNEL_TRANSPORT_LBTTCP 0x00 +#define LBM_CHANNEL_TRANSPORT_LBTRU 0x01 +#define LBM_CHANNEL_TRANSPORT_LBTRM 0x02 +#define LBM_CHANNEL_TRANSPORT_LBTIPC 0x03 +#define LBM_CHANNEL_TRANSPORT_LBTRDMA 0x04 +#define LBM_CHANNEL_TRANSPORT_LBTSMX 0x05 +#define LBM_CHANNEL_STREAM_TCP 0x10 +#define LBM_CHANNEL_TCP 0x20 + +#define LBM_CHANNEL_VALUE_MASK G_GUINT64_CONSTANT(0xfffffffffffff000) +#define LBM_CHANNEL_VALUE_SHIFT_COUNT 12 + +void lbm_channel_reset(void); +guint64 lbm_channel_assign(guint8 channel_type); +gboolean lbm_channel_is_transport(guint64 channel); +guint8 lbm_channel_type(guint64 channel); +guint64 lbm_channel_assign_unknown_transport_source_lbttcp(void); +guint64 lbm_channel_assign_unknown_transport_client_lbttcp(void); +guint64 lbm_channel_assign_unknown_stream_tcp(void); +gboolean lbm_channel_is_unknown_transport_lbttcp(guint64 channel); +gboolean lbm_channel_is_unknown_transport_source_lbttcp(guint64 channel); +gboolean lbm_channel_is_unknown_transport_client_lbttcp(guint64 channel); +gboolean lbm_channel_is_unknown_stream_tcp(guint64 channel); +gboolean lbm_channel_is_known(guint64 channel); + +#define LBM_CHANNEL_ID(ch) ((ch & LBM_CHANNEL_VALUE_MASK) >> LBM_CHANNEL_VALUE_SHIFT_COUNT) + +/*----------------------------------------------------------------------------*/ +/* Frame/SQN interface. */ +/*----------------------------------------------------------------------------*/ +typedef struct +{ + guint32 frame; + guint8 type; + guint32 sqn; + guint32 previous_frame; + guint32 previous_type_frame; + guint32 next_frame; + guint32 next_type_frame; + gboolean retransmission; + guint32 sqn_gap; + guint32 ooo_gap; + gboolean duplicate; +} lbm_transport_frame_t; + +typedef struct +{ + guint32 frame; + gboolean retransmission; +} lbm_transport_sqn_frame_t; + +typedef struct +{ + guint32 sqn; + guint32 frame_count; + wmem_tree_t * frame; /* List of lbm_transport_sqn_frame_t */ +} lbm_transport_sqn_t; + +lbm_transport_frame_t * lbm_transport_frame_add(wmem_tree_t * list, guint8 type, guint32 frame, guint32 sqn, gboolean retransmission); +lbm_transport_sqn_t * lbm_transport_sqn_add(wmem_tree_t * list, lbm_transport_frame_t * frame); + +/*----------------------------------------------------------------------------*/ +/* Topic interface. */ +/*----------------------------------------------------------------------------*/ +void lbm_topic_init(void); +const char * lbm_topic_find(guint64 channel, guint32 topic_index); +void lbm_topic_add(guint64 channel, guint32 topic_index, const char * name); + +#endif + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbmc.c b/epan/dissectors/packet-lbmc.c new file mode 100644 index 0000000000..bd3cfcf7ed --- /dev/null +++ b/epan/dissectors/packet-lbmc.c @@ -0,0 +1,14178 @@ +/* packet-lbmc.c + * Routines for LBMC Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#if HAVE_NETINET_IN_H + #include +#else +typedef unsigned int in_addr_t; +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "packet-lbm.h" +#include "packet-lbttcp.h" + +/*----------------------------------------------------------------------------*/ +/* Stream management. */ +/*----------------------------------------------------------------------------*/ + +/* Instance stream structures. */ +struct lbm_istream_entry_t_stct; +typedef struct lbm_istream_entry_t_stct lbm_istream_entry_t; +struct lbm_istream_substream_entry_t_stct; +typedef struct lbm_istream_substream_entry_t_stct lbm_istream_substream_entry_t; + +struct lbm_istream_substream_entry_t_stct +{ + address src_addr; + guint16 src_port; + address dst_addr; + guint16 dst_port; + guint32 lbm_stream_id; + lbm_istream_entry_t * parent; + guint32 substream_id; + guint32 first_frame; + guint32 last_frame; + guint32 messages; + guint32 bytes; +}; + +struct lbm_istream_entry_t_stct +{ + guint8 ctxinst_1[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; + guint8 ctxinst_2[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; + guint64 channel; + guint32 next_substream_id; + guint32 first_frame; + guint32 last_frame; + guint32 messages; + guint32 bytes; + wmem_tree_t * substream_list; +}; + +/* Domain stream structures */ +struct lbm_dstream_entry_t_stct; +typedef struct lbm_dstream_entry_t_stct lbm_dstream_entry_t; +struct lbm_dstream_substream_entry_t_stct; +typedef struct lbm_dstream_substream_entry_t_stct lbm_dstream_substream_entry_t; + +struct lbm_dstream_substream_entry_t_stct +{ + address src_addr; + guint16 src_port; + address dst_addr; + guint16 dst_port; + guint32 lbm_stream_id; + lbm_dstream_entry_t * parent; + guint32 substream_id; + guint32 first_frame; + guint32 last_frame; + guint32 messages; + guint32 bytes; +}; + +struct lbm_dstream_entry_t_stct +{ + guint32 domain_1; + address addr_1; + guint32 domain_2; + address addr_2; + guint16 port_1; + guint16 port_2; + guint64 channel; + guint32 next_substream_id; + guint32 first_frame; + guint32 last_frame; + guint32 messages; + guint32 bytes; + wmem_tree_t * substream_list; +}; + +/* Instance stream variables */ +#define LBM_ISTREAM_STREAM_KEY_ELEMENT_COUNT 4 +#define LBM_ISTREAM_STREAM_KEY_ELEMENT_CTXINST1_HIGH 0 +#define LBM_ISTREAM_STREAM_KEY_ELEMENT_CTXINST1_LOW 1 +#define LBM_ISTREAM_STREAM_KEY_ELEMENT_CTXINST2_HIGH 2 +#define LBM_ISTREAM_STREAM_KEY_ELEMENT_CTXINST2_LOW 3 + +#define LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_COUNT 5 +#define LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_SRC_ADDR 0 +#define LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_SRC_PORT 1 +#define LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_DST_ADDR 2 +#define LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_DST_PORT 3 +#define LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_LBM_STREAM_ID 4 + +static wmem_tree_t * instance_stream_table = NULL; + +/* Domain stream variables */ +#define LBM_DSTREAM_STREAM_KEY_ELEMENT_COUNT 6 +#define LBM_DSTREAM_STREAM_KEY_ELEMENT_DOMAIN_1 0 +#define LBM_DSTREAM_STREAM_KEY_ELEMENT_ADDR_1 1 +#define LBM_DSTREAM_STREAM_KEY_ELEMENT_DOMAIN_2 2 +#define LBM_DSTREAM_STREAM_KEY_ELEMENT_ADDR_2 3 +#define LBM_DSTREAM_STREAM_KEY_ELEMENT_PORT_1 4 +#define LBM_DSTREAM_STREAM_KEY_ELEMENT_PORT_2 5 + +#define LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_COUNT 5 +#define LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_SRC_ADDR 0 +#define LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_SRC_PORT 1 +#define LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_DST_ADDR 2 +#define LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_DST_PORT 3 +#define LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_LBM_STREAM_ID 4 + +static wmem_tree_t * domain_stream_table = NULL; + +static void lbm_stream_init(void) +{ + instance_stream_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); + domain_stream_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); +} + +static void lbm_istream_stream_build_key(guint32 * key_value, wmem_tree_key_t * key, const lbm_istream_entry_t * stream) +{ + guint32 val; + + /* Note: ctxinst_1 and ctxinst_2 are 8-byte blocks, not guaranteed to be aligned. So we memcpy them 4 bytes + at a time to an intermediate variable, to prevent any alignment issues with assigning to a 32-bit unsigned int + on certain platforms. + */ + memcpy((void *) &val, (void *) stream->ctxinst_1, sizeof(guint32)); + key_value[LBM_ISTREAM_STREAM_KEY_ELEMENT_CTXINST1_HIGH] = val; + memcpy((void *) &val, (void *) (stream->ctxinst_1 + sizeof(guint32)), sizeof(guint32)); + key_value[LBM_ISTREAM_STREAM_KEY_ELEMENT_CTXINST1_LOW] = val; + memcpy((void *) &val, (void *) stream->ctxinst_2, sizeof(guint32)); + key_value[LBM_ISTREAM_STREAM_KEY_ELEMENT_CTXINST2_HIGH] = val; + memcpy((void *) &val, (void *) (stream->ctxinst_2 + sizeof(guint32)), sizeof(guint32)); + key_value[LBM_ISTREAM_STREAM_KEY_ELEMENT_CTXINST2_LOW] = val; + key[0].length = LBM_ISTREAM_STREAM_KEY_ELEMENT_COUNT; + key[0].key = key_value; + key[1].length = 0; + key[1].key = NULL; +} + +static void lbm_stream_order_istream_key(lbm_istream_entry_t * stream) +{ + guint8 ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; + + if (memcmp((void *)stream->ctxinst_1, (void *)stream->ctxinst_2, LBM_CONTEXT_INSTANCE_BLOCK_SZ) > 0) + { + memcpy((void *)ctxinst, (void *)stream->ctxinst_1, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + memcpy((void *)stream->ctxinst_1, (void *)stream->ctxinst_2, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + memcpy((void *)stream->ctxinst_2, (void *)ctxinst, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + } +} + +static lbm_istream_entry_t * lbm_stream_istream_find(const guint8 * instance1, const guint8 * instance2) +{ + lbm_istream_entry_t key; + lbm_istream_entry_t * entry = NULL; + guint32 keyval[LBM_ISTREAM_STREAM_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + memset((void *)&key, 0, sizeof(lbm_istream_entry_t)); + memcpy((void *)key.ctxinst_1, (void *)instance1, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + memcpy((void *)key.ctxinst_2, (void *)instance2, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + lbm_stream_order_istream_key(&key); + lbm_istream_stream_build_key(keyval, tkey, &key); + entry = (lbm_istream_entry_t *) wmem_tree_lookup32_array(instance_stream_table, tkey); + return (entry); +} + +static lbm_istream_entry_t * lbm_stream_istream_add(const guint8 * instance1, const guint8 * instance2) +{ + lbm_istream_entry_t * entry; + guint32 keyval[LBM_ISTREAM_STREAM_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbm_stream_istream_find(instance1, instance2); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbm_istream_entry_t); + memcpy((void *)entry->ctxinst_1, (void *)instance1, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + memcpy((void *)entry->ctxinst_2, (void *)instance2, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + lbm_stream_order_istream_key(entry); + entry->channel = lbm_channel_assign(LBM_CHANNEL_STREAM_TCP); + entry->next_substream_id = 1; + entry->first_frame = ~((guint32)0); + entry->last_frame = 0; + entry->messages = 0; + entry->bytes = 0; + entry->substream_list = wmem_tree_new(wmem_file_scope()); + lbm_istream_stream_build_key(keyval, tkey, entry); + wmem_tree_insert32_array(instance_stream_table, tkey, (void *) entry); + return (entry); +} + +static void lbm_istream_substream_build_key(guint32 * key_value, wmem_tree_key_t * key, const lbm_istream_substream_entry_t * substream) +{ + guint32 val; + + /* Note: for the time being we only support IPv4 addresses (currently enforced in the dissectors), so + assume it's an IPv4 address. memcpy to an intermediate value (don't know for sure the address.data field + has any particular alignment) to prevent any alignment issues with assigning to a 32-bit unsigned int + on certain platforms. + */ + memcpy((void *) &val, (void *) substream->src_addr.data, sizeof(guint32)); + key_value[LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_SRC_ADDR] = val; + key_value[LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_SRC_PORT] = (guint32) substream->src_port; + memcpy((void *) &val, (void *) substream->dst_addr.data, sizeof(guint32)); + key_value[LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_DST_ADDR] = val; + key_value[LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_DST_PORT] = (guint32) substream->dst_port; + key_value[LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_LBM_STREAM_ID] = substream->lbm_stream_id; + key[0].length = LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_COUNT; + key[0].key = key_value; + key[1].length = 0; + key[1].key = NULL; +} + +static lbm_istream_substream_entry_t * lbm_stream_istream_substream_find(lbm_istream_entry_t * stream, const address * src_addr, guint16 src_port, const address * dst_addr, guint16 dst_port, guint32 stream_id) +{ + lbm_istream_substream_entry_t key; + lbm_istream_substream_entry_t * entry = NULL; + guint32 keyval[LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + memset((void *)&key, 0, sizeof(lbm_istream_substream_entry_t)); + COPY_ADDRESS_SHALLOW(&(key.src_addr), src_addr); + key.src_port = src_port; + COPY_ADDRESS_SHALLOW(&(key.dst_addr), dst_addr); + key.dst_port = dst_port; + key.lbm_stream_id = stream_id; + lbm_istream_substream_build_key(keyval, tkey, &key); + entry = (lbm_istream_substream_entry_t *) wmem_tree_lookup32_array(stream->substream_list, tkey); + return (entry); +} + +static lbm_istream_substream_entry_t * lbm_stream_istream_substream_add(lbm_istream_entry_t * stream, const address * src_addr, guint16 src_port, const address * dst_addr, guint16 dst_port, guint32 stream_id) +{ + lbm_istream_substream_entry_t * entry; + guint32 keyval[LBM_ISTREAM_SUBSTREAM_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbm_stream_istream_substream_find(stream, src_addr, src_port, dst_addr, dst_port, stream_id); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbm_istream_substream_entry_t); + SE_COPY_ADDRESS(&(entry->src_addr), src_addr); + entry->src_port = src_port; + SE_COPY_ADDRESS(&(entry->dst_addr), dst_addr); + entry->dst_port = dst_port; + entry->lbm_stream_id = stream_id; + entry->parent = stream; + entry->substream_id = stream->next_substream_id++; + entry->first_frame = ~((guint32)0); + entry->last_frame = 0; + entry->messages = 0; + entry->bytes = 0; + lbm_istream_substream_build_key(keyval, tkey, entry); + wmem_tree_insert32_array(stream->substream_list, tkey, (void *) entry); + return (entry); +} + +static void lbm_stream_istream_substream_update(lbm_istream_substream_entry_t * substream, guint16 length, guint32 frame) +{ + substream->messages++; + substream->parent->messages++; + substream->bytes += (guint32)length; + substream->parent->bytes += (guint32)length; + if (frame < substream->first_frame) + { + substream->first_frame = frame; + } + if (frame < substream->parent->first_frame) + { + substream->parent->first_frame = frame; + } + if (frame > substream->last_frame) + { + substream->last_frame = frame; + } + if (frame > substream->parent->last_frame) + { + substream->parent->last_frame = frame; + } +} + +static void lbm_dstream_stream_build_key(guint32 * key_value, wmem_tree_key_t * key, const lbm_dstream_entry_t * stream) +{ + guint32 val; + + /* Note: for the time being we only support IPv4 addresses (currently enforced in the dissectors), so + assume it's an IPv4 address. memcpy to an intermediate value (don't know for sure the address.data field + has any particular alignment) to prevent any alignment issues with assigning to a 32-bit unsigned int + on certain platforms. + */ + key_value[LBM_DSTREAM_STREAM_KEY_ELEMENT_DOMAIN_1] = stream->domain_1; + memcpy((void *) &val, (void *) (stream->addr_1.data), sizeof(guint32)); + key_value[LBM_DSTREAM_STREAM_KEY_ELEMENT_ADDR_1] = val; + key_value[LBM_DSTREAM_STREAM_KEY_ELEMENT_DOMAIN_2] = stream->domain_2; + memcpy((void *) &val, (void *) (stream->addr_2.data), sizeof(guint32)); + key_value[LBM_DSTREAM_STREAM_KEY_ELEMENT_ADDR_2] = val; + key_value[LBM_DSTREAM_STREAM_KEY_ELEMENT_PORT_1] = (guint32) stream->port_1; + key_value[LBM_DSTREAM_STREAM_KEY_ELEMENT_PORT_2] = (guint32) stream->port_2; + key[0].length = LBM_DSTREAM_STREAM_KEY_ELEMENT_COUNT; + key[0].key = key_value; + key[1].length = 0; + key[1].key = NULL; +} + +static void lbm_stream_order_dstream_key(lbm_dstream_entry_t * stream) +{ + gboolean swap_items = FALSE; + address addr; + guint32 domain; + guint16 port; + + if (stream->domain_1 > stream->domain_2) + { + swap_items = TRUE; + } + else if (stream->domain_1 == stream->domain_2) + { + int compare; + + compare = CMP_ADDRESS(&(stream->addr_1), &(stream->addr_2)); + if (compare > 0) + { + swap_items = TRUE; + } + else if (compare == 0) + { + if (stream->port_1 > stream->port_2) + { + swap_items = TRUE; + } + } + } + if (swap_items) + { + domain = stream->domain_1; + COPY_ADDRESS_SHALLOW(&addr, &(stream->addr_1)); + port = stream->port_1; + + stream->domain_1 = stream->domain_2; + COPY_ADDRESS_SHALLOW(&(stream->addr_1), &(stream->addr_2)); + stream->port_1 = stream->port_2; + + stream->domain_2 = domain; + COPY_ADDRESS_SHALLOW(&(stream->addr_2), &addr); + stream->port_2 = port; + } +} + +static lbm_dstream_entry_t * lbm_stream_dstream_find(const lbm_uim_stream_destination_t * endpoint_a, const lbm_uim_stream_destination_t * endpoint_b) +{ + lbm_dstream_entry_t key; + lbm_dstream_entry_t * entry = NULL; + guint32 keyval[LBM_DSTREAM_STREAM_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + key.domain_1 = endpoint_a->domain; + COPY_ADDRESS_SHALLOW(&(key.addr_1), &(endpoint_a->addr)); + key.port_1 = endpoint_a->port; + key.domain_2 = endpoint_b->domain; + COPY_ADDRESS_SHALLOW(&(key.addr_2), &(endpoint_b->addr)); + key.port_2 = endpoint_b->port; + lbm_stream_order_dstream_key(&key); + lbm_dstream_stream_build_key(keyval, tkey, &key); + entry = (lbm_dstream_entry_t *) wmem_tree_lookup32_array(domain_stream_table, tkey); + return (entry); +} + +static lbm_dstream_entry_t * lbm_stream_dstream_add(const lbm_uim_stream_destination_t * endpoint_a, const lbm_uim_stream_destination_t * endpoint_b) +{ + lbm_dstream_entry_t * entry; + guint32 keyval[LBM_DSTREAM_STREAM_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbm_stream_dstream_find(endpoint_a, endpoint_b); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbm_dstream_entry_t); + entry->domain_1 = endpoint_a->domain; + SE_COPY_ADDRESS(&(entry->addr_1), &(endpoint_a->addr)); + entry->port_1 = endpoint_a->port; + entry->domain_2 = endpoint_b->domain; + SE_COPY_ADDRESS(&(entry->addr_2), &(endpoint_b->addr)); + entry->port_2 = endpoint_b->port; + lbm_stream_order_dstream_key(entry); + entry->channel = lbm_channel_assign(LBM_CHANNEL_STREAM_TCP); + entry->next_substream_id = 1; + entry->first_frame = ~((guint32)0); + entry->last_frame = 0; + entry->messages = 0; + entry->bytes = 0; + entry->substream_list = wmem_tree_new(wmem_file_scope()); + lbm_dstream_stream_build_key(keyval, tkey, entry); + wmem_tree_insert32_array(domain_stream_table, tkey, (void *) entry); + return (entry); +} + +static void lbm_dstream_substream_build_key(guint32 * key_value, wmem_tree_key_t * key, const lbm_dstream_substream_entry_t * substream) +{ + guint32 val; + + /* Note: for the time being we only support IPv4 addresses (currently enforced in the dissectors), so + assume it's an IPv4 address. memcpy to an intermediate value (don't know for sure the address.data field + has any particular alignment) to prevent any alignment issues with assigning to a 32-bit unsigned int + on certain platforms. + */ + memcpy((void *) &val, (void *) substream->src_addr.data, sizeof(guint32)); + key_value[LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_SRC_ADDR] = val; + key_value[LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_SRC_PORT] = (guint32) substream->src_port; + memcpy((void *) &val, (void *) substream->dst_addr.data, sizeof(guint32)); + key_value[LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_DST_ADDR] = val; + key_value[LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_DST_PORT] = (guint32) substream->dst_port; + key_value[LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_LBM_STREAM_ID] = substream->lbm_stream_id; + key[0].length = LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_COUNT; + key[0].key = key_value; + key[1].length = 0; + key[1].key = NULL; +} + +static lbm_dstream_substream_entry_t * lbm_stream_dstream_substream_find(lbm_dstream_entry_t * stream, const address * src_addr, guint16 src_port, const address * dst_addr, guint16 dst_port, guint32 stream_id) +{ + lbm_dstream_substream_entry_t key; + lbm_dstream_substream_entry_t * entry = NULL; + guint32 keyval[LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + memset((void *)&key, 0, sizeof(lbm_dstream_substream_entry_t)); + COPY_ADDRESS_SHALLOW(&(key.src_addr), src_addr); + key.src_port = src_port; + COPY_ADDRESS_SHALLOW(&(key.dst_addr), dst_addr); + key.dst_port = dst_port; + key.lbm_stream_id = stream_id; + lbm_dstream_substream_build_key(keyval, tkey, &key); + entry = (lbm_dstream_substream_entry_t *) wmem_tree_lookup32_array(stream->substream_list, tkey); + return (entry); +} + +static lbm_dstream_substream_entry_t * lbm_stream_dstream_substream_add(lbm_dstream_entry_t * stream, const address * src_addr, guint16 src_port, const address * dst_addr, guint16 dst_port, guint32 stream_id) +{ + lbm_dstream_substream_entry_t * entry; + guint32 keyval[LBM_DSTREAM_SUBSTREAM_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbm_stream_dstream_substream_find(stream, src_addr, src_port, dst_addr, dst_port, stream_id); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbm_dstream_substream_entry_t); + SE_COPY_ADDRESS(&(entry->src_addr), src_addr); + entry->src_port = src_port; + SE_COPY_ADDRESS(&(entry->dst_addr), dst_addr); + entry->dst_port = dst_port; + entry->lbm_stream_id = stream_id; + entry->parent = stream; + entry->substream_id = stream->next_substream_id++; + entry->first_frame = ~((guint32)0); + entry->last_frame = 0; + entry->messages = 0; + entry->bytes = 0; + lbm_dstream_substream_build_key(keyval, tkey, entry); + wmem_tree_insert32_array(stream->substream_list, tkey, (void *) entry); + return (entry); +} + +static void lbm_stream_dstream_substream_update(lbm_dstream_substream_entry_t * substream, guint16 length, guint32 frame) +{ + substream->messages++; + substream->parent->messages++; + substream->bytes += (guint32)length; + substream->parent->bytes += (guint32)length; + if (frame < substream->first_frame) + { + substream->first_frame = frame; + } + if (frame < substream->parent->first_frame) + { + substream->parent->first_frame = frame; + } + if (frame > substream->last_frame) + { + substream->last_frame = frame; + } + if (frame > substream->parent->last_frame) + { + substream->parent->last_frame = frame; + } +} + +/*----------------------------------------------------------------------------*/ +/* Packet layouts. */ +/*----------------------------------------------------------------------------*/ + +/* LBMC header */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t next_hdr; + lbm_uint16_t msglen; + lbm_uint32_t tidx; + lbm_uint32_t sqn; +} lbmc_hdr_t; +#define O_LBMC_HDR_T_VER_TYPE OFFSETOF(lbmc_hdr_t, ver_type) +#define L_LBMC_HDR_T_VER_TYPE SIZEOF(lbmc_hdr_t, ver_type) +#define O_LBMC_HDR_T_NEXT_HDR OFFSETOF(lbmc_hdr_t, next_hdr) +#define L_LBMC_HDR_T_NEXT_HDR SIZEOF(lbmc_hdr_t, next_hdr) +#define O_LBMC_HDR_T_MSGLEN OFFSETOF(lbmc_hdr_t, msglen) +#define L_LBMC_HDR_T_MSGLEN SIZEOF(lbmc_hdr_t, msglen) +#define O_LBMC_HDR_T_TIDX OFFSETOF(lbmc_hdr_t, tidx) +#define L_LBMC_HDR_T_TIDX SIZEOF(lbmc_hdr_t, tidx) +#define O_LBMC_HDR_T_SQN OFFSETOF(lbmc_hdr_t, sqn) +#define L_LBMC_HDR_T_SQN SIZEOF(lbmc_hdr_t, sqn) +#define L_LBMC_HDR_T (gint) sizeof(lbmc_hdr_t) + +/* LBMC control header */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t next_hdr; + lbm_uint16_t msglen; +} lbmc_cntl_hdr_t; +#define O_LBMC_CNTL_HDR_T_VER_TYPE OFFSETOF(lbmc_cntl_hdr_t, ver_type) +#define L_LBMC_CNTL_HDR_T_VER_TYPE SIZEOF(lbmc_cntl_hdr_t, ver_type) +#define O_LBMC_CNTL_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_hdr_t, next_hdr) +#define L_LBMC_CNTL_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_hdr_t, next_hdr) +#define O_LBMC_CNTL_HDR_T_MSGLEN OFFSETOF(lbmc_cntl_hdr_t, msglen) +#define L_LBMC_CNTL_HDR_T_MSGLEN SIZEOF(lbmc_cntl_hdr_t, msglen) +#define L_LBMC_CNTL_HDR_T (gint) sizeof(lbmc_cntl_hdr_t) + +#define LBMC_HDR_VER_TYPE_VER_MASK 0xF0 +#define LBMC_HDR_VER_TYPE_TYPE_MASK 0x0F + +/* Minimal LBMC header */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t next_hdr; + lbm_uint16_t msglen; +} lbmc_minimal_hdr_t; +#define O_LBMC_MINIMAL_HDR_T_VER_TYPE OFFSETOF(lbmc_minimal_hdr_t, ver_type) +#define L_LBMC_MINIMAL_HDR_T_VER_TYPE SIZEOF(lbmc_minimal_hdr_t, ver_type) +#define O_LBMC_MINIMAL_HDR_T_NEXT_HDR OFFSETOF(lbmc_minimal_hdr_t, next_hdr) +#define L_LBMC_MINIMAL_HDR_T_NEXT_HDR SIZEOF(lbmc_minimal_hdr_t, next_hdr) +#define O_LBMC_MINIMAL_HDR_T_MSGLEN OFFSETOF(lbmc_minimal_hdr_t, msglen) +#define L_LBMC_MINIMAL_HDR_T_MSGLEN SIZEOF(lbmc_minimal_hdr_t, msglen) +#define L_LBMC_MINIMAL_HDR_T (gint) sizeof(lbmc_minimal_hdr_t) + +#define LBMC_HDR_VER(x) (x >> 4) +#define LBMC_HDR_TYPE(x) (x & 0xF) + +/* LBMC basic header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t res; +} lbmc_basic_hdr_t; +#define O_LBMC_BASIC_HDR_T_NEXT_HDR OFFSETOF(lbmc_basic_hdr_t, next_hdr) +#define L_LBMC_BASIC_HDR_T_NEXT_HDR SIZEOF(lbmc_basic_hdr_t, next_hdr) +#define O_LBMC_BASIC_HDR_T_HDR_LEN OFFSETOF(lbmc_basic_hdr_t, hdr_len) +#define L_LBMC_BASIC_HDR_T_HDR_LEN SIZEOF(lbmc_basic_hdr_t, hdr_len) +#define O_LBMC_BASIC_HDR_T_RES OFFSETOF(lbmc_basic_hdr_t, res) +#define L_LBMC_BASIC_HDR_T_RES SIZEOF(lbmc_basic_hdr_t, res) +#define L_LBMC_BASIC_HDR_T (gint) sizeof(lbmc_basic_hdr_t) + +/* LBMC fragment header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t first_sqn; + lbm_uint32_t offset; + lbm_uint32_t len; +} lbmc_frag_hdr_t; +#define O_LBMC_FRAG_HDR_T_NEXT_HDR OFFSETOF(lbmc_frag_hdr_t, next_hdr) +#define L_LBMC_FRAG_HDR_T_NEXT_HDR SIZEOF(lbmc_frag_hdr_t, next_hdr) +#define O_LBMC_FRAG_HDR_T_HDR_LEN OFFSETOF(lbmc_frag_hdr_t, hdr_len) +#define L_LBMC_FRAG_HDR_T_HDR_LEN SIZEOF(lbmc_frag_hdr_t, hdr_len) +#define O_LBMC_FRAG_HDR_T_FLAGS OFFSETOF(lbmc_frag_hdr_t, flags) +#define L_LBMC_FRAG_HDR_T_FLAGS SIZEOF(lbmc_frag_hdr_t, flags) +#define O_LBMC_FRAG_HDR_T_FIRST_SQN OFFSETOF(lbmc_frag_hdr_t, first_sqn) +#define L_LBMC_FRAG_HDR_T_FIRST_SQN SIZEOF(lbmc_frag_hdr_t, first_sqn) +#define O_LBMC_FRAG_HDR_T_OFFSET OFFSETOF(lbmc_frag_hdr_t, offset) +#define L_LBMC_FRAG_HDR_T_OFFSET SIZEOF(lbmc_frag_hdr_t, offset) +#define O_LBMC_FRAG_HDR_T_LEN OFFSETOF(lbmc_frag_hdr_t, len) +#define L_LBMC_FRAG_HDR_T_LEN SIZEOF(lbmc_frag_hdr_t, len) +#define L_LBMC_FRAG_HDR_T (gint) sizeof(lbmc_frag_hdr_t) + +/* LBMC batch header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; +} lbmc_batch_hdr_t; +#define O_LBMC_BATCH_HDR_T_NEXT_HDR OFFSETOF(lbmc_batch_hdr_t, next_hdr) +#define L_LBMC_BATCH_HDR_T_NEXT_HDR SIZEOF(lbmc_batch_hdr_t, next_hdr) +#define O_LBMC_BATCH_HDR_T_HDR_LEN OFFSETOF(lbmc_batch_hdr_t, hdr_len) +#define L_LBMC_BATCH_HDR_T_HDR_LEN SIZEOF(lbmc_batch_hdr_t, hdr_len) +#define O_LBMC_BATCH_HDR_T_FLAGS OFFSETOF(lbmc_batch_hdr_t, flags) +#define L_LBMC_BATCH_HDR_T_FLAGS SIZEOF(lbmc_batch_hdr_t, flags) +#define L_LBMC_BATCH_HDR_T (gint) sizeof(lbmc_batch_hdr_t) + +/* LBMC TCP request header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t res; + lbm_uint8_t transport; + lbm_uint32_t qidx; + lbm_uint16_t port; + lbm_uint16_t reserved; + lbm_uint32_t ipaddr; +} lbmc_tcp_request_hdr_t; +#define O_LBMC_TCP_REQUEST_HDR_T_NEXT_HDR OFFSETOF(lbmc_tcp_request_hdr_t, next_hdr) +#define L_LBMC_TCP_REQUEST_HDR_T_NEXT_HDR SIZEOF(lbmc_tcp_request_hdr_t, next_hdr) +#define O_LBMC_TCP_REQUEST_HDR_T_HDR_LEN OFFSETOF(lbmc_tcp_request_hdr_t, hdr_len) +#define L_LBMC_TCP_REQUEST_HDR_T_HDR_LEN SIZEOF(lbmc_tcp_request_hdr_t, hdr_len) +#define O_LBMC_TCP_REQUEST_HDR_T_FLAGS OFFSETOF(lbmc_tcp_request_hdr_t, res) +#define L_LBMC_TCP_REQUEST_HDR_T_FLAGS SIZEOF(lbmc_tcp_request_hdr_t, res) +#define O_LBMC_TCP_REQUEST_HDR_T_TRANSPORT OFFSETOF(lbmc_tcp_request_hdr_t, transport) +#define L_LBMC_TCP_REQUEST_HDR_T_TRANSPORT SIZEOF(lbmc_tcp_request_hdr_t, transport) +#define O_LBMC_TCP_REQUEST_HDR_T_QIDX OFFSETOF(lbmc_tcp_request_hdr_t, qidx) +#define L_LBMC_TCP_REQUEST_HDR_T_QIDX SIZEOF(lbmc_tcp_request_hdr_t, qidx) +#define O_LBMC_TCP_REQUEST_HDR_T_PORT OFFSETOF(lbmc_tcp_request_hdr_t, port) +#define L_LBMC_TCP_REQUEST_HDR_T_PORT SIZEOF(lbmc_tcp_request_hdr_t, port) +#define O_LBMC_TCP_REQUEST_HDR_T_RESERVED OFFSETOF(lbmc_tcp_request_hdr_t, reserved) +#define L_LBMC_TCP_REQUEST_HDR_T_RESERVED SIZEOF(lbmc_tcp_request_hdr_t, reserved) +#define O_LBMC_TCP_REQUEST_HDR_T_IPADDR OFFSETOF(lbmc_tcp_request_hdr_t, ipaddr) +#define L_LBMC_TCP_REQUEST_HDR_T_IPADDR SIZEOF(lbmc_tcp_request_hdr_t, ipaddr) +#define L_LBMC_TCP_REQUEST_HDR_T (gint) sizeof(lbmc_tcp_request_hdr_t) + +/* LBMC topicname header (an extension to lbmc_basic_hdr_t) */ +#define O_LBMC_TOPICNAME_HDR_T_NEXT_HDR OFFSETOF(lbmc_basic_hdr_t, next_hdr) +#define L_LBMC_TOPICNAME_HDR_T_NEXT_HDR SIZEOF(lbmc_basic_hdr_t, next_hdr) +#define O_LBMC_TOPICNAME_HDR_T_HDR_LEN OFFSETOF(lbmc_basic_hdr_t, hdr_len) +#define L_LBMC_TOPICNAME_HDR_T_HDR_LEN SIZEOF(lbmc_basic_hdr_t, hdr_len) +#define O_LBMC_TOPICNAME_HDR_T_FLAGS OFFSETOF(lbmc_basic_hdr_t, res) +#define L_LBMC_TOPICNAME_HDR_T_FLAGS SIZEOF(lbmc_basic_hdr_t, res) +#define O_LBMC_TOPICNAME_HDR_T_TOPIC (OFFSETOF(lbmc_basic_hdr_t, res) + SIZEOF(lbmc_basic_hdr_t, res)) + +/* LBMC appheader header. */ +#define O_LBMC_APPHDR_HDR_T_NEXT_HDR OFFSETOF(lbmc_basic_hdr_t, next_hdr) +#define L_LBMC_APPHDR_HDR_T_NEXT_HDR SIZEOF(lbmc_basic_hdr_t, next_hdr) +#define O_LBMC_APPHDR_HDR_T_HDR_LEN OFFSETOF(lbmc_basic_hdr_t, hdr_len) +#define L_LBMC_APPHDR_HDR_T_HDR_LEN SIZEOF(lbmc_basic_hdr_t, hdr_len) +#define O_LBMC_APPHDR_HDR_T_CODE OFFSETOF(lbmc_basic_hdr_t, res) +#define L_LBMC_APPHDR_HDR_T_CODE SIZEOF(lbmc_basic_hdr_t, res) +#define O_LBMC_APPHDR_HDR_T_DATA (OFFSETOF(lbmc_basic_hdr_t, res) + SIZEOF(lbmc_basic_hdr_t, res)) + +#define LBMC_APPHDR_CODE_MASK 0x7fff + +/* LBMC appheader chain element */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t res; +} lbmc_apphdr_chain_element_t; +#define O_LBMC_APPHDR_CHAIN_ELEMENT_T_NEXT_HDR OFFSETOF(lbmc_apphdr_chain_element_t, next_hdr) +#define L_LBMC_APPHDR_CHAIN_ELEMENT_T_NEXT_HDR SIZEOF(lbmc_apphdr_chain_element_t, next_hdr) +#define O_LBMC_APPHDR_CHAIN_ELEMENT_T_HDR_LEN OFFSETOF(lbmc_apphdr_chain_element_t, hdr_len) +#define L_LBMC_APPHDR_CHAIN_ELEMENT_T_HDR_LEN SIZEOF(lbmc_apphdr_chain_element_t, hdr_len) +#define O_LBMC_APPHDR_CHAIN_ELEMENT_T_RES OFFSETOF(lbmc_apphdr_chain_element_t, res) +#define L_LBMC_APPHDR_CHAIN_ELEMENT_T_RES SIZEOF(lbmc_apphdr_chain_element_t, res) +#define L_LBMC_APPHDR_CHAIN_ELEMENT_T_MIN (gint) sizeof(lbmc_apphdr_chain_element_t) + +/* LBMC appheader chain message properties element */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t res; + lbm_uint32_t len; +} lbmc_apphdr_chain_msgprop_element_t; +#define O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_NEXT_HDR OFFSETOF(lbmc_apphdr_chain_msgprop_element_t, next_hdr) +#define L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_NEXT_HDR SIZEOF(lbmc_apphdr_chain_msgprop_element_t, next_hdr) +#define O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_HDR_LEN OFFSETOF(lbmc_apphdr_chain_msgprop_element_t, hdr_len) +#define L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_HDR_LEN SIZEOF(lbmc_apphdr_chain_msgprop_element_t, hdr_len) +#define O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_RES OFFSETOF(lbmc_apphdr_chain_msgprop_element_t, res) +#define L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_RES SIZEOF(lbmc_apphdr_chain_msgprop_element_t, res) +#define O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_LEN OFFSETOF(lbmc_apphdr_chain_msgprop_element_t, len) +#define L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_LEN SIZEOF(lbmc_apphdr_chain_msgprop_element_t, len) +#define L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T (gint) sizeof(lbmc_apphdr_chain_msgprop_element_t) + +/* LBMC appheader chain header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t res; + lbm_uint8_t first_chain_hdr; +} lbmc_apphdr_chain_hdr_t; +#define O_LBMC_APPHDR_CHAIN_HDR_T_NEXT_HDR OFFSETOF(lbmc_apphdr_chain_hdr_t, next_hdr) +#define L_LBMC_APPHDR_CHAIN_HDR_T_NEXT_HDR SIZEOF(lbmc_apphdr_chain_hdr_t, next_hdr) +#define O_LBMC_APPHDR_CHAIN_HDR_T_HDR_LEN OFFSETOF(lbmc_apphdr_chain_hdr_t, hdr_len) +#define L_LBMC_APPHDR_CHAIN_HDR_T_HDR_LEN SIZEOF(lbmc_apphdr_chain_hdr_t, hdr_len) +#define O_LBMC_APPHDR_CHAIN_HDR_T_RES OFFSETOF(lbmc_apphdr_chain_hdr_t, res) +#define L_LBMC_APPHDR_CHAIN_HDR_T_RES SIZEOF(lbmc_apphdr_chain_hdr_t, res) +#define O_LBMC_APPHDR_CHAIN_HDR_T_FIRST_CHAIN_HDR OFFSETOF(lbmc_apphdr_chain_hdr_t, first_chain_hdr) +#define L_LBMC_APPHDR_CHAIN_HDR_T_FIRST_CHAIN_HDR SIZEOF(lbmc_apphdr_chain_hdr_t, first_chain_hdr) +#define L_LBMC_APPHDR_CHAIN_HDR_T (gint) sizeof(lbmc_apphdr_chain_hdr_t) + +/* LBMC UMQ Message ID header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint8_t msgid_regid[8]; + lbm_uint8_t msgid_stamp[8]; +} lbmc_umq_msgid_hdr_t; +#define O_LBMC_UMQ_MSGID_HDR_T_NEXT_HDR OFFSETOF(lbmc_umq_msgid_hdr_t, next_hdr) +#define L_LBMC_UMQ_MSGID_HDR_T_NEXT_HDR SIZEOF(lbmc_umq_msgid_hdr_t, next_hdr) +#define O_LBMC_UMQ_MSGID_HDR_T_HDR_LEN OFFSETOF(lbmc_umq_msgid_hdr_t, hdr_len) +#define L_LBMC_UMQ_MSGID_HDR_T_HDR_LEN SIZEOF(lbmc_umq_msgid_hdr_t, hdr_len) +#define O_LBMC_UMQ_MSGID_HDR_T_FLAGS OFFSETOF(lbmc_umq_msgid_hdr_t, flags) +#define L_LBMC_UMQ_MSGID_HDR_T_FLAGS SIZEOF(lbmc_umq_msgid_hdr_t, flags) +#define O_LBMC_UMQ_MSGID_HDR_T_MSGID_REGID OFFSETOF(lbmc_umq_msgid_hdr_t, msgid_regid) +#define L_LBMC_UMQ_MSGID_HDR_T_MSGID_REGID SIZEOF(lbmc_umq_msgid_hdr_t, msgid_regid) +#define O_LBMC_UMQ_MSGID_HDR_T_MSGID_STAMP OFFSETOF(lbmc_umq_msgid_hdr_t, msgid_stamp) +#define L_LBMC_UMQ_MSGID_HDR_T_MSGID_STAMP SIZEOF(lbmc_umq_msgid_hdr_t, msgid_stamp) +#define L_LBMC_UMQ_MSGID_HDR_T (gint) sizeof(lbmc_umq_msgid_hdr_t) + +/* LBMC UMQ SQD receive header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t queue_id; + lbm_uint32_t queue_ver; + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_umq_sqd_rcv_hdr_t; +#define O_LBMC_UMQ_SQD_RCV_HDR_T_NEXT_HDR OFFSETOF(lbmc_umq_sqd_rcv_hdr_t, next_hdr) +#define L_LBMC_UMQ_SQD_RCV_HDR_T_NEXT_HDR SIZEOF(lbmc_umq_sqd_rcv_hdr_t, next_hdr) +#define O_LBMC_UMQ_SQD_RCV_HDR_T_HDR_LEN OFFSETOF(lbmc_umq_sqd_rcv_hdr_t, hdr_len) +#define L_LBMC_UMQ_SQD_RCV_HDR_T_HDR_LEN SIZEOF(lbmc_umq_sqd_rcv_hdr_t, hdr_len) +#define O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS OFFSETOF(lbmc_umq_sqd_rcv_hdr_t, flags) +#define L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS SIZEOF(lbmc_umq_sqd_rcv_hdr_t, flags) +#define O_LBMC_UMQ_SQD_RCV_HDR_T_QUEUE_ID OFFSETOF(lbmc_umq_sqd_rcv_hdr_t, queue_id) +#define L_LBMC_UMQ_SQD_RCV_HDR_T_QUEUE_ID SIZEOF(lbmc_umq_sqd_rcv_hdr_t, queue_id) +#define O_LBMC_UMQ_SQD_RCV_HDR_T_QUEUE_VER OFFSETOF(lbmc_umq_sqd_rcv_hdr_t, queue_ver) +#define L_LBMC_UMQ_SQD_RCV_HDR_T_QUEUE_VER SIZEOF(lbmc_umq_sqd_rcv_hdr_t, queue_ver) +#define O_LBMC_UMQ_SQD_RCV_HDR_T_RCR_IDX OFFSETOF(lbmc_umq_sqd_rcv_hdr_t, rcr_idx) +#define L_LBMC_UMQ_SQD_RCV_HDR_T_RCR_IDX SIZEOF(lbmc_umq_sqd_rcv_hdr_t, rcr_idx) +#define O_LBMC_UMQ_SQD_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_umq_sqd_rcv_hdr_t, assign_id) +#define L_LBMC_UMQ_SQD_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_umq_sqd_rcv_hdr_t, assign_id) +#define L_LBMC_UMQ_SQD_RCV_HDR_T (gint) sizeof(lbmc_umq_sqd_rcv_hdr_t) + +/* LBMC UMQ resubmission header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t rcr_idx; + lbm_uint32_t resp_ip; + lbm_uint16_t resp_port; + lbm_uint16_t appset_idx; +} lbmc_umq_resub_hdr_t; +#define O_LBMC_UMQ_RESUB_HDR_T_NEXT_HDR OFFSETOF(lbmc_umq_resub_hdr_t, next_hdr) +#define L_LBMC_UMQ_RESUB_HDR_T_NEXT_HDR SIZEOF(lbmc_umq_resub_hdr_t, next_hdr) +#define O_LBMC_UMQ_RESUB_HDR_T_HDR_LEN OFFSETOF(lbmc_umq_resub_hdr_t, hdr_len) +#define L_LBMC_UMQ_RESUB_HDR_T_HDR_LEN SIZEOF(lbmc_umq_resub_hdr_t, hdr_len) +#define O_LBMC_UMQ_RESUB_HDR_T_FLAGS OFFSETOF(lbmc_umq_resub_hdr_t, flags) +#define L_LBMC_UMQ_RESUB_HDR_T_FLAGS SIZEOF(lbmc_umq_resub_hdr_t, flags) +#define O_LBMC_UMQ_RESUB_HDR_T_RCR_IDX OFFSETOF(lbmc_umq_resub_hdr_t, rcr_idx) +#define L_LBMC_UMQ_RESUB_HDR_T_RCR_IDX SIZEOF(lbmc_umq_resub_hdr_t, rcr_idx) +#define O_LBMC_UMQ_RESUB_HDR_T_RESP_IP OFFSETOF(lbmc_umq_resub_hdr_t, resp_ip) +#define L_LBMC_UMQ_RESUB_HDR_T_RESP_IP SIZEOF(lbmc_umq_resub_hdr_t, resp_ip) +#define O_LBMC_UMQ_RESUB_HDR_T_RESP_PORT OFFSETOF(lbmc_umq_resub_hdr_t, resp_port) +#define L_LBMC_UMQ_RESUB_HDR_T_RESP_PORT SIZEOF(lbmc_umq_resub_hdr_t, resp_port) +#define O_LBMC_UMQ_RESUB_HDR_T_APPSET_IDX OFFSETOF(lbmc_umq_resub_hdr_t, appset_idx) +#define L_LBMC_UMQ_RESUB_HDR_T_APPSET_IDX SIZEOF(lbmc_umq_resub_hdr_t, appset_idx) +#define L_LBMC_UMQ_RESUB_HDR_T (gint) sizeof(lbmc_umq_resub_hdr_t) + +/* LBMC originating transport ID header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint8_t otid[LBM_OTID_BLOCK_SZ]; +} lbmc_otid_hdr_t; +#define O_LBMC_OTID_HDR_T_NEXT_HDR OFFSETOF(lbmc_otid_hdr_t, next_hdr) +#define L_LBMC_OTID_HDR_T_NEXT_HDR SIZEOF(lbmc_otid_hdr_t, next_hdr) +#define O_LBMC_OTID_HDR_T_HDR_LEN OFFSETOF(lbmc_otid_hdr_t, hdr_len) +#define L_LBMC_OTID_HDR_T_HDR_LEN SIZEOF(lbmc_otid_hdr_t, hdr_len) +#define O_LBMC_OTID_HDR_T_FLAGS OFFSETOF(lbmc_otid_hdr_t, flags) +#define L_LBMC_OTID_HDR_T_FLAGS SIZEOF(lbmc_otid_hdr_t, flags) +#define O_LBMC_OTID_HDR_T_OTID OFFSETOF(lbmc_otid_hdr_t, otid) +#define L_LBMC_OTID_HDR_T_OTID SIZEOF(lbmc_otid_hdr_t, otid) +#define L_LBMC_OTID_HDR_T (gint) sizeof(lbmc_otid_hdr_t) + +/* LBMC context instance header(s) */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmc_ctxinst_hdr_t; +#define O_LBMC_CTXINST_HDR_T_NEXT_HDR OFFSETOF(lbmc_ctxinst_hdr_t, next_hdr) +#define L_LBMC_CTXINST_HDR_T_NEXT_HDR SIZEOF(lbmc_ctxinst_hdr_t, next_hdr) +#define O_LBMC_CTXINST_HDR_T_HDR_LEN OFFSETOF(lbmc_ctxinst_hdr_t, hdr_len) +#define L_LBMC_CTXINST_HDR_T_HDR_LEN SIZEOF(lbmc_ctxinst_hdr_t, hdr_len) +#define O_LBMC_CTXINST_HDR_T_FLAGS OFFSETOF(lbmc_ctxinst_hdr_t, flags) +#define L_LBMC_CTXINST_HDR_T_FLAGS SIZEOF(lbmc_ctxinst_hdr_t, flags) +#define O_LBMC_CTXINST_HDR_T_CTXINST OFFSETOF(lbmc_ctxinst_hdr_t, ctxinst) +#define L_LBMC_CTXINST_HDR_T_CTXINST SIZEOF(lbmc_ctxinst_hdr_t, ctxinst) +#define L_LBMC_CTXINST_HDR_T (gint) sizeof(lbmc_ctxinst_hdr_t) + +/* LBMC source index header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + char srcidx[8]; +} lbmc_srcidx_hdr_t; +#define O_LBMC_SRCIDX_HDR_T_NEXT_HDR OFFSETOF(lbmc_srcidx_hdr_t, next_hdr) +#define L_LBMC_SRCIDX_HDR_T_NEXT_HDR SIZEOF(lbmc_srcidx_hdr_t, next_hdr) +#define O_LBMC_SRCIDX_HDR_T_HDR_LEN OFFSETOF(lbmc_srcidx_hdr_t, hdr_len) +#define L_LBMC_SRCIDX_HDR_T_HDR_LEN SIZEOF(lbmc_srcidx_hdr_t, hdr_len) +#define O_LBMC_SRCIDX_HDR_T_FLAGS OFFSETOF(lbmc_srcidx_hdr_t, flags) +#define L_LBMC_SRCIDX_HDR_T_FLAGS SIZEOF(lbmc_srcidx_hdr_t, flags) +#define O_LBMC_SRCIDX_HDR_T_SRCIDX OFFSETOF(lbmc_srcidx_hdr_t, srcidx) +#define L_LBMC_SRCIDX_HDR_T_SRCIDX SIZEOF(lbmc_srcidx_hdr_t, srcidx) +#define L_LBMC_SRCIDX_HDR_T (gint) sizeof(lbmc_srcidx_hdr_t) + +/* LBMC UMQ ULB message header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t queue_id; + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t num_ras; +} lbmc_umq_ulb_msg_hdr_t; +#define O_LBMC_UMQ_ULB_MSG_HDR_T_NEXT_HDR OFFSETOF(lbmc_umq_ulb_msg_hdr_t, next_hdr) +#define L_LBMC_UMQ_ULB_MSG_HDR_T_NEXT_HDR SIZEOF(lbmc_umq_ulb_msg_hdr_t, next_hdr) +#define O_LBMC_UMQ_ULB_MSG_HDR_T_HDR_LEN OFFSETOF(lbmc_umq_ulb_msg_hdr_t, hdr_len) +#define L_LBMC_UMQ_ULB_MSG_HDR_T_HDR_LEN SIZEOF(lbmc_umq_ulb_msg_hdr_t, hdr_len) +#define O_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS OFFSETOF(lbmc_umq_ulb_msg_hdr_t, flags) +#define L_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS SIZEOF(lbmc_umq_ulb_msg_hdr_t, flags) +#define O_LBMC_UMQ_ULB_MSG_HDR_T_QUEUE_ID OFFSETOF(lbmc_umq_ulb_msg_hdr_t, queue_id) +#define L_LBMC_UMQ_ULB_MSG_HDR_T_QUEUE_ID SIZEOF(lbmc_umq_ulb_msg_hdr_t, queue_id) +#define O_LBMC_UMQ_ULB_MSG_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_umq_ulb_msg_hdr_t, ulb_src_id) +#define L_LBMC_UMQ_ULB_MSG_HDR_T_ULB_SRC_ID SIZEOF(lbmc_umq_ulb_msg_hdr_t, ulb_src_id) +#define O_LBMC_UMQ_ULB_MSG_HDR_T_ASSIGN_ID OFFSETOF(lbmc_umq_ulb_msg_hdr_t, assign_id) +#define L_LBMC_UMQ_ULB_MSG_HDR_T_ASSIGN_ID SIZEOF(lbmc_umq_ulb_msg_hdr_t, assign_id) +#define O_LBMC_UMQ_ULB_MSG_HDR_T_APPSET_IDX OFFSETOF(lbmc_umq_ulb_msg_hdr_t, appset_idx) +#define L_LBMC_UMQ_ULB_MSG_HDR_T_APPSET_IDX SIZEOF(lbmc_umq_ulb_msg_hdr_t, appset_idx) +#define O_LBMC_UMQ_ULB_MSG_HDR_T_NUM_RAS OFFSETOF(lbmc_umq_ulb_msg_hdr_t, num_ras) +#define L_LBMC_UMQ_ULB_MSG_HDR_T_NUM_RAS SIZEOF(lbmc_umq_ulb_msg_hdr_t, num_ras) +#define L_LBMC_UMQ_ULB_MSG_HDR_T (gint) sizeof(lbmc_umq_ulb_msg_hdr_t) + +/* LBMC control source-side filtering initialization header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t transport; + lbm_uint32_t transport_idx; + lbm_uint32_t client_idx; + lbm_uint16_t ssf_port; + lbm_uint16_t res; + lbm_uint32_t ssf_ip; +} lbmc_cntl_ssf_init_hdr_t; +#define O_LBMC_CNTL_SSF_INIT_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ssf_init_hdr_t, next_hdr) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ssf_init_hdr_t, next_hdr) +#define O_LBMC_CNTL_SSF_INIT_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ssf_init_hdr_t, hdr_len) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ssf_init_hdr_t, hdr_len) +#define O_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ssf_init_hdr_t, flags) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS SIZEOF(lbmc_cntl_ssf_init_hdr_t, flags) +#define O_LBMC_CNTL_SSF_INIT_HDR_T_TRANSPORT OFFSETOF(lbmc_cntl_ssf_init_hdr_t, transport) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_TRANSPORT SIZEOF(lbmc_cntl_ssf_init_hdr_t, transport) +#define O_LBMC_CNTL_SSF_INIT_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_ssf_init_hdr_t, transport_idx) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_ssf_init_hdr_t, transport_idx) +#define O_LBMC_CNTL_SSF_INIT_HDR_T_CLIENT_IDX OFFSETOF(lbmc_cntl_ssf_init_hdr_t, client_idx) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_CLIENT_IDX SIZEOF(lbmc_cntl_ssf_init_hdr_t, client_idx) +#define O_LBMC_CNTL_SSF_INIT_HDR_T_SSF_PORT OFFSETOF(lbmc_cntl_ssf_init_hdr_t, ssf_port) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_SSF_PORT SIZEOF(lbmc_cntl_ssf_init_hdr_t, ssf_port) +#define O_LBMC_CNTL_SSF_INIT_HDR_T_RES OFFSETOF(lbmc_cntl_ssf_init_hdr_t, res) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_RES SIZEOF(lbmc_cntl_ssf_init_hdr_t, res) +#define O_LBMC_CNTL_SSF_INIT_HDR_T_SSF_IP OFFSETOF(lbmc_cntl_ssf_init_hdr_t, ssf_ip) +#define L_LBMC_CNTL_SSF_INIT_HDR_T_SSF_IP SIZEOF(lbmc_cntl_ssf_init_hdr_t, ssf_ip) +#define L_LBMC_CNTL_SSF_INIT_HDR_T (gint) sizeof(lbmc_cntl_ssf_init_hdr_t) + +/* LBMC control source-side filtering control request header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t res; + lbm_uint8_t mode; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; + lbm_uint32_t client_idx; +} lbmc_cntl_ssf_creq_hdr_t; +#define O_LBMC_CNTL_SSF_CREQ_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ssf_creq_hdr_t, next_hdr) +#define L_LBMC_CNTL_SSF_CREQ_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ssf_creq_hdr_t, next_hdr) +#define O_LBMC_CNTL_SSF_CREQ_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ssf_creq_hdr_t, hdr_len) +#define L_LBMC_CNTL_SSF_CREQ_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ssf_creq_hdr_t, hdr_len) +#define O_LBMC_CNTL_SSF_CREQ_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ssf_creq_hdr_t, res) +#define L_LBMC_CNTL_SSF_CREQ_HDR_T_FLAGS SIZEOF(lbmc_cntl_ssf_creq_hdr_t, res) +#define O_LBMC_CNTL_SSF_CREQ_HDR_T_MODE OFFSETOF(lbmc_cntl_ssf_creq_hdr_t, mode) +#define L_LBMC_CNTL_SSF_CREQ_HDR_T_MODE SIZEOF(lbmc_cntl_ssf_creq_hdr_t, mode) +#define O_LBMC_CNTL_SSF_CREQ_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_ssf_creq_hdr_t, transport_idx) +#define L_LBMC_CNTL_SSF_CREQ_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_ssf_creq_hdr_t, transport_idx) +#define O_LBMC_CNTL_SSF_CREQ_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_ssf_creq_hdr_t, topic_idx) +#define L_LBMC_CNTL_SSF_CREQ_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_ssf_creq_hdr_t, topic_idx) +#define O_LBMC_CNTL_SSF_CREQ_HDR_T_CLIENT_IDX OFFSETOF(lbmc_cntl_ssf_creq_hdr_t, client_idx) +#define L_LBMC_CNTL_SSF_CREQ_HDR_T_CLIENT_IDX SIZEOF(lbmc_cntl_ssf_creq_hdr_t, client_idx) +#define L_LBMC_CNTL_SSF_CREQ_HDR_T (gint) sizeof(lbmc_cntl_ssf_creq_hdr_t) + +/* LBMC control UME presistent registration header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t marker; + lbm_uint32_t reg_id; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; + lbm_uint32_t src_reg_id; + lbm_uint16_t resp_port; + lbm_uint16_t res2; + lbm_uint32_t resp_ip; +} lbmc_cntl_ume_preg_hdr_t; +#define O_LBMC_CNTL_UME_PREG_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_preg_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_PREG_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_preg_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_PREG_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_preg_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_PREG_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_preg_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_PREG_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_preg_hdr_t, flags) +#define L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_preg_hdr_t, flags) +#define O_LBMC_CNTL_UME_PREG_HDR_T_MARKER OFFSETOF(lbmc_cntl_ume_preg_hdr_t, marker) +#define L_LBMC_CNTL_UME_PREG_HDR_T_MARKER SIZEOF(lbmc_cntl_ume_preg_hdr_t, marker) +#define O_LBMC_CNTL_UME_PREG_HDR_T_REG_ID OFFSETOF(lbmc_cntl_ume_preg_hdr_t, reg_id) +#define L_LBMC_CNTL_UME_PREG_HDR_T_REG_ID SIZEOF(lbmc_cntl_ume_preg_hdr_t, reg_id) +#define O_LBMC_CNTL_UME_PREG_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_ume_preg_hdr_t, transport_idx) +#define L_LBMC_CNTL_UME_PREG_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_ume_preg_hdr_t, transport_idx) +#define O_LBMC_CNTL_UME_PREG_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_ume_preg_hdr_t, topic_idx) +#define L_LBMC_CNTL_UME_PREG_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_ume_preg_hdr_t, topic_idx) +#define O_LBMC_CNTL_UME_PREG_HDR_T_SRC_REG_ID OFFSETOF(lbmc_cntl_ume_preg_hdr_t, src_reg_id) +#define L_LBMC_CNTL_UME_PREG_HDR_T_SRC_REG_ID SIZEOF(lbmc_cntl_ume_preg_hdr_t, src_reg_id) +#define O_LBMC_CNTL_UME_PREG_HDR_T_RESP_PORT OFFSETOF(lbmc_cntl_ume_preg_hdr_t, resp_port) +#define L_LBMC_CNTL_UME_PREG_HDR_T_RESP_PORT SIZEOF(lbmc_cntl_ume_preg_hdr_t, resp_port) +#define O_LBMC_CNTL_UME_PREG_HDR_T_RES2 OFFSETOF(lbmc_cntl_ume_preg_hdr_t, res2) +#define L_LBMC_CNTL_UME_PREG_HDR_T_RES2 SIZEOF(lbmc_cntl_ume_preg_hdr_t, res2) +#define O_LBMC_CNTL_UME_PREG_HDR_T_RESP_IP OFFSETOF(lbmc_cntl_ume_preg_hdr_t, resp_ip) +#define L_LBMC_CNTL_UME_PREG_HDR_T_RESP_IP SIZEOF(lbmc_cntl_ume_preg_hdr_t, resp_ip) +#define L_LBMC_CNTL_UME_PREG_HDR_T (gint) sizeof(lbmc_cntl_ume_preg_hdr_t) + +#define LBMC_CNTL_UME_PREG_MARKER(x) (x & 0x7F) +#define LBMC_CNTL_UME_PREG_MARKER_MASK 0x7F + +/* LBMC control UME persistent registration response header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t code; + lbm_uint8_t marker; + lbm_uint32_t reg_id; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; + lbm_uint32_t low_seqnum; + lbm_uint32_t high_seqnum; +} lbmc_cntl_ume_preg_resp_hdr_t; +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, code) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, code) +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, marker) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, marker) +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_REG_ID OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, reg_id) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_REG_ID SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, reg_id) +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, transport_idx) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, transport_idx) +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, topic_idx) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, topic_idx) +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_LOW_SEQNUM OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, low_seqnum) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_LOW_SEQNUM SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, low_seqnum) +#define O_LBMC_CNTL_UME_PREG_RESP_HDR_T_HIGH_SEQNUM OFFSETOF(lbmc_cntl_ume_preg_resp_hdr_t, high_seqnum) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T_HIGH_SEQNUM SIZEOF(lbmc_cntl_ume_preg_resp_hdr_t, high_seqnum) +#define L_LBMC_CNTL_UME_PREG_RESP_HDR_T (gint) sizeof(lbmc_cntl_ume_preg_resp_hdr_t) + +#define LBMC_CNTL_UME_PREG_RESP_CODE(x) (x & 0x0F) +#define LBMC_CNTL_UME_PREG_RESP_CODE_MASK 0x0F + +/* LBMC control UME acknowledgement header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t type; + lbm_uint32_t transport_idx; + lbm_uint32_t id_2; + lbm_uint32_t rcv_reg_id; + lbm_uint32_t seqnum; +} lbmc_cntl_ume_ack_hdr_t; +#define O_LBMC_CNTL_UME_ACK_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_ack_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_ACK_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_ack_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_ACK_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_ack_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_ACK_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_ack_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_ACK_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_ack_hdr_t, flags) +#define L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_ack_hdr_t, flags) +#define O_LBMC_CNTL_UME_ACK_HDR_T_TYPE OFFSETOF(lbmc_cntl_ume_ack_hdr_t, type) +#define L_LBMC_CNTL_UME_ACK_HDR_T_TYPE SIZEOF(lbmc_cntl_ume_ack_hdr_t, type) +#define O_LBMC_CNTL_UME_ACK_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_ume_ack_hdr_t, transport_idx) +#define L_LBMC_CNTL_UME_ACK_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_ume_ack_hdr_t, transport_idx) +#define O_LBMC_CNTL_UME_ACK_HDR_T_ID_2 OFFSETOF(lbmc_cntl_ume_ack_hdr_t, id_2) +#define L_LBMC_CNTL_UME_ACK_HDR_T_ID_2 SIZEOF(lbmc_cntl_ume_ack_hdr_t, id_2) +#define O_LBMC_CNTL_UME_ACK_HDR_T_RCV_REG_ID OFFSETOF(lbmc_cntl_ume_ack_hdr_t, rcv_reg_id) +#define L_LBMC_CNTL_UME_ACK_HDR_T_RCV_REG_ID SIZEOF(lbmc_cntl_ume_ack_hdr_t, rcv_reg_id) +#define O_LBMC_CNTL_UME_ACK_HDR_T_SEQNUM OFFSETOF(lbmc_cntl_ume_ack_hdr_t, seqnum) +#define L_LBMC_CNTL_UME_ACK_HDR_T_SEQNUM SIZEOF(lbmc_cntl_ume_ack_hdr_t, seqnum) +#define L_LBMC_CNTL_UME_ACK_HDR_T (gint) sizeof(lbmc_cntl_ume_ack_hdr_t) + +/* LBMC control UME ranged acknowledgement header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t first_seqnum; + lbm_uint32_t last_seqnum; +} lbmc_cntl_ume_ranged_ack_hdr_t; +#define O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_ranged_ack_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_ranged_ack_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_ranged_ack_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_ranged_ack_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_ranged_ack_hdr_t, flags) +#define L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_ranged_ack_hdr_t, flags) +#define O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FIRST_SEQNUM OFFSETOF(lbmc_cntl_ume_ranged_ack_hdr_t, first_seqnum) +#define L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FIRST_SEQNUM SIZEOF(lbmc_cntl_ume_ranged_ack_hdr_t, first_seqnum) +#define O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_LAST_SEQNUM OFFSETOF(lbmc_cntl_ume_ranged_ack_hdr_t, last_seqnum) +#define L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_LAST_SEQNUM SIZEOF(lbmc_cntl_ume_ranged_ack_hdr_t, last_seqnum) +#define L_LBMC_CNTL_UME_RANGED_ACK_HDR_T (gint) sizeof(lbmc_cntl_ume_ranged_ack_hdr_t) + +/* LBMC control UME acknowledgement ID header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t id; +} lbmc_cntl_ume_ack_id_hdr_t; +#define O_LBMC_CNTL_UME_ACK_ID_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_ack_id_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_ACK_ID_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_ack_id_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_ACK_ID_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_ack_id_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_ACK_ID_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_ack_id_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_ACK_ID_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_ack_id_hdr_t, flags) +#define L_LBMC_CNTL_UME_ACK_ID_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_ack_id_hdr_t, flags) +#define O_LBMC_CNTL_UME_ACK_ID_HDR_T_ID OFFSETOF(lbmc_cntl_ume_ack_id_hdr_t, id) +#define L_LBMC_CNTL_UME_ACK_ID_HDR_T_ID SIZEOF(lbmc_cntl_ume_ack_id_hdr_t, id) +#define L_LBMC_CNTL_UME_ACK_ID_HDR_T (gint) sizeof(lbmc_cntl_ume_ack_id_hdr_t) + +/* LBMC control UME retransmision request header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t request_idx; + lbm_uint32_t transport_idx; + lbm_uint32_t id_2; + lbm_uint32_t seqnum; + lbm_uint16_t rx_port; + lbm_uint16_t res; + lbm_uint32_t rx_ip; +} lbmc_cntl_ume_rxreq_hdr_t; +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, flags) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, flags) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_REQUEST_IDX OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, request_idx) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_REQUEST_IDX SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, request_idx) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, transport_idx) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, transport_idx) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_ID_2 OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, id_2) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_ID_2 SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, id_2) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_SEQNUM OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, seqnum) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_SEQNUM SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, seqnum) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_RX_PORT OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, rx_port) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_RX_PORT SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, rx_port) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_RES OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, res) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_RES SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, res) +#define O_LBMC_CNTL_UME_RXREQ_HDR_T_RX_IP OFFSETOF(lbmc_cntl_ume_rxreq_hdr_t, rx_ip) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T_RX_IP SIZEOF(lbmc_cntl_ume_rxreq_hdr_t, rx_ip) +#define L_LBMC_CNTL_UME_RXREQ_HDR_T (gint) sizeof(lbmc_cntl_ume_rxreq_hdr_t) + +/* LBMC control late join initiation request */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t request_idx; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; + lbm_uint32_t req_ip; + lbm_uint16_t req_port; + lbm_uint16_t res; + lbm_uint32_t tx_low_sqn; + lbm_uint32_t rx_req_max; + lbm_uint32_t rx_req_outstanding_max; +} lbmc_cntl_lji_req_hdr_t; +#define O_LBMC_CNTL_LJI_REQ_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_lji_req_hdr_t, next_hdr) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_lji_req_hdr_t, next_hdr) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_lji_req_hdr_t, hdr_len) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_lji_req_hdr_t, hdr_len) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS OFFSETOF(lbmc_cntl_lji_req_hdr_t, flags) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS SIZEOF(lbmc_cntl_lji_req_hdr_t, flags) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_REQUEST_IDX OFFSETOF(lbmc_cntl_lji_req_hdr_t, request_idx) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_REQUEST_IDX SIZEOF(lbmc_cntl_lji_req_hdr_t, request_idx) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_lji_req_hdr_t, transport_idx) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_lji_req_hdr_t, transport_idx) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_lji_req_hdr_t, topic_idx) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_lji_req_hdr_t, topic_idx) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_REQ_IP OFFSETOF(lbmc_cntl_lji_req_hdr_t, req_ip) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_REQ_IP SIZEOF(lbmc_cntl_lji_req_hdr_t, req_ip) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_REQ_PORT OFFSETOF(lbmc_cntl_lji_req_hdr_t, req_port) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_REQ_PORT SIZEOF(lbmc_cntl_lji_req_hdr_t, req_port) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_RES OFFSETOF(lbmc_cntl_lji_req_hdr_t, res) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_RES SIZEOF(lbmc_cntl_lji_req_hdr_t, res) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_TX_LOW_SQN OFFSETOF(lbmc_cntl_lji_req_hdr_t, tx_low_sqn) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_TX_LOW_SQN SIZEOF(lbmc_cntl_lji_req_hdr_t, tx_low_sqn) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_RX_REQ_MAX OFFSETOF(lbmc_cntl_lji_req_hdr_t, rx_req_max) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_RX_REQ_MAX SIZEOF(lbmc_cntl_lji_req_hdr_t, rx_req_max) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_RX_REQ_OUTSTANDING_MAX OFFSETOF(lbmc_cntl_lji_req_hdr_t, rx_req_outstanding_max) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_RX_REQ_OUTSTANDING_MAX SIZEOF(lbmc_cntl_lji_req_hdr_t, rx_req_outstanding_max) +#define O_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS OFFSETOF(lbmc_cntl_lji_req_hdr_t, flags) +#define L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS SIZEOF(lbmc_cntl_lji_req_hdr_t, flags) +#define L_LBMC_CNTL_LJI_REQ_HDR_T (gint) sizeof(lbmc_cntl_lji_req_hdr_t) + +/* LBMC control UME keepalive header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t type; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; + lbm_uint32_t reg_id; +} lbmc_cntl_ume_keepalive_hdr_t; +#define O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_keepalive_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_keepalive_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_keepalive_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_keepalive_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_keepalive_hdr_t, flags) +#define L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_keepalive_hdr_t, flags) +#define O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TYPE OFFSETOF(lbmc_cntl_ume_keepalive_hdr_t, type) +#define L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TYPE SIZEOF(lbmc_cntl_ume_keepalive_hdr_t, type) +#define O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_ume_keepalive_hdr_t, transport_idx) +#define L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_ume_keepalive_hdr_t, transport_idx) +#define O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_ume_keepalive_hdr_t, topic_idx) +#define L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_ume_keepalive_hdr_t, topic_idx) +#define O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_REG_ID OFFSETOF(lbmc_cntl_ume_keepalive_hdr_t, reg_id) +#define L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_REG_ID SIZEOF(lbmc_cntl_ume_keepalive_hdr_t, reg_id) +#define L_LBMC_CNTL_UME_KEEPALIVE_HDR_T (gint) sizeof(lbmc_cntl_ume_keepalive_hdr_t) + +/* LBMC control UME store ID header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t store_id; +} lbmc_cntl_ume_storeid_hdr_t; +#define O_LBMC_CNTL_UME_STOREID_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_storeid_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_STOREID_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_storeid_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_STOREID_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_storeid_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_STOREID_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_storeid_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID OFFSETOF(lbmc_cntl_ume_storeid_hdr_t, store_id) +#define L_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID SIZEOF(lbmc_cntl_ume_storeid_hdr_t, store_id) +#define L_LBMC_CNTL_UME_STOREID_HDR_T (gint) sizeof(lbmc_cntl_ume_storeid_hdr_t) + +#define LBMC_CNTL_UME_STOREID_STOREID(x) (x & 0x7FFF) +#define LBMC_CNTL_UME_STOREID_STOREID_MASK 0x7FFF + +/* LBMC control UME capability header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; +} lbmc_cntl_ume_capability_hdr_t; +#define O_LBMC_CNTL_UME_CAPABILITY_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_capability_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_CAPABILITY_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_capability_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_CAPABILITY_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_capability_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_CAPABILITY_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_capability_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_capability_hdr_t, flags) +#define L_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_capability_hdr_t, flags) +#define L_LBMC_CNTL_UME_CAPABILITY_HDR_T (gint) sizeof(lbmc_cntl_ume_capability_hdr_t) + +/* LBMC control UME Proxy Source header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; +} lbmc_cntl_ume_proxy_src_hdr_t; +#define O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_proxy_src_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_proxy_src_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_proxy_src_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_proxy_src_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_proxy_src_hdr_t, flags) +#define L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_proxy_src_hdr_t, flags) +#define L_LBMC_CNTL_UME_PROXY_SRC_HDR_T (gint) sizeof(lbmc_cntl_ume_proxy_src_hdr_t) + +/* LBMC control UME Store header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t grp_idx; + lbm_uint16_t store_tcp_port; + lbm_uint16_t store_idx; + lbm_uint32_t store_ip_addr; + lbm_uint32_t src_reg_id; +} lbmc_cntl_ume_store_hdr_t; +#define O_LBMC_CNTL_UME_STORE_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_store_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_STORE_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_store_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_STORE_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_store_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_STORE_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_store_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_STORE_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_store_hdr_t, flags) +#define L_LBMC_CNTL_UME_STORE_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_store_hdr_t, flags) +#define O_LBMC_CNTL_UME_STORE_HDR_T_GRP_IDX OFFSETOF(lbmc_cntl_ume_store_hdr_t, grp_idx) +#define L_LBMC_CNTL_UME_STORE_HDR_T_GRP_IDX SIZEOF(lbmc_cntl_ume_store_hdr_t, grp_idx) +#define O_LBMC_CNTL_UME_STORE_HDR_T_STORE_TCP_PORT OFFSETOF(lbmc_cntl_ume_store_hdr_t, store_tcp_port) +#define L_LBMC_CNTL_UME_STORE_HDR_T_STORE_TCP_PORT SIZEOF(lbmc_cntl_ume_store_hdr_t, store_tcp_port) +#define O_LBMC_CNTL_UME_STORE_HDR_T_STORE_IDX OFFSETOF(lbmc_cntl_ume_store_hdr_t, store_idx) +#define L_LBMC_CNTL_UME_STORE_HDR_T_STORE_IDX SIZEOF(lbmc_cntl_ume_store_hdr_t, store_idx) +#define O_LBMC_CNTL_UME_STORE_HDR_T_STORE_IP_ADDR OFFSETOF(lbmc_cntl_ume_store_hdr_t, store_ip_addr) +#define L_LBMC_CNTL_UME_STORE_HDR_T_STORE_IP_ADDR SIZEOF(lbmc_cntl_ume_store_hdr_t, store_ip_addr) +#define O_LBMC_CNTL_UME_STORE_HDR_T_SRC_REG_ID OFFSETOF(lbmc_cntl_ume_store_hdr_t, src_reg_id) +#define L_LBMC_CNTL_UME_STORE_HDR_T_SRC_REG_ID SIZEOF(lbmc_cntl_ume_store_hdr_t, src_reg_id) +#define L_LBMC_CNTL_UME_STORE_HDR_T (gint) sizeof(lbmc_cntl_ume_store_hdr_t) + +/* LBMC control UME Store Extended header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t grp_idx; + lbm_uint16_t store_tcp_port; + lbm_uint16_t store_idx; + lbm_uint32_t store_ip_addr; + lbm_uint32_t src_reg_id; + lbm_uint32_t domain_id; + lbm_uint32_t version; +} lbmc_cntl_ume_store_ext_hdr_t; +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, flags) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, flags) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_GRP_IDX OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, grp_idx) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_GRP_IDX SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, grp_idx) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_TCP_PORT OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, store_tcp_port) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_TCP_PORT SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, store_tcp_port) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_IDX OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, store_idx) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_IDX SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, store_idx) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_IP_ADDR OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, store_ip_addr) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_IP_ADDR SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, store_ip_addr) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_SRC_REG_ID OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, src_reg_id) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_SRC_REG_ID SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, src_reg_id) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_DOMAIN_ID OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, domain_id) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_DOMAIN_ID SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, domain_id) +#define O_LBMC_CNTL_UME_STORE_EXT_HDR_T_VERSION OFFSETOF(lbmc_cntl_ume_store_ext_hdr_t, version) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T_VERSION SIZEOF(lbmc_cntl_ume_store_ext_hdr_t, version) +#define L_LBMC_CNTL_UME_STORE_EXT_HDR_T (gint) sizeof(lbmc_cntl_ume_store_ext_hdr_t) + +/* LBMC control UME Late Join info header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t low_seqnum; + lbm_uint32_t high_seqnum; + lbm_uint32_t qidx; +} lbmc_cntl_ume_lj_info_hdr_t; +#define O_LBMC_CNTL_UME_LJ_INFO_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_lj_info_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_LJ_INFO_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_lj_info_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_LJ_INFO_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_lj_info_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_LJ_INFO_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_lj_info_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_LJ_INFO_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_lj_info_hdr_t, flags) +#define L_LBMC_CNTL_UME_LJ_INFO_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_lj_info_hdr_t, flags) +#define O_LBMC_CNTL_UME_LJ_INFO_HDR_T_LOW_SEQNUM OFFSETOF(lbmc_cntl_ume_lj_info_hdr_t, low_seqnum) +#define L_LBMC_CNTL_UME_LJ_INFO_HDR_T_LOW_SEQNUM SIZEOF(lbmc_cntl_ume_lj_info_hdr_t, low_seqnum) +#define O_LBMC_CNTL_UME_LJ_INFO_HDR_T_HIGH_SEQNUM OFFSETOF(lbmc_cntl_ume_lj_info_hdr_t, high_seqnum) +#define L_LBMC_CNTL_UME_LJ_INFO_HDR_T_HIGH_SEQNUM SIZEOF(lbmc_cntl_ume_lj_info_hdr_t, high_seqnum) +#define O_LBMC_CNTL_UME_LJ_INFO_HDR_T_QIDX OFFSETOF(lbmc_cntl_ume_lj_info_hdr_t, qidx) +#define L_LBMC_CNTL_UME_LJ_INFO_HDR_T_QIDX SIZEOF(lbmc_cntl_ume_lj_info_hdr_t, qidx) +#define L_LBMC_CNTL_UME_LJ_INFO_HDR_T (gint) sizeof(lbmc_cntl_ume_lj_info_hdr_t) + +/* LBMC control UME Store Group header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t grp_idx; + lbm_uint16_t grp_sz; + lbm_uint16_t res1; +} lbmc_cntl_ume_store_group_hdr_t; +#define O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_store_group_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_store_group_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_store_group_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_store_group_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_store_group_hdr_t, flags) +#define L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_store_group_hdr_t, flags) +#define O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_GRP_IDX OFFSETOF(lbmc_cntl_ume_store_group_hdr_t, grp_idx) +#define L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_GRP_IDX SIZEOF(lbmc_cntl_ume_store_group_hdr_t, grp_idx) +#define O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_GRP_SZ OFFSETOF(lbmc_cntl_ume_store_group_hdr_t, grp_sz) +#define L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_GRP_SZ SIZEOF(lbmc_cntl_ume_store_group_hdr_t, grp_sz) +#define O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_RES1 OFFSETOF(lbmc_cntl_ume_store_group_hdr_t, res1) +#define L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_RES1 SIZEOF(lbmc_cntl_ume_store_group_hdr_t, res1) +#define L_LBMC_CNTL_UME_STORE_GROUP_HDR_T (gint) sizeof(lbmc_cntl_ume_store_group_hdr_t) + +/* LBMC control TSNI header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t num_recs; +} lbmc_cntl_tsni_hdr_t; +#define O_LBMC_CNTL_TSNI_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_tsni_hdr_t, next_hdr) +#define L_LBMC_CNTL_TSNI_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_tsni_hdr_t, next_hdr) +#define O_LBMC_CNTL_TSNI_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_tsni_hdr_t, hdr_len) +#define L_LBMC_CNTL_TSNI_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_tsni_hdr_t, hdr_len) +#define O_LBMC_CNTL_TSNI_HDR_T_NUM_RECS OFFSETOF(lbmc_cntl_tsni_hdr_t, num_recs) +#define L_LBMC_CNTL_TSNI_HDR_T_NUM_RECS SIZEOF(lbmc_cntl_tsni_hdr_t, num_recs) +#define L_LBMC_CNTL_TSNI_HDR_T (gint) sizeof(lbmc_cntl_tsni_hdr_t) + +#define LBMC_CNTL_TSNI_NUM_RECS_MASK 0x7fff + +typedef struct +{ + lbm_uint32_t tidx; + lbm_uint32_t sqn; +} lbmc_cntl_tsni_rec_hdr_t; +#define O_LBMC_CNTL_TSNI_REC_HDR_T_TIDX OFFSETOF(lbmc_cntl_tsni_rec_hdr_t, tidx) +#define L_LBMC_CNTL_TSNI_REC_HDR_T_TIDX SIZEOF(lbmc_cntl_tsni_rec_hdr_t, tidx) +#define O_LBMC_CNTL_TSNI_REC_HDR_T_SQN OFFSETOF(lbmc_cntl_tsni_rec_hdr_t, sqn) +#define L_LBMC_CNTL_TSNI_REC_HDR_T_SQN SIZEOF(lbmc_cntl_tsni_rec_hdr_t, sqn) +#define L_LBMC_CNTL_TSNI_REC_HDR_T (gint) sizeof(lbmc_cntl_tsni_rec_hdr_t) + +/* LBMC control UMQ registration header(s) */ +typedef struct +{ + lbm_uint16_t port; + lbm_uint16_t reserved; + lbm_uint32_t ip; + lbm_uint32_t capabilities; +} lbmc_cntl_umq_reg_ctx_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_CTX_HDR_T_PORT OFFSETOF(lbmc_cntl_umq_reg_ctx_hdr_t, port) +#define L_LBMC_CNTL_UMQ_REG_CTX_HDR_T_PORT SIZEOF(lbmc_cntl_umq_reg_ctx_hdr_t, port) +#define O_LBMC_CNTL_UMQ_REG_CTX_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_reg_ctx_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_CTX_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_reg_ctx_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_REG_CTX_HDR_T_IP OFFSETOF(lbmc_cntl_umq_reg_ctx_hdr_t, ip) +#define L_LBMC_CNTL_UMQ_REG_CTX_HDR_T_IP SIZEOF(lbmc_cntl_umq_reg_ctx_hdr_t, ip) +#define O_LBMC_CNTL_UMQ_REG_CTX_HDR_T_CAPABILITIES OFFSETOF(lbmc_cntl_umq_reg_ctx_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_CTX_HDR_T_CAPABILITIES SIZEOF(lbmc_cntl_umq_reg_ctx_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_CTX_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_ctx_hdr_t) + +typedef struct +{ + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; +} lbmc_cntl_umq_reg_src_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_SRC_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_umq_reg_src_hdr_t, transport_idx) +#define L_LBMC_CNTL_UMQ_REG_SRC_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_umq_reg_src_hdr_t, transport_idx) +#define O_LBMC_CNTL_UMQ_REG_SRC_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_umq_reg_src_hdr_t, topic_idx) +#define L_LBMC_CNTL_UMQ_REG_SRC_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_umq_reg_src_hdr_t, topic_idx) +#define L_LBMC_CNTL_UMQ_REG_SRC_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_src_hdr_t) + +typedef struct +{ + lbm_uint32_t assign_id; + lbm_uint32_t rcv_type_id; + lbm_uint32_t last_topic_rcr_tsp; +} lbmc_cntl_umq_reg_rcv_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_reg_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_REG_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_reg_rcv_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_REG_RCV_HDR_T_RCV_TYPE_ID OFFSETOF(lbmc_cntl_umq_reg_rcv_hdr_t, rcv_type_id) +#define L_LBMC_CNTL_UMQ_REG_RCV_HDR_T_RCV_TYPE_ID SIZEOF(lbmc_cntl_umq_reg_rcv_hdr_t, rcv_type_id) +#define O_LBMC_CNTL_UMQ_REG_RCV_HDR_T_LAST_TOPIC_RCR_TSP OFFSETOF(lbmc_cntl_umq_reg_rcv_hdr_t, last_topic_rcr_tsp) +#define L_LBMC_CNTL_UMQ_REG_RCV_HDR_T_LAST_TOPIC_RCR_TSP SIZEOF(lbmc_cntl_umq_reg_rcv_hdr_t, last_topic_rcr_tsp) +#define L_LBMC_CNTL_UMQ_REG_RCV_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_rcv_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_rcv_dereg_hdr_t; +#define O_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_rcv_dereg_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_rcv_dereg_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rcv_dereg_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rcv_dereg_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T (gint) sizeof(lbmc_cntl_umq_rcv_dereg_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint32_t rcv_type_id; + lbm_uint16_t port; + lbm_uint16_t reserved; + lbm_uint32_t ip; + lbm_uint32_t capabilities; +} lbmc_cntl_umq_reg_ulb_rcv_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_RCV_TYPE_ID OFFSETOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, rcv_type_id) +#define L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_RCV_TYPE_ID SIZEOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, rcv_type_id) +#define O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_PORT OFFSETOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, port) +#define L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_PORT SIZEOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, port) +#define O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_IP OFFSETOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, ip) +#define L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_IP SIZEOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, ip) +#define O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_CAPABILITIES OFFSETOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_CAPABILITIES SIZEOF(lbmc_cntl_umq_reg_ulb_rcv_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_ulb_rcv_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_ulb_rcv_dereg_hdr_t; +#define O_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_ulb_rcv_dereg_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_ulb_rcv_dereg_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ulb_rcv_dereg_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ulb_rcv_dereg_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T (gint) sizeof(lbmc_cntl_umq_ulb_rcv_dereg_hdr_t) + +typedef struct +{ + lbm_uint32_t assign_id; + lbm_uint32_t rcv_type_id; + lbm_uint32_t last_topic_rcr_tsp; +} lbmc_cntl_umq_reg_observer_rcv_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_reg_observer_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_reg_observer_rcv_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_RCV_TYPE_ID OFFSETOF(lbmc_cntl_umq_reg_observer_rcv_hdr_t, rcv_type_id) +#define L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_RCV_TYPE_ID SIZEOF(lbmc_cntl_umq_reg_observer_rcv_hdr_t, rcv_type_id) +#define O_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_LAST_TOPIC_RCR_TSP OFFSETOF(lbmc_cntl_umq_reg_observer_rcv_hdr_t, last_topic_rcr_tsp) +#define L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_LAST_TOPIC_RCR_TSP SIZEOF(lbmc_cntl_umq_reg_observer_rcv_hdr_t, last_topic_rcr_tsp) +#define L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_observer_rcv_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_observer_rcv_dereg_hdr_t; +#define O_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_observer_rcv_dereg_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_observer_rcv_dereg_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_observer_rcv_dereg_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_observer_rcv_dereg_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T (gint) sizeof(lbmc_cntl_umq_observer_rcv_dereg_hdr_t) + +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t reg_type; + lbm_uint32_t queue_id; + lbm_uint16_t cmd_id; + lbm_uint16_t inst_idx; + lbm_uint8_t regid[8]; +} lbmc_cntl_umq_reg_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_reg_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_REG_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_reg_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_REG_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_reg_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_REG_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_reg_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_reg_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_reg_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_REG_HDR_T_REG_TYPE OFFSETOF(lbmc_cntl_umq_reg_hdr_t, reg_type) +#define L_LBMC_CNTL_UMQ_REG_HDR_T_REG_TYPE SIZEOF(lbmc_cntl_umq_reg_hdr_t, reg_type) +#define O_LBMC_CNTL_UMQ_REG_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_reg_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_REG_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_reg_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_REG_HDR_T_CMD_ID OFFSETOF(lbmc_cntl_umq_reg_hdr_t, cmd_id) +#define L_LBMC_CNTL_UMQ_REG_HDR_T_CMD_ID SIZEOF(lbmc_cntl_umq_reg_hdr_t, cmd_id) +#define O_LBMC_CNTL_UMQ_REG_HDR_T_INST_IDX OFFSETOF(lbmc_cntl_umq_reg_hdr_t, inst_idx) +#define L_LBMC_CNTL_UMQ_REG_HDR_T_INST_IDX SIZEOF(lbmc_cntl_umq_reg_hdr_t, inst_idx) +#define O_LBMC_CNTL_UMQ_REG_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_reg_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_REG_HDR_T_REGID SIZEOF(lbmc_cntl_umq_reg_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_REG_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_hdr_t) + +/* LBMC control UMQ registration response header(s) */ +typedef struct +{ + lbm_uint32_t capabilities; +} lbmc_cntl_umq_reg_resp_ctx_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RESP_CTX_HDR_T_CAPABILITIES OFFSETOF(lbmc_cntl_umq_reg_resp_ctx_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_RESP_CTX_HDR_T_CAPABILITIES SIZEOF(lbmc_cntl_umq_reg_resp_ctx_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_RESP_CTX_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_resp_ctx_hdr_t) + +typedef struct +{ + lbm_uint32_t capabilities; + lbm_uint16_t reserved; + lbm_uint16_t flags; + lbm_uint8_t stamp[8]; +} lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_CAPABILITIES OFFSETOF(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_CAPABILITIES SIZEOF(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t, capabilities) +#define O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_STAMP OFFSETOF(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t, stamp) +#define L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_STAMP SIZEOF(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t, stamp) +#define L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_resp_ctx_ex_hdr_t) + +typedef struct +{ + lbm_uint16_t reserved; + lbm_uint16_t code; +} lbmc_cntl_umq_reg_resp_err_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_reg_resp_err_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_reg_resp_err_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T_CODE OFFSETOF(lbmc_cntl_umq_reg_resp_err_hdr_t, code) +#define L_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T_CODE SIZEOF(lbmc_cntl_umq_reg_resp_err_hdr_t, code) +#define L_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_resp_err_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; +} lbmc_cntl_umq_reg_resp_src_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RESP_SRC_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_reg_resp_src_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_REG_RESP_SRC_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_reg_resp_src_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_REG_RESP_SRC_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_resp_src_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_reg_resp_rcv_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_reg_resp_rcv_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_reg_resp_rcv_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_reg_resp_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_reg_resp_rcv_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_reg_resp_rcv_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_reg_resp_rcv_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_reg_resp_rcv_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_reg_resp_rcv_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_resp_rcv_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_rcv_dereg_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_rcv_dereg_resp_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_rcv_dereg_resp_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rcv_dereg_resp_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rcv_dereg_resp_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_rcv_dereg_resp_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; + lbm_uint32_t capabilities; +} lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_CAPABILITIES OFFSETOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_CAPABILITIES SIZEOF(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t, capabilities) +#define L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_resp_ulb_rcv_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_ulb_rcv_dereg_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_ulb_rcv_dereg_resp_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_ulb_rcv_dereg_resp_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ulb_rcv_dereg_resp_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ulb_rcv_dereg_resp_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_ulb_rcv_dereg_resp_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_resp_observer_rcv_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_observer_rcv_dereg_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_observer_rcv_dereg_resp_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_observer_rcv_dereg_resp_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_observer_rcv_dereg_resp_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_observer_rcv_dereg_resp_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_observer_rcv_dereg_resp_hdr_t) + +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t resp_type; + lbm_uint32_t queue_id; + lbm_uint16_t cmd_id; + lbm_uint16_t inst_idx; + lbm_uint8_t regid[8]; +} lbmc_cntl_umq_reg_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_reg_resp_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_reg_resp_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_reg_resp_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_reg_resp_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_reg_resp_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_reg_resp_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESP_TYPE OFFSETOF(lbmc_cntl_umq_reg_resp_hdr_t, resp_type) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESP_TYPE SIZEOF(lbmc_cntl_umq_reg_resp_hdr_t, resp_type) +#define O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_reg_resp_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_reg_resp_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_CMD_ID OFFSETOF(lbmc_cntl_umq_reg_resp_hdr_t, cmd_id) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_CMD_ID SIZEOF(lbmc_cntl_umq_reg_resp_hdr_t, cmd_id) +#define O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_INST_IDX OFFSETOF(lbmc_cntl_umq_reg_resp_hdr_t, inst_idx) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_INST_IDX SIZEOF(lbmc_cntl_umq_reg_resp_hdr_t, inst_idx) +#define O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESPID OFFSETOF(lbmc_cntl_umq_reg_resp_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESPID SIZEOF(lbmc_cntl_umq_reg_resp_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_REG_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_reg_resp_hdr_t) + +/* LBMC control UMQ ACK header(s) */ +typedef struct +{ + lbm_uint8_t regid[8]; + lbm_uint8_t stamp[8]; +} lbmc_cntl_umq_ack_msgid_hdr_t; +#define O_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_ack_msgid_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T_REGID SIZEOF(lbmc_cntl_umq_ack_msgid_hdr_t, regid) +#define O_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T_STAMP OFFSETOF(lbmc_cntl_umq_ack_msgid_hdr_t, stamp) +#define L_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T_STAMP SIZEOF(lbmc_cntl_umq_ack_msgid_hdr_t, stamp) +#define L_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T (gint) sizeof(lbmc_cntl_umq_ack_msgid_hdr_t) + +typedef struct +{ + lbm_uint32_t queue_id; + lbm_uint16_t inst_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_ack_stable_hdr_t; +#define O_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_ack_stable_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_ack_stable_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_INST_IDX OFFSETOF(lbmc_cntl_umq_ack_stable_hdr_t, inst_idx) +#define L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_INST_IDX SIZEOF(lbmc_cntl_umq_ack_stable_hdr_t, inst_idx) +#define O_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ack_stable_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ack_stable_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T (gint) sizeof(lbmc_cntl_umq_ack_stable_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_ack_cr_hdr_t; +#define O_LBMC_CNTL_UMQ_ACK_CR_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_ack_cr_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_ACK_CR_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_ack_cr_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_ACK_CR_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ack_cr_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ACK_CR_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ack_cr_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_ACK_CR_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_ack_cr_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_ACK_CR_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_ack_cr_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_ACK_CR_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ack_cr_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ACK_CR_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ack_cr_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ACK_CR_HDR_T (gint) sizeof(lbmc_cntl_umq_ack_cr_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_ack_ulb_cr_hdr_t; +#define O_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_ack_ulb_cr_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_ack_ulb_cr_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ack_ulb_cr_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ack_ulb_cr_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_ack_ulb_cr_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_ack_ulb_cr_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ack_ulb_cr_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ack_ulb_cr_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T (gint) sizeof(lbmc_cntl_umq_ack_ulb_cr_hdr_t) + +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t msgs; + lbm_uint8_t ack_type; +} lbmc_cntl_umq_ack_hdr_t; +#define O_LBMC_CNTL_UMQ_ACK_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_ack_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_ACK_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_ack_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_ACK_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_ack_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_ACK_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_ack_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS OFFSETOF(lbmc_cntl_umq_ack_hdr_t, msgs) +#define L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS SIZEOF(lbmc_cntl_umq_ack_hdr_t, msgs) +#define O_LBMC_CNTL_UMQ_ACK_HDR_T_ACK_TYPE OFFSETOF(lbmc_cntl_umq_ack_hdr_t, ack_type) +#define L_LBMC_CNTL_UMQ_ACK_HDR_T_ACK_TYPE SIZEOF(lbmc_cntl_umq_ack_hdr_t, ack_type) +#define L_LBMC_CNTL_UMQ_ACK_HDR_T (gint) sizeof(lbmc_cntl_umq_ack_hdr_t) + +/* UMQ control receiver control record header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t queue_id; + lbm_uint32_t rcr_idx; + lbm_uint8_t msgid_regid[8]; + lbm_uint8_t msgid_stamp[8]; + lbm_uint32_t topic_tsp; + lbm_uint32_t q_tsp; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t num_ras; + lbm_uint32_t queue_ver; +} lbmc_cntl_umq_rcr_hdr_t; +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_rcr_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_rcr_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_rcr_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_rcr_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_rcr_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_MSGID_REGID OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, msgid_regid) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_MSGID_REGID SIZEOF(lbmc_cntl_umq_rcr_hdr_t, msgid_regid) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_MSGID_STAMP OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_MSGID_STAMP SIZEOF(lbmc_cntl_umq_rcr_hdr_t, msgid_stamp) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_TOPIC_TSP OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, topic_tsp) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_TOPIC_TSP SIZEOF(lbmc_cntl_umq_rcr_hdr_t, topic_tsp) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_Q_TSP OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, q_tsp) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_Q_TSP SIZEOF(lbmc_cntl_umq_rcr_hdr_t, q_tsp) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rcr_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_rcr_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_NUM_RAS OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, num_ras) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_NUM_RAS SIZEOF(lbmc_cntl_umq_rcr_hdr_t, num_ras) +#define O_LBMC_CNTL_UMQ_RCR_HDR_T_QUEUE_VER OFFSETOF(lbmc_cntl_umq_rcr_hdr_t, queue_ver) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T_QUEUE_VER SIZEOF(lbmc_cntl_umq_rcr_hdr_t, queue_ver) +#define L_LBMC_CNTL_UMQ_RCR_HDR_T (gint) sizeof(lbmc_cntl_umq_rcr_hdr_t) + +/* LBMC control UMQ keepalive header(s) */ +typedef struct +{ + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; +} lbmc_cntl_umq_ka_src_hdr_t; +#define O_LBMC_CNTL_UMQ_KA_SRC_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_umq_ka_src_hdr_t, transport_idx) +#define L_LBMC_CNTL_UMQ_KA_SRC_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_umq_ka_src_hdr_t, transport_idx) +#define O_LBMC_CNTL_UMQ_KA_SRC_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_umq_ka_src_hdr_t, topic_idx) +#define L_LBMC_CNTL_UMQ_KA_SRC_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_umq_ka_src_hdr_t, topic_idx) +#define L_LBMC_CNTL_UMQ_KA_SRC_HDR_T (gint) sizeof(lbmc_cntl_umq_ka_src_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_ka_rcv_hdr_t; +#define O_LBMC_CNTL_UMQ_KA_RCV_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_ka_rcv_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_KA_RCV_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_ka_rcv_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_KA_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ka_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_KA_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ka_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_KA_RCV_HDR_T (gint) sizeof(lbmc_cntl_umq_ka_rcv_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_ka_ulb_rcv_hdr_t; +#define O_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_ka_ulb_rcv_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_ka_ulb_rcv_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ka_ulb_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ka_ulb_rcv_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T (gint) sizeof(lbmc_cntl_umq_ka_ulb_rcv_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_ka_ulb_rcv_resp_hdr_t) + +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t ka_type; + lbm_uint32_t queue_id; + lbm_uint8_t regid[8]; + lbm_uint16_t inst_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_ka_hdr_t; +#define O_LBMC_CNTL_UMQ_KA_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_ka_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_KA_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_ka_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_KA_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_ka_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_KA_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_ka_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_ka_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_ka_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_KA_HDR_T_KA_TYPE OFFSETOF(lbmc_cntl_umq_ka_hdr_t, ka_type) +#define L_LBMC_CNTL_UMQ_KA_HDR_T_KA_TYPE SIZEOF(lbmc_cntl_umq_ka_hdr_t, ka_type) +#define O_LBMC_CNTL_UMQ_KA_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_ka_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_KA_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_ka_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_KA_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_ka_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_KA_HDR_T_REGID SIZEOF(lbmc_cntl_umq_ka_hdr_t, regid) +#define O_LBMC_CNTL_UMQ_KA_HDR_T_INST_IDX OFFSETOF(lbmc_cntl_umq_ka_hdr_t, inst_idx) +#define L_LBMC_CNTL_UMQ_KA_HDR_T_INST_IDX SIZEOF(lbmc_cntl_umq_ka_hdr_t, inst_idx) +#define O_LBMC_CNTL_UMQ_KA_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ka_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_KA_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ka_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_KA_HDR_T (gint) sizeof(lbmc_cntl_umq_ka_hdr_t) + +/* LBMC control UMQ retransmission request header(s) */ +typedef struct +{ + lbm_uint8_t regid[8]; +} lbmc_cntl_umq_rxreq_regid_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_REGID_RESP_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_rxreq_regid_resp_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_RXREQ_REGID_RESP_HDR_T_REGID SIZEOF(lbmc_cntl_umq_rxreq_regid_resp_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_RXREQ_REGID_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_regid_resp_hdr_t) + +typedef struct +{ + lbm_uint32_t ip; + lbm_uint16_t port; + lbm_uint16_t reserved; +} lbmc_cntl_umq_rxreq_addr_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_IP OFFSETOF(lbmc_cntl_umq_rxreq_addr_resp_hdr_t, ip) +#define L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_IP SIZEOF(lbmc_cntl_umq_rxreq_addr_resp_hdr_t, ip) +#define O_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_PORT OFFSETOF(lbmc_cntl_umq_rxreq_addr_resp_hdr_t, port) +#define L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_PORT SIZEOF(lbmc_cntl_umq_rxreq_addr_resp_hdr_t, port) +#define O_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_rxreq_addr_resp_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_rxreq_addr_resp_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_addr_resp_hdr_t) + +typedef struct +{ + lbm_uint32_t assign_id; + lbm_uint8_t msgid_regid[8]; + lbm_uint8_t msgid_stamp[8]; +} lbmc_cntl_umq_rxreq_mr_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rxreq_mr_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rxreq_mr_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_MSGID_REGID OFFSETOF(lbmc_cntl_umq_rxreq_mr_hdr_t, msgid_regid) +#define L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_MSGID_REGID SIZEOF(lbmc_cntl_umq_rxreq_mr_hdr_t, msgid_regid) +#define O_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_MSGID_STAMP OFFSETOF(lbmc_cntl_umq_rxreq_mr_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_MSGID_STAMP SIZEOF(lbmc_cntl_umq_rxreq_mr_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_mr_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; + lbm_uint8_t msgid_regid[8]; + lbm_uint8_t msgid_stamp[8]; +} lbmc_cntl_umq_rxreq_ulb_mr_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_MSGID_REGID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, msgid_regid) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_MSGID_REGID SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, msgid_regid) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_MSGID_STAMP OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_MSGID_STAMP SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_ulb_mr_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint8_t msgid_regid[8]; + lbm_uint8_t msgid_stamp[8]; +} lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_MSGID_REGID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t, msgid_regid) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_MSGID_REGID SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t, msgid_regid) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_MSGID_STAMP OFFSETOF(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_MSGID_STAMP SIZEOF(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_ulb_mr_abort_hdr_t) + +typedef struct +{ + lbm_uint32_t tsp; +} lbmc_cntl_umq_rxreq_qrcrr_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_QRCRR_HDR_T_TSP OFFSETOF(lbmc_cntl_umq_rxreq_qrcrr_hdr_t, tsp) +#define L_LBMC_CNTL_UMQ_RXREQ_QRCRR_HDR_T_TSP SIZEOF(lbmc_cntl_umq_rxreq_qrcrr_hdr_t, tsp) +#define L_LBMC_CNTL_UMQ_RXREQ_QRCRR_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_qrcrr_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t tsp; +} lbmc_cntl_umq_rxreq_trcrr_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_rxreq_trcrr_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_rxreq_trcrr_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T_TSP OFFSETOF(lbmc_cntl_umq_rxreq_trcrr_hdr_t, tsp) +#define L_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T_TSP SIZEOF(lbmc_cntl_umq_rxreq_trcrr_hdr_t, tsp) +#define L_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_trcrr_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint32_t tsp; +} lbmc_cntl_umq_rxreq_ulb_trcrr_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_trcrr_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_rxreq_ulb_trcrr_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_trcrr_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rxreq_ulb_trcrr_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_TSP OFFSETOF(lbmc_cntl_umq_rxreq_ulb_trcrr_hdr_t, tsp) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_TSP SIZEOF(lbmc_cntl_umq_rxreq_ulb_trcrr_hdr_t, tsp) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_ulb_trcrr_hdr_t) + +typedef struct +{ + lbm_uint32_t ulb_src_id; + lbm_uint32_t assign_id; + lbm_uint32_t tsp; +} lbmc_cntl_umq_rxreq_ulb_trcrr_abort_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_trcrr_abort_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_rxreq_ulb_trcrr_abort_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rxreq_ulb_trcrr_abort_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rxreq_ulb_trcrr_abort_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_TSP OFFSETOF(lbmc_cntl_umq_rxreq_ulb_trcrr_abort_hdr_t, tsp) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_TSP SIZEOF(lbmc_cntl_umq_rxreq_ulb_trcrr_abort_hdr_t, tsp) +#define L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_ulb_trcrr_abort_hdr_t) + +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t rxreq_type; +} lbmc_cntl_umq_rxreq_hdr_t; +#define O_LBMC_CNTL_UMQ_RXREQ_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_rxreq_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_RXREQ_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_rxreq_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_RXREQ_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_rxreq_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_RXREQ_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_rxreq_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_rxreq_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_rxreq_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_RXREQ_HDR_T_RXREQ_TYPE OFFSETOF(lbmc_cntl_umq_rxreq_hdr_t, rxreq_type) +#define L_LBMC_CNTL_UMQ_RXREQ_HDR_T_RXREQ_TYPE SIZEOF(lbmc_cntl_umq_rxreq_hdr_t, rxreq_type) +#define L_LBMC_CNTL_UMQ_RXREQ_HDR_T (gint) sizeof(lbmc_cntl_umq_rxreq_hdr_t) + +/* LBMC control UMQ queue management header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; +} lbmc_cntl_umq_qmgmt_hdr_t; +#define O_LBMC_CNTL_UMQ_QMGMT_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_qmgmt_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_QMGMT_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_qmgmt_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_QMGMT_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_qmgmt_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_QMGMT_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_qmgmt_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_QMGMT_HDR_T (gint) sizeof(lbmc_cntl_umq_qmgmt_hdr_t) + +/* LBMC control UMQ resubmission request header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint8_t msgid_regid[8]; + lbm_uint8_t msgid_stamp[8]; + lbm_uint32_t rcr_idx; + lbm_uint32_t resp_ip; + lbm_uint16_t resp_port; + lbm_uint16_t appset_idx; +} lbmc_cntl_umq_resub_req_hdr_t; +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_MSGID_REGID OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, msgid_regid) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_MSGID_REGID SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, msgid_regid) +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_MSGID_STAMP OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_MSGID_STAMP SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, msgid_stamp) +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RESP_IP OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, resp_ip) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RESP_IP SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, resp_ip) +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RESP_PORT OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, resp_port) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RESP_PORT SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, resp_port) +#define O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_resub_req_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_resub_req_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T (gint) sizeof(lbmc_cntl_umq_resub_req_hdr_t) + +/* LBMC control UMQ resubmission response header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t code; + lbm_uint8_t msgid_regid[8]; + lbm_uint8_t msgid_stamp[8]; + lbm_uint32_t rcr_idx; + lbm_uint16_t reserved; + lbm_uint16_t appset_idx; +} lbmc_cntl_umq_resub_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_CODE OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, code) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_CODE SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, code) +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_MSGID_REGID OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, msgid_regid) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_MSGID_REGID SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, msgid_regid) +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_MSGID_STAMP OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_MSGID_STAMP SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, msgid_stamp) +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_resub_resp_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_resub_resp_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_resub_resp_hdr_t) + +/* LBMC control topic interest header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t domain_id; +} lbmc_cntl_topic_interest_hdr_t; +#define O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_topic_interest_hdr_t, next_hdr) +#define L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_topic_interest_hdr_t, next_hdr) +#define O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_topic_interest_hdr_t, hdr_len) +#define L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_topic_interest_hdr_t, hdr_len) +#define O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS OFFSETOF(lbmc_cntl_topic_interest_hdr_t, flags) +#define L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS SIZEOF(lbmc_cntl_topic_interest_hdr_t, flags) +#define O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_DOMAIN_ID OFFSETOF(lbmc_cntl_topic_interest_hdr_t, domain_id) +#define L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_DOMAIN_ID SIZEOF(lbmc_cntl_topic_interest_hdr_t, domain_id) +#define L_LBMC_CNTL_TOPIC_INTEREST_HDR_T (gint) sizeof(lbmc_cntl_topic_interest_hdr_t) + +/* LBMC control pattern interest header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t type; + lbm_uint32_t domain_id; + lbm_uint8_t index[8]; +} lbmc_cntl_pattern_interest_hdr_t; +#define O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_pattern_interest_hdr_t, next_hdr) +#define L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_pattern_interest_hdr_t, next_hdr) +#define O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_pattern_interest_hdr_t, hdr_len) +#define L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_pattern_interest_hdr_t, hdr_len) +#define O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS OFFSETOF(lbmc_cntl_pattern_interest_hdr_t, flags) +#define L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS SIZEOF(lbmc_cntl_pattern_interest_hdr_t, flags) +#define O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_TYPE OFFSETOF(lbmc_cntl_pattern_interest_hdr_t, type) +#define L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_TYPE SIZEOF(lbmc_cntl_pattern_interest_hdr_t, type) +#define O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_DOMAIN_ID OFFSETOF(lbmc_cntl_pattern_interest_hdr_t, domain_id) +#define L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_DOMAIN_ID SIZEOF(lbmc_cntl_pattern_interest_hdr_t, domain_id) +#define O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_INDEX OFFSETOF(lbmc_cntl_pattern_interest_hdr_t, index) +#define L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_INDEX SIZEOF(lbmc_cntl_pattern_interest_hdr_t, index) +#define L_LBMC_CNTL_PATTERN_INTEREST_HDR_T (gint) sizeof(lbmc_cntl_pattern_interest_hdr_t) + +/* LBMC control advertisement header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t hop_count; + lbm_uint32_t ad_flags; + lbm_uint32_t cost; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; + lbm_uint32_t low_seqno; + lbm_uint32_t high_seqno; + lbm_uint32_t domain_id; + lbm_uint8_t pat_idx[8]; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmc_cntl_advertisement_hdr_t; +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_advertisement_hdr_t, next_hdr) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_advertisement_hdr_t, next_hdr) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_advertisement_hdr_t, hdr_len) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_advertisement_hdr_t, hdr_len) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS OFFSETOF(lbmc_cntl_advertisement_hdr_t, flags) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS SIZEOF(lbmc_cntl_advertisement_hdr_t, flags) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_HOP_COUNT OFFSETOF(lbmc_cntl_advertisement_hdr_t, hop_count) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_HOP_COUNT SIZEOF(lbmc_cntl_advertisement_hdr_t, hop_count) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS OFFSETOF(lbmc_cntl_advertisement_hdr_t, ad_flags) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS SIZEOF(lbmc_cntl_advertisement_hdr_t, ad_flags) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_COST OFFSETOF(lbmc_cntl_advertisement_hdr_t, cost) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_COST SIZEOF(lbmc_cntl_advertisement_hdr_t, cost) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_advertisement_hdr_t, transport_idx) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_advertisement_hdr_t, transport_idx) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_advertisement_hdr_t, topic_idx) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_advertisement_hdr_t, topic_idx) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_LOW_SEQNO OFFSETOF(lbmc_cntl_advertisement_hdr_t, low_seqno) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_LOW_SEQNO SIZEOF(lbmc_cntl_advertisement_hdr_t, low_seqno) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_HIGH_SEQNO OFFSETOF(lbmc_cntl_advertisement_hdr_t, high_seqno) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_HIGH_SEQNO SIZEOF(lbmc_cntl_advertisement_hdr_t, high_seqno) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_DOMAIN_ID OFFSETOF(lbmc_cntl_advertisement_hdr_t, domain_id) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_DOMAIN_ID SIZEOF(lbmc_cntl_advertisement_hdr_t, domain_id) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_PAT_IDX OFFSETOF(lbmc_cntl_advertisement_hdr_t, pat_idx) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_PAT_IDX SIZEOF(lbmc_cntl_advertisement_hdr_t, pat_idx) +#define O_LBMC_CNTL_ADVERTISEMENT_HDR_T_CTXINST OFFSETOF(lbmc_cntl_advertisement_hdr_t, ctxinst) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T_CTXINST SIZEOF(lbmc_cntl_advertisement_hdr_t, ctxinst) +#define L_LBMC_CNTL_ADVERTISEMENT_HDR_T (gint) sizeof(lbmc_cntl_advertisement_hdr_t) + +/* LBMC control UME storename header. */ +#define O_LBMC_UME_STORENAME_HDR_T_NEXT_HDR OFFSETOF(lbmc_basic_hdr_t, next_hdr) +#define L_LBMC_UME_STORENAME_HDR_T_NEXT_HDR SIZEOF(lbmc_basic_hdr_t, next_hdr) +#define O_LBMC_UME_STORENAME_HDR_T_HDR_LEN OFFSETOF(lbmc_basic_hdr_t, hdr_len) +#define L_LBMC_UME_STORENAME_HDR_T_HDR_LEN SIZEOF(lbmc_basic_hdr_t, hdr_len) +#define O_LBMC_UME_STORENAME_HDR_T_FLAGS OFFSETOF(lbmc_basic_hdr_t, res) +#define L_LBMC_UME_STORENAME_HDR_T_FLAGS SIZEOF(lbmc_basic_hdr_t, res) +#define O_LBMC_UME_STORENAME_HDR_T_STORE (OFFSETOF(lbmc_basic_hdr_t, res) + SIZEOF(lbmc_basic_hdr_t, res)) + +/* UMQ control ULB receiver control record header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t queue_id; + lbm_uint32_t ulb_src_id; + lbm_uint8_t msgid_regid[8]; + lbm_uint8_t msgid_stamp[8]; + lbm_uint32_t topic_tsp; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t num_ras; +} lbmc_cntl_umq_ulb_rcr_hdr_t; +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_ULB_SRC_ID OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, ulb_src_id) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_ULB_SRC_ID SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, ulb_src_id) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_MSGID_REGID OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, msgid_regid) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_MSGID_REGID SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, msgid_regid) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_MSGID_STAMP OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, msgid_stamp) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_MSGID_STAMP SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, msgid_stamp) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_TOPIC_TSP OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, topic_tsp) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_TOPIC_TSP SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, topic_tsp) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_NUM_RAS OFFSETOF(lbmc_cntl_umq_ulb_rcr_hdr_t, num_ras) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_NUM_RAS SIZEOF(lbmc_cntl_umq_ulb_rcr_hdr_t, num_ras) +#define L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T (gint) sizeof(lbmc_cntl_umq_ulb_rcr_hdr_t) + +/* LBMC control UMQ load factor header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t type; + lbm_uint16_t num_srcs; + lbm_uint16_t lf; +} lbmc_cntl_umq_lf_hdr_t; +#define O_LBMC_CNTL_UMQ_LF_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_lf_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_LF_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_lf_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_LF_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_lf_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_LF_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_lf_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_LF_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_lf_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_LF_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_lf_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_LF_HDR_T_TYPE OFFSETOF(lbmc_cntl_umq_lf_hdr_t, type) +#define L_LBMC_CNTL_UMQ_LF_HDR_T_TYPE SIZEOF(lbmc_cntl_umq_lf_hdr_t, type) +#define O_LBMC_CNTL_UMQ_LF_HDR_T_NUM_SRCS OFFSETOF(lbmc_cntl_umq_lf_hdr_t, num_srcs) +#define L_LBMC_CNTL_UMQ_LF_HDR_T_NUM_SRCS SIZEOF(lbmc_cntl_umq_lf_hdr_t, num_srcs) +#define O_LBMC_CNTL_UMQ_LF_HDR_T_LF OFFSETOF(lbmc_cntl_umq_lf_hdr_t, lf) +#define L_LBMC_CNTL_UMQ_LF_HDR_T_LF SIZEOF(lbmc_cntl_umq_lf_hdr_t, lf) +#define L_LBMC_CNTL_UMQ_LF_HDR_T (gint) sizeof(lbmc_cntl_umq_lf_hdr_t) + +/* LBMC control context information header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint8_t reserved; + lbm_uint8_t hop_count; + lbm_uint16_t port; + lbm_uint32_t addr; + lbm_uint32_t domain_id; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmc_cntl_ctxinfo_hdr_t; +#define O_LBMC_CNTL_CTXINFO_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, next_hdr) +#define L_LBMC_CNTL_CTXINFO_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ctxinfo_hdr_t, next_hdr) +#define O_LBMC_CNTL_CTXINFO_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, hdr_len) +#define L_LBMC_CNTL_CTXINFO_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ctxinfo_hdr_t, hdr_len) +#define O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, flags) +#define L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS SIZEOF(lbmc_cntl_ctxinfo_hdr_t, flags) +#define O_LBMC_CNTL_CTXINFO_HDR_T_RESERVED OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, reserved) +#define L_LBMC_CNTL_CTXINFO_HDR_T_RESERVED SIZEOF(lbmc_cntl_ctxinfo_hdr_t, reserved) +#define O_LBMC_CNTL_CTXINFO_HDR_T_HOP_COUNT OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, hop_count) +#define L_LBMC_CNTL_CTXINFO_HDR_T_HOP_COUNT SIZEOF(lbmc_cntl_ctxinfo_hdr_t, hop_count) +#define O_LBMC_CNTL_CTXINFO_HDR_T_PORT OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, port) +#define L_LBMC_CNTL_CTXINFO_HDR_T_PORT SIZEOF(lbmc_cntl_ctxinfo_hdr_t, port) +#define O_LBMC_CNTL_CTXINFO_HDR_T_ADDR OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, addr) +#define L_LBMC_CNTL_CTXINFO_HDR_T_ADDR SIZEOF(lbmc_cntl_ctxinfo_hdr_t, addr) +#define O_LBMC_CNTL_CTXINFO_HDR_T_DOMAIN_ID OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, domain_id) +#define L_LBMC_CNTL_CTXINFO_HDR_T_DOMAIN_ID SIZEOF(lbmc_cntl_ctxinfo_hdr_t, domain_id) +#define O_LBMC_CNTL_CTXINFO_HDR_T_CTXINST OFFSETOF(lbmc_cntl_ctxinfo_hdr_t, ctxinst) +#define L_LBMC_CNTL_CTXINFO_HDR_T_CTXINST SIZEOF(lbmc_cntl_ctxinfo_hdr_t, ctxinst) +#define L_LBMC_CNTL_CTXINFO_HDR_T (gint) sizeof(lbmc_cntl_ctxinfo_hdr_t) + +/* LBMC control UME proxy source election header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t source_ip; + lbm_uint32_t store_ip; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; + lbm_uint16_t source_port; + lbm_uint16_t store_port; + lbm_uint8_t source_ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; + lbm_uint8_t store_ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmc_cntl_ume_pser_hdr_t; +#define O_LBMC_CNTL_UME_PSER_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_pser_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_PSER_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_pser_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_PSER_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_pser_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_PSER_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_pser_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_PSER_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_pser_hdr_t, flags) +#define L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_pser_hdr_t, flags) +#define O_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_IP OFFSETOF(lbmc_cntl_ume_pser_hdr_t, source_ip) +#define L_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_IP SIZEOF(lbmc_cntl_ume_pser_hdr_t, source_ip) +#define O_LBMC_CNTL_UME_PSER_HDR_T_STORE_IP OFFSETOF(lbmc_cntl_ume_pser_hdr_t, store_ip) +#define L_LBMC_CNTL_UME_PSER_HDR_T_STORE_IP SIZEOF(lbmc_cntl_ume_pser_hdr_t, store_ip) +#define O_LBMC_CNTL_UME_PSER_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_ume_pser_hdr_t, transport_idx) +#define L_LBMC_CNTL_UME_PSER_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_ume_pser_hdr_t, transport_idx) +#define O_LBMC_CNTL_UME_PSER_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_ume_pser_hdr_t, topic_idx) +#define L_LBMC_CNTL_UME_PSER_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_ume_pser_hdr_t, topic_idx) +#define O_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_PORT OFFSETOF(lbmc_cntl_ume_pser_hdr_t, source_port) +#define L_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_PORT SIZEOF(lbmc_cntl_ume_pser_hdr_t, source_port) +#define O_LBMC_CNTL_UME_PSER_HDR_T_STORE_PORT OFFSETOF(lbmc_cntl_ume_pser_hdr_t, store_port) +#define L_LBMC_CNTL_UME_PSER_HDR_T_STORE_PORT SIZEOF(lbmc_cntl_ume_pser_hdr_t, store_port) +#define O_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_CTXINST OFFSETOF(lbmc_cntl_ume_pser_hdr_t, source_ctxinst) +#define L_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_CTXINST SIZEOF(lbmc_cntl_ume_pser_hdr_t, source_ctxinst) +#define O_LBMC_CNTL_UME_PSER_HDR_T_STORE_CTXINST OFFSETOF(lbmc_cntl_ume_pser_hdr_t, store_ctxinst) +#define L_LBMC_CNTL_UME_PSER_HDR_T_STORE_CTXINST SIZEOF(lbmc_cntl_ume_pser_hdr_t, store_ctxinst) +#define L_LBMC_CNTL_UME_PSER_HDR_T (gint) sizeof(lbmc_cntl_ume_pser_hdr_t) + +/* LBMC domain header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t domain; +} lbmc_domain_hdr_t; +#define O_LBMC_DOMAIN_HDR_T_NEXT_HDR OFFSETOF(lbmc_domain_hdr_t, next_hdr) +#define L_LBMC_DOMAIN_HDR_T_NEXT_HDR SIZEOF(lbmc_domain_hdr_t, next_hdr) +#define O_LBMC_DOMAIN_HDR_T_HDR_LEN OFFSETOF(lbmc_domain_hdr_t, hdr_len) +#define L_LBMC_DOMAIN_HDR_T_HDR_LEN SIZEOF(lbmc_domain_hdr_t, hdr_len) +#define O_LBMC_DOMAIN_HDR_T_FLAGS OFFSETOF(lbmc_domain_hdr_t, flags) +#define L_LBMC_DOMAIN_HDR_T_FLAGS SIZEOF(lbmc_domain_hdr_t, flags) +#define O_LBMC_DOMAIN_HDR_T_DOMAIN OFFSETOF(lbmc_domain_hdr_t, domain) +#define L_LBMC_DOMAIN_HDR_T_DOMAIN SIZEOF(lbmc_domain_hdr_t, domain) +#define L_LBMC_DOMAIN_HDR_T (gint) sizeof(lbmc_domain_hdr_t) + +/* LBMC control TNWG capabilities header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t capabilities1; + lbm_uint32_t capabilities2; + lbm_uint32_t capabilities3; + lbm_uint32_t capabilities4; +} lbmc_cntl_tnwg_capabilities_hdr_t; + +#define O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_tnwg_capabilities_hdr_t, next_hdr) +#define L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_tnwg_capabilities_hdr_t, next_hdr) +#define O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_tnwg_capabilities_hdr_t, hdr_len) +#define L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_tnwg_capabilities_hdr_t, hdr_len) +#define O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS OFFSETOF(lbmc_cntl_tnwg_capabilities_hdr_t, flags) +#define L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS SIZEOF(lbmc_cntl_tnwg_capabilities_hdr_t, flags) +#define O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1 OFFSETOF(lbmc_cntl_tnwg_capabilities_hdr_t, capabilities1) +#define L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1 SIZEOF(lbmc_cntl_tnwg_capabilities_hdr_t, capabilities1) +#define O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES2 OFFSETOF(lbmc_cntl_tnwg_capabilities_hdr_t, capabilities2) +#define L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES2 SIZEOF(lbmc_cntl_tnwg_capabilities_hdr_t, capabilities2) +#define O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3 OFFSETOF(lbmc_cntl_tnwg_capabilities_hdr_t, capabilities3) +#define L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3 SIZEOF(lbmc_cntl_tnwg_capabilities_hdr_t, capabilities3) +#define O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES4 OFFSETOF(lbmc_cntl_tnwg_capabilities_hdr_t, capabilities4) +#define L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES4 SIZEOF(lbmc_cntl_tnwg_capabilities_hdr_t, capabilities4) +#define L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T (gint) sizeof(lbmc_cntl_tnwg_capabilities_hdr_t) + +/* LBMC pattern index header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + char patidx[8]; +} lbmc_patidx_hdr_t; +#define O_LBMC_PATIDX_HDR_T_NEXT_HDR OFFSETOF(lbmc_patidx_hdr_t, next_hdr) +#define L_LBMC_PATIDX_HDR_T_NEXT_HDR SIZEOF(lbmc_patidx_hdr_t, next_hdr) +#define O_LBMC_PATIDX_HDR_T_HDR_LEN OFFSETOF(lbmc_patidx_hdr_t, hdr_len) +#define L_LBMC_PATIDX_HDR_T_HDR_LEN SIZEOF(lbmc_patidx_hdr_t, hdr_len) +#define O_LBMC_PATIDX_HDR_T_FLAGS OFFSETOF(lbmc_patidx_hdr_t, flags) +#define L_LBMC_PATIDX_HDR_T_FLAGS SIZEOF(lbmc_patidx_hdr_t, flags) +#define O_LBMC_PATIDX_HDR_T_PATIDX OFFSETOF(lbmc_patidx_hdr_t, patidx) +#define L_LBMC_PATIDX_HDR_T_PATIDX SIZEOF(lbmc_patidx_hdr_t, patidx) +#define L_LBMC_PATIDX_HDR_T (gint) sizeof(lbmc_patidx_hdr_t) + +/* LBMC control UME client lifetime header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t activity_tmo; + lbm_uint32_t lifetime; + lbm_uint32_t ttl; +} lbmc_cntl_ume_client_lifetime_hdr_t; +#define O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_client_lifetime_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_client_lifetime_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_client_lifetime_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_client_lifetime_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_client_lifetime_hdr_t, flags) +#define L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_client_lifetime_hdr_t, flags) +#define O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_ACTIVITY_TMO OFFSETOF(lbmc_cntl_ume_client_lifetime_hdr_t, activity_tmo) +#define L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_ACTIVITY_TMO SIZEOF(lbmc_cntl_ume_client_lifetime_hdr_t, activity_tmo) +#define O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_LIFETIME OFFSETOF(lbmc_cntl_ume_client_lifetime_hdr_t, lifetime) +#define L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_LIFETIME SIZEOF(lbmc_cntl_ume_client_lifetime_hdr_t, lifetime) +#define O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_TTL OFFSETOF(lbmc_cntl_ume_client_lifetime_hdr_t, ttl) +#define L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_TTL SIZEOF(lbmc_cntl_ume_client_lifetime_hdr_t, ttl) +#define L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T (gint) sizeof(lbmc_cntl_ume_client_lifetime_hdr_t) + +/* LBMC control UME session ID header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint8_t sid[8]; +} lbmc_cntl_ume_sid_hdr_t; +#define O_LBMC_CNTL_UME_SID_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_sid_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_SID_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_sid_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_SID_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_sid_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_SID_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_sid_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_SID_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_sid_hdr_t, flags) +#define L_LBMC_CNTL_UME_SID_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_sid_hdr_t, flags) +#define O_LBMC_CNTL_UME_SID_HDR_T_SID OFFSETOF(lbmc_cntl_ume_sid_hdr_t, sid) +#define L_LBMC_CNTL_UME_SID_HDR_T_SID SIZEOF(lbmc_cntl_ume_sid_hdr_t, sid) +#define L_LBMC_CNTL_UME_SID_HDR_T (gint) sizeof(lbmc_cntl_ume_sid_hdr_t) + +/* LBMC control UMQ index command header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t cmd_type; + lbm_uint32_t queue_id; + lbm_uint16_t cmd_id; + lbm_uint16_t inst_idx; + lbm_uint8_t regid[8]; +} lbmc_cntl_umq_idx_cmd_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_idx_cmd_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_idx_cmd_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_idx_cmd_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_idx_cmd_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_idx_cmd_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_idx_cmd_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_TYPE OFFSETOF(lbmc_cntl_umq_idx_cmd_hdr_t, cmd_type) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_TYPE SIZEOF(lbmc_cntl_umq_idx_cmd_hdr_t, cmd_type) +#define O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_idx_cmd_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_hdr_t, cmd_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_ID SIZEOF(lbmc_cntl_umq_idx_cmd_hdr_t, cmd_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_INST_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_hdr_t, inst_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_INST_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_hdr_t, inst_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_idx_cmd_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_REGID SIZEOF(lbmc_cntl_umq_idx_cmd_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_rcv_stop_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_rcv_stop_idx_assign_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_rcv_stop_idx_assign_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rcv_stop_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rcv_stop_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_rcv_stop_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_rcv_start_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_rcv_start_idx_assign_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_rcv_start_idx_assign_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rcv_start_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rcv_start_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_rcv_start_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint32_t flags; + lbm_uint8_t index_len; + lbm_uint8_t reserved[3]; +} lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX_LEN OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, index_len) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX_LEN SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, index_len) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED + L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_rcv_release_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_SRC_ID OFFSETOF(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t, src_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_SRC_ID SIZEOF(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t, src_id) +#define O_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_ulb_rcv_stop_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_SRC_ID OFFSETOF(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t, src_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_SRC_ID SIZEOF(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t, src_id) +#define O_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_ulb_rcv_start_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t src_id; + lbm_uint32_t assign_id; + lbm_uint32_t flags; + lbm_uint16_t appset_idx; + lbm_uint8_t index_len; + lbm_uint8_t reserved[1]; +} lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_SRC_ID OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, src_id) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_SRC_ID SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, src_id) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX_LEN OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, index_len) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX_LEN SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, index_len) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED + L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_ulb_idx_cmd_rcv_release_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint32_t flags; + lbm_uint8_t index_len; + lbm_uint8_t reserved[3]; +} lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, index_len) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, index_len) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED + L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED +#define L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_rcv_reserve_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t src_id; + lbm_uint32_t assign_id; + lbm_uint32_t flags; + lbm_uint16_t appset_idx; + lbm_uint8_t index_len; + lbm_uint8_t reserved[1]; +} lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_SRC_ID OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, src_id) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_SRC_ID SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, src_id) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, index_len) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, index_len) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED + L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED +#define L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_ulb_idx_cmd_rcv_reserve_idx_assign_hdr_t) + +/* LBMC control UMQ index command response header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t resp_type; + lbm_uint32_t queue_id; + lbm_uint16_t cmd_id; + lbm_uint16_t inst_idx; + lbm_uint8_t regid[8]; +} lbmc_cntl_umq_idx_cmd_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_RESP_TYPE OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, resp_type) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_RESP_TYPE SIZEOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, resp_type) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_CMD_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, cmd_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_CMD_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, cmd_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_INST_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, inst_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_INST_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, inst_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_REGID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_hdr_t) + +typedef struct +{ + lbm_uint16_t reserved; + lbm_uint16_t code; +} lbmc_cntl_umq_idx_cmd_resp_err_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_err_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_resp_err_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T_CODE OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_err_hdr_t, code) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T_CODE SIZEOF(lbmc_cntl_umq_idx_cmd_resp_err_hdr_t, code) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_err_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_idx_cmd_resp_rcv_stop_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_stop_idx_assign_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_stop_idx_assign_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_stop_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_stop_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_rcv_stop_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_rcv_start_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_rcv_release_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_SRC_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t, src_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_SRC_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t, src_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_stop_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_SRC_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t, src_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_SRC_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t, src_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_start_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t src_id; + lbm_uint32_t assign_id; + lbm_uint16_t appset_idx; + lbm_uint16_t reserved; +} lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_SRC_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t, src_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_SRC_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t, src_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_release_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint32_t flags; + lbm_uint16_t appset_idx; + lbm_uint8_t index_len; + lbm_uint8_t reserved[1]; +} lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, index_len) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, index_len) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED + L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_rcv_reserve_idx_assign_hdr_t) + +typedef struct +{ + lbm_uint32_t src_id; + lbm_uint32_t assign_id; + lbm_uint32_t flags; + lbm_uint16_t appset_idx; + lbm_uint8_t index_len; + lbm_uint8_t reserved[1]; +} lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t; +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_SRC_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, src_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_SRC_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, src_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, index_len) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, index_len) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED + L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED +#define L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T (gint) sizeof(lbmc_cntl_umq_idx_cmd_resp_ulb_rcv_reserve_idx_assign_hdr_t) + +/* LBMC originating domain header (same as lbmc_domain_hdr_t) */ +#define O_LBMC_ODOMAIN_HDR_T_NEXT_HDR OFFSETOF(lbmc_domain_hdr_t, next_hdr) +#define L_LBMC_ODOMAIN_HDR_T_NEXT_HDR SIZEOF(lbmc_domain_hdr_t, next_hdr) +#define O_LBMC_ODOMAIN_HDR_T_HDR_LEN OFFSETOF(lbmc_domain_hdr_t, hdr_len) +#define L_LBMC_ODOMAIN_HDR_T_HDR_LEN SIZEOF(lbmc_domain_hdr_t, hdr_len) +#define O_LBMC_ODOMAIN_HDR_T_FLAGS OFFSETOF(lbmc_domain_hdr_t, flags) +#define L_LBMC_ODOMAIN_HDR_T_FLAGS SIZEOF(lbmc_domain_hdr_t, flags) +#define O_LBMC_ODOMAIN_HDR_T_ODOMAIN OFFSETOF(lbmc_domain_hdr_t, domain) +#define L_LBMC_ODOMAIN_HDR_T_ODOMAIN SIZEOF(lbmc_domain_hdr_t, domain) +#define L_LBMC_ODOMAIN_HDR_T (gint) sizeof(lbmc_domain_hdr_t) + +/* LBMC stream header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t stream_id; + lbm_uint32_t sqn; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmc_stream_hdr_t; +#define O_LBMC_STREAM_HDR_T_NEXT_HDR OFFSETOF(lbmc_stream_hdr_t, next_hdr) +#define L_LBMC_STREAM_HDR_T_NEXT_HDR SIZEOF(lbmc_stream_hdr_t, next_hdr) +#define O_LBMC_STREAM_HDR_T_HDR_LEN OFFSETOF(lbmc_stream_hdr_t, hdr_len) +#define L_LBMC_STREAM_HDR_T_HDR_LEN SIZEOF(lbmc_stream_hdr_t, hdr_len) +#define O_LBMC_STREAM_HDR_T_FLAGS OFFSETOF(lbmc_stream_hdr_t, flags) +#define L_LBMC_STREAM_HDR_T_FLAGS SIZEOF(lbmc_stream_hdr_t, flags) +#define O_LBMC_STREAM_HDR_T_STREAM_ID OFFSETOF(lbmc_stream_hdr_t, stream_id) +#define L_LBMC_STREAM_HDR_T_STREAM_ID SIZEOF(lbmc_stream_hdr_t, stream_id) +#define O_LBMC_STREAM_HDR_T_SQN OFFSETOF(lbmc_stream_hdr_t, sqn) +#define L_LBMC_STREAM_HDR_T_SQN SIZEOF(lbmc_stream_hdr_t, sqn) +#define O_LBMC_STREAM_HDR_T_CTXINST OFFSETOF(lbmc_stream_hdr_t, ctxinst) +#define L_LBMC_STREAM_HDR_T_CTXINST SIZEOF(lbmc_stream_hdr_t, ctxinst) +#define L_LBMC_STREAM_HDR_T (gint) sizeof(lbmc_stream_hdr_t) + +/* LBMC control topic multi-domain interest header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint16_t domain_count; + lbm_uint16_t res1; +} lbmc_cntl_topic_md_interest_hdr_t; +#define O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_topic_md_interest_hdr_t, next_hdr) +#define L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_topic_md_interest_hdr_t, next_hdr) +#define O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_topic_md_interest_hdr_t, hdr_len) +#define L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_topic_md_interest_hdr_t, hdr_len) +#define O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS OFFSETOF(lbmc_cntl_topic_md_interest_hdr_t, flags) +#define L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS SIZEOF(lbmc_cntl_topic_md_interest_hdr_t, flags) +#define O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_DOMAIN_COUNT OFFSETOF(lbmc_cntl_topic_md_interest_hdr_t, domain_count) +#define L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_DOMAIN_COUNT SIZEOF(lbmc_cntl_topic_md_interest_hdr_t, domain_count) +#define O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_RES1 OFFSETOF(lbmc_cntl_topic_md_interest_hdr_t, res1) +#define L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_RES1 SIZEOF(lbmc_cntl_topic_md_interest_hdr_t, res1) +#define L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T (gint) sizeof(lbmc_cntl_topic_md_interest_hdr_t) + +/* LBMC control pattern multi-domain interest header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t type; + lbm_uint16_t domain_count; + lbm_uint16_t res1; + lbm_uint8_t index[8]; +} lbmc_cntl_pattern_md_interest_hdr_t; +#define O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_pattern_md_interest_hdr_t, next_hdr) +#define L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_pattern_md_interest_hdr_t, next_hdr) +#define O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_pattern_md_interest_hdr_t, hdr_len) +#define L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_pattern_md_interest_hdr_t, hdr_len) +#define O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS OFFSETOF(lbmc_cntl_pattern_md_interest_hdr_t, flags) +#define L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS SIZEOF(lbmc_cntl_pattern_md_interest_hdr_t, flags) +#define O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_TYPE OFFSETOF(lbmc_cntl_pattern_md_interest_hdr_t, type) +#define L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_TYPE SIZEOF(lbmc_cntl_pattern_md_interest_hdr_t, type) +#define O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_DOMAIN_COUNT OFFSETOF(lbmc_cntl_pattern_md_interest_hdr_t, domain_count) +#define L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_DOMAIN_COUNT SIZEOF(lbmc_cntl_pattern_md_interest_hdr_t, domain_count) +#define O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_RES1 OFFSETOF(lbmc_cntl_pattern_md_interest_hdr_t, res1) +#define L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_RES1 SIZEOF(lbmc_cntl_pattern_md_interest_hdr_t, res1) +#define O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_INDEX OFFSETOF(lbmc_cntl_pattern_md_interest_hdr_t, index) +#define L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_INDEX SIZEOF(lbmc_cntl_pattern_md_interest_hdr_t, index) +#define L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T (gint) sizeof(lbmc_cntl_pattern_md_interest_hdr_t) + +/* LBMC control TNWG keepalive header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t index; + lbm_uint8_t ts_seconds[8]; + lbm_uint32_t ts_microseconds; + lbm_uint32_t reserved_1; + lbm_uint8_t reserved_2[8]; + lbm_uint8_t reserved_3[8]; + lbm_uint8_t reserved_4[8]; + lbm_uint8_t reserved_5[8]; + lbm_uint8_t reserved_6[8]; +} lbmc_cntl_tnwg_ka_hdr_t; +#define O_LBMC_CNTL_TNWG_KA_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, next_hdr) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, next_hdr) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, hdr_len) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, hdr_len) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, flags) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, flags) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_INDEX OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, index) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_INDEX SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, index) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_TS_SECONDS OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, ts_seconds) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_TS_SECONDS SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, ts_seconds) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_TS_MICROSECONDS OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, ts_microseconds) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_TS_MICROSECONDS SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, ts_microseconds) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_1 OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_1) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_1 SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_1) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_2 OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_2) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_2 SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_2) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_3 OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_3) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_3 SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_3) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_4 OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_4) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_4 SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_4) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_5 OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_5) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_5 SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_5) +#define O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_6 OFFSETOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_6) +#define L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_6 SIZEOF(lbmc_cntl_tnwg_ka_hdr_t, reserved_6) +#define L_LBMC_CNTL_TNWG_KA_HDR_T (gint) sizeof(lbmc_cntl_tnwg_ka_hdr_t) + +/* LBMC control UME receiver keepalive header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t rcv_regid; + lbm_uint64_t session_id; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmc_cntl_ume_receiver_keepalive_hdr_t; +#define O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, flags) +#define L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, flags) +#define O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_RCV_REGID OFFSETOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, rcv_regid) +#define L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_RCV_REGID SIZEOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, rcv_regid) +#define O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_SESSION_ID OFFSETOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, session_id) +#define L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_SESSION_ID SIZEOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, session_id) +#define O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_CTXINST OFFSETOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, ctxinst) +#define L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_CTXINST SIZEOF(lbmc_cntl_ume_receiver_keepalive_hdr_t, ctxinst) +#define L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T (gint) sizeof(lbmc_cntl_ume_receiver_keepalive_hdr_t) + +/* LBMC control UMQ command header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t cmd_type; + lbm_uint32_t queue_id; + lbm_uint16_t cmd_id; + lbm_uint16_t inst_idx; + lbm_uint8_t regid[8]; +} lbmc_cntl_umq_cmd_hdr_t; +#define O_LBMC_CNTL_UMQ_CMD_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_cmd_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_cmd_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_CMD_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_cmd_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_cmd_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_CMD_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_cmd_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_cmd_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_TYPE OFFSETOF(lbmc_cntl_umq_cmd_hdr_t, cmd_type) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_TYPE SIZEOF(lbmc_cntl_umq_cmd_hdr_t, cmd_type) +#define O_LBMC_CNTL_UMQ_CMD_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_cmd_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_cmd_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_ID OFFSETOF(lbmc_cntl_umq_cmd_hdr_t, cmd_id) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_ID SIZEOF(lbmc_cntl_umq_cmd_hdr_t, cmd_id) +#define O_LBMC_CNTL_UMQ_CMD_HDR_T_INST_IDX OFFSETOF(lbmc_cntl_umq_cmd_hdr_t, inst_idx) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T_INST_IDX SIZEOF(lbmc_cntl_umq_cmd_hdr_t, inst_idx) +#define O_LBMC_CNTL_UMQ_CMD_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_cmd_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T_REGID SIZEOF(lbmc_cntl_umq_cmd_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_CMD_HDR_T (gint) sizeof(lbmc_cntl_umq_cmd_hdr_t) + +typedef struct +{ + lbm_uint8_t serial_num[8]; +} lbmc_cntl_umq_ctx_queue_topic_list_hdr_t; +#define O_LBMC_CNTL_UMQ_CTX_QUEUE_TOPIC_LIST_HDR_T_SERIAL_NUM OFFSETOF(lbmc_cntl_umq_ctx_queue_topic_list_hdr_t, serial_num) +#define L_LBMC_CNTL_UMQ_CTX_QUEUE_TOPIC_LIST_HDR_T_SERIAL_NUM SIZEOF(lbmc_cntl_umq_ctx_queue_topic_list_hdr_t, serial_num) +#define L_LBMC_CNTL_UMQ_CTX_QUEUE_TOPIC_LIST_HDR_T (gint) sizeof(lbmc_cntl_umq_ctx_queue_topic_list_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; + lbm_uint16_t info_only; + lbm_uint8_t num_msgids; + lbm_uint8_t flags; +} lbmc_cntl_umq_rcv_msg_retrieve_hdr_t; +#define O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, assign_id) +#define O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_INFO_ONLY OFFSETOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, info_only) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_INFO_ONLY SIZEOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, info_only) +#define O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGIDS OFFSETOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, num_msgids) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGIDS SIZEOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, num_msgids) +#define O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T (gint) sizeof(lbmc_cntl_umq_rcv_msg_retrieve_hdr_t) + +typedef struct +{ + lbm_uint8_t regid[8]; + lbm_uint8_t stamp[8]; +} lbmc_cntl_umq_rcv_msg_retrieve_entry_hdr_t; +#define O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_rcv_msg_retrieve_entry_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T_REGID SIZEOF(lbmc_cntl_umq_rcv_msg_retrieve_entry_hdr_t, regid) +#define O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STAMP OFFSETOF(lbmc_cntl_umq_rcv_msg_retrieve_entry_hdr_t, stamp) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STAMP SIZEOF(lbmc_cntl_umq_rcv_msg_retrieve_entry_hdr_t, stamp) +#define L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T (gint) sizeof(lbmc_cntl_umq_rcv_msg_retrieve_entry_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_rcv_msg_list_hdr_t; +#define O_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_rcv_msg_list_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_rcv_msg_list_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_rcv_msg_list_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_rcv_msg_list_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T (gint) sizeof(lbmc_cntl_umq_rcv_msg_list_hdr_t) + +/* LBMC control UMQ command response header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t resp_type; + lbm_uint32_t queue_id; + lbm_uint16_t cmd_id; + lbm_uint16_t inst_idx; + lbm_uint8_t regid[8]; +} lbmc_cntl_umq_cmd_resp_hdr_t; +#define O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_cmd_resp_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_cmd_resp_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_cmd_resp_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_cmd_resp_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_cmd_resp_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_cmd_resp_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_RESP_TYPE OFFSETOF(lbmc_cntl_umq_cmd_resp_hdr_t, resp_type) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_RESP_TYPE SIZEOF(lbmc_cntl_umq_cmd_resp_hdr_t, resp_type) +#define O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_QUEUE_ID OFFSETOF(lbmc_cntl_umq_cmd_resp_hdr_t, queue_id) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_QUEUE_ID SIZEOF(lbmc_cntl_umq_cmd_resp_hdr_t, queue_id) +#define O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_CMD_ID OFFSETOF(lbmc_cntl_umq_cmd_resp_hdr_t, cmd_id) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_CMD_ID SIZEOF(lbmc_cntl_umq_cmd_resp_hdr_t, cmd_id) +#define O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_INST_IDX OFFSETOF(lbmc_cntl_umq_cmd_resp_hdr_t, inst_idx) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_INST_IDX SIZEOF(lbmc_cntl_umq_cmd_resp_hdr_t, inst_idx) +#define O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_REGID OFFSETOF(lbmc_cntl_umq_cmd_resp_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_REGID SIZEOF(lbmc_cntl_umq_cmd_resp_hdr_t, regid) +#define L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T (gint) sizeof(lbmc_cntl_umq_cmd_resp_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t; +#define O_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T (gint) sizeof(lbmc_cntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t) + +typedef struct +{ + lbm_uint8_t num_msgs; + lbm_uint8_t flags; + lbm_uint16_t reserved; +} lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t; +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGS OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, num_msgs) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGS SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, num_msgs) +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_FLAGS OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, flags) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_FLAGS SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, flags) +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_RESERVED OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, reserved) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_RESERVED SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t, reserved) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T (gint) sizeof(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_hdr_t) + +typedef struct +{ + lbm_uint8_t regid[8]; + lbm_uint8_t stamp[8]; + lbm_uint32_t assign_id; + lbm_uint16_t num_ras; + lbm_uint8_t status; + lbm_uint8_t reserved; +} lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t; +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_REGID OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, regid) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_REGID SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, regid) +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STAMP OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, stamp) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STAMP SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, stamp) +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_ASSIGN_ID OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, assign_id) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_ASSIGN_ID SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, assign_id) +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_NUM_RAS OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, num_ras) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_NUM_RAS SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, num_ras) +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STATUS OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, status) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STATUS SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, status) +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_RESERVED OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, reserved) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_RESERVED SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t, reserved) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T (gint) sizeof(lbmc_xcntl_umq_cmd_resp_rcv_msg_retrieve_entry_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint32_t assign_id; +} lbmc_cntl_umq_cmd_resp_rcv_msg_list_hdr_t; +#define O_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_cmd_resp_rcv_msg_list_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_cmd_resp_rcv_msg_list_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_ASSIGN_ID OFFSETOF(lbmc_cntl_umq_cmd_resp_rcv_msg_list_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_ASSIGN_ID SIZEOF(lbmc_cntl_umq_cmd_resp_rcv_msg_list_hdr_t, assign_id) +#define L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T (gint) sizeof(lbmc_cntl_umq_cmd_resp_rcv_msg_list_hdr_t) + +typedef struct +{ + lbm_uint8_t num_msgs[8]; +} lbmc_xcntl_umq_cmd_resp_rcv_msg_list_hdr_t; +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_NUM_MSGS OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_list_hdr_t, num_msgs) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_NUM_MSGS SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_list_hdr_t, num_msgs) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T (gint) sizeof(lbmc_xcntl_umq_cmd_resp_rcv_msg_list_hdr_t) + +typedef struct +{ + lbm_uint8_t regid[8]; + lbm_uint8_t stamp[8]; +} lbmc_xcntl_umq_cmd_resp_rcv_msg_list_msg_entry_hdr_t; +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T_REGID OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_list_msg_entry_hdr_t, regid) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T_REGID SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_list_msg_entry_hdr_t, regid) +#define O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T_STAMP OFFSETOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_list_msg_entry_hdr_t, stamp) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T_STAMP SIZEOF(lbmc_xcntl_umq_cmd_resp_rcv_msg_list_msg_entry_hdr_t, stamp) +#define L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T (gint) sizeof(lbmc_xcntl_umq_cmd_resp_rcv_msg_list_msg_entry_hdr_t) + +typedef struct +{ + lbm_uint32_t num_topics; +} lbmc_cntl_umq_cmd_resp_ctx_topic_list_hdr_t; +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_HDR_T_NUM_TOPICS OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_hdr_t, num_topics) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_HDR_T_NUM_TOPICS SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_hdr_t, num_topics) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_HDR_T (gint) sizeof(lbmc_cntl_umq_cmd_resp_ctx_topic_list_hdr_t) + +typedef struct +{ + lbm_uint16_t num_receiver_type_ids; + lbm_uint16_t appset_idx; + lbm_uint8_t appset_name_len; + lbm_uint8_t reserved[3]; +} lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t; +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_NUM_RECEIVER_TYPE_IDS OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t, num_receiver_type_ids) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_NUM_RECEIVER_TYPE_IDS SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t, num_receiver_type_ids) +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_IDX OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t, appset_idx) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_IDX SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t, appset_idx) +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_NAME_LEN OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t, appset_name_len) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_NAME_LEN SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t, appset_name_len) +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T (gint) sizeof(lbmc_cntl_umq_cmd_resp_ctx_topic_list_appset_entry_hdr_t) + +typedef struct +{ + lbm_uint32_t rcr_idx; + lbm_uint16_t num_appsets; + lbm_uint8_t topic_len; + lbm_uint8_t reserved; +} lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t; +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_RCR_IDX OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t, rcr_idx) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_RCR_IDX SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t, rcr_idx) +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_NUM_APPSETS OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t, num_appsets) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_NUM_APPSETS SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t, num_appsets) +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_TOPIC_LEN OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t, topic_len) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_TOPIC_LEN SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t, topic_len) +#define O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T (gint) sizeof(lbmc_cntl_umq_cmd_resp_ctx_topic_list_topic_entry_hdr_t) + +typedef struct +{ + lbm_uint16_t reserved; + lbm_uint16_t code; +} lbmc_cntl_umq_cmd_resp_err_hdr_t; +#define O_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T_RESERVED OFFSETOF(lbmc_cntl_umq_cmd_resp_err_hdr_t, reserved) +#define L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T_RESERVED SIZEOF(lbmc_cntl_umq_cmd_resp_err_hdr_t, reserved) +#define O_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T_CODE OFFSETOF(lbmc_cntl_umq_cmd_resp_err_hdr_t, code) +#define L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T_CODE SIZEOF(lbmc_cntl_umq_cmd_resp_err_hdr_t, code) +#define L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T (gint) sizeof(lbmc_cntl_umq_cmd_resp_err_hdr_t) + +/* LBMC control source registration information request header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; +} lbmc_cntl_sri_req_hdr_t; +#define O_LBMC_CNTL_SRI_REQ_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_sri_req_hdr_t, next_hdr) +#define L_LBMC_CNTL_SRI_REQ_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_sri_req_hdr_t, next_hdr) +#define O_LBMC_CNTL_SRI_REQ_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_sri_req_hdr_t, hdr_len) +#define L_LBMC_CNTL_SRI_REQ_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_sri_req_hdr_t, hdr_len) +#define O_LBMC_CNTL_SRI_REQ_HDR_T_FLAGS OFFSETOF(lbmc_cntl_sri_req_hdr_t, flags) +#define L_LBMC_CNTL_SRI_REQ_HDR_T_FLAGS SIZEOF(lbmc_cntl_sri_req_hdr_t, flags) +#define O_LBMC_CNTL_SRI_REQ_HDR_T_TRANSPORT_IDX OFFSETOF(lbmc_cntl_sri_req_hdr_t, transport_idx) +#define L_LBMC_CNTL_SRI_REQ_HDR_T_TRANSPORT_IDX SIZEOF(lbmc_cntl_sri_req_hdr_t, transport_idx) +#define O_LBMC_CNTL_SRI_REQ_HDR_T_TOPIC_IDX OFFSETOF(lbmc_cntl_sri_req_hdr_t, topic_idx) +#define L_LBMC_CNTL_SRI_REQ_HDR_T_TOPIC_IDX SIZEOF(lbmc_cntl_sri_req_hdr_t, topic_idx) +#define L_LBMC_CNTL_SRI_REQ_HDR_T (gint) sizeof(lbmc_cntl_sri_req_hdr_t) + +/* LBMC control UME store domain header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t domain; +} lbmc_cntl_ume_store_domain_hdr_t; +#define O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_store_domain_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_store_domain_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_store_domain_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_store_domain_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_store_domain_hdr_t, flags) +#define L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_store_domain_hdr_t, flags) +#define O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_DOMAIN OFFSETOF(lbmc_cntl_ume_store_domain_hdr_t, domain) +#define L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_DOMAIN SIZEOF(lbmc_cntl_ume_store_domain_hdr_t, domain) +#define L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T (gint) sizeof(lbmc_cntl_ume_store_domain_hdr_t) + +/* LBMC control source registration information header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t version; + lbm_uint32_t low_sqn; + lbm_uint32_t high_sqn; +} lbmc_cntl_sri_hdr_t; +#define O_LBMC_CNTL_SRI_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_sri_hdr_t, next_hdr) +#define L_LBMC_CNTL_SRI_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_sri_hdr_t, next_hdr) +#define O_LBMC_CNTL_SRI_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_sri_hdr_t, hdr_len) +#define L_LBMC_CNTL_SRI_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_sri_hdr_t, hdr_len) +#define O_LBMC_CNTL_SRI_HDR_T_FLAGS OFFSETOF(lbmc_cntl_sri_hdr_t, flags) +#define L_LBMC_CNTL_SRI_HDR_T_FLAGS SIZEOF(lbmc_cntl_sri_hdr_t, flags) +#define O_LBMC_CNTL_SRI_HDR_T_VERSION OFFSETOF(lbmc_cntl_sri_hdr_t, version) +#define L_LBMC_CNTL_SRI_HDR_T_VERSION SIZEOF(lbmc_cntl_sri_hdr_t, version) +#define O_LBMC_CNTL_SRI_HDR_T_LOW_SQN OFFSETOF(lbmc_cntl_sri_hdr_t, low_sqn) +#define L_LBMC_CNTL_SRI_HDR_T_LOW_SQN SIZEOF(lbmc_cntl_sri_hdr_t, low_sqn) +#define O_LBMC_CNTL_SRI_HDR_T_HIGH_SQN OFFSETOF(lbmc_cntl_sri_hdr_t, high_sqn) +#define L_LBMC_CNTL_SRI_HDR_T_HIGH_SQN SIZEOF(lbmc_cntl_sri_hdr_t, high_sqn) +#define L_LBMC_CNTL_SRI_HDR_T (gint) sizeof(lbmc_cntl_sri_hdr_t) + +/* LBMC control route information header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t gateway_version; + lbm_uint32_t configuration_signature; + lbm_uint8_t node_id[8]; + lbm_uint32_t topology; + lbm_uint16_t vers; + lbm_uint16_t sqn; + lbm_uint8_t ttl; + lbm_uint8_t reserved1; + lbm_uint16_t reserved2; +} lbmc_cntl_route_info_hdr_t; +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_route_info_hdr_t, next_hdr) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_route_info_hdr_t, next_hdr) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_route_info_hdr_t, hdr_len) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_route_info_hdr_t, hdr_len) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_FLAGS OFFSETOF(lbmc_cntl_route_info_hdr_t, flags) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_FLAGS SIZEOF(lbmc_cntl_route_info_hdr_t, flags) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_GATEWAY_VERSION OFFSETOF(lbmc_cntl_route_info_hdr_t, gateway_version) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_GATEWAY_VERSION SIZEOF(lbmc_cntl_route_info_hdr_t, gateway_version) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_CONFIGURATION_SIGNATURE OFFSETOF(lbmc_cntl_route_info_hdr_t, configuration_signature) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_CONFIGURATION_SIGNATURE SIZEOF(lbmc_cntl_route_info_hdr_t, configuration_signature) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_NODE_ID OFFSETOF(lbmc_cntl_route_info_hdr_t, node_id) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_NODE_ID SIZEOF(lbmc_cntl_route_info_hdr_t, node_id) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_TOPOLOGY OFFSETOF(lbmc_cntl_route_info_hdr_t, topology) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_TOPOLOGY SIZEOF(lbmc_cntl_route_info_hdr_t, topology) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_VERS OFFSETOF(lbmc_cntl_route_info_hdr_t, vers) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_VERS SIZEOF(lbmc_cntl_route_info_hdr_t, vers) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_SQN OFFSETOF(lbmc_cntl_route_info_hdr_t, sqn) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_SQN SIZEOF(lbmc_cntl_route_info_hdr_t, sqn) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_TTL OFFSETOF(lbmc_cntl_route_info_hdr_t, ttl) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_TTL SIZEOF(lbmc_cntl_route_info_hdr_t, ttl) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_RESERVED1 OFFSETOF(lbmc_cntl_route_info_hdr_t, reserved1) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_RESERVED1 SIZEOF(lbmc_cntl_route_info_hdr_t, reserved1) +#define O_LBMC_CNTL_ROUTE_INFO_HDR_T_RESERVED2 OFFSETOF(lbmc_cntl_route_info_hdr_t, reserved2) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T_RESERVED2 SIZEOF(lbmc_cntl_route_info_hdr_t, reserved2) +#define L_LBMC_CNTL_ROUTE_INFO_HDR_T (gint) sizeof(lbmc_cntl_route_info_hdr_t) + +/* LBMC control route information neighbor header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint8_t node_id[8]; + lbm_uint32_t ingress_cost; + lbm_uint32_t egress_cost; +} lbmc_cntl_route_info_neighbor_hdr_t; +#define O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_route_info_neighbor_hdr_t, next_hdr) +#define L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_route_info_neighbor_hdr_t, next_hdr) +#define O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_route_info_neighbor_hdr_t, hdr_len) +#define L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_route_info_neighbor_hdr_t, hdr_len) +#define O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_FLAGS OFFSETOF(lbmc_cntl_route_info_neighbor_hdr_t, flags) +#define L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_FLAGS SIZEOF(lbmc_cntl_route_info_neighbor_hdr_t, flags) +#define O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_NODE_ID OFFSETOF(lbmc_cntl_route_info_neighbor_hdr_t, node_id) +#define L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_NODE_ID SIZEOF(lbmc_cntl_route_info_neighbor_hdr_t, node_id) +#define O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_INGRESS_COST OFFSETOF(lbmc_cntl_route_info_neighbor_hdr_t, ingress_cost) +#define L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_INGRESS_COST SIZEOF(lbmc_cntl_route_info_neighbor_hdr_t, ingress_cost) +#define O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_EGRESS_COST OFFSETOF(lbmc_cntl_route_info_neighbor_hdr_t, egress_cost) +#define L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_EGRESS_COST SIZEOF(lbmc_cntl_route_info_neighbor_hdr_t, egress_cost) +#define L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T (gint) sizeof(lbmc_cntl_route_info_neighbor_hdr_t) + +/* LBMC control gateway name header. */ +#define O_LBMC_CNTL_GATEWAY_NAME_HDR_T_NEXT_HDR OFFSETOF(lbmc_basic_hdr_t, next_hdr) +#define L_LBMC_CNTL_GATEWAY_NAME_HDR_T_NEXT_HDR SIZEOF(lbmc_basic_hdr_t, next_hdr) +#define O_LBMC_CNTL_GATEWAY_NAME_HDR_T_HDR_LEN OFFSETOF(lbmc_basic_hdr_t, hdr_len) +#define L_LBMC_CNTL_GATEWAY_NAME_HDR_T_HDR_LEN SIZEOF(lbmc_basic_hdr_t, hdr_len) +#define O_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS OFFSETOF(lbmc_basic_hdr_t, res) +#define L_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS SIZEOF(lbmc_basic_hdr_t, res) +#define O_LBMC_CNTL_GATEWAY_NAME_HDR_T_NAME (OFFSETOF(lbmc_basic_hdr_t, res) + SIZEOF(lbmc_basic_hdr_t, res)) + +/* LBMC control generic authentication header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t opid; +} lbmc_cntl_auth_generic_hdr_t; +#define O_LBMC_CNTL_AUTH_GENERIC_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_auth_generic_hdr_t, next_hdr) +#define L_LBMC_CNTL_AUTH_GENERIC_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_auth_generic_hdr_t, next_hdr) +#define O_LBMC_CNTL_AUTH_GENERIC_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_auth_generic_hdr_t, hdr_len) +#define L_LBMC_CNTL_AUTH_GENERIC_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_auth_generic_hdr_t, hdr_len) +#define O_LBMC_CNTL_AUTH_GENERIC_HDR_T_FLAGS OFFSETOF(lbmc_cntl_auth_generic_hdr_t, flags) +#define L_LBMC_CNTL_AUTH_GENERIC_HDR_T_FLAGS SIZEOF(lbmc_cntl_auth_generic_hdr_t, flags) +#define O_LBMC_CNTL_AUTH_GENERIC_HDR_T_OPID OFFSETOF(lbmc_cntl_auth_generic_hdr_t, opid) +#define L_LBMC_CNTL_AUTH_GENERIC_HDR_T_OPID SIZEOF(lbmc_cntl_auth_generic_hdr_t, opid) +#define L_LBMC_CNTL_AUTH_GENERIC_HDR_T (gint) sizeof(lbmc_cntl_auth_generic_hdr_t) + +/* LBMC control authentication request header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t opid; + lbm_uint8_t user_len; +} lbmc_cntl_auth_request_hdr_t; +#define O_LBMC_CNTL_AUTH_REQUEST_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_auth_request_hdr_t, next_hdr) +#define L_LBMC_CNTL_AUTH_REQUEST_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_auth_request_hdr_t, next_hdr) +#define O_LBMC_CNTL_AUTH_REQUEST_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_auth_request_hdr_t, hdr_len) +#define L_LBMC_CNTL_AUTH_REQUEST_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_auth_request_hdr_t, hdr_len) +#define O_LBMC_CNTL_AUTH_REQUEST_HDR_T_FLAGS OFFSETOF(lbmc_cntl_auth_request_hdr_t, flags) +#define L_LBMC_CNTL_AUTH_REQUEST_HDR_T_FLAGS SIZEOF(lbmc_cntl_auth_request_hdr_t, flags) +#define O_LBMC_CNTL_AUTH_REQUEST_HDR_T_OPID OFFSETOF(lbmc_cntl_auth_request_hdr_t, opid) +#define L_LBMC_CNTL_AUTH_REQUEST_HDR_T_OPID SIZEOF(lbmc_cntl_auth_request_hdr_t, opid) +#define O_LBMC_CNTL_AUTH_REQUEST_HDR_T_USER_LEN OFFSETOF(lbmc_cntl_auth_request_hdr_t, user_len) +#define L_LBMC_CNTL_AUTH_REQUEST_HDR_T_USER_LEN SIZEOF(lbmc_cntl_auth_request_hdr_t, user_len) +#define L_LBMC_CNTL_AUTH_REQUEST_HDR_T (gint) sizeof(lbmc_cntl_auth_request_hdr_t) + +/* LBMC control authentication challenge header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t opid; + lbm_uint8_t mod_len; + lbm_uint8_t gen_len; + lbm_uint8_t salt_len; + lbm_uint8_t pubkey_len; +} lbmc_cntl_auth_challenge_hdr_t; +#define O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_auth_challenge_hdr_t, next_hdr) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_auth_challenge_hdr_t, next_hdr) +#define O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_auth_challenge_hdr_t, hdr_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_auth_challenge_hdr_t, hdr_len) +#define O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_FLAGS OFFSETOF(lbmc_cntl_auth_challenge_hdr_t, flags) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_FLAGS SIZEOF(lbmc_cntl_auth_challenge_hdr_t, flags) +#define O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_OPID OFFSETOF(lbmc_cntl_auth_challenge_hdr_t, opid) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_OPID SIZEOF(lbmc_cntl_auth_challenge_hdr_t, opid) +#define O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_MOD_LEN OFFSETOF(lbmc_cntl_auth_challenge_hdr_t, mod_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_MOD_LEN SIZEOF(lbmc_cntl_auth_challenge_hdr_t, mod_len) +#define O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_GEN_LEN OFFSETOF(lbmc_cntl_auth_challenge_hdr_t, gen_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_GEN_LEN SIZEOF(lbmc_cntl_auth_challenge_hdr_t, gen_len) +#define O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_SALT_LEN OFFSETOF(lbmc_cntl_auth_challenge_hdr_t, salt_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_SALT_LEN SIZEOF(lbmc_cntl_auth_challenge_hdr_t, salt_len) +#define O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_PUBKEY_LEN OFFSETOF(lbmc_cntl_auth_challenge_hdr_t, pubkey_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_PUBKEY_LEN SIZEOF(lbmc_cntl_auth_challenge_hdr_t, pubkey_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T (gint) sizeof(lbmc_cntl_auth_challenge_hdr_t) + +/* LBMC control authentication challenge response header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t opid; + lbm_uint8_t pubkey_len; + lbm_uint8_t evidence_len; +} lbmc_cntl_auth_challenge_rsp_hdr_t; +#define O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_auth_challenge_rsp_hdr_t, next_hdr) +#define L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_auth_challenge_rsp_hdr_t, next_hdr) +#define O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_auth_challenge_rsp_hdr_t, hdr_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_auth_challenge_rsp_hdr_t, hdr_len) +#define O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_FLAGS OFFSETOF(lbmc_cntl_auth_challenge_rsp_hdr_t, flags) +#define L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_FLAGS SIZEOF(lbmc_cntl_auth_challenge_rsp_hdr_t, flags) +#define O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_OPID OFFSETOF(lbmc_cntl_auth_challenge_rsp_hdr_t, opid) +#define L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_OPID SIZEOF(lbmc_cntl_auth_challenge_rsp_hdr_t, opid) +#define O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_PUBKEY_LEN OFFSETOF(lbmc_cntl_auth_challenge_rsp_hdr_t, pubkey_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_PUBKEY_LEN SIZEOF(lbmc_cntl_auth_challenge_rsp_hdr_t, pubkey_len) +#define O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_EVIDENCE_LEN OFFSETOF(lbmc_cntl_auth_challenge_rsp_hdr_t, evidence_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_EVIDENCE_LEN SIZEOF(lbmc_cntl_auth_challenge_rsp_hdr_t, evidence_len) +#define L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T (gint) sizeof(lbmc_cntl_auth_challenge_rsp_hdr_t) + +/* LBMC control authentication result header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t opid; + lbm_uint8_t result; +} lbmc_cntl_auth_result_hdr_t; +#define O_LBMC_CNTL_AUTH_RESULT_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_auth_result_hdr_t, next_hdr) +#define L_LBMC_CNTL_AUTH_RESULT_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_auth_result_hdr_t, next_hdr) +#define O_LBMC_CNTL_AUTH_RESULT_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_auth_result_hdr_t, hdr_len) +#define L_LBMC_CNTL_AUTH_RESULT_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_auth_result_hdr_t, hdr_len) +#define O_LBMC_CNTL_AUTH_RESULT_HDR_T_FLAGS OFFSETOF(lbmc_cntl_auth_result_hdr_t, flags) +#define L_LBMC_CNTL_AUTH_RESULT_HDR_T_FLAGS SIZEOF(lbmc_cntl_auth_result_hdr_t, flags) +#define O_LBMC_CNTL_AUTH_RESULT_HDR_T_OPID OFFSETOF(lbmc_cntl_auth_result_hdr_t, opid) +#define L_LBMC_CNTL_AUTH_RESULT_HDR_T_OPID SIZEOF(lbmc_cntl_auth_result_hdr_t, opid) +#define O_LBMC_CNTL_AUTH_RESULT_HDR_T_RESULT OFFSETOF(lbmc_cntl_auth_result_hdr_t, result) +#define L_LBMC_CNTL_AUTH_RESULT_HDR_T_RESULT SIZEOF(lbmc_cntl_auth_result_hdr_t, result) +#define L_LBMC_CNTL_AUTH_RESULT_HDR_T (gint) sizeof(lbmc_cntl_auth_result_hdr_t) + +/* LBMC control HMAC header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t padding; + lbm_uint8_t data[LBM_HMAC_BLOCK_SZ]; +} lbmc_cntl_hmac_hdr_t; +#define O_LBMC_CNTL_HMAC_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_hmac_hdr_t, next_hdr) +#define L_LBMC_CNTL_HMAC_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_hmac_hdr_t, next_hdr) +#define O_LBMC_CNTL_HMAC_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_hmac_hdr_t, hdr_len) +#define L_LBMC_CNTL_HMAC_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_hmac_hdr_t, hdr_len) +#define O_LBMC_CNTL_HMAC_HDR_T_FLAGS OFFSETOF(lbmc_cntl_hmac_hdr_t, flags) +#define L_LBMC_CNTL_HMAC_HDR_T_FLAGS SIZEOF(lbmc_cntl_hmac_hdr_t, flags) +#define O_LBMC_CNTL_HMAC_HDR_T_PADDING OFFSETOF(lbmc_cntl_hmac_hdr_t, padding) +#define L_LBMC_CNTL_HMAC_HDR_T_PADDING SIZEOF(lbmc_cntl_hmac_hdr_t, padding) +#define O_LBMC_CNTL_HMAC_HDR_T_DATA OFFSETOF(lbmc_cntl_hmac_hdr_t, data) +#define L_LBMC_CNTL_HMAC_HDR_T_DATA SIZEOF(lbmc_cntl_hmac_hdr_t, data) +#define L_LBMC_CNTL_HMAC_HDR_T (gint) sizeof(lbmc_cntl_hmac_hdr_t) + +/* LBMC control UMQ session ID header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t key; + lbm_uint8_t sid[8]; +} lbmc_cntl_umq_sid_hdr_t; +#define O_LBMC_CNTL_UMQ_SID_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_umq_sid_hdr_t, next_hdr) +#define L_LBMC_CNTL_UMQ_SID_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_umq_sid_hdr_t, next_hdr) +#define O_LBMC_CNTL_UMQ_SID_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_umq_sid_hdr_t, hdr_len) +#define L_LBMC_CNTL_UMQ_SID_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_umq_sid_hdr_t, hdr_len) +#define O_LBMC_CNTL_UMQ_SID_HDR_T_FLAGS OFFSETOF(lbmc_cntl_umq_sid_hdr_t, flags) +#define L_LBMC_CNTL_UMQ_SID_HDR_T_FLAGS SIZEOF(lbmc_cntl_umq_sid_hdr_t, flags) +#define O_LBMC_CNTL_UMQ_SID_HDR_T_KEY OFFSETOF(lbmc_cntl_umq_sid_hdr_t, key) +#define L_LBMC_CNTL_UMQ_SID_HDR_T_KEY SIZEOF(lbmc_cntl_umq_sid_hdr_t, key) +#define O_LBMC_CNTL_UMQ_SID_HDR_T_SID OFFSETOF(lbmc_cntl_umq_sid_hdr_t, sid) +#define L_LBMC_CNTL_UMQ_SID_HDR_T_SID SIZEOF(lbmc_cntl_umq_sid_hdr_t, sid) +#define L_LBMC_CNTL_UMQ_SID_HDR_T (gint) sizeof(lbmc_cntl_umq_sid_hdr_t) + +/* LBMC destination header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t domain_id; + lbm_uint32_t ipaddr; + lbm_uint16_t port; + lbm_uint16_t hops_taken; + lbm_uint32_t orig_domain_id; + lbm_uint32_t orig_ipaddr; + lbm_uint16_t orig_port; + lbm_uint16_t reserved; +} lbmc_destination_hdr_t; +#define O_LBMC_DESTINATION_HDR_T_NEXT_HDR OFFSETOF(lbmc_destination_hdr_t, next_hdr) +#define L_LBMC_DESTINATION_HDR_T_NEXT_HDR SIZEOF(lbmc_destination_hdr_t, next_hdr) +#define O_LBMC_DESTINATION_HDR_T_HDR_LEN OFFSETOF(lbmc_destination_hdr_t, hdr_len) +#define L_LBMC_DESTINATION_HDR_T_HDR_LEN SIZEOF(lbmc_destination_hdr_t, hdr_len) +#define O_LBMC_DESTINATION_HDR_T_FLAGS OFFSETOF(lbmc_destination_hdr_t, flags) +#define L_LBMC_DESTINATION_HDR_T_FLAGS SIZEOF(lbmc_destination_hdr_t, flags) +#define O_LBMC_DESTINATION_HDR_T_DOMAIN_ID OFFSETOF(lbmc_destination_hdr_t, domain_id) +#define L_LBMC_DESTINATION_HDR_T_DOMAIN_ID SIZEOF(lbmc_destination_hdr_t, domain_id) +#define O_LBMC_DESTINATION_HDR_T_IPADDR OFFSETOF(lbmc_destination_hdr_t, ipaddr) +#define L_LBMC_DESTINATION_HDR_T_IPADDR SIZEOF(lbmc_destination_hdr_t, ipaddr) +#define O_LBMC_DESTINATION_HDR_T_PORT OFFSETOF(lbmc_destination_hdr_t, port) +#define L_LBMC_DESTINATION_HDR_T_PORT SIZEOF(lbmc_destination_hdr_t, port) +#define O_LBMC_DESTINATION_HDR_T_HOPS_TAKEN OFFSETOF(lbmc_destination_hdr_t, hops_taken) +#define L_LBMC_DESTINATION_HDR_T_HOPS_TAKEN SIZEOF(lbmc_destination_hdr_t, hops_taken) +#define O_LBMC_DESTINATION_HDR_T_ORIG_DOMAIN_ID OFFSETOF(lbmc_destination_hdr_t, orig_domain_id) +#define L_LBMC_DESTINATION_HDR_T_ORIG_DOMAIN_ID SIZEOF(lbmc_destination_hdr_t, orig_domain_id) +#define O_LBMC_DESTINATION_HDR_T_ORIG_IPADDR OFFSETOF(lbmc_destination_hdr_t, orig_ipaddr) +#define L_LBMC_DESTINATION_HDR_T_ORIG_IPADDR SIZEOF(lbmc_destination_hdr_t, orig_ipaddr) +#define O_LBMC_DESTINATION_HDR_T_ORIG_PORT OFFSETOF(lbmc_destination_hdr_t, orig_port) +#define L_LBMC_DESTINATION_HDR_T_ORIG_PORT SIZEOF(lbmc_destination_hdr_t, orig_port) +#define O_LBMC_DESTINATION_HDR_T_RESERVED OFFSETOF(lbmc_destination_hdr_t, reserved) +#define L_LBMC_DESTINATION_HDR_T_RESERVED SIZEOF(lbmc_destination_hdr_t, reserved) +#define L_LBMC_DESTINATION_HDR_T (gint) sizeof(lbmc_destination_hdr_t) + +/* LBMC topic index header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t tidx; +} lbmc_topic_idx_hdr_t; +#define O_LBMC_TOPIC_IDX_HDR_T_NEXT_HDR OFFSETOF(lbmc_topic_idx_hdr_t, next_hdr) +#define L_LBMC_TOPIC_IDX_HDR_T_NEXT_HDR SIZEOF(lbmc_topic_idx_hdr_t, next_hdr) +#define O_LBMC_TOPIC_IDX_HDR_T_HDR_LEN OFFSETOF(lbmc_topic_idx_hdr_t, hdr_len) +#define L_LBMC_TOPIC_IDX_HDR_T_HDR_LEN SIZEOF(lbmc_topic_idx_hdr_t, hdr_len) +#define O_LBMC_TOPIC_IDX_HDR_T_FLAGS OFFSETOF(lbmc_topic_idx_hdr_t, flags) +#define L_LBMC_TOPIC_IDX_HDR_T_FLAGS SIZEOF(lbmc_topic_idx_hdr_t, flags) +#define O_LBMC_TOPIC_IDX_HDR_T_TIDX OFFSETOF(lbmc_topic_idx_hdr_t, tidx) +#define L_LBMC_TOPIC_IDX_HDR_T_TIDX SIZEOF(lbmc_topic_idx_hdr_t, tidx) +#define L_LBMC_TOPIC_IDX_HDR_T (gint) sizeof(lbmc_topic_idx_hdr_t) + +/* LBMC control topic source header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t domain_id; +} lbmc_cntl_topic_source_hdr_t; +#define O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_topic_source_hdr_t, next_hdr) +#define L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_topic_source_hdr_t, next_hdr) +#define O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_topic_source_hdr_t, hdr_len) +#define L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_topic_source_hdr_t, hdr_len) +#define O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS OFFSETOF(lbmc_cntl_topic_source_hdr_t, flags) +#define L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS SIZEOF(lbmc_cntl_topic_source_hdr_t, flags) +#define O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_DOMAIN_ID OFFSETOF(lbmc_cntl_topic_source_hdr_t, domain_id) +#define L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_DOMAIN_ID SIZEOF(lbmc_cntl_topic_source_hdr_t, domain_id) +#define L_LBMC_CNTL_TOPIC_SOURCE_HDR_T (gint) sizeof(lbmc_cntl_topic_source_hdr_t) + +/* LBMC control topic source extended functionality header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t src_ip; + lbm_uint16_t src_port; + lbm_uint16_t unused; + lbm_uint32_t functionality_flags; +} lbmc_cntl_topic_source_exfunc_hdr_t; +#define O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_topic_source_exfunc_hdr_t, next_hdr) +#define L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_topic_source_exfunc_hdr_t, next_hdr) +#define O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_topic_source_exfunc_hdr_t, hdr_len) +#define L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_topic_source_exfunc_hdr_t, hdr_len) +#define O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FLAGS OFFSETOF(lbmc_cntl_topic_source_exfunc_hdr_t, flags) +#define L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FLAGS SIZEOF(lbmc_cntl_topic_source_exfunc_hdr_t, flags) +#define O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_SRC_IP OFFSETOF(lbmc_cntl_topic_source_exfunc_hdr_t, src_ip) +#define L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_SRC_IP SIZEOF(lbmc_cntl_topic_source_exfunc_hdr_t, src_ip) +#define O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_SRC_PORT OFFSETOF(lbmc_cntl_topic_source_exfunc_hdr_t, src_port) +#define L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_SRC_PORT SIZEOF(lbmc_cntl_topic_source_exfunc_hdr_t, src_port) +#define O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_UNUSED OFFSETOF(lbmc_cntl_topic_source_exfunc_hdr_t, unused) +#define L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_UNUSED SIZEOF(lbmc_cntl_topic_source_exfunc_hdr_t, unused) +#define O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS OFFSETOF(lbmc_cntl_topic_source_exfunc_hdr_t, functionality_flags) +#define L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS SIZEOF(lbmc_cntl_topic_source_exfunc_hdr_t, functionality_flags) +#define L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T (gint) sizeof(lbmc_cntl_topic_source_exfunc_hdr_t) + +/* LBM control UME proxy source election token header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t store_index; + lbm_uint32_t token; +} lbmc_cntl_ume_psrc_election_token_hdr_t; +#define O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_ume_psrc_election_token_hdr_t, next_hdr) +#define L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_ume_psrc_election_token_hdr_t, next_hdr) +#define O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_ume_psrc_election_token_hdr_t, hdr_len) +#define L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_ume_psrc_election_token_hdr_t, hdr_len) +#define O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_FLAGS OFFSETOF(lbmc_cntl_ume_psrc_election_token_hdr_t, flags) +#define L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_FLAGS SIZEOF(lbmc_cntl_ume_psrc_election_token_hdr_t, flags) +#define O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_STORE_INDEX OFFSETOF(lbmc_cntl_ume_psrc_election_token_hdr_t, store_index) +#define L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_STORE_INDEX SIZEOF(lbmc_cntl_ume_psrc_election_token_hdr_t, store_index) +#define O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_TOKEN OFFSETOF(lbmc_cntl_ume_psrc_election_token_hdr_t, token) +#define L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_TOKEN SIZEOF(lbmc_cntl_ume_psrc_election_token_hdr_t, token) +#define L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T (gint) sizeof(lbmc_cntl_ume_psrc_election_token_hdr_t) + +/* LBM control TCP session ID header. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t flags; + lbm_uint32_t sid; +} lbmc_cntl_tcp_sid_hdr_t; +#define O_LBMC_CNTL_TCP_SID_HDR_T_NEXT_HDR OFFSETOF(lbmc_cntl_tcp_sid_hdr_t, next_hdr) +#define L_LBMC_CNTL_TCP_SID_HDR_T_NEXT_HDR SIZEOF(lbmc_cntl_tcp_sid_hdr_t, next_hdr) +#define O_LBMC_CNTL_TCP_SID_HDR_T_HDR_LEN OFFSETOF(lbmc_cntl_tcp_sid_hdr_t, hdr_len) +#define L_LBMC_CNTL_TCP_SID_HDR_T_HDR_LEN SIZEOF(lbmc_cntl_tcp_sid_hdr_t, hdr_len) +#define O_LBMC_CNTL_TCP_SID_HDR_T_FLAGS OFFSETOF(lbmc_cntl_tcp_sid_hdr_t, flags) +#define L_LBMC_CNTL_TCP_SID_HDR_T_FLAGS SIZEOF(lbmc_cntl_tcp_sid_hdr_t, flags) +#define O_LBMC_CNTL_TCP_SID_HDR_T_SID OFFSETOF(lbmc_cntl_tcp_sid_hdr_t, sid) +#define L_LBMC_CNTL_TCP_SID_HDR_T_SID SIZEOF(lbmc_cntl_tcp_sid_hdr_t, sid) +#define L_LBMC_CNTL_TCP_SID_HDR_T (gint) sizeof(lbmc_cntl_tcp_sid_hdr_t) + +/* LBMC extended configuration option. */ +typedef struct +{ + lbm_uint8_t scope; + lbm_uint8_t parent; +} lbmc_extopt_cfgopt_hdr_t; +#define O_LBMC_EXTOPT_CFGOPT_HDR_T_SCOPE OFFSETOF(lbmc_extopt_cfgopt_hdr_t, scope) +#define L_LBMC_EXTOPT_CFGOPT_HDR_T_SCOPE SIZEOF(lbmc_extopt_cfgopt_hdr_t, scope) +#define O_LBMC_EXTOPT_CFGOPT_HDR_T_PARENT OFFSETOF(lbmc_extopt_cfgopt_hdr_t, scope) +#define L_LBMC_EXTOPT_CFGOPT_HDR_T_PARENT SIZEOF(lbmc_extopt_cfgopt_hdr_t, scope) +#define L_LBMC_EXTOPT_CFGOPT_HDR_T (gint) sizeof(lbmc_extopt_cfgopt_hdr_t) + +/* LBMC extended option. */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint8_t flags; + lbm_uint8_t id; + lbm_uint16_t subtype; + lbm_uint16_t fragment_offset; +} lbmc_extopt_hdr_t; +#define O_LBMC_EXTOPT_HDR_T_NEXT_HDR OFFSETOF(lbmc_extopt_hdr_t, next_hdr) +#define L_LBMC_EXTOPT_HDR_T_NEXT_HDR SIZEOF(lbmc_extopt_hdr_t, next_hdr) +#define O_LBMC_EXTOPT_HDR_T_HDR_LEN OFFSETOF(lbmc_extopt_hdr_t, hdr_len) +#define L_LBMC_EXTOPT_HDR_T_HDR_LEN SIZEOF(lbmc_extopt_hdr_t, hdr_len) +#define O_LBMC_EXTOPT_HDR_T_FLAGS OFFSETOF(lbmc_extopt_hdr_t, flags) +#define L_LBMC_EXTOPT_HDR_T_FLAGS SIZEOF(lbmc_extopt_hdr_t, flags) +#define O_LBMC_EXTOPT_HDR_T_ID OFFSETOF(lbmc_extopt_hdr_t, id) +#define L_LBMC_EXTOPT_HDR_T_ID SIZEOF(lbmc_extopt_hdr_t, id) +#define O_LBMC_EXTOPT_HDR_T_SUBTYPE OFFSETOF(lbmc_extopt_hdr_t, subtype) +#define L_LBMC_EXTOPT_HDR_T_SUBTYPE SIZEOF(lbmc_extopt_hdr_t, subtype) +#define O_LBMC_EXTOPT_HDR_T_FRAGMENT_OFFSET OFFSETOF(lbmc_extopt_hdr_t, fragment_offset) +#define L_LBMC_EXTOPT_HDR_T_FRAGMENT_OFFSET SIZEOF(lbmc_extopt_hdr_t, fragment_offset) +#define L_LBMC_EXTOPT_HDR_T (gint) sizeof(lbmc_extopt_hdr_t) + +/* LBMC message properties. */ +typedef struct +{ + lbm_uint32_t key_offset; + lbm_uint32_t value_offset; + lbm_uint32_t hash; + lbm_uint32_t type; +} lbm_msg_properties_hdr_t; +#define O_LBM_MSG_PROPERTIES_HDR_T_KEY_OFFSET OFFSETOF(lbm_msg_properties_hdr_t, key_offset) +#define L_LBM_MSG_PROPERTIES_HDR_T_KEY_OFFSET SIZEOF(lbm_msg_properties_hdr_t, key_offset) +#define O_LBM_MSG_PROPERTIES_HDR_T_VALUE_OFFSET OFFSETOF(lbm_msg_properties_hdr_t, value_offset) +#define L_LBM_MSG_PROPERTIES_HDR_T_VALUE_OFFSET SIZEOF(lbm_msg_properties_hdr_t, value_offset) +#define O_LBM_MSG_PROPERTIES_HDR_T_HASH OFFSETOF(lbm_msg_properties_hdr_t, hash) +#define L_LBM_MSG_PROPERTIES_HDR_T_HASH SIZEOF(lbm_msg_properties_hdr_t, hash) +#define O_LBM_MSG_PROPERTIES_HDR_T_TYPE OFFSETOF(lbm_msg_properties_hdr_t, type) +#define L_LBM_MSG_PROPERTIES_HDR_T_TYPE SIZEOF(lbm_msg_properties_hdr_t, type) +#define L_LBM_MSG_PROPERTIES_HDR_T (gint) sizeof(lbm_msg_properties_hdr_t) + +typedef struct +{ + lbm_uint32_t magic; + lbm_uint16_t num_fields; + lbm_uint8_t vertype; + lbm_uint8_t res; +} lbm_msg_properties_data_t; +#define O_LBM_MSG_PROPERTIES_DATA_T_MAGIC OFFSETOF(lbm_msg_properties_data_t, magic) +#define L_LBM_MSG_PROPERTIES_DATA_T_MAGIC SIZEOF(lbm_msg_properties_data_t, magic) +#define O_LBM_MSG_PROPERTIES_DATA_T_NUM_FIELDS OFFSETOF(lbm_msg_properties_data_t, num_fields) +#define L_LBM_MSG_PROPERTIES_DATA_T_NUM_FIELDS SIZEOF(lbm_msg_properties_data_t, num_fields) +#define O_LBM_MSG_PROPERTIES_DATA_T_VERTYPE OFFSETOF(lbm_msg_properties_data_t, vertype) +#define L_LBM_MSG_PROPERTIES_DATA_T_VERTYPE SIZEOF(lbm_msg_properties_data_t, vertype) +#define O_LBM_MSG_PROPERTIES_DATA_T_RES OFFSETOF(lbm_msg_properties_data_t, res) +#define L_LBM_MSG_PROPERTIES_DATA_T_RES SIZEOF(lbm_msg_properties_data_t, res) +#define L_LBM_MSG_PROPERTIES_DATA_T (gint) sizeof(lbm_msg_properties_data_t) + +/* Unhandled header. */ +#define O_LBMC_UNHANDLED_HDR_T_NEXT_HDR OFFSETOF(lbmc_basic_hdr_t, next_hdr) +#define L_LBMC_UNHANDLED_HDR_T_NEXT_HDR SIZEOF(lbmc_basic_hdr_t, next_hdr) +#define O_LBMC_UNHANDLED_HDR_T_HDR_LEN OFFSETOF(lbmc_basic_hdr_t, hdr_len) +#define L_LBMC_UNHANDLED_HDR_T_HDR_LEN SIZEOF(lbmc_basic_hdr_t, hdr_len) + +/* End of LBMC header definitions. */ + +#define LBMC_VERSION 0x0 + +#define LBMC_TYPE_MESSAGE 0x00 +#define LBMC_TYPE_EOT 0x01 +#define LBMC_TYPE_PRORX 0x02 +#define LBMC_TYPE_CONTROL 0x08 +#define LBMC_TYPE_RETRANS 0x0A + +#define LBMC_NHDR_DATA 0x00 +#define LBMC_NHDR_FRAG 0x01 +#define LBMC_NHDR_BATCH 0x02 +#define LBMC_NHDR_TGIDX 0x03 +#define LBMC_NHDR_REQUEST 0x04 +#define LBMC_NHDR_TOPICNAME 0x05 +#define LBMC_NHDR_APPHDR 0x06 +#define LBMC_NHDR_APPHDR_CHAIN 0x07 +#define LBMC_NHDR_UMQ_MSGID 0x08 +#define LBMC_NHDR_UMQ_SQD_RCV 0x09 +#define LBMC_NHDR_UMQ_RESUB 0x0A +#define LBMC_NHDR_OTID 0x0B +#define LBMC_NHDR_CTXINSTD 0x0C +#define LBMC_NHDR_CTXINSTR 0x0D +#define LBMC_NHDR_SRCIDX 0x0E +#define LBMC_NHDR_UMQ_ULB_MSG 0x0F +#define LBMC_NHDR_SSF_INIT 0x10 +#define LBMC_NHDR_SSF_CREQ 0x11 +#define LBMC_NHDR_UME_PREG 0x12 +#define LBMC_NHDR_UME_PREG_RESP 0x13 +#define LBMC_NHDR_UME_ACK 0x14 +#define LBMC_NHDR_UME_RXREQ 0x15 +#define LBMC_NHDR_UME_KEEPALIVE 0x16 +#define LBMC_NHDR_UME_STOREID 0x17 +#define LBMC_NHDR_UME_RANGED_ACK 0x18 +#define LBMC_NHDR_UME_ACK_ID 0x19 +#define LBMC_NHDR_UME_CAPABILITY 0x1A +#define LBMC_NHDR_UME_PROXY_SRC 0x1B +#define LBMC_NHDR_UME_STORE_GROUP 0x1C +#define LBMC_NHDR_UME_STORE_INFO 0x1D +#define LBMC_NHDR_UME_LJ_INFO 0x1E +#define LBMC_NHDR_TSNI 0x20 +#define LBMC_NHDR_UMQ_REG 0x30 +#define LBMC_NHDR_UMQ_REG_RESP 0x31 +#define LBMC_NHDR_UMQ_ACK 0x32 +#define LBMC_NHDR_UMQ_RCR 0x33 +#define LBMC_NHDR_UMQ_KA 0x34 +#define LBMC_NHDR_UMQ_RXREQ 0x35 +#define LBMC_NHDR_UMQ_QMGMT 0x36 +#define LBMC_NHDR_UMQ_RESUB_REQ 0x37 +#define LBMC_NHDR_UMQ_RESUB_RESP 0x38 +#define LBMC_NHDR_TOPIC_INTEREST 0x39 +#define LBMC_NHDR_PATTERN_INTEREST 0x3A +#define LBMC_NHDR_ADVERTISEMENT 0x3B +#define LBMC_NHDR_UME_CTXINSTS 0x3C +#define LBMC_NHDR_UME_STORENAME 0x3D +#define LBMC_NHDR_UMQ_ULB_RCR 0x3E +#define LBMC_NHDR_UMQ_LF 0x3F +#define LBMC_NHDR_CTXINFO 0x40 +#define LBMC_NHDR_UME_PSER 0x41 +#define LBMC_NHDR_CTXINST 0x42 +#define LBMC_NHDR_DOMAIN 0x43 +#define LBMC_NHDR_TNWG_CAPABILITIES 0x44 +#define LBMC_NHDR_PATIDX 0x45 +#define LBMC_NHDR_UME_CLIENT_LIFETIME 0x46 +#define LBMC_NHDR_UME_SID 0x47 +#define LBMC_NHDR_UMQ_IDX_CMD 0x48 +#define LBMC_NHDR_UMQ_IDX_CMD_RESP 0x49 +#define LBMC_NHDR_ODOMAIN 0x4a +#define LBMC_NHDR_STREAM 0x4b +#define LBMC_NHDR_TOPIC_MD_INTEREST 0x4c +#define LBMC_NHDR_PATTERN_MD_INTEREST 0x4d +#define LBMC_NHDR_LJI_REQ 0x4e +#define LBMC_NHDR_TNWG_KA 0x4f +#define LBMC_NHDR_UME_RCV_KEEPALIVE 0x50 +#define LBMC_NHDR_UMQ_CMD 0x51 +#define LBMC_NHDR_UMQ_CMD_RESP 0x52 +#define LBMC_NHDR_SRI_REQ 0x53 +#define LBMC_NHDR_UME_STORE_DOMAIN 0x54 +#define LBMC_NHDR_SRI 0x55 +#define LBMC_NHDR_ROUTE_INFO 0x56 +#define LBMC_NHDR_ROUTE_INFO_NEIGHBOR 0x57 +#define LBMC_NHDR_GATEWAY_NAME 0x58 +#define LBMC_NHDR_AUTHENTICATION 0x60 +#define LBMC_NHDR_HMAC 0x62 +#define LBMC_NHDR_UMQ_SID 0x63 +#define LBMC_NHDR_DESTINATION 0x64 +#define LBMC_NHDR_TOPIC_IDX 0x65 +#define LBMC_NHDR_TOPIC_SOURCE 0x67 +#define LBMC_NHDR_TOPIC_SOURCE_EXFUNC 0x68 +#define LBMC_NHDR_UME_STORE_INFO_EXT 0x69 +#define LBMC_NHDR_UME_PSRC_ELECTION_TOKEN 0x6A +#define LBMC_NHDR_TCP_SID 0x6B + +#define LBMC_NHDR_EXTOPT 0xFE + +#define LBMC_NHDR_NONE 0xFF + +#define LBMC_OPT_IGNORE 0x8000 +#define LBMC_OPT_IGNORE_CHAR 0x80 +#define LBMC_BATCH_START 0x0002 +#define LBMC_BATCH_END 0x0001 + +#define LBMC_CNTL_SSF_INIT_DEFAULT_INC 0x40 +#define LBMC_CNTL_SSF_INIT_DEFAULT_EXC 0x20 + +#define LBMC_CNTL_SSF_CREQ_MODE_INCLUDE 0x00 +#define LBMC_CNTL_SSF_CREQ_MODE_EXCLUDE 0x01 + +#define LBMC_REQUEST_TRANSPORT_TCP 0x00 +#define LBMC_CNTL_SSF_INIT_TRANSPORT_TCP 0x00 + +#define LBMC_UME_PREG_S_FLAG 0x80 +#define LBMC_UME_PREG_F_FLAG 0x40 +#define LBMC_UME_PREG_P_FLAG 0x20 +#define LBMC_UME_PREG_W_FLAG 0x10 +#define LBMC_UME_PREG_D_FLAG 0x08 +#define LBMC_UME_PREG_MARKER_PRI 0x01 +#define LBMC_UME_PREG_MARKER_SEC 0x02 +#define LBMC_UME_PREG_MARKER_TER 0x03 +#define LBMC_UME_PREG_RESP_O_FLAG 0x40 +#define LBMC_UME_PREG_RESP_E_FLAG 0x20 +#define LBMC_UME_PREG_RESP_S_FLAG 0x80 +#define LBMC_UME_PREG_RESP_W_FLAG 0x02 +#define LBMC_UME_PREG_RESP_D_FLAG 0x01 +#define LBMC_UME_PREG_RESP_ERRCODE_ENOERROR 0x00 +#define LBMC_UME_PREG_RESP_ERRCODE_ENOPATTERN 0x01 +#define LBMC_UME_PREG_RESP_ERRCODE_ESRCREGID 0x02 +#define LBMC_UME_PREG_RESP_ERRCODE_EREGID 0x03 +#define LBMC_UME_PREG_RESP_ERRCODE_ETOPICNAME 0x04 +#define LBMC_UME_PREG_RESP_ERRCODE_EACTIVE 0x05 +#define LBMC_UME_PREG_RESP_ERRCODE_ECONFIG 0x06 +#define LBMC_UME_PREG_RESP_CODE_NOACKS_FLAG 0x10 +#define LBMC_UME_PREG_RESP_CODE_NOCACHE_FLAG 0x10 +#define LBMC_UME_ACK_O_FLAG 0x40 +#define LBMC_UME_ACK_F_FLAG 0x20 +#define LBMC_UME_ACK_U_FLAG 0x10 +#define LBMC_UME_ACK_E_FLAG 0x08 +#define LBMC_UME_ACK_TYPE_CDELV 0x00 +#define LBMC_UME_ACK_TYPE_STABLE 0x01 +#define LBMC_UME_KEEPALIVE_R_FLAG 0x40 +#define LBMC_UME_KEEPALIVE_T_FLAG 0x20 +#define LBMC_UME_KEEPALIVE_TYPE_SRC 0x2 +#define LBMC_UME_KEEPALIVE_TYPE_RCV 0x1 +#define LBMC_UME_KEEPALIVE_TYPE_STORE 0x0 +#define LBMC_UME_STOREID_MAX_STOREID 0x7FFF +#define LBMC_UME_CAPABILITY_QC_FLAG 0x4000 +#define LBMC_UME_CAPABILITY_CLIENT_LIFETIME_FLAG 0x2000 +#define LBMC_UME_PROXY_SRC_E_FLAG 0x4000 +#define LBMC_UME_PROXY_SRC_C_FLAG 0x2000 +#define LBMC_UME_RXREQ_T_FLAG 0x4000 +#define LBMC_LJI_REQ_L_FLAG 0x0001 +#define LBMC_LJI_REQ_M_FLAG 0x0002 +#define LBMC_LJI_REQ_O_FLAG 0x0004 +#define LBMC_SRI_A_FLAG 0x0001 +#define LBMC_SRI_INITIAL_SQN_KNOWN_FLAG 0x0002 +#define LBMC_UMQ_REG_CTX_TYPE 0x1 +#define LBMC_UMQ_REG_SRC_TYPE 0x2 +#define LBMC_UMQ_REG_RCV_TYPE 0x3 +#define LBMC_UMQ_REG_RCV_DEREG_TYPE 0x4 +#define LBMC_UMQ_REG_ULB_RCV_TYPE 0x5 +#define LBMC_UMQ_REG_ULB_RCV_DEREG_TYPE 0x6 +#define LBMC_UMQ_REG_OBSERVER_RCV_TYPE 0x7 +#define LBMC_UMQ_REG_OBSERVER_RCV_DEREG_TYPE 0x8 +#define LBMC_UMQ_REG_R_FLAG 0x40 +#define LBMC_UMQ_REG_T_FLAG 0x20 +#define LBMC_UMQ_REG_I_FLAG 0x10 +#define LBMC_UMQ_REG_MSG_SEL_FLAG 0x08 +#define LBMC_UMQ_REG_RESP_CTX_TYPE 0x1 +#define LBMC_UMQ_REG_RESP_SRC_TYPE 0x2 +#define LBMC_UMQ_REG_RESP_RCV_TYPE 0x3 +#define LBMC_UMQ_REG_RESP_RCV_DEREG_TYPE 0x4 +#define LBMC_UMQ_REG_RESP_ULB_RCV_TYPE 0x5 +#define LBMC_UMQ_REG_RESP_ULB_RCV_DEREG_TYPE 0x6 +#define LBMC_UMQ_REG_RESP_OBSERVER_RCV_TYPE 0x7 +#define LBMC_UMQ_REG_RESP_OBSERVER_RCV_DEREG_TYPE 0x8 +#define LBMC_UMQ_REG_RESP_CTX_EX_TYPE 0x9 +#define LBMC_UMQ_REG_RESP_ERR_TYPE 0xFF +#define LBMC_UMQ_REG_RESP_R_FLAG 0x40 +#define LBMC_UMQ_REG_RESP_ERR_L_FLAG 0x20 +#define LBMC_UMQ_REG_RESP_SRC_S_FLAG 0x20 +#define LBMC_UMQ_REG_RESP_SRC_D_FLAG 0x10 +#define LBMC_UMQ_REG_RESP_CTX_EX_FLAG_FIRSTMSG 0x1 + +#define LBMC_UMQ_ACK_STABLE_TYPE 0x1 +#define LBMC_UMQ_ACK_CR_TYPE 0x2 +#define LBMC_UMQ_ACK_ULB_CR_TYPE 0x3 +#define LBMC_UMQ_ACK_T_FLAG 0x40 +#define LBMC_UMQ_ACK_D_FLAG 0x20 +#define LBMC_UMQ_ACK_NUMIDS_MASK 0x0F +#define LBMC_UMQ_RCR_BOI_FLAG 0x100 +#define LBMC_UMQ_RCR_R_FLAG 0x4000 +#define LBMC_UMQ_RCR_D_FLAG 0x2000 +#define LBMC_UMQ_RCR_S_FLAG 0x1000 +#define LBMC_UMQ_RCR_EOI_FLAG 0x200 +#define LBMC_UMQ_RCR_BOI_FLAG 0x100 +#define LBMC_UMQ_ULB_RCR_R_FLAG 0x4000 +#define LBMC_UMQ_ULB_RCR_D_FLAG 0x2000 +#define LBMC_UMQ_ULB_RCR_EOI_FLAG 0x200 +#define LBMC_UMQ_ULB_RCR_BOI_FLAG 0x100 +#define LBMC_UMQ_SQD_RCV_R_FLAG 0x4000 +#define LBMC_UMQ_SQD_RCV_S_FLAG 0x2000 +#define LBMC_UMQ_SQD_RCV_RE_FLAG 0x800 +#define LBMC_UMQ_SQD_RCV_EOI_FLAG 0x200 +#define LBMC_UMQ_SQD_RCV_BOI_FLAG 0x100 +#define LBMC_UMQ_RESUB_Q_FLAG 0x4000 +#define LBMC_UMQ_ULB_MSG_A_FLAG 0x4000 +#define LBMC_UMQ_ULB_MSG_R_FLAG 0x2000 +#define LBMC_UMQ_KA_CTX_TYPE 0x00 +#define LBMC_UMQ_KA_SRC_TYPE 0x01 +#define LBMC_UMQ_KA_RCV_TYPE 0x02 +#define LBMC_UMQ_KA_ULB_RCV_TYPE 0x03 +#define LBMC_UMQ_KA_CTX_RESP_TYPE 0x10 +#define LBMC_UMQ_KA_SRC_RESP_TYPE 0x11 +#define LBMC_UMQ_KA_RCV_RESP_TYPE 0x12 +#define LBMC_UMQ_KA_ULB_RCV_RESP_TYPE 0x13 +#define LBMC_UMQ_KA_R_FLAG 0x40 +#define LBMC_UMQ_RXREQ_MR_TYPE 0x1 +#define LBMC_UMQ_RXREQ_QRCRR_TYPE 0x2 +#define LBMC_UMQ_RXREQ_TRCRR_TYPE 0x3 +#define LBMC_UMQ_RXREQ_ULB_MR_TYPE 0x4 +#define LBMC_UMQ_RXREQ_ULB_TRCRR_TYPE 0x5 +#define LBMC_UMQ_RXREQ_ULB_MR_ABORT_TYPE 0x6 +#define LBMC_UMQ_RXREQ_ULB_TRCRR_ABORT_TYPE 0x7 +#define LBMC_UMQ_RXREQ_R_FLAG 0x40 +#define LBMC_UMQ_RESUB_RESP_ENQUEUED_CODE 0x1 +#define LBMC_UMQ_RESUB_RESP_CONSUMED_CODE 0x2 +#define LBMC_UMQ_RESUB_RESP_OUTSTANDING_CODE 0x3 +#define LBMC_UMQ_RESUB_RESP_RESUBALLOWED_CODE 0x4 +#define LBMC_UMQ_RESUB_RESP_RESUBDONE_CODE 0x5 +#define LBMC_UMQ_LF_SRC_TYPE 0x01 +#define LBMC_UMQ_LF_RCV_TYPE 0x02 +#define LBMC_UMQ_LF_U_FLAG 0x40 +#define LBMC_UMQ_IDX_CMD_RCV_STOP_IDX_ASSIGN_TYPE 0x1 +#define LBMC_UMQ_IDX_CMD_RCV_START_IDX_ASSIGN_TYPE 0x2 +#define LBMC_UMQ_IDX_CMD_ULB_RCV_STOP_IDX_ASSIGN_TYPE 0x3 +#define LBMC_UMQ_IDX_CMD_ULB_RCV_START_IDX_ASSIGN_TYPE 0x4 +#define LBMC_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_TYPE 0x5 +#define LBMC_UMQ_IDX_CMD_ULB_RCV_RELEASE_IDX_ASSIGN_TYPE 0x6 +#define LBMC_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_TYPE 0x7 +#define LBMC_UMQ_IDX_CMD_ULB_RCV_RESERVE_IDX_ASSIGN_TYPE 0x8 +#define LBMC_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_TYPE 0x1 +#define LBMC_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_TYPE 0x2 +#define LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_TYPE 0x3 +#define LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_TYPE 0x4 +#define LBMC_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_TYPE 0x5 +#define LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_TYPE 0x6 +#define LBMC_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_TYPE 0x7 +#define LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_TYPE 0x8 + +#define LBMC_UMQ_IDX_CMD_RESP_ERR_TYPE 0xFF +#define LBMC_UMQ_IDX_CMD_RESP_ERR_L_FLAG 0x20 +#define LBM_UMQ_INDEX_FLAG_NUMERIC 0x1 + +#define LBMC_TOPIC_INTEREST_CANCEL_FLAG 0x4000 +#define LBMC_TOPIC_INTEREST_REFRESH_FLAG 0x2000 +#define LBMC_PATTERN_INTEREST_CANCEL_FLAG 0x40 +#define LBMC_PATTERN_INTEREST_REFRESH_FLAG 0x20 +#define LBMC_ADVERTISEMENT_EOS_FLAG 0x40 +#define LBMC_ADVERTISEMENT_PATTERN_FLAG 0x20 +#define LBMC_ADVERTISEMENT_CHANGE_FLAG 0x10 +#define LBMC_ADVERTISEMENT_CTXINST_FLAG 0x08 +#define LBMC_TOPIC_SOURCE_EOS_FLAG 0x4000 +#define LBMC_ADVERTISEMENT_AD_LJ_FLAG 0x80000000 +#define LBMC_ADVERTISEMENT_AD_UME_FLAG 0x40000000 +#define LBMC_ADVERTISEMENT_AD_ACKTOSRC_FLAG 0x20000000 +#define LBMC_ADVERTISEMENT_AD_QUEUE_FLAG 0x10000000 +#define LBMC_ADVERTISEMENT_AD_ULB_FLAG 0x08000000 +#define LBMC_CTXINFO_QUERY_FLAG 0x4000 +#define LBMC_CTXINFO_ADDR_FLAG 0x2000 +#define LBMC_CTXINFO_CTXINST_FLAG 0x1000 +#define LBMC_CTXINFO_NAME_FLAG 0x0800 +#define LBMC_CTXINFO_TNWGSRC_FLAG 0x0400 +#define LBMC_CTXINFO_TNWGRCV_FLAG 0x0200 +#define LBMC_CTXINFO_PROXY_FLAG 0x0100 +#define LBMC_UME_PSER_SOURCE_CTXINST_FLAG 0x4000 +#define LBMC_UME_PSER_STORE_CTXINST_FLAG 0x2000 +#define LBMC_UME_PSER_REELECT_FLAG 0x1000 +#define LBMC_DOMAIN_ACTIVE_FLAG 0x4000 +#define LBMC_CNTL_TNWG_CAPABILITIES_VERSION_MASK 0x7fff +#define LBMC_CNTL_TNWG_CAPABILITIES1_UME_FLAG 0x80000000 +#define LBMC_CNTL_TNWG_CAPABILITIES1_UMQ_FLAG 0x40000000 +#define LBMC_CNTL_TNWG_CAPABILITIES3_PCRE_FLAG 0x80000000 +#define LBMC_CNTL_TNWG_CAPABILITIES3_REGEX_FLAG 0x40000000 + +#define LBM_CHAIN_ELEM_CHANNEL_NUMBER 0x1 +#define LBM_CHAIN_ELEM_HF_SQN 0x2 +#define LBM_CHAIN_ELEM_GW_INFO 0x3 +#define LBM_CHAIN_ELEM_APPHDR 0x4 +#define LBM_CHAIN_ELEM_USER_DATA 0x5 +#define LBM_CHAIN_ELEM_PROPERTIES_LENGTH 0x6 +#define LBM_CHAIN_ELEM_NONE 0xff + +#define LBMC_CNTL_TNWG_KA_Q_FLAG 0x4000 +#define LBMC_CNTL_TNWG_KA_R_FLAG 0x2000 + +#define LBMC_UMQ_CMD_TYPE_TOPIC_LIST 1 +#define LBMC_UMQ_CMD_TYPE_RCV_MSG_RETRIEVE 2 +#define LBMC_UMQ_CMD_TYPE_RCV_MSG_LIST 3 + +#define LBMC_UMQ_CMD_RESP_TYPE_CTX_TOPIC_LIST 1 +#define LBMC_UMQ_CMD_RESP_TYPE_RCV_MSG_RETRIEVE 2 +#define LBMC_UMQ_CMD_RESP_TYPE_RCV_MSG_LIST 3 +#define LBMC_UMQ_CMD_RESP_TYPE_ERROR 4 + +#define AUTH_OP_REQ 0x01 +#define AUTH_OP_CHALLENGE 0x02 +#define AUTH_OP_CHALLENGE_RSP 0x03 +#define AUTH_OP_RESULT 0x04 + +#define LBMC_UMQ_CMD_RESP_ERROR_AUTHFAIL 0x11 +#define LBMC_UMQ_CMD_RESP_ERROR_NOHMAC 0x12 +#define LBMC_UMQ_CMD_RESP_ERROR_NOAUTHOR 0x13 + +#define LBMC_EXTOPT_FLAG_IGNORE 0x80 +#define LBMC_EXTOPT_FLAG_IGNORE_SUBTYPE 0x40 +#define LBMC_EXTOPT_FLAG_MORE_FRAGMENT 0x20 + +#define LBMC_EXT_NHDR_CFGOPT 0x0100 +#define LBMC_EXT_NHDR_MSGSEL 0x0101 + +#define LBM_MSG_PROPERTIES_HDR_VER(vt) ((vt & 0xF0) >> 4) +#define LBM_MSG_PROPERTIES_HDR_TYPE(vt) (vt & 0xF) +#define LBM_MSG_PROPERTIES_HDR_VER_MASK 0xF0 +#define LBM_MSG_PROPERTIES_HDR_TYPE_MASK 0x0F + +#define LBM_MSG_PROPERTIES_VER 0x0 + +#define LBM_MSG_PROPERTIES_TYPE_NORMAL 0x0 + +#define LBM_MSG_PROPERTIES_MAGIC 0xABACDABA +#define LBM_MSG_PROPERTIES_ANTIMAGIC 0xBADAACAB + +#define LBM_MSG_PROPERTY_NONE 0x0 +#define LBM_MSG_PROPERTY_BOOLEAN 0x1 +#define LBM_MSG_PROPERTY_BYTE 0x2 +#define LBM_MSG_PROPERTY_SHORT 0x3 +#define LBM_MSG_PROPERTY_INT 0x4 +#define LBM_MSG_PROPERTY_LONG 0x5 +#define LBM_MSG_PROPERTY_FLOAT 0x6 +#define LBM_MSG_PROPERTY_DOUBLE 0x7 +#define LBM_MSG_PROPERTY_STRING 0x8 + +#define LBM_UMQ_QUEUE_MSG_STATUS_UNKNOWN 0 +#define LBM_UMQ_QUEUE_MSG_STATUS_UNASSIGNED 1 +#define LBM_UMQ_QUEUE_MSG_STATUS_ASSIGNED 2 +#define LBM_UMQ_QUEUE_MSG_STATUS_REASSIGNING 3 +#define LBM_UMQ_QUEUE_MSG_STATUS_CONSUMED 4 +#define LBM_UMQ_QUEUE_MSG_STATUS_COMPLETE 5 + +#define LBMC_CNTL_CONFIG_OPT_SCOPE_SOURCE 0x1 +#define LBMC_CNTL_CONFIG_OPT_SCOPE_RECEIVER 0x2 +#define LBMC_CNTL_CONFIG_OPT_SCOPE_CONTEXT 0x3 +#define LBMC_CNTL_CONFIG_OPT_SCOPE_WILDCARD_RECEIVER 0x4 +#define LBMC_CNTL_CONFIG_OPT_SCOPE_EVENT_QUEUE 0x5 +#define LBMC_CNTL_CONFIG_OPT_SCOPE_CONNECTION_FACTORY 0x6 +#define LBMC_CNTL_CONFIG_OPT_SCOPE_DESTINATION 0x7 +#define LBMC_CNTL_CONFIG_OPT_SCOPE_HFX 0x8 + +/*----------------------------------------------------------------------------*/ +/* Value translation tables. */ +/*----------------------------------------------------------------------------*/ + +static const value_string lbmc_message_type[] = +{ + { LBMC_TYPE_MESSAGE, "Message" }, + { LBMC_TYPE_PRORX, "Proactive Retransmission" }, + { LBMC_TYPE_RETRANS, "Retransmission" }, + { LBMC_TYPE_CONTROL, "Control" }, + { LBMC_TYPE_EOT, "EOT" }, + { 0x0, NULL } +}; + +static const value_string lbmc_next_header[] = +{ + { LBMC_NHDR_DATA, "Data" }, + { LBMC_NHDR_FRAG, "Fragment" }, + { LBMC_NHDR_BATCH, "Batch" }, + { LBMC_NHDR_TGIDX, "Unknown" }, + { LBMC_NHDR_REQUEST, "Request" }, + { LBMC_NHDR_TOPICNAME, "Topic name" }, + { LBMC_NHDR_APPHDR, "Application header" }, + { LBMC_NHDR_APPHDR_CHAIN, "Application header chain" }, + { LBMC_NHDR_UMQ_MSGID, "UMQ message ID" }, + { LBMC_NHDR_UMQ_SQD_RCV, "UMQ SQD rcv" }, + { LBMC_NHDR_UMQ_RESUB, "UMQ resub" }, + { LBMC_NHDR_OTID, "OTID" }, + { LBMC_NHDR_CTXINSTD, "Context instance destination" }, + { LBMC_NHDR_CTXINSTR, "Context instance return" }, + { LBMC_NHDR_SRCIDX, "Source index" }, + { LBMC_NHDR_UMQ_ULB_MSG, "UMQ ULB Message" }, + { LBMC_NHDR_SSF_INIT, "Source-side filtering init" }, + { LBMC_NHDR_SSF_CREQ, "Source-side filtering control request" }, + { LBMC_NHDR_UME_PREG, "UME persistent registration" }, + { LBMC_NHDR_UME_PREG_RESP, "UME persistent registration response" }, + { LBMC_NHDR_UME_ACK, "UME acknowledgement" }, + { LBMC_NHDR_UME_RXREQ, "UME retransmission request" }, + { LBMC_NHDR_UME_KEEPALIVE, "UME keepalive" }, + { LBMC_NHDR_UME_STOREID, "UME store ID" }, + { LBMC_NHDR_UME_RANGED_ACK, "UME ranged ACK" }, + { LBMC_NHDR_UME_ACK_ID, "UME ACK" }, + { LBMC_NHDR_UME_CAPABILITY, "UME capability" }, + { LBMC_NHDR_UME_PROXY_SRC, "Proxy source" }, + { LBMC_NHDR_UME_STORE_GROUP, "Store group" }, + { LBMC_NHDR_UME_STORE_INFO, "Store info" }, + { LBMC_NHDR_UME_LJ_INFO, "UME late-join info" }, + { LBMC_NHDR_TSNI, "Topic sequence info" }, + { LBMC_NHDR_UMQ_REG, "UMQ registration" }, + { LBMC_NHDR_UMQ_REG_RESP, "UMQ registration response" }, + { LBMC_NHDR_UMQ_ACK, "UMQ ACK" }, + { LBMC_NHDR_UMQ_RCR, "UMQ receiver control record" }, + { LBMC_NHDR_UMQ_KA, "UMQ keepalive" }, + { LBMC_NHDR_UMQ_RXREQ, "UME retransmission request" }, + { LBMC_NHDR_UMQ_QMGMT, "UMQ queue management" }, + { LBMC_NHDR_UMQ_RESUB_REQ, "UMQ resubmission request" }, + { LBMC_NHDR_UMQ_RESUB_RESP, "UMQ resubmission response" }, + { LBMC_NHDR_TOPIC_INTEREST, "Topic interest" }, + { LBMC_NHDR_PATTERN_INTEREST, "Pattern interest" }, + { LBMC_NHDR_ADVERTISEMENT, "Advertisement" }, + { LBMC_NHDR_UME_CTXINSTS, "Store context instance" }, + { LBMC_NHDR_UME_STORENAME, "Store name" }, + { LBMC_NHDR_UMQ_ULB_RCR, "UMQ ULB RCR" }, + { LBMC_NHDR_UMQ_LF, "UMQ load factor" }, + { LBMC_NHDR_CTXINFO, "Context information" }, + { LBMC_NHDR_UME_PSER, "UME proxy source election" }, + { LBMC_NHDR_CTXINST, "Context instance" }, + { LBMC_NHDR_DOMAIN, "Domain" }, + { LBMC_NHDR_TNWG_CAPABILITIES, "TNWG Capabilities" }, + { LBMC_NHDR_PATIDX, "Pattern index" }, + { LBMC_NHDR_UME_CLIENT_LIFETIME, "UME client lifetime" }, + { LBMC_NHDR_UME_SID, "UME session ID" }, + { LBMC_NHDR_UMQ_IDX_CMD, "UMQ index command" }, + { LBMC_NHDR_UMQ_IDX_CMD_RESP, "UMQ index command response" }, + { LBMC_NHDR_ODOMAIN, "Originating Domain" }, + { LBMC_NHDR_STREAM, "Stream" }, + { LBMC_NHDR_TOPIC_MD_INTEREST, "Topic multi-domain interest" }, + { LBMC_NHDR_PATTERN_MD_INTEREST, "Pattern multi-domain interest" }, + { LBMC_NHDR_LJI_REQ, "Late Join information request" }, + { LBMC_NHDR_TNWG_KA, "Gateway peer keepalive" }, + { LBMC_NHDR_UME_RCV_KEEPALIVE, "UME receiver keepalive" }, + { LBMC_NHDR_UMQ_CMD, "UMQ command" }, + { LBMC_NHDR_UMQ_CMD_RESP, "UMQ command response" }, + { LBMC_NHDR_SRI_REQ, "Source registration information request" }, + { LBMC_NHDR_UME_STORE_DOMAIN, "Store domain" }, + { LBMC_NHDR_SRI, "Source registration information" }, + { LBMC_NHDR_ROUTE_INFO, "Route information" }, + { LBMC_NHDR_ROUTE_INFO_NEIGHBOR, "Route information neighbor" }, + { LBMC_NHDR_GATEWAY_NAME, "Gateway name" }, + { LBMC_NHDR_AUTHENTICATION, "Authentication" }, + { LBMC_NHDR_HMAC, "HMAC" }, + { LBMC_NHDR_UMQ_SID, "UMQ session ID" }, + { LBMC_NHDR_DESTINATION, "Destination" }, + { LBMC_NHDR_TOPIC_IDX, "Topic index" }, + { LBMC_NHDR_TOPIC_SOURCE, "Topic source" }, + { LBMC_NHDR_TOPIC_SOURCE_EXFUNC, "Topic source extended functionality" }, + { LBMC_NHDR_EXTOPT, "Extended option" }, + { LBMC_NHDR_UME_STORE_INFO_EXT, "Store extended information" }, + { LBMC_NHDR_UME_PSRC_ELECTION_TOKEN, "Proxy source election token" }, + { LBMC_NHDR_NONE, "None" }, + { LBMC_NHDR_TCP_SID, "TCP session ID" }, + { 0x0, NULL } +}; + +static const value_string lbmc_req_transport_type[] = +{ + { LBMC_REQUEST_TRANSPORT_TCP, "TCP" }, + { 0x0, NULL } +}; + +static const value_string lbmc_ssf_transport_type[] = +{ + { LBMC_CNTL_SSF_INIT_TRANSPORT_TCP, "TCP" }, + { 0x0, NULL } +}; + +static const value_string lbmc_ssf_creq_mode[] = +{ + { LBMC_CNTL_SSF_CREQ_MODE_INCLUDE, "Include" }, + { LBMC_CNTL_SSF_CREQ_MODE_EXCLUDE, "Exclude" }, + { 0x0, NULL } +}; + +static const value_string lbmc_ume_preg_resp_error_code[] = +{ + { LBMC_UME_PREG_RESP_ERRCODE_ENOERROR, "No error" }, + { LBMC_UME_PREG_RESP_ERRCODE_ENOPATTERN, "Store has no matching pattern" }, + { LBMC_UME_PREG_RESP_ERRCODE_ESRCREGID, "Source RegID not found" }, + { LBMC_UME_PREG_RESP_ERRCODE_EREGID, "RegID is in use by a receiver" }, + { LBMC_UME_PREG_RESP_ERRCODE_ETOPICNAME, "Topic name does not match previous registration" }, + { LBMC_UME_PREG_RESP_ERRCODE_EACTIVE, "RegID is in use by a different source" }, + { LBMC_UME_PREG_RESP_ERRCODE_ECONFIG, "Source and store configuration values are incompatible" }, + { 0x0, NULL } +}; + +static const value_string lbmc_ume_ack_type[] = +{ + { LBMC_UME_ACK_TYPE_CDELV, "CDELV" }, + { LBMC_UME_ACK_TYPE_STABLE, "Stable" }, + { 0x0, NULL } +}; + +static const value_string lbmc_ume_ka_type[] = +{ + { LBMC_UME_KEEPALIVE_TYPE_SRC, "Source" }, + { LBMC_UME_KEEPALIVE_TYPE_RCV, "Receiver" }, + { LBMC_UME_KEEPALIVE_TYPE_STORE, "Store" }, + { 0x0, NULL } +}; + +static const true_false_string lbmc_ume_s_flag = +{ + "Source registration", + "Receiver registration" +}; + +static const true_false_string lbmc_ume_f_flag = +{ + "Do not forward ACKs", + "Forward ACKs" +}; + +static const true_false_string lbmc_ume_o_flag = +{ + "Old/returning client", + "New client" +}; + +static const true_false_string lbmc_ume_error_flag = +{ + "Error (see code)", + "No error" +}; + +static const true_false_string lbmc_ume_n_flag = +{ + "No cache (store) or no ACKs (receiver)", + "Cache (store) or ACKs (receiver)" +}; + +static const true_false_string lbmc_ume_r_flag = +{ + "Store requests a response", + "No response requested" +}; + +static const true_false_string lbmc_ume_t_flag = +{ + "Store has not seen a TIR for the topic", + "Store has seen a TIR for the topic" +}; + +static const value_string lbmc_apphdr_chain_type[] = +{ + { LBM_CHAIN_ELEM_CHANNEL_NUMBER, "Channel" }, + { LBM_CHAIN_ELEM_HF_SQN, "Hot failover sequence number" }, + { LBM_CHAIN_ELEM_GW_INFO, "Gateway info" }, + { LBM_CHAIN_ELEM_APPHDR, "Non-chained apphdr" }, + { LBM_CHAIN_ELEM_USER_DATA, "User data" }, + { LBM_CHAIN_ELEM_PROPERTIES_LENGTH, "Message properties length" }, + { LBM_CHAIN_ELEM_NONE, "None" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_reg_type[] = +{ + { LBMC_UMQ_REG_CTX_TYPE, "Context" }, + { LBMC_UMQ_REG_SRC_TYPE, "Source" }, + { LBMC_UMQ_REG_RCV_TYPE, "Receiver" }, + { LBMC_UMQ_REG_RCV_DEREG_TYPE, "Receiver deregistration" }, + { LBMC_UMQ_REG_ULB_RCV_TYPE, "ULB Receiver" }, + { LBMC_UMQ_REG_ULB_RCV_DEREG_TYPE, "ULB Receiver deregistration" }, + { LBMC_UMQ_REG_OBSERVER_RCV_TYPE, "Observer receiver registration" }, + { LBMC_UMQ_REG_OBSERVER_RCV_DEREG_TYPE, "Observer receiver deregistration" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_reg_response_type[] = +{ + { LBMC_UMQ_REG_RESP_CTX_TYPE, "Context" }, + { LBMC_UMQ_REG_RESP_SRC_TYPE, "Source" }, + { LBMC_UMQ_REG_RESP_RCV_TYPE, "Receiver" }, + { LBMC_UMQ_REG_RESP_RCV_DEREG_TYPE, "Receiver deregistration" }, + { LBMC_UMQ_REG_RESP_ERR_TYPE, "Error" }, + { LBMC_UMQ_REG_RESP_ULB_RCV_TYPE, "ULB Receiver" }, + { LBMC_UMQ_REG_RESP_ULB_RCV_DEREG_TYPE, "ULB Receiver deregistration" }, + { LBMC_UMQ_REG_RESP_OBSERVER_RCV_TYPE, "Observer receiver registration" }, + { LBMC_UMQ_REG_RESP_OBSERVER_RCV_DEREG_TYPE, "Observer receiver deregistration" }, + { LBMC_UMQ_REG_RESP_CTX_EX_TYPE, "Extended context registration" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_ack_type[] = +{ + { LBMC_UMQ_ACK_STABLE_TYPE, "Stable" }, + { LBMC_UMQ_ACK_CR_TYPE, "CR" }, + { LBMC_UMQ_ACK_ULB_CR_TYPE, "ULB CR" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_ka_type[] = +{ + { LBMC_UMQ_KA_CTX_TYPE, "Context" }, + { LBMC_UMQ_KA_SRC_TYPE, "Source" }, + { LBMC_UMQ_KA_RCV_TYPE, "Receiver" }, + { LBMC_UMQ_KA_ULB_RCV_TYPE, "ULB Receiver" }, + { LBMC_UMQ_KA_CTX_RESP_TYPE, "Context response" }, + { LBMC_UMQ_KA_SRC_RESP_TYPE, "Source response" }, + { LBMC_UMQ_KA_RCV_RESP_TYPE, "Receiver response" }, + { LBMC_UMQ_KA_ULB_RCV_RESP_TYPE, "ULB Receiver response" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_rxreq_type[] = +{ + { LBMC_UMQ_RXREQ_MR_TYPE, "MR" }, + { LBMC_UMQ_RXREQ_QRCRR_TYPE, "QRCRR" }, + { LBMC_UMQ_RXREQ_TRCRR_TYPE, "TRCRR" }, + { LBMC_UMQ_RXREQ_ULB_MR_TYPE, "ULB MR" }, + { LBMC_UMQ_RXREQ_ULB_MR_ABORT_TYPE, "ULB MR Abort" }, + { LBMC_UMQ_RXREQ_ULB_TRCRR_TYPE, "ULB TRCRR" }, + { LBMC_UMQ_RXREQ_ULB_TRCRR_ABORT_TYPE, "ULB TRCRR Abort" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_resub_response_code[] = +{ + { LBMC_UMQ_RESUB_RESP_ENQUEUED_CODE, "Enqueued" }, + { LBMC_UMQ_RESUB_RESP_CONSUMED_CODE, "Consumed" }, + { LBMC_UMQ_RESUB_RESP_OUTSTANDING_CODE, "Outstanding" }, + { LBMC_UMQ_RESUB_RESP_RESUBALLOWED_CODE, "Resubmission allowed" }, + { LBMC_UMQ_RESUB_RESP_RESUBDONE_CODE, "Resubmission done" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_lf_type[] = +{ + { LBMC_UMQ_LF_SRC_TYPE, "Source" }, + { LBMC_UMQ_LF_RCV_TYPE, "Receiver" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_index_cmd_type[] = +{ + { LBMC_UMQ_IDX_CMD_RCV_STOP_IDX_ASSIGN_TYPE, "Stop receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RCV_START_IDX_ASSIGN_TYPE, "Start receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_ULB_RCV_STOP_IDX_ASSIGN_TYPE, "Stop ULB receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_ULB_RCV_START_IDX_ASSIGN_TYPE, "Start ULB receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_TYPE, "Release receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_ULB_RCV_RELEASE_IDX_ASSIGN_TYPE, "Release ULB receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_TYPE, "Reserve receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_ULB_RCV_RESERVE_IDX_ASSIGN_TYPE, "Reserve ULB receiver index assignment" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_index_cmd_response_type[] = +{ + { LBMC_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_TYPE, "Stop receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_TYPE, "Start receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_TYPE, "Stop ULB receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_TYPE, "Start ULB receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_TYPE, "Release receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_TYPE, "Release ULB receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_TYPE, "Reserve receiver index assignment" }, + { LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_TYPE, "Reserve ULB receiver index assignment" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_index_cmd_response_error_type[] = +{ + { LBMC_UMQ_IDX_CMD_RESP_ERR_TYPE, "Error" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_cmd_type[] = +{ + { LBMC_UMQ_CMD_TYPE_TOPIC_LIST, "Topic list" }, + { LBMC_UMQ_CMD_TYPE_RCV_MSG_RETRIEVE, "Retrieve message" }, + { LBMC_UMQ_CMD_TYPE_RCV_MSG_LIST, "List message" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_cmd_response_type[] = +{ + { LBMC_UMQ_CMD_RESP_TYPE_CTX_TOPIC_LIST, "Topic list" }, + { LBMC_UMQ_CMD_RESP_TYPE_RCV_MSG_RETRIEVE, "Retrieve message" }, + { LBMC_UMQ_CMD_RESP_TYPE_RCV_MSG_LIST, "List message" }, + { LBMC_UMQ_CMD_RESP_TYPE_ERROR, "Error" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_cmd_response_error_code[] = +{ + { LBMC_UMQ_CMD_RESP_ERROR_AUTHFAIL, "Authentication failed" }, + { LBMC_UMQ_CMD_RESP_ERROR_NOHMAC, "HMAC failed" }, + { LBMC_UMQ_CMD_RESP_ERROR_NOAUTHOR, "Not authorized" }, + { 0x0, NULL } +}; + +static const value_string lbmc_auth_operation_id_type[] = +{ + { AUTH_OP_REQ, "Request" }, + { AUTH_OP_CHALLENGE, "Challenge" }, + { AUTH_OP_CHALLENGE_RSP, "Challenge response" }, + { AUTH_OP_RESULT, "Result" }, + { 0x0, NULL } +}; + +static const value_string lbmc_extopt_subtype[] = +{ + { LBMC_EXT_NHDR_CFGOPT, "Configuration option" }, + { LBMC_EXT_NHDR_MSGSEL, "Message selector" }, + { 0x0, NULL } +}; + +static const value_string lbm_msg_prop_header_type[] = +{ + { LBM_MSG_PROPERTIES_TYPE_NORMAL, "Normal" }, + { 0x0, NULL } +}; + +static const value_string lbm_msg_prop_magic_type[] = +{ + { LBM_MSG_PROPERTIES_MAGIC, "MAGIC" }, + { LBM_MSG_PROPERTIES_ANTIMAGIC, "ANTI-MAGIC" }, + { 0x0, NULL } +}; + +static const value_string lbm_msg_prop_field_type[] = +{ + { LBM_MSG_PROPERTY_NONE, "None" }, + { LBM_MSG_PROPERTY_BOOLEAN, "Boolean" }, + { LBM_MSG_PROPERTY_BYTE, "Byte" }, + { LBM_MSG_PROPERTY_SHORT, "Short" }, + { LBM_MSG_PROPERTY_INT, "Integer" }, + { LBM_MSG_PROPERTY_LONG, "Long" }, + { LBM_MSG_PROPERTY_FLOAT, "Float" }, + { LBM_MSG_PROPERTY_DOUBLE, "Double" }, + { LBM_MSG_PROPERTY_STRING, "String" }, + { 0x0, NULL } +}; + +static const value_string lbmc_umq_msg_status_code[] = +{ + { LBM_UMQ_QUEUE_MSG_STATUS_UNKNOWN, "Unknown" }, + { LBM_UMQ_QUEUE_MSG_STATUS_UNASSIGNED, "Unassigned" }, + { LBM_UMQ_QUEUE_MSG_STATUS_ASSIGNED, "Assigned" }, + { LBM_UMQ_QUEUE_MSG_STATUS_REASSIGNING, "Reassigning" }, + { LBM_UMQ_QUEUE_MSG_STATUS_CONSUMED, "Consumed" }, + { LBM_UMQ_QUEUE_MSG_STATUS_COMPLETE, "Complete" }, + { 0x0, NULL } +}; + +static const value_string lbmc_extopt_config_option_scope[] = +{ + { LBMC_CNTL_CONFIG_OPT_SCOPE_SOURCE, "Source" }, + { LBMC_CNTL_CONFIG_OPT_SCOPE_RECEIVER, "Receiver" }, + { LBMC_CNTL_CONFIG_OPT_SCOPE_CONTEXT, "Context" }, + { LBMC_CNTL_CONFIG_OPT_SCOPE_WILDCARD_RECEIVER, "Wildcard receiver" }, + { LBMC_CNTL_CONFIG_OPT_SCOPE_EVENT_QUEUE, "Event queue" }, + { LBMC_CNTL_CONFIG_OPT_SCOPE_CONNECTION_FACTORY, "Connection factory" }, + { LBMC_CNTL_CONFIG_OPT_SCOPE_DESTINATION, "Destination" }, + { LBMC_CNTL_CONFIG_OPT_SCOPE_HFX, "HFX" }, + { 0x0, NULL } +}; + +static const true_false_string lbmc_umq_r_flag = +{ + "Queue requests a response", + "No response requested" +}; + +/*----------------------------------------------------------------------------*/ +/* Preferences. */ +/*----------------------------------------------------------------------------*/ + +static gboolean lbmc_use_heuristic_subdissectors = TRUE; +static gboolean lbmc_reassemble_fragments = FALSE; +static gboolean lbmc_dissect_lbmpdm = FALSE; +static heur_dissector_list_t lbmc_heuristic_subdissector_list; +static dissector_handle_t lbmc_data_dissector_handle; + +/*----------------------------------------------------------------------------*/ +/* Handles of all types. */ +/*----------------------------------------------------------------------------*/ + +static int proto_lbmc = -1; +static int tnw_protocol_handle = -1; +static int lbmc_uim_tap_handle = -1; +static int lbmc_stream_tap_handle = -1; +static int hf_lbmc_tag = -1; +static int hf_lbmc_topic = -1; +static int hf_lbmc_ver_type = -1; +static int hf_lbmc_ver_type_version = -1; +static int hf_lbmc_ver_type_type = -1; +static int hf_lbmc_next_hdr = -1; +static int hf_lbmc_msglen = -1; +static int hf_lbmc_tidx = -1; +static int hf_lbmc_sqn = -1; +static int hf_lbmc_frag = -1; +static int hf_lbmc_frag_next_hdr = -1; +static int hf_lbmc_frag_hdr_len = -1; +static int hf_lbmc_frag_flags = -1; +static int hf_lbmc_frag_flags_ignore = -1; +static int hf_lbmc_frag_first_sqn = -1; +static int hf_lbmc_frag_offset = -1; +static int hf_lbmc_frag_len = -1; +static int hf_lbmc_batch = -1; +static int hf_lbmc_batch_next_hdr = -1; +static int hf_lbmc_batch_hdr_len = -1; +static int hf_lbmc_batch_flags = -1; +static int hf_lbmc_batch_flags_ignore = -1; +static int hf_lbmc_batch_flags_batch_start = -1; +static int hf_lbmc_batch_flags_batch_end = -1; +static int hf_lbmc_tcp_request = -1; +static int hf_lbmc_tcp_request_next_hdr = -1; +static int hf_lbmc_tcp_request_hdr_len = -1; +static int hf_lbmc_tcp_request_flags = -1; +static int hf_lbmc_tcp_request_flags_ignore = -1; +static int hf_lbmc_tcp_request_transport = -1; +static int hf_lbmc_tcp_request_qidx = -1; +static int hf_lbmc_tcp_request_port = -1; +static int hf_lbmc_tcp_request_reserved = -1; +static int hf_lbmc_tcp_request_ipaddr = -1; +static int hf_lbmc_topicname = -1; +static int hf_lbmc_topicname_next_hdr = -1; +static int hf_lbmc_topicname_hdr_len = -1; +static int hf_lbmc_topicname_flags = -1; +static int hf_lbmc_topicname_flags_ignore = -1; +static int hf_lbmc_topicname_topicname = -1; +static int hf_lbmc_apphdr = -1; +static int hf_lbmc_apphdr_next_hdr = -1; +static int hf_lbmc_apphdr_hdr_len = -1; +static int hf_lbmc_apphdr_code = -1; +static int hf_lbmc_apphdr_code_ignore = -1; +static int hf_lbmc_apphdr_code_code = -1; +static int hf_lbmc_apphdr_data = -1; +static int hf_lbmc_apphdr_chain = -1; +static int hf_lbmc_apphdr_chain_next_hdr = -1; +static int hf_lbmc_apphdr_chain_hdr_len = -1; +static int hf_lbmc_apphdr_chain_res = -1; +static int hf_lbmc_apphdr_chain_first_chain_hdr = -1; +static int hf_lbmc_apphdr_chain_element = -1; +static int hf_lbmc_apphdr_chain_element_next_hdr = -1; +static int hf_lbmc_apphdr_chain_element_hdr_len = -1; +static int hf_lbmc_apphdr_chain_element_res = -1; +static int hf_lbmc_apphdr_chain_element_data = -1; +static int hf_lbmc_apphdr_chain_msgprop = -1; +static int hf_lbmc_apphdr_chain_msgprop_next_hdr = -1; +static int hf_lbmc_apphdr_chain_msgprop_hdr_len = -1; +static int hf_lbmc_apphdr_chain_msgprop_res = -1; +static int hf_lbmc_apphdr_chain_msgprop_len = -1; +static int hf_lbmc_umq_msgid = -1; +static int hf_lbmc_umq_msgid_next_hdr = -1; +static int hf_lbmc_umq_msgid_hdr_len = -1; +static int hf_lbmc_umq_msgid_flags = -1; +static int hf_lbmc_umq_msgid_flags_ignore = -1; +static int hf_lbmc_umq_msgid_msgid_regid = -1; +static int hf_lbmc_umq_msgid_msgid_stamp = -1; +static int hf_lbmc_umq_sqd_rcv = -1; +static int hf_lbmc_umq_sqd_rcv_next_hdr = -1; +static int hf_lbmc_umq_sqd_rcv_hdr_len = -1; +static int hf_lbmc_umq_sqd_rcv_flags = -1; +static int hf_lbmc_umq_sqd_rcv_flags_ignore = -1; +static int hf_lbmc_umq_sqd_rcv_flags_r_flag = -1; +static int hf_lbmc_umq_sqd_rcv_flags_s_flag = -1; +static int hf_lbmc_umq_sqd_rcv_flags_re_flag = -1; +static int hf_lbmc_umq_sqd_rcv_flags_eoi_flag = -1; +static int hf_lbmc_umq_sqd_rcv_flags_boi_flag = -1; +static int hf_lbmc_umq_sqd_rcv_queue_id = -1; +static int hf_lbmc_umq_sqd_rcv_queue_ver = -1; +static int hf_lbmc_umq_sqd_rcv_rcr_idx = -1; +static int hf_lbmc_umq_sqd_rcv_assign_id = -1; +static int hf_lbmc_umq_resub = -1; +static int hf_lbmc_umq_resub_next_hdr = -1; +static int hf_lbmc_umq_resub_hdr_len = -1; +static int hf_lbmc_umq_resub_flags = -1; +static int hf_lbmc_umq_resub_flags_ignore = -1; +static int hf_lbmc_umq_resub_flags_q_flag = -1; +static int hf_lbmc_umq_resub_rcr_idx = -1; +static int hf_lbmc_umq_resub_resp_ip = -1; +static int hf_lbmc_umq_resub_resp_port = -1; +static int hf_lbmc_umq_resub_appset_idx = -1; +static int hf_lbmc_otid = -1; +static int hf_lbmc_otid_next_hdr = -1; +static int hf_lbmc_otid_hdr_len = -1; +static int hf_lbmc_otid_flags = -1; +static int hf_lbmc_otid_flags_ignore = -1; +static int hf_lbmc_otid_otid = -1; +static int hf_lbmc_ctxinst = -1; +static int hf_lbmc_ctxinst_next_hdr = -1; +static int hf_lbmc_ctxinst_hdr_len = -1; +static int hf_lbmc_ctxinst_flags = -1; +static int hf_lbmc_ctxinst_flags_ignore = -1; +static int hf_lbmc_ctxinst_ctxinst = -1; +static int hf_lbmc_ctxinstd = -1; +static int hf_lbmc_ctxinstr = -1; +static int hf_lbmc_srcidx = -1; +static int hf_lbmc_srcidx_next_hdr = -1; +static int hf_lbmc_srcidx_hdr_len = -1; +static int hf_lbmc_srcidx_flags = -1; +static int hf_lbmc_srcidx_flags_ignore = -1; +static int hf_lbmc_srcidx_srcidx = -1; +static int hf_lbmc_umq_ulb_msg = -1; +static int hf_lbmc_umq_ulb_msg_next_hdr = -1; +static int hf_lbmc_umq_ulb_msg_hdr_len = -1; +static int hf_lbmc_umq_ulb_msg_flags = -1; +static int hf_lbmc_umq_ulb_msg_flags_ignore = -1; +static int hf_lbmc_umq_ulb_msg_flags_a_flag = -1; +static int hf_lbmc_umq_ulb_msg_flags_r_flag = -1; +static int hf_lbmc_umq_ulb_msg_queue_id = -1; +static int hf_lbmc_umq_ulb_msg_ulb_src_id = -1; +static int hf_lbmc_umq_ulb_msg_assign_id = -1; +static int hf_lbmc_umq_ulb_msg_appset_idx = -1; +static int hf_lbmc_umq_ulb_msg_num_ras = -1; +static int hf_lbmc_ssf_init = -1; +static int hf_lbmc_ssf_init_next_hdr = -1; +static int hf_lbmc_ssf_init_hdr_len = -1; +static int hf_lbmc_ssf_init_transport = -1; +static int hf_lbmc_ssf_init_flags = -1; +static int hf_lbmc_ssf_init_flags_ignore = -1; +static int hf_lbmc_ssf_init_flags_default_inclusions = -1; +static int hf_lbmc_ssf_init_flags_default_exclusions = -1; +static int hf_lbmc_ssf_init_transport_idx = -1; +static int hf_lbmc_ssf_init_client_idx = -1; +static int hf_lbmc_ssf_init_ssf_port = -1; +static int hf_lbmc_ssf_init_res = -1; +static int hf_lbmc_ssf_init_ssf_ip = -1; +static int hf_lbmc_ssf_creq = -1; +static int hf_lbmc_ssf_creq_next_hdr = -1; +static int hf_lbmc_ssf_creq_hdr_len = -1; +static int hf_lbmc_ssf_creq_flags = -1; +static int hf_lbmc_ssf_creq_flags_ignore = -1; +static int hf_lbmc_ssf_creq_mode = -1; +static int hf_lbmc_ssf_creq_transport_idx = -1; +static int hf_lbmc_ssf_creq_topic_idx = -1; +static int hf_lbmc_ssf_creq_client_idx = -1; +static int hf_lbmc_ume_preg = -1; +static int hf_lbmc_ume_preg_next_hdr = -1; +static int hf_lbmc_ume_preg_hdr_len = -1; +static int hf_lbmc_ume_preg_flags = -1; +static int hf_lbmc_ume_preg_flags_ignore = -1; +static int hf_lbmc_ume_preg_flags_f_flag = -1; +static int hf_lbmc_ume_preg_flags_p_flag = -1; +static int hf_lbmc_ume_preg_flags_w_flag = -1; +static int hf_lbmc_ume_preg_flags_d_flag = -1; +static int hf_lbmc_ume_preg_marker = -1; +static int hf_lbmc_ume_preg_marker_s_flag = -1; +static int hf_lbmc_ume_preg_marker_marker = -1; +static int hf_lbmc_ume_preg_reg_id = -1; +static int hf_lbmc_ume_preg_transport_idx = -1; +static int hf_lbmc_ume_preg_topic_idx = -1; +static int hf_lbmc_ume_preg_src_reg_id = -1; +static int hf_lbmc_ume_preg_resp_port = -1; +static int hf_lbmc_ume_preg_res2 = -1; +static int hf_lbmc_ume_preg_resp_ip = -1; +static int hf_lbmc_ume_preg_resp = -1; +static int hf_lbmc_ume_preg_resp_next_hdr = -1; +static int hf_lbmc_ume_preg_resp_hdr_len = -1; +static int hf_lbmc_ume_preg_resp_code = -1; +static int hf_lbmc_ume_preg_resp_code_ignore = -1; +static int hf_lbmc_ume_preg_resp_code_e_flag = -1; +static int hf_lbmc_ume_preg_resp_code_o_flag = -1; +static int hf_lbmc_ume_preg_resp_code_n_flag = -1; +static int hf_lbmc_ume_preg_resp_code_w_flag = -1; +static int hf_lbmc_ume_preg_resp_code_d_flag = -1; +static int hf_lbmc_ume_preg_resp_code_code = -1; +static int hf_lbmc_ume_preg_resp_marker = -1; +static int hf_lbmc_ume_preg_resp_marker_s_flag = -1; +static int hf_lbmc_ume_preg_resp_marker_marker = -1; +static int hf_lbmc_ume_preg_resp_reg_id = -1; +static int hf_lbmc_ume_preg_resp_transport_idx = -1; +static int hf_lbmc_ume_preg_resp_topic_idx = -1; +static int hf_lbmc_ume_preg_resp_low_seqnum = -1; +static int hf_lbmc_ume_preg_resp_high_seqnum = -1; +static int hf_lbmc_ume_ack = -1; +static int hf_lbmc_ume_ack_next_hdr = -1; +static int hf_lbmc_ume_ack_hdr_len = -1; +static int hf_lbmc_ume_ack_flags = -1; +static int hf_lbmc_ume_ack_flags_ignore = -1; +static int hf_lbmc_ume_ack_flags_o_flag = -1; +static int hf_lbmc_ume_ack_flags_f_flag = -1; +static int hf_lbmc_ume_ack_flags_u_flag = -1; +static int hf_lbmc_ume_ack_flags_e_flag = -1; +static int hf_lbmc_ume_ack_type = -1; +static int hf_lbmc_ume_ack_transport_idx = -1; +static int hf_lbmc_ume_ack_id_2 = -1; +static int hf_lbmc_ume_ack_rcv_reg_id = -1; +static int hf_lbmc_ume_ack_seqnum = -1; +static int hf_lbmc_ume_rxreq = -1; +static int hf_lbmc_ume_rxreq_next_hdr = -1; +static int hf_lbmc_ume_rxreq_hdr_len = -1; +static int hf_lbmc_ume_rxreq_flags = -1; +static int hf_lbmc_ume_rxreq_flags_ignore = -1; +static int hf_lbmc_ume_rxreq_flags_tsni_req = -1; +static int hf_lbmc_ume_rxreq_request_idx = -1; +static int hf_lbmc_ume_rxreq_transport_idx = -1; +static int hf_lbmc_ume_rxreq_id_2 = -1; +static int hf_lbmc_ume_rxreq_seqnum = -1; +static int hf_lbmc_ume_rxreq_rx_port = -1; +static int hf_lbmc_ume_rxreq_res = -1; +static int hf_lbmc_ume_rxreq_rx_ip = -1; +static int hf_lbmc_ume_keepalive = -1; +static int hf_lbmc_ume_keepalive_next_hdr = -1; +static int hf_lbmc_ume_keepalive_hdr_len = -1; +static int hf_lbmc_ume_keepalive_flags = -1; +static int hf_lbmc_ume_keepalive_flags_ignore = -1; +static int hf_lbmc_ume_keepalive_flags_r_flag = -1; +static int hf_lbmc_ume_keepalive_flags_t_flag = -1; +static int hf_lbmc_ume_keepalive_type = -1; +static int hf_lbmc_ume_keepalive_transport_idx = -1; +static int hf_lbmc_ume_keepalive_topic_idx = -1; +static int hf_lbmc_ume_keepalive_reg_id = -1; +static int hf_lbmc_ume_storeid = -1; +static int hf_lbmc_ume_storeid_next_hdr = -1; +static int hf_lbmc_ume_storeid_hdr_len = -1; +static int hf_lbmc_ume_storeid_store_id = -1; +static int hf_lbmc_ume_storeid_store_id_ignore = -1; +static int hf_lbmc_ume_storeid_store_id_store_id = -1; +static int hf_lbmc_ume_ranged_ack = -1; +static int hf_lbmc_ume_ranged_ack_next_hdr = -1; +static int hf_lbmc_ume_ranged_ack_hdr_len = -1; +static int hf_lbmc_ume_ranged_ack_flags = -1; +static int hf_lbmc_ume_ranged_ack_flags_ignore = -1; +static int hf_lbmc_ume_ranged_ack_first_seqnum = -1; +static int hf_lbmc_ume_ranged_ack_last_seqnum = -1; +static int hf_lbmc_ume_ack_id = -1; +static int hf_lbmc_ume_ack_id_next_hdr = -1; +static int hf_lbmc_ume_ack_id_hdr_len = -1; +static int hf_lbmc_ume_ack_id_flags = -1; +static int hf_lbmc_ume_ack_id_flags_ignore = -1; +static int hf_lbmc_ume_ack_id_id = -1; +static int hf_lbmc_ume_capability = -1; +static int hf_lbmc_ume_capability_next_hdr = -1; +static int hf_lbmc_ume_capability_hdr_len = -1; +static int hf_lbmc_ume_capability_flags = -1; +static int hf_lbmc_ume_capability_flags_ignore = -1; +static int hf_lbmc_ume_capability_flags_qc_flag = -1; +static int hf_lbmc_ume_capability_flags_client_lifetime_flag = -1; +static int hf_lbmc_ume_proxy_src = -1; +static int hf_lbmc_ume_proxy_src_next_hdr = -1; +static int hf_lbmc_ume_proxy_src_hdr_len = -1; +static int hf_lbmc_ume_proxy_src_flags = -1; +static int hf_lbmc_ume_proxy_src_flags_ignore = -1; +static int hf_lbmc_ume_proxy_src_flags_enable = -1; +static int hf_lbmc_ume_proxy_src_flags_compatibility = -1; +static int hf_lbmc_ume_store_group = -1; +static int hf_lbmc_ume_store_group_next_hdr = -1; +static int hf_lbmc_ume_store_group_hdr_len = -1; +static int hf_lbmc_ume_store_group_flags = -1; +static int hf_lbmc_ume_store_group_flags_ignore = -1; +static int hf_lbmc_ume_store_group_grp_idx = -1; +static int hf_lbmc_ume_store_group_grp_sz = -1; +static int hf_lbmc_ume_store_group_res1 = -1; +static int hf_lbmc_ume_store = -1; +static int hf_lbmc_ume_store_next_hdr = -1; +static int hf_lbmc_ume_store_hdr_len = -1; +static int hf_lbmc_ume_store_flags = -1; +static int hf_lbmc_ume_store_flags_ignore = -1; +static int hf_lbmc_ume_store_grp_idx = -1; +static int hf_lbmc_ume_store_store_tcp_port = -1; +static int hf_lbmc_ume_store_store_idx = -1; +static int hf_lbmc_ume_store_store_ip_addr = -1; +static int hf_lbmc_ume_store_src_reg_id = -1; +static int hf_lbmc_ume_lj_info = -1; +static int hf_lbmc_ume_lj_info_next_hdr = -1; +static int hf_lbmc_ume_lj_info_hdr_len = -1; +static int hf_lbmc_ume_lj_info_flags = -1; +static int hf_lbmc_ume_lj_info_flags_ignore = -1; +static int hf_lbmc_ume_lj_info_low_seqnum = -1; +static int hf_lbmc_ume_lj_info_high_seqnum = -1; +static int hf_lbmc_ume_lj_info_qidx = -1; +static int hf_lbmc_tsni = -1; +static int hf_lbmc_tsni_next_hdr = -1; +static int hf_lbmc_tsni_hdr_len = -1; +static int hf_lbmc_tsni_num_recs = -1; +static int hf_lbmc_tsni_num_recs_ignore = -1; +static int hf_lbmc_tsni_num_recs_num_recs = -1; +static int hf_lbmc_tsni_rec = -1; +static int hf_lbmc_tsni_rec_tidx = -1; +static int hf_lbmc_tsni_rec_sqn = -1; +static int hf_lbmc_umq_reg = -1; +static int hf_lbmc_umq_reg_next_hdr = -1; +static int hf_lbmc_umq_reg_hdr_len = -1; +static int hf_lbmc_umq_reg_flags = -1; +static int hf_lbmc_umq_reg_flags_ignore = -1; +static int hf_lbmc_umq_reg_flags_r_flag = -1; +static int hf_lbmc_umq_reg_flags_t_flag = -1; +static int hf_lbmc_umq_reg_flags_i_flag = -1; +static int hf_lbmc_umq_reg_flags_msg_sel_flag = -1; +static int hf_lbmc_umq_reg_reg_type = -1; +static int hf_lbmc_umq_reg_queue_id = -1; +static int hf_lbmc_umq_reg_cmd_id = -1; +static int hf_lbmc_umq_reg_inst_idx = -1; +static int hf_lbmc_umq_reg_regid = -1; +static int hf_lbmc_umq_reg_reg_ctx = -1; +static int hf_lbmc_umq_reg_reg_ctx_port = -1; +static int hf_lbmc_umq_reg_reg_ctx_reserved = -1; +static int hf_lbmc_umq_reg_reg_ctx_ip = -1; +static int hf_lbmc_umq_reg_reg_ctx_capabilities = -1; +static int hf_lbmc_umq_reg_reg_src = -1; +static int hf_lbmc_umq_reg_reg_src_transport_idx = -1; +static int hf_lbmc_umq_reg_reg_src_topic_idx = -1; +static int hf_lbmc_umq_reg_reg_rcv = -1; +static int hf_lbmc_umq_reg_reg_rcv_assign_id = -1; +static int hf_lbmc_umq_reg_reg_rcv_rcv_type_id = -1; +static int hf_lbmc_umq_reg_reg_rcv_last_topic_rcr_tsp = -1; +static int hf_lbmc_umq_reg_rcv_dereg = -1; +static int hf_lbmc_umq_reg_rcv_dereg_rcr_idx = -1; +static int hf_lbmc_umq_reg_rcv_dereg_assign_id = -1; +static int hf_lbmc_umq_reg_reg_ulb_rcv = -1; +static int hf_lbmc_umq_reg_reg_ulb_rcv_ulb_src_id = -1; +static int hf_lbmc_umq_reg_reg_ulb_rcv_assign_id = -1; +static int hf_lbmc_umq_reg_reg_ulb_rcv_rcv_type_id = -1; +static int hf_lbmc_umq_reg_reg_ulb_rcv_port = -1; +static int hf_lbmc_umq_reg_reg_ulb_rcv_reserved = -1; +static int hf_lbmc_umq_reg_reg_ulb_rcv_ip = -1; +static int hf_lbmc_umq_reg_reg_ulb_rcv_capabilities = -1; +static int hf_lbmc_umq_reg_ulb_rcv_dereg = -1; +static int hf_lbmc_umq_reg_ulb_rcv_dereg_ulb_src_id = -1; +static int hf_lbmc_umq_reg_ulb_rcv_dereg_assign_id = -1; +static int hf_lbmc_umq_reg_reg_observer_rcv = -1; +static int hf_lbmc_umq_reg_reg_observer_rcv_assign_id = -1; +static int hf_lbmc_umq_reg_reg_observer_rcv_rcv_type_id = -1; +static int hf_lbmc_umq_reg_reg_observer_rcv_last_topic_rcr_tsp = -1; +static int hf_lbmc_umq_reg_observer_rcv_dereg = -1; +static int hf_lbmc_umq_reg_observer_rcv_dereg_rcr_idx = -1; +static int hf_lbmc_umq_reg_observer_rcv_dereg_assign_id = -1; +static int hf_lbmc_umq_reg_resp = -1; +static int hf_lbmc_umq_reg_resp_next_hdr = -1; +static int hf_lbmc_umq_reg_resp_hdr_len = -1; +static int hf_lbmc_umq_reg_resp_flags = -1; +static int hf_lbmc_umq_reg_resp_flags_ignore = -1; +static int hf_lbmc_umq_reg_resp_flags_r_flag = -1; +static int hf_lbmc_umq_reg_resp_flags_l_flag = -1; +static int hf_lbmc_umq_reg_resp_flags_src_s_flag = -1; +static int hf_lbmc_umq_reg_resp_flags_src_d_flag = -1; +static int hf_lbmc_umq_reg_resp_resp_type = -1; +static int hf_lbmc_umq_reg_resp_queue_id = -1; +static int hf_lbmc_umq_reg_resp_cmd_id = -1; +static int hf_lbmc_umq_reg_resp_inst_idx = -1; +static int hf_lbmc_umq_reg_resp_regid = -1; +static int hf_lbmc_umq_reg_resp_reg_ctx = -1; +static int hf_lbmc_umq_reg_resp_reg_ctx_capabilities = -1; +static int hf_lbmc_umq_reg_resp_reg_ctx_ex = -1; +static int hf_lbmc_umq_reg_resp_reg_ctx_ex_capabilities = -1; +static int hf_lbmc_umq_reg_resp_reg_ctx_ex_reserved = -1; +static int hf_lbmc_umq_reg_resp_reg_ctx_ex_flags = -1; +static int hf_lbmc_umq_reg_resp_reg_ctx_ex_flags_firstmsg = -1; +static int hf_lbmc_umq_reg_resp_reg_ctx_ex_stamp = -1; +static int hf_lbmc_umq_reg_resp_err = -1; +static int hf_lbmc_umq_reg_resp_err_reserved = -1; +static int hf_lbmc_umq_reg_resp_err_code = -1; +static int hf_lbmc_umq_reg_resp_reg_src = -1; +static int hf_lbmc_umq_reg_resp_reg_src_rcr_idx = -1; +static int hf_lbmc_umq_reg_resp_reg_rcv = -1; +static int hf_lbmc_umq_reg_resp_reg_rcv_rcr_idx = -1; +static int hf_lbmc_umq_reg_resp_reg_rcv_assign_id = -1; +static int hf_lbmc_umq_reg_resp_reg_rcv_appset_idx = -1; +static int hf_lbmc_umq_reg_resp_reg_rcv_reserved = -1; +static int hf_lbmc_umq_reg_resp_rcv_dereg = -1; +static int hf_lbmc_umq_reg_resp_rcv_dereg_rcr_idx = -1; +static int hf_lbmc_umq_reg_resp_rcv_dereg_assign_id = -1; +static int hf_lbmc_umq_reg_resp_reg_ulb_rcv = -1; +static int hf_lbmc_umq_reg_resp_reg_ulb_rcv_ulb_src_id = -1; +static int hf_lbmc_umq_reg_resp_reg_ulb_rcv_assign_id = -1; +static int hf_lbmc_umq_reg_resp_reg_ulb_rcv_appset_idx = -1; +static int hf_lbmc_umq_reg_resp_reg_ulb_rcv_reserved = -1; +static int hf_lbmc_umq_reg_resp_reg_ulb_rcv_capabilities = -1; +static int hf_lbmc_umq_reg_resp_ulb_rcv_dereg = -1; +static int hf_lbmc_umq_reg_resp_ulb_rcv_dereg_ulb_src_id = -1; +static int hf_lbmc_umq_reg_resp_ulb_rcv_dereg_assign_id = -1; +static int hf_lbmc_umq_reg_resp_reg_observer_rcv = -1; +static int hf_lbmc_umq_reg_resp_reg_observer_rcv_rcr_idx = -1; +static int hf_lbmc_umq_reg_resp_reg_observer_rcv_assign_id = -1; +static int hf_lbmc_umq_reg_resp_reg_observer_rcv_appset_idx = -1; +static int hf_lbmc_umq_reg_resp_reg_observer_rcv_reserved = -1; +static int hf_lbmc_umq_reg_resp_observer_rcv_dereg = -1; +static int hf_lbmc_umq_reg_resp_observer_rcv_dereg_rcr_idx = -1; +static int hf_lbmc_umq_reg_resp_observer_rcv_dereg_assign_id = -1; +static int hf_lbmc_umq_ack = -1; +static int hf_lbmc_umq_ack_next_hdr = -1; +static int hf_lbmc_umq_ack_hdr_len = -1; +static int hf_lbmc_umq_ack_msgs = -1; +static int hf_lbmc_umq_ack_msgs_ignore = -1; +static int hf_lbmc_umq_ack_msgs_t_flag = -1; +static int hf_lbmc_umq_ack_msgs_d_flag = -1; +static int hf_lbmc_umq_ack_msgs_numids = -1; +static int hf_lbmc_umq_ack_ack_type = -1; +static int hf_lbmc_umq_ack_msgid = -1; +static int hf_lbmc_umq_ack_msgid_regid = -1; +static int hf_lbmc_umq_ack_msgid_stamp = -1; +static int hf_lbmc_umq_ack_stable = -1; +static int hf_lbmc_umq_ack_stable_queue_id = -1; +static int hf_lbmc_umq_ack_stable_inst_idx = -1; +static int hf_lbmc_umq_ack_stable_reserved = -1; +static int hf_lbmc_umq_ack_cr = -1; +static int hf_lbmc_umq_ack_cr_rcr_idx = -1; +static int hf_lbmc_umq_ack_cr_assign_id = -1; +static int hf_lbmc_umq_ack_cr_appset_idx = -1; +static int hf_lbmc_umq_ack_cr_reserved = -1; +static int hf_lbmc_umq_ack_ulb_cr = -1; +static int hf_lbmc_umq_ack_ulb_cr_ulb_src_id = -1; +static int hf_lbmc_umq_ack_ulb_cr_assign_id = -1; +static int hf_lbmc_umq_ack_ulb_cr_appset_idx = -1; +static int hf_lbmc_umq_ack_ulb_cr_reserved = -1; +static int hf_lbmc_umq_rcr = -1; +static int hf_lbmc_umq_rcr_next_hdr = -1; +static int hf_lbmc_umq_rcr_hdr_len = -1; +static int hf_lbmc_umq_rcr_flags = -1; +static int hf_lbmc_umq_rcr_flags_ignore = -1; +static int hf_lbmc_umq_rcr_flags_r_flag = -1; +static int hf_lbmc_umq_rcr_flags_d_flag = -1; +static int hf_lbmc_umq_rcr_flags_s_flag = -1; +static int hf_lbmc_umq_rcr_flags_eoi_flag = -1; +static int hf_lbmc_umq_rcr_flags_boi_flag = -1; +static int hf_lbmc_umq_rcr_queue_id = -1; +static int hf_lbmc_umq_rcr_rcr_idx = -1; +static int hf_lbmc_umq_rcr_msgid_regid = -1; +static int hf_lbmc_umq_rcr_msgid_stamp = -1; +static int hf_lbmc_umq_rcr_topic_tsp = -1; +static int hf_lbmc_umq_rcr_q_tsp = -1; +static int hf_lbmc_umq_rcr_assign_id = -1; +static int hf_lbmc_umq_rcr_appset_idx = -1; +static int hf_lbmc_umq_rcr_num_ras = -1; +static int hf_lbmc_umq_rcr_queue_ver = -1; +static int hf_lbmc_cntl_umq_ka = -1; +static int hf_lbmc_cntl_umq_ka_next_hdr = -1; +static int hf_lbmc_cntl_umq_ka_hdr_len = -1; +static int hf_lbmc_cntl_umq_ka_flags = -1; +static int hf_lbmc_cntl_umq_ka_flags_ignore = -1; +static int hf_lbmc_cntl_umq_ka_flags_r_flag = -1; +static int hf_lbmc_cntl_umq_ka_ka_type = -1; +static int hf_lbmc_cntl_umq_ka_queue_id = -1; +static int hf_lbmc_cntl_umq_ka_regid = -1; +static int hf_lbmc_cntl_umq_ka_inst_idx = -1; +static int hf_lbmc_cntl_umq_ka_reserved = -1; +static int hf_lbmc_umq_ka_src = -1; +static int hf_lbmc_umq_ka_src_transport_idx = -1; +static int hf_lbmc_umq_ka_src_topic_idx = -1; +static int hf_lbmc_umq_ka_rcv = -1; +static int hf_lbmc_umq_ka_rcv_rcr_idx = -1; +static int hf_lbmc_umq_ka_rcv_assign_id = -1; +static int hf_lbmc_umq_ka_ulb_rcv = -1; +static int hf_lbmc_umq_ka_ulb_rcv_ulb_src_id = -1; +static int hf_lbmc_umq_ka_ulb_rcv_assign_id = -1; +static int hf_lbmc_umq_ka_ulb_rcv_resp = -1; +static int hf_lbmc_umq_ka_ulb_rcv_resp_ulb_src_id = -1; +static int hf_lbmc_umq_ka_ulb_rcv_resp_assign_id = -1; +static int hf_lbmc_umq_ka_ulb_rcv_resp_appset_idx = -1; +static int hf_lbmc_umq_ka_ulb_rcv_resp_reserved = -1; +static int hf_lbmc_umq_rxreq = -1; +static int hf_lbmc_umq_rxreq_next_hdr = -1; +static int hf_lbmc_umq_rxreq_hdr_len = -1; +static int hf_lbmc_umq_rxreq_flags = -1; +static int hf_lbmc_umq_rxreq_flags_ignore = -1; +static int hf_lbmc_umq_rxreq_flags_r_flag = -1; +static int hf_lbmc_umq_rxreq_rxreq_type = -1; +static int hf_lbmc_umq_rxreq_regid_resp = -1; +static int hf_lbmc_umq_rxreq_regid_resp_regid = -1; +static int hf_lbmc_umq_rxreq_addr_resp = -1; +static int hf_lbmc_umq_rxreq_addr_resp_ip = -1; +static int hf_lbmc_umq_rxreq_addr_resp_port = -1; +static int hf_lbmc_umq_rxreq_addr_resp_reserved = -1; +static int hf_lbmc_umq_rxreq_mr = -1; +static int hf_lbmc_umq_rxreq_mr_assign_id = -1; +static int hf_lbmc_umq_rxreq_mr_msgid_regid = -1; +static int hf_lbmc_umq_rxreq_mr_msgid_stamp = -1; +static int hf_lbmc_umq_rxreq_ulb_mr = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_ulb_src_id = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_assign_id = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_appset_idx = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_reserved = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_msgid_regid = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_msgid_stamp = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_abort = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_abort_ulb_src_id = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_abort_assign_id = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_abort_msgid_regid = -1; +static int hf_lbmc_umq_rxreq_ulb_mr_abort_msgid_stamp = -1; +static int hf_lbmc_umq_rxreq_qrcrr = -1; +static int hf_lbmc_umq_rxreq_qrcrr_tsp = -1; +static int hf_lbmc_umq_rxreq_trcrr = -1; +static int hf_lbmc_umq_rxreq_trcrr_rcr_idx = -1; +static int hf_lbmc_umq_rxreq_trcrr_tsp = -1; +static int hf_lbmc_umq_rxreq_ulb_trcrr = -1; +static int hf_lbmc_umq_rxreq_ulb_trcrr_ulb_src_id = -1; +static int hf_lbmc_umq_rxreq_ulb_trcrr_assign_id = -1; +static int hf_lbmc_umq_rxreq_ulb_trcrr_tsp = -1; +static int hf_lbmc_umq_rxreq_ulb_trcrr_abort = -1; +static int hf_lbmc_umq_rxreq_ulb_trcrr_abort_ulb_src_id = -1; +static int hf_lbmc_umq_rxreq_ulb_trcrr_abort_assign_id = -1; +static int hf_lbmc_umq_rxreq_ulb_trcrr_abort_tsp = -1; +static int hf_lbmc_umq_qmgmt = -1; +static int hf_lbmc_umq_qmgmt_next_hdr = -1; +static int hf_lbmc_umq_qmgmt_hdr_len = -1; +static int hf_lbmc_umq_resub_req = -1; +static int hf_lbmc_umq_resub_req_next_hdr = -1; +static int hf_lbmc_umq_resub_req_hdr_len = -1; +static int hf_lbmc_umq_resub_req_flags = -1; +static int hf_lbmc_umq_resub_req_flags_ignore = -1; +static int hf_lbmc_umq_resub_req_msgid_regid = -1; +static int hf_lbmc_umq_resub_req_msgid_stamp = -1; +static int hf_lbmc_umq_resub_req_rcr_idx = -1; +static int hf_lbmc_umq_resub_req_resp_ip = -1; +static int hf_lbmc_umq_resub_req_resp_port = -1; +static int hf_lbmc_umq_resub_req_appset_idx = -1; +static int hf_lbmc_umq_resub_resp = -1; +static int hf_lbmc_umq_resub_resp_next_hdr = -1; +static int hf_lbmc_umq_resub_resp_hdr_len = -1; +static int hf_lbmc_umq_resub_resp_flags = -1; +static int hf_lbmc_umq_resub_resp_flags_ignore = -1; +static int hf_lbmc_umq_resub_resp_code = -1; +static int hf_lbmc_umq_resub_resp_msgid_regid = -1; +static int hf_lbmc_umq_resub_resp_msgid_stamp = -1; +static int hf_lbmc_umq_resub_resp_rcr_idx = -1; +static int hf_lbmc_umq_resub_resp_reserved = -1; +static int hf_lbmc_umq_resub_resp_appset_idx = -1; +static int hf_lbmc_topic_interest = -1; +static int hf_lbmc_topic_interest_next_hdr = -1; +static int hf_lbmc_topic_interest_hdr_len = -1; +static int hf_lbmc_topic_interest_flags = -1; +static int hf_lbmc_topic_interest_flags_ignore = -1; +static int hf_lbmc_topic_interest_flags_cancel = -1; +static int hf_lbmc_topic_interest_flags_refresh = -1; +static int hf_lbmc_topic_interest_domain_id = -1; +static int hf_lbmc_pattern_interest = -1; +static int hf_lbmc_pattern_interest_next_hdr = -1; +static int hf_lbmc_pattern_interest_hdr_len = -1; +static int hf_lbmc_pattern_interest_flags = -1; +static int hf_lbmc_pattern_interest_flags_ignore = -1; +static int hf_lbmc_pattern_interest_flags_cancel = -1; +static int hf_lbmc_pattern_interest_flags_refresh = -1; +static int hf_lbmc_pattern_interest_type = -1; +static int hf_lbmc_pattern_interest_domain_id = -1; +static int hf_lbmc_pattern_interest_index = -1; +static int hf_lbmc_advertisement = -1; +static int hf_lbmc_advertisement_next_hdr = -1; +static int hf_lbmc_advertisement_hdr_len = -1; +static int hf_lbmc_advertisement_flags = -1; +static int hf_lbmc_advertisement_flags_ignore = -1; +static int hf_lbmc_advertisement_flags_eos = -1; +static int hf_lbmc_advertisement_flags_pattern = -1; +static int hf_lbmc_advertisement_flags_change = -1; +static int hf_lbmc_advertisement_flags_ctxinst = -1; +static int hf_lbmc_advertisement_hop_count = -1; +static int hf_lbmc_advertisement_ad_flags = -1; +static int hf_lbmc_advertisement_ad_flags_lj = -1; +static int hf_lbmc_advertisement_ad_flags_ume = -1; +static int hf_lbmc_advertisement_ad_flags_acktosrc = -1; +static int hf_lbmc_advertisement_ad_flags_queue = -1; +static int hf_lbmc_advertisement_ad_flags_ulb = -1; +static int hf_lbmc_advertisement_cost = -1; +static int hf_lbmc_advertisement_transport_idx = -1; +static int hf_lbmc_advertisement_topic_idx = -1; +static int hf_lbmc_advertisement_low_seqno = -1; +static int hf_lbmc_advertisement_high_seqno = -1; +static int hf_lbmc_advertisement_domain_id = -1; +static int hf_lbmc_advertisement_pat_idx = -1; +static int hf_lbmc_advertisement_ctxinst = -1; +static int hf_lbmc_ume_storename = -1; +static int hf_lbmc_ume_storename_next_hdr = -1; +static int hf_lbmc_ume_storename_hdr_len = -1; +static int hf_lbmc_ume_storename_flags = -1; +static int hf_lbmc_ume_storename_flags_ignore = -1; +static int hf_lbmc_ume_storename_store = -1; +static int hf_lbmc_umq_ulb_rcr = -1; +static int hf_lbmc_umq_ulb_rcr_next_hdr = -1; +static int hf_lbmc_umq_ulb_rcr_hdr_len = -1; +static int hf_lbmc_umq_ulb_rcr_flags = -1; +static int hf_lbmc_umq_ulb_rcr_flags_ignore = -1; +static int hf_lbmc_umq_ulb_rcr_flags_r_flag = -1; +static int hf_lbmc_umq_ulb_rcr_flags_d_flag = -1; +static int hf_lbmc_umq_ulb_rcr_flags_eoi_flag = -1; +static int hf_lbmc_umq_ulb_rcr_flags_boi_flag = -1; +static int hf_lbmc_umq_ulb_rcr_queue_id = -1; +static int hf_lbmc_umq_ulb_rcr_ulb_src_id = -1; +static int hf_lbmc_umq_ulb_rcr_msgid_regid = -1; +static int hf_lbmc_umq_ulb_rcr_msgid_stamp = -1; +static int hf_lbmc_umq_ulb_rcr_topic_tsp = -1; +static int hf_lbmc_umq_ulb_rcr_assign_id = -1; +static int hf_lbmc_umq_ulb_rcr_appset_idx = -1; +static int hf_lbmc_umq_ulb_rcr_num_ras = -1; +static int hf_lbmc_umq_lf = -1; +static int hf_lbmc_umq_lf_next_hdr = -1; +static int hf_lbmc_umq_lf_hdr_len = -1; +static int hf_lbmc_umq_lf_flags = -1; +static int hf_lbmc_umq_lf_flags_ignore = -1; +static int hf_lbmc_umq_lf_type = -1; +static int hf_lbmc_umq_lf_num_srcs = -1; +static int hf_lbmc_umq_lf_lf = -1; +static int hf_lbmc_ctxinfo = -1; +static int hf_lbmc_ctxinfo_next_hdr = -1; +static int hf_lbmc_ctxinfo_hdr_len = -1; +static int hf_lbmc_ctxinfo_flags = -1; +static int hf_lbmc_ctxinfo_flags_ignore = -1; +static int hf_lbmc_ctxinfo_flags_query = -1; +static int hf_lbmc_ctxinfo_flags_addr = -1; +static int hf_lbmc_ctxinfo_flags_ctxinst = -1; +static int hf_lbmc_ctxinfo_flags_name = -1; +static int hf_lbmc_ctxinfo_flags_tnwgsrc = -1; +static int hf_lbmc_ctxinfo_flags_tnwgrcv = -1; +static int hf_lbmc_ctxinfo_flags_proxy = -1; +static int hf_lbmc_ctxinfo_reserved = -1; +static int hf_lbmc_ctxinfo_hop_count = -1; +static int hf_lbmc_ctxinfo_port = -1; +static int hf_lbmc_ctxinfo_addr = -1; +static int hf_lbmc_ctxinfo_domain_id = -1; +static int hf_lbmc_ctxinfo_ctxinst = -1; +static int hf_lbmc_ctxinfo_name = -1; +static int hf_lbmc_ume_pser = -1; +static int hf_lbmc_ume_pser_next_hdr = -1; +static int hf_lbmc_ume_pser_hdr_len = -1; +static int hf_lbmc_ume_pser_flags = -1; +static int hf_lbmc_ume_pser_flags_ignore = -1; +static int hf_lbmc_ume_pser_flags_source_ctxinst = -1; +static int hf_lbmc_ume_pser_flags_store_ctxinst = -1; +static int hf_lbmc_ume_pser_flags_reelect = -1; +static int hf_lbmc_ume_pser_source_ip = -1; +static int hf_lbmc_ume_pser_store_ip = -1; +static int hf_lbmc_ume_pser_transport_idx = -1; +static int hf_lbmc_ume_pser_topic_idx = -1; +static int hf_lbmc_ume_pser_source_port = -1; +static int hf_lbmc_ume_pser_store_port = -1; +static int hf_lbmc_ume_pser_source_ctxinst = -1; +static int hf_lbmc_ume_pser_store_ctxinst = -1; +static int hf_lbmc_domain = -1; +static int hf_lbmc_domain_next_hdr = -1; +static int hf_lbmc_domain_hdr_len = -1; +static int hf_lbmc_domain_flags = -1; +static int hf_lbmc_domain_flags_ignore = -1; +static int hf_lbmc_domain_flags_active = -1; +static int hf_lbmc_domain_domain = -1; +static int hf_lbmc_tnwg_capabilities = -1; +static int hf_lbmc_tnwg_capabilities_next_hdr = -1; +static int hf_lbmc_tnwg_capabilities_hdr_len = -1; +static int hf_lbmc_tnwg_capabilities_flags = -1; +static int hf_lbmc_tnwg_capabilities_flags_ignore = -1; +static int hf_lbmc_tnwg_capabilities_flags_version = -1; +static int hf_lbmc_tnwg_capabilities_capabilities1 = -1; +static int hf_lbmc_tnwg_capabilities_capabilities1_ume = -1; +static int hf_lbmc_tnwg_capabilities_capabilities1_umq = -1; +static int hf_lbmc_tnwg_capabilities_capabilities2 = -1; +static int hf_lbmc_tnwg_capabilities_capabilities3 = -1; +static int hf_lbmc_tnwg_capabilities_capabilities3_pcre = -1; +static int hf_lbmc_tnwg_capabilities_capabilities3_regex = -1; +static int hf_lbmc_tnwg_capabilities_capabilities4 = -1; +static int hf_lbmc_patidx = -1; +static int hf_lbmc_patidx_next_hdr = -1; +static int hf_lbmc_patidx_hdr_len = -1; +static int hf_lbmc_patidx_flags = -1; +static int hf_lbmc_patidx_flags_ignore = -1; +static int hf_lbmc_patidx_patidx = -1; +static int hf_lbmc_ume_client_lifetime = -1; +static int hf_lbmc_ume_client_lifetime_next_hdr = -1; +static int hf_lbmc_ume_client_lifetime_hdr_len = -1; +static int hf_lbmc_ume_client_lifetime_flags = -1; +static int hf_lbmc_ume_client_lifetime_flags_ignore = -1; +static int hf_lbmc_ume_client_lifetime_activity_tmo = -1; +static int hf_lbmc_ume_client_lifetime_lifetime = -1; +static int hf_lbmc_ume_client_lifetime_ttl = -1; +static int hf_lbmc_ume_sid = -1; +static int hf_lbmc_ume_sid_next_hdr = -1; +static int hf_lbmc_ume_sid_hdr_len = -1; +static int hf_lbmc_ume_sid_flags = -1; +static int hf_lbmc_ume_sid_flags_ignore = -1; +static int hf_lbmc_ume_sid_sid = -1; +static int hf_lbmc_umq_idx_cmd = -1; +static int hf_lbmc_umq_idx_cmd_next_hdr = -1; +static int hf_lbmc_umq_idx_cmd_hdr_len = -1; +static int hf_lbmc_umq_idx_cmd_flags = -1; +static int hf_lbmc_umq_idx_cmd_flags_ignore = -1; +static int hf_lbmc_umq_idx_cmd_cmd_type = -1; +static int hf_lbmc_umq_idx_cmd_queue_id = -1; +static int hf_lbmc_umq_idx_cmd_cmd_id = -1; +static int hf_lbmc_umq_idx_cmd_inst_idx = -1; +static int hf_lbmc_umq_idx_cmd_regid = -1; +static int hf_lbmc_umq_idx_cmd_stop_assign = -1; +static int hf_lbmc_umq_idx_cmd_stop_assign_rcr_idx = -1; +static int hf_lbmc_umq_idx_cmd_stop_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_start_assign = -1; +static int hf_lbmc_umq_idx_cmd_start_assign_rcr_idx = -1; +static int hf_lbmc_umq_idx_cmd_start_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_release_assign = -1; +static int hf_lbmc_umq_idx_cmd_release_assign_rcr_idx = -1; +static int hf_lbmc_umq_idx_cmd_release_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_release_assign_flags = -1; +static int hf_lbmc_umq_idx_cmd_release_assign_flags_numeric = -1; +static int hf_lbmc_umq_idx_cmd_release_assign_index_len = -1; +static int hf_lbmc_umq_idx_cmd_release_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_release_assign_numeric_index = -1; +static int hf_lbmc_umq_idx_cmd_release_assign_string_index = -1; +static int hf_lbmc_umq_idx_cmd_ulb_stop_assign = -1; +static int hf_lbmc_umq_idx_cmd_ulb_stop_assign_src_id = -1; +static int hf_lbmc_umq_idx_cmd_ulb_stop_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_ulb_stop_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_ulb_stop_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_ulb_start_assign = -1; +static int hf_lbmc_umq_idx_cmd_ulb_start_assign_src_id = -1; +static int hf_lbmc_umq_idx_cmd_ulb_start_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_ulb_start_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_ulb_start_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_src_id = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_flags = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_flags_numeric = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_index_len = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_numeric_index = -1; +static int hf_lbmc_umq_idx_cmd_ulb_release_assign_string_index = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign_rcr_idx = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign_flags = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign_flags_numeric = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign_index_len = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign_numeric_index = -1; +static int hf_lbmc_umq_idx_cmd_reserve_assign_string_index = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_src_id = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_flags = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_flags_numeric = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_index_len = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_numeric_index = -1; +static int hf_lbmc_umq_idx_cmd_ulb_reserve_assign_string_index = -1; +static int hf_lbmc_umq_idx_cmd_resp = -1; +static int hf_lbmc_umq_idx_cmd_resp_next_hdr = -1; +static int hf_lbmc_umq_idx_cmd_resp_hdr_len = -1; +static int hf_lbmc_umq_idx_cmd_resp_flags = -1; +static int hf_lbmc_umq_idx_cmd_resp_flags_ignore = -1; +static int hf_lbmc_umq_idx_cmd_resp_flags_ulb = -1; +static int hf_lbmc_umq_idx_cmd_resp_resp_type = -1; +static int hf_lbmc_umq_idx_cmd_resp_queue_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_cmd_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_inst_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_regid = -1; +static int hf_lbmc_umq_idx_cmd_resp_err = -1; +static int hf_lbmc_umq_idx_cmd_resp_err_reserved = -1; +static int hf_lbmc_umq_idx_cmd_resp_err_code = -1; +static int hf_lbmc_umq_idx_cmd_resp_err_error_string = -1; +static int hf_lbmc_umq_idx_cmd_resp_stop_assign = -1; +static int hf_lbmc_umq_idx_cmd_resp_stop_assign_rcr_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_stop_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_start_assign = -1; +static int hf_lbmc_umq_idx_cmd_resp_start_assign_rcr_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_start_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_start_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_start_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_resp_release_assign = -1; +static int hf_lbmc_umq_idx_cmd_resp_release_assign_rcr_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_release_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_release_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_release_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_src_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_start_assign = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_src_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_release_assign = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_src_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_rcr_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_flags = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_flags_numeric = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_index_len = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_numeric_index = -1; +static int hf_lbmc_umq_idx_cmd_resp_reserve_assign_string_index = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_src_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_assign_id = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags_numeric = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_appset_idx = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_index_len = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_reserved = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_numeric_index = -1; +static int hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_string_index = -1; +static int hf_lbmc_odomain = -1; +static int hf_lbmc_odomain_next_hdr = -1; +static int hf_lbmc_odomain_hdr_len = -1; +static int hf_lbmc_odomain_flags = -1; +static int hf_lbmc_odomain_flags_ignore = -1; +static int hf_lbmc_odomain_domain = -1; +static int hf_lbmc_stream = -1; +static int hf_lbmc_stream_next_hdr = -1; +static int hf_lbmc_stream_hdr_len = -1; +static int hf_lbmc_stream_flags = -1; +static int hf_lbmc_stream_flags_ignore = -1; +static int hf_lbmc_stream_stream_id = -1; +static int hf_lbmc_stream_sqn = -1; +static int hf_lbmc_stream_ctxinst = -1; +static int hf_lbmc_topic_md_interest = -1; +static int hf_lbmc_topic_md_interest_next_hdr = -1; +static int hf_lbmc_topic_md_interest_hdr_len = -1; +static int hf_lbmc_topic_md_interest_flags = -1; +static int hf_lbmc_topic_md_interest_flags_ignore = -1; +static int hf_lbmc_topic_md_interest_flags_cancel = -1; +static int hf_lbmc_topic_md_interest_flags_refresh = -1; +static int hf_lbmc_topic_md_interest_domain_count = -1; +static int hf_lbmc_topic_md_interest_res1 = -1; +static int hf_lbmc_topic_md_interest_domain_id = -1; +static int hf_lbmc_pattern_md_interest = -1; +static int hf_lbmc_pattern_md_interest_next_hdr = -1; +static int hf_lbmc_pattern_md_interest_hdr_len = -1; +static int hf_lbmc_pattern_md_interest_flags = -1; +static int hf_lbmc_pattern_md_interest_flags_ignore = -1; +static int hf_lbmc_pattern_md_interest_flags_cancel = -1; +static int hf_lbmc_pattern_md_interest_flags_refresh = -1; +static int hf_lbmc_pattern_md_interest_type = -1; +static int hf_lbmc_pattern_md_interest_domain_count = -1; +static int hf_lbmc_pattern_md_interest_res1 = -1; +static int hf_lbmc_pattern_md_interest_index = -1; +static int hf_lbmc_pattern_md_interest_domain_id = -1; +static int hf_lbmc_lji_req = -1; +static int hf_lbmc_lji_req_next_hdr = -1; +static int hf_lbmc_lji_req_hdr_len = -1; +static int hf_lbmc_lji_req_flags = -1; +static int hf_lbmc_lji_req_flags_ignore = -1; +static int hf_lbmc_lji_req_flags_l_flag = -1; +static int hf_lbmc_lji_req_flags_m_flag = -1; +static int hf_lbmc_lji_req_flags_o_flag = -1; +static int hf_lbmc_lji_req_request_idx = -1; +static int hf_lbmc_lji_req_transport_idx = -1; +static int hf_lbmc_lji_req_topic_idx = -1; +static int hf_lbmc_lji_req_req_ip = -1; +static int hf_lbmc_lji_req_req_port = -1; +static int hf_lbmc_lji_req_res = -1; +static int hf_lbmc_lji_req_tx_low_sqn = -1; +static int hf_lbmc_lji_req_rx_req_max = -1; +static int hf_lbmc_lji_req_rx_req_outstanding_max = -1; +static int hf_lbmc_tnwg_ka = -1; +static int hf_lbmc_tnwg_ka_next_hdr = -1; +static int hf_lbmc_tnwg_ka_hdr_len = -1; +static int hf_lbmc_tnwg_ka_flags = -1; +static int hf_lbmc_tnwg_ka_flags_ignore = -1; +static int hf_lbmc_tnwg_ka_flags_q_flag = -1; +static int hf_lbmc_tnwg_ka_flags_r_flag = -1; +static int hf_lbmc_tnwg_ka_index = -1; +static int hf_lbmc_tnwg_ka_ts_seconds = -1; +static int hf_lbmc_tnwg_ka_ts_microseconds = -1; +static int hf_lbmc_tnwg_ka_reserved_1 = -1; +static int hf_lbmc_tnwg_ka_reserved_2 = -1; +static int hf_lbmc_tnwg_ka_reserved_3 = -1; +static int hf_lbmc_tnwg_ka_reserved_4 = -1; +static int hf_lbmc_tnwg_ka_reserved_5 = -1; +static int hf_lbmc_tnwg_ka_reserved_6 = -1; +static int hf_lbmc_ume_receiver_keepalive = -1; +static int hf_lbmc_ume_receiver_keepalive_next_hdr = -1; +static int hf_lbmc_ume_receiver_keepalive_hdr_len = -1; +static int hf_lbmc_ume_receiver_keepalive_flags = -1; +static int hf_lbmc_ume_receiver_keepalive_flags_ignore = -1; +static int hf_lbmc_ume_receiver_keepalive_rcv_regid = -1; +static int hf_lbmc_ume_receiver_keepalive_session_id = -1; +static int hf_lbmc_ume_receiver_keepalive_ctxinst = -1; +static int hf_lbmc_umq_cmd = -1; +static int hf_lbmc_umq_cmd_next_hdr = -1; +static int hf_lbmc_umq_cmd_hdr_len = -1; +static int hf_lbmc_umq_cmd_flags = -1; +static int hf_lbmc_umq_cmd_flags_ignore = -1; +static int hf_lbmc_umq_cmd_cmd_type = -1; +static int hf_lbmc_umq_cmd_queue_id = -1; +static int hf_lbmc_umq_cmd_cmd_id = -1; +static int hf_lbmc_umq_cmd_inst_idx = -1; +static int hf_lbmc_umq_cmd_regid = -1; +static int hf_lbmc_umq_cmd_topic_list = -1; +static int hf_lbmc_umq_cmd_topic_list_serial_num = -1; +static int hf_lbmc_umq_cmd_msg_retrieve = -1; +static int hf_lbmc_umq_cmd_msg_retrieve_rcr_idx = -1; +static int hf_lbmc_umq_cmd_msg_retrieve_assign_id = -1; +static int hf_lbmc_umq_cmd_msg_retrieve_info_only = -1; +static int hf_lbmc_umq_cmd_msg_retrieve_num_msgids = -1; +static int hf_lbmc_umq_cmd_msg_retrieve_flags = -1; +static int hf_lbmc_umq_cmd_msg_retrieve_entry = -1; +static int hf_lbmc_umq_cmd_msg_retrieve_entry_regid = -1; +static int hf_lbmc_umq_cmd_msg_retrieve_entry_stamp = -1; +static int hf_lbmc_umq_cmd_msg_list = -1; +static int hf_lbmc_umq_cmd_msg_list_rcr_idx = -1; +static int hf_lbmc_umq_cmd_msg_list_assign_id = -1; +static int hf_lbmc_umq_cmd_resp = -1; +static int hf_lbmc_umq_cmd_resp_next_hdr = -1; +static int hf_lbmc_umq_cmd_resp_hdr_len = -1; +static int hf_lbmc_umq_cmd_resp_flags = -1; +static int hf_lbmc_umq_cmd_resp_flags_ignore = -1; +static int hf_lbmc_umq_cmd_resp_resp_type = -1; +static int hf_lbmc_umq_cmd_resp_queue_id = -1; +static int hf_lbmc_umq_cmd_resp_cmd_id = -1; +static int hf_lbmc_umq_cmd_resp_inst_idx = -1; +static int hf_lbmc_umq_cmd_resp_regid = -1; +static int hf_lbmc_umq_cmd_resp_msg_retrieve = -1; +static int hf_lbmc_umq_cmd_resp_msg_retrieve_rcr_idx = -1; +static int hf_lbmc_umq_cmd_resp_msg_retrieve_assign_id = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_num_msgs = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_flags = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_reserved = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_regid = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_stamp = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_assign_id = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_num_ras = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_status = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_reserved = -1; +static int hf_lbmc_umq_cmd_resp_msg_list = -1; +static int hf_lbmc_umq_cmd_resp_msg_list_rcr_idx = -1; +static int hf_lbmc_umq_cmd_resp_msg_list_assign_id = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_list = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_list_num_msgs = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_list_entry = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_list_entry_regid = -1; +static int hf_lbmc_umq_cmd_resp_xmsg_list_entry_stamp = -1; +static int hf_lbmc_umq_cmd_resp_topic_list = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_num_topics = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_rcr_idx = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_num_appsets = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_topic_len = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_reserved = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_topic = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_num_receiver_type_ids = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_appset_idx = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_appset_name_len = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_reserved = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_name = -1; +static int hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_receiver_type_id = -1; +static int hf_lbmc_umq_cmd_resp_err = -1; +static int hf_lbmc_umq_cmd_resp_err_reserved = -1; +static int hf_lbmc_umq_cmd_resp_err_code = -1; +static int hf_lbmc_umq_cmd_resp_err_errmsg = -1; +static int hf_lbmc_sri_req = -1; +static int hf_lbmc_sri_req_next_hdr = -1; +static int hf_lbmc_sri_req_hdr_len = -1; +static int hf_lbmc_sri_req_flags = -1; +static int hf_lbmc_sri_req_flags_ignore = -1; +static int hf_lbmc_sri_req_transport_idx = -1; +static int hf_lbmc_sri_req_topic_idx = -1; +static int hf_lbmc_ume_store_domain = -1; +static int hf_lbmc_ume_store_domain_next_hdr = -1; +static int hf_lbmc_ume_store_domain_hdr_len = -1; +static int hf_lbmc_ume_store_domain_flags = -1; +static int hf_lbmc_ume_store_domain_flags_ignore = -1; +static int hf_lbmc_ume_store_domain_domain = -1; +static int hf_lbmc_sri = -1; +static int hf_lbmc_sri_next_hdr = -1; +static int hf_lbmc_sri_hdr_len = -1; +static int hf_lbmc_sri_flags = -1; +static int hf_lbmc_sri_flags_ignore = -1; +static int hf_lbmc_sri_flags_acktosrc = -1; +static int hf_lbmc_sri_flags_initial_sqn_known = -1; +static int hf_lbmc_sri_version = -1; +static int hf_lbmc_sri_low_sqn = -1; +static int hf_lbmc_sri_high_sqn = -1; +static int hf_lbmc_route_info = -1; +static int hf_lbmc_route_info_next_hdr = -1; +static int hf_lbmc_route_info_hdr_len = -1; +static int hf_lbmc_route_info_flags = -1; +static int hf_lbmc_route_info_flags_ignore = -1; +static int hf_lbmc_route_info_gateway_version = -1; +static int hf_lbmc_route_info_configuration_signature = -1; +static int hf_lbmc_route_info_node_id = -1; +static int hf_lbmc_route_info_topology = -1; +static int hf_lbmc_route_info_vers = -1; +static int hf_lbmc_route_info_sqn = -1; +static int hf_lbmc_route_info_ttl = -1; +static int hf_lbmc_route_info_reserved1 = -1; +static int hf_lbmc_route_info_reserved2 = -1; +static int hf_lbmc_route_info_neighbor = -1; +static int hf_lbmc_route_info_neighbor_next_hdr = -1; +static int hf_lbmc_route_info_neighbor_hdr_len = -1; +static int hf_lbmc_route_info_neighbor_flags = -1; +static int hf_lbmc_route_info_neighbor_flags_ignore = -1; +static int hf_lbmc_route_info_neighbor_node_id = -1; +static int hf_lbmc_route_info_neighbor_ingress_cost = -1; +static int hf_lbmc_route_info_neighbor_egress_cost = -1; +static int hf_lbmc_gateway_name = -1; +static int hf_lbmc_gateway_name_next_hdr = -1; +static int hf_lbmc_gateway_name_hdr_len = -1; +static int hf_lbmc_gateway_name_flags = -1; +static int hf_lbmc_gateway_name_flags_ignore = -1; +static int hf_lbmc_gateway_name_gateway_name = -1; +static int hf_lbmc_auth_request = -1; +static int hf_lbmc_auth_request_next_hdr = -1; +static int hf_lbmc_auth_request_hdr_len = -1; +static int hf_lbmc_auth_request_flags = -1; +static int hf_lbmc_auth_request_flags_ignore = -1; +static int hf_lbmc_auth_request_opid = -1; +static int hf_lbmc_auth_request_user_len = -1; +static int hf_lbmc_auth_request_user_name = -1; +static int hf_lbmc_auth_challenge = -1; +static int hf_lbmc_auth_challenge_next_hdr = -1; +static int hf_lbmc_auth_challenge_hdr_len = -1; +static int hf_lbmc_auth_challenge_flags = -1; +static int hf_lbmc_auth_challenge_flags_ignore = -1; +static int hf_lbmc_auth_challenge_opid = -1; +static int hf_lbmc_auth_challenge_mod_len = -1; +static int hf_lbmc_auth_challenge_gen_len = -1; +static int hf_lbmc_auth_challenge_salt_len = -1; +static int hf_lbmc_auth_challenge_pubkey_len = -1; +static int hf_lbmc_auth_challenge_mod = -1; +static int hf_lbmc_auth_challenge_gen = -1; +static int hf_lbmc_auth_challenge_salt = -1; +static int hf_lbmc_auth_challenge_pubkey = -1; +static int hf_lbmc_auth_challenge_rsp = -1; +static int hf_lbmc_auth_challenge_rsp_next_hdr = -1; +static int hf_lbmc_auth_challenge_rsp_hdr_len = -1; +static int hf_lbmc_auth_challenge_rsp_flags = -1; +static int hf_lbmc_auth_challenge_rsp_flags_ignore = -1; +static int hf_lbmc_auth_challenge_rsp_opid = -1; +static int hf_lbmc_auth_challenge_rsp_pubkey_len = -1; +static int hf_lbmc_auth_challenge_rsp_evidence_len = -1; +static int hf_lbmc_auth_challenge_rsp_pubkey = -1; +static int hf_lbmc_auth_challenge_rsp_evidence = -1; +static int hf_lbmc_auth_result = -1; +static int hf_lbmc_auth_result_next_hdr = -1; +static int hf_lbmc_auth_result_hdr_len = -1; +static int hf_lbmc_auth_result_flags = -1; +static int hf_lbmc_auth_result_flags_ignore = -1; +static int hf_lbmc_auth_result_opid = -1; +static int hf_lbmc_auth_result_result = -1; +static int hf_lbmc_auth_unknown = -1; +static int hf_lbmc_auth_unknown_next_hdr = -1; +static int hf_lbmc_auth_unknown_hdr_len = -1; +static int hf_lbmc_auth_unknown_flags = -1; +static int hf_lbmc_auth_unknown_opid = -1; +static int hf_lbmc_auth_unknown_data = -1; +static int hf_lbmc_hmac = -1; +static int hf_lbmc_hmac_next_hdr = -1; +static int hf_lbmc_hmac_hdr_len = -1; +static int hf_lbmc_hmac_flags = -1; +static int hf_lbmc_hmac_flags_ignore = -1; +static int hf_lbmc_hmac_padding = -1; +static int hf_lbmc_hmac_data = -1; +static int hf_lbmc_umq_sid = -1; +static int hf_lbmc_umq_sid_next_hdr = -1; +static int hf_lbmc_umq_sid_hdr_len = -1; +static int hf_lbmc_umq_sid_flags = -1; +static int hf_lbmc_umq_sid_flags_ignore = -1; +static int hf_lbmc_umq_sid_key = -1; +static int hf_lbmc_umq_sid_sid = -1; +static int hf_lbmc_destination = -1; +static int hf_lbmc_destination_next_hdr = -1; +static int hf_lbmc_destination_hdr_len = -1; +static int hf_lbmc_destination_flags = -1; +static int hf_lbmc_destination_flags_ignore = -1; +static int hf_lbmc_destination_domain_id = -1; +static int hf_lbmc_destination_ipaddr = -1; +static int hf_lbmc_destination_port = -1; +static int hf_lbmc_destination_hops_taken = -1; +static int hf_lbmc_destination_orig_domain_id = -1; +static int hf_lbmc_destination_orig_ipaddr = -1; +static int hf_lbmc_destination_orig_port = -1; +static int hf_lbmc_destination_reserved = -1; +static int hf_lbmc_topic_idx = -1; +static int hf_lbmc_topic_idx_next_hdr = -1; +static int hf_lbmc_topic_idx_hdr_len = -1; +static int hf_lbmc_topic_idx_flags = -1; +static int hf_lbmc_topic_idx_flags_ignore = -1; +static int hf_lbmc_topic_idx_tidx = -1; +static int hf_lbmc_topic_source = -1; +static int hf_lbmc_topic_source_next_hdr = -1; +static int hf_lbmc_topic_source_hdr_len = -1; +static int hf_lbmc_topic_source_flags = -1; +static int hf_lbmc_topic_source_flags_ignore = -1; +static int hf_lbmc_topic_source_flags_eos = -1; +static int hf_lbmc_topic_source_domain_id = -1; +static int hf_lbmc_topic_source_exfunc = -1; +static int hf_lbmc_topic_source_exfunc_next_hdr = -1; +static int hf_lbmc_topic_source_exfunc_hdr_len = -1; +static int hf_lbmc_topic_source_exfunc_flags = -1; +static int hf_lbmc_topic_source_exfunc_flags_ignore = -1; +static int hf_lbmc_topic_source_exfunc_src_ip = -1; +static int hf_lbmc_topic_source_exfunc_src_port = -1; +static int hf_lbmc_topic_source_exfunc_unused = -1; +static int hf_lbmc_topic_source_exfunc_functionality_flags = -1; +static int hf_lbmc_topic_source_exfunc_functionality_flags_ulb = -1; +static int hf_lbmc_topic_source_exfunc_functionality_flags_umq = -1; +static int hf_lbmc_topic_source_exfunc_functionality_flags_ume = -1; +static int hf_lbmc_topic_source_exfunc_functionality_flags_lj = -1; +static int hf_lbmc_ume_store_ext = -1; +static int hf_lbmc_ume_store_ext_next_hdr = -1; +static int hf_lbmc_ume_store_ext_hdr_len = -1; +static int hf_lbmc_ume_store_ext_flags = -1; +static int hf_lbmc_ume_store_ext_flags_ignore = -1; +static int hf_lbmc_ume_store_ext_grp_idx = -1; +static int hf_lbmc_ume_store_ext_store_tcp_port = -1; +static int hf_lbmc_ume_store_ext_store_idx = -1; +static int hf_lbmc_ume_store_ext_store_ip_addr = -1; +static int hf_lbmc_ume_store_ext_src_reg_id = -1; +static int hf_lbmc_ume_store_ext_domain_id = -1; +static int hf_lbmc_ume_store_ext_version = -1; +static int hf_lbmc_ume_psrc_election_token = -1; +static int hf_lbmc_ume_psrc_election_token_next_hdr = -1; +static int hf_lbmc_ume_psrc_election_token_hdr_len = -1; +static int hf_lbmc_ume_psrc_election_token_flags = -1; +static int hf_lbmc_ume_psrc_election_token_flags_ignore = -1; +static int hf_lbmc_ume_psrc_election_token_store_index = -1; +static int hf_lbmc_ume_psrc_election_token_token = -1; +static int hf_lbmc_tcp_sid = -1; +static int hf_lbmc_tcp_sid_next_hdr = -1; +static int hf_lbmc_tcp_sid_hdr_len = -1; +static int hf_lbmc_tcp_sid_flags = -1; +static int hf_lbmc_tcp_sid_flags_ignore = -1; +static int hf_lbmc_tcp_sid_sid = -1; +static int hf_lbmc_extopt = -1; +static int hf_lbmc_extopt_next_hdr = -1; +static int hf_lbmc_extopt_hdr_len = -1; +static int hf_lbmc_extopt_flags = -1; +static int hf_lbmc_extopt_flags_ignore = -1; +static int hf_lbmc_extopt_flags_ignore_subtype = -1; +static int hf_lbmc_extopt_flags_more_fragments = -1; +static int hf_lbmc_extopt_id = -1; +static int hf_lbmc_extopt_subtype = -1; +static int hf_lbmc_extopt_fragment_offset = -1; +static int hf_lbmc_extopt_data = -1; +static int hf_lbmc_extopt_cfgopt = -1; +static int hf_lbmc_extopt_cfgopt_scope = -1; +static int hf_lbmc_extopt_cfgopt_parent = -1; +static int hf_lbmc_extopt_cfgopt_name = -1; +static int hf_lbmc_extopt_cfgopt_value = -1; +static int hf_lbmc_extopt_msgsel = -1; +static int hf_lbmc_extopt_reassembled_data = -1; +static int hf_lbmc_extopt_reassembled_data_subtype = -1; +static int hf_lbmc_extopt_reassembled_data_len = -1; +static int hf_lbmc_extopt_reassembled_data_data = -1; +static int hf_lbmc_extopt_reassembled_data_msgsel = -1; +static int hf_lbm_msg_properties = -1; +static int hf_lbm_msg_properties_data = -1; +static int hf_lbm_msg_properties_data_magic = -1; +static int hf_lbm_msg_properties_data_num_fields = -1; +static int hf_lbm_msg_properties_data_vertype = -1; +static int hf_lbm_msg_properties_data_vertype_version = -1; +static int hf_lbm_msg_properties_data_vertype_type = -1; +static int hf_lbm_msg_properties_data_res = -1; +static int hf_lbm_msg_properties_hdr = -1; +static int hf_lbm_msg_properties_hdr_key_offset = -1; +static int hf_lbm_msg_properties_hdr_value_offset = -1; +static int hf_lbm_msg_properties_hdr_hash = -1; +static int hf_lbm_msg_properties_hdr_type = -1; +static int hf_lbm_msg_properties_hdr_key = -1; +static int hf_lbm_msg_properties_hdr_boolean_value = -1; +static int hf_lbm_msg_properties_hdr_byte_value = -1; +static int hf_lbm_msg_properties_hdr_short_value = -1; +static int hf_lbm_msg_properties_hdr_int_value = -1; +static int hf_lbm_msg_properties_hdr_float_value = -1; +static int hf_lbm_msg_properties_hdr_long_value = -1; +static int hf_lbm_msg_properties_hdr_double_value = -1; +static int hf_lbm_msg_properties_hdr_string_value = -1; +static int hf_lbm_msg_properties_hdr_unknown_value = -1; +static int hf_lbmc_unhandled = -1; +static int hf_lbmc_unhandled_next_hdr = -1; +static int hf_lbmc_unhandled_hdr_len = -1; +static int hf_lbmc_unhandled_data = -1; +static int hf_lbm_stream = -1; +static int hf_lbm_stream_stream_id = -1; +static int hf_lbm_stream_substream_id = -1; +static int hf_lbmc_reassembly = -1; +static int hf_lbmc_reassembly_fragment = -1; +static int hf_reassembly_frame = -1; + +/* Protocol trees */ +static gint ett_lbmc = -1; +static gint ett_lbmc_ver_type = -1; +static gint ett_lbmc_frag = -1; +static gint ett_lbmc_frag_flags = -1; +static gint ett_lbmc_batch = -1; +static gint ett_lbmc_batch_flags = -1; +static gint ett_lbmc_tcp_request = -1; +static gint ett_lbmc_tcp_request_flags = -1; +static gint ett_lbmc_topicname = -1; +static gint ett_lbmc_topicname_flags = -1; +static gint ett_lbmc_apphdr = -1; +static gint ett_lbmc_apphdr_code = -1; +static gint ett_lbmc_apphdr_chain = -1; +static gint ett_lbmc_apphdr_chain_element = -1; +static gint ett_lbmc_apphdr_chain_msgprop = -1; +static gint ett_lbmc_umq_msgid = -1; +static gint ett_lbmc_umq_msgid_flags = -1; +static gint ett_lbmc_umq_sqd_rcv = -1; +static gint ett_lbmc_umq_sqd_rcv_flags = -1; +static gint ett_lbmc_umq_resub = -1; +static gint ett_lbmc_umq_resub_flags = -1; +static gint ett_lbmc_otid = -1; +static gint ett_lbmc_otid_flags = -1; +static gint ett_lbmc_ctxinst = -1; +static gint ett_lbmc_ctxinst_flags = -1; +static gint ett_lbmc_ctxinstd = -1; +static gint ett_lbmc_ctxinstr = -1; +static gint ett_lbmc_srcidx = -1; +static gint ett_lbmc_srcidx_flags = -1; +static gint ett_lbmc_umq_ulb_msg = -1; +static gint ett_lbmc_umq_ulb_msg_flags = -1; +static gint ett_lbmc_ssf_init = -1; +static gint ett_lbmc_ssf_init_flags = -1; +static gint ett_lbmc_ssf_creq = -1; +static gint ett_lbmc_ssf_creq_flags = -1; +static gint ett_lbmc_ume_preg = -1; +static gint ett_lbmc_ume_preg_flags = -1; +static gint ett_lbmc_ume_preg_marker = -1; +static gint ett_lbmc_ume_preg_resp = -1; +static gint ett_lbmc_ume_preg_resp_code = -1; +static gint ett_lbmc_ume_preg_resp_marker = -1; +static gint ett_lbmc_ume_ack = -1; +static gint ett_lbmc_ume_ack_flags = -1; +static gint ett_lbmc_ume_rxreq = -1; +static gint ett_lbmc_ume_rxreq_flags = -1; +static gint ett_lbmc_ume_keepalive = -1; +static gint ett_lbmc_ume_keepalive_flags = -1; +static gint ett_lbmc_ume_storeid = -1; +static gint ett_lbmc_ume_storeid_store_id = -1; +static gint ett_lbmc_ume_ranged_ack = -1; +static gint ett_lbmc_ume_ranged_ack_flags = -1; +static gint ett_lbmc_ume_ack_id = -1; +static gint ett_lbmc_ume_ack_id_flags = -1; +static gint ett_lbmc_ume_capability = -1; +static gint ett_lbmc_ume_capability_flags = -1; +static gint ett_lbmc_ume_proxy_src = -1; +static gint ett_lbmc_ume_proxy_src_flags = -1; +static gint ett_lbmc_ume_store_group = -1; +static gint ett_lbmc_ume_store_group_flags = -1; +static gint ett_lbmc_ume_store = -1; +static gint ett_lbmc_ume_store_flags = -1; +static gint ett_lbmc_ume_lj_info = -1; +static gint ett_lbmc_ume_lj_info_flags = -1; +static gint ett_lbmc_tsni = -1; +static gint ett_lbmc_tsni_num_recs = -1; +static gint ett_lbmc_tsni_rec = -1; +static gint ett_lbmc_umq_reg = -1; +static gint ett_lbmc_umq_reg_flags = -1; +static gint ett_lbmc_umq_reg_reg_ctx = -1; +static gint ett_lbmc_umq_reg_reg_src = -1; +static gint ett_lbmc_umq_reg_reg_rcv = -1; +static gint ett_lbmc_umq_reg_rcv_dereg = -1; +static gint ett_lbmc_umq_reg_reg_ulb_rcv = -1; +static gint ett_lbmc_umq_reg_ulb_rcv_dereg = -1; +static gint ett_lbmc_umq_reg_reg_observer_rcv = -1; +static gint ett_lbmc_umq_reg_observer_rcv_dereg = -1; +static gint ett_lbmc_umq_reg_resp = -1; +static gint ett_lbmc_umq_reg_resp_flags = -1; +static gint ett_lbmc_umq_reg_resp_reg_ctx = -1; +static gint ett_lbmc_umq_reg_resp_reg_ctx_ex = -1; +static gint ett_lbmc_umq_reg_resp_reg_ctx_ex_flags = -1; +static gint ett_lbmc_umq_reg_resp_err = -1; +static gint ett_lbmc_umq_reg_resp_reg_src = -1; +static gint ett_lbmc_umq_reg_resp_reg_rcv = -1; +static gint ett_lbmc_umq_reg_resp_rcv_dereg = -1; +static gint ett_lbmc_umq_reg_resp_reg_ulb_rcv = -1; +static gint ett_lbmc_umq_reg_resp_ulb_rcv_dereg = -1; +static gint ett_lbmc_umq_reg_resp_reg_observer_rcv = -1; +static gint ett_lbmc_umq_reg_resp_observer_rcv_dereg = -1; +static gint ett_lbmc_umq_ack = -1; +static gint ett_lbmc_umq_ack_msgs = -1; +static gint ett_lbmc_umq_ack_msgid = -1; +static gint ett_lbmc_umq_ack_stable = -1; +static gint ett_lbmc_umq_ack_cr = -1; +static gint ett_lbmc_umq_ack_ulb_cr = -1; +static gint ett_lbmc_umq_rcr = -1; +static gint ett_lbmc_umq_rcr_flags = -1; +static gint ett_lbmc_umq_ka = -1; +static gint ett_lbmc_umq_ka_flags = -1; +static gint ett_lbmc_umq_ka_src = -1; +static gint ett_lbmc_umq_ka_rcv = -1; +static gint ett_lbmc_umq_ka_ulb_rcv = -1; +static gint ett_lbmc_umq_ka_ulb_rcv_resp = -1; +static gint ett_lbmc_umq_rxreq = -1; +static gint ett_lbmc_umq_rxreq_flags = -1; +static gint ett_lbmc_umq_rxreq_regid_resp = -1; +static gint ett_lbmc_umq_rxreq_addr_resp = -1; +static gint ett_lbmc_umq_rxreq_mr = -1; +static gint ett_lbmc_umq_rxreq_ulb_mr = -1; +static gint ett_lbmc_umq_rxreq_ulb_mr_abort = -1; +static gint ett_lbmc_umq_rxreq_qrcrr = -1; +static gint ett_lbmc_umq_rxreq_trcrr = -1; +static gint ett_lbmc_umq_rxreq_ulb_trcrr = -1; +static gint ett_lbmc_umq_rxreq_ulb_trcrr_abort = -1; +static gint ett_lbmc_umq_qmgmt = -1; +static gint ett_lbmc_umq_resub_req = -1; +static gint ett_lbmc_umq_resub_req_flags = -1; +static gint ett_lbmc_umq_resub_resp = -1; +static gint ett_lbmc_umq_resub_resp_flags = -1; +static gint ett_lbmc_topic_interest = -1; +static gint ett_lbmc_topic_interest_flags = -1; +static gint ett_lbmc_pattern_interest = -1; +static gint ett_lbmc_pattern_interest_flags = -1; +static gint ett_lbmc_advertisement = -1; +static gint ett_lbmc_advertisement_flags = -1; +static gint ett_lbmc_advertisement_ad_flags = -1; +static gint ett_lbmc_ume_storename = -1; +static gint ett_lbmc_ume_storename_flags = -1; +static gint ett_lbmc_umq_ulb_rcr = -1; +static gint ett_lbmc_umq_ulb_rcr_flags = -1; +static gint ett_lbmc_umq_lf = -1; +static gint ett_lbmc_umq_lf_flags = -1; +static gint ett_lbmc_ctxinfo = -1; +static gint ett_lbmc_ctxinfo_flags = -1; +static gint ett_lbmc_ume_pser = -1; +static gint ett_lbmc_ume_pser_flags = -1; +static gint ett_lbmc_domain = -1; +static gint ett_lbmc_domain_flags = -1; +static gint ett_lbmc_tnwg_capabilities = -1; +static gint ett_lbmc_tnwg_capabilities_flags = -1; +static gint ett_lbmc_tnwg_capabilities_capabilities1 = -1; +static gint ett_lbmc_tnwg_capabilities_capabilities3 = -1; +static gint ett_lbmc_patidx = -1; +static gint ett_lbmc_patidx_flags = -1; +static gint ett_lbmc_ume_client_lifetime = -1; +static gint ett_lbmc_ume_client_lifetime_flags = -1; +static gint ett_lbmc_ume_sid = -1; +static gint ett_lbmc_ume_sid_flags = -1; +static gint ett_lbmc_umq_idx_cmd = -1; +static gint ett_lbmc_umq_idx_cmd_flags = -1; +static gint ett_lbmc_umq_idx_cmd_stop_assign = -1; +static gint ett_lbmc_umq_idx_cmd_start_assign = -1; +static gint ett_lbmc_umq_idx_cmd_release_assign = -1; +static gint ett_lbmc_umq_idx_cmd_release_assign_flags = -1; +static gint ett_lbmc_umq_idx_cmd_ulb_stop_assign = -1; +static gint ett_lbmc_umq_idx_cmd_ulb_start_assign = -1; +static gint ett_lbmc_umq_idx_cmd_ulb_release_assign = -1; +static gint ett_lbmc_umq_idx_cmd_ulb_release_assign_flags = -1; +static gint ett_lbmc_umq_idx_cmd_reserve_assign = -1; +static gint ett_lbmc_umq_idx_cmd_reserve_assign_flags = -1; +static gint ett_lbmc_umq_idx_cmd_ulb_reserve_assign = -1; +static gint ett_lbmc_umq_idx_cmd_ulb_reserve_assign_flags = -1; +static gint ett_lbmc_umq_idx_cmd_resp = -1; +static gint ett_lbmc_umq_idx_cmd_resp_flags = -1; +static gint ett_lbmc_umq_idx_cmd_resp_err = -1; +static gint ett_lbmc_umq_idx_cmd_resp_stop_assign = -1; +static gint ett_lbmc_umq_idx_cmd_resp_start_assign = -1; +static gint ett_lbmc_umq_idx_cmd_resp_release_assign = -1; +static gint ett_lbmc_umq_idx_cmd_resp_ulb_stop_assign = -1; +static gint ett_lbmc_umq_idx_cmd_resp_ulb_start_assign = -1; +static gint ett_lbmc_umq_idx_cmd_resp_ulb_release_assign = -1; +static gint ett_lbmc_umq_idx_cmd_resp_reserve_assign = -1; +static gint ett_lbmc_umq_idx_cmd_resp_reserve_assign_flags = -1; +static gint ett_lbmc_umq_idx_cmd_resp_ulb_reserve_assign = -1; +static gint ett_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags = -1; +static gint ett_lbmc_odomain = -1; +static gint ett_lbmc_odomain_flags = -1; +static gint ett_lbmc_stream = -1; +static gint ett_lbmc_stream_flags = -1; +static gint ett_lbmc_topic_md_interest = -1; +static gint ett_lbmc_topic_md_interest_flags = -1; +static gint ett_lbmc_pattern_md_interest = -1; +static gint ett_lbmc_pattern_md_interest_flags = -1; +static gint ett_lbmc_lji_req = -1; +static gint ett_lbmc_lji_req_flags = -1; +static gint ett_lbmc_tnwg_ka = -1; +static gint ett_lbmc_tnwg_ka_flags = -1; +static gint ett_lbmc_ume_receiver_keepalive = -1; +static gint ett_lbmc_ume_receiver_keepalive_flags = -1; +static gint ett_lbmc_umq_cmd = -1; +static gint ett_lbmc_umq_cmd_flags = -1; +static gint ett_lbmc_umq_cmd_topic_list = -1; +static gint ett_lbmc_umq_cmd_msg_retrieve = -1; +static gint ett_lbmc_umq_cmd_msg_retrieve_entry = -1; +static gint ett_lbmc_umq_cmd_msg_list = -1; +static gint ett_lbmc_umq_cmd_resp = -1; +static gint ett_lbmc_umq_cmd_resp_flags = -1; +static gint ett_lbmc_umq_cmd_resp_msg_retrieve = -1; +static gint ett_lbmc_umq_cmd_resp_xmsg_retrieve = -1; +static gint ett_lbmc_umq_cmd_resp_xmsg_retrieve_entry = -1; +static gint ett_lbmc_umq_cmd_resp_msg_list = -1; +static gint ett_lbmc_umq_cmd_resp_xmsg_list = -1; +static gint ett_lbmc_umq_cmd_resp_xmsg_list_entry = -1; +static gint ett_lbmc_umq_cmd_resp_topic_list = -1; +static gint ett_lbmc_umq_cmd_resp_topic_list_topic_entry = -1; +static gint ett_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry = -1; +static gint ett_lbmc_umq_cmd_resp_err = -1; +static gint ett_lbmc_sri_req = -1; +static gint ett_lbmc_sri_req_flags = -1; +static gint ett_lbmc_ume_store_domain = -1; +static gint ett_lbmc_ume_store_domain_flags = -1; +static gint ett_lbmc_sri = -1; +static gint ett_lbmc_sri_flags = -1; +static gint ett_lbmc_route_info = -1; +static gint ett_lbmc_route_info_flags = -1; +static gint ett_lbmc_route_info_neighbor = -1; +static gint ett_lbmc_route_info_neighbor_flags = -1; +static gint ett_lbmc_gateway_name = -1; +static gint ett_lbmc_gateway_name_flags = -1; +static gint ett_lbmc_auth_request = -1; +static gint ett_lbmc_auth_request_flags = -1; +static gint ett_lbmc_auth_challenge = -1; +static gint ett_lbmc_auth_challenge_flags = -1; +static gint ett_lbmc_auth_challenge_rsp = -1; +static gint ett_lbmc_auth_challenge_rsp_flags = -1; +static gint ett_lbmc_auth_result = -1; +static gint ett_lbmc_auth_result_flags = -1; +static gint ett_lbmc_auth_unknown = -1; +static gint ett_lbmc_hmac = -1; +static gint ett_lbmc_hmac_flags = -1; +static gint ett_lbmc_umq_sid = -1; +static gint ett_lbmc_umq_sid_flags = -1; +static gint ett_lbmc_destination = -1; +static gint ett_lbmc_destination_flags = -1; +static gint ett_lbmc_topic_idx = -1; +static gint ett_lbmc_topic_idx_flags = -1; +static gint ett_lbmc_topic_source = -1; +static gint ett_lbmc_topic_source_flags = -1; +static gint ett_lbmc_topic_source_exfunc = -1; +static gint ett_lbmc_topic_source_exfunc_flags = -1; +static gint ett_lbmc_topic_source_exfunc_functionality_flags = -1; +static gint ett_lbmc_ume_store_ext = -1; +static gint ett_lbmc_ume_store_ext_flags = -1; +static gint ett_lbmc_ume_psrc_election_token = -1; +static gint ett_lbmc_ume_psrc_election_token_flags = -1; +static gint ett_lbmc_tcp_sid = -1; +static gint ett_lbmc_tcp_sid_flags = -1; +static gint ett_lbmc_extopt = -1; +static gint ett_lbmc_extopt_flags = -1; +static gint ett_lbmc_extopt_cfgopt = -1; +static gint ett_lbmc_extopt_reassembled_data = -1; +static gint ett_lbmc_extopt_reassembled_data_cfgopt = -1; +static gint ett_lbm_msg_properties = -1; +static gint ett_lbm_msg_properties_data = -1; +static gint ett_lbm_msg_properties_data_vertype = -1; +static gint ett_lbm_msg_properties_hdr = -1; +static gint ett_lbmc_unhandled_hdr = -1; +static gint ett_lbm_stream = -1; +static gint ett_lbmc_reassembly = -1; +static gint ett_unknown = -1; +static gint ett_msg_data = -1; +static gint ett_msgprop_data = -1; + +/* Expert info handles */ +static expert_field ei_lbmc_analysis_length_incorrect = EI_INIT; +static expert_field ei_lbmc_analysis_zero_length = EI_INIT; +static expert_field ei_lbmc_analysis_tsni = EI_INIT; +static expert_field ei_lbmc_analysis_invalid_value = EI_INIT; +static expert_field ei_lbmc_analysis_no_reassembly = EI_INIT; +static expert_field ei_lbmc_analysis_invalid_offset = EI_INIT; +static expert_field ei_lbmc_analysis_missing_reassembly_frame = EI_INIT; +static expert_field ei_lbmc_analysis_invalid_fragment = EI_INIT; + +/* Extended option reassembly structures. */ +#define LBMC_EXTOPT_REASSEMBLED_DATA_MAX_LEN 65536 +typedef struct +{ + gboolean reassembly_in_progress; + guint16 subtype; + int len; + gchar data[LBMC_EXTOPT_REASSEMBLED_DATA_MAX_LEN]; +} lbmc_extopt_reassembled_data_t; + +/* Stream structures. */ +typedef struct +{ + gboolean set; + guint32 stream_id; + guint32 sqn; + gchar ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmc_stream_info_t; + +typedef struct +{ + gboolean set; + gchar ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmc_ctxinst_info_t; + +typedef struct +{ + gboolean set; + lbm_uim_stream_destination_t endpoint_a; + lbm_uim_stream_destination_t endpoint_b; +} lbmc_destination_info_t; + +/* TCP session ID structures. */ +typedef struct +{ + gboolean set; + guint32 session_id; +} lbmc_tcp_sid_info_t; + +/*----------------------------------------------------------------------------*/ +/* Message reassembly. */ +/*----------------------------------------------------------------------------*/ +#define LBMC_MESSAGE_KEY_ELEMENT_COUNT 5 +#define LBMC_MESSAGE_KEY_ELEMENT_CHANNEL_HIGH 0 +#define LBMC_MESSAGE_KEY_ELEMENT_CHANNEL_LOW 1 +#define LBMC_MESSAGE_KEY_ELEMENT_ADDR 2 +#define LBMC_MESSAGE_KEY_ELEMENT_PORT 3 +#define LBMC_MESSAGE_KEY_ELEMENT_FIRST_SQN 4 + +static wmem_tree_t * lbmc_message_table = NULL; + +typedef struct +{ + int fragment_found; + guint32 first_sqn; + guint32 offset; + guint32 len; +} lbmc_fragment_info_t; + +struct lbmc_fragment_entry_t_stct; +typedef struct lbmc_fragment_entry_t_stct lbmc_fragment_entry_t; +struct lbmc_fragment_entry_t_stct +{ + lbmc_fragment_entry_t * prev; + lbmc_fragment_entry_t * next; + guint32 fragment_start; + guint32 fragment_len; + guint32 frame; + int frame_offset; + gchar * data; +}; + +typedef struct +{ + guint64 channel; + address addr; + guint16 port; + guint32 first_sqn; + guint32 fragment_count; + guint32 total_len; + guint32 accumulated_len; + guint32 msgprop_len; + gboolean data_is_umq_cmd_resp; + lbmc_fragment_entry_t * entry; + guint32 reassembled_frame; + tvbuff_t * reassembled_data; + tvbuff_t * data; + tvbuff_t * msgprop; +} lbmc_message_entry_t; + +static void lbmc_message_build_key(guint32 * key_value, wmem_tree_key_t * key, const lbmc_message_entry_t * message) +{ + guint32 val; + + key_value[LBMC_MESSAGE_KEY_ELEMENT_CHANNEL_HIGH] = (guint32) ((message->channel >> 32) & 0xffffffff); + key_value[LBMC_MESSAGE_KEY_ELEMENT_CHANNEL_LOW] = (guint32) ((message->channel & 0xffffffff) >> 32); + memcpy((void *) &val, (void *) message->addr.data, sizeof(guint32)); + key_value[LBMC_MESSAGE_KEY_ELEMENT_ADDR] = val; + key_value[LBMC_MESSAGE_KEY_ELEMENT_PORT] = (guint32) message->port; + key_value[LBMC_MESSAGE_KEY_ELEMENT_FIRST_SQN] = message->first_sqn; + key[0].length = LBMC_MESSAGE_KEY_ELEMENT_COUNT; + key[0].key = key_value; + key[1].length = 0; + key[1].key = NULL; +} + +static lbmc_message_entry_t * lbmc_message_find(guint64 channel, const address * dest_address, guint16 port, lbmc_fragment_info_t * info) +{ + lbmc_message_entry_t key; + lbmc_message_entry_t * entry = NULL; + guint32 keyval[LBMC_MESSAGE_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + memset((void *)&key, 0, sizeof(lbmc_message_entry_t)); + key.channel = channel; + COPY_ADDRESS_SHALLOW(&(key.addr), dest_address); + key.port = port; + key.first_sqn = info->first_sqn; + lbmc_message_build_key(keyval, tkey, &key); + entry = (lbmc_message_entry_t *) wmem_tree_lookup32_array(lbmc_message_table, tkey); + return (entry); +} + +static lbmc_message_entry_t * lbmc_message_create(guint64 channel, const address * dest_address, guint16 port, lbmc_fragment_info_t * info, guint32 msgprop_length) +{ + lbmc_message_entry_t * entry = NULL; + guint32 keyval[LBMC_MESSAGE_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbmc_message_find(channel, dest_address, port, info); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbmc_message_entry_t); + entry->channel = channel; + SE_COPY_ADDRESS(&(entry->addr), dest_address); + entry->port = port; + entry->first_sqn = info->first_sqn; + entry->fragment_count = 0; + entry->total_len = info->len; + entry->accumulated_len = 0; + entry->msgprop_len = msgprop_length; + entry->data_is_umq_cmd_resp = FALSE; + entry->entry = NULL; + entry->reassembled_frame = 0; + entry->reassembled_data = NULL; + entry->data = NULL; + entry->msgprop = NULL; + lbmc_message_build_key(keyval, tkey, entry); + wmem_tree_insert32_array(lbmc_message_table, tkey, (void *) entry); + return (entry); +} + +static void lbmc_message_add_fragment(lbmc_message_entry_t * message, tvbuff_t * tvb, int data_offset, lbmc_fragment_info_t * info, guint32 frame) +{ + lbmc_fragment_entry_t * frag = NULL; + lbmc_fragment_entry_t * cur = NULL; + + if ((tvb == NULL) || (info == NULL) || (message == NULL)) + { + return; + } + if (message->entry == NULL) + { + frag = wmem_new(wmem_file_scope(), lbmc_fragment_entry_t); + if (frag == NULL) + { + return; + } + frag->prev = NULL; + frag->next = NULL; + message->entry = frag; + } + else + { + cur = message->entry; + while (cur != NULL) + { + if (info->offset == cur->fragment_start) + { + /* Already have this fragment */ + return; + } + if (info->offset < cur->fragment_start) + { + /* Fragment goes after cur->prev */ + cur = cur->prev; + break; + } + if (cur->next == NULL) + { + /* Fragment goes after cur */ + break; + } + cur = cur->next; + } + frag = wmem_new(wmem_file_scope(), lbmc_fragment_entry_t); + if (frag == NULL) + { + return; + } + if (cur == NULL) + { + frag->prev = NULL; + frag->next = message->entry; + message->entry->prev = frag; + message->entry = frag; + } + else + { + frag->prev = cur; + frag->next = cur->next; + cur->next = frag; + if (frag->next != NULL) + { + frag->next->prev = frag; + } + } + } + frag->fragment_start = info->offset; + frag->fragment_len = tvb_reported_length_remaining(tvb, data_offset); + frag->data = (gchar *) tvb_memdup(wmem_file_scope(), tvb, data_offset, frag->fragment_len); + frag->frame = frame; + frag->frame_offset = data_offset; + message->accumulated_len += frag->fragment_len; + message->fragment_count++; +} + +/*----------------------------------------------------------------------------*/ +/* Message table/reassembly functions. */ +/*----------------------------------------------------------------------------*/ +static void lbmc_init_extopt_reassembled_data(lbmc_extopt_reassembled_data_t * reassembly) +{ + reassembly->reassembly_in_progress = FALSE; + reassembly->subtype = 0; + reassembly->len = 0; + memset((void *)&(reassembly->data), 0, sizeof(reassembly->data)); +} + +/*----------------------------------------------------------------------------*/ +/* Dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_nhdr_frag(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmc_fragment_info_t * frag_info) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_frag, tvb, offset, L_LBMC_FRAG_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_frag); + proto_tree_add_item(subtree, hf_lbmc_frag_next_hdr, tvb, offset + O_LBMC_FRAG_HDR_T_NEXT_HDR, L_LBMC_FRAG_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_frag_hdr_len, tvb, offset + O_LBMC_FRAG_HDR_T_HDR_LEN, L_LBMC_FRAG_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_FRAG_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_frag_flags, tvb, offset + O_LBMC_FRAG_HDR_T_FLAGS, L_LBMC_FRAG_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_frag); + proto_tree_add_item(flags_tree, hf_lbmc_frag_flags_ignore, tvb, offset + O_LBMC_FRAG_HDR_T_FLAGS, L_LBMC_FRAG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_frag_first_sqn, tvb, offset + O_LBMC_FRAG_HDR_T_FIRST_SQN, L_LBMC_FRAG_HDR_T_FIRST_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_frag_offset, tvb, offset + O_LBMC_FRAG_HDR_T_OFFSET, L_LBMC_FRAG_HDR_T_OFFSET, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_frag_len, tvb, offset + O_LBMC_FRAG_HDR_T_LEN, L_LBMC_FRAG_HDR_T_LEN, ENC_BIG_ENDIAN); + if (frag_info != NULL) + { + frag_info->fragment_found = 1; + frag_info->first_sqn = tvb_get_ntohl(tvb, offset + O_LBMC_FRAG_HDR_T_FIRST_SQN); + frag_info->offset = tvb_get_ntohl(tvb, offset + O_LBMC_FRAG_HDR_T_OFFSET); + frag_info->len = tvb_get_ntohl(tvb, offset + O_LBMC_FRAG_HDR_T_LEN); + } + return (L_LBMC_FRAG_HDR_T); +} + +static int dissect_nhdr_batch(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_batch, tvb, offset, L_LBMC_BATCH_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_batch); + proto_tree_add_item(subtree, hf_lbmc_batch_next_hdr, tvb, offset + O_LBMC_BATCH_HDR_T_NEXT_HDR, L_LBMC_BATCH_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_batch_hdr_len, tvb, offset + O_LBMC_BATCH_HDR_T_HDR_LEN, L_LBMC_BATCH_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_BATCH_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_batch_flags, tvb, offset + O_LBMC_BATCH_HDR_T_FLAGS, L_LBMC_BATCH_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_batch_flags); + proto_tree_add_item(flags_tree, hf_lbmc_batch_flags_ignore, tvb, offset + O_LBMC_BATCH_HDR_T_FLAGS, L_LBMC_BATCH_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_batch_flags_batch_start, tvb, offset + O_LBMC_BATCH_HDR_T_FLAGS, L_LBMC_BATCH_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_batch_flags_batch_end, tvb, offset + O_LBMC_BATCH_HDR_T_FLAGS, L_LBMC_BATCH_HDR_T_FLAGS, ENC_BIG_ENDIAN); + return (L_LBMC_BATCH_HDR_T); +} + +static int dissect_nhdr_request(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_tcp_request, tvb, offset, L_LBMC_TCP_REQUEST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_tcp_request); + proto_tree_add_item(subtree, hf_lbmc_tcp_request_next_hdr, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_NEXT_HDR, L_LBMC_TCP_REQUEST_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tcp_request_hdr_len, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_HDR_LEN, L_LBMC_TCP_REQUEST_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_tcp_request_flags, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_FLAGS, L_LBMC_TCP_REQUEST_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_tcp_request_flags); + proto_tree_add_item(flags_tree, hf_lbmc_tcp_request_flags_ignore, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_FLAGS, L_LBMC_TCP_REQUEST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tcp_request_transport, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_TRANSPORT, L_LBMC_TCP_REQUEST_HDR_T_TRANSPORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tcp_request_qidx, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_QIDX, L_LBMC_TCP_REQUEST_HDR_T_QIDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tcp_request_port, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_PORT, L_LBMC_TCP_REQUEST_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tcp_request_reserved, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_RESERVED, L_LBMC_TCP_REQUEST_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tcp_request_ipaddr, tvb, offset + O_LBMC_TCP_REQUEST_HDR_T_IPADDR, L_LBMC_TCP_REQUEST_HDR_T_IPADDR, ENC_BIG_ENDIAN); + return (L_LBMC_TCP_REQUEST_HDR_T); +} + +static int dissect_nhdr_topicname(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_TOPICNAME_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_topicname, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_topicname); + proto_tree_add_item(subtree, hf_lbmc_topicname_next_hdr, tvb, offset + O_LBMC_TOPICNAME_HDR_T_NEXT_HDR, L_LBMC_TOPICNAME_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topicname_hdr_len, tvb, offset + O_LBMC_TOPICNAME_HDR_T_HDR_LEN, L_LBMC_TOPICNAME_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_TOPICNAME_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_topicname_flags, tvb, offset + O_LBMC_TOPICNAME_HDR_T_FLAGS, L_LBMC_TOPICNAME_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_topicname_flags); + proto_tree_add_item(flags_tree, hf_lbmc_topicname_flags_ignore, tvb, offset + O_LBMC_TOPICNAME_HDR_T_FLAGS, L_LBMC_TOPICNAME_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topicname_topicname, tvb, offset + O_LBMC_TOPICNAME_HDR_T_FLAGS + L_LBMC_TOPICNAME_HDR_T_FLAGS, (gint)(hdrlen - L_LBMC_BASIC_HDR_T), ENC_ASCII|ENC_NA); + return ((int)hdrlen); +} + +static int dissect_nhdr_apphdr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 datalen = 0; + proto_item * code_item = NULL; + proto_tree * code_tree = NULL; + guint16 code = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_APPHDR_HDR_T_HDR_LEN); + datalen = hdrlen - (O_LBMC_APPHDR_HDR_T_CODE + L_LBMC_APPHDR_HDR_T_CODE); + subtree_item = proto_tree_add_item(tree, hf_lbmc_apphdr, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_apphdr); + proto_tree_add_item(subtree, hf_lbmc_apphdr_next_hdr, tvb, offset + O_LBMC_APPHDR_HDR_T_NEXT_HDR, L_LBMC_APPHDR_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_hdr_len, tvb, offset + O_LBMC_APPHDR_HDR_T_HDR_LEN, L_LBMC_APPHDR_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + code = tvb_get_ntohs(tvb, offset + O_LBMC_APPHDR_HDR_T_CODE); + code_item = proto_tree_add_none_format(subtree, hf_lbmc_apphdr_code, tvb, offset + O_LBMC_APPHDR_HDR_T_CODE, L_LBMC_APPHDR_HDR_T_CODE, "Code: 0x%04x", code); + code_tree = proto_item_add_subtree(code_item, ett_lbmc_apphdr_code); + proto_tree_add_item(code_tree, hf_lbmc_apphdr_code_ignore, tvb, offset + O_LBMC_APPHDR_HDR_T_CODE, L_LBMC_APPHDR_HDR_T_CODE, ENC_BIG_ENDIAN); + proto_tree_add_item(code_tree, hf_lbmc_apphdr_code_code, tvb, offset + O_LBMC_APPHDR_HDR_T_CODE, L_LBMC_APPHDR_HDR_T_CODE, ENC_BIG_ENDIAN); + proto_tree_add_none_format(subtree, hf_lbmc_apphdr_data, tvb, O_LBMC_APPHDR_HDR_T_CODE + L_LBMC_APPHDR_HDR_T_CODE, datalen, "Data (%u bytes)", datalen); + return ((int)hdrlen); +} + +static int dissect_nhdr_apphdr_chain_element(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, guint8 element) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 datalen = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_APPHDR_CHAIN_ELEMENT_T_HDR_LEN); + datalen = hdrlen - L_LBMC_APPHDR_CHAIN_ELEMENT_T_MIN; + subtree_item = proto_tree_add_none_format(tree, hf_lbmc_apphdr_chain_element, tvb, offset, (gint)hdrlen, "%s element", val_to_str(element, lbmc_apphdr_chain_type, "Unknown (0x%02x)")); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_apphdr_chain_element); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_element_next_hdr, tvb, offset + O_LBMC_APPHDR_CHAIN_ELEMENT_T_NEXT_HDR, L_LBMC_APPHDR_CHAIN_ELEMENT_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_element_hdr_len, tvb, offset + O_LBMC_APPHDR_CHAIN_ELEMENT_T_HDR_LEN, L_LBMC_APPHDR_CHAIN_ELEMENT_T_HDR_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_element_res, tvb, offset + O_LBMC_APPHDR_CHAIN_ELEMENT_T_RES, L_LBMC_APPHDR_CHAIN_ELEMENT_T_RES, ENC_BIG_ENDIAN); + if (datalen > 0) + { + proto_tree_add_none_format(subtree, hf_lbmc_apphdr_chain_element_data, tvb, offset + O_LBMC_APPHDR_CHAIN_ELEMENT_T_RES + L_LBMC_APPHDR_CHAIN_ELEMENT_T_RES, datalen, "Data (%u bytes)", datalen); + } + return ((int)hdrlen); +} + +static int dissect_nhdr_apphdr_chain_msgprop_element(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, guint8 element, guint32 * msg_prop_len) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint32 len; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_HDR_LEN); + subtree_item = proto_tree_add_none_format(tree, hf_lbmc_apphdr_chain_msgprop, tvb, offset, (gint)hdrlen, "%s element", val_to_str(element, lbmc_apphdr_chain_type, "Unknown (0x%02x)")); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_apphdr_chain_msgprop); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_msgprop_next_hdr, tvb, offset + O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_NEXT_HDR, L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_msgprop_hdr_len, tvb, offset + O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_HDR_LEN, L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_HDR_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_msgprop_res, tvb, offset + O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_RES, L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_msgprop_len, tvb, offset + O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_LEN, L_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_LEN, ENC_BIG_ENDIAN); + len = tvb_get_ntohl(tvb, offset + O_LBMC_APPHDR_CHAIN_MSGPROP_ELEMENT_T_LEN); + *msg_prop_len += len; + return ((int)hdrlen); +} + +static int dissect_nhdr_apphdr_chain(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, guint32 * msg_prop_len) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 datalen = 0; + int elem_offset = 0; + int elem_len = 0; + guint8 elem = 0; + int len_dissected = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_APPHDR_CHAIN_HDR_T_HDR_LEN); + datalen = hdrlen - L_LBMC_APPHDR_CHAIN_HDR_T; + subtree_item = proto_tree_add_item(tree, hf_lbmc_apphdr_chain, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_apphdr_chain); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_next_hdr, tvb, offset + O_LBMC_APPHDR_CHAIN_HDR_T_NEXT_HDR, L_LBMC_APPHDR_CHAIN_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_hdr_len, tvb, offset + O_LBMC_APPHDR_CHAIN_HDR_T_HDR_LEN, L_LBMC_APPHDR_CHAIN_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_res, tvb, offset + O_LBMC_APPHDR_CHAIN_HDR_T_RES, L_LBMC_APPHDR_CHAIN_HDR_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_apphdr_chain_first_chain_hdr, tvb, offset + O_LBMC_APPHDR_CHAIN_HDR_T_FIRST_CHAIN_HDR, L_LBMC_APPHDR_CHAIN_HDR_T_FIRST_CHAIN_HDR, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_APPHDR_CHAIN_HDR_T; + elem_offset = offset + L_LBMC_APPHDR_CHAIN_HDR_T; + elem = tvb_get_guint8(tvb, offset + O_LBMC_APPHDR_CHAIN_HDR_T_FIRST_CHAIN_HDR); + while (datalen > 0) + { + switch (elem) + { + case LBM_CHAIN_ELEM_PROPERTIES_LENGTH: + elem_len = dissect_nhdr_apphdr_chain_msgprop_element(tvb, elem_offset, pinfo, subtree, elem, msg_prop_len); + break; + default: + elem_len = dissect_nhdr_apphdr_chain_element(tvb, elem_offset, pinfo, subtree, elem); + break; + } + elem_offset += elem_len; + datalen -= elem_len; + len_dissected += elem_len; + if (datalen >= L_LBMC_APPHDR_CHAIN_ELEMENT_T_MIN) + { + elem = tvb_get_guint8(tvb, elem_offset + O_LBMC_APPHDR_CHAIN_ELEMENT_T_NEXT_HDR); + } + } + return (len_dissected); +} + +static int dissect_nhdr_umq_msgid(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_msgid, tvb, offset, L_LBMC_UMQ_MSGID_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_msgid); + proto_tree_add_item(subtree, hf_lbmc_umq_msgid_next_hdr, tvb, offset + O_LBMC_UMQ_MSGID_HDR_T_NEXT_HDR, L_LBMC_UMQ_MSGID_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_msgid_hdr_len, tvb, offset + O_LBMC_UMQ_MSGID_HDR_T_HDR_LEN, L_LBMC_UMQ_MSGID_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_UMQ_MSGID_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_msgid_flags, tvb, offset + O_LBMC_UMQ_MSGID_HDR_T_FLAGS, L_LBMC_UMQ_MSGID_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_msgid_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_msgid_flags_ignore, tvb, offset + O_LBMC_UMQ_MSGID_HDR_T_FLAGS, L_LBMC_UMQ_MSGID_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_msgid_msgid_regid, tvb, offset + O_LBMC_UMQ_MSGID_HDR_T_MSGID_REGID, L_LBMC_UMQ_MSGID_HDR_T_MSGID_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_msgid_msgid_stamp, tvb, offset + O_LBMC_UMQ_MSGID_HDR_T_MSGID_STAMP, L_LBMC_UMQ_MSGID_HDR_T_MSGID_STAMP, ENC_BIG_ENDIAN); + return (L_LBMC_UMQ_MSGID_HDR_T); +} + +static int dissect_nhdr_umq_sqd_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, gboolean * data_is_response) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_sqd_rcv, tvb, offset, L_LBMC_UMQ_SQD_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_sqd_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_sqd_rcv_next_hdr, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_NEXT_HDR, L_LBMC_UMQ_SQD_RCV_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_sqd_rcv_hdr_len, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_HDR_LEN, L_LBMC_UMQ_SQD_RCV_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_sqd_rcv_flags, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_sqd_rcv_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_sqd_rcv_flags_ignore, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_sqd_rcv_flags_r_flag, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_sqd_rcv_flags_s_flag, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_sqd_rcv_flags_re_flag, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_sqd_rcv_flags_eoi_flag, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_sqd_rcv_flags_boi_flag, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_sqd_rcv_queue_id, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_QUEUE_ID, L_LBMC_UMQ_SQD_RCV_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_sqd_rcv_queue_ver, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_QUEUE_VER, L_LBMC_UMQ_SQD_RCV_HDR_T_QUEUE_VER, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_sqd_rcv_rcr_idx, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_RCR_IDX, L_LBMC_UMQ_SQD_RCV_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_sqd_rcv_assign_id, tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_ASSIGN_ID, L_LBMC_UMQ_SQD_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + if (data_is_response != NULL) + { + guint32 rcr_index; + + rcr_index = tvb_get_ntohl(tvb, offset + O_LBMC_UMQ_SQD_RCV_HDR_T_RCR_IDX); + if (rcr_index == 0) + { + *data_is_response = TRUE; + } + else + { + *data_is_response = FALSE; + } + } + return (L_LBMC_UMQ_SQD_RCV_HDR_T); +} + +static int dissect_nhdr_umq_resub(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_resub, tvb, offset, L_LBMC_UMQ_RESUB_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_resub); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_next_hdr, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_NEXT_HDR, L_LBMC_UMQ_RESUB_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_hdr_len, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_HDR_LEN, L_LBMC_UMQ_RESUB_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_resub_flags, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_FLAGS, L_LBMC_UMQ_RESUB_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_resub_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_resub_flags_ignore, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_FLAGS, L_LBMC_UMQ_RESUB_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_resub_flags_q_flag, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_FLAGS, L_LBMC_UMQ_RESUB_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_rcr_idx, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_RCR_IDX, L_LBMC_UMQ_RESUB_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_ip, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_RESP_IP, L_LBMC_UMQ_RESUB_HDR_T_RESP_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_port, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_RESP_PORT, L_LBMC_UMQ_RESUB_HDR_T_RESP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_appset_idx, tvb, offset + O_LBMC_UMQ_RESUB_HDR_T_APPSET_IDX, L_LBMC_UMQ_RESUB_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + return (L_LBMC_UMQ_RESUB_HDR_T); +} + +static int dissect_nhdr_otid(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_otid, tvb, offset, L_LBMC_OTID_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_otid); + proto_tree_add_item(subtree, hf_lbmc_otid_next_hdr, tvb, offset + O_LBMC_OTID_HDR_T_NEXT_HDR, L_LBMC_OTID_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_otid_hdr_len, tvb, offset + O_LBMC_OTID_HDR_T_HDR_LEN, L_LBMC_OTID_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_OTID_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_otid_flags, tvb, offset + O_LBMC_OTID_HDR_T_FLAGS, L_LBMC_OTID_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_otid_flags); + proto_tree_add_item(flags_tree, hf_lbmc_otid_flags_ignore, tvb, offset + O_LBMC_OTID_HDR_T_FLAGS, L_LBMC_OTID_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_otid_otid, tvb, offset + O_LBMC_OTID_HDR_T_OTID, L_LBMC_OTID_HDR_T_OTID, ENC_NA); + return (L_LBMC_OTID_HDR_T); +} + +static void dissect_ctxinst(tvbuff_t * tvb, int offset, proto_tree * tree, lbmc_ctxinst_info_t * info) +{ + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + proto_tree_add_item(tree, hf_lbmc_ctxinst_next_hdr, tvb, offset + O_LBMC_CTXINST_HDR_T_NEXT_HDR, L_LBMC_CTXINST_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmc_ctxinst_hdr_len, tvb, offset + O_LBMC_CTXINST_HDR_T_HDR_LEN, L_LBMC_CTXINST_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CTXINST_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(tree, hf_lbmc_ctxinst_flags, tvb, offset + O_LBMC_CTXINST_HDR_T_FLAGS, L_LBMC_CTXINST_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ctxinst_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinst_flags_ignore, tvb, offset + O_LBMC_CTXINST_HDR_T_FLAGS, L_LBMC_CTXINST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmc_ctxinst_ctxinst, tvb, offset + O_LBMC_CTXINST_HDR_T_CTXINST, L_LBMC_CTXINST_HDR_T_CTXINST, ENC_NA); + if (info != NULL) + { + info->set = TRUE; + tvb_memcpy(tvb, (void *)&(info->ctxinst), offset + O_LBMC_CTXINST_HDR_T_CTXINST, L_LBMC_CTXINST_HDR_T_CTXINST); + } +} + +static int dissect_nhdr_ctxinstd(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmc_ctxinst_info_t * info) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ctxinstd, tvb, offset, L_LBMC_CTXINST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ctxinstd); + dissect_ctxinst(tvb, offset, subtree, info); + return (L_LBMC_CTXINST_HDR_T); +} + +static int dissect_nhdr_ctxinstr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmc_ctxinst_info_t * info) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ctxinstr, tvb, offset, L_LBMC_CTXINST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ctxinstr); + dissect_ctxinst(tvb, offset, subtree, info); + return (L_LBMC_CTXINST_HDR_T); +} + +static int dissect_nhdr_ctxinst(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmc_ctxinst_info_t * info) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ctxinst, tvb, offset, L_LBMC_CTXINST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ctxinst); + dissect_ctxinst(tvb, offset, subtree, info); + return (L_LBMC_CTXINST_HDR_T); +} + +static int dissect_nhdr_srcidx(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_srcidx, tvb, offset, L_LBMC_SRCIDX_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_srcidx); + proto_tree_add_item(subtree, hf_lbmc_srcidx_next_hdr, tvb, offset + O_LBMC_SRCIDX_HDR_T_NEXT_HDR, L_LBMC_SRCIDX_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_srcidx_hdr_len, tvb, offset + O_LBMC_SRCIDX_HDR_T_HDR_LEN, L_LBMC_SRCIDX_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_SRCIDX_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_srcidx_flags, tvb, offset + O_LBMC_SRCIDX_HDR_T_FLAGS, L_LBMC_SRCIDX_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_srcidx_flags); + proto_tree_add_item(flags_tree, hf_lbmc_srcidx_flags_ignore, tvb, offset + O_LBMC_SRCIDX_HDR_T_FLAGS, L_LBMC_SRCIDX_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_srcidx_srcidx, tvb, offset + O_LBMC_SRCIDX_HDR_T_SRCIDX, L_LBMC_SRCIDX_HDR_T_SRCIDX, ENC_BIG_ENDIAN); + return (L_LBMC_SRCIDX_HDR_T); +} + +static int dissect_nhdr_umq_ulb_msg(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ulb_msg, tvb, offset, L_LBMC_UMQ_ULB_MSG_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ulb_msg); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_msg_next_hdr, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_NEXT_HDR, L_LBMC_UMQ_ULB_MSG_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_msg_hdr_len, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_HDR_LEN, L_LBMC_UMQ_ULB_MSG_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_ulb_msg_flags, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS, L_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_ulb_msg); + proto_tree_add_item(flags_tree, hf_lbmc_umq_ulb_msg_flags_ignore, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS, L_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_ulb_msg_flags_a_flag, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS, L_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_ulb_msg_flags_r_flag, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS, L_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_msg_queue_id, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_QUEUE_ID, L_LBMC_UMQ_ULB_MSG_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_msg_ulb_src_id, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_ULB_SRC_ID, L_LBMC_UMQ_ULB_MSG_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_msg_assign_id, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_ASSIGN_ID, L_LBMC_UMQ_ULB_MSG_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_msg_appset_idx, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_APPSET_IDX, L_LBMC_UMQ_ULB_MSG_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_msg_num_ras, tvb, offset + O_LBMC_UMQ_ULB_MSG_HDR_T_NUM_RAS, L_LBMC_UMQ_ULB_MSG_HDR_T_NUM_RAS, ENC_BIG_ENDIAN); + return (L_LBMC_UMQ_ULB_MSG_HDR_T); +} + +static int dissect_nhdr_ssf_init(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ssf_init, tvb, offset, L_LBMC_CNTL_SSF_INIT_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ssf_init); + proto_tree_add_item(subtree, hf_lbmc_ssf_init_next_hdr, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_NEXT_HDR, L_LBMC_CNTL_SSF_INIT_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_init_hdr_len, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_HDR_LEN, L_LBMC_CNTL_SSF_INIT_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ssf_init_flags, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS, L_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ssf_init); + proto_tree_add_item(flags_tree, hf_lbmc_ssf_init_flags_ignore, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS, L_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ssf_init_flags_default_exclusions, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS, L_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ssf_init_flags_default_inclusions, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS, L_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_init_transport, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_TRANSPORT, L_LBMC_CNTL_SSF_INIT_HDR_T_TRANSPORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_init_transport_idx, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_SSF_INIT_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_init_client_idx, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_CLIENT_IDX, L_LBMC_CNTL_SSF_INIT_HDR_T_CLIENT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_init_ssf_port, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_SSF_PORT, L_LBMC_CNTL_SSF_INIT_HDR_T_SSF_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_init_res, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_RES, L_LBMC_CNTL_SSF_INIT_HDR_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_init_ssf_ip, tvb, offset + O_LBMC_CNTL_SSF_INIT_HDR_T_SSF_IP, L_LBMC_CNTL_SSF_INIT_HDR_T_SSF_IP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_SSF_INIT_HDR_T); +} + +static int dissect_nhdr_ssf_creq(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ssf_creq, tvb, offset, L_LBMC_CNTL_SSF_CREQ_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ssf_creq); + proto_tree_add_item(subtree, hf_lbmc_ssf_creq_next_hdr, tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_NEXT_HDR, L_LBMC_CNTL_SSF_CREQ_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_creq_hdr_len, tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_HDR_LEN, L_LBMC_CNTL_SSF_CREQ_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ssf_creq_flags, tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_FLAGS, L_LBMC_CNTL_SSF_CREQ_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ssf_creq); + proto_tree_add_item(flags_tree, hf_lbmc_ssf_creq_flags_ignore, tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_FLAGS, L_LBMC_CNTL_SSF_CREQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_creq_mode, tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_MODE, L_LBMC_CNTL_SSF_CREQ_HDR_T_MODE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_creq_transport_idx, tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_SSF_CREQ_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_creq_topic_idx, tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_TOPIC_IDX, L_LBMC_CNTL_SSF_CREQ_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ssf_creq_client_idx, tvb, offset + O_LBMC_CNTL_SSF_CREQ_HDR_T_CLIENT_IDX, L_LBMC_CNTL_SSF_CREQ_HDR_T_CLIENT_IDX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_SSF_CREQ_HDR_T); +} + +static int dissect_nhdr_ume_preg(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * marker_item = NULL; + proto_tree * marker_tree = NULL; + guint8 flags = 0; + guint8 marker = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_preg, tvb, offset, L_LBMC_CNTL_UME_PREG_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_preg); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_next_hdr, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_PREG_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_hdr_len, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_PREG_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_preg_flags, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_preg_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_preg_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_preg_flags_f_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_preg_flags_p_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_preg_flags_w_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_preg_flags_d_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + marker = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_MARKER); + marker_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_preg_marker, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_MARKER, L_LBMC_CNTL_UME_PREG_HDR_T_MARKER, "Marker: 0x%02x", marker); + marker_tree = proto_item_add_subtree(marker_item, ett_lbmc_ume_preg_marker); + proto_tree_add_item(marker_tree, hf_lbmc_ume_preg_marker_s_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_MARKER, L_LBMC_CNTL_UME_PREG_HDR_T_MARKER, ENC_BIG_ENDIAN); + proto_tree_add_item(marker_tree, hf_lbmc_ume_preg_marker_marker, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_MARKER, L_LBMC_CNTL_UME_PREG_HDR_T_MARKER, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_reg_id, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_REG_ID, L_LBMC_CNTL_UME_PREG_HDR_T_REG_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_transport_idx, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_UME_PREG_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_topic_idx, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_TOPIC_IDX, L_LBMC_CNTL_UME_PREG_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_src_reg_id, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_SRC_REG_ID, L_LBMC_CNTL_UME_PREG_HDR_T_SRC_REG_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_port, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_RESP_PORT, L_LBMC_CNTL_UME_PREG_HDR_T_RESP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_res2, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_RES2, L_LBMC_CNTL_UME_PREG_HDR_T_RES2, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_ip, tvb, offset + O_LBMC_CNTL_UME_PREG_HDR_T_RESP_IP, L_LBMC_CNTL_UME_PREG_HDR_T_RESP_IP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_PREG_HDR_T); +} + +static int dissect_nhdr_ume_preg_resp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * code_item = NULL; + proto_tree * code_tree = NULL; + proto_item * marker_item = NULL; + proto_tree * marker_tree = NULL; + guint8 code = 0; + guint8 marker = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_preg_resp, tvb, offset, L_LBMC_CNTL_UME_PREG_RESP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_preg_resp); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_next_hdr, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_hdr_len, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + code = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE); + code_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_preg_resp_code, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, "Code: 0x%02x", code); + code_tree = proto_item_add_subtree(code_item, ett_lbmc_ume_preg_resp_code); + proto_tree_add_item(code_tree, hf_lbmc_ume_preg_resp_code_ignore, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, ENC_BIG_ENDIAN); + proto_tree_add_item(code_tree, hf_lbmc_ume_preg_resp_code_o_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, ENC_BIG_ENDIAN); + proto_tree_add_item(code_tree, hf_lbmc_ume_preg_resp_code_e_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, ENC_BIG_ENDIAN); + if ((code & LBMC_UME_PREG_RESP_E_FLAG) == 0) + { + proto_tree_add_item(code_tree, hf_lbmc_ume_preg_resp_code_n_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, ENC_BIG_ENDIAN); + proto_tree_add_item(code_tree, hf_lbmc_ume_preg_resp_code_w_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, ENC_BIG_ENDIAN); + proto_tree_add_item(code_tree, hf_lbmc_ume_preg_resp_code_d_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, ENC_BIG_ENDIAN); + } + else + { + proto_tree_add_item(code_tree, hf_lbmc_ume_preg_resp_code_code, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE, ENC_BIG_ENDIAN); + } + marker = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER); + marker_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_preg_resp_marker, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER, "Marker: 0x%02x", marker); + marker_tree = proto_item_add_subtree(marker_item, ett_lbmc_ume_preg_resp_marker); + proto_tree_add_item(marker_tree, hf_lbmc_ume_preg_resp_marker_s_flag, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER, ENC_BIG_ENDIAN); + proto_tree_add_item(marker_tree, hf_lbmc_ume_preg_resp_marker_marker, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_reg_id, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_REG_ID, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_REG_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_transport_idx, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_topic_idx, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_TOPIC_IDX, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_low_seqnum, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_LOW_SEQNUM, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_LOW_SEQNUM, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_preg_resp_high_seqnum, tvb, offset + O_LBMC_CNTL_UME_PREG_RESP_HDR_T_HIGH_SEQNUM, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_HIGH_SEQNUM, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_PREG_RESP_HDR_T); +} + +static int dissect_nhdr_ume_ack(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_ack, tvb, offset, L_LBMC_CNTL_UME_ACK_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_ack); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_next_hdr, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_ACK_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_hdr_len, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_ACK_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_ack_flags, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_ack_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_ack_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_ack_flags_o_flag, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_ack_flags_f_flag, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_ack_flags_u_flag, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_ack_flags_e_flag, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_type, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_TYPE, L_LBMC_CNTL_UME_ACK_HDR_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_transport_idx, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_UME_ACK_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_id_2, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_ID_2, L_LBMC_CNTL_UME_ACK_HDR_T_ID_2, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_rcv_reg_id, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_RCV_REG_ID, L_LBMC_CNTL_UME_ACK_HDR_T_RCV_REG_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_seqnum, tvb, offset + O_LBMC_CNTL_UME_ACK_HDR_T_SEQNUM, L_LBMC_CNTL_UME_ACK_HDR_T_SEQNUM, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_ACK_HDR_T); +} + +static int dissect_nhdr_ume_rxreq(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_rxreq, tvb, offset, L_LBMC_CNTL_UME_RXREQ_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_rxreq); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_next_hdr, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_RXREQ_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_hdr_len, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_RXREQ_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_rxreq_flags, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS, L_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_rxreq_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_rxreq_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS, L_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_rxreq_flags_tsni_req, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS, L_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_request_idx, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_REQUEST_IDX, L_LBMC_CNTL_UME_RXREQ_HDR_T_REQUEST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_transport_idx, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_UME_RXREQ_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_id_2, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_ID_2, L_LBMC_CNTL_UME_RXREQ_HDR_T_ID_2, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_seqnum, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_SEQNUM, L_LBMC_CNTL_UME_RXREQ_HDR_T_SEQNUM, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_rx_port, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_RX_PORT, L_LBMC_CNTL_UME_RXREQ_HDR_T_RX_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_res, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_RES, L_LBMC_CNTL_UME_RXREQ_HDR_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_rxreq_rx_ip, tvb, offset + O_LBMC_CNTL_UME_RXREQ_HDR_T_RX_IP, L_LBMC_CNTL_UME_RXREQ_HDR_T_RX_IP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_RXREQ_HDR_T); +} + +static int dissect_nhdr_ume_keepalive(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_keepalive, tvb, offset, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_keepalive); + proto_tree_add_item(subtree, hf_lbmc_ume_keepalive_next_hdr, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_keepalive_hdr_len, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_keepalive_flags, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_keepalive_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_keepalive_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_keepalive_flags_r_flag, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_keepalive_flags_t_flag, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_keepalive_type, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TYPE, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_keepalive_transport_idx, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_keepalive_topic_idx, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TOPIC_IDX, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_keepalive_reg_id, tvb, offset + O_LBMC_CNTL_UME_KEEPALIVE_HDR_T_REG_ID, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_REG_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_KEEPALIVE_HDR_T); +} + +static int dissect_nhdr_ume_storeid(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * storeid_item = NULL; + proto_tree * storeid_tree = NULL; + guint16 store_id = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_storeid, tvb, offset, L_LBMC_CNTL_UME_STOREID_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_storeid); + proto_tree_add_item(subtree, hf_lbmc_ume_storeid_next_hdr, tvb, offset + O_LBMC_CNTL_UME_STOREID_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_STOREID_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_storeid_hdr_len, tvb, offset + O_LBMC_CNTL_UME_STOREID_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_STOREID_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + store_id = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID); + storeid_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_storeid_store_id, tvb, offset + O_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID, L_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID, "Store ID: 0x%04x", store_id); + storeid_tree = proto_item_add_subtree(storeid_item, ett_lbmc_ume_storeid_store_id); + proto_tree_add_item(storeid_tree, hf_lbmc_ume_storeid_store_id_ignore, tvb, offset + O_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID, L_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(storeid_tree, hf_lbmc_ume_storeid_store_id_store_id, tvb, offset + O_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID, L_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_STOREID_HDR_T); +} + +static int dissect_nhdr_ume_ranged_ack(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_ranged_ack, tvb, offset, L_LBMC_CNTL_UME_RANGED_ACK_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_ranged_ack); + proto_tree_add_item(subtree, hf_lbmc_ume_ranged_ack_next_hdr, tvb, offset + O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ranged_ack_hdr_len, tvb, offset + O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_ranged_ack_flags, tvb, offset + O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FLAGS, L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_ranged_ack_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_ranged_ack_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FLAGS, L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ranged_ack_first_seqnum, tvb, offset + O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FIRST_SEQNUM, L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FIRST_SEQNUM, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ranged_ack_last_seqnum, tvb, offset + O_LBMC_CNTL_UME_RANGED_ACK_HDR_T_LAST_SEQNUM, L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_LAST_SEQNUM, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_RANGED_ACK_HDR_T); +} + +static int dissect_nhdr_ume_ack_id(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_ack_id, tvb, offset, L_LBMC_CNTL_UME_ACK_ID_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_ack_id); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_id_next_hdr, tvb, offset + O_LBMC_CNTL_UME_ACK_ID_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_ACK_ID_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_id_hdr_len, tvb, offset + O_LBMC_CNTL_UME_ACK_ID_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_ACK_ID_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_ACK_ID_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_ack_id_flags, tvb, offset + O_LBMC_CNTL_UME_ACK_ID_HDR_T_FLAGS, L_LBMC_CNTL_UME_ACK_ID_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_ack_id_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_ack_id_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_ACK_ID_HDR_T_FLAGS, L_LBMC_CNTL_UME_ACK_ID_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_ack_id_id, tvb, offset + O_LBMC_CNTL_UME_ACK_ID_HDR_T_ID, L_LBMC_CNTL_UME_ACK_ID_HDR_T_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_ACK_ID_HDR_T); +} + +static int dissect_nhdr_ume_capability(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_capability, tvb, offset, L_LBMC_CNTL_UME_CAPABILITY_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_capability); + proto_tree_add_item(subtree, hf_lbmc_ume_capability_next_hdr, tvb, offset + O_LBMC_CNTL_UME_CAPABILITY_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_capability_hdr_len, tvb, offset + O_LBMC_CNTL_UME_CAPABILITY_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_capability_flags, tvb, offset + O_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_capability_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_capability_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_capability_flags_qc_flag, tvb, offset + O_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_capability_flags_client_lifetime_flag, tvb, offset + O_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_CAPABILITY_HDR_T); +} + +static int dissect_nhdr_ume_proxy_src(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_proxy_src, tvb, offset, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_proxy_src); + proto_tree_add_item(subtree, hf_lbmc_ume_proxy_src_next_hdr, tvb, offset + O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_proxy_src_hdr_len, tvb, offset + O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_proxy_src_flags, tvb, offset + O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_proxy_src_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_proxy_src_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_proxy_src_flags_enable, tvb, offset + O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_proxy_src_flags_compatibility, tvb, offset + O_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_PROXY_SRC_HDR_T); +} + +static int dissect_nhdr_ume_store_group(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_store_group, tvb, offset, L_LBMC_CNTL_UME_STORE_GROUP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_store_group); + proto_tree_add_item(subtree, hf_lbmc_ume_store_group_next_hdr, tvb, offset + O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_group_hdr_len, tvb, offset + O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_store_group_flags, tvb, offset + O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_FLAGS, L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_store_group_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_store_group_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_FLAGS, L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_group_grp_idx, tvb, offset + O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_GRP_IDX, L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_GRP_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_group_grp_sz, tvb, offset + O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_GRP_SZ, L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_GRP_SZ, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_group_res1, tvb, offset + O_LBMC_CNTL_UME_STORE_GROUP_HDR_T_RES1, L_LBMC_CNTL_UME_STORE_GROUP_HDR_T_RES1, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_STORE_GROUP_HDR_T); +} + +static int dissect_nhdr_ume_store(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_store, tvb, offset, L_LBMC_CNTL_UME_STORE_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_store); + proto_tree_add_item(subtree, hf_lbmc_ume_store_next_hdr, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_STORE_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_hdr_len, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_STORE_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_store_flags, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_FLAGS, L_LBMC_CNTL_UME_STORE_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_store_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_store_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_FLAGS, L_LBMC_CNTL_UME_STORE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_grp_idx, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_GRP_IDX, L_LBMC_CNTL_UME_STORE_HDR_T_GRP_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_store_tcp_port, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_STORE_TCP_PORT, L_LBMC_CNTL_UME_STORE_HDR_T_STORE_TCP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_store_idx, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_STORE_IDX, L_LBMC_CNTL_UME_STORE_HDR_T_STORE_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_store_ip_addr, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_STORE_IP_ADDR, L_LBMC_CNTL_UME_STORE_HDR_T_STORE_IP_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_src_reg_id, tvb, offset + O_LBMC_CNTL_UME_STORE_HDR_T_SRC_REG_ID, L_LBMC_CNTL_UME_STORE_HDR_T_SRC_REG_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_STORE_HDR_T); +} + +static int dissect_nhdr_ume_lj_info(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_lj_info, tvb, offset, L_LBMC_CNTL_UME_LJ_INFO_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_lj_info); + proto_tree_add_item(subtree, hf_lbmc_ume_lj_info_next_hdr, tvb, offset + O_LBMC_CNTL_UME_LJ_INFO_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_LJ_INFO_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_lj_info_hdr_len, tvb, offset + O_LBMC_CNTL_UME_LJ_INFO_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_LJ_INFO_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_LJ_INFO_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_lj_info_flags, tvb, offset + O_LBMC_CNTL_UME_LJ_INFO_HDR_T_FLAGS, L_LBMC_CNTL_UME_LJ_INFO_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_lj_info_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_lj_info_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_LJ_INFO_HDR_T_FLAGS, L_LBMC_CNTL_UME_LJ_INFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_lj_info_low_seqnum, tvb, offset + O_LBMC_CNTL_UME_LJ_INFO_HDR_T_LOW_SEQNUM, L_LBMC_CNTL_UME_LJ_INFO_HDR_T_LOW_SEQNUM, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_lj_info_high_seqnum, tvb, offset + O_LBMC_CNTL_UME_LJ_INFO_HDR_T_HIGH_SEQNUM, L_LBMC_CNTL_UME_LJ_INFO_HDR_T_HIGH_SEQNUM, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_lj_info_qidx, tvb, offset + O_LBMC_CNTL_UME_LJ_INFO_HDR_T_QIDX, L_LBMC_CNTL_UME_LJ_INFO_HDR_T_QIDX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_LJ_INFO_HDR_T); +} + +static int dissect_nhdr_tsni_rec(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * sqn_item = NULL; + guint32 sqn = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_tsni_rec, tvb, offset, L_LBMC_CNTL_TSNI_REC_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_tsni_rec); + proto_tree_add_item(subtree, hf_lbmc_tsni_rec_tidx, tvb, offset + O_LBMC_CNTL_TSNI_REC_HDR_T_TIDX, L_LBMC_CNTL_TSNI_REC_HDR_T_TIDX, ENC_BIG_ENDIAN); + sqn_item = proto_tree_add_item(subtree, hf_lbmc_tsni_rec_sqn, tvb, offset + O_LBMC_CNTL_TSNI_REC_HDR_T_SQN, L_LBMC_CNTL_TSNI_REC_HDR_T_SQN, ENC_BIG_ENDIAN); + sqn = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_TSNI_REC_HDR_T_SQN); + expert_add_info_format(pinfo, sqn_item, &ei_lbmc_analysis_tsni, "TSNI Sqn 0x%08x", sqn); + return (L_LBMC_CNTL_TSNI_REC_HDR_T); +} + +static int dissect_nhdr_tsni(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 hdrlen_remaining; + int rec_offset = 0; + proto_item * num_recs_subtree_item = NULL; + proto_tree * num_recs_subtree = NULL; + int len_dissected = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_TSNI_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_tsni, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_tsni); + proto_tree_add_item(subtree, hf_lbmc_tsni_next_hdr, tvb, offset + O_LBMC_CNTL_TSNI_HDR_T_NEXT_HDR, L_LBMC_CNTL_TSNI_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tsni_hdr_len, tvb, offset + O_LBMC_CNTL_TSNI_HDR_T_HDR_LEN, L_LBMC_CNTL_TSNI_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + num_recs_subtree_item = proto_tree_add_item(subtree, hf_lbmc_tsni_num_recs, tvb, offset + O_LBMC_CNTL_TSNI_HDR_T_NUM_RECS, L_LBMC_CNTL_TSNI_HDR_T_NUM_RECS, ENC_NA); + num_recs_subtree = proto_item_add_subtree(num_recs_subtree_item, ett_lbmc_tsni_num_recs); + proto_tree_add_item(num_recs_subtree, hf_lbmc_tsni_num_recs_ignore, tvb, offset + O_LBMC_CNTL_TSNI_HDR_T_NUM_RECS, L_LBMC_CNTL_TSNI_HDR_T_NUM_RECS, ENC_BIG_ENDIAN); + proto_tree_add_item(num_recs_subtree, hf_lbmc_tsni_num_recs_num_recs, tvb, offset + O_LBMC_CNTL_TSNI_HDR_T_NUM_RECS, L_LBMC_CNTL_TSNI_HDR_T_NUM_RECS, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_TSNI_HDR_T; + hdrlen_remaining = hdrlen - L_LBMC_CNTL_TSNI_HDR_T; + rec_offset = L_LBMC_CNTL_TSNI_HDR_T; + while (hdrlen_remaining >= L_LBMC_CNTL_TSNI_REC_HDR_T) + { + int reclen; + + reclen = dissect_nhdr_tsni_rec(tvb, offset + rec_offset, pinfo, subtree); + hdrlen_remaining -= reclen; + rec_offset += reclen; + len_dissected += reclen; + if (reclen == 0) + { + break; + } + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_reg_ctx(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_reg_ctx, tvb, offset, L_LBMC_CNTL_UMQ_REG_CTX_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_reg_ctx); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ctx_port, tvb, offset + O_LBMC_CNTL_UMQ_REG_CTX_HDR_T_PORT, L_LBMC_CNTL_UMQ_REG_CTX_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ctx_reserved, tvb, offset + O_LBMC_CNTL_UMQ_REG_CTX_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_REG_CTX_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ctx_ip, tvb, offset + O_LBMC_CNTL_UMQ_REG_CTX_HDR_T_IP, L_LBMC_CNTL_UMQ_REG_CTX_HDR_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ctx_capabilities, tvb, offset + O_LBMC_CNTL_UMQ_REG_CTX_HDR_T_CAPABILITIES, L_LBMC_CNTL_UMQ_REG_CTX_HDR_T_CAPABILITIES, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_CTX_HDR_T); +} + +static int dissect_nhdr_umq_reg_src(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_reg_src, tvb, offset, L_LBMC_CNTL_UMQ_REG_SRC_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_reg_src); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_src_transport_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_SRC_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_UMQ_REG_SRC_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_src_topic_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_SRC_HDR_T_TOPIC_IDX, L_LBMC_CNTL_UMQ_REG_SRC_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_SRC_HDR_T); +} + +static int dissect_nhdr_umq_reg_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_reg_rcv, tvb, offset, L_LBMC_CNTL_UMQ_REG_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_reg_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_rcv_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_RCV_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_REG_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_rcv_rcv_type_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_RCV_HDR_T_RCV_TYPE_ID, L_LBMC_CNTL_UMQ_REG_RCV_HDR_T_RCV_TYPE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_rcv_last_topic_rcr_tsp, tvb, offset + O_LBMC_CNTL_UMQ_REG_RCV_HDR_T_LAST_TOPIC_RCR_TSP, L_LBMC_CNTL_UMQ_REG_RCV_HDR_T_LAST_TOPIC_RCR_TSP, ENC_BIG_ENDIAN); + return ((int)L_LBMC_CNTL_UMQ_REG_RCV_HDR_T); +} + +static int dissect_nhdr_umq_rcv_dereg(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_rcv_dereg, tvb, offset, L_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_rcv_dereg); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_rcv_dereg_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_rcv_dereg_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return ((int)L_LBMC_CNTL_UMQ_RCV_DEREG_HDR_T); +} + +static int dissect_nhdr_umq_reg_ulb_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_reg_ulb_rcv, tvb, offset, L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_reg_ulb_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ulb_rcv_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ulb_rcv_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ulb_rcv_rcv_type_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_RCV_TYPE_ID, L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_RCV_TYPE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ulb_rcv_port, tvb, offset + O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_PORT, L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ulb_rcv_reserved, tvb, offset + O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ulb_rcv_ip, tvb, offset + O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_IP, L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_ulb_rcv_capabilities, tvb, offset + O_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_CAPABILITIES, L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T_CAPABILITIES, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_ULB_RCV_HDR_T); +} + +static int dissect_nhdr_umq_ulb_rcv_dereg(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_ulb_rcv_dereg, tvb, offset, L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_ulb_rcv_dereg); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_ulb_rcv_dereg_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_ulb_rcv_dereg_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return ((int)L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_HDR_T); +} + +static int dissect_nhdr_umq_reg_observer_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_reg_observer_rcv, tvb, offset, L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_reg_observer_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_observer_rcv_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_observer_rcv_rcv_type_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_RCV_TYPE_ID, L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_RCV_TYPE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_observer_rcv_last_topic_rcr_tsp, tvb, offset + O_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_LAST_TOPIC_RCR_TSP, L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T_LAST_TOPIC_RCR_TSP, ENC_BIG_ENDIAN); + return ((int)L_LBMC_CNTL_UMQ_REG_OBSERVER_RCV_HDR_T); +} + +static int dissect_nhdr_umq_observer_rcv_dereg(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_observer_rcv_dereg, tvb, offset, L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_observer_rcv_dereg); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_observer_rcv_dereg_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_observer_rcv_dereg_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_HDR_T); +} + +static int dissect_nhdr_umq_reg(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 reg_type = 0; + int len_dissected = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags; + int len = 0; + proto_item * reg_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_REG_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_REG_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_reg_flags, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_reg_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_flags_r_flag, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_flags_t_flag, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_flags_i_flag, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_flags_msg_sel_flag, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS, ENC_BIG_ENDIAN); + reg_type_item = proto_tree_add_item(subtree, hf_lbmc_umq_reg_reg_type, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_REG_TYPE, L_LBMC_CNTL_UMQ_REG_HDR_T_REG_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_REG_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_cmd_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_CMD_ID, L_LBMC_CNTL_UMQ_REG_HDR_T_CMD_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_inst_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_INST_IDX, L_LBMC_CNTL_UMQ_REG_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_regid, tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_REGID, L_LBMC_CNTL_UMQ_REG_HDR_T_REGID, ENC_BIG_ENDIAN); + + len_dissected = L_LBMC_CNTL_UMQ_REG_HDR_T; + reg_type = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_REG_HDR_T_REG_TYPE); + switch (reg_type) + { + case LBMC_UMQ_REG_CTX_TYPE: + len = dissect_nhdr_umq_reg_ctx(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_SRC_TYPE: + len = dissect_nhdr_umq_reg_src(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RCV_TYPE: + len = dissect_nhdr_umq_reg_rcv(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RCV_DEREG_TYPE: + len = dissect_nhdr_umq_rcv_dereg(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_ULB_RCV_TYPE: + len = dissect_nhdr_umq_reg_ulb_rcv(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_ULB_RCV_DEREG_TYPE: + len = dissect_nhdr_umq_ulb_rcv_dereg(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_OBSERVER_RCV_TYPE: + len = dissect_nhdr_umq_reg_observer_rcv(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_OBSERVER_RCV_DEREG_TYPE: + len = dissect_nhdr_umq_observer_rcv_dereg(tvb, offset + len_dissected, pinfo, subtree); + break; + default: + expert_add_info_format(pinfo, reg_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ REG type 0x%02x", reg_type); + len = 0; + break; + } + len_dissected += len; + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_reg_resp_ctx(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_reg_ctx, tvb, offset, L_LBMC_CNTL_UMQ_REG_RESP_CTX_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_reg_ctx); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ctx_capabilities, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_CTX_HDR_T_CAPABILITIES, L_LBMC_CNTL_UMQ_REG_RESP_CTX_HDR_T_CAPABILITIES, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_RESP_CTX_HDR_T); +} + +static int dissect_nhdr_umq_reg_resp_ctx_ex(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_reg_ctx_ex, tvb, offset, L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_reg_ctx_ex); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ctx_ex_capabilities, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_CAPABILITIES, L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_CAPABILITIES, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ctx_ex_reserved, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_RESERVED, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_reg_resp_reg_ctx_ex_flags, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_reg_resp_reg_ctx_ex_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_resp_reg_ctx_ex_flags_firstmsg, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ctx_ex_stamp, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_STAMP, L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_STAMP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T); +} + +static int dissect_nhdr_umq_reg_resp_err(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_err, tvb, offset, L_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_err); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_err_reserved, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_err_code, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T_CODE, L_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T_CODE, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_RESP_ERR_HDR_T); +} + +static int dissect_nhdr_umq_reg_resp_src(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_reg_src, tvb, offset, L_LBMC_CNTL_UMQ_REG_RESP_SRC_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_reg_src); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_src_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_SRC_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_REG_RESP_SRC_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_RESP_SRC_HDR_T); +} + +static int dissect_nhdr_umq_reg_resp_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_reg_rcv, tvb, offset, L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_reg_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_rcv_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_rcv_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_rcv_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_rcv_reserved, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T_RESERVED, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_RESP_RCV_HDR_T); +} + +static int dissect_nhdr_umq_rcv_dereg_resp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_rcv_dereg, tvb, offset, L_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_rcv_dereg); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_rcv_dereg_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_rcv_dereg_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RCV_DEREG_RESP_HDR_T); +} + +static int dissect_nhdr_umq_reg_resp_ulb_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_reg_ulb_rcv, tvb, offset, L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_reg_ulb_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ulb_rcv_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ulb_rcv_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ulb_rcv_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ulb_rcv_reserved, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_ulb_rcv_capabilities, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_CAPABILITIES, L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T_CAPABILITIES, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_RESP_ULB_RCV_HDR_T); +} + +static int dissect_nhdr_umq_ulb_rcv_dereg_resp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_ulb_rcv_dereg, tvb, offset, L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_ulb_rcv_dereg); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_ulb_rcv_dereg_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_ulb_rcv_dereg_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_ULB_RCV_DEREG_RESP_HDR_T); +} + +static int dissect_nhdr_umq_reg_resp_observer_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_reg_observer_rcv, tvb, offset, L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_reg_observer_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_observer_rcv_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_observer_rcv_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_observer_rcv_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_reg_observer_rcv_reserved, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T_RESERVED, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_REG_RESP_OBSERVER_RCV_HDR_T); +} + +static int dissect_nhdr_umq_observer_rcv_dereg_resp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp_observer_rcv_dereg, tvb, offset, L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp_observer_rcv_dereg); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_observer_rcv_dereg_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_observer_rcv_dereg_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_OBSERVER_RCV_DEREG_RESP_HDR_T); +} + +static int dissect_nhdr_umq_reg_resp(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 resp_type = 0; + int len_dissected = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags; + int len = 0; + proto_item * resp_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_HDR_LEN); + resp_type = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESP_TYPE); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_reg_resp, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_reg_resp); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_reg_resp_flags, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_reg_resp_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_resp_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_resp_flags_r_flag, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + switch (resp_type) + { + case LBMC_UMQ_REG_RESP_CTX_TYPE: + break; + case LBMC_UMQ_REG_RESP_CTX_EX_TYPE: + break; + case LBMC_UMQ_REG_RESP_ERR_TYPE: + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_resp_flags_l_flag, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + break; + case LBMC_UMQ_REG_RESP_SRC_TYPE: + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_resp_flags_src_s_flag, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_reg_resp_flags_src_d_flag, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + break; + case LBMC_UMQ_REG_RESP_RCV_TYPE: + break; + case LBMC_UMQ_REG_RESP_OBSERVER_RCV_TYPE: + break; + case LBMC_UMQ_REG_RESP_RCV_DEREG_TYPE: + break; + case LBMC_UMQ_REG_RESP_OBSERVER_RCV_DEREG_TYPE: + break; + case LBMC_UMQ_REG_RESP_ULB_RCV_TYPE: + break; + case LBMC_UMQ_REG_RESP_ULB_RCV_DEREG_TYPE: + break; + default: + break; + } + resp_type_item = proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_resp_type, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESP_TYPE, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESP_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_cmd_id, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_CMD_ID, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_CMD_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_inst_idx, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_INST_IDX, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_reg_resp_regid, tvb, offset + O_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESPID, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_REG_RESPID, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_REG_RESP_HDR_T; + switch (resp_type) + { + case LBMC_UMQ_REG_RESP_CTX_TYPE: + len = dissect_nhdr_umq_reg_resp_ctx(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_CTX_EX_TYPE: + len = dissect_nhdr_umq_reg_resp_ctx_ex(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_ERR_TYPE: + len = dissect_nhdr_umq_reg_resp_err(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_SRC_TYPE: + len = dissect_nhdr_umq_reg_resp_src(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_RCV_TYPE: + len = dissect_nhdr_umq_reg_resp_rcv(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_RCV_DEREG_TYPE: + len = dissect_nhdr_umq_rcv_dereg_resp(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_ULB_RCV_TYPE: + len = dissect_nhdr_umq_reg_resp_ulb_rcv(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_ULB_RCV_DEREG_TYPE: + len = dissect_nhdr_umq_ulb_rcv_dereg_resp(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_OBSERVER_RCV_TYPE: + len = dissect_nhdr_umq_reg_resp_observer_rcv(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_REG_RESP_OBSERVER_RCV_DEREG_TYPE: + len = dissect_nhdr_umq_observer_rcv_dereg_resp(tvb, offset + len_dissected, pinfo, subtree); + break; + default: + expert_add_info_format(pinfo, resp_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ REG RESP type 0x%02x", resp_type); + len = 0; + break; + } + len_dissected += len; + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_ack_msgid(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ack_msgid, tvb, offset, L_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ack_msgid); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_msgid_regid, tvb, offset + O_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T_REGID, L_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_msgid_stamp, tvb, offset + O_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T_STAMP, L_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T_STAMP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_ACK_MSGID_HDR_T); +} + +static int dissect_nhdr_umq_ack_stable(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ack_stable, tvb, offset, L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ack_stable); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_stable_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_stable_inst_idx, tvb, offset + O_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_INST_IDX, L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_stable_reserved, tvb, offset + O_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T_RESERVED, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_ACK_STABLE_HDR_T); +} + +static int dissect_nhdr_umq_ack_cr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ack_cr, tvb, offset, L_LBMC_CNTL_UMQ_ACK_CR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ack_cr); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_cr_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_ACK_CR_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_ACK_CR_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_cr_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ACK_CR_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ACK_CR_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_cr_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_ACK_CR_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_ACK_CR_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_cr_reserved, tvb, offset + O_LBMC_CNTL_UMQ_ACK_CR_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_ACK_CR_HDR_T_RESERVED, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_ACK_CR_HDR_T); +} + +static int dissect_nhdr_umq_ack_ulb_cr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ack_ulb_cr, tvb, offset, L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ack_ulb_cr); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_ulb_cr_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_ulb_cr_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_ulb_cr_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_ulb_cr_reserved, tvb, offset + O_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T_RESERVED, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_ACK_ULB_CR_HDR_T); +} + +static int dissect_nhdr_umq_ack(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 ack_type = 0; + guint8 num_ids = 0; + guint8 idx; + int len_dissected = 0; + proto_item * msgs_item = NULL; + proto_tree * msgs_tree = NULL; + guint8 msgs; + int len; + int packet_len = 0; + proto_item * ack_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ack, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ack); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_ACK_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ack_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_ACK_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + msgs = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS); + msgs_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_ack_msgs, tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, "Messages: 0x%02x", msgs); + msgs_tree = proto_item_add_subtree(msgs_item, ett_lbmc_umq_ack_msgs); + proto_tree_add_item(msgs_tree, hf_lbmc_umq_ack_msgs_ignore, tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, ENC_BIG_ENDIAN); + proto_tree_add_item(msgs_tree, hf_lbmc_umq_ack_msgs_t_flag, tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, ENC_BIG_ENDIAN); + proto_tree_add_item(msgs_tree, hf_lbmc_umq_ack_msgs_d_flag, tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, ENC_BIG_ENDIAN); + proto_tree_add_item(msgs_tree, hf_lbmc_umq_ack_msgs_numids, tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS, ENC_BIG_ENDIAN); + ack_type_item = proto_tree_add_item(subtree, hf_lbmc_umq_ack_ack_type, tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_ACK_TYPE, L_LBMC_CNTL_UMQ_ACK_HDR_T_ACK_TYPE, ENC_BIG_ENDIAN); + packet_len = tvb_reported_length_remaining(tvb, offset); + len_dissected = L_LBMC_CNTL_UMQ_ACK_HDR_T; + num_ids = msgs & LBMC_UMQ_ACK_NUMIDS_MASK; + for (idx = 0; (idx < num_ids) && (len_dissected < packet_len); idx++) + { + len = dissect_nhdr_umq_ack_msgid(tvb, offset + len_dissected, pinfo, subtree); + len_dissected += len; + } + ack_type = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_ACK_HDR_T_ACK_TYPE); + switch (ack_type) + { + case LBMC_UMQ_ACK_STABLE_TYPE: + len = dissect_nhdr_umq_ack_stable(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_ACK_CR_TYPE: + len = dissect_nhdr_umq_ack_cr(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_ACK_ULB_CR_TYPE: + len = dissect_nhdr_umq_ack_ulb_cr(tvb, offset + len_dissected, pinfo, subtree); + break; + default: + expert_add_info_format(pinfo, ack_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ ACK type 0x%02x", ack_type); + len = 0; + break; + } + len_dissected += len; + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_rcr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint16 flags; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rcr, tvb, offset, L_LBMC_CNTL_UMQ_RCR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rcr); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_RCR_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_RCR_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_rcr_flags, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_rcr_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_rcr_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_rcr_flags_r_flag, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_rcr_flags_d_flag, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_rcr_flags_s_flag, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_rcr_flags_eoi_flag, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_rcr_flags_boi_flag, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_RCR_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RCR_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_msgid_regid, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_MSGID_REGID, L_LBMC_CNTL_UMQ_RCR_HDR_T_MSGID_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_msgid_stamp, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_MSGID_STAMP, L_LBMC_CNTL_UMQ_RCR_HDR_T_MSGID_STAMP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_topic_tsp, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_TOPIC_TSP, L_LBMC_CNTL_UMQ_RCR_HDR_T_TOPIC_TSP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_q_tsp, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_Q_TSP, L_LBMC_CNTL_UMQ_RCR_HDR_T_Q_TSP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RCR_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_RCR_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_num_ras, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_NUM_RAS, L_LBMC_CNTL_UMQ_RCR_HDR_T_NUM_RAS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rcr_queue_ver, tvb, offset + O_LBMC_CNTL_UMQ_RCR_HDR_T_QUEUE_VER, L_LBMC_CNTL_UMQ_RCR_HDR_T_QUEUE_VER, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RCR_HDR_T); +} + +static int dissect_nhdr_umq_ka_src(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ka_src, tvb, offset, L_LBMC_CNTL_UMQ_KA_SRC_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ka_src); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_src_transport_idx, tvb, offset + O_LBMC_CNTL_UMQ_KA_SRC_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_UMQ_KA_SRC_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_src_topic_idx, tvb, offset + O_LBMC_CNTL_UMQ_KA_SRC_HDR_T_TOPIC_IDX, L_LBMC_CNTL_UMQ_KA_SRC_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_KA_SRC_HDR_T); +} + +static int dissect_nhdr_umq_ka_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ka_rcv, tvb, offset, L_LBMC_CNTL_UMQ_KA_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ka_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_rcv_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_KA_RCV_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_KA_RCV_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_rcv_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_KA_RCV_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_KA_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_KA_RCV_HDR_T); +} + +static int dissect_nhdr_umq_ka_ulb_rcv(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ka_ulb_rcv, tvb, offset, L_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ka_ulb_rcv); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_ulb_rcv_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_ulb_rcv_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_KA_ULB_RCV_HDR_T); +} + +static int dissect_nhdr_umq_ka_ulb_rcv_resp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ka_ulb_rcv_resp, tvb, offset, L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ka_ulb_rcv_resp); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_ulb_rcv_resp_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_ulb_rcv_resp_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_ulb_rcv_resp_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ka_ulb_rcv_resp_reserved, tvb, offset + O_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T_RESERVED, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_KA_ULB_RCV_RESP_HDR_T); +} + +static int dissect_nhdr_umq_ka(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 flags; + guint8 type; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + int len_dissected = 0; + int len; + proto_item * ka_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_cntl_umq_ka, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ka); + proto_tree_add_item(subtree, hf_lbmc_cntl_umq_ka_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_KA_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_cntl_umq_ka_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_KA_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_cntl_umq_ka_flags, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_ka_flags); + proto_tree_add_item(flags_tree, hf_lbmc_cntl_umq_ka_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_cntl_umq_ka_flags_r_flag, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS, ENC_BIG_ENDIAN); + ka_type_item = proto_tree_add_item(subtree, hf_lbmc_cntl_umq_ka_ka_type, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_KA_TYPE, L_LBMC_CNTL_UMQ_KA_HDR_T_KA_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_cntl_umq_ka_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_KA_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_cntl_umq_ka_regid, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_REGID, L_LBMC_CNTL_UMQ_KA_HDR_T_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_cntl_umq_ka_inst_idx, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_INST_IDX, L_LBMC_CNTL_UMQ_KA_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_cntl_umq_ka_reserved, tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_KA_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_KA_HDR_T; + type = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_KA_HDR_T_KA_TYPE); + switch (type) + { + case LBMC_UMQ_KA_SRC_TYPE: + case LBMC_UMQ_KA_SRC_RESP_TYPE: + len = dissect_nhdr_umq_ka_src(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_KA_RCV_TYPE: + case LBMC_UMQ_KA_RCV_RESP_TYPE: + len = dissect_nhdr_umq_ka_rcv(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_KA_ULB_RCV_TYPE: + len = dissect_nhdr_umq_ka_ulb_rcv(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_KA_ULB_RCV_RESP_TYPE: + len = dissect_nhdr_umq_ka_ulb_rcv_resp(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_KA_CTX_TYPE: + case LBMC_UMQ_KA_CTX_RESP_TYPE: + len = 0; + break; + default: + expert_add_info_format(pinfo, ka_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ KA type 0x%02x", type); + len = 0; + break; + } + len_dissected += len; + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_rxreq_regid_resp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_regid_resp, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_REGID_RESP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_regid_resp); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_regid_resp_regid, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_REGID_RESP_HDR_T_REGID, L_LBMC_CNTL_UMQ_RXREQ_REGID_RESP_HDR_T_REGID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_REGID_RESP_HDR_T); +} + +static int dissect_nhdr_umq_rxreq_addr_resp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_addr_resp, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_addr_resp); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_addr_resp_ip, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_IP, L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_addr_resp_port, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_PORT, L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_addr_resp_reserved, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T_RESERVED, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_ADDR_RESP_HDR_T); +} + +static int dissect_nhdr_umq_rxreq_mr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_mr, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_mr); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_mr_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_mr_msgid_regid, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_MSGID_REGID, L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_MSGID_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_mr_msgid_stamp, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_MSGID_STAMP, L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T_MSGID_STAMP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_MR_HDR_T); +} + +static int dissect_nhdr_umq_rxreq_ulb_mr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_ulb_mr, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_ulb_mr); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_reserved, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_msgid_regid, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_MSGID_REGID, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_MSGID_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_msgid_stamp, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_MSGID_STAMP, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T_MSGID_STAMP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_HDR_T); +} + +static int dissect_nhdr_umq_rxreq_ulb_mr_abort(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_ulb_mr_abort, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_ulb_mr_abort); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_abort_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_abort_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_abort_msgid_regid, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_MSGID_REGID, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_MSGID_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_mr_abort_msgid_stamp, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_MSGID_STAMP, L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T_MSGID_STAMP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_ULB_MR_ABORT_HDR_T); +} + +static int dissect_nhdr_umq_rxreq_qrcrr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_qrcrr, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_QRCRR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_qrcrr); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_qrcrr_tsp, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_QRCRR_HDR_T_TSP, L_LBMC_CNTL_UMQ_RXREQ_QRCRR_HDR_T_TSP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_QRCRR_HDR_T); +} + +static int dissect_nhdr_umq_rxreq_trcrr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_trcrr, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_trcrr); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_trcrr_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_trcrr_tsp, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T_TSP, L_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T_TSP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_TRCRR_HDR_T); +} + +static int dissect_nhdr_umq_rxreq_ulb_trcrr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_ulb_trcrr, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_ulb_trcrr); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_trcrr_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_trcrr_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_trcrr_tsp, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_TSP, L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T_TSP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_HDR_T); +} + +static int dissect_nhdr_umq_rxreq_ulb_trcrr_abort(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq_ulb_trcrr_abort, tvb, offset, L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq_ulb_trcrr_abort); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_trcrr_abort_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_trcrr_abort_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_ulb_trcrr_abort_tsp, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_TSP, L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T_TSP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RXREQ_ULB_TRCRR_ABORT_HDR_T); +} + +static int dissect_nhdr_umq_rxreq(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + guint8 flags; + guint8 type; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + int len_dissected = 0; + int len = 0; + proto_item * rxreq_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_rxreq, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_rxreq); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_RXREQ_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_RXREQ_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_rxreq_flags, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_rxreq_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_rxreq_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_rxreq_flags_r_flag, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + rxreq_type_item = proto_tree_add_item(subtree, hf_lbmc_umq_rxreq_rxreq_type, tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_RXREQ_TYPE, L_LBMC_CNTL_UMQ_RXREQ_HDR_T_RXREQ_TYPE, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_RXREQ_HDR_T; + if ((flags & LBMC_UMQ_RXREQ_R_FLAG) != 0) + { + len = dissect_nhdr_umq_rxreq_regid_resp(tvb, offset + len_dissected, pinfo, subtree); + } + else + { + len = dissect_nhdr_umq_rxreq_addr_resp(tvb, offset + len_dissected, pinfo, subtree); + } + len_dissected += len; + type = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_RXREQ_HDR_T_RXREQ_TYPE); + switch (type) + { + case LBMC_UMQ_RXREQ_MR_TYPE: + len = dissect_nhdr_umq_rxreq_mr(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_RXREQ_ULB_MR_TYPE: + len = dissect_nhdr_umq_rxreq_ulb_mr(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_RXREQ_ULB_MR_ABORT_TYPE: + len = dissect_nhdr_umq_rxreq_ulb_mr_abort(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_RXREQ_QRCRR_TYPE: + len = dissect_nhdr_umq_rxreq_qrcrr(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_RXREQ_TRCRR_TYPE: + len = dissect_nhdr_umq_rxreq_trcrr(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_RXREQ_ULB_TRCRR_TYPE: + len = dissect_nhdr_umq_rxreq_ulb_trcrr(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_RXREQ_ULB_TRCRR_ABORT_TYPE: + len = dissect_nhdr_umq_rxreq_ulb_trcrr_abort(tvb, offset + len_dissected, pinfo, subtree); + break; + default: + expert_add_info_format(pinfo, rxreq_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ RXREQ type 0x%02x", type); + len = 0; + break; + } + len_dissected += len; + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_qmgmt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + int len_dissected = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_QMGMT_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_qmgmt, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_qmgmt); + proto_tree_add_item(subtree, hf_lbmc_umq_qmgmt_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_QMGMT_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_QMGMT_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_qmgmt_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_QMGMT_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_QMGMT_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + len_dissected = lbmr_dissect_umq_qmgmt(tvb, (offset + L_LBMC_CNTL_UMQ_QMGMT_HDR_T) - 2, pinfo, subtree); + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_resub_req(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint16 flags; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_resub_req, tvb, offset, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_resub_req); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_req_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_req_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_resub_req_flags, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_resub_req_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_resub_req_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_req_msgid_regid, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_MSGID_REGID, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_MSGID_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_req_msgid_stamp, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_MSGID_STAMP, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_MSGID_STAMP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_req_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_req_resp_ip, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RESP_IP, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RESP_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_req_resp_port, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RESP_PORT, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_RESP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_req_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T); +} + +static int dissect_nhdr_umq_resub_resp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 flags; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_resub_resp, tvb, offset, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_resub_resp); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_resub_resp_flags, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_resub_resp_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_resub_resp_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_code, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_CODE, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_CODE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_msgid_regid, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_MSGID_REGID, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_MSGID_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_msgid_stamp, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_MSGID_STAMP, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_MSGID_STAMP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_reserved, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_resub_resp_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T); +} + +static int dissect_nhdr_topic_interest(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_topic_interest, tvb, offset, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_topic_interest); + proto_tree_add_item(subtree, hf_lbmc_topic_interest_next_hdr, tvb, offset + O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_NEXT_HDR, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_interest_hdr_len, tvb, offset + O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_HDR_LEN, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_topic_interest_flags, tvb, offset + O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_topic_interest_flags); + proto_tree_add_item(flags_tree, hf_lbmc_topic_interest_flags_ignore, tvb, offset + O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_topic_interest_flags_cancel, tvb, offset + O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_topic_interest_flags_refresh, tvb, offset + O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_interest_domain_id, tvb, offset + O_LBMC_CNTL_TOPIC_INTEREST_HDR_T_DOMAIN_ID, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_DOMAIN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_TOPIC_INTEREST_HDR_T); +} + +static int dissect_nhdr_pattern_interest(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_pattern_interest, tvb, offset, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_pattern_interest); + proto_tree_add_item(subtree, hf_lbmc_pattern_interest_next_hdr, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_NEXT_HDR, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_interest_hdr_len, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_HDR_LEN, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_pattern_interest_flags, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_pattern_interest_flags); + proto_tree_add_item(flags_tree, hf_lbmc_pattern_interest_flags_ignore, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_pattern_interest_flags_cancel, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_pattern_interest_flags_refresh, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_interest_type, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_TYPE, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_interest_domain_id, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_DOMAIN_ID, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_DOMAIN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_interest_index, tvb, offset + O_LBMC_CNTL_PATTERN_INTEREST_HDR_T_INDEX, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_INDEX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_PATTERN_INTEREST_HDR_T); +} + +static int dissect_nhdr_advertisement(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * ad_flags_item = NULL; + proto_tree * ad_flags_tree = NULL; + guint8 flags = 0; + guint32 ad_flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_advertisement, tvb, offset, L_LBMC_CNTL_ADVERTISEMENT_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_advertisement); + proto_tree_add_item(subtree, hf_lbmc_advertisement_next_hdr, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_NEXT_HDR, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_hdr_len, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_HDR_LEN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_advertisement_flags, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_advertisement_flags); + proto_tree_add_item(flags_tree, hf_lbmc_advertisement_flags_ignore, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_advertisement_flags_eos, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_advertisement_flags_pattern, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_advertisement_flags_change, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_advertisement_flags_ctxinst, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + ad_flags = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS); + ad_flags_item = proto_tree_add_none_format(subtree, hf_lbmc_advertisement_ad_flags, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, "Ad Flags: 0x%08x", ad_flags); + ad_flags_tree = proto_item_add_subtree(ad_flags_item, ett_lbmc_advertisement_ad_flags); + proto_tree_add_item(ad_flags_tree, hf_lbmc_advertisement_ad_flags_lj, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(ad_flags_tree, hf_lbmc_advertisement_ad_flags_ume, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(ad_flags_tree, hf_lbmc_advertisement_ad_flags_acktosrc, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(ad_flags_tree, hf_lbmc_advertisement_ad_flags_queue, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(ad_flags_tree, hf_lbmc_advertisement_ad_flags_ulb, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_hop_count, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_HOP_COUNT, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_HOP_COUNT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_cost, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_COST, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_COST, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_transport_idx, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_topic_idx, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_TOPIC_IDX, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_low_seqno, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_LOW_SEQNO, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_LOW_SEQNO, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_high_seqno, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_HIGH_SEQNO, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_HIGH_SEQNO, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_domain_id, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_DOMAIN_ID, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_DOMAIN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_pat_idx, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_PAT_IDX, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_PAT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_advertisement_ctxinst, tvb, offset + O_LBMC_CNTL_ADVERTISEMENT_HDR_T_CTXINST, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_CTXINST, ENC_NA); + return (L_LBMC_CNTL_ADVERTISEMENT_HDR_T); +} + +static int dissect_nhdr_storename(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_UME_STORENAME_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_storename, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_storename); + proto_tree_add_item(subtree, hf_lbmc_ume_storename_next_hdr, tvb, offset + O_LBMC_UME_STORENAME_HDR_T_NEXT_HDR, L_LBMC_UME_STORENAME_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_storename_hdr_len, tvb, offset + O_LBMC_UME_STORENAME_HDR_T_HDR_LEN, L_LBMC_UME_STORENAME_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_UME_STORENAME_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_storename_flags, tvb, offset + O_LBMC_UME_STORENAME_HDR_T_FLAGS, L_LBMC_UME_STORENAME_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_storename_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_storename_flags_ignore, tvb, offset + O_LBMC_UME_STORENAME_HDR_T_FLAGS, L_LBMC_UME_STORENAME_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_storename_store, tvb, offset + O_LBMC_UME_STORENAME_HDR_T_FLAGS + L_LBMC_UME_STORENAME_HDR_T_FLAGS, (gint)(hdrlen - L_LBMC_BASIC_HDR_T), ENC_ASCII|ENC_NA); + return ((int)hdrlen); +} + +static int dissect_nhdr_umq_ulb_rcr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint16 flags; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_ulb_rcr, tvb, offset, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_ulb_rcr); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_ulb_rcr_flags, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_ulb_rcr_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_ulb_rcr_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_ulb_rcr_flags_r_flag, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_ulb_rcr_flags_d_flag, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_ulb_rcr_flags_eoi_flag, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_ulb_rcr_flags_boi_flag, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_ulb_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_ULB_SRC_ID, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_msgid_regid, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_MSGID_REGID, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_MSGID_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_msgid_stamp, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_MSGID_STAMP, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_MSGID_STAMP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_topic_tsp, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_TOPIC_TSP, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_TOPIC_TSP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_ulb_rcr_num_ras, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_NUM_RAS, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_NUM_RAS, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T); +} + +static int dissect_nhdr_umq_lf(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 flags; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_lf, tvb, offset, L_LBMC_CNTL_UMQ_LF_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_lf); + proto_tree_add_item(subtree, hf_lbmc_umq_lf_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_LF_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_LF_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_lf_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_LF_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_LF_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_LF_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_lf_flags, tvb, offset + O_LBMC_CNTL_UMQ_LF_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_LF_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_lf_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_lf_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_LF_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_LF_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_lf_type, tvb, offset + O_LBMC_CNTL_UMQ_LF_HDR_T_TYPE, L_LBMC_CNTL_UMQ_LF_HDR_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_lf_num_srcs, tvb, offset + O_LBMC_CNTL_UMQ_LF_HDR_T_NUM_SRCS, L_LBMC_CNTL_UMQ_LF_HDR_T_NUM_SRCS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_lf_lf, tvb, offset + O_LBMC_CNTL_UMQ_LF_HDR_T_LF, L_LBMC_CNTL_UMQ_LF_HDR_T_LF, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_LF_HDR_T); +} + +static int dissect_nhdr_ctxinfo(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + wmem_strbuf_t * flagbuf; + const char * sep = ""; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_ctxinfo, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ctxinfo); + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_next_hdr, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_NEXT_HDR, L_LBMC_CNTL_CTXINFO_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_hdr_len, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_HDR_LEN, L_LBMC_CNTL_CTXINFO_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS); + flagbuf = wmem_strbuf_new_label(wmem_packet_scope()); + if ((flags & LBMC_CTXINFO_PROXY_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "Proxy"); + sep = ", "; + } + if ((flags & LBMC_CTXINFO_TNWGRCV_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "GW Rcv"); + sep = ", "; + } + if ((flags & LBMC_CTXINFO_TNWGSRC_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "GW Src"); + sep = ", "; + } + if ((flags & LBMC_CTXINFO_NAME_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "Name"); + sep = ", "; + } + if ((flags & LBMC_CTXINFO_CTXINST_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "CtxInst"); + sep = ", "; + } + if ((flags & LBMC_CTXINFO_ADDR_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "IP"); + sep = ", "; + } + if ((flags & LBMC_CTXINFO_QUERY_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "Query"); + } + if (flags != LBMC_OPT_IGNORE) + { + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ctxinfo_flags, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, "Flags: 0x%04x (%s)", flags, (char *)wmem_strbuf_get_str(flagbuf)); + } + else + { + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ctxinfo_flags, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, "Flags: 0x%04x", flags); + } + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ctxinfo_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinfo_flags_ignore, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinfo_flags_query, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinfo_flags_addr, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinfo_flags_ctxinst, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinfo_flags_name, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinfo_flags_tnwgsrc, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinfo_flags_tnwgrcv, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ctxinfo_flags_proxy, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_reserved, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_RESERVED, L_LBMC_CNTL_CTXINFO_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_hop_count, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_HOP_COUNT, L_LBMC_CNTL_CTXINFO_HDR_T_HOP_COUNT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_port, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_PORT, L_LBMC_CNTL_CTXINFO_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_addr, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_ADDR, L_LBMC_CNTL_CTXINFO_HDR_T_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_domain_id, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_DOMAIN_ID, L_LBMC_CNTL_CTXINFO_HDR_T_DOMAIN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_ctxinst, tvb, offset + O_LBMC_CNTL_CTXINFO_HDR_T_CTXINST, L_LBMC_CNTL_CTXINFO_HDR_T_CTXINST, ENC_NA); + if ((flags & LBMC_CTXINFO_NAME_FLAG) != 0) + { + proto_tree_add_item(subtree, hf_lbmc_ctxinfo_name, tvb, offset + L_LBMC_CNTL_CTXINFO_HDR_T, hdrlen - L_LBMC_CNTL_CTXINFO_HDR_T, ENC_ASCII|ENC_NA); + } + return ((int)hdrlen); +} + +static int dissect_nhdr_ume_pser(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_pser, tvb, offset, L_LBMC_CNTL_UME_PSER_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_pser); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_next_hdr, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_PSER_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_hdr_len, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_PSER_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_pser_flags, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_pser_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_pser_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_pser_flags_source_ctxinst, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_pser_flags_store_ctxinst, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_ume_pser_flags_reelect, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_source_ip, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_IP, L_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_store_ip, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_STORE_IP, L_LBMC_CNTL_UME_PSER_HDR_T_STORE_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_transport_idx, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_UME_PSER_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_topic_idx, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_TOPIC_IDX, L_LBMC_CNTL_UME_PSER_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_source_port, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_PORT, L_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_store_port, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_STORE_PORT, L_LBMC_CNTL_UME_PSER_HDR_T_STORE_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_source_ctxinst, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_CTXINST, L_LBMC_CNTL_UME_PSER_HDR_T_SOURCE_CTXINST, ENC_NA); + proto_tree_add_item(subtree, hf_lbmc_ume_pser_store_ctxinst, tvb, offset + O_LBMC_CNTL_UME_PSER_HDR_T_STORE_CTXINST, L_LBMC_CNTL_UME_PSER_HDR_T_STORE_CTXINST, ENC_NA); + return (L_LBMC_CNTL_UME_PSER_HDR_T); +} + +static int dissect_nhdr_domain(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_domain, tvb, offset, L_LBMC_DOMAIN_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_domain); + proto_tree_add_item(subtree, hf_lbmc_domain_next_hdr, tvb, offset + O_LBMC_DOMAIN_HDR_T_NEXT_HDR, L_LBMC_DOMAIN_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_domain_hdr_len, tvb, offset + O_LBMC_DOMAIN_HDR_T_HDR_LEN, L_LBMC_DOMAIN_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_DOMAIN_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_domain_flags, tvb, offset + O_LBMC_DOMAIN_HDR_T_FLAGS, L_LBMC_DOMAIN_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_domain_flags); + proto_tree_add_item(flags_tree, hf_lbmc_domain_flags_ignore, tvb, offset + O_LBMC_DOMAIN_HDR_T_FLAGS, L_LBMC_DOMAIN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_domain_flags_active, tvb, offset + O_LBMC_DOMAIN_HDR_T_FLAGS, L_LBMC_DOMAIN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_domain_domain, tvb, offset + O_LBMC_DOMAIN_HDR_T_DOMAIN, L_LBMC_DOMAIN_HDR_T_DOMAIN, ENC_BIG_ENDIAN); + return (L_LBMC_DOMAIN_HDR_T); +} + +static int dissect_nhdr_tnwg_capabilities(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + proto_item * cap1_item = NULL; + proto_tree * cap1_tree = NULL; + guint32 cap1 = 0; + proto_item * cap3_item = NULL; + proto_tree * cap3_tree = NULL; + guint32 cap3 = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_tnwg_capabilities, tvb, offset, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_tnwg_capabilities); + proto_tree_add_item(subtree, hf_lbmc_tnwg_capabilities_next_hdr, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_NEXT_HDR, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_capabilities_hdr_len, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_HDR_LEN, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_tnwg_capabilities_flags, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_tnwg_capabilities_flags); + proto_tree_add_item(flags_tree, hf_lbmc_tnwg_capabilities_flags_ignore, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_tnwg_capabilities_flags_version, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS, ENC_BIG_ENDIAN); + cap1 = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1); + cap1_item = proto_tree_add_none_format(subtree, hf_lbmc_tnwg_capabilities_capabilities1, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1, "Capabilities1: 0x%08x", cap1); + cap1_tree = proto_item_add_subtree(cap1_item, ett_lbmc_tnwg_capabilities_capabilities1); + proto_tree_add_item(cap1_tree, hf_lbmc_tnwg_capabilities_capabilities1_ume, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1, ENC_BIG_ENDIAN); + proto_tree_add_item(cap1_tree, hf_lbmc_tnwg_capabilities_capabilities1_umq, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_capabilities_capabilities2, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES2, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES2, ENC_BIG_ENDIAN); + cap3 = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3); + cap3_item = proto_tree_add_none_format(subtree, hf_lbmc_tnwg_capabilities_capabilities3, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3, "Capabilities3: 0x%08x", cap3); + cap3_tree = proto_item_add_subtree(cap3_item, ett_lbmc_tnwg_capabilities_capabilities3); + proto_tree_add_item(cap3_tree, hf_lbmc_tnwg_capabilities_capabilities3_pcre, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3, ENC_BIG_ENDIAN); + proto_tree_add_item(cap3_tree, hf_lbmc_tnwg_capabilities_capabilities3_regex, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_capabilities_capabilities4, tvb, offset + O_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES4, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES4, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T); +} + +static int dissect_nhdr_patidx(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_patidx, tvb, offset, L_LBMC_PATIDX_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_patidx); + proto_tree_add_item(subtree, hf_lbmc_patidx_next_hdr, tvb, offset + O_LBMC_PATIDX_HDR_T_NEXT_HDR, L_LBMC_PATIDX_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_patidx_hdr_len, tvb, offset + O_LBMC_PATIDX_HDR_T_HDR_LEN, L_LBMC_PATIDX_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_PATIDX_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_patidx_flags, tvb, offset + O_LBMC_PATIDX_HDR_T_FLAGS, L_LBMC_PATIDX_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_patidx_flags); + proto_tree_add_item(flags_tree, hf_lbmc_patidx_flags_ignore, tvb, offset + O_LBMC_PATIDX_HDR_T_FLAGS, L_LBMC_PATIDX_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_patidx_patidx, tvb, offset + O_LBMC_PATIDX_HDR_T_PATIDX, L_LBMC_PATIDX_HDR_T_PATIDX, ENC_BIG_ENDIAN); + return (L_LBMC_PATIDX_HDR_T); +} + +static int dissect_nhdr_ume_client_lifetime(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_client_lifetime, tvb, offset, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_client_lifetime); + proto_tree_add_item(subtree, hf_lbmc_ume_client_lifetime_next_hdr, tvb, offset + O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_client_lifetime_hdr_len, tvb, offset + O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_client_lifetime_flags, tvb, offset + O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_FLAGS, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_client_lifetime_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_client_lifetime_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_FLAGS, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_client_lifetime_activity_tmo, tvb, offset + O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_ACTIVITY_TMO, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_ACTIVITY_TMO, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_client_lifetime_lifetime, tvb, offset + O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_LIFETIME, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_LIFETIME, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_client_lifetime_ttl, tvb, offset + O_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_TTL, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_TTL, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T); +} + +static int dissect_nhdr_ume_sid(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_sid, tvb, offset, L_LBMC_CNTL_UME_SID_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_sid); + proto_tree_add_item(subtree, hf_lbmc_ume_sid_next_hdr, tvb, offset + O_LBMC_CNTL_UME_SID_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_SID_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_sid_hdr_len, tvb, offset + O_LBMC_CNTL_UME_SID_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_SID_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_SID_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_sid_flags, tvb, offset + O_LBMC_CNTL_UME_SID_HDR_T_FLAGS, L_LBMC_CNTL_UME_SID_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_sid_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_sid_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_SID_HDR_T_FLAGS, L_LBMC_CNTL_UME_SID_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_sid_sid, tvb, offset + O_LBMC_CNTL_UME_SID_HDR_T_SID, L_LBMC_CNTL_UME_SID_HDR_T_SID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_SID_HDR_T); +} + +static int dissect_nhdr_umq_idx_cmd(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + guint8 cmd_type = 0; + proto_item * opt_subtree_item = NULL; + proto_tree * opt_subtree = NULL; + guint32 opt_flags = 0; + proto_item * opt_flags_item = NULL; + proto_tree * opt_flags_tree = NULL; + guint8 index_len = 0; + int opt_len = 0; + int len_dissected = 0; + proto_item * cmd_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_idx_cmd, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_idx_cmd); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_idx_cmd_flags, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_idx_cmd_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_idx_cmd_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_FLAGS, ENC_BIG_ENDIAN); + cmd_type = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_TYPE); + cmd_type_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_cmd_type, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_TYPE, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_cmd_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_ID, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_CMD_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_inst_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_INST_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_regid, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_REGID, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_REGID, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T; + offset += L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T; + switch (cmd_type) + { + case LBMC_UMQ_IDX_CMD_RCV_STOP_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_stop_assign, tvb, offset, L_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_stop_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_stop_assign_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_stop_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_RCV_STOP_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_RCV_START_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_start_assign, tvb, offset, L_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_start_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_start_assign_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_start_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_RCV_START_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_ULB_RCV_STOP_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_ulb_stop_assign, tvb, offset, L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_ulb_stop_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_stop_assign_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_SRC_ID, L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_stop_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_stop_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_stop_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_ULB_RCV_STOP_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_ULB_RCV_START_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_ulb_start_assign, tvb, offset, L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_ulb_start_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_start_assign_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_SRC_ID, L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_start_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_start_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_start_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_ULB_RCV_START_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_release_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T + index_len, ENC_NA); + index_len = opt_len - L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T; + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_release_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_release_assign_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_release_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + opt_flags = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS); + opt_flags_item = proto_tree_add_none_format(opt_subtree, hf_lbmc_umq_idx_cmd_release_assign_flags, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS, "Flags: 0x%08x", opt_flags); + opt_flags_tree = proto_item_add_subtree(opt_flags_item, ett_lbmc_umq_idx_cmd_release_assign_flags); + proto_tree_add_item(opt_flags_tree, hf_lbmc_umq_idx_cmd_release_assign_flags_numeric, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_release_assign_index_len, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX_LEN, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_release_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED, ENC_NA); + if ((opt_flags & LBM_UMQ_INDEX_FLAG_NUMERIC) != 0) + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_release_assign_numeric_index, tvb, offset + L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_BIG_ENDIAN); + } + else + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_release_assign_string_index, tvb, offset + L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_ASCII|ENC_NA); + } + len_dissected += L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T + index_len; + break; + case LBMC_UMQ_IDX_CMD_ULB_RCV_RELEASE_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign, tvb, offset, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T + index_len, ENC_NA); + index_len = opt_len - L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T; + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_ulb_release_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_SRC_ID, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + opt_flags = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS); + opt_flags_item = proto_tree_add_none_format(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign_flags, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS, "Flags: 0x%08x", opt_flags); + opt_flags_tree = proto_item_add_subtree(opt_flags_item, ett_lbmc_umq_idx_cmd_ulb_release_assign_flags); + proto_tree_add_item(opt_flags_tree, hf_lbmc_umq_idx_cmd_ulb_release_assign_flags_numeric, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign_index_len, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX_LEN, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_INDEX_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED, ENC_NA); + if ((opt_flags & LBM_UMQ_INDEX_FLAG_NUMERIC) != 0) + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign_numeric_index, tvb, offset + L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_BIG_ENDIAN); + } + else + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_release_assign_string_index, tvb, offset + L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_ASCII|ENC_NA); + } + len_dissected += L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T + index_len; + break; + case LBMC_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_reserve_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T + index_len, ENC_NA); + index_len = opt_len - L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T; + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_reserve_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_reserve_assign_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_reserve_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + opt_flags = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS); + opt_flags_item = proto_tree_add_none_format(opt_subtree, hf_lbmc_umq_idx_cmd_reserve_assign_flags, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, "Flags: 0x%08x", opt_flags); + opt_flags_tree = proto_item_add_subtree(opt_flags_item, ett_lbmc_umq_idx_cmd_reserve_assign_flags); + proto_tree_add_item(opt_flags_tree, hf_lbmc_umq_idx_cmd_reserve_assign_flags_numeric, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_reserve_assign_index_len, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_reserve_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED, ENC_NA); + if ((opt_flags & LBM_UMQ_INDEX_FLAG_NUMERIC) != 0) + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_reserve_assign_numeric_index, tvb, offset + L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_BIG_ENDIAN); + } + else + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_reserve_assign_string_index, tvb, offset + L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_ASCII|ENC_NA); + } + len_dissected += L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T + index_len; + break; + case LBMC_UMQ_IDX_CMD_ULB_RCV_RESERVE_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign, tvb, offset, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T + index_len, ENC_NA); + index_len = opt_len - L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T; + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_ulb_reserve_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_SRC_ID, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + opt_flags = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS); + opt_flags_item = proto_tree_add_none_format(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_flags, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, "Flags: 0x%08x", opt_flags); + opt_flags_tree = proto_item_add_subtree(opt_flags_item, ett_lbmc_umq_idx_cmd_ulb_reserve_assign_flags); + proto_tree_add_item(opt_flags_tree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_flags_numeric, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_index_len, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED, ENC_NA); + if ((opt_flags & LBM_UMQ_INDEX_FLAG_NUMERIC) != 0) + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_numeric_index, tvb, offset + L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_BIG_ENDIAN); + } + else + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_ulb_reserve_assign_string_index, tvb, offset + L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_ASCII|ENC_NA); + } + len_dissected += L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T + index_len; + break; + default: + expert_add_info_format(pinfo, cmd_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ IDX CMD type 0x%02x", cmd_type); + break; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_idx_cmd_resp(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + guint8 resp_type = 0; + proto_item * opt_subtree_item = NULL; + proto_tree * opt_subtree = NULL; + int string_len = 0; + int len_dissected = 0; + guint32 opt_flags = 0; + proto_item * opt_flags_item = NULL; + proto_tree * opt_flags_tree = NULL; + guint8 index_len = 0; + proto_item * resp_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_idx_cmd_resp, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_idx_cmd_resp); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_idx_cmd_resp_flags, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_idx_cmd_resp_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_idx_cmd_resp_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_umq_idx_cmd_resp_flags_ulb, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + resp_type = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_RESP_TYPE); + resp_type_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_resp_type, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_RESP_TYPE, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_RESP_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_cmd_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_CMD_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_CMD_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_inst_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_INST_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_regid, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_REGID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_REGID, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T; + offset += L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T; + switch (resp_type) + { + case LBMC_UMQ_IDX_CMD_RESP_ERR_TYPE: + string_len = hdrlen - (L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T + L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T); + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_err, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T + string_len, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_err); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_err_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_err_code, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T_CODE, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T_CODE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_err_error_string, tvb, offset + L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T, string_len, ENC_ASCII|ENC_NA); + len_dissected += (L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ERR_HDR_T + string_len); + break; + case LBMC_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_stop_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_stop_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_stop_assign_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_stop_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_STOP_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_start_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_start_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_start_assign_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_start_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_start_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_start_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_START_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_ulb_stop_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_src_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_SRC_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_STOP_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_ulb_start_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_ulb_start_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_src_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_SRC_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_START_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_release_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_release_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_release_assign_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_release_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_release_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_release_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RELEASE_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_TYPE: + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_ulb_release_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_ulb_release_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_src_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_SRC_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected += L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RELEASE_IDX_ASSIGN_HDR_T; + break; + case LBMC_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_TYPE: + index_len = hdrlen - (L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T + L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T); + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign, tvb, offset, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T + index_len, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_reserve_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + opt_flags = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS); + opt_flags_item = proto_tree_add_none_format(opt_subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_flags, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, "Flags: 0x%08x", opt_flags); + opt_flags_tree = proto_item_add_subtree(opt_flags_item, ett_lbmc_umq_idx_cmd_resp_reserve_assign_flags); + proto_tree_add_item(opt_flags_tree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_flags_numeric, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_index_len, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED, ENC_NA); + if ((opt_flags & LBM_UMQ_INDEX_FLAG_NUMERIC) != 0) + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_numeric_index, tvb, offset + L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_BIG_ENDIAN); + } + else + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_reserve_assign_string_index, tvb, offset + L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_ASCII|ENC_NA); + } + len_dissected += (L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T + index_len); + break; + case LBMC_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_TYPE: + index_len = hdrlen - (L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T + L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T); + opt_subtree_item = proto_tree_add_item(subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign, tvb, offset, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T + index_len, ENC_NA); + opt_subtree = proto_item_add_subtree(opt_subtree_item, ett_lbmc_umq_idx_cmd_resp_ulb_reserve_assign); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_src_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_SRC_ID, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + opt_flags = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS); + opt_flags_item = proto_tree_add_none_format(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, "Flags: 0x%08x", opt_flags); + opt_flags_tree = proto_item_add_subtree(opt_flags_item, ett_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags); + proto_tree_add_item(opt_flags_tree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags_numeric, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_index_len, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_INDEX_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_reserved, tvb, offset + O_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_RESERVED, ENC_NA); + if ((opt_flags & LBM_UMQ_INDEX_FLAG_NUMERIC) != 0) + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_numeric_index, tvb, offset + L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_BIG_ENDIAN); + } + else + { + proto_tree_add_item(opt_subtree, hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_string_index, tvb, offset + L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T, (gint)index_len, ENC_ASCII|ENC_NA); + } + len_dissected += (L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T + index_len); + break; + default: + expert_add_info_format(pinfo, resp_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ IDX CMD RESP type 0x%02x", resp_type); + break; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_odomain(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_odomain, tvb, offset, L_LBMC_ODOMAIN_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_odomain); + proto_tree_add_item(subtree, hf_lbmc_odomain_next_hdr, tvb, offset + O_LBMC_ODOMAIN_HDR_T_NEXT_HDR, L_LBMC_ODOMAIN_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_odomain_hdr_len, tvb, offset + O_LBMC_ODOMAIN_HDR_T_HDR_LEN, L_LBMC_ODOMAIN_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_ODOMAIN_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_odomain_flags, tvb, offset + O_LBMC_ODOMAIN_HDR_T_FLAGS, L_LBMC_ODOMAIN_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_odomain_flags); + proto_tree_add_item(flags_tree, hf_lbmc_odomain_flags_ignore, tvb, offset + O_LBMC_ODOMAIN_HDR_T_FLAGS, L_LBMC_ODOMAIN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_odomain_domain, tvb, offset + O_LBMC_ODOMAIN_HDR_T_ODOMAIN, L_LBMC_ODOMAIN_HDR_T_ODOMAIN, ENC_BIG_ENDIAN); + return (L_LBMC_ODOMAIN_HDR_T); +} + +static int dissect_nhdr_stream(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmc_stream_info_t * info) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_stream, tvb, offset, L_LBMC_STREAM_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_stream); + proto_tree_add_item(subtree, hf_lbmc_stream_next_hdr, tvb, offset + O_LBMC_STREAM_HDR_T_NEXT_HDR, L_LBMC_STREAM_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_stream_hdr_len, tvb, offset + O_LBMC_STREAM_HDR_T_HDR_LEN, L_LBMC_STREAM_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_STREAM_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_stream_flags, tvb, offset + O_LBMC_STREAM_HDR_T_FLAGS, L_LBMC_STREAM_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_stream_flags); + proto_tree_add_item(flags_tree, hf_lbmc_stream_flags_ignore, tvb, offset + O_LBMC_STREAM_HDR_T_FLAGS, L_LBMC_STREAM_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_stream_stream_id, tvb, offset + O_LBMC_STREAM_HDR_T_STREAM_ID, L_LBMC_STREAM_HDR_T_STREAM_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_stream_sqn, tvb, offset + O_LBMC_STREAM_HDR_T_SQN, L_LBMC_STREAM_HDR_T_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_stream_ctxinst, tvb, offset + O_LBMC_STREAM_HDR_T_CTXINST, L_LBMC_STREAM_HDR_T_CTXINST, ENC_NA); + if (info != NULL) + { + info->set = TRUE; + info->stream_id = tvb_get_ntohl(tvb, offset + O_LBMC_STREAM_HDR_T_STREAM_ID); + info->sqn = tvb_get_ntohl(tvb, offset + O_LBMC_STREAM_HDR_T_SQN); + tvb_memcpy(tvb, (void *)&(info->ctxinst), offset + O_LBMC_STREAM_HDR_T_CTXINST, L_LBMC_STREAM_HDR_T_CTXINST); + } + return (L_LBMC_STREAM_HDR_T); +} + +static int dissect_nhdr_topic_md_interest(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + guint16 dom_count = 0; + int idx = 0; + int len_dissected = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_topic_md_interest, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_topic_md_interest); + proto_tree_add_item(subtree, hf_lbmc_topic_md_interest_next_hdr, tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_NEXT_HDR, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_md_interest_hdr_len, tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_HDR_LEN, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_topic_md_interest_flags, tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_topic_md_interest_flags); + proto_tree_add_item(flags_tree, hf_lbmc_topic_md_interest_flags_ignore, tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_topic_md_interest_flags_cancel, tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_topic_md_interest_flags_refresh, tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_md_interest_domain_count, tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_DOMAIN_COUNT, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_DOMAIN_COUNT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_md_interest_res1, tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_RES1, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_RES1, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T; + dom_count = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_DOMAIN_COUNT); + offset += L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T; + for (idx = 0; idx < dom_count; ++idx) + { + proto_tree_add_item(subtree, hf_lbmc_topic_md_interest_domain_id, tvb, offset, (gint)sizeof(lbm_uint32_t), ENC_BIG_ENDIAN); + offset += (int)sizeof(lbm_uint32_t); + len_dissected += (int)sizeof(lbm_uint32_t); + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_pattern_md_interest(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + guint16 dom_count = 0; + int idx = 0; + int len_dissected = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_pattern_md_interest, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_pattern_md_interest); + proto_tree_add_item(subtree, hf_lbmc_pattern_md_interest_next_hdr, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_NEXT_HDR, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_md_interest_hdr_len, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_HDR_LEN, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_pattern_md_interest_flags, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_pattern_md_interest_flags); + proto_tree_add_item(flags_tree, hf_lbmc_pattern_md_interest_flags_ignore, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_pattern_md_interest_flags_cancel, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_pattern_md_interest_flags_refresh, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_md_interest_type, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_TYPE, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_md_interest_domain_count, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_DOMAIN_COUNT, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_DOMAIN_COUNT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_md_interest_res1, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_RES1, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_RES1, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_pattern_md_interest_index, tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_INDEX, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_INDEX, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T; + dom_count = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_DOMAIN_COUNT); + offset += L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T; + for (idx = 0; idx < dom_count; ++idx) + { + proto_tree_add_item(subtree, hf_lbmc_pattern_md_interest_domain_id, tvb, offset, (gint)sizeof(lbm_uint32_t), ENC_BIG_ENDIAN); + offset += (int)sizeof(lbm_uint32_t); + len_dissected += (int)sizeof(lbm_uint32_t); + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_lji_req(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_lji_req, tvb, offset, L_LBMC_CNTL_LJI_REQ_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_lji_req); + proto_tree_add_item(subtree, hf_lbmc_lji_req_next_hdr, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_NEXT_HDR, L_LBMC_CNTL_LJI_REQ_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_hdr_len, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_HDR_LEN, L_LBMC_CNTL_LJI_REQ_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_lji_req_flags, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_lji_req_flags); + proto_tree_add_item(flags_tree, hf_lbmc_lji_req_flags_ignore, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_lji_req_flags_l_flag, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_lji_req_flags_m_flag, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_lji_req_flags_o_flag, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_request_idx, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_REQUEST_IDX, L_LBMC_CNTL_LJI_REQ_HDR_T_REQUEST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_transport_idx, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_LJI_REQ_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_topic_idx, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_TOPIC_IDX, L_LBMC_CNTL_LJI_REQ_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_req_ip, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_REQ_IP, L_LBMC_CNTL_LJI_REQ_HDR_T_REQ_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_req_port, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_REQ_PORT, L_LBMC_CNTL_LJI_REQ_HDR_T_REQ_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_res, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_RES, L_LBMC_CNTL_LJI_REQ_HDR_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_tx_low_sqn, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_TX_LOW_SQN, L_LBMC_CNTL_LJI_REQ_HDR_T_TX_LOW_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_rx_req_max, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_RX_REQ_MAX, L_LBMC_CNTL_LJI_REQ_HDR_T_RX_REQ_MAX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_lji_req_rx_req_outstanding_max, tvb, offset + O_LBMC_CNTL_LJI_REQ_HDR_T_RX_REQ_OUTSTANDING_MAX, L_LBMC_CNTL_LJI_REQ_HDR_T_RX_REQ_OUTSTANDING_MAX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_LJI_REQ_HDR_T); +} + +static int dissect_nhdr_tnwg_ka(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_tnwg_ka, tvb, offset, L_LBMC_CNTL_TNWG_KA_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_tnwg_ka); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_next_hdr, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_NEXT_HDR, L_LBMC_CNTL_TNWG_KA_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_hdr_len, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_HDR_LEN, L_LBMC_CNTL_TNWG_KA_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_tnwg_ka_flags, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS, L_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_tnwg_ka_flags); + proto_tree_add_item(flags_tree, hf_lbmc_tnwg_ka_flags_ignore, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS, L_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_tnwg_ka_flags_q_flag, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS, L_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_tnwg_ka_flags_r_flag, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS, L_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_index, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_INDEX, L_LBMC_CNTL_TNWG_KA_HDR_T_INDEX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_ts_seconds, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_TS_SECONDS, L_LBMC_CNTL_TNWG_KA_HDR_T_TS_SECONDS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_ts_microseconds, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_TS_MICROSECONDS, L_LBMC_CNTL_TNWG_KA_HDR_T_TS_MICROSECONDS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_reserved_1, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_1, L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_1, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_reserved_2, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_2, L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_2, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_reserved_3, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_3, L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_3, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_reserved_4, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_4, L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_4, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_reserved_5, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_5, L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_5, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tnwg_ka_reserved_6, tvb, offset + O_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_6, L_LBMC_CNTL_TNWG_KA_HDR_T_RESERVED_6, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_TNWG_KA_HDR_T); +} + +static int dissect_nhdr_ume_receiver_keepalive(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_receiver_keepalive, tvb, offset, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_receiver_keepalive); + proto_tree_add_item(subtree, hf_lbmc_ume_receiver_keepalive_next_hdr, tvb, offset + O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_receiver_keepalive_hdr_len, tvb, offset + O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_receiver_keepalive_flags, tvb, offset + O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_FLAGS, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_receiver_keepalive_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_receiver_keepalive_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_FLAGS, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_receiver_keepalive_rcv_regid, tvb, offset + O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_RCV_REGID, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_RCV_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_receiver_keepalive_session_id, tvb, offset + O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_SESSION_ID, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_SESSION_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_receiver_keepalive_ctxinst, tvb, offset + O_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_CTXINST, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_CTXINST, ENC_NA); + return (L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T); +} + +static int dissect_nhdr_umq_ctx_queue_topic_list(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_topic_list, tvb, offset, L_LBMC_CNTL_UMQ_CTX_QUEUE_TOPIC_LIST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_topic_list); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_topic_list_serial_num, tvb, offset + O_LBMC_CNTL_UMQ_CTX_QUEUE_TOPIC_LIST_HDR_T_SERIAL_NUM, L_LBMC_CNTL_UMQ_CTX_QUEUE_TOPIC_LIST_HDR_T_SERIAL_NUM, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_CTX_QUEUE_TOPIC_LIST_HDR_T); +} + +static int dissect_nhdr_umq_rcv_msg_retrieve_entry(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_msg_retrieve_entry, tvb, offset, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_msg_retrieve_entry); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_retrieve_entry_regid, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T_REGID, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_retrieve_entry_stamp, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STAMP, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STAMP, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_ENTRY_HDR_T); +} + +static int dissect_nhdr_umq_rcv_msg_retrieve(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int len = 0; + int dissected_len = 0; + guint8 num_msgids; + guint8 idx; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_msg_retrieve, tvb, offset, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_msg_retrieve); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_retrieve_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_retrieve_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_retrieve_info_only, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_INFO_ONLY, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_INFO_ONLY, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_retrieve_num_msgids, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGIDS, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGIDS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_retrieve_flags, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + + dissected_len = L_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T; + num_msgids = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGIDS); + for (idx = 0; idx < num_msgids; ++idx) + { + len = dissect_nhdr_umq_rcv_msg_retrieve_entry(tvb, offset + dissected_len, pinfo, subtree); + dissected_len += len; + } + proto_item_set_len(subtree_item, dissected_len); + return (dissected_len); +} + +static int dissect_nhdr_umq_rcv_msg_list(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_msg_list, tvb, offset, L_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_msg_list); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_list_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_msg_list_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_RCV_MSG_LIST_HDR_T); +} + +static int dissect_nhdr_umq_cmd(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + int len_dissected = 0; + guint8 cmd_type = 0; + proto_item * cmd_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_CMD_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_CMD_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_cmd_flags, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_CMD_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_cmd_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_cmd_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_CMD_HDR_T_FLAGS, ENC_BIG_ENDIAN); + cmd_type_item = proto_tree_add_item(subtree, hf_lbmc_umq_cmd_cmd_type, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_TYPE, L_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_CMD_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_cmd_id, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_ID, L_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_inst_idx, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_INST_IDX, L_LBMC_CNTL_UMQ_CMD_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_regid, tvb, offset + O_LBMC_CNTL_UMQ_CMD_HDR_T_REGID, L_LBMC_CNTL_UMQ_CMD_HDR_T_REGID, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_CMD_HDR_T; + cmd_type = tvb_get_guint8(tvb, O_LBMC_CNTL_UMQ_CMD_HDR_T_CMD_TYPE); + switch (cmd_type) + { + case LBMC_UMQ_CMD_TYPE_TOPIC_LIST: + len_dissected += dissect_nhdr_umq_ctx_queue_topic_list(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_CMD_TYPE_RCV_MSG_RETRIEVE: + len_dissected += dissect_nhdr_umq_rcv_msg_retrieve(tvb, offset + len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_CMD_TYPE_RCV_MSG_LIST: + len_dissected += dissect_nhdr_umq_rcv_msg_list(tvb, offset + len_dissected, pinfo, subtree); + break; + default: + expert_add_info_format(pinfo, cmd_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ CMD cmd_type 0x%02x", cmd_type); + break; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_cmd_resp_rcv_msg_retrieve(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp_msg_retrieve, tvb, offset, L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp_msg_retrieve); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_msg_retrieve_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_msg_retrieve_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T); +} + +static int dissect_nhdr_umq_cmd_resp_rcv_xmsg_retrieve(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int len_dissected; + int num_msgs; + int entry_offset; + proto_item * entry_item = NULL; + proto_tree * entry_tree = NULL; + int idx; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp_xmsg_retrieve, tvb, offset, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp_xmsg_retrieve); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_num_msgs, tvb, offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGS, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_flags, tvb, offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_FLAGS, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_reserved, tvb, offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_RESERVED, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T; + entry_offset = offset + len_dissected; + num_msgs = (int)tvb_get_guint8(tvb, offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_HDR_T_NUM_MSGS); + for (idx = 0; idx < num_msgs; ++idx) + { + entry_item = proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry, tvb, entry_offset, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T, ENC_NA); + entry_tree = proto_item_add_subtree(entry_item, ett_lbmc_umq_cmd_resp_xmsg_retrieve_entry); + proto_tree_add_item(entry_tree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_regid, tvb, entry_offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_REGID, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(entry_tree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_stamp, tvb, entry_offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STAMP, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STAMP, ENC_BIG_ENDIAN); + proto_tree_add_item(entry_tree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_assign_id, tvb, entry_offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_ASSIGN_ID, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(entry_tree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_num_ras, tvb, entry_offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_NUM_RAS, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_NUM_RAS, ENC_BIG_ENDIAN); + proto_tree_add_item(entry_tree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_status, tvb, entry_offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STATUS, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_STATUS, ENC_BIG_ENDIAN); + proto_tree_add_item(entry_tree, hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_reserved, tvb, entry_offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_RESERVED, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T_RESERVED, ENC_BIG_ENDIAN); + entry_offset += L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T; + len_dissected += L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_RETRIEVE_ENTRY_HDR_T; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_cmd_resp_rcv_msg_list(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp_msg_list, tvb, offset, L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp_msg_list); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_msg_list_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_msg_list_assign_id, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_ASSIGN_ID, L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_ASSIGN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T); +} + +static int dissect_nhdr_umq_cmd_resp_rcv_xmsg_list(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int len_dissected = 0; + guint64 num_msgs = 0; + int entry_offset = 0; + proto_item * entry_item = NULL; + proto_tree * entry_tree = NULL; + guint64 idx; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp_xmsg_list, tvb, offset, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp_xmsg_list); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_xmsg_list_num_msgs, tvb, offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_NUM_MSGS, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_NUM_MSGS, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T; + entry_offset = offset + len_dissected; + num_msgs = tvb_get_ntoh64(tvb, offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_HDR_T_NUM_MSGS); + for (idx = 0; idx < num_msgs; ++idx) + { + entry_item = proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_xmsg_list_entry, tvb, entry_offset, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T, ENC_NA); + entry_tree = proto_item_add_subtree(entry_item, ett_lbmc_umq_cmd_resp_xmsg_list_entry); + proto_tree_add_item(entry_tree, hf_lbmc_umq_cmd_resp_xmsg_list_entry_regid, tvb, entry_offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T_REGID, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(entry_tree, hf_lbmc_umq_cmd_resp_xmsg_list_entry_stamp, tvb, entry_offset + O_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T_STAMP, L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T_STAMP, ENC_BIG_ENDIAN); + entry_offset += L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T; + len_dissected += L_LBMC_XCNTL_UMQ_CMD_RESP_RCV_MSG_LIST_MSG_ENTRY_HDR_T; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_cmd_resp_ctx_topic_list_appset_entry(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int len_dissected = 0; + guint8 appset_name_len; + guint16 num_receiver_type_ids; + guint16 idx; + int receiver_type_id_offset; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry, tvb, offset, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_num_receiver_type_ids, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_NUM_RECEIVER_TYPE_IDS, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_NUM_RECEIVER_TYPE_IDS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_appset_idx, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_IDX, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_appset_name_len, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_NAME_LEN, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_NAME_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_reserved, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_RESERVED, ENC_NA); + len_dissected = L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T; + appset_name_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_APPSET_NAME_LEN); + len_dissected += (int)appset_name_len; + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_name, tvb, offset + L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T, (int)appset_name_len, ENC_ASCII|ENC_NA); + num_receiver_type_ids = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_APPSET_ENTRY_HDR_T_NUM_RECEIVER_TYPE_IDS); + if (num_receiver_type_ids > 0) + { + receiver_type_id_offset = offset + len_dissected; + for (idx = 0; idx < num_receiver_type_ids; ++idx) + { + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_receiver_type_id, tvb, receiver_type_id_offset, sizeof(lbm_uint32_t), ENC_BIG_ENDIAN); + len_dissected += (int)sizeof(lbm_uint32_t); + receiver_type_id_offset += (int)sizeof(lbm_uint32_t); + } + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_cmd_resp_ctx_topic_list_topic_entry(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int len_dissected = 0; + guint8 topic_len; + guint16 num_appsets; + guint16 idx; + int appset_offset; + int len; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry, tvb, offset, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp_topic_list_topic_entry); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_rcr_idx, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_RCR_IDX, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_RCR_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_num_appsets, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_NUM_APPSETS, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_NUM_APPSETS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_topic_len, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_TOPIC_LEN, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_TOPIC_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_reserved, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T; + topic_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_TOPIC_LEN); + len_dissected += (int)topic_len; + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_topic_entry_topic, tvb, offset + L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T, (int)topic_len, ENC_ASCII|ENC_NA); + num_appsets = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_TOPIC_ENTRY_HDR_T_NUM_APPSETS); + if (num_appsets > 0) + { + appset_offset = offset + len_dissected; + for (idx = 0; idx < num_appsets; ++idx) + { + len = dissect_nhdr_umq_cmd_resp_ctx_topic_list_appset_entry(tvb, appset_offset, pinfo, subtree); + appset_offset += len; + len_dissected += len; + } + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_cmd_resp_ctx_topic_list(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int len_dissected = 0; + int len; + guint32 num_topics; + guint32 idx; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp_topic_list, tvb, offset, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp_topic_list); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_topic_list_num_topics, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_HDR_T_NUM_TOPICS, L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_HDR_T_NUM_TOPICS, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_HDR_T; + num_topics = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_CTX_TOPIC_LIST_HDR_T_NUM_TOPICS); + for (idx = 0; idx < num_topics; ++idx) + { + len = dissect_nhdr_umq_cmd_resp_ctx_topic_list_topic_entry(tvb, offset + len_dissected, pinfo, subtree); + len_dissected += len; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_cmd_resp_err(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int len_dissected = 0; + int errmsg_len; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp_err, tvb, offset, L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp_err); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_err_reserved, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T_RESERVED, L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_err_code, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T_CODE, L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T_CODE, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T; + errmsg_len = tvb_reported_length_remaining(tvb, offset + L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_err_errmsg, tvb, offset + L_LBMC_CNTL_UMQ_CMD_RESP_ERR_HDR_T, errmsg_len, ENC_ASCII|ENC_NA); + len_dissected += errmsg_len; + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_umq_cmd_resp(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, gboolean data_msg) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + int len_dissected = 0; + int len; + guint8 resp_type; + proto_item * resp_type_item = NULL; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_cmd_resp, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_cmd_resp); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_cmd_resp_flags, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_cmd_resp_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_cmd_resp_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + resp_type_item = proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_resp_type, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_RESP_TYPE, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_RESP_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_queue_id, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_QUEUE_ID, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_cmd_id, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_CMD_ID, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_CMD_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_inst_idx, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_INST_IDX, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_cmd_resp_regid, tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_REGID, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_REGID, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T; + resp_type = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_RESP_TYPE); + if (tvb_length_remaining(tvb, offset + L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T) > 0) + { + switch (resp_type) + { + case LBMC_UMQ_CMD_RESP_TYPE_CTX_TOPIC_LIST: + len = dissect_nhdr_umq_cmd_resp_ctx_topic_list(tvb, len_dissected, pinfo, subtree); + break; + case LBMC_UMQ_CMD_RESP_TYPE_RCV_MSG_RETRIEVE: + if (data_msg) + { + len = dissect_nhdr_umq_cmd_resp_rcv_xmsg_retrieve(tvb, len_dissected, pinfo, subtree); + } + else + { + len = dissect_nhdr_umq_cmd_resp_rcv_msg_retrieve(tvb, len_dissected, pinfo, subtree); + } + break; + case LBMC_UMQ_CMD_RESP_TYPE_RCV_MSG_LIST: + if (data_msg) + { + len = dissect_nhdr_umq_cmd_resp_rcv_xmsg_list(tvb, len_dissected, pinfo, subtree); + } + else + { + len = dissect_nhdr_umq_cmd_resp_rcv_msg_list(tvb, len_dissected, pinfo, subtree); + } + break; + case LBMC_UMQ_CMD_RESP_TYPE_ERROR: + len = dissect_nhdr_umq_cmd_resp_err(tvb, len_dissected, pinfo, subtree); + break; + default: + expert_add_info_format(pinfo, resp_type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC UMQ CMD_RESP cmd_type 0x%02x", resp_type); + len = 0; + break; + } + } + else + { + len = 0; + } + len_dissected += len; + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_sri_req(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_sri_req, tvb, offset, L_LBMC_CNTL_SRI_REQ_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_sri_req); + proto_tree_add_item(subtree, hf_lbmc_sri_req_next_hdr, tvb, offset + O_LBMC_CNTL_SRI_REQ_HDR_T_NEXT_HDR, L_LBMC_CNTL_SRI_REQ_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_sri_req_hdr_len, tvb, offset + O_LBMC_CNTL_SRI_REQ_HDR_T_HDR_LEN, L_LBMC_CNTL_SRI_REQ_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_SRI_REQ_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_sri_req_flags, tvb, offset + O_LBMC_CNTL_SRI_REQ_HDR_T_FLAGS, L_LBMC_CNTL_SRI_REQ_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_sri_req_flags); + proto_tree_add_item(flags_tree, hf_lbmc_sri_req_flags_ignore, tvb, offset + O_LBMC_CNTL_SRI_REQ_HDR_T_FLAGS, L_LBMC_CNTL_SRI_REQ_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_sri_req_transport_idx, tvb, offset + O_LBMC_CNTL_SRI_REQ_HDR_T_TRANSPORT_IDX, L_LBMC_CNTL_SRI_REQ_HDR_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_sri_req_topic_idx, tvb, offset + O_LBMC_CNTL_SRI_REQ_HDR_T_TOPIC_IDX, L_LBMC_CNTL_SRI_REQ_HDR_T_TOPIC_IDX, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_SRI_REQ_HDR_T); +} + +static int dissect_nhdr_ume_store_domain(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_store_domain, tvb, offset, L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_store_domain); + proto_tree_add_item(subtree, hf_lbmc_ume_store_domain_next_hdr, tvb, offset + O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_domain_hdr_len, tvb, offset + O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_store_domain_flags, tvb, offset + O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_FLAGS, L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_store_domain_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_store_domain_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_FLAGS, L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_domain_domain, tvb, offset + O_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_DOMAIN, L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_DOMAIN, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T); +} + +static int dissect_nhdr_sri(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_sri, tvb, offset, L_LBMC_CNTL_SRI_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_sri); + proto_tree_add_item(subtree, hf_lbmc_sri_next_hdr, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_NEXT_HDR, L_LBMC_CNTL_SRI_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_sri_hdr_len, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_HDR_LEN, L_LBMC_CNTL_SRI_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_SRI_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_sri_flags, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_FLAGS, L_LBMC_CNTL_SRI_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_sri_flags); + proto_tree_add_item(flags_tree, hf_lbmc_sri_flags_ignore, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_FLAGS, L_LBMC_CNTL_SRI_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_sri_flags_acktosrc, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_FLAGS, L_LBMC_CNTL_SRI_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_sri_flags_initial_sqn_known, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_FLAGS, L_LBMC_CNTL_SRI_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_sri_version, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_VERSION, L_LBMC_CNTL_SRI_HDR_T_VERSION, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_sri_low_sqn, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_LOW_SQN, L_LBMC_CNTL_SRI_HDR_T_LOW_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_sri_high_sqn, tvb, offset + O_LBMC_CNTL_SRI_HDR_T_HIGH_SQN, L_LBMC_CNTL_SRI_HDR_T_HIGH_SQN, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_SRI_HDR_T); +} + +static int dissect_nhdr_route_info(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_route_info, tvb, offset, L_LBMC_CNTL_ROUTE_INFO_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_route_info); + proto_tree_add_item(subtree, hf_lbmc_route_info_next_hdr, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_NEXT_HDR, L_LBMC_CNTL_ROUTE_INFO_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_hdr_len, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_HDR_LEN, L_LBMC_CNTL_ROUTE_INFO_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_route_info_flags, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_FLAGS, L_LBMC_CNTL_ROUTE_INFO_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_route_info_flags); + proto_tree_add_item(flags_tree, hf_lbmc_route_info_flags_ignore, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_FLAGS, L_LBMC_CNTL_ROUTE_INFO_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_gateway_version, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_GATEWAY_VERSION, L_LBMC_CNTL_ROUTE_INFO_HDR_T_GATEWAY_VERSION, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_configuration_signature, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_CONFIGURATION_SIGNATURE, L_LBMC_CNTL_ROUTE_INFO_HDR_T_CONFIGURATION_SIGNATURE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_node_id, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_NODE_ID, L_LBMC_CNTL_ROUTE_INFO_HDR_T_NODE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_topology, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_TOPOLOGY, L_LBMC_CNTL_ROUTE_INFO_HDR_T_TOPOLOGY, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_vers, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_VERS, L_LBMC_CNTL_ROUTE_INFO_HDR_T_VERS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_sqn, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_SQN, L_LBMC_CNTL_ROUTE_INFO_HDR_T_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_ttl, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_TTL, L_LBMC_CNTL_ROUTE_INFO_HDR_T_TTL, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_reserved1, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_RESERVED1, L_LBMC_CNTL_ROUTE_INFO_HDR_T_RESERVED1, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_reserved2, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_HDR_T_RESERVED2, L_LBMC_CNTL_ROUTE_INFO_HDR_T_RESERVED2, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_ROUTE_INFO_HDR_T); +} + +static int dissect_nhdr_route_info_neighbor(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_route_info_neighbor, tvb, offset, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_route_info_neighbor); + proto_tree_add_item(subtree, hf_lbmc_route_info_neighbor_next_hdr, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_NEXT_HDR, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_neighbor_hdr_len, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_HDR_LEN, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_route_info_neighbor_flags, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_FLAGS, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_route_info_neighbor_flags); + proto_tree_add_item(flags_tree, hf_lbmc_route_info_neighbor_flags_ignore, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_FLAGS, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_neighbor_node_id, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_NODE_ID, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_NODE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_neighbor_ingress_cost, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_INGRESS_COST, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_INGRESS_COST, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_route_info_neighbor_egress_cost, tvb, offset + O_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_EGRESS_COST, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_EGRESS_COST, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T); +} + +static int dissect_nhdr_gateway_name(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_GATEWAY_NAME_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_gateway_name, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_gateway_name); + proto_tree_add_item(subtree, hf_lbmc_gateway_name_next_hdr, tvb, offset + O_LBMC_CNTL_GATEWAY_NAME_HDR_T_NEXT_HDR, L_LBMC_CNTL_GATEWAY_NAME_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_gateway_name_hdr_len, tvb, offset + O_LBMC_CNTL_GATEWAY_NAME_HDR_T_HDR_LEN, L_LBMC_CNTL_GATEWAY_NAME_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_gateway_name_flags, tvb, offset + O_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS, L_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_gateway_name_flags); + proto_tree_add_item(flags_tree, hf_lbmc_gateway_name_flags_ignore, tvb, offset + O_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS, L_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_gateway_name_gateway_name, tvb, offset + O_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS + L_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS, (gint)(hdrlen - L_LBMC_BASIC_HDR_T), ENC_ASCII|ENC_NA); + return ((int)hdrlen); +} + +static int dissect_nhdr_auth_request(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + int len_dissected = 0; + guint8 user_len; + int data_offset; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_auth_request, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_auth_request); + proto_tree_add_item(subtree, hf_lbmc_auth_request_next_hdr, tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_NEXT_HDR, L_LBMC_CNTL_AUTH_REQUEST_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_request_hdr_len, tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_HDR_LEN, L_LBMC_CNTL_AUTH_REQUEST_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_auth_request_flags, tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_REQUEST_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_auth_request_flags); + proto_tree_add_item(flags_tree, hf_lbmc_auth_request_flags_ignore, tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_REQUEST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_request_opid, tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_OPID, L_LBMC_CNTL_AUTH_REQUEST_HDR_T_OPID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_request_user_len, tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_USER_LEN, L_LBMC_CNTL_AUTH_REQUEST_HDR_T_USER_LEN, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_AUTH_REQUEST_HDR_T; + data_offset = offset + len_dissected; + user_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_REQUEST_HDR_T_USER_LEN); + if (user_len > 0) + { + proto_tree_add_item(subtree, hf_lbmc_auth_request_user_name, tvb, data_offset, (int)user_len, ENC_ASCII|ENC_NA); + len_dissected += (int)user_len; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_auth_challenge(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + int len_dissected = 0; + guint8 mod_len; + guint8 gen_len; + guint8 salt_len; + guint8 pubkey_len; + int data_offset; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_auth_challenge, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_auth_challenge); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_next_hdr, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_NEXT_HDR, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_hdr_len, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_HDR_LEN, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_auth_challenge_flags, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_auth_challenge_flags); + proto_tree_add_item(flags_tree, hf_lbmc_auth_challenge_flags_ignore, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_opid, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_OPID, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_OPID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_mod_len, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_MOD_LEN, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_MOD_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_gen_len, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_GEN_LEN, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_GEN_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_salt_len, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_SALT_LEN, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_SALT_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_pubkey_len, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_PUBKEY_LEN, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_PUBKEY_LEN, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T; + data_offset = offset + len_dissected; + mod_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_MOD_LEN); + if (mod_len > 0) + { + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_mod, tvb, data_offset, (int)mod_len, ENC_NA); + len_dissected += (int)mod_len; + data_offset += (int)mod_len; + } + gen_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_GEN_LEN); + if (gen_len > 0) + { + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_gen, tvb, data_offset, (int)gen_len, ENC_NA); + len_dissected += (int)gen_len; + data_offset += (int)gen_len; + } + salt_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_SALT_LEN); + if (salt_len > 0) + { + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_salt, tvb, data_offset, (int)salt_len, ENC_NA); + len_dissected += (int)salt_len; + data_offset += (int)salt_len; + } + pubkey_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_PUBKEY_LEN); + if (pubkey_len > 0) + { + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_pubkey, tvb, data_offset, (int)pubkey_len, ENC_NA); + len_dissected += (int)pubkey_len; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_auth_challenge_rsp(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + int len_dissected = 0; + guint8 pubkey_len; + guint8 evidence_len; + int data_offset; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_auth_challenge_rsp, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_auth_challenge_rsp); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_rsp_next_hdr, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_NEXT_HDR, L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_rsp_hdr_len, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_HDR_LEN, L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_auth_challenge_rsp_flags, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_auth_challenge_rsp_flags); + proto_tree_add_item(flags_tree, hf_lbmc_auth_challenge_rsp_flags_ignore, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_rsp_opid, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_OPID, L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_OPID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_rsp_pubkey_len, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_PUBKEY_LEN, L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_PUBKEY_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_rsp_evidence_len, tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_EVIDENCE_LEN, L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_EVIDENCE_LEN, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T; + data_offset = offset + len_dissected; + pubkey_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_PUBKEY_LEN); + if (pubkey_len > 0) + { + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_rsp_pubkey, tvb, data_offset, (int)pubkey_len, ENC_NA); + len_dissected += (int)pubkey_len; + data_offset += (int)pubkey_len; + } + evidence_len = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_EVIDENCE_LEN); + if (evidence_len > 0) + { + proto_tree_add_item(subtree, hf_lbmc_auth_challenge_rsp_evidence, tvb, data_offset, (int)evidence_len, ENC_NA); + len_dissected += (int)evidence_len; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_auth_result(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_auth_result, tvb, offset, L_LBMC_CNTL_AUTH_RESULT_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_auth_result); + proto_tree_add_item(subtree, hf_lbmc_auth_result_next_hdr, tvb, offset + O_LBMC_CNTL_AUTH_RESULT_HDR_T_NEXT_HDR, L_LBMC_CNTL_AUTH_RESULT_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_result_hdr_len, tvb, offset + O_LBMC_CNTL_AUTH_RESULT_HDR_T_HDR_LEN, L_LBMC_CNTL_AUTH_RESULT_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_RESULT_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_auth_result_flags, tvb, offset + O_LBMC_CNTL_AUTH_RESULT_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_RESULT_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_auth_result_flags); + proto_tree_add_item(flags_tree, hf_lbmc_auth_result_flags_ignore, tvb, offset + O_LBMC_CNTL_AUTH_RESULT_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_RESULT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_result_opid, tvb, offset + O_LBMC_CNTL_AUTH_RESULT_HDR_T_OPID, L_LBMC_CNTL_AUTH_RESULT_HDR_T_OPID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_result_result, tvb, offset + O_LBMC_CNTL_AUTH_RESULT_HDR_T_RESULT, L_LBMC_CNTL_AUTH_RESULT_HDR_T_RESULT, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_AUTH_RESULT_HDR_T); +} + +static int dissect_nhdr_auth_unknown(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * opid_item = NULL; + guint8 opid; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_GENERIC_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_auth_unknown, tvb, offset, (int) hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_auth_unknown); + proto_tree_add_item(subtree, hf_lbmc_auth_unknown_next_hdr, tvb, offset + O_LBMC_CNTL_AUTH_GENERIC_HDR_T_NEXT_HDR, L_LBMC_CNTL_AUTH_GENERIC_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_unknown_hdr_len, tvb, offset + O_LBMC_CNTL_AUTH_GENERIC_HDR_T_HDR_LEN, L_LBMC_CNTL_AUTH_GENERIC_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_auth_unknown_flags, tvb, offset + O_LBMC_CNTL_AUTH_GENERIC_HDR_T_FLAGS, L_LBMC_CNTL_AUTH_GENERIC_HDR_T_FLAGS, ENC_BIG_ENDIAN); + opid_item = proto_tree_add_item(subtree, hf_lbmc_auth_unknown_opid, tvb, offset + O_LBMC_CNTL_AUTH_GENERIC_HDR_T_OPID, L_LBMC_CNTL_AUTH_GENERIC_HDR_T_OPID, ENC_BIG_ENDIAN); + opid = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_AUTH_GENERIC_HDR_T_OPID); + expert_add_info_format(pinfo, opid_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC AUTH OPID 0x%02x", opid); + proto_tree_add_item(subtree, hf_lbmc_auth_unknown_data, tvb, offset + L_LBMC_CNTL_AUTH_GENERIC_HDR_T, (int) hdrlen - L_LBMC_CNTL_AUTH_GENERIC_HDR_T, ENC_NA); + return ((int) hdrlen); +} + +static int dissect_nhdr_hmac(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_hmac, tvb, offset, L_LBMC_CNTL_HMAC_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_hmac); + proto_tree_add_item(subtree, hf_lbmc_hmac_next_hdr, tvb, offset + O_LBMC_CNTL_HMAC_HDR_T_NEXT_HDR, L_LBMC_CNTL_HMAC_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_hmac_hdr_len, tvb, offset + O_LBMC_CNTL_HMAC_HDR_T_HDR_LEN, L_LBMC_CNTL_HMAC_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_HMAC_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_hmac_flags, tvb, offset + O_LBMC_CNTL_HMAC_HDR_T_FLAGS, L_LBMC_CNTL_HMAC_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_hmac_flags); + proto_tree_add_item(flags_tree, hf_lbmc_hmac_flags_ignore, tvb, offset + O_LBMC_CNTL_HMAC_HDR_T_FLAGS, L_LBMC_CNTL_HMAC_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_hmac_padding, tvb, offset + O_LBMC_CNTL_HMAC_HDR_T_PADDING, L_LBMC_CNTL_HMAC_HDR_T_PADDING, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_hmac_data, tvb, offset + O_LBMC_CNTL_HMAC_HDR_T_DATA, L_LBMC_CNTL_HMAC_HDR_T_DATA, ENC_NA); + return (L_LBMC_CNTL_HMAC_HDR_T); +} + +static int dissect_nhdr_umq_sid(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_umq_sid, tvb, offset, L_LBMC_CNTL_UMQ_SID_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_umq_sid); + proto_tree_add_item(subtree, hf_lbmc_umq_sid_next_hdr, tvb, offset + O_LBMC_CNTL_UMQ_SID_HDR_T_NEXT_HDR, L_LBMC_CNTL_UMQ_SID_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_sid_hdr_len, tvb, offset + O_LBMC_CNTL_UMQ_SID_HDR_T_HDR_LEN, L_LBMC_CNTL_UMQ_SID_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_CNTL_UMQ_SID_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_umq_sid_flags, tvb, offset + O_LBMC_CNTL_UMQ_SID_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_SID_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_umq_sid_flags); + proto_tree_add_item(flags_tree, hf_lbmc_umq_sid_flags_ignore, tvb, offset + O_LBMC_CNTL_UMQ_SID_HDR_T_FLAGS, L_LBMC_CNTL_UMQ_SID_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_sid_key, tvb, offset + O_LBMC_CNTL_UMQ_SID_HDR_T_KEY, L_LBMC_CNTL_UMQ_SID_HDR_T_KEY, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_umq_sid_sid, tvb, offset + O_LBMC_CNTL_UMQ_SID_HDR_T_SID, L_LBMC_CNTL_UMQ_SID_HDR_T_SID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UMQ_SID_HDR_T); +} + +static int dissect_nhdr_destination(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmc_destination_info_t * info) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_destination, tvb, offset, L_LBMC_DESTINATION_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_destination); + proto_tree_add_item(subtree, hf_lbmc_destination_next_hdr, tvb, offset + O_LBMC_DESTINATION_HDR_T_NEXT_HDR, L_LBMC_DESTINATION_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_hdr_len, tvb, offset + O_LBMC_DESTINATION_HDR_T_HDR_LEN, L_LBMC_DESTINATION_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_DESTINATION_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_destination_flags, tvb, offset + O_LBMC_DESTINATION_HDR_T_FLAGS, L_LBMC_DESTINATION_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_destination_flags); + proto_tree_add_item(flags_tree, hf_lbmc_destination_flags_ignore, tvb, offset + O_LBMC_DESTINATION_HDR_T_FLAGS, L_LBMC_DESTINATION_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_domain_id, tvb, offset + O_LBMC_DESTINATION_HDR_T_DOMAIN_ID, L_LBMC_DESTINATION_HDR_T_DOMAIN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_ipaddr, tvb, offset + O_LBMC_DESTINATION_HDR_T_IPADDR, L_LBMC_DESTINATION_HDR_T_IPADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_port, tvb, offset + O_LBMC_DESTINATION_HDR_T_PORT, L_LBMC_DESTINATION_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_hops_taken, tvb, offset + O_LBMC_DESTINATION_HDR_T_HOPS_TAKEN, L_LBMC_DESTINATION_HDR_T_HOPS_TAKEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_orig_domain_id, tvb, offset + O_LBMC_DESTINATION_HDR_T_ORIG_DOMAIN_ID, L_LBMC_DESTINATION_HDR_T_ORIG_DOMAIN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_orig_ipaddr, tvb, offset + O_LBMC_DESTINATION_HDR_T_ORIG_IPADDR, L_LBMC_DESTINATION_HDR_T_ORIG_IPADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_orig_port, tvb, offset + O_LBMC_DESTINATION_HDR_T_ORIG_PORT, L_LBMC_DESTINATION_HDR_T_ORIG_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_destination_reserved, tvb, offset + O_LBMC_DESTINATION_HDR_T_RESERVED, L_LBMC_DESTINATION_HDR_T_RESERVED, ENC_BIG_ENDIAN); + if (info != NULL) + { + info->set = TRUE; + info->endpoint_a.domain = tvb_get_ntohl(tvb, offset + O_LBMC_DESTINATION_HDR_T_DOMAIN_ID); + TVB_SET_ADDRESS(&(info->endpoint_a.addr), AT_IPv4, tvb, offset + O_LBMC_DESTINATION_HDR_T_IPADDR, L_LBMC_DESTINATION_HDR_T_IPADDR); + info->endpoint_a.port = tvb_get_ntohs(tvb, offset + O_LBMC_DESTINATION_HDR_T_PORT); + info->endpoint_b.domain = tvb_get_ntohl(tvb, offset + O_LBMC_DESTINATION_HDR_T_ORIG_DOMAIN_ID); + TVB_SET_ADDRESS(&(info->endpoint_b.addr), AT_IPv4, tvb, offset + O_LBMC_DESTINATION_HDR_T_ORIG_IPADDR, L_LBMC_DESTINATION_HDR_T_ORIG_IPADDR); + info->endpoint_b.port = tvb_get_ntohs(tvb, offset + O_LBMC_DESTINATION_HDR_T_ORIG_PORT); + } + return (L_LBMC_DESTINATION_HDR_T); +} + +static int dissect_nhdr_topic_idx(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint8 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_topic_idx, tvb, offset, L_LBMC_TOPIC_IDX_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_topic_idx); + proto_tree_add_item(subtree, hf_lbmc_topic_idx_next_hdr, tvb, offset + O_LBMC_TOPIC_IDX_HDR_T_NEXT_HDR, L_LBMC_TOPIC_IDX_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_idx_hdr_len, tvb, offset + O_LBMC_TOPIC_IDX_HDR_T_HDR_LEN, L_LBMC_TOPIC_IDX_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_TOPIC_IDX_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_topic_idx_flags, tvb, offset + O_LBMC_TOPIC_IDX_HDR_T_FLAGS, L_LBMC_TOPIC_IDX_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_topic_idx_flags); + proto_tree_add_item(flags_tree, hf_lbmc_topic_idx_flags_ignore, tvb, offset + O_LBMC_TOPIC_IDX_HDR_T_FLAGS, L_LBMC_TOPIC_IDX_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_idx_tidx, tvb, offset + O_LBMC_TOPIC_IDX_HDR_T_TIDX, L_LBMC_TOPIC_IDX_HDR_T_TIDX, ENC_BIG_ENDIAN); + return (L_LBMC_TOPIC_IDX_HDR_T); +} + +static int dissect_nhdr_topic_source(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_topic_source, tvb, offset, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_topic_source); + proto_tree_add_item(subtree, hf_lbmc_topic_source_next_hdr, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_NEXT_HDR, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_source_hdr_len, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_HDR_LEN, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_topic_source_flags, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_topic_source_flags); + proto_tree_add_item(flags_tree, hf_lbmc_topic_source_flags_ignore, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_topic_source_flags_eos, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_source_domain_id, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_HDR_T_DOMAIN_ID, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_DOMAIN_ID, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_TOPIC_SOURCE_HDR_T); +} + +static int dissect_nhdr_topic_source_exfunc(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + proto_item * functionality_flags_item = NULL; + proto_tree * functionality_flags_tree = NULL; + guint32 functionality_flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_topic_source_exfunc, tvb, offset, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_topic_source_exfunc); + proto_tree_add_item(subtree, hf_lbmc_topic_source_exfunc_next_hdr, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_NEXT_HDR, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_source_exfunc_hdr_len, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_HDR_LEN, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_topic_source_exfunc_flags, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_topic_source_exfunc_flags); + proto_tree_add_item(flags_tree, hf_lbmc_topic_source_exfunc_flags_ignore, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_source_exfunc_src_ip, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_SRC_IP, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_SRC_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_source_exfunc_src_port, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_SRC_PORT, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_SRC_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_topic_source_exfunc_unused, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_UNUSED, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_UNUSED, ENC_BIG_ENDIAN); + functionality_flags = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS); + functionality_flags_item = proto_tree_add_none_format(subtree, hf_lbmc_topic_source_exfunc_functionality_flags, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, "Flags: 0x%08x", functionality_flags); + functionality_flags_tree = proto_item_add_subtree(functionality_flags_item, ett_lbmc_topic_source_exfunc_functionality_flags); + proto_tree_add_item(functionality_flags_tree, hf_lbmc_topic_source_exfunc_functionality_flags_lj, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(functionality_flags_tree, hf_lbmc_topic_source_exfunc_functionality_flags_ume, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(functionality_flags_tree, hf_lbmc_topic_source_exfunc_functionality_flags_umq, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(functionality_flags_tree, hf_lbmc_topic_source_exfunc_functionality_flags_ulb, tvb, offset + O_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T); +} + +static int dissect_nhdr_ume_store_ext(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_store_ext, tvb, offset, L_LBMC_CNTL_UME_STORE_EXT_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_store_ext); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_next_hdr, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_hdr_len, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_store_ext_flags, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_FLAGS, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_store_ext_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_store_ext_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_FLAGS, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_grp_idx, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_GRP_IDX, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_GRP_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_store_tcp_port, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_TCP_PORT, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_TCP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_store_idx, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_IDX, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_store_ip_addr, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_IP_ADDR, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_STORE_IP_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_src_reg_id, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_SRC_REG_ID, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_SRC_REG_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_domain_id, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_DOMAIN_ID, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_DOMAIN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_store_ext_version, tvb, offset + O_LBMC_CNTL_UME_STORE_EXT_HDR_T_VERSION, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_VERSION, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_STORE_EXT_HDR_T); +} + +static int dissect_nhdr_ume_psrc_election_token(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_ume_psrc_election_token, tvb, offset, L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_ume_psrc_election_token); + proto_tree_add_item(subtree, hf_lbmc_ume_psrc_election_token_next_hdr, tvb, offset + O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_NEXT_HDR, L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_psrc_election_token_hdr_len, tvb, offset + O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_HDR_LEN, L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_ume_psrc_election_token_flags, tvb, offset + O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_FLAGS, L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_ume_psrc_election_token_flags); + proto_tree_add_item(flags_tree, hf_lbmc_ume_psrc_election_token_flags_ignore, tvb, offset + O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_FLAGS, L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_psrc_election_token_store_index, tvb, offset + O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_STORE_INDEX, L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_STORE_INDEX, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_ume_psrc_election_token_token, tvb, offset + O_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_TOKEN, L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_TOKEN, ENC_BIG_ENDIAN); + return (L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T); +} + +static int dissect_nhdr_tcp_sid(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmc_tcp_sid_info_t * info) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 flags = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmc_tcp_sid, tvb, offset, L_LBMC_CNTL_TCP_SID_HDR_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_tcp_sid); + proto_tree_add_item(subtree, hf_lbmc_tcp_sid_next_hdr, tvb, offset + O_LBMC_CNTL_TCP_SID_HDR_T_NEXT_HDR, L_LBMC_CNTL_TCP_SID_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tcp_sid_hdr_len, tvb, offset + O_LBMC_CNTL_TCP_SID_HDR_T_HDR_LEN, L_LBMC_CNTL_TCP_SID_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags = tvb_get_ntohs(tvb, offset + O_LBMC_CNTL_TCP_SID_HDR_T_FLAGS); + flags_item = proto_tree_add_none_format(subtree, hf_lbmc_tcp_sid_flags, tvb, offset + O_LBMC_CNTL_TCP_SID_HDR_T_FLAGS, L_LBMC_CNTL_TCP_SID_HDR_T_FLAGS, "Flags: 0x%04x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_tcp_sid_flags); + proto_tree_add_item(flags_tree, hf_lbmc_tcp_sid_flags_ignore, tvb, offset + O_LBMC_CNTL_TCP_SID_HDR_T_FLAGS, L_LBMC_CNTL_TCP_SID_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_tcp_sid_sid, tvb, offset + O_LBMC_CNTL_TCP_SID_HDR_T_SID, L_LBMC_CNTL_TCP_SID_HDR_T_SID, ENC_BIG_ENDIAN); + if (info != NULL) + { + info->set = TRUE; + info->session_id = tvb_get_ntohl(tvb, offset + O_LBMC_CNTL_TCP_SID_HDR_T_SID); + } + return (L_LBMC_CNTL_TCP_SID_HDR_T); +} + +static int dissect_nhdr_extopt_cfgopt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + /* + Returns number of bytes dissected (>=0), or -1 if an error occurs. In either case, *bytes_dissected + will contain the number of bytes successfully dissected. + */ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int curr_offset = offset; + int len_dissected = 0; + + while (tvb_reported_length_remaining(tvb, curr_offset) > L_LBMC_EXTOPT_CFGOPT_HDR_T) + { + int name_offset = 0; + int name_len = 0; + int value_offset = 0; + int value_len = 0; + int optlen = L_LBMC_EXTOPT_CFGOPT_HDR_T; + + name_offset = curr_offset + L_LBMC_EXTOPT_CFGOPT_HDR_T; + name_len = tvb_strsize(tvb, name_offset); + optlen += name_len; + value_offset = name_offset + name_len; + value_len = tvb_strsize(tvb, value_offset); + optlen += value_len; + subtree_item = proto_tree_add_item(tree, hf_lbmc_extopt_cfgopt, tvb, curr_offset, optlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_extopt_cfgopt); + proto_tree_add_item(subtree, hf_lbmc_extopt_cfgopt_scope, tvb, curr_offset + O_LBMC_EXTOPT_CFGOPT_HDR_T_SCOPE, L_LBMC_EXTOPT_CFGOPT_HDR_T_SCOPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_extopt_cfgopt_parent, tvb, curr_offset + O_LBMC_EXTOPT_CFGOPT_HDR_T_PARENT, L_LBMC_EXTOPT_CFGOPT_HDR_T_PARENT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_extopt_cfgopt_name, tvb, name_offset, name_len, ENC_ASCII|ENC_NA); + proto_tree_add_item(subtree, hf_lbmc_extopt_cfgopt_value, tvb, value_offset, value_len, ENC_ASCII|ENC_NA); + curr_offset += optlen; + len_dissected += optlen; + } + return (len_dissected); +} + +static int dissect_nhdr_extopt(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, lbmc_extopt_reassembled_data_t * reassembly) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * ritem = NULL; + proto_tree * rtree = NULL; + guint8 flags = 0; + int len_dissected = 0; + int data_len = 0; + guint16 subtype; + guint16 fragment_offset; + int data_offset; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_EXTOPT_HDR_T_HDR_LEN); + flags = tvb_get_guint8(tvb, offset + O_LBMC_EXTOPT_HDR_T_FLAGS); + subtype = tvb_get_ntohs(tvb, offset + O_LBMC_EXTOPT_HDR_T_SUBTYPE); + fragment_offset = tvb_get_ntohs(tvb, offset + O_LBMC_EXTOPT_HDR_T_FRAGMENT_OFFSET); + subtree_item = proto_tree_add_item(tree, hf_lbmc_extopt, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_extopt); + proto_tree_add_item(subtree, hf_lbmc_extopt_next_hdr, tvb, offset + O_LBMC_EXTOPT_HDR_T_NEXT_HDR, L_LBMC_EXTOPT_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_extopt_hdr_len, tvb, offset + O_LBMC_EXTOPT_HDR_T_HDR_LEN, L_LBMC_EXTOPT_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_none_format(subtree, + hf_lbmc_extopt_flags, tvb, offset + O_LBMC_EXTOPT_HDR_T_FLAGS, L_LBMC_EXTOPT_HDR_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmc_extopt_flags); + proto_tree_add_item(flags_tree, hf_lbmc_extopt_flags_ignore, tvb, offset + O_LBMC_EXTOPT_HDR_T_FLAGS, L_LBMC_EXTOPT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_extopt_flags_ignore_subtype, tvb, offset + O_LBMC_EXTOPT_HDR_T_FLAGS, L_LBMC_EXTOPT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmc_extopt_flags_more_fragments, tvb, offset + O_LBMC_EXTOPT_HDR_T_FLAGS, L_LBMC_EXTOPT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_extopt_id, tvb, offset + O_LBMC_EXTOPT_HDR_T_ID, L_LBMC_EXTOPT_HDR_T_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_extopt_subtype, tvb, offset + O_LBMC_EXTOPT_HDR_T_SUBTYPE, L_LBMC_EXTOPT_HDR_T_SUBTYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_extopt_fragment_offset, tvb, offset + O_LBMC_EXTOPT_HDR_T_FRAGMENT_OFFSET, L_LBMC_EXTOPT_HDR_T_FRAGMENT_OFFSET, ENC_BIG_ENDIAN); + len_dissected = L_LBMC_EXTOPT_HDR_T; + data_len = (int)hdrlen - len_dissected; + data_offset = offset + len_dissected; + len_dissected += data_len; + if ((flags & LBMC_EXTOPT_FLAG_MORE_FRAGMENT) == 0) + { + /* No more fragments. Do we have a reassembly already started? */ + if (reassembly->reassembly_in_progress) + { + tvbuff_t * reassembly_tvb; + gchar * buf; + proto_item * pi = NULL; + + tvb_memcpy(tvb, reassembly->data + fragment_offset, data_offset, data_len); + reassembly->len += data_len; + buf = (gchar *) wmem_memdup(wmem_file_scope(), reassembly->data, reassembly->len); + reassembly_tvb = tvb_new_real_data(buf, reassembly->len, reassembly->len); + add_new_data_source(pinfo, reassembly_tvb, "Reassembled EXTOPT fragment data"); + proto_tree_add_item(subtree, hf_lbmc_extopt_data, tvb, data_offset, data_len, ENC_NA); + ritem = proto_tree_add_item(tree, hf_lbmc_extopt_reassembled_data, reassembly_tvb, 0, reassembly->len, ENC_NA); + rtree = proto_item_add_subtree(ritem, ett_lbmc_extopt_reassembled_data); + pi = proto_tree_add_uint(rtree, hf_lbmc_extopt_reassembled_data_subtype, reassembly_tvb, 0, 0, reassembly->subtype); + PROTO_ITEM_SET_GENERATED(pi); + pi = proto_tree_add_uint(rtree, hf_lbmc_extopt_reassembled_data_len, reassembly_tvb, 0, 0, (guint32)reassembly->len); + PROTO_ITEM_SET_GENERATED(pi); + switch (reassembly->subtype) + { + case LBMC_EXT_NHDR_MSGSEL: + proto_tree_add_item(rtree, hf_lbmc_extopt_reassembled_data_msgsel, reassembly_tvb, 0, reassembly->len, ENC_ASCII|ENC_NA); + break; + case LBMC_EXT_NHDR_CFGOPT: + len_dissected += dissect_nhdr_extopt_cfgopt(reassembly_tvb, 0, pinfo, rtree); + break; + default: + proto_tree_add_item(rtree, hf_lbmc_extopt_reassembled_data_data, reassembly_tvb, 0, reassembly->len, ENC_NA); + break; + } + lbmc_init_extopt_reassembled_data(reassembly); + } + else + { + switch (subtype) + { + case LBMC_EXT_NHDR_MSGSEL: + proto_tree_add_item(subtree, hf_lbmc_extopt_msgsel, tvb, data_offset, data_len, ENC_ASCII|ENC_NA); + break; + case LBMC_EXT_NHDR_CFGOPT: + len_dissected += dissect_nhdr_extopt_cfgopt(tvb, data_offset, pinfo, subtree); + break; + default: + proto_tree_add_item(subtree, hf_lbmc_extopt_data, tvb, data_offset, data_len, ENC_NA); + break; + } + } + } + else + { + /* Self-contained extended option. */ + if (reassembly->reassembly_in_progress) + { + tvb_memcpy(tvb, reassembly->data + fragment_offset, data_offset, data_len); + reassembly->len += data_len; + proto_tree_add_item(subtree, hf_lbmc_extopt_data, tvb, offset + len_dissected, data_len, ENC_NA); + } + else + { + reassembly->reassembly_in_progress = TRUE; + reassembly->subtype = subtype; + reassembly->len = 0; + if (fragment_offset != 0) + { + expert_add_info_format(pinfo, NULL, &ei_lbmc_analysis_no_reassembly, "LBMC EXTOPT: reassembly not in progress but fragment_offset not zero (%" G_GUINT16_FORMAT ")", fragment_offset); + } + else + { + tvb_memcpy(tvb, reassembly->data + fragment_offset, data_offset, data_len); + reassembly->len += data_len; + } + proto_tree_add_item(subtree, hf_lbmc_extopt_data, tvb, data_offset, data_len, ENC_NA); + } + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_nhdr_unhandled(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, guint8 next_hdr) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 hdrlen = 0; + + hdrlen = tvb_get_guint8(tvb, offset + O_LBMC_BASIC_HDR_T_HDR_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmc_unhandled, tvb, offset, (gint)hdrlen, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmc_unhandled_hdr); + expert_add_info_format(pinfo, subtree_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC header type 0x%02x", next_hdr); + proto_tree_add_item(subtree, hf_lbmc_unhandled_next_hdr, tvb, offset + O_LBMC_UNHANDLED_HDR_T_NEXT_HDR, L_LBMC_UNHANDLED_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_unhandled_hdr_len, tvb, offset + O_LBMC_UNHANDLED_HDR_T_HDR_LEN, L_LBMC_UNHANDLED_HDR_T_HDR_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_unhandled_data, tvb, offset + O_LBMC_UNHANDLED_HDR_T_HDR_LEN + L_LBMC_UNHANDLED_HDR_T_HDR_LEN, hdrlen - (L_LBMC_UNHANDLED_HDR_T_NEXT_HDR + L_LBMC_UNHANDLED_HDR_T_HDR_LEN), ENC_NA); + return ((int)hdrlen); +} + +static int dissect_msg_properties(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * data_item = NULL; + proto_tree * data_tree = NULL; + proto_item * field_item = NULL; + proto_tree * field_tree = NULL; + proto_item * vertype_item = NULL; + proto_tree * vertype_tree = NULL; + guint32 magic; + guint32 * magic_ptr = NULL; + char magic_char[4]; + guint16 num_fields; + guint16 idx; + guint encoding; + int field_offset; + int data_length; + proto_item * magic_item = NULL; + + tvb_memcpy(tvb, (void *)magic_char, offset + O_LBM_MSG_PROPERTIES_DATA_T_MAGIC, 4); + magic_ptr = (guint32 *)magic_char; + magic = *magic_ptr; + encoding = ENC_LITTLE_ENDIAN; + if (magic == LBM_MSG_PROPERTIES_MAGIC) + { + encoding = ENC_LITTLE_ENDIAN; + } + else if (magic == LBM_MSG_PROPERTIES_ANTIMAGIC) + { + encoding = ENC_BIG_ENDIAN; + } + else + { + magic = 0xffffffff; + } + data_length = tvb_reported_length_remaining(tvb, offset); + subtree_item = proto_tree_add_item(tree, hf_lbm_msg_properties, tvb, offset, data_length, encoding); + subtree = proto_item_add_subtree(subtree_item, ett_lbm_msg_properties); + data_item = proto_tree_add_item(subtree, hf_lbm_msg_properties_data, tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_MAGIC, L_LBM_MSG_PROPERTIES_DATA_T, encoding); + data_tree = proto_item_add_subtree(data_item, ett_lbm_msg_properties_data); + magic_item = proto_tree_add_item(data_tree, hf_lbm_msg_properties_data_magic, tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_MAGIC, L_LBM_MSG_PROPERTIES_DATA_T_MAGIC, ENC_LITTLE_ENDIAN); + proto_tree_add_item(data_tree, hf_lbm_msg_properties_data_num_fields, tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_NUM_FIELDS, L_LBM_MSG_PROPERTIES_DATA_T_NUM_FIELDS, encoding); + vertype_item = proto_tree_add_item(data_tree, hf_lbm_msg_properties_data_vertype, tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_VERTYPE, L_LBM_MSG_PROPERTIES_DATA_T_VERTYPE, encoding); + vertype_tree = proto_item_add_subtree(vertype_item, ett_lbm_msg_properties_data_vertype); + proto_tree_add_item(vertype_tree, hf_lbm_msg_properties_data_vertype_version, tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_VERTYPE, L_LBM_MSG_PROPERTIES_DATA_T_VERTYPE, encoding); + proto_tree_add_item(vertype_tree, hf_lbm_msg_properties_data_vertype_type, tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_VERTYPE, L_LBM_MSG_PROPERTIES_DATA_T_VERTYPE, encoding); + proto_tree_add_item(data_tree, hf_lbm_msg_properties_data_res, tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_RES, L_LBM_MSG_PROPERTIES_DATA_T_RES, encoding); + if ((magic != LBM_MSG_PROPERTIES_MAGIC) && (magic != LBM_MSG_PROPERTIES_ANTIMAGIC)) + { + expert_add_info_format(pinfo, magic_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC Message Properties MAGIC value"); + return (L_LBM_MSG_PROPERTIES_DATA_T); + } + if (encoding == ENC_LITTLE_ENDIAN) + { + num_fields = tvb_get_letohs(tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_NUM_FIELDS); + } + else + { + num_fields = tvb_get_ntohs(tvb, offset + O_LBM_MSG_PROPERTIES_DATA_T_NUM_FIELDS); + } + field_offset = offset + L_LBM_MSG_PROPERTIES_DATA_T; + for (idx = 0; idx < num_fields; ++idx) + { + guint32 key_offset; + guint32 value_offset; + guint32 type; + int actual_key_offset; + int actual_value_offset; + int key_len; + int value_len; + proto_item * type_item = NULL; + + if (encoding == ENC_LITTLE_ENDIAN) + { + key_offset = tvb_get_letohl(tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_KEY_OFFSET); + value_offset = tvb_get_letohl(tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_VALUE_OFFSET); + type = tvb_get_letohl(tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_TYPE); + } + else + { + key_offset = tvb_get_ntohl(tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_KEY_OFFSET); + value_offset = tvb_get_ntohl(tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_VALUE_OFFSET); + type = tvb_get_ntohl(tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_TYPE); + } + actual_key_offset = (int) key_offset; + actual_value_offset = (int) value_offset; + field_item = proto_tree_add_item(subtree, hf_lbm_msg_properties_hdr, tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_KEY_OFFSET, L_LBM_MSG_PROPERTIES_HDR_T, encoding); + field_tree = proto_item_add_subtree(field_item, ett_lbm_msg_properties_hdr); + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_key_offset, tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_KEY_OFFSET, L_LBM_MSG_PROPERTIES_HDR_T_KEY_OFFSET, encoding); + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_value_offset, tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_VALUE_OFFSET, L_LBM_MSG_PROPERTIES_HDR_T_VALUE_OFFSET, encoding); + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_hash, tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_HASH, L_LBM_MSG_PROPERTIES_HDR_T_HASH, encoding); + type_item = proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_type, tvb, field_offset + O_LBM_MSG_PROPERTIES_HDR_T_TYPE, L_LBM_MSG_PROPERTIES_HDR_T_TYPE, encoding); + switch (type) + { + case LBM_MSG_PROPERTY_BOOLEAN: + case LBM_MSG_PROPERTY_BYTE: + value_len = 1; + break; + case LBM_MSG_PROPERTY_SHORT: + value_len = 2; + break; + case LBM_MSG_PROPERTY_INT: + case LBM_MSG_PROPERTY_FLOAT: + value_len = 4; + break; + case LBM_MSG_PROPERTY_LONG: + case LBM_MSG_PROPERTY_DOUBLE: + value_len = 8; + break; + case LBM_MSG_PROPERTY_STRING: + value_len = (int)tvb_strsize(tvb, actual_value_offset); + break; + default: + expert_add_info_format(pinfo, type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC Message Properties type 0x%08x", type); + value_len = 4; + break; + } + key_len = (int)tvb_strsize(tvb, actual_key_offset); + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_key, tvb, offset + actual_key_offset, key_len, encoding); + switch (type) + { + case LBM_MSG_PROPERTY_BOOLEAN: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_boolean_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + case LBM_MSG_PROPERTY_BYTE: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_byte_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + case LBM_MSG_PROPERTY_SHORT: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_short_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + case LBM_MSG_PROPERTY_INT: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_int_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + case LBM_MSG_PROPERTY_FLOAT: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_float_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + case LBM_MSG_PROPERTY_LONG: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_long_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + case LBM_MSG_PROPERTY_DOUBLE: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_double_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + case LBM_MSG_PROPERTY_STRING: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_string_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + default: + proto_tree_add_item(field_tree, hf_lbm_msg_properties_hdr_unknown_value, tvb, offset + actual_value_offset, value_len, encoding); + break; + } + field_offset += L_LBM_MSG_PROPERTIES_HDR_T; + } + return (data_length); +} + +/*----------------------------------------------------------------------------*/ +/* Miscellaneous functions. */ +/*----------------------------------------------------------------------------*/ +static const gchar * lbmc_determine_msg_type(const guint8 * header_array) +{ + if (header_array[LBMC_NHDR_SSF_INIT] != 0) + { + return ((gchar *)"SSF-INIT"); + } + else if (header_array[LBMC_NHDR_SSF_CREQ] != 0) + { + return ((gchar *)"SSF-CREQ"); + } + else if (header_array[LBMC_NHDR_UME_PREG] != 0) + { + return ((gchar *)"PREG"); + } + else if (header_array[LBMC_NHDR_UME_PREG_RESP] != 0) + { + return ((gchar *)"PREG-RESP"); + } + else if (header_array[LBMC_NHDR_UME_ACK] != 0) + { + return ((gchar *)"ACK"); + } + else if (header_array[LBMC_NHDR_UME_RXREQ] != 0) + { + return ((gchar *)"RXREQ"); + } + else if (header_array[LBMC_NHDR_UME_KEEPALIVE] != 0) + { + return ((gchar *)"UME-KA"); + } + else if (header_array[LBMC_NHDR_UME_CAPABILITY] != 0) + { + return ((gchar *)"UME-CAP"); + } + else if (header_array[LBMC_NHDR_TSNI] != 0) + { + return ((gchar *)"TSNI"); + } + else if (header_array[LBMC_NHDR_UMQ_REG] != 0) + { + return ((gchar *)"UMQ-REG"); + } + else if (header_array[LBMC_NHDR_UMQ_REG_RESP] != 0) + { + return ((gchar *)"UMQ-REG-RSP"); + } + else if (header_array[LBMC_NHDR_UMQ_ACK] != 0) + { + return ((gchar *)"UMQ-ACK"); + } + else if (header_array[LBMC_NHDR_UMQ_KA] != 0) + { + return ((gchar *)"UMQ-KA"); + } + else if (header_array[LBMC_NHDR_UMQ_RCR] != 0) + { + return ((gchar *)"UMQ-RCR"); + } + else if (header_array[LBMC_NHDR_UMQ_RXREQ] != 0) + { + return ((gchar *)"UMQ-RXREQ"); + } + else if (header_array[LBMC_NHDR_UMQ_QMGMT] != 0) + { + return ((gchar *)"UMQ-QMGMT"); + } + else if (header_array[LBMC_NHDR_UME_LJ_INFO] != 0) + { + return ((gchar *)"LJINFO"); + } + else if (header_array[LBMC_NHDR_UMQ_RESUB_REQ] != 0) + { + return ((gchar *)"UMQ-RESUB-REQ"); + } + else if (header_array[LBMC_NHDR_UMQ_RESUB_RESP] != 0) + { + return ((gchar *)"UMQ-RESUB-RESP"); + } + else if (header_array[LBMC_NHDR_TOPIC_INTEREST] != 0) + { + return ((gchar *)"TOPIC-INT"); + } + else if (header_array[LBMC_NHDR_PATTERN_INTEREST] != 0) + { + return ((gchar *)"PAT-INT"); + } + else if (header_array[LBMC_NHDR_ADVERTISEMENT] != 0) + { + return ((gchar *)"AD"); + } + else if (header_array[LBMC_NHDR_UMQ_ULB_RCR] != 0) + { + return ((gchar *)"UMQ-ULB-RCR"); + } + else if (header_array[LBMC_NHDR_UMQ_LF] != 0) + { + return ((gchar *)"UMQ-LF"); + } + else if (header_array[LBMC_NHDR_CTXINFO] != 0) + { + return ((gchar *)"CTXINFO"); + } + else if (header_array[LBMC_NHDR_UME_PSER] != 0) + { + return ((gchar *)"PSER"); + } + else if (header_array[LBMC_NHDR_DOMAIN] != 0) + { + return ((gchar *)"DOMAIN"); + } + else if (header_array[LBMC_NHDR_TNWG_CAPABILITIES] != 0) + { + return ((gchar *)"TNWG_CAP"); + } + else if (header_array[LBMC_NHDR_PATIDX] != 0) + { + return ((gchar *)"PATIDX"); + } + else if (header_array[LBMC_NHDR_UMQ_IDX_CMD] != 0) + { + return ((gchar *)"UMQ-IDX-CMD"); + } + else if (header_array[LBMC_NHDR_UMQ_IDX_CMD_RESP] != 0) + { + return ((gchar *)"UMQ-IDX-CMD-RESP"); + } + else if (header_array[LBMC_NHDR_TOPIC_MD_INTEREST] != 0) + { + return ((gchar *)"TOPIC-MD-INT"); + } + else if (header_array[LBMC_NHDR_PATTERN_MD_INTEREST] != 0) + { + return ((gchar *)"PAT-MD-INT"); + } + else if (header_array[LBMC_NHDR_LJI_REQ] != 0) + { + return ((gchar *)"LJI-REQ"); + } + else if (header_array[LBMC_NHDR_TNWG_KA] != 0) + { + return ((gchar *)"TNWG-KA"); + } + else if (header_array[LBMC_NHDR_AUTHENTICATION] != 0) + { + return ((gchar *)"AUTH"); + } + else if (header_array[LBMC_NHDR_UME_RCV_KEEPALIVE] != 0) + { + return ((gchar *)"UME-RCV-KA"); + } + else if (header_array[LBMC_NHDR_UMQ_CMD] != 0) + { + return ((gchar *)"UMQ-CMD"); + } + else if (header_array[LBMC_NHDR_UMQ_CMD_RESP] != 0) + { + return ((gchar *)"UMQ-CMD-RESP"); + } + else if (header_array[LBMC_NHDR_EXTOPT] != 0) + { + return ((gchar *)"EXTOPT"); + } + else if (header_array[LBMC_NHDR_HMAC] != 0) + { + return ((gchar *)"HMAC"); + } + else if (header_array[LBMC_NHDR_SRI_REQ] != 0) + { + return ((gchar *)"SRI-REQ"); + } + else if (header_array[LBMC_NHDR_SRI] != 0) + { + return ((gchar *)"SRI"); + } + else if (header_array[LBMC_NHDR_UME_PSRC_ELECTION_TOKEN] != 0) + { + return ((gchar *)"PSRC-ETOK"); + } + else if (header_array[LBMC_NHDR_TOPIC_SOURCE_EXFUNC] != 0) + { + return ((gchar *)"TOPIC-SRC-EX"); + } + else if (header_array[LBMC_NHDR_ROUTE_INFO] != 0) + { + return ((gchar *)"RTE-INFO"); + } + else if (header_array[LBMC_NHDR_TCP_SID] != 0) + { + return ((gchar *)"TCP-SID"); + } + return (NULL); +} + +static lbm_uim_stream_info_t * lbmc_dup_stream_info(const lbm_uim_stream_info_t * info) +{ + lbm_uim_stream_info_t * ptr = NULL; + + ptr = wmem_new(wmem_file_scope(), lbm_uim_stream_info_t); + ptr->channel = info->channel; + ptr->sqn = info->sqn; + ptr->endpoint_a.type = info->endpoint_a.type; + if (ptr->endpoint_a.type == lbm_uim_instance_stream) + { + memcpy((void *)ptr->endpoint_a.stream_info.ctxinst.ctxinst, (void *)info->endpoint_a.stream_info.ctxinst.ctxinst, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + } + else + { + ptr->endpoint_a.stream_info.dest = info->endpoint_a.stream_info.dest; + } + ptr->endpoint_b.type = info->endpoint_b.type; + if (ptr->endpoint_b.type == lbm_uim_instance_stream) + { + memcpy((void *)ptr->endpoint_b.stream_info.ctxinst.ctxinst, (void *)info->endpoint_b.stream_info.ctxinst.ctxinst, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + } + else + { + ptr->endpoint_b.stream_info.dest = info->endpoint_b.stream_info.dest; + } + ptr->description = wmem_strdup(wmem_file_scope(), info->description); + return (ptr); +} + +gboolean lbmc_test_lbmc_header(tvbuff_t * tvb, int offset) +{ + guint8 type; + guint8 version; + guint8 ver_type; + guint8 next_header; + guint16 msglen; + + if (tvb_reported_length_remaining(tvb, offset) < (O_LBMC_HDR_T_MSGLEN + L_LBMC_HDR_T_MSGLEN)) + { + return (FALSE); + } + ver_type = tvb_get_guint8(tvb, offset + O_LBMC_HDR_T_VER_TYPE); + version = LBMC_HDR_VER(ver_type); + type = LBMC_HDR_TYPE(ver_type); + if (version != LBMC_VERSION) + { + return (FALSE); + } + switch (type) + { + case LBMC_TYPE_MESSAGE: + case LBMC_TYPE_PRORX: + case LBMC_TYPE_EOT: + case LBMC_TYPE_CONTROL: + case LBMC_TYPE_RETRANS: + break; + default: + return (FALSE); + } + next_header = tvb_get_guint8(tvb, offset + O_LBMC_HDR_T_NEXT_HDR); + switch (next_header) + { + case LBMC_NHDR_DATA: + case LBMC_NHDR_FRAG: + case LBMC_NHDR_BATCH: + case LBMC_NHDR_TGIDX: + case LBMC_NHDR_REQUEST: + case LBMC_NHDR_TOPICNAME: + case LBMC_NHDR_APPHDR: + case LBMC_NHDR_APPHDR_CHAIN: + case LBMC_NHDR_UMQ_MSGID: + case LBMC_NHDR_UMQ_SQD_RCV: + case LBMC_NHDR_UMQ_RESUB: + case LBMC_NHDR_OTID: + case LBMC_NHDR_CTXINSTD: + case LBMC_NHDR_CTXINSTR: + case LBMC_NHDR_SRCIDX: + case LBMC_NHDR_UMQ_ULB_MSG: + case LBMC_NHDR_SSF_INIT: + case LBMC_NHDR_SSF_CREQ: + case LBMC_NHDR_UME_PREG: + case LBMC_NHDR_UME_PREG_RESP: + case LBMC_NHDR_UME_ACK: + case LBMC_NHDR_UME_RXREQ: + case LBMC_NHDR_UME_KEEPALIVE: + case LBMC_NHDR_UME_STOREID: + case LBMC_NHDR_UME_RANGED_ACK: + case LBMC_NHDR_UME_ACK_ID: + case LBMC_NHDR_UME_CAPABILITY: + case LBMC_NHDR_UME_PROXY_SRC: + case LBMC_NHDR_UME_STORE_GROUP: + case LBMC_NHDR_UME_STORE_INFO: + case LBMC_NHDR_UME_LJ_INFO: + case LBMC_NHDR_TSNI: + case LBMC_NHDR_UMQ_REG: + case LBMC_NHDR_UMQ_REG_RESP: + case LBMC_NHDR_UMQ_ACK: + case LBMC_NHDR_UMQ_RCR: + case LBMC_NHDR_UMQ_KA: + case LBMC_NHDR_UMQ_RXREQ: + case LBMC_NHDR_UMQ_QMGMT: + case LBMC_NHDR_UMQ_RESUB_REQ: + case LBMC_NHDR_UMQ_RESUB_RESP: + case LBMC_NHDR_TOPIC_INTEREST: + case LBMC_NHDR_PATTERN_INTEREST: + case LBMC_NHDR_ADVERTISEMENT: + case LBMC_NHDR_UME_CTXINSTS: + case LBMC_NHDR_UME_STORENAME: + case LBMC_NHDR_UMQ_ULB_RCR: + case LBMC_NHDR_UMQ_LF: + case LBMC_NHDR_CTXINFO: + case LBMC_NHDR_UME_PSER: + case LBMC_NHDR_CTXINST: + case LBMC_NHDR_DOMAIN: + case LBMC_NHDR_TNWG_CAPABILITIES: + case LBMC_NHDR_PATIDX: + case LBMC_NHDR_UME_CLIENT_LIFETIME: + case LBMC_NHDR_UME_SID: + case LBMC_NHDR_UMQ_IDX_CMD: + case LBMC_NHDR_UMQ_IDX_CMD_RESP: + case LBMC_NHDR_ODOMAIN: + case LBMC_NHDR_STREAM: + case LBMC_NHDR_TOPIC_MD_INTEREST: + case LBMC_NHDR_PATTERN_MD_INTEREST: + case LBMC_NHDR_LJI_REQ: + case LBMC_NHDR_TNWG_KA: + case LBMC_NHDR_UME_RCV_KEEPALIVE: + case LBMC_NHDR_UMQ_CMD: + case LBMC_NHDR_UMQ_CMD_RESP: + case LBMC_NHDR_SRI_REQ: + case LBMC_NHDR_UME_STORE_DOMAIN: + case LBMC_NHDR_SRI: + case LBMC_NHDR_ROUTE_INFO: + case LBMC_NHDR_ROUTE_INFO_NEIGHBOR: + case LBMC_NHDR_GATEWAY_NAME: + case LBMC_NHDR_AUTHENTICATION: + case LBMC_NHDR_HMAC: + case LBMC_NHDR_UMQ_SID: + case LBMC_NHDR_DESTINATION: + case LBMC_NHDR_TOPIC_IDX: + case LBMC_NHDR_TOPIC_SOURCE: + case LBMC_NHDR_TOPIC_SOURCE_EXFUNC: + case LBMC_NHDR_UME_STORE_INFO_EXT: + case LBMC_NHDR_UME_PSRC_ELECTION_TOKEN: + case LBMC_NHDR_TCP_SID: + case LBMC_NHDR_EXTOPT: + break; + default: + return (FALSE); + } + msglen = tvb_get_ntohs(tvb, offset + O_LBMC_HDR_T_MSGLEN); + if (msglen == 0) + { + return (FALSE); + } + return (TRUE); +} + +int lbmc_dissect_lbmc_packet(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, const char * tag_name, guint64 channel) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + guint8 type; + guint8 version; + guint8 ver_type; + guint8 next_hdr; + guint16 msglen = 0; + int pkt_offset = 0; + lbmc_basic_hdr_t bhdr; + tvbuff_t * lbmc_tvb = NULL; + int tvb_lbmc_offset = offset; + const char * topic_name = NULL; + guint32 topic_index = 0; + int len_dissected = 0; + int lbmc_hdr_len; + proto_item * ver_type_item = NULL; + proto_tree * ver_type_tree = NULL; + guint32 msgprop_len = 0; + lbmc_fragment_info_t frag_info; + lbmc_extopt_reassembled_data_t reassembly; + gboolean data_is_umq_cmd_resp; + gboolean packet_is_data; + lbmc_stream_info_t stream_info; + lbmc_ctxinst_info_t ctxinstd_info; + lbmc_ctxinst_info_t ctxinstr_info; + lbmc_destination_info_t destination_info; + lbm_istream_entry_t * inst_stream; + lbm_istream_substream_entry_t * inst_substream; + lbm_dstream_entry_t * dom_stream; + lbm_dstream_substream_entry_t * dom_substream; + proto_item * last_initial_item = NULL; + guint8 found_header[256]; + lbm_uim_stream_info_t uim_stream_info; + lbm_uim_stream_info_t * puim_stream_info = NULL; + lbmc_tcp_sid_info_t tcp_sid_info; + gboolean has_source_index; + address tcp_addr; + guint16 tcp_port = 0; + guint64 actual_channel = channel; + + while (tvb_reported_length_remaining(tvb, tvb_lbmc_offset) >= L_LBMC_MINIMAL_HDR_T) + { + proto_item * type_item = NULL; + + /* Get the version and type. */ + ver_type = tvb_get_guint8(tvb, tvb_lbmc_offset + O_LBMC_HDR_T_VER_TYPE); + version = LBMC_HDR_VER(ver_type); + type = LBMC_HDR_TYPE(ver_type); + /* Get the message length. */ + msglen = tvb_get_ntohs(tvb, tvb_lbmc_offset + O_LBMC_MINIMAL_HDR_T_MSGLEN); + if (msglen == 0) + { + expert_add_info_format(pinfo, NULL, &ei_lbmc_analysis_zero_length, "LBMC packet header length is zero"); + return (len_dissected); + } + /* Create a new tvb for just this LBMC message. */ + lbmc_tvb = tvb_new_subset(tvb, tvb_lbmc_offset, (gint)msglen, (gint)msglen); + if ((type == LBMC_TYPE_MESSAGE) || (type == LBMC_TYPE_RETRANS) || (type == LBMC_TYPE_PRORX)) + { + topic_index = tvb_get_ntohl(lbmc_tvb, O_LBMC_HDR_T_TIDX); + if (lbm_channel_is_transport(channel) && lbm_channel_is_known(channel)) + { + topic_name = lbm_topic_find(channel, topic_index); + } + lbmc_hdr_len = L_LBMC_HDR_T; + } + else + { + lbmc_hdr_len = L_LBMC_CNTL_HDR_T; + } + + if (topic_name == NULL) + { + if (tag_name == NULL) + { + subtree_item = proto_tree_add_protocol_format(tree, proto_lbmc, lbmc_tvb, 0, tvb_reported_length_remaining(tvb, 0), "LBMC Protocol"); + } + else + { + subtree_item = proto_tree_add_protocol_format(tree, proto_lbmc, lbmc_tvb, 0, tvb_reported_length_remaining(tvb, 0), "LBMC Protocol (Tag: %s)", tag_name); + } + } + else + { + if (tag_name == NULL) + { + subtree_item = proto_tree_add_protocol_format(tree, proto_lbmc, lbmc_tvb, 0, tvb_reported_length_remaining(tvb, 0), "LBMC Protocol for topic [%s]", topic_name); + } + else + { + subtree_item = proto_tree_add_protocol_format(tree, proto_lbmc, lbmc_tvb, 0, tvb_reported_length_remaining(tvb, 0), "LBMC Protocol (Tag: %s) for topic [%s]", tag_name, topic_name); + } + } + subtree = proto_item_add_subtree(subtree_item, ett_lbmc); + if (tag_name != NULL) + { + proto_item * pi = NULL; + + pi = proto_tree_add_string(subtree, hf_lbmc_tag, tvb, 0, 0, tag_name); + PROTO_ITEM_SET_GENERATED(pi); + } + if (topic_name != NULL) + { + proto_item * pi = NULL; + + pi = proto_tree_add_string(subtree, hf_lbmc_topic, tvb, 0, 0, topic_name); + PROTO_ITEM_SET_GENERATED(pi); + } + ver_type_item = proto_tree_add_none_format(subtree, + hf_lbmc_ver_type, + lbmc_tvb, + O_LBMC_HDR_T_VER_TYPE, + L_LBMC_HDR_T_VER_TYPE, + "Version/Type: 0x%02x (Version:%u, Type:%s)", + ver_type, + version, + val_to_str(type, lbmc_message_type, "Unknown (0x%02x)")); + ver_type_tree = proto_item_add_subtree(ver_type_item, ett_lbmc_ver_type); + proto_tree_add_item(ver_type_tree, hf_lbmc_ver_type_version, lbmc_tvb, O_LBMC_HDR_T_VER_TYPE, L_LBMC_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + type_item = proto_tree_add_item(ver_type_tree, hf_lbmc_ver_type_type, lbmc_tvb, O_LBMC_HDR_T_VER_TYPE, L_LBMC_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmc_next_hdr, lbmc_tvb, O_LBMC_HDR_T_NEXT_HDR, L_LBMC_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + last_initial_item = proto_tree_add_item(subtree, hf_lbmc_msglen, lbmc_tvb, O_LBMC_HDR_T_MSGLEN, L_LBMC_HDR_T_MSGLEN, ENC_BIG_ENDIAN); + len_dissected += (L_LBMC_HDR_T_VER_TYPE + L_LBMC_HDR_T_NEXT_HDR + L_LBMC_HDR_T_MSGLEN); + switch (type) + { + case LBMC_TYPE_EOT: + case LBMC_TYPE_CONTROL: + packet_is_data = FALSE; + break; + case LBMC_TYPE_MESSAGE: + case LBMC_TYPE_RETRANS: + case LBMC_TYPE_PRORX: + packet_is_data = TRUE; + break; + default: + expert_add_info_format(pinfo, type_item, &ei_lbmc_analysis_invalid_value, "Invalid LBMC type 0x%02x", type); + tvb_lbmc_offset += msglen; + len_dissected += (msglen - (L_LBMC_HDR_T_VER_TYPE + L_LBMC_HDR_T_NEXT_HDR + L_LBMC_HDR_T_MSGLEN)); + continue; + break; + } + next_hdr = tvb_get_guint8(lbmc_tvb, O_LBMC_HDR_T_NEXT_HDR); + pkt_offset = lbmc_hdr_len; + if ((type == LBMC_TYPE_MESSAGE) || (type == LBMC_TYPE_RETRANS) || (type == LBMC_TYPE_PRORX)) + { + proto_tree_add_item(subtree, hf_lbmc_tidx, lbmc_tvb, O_LBMC_HDR_T_TIDX, L_LBMC_HDR_T_TIDX, ENC_BIG_ENDIAN); + last_initial_item = proto_tree_add_item(subtree, hf_lbmc_sqn, lbmc_tvb, O_LBMC_HDR_T_SQN, L_LBMC_HDR_T_SQN, ENC_BIG_ENDIAN); + } + frag_info.fragment_found = 0; + frag_info.first_sqn = 0; + frag_info.offset = 0; + frag_info.len = 0; + msgprop_len = 0; + lbmc_init_extopt_reassembled_data(&reassembly); + data_is_umq_cmd_resp = FALSE; + stream_info.set = FALSE; + ctxinstd_info.set = FALSE; + ctxinstr_info.set = FALSE; + destination_info.set = FALSE; + inst_stream = NULL; + inst_substream = NULL; + dom_stream = NULL; + dom_substream = NULL; + memset((void *)found_header, 0, sizeof(found_header)); + puim_stream_info = NULL; + tcp_sid_info.set = FALSE; + has_source_index = FALSE; + while ((tvb_reported_length_remaining(lbmc_tvb, pkt_offset) >= L_LBMC_BASIC_HDR_T) && (next_hdr != LBMC_NHDR_DATA) && (next_hdr != LBMC_NHDR_NONE)) + { + tvbuff_t * hdr_tvb = NULL; + int dissected_hdr_len; + guint8 opid; + + bhdr.next_hdr = tvb_get_guint8(lbmc_tvb, pkt_offset + O_LBMC_BASIC_HDR_T_NEXT_HDR); + bhdr.hdr_len = tvb_get_guint8(lbmc_tvb, pkt_offset + O_LBMC_BASIC_HDR_T_HDR_LEN); + if (bhdr.hdr_len == 0) + { + expert_add_info_format(pinfo, NULL, &ei_lbmc_analysis_zero_length, "LBMC header length is zeror"); + return (len_dissected); + } + hdr_tvb = tvb_new_subset(lbmc_tvb, pkt_offset, (gint)bhdr.hdr_len, (gint)bhdr.hdr_len); + found_header[next_hdr] = 1; + switch (next_hdr) + { + case LBMC_NHDR_FRAG: + dissected_hdr_len = dissect_nhdr_frag(hdr_tvb, 0, pinfo, subtree, &frag_info); + break; + case LBMC_NHDR_BATCH: + dissected_hdr_len = dissect_nhdr_batch(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TGIDX: + /* Not implemented */ + dissected_hdr_len = dissect_nhdr_unhandled(hdr_tvb, 0, pinfo, subtree, next_hdr); + break; + case LBMC_NHDR_REQUEST: + dissected_hdr_len = dissect_nhdr_request(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TOPICNAME: + dissected_hdr_len = dissect_nhdr_topicname(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_APPHDR: + dissected_hdr_len = dissect_nhdr_apphdr(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_APPHDR_CHAIN: + dissected_hdr_len = dissect_nhdr_apphdr_chain(hdr_tvb, 0, pinfo, subtree, &msgprop_len); + break; + case LBMC_NHDR_UMQ_MSGID: + dissected_hdr_len = dissect_nhdr_umq_msgid(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_SQD_RCV: + dissected_hdr_len = dissect_nhdr_umq_sqd_rcv(hdr_tvb, 0, pinfo, subtree, &data_is_umq_cmd_resp); + break; + case LBMC_NHDR_UMQ_RESUB: + dissected_hdr_len = dissect_nhdr_umq_resub(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_OTID: + dissected_hdr_len = dissect_nhdr_otid(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_CTXINSTD: + dissected_hdr_len = dissect_nhdr_ctxinstd(hdr_tvb, 0, pinfo, subtree, &ctxinstd_info); + break; + case LBMC_NHDR_CTXINSTR: + dissected_hdr_len = dissect_nhdr_ctxinstr(hdr_tvb, 0, pinfo, subtree, &ctxinstr_info); + break; + case LBMC_NHDR_SRCIDX: + dissected_hdr_len = dissect_nhdr_srcidx(hdr_tvb, 0, pinfo, subtree); + has_source_index = TRUE; + break; + case LBMC_NHDR_UMQ_ULB_MSG: + dissected_hdr_len = dissect_nhdr_umq_ulb_msg(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_SSF_INIT: + dissected_hdr_len = dissect_nhdr_ssf_init(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_SSF_CREQ: + dissected_hdr_len = dissect_nhdr_ssf_creq(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_PREG: + dissected_hdr_len = dissect_nhdr_ume_preg(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_PREG_RESP: + dissected_hdr_len = dissect_nhdr_ume_preg_resp(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_ACK: + dissected_hdr_len = dissect_nhdr_ume_ack(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_RXREQ: + dissected_hdr_len = dissect_nhdr_ume_rxreq(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_KEEPALIVE: + dissected_hdr_len = dissect_nhdr_ume_keepalive(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_STOREID: + dissected_hdr_len = dissect_nhdr_ume_storeid(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_RANGED_ACK: + dissected_hdr_len = dissect_nhdr_ume_ranged_ack(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_ACK_ID: + dissected_hdr_len = dissect_nhdr_ume_ack_id(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_CAPABILITY: + dissected_hdr_len = dissect_nhdr_ume_capability(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_PROXY_SRC: + dissected_hdr_len = dissect_nhdr_ume_proxy_src(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_STORE_GROUP: + dissected_hdr_len = dissect_nhdr_ume_store_group(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_STORE_INFO: + dissected_hdr_len = dissect_nhdr_ume_store(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_LJ_INFO: + dissected_hdr_len = dissect_nhdr_ume_lj_info(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TSNI: + dissected_hdr_len = dissect_nhdr_tsni(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_REG: + dissected_hdr_len = dissect_nhdr_umq_reg(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_REG_RESP: + dissected_hdr_len = dissect_nhdr_umq_reg_resp(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_ACK: + dissected_hdr_len = dissect_nhdr_umq_ack(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_RCR: + dissected_hdr_len = dissect_nhdr_umq_rcr(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_KA: + dissected_hdr_len = dissect_nhdr_umq_ka(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_RXREQ: + dissected_hdr_len = dissect_nhdr_umq_rxreq(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_QMGMT: + dissected_hdr_len = dissect_nhdr_umq_qmgmt(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_RESUB_REQ: + dissected_hdr_len = dissect_nhdr_umq_resub_req(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_RESUB_RESP: + dissected_hdr_len = dissect_nhdr_umq_resub_resp(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TOPIC_INTEREST: + dissected_hdr_len = dissect_nhdr_topic_interest(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_PATTERN_INTEREST: + dissected_hdr_len = dissect_nhdr_pattern_interest(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_ADVERTISEMENT: + dissected_hdr_len = dissect_nhdr_advertisement(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_CTXINSTS: + dissected_hdr_len = dissect_nhdr_ctxinst(hdr_tvb, 0, pinfo, subtree, NULL); + break; + case LBMC_NHDR_UME_STORENAME: + dissected_hdr_len = dissect_nhdr_storename(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_ULB_RCR: + dissected_hdr_len = dissect_nhdr_umq_ulb_rcr(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_LF: + dissected_hdr_len = dissect_nhdr_umq_lf(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_CTXINFO: + dissected_hdr_len = dissect_nhdr_ctxinfo(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_PSER: + dissected_hdr_len = dissect_nhdr_ume_pser(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_CTXINST: + dissected_hdr_len = dissect_nhdr_ctxinst(hdr_tvb, 0, pinfo, subtree, NULL); + break; + case LBMC_NHDR_DOMAIN: + dissected_hdr_len = dissect_nhdr_domain(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TNWG_CAPABILITIES: + dissected_hdr_len = dissect_nhdr_tnwg_capabilities(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_PATIDX: + dissected_hdr_len = dissect_nhdr_patidx(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_CLIENT_LIFETIME: + dissected_hdr_len = dissect_nhdr_ume_client_lifetime(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_SID: + dissected_hdr_len = dissect_nhdr_ume_sid(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_IDX_CMD: + dissected_hdr_len = dissect_nhdr_umq_idx_cmd(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_IDX_CMD_RESP: + dissected_hdr_len = dissect_nhdr_umq_idx_cmd_resp(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_ODOMAIN: + dissected_hdr_len = dissect_nhdr_odomain(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_STREAM: + dissected_hdr_len = dissect_nhdr_stream(hdr_tvb, 0, pinfo, subtree, &stream_info); + break; + case LBMC_NHDR_TOPIC_MD_INTEREST: + dissected_hdr_len = dissect_nhdr_topic_md_interest(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_PATTERN_MD_INTEREST: + dissected_hdr_len = dissect_nhdr_pattern_md_interest(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_LJI_REQ: + dissected_hdr_len = dissect_nhdr_lji_req(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TNWG_KA: + dissected_hdr_len = dissect_nhdr_tnwg_ka(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_RCV_KEEPALIVE: + dissected_hdr_len = dissect_nhdr_ume_receiver_keepalive(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_CMD: + dissected_hdr_len = dissect_nhdr_umq_cmd(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_CMD_RESP: + dissected_hdr_len = dissect_nhdr_umq_cmd_resp(hdr_tvb, 0, pinfo, subtree, packet_is_data); + break; + case LBMC_NHDR_SRI_REQ: + dissected_hdr_len = dissect_nhdr_sri_req(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_STORE_DOMAIN: + dissected_hdr_len = dissect_nhdr_ume_store_domain(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_SRI: + dissected_hdr_len = dissect_nhdr_sri(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_ROUTE_INFO: + dissected_hdr_len = dissect_nhdr_route_info(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_ROUTE_INFO_NEIGHBOR: + dissected_hdr_len = dissect_nhdr_route_info_neighbor(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_GATEWAY_NAME: + dissected_hdr_len = dissect_nhdr_gateway_name(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_AUTHENTICATION: + opid = tvb_get_guint8(hdr_tvb, O_LBMC_CNTL_AUTH_GENERIC_HDR_T_OPID); + switch (opid) + { + case AUTH_OP_REQ: + dissected_hdr_len = dissect_nhdr_auth_request(hdr_tvb, 0, pinfo, subtree); + break; + case AUTH_OP_CHALLENGE: + dissected_hdr_len = dissect_nhdr_auth_challenge(hdr_tvb, 0, pinfo, subtree); + break; + case AUTH_OP_CHALLENGE_RSP: + dissected_hdr_len = dissect_nhdr_auth_challenge_rsp(hdr_tvb, 0, pinfo, subtree); + break; + case AUTH_OP_RESULT: + dissected_hdr_len = dissect_nhdr_auth_result(hdr_tvb, 0, pinfo, subtree); + break; + default: + dissected_hdr_len = dissect_nhdr_auth_unknown(hdr_tvb, 0, pinfo, subtree); + break; + } + break; + case LBMC_NHDR_HMAC: + dissected_hdr_len = dissect_nhdr_hmac(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UMQ_SID: + dissected_hdr_len = dissect_nhdr_umq_sid(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_DESTINATION: + dissected_hdr_len = dissect_nhdr_destination(hdr_tvb, 0, pinfo, subtree, &destination_info); + break; + case LBMC_NHDR_TOPIC_IDX: + dissected_hdr_len = dissect_nhdr_topic_idx(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TOPIC_SOURCE: + dissected_hdr_len = dissect_nhdr_topic_source(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TOPIC_SOURCE_EXFUNC: + dissected_hdr_len = dissect_nhdr_topic_source_exfunc(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_STORE_INFO_EXT: + dissected_hdr_len = dissect_nhdr_ume_store_ext(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_UME_PSRC_ELECTION_TOKEN: + dissected_hdr_len = dissect_nhdr_ume_psrc_election_token(hdr_tvb, 0, pinfo, subtree); + break; + case LBMC_NHDR_TCP_SID: + dissected_hdr_len = dissect_nhdr_tcp_sid(hdr_tvb, 0, pinfo, subtree, &tcp_sid_info); + break; + case LBMC_NHDR_EXTOPT: + dissected_hdr_len = dissect_nhdr_extopt(hdr_tvb, 0, pinfo, subtree, &reassembly); + break; + /* Headers that are not implemented. */ + case LBMC_NHDR_NONE: + default: + dissected_hdr_len = dissect_nhdr_unhandled(hdr_tvb, 0, pinfo, subtree, next_hdr); + break; + } + len_dissected += dissected_hdr_len; + next_hdr = bhdr.next_hdr; + pkt_offset += bhdr.hdr_len; + } + /* If transport is TCP and we got a TCP SID header, process it. */ + if (lbm_channel_is_unknown_transport_source_lbttcp(channel)) + { + COPY_ADDRESS_SHALLOW(&tcp_addr, &(pinfo->src)); + tcp_port = (guint16)pinfo->srcport; + } + else if (lbm_channel_is_unknown_transport_client_lbttcp(channel)) + { + COPY_ADDRESS_SHALLOW(&tcp_addr, &(pinfo->dst)); + tcp_port = (guint16)pinfo->destport; + } + if ((pinfo->fd->flags.visited == 0) && (tcp_sid_info.set) && !lbm_channel_is_known(channel)) + { + lbttcp_transport_sid_add(&tcp_addr, tcp_port, pinfo->fd->num, tcp_sid_info.session_id); + } + /* Try to determine the TCP transport channel. */ + if (lbm_channel_type(channel) == LBM_CHANNEL_TRANSPORT_LBTTCP) + { + if (lbm_channel_is_known(channel)) + { + if (topic_name != NULL) + { + topic_name = lbm_topic_find(channel, topic_index); + } + } + else + { + guint32 tcp_session_id = 0; + + if (lbttcp_transport_sid_find(&tcp_addr, tcp_port, pinfo->fd->num, &tcp_session_id)) + { + lbttcp_transport_t * tcp_transport = NULL; + + tcp_transport = lbttcp_transport_find(&tcp_addr, tcp_port, tcp_session_id, pinfo->fd->num); + if (tcp_transport != NULL) + { + actual_channel = tcp_transport->channel; + topic_name = lbm_topic_find(actual_channel, topic_index); + } + } + } + if (topic_name != NULL) + { + if (tag_name == NULL) + { + proto_item_set_text(subtree_item, "LBMC Protocol for topic [%s]", topic_name); + } + else + { + proto_item_set_text(subtree_item, "LBMC Protocol (Tag: %s) for topic [%s]", tag_name, topic_name); + } + } + } + + /* If TCP, handle stream info. */ + if (pinfo->ptype == PT_TCP) + { + if (stream_info.set && ctxinstd_info.set && !destination_info.set) + { + inst_stream = lbm_stream_istream_find(stream_info.ctxinst, ctxinstd_info.ctxinst); + if (inst_stream == NULL) + { + inst_stream = lbm_stream_istream_add(stream_info.ctxinst, ctxinstd_info.ctxinst); + } + if (inst_stream != NULL) + { + inst_substream = lbm_stream_istream_substream_find(inst_stream, &(pinfo->src), pinfo->srcport, &(pinfo->dst), pinfo->destport, stream_info.stream_id); + if (inst_substream == NULL) + { + inst_substream = lbm_stream_istream_substream_add(inst_stream, &(pinfo->src), pinfo->srcport, &(pinfo->dst), pinfo->destport, stream_info.stream_id); + } + if (inst_substream != NULL) + { + proto_item * stream_item = NULL; + proto_tree * stream_tree = NULL; + proto_item * pi = NULL; + lbm_uim_stream_tap_info_t * stream_tap_info = NULL; + + lbm_stream_istream_substream_update(inst_substream, msglen, pinfo->fd->num); + stream_item = proto_tree_add_item(subtree, hf_lbm_stream, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(stream_item); + stream_tree = proto_item_add_subtree(stream_item, ett_lbm_stream); + pi = proto_tree_add_uint64(stream_tree, hf_lbm_stream_stream_id, tvb, 0, 0, inst_stream->channel); + PROTO_ITEM_SET_GENERATED(pi); + pi = proto_tree_add_uint(stream_tree, hf_lbm_stream_substream_id, tvb, 0, 0, inst_substream->substream_id); + PROTO_ITEM_SET_GENERATED(pi); + proto_tree_move_item(subtree, last_initial_item, stream_item); + + stream_tap_info = wmem_new(wmem_file_scope(), lbm_uim_stream_tap_info_t); + stream_tap_info->channel = inst_stream->channel; + stream_tap_info->substream_id = inst_substream->substream_id; + stream_tap_info->bytes = msglen; + stream_tap_info->endpoint_a.type = lbm_uim_instance_stream; + memcpy((void *)stream_tap_info->endpoint_a.stream_info.ctxinst.ctxinst, (void *)stream_info.ctxinst, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + stream_tap_info->endpoint_b.type = lbm_uim_instance_stream; + memcpy((void *)stream_tap_info->endpoint_b.stream_info.ctxinst.ctxinst, (void *)ctxinstd_info.ctxinst, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + tap_queue_packet(lbmc_stream_tap_handle, pinfo, (void *)stream_tap_info); + } + uim_stream_info.channel = inst_stream->channel; + uim_stream_info.sqn = stream_info.sqn; + uim_stream_info.endpoint_a.type = lbm_uim_instance_stream; + memcpy((void *)uim_stream_info.endpoint_a.stream_info.ctxinst.ctxinst, (void *)stream_info.ctxinst, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + uim_stream_info.endpoint_b.type = lbm_uim_instance_stream; + memcpy((void *)uim_stream_info.endpoint_b.stream_info.ctxinst.ctxinst, (void *)ctxinstd_info.ctxinst, LBM_CONTEXT_INSTANCE_BLOCK_SZ); + puim_stream_info = &uim_stream_info; + } + } + else if (stream_info.set && destination_info.set) + { + dom_stream = lbm_stream_dstream_find(&(destination_info.endpoint_a), &(destination_info.endpoint_b)); + if (dom_stream == NULL) + { + dom_stream = lbm_stream_dstream_add(&(destination_info.endpoint_a), &(destination_info.endpoint_b)); + } + if (dom_stream != NULL) + { + dom_substream = lbm_stream_dstream_substream_find(dom_stream, &(pinfo->src), pinfo->srcport, &(pinfo->dst), pinfo->destport, stream_info.stream_id); + if (dom_substream == NULL) + { + dom_substream = lbm_stream_dstream_substream_add(dom_stream, &(pinfo->src), pinfo->srcport, &(pinfo->dst), pinfo->destport, stream_info.stream_id); + } + if (dom_substream != NULL) + { + proto_item * stream_item = NULL; + proto_tree * stream_tree = NULL; + proto_item * pi = NULL; + lbm_uim_stream_tap_info_t * stream_tap_info = NULL; + + lbm_stream_dstream_substream_update(dom_substream, msglen, pinfo->fd->num); + stream_item = proto_tree_add_item(subtree, hf_lbm_stream, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(stream_item); + stream_tree = proto_item_add_subtree(stream_item, ett_lbm_stream); + pi = proto_tree_add_uint64(stream_tree, hf_lbm_stream_stream_id, tvb, 0, 0, dom_stream->channel); + PROTO_ITEM_SET_GENERATED(pi); + pi = proto_tree_add_uint(stream_tree, hf_lbm_stream_substream_id, tvb, 0, 0, dom_substream->substream_id); + PROTO_ITEM_SET_GENERATED(pi); + proto_tree_move_item(subtree, last_initial_item, stream_item); + + stream_tap_info = wmem_new(wmem_file_scope(), lbm_uim_stream_tap_info_t); + stream_tap_info->channel = dom_stream->channel; + stream_tap_info->substream_id = dom_substream->substream_id; + stream_tap_info->bytes = msglen; + stream_tap_info->endpoint_a.type = lbm_uim_domain_stream; + stream_tap_info->endpoint_a.stream_info.dest = destination_info.endpoint_a; + stream_tap_info->endpoint_b.type = lbm_uim_domain_stream; + stream_tap_info->endpoint_b.stream_info.dest = destination_info.endpoint_b; + tap_queue_packet(lbmc_stream_tap_handle, pinfo, (void *)stream_tap_info); + } + uim_stream_info.channel = dom_stream->channel; + uim_stream_info.sqn = stream_info.sqn; + uim_stream_info.endpoint_a.type = lbm_uim_domain_stream; + uim_stream_info.endpoint_a.stream_info.dest = destination_info.endpoint_a; + uim_stream_info.endpoint_b.type = lbm_uim_domain_stream; + uim_stream_info.endpoint_b.stream_info.dest = destination_info.endpoint_b; + puim_stream_info = &uim_stream_info; + } + } + } + if (next_hdr == LBMC_NHDR_DATA) + { + int actual_data_len = 0; + int msgprop_offset = 0; + tvbuff_t * data_tvb = NULL; + tvbuff_t * msgprop_tvb = NULL; + gboolean msg_complete = TRUE; + gboolean msg_reassembled = FALSE; + lbmc_message_entry_t * msg = NULL; + gboolean dissector_found = FALSE; + + if (frag_info.fragment_found == 0) + { + /* No fragment info */ + if (msgprop_len > 0) + { + /* Has message properties */ + actual_data_len = tvb_reported_length_remaining(lbmc_tvb, pkt_offset) - msgprop_len; + msgprop_offset = pkt_offset + actual_data_len; + data_tvb = tvb_new_subset(lbmc_tvb, pkt_offset, actual_data_len, actual_data_len); + msgprop_tvb = tvb_new_subset(lbmc_tvb, msgprop_offset, msgprop_len, msgprop_len); + } + else + { + actual_data_len = tvb_reported_length_remaining(lbmc_tvb, pkt_offset); + data_tvb = tvb_new_subset(lbmc_tvb, pkt_offset, actual_data_len, actual_data_len); + msgprop_tvb = NULL; + } + msg_complete = TRUE; + msg_reassembled = FALSE; + } + else + { + /* Fragment info is present */ + if (!lbmc_reassemble_fragments) + { + /* But don't reassemble them */ + actual_data_len = tvb_reported_length_remaining(lbmc_tvb, pkt_offset); + data_tvb = tvb_new_subset(lbmc_tvb, pkt_offset, actual_data_len, actual_data_len); + msgprop_tvb = NULL; + msg_complete = TRUE; + } + else + { + /* Fragment info is present and we should reassemble */ + guint32 port; + + port = (guint32)pinfo->destport; + msg = lbmc_message_find(actual_channel, &(pinfo->dst), port, &frag_info); + if (msg == NULL) + { + msg = lbmc_message_create(actual_channel, &(pinfo->dst), port, &frag_info, msgprop_len); + } + if (msg != NULL) + { + /* Check fragment against message */ + int frag_len = tvb_reported_length_remaining(lbmc_tvb, pkt_offset); + if ((frag_info.offset + (guint32) frag_len) > msg->total_len) + { + /* Indicate a malformed packet */ + expert_add_info_format(pinfo, NULL, &ei_lbmc_analysis_invalid_fragment, + "Invalid fragment for message (msglen=%" G_GUINT32_FORMAT ", frag offset=%" G_GUINT32_FORMAT ", frag len=%d", + msg->total_len, frag_info.offset, frag_len); + } + else + { + (void)lbmc_message_add_fragment(msg, lbmc_tvb, pkt_offset, &frag_info, pinfo->fd->num); + if (data_is_umq_cmd_resp) + { + msg->data_is_umq_cmd_resp = TRUE; + } + if ((msg->total_len == msg->accumulated_len) && (msg->reassembled_frame == 0)) + { + /* Store the frame number in which the message will be reassembled */ + msg->reassembled_frame = pinfo->fd->num; + actual_data_len = tvb_reported_length_remaining(lbmc_tvb, pkt_offset); + data_tvb = tvb_new_subset(lbmc_tvb, pkt_offset, actual_data_len, actual_data_len); + msgprop_tvb = NULL; + msg_reassembled = TRUE; + msg_complete = TRUE; + } + else + { + /* This is not the last fragment of the message. */ + actual_data_len = tvb_reported_length_remaining(lbmc_tvb, pkt_offset); + data_tvb = tvb_new_subset(lbmc_tvb, pkt_offset, actual_data_len, actual_data_len); + msgprop_tvb = NULL; + msg_reassembled = TRUE; + msg_complete = FALSE; + } + } + } + } + } + + /* Note: + - Data to be dissected is in data_tvb + - Message properties to be dissected is in msgprop_tvb + */ + /* For reassembled messages, show the frame or reassembly information. */ + if (msg_reassembled) + { + if (msg->reassembled_frame == pinfo->fd->num) + { + proto_tree * frag_tree = NULL; + proto_item * frag_item = NULL; + proto_item * pi = NULL; + gboolean first_item = TRUE; + lbmc_fragment_entry_t * cur = NULL; + gchar * buf = NULL; + + /* Create a new real data tvb of the reassembled data. */ + buf = (gchar *)wmem_alloc(wmem_file_scope(), (size_t)msg->total_len); + cur = msg->entry; + while (cur != NULL) + { + memcpy(buf + cur->fragment_start, cur->data, cur->fragment_len); + cur = cur->next; + } + msg->reassembled_data = tvb_new_real_data(buf, msg->total_len, msg->total_len); + msg_complete = TRUE; + /* Create separate data and msgprop tvbs */ + msg->data = tvb_new_subset(msg->reassembled_data, 0, msg->total_len - msg->msgprop_len, msg->total_len - msg->msgprop_len); + if (msg->msgprop_len > 0) + { + msg->msgprop = tvb_new_subset(msg->reassembled_data, msg->total_len - msg->msgprop_len, msg->msgprop_len, msg->msgprop_len); + } + add_new_data_source(pinfo, msg->reassembled_data, "Reassembled Data"); + if (msg->data == NULL) + { + msg->data = tvb_new_subset(msg->reassembled_data, 0, msg->total_len - msg->msgprop_len, msg->total_len - msg->msgprop_len); + } + if (msg->msgprop == NULL) + { + if (msg->msgprop_len > 0) + { + msg->msgprop = tvb_new_subset(msg->reassembled_data, msg->total_len - msg->msgprop_len, msg->msgprop_len, msg->msgprop_len); + } + } + data_tvb = msg->data; + msgprop_tvb = msg->msgprop; + data_is_umq_cmd_resp = msg->data_is_umq_cmd_resp; + + frag_item = proto_tree_add_none_format(subtree, + hf_lbmc_reassembly, + data_tvb, + 0, + tvb_reported_length_remaining(data_tvb, 0), + "%" G_GUINT32_FORMAT " Reassembled Fragments (%" G_GUINT32_FORMAT " bytes):", + msg->fragment_count, + msg->total_len); + frag_tree = proto_item_add_subtree(frag_item, ett_lbmc_reassembly); + cur = msg->entry; + first_item = TRUE; + while (cur != NULL) + { + pi = proto_tree_add_uint_format_value(frag_tree, + hf_lbmc_reassembly_fragment, + msg->reassembled_data, + cur->fragment_start, + cur->fragment_len, + cur->frame, + "Frame: %" G_GUINT32_FORMAT ", payload: %" G_GUINT32_FORMAT "-%" G_GUINT32_FORMAT " (%" G_GUINT32_FORMAT " bytes)", + cur->frame, + cur->fragment_start, + (cur->fragment_start + cur->fragment_len) - 1, + cur->fragment_len); + PROTO_ITEM_SET_GENERATED(pi); + if (first_item) + { + proto_item_append_text(frag_item, " #%" G_GUINT32_FORMAT "(%" G_GUINT32_FORMAT ")", cur->frame, cur->fragment_len); + } + else + { + proto_item_append_text(frag_item, ", #%" G_GUINT32_FORMAT "(%" G_GUINT32_FORMAT ")", cur->frame, cur->fragment_len); + } + first_item = FALSE; + cur = cur->next; + } + PROTO_ITEM_SET_GENERATED(frag_item); + } + else + { + proto_item * pi = NULL; + + if (msg->reassembled_frame == 0) + { + expert_add_info(pinfo, NULL, &ei_lbmc_analysis_missing_reassembly_frame); + pi = proto_tree_add_text(subtree, data_tvb, 0, tvb_reported_length_remaining(data_tvb, 0), + "Message not reassembled - reassembly data missing from capture"); + } + else + { + pi = proto_tree_add_uint(subtree, hf_reassembly_frame, data_tvb, 0, tvb_reported_length_remaining(data_tvb, 0), msg->reassembled_frame); + } + PROTO_ITEM_SET_GENERATED(pi); + } + } + + if (data_is_umq_cmd_resp && msg_complete) + { + (void)dissect_nhdr_umq_cmd_resp(data_tvb, 0, pinfo, subtree, TRUE); + col_append_sep_str(pinfo->cinfo, COL_INFO, " ", "UMQ-CMD-RESP"); + } + else + { + if ((!lbm_channel_is_transport(channel)) && (!has_source_index)) + { + col_append_sep_str(pinfo->cinfo, COL_INFO, " ", "RX-DATA"); + } + else + { + col_append_sep_str(pinfo->cinfo, COL_INFO, " ", "DATA"); + } + if (lbmc_use_heuristic_subdissectors) + { + dissector_found = dissector_try_heuristic(lbmc_heuristic_subdissector_list, data_tvb, pinfo, subtree, NULL); + } + if (!dissector_found) + { + if (lbmc_dissect_lbmpdm) + { + int encoding; + int pdmlen; + + dissector_found = lbmpdm_verify_payload(data_tvb, 0, &encoding, &pdmlen); + } + if (dissector_found) + { + lbmpdm_dissect_lbmpdm_payload(data_tvb, 0, pinfo, subtree, actual_channel); + } + else + { + call_dissector(lbmc_data_dissector_handle, data_tvb, pinfo, subtree); + } + } + } + if (msgprop_tvb != NULL) + { + dissect_msg_properties(msgprop_tvb, 0, pinfo, subtree); + } + if (msg_complete) + { + if (puim_stream_info != NULL) + { + lbm_uim_stream_info_t * msg_info; + + if ((!lbm_channel_is_transport(actual_channel)) && (!has_source_index)) + { + puim_stream_info->description = "RX-DATA"; + } + else + { + puim_stream_info->description = "DATA"; + } + msg_info = lbmc_dup_stream_info(puim_stream_info); + tap_queue_packet(lbmc_uim_tap_handle, pinfo, (void *)msg_info); + } + } + len_dissected += tvb_reported_length_remaining(lbmc_tvb, pkt_offset); + } + else + { + const gchar * msg_type = NULL; + msg_type = lbmc_determine_msg_type(found_header); + + if (msg_type != NULL) + { + col_append_sep_str(pinfo->cinfo, COL_INFO, " ", msg_type); + if (puim_stream_info != NULL) + { + lbm_uim_stream_info_t * msg_info; + + puim_stream_info->description = msg_type; + msg_info = lbmc_dup_stream_info(puim_stream_info); + tap_queue_packet(lbmc_uim_tap_handle, pinfo, (void *)msg_info); + } + } + } + tvb_lbmc_offset += msglen; + } + return (len_dissected); +} + +/* The registration hand-off routine */ +void proto_reg_handoff_lbmc(void) +{ + static gboolean already_registered = FALSE; + + if (!already_registered) + { + lbmc_data_dissector_handle = find_dissector("data"); + lbmc_uim_tap_handle = register_tap("lbm_uim"); + lbmc_stream_tap_handle = register_tap("lbm_stream"); + } + + already_registered = TRUE; +} + +/* Register all the bits needed with the filtering engine */ +void proto_register_lbmc(void) +{ + static hf_register_info hf[] = + { + { &hf_lbmc_tag, + { "Tag", "lbmc.tag", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic, + { "Topic", "lbmc.topic", FT_STRING, BASE_NONE, NULL, 0x0, "Topic string", HFILL } }, + { &hf_lbmc_ver_type, + { "Version/Type", "lbmc.ver_type", FT_NONE, BASE_NONE, NULL, 0x0, "Version/Type information", HFILL } }, + { &hf_lbmc_ver_type_version, + { "Version", "lbmc.ver_type.version", FT_UINT8, BASE_DEC, NULL, LBMC_HDR_VER_TYPE_VER_MASK, "LBMC protocol version", HFILL } }, + { &hf_lbmc_ver_type_type, + { "Type", "lbmc.ver_type.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_message_type), LBMC_HDR_VER_TYPE_TYPE_MASK, "LBMC packet type", HFILL } }, + { &hf_lbmc_next_hdr, + { "Next Header", "lbmc.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_msglen, + { "Message Length", "lbmc.msglen", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tidx, + { "Topic Index", "lbmc.tidx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sqn, + { "Sequence Number", "lbmc.sqn", FT_UINT32, BASE_DEC, NULL, 0x0, "Topic sequence number", HFILL } }, + { &hf_lbmc_frag, + { "Fragment", "lbmc.frag", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_frag_next_hdr, + { "Next Header", "lbmc.frag.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_frag_hdr_len, + { "Header Length", "lbmc.frag.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_frag_flags, + { "Flags", "lbmc.frag.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_frag_flags_ignore, + { "Ignore", "lbmc.frag.flags.ignore", FT_BOOLEAN, L_LBMC_FRAG_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_frag_first_sqn, + { "First Sequence Number", "lbmc.frag.first_sqn", FT_UINT32, BASE_DEC, NULL, 0x0, "First sqn of fragment for this message", HFILL } }, + { &hf_lbmc_frag_offset, + { "Offset", "lbmc.frag.offset", FT_UINT32, BASE_DEC, NULL, 0x0, "Offset of this fragment within message", HFILL } }, + { &hf_lbmc_frag_len, + { "Length", "lbmc.frag.len", FT_UINT32, BASE_DEC, NULL, 0x0, "Total length of message", HFILL } }, + { &hf_lbmc_batch, + { "Batch", "lbmc.batch", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_batch_next_hdr, + { "Next Header", "lbmc.batch.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_batch_hdr_len, + { "Header Length", "lbmc.batch.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_batch_flags, + { "Flags", "lbmc.batch.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_batch_flags_ignore, + { "Ignore", "lbmc.batch.flags.ignore", FT_BOOLEAN, L_LBMC_BATCH_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_batch_flags_batch_start, + { "Batch Start", "lbmc.batch.flags.batch_start", FT_BOOLEAN, L_LBMC_BATCH_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_BATCH_START, "If set, indicates the start of an explicit batch", HFILL } }, + { &hf_lbmc_batch_flags_batch_end, + { "Batch End", "lbmc.batch.flags.batch_end", FT_BOOLEAN, L_LBMC_BATCH_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_BATCH_END, "If set, indicate the end of an explicit batch", HFILL } }, + { &hf_lbmc_tcp_request, + { "Request", "lbmc.tcp_request", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_request_next_hdr, + { "Next Header", "lbmc.tcp_request.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_request_hdr_len, + { "Header Length", "lbmc.tcp_request.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_request_flags, + { "Flags", "lbmc.tcp_request.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_request_flags_ignore, + { "Ignore", "lbmc.tcp_request_flags.ignore", FT_BOOLEAN, L_LBMC_TCP_REQUEST_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_tcp_request_transport, + { "Transport", "lbmc.tcp_request.transport", FT_UINT8, BASE_HEX, VALS(lbmc_req_transport_type), 0x0, "Transport type", HFILL } }, + { &hf_lbmc_tcp_request_qidx, + { "Request Index", "lbmc.tcp_request.qidx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_request_port, + { "Port", "lbmc.tcp_request.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_request_reserved, + { "Reserved", "lbmc.tcp_request.reserved", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_request_ipaddr, + { "Requester IP Address", "lbmc.tcp_request.ipaddr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topicname, + { "Topicname", "lbmc.topicname", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topicname_next_hdr, + { "Next Header", "lbmc.topicname.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_topicname_hdr_len, + { "Header Length", "lbmc.topicname.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topicname_flags, + { "Flags", "lbmc.topicname.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topicname_flags_ignore, + { "Ignore", "lbmc.topicname.flags.ignore", FT_BOOLEAN, L_LBMC_TOPICNAME_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_topicname_topicname, + { "Topic", "lbmc.topicname.topic", FT_STRING, BASE_NONE, NULL, 0x0, "Topic name", HFILL } }, + { &hf_lbmc_apphdr, + { "AppHeader", "lbmc.apphdr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_next_hdr, + { "Next Header", "lbmc.apphdr.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_hdr_len, + { "Header Length", "lbmc.apphdr.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_code, + { "Code", "lbmc.apphdr.code", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_code_ignore, + { "Ignore", "lbmc.apphdr.code.ignore", FT_BOOLEAN, L_LBMC_APPHDR_HDR_T_CODE * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_apphdr_code_code, + { "Application Code", "lbmc.apphdr.code.code", FT_UINT16, BASE_DEC_HEX, NULL, LBMC_APPHDR_CODE_MASK, "Application header code", HFILL } }, + { &hf_lbmc_apphdr_data, + { "Data", "lbmc.apphdr.data", FT_NONE, BASE_NONE, NULL, 0x0, "Application header data", HFILL } }, + { &hf_lbmc_apphdr_chain, + { "AppHeader Chain", "lbmc.apphdr_chain", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_next_hdr, + { "Next Header", "lbmc.apphdr_chain.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_hdr_len, + { "Header Length", "lbmc.apphdr_chain.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_res, + { "Reserved", "lbmc.apphdr_chain.res", FT_UINT8, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_first_chain_hdr, + { "First chain hdr", "lbmc.apphdr_chain.first_chain_hdr", FT_UINT8, BASE_HEX_DEC, VALS(lbmc_apphdr_chain_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_element, + { "AppHeader Chain Element", "lbmc.apphdr_chain.element", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_element_next_hdr, + { "Next Header", "lbmc.apphdr_chain.element.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_apphdr_chain_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_element_hdr_len, + { "Header Length", "lbmc.apphdr_chain.element.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_element_res, + { "Reserved", "lbmc.apphdr_chain.element.res", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_element_data, + { "Data", "lbmc.apphdr_chain.element.data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_msgprop, + { "AppHeader Chain Message Properties Element", "lbmc.apphdr_chain.msgprop", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_msgprop_next_hdr, + { "Next Header", "lbmc.apphdr_chain.msgprop.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_apphdr_chain_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_msgprop_hdr_len, + { "Header Length", "lbmc.apphdr_chain.msgprop.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_msgprop_res, + { "Reserved", "lbmc.apphdr_chain.msgprop.res", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_apphdr_chain_msgprop_len, + { "Properties Length", "lbmc.apphdr_chain.msgprop.proplen", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_msgid, + { "UMQ MessageID", "lbmc.umq_msgid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_msgid_next_hdr, + { "Next Header", "lbmc.umq_msgid.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_msgid_hdr_len, + { "Header Length", "lbmc.umq_msgid.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_msgid_flags, + { "Flags", "lbmc.umq_msgid.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_msgid_flags_ignore, + { "Ignore", "lbmc.umq_msgid.flags.ignore", FT_BOOLEAN, L_LBMC_UMQ_MSGID_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_umq_msgid_msgid_regid, + { "Message ID RegID", "lbmc.umq_msgid.msgid_regid", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, "Message ID registration ID", HFILL } }, + { &hf_lbmc_umq_msgid_msgid_stamp, + { "MessageID Stamp", "lbmc.umq_msgid.msgid_stamp", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, "Message ID stamp", HFILL } }, + { &hf_lbmc_umq_sqd_rcv, + { "UMQ SQD Receiver", "lbmc.umq_sqd_rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_next_hdr, + { "Next Header", "lbmc.umq_sqd_rcv.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_hdr_len, + { "Header Length", "lbmc.umq_sqd_rcv.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_flags, + { "Flags", "lbmc.umq_sqd_rcv.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_flags_ignore, + { "Ignore", "lbmc.umq_sqd_rcv.flags.ignore", FT_BOOLEAN, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_flags_r_flag, + { "Reassign", "lbmc.umq_sqd_rcv.flags.r_flag", FT_BOOLEAN, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_SQD_RCV_R_FLAG, "Set if this is a reassignment", HFILL } }, + { &hf_lbmc_umq_sqd_rcv_flags_s_flag, + { "Resubmit", "lbmc.umq_sqd_rcv.flags.s_flag", FT_BOOLEAN, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_SQD_RCV_S_FLAG, "Set if this is a resubmission", HFILL } }, + { &hf_lbmc_umq_sqd_rcv_flags_re_flag, + { "Redelivered", "lbmc.umq_sqd_rcv.flags.re_flag", FT_BOOLEAN, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_SQD_RCV_RE_FLAG, "Set if this is a redelivery", HFILL } }, + { &hf_lbmc_umq_sqd_rcv_flags_eoi_flag, + { "End of Index", "lbmc.umq_sqd_rcv.flags.eoi_flag", FT_BOOLEAN, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_SQD_RCV_BOI_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_flags_boi_flag, + { "Beginning of Index", "lbmc.umq_sqd_rcv.flags.boi_flag", FT_BOOLEAN, L_LBMC_UMQ_SQD_RCV_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_SQD_RCV_EOI_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_queue_id, + { "Queue ID", "lbmc.umq_sqd_rcv.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_queue_ver, + { "Queue Version", "lbmc.umq_sqd_rcv.queue_ver", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_rcr_idx, + { "RCR Index", "lbmc.umq_sqd_rcv.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sqd_rcv_assign_id, + { "Assignment ID", "lbmc.umq_sqd_rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub, + { "UMQ Resubmission", "lbmc.umq_resub", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_next_hdr, + { "Next Header", "lbmc.umq_resub.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_hdr_len, + { "Header Length", "lbmc.umq_resub.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_flags, + { "Flags", "lbmc.umq_resub.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_flags_ignore, + { "Ignore", "lbmc.umq_resub.flags.ignore", FT_BOOLEAN, L_LBMC_UMQ_RESUB_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_umq_resub_flags_q_flag, + { "Queue", "lbmc.umq_resub.flags.q_flag", FT_BOOLEAN, L_LBMC_UMQ_RESUB_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_RESUB_Q_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_resub_rcr_idx, + { "RCR Index", "lbmc.umq_resub.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, "Receiver control record index", HFILL } }, + { &hf_lbmc_umq_resub_resp_ip, + { "Response IP Address", "lbmc.umq_resub.resp_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_port, + { "Response Port", "lbmc.umq_resub.resp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_appset_idx, + { "AppSet Index", "lbmc.umq_resub.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_otid, + { "OTID", "lbmc.otid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_otid_next_hdr, + { "Next Header", "lbmc.otid.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_otid_hdr_len, + { "Header Length", "lbmc.otid.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_otid_flags, + { "Flags", "lbmc.otid.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_otid_flags_ignore, + { "Ignore", "lbmc.otid.flags.ignore", FT_BOOLEAN, L_LBMC_OTID_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_otid_otid, + { "OTID", "lbmc.otid.otid", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinst, + { "Context Instance", "lbmc.ctxinst", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinst_next_hdr, + { "Next Header", "lbmc.ctxinst.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinst_hdr_len, + { "Header Length", "lbmc.ctxinst.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinst_flags, + { "Flags", "lbmc.ctxinst.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinst_flags_ignore, + { "Ignore", "lbmc.ctxinst_flags.ignore", FT_BOOLEAN, L_LBMC_CTXINST_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ctxinst_ctxinst, + { "Context Instance", "lbmc.ctxinst.ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinstd, + { "Context Instance Destination", "lbmc.ctxinstd", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinstr, + { "Context Instance Return", "lbmc.ctxinstr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_srcidx, + { "Source Index", "lbmc.srcidx", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_srcidx_next_hdr, + { "Next Header", "lbmc.srcidx.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_srcidx_hdr_len, + { "Header Length", "lbmc.srcidx.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_srcidx_flags, + { "Flags", "lbmc.srcidx.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_srcidx_flags_ignore, + { "Ignore", "lbmc.srcidx.flags.ignore", FT_BOOLEAN, L_LBMC_SRCIDX_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_srcidx_srcidx, + { "Source Index", "lbmc.srcidx.srcidx", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg, + { "UMQ ULB Message", "lbmc.umq_ulb_msg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_next_hdr, + { "Next Header", "lbmc.umq_ulb_msg.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_hdr_len, + { "Header Length", "lbmc.umq_ulb_msg.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_flags, + { "Flags", "lbmc.umq_ulb_msg.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_flags_ignore, + { "Ignore", "lbmc.umq_ulb_msg.flags.ignore", FT_BOOLEAN, L_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_flags_a_flag, + { "Assigned", "lbmc.umq_ulb_msg.flags.a", FT_BOOLEAN, L_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_ULB_MSG_A_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_flags_r_flag, + { "Reassigned", "lbmc.umq_ulb_msg.flags.r", FT_BOOLEAN, L_LBMC_UMQ_ULB_MSG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_ULB_MSG_R_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_queue_id, + { "Queue ID", "lbmc.umq_ulb_msg.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_ulb_src_id, + { "ULB Source ID", "lbmc.umq_ulb_msg.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_assign_id, + { "Assignment ID", "lbmc.umq_ulb_msg.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_appset_idx, + { "AppSet Index", "lbmc.umq_ulb_msg.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_msg_num_ras, + { "Number of RAs", "lbmc.umq_ulb_msg.num_ras", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, "Number of reassignments", HFILL } }, + { &hf_lbmc_ssf_init, + { "SSF Init", "lbmc.ssf_init", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_next_hdr, + { "Next Header", "lbmc.ssf_init.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_hdr_len, + { "Header Length", "lbmc.ssf_init.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_transport, + { "Transport", "lbmc.ssf_init.transport", FT_UINT8, BASE_DEC, VALS(lbmc_ssf_transport_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_flags, + { "Flags", "lbmc.ssf_init.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_flags_ignore, + { "Ignore", "lbmc.ssf_init.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_ssf_init_flags_default_inclusions, + { "Default Inclusions", "lbmc.ssf_init.flags.default_inclusions", FT_BOOLEAN, L_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CNTL_SSF_INIT_DEFAULT_INC, NULL, HFILL } }, + { &hf_lbmc_ssf_init_flags_default_exclusions, + { "Default Exclusions", "lbmc.ssf_init.flags.default_exclusions", FT_BOOLEAN, L_LBMC_CNTL_SSF_INIT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CNTL_SSF_INIT_DEFAULT_EXC, NULL, HFILL } }, + { &hf_lbmc_ssf_init_transport_idx, + { "Transport Index", "lbmc.ssf_init.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_client_idx, + { "Client Index", "lbmc.ssf_init.client_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_ssf_port, + { "SSF Port", "lbmc.ssf_init.ssf_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_res, + { "Reserved", "lbmc.ssf_init.res", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_init_ssf_ip, + { "SSF IP Address", "lbmc.ssf_init.ssf_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_creq, + { "SSF CReq", "lbmc.ssf_creq", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_creq_next_hdr, + { "Next Header", "lbmc.ssf_creq.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_creq_hdr_len, + { "Header Length", "lbmc.ssf_creq.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_creq_flags, + { "Flags", "lbmc.ssf_creq.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_creq_flags_ignore, + { "Ignore", "lbmc.ssf_creq.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_SSF_CREQ_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_ssf_creq_mode, + { "Mode", "lbmc.ssf_creq.mode", FT_UINT8, BASE_HEX, VALS(lbmc_ssf_creq_mode), 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_creq_transport_idx, + { "Transport Index", "lbmc.ssf_creq.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_creq_topic_idx, + { "Topic Index", "lbmc.ssf_creq.topic_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ssf_creq_client_idx, + { "Client Index", "lbmc.ssf_creq.client_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg, + { "UME PReg", "lbmc.ume_preg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_next_hdr, + { "Next Header", "lbmc.ume_preg.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_hdr_len, + { "Header Length", "lbmc.ume_preg.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_flags, + { "Flags", "lbmc.ume_preg.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_flags_ignore, + { "Ignore", "lbmc.ume_preg.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_ume_preg_flags_f_flag, + { "Do Not Forward ACKs", "lbmc.ume_preg.flags.f_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS * 8, TFS(&lbmc_ume_f_flag), LBMC_UME_PREG_F_FLAG, "Set if ACKs are to be forwarded", HFILL } }, + { &hf_lbmc_ume_preg_flags_p_flag, + { "Proxy Source", "lbmc.ume_preg.flags.p_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_PREG_P_FLAG, "Set if this source is a proxy source", HFILL } }, + { &hf_lbmc_ume_preg_flags_w_flag, + { "Receiver Paced Persistence", "lbmc.ume_preg.flags.w_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_PREG_W_FLAG, "Set if receiver paced persistence is used", HFILL } }, + { &hf_lbmc_ume_preg_flags_d_flag, + { "Deregister", "lbmc.ume_preg.flags.d_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_PREG_D_FLAG, "Set if this is a de-registration", HFILL } }, + { &hf_lbmc_ume_preg_marker, + { "Marker", "lbmc.ume_preg.marker", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_marker_s_flag, + { "Source Registration", "lbmc.ume_preg.marker.s_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_HDR_T_MARKER * 8, TFS(&lbmc_ume_s_flag), LBMC_UME_PREG_S_FLAG, "Set if this is a source registration", HFILL } }, + { &hf_lbmc_ume_preg_marker_marker, + { "Marker", "lbmc.ume_preg.marker.marker", FT_UINT8, BASE_DEC_HEX, NULL, LBMC_CNTL_UME_PREG_MARKER_MASK, NULL, HFILL } }, + { &hf_lbmc_ume_preg_reg_id, + { "Registration ID", "lbmc.ume_preg.reg_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_transport_idx, + { "Transport Index", "lbmc.ume_preg.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_topic_idx, + { "Topic Index", "lbmc.ume_preg.topic_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_src_reg_id, + { "Source Registration ID", "lbmc.ume_preg.src_reg_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_port, + { "Response Port", "lbmc.ume_preg.resp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_res2, + { "Reserved2", "lbmc.ume_preg.res2", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_ip, + { "Response IP Address", "lbmc.ume_preg.resp_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp, + { "UME PReg Resp", "lbmc.ume_preg_resp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_next_hdr, + { "Next Header", "lbmc.ume_preg_resp.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_hdr_len, + { "Header Length", "lbmc.ume_preg_resp.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_code, + { "Code", "lbmc.ume_preg_resp.code", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_code_ignore, + { "Ignore", "lbmc.ume_preg_resp.code.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_code_e_flag, + { "Error Indicator", "lbmc.ume_preg_resp.code.e_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE * 8, TFS(&lbmc_ume_error_flag), LBMC_UME_PREG_RESP_E_FLAG, "Set if an error occurred", HFILL } }, + { &hf_lbmc_ume_preg_resp_code_o_flag, + { "Old Client", "lbmc.ume_preg_resp.code.o_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE * 8, TFS(&lbmc_ume_o_flag), LBMC_UME_PREG_RESP_O_FLAG, "Set if an old client was detected", HFILL } }, + { &hf_lbmc_ume_preg_resp_code_n_flag, + { "No ACKs/No Cache", "lbmc.ume_preg_resp.code.n_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE * 8, TFS(&lbmc_ume_n_flag), LBMC_UME_PREG_RESP_CODE_NOACKS_FLAG, "Set if not ACKing or not caching", HFILL } }, + { &hf_lbmc_ume_preg_resp_code_w_flag, + { "Receiver Paced Persistence", "lbmc.ume_preg_resp.code.w_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE * 8, TFS(&tfs_set_notset), LBMC_UME_PREG_RESP_W_FLAG, "Set if receiver paced persistence", HFILL } }, + { &hf_lbmc_ume_preg_resp_code_d_flag, + { "Deregister", "lbmc.ume_preg_resp.code.d_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_CODE * 8, TFS(&tfs_set_notset), LBMC_UME_PREG_RESP_D_FLAG, "Set if deregistration", HFILL } }, + { &hf_lbmc_ume_preg_resp_code_code, + { "Error Code", "lbmc.ume_preg_resp.code.code", FT_UINT8, BASE_HEX, VALS(lbmc_ume_preg_resp_error_code), LBMC_CNTL_UME_PREG_RESP_CODE_MASK, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_marker, + { "Marker", "lbmc.ume_preg_resp.marker", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_marker_s_flag, + { "Source Registration", "lbmc.ume_preg_resp.marker.s_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_PREG_RESP_HDR_T_MARKER * 8, TFS(&lbmc_ume_s_flag), LBMC_UME_PREG_S_FLAG, "Set if source registration", HFILL } }, + { &hf_lbmc_ume_preg_resp_marker_marker, + { "Marker", "lbmc.ume_preg_resp.marker.marker", FT_UINT8, BASE_DEC_HEX, NULL, LBMC_CNTL_UME_PREG_MARKER_MASK, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_reg_id, + { "Registration ID", "lbmc.ume_preg_resp.reg_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_transport_idx, + { "Transport Index", "lbmc.ume_preg_resp.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_topic_idx, + { "Topic Index", "lbmc.ume_preg_resp.topic_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_low_seqnum, + { "Low Sequence Number", "lbmc.ume_preg_resp.low_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_preg_resp_high_seqnum, + { "High Sequence Number", "lbmc.ume_preg_resp.high_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack, + { "UME ACK", "lbmc.ume_ack", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_next_hdr, + { "Next Header", "lbmc.ume_ack.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_hdr_len, + { "Header Length", "lbmc.ume_ack.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_flags, + { "Flags", "lbmc.ume_ack.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_flags_ignore, + { "Ignore", "lbmc.ume_ack.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_ume_ack_flags_o_flag, + { "Receiver Arrival-Order Delivery", "lbmc.ume_ack.flags.o_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_ACK_O_FLAG, "Set if receiver specified arrival-order delivery", HFILL } }, + { &hf_lbmc_ume_ack_flags_f_flag, + { "Do Not Forward ACKs", "lbmc.ume_ack.flags.f_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS * 8, TFS(&lbmc_ume_f_flag), LBMC_UME_ACK_F_FLAG, NULL, HFILL } }, + { &hf_lbmc_ume_ack_flags_u_flag, + { "User-Specified Receiver Registration ID", "lbmc.ume_ack.flags.u_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_ACK_U_FLAG, "Set if receiver registration ID was set by the user", HFILL } }, + { &hf_lbmc_ume_ack_flags_e_flag, + { "Explicit ACK", "lbmc.ume_ack.flags.e_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_ACK_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_ACK_E_FLAG, "Set if an explicit ACK", HFILL } }, + { &hf_lbmc_ume_ack_type, + { "Type", "lbmc.ume_ack.type", FT_UINT8, BASE_HEX, VALS(lbmc_ume_ack_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_transport_idx, + { "Transport Index", "lbmc.ume_ack.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_id_2, + { "Topic Index/Registration ID", "lbmc.ume_ack.id_2", FT_UINT32, BASE_DEC, NULL, 0x0, "Topic index (from store) or Registration ID (from receiver)", HFILL } }, + { &hf_lbmc_ume_ack_rcv_reg_id, + { "Receiver Registration ID", "lbmc.ume_ack.rcv_reg_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_seqnum, + { "Sequence Number", "lbmc.ume_ack.seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq, + { "UME RX Request", "lbmc.ume_rxreq", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_next_hdr, + { "Next Header", "lbmc.ume_rxreq.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_hdr_len, + { "Header Length", "lbmc.ume_rxreq.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_flags, + { "Flags", "lbmc.ume_rxreq.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_flags_ignore, + { "Ignore", "lbmc.ume_rxreq.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_flags_tsni_req, + { "TSNI Request", "lbmc.ume_rxreq.flags.t", FT_BOOLEAN, L_LBMC_CNTL_UME_RXREQ_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_RXREQ_T_FLAG, "Set if TSNI request", HFILL } }, + { &hf_lbmc_ume_rxreq_request_idx, + { "Request Index", "lbmc.ume_rxreq.request_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_transport_idx, + { "Transport Index", "lbmc.ume_rxreq.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_id_2, + { "Topic Index/Registration ID", "lbmc.ume_rxreq.id_2", FT_UINT32, BASE_DEC, NULL, 0x0, "Topic index (from store) or Registration ID (from receiver)", HFILL } }, + { &hf_lbmc_ume_rxreq_seqnum, + { "Sequence Number", "lbmc.ume_rxreq.seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_rx_port, + { "Retransmission Port", "lbmc.ume_rxreq.rx_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_res, + { "Reserved", "lbmc.ume_rxreq.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_rxreq_rx_ip, + { "Retransmission IP Address", "lbmc.ume_rxreq.rx_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive, + { "UME Keepalive", "lbmc.ume_keepalive", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive_next_hdr, + { "Next Header", "lbmc.ume_keepalive.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive_hdr_len, + { "Header Length", "lbmc.ume_keepalive.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive_flags, + { "Flags", "lbmc.ume_keepalive.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive_flags_ignore, + { "Ignore", "lbmc.ume_keepalive.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive_flags_r_flag, + { "Response Requested", "lbmc.ume_keepalive.flags.r_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS * 8, TFS(&lbmc_ume_r_flag), LBMC_UME_KEEPALIVE_R_FLAG, "Set if response requested", HFILL } }, + { &hf_lbmc_ume_keepalive_flags_t_flag, + { "No TIR Seen", "lbmc.ume_keepalive.flags.t_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_KEEPALIVE_HDR_T_FLAGS * 8, TFS(&lbmc_ume_t_flag), LBMC_UME_KEEPALIVE_T_FLAG, "Set if no TIR seen", HFILL } }, + { &hf_lbmc_ume_keepalive_type, + { "Type", "lbmc.ume_keepalive.type", FT_UINT8, BASE_HEX, VALS(lbmc_ume_ka_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive_transport_idx, + { "Transport Index", "lbmc.ume_keepalive.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive_topic_idx, + { "Topic Index", "lbmc.ume_keepalive.topic_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_keepalive_reg_id, + { "Registration ID", "lbmc.ume_keepalive.reg_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storeid, + { "UME Store ID", "lbmc.ume_storeid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storeid_next_hdr, + { "Next Header", "lbmc.ume_storeid.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storeid_hdr_len, + { "Header Length", "lbmc.ume_storeid.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storeid_store_id, + { "Store ID", "lbmc.ume_storeid.storeid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storeid_store_id_ignore, + { "Ignore", "lbmc.ume_storeid.storeid.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_STOREID_HDR_T_STORE_ID * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_storeid_store_id_store_id, + { "Store ID", "lbmc.ume_storeid.storeid.store_id", FT_UINT16, BASE_DEC_HEX, NULL, LBMC_CNTL_UME_STOREID_STOREID_MASK, NULL, HFILL } }, + { &hf_lbmc_ume_ranged_ack, + { "UME Ranged ACK", "lbmc.ume_ranged_ack", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ranged_ack_next_hdr, + { "Next Header", "lbmc.ume_ranged_ack.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ranged_ack_hdr_len, + { "Header Length", "lbmc.ume_ranged_ack.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ranged_ack_flags, + { "Flags", "lbmc.ume_ranged_ack.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ranged_ack_flags_ignore, + { "Ignore", "lbmc.ume_ranged_ack.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_RANGED_ACK_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_ranged_ack_first_seqnum, + { "First Sequence Number", "lbmc.ume_ranged_ack.first_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ranged_ack_last_seqnum, + { "Last Sequence Number", "lbmc.ume_ranged_ack.last_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_id, + { "UME ACK ID", "lbmc.ume_ack_id", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_id_next_hdr, + { "Next Header", "lbmc.ume_ack_id.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_id_hdr_len, + { "Header Length", "lbmc.ume_ack_id.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_id_flags, + { "Flags", "lbmc.ume_ack_id.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_ack_id_flags_ignore, + { "Ignore", "lbmc.ume_ack_id.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_ACK_ID_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_ack_id_id, + { "Acknowledgement ID", "lbmc.ume_ack_id.id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_capability, + { "UME Capability", "lbmc.ume_capability", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_capability_next_hdr, + { "Next Header", "lbmc.ume_capability.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_capability_hdr_len, + { "Header Length", "lbmc.ume_capability.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_capability_flags, + { "Flags", "lbmc.ume_capability.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_capability_flags_ignore, + { "Ignore", "lbmc.ume_capability.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_capability_flags_qc_flag, + { "Quorum/Consensus Capabilities", "lbmc.ume_capability.flags.qc_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_CAPABILITY_QC_FLAG, "Set if quorum/consensus supported", HFILL } }, + { &hf_lbmc_ume_capability_flags_client_lifetime_flag, + { "Client Lifetime Capabilities", "lbmc.ume_capability.flags.client_lifetime_flag", FT_BOOLEAN, L_LBMC_CNTL_UME_CAPABILITY_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_CAPABILITY_CLIENT_LIFETIME_FLAG, "Set if client lifetime enabled", HFILL } }, + { &hf_lbmc_ume_proxy_src, + { "UME Proxy Source", "lbmc.ume_proxy_src", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_proxy_src_next_hdr, + { "Next Header", "lbmc.ume_proxy_src.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_proxy_src_hdr_len, + { "Header Length", "lbmc.ume_proxy_src.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_proxy_src_flags, + { "Flags", "lbmc.ume_proxy_src.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_proxy_src_flags_ignore, + { "Ignore", "lbmc.ume_proxy_src.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_proxy_src_flags_enable, + { "Enable Proxy Source", "lbmc.ume_proxy_src.flags.enable", FT_BOOLEAN, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_PROXY_SRC_E_FLAG, "Set if proxy source is enabled", HFILL } }, + { &hf_lbmc_ume_proxy_src_flags_compatibility, + { "Enable Pre-6.0 Compatibility", "lbmc.ume_proxy_src.flags.compatibility", FT_BOOLEAN, L_LBMC_CNTL_UME_PROXY_SRC_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_PROXY_SRC_C_FLAG, "Set if pre-6.0 compatibility for created proxy source is enabled", HFILL } }, + { &hf_lbmc_ume_store_group, + { "UME Store Group", "lbmc.ume_store_group", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_group_next_hdr, + { "Next Header", "lbmc.ume_store_group.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_group_hdr_len, + { "Header Length", "lbmc.ume_store_group.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_group_flags, + { "Flags", "lbmc.ume_store_group.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_group_flags_ignore, + { "Ignore", "lbmc.ume_store_group.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_STORE_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_store_group_grp_idx, + { "Group Index", "lbmc.ume_store_group.grp_idx", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_group_grp_sz, + { "Group Size", "lbmc.ume_store_group.grp_sz", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_group_res1, + { "Reserved", "lbmc.ume_store_group.res1", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store, + { "UME Store", "lbmc.ume_store", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_next_hdr, + { "Next Header", "lbmc.ume_store.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_hdr_len, + { "Header Length", "lbmc.ume_store.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_flags, + { "Flags", "lbmc.ume_store.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_flags_ignore, + { "Ignore", "lbmc.ume_store.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_STORE_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_store_grp_idx, + { "Group Index", "lbmc.ume_store.grp_idx", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_store_tcp_port, + { "Store TCP Port", "lbmc.ume_store.store_tcp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_store_idx, + { "Store Index", "lbmc.ume_store.store_idx", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_store_ip_addr, + { "Store IP Address", "lbmc.ume_store.store_ip_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_src_reg_id, + { "Source RegID", "lbmc.ume_store.src_reg_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_lj_info, + { "UME Late Join", "lbmc.ume_lj_info", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_lj_info_next_hdr, + { "Next Header", "lbmc.ume_lj_info.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_lj_info_hdr_len, + { "Header Length", "lbmc.ume_lj_info.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_lj_info_flags, + { "Flags", "lbmc.ume_lj_info.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_lj_info_flags_ignore, + { "Ignore", "lbmc.ume_lj_info.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_LJ_INFO_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_lj_info_low_seqnum, + { "Low sequence", "lbmc.ume_lj_info.low_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_lj_info_high_seqnum, + { "High sequence", "lbmc.ume_lj_info.high_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_lj_info_qidx, + { "Request index", "lbmc.ume_lj_info.qidx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tsni, + { "TSNI", "lbmc.tsni", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tsni_next_hdr, + { "Next Header", "lbmc.tsni.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_tsni_hdr_len, + { "Header Length", "lbmc.tsni.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tsni_num_recs, + { "Num Recs", "lbmc.tsni.num_recs", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tsni_num_recs_ignore, + { "Ignore", "lbmc.tsni.num_recs.ignore", FT_BOOLEAN, L_LBMC_CNTL_TSNI_HDR_T_NUM_RECS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_tsni_num_recs_num_recs, + { "Num Recs", "lbmc.tsni.num_recs.num_recs", FT_UINT16, BASE_DEC_HEX, NULL, LBMC_CNTL_TSNI_NUM_RECS_MASK, NULL, HFILL } }, + { &hf_lbmc_tsni_rec, + { "TSNIs", "lbmc.tsni.tsni_rec", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tsni_rec_tidx, + { "Topic Index", "lbmc.tsni.tsni_rec.tidx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tsni_rec_sqn, + { "Sequence Number", "lbmc.tsni.tsni_rec.sqn", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg, + { "UMQ Registration", "lbmc.umq_reg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_next_hdr, + { "Next Header", "lbmc.umq_reg.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_hdr_len, + { "Header Length", "lbmc.umq_reg.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_flags, + { "Flags", "lbmc.umq_reg.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_flags_ignore, + { "Ignore", "lbmc.umq_reg.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_reg_flags_r_flag, + { "R Flag", "lbmc.umq_reg.flags.r_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_R_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_reg_flags_t_flag, + { "TSP Present", "lbmc.umq_reg.flags.t_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_T_FLAG, "Sst if TSP is present", HFILL } }, + { &hf_lbmc_umq_reg_flags_i_flag, + { "Index Assign Eligible", "lbmc.umq_reg.flags.i_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_I_FLAG, "Set if index assign eligible", HFILL } }, + { &hf_lbmc_umq_reg_flags_msg_sel_flag, + { "Message Selector", "lbmc.umq_reg.flags.msg_sel_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_MSG_SEL_FLAG, "Set if message selector present", HFILL } }, + { &hf_lbmc_umq_reg_reg_type, + { "Registration Type", "lbmc.umq_reg.reg_type", FT_UINT8, BASE_DEC, VALS(lbmc_umq_reg_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_queue_id, + { "Queue ID", "lbmc.umq_reg.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_cmd_id, + { "Command ID", "lbmc.umq_reg.cmd_id", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_inst_idx, + { "Instance Index", "lbmc.umq_reg.inst_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_regid, + { "Registration ID", "lbmc.umq_reg.regid", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ctx, + { "Context Registration", "lbmc.umq_reg.reg_ctx", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ctx_port, + { "Port", "lbmc.umq_reg.reg_ctx.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ctx_reserved, + { "Reserved", "lbmc.umq_reg.reg_ctx.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ctx_ip, + { "IP Address", "lbmc.umq_reg.reg_ctx.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ctx_capabilities, + { "Capabilities", "lbmc.umq_reg.reg_ctx.capabilities", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_src, + { "Source Registration", "lbmc.umq_reg.reg_src", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_src_transport_idx, + { "Transport Index", "lbmc.umq_reg.reg_src.transport_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_src_topic_idx, + { "Topic Index", "lbmc.umq_reg.reg_src.topic_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_rcv, + { "Receiver Registration", "lbmc.umq_reg.reg_rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_rcv_assign_id, + { "Assignment ID", "lbmc.umq_reg.reg_rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_rcv_rcv_type_id, + { "Receiver Type ID", "lbmc.umq_reg.reg_rcv.rcv_type_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_rcv_last_topic_rcr_tsp, + { "Last Topic RCR TSP", "lbmc.umq_reg.reg_rcv.last_topic_rcr_tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_rcv_dereg, + { "Receiver deregistration", "lbmc.umq_reg.rcv_dereg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_rcv_dereg_rcr_idx, + { "RCR Index", "lbmc.umq_reg.rcv_dereg.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_rcv_dereg_assign_id, + { "Assignment ID", "lbmc.umq_reg.rcv_dereg.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ulb_rcv, + { "ULB Receiver registration", "lbmc.umq_reg.reg_ulb_rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ulb_rcv_ulb_src_id, + { "ULB Source ID", "lbmc.umq_reg.reg_ulb_rcv.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ulb_rcv_assign_id, + { "Assignment ID", "lbmc.umq_reg.reg_ulb_rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ulb_rcv_rcv_type_id, + { "Receiver Type ID", "lbmc.umq_reg.reg_ulb_rcv.rcv_type_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ulb_rcv_port, + { "Port", "lbmc.umq_reg.reg_ulb_rcv.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ulb_rcv_reserved, + { "Reserved", "lbmc.umq_reg.reg_ulb_rcv.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ulb_rcv_ip, + { "IP Address", "lbmc.umq_reg.reg_ulb_rcv.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_ulb_rcv_capabilities, + { "Capabilities", "lbmc.umq_reg.reg_ulb_rcv.capabilities", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_ulb_rcv_dereg, + { "ULB Receiver Deregistration", "lbmc.umq_reg.ulb_rcv_dereg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_ulb_rcv_dereg_ulb_src_id, + { "ULB Source ID", "lbmc.umq_reg.ulb_rcv_dereg.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_ulb_rcv_dereg_assign_id, + { "Assignment ID", "lbmc.umq_reg.ulb_rcv_dereg.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_observer_rcv, + { "Observer Receiver Registration", "lbmc.umq_reg.reg_observer_rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_observer_rcv_assign_id, + { "Assignment ID", "lbmc.umq_reg.reg_observer_rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_observer_rcv_rcv_type_id, + { "Receiver Type ID", "lbmc.umq_reg.reg_observer_rcv.rcv_type_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_reg_observer_rcv_last_topic_rcr_tsp, + { "Last Topic RCR TSP", "lbmc.umq_reg.reg_observer_rcv.last_topic_rcr_tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_observer_rcv_dereg, + { "Observer Receiver Deregistration", "lbmc.umq_reg.observer_rcv_dereg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_observer_rcv_dereg_rcr_idx, + { "RCR Index", "lbmc.umq_reg.observer_rcv_dereg.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_observer_rcv_dereg_assign_id, + { "Assignment ID", "lbmc.umq_reg.observer_rcv_dereg.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp, + { "UMQ Registration Response", "lbmc.umq_reg_resp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_next_hdr, + { "Next Header", "lbmc.umq_reg_resp.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_hdr_len, + { "Header Length", "lbmc.umq_reg_resp.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_flags, + { "Flags", "lbmc.umq_reg_resp.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_flags_ignore, + { "Ignore", "lbmc.umq_reg_resp.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_flags_r_flag, + { "R Flag", "lbmc.umq_reg_resp.flags.r", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_RESP_R_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_flags_l_flag, + { "ULB Error", "lbmc.umq_reg_resp.flags.l", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_RESP_ERR_L_FLAG, "Set if ULB error occurred", HFILL } }, + { &hf_lbmc_umq_reg_resp_flags_src_s_flag, + { "Source Dissemination", "lbmc.umq_reg_resp.flags.src_s", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_RESP_SRC_S_FLAG, "Set if source dissemination model", HFILL } }, + { &hf_lbmc_umq_reg_resp_flags_src_d_flag, + { "RCR Index Present", "lbmc.umq_reg_resp.flags.src_d", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_RESP_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_RESP_SRC_D_FLAG, "Set if RCR index present", HFILL } }, + { &hf_lbmc_umq_reg_resp_resp_type, + { "Registration Response Type", "lbmc.umq_reg_resp.resp_type", FT_UINT8, BASE_DEC, VALS(lbmc_umq_reg_response_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_queue_id, + { "Queue ID", "lbmc.umq_reg_resp.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_cmd_id, + { "Command ID", "lbmc.umq_reg_resp.cmd_id", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_inst_idx, + { "Instance Index", "lbmc.umq_reg_resp.inst_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_regid, + { "Registration ID", "lbmc.umq_reg_resp.regid", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ctx, + { "Context Registration Response", "lbmc.umq_reg_resp.reg_ctx", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ctx_capabilities, + { "Capabilities", "lbmc.umq_reg_resp.reg_ctx.capabilities", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ctx_ex, + { "Extended Context Registration Response", "lbmc.umq_reg_resp.reg_ctx_ex", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ctx_ex_capabilities, + { "Capabilities", "lbmc.umq_reg_resp.reg_ctx_ex.capabilities", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ctx_ex_reserved, + { "Reserved", "lbmc.umq_reg_resp.reg_ctx_ex.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ctx_ex_flags, + { "Flags", "lbmc.umq_reg_resp.reg_ctx_ex.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ctx_ex_flags_firstmsg, + { "First Message", "lbmc.umq_reg_resp.reg_ctx_ex.flags.firstmsg", FT_BOOLEAN, L_LBMC_CNTL_UMQ_REG_RESP_CTX_EX_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_REG_RESP_CTX_EX_FLAG_FIRSTMSG, "Set if first message", HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ctx_ex_stamp, + { "Stamp", "lbmc.umq_reg_resp.reg_ctx_ex.stamp", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_err, + { "Registration Error Response", "lbmc.umq_reg_resp.err", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_err_reserved, + { "Reserved", "lbmc.umq_reg_resp.err.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_err_code, + { "Code", "lbmc.umq_reg_resp.err.code", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_src, + { "Source Registration Response", "lbmc.umq_reg_resp.reg_src", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_src_rcr_idx, + { "RCR Index", "lbmc.umq_reg_resp.reg_src.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_rcv, + { "Receiver Registration Response", "lbmc.umq_reg_resp.reg_rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_rcv_rcr_idx, + { "RCR Index", "lbmc.umq_reg_resp.reg_rcv.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_rcv_assign_id, + { "Assignment ID", "lbmc.umq_reg_resp.reg_rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_rcv_appset_idx, + { "Application Set Index", "lbmc.umq_reg_resp.reg_rcv.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_rcv_reserved, + { "Reserved", "lbmc.umq_reg_resp.reg_rcv.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_rcv_dereg, + { "Receiver Deregistration Response", "lbmc.umq_reg_resp.rcv_dereg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_rcv_dereg_rcr_idx, + { "RCR Index", "lbmc.umq_reg_resp.rcv_dereg.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_rcv_dereg_assign_id, + { "Assignment ID", "lbmc.umq_reg_resp.rcv_dereg.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ulb_rcv, + { "ULB Receiver Registration Response", "lbmc.umq_reg_resp.reg_ulb_rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ulb_rcv_ulb_src_id, + { "ULB Source ID", "lbmc.umq_reg_resp.reg_ulb_rcv.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ulb_rcv_assign_id, + { "Assignment ID", "lbmc.umq_reg_resp.reg_ulb_rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ulb_rcv_appset_idx, + { "Application Set Index", "lbmc.umq_reg_resp.reg_ulb_rcv.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ulb_rcv_reserved, + { "Reserved", "lbmc.umq_reg_resp.reg_ulb_rcv.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_ulb_rcv_capabilities, + { "Capabilities", "lbmc.umq_reg_resp.reg_ulb_rcv.capabilities", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_ulb_rcv_dereg, + { "ULB Receiver Deregistration Response", "lbmc.umq_reg_resp.ulb_rcv_dereg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_ulb_rcv_dereg_ulb_src_id, + { "ULB Source ID", "lbmc.umq_reg_resp.ulb_rcv_dereg.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_ulb_rcv_dereg_assign_id, + { "Assignment ID", "lbmc.umq_reg_resp.ulb_rcv_dereg.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_observer_rcv, + { "Observer Receiver Registration Response", "lbmc.umq_reg_resp.reg_observer_rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_observer_rcv_rcr_idx, + { "RCR Index", "lbmc.umq_reg_resp.reg_observer_rcv.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_observer_rcv_assign_id, + { "Assignment ID", "lbmc.umq_reg_resp.reg_observer_rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_observer_rcv_appset_idx, + { "Application Set Index", "lbmc.umq_reg_resp.reg_observer_rcv.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_reg_observer_rcv_reserved, + { "Reserved", "lbmc.umq_reg_resp.reg_observer_rcv.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_observer_rcv_dereg, + { "Observer Receiver Deregistration Response", "lbmc.umq_reg_resp.observer_rcv_dereg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_observer_rcv_dereg_rcr_idx, + { "RCR Index", "lbmc.umq_reg_resp.observer_rcv_dereg.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_reg_resp_observer_rcv_dereg_assign_id, + { "Assignment ID", "lbmc.umq_reg_resp.observer_rcv_dereg.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack, + { "UMQ ACK", "lbmc.umq_ack", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_next_hdr, + { "Next Header", "lbmc.umq_ack.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_hdr_len, + { "Header Length", "lbmc.umq_ack.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_msgs, + { "Msgs", "lbmc.umq_ack.msgs", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_msgs_ignore, + { "Ignore", "lbmc.umq_ack.msgs.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_ack_msgs_t_flag, + { "T Flag", "lbmc.umq_ack.msgs.t_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_ACK_T_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_ack_msgs_d_flag, + { "D Flag", "lbmc.umq_ack.msgs.d_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ACK_HDR_T_MSGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_ACK_D_FLAG, NULL, HFILL } }, + { &hf_lbmc_umq_ack_msgs_numids, + { "Number of Message IDs", "lbmc.umq_ack.msgs.num_ids", FT_UINT8, BASE_DEC_HEX, NULL, LBMC_UMQ_ACK_NUMIDS_MASK, NULL, HFILL } }, + { &hf_lbmc_umq_ack_ack_type, + { "ACK Type", "lbmc.umq_ack.ack_type", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_umq_ack_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_msgid, + { "Message ID", "lbmc.umq_ack.msgid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_msgid_regid, + { "Registration ID", "lbmc.umq_ack.msgid.regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_msgid_stamp, + { "Stamp", "lbmc.umq_ack.msgid.stamp", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_stable, + { "Stable", "lbmc.umq_ack.stable", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_stable_queue_id, + { "Queue ID", "lbmc.umq_ack.stable.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_stable_inst_idx, + { "Instance Index", "lbmc.umq_ack.stable.inst_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_stable_reserved, + { "Reserved", "lbmc.umq_ack.stable.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_cr, + { "Consumption Report", "lbmc.umq_ack.cr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_cr_rcr_idx, + { "RCR Index", "lbmc.umq_ack.cr.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_cr_assign_id, + { "Assignment ID", "lbmc.umq_ack.cr.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_cr_appset_idx, + { "Application Set Index", "lbmc.umq_ack.cr.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_cr_reserved, + { "Reserved", "lbmc.umq_ack.cr.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_ulb_cr, + { "ULB Consumption Report", "lbmc.umq_ack.ulb_cr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_ulb_cr_ulb_src_id, + { "ULB Source ID", "lbmc.umq_ack.ulb_cr.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_ulb_cr_assign_id, + { "Assignment ID", "lbmc.umq_ack.ulb_cr.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_ulb_cr_appset_idx, + { "Application Set Index", "lbmc.umq_ack.ulb_cr.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ack_ulb_cr_reserved, + { "Reserved", "lbmc.umq_ack.ulb_cr.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr, + { "UMQ Receiver Control Record", "lbmc.umq_rcr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_next_hdr, + { "Next Header", "lbmc.umq_rcr.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_hdr_len, + { "Header Length", "lbmc.umq_rcr.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_flags, + { "Flags", "lbmc.umq_rcr.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_flags_ignore, + { "Ignore", "lbmc.umq_rcr.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_flags_r_flag, + { "Reassign", "lbmc.umq_rcr.flags.r_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_RCR_R_FLAG, "Set if reassignment", HFILL } }, + { &hf_lbmc_umq_rcr_flags_d_flag, + { "Receiver Deregister", "lbmc.umq_rcr.flags.d_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_RCR_D_FLAG, "Set if receiver deregistration", HFILL } }, + { &hf_lbmc_umq_rcr_flags_s_flag, + { "Resubmit", "lbmc.umq_rcr.flags.s_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_RCR_S_FLAG, "Set if resubmission", HFILL } }, + { &hf_lbmc_umq_rcr_flags_eoi_flag, + { "End of Index", "lbmc.umq_rcr.flags.eoi_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_RCR_EOI_FLAG, "Set if end of index", HFILL } }, + { &hf_lbmc_umq_rcr_flags_boi_flag, + { "Beginning of Index", "lbmc.umq_rcr.flags.boi_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_RCR_BOI_FLAG, "Set if beginning of index", HFILL } }, + { &hf_lbmc_umq_rcr_queue_id, + { "Queue ID", "lbmc.umq_rcr.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_rcr_idx, + { "RCR Index", "lbmc.umq_rcr.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_msgid_regid, + { "Message ID Registration ID", "lbmc.umq_rcr.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_msgid_stamp, + { "Message ID Stamp", "lbmc.umq_rcr.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_topic_tsp, + { "Topic TSP", "lbmc.umq_rcr.topic_tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_q_tsp, + { "Queue TSP", "lbmc.umq_rcr.q_tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_assign_id, + { "Assignment ID", "lbmc.umq_rcr.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_appset_idx, + { "Application Set Index", "lbmc.umq_rcr.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_num_ras, + { "Number of Reassigns", "lbmc.umq_rcr.num_ras", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rcr_queue_ver, + { "Queue Version", "lbmc.umq_rcr.queue_ver", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka, + { "UMQ Keepalive", "lbmc.umq_ka", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_next_hdr, + { "Next Header", "lbmc.umq_ka.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_hdr_len, + { "Header Length", "lbmc.umq_ka.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_flags, + { "Flags", "lbmc.umq_ka.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_flags_ignore, + { "Ignore", "lbmc.umq_ka.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_flags_r_flag, + { "Response Requested", "lbmc.umq_ka.flags.r", FT_BOOLEAN, L_LBMC_CNTL_UMQ_KA_HDR_T_FLAGS * 8, TFS(&lbmc_umq_r_flag), LBMC_UMQ_KA_R_FLAG, "Set if response requested", HFILL } }, + { &hf_lbmc_cntl_umq_ka_ka_type, + { "Keepalive Type", "lbmc.umq_ka.ka_type", FT_UINT8, BASE_HEX_DEC, VALS(lbmc_umq_ka_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_queue_id, + { "Queue ID", "lbmc.umq_ka.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_regid, + { "Registration ID", "lbmc.umq_ka.regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_inst_idx, + { "Instance Index", "lbmc.umq_ka.inst_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_cntl_umq_ka_reserved, + { "Reserved", "lbmc.umq_ka.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_src, + { "Source", "lbmc.umq_ka.src", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_src_transport_idx, + { "Transport Index", "lbmc.umq_ka.src.transport_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_src_topic_idx, + { "Topic Index", "lbmc.umq_ka.src.topic_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_rcv, + { "Receiver", "lbmc.umq_ka.rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_rcv_rcr_idx, + { "RCR Index", "lbmc.umq_ka.rcv.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_rcv_assign_id, + { "Assignment ID", "lbmc.umq_ka.rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_ulb_rcv, + { "ULB Receiver", "lbmc.umq_ka.ulb_rcv", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_ulb_rcv_ulb_src_id, + { "ULB Source ID", "lbmc.umq_ka.ulb_rcv.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_ulb_rcv_assign_id, + { "Assignment ID", "lbmc.umq_ka.ulb_rcv.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_ulb_rcv_resp, + { "ULB Receiver Response", "lbmc.umq_ka.ulb_rcv_resp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_ulb_rcv_resp_ulb_src_id, + { "ULB Source ID", "lbmc.umq_ka.ulb_rcv_resp.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_ulb_rcv_resp_assign_id, + { "Assignment ID", "lbmc.umq_ka.ulb_rcv_resp.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_ulb_rcv_resp_appset_idx, + { "Application Set Index", "lbmc.umq_ka.ulb_rcv_resp.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ka_ulb_rcv_resp_reserved, + { "Reserved", "lbmc.umq_ka.ulb_rcv_resp.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq, + { "UMQ Retransmission Request", "lbmc.umq_rxreq", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_next_hdr, + { "Next Header", "lbmc.umq_rxreq.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_hdr_len, + { "Header Length", "lbmc.umq_rxreq.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_flags, + { "Flags", "lbmc.umq_rxreq.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_flags_ignore, + { "Ignore", "lbmc.umq_rxreq.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_flags_r_flag, + { "RegID Present", "lbmc.umq_rxreq.flags.r", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RXREQ_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_RXREQ_R_FLAG, "Set if registration ID is present", HFILL } }, + { &hf_lbmc_umq_rxreq_rxreq_type, + { "Retransmission Request Type", "lbmc.umq_rxreq.rxreq_type", FT_UINT8, BASE_HEX_DEC, VALS(lbmc_umq_rxreq_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_regid_resp, + { "RegID Response", "lbmc.umq_rxreq.regid_resp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_regid_resp_regid, + { "Registration ID", "lbmc.umq_rxreq.regid_resp.regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_addr_resp, + { "Address Response", "lbmc.umq_rxreq.addr_resp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_addr_resp_ip, + { "IP Address", "lbmc.umq_rxreq.addr_resp.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_addr_resp_port, + { "Port", "lbmc.umq_rxreq.addr_resp.port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_addr_resp_reserved, + { "Reserved", "lbmc.umq_rxreq.addr_resp.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_mr, + { "Message Request", "lbmc.umq_rxreq.mr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_mr_assign_id, + { "Assignment ID", "lbmc.umq_rxreq.mr.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_mr_msgid_regid, + { "Message ID Registration ID", "lbmc.umq_rxreq.mr.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_mr_msgid_stamp, + { "Message ID Stamp", "lbmc.umq_rxreq.mr.msgid_stamp", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr, + { "ULB MR", "lbmc.umq_rxreq.ulb_mr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_ulb_src_id, + { "ULB Source ID", "lbmc.umq_rxreq.ulb_mr.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_assign_id, + { "Assignment ID", "lbmc.umq_rxreq.ulb_mr.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_appset_idx, + { "Application Set Index", "lbmc.umq_rxreq.ulb_mr.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_reserved, + { "Reserved", "lbmc.umq_rxreq.ulb_mr.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_msgid_regid, + { "Message ID Registration ID", "lbmc.umq_rxreq.ulb_mr.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_msgid_stamp, + { "Message ID Stamp", "lbmc.umq_rxreq.ulb_mr.msgid_stamp", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_abort, + { "ULB MR Abort", "lbmc.umq_rxreq.ulb_mr_abort", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_abort_ulb_src_id, + { "ULB Source ID", "lbmc.umq_rxreq.ulb_mr_abort.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_abort_assign_id, + { "Assignment ID", "lbmc.umq_rxreq.ulb_mr_abort.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_abort_msgid_regid, + { "Message ID Registration ID", "lbmc.umq_rxreq.ulb_mr_abort.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_mr_abort_msgid_stamp, + { "Message ID Stamp", "lbmc.umq_rxreq.ulb_mr_abort.msgid_stamp", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_qrcrr, + { "Queue RCR Request", "lbmc.umq_rxreq.qrrcr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_qrcrr_tsp, + { "TSP", "lbmc.umq_rxreq.qrrcr.tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_trcrr, + { "Topic RCR Request", "lbmc.umq_rxreq.trcrr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_trcrr_rcr_idx, + { "RCR Index", "lbmc.umq_rxreq.trcrr.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_trcrr_tsp, + { "TSP", "lbmc.umq_rxreq.trcrr.tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_trcrr, + { "ULB Topic RCR Request", "lbmc.umq_rxreq.ulb_trcrr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_trcrr_ulb_src_id, + { "ULB Source ID", "lbmc.umq_rxreq.ulb_trcrr.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_trcrr_assign_id, + { "Assignment ID", "lbmc.umq_rxreq.ulb_trcrr.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_trcrr_tsp, + { "TSP", "lbmc.umq_rxreq.ulb_trcrr.tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_trcrr_abort, + { "ULB TRCRR Abort", "lbmc.umq_rxreq.ulb_trcrr_abort", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_trcrr_abort_ulb_src_id, + { "ULB Source ID", "lbmc.umq_rxreq.ulb_trcrr_abort.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_trcrr_abort_assign_id, + { "Assignment ID", "lbmc.umq_rxreq.ulb_trcrr_abort.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_rxreq_ulb_trcrr_abort_tsp, + { "TSP", "lbmc.umq_rxreq.ulb_trcrr_abort.tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_qmgmt, + { "Queue Management", "lbmc.umq_qmgmt", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_qmgmt_next_hdr, + { "Next Header", "lbmc.umq_qmgmt.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_qmgmt_hdr_len, + { "Header Length", "lbmc.umq_qmgmt.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req, + { "UMQ Resubmission Request", "lbmc.umq_resub_req", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_next_hdr, + { "Next Header", "lbmc.umq_resub_req.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_hdr_len, + { "Header Length", "lbmc.umq_resub_req.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_flags, + { "Flags", "lbmc.umq_resub_req.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_flags_ignore, + { "Ignore", "lbmc.umq_resub_req.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RESUB_REQ_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_msgid_regid, + { "Message ID Registration ID", "lbmc.umq_resub_req.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_msgid_stamp, + { "Message ID Stamp", "lbmc.umq_resub_req.msgid_stamp", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_rcr_idx, + { "RCR Index", "lbmc.umq_resub_req.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_resp_ip, + { "Response IP Address", "lbmc.umq_resub_req.resp_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_resp_port, + { "Response Port", "lbmc.umq_resub_req.resp_port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_req_appset_idx, + { "Application Set Index", "lbmc.umq_resub_req.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp, + { "UMQ Resubmission Response", "lbmc.umq_resub_resp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_next_hdr, + { "Next Header", "lbmc.umq_resub_resp.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_hdr_len, + { "Header Length", "lbmc.umq_resub_resp.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_flags, + { "Flags", "lbmc.umq_resub_resp.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_flags_ignore, + { "Ignore", "lbmc.umq_resub_resp.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_RESUB_RESP_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_code, + { "Code", "lbmc.umq_resub_resp.code", FT_UINT8, BASE_HEX_DEC, VALS(lbmc_umq_resub_response_code), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_msgid_regid, + { "Message ID Registration ID", "lbmc.umq_resub_resp.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_msgid_stamp, + { "Message ID Stamp", "lbmc.umq_resub_resp.msgid_stamp", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_rcr_idx, + { "RCR Index", "lbmc.umq_resub_resp.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_reserved, + { "Reserved", "lbmc.umq_resub_resp.resp_ip", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_resub_resp_appset_idx, + { "Application Set Index", "lbmc.umq_resub_resp.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_interest, + { "Topic Interest", "lbmc.topic_interest", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_interest_next_hdr, + { "Next Header", "lbmc.topic_interest.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_interest_hdr_len, + { "Header Length", "lbmc.topic_interest.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_interest_flags, + { "Flags", "lbmc.topic_interest.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_interest_flags_ignore, + { "Ignore", "lbmc.topic_interest.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_topic_interest_flags_cancel, + { "Cancel", "lbmc.topic_interest.flags.cancel", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_TOPIC_INTEREST_CANCEL_FLAG, "Set if cancelling interest", HFILL } }, + { &hf_lbmc_topic_interest_flags_refresh, + { "Refresh", "lbmc.topic_interest.flags.refresh", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_INTEREST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_TOPIC_INTEREST_REFRESH_FLAG, "Set if refreshing interest", HFILL } }, + { &hf_lbmc_topic_interest_domain_id, + { "Domain ID", "lbmc.topic_interest.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_interest, + { "Pattern Interest", "lbmc.pattern_interest", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_interest_next_hdr, + { "Next Header", "lbmc.pattern_interest.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_interest_hdr_len, + { "Header Length", "lbmc.pattern_interest.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_interest_flags, + { "Flags", "lbmc.pattern_interest.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_interest_flags_ignore, + { "Ignore", "lbmc.pattern_interest.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_pattern_interest_flags_cancel, + { "Cancel", "lbmc.pattern_interest.flags.cancel", FT_BOOLEAN, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_PATTERN_INTEREST_CANCEL_FLAG, "Set if cancelling interest", HFILL } }, + { &hf_lbmc_pattern_interest_flags_refresh, + { "Refresh", "lbmc.pattern_interest.flags.refresh", FT_BOOLEAN, L_LBMC_CNTL_PATTERN_INTEREST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_PATTERN_INTEREST_REFRESH_FLAG, "Set if refreshing interest", HFILL } }, + { &hf_lbmc_pattern_interest_type, + { "Type", "lbmc.pattern_interest.type", FT_UINT8, BASE_DEC_HEX, VALS(lbm_wildcard_pattern_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_interest_domain_id, + { "Domain ID", "lbmc.pattern_interest.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_interest_index, + { "Index", "lbmc.pattern_interest.index", FT_INT64, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement, + { "Advertisement", "lbmc.advertisement", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_next_hdr, + { "Next Header", "lbmc.advertisement.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_hdr_len, + { "Header Length", "lbmc.advertisement.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_flags, + { "Flags", "lbmc.advertisement.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_flags_ignore, + { "Ignore", "lbmc.advertisement.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_advertisement_flags_eos, + { "EOS", "lbmc.advertisement.flags.eos", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_EOS_FLAG, "Set if source EOS is being advertised", HFILL } }, + { &hf_lbmc_advertisement_flags_pattern, + { "Pattern", "lbmc.advertisement.flags.pattern", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_PATTERN_FLAG, "Set if the topic being advertised matched a pattern", HFILL } }, + { &hf_lbmc_advertisement_flags_change, + { "Change", "lbmc.advertisement.flags.change", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_CHANGE_FLAG, "Set if the advertisement indicates a change", HFILL } }, + { &hf_lbmc_advertisement_flags_ctxinst, + { "Context Instance", "lbmc.advertisement.flags.ctxinst", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_CTXINST_FLAG, NULL, HFILL } }, + { &hf_lbmc_advertisement_hop_count, + { "Hop Count", "lbmc.advertisement.hop_count", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_ad_flags, + { "Ad Flags", "lbmc.advertisement.ad_flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_ad_flags_lj, + { "Late Join", "lbmc.advertisement.ad_flags.lj", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_AD_LJ_FLAG, "Set if source provides late join", HFILL } }, + { &hf_lbmc_advertisement_ad_flags_ume, + { "UME", "lbmc.advertisement.ad_flags.ume", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_AD_UME_FLAG, "Set if a UME source", HFILL } }, + { &hf_lbmc_advertisement_ad_flags_acktosrc, + { "ACK To Source", "lbmc.advertisement.ad_flags.acktosrc", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_AD_ACKTOSRC_FLAG, "Set if ACKs are sent to source", HFILL } }, + { &hf_lbmc_advertisement_ad_flags_queue, + { "Queue", "lbmc.advertisement.ad_flags.queue", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_AD_QUEUE_FLAG, "Set if a queue", HFILL } }, + { &hf_lbmc_advertisement_ad_flags_ulb, + { "ULB", "lbmc.advertisement.ad_flags.ulb", FT_BOOLEAN, L_LBMC_CNTL_ADVERTISEMENT_HDR_T_AD_FLAGS * 8, TFS(&tfs_set_notset), LBMC_ADVERTISEMENT_AD_ULB_FLAG, "Set if a ULB source", HFILL } }, + { &hf_lbmc_advertisement_cost, + { "Cost", "lbmc.advertisement.cost", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_transport_idx, + { "Transport Index", "lbmc.advertisement.transport_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_topic_idx, + { "Topic Index", "lbmc.advertisement.topic_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_low_seqno, + { "Low Sequence Number", "lbmc.advertisement.low_seqno", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_high_seqno, + { "High Sequence Number", "lbmc.advertisement.high_seqno", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_domain_id, + { "Domain ID", "lbmc.advertisement.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_pat_idx, + { "Pattern Index", "lbmc.advertisement.pat_idx", FT_INT64, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_advertisement_ctxinst, + { "Context Instance", "lbmc.advertisement.ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storename, + { "Store Name", "lbmc.ume_storename", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storename_next_hdr, + { "Next Header", "lbmc.ume_storename.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storename_hdr_len, + { "Header Length", "lbmc.ume_storename.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storename_flags, + { "Flags", "lbmc.ume_storename.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_storename_flags_ignore, + { "Ignore", "lbmc.ume_storename.flags.ignore", FT_BOOLEAN, L_LBMC_UME_STORENAME_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_storename_store, + { "Store Name", "lbmc.ume_storename.store", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr, + { "UMQ ULB Receiver Control Record", "lbmc.umq_ulb_rcr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_next_hdr, + { "Next Header", "lbmc.umq_ulb_rcr.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_hdr_len, + { "Header Length", "lbmc.umq_ulb_rcr.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_flags, + { "Flags", "lbmc.umq_ulb_rcr.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_flags_ignore, + { "Ignore", "lbmc.umq_ulb_rcr.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_flags_r_flag, + { "Reassign", "lbmc.umq_ulb_rcr.flags.r_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_ULB_RCR_R_FLAG, "Reassign", HFILL } }, + { &hf_lbmc_umq_ulb_rcr_flags_d_flag, + { "Receiver Deregister", "lbmc.umq_ulb_rcr.flags.d_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_ULB_RCR_D_FLAG, "Receiver deregister", HFILL } }, + { &hf_lbmc_umq_ulb_rcr_flags_eoi_flag, + { "End of Index", "lbmc.umq_ulb_rcr.flags.eoi_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_ULB_RCR_EOI_FLAG, "End of index", HFILL } }, + { &hf_lbmc_umq_ulb_rcr_flags_boi_flag, + { "Beginning of Index", "lbmc.umq_ulb_rcr.flags.boi_flag", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ULB_RCR_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_ULB_RCR_BOI_FLAG, "Beginning of index", HFILL } }, + { &hf_lbmc_umq_ulb_rcr_queue_id, + { "Queue ID", "lbmc.umq_ulb_rcr.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_ulb_src_id, + { "ULB Source ID", "lbmc.umq_ulb_rcr.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_msgid_regid, + { "Message ID Registration ID", "lbmc.umq_ulb_rcr.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_msgid_stamp, + { "Message ID Stamp", "lbmc.umq_ulb_rcr.msgid_regid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_topic_tsp, + { "Topic TSP", "lbmc.umq_ulb_rcr.topic_tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_assign_id, + { "Assignment ID", "lbmc.umq_ulb_rcr.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_appset_idx, + { "Application Set Index", "lbmc.umq_ulb_rcr.appset_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_ulb_rcr_num_ras, + { "Number of RAs", "lbmc.umq_ulb_rcr.num_ras", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_lf, + { "UMQ Load Factor", "lbmc.umq_lf", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_lf_next_hdr, + { "Next Header", "lbmc.umq_lf.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_lf_hdr_len, + { "Header Length", "lbmc.umq_lf.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_lf_flags, + { "Flags", "lbmc.umq_lf.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_lf_flags_ignore, + { "Ignore", "lbmc.umq_lf.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_LF_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_lf_type, + { "Type", "lbmc.umq_lf.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmc_umq_lf_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_lf_num_srcs, + { "Number of Sources", "lbmc.umq_lf.resp_ip", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_lf_lf, + { "Load Factor", "lbmc.umq_lf.lf", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo, + { "Context Information", "lbmc.ctxinfo", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_next_hdr, + { "Next Header", "lbmc.ctxinfo.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_hdr_len, + { "Header Length", "lbmc.ctxinfo.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags, + { "Flags", "lbmc.ctxinfo.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags_ignore, + { "Ignore", "lbmc.ctxinfo.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags_query, + { "Query", "lbmc.ctxinfo.flags.query", FT_BOOLEAN, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CTXINFO_QUERY_FLAG, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags_addr, + { "Address", "lbmc.ctxinfo.flags.addr", FT_BOOLEAN, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CTXINFO_ADDR_FLAG, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags_ctxinst, + { "Context Instance", "lbmc.ctxinfo.flags.ctxinst", FT_BOOLEAN, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CTXINFO_CTXINST_FLAG, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags_name, + { "Name", "lbmc.ctxinfo.flags.name", FT_BOOLEAN, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CTXINFO_NAME_FLAG, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags_tnwgsrc, + { "Gateway Source", "lbmc.ctxinfo.flags.tnwgsrc", FT_BOOLEAN, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CTXINFO_TNWGSRC_FLAG, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags_tnwgrcv, + { "Gateway Receive", "lbmc.ctxinfo.flags.tnwgrcv", FT_BOOLEAN, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CTXINFO_TNWGRCV_FLAG, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_flags_proxy, + { "Proxy", "lbmc.ctxinfo.flags.proxy", FT_BOOLEAN, L_LBMC_CNTL_CTXINFO_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CTXINFO_PROXY_FLAG, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_reserved, + { "Reserved", "lbmc.ctxinfo.reserved", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_hop_count, + { "Hop Count", "lbmc.ctxinfo.hop_count", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_port, + { "Port", "lbmc.ctxinfo.port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_addr, + { "Address", "lbmc.ctxinfo.addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_domain_id, + { "Domain ID", "lbmc.ctxinfo.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_ctxinst, + { "Context Instance", "lbmc.ctxinfo.ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ctxinfo_name, + { "Name", "lbmc.ctxinfo.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser, + { "UME Proxy Source Election Record", "lbmc.ume_pser", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_next_hdr, + { "Next Header", "lbmc.ume_pser.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_hdr_len, + { "Header Length", "lbmc.ume_pser.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_flags, + { "Flags", "lbmc.ume_pser.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_flags_ignore, + { "Ignore", "lbmc.ume_pser.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_pser_flags_source_ctxinst, + { "Source Context Instance", "lbmc.ume_pser.flags.source_ctxinst", FT_BOOLEAN, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_PSER_SOURCE_CTXINST_FLAG, NULL, HFILL } }, + { &hf_lbmc_ume_pser_flags_store_ctxinst, + { "Store Context Instance", "lbmc.ume_pser.flags.store_ctxinst", FT_BOOLEAN, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_PSER_STORE_CTXINST_FLAG, NULL, HFILL } }, + { &hf_lbmc_ume_pser_flags_reelect, + { "Reelection", "lbmc.ume_pser.flags.reelect", FT_BOOLEAN, L_LBMC_CNTL_UME_PSER_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UME_PSER_REELECT_FLAG, NULL, HFILL } }, + { &hf_lbmc_ume_pser_source_ip, + { "Source Address", "lbmc.ume_pser.source_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_store_ip, + { "Store Address", "lbmc.ume_pser.store_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_transport_idx, + { "Transport Index", "lbmc.ume_pser.transport_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_topic_idx, + { "Topic Index", "lbmc.ume_pser.topic_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_source_port, + { "Source Port", "lbmc.ume_pser.source_port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_store_port, + { "Store Port", "lbmc.ume_pser.store_port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_source_ctxinst, + { "Source Context Instance", "lbmc.ume_pser.source_ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_pser_store_ctxinst, + { "Store Context Instance", "lbmc.ume_pser.store_ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_domain, + { "Domain", "lbmc.domain", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_domain_next_hdr, + { "Next Header", "lbmc.domain.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_domain_hdr_len, + { "Header Length", "lbmc.domain.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_domain_flags, + { "Flags", "lbmc.domain.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_domain_flags_ignore, + { "Ignore", "lbmc.domain.flags.ignore", FT_BOOLEAN, L_LBMC_DOMAIN_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_domain_flags_active, + { "Active", "lbmc.domain.flags.active", FT_BOOLEAN, L_LBMC_DOMAIN_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_DOMAIN_ACTIVE_FLAG, NULL, HFILL } }, + { &hf_lbmc_domain_domain, + { "Domain ID", "lbmc.domain.domain", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities, + { "TNWG Capabilities", "lbmc.tnwg_capabilities", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_next_hdr, + { "Next Header", "lbmc.tnwg_capabilities.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_hdr_len, + { "Header Length", "lbmc.tnwg_capabilities.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_flags, + { "Flags", "lbmc.tnwg_capabilities.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_flags_ignore, + { "Ignore", "lbmc.tnwg_capabilities.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_flags_version, + { "Version", "lbmc.tnwg_capabilities.flags.version", FT_UINT16, BASE_DEC, NULL, LBMC_CNTL_TNWG_CAPABILITIES_VERSION_MASK, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_capabilities1, + { "Capabilities1", "lbmc.tnwg_capabilities.capabilities1", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_capabilities1_ume, + { "UME", "lbmc.tnwg_capabilities.capabilities1.ume", FT_BOOLEAN, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1 * 8, TFS(&tfs_set_notset), LBMC_CNTL_TNWG_CAPABILITIES1_UME_FLAG, "Set if UME is supported", HFILL } }, + { &hf_lbmc_tnwg_capabilities_capabilities1_umq, + { "UMQ", "lbmc.tnwg_capabilities.capabilities1.umq", FT_BOOLEAN, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES1 * 8, TFS(&tfs_set_notset), LBMC_CNTL_TNWG_CAPABILITIES1_UMQ_FLAG, "Set if UMQ is supported", HFILL } }, + { &hf_lbmc_tnwg_capabilities_capabilities2, + { "Capabilities2", "lbmc.tnwg_capabilities.capabilities2", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_capabilities3, + { "Capabilities3", "lbmc.tnwg_capabilities.capabilities3", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_capabilities_capabilities3_pcre, + { "PCRE", "lbmc.tnwg_capabilities.capabilities3.pcre", FT_BOOLEAN, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3 * 8, TFS(&tfs_set_notset), LBMC_CNTL_TNWG_CAPABILITIES3_PCRE_FLAG, "Set if PCRE patterns are supported", HFILL } }, + { &hf_lbmc_tnwg_capabilities_capabilities3_regex, + { "Regex", "lbmc.tnwg_capabilities.capabilities3.regex", FT_BOOLEAN, L_LBMC_CNTL_TNWG_CAPABILITIES_HDR_T_CAPABILITIES3 * 8, TFS(&tfs_set_notset), LBMC_CNTL_TNWG_CAPABILITIES3_REGEX_FLAG, "Set if Regex patters are supported", HFILL } }, + { &hf_lbmc_tnwg_capabilities_capabilities4, + { "Capabilities4", "lbmc.tnwg_capabilities.capabilities4", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_patidx, + { "Pattern Index", "lbmc.patidx", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_patidx_next_hdr, + { "Next Header", "lbmc.patidx.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_patidx_hdr_len, + { "Header Length", "lbmc.patidx.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_patidx_flags, + { "Flags", "lbmc.patidx.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_patidx_flags_ignore, + { "Ignore", "lbmc.patidx.flags.ignore", FT_BOOLEAN, L_LBMC_PATIDX_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_patidx_patidx, + { "Source Index", "lbmc.patidx.patidx", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_client_lifetime, + { "UME Client Lifetime", "lbmc.ume_client_lifetime", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_client_lifetime_next_hdr, + { "Next Header", "lbmc.ume_client_lifetime.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_client_lifetime_hdr_len, + { "Header Length", "lbmc.ume_client_lifetime.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_client_lifetime_flags, + { "Flags", "lbmc.ume_client_lifetime.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_client_lifetime_flags_ignore, + { "Ignore", "lbmc.ume_client_lifetime.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_CLIENT_LIFETIME_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_client_lifetime_activity_tmo, + { "Activity Timeout", "lbmc.ume_client_lifetime.activity_tmo", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_client_lifetime_lifetime, + { "Lifetime", "lbmc.ume_client_lifetime.lifetime", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_client_lifetime_ttl, + { "Time to Live", "lbmc.ume_client_lifetime.ttl", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_sid, + { "UME Session ID", "lbmc.ume_sid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_sid_next_hdr, + { "Next Header", "lbmc.ume_sid.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_sid_hdr_len, + { "Header Length", "lbmc.ume_sid.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_sid_flags, + { "Flags", "lbmc.ume_sid.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_sid_flags_ignore, + { "Ignore", "lbmc.ume_sid.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_SID_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_sid_sid, + { "Session ID", "lbmc.ume_sid.sid", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd, + { "UMQ Index Command", "lbmc.umq_idx_cmd", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_next_hdr, + { "Next Header", "lbmc.umq_idx_cmd.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_hdr_len, + { "Header Length", "lbmc.umq_idx_cmd.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_flags, + { "Flags", "lbmc.umq_idx_cmd.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_flags_ignore, + { "Ignore", "lbmc.umq_idx_cmd.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_IDX_CMD_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_cmd_type, + { "Command Type", "lbmc.umq_idx_cmd.cmd_type", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_umq_index_cmd_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_queue_id, + { "Queue ID", "lbmc.umq_idx_cmd.queue_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_cmd_id, + { "Command ID", "lbmc.umq_idx_cmd.cmd_id", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_inst_idx, + { "Instance Index", "lbmc.umq_idx_cmd.inst_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_regid, + { "RegID", "lbmc.umq_idx_cmd.regid", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_stop_assign, + { "Stop Assign", "lbmc.umq_idx_cmd.stop_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_stop_assign_rcr_idx, + { "RCR Index", "lbmc.umq_idx_cmd.stop_assign.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_stop_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd.stop_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_start_assign, + { "Start Assign", "lbmc.umq_idx_cmd.start_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_start_assign_rcr_idx, + { "RCR Index", "lbmc.umq_idx_cmd.start_assign.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_start_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd.start_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign, + { "Release Assign", "lbmc.umq_idx_cmd.release_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign_rcr_idx, + { "RCR Index", "lbmc.umq_idx_cmd.release_assign.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd.release_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign_flags, + { "Flags", "lbmc.umq_idx_cmd.release_assign.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign_flags_numeric, + { "Numeric", "lbmc.umq_idx_cmd.release_assign.flags.numeric", FT_BOOLEAN, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBM_UMQ_INDEX_FLAG_NUMERIC, "Set if index is numeric", HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign_index_len, + { "Index Length", "lbmc.umq_idx_cmd.release_assign.index_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd.release_assign.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign_numeric_index, + { "Index", "lbmc.umq_idx_cmd.release_assign.numeric_index", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_release_assign_string_index, + { "Index", "lbmc.umq_idx_cmd.release_assign.string_index", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_stop_assign, + { "ULB Stop Assign", "lbmc.umq_idx_cmd.ulb_stop_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_stop_assign_src_id, + { "Source ID", "lbmc.umq_idx_cmd.ulb_stop_assign.src_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_stop_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd.ulb_stop_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_stop_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd.ulb_stop_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_stop_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd.ulb_stop_assign.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_start_assign, + { "ULB Start Assign", "lbmc.umq_idx_cmd.ulb_start_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_start_assign_src_id, + { "Source ID", "lbmc.umq_idx_cmd.ulb_start_assign.src_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_start_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd.ulb_start_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_start_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd.ulb_start_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_start_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd.ulb_start_assign.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign, + { "ULB Release Assign", "lbmc.umq_idx_cmd.ulb_release_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_src_id, + { "Source ID", "lbmc.umq_idx_cmd.ulb_release_assign.src_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd.ulb_release_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_flags, + { "Flags", "lbmc.umq_idx_cmd.ulb_release_assign.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_flags_numeric, + { "Numeric", "lbmc.umq_idx_cmd.ulb_release_assign.flags.numeric", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RELEASE_IDX_ASSIGN_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBM_UMQ_INDEX_FLAG_NUMERIC, "Set if index is numeric", HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd.ulb_release_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_index_len, + { "Index Length", "lbmc.umq_idx_cmd.ulb_release_assign.index_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd.ulb_release_assign.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_numeric_index, + { "Index", "lbmc.umq_idx_cmd.ulb_release_assign.numeric_index", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_release_assign_string_index, + { "Index", "lbmc.umq_idx_cmd.ulb_release_assign.string_index", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign, + { "Reserve Assign", "lbmc.umq_idx_cmd.reserve_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign_rcr_idx, + { "RCR Index", "lbmc.umq_idx_cmd.reserve_assign.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd.reserve_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign_flags, + { "Flags", "lbmc.umq_idx_cmd.reserve_assign.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign_flags_numeric, + { "Numeric", "lbmc.umq_idx_cmd.reserve_assign.flags.numeric", FT_BOOLEAN, L_LBMC_CNTL_UMQ_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBM_UMQ_INDEX_FLAG_NUMERIC, "Set if index is numeric", HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign_index_len, + { "Index Length", "lbmc.umq_idx_cmd.reserve_assign.index_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd.reserve_assign.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign_numeric_index, + { "Index", "lbmc.umq_idx_cmd.reserve_assign.numeric_index", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_reserve_assign_string_index, + { "Index", "lbmc.umq_idx_cmd.reserve_assign.string_index", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign, + { "ULB Reserve Assign", "lbmc.umq_idx_cmd.ulb_reserve_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_src_id, + { "Source ID", "lbmc.umq_idx_cmd.ulb_reserve_assign.src_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd.ulb_reserve_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_flags, + { "Flags", "lbmc.umq_idx_cmd.ulb_reserve_assign.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_flags_numeric, + { "Numeric", "lbmc.umq_idx_cmd.ulb_reserve_assign.flags.numeric", FT_BOOLEAN, L_LBMC_CNTL_UMQ_ULB_IDX_CMD_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBM_UMQ_INDEX_FLAG_NUMERIC, "Set if index is numeric", HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd.ulb_reserve_assign.index_len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_index_len, + { "Index Length", "lbmc.umq_idx_cmd.ulb_reserve_assign.index_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd.ulb_reserve_assign.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_numeric_index, + { "Index", "lbmc.umq_idx_cmd.ulb_reserve_assign.numeric_index", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_ulb_reserve_assign_string_index, + { "Index", "lbmc.umq_idx_cmd.ulb_reserve_assign.string_index", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp, + { "UMQ Index Command Response", "lbmc.umq_idx_cmd_resp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_next_hdr, + { "Next Header", "lbmc.umq_idx_cmd_resp.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_hdr_len, + { "Header Length", "lbmc.umq_idx_cmd_resp.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_flags, + { "Flags", "lbmc.umq_idx_cmd_resp.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_flags_ignore, + { "Ignore", "lbmc.umq_idx_cmd_resp.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_flags_ulb, + { "ULB", "lbmc.umq_idx_cmd_resp.flags.ulb", FT_BOOLEAN, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_UMQ_IDX_CMD_RESP_ERR_L_FLAG, "Set if ULB", HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_resp_type, + { "Response Type", "lbmc.umq_idx_cmd_resp.resp_type", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_umq_index_cmd_response_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_queue_id, + { "Queue ID", "lbmc.umq_idx_cmd_resp.queue_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_cmd_id, + { "Command ID", "lbmc.umq_idx_cmd_resp.cmd_id", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_inst_idx, + { "Instance Index", "lbmc.umq_idx_cmd_resp.inst_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_regid, + { "RegID", "lbmc.umq_idx_cmd_resp.regid", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_err, + { "Error", "lbmc.umq_idx_cmd_resp.err", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_err_reserved, + { "Reserved", "lbmc.umq_idx_cmd_resp.err.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_err_code, + { "Code", "lbmc.umq_idx_cmd_resp.err.code", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_err_error_string, + { "Error String", "lbmc.umq_idx_cmd_resp.err.error_string", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_stop_assign, + { "Stop Assign", "lbmc.umq_idx_cmd_resp.stop_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_stop_assign_rcr_idx, + { "RCR Index", "lbmc.umq_idx_cmd_resp.stop_assign.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_stop_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd_resp.stop_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_start_assign, + { "Start Assign", "lbmc.umq_idx_cmd_resp.start_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_start_assign_rcr_idx, + { "RCR Index", "lbmc.umq_idx_cmd_resp.start_assign.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_start_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd_resp.start_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_start_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd_resp.start_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_start_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd_resp.start_assign.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_release_assign, + { "Release Assign", "lbmc.umq_idx_cmd_resp.release_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_release_assign_rcr_idx, + { "RCR Index", "lbmc.umq_idx_cmd_resp.release_assign.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_release_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd_resp.release_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_release_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd_resp.release_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_release_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd_resp.release_assign.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign, + { "ULB Stop Assign", "lbmc.umq_idx_cmd_resp.ulb_stop_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_src_id, + { "Source ID", "lbmc.umq_idx_cmd_resp.ulb_stop_assign.src_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd_resp.ulb_stop_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd_resp.ulb_stop_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_stop_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd_resp.ulb_stop_assign.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_start_assign, + { "ULB Start Assign", "lbmc.umq_idx_cmd_resp.ulb_start_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_src_id, + { "Source ID", "lbmc.umq_idx_cmd_resp.ulb_start_assign.src_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd_resp.ulb_start_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd_resp.ulb_start_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_start_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd_resp.ulb_start_assign.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_release_assign, + { "ULB Release Assign", "lbmc.umq_idx_cmd_resp.ulb_release_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_src_id, + { "Source ID", "lbmc.umq_idx_cmd_resp.ulb_release_assign.src_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd_resp.ulb_release_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_appset_idx, + { "Application Set Index", "lbmc.umq_idx_cmd_resp.ulb_release_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_release_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd_resp.ulb_release_assign.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign, + { "Reserve Assign", "lbmc.umq_idx_cmd_resp.reserve_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_rcr_idx, + { "RCR Index", "lbmc.umq_idx_cmd_resp.reserve_assign.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd_resp.reserve_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_flags, + { "Flags", "lbmc.umq_idx_cmd_resp.reserve_assign.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_flags_numeric, + { "Numeric", "lbmc.umq_idx_cmd_resp.reserve_assign.flags.numeric", FT_BOOLEAN, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBM_UMQ_INDEX_FLAG_NUMERIC, "Set if index is numeric", HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_appset_idx, + { "AppSet Index", "lbmc.umq_idx_cmd_resp.reserve_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_index_len, + { "Index Length", "lbmc.umq_idx_cmd_resp.reserve_assign.index_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd_resp.reserve_assign.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_numeric_index, + { "Index", "lbmc.umq_idx_cmd_resp.reserve_assign.numeric_index", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_reserve_assign_string_index, + { "Index", "lbmc.umq_idx_cmd_resp.reserve_assign.string_index", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign, + { "ULB Reserve Assign", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_src_id, + { "Source ID", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.src_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_assign_id, + { "Assignment ID", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags, + { "Flags", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags_numeric, + { "Numeric", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.flags.numeric", FT_BOOLEAN, L_LBMC_CNTL_UMQ_IDX_CMD_RESP_ULB_RCV_RESERVE_IDX_ASSIGN_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBM_UMQ_INDEX_FLAG_NUMERIC, "Set if index is numeric", HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_appset_idx, + { "AppSet Index", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_index_len, + { "Index Length", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.index_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_reserved, + { "Reserved", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_numeric_index, + { "Index", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.numeric_index", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_string_index, + { "Index", "lbmc.umq_idx_cmd_resp.ulb_reserve_assign.string_index", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_odomain, + { "Originating Domain", "lbmc.odomain", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_odomain_next_hdr, + { "Next Header", "lbmc.odomain.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_odomain_hdr_len, + { "Header Length", "lbmc.odomain.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_odomain_flags, + { "Flags", "lbmc.odomain.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_odomain_flags_ignore, + { "Ignore", "lbmc.odomain.flags.ignore", FT_BOOLEAN, L_LBMC_ODOMAIN_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_odomain_domain, + { "Domain ID", "lbmc.odomain.domain", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_stream, + { "Stream", "lbmc.stream", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_stream_next_hdr, + { "Next Header", "lbmc.stream.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_stream_hdr_len, + { "Header Length", "lbmc.stream.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_stream_flags, + { "Flags", "lbmc.stream.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_stream_flags_ignore, + { "Ignore", "lbmc.stream.flags.ignore", FT_BOOLEAN, L_LBMC_STREAM_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_stream_stream_id, + { "Stream ID", "lbmc.stream.stream_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_stream_sqn, + { "Sequence Number", "lbmc.stream.sqn", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_stream_ctxinst, + { "Context Instance", "lbmc.stream.ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_md_interest, + { "Topic Multi-Domain Interest", "lbmc.topic_md_interest", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_md_interest_next_hdr, + { "Next Header", "lbmc.topic_md_interest.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_md_interest_hdr_len, + { "Header Length", "lbmc.topic_md_interest.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_md_interest_flags, + { "Flags", "lbmc.topic_md_interest.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_md_interest_flags_ignore, + { "Ignore", "lbmc.topic_md_interest.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_topic_md_interest_flags_cancel, + { "Cancel", "lbmc.topic_md_interest.flags.cancel", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_TOPIC_INTEREST_CANCEL_FLAG, "Set if cancelling interest", HFILL } }, + { &hf_lbmc_topic_md_interest_flags_refresh, + { "Refresh", "lbmc.topic_md_interest.flags.refresh", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_MD_INTEREST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_TOPIC_INTEREST_REFRESH_FLAG, "Set if refreshing interest", HFILL } }, + { &hf_lbmc_topic_md_interest_domain_count, + { "Domain Count", "lbmc.topic_md_interest.domain_count", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_md_interest_res1, + { "Reserved", "lbmc.topic_md_interest.res1", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_md_interest_domain_id, + { "Domain ID", "lbmc.topic_md_interest.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest, + { "Pattern Multi-Domain Interest", "lbmc.pattern_md_interest", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_next_hdr, + { "Next Header", "lbmc.pattern_md_interest.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_hdr_len, + { "Header Length", "lbmc.pattern_md_interest.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_flags, + { "Flags", "lbmc.pattern_md_interest.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_flags_ignore, + { "Ignore", "lbmc.pattern_md_interest.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_flags_cancel, + { "Cancel", "lbmc.pattern_md_interest.flags.cancel", FT_BOOLEAN, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_PATTERN_INTEREST_CANCEL_FLAG, "Set if cancelling interest", HFILL } }, + { &hf_lbmc_pattern_md_interest_flags_refresh, + { "Refresh", "lbmc.pattern_md_interest.flags.refresh", FT_BOOLEAN, L_LBMC_CNTL_PATTERN_MD_INTEREST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_PATTERN_INTEREST_REFRESH_FLAG, "Set if refreshing interest", HFILL } }, + { &hf_lbmc_pattern_md_interest_type, + { "Type", "lbmc.pattern_md_interest.type", FT_UINT8, BASE_DEC_HEX, VALS(lbm_wildcard_pattern_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_domain_count, + { "Domain Count", "lbmc.pattern_md_interest.domain_count", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_res1, + { "Reserved", "lbmc.pattern_md_interest.res1", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_index, + { "Index", "lbmc.pattern_md_interest.index", FT_INT64, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_pattern_md_interest_domain_id, + { "Domain ID", "lbmc.pattern_md_interest.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req, + { "Late Join Information Request", "lbmc.lji_req", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_next_hdr, + { "Next Header", "lbmc.lji_req.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_hdr_len, + { "Header Length", "lbmc.lji_req.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_flags, + { "Flags", "lbmc.lji_req.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_flags_ignore, + { "Ignore", "lbmc.lji_req.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_lji_req_flags_l_flag, + { "Low SQN Present", "lbmc.lji_req.flags.l_flag", FT_BOOLEAN, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_LJI_REQ_L_FLAG, "Set if low SQN present", HFILL } }, + { &hf_lbmc_lji_req_flags_m_flag, + { "RX Request Max Present", "lbmc.lji_req.flags.m_flag", FT_BOOLEAN, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_LJI_REQ_M_FLAG, "Set if RX request max present", HFILL } }, + { &hf_lbmc_lji_req_flags_o_flag, + { "RX Request Outstanding Max Present", "lbmc.lji_req.flags.o_flag", FT_BOOLEAN, L_LBMC_CNTL_LJI_REQ_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_LJI_REQ_O_FLAG, "Set if outstanding RX request max present", HFILL } }, + { &hf_lbmc_lji_req_request_idx, + { "Request Index", "lbmc.lji_req.request_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_transport_idx, + { "Transport Index", "lbmc.lji_req.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_topic_idx, + { "Topic Index", "lbmc.lji_req.topic_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_req_ip, + { "Request IP", "lbmc.lji_req.req_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_req_port, + { "Request Port", "lbmc.lji_req.req_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_res, + { "Reserved", "lbmc.lji_req.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_tx_low_sqn, + { "Transmitted Low SQN", "lbmc.lji_req.tx_low_sqn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_rx_req_max, + { "Maximum RX Requests", "lbmc.lji_req.rx_req_max", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_lji_req_rx_req_outstanding_max, + { "Maximum Outstanding RX Requests", "lbmc.lji_req.rx_req_outstanding_max", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka, + { "TNWG Keepalive", "lbmc.tnwg_ka", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_next_hdr, + { "Next Header", "lbmc.tnwg_ka.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_hdr_len, + { "Header Length", "lbmc.tnwg_ka.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_flags, + { "Flags", "lbmc.tnwg_ka.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_flags_ignore, + { "Ignore", "lbmc.tnwg_ka.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_flags_q_flag, + { "Query", "lbmc.tnwg_ka.flags.q_flag", FT_BOOLEAN, L_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CNTL_TNWG_KA_Q_FLAG, "Set if a keepalive query", HFILL } }, + { &hf_lbmc_tnwg_ka_flags_r_flag, + { "Response", "lbmc.tnwg_ka.flags.r_flag", FT_BOOLEAN, L_LBMC_CNTL_TNWG_KA_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_CNTL_TNWG_KA_R_FLAG, "Set if a keepalive response", HFILL } }, + { &hf_lbmc_tnwg_ka_index, + { "Index", "lbmc.tnwg_ka.index", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_ts_seconds, + { "TS Seconds", "lbmc.tnwg_ka.ts_seconds", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_ts_microseconds, + { "TS Microseconds", "lbmc.tnwg_ka.ts_microseconds", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_reserved_1, + { "Reserved 1", "lbmc.tnwg_ka.reserved_1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_reserved_2, + { "Reserved 2", "lbmc.tnwg_ka.reserved_2", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_reserved_3, + { "Reserved 3", "lbmc.tnwg_ka.reserved_3", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_reserved_4, + { "Reserved 4", "lbmc.tnwg_ka.reserved_4", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_reserved_5, + { "Reserved 5", "lbmc.tnwg_ka.reserved_5", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tnwg_ka_reserved_6, + { "Reserved 6", "lbmc.tnwg_ka.reserved_6", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_receiver_keepalive, + { "UME Receiver Keepalive", "lbmc.ume_receiver_keepalive", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_receiver_keepalive_next_hdr, + { "Next Header", "lbmc.ume_receiver_keepalive.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_receiver_keepalive_hdr_len, + { "Header Length", "lbmc.ume_receiver_keepalive.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_receiver_keepalive_flags, + { "Flags", "lbmc.ume_receiver_keepalive.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_receiver_keepalive_flags_ignore, + { "Ignore", "lbmc.ume_receiver_keepalive.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_RECEIVER_KEEPALIVE_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_receiver_keepalive_rcv_regid, + { "Receiver RegID", "lbmc.ume_receiver_keepalive.rcv_regid", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_receiver_keepalive_session_id, + { "Session ID", "lbmc.ume_receiver_keepalive.session_id", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_receiver_keepalive_ctxinst, + { "Context Instance", "lbmc.ume_receiver_keepalive.ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd, + { "UMQ Command", "lbmc.umq_cmd", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_next_hdr, + { "Next Header", "lbmc.umq_cmd.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_hdr_len, + { "Header Length", "lbmc.umq_cmd.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_flags, + { "Flags", "lbmc.umq_cmd.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_flags_ignore, + { "Ignore", "lbmc.umq_cmd.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_CMD_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_cmd_type, + { "Command", "lbmc.umq_cmd.cmd_type", FT_UINT8, BASE_DEC, VALS(lbmc_umq_cmd_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_queue_id, + { "Queue ID", "lbmc.umq_cmd.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_cmd_id, + { "Command ID", "lbmc.umq_cmd.cmd_id", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_inst_idx, + { "Instance index", "lbmc.umq_cmd.inst_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_regid, + { "Reg ID", "lbmc.umq_cmd.regid", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_topic_list, + { "Topic List", "lbmc.umq_cmd.topic_list", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_topic_list_serial_num, + { "Serial number", "lbmc.umq_cmd.topic_list.serial_num", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve, + { "Message Retrieve", "lbmc.umq_cmd.msg_retrieve", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve_rcr_idx, + { "RCR Index", "lbmc.umq_cmd.msg_retrieve.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve_assign_id, + { "Assignment ID", "lbmc.umq_cmd.msg_retrieve.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve_info_only, + { "Info Only", "lbmc.umq_cmd.msg_retrieve.info_only", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve_num_msgids, + { "Number of Message IDs", "lbmc.umq_cmd.msg_retrieve.num_msgids", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve_flags, + { "Flags", "lbmc.umq_cmd.msg_retrieve.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve_entry, + { "Message Retrieve Entry", "lbmc.umq_cmd.msg_retrieve.entry", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve_entry_regid, + { "Reg ID", "lbmc.umq_cmd.msg_retrieve.entry.regid", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_retrieve_entry_stamp, + { "Stamp", "lbmc.umq_cmd.msg_retrieve.entry.stamp", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_list, + { "Message List", "lbmc.umq_cmd.msg_list", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_list_rcr_idx, + { "RCR Index", "lbmc.umq_cmd.msg_list.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_msg_list_assign_id, + { "Assign ID", "lbmc.umq_cmd.msg_list.assign_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp, + { "UMQ Command Response", "lbmc.umq_cmd_resp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_next_hdr, + { "Next Header", "lbmc.umq_cmd_resp.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_hdr_len, + { "Header Length", "lbmc.umq_cmd_resp.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_flags, + { "Flags", "lbmc.umq_cmd_resp.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_flags_ignore, + { "Ignore", "lbmc.umq_cmd_resp.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_CMD_RESP_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_resp_type, + { "Response", "lbmc.umq_cmd_resp.resp_type", FT_UINT8, BASE_DEC, VALS(lbmc_umq_cmd_response_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_queue_id, + { "Queue ID", "lbmc.umq_cmd_resp.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_cmd_id, + { "Command ID", "lbmc.umq_cmd_resp.cmd_id", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_inst_idx, + { "Instance index", "lbmc.umq_cmd_resp.inst_idx", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_regid, + { "Reg ID", "lbmc.umq_cmd_resp.regid", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_msg_retrieve, + { "Message Retrieve", "lbmc.umq_cmd_resp.msg_retrieve", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_msg_retrieve_rcr_idx, + { "RCR Index", "lbmc.umq_cmd_resp.msg_retrieve.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_msg_retrieve_assign_id, + { "Assignment ID", "lbmc.umq_cmd_resp.msg_retrieve.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve, + { "Message Retrieve", "lbmc.umq_cmd_resp.xmsg_retrieve", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_num_msgs, + { "Number of Messages", "lbmc.umq_cmd_resp.xmsg_retrieve.num_msgs", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_flags, + { "Flags", "lbmc.umq_cmd_resp.xmsg_retrieve.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_reserved, + { "Reserved", "lbmc.umq_cmd_resp.xmsg_retrieve.reserved", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry, + { "Message", "lbmc.umq_cmd_resp.xmsg_retrieve.entry", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_regid, + { "Reg ID", "lbmc.umq_cmd_resp.xmsg_retrieve.entry.regid", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_stamp, + { "Stamp", "lbmc.umq_cmd_resp.xmsg_retrieve.entry.stamp", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_assign_id, + { "Assignment ID", "lbmc.umq_cmd_resp.xmsg_retrieve.entry.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_num_ras, + { "Number of Reassignments", "lbmc.umq_cmd_resp.xmsg_retrieve.entry.num_ras", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_status, + { "Status", "lbmc.umq_cmd_resp.xmsg_retrieve.entry.status", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_umq_msg_status_code), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_retrieve_entry_reserved, + { "Reserved", "lbmc.umq_cmd_resp.xmsg_retrieve.entry.reserved", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_msg_list, + { "Message List", "lbmc.umq_cmd_resp.msg_list", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_msg_list_rcr_idx, + { "RCR Index", "lbmc.umq_cmd_resp.msg_list.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_msg_list_assign_id, + { "Assignment ID", "lbmc.umq_cmd_resp.msg_list.assign_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_list, + { "Message List", "lbmc.umq_cmd_resp.xmsg_list", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_list_num_msgs, + { "Number of Messages", "lbmc.umq_cmd_resp.xmsg_list.num_msgs", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_list_entry, + { "Message", "lbmc.umq_cmd_resp.xmsg_list.entry", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_list_entry_regid, + { "Reg ID", "lbmc.umq_cmd_resp.xmsg_list.entry.regid", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_xmsg_list_entry_stamp, + { "Stamp", "lbmc.umq_cmd_resp.xmsg_list.entry.stamp", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list, + { "Topic List", "lbmc.umq_cmd_resp.topic_list", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_num_topics, + { "Number of Topics", "lbmc.umq_cmd_resp.topic_list.num_topics", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry, + { "Topic List Entry", "lbmc.umq_cmd_resp.topic_list.topic_entry", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_rcr_idx, + { "RCR Index", "lbmc.umq_cmd_resp.topic_list.topic_entry.rcr_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_num_appsets, + { "Number of AppSets", "lbmc.umq_cmd_resp.topic_list.topic_entry.num_appsets", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_topic_len, + { "Topic Length", "lbmc.umq_cmd_resp.topic_list.topic_entry.topic_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_reserved, + { "Reserved", "lbmc.umq_cmd_resp.topic_list.topic_entry.reserved", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_topic, + { "Topic", "lbmc.umq_cmd_resp.topic_list.topic_entry.topic", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry, + { "Appset Entry", "lbmc.umq_cmd_resp.topic_list.topic_entry.appset_entry", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_num_receiver_type_ids, + { "Number of Receiver Type IDs", "lbmc.umq_cmd_resp.topic_list.topic_entry.appset_entry.num_receiver_type_ids", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_appset_idx, + { "AppSet Index", "lbmc.umq_cmd_resp.topic_list.topic_entry.appset_entry.appset_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_appset_name_len, + { "AppSet Name Length", "lbmc.umq_cmd_resp.topic_list.topic_entry.appset_entry.appset_name_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_reserved, + { "Reserved", "lbmc.umq_cmd_resp.topic_list.topic_entry.appset_entry.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_name, + { "AppSet Name", "lbmc.umq_cmd_resp.topic_list.topic_entry.appset_entry.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry_receiver_type_id, + { "Receiver Type ID", "lbmc.umq_cmd_resp.topic_list.topic_entry.appset_entry.receiver_type_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_err, + { "Error", "lbmc.umq_cmd_resp.error", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_err_reserved, + { "Reserved", "lbmc.umq_cmd_resp.error.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_err_code, + { "Code", "lbmc.umq_cmd_resp.error.code", FT_UINT16, BASE_DEC_HEX, VALS(lbmc_umq_cmd_response_error_code), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_cmd_resp_err_errmsg, + { "Error Message", "lbmc.umq_cmd_resp.error.errmsg", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_req, + { "Source Registration Information Request", "lbmc.sri_req", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_req_next_hdr, + { "Next Header", "lbmc.sri_req.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_req_hdr_len, + { "Header Length", "lbmc.sri_req.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_req_flags, + { "Flags", "lbmc.sri_req.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_req_flags_ignore, + { "Ignore", "lbmc.sri_req.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_SRI_REQ_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_sri_req_transport_idx, + { "Transport Index", "lbmc.sri_req.transport_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_req_topic_idx, + { "Topic Index", "lbmc.sri_req.topic_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_domain, + { "UME Store Domain", "lbmc.ume_store_domain", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_domain_next_hdr, + { "Next Header", "lbmc.ume_store_domain.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_domain_hdr_len, + { "Header Length", "lbmc.ume_store_domain.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_domain_flags, + { "Flags", "lbmc.ume_store_domain.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_domain_flags_ignore, + { "Ignore", "lbmc.ume_store_domain.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_STORE_DOMAIN_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_store_domain_domain, + { "Domain ID", "lbmc.ume_store_domain.domain", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri, + { "Source Registration Information", "lbmc.sri", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_next_hdr, + { "Next Header", "lbmc.sri.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_hdr_len, + { "Header Length", "lbmc.sri.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_flags, + { "Flags", "lbmc.sri.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_flags_ignore, + { "Ignore", "lbmc.sri.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_SRI_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_sri_flags_acktosrc, + { "ACK to Source", "lbmc.sri.flags.acktosrc", FT_BOOLEAN, L_LBMC_CNTL_SRI_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_SRI_A_FLAG, "If set ACKs are sent to source", HFILL } }, + { &hf_lbmc_sri_flags_initial_sqn_known, + { "Initial SQN Known", "lbmc.sri.flags.initial_sqn_known", FT_BOOLEAN, L_LBMC_CNTL_SRI_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_SRI_INITIAL_SQN_KNOWN_FLAG, "If set, initial SQN is known", HFILL } }, + { &hf_lbmc_sri_version, + { "Version", "lbmc.sri.version", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_low_sqn, + { "Low Sequence Number", "lbmc.sri.low_sqn", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_sri_high_sqn, + { "High Sequence Number", "lbmc.sri.high_sqn", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info, + { "Route Information", "lbmc.route_info", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_next_hdr, + { "Next Header", "lbmc.route_info.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_hdr_len, + { "Header Length", "lbmc.route_info.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_flags, + { "Flags", "lbmc.route_info.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_flags_ignore, + { "Ignore", "lbmc.route_info.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_ROUTE_INFO_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_route_info_gateway_version, + { "Gateway Version", "lbmc.route_info.gateway_version", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_configuration_signature, + { "Configuration Signature", "lbmc.route_info.configuration_signature", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_node_id, + { "Node ID", "lbmc.route_info.node_id", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_topology, + { "Topology", "lbmc.route_info.topology", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_vers, + { "Version", "lbmc.route_info.vers", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_sqn, + { "SQN", "lbmc.route_info.sqn", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_ttl, + { "TTL", "lbmc.route_info.ttl", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_reserved1, + { "Reserved1", "lbmc.route_info.reserved1", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_reserved2, + { "Reserved2", "lbmc.route_info.reserved2", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_neighbor, + { "Route Information Neighbor", "lbmc.route_info_neighbor", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_neighbor_next_hdr, + { "Next Header", "lbmc.route_info_neighbor.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_neighbor_hdr_len, + { "Header Length", "lbmc.route_info_neighbor.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_neighbor_flags, + { "Flags", "lbmc.route_info_neighbor.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_neighbor_flags_ignore, + { "Ignore", "lbmc.route_info_neighbor.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_ROUTE_INFO_NEIGHBOR_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_route_info_neighbor_node_id, + { "Node ID", "lbmc.route_info_neighbor.node_id", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_neighbor_ingress_cost, + { "Ingress Cost", "lbmc.route_info_neighbor.ingress_cost", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_route_info_neighbor_egress_cost, + { "Egress Cost", "lbmc.route_info_neighbor.egress_cost", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_gateway_name, + { "Gateway Name", "lbmc.gateway_name", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_gateway_name_next_hdr, + { "Next Header", "lbmc.gateway_name.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_gateway_name_hdr_len, + { "Header Length", "lbmc.gateway_name.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_gateway_name_flags, + { "Flags", "lbmc.gateway_name.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_gateway_name_flags_ignore, + { "Ignore", "lbmc.gateway_name.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_GATEWAY_NAME_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_gateway_name_gateway_name, + { "Gateway Name", "lbmc.gateway_name.gateway_name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_request, + { "Authentication Request", "lbmc.auth_request", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_request_next_hdr, + { "Next Header", "lbmc.auth_request.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_request_hdr_len, + { "Header Length", "lbmc.auth_request.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_request_flags, + { "Flags", "lbmc.auth_request.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_request_flags_ignore, + { "Ignore", "lbmc.auth_request.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_AUTH_REQUEST_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_auth_request_opid, + { "Operation ID", "lbmc.auth_request.opid", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_auth_operation_id_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_request_user_len, + { "User Length", "lbmc.auth_request.user_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_request_user_name, + { "User Name", "lbmc.auth_request.user_name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge, + { "Authentication Challenge", "lbmc.auth_challenge", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_next_hdr, + { "Next Header", "lbmc.auth_challenge.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_hdr_len, + { "Header Length", "lbmc.auth_challenge.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_flags, + { "Flags", "lbmc.auth_challenge.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_flags_ignore, + { "Ignore", "lbmc.auth_challenge.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_AUTH_CHALLENGE_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_opid, + { "Operation ID", "lbmc.auth_challenge.opid", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_auth_operation_id_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_mod_len, + { "Mod Length", "lbmc.auth_challenge.mod_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_gen_len, + { "Gen Length", "lbmc.auth_challenge.gen_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_salt_len, + { "Salt Length", "lbmc.auth_challenge.salt_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_pubkey_len, + { "Pubkey Length", "lbmc.auth_challenge.pubkey_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_mod, + { "Mod", "lbmc.auth_challenge.mod", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_gen, + { "Gen", "lbmc.auth_challenge.gen", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_salt, + { "Salt", "lbmc.auth_challenge.salt", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_pubkey, + { "Pubkey", "lbmc.auth_challenge.pubkey", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp, + { "Authentication Challenge Response", "lbmc.auth_challenge_rsp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_next_hdr, + { "Next Header", "lbmc.auth_challenge_rsp.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_hdr_len, + { "Header Length", "lbmc.auth_challenge_rsp.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_flags, + { "Flags", "lbmc.auth_challenge_rsp.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_flags_ignore, + { "Ignore", "lbmc.auth_challenge_rsp.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_AUTH_CHALLENGE_RSP_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_opid, + { "Operation ID", "lbmc.auth_challenge_rsp.opid", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_auth_operation_id_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_pubkey_len, + { "Pubkey Length", "lbmc.auth_challenge_rsp.pubkey_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_evidence_len, + { "Evidence Length", "lbmc.auth_challenge_rsp.evidence_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_pubkey, + { "Pubkey", "lbmc.auth_challenge_rsp.pubkey", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_challenge_rsp_evidence, + { "Evidence", "lbmc.auth_challenge_rsp.evidence", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_result, + { "Authentication Result", "lbmc.auth_result", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_result_next_hdr, + { "Next Header", "lbmc.auth_result.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_result_hdr_len, + { "Header Length", "lbmc.auth_result.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_result_flags, + { "Flags", "lbmc.auth_result.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_result_flags_ignore, + { "Ignore", "lbmc.auth_result.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_AUTH_RESULT_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_auth_result_opid, + { "Operation ID", "lbmc.auth_result.opid", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_auth_operation_id_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_result_result, + { "Result", "lbmc.auth_result.result", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_unknown, + { "Unknown Authentication Header", "lbmc.auth_unknown", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_unknown_next_hdr, + { "Next Header", "lbmc.auth_unknown.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_unknown_hdr_len, + { "Header Length", "lbmc.auth_unknown.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_unknown_flags, + { "Flags", "lbmc.auth_unknown.flags", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_unknown_opid, + { "Operation ID", "lbmc.auth_unknown.opid", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_auth_operation_id_type), 0x0, NULL, HFILL } }, + { &hf_lbmc_auth_unknown_data, + { "Data", "lbmc.auth_unknown.data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_hmac, + { "HMAC", "lbmc.hmac", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_hmac_next_hdr, + { "Next Header", "lbmc.hmac.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_hmac_hdr_len, + { "Header Length", "lbmc.hmac.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_hmac_flags, + { "Flags", "lbmc.hmac.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_hmac_flags_ignore, + { "Ignore", "lbmc.hmac.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_HMAC_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_hmac_padding, + { "Padding", "lbmc.hmac.padding", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_hmac_data, + { "Data", "lbmc.hmac.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sid, + { "UMQ Session ID", "lbmc.umq_sid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sid_next_hdr, + { "Next Header", "lbmc.umq_sid.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sid_hdr_len, + { "Header Length", "lbmc.umq_sid.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sid_flags, + { "Flags", "lbmc.umq_sid.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sid_flags_ignore, + { "Ignore", "lbmc.umq_sid.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UMQ_SID_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE_CHAR, NULL, HFILL } }, + { &hf_lbmc_umq_sid_key, + { "Key", "lbmc.umq_sid.key", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_umq_sid_sid, + { "SID", "lbmc.umq_sid.sid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination, + { "Destination", "lbmc.destination", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_next_hdr, + { "Next Header", "lbmc.destination.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_hdr_len, + { "Header Length", "lbmc.destination.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_flags, + { "Flags", "lbmc.destination.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_flags_ignore, + { "Ignore", "lbmc.destination.flags.ignore", FT_BOOLEAN, L_LBMC_DESTINATION_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_destination_domain_id, + { "Domain ID", "lbmc.destination.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_ipaddr, + { "IP Address", "lbmc.destination.ipaddr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_port, + { "Port", "lbmc.destination.port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_hops_taken, + { "Hops Taken", "lbmc.destination.hops_taken", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_orig_domain_id, + { "Originating Domain ID", "lbmc.destination.orig_domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_orig_ipaddr, + { "Originating IP Address", "lbmc.destination.orig_ipaddr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_orig_port, + { "Originating Port", "lbmc.destination.orig_port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_destination_reserved, + { "Reserved", "lbmc.destination.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_idx, + { "Topic Index", "lbmc.topic_idx", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_idx_next_hdr, + { "Next Header", "lbmc.topic_idx.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_idx_hdr_len, + { "Header Length", "lbmc.topic_idx.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_idx_flags, + { "Flags", "lbmc.topic_idx.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_idx_flags_ignore, + { "Ignore", "lbmc.topic_idx.flags.ignore", FT_BOOLEAN, L_LBMC_TOPIC_IDX_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_topic_idx_tidx, + { "Topic Index", "lbmc.topic_idx.tidx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source, + { "Topic Source", "lbmc.topic_source", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_next_hdr, + { "Next Header", "lbmc.topic_source.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_hdr_len, + { "Header Length", "lbmc.topic_source.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_flags, + { "Flags", "lbmc.topic_source.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_flags_ignore, + { "Ignore", "lbmc.topic_source.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_topic_source_flags_eos, + { "End of Stream", "lbmc.topic_source.flags.eos", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_SOURCE_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_TOPIC_SOURCE_EOS_FLAG, NULL, HFILL } }, + { &hf_lbmc_topic_source_domain_id, + { "Domain ID", "lbmc.topic_source.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc, + { "Topic Source Extended Functionality", "lbmc.topic_source_exfunc", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_next_hdr, + { "Next Header", "lbmc.topic_source_exfunc.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_hdr_len, + { "Header Length", "lbmc.topic_source_exfunc.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_flags, + { "Flags", "lbmc.topic_source_exfunc.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_flags_ignore, + { "Ignore", "lbmc.topic_source_exfunc.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_src_ip, + { "Source Address", "lbmc.topic_source_exfunc.src_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_src_port, + { "Source Port", "lbmc.topic_source_exfunc.src_port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_unused, + { "Unused", "lbmc.topic_source_exfunc.unused", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_functionality_flags, + { "Functionality Flags", "lbmc.topic_source_exfunc.functionality_flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_functionality_flags_ulb, + { "ULB", "lbmc.topic_source_exfunc.functionality_flags.ulb", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS * 8, TFS(&tfs_capable_not_capable), LBM_TOPIC_OPT_EXFUNC_FFLAG_ULB, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_functionality_flags_umq, + { "UMQ", "lbmc.topic_source_exfunc.functionality_flags.umq", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS * 8, TFS(&tfs_capable_not_capable), LBM_TOPIC_OPT_EXFUNC_FFLAG_UMQ, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_functionality_flags_ume, + { "UME", "lbmc.topic_source_exfunc.functionality_flags.ume", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS * 8, TFS(&tfs_capable_not_capable), LBM_TOPIC_OPT_EXFUNC_FFLAG_UME, NULL, HFILL } }, + { &hf_lbmc_topic_source_exfunc_functionality_flags_lj, + { "Late Join", "lbmc.topic_source_exfunc.functionality_flags.lj", FT_BOOLEAN, L_LBMC_CNTL_TOPIC_SOURCE_EXFUNC_HDR_T_FUNCTIONALITY_FLAGS * 8, TFS(&tfs_capable_not_capable), LBM_TOPIC_OPT_EXFUNC_FFLAG_LJ, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext, + { "UME Store Extended", "lbmc.ume_store_ext", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_next_hdr, + { "Next Header", "lbmc.ume_store_ext.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_hdr_len, + { "Header Length", "lbmc.ume_store_ext.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_flags, + { "Flags", "lbmc.ume_store_ext.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_flags_ignore, + { "Ignore", "lbmc.ume_store_ext.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_STORE_EXT_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_grp_idx, + { "Group Index", "lbmc.ume_store_ext.grp_idx", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_store_tcp_port, + { "Store TCP Port", "lbmc.ume_store_ext.store_tcp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_store_idx, + { "Store Index", "lbmc.ume_store_ext.store_idx", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_store_ip_addr, + { "Store IP Address", "lbmc.ume_store_ext.store_ip_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_src_reg_id, + { "Source RegID", "lbmc.ume_store_ext.src_reg_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_domain_id, + { "Domain ID", "lbmc.ume_store_ext.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_store_ext_version, + { "Version", "lbmc.ume_store_ext.version", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_psrc_election_token, + { "UME Proxy Source Election Token", "lbmc.ume_psrc_election_token", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_psrc_election_token_next_hdr, + { "Next Header", "lbmc.ume_psrc_election_token.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_psrc_election_token_hdr_len, + { "Header Length", "lbmc.ume_psrc_election_token.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_psrc_election_token_flags, + { "Flags", "lbmc.ume_psrc_election_token.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_psrc_election_token_flags_ignore, + { "Ignore", "lbmc.ume_psrc_election_token.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_UME_PSRC_ELECTION_TOKEN_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_ume_psrc_election_token_store_index, + { "Store Index", "lbmc.ume_psrc_election_token.store_index", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_ume_psrc_election_token_token, + { "Token", "lbmc.ume_psrc_election_token.token", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_sid, + { "TCP Session ID", "lbmc.tcp_sid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_sid_next_hdr, + { "Next Header", "lbmc.tcp_sid.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_sid_hdr_len, + { "Header Length", "lbmc.tcp_sid.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_sid_flags, + { "Flags", "lbmc.tcp_sid.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_tcp_sid_flags_ignore, + { "Ignore", "lbmc.tcp_sid.flags.ignore", FT_BOOLEAN, L_LBMC_CNTL_TCP_SID_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbmc_tcp_sid_sid, + { "Session ID", "lbmc.tcp_sid.sid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt, + { "Extended Option", "lbmc.extopt", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_next_hdr, + { "Next Header", "lbmc.extopt.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_hdr_len, + { "Header Length", "lbmc.extopt.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_flags, + { "Flags", "lbmc.extopt.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_flags_ignore, + { "Ignore", "lbmc.extopt.flags.ignore", FT_BOOLEAN, L_LBMC_EXTOPT_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_EXTOPT_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmc_extopt_flags_ignore_subtype, + { "Ignore Subtype", "lbmc.extopt.flags.ignore_subtype", FT_BOOLEAN, L_LBMC_EXTOPT_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMC_EXTOPT_FLAG_IGNORE_SUBTYPE, NULL, HFILL } }, + { &hf_lbmc_extopt_flags_more_fragments, + { "More Fragments", "lbmc.extopt.flags.more_fragments", FT_BOOLEAN, L_LBMC_EXTOPT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMC_EXTOPT_FLAG_MORE_FRAGMENT, "Set if there are more fragments", HFILL } }, + { &hf_lbmc_extopt_id, + { "ID", "lbmc.extopt.id", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_subtype, + { "Subtype", "lbmc.extopt.subtype", FT_UINT16, BASE_DEC_HEX, VALS(lbmc_extopt_subtype), 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_fragment_offset, + { "Fragment offset", "lbmc.extopt.fragment_offset", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_data, + { "Data", "lbmc.extopt.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_cfgopt, + { "Configuration Option", "lbmc.extopt.cfgopt", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_cfgopt_scope, + { "Scope", "lbmc.extopt.cfgopt.scope", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_extopt_config_option_scope), 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_cfgopt_parent, + { "Parent", "lbmc.extopt.cfgopt.parent", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_cfgopt_name, + { "Name", "lbmc.extopt.cfgopt.name", FT_STRING, FT_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_cfgopt_value, + { "Value", "lbmc.extopt.cfgopt.value", FT_STRING, FT_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_msgsel, + { "Message Selector", "lbmc.extopt.msgsel", FT_STRING, FT_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_reassembled_data, + { "EXTOPT Reassembled Data", "lbmc.extopt.reassembled_data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_reassembled_data_subtype, + { "Subtype", "lbmc.extopt.reassembled_data.subtype", FT_UINT16, BASE_DEC_HEX, VALS(lbmc_extopt_subtype), 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_reassembled_data_len, + { "Length", "lbmc.extopt.reassembled_data.length", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_reassembled_data_data, + { "Data", "lbmc.extopt.reassembled_data.data", FT_BYTES, FT_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_extopt_reassembled_data_msgsel, + { "Message Selector", "lbmc.extopt.reassembled_data.msgsel", FT_STRING, FT_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties, + { "Message Properties", "lbmc.lbm_msg_properties", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_data, + { "Message Properties Data", "lbmc.lbm_msg_properties.data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_data_magic, + { "Magic", "lbmc.lbm_msg_properties.data.magic", FT_UINT32, BASE_HEX, VALS(lbm_msg_prop_magic_type), 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_data_num_fields, + { "Number of Fields", "lbmc.lbm_msg_properties.data.num_fields", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_data_vertype, + { "Version/Type", "lbmc.lbm_msg_properties.data.vertype", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_data_vertype_version, + { "Version", "lbmc.lbm_msg_properties.data.vertype.version", FT_UINT8, BASE_DEC, NULL, LBM_MSG_PROPERTIES_HDR_VER_MASK, NULL, HFILL } }, + { &hf_lbm_msg_properties_data_vertype_type, + { "Type", "lbmc.lbm_msg_properties.data.vertype.type", FT_UINT8, BASE_DEC_HEX, VALS(lbm_msg_prop_header_type), LBM_MSG_PROPERTIES_HDR_VER_MASK, NULL, HFILL } }, + { &hf_lbm_msg_properties_data_res, + { "Reserved", "lbmc.lbm_msg_properties.data.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr, + { "Message Properties", "lbmc.lbm_msg_properties.hdr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_key_offset, + { "Key offset", "lbmc.lbm_msg_properties.hdr.key_offset", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_value_offset, + { "Value offset", "lbmc.lbm_msg_properties.hdr.value_offset", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_hash, + { "Hash", "lbmc.lbm_msg_properties.hdr.hash", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_type, + { "Type", "lbmc.lbm_msg_properties.hdr.type", FT_UINT32, BASE_DEC_HEX, VALS(lbm_msg_prop_field_type), 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_key, + { "Key", "lbmc.lbm_msg_properties.hdr.key", FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_boolean_value, + { "Boolean Value", "lbmc.lbm_msg_properties.hdr.boolean_value", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_byte_value, + { "Byte Value", "lbmc.lbm_msg_properties.hdr.byte_value", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_short_value, + { "Short Value", "lbmc.lbm_msg_properties.hdr.short_value", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_int_value, + { "Int Value", "lbmc.lbm_msg_properties.hdr.int_value", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_float_value, + { "Float Value", "lbmc.lbm_msg_properties.hdr.float_value", FT_FLOAT, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_long_value, + { "Long Value", "lbmc.lbm_msg_properties.hdr.long_value", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_double_value, + { "Double Value", "lbmc.lbm_msg_properties.hdr.double_value", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_string_value, + { "String Value", "lbmc.lbm_msg_properties.hdr.string_value", FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_msg_properties_hdr_unknown_value, + { "Unknown Value", "lbmc.lbm_msg_properties.hdr.unknown_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_unhandled, + { "Unhandled", "lbmc.unhandled", FT_NONE, BASE_NONE, NULL, 0x0, "Unrecognized/unhandled header", HFILL } }, + { &hf_lbmc_unhandled_next_hdr, + { "Next Header", "lbmc.unhandled.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmc_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmc_unhandled_hdr_len, + { "Header Length", "lbmc.unhandled.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_unhandled_data, + { "Data", "lbmc.unhandled.data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_stream, + { "LBM Stream", "lbmc.lbm_stream", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_stream_stream_id, + { "Stream ID", "lbmc.lbm_stream.stream_id", FT_UINT64, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbm_stream_substream_id, + { "Substream ID", "lbmc.lbm_stream.substream_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_reassembly, + { "Reassembled Fragments", "lbmc.reassembly", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmc_reassembly_fragment, + { "Fragment", "lbmc.reassembly.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_reassembly_frame, + { "Reassembled message in frame", "lbmc.reassembly_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "Frame in which reassembled message appears", HFILL } }, + }; + + static gint * ett[] = + { + &ett_lbmc, + &ett_lbmc_ver_type, + &ett_lbmc_frag, + &ett_lbmc_frag_flags, + &ett_lbmc_batch, + &ett_lbmc_batch_flags, + &ett_lbmc_tcp_request, + &ett_lbmc_tcp_request_flags, + &ett_lbmc_topicname, + &ett_lbmc_topicname_flags, + &ett_lbmc_apphdr, + &ett_lbmc_apphdr_code, + &ett_lbmc_apphdr_chain, + &ett_lbmc_apphdr_chain_element, + &ett_lbmc_apphdr_chain_msgprop, + &ett_lbmc_umq_msgid, + &ett_lbmc_umq_msgid_flags, + &ett_lbmc_umq_sqd_rcv, + &ett_lbmc_umq_sqd_rcv_flags, + &ett_lbmc_umq_resub, + &ett_lbmc_umq_resub_flags, + &ett_lbmc_otid, + &ett_lbmc_otid_flags, + &ett_lbmc_ctxinst, + &ett_lbmc_ctxinst_flags, + &ett_lbmc_ctxinstd, + &ett_lbmc_ctxinstr, + &ett_lbmc_srcidx, + &ett_lbmc_srcidx_flags, + &ett_lbmc_umq_ulb_msg, + &ett_lbmc_umq_ulb_msg_flags, + &ett_lbmc_ssf_init, + &ett_lbmc_ssf_init_flags, + &ett_lbmc_ssf_creq, + &ett_lbmc_ssf_creq_flags, + &ett_lbmc_ume_preg, + &ett_lbmc_ume_preg_flags, + &ett_lbmc_ume_preg_marker, + &ett_lbmc_ume_preg_resp, + &ett_lbmc_ume_preg_resp_code, + &ett_lbmc_ume_preg_resp_marker, + &ett_lbmc_ume_ack, + &ett_lbmc_ume_ack_flags, + &ett_lbmc_ume_rxreq, + &ett_lbmc_ume_rxreq_flags, + &ett_lbmc_ume_keepalive, + &ett_lbmc_ume_keepalive_flags, + &ett_lbmc_ume_storeid, + &ett_lbmc_ume_storeid_store_id, + &ett_lbmc_ume_ranged_ack, + &ett_lbmc_ume_ranged_ack_flags, + &ett_lbmc_ume_ack_id, + &ett_lbmc_ume_ack_id_flags, + &ett_lbmc_ume_capability, + &ett_lbmc_ume_capability_flags, + &ett_lbmc_ume_proxy_src, + &ett_lbmc_ume_proxy_src_flags, + &ett_lbmc_ume_store_group, + &ett_lbmc_ume_store_group_flags, + &ett_lbmc_ume_store, + &ett_lbmc_ume_store_flags, + &ett_lbmc_ume_lj_info, + &ett_lbmc_ume_lj_info_flags, + &ett_lbmc_tsni, + &ett_lbmc_tsni_num_recs, + &ett_lbmc_tsni_rec, + &ett_lbmc_umq_reg, + &ett_lbmc_umq_reg_flags, + &ett_lbmc_umq_reg_reg_ctx, + &ett_lbmc_umq_reg_reg_src, + &ett_lbmc_umq_reg_reg_rcv, + &ett_lbmc_umq_reg_rcv_dereg, + &ett_lbmc_umq_reg_reg_ulb_rcv, + &ett_lbmc_umq_reg_ulb_rcv_dereg, + &ett_lbmc_umq_reg_reg_observer_rcv, + &ett_lbmc_umq_reg_observer_rcv_dereg, + &ett_lbmc_umq_reg_resp, + &ett_lbmc_umq_reg_resp_flags, + &ett_lbmc_umq_reg_resp_reg_ctx, + &ett_lbmc_umq_reg_resp_reg_ctx_ex, + &ett_lbmc_umq_reg_resp_reg_ctx_ex_flags, + &ett_lbmc_umq_reg_resp_err, + &ett_lbmc_umq_reg_resp_reg_src, + &ett_lbmc_umq_reg_resp_reg_rcv, + &ett_lbmc_umq_reg_resp_rcv_dereg, + &ett_lbmc_umq_reg_resp_reg_ulb_rcv, + &ett_lbmc_umq_reg_resp_ulb_rcv_dereg, + &ett_lbmc_umq_reg_resp_reg_observer_rcv, + &ett_lbmc_umq_reg_resp_observer_rcv_dereg, + &ett_lbmc_umq_ack, + &ett_lbmc_umq_ack_msgs, + &ett_lbmc_umq_ack_msgid, + &ett_lbmc_umq_ack_stable, + &ett_lbmc_umq_ack_cr, + &ett_lbmc_umq_ack_ulb_cr, + &ett_lbmc_umq_rcr, + &ett_lbmc_umq_rcr_flags, + &ett_lbmc_umq_ka, + &ett_lbmc_umq_ka_flags, + &ett_lbmc_umq_ka_src, + &ett_lbmc_umq_ka_rcv, + &ett_lbmc_umq_ka_ulb_rcv, + &ett_lbmc_umq_ka_ulb_rcv_resp, + &ett_lbmc_umq_rxreq, + &ett_lbmc_umq_rxreq_flags, + &ett_lbmc_umq_rxreq_regid_resp, + &ett_lbmc_umq_rxreq_addr_resp, + &ett_lbmc_umq_rxreq_mr, + &ett_lbmc_umq_rxreq_ulb_mr, + &ett_lbmc_umq_rxreq_ulb_mr_abort, + &ett_lbmc_umq_rxreq_qrcrr, + &ett_lbmc_umq_rxreq_trcrr, + &ett_lbmc_umq_rxreq_ulb_trcrr, + &ett_lbmc_umq_rxreq_ulb_trcrr_abort, + &ett_lbmc_umq_qmgmt, + &ett_lbmc_umq_resub_req, + &ett_lbmc_umq_resub_req_flags, + &ett_lbmc_umq_resub_resp, + &ett_lbmc_umq_resub_resp_flags, + &ett_lbmc_topic_interest, + &ett_lbmc_topic_interest_flags, + &ett_lbmc_pattern_interest, + &ett_lbmc_pattern_interest_flags, + &ett_lbmc_advertisement, + &ett_lbmc_advertisement_flags, + &ett_lbmc_advertisement_ad_flags, + &ett_lbmc_ume_storename, + &ett_lbmc_ume_storename_flags, + &ett_lbmc_umq_ulb_rcr, + &ett_lbmc_umq_ulb_rcr_flags, + &ett_lbmc_umq_lf, + &ett_lbmc_umq_lf_flags, + &ett_lbmc_ctxinfo, + &ett_lbmc_ctxinfo_flags, + &ett_lbmc_ume_pser, + &ett_lbmc_ume_pser_flags, + &ett_lbmc_domain, + &ett_lbmc_domain_flags, + &ett_lbmc_tnwg_capabilities, + &ett_lbmc_tnwg_capabilities_flags, + &ett_lbmc_tnwg_capabilities_capabilities1, + &ett_lbmc_tnwg_capabilities_capabilities3, + &ett_lbmc_patidx, + &ett_lbmc_patidx_flags, + &ett_lbmc_ume_client_lifetime, + &ett_lbmc_ume_client_lifetime_flags, + &ett_lbmc_ume_sid, + &ett_lbmc_ume_sid_flags, + &ett_lbmc_umq_idx_cmd, + &ett_lbmc_umq_idx_cmd_flags, + &ett_lbmc_umq_idx_cmd_stop_assign, + &ett_lbmc_umq_idx_cmd_start_assign, + &ett_lbmc_umq_idx_cmd_release_assign, + &ett_lbmc_umq_idx_cmd_release_assign_flags, + &ett_lbmc_umq_idx_cmd_ulb_stop_assign, + &ett_lbmc_umq_idx_cmd_ulb_start_assign, + &ett_lbmc_umq_idx_cmd_ulb_release_assign, + &ett_lbmc_umq_idx_cmd_ulb_release_assign_flags, + &ett_lbmc_umq_idx_cmd_reserve_assign, + &ett_lbmc_umq_idx_cmd_reserve_assign_flags, + &ett_lbmc_umq_idx_cmd_ulb_reserve_assign, + &ett_lbmc_umq_idx_cmd_ulb_reserve_assign_flags, + &ett_lbmc_umq_idx_cmd_resp, + &ett_lbmc_umq_idx_cmd_resp_flags, + &ett_lbmc_umq_idx_cmd_resp_err, + &ett_lbmc_umq_idx_cmd_resp_stop_assign, + &ett_lbmc_umq_idx_cmd_resp_start_assign, + &ett_lbmc_umq_idx_cmd_resp_release_assign, + &ett_lbmc_umq_idx_cmd_resp_ulb_stop_assign, + &ett_lbmc_umq_idx_cmd_resp_ulb_start_assign, + &ett_lbmc_umq_idx_cmd_resp_ulb_release_assign, + &ett_lbmc_umq_idx_cmd_resp_reserve_assign, + &ett_lbmc_umq_idx_cmd_resp_reserve_assign_flags, + &ett_lbmc_umq_idx_cmd_resp_ulb_reserve_assign, + &ett_lbmc_umq_idx_cmd_resp_ulb_reserve_assign_flags, + &ett_lbmc_odomain, + &ett_lbmc_odomain_flags, + &ett_lbmc_stream, + &ett_lbmc_stream_flags, + &ett_lbmc_topic_md_interest, + &ett_lbmc_topic_md_interest_flags, + &ett_lbmc_pattern_md_interest, + &ett_lbmc_pattern_md_interest_flags, + &ett_lbmc_lji_req, + &ett_lbmc_lji_req_flags, + &ett_lbmc_tnwg_ka, + &ett_lbmc_tnwg_ka_flags, + &ett_lbmc_ume_receiver_keepalive, + &ett_lbmc_ume_receiver_keepalive_flags, + &ett_lbmc_umq_cmd, + &ett_lbmc_umq_cmd_flags, + &ett_lbmc_umq_cmd_topic_list, + &ett_lbmc_umq_cmd_msg_retrieve, + &ett_lbmc_umq_cmd_msg_retrieve_entry, + &ett_lbmc_umq_cmd_msg_list, + &ett_lbmc_umq_cmd_resp, + &ett_lbmc_umq_cmd_resp_flags, + &ett_lbmc_umq_cmd_resp_msg_retrieve, + &ett_lbmc_umq_cmd_resp_xmsg_retrieve, + &ett_lbmc_umq_cmd_resp_xmsg_retrieve_entry, + &ett_lbmc_umq_cmd_resp_msg_list, + &ett_lbmc_umq_cmd_resp_xmsg_list, + &ett_lbmc_umq_cmd_resp_xmsg_list_entry, + &ett_lbmc_umq_cmd_resp_topic_list, + &ett_lbmc_umq_cmd_resp_topic_list_topic_entry, + &ett_lbmc_umq_cmd_resp_topic_list_topic_entry_appset_entry, + &ett_lbmc_umq_cmd_resp_err, + &ett_lbmc_sri_req, + &ett_lbmc_sri_req_flags, + &ett_lbmc_ume_store_domain, + &ett_lbmc_ume_store_domain_flags, + &ett_lbmc_sri, + &ett_lbmc_sri_flags, + &ett_lbmc_route_info, + &ett_lbmc_route_info_flags, + &ett_lbmc_route_info_neighbor, + &ett_lbmc_route_info_neighbor_flags, + &ett_lbmc_gateway_name, + &ett_lbmc_gateway_name_flags, + &ett_lbmc_auth_request, + &ett_lbmc_auth_request_flags, + &ett_lbmc_auth_challenge, + &ett_lbmc_auth_challenge_flags, + &ett_lbmc_auth_challenge_rsp, + &ett_lbmc_auth_challenge_rsp_flags, + &ett_lbmc_auth_result, + &ett_lbmc_auth_result_flags, + &ett_lbmc_auth_unknown, + &ett_lbmc_hmac, + &ett_lbmc_hmac_flags, + &ett_lbmc_umq_sid, + &ett_lbmc_umq_sid_flags, + &ett_lbmc_destination, + &ett_lbmc_destination_flags, + &ett_lbmc_topic_idx, + &ett_lbmc_topic_idx_flags, + &ett_lbmc_topic_source, + &ett_lbmc_topic_source_flags, + &ett_lbmc_topic_source_exfunc, + &ett_lbmc_topic_source_exfunc_flags, + &ett_lbmc_topic_source_exfunc_functionality_flags, + &ett_lbmc_ume_store_ext, + &ett_lbmc_ume_store_ext_flags, + &ett_lbmc_ume_psrc_election_token, + &ett_lbmc_ume_psrc_election_token_flags, + &ett_lbmc_tcp_sid, + &ett_lbmc_tcp_sid_flags, + &ett_lbmc_extopt, + &ett_lbmc_extopt_flags, + &ett_lbmc_extopt_cfgopt, + &ett_lbmc_extopt_reassembled_data, + &ett_lbmc_extopt_reassembled_data_cfgopt, + &ett_lbm_msg_properties, + &ett_lbm_msg_properties_data, + &ett_lbm_msg_properties_data_vertype, + &ett_lbm_msg_properties_hdr, + &ett_lbmc_unhandled_hdr, + &ett_lbm_stream, + &ett_lbmc_reassembly, + &ett_unknown, + &ett_msg_data, + &ett_msgprop_data + }; + static ei_register_info ei[] = + { + { &ei_lbmc_analysis_length_incorrect, { "lbmc.analysis.length_incorrect", PI_PROTOCOL, PI_ERROR, "Header length incorrect", EXPFILL } }, + { &ei_lbmc_analysis_zero_length, { "lbmc.analysis.zero_length", PI_MALFORMED, PI_ERROR, "Length dissected is zero", EXPFILL } }, + { &ei_lbmc_analysis_tsni, { "lbmc.analysis.tsni", PI_SEQUENCE, PI_NOTE, "TSNI Sqn", EXPFILL } }, + { &ei_lbmc_analysis_invalid_value, { "lbmc.analysis.invalid_value", PI_MALFORMED, PI_ERROR, "Invalid value", EXPFILL } }, + { &ei_lbmc_analysis_no_reassembly, { "lbmc.analysis.no_reassembly", PI_PROTOCOL, PI_ERROR, "Reassembly not in progress but fragment_offset not zero", EXPFILL } }, + { &ei_lbmc_analysis_invalid_offset, { "lbmc.analysis.invalid_offset", PI_MALFORMED, PI_ERROR, "Message property offset exceeds data length", EXPFILL } }, + { &ei_lbmc_analysis_missing_reassembly_frame, { "lbmc.analysis.missing_reassembly_frame", PI_UNDECODED, PI_WARN, "Reassembly frame not found - perhaps missing packets?", EXPFILL } }, + { &ei_lbmc_analysis_invalid_fragment, { "lbmc.analysis.invalid_fragment", PI_MALFORMED, PI_ERROR, "Invalid fragment", EXPFILL } }, + }; + module_t * lbmc_module = NULL; + expert_module_t * expert_lbmc; + + tnw_protocol_handle = proto_register_protocol("29West Protocol", "29West", "29west"); + proto_lbmc = proto_register_protocol("LBMC Protocol", "LBMC", "lbmc"); + + proto_register_field_array(proto_lbmc, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_lbmc = expert_register_protocol(proto_lbmc); + expert_register_field_array(expert_lbmc, ei, array_length(ei)); + + register_heur_dissector_list("29westdata", &lbmc_heuristic_subdissector_list); + + prefs_register_protocol(tnw_protocol_handle, NULL); + lbmc_module = prefs_register_protocol_subtree("29West", proto_lbmc, proto_reg_handoff_lbmc); + prefs_register_bool_preference(lbmc_module, + "use_heuristic_subdissectors", + "Use heuristic sub-dissectors", + "Use a registered heuristic sub-dissector to decode the data payload", + &lbmc_use_heuristic_subdissectors); + prefs_register_bool_preference(lbmc_module, + "reassemble_fragments", + "Reassemble fragmented data", + "Reassemble data message fragments", + &lbmc_reassemble_fragments); + prefs_register_bool_preference(lbmc_module, + "dissect_lbmpdm", + "Dissect LBMPDM payload", + "Recognize and dissect payloads containing LBMPDM messages (requires reassembly to be enabled)", + &lbmc_dissect_lbmpdm); + lbm_stream_init(); + lbmc_message_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); +} + +int lbmc_get_minimum_length(void) +{ + return (O_LBMC_HDR_T_MSGLEN + L_LBMC_HDR_T_MSGLEN); +} + +guint16 lbmc_get_message_length(tvbuff_t * tvb, int offset) +{ + return (tvb_get_ntohs(tvb, offset + O_LBMC_HDR_T_MSGLEN)); +} + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbmpdm.c b/epan/dissectors/packet-lbmpdm.c new file mode 100644 index 0000000000..a87382aa9e --- /dev/null +++ b/epan/dissectors/packet-lbmpdm.c @@ -0,0 +1,1522 @@ +/* packet-lbmpdm.c + * Routines for LBM PDM Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include "packet-lbm.h" + +/* Magic number for message header to check if data is big-endian or little-endian. */ +#define PDM_MSG_HDR_BE_MAGIC_BYTE_1 0xA7 +#define PDM_MSG_HDR_BE_MAGIC_BYTE_2 0x1C +#define PDM_MSG_HDR_BE_MAGIC_BYTE_3 0xCA +#define PDM_MSG_HDR_BE_MAGIC_BYTE_4 0xFE +#define PDM_MSG_HDR_LE_MAGIC_BYTE_1 0xFE +#define PDM_MSG_HDR_LE_MAGIC_BYTE_2 0xCA +#define PDM_MSG_HDR_LE_MAGIC_BYTE_3 0x1C +#define PDM_MSG_HDR_LE_MAGIC_BYTE_4 0xA7 + +/*------------*/ +/* PDM header */ +/*------------*/ +typedef struct lbmpdm_msg_hdr_stct_t +{ + guint32 magic; + guint8 ver_type; + guint8 next_hdr; + guint8 def_major_ver; + guint8 def_minor_ver; + guint32 def_id; + guint32 len; +} lbmpdm_msg_hdr_t; +#define O_LBMPDM_MSG_HDR_T_MAGIC OFFSETOF(lbmpdm_msg_hdr_t, magic) +#define L_LBMPDM_MSG_HDR_T_MAGIC SIZEOF(lbmpdm_msg_hdr_t, magic) +#define O_LBMPDM_MSG_HDR_T_VER_TYPE OFFSETOF(lbmpdm_msg_hdr_t, ver_type) +#define L_LBMPDM_MSG_HDR_T_VER_TYPE SIZEOF(lbmpdm_msg_hdr_t, ver_type) +#define O_LBMPDM_MSG_HDR_T_NEXT_HDR OFFSETOF(lbmpdm_msg_hdr_t, next_hdr) +#define L_LBMPDM_MSG_HDR_T_NEXT_HDR SIZEOF(lbmpdm_msg_hdr_t, next_hdr) +#define O_LBMPDM_MSG_HDR_T_DEF_MAJOR_VER OFFSETOF(lbmpdm_msg_hdr_t, def_major_ver) +#define L_LBMPDM_MSG_HDR_T_DEF_MAJOR_VER SIZEOF(lbmpdm_msg_hdr_t, def_major_ver) +#define O_LBMPDM_MSG_HDR_T_DEF_MINOR_VER OFFSETOF(lbmpdm_msg_hdr_t, def_minor_ver) +#define L_LBMPDM_MSG_HDR_T_DEF_MINOR_VER SIZEOF(lbmpdm_msg_hdr_t, def_minor_ver) +#define O_LBMPDM_MSG_HDR_T_DEF_ID OFFSETOF(lbmpdm_msg_hdr_t, def_id) +#define L_LBMPDM_MSG_HDR_T_DEF_ID SIZEOF(lbmpdm_msg_hdr_t, def_id) +#define O_LBMPDM_MSG_HDR_T_LEN OFFSETOF(lbmpdm_msg_hdr_t, len) +#define L_LBMPDM_MSG_HDR_T_LEN SIZEOF(lbmpdm_msg_hdr_t, len) +#define L_LBMPDM_MSG_HDR_T (gint) sizeof(lbmpdm_msg_hdr_t) + +/*---------------------*/ +/* PDM segment header. */ +/*---------------------*/ +typedef struct lbmpdm_seg_hdr_stct_t +{ + guint8 next_hdr; + guint8 flags; + guint16 res; + guint32 len; +} lbmpdm_seg_hdr_t; +#define O_LBMPDM_SEG_HDR_T_NEXT_HDR OFFSETOF(lbmpdm_seg_hdr_t, next_hdr) +#define L_LBMPDM_SEG_HDR_T_NEXT_HDR SIZEOF(lbmpdm_seg_hdr_t, next_hdr) +#define O_LBMPDM_SEG_HDR_T_FLAGS OFFSETOF(lbmpdm_seg_hdr_t, flags) +#define L_LBMPDM_SEG_HDR_T_FLAGS SIZEOF(lbmpdm_seg_hdr_t, flags) +#define O_LBMPDM_SEG_HDR_T_RES OFFSETOF(lbmpdm_seg_hdr_t, res) +#define L_LBMPDM_SEG_HDR_T_RES SIZEOF(lbmpdm_seg_hdr_t, res) +#define O_LBMPDM_SEG_HDR_T_LEN OFFSETOF(lbmpdm_seg_hdr_t, len) +#define L_LBMPDM_SEG_HDR_T_LEN SIZEOF(lbmpdm_seg_hdr_t, len) +#define L_LBMPDM_SEG_HDR_T (gint) sizeof(lbmpdm_seg_hdr_t) + +/*--------------------------------*/ +/* PDM definition segment header. */ +/*--------------------------------*/ +typedef struct lbmpdm_defn_stct_t +{ + gint32 id; + gint32 num_fields; + guint8 field_names_type; + guint8 finalized; + guint8 msg_vers_major; + guint8 msg_vers_minor; + guint32 fixed_req_section_len; + guint32 field_info_len; +} lbmpdm_defn_t; +#define O_LBMPDM_DEFN_T_ID OFFSETOF(lbmpdm_defn_t, id) +#define L_LBMPDM_DEFN_T_ID SIZEOF(lbmpdm_defn_t, id) +#define O_LBMPDM_DEFN_T_NUM_FIELDS OFFSETOF(lbmpdm_defn_t, num_fields) +#define L_LBMPDM_DEFN_T_NUM_FIELDS SIZEOF(lbmpdm_defn_t, num_fields) +#define O_LBMPDM_DEFN_T_FIELD_NAMES_TYPE OFFSETOF(lbmpdm_defn_t, field_names_type) +#define L_LBMPDM_DEFN_T_FIELD_NAMES_TYPE SIZEOF(lbmpdm_defn_t, field_names_type) +#define O_LBMPDM_DEFN_T_FINALIZED OFFSETOF(lbmpdm_defn_t, finalized) +#define L_LBMPDM_DEFN_T_FINALIZED SIZEOF(lbmpdm_defn_t, finalized) +#define O_LBMPDM_DEFN_T_MSG_VERS_MAJOR OFFSETOF(lbmpdm_defn_t, msg_vers_major) +#define L_LBMPDM_DEFN_T_MSG_VERS_MAJOR SIZEOF(lbmpdm_defn_t, msg_vers_major) +#define O_LBMPDM_DEFN_T_MSG_VERS_MINOR OFFSETOF(lbmpdm_defn_t, msg_vers_minor) +#define L_LBMPDM_DEFN_T_MSG_VERS_MINOR SIZEOF(lbmpdm_defn_t, msg_vers_minor) +#define O_LBMPDM_DEFN_T_FIXED_REQ_SECTION_LEN OFFSETOF(lbmpdm_defn_t, fixed_req_section_len) +#define L_LBMPDM_DEFN_T_FIXED_REQ_SECTION_LEN SIZEOF(lbmpdm_defn_t, fixed_req_section_len) +#define O_LBMPDM_DEFN_T_FIELD_INFO_LEN OFFSETOF(lbmpdm_defn_t, field_info_len) +#define L_LBMPDM_DEFN_T_FIELD_INFO_LEN SIZEOF(lbmpdm_defn_t, field_info_len) +#define L_LBMPDM_DEFN_T (gint) sizeof(lbmpdm_defn_t) + +/*----------------------------*/ +/* PDM definition field info. */ +/*----------------------------*/ +typedef struct lbmpdm_field_info_stct_t +{ + guint32 id; + guint32 len; + guint32 fixed_str_len; + guint32 num_arr_elem; + guint8 req; + guint8 fixed; + gint32 fld_int_name; + gint32 str_name_len; + /* NUL-terminated field name, if str_name_len != 0 */ + /* int16_t fld_type */ +} lbmpdm_field_info_t; +#define O_LBMPDM_FIELD_INFO_T_ID OFFSETOF(lbmpdm_field_info_t, id) +#define L_LBMPDM_FIELD_INFO_T_ID SIZEOF(lbmpdm_field_info_t, id) +#define O_LBMPDM_FIELD_INFO_T_LEN OFFSETOF(lbmpdm_field_info_t, len) +#define L_LBMPDM_FIELD_INFO_T_LEN SIZEOF(lbmpdm_field_info_t, len) +#define O_LBMPDM_FIELD_INFO_T_FIXED_STR_LEN OFFSETOF(lbmpdm_field_info_t, fixed_str_len) +#define L_LBMPDM_FIELD_INFO_T_FIXED_STR_LEN SIZEOF(lbmpdm_field_info_t, fixed_str_len) +#define O_LBMPDM_FIELD_INFO_T_NUM_ARR_ELEM OFFSETOF(lbmpdm_field_info_t, num_arr_elem) +#define L_LBMPDM_FIELD_INFO_T_NUM_ARR_ELEM SIZEOF(lbmpdm_field_info_t, num_arr_elem) +#define O_LBMPDM_FIELD_INFO_T_REQ OFFSETOF(lbmpdm_field_info_t, req) +#define L_LBMPDM_FIELD_INFO_T_REQ SIZEOF(lbmpdm_field_info_t, req) +#define O_LBMPDM_FIELD_INFO_T_FIXED OFFSETOF(lbmpdm_field_info_t, fixed) +#define L_LBMPDM_FIELD_INFO_T_FIXED SIZEOF(lbmpdm_field_info_t, fixed) +#define O_LBMPDM_FIELD_INFO_T_FLD_INT_NAME (O_LBMPDM_FIELD_INFO_T_FIXED + L_LBMPDM_FIELD_INFO_T_FIXED) +#define L_LBMPDM_FIELD_INFO_T_FLD_INT_NAME sizeof(guint32) +#define O_LBMPDM_FIELD_INFO_T_STR_NAME_LEN (O_LBMPDM_FIELD_INFO_T_FLD_INT_NAME + L_LBMPDM_FIELD_INFO_T_FLD_INT_NAME) +#define L_LBMPDM_FIELD_INFO_T_STR_NAME_LEN sizeof(guint32) +#define L_LBMPDM_FIELD_INFO_T (O_LBMPDM_FIELD_INFO_T_STR_NAME_LEN + L_LBMPDM_FIELD_INFO_T_STR_NAME_LEN) +#define L_LBMPDM_FIELD_INFO_T_INT_NAME (gint) (L_LBMPDM_FIELD_INFO_T + sizeof(guint16)) + +/*---------------------------------*/ +/* PDM offset table segment entry. */ +/*---------------------------------*/ +typedef struct +{ + guint32 id; + guint32 offset; +} lbmpdm_offset_entry_t; +#define O_LBMPDM_OFFSET_ENTRY_T_ID OFFSETOF(lbmpdm_offset_entry_t, id) +#define L_LBMPDM_OFFSET_ENTRY_T_ID SIZEOF(lbmpdm_offset_entry_t, id) +#define O_LBMPDM_OFFSET_ENTRY_T_OFFSET OFFSETOF(lbmpdm_offset_entry_t, offset) +#define L_LBMPDM_OFFSET_ENTRY_T_OFFSET SIZEOF(lbmpdm_offset_entry_t, offset) +#define L_LBMPDM_OFFSET_ENTRY_T (gint) sizeof(lbmpdm_offset_entry_t) + +/*-----------------------------------*/ +/* Header types (value of next_hdr). */ +/*-----------------------------------*/ +#define PDM_HDR_TYPE_DATA 0 +#define PDM_HDR_TYPE_OFSTTBLE 1 +#define PDM_HDR_TYPE_DEFN 2 +#define PDM_HDR_TYPE_EOM 0xFF + + +/* PDM protocol version number. + */ +#define PDM_VERS 1 + +/*------------------*/ +/* PDM field types. */ +/*------------------*/ +#define PDM_TYPE_BOOLEAN 0 +#define PDM_TYPE_INT8 1 +#define PDM_TYPE_UINT8 2 +#define PDM_TYPE_INT16 3 +#define PDM_TYPE_UINT16 4 +#define PDM_TYPE_INT32 5 +#define PDM_TYPE_UINT32 6 +#define PDM_TYPE_INT64 7 +#define PDM_TYPE_UINT64 8 +#define PDM_TYPE_FLOAT 9 +#define PDM_TYPE_DOUBLE 10 +#define PDM_TYPE_DECIMAL 11 +#define PDM_TYPE_TIMESTAMP 12 +#define PDM_TYPE_FIX_STRING 13 +#define PDM_TYPE_STRING 14 +#define PDM_TYPE_FIX_UNICODE 15 +#define PDM_TYPE_UNICODE 16 +#define PDM_TYPE_BLOB 17 +#define PDM_TYPE_MESSAGE 18 +#define PDM_TYPE_BOOLEAN_ARR 19 +#define PDM_TYPE_INT8_ARR 20 +#define PDM_TYPE_UINT8_ARR 21 +#define PDM_TYPE_INT16_ARR 22 +#define PDM_TYPE_UINT16_ARR 23 +#define PDM_TYPE_INT32_ARR 24 +#define PDM_TYPE_UINT32_ARR 25 +#define PDM_TYPE_INT64_ARR 26 +#define PDM_TYPE_UINT64_ARR 27 +#define PDM_TYPE_FLOAT_ARR 28 +#define PDM_TYPE_DOUBLE_ARR 29 +#define PDM_TYPE_DECIMAL_ARR 30 +#define PDM_TYPE_TIMESTAMP_ARR 31 +#define PDM_TYPE_FIX_STRING_ARR 32 +#define PDM_TYPE_STRING_ARR 33 +#define PDM_TYPE_FIX_UNICODE_ARR 34 +#define PDM_TYPE_UNICODE_ARR 35 +#define PDM_TYPE_BLOB_ARR 36 +#define PDM_TYPE_MESSAGE_ARR 37 + +/* Macros for protocol version number and pdm message type. + */ +#define PDM_HDR_VER(x) (x >> 4) +#define PDM_HDR_TYPE(x) (x & 0xF) +#define PDM_HDR_VER_TYPE(v,t) ((v << 4)|(t & 0xF)) +#define PDM_HDR_VER_TYPE_VER_MASK 0xf0 +#define PDM_HDR_VER_TYPE_TYPE_MASK 0x0f + +#define PDM_IGNORE_FLAG 0x80 + +#define PDM_DEFN_STR_FIELD_NAMES 0 +#define PDM_DEFN_INT_FIELD_NAMES 1 + +#define PDM_DEFN_OPTIONAL_FIELD 0 +#define PDM_DEFN_REQUIRED_FIELD 1 + +#define PDM_DEFN_VARIABLE_LENGTH_FIELD 0 +#define PDM_DEFN_FIXED_LENGTH_FIELD 1 + +typedef struct +{ + guint32 num_flds; + gint32 * min_set_offset; + gint32 * offset_list; +} lbmpdm_offset_table_t; + +struct lbmpdm_definition_field_t_stct; +typedef struct lbmpdm_definition_field_t_stct lbmpdm_definition_field_t; + +struct lbmpdm_definition_t_stct; +typedef struct lbmpdm_definition_t_stct lbmpdm_definition_t; + +struct lbmpdm_definition_field_t_stct +{ + guint32 id; + guint32 len; + guint32 fixed_string_len; + guint32 num_array_elem; + guint8 required; + guint8 fixed; + guint16 field_type; + guint16 base_type; + gint32 field_int_name; + guint32 field_string_name_len; + char * field_string_name; + int fixed_required_offset; + lbmpdm_definition_field_t * next_fixed_required; + lbmpdm_definition_t * definition; +}; + +struct lbmpdm_definition_t_stct +{ + guint64 channel; + guint32 id; + guint8 vers_major; + guint8 vers_minor; + gint32 num_fields; + guint8 field_names_type; + guint8 finalized; + guint32 fixed_req_section_len; + guint32 fixed_required_count; + lbmpdm_definition_field_t * first_fixed_required; + wmem_tree_t * field_list; +}; + +typedef struct +{ + guint64 channel; + guint32 msg_def_id; + guint8 ver_major; + guint8 ver_minor; + lbmpdm_offset_table_t * offset_table; +} lbmpdm_msg_definition_id_t; + +#define LBMPDM_DEFINITION_KEY_ELEMENT_COUNT 5 +#define LBMPDM_DEFINITION_KEY_ELEMENT_CHANNEL_HIGH 0 +#define LBMPDM_DEFINITION_KEY_ELEMENT_CHANNEL_LOW 1 +#define LBMPDM_DEFINITION_KEY_ELEMENT_ID 2 +#define LBMPDM_DEFINITION_KEY_ELEMENT_VERS_MAJOR 3 +#define LBMPDM_DEFINITION_KEY_ELEMENT_VERS_MINOR 4 + +static wmem_tree_t * lbmpdm_definition_table = NULL; + +/*----------------------------------------------------------------------------*/ +/* Handles of all types. */ +/*----------------------------------------------------------------------------*/ + +/* Protocol handle */ +static int proto_lbmpdm = -1; + +/* Protocol fields */ +static int hf_lbmpdm_magic = -1; +static int hf_lbmpdm_encoding = -1; +static int hf_lbmpdm_ver_type = -1; +static int hf_lbmpdm_ver_type_ver = -1; +static int hf_lbmpdm_ver_type_type = -1; +static int hf_lbmpdm_next_hdr = -1; +static int hf_lbmpdm_def_major_ver = -1; +static int hf_lbmpdm_def_minor_ver = -1; +static int hf_lbmpdm_def_id = -1; +static int hf_lbmpdm_len = -1; +static int hf_lbmpdm_segments = -1; +static int hf_lbmpdm_segment = -1; +static int hf_lbmpdm_segment_next_hdr = -1; +static int hf_lbmpdm_segment_flags = -1; +static int hf_lbmpdm_segment_res = -1; +static int hf_lbmpdm_segment_len = -1; +static int hf_lbmpdm_segment_def_id = -1; +static int hf_lbmpdm_segment_def_num_fields = -1; +static int hf_lbmpdm_segment_def_field_names_type = -1; +static int hf_lbmpdm_segment_def_finalized = -1; +static int hf_lbmpdm_segment_def_msg_vers_major = -1; +static int hf_lbmpdm_segment_def_msg_vers_minor = -1; +static int hf_lbmpdm_segment_def_fixed_req_section_len = -1; +static int hf_lbmpdm_segment_def_field_info_len = -1; +static int hf_lbmpdm_segment_def_field = -1; +static int hf_lbmpdm_segment_def_field_def_len = -1; +static int hf_lbmpdm_segment_def_field_id = -1;; +static int hf_lbmpdm_segment_def_field_len = -1; +static int hf_lbmpdm_segment_def_field_fixed_str_len = -1; +static int hf_lbmpdm_segment_def_field_num_arr_elem = -1; +static int hf_lbmpdm_segment_def_field_req = -1; +static int hf_lbmpdm_segment_def_field_fixed = -1; +static int hf_lbmpdm_segment_def_field_fld_int_name = -1; +static int hf_lbmpdm_segment_def_field_str_name_len = -1; +static int hf_lbmpdm_segment_def_field_str_name = -1; +static int hf_lbmpdm_segment_def_field_fld_type = -1; +static int hf_lbmpdm_offset_entry = -1; +static int hf_lbmpdm_offset_entry_id = -1; +static int hf_lbmpdm_offset_entry_offset = -1; +static int hf_lbmpdm_segment_data = -1; +static int hf_lbmpdm_field = -1; +static int hf_lbmpdm_field_id = -1; +static int hf_lbmpdm_field_string_name = -1; +static int hf_lbmpdm_field_int_name = -1; +static int hf_lbmpdm_field_type = -1; +static int hf_lbmpdm_field_total_length = -1; +static int hf_lbmpdm_field_length = -1; +static int hf_lbmpdm_field_value_boolean = -1; +static int hf_lbmpdm_field_value_int8 = -1; +static int hf_lbmpdm_field_value_uint8 = -1; +static int hf_lbmpdm_field_value_int16 = -1; +static int hf_lbmpdm_field_value_uint16 = -1; +static int hf_lbmpdm_field_value_int32 = -1; +static int hf_lbmpdm_field_value_uint32 = -1; +static int hf_lbmpdm_field_value_int64 = -1; +static int hf_lbmpdm_field_value_uint64 = -1; +static int hf_lbmpdm_field_value_float = -1; +static int hf_lbmpdm_field_value_double = -1; +static int hf_lbmpdm_field_value_decimal = -1; +static int hf_lbmpdm_field_value_timestamp = -1; +static int hf_lbmpdm_field_value_fixed_string = -1; +static int hf_lbmpdm_field_value_string = -1; +static int hf_lbmpdm_field_value_fixed_unicode = -1; +static int hf_lbmpdm_field_value_unicode = -1; +static int hf_lbmpdm_field_value_blob = -1; +static int hf_lbmpdm_field_value_message = -1; + +/* Protocol trees */ +static gint ett_lbmpdm = -1; +static gint ett_lbmpdm_ver_type = -1; +static gint ett_lbmpdm_segments = -1; +static gint ett_lbmpdm_segment = -1; +static gint ett_lbmpdm_offset_entry = -1; +static gint ett_lbmpdm_segment_def_field = -1; +static gint ett_lbmpdm_field = -1; + +/*----------------------------------------------------------------------------*/ +/* Value translation tables. */ +/*----------------------------------------------------------------------------*/ + +/* Value tables */ +static const value_string lbmpdm_field_type[] = +{ + { PDM_TYPE_BOOLEAN, "Boolean" }, + { PDM_TYPE_INT8, "8-bit integer" }, + { PDM_TYPE_UINT8, "8-bit unsigned integer" }, + { PDM_TYPE_INT16, "16-bit integer" }, + { PDM_TYPE_UINT16, "16-bit unsigned integer" }, + { PDM_TYPE_INT32, "32-bit integer" }, + { PDM_TYPE_UINT32, "32-bit unsigned integer" }, + { PDM_TYPE_INT64, "64-bit integer" }, + { PDM_TYPE_UINT64, "64-bit unsigned integer" }, + { PDM_TYPE_FLOAT, "Float" }, + { PDM_TYPE_DOUBLE, "Double" }, + { PDM_TYPE_DECIMAL, "Decimal" }, + { PDM_TYPE_TIMESTAMP, "Timestamp" }, + { PDM_TYPE_FIX_STRING, "Fixed-length string" }, + { PDM_TYPE_STRING, "String" }, + { PDM_TYPE_FIX_UNICODE, "Fixed-length unicode string" }, + { PDM_TYPE_UNICODE, "Unicode string" }, + { PDM_TYPE_BLOB, "Binary Large OBject" }, + { PDM_TYPE_MESSAGE, "Message" }, + { PDM_TYPE_BOOLEAN_ARR, "Array of booleans" }, + { PDM_TYPE_INT8_ARR, "Array of 8-bit integers" }, + { PDM_TYPE_UINT8_ARR, "Array of 8-bit unsigned integers" }, + { PDM_TYPE_INT16_ARR, "Array of 16-bit integers" }, + { PDM_TYPE_UINT16_ARR, "Array of 16-bit unsigned integers" }, + { PDM_TYPE_INT32_ARR, "Array of 32-bit integers" }, + { PDM_TYPE_UINT32_ARR, "Array of 32-bit unsigned integers" }, + { PDM_TYPE_INT64_ARR, "Array of 64-bit integers" }, + { PDM_TYPE_UINT64_ARR, "Array of 64-bit unsigned integers" }, + { PDM_TYPE_FLOAT_ARR, "Array of floats" }, + { PDM_TYPE_DOUBLE_ARR, "Array of doubles" }, + { PDM_TYPE_DECIMAL_ARR, "Array of decimals" }, + { PDM_TYPE_TIMESTAMP_ARR, "Array of timestamps" }, + { PDM_TYPE_FIX_STRING_ARR, "Array of fixed-length strings" }, + { PDM_TYPE_STRING_ARR, "Array of strings" }, + { PDM_TYPE_FIX_UNICODE_ARR, "Array of fixed-length unicode strings" }, + { PDM_TYPE_UNICODE_ARR, "Array of unicode strings" }, + { PDM_TYPE_BLOB_ARR, "Array of Binary Large OBjects" }, + { PDM_TYPE_MESSAGE_ARR, "Array of messages" }, + { 0x0, NULL } +}; + +static const value_string lbmpdm_next_header[] = +{ + { PDM_HDR_TYPE_DATA, "Data" }, + { PDM_HDR_TYPE_OFSTTBLE, "Offset table" }, + { PDM_HDR_TYPE_DEFN, "Definition" }, + { PDM_HDR_TYPE_EOM, "End of message" }, + { 0x0, NULL } +}; + +static const value_string lbmpdm_field_name_type[] = +{ + { PDM_DEFN_STR_FIELD_NAMES, "String" }, + { PDM_DEFN_INT_FIELD_NAMES, "Integer" }, + { 0x0, NULL } +}; + +static const value_string lbmpdm_field_required[] = +{ + { PDM_DEFN_OPTIONAL_FIELD, "Field is optional" }, + { PDM_DEFN_REQUIRED_FIELD, "Field is required" }, + { 0x0, NULL } +}; + +static const value_string lbmpdm_field_fixed_length[] = +{ + { PDM_DEFN_VARIABLE_LENGTH_FIELD, "Field is variable-length" }, + { PDM_DEFN_FIXED_LENGTH_FIELD, "Field is fixed-length" }, + { 0x0, NULL } +}; + +static guint64 lbmpdm_fetch_uint64_encoded(tvbuff_t * tvb, int offset, int encoding) +{ + guint64 value = 0; + + if (encoding == ENC_BIG_ENDIAN) + { + value = tvb_get_ntoh64(tvb, offset); + } + else + { + value = tvb_get_letoh64(tvb, offset); + } + return (value); +} + +static guint32 lbmpdm_fetch_uint32_encoded(tvbuff_t * tvb, int offset, int encoding) +{ + guint32 value = 0; + + if (encoding == ENC_BIG_ENDIAN) + { + value = tvb_get_ntohl(tvb, offset); + } + else + { + value = tvb_get_letohl(tvb, offset); + } + return (value); +} + +static guint16 lbmpdm_fetch_uint16_encoded(tvbuff_t * tvb, int offset, int encoding) +{ + guint16 value = 0; + + if (encoding == ENC_BIG_ENDIAN) + { + value = tvb_get_ntohs(tvb, offset); + } + else + { + value = tvb_get_letohs(tvb, offset); + } + return (value); +} + +static int lbmpdm_get_segment_length(tvbuff_t * tvb, int offset, int encoding, int * data_length) +{ + guint32 datalen = 0; + int seglen = 0; + + datalen = lbmpdm_fetch_uint32_encoded(tvb, offset + O_LBMPDM_SEG_HDR_T_LEN, encoding); + seglen = ((int)datalen) + L_LBMPDM_SEG_HDR_T; + *data_length = (int) datalen; + return (seglen); +} + +static void lbmpdm_definition_build_key(guint32 * key_value, wmem_tree_key_t * key, guint64 channel, guint32 id, guint8 version_major, guint8 version_minor) +{ + key_value[LBMPDM_DEFINITION_KEY_ELEMENT_CHANNEL_HIGH] = (guint32) ((channel >> 32) & 0xffffffff); + key_value[LBMPDM_DEFINITION_KEY_ELEMENT_CHANNEL_LOW] = (guint32) ((channel & 0xffffffff) >> 32); + key_value[LBMPDM_DEFINITION_KEY_ELEMENT_ID] = id; + key_value[LBMPDM_DEFINITION_KEY_ELEMENT_VERS_MAJOR] = version_major; + key_value[LBMPDM_DEFINITION_KEY_ELEMENT_VERS_MINOR] = version_minor; + key[0].length = LBMPDM_DEFINITION_KEY_ELEMENT_COUNT; + key[0].key = key_value; + key[1].length = 0; + key[1].key = NULL; +} + +static lbmpdm_definition_t * lbmpdm_definition_find(guint64 channel, guint32 ID, guint8 version_major, guint8 version_minor) +{ + lbmpdm_definition_t * entry = NULL; + guint32 keyval[LBMPDM_DEFINITION_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + lbmpdm_definition_build_key(keyval, tkey, channel, ID, version_major, version_minor); + entry = (lbmpdm_definition_t *) wmem_tree_lookup32_array(lbmpdm_definition_table, tkey); + return (entry); +} + +static lbmpdm_definition_t * lbmpdm_definition_add(guint64 channel, guint32 id, guint8 version_major, guint8 version_minor) +{ + lbmpdm_definition_t * entry = NULL; + guint32 keyval[LBMPDM_DEFINITION_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbmpdm_definition_find(channel, id, version_major, version_minor); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbmpdm_definition_t); + entry->channel = channel; + entry->id = id; + entry->vers_major = version_major; + entry->vers_minor = version_minor; + entry->field_list = wmem_tree_new(wmem_file_scope()); + lbmpdm_definition_build_key(keyval, tkey, channel, id, version_major, version_minor); + wmem_tree_insert32_array(lbmpdm_definition_table, tkey, (void *) entry); + return (entry); +} + +static lbmpdm_definition_field_t * lbmpdm_definition_field_find(lbmpdm_definition_t * definition, guint32 id) +{ + lbmpdm_definition_field_t * entry = NULL; + + entry = (lbmpdm_definition_field_t *) wmem_tree_lookup32(definition->field_list, id); + return (entry); +} + +static lbmpdm_definition_field_t * lbmpdm_definition_field_add(lbmpdm_definition_t * definition, guint32 id) +{ + lbmpdm_definition_field_t * entry = NULL; + + entry = lbmpdm_definition_field_find(definition, id); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new0(wmem_file_scope(), lbmpdm_definition_field_t); + entry->id = id; + entry->definition = definition; + wmem_tree_insert32(definition->field_list, id, (void *) entry); + return (entry); +} + +/*----------------------------------------------------------------------------*/ +/* Dissection functions. */ +/*----------------------------------------------------------------------------*/ +static void dissect_field_value(tvbuff_t * tvb, int offset, proto_tree * tree, guint16 field_type, int field_length, int encoding) +{ + switch (field_type) + { + case PDM_TYPE_BOOLEAN: + proto_tree_add_item(tree, hf_lbmpdm_field_value_boolean, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_INT8: + proto_tree_add_item(tree, hf_lbmpdm_field_value_int8, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_UINT8: + proto_tree_add_item(tree, hf_lbmpdm_field_value_uint8, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_INT16: + proto_tree_add_item(tree, hf_lbmpdm_field_value_int16, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_UINT16: + proto_tree_add_item(tree, hf_lbmpdm_field_value_uint16, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_INT32: + proto_tree_add_item(tree, hf_lbmpdm_field_value_int32, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_UINT32: + proto_tree_add_item(tree, hf_lbmpdm_field_value_uint32, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_INT64: + proto_tree_add_item(tree, hf_lbmpdm_field_value_int64, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_UINT64: + proto_tree_add_item(tree, hf_lbmpdm_field_value_uint64, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_FLOAT: + proto_tree_add_item(tree, hf_lbmpdm_field_value_float, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_DOUBLE: + proto_tree_add_item(tree, hf_lbmpdm_field_value_double, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_DECIMAL: + { + gint64 mantissa; + gint8 exponent; + gint64 whole = 0; + guint64 fraction = 0; + gint8 shift_count; + + exponent = (gint8)tvb_get_guint8(tvb, offset); + mantissa = (gint64)lbmpdm_fetch_uint64_encoded(tvb, offset + sizeof(guint8), encoding); + if (exponent >= 0) + { + whole = mantissa; + shift_count = exponent; + while (shift_count > 0) + { + whole *= 10; + shift_count--; + } + proto_tree_add_none_format(tree, hf_lbmpdm_field_value_decimal, tvb, offset, field_length, + "DECIMAL Value: %" G_GINT64_FORMAT " (%" G_GINT64_FORMAT "e%d)", whole, mantissa, exponent); + } + else + { + guint64 divisor = 1; + int decimal_digits = -exponent; + shift_count = decimal_digits; + while (shift_count > 0) + { + divisor *= 10; + shift_count--; + } + if (mantissa < 0) + { + whole = -mantissa; + } + else + { + whole = mantissa; + } + fraction = whole % divisor; + whole /= divisor; + if (mantissa < 0) + { + whole *= -1; + } + proto_tree_add_none_format(tree, hf_lbmpdm_field_value_decimal, tvb, offset, field_length, + "DECIMAL Value: %" G_GINT64_FORMAT ".%0*" G_GUINT64_FORMAT " (%" G_GINT64_FORMAT "e%d)", + whole, decimal_digits, fraction, mantissa, exponent); + } + } + break; + case PDM_TYPE_TIMESTAMP: + { + nstime_t timestamp; + + timestamp.secs = (time_t)lbmpdm_fetch_uint32_encoded(tvb, offset, encoding); + timestamp.nsecs = (int)(lbmpdm_fetch_uint32_encoded(tvb, offset + sizeof(guint32), encoding) * 1000); + proto_tree_add_time(tree, hf_lbmpdm_field_value_timestamp, tvb, offset, field_length, ×tamp); + } + break; + case PDM_TYPE_FIX_STRING: + proto_tree_add_item(tree, hf_lbmpdm_field_value_fixed_string, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_STRING: + proto_tree_add_item(tree, hf_lbmpdm_field_value_string, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_FIX_UNICODE: + proto_tree_add_item(tree, hf_lbmpdm_field_value_fixed_unicode, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_UNICODE: + proto_tree_add_item(tree, hf_lbmpdm_field_value_unicode, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_BLOB: + proto_tree_add_item(tree, hf_lbmpdm_field_value_blob, tvb, offset, field_length, encoding); + break; + case PDM_TYPE_MESSAGE: + proto_tree_add_item(tree, hf_lbmpdm_field_value_message, tvb, offset, field_length, encoding); + break; + default: + break; + } +} + +static int dissect_field(tvbuff_t * tvb, int offset, proto_tree * tree, lbmpdm_definition_field_t * field, gboolean string_field_names, int encoding) +{ + proto_item * field_item = NULL; + proto_tree * field_tree = NULL; + proto_item * ti = NULL; + int ofs = offset; + guint32 element_count = 0; + guint32 idx; + int len_dissected = 0; + + field_item = proto_tree_add_item(tree, hf_lbmpdm_field, tvb, offset, field->len, ENC_NA); + field_tree = proto_item_add_subtree(field_item, ett_lbmpdm_field); + ti = proto_tree_add_uint(field_tree, hf_lbmpdm_field_id, tvb, 0, 0, field->id); + PROTO_ITEM_SET_GENERATED(ti); + if (string_field_names) + { + ti = proto_tree_add_string(field_tree, hf_lbmpdm_field_string_name, tvb, 0, 0, field->field_string_name); + } + else + { + ti = proto_tree_add_uint(field_tree, hf_lbmpdm_field_int_name, tvb, 0, 0, field->field_int_name); + } + PROTO_ITEM_SET_GENERATED(ti); + ti = proto_tree_add_uint(field_tree, hf_lbmpdm_field_type, tvb, 0, 0, field->field_type); + PROTO_ITEM_SET_GENERATED(ti); + if (field->num_array_elem == 0) + { + element_count = 1; + } + else + { + element_count = field->num_array_elem; + if (field->fixed == PDM_DEFN_VARIABLE_LENGTH_FIELD) + { + proto_tree_add_item(field_tree, hf_lbmpdm_field_total_length, tvb, ofs, sizeof(guint32), encoding); + len_dissected += sizeof(guint32); + ofs += sizeof(guint32); + } + } + for (idx = 0; idx < element_count; ++idx) + { + /* field_len is length of the entire entry, including any length prefix. */ + guint32 field_len = field->len / element_count; + /* value_len is the length of the data only. */ + guint32 value_len = field_len; + /* value_offset is the offset of the actual value. */ + int value_offset = ofs; + + if (field->fixed == PDM_DEFN_VARIABLE_LENGTH_FIELD) + { + proto_tree_add_item(field_tree, hf_lbmpdm_field_length, tvb, ofs, sizeof(guint32), encoding); + value_len = lbmpdm_fetch_uint32_encoded(tvb, ofs, encoding); + field_len = value_len + sizeof(guint32); + value_offset += sizeof(guint32); + } + else if (field->fixed_string_len > 0) + { + value_len = field->fixed_string_len; + } + dissect_field_value(tvb, value_offset, field_tree, field->base_type, value_len, encoding); + ofs += (int)field_len; + len_dissected += (int)field_len; + } + return (len_dissected); +} + +static int dissect_segment_data(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmpdm_msg_definition_id_t * id, int encoding) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int datalen = 0; + int seglen = 0; + lbmpdm_definition_t * def = NULL; + + seglen = lbmpdm_get_segment_length(tvb, offset, encoding, &datalen); + subtree_item = proto_tree_add_none_format(tree, hf_lbmpdm_segment, tvb, offset, seglen, "Data Segment"); + subtree = proto_item_add_subtree(subtree_item, ett_lbmpdm_segment); + proto_tree_add_item(subtree, hf_lbmpdm_segment_next_hdr, tvb, offset + O_LBMPDM_SEG_HDR_T_NEXT_HDR, L_LBMPDM_SEG_HDR_T_NEXT_HDR, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_flags, tvb, offset + O_LBMPDM_SEG_HDR_T_FLAGS, L_LBMPDM_SEG_HDR_T_FLAGS, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_res, tvb, offset + O_LBMPDM_SEG_HDR_T_RES, L_LBMPDM_SEG_HDR_T_RES, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_len, tvb, offset + O_LBMPDM_SEG_HDR_T_LEN, L_LBMPDM_SEG_HDR_T_LEN, encoding); + if ((id != NULL) && (id->offset_table != NULL)) + { + def = lbmpdm_definition_find(id->channel, id->msg_def_id, id->ver_major, id->ver_minor); + } + if (def == NULL) + { + proto_tree_add_item(subtree, hf_lbmpdm_segment_data, tvb, offset + L_LBMPDM_SEG_HDR_T, datalen, ENC_NA); + } + else + { + int fld_offset = offset + L_LBMPDM_SEG_HDR_T; + lbmpdm_definition_field_t * field = NULL; + gboolean string_field_names = FALSE; + guint32 idx; + + if (def->field_names_type == PDM_DEFN_STR_FIELD_NAMES) + { + string_field_names = TRUE; + } + else + { + string_field_names = FALSE; + } + + /* Handle any fixed required fields first. */ + for (field = def->first_fixed_required; field != NULL; field = field->next_fixed_required) + { + fld_offset += dissect_field(tvb, fld_offset, subtree, field, string_field_names, encoding); + } + /* Step through the offset table. */ + for (idx = 0; idx < id->offset_table->num_flds; ++idx) + { + gint32 ofs = id->offset_table->offset_list[idx]; + if (ofs != -1) + { + field = lbmpdm_definition_field_find(def, idx); + if (field != NULL) + { + (void)dissect_field(tvb, offset + L_LBMPDM_SEG_HDR_T + ofs, subtree, field, string_field_names, encoding); + } + } + } + } + return (seglen); +} + +static int dissect_segment_ofstable(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmpdm_offset_table_t * * offset_table, int encoding) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int datalen = 0; + int seglen = 0; + int datalen_remaining = 0; + int ofs = 0; + int field_count = 0; + int idx; + gint32 * id_list = NULL; + gint32 * ofs_list = NULL; + gint32 max_index = -1; + gint32 min_offset = G_MAXINT32; + lbmpdm_offset_table_t * ofs_table = NULL; + + seglen = lbmpdm_get_segment_length(tvb, offset, encoding, &datalen); + subtree_item = proto_tree_add_none_format(tree, hf_lbmpdm_segment, tvb, offset, seglen, "offset Table Segment"); + subtree = proto_item_add_subtree(subtree_item, ett_lbmpdm_segment); + proto_tree_add_item(subtree, hf_lbmpdm_segment_next_hdr, tvb, offset + O_LBMPDM_SEG_HDR_T_NEXT_HDR, L_LBMPDM_SEG_HDR_T_NEXT_HDR, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_flags, tvb, offset + O_LBMPDM_SEG_HDR_T_FLAGS, L_LBMPDM_SEG_HDR_T_FLAGS, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_res, tvb, offset + O_LBMPDM_SEG_HDR_T_RES, L_LBMPDM_SEG_HDR_T_RES, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_len, tvb, offset + O_LBMPDM_SEG_HDR_T_LEN, L_LBMPDM_SEG_HDR_T_LEN, encoding); + field_count = datalen / L_LBMPDM_OFFSET_ENTRY_T; + id_list = wmem_alloc_array(wmem_packet_scope(), gint32, field_count); + ofs_list = wmem_alloc_array(wmem_packet_scope(), gint32, field_count); + for (idx = 0; idx < field_count; ++idx) + { + id_list[idx] = -1; + ofs_list[idx] = -1; + } + datalen_remaining = datalen; + ofs = offset + L_LBMPDM_SEG_HDR_T; + for (idx = 0; (idx < field_count) && (datalen_remaining >= L_LBMPDM_OFFSET_ENTRY_T); idx++, ofs += L_LBMPDM_OFFSET_ENTRY_T) + { + proto_item * offset_item = NULL; + proto_tree * offset_tree = NULL; + + offset_item = proto_tree_add_item(subtree, hf_lbmpdm_offset_entry, tvb, ofs, L_LBMPDM_OFFSET_ENTRY_T, ENC_NA); + offset_tree = proto_item_add_subtree(offset_item, ett_lbmpdm_offset_entry); + proto_tree_add_item(offset_tree, hf_lbmpdm_offset_entry_id, tvb, ofs + O_LBMPDM_OFFSET_ENTRY_T_ID, L_LBMPDM_OFFSET_ENTRY_T_ID, encoding); + id_list[idx] = (gint32)lbmpdm_fetch_uint32_encoded(tvb, ofs + O_LBMPDM_OFFSET_ENTRY_T_ID, encoding); + proto_tree_add_item(offset_tree, hf_lbmpdm_offset_entry_offset, tvb, ofs + O_LBMPDM_OFFSET_ENTRY_T_OFFSET, L_LBMPDM_OFFSET_ENTRY_T_OFFSET, encoding); + ofs_list[idx] = (gint32)lbmpdm_fetch_uint32_encoded(tvb, ofs + O_LBMPDM_OFFSET_ENTRY_T_OFFSET, encoding); + if (id_list[idx] > max_index) + { + max_index = id_list[idx]; + } + if (ofs_list[idx] < min_offset) + { + min_offset = ofs_list[idx]; + } + } + ofs_table = wmem_new(wmem_packet_scope(), lbmpdm_offset_table_t); + ofs_table->num_flds = max_index + 1; + ofs_table->min_set_offset = NULL; + ofs_table->offset_list = wmem_alloc_array(wmem_packet_scope(), gint32, ofs_table->num_flds); + for (idx = 0; idx < (int)ofs_table->num_flds; ++idx) + { + ofs_table->offset_list[idx] = -1; + } + for (idx = 0; idx < field_count; ++idx) + { + ofs_table->offset_list[id_list[idx]] = ofs_list[idx]; + if (ofs_list[idx] == min_offset) + { + ofs_table->min_set_offset = &(ofs_table->offset_list[id_list[idx]]); + } + } + if (offset_table != NULL) + { + *offset_table = ofs_table; + } + return (seglen); +} + +static int dissect_segment_defn(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, guint64 channel, int encoding) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int seglen = 0; + int ofs = 0; + gboolean string_field_name = FALSE; + int remaining_datalen = 0; + guint32 num_fields = 0; + lbmpdm_definition_t * def = NULL; + gboolean add_definition = FALSE; + guint32 def_id = 0; + guint8 vers_major = 0; + guint8 vers_minor = 0; + lbmpdm_definition_field_t * last_fixed_required_field = NULL; + + seglen = lbmpdm_get_segment_length(tvb, offset, encoding, &remaining_datalen); + if (pinfo->fd->flags.visited == 0) + { + add_definition = TRUE; + } + subtree_item = proto_tree_add_none_format(tree, hf_lbmpdm_segment, tvb, offset, seglen, "Definition Segment"); + subtree = proto_item_add_subtree(subtree_item, ett_lbmpdm_segment); + proto_tree_add_item(subtree, hf_lbmpdm_segment_next_hdr, tvb, offset + O_LBMPDM_SEG_HDR_T_NEXT_HDR, L_LBMPDM_SEG_HDR_T_NEXT_HDR, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_flags, tvb, offset + O_LBMPDM_SEG_HDR_T_FLAGS, L_LBMPDM_SEG_HDR_T_FLAGS, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_res, tvb, offset + O_LBMPDM_SEG_HDR_T_RES, L_LBMPDM_SEG_HDR_T_RES, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_len, tvb, offset + O_LBMPDM_SEG_HDR_T_LEN, L_LBMPDM_SEG_HDR_T_LEN, encoding); + ofs = offset + L_LBMPDM_SEG_HDR_T; + proto_tree_add_item(subtree, hf_lbmpdm_segment_def_id, tvb, ofs + O_LBMPDM_DEFN_T_ID, L_LBMPDM_DEFN_T_ID, encoding); + def_id = lbmpdm_fetch_uint32_encoded(tvb, ofs + O_LBMPDM_DEFN_T_ID, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_def_num_fields, tvb, ofs + O_LBMPDM_DEFN_T_NUM_FIELDS, L_LBMPDM_DEFN_T_NUM_FIELDS, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_def_field_names_type, tvb, ofs + O_LBMPDM_DEFN_T_FIELD_NAMES_TYPE, L_LBMPDM_DEFN_T_FIELD_NAMES_TYPE, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_def_finalized, tvb, ofs + O_LBMPDM_DEFN_T_FINALIZED, L_LBMPDM_DEFN_T_FINALIZED, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_def_msg_vers_major, tvb, ofs + O_LBMPDM_DEFN_T_MSG_VERS_MAJOR, L_LBMPDM_DEFN_T_MSG_VERS_MAJOR, encoding); + vers_major = tvb_get_guint8(tvb, ofs + O_LBMPDM_DEFN_T_MSG_VERS_MAJOR); + proto_tree_add_item(subtree, hf_lbmpdm_segment_def_msg_vers_minor, tvb, ofs + O_LBMPDM_DEFN_T_MSG_VERS_MINOR, L_LBMPDM_DEFN_T_MSG_VERS_MINOR, encoding); + vers_minor = tvb_get_guint8(tvb, ofs + O_LBMPDM_DEFN_T_MSG_VERS_MINOR); + proto_tree_add_item(subtree, hf_lbmpdm_segment_def_fixed_req_section_len, tvb, ofs + O_LBMPDM_DEFN_T_FIXED_REQ_SECTION_LEN, L_LBMPDM_DEFN_T_FIXED_REQ_SECTION_LEN, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_def_field_info_len, tvb, ofs + O_LBMPDM_DEFN_T_FIELD_INFO_LEN, L_LBMPDM_DEFN_T_FIELD_INFO_LEN, encoding); + if (tvb_get_guint8(tvb, ofs + O_LBMPDM_DEFN_T_FIELD_NAMES_TYPE) == PDM_DEFN_STR_FIELD_NAMES) + { + string_field_name = TRUE; + } + num_fields = lbmpdm_fetch_uint32_encoded(tvb, ofs + O_LBMPDM_DEFN_T_NUM_FIELDS, encoding); + if (add_definition) + { + def = lbmpdm_definition_find(channel, def_id, vers_major, vers_minor); + if (def == NULL) + { + def = lbmpdm_definition_add(channel, def_id, vers_major, vers_minor); + def->num_fields = num_fields; + def->field_names_type = tvb_get_guint8(tvb, ofs + O_LBMPDM_DEFN_T_FIELD_NAMES_TYPE); + def->fixed_req_section_len = lbmpdm_fetch_uint32_encoded(tvb, ofs + O_LBMPDM_DEFN_T_FIXED_REQ_SECTION_LEN, encoding); + def->first_fixed_required = NULL; + def->fixed_required_count = 0; + } + } + ofs += L_LBMPDM_DEFN_T; + remaining_datalen = seglen - L_LBMPDM_SEG_HDR_T - L_LBMPDM_DEFN_T; + while ((remaining_datalen > 0) && (num_fields > 0)) + { + proto_item * field_item = NULL; + proto_tree * field_tree = NULL; + guint32 def_len = L_LBMPDM_FIELD_INFO_T_INT_NAME; + int def_ofs = 0; + int type_ofs = L_LBMPDM_FIELD_INFO_T; + guint32 string_name_len = 0; + int string_name_ofs = -1; + + if (string_field_name) + { + def_len = lbmpdm_fetch_uint32_encoded(tvb, ofs, encoding) + sizeof(guint32); + } + field_item = proto_tree_add_item(subtree, hf_lbmpdm_segment_def_field, tvb, ofs, def_len, ENC_NA); + field_tree = proto_item_add_subtree(field_item, ett_lbmpdm_segment_def_field); + if (string_field_name) + { + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_def_len, tvb, ofs, sizeof(guint32), encoding); + def_ofs = sizeof(guint32); + type_ofs += def_ofs; + } + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_id, tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_ID, L_LBMPDM_FIELD_INFO_T_ID, encoding); + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_len, tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_LEN, L_LBMPDM_FIELD_INFO_T_LEN, encoding); + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_fixed_str_len, tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_FIXED_STR_LEN, L_LBMPDM_FIELD_INFO_T_FIXED_STR_LEN, encoding); + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_num_arr_elem, tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_NUM_ARR_ELEM, L_LBMPDM_FIELD_INFO_T_NUM_ARR_ELEM, encoding); + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_req, tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_REQ, L_LBMPDM_FIELD_INFO_T_REQ, encoding); + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_fixed, tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_FIXED, L_LBMPDM_FIELD_INFO_T_FIXED, encoding); + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_fld_int_name, tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_FLD_INT_NAME, L_LBMPDM_FIELD_INFO_T_FLD_INT_NAME, encoding); + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_str_name_len, tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_STR_NAME_LEN, L_LBMPDM_FIELD_INFO_T_STR_NAME_LEN, encoding); + if (string_field_name) + { + string_name_len = lbmpdm_fetch_uint32_encoded(tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_STR_NAME_LEN, encoding); + if (string_name_len > 0) + { + string_name_ofs = ofs + def_ofs + L_LBMPDM_FIELD_INFO_T; + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_str_name, tvb, string_name_ofs, (int)string_name_len, ENC_ASCII|ENC_NA); + type_ofs += string_name_len; + } + } + proto_tree_add_item(field_tree, hf_lbmpdm_segment_def_field_fld_type, tvb, ofs + type_ofs, sizeof(guint16), encoding); + if (add_definition && (def != NULL)) + { + lbmpdm_definition_field_t * field = NULL; + guint32 field_id; + + field_id = lbmpdm_fetch_uint32_encoded(tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_ID, encoding); + field = lbmpdm_definition_field_find(def, field_id); + if (field == NULL) + { + field = lbmpdm_definition_field_add(def, field_id); + if (field != NULL) + { + field->len = lbmpdm_fetch_uint32_encoded(tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_LEN, encoding); + field->fixed_string_len = lbmpdm_fetch_uint32_encoded(tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_FIXED_STR_LEN, encoding); + field->num_array_elem = lbmpdm_fetch_uint32_encoded(tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_NUM_ARR_ELEM, encoding); + field->required = tvb_get_guint8(tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_REQ); + field->fixed = tvb_get_guint8(tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_FIXED); + field->field_int_name = lbmpdm_fetch_uint32_encoded(tvb, ofs + def_ofs + O_LBMPDM_FIELD_INFO_T_FLD_INT_NAME, encoding); + if (string_field_name && (string_name_len > 0)) + { + field->field_string_name_len = string_name_len; + field->field_string_name = tvb_get_string_enc(wmem_file_scope(), tvb, string_name_ofs, string_name_len, ENC_ASCII); + } + else + { + field->field_string_name_len = 0; + field->field_string_name = NULL; + } + field->field_type = lbmpdm_fetch_uint16_encoded(tvb, ofs + type_ofs, encoding); + switch (field->field_type) + { + case PDM_TYPE_BOOLEAN: + case PDM_TYPE_BOOLEAN_ARR: + field->base_type = PDM_TYPE_BOOLEAN; + break; + case PDM_TYPE_INT8: + case PDM_TYPE_INT8_ARR: + field->base_type = PDM_TYPE_INT8; + break; + case PDM_TYPE_UINT8: + case PDM_TYPE_UINT8_ARR: + field->base_type = PDM_TYPE_UINT8; + break; + case PDM_TYPE_INT16: + case PDM_TYPE_INT16_ARR: + field->base_type = PDM_TYPE_INT16; + break; + case PDM_TYPE_UINT16: + case PDM_TYPE_UINT16_ARR: + field->base_type = PDM_TYPE_UINT16; + break; + case PDM_TYPE_INT32: + case PDM_TYPE_INT32_ARR: + field->base_type = PDM_TYPE_INT32; + break; + case PDM_TYPE_UINT32: + case PDM_TYPE_UINT32_ARR: + field->base_type = PDM_TYPE_UINT32; + break; + case PDM_TYPE_INT64: + case PDM_TYPE_INT64_ARR: + field->base_type = PDM_TYPE_INT64; + break; + case PDM_TYPE_UINT64: + case PDM_TYPE_UINT64_ARR: + field->base_type = PDM_TYPE_UINT64; + break; + case PDM_TYPE_FLOAT: + case PDM_TYPE_FLOAT_ARR: + field->base_type = PDM_TYPE_FLOAT; + break; + case PDM_TYPE_DOUBLE: + case PDM_TYPE_DOUBLE_ARR: + field->base_type = PDM_TYPE_DOUBLE; + break; + case PDM_TYPE_DECIMAL: + case PDM_TYPE_DECIMAL_ARR: + field->base_type = PDM_TYPE_DECIMAL; + break; + case PDM_TYPE_TIMESTAMP: + case PDM_TYPE_TIMESTAMP_ARR: + field->base_type = PDM_TYPE_TIMESTAMP; + break; + case PDM_TYPE_FIX_STRING: + case PDM_TYPE_FIX_STRING_ARR: + field->base_type = PDM_TYPE_FIX_STRING; + break; + case PDM_TYPE_STRING: + case PDM_TYPE_STRING_ARR: + field->base_type = PDM_TYPE_STRING; + break; + case PDM_TYPE_FIX_UNICODE: + case PDM_TYPE_FIX_UNICODE_ARR: + field->base_type = PDM_TYPE_FIX_UNICODE; + break; + case PDM_TYPE_UNICODE: + case PDM_TYPE_UNICODE_ARR: + field->base_type = PDM_TYPE_UNICODE; + break; + case PDM_TYPE_BLOB: + case PDM_TYPE_BLOB_ARR: + default: + field->base_type = PDM_TYPE_BLOB; + break; + case PDM_TYPE_MESSAGE: + case PDM_TYPE_MESSAGE_ARR: + field->base_type = PDM_TYPE_MESSAGE; + break; + } + if ((field->fixed == PDM_DEFN_FIXED_LENGTH_FIELD) && (field->required == PDM_DEFN_REQUIRED_FIELD)) + { + if (last_fixed_required_field == NULL) + { + def->first_fixed_required = field; + field->fixed_required_offset = 0; + } + else + { + last_fixed_required_field->next_fixed_required = field; + field->fixed_required_offset = last_fixed_required_field->fixed_required_offset + last_fixed_required_field->len; + } + last_fixed_required_field = field; + def->fixed_required_count++; + } + } + } + } + ofs += def_len; + remaining_datalen -= def_len; + num_fields--; + } + return (seglen); +} + +static int dissect_segment_unknown(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, int encoding) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + int datalen = 0; + int seglen = 0; + + seglen = lbmpdm_get_segment_length(tvb, offset, encoding, &datalen); + subtree_item = proto_tree_add_none_format(tree, hf_lbmpdm_segment, tvb, offset, seglen, "Unknown Segment"); + subtree = proto_item_add_subtree(subtree_item, ett_lbmpdm_segment); + proto_tree_add_item(subtree, hf_lbmpdm_segment_next_hdr, tvb, offset + O_LBMPDM_SEG_HDR_T_NEXT_HDR, L_LBMPDM_SEG_HDR_T_NEXT_HDR, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_flags, tvb, offset + O_LBMPDM_SEG_HDR_T_FLAGS, L_LBMPDM_SEG_HDR_T_FLAGS, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_res, tvb, offset + O_LBMPDM_SEG_HDR_T_RES, L_LBMPDM_SEG_HDR_T_RES, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_len, tvb, offset + O_LBMPDM_SEG_HDR_T_LEN, L_LBMPDM_SEG_HDR_T_LEN, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_segment_data, tvb, offset + L_LBMPDM_SEG_HDR_T, datalen, ENC_NA); + return (seglen); +} + +static gboolean check_lbmpdm_encoding(tvbuff_t * tvb, int offset, int * encoding) +{ + guint8 magic_byte_1; + guint8 magic_byte_2; + guint8 magic_byte_3; + guint8 magic_byte_4; + gboolean result = TRUE; + + magic_byte_1 = tvb_get_guint8(tvb, offset); + magic_byte_2 = tvb_get_guint8(tvb, offset + 1); + magic_byte_3 = tvb_get_guint8(tvb, offset + 2); + magic_byte_4 = tvb_get_guint8(tvb, offset + 3); + if ((magic_byte_1 == PDM_MSG_HDR_BE_MAGIC_BYTE_1) && (magic_byte_2 == PDM_MSG_HDR_BE_MAGIC_BYTE_2) + && (magic_byte_3 == PDM_MSG_HDR_BE_MAGIC_BYTE_3) && (magic_byte_4 == PDM_MSG_HDR_BE_MAGIC_BYTE_4)) + { + *encoding = ENC_BIG_ENDIAN; + } + else if ((magic_byte_1 == PDM_MSG_HDR_LE_MAGIC_BYTE_1) && (magic_byte_2 == PDM_MSG_HDR_LE_MAGIC_BYTE_2) + && (magic_byte_3 == PDM_MSG_HDR_LE_MAGIC_BYTE_3) && (magic_byte_4 == PDM_MSG_HDR_LE_MAGIC_BYTE_4)) + { + *encoding = ENC_LITTLE_ENDIAN; + } + else + { + result = FALSE; + } + return (result); +} + +gboolean lbmpdm_verify_payload(tvbuff_t * tvb, int offset, int * encoding, int * length) +{ + guint8 next_header; + guint32 len = 0; + + if (!tvb_bytes_exist(tvb, offset, L_LBMPDM_MSG_HDR_T)) + { + return (FALSE); + } + if (!check_lbmpdm_encoding(tvb, offset, encoding)) + { + return (FALSE); + } + next_header = tvb_get_guint8(tvb, offset + O_LBMPDM_MSG_HDR_T_NEXT_HDR); + switch (next_header) + { + case PDM_HDR_TYPE_DATA: + case PDM_HDR_TYPE_OFSTTBLE: + case PDM_HDR_TYPE_DEFN: + case PDM_HDR_TYPE_EOM: + break; + default: + return (FALSE); + break; + } + len = lbmpdm_fetch_uint32_encoded(tvb, offset + O_LBMPDM_MSG_HDR_T_LEN, *encoding); + if (len > G_MAXINT) + { + return (FALSE); + } + *length = (int)len; + return (TRUE); +} + +int lbmpdm_dissect_lbmpdm_payload(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, guint64 channel) +{ + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + proto_item * ver_type_item = NULL; + proto_tree * ver_type_tree = NULL; + proto_item * segments_item = NULL; + proto_tree * segments_tree = NULL; + proto_item * pi = NULL; + guint8 type; + guint8 version; + guint8 ver_type; + guint8 next_hdr; + int dissected_len = 0; + int encoding; + int msglen = 0; + int len_remaining = 0; + int ofs = 0; + int segment_len = 0; + int datalen = 0; + guint32 raw_msglen = 0; + lbmpdm_msg_definition_id_t msgid; + + if (!lbmpdm_verify_payload(tvb, offset, &encoding, &raw_msglen)) + { + return (0); + } + msglen = (int)raw_msglen; + + msgid.channel = channel; + msgid.msg_def_id = 0; + msgid.ver_major = 0; + msgid.ver_minor = 0; + msgid.offset_table = NULL; + subtree_item = proto_tree_add_protocol_format(tree, proto_lbmpdm, tvb, offset, msglen, "LBMPDM Protocol"); + subtree = proto_item_add_subtree(subtree_item, ett_lbmpdm); + proto_tree_add_item(subtree, hf_lbmpdm_magic, tvb, offset + O_LBMPDM_MSG_HDR_T_MAGIC, L_LBMPDM_MSG_HDR_T_MAGIC, encoding); + pi = proto_tree_add_string(subtree, hf_lbmpdm_encoding, tvb, offset + O_LBMPDM_MSG_HDR_T_MAGIC, L_LBMPDM_MSG_HDR_T_MAGIC, + ((encoding == ENC_BIG_ENDIAN) ? "Big-Endian" : "Little-Endian")); + PROTO_ITEM_SET_GENERATED(pi); + ver_type = tvb_get_guint8(tvb, offset + O_LBMPDM_MSG_HDR_T_VER_TYPE); + version = PDM_HDR_VER(ver_type); + type = PDM_HDR_TYPE(ver_type); + ver_type_item = proto_tree_add_none_format(subtree, hf_lbmpdm_ver_type, tvb, offset + O_LBMPDM_MSG_HDR_T_VER_TYPE, + L_LBMPDM_MSG_HDR_T_VER_TYPE, "Version/Type: 0x%02x (Version:%u, Type:%u)", ver_type, version, type); + ver_type_tree = proto_item_add_subtree(ver_type_item, ett_lbmpdm_ver_type); + proto_tree_add_item(ver_type_tree, hf_lbmpdm_ver_type_ver, tvb, offset + O_LBMPDM_MSG_HDR_T_VER_TYPE, L_LBMPDM_MSG_HDR_T_VER_TYPE, encoding); + proto_tree_add_item(ver_type_tree, hf_lbmpdm_ver_type_type, tvb, offset + O_LBMPDM_MSG_HDR_T_VER_TYPE, L_LBMPDM_MSG_HDR_T_VER_TYPE, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_next_hdr, tvb, offset + O_LBMPDM_MSG_HDR_T_NEXT_HDR, L_LBMPDM_MSG_HDR_T_NEXT_HDR, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_def_major_ver, tvb, offset + O_LBMPDM_MSG_HDR_T_DEF_MAJOR_VER, L_LBMPDM_MSG_HDR_T_DEF_MAJOR_VER, encoding); + msgid.ver_major = tvb_get_guint8(tvb, offset + O_LBMPDM_MSG_HDR_T_DEF_MAJOR_VER); + proto_tree_add_item(subtree, hf_lbmpdm_def_minor_ver, tvb, offset + O_LBMPDM_MSG_HDR_T_DEF_MINOR_VER, L_LBMPDM_MSG_HDR_T_DEF_MINOR_VER, encoding); + msgid.ver_minor = tvb_get_guint8(tvb, offset + O_LBMPDM_MSG_HDR_T_DEF_MINOR_VER); + proto_tree_add_item(subtree, hf_lbmpdm_def_id, tvb, offset + O_LBMPDM_MSG_HDR_T_DEF_ID, L_LBMPDM_MSG_HDR_T_DEF_ID, encoding); + msgid.msg_def_id = lbmpdm_fetch_uint32_encoded(tvb, offset + O_LBMPDM_MSG_HDR_T_DEF_ID, encoding); + proto_tree_add_item(subtree, hf_lbmpdm_len, tvb, offset + O_LBMPDM_MSG_HDR_T_LEN, L_LBMPDM_MSG_HDR_T_LEN, encoding); + + next_hdr = tvb_get_guint8(tvb, offset + O_LBMPDM_MSG_HDR_T_NEXT_HDR); + len_remaining = msglen - L_LBMPDM_MSG_HDR_T; + ofs = offset + L_LBMPDM_MSG_HDR_T; + dissected_len = L_LBMPDM_MSG_HDR_T; + datalen = msglen - L_LBMPDM_MSG_HDR_T; + if (len_remaining > 0) + { + guint8 this_hdr = next_hdr; + + segments_item = proto_tree_add_item(subtree, hf_lbmpdm_segments, tvb, ofs, datalen, encoding); + segments_tree = proto_item_add_subtree(segments_item, ett_lbmpdm_segments); + while ((this_hdr != PDM_HDR_TYPE_EOM) && (len_remaining >= L_LBMPDM_SEG_HDR_T)) + { + next_hdr = tvb_get_guint8(tvb, ofs + O_LBMPDM_SEG_HDR_T_NEXT_HDR); + switch (this_hdr) + { + case PDM_HDR_TYPE_DATA: + segment_len = dissect_segment_data(tvb, ofs, pinfo, segments_tree, &msgid, encoding); + break; + case PDM_HDR_TYPE_OFSTTBLE: + segment_len = dissect_segment_ofstable(tvb, ofs, pinfo, segments_tree, &(msgid.offset_table), encoding); + break; + case PDM_HDR_TYPE_DEFN: + segment_len = dissect_segment_defn(tvb, ofs, pinfo, segments_tree, channel, encoding); + break; + default: + segment_len = dissect_segment_unknown(tvb, ofs, pinfo, segments_tree, encoding); + break; + } + this_hdr = next_hdr; + dissected_len += segment_len; + len_remaining -= segment_len; + ofs += segment_len; + } + } + return (dissected_len); +} + +/* The registration hand-off routine */ +void proto_reg_handoff_lbmpdm(void) +{ + static gboolean already_registered = FALSE; + + if (!already_registered) + {} + + already_registered = TRUE; +} + +/* Register all the bits needed with the filtering engine */ +void proto_register_lbmpdm(void) +{ + static hf_register_info hf[] = + { + { &hf_lbmpdm_magic, + { "Magic", "lbmpdm.magic", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_encoding, + { "Encoding", "lbmpdm.encoding", FT_STRING, BASE_NONE, NULL, 0x0, "encoding as determined by magic number", HFILL } }, + { &hf_lbmpdm_ver_type, + { "Version/Type", "lbmpdm.ver_type", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_ver_type_ver, + { "Version", "lbmpdm.ver_type.ver", FT_UINT8, BASE_DEC, NULL, PDM_HDR_VER_TYPE_VER_MASK, NULL, HFILL } }, + { &hf_lbmpdm_ver_type_type, + { "Type", "lbmpdm.ver_type.type", FT_UINT8, BASE_DEC, NULL, PDM_HDR_VER_TYPE_TYPE_MASK, NULL, HFILL } }, + { &hf_lbmpdm_next_hdr, + { "Next Header", "lbmpdm.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmpdm_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmpdm_def_major_ver, + { "Definition Major Version", "lbmpdm.def_major_ver", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_def_minor_ver, + { "Definition Minor Version", "lbmpdm.def_minor_ver", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_def_id, + { "Definition ID", "lbmpdm.def_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_len, + { "Length", "lbmpdm.len", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segments, + { "Segments", "lbmpdm.segments", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment, + { "Segment", "lbmpdm.segment", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_next_hdr, + { "Next Header", "lbmpdm.segment.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbmpdm_next_header), 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_flags, + { "Flags", "lbmpdm.segment.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_res, + { "Reserved", "lbmpdm.segment.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_len, + { "Length", "lbmpdm.segment.len", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_id, + { "Definition ID", "lbmpdm.segment_def.id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_num_fields, + { "Number Of Fields", "lbmpdm.segment_def.num_fields", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_names_type, + { "Field Names Type", "lbmpdm.segment_def.field_names_type", FT_UINT8, BASE_HEX, VALS(lbmpdm_field_name_type), 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_finalized, + { "Finalized", "lbmpdm.segment_def.finalized", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_msg_vers_major, + { "Definition Major Version", "lbmpdm.segment_def.msg_vers_major", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_msg_vers_minor, + { "Definition Minor Version", "lbmpdm.segment_def.msg_vers_minor", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_fixed_req_section_len, + { "Fixed Required Section Length", "lbmpdm.segment_def.fixed_req_section_len", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_info_len, + { "Field Information Length", "lbmpdm.segment_def.field_info_len", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field, + { "Field Definition", "lbmpdm.segment_def.field", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_def_len, + { "Definition Length", "lbmpdm.segment_def.field.def_len", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_id, + { "ID", "lbmpdm.segment_def.field.id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_len, + { "Length", "lbmpdm.segment_def.field.len", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_fixed_str_len, + { "Fixed String Length", "lbmpdm.segment_def.field.fixed_str_len", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_num_arr_elem, + { "Number Of Array Elements", "lbmpdm.segment_def.field.num_arr_elem", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_req, + { "Required", "lbmpdm.segment_def.field.req", FT_UINT8, BASE_HEX, VALS(lbmpdm_field_required), 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_fixed, + { "Fixed Length Field", "lbmpdm.segment_def.field.fixed", FT_UINT8, BASE_HEX, VALS(lbmpdm_field_fixed_length), 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_fld_int_name, + { "Field Integer Name", "lbmpdm.segment_def.field.fld_int_name", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_str_name_len, + { "String Name Length", "lbmpdm.segment_def.field.str_name_len", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_str_name, + { "String Name", "lbmpdm.segment_def.field.str_name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_def_field_fld_type, + { "Field Type", "lbmpdm.segment_def.field.fld_type", FT_UINT16, BASE_DEC_HEX, VALS(lbmpdm_field_type), 0x0, NULL, HFILL } }, + { &hf_lbmpdm_offset_entry, + { "Offset Entry", "lbmpdm.segment_ofs.entry", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_offset_entry_id, + { "ID", "lbmpdm.segment_ofs.entry.id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_offset_entry_offset, + { "Offset", "lbmpdm.segment_ofs.entry.offset", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_segment_data, + { "Data", "lbmpdm.segment.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field, + { "Field", "lbmpdm.field", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_id, + { "ID", "lbmpdm.field.id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_string_name, + { "String Name", "lbmpdm.field.string_name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_int_name, + { "Integer Name", "lbmpdm.field.int_name", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_type, + { "Type", "lbmpdm.field.type", FT_UINT16, BASE_DEC_HEX, VALS(lbmpdm_field_type), 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_total_length, + { "Total Length", "lbmpdm.field.total_length", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_length, + { "Length", "lbmpdm.field.length", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_boolean, + { "Boolean Value", "lbmpdm.field.value_boolean", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_int8, + { "INT8 Value", "lbmpdm.field.value_int8", FT_INT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_uint8, + { "UINT8 Value", "lbmpdm.field.value_uint8", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_int16, + { "INT16 Value", "lbmpdm.field.value_int16", FT_INT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_uint16, + { "UINT16 Value", "lbmpdm.field.value_uint16", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_int32, + { "INT32 Value", "lbmpdm.field.value_int32", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_uint32, + { "UINT32 Value", "lbmpdm.field.value_uint32", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_int64, + { "INT64 Value", "lbmpdm.field.value_int64", FT_INT64, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_uint64, + { "UINT64 Value", "lbmpdm.field.value_uint64", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_float, + { "FLOAT Value", "lbmpdm.field.value_float", FT_FLOAT, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_double, + { "DOUBLE Value", "lbmpdm.field.value_double", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_decimal, + { "DECIMAL Value", "lbmpdm.field.value_decimal", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_timestamp, + { "TIMESTAMP Value", "lbmpdm.field.value_timestamp", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_fixed_string, + { "FIXED STRING Value", "lbmpdm.field.value_fixed_string", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_string, + { "STRING Value", "lbmpdm.field.value_string", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_fixed_unicode, + { "FIXED UNICODE Value", "lbmpdm.field.value_fixed_unicode", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_unicode, + { "UNICODE Value", "lbmpdm.field.value_unicode", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_blob, + { "BLOB Value", "lbmpdm.field.value_blob", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_field_value_message, + { "MESSAGE Value", "lbmpdm.field.value_message", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } } + }; + static gint * ett[] = + { + &ett_lbmpdm, + &ett_lbmpdm_ver_type, + &ett_lbmpdm_segments, + &ett_lbmpdm_segment, + &ett_lbmpdm_offset_entry, + &ett_lbmpdm_segment_def_field, + &ett_lbmpdm_field + }; + + proto_lbmpdm = proto_register_protocol("LBMPDM Protocol", "LBMPDM", "lbmpdm"); + + proto_register_field_array(proto_lbmpdm, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + lbmpdm_definition_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); +} + +int lbmpdm_get_minimum_length(void) +{ + return (L_LBMPDM_MSG_HDR_T); +} + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbmpdmtcp.c b/epan/dissectors/packet-lbmpdmtcp.c new file mode 100644 index 0000000000..609f990a5d --- /dev/null +++ b/epan/dissectors/packet-lbmpdmtcp.c @@ -0,0 +1,467 @@ +/* packet-lbmpdmtcp.c + * Routines for LBM PDM-over-TCP Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "packet-lbm.h" + +/* Protocol handle */ +static int lbmpdm_tcp_protocol_handle = -1; + +/* Dissector handle */ +static dissector_handle_t lbmpdm_tcp_dissector_handle; + +/*----------------------------------------------------------------------------*/ +/* LBM-TCP transport management. */ +/*----------------------------------------------------------------------------*/ + +typedef struct +{ + address addr1; + guint16 port1; + address addr2; + guint16 port2; + guint64 channel; +} lbmtcp_transport_t; + +static void lbmtcp_order_key(lbmtcp_transport_t * transport) +{ + gboolean swap = FALSE; + int compare; + + /* Order the key so that addr1:port1 <= addr2:port2 */ + compare = CMP_ADDRESS(&(transport->addr1), &(transport->addr2)); + if (compare > 0) + { + swap = TRUE; + } + else if (compare == 0) + { + if (transport->port1 > transport->port2) + { + swap = TRUE; + } + } + if (swap) + { + address addr; + guint16 port; + + COPY_ADDRESS_SHALLOW(&addr, &(transport->addr1)); + COPY_ADDRESS_SHALLOW(&(transport->addr2), &(transport->addr1)); + COPY_ADDRESS_SHALLOW(&(transport->addr1), &addr); + port = transport->port2; + transport->port2 = transport->port1; + transport->port1 = port; + } +} + +static lbmtcp_transport_t * lbmtcp_transport_add(const address * address1, guint16 port1, const address * address2, guint16 port2, guint32 frame) +{ + lbmtcp_transport_t * entry; + conversation_t * conv = NULL; + + conv = find_conversation(frame, address1, address2, PT_TCP, port1, port2, 0); + if (conv == NULL) + { + conv = conversation_new(frame, address1, address2, PT_TCP, port1, port2, 0); + } + entry = (lbmtcp_transport_t *) conversation_get_proto_data(conv, lbmpdm_tcp_protocol_handle); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbmtcp_transport_t); + SE_COPY_ADDRESS(&(entry->addr1), address1); + entry->port1 = port1; + SE_COPY_ADDRESS(&(entry->addr2), address2); + entry->port2 = port2; + lbmtcp_order_key(entry); + entry->channel = lbm_channel_assign(LBM_CHANNEL_TCP); + conversation_add_proto_data(conv, lbmpdm_tcp_protocol_handle, (void *) entry); + return (entry); +} + +/*----------------------------------------------------------------------------*/ +/* Preferences. */ +/*----------------------------------------------------------------------------*/ + +/* Preferences default values. */ +#define LBMPDM_TCP_DEFAULT_PORT_LOW 14371 +#define LBMPDM_TCP_DEFAULT_PORT_HIGH 14390 + +/* Global preferences variables (altered by the preferences dialog). */ +static guint32 global_lbmpdm_tcp_port_low = LBMPDM_TCP_DEFAULT_PORT_LOW; +static guint32 global_lbmpdm_tcp_port_high = LBMPDM_TCP_DEFAULT_PORT_HIGH; +static gboolean global_lbmpdm_tcp_use_tag = FALSE; + +/* Local preferences variables (used by the dissector). */ +static guint32 lbmpdm_tcp_port_low = LBMPDM_TCP_DEFAULT_PORT_LOW; +static guint32 lbmpdm_tcp_port_high = LBMPDM_TCP_DEFAULT_PORT_HIGH; +static gboolean lbmpdm_tcp_use_tag = FALSE; + +/* Tag definitions. */ +typedef struct +{ + char * name; + guint32 port_low; + guint32 port_high; +} lbmpdm_tcp_tag_entry_t; + +static lbmpdm_tcp_tag_entry_t * lbmpdm_tcp_tag_entry = NULL; +static guint lbmpdm_tcp_tag_count = 0; + +UAT_CSTRING_CB_DEF(lbmpdm_tcp_tag, name, lbmpdm_tcp_tag_entry_t) +UAT_DEC_CB_DEF(lbmpdm_tcp_tag, port_low, lbmpdm_tcp_tag_entry_t) +UAT_DEC_CB_DEF(lbmpdm_tcp_tag, port_high, lbmpdm_tcp_tag_entry_t) +static uat_field_t lbmpdm_tcp_tag_array[] = +{ + UAT_FLD_CSTRING(lbmpdm_tcp_tag, name, "Tag name", "Tag name"), + UAT_FLD_DEC(lbmpdm_tcp_tag, port_low, "Port low", "Port low"), + UAT_FLD_DEC(lbmpdm_tcp_tag, port_high, "Port high", "Port high"), + UAT_END_FIELDS +}; + +/*----------------------------------------------------------------------------*/ +/* UAT callback functions. */ +/*----------------------------------------------------------------------------*/ +static void lbmpdm_tcp_tag_update_cb(void * record, const char * * error_string) +{ + lbmpdm_tcp_tag_entry_t * tag = (lbmpdm_tcp_tag_entry_t *)record; + + if (tag->name == NULL) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + else + { + g_strstrip(tag->name); + if (tag->name[0] == 0) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + } +} + +static void * lbmpdm_tcp_tag_copy_cb(void * destination, const void * source, size_t length _U_) +{ + const lbmpdm_tcp_tag_entry_t * src = (const lbmpdm_tcp_tag_entry_t *)source; + lbmpdm_tcp_tag_entry_t * dest = (lbmpdm_tcp_tag_entry_t *)destination; + + dest->name = g_strdup(src->name); + dest->port_low = src->port_low; + dest->port_high = src->port_high; + return (dest); +} + +static void lbmpdm_tcp_tag_free_cb(void * record) +{ + lbmpdm_tcp_tag_entry_t * tag = (lbmpdm_tcp_tag_entry_t *)record; + + if (tag->name != NULL) + { + g_free(tag->name); + tag->name = NULL; + } +} + +static const lbmpdm_tcp_tag_entry_t * lbmpdm_tcp_tag_locate(packet_info * pinfo) +{ + guint idx; + const lbmpdm_tcp_tag_entry_t * tag = NULL; + + if (!lbmpdm_tcp_use_tag) + { + return (NULL); + } + + for (idx = 0; idx < lbmpdm_tcp_tag_count; ++idx) + { + tag = &(lbmpdm_tcp_tag_entry[idx]); + if (((pinfo->srcport >= tag->port_low) && (pinfo->srcport <= tag->port_high)) + || ((pinfo->destport >= tag->port_low) && (pinfo->destport <= tag->port_high))) + { + return (tag); + } + } + return (NULL); +} + +static char * lbmpdm_tcp_tag_find(packet_info * pinfo) +{ + const lbmpdm_tcp_tag_entry_t * tag = NULL; + + if (!lbmpdm_tcp_use_tag) + { + return (NULL); + } + + tag = lbmpdm_tcp_tag_locate(pinfo); + if (tag != NULL) + { + return tag->name; + } + return (NULL); +} + +/*----------------------------------------------------------------------------*/ +/* Handles of all types. */ +/*----------------------------------------------------------------------------*/ + +/* Dissector tree handles */ +static int ett_lbmpdm_tcp = -1; + +/* Dissector field handles */ +static int hf_lbmpdm_tcp_tag = -1; +static int hf_lbmpdm_tcp_channel = -1; + +static guint get_lbmpdm_tcp_pdu_length(packet_info * pinfo _U_, tvbuff_t * tvb, int offset) +{ + int encoding; + int packet_len = 0; + packet_len = 0; + + if (!lbmpdm_verify_payload(tvb, offset, &encoding, &packet_len)) + { + packet_len = 0; + } + return (packet_len); +} + +static int dissect_lbmpdm_tcp_pdu(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * dissector_data _U_) +{ + proto_tree * lbmpdm_tcp_tree = NULL; + proto_item * ti = NULL; + lbmtcp_transport_t * transport = NULL; + char * tag_name = NULL; + guint64 channel = LBM_CHANNEL_NO_CHANNEL; + + if (lbmpdm_tcp_use_tag) + { + tag_name = lbmpdm_tcp_tag_find(pinfo); + } + if (tag_name != NULL) + { + ti = proto_tree_add_protocol_format(tree, lbmpdm_tcp_protocol_handle, tvb, 0, -1, "LBMPDM-TCP Protocol (Tag: %s)", tag_name); + } + else + { + ti = proto_tree_add_protocol_format(tree, lbmpdm_tcp_protocol_handle, tvb, 0, -1, "LBMPDM-TCP Protocol"); + } + lbmpdm_tcp_tree = proto_item_add_subtree(ti, ett_lbmpdm_tcp); + + transport = lbmtcp_transport_add(&(pinfo->src), pinfo->srcport, &(pinfo->dst), pinfo->destport, pinfo->fd->num); + if (transport != NULL) + { + channel = transport->channel; + } + if (tag_name != NULL) + { + proto_item * item = NULL; + + item = proto_tree_add_string(lbmpdm_tcp_tree, hf_lbmpdm_tcp_tag, tvb, 0, 0, tag_name); + PROTO_ITEM_SET_GENERATED(item); + } + if (channel != LBM_CHANNEL_NO_CHANNEL) + { + proto_item * item = NULL; + + item = proto_tree_add_uint64(lbmpdm_tcp_tree, hf_lbmpdm_tcp_channel, tvb, 0, 0, channel); + PROTO_ITEM_SET_GENERATED(item); + } + return (lbmpdm_dissect_lbmpdm_payload(tvb, 0, pinfo, tree, channel)); +} + +/* + * dissect_lbmpdm_tcp - The dissector for LBMPDM over TCP + */ +static void dissect_lbmpdm_tcp(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree) +{ + char * tag_name = NULL; + + col_add_str(pinfo->cinfo, COL_PROTOCOL, "LBMPDM-TCP"); + col_clear(pinfo->cinfo, COL_INFO); + if (lbmpdm_tcp_use_tag) + { + tag_name = lbmpdm_tcp_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, lbmpdm_get_minimum_length(), /* Need at least the msglen */ + get_lbmpdm_tcp_pdu_length, dissect_lbmpdm_tcp_pdu, NULL); +} + +static gboolean test_lbmpdm_tcp_packet(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * user_data _U_) +{ + int encoding = 0; + int packet_len = 0; + + /* Must be a TCP packet. */ + if (pinfo->ptype != PT_TCP) + { + return (FALSE); + } + /* Destination address must be IPV4 and 4 bytes in length. */ + if ((pinfo->dst.type != AT_IPv4) || (pinfo->dst.len != 4)) + { + return (FALSE); + } + if (!lbmpdm_verify_payload(tvb, 0, &encoding, &packet_len)) + { + return (FALSE); + } + if (lbmpdm_tcp_use_tag) + { + if (lbmpdm_tcp_tag_find(pinfo) != NULL) + { + dissect_lbmpdm_tcp(tvb, pinfo, tree); + return (TRUE); + } + else + { + return (FALSE); + } + } + + /* Source port or destination port must be in the specified range. */ + if (!(((pinfo->srcport >= lbmpdm_tcp_port_low) && (pinfo->srcport <= lbmpdm_tcp_port_high)) + || ((pinfo->destport >= lbmpdm_tcp_port_low) && (pinfo->destport <= lbmpdm_tcp_port_high)))) + { + return (FALSE); + } + /* One of ours. Probably. */ + dissect_lbmpdm_tcp(tvb, pinfo, tree); + return (TRUE); +} + +/* The registration hand-off routine */ +void proto_reg_handoff_lbmpdm_tcp(void) +{ + static gboolean already_registered = FALSE; + + if (!already_registered) + { + lbmpdm_tcp_dissector_handle = create_dissector_handle(dissect_lbmpdm_tcp, lbmpdm_tcp_protocol_handle); + dissector_add_uint("tcp.port", 0, lbmpdm_tcp_dissector_handle); + heur_dissector_add("tcp", test_lbmpdm_tcp_packet, lbmpdm_tcp_protocol_handle); + } + + /* Make sure the port low is <= the port high. If not, don't change them. */ + if (global_lbmpdm_tcp_port_low <= global_lbmpdm_tcp_port_high) + { + lbmpdm_tcp_port_low = global_lbmpdm_tcp_port_low; + lbmpdm_tcp_port_high = global_lbmpdm_tcp_port_high; + } + + lbmpdm_tcp_use_tag = global_lbmpdm_tcp_use_tag; + + already_registered = TRUE; +} + +/* Register all the bits needed with the filtering engine */ +void proto_register_lbmpdm_tcp(void) +{ + static hf_register_info hf[] = + { + { &hf_lbmpdm_tcp_tag, + { "Tag", "lbmpdm_tcp.tag", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmpdm_tcp_channel, + { "Channel ID", "lbmpdm_tcp.channel", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + }; + static gint * ett[] = + { + &ett_lbmpdm_tcp, + }; + module_t * lbmpdm_tcp_module; + uat_t * tag_uat; + + lbmpdm_tcp_protocol_handle = proto_register_protocol("LBMPDM over TCP Protocol", "LBMPDM-TCP", "lbmpdm_tcp"); + + proto_register_field_array(lbmpdm_tcp_protocol_handle, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + + lbmpdm_tcp_module = prefs_register_protocol_subtree("29West", lbmpdm_tcp_protocol_handle, proto_reg_handoff_lbmpdm_tcp); + prefs_register_uint_preference(lbmpdm_tcp_module, + "port_low", + "Port range low (default " MAKESTRING(LBMPDM_TCP_DEFAULT_PORT_LOW)")", + "Set the low end of the TCP port range", + 10, + &global_lbmpdm_tcp_port_low); + + prefs_register_uint_preference(lbmpdm_tcp_module, + "port_high", + "Port range high (default " MAKESTRING(LBMPDM_TCP_DEFAULT_PORT_HIGH)")", + "Set the high end of the port range", + 10, + &global_lbmpdm_tcp_port_high); + + prefs_register_bool_preference(lbmpdm_tcp_module, + "use_lbmpdm_tcp_domain", + "Use LBMPDM-TCP tag table", + "Use table of LBMPDM-TCP tags to decode the packet instead of above values", + &global_lbmpdm_tcp_use_tag); + tag_uat = uat_new("LBMPDM-TCP tag definitions", + sizeof(lbmpdm_tcp_tag_entry_t), + "lbmpdm_tcp_domains", + TRUE, + (void * *)&lbmpdm_tcp_tag_entry, + &lbmpdm_tcp_tag_count, + UAT_AFFECTS_DISSECTION, + NULL, + lbmpdm_tcp_tag_copy_cb, + lbmpdm_tcp_tag_update_cb, + lbmpdm_tcp_tag_free_cb, + NULL, + lbmpdm_tcp_tag_array); + prefs_register_uat_preference(lbmpdm_tcp_module, + "tnw_lbmpdm_tcp_tags", + "LBMPDM-TCP Tags", + "A table to define LBMPDM-TCP tags", + tag_uat); +} + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbmr.c b/epan/dissectors/packet-lbmr.c new file mode 100644 index 0000000000..de3b98e2f2 --- /dev/null +++ b/epan/dissectors/packet-lbmr.c @@ -0,0 +1,6843 @@ +/* packet-lbmr.c + * Routines for LBM Topic Resolution Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#if HAVE_NETINET_IN_H + #include +#else +typedef unsigned int in_addr_t; +#endif +#if HAVE_WINSOCK2_H + #include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "packet-lbm.h" +#include "packet-lbtru.h" +#include "packet-lbtrm.h" +#include "packet-lbttcp.h" + +#define LBMR_MAX_NAMELEN 256 + +/*----------------------------------------------------------------------------*/ +/* LBT-IPC transport management. */ +/*----------------------------------------------------------------------------*/ + +typedef struct +{ + guint32 host_id; + guint32 session_id; + guint16 xport_id; + guint64 channel; +} lbtipc_transport_t; + +static wmem_tree_t * lbtipc_transport_table = NULL; + +#define LBTIPC_KEY_ELEMENT_COUNT 3 +#define LBTIPC_KEY_ELEMENT_HOST_ID 0 +#define LBTIPC_KEY_ELEMENT_SESSION_ID 1 +#define LBTIPC_KEY_ELEMENT_XPORT_ID 2 + +static void lbtipc_transport_init(void) +{ + lbtipc_transport_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); +} + +static lbtipc_transport_t * lbtipc_transport_find(guint32 host_id, guint32 session_id, guint16 xport_id) +{ + lbtipc_transport_t * entry = NULL; + guint32 keyval[LBTIPC_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + keyval[LBTIPC_KEY_ELEMENT_HOST_ID] = host_id; + keyval[LBTIPC_KEY_ELEMENT_SESSION_ID] = session_id; + keyval[LBTIPC_KEY_ELEMENT_XPORT_ID] = (guint32) xport_id; + tkey[0].length = LBTIPC_KEY_ELEMENT_COUNT; + tkey[0].key = keyval; + tkey[1].length = 0; + tkey[1].key = NULL; + entry = (lbtipc_transport_t *) wmem_tree_lookup32_array(lbtipc_transport_table, tkey); + return (entry); +} + +static lbtipc_transport_t * lbtipc_transport_add(guint32 host_id, guint32 session_id, guint16 xport_id) +{ + lbtipc_transport_t * entry; + guint32 keyval[LBTIPC_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbtipc_transport_find(host_id, session_id, xport_id); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbtipc_transport_t); + entry->host_id = host_id; + entry->session_id = session_id; + entry->xport_id = xport_id; + entry->channel = lbm_channel_assign(LBM_CHANNEL_TRANSPORT_LBTIPC); + keyval[LBTIPC_KEY_ELEMENT_HOST_ID] = host_id; + keyval[LBTIPC_KEY_ELEMENT_SESSION_ID] = session_id; + keyval[LBTIPC_KEY_ELEMENT_XPORT_ID] = (guint32) xport_id; + tkey[0].length = LBTIPC_KEY_ELEMENT_COUNT; + tkey[0].key = keyval; + tkey[1].length = 0; + tkey[1].key = NULL; + wmem_tree_insert32_array(lbtipc_transport_table, tkey, (void *) entry); + return (entry); +} + +static char * lbtipc_transport_source_string(guint32 host_id _U_, guint32 session_id, guint16 xport_id) +{ + return (wmem_strdup_printf(wmem_file_scope(), "LBT-IPC:%x:%" G_GUINT16_FORMAT, session_id, xport_id)); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-SMX transport management. */ +/*----------------------------------------------------------------------------*/ + +typedef struct +{ + guint32 host_id; + guint32 session_id; + guint16 xport_id; + guint64 channel; +} lbtsmx_transport_t; + +static wmem_tree_t * lbtsmx_transport_table = NULL; + +#define LBTSMX_KEY_ELEMENT_COUNT 3 +#define LBTSMX_KEY_ELEMENT_HOST_ID 0 +#define LBTSMX_KEY_ELEMENT_SESSION_ID 1 +#define LBTSMX_KEY_ELEMENT_XPORT_ID 2 + +static void lbtsmx_transport_init(void) +{ + lbtsmx_transport_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); +} + +static lbtsmx_transport_t * lbtsmx_transport_find(guint32 host_id, guint32 session_id, guint16 xport_id) +{ + lbtsmx_transport_t * entry = NULL; + guint32 keyval[LBTSMX_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + keyval[LBTSMX_KEY_ELEMENT_HOST_ID] = host_id; + keyval[LBTSMX_KEY_ELEMENT_SESSION_ID] = session_id; + keyval[LBTSMX_KEY_ELEMENT_XPORT_ID] = (guint32) xport_id; + tkey[0].length = LBTSMX_KEY_ELEMENT_COUNT; + tkey[0].key = keyval; + tkey[1].length = 0; + tkey[1].key = NULL; + entry = (lbtsmx_transport_t *) wmem_tree_lookup32_array(lbtsmx_transport_table, tkey); + return (entry); +} + +static lbtsmx_transport_t * lbtsmx_transport_add(guint32 host_id, guint32 session_id, guint16 xport_id) +{ + lbtsmx_transport_t * entry; + guint32 keyval[LBTSMX_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbtsmx_transport_find(host_id, session_id, xport_id); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbtsmx_transport_t); + entry->host_id = host_id; + entry->session_id = session_id; + entry->xport_id = xport_id; + entry->channel = lbm_channel_assign(LBM_CHANNEL_TRANSPORT_LBTSMX); + keyval[LBTSMX_KEY_ELEMENT_HOST_ID] = host_id; + keyval[LBTSMX_KEY_ELEMENT_SESSION_ID] = session_id; + keyval[LBTSMX_KEY_ELEMENT_XPORT_ID] = (guint32) xport_id; + tkey[0].length = LBTSMX_KEY_ELEMENT_COUNT; + tkey[0].key = keyval; + tkey[1].length = 0; + tkey[1].key = NULL; + wmem_tree_insert32_array(lbtsmx_transport_table, tkey, (void *) entry); + return (entry); +} + +static char * lbtsmx_transport_source_string(guint32 host_id _U_, guint32 session_id, guint16 xport_id) +{ + return (wmem_strdup_printf(wmem_file_scope(), "LBT-SMX:%x:%" G_GUINT16_FORMAT, session_id, xport_id)); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RDMA transport management. */ +/*----------------------------------------------------------------------------*/ + +typedef struct +{ + address source_address; + guint32 session_id; + guint16 port; + guint64 channel; +} lbtrdma_transport_t; + +static wmem_tree_t * lbtrdma_transport_table = NULL; + +#define LBTRDMA_KEY_ELEMENT_COUNT 3 +#define LBTRDMA_KEY_ELEMENT_SOURCE_ADDRESS 0 +#define LBTRDMA_KEY_ELEMENT_SESSION_ID 1 +#define LBTRDMA_KEY_ELEMENT_PORT 2 + +static void lbtrdma_transport_init(void) +{ + lbtrdma_transport_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); +} + +static void lbtrdma_transport_build_key(guint32 * key_value, wmem_tree_key_t * key, const lbtrdma_transport_t * transport) +{ + guint32 val; + + memcpy((void *) &val, (void *) transport->source_address.data, sizeof(guint32)); + key_value[LBTRDMA_KEY_ELEMENT_SOURCE_ADDRESS] = val; + key_value[LBTRDMA_KEY_ELEMENT_SESSION_ID] = transport->session_id; + key_value[LBTRDMA_KEY_ELEMENT_PORT] = (guint32) transport->port; + key[0].length = LBTRDMA_KEY_ELEMENT_COUNT; + key[0].key = key_value; + key[1].length = 0; + key[1].key = NULL; +} + +static lbtrdma_transport_t * lbtrdma_transport_find(const address * source_address, guint32 session_id, guint16 port) +{ + lbtrdma_transport_t key; + lbtrdma_transport_t * entry = NULL; + guint32 keyval[LBTRDMA_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + memset((void *)&key, 0, sizeof(lbtrdma_transport_t)); + COPY_ADDRESS_SHALLOW(&(key.source_address), source_address); + key.session_id = session_id; + key.port = port; + lbtrdma_transport_build_key(keyval, tkey, &key); + entry = (lbtrdma_transport_t *) wmem_tree_lookup32_array(lbtrdma_transport_table, tkey); + return (entry); +} + +static lbtrdma_transport_t * lbtrdma_transport_add(const address * source_address, guint32 session_id, guint16 port) +{ + lbtrdma_transport_t * entry; + guint32 keyval[LBTRDMA_KEY_ELEMENT_COUNT]; + wmem_tree_key_t tkey[2]; + + entry = lbtrdma_transport_find(source_address, session_id, port); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbtrdma_transport_t); + SE_COPY_ADDRESS(&(entry->source_address), source_address); + entry->session_id = session_id; + entry->port = port; + entry->channel = lbm_channel_assign(LBM_CHANNEL_TRANSPORT_LBTRDMA); + lbtrdma_transport_build_key(keyval, tkey, entry); + wmem_tree_insert32_array(lbtrdma_transport_table, tkey, (void *) entry); + return (entry); +} + +static char * lbtrdma_transport_source_string(const address * source_address _U_, guint32 session_id, guint16 port) +{ + return (wmem_strdup_printf(wmem_file_scope(), "LBT-RDMA:%x:%" G_GUINT16_FORMAT, session_id, port)); +} + +/*----------------------------------------------------------------------------*/ +/* Packet layouts. */ +/*----------------------------------------------------------------------------*/ + +/* LBMR main header. */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t tqrs; + lbm_uint16_t tirs; +} lbmr_hdr_t; +#define O_LBMR_HDR_T_VER_TYPE OFFSETOF(lbmr_hdr_t, ver_type) +#define L_LBMR_HDR_T_VER_TYPE SIZEOF(lbmr_hdr_t, ver_type) +#define O_LBMR_HDR_T_TQRS OFFSETOF(lbmr_hdr_t, tqrs) +#define L_LBMR_HDR_T_TQRS SIZEOF(lbmr_hdr_t, tqrs) +#define O_LBMR_HDR_T_TIRS OFFSETOF(lbmr_hdr_t, tirs) +#define L_LBMR_HDR_T_TIRS SIZEOF(lbmr_hdr_t, tirs) +#define L_LBMR_HDR_T (gint) sizeof(lbmr_hdr_t) + +#define LBMR_HDR_VER_VER_MASK 0xf0 +#define LBMR_HDR_VER_TYPE_MASK 0x07 +#define LBMR_HDR_VER(x) (((x) & LBMR_HDR_VER_VER_MASK) >> 4) +#define LBMR_HDR_TYPE(x) ((x) & LBMR_HDR_VER_TYPE_MASK) + +#define LBMR_HDR_TYPE_NORMAL 0x0 +#define LBMR_HDR_TYPE_WC_TQRS 0x1 +#define LBMR_HDR_TYPE_UCAST_RCV_ALIVE 0x2 +#define LBMR_HDR_TYPE_UCAST_SRC_ALIVE 0x3 +#define LBMR_HDR_TYPE_TOPIC_MGMT 0x4 +#define LBMR_HDR_TYPE_QUEUE_RES 0x6 +#define LBMR_HDR_TYPE_EXT 0x7 +#define LBMR_HDR_TYPE_OPTS_MASK 0x8 + +#define LBMR_WILDCARD_PATTERN_TYPE_PCRE 1 +#define LBMR_WILDCARD_PATTERN_TYPE_REGEX 2 + +/* LBMR extended header. */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t ext_type; + lbm_uint16_t dep; +} lbmr_hdr_ext_type_t; +#define O_LBMR_HDR_EXT_TYPE_T_VER_TYPE OFFSETOF(lbmr_hdr_ext_type_t, ver_type) +#define L_LBMR_HDR_EXT_TYPE_T_VER_TYPE SIZEOF(lbmr_hdr_ext_type_t, ver_type) +#define O_LBMR_HDR_EXT_TYPE_T_EXT_TYPE OFFSETOF(lbmr_hdr_ext_type_t, ext_type) +#define L_LBMR_HDR_EXT_TYPE_T_EXT_TYPE SIZEOF(lbmr_hdr_ext_type_t, ext_type) +#define O_LBMR_HDR_EXT_TYPE_T_DEP OFFSETOF(lbmr_hdr_ext_type_t, dep) +#define L_LBMR_HDR_EXT_TYPE_T_DEP SIZEOF(lbmr_hdr_ext_type_t, dep) +#define L_LBMR_HDR_EXT_TYPE_T (gint) sizeof(lbmr_hdr_ext_type_t) + +#define LBMR_HDR_EXT_TYPE_UME_PROXY_SRC_ELECT 0x1 +#define LBMR_HDR_EXT_TYPE_UMQ_QUEUE_MGMT 0x2 +#define LBMR_HDR_EXT_TYPE_CONTEXT_INFO 0x3 +#define LBMR_HDR_EXT_TYPE_TOPIC_RES_REQUEST 0x4 +#define LBMR_HDR_EXT_TYPE_TNWG_MSG 0x5 +#define LBMR_HDR_EXT_TYPE_REMOTE_DOMAIN_ROUTE 0x6 +#define LBMR_HDR_EXT_TYPE_REMOTE_CONTEXT_INFO 0x7 + +/* LBMR topic information record */ +typedef struct +{ + lbm_uint8_t transport; + lbm_uint8_t tlen; + lbm_uint16_t ttl; + lbm_uint32_t index; +} lbmr_tir_t; +#define O_LBMR_TIR_T_TRANSPORT OFFSETOF(lbmr_tir_t, transport) +#define L_LBMR_TIR_T_TRANSPORT SIZEOF(lbmr_tir_t, transport) +#define O_LBMR_TIR_T_TLEN OFFSETOF(lbmr_tir_t, tlen) +#define L_LBMR_TIR_T_TLEN SIZEOF(lbmr_tir_t, tlen) +#define O_LBMR_TIR_T_TTL OFFSETOF(lbmr_tir_t, ttl) +#define L_LBMR_TIR_T_TTL SIZEOF(lbmr_tir_t, ttl) +#define O_LBMR_TIR_T_INDEX OFFSETOF(lbmr_tir_t, index) +#define L_LBMR_TIR_T_INDEX SIZEOF(lbmr_tir_t, index) +#define L_LBMR_TIR_T (gint) sizeof(lbmr_tir_t) + +/* LBMR topic information record TCP option data */ +typedef struct +{ + lbm_uint32_t ip; + lbm_uint16_t port; +} lbmr_tir_tcp_t; +#define O_LBMR_TIR_TCP_T_IP OFFSETOF(lbmr_tir_tcp_t, ip) +#define L_LBMR_TIR_TCP_T_IP SIZEOF(lbmr_tir_tcp_t, ip) +#define O_LBMR_TIR_TCP_T_PORT OFFSETOF(lbmr_tir_tcp_t, port) +#define L_LBMR_TIR_TCP_T_PORT SIZEOF(lbmr_tir_tcp_t, port) +#define L_LBMR_TIR_TCP_T 6 + +typedef struct { + lbm_uint32_t ip; + lbm_uint32_t session_id; + lbm_uint16_t port; +} lbmr_tir_tcp_with_sid_t; +#define O_LBMR_TIR_TCP_WITH_SID_T_IP OFFSETOF(lbmr_tir_tcp_with_sid_t, ip) +#define L_LBMR_TIR_TCP_WITH_SID_T_IP SIZEOF(lbmr_tir_tcp_with_sid_t, ip) +#define O_LBMR_TIR_TCP_WITH_SID_T_SESSION_ID OFFSETOF(lbmr_tir_tcp_with_sid_t, session_id) +#define L_LBMR_TIR_TCP_WITH_SID_T_SESSION_ID SIZEOF(lbmr_tir_tcp_with_sid_t, session_id) +#define O_LBMR_TIR_TCP_WITH_SID_T_PORT OFFSETOF(lbmr_tir_tcp_with_sid_t, port) +#define L_LBMR_TIR_TCP_WITH_SID_T_PORT SIZEOF(lbmr_tir_tcp_with_sid_t, port) +#define L_LBMR_TIR_TCP_WITH_SID_T 10 + +/* LBMR topic information record LBT-RM option data */ +typedef struct +{ + lbm_uint32_t src_addr; + lbm_uint32_t mcast_addr; + lbm_uint32_t session_id; + lbm_uint16_t udp_dest_port; + lbm_uint16_t src_ucast_port; +} lbmr_tir_lbtrm_t; +#define O_LBMR_TIR_LBTRM_T_SRC_ADDR OFFSETOF(lbmr_tir_lbtrm_t, src_addr) +#define L_LBMR_TIR_LBTRM_T_SRC_ADDR SIZEOF(lbmr_tir_lbtrm_t, src_addr) +#define O_LBMR_TIR_LBTRM_T_MCAST_ADDR OFFSETOF(lbmr_tir_lbtrm_t, mcast_addr) +#define L_LBMR_TIR_LBTRM_T_MCAST_ADDR SIZEOF(lbmr_tir_lbtrm_t, mcast_addr) +#define O_LBMR_TIR_LBTRM_T_SESSION_ID OFFSETOF(lbmr_tir_lbtrm_t, session_id) +#define L_LBMR_TIR_LBTRM_T_SESSION_ID SIZEOF(lbmr_tir_lbtrm_t, session_id) +#define O_LBMR_TIR_LBTRM_T_UDP_DEST_PORT OFFSETOF(lbmr_tir_lbtrm_t, udp_dest_port) +#define L_LBMR_TIR_LBTRM_T_UDP_DEST_PORT SIZEOF(lbmr_tir_lbtrm_t, udp_dest_port) +#define O_LBMR_TIR_LBTRM_T_SRC_UCAST_PORT OFFSETOF(lbmr_tir_lbtrm_t, src_ucast_port) +#define L_LBMR_TIR_LBTRM_T_SRC_UCAST_PORT SIZEOF(lbmr_tir_lbtrm_t, src_ucast_port) +#define L_LBMR_TIR_LBTRM_T (gint) sizeof(lbmr_tir_lbtrm_t) + +/* LBMR topic information record LBT-RU option data */ +typedef struct +{ + lbm_uint32_t ip; + lbm_uint16_t port; +} lbmr_tir_lbtru_t; +#define O_LBMR_TIR_LBTRU_T_IP OFFSETOF(lbmr_tir_lbtru_t, ip) +#define L_LBMR_TIR_LBTRU_T_IP SIZEOF(lbmr_tir_lbtru_t, ip) +#define O_LBMR_TIR_LBTRU_T_PORT OFFSETOF(lbmr_tir_lbtru_t, port) +#define L_LBMR_TIR_LBTRU_T_PORT SIZEOF(lbmr_tir_lbtru_t, port) +#define L_LBMR_TIR_LBTRU_T 6 + +typedef struct +{ + lbm_uint32_t ip; + lbm_uint32_t session_id; + lbm_uint16_t port; +} lbmr_tir_lbtru_with_sid_t; +#define O_LBMR_TIR_LBTRU_WITH_SID_T_IP OFFSETOF(lbmr_tir_lbtru_with_sid_t, ip) +#define L_LBMR_TIR_LBTRU_WITH_SID_T_IP SIZEOF(lbmr_tir_lbtru_with_sid_t, ip) +#define O_LBMR_TIR_LBTRU_WITH_SID_T_SESSION_ID OFFSETOF(lbmr_tir_lbtru_with_sid_t, session_id) +#define L_LBMR_TIR_LBTRU_WITH_SID_T_SESSION_ID SIZEOF(lbmr_tir_lbtru_with_sid_t, session_id) +#define O_LBMR_TIR_LBTRU_WITH_SID_T_PORT OFFSETOF(lbmr_tir_lbtru_with_sid_t, port) +#define L_LBMR_TIR_LBTRU_WITH_SID_T_PORT SIZEOF(lbmr_tir_lbtru_with_sid_t, port) +#define L_LBMR_TIR_LBTRU_WITH_SID_T 10 + +/* LBMR topic information record LBT-IPC option data */ +typedef struct +{ + lbm_uint32_t host_id; + lbm_uint32_t session_id; + lbm_uint16_t xport_id; +} lbmr_tir_lbtipc_t; +#define O_LBMR_TIR_LBTIPC_T_HOST_ID OFFSETOF(lbmr_tir_lbtipc_t, host_id) +#define L_LBMR_TIR_LBTIPC_T_HOST_ID SIZEOF(lbmr_tir_lbtipc_t, host_id) +#define O_LBMR_TIR_LBTIPC_T_SESSION_ID OFFSETOF(lbmr_tir_lbtipc_t, session_id) +#define L_LBMR_TIR_LBTIPC_T_SESSION_ID SIZEOF(lbmr_tir_lbtipc_t, session_id) +#define O_LBMR_TIR_LBTIPC_T_XPORT_ID OFFSETOF(lbmr_tir_lbtipc_t, xport_id) +#define L_LBMR_TIR_LBTIPC_T_XPORT_ID SIZEOF(lbmr_tir_lbtipc_t, xport_id) +#define L_LBMR_TIR_LBTIPC_T 10 + +/* LBMR topic information record LBT-RDMA option data */ +typedef struct +{ + lbm_uint32_t ip; + lbm_uint32_t session_id; + lbm_uint16_t port; +} lbmr_tir_lbtrdma_t; +#define O_LBMR_TIR_LBTRDMA_T_IP OFFSETOF(lbmr_tir_lbtrdma_t, ip) +#define L_LBMR_TIR_LBTRDMA_T_IP SIZEOF(lbmr_tir_lbtrdma_t, ip) +#define O_LBMR_TIR_LBTRDMA_T_SESSION_ID OFFSETOF(lbmr_tir_lbtrdma_t, session_id) +#define L_LBMR_TIR_LBTRDMA_T_SESSION_ID SIZEOF(lbmr_tir_lbtrdma_t, session_id) +#define O_LBMR_TIR_LBTRDMA_T_PORT OFFSETOF(lbmr_tir_lbtrdma_t, port) +#define L_LBMR_TIR_LBTRDMA_T_PORT SIZEOF(lbmr_tir_lbtrdma_t, port) +#define L_LBMR_TIR_LBTRDMA_T 10 + +/* LBMR topic information record LBT-SMX option data */ +typedef struct +{ + lbm_uint32_t host_id; + lbm_uint32_t session_id; + lbm_uint16_t xport_id; +} lbmr_tir_lbtsmx_t; +#define O_LBMR_TIR_LBTSMX_T_HOST_ID OFFSETOF(lbmr_tir_lbtsmx_t, host_id) +#define L_LBMR_TIR_LBTSMX_T_HOST_ID SIZEOF(lbmr_tir_lbtsmx_t, host_id) +#define O_LBMR_TIR_LBTSMX_T_SESSION_ID OFFSETOF(lbmr_tir_lbtsmx_t, session_id) +#define L_LBMR_TIR_LBTSMX_T_SESSION_ID SIZEOF(lbmr_tir_lbtsmx_t, session_id) +#define O_LBMR_TIR_LBTSMX_T_XPORT_ID OFFSETOF(lbmr_tir_lbtsmx_t, xport_id) +#define L_LBMR_TIR_LBTSMX_T_XPORT_ID SIZEOF(lbmr_tir_lbtsmx_t, xport_id) +#define L_LBMR_TIR_LBTSMX_T 10 + +#define LBMR_TIR_TRANSPORT 0x7F +#define LBMR_TIR_OPTIONS 0x80 + +/* LBMR topic option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; +} lbmr_topic_opt_t; +#define O_LBMR_TOPIC_OPT_T_TYPE OFFSETOF(lbmr_topic_opt_t, type) +#define L_LBMR_TOPIC_OPT_T_TYPE SIZEOF(lbmr_topic_opt_t, type) +#define O_LBMR_TOPIC_OPT_T_LEN OFFSETOF(lbmr_topic_opt_t, len) +#define L_LBMR_TOPIC_OPT_T_LEN SIZEOF(lbmr_topic_opt_t, len) +#define O_LBMR_TOPIC_OPT_T_FLAGS OFFSETOF(lbmr_topic_opt_t, flags) +#define L_LBMR_TOPIC_OPT_T_FLAGS SIZEOF(lbmr_topic_opt_t, flags) +#define L_LBMR_TOPIC_OPT_T (gint) sizeof(lbmr_topic_opt_t) + +#define LBMR_TOPIC_OPT_FLAG_IGNORE 0x8000 + +/* LBMR topic option length */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t total_len; +} lbmr_topic_opt_len_t; +#define O_LBMR_TOPIC_OPT_LEN_T_TYPE OFFSETOF(lbmr_topic_opt_len_t, type) +#define L_LBMR_TOPIC_OPT_LEN_T_TYPE SIZEOF(lbmr_topic_opt_len_t, type) +#define O_LBMR_TOPIC_OPT_LEN_T_LEN OFFSETOF(lbmr_topic_opt_len_t, len) +#define L_LBMR_TOPIC_OPT_LEN_T_LEN SIZEOF(lbmr_topic_opt_len_t, len) +#define O_LBMR_TOPIC_OPT_LEN_T_TOTAL_LEN OFFSETOF(lbmr_topic_opt_len_t, total_len) +#define L_LBMR_TOPIC_OPT_LEN_T_TOTAL_LEN SIZEOF(lbmr_topic_opt_len_t, total_len) +#define L_LBMR_TOPIC_OPT_LEN_T (gint) sizeof(lbmr_topic_opt_len_t) + +#define LBMR_TOPIC_OPT_LEN_TYPE 0x00 +#define LBMR_TOPIC_OPT_LEN_SZ 4 + +/* LBMR topic UME option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint16_t store_tcp_port; + lbm_uint16_t src_tcp_port; + lbm_uint32_t store_tcp_addr; + lbm_uint32_t src_tcp_addr; + lbm_uint32_t src_reg_id; + lbm_uint32_t transport_idx; + lbm_uint32_t high_seqnum; + lbm_uint32_t low_seqnum; +} lbmr_topic_opt_ume_t; +#define O_LBMR_TOPIC_OPT_UME_T_TYPE OFFSETOF(lbmr_topic_opt_ume_t, type) +#define L_LBMR_TOPIC_OPT_UME_T_TYPE SIZEOF(lbmr_topic_opt_ume_t, type) +#define O_LBMR_TOPIC_OPT_UME_T_LEN OFFSETOF(lbmr_topic_opt_ume_t, len) +#define L_LBMR_TOPIC_OPT_UME_T_LEN SIZEOF(lbmr_topic_opt_ume_t, len) +#define O_LBMR_TOPIC_OPT_UME_T_FLAGS OFFSETOF(lbmr_topic_opt_ume_t, flags) +#define L_LBMR_TOPIC_OPT_UME_T_FLAGS SIZEOF(lbmr_topic_opt_ume_t, flags) +#define O_LBMR_TOPIC_OPT_UME_T_STORE_TCP_PORT OFFSETOF(lbmr_topic_opt_ume_t, store_tcp_port) +#define L_LBMR_TOPIC_OPT_UME_T_STORE_TCP_PORT SIZEOF(lbmr_topic_opt_ume_t, store_tcp_port) +#define O_LBMR_TOPIC_OPT_UME_T_SRC_TCP_PORT OFFSETOF(lbmr_topic_opt_ume_t, src_tcp_port) +#define L_LBMR_TOPIC_OPT_UME_T_SRC_TCP_PORT SIZEOF(lbmr_topic_opt_ume_t, src_tcp_port) +#define O_LBMR_TOPIC_OPT_UME_T_STORE_TCP_ADDR OFFSETOF(lbmr_topic_opt_ume_t, store_tcp_addr) +#define L_LBMR_TOPIC_OPT_UME_T_STORE_TCP_ADDR SIZEOF(lbmr_topic_opt_ume_t, store_tcp_addr) +#define O_LBMR_TOPIC_OPT_UME_T_SRC_TCP_ADDR OFFSETOF(lbmr_topic_opt_ume_t, src_tcp_addr) +#define L_LBMR_TOPIC_OPT_UME_T_SRC_TCP_ADDR SIZEOF(lbmr_topic_opt_ume_t, src_tcp_addr) +#define O_LBMR_TOPIC_OPT_UME_T_SRC_REG_ID OFFSETOF(lbmr_topic_opt_ume_t, src_reg_id) +#define L_LBMR_TOPIC_OPT_UME_T_SRC_REG_ID SIZEOF(lbmr_topic_opt_ume_t, src_reg_id) +#define O_LBMR_TOPIC_OPT_UME_T_TRANSPORT_IDX OFFSETOF(lbmr_topic_opt_ume_t, transport_idx) +#define L_LBMR_TOPIC_OPT_UME_T_TRANSPORT_IDX SIZEOF(lbmr_topic_opt_ume_t, transport_idx) +#define O_LBMR_TOPIC_OPT_UME_T_HIGH_SEQNUM OFFSETOF(lbmr_topic_opt_ume_t, high_seqnum) +#define L_LBMR_TOPIC_OPT_UME_T_HIGH_SEQNUM SIZEOF(lbmr_topic_opt_ume_t, high_seqnum) +#define O_LBMR_TOPIC_OPT_UME_T_LOW_SEQNUM OFFSETOF(lbmr_topic_opt_ume_t, low_seqnum) +#define L_LBMR_TOPIC_OPT_UME_T_LOW_SEQNUM SIZEOF(lbmr_topic_opt_ume_t, low_seqnum) +#define L_LBMR_TOPIC_OPT_UME_T (gint) sizeof(lbmr_topic_opt_ume_t) + +#define LBMR_TOPIC_OPT_UME_TYPE 0x01 +#define LBMR_TOPIC_OPT_UME_FLAG_IGNORE 0x8000 +#define LBMR_TOPIC_OPT_UME_FLAG_LATEJOIN 0x4000 +#define LBMR_TOPIC_OPT_UME_FLAG_STORE 0x2000 +#define LBMR_TOPIC_OPT_UME_FLAG_QCCAP 0x1000 +#define LBMR_TOPIC_OPT_UME_FLAG_ACKTOSRC 0x800 +#define LBMR_TOPIC_OPT_UME_SZ 32 + +/* LBMR topic UME store option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint8_t flags; + lbm_uint8_t grp_idx; + lbm_uint16_t store_tcp_port; + lbm_uint16_t store_idx; + lbm_uint32_t store_ip_addr; + lbm_uint32_t src_reg_id; +} lbmr_topic_opt_ume_store_t; +#define O_LBMR_TOPIC_OPT_UME_STORE_T_TYPE OFFSETOF(lbmr_topic_opt_ume_store_t, type) +#define L_LBMR_TOPIC_OPT_UME_STORE_T_TYPE SIZEOF(lbmr_topic_opt_ume_store_t, type) +#define O_LBMR_TOPIC_OPT_UME_STORE_T_LEN OFFSETOF(lbmr_topic_opt_ume_store_t, len) +#define L_LBMR_TOPIC_OPT_UME_STORE_T_LEN SIZEOF(lbmr_topic_opt_ume_store_t, len) +#define O_LBMR_TOPIC_OPT_UME_STORE_T_FLAGS OFFSETOF(lbmr_topic_opt_ume_store_t, flags) +#define L_LBMR_TOPIC_OPT_UME_STORE_T_FLAGS SIZEOF(lbmr_topic_opt_ume_store_t, flags) +#define O_LBMR_TOPIC_OPT_UME_STORE_T_GRP_IDX OFFSETOF(lbmr_topic_opt_ume_store_t, grp_idx) +#define L_LBMR_TOPIC_OPT_UME_STORE_T_GRP_IDX SIZEOF(lbmr_topic_opt_ume_store_t, grp_idx) +#define O_LBMR_TOPIC_OPT_UME_STORE_T_STORE_TCP_PORT OFFSETOF(lbmr_topic_opt_ume_store_t, store_tcp_port) +#define L_LBMR_TOPIC_OPT_UME_STORE_T_STORE_TCP_PORT SIZEOF(lbmr_topic_opt_ume_store_t, store_tcp_port) +#define O_LBMR_TOPIC_OPT_UME_STORE_T_STORE_IDX OFFSETOF(lbmr_topic_opt_ume_store_t, store_idx) +#define L_LBMR_TOPIC_OPT_UME_STORE_T_STORE_IDX SIZEOF(lbmr_topic_opt_ume_store_t, store_idx) +#define O_LBMR_TOPIC_OPT_UME_STORE_T_STORE_IP_ADDR OFFSETOF(lbmr_topic_opt_ume_store_t, store_ip_addr) +#define L_LBMR_TOPIC_OPT_UME_STORE_T_STORE_IP_ADDR SIZEOF(lbmr_topic_opt_ume_store_t, store_ip_addr) +#define O_LBMR_TOPIC_OPT_UME_STORE_T_SRC_REG_ID OFFSETOF(lbmr_topic_opt_ume_store_t, src_reg_id) +#define L_LBMR_TOPIC_OPT_UME_STORE_T_SRC_REG_ID SIZEOF(lbmr_topic_opt_ume_store_t, src_reg_id) +#define L_LBMR_TOPIC_OPT_UME_STORE_T (gint) sizeof(lbmr_topic_opt_ume_store_t) + +#define LBMR_TOPIC_OPT_UME_STORE_TYPE 0x02 +#define LBMR_TOPIC_OPT_UME_STORE_FLAG_IGNORE 0x80 +#define LBMR_TOPIC_OPT_UME_STORE_SZ 16 + +/* LBMR topic UME store group option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint8_t flags; + lbm_uint8_t grp_idx; + lbm_uint16_t grp_sz; + lbm_uint16_t reserved; +} lbmr_topic_opt_ume_store_group_t; +#define O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_TYPE OFFSETOF(lbmr_topic_opt_ume_store_group_t, type) +#define L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_TYPE SIZEOF(lbmr_topic_opt_ume_store_group_t, type) +#define O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_LEN OFFSETOF(lbmr_topic_opt_ume_store_group_t, len) +#define L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_LEN SIZEOF(lbmr_topic_opt_ume_store_group_t, len) +#define O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_FLAGS OFFSETOF(lbmr_topic_opt_ume_store_group_t, flags) +#define L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_FLAGS SIZEOF(lbmr_topic_opt_ume_store_group_t, flags) +#define O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_GRP_IDX OFFSETOF(lbmr_topic_opt_ume_store_group_t, grp_idx) +#define L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_GRP_IDX SIZEOF(lbmr_topic_opt_ume_store_group_t, grp_idx) +#define O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_GRP_SZ OFFSETOF(lbmr_topic_opt_ume_store_group_t, grp_sz) +#define L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_GRP_SZ SIZEOF(lbmr_topic_opt_ume_store_group_t, grp_sz) +#define O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_RESERVED OFFSETOF(lbmr_topic_opt_ume_store_group_t, reserved) +#define L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_RESERVED SIZEOF(lbmr_topic_opt_ume_store_group_t, reserved) +#define L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T (gint) sizeof(lbmr_topic_opt_ume_store_group_t) + +#define LBMR_TOPIC_OPT_UME_STORE_GROUP_TYPE 0x03 +#define LBMR_TOPIC_OPT_UME_STORE_GROUP_FLAG_IGNORE 0x80 +#define LBMR_TOPIC_OPT_UME_STORE_GROUP_SZ 8 + +/* LBMR topic latejoin option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint16_t src_tcp_port; + lbm_uint16_t reserved; + lbm_uint32_t src_ip_addr; + lbm_uint32_t transport_idx; + lbm_uint32_t high_seqnum; + lbm_uint32_t low_seqnum; +} lbmr_topic_opt_latejoin_t; +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_TYPE OFFSETOF(lbmr_topic_opt_latejoin_t, type) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_TYPE SIZEOF(lbmr_topic_opt_latejoin_t, type) +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_LEN OFFSETOF(lbmr_topic_opt_latejoin_t, len) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_LEN SIZEOF(lbmr_topic_opt_latejoin_t, len) +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS OFFSETOF(lbmr_topic_opt_latejoin_t, flags) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS SIZEOF(lbmr_topic_opt_latejoin_t, flags) +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_SRC_TCP_PORT OFFSETOF(lbmr_topic_opt_latejoin_t, src_tcp_port) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_SRC_TCP_PORT SIZEOF(lbmr_topic_opt_latejoin_t, src_tcp_port) +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_RESERVED OFFSETOF(lbmr_topic_opt_latejoin_t, reserved) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_RESERVED SIZEOF(lbmr_topic_opt_latejoin_t, reserved) +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_SRC_IP_ADDR OFFSETOF(lbmr_topic_opt_latejoin_t, src_ip_addr) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_SRC_IP_ADDR SIZEOF(lbmr_topic_opt_latejoin_t, src_ip_addr) +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_TRANSPORT_IDX OFFSETOF(lbmr_topic_opt_latejoin_t, transport_idx) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_TRANSPORT_IDX SIZEOF(lbmr_topic_opt_latejoin_t, transport_idx) +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_HIGH_SEQNUM OFFSETOF(lbmr_topic_opt_latejoin_t, high_seqnum) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_HIGH_SEQNUM SIZEOF(lbmr_topic_opt_latejoin_t, high_seqnum) +#define O_LBMR_TOPIC_OPT_LATEJOIN_T_LOW_SEQNUM OFFSETOF(lbmr_topic_opt_latejoin_t, low_seqnum) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T_LOW_SEQNUM SIZEOF(lbmr_topic_opt_latejoin_t, low_seqnum) +#define L_LBMR_TOPIC_OPT_LATEJOIN_T (gint) sizeof(lbmr_topic_opt_latejoin_t) + +#define LBMR_TOPIC_OPT_LATEJOIN_TYPE 0x04 +#define LBMR_TOPIC_OPT_LATEJOIN_FLAG_IGNORE 0x8000 +#define LBMR_TOPIC_OPT_LATEJOIN_FLAG_ACKTOSRC 0x4000 +#define LBMR_TOPIC_OPT_LATEJOIN_SZ 24 + +/* LBMR topic queue control option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint32_t rcr_idx; +} lbmr_topic_opt_umq_rcridx_t; +#define O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_TYPE OFFSETOF(lbmr_topic_opt_umq_rcridx_t, type) +#define L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_TYPE SIZEOF(lbmr_topic_opt_umq_rcridx_t, type) +#define O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_LEN OFFSETOF(lbmr_topic_opt_umq_rcridx_t, len) +#define L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_LEN SIZEOF(lbmr_topic_opt_umq_rcridx_t, len) +#define O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_FLAGS OFFSETOF(lbmr_topic_opt_umq_rcridx_t, flags) +#define L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_FLAGS SIZEOF(lbmr_topic_opt_umq_rcridx_t, flags) +#define O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_RCR_IDX OFFSETOF(lbmr_topic_opt_umq_rcridx_t, rcr_idx) +#define L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_RCR_IDX SIZEOF(lbmr_topic_opt_umq_rcridx_t, rcr_idx) +#define L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T (gint) sizeof(lbmr_topic_opt_umq_rcridx_t) + +#define LBMR_TOPIC_OPT_UMQ_RCRIDX_TYPE 0x05 +#define LBMR_TOPIC_OPT_UMQ_RCRIDX_SZ 8 +#define LBMR_TOPIC_OPT_UMQ_RCRIDX_FLAG_IGNORE 0x8000 + +#define LBMR_TOPIC_OPT_UMQ_QINFO_TYPE 0x06 +#define LBMR_TOPIC_OPT_UMQ_FLAG_IGNORE 0x8000 +#define LBMR_TOPIC_OPT_UMQ_FLAG_QUEUE 0x4000 +#define LBMR_TOPIC_OPT_UMQ_FLAG_RCVLISTEN 0x2000 +#define LBMR_TOPIC_OPT_UMQ_FLAG_CONTROL 0x1000 +#define LBMR_TOPIC_OPT_UMQ_FLAG_SRCRCVLISTEN 0x0800 +#define LBMR_TOPIC_OPT_UMQ_FLAG_PARTICIPANTS_ONLY 0x0400 +#define LBMR_TOPIC_OPT_UMQ_MAX_QNAME_LEN 252 + +/* LBMR topic ULB option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint32_t queue_id; + lbm_uint8_t regid[8]; + lbm_uint32_t ulb_src_id; + lbm_uint32_t src_ip_addr; + lbm_uint16_t src_tcp_port; + lbm_uint16_t reserved; +} lbmr_topic_opt_ulb_t; +#define O_LBMR_TOPIC_OPT_ULB_T_TYPE OFFSETOF(lbmr_topic_opt_ulb_t, type) +#define L_LBMR_TOPIC_OPT_ULB_T_TYPE SIZEOF(lbmr_topic_opt_ulb_t, type) +#define O_LBMR_TOPIC_OPT_ULB_T_LEN OFFSETOF(lbmr_topic_opt_ulb_t, len) +#define L_LBMR_TOPIC_OPT_ULB_T_LEN SIZEOF(lbmr_topic_opt_ulb_t, len) +#define O_LBMR_TOPIC_OPT_ULB_T_FLAGS OFFSETOF(lbmr_topic_opt_ulb_t, flags) +#define L_LBMR_TOPIC_OPT_ULB_T_FLAGS SIZEOF(lbmr_topic_opt_ulb_t, flags) +#define O_LBMR_TOPIC_OPT_ULB_T_QUEUE_ID OFFSETOF(lbmr_topic_opt_ulb_t, queue_id) +#define L_LBMR_TOPIC_OPT_ULB_T_QUEUE_ID SIZEOF(lbmr_topic_opt_ulb_t, queue_id) +#define O_LBMR_TOPIC_OPT_ULB_T_REGID OFFSETOF(lbmr_topic_opt_ulb_t, regid) +#define L_LBMR_TOPIC_OPT_ULB_T_REGID SIZEOF(lbmr_topic_opt_ulb_t, regid) +#define O_LBMR_TOPIC_OPT_ULB_T_ULB_SRC_ID OFFSETOF(lbmr_topic_opt_ulb_t, ulb_src_id) +#define L_LBMR_TOPIC_OPT_ULB_T_ULB_SRC_ID SIZEOF(lbmr_topic_opt_ulb_t, ulb_src_id) +#define O_LBMR_TOPIC_OPT_ULB_T_SRC_IP_ADDR OFFSETOF(lbmr_topic_opt_ulb_t, src_ip_addr) +#define L_LBMR_TOPIC_OPT_ULB_T_SRC_IP_ADDR SIZEOF(lbmr_topic_opt_ulb_t, src_ip_addr) +#define O_LBMR_TOPIC_OPT_ULB_T_SRC_TCP_PORT OFFSETOF(lbmr_topic_opt_ulb_t, src_tcp_port) +#define L_LBMR_TOPIC_OPT_ULB_T_SRC_TCP_PORT SIZEOF(lbmr_topic_opt_ulb_t, src_tcp_port) +#define O_LBMR_TOPIC_OPT_ULB_T_RESERVED OFFSETOF(lbmr_topic_opt_ulb_t, reserved) +#define L_LBMR_TOPIC_OPT_ULB_T_RESERVED SIZEOF(lbmr_topic_opt_ulb_t, reserved) +#define L_LBMR_TOPIC_OPT_ULB_T (gint) sizeof(lbmr_topic_opt_ulb_t) + +#define LBMR_TOPIC_OPT_ULB_TYPE 0x0B +#define LBMR_TOPIC_OPT_ULB_FLAG_IGNORE 0x8000 +#define LBMR_TOPIC_OPT_ULB_SZ 28 + +/* LBMR topic cost option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint8_t flags; + lbm_uint8_t hop_count; + lbm_uint32_t cost; +} lbmr_topic_opt_cost_t; +#define O_LBMR_TOPIC_OPT_COST_T_TYPE OFFSETOF(lbmr_topic_opt_cost_t, type) +#define L_LBMR_TOPIC_OPT_COST_T_TYPE SIZEOF(lbmr_topic_opt_cost_t, type) +#define O_LBMR_TOPIC_OPT_COST_T_LEN OFFSETOF(lbmr_topic_opt_cost_t, len) +#define L_LBMR_TOPIC_OPT_COST_T_LEN SIZEOF(lbmr_topic_opt_cost_t, len) +#define O_LBMR_TOPIC_OPT_COST_T_FLAGS OFFSETOF(lbmr_topic_opt_cost_t, flags) +#define L_LBMR_TOPIC_OPT_COST_T_FLAGS SIZEOF(lbmr_topic_opt_cost_t, flags) +#define O_LBMR_TOPIC_OPT_COST_T_HOP_COUNT OFFSETOF(lbmr_topic_opt_cost_t, hop_count) +#define L_LBMR_TOPIC_OPT_COST_T_HOP_COUNT SIZEOF(lbmr_topic_opt_cost_t, hop_count) +#define O_LBMR_TOPIC_OPT_COST_T_COST OFFSETOF(lbmr_topic_opt_cost_t, cost) +#define L_LBMR_TOPIC_OPT_COST_T_COST SIZEOF(lbmr_topic_opt_cost_t, cost) +#define L_LBMR_TOPIC_OPT_COST_T (gint) sizeof(lbmr_topic_opt_cost_t) + +#define LBMR_TOPIC_OPT_COST_TYPE 0x07 +#define LBMR_TOPIC_OPT_COST_FLAG_IGNORE 0x80 +#define LBMR_TOPIC_OPT_COST_SZ 8 + +/* LBMR topic originating transport ID option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint8_t originating_transport[LBM_OTID_BLOCK_SZ]; +} lbmr_topic_opt_otid_t; +#define O_LBMR_TOPIC_OPT_OTID_T_TYPE OFFSETOF(lbmr_topic_opt_otid_t, type) +#define L_LBMR_TOPIC_OPT_OTID_T_TYPE SIZEOF(lbmr_topic_opt_otid_t, type) +#define O_LBMR_TOPIC_OPT_OTID_T_LEN OFFSETOF(lbmr_topic_opt_otid_t, len) +#define L_LBMR_TOPIC_OPT_OTID_T_LEN SIZEOF(lbmr_topic_opt_otid_t, len) +#define O_LBMR_TOPIC_OPT_OTID_T_FLAGS OFFSETOF(lbmr_topic_opt_otid_t, flags) +#define L_LBMR_TOPIC_OPT_OTID_T_FLAGS SIZEOF(lbmr_topic_opt_otid_t, flags) +#define O_LBMR_TOPIC_OPT_OTID_T_ORIGINATING_TRANSPORT OFFSETOF(lbmr_topic_opt_otid_t, originating_transport) +#define L_LBMR_TOPIC_OPT_OTID_T_ORIGINATING_TRANSPORT SIZEOF(lbmr_topic_opt_otid_t, originating_transport) +#define L_LBMR_TOPIC_OPT_OTID_T (gint) sizeof(lbmr_topic_opt_otid_t) + +#define LBMR_TOPIC_OPT_OTID_TYPE 0x08 +#define LBMR_TOPIC_OPT_OTID_FLAG_IGNORE 0x8000 +#define LBMR_TOPIC_OPT_OTID_SZ 36 + +/* LBMR topic context instance transport option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint8_t flags; + lbm_uint8_t res; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmr_topic_opt_ctxinst_t; +#define O_LBMR_TOPIC_OPT_CTXINST_T_TYPE OFFSETOF(lbmr_topic_opt_ctxinst_t, type) +#define L_LBMR_TOPIC_OPT_CTXINST_T_TYPE SIZEOF(lbmr_topic_opt_ctxinst_t, type) +#define O_LBMR_TOPIC_OPT_CTXINST_T_LEN OFFSETOF(lbmr_topic_opt_ctxinst_t, len) +#define L_LBMR_TOPIC_OPT_CTXINST_T_LEN SIZEOF(lbmr_topic_opt_ctxinst_t, len) +#define O_LBMR_TOPIC_OPT_CTXINST_T_FLAGS OFFSETOF(lbmr_topic_opt_ctxinst_t, flags) +#define L_LBMR_TOPIC_OPT_CTXINST_T_FLAGS SIZEOF(lbmr_topic_opt_ctxinst_t, flags) +#define O_LBMR_TOPIC_OPT_CTXINST_T_RES OFFSETOF(lbmr_topic_opt_ctxinst_t, res) +#define L_LBMR_TOPIC_OPT_CTXINST_T_RES SIZEOF(lbmr_topic_opt_ctxinst_t, res) +#define O_LBMR_TOPIC_OPT_CTXINST_T_CTXINST OFFSETOF(lbmr_topic_opt_ctxinst_t, ctxinst) +#define L_LBMR_TOPIC_OPT_CTXINST_T_CTXINST SIZEOF(lbmr_topic_opt_ctxinst_t, ctxinst) +#define L_LBMR_TOPIC_OPT_CTXINST_T (gint) sizeof(lbmr_topic_opt_ctxinst_t) + +#define LBMR_TOPIC_OPT_CTXINST_TYPE 0x09 +#define LBMR_TOPIC_OPT_CTXINST_FLAG_IGNORE 0x80 +#define LBMR_TOPIC_OPT_CTXINST_SZ 12 + +/* LBMR topic context instance store transport option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint8_t flags; + lbm_uint8_t idx; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmr_topic_opt_ctxinsts_t; +#define O_LBMR_TOPIC_OPT_CTXINSTS_T_TYPE OFFSETOF(lbmr_topic_opt_ctxinsts_t, type) +#define L_LBMR_TOPIC_OPT_CTXINSTS_T_TYPE SIZEOF(lbmr_topic_opt_ctxinsts_t, type) +#define O_LBMR_TOPIC_OPT_CTXINSTS_T_LEN OFFSETOF(lbmr_topic_opt_ctxinsts_t, len) +#define L_LBMR_TOPIC_OPT_CTXINSTS_T_LEN SIZEOF(lbmr_topic_opt_ctxinsts_t, len) +#define O_LBMR_TOPIC_OPT_CTXINSTS_T_FLAGS OFFSETOF(lbmr_topic_opt_ctxinsts_t, flags) +#define L_LBMR_TOPIC_OPT_CTXINSTS_T_FLAGS SIZEOF(lbmr_topic_opt_ctxinsts_t, flags) +#define O_LBMR_TOPIC_OPT_CTXINSTS_T_IDX OFFSETOF(lbmr_topic_opt_ctxinsts_t, idx) +#define L_LBMR_TOPIC_OPT_CTXINSTS_T_IDX SIZEOF(lbmr_topic_opt_ctxinsts_t, idx) +#define O_LBMR_TOPIC_OPT_CTXINSTS_T_CTXINST OFFSETOF(lbmr_topic_opt_ctxinsts_t, ctxinst) +#define L_LBMR_TOPIC_OPT_CTXINSTS_T_CTXINST SIZEOF(lbmr_topic_opt_ctxinsts_t, ctxinst) +#define L_LBMR_TOPIC_OPT_CTXINSTS_T (gint) sizeof(lbmr_topic_opt_ctxinsts_t) + +#define LBMR_TOPIC_OPT_CTXINSTS_TYPE 0x0A +#define LBMR_TOPIC_OPT_CTXINSTS_FLAG_IGNORE 0x80 +#define LBMR_TOPIC_OPT_CTXINSTS_SZ 12 + +/* LBMR topic context instance queue transport option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint8_t flags; + lbm_uint8_t idx; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmr_topic_opt_ctxinstq_t; +#define O_LBMR_TOPIC_OPT_CTXINSTQ_T_TYPE OFFSETOF(lbmr_topic_opt_ctxinstq_t, type) +#define L_LBMR_TOPIC_OPT_CTXINSTQ_T_TYPE SIZEOF(lbmr_topic_opt_ctxinstq_t, type) +#define O_LBMR_TOPIC_OPT_CTXINSTQ_T_LEN OFFSETOF(lbmr_topic_opt_ctxinstq_t, len) +#define L_LBMR_TOPIC_OPT_CTXINSTQ_T_LEN SIZEOF(lbmr_topic_opt_ctxinstq_t, len) +#define O_LBMR_TOPIC_OPT_CTXINSTQ_T_FLAGS OFFSETOF(lbmr_topic_opt_ctxinstq_t, flags) +#define L_LBMR_TOPIC_OPT_CTXINSTQ_T_FLAGS SIZEOF(lbmr_topic_opt_ctxinstq_t, flags) +#define O_LBMR_TOPIC_OPT_CTXINSTQ_T_IDX OFFSETOF(lbmr_topic_opt_ctxinstq_t, idx) +#define L_LBMR_TOPIC_OPT_CTXINSTQ_T_IDX SIZEOF(lbmr_topic_opt_ctxinstq_t, idx) +#define O_LBMR_TOPIC_OPT_CTXINSTQ_T_CTXINST OFFSETOF(lbmr_topic_opt_ctxinstq_t, ctxinst) +#define L_LBMR_TOPIC_OPT_CTXINSTQ_T_CTXINST SIZEOF(lbmr_topic_opt_ctxinstq_t, ctxinst) +#define L_LBMR_TOPIC_OPT_CTXINSTQ_T (gint) sizeof(lbmr_topic_opt_ctxinstq_t) + +#define LBMR_TOPIC_OPT_CTXINSTQ_TYPE 0x0C +#define LBMR_TOPIC_OPT_CTXINSTQ_FLAG_IGNORE 0x80 +#define LBMR_TOPIC_OPT_CTXINSTQ_SZ 12 + +/* LBMR topic domain ID option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint32_t domain_id; +} lbmr_topic_opt_domain_id_t; +#define O_LBMR_TOPIC_OPT_DOMAIN_ID_T_TYPE OFFSETOF(lbmr_topic_opt_domain_id_t, type) +#define L_LBMR_TOPIC_OPT_DOMAIN_ID_T_TYPE SIZEOF(lbmr_topic_opt_domain_id_t, type) +#define O_LBMR_TOPIC_OPT_DOMAIN_ID_T_LEN OFFSETOF(lbmr_topic_opt_domain_id_t, len) +#define L_LBMR_TOPIC_OPT_DOMAIN_ID_T_LEN SIZEOF(lbmr_topic_opt_domain_id_t, len) +#define O_LBMR_TOPIC_OPT_DOMAIN_ID_T_FLAGS OFFSETOF(lbmr_topic_opt_domain_id_t, flags) +#define L_LBMR_TOPIC_OPT_DOMAIN_ID_T_FLAGS SIZEOF(lbmr_topic_opt_domain_id_t, flags) +#define O_LBMR_TOPIC_OPT_DOMAIN_ID_T_DOMAIN_ID OFFSETOF(lbmr_topic_opt_domain_id_t, domain_id) +#define L_LBMR_TOPIC_OPT_DOMAIN_ID_T_DOMAIN_ID SIZEOF(lbmr_topic_opt_domain_id_t, domain_id) +#define L_LBMR_TOPIC_OPT_DOMAIN_ID_T (gint) sizeof(lbmr_topic_opt_domain_id_t) + +#define LBMR_TOPIC_OPT_DOMAIN_ID_TYPE 0x0D +#define LBMR_TOPIC_OPT_DOMAIN_ID_FLAG_IGNORE 0x8000 +#define LBMR_TOPIC_OPT_DOMAIN_ID_SZ 8 + +/* LBMR topic extended functionality option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint16_t src_tcp_port; + lbm_uint16_t reserved; + lbm_uint32_t src_ip_addr; + lbm_uint32_t functionality_flags; +} lbmr_topic_opt_exfunc_t; +#define O_LBMR_TOPIC_OPT_EXFUNC_T_TYPE OFFSETOF(lbmr_topic_opt_exfunc_t, type) +#define L_LBMR_TOPIC_OPT_EXFUNC_T_TYPE SIZEOF(lbmr_topic_opt_exfunc_t, type) +#define O_LBMR_TOPIC_OPT_EXFUNC_T_LEN OFFSETOF(lbmr_topic_opt_exfunc_t, len) +#define L_LBMR_TOPIC_OPT_EXFUNC_T_LEN SIZEOF(lbmr_topic_opt_exfunc_t, len) +#define O_LBMR_TOPIC_OPT_EXFUNC_T_FLAGS OFFSETOF(lbmr_topic_opt_exfunc_t, flags) +#define L_LBMR_TOPIC_OPT_EXFUNC_T_FLAGS SIZEOF(lbmr_topic_opt_exfunc_t, flags) +#define O_LBMR_TOPIC_OPT_EXFUNC_T_SRC_TCP_PORT OFFSETOF(lbmr_topic_opt_exfunc_t, src_tcp_port) +#define L_LBMR_TOPIC_OPT_EXFUNC_T_SRC_TCP_PORT SIZEOF(lbmr_topic_opt_exfunc_t, src_tcp_port) +#define O_LBMR_TOPIC_OPT_EXFUNC_T_RESERVED OFFSETOF(lbmr_topic_opt_exfunc_t, reserved) +#define L_LBMR_TOPIC_OPT_EXFUNC_T_RESERVED SIZEOF(lbmr_topic_opt_exfunc_t, reserved) +#define O_LBMR_TOPIC_OPT_EXFUNC_T_SRC_IP_ADDR OFFSETOF(lbmr_topic_opt_exfunc_t, src_ip_addr) +#define L_LBMR_TOPIC_OPT_EXFUNC_T_SRC_IP_ADDR SIZEOF(lbmr_topic_opt_exfunc_t, src_ip_addr) +#define O_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS OFFSETOF(lbmr_topic_opt_exfunc_t, functionality_flags) +#define L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS SIZEOF(lbmr_topic_opt_exfunc_t, functionality_flags) +#define L_LBMR_TOPIC_OPT_EXFUNC_T (gint) sizeof(lbmr_topic_opt_exfunc_t) + +#define LBMR_TOPIC_OPT_EXFUNC_TYPE 0x0E +#define LBMR_TOPIC_OPT_EXFUNC_FLAG_IGNORE 0x8000 +#define LBMR_TOPIC_OPT_EXFUNC_SZ 16 + +/* Transports */ +#define LBMR_TRANSPORT_TCP 0x00 +#define LBMR_TRANSPORT_LBTRU 0x01 +#define LBMR_TRANSPORT_TCP6 0x02 +#define LBMR_TRANSPORT_LBTSMX 0x4 +#define LBMR_TRANSPORT_LBTRM 0x10 +#define LBMR_TRANSPORT_LBTIPC 0x40 +#define LBMR_TRANSPORT_LBTRDMA 0x20 +#define LBMR_TRANSPORT_PGM 0x11 + +#define LBMR_TRANSPORT_OPTION_MASK 0x80 + +/* LBMR context info */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t ext_type; + lbm_uint8_t len; + lbm_uint8_t hop_count; + lbm_uint16_t flags; + lbm_uint16_t port; + lbm_uint32_t ip; + lbm_uint8_t instance[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmr_ctxinfo_t; +#define O_LBMR_CTXINFO_T_VER_TYPE OFFSETOF(lbmr_ctxinfo_t, ver_type) +#define L_LBMR_CTXINFO_T_VER_TYPE SIZEOF(lbmr_ctxinfo_t, ver_type) +#define O_LBMR_CTXINFO_T_EXT_TYPE OFFSETOF(lbmr_ctxinfo_t, ext_type) +#define L_LBMR_CTXINFO_T_EXT_TYPE SIZEOF(lbmr_ctxinfo_t, ext_type) +#define O_LBMR_CTXINFO_T_LEN OFFSETOF(lbmr_ctxinfo_t, len) +#define L_LBMR_CTXINFO_T_LEN SIZEOF(lbmr_ctxinfo_t, len) +#define O_LBMR_CTXINFO_T_HOP_COUNT OFFSETOF(lbmr_ctxinfo_t, hop_count) +#define L_LBMR_CTXINFO_T_HOP_COUNT SIZEOF(lbmr_ctxinfo_t, hop_count) +#define O_LBMR_CTXINFO_T_FLAGS OFFSETOF(lbmr_ctxinfo_t, flags) +#define L_LBMR_CTXINFO_T_FLAGS SIZEOF(lbmr_ctxinfo_t, flags) +#define O_LBMR_CTXINFO_T_PORT OFFSETOF(lbmr_ctxinfo_t, port) +#define L_LBMR_CTXINFO_T_PORT SIZEOF(lbmr_ctxinfo_t, port) +#define O_LBMR_CTXINFO_T_IP OFFSETOF(lbmr_ctxinfo_t, ip) +#define L_LBMR_CTXINFO_T_IP SIZEOF(lbmr_ctxinfo_t, ip) +#define O_LBMR_CTXINFO_T_INSTANCE OFFSETOF(lbmr_ctxinfo_t, instance) +#define L_LBMR_CTXINFO_T_INSTANCE SIZEOF(lbmr_ctxinfo_t, instance) +#define L_LBMR_CTXINFO_T (gint) sizeof(lbmr_ctxinfo_t) + +#define LBMR_CTXINFO_QUERY_FLAG 0x8000 +#define LBMR_CTXINFO_IP_FLAG 0x4000 +#define LBMR_CTXINFO_INSTANCE_FLAG 0x2000 +#define LBMR_CTXINFO_TNWG_SRC_FLAG 0x1000 +#define LBMR_CTXINFO_TNWG_RCV_FLAG 0x0800 +#define LBMR_CTXINFO_PROXY_FLAG 0x0400 +#define LBMR_CTXINFO_NAME_FLAG 0x0001 + +/* LBMR topic resolution request */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t ext_type; + lbm_uint16_t flags; +} lbmr_topic_res_request_t; +#define O_LBMR_TOPIC_RES_REQUEST_T_VER_TYPE OFFSETOF(lbmr_topic_res_request_t, ver_type) +#define L_LBMR_TOPIC_RES_REQUEST_T_VER_TYPE SIZEOF(lbmr_topic_res_request_t, ver_type) +#define O_LBMR_TOPIC_RES_REQUEST_T_EXT_TYPE OFFSETOF(lbmr_topic_res_request_t, ext_type) +#define L_LBMR_TOPIC_RES_REQUEST_T_EXT_TYPE SIZEOF(lbmr_topic_res_request_t, ext_type) +#define O_LBMR_TOPIC_RES_REQUEST_T_FLAGS OFFSETOF(lbmr_topic_res_request_t, flags) +#define L_LBMR_TOPIC_RES_REQUEST_T_FLAGS SIZEOF(lbmr_topic_res_request_t, flags) +#define L_LBMR_TOPIC_RES_REQUEST_T (gint) sizeof(lbmr_topic_res_request_t) + +#define LBM_TOPIC_RES_REQUEST_GW_REMOTE_INTEREST 0x40 +#define LBM_TOPIC_RES_REQUEST_CONTEXT_QUERY 0x20 +#define LBM_TOPIC_RES_REQUEST_CONTEXT_ADVERTISEMENT 0x10 +#define LBM_TOPIC_RES_REQUEST_RESERVED1 0x08 +#define LBM_TOPIC_RES_REQUEST_ADVERTISEMENT 0x04 +#define LBM_TOPIC_RES_REQUEST_QUERY 0x02 +#define LBM_TOPIC_RES_REQUEST_WILDCARD_QUERY 0x01 + +/* LBMR topic management block */ +typedef struct +{ + lbm_uint16_t len; + lbm_uint16_t tmrs; +} lbmr_tmb_t; +#define O_LBMR_TMB_T_LEN OFFSETOF(lbmr_tmb_t, len) +#define L_LBMR_TMB_T_LEN SIZEOF(lbmr_tmb_t, len) +#define O_LBMR_TMB_T_TMRS OFFSETOF(lbmr_tmb_t, tmrs) +#define L_LBMR_TMB_T_TMRS SIZEOF(lbmr_tmb_t, tmrs) +#define L_LBMR_TMB_T (gint) sizeof(lbmr_tmb_t) + +/* LBMR topic management record */ +typedef struct +{ + lbm_uint16_t len; + lbm_uint8_t type; + lbm_uint8_t flags; +} lbmr_tmr_t; +#define O_LBMR_TMR_T_LEN OFFSETOF(lbmr_tmr_t, len) +#define L_LBMR_TMR_T_LEN SIZEOF(lbmr_tmr_t, len) +#define O_LBMR_TMR_T_TYPE OFFSETOF(lbmr_tmr_t, type) +#define L_LBMR_TMR_T_TYPE SIZEOF(lbmr_tmr_t, type) +#define O_LBMR_TMR_T_FLAGS OFFSETOF(lbmr_tmr_t, flags) +#define L_LBMR_TMR_T_FLAGS SIZEOF(lbmr_tmr_t, flags) +#define L_LBMR_TMR_T (gint) sizeof(lbmr_tmr_t) + +#define LBMR_TMR_LEAVE_TOPIC 0x00 +#define LBMR_TMR_TOPIC_USE 0x01 + +#define LBMR_TMR_FLAG_RESPONSE 0x80 +#define LBMR_TMR_FLAG_WILDCARD_PCRE 0x40 +#define LBMR_TMR_FLAG_WILDCARD_REGEX 0x20 +#define LBMR_TMR_FLAG_WILDCARD_MASK (LBMR_TMR_FLAG_WILDCARD_PCRE | LBMR_TMR_FLAG_WILDCARD_REGEX) + +/* LBMR queue information record */ +typedef struct +{ + lbm_uint32_t queue_id; + lbm_uint32_t queue_ver; + lbm_uint32_t queue_prev_ver; + lbm_uint16_t grp_blks; + lbm_uint16_t queue_blks; +} lbmr_qir_t; +#define O_LBMR_QIR_T_QUEUE_ID OFFSETOF(lbmr_qir_t, queue_id) +#define L_LBMR_QIR_T_QUEUE_ID SIZEOF(lbmr_qir_t, queue_id) +#define O_LBMR_QIR_T_QUEUE_VER OFFSETOF(lbmr_qir_t, queue_ver) +#define L_LBMR_QIR_T_QUEUE_VER SIZEOF(lbmr_qir_t, queue_ver) +#define O_LBMR_QIR_T_QUEUE_PREV_VER OFFSETOF(lbmr_qir_t, queue_prev_ver) +#define L_LBMR_QIR_T_QUEUE_PREV_VER SIZEOF(lbmr_qir_t, queue_prev_ver) +#define O_LBMR_QIR_T_GRP_BLKS OFFSETOF(lbmr_qir_t, grp_blks) +#define L_LBMR_QIR_T_GRP_BLKS SIZEOF(lbmr_qir_t, grp_blks) +#define O_LBMR_QIR_T_QUEUE_BLKS OFFSETOF(lbmr_qir_t, queue_blks) +#define L_LBMR_QIR_T_QUEUE_BLKS SIZEOF(lbmr_qir_t, queue_blks) +#define L_LBMR_QIR_T (gint) sizeof(lbmr_qir_t) + +#define LBMR_QIR_OPTIONS 0x8000 +#define LBMR_QIR_GRP_BLOCKS_MASK 0x7fff + +/* LBMR queue group block record */ +typedef struct +{ + lbm_uint16_t grp_idx; + lbm_uint16_t grp_sz; +} lbmr_qir_grp_blk_t; +#define O_LBMR_QIR_GRP_BLK_T_GRP_IDX OFFSETOF(lbmr_qir_grp_blk_t, grp_idx) +#define L_LBMR_QIR_GRP_BLK_T_GRP_IDX SIZEOF(lbmr_qir_grp_blk_t, grp_idx) +#define O_LBMR_QIR_GRP_BLK_T_GRP_SZ OFFSETOF(lbmr_qir_grp_blk_t, grp_sz) +#define L_LBMR_QIR_GRP_BLK_T_GRP_SZ SIZEOF(lbmr_qir_grp_blk_t, grp_sz) +#define L_LBMR_QIR_GRP_BLK_T (gint) sizeof(lbmr_qir_grp_blk_t) + +/* LBMR queue block record */ +typedef struct +{ + lbm_uint32_t ip; + lbm_uint16_t port; + lbm_uint16_t idx; + lbm_uint16_t grp_idx; + lbm_uint16_t reserved; +} lbmr_qir_queue_blk_t; +#define O_LBMR_QIR_QUEUE_BLK_T_IP OFFSETOF(lbmr_qir_queue_blk_t, ip) +#define L_LBMR_QIR_QUEUE_BLK_T_IP SIZEOF(lbmr_qir_queue_blk_t, ip) +#define O_LBMR_QIR_QUEUE_BLK_T_PORT OFFSETOF(lbmr_qir_queue_blk_t, port) +#define L_LBMR_QIR_QUEUE_BLK_T_PORT SIZEOF(lbmr_qir_queue_blk_t, port) +#define O_LBMR_QIR_QUEUE_BLK_T_IDX OFFSETOF(lbmr_qir_queue_blk_t, idx) +#define L_LBMR_QIR_QUEUE_BLK_T_IDX SIZEOF(lbmr_qir_queue_blk_t, idx) +#define O_LBMR_QIR_QUEUE_BLK_T_GRP_IDX OFFSETOF(lbmr_qir_queue_blk_t, grp_idx) +#define L_LBMR_QIR_QUEUE_BLK_T_GRP_IDX SIZEOF(lbmr_qir_queue_blk_t, grp_idx) +#define O_LBMR_QIR_QUEUE_BLK_T_RESERVED OFFSETOF(lbmr_qir_queue_blk_t, reserved) +#define L_LBMR_QIR_QUEUE_BLK_T_RESERVED SIZEOF(lbmr_qir_queue_blk_t, reserved) +#define L_LBMR_QIR_QUEUE_BLK_T (gint) sizeof(lbmr_qir_queue_blk_t) + +#define LBMR_QIR_QUEUE_BLK_FLAG_MASTER 0x8000 + +/* LBMR packet option header */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; +} lbmr_lbmr_opt_hdr_t; +#define O_LBMR_LBMR_OPT_HDR_T_TYPE OFFSETOF(lbmr_lbmr_opt_hdr_t, type) +#define L_LBMR_LBMR_OPT_HDR_T_TYPE SIZEOF(lbmr_lbmr_opt_hdr_t, type) +#define O_LBMR_LBMR_OPT_HDR_T_LEN OFFSETOF(lbmr_lbmr_opt_hdr_t, len) +#define L_LBMR_LBMR_OPT_HDR_T_LEN SIZEOF(lbmr_lbmr_opt_hdr_t, len) +#define O_LBMR_LBMR_OPT_HDR_T_FLAGS OFFSETOF(lbmr_lbmr_opt_hdr_t, flags) +#define L_LBMR_LBMR_OPT_HDR_T_FLAGS SIZEOF(lbmr_lbmr_opt_hdr_t, flags) +#define L_LBMR_LBMR_OPT_HDR_T (gint) sizeof(lbmr_lbmr_opt_hdr_t) + +#define LBMR_LBMR_OPT_HDR_FLAG_IGNORE 0x8000 + +/* LBMR packet option length header */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t total_len; +} lbmr_lbmr_opt_len_t; +#define O_LBMR_LBMR_OPT_LEN_T_TYPE OFFSETOF(lbmr_lbmr_opt_len_t, type) +#define L_LBMR_LBMR_OPT_LEN_T_TYPE SIZEOF(lbmr_lbmr_opt_len_t, type) +#define O_LBMR_LBMR_OPT_LEN_T_LEN OFFSETOF(lbmr_lbmr_opt_len_t, len) +#define L_LBMR_LBMR_OPT_LEN_T_LEN SIZEOF(lbmr_lbmr_opt_len_t, len) +#define O_LBMR_LBMR_OPT_LEN_T_TOTAL_LEN OFFSETOF(lbmr_lbmr_opt_len_t, total_len) +#define L_LBMR_LBMR_OPT_LEN_T_TOTAL_LEN SIZEOF(lbmr_lbmr_opt_len_t, total_len) +#define L_LBMR_LBMR_OPT_LEN_T (gint) sizeof(lbmr_lbmr_opt_len_t) + +#define LBMR_LBMR_OPT_LEN_TYPE 0x80 + +/* LBMR packet option source ID header */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint8_t src_id[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmr_lbmr_opt_src_id_t; +#define O_LBMR_LBMR_OPT_SRC_ID_T_TYPE OFFSETOF(lbmr_lbmr_opt_src_id_t, type) +#define L_LBMR_LBMR_OPT_SRC_ID_T_TYPE SIZEOF(lbmr_lbmr_opt_src_id_t, type) +#define O_LBMR_LBMR_OPT_SRC_ID_T_LEN OFFSETOF(lbmr_lbmr_opt_src_id_t, len) +#define L_LBMR_LBMR_OPT_SRC_ID_T_LEN SIZEOF(lbmr_lbmr_opt_src_id_t, len) +#define O_LBMR_LBMR_OPT_SRC_ID_T_FLAGS OFFSETOF(lbmr_lbmr_opt_src_id_t, flags) +#define L_LBMR_LBMR_OPT_SRC_ID_T_FLAGS SIZEOF(lbmr_lbmr_opt_src_id_t, flags) +#define O_LBMR_LBMR_OPT_SRC_ID_T_SRC_ID OFFSETOF(lbmr_lbmr_opt_src_id_t, src_id) +#define L_LBMR_LBMR_OPT_SRC_ID_T_SRC_ID SIZEOF(lbmr_lbmr_opt_src_id_t, src_id) +#define L_LBMR_LBMR_OPT_SRC_ID_T (gint) sizeof(lbmr_lbmr_opt_src_id_t) + +#define LBMR_LBMR_OPT_SRC_ID_TYPE 0x81 +#define LBMR_LBMR_OPT_SRC_ID_FLAG_IGNORE 0x8000 + +/* LBMR packet option source type header */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint8_t flags; + lbm_uint8_t src_type; +} lbmr_lbmr_opt_src_type_t; +#define O_LBMR_LBMR_OPT_SRC_TYPE_T_TYPE OFFSETOF(lbmr_lbmr_opt_src_type_t, type) +#define L_LBMR_LBMR_OPT_SRC_TYPE_T_TYPE SIZEOF(lbmr_lbmr_opt_src_type_t, type) +#define O_LBMR_LBMR_OPT_SRC_TYPE_T_LEN OFFSETOF(lbmr_lbmr_opt_src_type_t, len) +#define L_LBMR_LBMR_OPT_SRC_TYPE_T_LEN SIZEOF(lbmr_lbmr_opt_src_type_t, len) +#define O_LBMR_LBMR_OPT_SRC_TYPE_T_FLAGS OFFSETOF(lbmr_lbmr_opt_src_type_t, flags) +#define L_LBMR_LBMR_OPT_SRC_TYPE_T_FLAGS SIZEOF(lbmr_lbmr_opt_src_type_t, flags) +#define O_LBMR_LBMR_OPT_SRC_TYPE_T_SRC_TYPE OFFSETOF(lbmr_lbmr_opt_src_type_t, src_type) +#define L_LBMR_LBMR_OPT_SRC_TYPE_T_SRC_TYPE SIZEOF(lbmr_lbmr_opt_src_type_t, src_type) +#define L_LBMR_LBMR_OPT_SRC_TYPE_T (gint) sizeof(lbmr_lbmr_opt_src_type_t) + +#define LBMR_LBMR_OPT_SRC_TYPE_TYPE 0x82 +#define LBMR_LBMR_OPT_SRC_TYPE_SZ 4 +#define LBMR_LBMR_OPT_SRC_TYPE_FLAG_IGNORE 0x80 + +#define LBMR_LBMR_OPT_SRC_TYPE_SRC_TYPE_APPLICATION 0 +#define LBMR_LBMR_OPT_SRC_TYPE_SRC_TYPE_TNWGD 1 +#define LBMR_LBMR_OPT_SRC_TYPE_SRC_TYPE_STORE 2 + +/* LBMR packet option version header */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint32_t version; +} lbmr_lbmr_opt_version_t; +#define O_LBMR_LBMR_OPT_VERSION_T_TYPE OFFSETOF(lbmr_lbmr_opt_version_t, type) +#define L_LBMR_LBMR_OPT_VERSION_T_TYPE SIZEOF(lbmr_lbmr_opt_version_t, type) +#define O_LBMR_LBMR_OPT_VERSION_T_LEN OFFSETOF(lbmr_lbmr_opt_version_t, len) +#define L_LBMR_LBMR_OPT_VERSION_T_LEN SIZEOF(lbmr_lbmr_opt_version_t, len) +#define O_LBMR_LBMR_OPT_VERSION_T_FLAGS OFFSETOF(lbmr_lbmr_opt_version_t, flags) +#define L_LBMR_LBMR_OPT_VERSION_T_FLAGS SIZEOF(lbmr_lbmr_opt_version_t, flags) +#define O_LBMR_LBMR_OPT_VERSION_T_VERSION OFFSETOF(lbmr_lbmr_opt_version_t, version) +#define L_LBMR_LBMR_OPT_VERSION_T_VERSION SIZEOF(lbmr_lbmr_opt_version_t, version) +#define L_LBMR_LBMR_OPT_VERSION_T (gint) sizeof(lbmr_lbmr_opt_version_t) + +#define LBMR_LBMR_OPT_VERSION_TYPE 0x83 +#define LBMR_LBMR_OPT_VERSIION_SZ 8 +#define LBMR_LBMR_OPT_VERSION_FLAG_IGNORE 0x8000 +#define LBMR_LBMR_OPT_VERSION_FLAG_UME 0x0001 +#define LBMR_LBMR_OPT_VERSION_FLAG_UMQ 0x0002 + +/* LBMR packet option domain header */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint32_t local_domain_id; +} lbmr_lbmr_opt_local_domain_t; +#define O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_TYPE OFFSETOF(lbmr_lbmr_opt_local_domain_t, type) +#define L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_TYPE SIZEOF(lbmr_lbmr_opt_local_domain_t, type) +#define O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_LEN OFFSETOF(lbmr_lbmr_opt_local_domain_t, len) +#define L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_LEN SIZEOF(lbmr_lbmr_opt_local_domain_t, len) +#define O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_FLAGS OFFSETOF(lbmr_lbmr_opt_local_domain_t, flags) +#define L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_FLAGS SIZEOF(lbmr_lbmr_opt_local_domain_t, flags) +#define O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_LOCAL_DOMAIN_ID OFFSETOF(lbmr_lbmr_opt_local_domain_t, local_domain_id) +#define L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_LOCAL_DOMAIN_ID SIZEOF(lbmr_lbmr_opt_local_domain_t, local_domain_id) +#define L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T (gint) sizeof(lbmr_lbmr_opt_local_domain_t) + +#define LBMR_LBMR_OPT_LOCAL_DOMAIN_TYPE 0x84 +#define LBMR_LBMR_OPT_LOCAL_DOMAIN_SZ 8 +#define LBMR_LBMR_OPT_LOCAL_DOMAIN_FLAG_IGNORE 0x8000 + +/* LBMR (extended) proxy source election record */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t ext_type; + lbm_uint16_t dep_type; + lbm_uint16_t len; + lbm_uint16_t flags; + lbm_uint32_t source_ip; + lbm_uint32_t store_ip; + lbm_uint32_t transport_idx; + lbm_uint32_t topic_idx; + lbm_uint16_t source_port; + lbm_uint16_t store_port; +} lbmr_pser_t; +#define O_LBMR_PSER_T_VER_TYPE OFFSETOF(lbmr_pser_t, ver_type) +#define L_LBMR_PSER_T_VER_TYPE SIZEOF(lbmr_pser_t, ver_type) +#define O_LBMR_PSER_T_EXT_TYPE OFFSETOF(lbmr_pser_t, ext_type) +#define L_LBMR_PSER_T_EXT_TYPE SIZEOF(lbmr_pser_t, ext_type) +#define O_LBMR_PSER_T_DEP_TYPE OFFSETOF(lbmr_pser_t, dep_type) +#define L_LBMR_PSER_T_DEP_TYPE SIZEOF(lbmr_pser_t, dep_type) +#define O_LBMR_PSER_T_LEN OFFSETOF(lbmr_pser_t, len) +#define L_LBMR_PSER_T_LEN SIZEOF(lbmr_pser_t, len) +#define O_LBMR_PSER_T_FLAGS OFFSETOF(lbmr_pser_t, flags) +#define L_LBMR_PSER_T_FLAGS SIZEOF(lbmr_pser_t, flags) +#define O_LBMR_PSER_T_SOURCE_IP OFFSETOF(lbmr_pser_t, source_ip) +#define L_LBMR_PSER_T_SOURCE_IP SIZEOF(lbmr_pser_t, source_ip) +#define O_LBMR_PSER_T_STORE_IP OFFSETOF(lbmr_pser_t, store_ip) +#define L_LBMR_PSER_T_STORE_IP SIZEOF(lbmr_pser_t, store_ip) +#define O_LBMR_PSER_T_TRANSPORT_IDX OFFSETOF(lbmr_pser_t, transport_idx) +#define L_LBMR_PSER_T_TRANSPORT_IDX SIZEOF(lbmr_pser_t, transport_idx) +#define O_LBMR_PSER_T_TOPIC_IDX OFFSETOF(lbmr_pser_t, topic_idx) +#define L_LBMR_PSER_T_TOPIC_IDX SIZEOF(lbmr_pser_t, topic_idx) +#define O_LBMR_PSER_T_SOURCE_PORT OFFSETOF(lbmr_pser_t, source_port) +#define L_LBMR_PSER_T_SOURCE_PORT SIZEOF(lbmr_pser_t, source_port) +#define O_LBMR_PSER_T_STORE_PORT OFFSETOF(lbmr_pser_t, store_port) +#define L_LBMR_PSER_T_STORE_PORT SIZEOF(lbmr_pser_t, store_port) +#define O_LBMR_PSER_T_TOPIC (O_LBMR_PSER_T_STORE_PORT + L_LBMR_PSER_T_STORE_PORT) +#define L_LBMR_PSER_T (gint) sizeof(lbmr_pser_t) + +#define LBMR_PSER_OPT_FLAG 0x8000 +#define LBMR_HDR_EXT_TYPE_UME_PROXY_SRC_ELECT_DEP_ELECT 0 +#define LBMR_HDR_EXT_TYPE_UME_PROXY_SRC_ELECT_DEP_REELECT 1 + +typedef struct +{ + lbm_uint16_t type; + lbm_uint16_t optlen; +} lbmr_pser_optlen_t; +#define O_LBMR_PSER_OPTLEN_T_TYPE OFFSETOF(lbmr_pser_optlen_t, type) +#define L_LBMR_PSER_OPTLEN_T_TYPE SIZEOF(lbmr_pser_optlen_t, type) +#define O_LBMR_PSER_OPTLEN_T_OPTLEN OFFSETOF(lbmr_pser_optlen_t, optlen) +#define L_LBMR_PSER_OPTLEN_T_OPTLEN SIZEOF(lbmr_pser_optlen_t, optlen) +#define L_LBMR_PSER_OPTLEN_T (gint) sizeof(lbmr_pser_optlen_t) + +typedef struct +{ + lbm_uint8_t len; + lbm_uint8_t type; +} lbmr_pser_opt_hdr_t; +#define O_LBMR_PSER_OPT_HDR_T_LEN OFFSETOF(lbmr_pser_opt_hdr_t, len) +#define L_LBMR_PSER_OPT_HDR_T_LEN SIZEOF(lbmr_pser_opt_hdr_t, len) +#define O_LBMR_PSER_OPT_HDR_T_TYPE OFFSETOF(lbmr_pser_opt_hdr_t, type) +#define L_LBMR_PSER_OPT_HDR_T_TYPE SIZEOF(lbmr_pser_opt_hdr_t, type) +#define L_LBMR_PSER_OPT_HDR_T (gint) sizeof(lbmr_pser_opt_hdr_t) + +#define LBMR_PSER_OPT_SRC_CTXINST_TYPE 0x00 +#define LBMR_PSER_OPT_STORE_CTXINST_TYPE 0x01 + +typedef struct +{ + lbm_uint8_t len; + lbm_uint8_t type; + lbm_uint8_t ctxinst[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmr_pser_opt_ctxinst_t; +#define O_LBMR_PSER_OPT_CTXINST_T_LEN OFFSETOF(lbmr_pser_opt_ctxinst_t, len) +#define L_LBMR_PSER_OPT_CTXINST_T_LEN SIZEOF(lbmr_pser_opt_ctxinst_t, len) +#define O_LBMR_PSER_OPT_CTXINST_T_TYPE OFFSETOF(lbmr_pser_opt_ctxinst_t, type) +#define L_LBMR_PSER_OPT_CTXINST_T_TYPE SIZEOF(lbmr_pser_opt_ctxinst_t, type) +#define O_LBMR_PSER_OPT_CTXINST_T_CTXINST OFFSETOF(lbmr_pser_opt_ctxinst_t, ctxinst) +#define L_LBMR_PSER_OPT_CTXINST_T_CTXINST SIZEOF(lbmr_pser_opt_ctxinst_t, ctxinst) +#define L_LBMR_PSER_OPT_CTXINST_T (gint) sizeof(lbmr_pser_opt_ctxinst_t) + +/* LBMR (extended) gateway message */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t ext_type; + lbm_uint16_t len; + lbm_uint16_t type; + lbm_uint16_t reserved; +} lbmr_tnwg_t; +#define O_LBMR_TNWG_T_VER_TYPE OFFSETOF(lbmr_tnwg_t, ver_type) +#define L_LBMR_TNWG_T_VER_TYPE SIZEOF(lbmr_tnwg_t, ver_type) +#define O_LBMR_TNWG_T_EXT_TYPE OFFSETOF(lbmr_tnwg_t, ext_type) +#define L_LBMR_TNWG_T_EXT_TYPE SIZEOF(lbmr_tnwg_t, ext_type) +#define O_LBMR_TNWG_T_LEN OFFSETOF(lbmr_tnwg_t, len) +#define L_LBMR_TNWG_T_LEN SIZEOF(lbmr_tnwg_t, len) +#define O_LBMR_TNWG_T_TYPE OFFSETOF(lbmr_tnwg_t, type) +#define L_LBMR_TNWG_T_TYPE SIZEOF(lbmr_tnwg_t, type) +#define O_LBMR_TNWG_T_RESERVED OFFSETOF(lbmr_tnwg_t, reserved) +#define L_LBMR_TNWG_T_RESERVED SIZEOF(lbmr_tnwg_t, reserved) +#define L_LBMR_TNWG_T (gint) sizeof(lbmr_tnwg_t) + +#define LBMR_TNWG_TYPE_INTEREST 0x0000 +#define LBMR_TNWG_TYPE_CTXINFO 0x0001 +#define LBMR_TNWG_TYPE_TRREQ 0x0002 + +/* LBMR (extended) gateway message - interest header */ +typedef struct +{ + lbm_uint16_t len; + lbm_uint16_t count; +} lbmr_tnwg_interest_t; +#define O_LBMR_TNWG_INTEREST_T_LEN OFFSETOF(lbmr_tnwg_interest_t, len) +#define L_LBMR_TNWG_INTEREST_T_LEN SIZEOF(lbmr_tnwg_interest_t, len) +#define O_LBMR_TNWG_INTEREST_T_COUNT OFFSETOF(lbmr_tnwg_interest_t, count) +#define L_LBMR_TNWG_INTEREST_T_COUNT SIZEOF(lbmr_tnwg_interest_t, count) +#define L_LBMR_TNWG_INTEREST_T (gint) sizeof(lbmr_tnwg_interest_t) + +/* LBMR (extended) gateway message - interest record */ +typedef struct +{ + lbm_uint16_t len; + lbm_uint8_t flags; + lbm_uint8_t pattype; + lbm_uint32_t domain_id; +} lbmr_tnwg_interest_rec_t; +#define O_LBMR_TNWG_INTEREST_REC_T_LEN OFFSETOF(lbmr_tnwg_interest_rec_t, len) +#define L_LBMR_TNWG_INTEREST_REC_T_LEN SIZEOF(lbmr_tnwg_interest_rec_t, len) +#define O_LBMR_TNWG_INTEREST_REC_T_FLAGS OFFSETOF(lbmr_tnwg_interest_rec_t, flags) +#define L_LBMR_TNWG_INTEREST_REC_T_FLAGS SIZEOF(lbmr_tnwg_interest_rec_t, flags) +#define O_LBMR_TNWG_INTEREST_REC_T_PATTYPE OFFSETOF(lbmr_tnwg_interest_rec_t, pattype) +#define L_LBMR_TNWG_INTEREST_REC_T_PATTYPE SIZEOF(lbmr_tnwg_interest_rec_t, pattype) +#define O_LBMR_TNWG_INTEREST_REC_T_DOMAIN_ID OFFSETOF(lbmr_tnwg_interest_rec_t, domain_id) +#define L_LBMR_TNWG_INTEREST_REC_T_DOMAIN_ID SIZEOF(lbmr_tnwg_interest_rec_t, domain_id) +#define L_LBMR_TNWG_INTEREST_REC_T (gint) sizeof(lbmr_tnwg_interest_rec_t) + +#define LBMR_TNWG_INTEREST_REC_PATTERN_FLAG 0x80 +#define LBMR_TNWG_INTEREST_REC_CANCEL_FLAG 0x40 +#define LBMR_TNWG_INTEREST_REC_REFRESH_FLAG 0x20 + +/* LBMR (extended) gateway message - ctxinfo header */ +typedef struct +{ + lbm_uint16_t len; + lbm_uint8_t hop_count; + lbm_uint8_t reserved; + lbm_uint32_t flags1; + lbm_uint32_t flags2; +} lbmr_tnwg_ctxinfo_t; +#define O_LBMR_TNWG_CTXINFO_T_LEN OFFSETOF(lbmr_tnwg_ctxinfo_t, len) +#define L_LBMR_TNWG_CTXINFO_T_LEN SIZEOF(lbmr_tnwg_ctxinfo_t, len) +#define O_LBMR_TNWG_CTXINFO_T_HOP_COUNT OFFSETOF(lbmr_tnwg_ctxinfo_t, hop_count) +#define L_LBMR_TNWG_CTXINFO_T_HOP_COUNT SIZEOF(lbmr_tnwg_ctxinfo_t, hop_count) +#define O_LBMR_TNWG_CTXINFO_T_RESERVED OFFSETOF(lbmr_tnwg_ctxinfo_t, reserved) +#define L_LBMR_TNWG_CTXINFO_T_RESERVED SIZEOF(lbmr_tnwg_ctxinfo_t, reserved) +#define O_LBMR_TNWG_CTXINFO_T_FLAGS1 OFFSETOF(lbmr_tnwg_ctxinfo_t, flags1) +#define L_LBMR_TNWG_CTXINFO_T_FLAGS1 SIZEOF(lbmr_tnwg_ctxinfo_t, flags1) +#define O_LBMR_TNWG_CTXINFO_T_FLAGS2 OFFSETOF(lbmr_tnwg_ctxinfo_t, flags2) +#define L_LBMR_TNWG_CTXINFO_T_FLAGS2 SIZEOF(lbmr_tnwg_ctxinfo_t, flags2) +#define L_LBMR_TNWG_CTXINFO_T (gint) sizeof(lbmr_tnwg_ctxinfo_t) + +#define LBMR_TNWG_CTXINFO_QUERY_FLAG 0x80000000 +#define LBMR_TNWG_CTXINFO_TNWG_SRC_FLAG 0x40000000 +#define LBMR_TNWG_CTXINFO_TNWG_RCV_FLAG 0x20000000 +#define LBMR_TNWG_CTXINFO_PROXY_FLAG 0x10000000 + +/* LBMR (extended) gateway message - topic res request header */ +typedef struct +{ + lbm_uint16_t len; +} lbmr_tnwg_trreq_t; +#define O_LBMR_TNWG_TRREQ_T_LEN OFFSETOF(lbmr_tnwg_trreq_t, len) +#define L_LBMR_TNWG_TRREQ_T_LEN SIZEOF(lbmr_tnwg_trreq_t, len) +#define L_LBMR_TNWG_TRREQ_T (gint) sizeof(lbmr_tnwg_trreq_t) + +/* LBMR (extended) gateway message - basic option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; +} lbmr_tnwg_opt_t; +#define O_LBMR_TNWG_OPT_T_TYPE OFFSETOF(lbmr_tnwg_opt_t, type) +#define L_LBMR_TNWG_OPT_T_TYPE SIZEOF(lbmr_tnwg_opt_t, type) +#define O_LBMR_TNWG_OPT_T_LEN OFFSETOF(lbmr_tnwg_opt_t, len) +#define L_LBMR_TNWG_OPT_T_LEN SIZEOF(lbmr_tnwg_opt_t, len) +#define O_LBMR_TNWG_OPT_T_FLAGS OFFSETOF(lbmr_tnwg_opt_t, flags) +#define L_LBMR_TNWG_OPT_T_FLAGS SIZEOF(lbmr_tnwg_opt_t, flags) +#define L_LBMR_TNWG_OPT_T (gint) sizeof(lbmr_tnwg_opt_t) + +#define LBMR_TNWG_OPT_IGNORE_FLAG 0x8000 + +/* LBMR (extended) gateway message - ctxinst option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint8_t instance[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmr_tnwg_opt_ctxinst_t; +#define O_LBMR_TNWG_OPT_CTXINST_T_TYPE OFFSETOF(lbmr_tnwg_opt_ctxinst_t, type) +#define L_LBMR_TNWG_OPT_CTXINST_T_TYPE SIZEOF(lbmr_tnwg_opt_ctxinst_t, type) +#define O_LBMR_TNWG_OPT_CTXINST_T_LEN OFFSETOF(lbmr_tnwg_opt_ctxinst_t, len) +#define L_LBMR_TNWG_OPT_CTXINST_T_LEN SIZEOF(lbmr_tnwg_opt_ctxinst_t, len) +#define O_LBMR_TNWG_OPT_CTXINST_T_FLAGS OFFSETOF(lbmr_tnwg_opt_ctxinst_t, flags) +#define L_LBMR_TNWG_OPT_CTXINST_T_FLAGS SIZEOF(lbmr_tnwg_opt_ctxinst_t, flags) +#define O_LBMR_TNWG_OPT_CTXINST_T_INSTANCE OFFSETOF(lbmr_tnwg_opt_ctxinst_t, instance) +#define L_LBMR_TNWG_OPT_CTXINST_T_INSTANCE SIZEOF(lbmr_tnwg_opt_ctxinst_t, instance) +#define L_LBMR_TNWG_OPT_CTXINST_T (gint) sizeof(lbmr_tnwg_opt_ctxinst_t) + +#define LBMR_TNWG_OPT_CTXINST_TYPE 0x00 + +/* LBMR (extended) gateway message - address option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint16_t port; + lbm_uint16_t res; + lbm_uint32_t ip; +} lbmr_tnwg_opt_address_t; +#define O_LBMR_TNWG_OPT_ADDRESS_T_TYPE OFFSETOF(lbmr_tnwg_opt_address_t, type) +#define L_LBMR_TNWG_OPT_ADDRESS_T_TYPE SIZEOF(lbmr_tnwg_opt_address_t, type) +#define O_LBMR_TNWG_OPT_ADDRESS_T_LEN OFFSETOF(lbmr_tnwg_opt_address_t, len) +#define L_LBMR_TNWG_OPT_ADDRESS_T_LEN SIZEOF(lbmr_tnwg_opt_address_t, len) +#define O_LBMR_TNWG_OPT_ADDRESS_T_FLAGS OFFSETOF(lbmr_tnwg_opt_address_t, flags) +#define L_LBMR_TNWG_OPT_ADDRESS_T_FLAGS SIZEOF(lbmr_tnwg_opt_address_t, flags) +#define O_LBMR_TNWG_OPT_ADDRESS_T_PORT OFFSETOF(lbmr_tnwg_opt_address_t, port) +#define L_LBMR_TNWG_OPT_ADDRESS_T_PORT SIZEOF(lbmr_tnwg_opt_address_t, port) +#define O_LBMR_TNWG_OPT_ADDRESS_T_RES OFFSETOF(lbmr_tnwg_opt_address_t, res) +#define L_LBMR_TNWG_OPT_ADDRESS_T_RES SIZEOF(lbmr_tnwg_opt_address_t, res) +#define O_LBMR_TNWG_OPT_ADDRESS_T_IP OFFSETOF(lbmr_tnwg_opt_address_t, ip) +#define L_LBMR_TNWG_OPT_ADDRESS_T_IP SIZEOF(lbmr_tnwg_opt_address_t, ip) +#define L_LBMR_TNWG_OPT_ADDRESS_T (gint) sizeof(lbmr_tnwg_opt_address_t) + +#define LBMR_TNWG_OPT_ADDRESS_TYPE 0x01 + +/* LBMR (extended) gateway message - domain option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint32_t domain_id; +} lbmr_tnwg_opt_domain_t; +#define O_LBMR_TNWG_OPT_DOMAIN_T_TYPE OFFSETOF(lbmr_tnwg_opt_domain_t, type) +#define L_LBMR_TNWG_OPT_DOMAIN_T_TYPE SIZEOF(lbmr_tnwg_opt_domain_t, type) +#define O_LBMR_TNWG_OPT_DOMAIN_T_LEN OFFSETOF(lbmr_tnwg_opt_domain_t, len) +#define L_LBMR_TNWG_OPT_DOMAIN_T_LEN SIZEOF(lbmr_tnwg_opt_domain_t, len) +#define O_LBMR_TNWG_OPT_DOMAIN_T_FLAGS OFFSETOF(lbmr_tnwg_opt_domain_t, flags) +#define L_LBMR_TNWG_OPT_DOMAIN_T_FLAGS SIZEOF(lbmr_tnwg_opt_domain_t, flags) +#define O_LBMR_TNWG_OPT_DOMAIN_T_DOMAIN_ID OFFSETOF(lbmr_tnwg_opt_domain_t, domain_id) +#define L_LBMR_TNWG_OPT_DOMAIN_T_DOMAIN_ID SIZEOF(lbmr_tnwg_opt_domain_t, domain_id) +#define L_LBMR_TNWG_OPT_DOMAIN_T (gint) sizeof(lbmr_tnwg_opt_domain_t) + +#define LBMR_TNWG_OPT_DOMAIN_TYPE 0x02 + +/* LBMR (extended) gateway message - name option (a base option) */ +#define LBMR_TNWG_OPT_NAME_TYPE 0x03 + +/* LBMR (extended) remote domain route message */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t ext_type; + lbm_uint16_t num_domains; + lbm_uint32_t ip; + lbm_uint16_t port; + lbm_uint16_t reserved; + lbm_uint32_t length; + /* lbm_uint32_t domains[num_domains]; */ +} lbmr_remote_domain_route_hdr_t; +#define O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_VER_TYPE OFFSETOF(lbmr_remote_domain_route_hdr_t, ver_type) +#define L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_VER_TYPE SIZEOF(lbmr_remote_domain_route_hdr_t, ver_type) +#define O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_EXT_TYPE OFFSETOF(lbmr_remote_domain_route_hdr_t, ext_type) +#define L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_EXT_TYPE SIZEOF(lbmr_remote_domain_route_hdr_t, ext_type) +#define O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_NUM_DOMAINS OFFSETOF(lbmr_remote_domain_route_hdr_t, num_domains) +#define L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_NUM_DOMAINS SIZEOF(lbmr_remote_domain_route_hdr_t, num_domains) +#define O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_IP OFFSETOF(lbmr_remote_domain_route_hdr_t, ip) +#define L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_IP SIZEOF(lbmr_remote_domain_route_hdr_t, ip) +#define O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_PORT OFFSETOF(lbmr_remote_domain_route_hdr_t, port) +#define L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_PORT SIZEOF(lbmr_remote_domain_route_hdr_t, port) +#define O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_RESERVED OFFSETOF(lbmr_remote_domain_route_hdr_t, reserved) +#define L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_RESERVED SIZEOF(lbmr_remote_domain_route_hdr_t, reserved) +#define O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_LENGTH OFFSETOF(lbmr_remote_domain_route_hdr_t, length) +#define L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_LENGTH SIZEOF(lbmr_remote_domain_route_hdr_t, length) +#define L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T (gint) sizeof(lbmr_remote_domain_route_hdr_t) + +/* LBMR (extended) remote context information message */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t ext_type; + lbm_uint16_t len; + lbm_uint16_t num_recs; + lbm_uint16_t reserved; +} lbmr_rctxinfo_t; +#define O_LBMR_RCTXINFO_T_VER_TYPE OFFSETOF(lbmr_rctxinfo_t, ver_type) +#define L_LBMR_RCTXINFO_T_VER_TYPE SIZEOF(lbmr_rctxinfo_t, ver_type) +#define O_LBMR_RCTXINFO_T_EXT_TYPE OFFSETOF(lbmr_rctxinfo_t, ext_type) +#define L_LBMR_RCTXINFO_T_EXT_TYPE SIZEOF(lbmr_rctxinfo_t, ext_type) +#define O_LBMR_RCTXINFO_T_LEN OFFSETOF(lbmr_rctxinfo_t, len) +#define L_LBMR_RCTXINFO_T_LEN SIZEOF(lbmr_rctxinfo_t, len) +#define O_LBMR_RCTXINFO_T_NUM_RECS OFFSETOF(lbmr_rctxinfo_t, num_recs) +#define L_LBMR_RCTXINFO_T_NUM_RECS SIZEOF(lbmr_rctxinfo_t, num_recs) +#define O_LBMR_RCTXINFO_T_RESERVED OFFSETOF(lbmr_rctxinfo_t, reserved) +#define L_LBMR_RCTXINFO_T_RESERVED SIZEOF(lbmr_rctxinfo_t, reserved) +#define L_LBMR_RCTXINFO_T (gint) sizeof(lbmr_rctxinfo_t) + +/* LBMR (extended) remote context information record */ +typedef struct +{ + lbm_uint16_t len; + lbm_uint16_t flags; +} lbmr_rctxinfo_rec_t; +#define O_LBMR_RCTXINFO_REC_T_LEN OFFSETOF(lbmr_rctxinfo_rec_t, len) +#define L_LBMR_RCTXINFO_REC_T_LEN SIZEOF(lbmr_rctxinfo_rec_t, len) +#define O_LBMR_RCTXINFO_REC_T_FLAGS OFFSETOF(lbmr_rctxinfo_rec_t, flags) +#define L_LBMR_RCTXINFO_REC_T_FLAGS SIZEOF(lbmr_rctxinfo_rec_t, flags) +#define L_LBMR_RCTXINFO_REC_T (gint) sizeof(lbmr_rctxinfo_rec_t) + +#define LBMR_RCTXINFO_REC_FLAG_QUERY 0x8000 + +/* LBMR (extended) remote context information record option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; +} lbmr_rctxinfo_rec_opt_t; +#define O_LBMR_RCTXINFO_REC_OPT_T_TYPE OFFSETOF(lbmr_rctxinfo_rec_opt_t, type) +#define L_LBMR_RCTXINFO_REC_OPT_T_TYPE SIZEOF(lbmr_rctxinfo_rec_opt_t, type) +#define O_LBMR_RCTXINFO_REC_OPT_T_LEN OFFSETOF(lbmr_rctxinfo_rec_opt_t, len) +#define L_LBMR_RCTXINFO_REC_OPT_T_LEN SIZEOF(lbmr_rctxinfo_rec_opt_t, len) +#define O_LBMR_RCTXINFO_REC_OPT_T_FLAGS OFFSETOF(lbmr_rctxinfo_rec_opt_t, flags) +#define L_LBMR_RCTXINFO_REC_OPT_T_FLAGS SIZEOF(lbmr_rctxinfo_rec_opt_t, flags) +#define L_LBMR_RCTXINFO_REC_OPT_T (gint) sizeof(lbmr_rctxinfo_rec_opt_t) + +/* LBMR (extended) remote context information record address option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint32_t domain_id; + lbm_uint32_t ip; + lbm_uint16_t port; + lbm_uint16_t res; +} lbmr_rctxinfo_rec_address_opt_t; +#define O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_TYPE OFFSETOF(lbmr_rctxinfo_rec_address_opt_t, type) +#define L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_TYPE SIZEOF(lbmr_rctxinfo_rec_address_opt_t, type) +#define O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_LEN OFFSETOF(lbmr_rctxinfo_rec_address_opt_t, len) +#define L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_LEN SIZEOF(lbmr_rctxinfo_rec_address_opt_t, len) +#define O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_FLAGS OFFSETOF(lbmr_rctxinfo_rec_address_opt_t, flags) +#define L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_FLAGS SIZEOF(lbmr_rctxinfo_rec_address_opt_t, flags) +#define O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_DOMAIN_ID OFFSETOF(lbmr_rctxinfo_rec_address_opt_t, domain_id) +#define L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_DOMAIN_ID SIZEOF(lbmr_rctxinfo_rec_address_opt_t, domain_id) +#define O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_IP OFFSETOF(lbmr_rctxinfo_rec_address_opt_t, ip) +#define L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_IP SIZEOF(lbmr_rctxinfo_rec_address_opt_t, ip) +#define O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_PORT OFFSETOF(lbmr_rctxinfo_rec_address_opt_t, port) +#define L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_PORT SIZEOF(lbmr_rctxinfo_rec_address_opt_t, port) +#define O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_RES OFFSETOF(lbmr_rctxinfo_rec_address_opt_t, res) +#define L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_RES SIZEOF(lbmr_rctxinfo_rec_address_opt_t, res) +#define L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T (gint) sizeof(lbmr_rctxinfo_rec_address_opt_t) + +#define LBMR_RCTXINFO_OPT_ADDRESS_TYPE 0x01 + +/* LBMR (extended) remote context information record instance option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint8_t instance[LBM_CONTEXT_INSTANCE_BLOCK_SZ]; +} lbmr_rctxinfo_rec_instance_opt_t; +#define O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_TYPE OFFSETOF(lbmr_rctxinfo_rec_instance_opt_t, type) +#define L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_TYPE SIZEOF(lbmr_rctxinfo_rec_instance_opt_t, type) +#define O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_LEN OFFSETOF(lbmr_rctxinfo_rec_instance_opt_t, len) +#define L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_LEN SIZEOF(lbmr_rctxinfo_rec_instance_opt_t, len) +#define O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_FLAGS OFFSETOF(lbmr_rctxinfo_rec_instance_opt_t, flags) +#define L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_FLAGS SIZEOF(lbmr_rctxinfo_rec_instance_opt_t, flags) +#define O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_INSTANCE OFFSETOF(lbmr_rctxinfo_rec_instance_opt_t, instance) +#define L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_INSTANCE SIZEOF(lbmr_rctxinfo_rec_instance_opt_t, instance) +#define L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T (gint) sizeof(lbmr_rctxinfo_rec_instance_opt_t) + +#define LBMR_RCTXINFO_OPT_INSTANCE_TYPE 0x02 + +/* LBMR (extended) remote context information record odomain option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; + lbm_uint32_t domain_id; +} lbmr_rctxinfo_rec_odomain_opt_t; +#define O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_TYPE OFFSETOF(lbmr_rctxinfo_rec_odomain_opt_t, type) +#define L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_TYPE SIZEOF(lbmr_rctxinfo_rec_odomain_opt_t, type) +#define O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_LEN OFFSETOF(lbmr_rctxinfo_rec_odomain_opt_t, len) +#define L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_LEN SIZEOF(lbmr_rctxinfo_rec_odomain_opt_t, len) +#define O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_FLAGS OFFSETOF(lbmr_rctxinfo_rec_odomain_opt_t, flags) +#define L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_FLAGS SIZEOF(lbmr_rctxinfo_rec_odomain_opt_t, flags) +#define O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_DOMAIN_ID OFFSETOF(lbmr_rctxinfo_rec_odomain_opt_t, domain_id) +#define L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_DOMAIN_ID SIZEOF(lbmr_rctxinfo_rec_odomain_opt_t, domain_id) +#define L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T (gint) sizeof(lbmr_rctxinfo_rec_odomain_opt_t) + +#define LBMR_RCTXINFO_OPT_ODOMAIN_TYPE 0x03 + +/* LBMR (extended) remote context information record name option */ +typedef struct +{ + lbm_uint8_t type; + lbm_uint8_t len; + lbm_uint16_t flags; +} lbmr_rctxinfo_rec_name_opt_t; +#define O_LBMR_RCTXINFO_REC_NAME_OPT_T_TYPE OFFSETOF(lbmr_rctxinfo_rec_name_opt_t, type) +#define L_LBMR_RCTXINFO_REC_NAME_OPT_T_TYPE SIZEOF(lbmr_rctxinfo_rec_name_opt_t, type) +#define O_LBMR_RCTXINFO_REC_NAME_OPT_T_LEN OFFSETOF(lbmr_rctxinfo_rec_name_opt_t, len) +#define L_LBMR_RCTXINFO_REC_NAME_OPT_T_LEN SIZEOF(lbmr_rctxinfo_rec_name_opt_t, len) +#define O_LBMR_RCTXINFO_REC_NAME_OPT_T_FLAGS OFFSETOF(lbmr_rctxinfo_rec_name_opt_t, flags) +#define L_LBMR_RCTXINFO_REC_NAME_OPT_T_FLAGS SIZEOF(lbmr_rctxinfo_rec_name_opt_t, flags) +#define L_LBMR_RCTXINFO_REC_NAME_OPT_T (gint) sizeof(lbmr_rctxinfo_rec_name_opt_t) + +#define LBMR_RCTXINFO_OPT_NAME_TYPE 0x04 + +/* Queue management headers (may appear in LBMR or LBMC packets) */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t ext_type; +} lbmr_umq_qmgmt_hdr_t; +#define O_LBMR_UMQ_QMGMT_HDR_T_VER_TYPE OFFSETOF(lbmr_umq_qmgmt_hdr_t, ver_type) +#define L_LBMR_UMQ_QMGMT_HDR_T_VER_TYPE SIZEOF(lbmr_umq_qmgmt_hdr_t, ver_type) +#define O_LBMR_UMQ_QMGMT_HDR_T_EXT_TYPE OFFSETOF(lbmr_umq_qmgmt_hdr_t, ext_type) +#define L_LBMR_UMQ_QMGMT_HDR_T_EXT_TYPE SIZEOF(lbmr_umq_qmgmt_hdr_t, ext_type) +#define L_LBMR_UMQ_QMGMT_HDR_T (gint) sizeof(lbmr_umq_qmgmt_hdr_t) + +typedef struct +{ + lbm_uint8_t filler1; + lbm_uint8_t filler2; + lbm_uint8_t flags; + lbm_uint8_t pckt_type; + lbm_uint8_t cfgsig[20]; + lbm_uint32_t queue_id; + lbm_uint32_t queue_ver; + lbm_uint32_t ip; + lbm_uint16_t port; + lbm_uint16_t inst_idx; + lbm_uint16_t grp_idx; + lbm_uint16_t pckt_type_dep16; +} umq_qmgmt_hdr_t; +#define O_UMQ_QMGMT_HDR_T_FLAGS OFFSETOF(umq_qmgmt_hdr_t, flags) +#define L_UMQ_QMGMT_HDR_T_FLAGS SIZEOF(umq_qmgmt_hdr_t, flags) +#define O_UMQ_QMGMT_HDR_T_PCKT_TYPE OFFSETOF(umq_qmgmt_hdr_t, pckt_type) +#define L_UMQ_QMGMT_HDR_T_PCKT_TYPE SIZEOF(umq_qmgmt_hdr_t, pckt_type) +#define O_UMQ_QMGMT_HDR_T_CFGSIG OFFSETOF(umq_qmgmt_hdr_t, cfgsig) +#define L_UMQ_QMGMT_HDR_T_CFGSIG SIZEOF(umq_qmgmt_hdr_t, cfgsig) +#define O_UMQ_QMGMT_HDR_T_QUEUE_ID OFFSETOF(umq_qmgmt_hdr_t, queue_id) +#define L_UMQ_QMGMT_HDR_T_QUEUE_ID SIZEOF(umq_qmgmt_hdr_t, queue_id) +#define O_UMQ_QMGMT_HDR_T_QUEUE_VER OFFSETOF(umq_qmgmt_hdr_t, queue_ver) +#define L_UMQ_QMGMT_HDR_T_QUEUE_VER SIZEOF(umq_qmgmt_hdr_t, queue_ver) +#define O_UMQ_QMGMT_HDR_T_IP OFFSETOF(umq_qmgmt_hdr_t, ip) +#define L_UMQ_QMGMT_HDR_T_IP SIZEOF(umq_qmgmt_hdr_t, ip) +#define O_UMQ_QMGMT_HDR_T_PORT OFFSETOF(umq_qmgmt_hdr_t, port) +#define L_UMQ_QMGMT_HDR_T_PORT SIZEOF(umq_qmgmt_hdr_t, port) +#define O_UMQ_QMGMT_HDR_T_INST_IDX OFFSETOF(umq_qmgmt_hdr_t, inst_idx) +#define L_UMQ_QMGMT_HDR_T_INST_IDX SIZEOF(umq_qmgmt_hdr_t, inst_idx) +#define O_UMQ_QMGMT_HDR_T_GRP_IDX OFFSETOF(umq_qmgmt_hdr_t, grp_idx) +#define L_UMQ_QMGMT_HDR_T_GRP_IDX SIZEOF(umq_qmgmt_hdr_t, grp_idx) +#define O_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16 OFFSETOF(umq_qmgmt_hdr_t, pckt_type_dep16) +#define L_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16 SIZEOF(umq_qmgmt_hdr_t, pckt_type_dep16) +#define L_UMQ_QMGMT_HDR_T (gint) sizeof(umq_qmgmt_hdr_t) + +#define UMQ_QMGMT_HDR_I_FLAG 0x80 +#define UMQ_QMGMT_HDR_N_FLAG 0x40 +#define UMQ_QMGMT_HDR_IL_L_FLAG 0x20 +#define UMQ_QMGMT_HDR_IL_K_FLAG 0x10 + +typedef struct +{ + lbm_uint32_t highest_rcr_tsp; +} umq_qmgmt_il_hdr_t; +#define O_UMQ_QMGMT_IL_HDR_T_HIGHEST_RCR_TSP OFFSETOF(umq_qmgmt_il_hdr_t, highest_rcr_tsp) +#define L_UMQ_QMGMT_IL_HDR_T_HIGHEST_RCR_TSP SIZEOF(umq_qmgmt_il_hdr_t, highest_rcr_tsp) +#define L_UMQ_QMGMT_IL_HDR_T (gint) sizeof(umq_qmgmt_il_hdr_t) + +typedef struct +{ + lbm_uint32_t ip; + lbm_uint16_t port; + lbm_uint16_t inst_idx; + lbm_uint16_t grp_idx; + lbm_uint16_t flags; +} umq_qmgmt_il_inst_hdr_t; +#define O_UMQ_QMGMT_IL_INST_HDR_T_IP OFFSETOF(umq_qmgmt_il_inst_hdr_t, ip) +#define L_UMQ_QMGMT_IL_INST_HDR_T_IP SIZEOF(umq_qmgmt_il_inst_hdr_t, ip) +#define O_UMQ_QMGMT_IL_INST_HDR_T_PORT OFFSETOF(umq_qmgmt_il_inst_hdr_t, port) +#define L_UMQ_QMGMT_IL_INST_HDR_T_PORT SIZEOF(umq_qmgmt_il_inst_hdr_t, port) +#define O_UMQ_QMGMT_IL_INST_HDR_T_INST_IDX OFFSETOF(umq_qmgmt_il_inst_hdr_t, inst_idx) +#define L_UMQ_QMGMT_IL_INST_HDR_T_INST_IDX SIZEOF(umq_qmgmt_il_inst_hdr_t, inst_idx) +#define O_UMQ_QMGMT_IL_INST_HDR_T_GRP_IDX OFFSETOF(umq_qmgmt_il_inst_hdr_t, grp_idx) +#define L_UMQ_QMGMT_IL_INST_HDR_T_GRP_IDX SIZEOF(umq_qmgmt_il_inst_hdr_t, grp_idx) +#define O_UMQ_QMGMT_IL_INST_HDR_T_FLAGS OFFSETOF(umq_qmgmt_il_inst_hdr_t, flags) +#define L_UMQ_QMGMT_IL_INST_HDR_T_FLAGS SIZEOF(umq_qmgmt_il_inst_hdr_t, flags) +#define L_UMQ_QMGMT_IL_INST_HDR_T (gint) sizeof(umq_qmgmt_il_inst_hdr_t) + +#define UMQ_QMGMT_HDR_IL_INST_M_FLAG 0x8000 +#define UMQ_QMGMT_HDR_IL_INST_Q_FLAG 0x4000 +#define UMQ_QMGMT_HDR_IL_INST_P_FLAG 0x2000 + +typedef struct +{ + lbm_uint32_t queue_new_ver; +} umq_qmgmt_ec_hdr_t; +#define O_UMQ_QMGMT_EC_HDR_T_QUEUE_NEW_VER OFFSETOF(umq_qmgmt_ec_hdr_t, queue_new_ver) +#define L_UMQ_QMGMT_EC_HDR_T_QUEUE_NEW_VER SIZEOF(umq_qmgmt_ec_hdr_t, queue_new_ver) +#define L_UMQ_QMGMT_EC_HDR_T (gint) sizeof(umq_qmgmt_ec_hdr_t) + +typedef struct +{ + lbm_uint32_t highest_rcr_tsp; + lbm_uint32_t age; +} umq_qmgmt_ev_hdr_t; +#define O_UMQ_QMGMT_EV_HDR_T_HIGHEST_RCR_TSP OFFSETOF(umq_qmgmt_ev_hdr_t, highest_rcr_tsp) +#define L_UMQ_QMGMT_EV_HDR_T_HIGHEST_RCR_TSP SIZEOF(umq_qmgmt_ev_hdr_t, highest_rcr_tsp) +#define O_UMQ_QMGMT_EV_HDR_T_AGE OFFSETOF(umq_qmgmt_ev_hdr_t, age) +#define L_UMQ_QMGMT_EV_HDR_T_AGE SIZEOF(umq_qmgmt_ev_hdr_t, age) +#define L_UMQ_QMGMT_EV_HDR_T (gint) sizeof(umq_qmgmt_ev_hdr_t) + +typedef struct +{ + lbm_uint32_t highest_rcr_tsp; +} umq_qmgmt_qro_hdr_t; +#define O_UMQ_QMGMT_QRO_HDR_T_HIGHEST_RCR_TSP OFFSETOF(umq_qmgmt_qro_hdr_t, highest_rcr_tsp) +#define L_UMQ_QMGMT_QRO_HDR_T_HIGHEST_RCR_TSP SIZEOF(umq_qmgmt_qro_hdr_t, highest_rcr_tsp) +#define L_UMQ_QMGMT_QRO_HDR_T (gint) sizeof(umq_qmgmt_qro_hdr_t) + +#define UMQ_QMGMT_HDR_PCKT_TYPE_IL 0x1 +#define UMQ_QMGMT_HDR_PCKT_TYPE_JR 0x2 +#define UMQ_QMGMT_HDR_PCKT_TYPE_JREJ 0x3 +#define UMQ_QMGMT_HDR_PCKT_TYPE_IKA 0x4 +#define UMQ_QMGMT_HDR_PCKT_TYPE_EC 0x5 +#define UMQ_QMGMT_HDR_PCKT_TYPE_EV 0x6 +#define UMQ_QMGMT_HDR_PCKT_TYPE_CNIL 0x7 +#define UMQ_QMGMT_HDR_PCKT_TYPE_QRO 0x8 + +#define LBMR_VERSION_0 0x00 +#define LBMR_VERSION_1 0x01 +#define LBMR_VERSION_GATEWAY LBMR_VERSION_1 +#define LBMR_VERSION LBMR_VERSION_0 + +/*----------------------------------------------------------------------------*/ +/* Value translation tables. */ +/*----------------------------------------------------------------------------*/ + +static const value_string lbmr_packet_type[] = +{ + { LBMR_HDR_TYPE_NORMAL, "NORMAL" }, + { LBMR_HDR_TYPE_WC_TQRS, "WC-TQR" }, + { LBMR_HDR_TYPE_UCAST_RCV_ALIVE, "Rcv Alive" }, + { LBMR_HDR_TYPE_UCAST_SRC_ALIVE, "Src Alive" }, + { LBMR_HDR_TYPE_TOPIC_MGMT, "Topic Mgmt" }, + { LBMR_HDR_TYPE_QUEUE_RES, "UMQ" }, + { LBMR_HDR_TYPE_EXT, "Extended" }, + { 0x0, NULL } +}; + +static const value_string lbmr_ext_packet_type[] = +{ + { LBMR_HDR_EXT_TYPE_UME_PROXY_SRC_ELECT, "Proxy Source Election" }, + { LBMR_HDR_EXT_TYPE_UMQ_QUEUE_MGMT, "Queue Management" }, + { LBMR_HDR_EXT_TYPE_CONTEXT_INFO, "Context Information" }, + { LBMR_HDR_EXT_TYPE_TOPIC_RES_REQUEST, "Topic Resolution Request" }, + { LBMR_HDR_EXT_TYPE_TNWG_MSG, "Gateway Message" }, + { LBMR_HDR_EXT_TYPE_REMOTE_DOMAIN_ROUTE, "Remote Domain Route" }, + { LBMR_HDR_EXT_TYPE_REMOTE_CONTEXT_INFO, "Remote Context Information" }, + { 0x0, NULL } +}; + +static const value_string lbmr_transport_type[] = +{ + { LBMR_TRANSPORT_TCP, "TCP" }, + { LBMR_TRANSPORT_LBTSMX, "LBT-SMX" }, + { LBMR_TRANSPORT_LBTRU, "LBT-RU" }, + { LBMR_TRANSPORT_LBTRM, "LBT-RM" }, + { LBMR_TRANSPORT_LBTIPC, "LBT-IPC" }, + { LBMR_TRANSPORT_LBTRDMA, "LBT-RDMA" }, + { 0x0, NULL } +}; + +static const value_string lbmr_tmr_type[] = +{ + { LBMR_TMR_LEAVE_TOPIC, "Leave Topic" }, + { LBMR_TMR_TOPIC_USE, "Topic Use" }, + { 0x0, NULL } +}; + +static const value_string lbmr_topic_option_type[] = +{ + { LBMR_TOPIC_OPT_LEN_TYPE, "Option Length" }, + { LBMR_TOPIC_OPT_UME_TYPE, "UME" }, + { LBMR_TOPIC_OPT_UME_STORE_TYPE, "UME Store" }, + { LBMR_TOPIC_OPT_UME_STORE_GROUP_TYPE, "UME Store Group" }, + { LBMR_TOPIC_OPT_LATEJOIN_TYPE, "Late Join" }, + { LBMR_TOPIC_OPT_UMQ_RCRIDX_TYPE, "UMQ Receiver Control Record Index" }, + { LBMR_TOPIC_OPT_UMQ_QINFO_TYPE, "UMQ Queue Info" }, + { LBMR_TOPIC_OPT_COST_TYPE, "Cost" }, + { LBMR_TOPIC_OPT_OTID_TYPE, "Originating Transport" }, + { LBMR_TOPIC_OPT_CTXINST_TYPE, "Context Instance" }, + { LBMR_TOPIC_OPT_CTXINSTS_TYPE, "Store Context Instance" }, + { LBMR_TOPIC_OPT_ULB_TYPE, "UMQ ULB" }, + { LBMR_TOPIC_OPT_CTXINSTQ_TYPE, "Queue Context Instance" }, + { LBMR_TOPIC_OPT_DOMAIN_ID_TYPE, "Domain ID" }, + { LBMR_TOPIC_OPT_EXFUNC_TYPE, "Extended Functionality" }, + { 0x0, NULL } +}; + +static const value_string lbmr_pser_dependent_type[] = +{ + { LBMR_HDR_EXT_TYPE_UME_PROXY_SRC_ELECT_DEP_ELECT, "Election" }, + { LBMR_HDR_EXT_TYPE_UME_PROXY_SRC_ELECT_DEP_REELECT, "Re-election" }, + { 0x0, NULL } +}; + +static const value_string lbmr_unknown_dependent_type[] = +{ + { 0x0, NULL } +}; + +static const value_string lbmr_option_type[] = +{ + { LBMR_LBMR_OPT_LEN_TYPE, "Option length" }, + { LBMR_LBMR_OPT_SRC_ID_TYPE, "Source ID" }, + { LBMR_LBMR_OPT_SRC_TYPE_TYPE, "Source type" }, + { LBMR_LBMR_OPT_VERSION_TYPE, "Version" }, + { LBMR_LBMR_OPT_LOCAL_DOMAIN_TYPE, "Local Domain" }, + { 0x0, NULL } +}; + +static const value_string lbmr_pser_option_type[] = +{ + { LBMR_PSER_OPT_SRC_CTXINST_TYPE, "Source context instance" }, + { LBMR_PSER_OPT_STORE_CTXINST_TYPE, "Store context instance" }, + { 0x0, NULL } +}; + +static const value_string lbmr_option_source_type[] = +{ + { LBMR_LBMR_OPT_SRC_TYPE_SRC_TYPE_APPLICATION, "Application" }, + { LBMR_LBMR_OPT_SRC_TYPE_SRC_TYPE_TNWGD, "Gateway" }, + { LBMR_LBMR_OPT_SRC_TYPE_SRC_TYPE_STORE, "Store" }, + { 0x0, NULL } +}; + +static const value_string lbmr_tnwg_function_type[] = +{ + { LBMR_TNWG_TYPE_INTEREST, "Interest" }, + { LBMR_TNWG_TYPE_CTXINFO, "Context information" }, + { LBMR_TNWG_TYPE_TRREQ, "Topic res request" }, + { 0x0, NULL } +}; + +static const value_string lbmr_tnwg_option_type[] = +{ + { LBMR_TNWG_OPT_CTXINST_TYPE, "Context instance" }, + { LBMR_TNWG_OPT_ADDRESS_TYPE, "Address" }, + { LBMR_TNWG_OPT_DOMAIN_TYPE, "Domain" }, + { LBMR_TNWG_OPT_NAME_TYPE, "Name" }, + { 0x0, NULL } +}; + +static const value_string umq_qmgmt_packet_type[] = +{ + { UMQ_QMGMT_HDR_PCKT_TYPE_IL, "Instance List" }, + { UMQ_QMGMT_HDR_PCKT_TYPE_JR, "Join Request" }, + { UMQ_QMGMT_HDR_PCKT_TYPE_JREJ, "Join Request Rejection" }, + { UMQ_QMGMT_HDR_PCKT_TYPE_IKA, "Instance Keepalive" }, + { UMQ_QMGMT_HDR_PCKT_TYPE_EC, "Election Call" }, + { UMQ_QMGMT_HDR_PCKT_TYPE_EV, "Election Vote" }, + { UMQ_QMGMT_HDR_PCKT_TYPE_CNIL, "Confirm New Instance List" }, + { UMQ_QMGMT_HDR_PCKT_TYPE_QRO, "Queue resume operation" }, + { 0x0, NULL } +}; + +static const value_string lbmr_rctxinfo_option_type[] = +{ + { LBMR_RCTXINFO_OPT_ADDRESS_TYPE, "Address" }, + { LBMR_RCTXINFO_OPT_INSTANCE_TYPE, "Instance" }, + { LBMR_RCTXINFO_OPT_ODOMAIN_TYPE, "Originating Domain" }, + { LBMR_RCTXINFO_OPT_NAME_TYPE, "Name" }, + { 0x0, NULL } +}; + +/*----------------------------------------------------------------------------*/ +/* Preferences. */ +/*----------------------------------------------------------------------------*/ + +/* Preferences default values. */ +#define LBMR_DEFAULT_MC_INCOMING_UDP_PORT 12965 +#define LBMR_DEFAULT_MC_INCOMING_UDP_PORT_STRING MAKESTRING(LBMR_DEFAULT_MC_INCOMING_UDP_PORT) +#define LBMR_DEFAULT_MC_OUTGOING_UDP_PORT 12965 +#define LBMR_DEFAULT_MC_OUTGOING_UDP_PORT_STRING MAKESTRING(LBMR_DEFAULT_MC_OUTGOING_UDP_PORT) +#define LBMR_DEFAULT_MC_INCOMING_ADDRESS "224.9.10.11" +#define LBMR_DEFAULT_MC_OUTGOING_ADDRESS "224.9.10.11" +#define LBMR_DEFAULT_UC_PORT_HIGH 14406 +#define LBMR_DEFAULT_UC_PORT_HIGH_STRING MAKESTRING(LBMR_DEFAULT_UC_PORT_HIGH) +#define LBMR_DEFAULT_UC_PORT_LOW 14402 +#define LBMR_DEFAULT_UC_PORT_LOW_STRING MAKESTRING(LBMR_DEFAULT_UC_PORT_LOW) +#define LBMR_DEFAULT_UC_DEST_PORT 15380 +#define LBMR_DEFAULT_UC_DEST_PORT_STRING MAKESTRING(LBMR_DEFAULT_UC_DEST_PORT) +#define LBMR_DEFAULT_UC_ADDRESS "0.0.0.0" + +/* Global preferences variables (altered by the preferences dialog). */ +static guint32 global_lbmr_mc_incoming_udp_port = LBMR_DEFAULT_MC_INCOMING_UDP_PORT; +static guint32 global_lbmr_mc_outgoing_udp_port = LBMR_DEFAULT_MC_OUTGOING_UDP_PORT; +static const char * global_lbmr_mc_incoming_address = LBMR_DEFAULT_MC_INCOMING_ADDRESS; +static const char * global_lbmr_mc_outgoing_address = LBMR_DEFAULT_MC_OUTGOING_ADDRESS; +static guint32 global_lbmr_uc_port_high = LBMR_DEFAULT_UC_PORT_HIGH; +static guint32 global_lbmr_uc_port_low = LBMR_DEFAULT_UC_PORT_LOW; +static guint32 global_lbmr_uc_dest_port = LBMR_DEFAULT_UC_DEST_PORT; +static const char * global_lbmr_uc_address = LBMR_DEFAULT_UC_ADDRESS; +static gboolean global_lbmr_use_tag = FALSE; + +/* Local preferences variables (used by the dissector). */ +static guint32 lbmr_mc_incoming_udp_port = LBMR_DEFAULT_MC_INCOMING_UDP_PORT; +static guint32 lbmr_mc_outgoing_udp_port = LBMR_DEFAULT_MC_OUTGOING_UDP_PORT; +static guint32 lbmr_mc_incoming_address_host = 0; +static guint32 lbmr_mc_outgoing_address_host = 0; +static guint32 lbmr_uc_port_high = LBMR_DEFAULT_UC_PORT_HIGH; +static guint32 lbmr_uc_port_low = LBMR_DEFAULT_UC_PORT_LOW; +static guint32 lbmr_uc_dest_port = LBMR_DEFAULT_UC_DEST_PORT; +static guint32 lbmr_uc_address_host = 0; +static gboolean lbmr_use_tag = FALSE; + +typedef struct +{ + char * name; + guint32 mc_outgoing_udp_port; + guint32 mc_incoming_udp_port; + char * mc_incoming_address; + guint32 mc_incoming_address_val_h; + char * mc_outgoing_address; + guint32 mc_outgoing_address_val_h; + guint32 uc_port_high; + guint32 uc_port_low; + guint32 uc_dest_port; + char * uc_address; + guint32 uc_address_val_h; +} lbmr_tag_entry_t; + +static lbmr_tag_entry_t * lbmr_tag_entry = NULL; +static guint lbmr_tag_count = 0; + +UAT_CSTRING_CB_DEF(lbmr_tag, name, lbmr_tag_entry_t) +UAT_DEC_CB_DEF(lbmr_tag, mc_outgoing_udp_port, lbmr_tag_entry_t) +UAT_DEC_CB_DEF(lbmr_tag, mc_incoming_udp_port, lbmr_tag_entry_t) +UAT_IPV4_MC_CB_DEF(lbmr_tag, mc_incoming_address, lbmr_tag_entry_t) +UAT_IPV4_MC_CB_DEF(lbmr_tag, mc_outgoing_address, lbmr_tag_entry_t) +UAT_DEC_CB_DEF(lbmr_tag, uc_port_high, lbmr_tag_entry_t) +UAT_DEC_CB_DEF(lbmr_tag, uc_port_low, lbmr_tag_entry_t) +UAT_DEC_CB_DEF(lbmr_tag, uc_dest_port, lbmr_tag_entry_t) +UAT_IPV4_CB_DEF(lbmr_tag, uc_address, lbmr_tag_entry_t) +static uat_field_t lbmr_tag_array[] = +{ + UAT_FLD_CSTRING(lbmr_tag, name, "Tag name", "Tag name"), + UAT_FLD_DEC(lbmr_tag, mc_incoming_udp_port, "Incoming multicast UDP port", "Incoming UDP port"), + UAT_FLD_IPV4_MC(lbmr_tag, mc_incoming_address, "Incoming multicast address", "Incoming multicast address"), + UAT_FLD_DEC(lbmr_tag, mc_outgoing_udp_port, "Outgoing UDP port", "Outgoing UDP port"), + UAT_FLD_IPV4_MC(lbmr_tag, mc_outgoing_address, "Outgoing multicast address", "Outgoing multicast address"), + UAT_FLD_DEC(lbmr_tag, uc_port_low, "Unicast UDP port low", "Unicast UDP port low"), + UAT_FLD_DEC(lbmr_tag, uc_port_high, "Unicast UDP port high", "Unicast UDP port high"), + UAT_FLD_DEC(lbmr_tag, uc_dest_port, "Unicast UDP destination port", "Unicast UDP destination port"), + UAT_FLD_IPV4(lbmr_tag, uc_address, "Unicast resolver address", "Unicast resolver address"), + UAT_END_FIELDS +}; + +/*----------------------------------------------------------------------------*/ +/* UAT callback functions. */ +/*----------------------------------------------------------------------------*/ +static void lbmr_tag_update_cb(void * record, const char * * error_string) +{ + lbmr_tag_entry_t * tag = (lbmr_tag_entry_t *)record; + + if (tag->name == NULL) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + else + { + g_strstrip(tag->name); + if (tag->name[0] == 0) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + } +} + +static void * lbmr_tag_copy_cb(void * destination, const void * source, size_t length _U_) +{ + const lbmr_tag_entry_t * src = (const lbmr_tag_entry_t *)source; + lbmr_tag_entry_t * dest = (lbmr_tag_entry_t *)destination; + + dest->name = g_strdup(src->name); + dest->mc_outgoing_udp_port = src->mc_outgoing_udp_port; + dest->mc_incoming_udp_port = src->mc_incoming_udp_port; + dest->mc_incoming_address = g_strdup(src->mc_incoming_address); + dest->mc_incoming_address_val_h = src->mc_incoming_address_val_h; + dest->mc_outgoing_address = g_strdup(src->mc_outgoing_address); + dest->mc_outgoing_address_val_h = src->mc_outgoing_address_val_h; + dest->uc_port_high = src->uc_port_high; + dest->uc_port_low = src->uc_port_low; + dest->uc_dest_port = src->uc_dest_port; + dest->uc_address = g_strdup(src->uc_address); + dest->uc_address_val_h = src->uc_address_val_h; + return (dest); +} + +static void lbmr_tag_free_cb(void * record) +{ + lbmr_tag_entry_t * tag = (lbmr_tag_entry_t *)record; + + if (tag->name != NULL) + { + g_free(tag->name); + tag->name = NULL; + } + if (tag->mc_incoming_address != NULL) + { + g_free(tag->mc_incoming_address); + tag->mc_incoming_address = NULL; + } + if (tag->mc_outgoing_address != NULL) + { + g_free(tag->mc_outgoing_address); + tag->mc_outgoing_address = NULL; + } + if (tag->uc_address != NULL) + { + g_free(tag->uc_address); + tag->uc_address = NULL; + } +} + +static gboolean lbmr_match_packet(packet_info * pinfo, const lbmr_tag_entry_t * entry) +{ + in_addr_t dest_addr; + in_addr_t src_addr; + in_addr_t dest_addr_h; + in_addr_t src_addr_h; + + dest_addr = *((in_addr_t *)pinfo->dst.data); + dest_addr_h = g_ntohl(dest_addr); + src_addr = *((in_addr_t *)pinfo->src.data); + src_addr_h = g_ntohl(src_addr); + + if (IN_MULTICAST(dest_addr_h)) + { + /* Check multicast topic resolution values. */ + if ((dest_addr_h != entry->mc_incoming_address_val_h) && (dest_addr_h != entry->mc_outgoing_address_val_h)) + { + /* No match. */ + return (FALSE); + } + /* Check for the correct port. */ + if ((dest_addr_h == entry->mc_incoming_address_val_h) && (pinfo->destport != entry->mc_incoming_udp_port)) + { + /* Wrong incoming port. */ + return (FALSE); + } + if ((dest_addr_h == entry->mc_outgoing_address_val_h) && (pinfo->destport != entry->mc_outgoing_udp_port)) + { + /* Wrong outgoing port. */ + return (FALSE); + } + /* Must be one of ours. */ + return (TRUE); + } + else + { + /* Check unicast topic resolution values. */ + /* Address should be either not specified, or match the src or dest address of the packet. */ + if ((entry->uc_address_val_h == 0) || (entry->uc_address_val_h == dest_addr_h) || (entry->uc_address_val_h == src_addr_h)) + { + if (((pinfo->destport == entry->uc_dest_port) || (pinfo->srcport == entry->uc_dest_port)) + && (((pinfo->destport <= entry->uc_port_high) && (pinfo->destport >= entry->uc_port_low)) + || ((pinfo->srcport <= entry->uc_port_high) && (pinfo->srcport >= entry->uc_port_low)))) + { + /* One of ours, so handle it. */ + return (TRUE); + } + } + } + return (FALSE); +} + +static char * lbmr_tag_find(packet_info * pinfo) +{ + guint idx; + lbmr_tag_entry_t * tag = NULL; + + if (!lbmr_use_tag) + { + return (NULL); + } + for (idx = 0; idx < lbmr_tag_count; ++idx) + { + tag = &(lbmr_tag_entry[idx]); + if (lbmr_match_packet(pinfo, tag)) + { + return tag->name; + } + } + return (NULL); +} + +/*----------------------------------------------------------------------------*/ +/* Handles of all types. */ +/*----------------------------------------------------------------------------*/ +/* Protocol handle */ +static int proto_lbmr = -1; + +/* Dissector handle */ +static dissector_handle_t lbmr_dissector_handle; + +/* Dissector tree handles */ +static gint ett_lbmr = -1; +static gint ett_lbmr_hdr = -1; +static gint ett_lbmr_hdr_ver_type = -1; +static gint ett_lbmr_tqrs = -1; +static gint ett_lbmr_tqr = -1; +static gint ett_lbmr_tirs = -1; +static gint ett_lbmr_tir = -1; +static gint ett_lbmr_tir_transport = -1; +static gint ett_lbmr_tir_tcp = -1; +static gint ett_lbmr_tir_lbtrm = -1; +static gint ett_lbmr_tir_lbtru = -1; +static gint ett_lbmr_tir_lbtipc = -1; +static gint ett_lbmr_tir_lbtrdma = -1; +static gint ett_lbmr_tir_lbtsmx = -1; +static gint ett_lbmr_topts = -1; +static gint ett_lbmr_topt_len = -1; +static gint ett_lbmr_topt_ume = -1; +static gint ett_lbmr_topt_ume_flags = -1; +static gint ett_lbmr_topt_ume_store = -1; +static gint ett_lbmr_topt_ume_store_flags = -1; +static gint ett_lbmr_topt_ume_store_group = -1; +static gint ett_lbmr_topt_ume_store_group_flags = -1; +static gint ett_lbmr_topt_latejoin = -1; +static gint ett_lbmr_topt_latejoin_flags = -1; +static gint ett_lbmr_topt_umq_rcridx = -1; +static gint ett_lbmr_topt_umq_rcridx_flags = -1; +static gint ett_lbmr_topt_umq_qinfo = -1; +static gint ett_lbmr_topt_umq_qinfo_flags = -1; +static gint ett_lbmr_topt_cost = -1; +static gint ett_lbmr_topt_cost_flags = -1; +static gint ett_lbmr_topt_otid = -1; +static gint ett_lbmr_topt_otid_flags = -1; +static gint ett_lbmr_topt_ctxinst = -1; +static gint ett_lbmr_topt_ctxinst_flags = -1; +static gint ett_lbmr_topt_ctxinsts = -1; +static gint ett_lbmr_topt_ctxinsts_flags = -1; +static gint ett_lbmr_topt_ulb = -1; +static gint ett_lbmr_topt_ulb_flags = -1; +static gint ett_lbmr_topt_ctxinstq = -1; +static gint ett_lbmr_topt_ctxinstq_flags = -1; +static gint ett_lbmr_topt_domain_id = -1; +static gint ett_lbmr_topt_domain_id_flags = -1; +static gint ett_lbmr_topt_exfunc = -1; +static gint ett_lbmr_topt_exfunc_flags = -1; +static gint ett_lbmr_topt_exfunc_functionality_flags = -1; +static gint ett_lbmr_topt_unknown = -1; +static gint ett_lbmr_tmb = -1; +static gint ett_lbmr_tmrs = -1; +static gint ett_lbmr_tmr = -1; +static gint ett_lbmr_tmr_flags = -1; +static gint ett_lbmr_pser_flags = -1; +static gint ett_lbmr_pser_opts = -1; +static gint ett_lbmr_pser_opt_len = -1; +static gint ett_lbmr_pser_opt_ctxinst = -1; +static gint ett_lbmr_qqrs = -1; +static gint ett_lbmr_qirs = -1; +static gint ett_lbmr_qir = -1; +static gint ett_lbmr_qir_options = -1; +static gint ett_lbmr_qir_grp_blks = -1; +static gint ett_lbmr_qir_grp_blk = -1; +static gint ett_lbmr_qir_queue_blk = -1; +static gint ett_lbmr_qir_grp = -1; +static gint ett_lbmr_qir_queue = -1; +static gint ett_lbmr_topic_res_request_flags = -1; +static gint ett_lbmr_ctxinfo_flags = -1; +static gint ett_lbmr_tnwg = -1; +static gint ett_lbmr_tnwg_interest = -1; +static gint ett_lbmr_tnwg_interest_rec = -1; +static gint ett_lbmr_tnwg_interest_rec_flags = -1; +static gint ett_lbmr_tnwg_ctxinfo = -1; +static gint ett_lbmr_tnwg_ctxinfo_flags1 = -1; +static gint ett_lbmr_tnwg_trreq = -1; +static gint ett_lbmr_tnwg_ctxinst_opt = -1; +static gint ett_lbmr_tnwg_ctxinst_opt_flags = -1; +static gint ett_lbmr_tnwg_address_opt = -1; +static gint ett_lbmr_tnwg_address_opt_flags = -1; +static gint ett_lbmr_tnwg_domain_opt = -1; +static gint ett_lbmr_tnwg_domain_opt_flags = -1; +static gint ett_lbmr_tnwg_name_opt = -1; +static gint ett_lbmr_tnwg_name_opt_flags = -1; +static gint ett_lbmr_tnwg_unknown_opt = -1; +static gint ett_lbmr_tnwg_unknown_opt_flags = -1; +static gint ett_lbmr_remote_domain_route_hdr = -1; +static gint ett_lbmr_rctxinfo = -1; +static gint ett_lbmr_rctxinfo_rec = -1; +static gint ett_lbmr_rctxinfo_rec_flags = -1; +static gint ett_lbmr_rctxinfo_rec_address = -1; +static gint ett_lbmr_rctxinfo_rec_instance = -1; +static gint ett_lbmr_rctxinfo_rec_odomain = -1; +static gint ett_lbmr_rctxinfo_rec_name = -1; +static gint ett_lbmr_rctxinfo_rec_unknown = -1; +static gint ett_qmgmt_flags = -1; +static gint ett_qmgmt_il = -1; +static gint ett_qmgmt_il_inst = -1; +static gint ett_qmgmt_il_inst_flags = -1; +static gint ett_qmgmt_ec = -1; +static gint ett_qmgmt_ev = -1; +static gint ett_qmgmt_qro = -1; +static gint ett_lbmr_opts = -1; +static gint ett_lbmr_opt_src_id = -1; +static gint ett_lbmr_opt_src_id_flags = -1; +static gint ett_lbmr_opt_len = -1; +static gint ett_lbmr_opt_src_type = -1; +static gint ett_lbmr_opt_src_type_flags = -1; +static gint ett_lbmr_opt_version = -1; +static gint ett_lbmr_opt_version_flags = -1; +static gint ett_lbmr_opt_local_domain = -1; +static gint ett_lbmr_opt_local_domain_flags = -1; +static gint ett_lbmr_opt_unknown = -1; + +/* Dissector field handles */ +static int hf_lbmr_tag = -1; +static int hf_lbmr_hdr = -1; +static int hf_lbmr_hdr_ver_type = -1; +static int hf_lbmr_hdr_ver_type_ver = -1; +static int hf_lbmr_hdr_ver_type_opt = -1; +static int hf_lbmr_hdr_ver_type_type = -1; +static int hf_lbmr_hdr_tqrs = -1; +static int hf_lbmr_hdr_tirs = -1; +static int hf_lbmr_hdr_qqrs = -1; +static int hf_lbmr_hdr_qirs = -1; +static int hf_lbmr_hdr_ext_type = -1; +static int hf_lbmr_tqrs = -1; +static int hf_lbmr_tqr = -1; +static int hf_lbmr_tqr_pattern_type = -1; +static int hf_lbmr_tqr_pattern = -1; +static int hf_lbmr_tqr_name = -1; +static int hf_lbmr_tirs = -1; +static int hf_lbmr_tir = -1; +static int hf_lbmr_tir_transport = -1; +static int hf_lbmr_tir_transport_opts = -1; +static int hf_lbmr_tir_transport_type = -1; +static int hf_lbmr_tir_tlen = -1; +static int hf_lbmr_tir_ttl = -1; +static int hf_lbmr_tir_index = -1; +static int hf_lbmr_tir_name = -1; +static int hf_lbmr_tir_tcp = -1; +static int hf_lbmr_tir_tcp_ip = -1; +static int hf_lbmr_tir_tcp_session_id = -1; +static int hf_lbmr_tir_tcp_port = -1; +static int hf_lbmr_tir_lbtrm = -1; +static int hf_lbmr_tir_lbtrm_src_addr = -1; +static int hf_lbmr_tir_lbtrm_mcast_addr = -1; +static int hf_lbmr_tir_lbtrm_session_id = -1; +static int hf_lbmr_tir_lbtrm_udp_dest_port = -1; +static int hf_lbmr_tir_lbtrm_src_ucast_port = -1; +static int hf_lbmr_tir_lbtru = -1; +static int hf_lbmr_tir_lbtru_ip = -1; +static int hf_lbmr_tir_lbtru_port = -1; +static int hf_lbmr_tir_lbtru_session_id = -1; +static int hf_lbmr_tir_lbtipc = -1; +static int hf_lbmr_tir_lbtipc_host_id = -1; +static int hf_lbmr_tir_lbtipc_session_id = -1; +static int hf_lbmr_tir_lbtipc_xport_id = -1; +static int hf_lbmr_tir_lbtrdma = -1; +static int hf_lbmr_tir_lbtrdma_ip = -1; +static int hf_lbmr_tir_lbtrdma_session_id = -1; +static int hf_lbmr_tir_lbtrdma_port = -1; +static int hf_lbmr_tir_lbtsmx = -1; +static int hf_lbmr_tir_lbtsmx_host_id = -1; +static int hf_lbmr_tir_lbtsmx_session_id = -1; +static int hf_lbmr_tir_lbtsmx_xport_id = -1; +static int hf_lbmr_tir_channel = -1; +static int hf_lbmr_tir_unknown_transport = -1; +static int hf_lbmr_topts = -1; +static int hf_lbmr_topt_len = -1; +static int hf_lbmr_topt_len_type = -1; +static int hf_lbmr_topt_len_len = -1; +static int hf_lbmr_topt_len_total_len = -1; +static int hf_lbmr_topt_ume = -1; +static int hf_lbmr_topt_ume_type = -1; +static int hf_lbmr_topt_ume_len = -1; +static int hf_lbmr_topt_ume_flags = -1; +static int hf_lbmr_topt_ume_flags_ignore = -1; +static int hf_lbmr_topt_ume_flags_latejoin = -1; +static int hf_lbmr_topt_ume_flags_store = -1; +static int hf_lbmr_topt_ume_flags_qccap = -1; +static int hf_lbmr_topt_ume_flags_acktosrc = -1; +static int hf_lbmr_topt_ume_store_tcp_port = -1; +static int hf_lbmr_topt_ume_src_tcp_port = -1; +static int hf_lbmr_topt_ume_store_tcp_addr = -1; +static int hf_lbmr_topt_ume_src_tcp_addr = -1; +static int hf_lbmr_topt_ume_src_reg_id = -1; +static int hf_lbmr_topt_ume_transport_idx = -1; +static int hf_lbmr_topt_ume_high_seqnum = -1; +static int hf_lbmr_topt_ume_low_seqnum = -1; +static int hf_lbmr_topt_ume_store = -1; +static int hf_lbmr_topt_ume_store_type = -1; +static int hf_lbmr_topt_ume_store_len = -1; +static int hf_lbmr_topt_ume_store_flags = -1; +static int hf_lbmr_topt_ume_store_flags_ignore = -1; +static int hf_lbmr_topt_ume_store_grp_idx = -1; +static int hf_lbmr_topt_ume_store_store_tcp_port = -1; +static int hf_lbmr_topt_ume_store_store_idx = -1; +static int hf_lbmr_topt_ume_store_store_ip_addr = -1; +static int hf_lbmr_topt_ume_store_src_reg_id = -1; +static int hf_lbmr_topt_ume_store_group = -1; +static int hf_lbmr_topt_ume_store_group_type = -1; +static int hf_lbmr_topt_ume_store_group_len = -1; +static int hf_lbmr_topt_ume_store_group_flags = -1; +static int hf_lbmr_topt_ume_store_group_flags_ignore = -1; +static int hf_lbmr_topt_ume_store_group_grp_idx = -1; +static int hf_lbmr_topt_ume_store_group_grp_sz = -1; +static int hf_lbmr_topt_ume_store_group_reserved = -1; +static int hf_lbmr_topt_latejoin = -1; +static int hf_lbmr_topt_latejoin_type = -1; +static int hf_lbmr_topt_latejoin_len = -1; +static int hf_lbmr_topt_latejoin_flags = -1; +static int hf_lbmr_topt_latejoin_flags_ignore = -1; +static int hf_lbmr_topt_latejoin_flags_acktosrc = -1; +static int hf_lbmr_topt_latejoin_src_tcp_port = -1; +static int hf_lbmr_topt_latejoin_reserved = -1; +static int hf_lbmr_topt_latejoin_src_ip_addr = -1; +static int hf_lbmr_topt_latejoin_transport_idx = -1; +static int hf_lbmr_topt_latejoin_high_seqnum = -1; +static int hf_lbmr_topt_latejoin_low_seqnum = -1; +static int hf_lbmr_topt_umq_rcridx = -1; +static int hf_lbmr_topt_umq_rcridx_type = -1; +static int hf_lbmr_topt_umq_rcridx_len = -1; +static int hf_lbmr_topt_umq_rcridx_flags = -1; +static int hf_lbmr_topt_umq_rcridx_flags_ignore = -1; +static int hf_lbmr_topt_umq_rcridx_rcr_idx = -1; +static int hf_lbmr_topt_umq_qinfo = -1; +static int hf_lbmr_topt_umq_qinfo_type = -1; +static int hf_lbmr_topt_umq_qinfo_len = -1; +static int hf_lbmr_topt_umq_qinfo_flags = -1; +static int hf_lbmr_topt_umq_qinfo_flags_ignore = -1; +static int hf_lbmr_topt_umq_qinfo_flags_queue = -1; +static int hf_lbmr_topt_umq_qinfo_flags_rcvlisten = -1; +static int hf_lbmr_topt_umq_qinfo_flags_control = -1; +static int hf_lbmr_topt_umq_qinfo_flags_srcrcvlisten = -1; +static int hf_lbmr_topt_umq_qinfo_flags_participants_only = -1; +static int hf_lbmr_topt_umq_qinfo_queue = -1; +static int hf_lbmr_topt_cost = -1; +static int hf_lbmr_topt_cost_type = -1; +static int hf_lbmr_topt_cost_len = -1; +static int hf_lbmr_topt_cost_flags = -1; +static int hf_lbmr_topt_cost_flags_ignore = -1; +static int hf_lbmr_topt_cost_hop_count = -1; +static int hf_lbmr_topt_cost_cost = -1; +static int hf_lbmr_topt_otid = -1; +static int hf_lbmr_topt_otid_type = -1; +static int hf_lbmr_topt_otid_len = -1; +static int hf_lbmr_topt_otid_flags = -1; +static int hf_lbmr_topt_otid_flags_ignore = -1; +static int hf_lbmr_topt_otid_originating_transport = -1; +static int hf_lbmr_topt_ctxinst = -1; +static int hf_lbmr_topt_ctxinst_type = -1; +static int hf_lbmr_topt_ctxinst_len = -1; +static int hf_lbmr_topt_ctxinst_flags = -1; +static int hf_lbmr_topt_ctxinst_flags_ignore = -1; +static int hf_lbmr_topt_ctxinst_res = -1; +static int hf_lbmr_topt_ctxinst_ctxinst = -1; +static int hf_lbmr_topt_ctxinsts = -1; +static int hf_lbmr_topt_ctxinsts_type = -1; +static int hf_lbmr_topt_ctxinsts_len = -1; +static int hf_lbmr_topt_ctxinsts_flags = -1; +static int hf_lbmr_topt_ctxinsts_flags_ignore = -1; +static int hf_lbmr_topt_ctxinsts_idx = -1; +static int hf_lbmr_topt_ctxinsts_ctxinst = -1; +static int hf_lbmr_topt_ulb = -1; +static int hf_lbmr_topt_ulb_type = -1; +static int hf_lbmr_topt_ulb_len = -1; +static int hf_lbmr_topt_ulb_flags = -1; +static int hf_lbmr_topt_ulb_flags_ignore = -1; +static int hf_lbmr_topt_ulb_queue_id = -1; +static int hf_lbmr_topt_ulb_regid = -1; +static int hf_lbmr_topt_ulb_ulb_src_id = -1; +static int hf_lbmr_topt_ulb_src_ip_addr = -1; +static int hf_lbmr_topt_ulb_src_tcp_port = -1; +static int hf_lbmr_topt_ulb_reserved = -1; +static int hf_lbmr_topt_ctxinstq = -1; +static int hf_lbmr_topt_ctxinstq_type = -1; +static int hf_lbmr_topt_ctxinstq_len = -1; +static int hf_lbmr_topt_ctxinstq_flags = -1; +static int hf_lbmr_topt_ctxinstq_flags_ignore = -1; +static int hf_lbmr_topt_ctxinstq_idx = -1; +static int hf_lbmr_topt_ctxinstq_ctxinst = -1; +static int hf_lbmr_topt_domain_id = -1; +static int hf_lbmr_topt_domain_id_type = -1; +static int hf_lbmr_topt_domain_id_len = -1; +static int hf_lbmr_topt_domain_id_flags = -1; +static int hf_lbmr_topt_domain_id_flags_ignore = -1; +static int hf_lbmr_topt_domain_id_domain_id = -1; +static int hf_lbmr_topt_exfunc = -1; +static int hf_lbmr_topt_exfunc_type = -1; +static int hf_lbmr_topt_exfunc_len = -1; +static int hf_lbmr_topt_exfunc_flags = -1; +static int hf_lbmr_topt_exfunc_flags_ignore = -1; +static int hf_lbmr_topt_exfunc_src_tcp_port = -1; +static int hf_lbmr_topt_exfunc_reserved = -1; +static int hf_lbmr_topt_exfunc_src_ip_addr = -1; +static int hf_lbmr_topt_exfunc_functionality_flags = -1; +static int hf_lbmr_topt_exfunc_functionality_flags_lj = -1; +static int hf_lbmr_topt_exfunc_functionality_flags_ume = -1; +static int hf_lbmr_topt_exfunc_functionality_flags_umq = -1; +static int hf_lbmr_topt_exfunc_functionality_flags_ulb = -1; +static int hf_lbmr_topt_unknown = -1; +static int hf_lbmr_topt_unknown_type = -1; +static int hf_lbmr_topt_unknown_len = -1; +static int hf_lbmr_topt_unknown_flags = -1; +static int hf_lbmr_topt_unknown_data = -1; +static int hf_lbmr_qqr = -1; +static int hf_lbmr_qqr_name = -1; +static int hf_lbmr_qirs = -1; +static int hf_lbmr_qir = -1; +static int hf_lbmr_qir_queue_name = -1; +static int hf_lbmr_qir_topic_name = -1; +static int hf_lbmr_qir_queue_id = -1; +static int hf_lbmr_qir_queue_ver = -1; +static int hf_lbmr_qir_queue_prev_ver = -1; +static int hf_lbmr_qir_grp_blks = -1; +static int hf_lbmr_qir_grp_blks_option_flag = -1; +static int hf_lbmr_qir_grp_blks_count = -1; +static int hf_lbmr_qir_queue_blks = -1; +static int hf_lbmr_qir_grps = -1; +static int hf_lbmr_qir_grp_blk = -1; +static int hf_lbmr_qir_grp_blk_grp_idx = -1; +static int hf_lbmr_qir_grp_blk_grp_sz = -1; +static int hf_lbmr_qir_queues = -1; +static int hf_lbmr_qir_queue_blk = -1; +static int hf_lbmr_qir_queue_blk_ip = -1; +static int hf_lbmr_qir_queue_blk_port = -1; +static int hf_lbmr_qir_queue_blk_idx = -1; +static int hf_lbmr_qir_queue_blk_grp_idx = -1; +static int hf_lbmr_qir_queue_blk_reserved = -1; +static int hf_lbmr_tmb = -1; +static int hf_lbmr_tmb_len = -1; +static int hf_lbmr_tmb_tmrs = -1; +static int hf_lbmr_tmb_tmr_list = -1; +static int hf_lbmr_tmr = -1; +static int hf_lbmr_tmr_len = -1; +static int hf_lbmr_tmr_type = -1; +static int hf_lbmr_tmr_flags = -1; +static int hf_lbmr_tmr_flags_response = -1; +static int hf_lbmr_tmr_flags_wildcard_pcre = -1; +static int hf_lbmr_tmr_flags_wildcard_regex = -1; +static int hf_lbmr_tmr_name = -1; +static int hf_lbmr_pser_dep_type = -1; +static int hf_lbmr_pser_len = -1; +static int hf_lbmr_pser_flags = -1; +static int hf_lbmr_pser_flags_option = -1; +static int hf_lbmr_pser_source_ip = -1; +static int hf_lbmr_pser_store_ip = -1; +static int hf_lbmr_pser_transport_idx = -1; +static int hf_lbmr_pser_topic_idx = -1; +static int hf_lbmr_pser_source_port = -1; +static int hf_lbmr_pser_store_port = -1; +static int hf_lbmr_pser_topic = -1; +static int hf_lbmr_pser_opts = -1; +static int hf_lbmr_pser_optlen = -1; +static int hf_lbmr_pser_optlen_type = -1; +static int hf_lbmr_pser_optlen_optlen = -1; +static int hf_lbmr_pser_opt_ctxinst = -1; +static int hf_lbmr_pser_opt_ctxinst_len = -1; +static int hf_lbmr_pser_opt_ctxinst_type = -1; +static int hf_lbmr_pser_opt_ctxinst_ctxinst = -1; +static int hf_lbmr_opts = -1; +static int hf_lbmr_opt_len = -1; +static int hf_lbmr_opt_len_type = -1; +static int hf_lbmr_opt_len_len = -1; +static int hf_lbmr_opt_len_total_len = -1; +static int hf_lbmr_opt_src_id = -1; +static int hf_lbmr_opt_src_id_type = -1; +static int hf_lbmr_opt_src_id_len = -1; +static int hf_lbmr_opt_src_id_flags = -1; +static int hf_lbmr_opt_src_id_flags_ignore = -1; +static int hf_lbmr_opt_src_id_src_id = -1; +static int hf_lbmr_opt_src_type = -1; +static int hf_lbmr_opt_src_type_type = -1; +static int hf_lbmr_opt_src_type_len = -1; +static int hf_lbmr_opt_src_type_flags = -1; +static int hf_lbmr_opt_src_type_flags_ignore = -1; +static int hf_lbmr_opt_src_type_src_type = -1; +static int hf_lbmr_opt_version = -1; +static int hf_lbmr_opt_version_type = -1; +static int hf_lbmr_opt_version_len = -1; +static int hf_lbmr_opt_version_flags = -1; +static int hf_lbmr_opt_version_flags_ignore = -1; +static int hf_lbmr_opt_version_flags_ume = -1; +static int hf_lbmr_opt_version_flags_umq = -1; +static int hf_lbmr_opt_version_version = -1; +static int hf_lbmr_opt_local_domain = -1; +static int hf_lbmr_opt_local_domain_type = -1; +static int hf_lbmr_opt_local_domain_len = -1; +static int hf_lbmr_opt_local_domain_flags = -1; +static int hf_lbmr_opt_local_domain_flags_ignore = -1; +static int hf_lbmr_opt_local_domain_local_domain_id = -1; +static int hf_lbmr_opt_unknown = -1; +static int hf_lbmr_opt_unknown_type = -1; +static int hf_lbmr_opt_unknown_len = -1; +static int hf_lbmr_opt_unknown_flags = -1; +static int hf_lbmr_opt_unknown_data = -1; +static int hf_lbmr_topic_res_request_flags = -1; +static int hf_lbmr_topic_res_request_flags_gw_remote_interest = -1; +static int hf_lbmr_topic_res_request_flags_context_query = -1; +static int hf_lbmr_topic_res_request_flags_context_advertisement = -1; +static int hf_lbmr_topic_res_request_flags_gateway_meta = -1; +static int hf_lbmr_topic_res_request_flags_advertisement = -1; +static int hf_lbmr_topic_res_request_flags_query = -1; +static int hf_lbmr_topic_res_request_flags_wildcard_query = -1; +static int hf_lbmr_ctxinfo_len = -1; +static int hf_lbmr_ctxinfo_hop_count = -1; +static int hf_lbmr_ctxinfo_flags = -1; +static int hf_lbmr_ctxinfo_flags_query = -1; +static int hf_lbmr_ctxinfo_flags_ip = -1; +static int hf_lbmr_ctxinfo_flags_instance = -1; +static int hf_lbmr_ctxinfo_flags_tnwg_src = -1; +static int hf_lbmr_ctxinfo_flags_tnwg_rcv = -1; +static int hf_lbmr_ctxinfo_flags_proxy = -1; +static int hf_lbmr_ctxinfo_flags_name = -1; +static int hf_lbmr_ctxinfo_port = -1; +static int hf_lbmr_ctxinfo_ip = -1; +static int hf_lbmr_ctxinfo_instance = -1; +static int hf_lbmr_ctxinfo_name = -1; +static int hf_lbmr_tnwg_len = -1; +static int hf_lbmr_tnwg_type = -1; +static int hf_lbmr_tnwg_reserved = -1; +static int hf_lbmr_tnwg_interest = -1; +static int hf_lbmr_tnwg_interest_len = -1; +static int hf_lbmr_tnwg_interest_count = -1; +static int hf_lbmr_tnwg_interest_rec = -1; +static int hf_lbmr_tnwg_interest_rec_len = -1; +static int hf_lbmr_tnwg_interest_rec_flags = -1; +static int hf_lbmr_tnwg_interest_rec_flags_pattern = -1; +static int hf_lbmr_tnwg_interest_rec_flags_cancel = -1; +static int hf_lbmr_tnwg_interest_rec_flags_refresh = -1; +static int hf_lbmr_tnwg_interest_rec_pattype = -1; +static int hf_lbmr_tnwg_interest_rec_domain_id = -1; +static int hf_lbmr_tnwg_interest_rec_symbol = -1; +static int hf_lbmr_tnwg_ctxinfo = -1; +static int hf_lbmr_tnwg_ctxinfo_len = -1; +static int hf_lbmr_tnwg_ctxinfo_hop_count = -1; +static int hf_lbmr_tnwg_ctxinfo_reserved = -1; +static int hf_lbmr_tnwg_ctxinfo_flags1 = -1; +static int hf_lbmr_tnwg_ctxinfo_flags1_query = -1; +static int hf_lbmr_tnwg_ctxinfo_flags1_tnwg_src = -1; +static int hf_lbmr_tnwg_ctxinfo_flags1_tnwg_rcv = -1; +static int hf_lbmr_tnwg_ctxinfo_flags1_proxy = -1; +static int hf_lbmr_tnwg_ctxinfo_flags2 = -1; +static int hf_lbmr_tnwg_trreq = -1; +static int hf_lbmr_tnwg_trreq_len = -1; +static int hf_lbmr_tnwg_opt = -1; +static int hf_lbmr_tnwg_opt_type = -1; +static int hf_lbmr_tnwg_opt_len = -1; +static int hf_lbmr_tnwg_opt_flags = -1; +static int hf_lbmr_tnwg_opt_flags_ignore = -1; +static int hf_lbmr_tnwg_opt_data = -1; +static int hf_lbmr_tnwg_opt_ctxinst = -1; +static int hf_lbmr_tnwg_opt_ctxinst_type = -1; +static int hf_lbmr_tnwg_opt_ctxinst_len = -1; +static int hf_lbmr_tnwg_opt_ctxinst_flags = -1; +static int hf_lbmr_tnwg_opt_ctxinst_flags_ignore = -1; +static int hf_lbmr_tnwg_opt_ctxinst_instance = -1; +static int hf_lbmr_tnwg_opt_address = -1; +static int hf_lbmr_tnwg_opt_address_type = -1; +static int hf_lbmr_tnwg_opt_address_len = -1; +static int hf_lbmr_tnwg_opt_address_flags = -1; +static int hf_lbmr_tnwg_opt_address_flags_ignore = -1; +static int hf_lbmr_tnwg_opt_address_port = -1; +static int hf_lbmr_tnwg_opt_address_res = -1; +static int hf_lbmr_tnwg_opt_address_ip = -1; +static int hf_lbmr_tnwg_opt_domain = -1; +static int hf_lbmr_tnwg_opt_domain_type = -1; +static int hf_lbmr_tnwg_opt_domain_len = -1; +static int hf_lbmr_tnwg_opt_domain_flags = -1; +static int hf_lbmr_tnwg_opt_domain_flags_ignore = -1; +static int hf_lbmr_tnwg_opt_domain_domain_id = -1; +static int hf_lbmr_tnwg_opt_name = -1; +static int hf_lbmr_tnwg_opt_name_type = -1; +static int hf_lbmr_tnwg_opt_name_len = -1; +static int hf_lbmr_tnwg_opt_name_flags = -1; +static int hf_lbmr_tnwg_opt_name_flags_ignore = -1; +static int hf_lbmr_tnwg_opt_name_name = -1; +static int hf_lbmr_remote_domain_route_hdr_num_domains = -1; +static int hf_lbmr_remote_domain_route_hdr_ip = -1; +static int hf_lbmr_remote_domain_route_hdr_port = -1; +static int hf_lbmr_remote_domain_route_hdr_reserved = -1; +static int hf_lbmr_remote_domain_route_hdr_length = -1; +static int hf_lbmr_remote_domain_route_hdr_domain = -1; +static int hf_lbmr_rctxinfo_len = -1; +static int hf_lbmr_rctxinfo_num_recs = -1; +static int hf_lbmr_rctxinfo_reserved = -1; +static int hf_lbmr_rctxinfo_rec = -1; +static int hf_lbmr_rctxinfo_rec_len = -1; +static int hf_lbmr_rctxinfo_rec_flags = -1; +static int hf_lbmr_rctxinfo_rec_flags_query = -1; +static int hf_lbmr_rctxinfo_rec_address = -1; +static int hf_lbmr_rctxinfo_rec_address_type = -1; +static int hf_lbmr_rctxinfo_rec_address_len = -1; +static int hf_lbmr_rctxinfo_rec_address_flags = -1; +static int hf_lbmr_rctxinfo_rec_address_domain_id = -1; +static int hf_lbmr_rctxinfo_rec_address_ip = -1; +static int hf_lbmr_rctxinfo_rec_address_port = -1; +static int hf_lbmr_rctxinfo_rec_address_res = -1; +static int hf_lbmr_rctxinfo_rec_instance = -1; +static int hf_lbmr_rctxinfo_rec_instance_type = -1; +static int hf_lbmr_rctxinfo_rec_instance_len = -1; +static int hf_lbmr_rctxinfo_rec_instance_flags = -1; +static int hf_lbmr_rctxinfo_rec_instance_instance = -1; +static int hf_lbmr_rctxinfo_rec_odomain = -1; +static int hf_lbmr_rctxinfo_rec_odomain_type = -1; +static int hf_lbmr_rctxinfo_rec_odomain_len = -1; +static int hf_lbmr_rctxinfo_rec_odomain_flags = -1; +static int hf_lbmr_rctxinfo_rec_odomain_domain_id = -1; +static int hf_lbmr_rctxinfo_rec_name = -1; +static int hf_lbmr_rctxinfo_rec_name_type = -1; +static int hf_lbmr_rctxinfo_rec_name_len = -1; +static int hf_lbmr_rctxinfo_rec_name_flags = -1; +static int hf_lbmr_rctxinfo_rec_name_name = -1; +static int hf_lbmr_rctxinfo_rec_unknown = -1; +static int hf_lbmr_rctxinfo_rec_unknown_type = -1; +static int hf_lbmr_rctxinfo_rec_unknown_len = -1; +static int hf_lbmr_rctxinfo_rec_unknown_flags = -1; +static int hf_lbmr_rctxinfo_rec_unknown_data = -1; +static int hf_qmgmt_flags = -1; +static int hf_qmgmt_flags_i_flag = -1; +static int hf_qmgmt_flags_n_flag = -1; +static int hf_qmgmt_flags_il_l_flag = -1; +static int hf_qmgmt_flags_il_k_flag = -1; +static int hf_qmgmt_pckt_type = -1; +static int hf_qmgmt_cfgsig = -1; +static int hf_qmgmt_queue_id = -1; +static int hf_qmgmt_queue_ver = -1; +static int hf_qmgmt_ip = -1; +static int hf_qmgmt_port = -1; +static int hf_qmgmt_inst_idx = -1; +static int hf_qmgmt_grp_idx = -1; +static int hf_qmgmt_pckt_type_dep16 = -1; +static int hf_qmgmt_il_num_insts = -1; +static int hf_qmgmt_jrej_code = -1; +static int hf_qmgmt_ev_bias = -1; +static int hf_qmgmt_il = -1; +static int hf_qmgmt_il_highest_rcr_tsp = -1; +static int hf_qmgmt_il_inst = -1; +static int hf_qmgmt_il_inst_ip = -1; +static int hf_qmgmt_il_inst_port = -1; +static int hf_qmgmt_il_inst_inst_idx = -1; +static int hf_qmgmt_il_inst_grp_idx = -1; +static int hf_qmgmt_il_inst_flags = -1; +static int hf_qmgmt_il_inst_flags_m_flag = -1; +static int hf_qmgmt_il_inst_flags_q_flag = -1; +static int hf_qmgmt_il_inst_flags_p_flag = -1; +static int hf_qmgmt_ec = -1; +static int hf_qmgmt_ec_queue_new_ver = -1; +static int hf_qmgmt_ev = -1; +static int hf_qmgmt_ev_highest_rcr_tsp = -1; +static int hf_qmgmt_ev_age = -1; +static int hf_qmgmt_qro = -1; +static int hf_qmgmt_qro_highest_rcr_tsp = -1; +static int hf_qmgmt_qname = -1; + +/* Expert info handles */ +static expert_field ei_lbmr_analysis_length_incorrect = EI_INIT; +static expert_field ei_lbmr_analysis_invalid_value = EI_INIT; +static expert_field ei_lbmr_analysis_zero_len_option = EI_INIT; + +/* Tap handle */ +static int lbmr_tap_handle = -1; + +/*----------------------------------------------------------------------------*/ +/* Statistics. */ +/*----------------------------------------------------------------------------*/ +/* Statistics structures */ +struct tqr_node_t_stct; +struct tqr_node_t_stct +{ + char * topic; + struct tqr_node_t_stct * next; +}; +typedef struct tqr_node_t_stct tqr_node_t; + +struct tir_node_t_stct; +struct tir_node_t_stct +{ + char * topic; + char * source_string; + guint32 index; + struct tir_node_t_stct * next; +}; +typedef struct tir_node_t_stct tir_node_t; + +typedef struct +{ + gint tqr_count; + tqr_node_t * tqr; + gint tir_count; + tir_node_t * tir; + gint wctqr_count; + tqr_node_t * wctqr; +} lbmr_topic_contents_t; + +struct qqr_node_t_stct; +struct qqr_node_t_stct +{ + char * queue; + struct qqr_node_t_stct * next; +}; +typedef struct qqr_node_t_stct qqr_node_t; + +struct qir_node_t_stct; +struct qir_node_t_stct +{ + char * queue; + char * topic; + guint16 port; + struct qir_node_t_stct * next; +}; +typedef struct qir_node_t_stct qir_node_t; + +typedef struct +{ + gint qqr_count; + qqr_node_t * qqr; + gint qir_count; + qir_node_t * qir; +} lbmr_queue_contents_t; + +typedef struct +{ + gint type; + union + { + lbmr_topic_contents_t topic; + lbmr_queue_contents_t queue; + } contents; +} lbmr_contents_t; + +#define LBMR_CONTENTS_TOPIC 0 +#define LBMR_CONTENTS_QUEUE 1 + +/* Statistics titles */ +static const gchar * lbmr_stat_tree_name_topic_ads_topic = "29West/Topics/Advertisements by Topic"; +static const gchar * lbmr_stat_tree_name_topic_ads_source = "29West/Topics/Advertisements by Source"; +static const gchar * lbmr_stat_tree_name_topic_ads_transport = "29West/Topics/Advertisements by Transport"; +static const gchar * lbmr_stat_tree_name_topic_queries_topic = "29West/Topics/Queries by Topic"; +static const gchar * lbmr_stat_tree_name_topic_queries_receiver = "29West/Topics/Queries by Receiver"; +static const gchar * lbmr_stat_tree_name_topic_queries_pattern = "29West/Topics/Wildcard Queries by Pattern"; +static const gchar * lbmr_stat_tree_name_topic_queries_pattern_receiver = "29West/Topics/Wildcard Queries by Receiver"; +static const gchar * lbmr_stat_tree_name_queue_ads_queue = "29West/Queues/Advertisements by Queue"; +static const gchar * lbmr_stat_tree_name_queue_ads_source = "29West/Queues/Advertisements by Source"; +static const gchar * lbmr_stat_tree_name_queue_queries_queue = "29West/Queues/Queries by Queue"; +static const gchar * lbmr_stat_tree_name_queue_queries_receiver = "29West/Queues/Queries by Receiver"; + +/* Statistics handles */ +static int lbmr_stats_tree_handle_topic_ads_topic = -1; +static int lbmr_stats_tree_handle_topic_ads_source = -1; +static int lbmr_stats_tree_handle_topic_ads_transport = -1; +static int lbmr_stats_tree_handle_topic_queries_topic = -1; +static int lbmr_stats_tree_handle_topic_queries_receiver = -1; +static int lbmr_stats_tree_handle_topic_queries_pattern = -1; +static int lbmr_stats_tree_handle_topic_queries_pattern_receiver = -1; +static int lbmr_stats_tree_handle_queue_ads_queue = -1; +static int lbmr_stats_tree_handle_queue_ads_source = -1; +static int lbmr_stats_tree_handle_queue_queries_queue = -1; +static int lbmr_stats_tree_handle_queue_queries_receiver = -1; + +/*----------------------------------------------------------------------------*/ +/* Statistics tree utility functions. */ +/*----------------------------------------------------------------------------*/ + +static void add_contents_tqr(lbmr_contents_t * contents, const char * topic) +{ + tqr_node_t * node = NULL; + + node = wmem_new(wmem_file_scope(), tqr_node_t); + node->topic = wmem_strdup(wmem_file_scope(), topic); + node->next = contents->contents.topic.tqr; + contents->contents.topic.tqr = node; + contents->contents.topic.tqr_count++; +} + +static void add_contents_wctqr(lbmr_contents_t * contents, unsigned char type, const char * pattern) +{ + tqr_node_t * node = NULL; + + node = wmem_new(wmem_file_scope(), tqr_node_t); + node->topic = wmem_strdup_printf(wmem_file_scope(), "%s (%s)", + pattern, + val_to_str(type, lbm_wildcard_pattern_type_short, "UNKN[0x%02x]")); + node->next = contents->contents.topic.wctqr; + contents->contents.topic.wctqr = node; + contents->contents.topic.wctqr_count++; +} + +static void add_contents_tir(lbmr_contents_t * contents, const char * topic, char * source, guint32 topic_index) +{ + tir_node_t * node = NULL; + + node = wmem_new(wmem_file_scope(), tir_node_t); + node->topic = wmem_strdup(wmem_file_scope(), topic); + node->source_string = source; + node->index = topic_index; + node->next = contents->contents.topic.tir; + contents->contents.topic.tir = node; + contents->contents.topic.tir_count++; +} + +static void add_contents_qqr(lbmr_contents_t * contents, const char * queue) +{ + qqr_node_t * node = NULL; + + node = wmem_new(wmem_file_scope(), qqr_node_t); + node->queue = wmem_strdup(wmem_file_scope(), queue); + node->next = contents->contents.queue.qqr; + contents->contents.queue.qqr = node; + contents->contents.queue.qqr_count++; +} + +static void add_contents_qir(lbmr_contents_t * contents, const char * queue, const char * topic, guint16 port) +{ + qir_node_t * node = NULL; + + node = wmem_new(wmem_file_scope(), qir_node_t); + node->queue = wmem_strdup(wmem_file_scope(), queue); + node->topic = wmem_strdup(wmem_file_scope(), topic); + node->port = port; + node->next = contents->contents.queue.qir; + contents->contents.queue.qir = node; + contents->contents.queue.qir_count++; +} + +/*----------------------------------------------------------------------------*/ +/* Topic advertisements by Topic: */ +/* Topic name */ +/* - Source address */ +/* - Source string (including topic index) */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_topic_ads_topic_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_topic_ads_topic = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_topic, 0, TRUE); +} + +static int lbmr_topic_ads_topic_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const tir_node_t * node; + int topic_node; + int source_node; + guint8 str[128]; + const lbmr_topic_contents_t * tc = NULL; + guint8 full_source_string[256]; + + if (contents->type != LBMR_CONTENTS_TOPIC) + { + return (1); + } + tc = &(contents->contents.topic); + if (tc->tir_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_topic_ads_topic, 0, FALSE, tc->tir_count); + for (node = tc->tir; node != NULL; node = node->next) + { + topic_node = tick_stat_node(tree, node->topic, lbmr_stats_tree_handle_topic_ads_topic, TRUE); + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + source_node = tick_stat_node(tree, str, topic_node, TRUE); + g_snprintf(full_source_string, sizeof(full_source_string), "%s[%" G_GUINT32_FORMAT "]", node->source_string, node->index); + tick_stat_node(tree, full_source_string, source_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Topic advertisements by Source: */ +/* Source address */ +/* - Topic name */ +/* - Source string (including topic index) */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_topic_ads_source_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_topic_ads_source = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_source, 0, TRUE); +} + +static int lbmr_topic_ads_source_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const tir_node_t * node; + int source_node; + int topic_node; + guint8 str[128]; + const lbmr_topic_contents_t * tc = NULL; + guint8 full_source_string[256]; + + if (contents->type != LBMR_CONTENTS_TOPIC) + { + return (1); + } + tc = &(contents->contents.topic); + if (tc->tir_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_topic_ads_source, 0, FALSE, tc->tir_count); + for (node = tc->tir; node != NULL; node = node->next) + { + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + source_node = tick_stat_node(tree, str, lbmr_stats_tree_handle_topic_ads_source, TRUE); + topic_node = tick_stat_node(tree, node->topic, source_node, TRUE); + g_snprintf(full_source_string, sizeof(full_source_string), "%s[%" G_GUINT32_FORMAT "]", node->source_string, node->index); + tick_stat_node(tree, full_source_string, topic_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Topic advertisements by Transport: */ +/* Source string */ +/* - Topic name (including topic index) */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_topic_ads_transport_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_topic_ads_transport = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_transport, 0, TRUE); +} + +static int lbmr_topic_ads_transport_stats_tree_packet(stats_tree * tree, packet_info * pinfo _U_, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const tir_node_t * node; + int transport_node; + const lbmr_topic_contents_t * tc = NULL; + guint8 topic_with_index[256]; + + if (contents->type != LBMR_CONTENTS_TOPIC) + { + return (1); + } + tc = &(contents->contents.topic); + if (tc->tir_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_topic_ads_transport, 0, FALSE, tc->tir_count); + for (node = tc->tir; node != NULL; node = node->next) + { + transport_node = tick_stat_node(tree, node->source_string, lbmr_stats_tree_handle_topic_ads_transport, TRUE); + g_snprintf(topic_with_index, sizeof(topic_with_index), "%s [%" G_GUINT32_FORMAT "]", node->topic, node->index); + tick_stat_node(tree, topic_with_index, transport_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Topic queries by Topic: */ +/* Topic name */ +/* - Receiver address */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_topic_queries_topic_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_topic_queries_topic = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_topic, 0, TRUE); +} + +static int lbmr_topic_queries_topic_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const tqr_node_t * node; + int topic_node; + guint8 str[128]; + const lbmr_topic_contents_t * tc = NULL; + + if (contents->type != LBMR_CONTENTS_TOPIC) + { + return (1); + } + tc = &(contents->contents.topic); + if (tc->tqr_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_topic_queries_topic, 0, FALSE, tc->tqr_count); + for (node = tc->tqr; node != NULL; node = node->next) + { + topic_node = tick_stat_node(tree, node->topic, lbmr_stats_tree_handle_topic_queries_topic, TRUE); + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + tick_stat_node(tree, str, topic_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Topic queries by Receiver: */ +/* Receiver address */ +/* - Topic name */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_topic_queries_receiver_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_topic_queries_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_receiver, 0, TRUE); +} + +static int lbmr_topic_queries_receiver_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const tqr_node_t * node; + int receiver_node; + guint8 str[128]; + const lbmr_topic_contents_t * tc = NULL; + + if (contents->type != LBMR_CONTENTS_TOPIC) + { + return (1); + } + tc = &(contents->contents.topic); + if (tc->tqr_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_topic_queries_receiver, 0, FALSE, tc->tqr_count); + for (node = tc->tqr; node != NULL; node = node->next) + { + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + receiver_node = tick_stat_node(tree, str, lbmr_stats_tree_handle_topic_queries_receiver, TRUE); + tick_stat_node(tree, node->topic, receiver_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Topic queries by Pattern: */ +/* Pattern */ +/* - Receiver address */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_topic_queries_pattern_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_topic_queries_pattern = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_pattern, 0, TRUE); +} + +static int lbmr_topic_queries_pattern_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const tqr_node_t * node; + int topic_node; + guint8 str[128]; + const lbmr_topic_contents_t * tc = NULL; + + if (contents->type != LBMR_CONTENTS_TOPIC) + { + return (1); + } + tc = &(contents->contents.topic); + if (tc->wctqr_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_topic_queries_pattern, 0, FALSE, tc->wctqr_count); + for (node = tc->wctqr; node != NULL; node = node->next) + { + topic_node = tick_stat_node(tree, node->topic, lbmr_stats_tree_handle_topic_queries_pattern, TRUE); + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + tick_stat_node(tree, str, topic_node, TRUE); + } + } + return (1); + +} + +/*----------------------------------------------------------------------------*/ +/* Topic queries by Pattern: */ +/* Receiver address */ +/* - Patternme */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_topic_queries_pattern_receiver_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_topic_queries_pattern_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_pattern_receiver, 0, TRUE); +} + +static int lbmr_topic_queries_pattern_receiver_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const tqr_node_t * node; + int receiver_node; + guint8 str[128]; + const lbmr_topic_contents_t * tc = NULL; + + if (contents->type != LBMR_CONTENTS_TOPIC) + { + return (1); + } + tc = &(contents->contents.topic); + if (tc->wctqr_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_topic_queries_pattern_receiver, 0, FALSE, tc->wctqr_count); + for (node = tc->wctqr; node != NULL; node = node->next) + { + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + receiver_node = tick_stat_node(tree, str, lbmr_stats_tree_handle_topic_queries_pattern_receiver, TRUE); + tick_stat_node(tree, node->topic, receiver_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Queue advertisements by Queue: */ +/* Queue name */ +/* - Source address and port */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_queue_ads_queue_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_queue_ads_queue = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_ads_queue, 0, TRUE); +} + +static int lbmr_queue_ads_queue_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const qir_node_t * node; + int queue_node; + guint8 str[128]; + const lbmr_queue_contents_t * qc = NULL; + + if (contents->type != LBMR_CONTENTS_QUEUE) + { + return (1); + } + qc = &(contents->contents.queue); + if (qc->qir_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_queue_ads_queue, 0, FALSE, qc->qir_count); + for (node = qc->qir; node != NULL; node = node->next) + { + queue_node = tick_stat_node(tree, node->queue, lbmr_stats_tree_handle_queue_ads_queue, TRUE); + g_snprintf(str, sizeof(str), "%s:%" G_GUINT32_FORMAT, address_to_str(wmem_file_scope(), &pinfo->net_src), node->port); + tick_stat_node(tree, str, queue_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Queue advertisements by Source: */ +/* Source address */ +/* - Queue name and port */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_queue_ads_source_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_queue_ads_source = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_ads_source, 0, TRUE); +} + +static int lbmr_queue_ads_source_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const qir_node_t * node; + int source_node; + guint8 str[512]; + const lbmr_queue_contents_t * qc = NULL; + + if (contents->type != LBMR_CONTENTS_QUEUE) + { + return (1); + } + qc = &(contents->contents.queue); + if (qc->qir_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_queue_ads_source, 0, FALSE, qc->qir_count); + for (node = qc->qir; node != NULL; node = node->next) + { + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + source_node = tick_stat_node(tree, str, lbmr_stats_tree_handle_queue_ads_source, TRUE); + g_snprintf(str, sizeof(str), "%s [%" G_GUINT16_FORMAT, node->queue, node->port); + tick_stat_node(tree, str, source_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Queue queries by Queue: */ +/* Queue name */ +/* - Receiver address */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_queue_queries_queue_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_queue_queries_queue = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_queries_queue, 0, TRUE); +} + +static int lbmr_queue_queries_queue_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const qqr_node_t * node = NULL; + int queue_node = 0; + guint8 str[128]; + const lbmr_queue_contents_t * qc = NULL; + + if (contents->type != LBMR_CONTENTS_QUEUE) + { + return (1); + } + qc = &(contents->contents.queue); + if (qc->qqr_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_queue_queries_queue, 0, FALSE, qc->qqr_count); + for (node = qc->qqr; node != NULL; node = node->next) + { + queue_node = tick_stat_node(tree, node->queue, lbmr_stats_tree_handle_queue_queries_queue, TRUE); + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + tick_stat_node(tree, str, queue_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Queue queries by Receiver: */ +/* Receiver address */ +/* - Queue name */ +/*----------------------------------------------------------------------------*/ + +static void lbmr_queue_queries_receiver_stats_tree_init(stats_tree * tree) +{ + lbmr_stats_tree_handle_queue_queries_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_queries_receiver, 0, TRUE); +} + +static int lbmr_queue_queries_receiver_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data) +{ + const lbmr_contents_t * contents = (const lbmr_contents_t *)data; + const qqr_node_t * node; + int receiver_node; + guint8 str[128]; + const lbmr_queue_contents_t * qc = NULL; + + if (contents->type != LBMR_CONTENTS_QUEUE) + { + return (1); + } + qc = &(contents->contents.queue); + if (qc->qqr_count > 0) + { + increase_stat_node(tree, lbmr_stat_tree_name_queue_queries_receiver, 0, FALSE, qc->qqr_count); + for (node = qc->qqr; node != NULL; node = node->next) + { + g_snprintf(str, sizeof(str), "%s", address_to_str(wmem_file_scope(), &pinfo->net_src)); + receiver_node = tick_stat_node(tree, str, lbmr_stats_tree_handle_queue_queries_receiver, TRUE); + tick_stat_node(tree, node->queue, receiver_node, TRUE); + } + } + return (1); +} + +/*----------------------------------------------------------------------------*/ +/* Dissector functions. */ +/*----------------------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------*/ +/* LBMR TNWG option dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_tnwg_ctxinst_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * opt_tree = NULL; + proto_item * opt_item = NULL; + guint8 opt_len = 0; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + + opt_len = tvb_get_guint8(tvb, offset + O_LBMR_TNWG_OPT_CTXINST_T_LEN); + opt_item = proto_tree_add_item(tree, hf_lbmr_tnwg_opt_ctxinst, tvb, offset, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_tnwg_ctxinst_opt); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_ctxinst_type, tvb, offset + O_LBMR_TNWG_OPT_CTXINST_T_TYPE, L_LBMR_TNWG_OPT_CTXINST_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_ctxinst_len, tvb, offset + O_LBMR_TNWG_OPT_CTXINST_T_LEN, L_LBMR_TNWG_OPT_CTXINST_T_LEN, ENC_BIG_ENDIAN); + + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_ctxinst_flags, tvb, offset + O_LBMR_TNWG_OPT_CTXINST_T_FLAGS, L_LBMR_TNWG_OPT_CTXINST_T_FLAGS, ENC_BIG_ENDIAN); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_tnwg_ctxinst_opt_flags); + proto_tree_add_item(flags_tree, hf_lbmr_tnwg_opt_ctxinst_flags_ignore, tvb, offset + O_LBMR_TNWG_OPT_CTXINST_T_FLAGS, L_LBMR_TNWG_OPT_CTXINST_T_FLAGS, ENC_BIG_ENDIAN); + + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_ctxinst_instance, tvb, offset + O_LBMR_TNWG_OPT_CTXINST_T_INSTANCE, L_LBMR_TNWG_OPT_CTXINST_T_INSTANCE, ENC_NA); + return ((int) opt_len); +} + +static int dissect_lbmr_tnwg_address_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * opt_tree = NULL; + proto_item * opt_item = NULL; + guint8 opt_len = 0; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + + opt_len = tvb_get_guint8(tvb, offset + O_LBMR_TNWG_OPT_ADDRESS_T_LEN); + opt_item = proto_tree_add_item(tree, hf_lbmr_tnwg_opt_address, tvb, offset, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_tnwg_address_opt); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_address_type, tvb, offset + O_LBMR_TNWG_OPT_ADDRESS_T_TYPE, L_LBMR_TNWG_OPT_ADDRESS_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_address_len, tvb, offset + O_LBMR_TNWG_OPT_ADDRESS_T_LEN, L_LBMR_TNWG_OPT_ADDRESS_T_LEN, ENC_BIG_ENDIAN); + + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_address_flags, tvb, offset + O_LBMR_TNWG_OPT_ADDRESS_T_FLAGS, L_LBMR_TNWG_OPT_ADDRESS_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_tnwg_address_opt_flags); + proto_tree_add_item(flags_tree, hf_lbmr_tnwg_opt_address_flags_ignore, tvb, offset + O_LBMR_TNWG_OPT_ADDRESS_T_FLAGS, L_LBMR_TNWG_OPT_ADDRESS_T_FLAGS, ENC_BIG_ENDIAN); + + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_address_port, tvb, offset + O_LBMR_TNWG_OPT_ADDRESS_T_PORT, L_LBMR_TNWG_OPT_ADDRESS_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_address_res, tvb, offset + O_LBMR_TNWG_OPT_ADDRESS_T_RES, L_LBMR_TNWG_OPT_ADDRESS_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_address_ip, tvb, offset + O_LBMR_TNWG_OPT_ADDRESS_T_IP, L_LBMR_TNWG_OPT_ADDRESS_T_IP, ENC_BIG_ENDIAN); + return ((int)opt_len); +} + +static int dissect_lbmr_tnwg_domain_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * opt_tree = NULL; + proto_item * opt_item = NULL; + guint8 opt_len = 0; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + + opt_len = tvb_get_guint8(tvb, offset + O_LBMR_TNWG_OPT_DOMAIN_T_LEN); + opt_item = proto_tree_add_item(tree, hf_lbmr_tnwg_opt_domain, tvb, offset, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_tnwg_domain_opt); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_domain_type, tvb, offset + O_LBMR_TNWG_OPT_DOMAIN_T_TYPE, L_LBMR_TNWG_OPT_DOMAIN_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_domain_len, tvb, offset + O_LBMR_TNWG_OPT_DOMAIN_T_LEN, L_LBMR_TNWG_OPT_DOMAIN_T_LEN, ENC_BIG_ENDIAN); + + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_domain_flags, tvb, offset + O_LBMR_TNWG_OPT_DOMAIN_T_FLAGS, L_LBMR_TNWG_OPT_DOMAIN_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_tnwg_domain_opt_flags); + proto_tree_add_item(flags_tree, hf_lbmr_tnwg_opt_domain_flags_ignore, tvb, offset + O_LBMR_TNWG_OPT_DOMAIN_T_FLAGS, L_LBMR_TNWG_OPT_DOMAIN_T_FLAGS, ENC_BIG_ENDIAN); + + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_domain_domain_id, tvb, offset + O_LBMR_TNWG_OPT_DOMAIN_T_DOMAIN_ID, L_LBMR_TNWG_OPT_DOMAIN_T_DOMAIN_ID, ENC_BIG_ENDIAN); + return ((int)opt_len); +} + +static int dissect_lbmr_tnwg_name_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * opt_tree = NULL; + proto_item * opt_item = NULL; + guint8 opt_len = 0; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + guint32 name_len = 0; + + opt_len = tvb_get_guint8(tvb, offset + O_LBMR_TNWG_OPT_T_LEN); + name_len = opt_len - L_LBMR_TNWG_OPT_T; + opt_item = proto_tree_add_item(tree, hf_lbmr_tnwg_opt_name, tvb, offset, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_tnwg_name_opt); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_name_type, tvb, offset + O_LBMR_TNWG_OPT_T_TYPE, L_LBMR_TNWG_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_name_len, tvb, offset + O_LBMR_TNWG_OPT_T_LEN, L_LBMR_TNWG_OPT_T_LEN, ENC_BIG_ENDIAN); + + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_name_flags, tvb, offset + O_LBMR_TNWG_OPT_T_FLAGS, L_LBMR_TNWG_OPT_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_tnwg_name_opt_flags); + proto_tree_add_item(flags_tree, hf_lbmr_tnwg_opt_name_flags_ignore, tvb, offset + O_LBMR_TNWG_OPT_T_FLAGS, L_LBMR_TNWG_OPT_T_FLAGS, ENC_BIG_ENDIAN); + + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_name_name, tvb, offset + L_LBMR_TNWG_OPT_T, name_len, ENC_ASCII|ENC_NA); + return ((int)opt_len); +} + +static int dissect_lbmr_tnwg_unknown_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * opt_tree = NULL; + proto_item * opt_item = NULL; + guint8 opt_len = 0; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + guint32 data_len = 0; + + opt_len = tvb_get_guint8(tvb, offset + O_LBMR_TNWG_OPT_T_LEN); + data_len = opt_len - L_LBMR_TNWG_OPT_T; + opt_item = proto_tree_add_item(tree, hf_lbmr_tnwg_opt, tvb, offset, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_tnwg_unknown_opt); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_type, tvb, offset + O_LBMR_TNWG_OPT_T_TYPE, L_LBMR_TNWG_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_len, tvb, offset + O_LBMR_TNWG_OPT_T_LEN, L_LBMR_TNWG_OPT_T_LEN, ENC_BIG_ENDIAN); + + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_flags, tvb, offset + O_LBMR_TNWG_OPT_T_FLAGS, L_LBMR_TNWG_OPT_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_tnwg_unknown_opt_flags); + proto_tree_add_item(flags_tree, hf_lbmr_tnwg_opt_flags_ignore, tvb, offset + O_LBMR_TNWG_OPT_T_FLAGS, L_LBMR_TNWG_OPT_T_FLAGS, ENC_BIG_ENDIAN); + + proto_tree_add_item(opt_tree, hf_lbmr_tnwg_opt_data, tvb, offset + L_LBMR_TNWG_OPT_T, data_len, ENC_NA); + return ((int)opt_len); +} + +static int dissect_lbmr_tnwg_opts(tvbuff_t * tvb, int offset, int length, packet_info * pinfo, proto_tree * tree) +{ + int len_remaining = length; + int curr_offset = offset; + int dissected_len = 0; + guint8 type = 0; + int len_used = 0; + + while (len_remaining >= L_LBMR_TNWG_OPT_T) + { + type = tvb_get_guint8(tvb, curr_offset); + switch (type) + { + case LBMR_TNWG_OPT_CTXINST_TYPE: + dissected_len += dissect_lbmr_tnwg_ctxinst_opt(tvb, curr_offset, pinfo, tree); + break; + case LBMR_TNWG_OPT_ADDRESS_TYPE: + dissected_len += dissect_lbmr_tnwg_address_opt(tvb, curr_offset, pinfo, tree); + break; + case LBMR_TNWG_OPT_DOMAIN_TYPE: + dissected_len += dissect_lbmr_tnwg_domain_opt(tvb, curr_offset, pinfo, tree); + break; + case LBMR_TNWG_OPT_NAME_TYPE: + dissected_len += dissect_lbmr_tnwg_name_opt(tvb, curr_offset, pinfo, tree); + break; + default: + dissected_len += dissect_lbmr_tnwg_unknown_opt(tvb, curr_offset, pinfo, tree); + break; + } + len_remaining -= dissected_len; + len_used += dissected_len; + curr_offset += dissected_len; + } + return (len_used); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR TNWG Interest dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_tnwg_interest_rec(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * rec_tree = NULL; + proto_item * rec_item = NULL; + guint16 rec_len = 0; + gint string_len = 0; + guint8 flags = 0; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + + rec_len = tvb_get_ntohs(tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_LEN); + flags = tvb_get_guint8(tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_FLAGS); + string_len = rec_len - L_LBMR_TNWG_INTEREST_REC_T; + + rec_item = proto_tree_add_item(tree, hf_lbmr_tnwg_interest_rec, tvb, offset, rec_len, ENC_NA); + rec_tree = proto_item_add_subtree(rec_item, ett_lbmr_tnwg_interest_rec); + proto_tree_add_item(rec_tree, hf_lbmr_tnwg_interest_rec_len, tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_LEN, L_LBMR_TNWG_INTEREST_REC_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_none_format(rec_tree, hf_lbmr_tnwg_interest_rec_flags, tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_FLAGS, L_LBMR_TNWG_INTEREST_REC_T_FLAGS, "Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_tnwg_interest_rec_flags); + proto_tree_add_item(flags_tree, hf_lbmr_tnwg_interest_rec_flags_pattern, tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_FLAGS, L_LBMR_TNWG_INTEREST_REC_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_tnwg_interest_rec_flags_cancel, tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_FLAGS, L_LBMR_TNWG_INTEREST_REC_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_tnwg_interest_rec_flags_refresh, tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_FLAGS, L_LBMR_TNWG_INTEREST_REC_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(rec_tree, hf_lbmr_tnwg_interest_rec_pattype, tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_PATTYPE, L_LBMR_TNWG_INTEREST_REC_T_PATTYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(rec_tree, hf_lbmr_tnwg_interest_rec_domain_id, tvb, offset + O_LBMR_TNWG_INTEREST_REC_T_DOMAIN_ID, L_LBMR_TNWG_INTEREST_REC_T_DOMAIN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(rec_tree, hf_lbmr_tnwg_interest_rec_symbol, tvb, offset + L_LBMR_TNWG_INTEREST_REC_T, string_len, ENC_ASCII|ENC_NA); + return ((int)rec_len); +} + +static int dissect_lbmr_tnwg_interest(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_tree * int_tree = NULL; + proto_item * int_item = NULL; + guint16 rec_count = 0; + int curr_offset = 0; + int len = 0; + int len_remaining = 0; + int len_dissected = 0; + + len_remaining = tvb_get_ntohs(tvb, offset + O_LBMR_TNWG_INTEREST_T_LEN); + rec_count = tvb_get_ntohs(tvb, offset + O_LBMR_TNWG_INTEREST_T_COUNT); + int_item = proto_tree_add_item(tree, hf_lbmr_tnwg_interest, tvb, offset, len_remaining, ENC_NA); + int_tree = proto_item_add_subtree(int_item, ett_lbmr_tnwg_interest); + proto_tree_add_item(int_tree, hf_lbmr_tnwg_interest_len, tvb, offset + O_LBMR_TNWG_INTEREST_T_LEN, L_LBMR_TNWG_INTEREST_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(int_tree, hf_lbmr_tnwg_interest_count, tvb, offset + O_LBMR_TNWG_INTEREST_T_COUNT, L_LBMR_TNWG_INTEREST_T_COUNT, ENC_BIG_ENDIAN); + + curr_offset = offset + L_LBMR_TNWG_INTEREST_T; + len = L_LBMR_TNWG_INTEREST_T; + while (rec_count > 0) + { + len_dissected = dissect_lbmr_tnwg_interest_rec(tvb, curr_offset, pinfo, int_tree); + curr_offset += len_dissected; + len += len_dissected; + rec_count--; + } + return (len); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR TNWG ContextInfo dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_tnwg_ctxinfo(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_tree * ctxinfo_tree = NULL; + proto_item * ctxinfo_item = NULL; + proto_tree * flags1_tree = NULL; + proto_item * flags1_item = NULL; + guint32 flags1 = 0; + wmem_strbuf_t * flagbuf; + const char * sep = ""; + guint16 reclen = 0; + guint16 len_remaining = 0; + int len_used = 0; + + reclen = tvb_get_ntohs(tvb, offset + O_LBMR_TNWG_CTXINFO_T_LEN); + len_remaining = reclen; + flags1 = tvb_get_ntohl(tvb, offset + O_LBMR_TNWG_CTXINFO_T_FLAGS1); + + ctxinfo_item = proto_tree_add_item(tree, hf_lbmr_tnwg_ctxinfo, tvb, offset, (gint)reclen, ENC_NA); + ctxinfo_tree = proto_item_add_subtree(ctxinfo_item, ett_lbmr_tnwg_ctxinfo); + proto_tree_add_item(ctxinfo_tree, hf_lbmr_tnwg_ctxinfo_len, tvb, offset + O_LBMR_TNWG_CTXINFO_T_LEN, L_LBMR_TNWG_CTXINFO_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(ctxinfo_tree, hf_lbmr_tnwg_ctxinfo_hop_count, tvb, offset + O_LBMR_TNWG_CTXINFO_T_HOP_COUNT, L_LBMR_TNWG_CTXINFO_T_HOP_COUNT, ENC_BIG_ENDIAN); + proto_tree_add_item(ctxinfo_tree, hf_lbmr_tnwg_ctxinfo_reserved, tvb, offset + O_LBMR_TNWG_CTXINFO_T_RESERVED, L_LBMR_TNWG_CTXINFO_T_RESERVED, ENC_BIG_ENDIAN); + + flagbuf = wmem_strbuf_new_label(wmem_packet_scope()); + if ((flags1 & LBMR_TNWG_CTXINFO_QUERY_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "Query"); + sep = ", "; + } + if ((flags1 & LBMR_TNWG_CTXINFO_TNWG_SRC_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "GW Src"); + sep = ", "; + } + if ((flags1 & LBMR_TNWG_CTXINFO_TNWG_RCV_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "GW Rcv"); + sep = ", "; + } + if ((flags1 & LBMR_TNWG_CTXINFO_PROXY_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "Proxy"); + } + if (flags1 != 0) + { + flags1_item = proto_tree_add_none_format(ctxinfo_tree, hf_lbmr_tnwg_ctxinfo_flags1, tvb, offset + O_LBMR_TNWG_CTXINFO_T_FLAGS1, L_LBMR_TNWG_CTXINFO_T_FLAGS1, "Flags1: 0x%04x (%s)", flags1, wmem_strbuf_get_str(flagbuf)); + } + else + { + flags1_item = proto_tree_add_item(ctxinfo_tree, hf_lbmr_tnwg_ctxinfo_flags1, tvb, offset + O_LBMR_TNWG_CTXINFO_T_FLAGS1, L_LBMR_TNWG_CTXINFO_T_FLAGS1, ENC_NA); + } + flags1_tree = proto_item_add_subtree(flags1_item, ett_lbmr_tnwg_ctxinfo_flags1); + proto_tree_add_item(flags1_tree, hf_lbmr_tnwg_ctxinfo_flags1_query, tvb, offset + O_LBMR_TNWG_CTXINFO_T_FLAGS1, L_LBMR_TNWG_CTXINFO_T_FLAGS1, ENC_BIG_ENDIAN); + proto_tree_add_item(flags1_tree, hf_lbmr_tnwg_ctxinfo_flags1_tnwg_src, tvb, offset + O_LBMR_TNWG_CTXINFO_T_FLAGS1, L_LBMR_TNWG_CTXINFO_T_FLAGS1, ENC_BIG_ENDIAN); + proto_tree_add_item(flags1_tree, hf_lbmr_tnwg_ctxinfo_flags1_tnwg_rcv, tvb, offset + O_LBMR_TNWG_CTXINFO_T_FLAGS1, L_LBMR_TNWG_CTXINFO_T_FLAGS1, ENC_BIG_ENDIAN); + proto_tree_add_item(flags1_tree, hf_lbmr_tnwg_ctxinfo_flags1_proxy, tvb, offset + O_LBMR_TNWG_CTXINFO_T_FLAGS1, L_LBMR_TNWG_CTXINFO_T_FLAGS1, ENC_BIG_ENDIAN); + proto_tree_add_item(ctxinfo_tree, hf_lbmr_tnwg_ctxinfo_flags2, tvb, offset + O_LBMR_TNWG_CTXINFO_T_FLAGS2, L_LBMR_TNWG_CTXINFO_T_FLAGS2, ENC_BIG_ENDIAN); + + offset += L_LBMR_TNWG_CTXINFO_T; + len_remaining -= L_LBMR_TNWG_CTXINFO_T; + len_used = L_LBMR_TNWG_CTXINFO_T; + if (len_remaining >= L_LBMR_TNWG_OPT_T) + { + len_used += dissect_lbmr_tnwg_opts(tvb, offset, len_remaining, pinfo, ctxinfo_tree); + } + return (len_used); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR TNWG TopicRes Request dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_tnwg_trreq(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_tree * trreq_tree = NULL; + proto_item * trreq_item = NULL; + guint16 reclen = 0; + guint16 len_remaining = 0; + int len_used = 0; + + reclen = tvb_get_ntohs(tvb, offset + O_LBMR_TNWG_TRREQ_T_LEN); + len_remaining = reclen; + + trreq_item = proto_tree_add_item(tree, hf_lbmr_tnwg_trreq, tvb, offset, (gint)reclen, ENC_NA); + trreq_tree = proto_item_add_subtree(trreq_item, ett_lbmr_tnwg_trreq); + proto_tree_add_item(trreq_tree, hf_lbmr_tnwg_trreq_len, tvb, offset + O_LBMR_TNWG_TRREQ_T_LEN, L_LBMR_TNWG_TRREQ_T_LEN, ENC_BIG_ENDIAN); + + offset += L_LBMR_TNWG_TRREQ_T; + len_remaining -= L_LBMR_TNWG_TRREQ_T; + len_used = L_LBMR_TNWG_TRREQ_T; + if (len_remaining >= L_LBMR_TNWG_OPT_T) + { + len_used += dissect_lbmr_tnwg_opts(tvb, offset, len_remaining, pinfo, trreq_tree); + } + return (len_used); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR TNWG dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_tnwg(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + guint16 type = 0; + int curr_offset = 0; + int len_dissected = 0; + proto_item * type_item = NULL; + + type = tvb_get_ntohs(tvb, offset + O_LBMR_TNWG_T_TYPE); + proto_tree_add_item(tree, hf_lbmr_tnwg_len, tvb, offset + O_LBMR_TNWG_T_LEN, L_LBMR_TNWG_T_LEN, ENC_BIG_ENDIAN); + type_item = proto_tree_add_item(tree, hf_lbmr_tnwg_type, tvb, offset + O_LBMR_TNWG_T_TYPE, L_LBMR_TNWG_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_tnwg_reserved, tvb, offset + O_LBMR_TNWG_T_RESERVED, L_LBMR_TNWG_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected = L_LBMR_TNWG_T; + curr_offset = offset + L_LBMR_TNWG_T; + switch (type) + { + case LBMR_TNWG_TYPE_INTEREST: + len_dissected += dissect_lbmr_tnwg_interest(tvb, curr_offset, pinfo, tree); + break; + case LBMR_TNWG_TYPE_CTXINFO: + len_dissected += dissect_lbmr_tnwg_ctxinfo(tvb, curr_offset, pinfo, tree); + break; + case LBMR_TNWG_TYPE_TRREQ: + len_dissected += dissect_lbmr_tnwg_trreq(tvb, curr_offset, pinfo, tree); + break; + default: + expert_add_info_format(pinfo, type_item, &ei_lbmr_analysis_invalid_value, "Unknown LBMR TNWG type 0x%04x", type); + break; + } + return ((int)len_dissected); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Topic Management dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_tmr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + gint namelen = 0; + int name_offset = 0; + char * name = NULL; + proto_item * ti = NULL; + proto_tree * tinfo_tree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + guint16 tmr_len; + guint8 tmr_type; + guint8 tmr_flags; + char workbuf[256]; + + tmr_len = tvb_get_ntohs(tvb, offset + O_LBMR_TMR_T_LEN); + tmr_type = tvb_get_guint8(tvb, offset + O_LBMR_TMR_T_TYPE); + tmr_flags = tvb_get_guint8(tvb, offset + O_LBMR_TMR_T_FLAGS); + name_offset = offset + L_LBMR_TMR_T; + + name = tvb_get_stringz_enc(wmem_packet_scope(), tvb, name_offset, &namelen, ENC_ASCII); + + memset(workbuf, 0, sizeof(workbuf)); + switch (tmr_type) + { + case LBMR_TMR_LEAVE_TOPIC: + default: + break; + case LBMR_TMR_TOPIC_USE: + if (tmr_flags & LBMR_TMR_FLAG_RESPONSE) + { + g_snprintf((gchar *)workbuf, (gulong)sizeof(workbuf), "%s", " Response"); + } + else + { + g_snprintf((gchar *)workbuf, (gulong)sizeof(workbuf), "%s", " Query"); + } + break; + } + ti = proto_tree_add_none_format(tree, hf_lbmr_tmr, tvb, offset, tmr_len, "%s: %s%s, Length %" G_GUINT16_FORMAT, name, val_to_str(tmr_type, lbmr_tmr_type, "Unknown (0x%02x)"), workbuf, tmr_len); + tinfo_tree = proto_item_add_subtree(ti, ett_lbmr_tmr); + proto_tree_add_item(tinfo_tree, hf_lbmr_tmr_len, tvb, offset + O_LBMR_TMR_T_LEN, L_LBMR_TMR_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(tinfo_tree, hf_lbmr_tmr_type, tvb, offset + O_LBMR_TMR_T_TYPE, L_LBMR_TMR_T_TYPE, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(tinfo_tree, hf_lbmr_tmr_flags, tvb, offset + O_LBMR_TMR_T_FLAGS, L_LBMR_TMR_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_tmr_flags); + proto_tree_add_item(flags_tree, hf_lbmr_tmr_flags_response, tvb, offset + O_LBMR_TMR_T_FLAGS, L_LBMR_TMR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_tmr_flags_wildcard_pcre, tvb, offset + O_LBMR_TMR_T_FLAGS, L_LBMR_TMR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_tmr_flags_wildcard_regex, tvb, offset + O_LBMR_TMR_T_FLAGS, L_LBMR_TMR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(tinfo_tree, hf_lbmr_tmr_name, tvb, name_offset, namelen, ENC_ASCII|ENC_NA); + return ((int) tmr_len); +} + +static int dissect_lbmr_tmb(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + int tmr_len = 0; + proto_tree * tmb_tree = NULL; + proto_item * ti = NULL; + proto_tree * tmr_tree = NULL; + proto_item * tmr_ti = NULL; + int tmr_count = 0; + guint16 tmrs; + int len_dissected; + + tmrs = tvb_get_ntohs(tvb, offset + O_LBMR_TMB_T_TMRS); + ti = proto_tree_add_item(tree, hf_lbmr_tmb, tvb, offset, -1, ENC_NA); + tmb_tree = proto_item_add_subtree(ti, ett_lbmr_tmb); + proto_tree_add_item(tmb_tree, hf_lbmr_tmb_len, tvb, offset + O_LBMR_TMB_T_LEN, L_LBMR_TMB_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(tmb_tree, hf_lbmr_tmb_tmrs, tvb, offset + O_LBMR_TMB_T_TMRS, L_LBMR_TMB_T_TMRS, ENC_BIG_ENDIAN); + tmr_ti = proto_tree_add_item(tmb_tree, hf_lbmr_tmb_tmr_list, tvb, offset + L_LBMR_TMB_T, -1, ENC_NA); + tmr_tree = proto_item_add_subtree(tmr_ti, ett_lbmr_tmrs); + + offset += L_LBMR_TMB_T; + len_dissected = L_LBMR_TMB_T; + while (tmr_count < tmrs) + { + tmr_len = dissect_lbmr_tmr(tvb, offset, pinfo, tmr_tree); + len_dissected += tmr_len; + offset += tmr_len; + tmr_count++; + } + return (len_dissected); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Topic Query Record dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_tqr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, gboolean wildcard_tqr, lbmr_contents_t * contents) +{ + gint namelen = 0; + guint reclen = 0; + char * name = NULL; + guint8 pattern_type; + proto_item * tqr_item = NULL; + proto_tree * tqr_tree = NULL; + gint name_offset = offset; + + if (wildcard_tqr) + { + pattern_type = tvb_get_guint8(tvb, offset); + name_offset++; + reclen++; + } + name = tvb_get_stringz_enc(wmem_packet_scope(), tvb, name_offset, &namelen, ENC_ASCII); + reclen += namelen; + + if (wildcard_tqr) + { + tqr_item = proto_tree_add_none_format(tree, hf_lbmr_tqr, tvb, offset, reclen, "Wildcard TQR: %s", name); + } + else + { + tqr_item = proto_tree_add_none_format(tree, hf_lbmr_tqr, tvb, offset, reclen, "TQR: %s", name); + } + tqr_tree = proto_item_add_subtree(tqr_item, ett_lbmr_tqr); + if (wildcard_tqr) + { + proto_tree_add_item(tqr_tree, hf_lbmr_tqr_pattern_type, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tqr_tree, hf_lbmr_tqr_pattern, tvb, offset, namelen, ENC_ASCII|ENC_NA); + add_contents_wctqr(contents, pattern_type, name); + } + else + { + proto_tree_add_item(tqr_tree, hf_lbmr_tqr_name, tvb, offset, namelen, ENC_ASCII|ENC_NA); + add_contents_tqr(contents, name); + } + return (reclen); +} + +static int dissect_lbmr_tqrs(tvbuff_t * tvb, int offset, guint8 tqr_count, packet_info * pinfo, proto_tree * tree, + gboolean wildcard_tqr, lbmr_contents_t * contents) +{ + int start_offset = 0; + int tqr_len = 0; + proto_tree * tqrs_tree = NULL; + proto_item * ti = NULL; + int len = 0; + + start_offset = offset; + if (wildcard_tqr) + { + ti = proto_tree_add_none_format(tree, hf_lbmr_tqrs, tvb, start_offset, -1, "Wildcard TQRs"); + } + else + { + ti = proto_tree_add_none_format(tree, hf_lbmr_tqrs, tvb, start_offset, -1, "TQRs"); + } + tqrs_tree = proto_item_add_subtree(ti, ett_lbmr_tqrs); + while (tqr_count-- > 0) + { + tqr_len = dissect_lbmr_tqr(tvb, offset, pinfo, tqrs_tree, wildcard_tqr, contents); + len += tqr_len; + offset += tqr_len; + } + proto_item_set_len(ti, len); + return (len); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Topic Information Record dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_tir_options(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + guint8 opt_type = 0; + guint8 opt_len = 0; + int opt_total_len = 0; + int opt_remaining_len = 0; + int curr_offset = offset; + proto_item * oi = NULL; + proto_tree * otree = NULL; + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * fflags_item = NULL; + proto_tree * fflags_tree = NULL; + proto_item * optlen_item = NULL; + proto_tree * optlen_tree = NULL; + int len = 0; + + opt_total_len = (int)tvb_get_ntohs(tvb, curr_offset + O_LBMR_TOPIC_OPT_LEN_T_TOTAL_LEN); + opt_remaining_len = opt_total_len; + + oi = proto_tree_add_none_format(tree, hf_lbmr_topts, tvb, curr_offset, opt_total_len, "Options: %d bytes", opt_total_len); + otree = proto_item_add_subtree(oi, ett_lbmr_topts); + optlen_item = proto_tree_add_item(otree, hf_lbmr_topt_len, tvb, curr_offset, L_LBMR_TOPIC_OPT_LEN_T, ENC_NA); + optlen_tree = proto_item_add_subtree(optlen_item, ett_lbmr_topt_len); + proto_tree_add_item(optlen_tree, hf_lbmr_topt_len_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_LEN_T_TYPE, L_LBMR_TOPIC_OPT_LEN_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(optlen_tree, hf_lbmr_topt_len_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_LEN_T_LEN, L_LBMR_TOPIC_OPT_LEN_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(optlen_tree, hf_lbmr_topt_len_total_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_LEN_T_TOTAL_LEN, L_LBMR_TOPIC_OPT_LEN_T_TOTAL_LEN, ENC_BIG_ENDIAN); + len = L_LBMR_TOPIC_OPT_LEN_T; + curr_offset += L_LBMR_TOPIC_OPT_LEN_T; + opt_remaining_len -= L_LBMR_TOPIC_OPT_LEN_T; + while (opt_remaining_len > 0) + { + proto_item * opt_item = NULL; + proto_tree * opt_tree = NULL; + proto_item * ei_item = NULL; + int qname_len; + + opt_type = tvb_get_guint8(tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE); + opt_len = tvb_get_guint8(tvb, curr_offset + O_LBMR_TOPIC_OPT_T_LEN); + if (opt_len == 0) + { + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_unknown, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_unknown); + proto_tree_add_item(opt_tree, hf_lbmr_topt_unknown_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, L_LBMR_TOPIC_OPT_T_TYPE, ENC_BIG_ENDIAN); + ei_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_unknown_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_LEN, L_LBMR_TOPIC_OPT_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_unknown_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + if (((int) opt_len) > L_LBMR_TOPIC_OPT_T) + { + proto_tree_add_item(opt_tree, hf_lbmr_topt_unknown_data, tvb, curr_offset + L_LBMR_TOPIC_OPT_T, ((int) opt_len) - L_LBMR_TOPIC_OPT_T, ENC_NA); + } + expert_add_info_format(pinfo, ei_item, &ei_lbmr_analysis_zero_len_option, "Zero-length LBMR option"); + return (len); + } + switch (opt_type) + { + case LBMR_TOPIC_OPT_UME_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_ume, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_ume); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_TYPE, L_LBMR_TOPIC_OPT_UME_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_LEN, L_LBMR_TOPIC_OPT_UME_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_FLAGS, L_LBMR_TOPIC_OPT_UME_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_ume_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ume_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_FLAGS, L_LBMR_TOPIC_OPT_UME_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ume_flags_latejoin, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_FLAGS, L_LBMR_TOPIC_OPT_UME_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ume_flags_store, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_FLAGS, L_LBMR_TOPIC_OPT_UME_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ume_flags_qccap, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_FLAGS, L_LBMR_TOPIC_OPT_UME_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ume_flags_acktosrc, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_FLAGS, L_LBMR_TOPIC_OPT_UME_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_tcp_port, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_STORE_TCP_PORT, L_LBMR_TOPIC_OPT_UME_T_STORE_TCP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_src_tcp_port, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_SRC_TCP_PORT, L_LBMR_TOPIC_OPT_UME_T_SRC_TCP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_tcp_addr, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_STORE_TCP_ADDR, L_LBMR_TOPIC_OPT_UME_T_STORE_TCP_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_src_tcp_addr, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_SRC_TCP_ADDR, L_LBMR_TOPIC_OPT_UME_T_SRC_TCP_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_src_reg_id, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_SRC_REG_ID, L_LBMR_TOPIC_OPT_UME_T_SRC_REG_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_transport_idx, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_TRANSPORT_IDX, L_LBMR_TOPIC_OPT_UME_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_high_seqnum, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_HIGH_SEQNUM, L_LBMR_TOPIC_OPT_UME_T_HIGH_SEQNUM, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_low_seqnum, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_T_LOW_SEQNUM, L_LBMR_TOPIC_OPT_UME_T_LOW_SEQNUM, ENC_BIG_ENDIAN); + break; + case LBMR_TOPIC_OPT_UME_STORE_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_ume_store, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_ume_store); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_TYPE, L_LBMR_TOPIC_OPT_UME_STORE_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_LEN, L_LBMR_TOPIC_OPT_UME_STORE_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_FLAGS, L_LBMR_TOPIC_OPT_UME_STORE_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_ume_store_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ume_store_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_FLAGS, L_LBMR_TOPIC_OPT_UME_STORE_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_grp_idx, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_GRP_IDX, L_LBMR_TOPIC_OPT_UME_STORE_T_GRP_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_store_tcp_port, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_STORE_TCP_PORT, L_LBMR_TOPIC_OPT_UME_STORE_T_STORE_TCP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_store_idx, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_STORE_IDX, L_LBMR_TOPIC_OPT_UME_STORE_T_STORE_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_store_ip_addr, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_STORE_IP_ADDR, L_LBMR_TOPIC_OPT_UME_STORE_T_STORE_IP_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_src_reg_id, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_T_SRC_REG_ID, L_LBMR_TOPIC_OPT_UME_STORE_T_SRC_REG_ID, ENC_BIG_ENDIAN); + break; + case LBMR_TOPIC_OPT_UME_STORE_GROUP_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_ume_store_group, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_ume_store_group); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_group_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_TYPE, L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_group_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_LEN, L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_group_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_FLAGS, L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_ume_store_group_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ume_store_group_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_FLAGS, L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_group_grp_idx, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_GRP_IDX, L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_GRP_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_group_grp_sz, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_GRP_SZ, L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_GRP_SZ, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ume_store_group_reserved, tvb, curr_offset + O_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_RESERVED, L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_RESERVED, ENC_BIG_ENDIAN); + break; + case LBMR_TOPIC_OPT_LATEJOIN_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_latejoin, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_latejoin); + proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_TYPE, L_LBMR_TOPIC_OPT_LATEJOIN_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_LEN, L_LBMR_TOPIC_OPT_LATEJOIN_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS, L_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_latejoin_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_latejoin_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS, L_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_latejoin_flags_acktosrc, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS, L_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_src_tcp_port, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_SRC_TCP_PORT, L_LBMR_TOPIC_OPT_LATEJOIN_T_SRC_TCP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_reserved, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_RESERVED, L_LBMR_TOPIC_OPT_LATEJOIN_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_src_ip_addr, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_SRC_IP_ADDR, L_LBMR_TOPIC_OPT_LATEJOIN_T_SRC_IP_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_transport_idx, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_TRANSPORT_IDX, L_LBMR_TOPIC_OPT_LATEJOIN_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_high_seqnum, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_HIGH_SEQNUM, L_LBMR_TOPIC_OPT_LATEJOIN_T_HIGH_SEQNUM, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_latejoin_low_seqnum, tvb, curr_offset + O_LBMR_TOPIC_OPT_LATEJOIN_T_LOW_SEQNUM, L_LBMR_TOPIC_OPT_LATEJOIN_T_LOW_SEQNUM, ENC_BIG_ENDIAN); + break; + case LBMR_TOPIC_OPT_UMQ_RCRIDX_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_umq_rcridx, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_umq_rcridx); + proto_tree_add_item(opt_tree, hf_lbmr_topt_umq_rcridx_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_TYPE, L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_umq_rcridx_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_LEN, L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_umq_rcridx_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_FLAGS, L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_umq_rcridx_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_umq_rcridx_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_FLAGS, L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_umq_rcridx_rcr_idx, tvb, curr_offset + O_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_RCR_IDX, L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_RCR_IDX, ENC_BIG_ENDIAN); + break; + case LBMR_TOPIC_OPT_UMQ_QINFO_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_umq_qinfo, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_umq_qinfo); + proto_tree_add_item(opt_tree, hf_lbmr_topt_umq_qinfo_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, L_LBMR_TOPIC_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_umq_qinfo_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_LEN, L_LBMR_TOPIC_OPT_T_LEN, ENC_BIG_ENDIAN); + qname_len = opt_len - L_LBMR_TOPIC_OPT_T; + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_umq_qinfo_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_umq_qinfo_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_umq_qinfo_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_umq_qinfo_flags_queue, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_umq_qinfo_flags_rcvlisten, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_umq_qinfo_flags_control, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_umq_qinfo_flags_srcrcvlisten, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topt_umq_qinfo_flags_participants_only, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_umq_qinfo_queue, tvb, curr_offset + L_LBMR_TOPIC_OPT_T, qname_len, ENC_ASCII|ENC_NA); + break; + case LBMR_TOPIC_OPT_COST_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_cost, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_cost); + proto_tree_add_item(opt_tree, hf_lbmr_topt_cost_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_COST_T_TYPE, L_LBMR_TOPIC_OPT_COST_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_cost_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_COST_T_LEN, L_LBMR_TOPIC_OPT_COST_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_cost_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_COST_T_FLAGS, L_LBMR_TOPIC_OPT_COST_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_cost_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_cost_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_COST_T_FLAGS, L_LBMR_TOPIC_OPT_COST_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_cost_hop_count, tvb, curr_offset + O_LBMR_TOPIC_OPT_COST_T_HOP_COUNT, L_LBMR_TOPIC_OPT_COST_T_HOP_COUNT, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_cost_cost, tvb, curr_offset + O_LBMR_TOPIC_OPT_COST_T_COST, L_LBMR_TOPIC_OPT_COST_T_COST, ENC_BIG_ENDIAN); + break; + case LBMR_TOPIC_OPT_OTID_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_otid, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_otid); + proto_tree_add_item(opt_tree, hf_lbmr_topt_otid_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_OTID_T_TYPE, L_LBMR_TOPIC_OPT_OTID_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_otid_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_OTID_T_LEN, L_LBMR_TOPIC_OPT_OTID_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_otid_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_OTID_T_FLAGS, L_LBMR_TOPIC_OPT_OTID_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_otid_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_otid_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_OTID_T_FLAGS, L_LBMR_TOPIC_OPT_OTID_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_otid_originating_transport, tvb, curr_offset + O_LBMR_TOPIC_OPT_OTID_T_ORIGINATING_TRANSPORT, L_LBMR_TOPIC_OPT_OTID_T_ORIGINATING_TRANSPORT, ENC_NA); + break; + case LBMR_TOPIC_OPT_CTXINST_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_ctxinst, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_ctxinst); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinst_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINST_T_TYPE, L_LBMR_TOPIC_OPT_CTXINST_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinst_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINST_T_LEN, L_LBMR_TOPIC_OPT_CTXINST_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinst_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINST_T_FLAGS, L_LBMR_TOPIC_OPT_CTXINST_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_ctxinst_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ctxinst_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINST_T_FLAGS, L_LBMR_TOPIC_OPT_CTXINST_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinst_res, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINST_T_RES, L_LBMR_TOPIC_OPT_CTXINST_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinst_ctxinst, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINST_T_CTXINST, L_LBMR_TOPIC_OPT_CTXINST_T_CTXINST, ENC_NA); + break; + case LBMR_TOPIC_OPT_CTXINSTS_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_ctxinsts, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_ctxinsts); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinsts_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTS_T_TYPE, L_LBMR_TOPIC_OPT_CTXINSTS_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinsts_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTS_T_LEN, L_LBMR_TOPIC_OPT_CTXINSTS_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinsts_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTS_T_FLAGS, L_LBMR_TOPIC_OPT_CTXINSTS_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_ctxinsts_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ctxinsts_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTS_T_FLAGS, L_LBMR_TOPIC_OPT_CTXINSTS_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinsts_idx, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTS_T_IDX, L_LBMR_TOPIC_OPT_CTXINSTS_T_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinsts_ctxinst, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTS_T_CTXINST, L_LBMR_TOPIC_OPT_CTXINSTS_T_CTXINST, ENC_NA); + break; + case LBMR_TOPIC_OPT_ULB_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_ulb, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_ulb); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_TYPE, L_LBMR_TOPIC_OPT_ULB_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_LEN, L_LBMR_TOPIC_OPT_ULB_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_FLAGS, L_LBMR_TOPIC_OPT_ULB_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_ulb_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ulb_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_FLAGS, L_LBMR_TOPIC_OPT_ULB_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_queue_id, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_QUEUE_ID, L_LBMR_TOPIC_OPT_ULB_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_regid, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_REGID, L_LBMR_TOPIC_OPT_ULB_T_REGID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_ulb_src_id, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_ULB_SRC_ID, L_LBMR_TOPIC_OPT_ULB_T_ULB_SRC_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_src_ip_addr, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_SRC_IP_ADDR, L_LBMR_TOPIC_OPT_ULB_T_SRC_IP_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_src_tcp_port, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_SRC_TCP_PORT, L_LBMR_TOPIC_OPT_ULB_T_SRC_TCP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ulb_reserved, tvb, curr_offset + O_LBMR_TOPIC_OPT_ULB_T_RESERVED, L_LBMR_TOPIC_OPT_ULB_T_RESERVED, ENC_BIG_ENDIAN); + break; + case LBMR_TOPIC_OPT_CTXINSTQ_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_ctxinstq, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_ctxinstq); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinstq_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTQ_T_TYPE, L_LBMR_TOPIC_OPT_CTXINSTQ_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinstq_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTQ_T_LEN, L_LBMR_TOPIC_OPT_CTXINSTQ_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinstq_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTQ_T_FLAGS, L_LBMR_TOPIC_OPT_CTXINSTQ_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_ctxinstq_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_ctxinstq_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTQ_T_FLAGS, L_LBMR_TOPIC_OPT_CTXINSTQ_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinstq_idx, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTQ_T_IDX, L_LBMR_TOPIC_OPT_CTXINSTQ_T_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_ctxinstq_ctxinst, tvb, curr_offset + O_LBMR_TOPIC_OPT_CTXINSTQ_T_CTXINST, L_LBMR_TOPIC_OPT_CTXINSTQ_T_CTXINST, ENC_NA); + break; + case LBMR_TOPIC_OPT_DOMAIN_ID_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_domain_id, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_domain_id); + proto_tree_add_item(opt_tree, hf_lbmr_topt_domain_id_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_DOMAIN_ID_T_TYPE, L_LBMR_TOPIC_OPT_DOMAIN_ID_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_domain_id_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_DOMAIN_ID_T_LEN, L_LBMR_TOPIC_OPT_DOMAIN_ID_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_domain_id_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_DOMAIN_ID_T_FLAGS, L_LBMR_TOPIC_OPT_DOMAIN_ID_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_domain_id_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_domain_id_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_DOMAIN_ID_T_FLAGS, L_LBMR_TOPIC_OPT_DOMAIN_ID_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_domain_id_domain_id, tvb, curr_offset + O_LBMR_TOPIC_OPT_DOMAIN_ID_T_DOMAIN_ID, L_LBMR_TOPIC_OPT_DOMAIN_ID_T_DOMAIN_ID, ENC_BIG_ENDIAN); + break; + case LBMR_TOPIC_OPT_EXFUNC_TYPE: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_exfunc, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_exfunc); + proto_tree_add_item(opt_tree, hf_lbmr_topt_exfunc_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_TYPE, L_LBMR_TOPIC_OPT_EXFUNC_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_exfunc_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_LEN, L_LBMR_TOPIC_OPT_EXFUNC_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_exfunc_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_FLAGS, L_LBMR_TOPIC_OPT_EXFUNC_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topt_exfunc_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topt_exfunc_flags_ignore, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_FLAGS, L_LBMR_TOPIC_OPT_EXFUNC_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_exfunc_src_tcp_port, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_SRC_TCP_PORT, L_LBMR_TOPIC_OPT_EXFUNC_T_SRC_TCP_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_exfunc_reserved, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_RESERVED, L_LBMR_TOPIC_OPT_EXFUNC_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_exfunc_src_ip_addr, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_SRC_IP_ADDR, L_LBMR_TOPIC_OPT_EXFUNC_T_SRC_IP_ADDR, ENC_BIG_ENDIAN); + fflags_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_exfunc_functionality_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, ENC_NA); + fflags_tree = proto_item_add_subtree(fflags_item, ett_lbmr_topt_exfunc_functionality_flags); + proto_tree_add_item(fflags_tree, hf_lbmr_topt_exfunc_functionality_flags_ulb, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(fflags_tree, hf_lbmr_topt_exfunc_functionality_flags_umq, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(fflags_tree, hf_lbmr_topt_exfunc_functionality_flags_ume, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(fflags_tree, hf_lbmr_topt_exfunc_functionality_flags_lj, tvb, curr_offset + O_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS, ENC_BIG_ENDIAN); + break; + default: + opt_item = proto_tree_add_item(otree, hf_lbmr_topt_unknown, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, opt_len, ENC_NA); + opt_tree = proto_item_add_subtree(opt_item, ett_lbmr_topt_unknown); + ei_item = proto_tree_add_item(opt_tree, hf_lbmr_topt_unknown_type, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_TYPE, L_LBMR_TOPIC_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_unknown_len, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_LEN, L_LBMR_TOPIC_OPT_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbmr_topt_unknown_flags, tvb, curr_offset + O_LBMR_TOPIC_OPT_T_FLAGS, L_LBMR_TOPIC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + if (((int) opt_len) > L_LBMR_TOPIC_OPT_T) + { + proto_tree_add_item(opt_tree, hf_lbmr_topt_unknown_data, tvb, curr_offset + L_LBMR_TOPIC_OPT_T, ((int) opt_len) - L_LBMR_TOPIC_OPT_T, ENC_NA); + } + expert_add_info_format(pinfo, ei_item, &ei_lbmr_analysis_invalid_value, "Unknown option 0x%02x", opt_type); + break; + } + len += opt_len; + curr_offset += opt_len; + opt_remaining_len -= opt_len; + } + return (opt_total_len); +} + +static int dissect_lbmr_tir_transport(tvbuff_t * tvb, int offset, lbm_uint8_t transport, lbm_uint8_t transport_len, const char * topic_name, + guint32 topic_index, packet_info * pinfo, proto_tree * tree, lbmr_contents_t * contents, proto_item * transport_len_item) +{ + int len = 0; + guint64 channel; + proto_item * channel_item = NULL; + proto_item * ei_item = NULL; + + switch (transport) + { + case LBMR_TRANSPORT_TCP: + { + guint16 port = 0; + guint32 session_id = 0; + proto_item * tcp_item = NULL; + proto_tree * tcp_tree = NULL; + lbttcp_transport_t * lbttcp_transport = NULL; + + tcp_item = proto_tree_add_item(tree, hf_lbmr_tir_tcp, tvb, offset, (gint) transport_len, ENC_NA); + tcp_tree = proto_item_add_subtree(tcp_item, ett_lbmr_tir_tcp); + if ((transport_len != L_LBMR_TIR_TCP_T) && (transport_len != L_LBMR_TIR_TCP_WITH_SID_T)) + { + expert_add_info_format(pinfo, transport_len_item, &ei_lbmr_analysis_length_incorrect, "Wrong transport length for LBMR TIR TCP info"); + return (0); + } + if (transport_len == L_LBMR_TIR_TCP_WITH_SID_T) + { + session_id = tvb_get_ntohl(tvb, offset + O_LBMR_TIR_TCP_WITH_SID_T_SESSION_ID); + port = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_TCP_WITH_SID_T_PORT); + proto_tree_add_item(tcp_tree, hf_lbmr_tir_tcp_ip, tvb, offset + O_LBMR_TIR_TCP_WITH_SID_T_IP, L_LBMR_TIR_TCP_WITH_SID_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(tcp_tree, hf_lbmr_tir_tcp_session_id, tvb, offset + O_LBMR_TIR_TCP_WITH_SID_T_SESSION_ID, L_LBMR_TIR_TCP_WITH_SID_T_SESSION_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(tcp_tree, hf_lbmr_tir_tcp_port, tvb, offset + O_LBMR_TIR_TCP_WITH_SID_T_PORT, L_LBMR_TIR_TCP_WITH_SID_T_PORT, ENC_BIG_ENDIAN); + len += L_LBMR_TIR_TCP_WITH_SID_T; + } + else + { + port = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_TCP_T_PORT); + proto_tree_add_item(tcp_tree, hf_lbmr_tir_tcp_ip, tvb, offset + O_LBMR_TIR_TCP_T_IP, L_LBMR_TIR_TCP_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(tcp_tree, hf_lbmr_tir_tcp_port, tvb, offset + O_LBMR_TIR_TCP_T_PORT, L_LBMR_TIR_TCP_T_PORT, ENC_BIG_ENDIAN); + session_id = 0; + len += L_LBMR_TIR_TCP_T; + } + lbttcp_transport = lbttcp_transport_add(&(pinfo->src), port, session_id, 0); + channel = lbttcp_transport->channel; + add_contents_tir(contents, topic_name, lbttcp_transport_source_string(&(pinfo->src), port, session_id), topic_index); + } + break; + case LBMR_TRANSPORT_LBTRM: + { + guint16 src_ucast_port = 0; + guint16 udp_dest_port = 0; + guint32 session_id = 0; + proto_item * lbtrm_item = NULL; + proto_tree * lbtrm_tree = NULL; + lbtrm_transport_t * lbtrm_transport = NULL; + address multicast_group; + + lbtrm_item = proto_tree_add_item(tree, hf_lbmr_tir_lbtrm, tvb, offset, (gint)transport_len, ENC_NA); + lbtrm_tree = proto_item_add_subtree(lbtrm_item, ett_lbmr_tir_lbtrm); + TVB_SET_ADDRESS(&multicast_group, AT_IPv4, tvb, offset + O_LBMR_TIR_LBTRM_T_MCAST_ADDR, L_LBMR_TIR_LBTRM_T_MCAST_ADDR); + session_id = tvb_get_ntohl(tvb, offset + O_LBMR_TIR_LBTRM_T_SESSION_ID); + udp_dest_port = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_LBTRM_T_UDP_DEST_PORT); + src_ucast_port = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_LBTRM_T_SRC_UCAST_PORT); + proto_tree_add_item(lbtrm_tree, hf_lbmr_tir_lbtrm_src_addr, tvb, offset + O_LBMR_TIR_LBTRM_T_SRC_ADDR, L_LBMR_TIR_LBTRM_T_SRC_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtrm_tree, hf_lbmr_tir_lbtrm_mcast_addr, tvb, offset + O_LBMR_TIR_LBTRM_T_MCAST_ADDR, L_LBMR_TIR_LBTRM_T_MCAST_ADDR, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtrm_tree, hf_lbmr_tir_lbtrm_session_id, tvb, offset + O_LBMR_TIR_LBTRM_T_SESSION_ID, L_LBMR_TIR_LBTRM_T_SESSION_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtrm_tree, hf_lbmr_tir_lbtrm_udp_dest_port, tvb, offset + O_LBMR_TIR_LBTRM_T_UDP_DEST_PORT, L_LBMR_TIR_LBTRM_T_UDP_DEST_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtrm_tree, hf_lbmr_tir_lbtrm_src_ucast_port, tvb, offset + O_LBMR_TIR_LBTRM_T_SRC_UCAST_PORT, L_LBMR_TIR_LBTRM_T_SRC_UCAST_PORT, ENC_BIG_ENDIAN); + lbtrm_transport = lbtrm_transport_add(&(pinfo->src), src_ucast_port, session_id, &multicast_group, udp_dest_port, 0); + channel = lbtrm_transport->channel; + add_contents_tir(contents, topic_name, lbtrm_transport_source_string(&(pinfo->src), src_ucast_port, session_id, &multicast_group, udp_dest_port), topic_index); + len += L_LBMR_TIR_LBTRM_T; + if (transport_len != L_LBMR_TIR_LBTRM_T) + { + expert_add_info_format(pinfo, transport_len_item, &ei_lbmr_analysis_length_incorrect, "Wrong transport length for LBMR TIR LBTRM info"); + } + } + break; + case LBMR_TRANSPORT_LBTRU: + { + guint32 session_id; + guint16 port; + proto_item * lbtru_item = NULL; + proto_tree * lbtru_tree = NULL; + lbtru_transport_t * lbtru_transport = NULL; + + lbtru_item = proto_tree_add_item(tree, hf_lbmr_tir_lbtru, tvb, offset, (gint)transport_len, ENC_NA); + lbtru_tree = proto_item_add_subtree(lbtru_item, ett_lbmr_tir_lbtru); + if ((transport_len != L_LBMR_TIR_LBTRU_T) && (transport_len != L_LBMR_TIR_LBTRU_WITH_SID_T)) + { + expert_add_info_format(pinfo, transport_len_item, &ei_lbmr_analysis_length_incorrect, "Wrong transport length for LBMR TIR LBTRU info"); + return (0); + } + if (transport_len == L_LBMR_TIR_LBTRU_WITH_SID_T) + { + session_id = tvb_get_ntohl(tvb, offset + O_LBMR_TIR_LBTRU_WITH_SID_T_SESSION_ID); + port = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_LBTRU_WITH_SID_T_PORT); + proto_tree_add_item(lbtru_tree, hf_lbmr_tir_lbtru_ip, tvb, offset + O_LBMR_TIR_LBTRU_WITH_SID_T_IP, L_LBMR_TIR_LBTRU_WITH_SID_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtru_tree, hf_lbmr_tir_lbtru_session_id, tvb, offset + O_LBMR_TIR_LBTRU_WITH_SID_T_SESSION_ID, L_LBMR_TIR_LBTRU_WITH_SID_T_SESSION_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtru_tree, hf_lbmr_tir_lbtru_port, tvb, offset + O_LBMR_TIR_LBTRU_WITH_SID_T_PORT, L_LBMR_TIR_LBTRU_WITH_SID_T_PORT, ENC_BIG_ENDIAN); + len += L_LBMR_TIR_LBTRU_WITH_SID_T; + } + else + { + session_id = 0; + port = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_LBTRU_T_PORT); + proto_tree_add_item(lbtru_tree, hf_lbmr_tir_lbtru_ip, tvb, offset + O_LBMR_TIR_LBTRU_T_IP, L_LBMR_TIR_LBTRU_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtru_tree, hf_lbmr_tir_lbtru_port, tvb, offset + O_LBMR_TIR_LBTRU_T_PORT, L_LBMR_TIR_LBTRU_T_PORT, ENC_BIG_ENDIAN); + len += L_LBMR_TIR_LBTRU_T; + } + lbtru_transport = lbtru_transport_add(&(pinfo->src), port, session_id, 0); + channel = lbtru_transport->channel; + add_contents_tir(contents, topic_name, lbtru_transport_source_string(&(pinfo->src), port, session_id), topic_index); + } + break; + case LBMR_TRANSPORT_LBTIPC: + { + guint32 host_id; + guint32 session_id; + guint16 xport_id; + proto_item * lbtipc_item = NULL; + proto_tree * lbtipc_tree = NULL; + lbtipc_transport_t * lbtipc_transport = NULL; + + lbtipc_item = proto_tree_add_item(tree, hf_lbmr_tir_lbtipc, tvb, offset, (gint)transport_len, ENC_NA); + lbtipc_tree = proto_item_add_subtree(lbtipc_item, ett_lbmr_tir_lbtipc); + if (transport_len != L_LBMR_TIR_LBTIPC_T) + { + expert_add_info_format(pinfo, transport_len_item, &ei_lbmr_analysis_length_incorrect, "Wrong transport length for LBMR TIR LBTIPC info"); + return (0); + } + host_id = tvb_get_ntohl(tvb, offset + O_LBMR_TIR_LBTIPC_T_HOST_ID); + session_id = tvb_get_ntohl(tvb, offset + O_LBMR_TIR_LBTIPC_T_SESSION_ID); + xport_id = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_LBTIPC_T_XPORT_ID); + proto_tree_add_item(lbtipc_tree, hf_lbmr_tir_lbtipc_host_id, tvb, offset + O_LBMR_TIR_LBTIPC_T_HOST_ID, L_LBMR_TIR_LBTIPC_T_HOST_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtipc_tree, hf_lbmr_tir_lbtipc_session_id, tvb, offset + O_LBMR_TIR_LBTIPC_T_SESSION_ID, L_LBMR_TIR_LBTIPC_T_SESSION_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtipc_tree, hf_lbmr_tir_lbtipc_xport_id, tvb, offset + O_LBMR_TIR_LBTIPC_T_XPORT_ID, L_LBMR_TIR_LBTIPC_T_XPORT_ID, ENC_BIG_ENDIAN); + lbtipc_transport = lbtipc_transport_add(host_id, session_id, xport_id); + channel = lbtipc_transport->channel; + add_contents_tir(contents, topic_name, lbtipc_transport_source_string(host_id, session_id, xport_id), topic_index); + len += L_LBMR_TIR_LBTIPC_T; + } + break; + case LBMR_TRANSPORT_LBTRDMA: + { + guint32 session_id; + guint16 port; + proto_item * lbtrdma_item = NULL; + proto_tree * lbtrdma_tree = NULL; + lbtrdma_transport_t * lbtrdma_transport = NULL; + address source_addr; + + lbtrdma_item = proto_tree_add_item(tree, hf_lbmr_tir_lbtrdma, tvb, offset, (gint)transport_len, ENC_NA); + lbtrdma_tree = proto_item_add_subtree(lbtrdma_item, ett_lbmr_tir_lbtrdma); + if (transport_len != L_LBMR_TIR_LBTRDMA_T) + { + expert_add_info_format(pinfo, transport_len_item, &ei_lbmr_analysis_length_incorrect, "Wrong transport length for LBMR TIR LBTRDMA info"); + return (0); + } + TVB_SET_ADDRESS(&source_addr, AT_IPv4, tvb, offset + O_LBMR_TIR_LBTRDMA_T_IP, L_LBMR_TIR_LBTRDMA_T_IP); + session_id = tvb_get_ntohl(tvb, offset + O_LBMR_TIR_LBTRDMA_T_SESSION_ID); + port = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_LBTRDMA_T_PORT); + proto_tree_add_item(lbtrdma_tree, hf_lbmr_tir_lbtrdma_ip, tvb, offset + O_LBMR_TIR_LBTRDMA_T_IP, L_LBMR_TIR_LBTRDMA_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtrdma_tree, hf_lbmr_tir_lbtrdma_session_id, tvb, offset + O_LBMR_TIR_LBTRDMA_T_SESSION_ID, L_LBMR_TIR_LBTRDMA_T_SESSION_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtrdma_tree, hf_lbmr_tir_lbtrdma_port, tvb, offset + O_LBMR_TIR_LBTRDMA_T_PORT, L_LBMR_TIR_LBTRDMA_T_PORT, ENC_BIG_ENDIAN); + lbtrdma_transport = lbtrdma_transport_add(&source_addr, port, session_id); + channel = lbtrdma_transport->channel; + add_contents_tir(contents, topic_name, lbtrdma_transport_source_string(&source_addr, port, session_id), topic_index); + len += L_LBMR_TIR_LBTRDMA_T; + } + break; + case LBMR_TRANSPORT_LBTSMX: + { + guint32 host_id; + guint32 session_id; + guint16 xport_id; + proto_item * lbtsmx_item = NULL; + proto_tree * lbtsmx_tree = NULL; + lbtsmx_transport_t * lbtsmx_transport = NULL; + + lbtsmx_item = proto_tree_add_item(tree, hf_lbmr_tir_lbtsmx, tvb, offset, (gint)transport_len, ENC_NA); + lbtsmx_tree = proto_item_add_subtree(lbtsmx_item, ett_lbmr_tir_lbtsmx); + if (transport_len != L_LBMR_TIR_LBTSMX_T) + { + expert_add_info_format(pinfo, transport_len_item, &ei_lbmr_analysis_length_incorrect, "Wrong transport length for LBMR TIR LBTSMX info"); + } + host_id = tvb_get_ntohl(tvb, offset + O_LBMR_TIR_LBTSMX_T_HOST_ID); + session_id = tvb_get_ntohl(tvb, offset + O_LBMR_TIR_LBTSMX_T_SESSION_ID); + xport_id = tvb_get_ntohs(tvb, offset + O_LBMR_TIR_LBTSMX_T_XPORT_ID); + proto_tree_add_item(lbtsmx_tree, hf_lbmr_tir_lbtsmx_host_id, tvb, offset + O_LBMR_TIR_LBTSMX_T_HOST_ID, L_LBMR_TIR_LBTSMX_T_HOST_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtsmx_tree, hf_lbmr_tir_lbtsmx_session_id, tvb, offset + O_LBMR_TIR_LBTSMX_T_SESSION_ID, L_LBMR_TIR_LBTSMX_T_SESSION_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(lbtsmx_tree, hf_lbmr_tir_lbtsmx_xport_id, tvb, offset + O_LBMR_TIR_LBTSMX_T_XPORT_ID, L_LBMR_TIR_LBTSMX_T_XPORT_ID, ENC_BIG_ENDIAN); + lbtsmx_transport = lbtsmx_transport_add(host_id, session_id, xport_id); + channel = lbtsmx_transport->channel; + add_contents_tir(contents, topic_name, lbtsmx_transport_source_string(host_id, session_id, xport_id), topic_index); + len += L_LBMR_TIR_LBTSMX_T; + } + break; + default: + ei_item = proto_tree_add_item(tree, hf_lbmr_tir_unknown_transport, tvb, offset, transport_len, ENC_NA); + expert_add_info_format(pinfo, ei_item, &ei_lbmr_analysis_invalid_value, "Unknown LBMR TIR transport 0x%02x", transport); + len = transport_len; + channel = LBM_CHANNEL_NO_CHANNEL; + break; + } + if (channel != LBM_CHANNEL_NO_CHANNEL) + { + lbm_topic_add(channel, topic_index, topic_name); + channel_item = proto_tree_add_uint64(tree, hf_lbmr_tir_channel, tvb, 0, 0, channel); + PROTO_ITEM_SET_GENERATED(channel_item); + } + return (len); +} + +static int dissect_lbmr_tir_entry(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, lbmr_contents_t * contents) +{ + gint namelen = 0; + gint reclen = 0; + int dissect_len = 0; + int tinfo_offset = 0; + char * name = NULL; + proto_item * ti = NULL; + proto_tree * tinfo_tree = NULL; + guint8 transport; + guint8 tlen; + guint16 ttl; + guint32 idx; + int curr_offset; + proto_item * transport_item = NULL; + proto_tree * transport_tree = NULL; + proto_item * transport_len_item = NULL; + + name = tvb_get_stringz_enc(wmem_packet_scope(), tvb, offset, &namelen, ENC_ASCII); + reclen += namelen; + curr_offset = offset + namelen; + tinfo_offset = curr_offset; + transport = tvb_get_guint8(tvb, curr_offset + O_LBMR_TIR_T_TRANSPORT); + tlen = tvb_get_guint8(tvb, curr_offset + O_LBMR_TIR_T_TLEN); + ttl = tvb_get_ntohs(tvb, curr_offset + O_LBMR_TIR_T_TTL); + idx = tvb_get_ntohl(tvb, curr_offset + O_LBMR_TIR_T_INDEX); + reclen += L_LBMR_TIR_T; + curr_offset += L_LBMR_TIR_T; + + ti = proto_tree_add_none_format(tree, hf_lbmr_tir, tvb, offset, reclen, "%s: %s, Length %u, Index %" G_GUINT32_FORMAT ", TTL %" G_GUINT16_FORMAT, + name, val_to_str((transport & LBMR_TIR_TRANSPORT), lbmr_transport_type, "Unknown (0x%02x)"), tlen, idx, ttl); + tinfo_tree = proto_item_add_subtree(ti, ett_lbmr_tir); + proto_tree_add_item(tinfo_tree, hf_lbmr_tir_name, tvb, offset, namelen, ENC_ASCII|ENC_NA); + transport_item = proto_tree_add_item(tinfo_tree, hf_lbmr_tir_transport, tvb, tinfo_offset + O_LBMR_TIR_T_TRANSPORT, L_LBMR_TIR_T_TRANSPORT, ENC_NA); + transport_tree = proto_item_add_subtree(transport_item, ett_lbmr_tir_transport); + proto_tree_add_item(transport_tree, hf_lbmr_tir_transport_opts, tvb, tinfo_offset + O_LBMR_TIR_T_TRANSPORT, L_LBMR_TIR_T_TRANSPORT, ENC_BIG_ENDIAN); + proto_tree_add_item(transport_tree, hf_lbmr_tir_transport_type, tvb, tinfo_offset + O_LBMR_TIR_T_TRANSPORT, L_LBMR_TIR_T_TRANSPORT, ENC_BIG_ENDIAN); + transport_len_item = proto_tree_add_item(tinfo_tree, hf_lbmr_tir_tlen, tvb, tinfo_offset + O_LBMR_TIR_T_TLEN, L_LBMR_TIR_T_TLEN, ENC_BIG_ENDIAN); + proto_tree_add_item(tinfo_tree, hf_lbmr_tir_ttl, tvb, tinfo_offset + O_LBMR_TIR_T_TTL, L_LBMR_TIR_T_TTL, ENC_BIG_ENDIAN); + proto_tree_add_item(tinfo_tree, hf_lbmr_tir_index, tvb, tinfo_offset + O_LBMR_TIR_T_INDEX, L_LBMR_TIR_T_INDEX, ENC_BIG_ENDIAN); + if ((transport & LBMR_TIR_OPTIONS) != 0) + { + dissect_len = dissect_lbmr_tir_options(tvb, curr_offset, pinfo, tinfo_tree); + reclen += dissect_len; + curr_offset += dissect_len; + } + reclen += dissect_lbmr_tir_transport(tvb, curr_offset, (lbm_uint8_t)(transport & LBMR_TIR_TRANSPORT), tlen, name, idx, pinfo, tinfo_tree, contents, transport_len_item); + proto_item_set_len(ti, reclen); + return (reclen); +} + +static int dissect_lbmr_tirs(tvbuff_t * tvb, int offset, guint16 tir_count, packet_info * pinfo, proto_tree * tree, + const char * name, lbmr_contents_t * contents) +{ + int start_offset; + int tir_len; + proto_tree * tirs_tree = NULL; + proto_item * ti = NULL; + int len = 0; + + start_offset = offset; + ti = proto_tree_add_none_format(tree, hf_lbmr_tirs, tvb, start_offset, -1, "%s", name); + tirs_tree = proto_item_add_subtree(ti, ett_lbmr_tirs); + while (tir_count-- > 0) + { + tir_len = dissect_lbmr_tir_entry(tvb, offset, pinfo, tirs_tree, contents); + offset += tir_len; + len += tir_len; + } + proto_item_set_len(ti, len); + return (len); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Queue Query Record dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_qqr(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmr_contents_t * contents) +{ + gint namelen = 0; + guint reclen = 0; + char * name = NULL; + + name = tvb_get_stringz_enc(wmem_packet_scope(), tvb, offset, &namelen, ENC_ASCII); + reclen += namelen; + add_contents_qqr(contents, name); + + proto_tree_add_item(tree, hf_lbmr_qqr_name, tvb, offset, namelen, ENC_ASCII|ENC_NA); + return (reclen); +} + +static int dissect_lbmr_qqrs(tvbuff_t * tvb, int offset, guint8 qqr_count, packet_info * pinfo, proto_tree * tree, lbmr_contents_t * contents) +{ + int start_offset; + int qqr_len; + proto_tree * qqrs_tree = NULL; + proto_item * qqrs_ti = NULL; + int total_len = 0; + + start_offset = offset; + qqrs_ti = proto_tree_add_item(tree, hf_lbmr_qqr, tvb, start_offset, -1, ENC_NA); + qqrs_tree = proto_item_add_subtree(qqrs_ti, ett_lbmr_qqrs); + while (qqr_count-- > 0) + { + qqr_len = dissect_lbmr_qqr(tvb, offset, pinfo, qqrs_tree, contents); + total_len += qqr_len; + offset += qqr_len; + } + proto_item_set_len(qqrs_ti, total_len); + return (total_len); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Queue Information Record dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_qir_queue_blk(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, const char * queue_name, + const char * topic_name, lbmr_contents_t * contents) +{ + guint16 port = 0; + proto_item * ti = NULL; + proto_tree * blk_tree = NULL; + + port = tvb_get_ntohs(tvb, offset + O_LBMR_QIR_QUEUE_BLK_T_PORT); + ti = proto_tree_add_item(tree, hf_lbmr_qir_queue_blk, tvb, offset, L_LBMR_QIR_QUEUE_BLK_T, ENC_NA); + blk_tree = proto_item_add_subtree(ti, ett_lbmr_qir_queue_blk); + proto_tree_add_item(blk_tree, hf_lbmr_qir_queue_blk_ip, tvb, offset + O_LBMR_QIR_QUEUE_BLK_T_IP, L_LBMR_QIR_QUEUE_BLK_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(blk_tree, hf_lbmr_qir_queue_blk_port, tvb, offset + O_LBMR_QIR_QUEUE_BLK_T_PORT, L_LBMR_QIR_QUEUE_BLK_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(blk_tree, hf_lbmr_qir_queue_blk_idx, tvb, offset + O_LBMR_QIR_QUEUE_BLK_T_IDX, L_LBMR_QIR_QUEUE_BLK_T_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(blk_tree, hf_lbmr_qir_queue_blk_grp_idx, tvb, offset + O_LBMR_QIR_QUEUE_BLK_T_GRP_IDX, L_LBMR_QIR_QUEUE_BLK_T_GRP_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(blk_tree, hf_lbmr_qir_queue_blk_reserved, tvb, offset + O_LBMR_QIR_QUEUE_BLK_T_RESERVED, L_LBMR_QIR_QUEUE_BLK_T_RESERVED, ENC_BIG_ENDIAN); + add_contents_qir(contents, queue_name, topic_name, port); + return ((int)L_LBMR_QIR_QUEUE_BLK_T); +} + +static int dissect_lbmr_qir_grp_blk(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree, lbmr_contents_t * contents _U_) +{ + proto_item * ti = NULL; + proto_tree * blk_tree = NULL; + guint16 idx = 0; + guint16 sz = 0; + + idx = tvb_get_ntohs(tvb, offset + O_LBMR_QIR_GRP_BLK_T_GRP_IDX); + sz = tvb_get_ntohs(tvb, offset + O_LBMR_QIR_GRP_BLK_T_GRP_SZ); + ti = proto_tree_add_none_format(tree, hf_lbmr_qir_grp_blk, tvb, offset, L_LBMR_QIR_GRP_BLK_T, "Group block, Index %" G_GUINT16_FORMAT ", Size %" G_GUINT16_FORMAT, idx, sz); + blk_tree = proto_item_add_subtree(ti, ett_lbmr_qir_grp_blk); + proto_tree_add_item(blk_tree, hf_lbmr_qir_grp_blk_grp_idx, tvb, offset + O_LBMR_QIR_GRP_BLK_T_GRP_IDX, L_LBMR_QIR_GRP_BLK_T_GRP_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(blk_tree, hf_lbmr_qir_grp_blk_grp_sz, tvb, offset + O_LBMR_QIR_GRP_BLK_T_GRP_SZ, L_LBMR_QIR_GRP_BLK_T_GRP_SZ, ENC_BIG_ENDIAN); + return ((int)L_LBMR_QIR_GRP_BLK_T); +} + +static int dissect_lbmr_qir_entry(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, lbmr_contents_t * contents) +{ + gint qnamelen = 0; + gint qnameoffset = 0; + char * qname = NULL; + gint tnamelen = 0; + gint tnameoffset = 0; + char * tname = NULL; + gint reclen = 0; + int curr_offset = 0; + proto_item * qirti = NULL; + proto_tree * qirtree = NULL; + proto_item * grpti = NULL; + proto_tree * grptree = NULL; + int grplen = 0; + proto_item * queueti = NULL; + proto_item * queuetree = NULL; + int queuelen = 0; + guint32 queue_id = 0; + guint16 grp_blks = 0; + guint16 queue_blks = 0; + guint16 have_options = 0; + int optlen = 0; + proto_item * grpblkti = NULL; + proto_tree * grpblktree = NULL; + + /* + queue name (null-terminated) + topic name (null-terminated) + lbmr_qir_t + if qir.grp_blks & LBMR_QIR_OPTIONS + parse options (normal topic options - though there shouldn't be any) can use dissect_lbmr_tir_options + endif + group blocks (lbmr_qir_grp_blk_t) + queue blocks (lbmr_qir_queue_blk_t) + */ + curr_offset = offset; + qnameoffset = curr_offset; + qname = tvb_get_stringz_enc(wmem_packet_scope(), tvb, qnameoffset, &qnamelen, ENC_ASCII); + curr_offset += qnamelen; + reclen += qnamelen; + tnameoffset = curr_offset; + tname = tvb_get_stringz_enc(wmem_packet_scope(), tvb, tnameoffset, &tnamelen, ENC_ASCII); + curr_offset += tnamelen; + reclen += tnamelen; + queue_id = tvb_get_ntohl(tvb, curr_offset + O_LBMR_QIR_T_QUEUE_ID); + have_options = tvb_get_ntohs(tvb, curr_offset + O_LBMR_QIR_T_GRP_BLKS); + grp_blks = have_options & LBMR_QIR_GRP_BLOCKS_MASK; + have_options &= LBMR_QIR_OPTIONS; + queue_blks = tvb_get_ntohs(tvb, curr_offset + O_LBMR_QIR_T_QUEUE_BLKS); + qirti = proto_tree_add_none_format(tree, hf_lbmr_qir, tvb, offset, reclen, "%s: %s, ID %" G_GUINT32_FORMAT, qname, tname, queue_id); + qirtree = proto_item_add_subtree(qirti, ett_lbmr_qir); + proto_tree_add_item(qirtree, hf_lbmr_qir_queue_name, tvb, qnameoffset, qnamelen, ENC_ASCII|ENC_NA); + proto_tree_add_item(qirtree, hf_lbmr_qir_topic_name, tvb, tnameoffset, tnamelen, ENC_ASCII|ENC_NA); + proto_tree_add_item(qirtree, hf_lbmr_qir_queue_id, tvb, curr_offset + O_LBMR_QIR_T_QUEUE_ID, L_LBMR_QIR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(qirtree, hf_lbmr_qir_queue_ver, tvb, curr_offset + O_LBMR_QIR_T_QUEUE_VER, L_LBMR_QIR_T_QUEUE_VER, ENC_BIG_ENDIAN); + proto_tree_add_item(qirtree, hf_lbmr_qir_queue_prev_ver, tvb, curr_offset + O_LBMR_QIR_T_QUEUE_PREV_VER, L_LBMR_QIR_T_QUEUE_PREV_VER, ENC_BIG_ENDIAN); + grpblkti = proto_tree_add_item(qirtree, hf_lbmr_qir_grp_blks, tvb, curr_offset + O_LBMR_QIR_T_GRP_BLKS, L_LBMR_QIR_T_GRP_BLKS, ENC_NA); + grpblktree = proto_item_add_subtree(grpblkti, ett_lbmr_qir_grp_blks); + proto_tree_add_item(grpblktree, hf_lbmr_qir_grp_blks_option_flag, tvb, curr_offset + O_LBMR_QIR_T_GRP_BLKS, L_LBMR_QIR_T_GRP_BLKS, ENC_BIG_ENDIAN); + proto_tree_add_item(grpblktree, hf_lbmr_qir_grp_blks_count, tvb, curr_offset + O_LBMR_QIR_T_GRP_BLKS, L_LBMR_QIR_T_GRP_BLKS, ENC_BIG_ENDIAN); + proto_tree_add_item(qirtree, hf_lbmr_qir_queue_blks, tvb, curr_offset + O_LBMR_QIR_T_QUEUE_BLKS, L_LBMR_QIR_T_QUEUE_BLKS, ENC_BIG_ENDIAN); + curr_offset += L_LBMR_QIR_T; + reclen += L_LBMR_QIR_T; + if (have_options) + { + optlen = dissect_lbmr_tir_options(tvb, curr_offset, pinfo, tree); + curr_offset += optlen; + reclen += optlen; + } + if (grp_blks > 0) + { + grpti = proto_tree_add_item(qirtree, hf_lbmr_qir_grps, tvb, curr_offset, 1, ENC_NA); + grptree = proto_item_add_subtree(grpti, ett_lbmr_qir_grp); + grplen = 0; + while (grp_blks-- > 0) + { + optlen = dissect_lbmr_qir_grp_blk(tvb, curr_offset, pinfo, grptree, contents); + curr_offset += optlen; + reclen += optlen; + grplen += optlen; + } + proto_item_set_len(grpti, grplen); + } + if (queue_blks > 0) + { + queueti = proto_tree_add_item(qirtree, hf_lbmr_qir_queues, tvb, curr_offset, 1, ENC_NA); + queuetree = proto_item_add_subtree(queueti, ett_lbmr_qir_queue); + queuelen = 0; + while (queue_blks-- > 0) + { + optlen = dissect_lbmr_qir_queue_blk(tvb, curr_offset, pinfo, queuetree, qname, tname, contents); + curr_offset += optlen; + reclen += optlen; + queuelen += optlen; + } + proto_item_set_len(queueti, queuelen); + } + proto_item_set_len(qirti, reclen); + return (reclen); +} + +static int dissect_lbmr_qirs(tvbuff_t * tvb, int offset, guint16 qirs, packet_info * pinfo, proto_tree * tree, lbmr_contents_t * contents) +{ + int start_offset; + int qir_len; + proto_tree * qirs_tree = NULL; + proto_item * qirs_ti = NULL; + int len = 0; + + start_offset = offset; + qirs_ti = proto_tree_add_item(tree, hf_lbmr_qirs, tvb, start_offset, -1, ENC_NA); + qirs_tree = proto_item_add_subtree(qirs_ti, ett_lbmr_qirs); + while (qirs-- > 0) + { + qir_len = dissect_lbmr_qir_entry(tvb, offset, pinfo, qirs_tree, contents); + len += qir_len; + offset += qir_len; + } + proto_item_set_len(qirs_ti, len); + return (len); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Proxy Source Election Record dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_pser(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + int hdr_len = 0; + int len = 0; + int topic_len = 0; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + int curr_offset = offset; + guint16 flags = 0; + + hdr_len = (int)tvb_get_ntohs(tvb, curr_offset + O_LBMR_PSER_T_LEN); + flags = tvb_get_ntohs(tvb, curr_offset + O_LBMR_PSER_T_FLAGS); + topic_len = hdr_len - L_LBMR_PSER_T; + proto_tree_add_item(tree, hf_lbmr_pser_dep_type, tvb, offset + O_LBMR_PSER_T_DEP_TYPE, L_LBMR_PSER_T_DEP_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_pser_len, tvb, offset + O_LBMR_PSER_T_LEN, L_LBMR_PSER_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_none_format(tree, hf_lbmr_pser_flags, tvb, offset + O_LBMR_PSER_T_FLAGS, L_LBMR_PSER_T_FLAGS, "Flags (0x%04x)", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_pser_flags); + proto_tree_add_item(flags_tree, hf_lbmr_pser_flags_option, tvb, offset + O_LBMR_PSER_T_FLAGS, L_LBMR_PSER_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_pser_source_ip, tvb, offset + O_LBMR_PSER_T_SOURCE_IP, L_LBMR_PSER_T_SOURCE_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_pser_store_ip, tvb, offset + O_LBMR_PSER_T_STORE_IP, L_LBMR_PSER_T_STORE_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_pser_transport_idx, tvb, offset + O_LBMR_PSER_T_TRANSPORT_IDX, L_LBMR_PSER_T_TRANSPORT_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_pser_topic_idx, tvb, offset + O_LBMR_PSER_T_TOPIC_IDX, L_LBMR_PSER_T_TOPIC_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_pser_source_port, tvb, offset + O_LBMR_PSER_T_SOURCE_PORT, L_LBMR_PSER_T_SOURCE_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_pser_store_port, tvb, offset + O_LBMR_PSER_T_STORE_PORT, L_LBMR_PSER_T_STORE_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_pser_topic, tvb, offset + O_LBMR_PSER_T_TOPIC, topic_len, ENC_ASCII|ENC_NA); + curr_offset += hdr_len; + len = hdr_len; + if ((flags & LBMR_PSER_OPT_FLAG) != 0) + { + proto_tree * opts_tree = NULL; + proto_item * opts_item = NULL; + proto_tree * optlen_tree = NULL; + proto_tree * optlen_item = NULL; + guint16 opt_len = 0; + + opt_len = tvb_get_ntohs(tvb, curr_offset + O_LBMR_PSER_OPTLEN_T_OPTLEN); + opts_item = proto_tree_add_item(tree, hf_lbmr_pser_opts, tvb, curr_offset, -1, ENC_NA); + opts_tree = proto_item_add_subtree(opts_item, ett_lbmr_pser_opts); + optlen_item = proto_tree_add_item(opts_tree, hf_lbmr_pser_optlen, tvb, curr_offset, L_LBMR_PSER_OPTLEN_T, ENC_NA); + optlen_tree = proto_item_add_subtree(optlen_item, ett_lbmr_pser_opt_len); + proto_tree_add_item(optlen_tree, hf_lbmr_pser_optlen_type, tvb, curr_offset + O_LBMR_PSER_OPTLEN_T_TYPE, L_LBMR_PSER_OPTLEN_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(optlen_tree, hf_lbmr_pser_optlen_optlen, tvb, curr_offset + O_LBMR_PSER_OPTLEN_T_OPTLEN, L_LBMR_PSER_OPTLEN_T_OPTLEN, ENC_BIG_ENDIAN); + proto_item_set_len(opts_item, opt_len); + len += L_LBMR_PSER_OPTLEN_T; + curr_offset += L_LBMR_PSER_OPTLEN_T; + opt_len -= L_LBMR_PSER_OPTLEN_T; + while (opt_len > 0) + { + proto_tree * ctxinst_tree = NULL; + proto_item * ctxinst_item = NULL; + guint8 opt_type = tvb_get_guint8(tvb, curr_offset + O_LBMR_PSER_OPT_HDR_T_TYPE); + guint8 option_len = tvb_get_guint8(tvb, O_LBMR_PSER_OPT_HDR_T_LEN); + + switch (opt_type) + { + case LBMR_PSER_OPT_SRC_CTXINST_TYPE: + case LBMR_PSER_OPT_STORE_CTXINST_TYPE: + ctxinst_item = proto_tree_add_item(opts_tree, hf_lbmr_pser_opt_ctxinst, tvb, offset, L_LBMR_PSER_OPT_CTXINST_T, ENC_NA); + ctxinst_tree = proto_item_add_subtree(ctxinst_item, ett_lbmr_pser_opt_ctxinst); + proto_tree_add_item(ctxinst_tree, hf_lbmr_pser_opt_ctxinst_len, tvb, curr_offset + O_LBMR_PSER_OPT_CTXINST_T_LEN, L_LBMR_PSER_OPT_CTXINST_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(ctxinst_tree, hf_lbmr_pser_opt_ctxinst_type, tvb, curr_offset + O_LBMR_PSER_OPT_CTXINST_T_TYPE, L_LBMR_PSER_OPT_CTXINST_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(ctxinst_tree, hf_lbmr_pser_opt_ctxinst_ctxinst, tvb, curr_offset + O_LBMR_PSER_OPT_CTXINST_T_CTXINST, L_LBMR_PSER_OPT_CTXINST_T_CTXINST, ENC_NA); + len += L_LBMR_PSER_OPT_CTXINST_T; + curr_offset += L_LBMR_PSER_OPT_CTXINST_T; + opt_len -= L_LBMR_PSER_OPT_CTXINST_T; + break; + default: + len += option_len; + curr_offset += option_len; + opt_len -= option_len; + expert_add_info_format(pinfo, NULL, &ei_lbmr_analysis_invalid_value, "Unknown LBMR PSER option 0x%02x", opt_type); + break; + } + } + } + return (len); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Queue Management dissection functions. */ +/*----------------------------------------------------------------------------*/ +int lbmr_dissect_umq_qmgmt(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + guint8 pckt_type = 0; + int curr_offset = 0; + guint16 dep16; + guint16 idx; + guint8 flags = 0; + int len_dissected = 0; + proto_item * subtree_item = NULL; + proto_tree * subtree = NULL; + + flags = tvb_get_guint8(tvb, offset + O_UMQ_QMGMT_HDR_T_FLAGS); + pckt_type = tvb_get_guint8(tvb, offset + O_UMQ_QMGMT_HDR_T_PCKT_TYPE); + dep16 = tvb_get_ntohs(tvb, offset + O_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16); + subtree_item = proto_tree_add_item(tree, hf_qmgmt_flags, tvb, offset + O_UMQ_QMGMT_HDR_T_FLAGS, L_UMQ_QMGMT_HDR_T_FLAGS, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_qmgmt_flags); + proto_tree_add_item(subtree, hf_qmgmt_flags_i_flag, tvb, offset + O_UMQ_QMGMT_HDR_T_FLAGS, L_UMQ_QMGMT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_qmgmt_flags_n_flag, tvb, offset + O_UMQ_QMGMT_HDR_T_FLAGS, L_UMQ_QMGMT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + if (pckt_type == UMQ_QMGMT_HDR_PCKT_TYPE_IL) + { + proto_tree_add_item(subtree, hf_qmgmt_flags_il_l_flag, tvb, offset + O_UMQ_QMGMT_HDR_T_FLAGS, L_UMQ_QMGMT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_qmgmt_flags_il_k_flag, tvb, offset + O_UMQ_QMGMT_HDR_T_FLAGS, L_UMQ_QMGMT_HDR_T_FLAGS, ENC_BIG_ENDIAN); + } + proto_tree_add_item(tree, hf_qmgmt_pckt_type, tvb, offset + O_UMQ_QMGMT_HDR_T_PCKT_TYPE, L_UMQ_QMGMT_HDR_T_PCKT_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_qmgmt_cfgsig, tvb, offset + O_UMQ_QMGMT_HDR_T_CFGSIG, L_UMQ_QMGMT_HDR_T_CFGSIG, ENC_NA); + proto_tree_add_item(tree, hf_qmgmt_queue_id, tvb, offset + O_UMQ_QMGMT_HDR_T_QUEUE_ID, L_UMQ_QMGMT_HDR_T_QUEUE_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_qmgmt_queue_ver, tvb, offset + O_UMQ_QMGMT_HDR_T_QUEUE_VER, L_UMQ_QMGMT_HDR_T_QUEUE_VER, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_qmgmt_ip, tvb, offset + O_UMQ_QMGMT_HDR_T_IP, L_UMQ_QMGMT_HDR_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_qmgmt_port, tvb, offset + O_UMQ_QMGMT_HDR_T_PORT, L_UMQ_QMGMT_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_qmgmt_inst_idx, tvb, offset + O_UMQ_QMGMT_HDR_T_INST_IDX, L_UMQ_QMGMT_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_qmgmt_grp_idx, tvb, offset + O_UMQ_QMGMT_HDR_T_GRP_IDX, L_UMQ_QMGMT_HDR_T_GRP_IDX, ENC_BIG_ENDIAN); + switch (pckt_type) + { + case UMQ_QMGMT_HDR_PCKT_TYPE_IL: + proto_tree_add_item(tree, hf_qmgmt_il_num_insts, tvb, offset + O_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16, L_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16, ENC_BIG_ENDIAN); + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_JREJ: + proto_tree_add_item(tree, hf_qmgmt_jrej_code, tvb, offset + O_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16, L_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16, ENC_BIG_ENDIAN); + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_EV: + proto_tree_add_item(tree, hf_qmgmt_ev_bias, tvb, offset + O_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16, L_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16, ENC_BIG_ENDIAN); + break; + default: + proto_tree_add_item(tree, hf_qmgmt_pckt_type_dep16, tvb, offset + O_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16, L_UMQ_QMGMT_HDR_T_PCKT_TYPE_DEP16, ENC_BIG_ENDIAN); + break; + } + len_dissected = L_UMQ_QMGMT_HDR_T; + curr_offset = offset + L_UMQ_QMGMT_HDR_T; + switch (pckt_type) + { + case UMQ_QMGMT_HDR_PCKT_TYPE_IL: + { + proto_item * il_subtree_item = NULL; + proto_tree * il_subtree = NULL; + + il_subtree_item = proto_tree_add_item(tree, hf_qmgmt_il, tvb, curr_offset, L_UMQ_QMGMT_IL_HDR_T, ENC_NA); + il_subtree = proto_item_add_subtree(il_subtree_item, ett_qmgmt_il); + proto_tree_add_item(il_subtree, hf_qmgmt_il_highest_rcr_tsp, tvb, curr_offset + O_UMQ_QMGMT_IL_HDR_T_HIGHEST_RCR_TSP, L_UMQ_QMGMT_IL_HDR_T_HIGHEST_RCR_TSP, ENC_BIG_ENDIAN); + len_dissected += L_UMQ_QMGMT_IL_HDR_T; + curr_offset += L_UMQ_QMGMT_IL_HDR_T; + for (idx = 0; idx < dep16; ++idx) + { + proto_item * il_inst_subtree_item = NULL; + proto_tree * il_inst_subtree = NULL; + proto_item * il_inst_flags_subtree_item = NULL; + proto_tree * il_inst_flags_subtree = NULL; + + il_inst_subtree_item = proto_tree_add_item(tree, hf_qmgmt_il_inst, tvb, curr_offset, L_UMQ_QMGMT_IL_INST_HDR_T, ENC_NA); + il_inst_subtree = proto_item_add_subtree(il_inst_subtree_item, ett_qmgmt_il_inst); + proto_tree_add_item(il_inst_subtree, hf_qmgmt_il_inst_ip, tvb, curr_offset + O_UMQ_QMGMT_IL_INST_HDR_T_IP, L_UMQ_QMGMT_IL_INST_HDR_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(il_inst_subtree, hf_qmgmt_il_inst_port, tvb, curr_offset + O_UMQ_QMGMT_IL_INST_HDR_T_PORT, L_UMQ_QMGMT_IL_INST_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(il_inst_subtree, hf_qmgmt_il_inst_inst_idx, tvb, curr_offset + O_UMQ_QMGMT_IL_INST_HDR_T_INST_IDX, L_UMQ_QMGMT_IL_INST_HDR_T_INST_IDX, ENC_BIG_ENDIAN); + proto_tree_add_item(il_inst_subtree, hf_qmgmt_il_inst_grp_idx, tvb, curr_offset + O_UMQ_QMGMT_IL_INST_HDR_T_GRP_IDX, L_UMQ_QMGMT_IL_INST_HDR_T_GRP_IDX, ENC_BIG_ENDIAN); + il_inst_flags_subtree_item = proto_tree_add_item(il_inst_subtree, hf_qmgmt_il_inst_flags, tvb, curr_offset + O_UMQ_QMGMT_IL_INST_HDR_T_FLAGS, L_UMQ_QMGMT_IL_INST_HDR_T_FLAGS, ENC_NA); + il_inst_flags_subtree = proto_item_add_subtree(il_inst_flags_subtree_item, ett_qmgmt_il_inst_flags); + proto_tree_add_item(il_inst_flags_subtree, hf_qmgmt_il_inst_flags_m_flag, tvb, curr_offset + O_UMQ_QMGMT_IL_INST_HDR_T_FLAGS, L_UMQ_QMGMT_IL_INST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(il_inst_flags_subtree, hf_qmgmt_il_inst_flags_q_flag, tvb, curr_offset + O_UMQ_QMGMT_IL_INST_HDR_T_FLAGS, L_UMQ_QMGMT_IL_INST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(il_inst_flags_subtree, hf_qmgmt_il_inst_flags_p_flag, tvb, curr_offset + O_UMQ_QMGMT_IL_INST_HDR_T_FLAGS, L_UMQ_QMGMT_IL_INST_HDR_T_FLAGS, ENC_BIG_ENDIAN); + len_dissected += L_UMQ_QMGMT_IL_INST_HDR_T; + curr_offset += L_UMQ_QMGMT_IL_INST_HDR_T; + } + } + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_JR: + /* Nothing to do */ + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_JREJ: + /* Nothing to do */ + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_IKA: + /* Nothing to do */ + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_EC: + { + proto_item * ec_subtree_item = NULL; + proto_tree * ec_subtree = NULL; + + ec_subtree_item = proto_tree_add_item(tree, hf_qmgmt_ec, tvb, curr_offset, L_UMQ_QMGMT_EC_HDR_T, ENC_NA); + ec_subtree = proto_item_add_subtree(ec_subtree_item, ett_qmgmt_ec); + proto_tree_add_item(ec_subtree, hf_qmgmt_ec_queue_new_ver, tvb, curr_offset + O_UMQ_QMGMT_EC_HDR_T_QUEUE_NEW_VER, L_UMQ_QMGMT_EC_HDR_T_QUEUE_NEW_VER, ENC_BIG_ENDIAN); + len_dissected += L_UMQ_QMGMT_EC_HDR_T; + curr_offset += L_UMQ_QMGMT_EC_HDR_T; + } + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_EV: + { + proto_item * ev_subtree_item = NULL; + proto_tree * ev_subtree = NULL; + + ev_subtree_item = proto_tree_add_item(tree, hf_qmgmt_ev, tvb, curr_offset, L_UMQ_QMGMT_EV_HDR_T, ENC_NA); + ev_subtree = proto_item_add_subtree(ev_subtree_item, ett_qmgmt_ev); + proto_tree_add_item(ev_subtree, hf_qmgmt_ev_highest_rcr_tsp, tvb, curr_offset + O_UMQ_QMGMT_EV_HDR_T_HIGHEST_RCR_TSP, L_UMQ_QMGMT_EV_HDR_T_HIGHEST_RCR_TSP, ENC_BIG_ENDIAN); + proto_tree_add_item(ev_subtree, hf_qmgmt_ev_age, tvb, curr_offset + O_UMQ_QMGMT_EV_HDR_T_AGE, L_UMQ_QMGMT_EV_HDR_T_AGE, ENC_BIG_ENDIAN); + len_dissected += L_UMQ_QMGMT_EV_HDR_T; + curr_offset += L_UMQ_QMGMT_EV_HDR_T; + } + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_CNIL: + /* Nothing to do */ + break; + case UMQ_QMGMT_HDR_PCKT_TYPE_QRO: + { + proto_item * qro_subtree_item = NULL; + proto_tree * qro_subtree = NULL; + + qro_subtree_item = proto_tree_add_item(tree, hf_qmgmt_qro, tvb, curr_offset, L_UMQ_QMGMT_QRO_HDR_T, ENC_NA); + qro_subtree = proto_item_add_subtree(qro_subtree_item, ett_qmgmt_qro); + proto_tree_add_item(qro_subtree, hf_qmgmt_qro_highest_rcr_tsp, tvb, curr_offset + O_UMQ_QMGMT_QRO_HDR_T_HIGHEST_RCR_TSP, L_UMQ_QMGMT_QRO_HDR_T_HIGHEST_RCR_TSP, ENC_BIG_ENDIAN); + len_dissected += L_UMQ_QMGMT_QRO_HDR_T; + curr_offset += L_UMQ_QMGMT_QRO_HDR_T; + } + break; + default: + expert_add_info_format(pinfo, NULL, &ei_lbmr_analysis_invalid_value, "Unknown LBMR QMGMT packet type 0x%02x", pckt_type); + break; + } + if ((flags & UMQ_QMGMT_HDR_N_FLAG) != 0) + { + int qnamelen = tvb_reported_length_remaining(tvb, curr_offset); + if (qnamelen > 1) + { + proto_tree_add_item(tree, hf_qmgmt_qname, tvb, curr_offset, qnamelen, ENC_ASCII|ENC_NA); + } + len_dissected += qnamelen; + } + return (len_dissected); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR ContextInfo dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_ctxinfo(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + guint16 flags = 0; + guint8 reclen = 0; + int name_offset = -1; + int name_len = 0; + wmem_strbuf_t * flagbuf; + const char * sep = ""; + + flags = tvb_get_ntohs(tvb, offset + O_LBMR_CTXINFO_T_FLAGS); + reclen = tvb_get_guint8(tvb, offset + O_LBMR_CTXINFO_T_LEN); + if ((flags & LBMR_CTXINFO_NAME_FLAG) != 0) + { + name_offset = offset + L_LBMR_CTXINFO_T; + name_len = reclen - L_LBMR_CTXINFO_T; + } + proto_tree_add_item(tree, hf_lbmr_ctxinfo_len, tvb, offset + O_LBMR_CTXINFO_T_LEN, L_LBMR_CTXINFO_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_ctxinfo_hop_count, tvb, offset + O_LBMR_CTXINFO_T_HOP_COUNT, L_LBMR_CTXINFO_T_HOP_COUNT, ENC_BIG_ENDIAN); + flagbuf = wmem_strbuf_new_label(wmem_packet_scope()); + if ((flags & LBMR_CTXINFO_NAME_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "Name"); + sep = ", "; + } + if ((flags & LBMR_CTXINFO_PROXY_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "Proxy"); + sep = ", "; + } + if ((flags & LBMR_CTXINFO_TNWG_RCV_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "GW Rcv"); + sep = ", "; + } + if ((flags & LBMR_CTXINFO_TNWG_SRC_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "GW Src"); + sep = ", "; + } + if ((flags & LBMR_CTXINFO_INSTANCE_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "CtxInst"); + sep = ", "; + } + if ((flags & LBMR_CTXINFO_IP_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "IP"); + sep = ", "; + } + if ((flags & LBMR_CTXINFO_QUERY_FLAG) != 0) + { + wmem_strbuf_append(flagbuf, sep); + wmem_strbuf_append(flagbuf, "Query"); + } + if (flags != 0) + { + flags_item = proto_tree_add_none_format(tree, hf_lbmr_ctxinfo_flags, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, "Flags: 0x%04x (%s)", flags, wmem_strbuf_get_str(flagbuf)); + } + else + { + flags_item = proto_tree_add_item(tree, hf_lbmr_ctxinfo_flags, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, ENC_NA); + } + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_ctxinfo_flags); + proto_tree_add_item(flags_tree, hf_lbmr_ctxinfo_flags_query, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_ctxinfo_flags_ip, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_ctxinfo_flags_instance, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_ctxinfo_flags_tnwg_src, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_ctxinfo_flags_tnwg_rcv, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_ctxinfo_flags_proxy, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_ctxinfo_flags_name, tvb, offset + O_LBMR_CTXINFO_T_FLAGS, L_LBMR_CTXINFO_T_FLAGS, ENC_ASCII); + + proto_tree_add_item(tree, hf_lbmr_ctxinfo_port, tvb, offset + O_LBMR_CTXINFO_T_PORT, L_LBMR_CTXINFO_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_ctxinfo_ip, tvb, offset + O_LBMR_CTXINFO_T_IP, L_LBMR_CTXINFO_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_ctxinfo_instance, tvb, offset + O_LBMR_CTXINFO_T_INSTANCE, L_LBMR_CTXINFO_T_INSTANCE, ENC_NA); + + if (name_offset != -1) + { + proto_tree_add_item(tree, hf_lbmr_ctxinfo_name, tvb, name_offset, name_len, ENC_ASCII|ENC_NA); + } + return ((int)reclen); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Topic Res Request dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_topic_res_request(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_item * flags_item = NULL; + proto_tree * flags_tree = NULL; + + flags_item = proto_tree_add_item(tree, hf_lbmr_topic_res_request_flags, tvb, offset + O_LBMR_TOPIC_RES_REQUEST_T_FLAGS, L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_topic_res_request_flags); + proto_tree_add_item(flags_tree, hf_lbmr_topic_res_request_flags_gw_remote_interest, tvb, offset + O_LBMR_TOPIC_RES_REQUEST_T_FLAGS, L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topic_res_request_flags_context_query, tvb, offset + O_LBMR_TOPIC_RES_REQUEST_T_FLAGS, L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topic_res_request_flags_context_advertisement, tvb, offset + O_LBMR_TOPIC_RES_REQUEST_T_FLAGS, L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topic_res_request_flags_gateway_meta, tvb, offset + O_LBMR_TOPIC_RES_REQUEST_T_FLAGS, L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topic_res_request_flags_advertisement, tvb, offset + O_LBMR_TOPIC_RES_REQUEST_T_FLAGS, L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topic_res_request_flags_query, tvb, offset + O_LBMR_TOPIC_RES_REQUEST_T_FLAGS, L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_topic_res_request_flags_wildcard_query, tvb, offset + O_LBMR_TOPIC_RES_REQUEST_T_FLAGS, L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, ENC_BIG_ENDIAN); + return (L_LBMR_TOPIC_RES_REQUEST_T); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Remote Domain Route dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_remote_domain_route(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + guint16 num_domains; + int len_dissected = 0; + int ofs = 0; + guint16 idx; + + num_domains = tvb_get_ntohs(tvb, offset + O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_NUM_DOMAINS); + proto_tree_add_item(tree, hf_lbmr_remote_domain_route_hdr_num_domains, tvb, offset + O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_NUM_DOMAINS, L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_NUM_DOMAINS, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_remote_domain_route_hdr_ip, tvb, offset + O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_IP, L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_remote_domain_route_hdr_port, tvb, offset + O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_PORT, L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_remote_domain_route_hdr_reserved, tvb, offset + O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_RESERVED, L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_RESERVED, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_remote_domain_route_hdr_length, tvb, offset + O_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_LENGTH, L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T_LENGTH, ENC_BIG_ENDIAN); + len_dissected = L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T; + ofs = offset + L_LBMR_REMOTE_DOMAIN_ROUTE_HDR_T; + for (idx = 0; idx < num_domains; ++idx) + { + proto_tree_add_item(tree, hf_lbmr_remote_domain_route_hdr_domain, tvb, ofs, sizeof(lbm_uint32_t), ENC_BIG_ENDIAN); + len_dissected += (int)sizeof(lbm_uint32_t); + ofs += (int)sizeof(lbm_uint32_t); + } + return (len_dissected); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Remote ContextInfo option dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_rctxinfo_rec_address_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmr_rctxinfo_rec_address, tvb, offset, L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_rctxinfo_rec_address); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_address_type, tvb, offset + O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_TYPE, L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_address_len, tvb, offset + O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_LEN, L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_address_flags, tvb, offset + O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_FLAGS, L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_address_domain_id, tvb, offset + O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_DOMAIN_ID, L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_DOMAIN_ID, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_address_ip, tvb, offset + O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_IP, L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_IP, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_address_port, tvb, offset + O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_PORT, L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_address_res, tvb, offset + O_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_RES, L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T_RES, ENC_BIG_ENDIAN); + return ((int)L_LBMR_RCTXINFO_REC_ADDRESS_OPT_T); +} + +static int dissect_lbmr_rctxinfo_rec_instance_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + guint8 len = 0; + + len = tvb_get_guint8(tvb, offset + O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmr_rctxinfo_rec_instance, tvb, offset, (int)len, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_rctxinfo_rec_instance); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_instance_type, tvb, offset + O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_TYPE, L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_instance_len, tvb, offset + O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_LEN, L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_instance_flags, tvb, offset + O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_FLAGS, L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_instance_instance, tvb, offset + O_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_INSTANCE, L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T_INSTANCE, ENC_NA); + return ((int)L_LBMR_RCTXINFO_REC_INSTANCE_OPT_T); +} + +static int dissect_lbmr_rctxinfo_rec_odomain_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + guint8 len = 0; + + len = tvb_get_guint8(tvb, offset + O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmr_rctxinfo_rec_odomain, tvb, offset, (int)len, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_rctxinfo_rec_odomain); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_odomain_type, tvb, offset + O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_TYPE, L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_odomain_len, tvb, offset + O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_LEN, L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_odomain_flags, tvb, offset + O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_FLAGS, L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_odomain_domain_id, tvb, offset + O_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_DOMAIN_ID, L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T_DOMAIN_ID, ENC_BIG_ENDIAN); + return ((int)L_LBMR_RCTXINFO_REC_ODOMAIN_OPT_T); +} + +static int dissect_lbmr_rctxinfo_rec_name_opt(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + guint8 len = 0; + int name_len = 0; + + len = tvb_get_guint8(tvb, offset + O_LBMR_RCTXINFO_REC_NAME_OPT_T_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmr_rctxinfo_rec_name, tvb, offset, (int)len, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_rctxinfo_rec_name); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_name_type, tvb, offset + O_LBMR_RCTXINFO_REC_NAME_OPT_T_TYPE, L_LBMR_RCTXINFO_REC_NAME_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_name_len, tvb, offset + O_LBMR_RCTXINFO_REC_NAME_OPT_T_LEN, L_LBMR_RCTXINFO_REC_NAME_OPT_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_name_flags, tvb, offset + O_LBMR_RCTXINFO_REC_NAME_OPT_T_FLAGS, L_LBMR_RCTXINFO_REC_NAME_OPT_T_FLAGS, ENC_BIG_ENDIAN); + name_len = ((int)len) - L_LBMR_RCTXINFO_REC_NAME_OPT_T; + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_name_name, tvb, offset + L_LBMR_RCTXINFO_REC_NAME_OPT_T, name_len, ENC_ASCII|ENC_NA); + return ((int)len); +} + +static int dissect_lbmr_rctxinfo_rec_unknown_opt(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + guint8 len = 0; + int data_len = 0; + guint8 opt_type; + + opt_type = tvb_get_guint8(tvb, offset + O_LBMR_RCTXINFO_REC_OPT_T_TYPE); + len = tvb_get_guint8(tvb, offset + O_LBMR_RCTXINFO_REC_OPT_T_LEN); + subtree_item = proto_tree_add_item(tree, hf_lbmr_rctxinfo_rec_unknown, tvb, offset, (int)len, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_rctxinfo_rec_unknown); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_unknown_type, tvb, offset + O_LBMR_RCTXINFO_REC_OPT_T_TYPE, L_LBMR_RCTXINFO_REC_OPT_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_unknown_len, tvb, offset + O_LBMR_RCTXINFO_REC_OPT_T_LEN, L_LBMR_RCTXINFO_REC_OPT_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_unknown_flags, tvb, offset + O_LBMR_RCTXINFO_REC_OPT_T_FLAGS, L_LBMR_RCTXINFO_REC_OPT_T_FLAGS, ENC_BIG_ENDIAN); + data_len = ((int) len) - L_LBMR_RCTXINFO_REC_OPT_T; + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_unknown_data, tvb, offset + L_LBMR_RCTXINFO_REC_OPT_T, data_len, ENC_NA); + expert_add_info_format(pinfo, subtree_item, &ei_lbmr_analysis_invalid_value, "Unknown LBMR RCTXINFO option 0x%02x", opt_type); + return ((int) len); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Remote ContextInfo dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_rctxinfo_rec(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + guint8 opt_type = 0; + proto_tree * flags_subtree = NULL; + proto_item * flags_item = NULL; + guint16 len = 0; + guint16 flags = 0; + int rec_len_remaining = 0; + int ofs = 0; + int opt_len_dissected = 0; + int len_dissected = 0; + + len = tvb_get_ntohs(tvb, offset + O_LBMR_RCTXINFO_REC_T_LEN); + flags = tvb_get_ntohs(tvb, offset + O_LBMR_RCTXINFO_REC_T_FLAGS); + subtree_item = proto_tree_add_item(tree, hf_lbmr_rctxinfo_rec, tvb, offset, -1, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_rctxinfo_rec); + proto_tree_add_item(subtree, hf_lbmr_rctxinfo_rec_len, tvb, offset + O_LBMR_RCTXINFO_REC_T_LEN, L_LBMR_RCTXINFO_REC_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_none_format(subtree, hf_lbmr_rctxinfo_rec_flags, tvb, offset + O_LBMR_RCTXINFO_REC_T_FLAGS, L_LBMR_RCTXINFO_REC_T_FLAGS, "Flags: 0x%04x", flags); + flags_subtree = proto_item_add_subtree(flags_item, ett_lbmr_rctxinfo_rec_flags); + proto_tree_add_item(flags_subtree, hf_lbmr_rctxinfo_rec_flags_query, tvb, offset + O_LBMR_RCTXINFO_REC_T_FLAGS, L_LBMR_RCTXINFO_REC_T_FLAGS, ENC_BIG_ENDIAN); + ofs = offset + L_LBMR_RCTXINFO_REC_T; + rec_len_remaining = len - L_LBMR_RCTXINFO_REC_T; + len_dissected = L_LBMR_RCTXINFO_REC_T; + while (rec_len_remaining > 0) + { + opt_type = tvb_get_guint8(tvb, ofs + O_LBMR_RCTXINFO_REC_OPT_T_TYPE); + switch (opt_type) + { + case LBMR_RCTXINFO_OPT_ADDRESS_TYPE: + opt_len_dissected = dissect_lbmr_rctxinfo_rec_address_opt(tvb, ofs, pinfo, subtree); + break; + case LBMR_RCTXINFO_OPT_INSTANCE_TYPE: + opt_len_dissected = dissect_lbmr_rctxinfo_rec_instance_opt(tvb, ofs, pinfo, subtree); + break; + case LBMR_RCTXINFO_OPT_ODOMAIN_TYPE: + opt_len_dissected = dissect_lbmr_rctxinfo_rec_odomain_opt(tvb, ofs, pinfo, subtree); + break; + case LBMR_RCTXINFO_OPT_NAME_TYPE: + opt_len_dissected = dissect_lbmr_rctxinfo_rec_name_opt(tvb, ofs, pinfo, subtree); + break; + default: + opt_len_dissected = dissect_lbmr_rctxinfo_rec_unknown_opt(tvb, ofs, pinfo, subtree); + break; + } + len_dissected += opt_len_dissected; + rec_len_remaining -= opt_len_dissected; + ofs += opt_len_dissected; + } + proto_item_set_len(subtree_item, len_dissected); + return (len_dissected); +} + +static int dissect_lbmr_rctxinfo(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + guint16 num_recs = 0; + int ofs = 0; + int len_dissected = 0; + int rec_len_dissected = 0; + + num_recs = tvb_get_ntohs(tvb, offset + O_LBMR_RCTXINFO_T_NUM_RECS); + proto_tree_add_item(tree, hf_lbmr_rctxinfo_len, tvb, offset + O_LBMR_RCTXINFO_T_LEN, L_LBMR_RCTXINFO_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_rctxinfo_num_recs, tvb, offset + O_LBMR_RCTXINFO_T_NUM_RECS, L_LBMR_RCTXINFO_T_NUM_RECS, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_lbmr_rctxinfo_reserved, tvb, offset + O_LBMR_RCTXINFO_T_RESERVED, L_LBMR_RCTXINFO_T_RESERVED, ENC_BIG_ENDIAN); + len_dissected = L_LBMR_RCTXINFO_T; + ofs = offset + L_LBMR_RCTXINFO_T; + while (num_recs > 0) + { + rec_len_dissected = dissect_lbmr_rctxinfo_rec(tvb, ofs, pinfo, tree); + ofs += rec_len_dissected; + len_dissected += rec_len_dissected; + num_recs--; + } + return (len_dissected); +} + +static proto_item * format_ver_type(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + proto_item * type_item = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmr_hdr_ver_type, tvb, offset + O_LBMR_HDR_T_VER_TYPE, L_LBMR_HDR_T_VER_TYPE, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_hdr_ver_type); + proto_tree_add_item(subtree, hf_lbmr_hdr_ver_type_ver, tvb, offset + O_LBMR_HDR_T_VER_TYPE, L_LBMR_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_hdr_ver_type_opt, tvb, offset + O_LBMR_HDR_T_VER_TYPE, L_LBMR_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + type_item = proto_tree_add_item(subtree, hf_lbmr_hdr_ver_type_type, tvb, offset + O_LBMR_HDR_T_VER_TYPE, L_LBMR_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + return (type_item); +} + +/*----------------------------------------------------------------------------*/ +/* LBMR Option dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr_opt_len(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + int len = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmr_opt_len, tvb, offset, L_LBMR_LBMR_OPT_SRC_ID_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_opt_len); + proto_tree_add_item(subtree, hf_lbmr_opt_len_type, tvb, offset + O_LBMR_LBMR_OPT_LEN_T_TYPE, L_LBMR_LBMR_OPT_LEN_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_len_len, tvb, offset + O_LBMR_LBMR_OPT_LEN_T_LEN, L_LBMR_LBMR_OPT_LEN_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_len_total_len, tvb, offset + O_LBMR_LBMR_OPT_LEN_T_TOTAL_LEN, L_LBMR_LBMR_OPT_LEN_T_TOTAL_LEN, ENC_BIG_ENDIAN); + len = L_LBMR_LBMR_OPT_LEN_T; + return (len); +} + +static int dissect_lbmr_opt_src_id(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + proto_tree * flags_subtree = NULL; + proto_item * flags_subtree_item = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmr_opt_src_id, tvb, offset, L_LBMR_LBMR_OPT_SRC_ID_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_opt_src_id); + proto_tree_add_item(subtree, hf_lbmr_opt_src_id_type, tvb, offset + O_LBMR_LBMR_OPT_SRC_ID_T_TYPE, L_LBMR_LBMR_OPT_SRC_ID_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_src_id_len, tvb, offset + O_LBMR_LBMR_OPT_SRC_ID_T_LEN, L_LBMR_LBMR_OPT_SRC_ID_T_LEN, ENC_BIG_ENDIAN); + flags_subtree_item = proto_tree_add_item(subtree, hf_lbmr_opt_src_id_flags, tvb, offset + O_LBMR_LBMR_OPT_SRC_ID_T_FLAGS, L_LBMR_LBMR_OPT_SRC_ID_T_FLAGS, ENC_NA); + flags_subtree = proto_item_add_subtree(flags_subtree_item, ett_lbmr_opt_src_id_flags); + proto_tree_add_item(flags_subtree, hf_lbmr_opt_src_id_flags_ignore, tvb, offset + O_LBMR_LBMR_OPT_SRC_ID_T_FLAGS, L_LBMR_LBMR_OPT_SRC_ID_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_src_id_src_id, tvb, offset + O_LBMR_LBMR_OPT_SRC_ID_T_SRC_ID, L_LBMR_LBMR_OPT_SRC_ID_T_SRC_ID, ENC_NA); + return (L_LBMR_LBMR_OPT_SRC_ID_T); +} + +static int dissect_lbmr_opt_src_type(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + proto_tree * flags_subtree = NULL; + proto_item * flags_subtree_item = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmr_opt_src_type, tvb, offset, L_LBMR_LBMR_OPT_SRC_TYPE_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_opt_src_type); + proto_tree_add_item(subtree, hf_lbmr_opt_src_type_type, tvb, offset + O_LBMR_LBMR_OPT_SRC_TYPE_T_TYPE, L_LBMR_LBMR_OPT_SRC_TYPE_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_src_type_len, tvb, offset + O_LBMR_LBMR_OPT_SRC_TYPE_T_LEN, L_LBMR_LBMR_OPT_SRC_TYPE_T_LEN, ENC_BIG_ENDIAN); + flags_subtree_item = proto_tree_add_item(subtree, hf_lbmr_opt_src_type_flags, tvb, offset + O_LBMR_LBMR_OPT_SRC_TYPE_T_FLAGS, L_LBMR_LBMR_OPT_SRC_TYPE_T_FLAGS, ENC_NA); + flags_subtree = proto_item_add_subtree(flags_subtree_item, ett_lbmr_opt_src_type_flags); + proto_tree_add_item(flags_subtree, hf_lbmr_opt_src_type_flags_ignore, tvb, offset + O_LBMR_LBMR_OPT_SRC_TYPE_T_FLAGS, L_LBMR_LBMR_OPT_SRC_TYPE_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_src_type_src_type, tvb, offset + O_LBMR_LBMR_OPT_SRC_TYPE_T_SRC_TYPE, L_LBMR_LBMR_OPT_SRC_TYPE_T_SRC_TYPE, ENC_BIG_ENDIAN); + return (L_LBMR_LBMR_OPT_SRC_TYPE_T); +} + +static int dissect_lbmr_opt_version(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmr_opt_version, tvb, offset, L_LBMR_LBMR_OPT_VERSION_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_opt_version); + proto_tree_add_item(subtree, hf_lbmr_opt_version_type, tvb, offset + O_LBMR_LBMR_OPT_VERSION_T_TYPE, L_LBMR_LBMR_OPT_VERSION_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_version_len, tvb, offset + O_LBMR_LBMR_OPT_VERSION_T_LEN, L_LBMR_LBMR_OPT_VERSION_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(subtree, hf_lbmr_opt_version_flags, tvb, offset + O_LBMR_LBMR_OPT_VERSION_T_FLAGS, L_LBMR_LBMR_OPT_VERSION_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_opt_version_flags); + proto_tree_add_item(flags_tree, hf_lbmr_opt_version_flags_ignore, tvb, offset + O_LBMR_LBMR_OPT_VERSION_T_FLAGS, L_LBMR_LBMR_OPT_VERSION_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_opt_version_flags_ume, tvb, offset + O_LBMR_LBMR_OPT_VERSION_T_FLAGS, L_LBMR_LBMR_OPT_VERSION_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbmr_opt_version_flags_umq, tvb, offset + O_LBMR_LBMR_OPT_VERSION_T_FLAGS, L_LBMR_LBMR_OPT_VERSION_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_version_version, tvb, offset + O_LBMR_LBMR_OPT_VERSION_T_VERSION, L_LBMR_LBMR_OPT_VERSION_T_VERSION, ENC_BIG_ENDIAN); + return (L_LBMR_LBMR_OPT_VERSION_T); +} + +static int dissect_lbmr_opt_local_domain(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + + subtree_item = proto_tree_add_item(tree, hf_lbmr_opt_local_domain, tvb, offset, L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_opt_local_domain); + proto_tree_add_item(subtree, hf_lbmr_opt_local_domain_type, tvb, offset + O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_TYPE, L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_local_domain_len, tvb, offset + O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_LEN, L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_LEN, ENC_BIG_ENDIAN); + flags_item = proto_tree_add_item(subtree, hf_lbmr_opt_local_domain_flags, tvb, offset + O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_FLAGS, L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_FLAGS, ENC_NA); + flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_opt_local_domain_flags); + proto_tree_add_item(flags_tree, hf_lbmr_opt_local_domain_flags_ignore, tvb, offset + O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_FLAGS, L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_FLAGS, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_local_domain_local_domain_id, tvb, offset + O_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_LOCAL_DOMAIN_ID, L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_LOCAL_DOMAIN_ID, ENC_BIG_ENDIAN); + return (L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T); +} + +static int dissect_lbmr_opt_unknown(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_tree * subtree = NULL; + proto_item * subtree_item = NULL; + guint8 len = 0; + proto_item * type_item = NULL; + guint8 opt_type = 0; + + subtree_item = proto_tree_add_item(tree, hf_lbmr_opt_unknown, tvb, offset, -1, ENC_NA); + subtree = proto_item_add_subtree(subtree_item, ett_lbmr_opt_unknown); + opt_type = tvb_get_guint8(tvb, offset + O_LBMR_LBMR_OPT_HDR_T_TYPE); + type_item = proto_tree_add_item(subtree, hf_lbmr_opt_unknown_type, tvb, offset + O_LBMR_LBMR_OPT_HDR_T_TYPE, L_LBMR_LBMR_OPT_HDR_T_TYPE, ENC_BIG_ENDIAN); + len = tvb_get_guint8(tvb, offset + O_LBMR_LBMR_OPT_HDR_T_LEN); + proto_tree_add_item(subtree, hf_lbmr_opt_unknown_len, tvb, offset + O_LBMR_LBMR_OPT_HDR_T_LEN, L_LBMR_LBMR_OPT_HDR_T_LEN, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_lbmr_opt_unknown_flags, tvb, offset + O_LBMR_LBMR_OPT_HDR_T_FLAGS, L_LBMR_LBMR_OPT_HDR_T_FLAGS, ENC_NA); + proto_tree_add_item(subtree, hf_lbmr_opt_unknown_data, tvb, offset + L_LBMR_LBMR_OPT_HDR_T, (int) len - L_LBMR_LBMR_OPT_HDR_T, ENC_NA); + proto_item_set_len(subtree_item, (int) len); + expert_add_info_format(pinfo, type_item, &ei_lbmr_analysis_invalid_value, "Unknown LBMR option type 0x%02x", opt_type); + return ((int) len); +} + +static int dissect_lbmr_options(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_tree * opt_tree = NULL; + proto_item * ti = NULL; + int curr_offset = offset; + int len = 0; + + ti = proto_tree_add_item(tree, hf_lbmr_opts, tvb, curr_offset, -1, ENC_NA); + opt_tree = proto_item_add_subtree(ti, ett_lbmr_opts); + while (tvb_reported_length_remaining(tvb, curr_offset) > 0) + { + int opt_len; + guint8 opt_type; + + opt_type = tvb_get_guint8(tvb, curr_offset + O_LBMR_LBMR_OPT_HDR_T_TYPE); + switch (opt_type) + { + case LBMR_LBMR_OPT_LEN_TYPE: + opt_len = dissect_lbmr_opt_len(tvb, curr_offset, pinfo, opt_tree); + break; + case LBMR_LBMR_OPT_SRC_ID_TYPE: + opt_len = dissect_lbmr_opt_src_id(tvb, curr_offset, pinfo, opt_tree); + break; + case LBMR_LBMR_OPT_SRC_TYPE_TYPE: + opt_len = dissect_lbmr_opt_src_type(tvb, curr_offset, pinfo, opt_tree); + break; + case LBMR_LBMR_OPT_VERSION_TYPE: + opt_len = dissect_lbmr_opt_version(tvb, curr_offset, pinfo, opt_tree); + break; + case LBMR_LBMR_OPT_LOCAL_DOMAIN_TYPE: + opt_len = dissect_lbmr_opt_local_domain(tvb, curr_offset, pinfo, opt_tree); + break; + default: + opt_len = dissect_lbmr_opt_unknown(tvb, curr_offset, pinfo, opt_tree); + break; + } + len += opt_len; + curr_offset += opt_len; + } + return (len); +} + +/*----------------------------------------------------------------------------*/ +/* dissect_lbmr - The dissector for LBM Topic Resolution protocol. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbmr(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * user_data _U_) +{ + proto_tree * lbmr_tree = NULL; + proto_item * ti = NULL; + int offset = 0; + guint8 ver_type; + guint8 ver; + guint8 type; + lbmr_contents_t * contents = NULL; + char * tag_name = NULL; + int total_len_dissected = 0; + int len_dissected = 0; + tvbuff_t * packet_tvb = NULL; + proto_item * lbmr_hdr_item = NULL; + proto_tree * lbmr_hdr_tree = NULL; + + col_set_str(pinfo->cinfo, COL_PROTOCOL, "LBMR"); + if (lbmr_use_tag) + { + tag_name = lbmr_tag_find(pinfo); + } + col_clear(pinfo->cinfo, COL_INFO); + if (tag_name != NULL) + { + col_add_fstr(pinfo->cinfo, COL_INFO, "[Tag: %s]", tag_name); + } + col_set_fence(pinfo->cinfo, COL_INFO); + + ver_type = tvb_get_guint8(tvb, O_LBMR_HDR_T_VER_TYPE); + ver = LBMR_HDR_VER(ver_type); + type = LBMR_HDR_TYPE(ver_type); + offset = 0; + total_len_dissected = 0; + packet_tvb = tvb; + + if ((ver_type & LBMR_HDR_TYPE_OPTS_MASK) != 0) + { + guint8 opt_type; + guint8 opt_len; + + opt_type = tvb_get_guint8(tvb, -L_LBMR_LBMR_OPT_LEN_T + O_LBMR_LBMR_OPT_LEN_T_TYPE); + opt_len = tvb_get_guint8(tvb, -L_LBMR_LBMR_OPT_LEN_T + O_LBMR_LBMR_OPT_LEN_T_LEN); + if ((opt_type == LBMR_LBMR_OPT_LEN_TYPE) && (((gint)opt_len) == L_LBMR_LBMR_OPT_LEN_T)) + { + gint opt_total_len = 0; + gint packet_len; + + packet_len = tvb_reported_length_remaining(tvb, 0); + opt_total_len = (gint)tvb_get_ntohs(tvb, -L_LBMR_LBMR_OPT_LEN_T + O_LBMR_LBMR_OPT_LEN_T_TOTAL_LEN); + if (packet_len > opt_total_len) + { + gint tvb_len = packet_len - opt_total_len; + + packet_tvb = tvb_new_subset(tvb, 0, tvb_len, tvb_len); + } + } + } + + if (type == LBMR_HDR_TYPE_EXT) + { + guint8 ext_type = 0; + const gchar * ext_string; + proto_item * ext_type_item = NULL; + + ext_type = tvb_get_guint8(tvb, O_LBMR_HDR_EXT_TYPE_T_EXT_TYPE); + ext_string = val_to_str(ext_type, lbmr_ext_packet_type, "Unknown(0x%02x)"); + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "ExtType %s", ext_string); + if (tag_name != NULL) + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_EXT_TYPE_T_VER_TYPE, -1, "LBM Topic Resolution Protocol (Tag: %s): Version %u, Type 0x%x (%s), ExtType %s", + tag_name, ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)"), ext_string); + } + else + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_EXT_TYPE_T_VER_TYPE, -1, "LBM Topic Resolution Protocol: Version %u, Type 0x%x (%s), ExtType %s", + ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)"), ext_string); + } + lbmr_tree = proto_item_add_subtree(ti, ett_lbmr); + if (tag_name != NULL) + { + proto_item * item = NULL; + + item = proto_tree_add_string(lbmr_tree, hf_lbmr_tag, tvb, 0, 0, tag_name); + PROTO_ITEM_SET_GENERATED(item); + } + lbmr_hdr_item = proto_tree_add_item(lbmr_tree, hf_lbmr_hdr, tvb, 0, -1, ENC_NA); + lbmr_hdr_tree = proto_item_add_subtree(lbmr_hdr_item, ett_lbmr_hdr); + format_ver_type(tvb, 0, pinfo, lbmr_hdr_tree); + ext_type_item = proto_tree_add_item(lbmr_hdr_tree, hf_lbmr_hdr_ext_type, tvb, O_LBMR_HDR_EXT_TYPE_T_EXT_TYPE, L_LBMR_HDR_EXT_TYPE_T_EXT_TYPE, ENC_BIG_ENDIAN); + + /* ver_type and ext_type have already been processed. But their dissected length is included in the individual type dissections below. */ + switch (ext_type) + { + case LBMR_HDR_EXT_TYPE_UME_PROXY_SRC_ELECT: + len_dissected = dissect_lbmr_pser(packet_tvb, offset, pinfo, lbmr_tree); + break; + case LBMR_HDR_EXT_TYPE_UMQ_QUEUE_MGMT: + offset += L_LBMR_UMQ_QMGMT_HDR_T_VER_TYPE + L_LBMR_UMQ_QMGMT_HDR_T_EXT_TYPE; + total_len_dissected += L_LBMR_UMQ_QMGMT_HDR_T_VER_TYPE + L_LBMR_UMQ_QMGMT_HDR_T_EXT_TYPE; + len_dissected = lbmr_dissect_umq_qmgmt(packet_tvb, offset - 2, pinfo, lbmr_tree); + break; + case LBMR_HDR_EXT_TYPE_CONTEXT_INFO: + len_dissected = dissect_lbmr_ctxinfo(packet_tvb, offset, pinfo, lbmr_tree); + break; + case LBMR_HDR_EXT_TYPE_TOPIC_RES_REQUEST: + len_dissected = dissect_lbmr_topic_res_request(packet_tvb, offset, pinfo, lbmr_tree); + break; + case LBMR_HDR_EXT_TYPE_TNWG_MSG: + len_dissected = dissect_lbmr_tnwg(packet_tvb, offset, pinfo, lbmr_tree); + break; + case LBMR_HDR_EXT_TYPE_REMOTE_DOMAIN_ROUTE: + len_dissected = dissect_lbmr_remote_domain_route(packet_tvb, offset, pinfo, lbmr_tree); + break; + case LBMR_HDR_EXT_TYPE_REMOTE_CONTEXT_INFO: + len_dissected = dissect_lbmr_rctxinfo(packet_tvb, offset, pinfo, lbmr_tree); + break; + default: + len_dissected = L_LBMR_HDR_EXT_TYPE_T_VER_TYPE + L_LBMR_HDR_EXT_TYPE_T_EXT_TYPE; + expert_add_info_format(pinfo, ext_type_item, &ei_lbmr_analysis_invalid_value, "Unknown LBMR extended type 0x%02x", ext_type); + break; + } + offset += len_dissected; + total_len_dissected += len_dissected; + } + else + { + guint8 tqrs = 0; + guint16 tirs = 0; + gboolean rd_keepalive = FALSE; + gboolean topic_mgmt = FALSE; + gboolean client_rd_keepalive = FALSE; + gboolean zero_tirs_tqrs = FALSE; + proto_item * type_item = NULL; + + tqrs = tvb_get_guint8(tvb, O_LBMR_HDR_T_TQRS); + tirs = tvb_get_ntohs(tvb, O_LBMR_HDR_T_TIRS); + if ((tqrs == 0) && (tirs == 0)) + { + zero_tirs_tqrs = TRUE; + } + if ((type == LBMR_HDR_TYPE_NORMAL) && zero_tirs_tqrs) + { + rd_keepalive = TRUE; + } + else if (zero_tirs_tqrs && ((type == LBMR_HDR_TYPE_UCAST_RCV_ALIVE) || (type == LBMR_HDR_TYPE_UCAST_SRC_ALIVE))) + { + client_rd_keepalive = TRUE; + } + else if (type == LBMR_HDR_TYPE_TOPIC_MGMT) + { + topic_mgmt = TRUE; + } + switch (type) + { + case LBMR_HDR_TYPE_QUEUE_RES: + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "QQRs %u QIRs %" G_GUINT16_FORMAT, tqrs, tirs); + break; + default: + if (rd_keepalive) + { + col_append_sep_str(pinfo->cinfo, COL_INFO, " ", "Unicast Resolver Keepalive"); + } + else if (client_rd_keepalive) + { + if (type == LBMR_HDR_TYPE_UCAST_RCV_ALIVE) + { + col_append_sep_str(pinfo->cinfo, COL_INFO, " ", "Receiver Alive"); + } + else + { + col_append_sep_str(pinfo->cinfo, COL_INFO, " ", "Source Alive"); + } + } + else if (topic_mgmt) + { + col_append_sep_str(pinfo->cinfo, COL_INFO, " ", "Topic Management"); + } + else + { + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "TQRs %u TIRs %" G_GUINT16_FORMAT, tqrs, tirs); + } + break; + } + + switch (type) + { + case LBMR_HDR_TYPE_QUEUE_RES: + if (tag_name != NULL) + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_T_VER_TYPE, -1, "LBM Topic Resolution Protocol (Tag: %s): Version %u, Type 0x%x (%s) QQRs %u, QIRs %" G_GUINT16_FORMAT, + tag_name, ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)"), tqrs, tirs); + } + else + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_T_VER_TYPE, -1, "LBM Topic Resolution Protocol: Version %u, Type 0x%x (%s) QQRs %u, QIRs %" G_GUINT16_FORMAT, + ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)"), tqrs, tirs); + } + break; + default: + if (tag_name != NULL) + { + if (rd_keepalive) + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_T_VER_TYPE, -1, "LBM Topic Resolution Protocol (Tag: %s): Version %u, Type 0x%x (%s) Unicast Resolver Keepalive", + tag_name, ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)")); + } + else if (topic_mgmt) + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_T_VER_TYPE, -1, "LBM Topic Resolution Protocol (Tag: %s): Version %u, Type 0x%x (%s) Topic Management", + tag_name, ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)")); + } + else + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_T_VER_TYPE, -1, "LBM Topic Resolution Protocol (Tag: %s): Version %u, Type 0x%x (%s) TQRs %u, TIRs %" G_GUINT16_FORMAT, + tag_name, ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)"), tqrs, tirs); + } + } + else + { + if (rd_keepalive) + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_T_VER_TYPE, -1, "LBM Topic Resolution Protocol: Version %u, Type 0x%x (%s) Unicast Resolver Keepalive", + ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)")); + } + else if (topic_mgmt) + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_T_VER_TYPE, -1, "LBM Topic Resolution Protocol: Version %u, Type 0x%x (%s) Topic Management", + ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)")); + } + else + { + ti = proto_tree_add_protocol_format(tree, proto_lbmr, tvb, O_LBMR_HDR_T_VER_TYPE, -1, "LBM Topic Resolution Protocol: Version %u, Type 0x%x (%s) TQRs %u, TIRs %" G_GUINT16_FORMAT, + ver, type, val_to_str(type, lbmr_packet_type, "Unknown(0x%02x)"), tqrs, tirs); + } + } + break; + } + lbmr_tree = proto_item_add_subtree(ti, ett_lbmr); + if (tag_name != NULL) + { + proto_item * item; + item = proto_tree_add_string(lbmr_tree, hf_lbmr_tag, tvb, 0, 0, tag_name); + PROTO_ITEM_SET_GENERATED(item); + } + lbmr_hdr_item = proto_tree_add_item(lbmr_tree, hf_lbmr_hdr, tvb, 0, -1, ENC_NA); + lbmr_hdr_tree = proto_item_add_subtree(lbmr_hdr_item, ett_lbmr_hdr); + type_item = format_ver_type(tvb, 0, pinfo, lbmr_hdr_tree); + switch (type) + { + case LBMR_HDR_TYPE_QUEUE_RES: + proto_tree_add_item(lbmr_hdr_tree, hf_lbmr_hdr_qqrs, tvb, O_LBMR_HDR_T_TQRS, L_LBMR_HDR_T_TQRS, ENC_BIG_ENDIAN); + proto_tree_add_item(lbmr_hdr_tree, hf_lbmr_hdr_qirs, tvb, O_LBMR_HDR_T_TIRS, L_LBMR_HDR_T_TIRS, ENC_BIG_ENDIAN); + break; + default: + proto_tree_add_item(lbmr_hdr_tree, hf_lbmr_hdr_tqrs, tvb, O_LBMR_HDR_T_TQRS, L_LBMR_HDR_T_TQRS, ENC_BIG_ENDIAN); + proto_tree_add_item(lbmr_hdr_tree, hf_lbmr_hdr_tirs, tvb, O_LBMR_HDR_T_TIRS, L_LBMR_HDR_T_TIRS, ENC_BIG_ENDIAN); + break; + } + + offset = L_LBMR_HDR_T; + total_len_dissected = L_LBMR_HDR_T; + contents = wmem_new0(wmem_file_scope(), lbmr_contents_t); + switch (type) + { + case LBMR_HDR_TYPE_QUEUE_RES: + contents->type = LBMR_CONTENTS_QUEUE; + if (tqrs > 0) + { + len_dissected = dissect_lbmr_qqrs(packet_tvb, offset, tqrs, pinfo, lbmr_tree, contents); + total_len_dissected += len_dissected; + offset += len_dissected; + } + if (tirs > 0) + { + len_dissected = dissect_lbmr_qirs(packet_tvb, offset, tirs, pinfo, lbmr_tree, contents); + total_len_dissected += len_dissected; + offset += len_dissected; + } + tap_queue_packet(lbmr_tap_handle, pinfo, contents); + break; + case LBMR_HDR_TYPE_NORMAL: + case LBMR_HDR_TYPE_WC_TQRS: + if (!rd_keepalive) + { + contents->type = LBMR_CONTENTS_TOPIC; + if (tqrs > 0) + { + gboolean wc_tqrs = FALSE; + + if (type == LBMR_HDR_TYPE_WC_TQRS) + { + wc_tqrs = TRUE; + } + len_dissected = dissect_lbmr_tqrs(packet_tvb, offset, tqrs, pinfo, lbmr_tree, wc_tqrs, contents); + total_len_dissected += len_dissected; + offset += len_dissected; + } + if (tirs > 0) + { + len_dissected = dissect_lbmr_tirs(packet_tvb, offset, tirs, pinfo, lbmr_tree, "TIRs", contents); + total_len_dissected += len_dissected; + offset += len_dissected; + } + tap_queue_packet(lbmr_tap_handle, pinfo, contents); + } + break; + case LBMR_HDR_TYPE_TOPIC_MGMT: + len_dissected = dissect_lbmr_tmb(packet_tvb, offset, pinfo, lbmr_tree); + total_len_dissected += len_dissected; + offset += len_dissected; + break; + case LBMR_HDR_TYPE_UCAST_RCV_ALIVE: + case LBMR_HDR_TYPE_UCAST_SRC_ALIVE: + break; + default: + expert_add_info_format(pinfo, type_item, &ei_lbmr_analysis_invalid_value, "Unknown LBMR type 0x%02x", type); + break; + } + } + if ((tvb_reported_length_remaining(tvb, offset) > 0) && ((ver_type & LBMR_HDR_TYPE_OPTS_MASK) != 0)) + { + /* Process LBMR packet options. */ + len_dissected = dissect_lbmr_options(tvb, offset, pinfo, lbmr_tree); + total_len_dissected += len_dissected; + } + return (total_len_dissected); +} + +static gboolean test_lbmr_packet(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * user_data _U_) +{ + lbmr_tag_entry_t entry; + gboolean valid_packet = FALSE; + + /* Must be a UDP packet. */ + if (pinfo->ptype != PT_UDP) + { + return (FALSE); + } + /* Destination address must be IPV4 and 4 bytes in length. */ + if ((pinfo->dst.type != AT_IPv4) || (pinfo->dst.len != 4)) + { + return (FALSE); + } + + if (lbmr_use_tag) + { + if (lbmr_tag_find(pinfo) != NULL) + { + valid_packet = TRUE; + } + } + else + { + entry.name = NULL; + entry.mc_outgoing_udp_port = lbmr_mc_outgoing_udp_port; + entry.mc_incoming_udp_port = lbmr_mc_incoming_udp_port; + entry.mc_incoming_address = NULL; + entry.mc_incoming_address_val_h = lbmr_mc_incoming_address_host; + entry.mc_outgoing_address = NULL; + entry.mc_outgoing_address_val_h = lbmr_mc_outgoing_address_host; + entry.uc_port_high = lbmr_uc_port_high; + entry.uc_port_low = lbmr_uc_port_low; + entry.uc_dest_port = lbmr_uc_dest_port; + entry.uc_address = NULL; + entry.uc_address_val_h = lbmr_uc_address_host; + valid_packet = lbmr_match_packet(pinfo, &entry); + } + if (valid_packet) + { + dissect_lbmr(tvb, pinfo, tree, NULL); + return (TRUE); + } + return (FALSE); +} + +/* The registration hand-off routine */ +void proto_reg_handoff_lbmr(void) +{ + static gboolean already_registered = FALSE; + struct in_addr addr; + + if (!already_registered) + { + lbmr_dissector_handle = new_create_dissector_handle(dissect_lbmr, proto_lbmr); + dissector_add_uint("udp.port", 0, lbmr_dissector_handle); + heur_dissector_add("udp", test_lbmr_packet, proto_lbmr); + } + + lbmr_mc_incoming_udp_port = global_lbmr_mc_incoming_udp_port; + lbmr_mc_outgoing_udp_port = global_lbmr_mc_outgoing_udp_port; + inet_aton(global_lbmr_mc_incoming_address, &addr); + lbmr_mc_incoming_address_host = g_ntohl(addr.s_addr); + + inet_aton(global_lbmr_mc_outgoing_address, &addr); + lbmr_mc_outgoing_address_host = g_ntohl(addr.s_addr); + + /* Make sure the low port is <= the high port. If not, don't change them. */ + if (global_lbmr_uc_port_low <= global_lbmr_uc_port_high) + { + lbmr_uc_port_high = global_lbmr_uc_port_high; + lbmr_uc_port_low = global_lbmr_uc_port_low; + } + lbmr_uc_dest_port = global_lbmr_uc_dest_port; + inet_aton(global_lbmr_uc_address, &addr); + lbmr_uc_address_host = g_ntohl(addr.s_addr); + lbmr_use_tag = global_lbmr_use_tag; + + already_registered = TRUE; +} + +/* Register all the bits needed with the filtering engine */ +void proto_register_lbmr(void) +{ + static hf_register_info hf[] = + { + { &hf_lbmr_tag, + { "Tag", "lbmr.tag", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_hdr, + { "Header", "lbmr.hdr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_hdr_ver_type, + { "Version/Type", "lbmr.hdr.ver_type", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_hdr_ver_type_ver, + { "Version", "lbmr.hdr.ver_type.ver", FT_UINT8, BASE_DEC, NULL, LBMR_HDR_VER_VER_MASK, NULL, HFILL } }, + { &hf_lbmr_hdr_ver_type_opt, + { "Options", "lbmr.hdr.ver_type.opts", FT_BOOLEAN, 8, TFS(&tfs_present_not_present), LBMR_HDR_TYPE_OPTS_MASK, "Set if LBMR options are present", HFILL } }, + { &hf_lbmr_hdr_ver_type_type, + { "Type", "lbmr.hdr.ver_type.type", FT_UINT8, BASE_HEX, VALS(lbmr_packet_type), LBMR_HDR_VER_TYPE_MASK, NULL, HFILL } }, + { &hf_lbmr_hdr_tqrs, + { "Topic Query Records", "lbmr.hdr.tqrs", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_hdr_tirs, + { "Topic Information Records", "lbmr.hdr.tirs", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_hdr_qqrs, + { "Queue Query Records", "lbmr.hdr.qqrs", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_hdr_qirs, + { "Queue Information Records", "lbmr.hdr.qirs", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_hdr_ext_type, + { "Extended Type", "lbmr.hdr.ext_type", FT_UINT8, BASE_HEX, VALS(lbmr_ext_packet_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tqrs, + { "TQRs", "lbmr.tqrs", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tqr, + { "TQR", "lbmr.tqr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tqr_pattern_type, + { "Pattern Type", "lbmr.tqr.pattern_type", FT_UINT8, BASE_DEC, VALS(lbm_wildcard_pattern_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tqr_pattern, + { "Pattern", "lbmr.tqr.pattern", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tqr_name, + { "Topic Name", "lbmr.tqr.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tirs, + { "TIRs", "lbmr.tirs", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir, + { "TIR", "lbmr.tir", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_name, + { "Topic Name", "lbmr.tir.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_transport, + { "Transport", "lbmr.tir.transport", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_transport_opts, + { "Transport Options Present", "lbmr.tir.transport.opts", FT_BOOLEAN, L_LBMR_TIR_T_TRANSPORT * 8, TFS(&tfs_set_notset), LBMR_TIR_OPTIONS, "Set if transport options are present", HFILL } }, + { &hf_lbmr_tir_transport_type, + { "Transport Type", "lbmr.tir.transport.type", FT_UINT8, BASE_HEX, VALS(lbmr_transport_type), LBMR_TIR_TRANSPORT, NULL, HFILL } }, + { &hf_lbmr_tir_tlen, + { "Transport Info Length", "lbmr.tir.tlen", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_ttl, + { "TTL", "lbmr.tir.ttl", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_index, + { "Index", "lbmr.tir.index", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_tcp, + { "TCP Transport", "lbmr.tir.tcp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_tcp_ip, + { "Source IP", "lbmr.tir.tcp.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_tcp_session_id, + { "Session ID", "lbmr.tir.tcp.session_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_tcp_port, + { "Source Port", "lbmr.tir.tcp.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrm, + { "LBTRM Transport", "lbmr.tir.lbtrm", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrm_src_addr, + { "Source IP", "lbmr.tir.lbtrm.srcip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrm_mcast_addr, + { "Multicast IP", "lbmr.tir.lbtrm.mcastip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrm_session_id, + { "Session ID", "lbmr.tir.lbtrm.sessid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrm_udp_dest_port, + { "Destination Port", "lbmr.tir.lbtrm.dport", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrm_src_ucast_port, + { "Source Port", "lbmr.tir.lbtrm.sport", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtru, + { "LBTRU Transport", "lbmr.tir.lbtru", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtru_ip, + { "Source IP", "lbmr.tir.lbtru.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtru_port, + { "Source Port", "lbmr.tir.lbtru.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtru_session_id, + { "Session ID", "lbmr.tir.lbtru.session_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtipc, + { "LBTIPC Transport", "lbmr.tir.lbtipc", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtipc_host_id, + { "Host ID", "lbmr.tir.lbtipc.host_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtipc_session_id, + { "Session ID", "lbmr.tir.lbtipc.session_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtipc_xport_id, + { "Transport ID", "lbmr.tir.lbtipc.xport_id", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrdma, + { "LBTRDMA Transport", "lbmr.tir.lbtrdma", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrdma_ip, + { "Source IP", "lbmr.tir.lbtrdma.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrdma_session_id, + { "Session ID", "lbmr.tir.lbtrdma.session_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtrdma_port, + { "Port", "lbmr.tir.lbtrdma.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtsmx, + { "LBTSMX Transport", "lbmr.tir.lbtsmx", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtsmx_host_id, + { "Host ID", "lbmr.tir.lbtsmx.host_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtsmx_session_id, + { "Session ID", "lbmr.tir.lbtsmx.session_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_lbtsmx_xport_id, + { "Transport ID", "lbmr.tir.lbtsmx.xport_id", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_channel, + { "Channel", "lbmr.tir.channel", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tir_unknown_transport, + { "Unknown Transport", "lbmr.tir.unknown_transport", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topts, + { "Options", "lbmr.topts", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_len, + { "Length Option", "lbmr.topt.len", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_len_type, + { "Type", "lbmr.topt.len.type", FT_UINT8, BASE_DEC, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_len_len, + { "Length", "lbmr.topt.len.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_len_total_len, + { "Total Length", "lbmr.topt.len.total_len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume, + { "UME Option", "lbmr.topt.ume", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_type, + { "Type", "lbmr.topt.ume.type", FT_UINT8, BASE_DEC, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_len, + { "Length", "lbmr.topt.ume.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_flags, + { "Flags", "lbmr.topt.ume.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_flags_ignore, + { "Ignore", "lbmr.topt.ume.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_UME_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_UME_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_ume_flags_latejoin, + { "Late Join", "lbmr.topt.ume.flags.latejoin", FT_BOOLEAN, L_LBMR_TOPIC_OPT_UME_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UME_FLAG_LATEJOIN, "If set, the source provides late join", HFILL } }, + { &hf_lbmr_topt_ume_flags_store, + { "Store", "lbmr.topt.ume.flags.store", FT_BOOLEAN, L_LBMR_TOPIC_OPT_UME_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UME_FLAG_STORE, "If set, one or more stores are specified", HFILL } }, + { &hf_lbmr_topt_ume_flags_qccap, + { "Q/C Capable", "lbmr.topt.ume.flags.qccap", FT_BOOLEAN, L_LBMR_TOPIC_OPT_UME_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UME_FLAG_QCCAP, "If set, the source supports quorun/consensus", HFILL } }, + { &hf_lbmr_topt_ume_flags_acktosrc, + { "Send ACKs to Source", "lbmr.topt.ume.flags.acktosrc", FT_BOOLEAN, L_LBMR_TOPIC_OPT_UME_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UME_FLAG_ACKTOSRC, "If set, receivers send ACKs to the source", HFILL } }, + { &hf_lbmr_topt_ume_store_tcp_port, + { "Store TCP Port", "lbmr.topt.ume.store_tcp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_src_tcp_port, + { "Source TCP Port", "lbmr.topt.ume.src_tcp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_tcp_addr, + { "Store TCP Address", "lbmr.topt.ume.store_tcp_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_src_tcp_addr, + { "Source TCP Address", "lbmr.topt.ume.src_tcp_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_src_reg_id, + { "Source Registration ID", "lbmr.topt.ume.src_reg_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_transport_idx, + { "Transport Index", "lbmr.topt.ume.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_high_seqnum, + { "High Sequence Number", "lbmr.topt.ume.high_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_low_seqnum, + { "Low Sequence Number", "lbmr.topt.ume.low_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store, + { "UME Store Option", "lbmr.topt.ume_store", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_type, + { "Type", "lbmr.topt.ume_store.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_len, + { "Length", "lbmr.topt.ume_store.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_flags, + { "Flags", "lbmr.topt.ume_store.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_flags_ignore, + { "Ignore", "lbmr.topt.ume_store.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_UME_STORE_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_UME_STORE_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_grp_idx, + { "Group Index", "lbmr.topt.ume_store.grp_idx", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_store_tcp_port, + { "Store TCP Port", "lbmr.topt.ume_store.store_tcp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_store_idx, + { "Store Index", "lbmr.topt.ume_store.store_idx", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_store_ip_addr, + { "Store IP Address", "lbmr.topt.ume_store.store_ip_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_src_reg_id, + { "Source Registration ID", "lbmr.topt.ume_store.src_reg_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_group, + { "UME Store Group Option", "lbmr.topt.ume_store_group", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_group_type, + { "Type", "lbmr.topt.ume_store_group.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_group_len, + { "Length", "lbmr.topt.ume_store_group.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_group_flags, + { "Flags", "lbmr.topt.ume_store_group.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_group_flags_ignore, + { "Ignore", "lbmr.topt.ume_store_group.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_UME_STORE_GROUP_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_UME_STORE_GROUP_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_group_grp_idx, + { "Group Index", "lbmr.topt.ume_store_group.grp_idx", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_group_grp_sz, + { "Group Size", "lbmr.topt.ume_store_group.grp_sz", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ume_store_group_reserved, + { "Reserved", "lbmr.topt.ume_store_group.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin, + { "Late Join Option", "lbmr.topt.latejoin", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_type, + { "Type", "lbmr.topt.latejoin.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_len, + { "Length", "lbmr.topt.latejoin.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_flags, + { "Flags", "lbmr.topt.latejoin.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_flags_ignore, + { "Ignore", "lbmr.topt.latejoin.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_LATEJOIN_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_flags_acktosrc, + { "Send ACKs to Source", "lbmr.topt.latejoin.flags.acktosrc", FT_BOOLEAN, L_LBMR_TOPIC_OPT_LATEJOIN_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_LATEJOIN_FLAG_ACKTOSRC, "If set, ACKs are sent to source", HFILL } }, + { &hf_lbmr_topt_latejoin_src_tcp_port, + { "Source TCP Port", "lbmr.topt.latejoin.src_tcp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_reserved, + { "Reserved", "lbmr.topt.latejoin.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_src_ip_addr, + { "Source IP Address", "lbmr.topt.latejoin.src_ip_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_transport_idx, + { "Transport Index", "lbmr.topt.latejoin.transport_idx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_high_seqnum, + { "High Sequence Number", "lbmr.topt.latejoin.high_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_latejoin_low_seqnum, + { "Low Sequence Number", "lbmr.topt.latejoin.low_seqnum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_rcridx, + { "Receiver Control Record Index Option", "lbmr.topt.umq_rcridx", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_rcridx_type, + { "Type", "lbmr.topt.umq_rcridx.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_rcridx_len, + { "Length", "lbmr.topt.umq_rcridx.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_rcridx_flags, + { "Flags", "lbmr.topt.umq_rcridx.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_rcridx_flags_ignore, + { "Ignore", "lbmr.topt.umq_rcridx.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_UMQ_RCRIDX_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_UMQ_RCRIDX_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_umq_rcridx_rcr_idx, + { "Receiver Control Record Index", "lbmr.topt.umq_rcridx.rcr_idx", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo, + { "Queue Info Option", "lbmr.topt.umq_qinfo", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_type, + { "Type", "lbmr.topt.umq_qinfo.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_len, + { "Length", "lbmr.topt.umq_qinfo.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_flags, + { "Flags", "lbmr.topt.umq_qinfo.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_flags_ignore, + { "Ignore", "lbmr.topt.umq_qinfo.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_UMQ_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_flags_queue, + { "Queue", "lbmr.topt.umq_qinfo.flags.queue", FT_BOOLEAN, L_LBMR_TOPIC_OPT_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UMQ_FLAG_QUEUE, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_flags_rcvlisten, + { "Receiver Listen", "lbmr.topt.umq_qinfo.flags.rcvlisten", FT_BOOLEAN, L_LBMR_TOPIC_OPT_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UMQ_FLAG_RCVLISTEN, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_flags_control, + { "Control", "lbmr.topt.umq_qinfo.flags.control", FT_BOOLEAN, L_LBMR_TOPIC_OPT_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UMQ_FLAG_CONTROL, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_flags_srcrcvlisten, + { "Source Receiver Listen", "lbmr.topt.umq_qinfo.flags.srcrcvlisten", FT_BOOLEAN, L_LBMR_TOPIC_OPT_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UMQ_FLAG_SRCRCVLISTEN, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_flags_participants_only, + { "Participants Only", "lbmr.topt.umq_qinfo.flags.participants_only", FT_BOOLEAN, L_LBMR_TOPIC_OPT_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TOPIC_OPT_UMQ_FLAG_PARTICIPANTS_ONLY, NULL, HFILL } }, + { &hf_lbmr_topt_umq_qinfo_queue, + { "Queue", "lbmr.topt.ume_qinfo.queue", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_cost, + { "Cost Option", "lbmr.topt.cost", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_cost_type, + { "Type", "lbmr.topt.cost.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_cost_len, + { "Length", "lbmr.topt.cost.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_cost_flags, + { "Flags", "lbmr.topt.cost.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_cost_flags_ignore, + { "Ignore", "lbmr.topt.cost.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_COST_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_COST_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_cost_hop_count, + { "Hop count", "lbmr.topt.cost.hop_count", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_cost_cost, + { "Cost", "lbmr.topt.cost.cost", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_otid, + { "Originating Transport ID Option", "lbmr.topt.otid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_otid_type, + { "Type", "lbmr.topt.otid.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_otid_len, + { "Length", "lbmr.topt.otid.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_otid_flags, + { "Flags", "lbmr.topt.otid.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_otid_flags_ignore, + { "Ignore", "lbmr.topt.otid.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_OTID_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_OTID_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_otid_originating_transport, + { "Originating Transport ID", "lbmr.topt.otid.originating_transport", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinst, + { "Context Instance Option", "lbmr.topt.ctxinst", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinst_type, + { "Type", "lbmr.topt.ctxinst.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinst_len, + { "Length", "lbmr.topt.ctxinst.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinst_flags, + { "Flags", "lbmr.topt.ctxinst.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinst_flags_ignore, + { "Ignore", "lbmr.topt.ctxinst.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_CTXINST_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_CTXINST_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinst_res, + { "Reserved", "lbmr.topt.ctxinst.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinst_ctxinst, + { "Context Instance", "lbmr.topt.ctxinst.ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinsts, + { "Store Context Instance Option", "lbmr.topt.ctxinsts", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinsts_type, + { "Type", "lbmr.topt.ctxinsts.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinsts_len, + { "Length", "lbmr.topt.ctxinsts.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinsts_flags, + { "Flags", "lbmr.topt.ctxinsts.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinsts_flags_ignore, + { "Ignore", "lbmr.topt.ctxinsts.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_CTXINSTS_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_CTXINSTS_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinsts_idx, + { "Index", "lbmr.topt.ctxinsts.idx", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinsts_ctxinst, + { "Store Context Instance", "lbmr.topt.ctxinsts.ctxinsts", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb, + { "ULB Option", "lbmr.topt.ulb", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_type, + { "Type", "lbmr.topt.ulb.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_len, + { "Length", "lbmr.topt.ulb.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_flags, + { "Flags", "lbmr.topt.ulb.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_flags_ignore, + { "Ignore", "lbmr.topt.ulb.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_ULB_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_ULB_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_queue_id, + { "Queue ID", "lbmr.topt.ulb.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_regid, + { "Registration ID", "lbmr.topt.ulb.regid", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_ulb_src_id, + { "ULB Source ID", "lbmr.topt.ulb.ulb_src_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_src_ip_addr, + { "Source IP Address", "lbmr.topt.ulb.src_ip_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_src_tcp_port, + { "Source TCP Port", "lbmr.topt.ulb.src_tcp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ulb_reserved, + { "Reserved", "lbmr.topt.ulb.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinstq, + { "Queue Context Instance Option", "lbmr.topt.ctxinstq", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinstq_type, + { "Type", "lbmr.topt.ctxinstq.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinstq_len, + { "Length", "lbmr.topt.ctxinstq.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinstq_flags, + { "Flags", "lbmr.topt.ctxinstq.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinstq_flags_ignore, + { "Ignore", "lbmr.topt.ctxinstq.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_CTXINSTQ_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_CTXINSTQ_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinstq_idx, + { "Index", "lbmr.topt.ctxinstq.idx", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_ctxinstq_ctxinst, + { "Store Context Instance", "lbmr.topt.ctxinstq.ctxinstq", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_domain_id, + { "Domain ID Option", "lbmr.topt.domain_id", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_domain_id_type, + { "Type", "lbmr.topt.domain_id.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_domain_id_len, + { "Length", "lbmr.topt.domain_id.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_domain_id_flags, + { "Flags", "lbmr.topt.domain_id.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_domain_id_flags_ignore, + { "Ignore", "lbmr.topt.domain_id.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_DOMAIN_ID_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_DOMAIN_ID_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_domain_id_domain_id, + { "Domain ID", "lbmr.topt.domain_id.domain_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc, + { "Extended Functionality Option", "lbmr.topt.exfunc", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_type, + { "Type", "lbmr.topt.exfunc.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_len, + { "Length", "lbmr.topt.exfunc.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_flags, + { "Flags", "lbmr.topt.exfunc.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_flags_ignore, + { "Ignore", "lbmr.topt.exfunc.flags.ignore", FT_BOOLEAN, L_LBMR_TOPIC_OPT_EXFUNC_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TOPIC_OPT_EXFUNC_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_src_tcp_port, + { "Source TCP Port", "lbmr.topt.exfunc.src_tcp_port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_reserved, + { "Reserved", "lbmr.topt.exfunc.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_src_ip_addr, + { "Source IP Address", "lbmr.topt.exfunc.src_ip_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_functionality_flags, + { "Functionality Flags", "lbmr.topt.exfunc.functionality_flags", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_exfunc_functionality_flags_ulb, + { "ULB", "lbmr.topt.exfunc.functionality_flags.ulb", FT_BOOLEAN, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS * 8, TFS(&tfs_capable_not_capable), LBM_TOPIC_OPT_EXFUNC_FFLAG_ULB, "Set if ULB supported", HFILL } }, + { &hf_lbmr_topt_exfunc_functionality_flags_umq, + { "UMQ", "lbmr.topt.exfunc.functionality_flags.umq", FT_BOOLEAN, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS * 8, TFS(&tfs_capable_not_capable), LBM_TOPIC_OPT_EXFUNC_FFLAG_UMQ, "Set if UMQ supported", HFILL } }, + { &hf_lbmr_topt_exfunc_functionality_flags_ume, + { "UME", "lbmr.topt.exfunc.functionality_flags.ume", FT_BOOLEAN, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS * 8, TFS(&tfs_capable_not_capable), LBM_TOPIC_OPT_EXFUNC_FFLAG_UME, "Set if UME supported", HFILL } }, + { &hf_lbmr_topt_exfunc_functionality_flags_lj, + { "Late Join", "lbmr.topt.exfunc.functionality_flags.lj", FT_BOOLEAN, L_LBMR_TOPIC_OPT_EXFUNC_T_FUNCTIONALITY_FLAGS * 8, TFS(&tfs_capable_not_capable), LBM_TOPIC_OPT_EXFUNC_FFLAG_LJ, "Set if late join supported", HFILL } }, + { &hf_lbmr_topt_unknown, + { "Unknown Option", "lbmr.topt.unknown", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_unknown_type, + { "Type", "lbmr.topt.unknown.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_topic_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_unknown_len, + { "Length", "lbmr.topt.unknown.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_unknown_flags, + { "Flags", "lbmr.topt.unknown.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topt_unknown_data, + { "Data", "lbmr.topt.unknown.data", FT_BYTES, FT_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tmb, + { "Topic Management Block", "lbmr.tmb", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tmb_len, + { "Length", "lbmr.tmb.len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tmb_tmrs, + { "Topic Management Record Count", "lbmr.tmb.tmrs", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tmb_tmr_list, + { "Topic Management Records", "lbmr.tmb.tmr_list", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tmr, + { "Topic Management Record", "lbmr.tmb.tmr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tmr_len, + { "Length", "lbmr.tmb.tmr.len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tmr_type, + { "TMR Type", "lbmr.tmb.tmr.type", FT_UINT8, BASE_DEC, VALS(lbmr_tmr_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tmr_flags, + { "Flags", "lbmr.tmb.tmr.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tmr_flags_response, + { "Response", "lbmr.tmb.tmr.flags.response", FT_BOOLEAN, L_LBMR_TMR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TMR_FLAG_RESPONSE, "Set if this is a response", HFILL } }, + { &hf_lbmr_tmr_flags_wildcard_pcre, + { "PCRE pattern", "lbmr.tmb.tmr.flags.wildcard_pcre", FT_BOOLEAN, L_LBMR_TMR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TMR_FLAG_WILDCARD_PCRE, "Set if topic is a PCRE pattern", HFILL } }, + { &hf_lbmr_tmr_flags_wildcard_regex, + { "Regex pattern", "lbmr.tmb.tmr.flags.wildcard_regex", FT_BOOLEAN, L_LBMR_TMR_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TMR_FLAG_WILDCARD_REGEX, "Set if topic is a Regex pattern", HFILL } }, + { &hf_lbmr_tmr_name, + { "Topic Name", "lbmr.tmb.tmr.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_dep_type, + { "Dependent Type", "lbmr.pser.dep_type", FT_UINT16, BASE_DEC_HEX, VALS(lbmr_pser_dependent_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_len, + { "Length", "lbmr.pser.len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_flags, + { "Flags", "lbmr.pser.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_flags_option, + { "Option", "lbmr.pser.flags.option", FT_BOOLEAN, L_LBMR_PSER_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_PSER_OPT_FLAG, NULL, HFILL } }, + { &hf_lbmr_pser_source_ip, + { "Source IP", "lbmr.pser.source_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_store_ip, + { "Store IP", "lbmr.pser.store_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_transport_idx, + { "Transport Index", "lbmr.pser.transport_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_topic_idx, + { "Topic Index", "lbmr.pser.topic_idx", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_source_port, + { "Source Port", "lbmr.pser.source_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_store_port, + { "Store Port", "lbmr.pser.store_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_topic, + { "Topic", "lbmr.pser.topic", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_opts, + { "Options", "lbmr.pser.opts", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_optlen, + { "Option Length", "lbmr.pser.opt.optlen", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_optlen_type, + { "Type", "lbmr.pser.opt.optlen.type", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_optlen_optlen, + { "Options Length", "lbmr.pser.opt.optlen.optlen", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_opt_ctxinst, + { "Context Instance Option", "lbmr.pser.opt.ctxinst", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_opt_ctxinst_len, + { "Length", "lbmr.pser.opt.ctxinst.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_opt_ctxinst_type, + { "Type", "lbmr.pser.opt.ctxinst.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_pser_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_pser_opt_ctxinst_ctxinst, + { "Context Instance", "lbmr.pser.opt.ctxinst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qqr, + { "QQRs", "lbmr.qqr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qqr_name, + { "Queue name", "lbmr.qqr.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qirs, + { "QIRs", "lbmr.qirs", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir, + { "QIR", "lbmr.qir", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_name, + { "Queue name", "lbmr.qir.qname", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_topic_name, + { "Topic name", "lbmr.qir.tname", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_id, + { "Queue ID", "lbmr.qir.queue_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_ver, + { "Queue Version", "lbmr.qir.queue_ver", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_prev_ver, + { "Queue Previous Version", "lbmr.qir.queue_prev_ver", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_grp_blks, + { "Group Blocks", "lbmr.qir.grp_blks", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_grp_blks_option_flag, + { "QIR Options Present", "lbmr.qir.grp_blocks.opts", FT_BOOLEAN, L_LBMR_QIR_T_GRP_BLKS * 8, TFS(&tfs_set_notset), LBMR_QIR_OPTIONS, NULL, HFILL } }, + { &hf_lbmr_qir_grp_blks_count, + { "Group Block Count", "lbmr.qir.grp_blks.count", FT_UINT16, BASE_DEC_HEX, NULL, LBMR_QIR_GRP_BLOCKS_MASK, NULL, HFILL } }, + { &hf_lbmr_qir_queue_blks, + { "Queue Blocks", "lbmr.qir.queue_blks", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_grps, + { "Groups", "lbmr.qir.grps", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_grp_blk, + { "Group Block", "lbmr.qir.grp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_grp_blk_grp_idx, + { "Group Index", "lbmr.qir.grp.grp_idx", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_grp_blk_grp_sz, + { "Group Size", "lbmr.qir.grp.grp_sz", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queues, + { "Queues", "lbmr.qir.queues", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_blk, + { "Queue Block", "lbmr.qir.queue", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_blk_ip, + { "IP Address", "lbmr.qir.queue.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_blk_port, + { "Port", "lbmr.qir.queue.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_blk_idx, + { "Index", "lbmr.qir.queue.idx", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_blk_grp_idx, + { "Group Index", "lbmr.qir.queue.grp_idx", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_qir_queue_blk_reserved, + { "Reserved", "lbmr.qir.queue.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opts, + { "Options", "lbmr.opt", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_len, + { "Length Option", "lbmr.opt.len", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_len_type, + { "Type", "lbmr.opt.len.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_len_len, + { "Length", "lbmr.opt.len.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_len_total_len, + { "Total Length", "lbmr.opt.len.total_len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_id, + { "Source ID Option", "lbmr.opt.src_id", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_id_type, + { "Type", "lbmr.opt.src_id.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_id_len, + { "Length", "lbmr.opt.src_id.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_id_flags, + { "Flags", "lbmr.opt.src_id.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_id_flags_ignore, + { "Ignore", "lbmr.opt.src_id.flags.ignore", FT_BOOLEAN, L_LBMR_LBMR_OPT_SRC_ID_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_LBMR_OPT_SRC_ID_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_opt_src_id_src_id, + { "Source ID", "lbmr.opt.src_id.src_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_type, + { "Source Type Option", "lbmr.opt.src_type", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_type_type, + { "Type", "lbmr.opt.src_type.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_type_len, + { "Length", "lbmr.opt.src_type.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_type_flags, + { "Flags", "lbmr.opt.src_type.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_src_type_flags_ignore, + { "Ignore", "lbmr.opt.src_type.flags.ignore", FT_BOOLEAN, L_LBMR_LBMR_OPT_SRC_TYPE_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_LBMR_OPT_SRC_TYPE_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_opt_src_type_src_type, + { "Source Type", "lbmr.opt.src_type.src_type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_option_source_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_version, + { "Version Option", "lbmr.opt.version", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_version_type, + { "Type", "lbmr.opt.version.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_version_len, + { "Length", "lbmr.opt.version.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_version_flags, + { "Flags", "lbmr.opt.version.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_version_flags_ignore, + { "Ignore", "lbmr.opt.version.flags.ignore", FT_BOOLEAN, L_LBMR_LBMR_OPT_VERSION_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_LBMR_OPT_VERSION_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_opt_version_flags_ume, + { "UME Capable", "lbmr.opt.version.flags.ume", FT_BOOLEAN, L_LBMR_LBMR_OPT_VERSION_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_LBMR_OPT_VERSION_FLAG_UME, "Set if UME capable", HFILL } }, + { &hf_lbmr_opt_version_flags_umq, + { "UMQ Capable", "lbmr.opt.version.flags.umq", FT_BOOLEAN, L_LBMR_LBMR_OPT_VERSION_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_LBMR_OPT_VERSION_FLAG_UMQ, "Set if UMQ capable", HFILL } }, + { &hf_lbmr_opt_version_version, + { "Version", "lbmr.opt.version.version", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_local_domain, + { "Local Domain Option", "lbmr.opt.local_domain", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_local_domain_type, + { "Type", "lbmr.opt.local_domain.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_local_domain_len, + { "Length", "lbmr.opt.local_domain.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_local_domain_flags, + { "Flags", "lbmr.opt.local_domain.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_local_domain_flags_ignore, + { "Ignore", "lbmr.opt.local_domain.flags.ignore", FT_BOOLEAN, L_LBMR_LBMR_OPT_LOCAL_DOMAIN_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_LBMR_OPT_VERSION_FLAG_IGNORE, NULL, HFILL } }, + { &hf_lbmr_opt_local_domain_local_domain_id, + { "Local Domain ID", "lbmr.opt.local_domain.local_domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_unknown, + { "Unknown ID Option", "lbmr.opt.unknown", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_unknown_type, + { "Type", "lbmr.opt.unknown.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_unknown_len, + { "Length", "lbmr.opt.unknown.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_unknown_flags, + { "Flags", "lbmr.opt.unknown.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_opt_unknown_data, + { "Data", "lbmr.opt.unknown.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topic_res_request_flags, + { "Flags", "lbmr.topic_res_request.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_topic_res_request_flags_gw_remote_interest, + { "Gateway Remote Interest", "lbmr.topic_res_request.flags.gw_remote_interest", FT_BOOLEAN, 8 * L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, TFS(&tfs_set_notset), LBM_TOPIC_RES_REQUEST_GW_REMOTE_INTEREST, "Set if gateway remote interest is requested", HFILL } }, + { &hf_lbmr_topic_res_request_flags_context_query, + { "Context Queries", "lbmr.topic_res_request.flags.context_query", FT_BOOLEAN, 8 * L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, TFS(&tfs_set_notset), LBM_TOPIC_RES_REQUEST_CONTEXT_QUERY, "Set if context queries are requested", HFILL } }, + { &hf_lbmr_topic_res_request_flags_context_advertisement, + { "Context Advertisements", "lbmr.topic_res_request.flags.context_advertisement", FT_BOOLEAN, 8 * L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, TFS(&tfs_set_notset), LBM_TOPIC_RES_REQUEST_CONTEXT_ADVERTISEMENT, "Set if context advertisements are requested", HFILL } }, + { &hf_lbmr_topic_res_request_flags_gateway_meta, + { "Gateway Meta Flag", "lbmr.topic_res_request.flags.gateway_meta", FT_BOOLEAN, 8 * L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, TFS(&tfs_set_notset), LBM_TOPIC_RES_REQUEST_RESERVED1, NULL, HFILL } }, + { &hf_lbmr_topic_res_request_flags_advertisement, + { "Advertisements", "lbmr.topic_res_request.flags.advertisement", FT_BOOLEAN, 8 * L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, TFS(&tfs_set_notset), LBM_TOPIC_RES_REQUEST_ADVERTISEMENT, "Set if advertisements are requested", HFILL } }, + { &hf_lbmr_topic_res_request_flags_query, + { "Queries", "lbmr.topic_res_request.flags.query", FT_BOOLEAN, 8 * L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, TFS(&tfs_set_notset), LBM_TOPIC_RES_REQUEST_QUERY, "Set if queries are requested", HFILL } }, + { &hf_lbmr_topic_res_request_flags_wildcard_query, + { "Wildcard Queries", "lbmr.topic_res_request.flags.wildcard_query", FT_BOOLEAN, 8 * L_LBMR_TOPIC_RES_REQUEST_T_FLAGS, TFS(&tfs_set_notset), LBM_TOPIC_RES_REQUEST_WILDCARD_QUERY, "Set if wildcard queries are requested", HFILL } }, + { &hf_lbmr_ctxinfo_len, + { "Length", "lbmr.ctxinfo.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_ctxinfo_hop_count, + { "Hop Count", "lbmr.ctxinfo.hop_count", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_ctxinfo_flags, + { "Flags", "lbmr.ctxinfo.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_ctxinfo_flags_query, + { "Query", "lbmr.ctxinfo.flags.query", FT_BOOLEAN, 16, TFS(&tfs_set_notset), LBMR_CTXINFO_QUERY_FLAG, "Set if query, clear if response", HFILL } }, + { &hf_lbmr_ctxinfo_flags_ip, + { "IP Address", "lbmr.ctxinfo.flags.ip", FT_BOOLEAN, 16, TFS(&tfs_present_not_present), LBMR_CTXINFO_IP_FLAG, "Set if IP address is included", HFILL } }, + { &hf_lbmr_ctxinfo_flags_instance, + { "Instance", "lbmr.ctxinfo.flags.instance", FT_BOOLEAN, 16, TFS(&tfs_present_not_present), LBMR_CTXINFO_INSTANCE_FLAG, "Set if context instance is included", HFILL } }, + { &hf_lbmr_ctxinfo_flags_tnwg_src, + { "Gateway Source", "lbmr.ctxinfo.flags.tnwg_src", FT_BOOLEAN, 16, TFS(&tfs_set_notset), LBMR_CTXINFO_TNWG_SRC_FLAG, "Set if a gateway source", HFILL } }, + { &hf_lbmr_ctxinfo_flags_tnwg_rcv, + { "Gateway Receiver", "lbmr.ctxinfo.flags.tnwg_rcv", FT_BOOLEAN, 16, TFS(&tfs_set_notset), LBMR_CTXINFO_TNWG_RCV_FLAG, "Set if a gateway receiver", HFILL } }, + { &hf_lbmr_ctxinfo_flags_proxy, + { "Proxy", "lbmr.ctxinfo.flags.proxy", FT_BOOLEAN, 16, TFS(&tfs_set_notset), LBMR_CTXINFO_PROXY_FLAG, "Set if a proxy for another context", HFILL } }, + { &hf_lbmr_ctxinfo_flags_name, + { "Name", "lbmr.ctxinfo.flags.name", FT_BOOLEAN, 16, TFS(&tfs_present_not_present), LBMR_CTXINFO_NAME_FLAG, "Set if context name is included", HFILL } }, + { &hf_lbmr_ctxinfo_port, + { "Port", "lbmr.ctxinfo.port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_ctxinfo_ip, + { "IP Address", "lbmr.ctxinfo.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_ctxinfo_instance, + { "Instance", "lbmr.ctxinfo.instance", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_ctxinfo_name, + { "Name", "lbmr.ctxinfo.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_len, + { "Length", "lbmr.tnwg.len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_type, + { "Type", "lbmr.tnwg.type", FT_UINT16, BASE_DEC_HEX, VALS(lbmr_tnwg_function_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_reserved, + { "Reserved", "lbmr.tnwg.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest, + { "Interest", "lbmr.tnwg.interest", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest_len, + { "Length", "lbmr.tnwg.interest.len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest_count, + { "Record Count", "lbmr.tnwg.interest.count", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest_rec, + { "Interest Record", "lbmr.tnwg.interest_rec", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest_rec_len, + { "Length", "lbmr.tnwg.interest_rec.len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest_rec_flags, + { "Flags", "lbmr.tnwg.interest_rec.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest_rec_flags_pattern, + { "Pattern", "lbmr.tnwg.interest_rec.flags.pattern", FT_BOOLEAN, L_LBMR_TNWG_INTEREST_REC_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TNWG_INTEREST_REC_PATTERN_FLAG, "Set if interest is for a pattern", HFILL } }, + { &hf_lbmr_tnwg_interest_rec_flags_cancel, + { "Cancel", "lbmr.tnwg.interest_rec.flags.cancel", FT_BOOLEAN, L_LBMR_TNWG_INTEREST_REC_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TNWG_INTEREST_REC_CANCEL_FLAG, "Set if interest is being cancelled", HFILL } }, + { &hf_lbmr_tnwg_interest_rec_flags_refresh, + { "Refresh", "lbmr.tnwg.interest_rec.flags.refresh", FT_BOOLEAN, L_LBMR_TNWG_INTEREST_REC_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_TNWG_INTEREST_REC_REFRESH_FLAG, "Set if interest is being refreshed", HFILL } }, + { &hf_lbmr_tnwg_interest_rec_pattype, + { "Pattern Type", "lbmr.tnwg.interest_rec.pattype", FT_UINT8, BASE_DEC_HEX, VALS(lbm_wildcard_pattern_type_short), 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest_rec_domain_id, + { "Domain ID", "lbmr.tnwg.interest_rec.domain_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_interest_rec_symbol, + { "Symbol", "lbmr.tnwg.interest_rec.symbol", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_ctxinfo, + { "Context Information", "lbmr.tnwg.ctxinfo", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_len, + { "Length", "lbmr.tnwg.ctxinfo.len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_hop_count, + { "Hop Count", "lbmr.tnwg.ctxinfo.hop_count", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_reserved, + { "Reserved", "lbmr.tnwg.ctxinfo.reserved", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_flags1, + { "Flags1", "lbmr.tnwg.ctxinfo.flags1", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_flags1_query, + { "Query", "lbmr.tnwg.ctxinfo.flags1.query", FT_BOOLEAN, L_LBMR_TNWG_CTXINFO_T_FLAGS1 * 8, TFS(&tfs_set_notset), LBMR_TNWG_CTXINFO_QUERY_FLAG, "Set if a query, clear if a response", HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_flags1_tnwg_src, + { "TNWG Source", "lbmr.tnwg.ctxinfo.flags1.tnwg_src", FT_BOOLEAN, L_LBMR_TNWG_CTXINFO_T_FLAGS1 * 8, TFS(&tfs_set_notset), LBMR_TNWG_CTXINFO_TNWG_SRC_FLAG, "Set if a gateway source", HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_flags1_tnwg_rcv, + { "TNWG Receiver", "lbmr.tnwg.ctxinfo.flags1.tnwg_rcv", FT_BOOLEAN, L_LBMR_TNWG_CTXINFO_T_FLAGS1 * 8, TFS(&tfs_set_notset), LBMR_TNWG_CTXINFO_TNWG_RCV_FLAG, "Set if a gateway receiver", HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_flags1_proxy, + { "Proxy", "lbmr.tnwg.ctxinfo.flags1.proxy", FT_BOOLEAN, L_LBMR_TNWG_CTXINFO_T_FLAGS1 * 8, TFS(&tfs_set_notset), LBMR_TNWG_CTXINFO_PROXY_FLAG, "Set if a proxy for another context", HFILL } }, + { &hf_lbmr_tnwg_ctxinfo_flags2, + { "Flags2", "lbmr.tnwg.ctxinfo.flags2", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_trreq, + { "Topic Res Request", "lbmr.tnwg.trreq", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_trreq_len, + { "Length", "lbmr.tnwg.trreq.len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt, + { "Unknown Option", "lbmr.tnwg.opt", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_type, + { "Type", "lbmr.tnwg.opt.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_tnwg_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_len, + { "Length", "lbmr.tnwg.opt.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_flags, + { "Flags", "lbmr.tnwg.opt.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_flags_ignore, + { "Ignore", "lbmr.tnwg.opt.flags.ignore", FT_BOOLEAN, L_LBMR_TNWG_OPT_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TNWG_OPT_IGNORE_FLAG, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_data, + { "Data", "lbmr.tnwg.opt.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_ctxinst, + { "Context Instance Option", "lbmr.tnwg.opt_ctxinst", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_ctxinst_type, + { "Type", "lbmr.tnwg.opt_ctxinst.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_tnwg_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_ctxinst_len, + { "Length", "lbmr.tnwg.opt_ctxinst.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_ctxinst_flags, + { "Flags", "lbmr.tnwg.opt_ctxinst.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_ctxinst_flags_ignore, + { "Ignore", "lbmr.tnwg.opt_ctxinst.flags.ignore", FT_BOOLEAN, L_LBMR_TNWG_OPT_CTXINST_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TNWG_OPT_IGNORE_FLAG, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_ctxinst_instance, + { "Context Instance", "lbmr.tnwg.opt_ctxinst.instance", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_address, + { "Address Option", "lbmr.tnwg.opt_address", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_address_type, + { "Type", "lbmr.tnwg.opt_address.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_tnwg_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_address_len, + { "Length", "lbmr.tnwg.opt_address.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_address_flags, + { "Flags", "lbmr.tnwg.opt_address.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_address_flags_ignore, + { "Ignore", "lbmr.tnwg.opt_address.flags.ignore", FT_BOOLEAN, L_LBMR_TNWG_OPT_ADDRESS_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TNWG_OPT_IGNORE_FLAG, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_address_port, + { "Port", "lbmr.tnwg.opt_address.port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_address_res, + { "Reserved", "lbmr.tnwg.opt_address.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_address_ip, + { "IP Address", "lbmr.tnwg.opt_address.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_domain, + { "Domain Option", "lbmr.tnwg.opt_domain", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_domain_type, + { "Type", "lbmr.tnwg.opt_domain.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_tnwg_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_domain_len, + { "Length", "lbmr.tnwg.opt_domain.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_domain_flags, + { "Flags", "lbmr.tnwg.opt_domain.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_domain_flags_ignore, + { "Ignore", "lbmr.tnwg.opt_domain.flags.ignore", FT_BOOLEAN, L_LBMR_TNWG_OPT_DOMAIN_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TNWG_OPT_IGNORE_FLAG, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_domain_domain_id, + { "Domain ID", "lbmr.tnwg.opt_domain.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_name, + { "Name Option", "lbmr.tnwg.opt_name", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_name_type, + { "Type", "lbmr.tnwg.opt_name.type", FT_UINT8, BASE_HEX_DEC, VALS(lbmr_tnwg_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_name_len, + { "Length", "lbmr.tnwg.opt_name.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_name_flags, + { "Flags", "lbmr.tnwg.opt_name.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_name_flags_ignore, + { "Ignore", "lbmr.tnwg.opt_name.flags.ignore", FT_BOOLEAN, L_LBMR_TNWG_OPT_T_FLAGS * 8, TFS(&lbm_ignore_flag), LBMR_TNWG_OPT_IGNORE_FLAG, NULL, HFILL } }, + { &hf_lbmr_tnwg_opt_name_name, + { "Name", "lbmr.tnwg.opt_name.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_remote_domain_route_hdr_num_domains, + { "Number of Domains", "lbmr.remote_domain_route.num_domains", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_remote_domain_route_hdr_ip, + { "IP Address", "lbmr.remote_domain_route.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_remote_domain_route_hdr_port, + { "Port", "lbmr.remote_domain_route.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_remote_domain_route_hdr_reserved, + { "Reserved", "lbmr.remote_domain_route.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_remote_domain_route_hdr_length, + { "Length", "lbmr.remote_domain_route.length", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_remote_domain_route_hdr_domain, + { "Domain", "lbmr.remote_domain_route.domain", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_len, + { "Length", "lbmr.rctxinfo.len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_num_recs, + { "Number of Records", "lbmr.rctxinfo.num_recs", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_reserved, + { "Reserved", "lbmr.rctxinfo.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec, + { "Remote Context Information Record", "lbmr.rctxinfo.rec", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_len, + { "Length", "lbmr.rctxinfo.rec.len", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_flags, + { "Flags", "lbmr.rctxinfo.rec.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_flags_query, + { "Query", "lbmr.rctxinfo.rec.flags.query", FT_BOOLEAN, L_LBMR_RCTXINFO_REC_T_FLAGS * 8, TFS(&tfs_set_notset), LBMR_RCTXINFO_REC_FLAG_QUERY, "Set if a query, clear if a response", HFILL } }, + { &hf_lbmr_rctxinfo_rec_address, + { "Address Option", "lbmr.rctxinfo.rec.address", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_address_type, + { "Type", "lbmr.rctxinfo.rec.address.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_rctxinfo_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_address_len, + { "Length", "lbmr.rctxinfo.rec.address.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_address_flags, + { "Flags", "lbmr.rctxinfo.rec.address.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_address_domain_id, + { "Domain ID", "lbmr.rctxinfo.rec.address.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_address_ip, + { "Address", "lbmr.rctxinfo.rec.address.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_address_port, + { "Port", "lbmr.rctxinfo.rec.address.port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_address_res, + { "Reserved", "lbmr.rctxinfo.rec.address.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_instance, + { "Instance Option", "lbmr.rctxinfo.rec.instance", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_instance_type, + { "Type", "lbmr.rctxinfo.rec.instance.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_rctxinfo_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_instance_len, + { "Length", "lbmr.rctxinfo.rec.instance.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_instance_flags, + { "Flags", "lbmr.rctxinfo.rec.instance.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_instance_instance, + { "Instance", "lbmr.rctxinfo.rec.instance.instance", FT_BYTES, FT_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_odomain, + { "Originating Domain Option", "lbmr.rctxinfo.rec.odomain", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_odomain_type, + { "Type", "lbmr.rctxinfo.rec.odomain.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_rctxinfo_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_odomain_len, + { "Length", "lbmr.rctxinfo.rec.odomain.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_odomain_flags, + { "Flags", "lbmr.rctxinfo.rec.odomain.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_odomain_domain_id, + { "Domain ID", "lbmr.rctxinfo.rec.odomain.domain_id", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_name, + { "Name Option", "lbmr.rctxinfo.rec.name", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_name_type, + { "Type", "lbmr.rctxinfo.rec.name.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_rctxinfo_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_name_len, + { "Length", "lbmr.rctxinfo.rec.name.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_name_flags, + { "Flags", "lbmr.rctxinfo.rec.name.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_name_name, + { "Name", "lbmr.rctxinfo.rec.name.name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_unknown, + { "Unknown Option", "lbmr.rctxinfo.rec.unknown", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_unknown_type, + { "Type", "lbmr.rctxinfo.rec.unknown.type", FT_UINT8, BASE_DEC_HEX, VALS(lbmr_rctxinfo_option_type), 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_unknown_len, + { "Length", "lbmr.rctxinfo.rec.unknown.len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_unknown_flags, + { "Flags", "lbmr.rctxinfo.rec.unknown.flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbmr_rctxinfo_rec_unknown_data, + { "Data", "lbmr.rctxinfo.rec.unknown.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_flags, + { "Flags", "lbmr.qmgmt.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_flags_i_flag, + { "Ignore", "lbmr.qmgmt.flags.i_flag", FT_BOOLEAN, L_UMQ_QMGMT_HDR_T_FLAGS * 8, TFS(&lbm_ignore_flag), UMQ_QMGMT_HDR_I_FLAG, NULL, HFILL } }, + { &hf_qmgmt_flags_n_flag, + { "Queue Name", "lbmr.qmgmt.flags.n_flag", FT_BOOLEAN, L_UMQ_QMGMT_HDR_T_FLAGS * 8, TFS(&tfs_present_not_present), UMQ_QMGMT_HDR_N_FLAG, "Set if queue name is present", HFILL } }, + { &hf_qmgmt_flags_il_l_flag, + { "New Instance List", "lbmr.qmgmt.flags.il_l_flag", FT_BOOLEAN, L_UMQ_QMGMT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), UMQ_QMGMT_HDR_IL_L_FLAG, "Set if contains a new instance list", HFILL } }, + { &hf_qmgmt_flags_il_k_flag, + { "Keepalive Requested", "lbmr.qmgmt.flags.il_k_flag", FT_BOOLEAN, L_UMQ_QMGMT_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), UMQ_QMGMT_HDR_IL_K_FLAG, "Set if a keepalive requester", HFILL } }, + { &hf_qmgmt_pckt_type, + { "Packet Type", "lbmr.qmgmt.pckt_type", FT_UINT8, BASE_HEX_DEC, VALS(umq_qmgmt_packet_type), 0x0, NULL, HFILL } }, + { &hf_qmgmt_cfgsig, + { "Configuration Signature", "lbmr.qmgmt.cfg_sig", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_queue_id, + { "Queue ID", "lbmr.qmgmt.queue_id", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_queue_ver, + { "Queue Version", "lbmr.qmgmt.queue_ver", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_ip, + { "IP Address", "lbmr.qmgmt.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_port, + { "Port", "lbmr.qmgmt.port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_inst_idx, + { "Instance Index", "lbmr.qmgmt.inst_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_grp_idx, + { "Group Index", "lbmr.qmgmt.grp_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_pckt_type_dep16, + { "Packet-Type Dependent Data", "lbmr.qmgmt.pckt_type_dep16", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_num_insts, + { "Number of IL Instances", "lbmr.qmgmt.il_num_insts", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_jrej_code, + { "Join Rejection Code", "lbmr.qmgmt.jrej_code", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_ev_bias, + { "EV Bias", "lbmr.qmgmt.ev_bias", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il, + { "Instance List Header", "lbmr.qmgmt.il", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_highest_rcr_tsp, + { "Highest RCR TSP", "lbmr.qmgmt.il.highest_rcr_tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_inst, + { "Instance Header", "lbmr.qmgmt.il_inst", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_inst_ip, + { "IP", "lbmr.qmgmt.il_inst.ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_inst_port, + { "Port", "lbmr.qmgmt.il_inst.port", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_inst_inst_idx, + { "Instance Index", "lbmr.qmgmt.il_inst.inst_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_inst_grp_idx, + { "Group Index", "lbmr.qmgmt.il_inst.grp_idx", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_inst_flags, + { "Flags", "lbmr.qmgmt.il_inst.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_il_inst_flags_m_flag, + { "Master", "lbmr.qmgmt.il_inst.flags.m_flag", FT_BOOLEAN, L_UMQ_QMGMT_IL_INST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), UMQ_QMGMT_HDR_IL_INST_M_FLAG, "Set if the master queue", HFILL } }, + { &hf_qmgmt_il_inst_flags_q_flag, + { "Queue Election Master", "lbmr.qmgmt.il_inst.flags.q_flag", FT_BOOLEAN, L_UMQ_QMGMT_IL_INST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), UMQ_QMGMT_HDR_IL_INST_Q_FLAG, "Set if a queue election master", HFILL } }, + { &hf_qmgmt_il_inst_flags_p_flag, + { "Post Election Master", "lbmr.qmgmt.il_inst.flags.p_flag", FT_BOOLEAN, L_UMQ_QMGMT_IL_INST_HDR_T_FLAGS * 8, TFS(&tfs_set_notset), UMQ_QMGMT_HDR_IL_INST_P_FLAG, "Set if a post election master", HFILL } }, + { &hf_qmgmt_ec, + { "Election Call Header", "lbmr.qmgmt.ec", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_ec_queue_new_ver, + { "Queue New Version", "lbmr.qmgmt.ec.queue_new_ver", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_ev, + { "Election Vote Header", "lbmr.qmgmt.ev", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_ev_highest_rcr_tsp, + { "Highest RCR TSP", "lbmr.qmgmt.ev.highest_rcr_tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_ev_age, + { "Age", "lbmr.qmgmt.ev.age", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_qro, + { "Queue Resume Operation Header", "lbmr.qmgmt.qro", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_qro_highest_rcr_tsp, + { "Highest RCR TSP", "lbmr.qmgmt.qro.highest_rcr_tsp", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_qmgmt_qname, + { "Queue Name", "lbmr.qmgmt.qname", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } } + }; + static gint * ett[] = + { + &ett_lbmr, + &ett_lbmr_hdr, + &ett_lbmr_hdr_ver_type, + &ett_lbmr_opts, + &ett_lbmr_opt_src_id, + &ett_lbmr_opt_src_id_flags, + &ett_lbmr_opt_len, + &ett_lbmr_opt_src_type, + &ett_lbmr_opt_src_type_flags, + &ett_lbmr_opt_version, + &ett_lbmr_opt_version_flags, + &ett_lbmr_opt_local_domain, + &ett_lbmr_opt_local_domain_flags, + &ett_lbmr_opt_unknown, + &ett_lbmr_tqrs, + &ett_lbmr_tqr, + &ett_lbmr_tirs, + &ett_lbmr_tir, + &ett_lbmr_tir_transport, + &ett_lbmr_tir_tcp, + &ett_lbmr_tir_lbtrm, + &ett_lbmr_tir_lbtru, + &ett_lbmr_tir_lbtipc, + &ett_lbmr_tir_lbtrdma, + &ett_lbmr_tir_lbtsmx, + &ett_lbmr_topts, + &ett_lbmr_topt_len, + &ett_lbmr_topt_ume, + &ett_lbmr_topt_ume_flags, + &ett_lbmr_topt_ume_store, + &ett_lbmr_topt_ume_store_flags, + &ett_lbmr_topt_ume_store_group, + &ett_lbmr_topt_ume_store_group_flags, + &ett_lbmr_topt_latejoin, + &ett_lbmr_topt_latejoin_flags, + &ett_lbmr_topt_umq_rcridx, + &ett_lbmr_topt_umq_rcridx_flags, + &ett_lbmr_topt_umq_qinfo, + &ett_lbmr_topt_umq_qinfo_flags, + &ett_lbmr_topt_cost, + &ett_lbmr_topt_cost_flags, + &ett_lbmr_topt_otid, + &ett_lbmr_topt_otid_flags, + &ett_lbmr_topt_ctxinst, + &ett_lbmr_topt_ctxinst_flags, + &ett_lbmr_topt_ctxinsts, + &ett_lbmr_topt_ctxinsts_flags, + &ett_lbmr_topt_ulb, + &ett_lbmr_topt_ulb_flags, + &ett_lbmr_topt_domain_id, + &ett_lbmr_topt_domain_id_flags, + &ett_lbmr_topt_exfunc, + &ett_lbmr_topt_exfunc_flags, + &ett_lbmr_topt_exfunc_functionality_flags, + &ett_lbmr_topt_unknown, + &ett_lbmr_tmb, + &ett_lbmr_tmrs, + &ett_lbmr_tmr, + &ett_lbmr_tmr_flags, + &ett_lbmr_pser_flags, + &ett_lbmr_pser_opts, + &ett_lbmr_pser_opt_len, + &ett_lbmr_pser_opt_ctxinst, + &ett_lbmr_qqrs, + &ett_lbmr_qirs, + &ett_lbmr_qir, + &ett_lbmr_qir_options, + &ett_lbmr_qir_grp_blks, + &ett_lbmr_qir_grp_blk, + &ett_lbmr_qir_queue_blk, + &ett_lbmr_qir_grp, + &ett_lbmr_qir_queue, + &ett_lbmr_topic_res_request_flags, + &ett_lbmr_ctxinfo_flags, + &ett_lbmr_tnwg, + &ett_lbmr_tnwg_interest, + &ett_lbmr_tnwg_interest_rec, + &ett_lbmr_tnwg_interest_rec_flags, + &ett_lbmr_tnwg_ctxinfo, + &ett_lbmr_tnwg_ctxinfo_flags1, + &ett_lbmr_tnwg_trreq, + &ett_lbmr_tnwg_ctxinst_opt, + &ett_lbmr_tnwg_ctxinst_opt_flags, + &ett_lbmr_tnwg_address_opt, + &ett_lbmr_tnwg_address_opt_flags, + &ett_lbmr_tnwg_domain_opt, + &ett_lbmr_tnwg_domain_opt_flags, + &ett_lbmr_tnwg_name_opt, + &ett_lbmr_tnwg_name_opt_flags, + &ett_lbmr_tnwg_unknown_opt, + &ett_lbmr_tnwg_unknown_opt_flags, + &ett_lbmr_remote_domain_route_hdr, + &ett_lbmr_rctxinfo, + &ett_lbmr_rctxinfo_rec, + &ett_lbmr_rctxinfo_rec_flags, + &ett_lbmr_rctxinfo_rec_address, + &ett_lbmr_rctxinfo_rec_instance, + &ett_lbmr_rctxinfo_rec_odomain, + &ett_lbmr_rctxinfo_rec_name, + &ett_lbmr_rctxinfo_rec_unknown, + &ett_qmgmt_flags, + &ett_qmgmt_il, + &ett_qmgmt_il_inst, + &ett_qmgmt_il_inst_flags, + &ett_qmgmt_ec, + &ett_qmgmt_ev, + &ett_qmgmt_qro + }; + static ei_register_info ei[] = + { + { &ei_lbmr_analysis_length_incorrect, { "lbmr.analysis.length_incorrect", PI_MALFORMED, PI_ERROR, "Header length incorrect", EXPFILL } }, + { &ei_lbmr_analysis_invalid_value, { "lbmr.analysis.invalid_value", PI_UNDECODED, PI_WARN, "Invalid value", EXPFILL } }, + { &ei_lbmr_analysis_zero_len_option, { "lbmr.analysis.zero_len_option", PI_MALFORMED, PI_ERROR, "Zero-length LBMR option", EXPFILL } }, + }; + module_t * lbmr_module; + struct in_addr addr; + uat_t * tag_uat; + expert_module_t * expert_lbmr; + + proto_lbmr = proto_register_protocol("LBM Topic Resolution Protocol", + "LBMR", "lbmr"); + + proto_register_field_array(proto_lbmr, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_lbmr = expert_register_protocol(proto_lbmr); + expert_register_field_array(expert_lbmr, ei, array_length(ei)); + + lbmr_module = prefs_register_protocol_subtree("29West", proto_lbmr, proto_reg_handoff_lbmr); + prefs_register_uint_preference(lbmr_module, + "mc_incoming_port", + "Incoming multicast UDP port (default " LBMR_DEFAULT_MC_INCOMING_UDP_PORT_STRING ")", + "Set the UDP port for incoming multicast topic resolution (context resolver_multicast_incoming_port)", + 10, + &global_lbmr_mc_incoming_udp_port); + inet_aton(LBMR_DEFAULT_MC_INCOMING_ADDRESS, &addr); + lbmr_mc_incoming_address_host = g_ntohl(addr.s_addr); + prefs_register_string_preference(lbmr_module, + "mc_incoming_address", + "Incoming multicast address (default " LBMR_DEFAULT_MC_INCOMING_ADDRESS ")", + "Set the multicast address for incoming multicast topic resolution (context resolver_multicast_incoming_address)", + &global_lbmr_mc_incoming_address); + prefs_register_uint_preference(lbmr_module, + "mc_outgoing_port", + "Outgoing multicast UDP port (default " LBMR_DEFAULT_MC_OUTGOING_UDP_PORT_STRING ")", + "Set the UDP port for outgoing multicast topic resolution (context resolver_multicast_outgoing_port)", + 10, + &global_lbmr_mc_outgoing_udp_port); + inet_aton(LBMR_DEFAULT_MC_OUTGOING_ADDRESS, &addr); + lbmr_mc_outgoing_address_host = g_ntohl(addr.s_addr); + prefs_register_string_preference(lbmr_module, + "mc_outgoing_address", + "Outgoing multicast address (default " LBMR_DEFAULT_MC_OUTGOING_ADDRESS ")", + "Set the multicast address for outgoing multicast topic resolution (context resolver_multicast_outgoing_address)", + &global_lbmr_mc_outgoing_address); + prefs_register_uint_preference(lbmr_module, + "uc_port_low", + "Unicast UDP port low (default " LBMR_DEFAULT_UC_PORT_LOW_STRING ")", + "Set the low UDP port for unicast topic resolution (context resolver_unicast_port_low)", + 10, + &global_lbmr_uc_port_low); + prefs_register_uint_preference(lbmr_module, + "uc_port_high", + "Unicast UDP port high (default " LBMR_DEFAULT_UC_PORT_HIGH_STRING ")", + "Set the high UDP port for unicast topic resolution (context resolver_unicast_port_high)", + 10, + &global_lbmr_uc_port_high); + prefs_register_uint_preference(lbmr_module, + "uc_dest_port", + "Unicast UDP destination port (default " LBMR_DEFAULT_UC_DEST_PORT_STRING ")", + "Set the destination port for unicast topic resolution (context resolver_unicast_destination_port)", + 10, + &global_lbmr_uc_dest_port); + inet_aton(LBMR_DEFAULT_UC_ADDRESS, &addr); + lbmr_uc_address_host = g_ntohl(addr.s_addr); + prefs_register_string_preference(lbmr_module, + "uc_address", + "Unicast resolver address (default " LBMR_DEFAULT_UC_ADDRESS ")", + "Set the address of the unicast resolver daemon (context resolver_unicast_address)", + &global_lbmr_uc_address); + prefs_register_bool_preference(lbmr_module, + "use_lbmr_domain", + "Use LBMR tag table", + "Use table of LBMR tags to decode the packet instead of above values", + &global_lbmr_use_tag); + tag_uat = uat_new("LBMR tag definitions", + sizeof(lbmr_tag_entry_t), + "lbmr_domains", + TRUE, + (void * *)&lbmr_tag_entry, + &lbmr_tag_count, + UAT_AFFECTS_DISSECTION, + NULL, + lbmr_tag_copy_cb, + lbmr_tag_update_cb, + lbmr_tag_free_cb, + NULL, + lbmr_tag_array); + prefs_register_uat_preference(lbmr_module, + "tnw_lbmr_tags", + "LBMR Tags", + "A table to define LBMR tags", + tag_uat); + + lbmr_tap_handle = register_tap("lbmr"); + + stats_tree_register("lbmr", + "lbmr_topic_ads_topic", + lbmr_stat_tree_name_topic_ads_topic, + 0, + lbmr_topic_ads_topic_stats_tree_packet, + lbmr_topic_ads_topic_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_topic_ads_source", + lbmr_stat_tree_name_topic_ads_source, + 0, + lbmr_topic_ads_source_stats_tree_packet, + lbmr_topic_ads_source_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_topic_ads_transport", + lbmr_stat_tree_name_topic_ads_transport, + 0, + lbmr_topic_ads_transport_stats_tree_packet, + lbmr_topic_ads_transport_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_topic_queries_topic", + lbmr_stat_tree_name_topic_queries_topic, + 0, + lbmr_topic_queries_topic_stats_tree_packet, + lbmr_topic_queries_topic_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_topic_queries_receiver", + lbmr_stat_tree_name_topic_queries_receiver, + 0, + lbmr_topic_queries_receiver_stats_tree_packet, + lbmr_topic_queries_receiver_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_topic_queries_pattern", + lbmr_stat_tree_name_topic_queries_pattern, + 0, + lbmr_topic_queries_pattern_stats_tree_packet, + lbmr_topic_queries_pattern_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_topic_queries_pattern_receiver", + lbmr_stat_tree_name_topic_queries_pattern_receiver, + 0, + lbmr_topic_queries_pattern_receiver_stats_tree_packet, + lbmr_topic_queries_pattern_receiver_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_queue_ads_queue", + lbmr_stat_tree_name_queue_ads_queue, + 0, + lbmr_queue_ads_queue_stats_tree_packet, + lbmr_queue_ads_queue_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_queue_ads_source", + lbmr_stat_tree_name_queue_ads_source, + 0, + lbmr_queue_ads_source_stats_tree_packet, + lbmr_queue_ads_source_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_queue_queries_queue", + lbmr_stat_tree_name_queue_queries_queue, + 0, + lbmr_queue_queries_queue_stats_tree_packet, + lbmr_queue_queries_queue_stats_tree_init, + NULL); + stats_tree_register("lbmr", + "lbmr_queue_queries_receiver", + lbmr_stat_tree_name_queue_queries_receiver, + 0, + lbmr_queue_queries_receiver_stats_tree_packet, + lbmr_queue_queries_receiver_stats_tree_init, + NULL); + + lbm_topic_init(); + lbtsmx_transport_init(); + lbtipc_transport_init(); + lbtrdma_transport_init(); +} + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbtrm.c b/epan/dissectors/packet-lbtrm.c new file mode 100644 index 0000000000..f712716f4b --- /dev/null +++ b/epan/dissectors/packet-lbtrm.c @@ -0,0 +1,1996 @@ +/* packet-lbtrm.c + * Routines for LBT-RM Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#if HAVE_NETINET_IN_H + #include +#else +typedef unsigned int in_addr_t; +#endif +#if HAVE_WINSOCK2_H + #include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "packet-lbm.h" +#include "packet-lbtrm.h" + +/* Protocol handle */ +static int proto_lbtrm = -1; + +/* Dissector handle */ +static dissector_handle_t lbtrm_dissector_handle; + +/* Tap handle */ +static int lbtrm_tap_handle = -1; + +/*----------------------------------------------------------------------------*/ +/* LBT-RM transport management. */ +/*----------------------------------------------------------------------------*/ + +static const address lbtrm_null_address = { AT_NONE, -1, 0, NULL }; + +static lbtrm_transport_t * lbtrm_transport_unicast_find(const address * source_address, guint16 source_port, guint32 session_id, guint32 frame) +{ + lbtrm_transport_t * transport = NULL; + conversation_t * conv = NULL; + wmem_tree_t * session_tree = NULL; + + conv = find_conversation(0, source_address, &lbtrm_null_address, PT_UDP, source_port, 0, 0); + if (conv != NULL) + { + if (frame != 0) + { + if (conv->setup_frame == 0) + { + conv->setup_frame = frame; + } + if (frame > conv->last_frame) + { + conv->last_frame = frame; + } + } + session_tree = (wmem_tree_t *) conversation_get_proto_data(conv, proto_lbtrm); + if (session_tree != NULL) + { + transport = (lbtrm_transport_t *) wmem_tree_lookup32(session_tree, session_id); + } + } + return (transport); +} + +static void lbtrm_transport_unicast_add(const address * source_address, guint16 source_port, guint32 session_id, lbtrm_transport_t * transport) +{ + conversation_t * conv = NULL; + wmem_tree_t * session_tree = NULL; + lbtrm_transport_t * transport_entry = NULL; + + conv = find_conversation(0, source_address, &lbtrm_null_address, PT_UDP, source_port, 0, 0); + if (conv == NULL) + { + conv = conversation_new(0, source_address, &lbtrm_null_address, PT_UDP, source_port, 0, 0); + } + session_tree = (wmem_tree_t *) conversation_get_proto_data(conv, proto_lbtrm); + if (session_tree == NULL) + { + session_tree = wmem_tree_new(wmem_file_scope()); + conversation_add_proto_data(conv, proto_lbtrm, (void *) session_tree); + } + transport_entry = (lbtrm_transport_t *) wmem_tree_lookup32(session_tree, session_id); + if (transport_entry == NULL) + { + wmem_tree_insert32(session_tree, session_id, (void *) transport); + } +} + +static lbtrm_transport_t * lbtrm_transport_find(const address * source_address, guint16 source_port, guint32 session_id, const address * multicast_group, guint16 dest_port, guint32 frame) +{ + lbtrm_transport_t * entry = NULL; + wmem_tree_t * session_tree = NULL; + conversation_t * conv = NULL; + + conv = find_conversation(frame, source_address, multicast_group, PT_UDP, source_port, dest_port, 0); + if (conv != NULL) + { + if (frame != 0) + { + if (conv->setup_frame == 0) + { + conv->setup_frame = frame; + } + if (frame > conv->last_frame) + { + conv->last_frame = frame; + } + } + session_tree = (wmem_tree_t *) conversation_get_proto_data(conv, proto_lbtrm); + if (session_tree != NULL) + { + entry = (lbtrm_transport_t *) wmem_tree_lookup32(session_tree, session_id); + } + } + return (entry); +} + +lbtrm_transport_t * lbtrm_transport_add(const address * source_address, guint16 source_port, guint32 session_id, const address * multicast_group, guint16 dest_port, guint32 frame) +{ + lbtrm_transport_t * entry; + conversation_t * conv = NULL; + wmem_tree_t * session_tree = NULL; + + conv = find_conversation(frame, source_address, multicast_group, PT_UDP, source_port, dest_port, 0); + if (conv == NULL) + { + conv = conversation_new(frame, source_address, multicast_group, PT_UDP, source_port, dest_port, 0); + } + if (frame != 0) + { + if (conv->setup_frame == 0) + { + conv->setup_frame = frame; + } + if (frame > conv->last_frame) + { + conv->last_frame = frame; + } + } + session_tree = (wmem_tree_t *) conversation_get_proto_data(conv, proto_lbtrm); + if (session_tree == NULL) + { + session_tree = wmem_tree_new(wmem_file_scope()); + conversation_add_proto_data(conv, proto_lbtrm, (void *) session_tree); + } + entry = (lbtrm_transport_t *) wmem_tree_lookup32(session_tree, session_id); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbtrm_transport_t); + SE_COPY_ADDRESS(&(entry->source_address), source_address); + entry->source_port = source_port; + entry->session_id = session_id; + SE_COPY_ADDRESS(&(entry->multicast_group), multicast_group); + entry->dest_port = dest_port; + entry->channel = lbm_channel_assign(LBM_CHANNEL_TRANSPORT_LBTRM); + entry->frame = wmem_tree_new(wmem_file_scope()); + entry->last_frame = NULL; + entry->last_data_frame = NULL; + entry->last_sm_frame = NULL; + entry->last_nak_frame = NULL; + entry->last_ncf_frame = NULL; + entry->data_sqn = wmem_tree_new(wmem_file_scope()); + entry->sm_sqn = wmem_tree_new(wmem_file_scope()); + entry->data_high_sqn = 0; + entry->sm_high_sqn = 0; + wmem_tree_insert32(session_tree, session_id, (void *) entry); + lbtrm_transport_unicast_add(source_address, source_port, session_id, entry); + return (entry); +} + +static lbm_transport_sqn_t * lbtrm_transport_sqn_find(lbtrm_transport_t * transport, guint8 type, guint32 sqn) +{ + lbm_transport_sqn_t * sqn_entry = NULL; + + switch (type) + { + case LBTRM_PACKET_TYPE_DATA: + sqn_entry = (lbm_transport_sqn_t *) wmem_tree_lookup32(transport->data_sqn, sqn); + break; + case LBTRM_PACKET_TYPE_SM: + sqn_entry = (lbm_transport_sqn_t *) wmem_tree_lookup32(transport->sm_sqn, sqn); + break; + case LBTRM_PACKET_TYPE_NAK: + case LBTRM_PACKET_TYPE_NCF: + default: + sqn_entry = NULL; + break; + } + return (sqn_entry); +} + +static lbm_transport_sqn_t * lbtrm_transport_sqn_add(lbtrm_transport_t * transport, lbm_transport_frame_t * frame) +{ + wmem_tree_t * sqn_list = NULL; + lbm_transport_sqn_t * sqn_entry = NULL; + + switch (frame->type) + { + case LBTRM_PACKET_TYPE_DATA: + sqn_list = transport->data_sqn; + break; + case LBTRM_PACKET_TYPE_SM: + sqn_list = transport->sm_sqn; + break; + case LBTRM_PACKET_TYPE_NAK: + case LBTRM_PACKET_TYPE_NCF: + default: + return (NULL); + break; + } + + /* Add the sqn. */ + sqn_entry = lbm_transport_sqn_add(sqn_list, frame); + return (sqn_entry); +} + +static lbm_transport_frame_t * lbtrm_transport_frame_find(lbtrm_transport_t * transport, guint32 frame) +{ + return ((lbm_transport_frame_t *) wmem_tree_lookup32(transport->frame, frame)); +} + +static lbm_transport_frame_t * lbtrm_transport_frame_add(lbtrm_transport_t * transport, guint8 type, guint32 frame, guint32 sqn, gboolean retransmission) +{ + lbm_transport_sqn_t * dup_sqn_entry = NULL; + lbm_transport_frame_t * frame_entry = NULL; + + /* Locate the frame. */ + frame_entry = lbtrm_transport_frame_find(transport, frame); + if (frame_entry != NULL) + { + return (frame_entry); + } + frame_entry = lbm_transport_frame_add(transport->frame, type, frame, sqn, retransmission); + if (transport->last_frame != NULL) + { + frame_entry->previous_frame = transport->last_frame->frame; + transport->last_frame->next_frame = frame; + } + transport->last_frame = frame_entry; + switch (type) + { + case LBTRM_PACKET_TYPE_DATA: + if (transport->last_data_frame != NULL) + { + frame_entry->previous_type_frame = transport->last_data_frame->frame; + transport->last_data_frame->next_type_frame = frame; + /* Ideally, this frame's sqn is 1 more than the highest data sqn seen */ + if (frame_entry->sqn <= transport->data_high_sqn) + { + dup_sqn_entry = lbtrm_transport_sqn_find(transport, type, frame_entry->sqn); + if (!frame_entry->retransmission) + { + /* Out of order */ + if (dup_sqn_entry != NULL) + { + frame_entry->duplicate = TRUE; + } + if (frame_entry->sqn != transport->data_high_sqn) + { + frame_entry->ooo_gap = transport->data_high_sqn - frame_entry->sqn; + } + } + } + else + { + if (!frame_entry->retransmission) + { + if (frame_entry->sqn != (transport->data_high_sqn + 1)) + { + /* Gap */ + frame_entry->sqn_gap = frame_entry->sqn - (transport->last_data_frame->sqn + 1); + } + } + } + } + if ((frame_entry->sqn > transport->data_high_sqn) && !frame_entry->retransmission) + { + transport->data_high_sqn = frame_entry->sqn; + } + transport->last_data_frame = frame_entry; + break; + case LBTRM_PACKET_TYPE_SM: + if (transport->last_sm_frame != NULL) + { + frame_entry->previous_type_frame = transport->last_sm_frame->frame; + transport->last_sm_frame->next_type_frame = frame; + /* Ideally, this frame's sqn is 1 more than the highest SM sqn seen */ + if (frame_entry->sqn <= transport->sm_high_sqn) + { + /* Out of order */ + dup_sqn_entry = lbtrm_transport_sqn_find(transport, type, frame_entry->sqn); + if (dup_sqn_entry != NULL) + { + frame_entry->duplicate = TRUE; + } + if (frame_entry->sqn != transport->sm_high_sqn) + { + frame_entry->ooo_gap = transport->sm_high_sqn - frame_entry->sqn; + } + } + else + { + if (frame_entry->sqn != (transport->sm_high_sqn + 1)) + { + /* Gap */ + frame_entry->sqn_gap = frame_entry->sqn - (transport->sm_high_sqn + 1); + } + } + } + if (frame_entry->sqn > transport->sm_high_sqn) + { + transport->sm_high_sqn = frame_entry->sqn; + } + transport->last_sm_frame = frame_entry; + break; + case LBTRM_PACKET_TYPE_NAK: + if (transport->last_nak_frame != NULL) + { + frame_entry->previous_type_frame = transport->last_nak_frame->frame; + transport->last_nak_frame->next_type_frame = frame; + } + transport->last_nak_frame = frame_entry; + break; + case LBTRM_PACKET_TYPE_NCF: + if (transport->last_ncf_frame != NULL) + { + frame_entry->previous_type_frame = transport->last_ncf_frame->frame; + transport->last_ncf_frame->next_type_frame = frame; + } + transport->last_ncf_frame = frame_entry; + break; + } + + /* Add the sqn. */ + (void)lbtrm_transport_sqn_add(transport, frame_entry); + return (frame_entry); +} + +char * lbtrm_transport_source_string(const address * source_address, guint16 source_port, guint32 session_id, const address * multicast_group, guint16 dest_port) +{ + return (wmem_strdup_printf(wmem_file_scope(), "LBTRM:%s:%" G_GUINT16_FORMAT ":%08x:%s:%" G_GUINT16_FORMAT, address_to_str(wmem_packet_scope(), source_address), source_port, session_id, + address_to_str(wmem_packet_scope(), multicast_group), dest_port)); +} + +static char * lbtrm_transport_source_string_transport(lbtrm_transport_t * transport) +{ + return (lbtrm_transport_source_string(&(transport->source_address), transport->source_port, transport->session_id, &(transport->multicast_group), transport->dest_port)); +} + +/*----------------------------------------------------------------------------*/ +/* Packet definitions. */ +/*----------------------------------------------------------------------------*/ + +/* LBT-RM main header */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t next_hdr; + lbm_uint16_t ucast_port; + lbm_uint32_t session_id; +} lbtrm_hdr_t; +#define O_LBTRM_HDR_T_VER_TYPE OFFSETOF(lbtrm_hdr_t, ver_type) +#define L_LBTRM_HDR_T_VER_TYPE SIZEOF(lbtrm_hdr_t, ver_type) +#define O_LBTRM_HDR_T_NEXT_HDR OFFSETOF(lbtrm_hdr_t, next_hdr) +#define L_LBTRM_HDR_T_NEXT_HDR SIZEOF(lbtrm_hdr_t, next_hdr) +#define O_LBTRM_HDR_T_UCAST_PORT OFFSETOF(lbtrm_hdr_t, ucast_port) +#define L_LBTRM_HDR_T_UCAST_PORT SIZEOF(lbtrm_hdr_t, ucast_port) +#define O_LBTRM_HDR_T_SESSION_ID OFFSETOF(lbtrm_hdr_t, session_id) +#define L_LBTRM_HDR_T_SESSION_ID SIZEOF(lbtrm_hdr_t, session_id) +#define L_LBTRM_HDR_T (gint) (sizeof(lbtrm_hdr_t)) + +#define LBTRM_VERSION 0x00 +#define LBTRM_HDR_VER(x) (x >> 4) +#define LBTRM_HDR_TYPE(x) (x & 0x0F) +#define LBTRM_HDR_VER_MASK 0xF0 +#define LBTRM_HDR_TYPE_MASK 0x0F + +/* LBT-RM data header */ +typedef struct +{ + lbm_uint32_t sqn; + lbm_uint32_t trail_sqn; + lbm_uint8_t flags_fec_type; + lbm_uint8_t flags_tgsz; + lbm_uint16_t fec_symbol; +} lbtrm_data_hdr_t; +#define O_LBTRM_DATA_HDR_T_SQN OFFSETOF(lbtrm_data_hdr_t, sqn) +#define L_LBTRM_DATA_HDR_T_SQN SIZEOF(lbtrm_data_hdr_t, sqn) +#define O_LBTRM_DATA_HDR_T_TRAIL_SQN OFFSETOF(lbtrm_data_hdr_t, trail_sqn) +#define L_LBTRM_DATA_HDR_T_TRAIL_SQN SIZEOF(lbtrm_data_hdr_t, trail_sqn) +#define O_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE OFFSETOF(lbtrm_data_hdr_t, flags_fec_type) +#define L_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE SIZEOF(lbtrm_data_hdr_t, flags_fec_type) +#define O_LBTRM_DATA_HDR_T_FLAGS_TGSZ OFFSETOF(lbtrm_data_hdr_t, flags_tgsz) +#define L_LBTRM_DATA_HDR_T_FLAGS_TGSZ SIZEOF(lbtrm_data_hdr_t, flags_tgsz) +#define O_LBTRM_DATA_HDR_T_FEC_SYMBOL OFFSETOF(lbtrm_data_hdr_t, fec_symbol) +#define L_LBTRM_DATA_HDR_T_FEC_SYMBOL SIZEOF(lbtrm_data_hdr_t, fec_symbol) +#define L_LBTRM_DATA_HDR_T (gint) (sizeof(lbtrm_data_hdr_t)) + +#define LBTRM_DATA_UNICAST_NAKS_FLAG 0x80 +#define LBTRM_MULTICAST_NAKS_FLAG 0x40 +#define LBTRM_DATA_RETRANSMISSION_FLAG 0x20 +#define LBTRM_LATE_JOIN_FLAG 0x10 +#define LBTRM_FEC_TYPE_MASK 0xF +#define LBTRM_DATA_FLAGS(x) (x >> 4) +#define LBTRM_DATA_FLAGS_MASK 0xF0 + +/* LBT-RM Session Message header */ +typedef struct +{ + lbm_uint32_t sm_sqn; + lbm_uint32_t lead_sqn; + lbm_uint32_t trail_sqn; + lbm_uint8_t flags_fec_type; + lbm_uint8_t flags_tgsz; + lbm_uint16_t reserved; +} lbtrm_sm_hdr_t; +#define O_LBTRM_SM_HDR_T_SM_SQN OFFSETOF(lbtrm_sm_hdr_t, sm_sqn) +#define L_LBTRM_SM_HDR_T_SM_SQN SIZEOF(lbtrm_sm_hdr_t, sm_sqn) +#define O_LBTRM_SM_HDR_T_LEAD_SQN OFFSETOF(lbtrm_sm_hdr_t, lead_sqn) +#define L_LBTRM_SM_HDR_T_LEAD_SQN SIZEOF(lbtrm_sm_hdr_t, lead_sqn) +#define O_LBTRM_SM_HDR_T_TRAIL_SQN OFFSETOF(lbtrm_sm_hdr_t, trail_sqn) +#define L_LBTRM_SM_HDR_T_TRAIL_SQN SIZEOF(lbtrm_sm_hdr_t, trail_sqn) +#define O_LBTRM_SM_HDR_T_FLAGS_FEC_TYPE OFFSETOF(lbtrm_sm_hdr_t, flags_fec_type) +#define L_LBTRM_SM_HDR_T_FLAGS_FEC_TYPE SIZEOF(lbtrm_sm_hdr_t, flags_fec_type) +#define O_LBTRM_SM_HDR_T_FLAGS_TGSZ OFFSETOF(lbtrm_sm_hdr_t, flags_tgsz) +#define L_LBTRM_SM_HDR_T_FLAGS_TGSZ SIZEOF(lbtrm_sm_hdr_t, flags_tgsz) +#define O_LBTRM_SM_HDR_T_RESERVED OFFSETOF(lbtrm_sm_hdr_t, reserved) +#define L_LBTRM_SM_HDR_T_RESERVED SIZEOF(lbtrm_sm_hdr_t, reserved) +#define L_LBTRM_SM_HDR_T (gint) (sizeof(lbtrm_sm_hdr_t)) + +#define LBTRM_SM_UNICAST_NAKS_FLAG 0x80 +#define LBTRM_SM_FLAGS(x) (x >> 4) +#define LBTRM_SM_FLAGS_MASK 0xF0 + +/* LBT-RM NAK header */ +typedef struct +{ + lbm_uint16_t num_naks; + lbm_uint16_t format; +} lbtrm_nak_hdr_t; +#define O_LBTRM_NAK_HDR_T_NUM_NAKS OFFSETOF(lbtrm_nak_hdr_t, num_naks) +#define L_LBTRM_NAK_HDR_T_NUM_NAKS SIZEOF(lbtrm_nak_hdr_t, num_naks) +#define O_LBTRM_NAK_HDR_T_FORMAT OFFSETOF(lbtrm_nak_hdr_t, format) +#define L_LBTRM_NAK_HDR_T_FORMAT SIZEOF(lbtrm_nak_hdr_t, format) +#define L_LBTRM_NAK_HDR_T (gint) (sizeof(lbtrm_nak_hdr_t)) + +#define LBTRM_NAK_SELECTIVE_FORMAT 0x0 +#define LBTRM_NAK_PARITY_FORMAT 0x1 +#define LBTRM_NAK_HDR_FORMAT(x) (x & 0xF) +#define LBTRM_NAK_HDR_FORMAT_MASK 0x0F + +/* LBT-RM NAK Confirmation */ +typedef struct +{ + lbm_uint32_t trail_sqn; + lbm_uint16_t num_ncfs; + lbm_uint8_t reserved; + lbm_uint8_t reason_format; +} lbtrm_ncf_hdr_t; +#define O_LBTRM_NCF_HDR_T_TRAIL_SQN OFFSETOF(lbtrm_ncf_hdr_t, trail_sqn) +#define L_LBTRM_NCF_HDR_T_TRAIL_SQN SIZEOF(lbtrm_ncf_hdr_t, trail_sqn) +#define O_LBTRM_NCF_HDR_T_NUM_NCFS OFFSETOF(lbtrm_ncf_hdr_t, num_ncfs) +#define L_LBTRM_NCF_HDR_T_NUM_NCFS SIZEOF(lbtrm_ncf_hdr_t, num_ncfs) +#define O_LBTRM_NCF_HDR_T_RESERVED OFFSETOF(lbtrm_ncf_hdr_t, reserved) +#define L_LBTRM_NCF_HDR_T_RESERVED SIZEOF(lbtrm_ncf_hdr_t, reserved) +#define O_LBTRM_NCF_HDR_T_REASON_FORMAT OFFSETOF(lbtrm_ncf_hdr_t, reason_format) +#define L_LBTRM_NCF_HDR_T_REASON_FORMAT SIZEOF(lbtrm_ncf_hdr_t, reason_format) +#define L_LBTRM_NCF_HDR_T (gint) (sizeof(lbtrm_ncf_hdr_t)) + +#define LBTRM_NCF_SELECTIVE_FORMAT 0x0 +#define LBTRM_NCF_PARITY_FORMAT 0x1 +#define LBTRM_NCF_HDR_REASON(x) ((x & 0xF0) >> 4) +#define LBTRM_NCF_HDR_FORMAT(x) (x & 0xF) +#define LBTRM_NCF_HDR_REASON_MASK 0xF0 +#define LBTRM_NCF_HDR_FORMAT_MASK 0x0F + +/* LBT-RM option header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t res; +} lbtrm_basic_opt_t; +#define O_LBTRM_BASIC_OPT_T_NEXT_HDR OFFSETOF(lbtrm_basic_opt_t, next_hdr) +#define L_LBTRM_BASIC_OPT_T_NEXT_HDR SIZEOF(lbtrm_basic_opt_t, next_hdr) +#define O_LBTRM_BASIC_OPT_T_HDR_LEN OFFSETOF(lbtrm_basic_opt_t, hdr_len) +#define L_LBTRM_BASIC_OPT_T_HDR_LEN SIZEOF(lbtrm_basic_opt_t, hdr_len) +#define O_LBTRM_BASIC_OPT_T_RES OFFSETOF(lbtrm_basic_opt_t, res) +#define L_LBTRM_BASIC_OPT_T_RES SIZEOF(lbtrm_basic_opt_t, res) +#define L_LBTRM_BASIC_OPT_T (gint) (sizeof(lbtrm_basic_opt_t)) + +#define LBTRM_NHDR_DATA 0x0 + +/*----------------------------------------------------------------------------*/ +/* Value translation tables. */ +/*----------------------------------------------------------------------------*/ + +static const value_string lbtrm_packet_type[] = +{ + { LBTRM_PACKET_TYPE_DATA, "DATA" }, + { LBTRM_PACKET_TYPE_SM, "SM" }, + { LBTRM_PACKET_TYPE_NAK, "NAK" }, + { LBTRM_PACKET_TYPE_NCF, "NCF" }, + { 0x0, NULL } +}; + +static const value_string lbtrm_nak_format[] = +{ + { LBTRM_NAK_SELECTIVE_FORMAT, "Selective" }, + { LBTRM_NAK_PARITY_FORMAT, "Parity" }, + { 0x0, NULL } +}; + +static const value_string lbtrm_ncf_format[] = +{ + { LBTRM_NCF_SELECTIVE_FORMAT, "Selective" }, + { LBTRM_NCF_PARITY_FORMAT, "Parity" }, + { 0x0, NULL } +}; + +static const value_string lbtrm_ncf_reason[] = +{ + { LBTRM_NCF_REASON_NO_RETRY, "Do not retry" }, + { LBTRM_NCF_REASON_IGNORED, "NAK Ignored" }, + { LBTRM_NCF_REASON_RX_DELAY, "Retransmit Delay" }, + { LBTRM_NCF_REASON_SHED, "NAK Shed" }, + { 0x0, NULL } +}; + +static const value_string lbtrm_next_header[] = +{ + { LBTRM_NHDR_DATA, "Data" }, + { 0x0, NULL } +}; + +/*----------------------------------------------------------------------------*/ +/* Preferences. */ +/*----------------------------------------------------------------------------*/ + +/* Preferences default values. */ +#define LBTRM_DEFAULT_DPORT_LOW 14400 +#define LBTRM_DEFAULT_DPORT_HIGH 14400 +#define LBTRM_DEFAULT_SPORT_HIGH 14399 +#define LBTRM_DEFAULT_SPORT_LOW 14390 +#define LBTRM_DEFAULT_MC_ADDRESS_LOW "224.10.10.10" +#define LBTRM_DEFAULT_MC_ADDRESS_HIGH "224.10.10.14" +#define MIM_DEFAULT_INCOMING_DPORT 14401 +#define MIM_DEFAULT_OUTGOING_DPORT 14401 +#define MIM_DEFAULT_MC_INCOMING_ADDRESS "224.10.10.21" +#define MIM_DEFAULT_MC_OUTGOING_ADDRESS "224.10.10.21" + +/* Global preferences variables (altered by the preferences dialog). */ +static const char * global_lbtrm_mc_address_low = LBTRM_DEFAULT_MC_ADDRESS_LOW; +static const char * global_lbtrm_mc_address_high = LBTRM_DEFAULT_MC_ADDRESS_HIGH; +static guint32 global_lbtrm_dest_port_low = LBTRM_DEFAULT_DPORT_LOW; +static guint32 global_lbtrm_dest_port_high = LBTRM_DEFAULT_DPORT_HIGH; +static guint32 global_lbtrm_src_port_low = LBTRM_DEFAULT_SPORT_LOW; +static guint32 global_lbtrm_src_port_high = LBTRM_DEFAULT_SPORT_HIGH; +static guint32 global_mim_incoming_dest_port = MIM_DEFAULT_INCOMING_DPORT; +static guint32 global_mim_outgoing_dest_port = MIM_DEFAULT_OUTGOING_DPORT; +static const char * global_mim_incoming_mc_address = MIM_DEFAULT_MC_INCOMING_ADDRESS; +static const char * global_mim_outgoing_mc_address = MIM_DEFAULT_MC_OUTGOING_ADDRESS; +static gboolean global_lbtrm_expert_separate_naks = FALSE; +static gboolean global_lbtrm_expert_separate_ncfs = FALSE; +static gboolean global_lbtrm_use_tag = FALSE; +static gboolean global_lbtrm_sequence_analysis = FALSE; + +/* Local preferences variables (used by the dissector). */ +static guint32 lbtrm_mc_address_low_host = 0; +static guint32 lbtrm_mc_address_high_host = 0; +static guint32 lbtrm_dest_port_low = LBTRM_DEFAULT_DPORT_LOW; +static guint32 lbtrm_dest_port_high = LBTRM_DEFAULT_DPORT_HIGH; +static guint32 lbtrm_src_port_low = LBTRM_DEFAULT_SPORT_LOW; +static guint32 lbtrm_src_port_high = LBTRM_DEFAULT_SPORT_HIGH; +static guint32 mim_incoming_dest_port = MIM_DEFAULT_INCOMING_DPORT; +static guint32 mim_outgoing_dest_port = MIM_DEFAULT_OUTGOING_DPORT; +static guint32 mim_incoming_mc_address_host = 0; +static guint32 mim_outgoing_mc_address_host = 0; +static gboolean lbtrm_expert_separate_naks = FALSE; +static gboolean lbtrm_expert_separate_ncfs = FALSE; +static gboolean lbtrm_use_tag = FALSE; +static gboolean lbtrm_sequence_analysis = FALSE; + +/*----------------------------------------------------------------------------*/ +/* Tag management. */ +/*----------------------------------------------------------------------------*/ +typedef struct +{ + char * name; + char * mc_address_low; + guint32 mc_address_low_val_h; + char * mc_address_high; + guint32 mc_address_high_val_h; + guint32 dport_low; + guint32 dport_high; + guint32 sport_low; + guint32 sport_high; + guint32 mim_incoming_dport; + guint32 mim_outgoing_dport; + char * mim_mc_incoming_address; + guint32 mim_mc_incoming_address_val_h; + char * mim_mc_outgoing_address; + guint32 mim_mc_outgoing_address_val_h; +} lbtrm_tag_entry_t; + +static lbtrm_tag_entry_t * lbtrm_tag_entry = NULL; +static guint lbtrm_tag_count = 0; + +UAT_CSTRING_CB_DEF(lbtrm_tag, name, lbtrm_tag_entry_t) +UAT_IPV4_MC_CB_DEF(lbtrm_tag, mc_address_low, lbtrm_tag_entry_t) +UAT_IPV4_MC_CB_DEF(lbtrm_tag, mc_address_high, lbtrm_tag_entry_t) +UAT_DEC_CB_DEF(lbtrm_tag, dport_low, lbtrm_tag_entry_t) +UAT_DEC_CB_DEF(lbtrm_tag, dport_high, lbtrm_tag_entry_t) +UAT_DEC_CB_DEF(lbtrm_tag, sport_low, lbtrm_tag_entry_t) +UAT_DEC_CB_DEF(lbtrm_tag, sport_high, lbtrm_tag_entry_t) +UAT_DEC_CB_DEF(lbtrm_tag, mim_incoming_dport, lbtrm_tag_entry_t) +UAT_DEC_CB_DEF(lbtrm_tag, mim_outgoing_dport, lbtrm_tag_entry_t) +UAT_IPV4_MC_CB_DEF(lbtrm_tag, mim_mc_incoming_address, lbtrm_tag_entry_t) +UAT_IPV4_MC_CB_DEF(lbtrm_tag, mim_mc_outgoing_address, lbtrm_tag_entry_t) +static uat_field_t lbtrm_tag_array[] = +{ + UAT_FLD_CSTRING(lbtrm_tag, name, "Tag name", "Tag name"), + UAT_FLD_IPV4_MC(lbtrm_tag, mc_address_low, "Multicast address low", "Multicast address low"), + UAT_FLD_IPV4_MC(lbtrm_tag, mc_address_high, "Multicast address high", "Multicast address high"), + UAT_FLD_DEC(lbtrm_tag, dport_low, "Destination port low", "Destination port low"), + UAT_FLD_DEC(lbtrm_tag, dport_high, "Destination port high", "Destination port high"), + UAT_FLD_DEC(lbtrm_tag, sport_low, "Source port low", "Source port low"), + UAT_FLD_DEC(lbtrm_tag, sport_high, "Source port high", "Source port high"), + UAT_FLD_DEC(lbtrm_tag, mim_incoming_dport, "MIM incoming destination port", "MIM incoming destination port"), + UAT_FLD_DEC(lbtrm_tag, mim_outgoing_dport, "MIM outgoing destination port", "MIM outgoing destination port"), + UAT_FLD_IPV4_MC(lbtrm_tag, mim_mc_incoming_address, "MIM incoming multicast address", "MIM incoming multicast address"), + UAT_FLD_IPV4_MC(lbtrm_tag, mim_mc_outgoing_address, "MIM outgoing multicast address", "MIM outgoing multicast address"), + UAT_END_FIELDS +}; + +/*----------------------------------------------------------------------------*/ +/* UAT callback functions. */ +/*----------------------------------------------------------------------------*/ +static void lbtrm_tag_update_cb(void * record, const char * * error_string) +{ + lbtrm_tag_entry_t * tag = (lbtrm_tag_entry_t *)record; + + if (tag->name == NULL) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + else + { + g_strstrip(tag->name); + if (tag->name[0] == 0) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + } +} + +static void * lbtrm_tag_copy_cb(void * destination, const void * source, size_t length _U_) +{ + const lbtrm_tag_entry_t * src = (const lbtrm_tag_entry_t *)source; + lbtrm_tag_entry_t * dest = (lbtrm_tag_entry_t *)destination; + + dest->name = g_strdup(src->name); + dest->mc_address_low = g_strdup(src->mc_address_low); + dest->mc_address_low_val_h = src->mc_address_low_val_h; + dest->mc_address_high = g_strdup(src->mc_address_high); + dest->mc_address_high_val_h = src->mc_address_high_val_h; + dest->dport_low = src->dport_low; + dest->dport_high = src->dport_high; + dest->sport_low = src->sport_low; + dest->sport_high = src->sport_high; + dest->mim_incoming_dport = src->mim_incoming_dport; + dest->mim_outgoing_dport = src->mim_outgoing_dport; + dest->mim_mc_incoming_address = g_strdup(src->mim_mc_incoming_address); + dest->mim_mc_incoming_address_val_h = src->mim_mc_incoming_address_val_h; + dest->mim_mc_outgoing_address = g_strdup(src->mim_mc_outgoing_address); + dest->mim_mc_outgoing_address_val_h = src->mim_mc_outgoing_address_val_h; + return (dest); +} + +static void lbtrm_tag_free_cb(void * record) +{ + lbtrm_tag_entry_t * tag = (lbtrm_tag_entry_t *)record; + + if (tag->name != NULL) + { + g_free(tag->name); + tag->name = NULL; + } + if (tag->mc_address_low != NULL) + { + g_free(tag->mc_address_low); + tag->mc_address_low = NULL; + } + if (tag->mc_address_high != NULL) + { + g_free(tag->mc_address_high); + tag->mc_address_high = NULL; + } + if (tag->mim_mc_incoming_address != NULL) + { + g_free(tag->mim_mc_incoming_address); + tag->mim_mc_incoming_address = NULL; + } + if (tag->mim_mc_outgoing_address != NULL) + { + g_free(tag->mim_mc_outgoing_address); + tag->mim_mc_outgoing_address = NULL; + } +} + +static char * lbtrm_tag_find(packet_info * pinfo) +{ + guint idx; + lbtrm_tag_entry_t * tag = NULL; + in_addr_t dest_addr; + in_addr_t dest_addr_h; + + if (!lbtrm_use_tag) + { + return (NULL); + } + + dest_addr = *((in_addr_t *)pinfo->dst.data); + dest_addr_h = g_ntohl(dest_addr); + for (idx = 0; idx < lbtrm_tag_count; ++idx) + { + tag = &(lbtrm_tag_entry[idx]); + /* Is the destination a multicast address? */ + if (IN_MULTICAST(dest_addr_h)) + { + /* Check the MC address. */ + if ((dest_addr_h >= tag->mc_address_low_val_h) && (dest_addr_h <= tag->mc_address_high_val_h)) + { + /* It's in the LBT-RM multicast range. Check the ports. */ + if ((pinfo->destport >= tag->dport_low) && (pinfo->destport <= tag->dport_high)) + { + /* Must be one of ours. */ + return (tag->name); + } + } + else if ((dest_addr_h == tag->mim_mc_incoming_address_val_h) || (dest_addr_h == tag->mim_mc_outgoing_address_val_h)) + { + /* Might be MIM. Check the port. */ + if (((dest_addr_h == tag->mim_mc_incoming_address_val_h) && (pinfo->destport == tag->mim_incoming_dport)) + || ((dest_addr_h == tag->mim_mc_outgoing_address_val_h) && (pinfo->destport == tag->mim_outgoing_dport))) + { + /* Must be one of ours. */ + return (tag->name); + } + } + /* Not ours. */ + continue; + } + else + { + /* Not multicast, might be a unicast UDP NAK. Check the destination port. */ + if ((pinfo->destport < tag->sport_low) || (pinfo->destport > tag->sport_high)) + { + /* Wrong port. */ + continue; + } + /* One of ours, so handle it. */ + return (tag->name); + } + } + /* Not one of ours. */ + return (NULL); +} + +/*----------------------------------------------------------------------------*/ +/* Handles of all types. */ +/*----------------------------------------------------------------------------*/ + +/* Dissector tree handles */ +static gint ett_lbtrm = -1; +static gint ett_lbtrm_hdr = -1; +static gint ett_lbtrm_hdr_ver_type = -1; +static gint ett_lbtrm_data = -1; +static gint ett_lbtrm_data_flags_fec_type = -1; +static gint ett_lbtrm_sm = -1; +static gint ett_lbtrm_sm_flags_fec_type = -1; +static gint ett_lbtrm_nak = -1; +static gint ett_lbtrm_nak_list = -1; +static gint ett_lbtrm_ncf = -1; +static gint ett_lbtrm_ncf_reason_format = -1; +static gint ett_lbtrm_ncf_list = -1; +static gint ett_lbtrm_transport = -1; +static gint ett_lbtrm_transport_sqn = -1; + +/* Dissector field handles */ +static int hf_lbtrm_channel = -1; +static int hf_lbtrm_tag = -1; +static int hf_lbtrm_hdr = -1; +static int hf_lbtrm_hdr_ver_type = -1; +static int hf_lbtrm_hdr_ver_type_ver = -1; +static int hf_lbtrm_hdr_ver_type_type = -1; +static int hf_lbtrm_hdr_next_hdr = -1; +static int hf_lbtrm_hdr_ucast_port = -1; +static int hf_lbtrm_hdr_session_id = -1; +static int hf_lbtrm_data = -1; +static int hf_lbtrm_data_sqn = -1; +static int hf_lbtrm_data_trail_sqn = -1; +static int hf_lbtrm_data_flags_fec_type = -1; +static int hf_lbtrm_data_flags_fec_type_ucast_naks = -1; +static int hf_lbtrm_data_flags_fec_type_rx = -1; +static int hf_lbtrm_data_flags_tgsz = -1; +static int hf_lbtrm_data_fec_symbol = -1; +static int hf_lbtrm_sm = -1; +static int hf_lbtrm_sm_sm_sqn = -1; +static int hf_lbtrm_sm_lead_sqn = -1; +static int hf_lbtrm_sm_trail_sqn = -1; +static int hf_lbtrm_sm_flags_fec_type = -1; +static int hf_lbtrm_sm_flags_fec_type_ucast_naks = -1; +static int hf_lbtrm_sm_flags_tgsz = -1; +static int hf_lbtrm_sm_reserved = -1; +static int hf_lbtrm_nak = -1; +static int hf_lbtrm_nak_num_naks = -1; +static int hf_lbtrm_nak_format = -1; +static int hf_lbtrm_nak_naks = -1; +static int hf_lbtrm_nak_nak = -1; +static int hf_lbtrm_ncf = -1; +static int hf_lbtrm_ncf_trail_sqn = -1; +static int hf_lbtrm_ncf_num_ncfs = -1; +static int hf_lbtrm_ncf_reserved = -1; +static int hf_lbtrm_ncf_reason_format = -1; +static int hf_lbtrm_ncf_reason_format_reason = -1; +static int hf_lbtrm_ncf_reason_format_format = -1; +static int hf_lbtrm_ncf_ncfs = -1; +static int hf_lbtrm_ncf_ncf = -1; +static int hf_lbtrm_analysis = -1; +static int hf_lbtrm_analysis_prev_frame = -1; +static int hf_lbtrm_analysis_prev_data_frame = -1; +static int hf_lbtrm_analysis_prev_sm_frame = -1; +static int hf_lbtrm_analysis_prev_nak_frame = -1; +static int hf_lbtrm_analysis_prev_ncf_frame = -1; +static int hf_lbtrm_analysis_next_frame = -1; +static int hf_lbtrm_analysis_next_data_frame = -1; +static int hf_lbtrm_analysis_next_sm_frame = -1; +static int hf_lbtrm_analysis_next_nak_frame = -1; +static int hf_lbtrm_analysis_next_ncf_frame = -1; +static int hf_lbtrm_analysis_sqn = -1; +static int hf_lbtrm_analysis_sqn_frame = -1; +static int hf_lbtrm_analysis_data_retransmission = -1; +static int hf_lbtrm_analysis_data_sqn_gap = -1; +static int hf_lbtrm_analysis_data_ooo_gap = -1; +static int hf_lbtrm_analysis_data_duplicate = -1; +static int hf_lbtrm_analysis_sm_sqn_gap = -1; +static int hf_lbtrm_analysis_sm_ooo_gap = -1; +static int hf_lbtrm_analysis_sm_duplicate = -1; + +/* Expert info handles */ +static expert_field ei_lbtrm_analysis_ncf = EI_INIT; +static expert_field ei_lbtrm_analysis_ncf_ncf = EI_INIT; +static expert_field ei_lbtrm_analysis_nak = EI_INIT; +static expert_field ei_lbtrm_analysis_nak_nak = EI_INIT; +static expert_field ei_lbtrm_analysis_sm = EI_INIT; +static expert_field ei_lbtrm_analysis_rx = EI_INIT; +static expert_field ei_lbtrm_analysis_invalid_value = EI_INIT; +static expert_field ei_lbtrm_analysis_data_rx = EI_INIT; +static expert_field ei_lbtrm_analysis_data_gap = EI_INIT; +static expert_field ei_lbtrm_analysis_data_ooo = EI_INIT; +static expert_field ei_lbtrm_analysis_data_dup = EI_INIT; +static expert_field ei_lbtrm_analysis_sm_gap = EI_INIT; +static expert_field ei_lbtrm_analysis_sm_ooo = EI_INIT; +static expert_field ei_lbtrm_analysis_sm_dup = EI_INIT; + +/*----------------------------------------------------------------------------*/ +/* LBT-RM data payload dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtrm_data_contents(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, const char * tag_name, guint64 channel) +{ + tvbuff_t * next_tvb; + + next_tvb = tvb_new_subset(tvb, offset, -1, -1); + return (lbmc_dissect_lbmc_packet(next_tvb, 0, pinfo, tree, tag_name, channel)); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RM NAK confirmation packet dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtrm_ncf_list(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, int ncf_count, int reason, lbm_lbtrm_tap_info_t * tap_info) +{ + proto_tree * ncf_tree = NULL; + proto_item * ncf_item = NULL; + lbm_uint32_t ncf; + int idx = 0; + int len = 0; + + ncf_item = proto_tree_add_item(tree, hf_lbtrm_ncf_ncfs, tvb, offset + len, (int)(sizeof(lbm_uint32_t) * ncf_count), ENC_NA); + ncf_tree = proto_item_add_subtree(ncf_item, ett_lbtrm_ncf_list); + + for (idx = 0; idx < ncf_count; idx++) + { + proto_item * sep_ncf_item = NULL; + + ncf = tvb_get_ntohl(tvb, offset + len); + sep_ncf_item = proto_tree_add_item(ncf_tree, hf_lbtrm_ncf_ncf, tvb, offset + len, sizeof(lbm_uint32_t), ENC_BIG_ENDIAN); + if (lbtrm_expert_separate_ncfs) + { + expert_add_info_format(pinfo, sep_ncf_item, &ei_lbtrm_analysis_ncf_ncf, "NCF 0x%08x %s", ncf, val_to_str(reason, lbtrm_ncf_reason, "Unknown (0x%02x)")); + } + if (tap_info != NULL) + { + tap_info->sqns[idx] = ncf; + } + len += 4; + } + return (len); +} + +static int dissect_lbtrm_ncf(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, lbm_lbtrm_tap_info_t * tap_info) +{ + int len = 0; + guint16 num_ncfs; + guint8 reason; + proto_tree * ncf_tree = NULL; + proto_item * ncf_item = NULL; + proto_tree * rf_tree = NULL; + proto_item * rf_item = NULL; + proto_item * reason_item = NULL; + + ncf_item = proto_tree_add_item(tree, hf_lbtrm_ncf, tvb, offset, -1, ENC_NA); + ncf_tree = proto_item_add_subtree(ncf_item, ett_lbtrm_ncf); + num_ncfs = tvb_get_ntohs(tvb, offset + O_LBTRM_NCF_HDR_T_NUM_NCFS); + reason = tvb_get_guint8(tvb, offset + O_LBTRM_NCF_HDR_T_REASON_FORMAT); + proto_tree_add_item(ncf_tree, hf_lbtrm_ncf_trail_sqn, tvb, offset + O_LBTRM_NCF_HDR_T_TRAIL_SQN, L_LBTRM_NCF_HDR_T_TRAIL_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(ncf_tree, hf_lbtrm_ncf_num_ncfs, tvb, offset + O_LBTRM_NCF_HDR_T_NUM_NCFS, L_LBTRM_NCF_HDR_T_NUM_NCFS, ENC_BIG_ENDIAN); + proto_tree_add_item(ncf_tree, hf_lbtrm_ncf_reserved, tvb, offset + O_LBTRM_NCF_HDR_T_RESERVED, L_LBTRM_NCF_HDR_T_RESERVED, ENC_BIG_ENDIAN); + rf_item = proto_tree_add_none_format(ncf_tree, hf_lbtrm_ncf_reason_format, tvb, O_LBTRM_NCF_HDR_T_REASON_FORMAT, L_LBTRM_NCF_HDR_T_REASON_FORMAT, + "Reason/Format: %s/%s", val_to_str(LBTRM_NCF_HDR_REASON(reason), lbtrm_ncf_reason, "Unknown (0x%02x)"), + val_to_str(LBTRM_NCF_HDR_FORMAT(reason), lbtrm_ncf_format, "Unknown (0x%02x)")); + rf_tree = proto_item_add_subtree(rf_item, ett_lbtrm_ncf_reason_format); + reason_item = proto_tree_add_item(rf_tree, hf_lbtrm_ncf_reason_format_reason, tvb, offset + O_LBTRM_NCF_HDR_T_REASON_FORMAT, L_LBTRM_NCF_HDR_T_REASON_FORMAT, ENC_BIG_ENDIAN); + proto_tree_add_item(rf_tree, hf_lbtrm_ncf_reason_format_format, tvb, offset + O_LBTRM_NCF_HDR_T_REASON_FORMAT, L_LBTRM_NCF_HDR_T_REASON_FORMAT, ENC_BIG_ENDIAN); + len = L_LBTRM_NCF_HDR_T; + if (!lbtrm_expert_separate_ncfs) + { + expert_add_info_format(pinfo, reason_item, &ei_lbtrm_analysis_ncf, "NCF %s", val_to_str(LBTRM_NCF_HDR_REASON(reason), lbtrm_ncf_reason, "Unknown (0x%02x)")); + } + if (tap_info != NULL) + { + tap_info->ncf_reason = LBTRM_NCF_HDR_REASON(reason); + tap_info->num_sqns = num_ncfs; + tap_info->sqns = wmem_alloc_array(wmem_file_scope(), guint32, num_ncfs); + } + len += dissect_lbtrm_ncf_list(tvb, offset + len, pinfo, ncf_tree, num_ncfs, LBTRM_NCF_HDR_REASON(reason), tap_info); + proto_item_set_len(ncf_item, len); + return (len); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RM NAK packet dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtrm_nak_list(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, int nak_count, lbm_lbtrm_tap_info_t * tap_info) +{ + proto_tree * nak_tree = NULL; + proto_item * nak_item = NULL; + lbm_uint32_t nak; + int idx = 0; + int len = 0; + + nak_item = proto_tree_add_item(tree, hf_lbtrm_nak_naks, tvb, offset + len, (int)(sizeof(lbm_uint32_t) * nak_count), ENC_NA); + nak_tree = proto_item_add_subtree(nak_item, ett_lbtrm_nak_list); + + for (idx = 0; idx < nak_count; idx++) + { + proto_item * sep_nak_item = NULL; + + nak = tvb_get_ntohl(tvb, offset + len); + sep_nak_item = proto_tree_add_item(nak_tree, hf_lbtrm_nak_nak, tvb, offset + len, sizeof(lbm_uint32_t), ENC_BIG_ENDIAN); + if (lbtrm_expert_separate_naks) + { + expert_add_info_format(pinfo, sep_nak_item, &ei_lbtrm_analysis_nak_nak, "NAK 0x%08x", nak); + } + if (tap_info != NULL) + { + tap_info->sqns[idx] = nak; + } + len += 4; + } + return (len); +} + +static int dissect_lbtrm_nak(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, lbm_lbtrm_tap_info_t * tap_info) +{ + int len = 0; + guint16 num_naks; + proto_tree * nak_tree = NULL; + proto_item * nak_item = NULL; + + nak_item = proto_tree_add_item(tree, hf_lbtrm_nak, tvb, offset, -1, ENC_NA); + nak_tree = proto_item_add_subtree(nak_item, ett_lbtrm_nak); + num_naks = tvb_get_ntohs(tvb, offset + O_LBTRM_NAK_HDR_T_NUM_NAKS); + proto_tree_add_item(nak_tree, hf_lbtrm_nak_num_naks, tvb, offset + O_LBTRM_NAK_HDR_T_NUM_NAKS, L_LBTRM_NAK_HDR_T_NUM_NAKS, ENC_BIG_ENDIAN); + proto_tree_add_item(nak_tree, hf_lbtrm_nak_format, tvb, offset + O_LBTRM_NAK_HDR_T_FORMAT, L_LBTRM_NAK_HDR_T_FORMAT, ENC_BIG_ENDIAN); + len = L_LBTRM_NAK_HDR_T; + if (!lbtrm_expert_separate_naks) + { + expert_add_info(pinfo, nak_item, &ei_lbtrm_analysis_nak); + } + if (tap_info != NULL) + { + tap_info->num_sqns = num_naks; + tap_info->sqns = wmem_alloc_array(wmem_file_scope(), guint32, num_naks); + } + len += dissect_lbtrm_nak_list(tvb, offset + len, pinfo, nak_tree, num_naks, tap_info); + proto_item_set_len(nak_item, len); + return (len); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RM session message packet dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtrm_sm(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, guint32 * sequence, lbm_lbtrm_tap_info_t * tap_info) +{ + proto_tree * sm_tree = NULL; + proto_item * sm_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + proto_item * sm_sqn_item = NULL; + guint8 flags; + guint32 sqn; + + sm_item = proto_tree_add_item(tree, hf_lbtrm_sm, tvb, offset, L_LBTRM_SM_HDR_T, ENC_NA); + sm_tree = proto_item_add_subtree(sm_item, ett_lbtrm_sm); + sm_sqn_item = proto_tree_add_item(sm_tree, hf_lbtrm_sm_sm_sqn, tvb, offset + O_LBTRM_SM_HDR_T_SM_SQN, L_LBTRM_SM_HDR_T_SM_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(sm_tree, hf_lbtrm_sm_lead_sqn, tvb, offset + O_LBTRM_SM_HDR_T_LEAD_SQN, L_LBTRM_SM_HDR_T_LEAD_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(sm_tree, hf_lbtrm_sm_trail_sqn, tvb, offset + O_LBTRM_SM_HDR_T_TRAIL_SQN, L_LBTRM_SM_HDR_T_TRAIL_SQN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBTRM_SM_HDR_T_FLAGS_FEC_TYPE); + flags_item = proto_tree_add_none_format(sm_tree, hf_lbtrm_sm_flags_fec_type, tvb, offset + O_LBTRM_SM_HDR_T_FLAGS_FEC_TYPE, L_LBTRM_SM_HDR_T_FLAGS_FEC_TYPE, + "FEC Flags: 0x%02x", flags); + flags_tree = proto_item_add_subtree(flags_item, ett_lbtrm_sm_flags_fec_type); + proto_tree_add_item(flags_tree, hf_lbtrm_sm_flags_fec_type_ucast_naks, tvb, offset + O_LBTRM_SM_HDR_T_FLAGS_FEC_TYPE, L_LBTRM_SM_HDR_T_FLAGS_FEC_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(sm_tree, hf_lbtrm_sm_flags_tgsz, tvb, offset + O_LBTRM_SM_HDR_T_FLAGS_TGSZ, L_LBTRM_SM_HDR_T_FLAGS_TGSZ, ENC_BIG_ENDIAN); + proto_tree_add_item(sm_tree, hf_lbtrm_sm_reserved, tvb, offset + O_LBTRM_SM_HDR_T_RESERVED, L_LBTRM_SM_HDR_T_RESERVED, ENC_BIG_ENDIAN); + sqn = tvb_get_ntohl(tvb, offset + O_LBTRM_SM_HDR_T_SM_SQN); + expert_add_info(pinfo, sm_sqn_item, &ei_lbtrm_analysis_sm); + if (sequence != NULL) + { + *sequence = sqn; + } + if (tap_info != NULL) + { + tap_info->sqn = sqn; + } + return (L_LBTRM_SM_HDR_T); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RM data packet dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtrm_data(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, guint32 * sequence, gboolean * retransmission, lbm_lbtrm_tap_info_t * tap_info) +{ + proto_tree * data_tree = NULL; + proto_item * data_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * flags_item = NULL; + proto_item * sqn_item = NULL; + guint8 flags; + guint32 sqn; + + data_item = proto_tree_add_item(tree, hf_lbtrm_data, tvb, offset, L_LBTRM_DATA_HDR_T, ENC_NA); + data_tree = proto_item_add_subtree(data_item, ett_lbtrm_data); + sqn_item = proto_tree_add_item(data_tree, hf_lbtrm_data_sqn, tvb, offset + O_LBTRM_DATA_HDR_T_SQN, L_LBTRM_DATA_HDR_T_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(data_tree, hf_lbtrm_data_trail_sqn, tvb, offset + O_LBTRM_DATA_HDR_T_TRAIL_SQN, L_LBTRM_DATA_HDR_T_TRAIL_SQN, ENC_BIG_ENDIAN); + flags = tvb_get_guint8(tvb, offset + O_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE); + flags_item = proto_tree_add_none_format(data_tree, hf_lbtrm_data_flags_fec_type, tvb, offset + O_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE, L_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE, + "FEC Flags: 0x%02x", LBTRM_DATA_FLAGS(flags)); + flags_tree = proto_item_add_subtree(flags_item, ett_lbtrm_data_flags_fec_type); + proto_tree_add_item(flags_tree, hf_lbtrm_data_flags_fec_type_ucast_naks, tvb, offset + O_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE, L_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(flags_tree, hf_lbtrm_data_flags_fec_type_rx, tvb, offset + O_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE, L_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE, ENC_BIG_ENDIAN); + proto_tree_add_item(data_tree, hf_lbtrm_data_flags_tgsz, tvb, offset + O_LBTRM_DATA_HDR_T_FLAGS_TGSZ, L_LBTRM_DATA_HDR_T_FLAGS_TGSZ, ENC_BIG_ENDIAN); + proto_tree_add_item(data_tree, hf_lbtrm_data_fec_symbol, tvb, offset + O_LBTRM_DATA_HDR_T_FEC_SYMBOL, L_LBTRM_DATA_HDR_T_FEC_SYMBOL, ENC_BIG_ENDIAN); + sqn = tvb_get_ntohl(tvb, offset + O_LBTRM_DATA_HDR_T_SQN); + if (sequence != NULL) + { + *sequence = sqn; + } + if (retransmission != NULL) + { + *retransmission = FALSE; + } + if ((flags & LBTRM_DATA_RETRANSMISSION_FLAG) != 0) + { + expert_add_info_format(pinfo, sqn_item, &ei_lbtrm_analysis_rx, "RX 0x%08x", sqn); + if (retransmission != NULL) + { + *retransmission = TRUE; + } + if (tap_info != NULL) + { + tap_info->retransmission = TRUE; + } + } + if (tap_info != NULL) + { + tap_info->sqn = sqn; + } + return (L_LBTRM_DATA_HDR_T); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RM packet dissector. */ +/*----------------------------------------------------------------------------*/ +typedef struct +{ + proto_tree * tree; + tvbuff_t * tvb; + guint32 current_frame; +} lbtrm_sqn_frame_list_callback_data_t; + +static gboolean dissect_lbtrm_sqn_frame_list_callback(void * frame, void * user_data) +{ + lbtrm_sqn_frame_list_callback_data_t * cb_data = (lbtrm_sqn_frame_list_callback_data_t *) user_data; + proto_item * transport_item = NULL; + lbm_transport_sqn_frame_t * sqn_frame = (lbm_transport_sqn_frame_t *) frame; + + if (sqn_frame->frame != cb_data->current_frame) + { + if (sqn_frame->retransmission) + { + transport_item = proto_tree_add_uint_format_value(cb_data->tree, hf_lbtrm_analysis_sqn_frame, cb_data->tvb, 0, 0, sqn_frame->frame, "%" G_GUINT32_FORMAT " (RX)", sqn_frame->frame); + } + else + { + transport_item = proto_tree_add_uint(cb_data->tree, hf_lbtrm_analysis_sqn_frame, cb_data->tvb, 0, 0, sqn_frame->frame); + } + PROTO_ITEM_SET_GENERATED(transport_item); + } + return (FALSE); +} + +static int dissect_lbtrm(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * user_data _U_) +{ + proto_tree * lbtrm_tree = NULL; + proto_item * lbtrm_item; + int offset = 0; + guint8 next_hdr = 0; + char * tag_name = NULL; + int dissected_len = 0; + int total_dissected_len = 0; + proto_tree * hdr_tree = NULL; + proto_item * hdr_item = NULL; + proto_tree * ver_type_tree = NULL; + proto_item * ver_type_item = NULL; + guint16 src_port = 0; + guint32 session_id = 0; + guint16 dest_port = 0; + lbtrm_transport_t * transport = NULL; + proto_tree * transport_tree = NULL; + proto_item * transport_item = NULL; + guint32 sequence = 0; + gboolean retransmission = FALSE; + guint8 packet_type = 0; + guint64 channel = LBM_CHANNEL_NO_CHANNEL; + guint8 ver_type = 0; + guint8 flags_fec_type = 0; + guint16 num_naks = 0; + guint16 num_ncfs = 0; + lbm_lbtrm_tap_info_t * tapinfo = NULL; + proto_item * header_type_item = NULL; + + col_add_str(pinfo->cinfo, COL_PROTOCOL, "LBT-RM"); + col_clear(pinfo->cinfo, COL_INFO); + if (lbtrm_use_tag) + { + tag_name = lbtrm_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); + + ver_type = tvb_get_guint8(tvb, O_LBTRM_HDR_T_VER_TYPE); + packet_type = LBTRM_HDR_TYPE(ver_type); + next_hdr = tvb_get_guint8(tvb, O_LBTRM_HDR_T_NEXT_HDR); + src_port = tvb_get_ntohs(tvb, O_LBTRM_HDR_T_UCAST_PORT); + session_id = tvb_get_ntohl(tvb, O_LBTRM_HDR_T_SESSION_ID); + if (tag_name != NULL) + { + lbtrm_item = proto_tree_add_protocol_format(tree, proto_lbtrm, tvb, offset, -1, "LBT-RM Protocol (Tag: %s): Version %u, Type %s: Source Unicast Port %" G_GUINT16_FORMAT ", Session ID 0x%08x", + tag_name, LBTRM_HDR_VER(ver_type), val_to_str(packet_type, lbtrm_packet_type, "Unknown (0x%02x)"), + src_port, session_id); + } + else + { + lbtrm_item = proto_tree_add_protocol_format(tree, proto_lbtrm, tvb, offset, -1, "LBT-RM Protocol: Version %u, Type %s: Source Unicast Port %" G_GUINT16_FORMAT ", Session ID 0x%08x", + LBTRM_HDR_VER(ver_type), val_to_str(packet_type, lbtrm_packet_type, "Unknown (0x%02x)"), + src_port, session_id); + } + lbtrm_tree = proto_item_add_subtree(lbtrm_item, ett_lbtrm); + + /* Addresses are in network order, ports in host order. */ + dest_port = pinfo->destport; + + if (PINFO_FD_VISITED(pinfo) == 0) + { + /* First time through - add the info. */ + /* Note that this won't handle the case when a NAK occurs in the capture before any other packets for that transport. Oh well. */ + if (packet_type == LBTRM_PACKET_TYPE_NAK) + { + transport = lbtrm_transport_unicast_find(&(pinfo->dst), src_port, session_id, pinfo->fd->num); + } + else + { + transport = lbtrm_transport_add(&(pinfo->src), src_port, session_id, &(pinfo->dst), dest_port, pinfo->fd->num); + } + } + else + { + if (packet_type == LBTRM_PACKET_TYPE_NAK) + { + transport = lbtrm_transport_unicast_find(&(pinfo->dst), src_port, session_id, pinfo->fd->num); + } + else + { + transport = lbtrm_transport_find(&(pinfo->src), src_port, session_id, &(pinfo->dst), dest_port, pinfo->fd->num); + } + } + if (transport != NULL) + { + proto_item * item = NULL; + + channel = transport->channel; + item = proto_tree_add_uint64(lbtrm_tree, hf_lbtrm_channel, tvb, 0, 0, channel); + PROTO_ITEM_SET_GENERATED(item); + } + if (tag_name != NULL) + { + proto_item * item = NULL; + + item = proto_tree_add_string(lbtrm_tree, hf_lbtrm_tag, tvb, 0, 0, tag_name); + PROTO_ITEM_SET_GENERATED(item); + } + if (transport != NULL) + { + tapinfo = wmem_new0(wmem_file_scope(), lbm_lbtrm_tap_info_t); + tapinfo->transport = lbtrm_transport_source_string_transport(transport); + tapinfo->type = packet_type; + } + + hdr_item = proto_tree_add_item(lbtrm_tree, hf_lbtrm_hdr, tvb, O_LBTRM_HDR_T_VER_TYPE, L_LBTRM_HDR_T, ENC_NA); + hdr_tree = proto_item_add_subtree(hdr_item, ett_lbtrm_hdr); + ver_type_item = proto_tree_add_none_format(hdr_tree, hf_lbtrm_hdr_ver_type, tvb, O_LBTRM_HDR_T_VER_TYPE, L_LBTRM_HDR_T_VER_TYPE, "Version/Type: Version %u, Type %s", + LBTRM_HDR_VER(ver_type), val_to_str(packet_type, lbtrm_packet_type, "Unknown (0x%02x)")); + ver_type_tree = proto_item_add_subtree(ver_type_item, ett_lbtrm_hdr_ver_type); + proto_tree_add_item(ver_type_tree, hf_lbtrm_hdr_ver_type_ver, tvb, O_LBTRM_HDR_T_VER_TYPE, L_LBTRM_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + header_type_item = proto_tree_add_item(ver_type_tree, hf_lbtrm_hdr_ver_type_type, tvb, O_LBTRM_HDR_T_VER_TYPE, L_LBTRM_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + /* Setup the INFO column for this packet. */ + switch (packet_type) + { + case LBTRM_PACKET_TYPE_DATA: + sequence = tvb_get_ntohl(tvb, L_LBTRM_HDR_T + O_LBTRM_DATA_HDR_T_SQN); + flags_fec_type = tvb_get_guint8(tvb, L_LBTRM_HDR_T + O_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE); + if ((flags_fec_type & LBTRM_DATA_RETRANSMISSION_FLAG) != 0) + { + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "DATA(RX) sqn 0x%x Port %" G_GUINT16_FORMAT " ID 0x%08x", sequence, src_port, session_id); + } + else + { + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "DATA sqn 0x%x Port %" G_GUINT16_FORMAT " ID 0x%08x", sequence, src_port, session_id); + } + break; + case LBTRM_PACKET_TYPE_SM: + sequence = tvb_get_ntohl(tvb, L_LBTRM_HDR_T + O_LBTRM_SM_HDR_T_SM_SQN); + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "SM sqn 0x%x Port %" G_GUINT16_FORMAT " ID 0x%08x", sequence, src_port, session_id); + break; + case LBTRM_PACKET_TYPE_NAK: + num_naks = tvb_get_ntohs(tvb, L_LBTRM_HDR_T + O_LBTRM_NAK_HDR_T_NUM_NAKS); + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "NAK %u naks Port %" G_GUINT16_FORMAT " ID 0x%08x", num_naks, src_port, session_id); + break; + case LBTRM_PACKET_TYPE_NCF: + num_ncfs = tvb_get_ntohs(tvb, L_LBTRM_HDR_T + O_LBTRM_NCF_HDR_T_NUM_NCFS); + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "NCF %u ncfs Port %" G_GUINT16_FORMAT " ID 0x%08x", num_ncfs, src_port, session_id); + break; + default: + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "Unknown (0x%02x)", packet_type); + expert_add_info_format(pinfo, header_type_item, &ei_lbtrm_analysis_invalid_value, "Unrecognized type 0x%02x", packet_type); + break; + } + + proto_tree_add_item(hdr_tree, hf_lbtrm_hdr_next_hdr, tvb, O_LBTRM_HDR_T_NEXT_HDR, L_LBTRM_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(hdr_tree, hf_lbtrm_hdr_ucast_port, tvb, O_LBTRM_HDR_T_UCAST_PORT, L_LBTRM_HDR_T_UCAST_PORT, ENC_BIG_ENDIAN); + proto_tree_add_item(hdr_tree, hf_lbtrm_hdr_session_id, tvb, O_LBTRM_HDR_T_SESSION_ID, L_LBTRM_HDR_T_SESSION_ID, ENC_BIG_ENDIAN); + total_dissected_len = L_LBTRM_HDR_T; + offset = L_LBTRM_HDR_T; + switch (packet_type) + { + case LBTRM_PACKET_TYPE_DATA: + dissected_len = dissect_lbtrm_data(tvb, offset, pinfo, lbtrm_tree, &sequence, &retransmission, tapinfo); + break; + case LBTRM_PACKET_TYPE_SM: + dissected_len = dissect_lbtrm_sm(tvb, offset, pinfo, lbtrm_tree, &sequence, tapinfo); + break; + case LBTRM_PACKET_TYPE_NAK: + dissected_len = dissect_lbtrm_nak(tvb, offset, pinfo, lbtrm_tree, tapinfo); + break; + case LBTRM_PACKET_TYPE_NCF: + dissected_len = dissect_lbtrm_ncf(tvb, offset, pinfo, lbtrm_tree, tapinfo); + break; + default: + return (total_dissected_len); + break; + } + total_dissected_len += dissected_len; + offset += dissected_len; + while (next_hdr != LBTRM_NHDR_DATA) + { + guint8 hdrlen = 0; + + next_hdr = tvb_get_guint8(tvb, offset + O_LBTRM_BASIC_OPT_T_NEXT_HDR); + hdrlen = tvb_get_guint8(tvb, offset + O_LBTRM_BASIC_OPT_T_HDR_LEN); + if (hdrlen == 0) + { + break; + } + offset += hdrlen; + total_dissected_len += hdrlen; + } + + if (lbtrm_sequence_analysis) + { + if (pinfo->fd->flags.visited == 0) + { + if (transport != NULL) + { + lbtrm_transport_frame_add(transport, packet_type, pinfo->fd->num, sequence, retransmission); + } + } + else + { + if (transport != NULL) + { + lbm_transport_frame_t * frame = NULL; + + /* Setup the tree */ + transport_item = proto_tree_add_item(lbtrm_tree, hf_lbtrm_analysis, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(transport_item); + transport_tree = proto_item_add_subtree(transport_item, ett_lbtrm_transport); + frame = lbtrm_transport_frame_find(transport, pinfo->fd->num); + if (frame != NULL) + { + lbm_transport_sqn_t * sqn = NULL; + + if (frame->previous_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_prev_frame, tvb, 0, 0, frame->previous_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_next_frame, tvb, 0, 0, frame->next_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + switch (packet_type) + { + case LBTRM_PACKET_TYPE_DATA: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_prev_data_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_next_data_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + sqn = lbtrm_transport_sqn_find(transport, packet_type, sequence); + if (sqn != NULL) + { + if (sqn->frame_count > 1) + { + proto_tree * frame_tree = NULL; + proto_item * frame_tree_item = NULL; + lbtrm_sqn_frame_list_callback_data_t cb_data; + + frame_tree_item = proto_tree_add_item(transport_tree, hf_lbtrm_analysis_sqn, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(frame_tree_item); + frame_tree = proto_item_add_subtree(frame_tree_item, ett_lbtrm_transport_sqn); + cb_data.tree = frame_tree; + cb_data.tvb = tvb; + cb_data.current_frame = pinfo->fd->num; + wmem_tree_foreach(sqn->frame, dissect_lbtrm_sqn_frame_list_callback, (void *) &cb_data); + } + } + if (frame->retransmission) + { + transport_item = proto_tree_add_boolean(transport_tree, hf_lbtrm_analysis_data_retransmission, tvb, 0, 0, TRUE); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info(pinfo, transport_item, &ei_lbtrm_analysis_data_rx); + } + if (frame->sqn_gap != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_data_sqn_gap, tvb, 0, 0, frame->sqn_gap); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info_format(pinfo, transport_item, &ei_lbtrm_analysis_data_gap, "Data sequence gap (%" G_GUINT32_FORMAT ")", frame->sqn_gap); + } + if (frame->ooo_gap != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_data_ooo_gap, tvb, 0, 0, frame->ooo_gap); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info_format(pinfo, transport_item, &ei_lbtrm_analysis_data_ooo, "Data sequence out of order gap (%" G_GUINT32_FORMAT ")", frame->ooo_gap); + } + if (frame->duplicate) + { + transport_item = proto_tree_add_boolean(transport_tree, hf_lbtrm_analysis_data_duplicate, tvb, 0, 0, TRUE); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info(pinfo, transport_item, &ei_lbtrm_analysis_data_dup); + } + break; + case LBTRM_PACKET_TYPE_SM: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_prev_sm_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_next_sm_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + sqn = lbtrm_transport_sqn_find(transport, packet_type, sequence); + if (sqn != NULL) + { + if (sqn->frame_count > 1) + { + proto_tree * frame_tree = NULL; + proto_item * frame_tree_item = NULL; + lbtrm_sqn_frame_list_callback_data_t cb_data; + + frame_tree_item = proto_tree_add_item(transport_tree, hf_lbtrm_analysis_sqn, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(frame_tree_item); + frame_tree = proto_item_add_subtree(frame_tree_item, ett_lbtrm_transport_sqn); + cb_data.tree = frame_tree; + cb_data.tvb = tvb; + cb_data.current_frame = pinfo->fd->num; + wmem_tree_foreach(sqn->frame, dissect_lbtrm_sqn_frame_list_callback, (void *) &cb_data); + } + } + if (frame->sqn_gap != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_sm_sqn_gap, tvb, 0, 0, frame->sqn_gap); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info_format(pinfo, transport_item, &ei_lbtrm_analysis_sm_gap, "SM sequence gap (%" G_GUINT32_FORMAT ")", frame->sqn_gap); + } + if (frame->ooo_gap != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_sm_ooo_gap, tvb, 0, 0, frame->ooo_gap); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info_format(pinfo, transport_item, &ei_lbtrm_analysis_sm_ooo, "SM sequence out of order gap (%" G_GUINT32_FORMAT ")", frame->ooo_gap); + } + if (frame->duplicate) + { + transport_item = proto_tree_add_boolean(transport_tree, hf_lbtrm_analysis_sm_duplicate, tvb, 0, 0, TRUE); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info(pinfo, transport_item, &ei_lbtrm_analysis_sm_dup); + } + break; + case LBTRM_PACKET_TYPE_NAK: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_prev_nak_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_next_nak_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + break; + case LBTRM_PACKET_TYPE_NCF: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_prev_ncf_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtrm_analysis_next_ncf_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + break; + default: + break; + } + } + } + } + } + if ((packet_type == LBTRM_PACKET_TYPE_DATA) && (next_hdr == LBTRM_NHDR_DATA)) + { + total_dissected_len += dissect_lbtrm_data_contents(tvb, offset, pinfo, tree, tag_name, channel); + } + if (tapinfo != NULL) + { + tap_queue_packet(lbtrm_tap_handle, pinfo, (void *)tapinfo); + } + return (total_dissected_len); +} + +static gboolean test_lbtrm_packet(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * user_data) +{ + in_addr_t dest_addr; + in_addr_t dest_addr_h; + gboolean valid_packet = FALSE; + guint8 ver_type = 0; + guint8 packet_type = 0; + guint8 packet_ver = 0; + guint8 next_hdr = 0; + + /* Must be a UDP packet. */ + if (pinfo->ptype != PT_UDP) + { + return (FALSE); + } + /* Destination address must be IPV4 and 4 bytes in length. */ + if ((pinfo->dst.type != AT_IPv4) || (pinfo->dst.len != 4)) + { + return (FALSE); + } + if (tvb_reported_length_remaining(tvb, 0) < L_LBTRM_HDR_T) + { + return (FALSE); + } + ver_type = tvb_get_guint8(tvb, O_LBTRM_HDR_T_VER_TYPE); + packet_type = LBTRM_HDR_TYPE(ver_type); + switch (packet_type) + { + case LBTRM_PACKET_TYPE_DATA: + case LBTRM_PACKET_TYPE_SM: + case LBTRM_PACKET_TYPE_NAK: + case LBTRM_PACKET_TYPE_NCF: + break; + default: + return (FALSE); + } + packet_ver = LBTRM_HDR_VER(ver_type); + if (packet_ver != LBTRM_VERSION) + { + return (FALSE); + } + next_hdr = tvb_get_guint8(tvb, O_LBTRM_HDR_T_NEXT_HDR); + if (next_hdr != LBTRM_NHDR_DATA) + { + return (FALSE); + } + if (lbtrm_use_tag) + { + if (lbtrm_tag_find(pinfo) != NULL) + { + valid_packet = TRUE; + } + } + else + { + dest_addr = *((in_addr_t *)pinfo->dst.data); + dest_addr_h = g_ntohl(dest_addr); + + /* Is the destination a multicast address? */ + if (IN_MULTICAST(dest_addr_h)) + { + /* Check the MC address. */ + if ((dest_addr_h >= lbtrm_mc_address_low_host) && (dest_addr_h <= lbtrm_mc_address_high_host)) + { + /* It's in the LBT-RM multicast range. Check the ports. */ + if ((pinfo->destport >= lbtrm_dest_port_low) && (pinfo->destport <= lbtrm_dest_port_high)) + { + /* Must be one of ours. */ + valid_packet = TRUE; + } + } + else if ((dest_addr_h == mim_incoming_mc_address_host) || (dest_addr_h == mim_outgoing_mc_address_host)) + { + /* Might be MIM. Check the port. */ + if (((dest_addr_h == mim_incoming_mc_address_host) && (pinfo->destport == mim_incoming_dest_port)) + || ((dest_addr_h == mim_outgoing_mc_address_host) && (pinfo->destport == mim_outgoing_dest_port))) + { + /* Must be one of ours. */ + valid_packet = TRUE; + } + } + } + else + { + /* Not multicast, might be a unicast UDP NAK. Check the destination port. */ + if ((pinfo->destport >= lbtrm_src_port_low) && (pinfo->destport <= lbtrm_src_port_high)) + { + valid_packet = TRUE; + } + } + } + if (valid_packet) + { + dissect_lbtrm(tvb, pinfo, tree, user_data); + return (TRUE); + } + return (FALSE); +} + +/* The registration hand-off routine */ +void proto_reg_handoff_lbtrm(void) +{ + static gboolean already_registered = FALSE; + struct in_addr addr; + in_addr_t dest_addr_h_low; + in_addr_t dest_addr_h_high; + + if (!already_registered) + { + lbtrm_dissector_handle = new_create_dissector_handle(dissect_lbtrm, proto_lbtrm); + dissector_add_uint("udp.port", 0, lbtrm_dissector_handle); + heur_dissector_add("udp", test_lbtrm_packet, proto_lbtrm); + lbtrm_tap_handle = register_tap("lbtrm"); + } + + /* Make sure the low MC address is <= the high MC address. If not, don't change them. */ + inet_aton(global_lbtrm_mc_address_low, &addr); + dest_addr_h_low = g_ntohl(addr.s_addr); + inet_aton(global_lbtrm_mc_address_high, &addr); + dest_addr_h_high = g_ntohl(addr.s_addr); + if (dest_addr_h_low <= dest_addr_h_high) + { + lbtrm_mc_address_low_host = dest_addr_h_low; + lbtrm_mc_address_high_host = dest_addr_h_high; + } + + /* Make sure the low destination port is <= the high destination port. If not, don't change them. */ + if (global_lbtrm_dest_port_low <= global_lbtrm_dest_port_high) + { + lbtrm_dest_port_low = global_lbtrm_dest_port_low; + lbtrm_dest_port_high = global_lbtrm_dest_port_high; + } + + /* Make sure the low source port is <= the high source port. If not, don't change them. */ + if (global_lbtrm_src_port_low <= global_lbtrm_src_port_high) + { + lbtrm_src_port_low = global_lbtrm_src_port_low; + lbtrm_src_port_high = global_lbtrm_src_port_high; + } + + /* Add the dissector hooks for the MIM MC groups. */ + inet_aton(global_mim_incoming_mc_address, &addr); + mim_incoming_mc_address_host = g_htonl(addr.s_addr); + inet_aton(global_mim_outgoing_mc_address, &addr); + mim_outgoing_mc_address_host = g_htonl(addr.s_addr); + + /* Add the dissector hooks for the MIM ports. */ + mim_incoming_dest_port = global_mim_incoming_dest_port; + mim_outgoing_dest_port = global_mim_outgoing_dest_port; + + lbtrm_expert_separate_naks = global_lbtrm_expert_separate_naks; + lbtrm_expert_separate_ncfs = global_lbtrm_expert_separate_ncfs; + + lbtrm_sequence_analysis = global_lbtrm_sequence_analysis; + + lbtrm_use_tag = global_lbtrm_use_tag; + + already_registered = TRUE; +} + +/* Register all the bits needed with the filtering engine */ +void proto_register_lbtrm(void) +{ + static hf_register_info hf[] = + { + { &hf_lbtrm_channel, + { "Channel ID", "lbtrm.channel", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_tag, + { "Tag", "lbtrm.tag", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_hdr, + { "Header", "lbtrm.hdr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_hdr_ver_type, + { "Version/Type", "lbtrm.hdr.ver_type", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_hdr_ver_type_ver, + { "Version", "lbtrm.hdr.ver_type.ver", FT_UINT8, BASE_DEC, NULL, LBTRM_HDR_VER_MASK, NULL, HFILL } }, + { &hf_lbtrm_hdr_ver_type_type, + { "Type", "lbtrm.hdr.ver_type.type", FT_UINT8, BASE_HEX, VALS(lbtrm_packet_type), LBTRM_HDR_TYPE_MASK, NULL, HFILL } }, + { &hf_lbtrm_hdr_next_hdr, + { "Next Header", "lbtrm.hdr.next_hdr", FT_UINT8, BASE_HEX, VALS(lbtrm_next_header), 0x0, NULL, HFILL } }, + { &hf_lbtrm_hdr_ucast_port, + { "Source Unicast Port", "lbtrm.hdr.ucast_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_hdr_session_id, + { "Session ID", "lbtrm.hdr.session_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_data, + { "Data Header", "lbtrm.data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_data_sqn, + { "Sequence Number", "lbtrm.data.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_data_trail_sqn, + { "Trailing Edge Sequence Number", "lbtrm.data.trail_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_data_flags_fec_type, + { "FEC Flags", "lbtrm.data.flags_fec_type", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_data_flags_fec_type_ucast_naks, + { "Unicast NAKs", "lbtrm.data.flags_fec_type.ucast_naks", FT_BOOLEAN, L_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE * 8, TFS(&tfs_set_notset), LBTRM_DATA_UNICAST_NAKS_FLAG, "Set if NAKs are sent via unicast", HFILL } }, + { &hf_lbtrm_data_flags_fec_type_rx, + { "Retransmission", "lbtrm.data.flags_fec_type.rx", FT_BOOLEAN, L_LBTRM_DATA_HDR_T_FLAGS_FEC_TYPE * 8, TFS(&tfs_set_notset), LBTRM_DATA_RETRANSMISSION_FLAG, "Set if this is a retransmission", HFILL } }, + { &hf_lbtrm_data_flags_tgsz, + { "TGSZ Flags", "lbtrm.data.flags_tgsz", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_data_fec_symbol, + { "FEC Symbol", "lbtrm.data.fec_symbol", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_sm, + { "Session Message Header", "lbtrm.sm", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_sm_sm_sqn, + { "Sequence Number", "lbtrm.sm.sm_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_sm_lead_sqn, + { "Lead Sequence Number", "lbtrm.sm.lead_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_sm_trail_sqn, + { "Trail Sequence Number", "lbtrm.sm.trail_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_sm_flags_fec_type, + { "FEC Flags", "lbtrm.sm.flags_fec_type", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_sm_flags_fec_type_ucast_naks, + { "Unicast NAKs", "lbtrm.sm.flags_fec_type.ucast_naks", FT_BOOLEAN, 8, TFS(&tfs_present_not_present), LBTRM_SM_UNICAST_NAKS_FLAG, "Set if NAKs are sent via unicast", HFILL } }, + { &hf_lbtrm_sm_flags_tgsz, + { "TGSZ Flags", "lbtrm.sm.flags_tgsz", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_sm_reserved, + { "Reserved", "lbtrm.sm.reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_nak, + { "NAK Header", "lbtrm.nak", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_nak_num_naks, + { "Number of NAKs", "lbtrm.nak.num_naks", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_nak_format, + { "Format", "lbtrm.nak.format", FT_UINT8, BASE_HEX, VALS(lbtrm_nak_format), LBTRM_NAK_HDR_FORMAT_MASK, NULL, HFILL } }, + { &hf_lbtrm_nak_naks, + { "NAK List", "lbtrm.nak.naks", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_nak_nak, + { "NAK", "lbtrm.nak.nak", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_ncf, + { "NAK Confirmation Header", "lbtrm.ncf", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_ncf_trail_sqn, + { "Trailing Sequence Number", "lbtrm.ncf.trail_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_ncf_num_ncfs, + { "Number of Individual NCFs", "lbtrm.ncf.num_ncfs", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_ncf_reserved, + { "Reserved", "lbtrm.ncf.reserved", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_ncf_reason_format, + { "Reason/Format", "lbtrm.ncf.reason_format", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_ncf_reason_format_reason, + { "Reason", "lbtrm.ncf.reason", FT_UINT8, BASE_HEX, VALS(lbtrm_ncf_reason), LBTRM_NCF_HDR_REASON_MASK, NULL, HFILL } }, + { &hf_lbtrm_ncf_reason_format_format, + { "Format", "lbtrm.ncf.format", FT_UINT8, BASE_HEX, VALS(lbtrm_ncf_format), LBTRM_NCF_HDR_FORMAT_MASK, NULL, HFILL } }, + { &hf_lbtrm_ncf_ncfs, + { "NCF List", "lbtrm.ncf.ncfs", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_ncf_ncf, + { "NCF", "lbtrm.ncf.ncf", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis, + { "Transport Analysis", "lbtrm.transport", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_prev_frame, + { "Previous Transport frame", "lbtrm.transport.prev_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_prev_data_frame, + { "Previous Transport DATA frame", "lbtrm.transport.prev_data_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_prev_sm_frame, + { "Previous Transport SM frame", "lbtrm.transport.prev_sm_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_prev_nak_frame, + { "Previous Transport NAK frame", "lbtrm.transport.prev_nak_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_prev_ncf_frame, + { "Previous Transport NCF frame", "lbtrm.transport.prev_ncf_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_next_frame, + { "Next Transport frame", "lbtrm.transport.next_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_next_data_frame, + { "Next Transport DATA frame", "lbtrm.transport.next_data_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_next_sm_frame, + { "Next Transport SM frame", "lbtrm.transport.next_sm_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_next_nak_frame, + { "Next Transport NAK frame", "lbtrm.transport.next_nak_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_next_ncf_frame, + { "Next Transport NCF frame", "lbtrm.transport.next_ncf_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_sqn, + { "SQN Also in", "lbtrm.transport.sqn", FT_NONE, BASE_NONE, NULL, 0x0, "Sequence number also appears in these frames", HFILL } }, + { &hf_lbtrm_analysis_sqn_frame, + { "Frame", "lbtrm.transport.sqn.frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_data_retransmission, + { "Frame is a Data Retransmission", "lbtrm.transport.data_retransmission", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_data_sqn_gap, + { "Gap in Data Sequence", "lbtrm.transport.data_sqn_gap", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_data_ooo_gap, + { "Data Sequence Out of Order Gap", "lbtrm.transport.data_ooo_gap", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_data_duplicate, + { "Duplicate Data frame", "lbtrm.transport.data_duplicate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_sm_sqn_gap, + { "Gap in SM Sequence", "lbtrm.transport.sm_sqn_gap", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_sm_ooo_gap, + { "SM Sequence Out of Order Gap", "lbtrm.transport.sm_ooo_gap", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtrm_analysis_sm_duplicate, + { "Duplicate SM frame", "lbtrm.transport.sm_duplicate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + }; + static gint * ett[] = + { + &ett_lbtrm, + &ett_lbtrm_hdr, + &ett_lbtrm_hdr_ver_type, + &ett_lbtrm_data, + &ett_lbtrm_data_flags_fec_type, + &ett_lbtrm_sm, + &ett_lbtrm_sm_flags_fec_type, + &ett_lbtrm_nak, + &ett_lbtrm_nak_list, + &ett_lbtrm_ncf, + &ett_lbtrm_ncf_reason_format, + &ett_lbtrm_ncf_list, + &ett_lbtrm_transport, + &ett_lbtrm_transport_sqn + }; + static ei_register_info ei[] = + { + { &ei_lbtrm_analysis_ncf, { "lbtrm.analysis.ncf", PI_SEQUENCE, PI_NOTE, "NCF", EXPFILL } }, + { &ei_lbtrm_analysis_ncf_ncf, { "lbtrm.analysis.ncf.ncf", PI_SEQUENCE, PI_NOTE, "NCF", EXPFILL } }, + { &ei_lbtrm_analysis_nak, { "lbtrm.analysis.nak", PI_SEQUENCE, PI_WARN, "NAK", EXPFILL } }, + { &ei_lbtrm_analysis_nak_nak, { "lbtrm.analysis.nak.nak", PI_SEQUENCE, PI_WARN, "NAK", EXPFILL } }, + { &ei_lbtrm_analysis_sm, { "lbtrm.analysis.sm", PI_SEQUENCE, PI_CHAT, "SM", EXPFILL } }, + { &ei_lbtrm_analysis_rx, { "lbtrm.analysis.rx", PI_SEQUENCE, PI_NOTE, "RX", EXPFILL } }, + { &ei_lbtrm_analysis_invalid_value, { "lbtrm.analysis.invalid_value", PI_MALFORMED, PI_ERROR, "Invalid value", EXPFILL } }, + { &ei_lbtrm_analysis_data_rx, { "lbtrm.analysis.data.rx", PI_SEQUENCE, PI_NOTE, "Data RX", EXPFILL } }, + { &ei_lbtrm_analysis_data_gap, { "lbtrm.analysis.data.gap", PI_SEQUENCE, PI_NOTE, "Data sequence gap", EXPFILL } }, + { &ei_lbtrm_analysis_data_ooo, { "lbtrm.analysis.data.ooo", PI_SEQUENCE, PI_NOTE, "Data out of order", EXPFILL } }, + { &ei_lbtrm_analysis_data_dup, { "lbtrm.analysis.data.dup", PI_SEQUENCE, PI_NOTE, "Duplicate data", EXPFILL } }, + { &ei_lbtrm_analysis_sm_gap, { "lbtrm.analysis.sm.gap", PI_SEQUENCE, PI_NOTE, "SM sequence gap", EXPFILL } }, + { &ei_lbtrm_analysis_sm_ooo, { "lbtrm.analysis.sm.ooo", PI_SEQUENCE, PI_NOTE, "SM out of order", EXPFILL } }, + { &ei_lbtrm_analysis_sm_dup, { "lbtrm.analysis.sm.dup", PI_SEQUENCE, PI_NOTE, "Duplicate SM", EXPFILL } }, + }; + module_t * lbtrm_module; + struct in_addr addr; + uat_t * tag_uat; + expert_module_t * expert_lbtrm; + + proto_lbtrm = proto_register_protocol("LBT Reliable Multicast Protocol", + "LBT-RM", "lbtrm"); + + proto_register_field_array(proto_lbtrm, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_lbtrm = expert_register_protocol(proto_lbtrm); + expert_register_field_array(expert_lbtrm, ei, array_length(ei)); + + lbtrm_module = prefs_register_protocol_subtree("29West", proto_lbtrm, proto_reg_handoff_lbtrm); + inet_aton(LBTRM_DEFAULT_MC_ADDRESS_LOW, &addr); + lbtrm_mc_address_low_host = g_ntohl(addr.s_addr); + prefs_register_string_preference(lbtrm_module, + "mc_address_low", + "Multicast address range low (default " LBTRM_DEFAULT_MC_ADDRESS_LOW ")", + "Set the low end of the LBT-RM multicast address range (context transport_lbtrm_multicast_address_low)", + &global_lbtrm_mc_address_low); + + inet_aton(LBTRM_DEFAULT_MC_ADDRESS_HIGH, &addr); + lbtrm_mc_address_high_host = g_ntohl(addr.s_addr); + prefs_register_string_preference(lbtrm_module, + "mc_address_high", + "Multicast address range high (default " LBTRM_DEFAULT_MC_ADDRESS_HIGH ")", + "Set the high end of the LBT-RM multicast address range (context transport_lbtrm_multicast_address_high)", + &global_lbtrm_mc_address_high); + + prefs_register_uint_preference(lbtrm_module, + "dport_low", + "Destination port range low (default " MAKESTRING(LBTRM_DEFAULT_DPORT_LOW)")", + "Set the low end of the LBT-RM UDP destination port range (source transport_lbtrm_destination_port)", + 10, + &global_lbtrm_dest_port_low); + + prefs_register_uint_preference(lbtrm_module, + "dport_high", + "Destination port range high (default " MAKESTRING(LBTRM_DEFAULT_DPORT_HIGH)")", + "Set the high end of the LBT-RM UDP destination port range (source transport_lbtrm_destination_port)", + 10, + &global_lbtrm_dest_port_high); + + prefs_register_uint_preference(lbtrm_module, + "sport_low", + "Source port range low (default " MAKESTRING(LBTRM_DEFAULT_SPORT_LOW)")", + "Set the low end of the LBT-RM UDP source port range (context transport_lbtrm_source_port_low)", + 10, + &global_lbtrm_src_port_low); + + prefs_register_uint_preference(lbtrm_module, + "sport_high", + "Source port range high (default " MAKESTRING(LBTRM_DEFAULT_SPORT_HIGH)")", + "Set the high end of the LBT-RM UDP source port range (context transport_lbtrm_source_port_high)", + 10, + &global_lbtrm_src_port_high); + + inet_aton(MIM_DEFAULT_MC_INCOMING_ADDRESS, &addr); + mim_incoming_mc_address_host = g_ntohl(addr.s_addr); + prefs_register_string_preference(lbtrm_module, + "mim_incoming_address", + "MIM incoming multicast address (default " MIM_DEFAULT_MC_INCOMING_ADDRESS ")", + "Set the incoming MIM multicast address (context mim_incoming_address)", + &global_mim_incoming_mc_address); + + inet_aton(MIM_DEFAULT_MC_OUTGOING_ADDRESS, &addr); + mim_outgoing_mc_address_host = g_ntohl(addr.s_addr); + prefs_register_string_preference(lbtrm_module, + "mim_outgoing_address", + "MIM outgoing multicast address (default " MIM_DEFAULT_MC_OUTGOING_ADDRESS ")", + "Set the outgoing MIM multicast address (context mim_outgoing_address)", + &global_mim_incoming_mc_address); + + prefs_register_uint_preference(lbtrm_module, + "mim_incoming_dport", + "MIM incoming port (default " MAKESTRING(MIM_DEFAULT_INCOMING_DPORT)")", + "Set the incoming MIM UDP port (context mim_incoming_destination_port)", + 10, + &global_mim_incoming_dest_port); + + prefs_register_uint_preference(lbtrm_module, + "mim_outgoing_dport", + "MIM outgoing port (default " MAKESTRING(MIM_DEFAULT_OUTGOING_DPORT)")", + "Set the outgoing MIM UDP port (context mim_outgoing_destination_port)", + 10, + &global_mim_outgoing_dest_port); + + lbtrm_expert_separate_naks = global_lbtrm_expert_separate_naks; + prefs_register_bool_preference(lbtrm_module, + "expert_separate_naks", + "Separate NAKs in Expert Info", + "Separate multiple NAKs from a single packet into distinct Expert Info entries", + &global_lbtrm_expert_separate_naks); + + lbtrm_expert_separate_ncfs = global_lbtrm_expert_separate_ncfs; + prefs_register_bool_preference(lbtrm_module, + "expert_separate_ncfs", + "Separate NCFs in Expert Info", + "Separate multiple NCFs from a single packet into distinct Expert Info entries", + &global_lbtrm_expert_separate_ncfs); + + lbtrm_sequence_analysis = global_lbtrm_sequence_analysis; + prefs_register_bool_preference(lbtrm_module, + "sequence_analysis", + "Perform sequence Number Analysis", + "Perform analysis on LBT-RM sequence numbers to determine out-of-order, gaps, loss, etc", + &global_lbtrm_sequence_analysis); + + lbtrm_use_tag = global_lbtrm_use_tag; + prefs_register_bool_preference(lbtrm_module, + "use_lbtrm_domain", + "Use LBT-RM tag table", + "Use table of LBT-RM tags to decode the packet instead of above values", + &global_lbtrm_use_tag); + tag_uat = uat_new("LBT-RM tag definitions", + sizeof(lbtrm_tag_entry_t), + "lbtrm_domains", + TRUE, + (void * *)&lbtrm_tag_entry, + &lbtrm_tag_count, + UAT_AFFECTS_DISSECTION, + NULL, + lbtrm_tag_copy_cb, + lbtrm_tag_update_cb, + lbtrm_tag_free_cb, + NULL, + lbtrm_tag_array); + prefs_register_uat_preference(lbtrm_module, + "tnw_lbtrm_tags", + "LBT-RM Tags", + "A table to define LBT-RM tags", + tag_uat); +} + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbtrm.h b/epan/dissectors/packet-lbtrm.h new file mode 100644 index 0000000000..b9ab1d6acb --- /dev/null +++ b/epan/dissectors/packet-lbtrm.h @@ -0,0 +1,71 @@ +/* packet-lbtrm.h + * Routines for LBT-RM Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef PACKET_LBTRM_H_INCLUDED +#define PACKET_LBTRM_H_INCLUDED + +#include "config.h" +#include +#include +#include +#include +#include "packet-lbm.h" + +typedef struct +{ + address source_address; + guint16 source_port; + guint32 session_id; + address multicast_group; + guint16 dest_port; + guint64 channel; + wmem_tree_t * frame; + lbm_transport_frame_t * last_frame; + lbm_transport_frame_t * last_data_frame; + lbm_transport_frame_t * last_sm_frame; + lbm_transport_frame_t * last_nak_frame; + lbm_transport_frame_t * last_ncf_frame; + wmem_tree_t * data_sqn; + wmem_tree_t * sm_sqn; + guint32 data_high_sqn; + guint32 sm_high_sqn; +} lbtrm_transport_t; + +lbtrm_transport_t * lbtrm_transport_add(const address * source_address, guint16 source_port, guint32 session_id, const address * multicast_group, guint16 dest_port, guint32 frame); +char * lbtrm_transport_source_string(const address * source_address, guint16 source_port, guint32 session_id, const address * multicast_group, guint16 dest_port); + +#endif + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbtru.c b/epan/dissectors/packet-lbtru.c new file mode 100644 index 0000000000..6482281d8b --- /dev/null +++ b/epan/dissectors/packet-lbtru.c @@ -0,0 +1,2002 @@ +/* packet-lbtru.c + * Routines for LBT-RU Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "packet-lbm.h" +#include "packet-lbtru.h" + +/* Protocol handle */ +static int proto_lbtru = -1; + +/* Dissector handle */ +static dissector_handle_t lbtru_dissector_handle; + +/*----------------------------------------------------------------------------*/ +/* LBT-RU transport management. */ +/*----------------------------------------------------------------------------*/ + +static const address lbtru_null_address = { AT_NONE, -1, 0, NULL }; + +static lbtru_transport_t * lbtru_transport_find(const address * source_address, guint16 source_port, guint32 session_id, guint32 frame) +{ + lbtru_transport_t * entry = NULL; + wmem_tree_t * session_tree = NULL; + conversation_t * conv = NULL; + + conv = find_conversation(frame, source_address, &lbtru_null_address, PT_UDP, source_port, 0, 0); + if (conv != NULL) + { + if (frame != 0) + { + if (conv->setup_frame == 0) + { + conv->setup_frame = frame; + } + if (frame > conv->last_frame) + { + conv->last_frame = frame; + } + } + session_tree = (wmem_tree_t *) conversation_get_proto_data(conv, proto_lbtru); + if (session_tree != NULL) + { + entry = (lbtru_transport_t *) wmem_tree_lookup32(session_tree, session_id); + } + } + return (entry); +} + +lbtru_transport_t * lbtru_transport_add(const address * source_address, guint16 source_port, guint32 session_id, guint32 frame) +{ + lbtru_transport_t * entry = NULL; + wmem_tree_t * session_tree = NULL; + conversation_t * conv = NULL; + + conv = find_conversation(frame, source_address, &lbtru_null_address, PT_UDP, source_port, 0, 0); + if (conv == NULL) + { + conv = conversation_new(frame, source_address, &lbtru_null_address, PT_UDP, source_port, 0, 0); + } + if (frame != 0) + { + if (conv->setup_frame == 0) + { + conv->setup_frame = frame; + } + if (frame > conv->last_frame) + { + conv->last_frame = frame; + } + } + session_tree = (wmem_tree_t *) conversation_get_proto_data(conv, proto_lbtru); + if (session_tree == NULL) + { + session_tree = wmem_tree_new(wmem_file_scope()); + conversation_add_proto_data(conv, proto_lbtru, (void *)session_tree); + } + entry = (lbtru_transport_t *) wmem_tree_lookup32(session_tree, session_id); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new(wmem_file_scope(), lbtru_transport_t); + SE_COPY_ADDRESS(&(entry->source_address), source_address); + entry->source_port = source_port; + entry->session_id = session_id; + entry->channel = lbm_channel_assign(LBM_CHANNEL_TRANSPORT_LBTRU); + entry->next_client_id = 1; + entry->client_list = wmem_list_new(wmem_file_scope()); + wmem_tree_insert32(session_tree, session_id, (void *) entry); + return (entry); +} + +static lbtru_client_transport_t * lbtru_client_transport_find(lbtru_transport_t * transport, const address * receiver_address, guint16 receiver_port, guint32 frame) +{ + lbtru_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, PT_UDP, 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_lbtru); + if (session_tree != NULL) + { + entry = (lbtru_client_transport_t *) wmem_tree_lookup32(session_tree, transport->session_id); + } + } + return (entry); +} + +static lbtru_client_transport_t * lbtru_client_transport_add(lbtru_transport_t * transport, const address * receiver_address, guint16 receiver_port, guint32 frame) +{ + lbtru_client_transport_t * entry = NULL; + conversation_t * client_conv = NULL; + wmem_tree_t * session_tree = NULL; + + if (transport == NULL) + { + return (NULL); + } + entry = lbtru_client_transport_find(transport, receiver_address, receiver_port, frame); + if (entry != NULL) + { + return (entry); + } + entry = wmem_new0(wmem_file_scope(), lbtru_client_transport_t); + SE_COPY_ADDRESS(&(entry->receiver_address), receiver_address); + entry->receiver_port = receiver_port; + entry->transport = transport; + entry->id = transport->next_client_id++; + entry->frame = wmem_tree_new(wmem_file_scope()); + entry->last_frame = NULL; + entry->last_data_frame = NULL; + entry->last_sm_frame = NULL; + entry->last_nak_frame = NULL; + entry->last_ncf_frame = NULL; + entry->last_ack_frame = NULL; + entry->last_creq_frame = NULL; + entry->last_rst_frame = NULL; + entry->data_sqn = wmem_tree_new(wmem_file_scope()); + entry->sm_sqn = wmem_tree_new(wmem_file_scope()); + entry->data_high_sqn = 0; + entry->sm_high_sqn = 0; + + /* See if a conversation for this address/port pair exists. */ + client_conv = find_conversation(frame, &(transport->source_address), receiver_address, PT_UDP, transport->source_port, receiver_port, 0); + if (client_conv == NULL) + { + client_conv = conversation_new(frame, &(transport->source_address), receiver_address, PT_UDP, transport->source_port, receiver_port, 0); + session_tree = wmem_tree_new(wmem_file_scope()); + conversation_add_proto_data(client_conv, proto_lbtru, (void *) session_tree); + } + else + { + session_tree = (wmem_tree_t *) conversation_get_proto_data(client_conv, proto_lbtru); + if (session_tree == NULL) + { + session_tree = wmem_tree_new(wmem_file_scope()); + conversation_add_proto_data(client_conv, proto_lbtru, (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); +} + +static lbm_transport_sqn_t * lbtru_client_transport_sqn_find(lbtru_client_transport_t * client, guint8 type, guint32 sqn) +{ + lbm_transport_sqn_t * sqn_entry = NULL; + + switch (type) + { + case LBTRU_PACKET_TYPE_DATA: + sqn_entry = (lbm_transport_sqn_t *) wmem_tree_lookup32(client->data_sqn, sqn); + break; + case LBTRU_PACKET_TYPE_SM: + sqn_entry = (lbm_transport_sqn_t *) wmem_tree_lookup32(client->sm_sqn, sqn); + break; + case LBTRU_PACKET_TYPE_NAK: + case LBTRU_PACKET_TYPE_NCF: + case LBTRU_PACKET_TYPE_ACK: + case LBTRU_PACKET_TYPE_CREQ: + case LBTRU_PACKET_TYPE_RST: + default: + sqn_entry = NULL; + break; + } + return (sqn_entry); +} + +static lbm_transport_sqn_t * lbtru_client_transport_sqn_add(lbtru_client_transport_t * client, lbm_transport_frame_t * frame) +{ + wmem_tree_t * sqn_list = NULL; + lbm_transport_sqn_t * sqn_entry = NULL; + + switch (frame->type) + { + case LBTRU_PACKET_TYPE_DATA: + sqn_list = client->data_sqn; + break; + case LBTRU_PACKET_TYPE_SM: + sqn_list = client->sm_sqn; + break; + case LBTRU_PACKET_TYPE_NAK: + case LBTRU_PACKET_TYPE_NCF: + case LBTRU_PACKET_TYPE_ACK: + case LBTRU_PACKET_TYPE_CREQ: + case LBTRU_PACKET_TYPE_RST: + default: + return (NULL); + break; + } + + /* Add the sqn. */ + sqn_entry = lbm_transport_sqn_add(sqn_list, frame); + return (sqn_entry); +} + +static lbm_transport_frame_t * lbtru_client_transport_frame_find(lbtru_client_transport_t * client, guint32 frame) +{ + return ((lbm_transport_frame_t *) wmem_tree_lookup32(client->frame, frame)); +} + +static lbm_transport_frame_t * lbtru_client_transport_frame_add(lbtru_client_transport_t * client, guint8 type, guint32 frame, guint32 sqn, gboolean retransmission) +{ + lbm_transport_sqn_t * dup_sqn_entry = NULL; + lbm_transport_frame_t * frame_entry = NULL; + + /* Locate the frame. */ + frame_entry = lbtru_client_transport_frame_find(client, frame); + if (frame_entry != NULL) + { + return (frame_entry); + } + frame_entry = lbm_transport_frame_add(client->frame, type, frame, sqn, retransmission); + if (client->last_frame != NULL) + { + frame_entry->previous_frame = client->last_frame->frame; + client->last_frame->next_frame = frame; + } + client->last_frame = frame_entry; + switch (type) + { + case LBTRU_PACKET_TYPE_DATA: + if (client->last_data_frame != NULL) + { + frame_entry->previous_type_frame = client->last_data_frame->frame; + client->last_data_frame->next_type_frame = frame; + /* Ideally, this frame's sqn is 1 more than the highest data sqn seen */ + if (frame_entry->sqn <= client->data_high_sqn) + { + dup_sqn_entry = lbtru_client_transport_sqn_find(client, type, frame_entry->sqn); + if (!frame_entry->retransmission) + { + /* Out of order */ + if (dup_sqn_entry != NULL) + { + frame_entry->duplicate = TRUE; + } + if (frame_entry->sqn != client->data_high_sqn) + { + frame_entry->ooo_gap = client->data_high_sqn - frame_entry->sqn; + } + } + } + else + { + if (!frame_entry->retransmission) + { + if (frame_entry->sqn != (client->data_high_sqn + 1)) + { + /* Gap */ + frame_entry->sqn_gap = frame_entry->sqn - (client->last_data_frame->sqn + 1); + } + } + } + } + if ((frame_entry->sqn > client->data_high_sqn) && !frame_entry->retransmission) + { + client->data_high_sqn = frame_entry->sqn; + } + client->last_data_frame = frame_entry; + break; + case LBTRU_PACKET_TYPE_SM: + if (client->last_sm_frame != NULL) + { + frame_entry->previous_type_frame = client->last_sm_frame->frame; + client->last_sm_frame->next_type_frame = frame; + /* Ideally, this frame's sqn is 1 more than the highest SM sqn seen */ + if (frame_entry->sqn <= client->sm_high_sqn) + { + /* Out of order */ + dup_sqn_entry = lbtru_client_transport_sqn_find(client, type, frame_entry->sqn); + if (dup_sqn_entry != NULL) + { + frame_entry->duplicate = TRUE; + } + if (frame_entry->sqn != client->sm_high_sqn) + { + frame_entry->ooo_gap = client->sm_high_sqn - frame_entry->sqn; + } + } + else + { + if (frame_entry->sqn != (client->sm_high_sqn + 1)) + { + /* Gap */ + frame_entry->sqn_gap = frame_entry->sqn - (client->sm_high_sqn + 1); + } + } + } + if (frame_entry->sqn > client->sm_high_sqn) + { + client->sm_high_sqn = frame_entry->sqn; + } + client->last_sm_frame = frame_entry; + break; + case LBTRU_PACKET_TYPE_NAK: + if (client->last_nak_frame != NULL) + { + frame_entry->previous_type_frame = client->last_nak_frame->frame; + client->last_nak_frame->next_type_frame = frame; + } + client->last_nak_frame = frame_entry; + break; + case LBTRU_PACKET_TYPE_NCF: + if (client->last_ncf_frame != NULL) + { + frame_entry->previous_type_frame = client->last_ncf_frame->frame; + client->last_ncf_frame->next_type_frame = frame; + } + client->last_ncf_frame = frame_entry; + break; + case LBTRU_PACKET_TYPE_ACK: + if (client->last_ack_frame != NULL) + { + frame_entry->previous_type_frame = client->last_ack_frame->frame; + client->last_ack_frame->next_type_frame = frame; + } + client->last_ack_frame = frame_entry; + break; + case LBTRU_PACKET_TYPE_CREQ: + if (client->last_creq_frame != NULL) + { + frame_entry->previous_type_frame = client->last_creq_frame->frame; + client->last_creq_frame->next_type_frame = frame; + } + client->last_creq_frame = frame_entry; + break; + case LBTRU_PACKET_TYPE_RST: + if (client->last_rst_frame != NULL) + { + frame_entry->previous_type_frame = client->last_rst_frame->frame; + client->last_rst_frame->next_type_frame = frame; + } + client->last_rst_frame = frame_entry; + break; + } + + /* Add the sqn. */ + (void)lbtru_client_transport_sqn_add(client, frame_entry); + return (frame_entry); +} + +char * lbtru_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(), "LBT-RU:%s:%" G_GUINT16_FORMAT, address_to_str(wmem_packet_scope(), source_address), source_port); + } + else + { + bufptr = wmem_strdup_printf(wmem_file_scope(), "LBT-RU:%s:%" G_GUINT16_FORMAT ":%08x", address_to_str(wmem_packet_scope(), source_address), source_port, session_id); + } + return (bufptr); +} + +/*----------------------------------------------------------------------------*/ +/* Packet layouts. */ +/*----------------------------------------------------------------------------*/ + +/* LBT-RU main header */ +typedef struct +{ + lbm_uint8_t ver_type; + lbm_uint8_t next_hdr; + lbm_uint16_t flags_or_res; +} lbtru_hdr_t; +#define O_LBTRU_HDR_T_VER_TYPE OFFSETOF(lbtru_hdr_t, ver_type) +#define L_LBTRU_HDR_T_VER_TYPE SIZEOF(lbtru_hdr_t, ver_type) +#define O_LBTRU_HDR_T_NEXT_HDR OFFSETOF(lbtru_hdr_t, next_hdr) +#define L_LBTRU_HDR_T_NEXT_HDR SIZEOF(lbtru_hdr_t, next_hdr) +#define O_LBTRU_HDR_T_FLAGS_OR_RES OFFSETOF(lbtru_hdr_t, flags_or_res) +#define L_LBTRU_HDR_T_FLAGS_OR_RES SIZEOF(lbtru_hdr_t, flags_or_res) +#define L_LBTRU_HDR_T (gint) sizeof(lbtru_hdr_t) + +#define LBTRU_VERSION 0x00 +#define LBTRU_HDR_VER(x) (x >> 4) +#define LBTRU_HDR_TYPE(x) (x & 0x0F) +#define LBTRU_HDR_VER_VER_MASK 0xF0 +#define LBTRU_HDR_VER_TYPE_MASK 0x0F + +#define LBTRU_RETRANSMISSION_FLAG 0x4000 + +/* LBT-RU data header */ +typedef struct +{ + lbm_uint32_t sqn; + lbm_uint32_t trail_sqn; +} lbtru_data_hdr_t; +#define O_LBTRU_DATA_HDR_T_SQN OFFSETOF(lbtru_data_hdr_t, sqn) +#define L_LBTRU_DATA_HDR_T_SQN SIZEOF(lbtru_data_hdr_t, sqn) +#define O_LBTRU_DATA_HDR_T_TRAIL_SQN OFFSETOF(lbtru_data_hdr_t, trail_sqn) +#define L_LBTRU_DATA_HDR_T_TRAIL_SQN SIZEOF(lbtru_data_hdr_t, trail_sqn) +#define L_LBTRU_DATA_HDR_T (gint) (sizeof(lbtru_data_hdr_t)) + +/* LBT-RU Session Message header */ +typedef struct +{ + lbm_uint32_t sm_sqn; + lbm_uint32_t lead_sqn; + lbm_uint32_t trail_sqn; +} lbtru_sm_hdr_t; +#define O_LBTRU_SM_HDR_T_SM_SQN OFFSETOF(lbtru_sm_hdr_t, sm_sqn) +#define L_LBTRU_SM_HDR_T_SM_SQN SIZEOF(lbtru_sm_hdr_t, sm_sqn) +#define O_LBTRU_SM_HDR_T_LEAD_SQN OFFSETOF(lbtru_sm_hdr_t, lead_sqn) +#define L_LBTRU_SM_HDR_T_LEAD_SQN SIZEOF(lbtru_sm_hdr_t, lead_sqn) +#define O_LBTRU_SM_HDR_T_TRAIL_SQN OFFSETOF(lbtru_sm_hdr_t, trail_sqn) +#define L_LBTRU_SM_HDR_T_TRAIL_SQN SIZEOF(lbtru_sm_hdr_t, trail_sqn) +#define L_LBTRU_SM_HDR_T (gint) (sizeof(lbtru_sm_hdr_t)) + +#define LBTRU_SM_SYN_FLAG 0x8000 + +/* LBT-RU NAK header */ +typedef struct +{ + lbm_uint16_t num_naks; + lbm_uint16_t format; +} lbtru_nak_hdr_t; +#define O_LBTRU_NAK_HDR_T_NUM_NAKS OFFSETOF(lbtru_nak_hdr_t, num_naks) +#define L_LBTRU_NAK_HDR_T_NUM_NAKS SIZEOF(lbtru_nak_hdr_t, num_naks) +#define O_LBTRU_NAK_HDR_T_FORMAT OFFSETOF(lbtru_nak_hdr_t, format) +#define L_LBTRU_NAK_HDR_T_FORMAT SIZEOF(lbtru_nak_hdr_t, format) +#define L_LBTRU_NAK_HDR_T (gint) (sizeof(lbtru_nak_hdr_t)) + +#define LBTRU_NAK_SELECTIVE_FORMAT 0x0 +#define LBTRU_NAK_HDR_FORMAT_MASK 0x000F +#define LBTRU_NAK_HDR_FORMAT(x) (x & 0xF) + +/* LBT-RU NAK Confirmation header */ +typedef struct +{ + lbm_uint32_t trail_sqn; + lbm_uint16_t num_ncfs; + lbm_uint8_t reserved; + lbm_uint8_t reason_format; +} lbtru_ncf_hdr_t; +#define O_LBTRU_NCF_HDR_T_TRAIL_SQN OFFSETOF(lbtru_ncf_hdr_t, trail_sqn) +#define L_LBTRU_NCF_HDR_T_TRAIL_SQN SIZEOF(lbtru_ncf_hdr_t, trail_sqn) +#define O_LBTRU_NCF_HDR_T_NUM_NCFS OFFSETOF(lbtru_ncf_hdr_t, num_ncfs) +#define L_LBTRU_NCF_HDR_T_NUM_NCFS SIZEOF(lbtru_ncf_hdr_t, num_ncfs) +#define O_LBTRU_NCF_HDR_T_RESERVED OFFSETOF(lbtru_ncf_hdr_t, reserved) +#define L_LBTRU_NCF_HDR_T_RESERVED SIZEOF(lbtru_ncf_hdr_t, reserved) +#define O_LBTRU_NCF_HDR_T_REASON_FORMAT OFFSETOF(lbtru_ncf_hdr_t, reason_format) +#define L_LBTRU_NCF_HDR_T_REASON_FORMAT SIZEOF(lbtru_ncf_hdr_t, reason_format) +#define L_LBTRU_NCF_HDR_T (gint) (sizeof(lbtru_ncf_hdr_t)) + +#define LBTRU_NCF_SELECTIVE_FORMAT 0x0 +#define LBTRU_NCF_REASON_NO_RETRY 0x0 +#define LBTRU_NCF_REASON_IGNORED 0x1 +#define LBTRU_NCF_REASON_RX_DELAY 0x2 +#define LBTRU_NCF_REASON_SHED 0x3 +#define LBTRU_NCF_HDR_REASON(x) ((x & 0xF0) >> 4) +#define LBTRU_NCF_HDR_FORMAT(x) (x & 0xF) +#define LBTRU_NCF_HDR_REASON_MASK 0xF0 +#define LBTRU_NCF_HDR_FORMAT_MASK 0x0F + +/* LBT-RU ACK header */ +typedef struct +{ + lbm_uint32_t ack_sqn; +} lbtru_ack_hdr_t; +#define O_LBTRU_ACK_HDR_T_ACK_SQN OFFSETOF(lbtru_ack_hdr_t, ack_sqn) +#define L_LBTRU_ACK_HDR_T_ACK_SQN SIZEOF(lbtru_ack_hdr_t, ack_sqn) +#define L_LBTRU_ACK_HDR_T (gint) (sizeof(lbtru_ack_hdr_t)) + +/* LBT-RU basic option header */ +typedef struct +{ + lbm_uint8_t next_hdr; + lbm_uint8_t hdr_len; + lbm_uint16_t res; +} lbtru_basic_opt_t; +#define O_LBTRU_BASIC_OPT_T_NEXT_HDR OFFSETOF(lbtru_basic_opt_t, next_hdr) +#define L_LBTRU_BASIC_OPT_T_NEXT_HDR SIZEOF(lbtru_basic_opt_t, next_hdr) +#define O_LBTRU_BASIC_OPT_T_HDR_LEN OFFSETOF(lbtru_basic_opt_t, hdr_len) +#define L_LBTRU_BASIC_OPT_T_HDR_LEN SIZEOF(lbtru_basic_opt_t, hdr_len) +#define O_LBTRU_BASIC_OPT_T_RES OFFSETOF(lbtru_basic_opt_t, res) +#define L_LBTRU_BASIC_OPT_T_RES SIZEOF(lbtru_basic_opt_t, res) +#define L_LBTRU_BASIC_OPT_T (gint) (sizeof(lbtru_basic_opt_t)) + +/* LBT-RU Session ID option header */ +typedef struct +{ + lbm_uint32_t session_id; +} lbtru_sid_opt_t; +#define O_LBTRU_SID_OPT_T_SESSION_ID OFFSETOF(lbtru_sid_opt_t, session_id) +#define L_LBTRU_SID_OPT_T_SESSION_ID SIZEOF(lbtru_sid_opt_t, session_id) +#define L_LBTRU_SID_OPT_T (gint) (sizeof(lbtru_sid_opt_t)) + +/* LBT-RU Client ID option header */ +typedef struct +{ + lbm_uint32_t client_sid; +} lbtru_cid_opt_t; +#define O_LBTRU_CID_OPT_T_CLIENT_SID OFFSETOF(lbtru_cid_opt_t, client_sid) +#define L_LBTRU_CID_OPT_T_CLIENT_SID SIZEOF(lbtru_cid_opt_t, client_sid) +#define L_LBTRU_CID_OPT_T (gint) (sizeof(lbtru_cid_opt_t)) + +#define LBTRU_OPT_IGNORE 0x8000 + +#define LBTRU_NHDR_DATA 0x00 +#define LBTRU_NHDR_SID 0x01 +#define LBTRU_NHDR_CID 0x02 + +/* CREQ and RST use the normal header */ +#define LBTRU_CREQ_REQUEST_SYN 0x0 + +#define LBTRU_RST_REASON_DEFAULT 0x0 + +/*----------------------------------------------------------------------------*/ +/* Value translation tables. */ +/*----------------------------------------------------------------------------*/ + +static const value_string lbtru_packet_type[] = +{ + { LBTRU_PACKET_TYPE_DATA, "DATA" }, + { LBTRU_PACKET_TYPE_SM, "SM" }, + { LBTRU_PACKET_TYPE_NAK, "NAK" }, + { LBTRU_PACKET_TYPE_NCF, "NCF" }, + { LBTRU_PACKET_TYPE_ACK, "ACK" }, + { LBTRU_PACKET_TYPE_CREQ, "CREQ" }, + { LBTRU_PACKET_TYPE_RST, "RST" }, + { 0x0, NULL } +}; + +static const value_string lbtru_nak_format[] = +{ + { LBTRU_NAK_SELECTIVE_FORMAT, "Selective" }, + { 0x0, NULL } +}; + +static const value_string lbtru_ncf_format[] = +{ + { LBTRU_NCF_SELECTIVE_FORMAT, "Selective" }, + { 0x0, NULL } +}; + +static const value_string lbtru_ncf_reason[] = +{ + { LBTRU_NCF_REASON_NO_RETRY, "Do not retry" }, + { LBTRU_NCF_REASON_IGNORED, "NAK Ignored" }, + { LBTRU_NCF_REASON_RX_DELAY, "Retransmit Delay" }, + { LBTRU_NCF_REASON_SHED, "NAK Shed" }, + { 0x0, NULL } +}; + +static const value_string lbtru_creq_request[] = +{ + { LBTRU_CREQ_REQUEST_SYN, "SYN" }, + { 0x0, NULL } +}; + +static const value_string lbtru_rst_reason[] = +{ + { LBTRU_RST_REASON_DEFAULT, "Default" }, + { 0x0, NULL } +}; + +static const value_string lbtru_next_header[] = +{ + { LBTRU_NHDR_DATA, "DATA" }, + { LBTRU_NHDR_SID, "SID" }, + { LBTRU_NHDR_CID, "CID" }, + { 0x0, NULL } +}; + +/*----------------------------------------------------------------------------*/ +/* Preferences. */ +/*----------------------------------------------------------------------------*/ + +/* Preferences default values. */ +#define LBTRU_DEFAULT_SOURCE_PORT_LOW 14380 +#define LBTRU_DEFAULT_SOURCE_PORT_HIGH 14389 +#define LBTRU_DEFAULT_RECEIVER_PORT_LOW 14360 +#define LBTRU_DEFAULT_RECEIVER_PORT_HIGH 14379 + +/* Global preferences variables (altered by the preferences dialog). */ +static guint32 global_lbtru_source_port_low = LBTRU_DEFAULT_SOURCE_PORT_LOW; +static guint32 global_lbtru_source_port_high = LBTRU_DEFAULT_SOURCE_PORT_HIGH; +static guint32 global_lbtru_receiver_port_low = LBTRU_DEFAULT_RECEIVER_PORT_LOW; +static guint32 global_lbtru_receiver_port_high = LBTRU_DEFAULT_RECEIVER_PORT_HIGH; +static gboolean global_lbtru_expert_separate_naks = FALSE; +static gboolean global_lbtru_expert_separate_ncfs = FALSE; +static gboolean global_lbtru_use_tag = FALSE; +static gboolean global_lbtru_sequence_analysis = FALSE; + +/* Local preferences variables (used by the dissector). */ +static guint32 lbtru_source_port_low = LBTRU_DEFAULT_SOURCE_PORT_LOW; +static guint32 lbtru_source_port_high = LBTRU_DEFAULT_SOURCE_PORT_HIGH; +static guint32 lbtru_receiver_port_low = LBTRU_DEFAULT_RECEIVER_PORT_LOW; +static guint32 lbtru_receiver_port_high = LBTRU_DEFAULT_RECEIVER_PORT_HIGH; +static gboolean lbtru_expert_separate_naks = FALSE; +static gboolean lbtru_expert_separate_ncfs = FALSE; +static gboolean lbtru_use_tag = FALSE; +static gboolean lbtru_sequence_analysis = FALSE; + +/*----------------------------------------------------------------------------*/ +/* Tag management. */ +/*----------------------------------------------------------------------------*/ +typedef struct +{ + char * name; + guint32 source_port_low; + guint32 source_port_high; + guint32 receiver_port_low; + guint32 receiver_port_high; +} lbtru_tag_entry_t; + +static lbtru_tag_entry_t * lbtru_tag_entry = NULL; +static guint lbtru_tag_count = 0; + +UAT_CSTRING_CB_DEF(lbtru_tag, name, lbtru_tag_entry_t) +UAT_DEC_CB_DEF(lbtru_tag, source_port_low, lbtru_tag_entry_t) +UAT_DEC_CB_DEF(lbtru_tag, source_port_high, lbtru_tag_entry_t) +UAT_DEC_CB_DEF(lbtru_tag, receiver_port_low, lbtru_tag_entry_t) +UAT_DEC_CB_DEF(lbtru_tag, receiver_port_high, lbtru_tag_entry_t) +static uat_field_t lbtru_tag_array[] = +{ + UAT_FLD_CSTRING(lbtru_tag, name, "Tag name", "Tag name"), + UAT_FLD_DEC(lbtru_tag, source_port_low, "Source port low", "Source port low"), + UAT_FLD_DEC(lbtru_tag, source_port_high, "Source port high", "Source port high"), + UAT_FLD_DEC(lbtru_tag, receiver_port_low, "Receiver port low", "Receiver port low"), + UAT_FLD_DEC(lbtru_tag, receiver_port_high, "Receiver port high", "Receiver port high"), + UAT_END_FIELDS +}; + +/*----------------------------------------------------------------------------*/ +/* UAT callback functions. */ +/*----------------------------------------------------------------------------*/ +static void lbtru_tag_update_cb(void * record, const char * * error_string) +{ + lbtru_tag_entry_t * tag = (lbtru_tag_entry_t *)record; + + if (tag->name == NULL) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + else + { + g_strstrip(tag->name); + if (tag->name[0] == 0) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + } +} + +static void * lbtru_tag_copy_cb(void * destination, const void * source, size_t length _U_) +{ + const lbtru_tag_entry_t * src = (const lbtru_tag_entry_t *)source; + lbtru_tag_entry_t * dest = (lbtru_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->receiver_port_low = src->receiver_port_low; + dest->receiver_port_high = src->receiver_port_high; + return (dest); +} + +static void lbtru_tag_free_cb(void * record) +{ + lbtru_tag_entry_t * tag = (lbtru_tag_entry_t *)record; + + if (tag->name != NULL) + { + g_free(tag->name); + tag->name = NULL; + } +} + +static char * lbtru_tag_find(packet_info * pinfo) +{ + guint idx; + lbtru_tag_entry_t * tag = NULL; + + if (!lbtru_use_tag) + { + return (NULL); + } + + for (idx = 0; idx < lbtru_tag_count; ++idx) + { + tag = &(lbtru_tag_entry[idx]); + if (((pinfo->destport >= tag->source_port_low) + && (pinfo->destport <= tag->source_port_high) + && (pinfo->srcport >= tag->receiver_port_low) + && (pinfo->srcport <= tag->receiver_port_high)) + || ((pinfo->destport >= tag->receiver_port_low) + && (pinfo->destport <= tag->receiver_port_high) + && (pinfo->srcport >= tag->source_port_low) + && (pinfo->srcport <= tag->source_port_high))) + { + /* One of ours. */ + return tag->name; + } + } + return (NULL); +} + +/*----------------------------------------------------------------------------*/ +/* Handles of all types. */ +/*----------------------------------------------------------------------------*/ + +/* Dissector tree handles */ +static gint ett_lbtru = -1; +static gint ett_lbtru_channel = -1; +static gint ett_lbtru_hdr = -1; +static gint ett_lbtru_hdr_ver_type = -1; +static gint ett_lbtru_hdr_flags = -1; +static gint ett_lbtru_data = -1; +static gint ett_lbtru_sm = -1; +static gint ett_lbtru_nak = -1; +static gint ett_lbtru_nak_format = -1; +static gint ett_lbtru_nak_list = -1; +static gint ett_lbtru_ncf = -1; +static gint ett_lbtru_ncf_reason_format = -1; +static gint ett_lbtru_ncf_list = -1; +static gint ett_lbtru_ack = -1; +static gint ett_lbtru_opt = -1; +static gint ett_lbtru_opt_sid_flags = -1; +static gint ett_lbtru_opt_cid_flags = -1; +static gint ett_lbtru_transport = -1; +static gint ett_lbtru_transport_sqn = -1; + +/* Dissector field handles */ +static int hf_lbtru_channel = -1; +static int hf_lbtru_channel_id = -1; +static int hf_lbtru_channel_client = -1; +static int hf_lbtru_tag = -1; +static int hf_lbtru_hdr = -1; +static int hf_lbtru_hdr_ver_type = -1; +static int hf_lbtru_hdr_ver_type_ver = -1; +static int hf_lbtru_hdr_ver_type_type = -1; +static int hf_lbtru_hdr_next_hdr = -1; +static int hf_lbtru_hdr_res = -1; +static int hf_lbtru_hdr_flags = -1; +static int hf_lbtru_hdr_flags_syn = -1; +static int hf_lbtru_hdr_flags_rx = -1; +static int hf_lbtru_hdr_request = -1; +static int hf_lbtru_hdr_reason = -1; +static int hf_lbtru_data = -1; +static int hf_lbtru_data_sqn = -1; +static int hf_lbtru_data_trail_sqn = -1; +static int hf_lbtru_sm = -1; +static int hf_lbtru_sm_sqn = -1; +static int hf_lbtru_sm_lead_sqn = -1; +static int hf_lbtru_sm_trail_sqn = -1; +static int hf_lbtru_nak = -1; +static int hf_lbtru_nak_num = -1; +static int hf_lbtru_nak_format = -1; +static int hf_lbtru_nak_format_format = -1; +static int hf_lbtru_nak_list = -1; +static int hf_lbtru_nak_list_nak = -1; +static int hf_lbtru_ncf = -1; +static int hf_lbtru_ncf_trail_sqn = -1; +static int hf_lbtru_ncf_num = -1; +static int hf_lbtru_ncf_reserved = -1; +static int hf_lbtru_ncf_reason_format = -1; +static int hf_lbtru_ncf_reason = -1; +static int hf_lbtru_ncf_format = -1; +static int hf_lbtru_ncf_list = -1; +static int hf_lbtru_ncf_list_ncf = -1; +static int hf_lbtru_ack = -1; +static int hf_lbtru_ack_sqn = -1; +static int hf_lbtru_opt_sid = -1; +static int hf_lbtru_opt_sid_next_hdr = -1; +static int hf_lbtru_opt_sid_hdr_len = -1; +static int hf_lbtru_opt_sid_flags = -1; +static int hf_lbtru_opt_sid_flags_ignore = -1; +static int hf_lbtru_opt_sid_session_id = -1; +static int hf_lbtru_opt_cid = -1; +static int hf_lbtru_opt_cid_next_hdr = -1; +static int hf_lbtru_opt_cid_hdr_len = -1; +static int hf_lbtru_opt_cid_flags = -1; +static int hf_lbtru_opt_cid_flags_ignore = -1; +static int hf_lbtru_opt_cid_client_id = -1; +static int hf_lbtru_analysis = -1; +static int hf_lbtru_analysis_prev_frame = -1; +static int hf_lbtru_analysis_prev_data_frame = -1; +static int hf_lbtru_analysis_prev_sm_frame = -1; +static int hf_lbtru_analysis_prev_nak_frame = -1; +static int hf_lbtru_analysis_prev_ncf_frame = -1; +static int hf_lbtru_analysis_prev_ack_frame = -1; +static int hf_lbtru_analysis_prev_creq_frame = -1; +static int hf_lbtru_analysis_prev_rst_frame = -1; +static int hf_lbtru_analysis_next_frame = -1; +static int hf_lbtru_analysis_next_data_frame = -1; +static int hf_lbtru_analysis_next_sm_frame = -1; +static int hf_lbtru_analysis_next_nak_frame = -1; +static int hf_lbtru_analysis_next_ncf_frame = -1; +static int hf_lbtru_analysis_next_ack_frame = -1; +static int hf_lbtru_analysis_next_creq_frame = -1; +static int hf_lbtru_analysis_next_rst_frame = -1; +static int hf_lbtru_analysis_sqn = -1; +static int hf_lbtru_analysis_sqn_frame = -1; +static int hf_lbtru_analysis_data_retransmission = -1; +static int hf_lbtru_analysis_data_sqn_gap = -1; +static int hf_lbtru_analysis_data_ooo_gap = -1; +static int hf_lbtru_analysis_data_duplicate = -1; +static int hf_lbtru_analysis_sm_sqn_gap = -1; +static int hf_lbtru_analysis_sm_ooo_gap = -1; +static int hf_lbtru_analysis_sm_duplicate = -1; + +/* Expert info handles */ +static expert_field ei_lbtru_analysis_unknown_type = EI_INIT; +static expert_field ei_lbtru_analysis_unknown_header = EI_INIT; +static expert_field ei_lbtru_analysis_ack = EI_INIT; +static expert_field ei_lbtru_analysis_ncf = EI_INIT; +static expert_field ei_lbtru_analysis_ncf_ncf = EI_INIT; +static expert_field ei_lbtru_analysis_nak = EI_INIT; +static expert_field ei_lbtru_analysis_nak_nak = EI_INIT; +static expert_field ei_lbtru_analysis_sm = EI_INIT; +static expert_field ei_lbtru_analysis_sm_syn = EI_INIT; +static expert_field ei_lbtru_analysis_creq = EI_INIT; +static expert_field ei_lbtru_analysis_rst = EI_INIT; +static expert_field ei_lbtru_analysis_data_rx = EI_INIT; +static expert_field ei_lbtru_analysis_data_gap = EI_INIT; +static expert_field ei_lbtru_analysis_data_ooo = EI_INIT; +static expert_field ei_lbtru_analysis_data_dup = EI_INIT; +static expert_field ei_lbtru_analysis_sm_gap = EI_INIT; +static expert_field ei_lbtru_analysis_sm_ooo = EI_INIT; +static expert_field ei_lbtru_analysis_sm_dup = EI_INIT; + +/*----------------------------------------------------------------------------*/ +/* LBT-RU data payload dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtru_data_contents(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, const char * tag_name, guint64 channel) +{ + tvbuff_t * next_tvb; + + next_tvb = tvb_new_subset(tvb, offset, -1, -1); + return (lbmc_dissect_lbmc_packet(next_tvb, 0, pinfo, tree, tag_name, channel)); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RU ACK packet dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtru_ack(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + proto_tree * ack_tree = NULL; + proto_item * ack_item = NULL; + proto_item * ack = NULL; + + ack_item = proto_tree_add_item(tree, hf_lbtru_ack, tvb, offset, L_LBTRU_ACK_HDR_T, ENC_NA); + ack_tree = proto_item_add_subtree(ack_item, ett_lbtru_ack); + ack = proto_tree_add_item(ack_tree, hf_lbtru_ack_sqn, tvb, offset + O_LBTRU_ACK_HDR_T_ACK_SQN, L_LBTRU_ACK_HDR_T_ACK_SQN, ENC_BIG_ENDIAN); + expert_add_info(pinfo, ack, &ei_lbtru_analysis_ack); + return (L_LBTRU_ACK_HDR_T); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RU NAK confirmation packet dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtru_ncf_list(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, int ncf_count, int reason) +{ + proto_tree * ncf_tree = NULL; + proto_item * ncf_item = NULL; + lbm_uint32_t ncf; + int idx = 0; + int len = 0; + + ncf_item = proto_tree_add_item(tree, hf_lbtru_ncf_list, tvb, offset, -1, ENC_NA); + ncf_tree = proto_item_add_subtree(ncf_item, ett_lbtru_ncf_list); + + for (idx = 0; idx < ncf_count; idx++) + { + proto_item * sep_ncf_item = NULL; + + ncf = tvb_get_ntohl(tvb, offset + len); + sep_ncf_item = proto_tree_add_item(ncf_tree, hf_lbtru_ncf_list_ncf, tvb, offset + len, sizeof(lbm_uint32_t), ENC_BIG_ENDIAN); + if (lbtru_expert_separate_ncfs) + { + expert_add_info_format(pinfo, sep_ncf_item, &ei_lbtru_analysis_ncf_ncf, "NCF 0x%08x %s", ncf, val_to_str(reason, lbtru_ncf_reason, "Unknown (0x%02x)")); + } + len += (int)sizeof(lbm_uint32_t); + } + proto_item_set_len(ncf_item, len); + return (len); +} + +static int dissect_lbtru_ncf(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + int len_dissected; + guint16 num_ncfs; + guint8 reason_format; + proto_tree * ncf_tree = NULL; + proto_item * ncf_item = NULL; + proto_tree * rf_tree = NULL; + proto_item * rf_item = NULL; + + ncf_item = proto_tree_add_item(tree, hf_lbtru_ncf, tvb, offset, -1, ENC_NA); + ncf_tree = proto_item_add_subtree(ncf_item, ett_lbtru_ncf); + proto_tree_add_item(ncf_tree, hf_lbtru_ncf_trail_sqn, tvb, offset + O_LBTRU_NCF_HDR_T_TRAIL_SQN, L_LBTRU_NCF_HDR_T_TRAIL_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(ncf_tree, hf_lbtru_ncf_num, tvb, offset + O_LBTRU_NCF_HDR_T_NUM_NCFS, L_LBTRU_NCF_HDR_T_NUM_NCFS, ENC_BIG_ENDIAN); + proto_tree_add_item(ncf_tree, hf_lbtru_ncf_reserved, tvb, offset + O_LBTRU_NCF_HDR_T_RESERVED, L_LBTRU_NCF_HDR_T_RESERVED, ENC_BIG_ENDIAN); + rf_item = proto_tree_add_item(ncf_tree, hf_lbtru_ncf_reason_format, tvb, offset + O_LBTRU_NCF_HDR_T_REASON_FORMAT, L_LBTRU_NCF_HDR_T_REASON_FORMAT, ENC_NA); + rf_tree = proto_item_add_subtree(rf_item, ett_lbtru_ncf_reason_format); + proto_tree_add_item(rf_tree, hf_lbtru_ncf_reason, tvb, offset + O_LBTRU_NCF_HDR_T_REASON_FORMAT, L_LBTRU_NCF_HDR_T_REASON_FORMAT, ENC_BIG_ENDIAN); + proto_tree_add_item(rf_tree, hf_lbtru_ncf_format, tvb, offset + O_LBTRU_NCF_HDR_T_REASON_FORMAT, L_LBTRU_NCF_HDR_T_REASON_FORMAT, ENC_BIG_ENDIAN); + len_dissected = L_LBTRU_NCF_HDR_T; + num_ncfs = tvb_get_ntohs(tvb, offset + O_LBTRU_NCF_HDR_T_NUM_NCFS); + reason_format = tvb_get_guint8(tvb, offset + O_LBTRU_NCF_HDR_T_REASON_FORMAT); + len_dissected += dissect_lbtru_ncf_list(tvb, offset + L_LBTRU_NCF_HDR_T, pinfo, ncf_tree, num_ncfs, LBTRU_NCF_HDR_REASON(reason_format)); + if (!lbtru_expert_separate_ncfs) + { + expert_add_info_format(pinfo, ncf_item, &ei_lbtru_analysis_ncf, "NCF %s", val_to_str(LBTRU_NCF_HDR_REASON(reason_format), lbtru_ncf_reason, "Unknown (0x%02x)")); + } + proto_item_set_len(ncf_item, len_dissected); + return (len_dissected); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RU NAK packet dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtru_nak_list(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, int nak_count) +{ + proto_tree * nak_tree = NULL; + proto_item * nak_item = NULL; + int idx = 0; + int len = 0; + + nak_item = proto_tree_add_item(tree, hf_lbtru_nak_list, tvb, offset, -1, ENC_NA); + nak_tree = proto_item_add_subtree(nak_item, ett_lbtru_nak_list); + + for (idx = 0; idx < nak_count; idx++) + { + proto_item * sep_nak_item = NULL; + lbm_uint32_t nak; + + nak = tvb_get_ntohl(tvb, offset + len); + sep_nak_item = proto_tree_add_item(nak_tree, hf_lbtru_nak_list_nak, tvb, offset + len, sizeof(lbm_uint32_t), ENC_BIG_ENDIAN); + if (lbtru_expert_separate_naks) + { + expert_add_info_format(pinfo, sep_nak_item, &ei_lbtru_analysis_nak_nak, "NAK 0x%08x", nak); + } + len += (int)sizeof(lbm_uint32_t); + } + proto_item_set_len(nak_item, len); + return (len); +} + +static int dissect_lbtru_nak(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree) +{ + int len_dissected; + guint16 num_naks; + proto_tree * nak_tree = NULL; + proto_item * nak_item = NULL; + proto_tree * format_tree = NULL; + proto_item * format_item = NULL; + + nak_item = proto_tree_add_item(tree, hf_lbtru_nak, tvb, offset, -1, ENC_NA); + nak_tree = proto_item_add_subtree(nak_item, ett_lbtru_nak); + proto_tree_add_item(nak_tree, hf_lbtru_nak_num, tvb, offset + O_LBTRU_NAK_HDR_T_NUM_NAKS, L_LBTRU_NAK_HDR_T_NUM_NAKS, ENC_BIG_ENDIAN); + format_item = proto_tree_add_item(nak_tree, hf_lbtru_nak_format, tvb, offset + O_LBTRU_NAK_HDR_T_FORMAT, L_LBTRU_NAK_HDR_T_FORMAT, ENC_NA); + format_tree = proto_item_add_subtree(format_item, ett_lbtru_nak_format); + proto_tree_add_item(format_tree, hf_lbtru_nak_format_format, tvb, offset + O_LBTRU_NAK_HDR_T_FORMAT, L_LBTRU_NAK_HDR_T_FORMAT, ENC_BIG_ENDIAN); + len_dissected = L_LBTRU_NAK_HDR_T; + num_naks = tvb_get_ntohs(tvb, offset + O_LBTRU_NAK_HDR_T_NUM_NAKS); + len_dissected += dissect_lbtru_nak_list(tvb, offset + L_LBTRU_NAK_HDR_T, pinfo, nak_tree, num_naks); + if (!lbtru_expert_separate_naks) + { + expert_add_info(pinfo, nak_item, &ei_lbtru_analysis_nak); + } + proto_item_set_len(nak_item, len_dissected); + return (len_dissected); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RU session message packet dissection function. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtru_sm(tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * tree, int syn) +{ + proto_tree * sm_tree = NULL; + proto_item * sm_item = NULL; + proto_item * sm_sqn = NULL; + + sm_item = proto_tree_add_item(tree, hf_lbtru_sm, tvb, offset, L_LBTRU_SM_HDR_T, ENC_NA); + sm_tree = proto_item_add_subtree(sm_item, ett_lbtru_sm); + sm_sqn = proto_tree_add_item(sm_tree, hf_lbtru_sm_sqn, tvb, offset + O_LBTRU_SM_HDR_T_SM_SQN, L_LBTRU_SM_HDR_T_SM_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(sm_tree, hf_lbtru_sm_lead_sqn, tvb, offset + O_LBTRU_SM_HDR_T_LEAD_SQN, L_LBTRU_SM_HDR_T_LEAD_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(sm_tree, hf_lbtru_sm_trail_sqn, tvb, offset + O_LBTRU_SM_HDR_T_TRAIL_SQN, L_LBTRU_SM_HDR_T_TRAIL_SQN, ENC_BIG_ENDIAN); + if (syn) + { + expert_add_info(pinfo, sm_sqn, &ei_lbtru_analysis_sm_syn); + } + else + { + expert_add_info(pinfo, sm_sqn, &ei_lbtru_analysis_sm); + } + return (L_LBTRU_SM_HDR_T); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RU data packet dissection functions. */ +/*----------------------------------------------------------------------------*/ +static int dissect_lbtru_data(tvbuff_t * tvb, int offset, packet_info * pinfo _U_, proto_tree * tree) +{ + proto_tree * data_tree = NULL; + proto_item * data_item = NULL; + + data_item = proto_tree_add_item(tree, hf_lbtru_data, tvb, offset, L_LBTRU_DATA_HDR_T, ENC_NA); + data_tree = proto_item_add_subtree(data_item, ett_lbtru_data); + proto_tree_add_item(data_tree, hf_lbtru_data_sqn, tvb, offset + O_LBTRU_DATA_HDR_T_SQN, L_LBTRU_DATA_HDR_T_SQN, ENC_BIG_ENDIAN); + proto_tree_add_item(data_tree, hf_lbtru_data_trail_sqn, tvb, offset + O_LBTRU_DATA_HDR_T_TRAIL_SQN, L_LBTRU_DATA_HDR_T_TRAIL_SQN, ENC_BIG_ENDIAN); + return (L_LBTRU_DATA_HDR_T); +} + +/*----------------------------------------------------------------------------*/ +/* LBT-RU packet dissector. */ +/*----------------------------------------------------------------------------*/ +typedef struct +{ + proto_tree * tree; + tvbuff_t * tvb; + guint32 current_frame; +} lbtru_sqn_frame_list_callback_data_t; + +static gboolean dissect_lbtru_sqn_frame_list_callback(void * frame, void * user_data) +{ + lbtru_sqn_frame_list_callback_data_t * cb_data = (lbtru_sqn_frame_list_callback_data_t *) user_data; + proto_item * transport_item = NULL; + lbm_transport_sqn_frame_t * sqn_frame = (lbm_transport_sqn_frame_t *) frame; + + if (sqn_frame->frame != cb_data->current_frame) + { + if (sqn_frame->retransmission) + { + transport_item = proto_tree_add_uint_format_value(cb_data->tree, hf_lbtru_analysis_sqn_frame, cb_data->tvb, 0, 0, sqn_frame->frame, "%" G_GUINT32_FORMAT " (RX)", sqn_frame->frame); + } + else + { + transport_item = proto_tree_add_uint(cb_data->tree, hf_lbtru_analysis_sqn_frame, cb_data->tvb, 0, 0, sqn_frame->frame); + } + PROTO_ITEM_SET_GENERATED(transport_item); + } + return (FALSE); +} + +static int dissect_lbtru(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * user_data _U_) +{ + proto_tree * lbtru_tree = NULL; + proto_item * lbtru_item = NULL; + proto_tree * flags_tree = NULL; + proto_item * flags_item; + int ofs = 0; + guint32 session_id = 0; + char * tag_name = NULL; + int dissected_len; + int total_dissected_len = 0; + proto_tree * ver_type_tree = NULL; + proto_item * ver_type_item = NULL; + proto_tree * header_tree = NULL; + proto_item * header_item = NULL; + proto_tree * transport_tree = NULL; + proto_item * transport_item = NULL; + gboolean from_source = TRUE; + guint8 packet_type = 0; + address source_address; + address receiver_address; + guint16 source_port = 0; + guint16 receiver_port = 0; + lbtru_transport_t * transport = NULL; + lbtru_client_transport_t * client = NULL; + guint64 channel = LBM_CHANNEL_NO_CHANNEL; + proto_tree * channel_tree = NULL; + proto_item * channel_item = NULL; + guint8 ver_type = 0; + guint8 next_hdr = 0; + guint32 packet_sqn = 0; + guint16 flags_or_res = 0; + guint16 num_naks = 0; + guint16 num_ncfs = 0; + gboolean retransmission = FALSE; + proto_item * fld_item = NULL; + proto_item * ei_item = NULL; + proto_item * type_item = NULL; + proto_item * next_hdr_item = NULL; + + col_add_str(pinfo->cinfo, COL_PROTOCOL, "LBT-RU"); + if (lbtru_use_tag) + { + tag_name = lbtru_tag_find(pinfo); + } + col_clear(pinfo->cinfo, COL_INFO); + if (tag_name != NULL) + { + col_add_fstr(pinfo->cinfo, COL_INFO, "[Tag: %s]", tag_name); + } + col_set_fence(pinfo->cinfo, COL_INFO); + + ver_type = tvb_get_guint8(tvb, O_LBTRU_HDR_T_VER_TYPE); + next_hdr = tvb_get_guint8(tvb, O_LBTRU_HDR_T_NEXT_HDR); + flags_or_res = tvb_get_ntohs(tvb, O_LBTRU_HDR_T_FLAGS_OR_RES); + packet_type = LBTRU_HDR_TYPE(ver_type); + if (tag_name != NULL) + { + lbtru_item = proto_tree_add_protocol_format(tree, proto_lbtru, tvb, ofs, -1, "LBT-RU Protocol (Tag: %s): Version %u, Type %s", tag_name, + LBTRU_HDR_VER(ver_type), val_to_str(LBTRU_HDR_TYPE(ver_type), lbtru_packet_type, "Unknown (0x%02x)")); + } + else + { + lbtru_item = proto_tree_add_protocol_format(tree, proto_lbtru, tvb, ofs, -1, "LBT-RU Protocol: Version %u, Type %s", LBTRU_HDR_VER(ver_type), + val_to_str(LBTRU_HDR_TYPE(ver_type), lbtru_packet_type, "Unknown (0x%02x)")); + } + lbtru_tree = proto_item_add_subtree(lbtru_item, ett_lbtru); + if (tag_name != NULL) + { + proto_item * item = NULL; + item = proto_tree_add_string(lbtru_tree, hf_lbtru_tag, tvb, 0, 0, tag_name); + PROTO_ITEM_SET_GENERATED(item); + } + channel_item = proto_tree_add_item(lbtru_tree, hf_lbtru_channel, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(channel_item); + channel_tree = proto_item_add_subtree(channel_item, ett_lbtru_channel); + + header_item = proto_tree_add_item(lbtru_tree, hf_lbtru_hdr, tvb, 0, -1, ENC_NA); + header_tree = proto_item_add_subtree(header_item, ett_lbtru_hdr); + ver_type_item = proto_tree_add_none_format(header_tree, hf_lbtru_hdr_ver_type, tvb, O_LBTRU_HDR_T_VER_TYPE, L_LBTRU_HDR_T_VER_TYPE, "Version/Type: Version %u, Type %s", + LBTRU_HDR_VER(ver_type), val_to_str(LBTRU_HDR_TYPE(ver_type), lbtru_packet_type, "Unknown (0x%02x)")); + ver_type_tree = proto_item_add_subtree(ver_type_item, ett_lbtru_hdr_ver_type); + proto_tree_add_item(ver_type_tree, hf_lbtru_hdr_ver_type_ver, tvb, O_LBTRU_HDR_T_VER_TYPE, L_LBTRU_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + type_item = proto_tree_add_item(ver_type_tree, hf_lbtru_hdr_ver_type_type, tvb, O_LBTRU_HDR_T_VER_TYPE, L_LBTRU_HDR_T_VER_TYPE, ENC_BIG_ENDIAN); + next_hdr_item = proto_tree_add_item(header_tree, hf_lbtru_hdr_next_hdr, tvb, O_LBTRU_HDR_T_NEXT_HDR, L_LBTRU_HDR_T_NEXT_HDR, ENC_BIG_ENDIAN); + total_dissected_len = L_LBTRU_HDR_T_VER_TYPE + L_LBTRU_HDR_T_NEXT_HDR; + ofs = L_LBTRU_HDR_T_VER_TYPE + L_LBTRU_HDR_T_NEXT_HDR; + + switch (packet_type) + { + case LBTRU_PACKET_TYPE_DATA: + packet_sqn = tvb_get_ntohl(tvb, L_LBTRU_HDR_T + O_LBTRU_DATA_HDR_T_SQN); + if ((flags_or_res & LBTRU_RETRANSMISSION_FLAG) != 0) + { + retransmission = TRUE; + } + if (retransmission) + { + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "DATA(RX) sqn 0x%x", packet_sqn); + } + else + { + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "DATA sqn 0x%x", packet_sqn); + } + from_source = TRUE; + break; + case LBTRU_PACKET_TYPE_SM: + packet_sqn = tvb_get_ntohl(tvb, L_LBTRU_HDR_T + O_LBTRU_SM_HDR_T_SM_SQN); + if ((flags_or_res & LBTRU_SM_SYN_FLAG) != 0) + { + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "SM sqn 0x%x SYN", packet_sqn); + } + else + { + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "SM sqn 0x%x", packet_sqn); + } + from_source = TRUE; + break; + case LBTRU_PACKET_TYPE_NAK: + num_naks = tvb_get_ntohs(tvb, L_LBTRU_HDR_T + O_LBTRU_NAK_HDR_T_NUM_NAKS); + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "NAK %" G_GUINT16_FORMAT " naks", num_naks); + from_source = FALSE; + break; + case LBTRU_PACKET_TYPE_NCF: + num_ncfs = tvb_get_ntohs(tvb, L_LBTRU_HDR_T + O_LBTRU_NCF_HDR_T_NUM_NCFS); + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "NCF %" G_GUINT16_FORMAT " ncfs", num_ncfs); + from_source = TRUE; + break; + case LBTRU_PACKET_TYPE_ACK: + packet_sqn = tvb_get_ntohl(tvb, L_LBTRU_HDR_T + O_LBTRU_ACK_HDR_T_ACK_SQN); + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "ACK sqn 0x%x", packet_sqn); + from_source = FALSE; + break; + case LBTRU_PACKET_TYPE_CREQ: + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "CREQ %s", val_to_str(flags_or_res, lbtru_creq_request, "Unknown (0x%02x)")); + from_source = FALSE; + break; + case LBTRU_PACKET_TYPE_RST: + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "RST %s", val_to_str(flags_or_res, lbtru_rst_reason, "Unknown (0x%02x)")); + from_source = TRUE; + break; + default: + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "Unknown (0x%02x)", LBTRU_HDR_TYPE(ver_type)); + expert_add_info_format(pinfo, type_item, &ei_lbtru_analysis_unknown_type, "Unrecognized type 0x%02x", LBTRU_HDR_TYPE(ver_type)); + return (0); + break; + } + + /* Handle the flags_or_res field. */ + switch (packet_type) + { + case LBTRU_PACKET_TYPE_DATA: + flags_item = proto_tree_add_none_format(header_tree, hf_lbtru_hdr_flags, tvb, O_LBTRU_HDR_T_FLAGS_OR_RES, L_LBTRU_HDR_T_FLAGS_OR_RES, "Flags: 0x%04x", flags_or_res); + flags_tree = proto_item_add_subtree(flags_item, ett_lbtru_hdr_flags); + proto_tree_add_item(flags_tree, hf_lbtru_hdr_flags_rx, tvb, O_LBTRU_HDR_T_FLAGS_OR_RES, L_LBTRU_HDR_T_FLAGS_OR_RES, ENC_BIG_ENDIAN); + total_dissected_len += L_LBTRU_HDR_T_FLAGS_OR_RES; + ofs += L_LBTRU_HDR_T_FLAGS_OR_RES; + break; + case LBTRU_PACKET_TYPE_NAK: + case LBTRU_PACKET_TYPE_NCF: + case LBTRU_PACKET_TYPE_ACK: + proto_tree_add_item(header_tree, hf_lbtru_hdr_res, tvb, O_LBTRU_HDR_T_FLAGS_OR_RES, L_LBTRU_HDR_T_FLAGS_OR_RES, ENC_BIG_ENDIAN); + total_dissected_len += L_LBTRU_HDR_T_FLAGS_OR_RES; + ofs += L_LBTRU_HDR_T_FLAGS_OR_RES; + break; + case LBTRU_PACKET_TYPE_SM: + flags_item = proto_tree_add_none_format(header_tree, hf_lbtru_hdr_flags, tvb, O_LBTRU_HDR_T_FLAGS_OR_RES, L_LBTRU_HDR_T_FLAGS_OR_RES, "Flags: 0x%04x", flags_or_res); + flags_tree = proto_item_add_subtree(flags_item, ett_lbtru_hdr_flags); + proto_tree_add_item(flags_tree, hf_lbtru_hdr_flags_syn, tvb, O_LBTRU_HDR_T_FLAGS_OR_RES, L_LBTRU_HDR_T_FLAGS_OR_RES, ENC_BIG_ENDIAN); + total_dissected_len += L_LBTRU_HDR_T_FLAGS_OR_RES; + ofs += L_LBTRU_HDR_T_FLAGS_OR_RES; + break; + case LBTRU_PACKET_TYPE_CREQ: + ei_item = proto_tree_add_item(header_tree, hf_lbtru_hdr_request, tvb, O_LBTRU_HDR_T_FLAGS_OR_RES, L_LBTRU_HDR_T_FLAGS_OR_RES, ENC_BIG_ENDIAN); + expert_add_info_format(pinfo, ei_item, &ei_lbtru_analysis_creq, "CREQ %s", val_to_str(flags_or_res, lbtru_creq_request, "Unknown (0x%04x)")); + total_dissected_len += L_LBTRU_HDR_T_FLAGS_OR_RES; + ofs += L_LBTRU_HDR_T_FLAGS_OR_RES; + break; + case LBTRU_PACKET_TYPE_RST: + ei_item = proto_tree_add_item(header_tree, hf_lbtru_hdr_reason, tvb, O_LBTRU_HDR_T_FLAGS_OR_RES, L_LBTRU_HDR_T_FLAGS_OR_RES, ENC_BIG_ENDIAN); + expert_add_info_format(pinfo, ei_item, &ei_lbtru_analysis_rst, "RST %s", val_to_str(flags_or_res, lbtru_rst_reason, "Unknown (0x%04x)")); + break; + default: + break; + } + + /* Handle the packet-specific data */ + switch (LBTRU_HDR_TYPE(ver_type)) + { + case LBTRU_PACKET_TYPE_DATA: + dissected_len = dissect_lbtru_data(tvb, L_LBTRU_HDR_T, pinfo, lbtru_tree); + break; + case LBTRU_PACKET_TYPE_SM: + dissected_len = dissect_lbtru_sm(tvb, L_LBTRU_HDR_T, pinfo, lbtru_tree, (flags_or_res & LBTRU_SM_SYN_FLAG)); + break; + case LBTRU_PACKET_TYPE_NAK: + dissected_len = dissect_lbtru_nak(tvb, ofs, pinfo, lbtru_tree); + break; + case LBTRU_PACKET_TYPE_NCF: + dissected_len = dissect_lbtru_ncf(tvb, ofs, pinfo, lbtru_tree); + break; + case LBTRU_PACKET_TYPE_ACK: + dissected_len = dissect_lbtru_ack(tvb, ofs, pinfo, lbtru_tree); + break; + default: + dissected_len = 0; + break; + } + total_dissected_len += dissected_len; + ofs += dissected_len; + /* If we're doing sequence analysis, the tree goes here. */ + if (lbtru_sequence_analysis) + { + transport_item = proto_tree_add_item(lbtru_tree, hf_lbtru_analysis, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(transport_item); + transport_tree = proto_item_add_subtree(transport_item, ett_lbtru_transport); + } + while (next_hdr != LBTRU_NHDR_DATA) + { + proto_tree * opt_tree = NULL; + proto_item * opt_flags_item = NULL; + proto_tree * opt_flags_tree = NULL; + int hdrlen; + guint8 cur_next_hdr; + + cur_next_hdr = tvb_get_guint8(tvb, ofs + O_LBTRU_BASIC_OPT_T_NEXT_HDR); + hdrlen = (int)tvb_get_guint8(tvb, ofs + O_LBTRU_BASIC_OPT_T_HDR_LEN); + switch (next_hdr) + { + case LBTRU_NHDR_SID: + fld_item = proto_tree_add_item(lbtru_tree, hf_lbtru_opt_sid, tvb, ofs, L_LBTRU_BASIC_OPT_T + L_LBTRU_SID_OPT_T, ENC_NA); + opt_tree = proto_item_add_subtree(fld_item, ett_lbtru_opt); + next_hdr_item = proto_tree_add_item(opt_tree, hf_lbtru_opt_sid_next_hdr, tvb, ofs + O_LBTRU_BASIC_OPT_T_NEXT_HDR, L_LBTRU_BASIC_OPT_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbtru_opt_sid_hdr_len, tvb, ofs + O_LBTRU_BASIC_OPT_T_HDR_LEN, L_LBTRU_BASIC_OPT_T_HDR_LEN, ENC_BIG_ENDIAN); + opt_flags_item = proto_tree_add_item(opt_tree, hf_lbtru_opt_sid_flags, tvb, ofs + O_LBTRU_BASIC_OPT_T_RES, L_LBTRU_BASIC_OPT_T_RES, ENC_NA); + opt_flags_tree = proto_item_add_subtree(opt_flags_item, ett_lbtru_opt_sid_flags); + proto_tree_add_item(opt_flags_tree, hf_lbtru_opt_sid_flags_ignore, tvb, ofs + O_LBTRU_BASIC_OPT_T_RES, L_LBTRU_BASIC_OPT_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbtru_opt_sid_session_id, tvb, ofs + L_LBTRU_BASIC_OPT_T + O_LBTRU_SID_OPT_T_SESSION_ID, L_LBTRU_SID_OPT_T_SESSION_ID, ENC_BIG_ENDIAN); + session_id = tvb_get_ntohl(tvb, ofs + L_LBTRU_BASIC_OPT_T + O_LBTRU_SID_OPT_T_SESSION_ID); + break; + case LBTRU_NHDR_CID: + fld_item = proto_tree_add_item(lbtru_tree, hf_lbtru_opt_cid, tvb, ofs, L_LBTRU_BASIC_OPT_T + L_LBTRU_CID_OPT_T, ENC_NA); + opt_tree = proto_item_add_subtree(fld_item, ett_lbtru_opt); + next_hdr_item = proto_tree_add_item(opt_tree, hf_lbtru_opt_cid_next_hdr, tvb, ofs + O_LBTRU_BASIC_OPT_T_NEXT_HDR, L_LBTRU_BASIC_OPT_T_NEXT_HDR, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbtru_opt_cid_hdr_len, tvb, ofs + O_LBTRU_BASIC_OPT_T_HDR_LEN, L_LBTRU_BASIC_OPT_T_HDR_LEN, ENC_BIG_ENDIAN); + opt_flags_item = proto_tree_add_item(opt_tree, hf_lbtru_opt_cid_flags, tvb, ofs + O_LBTRU_BASIC_OPT_T_RES, L_LBTRU_BASIC_OPT_T_RES, ENC_NA); + opt_flags_tree = proto_item_add_subtree(opt_flags_item, ett_lbtru_opt_cid_flags); + proto_tree_add_item(opt_flags_tree, hf_lbtru_opt_cid_flags_ignore, tvb, ofs + O_LBTRU_BASIC_OPT_T_RES, L_LBTRU_BASIC_OPT_T_RES, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_lbtru_opt_cid_client_id, tvb, ofs + L_LBTRU_BASIC_OPT_T + O_LBTRU_CID_OPT_T_CLIENT_SID, L_LBTRU_CID_OPT_T_CLIENT_SID, ENC_BIG_ENDIAN); + break; + default: + expert_add_info_format(pinfo, next_hdr_item, &ei_lbtru_analysis_unknown_header, "Unrecognized header 0x%02x", next_hdr); + break; + } + next_hdr = cur_next_hdr; + ofs += hdrlen; + total_dissected_len += hdrlen; + } + + /* Find (or create) the transport and client entries */ + if (from_source) + { + COPY_ADDRESS_SHALLOW(&source_address, &(pinfo->src)); + source_port = pinfo->srcport; + COPY_ADDRESS_SHALLOW(&receiver_address, &(pinfo->dst)); + receiver_port = pinfo->destport; + } + else + { + COPY_ADDRESS_SHALLOW(&source_address, &(pinfo->dst)); + source_port = pinfo->destport; + COPY_ADDRESS_SHALLOW(&receiver_address, &(pinfo->src)); + receiver_port = pinfo->srcport; + } + if (pinfo->fd->flags.visited == 0) + { + transport = lbtru_transport_add(&source_address, source_port, session_id, pinfo->fd->num); + } + else + { + transport = lbtru_transport_find(&source_address, source_port, session_id, pinfo->fd->num); + } + if (transport != NULL) + { + if (pinfo->fd->flags.visited == 0) + { + client = lbtru_client_transport_add(transport, &receiver_address, receiver_port, pinfo->fd->num); + if (client != NULL) + { + if (lbtru_sequence_analysis) + { + lbtru_client_transport_frame_add(client, packet_type, pinfo->fd->num, packet_sqn, retransmission); + } + } + } + else + { + client = lbtru_client_transport_find(transport, &receiver_address, receiver_port, pinfo->fd->num); + } + } + + if (transport != NULL) + { + channel = transport->channel; + fld_item = proto_tree_add_uint64(channel_tree, hf_lbtru_channel_id, tvb, 0, 0, channel); + PROTO_ITEM_SET_GENERATED(fld_item); + if (client != NULL) + { + fld_item = proto_tree_add_uint(channel_tree, hf_lbtru_channel_client, tvb, 0, 0, client->id); + PROTO_ITEM_SET_GENERATED(fld_item); + } + } + + if ((packet_type == LBTRU_PACKET_TYPE_DATA) && (next_hdr == LBTRU_NHDR_DATA)) + { + total_dissected_len += dissect_lbtru_data_contents(tvb, ofs, pinfo, tree, tag_name, channel); + } + if (lbtru_sequence_analysis) + { + if ((transport != NULL) && (client != NULL)) + { + lbm_transport_frame_t * frame = NULL; + + /* Fill in the tree */ + frame = lbtru_client_transport_frame_find(client, pinfo->fd->num); + if (frame != NULL) + { + lbm_transport_sqn_t * sqn = NULL; + + if (frame->previous_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_prev_frame, tvb, 0, 0, frame->previous_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_next_frame, tvb, 0, 0, frame->next_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + switch (packet_type) + { + case LBTRU_PACKET_TYPE_DATA: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_prev_data_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_next_data_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + sqn = lbtru_client_transport_sqn_find(client, packet_type, packet_sqn); + if (sqn != NULL) + { + if (sqn->frame_count > 1) + { + proto_tree * frame_tree = NULL; + proto_item * frame_tree_item = NULL; + lbtru_sqn_frame_list_callback_data_t cb_data; + + frame_tree_item = proto_tree_add_item(transport_tree, hf_lbtru_analysis_sqn, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(frame_tree_item); + frame_tree = proto_item_add_subtree(frame_tree_item, ett_lbtru_transport_sqn); + cb_data.tree = frame_tree; + cb_data.tvb = tvb; + cb_data.current_frame = pinfo->fd->num; + wmem_tree_foreach(sqn->frame, dissect_lbtru_sqn_frame_list_callback, (void *) &cb_data); + } + } + if (frame->retransmission) + { + transport_item = proto_tree_add_boolean(transport_tree, hf_lbtru_analysis_data_retransmission, tvb, 0, 0, TRUE); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info(pinfo, transport_item, &ei_lbtru_analysis_data_rx); + } + if (frame->sqn_gap != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_data_sqn_gap, tvb, 0, 0, frame->sqn_gap); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info_format(pinfo, transport_item, &ei_lbtru_analysis_data_gap, "Data sequence gap (%" G_GUINT32_FORMAT ")", frame->sqn_gap); + + } + if (frame->ooo_gap != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_data_ooo_gap, tvb, 0, 0, frame->ooo_gap); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info_format(pinfo, transport_item, &ei_lbtru_analysis_data_ooo, "Data sequence out of order gap (%" G_GUINT32_FORMAT ")", frame->ooo_gap); + } + if (frame->duplicate) + { + transport_item = proto_tree_add_boolean(transport_tree, hf_lbtru_analysis_data_duplicate, tvb, 0, 0, TRUE); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info(pinfo, transport_item, &ei_lbtru_analysis_data_dup); + } + break; + case LBTRU_PACKET_TYPE_SM: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_prev_sm_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_next_sm_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + sqn = lbtru_client_transport_sqn_find(client, packet_type, packet_sqn); + if (sqn != NULL) + { + if (sqn->frame_count > 1) + { + proto_tree * frame_tree = NULL; + proto_item * frame_tree_item = NULL; + lbtru_sqn_frame_list_callback_data_t cb_data; + + frame_tree_item = proto_tree_add_item(transport_tree, hf_lbtru_analysis_sqn, tvb, 0, 0, ENC_NA); + PROTO_ITEM_SET_GENERATED(frame_tree_item); + frame_tree = proto_item_add_subtree(frame_tree_item, ett_lbtru_transport_sqn); + cb_data.tree = frame_tree; + cb_data.tvb = tvb; + cb_data.current_frame = pinfo->fd->num; + wmem_tree_foreach(sqn->frame, dissect_lbtru_sqn_frame_list_callback, (void *) &cb_data); + } + } + if (frame->sqn_gap != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_sm_sqn_gap, tvb, 0, 0, frame->sqn_gap); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info_format(pinfo, transport_item, &ei_lbtru_analysis_sm_gap, "SM sequence gap (%" G_GUINT32_FORMAT ")", frame->sqn_gap); + + } + if (frame->ooo_gap != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_sm_ooo_gap, tvb, 0, 0, frame->ooo_gap); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info_format(pinfo, transport_item, &ei_lbtru_analysis_sm_ooo, "SM sequence out of order gap (%" G_GUINT32_FORMAT ")", frame->ooo_gap); + } + if (frame->duplicate) + { + transport_item = proto_tree_add_boolean(transport_tree, hf_lbtru_analysis_sm_duplicate, tvb, 0, 0, TRUE); + PROTO_ITEM_SET_GENERATED(transport_item); + expert_add_info(pinfo, transport_item, &ei_lbtru_analysis_sm_dup); + } + break; + case LBTRU_PACKET_TYPE_NAK: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_prev_nak_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_next_nak_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + break; + case LBTRU_PACKET_TYPE_NCF: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_prev_ncf_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_next_ncf_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + break; + case LBTRU_PACKET_TYPE_ACK: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_prev_ack_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_next_ack_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + break; + case LBTRU_PACKET_TYPE_CREQ: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_prev_creq_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_next_creq_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + break; + case LBTRU_PACKET_TYPE_RST: + if (frame->previous_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_prev_rst_frame, tvb, 0, 0, frame->previous_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + if (frame->next_type_frame != 0) + { + transport_item = proto_tree_add_uint(transport_tree, hf_lbtru_analysis_next_rst_frame, tvb, 0, 0, frame->next_type_frame); + PROTO_ITEM_SET_GENERATED(transport_item); + } + break; + default: + break; + } + } + } + } + return (total_dissected_len); +} + +static gboolean test_lbtru_packet(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * user_data) +{ + gboolean valid_packet = FALSE; + + /* Must be a UDP packet. */ + if (pinfo->ptype != PT_UDP) + { + return (FALSE); + } + /* Destination address must be IPV4 and 4 bytes in length. */ + if ((pinfo->dst.type != AT_IPv4) || (pinfo->dst.len != 4)) + { + return (FALSE); + } + + if (lbtru_use_tag) + { + if (lbtru_tag_find(pinfo) != NULL) + { + valid_packet = TRUE; + } + } + else + { + /* + Source port must be in the source port range and destination port must be in the receiver port range, + or vice-versa. + */ + if (((pinfo->destport >= lbtru_source_port_low) + && (pinfo->destport <= lbtru_source_port_high) + && (pinfo->srcport >= lbtru_receiver_port_low) + && (pinfo->srcport <= lbtru_receiver_port_high)) + || ((pinfo->destport >= lbtru_receiver_port_low) + && (pinfo->destport <= lbtru_receiver_port_high) + && (pinfo->srcport >= lbtru_source_port_low) + && (pinfo->srcport <= lbtru_source_port_high))) + { + /* One of ours. */ + valid_packet = TRUE; + } + } + if (valid_packet) + { + dissect_lbtru(tvb, pinfo, tree, user_data); + return (TRUE); + } + /* Not one of ours. */ + return (FALSE); +} + +/* The registration hand-off routine */ +void proto_reg_handoff_lbtru(void) +{ + static gboolean already_registered = FALSE; + + if (!already_registered) + { + lbtru_dissector_handle = new_create_dissector_handle(dissect_lbtru, proto_lbtru); + dissector_add_uint("udp.port", 0, lbtru_dissector_handle); + heur_dissector_add("udp", test_lbtru_packet, proto_lbtru); + } + + /* Make sure the low source port is <= the high source port. If not, don't change them. */ + if (global_lbtru_source_port_low <= global_lbtru_source_port_high) + { + lbtru_source_port_low = global_lbtru_source_port_low; + lbtru_source_port_high = global_lbtru_source_port_high; + } + + /* Make sure the low receiver port is <= the high receiver port. If not, don't change them. */ + if (global_lbtru_receiver_port_low <= global_lbtru_receiver_port_high) + { + lbtru_receiver_port_low = global_lbtru_receiver_port_low; + lbtru_receiver_port_high = global_lbtru_receiver_port_high; + } + + lbtru_expert_separate_naks = global_lbtru_expert_separate_naks; + lbtru_expert_separate_ncfs = global_lbtru_expert_separate_ncfs; + + lbtru_sequence_analysis = global_lbtru_sequence_analysis; + + lbtru_use_tag = global_lbtru_use_tag; + + already_registered = TRUE; +} + +/* Register all the bits needed with the filtering engine */ +void proto_register_lbtru(void) +{ + static hf_register_info hf[] = + { + { &hf_lbtru_channel, + { "Channel", "lbtru.channel", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_channel_id, + { "Channel ID", "lbtru.channel.channel", FT_UINT64, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_channel_client, + { "Channel Client", "lbtru.channel.client", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_tag, + { "Tag", "lbtru.tag", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_hdr, + { "Header", "lbtru.hdr", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_hdr_ver_type, + { "Version/Type", "lbtru.hdr.ver_type", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_hdr_ver_type_ver, + { "Version", "lbtru.hdr.ver_type.ver", FT_UINT8, BASE_DEC, NULL, LBTRU_HDR_VER_VER_MASK, NULL, HFILL } }, + { &hf_lbtru_hdr_ver_type_type, + { "Type", "lbtru.hdr.ver_type.type", FT_UINT8, BASE_HEX, VALS(lbtru_packet_type), LBTRU_HDR_VER_TYPE_MASK, NULL, HFILL } }, + { &hf_lbtru_hdr_next_hdr, + { "Next Header", "lbtru.hdr.next_hdr", FT_UINT8, BASE_HEX, VALS(lbtru_next_header), 0x0, NULL, HFILL } }, + { &hf_lbtru_hdr_res, + { "Reserved", "lbtru.hdr.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_hdr_flags, + { "Flags", "lbtru.hdr.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_hdr_flags_rx, + { "Retransmission", "lbtru.hdr.flags.rx", FT_BOOLEAN, L_LBTRU_HDR_T_FLAGS_OR_RES * 8, TFS(&tfs_set_notset), LBTRU_RETRANSMISSION_FLAG, NULL, HFILL } }, + { &hf_lbtru_hdr_flags_syn, + { "SYN", "lbtru.hdr.flags.syn", FT_BOOLEAN, L_LBTRU_HDR_T_FLAGS_OR_RES * 8, TFS(&tfs_set_notset), LBTRU_SM_SYN_FLAG, NULL, HFILL } }, + { &hf_lbtru_hdr_request, + { "Request", "lbtru.hdr.request", FT_UINT16, BASE_HEX, VALS(lbtru_creq_request), 0x0, NULL, HFILL } }, + { &hf_lbtru_hdr_reason, + { "Reason", "lbtru.hdr.reason", FT_UINT16, BASE_HEX, VALS(lbtru_rst_reason), 0x0, NULL, HFILL } }, + { &hf_lbtru_data, + { "Data Header", "lbtru.data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_data_sqn, + { "Sequence Number", "lbtru.data.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_data_trail_sqn, + { "Trailing Edge Sequence Number", "lbtru.data.trail", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_sm, + { "Session Message Header", "lbtru.sm", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_sm_sqn, + { "Sequence Number", "lbtru.sm.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_sm_lead_sqn, + { "Leading Edge Sequence Number", "lbtru.sm.lead", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_sm_trail_sqn, + { "Trailing Edge Sequence Number", "lbtru.sm.trail", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_nak, + { "NAK Header", "lbtru.nak", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_nak_num, + { "Number of NAKs", "lbtru.nak.num", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_nak_format, + { "Format", "lbtru.nak.format", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_nak_format_format, + { "Format", "lbtru.nak.format.format", FT_UINT16, BASE_DEC, VALS(lbtru_nak_format), LBTRU_NAK_HDR_FORMAT_MASK, NULL, HFILL } }, + { &hf_lbtru_nak_list, + { "NAK List", "lbtru.nak.list", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_nak_list_nak, + { "NAK", "lbtru.nak.list.nak", FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ncf, + { "NAK Confirmation Header", "lbtru.ncf", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ncf_trail_sqn, + { "Trailing Edge Sequence Number", "lbtru.ncf.trail", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ncf_num, + { "Number of Individual NCFs", "lbtru.ncf.num", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ncf_reserved, + { "Reserved", "lbtru.ncf.reserved", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ncf_reason_format, + { "Reason/Format", "lbtru.ncf.reason_format", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ncf_reason, + { "Reason", "lbtru.ncf.reason_format.reason", FT_UINT8, BASE_HEX, VALS(lbtru_ncf_reason), LBTRU_NCF_HDR_REASON_MASK, NULL, HFILL } }, + { &hf_lbtru_ncf_format, + { "Format", "lbtru.ncf.reason_format.format", FT_UINT8, BASE_HEX, VALS(lbtru_ncf_format), LBTRU_NCF_HDR_FORMAT_MASK, NULL, HFILL } }, + { &hf_lbtru_ncf_list, + { "NCF List", "lbtru.ncf.list", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ncf_list_ncf, + { "NCF", "lbtru.ncf.list.ncf", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ack, + { "ACK Header", "lbtru.ack", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_ack_sqn, + { "ACK Sequence Number", "lbtru.ack.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_sid, + { "SID Option", "lbtru.opt_sid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_sid_next_hdr, + { "Next Header", "lbtru.opt_sid.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbtru_next_header), 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_sid_hdr_len, + { "Header Length", "lbtru.opt_sid.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_sid_flags, + { "Flags", "lbtru.opt_sid.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_sid_flags_ignore, + { "Ignore", "lbtru.opt_sid.flags.ignore", FT_BOOLEAN, L_LBTRU_BASIC_OPT_T_RES * 8, &(tfs_set_notset), LBTRU_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbtru_opt_sid_session_id, + { "Session ID", "lbtru.opt_sid.session_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_cid, + { "CID Option", "lbtru.opt_cid", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_cid_next_hdr, + { "Next Header", "lbtru.opt_cid.next_hdr", FT_UINT8, BASE_DEC_HEX, VALS(lbtru_next_header), 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_cid_hdr_len, + { "Header Length", "lbtru.opt_cid.hdr_len", FT_UINT8, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_cid_flags, + { "Flags", "lbtru.opt_cid.flags", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_opt_cid_flags_ignore, + { "Ignore", "lbtru.opt_cid.flags.ignore", FT_BOOLEAN, L_LBTRU_BASIC_OPT_T_RES * 8, &(tfs_set_notset), LBTRU_OPT_IGNORE, NULL, HFILL } }, + { &hf_lbtru_opt_cid_client_id, + { "Client ID", "lbtru.opt_cid.client_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis, + { "Transport Analysis", "lbtru.analysis", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_prev_frame, + { "Previous Transport Frame", "lbtru.analysis.prev_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_prev_data_frame, + { "Previous Transport DATA Frame", "lbtru.analysis.prev_data_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_prev_sm_frame, + { "Previous Transport SM Frame", "lbtru.analysis.prev_sm_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_prev_nak_frame, + { "Previous Transport NAK Frame", "lbtru.analysis.prev_nak_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_prev_ncf_frame, + { "Previous Transport NCF Frame", "lbtru.analysis.prev_ncf_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_prev_ack_frame, + { "Previous Transport ACK Frame", "lbtru.analysis.prev_ack_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_prev_creq_frame, + { "Previous Transport CREQ Frame", "lbtru.analysis.prev_creq_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_prev_rst_frame, + { "Previous Transport RST Frame", "lbtru.analysis.prev_rst_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_next_frame, + { "Next Transport Frame", "lbtru.analysis.next_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_next_data_frame, + { "Next Transport DATA Frame", "lbtru.analysis.next_data_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_next_sm_frame, + { "Next Transport SM Frame", "lbtru.analysis.next_sm_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_next_nak_frame, + { "Next Transport NAK Frame", "lbtru.analysis.next_nak_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_next_ncf_frame, + { "Next Transport NCF Frame", "lbtru.analysis.next_ncf_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_next_ack_frame, + { "Next Transport ACK Frame", "lbtru.analysis.next_ack_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_next_creq_frame, + { "Next Transport CREQ Frame", "lbtru.analysis.next_creq_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_next_rst_frame, + { "Next Transport RST Frame", "lbtru.analysis.next_rst_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_sqn, + { "SQN Also in", "lbtru.analysis.sqn", FT_NONE, BASE_NONE, NULL, 0x0, "Sequence number also appears in these frames", HFILL } }, + { &hf_lbtru_analysis_sqn_frame, + { "Frame", "lbtru.analysis.sqn.frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_data_retransmission, + { "Frame is a Data Retransmission", "lbtru.analysis.data_retransmission", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_data_sqn_gap, + { "Gap in Data Sequence", "lbtru.analysis.data_sqn_gap", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_data_ooo_gap, + { "Data Sequence Out of Order Gap", "lbtru.analysis.data_ooo_gap", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_data_duplicate, + { "Duplicate Data Frame", "lbtru.analysis.data_duplicate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_sm_sqn_gap, + { "Gap in SM Sequence", "lbtru.analysis.sm_sqn_gap", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_sm_ooo_gap, + { "SM Sequence Out of Order Gap", "lbtru.analysis.sm_ooo_gap", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_lbtru_analysis_sm_duplicate, + { "Duplicate SM Frame", "lbtru.analysis.sm_duplicate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + }; + static gint * ett[] = + { + &ett_lbtru, + &ett_lbtru_channel, + &ett_lbtru_hdr, + &ett_lbtru_hdr_ver_type, + &ett_lbtru_hdr_flags, + &ett_lbtru_data, + &ett_lbtru_sm, + &ett_lbtru_nak, + &ett_lbtru_nak_format, + &ett_lbtru_nak_list, + &ett_lbtru_ncf, + &ett_lbtru_ncf_reason_format, + &ett_lbtru_ncf_list, + &ett_lbtru_ack, + &ett_lbtru_opt, + &ett_lbtru_opt_sid_flags, + &ett_lbtru_opt_cid_flags, + &ett_lbtru_transport, + &ett_lbtru_transport_sqn, + }; + static ei_register_info ei[] = + { + { &ei_lbtru_analysis_unknown_type, { "lbtru.analysis.unknown_type", PI_MALFORMED, PI_ERROR, "Unrecognized type", EXPFILL } }, + { &ei_lbtru_analysis_unknown_header, { "lbtru.analysis.unknown_header", PI_MALFORMED, PI_ERROR, "Unrecognized header", EXPFILL } }, + { &ei_lbtru_analysis_ack, { "lbtru.analysis.ack", PI_SEQUENCE, PI_CHAT, "ACK", EXPFILL } }, + { &ei_lbtru_analysis_ncf, { "lbtru.analysis.ncf", PI_SEQUENCE, PI_NOTE, "NCF", EXPFILL } }, + { &ei_lbtru_analysis_ncf_ncf, { "lbtru.analysis.ncf.ncf", PI_SEQUENCE, PI_NOTE, "NCF", EXPFILL } }, + { &ei_lbtru_analysis_nak, { "lbtru.analysis.nak", PI_SEQUENCE, PI_WARN, "NAK", EXPFILL } }, + { &ei_lbtru_analysis_nak_nak, { "lbtru.analysis.nak.nak", PI_SEQUENCE, PI_WARN, "NAK", EXPFILL } }, + { &ei_lbtru_analysis_sm, { "lbtru.analysis.sm", PI_SEQUENCE, PI_CHAT, "SM", EXPFILL } }, + { &ei_lbtru_analysis_sm_syn, { "lbtru.analysis.sm.syn", PI_SEQUENCE, PI_CHAT, "SM SYN", EXPFILL } }, + { &ei_lbtru_analysis_creq, { "lbtru.analysis.creq", PI_SEQUENCE, PI_CHAT, "Connection REQuest", EXPFILL } }, + { &ei_lbtru_analysis_rst, { "lbtru.analysis.rst", PI_SEQUENCE, PI_CHAT, "ReSeT", EXPFILL } }, + { &ei_lbtru_analysis_data_rx, { "lbtru.analysis.data.rx", PI_SEQUENCE, PI_NOTE, "Data retransmission", EXPFILL } }, + { &ei_lbtru_analysis_data_gap, { "lbtru.analysis.data.gap", PI_SEQUENCE, PI_NOTE, "Data sequence gap", EXPFILL } }, + { &ei_lbtru_analysis_data_ooo, { "lbtru.analysis.data.ooo", PI_SEQUENCE, PI_NOTE, "Data sequence out of order", EXPFILL } }, + { &ei_lbtru_analysis_data_dup, { "lbtru.analysis.data.dup", PI_SEQUENCE, PI_NOTE, "Duplicate data", EXPFILL } }, + { &ei_lbtru_analysis_sm_gap, { "lbtru.analysis.sm.gap", PI_SEQUENCE, PI_NOTE, "SM sequence gap", EXPFILL } }, + { &ei_lbtru_analysis_sm_ooo, { "lbtru.analysis.sm.ooo", PI_SEQUENCE, PI_NOTE, "SM sequence out of order", EXPFILL } }, + { &ei_lbtru_analysis_sm_dup, { "lbtru.analysis.sm.dup", PI_SEQUENCE, PI_NOTE, "Duplicate SM", EXPFILL } }, + }; + module_t * lbtru_module; + uat_t * tag_uat; + expert_module_t * expert_lbtru; + + proto_lbtru = proto_register_protocol("LBT Reliable Unicast Protocol", + "LBT-RU", "lbtru"); + + proto_register_field_array(proto_lbtru, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_lbtru = expert_register_protocol(proto_lbtru); + expert_register_field_array(expert_lbtru, ei, array_length(ei)); + + lbtru_module = prefs_register_protocol_subtree("29West", proto_lbtru, proto_reg_handoff_lbtru); + prefs_register_uint_preference(lbtru_module, + "source_port_low", + "Source port range low (default " MAKESTRING(LBTRU_DEFAULT_SOURCE_PORT_LOW)")", + "Set the low end of the LBT-RU source UDP port range (context transport_lbtru_port_low)", + 10, + &global_lbtru_source_port_low); + + prefs_register_uint_preference(lbtru_module, + "source_port_high", + "Source port range high (default " MAKESTRING(LBTRU_DEFAULT_SOURCE_PORT_HIGH)")", + "Set the high end of the LBT-RU source UDP port range (context transport_lbtru_port_high)", + 10, + &global_lbtru_source_port_high); + + prefs_register_uint_preference(lbtru_module, + "receiver_port_low", + "Receiver port range low (default " MAKESTRING(LBTRU_DEFAULT_RECEIVER_PORT_LOW)")", + "Set the low end of the LBT-RU receiver UDP port range (receiver transport_lbtru_port_low)", + 10, + &global_lbtru_receiver_port_low); + + prefs_register_uint_preference(lbtru_module, + "receiver_port_high", + "Receiver port range high (default " MAKESTRING(LBTRU_DEFAULT_RECEIVER_PORT_HIGH)")", + "Set the high end of the LBT-RU receiver UDP port range (receiver transport_lbtru_port_high)", + 10, + &global_lbtru_receiver_port_high); + + lbtru_expert_separate_naks = global_lbtru_expert_separate_naks; + prefs_register_bool_preference(lbtru_module, + "expert_separate_naks", + "Separate NAKs in Expert Info", + "Separate multiple NAKs from a single packet into distinct Expert Info entries", + &global_lbtru_expert_separate_naks); + lbtru_expert_separate_ncfs = global_lbtru_expert_separate_ncfs; + prefs_register_bool_preference(lbtru_module, + "expert_separate_ncfs", + "Separate NCFs in Expert Info", + "Separate multiple NCFs from a single packet into distinct Expert Info entries", + &global_lbtru_expert_separate_ncfs); + + lbtru_sequence_analysis = global_lbtru_sequence_analysis; + prefs_register_bool_preference(lbtru_module, + "sequence_analysis", + "Perform Sequence Number Analysis", + "Perform analysis on LBT-RU sequence numbers to determine out-of-order, gaps, loss, etc", + &global_lbtru_sequence_analysis); + + prefs_register_bool_preference(lbtru_module, + "use_lbtru_domain", + "Use LBT-RU tag table", + "Use table of LBT-RU tags to decode the packet instead of above values", + &global_lbtru_use_tag); + tag_uat = uat_new("LBT-RU tag definitions", + sizeof(lbtru_tag_entry_t), + "lbtru_domains", + TRUE, + (void * *)&lbtru_tag_entry, + &lbtru_tag_count, + UAT_AFFECTS_DISSECTION, + NULL, + lbtru_tag_copy_cb, + lbtru_tag_update_cb, + lbtru_tag_free_cb, + NULL, + lbtru_tag_array); + prefs_register_uat_preference(lbtru_module, + "tnw_lbtru_tags", + "LBT-RU Tags", + "A table to define LBT-RU tags", + tag_uat); +} + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbtru.h b/epan/dissectors/packet-lbtru.h new file mode 100644 index 0000000000..e469d4a059 --- /dev/null +++ b/epan/dissectors/packet-lbtru.h @@ -0,0 +1,82 @@ +/* packet-lbtru.h + * Routines for LBT-RU Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef PACKET_LBTRU_H_INCLUDED +#define PACKET_LBTRU_H_INCLUDED + +#include "config.h" +#include +#include +#include +#include +#include "packet-lbm.h" + +typedef struct +{ + address source_address; + guint16 source_port; + guint32 session_id; + guint64 channel; + guint32 next_client_id; + wmem_list_t * client_list; +} lbtru_transport_t; + +typedef struct +{ + address receiver_address; + guint16 receiver_port; + guint32 id; + lbtru_transport_t * transport; + wmem_tree_t * frame; + lbm_transport_frame_t * last_frame; + lbm_transport_frame_t * last_data_frame; + lbm_transport_frame_t * last_sm_frame; + lbm_transport_frame_t * last_nak_frame; + lbm_transport_frame_t * last_ncf_frame; + lbm_transport_frame_t * last_ack_frame; + lbm_transport_frame_t * last_creq_frame; + lbm_transport_frame_t * last_rst_frame; + wmem_tree_t * data_sqn; + wmem_tree_t * sm_sqn; + guint32 data_high_sqn; + guint32 sm_high_sqn; +} lbtru_client_transport_t; + +lbtru_transport_t * lbtru_transport_add(const address * source_address, guint16 source_port, guint32 session_id, guint32 frame); +char * lbtru_transport_source_string(const address * source_address, guint16 source_port, guint32 session_id); + +#endif + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbttcp.c b/epan/dissectors/packet-lbttcp.c new file mode 100644 index 0000000000..2c53bd929a --- /dev/null +++ b/epan/dissectors/packet-lbttcp.c @@ -0,0 +1,844 @@ +/* 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 + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "packet-lbm.h" +#include "packet-lbttcp.h" + +/* 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 = { AT_NONE, -1, 0, NULL }; + +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, PT_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); + SE_COPY_ADDRESS(&(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, PT_TCP, source_port, 0, 0); + if (conv == NULL) + { + conv = conversation_new(frame, source_address, &lbttcp_null_address, PT_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, PT_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); + SE_COPY_ADDRESS(&(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, PT_TCP, transport->source_port, receiver_port, 0); + if (client_conv == NULL) + { + client_conv = conversation_new(frame, &(transport->source_address), receiver_address, PT_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:%" G_GUINT16_FORMAT, address_to_str(wmem_packet_scope(), source_address), source_port); + } + else + { + bufptr = wmem_strdup_printf(wmem_file_scope(), "TCP:%s:%" G_GUINT16_FORMAT ":%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(0, source_address, &lbttcp_null_address, PT_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(0, source_address, &lbttcp_null_address, PT_TCP, source_port, 0, 0); + if (conv == NULL) + { + conv = conversation_new(0, source_address, &lbttcp_null_address, PT_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 void lbttcp_tag_update_cb(void * record, const char * * error_string) +{ + lbttcp_tag_entry_t * tag = (lbttcp_tag_entry_t *)record; + + if (tag->name == NULL) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + else + { + g_strstrip(tag->name); + if (tag->name[0] == 0) + { + *error_string = g_strdup_printf("Tag name can't be empty"); + } + } +} + +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) +{ + 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->fd->num); + if (transport == NULL) + { + /* See if we know about a SID */ + if (lbttcp_transport_sid_find(&source_address, srcport, pinfo->fd->num, &sid)) + { + transport = lbttcp_transport_find(&source_address, srcport, sid, pinfo->fd->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->fd->num); + if (client == NULL) + { + /* No - add it. */ + client = lbttcp_client_transport_add(transport, &client_address, clntport, pinfo->fd->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->fd->num); + if (transport != NULL) + { + channel = transport->channel; + client = lbttcp_client_transport_add(transport, &client_address, clntport, pinfo->fd->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); +} + +/* The registration hand-off routine */ +void proto_reg_handoff_lbttcp(void) +{ + static gboolean already_registered = FALSE; + + if (!already_registered) + { + lbttcp_dissector_handle = new_create_dissector_handle(dissect_lbttcp, proto_lbttcp); + dissector_add_uint("tcp.port", 0, lbttcp_dissector_handle); + heur_dissector_add("tcp", test_lbttcp_packet, proto_lbttcp); + } + + /* 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; +} + +/* 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_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, + lbttcp_tag_array); + prefs_register_uat_preference(lbttcp_module, + "tnw_lbttcp_tags", + "LBT-TCP Tags", + "A table to define LBT-TCP tags", + tag_uat); +} + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ diff --git a/epan/dissectors/packet-lbttcp.h b/epan/dissectors/packet-lbttcp.h new file mode 100644 index 0000000000..63fd878c27 --- /dev/null +++ b/epan/dissectors/packet-lbttcp.h @@ -0,0 +1,70 @@ +/* packet-lbttcp.h + * Routines for LBM TCP Packet dissection + * + * Copyright (c) 2005-2014 Informatica Corporation. All Rights Reserved. + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef PACKET_LBTTCP_H_INCLUDED +#define PACKET_LBTTCP_H_INCLUDED + +#include "config.h" +#include +#include +#include + +typedef struct +{ + address source_address; + guint16 source_port; + guint32 session_id; + guint64 channel; + guint32 next_client_id; + wmem_list_t * client_list; +} lbttcp_transport_t; + +typedef struct +{ + address receiver_address; + guint16 receiver_port; + guint32 id; + lbttcp_transport_t * transport; +} lbttcp_client_transport_t; + +lbttcp_transport_t * lbttcp_transport_find(const address * source_address, guint16 source_port, guint32 session_id, guint32 frame); +lbttcp_transport_t * lbttcp_transport_add(const address * source_address, guint16 source_port, guint32 session_id, guint32 frame); +char * lbttcp_transport_source_string(const address * source_address, guint16 source_port, guint32 session_id); +gboolean lbttcp_transport_sid_find(const address * source_address, guint16 source_port, guint32 frame, guint32 * session_id); +void lbttcp_transport_sid_add(const address * source_address, guint16 source_port, guint32 frame, guint32 session_id); + +#endif + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=4 expandtab: + * :indentSize=4:tabSize=4:noTabs=true: + */ -- cgit v1.2.3