3 * $Id: packet-rtcp.c,v 1.19 2001/08/18 09:27:06 guy Exp $
5 * Routines for RTCP dissection
6 * RTCP = Real-time Transport Control Protocol
8 * Copyright 2000, Philips Electronics N.V.
9 * Written by Andreas Sikkema <andreas.sikkema@philips.com>
11 * Ethereal - Network traffic analyzer
12 * By Gerald Combs <gerald@ethereal.com>
13 * Copyright 1998 Gerald Combs
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
31 * This dissector tries to dissect the RTCP protocol according to Annex A
32 * of ITU-T Recommendation H.225.0 (02/98) and RFC 1889
33 * H.225.0 literally copies RFC 1889, but omitting a few sections.
35 * RTCP traffic is handled by an uneven UDP portnumber. This can be any
36 * port number, but there is a registered port available, port 5005
37 * See Annex B of ITU-T Recommendation H.225.0, section B.7
49 #ifdef HAVE_SYS_TYPES_H
50 # include <sys/types.h>
53 #ifdef HAVE_NETINET_IN_H
54 # include <netinet/in.h>
60 #include "packet-rtcp.h"
62 #include "packet-ntp.h"
64 #include "conversation.h"
66 /* Version is the first 2 bits of the first octet*/
67 #define RTCP_VERSION(octet) ((octet) >> 6)
69 /* Padding is the third bit; no need to shift, because true is any value
71 #define RTCP_PADDING(octet) ((octet) & 0x20)
73 /* Receiver/ Sender count is the 5 last bits */
74 #define RTCP_COUNT(octet) ((octet) & 0x1F)
76 static const value_string rtcp_version_vals[] =
78 { 0, "Old VAT Version" },
79 { 1, "First Draft Version" },
80 { 2, "RFC 1889 Version" },
84 /* RTCP packet types according to Section A.11.1 */
90 /* Supplemental H.261 specific RTCP packet types according to Section C.3.5 */
94 static const value_string rtcp_packet_type_vals[] =
96 { RTCP_SR, "Sender Report" },
97 { RTCP_RR, "Receiver Report" },
98 { RTCP_SDES, "Source description" },
99 { RTCP_BYE, "Goodbye" },
100 { RTCP_APP, "Application specific" },
101 { RTCP_FIR, "Full Intra-frame Request (H.261)" },
102 { RTCP_NACK, "Negative Acknowledgement (H.261)" },
106 /* RTCP SDES types (Section A.11.2) */
107 #define RTCP_SDES_END 0
108 #define RTCP_SDES_CNAME 1
109 #define RTCP_SDES_NAME 2
110 #define RTCP_SDES_EMAIL 3
111 #define RTCP_SDES_PHONE 4
112 #define RTCP_SDES_LOC 5
113 #define RTCP_SDES_TOOL 6
114 #define RTCP_SDES_NOTE 7
115 #define RTCP_SDES_PRIV 8
117 static const value_string rtcp_sdes_type_vals[] =
119 { RTCP_SDES_END, "END" },
120 { RTCP_SDES_CNAME, "CNAME (user and domain)" },
121 { RTCP_SDES_NAME, "NAME (common name)" },
122 { RTCP_SDES_EMAIL, "EMAIL (e-mail address)" },
123 { RTCP_SDES_PHONE, "PHONE (phone number)" },
124 { RTCP_SDES_LOC, "LOC (geographic location)" },
125 { RTCP_SDES_TOOL, "TOOL (name/version of source app)" },
126 { RTCP_SDES_NOTE, "NOTE (note about source)" },
127 { RTCP_SDES_PRIV, "PRIV (private extensions)" },
131 /* RTCP header fields */
132 static int proto_rtcp = -1;
133 static int hf_rtcp_version = -1;
134 static int hf_rtcp_padding = -1;
135 static int hf_rtcp_rc = -1;
136 static int hf_rtcp_sc = -1;
137 static int hf_rtcp_pt = -1;
138 static int hf_rtcp_length = -1;
139 static int hf_rtcp_ssrc_sender = -1;
140 static int hf_rtcp_ntp = -1;
141 static int hf_rtcp_rtp_timestamp = -1;
142 static int hf_rtcp_sender_pkt_cnt = -1;
143 static int hf_rtcp_sender_oct_cnt = -1;
144 static int hf_rtcp_ssrc_source = -1;
145 static int hf_rtcp_ssrc_fraction = -1;
146 static int hf_rtcp_ssrc_cum_nr = -1;
147 /* First the 32 bit number, then the split
148 * up 16 bit values */
149 /* These two are added to a subtree */
150 static int hf_rtcp_ssrc_ext_high_seq = -1;
151 static int hf_rtcp_ssrc_high_seq = -1;
152 static int hf_rtcp_ssrc_high_cycles = -1;
153 static int hf_rtcp_ssrc_jitter = -1;
154 static int hf_rtcp_ssrc_lsr = -1;
155 static int hf_rtcp_ssrc_dlsr = -1;
156 static int hf_rtcp_ssrc_csrc = -1;
157 static int hf_rtcp_ssrc_type = -1;
158 static int hf_rtcp_ssrc_length = -1;
159 static int hf_rtcp_ssrc_text = -1;
160 static int hf_rtcp_ssrc_prefix_len = -1;
161 static int hf_rtcp_ssrc_prefix_string= -1;
162 static int hf_rtcp_subtype = -1;
163 static int hf_rtcp_name_ascii = -1;
164 static int hf_rtcp_app_data = -1;
165 static int hf_rtcp_fsn = -1;
166 static int hf_rtcp_blp = -1;
167 static int hf_rtcp_padding_count = -1;
168 static int hf_rtcp_padding_data = -1;
170 /* RTCP fields defining a sub tree */
171 static gint ett_rtcp = -1;
172 static gint ett_ssrc = -1;
173 static gint ett_ssrc_item = -1;
174 static gint ett_ssrc_ext_high = -1;
175 static gint ett_sdes = -1;
176 static gint ett_sdes_item = -1;
178 static address fake_addr;
179 static int heur_init = FALSE;
181 static char rtcp_proto[] = "RTCP";
183 static gboolean dissect_rtcp_heur( tvbuff_t *tvb, packet_info *pinfo,
186 void rtcp_add_address( const unsigned char* ip_addr, int prt )
189 conversation_t* pconv = ( conversation_t* ) NULL;
191 src_addr.type = AT_IPv4;
193 src_addr.data = ip_addr;
196 * The first time the function is called let the udp dissector
197 * know that we're interested in traffic
200 heur_dissector_add( "udp", dissect_rtcp_heur, proto_rtcp );
205 * Check if the ip address and port combination is not
208 pconv = find_conversation( &src_addr, &fake_addr, PT_UDP, prt, 0, 0 );
214 conversation_new( &src_addr, &fake_addr, PT_UDP, (guint32) prt,
215 (guint32) 0, (void*) rtcp_proto, 0 );
221 static void rtcp_init( void )
223 unsigned char* tmp_data;
226 /* Create a fake adddress... */
227 fake_addr.type = AT_IPv4;
230 tmp_data = malloc( fake_addr.len );
231 for ( i = 0; i < fake_addr.len; i++) {
234 fake_addr.data = tmp_data;
239 dissect_rtcp_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
241 conversation_t* pconv;
243 if (!proto_is_protocol_enabled(proto_rtcp))
244 return FALSE; /* RTCP has been disabled */
246 /* This is a heuristic dissector, which means we get all the UDP
247 * traffic not sent to a known dissector and not claimed by
248 * a heuristic dissector called before us!
249 * So we first check if the frame is really meant for us.
251 if ( ( pconv = find_conversation( &pinfo->src, &fake_addr, pinfo->ptype,
252 pinfo->srcport, 0, 0 ) ) == NULL ) {
254 * The source ip:port combination was not what we were
255 * looking for, check the destination
257 if ( ( pconv = find_conversation( &pinfo->dst, &fake_addr,
258 pinfo->ptype, pinfo->destport, 0, 0 ) ) == NULL ) {
265 * An RTCP conversation always contains data
267 if ( pconv->data == NULL )
271 * An RTCP conversation data always contains "RTCP"
273 if ( strcmp( pconv->data, rtcp_proto ) != 0 )
277 * The message is a valid RTCP message!
279 dissect_rtcp( tvb, pinfo, tree );
286 dissect_rtcp_nack( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree )
288 /* Packet type = FIR (H261) */
289 proto_tree_add_uint( tree, hf_rtcp_rc, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 31 );
291 /* Packet type, 8 bits = APP */
292 proto_tree_add_item( tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
295 /* Packet length in 32 bit words minus one */
296 proto_tree_add_uint( tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
300 proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
304 proto_tree_add_uint( tree, hf_rtcp_fsn, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
308 proto_tree_add_uint( tree, hf_rtcp_blp, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
315 dissect_rtcp_fir( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree )
317 /* Packet type = FIR (H261) */
318 proto_tree_add_uint( tree, hf_rtcp_rc, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 31 );
320 /* Packet type, 8 bits = APP */
321 proto_tree_add_item( tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
324 /* Packet length in 32 bit words minus one */
325 proto_tree_add_uint( tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
329 proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
336 dissect_rtcp_app( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree,
337 unsigned int padding, unsigned int packet_len )
339 unsigned int counter = 0;
343 proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
348 for( counter = 0; counter < 4; counter++ )
349 ascii_name[ counter ] = tvb_get_guint8( tvb, offset + counter );
350 /* strncpy( ascii_name, pd + offset, 4 ); */
351 ascii_name[4] = '\0';
352 proto_tree_add_string( tree, hf_rtcp_name_ascii, tvb, offset, 4,
357 /* Applications specific data */
359 /* If there's padding present, we have to remove that from the data part
360 * The last octet of the packet contains the length of the padding
362 packet_len -= tvb_get_guint8( tvb, offset + packet_len - 1 );
364 proto_tree_add_item( tree, hf_rtcp_app_data, tvb, offset, packet_len, FALSE );
365 offset += packet_len;
371 dissect_rtcp_bye( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree,
374 unsigned int chunk = 1;
375 unsigned int reason_length = 0;
376 unsigned int counter = 0;
377 char* reason_text = NULL;
379 while ( chunk <= count ) {
380 /* source identifier, 32 bits */
381 proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
385 /* Bye reason consists of an 8 bit length l and a string with length l */
386 reason_length = tvb_get_guint8( tvb, offset );
387 proto_tree_add_item( tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
390 reason_text = ( char* ) malloc( reason_length + 1 );
391 for ( counter = 0; counter < reason_length; counter++ ) reason_text[ counter ] = tvb_get_guint8( tvb, offset + counter );
392 /* strncpy( reason_text, pd + offset, reason_length ); */
393 reason_text[ reason_length ] = '\0';
394 proto_tree_add_string( tree, hf_rtcp_ssrc_text, tvb, offset, reason_length, reason_text );
396 offset += reason_length;
403 dissect_rtcp_sdes( tvbuff_t *tvb, int offset, frame_data *fd, proto_tree *tree,
406 unsigned int chunk = 1;
407 proto_item *sdes_item;
408 proto_tree *sdes_tree;
409 proto_tree *sdes_item_tree;
412 int items_start_offset;
414 unsigned int item_len = 0;
415 unsigned int sdes_type = 0;
416 unsigned int counter = 0;
417 unsigned int prefix_len = 0;
418 char *prefix_string = NULL;
420 while ( chunk <= count ) {
421 /* Create a subtree for this chunk; we don't yet know
423 start_offset = offset;
425 ssrc = tvb_get_ntohl( tvb, offset );
426 sdes_item = proto_tree_add_text(tree, tvb, offset, 0,
427 "Chunk %u, SSRC/CSRC %u", chunk, ssrc);
428 sdes_tree = proto_item_add_subtree( sdes_item, ett_sdes );
430 /* SSRC_n source identifier, 32 bits */
431 proto_tree_add_uint( sdes_tree, hf_rtcp_ssrc_source, tvb, offset, 4, ssrc );
434 /* Create a subtree for the SDES items; we don't yet know
436 items_start_offset = offset;
437 ti = proto_tree_add_text(sdes_tree, tvb, offset, 0,
439 sdes_item_tree = proto_item_add_subtree( ti, ett_sdes_item );
442 * Not every message is ended with "null" bytes, so check for
443 * end of frame instead.
445 while ( ( tvb_reported_length_remaining( tvb, offset ) > 0 )
446 && ( tvb_get_guint8( tvb, offset ) != RTCP_SDES_END ) ) {
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 ( tvb_bytes_exist( tvb, offset, 4) ) {
683 * First retreive the packet_type
685 packet_type = tvb_get_guint8( tvb, offset + 1 );
688 * Check if it's a valid type
690 if ( ( packet_type < 192 ) || ( packet_type > 204 ) )
694 * get the packet-length for the complete RTCP packet
696 packet_length = ( tvb_get_ntohs( tvb, offset + 2 ) + 1 ) * 4;
698 ti = proto_tree_add_item(tree, proto_rtcp, tvb, offset, packet_length, FALSE );
699 rtcp_tree = proto_item_add_subtree( ti, ett_rtcp );
701 temp_byte = tvb_get_guint8( tvb, offset );
703 proto_tree_add_uint( rtcp_tree, hf_rtcp_version, tvb,
704 offset, 1, RTCP_VERSION( temp_byte ) );
705 padding_set = RTCP_PADDING( temp_byte );
706 proto_tree_add_boolean( rtcp_tree, hf_rtcp_padding, tvb,
707 offset, 1, padding_set );
708 elem_count = RTCP_COUNT( temp_byte );
710 switch ( packet_type ) {
713 /* Receiver report count, 5 bits */
714 proto_tree_add_uint( rtcp_tree, hf_rtcp_rc, tvb, offset, 1, elem_count );
716 /* Packet type, 8 bits */
717 proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
719 /* Packet length in 32 bit words MINUS one, 16 bits */
720 proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
722 /* Sender Synchronization source, 32 bits */
723 proto_tree_add_uint( rtcp_tree, hf_rtcp_ssrc_sender, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
726 if ( packet_type == RTCP_SR ) offset = dissect_rtcp_sr( tvb, offset, pinfo->fd, rtcp_tree, elem_count );
727 else offset = dissect_rtcp_rr( tvb, offset, pinfo->fd, rtcp_tree, elem_count );
730 /* Source count, 5 bits */
731 proto_tree_add_uint( rtcp_tree, hf_rtcp_sc, tvb, offset, 1, elem_count );
733 /* Packet type, 8 bits */
734 proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
736 /* Packet length in 32 bit words MINUS one, 16 bits */
737 proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
739 offset = dissect_rtcp_sdes( tvb, offset, pinfo->fd, rtcp_tree, elem_count );
742 /* Source count, 5 bits */
743 proto_tree_add_uint( rtcp_tree, hf_rtcp_sc, tvb, offset, 1, elem_count );
745 /* Packet type, 8 bits */
746 proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
748 /* Packet length in 32 bit words MINUS one, 16 bits */
749 proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
751 offset = dissect_rtcp_bye( tvb, offset, pinfo->fd, rtcp_tree, elem_count );
754 /* Subtype, 5 bits */
755 proto_tree_add_uint( rtcp_tree, hf_rtcp_subtype, tvb, offset, 1, elem_count );
757 /* Packet type, 8 bits */
758 proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
760 /* Packet length in 32 bit words MINUS one, 16 bits */
761 proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
763 offset = dissect_rtcp_app( tvb, offset,
764 pinfo->fd, rtcp_tree, padding_set,
768 offset = dissect_rtcp_fir( tvb, offset, pinfo->fd, rtcp_tree );
771 offset = dissect_rtcp_nack( tvb, offset, pinfo->fd, rtcp_tree );
775 * To prevent endless loops in case of an unknown message type
776 * increase offset. Some time the while will end :-)
782 /* If the padding bit is set, the last octet of the
783 * packet contains the length of the padding
784 * We only have to check for this at the end of the LAST RTCP message
787 /* If everything went according to plan offset should now point to the
788 * first octet of the padding
790 proto_tree_add_item( rtcp_tree, hf_rtcp_padding_data, tvb, offset, tvb_length_remaining( tvb, offset) - 1, FALSE );
791 offset += tvb_length_remaining( tvb, offset) - 1;
792 proto_tree_add_item( rtcp_tree, hf_rtcp_padding_count, tvb, offset, 1, FALSE );
798 proto_register_rtcp(void)
800 static hf_register_info hf[] =
809 VALS(rtcp_version_vals),
829 "Reception report count",
857 VALS( rtcp_packet_type_vals ),
875 &hf_rtcp_ssrc_sender,
890 "rtcp.timestamp.ntp",
899 &hf_rtcp_rtp_timestamp,
902 "rtcp.timestamp.rtp",
911 &hf_rtcp_sender_pkt_cnt,
913 "Sender's packet count",
914 "rtcp.sender.packetcount",
923 &hf_rtcp_sender_oct_cnt,
925 "Sender's octet count",
926 "rtcp.sender.octetcount",
935 &hf_rtcp_ssrc_source,
938 "rtcp.ssrc.identifier",
947 &hf_rtcp_ssrc_fraction,
950 "rtcp.ssrc.fraction",
959 &hf_rtcp_ssrc_cum_nr,
961 "Cumulative number of packets lost",
971 &hf_rtcp_ssrc_ext_high_seq,
973 "Extended highest sequence number received",
974 "rtcp.ssrc.ext_high",
983 &hf_rtcp_ssrc_high_seq,
985 "Highest sequence number received",
986 "rtcp.ssrc.high_seq",
995 &hf_rtcp_ssrc_high_cycles,
997 "Sequence number cycles count",
998 "rtcp.ssrc.high_cycles",
1007 &hf_rtcp_ssrc_jitter,
1009 "Interarrival jitter",
1021 "Last SR timestamp",
1033 "Delay since last SR timestamp",
1045 "SSRC / CSRC identifier",
1046 "rtcp.sdes.ssrc_csrc",
1061 VALS( rtcp_sdes_type_vals ),
1067 &hf_rtcp_ssrc_length,
1091 &hf_rtcp_ssrc_prefix_len,
1094 "rtcp.sdes.prefix.length",
1103 &hf_rtcp_ssrc_prefix_string,
1106 "rtcp.sdes.prefix.string",
1127 &hf_rtcp_name_ascii,
1141 "Application specific data",
1153 "First sequence number",
1165 "Bitmask of following lost packets",
1175 &hf_rtcp_padding_count,
1178 "rtcp.padding.count",
1187 &hf_rtcp_padding_data,
1190 "rtcp.padding.data",
1200 static gint *ett[] =
1211 proto_rtcp = proto_register_protocol("Real-time Transport Control Protocol",
1213 proto_register_field_array(proto_rtcp, hf, array_length(hf));
1214 proto_register_subtree_array(ett, array_length(ett));
1217 register_init_routine( &rtcp_init );
1222 proto_reg_handoff_rtcp(void)
1225 * Register this dissector as one that can be assigned to a
1228 conv_dissector_add("udp", dissect_rtcp, proto_rtcp);