/* packet-rdt.c

 *

 * Routines for RDT dissection

 * RDT = Real Data Transport

 *

 * Copyright 2005

 * Written by Martin Mathieson and Tom Marshall

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

/* Information sources:

 * helixcommunity.org sources, in particular

 * server/protocol/transport/rdt/pub/tngpkt.pm

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/conversation.h>

#include <epan/prefs.h>

#include <epan/proto_data.h>

#include "packet-rdt.h"

static dissector_handle_t rdt_handle;

static int     proto_rdt;

/* Packet fields */

static int     hf_rdt_packet;

/* flags1: shared */

static int     hf_rdt_len_included;

/* flags1: data packet */

static int     hf_rdt_data_flags1;

static int     hf_rdt_data_need_reliable;

static int     hf_rdt_data_stream_id;

static int     hf_rdt_data_is_reliable;

/* flags2: data packet */

static int     hf_rdt_data_flags2;

static int     hf_rdt_data_backtoback;

static int     hf_rdt_data_slowdata;

static int     hf_rdt_data_asmrule;

/* flags1: asm action packet */

static int     hf_rdt_aact_flags;

static int     hf_rdt_aact_stream_id;

/* flags1: ack packet */

static int     hf_rdt_ack_flags;

static int     hf_rdt_ack_lost_high;

/* flags1: latency report packet */

static int     hf_rdt_latency_report_flags;

/* flags1: bandwidth report packet */

static int     hf_rdt_bandwidth_report_flags;

/* flags1: stream end packet */

static int     hf_rdt_stre_flags;

static int     hf_rdt_stre_need_reliable;

static int     hf_rdt_stre_stream_id;

static int     hf_rdt_stre_packet_sent;

static int     hf_rdt_stre_ext_flag;

/* static int     hf_rdt_rtt_request_flags; */

/* static int     hf_rdt_rtt_response_flags; */

/* static int     hf_rdt_congestion_flags; */

static int     hf_rdt_report_flags;

/* static int     hf_rdt_tirq_flags; */

static int     hf_rdt_tirp_flags;

static int     hf_rdt_bw_probing_flags;

/* Octets 1-2: sequence number or packet type */

static int     hf_rdt_sequence_number;

static int     hf_rdt_packet_type;

/* Only present if length_included */

static int     hf_rdt_packet_length;

/* General shared fields */

static int     hf_rdt_timestamp;

static int     hf_rdt_stream_id_ex;

static int     hf_rdt_asmrule_ex;

static int     hf_rdt_total_reliable;

static int     hf_rdt_data;

/* Special use fields */

static int     hf_rdt_aact_reliable_seqno;

static int     hf_rdt_brpt_interval;

static int     hf_rdt_brpt_bandwidth;

static int     hf_rdt_brpt_sequence;

static int     hf_rdt_rtrp_ts_sec;

static int     hf_rdt_rtrp_ts_usec;

static int     hf_rdt_cong_xmit_mult;

static int     hf_rdt_cong_recv_mult;

static int     hf_rdt_stre_seqno;

static int     hf_rdt_stre_dummy_flags1;

static int     hf_rdt_stre_dummy_type;

static int     hf_rdt_stre_reason_code;

static int     hf_rdt_lrpt_server_out_time;

static int     hf_rdt_tirq_request_rtt_info;

static int     hf_rdt_tirq_request_buffer_info;

static int     hf_rdt_tirq_request_time_msec;

static int     hf_rdt_tirp_has_rtt_info;

static int     hf_rdt_tirp_is_delayed;

static int     hf_rdt_tirp_has_buffer_info;

static int     hf_rdt_tirp_request_time_msec;

static int     hf_rdt_tirp_response_time_msec;

static int     hf_rdt_tirp_buffer_info;

static int     hf_rdt_tirp_buffer_info_count;

static int     hf_rdt_tirp_buffer_info_stream_id;

static int     hf_rdt_tirp_buffer_info_lowest_timestamp;

static int     hf_rdt_tirp_buffer_info_highest_timestamp;

static int     hf_rdt_tirp_buffer_info_bytes_buffered;

static int     hf_rdt_bwpp_seqno;

static int     hf_rdt_unk_flags1;

/* RDT setup fields */

static int     hf_rdt_setup;

static int     hf_rdt_setup_frame;

static int     hf_rdt_setup_method;

static int     hf_rdt_feature_level;

/* RDT fields defining a sub tree */

static int     ett_rdt;

static int     ett_rdt_packet;

static int     ett_rdt_setup;

static int     ett_rdt_data_flags1;

static int     ett_rdt_data_flags2;

static int     ett_rdt_aact_flags;

static int     ett_rdt_ack_flags;

static int     ett_rdt_latency_report_flags;

static int     ett_rdt_bandwidth_report_flags;

static int     ett_rdt_stre_flags;

static int     ett_rdt_rtt_request_flags;

static int     ett_rdt_rtt_response_flags;

static int     ett_rdt_congestion_flags;

static int     ett_rdt_report_flags;

static int     ett_rdt_tirq_flags;

static int     ett_rdt_tirp_flags;

static int     ett_rdt_tirp_buffer_info;

static int     ett_rdt_bw_probing_flags;

static expert_field ei_rdt_packet_length;

#define RDT_UDP_PORT        6970

void proto_register_rdt(void);

void proto_reg_handoff_rdt(void);

/* Parse individual packet types */

static unsigned dissect_rdt_data_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_asm_action_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_bandwidth_report_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_ack_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_rtt_request_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_rtt_response_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_congestion_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_stream_end_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_report_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_latency_report_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_transport_info_request_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_transport_info_response_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_bw_probing_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static unsigned dissect_rdt_unknown_control(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset);

static void show_setup_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);

/* Preferences bool to control whether or not setup info should be shown */

static bool global_rdt_show_setup_info = true;

/* Packet types */

#define RDT_ASMACTIION_PACKET               0xff00

#define RDT_BANDWIDTHREPORT_PACKET          0xff01

#define RDT_ACK_PACKET                      0xff02

#define RDT_RTTREQUEST_PACKET               0xff03

#define RDT_RTTRESPONSE_PACKET              0xff04

#define RDT_CONGESTION_PACKET               0xff05

#define RDT_STREAMEND_PACKET                0xff06

#define RDT_REPORT_PACKET                   0xff07

#define RDT_LATENCYREPORT_PACKET            0xff08

#define RDT_TRANSPORTINFO_PACKET            0xff09

#define RDT_TRANSPORTINFORESPONSE_PACKET    0xff0a

#define RDT_BWPROBING_PACKET                0xff0b

static const value_string packet_type_vals[] =

{

    { RDT_ASMACTIION_PACKET,             "Asm action"  },

    { RDT_BANDWIDTHREPORT_PACKET,        "Bandwidth report"  },

    { RDT_ACK_PACKET,                    "Ack"  },

    { RDT_RTTREQUEST_PACKET,             "RTT request"  },

    { RDT_RTTRESPONSE_PACKET,            "RTT response"  },

    { RDT_CONGESTION_PACKET,             "Congestion"  },

    { RDT_STREAMEND_PACKET,              "Stream end" },

    { RDT_REPORT_PACKET,                 "Report" },

    { RDT_LATENCYREPORT_PACKET,          "Latency report" },

    { RDT_TRANSPORTINFO_PACKET,          "Transport info" },

    { RDT_TRANSPORTINFORESPONSE_PACKET,  "Transport info response" },

    { RDT_BWPROBING_PACKET,              "BW probing" },

    { 0, NULL }

};

/* Set up an RDT conversation */

void rdt_add_address(packet_info *pinfo,

                     address *addr, int port,

                     int other_port,

                     const char *setup_method,

                     int   rdt_feature_level)

{

    address null_addr;

    conversation_t* p_conv;

    struct _rdt_conversation_info *p_conv_data;

    /* If this isn't the first time this packet has been processed,

       we've already done this work, so we don't need to do it

      again. */

    if (pinfo->fd->visited)

    {

        return;

    }

    clear_address(&null_addr);

    /* Check if the ip address and port combination is not already registered

       as a conversation. */

    p_conv = find_conversation(pinfo->num, addr, &null_addr, CONVERSATION_UDP, port, other_port,

                               NO_ADDR_B | (!other_port ? NO_PORT_B : 0));

    /* If not, create a new conversation. */

    if ( !p_conv || p_conv->setup_frame != pinfo->num)

    {

        p_conv = conversation_new(pinfo->num, addr, &null_addr, CONVERSATION_UDP,

                                  (uint32_t)port, (uint32_t)other_port,

                                  NO_ADDR2 | (!other_port ? NO_PORT2 : 0));

    }

    /* Set dissector */

    conversation_set_dissector(p_conv, rdt_handle);

    /* Check if the conversation has data associated with it. */

    p_conv_data = (struct _rdt_conversation_info *)conversation_get_proto_data(p_conv, proto_rdt);

    /* If not, add a new data item. */

    if (!p_conv_data)

    {

        /* Create conversation data */

        p_conv_data = wmem_new(wmem_file_scope(), struct _rdt_conversation_info);

        conversation_add_proto_data(p_conv, proto_rdt, p_conv_data);

    }

    /* Update the conversation data. */

    (void) g_strlcpy(p_conv_data->method, setup_method, MAX_RDT_SETUP_METHOD_SIZE);

    p_conv_data->frame_number = pinfo->num;

    p_conv_data->feature_level = rdt_feature_level;

}

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

/* Main dissection function                                                 */

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

static int dissect_rdt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)

{

    unsigned    previous_offset = 0;

    int         offset = 0;

    proto_item  *ti;

    proto_tree  *rdt_tree = NULL;

    proto_tree  *rdt_packet_tree;

    uint16_t    packet_type;

    /* Set/clear columns */

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "RDT");

    col_clear(pinfo->cinfo, COL_INFO);

    /* Create RDT protocol tree */

    ti = proto_tree_add_item(tree, proto_rdt, tvb, offset, -1, ENC_NA);

    rdt_tree = proto_item_add_subtree(ti, ett_rdt);

    /* Conversation setup info */

    if (global_rdt_show_setup_info)

    {

        show_setup_info(tvb, pinfo, rdt_tree);

    }

    /* Parse all RDT packets found in the frame */

    while (offset != -1 && tvb_reported_length_remaining(tvb, offset))

    {

        /* Every packet type should have at least 3 bytes */

        tvb_ensure_bytes_exist(tvb, offset, 3);

        /* 2nd & 3rd bytes determine packet type */

        packet_type = tvb_get_ntohs(tvb, offset+1);

        /* Add a tree for the next individual packet */

        ti =  proto_tree_add_string_format(rdt_tree, hf_rdt_packet, tvb, offset, -1,

                                           "",

                                           "RDT packet (%s)",

                                           packet_type < 0xff00 ? "Data" :

                                               val_to_str_const(packet_type, packet_type_vals, "Unknown"));

        rdt_packet_tree = proto_item_add_subtree(ti, ett_rdt_packet);

        /* Dissect the details of the next packet in this frame */

        if (packet_type < 0xff00)

        {

            offset = dissect_rdt_data_packet(tvb, pinfo, rdt_packet_tree, offset);

        }

        else

        {

            switch (packet_type)

            {

            case RDT_ASMACTIION_PACKET:

                offset = dissect_rdt_asm_action_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_BANDWIDTHREPORT_PACKET:

                offset = dissect_rdt_bandwidth_report_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_ACK_PACKET:

                offset = dissect_rdt_ack_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_RTTREQUEST_PACKET:

                offset = dissect_rdt_rtt_request_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_RTTRESPONSE_PACKET:

                offset = dissect_rdt_rtt_response_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_CONGESTION_PACKET:

                offset = dissect_rdt_congestion_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_STREAMEND_PACKET:

                offset = dissect_rdt_stream_end_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_REPORT_PACKET:

                offset = dissect_rdt_report_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_LATENCYREPORT_PACKET:

                offset = dissect_rdt_latency_report_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_TRANSPORTINFO_PACKET:

                offset = dissect_rdt_transport_info_request_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_TRANSPORTINFORESPONSE_PACKET:

                offset = dissect_rdt_transport_info_response_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            case RDT_BWPROBING_PACKET:

                offset = dissect_rdt_bw_probing_packet(tvb, pinfo, rdt_packet_tree, offset);

                break;

            default:

                /* Unknown control packet */

                offset = dissect_rdt_unknown_control(tvb, pinfo, rdt_packet_tree, offset);

                break;

            }

        }

        /* Select correct number of bytes for the tree showing this packet */

        if (offset != -1)

        {

            proto_item_set_len(rdt_packet_tree, offset-previous_offset);

        }

        previous_offset = offset;

    }

    return tvb_captured_length(tvb);

}

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

/* Functions to dissect individual packet types */

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

/* Dissect a data packet */

unsigned dissect_rdt_data_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    unsigned    start_offset = offset;

    uint16_t    packet_length;

    uint8_t     flags1;

    uint8_t     length_included_flag;

    uint8_t     need_reliable_flag;

    uint16_t    stream_id;

    uint16_t    sequence_number;

    uint8_t     is_reliable_flag;

    uint8_t     flags2;

    uint32_t    timestamp;

    uint16_t    asm_rule_number;

    uint8_t     back_to_back;

    uint8_t     slow_data;

    proto_tree  *flags_tree1;

    proto_tree  *flags_tree2;

    proto_item  *ti;

    /* Flags in first byte */

    flags1 = tvb_get_uint8(tvb, offset);

    length_included_flag = (flags1 & 0x80) >> 7;

    need_reliable_flag = (flags1 & 0x40) >> 6;

    stream_id = (flags1 & 0x3e) >> 1;

    is_reliable_flag = flags1 & 0x01;

    /* Create subtree for flags1 fields */

    ti =  proto_tree_add_string_format(tree, hf_rdt_data_flags1, tvb, offset, 1,

            "",

            "Length-included=%u, need-reliable=%u, stream-id=%u, is-reliable=%u",

            length_included_flag,

            need_reliable_flag,

            stream_id,

            is_reliable_flag);

    flags_tree1 = proto_item_add_subtree(ti, ett_rdt_data_flags1);

    proto_tree_add_item(flags_tree1, hf_rdt_len_included, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree1, hf_rdt_data_need_reliable, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree1, hf_rdt_data_stream_id, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree1, hf_rdt_data_is_reliable, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Sequence number */

    sequence_number = tvb_get_ntohs(tvb, offset);

    proto_tree_add_item(tree, hf_rdt_sequence_number, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* Length field is optional */

    if (length_included_flag)

    {

        packet_length = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_packet_length, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        /* Check that there are as many bytes as reported */

        tvb_ensure_bytes_exist(tvb, start_offset, packet_length);

    }

    else

    {

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    /* More flags */

    flags2 = tvb_get_uint8(tvb, offset);

    back_to_back = (flags2 & 0x80) >> 7;

    slow_data = (flags2 & 0x40) >> 6;

    asm_rule_number = flags2 & 0x3f;

    /* Create subtree for flags2 fields */

    ti =  proto_tree_add_string_format(tree, hf_rdt_data_flags2, tvb, offset, 1,

            "",

            "Back-to-back=%u, slow-data=%u, asm-rule=%u",

            back_to_back,

            slow_data,

            asm_rule_number);

    /* Create subtree for flags and add fields */

    flags_tree2 = proto_item_add_subtree(ti, ett_rdt_data_flags2);

    proto_tree_add_item(flags_tree2, hf_rdt_data_backtoback, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree2, hf_rdt_data_slowdata, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree2, hf_rdt_data_asmrule, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Timestamp */

    timestamp = tvb_get_ntohl(tvb, offset);

    proto_tree_add_item(tree, hf_rdt_timestamp, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    /* Stream ID expansion */

    if (stream_id == 31)

    {

        stream_id = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_stream_id_ex, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

    }

    /* Total reliable */

    if (need_reliable_flag)

    {

        proto_tree_add_item(tree, hf_rdt_total_reliable, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

    }

    /* Asm rule number */

    if (asm_rule_number == 63)

    {

        asm_rule_number = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_asmrule_ex, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

    }

    col_append_fstr(pinfo->cinfo, COL_INFO,

                    "DATA: stream-id=%02u asm-rule=%02u seq=%05u ts=%05u  ",

                    stream_id, asm_rule_number, sequence_number, timestamp);

    /* The remaining data is unparsed. */

    proto_tree_add_item(tree, hf_rdt_data, tvb, offset, -1, ENC_NA);

    offset += tvb_captured_length_remaining(tvb, offset);

    if (packet_length < (offset - start_offset) ||

        packet_length > tvb_reported_length_remaining(tvb, start_offset))

    {

        proto_tree_add_expert(tree, pinfo, &ei_rdt_packet_length, tvb, 0, 0);

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    return start_offset + packet_length;

}

/* Dissect an asm-action packet */

unsigned dissect_rdt_asm_action_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    unsigned    start_offset = offset;

    uint16_t    packet_length;

    uint8_t     flags1;

    uint8_t     length_included_flag;

    uint16_t    stream_id;

    uint16_t    rel_seqno;

    proto_tree  *flags_tree;

    proto_item  *ti;

    /* Flags in first byte */

    flags1 = tvb_get_uint8(tvb, offset);

    length_included_flag = (flags1 & 0x80) >> 7;

    stream_id = (flags1 & 0x7c) >> 2;

    /* Create subtree for flags fields */

    proto_tree_add_item(tree, proto_rdt, tvb, offset, -1, ENC_NA);

    ti =  proto_tree_add_string_format(tree, hf_rdt_aact_flags, tvb, offset, 1,

            "",

            "Length-included=%u, stream_id=%u",

            length_included_flag,

            stream_id);

    flags_tree = proto_item_add_subtree(ti, ett_rdt_aact_flags);

    proto_tree_add_item(flags_tree, hf_rdt_len_included, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree, hf_rdt_aact_stream_id, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    rel_seqno = tvb_get_ntohs(tvb, offset);

    proto_tree_add_item(tree, hf_rdt_aact_reliable_seqno, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* Length field is optional */

    if (length_included_flag)

    {

        packet_length = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_packet_length, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        /* Check that there are as many bytes as reported */

        tvb_ensure_bytes_exist(tvb, start_offset, packet_length);

    }

    else

    {

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    /* Stream ID expansion */

    if (stream_id == 31)

    {

        stream_id = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_stream_id_ex, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

    }

    col_append_fstr(pinfo->cinfo, COL_INFO,

                    "ASM-ACTION: stream-id=%02u rel-seqno=%05u  ",

                    stream_id, rel_seqno);

    /* The remaining data is unparsed. */

    proto_tree_add_item(tree, hf_rdt_data, tvb, offset, -1, ENC_NA);

    if (packet_length < (offset - start_offset) ||

        packet_length > tvb_reported_length_remaining(tvb, start_offset))

    {

        proto_tree_add_expert(tree, pinfo, &ei_rdt_packet_length, tvb, 0, 0);

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    return start_offset + packet_length;

}

/* Dissect an bandwidth-report packet */

unsigned dissect_rdt_bandwidth_report_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    unsigned    start_offset = offset;

    uint16_t    packet_length;

    uint8_t     flags1;

    uint8_t     length_included_flag;

    proto_tree  *flags_tree;

    proto_item  *ti;

    /* Flags in first byte */

    flags1 = tvb_get_uint8(tvb, offset);

    length_included_flag = (flags1 & 0x80) >> 7;

    /* Create subtree for flags fields */

    ti =  proto_tree_add_string_format(tree, hf_rdt_bandwidth_report_flags, tvb, offset, 1,

            "",

            "Length-included=%u",

            length_included_flag);

    flags_tree = proto_item_add_subtree(ti, ett_rdt_bandwidth_report_flags);

    proto_tree_add_item(flags_tree, hf_rdt_len_included, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* Length field is optional */

    if (length_included_flag)

    {

        packet_length = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_packet_length, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        /* Check that there are as many bytes as reported */

        tvb_ensure_bytes_exist(tvb, start_offset, packet_length);

    }

    else

    {

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    proto_tree_add_item(tree, hf_rdt_brpt_interval, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    proto_tree_add_item(tree, hf_rdt_brpt_bandwidth, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    proto_tree_add_item(tree, hf_rdt_brpt_sequence, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    col_append_str(pinfo->cinfo, COL_INFO, "BANDWIDTH-REPORT:  ");

    if (packet_length < (offset - start_offset) ||

        packet_length > tvb_reported_length_remaining(tvb, start_offset))

    {

        proto_tree_add_expert(tree, pinfo, &ei_rdt_packet_length, tvb, 0, 0);

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    return start_offset + packet_length;

}

/* Dissect an ack packet */

unsigned dissect_rdt_ack_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    unsigned    start_offset = offset;

    uint16_t    packet_length;

    uint8_t     flags1;

    uint8_t     length_included_flag;

    uint8_t     lost_high_flag;

    proto_tree  *flags_tree;

    proto_item  *ti;

    /* Flags in first byte */

    flags1 = tvb_get_uint8(tvb, offset);

    length_included_flag = (flags1 & 0x80) >> 7;

    lost_high_flag = (flags1 & 0x40) >> 6;

    /* Create subtree for flags fields */

    ti =  proto_tree_add_string_format(tree, hf_rdt_ack_flags, tvb, offset, 1,

            "",

            "Length-included=%u, lost-high=%u",

            length_included_flag,

            lost_high_flag);

    flags_tree = proto_item_add_subtree(ti, ett_rdt_ack_flags);

    proto_tree_add_item(flags_tree, hf_rdt_len_included, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree, hf_rdt_ack_lost_high, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* Length field is optional */

    if (length_included_flag)

    {

        packet_length = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_packet_length, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        /* Check that there are as many bytes as reported */

        tvb_ensure_bytes_exist(tvb, start_offset, packet_length);

    }

    else

    {

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    /* XXX: The remaining data is unparsed. */

    proto_tree_add_item(tree, hf_rdt_data, tvb, offset, -1, ENC_NA);

    col_append_fstr(pinfo->cinfo, COL_INFO, "ACK: lh=%u  ", lost_high_flag);

    if (packet_length < (offset - start_offset) ||

        packet_length > tvb_reported_length_remaining(tvb, start_offset))

    {

        proto_tree_add_expert(tree, pinfo, &ei_rdt_packet_length, tvb, 0, 0);

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    return start_offset + packet_length;

}

/* Dissect an att-request packet */

unsigned dissect_rdt_rtt_request_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    /* Flags in first byte */

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    col_append_str(pinfo->cinfo, COL_INFO, "RTT-REQUEST:  ");

    return offset;

}

/* Dissect an att-response packet */

unsigned dissect_rdt_rtt_response_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    /* Flags in first byte */

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    proto_tree_add_item(tree, hf_rdt_rtrp_ts_sec, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    proto_tree_add_item(tree, hf_rdt_rtrp_ts_usec, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    col_append_str(pinfo->cinfo, COL_INFO, "RTT-RESPONSE:  ");

    return offset;

}

/* Dissect an congestion packet */

unsigned dissect_rdt_congestion_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    /* Flags in first byte */

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    proto_tree_add_item(tree, hf_rdt_cong_xmit_mult, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    proto_tree_add_item(tree, hf_rdt_cong_recv_mult, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    col_append_str(pinfo->cinfo, COL_INFO, "CONGESTION:  ");

    return offset;

}

/* Dissect an stream-end packet */

unsigned dissect_rdt_stream_end_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    uint8_t     flags1;

    uint8_t     need_reliable;

    uint16_t    stream_id;

    uint8_t     packet_sent;

    uint8_t     ext_flag;

    proto_tree  *flags_tree;

    proto_item  *ti;

    /* Flags in first byte */

    flags1 = tvb_get_uint8(tvb, offset);

    need_reliable = (flags1 & 0x80) >> 7;

    stream_id = (flags1 & 0x7c) >> 2;

    packet_sent = (flags1 & 0x2) >> 1;

    ext_flag = flags1 & 0x1;

    /* Create subtree for flags fields */

    ti =  proto_tree_add_string_format(tree, hf_rdt_stre_flags, tvb, offset, 1,

            "",

            "Need-reliable=%u, stream-id=%u, packet-sent=%u, ext-flag=%u",

            need_reliable,

            stream_id,

            packet_sent,

            ext_flag);

    flags_tree = proto_item_add_subtree(ti, ett_rdt_stre_flags);

    proto_tree_add_item(flags_tree, hf_rdt_stre_need_reliable, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree, hf_rdt_stre_stream_id, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree, hf_rdt_stre_packet_sent, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree, hf_rdt_stre_ext_flag, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    proto_tree_add_item(tree, hf_rdt_stre_seqno, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    proto_tree_add_item(tree, hf_rdt_timestamp, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    /* Stream ID expansion */

    if (stream_id == 31)

    {

        stream_id = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_stream_id_ex, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

    }

    /* Total reliable */

    if (need_reliable)

    {

        proto_tree_add_item(tree, hf_rdt_total_reliable, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

    }

    if (ext_flag)

    {

        proto_tree_add_item(tree, hf_rdt_stre_dummy_flags1, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        proto_tree_add_item(tree, hf_rdt_stre_dummy_type, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item(tree, hf_rdt_stre_reason_code, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        /* XXX: Remainder is reason_text */

        offset += tvb_captured_length_remaining(tvb, offset);

    }

    col_append_fstr(pinfo->cinfo, COL_INFO, "STREAM-END: stream-id=%02u  ", stream_id);

    return offset;

}

/* Dissect an report packet */

unsigned dissect_rdt_report_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    unsigned    start_offset = offset;

    uint16_t    packet_length;

    uint8_t     flags1;

    uint8_t     length_included_flag;

    proto_tree  *flags_tree;

    proto_item  *ti;

    /* Flags in first byte */

    flags1 = tvb_get_uint8(tvb, offset);

    length_included_flag = (flags1 & 0x80) >> 7;

    /* Create subtree for flags fields */

    ti =  proto_tree_add_string_format(tree, hf_rdt_report_flags, tvb, offset, 1,

            "",

            "Length-included=%u",

            length_included_flag);

    flags_tree = proto_item_add_subtree(ti, ett_rdt_report_flags);

    proto_tree_add_item(flags_tree, hf_rdt_len_included, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* Length field is optional */

    if (length_included_flag)

    {

        packet_length = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_packet_length, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        /* Check that there are as many bytes as reported */

        tvb_ensure_bytes_exist(tvb, start_offset, packet_length);

    }

    else

    {

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    col_append_str(pinfo->cinfo, COL_INFO, "REPORT:  ");

    /* The remaining data is unparsed. */

    proto_tree_add_item(tree, hf_rdt_data, tvb, offset, -1, ENC_NA);

    if (packet_length < (offset - start_offset) ||

        packet_length > tvb_reported_length_remaining(tvb, start_offset))

    {

        proto_tree_add_expert(tree, pinfo, &ei_rdt_packet_length, tvb, 0, 0);

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    return start_offset + packet_length;

}

/* Dissect an latency-report packet */

unsigned dissect_rdt_latency_report_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    unsigned    start_offset = offset;

    uint16_t    packet_length;

    uint8_t     flags1;

    uint8_t     length_included_flag;

    uint32_t    server_out_time;

    proto_tree  *flags_tree;

    proto_item  *ti;

    /* Flags in first byte */

    flags1 = tvb_get_uint8(tvb, offset);

    length_included_flag = (flags1 & 0x80) >> 7;

    /* Create subtree for flags fields */

    ti =  proto_tree_add_string_format(tree, hf_rdt_latency_report_flags, tvb, offset, 1,

            "",

            "Length-included=%u",

            length_included_flag);

    flags_tree = proto_item_add_subtree(ti, ett_rdt_latency_report_flags);

    proto_tree_add_item(flags_tree, hf_rdt_len_included, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* Length field is optional */

    if (length_included_flag)

    {

        packet_length = tvb_get_ntohs(tvb, offset);

        proto_tree_add_item(tree, hf_rdt_packet_length, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        /* Check that there are as many bytes as reported */

        tvb_ensure_bytes_exist(tvb, start_offset, packet_length);

    }

    else

    {

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    server_out_time = tvb_get_ntohl(tvb, offset);

    proto_tree_add_item(tree, hf_rdt_lrpt_server_out_time, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    col_append_fstr(pinfo->cinfo, COL_INFO, "LATENCY-REPORT: t=%u  ", server_out_time);

    if (packet_length < (offset - start_offset) ||

        packet_length > tvb_reported_length_remaining(tvb, start_offset))

    {

        proto_tree_add_expert(tree, pinfo, &ei_rdt_packet_length, tvb, 0, 0);

        packet_length = tvb_captured_length_remaining(tvb, start_offset);

    }

    return start_offset + packet_length;

}

/* Dissect a transport-info packet */

unsigned dissect_rdt_transport_info_request_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset)

{

    uint8_t     flags1;

    uint8_t     request_rtt_info_flag;

    uint8_t     request_buffer_info_flag;

    proto_tree  *flags_tree;

    proto_item  *ti;

    /* Flags in first byte */

    flags1 = tvb_get_uint8(tvb, offset);

    request_rtt_info_flag = (flags1 & 0x2) >> 1;

    request_buffer_info_flag = (flags1 & 0x01);

    /* Create subtree for flags fields */

    ti =  proto_tree_add_string_format(tree, hf_rdt_ack_flags, tvb, offset, 1,

            "",

            "Request-rtt-info=%u, request-buffer-info=%u",

            request_rtt_info_flag,

            request_buffer_info_flag);

    flags_tree = proto_item_add_subtree(ti, ett_rdt_tirq_flags);

    proto_tree_add_item(flags_tree, hf_rdt_tirq_request_rtt_info, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(flags_tree, hf_rdt_tirq_request_buffer_info, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    /* Packet type */

    proto_tree_add_item(tree, hf_rdt_packet_type, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    if (request_rtt_info_flag)

    {

        proto_tree_add_item(tree, hf_rdt_tirq_request_time_msec, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

    }

    col_append_str(pinfo->cinfo, COL_INFO, "TRANSPORT-INFO-REQUEST:  ");

    return offset;