/* Routines for LTE RLC disassembly

 *

 * Martin Mathieson

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/expert.h>

#include <epan/prefs.h>

#include <epan/tap.h>

#include <epan/proto_data.h>

#include <epan/tfs.h>

#include <wsutil/array.h>

#include "packet-mac-lte.h"

#include "packet-rlc-lte.h"

#include "packet-rlc-3gpp-common.h"

#include "packet-pdcp-lte.h"

/* Described in:

 * 3GPP TS 36.322 Evolved Universal Terrestrial Radio Access (E-UTRA)

 * Radio Link Control (RLC) Protocol specification v14.0.0

 */

/* TODO:

   - add intermediate results to segments leading to final reassembly

   - use multiple active rlc_channel_reassembly_info's per channel

   - sequence analysis gets confused when we change cells and skip back

     to SN 0. Maybe add cell-id to context and add to channel/result key?

*/

void proto_register_rlc_lte(void);

void proto_reg_handoff_rlc_lte(void);

/********************************/

/* Preference settings          */

#define SEQUENCE_ANALYSIS_MAC_ONLY 1

#define SEQUENCE_ANALYSIS_RLC_ONLY 2

/* By default do try to analyse the sequence of messages for AM/UM channels

   using MAC PDUs */

static int global_rlc_lte_am_sequence_analysis = SEQUENCE_ANALYSIS_MAC_ONLY;

static int global_rlc_lte_um_sequence_analysis = SEQUENCE_ANALYSIS_MAC_ONLY;

/* By default do call PDCP/RRC dissectors for SDU data */

static bool global_rlc_lte_call_pdcp_for_srb = true;

enum pdcp_for_drb { PDCP_drb_off, PDCP_drb_SN_7, PDCP_drb_SN_12, PDCP_drb_SN_signalled, PDCP_drb_SN_15, PDCP_drb_SN_18};

static const enum_val_t pdcp_drb_col_vals[] = {

    {"pdcp-drb-off",           "Off",                 PDCP_drb_off},

    {"pdcp-drb-sn-7",          "7-bit SN",            PDCP_drb_SN_7},

    {"pdcp-drb-sn-12",         "12-bit SN",           PDCP_drb_SN_12},

    {"pdcp-drb-sn-15",         "15-bit SN",           PDCP_drb_SN_15},

    {"pdcp-drb-sn-18",         "18-bit SN",           PDCP_drb_SN_18},

    {"pdcp-drb-sn-signalling", "Use signalled value", PDCP_drb_SN_signalled},

    {NULL, NULL, -1}

};

static int global_rlc_lte_call_pdcp_for_drb = (int)PDCP_drb_SN_signalled;

static bool global_rlc_lte_call_rrc_for_ccch = true;

static bool global_rlc_lte_call_rrc_for_mcch;

static bool global_rlc_lte_call_ip_for_mtch;

/* Preference to expect RLC headers without payloads */

static bool global_rlc_lte_headers_expected;

/* Re-assembly of segments */

static bool global_rlc_lte_reassembly = true;

/* Tree storing UE related parameters */

#define NO_EXT_LI 0x0

#define UL_EXT_LI 0x1

#define DL_EXT_LI 0x2

typedef struct rlc_ue_parameters {

    uint32_t id;

    uint8_t ext_li_field;

    uint8_t pdcp_sn_bits;

} rlc_ue_parameters;

static wmem_tree_t *ue_parameters_tree;

/**************************************************/

/* Initialize the protocol and registered fields. */

static int proto_rlc_lte;

static int proto_mac_lte;

static int proto_pdcp_lte;

static dissector_handle_t pdcp_lte_handle;

static dissector_handle_t ip_handle;

static dissector_handle_t lte_rrc_mcch;

static dissector_handle_t lte_rrc_ul_ccch;

static dissector_handle_t lte_rrc_dl_ccch;

static dissector_handle_t lte_rrc_bcch_bch;

static dissector_handle_t lte_rrc_bcch_dl_sch;

static dissector_handle_t lte_rrc_pcch;

static dissector_handle_t lte_rrc_ul_ccch_nb;

static dissector_handle_t lte_rrc_dl_ccch_nb;

static dissector_handle_t lte_rrc_bcch_bch_nb;

static dissector_handle_t lte_rrc_bcch_dl_sch_nb;

static dissector_handle_t lte_rrc_pcch_nb;

static int rlc_lte_tap;

/* Decoding context */

static int hf_rlc_lte_context;

static int hf_rlc_lte_context_mode;

static int hf_rlc_lte_context_direction;

static int hf_rlc_lte_context_priority;

static int hf_rlc_lte_context_ueid;

static int hf_rlc_lte_context_channel_type;

static int hf_rlc_lte_context_channel_id;

static int hf_rlc_lte_context_pdu_length;

static int hf_rlc_lte_context_um_sn_length;

static int hf_rlc_lte_context_am_sn_length;

/* Transparent mode fields */

static int hf_rlc_lte_tm;

static int hf_rlc_lte_tm_data;

/* Unacknowledged mode fields */

static int hf_rlc_lte_um;

static int hf_rlc_lte_um_header;

static int hf_rlc_lte_um_fi;

static int hf_rlc_lte_um_fixed_e;

static int hf_rlc_lte_um_sn;

static int hf_rlc_lte_um_fixed_reserved;

static int hf_rlc_lte_um_data;

static int hf_rlc_lte_extension_part;

/* Extended header (common to UM and AM) */

static int hf_rlc_lte_extension_e;

static int hf_rlc_lte_extension_li;

static int hf_rlc_lte_extension_padding;

/* Acknowledged mode fields */

static int hf_rlc_lte_am;

static int hf_rlc_lte_am_header;

static int hf_rlc_lte_am_data_control;

static int hf_rlc_lte_am_rf;

static int hf_rlc_lte_am_p;

static int hf_rlc_lte_am_fi;

static int hf_rlc_lte_am_fixed_e;

static int hf_rlc_lte_am_fixed_sn;

static int hf_rlc_lte_am_fixed_reserved;

static int hf_rlc_lte_am_segment_lsf16;

static int hf_rlc_lte_am_fixed_reserved2;

static int hf_rlc_lte_am_fixed_sn16;

static int hf_rlc_lte_am_segment_lsf;

static int hf_rlc_lte_am_segment_so;

static int hf_rlc_lte_am_segment_so16;

static int hf_rlc_lte_am_data;

/* Control fields */

static int hf_rlc_lte_am_cpt;

static int hf_rlc_lte_am_ack_sn;

static int hf_rlc_lte_am_e1;

static int hf_rlc_lte_am_e2;

static int hf_rlc_lte_am_nack_sn;

static int hf_rlc_lte_am_nacks;

static int hf_rlc_lte_am_so_start;

static int hf_rlc_lte_am_so_end;

static int hf_rlc_lte_predefined_pdu;

static int hf_rlc_lte_header_only;

/* Sequence Analysis */

static int hf_rlc_lte_sequence_analysis;

static int hf_rlc_lte_sequence_analysis_ok;

static int hf_rlc_lte_sequence_analysis_previous_frame;

static int hf_rlc_lte_sequence_analysis_next_frame;

static int hf_rlc_lte_sequence_analysis_expected_sn;

static int hf_rlc_lte_sequence_analysis_framing_info_correct;

static int hf_rlc_lte_sequence_analysis_mac_retx;

static int hf_rlc_lte_sequence_analysis_retx;

static int hf_rlc_lte_sequence_analysis_repeated;

static int hf_rlc_lte_sequence_analysis_skipped;

static int hf_rlc_lte_sequence_analysis_repeated_nack;

static int hf_rlc_lte_sequence_analysis_repeated_nack_original_frame;

static int hf_rlc_lte_sequence_analysis_ack_out_of_range;

static int hf_rlc_lte_sequence_analysis_ack_out_of_range_opposite_frame;

/* Reassembly */

static int hf_rlc_lte_reassembly_source;

static int hf_rlc_lte_reassembly_source_number_of_segments;

static int hf_rlc_lte_reassembly_source_total_length;

static int hf_rlc_lte_reassembly_source_segment;

static int hf_rlc_lte_reassembly_source_segment_sn;

static int hf_rlc_lte_reassembly_source_segment_framenum;

static int hf_rlc_lte_reassembly_source_segment_length;

/* Subtrees. */

static int ett_rlc_lte;

static int ett_rlc_lte_context;

static int ett_rlc_lte_um_header;

static int ett_rlc_lte_am_header;

static int ett_rlc_lte_extension_part;

static int ett_rlc_lte_sequence_analysis;

static int ett_rlc_lte_reassembly_source;

static int ett_rlc_lte_reassembly_source_segment;

static expert_field ei_rlc_lte_context_mode;

static expert_field ei_rlc_lte_am_nack_sn;

static expert_field ei_rlc_lte_am_nack_sn_ahead_ack;

static expert_field ei_rlc_lte_um_sn_repeated;

static expert_field ei_rlc_lte_am_nack_sn_ack_same;

static expert_field ei_rlc_lte_am_cpt;

static expert_field ei_rlc_lte_am_data_no_data;

static expert_field ei_rlc_lte_sequence_analysis_last_segment_complete;

static expert_field ei_rlc_lte_sequence_analysis_mac_retx;

static expert_field ei_rlc_lte_am_nack_sn_partial;

static expert_field ei_rlc_lte_sequence_analysis_repeated_nack;

static expert_field ei_rlc_lte_bytes_after_status_pdu_complete;

static expert_field ei_rlc_lte_sequence_analysis_repeated;

static expert_field ei_rlc_lte_wrong_sequence_number;

static expert_field ei_rlc_lte_sequence_analysis_retx;

static expert_field ei_rlc_lte_am_sn_missing;

static expert_field ei_rlc_lte_um_sn;

static expert_field ei_rlc_lte_header_only;

static expert_field ei_rlc_lte_am_data_no_data_beyond_extensions;

static expert_field ei_rlc_lte_um_sn_missing;

static expert_field ei_rlc_lte_sequence_analysis_ack_out_of_range_opposite_frame;

static expert_field ei_rlc_lte_sequence_analysis_last_segment_not_continued;

static expert_field ei_rlc_lte_reserved_bits_not_zero;

static expert_field ei_rlc_lte_no_per_frame_info;

static expert_field ei_rlc_lte_unknown_udp_framing_tag;

static expert_field ei_rlc_lte_missing_udp_framing_tag;

/* Value-strings */

static const value_string direction_vals[] =

{

    { DIRECTION_UPLINK,      "Uplink"},

    { DIRECTION_DOWNLINK,    "Downlink"},

    { 0, NULL }

};

static const value_string rlc_mode_short_vals[] =

{

    { RLC_TM_MODE,      "TM"},

    { RLC_UM_MODE,      "UM"},

    { RLC_AM_MODE,      "AM"},

    { RLC_PREDEF,       "PREDEFINED"},  /* For data testing */

    { 0, NULL }

};

static const value_string rlc_mode_vals[] =

{

    { RLC_TM_MODE,      "Transparent Mode"},

    { RLC_UM_MODE,      "Unacknowledged Mode"},

    { RLC_AM_MODE,      "Acknowledged Mode"},

    { 0, NULL }

};

static const value_string rlc_channel_type_vals[] =

{

    { CHANNEL_TYPE_CCCH,         "CCCH"},

    { CHANNEL_TYPE_BCCH_BCH,     "BCCH_BCH"},

    { CHANNEL_TYPE_PCCH,         "PCCH"},

    { CHANNEL_TYPE_SRB,          "SRB"},

    { CHANNEL_TYPE_DRB,          "DRB"},

    { CHANNEL_TYPE_BCCH_DL_SCH,  "BCCH_DL_SCH"},

    { CHANNEL_TYPE_MCCH,         "MCCH"},

    { CHANNEL_TYPE_MTCH,         "MTCH"},

    { 0, NULL }

};

static const value_string framing_info_vals[] =

{

    { 0,      "First byte begins a RLC SDU and last byte ends a RLC SDU"},

    { 1,      "First byte begins a RLC SDU and last byte does not end a RLC SDU"},

    { 2,      "First byte does not begin a RLC SDU and last byte ends a RLC SDU"},

    { 3,      "First byte does not begin a RLC SDU and last byte does not end a RLC SDU"},

    { 0, NULL }

};

static const value_string fixed_extension_vals[] =

{

    { 0,      "Data field follows from the octet following the fixed part of the header"},

    { 1,      "A set of E field and LI field follows from the octet following the fixed part of the header"},

    { 0, NULL }

};

static const value_string extension_extension_vals[] =

{

    { 0,      "Data field follows from the octet following the LI field following this E field"},

    { 1,      "A set of E field and LI field follows from the bit following the LI field following this E field"},

    { 0, NULL }

};

static const value_string resegmentation_flag_vals[] =

{

    { 0,      "AMD PDU"},

    { 1,      "AMD PDU segment"},

    { 0, NULL }

};

static const value_string polling_bit_vals[] =

{

    { 0,      "Status report not requested"},

    { 1,      "Status report is requested"},

    { 0, NULL }

};

static const value_string lsf_vals[] =

{

    { 0,      "Last byte of the AMD PDU segment does not correspond to the last byte of an AMD PDU"},

    { 1,      "Last byte of the AMD PDU segment corresponds to the last byte of an AMD PDU"},

    { 0, NULL }

};

static const value_string control_pdu_type_vals[] =

{

    { 0,      "STATUS PDU"},

    { 0, NULL }

};

static const value_string am_e1_vals[] =

{

    { 0,      "A set of NACK_SN, E1 and E2 does not follow"},

    { 1,      "A set of NACK_SN, E1 and E2 follows"},

    { 0, NULL }

};

static const value_string am_e2_vals[] =

{

    { 0,      "A set of SOstart and SOend does not follow for this NACK_SN"},

    { 1,      "A set of SOstart and SOend follows for this NACK_SN"},

    { 0, NULL }

};

static const value_string header_only_vals[] =

{

    { 0,      "RLC PDU Headers and body present"},

    { 1,      "RLC PDU Headers only"},

    { 0, NULL }

};

/**********************************************************************************/

/* These are for keeping track of UM/AM extension headers, and the lengths found  */

/* in them                                                                        */

static uint8_t s_number_of_extensions;

#define MAX_RLC_SDUS 192

static uint16_t s_lengths[MAX_RLC_SDUS];

/*********************************************************************/

/* UM/AM sequence analysis                                           */

/* Types for RLC channel hash table                                   */

/* This table is maintained during initial dissection of RLC          */

/* frames, mapping from channel_hash_key -> sequence_analysis_report  */

/* Channel key */

typedef struct

{

    unsigned  ueId : 16;

    unsigned  channelType : 3;

    unsigned  channelId : 5;

    unsigned  direction : 1;

} channel_hash_key;

/******************************************************************/

/* State maintained for AM/UM reassembly                          */

typedef struct rlc_segment {

    uint32_t frameNum;

    uint16_t SN;

    uint8_t *data;

    uint16_t length;

} rlc_segment;

typedef struct rlc_channel_reassembly_info

{

    uint16_t number_of_segments;

    #define RLC_MAX_SEGMENTS 100

    rlc_segment segments[RLC_MAX_SEGMENTS];

} rlc_channel_reassembly_info;

/*******************************************************************/

/* Conversation-type status for sequence analysis on channel       */

typedef struct

{

    uint8_t  rlcMode;

    /* For UM, we always expect the SN to keep advancing, and these fields

       keep track of this.

       For AM, these correspond to new data */

    uint16_t previousSequenceNumber;

    uint32_t previousFrameNum;

    bool previousSegmentIncomplete;

    /* Accumulate info about current segmented SDU */

    struct rlc_channel_reassembly_info *reassembly_info;

} channel_sequence_analysis_status;

/* The sequence analysis channel hash table (channel_hash_key* -> channel_sequence_analysis_status*) */

static wmem_map_t *sequence_analysis_channel_hash;

/* Types for sequence analysis frame report hash table                  */

/* This is a table from framenum -> state_report_in_frame               */

/* This is necessary because the per-packet info is already being used  */

/* for context information before the dissector is called               */

/* Info to attach to frame when first read, recording what to show about sequence */

typedef enum {

    SN_OK, SN_Repeated, SN_MAC_Retx, SN_Retx, SN_Missing, ACK_Out_of_Window, SN_Error

} sequence_analysis_state;

typedef struct

{

    bool      sequenceExpectedCorrect;

    uint16_t  sequenceExpected;

    uint32_t  previousFrameNum;

    bool      previousSegmentIncomplete;

    uint32_t  nextFrameNum;

    uint16_t  firstSN;

    uint16_t  lastSN;

    /* AM/UM */

    sequence_analysis_state state;

} sequence_analysis_report;

/* The sequence analysis frame report hash table instance itself, lookup when visited */

/* rlc_result_hash_key* -> sequence_analysis_report* */

static wmem_map_t *sequence_analysis_report_hash;

static void *get_report_hash_key(uint16_t SN, uint32_t frameNumber,

                                    rlc_lte_info *p_rlc_lte_info,

                                    bool do_persist);

/* The reassembly result hash table */

static wmem_map_t *reassembly_report_hash;

/* Create a new struct for reassembly */

static void reassembly_reset(channel_sequence_analysis_status *status)

{

    status->reassembly_info = wmem_new0(wmem_file_scope(), rlc_channel_reassembly_info);

}

/* Hide previous one */

static void reassembly_destroy(channel_sequence_analysis_status *status)

{

    /* Just "leak" it. There seems to be no way to free this memory... */

    status->reassembly_info = NULL;

}

/* Add a new segment to the accumulating segmented SDU */

static void reassembly_add_segment(channel_sequence_analysis_status *status,

                                   uint16_t SN, uint32_t frame,

                                   tvbuff_t *tvb, unsigned offset, int length)

{

    int segment_number =  status->reassembly_info->number_of_segments;

    uint8_t *segment_data;

    /* Give up if reach segment limit */

    if (segment_number >= (RLC_MAX_SEGMENTS-1)) {

        reassembly_destroy(status);

        return;

    }

    segment_data = (uint8_t *)tvb_memdup(wmem_file_scope(),tvb, offset, length);

    /* Add new segment */

    status->reassembly_info->segments[segment_number].frameNum = frame;

    status->reassembly_info->segments[segment_number].SN = SN;

    status->reassembly_info->segments[segment_number].data = segment_data;

    status->reassembly_info->segments[segment_number].length = length;

    status->reassembly_info->number_of_segments++;

}

/* Record the current & complete segmented SDU by mapping from this frame number to

   struct with segment info. */

static void reassembly_record(channel_sequence_analysis_status *status, packet_info *pinfo,

                              uint16_t SN, rlc_lte_info *p_rlc_lte_info)

{

    /* Just store existing info in hash table */

    wmem_map_insert(reassembly_report_hash,

                        get_report_hash_key(SN, pinfo->num, p_rlc_lte_info, true),

                        status->reassembly_info);

}

/* Create and return a tvb based upon contents of reassembly info */

static tvbuff_t* reassembly_get_reassembled_tvb(rlc_channel_reassembly_info *reassembly_info,

                                                tvbuff_t *parent_tvb, packet_info *pinfo)

{

    int n;

    unsigned   combined_length = 0;

    uint8_t *combined_data;

    unsigned combined_offset = 0;

    tvbuff_t *reassembled_tvb;

    /* Allocate buffer big enough to hold re-assembled data */

    for (n=0; n < reassembly_info->number_of_segments; n++) {

        combined_length += reassembly_info->segments[n].length;

    }

    combined_data = (uint8_t *)wmem_alloc(pinfo->pool, combined_length);

    /* Copy data into contiguous buffer */

    for (n=0; n < reassembly_info->number_of_segments; n++) {

        uint8_t *data = reassembly_info->segments[n].data;

        int length = reassembly_info->segments[n].length;

        memcpy(combined_data+combined_offset, data, length);

        combined_offset += length;

    }

    /* Create and return tvb with this data */

    reassembled_tvb = tvb_new_child_real_data(parent_tvb, combined_data, combined_offset, combined_offset);

    add_new_data_source(pinfo, reassembled_tvb, "Reassembled SDU");

    return reassembled_tvb;

}

/* Show where the segments came from for a reassembled SDU */

static void reassembly_show_source(rlc_channel_reassembly_info *reassembly_info,

                                   proto_tree *tree, tvbuff_t *tvb, unsigned offset)

{

    int n;

    proto_item *source_ti, *ti;

    proto_tree *source_tree;

    proto_item *segment_ti;

    proto_tree *segment_tree;

    unsigned   total_length=0;

    /* Create root of source info */

    source_ti = proto_tree_add_item(tree,

                                    hf_rlc_lte_reassembly_source,

                                    tvb, 0, 0, ENC_ASCII);

    source_tree = proto_item_add_subtree(source_ti, ett_rlc_lte_reassembly_source);

    proto_item_set_generated(source_ti);

    for (n=0; n < reassembly_info->number_of_segments; n++) {

        total_length += reassembly_info->segments[n].length;

    }

    proto_item_append_text(source_ti, " %u segments, %u bytes", reassembly_info->number_of_segments,

                           total_length);

    /* Number of segments */

    ti = proto_tree_add_uint(source_tree,

                             hf_rlc_lte_reassembly_source_number_of_segments,

                             tvb, 0, 0, reassembly_info->number_of_segments);

    proto_item_set_generated(ti);

    /* Total length */

    ti = proto_tree_add_uint(source_tree,

                             hf_rlc_lte_reassembly_source_total_length,

                             tvb, 0, 0, total_length);

    proto_item_set_generated(ti);

    /* Now add info about each segment in turn */

    for (n=0; n < reassembly_info->number_of_segments; n++) {

        /* Add next segment as a subtree */

        rlc_segment *segment = &(reassembly_info->segments[n]);

        proto_item_append_text(source_ti, " (SN=%u frame=%u len=%u)",

                               segment->SN, segment->frameNum, segment->length);

        /* N.B. assume last segment from passed-in tvb! */

        segment_ti = proto_tree_add_item(source_tree,

                                         hf_rlc_lte_reassembly_source_segment,

                                         tvb,

                                         (n == reassembly_info->number_of_segments-1) ? offset : 0,

                                         (n == reassembly_info->number_of_segments-1) ? segment->length : 0,

                                         ENC_NA);

        segment_tree = proto_item_add_subtree(segment_ti, ett_rlc_lte_reassembly_source_segment);

        proto_item_append_text(segment_ti, " (SN=%u frame=%u length=%u)",

                               segment->SN, segment->frameNum, segment->length);

        proto_item_set_generated(segment_ti);

        /* Add details to segment tree */

        ti = proto_tree_add_uint(segment_tree, hf_rlc_lte_reassembly_source_segment_sn,

                                 tvb, 0, 0, segment->SN);

        proto_item_set_generated(ti);

        ti = proto_tree_add_uint(segment_tree, hf_rlc_lte_reassembly_source_segment_framenum,

                                 tvb, 0, 0, segment->frameNum);

        proto_item_set_generated(ti);

        ti = proto_tree_add_uint(segment_tree, hf_rlc_lte_reassembly_source_segment_length,

                                 tvb, 0, 0, segment->length);

        proto_item_set_generated(ti);

    }

}

/******************************************************************/

/* Conversation-type status for repeated NACK checking on channel */

typedef struct

{

    uint16_t        noOfNACKs;

    uint16_t        NACKs[MAX_NACKs];

    uint32_t        frameNum;

} channel_repeated_nack_status;

static wmem_map_t *repeated_nack_channel_hash;

typedef struct {

    uint16_t        noOfNACKsRepeated;

    uint16_t        repeatedNACKs[MAX_NACKs];

    uint32_t        previousFrameNum;

} channel_repeated_nack_report;

static wmem_map_t *repeated_nack_report_hash;

/********************************************************/

/* Forward declarations & functions                     */

static void dissect_rlc_lte_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, bool is_udp_framing);

/* Write the given formatted text to:

   - the info column

   - the top-level RLC PDU item

   - another subtree item (if supplied) */

static void write_pdu_label_and_info(proto_item *pdu_ti, proto_item *sub_ti,

                                     packet_info *pinfo, const char *format, ...) G_GNUC_PRINTF(4, 5);

static void write_pdu_label_and_info(proto_item *pdu_ti, proto_item *sub_ti,

                                     packet_info *pinfo, const char *format, ...)

{

    #define MAX_INFO_BUFFER 256

    static char info_buffer[MAX_INFO_BUFFER];

    va_list ap;

    va_start(ap, format);

    vsnprintf(info_buffer, MAX_INFO_BUFFER, format, ap);

    va_end(ap);

    /* Add to indicated places */

    col_append_str(pinfo->cinfo, COL_INFO, info_buffer);

    proto_item_append_text(pdu_ti, "%s", info_buffer);

    if (sub_ti != NULL) {

        proto_item_append_text(sub_ti, "%s", info_buffer);

    }

}

/* Version of function above, where no vsnprintf() call needed

   - the info column

   - the top-level RLC PDU item

   - another subtree item (if supplied) */

static void write_pdu_label_and_info_literal(proto_item *pdu_ti, proto_item *sub_ti,

                                             packet_info *pinfo, const char *info_buffer)

{

    /* Add to indicated places */

    col_append_str(pinfo->cinfo, COL_INFO, info_buffer);

    proto_item_append_text(pdu_ti, "%s", info_buffer);

    if (sub_ti != NULL) {

        proto_item_append_text(sub_ti, "%s", info_buffer);

    }

}

/* Dissect extension headers (common to both UM and AM) */

static int dissect_rlc_lte_extension_header(tvbuff_t *tvb, packet_info *pinfo _U_,

                                            proto_tree *tree,

                                            unsigned offset,

                                            rlc_lte_info *p_rlc_lte_info)

{

    uint8_t isOdd;

    uint64_t extension = 1;

    uint64_t length;

    /* Reset this count */

    s_number_of_extensions = 0;

    while (extension && (s_number_of_extensions < MAX_RLC_SDUS)) {

        proto_tree *extension_part_tree;

        proto_item *extension_part_ti;

        /* Extension part subtree */

        extension_part_ti = proto_tree_add_string_format(tree,

                                                         hf_rlc_lte_extension_part,

                                                         tvb, offset, 2,

                                                         "",

                                                         "Extension Part");

        extension_part_tree = proto_item_add_subtree(extension_part_ti,

                                                     ett_rlc_lte_extension_part);

        if (p_rlc_lte_info->extendedLiField == false) {

            isOdd = (s_number_of_extensions % 2);

            /* Read next extension */

            proto_tree_add_bits_ret_val(extension_part_tree, hf_rlc_lte_extension_e, tvb,

                                        (offset*8) + ((isOdd) ? 4 : 0),

                                        1,

                                        &extension, ENC_BIG_ENDIAN);

            /* Read length field */

            proto_tree_add_bits_ret_val(extension_part_tree, hf_rlc_lte_extension_li, tvb,

                                        (offset*8) + ((isOdd) ? 5 : 1),

                                        11,

                                        &length, ENC_BIG_ENDIAN);

            /* Move on to byte of next extension */

            if (isOdd) {

                offset += 2;

            } else {

                offset++;

            }

        } else {

            /* Read next extension */

            proto_tree_add_bits_ret_val(extension_part_tree, hf_rlc_lte_extension_e, tvb,

                                        (offset*8),

                                        1,

                                        &extension, ENC_BIG_ENDIAN);

            /* Read length field */

            proto_tree_add_bits_ret_val(extension_part_tree, hf_rlc_lte_extension_li, tvb,

                                        (offset*8) + 1,

                                        15,

                                        &length, ENC_BIG_ENDIAN);

            /* Move on to byte of next extension */

            offset += 2;

        }

        proto_item_append_text(extension_part_tree, " (length=%u)", (uint16_t)length);

        s_lengths[s_number_of_extensions++] = (uint16_t)length;

    }

    /* May need to skip padding after last extension part */

    isOdd = (s_number_of_extensions % 2);

    if (isOdd && (p_rlc_lte_info->extendedLiField == false)) {

        proto_tree_add_item(tree, hf_rlc_lte_extension_padding,

                            tvb, offset++, 1, ENC_BIG_ENDIAN);

    }

    return offset;

}

/* Show in the info column how many bytes are in the UM/AM PDU, and indicate

   whether or not the beginning and end are included in this packet */

static void show_PDU_in_info(packet_info *pinfo,

                             proto_item *top_ti,

                             int32_t length,

                             bool first_includes_start,

                             bool last_includes_end)

{

    /* Reflect this PDU in the info column */

    if (length > 0) {

        write_pdu_label_and_info(top_ti, NULL, pinfo,

                                 "  %s%u-byte%s%s",

                                 (first_includes_start) ? "[" : "..",

                                 length,

                                 (length > 1) ? "s" : "",

                                 (last_includes_end) ? "]" : "..");

    }

    else {

        write_pdu_label_and_info(top_ti, NULL, pinfo,

                                 "  %sunknown-bytes%s",

                                 (first_includes_start) ? "[" : "..",

                                 (last_includes_end) ? "]" : "..");

    }

}

/* Show an SDU. If configured, pass to PDCP/RRC/IP dissector */

static void show_PDU_in_tree(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, unsigned offset, int length,

                             rlc_lte_info *rlc_info, bool whole_pdu, rlc_channel_reassembly_info *reassembly_info,

                             sequence_analysis_state state)

{

    wmem_tree_key_t key[3];

    uint32_t id;

    rlc_ue_parameters *params;

    /* Add raw data (according to mode) */

    proto_item *data_ti = proto_tree_add_item(tree,

                                              (rlc_info->rlcMode == RLC_AM_MODE) ?

                                                    hf_rlc_lte_am_data :

                                                    hf_rlc_lte_um_data,

                                              tvb, offset, length, ENC_NA);

    if (whole_pdu || (reassembly_info != NULL)) {

        if (((global_rlc_lte_call_pdcp_for_srb) && (rlc_info->channelType == CHANNEL_TYPE_SRB)) ||

            ((global_rlc_lte_call_pdcp_for_drb != PDCP_drb_off) && (rlc_info->channelType == CHANNEL_TYPE_DRB))) {

            /* Send whole PDU to PDCP */

            /* TODO: made static to avoid compiler warning... */

            static tvbuff_t *pdcp_tvb = NULL;

            struct pdcp_lte_info *p_pdcp_lte_info;

            /* Get tvb for passing to LTE PDCP dissector */

            if (reassembly_info == NULL) {

                pdcp_tvb = tvb_new_subset_length(tvb, offset, length);

            }

            else {

                /* Get combined tvb. */

                pdcp_tvb = reassembly_get_reassembled_tvb(reassembly_info, tvb, pinfo);

                reassembly_show_source(reassembly_info, tree, tvb, offset);

            }

            /* Reuse or allocate struct */

            p_pdcp_lte_info = (pdcp_lte_info *)p_get_proto_data(wmem_file_scope(), pinfo, proto_pdcp_lte, 0);

            if (p_pdcp_lte_info == NULL) {

                p_pdcp_lte_info = wmem_new0(wmem_file_scope(), pdcp_lte_info);

                /* Store info in packet */

                p_add_proto_data(wmem_file_scope(), pinfo, proto_pdcp_lte, 0, p_pdcp_lte_info);

            }

            p_pdcp_lte_info->ueid = rlc_info->ueid;

            if (rlc_info->nbMode == rlc_nb_mode) {

                p_pdcp_lte_info->channelType = Channel_DCCH_NB;

            } else {

                p_pdcp_lte_info->channelType = Channel_DCCH;

            }

            p_pdcp_lte_info->channelId = rlc_info->channelId;

            p_pdcp_lte_info->direction = rlc_info->direction;

            p_pdcp_lte_info->is_retx = (state != SN_OK);

            /* Set plane and sequence number length */

            p_pdcp_lte_info->no_header_pdu = false;

            if (rlc_info->channelType == CHANNEL_TYPE_SRB) {

                p_pdcp_lte_info->plane = SIGNALING_PLANE;

                if ((rlc_info->nbMode == rlc_nb_mode) && (rlc_info->channelId == 3)) {

                    p_pdcp_lte_info->no_header_pdu = true;

                    p_pdcp_lte_info->seqnum_length = 0;

                } else {

                    p_pdcp_lte_info->seqnum_length = 5;

                }

            }

            else {

                p_pdcp_lte_info->plane = USER_PLANE;

                switch (global_rlc_lte_call_pdcp_for_drb) {

                    case PDCP_drb_SN_7:

                        p_pdcp_lte_info->seqnum_length = 7;

                        break;

                    case PDCP_drb_SN_12:

                        p_pdcp_lte_info->seqnum_length = 12;

                        break;

                    case PDCP_drb_SN_15:

                        p_pdcp_lte_info->seqnum_length = 15;

                        break;

                    case PDCP_drb_SN_18:

                        p_pdcp_lte_info->seqnum_length = 18;

                        break;

                    case PDCP_drb_SN_signalled:

                        /* Use whatever was signalled (e.g. in RRC) */

                        id = (rlc_info->channelId << 16) | rlc_info->ueid;

                        key[0].length = 1;

                        key[0].key = &id;

                        key[1].length = 1;

                        key[1].key = &pinfo->num;

                        key[2].length = 0;

                        key[2].key = NULL;

                        params = (rlc_ue_parameters *)wmem_tree_lookup32_array_le(ue_parameters_tree, key);

                        if (params && (params->id != id)) {

                            params = NULL;

                        }

                        if (params) {

                            p_pdcp_lte_info->seqnum_length = params->pdcp_sn_bits;

                        } else if (rlc_info->nbMode == rlc_nb_mode) {

                            p_pdcp_lte_info->seqnum_length = 7;

                        } else {

                            p_pdcp_lte_info->seqnum_length = 12;

                        }

                        break;

                    default:

                        DISSECTOR_ASSERT(false);

                        break;

                }

            }

            TRY {

                call_dissector_only(pdcp_lte_handle, pdcp_tvb, pinfo, tree, NULL);

            }

            CATCH_ALL {

            }

            ENDTRY

            proto_item_set_hidden(data_ti);

        }

        else if (global_rlc_lte_call_rrc_for_mcch && (rlc_info->channelType == CHANNEL_TYPE_MCCH)) {

            /* Send whole PDU to RRC */

            static tvbuff_t *rrc_tvb = NULL;

            /* Get tvb for passing to LTE RRC dissector */

            if (reassembly_info == NULL) {

                rrc_tvb = tvb_new_subset_length(tvb, offset, length);

            }

            else {

                /* Get combined tvb. */

                rrc_tvb = reassembly_get_reassembled_tvb(reassembly_info, tvb, pinfo);

                reassembly_show_source(reassembly_info, tree, tvb, offset);

            }

            TRY {

                call_dissector_only(lte_rrc_mcch, rrc_tvb, pinfo, tree, NULL);

            }

            CATCH_ALL {

            }

            ENDTRY

            proto_item_set_hidden(data_ti);

        }

        else if (global_rlc_lte_call_ip_for_mtch && (rlc_info->channelType == CHANNEL_TYPE_MTCH)) {

            /* Send whole PDU to IP */

            static tvbuff_t *ip_tvb = NULL;

            /* Get tvb for passing to IP dissector */

            if (reassembly_info == NULL) {

                ip_tvb = tvb_new_subset_length(tvb, offset, length);

            }

            else {

                /* Get combined tvb. */

                ip_tvb = reassembly_get_reassembled_tvb(reassembly_info, tvb, pinfo);

                reassembly_show_source(reassembly_info, tree, tvb, offset);

            }

            TRY {

                call_dissector_only(ip_handle, ip_tvb, pinfo, tree, NULL);

            }

            CATCH_ALL {

            }

            ENDTRY

            proto_item_set_hidden(data_ti);

        }

    }

}

/* Hash table functions for RLC channels */

/* Equal keys */

static int rlc_channel_equal(const void *v, const void *v2)

{

    const channel_hash_key* val1 = (const channel_hash_key *)v;

    const channel_hash_key* val2 = (const channel_hash_key *)v2;

    /* All fields must match */

    /* N.B. Currently fits into one word, so could return (*v == *v2)

       if we're sure they're initialised to 0... */

    return ((val1->ueId        == val2->ueId) &&

            (val1->channelType == val2->channelType) &&

            (val1->channelId   == val2->channelId) &&

            (val1->direction   == val2->direction));

}

/* Compute a hash value for a given key. */

static unsigned rlc_channel_hash_func(const void *v)

{

    const channel_hash_key* val1 = (const channel_hash_key *)v;

    /* TODO: check/reduce multipliers */

    return ((val1->ueId * 1024) + (val1->channelType*64) + (val1->channelId*2) + val1->direction);

}

/*************************************************************************/

/* Result hash                                                           */

typedef struct {

    uint32_t          frameNumber;

    uint32_t          SN :             10;

    uint32_t          channelType :    2;

    uint32_t          channelId:       5;

    uint32_t          direction:       1;

} rlc_result_hash_key;

/* Compare 2 rlc_result_hash_key structs */

static int rlc_result_hash_equal(const void *v, const void *v2)

{

    const rlc_result_hash_key *val1 = (const rlc_result_hash_key *)v;

    const rlc_result_hash_key *val2 = (const rlc_result_hash_key *)v2;

    /* All fields (and any padding...) must match */

    return (memcmp(val1, val2, sizeof(rlc_result_hash_key)) == 0);

}

/* Compute a hash value for a given key. */

static unsigned rlc_result_hash_func(const void *v)

{

    const rlc_result_hash_key* val1 = (const rlc_result_hash_key *)v;

    /* Got rid of multipliers - no evidence that they reduced collisions */

    return val1->frameNumber + val1->SN +

                               val1->channelType +

                               val1->channelId +

                               val1->direction;

}

/* Convenience function to get a pointer for the hash_func to work with */

static void *get_report_hash_key(uint16_t SN, uint32_t frameNumber,

                                    rlc_lte_info *p_rlc_lte_info,

                                    bool do_persist)

{

    static rlc_result_hash_key key;

    rlc_result_hash_key *p_key;

    /* Only allocate a struct when will be adding entry */

    if (do_persist) {

        p_key = wmem_new0(wmem_file_scope(), rlc_result_hash_key);

    }

    else {

        memset(&key, 0, sizeof(rlc_result_hash_key));