/* packet-umts_fp.c

 * Routines for UMTS FP disassembly

 *

 * Martin Mathieson

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/prefs.h>

#include <epan/conversation.h>

#include <epan/proto_data.h>

#include <epan/tfs.h>

#include <wsutil/array.h>

#include <wsutil/crc7.h> /* For FP data header and control frame CRC. */

#include <wsutil/crc16-plain.h> /* For FP Payload CRC. */

#include <wsutil/crc11.h> /* For FP EDCH header CRC. */

#include <wsutil/pint.h>

#include <wsutil/ws_roundup.h>

#include "packet-umts_fp.h"

#include "packet-nbap.h"

#include "packet-rrc.h"

/* The Frame Protocol (FP) is described in:

 * 3GPP TS 25.427 (for dedicated channels)

 * 3GPP TS 25.435 (for common/shared channels)

 *

 * TODO:

 *  - IUR interface-specific formats

 *  - do CRC verification before further parsing

 *  - Set the logical channel properly for non multiplexed, channels

 *    for channels that doesn't have the C/T field! This should be based

 *    on the RRC message RadioBearerSetup.

 *  - E-DCH T2 heuristic dissector

 */

void proto_register_fp(void);

void proto_reg_handoff_fp(void);

/* Initialize the protocol and registered fields. */

static int proto_fp;

static int proto_umts_mac;

static int proto_umts_rlc;

static int hf_fp_release;

static int hf_fp_release_version;

static int hf_fp_release_year;

static int hf_fp_release_month;

static int hf_fp_channel_type;

static int hf_fp_division;

static int hf_fp_direction;

static int hf_fp_ddi_config;

static int hf_fp_ddi_config_ddi;

static int hf_fp_ddi_config_macd_pdu_size;

static int hf_fp_header_crc;

static int hf_fp_ft;

static int hf_fp_cfn;

static int hf_fp_pch_cfn;

static int hf_fp_pch_toa;

static int hf_fp_cfn_control;

static int hf_fp_toa;

static int hf_fp_tfi;

static int hf_fp_usch_tfi;

static int hf_fp_cpch_tfi;

static int hf_fp_propagation_delay;

static int hf_fp_tb;

static int hf_fp_chan_zero_tbs;

static int hf_fp_received_sync_ul_timing_deviation;

static int hf_fp_pch_pi;

static int hf_fp_pch_tfi;

static int hf_fp_fach_tfi;

static int hf_fp_transmit_power_level;

static int hf_fp_paging_indication_bitmap;

static int hf_fp_relevant_paging_indication_bitmap;

static int hf_fp_pdsch_set_id;

static int hf_fp_rx_timing_deviation;

static int hf_fp_dch_e_rucch_flag;

static int hf_fp_dch_control_frame_type;

static int hf_fp_dch_rx_timing_deviation;

static int hf_fp_quality_estimate;

static int hf_fp_payload_crc;

static int hf_fp_payload_crc_status;

static int hf_fp_edch_header_crc;

static int hf_fp_edch_fsn;

static int hf_fp_edch_subframe;

static int hf_fp_edch_number_of_subframes;

static int hf_fp_edch_harq_retransmissions;

static int hf_fp_edch_subframe_number;

static int hf_fp_edch_number_of_mac_es_pdus;

static int hf_fp_edch_ddi;

static int hf_fp_edch_subframe_header;

static int hf_fp_edch_number_of_mac_d_pdus;

static int hf_fp_edch_pdu_padding;

static int hf_fp_edch_tsn;

static int hf_fp_edch_mac_es_pdu;

static int hf_fp_edch_user_buffer_size;

static int hf_fp_edch_no_macid_sdus;

static int hf_fp_edch_number_of_mac_is_pdus;

static int hf_fp_edch_mac_is_pdu;

static int hf_fp_edch_e_rnti;

static int hf_fp_edch_macis_descriptors;

static int hf_fp_edch_macis_lchid;

static int hf_fp_edch_macis_length;

static int hf_fp_edch_macis_flag;

static int hf_fp_edch_entity;

static int hf_fp_frame_seq_nr;

static int hf_fp_hsdsch_pdu_block_header;

/* static int hf_fp_hsdsch_pdu_block; */

static int hf_fp_flush;

static int hf_fp_fsn_drt_reset;

static int hf_fp_drt_indicator;

static int hf_fp_fach_indicator;

static int hf_fp_total_pdu_blocks;

static int hf_fp_drt;

static int hf_fp_hrnti;

static int hf_fp_rach_measurement_result;

static int hf_fp_lchid;

static int hf_fp_pdu_length_in_block;

static int hf_fp_pdus_in_block;

static int hf_fp_cmch_pi;

static int hf_fp_user_buffer_size;

static int hf_fp_hsdsch_credits;

static int hf_fp_hsdsch_max_macd_pdu_len;

static int hf_fp_hsdsch_max_macdc_pdu_len;

static int hf_fp_hsdsch_interval;

static int hf_fp_hsdsch_calculated_rate;

static int hf_fp_hsdsch_unlimited_rate;

static int hf_fp_hsdsch_repetition_period;

static int hf_fp_hsdsch_data_padding;

static int hf_fp_hsdsch_new_ie_flags;

static int hf_fp_hsdsch_new_ie_flag[8];

static int hf_fp_hsdsch_drt;

static int hf_fp_hsdsch_entity;

static int hf_fp_hsdsch_physical_layer_category;

static int hf_fp_timing_advance;

static int hf_fp_num_of_pdu;

static int hf_fp_mac_d_pdu_len;

static int hf_fp_mac_d_pdu;

static int hf_fp_data;

static int hf_fp_crcis;

static int hf_fp_crci[8];

static int hf_fp_common_control_frame_type;

static int hf_fp_t1;

static int hf_fp_t2;

static int hf_fp_t3;

static int hf_fp_ul_sir_target;

static int hf_fp_pusch_set_id;

static int hf_fp_activation_cfn;

static int hf_fp_duration;

static int hf_fp_power_offset;

static int hf_fp_code_number;

static int hf_fp_spreading_factor;

static int hf_fp_mc_info;

static int hf_fp_rach_new_ie_flags;

static int hf_fp_rach_new_ie_flag_unused[7];

static int hf_fp_rach_ext_propagation_delay_present;

static int hf_fp_rach_cell_portion_id_present;

static int hf_fp_rach_angle_of_arrival_present;

static int hf_fp_rach_ext_rx_sync_ul_timing_deviation_present;

static int hf_fp_rach_ext_rx_timing_deviation_present;

static int hf_fp_cell_portion_id;

static int hf_fp_ext_propagation_delay;

static int hf_fp_angle_of_arrival;

static int hf_fp_ext_received_sync_ul_timing_deviation;

static int hf_fp_radio_interface_parameter_update_flag[5];

static int hf_fp_dpc_mode;

static int hf_fp_tpc_po;

static int hf_fp_multiple_rl_set_indicator;

static int hf_fp_max_ue_tx_pow;

static int hf_fp_congestion_status;

static int hf_fp_e_rucch_present;

static int hf_fp_extended_bits_present;

static int hf_fp_extended_bits;

static int hf_fp_spare_extension;

static int hf_fp_ul_setup_frame;

static int hf_fp_dl_setup_frame;

static int hf_fp_relevant_pi_frame;

/* Subtrees. */

static int ett_fp;

static int ett_fp_release;

static int ett_fp_data;

static int ett_fp_crcis;

static int ett_fp_ddi_config;

static int ett_fp_edch_subframe_header;

static int ett_fp_edch_subframe;

static int ett_fp_edch_maces;

static int ett_fp_edch_macis_descriptors;

static int ett_fp_hsdsch_new_ie_flags;

static int ett_fp_rach_new_ie_flags;

static int ett_fp_hsdsch_pdu_block_header;

static int ett_fp_pch_relevant_pi;

static expert_field ei_fp_hsdsch_common_experimental_support;

static expert_field ei_fp_hsdsch_common_t3_not_implemented;

static expert_field ei_fp_channel_type_unknown;

static expert_field ei_fp_ddi_not_defined;

static expert_field ei_fp_stop_hsdpa_transmission;

static expert_field ei_fp_hsdsch_entity_not_specified;

static expert_field ei_fp_expecting_tdd;

static expert_field ei_fp_bad_payload_checksum;

static expert_field ei_fp_e_rnti_t2_edch_frames;

static expert_field ei_fp_crci_no_subdissector;

static expert_field ei_fp_timing_adjustment_reported;

static expert_field ei_fp_mac_is_sdus_miscount;

static expert_field ei_fp_maybe_srb;

static expert_field ei_fp_transport_channel_type_unknown;

static expert_field ei_fp_pch_lost_relevant_pi_frame;

static expert_field ei_fp_unable_to_locate_ddi_entry;

static expert_field ei_fp_e_rnti_first_entry;

static expert_field ei_fp_bad_header_checksum;

static expert_field ei_fp_crci_error_bit_set_for_tb;

static expert_field ei_fp_spare_extension;

static expert_field ei_fp_no_per_frame_info;

static expert_field ei_fp_no_per_conv_channel_info;

static expert_field ei_fp_invalid_frame_count;

static expert_field ei_fp_invalid_ddi_count;

static dissector_handle_t rlc_bcch_handle;

static dissector_handle_t mac_fdd_dch_handle;

static dissector_handle_t mac_fdd_rach_handle;

static dissector_handle_t mac_fdd_fach_handle;

static dissector_handle_t mac_fdd_pch_handle;

static dissector_handle_t mac_fdd_edch_handle;

static dissector_handle_t mac_fdd_edch_type2_handle;

static dissector_handle_t mac_fdd_hsdsch_handle;

static dissector_handle_t fp_handle;

static dissector_handle_t fp_aal2_handle;

static proto_tree *top_level_tree;

/* Variables used for preferences */

static bool preferences_call_mac_dissectors = true;

static bool preferences_show_release_info = true;

static bool preferences_payload_checksum = true;

static bool preferences_header_checksum = true;

static bool preferences_track_paging_indications = true;

/* E-DCH (T1) channel header information */

struct edch_t1_subframe_info

{

    uint8_t subframe_number;

    uint8_t number_of_mac_es_pdus;

    uint8_t ddi[64];

    uint16_t number_of_mac_d_pdus[64];

};

/* E-DCH (T2) channel header information */

struct edch_t2_subframe_info

{

    uint8_t  subframe_number;

    uint8_t  number_of_mac_is_pdus;

    uint8_t  number_of_mac_is_sdus[16];

    uint8_t  mac_is_lchid[16][16];

    uint16_t mac_is_length[16][16];

};

static const value_string channel_type_vals[] =

{

    { CHANNEL_RACH_FDD,         "RACH_FDD" },

    { CHANNEL_RACH_TDD,         "RACH_TDD" },

    { CHANNEL_FACH_FDD,         "FACH_FDD" },

    { CHANNEL_FACH_TDD,         "FACH_TDD" },

    { CHANNEL_DSCH_FDD,         "DSCH_FDD" },

    { CHANNEL_DSCH_TDD,         "DSCH_TDD" },

    { CHANNEL_USCH_TDD_384,     "USCH_TDD_384" },

    { CHANNEL_USCH_TDD_128,     "USCH_TDD_128" },

    { CHANNEL_PCH,              "PCH" },

    { CHANNEL_CPCH,             "CPCH" },

    { CHANNEL_BCH,              "BCH" },

    { CHANNEL_DCH,              "DCH" },

    { CHANNEL_HSDSCH,           "HSDSCH" },

    { CHANNEL_IUR_CPCHF,        "IUR CPCHF" },

    { CHANNEL_IUR_FACH,         "IUR FACH" },

    { CHANNEL_IUR_DSCH,         "IUR DSCH" },

    { CHANNEL_EDCH,             "EDCH" },

    { CHANNEL_RACH_TDD_128,     "RACH_TDD_128" },

    { CHANNEL_HSDSCH_COMMON,    "HSDSCH-COMMON" },

    { CHANNEL_HSDSCH_COMMON_T3, "HSDSCH-COMMON-T3" },

    { CHANNEL_EDCH_COMMON,      "EDCH-COMMON"},

    { 0, NULL }

};

static const value_string division_vals[] =

{

    { Division_FDD,      "FDD"},

    { Division_TDD_384,  "TDD-384"},

    { Division_TDD_128,  "TDD-128"},

    { Division_TDD_768,  "TDD-768"},

    { 0, NULL }

};

/* Frame Type (ft) values */

#define FT_DATA    0

#define FT_CONTROL 1

static const value_string frame_type_vals[] = {

    { FT_DATA,      "Data" },

    { FT_CONTROL,   "Control" },

    { 0,   NULL }

};

static const value_string crci_vals[] = {

    { 0,   "Correct" },

    { 1,   "Not correct" },

    { 0,   NULL }

};

static const value_string paging_indication_vals[] = {

    { 0,   "no PI-bitmap in payload" },

    { 1,   "PI-bitmap in payload" },

    { 0,   NULL }

};

static const value_string spreading_factor_vals[] = {

    { 0,   "4"},

    { 1,   "8"},

    { 2,   "16"},

    { 3,   "32"},

    { 4,   "64"},

    { 5,   "128"},

    { 6,   "256"},

    { 0,   NULL }

};

static const value_string congestion_status_vals[] = {

    { 0,   "No TNL congestion"},

    { 1,   "Reserved for future use"},

    { 2,   "TNL congestion - detected by delay build-up"},

    { 3,   "TNL congestion - detected by frame loss"},

    { 0,   NULL }

};

static const value_string e_rucch_flag_vals[] = {

    { 0,   "Conventional E-RUCCH reception" },

    { 1,   "TA Request reception" },

    { 0,   NULL }

};

static const value_string hsdshc_mac_entity_vals[] = {

    { entity_not_specified,    "Unspecified (assume MAC-hs)" },

    { hs,                      "MAC-hs" },

    { ehs,                     "MAC-ehs" },

    { 0,   NULL }

};

static const value_string edch_mac_entity_vals[] = {

    { 0,                    "MAC-e/es" },

    { 1,                    "MAC-i/is" },

    { 0,   NULL }

};

static const value_string lchid_vals[] = {

    {  0,   "Logical Channel 1" },

    {  1,   "Logical Channel 2" },

    {  2,   "Logical Channel 3" },

    {  3,   "Logical Channel 4" },

    {  4,   "Logical Channel 5" },

    {  5,   "Logical Channel 6" },

    {  6,   "Logical Channel 7" },

    {  7,   "Logical Channel 8" },

    {  8,   "Logical Channel 9" },

    {  9,   "Logical Channel 10" },

    { 10,   "Logical Channel 11" },

    { 11,   "Logical Channel 12" },

    { 12,   "Logical Channel 13" },

    { 13,   "Logical Channel 14" },

    { 14,   "CCCH (SRB0)" },

    { 15,   "E-RNTI being included (FDD only)" },

    { 0,   NULL }

};

/* Dedicated control types */

#define DCH_OUTER_LOOP_POWER_CONTROL            1

#define DCH_TIMING_ADJUSTMENT                   2

#define DCH_DL_SYNCHRONISATION                  3

#define DCH_UL_SYNCHRONISATION                  4

#define DCH_DL_NODE_SYNCHRONISATION             6

#define DCH_UL_NODE_SYNCHRONISATION             7

#define DCH_RX_TIMING_DEVIATION                 8

#define DCH_RADIO_INTERFACE_PARAMETER_UPDATE    9

#define DCH_TIMING_ADVANCE                     10

#define DCH_TNL_CONGESTION_INDICATION          11

static const value_string dch_control_frame_type_vals[] = {

    { DCH_OUTER_LOOP_POWER_CONTROL,         "OUTER LOOP POWER CONTROL" },

    { DCH_TIMING_ADJUSTMENT,                "TIMING ADJUSTMENT" },

    { DCH_DL_SYNCHRONISATION,               "DL SYNCHRONISATION" },

    { DCH_UL_SYNCHRONISATION,               "UL SYNCHRONISATION" },

    { 5,                                    "Reserved Value" },

    { DCH_DL_NODE_SYNCHRONISATION,          "DL NODE SYNCHRONISATION" },

    { DCH_UL_NODE_SYNCHRONISATION,          "UL NODE SYNCHRONISATION" },

    { DCH_RX_TIMING_DEVIATION,              "RX TIMING DEVIATION" },

    { DCH_RADIO_INTERFACE_PARAMETER_UPDATE, "RADIO INTERFACE PARAMETER UPDATE" },

    { DCH_TIMING_ADVANCE,                   "TIMING ADVANCE" },

    { DCH_TNL_CONGESTION_INDICATION,        "TNL CONGESTION INDICATION" },

    { 0,   NULL }

};

/* Common channel control types */

#define COMMON_OUTER_LOOP_POWER_CONTROL                1

#define COMMON_TIMING_ADJUSTMENT                       2

#define COMMON_DL_SYNCHRONISATION                      3

#define COMMON_UL_SYNCHRONISATION                      4

#define COMMON_DL_NODE_SYNCHRONISATION                 6

#define COMMON_UL_NODE_SYNCHRONISATION                 7

#define COMMON_DYNAMIC_PUSCH_ASSIGNMENT                8

#define COMMON_TIMING_ADVANCE                          9

#define COMMON_HS_DSCH_Capacity_Request               10

#define COMMON_HS_DSCH_Capacity_Allocation            11

#define COMMON_HS_DSCH_Capacity_Allocation_Type_2     12

static const value_string common_control_frame_type_vals[] = {

    { COMMON_OUTER_LOOP_POWER_CONTROL,            "OUTER LOOP POWER CONTROL" },

    { COMMON_TIMING_ADJUSTMENT,                   "TIMING ADJUSTMENT" },

    { COMMON_DL_SYNCHRONISATION,                  "DL SYNCHRONISATION" },

    { COMMON_UL_SYNCHRONISATION,                  "UL SYNCHRONISATION" },

    { 5,                                          "Reserved Value" },

    { COMMON_DL_NODE_SYNCHRONISATION,             "DL NODE SYNCHRONISATION" },

    { COMMON_UL_NODE_SYNCHRONISATION,             "UL NODE SYNCHRONISATION" },

    { COMMON_DYNAMIC_PUSCH_ASSIGNMENT,            "DYNAMIC PUSCH ASSIGNMENT" },

    { COMMON_TIMING_ADVANCE,                      "TIMING ADVANCE" },

    { COMMON_HS_DSCH_Capacity_Request,            "HS-DSCH Capacity Request" },

    { COMMON_HS_DSCH_Capacity_Allocation,         "HS-DSCH Capacity Allocation" },

    { COMMON_HS_DSCH_Capacity_Allocation_Type_2,  "HS-DSCH Capacity Allocation Type 2" },

    { 0,   NULL }

};

/* 0 to 7*/

static const uint8_t hsdsch_macdflow_id_rlc_map[] = {

    RLC_UM,                   /*0 SRB */

    RLC_AM,                   /*1 Interactive PS*/

    RLC_AM,                   /*2 Interactive PS*/

    RLC_UNKNOWN_MODE,         /*3 ???*/

    RLC_AM,                   /*4 Streaming PS*/

    RLC_UNKNOWN_MODE,

    RLC_UNKNOWN_MODE,

    RLC_UNKNOWN_MODE

};

/* Mapping hsdsch MACd-FlowId to MAC_CONTENT, basically flowid = 1 (0) => SRB*/

/* 1 to 8*/

static const uint8_t hsdsch_macdflow_id_mac_content_map[] = {

    MAC_CONTENT_DCCH,    /*1 SRB */

    MAC_CONTENT_PS_DTCH, /*2 Interactive PS*/

    MAC_CONTENT_PS_DTCH, /*3 Interactive PS*/

    RLC_UNKNOWN_MODE,    /*4 ???*/

    MAC_CONTENT_PS_DTCH, /*5 Streaming PS*/

    RLC_UNKNOWN_MODE,

    RLC_UNKNOWN_MODE,

    RLC_UNKNOWN_MODE

};

/* Make fake logical channel id's based on MACdFlow-ID's,

* XXXX Bug 12121 expanded the number of entries to 8(+2),

* not at all sure what the proper value should be 0xfF?

*/

static const uint8_t fake_lchid_macd_flow[] = {1,9,14,11,0,12,0,0};

/* Dissect message parts */

static int dissect_tb_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                           unsigned offset, struct fp_info *p_fp_info,

                           dissector_handle_t *data_handle,

                           void *data);

static int dissect_macd_pdu_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                 unsigned offset, uint16_t length, uint16_t number_of_pdus, struct fp_info *p_fp_info,

                                 void *data);

static int dissect_macd_pdu_data_type_2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                        unsigned offset, uint16_t length, uint16_t number_of_pdus, struct fp_info * fpi,

                                        void *data);

static int dissect_crci_bits(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                             fp_info *p_fp_info, unsigned offset);

static void dissect_spare_extension_and_crc(tvbuff_t *tvb, packet_info *pinfo,

                                            proto_tree *tree, uint8_t dch_crc_present,

                                            unsigned offset, unsigned header_length);

/* Dissect common control messages */

static int dissect_common_outer_loop_power_control(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb,

                                                   unsigned offset, struct fp_info *p_fp_info);

static int dissect_common_timing_adjustment(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb,

                                            unsigned offset, struct fp_info *p_fp_info);

static int dissect_common_dl_node_synchronisation(packet_info *pinfo, proto_tree *tree,

                                                  tvbuff_t *tvb, unsigned offset);

static int dissect_common_ul_node_synchronisation(packet_info *pinfo, proto_tree *tree,

                                                  tvbuff_t *tvb, unsigned offset);

static int dissect_common_dl_synchronisation(packet_info *pinfo, proto_tree *tree,

                                            tvbuff_t *tvb, unsigned offset,

                                            struct fp_info *p_fp_info);

static int dissect_common_ul_synchronisation(packet_info *pinfo, proto_tree *tree,

                                            tvbuff_t *tvb, unsigned offset,

                                            struct fp_info *p_fp_info);

static int dissect_common_timing_advance(packet_info *pinfo, proto_tree *tree,

                                         tvbuff_t *tvb, unsigned offset);

static int dissect_hsdpa_capacity_request(packet_info *pinfo, proto_tree *tree,

                                          tvbuff_t *tvb, unsigned offset);

static int dissect_hsdpa_capacity_allocation(packet_info *pinfo, proto_tree *tree,

                                             tvbuff_t *tvb, unsigned offset,

                                             struct fp_info *p_fp_info);

static int dissect_hsdpa_capacity_allocation_type_2(packet_info *pinfo, proto_tree *tree,

                                                    tvbuff_t *tvb, unsigned offset);

static void dissect_common_control(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                   unsigned offset, struct fp_info *p_fp_info);

static int dissect_common_dynamic_pusch_assignment(packet_info *pinfo, proto_tree *tree,

                                                   tvbuff_t *tvb, unsigned offset);

/* Dissect common channel types */

static void dissect_rach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                      unsigned offset, struct fp_info *p_fp_info,

                                      void *data);

static void dissect_fach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                      unsigned offset, struct fp_info *p_fp_info,

                                      void *data);

static void dissect_dsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                      unsigned offset, struct fp_info *p_fp_info);

static void dissect_usch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                      unsigned offset, struct fp_info *p_fp_info);

static void dissect_pch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                     unsigned offset, struct fp_info *p_fp_info,

                                     void *data);

static void dissect_cpch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                      unsigned offset, struct fp_info *p_fp_info);

static void dissect_bch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                     unsigned offset, struct fp_info *p_fp_info);

static void dissect_iur_dsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                          unsigned offset, struct fp_info *p_fp_info);

static void dissect_hsdsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                        unsigned offset, struct fp_info *p_fp_info,

                                        void *data);

static void dissect_hsdsch_type_2_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                               unsigned offset, struct fp_info *p_fp_info,

                                               void *data);

static void dissect_hsdsch_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                               unsigned offset,

                                               struct fp_info *p_fp_info,

                                               void *data);

/* Dissect DCH control messages */

static int dissect_dch_timing_adjustment(proto_tree *tree, packet_info *pinfo,

                                         tvbuff_t *tvb, unsigned offset);

static int dissect_dch_rx_timing_deviation(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, unsigned offset,

                                           struct fp_info *p_fp_info);

static int dissect_dch_dl_synchronisation(proto_tree *tree, packet_info *pinfo,

                                          tvbuff_t *tvb, unsigned offset);

static int dissect_dch_ul_synchronisation(proto_tree *tree, packet_info *pinfo,

                                          tvbuff_t *tvb, unsigned offset);

static int dissect_dch_outer_loop_power_control(proto_tree *tree, packet_info *pinfo,

                                                tvbuff_t *tvb, unsigned offset);

static int dissect_dch_dl_node_synchronisation(proto_tree *tree, packet_info *pinfo,

                                               tvbuff_t *tvb, unsigned offset);

static int dissect_dch_ul_node_synchronisation(proto_tree *tree, packet_info *pinfo,

                                               tvbuff_t *tvb, unsigned offset);

static int dissect_dch_radio_interface_parameter_update(proto_tree *tree, packet_info *pinfo,

                                                        tvbuff_t *tvb, unsigned offset);

static int dissect_dch_timing_advance(proto_tree *tree, packet_info *pinfo,

                                      tvbuff_t *tvb, unsigned offset, struct fp_info *p_fp_info);

static int dissect_dch_tnl_congestion_indication(proto_tree *tree, packet_info *pinfo,

                                                 tvbuff_t *tvb, unsigned offset);

static void dissect_dch_control_frame(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb,

                                      unsigned offset, struct fp_info *p_fp_info);

/* Dissect a DCH channel */

static void dissect_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                     unsigned offset, struct fp_info *p_fp_info,

                                     void *data);

/* Dissect dedicated channels */

static void dissect_e_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                       unsigned offset, struct fp_info *p_fp_info,

                                       bool is_common,

                                       void *data);

static void dissect_e_dch_t2_or_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                                                    unsigned offset, struct fp_info *p_fp_info,

                                                    int number_of_subframes,

                                                    bool is_common,

                                                    uint16_t header_crc,

                                                    proto_item * header_crc_pi,

                                                    void *data);

/* Main dissection function */

static int dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data);

/*

 * CRNC sends data downlink on uplink parameters.

 */

void

set_umts_fp_conv_data(conversation_t *conversation, umts_fp_conversation_info_t *umts_fp_conversation_info)

{

    if (conversation == NULL) {

        return;

     }

    conversation_add_proto_data(conversation, proto_fp, umts_fp_conversation_info);

}

static int

get_tb_count(struct fp_info *p_fp_info)

{

    int chan, tb_count = 0;

    for (chan = 0; chan < p_fp_info->num_chans; chan++) {

        tb_count += p_fp_info->chan_num_tbs[chan];

    }

    return tb_count;

}

static bool verify_control_frame_crc(tvbuff_t * tvb, packet_info * pinfo, proto_item * pi, uint16_t frame_crc)

{

    uint8_t crc = 0;

    uint8_t * data = NULL;

    /* Get data. */

    data = (uint8_t *)tvb_memdup(pinfo->pool, tvb, 0, tvb_reported_length(tvb));

    /* Include only FT flag bit in CRC calculation. */

    data[0] = data[0] & 1;

    /* Calculate crc7 sum. */

    crc = crc7update(0, data, tvb_reported_length(tvb));

    crc = crc7finalize(crc); /* finalize crc */

    if (frame_crc == crc) {

        proto_item_append_text(pi, " [correct]");

        return true;

    } else {

        proto_item_append_text(pi, " [incorrect, should be 0x%x]", crc);

        expert_add_info(pinfo, pi, &ei_fp_bad_header_checksum);

        return false;

    }

}

static bool verify_header_crc(tvbuff_t * tvb, packet_info * pinfo, proto_item * pi, uint16_t header_crc, unsigned header_length)

{

    uint8_t crc = 0;

    uint8_t * data = NULL;

    /* Get data of header with first byte removed. */

    data = (uint8_t *)tvb_memdup(pinfo->pool, tvb, 1, header_length-1);

    /* Calculate crc7 sum. */

    crc = crc7update(0, data, header_length-1);

    crc = crc7finalize(crc); /* finalize crc */

    if (header_crc == crc) {

        proto_item_append_text(pi, " [correct]");

        return true;

    } else {

        proto_item_append_text(pi, " [incorrect, should be 0x%x]", crc);

        expert_add_info(pinfo, pi, &ei_fp_bad_header_checksum);

        return false;

    }

}

static bool verify_header_crc_edch(tvbuff_t * tvb, packet_info * pinfo, proto_item * pi, uint16_t header_crc, unsigned header_length)

{

    uint16_t crc = 0;

    uint8_t * data = NULL;

    /* First create new subset of header with first byte removed. */

    tvbuff_t * headtvb = tvb_new_subset_length(tvb, 1, header_length-1);

    /* Get data of header with first byte removed. */

    data = (uint8_t *)tvb_memdup(pinfo->pool, headtvb, 0, header_length-1);

    /* Remove first 4 bits of the remaining data which are Header CRC cont. */

    data[0] = data[0] & 0x0f;

    crc = crc11_307_noreflect_noxor(data, header_length-1);

    if (header_crc == crc) {

        proto_item_append_text(pi, " [correct]");

        return true;

    } else {

        proto_item_append_text(pi, " [incorrect, should be 0x%x]", crc);

        expert_add_info(pinfo, pi, &ei_fp_bad_header_checksum);

        return false;

    }

}

/* Dissect the TBs of a UL data frame*/

static int

dissect_tb_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                unsigned offset, struct fp_info *p_fp_info,

                dissector_handle_t *data_handle, void *data)

{

    int         chan, num_tbs   = 0;

    unsigned    bit_offset      = 0;

    unsigned    crci_bit_offset = (offset+1)<<3; /* Current offset + Quality estimate of 1 byte at the end*/

    unsigned    data_bits       = 0;

    uint8_t     crci_bit        = 0;

    proto_item *tree_ti         = NULL;

    proto_tree *data_tree       = NULL;

    bool        dissected       = false;

    /* Add data subtree */

    tree_ti =  proto_tree_add_item(tree, hf_fp_data, tvb, offset, -1, ENC_NA);

    proto_item_set_text(tree_ti, "TB data for %u chans", p_fp_info->num_chans);

    data_tree = proto_item_add_subtree(tree_ti, ett_fp_data);

    if (p_fp_info->num_chans >= MAX_FP_CHANS) {

        expert_add_info_format(pinfo, data_tree, &ei_fp_invalid_frame_count, "Invalid Number of channels (max is %u)", MAX_FP_CHANS);

        return offset;

    }

    /* Calculate offset to CRCI bits */

    if (p_fp_info->is_uplink) {

        for (chan=0; chan < p_fp_info->num_chans; chan++) {

            int n;

            for (n=0; n < p_fp_info->chan_num_tbs[chan]; n++) {

                /* Advance bit offset */

                crci_bit_offset += p_fp_info->chan_tf_size[chan];

                /* Pad out to next byte */

                crci_bit_offset = WS_ROUNDUP_8(crci_bit_offset);

            }

        }

    }

    /* Now for the TB data */

    for (chan=0; chan < p_fp_info->num_chans; chan++) {

        int n;

        p_fp_info->cur_chan = chan;    /*Set current channel?*/

        /* Clearly show channels with no TBs */

        if (p_fp_info->chan_num_tbs[chan] == 0) {

            proto_item *no_tb_ti = proto_tree_add_uint(data_tree, hf_fp_chan_zero_tbs, tvb,

                                                       offset+(bit_offset/8),

                                                       0, chan+1);

            proto_item_append_text(no_tb_ti, " (of size %d)",

                                   p_fp_info->chan_tf_size[chan]);

            proto_item_set_generated(no_tb_ti);

        }

        /* Show TBs from non-empty channels */

        for (n=0; n < p_fp_info->chan_num_tbs[chan]; n++) {

            proto_item *ti;

            p_fp_info->cur_tb = chan;    /*Set current transport block?*/

            if (data_tree) {

                ti = proto_tree_add_item(data_tree, hf_fp_tb, tvb,

                                         offset + (bit_offset/8),

                                         ((bit_offset % 8) + p_fp_info->chan_tf_size[chan] + 7) / 8,

                                         ENC_NA);

                proto_item_set_text(ti, "TB (chan %u, tb %u, %u bits)",

                                    chan+1, n+1, p_fp_info->chan_tf_size[chan]);

            }

            if (preferences_call_mac_dissectors && data_handle &&

                (p_fp_info->chan_tf_size[chan] > 0)) {

                tvbuff_t *next_tvb;

                proto_item *item;

                /* If this is DL we should not care about crci bits (since they don't exists)*/

                if (p_fp_info->is_uplink) {

                    if ( p_fp_info->channel == CHANNEL_RACH_FDD) {    /*In RACH we don't have any QE field, hence go back 8 bits.*/

                        crci_bit = tvb_get_bits8(tvb, crci_bit_offset+n-8, 1);

                        item = proto_tree_add_item(data_tree, hf_fp_crci[n%8], tvb, (crci_bit_offset+n-8)/8, 1, ENC_BIG_ENDIAN);

                        proto_item_set_generated(item);

                    } else {

                        crci_bit = tvb_get_bits8(tvb, crci_bit_offset+n, 1);

                        item = proto_tree_add_item(data_tree, hf_fp_crci[n%8], tvb, (crci_bit_offset+n)/8, 1, ENC_BIG_ENDIAN);

                        proto_item_set_generated(item);

                    }

                }

                if (crci_bit == 0 || !p_fp_info->is_uplink) {

                    next_tvb = tvb_new_subset_length(tvb, offset + bit_offset/8,

                                              ((bit_offset % 8) + p_fp_info->chan_tf_size[chan] + 7) / 8);

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

                    /* TODO: maybe this decision can be based only on info available in fp_info */

                    call_dissector_with_data(*data_handle, next_tvb, pinfo, top_level_tree, data);

                    dissected = true;

                } else {

                    proto_tree_add_expert(tree, pinfo, &ei_fp_crci_no_subdissector, tvb, offset + bit_offset/8,

                                               ((bit_offset % 8) + p_fp_info->chan_tf_size[chan] + 7) / 8);

                }

            }

            num_tbs++;

            /* Advance bit offset */

            bit_offset += p_fp_info->chan_tf_size[chan];

            data_bits  += p_fp_info->chan_tf_size[chan];

            /* Pad out to next byte */

            bit_offset = WS_ROUNDUP_8(bit_offset);

        }

    }

    if (dissected == false) {

        col_append_fstr(pinfo->cinfo, COL_INFO, "(%u bits in %u tbs)",

                        data_bits, num_tbs);

    }

    /* Data tree should cover entire length */

    if (data_tree) {

        proto_item_set_len(tree_ti, bit_offset/8);

        proto_item_append_text(tree_ti, " (%u bits in %u tbs)", data_bits, num_tbs);

    }

    /* Move offset past TBs (we know it's already padded out to next byte) */

    offset += (bit_offset / 8);

    return offset;

}

/* Dissect the MAC-d PDUs of an HS-DSCH (type 1) frame.

   Length is in bits, and payload is offset by 4 bits of padding */

static int

dissect_macd_pdu_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                      unsigned offset, uint16_t length, uint16_t number_of_pdus,

                      struct fp_info *p_fp_info, void *data)

{

    int         pdu;

    unsigned    bit_offset = 0;

    proto_item *pdus_ti    = NULL;

    proto_tree *data_tree  = NULL;

    bool        dissected  = false;

    /* Add data subtree */

    pdus_ti =  proto_tree_add_item(tree, hf_fp_data, tvb, offset, -1, ENC_NA);

    proto_item_set_text(pdus_ti, "%u MAC-d PDUs of %u bits", number_of_pdus, length);

    data_tree = proto_item_add_subtree(pdus_ti, ett_fp_data);

    if (number_of_pdus >= MAX_MAC_FRAMES) {

        expert_add_info_format(pinfo, data_tree, &ei_fp_invalid_frame_count, "Invalid number_of_pdus (max is %u)", MAX_MAC_FRAMES);

        return offset;

    }

    /* Now for the PDUs */

    for (pdu=0; pdu < number_of_pdus; pdu++) {

        proto_item *pdu_ti;

        if (data_tree) {

            /* Show 4 bits padding at start of PDU */

            proto_tree_add_item(data_tree, hf_fp_hsdsch_data_padding, tvb, offset+(bit_offset/8), 1, ENC_BIG_ENDIAN);

        }

        bit_offset += 4;

        /* Data bytes! */

        if (data_tree) {

            pdu_ti = proto_tree_add_item(data_tree, hf_fp_mac_d_pdu, tvb,

                                         offset + (bit_offset/8),

                                         ((bit_offset % 8) + length + 7) / 8,

                                         ENC_NA);

            proto_item_set_text(pdu_ti, "MAC-d PDU (PDU %u)", pdu+1);

        }

        p_fp_info->cur_tb = pdu;    /*Set TB (PDU) index correctly*/

        if (preferences_call_mac_dissectors) {

            tvbuff_t *next_tvb;

            next_tvb = tvb_new_subset_length(tvb, offset + bit_offset/8,

                                      ((bit_offset % 8) + length + 7)/8);

            call_dissector_with_data(mac_fdd_hsdsch_handle, next_tvb, pinfo, top_level_tree, data);

            dissected = true;

        }

        /* Advance bit offset */

        bit_offset += length;

        /* Pad out to next byte */

        bit_offset = WS_ROUNDUP_8(bit_offset);

    }

    /* Data tree should cover entire length */

    proto_item_set_len(pdus_ti, bit_offset/8);

    /* Move offset past PDUs (we know it's already padded out to next byte) */

    offset += (bit_offset / 8);

    /* Show summary in info column */

    if (dissected == false) {

        col_append_fstr(pinfo->cinfo, COL_INFO, "   %u PDUs of %u bits",

                        number_of_pdus, length);

    }

    return offset;

}

/* Dissect the MAC-d PDUs of an HS-DSCH (type 2) frame.

   Length is in bytes, and payload is byte-aligned (no padding) */

static int

dissect_macd_pdu_data_type_2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                             unsigned offset, uint16_t length, uint16_t number_of_pdus,

                             struct fp_info *fpi, void *data)

{

    int         pdu;

    proto_item *pdus_ti      = NULL;

    proto_tree *data_tree    = NULL;

    unsigned    first_offset = offset;

    bool        dissected    = false;

    /* Add data subtree */

    pdus_ti =  proto_tree_add_item(tree, hf_fp_data, tvb, offset, -1, ENC_NA);

    proto_item_set_text(pdus_ti, "%u MAC-d PDUs of %u bytes", number_of_pdus, length);

    data_tree = proto_item_add_subtree(pdus_ti, ett_fp_data);

    if (number_of_pdus >= MAX_MAC_FRAMES) {

        expert_add_info_format(pinfo, data_tree, &ei_fp_invalid_frame_count, "Invalid number_of_pdus (max is %u)", MAX_MAC_FRAMES);

        return offset;

    }

    /* Now for the PDUs */

    for (pdu=0; pdu < number_of_pdus; pdu++) {

        proto_item *pdu_ti;

        /* Data bytes! */

        if (data_tree) {

            pdu_ti = proto_tree_add_item(data_tree, hf_fp_mac_d_pdu, tvb,

                                         offset, length, ENC_NA);

            proto_item_set_text(pdu_ti, "MAC-d PDU (PDU %u)", pdu+1);

        }

        if (preferences_call_mac_dissectors) {

            tvbuff_t *next_tvb = tvb_new_subset_length(tvb, offset, length);

            fpi->cur_tb = pdu;    /*Set proper pdu index for MAC and higher layers*/

            call_dissector_with_data(mac_fdd_hsdsch_handle, next_tvb, pinfo, top_level_tree, data);

            dissected = true;

        }

        /* Advance offset */

        offset += length;

    }

    /* Data tree should cover entire length */

    proto_item_set_len(pdus_ti, offset-first_offset);

    /* Show summary in info column */

    if (!dissected) {

        col_append_fstr(pinfo->cinfo, COL_INFO, "   %u PDUs of %u bits",

                        number_of_pdus, length*8);

    }

    return offset;

}

/* Dissect CRCI bits (uplink) */

static int

dissect_crci_bits(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                  fp_info *p_fp_info, unsigned offset)

{

    int         n, num_tbs;

    proto_item *ti         = NULL;

    proto_tree *crcis_tree = NULL;

    unsigned    errors     = 0;

    num_tbs = get_tb_count(p_fp_info);

    /* Add CRCIs subtree */

    if (tree) {

        ti =  proto_tree_add_item(tree, hf_fp_crcis, tvb, offset, (num_tbs+7)/8, ENC_NA);

        proto_item_set_text(ti, "CRCI bits for %u tbs", num_tbs);

        crcis_tree = proto_item_add_subtree(ti, ett_fp_crcis);

    }

    /* CRCIs */

    for (n=0; n < num_tbs; n++) {

        int bit = (tvb_get_uint8(tvb, offset+(n/8)) >> (7-(n%8))) & 0x01;

        proto_tree_add_item(crcis_tree, hf_fp_crci[n%8], tvb, offset+(n/8),

                            1, ENC_BIG_ENDIAN);

        if (bit == 1) {

            errors++;

            expert_add_info(pinfo, ti, &ei_fp_crci_error_bit_set_for_tb);

        }

    }

    if (tree) {

        /* Highlight range of bytes covered by indicator bits */

        proto_item_set_len(ti, (num_tbs+7) / 8);

        /* Show error count in root text */

        proto_item_append_text(ti, " (%u errors)", errors);

    }

    offset += ((num_tbs+7) / 8);

    return offset;

}

static void

dissect_spare_extension_and_crc(tvbuff_t *tvb, packet_info *pinfo,

                                proto_tree *tree, uint8_t dch_crc_present,

                                unsigned offset, unsigned header_length)

{

    int         crc_size = 0;

    int         remain   = tvb_reported_length_remaining(tvb, offset);

    /* Payload CRC (optional) */

    if ((dch_crc_present == 1) || ((dch_crc_present == 2) && (remain >= 2))) {

        crc_size = 2;

    }

    if (remain > crc_size) {

        proto_item *ti;

        ti = proto_tree_add_item(tree, hf_fp_spare_extension, tvb,

                                 offset, remain-crc_size, ENC_NA);