/* packet-sdp.c

 * Routines for SDP packet disassembly (RFC 2327)

 *

 * Jason Lango <jal@netapp.com>

 * Liberally copied from packet-http.c, by Guy Harris <guy@alum.mit.edu>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 * Ref https://www.ietf.org/rfc/rfc4566

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/asn1.h>

#include <epan/prefs.h>

#include <epan/expert.h>

#include <epan/tap.h>

#include <epan/show_exception.h>

#include <epan/addr_resolv.h>

#include <epan/conversation.h>

#include <epan/proto_data.h>

#include <epan/strutil.h>

#include <wsutil/strtoi.h>

#include <wsutil/str_util.h>

#include <wsutil/array.h>

#include "packet-media-type.h"

#include "packet-sdp.h"

#include "packet-http.h"

/* un-comment the following as well as this line in conversation.c, to enable debug printing */

/* #define DEBUG_CONVERSATION */

#include "conversation_debug.h"

#include "packet-gsm_osmux.h"

#include "packet-rtp.h"

#include "packet-rtp_pt.h"

#include "packet-rtcp.h"

#include "packet-t38.h"

#include "packet-msrp.h"

#include "packet-sprt.h"

#include "packet-bfcp.h"

#include "packet-h245.h"

#include "packet-h264.h"

#include "packet-h265.h"

#include "packet-mp4ves.h"

void proto_register_sdp(void);

void proto_reg_handoff_sdp(void);

static dissector_handle_t sdp_handle;

static dissector_handle_t rtcp_handle;

static dissector_handle_t sprt_handle;

static dissector_handle_t msrp_handle;

static dissector_handle_t bfcp_handle;

static dissector_handle_t h264_handle;

static dissector_handle_t h265_handle;

static dissector_handle_t mp4ves_config_handle;

static int sdp_tap;

static int proto_sdp;

static int proto_sprt;

static const char* UNKNOWN_ENCODING = "Unknown";

static wmem_tree_t *sdp_transport_reqs;

static wmem_tree_t *sdp_transport_rsps;

static wmem_map_t *sdp_rtsp_control_map;

/* preference globals */

static bool global_sdp_establish_conversation = true;

/* Top level fields */

static int hf_protocol_version;

static int hf_owner;

static int hf_session_name;

static int hf_session_info;

static int hf_uri;

static int hf_email;

static int hf_phone;

static int hf_connection_info;

static int hf_bandwidth;

static int hf_timezone;

static int hf_encryption_key;

static int hf_session_attribute;

static int hf_media_attribute;

static int hf_time;

static int hf_repeat_time;

static int hf_media;

static int hf_media_title;

static int hf_unknown;

static int hf_invalid;

static int hf_ipbcp_version;

static int hf_ipbcp_type;

/* hf_owner subfields*/

static int hf_owner_username;

static int hf_owner_sessionid;

static int hf_owner_version;

static int hf_owner_network_type;

static int hf_owner_address_type;

static int hf_owner_address;

/* hf_connection_info subfields */

static int hf_connection_info_network_type;

static int hf_connection_info_address_type;

static int hf_connection_info_connection_address;

static int hf_connection_info_ttl;

static int hf_connection_info_num_addr;

/* hf_bandwidth subfields */

static int hf_bandwidth_modifier;

static int hf_bandwidth_value;

/* hf_time subfields */

static int hf_time_start;

static int hf_time_stop;

/* hf_repeat_time subfield */

static int hf_repeat_time_interval;

static int hf_repeat_time_duration;

static int hf_repeat_time_offset;

/* hf_timezone subfields */

static int hf_timezone_time;

static int hf_timezone_offset;

/* hf_encryption_key subfields */

static int hf_encryption_key_type;

static int hf_encryption_key_data;

/* hf_session_attribute subfields */

static int hf_session_attribute_field;

static int hf_session_attribute_value;

/* hf_media subfields */

static int hf_media_media;

static int hf_media_port;

static int hf_media_port_string;

static int hf_media_portcount;

static int hf_media_proto;

static int hf_media_format;

/* hf_session_attribute subfields */

static int hf_media_attribute_field;

static int hf_media_attribute_value;

static int hf_media_encoding_name;

static int hf_media_sample_rate;

static int hf_media_channels;

static int hf_media_format_specific_parameter;

static int hf_sdp_fmtp_mpeg4_profile_level_id;

static int hf_sdp_fmtp_h263_profile;

static int hf_sdp_fmtp_h263_level;

static int hf_sdp_h264_packetization_mode;

static int hf_SDPh223LogicalChannelParameters;

/* hf_session_attribute hf_media_attribute subfields */

static int hf_key_mgmt_att_value;

static int hf_key_mgmt_prtcl_id;

static int hf_key_mgmt_data;

static int hf_sdp_crypto_tag;

static int hf_sdp_crypto_crypto_suite;

static int hf_sdp_crypto_master_key;

static int hf_sdp_crypto_master_salt;

static int hf_sdp_crypto_lifetime;

static int hf_sdp_crypto_mki;

static int hf_sdp_crypto_mki_length;

/* a=candidate subfields */

static int hf_ice_candidate_foundation;

static int hf_ice_candidate_componentid;

static int hf_ice_candidate_transport;

static int hf_ice_candidate_priority;

static int hf_ice_candidate_address;

static int hf_ice_candidate_port;

static int hf_ice_candidate_type;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_sdp_nal_unit_2_string;

static int hf_sdp_key_and_salt;

static int hf_sdp_nal_unit_1_string;

static int hf_sdp_data;

/* trees */

static int ett_sdp;

static int ett_sdp_owner;

static int ett_sdp_connection_info;

static int ett_sdp_bandwidth;

static int ett_sdp_time;

static int ett_sdp_repeat_time;

static int ett_sdp_timezone;

static int ett_sdp_encryption_key;

static int ett_sdp_session_attribute;

static int ett_sdp_media;

static int ett_sdp_media_attribute;

static int ett_sdp_fmtp;

static int ett_sdp_key_mgmt;

static int ett_sdp_crypto_key_parameters;

static expert_field ei_sdp_invalid_key_param;

static expert_field ei_sdp_invalid_line_equal;

static expert_field ei_sdp_invalid_line_fields;

static expert_field ei_sdp_invalid_line_space;

static expert_field ei_sdp_invalid_conversion;

static expert_field ei_sdp_invalid_media_port;

static expert_field ei_sdp_invalid_sample_rate;

static expert_field ei_sdp_invalid_channels;

static expert_field ei_sdp_invalid_media_format;

static expert_field ei_sdp_invalid_crypto_tag;

static expert_field ei_sdp_invalid_crypto_mki_length;

/* patterns used for tvb_ws_mempbrk_pattern_uint8 */

static ws_mempbrk_pattern pbrk_digits;

static ws_mempbrk_pattern pbrk_alpha;

typedef enum {

    SDP_PROTO_UNKNOWN = 0,

    SDP_PROTO_RTP,

    SDP_PROTO_SRTP,

    SDP_PROTO_T38,

    SDP_PROTO_MSRP,

    SDP_PROTO_SPRT,

    SDP_PROTO_BFCP,

} transport_proto_t;

#define SDP_MAX_RTP_CHANNELS 4

#define SDP_MAX_RTP_PAYLOAD_TYPES 20

#define SDP_NO_OF_PT 128

/*

 * All parameters specific to one media description ("m=").

 */

typedef struct {

    int32_t pt[SDP_MAX_RTP_PAYLOAD_TYPES];

    int8_t pt_count;

    rtp_dyn_payload_t *rtp_dyn_payload;

    bool set_rtp;

} transport_media_pt_t;

/*

 * Store data extracted from one Media Description section of a SDP. Memory is

 * allocated in wmem_file_scope().

 */

typedef struct {

    transport_proto_t proto;    /**< Protocol, parsed from "m=" line. */

    uint32_t media_types;        /**< Whether "m=video" or others */

    bool bundled;           /**< "m=" lines are "bundled", that is, all on same port */

    uint16_t media_port;         /**< Port number, parsed from "m=" line. */

    uint16_t control_port;       /**< Port number, parsed from "a=rtcp" or "a=rtcp-mux" line. */

    address conn_addr;          /**< The address from the "c=" line (default

                                     from session level, possibly overridden at

                                     the media level). */

    char* control_uri;          /**< RTSP media control URI, parsed from "a=control:"

                                     XXX - allowed to default to session level if not

                                     overridden if only one media desc, but this is

                                     not implemented yet. */

    transport_media_pt_t media; /**< Information about payload numbers for this media. */

    /*

     * Media-level only attributes.

     */

    union {

        struct {

            address ipaddr;

            uint16_t port_number;

        } msrp;                 /**< MSRP transport info, parsed from "a=label:" */

    } media_attr;

} media_description_t;

/*

 * Information parsed from one or two (offer/answer) SDPs that is stored in the

 * conversation. The contents are allocated within wmem_file_scope().

 */

typedef struct {

    enum sdp_exchange_type sdp_status;

    char  *encoding_name[SDP_NO_OF_PT];

    unsigned sample_rate[SDP_NO_OF_PT];

    unsigned channels[SDP_NO_OF_PT];

    /* Data parsed from "m=" */

    wmem_array_t *media_descriptions;   /* array of media_description_t */

    wmem_array_t *sdp_setup_info_list;  /* array of sdp_setup_info_t that refer

                                         * to the same RTP conversation */

    /* SRTP related info XXX note currently we only handle one crypto line in the SDP

    * We should probably handle offer/answer and session updates etc(SIP) quite possibly the whole handling of

    * setting up the RTP conversations should be done by the signaling protocol(s) calling the SDP dissector

    * and the SDP dissector just provide the relevant data.

    * YES! packet-sdp.c should be about SDP parsing... SDP *state* needs to be maintained by upper

    * protocols, because each one has different rules/semantics.

    */

    unsigned  encryption_algorithm;

    unsigned  auth_algorithm;

    unsigned  mki_len;                /* number of octets used for the MKI in the RTP payload */

    unsigned  auth_tag_len;           /* number of octets used for the Auth Tag in the RTP payload */

} transport_info_t;

/*

 * Information about the session description. These are accumulated while

 * parsing the session description and will be applied to the media description.

 * Memory scope can be pinfo->pool since the contents are no longer

 * needed once they are processed into transport_info_t (via

 * complete_descriptions).

 */

typedef struct {

    address conn_addr;         /**< Parsed from "c=" line. */

    rtp_dyn_payload_t *rtp_dyn_payload; /**< Parsed from "a=rtpmap:" line.

                                             Note: wmem_file_scope, needs manual dealloc. */

} session_info_t;

/* Structure for private data to hold ED137 related values */

typedef struct sdp_data_t {

  char *ed137_type;           /* Radio session type */

  char *ed137_txrxmode;       /* Tx/Rx mode */

  char *ed137_fid;            /* Frequency ID */

} sdp_data_t;

/* here lie the debugging dumper functions */

#ifdef DEBUG_CONVERSATION

static void sdp_dump_transport_media(const transport_media_pt_t* media) {

    int i;

    int count;

    DPRINT2(("transport_media contents:"));

    DINDENT();

        if (!media) {

            DPRINT2(("null transport_media_pt_t*"));

            DENDENT();

            return;

        }

        count = (int)media->pt_count;

        DPRINT2(("pt_count=%d",count));

        DINDENT();

            for (i=0; i < count; i++) {

                DPRINT2(("pt=%d", media->pt[i]));

            }

        DENDENT();

        DPRINT2(("rtp_dyn_payload hashtable=%s", media->rtp_dyn_payload ? "YES" : "NO"));

        if (media->rtp_dyn_payload) {

            rtp_dump_dyn_payload(media->rtp_dyn_payload);

        }

        DPRINT2(("set_rtp=%s", media->set_rtp ? "TRUE" : "FALSE"));

    DENDENT();

}

static const value_string sdp_exchange_type_vs[] = {

    { SDP_EXCHANGE_OFFER,         "SDP_EXCHANGE_OFFER" },

    { SDP_EXCHANGE_ANSWER_ACCEPT, "SDP_EXCHANGE_ANSWER_ACCEPT" },

    { SDP_EXCHANGE_ANSWER_REJECT, "SDP_EXCHANGE_ANSWER_REJECT" },

    { 0, NULL }

};

static void sdp_dump_transport_info(packet_info *pinfo, const transport_info_t* info) {

    int i;

    int count;

    DPRINT2(("transport_info contents:"));

    DINDENT();

        if (!info) {

            DPRINT2(("null transport_info_t*"));

            DENDENT();

            return;

        }

        DPRINT2(("sdp_status=%s",

                 val_to_str_const(info->sdp_status, sdp_exchange_type_vs, "SDP_EXCHANGE_UNKNOWN")));

        DPRINT2(("payload type contents:"));

        DINDENT();

            for (i=0; i < SDP_NO_OF_PT; i++) {

                /* don't print out unknown encodings */

                if (info->encoding_name[i] &&

                    strcmp(UNKNOWN_ENCODING,info->encoding_name[i]) != 0) {

                    DPRINT2(("payload type #%d:",i));

                    DINDENT();

                        DPRINT2(("encoding_name=%s", info->encoding_name[i]));

                        DPRINT2(("sample_rate=%d", info->sample_rate[i]));

                    DENDENT();

                }

            }

        DENDENT();

        count = wmem_array_get_count(info->media_descriptions);

        DPRINT2(("media_count=%d", count));

        DPRINT2(("rtp channels:"));

        DINDENT();

            for (i=0; i < count; i++) {

                media_description_t *media_desc = (media_description_t *)wmem_array_index(info->media_descriptions, i);

                DPRINT2(("channel #%d:",i));

                DINDENT();

                    DPRINT2(("conn_addr=%s", address_to_str(pinfo->pool, &(media_desc->conn_addr))));

                    DPRINT2(("media_port=%d", media_desc->media_port));

                    DPRINT2(("proto=%d", media_desc->proto));

                    sdp_dump_transport_media(&(media_desc->media));

                DENDENT();

            }

        DENDENT();

        DPRINT2(("encryption_algorithm=%u", info->encryption_algorithm));

        DPRINT2(("auth_algorithm=%u", info->auth_algorithm));

        if (info->encryption_algorithm || info->auth_algorithm) {

            DPRINT2(("mki_len=%u", info->mki_len));

            if (info->auth_algorithm) {

                DPRINT2(("auth_tag_len=%u", info->auth_tag_len));

            }

        }

    DENDENT();

}

#endif /* DEBUG_CONVERSATION */

/* key-mgmt dissector

 * IANA registry:

 * http://www.iana.org/assignments/sdp-parameters

 */

static dissector_table_t key_mgmt_dissector_table;

/* Finds next token (sequence of non-space chars) in tvb from given offset.

 * The returned value is the token length, or 0 if none found.

 * The offset is changed to be the starting offset, in case there were one or more

 * spaces at the beginning. (this will also add expert info in such a case)

 * The next_offset is set to the next found space after the token, or -1 if the

 * end of line is hit or no token found.

 * If this is the last token in the line, tokenlen will not be 0, but next_offset

 * will be -1.

 *

 * The optional param, if true, means no expert error will be issued if no token

 * is found; if false then a expert error will be issued if no token is found.

 *

 * This function expects to be given a tvb of only one line, and does no error

 * checking of its given arguments.

 */

static inline int

find_next_optional_token_in_line(tvbuff_t *tvb, proto_tree *tree,

                                 int *offset, int *next_offset,

                                 const bool optional)

{

    int tokenlen = 0;

    int next_off = -1;

    int off      = *offset;

    if (tvb_offset_exists(tvb, off)) {

        while (tokenlen == 0) {

            next_off = tvb_find_uint8(tvb, off, -1, ' ');

            if (next_off == -1) {

                tokenlen = tvb_captured_length_remaining(tvb, off);

                break; /* Nothing more left */

            }

            tokenlen = next_off - off;

            if (tokenlen == 0) {

                /* two spaces in a row - illegal, but we'll keep dissecting */

                proto_tree_add_expert(tree, NULL, &ei_sdp_invalid_line_space, tvb, off-1, 2);

                off = next_off + 1;

            }

        }

    }

    if (!optional && tokenlen == 0) {

        proto_tree_add_expert(tree, NULL, &ei_sdp_invalid_line_fields, tvb, 0, -1);

    }

    *next_offset = next_off;

    *offset      = off;

    return tokenlen;

}

/* Same as above, but always issues an expert error if a token is not found. */

static inline int

find_next_token_in_line(tvbuff_t *tvb, proto_tree *tree, int *offset, int *next_offset)

{

    return find_next_optional_token_in_line(tvb, tree, offset, next_offset, false);

}

/* Convert the protocol from the "m=" line to something we understand. */

static transport_proto_t

parse_sdp_media_protocol(const char *media_proto)

{

    /* Sorted according to the "proto" registry at

     * https://www.iana.org/assignments/sdp-parameters/sdp-parameters.xhtml#sdp-parameters-2 */

    const struct {

        const char *proto_name;

        transport_proto_t proto;

    } protocols[] = {

        { "RTP/AVP",            SDP_PROTO_RTP }, /* RFC 4566 */

        { "udptl",              SDP_PROTO_T38 }, /* ITU-T T.38, example in Annex E */

        { "UDPTL",              SDP_PROTO_T38 }, /* Note: IANA registry contains lower case */

        { "RTP/AVPF",           SDP_PROTO_RTP }, /* RFC 4585 */

        { "RTP/SAVP",           SDP_PROTO_SRTP }, /* RFC 3711 */

        { "RTP/SAVPF",          SDP_PROTO_SRTP }, /* RFC 5124 */

        { "UDP/TLS/RTP/SAVP",   SDP_PROTO_SRTP }, /* RFC 5764 */

        { "UDP/TLS/RTP/SAVPF",  SDP_PROTO_SRTP }, /* RFC 5764 */

        { "msrp/tcp",           SDP_PROTO_MSRP }, /* Not in IANA, where is this from? */

        { "UDPSPRT",            SDP_PROTO_SPRT }, /* Not in IANA, but draft-rajeshkumar-avt-v150-registration-00 */

        { "udpsprt",            SDP_PROTO_SPRT }, /* lowercase per section E.1.1 of ITU-T V.150.1 */

        { "udpsprt",            SDP_PROTO_SPRT }, /* lowercase per section E.1.1 of ITU-T V.150.1 */

        { "UDP/BFCP",           SDP_PROTO_BFCP }, /* RFC 8856 */

    };

    for (unsigned i = 0; i < G_N_ELEMENTS(protocols); i++) {

        if (!strcmp(protocols[i].proto_name, media_proto)) {

            return protocols[i].proto;

        }

    }

    return SDP_PROTO_UNKNOWN;

}

/* Parses the parts from "c=" into address structures. */

static void

parse_sdp_connection_address(const char *connection_type, const char *connection_address,

        wmem_allocator_t *allocator, address *conn_addr)

{

    if (strcmp(connection_type, "IP4") == 0) {

        uint32_t ip4_addr;

        if (str_to_ip(connection_address, &ip4_addr)) {

            /* connection_address could be converted to a valid ipv4 address*/

            alloc_address_wmem(allocator, conn_addr, AT_IPv4, 4, &ip4_addr);

        }

    } else if (strcmp(connection_type, "IP6") == 0) {

        ws_in6_addr ip6_addr;

        if (str_to_ip6(connection_address, &ip6_addr)) {

            /* connection_address could be converted to a valid ipv6 address*/

            alloc_address_wmem(allocator, conn_addr, AT_IPv6, 16, &ip6_addr);

        }

    }

}

/**

 * Starts a new media description. If there are too many media descriptions,

 * no new media description is started and NULL is returned.

 */

static media_description_t *

sdp_new_media_description(wmem_array_t *media_descriptions, session_info_t *session_info)

{

    media_description_t empty_desc;

    media_description_t *media_desc;

    /* Limit number to avoid consuming excess memory. */

    if (wmem_array_get_count(media_descriptions) >= SDP_MAX_RTP_CHANNELS) {

        DPRINT(("Too many media descriptions (more than %d), returning NULL!",

                wmem_array_get_count(media_descriptions)));

        return NULL;

    }

    memset(&empty_desc, 0, sizeof(media_description_t));

    wmem_array_append_one(media_descriptions, empty_desc);

    media_desc = (media_description_t *) wmem_array_index(media_descriptions,

            wmem_array_get_count(media_descriptions) - 1);

    /* XXX does it make sense making media_desc->media.pt a wmem array? */

    /* If "c=" is given at the session level, copy it to the media description.

     * It will be overridden as needed. */

    if (session_info->conn_addr.type != AT_NONE) {

        copy_address_wmem(wmem_file_scope(), &media_desc->conn_addr, &session_info->conn_addr);

    }

    /* If "a=rtpmap:" was set on the session level, copy them to media level. */

    media_desc->media.rtp_dyn_payload =

        rtp_dyn_payload_dup(session_info->rtp_dyn_payload);

    return media_desc;

}

rtp_dyn_payload_t *

sdp_get_rtsp_media_desc(const char* control_uri)

{

    return wmem_map_lookup(sdp_rtsp_control_map, control_uri);

}

/* Remove information about media descriptions which are unused. These appeared

 * in the "a=rtpmap:" (and maybe even in the payload types part of "m="?), but

 * are not used (port is zero or it was not assigned to RTP dissector). */

static void

clean_unused_media_descriptions(wmem_array_t *descs)

{

    for (unsigned i = 0; i < wmem_array_get_count(descs); i++) {

        media_description_t *media_desc = (media_description_t *)wmem_array_index(descs, i);

        /* If not assigned to subdissector, clear the unused information. */

        if (!media_desc->media.set_rtp) {

            rtp_dyn_payload_free(media_desc->media.rtp_dyn_payload);

            media_desc->media.rtp_dyn_payload = NULL;

        }

    }

}

/* Subdissector functions */

static void

dissect_sdp_owner(tvbuff_t *tvb, proto_item *ti) {

    proto_tree *sdp_owner_tree;

    int         offset, next_offset, tokenlen;

    offset = 0;

    sdp_owner_tree = proto_item_add_subtree(ti, ett_sdp_owner);

    /* Find the username */

    tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_owner_tree, hf_owner_username, tvb, offset, tokenlen,

                        ENC_UTF_8);

    offset = next_offset  + 1;

    /* Find the session id */

    tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_owner_tree, hf_owner_sessionid, tvb, offset,

                        tokenlen, ENC_UTF_8);

    offset = next_offset + 1;

    /* Find the version */

    tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_owner_tree, hf_owner_version, tvb, offset, tokenlen,

                        ENC_UTF_8);

    offset = next_offset + 1;

    /* Find the network type */

    tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_owner_tree, hf_owner_network_type, tvb, offset,

                        tokenlen, ENC_UTF_8);

    offset = next_offset + 1;

    /* Find the address type */

    tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_owner_tree, hf_owner_address_type, tvb, offset,

                        tokenlen, ENC_UTF_8);

    offset = next_offset + 1;

    /* Find the address */

    proto_tree_add_item(sdp_owner_tree, hf_owner_address, tvb, offset, -1, ENC_UTF_8);

}

/*

 * XXX - this can leak memory if an exception is thrown after we've fetched

 * a string.

 */

static void

dissect_sdp_connection_info(packet_info *pinfo, tvbuff_t *tvb, proto_item* ti, session_info_t *session_info, media_description_t *media_desc)

{

    proto_tree *sdp_connection_info_tree;

    int         offset, next_offset, tokenlen;

    const char *connection_type, *connection_address;

    offset = 0;

    sdp_connection_info_tree = proto_item_add_subtree(ti,

                                                      ett_sdp_connection_info);

    /* Find the network type */

    tokenlen = find_next_token_in_line(tvb, sdp_connection_info_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_connection_info_tree,

                        hf_connection_info_network_type, tvb, offset, tokenlen,

                        ENC_UTF_8);

    offset = next_offset + 1;

    /* Find the address type */

    tokenlen = find_next_token_in_line(tvb, sdp_connection_info_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    /* Save connection address type */

    proto_tree_add_item_ret_string(sdp_connection_info_tree,

                        hf_connection_info_address_type, tvb, offset, tokenlen,

                        ENC_UTF_8|ENC_NA, pinfo->pool, (const uint8_t**)&connection_type);

    DPRINT(("parsed connection line type=%s", connection_type));

    offset = next_offset + 1;

    /* Find the connection address */

    /* XXX - what if there's a <number of addresses> value? */

    next_offset = tvb_find_uint8(tvb, offset, -1, '/');

    if (next_offset == -1) {

        tokenlen = -1; /* end of tvbuff */

        /* Save connection address */

        connection_address = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset, tvb_captured_length_remaining(tvb, offset), ENC_UTF_8|ENC_NA);

    } else {

        tokenlen = next_offset - offset;

        /* Save connection address */

        connection_address = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA);

    }

    DPRINT(("parsed connection line address=%s", connection_address));

    /* Parse and store connection address. Session-level addresses are

     * packet-scoped since they will be cloned in file-scope when needed. */

    if (session_info) {

        parse_sdp_connection_address(connection_type, connection_address,

                pinfo->pool,

                &session_info->conn_addr);

    } else if (media_desc) {

        /* Clear possibly inherited address from session level. */

        free_address_wmem(wmem_file_scope(), &media_desc->conn_addr);

        parse_sdp_connection_address(connection_type, connection_address,

                wmem_file_scope(),

                &media_desc->conn_addr);

    }

    proto_tree_add_item(sdp_connection_info_tree,

                        hf_connection_info_connection_address, tvb, offset,

                        tokenlen, ENC_UTF_8);

    if (next_offset != -1) {

        offset = next_offset + 1;

        next_offset = tvb_find_uint8(tvb, offset, -1, '/');

        if (next_offset == -1) {

            tokenlen = -1; /* end of tvbuff */

        } else {

            tokenlen = next_offset - offset;

        }

        proto_tree_add_item(sdp_connection_info_tree,

                            hf_connection_info_ttl, tvb, offset, tokenlen, ENC_UTF_8);

        if (next_offset != -1) {

            offset = next_offset + 1;

            proto_tree_add_item(sdp_connection_info_tree,

                                hf_connection_info_num_addr, tvb, offset, -1, ENC_UTF_8);

        }

    }

}

static void

dissect_sdp_bandwidth(tvbuff_t *tvb, proto_item *ti) {

    proto_tree *sdp_bandwidth_tree;

    int         offset, next_offset, tokenlen;

    proto_item *item;

    bool        unit_is_kbs = false;

    bool        unit_is_bps = false;

    offset = 0;

    sdp_bandwidth_tree = proto_item_add_subtree(ti, ett_sdp_bandwidth);

    /* find the modifier */

    next_offset = tvb_find_uint8(tvb, offset, -1, ':');

    if (next_offset == -1)

        return;

    tokenlen = next_offset - offset;

    item = proto_tree_add_item(sdp_bandwidth_tree, hf_bandwidth_modifier, tvb, offset,

                               tokenlen, ENC_UTF_8);

    if (tvb_strneql(tvb, offset, "CT", 2) == 0) {

        proto_item_append_text(item, " [Conference Total(total bandwidth of all RTP sessions)]");

        unit_is_kbs = true;

    } else if (tvb_strneql(tvb, offset, "AS", 2) == 0) {

        proto_item_append_text(item, " [Application Specific (RTP session bandwidth)]");

        unit_is_kbs = true;

    } else if (tvb_strneql(tvb, offset, "TIAS", 4) == 0) {

        proto_item_append_text(item, " [Transport Independent Application Specific maximum]");

        unit_is_bps = true;

    }

    offset = next_offset + 1;

    item = proto_tree_add_item(sdp_bandwidth_tree, hf_bandwidth_value, tvb, offset, -1,

                               ENC_UTF_8);

    if (unit_is_kbs == true)

        proto_item_append_text(item, " kb/s");

    if (unit_is_bps == true)

        proto_item_append_text(item, " b/s");

}

static void dissect_sdp_time(tvbuff_t *tvb, proto_item* ti) {

    proto_tree *sdp_time_tree;

    int         offset, next_offset, tokenlen;

    offset = 0;

    sdp_time_tree = proto_item_add_subtree(ti, ett_sdp_time);

    /* get start time */

    tokenlen = find_next_token_in_line(tvb, sdp_time_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_time_tree, hf_time_start, tvb, offset, tokenlen,

                        ENC_UTF_8);

    /* get stop time */

    offset = next_offset + 1;

    proto_tree_add_item(sdp_time_tree, hf_time_stop, tvb, offset, -1, ENC_UTF_8);

}

static void dissect_sdp_repeat_time(tvbuff_t *tvb, proto_item* ti) {

    proto_tree *sdp_repeat_time_tree;

    int         offset, next_offset, tokenlen;

    bool        optional = false;

    offset = 0;

    sdp_repeat_time_tree = proto_item_add_subtree(ti, ett_sdp_time);

    /* get interval */

    tokenlen = find_next_token_in_line(tvb, sdp_repeat_time_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_repeat_time_tree, hf_repeat_time_interval, tvb,

                        offset, tokenlen, ENC_UTF_8);

    /* get duration */

    offset = next_offset + 1;

    tokenlen = find_next_token_in_line(tvb, sdp_repeat_time_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item(sdp_repeat_time_tree, hf_repeat_time_duration, tvb,

                        offset, tokenlen, ENC_UTF_8);

    /* get offsets */

    do {

        offset = next_offset +1;

        tokenlen = find_next_optional_token_in_line(tvb, sdp_repeat_time_tree,

                                                    &offset, &next_offset, optional);

        if (tokenlen == 0)

            break;

        proto_tree_add_item(sdp_repeat_time_tree, hf_repeat_time_offset,

                            tvb, offset, tokenlen, ENC_UTF_8);

        optional = true;

    } while (next_offset != -1);

}

static void

dissect_sdp_timezone(tvbuff_t *tvb, proto_item* ti) {

    proto_tree* sdp_timezone_tree;

    int         offset, next_offset, tokenlen;

    bool        optional = false;

    offset = 0;

    sdp_timezone_tree = proto_item_add_subtree(ti, ett_sdp_timezone);

    do {

        tokenlen = find_next_optional_token_in_line(tvb, sdp_timezone_tree,

                                                    &offset, &next_offset, optional);

        if (tokenlen == 0)

            break;

        proto_tree_add_item(sdp_timezone_tree, hf_timezone_time, tvb, offset,

                            tokenlen, ENC_UTF_8);

        offset = next_offset + 1;

        tokenlen = find_next_optional_token_in_line(tvb, sdp_timezone_tree,

                                                    &offset, &next_offset, optional);

        if (tokenlen == 0)

            break;

        proto_tree_add_item(sdp_timezone_tree, hf_timezone_offset, tvb, offset,

                            tokenlen, ENC_UTF_8);

        offset = next_offset + 1;

        optional = true;

    } while (next_offset != -1);

}

static void dissect_sdp_encryption_key(tvbuff_t *tvb, proto_item * ti) {

    proto_tree *sdp_encryption_key_tree;

    int         offset, next_offset, tokenlen;

    offset = 0;

    sdp_encryption_key_tree = proto_item_add_subtree(ti, ett_sdp_encryption_key);

    next_offset = tvb_find_uint8(tvb, offset, -1, ':');

    if (next_offset == -1)

        return;

    tokenlen = next_offset - offset;

    proto_tree_add_item(sdp_encryption_key_tree, hf_encryption_key_type,

                        tvb, offset, tokenlen, ENC_UTF_8);

    offset = next_offset + 1;

    proto_tree_add_item(sdp_encryption_key_tree, hf_encryption_key_data,

                        tvb, offset, -1, ENC_UTF_8);

}

static void dissect_key_mgmt(tvbuff_t *tvb, packet_info * pinfo, proto_item * ti) {

    char         *data_p      = NULL;

    const uint8_t *prtcl_id    = NULL;

    int           len;

    tvbuff_t     *keymgmt_tvb;

    int           found_match = 0;

    proto_tree   *key_tree;

    int           next_offset;

    int           offset      = 0;

    int           tokenlen;

    key_tree = proto_item_add_subtree(ti, ett_sdp_key_mgmt);

    tokenlen = find_next_token_in_line(tvb, key_tree, &offset, &next_offset);

    if (tokenlen == 0)

        return;

    proto_tree_add_item_ret_string(key_tree, hf_key_mgmt_prtcl_id, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA, pinfo->pool, &prtcl_id);

    offset = next_offset + 1;

    len = tvb_captured_length_remaining(tvb, offset);

    if (len < 0)

        return;

    data_p = (char *)tvb_get_string_enc(pinfo->pool, tvb, offset, len, ENC_UTF_8|ENC_NA);

    keymgmt_tvb = base64_to_tvb(tvb, data_p);

    add_new_data_source(pinfo, keymgmt_tvb, "Key Management Data");

    if ((prtcl_id != NULL) && (key_mgmt_dissector_table != NULL)) {

        found_match = dissector_try_string_with_data(key_mgmt_dissector_table,

                                           (const char *)prtcl_id,

                                           keymgmt_tvb, pinfo,

                                           key_tree, true, NULL);

    }

    if (found_match) {

        proto_item *ti2 = proto_tree_add_item(key_tree, hf_key_mgmt_data,

                                              keymgmt_tvb, 0, -1, ENC_NA);

        proto_item_set_hidden(ti2);

    } else {

        proto_tree_add_item(key_tree, hf_key_mgmt_data,

                            keymgmt_tvb, 0, -1, ENC_NA);

    }

}

static void dissect_sdp_session_attribute(tvbuff_t *tvb, packet_info * pinfo, proto_item * ti) {

    proto_tree   *sdp_session_attribute_tree;

    int           offset, next_offset, tokenlen;

    const uint8_t *field_name;

    offset = 0;

    sdp_session_attribute_tree = proto_item_add_subtree(ti,

                                                        ett_sdp_session_attribute);

    next_offset = tvb_find_uint8(tvb, offset, -1, ':');

    if (next_offset == -1)

        return;

    tokenlen = next_offset - offset;

    proto_tree_add_item_ret_string(sdp_session_attribute_tree, hf_session_attribute_field,

                        tvb, offset, tokenlen, ENC_UTF_8|ENC_NA, pinfo->pool, &field_name);

    offset = next_offset + 1;

    if (tvb_captured_length_remaining(tvb, offset) == 0) {

        expert_add_info(pinfo, ti, &ei_sdp_invalid_line_fields);

        return;

    }

    if (strcmp((const char *)field_name, "ipbcp") == 0) {

        offset = tvb_ws_mempbrk_pattern_uint8(tvb, offset, -1,&pbrk_digits, NULL);

        if (offset == -1)

            return;

        tokenlen = find_next_token_in_line(tvb, sdp_session_attribute_tree, &offset, &next_offset);

        if (tokenlen == 0)

            return;

        proto_tree_add_item(sdp_session_attribute_tree, hf_ipbcp_version, tvb, offset, tokenlen, ENC_UTF_8);

        offset = tvb_ws_mempbrk_pattern_uint8(tvb, offset, -1,&pbrk_alpha, NULL);

        if (offset == -1)

            return;

        tokenlen = tvb_find_line_end(tvb, offset, -1, &next_offset, false);

        if (tokenlen == -1)

            return;

        proto_tree_add_item(sdp_session_attribute_tree, hf_ipbcp_type, tvb, offset, tokenlen, ENC_UTF_8);

    } else if (strcmp((const char *)field_name, "key-mgmt") == 0) {

        tvbuff_t   *key_tvb;

        proto_item *key_ti;

        key_tvb = tvb_new_subset_remaining(tvb, offset);

        key_ti = proto_tree_add_item(sdp_session_attribute_tree, hf_key_mgmt_att_value, key_tvb, 0, -1, ENC_UTF_8);

        dissect_key_mgmt(key_tvb, pinfo, key_ti);

    } else {

        proto_tree_add_item(sdp_session_attribute_tree, hf_session_attribute_value,

                            tvb, offset, -1, ENC_UTF_8);

    }

}

/* Dissect media description - this is passed the line starting after 'm=', so like one of these:

 *    audio 29156 RTP/AVP 18 0

 *    video 49170/2 RTP/AVP 31 99

 */

static void

dissect_sdp_media(tvbuff_t *tvb, packet_info* pinfo, proto_item *ti,

                  media_description_t *media_desc) {

    proto_tree *sdp_media_tree;

    int         offset, next_offset, tokenlen, idx;

    uint8_t    *media_format;

    bool        optional = false;

    proto_item *it;

    const char *media_type_str;

    const char *media_port_str;

    const char *media_proto_str;

    transport_proto_t transport_proto;

    uint16_t    media_port;

    bool        media_port_valid;

    proto_item *pi;

    offset = 0;

    /* Create tree for media session */

    sdp_media_tree = proto_item_add_subtree(ti, ett_sdp_media);

    tokenlen = find_next_token_in_line(tvb, sdp_media_tree, &offset, &next_offset);

    if (tokenlen == 0)