packet-rtcp.c

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