2000-04-21 01:45:58 +00:00
|
|
|
/* packet-rtcp.c
|
2001-06-12 06:32:39 +00:00
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2000-04-21 01:45:58 +00:00
|
|
|
*
|
2000-10-19 06:45:11 +00:00
|
|
|
* Routines for RTCP dissection
|
|
|
|
* RTCP = Real-time Transport Control Protocol
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-10-19 06:45:11 +00:00
|
|
|
* Copyright 2000, Philips Electronics N.V.
|
2004-02-14 22:48:53 +00:00
|
|
|
* Written by Andreas Sikkema <h323@ramdyne.nl>
|
2000-04-21 01:45:58 +00:00
|
|
|
*
|
2004-05-31 19:35:53 +00:00
|
|
|
* Copyright 2004, Anders Broman <anders.broman@ericsson.com>
|
|
|
|
*
|
2000-04-21 01:45:58 +00:00
|
|
|
* Ethereal - Network traffic analyzer
|
2001-06-12 06:32:39 +00:00
|
|
|
* By Gerald Combs <gerald@ethereal.com>
|
2000-04-21 01:45:58 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-04-21 01:45:58 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-04-21 01:45:58 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-04-21 01:45:58 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
2000-10-19 06:45:11 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This dissector tries to dissect the RTCP protocol according to Annex A
|
|
|
|
* of ITU-T Recommendation H.225.0 (02/98) and RFC 1889
|
|
|
|
* H.225.0 literally copies RFC 1889, but omitting a few sections.
|
2000-04-21 01:45:58 +00:00
|
|
|
*
|
2002-08-28 21:04:11 +00:00
|
|
|
* RTCP traffic is handled by an uneven UDP portnumber. This can be any
|
2000-10-19 06:45:11 +00:00
|
|
|
* port number, but there is a registered port available, port 5005
|
|
|
|
* See Annex B of ITU-T Recommendation H.225.0, section B.7
|
2000-04-21 01:45:58 +00:00
|
|
|
*
|
2004-05-31 19:35:53 +00:00
|
|
|
* See also http://www.iana.org/assignments/rtp-parameters
|
2000-04-21 01:45:58 +00:00
|
|
|
*/
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <glib.h>
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
#include <stdio.h>
|
2000-04-21 01:45:58 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "packet-rtcp.h"
|
2000-10-19 08:17:45 +00:00
|
|
|
#if 0
|
|
|
|
#include "packet-ntp.h"
|
|
|
|
#endif
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/conversation.h>
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
#include "prefs.h"
|
|
|
|
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Version is the first 2 bits of the first octet*/
|
|
|
|
#define RTCP_VERSION(octet) ((octet) >> 6)
|
|
|
|
|
|
|
|
/* Padding is the third bit; no need to shift, because true is any value
|
|
|
|
other than 0! */
|
|
|
|
#define RTCP_PADDING(octet) ((octet) & 0x20)
|
|
|
|
|
|
|
|
/* Receiver/ Sender count is the 5 last bits */
|
|
|
|
#define RTCP_COUNT(octet) ((octet) & 0x1F)
|
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
static dissector_handle_t rtcp_handle;
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
static const value_string rtcp_version_vals[] =
|
2000-10-19 06:45:11 +00:00
|
|
|
{
|
|
|
|
{ 0, "Old VAT Version" },
|
|
|
|
{ 1, "First Draft Version" },
|
|
|
|
{ 2, "RFC 1889 Version" },
|
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
/* RTCP packet types according to Section A.11.1 */
|
2004-05-31 19:35:53 +00:00
|
|
|
/* And http://www.iana.org/assignments/rtp-parameters */
|
2000-10-19 06:45:11 +00:00
|
|
|
#define RTCP_SR 200
|
|
|
|
#define RTCP_RR 201
|
|
|
|
#define RTCP_SDES 202
|
|
|
|
#define RTCP_BYE 203
|
|
|
|
#define RTCP_APP 204
|
2004-05-31 19:35:53 +00:00
|
|
|
#define RTCP_XR 207
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Supplemental H.261 specific RTCP packet types according to Section C.3.5 */
|
|
|
|
#define RTCP_FIR 192
|
|
|
|
#define RTCP_NACK 193
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
static const value_string rtcp_packet_type_vals[] =
|
2000-10-19 06:45:11 +00:00
|
|
|
{
|
|
|
|
{ RTCP_SR, "Sender Report" },
|
|
|
|
{ RTCP_RR, "Receiver Report" },
|
|
|
|
{ RTCP_SDES, "Source description" },
|
|
|
|
{ RTCP_BYE, "Goodbye" },
|
|
|
|
{ RTCP_APP, "Application specific" },
|
|
|
|
{ RTCP_FIR, "Full Intra-frame Request (H.261)" },
|
|
|
|
{ RTCP_NACK, "Negative Acknowledgement (H.261)" },
|
2004-06-01 18:58:04 +00:00
|
|
|
{ RTCP_XR, "Extended report"},
|
2000-10-19 06:45:11 +00:00
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
/* RTCP SDES types (Section A.11.2) */
|
|
|
|
#define RTCP_SDES_END 0
|
|
|
|
#define RTCP_SDES_CNAME 1
|
|
|
|
#define RTCP_SDES_NAME 2
|
|
|
|
#define RTCP_SDES_EMAIL 3
|
|
|
|
#define RTCP_SDES_PHONE 4
|
|
|
|
#define RTCP_SDES_LOC 5
|
|
|
|
#define RTCP_SDES_TOOL 6
|
|
|
|
#define RTCP_SDES_NOTE 7
|
|
|
|
#define RTCP_SDES_PRIV 8
|
2004-05-31 19:35:53 +00:00
|
|
|
#define RTCP_SDES_H323_CADDR 9
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
static const value_string rtcp_sdes_type_vals[] =
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
{ RTCP_SDES_END, "END" },
|
|
|
|
{ RTCP_SDES_CNAME, "CNAME (user and domain)" },
|
|
|
|
{ RTCP_SDES_NAME, "NAME (common name)" },
|
|
|
|
{ RTCP_SDES_EMAIL, "EMAIL (e-mail address)" },
|
|
|
|
{ RTCP_SDES_PHONE, "PHONE (phone number)" },
|
|
|
|
{ RTCP_SDES_LOC, "LOC (geographic location)" },
|
|
|
|
{ RTCP_SDES_TOOL, "TOOL (name/version of source app)" },
|
|
|
|
{ RTCP_SDES_NOTE, "NOTE (note about source)" },
|
|
|
|
{ RTCP_SDES_PRIV, "PRIV (private extensions)" },
|
2004-05-31 19:35:53 +00:00
|
|
|
{ RTCP_SDES_H323_CADDR,"H323-CADDR (H.323 callable address)"},
|
2000-10-19 06:45:11 +00:00
|
|
|
{ 0, NULL },
|
|
|
|
};
|
2004-05-31 19:35:53 +00:00
|
|
|
/* RTCP Application PoC1 Value strings */
|
|
|
|
static const value_string rtcp_app_poc1_floor_cnt_type_vals[] =
|
|
|
|
{
|
|
|
|
{ 0, "Floor Request"},
|
|
|
|
{ 1, "Floor Grant"},
|
|
|
|
{ 2, "Floor Taken"},
|
|
|
|
{ 3, "Floor Deny"},
|
|
|
|
{ 4, "Floor Release"},
|
|
|
|
{ 5, "Floor Idle"},
|
|
|
|
{ 6, "Floor Revoke"},
|
2004-06-01 18:58:04 +00:00
|
|
|
{ 0, NULL },
|
2004-05-31 19:35:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string rtcp_app_poc1_reason_code1_vals[] =
|
|
|
|
{
|
|
|
|
{ 1, "Floor already in use"},
|
|
|
|
{ 2, "Internal PoC server error"},
|
2004-06-01 18:58:04 +00:00
|
|
|
{ 0, NULL },
|
2004-05-31 19:35:53 +00:00
|
|
|
};
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2004-05-31 19:35:53 +00:00
|
|
|
static const value_string rtcp_app_poc1_reason_code2_vals[] =
|
|
|
|
{
|
|
|
|
{ 1, "Only one user"},
|
|
|
|
{ 2, "Talk burst too long"},
|
2004-06-01 18:58:04 +00:00
|
|
|
{ 0, NULL },
|
2004-05-31 19:35:53 +00:00
|
|
|
};
|
2000-10-19 06:45:11 +00:00
|
|
|
/* RTCP header fields */
|
|
|
|
static int proto_rtcp = -1;
|
|
|
|
static int hf_rtcp_version = -1;
|
|
|
|
static int hf_rtcp_padding = -1;
|
|
|
|
static int hf_rtcp_rc = -1;
|
|
|
|
static int hf_rtcp_sc = -1;
|
|
|
|
static int hf_rtcp_pt = -1;
|
|
|
|
static int hf_rtcp_length = -1;
|
|
|
|
static int hf_rtcp_ssrc_sender = -1;
|
|
|
|
static int hf_rtcp_ntp = -1;
|
|
|
|
static int hf_rtcp_rtp_timestamp = -1;
|
|
|
|
static int hf_rtcp_sender_pkt_cnt = -1;
|
|
|
|
static int hf_rtcp_sender_oct_cnt = -1;
|
|
|
|
static int hf_rtcp_ssrc_source = -1;
|
|
|
|
static int hf_rtcp_ssrc_fraction = -1;
|
|
|
|
static int hf_rtcp_ssrc_cum_nr = -1;
|
2002-08-28 21:04:11 +00:00
|
|
|
/* First the 32 bit number, then the split
|
2000-10-19 06:45:11 +00:00
|
|
|
* up 16 bit values */
|
|
|
|
/* These two are added to a subtree */
|
|
|
|
static int hf_rtcp_ssrc_ext_high_seq = -1;
|
|
|
|
static int hf_rtcp_ssrc_high_seq = -1;
|
|
|
|
static int hf_rtcp_ssrc_high_cycles = -1;
|
|
|
|
static int hf_rtcp_ssrc_jitter = -1;
|
|
|
|
static int hf_rtcp_ssrc_lsr = -1;
|
|
|
|
static int hf_rtcp_ssrc_dlsr = -1;
|
|
|
|
static int hf_rtcp_ssrc_csrc = -1;
|
|
|
|
static int hf_rtcp_ssrc_type = -1;
|
|
|
|
static int hf_rtcp_ssrc_length = -1;
|
|
|
|
static int hf_rtcp_ssrc_text = -1;
|
|
|
|
static int hf_rtcp_ssrc_prefix_len = -1;
|
|
|
|
static int hf_rtcp_ssrc_prefix_string= -1;
|
|
|
|
static int hf_rtcp_subtype = -1;
|
|
|
|
static int hf_rtcp_name_ascii = -1;
|
|
|
|
static int hf_rtcp_app_data = -1;
|
|
|
|
static int hf_rtcp_fsn = -1;
|
|
|
|
static int hf_rtcp_blp = -1;
|
|
|
|
static int hf_rtcp_padding_count = -1;
|
|
|
|
static int hf_rtcp_padding_data = -1;
|
2004-06-15 18:26:08 +00:00
|
|
|
static int hf_rtcp_app_poc1_subtype = -1;
|
2004-06-01 18:58:04 +00:00
|
|
|
static int hf_rtcp_app_poc1_sip_uri = -1;
|
|
|
|
static int hf_rtcp_app_poc1_disp_name = -1;
|
2004-05-31 19:35:53 +00:00
|
|
|
static int hf_rtcp_app_poc1_last_pkt_seq_no = -1;
|
|
|
|
static int hf_rtcp_app_poc1_reason_code1 = -1;
|
|
|
|
static int hf_rtcp_app_poc1_item_len = -1;
|
|
|
|
static int hf_rtcp_app_poc1_reason1_phrase = -1;
|
|
|
|
static int hf_rtcp_app_poc1_reason_code2 = -1;
|
|
|
|
static int hf_rtcp_app_poc1_additionalinfo = -1;
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
/* RTCP setup fields */
|
|
|
|
static int hf_rtcp_setup = -1;
|
|
|
|
static int hf_rtcp_setup_frame = -1;
|
|
|
|
static int hf_rtcp_setup_method = -1;
|
|
|
|
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* RTCP fields defining a sub tree */
|
2004-05-31 19:35:53 +00:00
|
|
|
static gint ett_rtcp = -1;
|
|
|
|
static gint ett_ssrc = -1;
|
|
|
|
static gint ett_ssrc_item = -1;
|
2004-06-01 18:58:04 +00:00
|
|
|
static gint ett_ssrc_ext_high = -1;
|
2004-05-31 19:35:53 +00:00
|
|
|
static gint ett_sdes = -1;
|
|
|
|
static gint ett_sdes_item = -1;
|
|
|
|
static gint ett_PoC1 = -1;
|
2004-06-15 18:26:08 +00:00
|
|
|
static gint ett_rtcp_setup = -1;
|
2000-10-19 06:45:11 +00:00
|
|
|
|
|
|
|
static address fake_addr;
|
|
|
|
static int heur_init = FALSE;
|
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
static gboolean dissect_rtcp_heur( tvbuff_t *tvb, packet_info *pinfo,
|
|
|
|
proto_tree *tree );
|
2001-11-27 07:13:32 +00:00
|
|
|
static void dissect_rtcp( tvbuff_t *tvb, packet_info *pinfo,
|
|
|
|
proto_tree *tree );
|
2004-06-15 18:26:08 +00:00
|
|
|
static void show_setup_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
|
2001-01-03 06:56:03 +00:00
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
/* Preferences bool to control whether or not setup info should be shown */
|
|
|
|
static gboolean global_rtcp_show_setup_info = TRUE;
|
|
|
|
|
|
|
|
/* Memory chunk for storing conversation and per-packet info */
|
|
|
|
static GMemChunk *rtcp_conversations = NULL;
|
|
|
|
|
|
|
|
|
|
|
|
void rtcp_add_address( packet_info *pinfo,
|
|
|
|
const unsigned char* ip_addr, int port,
|
|
|
|
int other_port,
|
|
|
|
gchar *setup_method, guint32 setup_frame_number)
|
2000-10-19 06:45:11 +00:00
|
|
|
{
|
|
|
|
address src_addr;
|
2004-06-15 18:26:08 +00:00
|
|
|
conversation_t* p_conv;
|
|
|
|
struct _rtcp_conversation_info *p_conv_data = NULL;
|
2001-09-03 10:33:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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->flags.visited)
|
2004-06-29 20:29:57 +00:00
|
|
|
{
|
2001-09-03 10:33:12 +00:00
|
|
|
return;
|
2004-06-29 20:29:57 +00:00
|
|
|
}
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
src_addr.type = pinfo->net_src.type;
|
|
|
|
src_addr.len = pinfo->net_src.len;
|
2000-10-19 06:45:11 +00:00
|
|
|
src_addr.data = ip_addr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The first time the function is called let the udp dissector
|
|
|
|
* know that we're interested in traffic
|
2004-06-15 18:26:08 +00:00
|
|
|
* TODO???
|
|
|
|
*
|
2000-10-19 06:45:11 +00:00
|
|
|
if ( ! heur_init ) {
|
2001-01-09 06:32:10 +00:00
|
|
|
heur_dissector_add( "udp", dissect_rtcp_heur, proto_rtcp );
|
2000-10-19 06:45:11 +00:00
|
|
|
heur_init = TRUE;
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
2004-06-15 18:26:08 +00:00
|
|
|
*/
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/*
|
2002-08-28 21:04:11 +00:00
|
|
|
* Check if the ip address and port combination is not
|
2000-10-19 06:45:11 +00:00
|
|
|
* already registered
|
|
|
|
*/
|
2004-06-15 18:26:08 +00:00
|
|
|
p_conv = find_conversation( &src_addr, &src_addr, PT_UDP, port, other_port,
|
|
|
|
NO_ADDR_B | (!other_port ? NO_PORT_B : 0));
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/*
|
|
|
|
* If not, add
|
|
|
|
*/
|
2004-06-15 18:26:08 +00:00
|
|
|
if ( ! p_conv ) {
|
|
|
|
/* Create conversation data */
|
|
|
|
p_conv_data = g_mem_chunk_alloc(rtcp_conversations);
|
|
|
|
|
|
|
|
/* Check length first time we look at method string */
|
|
|
|
strncpy(p_conv_data->method, setup_method,
|
|
|
|
(strlen(setup_method)+1 <= MAX_RTCP_SETUP_METHOD_SIZE) ?
|
|
|
|
strlen(setup_method)+1 :
|
|
|
|
MAX_RTCP_SETUP_METHOD_SIZE);
|
|
|
|
p_conv_data->method[MAX_RTCP_SETUP_METHOD_SIZE] = '\0';
|
|
|
|
p_conv_data->frame_number = setup_frame_number;
|
|
|
|
|
|
|
|
/* Create conversation with this data */
|
|
|
|
p_conv = conversation_new( &src_addr, &src_addr, PT_UDP,
|
2004-06-29 20:29:57 +00:00
|
|
|
(guint32)port, (guint32)other_port,
|
2004-06-15 18:26:08 +00:00
|
|
|
NO_ADDR2 | (!other_port ? NO_PORT2 : 0));
|
|
|
|
conversation_add_proto_data(p_conv, proto_rtcp, p_conv_data);
|
|
|
|
|
|
|
|
/* Set dissector */
|
|
|
|
conversation_set_dissector(p_conv, rtcp_handle);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Update existing conversation data */
|
|
|
|
p_conv_data = conversation_get_proto_data(p_conv, proto_rtcp);
|
|
|
|
strcpy(p_conv_data->method, setup_method);
|
|
|
|
p_conv_data->frame_number = setup_frame_number;
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
static void rtcp_init( void )
|
2000-10-19 06:45:11 +00:00
|
|
|
{
|
|
|
|
unsigned char* tmp_data;
|
|
|
|
int i;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
/* (Re)allocate mem chunk for conversations */
|
|
|
|
if (rtcp_conversations)
|
|
|
|
{
|
|
|
|
g_mem_chunk_destroy(rtcp_conversations);
|
|
|
|
}
|
|
|
|
rtcp_conversations = g_mem_chunk_new("rtcp_conversations",
|
|
|
|
sizeof(struct _rtcp_conversation_info),
|
|
|
|
20 * sizeof(struct _rtcp_conversation_info),
|
|
|
|
G_ALLOC_ONLY);
|
|
|
|
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Create a fake adddress... */
|
|
|
|
fake_addr.type = AT_IPv4;
|
|
|
|
fake_addr.len = 4;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2003-04-27 20:57:58 +00:00
|
|
|
tmp_data = g_malloc( fake_addr.len );
|
2000-10-19 06:45:11 +00:00
|
|
|
for ( i = 0; i < fake_addr.len; i++) {
|
|
|
|
tmp_data[i] = 0;
|
|
|
|
}
|
|
|
|
fake_addr.data = tmp_data;
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
static gboolean
|
2000-10-19 06:45:11 +00:00
|
|
|
dissect_rtcp_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
|
|
|
|
{
|
2000-11-05 09:30:11 +00:00
|
|
|
conversation_t* pconv;
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* This is a heuristic dissector, which means we get all the UDP
|
|
|
|
* traffic not sent to a known dissector and not claimed by
|
|
|
|
* a heuristic dissector called before us!
|
|
|
|
* So we first check if the frame is really meant for us.
|
|
|
|
*/
|
2001-07-03 04:56:46 +00:00
|
|
|
if ( ( pconv = find_conversation( &pinfo->src, &fake_addr, pinfo->ptype,
|
|
|
|
pinfo->srcport, 0, 0 ) ) == NULL ) {
|
2000-10-19 06:45:11 +00:00
|
|
|
/*
|
2000-10-21 05:52:28 +00:00
|
|
|
* The source ip:port combination was not what we were
|
|
|
|
* looking for, check the destination
|
2000-10-19 06:45:11 +00:00
|
|
|
*/
|
2001-07-03 04:56:46 +00:00
|
|
|
if ( ( pconv = find_conversation( &pinfo->dst, &fake_addr,
|
|
|
|
pinfo->ptype, pinfo->destport, 0, 0 ) ) == NULL ) {
|
2000-10-19 06:45:11 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
|
|
|
|
/*
|
2001-09-03 10:33:12 +00:00
|
|
|
* An RTCP conversation always has a data item for RTCP.
|
|
|
|
* (Its existence is sufficient to indicate that this is an RTCP
|
|
|
|
* conversation.)
|
2000-10-19 06:45:11 +00:00
|
|
|
*/
|
2001-09-03 10:33:12 +00:00
|
|
|
if (conversation_get_proto_data(pconv, proto_rtcp) == NULL)
|
2000-10-19 06:45:11 +00:00
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The message is a valid RTCP message!
|
|
|
|
*/
|
|
|
|
dissect_rtcp( tvb, pinfo, tree );
|
|
|
|
|
|
|
|
return TRUE;
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
2002-04-09 09:04:33 +00:00
|
|
|
dissect_rtcp_nack( tvbuff_t *tvb, int offset, proto_tree *tree )
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Packet type = FIR (H261) */
|
2003-11-09 22:55:35 +00:00
|
|
|
proto_tree_add_uint( tree, hf_rtcp_rc, tvb, offset, 1, tvb_get_guint8( tvb, offset ) );
|
2000-10-19 06:45:11 +00:00
|
|
|
offset++;
|
|
|
|
/* Packet type, 8 bits = APP */
|
|
|
|
proto_tree_add_item( tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
/* Packet length in 32 bit words minus one */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
|
|
|
|
|
|
|
/* SSRC */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
2000-04-21 01:45:58 +00:00
|
|
|
offset += 4;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* FSN, 16 bits */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_fsn, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* BLP, 16 bits */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_blp, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2002-04-09 09:04:33 +00:00
|
|
|
dissect_rtcp_fir( tvbuff_t *tvb, int offset, proto_tree *tree )
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Packet type = FIR (H261) */
|
2003-11-09 22:55:35 +00:00
|
|
|
proto_tree_add_uint( tree, hf_rtcp_rc, tvb, offset, 1, tvb_get_guint8( tvb, offset ) );
|
2000-10-19 06:45:11 +00:00
|
|
|
offset++;
|
|
|
|
/* Packet type, 8 bits = APP */
|
|
|
|
proto_tree_add_item( tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Packet length in 32 bit words minus one */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
|
|
|
|
|
|
|
/* SSRC */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
2000-04-21 01:45:58 +00:00
|
|
|
offset += 4;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-05-31 19:35:53 +00:00
|
|
|
dissect_rtcp_app( tvbuff_t *tvb,packet_info *pinfo, int offset, proto_tree *tree,
|
|
|
|
unsigned int padding, unsigned int packet_len, guint rtcp_subtype )
|
2000-10-19 06:45:11 +00:00
|
|
|
{
|
|
|
|
unsigned int counter = 0;
|
|
|
|
char ascii_name[5];
|
2004-05-31 19:35:53 +00:00
|
|
|
guint sdes_type = 0;
|
|
|
|
guint item_len = 0;
|
|
|
|
guint items_start_offset;
|
|
|
|
proto_tree *PoC1_tree;
|
|
|
|
proto_item *PoC1_item;
|
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
/* XXX If more application types are to be dissected it may be useful to use a table like in packet-sip.c */
|
2004-05-31 19:35:53 +00:00
|
|
|
static const char app_name_str[] = "PoC1";
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
|
|
|
|
/* SSRC / CSRC */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
2000-04-21 01:45:58 +00:00
|
|
|
offset += 4;
|
2000-10-19 06:45:11 +00:00
|
|
|
packet_len -= 4;
|
|
|
|
|
|
|
|
/* Name (ASCII) */
|
|
|
|
for( counter = 0; counter < 4; counter++ )
|
|
|
|
ascii_name[ counter ] = tvb_get_guint8( tvb, offset + counter );
|
|
|
|
/* strncpy( ascii_name, pd + offset, 4 ); */
|
|
|
|
ascii_name[4] = '\0';
|
|
|
|
proto_tree_add_string( tree, hf_rtcp_name_ascii, tvb, offset, 4,
|
|
|
|
ascii_name );
|
2004-05-31 19:35:53 +00:00
|
|
|
if ( strncasecmp(ascii_name,app_name_str,4 ) != 0 ){ /* Not PoC1 */
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO,"( %s ) subtype=%u",ascii_name, rtcp_subtype);
|
|
|
|
offset += 4;
|
|
|
|
packet_len -= 4;
|
|
|
|
/* Applications specific data */
|
|
|
|
if ( padding ) {
|
|
|
|
/* If there's padding present, we have to remove that from the data part
|
|
|
|
* The last octet of the packet contains the length of the padding
|
|
|
|
*/
|
|
|
|
packet_len -= tvb_get_guint8( tvb, offset + packet_len - 1 );
|
|
|
|
}
|
|
|
|
proto_tree_add_item( tree, hf_rtcp_app_data, tvb, offset, packet_len, FALSE );
|
|
|
|
offset += packet_len;
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
}else{/* PoC1 Application */
|
|
|
|
proto_item *item;
|
2004-06-15 18:26:08 +00:00
|
|
|
item = proto_tree_add_uint( tree, hf_rtcp_app_poc1_subtype, tvb, offset - 8, 1, rtcp_subtype );
|
2004-05-31 19:35:53 +00:00
|
|
|
PROTO_ITEM_SET_GENERATED(item);
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO,"(%s) subtype=%s",ascii_name,
|
|
|
|
val_to_str(rtcp_subtype,rtcp_app_poc1_floor_cnt_type_vals,"unknown (%u)") );
|
|
|
|
offset += 4;
|
|
|
|
packet_len -= 4;
|
|
|
|
/* Applications specific data */
|
|
|
|
if ( padding ) {
|
|
|
|
/* If there's padding present, we have to remove that from the data part
|
|
|
|
* The last octet of the packet contains the length of the padding
|
|
|
|
*/
|
|
|
|
packet_len -= tvb_get_guint8( tvb, offset + packet_len - 1 );
|
|
|
|
}
|
|
|
|
/* Create a subtree for the PoC1 Application items; we don't yet know
|
|
|
|
the length */
|
|
|
|
items_start_offset = offset;
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2004-05-31 19:35:53 +00:00
|
|
|
PoC1_item = proto_tree_add_text(tree, tvb, offset, packet_len,
|
|
|
|
"PoC1 Application specific data");
|
|
|
|
PoC1_tree = proto_item_add_subtree( PoC1_item, ett_PoC1 );
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2004-05-31 19:35:53 +00:00
|
|
|
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_data, tvb, offset, packet_len, FALSE );
|
|
|
|
switch ( rtcp_subtype ) {
|
|
|
|
case 2:
|
|
|
|
sdes_type = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_ssrc_type, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
packet_len--;
|
|
|
|
/* Item length, 8 bits */
|
|
|
|
item_len = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
packet_len--;
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_poc1_sip_uri, tvb, offset, item_len, FALSE );
|
|
|
|
offset = offset + item_len;
|
|
|
|
packet_len = packet_len - item_len;
|
|
|
|
sdes_type = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_ssrc_type, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
packet_len--;
|
|
|
|
/* Item length, 8 bits */
|
|
|
|
item_len = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
packet_len--;
|
|
|
|
if ( item_len != 0 )
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_poc1_disp_name, tvb, offset, item_len, FALSE );
|
|
|
|
offset = offset + item_len;
|
|
|
|
packet_len = packet_len - item_len;
|
|
|
|
break;
|
2004-06-15 18:26:08 +00:00
|
|
|
case 3:
|
2004-05-31 19:35:53 +00:00
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_poc1_reason_code1, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
packet_len--;
|
|
|
|
/* Item length, 8 bits */
|
|
|
|
item_len = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_poc1_item_len, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
packet_len--;
|
|
|
|
if ( item_len != 0 )
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_poc1_reason1_phrase, tvb, offset, item_len, FALSE );
|
|
|
|
offset = offset + item_len;
|
|
|
|
packet_len = packet_len - item_len;
|
|
|
|
break;
|
2004-06-15 18:26:08 +00:00
|
|
|
case 4:
|
2004-05-31 19:35:53 +00:00
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_poc1_last_pkt_seq_no, tvb, offset, 2, FALSE );
|
2004-06-01 18:58:04 +00:00
|
|
|
proto_tree_add_text(PoC1_tree, tvb, offset + 2, 2, "Padding 2 bytes");
|
|
|
|
offset += 4;
|
2004-05-31 19:35:53 +00:00
|
|
|
packet_len-=4;
|
|
|
|
break;
|
2004-06-15 18:26:08 +00:00
|
|
|
case 6:
|
2004-05-31 19:35:53 +00:00
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_poc1_reason_code2, tvb, offset, 2, FALSE );
|
|
|
|
proto_tree_add_item( PoC1_tree, hf_rtcp_app_poc1_additionalinfo, tvb, offset + 2, 2, FALSE );
|
2004-06-01 18:58:04 +00:00
|
|
|
offset += 4;
|
2004-05-31 19:35:53 +00:00
|
|
|
packet_len-=4;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset += packet_len;
|
|
|
|
return offset;
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
|
|
|
|
2004-05-31 19:35:53 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
static int
|
2002-04-09 09:04:33 +00:00
|
|
|
dissect_rtcp_bye( tvbuff_t *tvb, int offset, proto_tree *tree,
|
2001-09-03 08:10:46 +00:00
|
|
|
unsigned int count )
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
unsigned int chunk = 1;
|
|
|
|
unsigned int reason_length = 0;
|
|
|
|
char* reason_text = NULL;
|
|
|
|
|
|
|
|
while ( chunk <= count ) {
|
|
|
|
/* source identifier, 32 bits */
|
2002-07-17 10:37:31 +00:00
|
|
|
proto_tree_add_item( tree, hf_rtcp_ssrc_source, tvb, offset, 4, FALSE);
|
2000-10-19 06:45:11 +00:00
|
|
|
offset += 4;
|
2002-07-17 10:37:31 +00:00
|
|
|
chunk++;
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2002-01-10 22:21:14 +00:00
|
|
|
if ( tvb_reported_length_remaining( tvb, offset ) > 0 ) {
|
|
|
|
/* Bye reason consists of an 8 bit length l and a string with length l */
|
|
|
|
reason_length = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
|
2004-02-25 09:31:07 +00:00
|
|
|
reason_text = tvb_get_string(tvb, offset, reason_length);
|
2002-01-10 22:21:14 +00:00
|
|
|
proto_tree_add_string( tree, hf_rtcp_ssrc_text, tvb, offset, reason_length, reason_text );
|
2003-05-28 22:40:19 +00:00
|
|
|
g_free( reason_text );
|
2002-01-10 22:21:14 +00:00
|
|
|
offset += reason_length;
|
|
|
|
}
|
2000-10-19 06:45:11 +00:00
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
|
|
|
|
2002-04-15 21:25:05 +00:00
|
|
|
static void
|
2002-04-09 09:04:33 +00:00
|
|
|
dissect_rtcp_sdes( tvbuff_t *tvb, int offset, proto_tree *tree,
|
2001-09-03 08:10:46 +00:00
|
|
|
unsigned int count )
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
unsigned int chunk = 1;
|
|
|
|
proto_item *sdes_item;
|
|
|
|
proto_tree *sdes_tree;
|
|
|
|
proto_tree *sdes_item_tree;
|
|
|
|
proto_item *ti;
|
|
|
|
int start_offset;
|
|
|
|
int items_start_offset;
|
|
|
|
guint32 ssrc;
|
|
|
|
unsigned int item_len = 0;
|
|
|
|
unsigned int sdes_type = 0;
|
|
|
|
unsigned int counter = 0;
|
|
|
|
unsigned int prefix_len = 0;
|
|
|
|
char *prefix_string = NULL;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
while ( chunk <= count ) {
|
|
|
|
/* Create a subtree for this chunk; we don't yet know
|
|
|
|
the length. */
|
|
|
|
start_offset = offset;
|
|
|
|
|
|
|
|
ssrc = tvb_get_ntohl( tvb, offset );
|
2004-05-13 17:24:16 +00:00
|
|
|
if (ssrc == 0) {
|
|
|
|
/* According to RFC1889 section 6.4:
|
|
|
|
* "The list of items in each chunk is terminated by one or more
|
|
|
|
* null octets, the first of which is interpreted as an item type
|
|
|
|
* of zero to denote the end of the list, and the remainder as
|
|
|
|
* needed to pad until the next 32-bit boundary.
|
|
|
|
*
|
|
|
|
* A chunk with zero items (four null octets) is valid but useless."
|
|
|
|
*/
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 4, "Padding");
|
|
|
|
offset += 4;
|
|
|
|
continue;
|
|
|
|
}
|
Allow a length of -1 to be specified when adding FT_NONE and FT_PROTOCOL
items to the protocol tree; it's interpreted as "the rest of the data in
the tvbuff". This can be used if
1) the item covers the entire packet or the remaining payload in
the packet
or
2) the item's length won't be known until it's dissected, and
will be then set with "proto_item_set_len()" - if an
exception is thrown in the dissection, it means the item ran
*past* the end of the tvbuff, so saying it runs to the end of
the tvbuff is reasonable.
Convert a number of "proto_tree_add_XXX()" calls using
"tvb_length_remaining()", values derived from the result of
"tvb_length()", or 0 (in the case of items whose length is unknown) to
use -1 instead (using 0 means that if an exception is thrown, selecting
the item highlights nothing; using -1 means it highlights all the data
for that item that's available).
In some places where "tvb_length()" or "tvb_length_remaining()" was used
to determine how large a packet is, use "tvb_reported_length()" or
"tvb_reported_length_remaining()", instead - the first two calls
indicate how much captured data was in the packet, the latter two calls
indicate how large the packet actually was (and the fact that using the
latter could cause BoundsError exceptions to be thrown is a feature - if
such an exception is thrown, the frame really *was* short, and it should
be tagged as such).
Replace some "proto_tree_add_XXX()" calls with equivalent
"proto_tree_add_item()" calls.
Fix some indentation.
svn path=/trunk/; revision=4578
2002-01-20 22:12:39 +00:00
|
|
|
sdes_item = proto_tree_add_text(tree, tvb, offset, -1,
|
2000-10-19 06:45:11 +00:00
|
|
|
"Chunk %u, SSRC/CSRC %u", chunk, ssrc);
|
|
|
|
sdes_tree = proto_item_add_subtree( sdes_item, ett_sdes );
|
|
|
|
|
|
|
|
/* SSRC_n source identifier, 32 bits */
|
|
|
|
proto_tree_add_uint( sdes_tree, hf_rtcp_ssrc_source, tvb, offset, 4, ssrc );
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
/* Create a subtree for the SDES items; we don't yet know
|
2002-08-28 21:04:11 +00:00
|
|
|
the length */
|
2000-10-19 06:45:11 +00:00
|
|
|
items_start_offset = offset;
|
Allow a length of -1 to be specified when adding FT_NONE and FT_PROTOCOL
items to the protocol tree; it's interpreted as "the rest of the data in
the tvbuff". This can be used if
1) the item covers the entire packet or the remaining payload in
the packet
or
2) the item's length won't be known until it's dissected, and
will be then set with "proto_item_set_len()" - if an
exception is thrown in the dissection, it means the item ran
*past* the end of the tvbuff, so saying it runs to the end of
the tvbuff is reasonable.
Convert a number of "proto_tree_add_XXX()" calls using
"tvb_length_remaining()", values derived from the result of
"tvb_length()", or 0 (in the case of items whose length is unknown) to
use -1 instead (using 0 means that if an exception is thrown, selecting
the item highlights nothing; using -1 means it highlights all the data
for that item that's available).
In some places where "tvb_length()" or "tvb_length_remaining()" was used
to determine how large a packet is, use "tvb_reported_length()" or
"tvb_reported_length_remaining()", instead - the first two calls
indicate how much captured data was in the packet, the latter two calls
indicate how large the packet actually was (and the fact that using the
latter could cause BoundsError exceptions to be thrown is a feature - if
such an exception is thrown, the frame really *was* short, and it should
be tagged as such).
Replace some "proto_tree_add_XXX()" calls with equivalent
"proto_tree_add_item()" calls.
Fix some indentation.
svn path=/trunk/; revision=4578
2002-01-20 22:12:39 +00:00
|
|
|
ti = proto_tree_add_text(sdes_tree, tvb, offset, -1,
|
2000-10-19 06:45:11 +00:00
|
|
|
"SDES items" );
|
|
|
|
sdes_item_tree = proto_item_add_subtree( ti, ett_sdes_item );
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/*
|
|
|
|
* Not every message is ended with "null" bytes, so check for
|
|
|
|
* end of frame instead.
|
|
|
|
*/
|
2001-08-18 09:27:06 +00:00
|
|
|
while ( ( tvb_reported_length_remaining( tvb, offset ) > 0 )
|
|
|
|
&& ( tvb_get_guint8( tvb, offset ) != RTCP_SDES_END ) ) {
|
2000-10-19 06:45:11 +00:00
|
|
|
/* ID, 8 bits */
|
|
|
|
sdes_type = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_type, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Item length, 8 bits */
|
|
|
|
item_len = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
|
2000-04-21 01:45:58 +00:00
|
|
|
offset++;
|
2000-10-19 06:45:11 +00:00
|
|
|
|
|
|
|
if ( sdes_type == RTCP_SDES_PRIV ) {
|
|
|
|
/* PRIV adds two items between the SDES length
|
|
|
|
* and value - an 8 bit length giving the
|
|
|
|
* length of a "prefix string", and the string.
|
|
|
|
*/
|
|
|
|
prefix_len = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_prefix_len, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
|
2003-04-27 20:57:58 +00:00
|
|
|
prefix_string = g_malloc( prefix_len + 1 );
|
2000-10-19 06:45:11 +00:00
|
|
|
for ( counter = 0; counter < prefix_len; counter++ )
|
|
|
|
prefix_string[ counter ] =
|
|
|
|
tvb_get_guint8( tvb, offset + counter );
|
|
|
|
/* strncpy( prefix_string, pd + offset, prefix_len ); */
|
|
|
|
prefix_string[ prefix_len ] = '\0';
|
|
|
|
proto_tree_add_string( sdes_item_tree, hf_rtcp_ssrc_prefix_string, tvb, offset, prefix_len, prefix_string );
|
2003-05-28 22:40:19 +00:00
|
|
|
g_free( prefix_string );
|
2000-10-19 06:45:11 +00:00
|
|
|
offset += prefix_len;
|
|
|
|
}
|
2003-04-27 20:57:58 +00:00
|
|
|
prefix_string = g_malloc( item_len + 1 );
|
2000-10-19 06:45:11 +00:00
|
|
|
for ( counter = 0; counter < item_len; counter++ )
|
|
|
|
prefix_string[ counter ] =
|
|
|
|
tvb_get_guint8( tvb, offset + counter );
|
|
|
|
/* strncpy( prefix_string, pd + offset, item_len ); */
|
|
|
|
prefix_string[ item_len] = 0;
|
|
|
|
proto_tree_add_string( sdes_item_tree, hf_rtcp_ssrc_text, tvb, offset, item_len, prefix_string );
|
2003-05-28 22:40:19 +00:00
|
|
|
g_free( prefix_string );
|
2000-10-19 06:45:11 +00:00
|
|
|
offset += item_len;
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Set the length of the items subtree. */
|
|
|
|
proto_item_set_len(ti, offset - items_start_offset);
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/* 32 bits = 4 bytes, so.....
|
|
|
|
* If offset % 4 != 0, we divide offset by 4, add one and then
|
2000-10-19 06:45:11 +00:00
|
|
|
* multiply by 4 again to reach the boundary
|
|
|
|
*/
|
|
|
|
if ( offset % 4 != 0 )
|
|
|
|
offset = ((offset / 4) + 1 ) * 4;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Set the length of this chunk. */
|
|
|
|
proto_item_set_len(sdes_item, offset - start_offset);
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
chunk++;
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2002-04-09 09:04:33 +00:00
|
|
|
dissect_rtcp_rr( tvbuff_t *tvb, int offset, proto_tree *tree,
|
2001-09-03 08:10:46 +00:00
|
|
|
unsigned int count )
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
unsigned int counter = 1;
|
|
|
|
proto_tree *ssrc_tree = (proto_tree*) NULL;
|
|
|
|
proto_tree *ssrc_sub_tree = (proto_tree*) NULL;
|
|
|
|
proto_tree *high_sec_tree = (proto_tree*) NULL;
|
|
|
|
proto_item *ti = (proto_item*) NULL;
|
|
|
|
guint8 rr_flt;
|
|
|
|
unsigned int cum_nr = 0;
|
|
|
|
|
|
|
|
while ( counter <= count ) {
|
|
|
|
/* Create a new subtree for a length of 24 bytes */
|
|
|
|
ti = proto_tree_add_text(tree, tvb, offset, 24,
|
|
|
|
"Source %u", counter );
|
|
|
|
ssrc_tree = proto_item_add_subtree( ti, ett_ssrc );
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* SSRC_n source identifier, 32 bits */
|
|
|
|
proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
offset += 4;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
ti = proto_tree_add_text(ssrc_tree, tvb, offset, 20, "SSRC contents" );
|
|
|
|
ssrc_sub_tree = proto_item_add_subtree( ti, ett_ssrc_item );
|
|
|
|
|
|
|
|
/* Fraction lost, 8bits */
|
|
|
|
rr_flt = tvb_get_guint8( tvb, offset );
|
|
|
|
proto_tree_add_uint_format( ssrc_sub_tree, hf_rtcp_ssrc_fraction, tvb,
|
|
|
|
offset, 1, rr_flt, "Fraction lost: %u / 256", rr_flt );
|
|
|
|
offset++;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* Cumulative number of packets lost, 24 bits */
|
|
|
|
cum_nr = tvb_get_ntohl( tvb, offset ) >> 8;
|
|
|
|
proto_tree_add_uint( ssrc_sub_tree, hf_rtcp_ssrc_cum_nr, tvb,
|
|
|
|
offset, 3, cum_nr );
|
|
|
|
offset += 3;
|
|
|
|
|
|
|
|
/* Extended highest sequence nr received, 32 bits
|
|
|
|
* Just for the sake of it, let's add another subtree
|
|
|
|
* because this might be a little clearer
|
|
|
|
*/
|
|
|
|
ti = proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_ext_high_seq,
|
|
|
|
tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
high_sec_tree = proto_item_add_subtree( ti, ett_ssrc_ext_high );
|
|
|
|
/* Sequence number cycles */
|
|
|
|
proto_tree_add_uint( high_sec_tree, hf_rtcp_ssrc_high_cycles,
|
|
|
|
tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
|
|
|
/* highest sequence number received */
|
|
|
|
proto_tree_add_uint( high_sec_tree, hf_rtcp_ssrc_high_seq,
|
|
|
|
tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
|
|
|
|
|
|
|
/* Interarrival jitter */
|
|
|
|
proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_jitter, tvb,
|
|
|
|
offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
/* Last SR timestamp */
|
|
|
|
proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_lsr, tvb,
|
|
|
|
offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
offset += 4;
|
|
|
|
|
|
|
|
/* Delay since last SR timestamp */
|
|
|
|
proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_dlsr, tvb,
|
|
|
|
offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
offset += 4;
|
|
|
|
counter++;
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2000-04-21 01:45:58 +00:00
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2002-04-09 09:04:33 +00:00
|
|
|
dissect_rtcp_sr( tvbuff_t *tvb, int offset, proto_tree *tree,
|
2001-09-03 08:10:46 +00:00
|
|
|
unsigned int count )
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
2000-10-19 08:17:45 +00:00
|
|
|
#if 0
|
|
|
|
gchar buff[ NTP_TS_SIZE ];
|
2000-10-19 06:45:11 +00:00
|
|
|
char* ptime = tvb_get_ptr( tvb, offset, 8 );
|
|
|
|
|
|
|
|
/* Retreive the NTP timestamp. Using the NTP dissector for this */
|
2000-10-19 08:17:45 +00:00
|
|
|
ntp_fmt_ts( ptime, buff );
|
2000-10-19 06:45:11 +00:00
|
|
|
proto_tree_add_string_format( tree, hf_rtcp_ntp, tvb, offset, 8, ( const char* ) &buff, "NTP timestamp: %s", &buff );
|
|
|
|
free( ptime ); ??????????????????????????????????????????????????????????????????
|
|
|
|
offset += 8;
|
2000-10-19 08:17:45 +00:00
|
|
|
#else
|
|
|
|
/*
|
|
|
|
* XXX - RFC 1889 says this is an NTP timestamp, but that appears
|
|
|
|
* not to be the case.
|
|
|
|
*/
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 4, "Timestamp, MSW: %u",
|
|
|
|
tvb_get_ntohl(tvb, offset));
|
|
|
|
offset += 4;
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 4, "Timestamp, LSW: %u",
|
|
|
|
tvb_get_ntohl(tvb, offset));
|
|
|
|
offset += 4;
|
|
|
|
#endif
|
2000-10-19 06:45:11 +00:00
|
|
|
/* RTP timestamp, 32 bits */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_rtp_timestamp, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
offset += 4;
|
|
|
|
/* Sender's packet count, 32 bits */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_sender_pkt_cnt, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
offset += 4;
|
|
|
|
/* Sender's octet count, 32 bits */
|
|
|
|
proto_tree_add_uint( tree, hf_rtcp_sender_oct_cnt, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
offset += 4;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/* The rest of the packet is equal to the RR packet */
|
2001-09-03 08:10:46 +00:00
|
|
|
if ( count != 0 )
|
2002-04-09 09:04:33 +00:00
|
|
|
offset = dissect_rtcp_rr( tvb, offset, tree, count );
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
return offset;
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
/* Look for conversation info and display any setup info found */
|
|
|
|
void show_setup_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
/* Conversation and current data */
|
|
|
|
conversation_t *p_conv = NULL;
|
|
|
|
struct _rtcp_conversation_info *p_conv_data = NULL;
|
|
|
|
|
2004-06-30 21:08:58 +00:00
|
|
|
/* Use existing packet data if available */
|
|
|
|
p_conv_data = p_get_proto_data(pinfo->fd, proto_rtcp);
|
|
|
|
|
|
|
|
if (!p_conv_data)
|
2004-06-15 18:26:08 +00:00
|
|
|
{
|
|
|
|
/* First time, get info from conversation */
|
2004-06-29 20:29:57 +00:00
|
|
|
p_conv = find_conversation(&pinfo->net_dst, &pinfo->net_src,
|
|
|
|
pinfo->ptype,
|
|
|
|
pinfo->destport, pinfo->srcport, NO_ADDR_B);
|
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
if (p_conv)
|
|
|
|
{
|
|
|
|
/* Create space for packet info */
|
|
|
|
struct _rtcp_conversation_info *p_conv_packet_data;
|
|
|
|
p_conv_data = conversation_get_proto_data(p_conv, proto_rtcp);
|
|
|
|
|
|
|
|
/* Save this conversation info into packet info */
|
|
|
|
p_conv_packet_data = g_mem_chunk_alloc(rtcp_conversations);
|
|
|
|
strcpy(p_conv_packet_data->method, p_conv_data->method);
|
|
|
|
p_conv_packet_data->frame_number = p_conv_data->frame_number;
|
|
|
|
p_add_proto_data(pinfo->fd, proto_rtcp, p_conv_packet_data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create setup info subtree with summary info. */
|
|
|
|
if (p_conv_data)
|
|
|
|
{
|
|
|
|
proto_tree *rtcp_setup_tree;
|
|
|
|
proto_item *ti = proto_tree_add_string_format(tree, hf_rtcp_setup, tvb, 0, 0,
|
|
|
|
"",
|
|
|
|
"Stream setup by %s (frame %d)",
|
|
|
|
p_conv_data->method,
|
|
|
|
p_conv_data->frame_number);
|
|
|
|
PROTO_ITEM_SET_GENERATED(ti);
|
|
|
|
rtcp_setup_tree = proto_item_add_subtree(ti, ett_rtcp_setup);
|
|
|
|
if (rtcp_setup_tree)
|
|
|
|
{
|
|
|
|
/* Add details into subtree */
|
|
|
|
proto_item* item = proto_tree_add_uint(rtcp_setup_tree, hf_rtcp_setup_frame,
|
|
|
|
tvb, 0, 0, p_conv_data->frame_number);
|
|
|
|
PROTO_ITEM_SET_GENERATED(item);
|
|
|
|
item = proto_tree_add_string(rtcp_setup_tree, hf_rtcp_setup_method,
|
|
|
|
tvb, 0, 0, p_conv_data->method);
|
|
|
|
PROTO_ITEM_SET_GENERATED(item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-11-27 07:13:32 +00:00
|
|
|
static void
|
2000-10-19 06:45:11 +00:00
|
|
|
dissect_rtcp( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
proto_item *ti = NULL;
|
|
|
|
proto_tree *rtcp_tree = NULL;
|
|
|
|
unsigned int temp_byte = 0;
|
|
|
|
unsigned int padding_set = 0;
|
|
|
|
unsigned int elem_count = 0;
|
|
|
|
unsigned int packet_type = 0;
|
|
|
|
unsigned int offset = 0;
|
|
|
|
guint16 packet_length = 0;
|
2004-05-31 19:35:53 +00:00
|
|
|
guint rtcp_subtype = 0;
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if ( check_col( pinfo->cinfo, COL_PROTOCOL ) ) {
|
|
|
|
col_set_str( pinfo->cinfo, COL_PROTOCOL, "RTCP" );
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if ( check_col( pinfo->cinfo, COL_INFO) ) {
|
2000-10-19 06:45:11 +00:00
|
|
|
/* The second octet contains the packet type */
|
|
|
|
/* switch ( pd[ offset + 1 ] ) { */
|
|
|
|
switch ( tvb_get_guint8( tvb, 1 ) ) {
|
|
|
|
case RTCP_SR:
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Sender Report");
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_RR:
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Receiver Report");
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_SDES:
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Source Description");
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_BYE:
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Goodbye");
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_APP:
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Application defined");
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
2004-05-31 19:35:53 +00:00
|
|
|
case RTCP_XR:
|
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Extended report");
|
|
|
|
break;
|
2000-10-19 06:45:11 +00:00
|
|
|
case RTCP_FIR:
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Full Intra-frame Request (H.261)");
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_NACK:
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Negative Acknowledgement (H.261)");
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
default:
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str( pinfo->cinfo, COL_INFO, "Unknown packet type");
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( tree ) {
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
|
|
|
* Check if there are at least 4 bytes left in the frame,
|
|
|
|
* the last 16 bits of those is the length of the current
|
2000-10-19 06:45:11 +00:00
|
|
|
* RTCP message. The last compound message contains padding,
|
|
|
|
* that enables us to break from the while loop.
|
|
|
|
*/
|
2001-04-23 04:35:39 +00:00
|
|
|
while ( tvb_bytes_exist( tvb, offset, 4) ) {
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
2000-10-19 06:45:11 +00:00
|
|
|
* First retreive the packet_type
|
|
|
|
*/
|
|
|
|
packet_type = tvb_get_guint8( tvb, offset + 1 );
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if it's a valid type
|
|
|
|
*/
|
|
|
|
if ( ( packet_type < 192 ) || ( packet_type > 204 ) )
|
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
/*
|
|
|
|
* get the packet-length for the complete RTCP packet
|
|
|
|
*/
|
|
|
|
packet_length = ( tvb_get_ntohs( tvb, offset + 2 ) + 1 ) * 4;
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_rtcp, tvb, offset, packet_length, FALSE );
|
2000-10-19 06:45:11 +00:00
|
|
|
rtcp_tree = proto_item_add_subtree( ti, ett_rtcp );
|
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
|
|
|
|
/* Conversation setup info */
|
|
|
|
if (global_rtcp_show_setup_info)
|
|
|
|
{
|
|
|
|
show_setup_info(tvb, pinfo, rtcp_tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
temp_byte = tvb_get_guint8( tvb, offset );
|
|
|
|
|
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_version, tvb,
|
2003-11-09 22:55:35 +00:00
|
|
|
offset, 1, temp_byte);
|
2000-10-19 06:45:11 +00:00
|
|
|
padding_set = RTCP_PADDING( temp_byte );
|
|
|
|
proto_tree_add_boolean( rtcp_tree, hf_rtcp_padding, tvb,
|
2003-11-09 22:55:35 +00:00
|
|
|
offset, 1, temp_byte );
|
2000-10-19 06:45:11 +00:00
|
|
|
elem_count = RTCP_COUNT( temp_byte );
|
|
|
|
|
|
|
|
switch ( packet_type ) {
|
|
|
|
case RTCP_SR:
|
|
|
|
case RTCP_RR:
|
|
|
|
/* Receiver report count, 5 bits */
|
2003-11-09 22:55:35 +00:00
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_rc, tvb, offset, 1, temp_byte );
|
2000-10-19 06:45:11 +00:00
|
|
|
offset++;
|
|
|
|
/* Packet type, 8 bits */
|
|
|
|
proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
/* Packet length in 32 bit words MINUS one, 16 bits */
|
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
|
|
|
/* Sender Synchronization source, 32 bits */
|
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_ssrc_sender, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
|
|
|
|
offset += 4;
|
|
|
|
|
2002-04-09 09:04:33 +00:00
|
|
|
if ( packet_type == RTCP_SR ) offset = dissect_rtcp_sr( tvb, offset, rtcp_tree, elem_count );
|
|
|
|
else offset = dissect_rtcp_rr( tvb, offset, rtcp_tree, elem_count );
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_SDES:
|
|
|
|
/* Source count, 5 bits */
|
2003-11-09 22:55:35 +00:00
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_sc, tvb, offset, 1, temp_byte );
|
2000-10-19 06:45:11 +00:00
|
|
|
offset++;
|
|
|
|
/* Packet type, 8 bits */
|
|
|
|
proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
/* Packet length in 32 bit words MINUS one, 16 bits */
|
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
2002-04-15 21:25:05 +00:00
|
|
|
dissect_rtcp_sdes( tvb, offset, rtcp_tree, elem_count );
|
|
|
|
offset += packet_length - 4;
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_BYE:
|
|
|
|
/* Source count, 5 bits */
|
2003-11-09 22:55:35 +00:00
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_sc, tvb, offset, 1, temp_byte );
|
2000-10-19 06:45:11 +00:00
|
|
|
offset++;
|
|
|
|
/* Packet type, 8 bits */
|
|
|
|
proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
/* Packet length in 32 bit words MINUS one, 16 bits */
|
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
2002-04-09 09:04:33 +00:00
|
|
|
offset = dissect_rtcp_bye( tvb, offset, rtcp_tree, elem_count );
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_APP:
|
|
|
|
/* Subtype, 5 bits */
|
2004-05-31 19:35:53 +00:00
|
|
|
rtcp_subtype = elem_count;
|
2000-10-19 06:45:11 +00:00
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_subtype, tvb, offset, 1, elem_count );
|
|
|
|
offset++;
|
|
|
|
/* Packet type, 8 bits */
|
|
|
|
proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
|
|
|
|
offset++;
|
|
|
|
/* Packet length in 32 bit words MINUS one, 16 bits */
|
|
|
|
proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
|
|
|
|
offset += 2;
|
2004-05-31 19:35:53 +00:00
|
|
|
offset = dissect_rtcp_app( tvb, pinfo, offset,
|
2002-04-09 09:04:33 +00:00
|
|
|
rtcp_tree, padding_set,
|
2004-05-31 19:35:53 +00:00
|
|
|
packet_length - 4, rtcp_subtype );
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_FIR:
|
2002-04-09 09:04:33 +00:00
|
|
|
offset = dissect_rtcp_fir( tvb, offset, rtcp_tree );
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
case RTCP_NACK:
|
2002-04-09 09:04:33 +00:00
|
|
|
offset = dissect_rtcp_nack( tvb, offset, rtcp_tree );
|
2000-10-19 06:45:11 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* To prevent endless loops in case of an unknown message type
|
|
|
|
* increase offset. Some time the while will end :-)
|
|
|
|
*/
|
|
|
|
offset++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
/* If the padding bit is set, the last octet of the
|
|
|
|
* packet contains the length of the padding
|
2000-10-19 06:45:11 +00:00
|
|
|
* We only have to check for this at the end of the LAST RTCP message
|
|
|
|
*/
|
|
|
|
if ( padding_set ) {
|
2002-08-28 21:04:11 +00:00
|
|
|
/* If everything went according to plan offset should now point to the
|
|
|
|
* first octet of the padding
|
2000-10-19 06:45:11 +00:00
|
|
|
*/
|
|
|
|
proto_tree_add_item( rtcp_tree, hf_rtcp_padding_data, tvb, offset, tvb_length_remaining( tvb, offset) - 1, FALSE );
|
|
|
|
offset += tvb_length_remaining( tvb, offset) - 1;
|
|
|
|
proto_tree_add_item( rtcp_tree, hf_rtcp_padding_count, tvb, offset, 1, FALSE );
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
proto_register_rtcp(void)
|
|
|
|
{
|
2002-08-28 21:04:11 +00:00
|
|
|
static hf_register_info hf[] =
|
2000-10-19 06:45:11 +00:00
|
|
|
{
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_version,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Version",
|
|
|
|
"rtcp.version",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
VALS(rtcp_version_vals),
|
2003-11-09 22:55:35 +00:00
|
|
|
0xC0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_padding,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Padding",
|
|
|
|
"rtcp.padding",
|
|
|
|
FT_BOOLEAN,
|
2003-11-09 22:55:35 +00:00
|
|
|
8,
|
2002-08-28 21:04:11 +00:00
|
|
|
NULL,
|
2003-11-09 22:55:35 +00:00
|
|
|
0x20,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_rc,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Reception report count",
|
|
|
|
"rtcp.rc",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2003-11-09 22:55:35 +00:00
|
|
|
0x1F,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_sc,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Source count",
|
|
|
|
"rtcp.sc",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2003-11-09 22:55:35 +00:00
|
|
|
0x1F,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_pt,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Packet type",
|
|
|
|
"rtcp.pt",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
VALS( rtcp_packet_type_vals ),
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_length,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Length",
|
|
|
|
"rtcp.length",
|
|
|
|
FT_UINT16,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_sender,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Sender SSRC",
|
|
|
|
"rtcp.senderssrc",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ntp,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"NTP timestamp",
|
|
|
|
"rtcp.timestamp.ntp",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_rtp_timestamp,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"RTP timestamp",
|
|
|
|
"rtcp.timestamp.rtp",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_sender_pkt_cnt,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Sender's packet count",
|
|
|
|
"rtcp.sender.packetcount",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_sender_oct_cnt,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Sender's octet count",
|
|
|
|
"rtcp.sender.octetcount",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_source,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Identifier",
|
|
|
|
"rtcp.ssrc.identifier",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_fraction,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Fraction lost",
|
|
|
|
"rtcp.ssrc.fraction",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_cum_nr,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Cumulative number of packets lost",
|
|
|
|
"rtcp.ssrc.cum_nr",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_ext_high_seq,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Extended highest sequence number received",
|
|
|
|
"rtcp.ssrc.ext_high",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_high_seq,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Highest sequence number received",
|
|
|
|
"rtcp.ssrc.high_seq",
|
|
|
|
FT_UINT16,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_high_cycles,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Sequence number cycles count",
|
|
|
|
"rtcp.ssrc.high_cycles",
|
|
|
|
FT_UINT16,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_jitter,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Interarrival jitter",
|
|
|
|
"rtcp.ssrc.jitter",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_lsr,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Last SR timestamp",
|
|
|
|
"rtcp.ssrc.lsr",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_dlsr,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Delay since last SR timestamp",
|
|
|
|
"rtcp.ssrc.dlsr",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_csrc,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"SSRC / CSRC identifier",
|
|
|
|
"rtcp.sdes.ssrc_csrc",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_type,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Type",
|
|
|
|
"rtcp.sdes.type",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
VALS( rtcp_sdes_type_vals ),
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_length,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Length",
|
|
|
|
"rtcp.sdes.length",
|
|
|
|
FT_UINT32,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_text,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Text",
|
|
|
|
"rtcp.sdes.text",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_prefix_len,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Prefix length",
|
|
|
|
"rtcp.sdes.prefix.length",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_ssrc_prefix_string,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Prefix string",
|
|
|
|
"rtcp.sdes.prefix.string",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_subtype,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Subtype",
|
|
|
|
"rtcp.app.subtype",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_name_ascii,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Name (ASCII)",
|
|
|
|
"rtcp.app.name",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_app_data,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Application specific data",
|
|
|
|
"rtcp.app.data",
|
|
|
|
FT_BYTES,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2004-05-31 19:35:53 +00:00
|
|
|
{
|
2004-06-15 18:26:08 +00:00
|
|
|
&hf_rtcp_app_poc1_subtype,
|
2004-05-31 19:35:53 +00:00
|
|
|
{
|
|
|
|
"Subtype",
|
|
|
|
"rtcp.app.PoC1.subtype",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
VALS(rtcp_app_poc1_floor_cnt_type_vals),
|
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_app_poc1_sip_uri,
|
2004-06-01 18:58:04 +00:00
|
|
|
{
|
2004-05-31 19:35:53 +00:00
|
|
|
"SIP URI",
|
|
|
|
"rtcp.app.poc1.sip.uri",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_app_poc1_disp_name,
|
2004-06-01 18:58:04 +00:00
|
|
|
{
|
2004-05-31 19:35:53 +00:00
|
|
|
"Display Name",
|
|
|
|
"rtcp.app.poc1.disp.name",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_app_poc1_last_pkt_seq_no,
|
2004-06-01 18:58:04 +00:00
|
|
|
{
|
2004-05-31 19:35:53 +00:00
|
|
|
"Seq. no of last RTP packet",
|
|
|
|
"rtcp.app.poc1.last.pkt.seq.no",
|
|
|
|
FT_UINT16,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_app_poc1_reason_code1,
|
2004-06-01 18:58:04 +00:00
|
|
|
{
|
2004-05-31 19:35:53 +00:00
|
|
|
"Reason code",
|
|
|
|
"rtcp.app.poc1.reason.code",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
2004-06-01 18:58:04 +00:00
|
|
|
VALS(rtcp_app_poc1_reason_code1_vals),
|
2004-05-31 19:35:53 +00:00
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_app_poc1_item_len,
|
2004-06-01 18:58:04 +00:00
|
|
|
{
|
2004-05-31 19:35:53 +00:00
|
|
|
"Item length",
|
|
|
|
"rtcp.app.poc1.item.len",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_app_poc1_reason1_phrase,
|
2004-06-01 18:58:04 +00:00
|
|
|
{
|
2004-05-31 19:35:53 +00:00
|
|
|
"Reason Phrase",
|
|
|
|
"rtcp.app.poc1.reason.phrase",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_app_poc1_reason_code2,
|
2004-06-01 18:58:04 +00:00
|
|
|
{
|
2004-05-31 19:35:53 +00:00
|
|
|
"Reason code",
|
|
|
|
"rtcp.app.poc1.reason.code",
|
|
|
|
FT_UINT16,
|
|
|
|
BASE_DEC,
|
|
|
|
VALS(rtcp_app_poc1_reason_code2_vals),
|
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_app_poc1_additionalinfo,
|
2004-06-01 18:58:04 +00:00
|
|
|
{
|
2004-05-31 19:35:53 +00:00
|
|
|
"additional information",
|
|
|
|
"rtcp.app.poc1.add.info",
|
|
|
|
FT_UINT16,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"", HFILL
|
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_fsn,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"First sequence number",
|
|
|
|
"rtcp.nack.fsn",
|
|
|
|
FT_UINT16,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_blp,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Bitmask of following lost packets",
|
|
|
|
"rtcp.nack.blp",
|
|
|
|
FT_UINT16,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_padding_count,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Padding count",
|
|
|
|
"rtcp.padding.count",
|
|
|
|
FT_UINT8,
|
|
|
|
BASE_DEC,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2000-10-19 06:45:11 +00:00
|
|
|
&hf_rtcp_padding_data,
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
|
|
|
"Padding data",
|
|
|
|
"rtcp.padding.data",
|
|
|
|
FT_BYTES,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
2000-10-19 06:45:11 +00:00
|
|
|
0x0,
|
2002-08-28 21:04:11 +00:00
|
|
|
"", HFILL
|
2000-10-19 06:45:11 +00:00
|
|
|
}
|
|
|
|
},
|
2004-06-15 18:26:08 +00:00
|
|
|
{
|
|
|
|
&hf_rtcp_setup,
|
|
|
|
{
|
|
|
|
"Stream setup",
|
|
|
|
"rtcp.setup",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"Stream setup, method and frame number", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_setup_frame,
|
|
|
|
{
|
|
|
|
"Setup frame",
|
|
|
|
"rtcp.setup-frame",
|
|
|
|
FT_FRAMENUM,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"Frame that set up this stream", HFILL
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
&hf_rtcp_setup_method,
|
|
|
|
{
|
|
|
|
"Setup Method",
|
|
|
|
"rtcp.setup-method",
|
|
|
|
FT_STRING,
|
|
|
|
BASE_NONE,
|
|
|
|
NULL,
|
|
|
|
0x0,
|
|
|
|
"Method used to set up this stream", HFILL
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-06-01 18:58:04 +00:00
|
|
|
};
|
2002-08-28 21:04:11 +00:00
|
|
|
|
|
|
|
static gint *ett[] =
|
2000-10-19 06:45:11 +00:00
|
|
|
{
|
2000-04-21 01:45:58 +00:00
|
|
|
&ett_rtcp,
|
2000-10-19 06:45:11 +00:00
|
|
|
&ett_ssrc,
|
|
|
|
&ett_ssrc_item,
|
|
|
|
&ett_ssrc_ext_high,
|
|
|
|
&ett_sdes,
|
|
|
|
&ett_sdes_item,
|
2004-05-31 19:35:53 +00:00
|
|
|
&ett_PoC1,
|
2004-06-15 18:26:08 +00:00
|
|
|
&ett_rtcp_setup
|
2000-04-21 01:45:58 +00:00
|
|
|
};
|
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
module_t *rtcp_module;
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_rtcp = proto_register_protocol("Real-time Transport Control Protocol",
|
|
|
|
"RTCP", "rtcp");
|
2000-10-19 06:45:11 +00:00
|
|
|
proto_register_field_array(proto_rtcp, hf, array_length(hf));
|
2000-04-21 01:45:58 +00:00
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2000-10-19 06:45:11 +00:00
|
|
|
|
2001-09-08 00:43:51 +00:00
|
|
|
register_dissector("rtcp", dissect_rtcp, proto_rtcp);
|
|
|
|
|
2004-06-15 18:26:08 +00:00
|
|
|
rtcp_module = prefs_register_protocol(proto_rtcp, NULL);
|
|
|
|
|
|
|
|
prefs_register_bool_preference(rtcp_module, "show_setup_info",
|
|
|
|
"Show stream setup information",
|
|
|
|
"Where available, show which protocol and frame caused "
|
|
|
|
"this RTCP stream to be created",
|
|
|
|
&global_rtcp_show_setup_info);
|
|
|
|
|
2000-10-19 06:45:11 +00:00
|
|
|
register_init_routine( &rtcp_init );
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
Add tables of "conversation" dissectors, which are associated with
particular protocols, and which keep track of all dissectors that could
be associated with conversations using those particular protocols - for
example, the RTP and RTCP dissectors could be assigned to UDP
conversations.
This is for future use with UI features allowing the dissector for a
given conversation to be set from the UI, to allow
1) conversations between two ports, both of which have
dissectors associated with them, that have been given to the
wrong dissector to be given to the right dissector;
2) conversations between two ports, neither of which have
dissectors associated with them, to be given to a dissector
(RTP and RTCP, for example, typically run on random ports,
and if you don't have, in a capture, traffic that would say
"OK, traffic between these two hosts and ports will be RTP
traffic", you may have to tell Ethereal explicitly what
protocol the conversation is).
svn path=/trunk/; revision=2848
2001-01-09 05:53:21 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_rtcp(void)
|
|
|
|
{
|
|
|
|
/*
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
* Register this dissector as one that can be selected by a
|
|
|
|
* UDP port number.
|
Add tables of "conversation" dissectors, which are associated with
particular protocols, and which keep track of all dissectors that could
be associated with conversations using those particular protocols - for
example, the RTP and RTCP dissectors could be assigned to UDP
conversations.
This is for future use with UI features allowing the dissector for a
given conversation to be set from the UI, to allow
1) conversations between two ports, both of which have
dissectors associated with them, that have been given to the
wrong dissector to be given to the right dissector;
2) conversations between two ports, neither of which have
dissectors associated with them, to be given to a dissector
(RTP and RTCP, for example, typically run on random ports,
and if you don't have, in a capture, traffic that would say
"OK, traffic between these two hosts and ports will be RTP
traffic", you may have to tell Ethereal explicitly what
protocol the conversation is).
svn path=/trunk/; revision=2848
2001-01-09 05:53:21 +00:00
|
|
|
*/
|
2001-12-03 04:00:26 +00:00
|
|
|
rtcp_handle = find_dissector("rtcp");
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
dissector_add_handle("udp.port", rtcp_handle);
|
Add tables of "conversation" dissectors, which are associated with
particular protocols, and which keep track of all dissectors that could
be associated with conversations using those particular protocols - for
example, the RTP and RTCP dissectors could be assigned to UDP
conversations.
This is for future use with UI features allowing the dissector for a
given conversation to be set from the UI, to allow
1) conversations between two ports, both of which have
dissectors associated with them, that have been given to the
wrong dissector to be given to the right dissector;
2) conversations between two ports, neither of which have
dissectors associated with them, to be given to a dissector
(RTP and RTCP, for example, typically run on random ports,
and if you don't have, in a capture, traffic that would say
"OK, traffic between these two hosts and ports will be RTP
traffic", you may have to tell Ethereal explicitly what
protocol the conversation is).
svn path=/trunk/; revision=2848
2001-01-09 05:53:21 +00:00
|
|
|
}
|