content/browser/renderer_host/p2p/socket_host.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/p2p/socket_host.h"
   6
   7 #include "base/sys_byteorder.h"
   8 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
   9 #include "content/browser/renderer_host/p2p/socket_host_tcp_server.h"
  10 #include "content/browser/renderer_host/p2p/socket_host_udp.h"
  11 #include "content/browser/renderer_host/render_process_host_impl.h"
  12 #include "content/public/browser/browser_thread.h"
  13 #include "crypto/hmac.h"
  14 #include "third_party/libjingle/source/talk/p2p/base/stun.h"
  15 #include "third_party/webrtc/base/asyncpacketsocket.h"
  16 #include "third_party/webrtc/base/byteorder.h"
  17 #include "third_party/webrtc/base/messagedigest.h"
  18
  19 namespace {
  20
  21 const uint32 kStunMagicCookie = 0x2112A442;
  22 const int kMinRtpHdrLen = 12;
  23 const int kRtpExtnHdrLen = 4;
  24 const int kDtlsRecordHeaderLen = 13;
  25 const int kTurnChannelHdrLen = 4;
  26 const int kAbsSendTimeExtnLen = 3;
  27 const int kOneByteHdrLen = 1;
  28
  29 // Fake auth tag written by the render process if external authentication is
  30 // enabled. HMAC in packet will be compared against this value before updating
  31 // packet with actual HMAC value.
  32 static const unsigned char kFakeAuthTag[10] = {
  33     0xba, 0xdd, 0xba, 0xdd, 0xba, 0xdd, 0xba, 0xdd, 0xba, 0xdd
  34 };
  35
  36 bool IsTurnChannelData(const char* data) {
  37   return ((*data & 0xC0) == 0x40);
  38 }
  39
  40 bool IsDtlsPacket(const char* data, int len) {
  41   const uint8* u = reinterpret_cast<const uint8*>(data);
  42   return (len >= kDtlsRecordHeaderLen && (u[0] > 19 && u[0] < 64));
  43 }
  44
  45 bool IsRtcpPacket(const char* data) {
  46   int type = (static_cast<uint8>(data[1]) & 0x7F);
  47   return (type >= 64 && type < 96);
  48 }
  49
  50 bool IsTurnSendIndicationPacket(const char* data) {
  51   uint16 type = rtc::GetBE16(data);
  52   return (type == cricket::TURN_SEND_INDICATION);
  53 }
  54
  55 bool IsRtpPacket(const char* data, int len) {
  56   return ((*data & 0xC0) == 0x80);
  57 }
  58
  59 // Verifies rtp header and message length.
  60 bool ValidateRtpHeader(const char* rtp, int length, size_t* header_length) {
  61   if (header_length)
  62     *header_length = 0;
  63
  64   int cc_count = rtp[0] & 0x0F;
  65   int rtp_hdr_len_without_extn = kMinRtpHdrLen + 4 * cc_count;
  66   if (rtp_hdr_len_without_extn > length) {
  67     return false;
  68   }
  69
  70   // If extension bit is not set, we are done with header processing, as input
  71   // length is verified above.
  72   if (!(rtp[0] & 0x10)) {
  73     if (header_length)
  74       *header_length = rtp_hdr_len_without_extn;
  75
  76     return true;
  77   }
  78
  79   rtp += rtp_hdr_len_without_extn;
  80
  81   // Getting extension profile length.
  82   // Length is in 32 bit words.
  83   uint16 extn_length = rtc::GetBE16(rtp + 2) * 4;
  84
  85   // Verify input length against total header size.
  86   if (rtp_hdr_len_without_extn + kRtpExtnHdrLen + extn_length > length) {
  87     return false;
  88   }
  89
  90   if (header_length)
  91     *header_length = rtp_hdr_len_without_extn + kRtpExtnHdrLen + extn_length;
  92   return true;
  93 }
  94
  95 void UpdateAbsSendTimeExtnValue(char* extn_data, int len,
  96                                 uint32 abs_send_time) {
  97   // Absolute send time in RTP streams.
  98   //
  99   // The absolute send time is signaled to the receiver in-band using the
 100   // general mechanism for RTP header extensions [RFC5285]. The payload
 101   // of this extension (the transmitted value) is a 24-bit unsigned integer
 102   // containing the sender's current time in seconds as a fixed point number
 103   // with 18 bits fractional part.
 104   //
 105   // The form of the absolute send time extension block:
 106   //
 107   //    0                   1                   2                   3
 108   //    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 109   //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 110   //   |  ID   | len=2 |              absolute send time               |
 111   //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 112   DCHECK_EQ(len, kAbsSendTimeExtnLen);
 113   // Now() has resolution ~1-15ms, using HighResNow(). But it is warned not to
 114   // use it unless necessary, as it is expensive than Now().
 115   uint32 now_second = abs_send_time;
 116   if (!now_second) {
 117     uint64 now_us =
 118         (base::TimeTicks::HighResNow() - base::TimeTicks()).InMicroseconds();
 119     // Convert second to 24-bit unsigned with 18 bit fractional part
 120     now_second =
 121         ((now_us << 18) / base::Time::kMicrosecondsPerSecond) & 0x00FFFFFF;
 122   }
 123   // TODO(mallinath) - Add SetBE24 to byteorder.h in libjingle.
 124   extn_data[0] = static_cast<uint8>(now_second >> 16);
 125   extn_data[1] = static_cast<uint8>(now_second >> 8);
 126   extn_data[2] = static_cast<uint8>(now_second);
 127 }
 128
 129 // Assumes |len| is actual packet length + tag length. Updates HMAC at end of
 130 // the RTP packet.
 131 void UpdateRtpAuthTag(char* rtp, int len,
 132                       const rtc::PacketOptions& options) {
 133   // If there is no key, return.
 134   if (options.packet_time_params.srtp_auth_key.empty())
 135     return;
 136
 137   size_t tag_length = options.packet_time_params.srtp_auth_tag_len;
 138   char* auth_tag = rtp + (len - tag_length);
 139
 140   // We should have a fake HMAC value @ auth_tag.
 141   DCHECK_EQ(0, memcmp(auth_tag, kFakeAuthTag, tag_length));
 142
 143   crypto::HMAC hmac(crypto::HMAC::SHA1);
 144   if (!hmac.Init(reinterpret_cast<const unsigned char*>(
 145         &options.packet_time_params.srtp_auth_key[0]),
 146         options.packet_time_params.srtp_auth_key.size())) {
 147     NOTREACHED();
 148     return;
 149   }
 150
 151   if (hmac.DigestLength() < tag_length) {
 152     NOTREACHED();
 153     return;
 154   }
 155
 156   // Copy ROC after end of rtp packet.
 157   memcpy(auth_tag, &options.packet_time_params.srtp_packet_index, 4);
 158   // Authentication of a RTP packet will have RTP packet + ROC size.
 159   int auth_required_length = len - tag_length + 4;
 160
 161   unsigned char output[64];
 162   if (!hmac.Sign(base::StringPiece(rtp, auth_required_length),
 163                  output, sizeof(output))) {
 164     NOTREACHED();
 165     return;
 166   }
 167   // Copy HMAC from output to packet. This is required as auth tag length
 168   // may not be equal to the actual HMAC length.
 169   memcpy(auth_tag, output, tag_length);
 170 }
 171
 172 }  // namespace
 173
 174 namespace content {
 175
 176 namespace packet_processing_helpers {
 177
 178 bool ApplyPacketOptions(char* data, int length,
 179                         const rtc::PacketOptions& options,
 180                         uint32 abs_send_time) {
 181   DCHECK(data != NULL);
 182   DCHECK(length > 0);
 183   // if there is no valid |rtp_sendtime_extension_id| and |srtp_auth_key| in
 184   // PacketOptions, nothing to be updated in this packet.
 185   if (options.packet_time_params.rtp_sendtime_extension_id == -1 &&
 186       options.packet_time_params.srtp_auth_key.empty()) {
 187     return true;
 188   }
 189
 190   DCHECK(!IsDtlsPacket(data, length));
 191   DCHECK(!IsRtcpPacket(data));
 192
 193   // If there is a srtp auth key present then packet must be a RTP packet.
 194   // RTP packet may have been wrapped in a TURN Channel Data or
 195   // TURN send indication.
 196   int rtp_start_pos;
 197   int rtp_length;
 198   if (!GetRtpPacketStartPositionAndLength(
 199       data, length, &rtp_start_pos, &rtp_length)) {
 200     // This method should never return false.
 201     NOTREACHED();
 202     return false;
 203   }
 204
 205   // Skip to rtp packet.
 206   char* start = data + rtp_start_pos;
 207   // If packet option has non default value (-1) for sendtime extension id,
 208   // then we should parse the rtp packet to update the timestamp. Otherwise
 209   // just calculate HMAC and update packet with it.
 210   if (options.packet_time_params.rtp_sendtime_extension_id != -1) {
 211     UpdateRtpAbsSendTimeExtn(
 212         start, rtp_length,
 213         options.packet_time_params.rtp_sendtime_extension_id, abs_send_time);
 214   }
 215
 216   UpdateRtpAuthTag(start, rtp_length, options);
 217   return true;
 218 }
 219
 220 bool GetRtpPacketStartPositionAndLength(const char* packet,
 221                                         int length,
 222                                         int* rtp_start_pos,
 223                                         int* rtp_packet_length) {
 224   int rtp_begin;
 225   int rtp_length = 0;
 226   if (IsTurnChannelData(packet)) {
 227     // Turn Channel Message header format.
 228     //   0                   1                   2                   3
 229     //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 230     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 231     // |         Channel Number        |            Length             |
 232     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 233     // |                                                               |
 234     // /                       Application Data                        /
 235     // /                                                               /
 236     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 237     if (length < kTurnChannelHdrLen) {
 238       return false;
 239     }
 240
 241     rtp_begin = kTurnChannelHdrLen;
 242     rtp_length = rtc::GetBE16(&packet[2]);
 243     if (length < rtp_length + kTurnChannelHdrLen) {
 244       return false;
 245     }
 246   } else if (IsTurnSendIndicationPacket(packet)) {
 247     if (length <= P2PSocketHost::kStunHeaderSize) {
 248       // Message must be greater than 20 bytes, if it's carrying any payload.
 249       return false;
 250     }
 251     // Validate STUN message length.
 252     int stun_msg_len = rtc::GetBE16(&packet[2]);
 253     if (stun_msg_len + P2PSocketHost::kStunHeaderSize != length) {
 254       return false;
 255     }
 256
 257     // First skip mandatory stun header which is of 20 bytes.
 258     rtp_begin = P2PSocketHost::kStunHeaderSize;
 259     // Loop through STUN attributes until we find STUN DATA attribute.
 260     const char* start = packet + rtp_begin;
 261     bool data_attr_present = false;
 262     while ((packet + rtp_begin) - start < stun_msg_len) {
 263       // Keep reading STUN attributes until we hit DATA attribute.
 264       // Attribute will be a TLV structure.
 265       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 266       // |         Type                  |            Length             |
 267       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 268       // |                         Value (variable)                ....
 269       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 270       // The value in the length field MUST contain the length of the Value
 271       // part of the attribute, prior to padding, measured in bytes.  Since
 272       // STUN aligns attributes on 32-bit boundaries, attributes whose content
 273       // is not a multiple of 4 bytes are padded with 1, 2, or 3 bytes of
 274       // padding so that its value contains a multiple of 4 bytes.  The
 275       // padding bits are ignored, and may be any value.
 276       uint16 attr_type, attr_length;
 277       // Getting attribute type and length.
 278       attr_type = rtc::GetBE16(&packet[rtp_begin]);
 279       attr_length = rtc::GetBE16(
 280           &packet[rtp_begin + sizeof(attr_type)]);
 281       // Checking for bogus attribute length.
 282       if (length < attr_length + rtp_begin) {
 283         return false;
 284       }
 285
 286       if (attr_type != cricket::STUN_ATTR_DATA) {
 287         rtp_begin += sizeof(attr_type) + sizeof(attr_length) + attr_length;
 288         if ((attr_length % 4) != 0) {
 289           rtp_begin += (4 - (attr_length % 4));
 290         }
 291         continue;
 292       }
 293
 294       data_attr_present = true;
 295       rtp_begin += 4;  // Skip STUN_DATA_ATTR header.
 296       rtp_length = attr_length;
 297       // One final check of length before exiting.
 298       if (length < rtp_length + rtp_begin) {
 299         return false;
 300       }
 301       // We found STUN_DATA_ATTR. We can skip parsing rest of the packet.
 302       break;
 303     }
 304
 305     if (!data_attr_present) {
 306       // There is no data attribute present in the message. We can't do anything
 307       // with the message.
 308       return false;
 309     }
 310
 311   } else {
 312     // This is a raw RTP packet.
 313     rtp_begin = 0;
 314     rtp_length = length;
 315   }
 316
 317   // Making sure we have a valid RTP packet at the end.
 318   if ((rtp_length >= kMinRtpHdrLen) &&
 319       IsRtpPacket(packet + rtp_begin, rtp_length) &&
 320       ValidateRtpHeader(packet + rtp_begin, rtp_length, NULL)) {
 321     *rtp_start_pos = rtp_begin;
 322     *rtp_packet_length = rtp_length;
 323     return true;
 324   }
 325   return false;
 326 }
 327
 328 // ValidateRtpHeader must be called before this method to make sure, we have
 329 // a sane rtp packet.
 330 bool UpdateRtpAbsSendTimeExtn(char* rtp, int length,
 331                               int extension_id, uint32 abs_send_time) {
 332   //  0                   1                   2                   3
 333   //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 334   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 335   // |V=2|P|X|  CC   |M|     PT      |       sequence number         |
 336   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 337   // |                           timestamp                           |
 338   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 339   // |           synchronization source (SSRC) identifier            |
 340   // +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 341   // |            contributing source (CSRC) identifiers             |
 342   // |                             ....                              |
 343   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 344
 345   // Return if extension bit is not set.
 346   if (!(rtp[0] & 0x10)) {
 347     return true;
 348   }
 349
 350   int cc_count = rtp[0] & 0x0F;
 351   int rtp_hdr_len_without_extn = kMinRtpHdrLen + 4 * cc_count;
 352
 353   rtp += rtp_hdr_len_without_extn;
 354
 355   // Getting extension profile ID and length.
 356   uint16 profile_id = rtc::GetBE16(rtp);
 357   // Length is in 32 bit words.
 358   uint16 extn_length = rtc::GetBE16(rtp + 2) * 4;
 359
 360   rtp += kRtpExtnHdrLen;  // Moving past extn header.
 361
 362   bool found = false;
 363   // WebRTC is using one byte header extension.
 364   // TODO(mallinath) - Handle two byte header extension.
 365   if (profile_id == 0xBEDE) {  // OneByte extension header
 366     //  0
 367     //  0 1 2 3 4 5 6 7
 368     // +-+-+-+-+-+-+-+-+
 369     // |  ID   |  len  |
 370     // +-+-+-+-+-+-+-+-+
 371
 372     //  0                   1                   2                   3
 373     //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 374     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 375     // |       0xBE    |    0xDE       |           length=3            |
 376     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 377     // |  ID   | L=0   |     data      |  ID   |  L=1  |   data...
 378     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 379     //       ...data   |    0 (pad)    |    0 (pad)    |  ID   | L=3   |
 380     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 381     // |                          data                                 |
 382     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 383     char* extn_start = rtp;
 384     while (rtp - extn_start < extn_length) {
 385       const int id = (*rtp & 0xF0) >> 4;
 386       const int len = (*rtp & 0x0F) + 1;
 387       // The 4-bit length is the number minus one of data bytes of this header
 388       // extension element following the one-byte header.
 389       if (id == extension_id) {
 390         UpdateAbsSendTimeExtnValue(rtp + kOneByteHdrLen, len, abs_send_time);
 391         found = true;
 392         break;
 393       }
 394       rtp += kOneByteHdrLen + len;
 395       // Counting padding bytes.
 396       while ((*rtp == 0) && (rtp - extn_start < extn_length)) {
 397         ++rtp;
 398       }
 399     }
 400   }
 401   return found;
 402 }
 403
 404 }  // packet_processing_helpers
 405
 406 P2PSocketHost::P2PSocketHost(IPC::Sender* message_sender, int socket_id)
 407     : message_sender_(message_sender),
 408       id_(socket_id),
 409       state_(STATE_UNINITIALIZED),
 410       dump_incoming_rtp_packet_(false),
 411       dump_outgoing_rtp_packet_(false),
 412       weak_ptr_factory_(this) {
 413 }
 414
 415 P2PSocketHost::~P2PSocketHost() { }
 416
 417 // Verifies that the packet |data| has a valid STUN header.
 418 // static
 419 bool P2PSocketHost::GetStunPacketType(
 420     const char* data, int data_size, StunMessageType* type) {
 421
 422   if (data_size < kStunHeaderSize)
 423     return false;
 424
 425   uint32 cookie = base::NetToHost32(*reinterpret_cast<const uint32*>(data + 4));
 426   if (cookie != kStunMagicCookie)
 427     return false;
 428
 429   uint16 length = base::NetToHost16(*reinterpret_cast<const uint16*>(data + 2));
 430   if (length != data_size - kStunHeaderSize)
 431     return false;
 432
 433   int message_type = base::NetToHost16(*reinterpret_cast<const uint16*>(data));
 434
 435   // Verify that the type is known:
 436   switch (message_type) {
 437     case STUN_BINDING_REQUEST:
 438     case STUN_BINDING_RESPONSE:
 439     case STUN_BINDING_ERROR_RESPONSE:
 440     case STUN_SHARED_SECRET_REQUEST:
 441     case STUN_SHARED_SECRET_RESPONSE:
 442     case STUN_SHARED_SECRET_ERROR_RESPONSE:
 443     case STUN_ALLOCATE_REQUEST:
 444     case STUN_ALLOCATE_RESPONSE:
 445     case STUN_ALLOCATE_ERROR_RESPONSE:
 446     case STUN_SEND_REQUEST:
 447     case STUN_SEND_RESPONSE:
 448     case STUN_SEND_ERROR_RESPONSE:
 449     case STUN_DATA_INDICATION:
 450       *type = static_cast<StunMessageType>(message_type);
 451       return true;
 452
 453     default:
 454       return false;
 455   }
 456 }
 457
 458 // static
 459 bool P2PSocketHost::IsRequestOrResponse(StunMessageType type) {
 460   return type == STUN_BINDING_REQUEST || type == STUN_BINDING_RESPONSE ||
 461       type == STUN_ALLOCATE_REQUEST || type == STUN_ALLOCATE_RESPONSE;
 462 }
 463
 464 // static
 465 P2PSocketHost* P2PSocketHost::Create(IPC::Sender* message_sender,
 466                                      int socket_id,
 467                                      P2PSocketType type,
 468                                      net::URLRequestContextGetter* url_context,
 469                                      P2PMessageThrottler* throttler) {
 470   switch (type) {
 471     case P2P_SOCKET_UDP:
 472       return new P2PSocketHostUdp(message_sender, socket_id, throttler);
 473     case P2P_SOCKET_TCP_SERVER:
 474       return new P2PSocketHostTcpServer(
 475           message_sender, socket_id, P2P_SOCKET_TCP_CLIENT);
 476
 477     case P2P_SOCKET_STUN_TCP_SERVER:
 478       return new P2PSocketHostTcpServer(
 479           message_sender, socket_id, P2P_SOCKET_STUN_TCP_CLIENT);
 480
 481     case P2P_SOCKET_TCP_CLIENT:
 482     case P2P_SOCKET_SSLTCP_CLIENT:
 483     case P2P_SOCKET_TLS_CLIENT:
 484       return new P2PSocketHostTcp(message_sender, socket_id, type, url_context);
 485
 486     case P2P_SOCKET_STUN_TCP_CLIENT:
 487     case P2P_SOCKET_STUN_SSLTCP_CLIENT:
 488     case P2P_SOCKET_STUN_TLS_CLIENT:
 489       return new P2PSocketHostStunTcp(
 490           message_sender, socket_id, type, url_context);
 491   }
 492
 493   NOTREACHED();
 494   return NULL;
 495 }
 496
 497 void P2PSocketHost::StartRtpDump(
 498     bool incoming,
 499     bool outgoing,
 500     const RenderProcessHost::WebRtcRtpPacketCallback& packet_callback) {
 501   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 502   DCHECK(!packet_callback.is_null());
 503   DCHECK(incoming || outgoing);
 504
 505   if (incoming)
 506     dump_incoming_rtp_packet_ = true;
 507
 508   if (outgoing)
 509     dump_outgoing_rtp_packet_ = true;
 510
 511   packet_dump_callback_ = packet_callback;
 512 }
 513
 514 void P2PSocketHost::StopRtpDump(bool incoming, bool outgoing) {
 515   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 516   DCHECK(incoming || outgoing);
 517
 518   if (incoming)
 519     dump_incoming_rtp_packet_ = false;
 520
 521   if (outgoing)
 522     dump_outgoing_rtp_packet_ = false;
 523
 524   if (!dump_incoming_rtp_packet_ && !dump_outgoing_rtp_packet_)
 525     packet_dump_callback_.Reset();
 526 }
 527
 528 void P2PSocketHost::DumpRtpPacket(const char* packet,
 529                                   size_t length,
 530                                   bool incoming) {
 531   if (IsDtlsPacket(packet, length) || IsRtcpPacket(packet))
 532     return;
 533
 534   int rtp_packet_pos = 0;
 535   int rtp_packet_length = length;
 536   if (!packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 537           packet, length, &rtp_packet_pos, &rtp_packet_length))
 538     return;
 539
 540   packet += rtp_packet_pos;
 541
 542   size_t header_length = 0;
 543   bool valid = ValidateRtpHeader(packet, rtp_packet_length, &header_length);
 544   if (!valid) {
 545     DCHECK(false);
 546     return;
 547   }
 548
 549   scoped_ptr<uint8[]> header_buffer(new uint8[header_length]);
 550   memcpy(header_buffer.get(), packet, header_length);
 551
 552   // Posts to the IO thread as the data members should be accessed on the IO
 553   // thread only.
 554   BrowserThread::PostTask(BrowserThread::IO,
 555                           FROM_HERE,
 556                           base::Bind(&P2PSocketHost::DumpRtpPacketOnIOThread,
 557                                      weak_ptr_factory_.GetWeakPtr(),
 558                                      Passed(&header_buffer),
 559                                      header_length,
 560                                      rtp_packet_length,
 561                                      incoming));
 562 }
 563
 564 void P2PSocketHost::DumpRtpPacketOnIOThread(scoped_ptr<uint8[]> packet_header,
 565                                             size_t header_length,
 566                                             size_t packet_length,
 567                                             bool incoming) {
 568   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 569
 570   if ((incoming && !dump_incoming_rtp_packet_) ||
 571       (!incoming && !dump_outgoing_rtp_packet_) ||
 572       packet_dump_callback_.is_null()) {
 573     return;
 574   }
 575
 576   // |packet_dump_callback_| must be called on the UI thread.
 577   BrowserThread::PostTask(BrowserThread::UI,
 578                           FROM_HERE,
 579                           base::Bind(packet_dump_callback_,
 580                                      Passed(&packet_header),
 581                                      header_length,
 582                                      packet_length,
 583                                      incoming));
 584 }
 585
 586 }  // namespace content