packet-rtcp.c

   1 /* packet-rtcp.c
   2  *
   3  * $Id: packet-rtcp.c,v 1.40 2004/02/25 09:31:06 guy Exp $
   4  *
   5  * Routines for RTCP dissection
   6  * RTCP = Real-time Transport Control Protocol
   7  *
   8  * Copyright 2000, Philips Electronics N.V.
   9  * Written by Andreas Sikkema <h323@ramdyne.nl>
  10  *
  11  * Ethereal - Network traffic analyzer
  12  * By Gerald Combs <gerald@ethereal.com>
  13  * Copyright 1998 Gerald Combs
  14  *
  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.
  19  *
  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.
  24  *
  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.
  28  */
  29
  30 /*
  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.
  34  *
  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
  38  *
  39  */
  40
  41
  42 #ifdef HAVE_CONFIG_H
  43 # include "config.h"
  44 #endif
  45
  46 #include <glib.h>
  47 #include <epan/packet.h>
  48
  49 #include <stdio.h>
  50 #include <string.h>
  51
  52 #include "packet-rtcp.h"
  53 #if 0
  54 #include "packet-ntp.h"
  55 #endif
  56 #include <epan/conversation.h>
  57
  58 /* Version is the first 2 bits of the first octet*/
  59 #define RTCP_VERSION(octet)     ((octet) >> 6)
  60
  61 /* Padding is the third bit; no need to shift, because true is any value
  62    other than 0! */
  63 #define RTCP_PADDING(octet)     ((octet) & 0x20)
  64
  65 /* Receiver/ Sender count is the 5 last bits  */
  66 #define RTCP_COUNT(octet)       ((octet) & 0x1F)
  67
  68 static const value_string rtcp_version_vals[] =
  69 {
  70         { 0, "Old VAT Version" },
  71         { 1, "First Draft Version" },
  72         { 2, "RFC 1889 Version" },
  73         { 0, NULL },
  74 };
  75
  76 /* RTCP packet types according to Section A.11.1 */
  77 #define RTCP_SR   200
  78 #define RTCP_RR   201
  79 #define RTCP_SDES 202
  80 #define RTCP_BYE  203
  81 #define RTCP_APP  204
  82 /* Supplemental H.261 specific RTCP packet types according to Section C.3.5 */
  83 #define RTCP_FIR  192
  84 #define RTCP_NACK 193
  85
  86 static const value_string rtcp_packet_type_vals[] =
  87 {
  88         { RTCP_SR,   "Sender Report" },
  89         { RTCP_RR,   "Receiver Report" },
  90         { RTCP_SDES, "Source description" },
  91         { RTCP_BYE,  "Goodbye" },
  92         { RTCP_APP,  "Application specific" },
  93         { RTCP_FIR,  "Full Intra-frame Request (H.261)" },
  94         { RTCP_NACK, "Negative Acknowledgement (H.261)" },
  95         { 0,         NULL },
  96 };
  97
  98 /* RTCP SDES types (Section A.11.2) */
  99 #define RTCP_SDES_END    0
 100 #define RTCP_SDES_CNAME  1
 101 #define RTCP_SDES_NAME   2
 102 #define RTCP_SDES_EMAIL  3
 103 #define RTCP_SDES_PHONE  4
 104 #define RTCP_SDES_LOC    5
 105 #define RTCP_SDES_TOOL   6
 106 #define RTCP_SDES_NOTE   7
 107 #define RTCP_SDES_PRIV   8
 108
 109 static const value_string rtcp_sdes_type_vals[] =
 110 {
 111         { RTCP_SDES_END,   "END" },
 112         { RTCP_SDES_CNAME, "CNAME (user and domain)" },
 113         { RTCP_SDES_NAME,  "NAME (common name)" },
 114         { RTCP_SDES_EMAIL, "EMAIL (e-mail address)" },
 115         { RTCP_SDES_PHONE, "PHONE (phone number)" },
 116         { RTCP_SDES_LOC,   "LOC (geographic location)" },
 117         { RTCP_SDES_TOOL,  "TOOL (name/version of source app)" },
 118         { RTCP_SDES_NOTE,  "NOTE (note about source)" },
 119         { RTCP_SDES_PRIV,  "PRIV (private extensions)" },
 120         { 0,               NULL },
 121 };
 122
 123 /* RTCP header fields                   */
 124 static int proto_rtcp                = -1;
 125 static int hf_rtcp_version           = -1;
 126 static int hf_rtcp_padding           = -1;
 127 static int hf_rtcp_rc                = -1;
 128 static int hf_rtcp_sc                = -1;
 129 static int hf_rtcp_pt                = -1;
 130 static int hf_rtcp_length            = -1;
 131 static int hf_rtcp_ssrc_sender       = -1;
 132 static int hf_rtcp_ntp               = -1;
 133 static int hf_rtcp_rtp_timestamp     = -1;
 134 static int hf_rtcp_sender_pkt_cnt    = -1;
 135 static int hf_rtcp_sender_oct_cnt    = -1;
 136 static int hf_rtcp_ssrc_source       = -1;
 137 static int hf_rtcp_ssrc_fraction     = -1;
 138 static int hf_rtcp_ssrc_cum_nr       = -1;
 139 /* First the 32 bit number, then the split
 140  * up 16 bit values */
 141 /* These two are added to a subtree */
 142 static int hf_rtcp_ssrc_ext_high_seq = -1;
 143 static int hf_rtcp_ssrc_high_seq     = -1;
 144 static int hf_rtcp_ssrc_high_cycles  = -1;
 145 static int hf_rtcp_ssrc_jitter       = -1;
 146 static int hf_rtcp_ssrc_lsr          = -1;
 147 static int hf_rtcp_ssrc_dlsr         = -1;
 148 static int hf_rtcp_ssrc_csrc         = -1;
 149 static int hf_rtcp_ssrc_type         = -1;
 150 static int hf_rtcp_ssrc_length       = -1;
 151 static int hf_rtcp_ssrc_text         = -1;
 152 static int hf_rtcp_ssrc_prefix_len   = -1;
 153 static int hf_rtcp_ssrc_prefix_string= -1;
 154 static int hf_rtcp_subtype           = -1;
 155 static int hf_rtcp_name_ascii        = -1;
 156 static int hf_rtcp_app_data          = -1;
 157 static int hf_rtcp_fsn               = -1;
 158 static int hf_rtcp_blp               = -1;
 159 static int hf_rtcp_padding_count     = -1;
 160 static int hf_rtcp_padding_data      = -1;
 161
 162 /* RTCP fields defining a sub tree */
 163 static gint ett_rtcp           = -1;
 164 static gint ett_ssrc           = -1;
 165 static gint ett_ssrc_item      = -1;
 166 static gint ett_ssrc_ext_high  = -1;
 167 static gint ett_sdes           = -1;
 168 static gint ett_sdes_item      = -1;
 169
 170 static address fake_addr;
 171 static int heur_init = FALSE;
 172
 173 static gboolean dissect_rtcp_heur( tvbuff_t *tvb, packet_info *pinfo,
 174     proto_tree *tree );
 175 static void dissect_rtcp( tvbuff_t *tvb, packet_info *pinfo,
 176      proto_tree *tree );
 177
 178 void rtcp_add_address( packet_info *pinfo, const unsigned char* ip_addr,
 179     int prt )
 180 {
 181         address src_addr;
 182         conversation_t* pconv;
 183
 184         /*
 185          * If this isn't the first time this packet has been processed,
 186          * we've already done this work, so we don't need to do it
 187          * again.
 188          */
 189         if (pinfo->fd->flags.visited)
 190                 return;
 191
 192         src_addr.type = AT_IPv4;
 193         src_addr.len = 4;
 194         src_addr.data = ip_addr;
 195
 196         /*
 197          * The first time the function is called let the udp dissector
 198          * know that we're interested in traffic
 199          */
 200         if ( ! heur_init ) {
 201                 heur_dissector_add( "udp", dissect_rtcp_heur, proto_rtcp );
 202                 heur_init = TRUE;
 203         }
 204
 205         /*
 206          * Check if the ip address and port combination is not
 207          * already registered
 208          */
 209         pconv = find_conversation( &src_addr, &fake_addr, PT_UDP, prt, 0, 0 );
 210
 211         /*
 212          * If not, add
 213          * XXX - use wildcard address and port B?
 214          */
 215         if ( ! pconv ) {
 216                 pconv = conversation_new( &src_addr, &fake_addr, PT_UDP,
 217                     (guint32) prt, (guint32) 0, 0 );
 218                 conversation_add_proto_data(pconv, proto_rtcp, NULL);
 219         }
 220
 221 }
 222
 223 #if 0
 224 static void rtcp_init( void )
 225 {
 226         unsigned char* tmp_data;
 227         int i;
 228
 229         /* Create a fake adddress... */
 230         fake_addr.type = AT_IPv4;
 231         fake_addr.len = 4;
 232
 233         tmp_data = g_malloc( fake_addr.len );
 234         for ( i = 0; i < fake_addr.len; i++) {
 235                 tmp_data[i] = 0;
 236         }
 237         fake_addr.data = tmp_data;
 238 }
 239 #endif
 240
 241 static gboolean
 242 dissect_rtcp_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
 243 {
 244         conversation_t* pconv;
 245
 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.
 250          */
 251         if ( ( pconv = find_conversation( &pinfo->src, &fake_addr, pinfo->ptype,
 252             pinfo->srcport, 0, 0 ) ) == NULL ) {
 253                 /*
 254                  * The source ip:port combination was not what we were
 255                  * looking for, check the destination
 256                  */
 257                 if ( ( pconv = find_conversation( &pinfo->dst, &fake_addr,
 258                     pinfo->ptype, pinfo->destport, 0, 0 ) ) == NULL ) {
 259                         return FALSE;
 260                 }
 261         }
 262
 263
 264         /*
 265          * An RTCP conversation always has a data item for RTCP.
 266          * (Its existence is sufficient to indicate that this is an RTCP
 267          * conversation.)
 268          */
 269         if (conversation_get_proto_data(pconv, proto_rtcp) == NULL)
 270                 return FALSE;
 271
 272         /*
 273          * The message is a valid RTCP message!
 274          */
 275         dissect_rtcp( tvb, pinfo, tree );
 276
 277         return TRUE;
 278 }
 279
 280
 281 static int
 282 dissect_rtcp_nack( tvbuff_t *tvb, int offset, proto_tree *tree )
 283 {
 284         /* Packet type = FIR (H261) */
 285         proto_tree_add_uint( tree, hf_rtcp_rc, tvb, offset, 1, tvb_get_guint8( tvb, offset ) );
 286         offset++;
 287         /* Packet type, 8 bits  = APP */
 288         proto_tree_add_item( tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
 289         offset++;
 290
 291         /* Packet length in 32 bit words minus one */
 292         proto_tree_add_uint( tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 293         offset += 2;
 294
 295         /* SSRC  */
 296         proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 297         offset += 4;
 298
 299         /* FSN, 16 bits */
 300         proto_tree_add_uint( tree, hf_rtcp_fsn, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 301         offset += 2;
 302
 303         /* BLP, 16 bits */
 304         proto_tree_add_uint( tree, hf_rtcp_blp, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 305         offset += 2;
 306
 307         return offset;
 308 }
 309
 310 static int
 311 dissect_rtcp_fir( tvbuff_t *tvb, int offset, proto_tree *tree )
 312 {
 313         /* Packet type = FIR (H261) */
 314         proto_tree_add_uint( tree, hf_rtcp_rc, tvb, offset, 1, tvb_get_guint8( tvb, offset ) );
 315         offset++;
 316         /* Packet type, 8 bits  = APP */
 317         proto_tree_add_item( tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
 318         offset++;
 319
 320         /* Packet length in 32 bit words minus one */
 321         proto_tree_add_uint( tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 322         offset += 2;
 323
 324         /* SSRC  */
 325         proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 326         offset += 4;
 327
 328         return offset;
 329 }
 330
 331 static int
 332 dissect_rtcp_app( tvbuff_t *tvb, int offset, proto_tree *tree,
 333     unsigned int padding, unsigned int packet_len )
 334 {
 335         unsigned int counter = 0;
 336         char ascii_name[5];
 337
 338         /* SSRC / CSRC */
 339         proto_tree_add_uint( tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 340         offset += 4;
 341         packet_len -= 4;
 342
 343         /* Name (ASCII) */
 344         for( counter = 0; counter < 4; counter++ )
 345             ascii_name[ counter ] = tvb_get_guint8( tvb, offset + counter );
 346         /* strncpy( ascii_name, pd + offset, 4 ); */
 347         ascii_name[4] = '\0';
 348         proto_tree_add_string( tree, hf_rtcp_name_ascii, tvb, offset, 4,
 349             ascii_name );
 350         offset += 4;
 351         packet_len -= 4;
 352
 353         /* Applications specific data */
 354         if ( padding ) {
 355                 /* If there's padding present, we have to remove that from the data part
 356                  * The last octet of the packet contains the length of the padding
 357                  */
 358                 packet_len -= tvb_get_guint8( tvb, offset + packet_len - 1 );
 359         }
 360         proto_tree_add_item( tree, hf_rtcp_app_data, tvb, offset, packet_len, FALSE );
 361         offset += packet_len;
 362
 363         return offset;
 364 }
 365
 366 static int
 367 dissect_rtcp_bye( tvbuff_t *tvb, int offset, proto_tree *tree,
 368     unsigned int count )
 369 {
 370         unsigned int chunk          = 1;
 371         unsigned int reason_length  = 0;
 372         char* reason_text = NULL;
 373
 374         while ( chunk <= count ) {
 375                 /* source identifier, 32 bits */
 376                 proto_tree_add_item( tree, hf_rtcp_ssrc_source, tvb, offset, 4, FALSE);
 377                 offset += 4;
 378                 chunk++;
 379         }
 380
 381         if ( tvb_reported_length_remaining( tvb, offset ) > 0 ) {
 382                 /* Bye reason consists of an 8 bit length l and a string with length l */
 383                 reason_length = tvb_get_guint8( tvb, offset );
 384                 proto_tree_add_item( tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
 385                 offset++;
 386
 387                 reason_text = tvb_get_string(tvb, offset, reason_length);
 388                 proto_tree_add_string( tree, hf_rtcp_ssrc_text, tvb, offset, reason_length, reason_text );
 389                 g_free( reason_text );
 390                 offset += reason_length;
 391         }
 392
 393         return offset;
 394
 395 }
 396
 397 static void
 398 dissect_rtcp_sdes( tvbuff_t *tvb, int offset, proto_tree *tree,
 399     unsigned int count )
 400 {
 401         unsigned int chunk          = 1;
 402         proto_item *sdes_item;
 403         proto_tree *sdes_tree;
 404         proto_tree *sdes_item_tree;
 405         proto_item *ti;
 406         int start_offset;
 407         int items_start_offset;
 408         guint32 ssrc;
 409         unsigned int item_len       = 0;
 410         unsigned int sdes_type      = 0;
 411         unsigned int counter        = 0;
 412         unsigned int prefix_len     = 0;
 413         char *prefix_string = NULL;
 414
 415         while ( chunk <= count ) {
 416                 /* Create a subtree for this chunk; we don't yet know
 417                    the length. */
 418                 start_offset = offset;
 419
 420                 ssrc = tvb_get_ntohl( tvb, offset );
 421                 sdes_item = proto_tree_add_text(tree, tvb, offset, -1,
 422                     "Chunk %u, SSRC/CSRC %u", chunk, ssrc);
 423                 sdes_tree = proto_item_add_subtree( sdes_item, ett_sdes );
 424
 425                 /* SSRC_n source identifier, 32 bits */
 426                 proto_tree_add_uint( sdes_tree, hf_rtcp_ssrc_source, tvb, offset, 4, ssrc );
 427                 offset += 4;
 428
 429                 /* Create a subtree for the SDES items; we don't yet know
 430                    the length */
 431                 items_start_offset = offset;
 432                 ti = proto_tree_add_text(sdes_tree, tvb, offset, -1,
 433                     "SDES items" );
 434                 sdes_item_tree = proto_item_add_subtree( ti, ett_sdes_item );
 435
 436                 /*
 437                  * Not every message is ended with "null" bytes, so check for
 438                  * end of frame instead.
 439                  */
 440                 while ( ( tvb_reported_length_remaining( tvb, offset ) > 0 )
 441                     && ( tvb_get_guint8( tvb, offset ) != RTCP_SDES_END ) ) {
 442                         /* ID, 8 bits */
 443                         sdes_type = tvb_get_guint8( tvb, offset );
 444                         proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_type, tvb, offset, 1, FALSE );
 445                         offset++;
 446
 447                         /* Item length, 8 bits */
 448                         item_len = tvb_get_guint8( tvb, offset );
 449                         proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_length, tvb, offset, 1, FALSE );
 450                         offset++;
 451
 452                         if ( sdes_type == RTCP_SDES_PRIV ) {
 453                                 /* PRIV adds two items between the SDES length
 454                                  * and value - an 8 bit length giving the
 455                                  * length of a "prefix string", and the string.
 456                                  */
 457                                 prefix_len = tvb_get_guint8( tvb, offset );
 458                                 proto_tree_add_item( sdes_item_tree, hf_rtcp_ssrc_prefix_len, tvb, offset, 1, FALSE );
 459                                 offset++;
 460
 461                                 prefix_string = g_malloc( prefix_len + 1 );
 462                                 for ( counter = 0; counter < prefix_len; counter++ )
 463                                         prefix_string[ counter ] =
 464                                             tvb_get_guint8( tvb, offset + counter );
 465                                 /* strncpy( prefix_string, pd + offset, prefix_len ); */
 466                                 prefix_string[ prefix_len ] = '\0';
 467                                 proto_tree_add_string( sdes_item_tree, hf_rtcp_ssrc_prefix_string, tvb, offset, prefix_len, prefix_string );
 468                                 g_free( prefix_string );
 469                                 offset += prefix_len;
 470                         }
 471                         prefix_string = g_malloc( item_len + 1 );
 472                         for ( counter = 0; counter < item_len; counter++ )
 473                             prefix_string[ counter ] =
 474                                 tvb_get_guint8( tvb, offset + counter );
 475                         /* strncpy( prefix_string, pd + offset, item_len ); */
 476                         prefix_string[ item_len] = 0;
 477                         proto_tree_add_string( sdes_item_tree, hf_rtcp_ssrc_text, tvb, offset, item_len, prefix_string );
 478                         g_free( prefix_string );
 479                         offset += item_len;
 480                 }
 481
 482                 /* Set the length of the items subtree. */
 483                 proto_item_set_len(ti, offset - items_start_offset);
 484
 485                 /* 32 bits = 4 bytes, so.....
 486                  * If offset % 4 != 0, we divide offset by 4, add one and then
 487                  * multiply by 4 again to reach the boundary
 488                  */
 489                 if ( offset % 4 != 0 )
 490                         offset = ((offset / 4) + 1 ) * 4;
 491
 492                 /* Set the length of this chunk. */
 493                 proto_item_set_len(sdes_item, offset - start_offset);
 494
 495                 chunk++;
 496         }
 497 }
 498
 499 static int
 500 dissect_rtcp_rr( tvbuff_t *tvb, int offset, proto_tree *tree,
 501     unsigned int count )
 502 {
 503         unsigned int counter = 1;
 504         proto_tree *ssrc_tree = (proto_tree*) NULL;
 505         proto_tree *ssrc_sub_tree = (proto_tree*) NULL;
 506         proto_tree *high_sec_tree = (proto_tree*) NULL;
 507         proto_item *ti = (proto_item*) NULL;
 508         guint8 rr_flt;
 509         unsigned int cum_nr = 0;
 510
 511         while ( counter <= count ) {
 512                 /* Create a new subtree for a length of 24 bytes */
 513                 ti = proto_tree_add_text(tree, tvb, offset, 24,
 514                     "Source %u", counter );
 515                 ssrc_tree = proto_item_add_subtree( ti, ett_ssrc );
 516
 517                 /* SSRC_n source identifier, 32 bits */
 518                 proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_source, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 519                 offset += 4;
 520
 521                 ti = proto_tree_add_text(ssrc_tree, tvb, offset, 20, "SSRC contents" );
 522                 ssrc_sub_tree = proto_item_add_subtree( ti, ett_ssrc_item );
 523
 524                 /* Fraction lost, 8bits */
 525                 rr_flt = tvb_get_guint8( tvb, offset );
 526                 proto_tree_add_uint_format( ssrc_sub_tree, hf_rtcp_ssrc_fraction, tvb,
 527                     offset, 1, rr_flt, "Fraction lost: %u / 256", rr_flt );
 528                 offset++;
 529
 530                 /* Cumulative number of packets lost, 24 bits */
 531                 cum_nr = tvb_get_ntohl( tvb, offset ) >> 8;
 532                 proto_tree_add_uint( ssrc_sub_tree, hf_rtcp_ssrc_cum_nr, tvb,
 533                     offset, 3, cum_nr );
 534                 offset += 3;
 535
 536                 /* Extended highest sequence nr received, 32 bits
 537                  * Just for the sake of it, let's add another subtree
 538                  * because this might be a little clearer
 539                  */
 540                 ti = proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_ext_high_seq,
 541                     tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 542                 high_sec_tree = proto_item_add_subtree( ti, ett_ssrc_ext_high );
 543                 /* Sequence number cycles */
 544                 proto_tree_add_uint( high_sec_tree, hf_rtcp_ssrc_high_cycles,
 545                     tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 546                 offset += 2;
 547                 /* highest sequence number received */
 548                 proto_tree_add_uint( high_sec_tree, hf_rtcp_ssrc_high_seq,
 549                     tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 550                 offset += 2;
 551
 552                 /* Interarrival jitter */
 553                 proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_jitter, tvb,
 554                     offset, 4, tvb_get_ntohl( tvb, offset ) );
 555                 offset += 4;
 556
 557                 /* Last SR timestamp */
 558                 proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_lsr, tvb,
 559                     offset, 4, tvb_get_ntohl( tvb, offset ) );
 560                 offset += 4;
 561
 562                 /* Delay since last SR timestamp */
 563                 proto_tree_add_uint( ssrc_tree, hf_rtcp_ssrc_dlsr, tvb,
 564                     offset, 4, tvb_get_ntohl( tvb, offset ) );
 565                 offset += 4;
 566                 counter++;
 567         }
 568
 569         return offset;
 570 }
 571
 572 static int
 573 dissect_rtcp_sr( tvbuff_t *tvb, int offset, proto_tree *tree,
 574     unsigned int count )
 575 {
 576 #if 0
 577         gchar buff[ NTP_TS_SIZE ];
 578         char* ptime = tvb_get_ptr( tvb, offset, 8 );
 579
 580         /* Retreive the NTP timestamp. Using the NTP dissector for this */
 581         ntp_fmt_ts( ptime, buff );
 582         proto_tree_add_string_format( tree, hf_rtcp_ntp, tvb, offset, 8, ( const char* ) &buff, "NTP timestamp: %s", &buff );
 583         free( ptime ); ??????????????????????????????????????????????????????????????????
 584         offset += 8;
 585 #else
 586         /*
 587          * XXX - RFC 1889 says this is an NTP timestamp, but that appears
 588          * not to be the case.
 589          */
 590         proto_tree_add_text(tree, tvb, offset, 4, "Timestamp, MSW: %u",
 591                 tvb_get_ntohl(tvb, offset));
 592         offset += 4;
 593         proto_tree_add_text(tree, tvb, offset, 4, "Timestamp, LSW: %u",
 594                 tvb_get_ntohl(tvb, offset));
 595         offset += 4;
 596 #endif
 597         /* RTP timestamp, 32 bits */
 598         proto_tree_add_uint( tree, hf_rtcp_rtp_timestamp, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 599         offset += 4;
 600         /* Sender's packet count, 32 bits */
 601         proto_tree_add_uint( tree, hf_rtcp_sender_pkt_cnt, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 602         offset += 4;
 603         /* Sender's octet count, 32 bits */
 604         proto_tree_add_uint( tree, hf_rtcp_sender_oct_cnt, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 605         offset += 4;
 606
 607         /* The rest of the packet is equal to the RR packet */
 608         if ( count != 0 )
 609                 offset = dissect_rtcp_rr( tvb, offset, tree, count );
 610
 611         return offset;
 612 }
 613
 614 static void
 615 dissect_rtcp( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
 616 {
 617         proto_item *ti           = NULL;
 618         proto_tree *rtcp_tree    = NULL;
 619         unsigned int temp_byte   = 0;
 620         unsigned int padding_set = 0;
 621         unsigned int elem_count  = 0;
 622         unsigned int packet_type = 0;
 623         unsigned int offset      = 0;
 624         guint16 packet_length    = 0;
 625
 626         if ( check_col( pinfo->cinfo, COL_PROTOCOL ) )   {
 627                 col_set_str( pinfo->cinfo, COL_PROTOCOL, "RTCP" );
 628         }
 629
 630         if ( check_col( pinfo->cinfo, COL_INFO) ) {
 631                 /* The second octet contains the packet type */
 632                 /* switch ( pd[ offset + 1 ] ) { */
 633                 switch ( tvb_get_guint8( tvb, 1 ) ) {
 634                         case RTCP_SR:
 635                                 col_set_str( pinfo->cinfo, COL_INFO, "Sender Report");
 636                                 break;
 637                         case RTCP_RR:
 638                                 col_set_str( pinfo->cinfo, COL_INFO, "Receiver Report");
 639                                 break;
 640                         case RTCP_SDES:
 641                                 col_set_str( pinfo->cinfo, COL_INFO, "Source Description");
 642                                 break;
 643                         case RTCP_BYE:
 644                                 col_set_str( pinfo->cinfo, COL_INFO, "Goodbye");
 645                                 break;
 646                         case RTCP_APP:
 647                                 col_set_str( pinfo->cinfo, COL_INFO, "Application defined");
 648                                 break;
 649                         case RTCP_FIR:
 650                                 col_set_str( pinfo->cinfo, COL_INFO, "Full Intra-frame Request (H.261)");
 651                                 break;
 652                         case RTCP_NACK:
 653                                 col_set_str( pinfo->cinfo, COL_INFO, "Negative Acknowledgement (H.261)");
 654                                 break;
 655                         default:
 656                                 col_set_str( pinfo->cinfo, COL_INFO, "Unknown packet type");
 657                                 break;
 658                 }
 659         }
 660
 661         if ( tree ) {
 662
 663                 /*
 664                  * Check if there are at least 4 bytes left in the frame,
 665                  * the last 16 bits of those is the length of the current
 666                  * RTCP message. The last compound message contains padding,
 667                  * that enables us to break from the while loop.
 668                  */
 669                 while ( tvb_bytes_exist( tvb, offset, 4) ) {
 670                         /*
 671                          * First retreive the packet_type
 672                          */
 673                         packet_type = tvb_get_guint8( tvb, offset + 1 );
 674
 675                         /*
 676                          * Check if it's a valid type
 677                          */
 678                         if ( ( packet_type < 192 ) || ( packet_type >  204 ) )
 679                                 break;
 680
 681                         /*
 682                          * get the packet-length for the complete RTCP packet
 683                          */
 684                         packet_length = ( tvb_get_ntohs( tvb, offset + 2 ) + 1 ) * 4;
 685
 686                         ti = proto_tree_add_item(tree, proto_rtcp, tvb, offset, packet_length, FALSE );
 687                         rtcp_tree = proto_item_add_subtree( ti, ett_rtcp );
 688
 689                         temp_byte = tvb_get_guint8( tvb, offset );
 690
 691                         proto_tree_add_uint( rtcp_tree, hf_rtcp_version, tvb,
 692                             offset, 1, temp_byte);
 693                         padding_set = RTCP_PADDING( temp_byte );
 694                         proto_tree_add_boolean( rtcp_tree, hf_rtcp_padding, tvb,
 695                             offset, 1, temp_byte );
 696                         elem_count = RTCP_COUNT( temp_byte );
 697
 698                         switch ( packet_type ) {
 699                                 case RTCP_SR:
 700                                 case RTCP_RR:
 701                                         /* Receiver report count, 5 bits */
 702                                         proto_tree_add_uint( rtcp_tree, hf_rtcp_rc, tvb, offset, 1, temp_byte );
 703                                         offset++;
 704                                         /* Packet type, 8 bits */
 705                                         proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
 706                                         offset++;
 707                                         /* Packet length in 32 bit words MINUS one, 16 bits */
 708                                         proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 709                                         offset += 2;
 710                                         /* Sender Synchronization source, 32 bits */
 711                                         proto_tree_add_uint( rtcp_tree, hf_rtcp_ssrc_sender, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 712                                         offset += 4;
 713
 714                                         if ( packet_type == RTCP_SR ) offset = dissect_rtcp_sr( tvb, offset, rtcp_tree, elem_count );
 715                                         else offset = dissect_rtcp_rr( tvb, offset, rtcp_tree, elem_count );
 716                                         break;
 717                                 case RTCP_SDES:
 718                                         /* Source count, 5 bits */
 719                                         proto_tree_add_uint( rtcp_tree, hf_rtcp_sc, tvb, offset, 1, temp_byte );
 720                                         offset++;
 721                                         /* Packet type, 8 bits */
 722                                         proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
 723                                         offset++;
 724                                         /* Packet length in 32 bit words MINUS one, 16 bits */
 725                                         proto_tree_add_uint( rtcp_tree, hf_rtcp_length, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 726                                         offset += 2;
 727                                         dissect_rtcp_sdes( tvb, offset, rtcp_tree, elem_count );
 728                                         offset += packet_length - 4;
 729                                         break;
 730                                 case RTCP_BYE:
 731                                         /* Source count, 5 bits */
 732                                         proto_tree_add_uint( rtcp_tree, hf_rtcp_sc, tvb, offset, 1, temp_byte );
 733                                         offset++;
 734                                         /* Packet type, 8 bits */
 735                                         proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
 736                                         offset++;
 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 ) );
 739                                         offset += 2;
 740                                         offset = dissect_rtcp_bye( tvb, offset, rtcp_tree, elem_count );
 741                                         break;
 742                                 case RTCP_APP:
 743                                         /* Subtype, 5 bits */
 744                                         proto_tree_add_uint( rtcp_tree, hf_rtcp_subtype, tvb, offset, 1, elem_count );
 745                                         offset++;
 746                                         /* Packet type, 8 bits */
 747                                         proto_tree_add_item( rtcp_tree, hf_rtcp_pt, tvb, offset, 1, FALSE );
 748                                         offset++;
 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 ) );
 751                                         offset += 2;
 752                                         offset = dissect_rtcp_app( tvb, offset,
 753                                             rtcp_tree, padding_set,
 754                                             packet_length - 4 );
 755                                         break;
 756                                 case RTCP_FIR:
 757                                         offset = dissect_rtcp_fir( tvb, offset, rtcp_tree );
 758                                         break;
 759                                 case RTCP_NACK:
 760                                         offset = dissect_rtcp_nack( tvb, offset, rtcp_tree );
 761                                         break;
 762                                 default:
 763                                         /*
 764                                          * To prevent endless loops in case of an unknown message type
 765                                          * increase offset. Some time the while will end :-)
 766                                          */
 767                                         offset++;
 768                                         break;
 769                         }
 770                 }
 771                 /* If the padding bit is set, the last octet of the
 772                  * packet contains the length of the padding
 773                  * We only have to check for this at the end of the LAST RTCP message
 774                  */
 775                 if ( padding_set ) {
 776                         /* If everything went according to plan offset should now point to the
 777                          * first octet of the padding
 778                          */
 779                         proto_tree_add_item( rtcp_tree, hf_rtcp_padding_data, tvb, offset, tvb_length_remaining( tvb, offset) - 1, FALSE );
 780                         offset += tvb_length_remaining( tvb, offset) - 1;
 781                         proto_tree_add_item( rtcp_tree, hf_rtcp_padding_count, tvb, offset, 1, FALSE );
 782                 }
 783         }
 784 }
 785
 786 void
 787 proto_register_rtcp(void)
 788 {
 789         static hf_register_info hf[] =
 790         {
 791                 {
 792                         &hf_rtcp_version,
 793                         {
 794                                 "Version",
 795                                 "rtcp.version",
 796                                 FT_UINT8,
 797                                 BASE_DEC,
 798                                 VALS(rtcp_version_vals),
 799                                 0xC0,
 800                                 "", HFILL
 801                         }
 802                 },
 803                 {
 804                         &hf_rtcp_padding,
 805                         {
 806                                 "Padding",
 807                                 "rtcp.padding",
 808                                 FT_BOOLEAN,
 809                                 8,
 810                                 NULL,
 811                                 0x20,
 812                                 "", HFILL
 813                         }
 814                 },
 815                 {
 816                         &hf_rtcp_rc,
 817                         {
 818                                 "Reception report count",
 819                                 "rtcp.rc",
 820                                 FT_UINT8,
 821                                 BASE_DEC,
 822                                 NULL,
 823                                 0x1F,
 824                                 "", HFILL
 825                         }
 826                 },
 827                 {
 828                         &hf_rtcp_sc,
 829                         {
 830                                 "Source count",
 831                                 "rtcp.sc",
 832                                 FT_UINT8,
 833                                 BASE_DEC,
 834                                 NULL,
 835                                 0x1F,
 836                                 "", HFILL
 837                         }
 838                 },
 839                 {
 840                         &hf_rtcp_pt,
 841                         {
 842                                 "Packet type",
 843                                 "rtcp.pt",
 844                                 FT_UINT8,
 845                                 BASE_DEC,
 846                                 VALS( rtcp_packet_type_vals ),
 847                                 0x0,
 848                                 "", HFILL
 849                         }
 850                 },
 851                 {
 852                         &hf_rtcp_length,
 853                         {
 854                                 "Length",
 855                                 "rtcp.length",
 856                                 FT_UINT16,
 857                                 BASE_DEC,
 858                                 NULL,
 859                                 0x0,
 860                                 "", HFILL
 861                         }
 862                 },
 863                 {
 864                         &hf_rtcp_ssrc_sender,
 865                         {
 866                                 "Sender SSRC",
 867                                 "rtcp.senderssrc",
 868                                 FT_UINT32,
 869                                 BASE_DEC,
 870                                 NULL,
 871                                 0x0,
 872                                 "", HFILL
 873                         }
 874                 },
 875                 {
 876                         &hf_rtcp_ntp,
 877                         {
 878                                 "NTP timestamp",
 879                                 "rtcp.timestamp.ntp",
 880                                 FT_STRING,
 881                                 BASE_NONE,
 882                                 NULL,
 883                                 0x0,
 884                                 "", HFILL
 885                         }
 886                 },
 887                 {
 888                         &hf_rtcp_rtp_timestamp,
 889                         {
 890                                 "RTP timestamp",
 891                                 "rtcp.timestamp.rtp",
 892                                 FT_UINT32,
 893                                 BASE_DEC,
 894                                 NULL,
 895                                 0x0,
 896                                 "", HFILL
 897                         }
 898                 },
 899                 {
 900                         &hf_rtcp_sender_pkt_cnt,
 901                         {
 902                                 "Sender's packet count",
 903                                 "rtcp.sender.packetcount",
 904                                 FT_UINT32,
 905                                 BASE_DEC,
 906                                 NULL,
 907                                 0x0,
 908                                 "", HFILL
 909                         }
 910                 },
 911                 {
 912                         &hf_rtcp_sender_oct_cnt,
 913                         {
 914                                 "Sender's octet count",
 915                                 "rtcp.sender.octetcount",
 916                                 FT_UINT32,
 917                                 BASE_DEC,
 918                                 NULL,
 919                                 0x0,
 920                                 "", HFILL
 921                         }
 922                 },
 923                 {
 924                         &hf_rtcp_ssrc_source,
 925                         {
 926                                 "Identifier",
 927                                 "rtcp.ssrc.identifier",
 928                                 FT_UINT32,
 929                                 BASE_DEC,
 930                                 NULL,
 931                                 0x0,
 932                                 "", HFILL
 933                         }
 934                 },
 935                 {
 936                         &hf_rtcp_ssrc_fraction,
 937                         {
 938                                 "Fraction lost",
 939                                 "rtcp.ssrc.fraction",
 940                                 FT_UINT8,
 941                                 BASE_DEC,
 942                                 NULL,
 943                                 0x0,
 944                                 "", HFILL
 945                         }
 946                 },
 947                 {
 948                         &hf_rtcp_ssrc_cum_nr,
 949                         {
 950                                 "Cumulative number of packets lost",
 951                                 "rtcp.ssrc.cum_nr",
 952                                 FT_UINT32,
 953                                 BASE_DEC,
 954                                 NULL,
 955                                 0x0,
 956                                 "", HFILL
 957                         }
 958                 },
 959                 {
 960                         &hf_rtcp_ssrc_ext_high_seq,
 961                         {
 962                                 "Extended highest sequence number received",
 963                                 "rtcp.ssrc.ext_high",
 964                                 FT_UINT32,
 965                                 BASE_DEC,
 966                                 NULL,
 967                                 0x0,
 968                                 "", HFILL
 969                         }
 970                 },
 971                 {
 972                         &hf_rtcp_ssrc_high_seq,
 973                         {
 974                                 "Highest sequence number received",
 975                                 "rtcp.ssrc.high_seq",
 976                                 FT_UINT16,
 977                                 BASE_DEC,
 978                                 NULL,
 979                                 0x0,
 980                                 "", HFILL
 981                         }
 982                 },
 983                 {
 984                         &hf_rtcp_ssrc_high_cycles,
 985                         {
 986                                 "Sequence number cycles count",
 987                                 "rtcp.ssrc.high_cycles",
 988                                 FT_UINT16,
 989                                 BASE_DEC,
 990                                 NULL,
 991                                 0x0,
 992                                 "", HFILL
 993                         }
 994                 },
 995                 {
 996                         &hf_rtcp_ssrc_jitter,
 997                         {
 998                                 "Interarrival jitter",
 999                                 "rtcp.ssrc.jitter",
1000                                 FT_UINT32,
1001                                 BASE_DEC,
1002                                 NULL,
1003                                 0x0,
1004                                 "", HFILL
1005                         }
1006                 },
1007                 {
1008                         &hf_rtcp_ssrc_lsr,
1009                         {
1010                                 "Last SR timestamp",
1011                                 "rtcp.ssrc.lsr",
1012                                 FT_UINT32,
1013                                 BASE_DEC,
1014                                 NULL,
1015                                 0x0,
1016                                 "", HFILL
1017                         }
1018                 },
1019                 {
1020                         &hf_rtcp_ssrc_dlsr,
1021                         {
1022                                 "Delay since last SR timestamp",
1023                                 "rtcp.ssrc.dlsr",
1024                                 FT_UINT32,
1025                                 BASE_DEC,
1026                                 NULL,
1027                                 0x0,
1028                                 "", HFILL
1029                         }
1030                 },
1031                 {
1032                         &hf_rtcp_ssrc_csrc,
1033                         {
1034                                 "SSRC / CSRC identifier",
1035                                 "rtcp.sdes.ssrc_csrc",
1036                                 FT_UINT32,
1037                                 BASE_DEC,
1038                                 NULL,
1039                                 0x0,
1040                                 "", HFILL
1041                         }
1042                 },
1043                 {
1044                         &hf_rtcp_ssrc_type,
1045                         {
1046                                 "Type",
1047                                 "rtcp.sdes.type",
1048                                 FT_UINT8,
1049                                 BASE_DEC,
1050                                 VALS( rtcp_sdes_type_vals ),
1051                                 0x0,
1052                                 "", HFILL
1053                         }
1054                 },
1055                 {
1056                         &hf_rtcp_ssrc_length,
1057                         {
1058                                 "Length",
1059                                 "rtcp.sdes.length",
1060                                 FT_UINT32,
1061                                 BASE_DEC,
1062                                 NULL,
1063                                 0x0,
1064                                 "", HFILL
1065                         }
1066                 },
1067                 {
1068                         &hf_rtcp_ssrc_text,
1069                         {
1070                                 "Text",
1071                                 "rtcp.sdes.text",
1072                                 FT_STRING,
1073                                 BASE_NONE,
1074                                 NULL,
1075                                 0x0,
1076                                 "", HFILL
1077                         }
1078                 },
1079                 {
1080                         &hf_rtcp_ssrc_prefix_len,
1081                         {
1082                                 "Prefix length",
1083                                 "rtcp.sdes.prefix.length",
1084                                 FT_UINT8,
1085                                 BASE_DEC,
1086                                 NULL,
1087                                 0x0,
1088                                 "", HFILL
1089                         }
1090                 },
1091                 {
1092                         &hf_rtcp_ssrc_prefix_string,
1093                         {
1094                                 "Prefix string",
1095                                 "rtcp.sdes.prefix.string",
1096                                 FT_STRING,
1097                                 BASE_NONE,
1098                                 NULL,
1099                                 0x0,
1100                                 "", HFILL
1101                         }
1102                 },
1103                 {
1104                         &hf_rtcp_subtype,
1105                         {
1106                                 "Subtype",
1107                                 "rtcp.app.subtype",
1108                                 FT_UINT8,
1109                                 BASE_DEC,
1110                                 NULL,
1111                                 0x0,
1112                                 "", HFILL
1113                         }
1114                 },
1115                 {
1116                         &hf_rtcp_name_ascii,
1117                         {
1118                                 "Name (ASCII)",
1119                                 "rtcp.app.name",
1120                                 FT_STRING,
1121                                 BASE_NONE,
1122                                 NULL,
1123                                 0x0,
1124                                 "", HFILL
1125                         }
1126                 },
1127                 {
1128                         &hf_rtcp_app_data,
1129                         {
1130                                 "Application specific data",
1131                                 "rtcp.app.data",
1132                                 FT_BYTES,
1133                                 BASE_NONE,
1134                                 NULL,
1135                                 0x0,
1136                                 "", HFILL
1137                         }
1138                 },
1139                 {
1140                         &hf_rtcp_fsn,
1141                         {
1142                                 "First sequence number",
1143                                 "rtcp.nack.fsn",
1144                                 FT_UINT16,
1145                                 BASE_DEC,
1146                                 NULL,
1147                                 0x0,
1148                                 "", HFILL
1149                         }
1150                 },
1151                 {
1152                         &hf_rtcp_blp,
1153                         {
1154                                 "Bitmask of following lost packets",
1155                                 "rtcp.nack.blp",
1156                                 FT_UINT16,
1157                                 BASE_DEC,
1158                                 NULL,
1159                                 0x0,
1160                                 "", HFILL
1161                         }
1162                 },
1163                 {
1164                         &hf_rtcp_padding_count,
1165                         {
1166                                 "Padding count",
1167                                 "rtcp.padding.count",
1168                                 FT_UINT8,
1169                                 BASE_DEC,
1170                                 NULL,
1171                                 0x0,
1172                                 "", HFILL
1173                         }
1174                 },
1175                 {
1176                         &hf_rtcp_padding_data,
1177                         {
1178                                 "Padding data",
1179                                 "rtcp.padding.data",
1180                                 FT_BYTES,
1181                                 BASE_NONE,
1182                                 NULL,
1183                                 0x0,
1184                                 "", HFILL
1185                         }
1186                 },
1187 };
1188
1189         static gint *ett[] =
1190         {
1191                 &ett_rtcp,
1192                 &ett_ssrc,
1193                 &ett_ssrc_item,
1194                 &ett_ssrc_ext_high,
1195                 &ett_sdes,
1196                 &ett_sdes_item,
1197         };
1198
1199
1200         proto_rtcp = proto_register_protocol("Real-time Transport Control Protocol",
1201             "RTCP", "rtcp");
1202         proto_register_field_array(proto_rtcp, hf, array_length(hf));
1203         proto_register_subtree_array(ett, array_length(ett));
1204
1205         register_dissector("rtcp", dissect_rtcp, proto_rtcp);
1206
1207 #if 0
1208         register_init_routine( &rtcp_init );
1209 #endif
1210 }
1211
1212 void
1213 proto_reg_handoff_rtcp(void)
1214 {
1215         dissector_handle_t rtcp_handle;
1216
1217         /*
1218          * Register this dissector as one that can be selected by a
1219          * UDP port number.
1220          */
1221         rtcp_handle = find_dissector("rtcp");
1222         dissector_add_handle("udp.port", rtcp_handle);
1223 }