packet-rtp.c

   1 /* packet-rtp.c
   2  *
   3  * Routines for RTP dissection
   4  * RTP = Real time Transport Protocol
   5  *
   6  * Copyright 2000, Philips Electronics N.V.
   7  * Written by Andreas Sikkema <andreas.sikkema@philips.com>
   8  *
   9  * $Id: packet-rtp.c,v 1.41 2003/08/23 06:36:46 guy Exp $
  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 RTP protocol according to Annex A
  32  * of ITU-T Recommendation H.225.0 (02/98) or RFC 1889
  33  *
  34  * RTP traffic is handled by an even UDP portnumber. This can be any
  35  * port number, but there is a registered port available, port 5004
  36  * See Annex B of ITU-T Recommendation H.225.0, section B.7
  37  *
  38  * This doesn't dissect older versions of RTP, such as:
  39  *
  40  *    the vat protocol ("version 0") - see
  41  *
  42  *      ftp://ftp.ee.lbl.gov/conferencing/vat/alpha-test/vatsrc-4.0b2.tar.gz
  43  *
  44  *    and look in "session-vat.cc" if you want to write a dissector
  45  *    (have fun - there aren't any nice header files showing the packet
  46  *    format);
  47  *
  48  *    version 1, as documented in
  49  *
  50  *      ftp://gaia.cs.umass.edu/pub/hgschulz/rtp/draft-ietf-avt-rtp-04.txt
  51  */
  52
  53
  54 #ifdef HAVE_CONFIG_H
  55 # include "config.h"
  56 #endif
  57
  58 #include <glib.h>
  59 #include <epan/packet.h>
  60
  61 #include <stdio.h>
  62 #include <string.h>
  63
  64 #include "packet-rtp.h"
  65 #include "rtp_pt.h"
  66 #include <epan/conversation.h>
  67 #include "tap.h"
  68
  69 static int rtp_tap = -1;
  70
  71 static dissector_table_t rtp_pt_dissector_table;
  72
  73 /* RTP header fields             */
  74 static int proto_rtp           = -1;
  75 static int hf_rtp_version      = -1;
  76 static int hf_rtp_padding      = -1;
  77 static int hf_rtp_extension    = -1;
  78 static int hf_rtp_csrc_count   = -1;
  79 static int hf_rtp_marker       = -1;
  80 static int hf_rtp_payload_type = -1;
  81 static int hf_rtp_seq_nr       = -1;
  82 static int hf_rtp_timestamp    = -1;
  83 static int hf_rtp_ssrc         = -1;
  84 static int hf_rtp_csrc_item    = -1;
  85 static int hf_rtp_data         = -1;
  86 static int hf_rtp_padding_data = -1;
  87 static int hf_rtp_padding_count= -1;
  88
  89 /* RTP header extension fields   */
  90 static int hf_rtp_prof_define  = -1;
  91 static int hf_rtp_length       = -1;
  92 static int hf_rtp_hdr_ext      = -1;
  93
  94 /* RTP fields defining a sub tree */
  95 static gint ett_rtp       = -1;
  96 static gint ett_csrc_list = -1;
  97 static gint ett_hdr_ext   = -1;
  98
  99 static dissector_handle_t data_handle;
 100
 101 static gboolean dissect_rtp_heur( tvbuff_t *tvb, packet_info *pinfo,
 102     proto_tree *tree );
 103 static void dissect_rtp( tvbuff_t *tvb, packet_info *pinfo,
 104     proto_tree *tree );
 105
 106 /*
 107  * Fields in the first octet of the RTP header.
 108  */
 109
 110 /* Version is the first 2 bits of the first octet*/
 111 #define RTP_VERSION(octet)      ((octet) >> 6)
 112
 113 /* Padding is the third bit; No need to shift, because true is any value
 114    other than 0! */
 115 #define RTP_PADDING(octet)      ((octet) & 0x20)
 116
 117 /* Extension bit is the fourth bit */
 118 #define RTP_EXTENSION(octet)    ((octet) & 0x10)
 119
 120 /* CSRC count is the last four bits */
 121 #define RTP_CSRC_COUNT(octet)   ((octet) & 0xF)
 122
 123 static const value_string rtp_version_vals[] =
 124 {
 125         { 0, "Old VAT Version" },
 126         { 1, "First Draft Version" },
 127         { 2, "RFC 1889 Version" },
 128         { 0, NULL },
 129 };
 130
 131 /*
 132  * Fields in the second octet of the RTP header.
 133  */
 134
 135 /* Marker is the first bit of the second octet */
 136 #define RTP_MARKER(octet)       ((octet) & 0x80)
 137
 138 /* Payload type is the last 7 bits */
 139 #define RTP_PAYLOAD_TYPE(octet) ((octet) & 0x7F)
 140
 141 static const value_string rtp_payload_type_vals[] =
 142 {
 143         { PT_PCMU,      "ITU-T G.711 PCMU" },
 144         { PT_1016,      "USA Federal Standard FS-1016" },
 145         { PT_G721,      "ITU-T G.721" },
 146         { PT_GSM,       "GSM 06.10" },
 147         { PT_G723,      "ITU-T G.723" },
 148         { PT_DVI4_8000, "DVI4 8000 samples/s" },
 149         { PT_DVI4_16000, "DVI4 16000 samples/s" },
 150         { PT_LPC,       "Experimental linear predictive encoding from Xerox PARC" },
 151         { PT_PCMA,      "ITU-T G.711 PCMA" },
 152         { PT_G722,      "ITU-T G.722" },
 153         { PT_L16_STEREO, "16-bit uncompressed audio, stereo" },
 154         { PT_L16_MONO,  "16-bit uncompressed audio, monaural" },
 155         { PT_QCELP,     "Qualcomm Code Excited Linear Predictive coding" },
 156         { PT_CN,        "Comfort noise" },
 157         { PT_MPA,       "MPEG-I/II Audio"},
 158         { PT_G728,      "ITU-T G.728" },
 159         { PT_DVI4_11025, "DVI4 11025 samples/s" },
 160         { PT_DVI4_22050, "DVI4 22050 samples/s" },
 161         { PT_G729,      "ITU-T G.729" },
 162         { PT_CELB,      "Sun CellB video encoding" },
 163         { PT_JPEG,      "JPEG-compressed video" },
 164         { PT_NV,        "'nv' program" },
 165         { PT_H261,      "ITU-T H.261" },
 166         { PT_MPV,       "MPEG-I/II Video"},
 167         { PT_MP2T,      "MPEG-II transport streams"},
 168         { PT_H263,      "ITU-T H.263" },
 169         { 0,            NULL },
 170 };
 171
 172 static address fake_addr;
 173 static int heur_init = FALSE;
 174
 175 void rtp_add_address( packet_info *pinfo, const unsigned char* ip_addr,
 176     int prt )
 177 {
 178         address src_addr;
 179         conversation_t* pconv;
 180
 181         /*
 182          * If this isn't the first time this packet has been processed,
 183          * we've already done this work, so we don't need to do it
 184          * again.
 185          */
 186         if (pinfo->fd->flags.visited)
 187                 return;
 188
 189         src_addr.type = AT_IPv4;
 190         src_addr.len = 4;
 191         src_addr.data = ip_addr;
 192
 193         /*
 194          * The first time the function is called let the tcp dissector
 195          * know that we're interested in traffic
 196          */
 197         if ( ! heur_init ) {
 198                 heur_dissector_add( "udp", dissect_rtp_heur, proto_rtp );
 199                 heur_init = TRUE;
 200         }
 201
 202         /*
 203          * Check if the ip address an dport combination is not
 204          * already registered
 205          */
 206         pconv = find_conversation( &src_addr, &fake_addr, PT_UDP, prt, 0, 0 );
 207
 208         /*
 209          * If not, add
 210          * XXX - use wildcard address and port B?
 211          */
 212         if ( ! pconv ) {
 213                 pconv = conversation_new( &src_addr, &fake_addr, PT_UDP,
 214                     (guint32) prt, (guint32) 0, 0 );
 215                 conversation_add_proto_data(pconv, proto_rtp, NULL);
 216         }
 217
 218 }
 219
 220 #if 0
 221 static void rtp_init( void )
 222 {
 223         unsigned char* tmp_data;
 224         int i;
 225
 226         /* Create a fake adddress... */
 227         fake_addr.type = AT_IPv4;
 228         fake_addr.len = 4;
 229
 230         tmp_data = malloc( fake_addr.len );
 231         for ( i = 0; i < fake_addr.len; i++) {
 232                 tmp_data[i] = 0;
 233         }
 234         fake_addr.data = tmp_data;
 235 }
 236 #endif
 237
 238 static gboolean
 239 dissect_rtp_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
 240 {
 241         conversation_t* pconv;
 242
 243         /* This is a heuristic dissector, which means we get all the TCP
 244          * traffic not sent to a known dissector and not claimed by
 245          * a heuristic dissector called before us!
 246          * So we first check if the frame is really meant for us.
 247          */
 248         if ( ( pconv = find_conversation( &pinfo->src, &fake_addr, pinfo->ptype,
 249             pinfo->srcport, 0, 0 ) ) == NULL ) {
 250                 /*
 251                  * The source ip:port combination was not what we were
 252                  * looking for, check the destination
 253                  */
 254                 if ( ( pconv = find_conversation( &pinfo->dst, &fake_addr,
 255                     pinfo->ptype, pinfo->destport, 0, 0 ) ) == NULL ) {
 256                         return FALSE;
 257                 }
 258         }
 259
 260         /*
 261          * An RTP conversation always has a data item for RTP.
 262          * (Its existence is sufficient to indicate that this is an RTP
 263          * conversation.)
 264          */
 265         if (conversation_get_proto_data(pconv, proto_rtp) == NULL)
 266                 return FALSE;
 267
 268         dissect_rtp( tvb, pinfo, tree );
 269
 270         return TRUE;
 271 }
 272
 273 static void
 274 dissect_rtp_data( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 275     proto_tree *rtp_tree, int offset, unsigned int data_len,
 276     unsigned int data_reported_len, unsigned int payload_type )
 277 {
 278         tvbuff_t *newtvb;
 279
 280         newtvb = tvb_new_subset( tvb, offset, data_len, data_reported_len );
 281         if (!dissector_try_port(rtp_pt_dissector_table, payload_type, newtvb,
 282             pinfo, tree))
 283                 proto_tree_add_item( rtp_tree, hf_rtp_data, newtvb, 0, -1, FALSE );
 284 }
 285
 286 static void
 287 dissect_rtp( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree )
 288 {
 289         proto_item *ti            = NULL;
 290         proto_tree *rtp_tree      = NULL;
 291         proto_tree *rtp_csrc_tree = NULL;
 292         guint8      octet;
 293         unsigned int version;
 294         gboolean    padding_set;
 295         gboolean    extension_set;
 296         unsigned int csrc_count;
 297         gboolean    marker_set;
 298         unsigned int payload_type;
 299         unsigned int i            = 0;
 300         unsigned int hdr_extension= 0;
 301         unsigned int padding_count;
 302         int         data_len;
 303         unsigned int offset = 0;
 304         guint16     seq_num;
 305         guint32     timestamp;
 306         guint32     sync_src;
 307         guint32     csrc_item;
 308
 309         static struct _rtp_info rtp_info;
 310
 311         /* Get the fields in the first octet */
 312         octet = tvb_get_guint8( tvb, offset );
 313         version = RTP_VERSION( octet );
 314
 315         if (version != 2) {
 316                 /*
 317                  * Unknown or unsupported version.
 318                  */
 319                 if ( check_col( pinfo->cinfo, COL_PROTOCOL ) )   {
 320                         col_set_str( pinfo->cinfo, COL_PROTOCOL, "RTP" );
 321                 }
 322
 323                 if ( check_col( pinfo->cinfo, COL_INFO) ) {
 324                         col_add_fstr( pinfo->cinfo, COL_INFO,
 325                             "Unknown RTP version %u", version);
 326                 }
 327
 328                 if ( tree ) {
 329                         ti = proto_tree_add_item( tree, proto_rtp, tvb, offset, -1, FALSE );
 330                         rtp_tree = proto_item_add_subtree( ti, ett_rtp );
 331
 332                         proto_tree_add_uint( rtp_tree, hf_rtp_version, tvb,
 333                             offset, 1, version );
 334                 }
 335                 return;
 336         }
 337
 338         padding_set = RTP_PADDING( octet );
 339         extension_set = RTP_EXTENSION( octet );
 340         csrc_count = RTP_CSRC_COUNT( octet );
 341
 342         /* Get the fields in the second octet */
 343         octet = tvb_get_guint8( tvb, offset + 1 );
 344         marker_set = RTP_MARKER( octet );
 345         payload_type = RTP_PAYLOAD_TYPE( octet );
 346
 347         /* Get the subsequent fields */
 348         seq_num = tvb_get_ntohs( tvb, offset + 2 );
 349         timestamp = tvb_get_ntohl( tvb, offset + 4 );
 350         sync_src = tvb_get_ntohl( tvb, offset + 8 );
 351
 352         /* fill in the rtp_info structure */
 353         rtp_info.info_padding_set = padding_set;
 354         rtp_info.info_padding_count = 0;
 355         rtp_info.info_marker_set = marker_set;
 356         rtp_info.info_payload_type = payload_type;
 357         rtp_info.info_seq_num = seq_num;
 358         rtp_info.info_timestamp = timestamp;
 359         rtp_info.info_sync_src = sync_src;
 360         rtp_info.info_data_len = tvb_reported_length_remaining( tvb, offset );
 361
 362         if ( check_col( pinfo->cinfo, COL_PROTOCOL ) )   {
 363                 col_set_str( pinfo->cinfo, COL_PROTOCOL, "RTP" );
 364         }
 365
 366         if ( check_col( pinfo->cinfo, COL_INFO) ) {
 367                 col_add_fstr( pinfo->cinfo, COL_INFO,
 368                     "Payload type=%s, SSRC=%u, Seq=%u, Time=%u%s",
 369                     val_to_str( payload_type, rtp_payload_type_vals,
 370                         "Unknown (%u)" ),
 371                     sync_src,
 372                     seq_num,
 373                     timestamp,
 374                     marker_set ? ", Mark" : "");
 375         }
 376         if ( tree ) {
 377                 ti = proto_tree_add_item( tree, proto_rtp, tvb, offset, -1, FALSE );
 378                 rtp_tree = proto_item_add_subtree( ti, ett_rtp );
 379
 380                 proto_tree_add_uint( rtp_tree, hf_rtp_version, tvb,
 381                     offset, 1, version );
 382                 proto_tree_add_boolean( rtp_tree, hf_rtp_padding, tvb,
 383                     offset, 1, padding_set );
 384                 proto_tree_add_boolean( rtp_tree, hf_rtp_extension, tvb,
 385                     offset, 1, extension_set );
 386                 proto_tree_add_uint( rtp_tree, hf_rtp_csrc_count, tvb,
 387                     offset, 1, csrc_count );
 388                 offset++;
 389
 390                 proto_tree_add_boolean( rtp_tree, hf_rtp_marker, tvb, offset,
 391                     1, marker_set );
 392                 proto_tree_add_uint( rtp_tree, hf_rtp_payload_type, tvb,
 393                     offset, 1, payload_type );
 394                 offset++;
 395
 396                 /* Sequence number 16 bits (2 octets) */
 397                 proto_tree_add_uint( rtp_tree, hf_rtp_seq_nr, tvb, offset, 2, seq_num );
 398                 offset += 2;
 399
 400                 /* Timestamp 32 bits (4 octets) */
 401                 proto_tree_add_uint( rtp_tree, hf_rtp_timestamp, tvb, offset, 4, timestamp );
 402                 offset += 4;
 403
 404                 /* Synchronization source identifier 32 bits (4 octets) */
 405                 proto_tree_add_uint( rtp_tree, hf_rtp_ssrc, tvb, offset, 4, sync_src );
 406                 offset += 4;
 407         } else {
 408                 offset += 12;
 409         }
 410         /* CSRC list*/
 411         if ( csrc_count > 0 ) {
 412                 if ( tree ) {
 413                         ti = proto_tree_add_text(rtp_tree, tvb, offset, csrc_count * 4, "Contributing Source identifiers");
 414                         rtp_csrc_tree = proto_item_add_subtree( ti, ett_csrc_list );
 415                 }
 416                 for (i = 0; i < csrc_count; i++ ) {
 417                         csrc_item = tvb_get_ntohl( tvb, offset );
 418                         if ( tree ) proto_tree_add_uint_format( rtp_csrc_tree,
 419                             hf_rtp_csrc_item, tvb, offset, 4,
 420                             csrc_item,
 421                             "CSRC item %d: %u",
 422                             i, csrc_item );
 423                         offset += 4;
 424                 }
 425         }
 426
 427         /* Optional RTP header extension */
 428         if ( extension_set ) {
 429                 /* Defined by profile field is 16 bits (2 octets) */
 430                 if ( tree ) proto_tree_add_uint( rtp_tree, hf_rtp_prof_define, tvb, offset, 2, tvb_get_ntohs( tvb, offset ) );
 431                 offset += 2;
 432
 433                 hdr_extension = tvb_get_ntohs( tvb, offset );
 434                 if ( tree ) proto_tree_add_uint( rtp_tree, hf_rtp_length, tvb,
 435                     offset, 2, hdr_extension);
 436                 offset += 2;
 437                 if ( hdr_extension > 0 ) {
 438                         if ( tree ) { ti = proto_tree_add_text(rtp_tree, tvb, offset, csrc_count * 4, "Header extensions");
 439                         /* I'm re-using the old tree variable here
 440                            from the CSRC list!*/
 441                         rtp_csrc_tree = proto_item_add_subtree( ti,
 442                             ett_hdr_ext );
 443             }
 444                         for (i = 0; i < hdr_extension; i++ ) {
 445                                 if ( tree ) proto_tree_add_uint( rtp_csrc_tree, hf_rtp_hdr_ext, tvb, offset, 4, tvb_get_ntohl( tvb, offset ) );
 446                                 offset += 4;
 447                         }
 448                 }
 449         }
 450
 451         if ( padding_set ) {
 452                 /*
 453                  * This RTP frame has padding - find it.
 454                  *
 455                  * The padding count is found in the LAST octet of
 456                  * the packet; it contains the number of octets
 457                  * that can be ignored at the end of the packet.
 458                  */
 459                 if (tvb_length(tvb) < tvb_reported_length(tvb)) {
 460                         /*
 461                          * We don't *have* the last octet of the
 462                          * packet, so we can't get the padding
 463                          * count.
 464                          *
 465                          * Put an indication of that into the
 466                          * tree, and just put in a raw data
 467                          * item.
 468                          */
 469                         if ( tree ) proto_tree_add_text(rtp_tree, tvb, 0, 0,
 470                             "Frame has padding, but not all the frame data was captured");
 471                         call_dissector(data_handle,
 472                             tvb_new_subset(tvb, offset, -1, -1),
 473                             pinfo, rtp_tree);
 474                         return;
 475                 }
 476
 477                 padding_count = tvb_get_guint8( tvb,
 478                     tvb_reported_length( tvb ) - 1 );
 479                 data_len =
 480                     tvb_reported_length_remaining( tvb, offset ) - padding_count;
 481
 482                 rtp_info.info_payload_offset = offset;
 483                 rtp_info.info_payload_len = tvb_length_remaining(tvb, offset);
 484                 rtp_info.info_padding_count = padding_count;
 485
 486                 if (data_len > 0) {
 487                         /*
 488                          * There's data left over when you take out
 489                          * the padding; dissect it.
 490                          */
 491                         dissect_rtp_data( tvb, pinfo, tree, rtp_tree,
 492                             offset,
 493                             data_len,
 494                             data_len,
 495                             payload_type );
 496                         offset += data_len;
 497                 } else if (data_len < 0) {
 498                         /*
 499                          * The padding count is bigger than the
 500                          * amount of RTP payload in the packet!
 501                          * Clip the padding count.
 502                          *
 503                          * XXX - put an item in the tree to indicate
 504                          * that the padding count is bogus?
 505                          */
 506                         padding_count =
 507                             tvb_reported_length_remaining(tvb, offset);
 508                 }
 509                 if (padding_count > 1) {
 510                         /*
 511                          * There's more than one byte of padding;
 512                          * show all but the last byte as padding
 513                          * data.
 514                          */
 515                         if ( tree ) proto_tree_add_item( rtp_tree, hf_rtp_padding_data,
 516                             tvb, offset, padding_count - 1, FALSE );
 517                         offset += padding_count - 1;
 518                 }
 519                 /*
 520                  * Show the last byte in the PDU as the padding
 521                  * count.
 522                  */
 523                 if ( tree ) proto_tree_add_item( rtp_tree, hf_rtp_padding_count,
 524                     tvb, offset, 1, FALSE );
 525         }
 526         else {
 527                 /*
 528                  * No padding.
 529                  */
 530                 dissect_rtp_data( tvb, pinfo, tree, rtp_tree, offset,
 531                     tvb_length_remaining( tvb, offset ),
 532                     tvb_reported_length_remaining( tvb, offset ),
 533                     payload_type );
 534                 rtp_info.info_payload_offset = offset;
 535                 rtp_info.info_payload_len = tvb_length_remaining(tvb, offset);
 536         }
 537         tap_queue_packet(rtp_tap, pinfo, &rtp_info);
 538 }
 539
 540 void
 541 proto_register_rtp(void)
 542 {
 543         static hf_register_info hf[] =
 544         {
 545                 {
 546                         &hf_rtp_version,
 547                         {
 548                                 "Version",
 549                                 "rtp.version",
 550                                 FT_UINT8,
 551                                 BASE_DEC,
 552                                 VALS(rtp_version_vals),
 553                                 0x0,
 554                                 "", HFILL
 555                         }
 556                 },
 557                 {
 558                         &hf_rtp_padding,
 559                         {
 560                                 "Padding",
 561                                 "rtp.padding",
 562                                 FT_BOOLEAN,
 563                                 BASE_NONE,
 564                                 NULL,
 565                                 0x0,
 566                                 "", HFILL
 567                         }
 568                 },
 569                 {
 570                         &hf_rtp_extension,
 571                         {
 572                                 "Extension",
 573                                 "rtp.ext",
 574                                 FT_BOOLEAN,
 575                                 BASE_NONE,
 576                                 NULL,
 577                                 0x0,
 578                                 "", HFILL
 579                         }
 580                 },
 581                 {
 582                         &hf_rtp_csrc_count,
 583                         {
 584                                 "Contributing source identifiers count",
 585                                 "rtp.cc",
 586                                 FT_UINT8,
 587                                 BASE_DEC,
 588                                 NULL,
 589                                 0x0,
 590                                 "", HFILL
 591                         }
 592                 },
 593                 {
 594                         &hf_rtp_marker,
 595                         {
 596                                 "Marker",
 597                                 "rtp.marker",
 598                                 FT_BOOLEAN,
 599                                 BASE_NONE,
 600                                 NULL,
 601                                 0x0,
 602                                 "", HFILL
 603                         }
 604                 },
 605                 {
 606                         &hf_rtp_payload_type,
 607                         {
 608                                 "Payload type",
 609                                 "rtp.p_type",
 610                                 FT_UINT8,
 611                                 BASE_DEC,
 612                                 VALS(rtp_payload_type_vals),
 613                                 0x0,
 614                                 "", HFILL
 615                         }
 616                 },
 617                 {
 618                         &hf_rtp_seq_nr,
 619                         {
 620                                 "Sequence number",
 621                                 "rtp.seq",
 622                                 FT_UINT16,
 623                                 BASE_DEC,
 624                                 NULL,
 625                                 0x0,
 626                                 "", HFILL
 627                         }
 628                 },
 629                 {
 630                         &hf_rtp_timestamp,
 631                         {
 632                                 "Timestamp",
 633                                 "rtp.timestamp",
 634                                 FT_UINT32,
 635                                 BASE_DEC,
 636                                 NULL,
 637                                 0x0,
 638                                 "", HFILL
 639                         }
 640                 },
 641                 {
 642                         &hf_rtp_ssrc,
 643                         {
 644                                 "Synchronization Source identifier",
 645                                 "rtp.ssrc",
 646                                 FT_UINT32,
 647                                 BASE_DEC,
 648                                 NULL,
 649                                 0x0,
 650                                 "", HFILL
 651                         }
 652                 },
 653                 {
 654                         &hf_rtp_prof_define,
 655                         {
 656                                 "Defined by profile",
 657                                 "rtp.ext.profile",
 658                                 FT_UINT16,
 659                                 BASE_DEC,
 660                                 NULL,
 661                                 0x0,
 662                                 "", HFILL
 663                         }
 664                 },
 665                 {
 666                         &hf_rtp_length,
 667                         {
 668                                 "Extension length",
 669                                 "rtp.ext.len",
 670                                 FT_UINT16,
 671                                 BASE_DEC,
 672                                 NULL,
 673                                 0x0,
 674                                 "", HFILL
 675                         }
 676                 },
 677                 {
 678                         &hf_rtp_csrc_item,
 679                         {
 680                                 "CSRC item",
 681                                 "rtp.csrc.item",
 682                                 FT_UINT32,
 683                                 BASE_DEC,
 684                                 NULL,
 685                                 0x0,
 686                                 "", HFILL
 687                         }
 688                 },
 689                 {
 690                         &hf_rtp_hdr_ext,
 691                         {
 692                                 "Header extension",
 693                                 "rtp.hdr_ext",
 694                                 FT_UINT32,
 695                                 BASE_DEC,
 696                                 NULL,
 697                                 0x0,
 698                                 "", HFILL
 699                         }
 700                 },
 701                 {
 702                         &hf_rtp_data,
 703                         {
 704                                 "Payload",
 705                                 "rtp.payload",
 706                                 FT_BYTES,
 707                                 BASE_HEX,
 708                                 NULL,
 709                                 0x0,
 710                                 "", HFILL
 711                         }
 712                 },
 713                 {
 714                         &hf_rtp_padding_data,
 715                         {
 716                                 "Padding data",
 717                                 "rtp.padding.data",
 718                                 FT_BYTES,
 719                                 BASE_HEX,
 720                                 NULL,
 721                                 0x0,
 722                                 "", HFILL
 723                         }
 724                 },
 725                 {
 726                         &hf_rtp_padding_count,
 727                         {
 728                                 "Padding count",
 729                                 "rtp.padding.count",
 730                                 FT_UINT8,
 731                                 BASE_DEC,
 732                                 NULL,
 733                                 0x0,
 734                                 "", HFILL
 735                         }
 736                 },
 737 };
 738
 739         static gint *ett[] =
 740         {
 741                 &ett_rtp,
 742                 &ett_csrc_list,
 743                 &ett_hdr_ext,
 744         };
 745
 746
 747         proto_rtp = proto_register_protocol("Real-Time Transport Protocol",
 748             "RTP", "rtp");
 749         proto_register_field_array(proto_rtp, hf, array_length(hf));
 750         proto_register_subtree_array(ett, array_length(ett));
 751
 752         register_dissector("rtp", dissect_rtp, proto_rtp);
 753         rtp_tap = register_tap("rtp");
 754
 755         rtp_pt_dissector_table = register_dissector_table("rtp.pt",
 756             "RTP payload type", FT_UINT8, BASE_DEC);
 757
 758 #if 0
 759         register_init_routine( &rtp_init );
 760 #endif
 761 }
 762
 763 void
 764 proto_reg_handoff_rtp(void)
 765 {
 766         dissector_handle_t rtp_handle;
 767
 768         data_handle = find_dissector("data");
 769
 770         /*
 771          * Register this dissector as one that can be selected by a
 772          * UDP port number.
 773          */
 774         rtp_handle = find_dissector("rtp");
 775         dissector_add_handle("udp.port", rtp_handle);
 776 }