3 * Routines for RTCP dissection
4 * RTCP = Real-time Transport Control Protocol
6 * Copyright 2000, Philips Electronics N.V.
7 * Written by Andreas Sikkema <andreas.sikkema@philips.com>
9 * Ethereal - Network traffic analyzer
10 * By Gerald Combs <gerald@zing.org>
11 * Copyright 1998 Gerald Combs
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version 2
17 * of the License, or (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
30 * This dissector tries to dissect the RTCP protocol according to Annex A
31 * of ITU-T Recommendation H.225.0 (02/98) and RFC 1889
32 * H.225.0 literally copies RFC 1889, but omitting a few sections.
34 * RTCP traffic is handled by an uneven UDP portnumber. This can be any
35 * port number, but there is a registered port available, port 5005
36 * See Annex B of ITU-T Recommendation H.225.0, section B.7
48 #ifdef HAVE_SYS_TYPES_H
49 # include <sys/types.h>
52 #ifdef HAVE_NETINET_IN_H
53 # include <netinet/in.h>
59 #include "packet-rtcp.h"
61 #include "packet-ntp.h"
63 #include "conversation.h"
65 /* Version is the first 2 bits of the first octet*/
66 #define RTCP_VERSION(octet) ((octet) >> 6)
68 /* Padding is the third bit; no need to shift, because true is any value
70 #define RTCP_PADDING(octet) ((octet) & 0x20)
72 /* Receiver/ Sender count is the 5 last bits */
73 #define RTCP_COUNT(octet) ((octet) & 0x1F)
75 static const value_string rtcp_version_vals[] =
77 { 0, "Old VAT Version" },
78 { 1, "First Draft Version" },
79 { 2, "RFC 1889 Version" },
83 /* RTCP packet types according to Section A.11.1 */
89 /* Supplemental H.261 specific RTCP packet types according to Section C.3.5 */
93 static const value_string rtcp_packet_type_vals[] =
95 { RTCP_SR, "Sender Report" },
96 { RTCP_RR, "Receiver Report" },
97 { RTCP_SDES, "Source description" },
98 { RTCP_BYE, "Goodbye" },
99 { RTCP_APP, "Application specific" },
100 { RTCP_FIR, "Full Intra-frame Request (H.261)" },
101 { RTCP_NACK, "Negative Acknowledgement (H.261)" },
105 /* RTCP SDES types (Section A.11.2) */
106 #define RTCP_SDES_END 0
107 #define RTCP_SDES_CNAME 1
108 #define RTCP_SDES_NAME 2
109 #define RTCP_SDES_EMAIL 3
110 #define RTCP_SDES_PHONE 4
111 #define RTCP_SDES_LOC 5
112 #define RTCP_SDES_TOOL 6
113 #define RTCP_SDES_NOTE 7
114 #define RTCP_SDES_PRIV 8
116 static const value_string rtcp_sdes_type_vals[] =
118 { RTCP_SDES_END, "END" },
119 { RTCP_SDES_CNAME, "CNAME (user and domain)" },
120 { RTCP_SDES_NAME, "NAME (common name)" },
121 { RTCP_SDES_EMAIL, "EMAIL (e-mail address)" },
122 { RTCP_SDES_PHONE, "PHONE (phone number)" },
123 { RTCP_SDES_LOC, "LOC (geographic location)" },
124 { RTCP_SDES_TOOL, "TOOL (name/version of source app)" },
125 { RTCP_SDES_NOTE, "NOTE (note about source)" },
126 { RTCP_SDES_PRIV, "PRIV (private extensions)" },
130 /* RTCP header fields */
131 static int proto_rtcp = -1;
132 static int hf_rtcp_version = -1;
133 static int hf_rtcp_padding = -1;
134 static int hf_rtcp_rc = -1;
135 static int hf_rtcp_sc = -1;
136 static int hf_rtcp_pt = -1;
137 static int hf_rtcp_length = -1;
138 static int hf_rtcp_ssrc_sender = -1;
139 static int hf_rtcp_ntp = -1;
140 static int hf_rtcp_rtp_timestamp = -1;
141 static int hf_rtcp_sender_pkt_cnt = -1;
142 static int hf_rtcp_sender_oct_cnt = -1;
143 static int hf_rtcp_ssrc_source = -1;
144 static int hf_rtcp_ssrc_fraction = -1;
145 static int hf_rtcp_ssrc_cum_nr = -1;
146 /* First the 32 bit number, then the split
147 * up 16 bit values */
148 /* These two are added to a subtree */
149 static int hf_rtcp_ssrc_ext_high_seq = -1;
150 static int hf_rtcp_ssrc_high_seq = -1;
151 static int hf_rtcp_ssrc_high_cycles = -1;
152 static int hf_rtcp_ssrc_jitter = -1;
153 static int hf_rtcp_ssrc_lsr = -1;
154 static int hf_rtcp_ssrc_dlsr = -1;
155 static int hf_rtcp_ssrc_csrc = -1;
156 static int hf_rtcp_ssrc_type = -1;
157 static int hf_rtcp_ssrc_length = -1;
158 static int hf_rtcp_ssrc_text = -1;
159 static int hf_rtcp_ssrc_prefix_len = -1;
160 static int hf_rtcp_ssrc_prefix_string= -1;
161 static int hf_rtcp_subtype = -1;
162 static int hf_rtcp_name_ascii = -1;
163 static int hf_rtcp_app_data = -1;
164 static int hf_rtcp_fsn = -1;
165 static int hf_rtcp_blp = -1;
166 static int hf_rtcp_padding_count = -1;
167 static int hf_rtcp_padding_data = -1;
169 /* RTCP fields defining a sub tree */
170 static gint ett_rtcp = -1;
171 static gint ett_ssrc = -1;
172 static gint ett_ssrc_item = -1;
173 static gint ett_ssrc_ext_high = -1;
174 static gint ett_sdes = -1;
175 static gint ett_sdes_item = -1;
177 static address fake_addr;
178 static int heur_init = FALSE;
180 static char rtcp_proto[] = "RTCP";
182 static gboolean dissect_rtcp_heur( tvbuff_t *tvb, packet_info *pinfo,
185 void rtcp_add_address( const unsigned char* ip_addr, int prt )
188 conversation_t* pconv = ( conversation_t* ) NULL;
190 src_addr.type = AT_IPv4;
192 src_addr.data = ip_addr;
195 * The first time the function is called let the udp dissector
196 * know that we're interested in traffic
199 heur_dissector_add( "udp", dissect_rtcp_heur, proto_rtcp );
204 * Check if the ip address and port combination is not
207 pconv = find_conversation( &src_addr, &fake_addr, PT_UDP, prt, 0, 0 );
213 conversation_new( &src_addr, &fake_addr, PT_UDP, (guint32) prt,
214 (guint32) 0, (void*) rtcp_proto, 0 );
220 static void rtcp_init( void )
222 unsigned char* tmp_data;
225 /* Create a fake adddress... */
226 fake_addr.type = AT_IPv4;
229 tmp_data = malloc( fake_addr.len );
230 for ( i = 0; i < fake_addr.len; i++) {
233 fake_addr.data = tmp_data;
238 dissect_rtcp_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
240 conversation_t* pconv;
242 if (!proto_is_protocol_enabled(proto_rtcp))
243 return FALSE; /* RTCP has been disabled */
245 /* This is a heuristic dissector, which means we get all the UDP
246 * traffic not sent to a known dissector and not claimed by
247 * a heuristic dissector called before us!
248 * So we first check if the frame is really meant for us.
250 if ( ( pconv = find_conversation( &pi.src, &fake_addr, pi.ptype,
251 pi.srcport, 0, 0 ) ) == NULL ) {
253 * The source ip:port combination was not what we were
254 * looking for, check the destination
256 if ( ( pconv = find_conversation( &pi.dst, &fake_addr,
257 pi.ptype, pi.destport, 0, 0 ) ) == NULL ) {
264 * An RTCP conversation always contains data
266 if ( pconv->data == NULL )
270 * An RTCP conversation data always contains "RTCP"
272 if ( strcmp( pconv->data, rtcp_proto ) != 0 )
276 * The message is a valid RTCP message!
278 dissect_rtcp( tvb, pinfo, tree );
285 dissect_rtcp_nack( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree )
287 /* Packet type = FIR (H261) */
288 proto_tree_add_uint( tree, hf_rtcp_rc, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 31 );
290 /* Packet type, 8 bits = APP */
291 proto_tree_add_item( tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
294 /* Packet length in 32 bit words minus one */
295 proto_tree_add_uint( tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
299 proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
303 proto_tree_add_uint( tree, hf_rtcp_fsn, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
307 proto_tree_add_uint( tree, hf_rtcp_blp, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
314 dissect_rtcp_fir( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree )
316 /* Packet type = FIR (H261) */
317 proto_tree_add_uint( tree, hf_rtcp_rc, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 31 );
319 /* Packet type, 8 bits = APP */
320 proto_tree_add_item( tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
323 /* Packet length in 32 bit words minus one */
324 proto_tree_add_uint( tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
328 proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
335 dissect_rtcp_app( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree,
336 unsigned int padding, unsigned int packet_len )
338 unsigned int counter = 0;
342 proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
347 for( counter = 0; counter < 4; counter++ )
348 ascii_name[ counter ] = tvb_get_guint8( tvb, offset + counter );
349 /* strncpy( ascii_name, pd + offset, 4 ); */
350 ascii_name[4] = '\0';
351 proto_tree_add_string( tree, hf_rtcp_name_ascii, tvb, offset, 4,
356 /* Applications specific data */
358 /* If there's padding present, we have to remove that from the data part
359 * The last octet of the packet contains the length of the padding
361 packet_len -= tvb_get_guint8( tvb, offset + packet_len - 1 );
363 proto_tree_add_item( tree, hf_rtcp_app_data, tvb, offset, packet_len, FALSE );
364 offset += packet_len;
370 dissect_rtcp_bye( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree,
373 unsigned int chunk = 1;
374 unsigned int reason_length = 0;
375 unsigned int counter = 0;
376 char* reason_text = NULL;
378 while ( chunk <= count ) {
379 /* source identifier, 32 bits */
380 proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
384 /* Bye reason consists of an 8 bit length l and a string with length l */
385 reason_length = tvb_get_guint8( tvb, offset );
386 proto_tree_add_item( tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
389 reason_text = ( char* ) malloc( reason_length + 1 );
390 for ( counter = 0; counter < reason_length; counter++ ) reason_text[ counter ] = tvb_get_guint8( tvb, offset + counter );
391 /* strncpy( reason_text, pd + offset, reason_length ); */
392 reason_text[ reason_length ] = '\0';
393 proto_tree_add_string( tree, hf_rtcp_ssrc_text, tvb, offset, reason_length, reason_text );
395 offset += reason_length;
402 dissect_rtcp_sdes( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree,
405 unsigned int chunk = 1;
406 proto_item *sdes_item;
407 proto_tree *sdes_tree;
408 proto_tree *sdes_item_tree;
411 int items_start_offset;
413 unsigned int item_len = 0;
414 unsigned int sdes_type = 0;
415 unsigned int counter = 0;
416 unsigned int prefix_len = 0;
417 char *prefix_string = NULL;
419 while ( chunk <= count ) {
420 /* Create a subtree for this chunk; we don't yet know
422 start_offset = offset;
424 ssrc = tvb_get_ntohl( tvb, offset );
425 sdes_item = proto_tree_add_text(tree, tvb, offset, 0,
426 "Chunk %u, SSRC/CSRC %u", chunk, ssrc);
427 sdes_tree = proto_item_add_subtree( sdes_item, ett_sdes );
429 /* SSRC_n source identifier, 32 bits */
430 proto_tree_add_uint( sdes_tree, hf_rtcp_ssrc_source, tvb, offset, 4, ssrc );
433 /* Create a subtree for the SDES items; we don't yet know
435 items_start_offset = offset;
436 ti = proto_tree_add_text(sdes_tree, tvb, offset, 0,
438 sdes_item_tree = proto_item_add_subtree( ti, ett_sdes_item );
441 * Not every message is ended with "null" bytes, so check for
442 * end of frame instead.
444 while ( ( tvb_get_guint8( tvb, offset ) != RTCP_SDES_END )
445 && ( tvb_length_remaining( tvb, offset) >= 2 ) ) {
446 /* while ( ( pd[ offset ] != RTCP_SDES_END ) && ( BYTES_ARE_IN_FRAME( offset, 2 ) ) ) { */
448 sdes_type = tvb_get_guint8( tvb, offset );
449 proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_type, tvb, offset, 1, FALSE );
452 /* Item length, 8 bits */
453 item_len = tvb_get_guint8( tvb, offset );
454 proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
457 if ( sdes_type == RTCP_SDES_PRIV ) {
458 /* PRIV adds two items between the SDES length
459 * and value - an 8 bit length giving the
460 * length of a "prefix string", and the string.
462 prefix_len = tvb_get_guint8( tvb, offset );
463 proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_prefix_len, tvb, offset, 1, FALSE );
466 prefix_string = ( char * ) malloc( prefix_len + 1 );
467 for ( counter = 0; counter < prefix_len; counter++ )
468 prefix_string[ counter ] =
469 tvb_get_guint8( tvb, offset + counter );
470 /* strncpy( prefix_string, pd + offset, prefix_len ); */
471 prefix_string[ prefix_len ] = '\0';
472 proto_tree_add_string( sdes_item_tree, hf_rtcp_ssrc_prefix_string, tvb, offset, prefix_len, prefix_string );
473 free( prefix_string );
474 offset += prefix_len;
476 prefix_string = ( char * ) malloc( item_len + 1 );
477 for ( counter = 0; counter < item_len; counter++ )
478 prefix_string[ counter ] =
479 tvb_get_guint8( tvb, offset + counter );
480 /* strncpy( prefix_string, pd + offset, item_len ); */
481 prefix_string[ item_len] = 0;
482 proto_tree_add_string( sdes_item_tree, hf_rtcp_ssrc_text, tvb, offset, item_len, prefix_string );
483 free( prefix_string );
487 /* Set the length of the items subtree. */
488 proto_item_set_len(ti, offset - items_start_offset);
490 /* 32 bits = 4 bytes, so.....
491 * If offset % 4 != 0, we divide offset by 4, add one and then
492 * multiply by 4 again to reach the boundary
494 if ( offset % 4 != 0 )
495 offset = ((offset / 4) + 1 ) * 4;
497 /* Set the length of this chunk. */
498 proto_item_set_len(sdes_item, offset - start_offset);
508 dissect_rtcp_rr( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree,
511 unsigned int counter = 1;
512 proto_tree *ssrc_tree = (proto_tree*) NULL;
513 proto_tree *ssrc_sub_tree = (proto_tree*) NULL;
514 proto_tree *high_sec_tree = (proto_tree*) NULL;
515 proto_item *ti = (proto_item*) NULL;
517 unsigned int cum_nr = 0;
519 while ( counter <= count ) {
520 /* Create a new subtree for a length of 24 bytes */
521 ti = proto_tree_add_text(tree, tvb, offset, 24,
522 "Source %u", counter );
523 ssrc_tree = proto_item_add_subtree( ti, ett_ssrc );
525 /* SSRC_n source identifier, 32 bits */
526 proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
529 ti = proto_tree_add_text(ssrc_tree, tvb, offset, 20, "SSRC contents" );
530 ssrc_sub_tree = proto_item_add_subtree( ti, ett_ssrc_item );
532 /* Fraction lost, 8bits */
533 rr_flt = tvb_get_guint8( tvb, offset );
534 proto_tree_add_uint_format( ssrc_sub_tree, hf_rtcp_ssrc_fraction, tvb,
535 offset, 1, rr_flt, "Fraction lost: %u / 256", rr_flt );
538 /* Cumulative number of packets lost, 24 bits */
539 cum_nr = tvb_get_ntohl( tvb, offset ) >> 8;
540 proto_tree_add_uint( ssrc_sub_tree, hf_rtcp_ssrc_cum_nr, tvb,
544 /* Extended highest sequence nr received, 32 bits
545 * Just for the sake of it, let's add another subtree
546 * because this might be a little clearer
548 ti = proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_ext_high_seq,
549 tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
550 high_sec_tree = proto_item_add_subtree( ti, ett_ssrc_ext_high );
551 /* Sequence number cycles */
552 proto_tree_add_uint( high_sec_tree, hf_rtcp_ssrc_high_cycles,
553 tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
555 /* highest sequence number received */
556 proto_tree_add_uint( high_sec_tree, hf_rtcp_ssrc_high_seq,
557 tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
560 /* Interarrival jitter */
561 proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_jitter, tvb,
562 offset, 4, tvb_get_ntohl( tvb, offset ) );
565 /* Last SR timestamp */
566 proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_lsr, tvb,
567 offset, 4, tvb_get_ntohl( tvb, offset ) );
570 /* Delay since last SR timestamp */
571 proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_dlsr, tvb,
572 offset, 4, tvb_get_ntohl( tvb, offset ) );
581 dissect_rtcp_sr( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree,
585 gchar buff[ NTP_TS_SIZE ];
586 char* ptime = tvb_get_ptr( tvb, offset, 8 );
588 /* Retreive the NTP timestamp. Using the NTP dissector for this */
589 ntp_fmt_ts( ptime, buff );
590 proto_tree_add_string_format( tree, hf_rtcp_ntp, tvb, offset, 8, ( const char* ) &buff, "NTP timestamp: %s", &buff );
591 free( ptime ); ??????????????????????????????????????????????????????????????????
595 * XXX - RFC 1889 says this is an NTP timestamp, but that appears
596 * not to be the case.
598 proto_tree_add_text(tree, tvb, offset, 4, "Timestamp, MSW: %u",
599 tvb_get_ntohl(tvb, offset));
601 proto_tree_add_text(tree, tvb, offset, 4, "Timestamp, LSW: %u",
602 tvb_get_ntohl(tvb, offset));
605 /* RTP timestamp, 32 bits */
606 proto_tree_add_uint( tree, hf_rtcp_rtp_timestamp, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
608 /* Sender's packet count, 32 bits */
609 proto_tree_add_uint( tree, hf_rtcp_sender_pkt_cnt, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
611 /* Sender's octet count, 32 bits */
612 proto_tree_add_uint( tree, hf_rtcp_sender_oct_cnt, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
615 /* The rest of the packet is equal to the RR packet */
617 offset = dissect_rtcp_rr( tvb, offset, fd, tree, count );
623 dissect_rtcp( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
625 proto_item *ti = NULL;
626 proto_tree *rtcp_tree = NULL;
627 unsigned int temp_byte = 0;
628 unsigned int padding_set = 0;
629 unsigned int elem_count = 0;
630 unsigned int packet_type = 0;
631 unsigned int offset = 0;
632 guint16 packet_length = 0;
634 CHECK_DISPLAY_AS_DATA(proto_rtcp, tvb, pinfo, tree);
636 pinfo->current_proto = "RTCP";
638 if ( check_col( pinfo->fd, COL_PROTOCOL ) ) {
639 col_set_str( pinfo->fd, COL_PROTOCOL, "RTCP" );
642 if ( check_col( pinfo->fd, COL_INFO) ) {
643 /* The second octet contains the packet type */
644 /* switch ( pd[ offset + 1 ] ) { */
645 switch ( tvb_get_guint8( tvb, 1 ) ) {
647 col_set_str( pinfo->fd, COL_INFO, "Sender Report");
650 col_set_str( pinfo->fd, COL_INFO, "Receiver Report");
653 col_set_str( pinfo->fd, COL_INFO, "Source Description");
656 col_set_str( pinfo->fd, COL_INFO, "Goodbye");
659 col_set_str( pinfo->fd, COL_INFO, "Application defined");
662 col_set_str( pinfo->fd, COL_INFO, "Full Intra-frame Request (H.261)");
665 col_set_str( pinfo->fd, COL_INFO, "Negative Acknowledgement (H.261)");
668 col_set_str( pinfo->fd, COL_INFO, "Unknown packet type");
676 * Check if there are at least 4 bytes left in the frame,
677 * the last 16 bits of those is the length of the current
678 * RTCP message. The last compound message contains padding,
679 * that enables us to break from the while loop.
681 /* while ( BYTES_ARE_IN_FRAME( offset, 4 ) ) { */
682 while ( tvb_length_remaining( tvb, offset) >= 4 ) {
684 * First retreive the packet_type
686 packet_type = tvb_get_guint8( tvb, offset + 1 );
689 * Check if it's a valid type
691 if ( ( packet_type < 192 ) || ( packet_type > 204 ) )
695 * get the packet-length for the complete RTCP packet
697 packet_length = ( tvb_get_ntohs( tvb, offset + 2 ) + 1 ) * 4;
699 ti = proto_tree_add_item(tree, proto_rtcp, tvb, offset, packet_length, FALSE );
700 rtcp_tree = proto_item_add_subtree( ti, ett_rtcp );
702 temp_byte = tvb_get_guint8( tvb, offset );
704 proto_tree_add_uint( rtcp_tree, hf_rtcp_version, tvb,
705 offset, 1, RTCP_VERSION( temp_byte ) );
706 padding_set = RTCP_PADDING( temp_byte );
707 proto_tree_add_boolean( rtcp_tree, hf_rtcp_padding, tvb,
708 offset, 1, padding_set );
709 elem_count = RTCP_COUNT( temp_byte );
711 switch ( packet_type ) {
714 /* Receiver report count, 5 bits */
715 proto_tree_add_uint( rtcp_tree, hf_rtcp_rc, tvb, offset, 1, elem_count );
717 /* Packet type, 8 bits */
718 proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
720 /* Packet length in 32 bit words MINUS one, 16 bits */
721 proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
723 /* Sender Synchronization source, 32 bits */
724 proto_tree_add_uint( rtcp_tree, hf_rtcp_ssrc_sender, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
727 if ( packet_type == RTCP_SR ) offset = dissect_rtcp_sr( tvb, offset, pinfo->fd, rtcp_tree, elem_count );
728 else offset = dissect_rtcp_rr( tvb, offset, pinfo->fd, rtcp_tree, elem_count );
731 /* Source count, 5 bits */
732 proto_tree_add_uint( rtcp_tree, hf_rtcp_sc, tvb, offset, 1, elem_count );
734 /* Packet type, 8 bits */
735 proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
737 /* Packet length in 32 bit words MINUS one, 16 bits */
738 proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
740 offset = dissect_rtcp_sdes( tvb, offset, pinfo->fd, rtcp_tree, elem_count );
743 /* Source count, 5 bits */
744 proto_tree_add_uint( rtcp_tree, hf_rtcp_sc, tvb, offset, 1, elem_count );
746 /* Packet type, 8 bits */
747 proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
749 /* Packet length in 32 bit words MINUS one, 16 bits */
750 proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
752 offset = dissect_rtcp_bye( tvb, offset, pinfo->fd, rtcp_tree, elem_count );
755 /* Subtype, 5 bits */
756 proto_tree_add_uint( rtcp_tree, hf_rtcp_subtype, tvb, offset, 1, elem_count );
758 /* Packet type, 8 bits */
759 proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
761 /* Packet length in 32 bit words MINUS one, 16 bits */
762 proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
764 dissect_rtcp_app( tvb, offset,
765 pinfo->fd, rtcp_tree, padding_set,
769 dissect_rtcp_fir( tvb, offset, pinfo->fd, rtcp_tree );
772 dissect_rtcp_nack( tvb, offset, pinfo->fd, rtcp_tree );
776 * To prevent endless loops in case of an unknown message type
777 * increase offset. Some time the while will end :-)
783 /* If the padding bit is set, the last octet of the
784 * packet contains the length of the padding
785 * We only have to check for this at the end of the LAST RTCP message
788 /* If everything went according to plan offset should now point to the
789 * first octet of the padding
791 proto_tree_add_item( rtcp_tree, hf_rtcp_padding_data, tvb, offset, tvb_length_remaining( tvb, offset) - 1, FALSE );
792 offset += tvb_length_remaining( tvb, offset) - 1;
793 proto_tree_add_item( rtcp_tree, hf_rtcp_padding_count, tvb, offset, 1, FALSE );
799 proto_register_rtcp(void)
801 static hf_register_info hf[] =
810 VALS(rtcp_version_vals),
830 "Reception report count",
858 VALS( rtcp_packet_type_vals ),
876 &hf_rtcp_ssrc_sender,
891 "rtcp.timestamp.ntp",
900 &hf_rtcp_rtp_timestamp,
903 "rtcp.timestamp.rtp",
912 &hf_rtcp_sender_pkt_cnt,
914 "Sender's packet count",
915 "rtcp.sender.packetcount",
924 &hf_rtcp_sender_oct_cnt,
926 "Sender's octet count",
927 "rtcp.sender.octetcount",
936 &hf_rtcp_ssrc_source,
939 "rtcp.ssrc.identifier",
948 &hf_rtcp_ssrc_fraction,
951 "rtcp.ssrc.fraction",
960 &hf_rtcp_ssrc_cum_nr,
962 "Cumulative number of packets lost",
972 &hf_rtcp_ssrc_ext_high_seq,
974 "Extended highest sequence number received",
975 "rtcp.ssrc.ext_high",
984 &hf_rtcp_ssrc_high_seq,
986 "Highest sequence number received",
987 "rtcp.ssrc.high_seq",
996 &hf_rtcp_ssrc_high_cycles,
998 "Sequence number cycles count",
999 "rtcp.ssrc.high_cycles",
1008 &hf_rtcp_ssrc_jitter,
1010 "Interarrival jitter",
1022 "Last SR timestamp",
1034 "Delay since last SR timestamp",
1046 "SSRC / CSRC identifier",
1047 "rtcp.sdes.ssrc_csrc",
1062 VALS( rtcp_sdes_type_vals ),
1068 &hf_rtcp_ssrc_length,
1092 &hf_rtcp_ssrc_prefix_len,
1095 "rtcp.sdes.prefix.length",
1104 &hf_rtcp_ssrc_prefix_string,
1107 "rtcp.sdes.prefix.string",
1128 &hf_rtcp_name_ascii,
1142 "Application specific data",
1154 "First sequence number",
1166 "Bitmask of following lost packets",
1176 &hf_rtcp_padding_count,
1179 "rtcp.padding.count",
1188 &hf_rtcp_padding_data,
1191 "rtcp.padding.data",
1201 static gint *ett[] =
1212 proto_rtcp = proto_register_protocol("Real-time Transport Control Protocol",
1214 proto_register_field_array(proto_rtcp, hf, array_length(hf));
1215 proto_register_subtree_array(ett, array_length(ett));
1218 register_init_routine( &rtcp_init );
1223 proto_reg_handoff_rtcp(void)
1226 * Register this dissector as one that can be assigned to a
1229 conv_dissector_add("udp", dissect_rtcp, proto_rtcp);