/src/wireshark/epan/dissectors/packet-catapult-dct2000.c

Source
/* packet-catapult-dct2000.c
 * Routines for Catapult DCT2000 packet stub header disassembly
 *
 * 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 <stdio.h>      /* for sscanf() */

#include <epan/packet.h>
#include <epan/expert.h>
#include <epan/prefs.h>
#include <epan/addr_resolv.h>
#include <epan/proto_data.h>
#include <epan/tfs.h>

#include <wsutil/strtoi.h>

#include <wiretap/catapult_dct2000.h>
#include "packet-umts_fp.h"
#include "packet-umts_rlc.h"

#include "packet-mac-lte.h"
#include "packet-rlc-lte.h"
#include "packet-pdcp-lte.h"

#include "packet-mac-nr.h"
#include "packet-pdcp-nr.h"

void proto_reg_handoff_catapult_dct2000(void);
void proto_register_catapult_dct2000(void);

/* Protocol and registered fields. */
static int proto_catapult_dct2000;

static int hf_catapult_dct2000_context;
static int hf_catapult_dct2000_port_number;
static int hf_catapult_dct2000_timestamp;
static int hf_catapult_dct2000_protocol;
static int hf_catapult_dct2000_variant;
static int hf_catapult_dct2000_outhdr;
static int hf_catapult_dct2000_direction;
static int hf_catapult_dct2000_encap;
static int hf_catapult_dct2000_unparsed_data;
static int hf_catapult_dct2000_comment;
static int hf_catapult_dct2000_sprint;
static int hf_catapult_dct2000_error_comment;
static int hf_catapult_dct2000_tty;
static int hf_catapult_dct2000_tty_line;
static int hf_catapult_dct2000_dissected_length;

static int hf_catapult_dct2000_ipprim_addresses;
static int hf_catapult_dct2000_ipprim_src_addr_v4;
static int hf_catapult_dct2000_ipprim_src_addr_v6;
static int hf_catapult_dct2000_ipprim_dst_addr_v4;
static int hf_catapult_dct2000_ipprim_dst_addr_v6;
static int hf_catapult_dct2000_ipprim_addr_v4;
static int hf_catapult_dct2000_ipprim_addr_v6;
static int hf_catapult_dct2000_ipprim_udp_src_port;
static int hf_catapult_dct2000_ipprim_udp_dst_port;
static int hf_catapult_dct2000_ipprim_udp_port;
static int hf_catapult_dct2000_ipprim_tcp_src_port;
static int hf_catapult_dct2000_ipprim_tcp_dst_port;
static int hf_catapult_dct2000_ipprim_tcp_port;
static int hf_catapult_dct2000_ipprim_conn_id;

static int hf_catapult_dct2000_sctpprim_addresses;
static int hf_catapult_dct2000_sctpprim_dst_addr_v4;
static int hf_catapult_dct2000_sctpprim_dst_addr_v6;
static int hf_catapult_dct2000_sctpprim_addr_v4;
static int hf_catapult_dct2000_sctpprim_addr_v6;
static int hf_catapult_dct2000_sctpprim_dst_port;

static int hf_catapult_dct2000_ueid;
static int hf_catapult_dct2000_srbid;
static int hf_catapult_dct2000_drbid;
static int hf_catapult_dct2000_cellid;
static int hf_catapult_dct2000_bcch_transport;
static int hf_catapult_dct2000_rlc_op;
static int hf_catapult_dct2000_rlc_channel_type;
static int hf_catapult_dct2000_rlc_mui;
static int hf_catapult_dct2000_rlc_cnf;
static int hf_catapult_dct2000_rlc_discard_req;
static int hf_catapult_dct2000_carrier_type;
static int hf_catapult_dct2000_cell_group;
static int hf_catapult_dct2000_carrier_id;

static int hf_catapult_dct2000_security_mode_params;
static int hf_catapult_dct2000_uplink_sec_mode;
static int hf_catapult_dct2000_downlink_sec_mode;
static int hf_catapult_dct2000_ciphering_algorithm;
static int hf_catapult_dct2000_ciphering_key;
static int hf_catapult_dct2000_integrity_algorithm;
static int hf_catapult_dct2000_integrity_key;

static int hf_catapult_dct2000_lte_ccpri_opcode;
static int hf_catapult_dct2000_lte_ccpri_status;
static int hf_catapult_dct2000_lte_ccpri_channel;

static int hf_catapult_dct2000_lte_nas_rrc_opcode;
static int hf_catapult_dct2000_lte_nas_rrc_establish_cause;
static int hf_catapult_dct2000_lte_nas_rrc_priority;
static int hf_catapult_dct2000_lte_nas_rrc_release_cause;

static int hf_catapult_dct2000_nr_nas_s1ap_opcode;

/* UMTS RLC fields */
static int hf_catapult_dct2000_rbid;
static int hf_catapult_dct2000_ccch_id;
static int hf_catapult_dct2000_no_crc_error;
static int hf_catapult_dct2000_crc_error;
static int hf_catapult_dct2000_clear_tx_buffer;
static int hf_catapult_dct2000_buffer_occupancy;
static int hf_catapult_dct2000_pdu_size;
static int hf_catapult_dct2000_ueid_type;
static int hf_catapult_dct2000_tx_priority;
static int hf_catapult_dct2000_last_in_seg_set;
static int hf_catapult_dct2000_rx_timing_deviation;
static int hf_catapult_dct2000_transport_channel_type;
static int hf_catapult_dct2000_no_padding_bits;

static int hf_catapult_dct2000_rawtraffic_interface;
static int hf_catapult_dct2000_rawtraffic_direction;
static int hf_catapult_dct2000_rawtraffic_pdu;


/* Variables used for preferences */
static bool catapult_dct2000_try_ipprim_heuristic = true;
static bool catapult_dct2000_try_sctpprim_heuristic = true;
static bool catapult_dct2000_dissect_lte_rrc = true;
static bool catapult_dct2000_dissect_mac_lte_oob_messages = true;
static bool catapult_dct2000_dissect_old_protocol_names;
static bool catapult_dct2000_use_protocol_name_as_dissector_name;

/* Protocol subtree. */
static int ett_catapult_dct2000;
static int ett_catapult_dct2000_ipprim;
static int ett_catapult_dct2000_sctpprim;
static int ett_catapult_dct2000_tty;
static int ett_catapult_dct2000_security_mode_params;

static expert_field ei_catapult_dct2000_lte_ccpri_status_error;
static expert_field ei_catapult_dct2000_error_comment_expert;
static expert_field ei_catapult_dct2000_string_invalid;

static const value_string direction_vals[] = {
    { 0,   "Sent" },
    { 1,   "Received" },
    { 0,   NULL },
};

static const value_string encap_vals[] = {
    { WTAP_ENCAP_RAW_IP,                 "Raw IP" },
    { WTAP_ENCAP_ETHERNET,               "Ethernet" },
    { WTAP_ENCAP_ISDN,                   "LAPD" },
    { WTAP_ENCAP_ATM_PDUS_UNTRUNCATED,   "ATM (PDUs untruncated)" },
    { WTAP_ENCAP_PPP,                    "PPP" },
    { DCT2000_ENCAP_SSCOP,               "SSCOP" },
    { WTAP_ENCAP_FRELAY,                 "Frame Relay" },
    { WTAP_ENCAP_MTP2,                   "MTP2" },
    { DCT2000_ENCAP_NBAP,                "NBAP" },
    { DCT2000_ENCAP_UNHANDLED,           "No Direct Encapsulation" },
    { 0,                                 NULL },
};

static const value_string bcch_transport_vals[] = {
    { BCH_TRANSPORT,    "BCH" },
    { DLSCH_TRANSPORT,  "DLSCH" },
    { 0,   NULL },
};


#define RLC_MGMT_ASSIGN                 0x41
#define RLC_AM_DATA_REQ                 0x60
#define RLC_AM_DATA_IND                 0x61
#define RLC_AM_DATA_CONF                0x62
#define RLC_UM_DATA_REQ                 0x70
#define RLC_UM_DATA_IND                 0x71
#define RLC_UM_DATA_CONF                0x74
#define RLC_TR_DATA_REQ                 0x80
#define RLC_TR_DATA_IND                 0x81
#define RLC_TR_DATA_CONF                0x83

static const value_string rlc_op_vals[] = {
    { RLC_AM_DATA_REQ,   "[UL] [AM]" },
    { RLC_AM_DATA_IND,   "[DL] [AM]" },
    { RLC_UM_DATA_REQ,   "[UL] [UM]"},
    { RLC_UM_DATA_IND,   "[DL] [UM]"},
    { RLC_TR_DATA_REQ,   "[UL] [TM]"},
    { RLC_TR_DATA_IND,   "[DL] [TM]"},
    { 0,   NULL }
};


static const value_string rlc_logical_channel_vals[] = {
    { Channel_DCCH,  "DCCH"},
    { Channel_BCCH,  "BCCH"},
    { Channel_CCCH,  "CCCH"},
    { Channel_PCCH,  "PCCH"},
    { 0,             NULL}
};


#define CCPRI_REQ 1
#define CCPRI_IND 2

static const value_string ccpri_opcode_vals[] = {
    { CCPRI_REQ,     "REQUEST"},
    { CCPRI_IND,     "INDICATION"},
    { 0,             NULL}
};

static const value_string rlc_rbid_vals[] = {
    { 1,     "DCH1"},
    { 2,     "DCH2"},
    { 3,     "DCH3"},
    { 4,     "DCH4"},
    { 5,     "DCH5"},
    { 6,     "DCH6"},
    { 7,     "DCH7"},
    { 8,     "DCH8"},
    { 9,     "DCH9"},
    { 10,    "DCH10"},
    { 11,    "DCH11"},
    { 12,    "DCH12"},
    { 13,    "DCH13"},
    { 14,    "DCH14"},
    { 15,    "DCH15"},
    { 17,    "BCCH"},
    { 18,    "CCCH"},
    { 19,    "PCCH"},
    { 20,    "SHCCH"},
    { 21,    "CTCH"},
    { 23,    "MCCH"},
    { 24,    "MSCH"},
    { 25,    "MTCH"},
    { 0,     NULL}
};
static value_string_ext rlc_rbid_vals_ext = VALUE_STRING_EXT_INIT(rlc_rbid_vals);

static const value_string ueid_type_vals[] = {
    { 0,     "URNTI"},
    { 1,     "CRNTI"},
    { 0,     NULL}
};

static const value_string transport_channel_type_vals[] = {
    { 1,     "RACH"},
    { 2,     "FACH"},
    { 3,     "BCH"},
    { 4,     "PCH"},
    { 6,     "USCH"},
    { 7,     "DSCH"},
    { 8,     "DCH"},
    { 9,     "HSDSCH"},
    { 10,    "EDCH"},
    { 0,     NULL}
};

#define LTE_NAS_RRC_DATA_IND       0x02
#define LTE_NAS_RRC_DATA_REQ       0x03
#define LTE_NAS_RRC_ESTABLISH_REQ  0x06
#define LTE_NAS_RRC_RELEASE_IND    0x08

static const value_string lte_nas_rrc_opcode_vals[] = {
    { LTE_NAS_RRC_DATA_IND,        "Data-Ind"},
    { LTE_NAS_RRC_DATA_REQ,        "Data-Req"},
    { LTE_NAS_RRC_ESTABLISH_REQ,   "Establish-Req"},
    { LTE_NAS_RRC_RELEASE_IND,     "Release-Ind"},
    { 0,     NULL}
};


#define NAS_S1AP_DATA_REQ       0x00
#define NAS_S1AP_DATA_IND       0x01

static const value_string nas_s1ap_opcode_vals[] = {
    { NAS_S1AP_DATA_REQ,        "Data-Req"},
    { NAS_S1AP_DATA_IND,        "Data-Ind"},
    { 0,     NULL}
};


/* Distinguish between similar 4G or 5G protocols */
enum LTE_or_NR {
    LTE,
    NR
};

static const value_string carrier_type_vals[] = {
    { 0,        "LTE"},
    { 1,        "CatM"},
    { 2,        "NBIoT"},
    { 3,        "NR"},
    { 0,     NULL}
};


static const value_string security_mode_vals[] = {
    { 0,        "None"},
    { 1,        "Integrity only"},
    { 2,        "Ciphering and Integrity"},
    { 0,     NULL}
};

static const value_string ciphering_algorithm_vals[] = {
    { 0,        "EEA0"},
    { 1,        "EEA1"},
    { 2,        "EEA2"},
    { 3,        "EEA3"},
    { 0,     NULL}
};

static const value_string integrity_algorithm_vals[] = {
    { 0,        "EIA0"},
    { 1,        "EIA1"},
    { 2,        "EIA2"},
    { 3,        "EIA3"},
    { 0,     NULL}
};


#define MAX_OUTHDR_VALUES 32

static int proto_fp;
static int proto_umts_rlc;

static int proto_rlc_lte;
static int proto_pdcp_lte;


static dissector_handle_t mac_lte_handle;
static dissector_handle_t rlc_lte_handle;
static dissector_handle_t pdcp_lte_handle;
static dissector_handle_t catapult_dct2000_handle;
static dissector_handle_t nrup_handle;

static dissector_handle_t mac_nr_handle;

static dissector_handle_t eth_handle;

static dissector_handle_t look_for_dissector(const char *protocol_name);
static unsigned parse_outhdr_string(const char *outhdr_string, int outhdr_length, unsigned *outhdr_values);

static void attach_fp_info(packet_info *pinfo, bool received,
                           const char *protocol_name, int variant,
                           unsigned *outhdr_values, unsigned outhdr_values_found);
static void attach_rlc_info(packet_info *pinfo, uint32_t urnti, uint8_t rbid,
                            bool is_sent, unsigned *outhdr_values,
                            unsigned outhdr_values_found);

static void attach_mac_lte_info(packet_info *pinfo, unsigned *outhdr_values,
                                unsigned outhdr_values_found);
static void attach_rlc_lte_info(packet_info *pinfo, unsigned *outhdr_values,
                                unsigned outhdr_values_found);
static void attach_pdcp_lte_info(packet_info *pinfo, unsigned *outhdr_values,
                                 unsigned outhdr_values_found);


/* Return the number of bytes used to encode the length field
   (we're not interested in the length value itself) */
static int skipASNLength(uint8_t value)
{
    if ((value & 0x80) == 0)
    {
        return 1;
    }
    else
    {
        return ((value & 0x03) == 1) ? 2 : 3;
    }
}


/* Look for the protocol data within an ipprim packet.
   Only set *data_offset if data field found. */
static bool find_ipprim_data_offset(tvbuff_t *tvb, int *data_offset, uint8_t direction,
                                        uint32_t *source_addr_offset, uint8_t *source_addr_length,
                                        uint32_t *dest_addr_offset,   uint8_t *dest_addr_length,
                                        uint32_t *source_port_offset, uint32_t *dest_port_offset,
                                        port_type *type_of_port,
                                        uint16_t *conn_id_offset)
{
    uint8_t length;
    int    offset = *data_offset;

    /* Get the ipprim command code. */
    uint8_t tag = tvb_get_uint8(tvb, offset++);

    /* Only accept UDP or TCP data request or indication */
    switch (tag) {
        case 0x23:  /* UDP data request */
        case 0x24:  /* UDP data indication */
            *type_of_port = PT_UDP;
            break;
        case 0x45:  /* TCP data request */
        case 0x46:  /* TCP data indication */
            *type_of_port = PT_TCP;
            break;
        default:
            return false;
    }

    /* Skip any other TLC fields before reach payload */
    while (tvb_reported_length_remaining(tvb, offset) > 2) {
        /* Look at next tag */
        tag = tvb_get_uint8(tvb, offset++);

        /* Is this the data payload we're expecting? */
        if (((tag == 0x34) && (*type_of_port == PT_UDP)) ||
            ((tag == 0x48) && (*type_of_port == PT_TCP))) {

            *data_offset = offset;
            return true;
        }
        else {
            /* Read length in next byte */
            length = tvb_get_uint8(tvb, offset++);

            if (tag == 0x31 && length >=4) {
                /* Remote IP address */
                if (direction == 0) {
                    /* Sent *to* remote, so dest */
                    *dest_addr_offset = offset;
                    *dest_addr_length = (length/4) * 4;
                }
                else {
                    *source_addr_offset = offset;
                    *source_addr_length = (length/4) * 4;
                }

                /* Remote port follows (if present) */
                if ((length % 4) == 2) {
                    if (direction == 0) {
                        *dest_port_offset = offset + *dest_addr_length;
                    }
                    else {
                        *source_port_offset = offset + *source_addr_length;
                    }
                }
            }
            else
            if (tag == 0x32) {
                if (length == 4 || length == 16) {
                    /* Local IP address */
                    if (direction == 0) {
                        /* Sent *from* local, so source */
                        *source_addr_offset = offset;
                        *source_addr_length = length;
                    }
                    else {
                        *dest_addr_offset = offset;
                        *dest_addr_length = length;
                    }
                }
            }
            else
            if (tag == 0x33 && length == 2) {
                /* Get local port */
                if (direction == 0) {
                    /* Sent from local, so source */
                    *source_port_offset = offset;
                }
                else {
                    *dest_port_offset = offset;
                }
            }
            else
            if (tag == 0x36 && length == 2) {
                /* Get conn_id */
                *conn_id_offset = offset;
            }

            /* Skip the length of the indicated value */
            offset += length;
        }
    }

    /* No data found... */
    return false;
}



/* Look for the protocol data within an sctpprim (variant 1 or 2...) packet.
   Only set *data_offset if data field found. */
static bool find_sctpprim_variant1_data_offset(tvbuff_t *tvb, int *data_offset,
                                                   uint32_t *dest_addr_offset,
                                                   uint16_t *dest_addr_length,
                                                   uint32_t *dest_port_offset)
{
    int offset = *data_offset;

    /* Get the sctpprim command code. */
    uint8_t first_tag = tvb_get_uint8(tvb, offset++);
    uint8_t tag;
    uint8_t first_length_byte;

    /* Only accept interested in data requests or indications */
    switch (first_tag) {
        case 0x04:  /* data request */
        case 0x62:  /* data indication */
            break;
        default:
            return false;
    }

    first_length_byte = tvb_get_uint8(tvb, offset);
    offset += skipASNLength(first_length_byte);

    /* Skip any other fields before reach payload */
    while (tvb_reported_length_remaining(tvb, offset) > 2) {
        /* Look at next tag */
        tag = tvb_get_uint8(tvb, offset++);

        /* Is this the data payload we're expecting? */
        if (tag == 0x19) {
            *data_offset = offset;
            return true;
        }
        else {
            /* Skip length field */
            offset++;
            switch (tag) {
                case 0x0a: /* destPort */
                    *dest_port_offset = offset;
                    offset += 2;
                    break;

                case 0x01: /* sctpInstanceNum */
                case 0x1e: /* strseqnum */
                case 0x0d: /* streamnum */
                    offset += 2;
                    continue;

                case 0x09: /* ipv4Address */
                    *dest_addr_offset = offset;
                    *dest_addr_length = 4;
                    offset += 4;
                    break;

                case 0x1d:
                case 0x0c: /* payloadType */
                    offset += 4;
                    continue;

                default:
                    /* Fail if not a known header field */
                    return false;
            }
        }
    }

    /* No data found... */
    return false;
}

/* Look for the protocol data within an sctpprim (variant 3) packet.
   Return value indicates whether this header found.
   Only set *data_offset if data field found. */
static bool find_sctpprim_variant3_data_offset(tvbuff_t *tvb, int *data_offset,
                                                   uint32_t *dest_addr_offset,
                                                   uint16_t *dest_addr_length,
                                                   uint32_t *dest_port_offset)
{
    uint16_t tag    = 0;
    uint16_t length = 0;
    int     offset = *data_offset;

    /* Get the sctpprim (2 byte) command code. */
    uint16_t top_tag = tvb_get_ntohs(tvb, offset);
    offset += 2;

    /* Only interested in data requests or indications */
    if ((top_tag != 0x0400) &&  /* SendDataReq */
       (top_tag != 0x6200)) {  /* DataInd */
        return false;
    }

    /* Overall length field is next 2 bytes */
    offset += 2;

    /* Rx/Tx ops have different formats */

    /*****************/
    /* DataInd        */
    if (top_tag == 0x6200) {
        /* Next 2 bytes are associate ID */
        offset += 2;

        /* Next 2 bytes are destination port */
        *dest_port_offset = offset;
        offset += 2;

        /* Destination address should follow - check tag */
        tag = tvb_get_ntohs(tvb, offset);
        if (tag != 0x0900) {
            return false;
        }
        else {
            /* Skip tag */
            offset += 2;

            /* Length field */
            length = tvb_get_ntohs(tvb, offset) / 2;
            if ((length != 4) && (length != 16))
            {
                return false;
            }
            offset += 2;

            /* Address data is here */
            *dest_addr_offset = offset;
            *dest_addr_length = length;

            offset += length;
        }

        /* Not interested in remaining (fixed) fields */
        if (tvb_reported_length_remaining(tvb, offset) > (4 + 2 + 2 + 4)) {
            offset += (4 + 2 + 2 + 4);
        }
        else {
            return false;
        }

        /* Data should now be here */
        tag = tvb_get_ntohs(tvb, offset);
        offset += 2;
        if (tag == 0x1900) {
            /* 2-byte length field */
            offset += 2;

            /* Data is here!!! */
            *data_offset = offset;
            return true;
        }
        else {
            return false;
        }
    }

    /***********************************/
    /* SendDataReq (top_tag == 0x0400) */
    else {
        /* AssociateId should follow - check tag */
        tag = tvb_get_ntohs(tvb, offset);
        if (tag != 0x2400) {
            return false;
        }
        else {
            /* Skip tag */
            offset += 2;

            /* Skip 2-byte value */
            offset += 2;
        }

        /* Get tag */
        tag = tvb_get_ntohs(tvb, offset);
        offset += 2;

        /* Some optional params */
        while ((tag != 0x0c00) && (tvb_reported_length_remaining(tvb, offset) > 4)) {
            switch (tag) {
                case 0x0900:   /* Dest address */
                    /* Length field */
                    length = tvb_get_ntohs(tvb, offset) / 2;
                    if ((length != 4) && (length != 16)) {
                        return false;
                    }
                    offset += 2;

                    /* Address data is here */
                    *dest_addr_offset = offset;
                    *dest_addr_length = length;

                    offset += length;
                    break;

                case 0x0a00:   /* Dest port number */
                    *dest_port_offset = offset;
                    offset += 2;
                    break;

                case 0x0d00:   /* StreamNum */
                    offset += 2;
                    break;


                default:
                    return false;
            }

            /* Get the next tag */
            tag = tvb_get_ntohs(tvb, offset);
            offset += 2;
        }


        /* Mandatory payload type */
        if (tag != 0x0c00) {
            return false;
        }
        length = tvb_get_ntohs(tvb, offset) / 2;
        offset += 2;
        offset += length;


        /* Optional options */
        tag = tvb_get_ntohs(tvb, offset);
        offset += 2;
        if (tag == 0x0b00) {
            length = tvb_get_ntohs(tvb, offset) / 2;
            offset += 2;

            offset += length;

            /* Get next tag */
            tag = tvb_get_ntohs(tvb, offset);
            offset += 2;
        }


        /* Data should now be here!! */
        if (tag == 0x1900) {
            /* 2-byte length field */
            offset += 2;

            /* Data is here!!! */
            *data_offset = offset;
            return true;
        }
        else {
            return false;
        }
    }
}


/* Dissect a UMTS RLC frame by:
   - parsing the primitive header
   - passing those values + outheader to dissector
   - calling the UMTS RLC dissector */
static void dissect_rlc_umts(tvbuff_t *tvb, int offset,
                             packet_info *pinfo, proto_tree *tree,
                             bool is_sent, unsigned *outhdr_values,
                             unsigned outhdr_values_found)
{
    uint8_t             tag;
    bool                ueid_set        = false, rbid_set=false;
    uint32_t            ueid            = 0;
    uint8_t             rbid            = 0;
    uint8_t             length;
    tvbuff_t           *rlc_tvb;
    dissector_handle_t  rlc_umts_handle = 0;

    /* Top-level opcode */
    tag = tvb_get_uint8(tvb, offset++);
    switch (tag) {
        case 0xc0:    /* mac data request */
        case 0xc1:    /* mac data indication */
            break;

        default:
            /* No data to dissect */
            return;
    }

    /* Keep going until reach data tag or end of frame */
    while ((tag != 0x41) && tvb_reported_length_remaining(tvb, offset)) { /* i.e. Data */
        tag = tvb_get_uint8(tvb, offset++);
        switch (tag) {
            case 0x72:  /* UE Id */
                ueid = tvb_get_ntohl(tvb, offset);
                offset += 2;
                proto_tree_add_item(tree, hf_catapult_dct2000_ueid, tvb, offset, 2, ENC_BIG_ENDIAN);
                offset += 2;
                ueid_set = true;
                break;
            case 0xa2:  /* RBID */
                offset++;  /* skip length */
                proto_tree_add_item_ret_uint8(tree, hf_catapult_dct2000_rbid, tvb, offset, 1, ENC_BIG_ENDIAN, &rbid);
                offset++;
                rbid_set = true;
                break;
            case 0x22:  /* CCCH-id setting rbid to CCCH! */
                offset++;  /* skip length */
                proto_tree_add_item(tree, hf_catapult_dct2000_ccch_id, tvb, offset, 1, ENC_BIG_ENDIAN);
                offset++;
                rbid = 18;
                break;
            case 0xc4:  /* No CRC error */
                proto_tree_add_item(tree, hf_catapult_dct2000_no_crc_error, tvb, offset-1, 1, ENC_NA);
                break;
            case 0xc5:  /* CRC error */
                proto_tree_add_item(tree, hf_catapult_dct2000_crc_error, tvb, offset-1, 1, ENC_NA);
                break;
            case 0xf7:  /* Clear Tx Buffer */
                proto_tree_add_item(tree, hf_catapult_dct2000_clear_tx_buffer, tvb, offset-1, 1, ENC_NA);
                break;

            case 0x41:  /* Data !!! */
                offset += skipASNLength(tvb_get_uint8(tvb, offset));
                break;

            default:
                /* For other fields, just skip length and following data */
                length = tvb_get_uint8(tvb, offset++);
                switch (tag) {
                    case 0x42:   /* Buffer Occupancy */
                        proto_tree_add_item(tree, hf_catapult_dct2000_buffer_occupancy, tvb, offset, length, ENC_BIG_ENDIAN);
                        break;
                    case 0x49:   /* PDU Size */
                        proto_tree_add_item(tree, hf_catapult_dct2000_pdu_size, tvb, offset, 2, ENC_LITTLE_ENDIAN);
                        break;
                    case 0x47:   /* UEId type */
                        proto_tree_add_item(tree, hf_catapult_dct2000_ueid_type, tvb, offset, 1, ENC_BIG_ENDIAN);
                        break;
                    case 0x4e:   /* Tx Priority */
                        proto_tree_add_item(tree, hf_catapult_dct2000_tx_priority, tvb, offset, 1, ENC_BIG_ENDIAN);
                        break;
                    case 0x4c:   /* Last in seg set */
                        proto_tree_add_item(tree, hf_catapult_dct2000_last_in_seg_set, tvb, offset, 1, ENC_BIG_ENDIAN);
                        break;
                    case 0x43:   /* Rx timing deviation */
                        proto_tree_add_item(tree, hf_catapult_dct2000_rx_timing_deviation, tvb, offset, 1, ENC_BIG_ENDIAN);
                        break;
                    case 0x46:   /* Transport channel type */
                        proto_tree_add_item(tree, hf_catapult_dct2000_transport_channel_type, tvb, offset, 1, ENC_BIG_ENDIAN);
                        break;
                    case 0xc2:   /* Number of padding bits */
                        proto_tree_add_item(tree, hf_catapult_dct2000_no_padding_bits, tvb, offset, 1, ENC_BIG_ENDIAN);
                        break;

                    default:
                        break;


                }
                offset += length;
        }
    }

    /* Have we got enough info to call dissector */
    if ((tag == 0x41) && ueid_set && rbid_set) {
        attach_rlc_info(pinfo, ueid, rbid, is_sent, outhdr_values,
                        outhdr_values_found);

        /* Set appropriate RLC dissector handle */
        switch (rbid) {
            case 1:  case 2:  case 3:  case 4:  case 5:
            case 6:  case 7:  case 8:  case 9:  case 10:
            case 11: case 12: case 13: case 14: case 15:
                /* DCH channels. */
                /*   TODO: can't really tell if these are control or transport...
                     maybe control with preferences (UAT?) between "rlc.ps_dtch" and "rlc.dcch" ? */
                rlc_umts_handle = find_dissector("rlc.dch_unknown");
                break;
            case 18:
                rlc_umts_handle = find_dissector("rlc.ccch");
                break;
            case 21:
                rlc_umts_handle = find_dissector("rlc.ctch");
                break;

            default:
                /* Give up here */
                return;
        }

        /* Call UMTS RLC dissector */
        if (rlc_umts_handle != 0) {
            rlc_tvb = tvb_new_subset_remaining(tvb, offset);
            call_dissector_only(rlc_umts_handle, rlc_tvb, pinfo, tree, NULL);
        }
    }
}

static char* get_key(wmem_allocator_t *allocator, tvbuff_t*tvb, int offset)
{
    return tvb_bytes_to_str(allocator, tvb, offset, 16);
}


/* Dissect an RRC LTE or NR frame by first parsing the header entries then passing
   the data to the RRC dissector, according to direction and channel type. */
static void dissect_rrc_lte_nr(tvbuff_t *tvb, int offset,
                               packet_info *pinfo, proto_tree *tree,
                               enum LTE_or_NR lte_or_nr)
{
    uint8_t             opcode, tag;
    dissector_handle_t  protocol_handle = 0;
    bool                isUplink        = false;
    LogicalChannelType  logicalChannelType;
    uint16_t            cell_id;
    uint8_t             bcch_transport  = 0;
    uint32_t            ueid = 0;
    tvbuff_t           *rrc_tvb;

    /* Top-level opcode */
    opcode = tvb_get_uint8(tvb, offset++);
    switch (opcode) {
        case 0x00:    /* Data_Req_UE */
        case 0x05:    /* Data_Req_UE_SM */
        case 0x04:    /* Data_Ind_eNodeB */
            isUplink = true;
            break;

        case 0x02:    /* Data_Req_eNodeB */
        case 0x03:    /* Data_Ind_UE */
        case 0x07:    /* Data_Ind_UE_SM */
            isUplink = false;
            break;

        default:
            /* Unexpected opcode tag! */
            return;
    }

    /* Skip length */
    offset += skipASNLength(tvb_get_uint8(tvb, offset));

    /* Get next tag */
    tag = tvb_get_uint8(tvb, offset++);
    switch (tag) {
        case 0x12:    /* UE_Id_LCId */
        {
            /* Dedicated channel info */

            /* Skip length */
            offset++;

            logicalChannelType = Channel_DCCH;

            /* UEId */
            proto_tree_add_item_ret_uint(tree, hf_catapult_dct2000_ueid, tvb, offset, 2, ENC_BIG_ENDIAN, &ueid);
            offset += 2;

            /* Get tag of channel type */
            tag = tvb_get_uint8(tvb, offset++);

            switch (tag) {
                case 0:
                    offset++;
                    col_append_fstr(pinfo->cinfo, COL_INFO, " SRB:%u",
                                    tvb_get_uint8(tvb, offset));
                    proto_tree_add_item(tree, hf_catapult_dct2000_srbid,
                                        tvb, offset, 1, ENC_BIG_ENDIAN);
                    offset++;
                    break;
                case 1:
                    offset++;
                    col_append_fstr(pinfo->cinfo, COL_INFO, " DRB:%u",
                                    tvb_get_uint8(tvb, offset));
                    proto_tree_add_item(tree, hf_catapult_dct2000_drbid,
                                        tvb, offset, 1, ENC_BIG_ENDIAN);
                    offset++;
                    break;

                default:
                    /* Unexpected channel type */
                    return;
            }

            break;
        }

        case 0x1a:     /* Cell_LCId */

            /* Common channel info */

            /* Skip length */
            offset++;

            /* Cell-id */
            proto_tree_add_item(tree, hf_catapult_dct2000_cellid,
                                tvb, offset, 2, ENC_BIG_ENDIAN);
            cell_id = tvb_get_ntohs(tvb, offset);
            offset += 2;

            /* Logical channel type */
            proto_tree_add_item(tree, hf_catapult_dct2000_rlc_channel_type,
                                tvb, offset, 1, ENC_BIG_ENDIAN);
            logicalChannelType = (LogicalChannelType)tvb_get_uint8(tvb, offset);
            offset++;

            /* Won't be seen if RRC decoder is called... */
            col_append_fstr(pinfo->cinfo, COL_INFO, " cell-id=%u %s",
                            cell_id,
                            val_to_str_const(logicalChannelType, rlc_logical_channel_vals,
                                             "UNKNOWN-CHANNEL"));


            switch (logicalChannelType) {
                case Channel_BCCH:
                    /* Skip length */
                    offset++;

                    /* Transport channel type */
                    bcch_transport = tvb_get_uint8(tvb, offset);
                    proto_tree_add_item(tree, hf_catapult_dct2000_bcch_transport,
                                        tvb, offset, 1, ENC_BIG_ENDIAN);
                    offset++;
                    break;

                case Channel_CCCH:
                    /* Skip length */
                    offset++;

                    /* UEId */
                    proto_tree_add_item(tree, hf_catapult_dct2000_ueid,
                                        tvb, offset, 2, ENC_BIG_ENDIAN);
                    offset += 2;
                    break;

                default:
                    break;
            }
            break;

        default:
            /* Unexpected tag */
            return;
    }

    /* Optional Carrier Id */
    if (tvb_get_uint8(tvb, offset)==0x1e) {
        offset += 2;  /* tag + len of 1 */
        proto_tree_add_item(tree, hf_catapult_dct2000_carrier_id,
                            tvb, offset, 1, ENC_BIG_ENDIAN);
        offset++;
    }

    /* Optional Carrier Type */
    if (tvb_get_uint8(tvb, offset)==0x20) {
        offset += 2;
        proto_tree_add_item(tree, hf_catapult_dct2000_carrier_type,
                            tvb, offset, 1, ENC_BIG_ENDIAN);
        offset++;
    }

    /* Optional Cell Group */
    if (tvb_get_uint8(tvb, offset)==0x22) {
        offset += 2;
        proto_tree_add_item(tree, hf_catapult_dct2000_cell_group,
                            tvb, offset, 1, ENC_BIG_ENDIAN);
        offset++;
    }

    if (opcode == 0x07) {
        /* Data_Ind_UE_SM - 1 byte MAC */
        offset++;
    }
    else if (opcode == 0x05) {
        /* Data_Req_UE_SM - SecurityMode Params */
        /* N.B. DRB keys do not get configured here.. */
        offset++;  /* tag */
        uint8_t len = tvb_get_uint8(tvb, offset++); /* length */

        /* Uplink Sec Mode */
        proto_item *sc_ti;
        proto_tree *sc_tree;
        sc_ti = proto_tree_add_item(tree, hf_catapult_dct2000_security_mode_params, tvb, offset, len, ENC_NA);
        sc_tree = proto_item_add_subtree(sc_ti, ett_catapult_dct2000_security_mode_params);

        uint32_t uplink_sec_mode;
        proto_tree_add_item_ret_uint(sc_tree, hf_catapult_dct2000_uplink_sec_mode,
                                     tvb, offset++, 1, ENC_BIG_ENDIAN, &uplink_sec_mode);

        /* Downlink Sec Mode */
        uint32_t downlink_sec_mode;
        proto_tree_add_item_ret_uint(sc_tree, hf_catapult_dct2000_downlink_sec_mode,
                                     tvb, offset++, 1, ENC_BIG_ENDIAN, &downlink_sec_mode);

        if (len > 2) {
            offset++;  /* tag Should be 0x21 */
            offset++; /* len */

            tag = tvb_get_uint8(tvb, offset++);
            if (tag == 0x25) {
                /* Cell Group Id */
                offset++;
                proto_tree_add_item(sc_tree, hf_catapult_dct2000_cell_group,
                                    tvb, offset, 1, ENC_BIG_ENDIAN);
            }

            /* Optional cryptParams */
            if (tag == 0x2) {
                uint32_t cipher_algorithm;

                len = tvb_get_uint8(tvb, offset++);

                /* Cipher algorithm (required) */
                offset += 2; /* Skip tag and length */
                proto_tree_add_item_ret_uint(sc_tree, hf_catapult_dct2000_ciphering_algorithm,
                                             tvb, offset++, 1, ENC_BIG_ENDIAN, &cipher_algorithm);

                /* Ciphering key (optional) */
                if (len > 3) {
                    /* Skip tag and length */
                    offset += 2;
                    proto_tree_add_item(sc_tree, hf_catapult_dct2000_ciphering_key,
                                        tvb, offset, 16, ENC_NA);
                    char *key = get_key(pinfo->pool, tvb, offset);

                    if (!PINFO_FD_VISITED(pinfo)) {
                        if (lte_or_nr == NR) {
                            set_pdcp_nr_rrc_ciphering_key(ueid, key, pinfo->num);
                        }
                        else {
                            set_pdcp_lte_rrc_ciphering_key(ueid, key, pinfo->num);
                        }
                    }
                    offset += 16;
                }
            }
            else {
                offset--;
            }

            /* Now should be Auth params (required) */
            uint32_t integrity_algorithm;
            /* Skip tag */
            offset++;

            len = tvb_get_uint8(tvb, offset++);

            /* Integrity algorithm (required) */
            offset += 2; /* Skip tag and length */
            proto_tree_add_item_ret_uint(sc_tree, hf_catapult_dct2000_integrity_algorithm,
                                         tvb, offset++, 1, ENC_BIG_ENDIAN, &integrity_algorithm);

            /* Integrity key (optional */
            if (len > 3) {
                /* Skip tag and length */
                offset += 2;
                proto_tree_add_item(sc_tree, hf_catapult_dct2000_integrity_key,
                                    tvb, offset, 16, ENC_NA);
                char *key = get_key(pinfo->pool, tvb, offset);

                if (!PINFO_FD_VISITED(pinfo)) {
                    if (lte_or_nr == NR) {
                        set_pdcp_nr_rrc_integrity_key(ueid, key, pinfo->num);
                    }
                    else {
                        set_pdcp_lte_rrc_integrity_key(ueid, key, pinfo->num);
                    }
                }
                offset += 16;
            }
        }
    }

    /* Optional data tag may follow */
    if (!tvb_reported_length_remaining(tvb, offset)) {
        return;
    }
    tag = tvb_get_uint8(tvb, offset++);
    if (tag != 0xaa) {
        return;
    }

    /* Skip length */
    offset += skipASNLength(tvb_get_uint8(tvb, offset));

    /* Look up dissector handle corresponding to direction and channel type */
    if (isUplink) {

        /* Uplink channel types */
        switch (logicalChannelType) {
            case Channel_DCCH:
                if (lte_or_nr == LTE) {
                    protocol_handle = find_dissector("lte_rrc.ul_dcch");
                }
                else {
                    protocol_handle = find_dissector("nr-rrc.ul.dcch");
                }
                break;
            case Channel_CCCH:
                if (lte_or_nr == LTE) {
                    protocol_handle = find_dissector("lte_rrc.ul_ccch");
                }
                else {
                    if (tvb_captured_length_remaining(tvb, offset) == 6) {
                        protocol_handle = find_dissector("nr-rrc.ul.ccch");
                    }
                    else {
                        /* Should be 8 bytes.. */
                        protocol_handle = find_dissector("nr-rrc.ul.ccch1");
                    }
                }
                break;

            default:
                /* Unknown Uplink channel type */
                break;
        }
    } else {

        /* Downlink channel types */
        switch (logicalChannelType) {
            case Channel_DCCH:
                if (lte_or_nr == LTE) {
                    protocol_handle = find_dissector("lte_rrc.dl_dcch");
                }
                else {
                    protocol_handle = find_dissector("nr-rrc.dl.dcch");
                }
                break;
            case Channel_CCCH:
                if (lte_or_nr == LTE) {
                    protocol_handle = find_dissector("lte_rrc.dl_ccch");
                }
                else {
                    protocol_handle = find_dissector("nr-rrc.dl.ccch");
                }
                break;
            case Channel_PCCH:
                if (lte_or_nr == LTE) {
                    protocol_handle = find_dissector("lte_rrc.pcch");
                }
                else {
                    protocol_handle = find_dissector("nr-rrc.pcch");
                }
                break;
            case Channel_BCCH:
                if (bcch_transport == 1) {
                    if (lte_or_nr == LTE) {
                        protocol_handle = find_dissector("lte_rrc.bcch_bch");
                    }
                    else {
                        protocol_handle = find_dissector("nr-rrc.bcch.bch");
                    }
                }
                else {
                    if (lte_or_nr == LTE) {
                        protocol_handle = find_dissector("lte_rrc.bcch_dl_sch");
                    }
                    else {
                        protocol_handle = find_dissector("nr-rrc.bcch.dl.sch");
                    }
                }
                break;

            default:
                /* Unknown Downlink channel type */
                break;
        }
    }

    /* Send to RRC dissector, if got here, have sub-dissector and some data left */
    if ((protocol_handle != NULL) && (tvb_reported_length_remaining(tvb, offset) > 0)) {

        /* Set MAC-NR info for this PDU.  Needed so that UEId can be found for this frame,
         * as used by MAC/RLC/PDCP configuration from RRC dissector */
        if (ueid) {
            struct mac_nr_info *p_mac_nr_info;
            p_mac_nr_info = wmem_new0(wmem_file_scope(), struct mac_nr_info);
            p_mac_nr_info->ueid = ueid;
            p_mac_nr_info->direction = (isUplink) ? DIRECTION_UPLINK : DIRECTION_DOWNLINK;
            /* Store info in packet */
            set_mac_nr_proto_data(pinfo, p_mac_nr_info);
        }

        rrc_tvb = tvb_new_subset_remaining(tvb, offset);
        call_dissector_only(protocol_handle, rrc_tvb, pinfo, tree, NULL);
    }
}


/* Dissect an CCPRI LTE frame by first parsing the header entries then passing
   the data to the CPRI C&M dissector

   XXX - is this the Common Public Radio Interface?  If so, what's the extra
   "C" in "CCPRI"?  And why is the LAPB dissector involved here?  The CPRI
   spec just speaks of HDLC; LAPB is certainly a HDLC-based protocol, but
   that doesn't mean every HDLC-based protocol is LAPB. */
static void dissect_ccpri_lte(tvbuff_t *tvb, int offset,
                              packet_info *pinfo, proto_tree *tree)
{
    uint8_t             opcode;
    uint8_t             tag;
    tvbuff_t           *ccpri_tvb;
    dissector_handle_t  protocol_handle = 0;
    uint16_t            length;

    /* Top-level opcode */
    proto_tree_add_item_ret_uint8(tree, hf_catapult_dct2000_lte_ccpri_opcode, tvb, offset, 1, ENC_BIG_ENDIAN, &opcode);
    offset++;

    /* Skip 2-byte length field */
    offset += 2;

    /* Cell-id */
    proto_tree_add_item(tree, hf_catapult_dct2000_cellid,
                        tvb, offset, 2, ENC_BIG_ENDIAN);
    offset += 2;

    /* Status (ind only) */
    if (opcode == 2) {
        proto_item *ti;
        uint8_t status = tvb_get_uint8(tvb, offset);
        ti = proto_tree_add_item(tree, hf_catapult_dct2000_lte_ccpri_status,
                                 tvb, offset, 1, ENC_BIG_ENDIAN);
        offset++;

        if (status != 0) {
            expert_add_info(pinfo, ti, &ei_catapult_dct2000_lte_ccpri_status_error);

        }
    }

    /* Channel ID */
    proto_tree_add_item(tree, hf_catapult_dct2000_lte_ccpri_channel,
                        tvb, offset, 1, ENC_BIG_ENDIAN);
    offset++;

    /* Data tag must follow */
    tag = tvb_get_uint8(tvb, offset++);
    if (tag != 2) {
        return;
    }

    /* Skip length */
    length = tvb_get_ntohs(tvb, offset);
    offset += 2;

    /* Send remainder to lapb dissector; I assume "CPRI" is the Common
       Public Radio Interface, in which case the "lapb" dissector is
       being used to dissect the HDLC used by CPRI, and in which case
       we should really have a CPRI dissector that dissects its HDLC
       and then hands off to a CPRI C&M dissector. */
    protocol_handle = find_dissector("lapb");
    if ((protocol_handle != NULL) && (tvb_reported_length_remaining(tvb, offset) > 0)) {
        ccpri_tvb = tvb_new_subset_length(tvb, offset, length);
        call_dissector_only(protocol_handle, ccpri_tvb, pinfo, tree, NULL);
    }
}




/* Dissect a PDCP LTE frame by first parsing the RLCPrim header then passing
   the data to the PDCP LTE dissector */
static void dissect_pdcp_lte(tvbuff_t *tvb, int offset,
                             packet_info *pinfo, proto_tree *tree)
{
    uint8_t               opcode;
    uint8_t               tag;
    struct pdcp_lte_info *p_pdcp_lte_info;
    tvbuff_t             *pdcp_lte_tvb;
    uint16_t              ueid;
    uint8_t               channelId;

    /* Look this up so can update channel info */
    p_pdcp_lte_info = (struct pdcp_lte_info *)p_get_proto_data(wmem_file_scope(), pinfo, proto_pdcp_lte, 0);
    if (p_pdcp_lte_info == NULL) {
        /* This really should be set...can't dissect anything without it */
        return;
    }

    /* Top-level opcode */
    opcode = tvb_get_uint8(tvb, offset);
    if (tree) {
        proto_tree_add_item(tree, hf_catapult_dct2000_rlc_op, tvb, offset, 1, ENC_BIG_ENDIAN);
    }
    offset++;

    col_set_str(pinfo->cinfo, COL_INFO, val_to_str_const(opcode, rlc_op_vals, "Unknown"));

    /* Assume UE side, so REQ is UL, IND is DL */
    switch (opcode) {
       case RLC_AM_DATA_REQ:
       case RLC_UM_DATA_REQ:
       case RLC_TR_DATA_REQ:
           p_pdcp_lte_info->direction = DIRECTION_UPLINK;
           break;

       default:
           p_pdcp_lte_info->direction = DIRECTION_DOWNLINK;
    }

    /* Parse header */
    switch (opcode) {
        case RLC_AM_DATA_REQ:
        case RLC_AM_DATA_IND:
        case RLC_UM_DATA_REQ:
        case RLC_UM_DATA_IND:
        case RLC_TR_DATA_REQ:
        case RLC_TR_DATA_IND:

            /* Get next tag */
            tag = tvb_get_uint8(tvb, offset++);
            switch (tag) {
                case 0x10:    /* UE_Id_LCId */

                    /* Dedicated channel info */

                    /* Length will fit in one byte here */
                    offset++;

                    p_pdcp_lte_info->channelType = Channel_DCCH;

                    /* UEId */
                    proto_tree_add_item_ret_uint16(tree, hf_catapult_dct2000_ueid, tvb, offset, 2, ENC_BIG_ENDIAN, &ueid);
                    col_append_fstr(pinfo->cinfo, COL_INFO,
                                    " UEId=%u", ueid);
                    p_pdcp_lte_info->ueid = ueid;
                    offset += 2;

                    /* Get tag of channel type */
                    tag = tvb_get_uint8(tvb, offset++);

                    switch (tag) {
                        case 0:
                            offset++;
                            channelId = tvb_get_uint8(tvb, offset);
                            col_append_fstr(pinfo->cinfo, COL_INFO, " SRB:%u",
                                            channelId);
                            proto_tree_add_item(tree, hf_catapult_dct2000_srbid,
                                                tvb, offset++, 1, ENC_BIG_ENDIAN);
                            p_pdcp_lte_info->channelId = channelId;
                            break;
                        case 1:
                            offset++;
                            channelId = tvb_get_uint8(tvb, offset);
                            col_append_fstr(pinfo->cinfo, COL_INFO, " DRB:%u",
                                            channelId);
                            proto_tree_add_item(tree, hf_catapult_dct2000_drbid,
                                                tvb, offset++, 1, ENC_BIG_ENDIAN);
                            p_pdcp_lte_info->channelId = channelId;
                            break;

                        default:
                            /* Unexpected channel type */
                            return;
                    }
                    break;

                case 0x1a:     /* Cell_LCId */

                    /* Common channel info */

                    /* Skip length */
                    offset++;

                    /* Cell-id */
                    proto_tree_add_item(tree, hf_catapult_dct2000_cellid,
                                        tvb, offset, 2, ENC_BIG_ENDIAN);
                    offset += 2;

                    /* Logical channel type */
                    proto_tree_add_item(tree, hf_catapult_dct2000_rlc_channel_type,
                                        tvb, offset, 1, ENC_BIG_ENDIAN);
                    p_pdcp_lte_info->channelType = (LogicalChannelType)tvb_get_uint8(tvb, offset++);
                    col_append_fstr(pinfo->cinfo, COL_INFO, " %s",
                                    val_to_str_const(p_pdcp_lte_info->channelType, rlc_logical_channel_vals,
                                                     "UNKNOWN-CHANNEL"));

                    switch (p_pdcp_lte_info->channelType) {
                        case Channel_BCCH:
                            /* Skip length */
                            offset++;

                            /* Transport channel type */
                            p_pdcp_lte_info->BCCHTransport = (BCCHTransportType)tvb_get_uint8(tvb, offset);
                            proto_tree_add_item(tree, hf_catapult_dct2000_bcch_transport,
                                                tvb, offset, 1, ENC_BIG_ENDIAN);
                            offset++;
                            break;

                        case Channel_CCCH:
                            /* Skip length */
                            offset++;

                            /* UEId */
                            proto_tree_add_item_ret_uint16(tree, hf_catapult_dct2000_ueid,
                                                           tvb, offset, 2, ENC_BIG_ENDIAN, &ueid);
                            offset += 2;

                            col_append_fstr(pinfo->cinfo, COL_INFO, " UEId=%u", ueid);
                            break;

                        default:
                            break;
                    }
                    break;

                default:
                    /* Unexpected tag */
                    return;
            }

            /* Other optional fields may follow */
            tag = tvb_get_uint8(tvb, offset++);
            while ((tag != 0x41) && (tvb_reported_length_remaining(tvb, offset) > 2)) {

                if (tag == 0x35) {
                    /* This is MUI */
                    offset++;
                    proto_tree_add_item(tree, hf_catapult_dct2000_rlc_mui,
                                        tvb, offset, 2, ENC_BIG_ENDIAN);
                    offset += 2;

                    /* CNF follows MUI in AM */
                    if ((opcode == RLC_AM_DATA_REQ) || (opcode == RLC_AM_DATA_IND)) {
                        proto_tree_add_item(tree, hf_catapult_dct2000_rlc_cnf,
                                               tvb, offset, 1, ENC_NA);
                        offset++;
                    }
                }
                else if (tag == 0x45) {
                    /* Discard Req */
                    offset++;
                    proto_tree_add_item(tree, hf_catapult_dct2000_rlc_discard_req,
                                           tvb, offset, 1, ENC_NA);
                    offset++;
                }

                tag = tvb_get_uint8(tvb, offset++);
            }


            /********************************/
            /* Should be at data tag now    */

            /* Call PDCP LTE dissector */
            pdcp_lte_tvb = tvb_new_subset_remaining(tvb, offset);
            call_dissector_only(pdcp_lte_handle, pdcp_lte_tvb, pinfo, tree, NULL);

            break;

        default:
            return;
    }
}





/* Look up dissector by protocol name.  Fix up known name mis-matches.
   This includes exact matches and prefixes (e.g. "diameter_rx" -> "diameter") */
static dissector_handle_t look_for_dissector(const char *protocol_name)
{
    if (strncmp(protocol_name, "diameter", strlen("diameter")) == 0) {
        return find_dissector("diameter");
    }
    else
    if (strncmp(protocol_name, "gtpv2_r", 7) == 0) {
        return find_dissector("gtpv2");
    }
    else
    if (strncmp(protocol_name, "s1ap", 4) == 0) {
        return find_dissector("s1ap");
    }
    else
    if (strncmp(protocol_name, "x2ap_r", 6) == 0) {
        return find_dissector("x2ap");
    }
    else
    if (strncmp(protocol_name, "xnap_r1", 7) == 0) {
        return find_dissector("xnap");
    }
    else
    if (strncmp(protocol_name, "ngap_r1", 7) == 0) {
        return find_dissector("ngap");
    }

    /* Only check really old names to convert if preference is checked */
    else if (catapult_dct2000_dissect_old_protocol_names) {
        /* Use known aliases and protocol name prefixes */
        if (strcmp(protocol_name, "tbcp") == 0) {
            return find_dissector("rtcp");
        }
        else
        if ((strcmp(protocol_name, "xcap_caps") == 0) ||
            (strcmp(protocol_name, "soap") == 0) ||
            (strcmp(protocol_name, "mm1") == 0) ||
            (strcmp(protocol_name, "mm3") == 0) ||
            (strcmp(protocol_name, "mm7") == 0)) {

             return find_dissector("http");
        }
        else
        if ((strncmp(protocol_name, "fp_r", 4) == 0) ||
            (strcmp(protocol_name, "fpiur_r5") == 0)) {

            return find_dissector("fp");
        }
        else
        if (strncmp(protocol_name, "iuup_rtp_r", strlen("iuup_rtp_r")) == 0) {
            return find_dissector("rtp");
        }
        else
        if (strcmp(protocol_name, "sipt") == 0) {
            return find_dissector("sip");
        }
        else
        if (strncmp(protocol_name, "nbap_sctp", strlen("nbap_sctp")) == 0) {
            return find_dissector("nbap");
        }
        else
        if (strcmp(protocol_name, "dhcpv4") == 0) {
            return find_dissector("dhcp");
        }
        else
        if (strcmp(protocol_name, "wimax") == 0) {
            return find_dissector("wimaxasncp");
        }
        else
        if (strncmp(protocol_name, "sabp", strlen("sabp")) == 0) {
            return find_dissector("sabp");
        }
        else
        if (strcmp(protocol_name, "wtp") == 0) {
            return find_dissector("wtp-udp");
        }
        else
        if (strncmp(protocol_name, "gtp", strlen("gtp")) == 0) {
            return find_dissector("gtp");
        }
    }

    /* Try for an exact match */
    return find_dissector(protocol_name);
}


/* Populate outhdr_values array with numbers found in outhdr_string */
static unsigned parse_outhdr_string(const char *outhdr_string, int outhdr_string_len, unsigned *outhdr_values)
{
    int   n                 = 0;
    int   outhdr_values_found;

    /* Populate values array */
    for (outhdr_values_found=0; outhdr_values_found < MAX_OUTHDR_VALUES; ) {

        unsigned  digit_array[MAX_OUTHDR_VALUES];
        unsigned  number_digits = 0;

        unsigned   number = 0;
        unsigned   multiplier = 1;
        unsigned   d;

        /* Find digits */
        for ( ; (n < outhdr_string_len) && (number_digits < MAX_OUTHDR_VALUES); n++) {
            if (!g_ascii_isdigit(outhdr_string[n])) {
                break;
            }
            else {
                digit_array[number_digits++] = outhdr_string[n] - '0';
            }
        }

        if (number_digits == 0) {
            /* No more numbers left */
            break;
        }

        /* Convert digits into value (much faster than format_text() + atoi()) */
        for (d=number_digits; d > 0; d--) {
            number += ((digit_array[d-1]) * multiplier);
            multiplier *= 10;
        }
        outhdr_values[outhdr_values_found++] = number;

        /* Skip comma */
        n++;
    }
    return outhdr_values_found;
}



/* Fill in an FP packet info struct and attach it to the packet for the FP
   dissector to use */
static void attach_fp_info(packet_info *pinfo, bool received,
                           const char *protocol_name, int variant,
                           unsigned *outhdr_values, unsigned outhdr_values_found)
{
    unsigned i = 0;
    int   chan;
    unsigned tf_start, num_chans_start;
    int   node_type;
    int   calculated_variant;

    /* Only need to set info once per session. */
    struct fp_info *p_fp_info = (struct fp_info *)p_get_proto_data(wmem_file_scope(), pinfo, proto_fp, 0);
    if (p_fp_info != NULL) {
        return;
    }

    /* Allocate struct */
    p_fp_info = wmem_new0(wmem_file_scope(), struct fp_info);

    /* Check that the number of outhdr values looks sensible */
    if (((strcmp(protocol_name, "fpiur_r5") == 0) && (outhdr_values_found != 2)) ||
        (outhdr_values_found < 5)) {

        return;
    }

    /* 3gpp release (99, 4, 5, 6, 7) */
    if (strcmp(protocol_name, "fp") == 0) {
        p_fp_info->release = 99;
    }
    else if (strcmp(protocol_name, "fp_r4") == 0) {
        p_fp_info->release = 4;
    }
    else if (strcmp(protocol_name, "fp_r5") == 0) {
        p_fp_info->release = 5;
    }
    else if (strcmp(protocol_name, "fp_r6") == 0) {
        p_fp_info->release = 6;
    }
    else if (strcmp(protocol_name, "fp_r7") == 0) {
        p_fp_info->release = 7;
    }
    else if (strcmp(protocol_name, "fp_r8") == 0) {
        p_fp_info->release = 8;
    }
    else if (strcmp(protocol_name, "fpiur_r5") == 0) {
        p_fp_info->release = 5;
    }
    else {
        /* Really shouldn't get here */
        DISSECTOR_ASSERT_NOT_REACHED();
        return;
    }

    /* Release date is derived from variant number */
    /* Only R6 sub-versions currently influence format within a release */
    switch (p_fp_info->release) {
        case 6:
            if (variant < 256) {
                calculated_variant = variant;
            }
            else {
                calculated_variant = variant / 256;
            }

            switch (calculated_variant) {
                case 1:
                    p_fp_info->release_year = 2005;
                    p_fp_info->release_month = 6;
                    break;
                case 2:
                    p_fp_info->release_year = 2005;
                    p_fp_info->release_month = 9;
                    break;
                case 3:
                default:
                    p_fp_info->release_year = 2006;
                    p_fp_info->release_month = 3;
                    break;
            }
            break;
        case 7:
            p_fp_info->release_year = 2008;
            p_fp_info->release_month = 3;
            break;

        case 8:
            p_fp_info->release_year = 2010;
            p_fp_info->release_month = 6;
            break;


        default:
            p_fp_info->release_year = 0;
            p_fp_info->release_month = 0;
    }


    /* Channel type */
    p_fp_info->channel = outhdr_values[i++];
    /* Sad hack until this value is filled in properly */
    if (p_fp_info->channel == 0) {
        p_fp_info->channel = CHANNEL_DCH;
    }

    /* Derive direction from node type/side */
    node_type = outhdr_values[i++];
    p_fp_info->is_uplink = (( received  && (node_type == 2)) ||
                            (!received  && (node_type == 1)));

    /* Division type introduced for R7 */
    if ((p_fp_info->release == 7) ||
        (p_fp_info->release == 8)) {
        p_fp_info->division = (enum division_type)outhdr_values[i++];
    }

    /* HS-DSCH config */
    if (p_fp_info->channel == CHANNEL_HSDSCH) {
        if ((p_fp_info->release == 7) ||
            (p_fp_info->release == 8)) {
            /* Entity (MAC-hs or MAC-ehs) used */
            if (outhdr_values[i++]) {
                p_fp_info->hsdsch_entity = ehs;
            }
        }
        else {
            /* This is the pre-R7 default */
            p_fp_info->hsdsch_entity = hs;
        }
    }


    /* IUR only uses the above... */
    if (strcmp(protocol_name, "fpiur_r5") == 0) {
        /* Store info in packet */
        p_fp_info->iface_type = IuR_Interface;
        p_add_proto_data(wmem_file_scope(), pinfo, proto_fp, 0, p_fp_info);
        return;
    }

    /* DCH CRC present... */
    p_fp_info->dch_crc_present = outhdr_values[i++];

    /* ... but don't trust for edch */
    if (p_fp_info->channel == CHANNEL_EDCH) {
        p_fp_info->dch_crc_present = 2; /* unknown */
    }

    /* How many paging indications (if PCH data) */
    p_fp_info->paging_indications = outhdr_values[i++];

    /* Number of channels (for coordinated channels) */
    p_fp_info->num_chans = outhdr_values[i++];
    if (p_fp_info->num_chans > MAX_FP_CHANS) {
        p_fp_info->num_chans = MAX_FP_CHANS;
    }

    /* EDCH-Common is always T2 */
    if (p_fp_info->channel == CHANNEL_EDCH_COMMON) {
        p_fp_info->edch_type = 1;
    }

    if (p_fp_info->channel != CHANNEL_EDCH) {
        /* TF size for each channel */
        tf_start = i;
        for (chan=0; chan < p_fp_info->num_chans; chan++) {
            if (outhdr_values_found > tf_start+chan) {
                p_fp_info->chan_tf_size[chan] = outhdr_values[tf_start+chan];
            } else {
                p_fp_info->chan_tf_size[chan] = 0;
            }
        }

        /* Number of TBs for each channel */
        num_chans_start = tf_start + p_fp_info->num_chans;
        for (chan=0; chan < p_fp_info->num_chans; chan++) {
            if (outhdr_values_found > num_chans_start+chan) {
                p_fp_info->chan_num_tbs[chan] = outhdr_values[num_chans_start+chan];
            } else {
                p_fp_info->chan_num_tbs[chan] = 0;
            }
        }
    }
    /* EDCH info */
    else {
        int n;

        p_fp_info->no_ddi_entries = outhdr_values[i++];
        if (p_fp_info->no_ddi_entries > MAX_EDCH_DDIS) {
            p_fp_info->no_ddi_entries = MAX_EDCH_DDIS;
        }

        /* DDI values */
        for (n=0; n < p_fp_info->no_ddi_entries; n++) {
            if (outhdr_values_found > i) {
                p_fp_info->edch_ddi[n] = outhdr_values[i++];
            } else {
                p_fp_info->edch_ddi[n] = 0;
            }
        }

        /* Corresponding MAC-d sizes */
        for (n=0; n < p_fp_info->no_ddi_entries; n++) {
            if (outhdr_values_found > i) {
                p_fp_info->edch_macd_pdu_size[n] = outhdr_values[i++];
            } else {
                p_fp_info->edch_macd_pdu_size[n] = 0;
            }
        }

        if (strcmp(protocol_name, "fp_r8") == 0) {
            if (outhdr_values_found > i) {
                p_fp_info->edch_type = outhdr_values[i];
            } else {
                p_fp_info->edch_type = 0;
            }
        }
        else {
            p_fp_info->edch_type = 0;
        }
    }

    /* Interface must be IuB */
    p_fp_info->iface_type = IuB_Interface;

    /* Store info in packet */
    p_add_proto_data(wmem_file_scope(), pinfo, proto_fp, 0, p_fp_info);
}


/* Fill in an RLC packet info struct and attach it to the packet for the RLC
   dissector to use */
static void attach_rlc_info(packet_info *pinfo, uint32_t urnti, uint8_t rbid,
                            bool is_sent, unsigned *outhdr_values,
                            unsigned outhdr_values_found)
{
    /* Only need to set info once per session. */
    struct fp_info  *p_fp_info;
    struct rlc_info *p_rlc_info = (struct rlc_info *)p_get_proto_data(wmem_file_scope(), pinfo, proto_umts_rlc, 0);

    if (p_rlc_info != NULL) {
        return;
    }

    /* Check that the number of outhdr values looks correct */
    if (outhdr_values_found != 2) {
        return;
    }

    /* Allocate structs */
    p_rlc_info = wmem_new(wmem_file_scope(), struct rlc_info);
    p_fp_info = wmem_new0(wmem_file_scope(), struct fp_info);

    /* Fill in struct fields for first (only) PDU in this frame */

    /* Urnti.  Just use UEId */
    p_rlc_info->ueid[0] = urnti;

    /* ciphered (off by default) */
    p_rlc_info->ciphered[0] = false;

    /* deciphered (off by default) */
    p_rlc_info->deciphered[0] = false;

    /* Mode. */
    switch (outhdr_values[1]) {
        case 1:
            p_rlc_info->mode[0] = RLC_TM;
            break;
        case 2:
            p_rlc_info->mode[0] = RLC_UM;
            break;
        case 3:
            p_rlc_info->mode[0] = RLC_AM;
            break;
        case 4:
            p_rlc_info->mode[0] = RLC_UM;
            p_rlc_info->ciphered[0] = true;
            break;
        case 5:
            p_rlc_info->mode[0] = RLC_AM;
            p_rlc_info->ciphered[0] = true;
            break;
        default:
            return;
    }

    /* rbid. TODO: does this need conversion? */
    p_rlc_info->rbid[0] = rbid;

    /* li_size */
    p_rlc_info->li_size[0] = (enum rlc_li_size)outhdr_values[0];

    /* Store info in packet */
    p_add_proto_data(wmem_file_scope(), pinfo, proto_umts_rlc, 0, p_rlc_info);

    /* Also store minimal FP info consulted by RLC dissector
       TODO: Don't really know direction, but use S/R flag to make
       logs in same context consistent. Will be correct for NodeB logs,
       but RLC dissector seems to not use anyway... */
    p_fp_info->is_uplink = is_sent;
    p_fp_info->cur_tb = 0; /* Always the first/only one */
    p_add_proto_data(wmem_file_scope(), pinfo, proto_fp, 0, p_fp_info);
}


/* Fill in a MAC LTE packet info struct and attach it to the packet for that
   dissector to use */
static void attach_mac_lte_info(packet_info *pinfo, unsigned *outhdr_values, unsigned outhdr_values_found)
{
    struct mac_lte_info *p_mac_lte_info;
    unsigned int         i = 0;

    /* Only need to set info once per session. */
    p_mac_lte_info = get_mac_lte_proto_data(pinfo);
    if (p_mac_lte_info != NULL) {
        return;
    }

    /* Allocate & zero struct */
    p_mac_lte_info = wmem_new0(wmem_file_scope(), struct mac_lte_info);

    /* Populate the struct from outhdr values */
    p_mac_lte_info->crcStatusValid = false;  /* not set yet */

    p_mac_lte_info->radioType = outhdr_values[i++] + 1;        // 1
    p_mac_lte_info->rntiType = outhdr_values[i++];             // 2
    p_mac_lte_info->direction = outhdr_values[i++];            // 3
    /* Set these extra PHY present flags to false by default */
    if (p_mac_lte_info->direction == DIRECTION_UPLINK) {
        p_mac_lte_info->detailed_phy_info.ul_info.present = false;
    }
    else {
        p_mac_lte_info->detailed_phy_info.dl_info.present = false;
    }

    p_mac_lte_info->sfnSfInfoPresent = true;
    p_mac_lte_info->subframeNumber = outhdr_values[i++];       // 4
    p_mac_lte_info->isPredefinedData = outhdr_values[i++];     // 5
    p_mac_lte_info->rnti = outhdr_values[i++];                 // 6
    p_mac_lte_info->ueid = outhdr_values[i++];                 // 7
    p_mac_lte_info->length = outhdr_values[i++];               // 8
    if (outhdr_values_found > 8) {
        p_mac_lte_info->reTxCount = outhdr_values[i++];        // 9
    }
    /* TODO: delete if won't see this special case anymore? */
    if (outhdr_values_found == 10) {
        /* CRC only valid for Downlink */
        if (p_mac_lte_info->direction == DIRECTION_DOWNLINK) {
            p_mac_lte_info->crcStatusValid = true;
            p_mac_lte_info->crcStatus = (mac_lte_crc_status)outhdr_values[i++]; // 10
        }
        else {
            i++;     // 10 (ignoring for UL)
        }
    }

    p_mac_lte_info->dl_retx = dl_retx_unknown;

    if (outhdr_values_found > 10) {
        /* Extra PHY parameters */
        if (p_mac_lte_info->direction == DIRECTION_DOWNLINK) {
            p_mac_lte_info->detailed_phy_info.dl_info.present = outhdr_values[i++];         // 10
            p_mac_lte_info->detailed_phy_info.dl_info.dci_format = outhdr_values[i++];      // 11
            p_mac_lte_info->detailed_phy_info.dl_info.resource_allocation_type = outhdr_values[i++]; // 12
            p_mac_lte_info->detailed_phy_info.dl_info.aggregation_level = outhdr_values[i++];  // 13
            p_mac_lte_info->detailed_phy_info.dl_info.mcs_index = outhdr_values[i++];          // 14
            p_mac_lte_info->detailed_phy_info.dl_info.redundancy_version_index = outhdr_values[i++]; // 15
            p_mac_lte_info->dl_retx = (outhdr_values[i++]) ? dl_retx_yes : dl_retx_no;  // 16

            p_mac_lte_info->detailed_phy_info.dl_info.resource_block_length = outhdr_values[i++]; // 17
            p_mac_lte_info->crcStatusValid = true;                                                // 18
            p_mac_lte_info->crcStatus = (mac_lte_crc_status)outhdr_values[i++];
            if (outhdr_values_found > 18) {
                p_mac_lte_info->detailed_phy_info.dl_info.harq_id = outhdr_values[i++];    // 19
                p_mac_lte_info->detailed_phy_info.dl_info.ndi = outhdr_values[i++];        // 20
            }
            if (outhdr_values_found > 20) {
                p_mac_lte_info->detailed_phy_info.dl_info.transport_block = outhdr_values[i++];  // 21
            }
        }
        else {
            /* Uplink */
            p_mac_lte_info->detailed_phy_info.ul_info.present = outhdr_values[i++];          // 10
            p_mac_lte_info->detailed_phy_info.ul_info.modulation_type = outhdr_values[i++];  // 11
            p_mac_lte_info->detailed_phy_info.ul_info.tbs_index = outhdr_values[i++];        // 12
            p_mac_lte_info->detailed_phy_info.ul_info.resource_block_length = outhdr_values[i++]; // 13
            p_mac_lte_info->detailed_phy_info.ul_info.resource_block_start = outhdr_values[i++];  // 14
            /* Skip retx flag */
            i++;                                                                                  // 15

            /* TODO: delete if won't see this special case anymore? */
            if (outhdr_values_found == 16) {
                p_mac_lte_info->subframeNumberOfGrantPresent = true;
                p_mac_lte_info->subframeNumberOfGrant = outhdr_values[i++];   // 16
            }
            if (outhdr_values_found > 16) {
                p_mac_lte_info->detailed_phy_info.ul_info.harq_id = outhdr_values[i++]; // 16
                p_mac_lte_info->detailed_phy_info.ul_info.ndi = outhdr_values[i++];     // 17

                p_mac_lte_info->subframeNumberOfGrantPresent = true;
                p_mac_lte_info->subframeNumberOfGrant = outhdr_values[i++];             // 18
            }
        }
    }

    /* System frame number */
    if (i < outhdr_values_found) {
        p_mac_lte_info->sysframeNumber = outhdr_values[i++];
    }

    if ((p_mac_lte_info->direction == DIRECTION_UPLINK) &&
        (i < outhdr_values_found)) {

        p_mac_lte_info->isPHICHNACK = outhdr_values[i++];
    }

    if (p_mac_lte_info->direction == DIRECTION_UPLINK) {
        /* R10 parameter not set yet */
        p_mac_lte_info->isExtendedBSRSizes = false;
    }

    if (i < outhdr_values_found) {
        /* Carrier ID */
        p_mac_lte_info->carrierId = (mac_lte_carrier_id)outhdr_values[i++];
    }

    /* Remaining fields not (yet?) supported in
       the mac-lte dissector. */
    if (i++ < outhdr_values_found) {
        /* Serving cell index */
    }
    if (i < outhdr_values_found) {
        /* UE Type */
    }

    /* Store info in packet */
    set_mac_lte_proto_data(pinfo, p_mac_lte_info);
}


/* Fill in a RLC LTE packet info struct and attach it to the packet for that
   dissector to use */
static void attach_rlc_lte_info(packet_info *pinfo, unsigned *outhdr_values,
                                unsigned outhdr_values_found _U_)
{
    struct rlc_lte_info *p_rlc_lte_info;
    unsigned int         i = 0;

    /* Only need to set info once per session. */
    p_rlc_lte_info = (rlc_lte_info *)p_get_proto_data(wmem_file_scope(), pinfo, proto_rlc_lte, 0);
    if (p_rlc_lte_info != NULL) {
        return;
    }

    /* Allocate & zero struct */
    p_rlc_lte_info = wmem_new0(wmem_file_scope(), rlc_lte_info);

    p_rlc_lte_info->rlcMode = outhdr_values[i++];
    p_rlc_lte_info->direction = outhdr_values[i++];
    p_rlc_lte_info->priority = outhdr_values[i++];
    p_rlc_lte_info->sequenceNumberLength = outhdr_values[i++];
    p_rlc_lte_info->channelId = outhdr_values[i++];
    p_rlc_lte_info->channelType = outhdr_values[i++];
    p_rlc_lte_info->ueid = outhdr_values[i++];
    p_rlc_lte_info->pduLength = outhdr_values[i];

    /* Store info in packet */
    p_add_proto_data(wmem_file_scope(), pinfo, proto_rlc_lte, 0, p_rlc_lte_info);
}

/* Fill in a PDCP LTE packet info struct and attach it to the packet for the PDCP LTE
   dissector to use */
static void attach_pdcp_lte_info(packet_info *pinfo, unsigned *outhdr_values,
                                 unsigned outhdr_values_found _U_)
{
    struct pdcp_lte_info *p_pdcp_lte_info;
    unsigned int          i = 0;

    /* Only need to set info once per session. */
    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) {
        return;
    }

    /* Allocate & zero struct */
    p_pdcp_lte_info = wmem_new0(wmem_file_scope(), pdcp_lte_info);

    p_pdcp_lte_info->no_header_pdu = outhdr_values[i++];
    p_pdcp_lte_info->plane = (enum pdcp_plane)outhdr_values[i++];
    if (p_pdcp_lte_info->plane != USER_PLANE) {
        p_pdcp_lte_info->plane = SIGNALING_PLANE;
    }
    p_pdcp_lte_info->seqnum_length = outhdr_values[i++];

    p_pdcp_lte_info->rohc.rohc_compression = outhdr_values[i++];
    p_pdcp_lte_info->rohc.rohc_ip_version = outhdr_values[i++];
    p_pdcp_lte_info->rohc.cid_inclusion_info = outhdr_values[i++];
    p_pdcp_lte_info->rohc.large_cid_present = outhdr_values[i++];
    p_pdcp_lte_info->rohc.mode = (enum rohc_mode)outhdr_values[i++];
    p_pdcp_lte_info->rohc.rnd = outhdr_values[i++];
    p_pdcp_lte_info->rohc.udp_checksum_present = outhdr_values[i++];
    p_pdcp_lte_info->rohc.profile = outhdr_values[i];

    /* Remaining 2 (fixed) fields are ah_length and gre_checksum */

    /* Store info in packet */
    p_add_proto_data(wmem_file_scope(), pinfo, proto_pdcp_lte, 0, p_pdcp_lte_info);
}


/* Attempt to show tty (raw character messages) as text lines. */
static void dissect_tty_lines(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
{
    unsigned    linelen, next_offset;
    proto_tree *tty_tree;
    proto_item *ti;
    int         lines = 0;

    /* Create tty tree. */
    ti = proto_tree_add_item(tree, hf_catapult_dct2000_tty, tvb, offset, -1, ENC_NA);
    tty_tree = proto_item_add_subtree(ti, ett_catapult_dct2000_tty);

    /* Show the tty lines one at a time. */
    while (tvb_offset_exists(tvb, offset)) {
        /* Find the end of the line. */
        tvb_find_line_end_unquoted_remaining(tvb, offset, &linelen, &next_offset);

        /* Extract & add the string. */
        char *string = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset, linelen, ENC_ASCII);
        if (g_ascii_isprint(string[0])) {
            /* If the first byte of the string is printable ASCII treat as string... */
            proto_tree_add_string_format(tty_tree, hf_catapult_dct2000_tty_line,
                                         tvb, offset,
                                         linelen, string,
                                         "%s", string);
        }
        else {
            /* Otherwise show as $hex */
            int tty_string_length = tvb_reported_length_remaining(tvb, offset);

            wmem_strbuf_t *hex_buf = wmem_strbuf_new(pinfo->pool, "$");
            wmem_strbuf_append(hex_buf, tvb_bytes_to_str(pinfo->pool, tvb, offset, tty_string_length));

            string = wmem_strbuf_finalize(hex_buf);
        }
        lines++;

        /* Show first line in info column */
        if (lines == 1) {
            col_append_fstr(pinfo->cinfo, COL_INFO, "tty (%s", string);
            proto_item_append_text(ti, " (%s)", string);
        }

        /* Move onto next line. */
        offset = next_offset;
    }

    /* Close off summary of tty message in info column */
    if (lines != 0) {
        col_append_str(pinfo->cinfo, COL_INFO, (lines > 1) ? "...)" : ")");
    }
}


/* Scan the log comment looking for notable out-of-band MAC events that should
   be sent to the MAC dissector */
static void check_for_oob_mac_lte_events(packet_info *pinfo, tvbuff_t *tvb, proto_tree *tree,
                                         const char *string)
{
    unsigned             number_of_ues;
    unsigned             ueids[MAX_SRs];
    unsigned             rntis[MAX_SRs];
    unsigned             rapid;
    unsigned             rach_attempt_number;
    unsigned             temp;
    mac_lte_oob_event    oob_event;
    struct mac_lte_info *p_mac_lte_info;

    /* Current strings of interest begin with ">> ", so if don't see, avoid sscanf() calls. */
    if (strncmp(string, ">> ", 3) != 0) {
        return;
    }

    /*********************************************/
    /* Look for strings matching formats         */

    /* RACH Preamble request */
    if (sscanf(string, ">> RACH Preamble Request [CarrierId=%u] [LTE UE = %u] [RAPID = %u] [Attempt = %u",
               &temp, &ueids[0], &rapid, &rach_attempt_number) == 4) {
        oob_event = ltemac_send_preamble;
    }

    /* Scheduling Requests */
    else if (sscanf(string, ">> Schedule Requests (%u)  [CarrierId=%u][UE=%u][RNTI=%u]",
                    &number_of_ues, &temp, &ueids[0], &rntis[0]) == 4) {
        const char *current_position;

        /* Newer, multi-UE format */
        oob_event = ltemac_send_sr;

        /* Parse other ueid/rnti pairs */
        number_of_ues = MIN(number_of_ues, MAX_SRs);
        if (number_of_ues > 1) {
            current_position = string;

            for (unsigned n=1; n < number_of_ues; n++) {

                /* Find the start of the next entry */
                current_position = strstr(current_position, "] ");
                if (current_position != NULL) {
                    current_position += 2;
                }
                else {
                    /* This is an error - shouldn't happen */
                    return;
                }

                /* Read this entry */
                if (sscanf(current_position, "[UE=%u][RNTI=%u]", &ueids[n], &rntis[n]) != 2) {
                    /* Assuming that if we can't read this one there is no point trying others */
                    number_of_ues = n;
                    break;
                }
            }
        }
    }

    /* SR failures */
    else if (sscanf(string, ">> INFO (inst %u) MAC:    [UE = %u]    SR failed (CRNTI=%u)",
                    &temp, &ueids[0], &rntis[0]) == 3) {
        oob_event = ltemac_sr_failure;
    }

    /* No events found */
    else return;


    /********************************************/
    /* We have an event. Allocate & zero struct */
    p_mac_lte_info = wmem_new0(wmem_file_scope(), mac_lte_info);

    /* This indicates to MAC dissector that it has an oob event */
    p_mac_lte_info->length = 0;

    switch (oob_event) {
        case ltemac_send_preamble:
            p_mac_lte_info->ueid = ueids[0];
            p_mac_lte_info->rapid = rapid;
            p_mac_lte_info->rach_attempt_number = rach_attempt_number;
            p_mac_lte_info->direction = DIRECTION_UPLINK;
           break;
        case ltemac_send_sr:
            for (unsigned n=0; n < number_of_ues; n++) {
                p_mac_lte_info->oob_ueid[n] = ueids[n];
                p_mac_lte_info->oob_rnti[n] = rntis[n];
            }
            p_mac_lte_info->number_of_srs = number_of_ues;
            p_mac_lte_info->direction = DIRECTION_UPLINK;
            break;
        case ltemac_sr_failure:
            p_mac_lte_info->rnti = rntis[0];
            p_mac_lte_info->ueid = ueids[0];
            p_mac_lte_info->direction = DIRECTION_DOWNLINK;
            break;
    }

    p_mac_lte_info->radioType = FDD_RADIO; /* TODO: will be the same as rest of log... */
    p_mac_lte_info->sfnSfInfoPresent = false;  /* We don't have this */
    p_mac_lte_info->oob_event = oob_event;

    /* Store info in packet */
    set_mac_lte_proto_data(pinfo, p_mac_lte_info);

    /* Call MAC dissector */
    call_dissector_only(mac_lte_handle, tvb, pinfo, tree, NULL);
}

static uint8_t
hex_from_char(char c)
{
    if ((c >= '0') && (c <= '9')) {
        return c - '0';
    }

    if ((c >= 'a') && (c <= 'f')) {
        return 0x0a + (c - 'a');
    }

    /* Not a valid hex string character */
    return 0xff;
}


/*****************************************/
/* Main dissection function.             */
/*****************************************/
static int
dissect_catapult_dct2000(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
    proto_tree         *dct2000_tree = NULL;
    proto_item         *ti           = NULL;
    int                 offset       = 0;
    unsigned            context_length;
    const char         *context_name;
    uint8_t             port_number;
    unsigned            protocol_length;
    unsigned            timestamp_length;
    const char         *timestamp_string;
    unsigned            variant_length;
    const char         *variant_string;
    uint32_t            variant;
    unsigned            outhdr_length;
    const char         *outhdr_string;
    uint8_t             direction;
    tvbuff_t           *next_tvb;
    int                 encap;
    dissector_handle_t  protocol_handle = 0;
    dissector_handle_t  heur_protocol_handle = 0;
    void               *protocol_data = 0;
    int                 sub_dissector_result = 0;
    const char         *protocol_name;
    bool                is_comment, is_sprint = false;
    unsigned            outhdr_values[MAX_OUTHDR_VALUES];
    unsigned            outhdr_values_found;

    /* Set Protocol */
    col_set_str(pinfo->cinfo, COL_PROTOCOL, "DCT2000");

    /* Clear Info */
    col_clear(pinfo->cinfo, COL_INFO);

    /* Create root (protocol) tree. */
    if (tree) {
        ti = proto_tree_add_item(tree, proto_catapult_dct2000, tvb, offset, -1, ENC_NA);
        dct2000_tree = proto_item_add_subtree(ti, ett_catapult_dct2000);
    }

    /*********************************************************************/
    /* Note that these are the fields of the stub header as written out  */
    /* by the wiretap module                                             */

    /* Context Name */
    context_name = (char*)tvb_get_stringz_enc(pinfo->pool, tvb, offset, &context_length, ENC_ASCII);
    if (dct2000_tree) {
        proto_tree_add_string(dct2000_tree, hf_catapult_dct2000_context, tvb,
                            offset, context_length, context_name);
    }
    offset += context_length;

    /* Context port number */
    port_number = tvb_get_uint8(tvb, offset);
    if (dct2000_tree) {
        proto_tree_add_item(dct2000_tree, hf_catapult_dct2000_port_number, tvb,
                            offset, 1, ENC_BIG_ENDIAN);
    }
    offset++;

    /* Timestamp in file */
    timestamp_string = (char*)tvb_get_stringz_enc(pinfo->pool, tvb, offset, &timestamp_length, ENC_ASCII);
    if (dct2000_tree) {
        /* g_ascii_strtod(timestamp_string, NULL)) is much simpler, but *very* slow..
           There will be seconds, a dot, and 4 decimal places.
           N.B. timestamp_length also includes following NULL character */
        if (timestamp_length < 7) {
            /* Can't properly parse, but leave showing how far we got */
            return offset;
        }

        /* Seconds. */
        int seconds = 0;
        int multiplier = 1;
        for (int d=timestamp_length-7; d >= 0; d--) {
            seconds += ((timestamp_string[d]-'0') * multiplier);
            multiplier *= 10;
        }

        /* Subseconds (4 digits). N.B. trailing zeros are written out by wiretap module. */
        int subseconds = 0;
        subseconds += (timestamp_string[timestamp_length-2]-'0');
        subseconds += (timestamp_string[timestamp_length-3]-'0')*10;
        subseconds += (timestamp_string[timestamp_length-4]-'0')*100;
        subseconds += (timestamp_string[timestamp_length-5]-'0')*1000;

        proto_tree_add_double(dct2000_tree, hf_catapult_dct2000_timestamp, tvb,
                              offset, timestamp_length,
                              seconds+(subseconds/10000.0));
    }
    offset += timestamp_length;


    /* DCT2000 protocol name */
    protocol_name = (char*)tvb_get_stringz_enc(pinfo->pool, tvb, offset, &protocol_length, ENC_ASCII);
    if (dct2000_tree) {
        proto_tree_add_string(dct2000_tree, hf_catapult_dct2000_protocol, tvb,
                            offset, protocol_length, protocol_name);
    }
    is_comment = (strcmp(protocol_name, "comment") == 0);
    if (!is_comment) {
        is_sprint = (strcmp(protocol_name, "sprint") == 0);
    }
    offset += protocol_length;


    /* Protocol Variant */
    variant_string = (char*)tvb_get_stringz_enc(pinfo->pool, tvb, offset, &variant_length, ENC_ASCII);
    if (!is_comment && !is_sprint) {
        proto_tree_add_string(dct2000_tree, hf_catapult_dct2000_variant, tvb,
                            offset, variant_length, variant_string);
    }
    offset += variant_length;

    /* Outhdr (shown as string) */
    outhdr_string = (char*)tvb_get_stringz_enc(pinfo->pool, tvb, offset, &outhdr_length, ENC_ASCII);
    if (!is_comment && !is_sprint && (outhdr_length > 1)) {
        proto_tree_add_string(dct2000_tree, hf_catapult_dct2000_outhdr, tvb,
                            offset, outhdr_length, outhdr_string);
    }
    offset += outhdr_length;


    /* Direction */
    direction = tvb_get_uint8(tvb, offset);
    if (dct2000_tree) {
        proto_tree_add_item(dct2000_tree, hf_catapult_dct2000_direction, tvb,
                            offset, 1, ENC_BIG_ENDIAN);
    }
    offset++;

    /* Read frame encapsulation set by wiretap */
    if (!is_comment && !is_sprint) {
        proto_tree_add_item(dct2000_tree, hf_catapult_dct2000_encap, tvb, offset, 1, ENC_BIG_ENDIAN);
    }
    encap = tvb_get_uint8(tvb, offset);
    offset++;

    /* Add useful details to protocol tree label */
    proto_item_append_text(ti, "   context=%s.%u   t=%s   %c   prot=%s (v=%s)",
                           context_name,
                           port_number,
                           timestamp_string,
                           (direction == 0) ? 'S' : 'R',
                           protocol_name,
                           variant_string);


    memset(outhdr_values, 0, sizeof outhdr_values);
    outhdr_values_found = 0;

    /* FP protocols need info from outhdr attached */
    if ((strcmp(protocol_name, "fp") == 0) ||
        (strncmp(protocol_name, "fp_r", 4) == 0) ||
        (strcmp(protocol_name, "fpiur_r5") == 0)) {

        outhdr_values_found = parse_outhdr_string(outhdr_string, outhdr_length,
                                                  outhdr_values);
        if (ws_strtou32(variant_string, NULL, &variant))
            attach_fp_info(pinfo, direction, protocol_name, variant,
                           outhdr_values, outhdr_values_found);
        else
            expert_add_info(pinfo, ti, &ei_catapult_dct2000_string_invalid);
    }

    /* RLC protocols need info from outhdr attached */
    else if ((strcmp(protocol_name, "rlc") == 0) ||
             (strcmp(protocol_name, "rlc_r4") == 0) ||
             (strcmp(protocol_name, "rlc_r5") == 0) ||
             (strcmp(protocol_name, "rlc_r6") == 0) ||
             (strcmp(protocol_name, "rlc_r7") == 0) ||
             (strcmp(protocol_name, "rlc_r8") == 0) ||
             (strcmp(protocol_name, "rlc_r9") == 0)) {

        outhdr_values_found = parse_outhdr_string(outhdr_string, outhdr_length,
                                                  outhdr_values);
        /* Can't attach info yet.  Need combination of outheader values
           and fields parsed from primitive header... */
    }

    /* LTE MAC needs info attached */
    else if ((strcmp(protocol_name, "mac_r8_lte") == 0) ||
             (strcmp(protocol_name, "mac_r9_lte") == 0) ||
             (strcmp(protocol_name, "mac_r10_lte") == 0)) {
        outhdr_values_found = parse_outhdr_string(outhdr_string, outhdr_length,
                                                  outhdr_values);
        attach_mac_lte_info(pinfo, outhdr_values, outhdr_values_found);
    }

    /* LTE RLC needs info attached */
    else if ((strcmp(protocol_name, "rlc_r8_lte") == 0) ||
             (strcmp(protocol_name, "rlc_r9_lte") == 0) ||
             (strcmp(protocol_name, "rlc_r10_lte") == 0)) {
        outhdr_values_found = parse_outhdr_string(outhdr_string, outhdr_length,
                                                  outhdr_values);
        attach_rlc_lte_info(pinfo, outhdr_values, outhdr_values_found);
    }

    /* LTE PDCP needs info attached */
    else if ((strcmp(protocol_name, "pdcp_r8_lte") == 0) ||
             (strcmp(protocol_name, "pdcp_r9_lte") == 0) ||
             (strcmp(protocol_name, "pdcp_r10_lte") == 0)) {
        outhdr_values_found = parse_outhdr_string(outhdr_string, outhdr_length,
                                                  outhdr_values);
        attach_pdcp_lte_info(pinfo, outhdr_values, outhdr_values_found);
    }

    else if ((strcmp(protocol_name, "nas_rrc_r8_lte") == 0) ||
             (strcmp(protocol_name, "nas_rrc_r9_lte") == 0) ||
             (strcmp(protocol_name, "nas_rrc_r10_lte") == 0) ||
             (strcmp(protocol_name, "nas_rrc_r13_lte") == 0) ||
             (strcmp(protocol_name, "nas_rrc_r15_5gnr") == 0)) {
        bool nas_body_found = true;
        uint8_t opcode = tvb_get_uint8(tvb, offset);
        proto_tree_add_item(tree, hf_catapult_dct2000_lte_nas_rrc_opcode,
                            tvb, offset++, 1, ENC_BIG_ENDIAN);

        offset++;   /* Skip overall length */

        switch (opcode) {
            case LTE_NAS_RRC_DATA_IND:
            case LTE_NAS_RRC_DATA_REQ:
                /* UEId */
                offset++; /* tag */
                offset += 2; /* 2 wasted bytes of UEId*/
                proto_tree_add_item(tree, hf_catapult_dct2000_ueid,
                                    tvb, offset, 2, ENC_BIG_ENDIAN);
                offset += 2;
                break;
            case LTE_NAS_RRC_ESTABLISH_REQ:
                /* UEId */
                offset++; /* tag */
                offset += 2; /* 2 wasted bytes of UEId*/
                proto_tree_add_item(tree, hf_catapult_dct2000_ueid,
                                    tvb, offset, 2, ENC_BIG_ENDIAN);
                offset += 2;

                /* Establish cause. TODO: value_string */
                offset += 2;  /* tag + length */
                proto_tree_add_item(tree, hf_catapult_dct2000_lte_nas_rrc_establish_cause,
                                    tvb, offset++, 1, ENC_BIG_ENDIAN);

                /* Priority.  TODO: Vals are low | high */
                offset += 2;  /* tag + length */
                proto_tree_add_item(tree, hf_catapult_dct2000_lte_nas_rrc_priority,
                                    tvb, offset++, 1, ENC_BIG_ENDIAN);
                break;
            case LTE_NAS_RRC_RELEASE_IND:
                /* UEId */
                offset++; /* tag */
                offset += 2; /* 2 wasted bytes of UEId*/
                proto_tree_add_item(tree, hf_catapult_dct2000_ueid,
                                    tvb, offset, 2, ENC_BIG_ENDIAN);
                offset += 2;

                /* Release cause.  TODO: value_string */
                offset += 2;  /* tag + length */
                proto_tree_add_item(tree, hf_catapult_dct2000_lte_nas_rrc_release_cause,
                                    tvb, offset++, 1, ENC_BIG_ENDIAN);
                break;

            default:
                nas_body_found = false;
                break;
        }

        /* Look up dissector if it looks right */
        if (nas_body_found) {
            offset += 2;  /* L3 tag + len */
            if (strcmp(protocol_name, "nas_rrc_r15_5gnr") == 0) {
                protocol_handle = find_dissector("nas-5gs");
            }
            else {
                protocol_handle = find_dissector("nas-eps");
            }
        }
    }

    /* NR NAS for S1AP */
    else if (strcmp(protocol_name, "nas_s1ap_r15_5gnr") == 0) {
        uint8_t opcode = tvb_get_uint8(tvb, offset);
        if (opcode <= NAS_S1AP_DATA_IND) {
            /* Opcode tag (only interested in ones that carry NAS PDU) */
            proto_tree_add_item(tree, hf_catapult_dct2000_nr_nas_s1ap_opcode,
                                tvb, offset++, 1, ENC_BIG_ENDIAN);

            /* Skip overall length */
            offset += skipASNLength(tvb_get_uint8(tvb, offset));

            /* UE Id. Skip tag and fixed length */
            offset += 2;
            /* Ignore first 2 bytes of UEId */
            offset += 2;
            proto_tree_add_item(tree, hf_catapult_dct2000_ueid,
                                tvb, offset, 2, ENC_BIG_ENDIAN);
            offset += 2;

            /* NAS PDU tag is 2 bytes */
            uint16_t data_tag = tvb_get_ntohs(tvb, offset);
            if (data_tag == 0x0021) {
                offset += 2;
                /* Also skip length */
                offset += 2;
                protocol_handle = find_dissector("nas-5gs");

                /* N.B. Ignoring some optional fields after the NAS PDU */
            }
        }
    }


    /* Note that the first item of pinfo->pseudo_header->dct2000 will contain
       the pseudo-header needed (in some cases) by the Wireshark dissector that
       this packet data will be handed off to. */


    /***********************************************************************/
    /* Now hand off to the dissector of intended packet encapsulation type */

    /* Get protocol handle, and set p2p_dir where necessary.
       (packet-frame.c won't copy it from pseudo-header because it doesn't
        know about Catapult DCT2000 encap type...)
    */
    switch (encap) {
        case WTAP_ENCAP_RAW_IP:
            protocol_handle = find_dissector("ip");
#if 0
            /* TODO: this doesn't work yet.
               pseudo_header isn't copied from wtap to pinfo... */
            if ((pinfo->pseudo_header != NULL) &&
                (pinfo->pseudo_header->dct2000.inner_pseudo_header.pdcp.ueid != 0)) {

                proto_item *ti;

                /* Add PDCP thread info as generated fields */
                ti = proto_tree_add_uint(dct2000_tree, hf_catapult_dct2000_lte_ueid, tvb, 0, 0,
                                         pinfo->pseudo_header->dct2000.inner_pseudo_header.pdcp.ueid);
                proto_item_set_generated(ti);
                ti = proto_tree_add_uint(dct2000_tree, hf_catapult_dct2000_lte_drbid, tvb, 0, 0,
                                         pinfo->pseudo_header->dct2000.inner_pseudo_header.pdcp.drbid);
                proto_item_set_generated(ti);
            }
#endif
            break;
        case WTAP_ENCAP_ETHERNET:
            protocol_handle = find_dissector("eth_withoutfcs");
            break;
        case WTAP_ENCAP_ISDN:
            /*
             * XXX - if the file can handle B-channel traffic as well
             * as D-channel traffic, have the libwiretap code fill
             * in the channel, and call the ISDN dissector rather
             * than the LAPD-with-pseudoheader dissector.
             */
            protocol_handle = find_dissector("lapd-phdr");
            protocol_data = &pinfo->pseudo_header->dct2000.inner_pseudo_header.isdn;
            break;
        case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
            protocol_handle = find_dissector("atm_untruncated");
            protocol_data = &pinfo->pseudo_header->dct2000.inner_pseudo_header.atm;
            break;
        case WTAP_ENCAP_PPP:
            protocol_handle = find_dissector("ppp_hdlc");
            pinfo->p2p_dir = pinfo->pseudo_header->p2p.sent;
            break;
        case DCT2000_ENCAP_SSCOP:
            protocol_handle = find_dissector("sscop");
            break;
        case WTAP_ENCAP_FRELAY:
            protocol_handle = find_dissector("fr");
            break;
        case DCT2000_ENCAP_MTP2:
            protocol_handle = find_dissector("mtp2");
            break;
        case DCT2000_ENCAP_NBAP:
            protocol_handle = find_dissector("nbap");
            break;

        case DCT2000_ENCAP_UNHANDLED:
            /**********************************************************/
            /* The wiretap module wasn't able to set an encapsulation */
            /* type, but it may still be possible to dissect the data */
            /* if we know about the protocol or if we can recognise   */
            /* and parse or skip a primitive header                   */
            /**********************************************************/

            /* Show context.port in src or dest column as appropriate */
            if (direction == 0) {
                col_add_fstr(pinfo->cinfo, COL_DEF_SRC,
                             "%s.%u",
                             context_name,
                             port_number);
            }
            else
            if (direction == 1) {
                col_add_fstr(pinfo->cinfo, COL_DEF_DST,
                             "%s.%u",
                             context_name,
                             port_number);
            }


            /**************************************************************************/
            /* These protocols have no encapsulation type, just look them up directly */

            if ((strcmp(protocol_name, "rlc") == 0) ||
                (strcmp(protocol_name, "rlc_r4") == 0) ||
                (strcmp(protocol_name, "rlc_r5") == 0) ||
                (strcmp(protocol_name, "rlc_r6") == 0) ||
                (strcmp(protocol_name, "rlc_r7") == 0) ||
                (strcmp(protocol_name, "rlc_r8") == 0) ||
                (strcmp(protocol_name, "rlc_r9") == 0)) {

                dissect_rlc_umts(tvb, offset, pinfo, tree, direction,
                                 outhdr_values, outhdr_values_found);
                return tvb_captured_length(tvb);
            }

            else
            if ((strcmp(protocol_name, "mac_r8_lte") == 0) ||
                (strcmp(protocol_name, "mac_r9_lte") == 0) ||
                (strcmp(protocol_name, "mac_r10_lte") == 0)) {
                protocol_handle = mac_lte_handle;
            }

            else
            if ((strcmp(protocol_name, "rlc_r8_lte") == 0) ||
                (strcmp(protocol_name, "rlc_r9_lte") == 0) ||
                (strcmp(protocol_name, "rlc_r10_lte") == 0)) {
                protocol_handle = rlc_lte_handle;
            }

            else
            if ((strcmp(protocol_name, "pdcp_r8_lte") == 0) ||
                (strcmp(protocol_name, "pdcp_r9_lte") == 0) ||
                (strcmp(protocol_name, "pdcp_r10_lte") == 0)) {
                /* Dissect proprietary header, then pass remainder to PDCP */
                dissect_pdcp_lte(tvb, offset, pinfo, tree);
                return tvb_captured_length(tvb);
            }


            /* Work with generic XML protocol. */
            else
            if (strcmp(protocol_name, "xml") == 0) {
                protocol_handle = find_dissector("xml");
            }


            /* Attempt to show tty messages as raw text */
            else
            if (strcmp(protocol_name, "tty") == 0) {
                dissect_tty_lines(tvb, pinfo, dct2000_tree, offset);
                return tvb_captured_length(tvb);
            }

            else
            if (strcmp(protocol_name, "sipprim") == 0) {
                protocol_handle = find_dissector("sipprim");
            }

            else
            if (strcmp(protocol_name, "comment") == 0) {
                /* Extract & add the string. */
                proto_item *string_ti;
                const char *string;

                /* Show comment string */
                string_ti = proto_tree_add_item_ret_string(dct2000_tree, hf_catapult_dct2000_comment, tvb,
                                                offset, tvb_reported_length_remaining(tvb, offset), ENC_ASCII|ENC_NA, pinfo->pool, (const uint8_t**)&string);
                col_append_str(pinfo->cinfo, COL_INFO, string);

                if (catapult_dct2000_dissect_mac_lte_oob_messages) {
                    /* Look into string for out-of-band MAC events, such as SRReq, SRInd */
                    check_for_oob_mac_lte_events(pinfo, tvb, tree, string);
                }

                /* Look for and flag generic error messages */
                if (strncmp(string, ">> ERR", 6) == 0) {
                    proto_item *error_ti = proto_tree_add_item(dct2000_tree, hf_catapult_dct2000_error_comment, tvb,
                                                               offset, -1, ENC_NA);
                    proto_item_set_generated(error_ti);
                    expert_add_info_format(pinfo, string_ti, &ei_catapult_dct2000_error_comment_expert,
                                          "%s", string);
                }


                /* Look for logged MAC-NR PDU */
                /* Example contents would be:
                    $Debug  - NRMAC PDU: direction=0 rntiType=3 rnti=8495 ueid=1 SN=0 SFN=0 length=22 $40111212121212121212121212121212121212121212
                */
                int dir, rntiType, rnti, ueid, sn, sfn, length;

                if ((sscanf(string, "L1_App: NRMAC PDU: direction=%d rntiType=%d rnti=%d ueid=%d SN=%d  SFN=%d length=%d $",
                            &dir, &rntiType, &rnti, &ueid, &sn, &sfn, &length) == 7) ||
                    (sscanf(string, "NRMAC PDU: direction=%d rntiType=%d rnti=%d ueid=%d SN=%d  SFN=%d length=%d $",
                            &dir, &rntiType, &rnti, &ueid, &sn, &sfn, &length) == 7))
                {
                    struct mac_nr_info *p_mac_nr_info;

                    /* Only need to set info once per session? */
                    /* p_mac_nr_info = get_mac_nr_proto_data(pinfo); */

                    /* Allocate & zero struct */
                    p_mac_nr_info = wmem_new0(wmem_file_scope(), struct mac_nr_info);

                    /* Populate the struct from outhdr values */
                    p_mac_nr_info->radioType = FDD_RADIO;

                    /* Map internal RNTI type -> Wireshark #defines from packet-mac-nr.h */
                    switch (rntiType) {
                        case 2:
                            p_mac_nr_info->rntiType = P_RNTI;
                            break;
                        case 3:
                            p_mac_nr_info->rntiType = RA_RNTI;
                            break;
                        case 4:
                            p_mac_nr_info->rntiType = C_RNTI; /* temp C-RNTI */
                            break;
                        case 5:
                            p_mac_nr_info->rntiType = C_RNTI;
                            break;
                        case 6:
                            p_mac_nr_info->rntiType = MSGB_RNTI;
                            break;
                        default:
                            p_mac_nr_info->rntiType = NO_RNTI;
                            break;
                    }

                    p_mac_nr_info->direction = dir;
                    p_mac_nr_info->rnti = rnti;
                    // 0xFFFF trumps logged rntiType...
                    if (rnti == 65535) {
                        p_mac_nr_info->rntiType = SI_RNTI;
                    }
                    p_mac_nr_info->ueid = ueid;

                    p_mac_nr_info->phr_type2_othercell = false;

                    p_mac_nr_info->length = length;

                    /* Always present. TODO: miss out if both zero? */
                    p_mac_nr_info->sfnSlotInfoPresent = true;
                    p_mac_nr_info->sysframeNumber = sfn;
                    p_mac_nr_info->slotNumber = sn;  /* only right if mu==0, but don't know SCS */

                    /* Store info in packet */
                    set_mac_nr_proto_data(pinfo, p_mac_nr_info);

                    /* Payload is from $ to end of string */
                    int data_offset = 0;
                    for (unsigned int n=0; n < strlen(string); n++) {
                        if (string[n] == '$') {
                            data_offset = n;
                            break;
                        }
                    }

                    /* Convert data to hex. */
                    char *mac_data = (char *)wmem_alloc(pinfo->pool, 2 + (strlen(string)-data_offset)/2);
                    int idx, m;
                    for (idx=0, m=data_offset+1; string[m] != '\0'; m+=2, idx++) {
                        mac_data[idx] = (hex_from_char(string[m]) << 4) + hex_from_char(string[m+1]);
                    }

                    /* Create tvb */
                    tvbuff_t *mac_nr_tvb = tvb_new_child_real_data(tvb, (const uint8_t*)mac_data, idx, idx);
                    add_new_data_source(pinfo, mac_nr_tvb, "MAC-NR Payload");
                    /* Call the dissector! */
                    call_dissector_only(mac_nr_handle, mac_nr_tvb, pinfo, tree, NULL);
                }

                /* Look for logged NRUP PDU */
                const char *nrup_pattern = "NRUP PDU: ";
                char *start = strstr(string, nrup_pattern);
                if (start) {
                    int off = 0;

                    while (start[off] && start[off] != '$') {
                        off++;
                    }

                    const char *payload = &start[off+1];

                    /* Pad out to nearest 4 bytes if necessary. */
                    /* Convert data to hex. */
                    #define MAX_NRUP_DATA_LENGTH 200
                    static uint8_t nrup_data[MAX_NRUP_DATA_LENGTH];
                    int idx, m;

                    /* The rest (or all) is data! */
                    for (m=0, idx=0; payload[m] != '\0' && idx < MAX_NRUP_DATA_LENGTH-4; m+=2, idx++) {
                        nrup_data[idx] = (hex_from_char(payload[m]) << 4) + hex_from_char(payload[m+1]);
                    }
                    length = idx;
                    /* Pad out to nearest 4 bytes if necessary. */
                    if (length % 4 != 0) {
                        for (int p=length % 4; p < 4; p++) {
                            nrup_data[length++] = '\0';
                        }
                    }

                    /* Create separate NRUP tvb */
                    /* XXX - Should the reported length be based upon
                     * strlen(payload) / 2 as we might have truncated? */
                    tvbuff_t *nrup_tvb = tvb_new_child_real_data(tvb, nrup_data, length, length);
                    add_new_data_source(pinfo, nrup_tvb, "NRUP Payload");

                    /* Call the dissector! */
                    call_dissector_only(nrup_handle, nrup_tvb, pinfo, tree, NULL);
                }

                /* Read key info from formatted lines */
                /* e.g. NRPDCP: RRCPRIM:ueId=   1;setThreadAuthKey: RRC id=1 alg 2 key: 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 */
                if (strstr(string, "setThreadAuthKey:")) {
                    unsigned ue_id, id, alg;
                    if (!PINFO_FD_VISITED(pinfo) && sscanf(string, "NRPDCP: RRCPRIM:ueId=   %u;setThreadAuthKey: RRC id=%u alg %u key: ", &ue_id, &id, &alg) == 3) {
                        char *key = g_strdup(strstr(string, "key: ")+5);
                        set_pdcp_nr_rrc_integrity_key(ue_id, key, pinfo->num);
                        g_free(key);
                    }
                    else if (!PINFO_FD_VISITED(pinfo) && sscanf(string, "NRPDCP: RRCPRIM:ueId=   %u;setThreadAuthKey: UP id=%u alg %u key: ", &ue_id, &id, &alg) == 3) {
                        char *key = g_strdup(strstr(string, "key: ")+5);
                        set_pdcp_nr_up_integrity_key(ue_id, key, pinfo->num);
                        g_free(key);
                    }
                }
                else if (strstr(string, "setThreadCryptKey:")) {
                    unsigned ue_id, id, alg;
                    if (!PINFO_FD_VISITED(pinfo) && sscanf(string, "NRPDCP: RRCPRIM:ueId=   %u;setThreadCryptKey: RRC id=%u alg %u key: ", &ue_id, &id, &alg) == 3) {
                        char *key = g_strdup(strstr(string, "key: ")+5);
                        set_pdcp_nr_rrc_ciphering_key(ue_id, key, pinfo->num);
                        g_free(key);
                    }
                    else if (!PINFO_FD_VISITED(pinfo) && sscanf(string, "NRPDCP: RRCPRIM:ueId=   %u;setThreadCryptKey: UP id=%u alg %u key: ", &ue_id, &id, &alg) == 3) {
                        char *key = g_strdup(strstr(string, "key: ")+5);
                        set_pdcp_nr_up_ciphering_key(ue_id, key, pinfo->num);
                        g_free(key);
                    }
                }

                /* 'raw' (ethernet) frames logged as text comments */
                int raw_interface;
                char raw_direction;
                if (sscanf(string, "RawTraffic: Interface: %d %c $",
                           &raw_interface, &raw_direction) == 2)
                {
                    /* Interface */
                    proto_tree_add_uint(tree, hf_catapult_dct2000_rawtraffic_interface,
                                        tvb, 0, 0, raw_interface);

                    /* Direction */
                    proto_tree_add_uint(tree, hf_catapult_dct2000_rawtraffic_direction,
                                        tvb, 0, 0, raw_direction == 'r');

                    /* Payload is from $ to end of string */
                    int data_offset = 0;
                    for (unsigned int n=0; n < strlen(string); n++) {
                        if (string[n] == '$') {
                            data_offset = n;
                            break;
                        }
                    }

                    /* Convert data to hex. */
                    static uint8_t eth_data[36000];
                    int idx, m;
                    for (idx=0, m=data_offset+1; idx<36000 && string[m] != '\0'; m+=2, idx++) {
                        eth_data[idx] = (hex_from_char(string[m]) << 4) + hex_from_char(string[m+1]);
                    }

                    /* Create tvb */
                    tvbuff_t *raw_traffic_tvb = tvb_new_child_real_data(tvb, eth_data, idx, idx);
                    add_new_data_source(pinfo, raw_traffic_tvb, "Raw-Traffic Payload");

                    /* PDU */
                    proto_tree_add_item(tree, hf_catapult_dct2000_rawtraffic_pdu, raw_traffic_tvb,
                                        0, tvb_reported_length(raw_traffic_tvb), ENC_NA);

                    /* Call the dissector! */
                   call_dissector_only(eth_handle, raw_traffic_tvb, pinfo, tree, NULL);
                }

                return tvb_captured_length(tvb);
            }

            else
            if (strcmp(protocol_name, "sprint") == 0) {
                /* Extract & add the string. */
                const char *string;

                /* Show sprint string */
                proto_tree_add_item_ret_string(dct2000_tree, hf_catapult_dct2000_sprint, tvb,
                                                offset, tvb_reported_length_remaining(tvb, offset), ENC_ASCII|ENC_NA, pinfo->pool, (const uint8_t**)&string);
                col_append_str(pinfo->cinfo, COL_INFO, string);

                return tvb_captured_length(tvb);
            }

            /* RRC (LTE or NR).
               Dissect proprietary header, then pass remainder
               to RRC dissector (depending upon direction and channel type) */
            else
            if (catapult_dct2000_dissect_lte_rrc &&
                ((strcmp(protocol_name, "rrc_r8_lte") == 0) ||
                 (strcmp(protocol_name, "rrcpdcpprim_r8_lte") == 0) ||
                 (strcmp(protocol_name, "rrc_r9_lte") == 0) ||
                 (strcmp(protocol_name, "rrcpdcpprim_r9_lte") == 0) ||
                 (strcmp(protocol_name, "rrc_r10_lte") == 0) ||
                 (strcmp(protocol_name, "rrc_r11_lte") == 0) ||
                 (strcmp(protocol_name, "rrc_r12_lte") == 0) ||
                 (strcmp(protocol_name, "rrc_r13_lte") == 0) ||
                 (strcmp(protocol_name, "rrc_r15_lte") == 0) ||
                 (strcmp(protocol_name, "rrc_r16_lte") == 0) ||
                 (strcmp(protocol_name, "rrcpdcpprim_r15_lte") == 0))) {

                dissect_rrc_lte_nr(tvb, offset, pinfo, tree, LTE);
                return tvb_captured_length(tvb);
            }
            else if ((strcmp(protocol_name, "rrc_r15_5g") == 0) ||
                     (strcmp(protocol_name, "rrc_r16_5g") == 0)) {
                dissect_rrc_lte_nr(tvb, offset, pinfo, tree, NR);
                return tvb_captured_length(tvb);
            }

            else
            if ((strcmp(protocol_name, "ccpri_r8_lte") == 0) ||
                (strcmp(protocol_name, "ccpri_r9_lte") == 0)) {

                /* Dissect proprietary header, then pass remainder to lapb */
                dissect_ccpri_lte(tvb, offset, pinfo, tree);
                return tvb_captured_length(tvb);
            }

            /* Many DCT2000 protocols have at least one IPPrim variant. If the
               protocol name can be matched to a dissector, try to find the
               UDP/TCP data inside and dissect it.
            */

            if (!protocol_handle && catapult_dct2000_try_ipprim_heuristic) {
                uint32_t     source_addr_offset = 0, dest_addr_offset = 0;
                uint8_t      source_addr_length = 0, dest_addr_length = 0;
                uint32_t     source_port_offset = 0, dest_port_offset = 0;
                port_type    type_of_port = PT_NONE;
                uint16_t     conn_id_offset = 0;
                int          offset_before_ipprim_header = offset;

                /* For ipprim, want to show ipprim header even if can't find dissector to call for payload.. */
                if (find_ipprim_data_offset(tvb, &offset, direction,
                                            &source_addr_offset, &source_addr_length,
                                            &dest_addr_offset, &dest_addr_length,
                                            &source_port_offset, &dest_port_offset,
                                            &type_of_port,
                                            &conn_id_offset)) {

                    proto_tree *ipprim_tree;
                    proto_item *ipprim_ti;
                    struct     e_in6_addr sourcev6, destv6;

                    /* Fetch IPv6 addresses */
                    if (source_addr_length != 4) {
                        tvb_get_ipv6(tvb, source_addr_offset, &sourcev6);
                    }
                    if (dest_addr_length != 4) {
                        tvb_get_ipv6(tvb, dest_addr_offset, &destv6);
                    }


                    /* Will use this dissector then. */
                    heur_protocol_handle = look_for_dissector(protocol_name);
                    protocol_handle = heur_protocol_handle;

                    /* Add address parameters to tree */
                    /* Unfortunately can't automatically create a conversation filter for this...
                       I *could* create a fake IP header from these details, but then it would be tricky
                       to get the FP dissector called as it has no well-known ports or heuristics... */
                    ipprim_ti =  proto_tree_add_string_format(dct2000_tree, hf_catapult_dct2000_ipprim_addresses,
                                                       tvb, offset_before_ipprim_header, 0,
                                                       "", "IPPrim transport (%s): %s:%u -> %s:%u",
                                                       (type_of_port == PT_UDP) ? "UDP" : "TCP",
                                                       (source_addr_offset) ?
                                                           ((source_addr_length == 4) ?
                                                              get_hostname(tvb_get_ipv4(tvb, source_addr_offset)) :
                                                              get_hostname6(&sourcev6)
                                                            ) :
                                                           "0.0.0.0",
                                                       (source_port_offset) ?
                                                           tvb_get_ntohs(tvb, source_port_offset) :
                                                           0,
                                                       (dest_addr_offset) ?
                                                         ((dest_addr_length == 4) ?
                                                              get_hostname(tvb_get_ipv4(tvb, dest_addr_offset)) :
                                                              get_hostname6(&destv6)
                                                            ) :
                                                           "0.0.0.0",
                                                       (dest_port_offset) ?
                                                           tvb_get_ntohs(tvb, dest_port_offset) :
                                                           0);
                    if ((type_of_port == PT_TCP) && (conn_id_offset != 0)) {
                        proto_item_append_text(ipprim_ti, " (conn_id=%u)", tvb_get_ntohs(tvb, conn_id_offset));
                    }

                    /* Add these IPPRIM fields inside an IPPRIM subtree */
                    ipprim_tree = proto_item_add_subtree(ipprim_ti, ett_catapult_dct2000_ipprim);

                    /* Try to add right stuff to pinfo so conversation stuff works... */
                    pinfo->ptype = type_of_port;

                    /* Add addresses & ports into ipprim tree.
                       Also set address info in pinfo for conversations... */
                    if (source_addr_offset != 0) {
                        proto_item *addr_ti;

                        set_address_tvb(&pinfo->net_src,
                                    (source_addr_length == 4) ? AT_IPv4 : AT_IPv6,
                                    source_addr_length, tvb, source_addr_offset);
                        copy_address_shallow(&pinfo->src, &pinfo->net_src);

                        proto_tree_add_item(ipprim_tree,
                                            (source_addr_length == 4) ?
                                                hf_catapult_dct2000_ipprim_src_addr_v4 :
                                                hf_catapult_dct2000_ipprim_src_addr_v6,
                                            tvb, source_addr_offset, source_addr_length,
                                            ENC_NA);

                        /* Add hidden item for "side-less" addr */
                        addr_ti = proto_tree_add_item(ipprim_tree,
                                                      (source_addr_length == 4) ?
                                                          hf_catapult_dct2000_ipprim_addr_v4 :
                                                          hf_catapult_dct2000_ipprim_addr_v6,
                                                      tvb, source_addr_offset, source_addr_length,
                                                      ENC_NA);
                        proto_item_set_hidden(addr_ti);
                    }
                    if (source_port_offset != 0) {
                        proto_item *port_ti;

                        pinfo->srcport = tvb_get_ntohs(tvb, source_port_offset);

                        proto_tree_add_item(ipprim_tree,
                                            (type_of_port == PT_UDP) ?
                                               hf_catapult_dct2000_ipprim_udp_src_port :
                                               hf_catapult_dct2000_ipprim_tcp_src_port,
                                            tvb, source_port_offset, 2, ENC_BIG_ENDIAN);
                        port_ti = proto_tree_add_item(ipprim_tree,
                                                      (type_of_port == PT_UDP) ?
                                                          hf_catapult_dct2000_ipprim_udp_port :
                                                          hf_catapult_dct2000_ipprim_tcp_port,
                                                      tvb, source_port_offset, 2, ENC_BIG_ENDIAN);
                        proto_item_set_hidden(port_ti);
                    }
                    if (dest_addr_offset != 0) {
                        proto_item *addr_ti;

                        set_address_tvb(&pinfo->net_dst,
                                    (dest_addr_length == 4) ? AT_IPv4 : AT_IPv6,
                                    dest_addr_length, tvb, dest_addr_offset);
                        copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
                        proto_tree_add_item(ipprim_tree,
                                            (dest_addr_length == 4) ?
                                                hf_catapult_dct2000_ipprim_dst_addr_v4 :
                                                hf_catapult_dct2000_ipprim_dst_addr_v6,
                                            tvb, dest_addr_offset, dest_addr_length,
                                            ENC_NA);

                        /* Add hidden item for "side-less" addr */
                        addr_ti = proto_tree_add_item(ipprim_tree,
                                                      (dest_addr_length == 4) ?
                                                          hf_catapult_dct2000_ipprim_addr_v4 :
                                                          hf_catapult_dct2000_ipprim_addr_v6,
                                                      tvb, dest_addr_offset, dest_addr_length,
                                                      ENC_NA);
                        proto_item_set_hidden(addr_ti);
                    }
                    if (dest_port_offset != 0) {
                        proto_item *port_ti;

                        pinfo->destport = tvb_get_ntohs(tvb, dest_port_offset);

                        proto_tree_add_item(ipprim_tree,
                                            (type_of_port == PT_UDP) ?
                                               hf_catapult_dct2000_ipprim_udp_dst_port :
                                               hf_catapult_dct2000_ipprim_tcp_dst_port,
                                            tvb, dest_port_offset, 2, ENC_BIG_ENDIAN);
                        port_ti = proto_tree_add_item(ipprim_tree,
                                                      (type_of_port == PT_UDP) ?
                                                          hf_catapult_dct2000_ipprim_udp_port :
                                                          hf_catapult_dct2000_ipprim_tcp_port,
                                                      tvb, dest_port_offset, 2, ENC_BIG_ENDIAN);
                        proto_item_set_hidden(port_ti);
                    }
                    if (conn_id_offset != 0) {
                        proto_tree_add_item(ipprim_tree,
                                            hf_catapult_dct2000_ipprim_conn_id,
                                            tvb, conn_id_offset, 2, ENC_BIG_ENDIAN);
                    }


                    /* Set source and dest columns now (will be overwritten if
                       src and dst IP addresses set) */
                    if (source_addr_offset) {
                        col_append_fstr(pinfo->cinfo, COL_DEF_SRC,
                                        "(%s:%u)",
                                        get_hostname(tvb_get_ipv4(tvb, source_addr_offset)),
                                        tvb_get_ntohs(tvb, source_port_offset));
                    }
                    if (dest_addr_offset) {
                        col_append_fstr(pinfo->cinfo, COL_DEF_DST,
                                        "(%s:%u)",
                                        get_hostname(tvb_get_ipv4(tvb, dest_addr_offset)),
                                        tvb_get_ntohs(tvb, dest_port_offset));
                    }

                    /* Set length for IPPrim tree */
                    proto_item_set_len(ipprim_tree, offset - offset_before_ipprim_header);
                }
            }


            /* Try SCTP Prim heuristic if configured to */
            if (!protocol_handle && catapult_dct2000_try_sctpprim_heuristic) {
                uint32_t     dest_addr_offset = 0;
                uint16_t     dest_addr_length = 0;
                uint32_t     dest_port_offset = 0;
                int          offset_before_sctpprim_header = offset;

                heur_protocol_handle = look_for_dissector(protocol_name);
                if ((heur_protocol_handle != 0) &&
                    (find_sctpprim_variant1_data_offset(tvb, &offset,
                                                        &dest_addr_offset,
                                                        &dest_addr_length,
                                                        &dest_port_offset) ||
                     find_sctpprim_variant3_data_offset(tvb, &offset,
                                                        &dest_addr_offset,
                                                        &dest_addr_length,
                                                        &dest_port_offset))) {

                    proto_tree *sctpprim_tree;
                    proto_item *ti_local;

                    /* Will use this dissector then. */
                    protocol_handle = heur_protocol_handle;

                    ti_local =  proto_tree_add_string_format(dct2000_tree, hf_catapult_dct2000_sctpprim_addresses,
                                                       tvb, offset_before_sctpprim_header, 0,
                                                       "", "SCTPPrim transport:  -> %s:%u",
                                                       (dest_addr_offset) ?
                                                         ((dest_addr_length == 4) ?
                                                              get_hostname(tvb_get_ipv4(tvb, dest_addr_offset)) :
                                                              "<ipv6-address>"
                                                            ) :
                                                           "0.0.0.0",
                                                       (dest_port_offset) ?
                                                         tvb_get_ntohs(tvb, dest_port_offset) :
                                                         0);

                    /* Add these SCTPPRIM fields inside an SCTPPRIM subtree */
                    sctpprim_tree = proto_item_add_subtree(ti_local, ett_catapult_dct2000_sctpprim);

                    /* Destination address */
                    if (dest_addr_offset != 0) {
                        proto_item *addr_ti;

                        set_address_tvb(&pinfo->net_dst,
                                    (dest_addr_length == 4) ? AT_IPv4 : AT_IPv6,
                                    dest_addr_length, tvb, dest_addr_offset);
                        copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
                        proto_tree_add_item(sctpprim_tree,
                                            (dest_addr_length == 4) ?
                                                hf_catapult_dct2000_sctpprim_dst_addr_v4 :
                                                hf_catapult_dct2000_sctpprim_dst_addr_v6,
                                            tvb, dest_addr_offset, dest_addr_length,
                                            ENC_NA);

                        /* Add hidden item for "side-less" addr */
                        addr_ti = proto_tree_add_item(sctpprim_tree,
                                                      (dest_addr_length == 4) ?
                                                          hf_catapult_dct2000_sctpprim_addr_v4 :
                                                          hf_catapult_dct2000_sctpprim_addr_v6,
                                                      tvb, dest_addr_offset, dest_addr_length,
                                                      ENC_NA);
                        proto_item_set_hidden(addr_ti);
                    }

                    if (dest_port_offset != 0) {
                        pinfo->destport = tvb_get_ntohs(tvb, dest_port_offset);

                        proto_tree_add_item(sctpprim_tree,
                                            hf_catapult_dct2000_sctpprim_dst_port,
                                            tvb, dest_port_offset, 2, ENC_BIG_ENDIAN);
                    }

                    /* Set length for SCTPPrim tree */
                    proto_item_set_len(sctpprim_tree, offset - offset_before_sctpprim_header);
                }
            }

            /* Next chance: is there a (private) registered protocol of the form
               "dct2000.protocol" ? */
            if (protocol_handle == 0) {
                /* TODO: only look inside if a preference enabled? */
                char dotted_protocol_name[128];
                /* N.B. avoiding snprintf(), which was slow */
                (void) g_strlcpy(dotted_protocol_name, "dct2000.", 128);
                (void) g_strlcpy(dotted_protocol_name+8, protocol_name, 128-8);
                protocol_handle = find_dissector(dotted_protocol_name);
            }

            /* Last resort: Allow any PDU to be dissected if the protocol matches with
               a dissector name */
            if ( !protocol_handle && catapult_dct2000_use_protocol_name_as_dissector_name) {
                protocol_handle = find_dissector(protocol_name);
            }


            break;

        default:
            /* !! If get here, there is a mismatch between
               this dissector and the wiretap module catapult_dct2000.c !!
            */
            DISSECTOR_ASSERT_NOT_REACHED();
            return 0;
    }

    /* Set selection length of dct2000 tree */
    proto_item_set_len(dct2000_tree, offset);

    /* Try appropriate dissector, if one has been selected */
    if (protocol_handle != 0) {
        /* Dissect the remainder of the frame using chosen protocol handle */
        next_tvb = tvb_new_subset_remaining(tvb, offset);
        sub_dissector_result = call_dissector_only(protocol_handle, next_tvb, pinfo, tree, protocol_data);
    }


    if (protocol_handle == 0 || sub_dissector_result == 0) {
        /* Could get here because:
           - encap is DCT2000_ENCAP_UNHANDLED and we still didn't handle it, OR
           - desired protocol is unavailable (probably disabled), OR
           - protocol rejected our data
           Show remaining bytes as unparsed data */
        proto_tree_add_item(dct2000_tree, hf_catapult_dct2000_unparsed_data,
                            tvb, offset, -1, ENC_NA);

        col_add_fstr(pinfo->cinfo, COL_INFO,
                     "Not dissected  (context=%s.%u   t=%s   %c   prot=%s (v=%s))",
                     context_name,
                     port_number,
                     timestamp_string,
                     (direction == 0) ? 'S' : 'R',
                     protocol_name,
                     variant_string);
    }
    else {
        /* Show number of dissected bytes */
        if (dct2000_tree) {
            proto_item *ti_local = proto_tree_add_uint(dct2000_tree,
                                                 hf_catapult_dct2000_dissected_length,
                                                 tvb, 0, 0, tvb_reported_length(tvb)-offset);
            proto_item_set_generated(ti_local);
        }
    }

    return tvb_captured_length(tvb);
}



/******************************************************************************/
/* Associate this protocol with the Catapult DCT2000 file encapsulation type. */
/******************************************************************************/
void proto_reg_handoff_catapult_dct2000(void)
{
    dissector_add_uint("wtap_encap", WTAP_ENCAP_CATAPULT_DCT2000, catapult_dct2000_handle);

    mac_lte_handle = find_dissector("mac-lte");
    rlc_lte_handle = find_dissector("rlc-lte");
    pdcp_lte_handle = find_dissector("pdcp-lte");

    mac_nr_handle = find_dissector("mac-nr");
    nrup_handle = find_dissector("nrup");
    eth_handle = find_dissector("eth_withoutfcs");
    nrup_handle = find_dissector("nrup");

    proto_fp = proto_get_id_by_filter_name("fp");
    proto_umts_rlc = proto_get_id_by_filter_name("rlc");
    proto_rlc_lte = proto_get_id_by_filter_name("rlc-lte");
    proto_pdcp_lte = proto_get_id_by_filter_name("pdcp-lte");
}

/****************************************/
/* Register the protocol                */
/****************************************/
void proto_register_catapult_dct2000(void)
{
    static hf_register_info hf[] =
    {
        { &hf_catapult_dct2000_context,
            { "Context",
              "dct2000.context", FT_STRING, BASE_NONE, NULL, 0x0,
              "Context name", HFILL
            }
        },
        { &hf_catapult_dct2000_port_number,
            { "Context Port number",
              "dct2000.context_port", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_timestamp,
            { "Timestamp",
              "dct2000.timestamp", FT_DOUBLE, BASE_NONE, NULL, 0x0,
              "File timestamp", HFILL
            }
        },
        { &hf_catapult_dct2000_protocol,
            { "DCT2000 protocol",
              "dct2000.protocol", FT_STRING, BASE_NONE, NULL, 0x0,
              "Original (DCT2000) protocol name", HFILL
            }
        },
        { &hf_catapult_dct2000_variant,
            { "Protocol variant",
              "dct2000.variant", FT_STRING, BASE_NONE, NULL, 0x0,
              "DCT2000 protocol variant", HFILL
            }
        },
        { &hf_catapult_dct2000_outhdr,
            { "Out-header",
              "dct2000.outhdr", FT_STRING, BASE_NONE, NULL, 0x0,
              "DCT2000 protocol outhdr", HFILL
            }
        },
        { &hf_catapult_dct2000_direction,
            { "Direction",
              "dct2000.direction", FT_UINT8, BASE_DEC, VALS(direction_vals), 0x0,
              "Frame direction (Sent or Received)", HFILL
            }
        },
        { &hf_catapult_dct2000_encap,
            { "Wireshark encapsulation",
              "dct2000.encapsulation", FT_UINT8, BASE_DEC, VALS(encap_vals), 0x0,
              "Wireshark frame encapsulation used", HFILL
            }
        },
        { &hf_catapult_dct2000_unparsed_data,
            { "Unparsed protocol data",
              "dct2000.unparsed_data", FT_BYTES, BASE_NONE, NULL, 0x0,
              "Unparsed DCT2000 protocol data", HFILL
            }
        },
        { &hf_catapult_dct2000_comment,
            { "Comment",
              "dct2000.comment", FT_STRING, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_sprint,
            { "Sprint text",
              "dct2000.sprint", FT_STRING, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_error_comment,
            { "Error comment",
              "dct2000.error-comment", FT_NONE, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_dissected_length,
            { "Dissected length",
              "dct2000.dissected-length", FT_UINT16, BASE_DEC, NULL, 0x0,
              "Number of bytes dissected by subdissector(s)", HFILL
            }
        },

        { &hf_catapult_dct2000_ipprim_addresses,
            { "IPPrim Addresses",
              "dct2000.ipprim", FT_STRING, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_src_addr_v4,
            { "Source Address",
              "dct2000.ipprim.src", FT_IPv4, BASE_NONE, NULL, 0x0,
              "IPPrim IPv4 Source Address", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_src_addr_v6,
            { "Source Address",
              "dct2000.ipprim.srcv6", FT_IPv6, BASE_NONE, NULL, 0x0,
              "IPPrim IPv6 Source Address", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_dst_addr_v4,
            { "Destination Address",
              "dct2000.ipprim.dst", FT_IPv4, BASE_NONE, NULL, 0x0,
              "IPPrim IPv4 Destination Address", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_dst_addr_v6,
            { "Destination Address",
              "dct2000.ipprim.dstv6", FT_IPv6, BASE_NONE, NULL, 0x0,
              "IPPrim IPv6 Destination Address", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_addr_v4,
            { "Address",
              "dct2000.ipprim.addr", FT_IPv4, BASE_NONE, NULL, 0x0,
              "IPPrim IPv4 Address", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_addr_v6,
            { "Address",
              "dct2000.ipprim.addrv6", FT_IPv6, BASE_NONE, NULL, 0x0,
              "IPPrim IPv6 Address", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_udp_src_port,
            { "UDP Source Port",
              "dct2000.ipprim.udp.srcport", FT_UINT16, BASE_PT_UDP, NULL, 0x0,
              "IPPrim UDP Source Port", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_udp_dst_port,
            { "UDP Destination Port",
              "dct2000.ipprim.udp.dstport", FT_UINT16, BASE_PT_UDP, NULL, 0x0,
              "IPPrim UDP Destination Port", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_udp_port,
            { "UDP Port",
              "dct2000.ipprim.udp.port", FT_UINT16, BASE_PT_UDP, NULL, 0x0,
              "IPPrim UDP Port", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_tcp_src_port,
            { "TCP Source Port",
              "dct2000.ipprim.tcp.srcport", FT_UINT16, BASE_PT_TCP, NULL, 0x0,
              "IPPrim TCP Source Port", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_tcp_dst_port,
            { "TCP Destination Port",
              "dct2000.ipprim.tcp.dstport", FT_UINT16, BASE_PT_TCP, NULL, 0x0,
              "IPPrim TCP Destination Port", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_tcp_port,
            { "TCP Port",
              "dct2000.ipprim.tcp.port", FT_UINT16, BASE_PT_TCP, NULL, 0x0,
              "IPPrim TCP Port", HFILL
            }
        },
        { &hf_catapult_dct2000_ipprim_conn_id,
            { "Conn Id",
              "dct2000.ipprim.conn-id", FT_UINT16, BASE_DEC, NULL, 0x0,
              "IPPrim TCP Connection ID", HFILL
            }
        },

        { &hf_catapult_dct2000_sctpprim_addresses,
            { "SCTPPrim Addresses",
              "dct2000.sctpprim", FT_STRING, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_sctpprim_dst_addr_v4,
            { "Destination Address",
              "dct2000.sctpprim.dst", FT_IPv4, BASE_NONE, NULL, 0x0,
              "SCTPPrim IPv4 Destination Address", HFILL
            }
        },
        { &hf_catapult_dct2000_sctpprim_dst_addr_v6,
            { "Destination Address",
              "dct2000.sctpprim.dstv6", FT_IPv6, BASE_NONE, NULL, 0x0,
              "SCTPPrim IPv6 Destination Address", HFILL
            }
        },
        { &hf_catapult_dct2000_sctpprim_addr_v4,
            { "Address",
              "dct2000.sctpprim.addr", FT_IPv4, BASE_NONE, NULL, 0x0,
              "SCTPPrim IPv4 Address", HFILL
            }
        },
        { &hf_catapult_dct2000_sctpprim_addr_v6,
            { "Address",
              "dct2000.sctpprim.addrv6", FT_IPv6, BASE_NONE, NULL, 0x0,
              "SCTPPrim IPv6 Address", HFILL
            }
        },
        { &hf_catapult_dct2000_sctpprim_dst_port,
            { "UDP Destination Port",
              "dct2000.sctprim.dstport", FT_UINT16, BASE_PT_SCTP, NULL, 0x0,
              "SCTPPrim Destination Port", HFILL
            }
        },

        { &hf_catapult_dct2000_tty,
            { "tty contents",
              "dct2000.tty", FT_NONE, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_tty_line,
            { "tty line",
              "dct2000.tty-line", FT_STRING, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },

        { &hf_catapult_dct2000_ueid,
            { "UE Id",
              "dct2000.ueid", FT_UINT16, BASE_DEC, NULL, 0x0,
              "User Equipment Identifier", HFILL
            }
        },
        { &hf_catapult_dct2000_srbid,
            { "srbid",
              "dct2000.srbid", FT_UINT8, BASE_DEC, NULL, 0x0,
              "Signalling Radio Bearer Identifier", HFILL
            }
        },
        { &hf_catapult_dct2000_drbid,
            { "drbid",
              "dct2000.drbid", FT_UINT8, BASE_DEC, NULL, 0x0,
              "Data Radio Bearer Identifier", HFILL
            }
        },
        { &hf_catapult_dct2000_cellid,
            { "Cell-Id",
              "dct2000.cellid", FT_UINT16, BASE_DEC, NULL, 0x0,
              "Cell Identifier", HFILL
            }
        },
        { &hf_catapult_dct2000_bcch_transport,
            { "BCCH Transport",
              "dct2000.bcch-transport", FT_UINT16, BASE_DEC, VALS(bcch_transport_vals), 0x0,
              "BCCH Transport Channel", HFILL
            }
        },
        { &hf_catapult_dct2000_rlc_op,
            { "RLC Op",
              "dct2000.rlc-op", FT_UINT8, BASE_DEC, VALS(rlc_op_vals), 0x0,
              "RLC top-level op", HFILL
            }
        },
        { &hf_catapult_dct2000_rlc_channel_type,
            { "RLC Logical Channel Type",
              "dct2000.rlc-logchan-type", FT_UINT8, BASE_DEC, VALS(rlc_logical_channel_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_rlc_mui,
            { "MUI",
              "dct2000.rlc-mui", FT_UINT16, BASE_DEC, NULL, 0x0,
              "RLC MUI", HFILL
            }
        },
        { &hf_catapult_dct2000_rlc_cnf,
            { "CNF",
              "dct2000.rlc-cnf", FT_BOOLEAN, BASE_NONE, TFS(&tfs_yes_no), 0x0,
              "RLC CNF", HFILL
            }
        },
        { &hf_catapult_dct2000_rlc_discard_req,
            { "Discard Req",
              "dct2000.rlc-discard-req", FT_BOOLEAN, BASE_NONE, TFS(&tfs_yes_no), 0x0,
              "RLC Discard Req", HFILL
            }
        },
        { &hf_catapult_dct2000_carrier_type,
            { "Carrier Type",
              "dct2000.carrier-type", FT_UINT8, BASE_DEC, VALS(carrier_type_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_cell_group,
            { "Cell Group",
              "dct2000.cell-group", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_carrier_id,
            { "Carrier Id",
              "dct2000.carrier-id", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },

        { &hf_catapult_dct2000_security_mode_params,
            { "Security Mode Params",
              "dct2000.security-mode-params", FT_NONE, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_uplink_sec_mode,
            { "Uplink Security Mode",
              "dct2000.uplink-security-mode", FT_UINT8, BASE_DEC, VALS(security_mode_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_downlink_sec_mode,
            { "Downlink Security Mode",
              "dct2000.downlink-security-mode", FT_UINT8, BASE_DEC, VALS(security_mode_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_ciphering_algorithm,
            { "Ciphering Algorithm",
              "dct2000.ciphering-algorithm", FT_UINT8, BASE_DEC, VALS(ciphering_algorithm_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_ciphering_key,
            { "Ciphering Key",
              "dct2000.ciphering-key", FT_BYTES, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_integrity_algorithm,
            { "Integrity Algorithm",
              "dct2000.integrity-algorithm", FT_UINT8, BASE_DEC, VALS(integrity_algorithm_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_integrity_key,
            { "Integrity Key",
              "dct2000.integrity-key", FT_BYTES, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },

        { &hf_catapult_dct2000_lte_ccpri_opcode,
            { "CCPRI opcode",
              "dct2000.lte.ccpri.opcode", FT_UINT8, BASE_DEC, VALS(ccpri_opcode_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_lte_ccpri_status,
            { "Status",
              "dct2000.lte.ccpri.status", FT_BOOLEAN, BASE_NONE, TFS(&tfs_error_ok), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_lte_ccpri_channel,
            { "Channel",
              "dct2000.lte.ccpri.channel", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },

        { &hf_catapult_dct2000_lte_nas_rrc_opcode,
            { "NAS RRC Opcode",
              "dct2000.lte.nas-rrc.opcode", FT_UINT8, BASE_DEC, VALS(lte_nas_rrc_opcode_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_lte_nas_rrc_establish_cause,
            { "Establish Cause",
              "dct2000.lte.nas-rrc.establish-cause", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_lte_nas_rrc_priority,
            { "Priority",
              "dct2000.lte.nas-rrc.priority", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_lte_nas_rrc_release_cause,
            { "Priority",
              "dct2000.lte.nas-rrc.priority", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_nr_nas_s1ap_opcode,
            { "NAS S1AP Opcode",
              "dct2000.nas-s1ap.opcode", FT_UINT8, BASE_DEC, VALS(nas_s1ap_opcode_vals), 0x0,
              NULL, HFILL
            }
        },

        { &hf_catapult_dct2000_rbid,
            { "Channel",
              "dct2000.rbid", FT_UINT8, BASE_DEC | BASE_EXT_STRING, &rlc_rbid_vals_ext, 0x0,
              "Channel (rbid)", HFILL
            }
        },
        { &hf_catapult_dct2000_ccch_id,
            { "CCCH Id",
              "dct2000.ccch-id", FT_UINT8, BASE_DEC, NULL, 0x0,
              "CCCH Identifier", HFILL
            }
        },
        { &hf_catapult_dct2000_no_crc_error,
            { "No CRC Error",
              "dct2000.no-crc-error", FT_NONE, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_crc_error,
            { "CRC Error",
              "dct2000.crc-error", FT_NONE, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_clear_tx_buffer,
            { "Clear Tx Buffer",
              "dct2000.clear-tx-buffer", FT_NONE, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_buffer_occupancy,
            { "Buffer Occupancy",
              "dct2000.buffer-occupancy", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_pdu_size,
            { "PDU Size",
              "dct2000.pdu-size", FT_UINT16, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_ueid_type,
            { "UEId Type",
              "dct2000.ueid-type", FT_UINT8, BASE_DEC, VALS(ueid_type_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_tx_priority,
            { "Tx Priority",
              "dct2000.tx-priority", FT_BOOLEAN, BASE_NONE, TFS(&tfs_high_normal), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_last_in_seg_set,
            { "Last in seg set",
              "dct2000.last-in-seg-set", FT_BOOLEAN, BASE_NONE, TFS(&tfs_yes_no), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_rx_timing_deviation,
            { "Tx Timing Deviation",
              "dct2000.rx-timing-deviation", FT_UINT32, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_transport_channel_type,
            { "Transport Channel Type",
              "dct2000.transport_channel_type", FT_UINT8, BASE_DEC, VALS(transport_channel_type_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_no_padding_bits,
            { "Number of padding bits",
              "dct2000.number-of-padding-bits", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },

        { &hf_catapult_dct2000_rawtraffic_interface,
            { "Interface",
              "dct2000.rawtraffic.interface", FT_UINT8, BASE_DEC, NULL, 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_rawtraffic_direction,
            { "Direction",
              "dct2000.rawtraffic.direction", FT_UINT8, BASE_DEC, VALS(direction_vals), 0x0,
              NULL, HFILL
            }
        },
        { &hf_catapult_dct2000_rawtraffic_pdu,
            { "PDU",
              "dct2000.rawtraffic.pdu", FT_BYTES, BASE_NONE, NULL, 0x0,
              NULL, HFILL
            }
        }
    };

    static int *ett[] =
    {
        &ett_catapult_dct2000,
        &ett_catapult_dct2000_ipprim,
        &ett_catapult_dct2000_sctpprim,
        &ett_catapult_dct2000_tty,
        &ett_catapult_dct2000_security_mode_params
    };

    static ei_register_info ei[] = {
        { &ei_catapult_dct2000_lte_ccpri_status_error, { "dct2000.lte.ccpri.status.error", PI_SEQUENCE, PI_ERROR, "CCPRI Indication has error status", EXPFILL }},
        { &ei_catapult_dct2000_error_comment_expert, { "dct2000.error-comment.expert", PI_SEQUENCE, PI_ERROR, "Formatted expert comment", EXPFILL }},
        { &ei_catapult_dct2000_string_invalid, { "dct2000.string.invalid", PI_MALFORMED, PI_ERROR, "String must contain an integer", EXPFILL }}
    };

    module_t *catapult_dct2000_module;
    expert_module_t* expert_catapult_dct2000;

    /* Register protocol. */
    proto_catapult_dct2000 = proto_register_protocol("Catapult DCT2000 packet",
                                                     "DCT2000",
                                                     "dct2000");
    proto_register_field_array(proto_catapult_dct2000, hf, array_length(hf));
    proto_register_subtree_array(ett, array_length(ett));
    expert_catapult_dct2000 = expert_register_protocol(proto_catapult_dct2000);
    expert_register_field_array(expert_catapult_dct2000, ei, array_length(ei));

    /* Allow dissector to find be found by name. */
    catapult_dct2000_handle = register_dissector("dct2000", dissect_catapult_dct2000, proto_catapult_dct2000);

    /* Preferences */
    catapult_dct2000_module = prefs_register_protocol(proto_catapult_dct2000, NULL);

    /* This preference no longer supported (introduces linkage dependency between
       dissectors and wiretap) */
    prefs_register_obsolete_preference(catapult_dct2000_module, "board_ports_only");
    prefs_register_obsolete_preference(catapult_dct2000_module, "decode_lte_s1ap");

    /* Determines whether for not-handled protocols we should try to parse it if:
       - it looks like it's embedded in an ipprim message, AND
       - the DCT2000 protocol name can be matched to a Wireshark dissector name */
    prefs_register_bool_preference(catapult_dct2000_module, "ipprim_heuristic",
                                   "Use IP Primitive heuristic",
                                   "If a payload looks like it's embedded in an "
                                   "IP primitive message, and there is a Wireshark "
                                   "dissector matching the DCT2000 protocol name, "
                                   "try parsing the payload using that dissector",
                                   &catapult_dct2000_try_ipprim_heuristic);

    /* Determines whether for not-handled protocols we should try to parse it if:
       - it looks like it's embedded in an sctpprim message, AND
       - the DCT2000 protocol name can be matched to a Wireshark dissector name */
    prefs_register_bool_preference(catapult_dct2000_module, "sctpprim_heuristic",
                                   "Use SCTP Primitive heuristic",
                                   "If a payload looks like it's embedded in an "
                                   "SCTP primitive message, and there is a Wireshark "
                                   "dissector matching the DCT2000 protocol name, "
                                   "try parsing the payload using that dissector",
                                   &catapult_dct2000_try_sctpprim_heuristic);

    /* Determines whether LTE RRC messages should be dissected */
    prefs_register_bool_preference(catapult_dct2000_module, "decode_lte_rrc",
                                   "Attempt to decode LTE RRC frames",
                                   "When set, attempt to decode LTE RRC frames. "
                                   "Note that this won't affect other protocols "
                                   "that also call the LTE RRC dissector",
                                   &catapult_dct2000_dissect_lte_rrc);

    /* Determines whether out-of-band messages should dissected */
    prefs_register_bool_preference(catapult_dct2000_module, "decode_mac_lte_oob_messages",
                                   "Look for out-of-band LTE MAC events messages in comments",
                                   "When set, look for formatted messages indicating "
                                   "specific events.  This may be quite slow, so should "
                                   "be disabled if LTE MAC is not being analysed",
                                   &catapult_dct2000_dissect_mac_lte_oob_messages);

    /* Whether old protocol names conversions should be checked */
    prefs_register_bool_preference(catapult_dct2000_module, "convert_old_protocol_names",
                                   "Convert old protocol names to wireshark dissector names",
                                   "When set, look for some older protocol names so that"
                                   "they may be matched with wireshark dissectors.",
                                   &catapult_dct2000_dissect_old_protocol_names);

    /* Determines if the protocol field in the DCT2000 shall be used to lookup for dissector */
    prefs_register_bool_preference(catapult_dct2000_module, "use_protocol_name_as_dissector_name",
                                   "Look for a dissector using the protocol name in the "
                                   "DCT2000 record",
                                   "When set, if there is a Wireshark dissector matching "
                                   "the protocol name, it will parse the PDU using "
                                   "that dissector. This may be slow, so should be "
                                   "disabled unless you are using this feature.",
                                   &catapult_dct2000_use_protocol_name_as_dissector_name);
}

/*
 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 4
 * tab-width: 8
 * indent-tabs-mode: nil
 * End:
 *
 * vi: set shiftwidth=4 tabstop=8 expandtab:
 * :indentSize=4:tabSize=8:noTabs=true:
 */

Coverage Report

Created: 2026-09-28 06:52