Implements RTP header dumping.

content/browser/renderer_host/p2p/socket_host.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/p2p/socket_host.h"
 
 #include "base/sys_byteorder.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp_server.h"
 #include "content/browser/renderer_host/p2p/socket_host_udp.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/public/browser/browser_thread.h"
 #include "crypto/hmac.h"
 #include "third_party/libjingle/source/talk/base/asyncpacketsocket.h"
 #include "third_party/libjingle/source/talk/base/byteorder.h"
 #include "third_party/libjingle/source/talk/base/messagedigest.h"
 #include "third_party/libjingle/source/talk/p2p/base/stun.h"
 
 namespace {
 
 const uint32 kStunMagicCookie = 0x2112A442;
 const int kMinRtpHdrLen = 12;
@@ skipping 27 matching lines @@
 bool IsTurnSendIndicationPacket(const char* data) {
   uint16 type = talk_base::GetBE16(data);
   return (type == cricket::TURN_SEND_INDICATION);
 }
 
 bool IsRtpPacket(const char* data, int len) {
   return ((*data & 0xC0) == 0x80);
 }
 
 // Verifies rtp header and message length.
-bool ValidateRtpHeader(char* rtp, int length) {
+bool ValidateRtpHeader(const char* rtp, int length, size_t* header_length) {
+  if (header_length)
+    *header_length = 0;
+
   int cc_count = rtp[0] & 0x0F;
   int rtp_hdr_len_without_extn = kMinRtpHdrLen + 4 * cc_count;
   if (rtp_hdr_len_without_extn > length) {
     return false;
   }
 
   // If extension bit is not set, we are done with header processing, as input
   // length is verified above.
   if (!(rtp[0] & 0x10)) {
+    if (header_length)
+      *header_length = rtp_hdr_len_without_extn;
+
     return true;
   }
 
   rtp += rtp_hdr_len_without_extn;
 
   // Getting extension profile length.
   // Length is in 32 bit words.
   uint16 extn_length = talk_base::GetBE16(rtp + 2) * 4;
 
   // Verify input length against total header size.
   if (rtp_hdr_len_without_extn + kRtpExtnHdrLen + extn_length > length) {
     return false;
   }
+
+  if (header_length)
+    *header_length = rtp_hdr_len_without_extn + kRtpExtnHdrLen + extn_length;
   return true;
 }
 
 void UpdateAbsSendTimeExtnValue(char* extn_data, int len,
                                 uint32 abs_send_time) {
   // Absolute send time in RTP streams.
   //
   // The absolute send time is signaled to the receiver in-band using the
   // general mechanism for RTP header extensions [RFC5285]. The payload
   // of this extension (the transmitted value) is a 24-bit unsigned integer
@@ skipping 108 matching lines @@
   if (options.packet_time_params.rtp_sendtime_extension_id != -1) {
     UpdateRtpAbsSendTimeExtn(
         start, rtp_length,
         options.packet_time_params.rtp_sendtime_extension_id, abs_send_time);
   }
 
   UpdateRtpAuthTag(start, rtp_length, options);
   return true;
 }
 
-bool GetRtpPacketStartPositionAndLength(
-    char* packet, int length, int* rtp_start_pos, int* rtp_packet_length) {
+bool GetRtpPacketStartPositionAndLength(const char* packet,
+                                        int length,
+                                        int* rtp_start_pos,
+                                        int* rtp_packet_length) {
   int rtp_begin, rtp_length;
   if (IsTurnChannelData(packet)) {
     // Turn Channel Message header format.
     //   0                   1                   2                   3
     //  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
     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     // |         Channel Number        |            Length             |
     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     // |                                                               |
     // /                       Application Data                        /
@@ skipping 15 matching lines @@
     }
     // Validate STUN message length.
     int stun_msg_len = talk_base::GetBE16(&packet[2]);
     if (stun_msg_len + P2PSocketHost::kStunHeaderSize != length) {
       return false;
     }
 
     // First skip mandatory stun header which is of 20 bytes.
     rtp_begin = P2PSocketHost::kStunHeaderSize;
     // Loop through STUN attributes until we find STUN DATA attribute.
-    char* start = packet + rtp_begin;
+    const char* start = packet + rtp_begin;
     bool data_attr_present = false;
     while ((packet + rtp_begin) - start < stun_msg_len) {
       // Keep reading STUN attributes until we hit DATA attribute.
       // Attribute will be a TLV structure.
       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       // |         Type                  |            Length             |
       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       // |                         Value (variable)                ....
       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       // The value in the length field MUST contain the length of the Value
@@ skipping 39 matching lines @@
 
   } else {
     // This is a raw RTP packet.
     rtp_begin = 0;
     rtp_length = length;
   }
 
   // Making sure we have a valid RTP packet at the end.
   if (!(rtp_length < kMinRtpHdrLen) &&
       IsRtpPacket(packet + rtp_begin, rtp_length) &&
-      ValidateRtpHeader(packet + rtp_begin, rtp_length)) {
+      ValidateRtpHeader(packet + rtp_begin, rtp_length, NULL)) {
     *rtp_start_pos = rtp_begin;
     *rtp_packet_length = rtp_length;
     return true;
   }
   return false;
 }
 
 // ValidateRtpHeader must be called before this method to make sure, we have
 // a sane rtp packet.
 bool UpdateRtpAbsSendTimeExtn(char* rtp, int length,
@@ skipping 65 matching lines @@
       while ((*rtp == 0) && (rtp - extn_start < extn_length)) {
         ++rtp;
       }
     }
   }
   return found;
 }
 
 }  // packet_processing_helpers
 
-P2PSocketHost::P2PSocketHost(IPC::Sender* message_sender,
-                             int id)
+P2PSocketHost::P2PSocketHost(IPC::Sender* message_sender, int socket_id)
     : message_sender_(message_sender),
-      id_(id),
-      state_(STATE_UNINITIALIZED) {
+      id_(socket_id),
+      state_(STATE_UNINITIALIZED),
+      dump_incoming_rtp_packet_(false),
+      dump_outgoing_rtp_packet_(false),
+      weak_ptr_factory_(this) {
 }
 
 P2PSocketHost::~P2PSocketHost() { }
 
 // Verifies that the packet |data| has a valid STUN header.
 // static
 bool P2PSocketHost::GetStunPacketType(
     const char* data, int data_size, StunMessageType* type) {
 
   if (data_size < kStunHeaderSize)
@@ skipping 32 matching lines @@
   }
 }
 
 // static
 bool P2PSocketHost::IsRequestOrResponse(StunMessageType type) {
   return type == STUN_BINDING_REQUEST || type == STUN_BINDING_RESPONSE ||
       type == STUN_ALLOCATE_REQUEST || type == STUN_ALLOCATE_RESPONSE;
 }
 
 // static
-P2PSocketHost* P2PSocketHost::Create(
-    IPC::Sender* message_sender, int id, P2PSocketType type,
-    net::URLRequestContextGetter* url_context,
-    P2PMessageThrottler* throttler) {
+P2PSocketHost* P2PSocketHost::Create(IPC::Sender* message_sender,
+                                     int socket_id,
+                                     P2PSocketType type,
+                                     net::URLRequestContextGetter* url_context,
+                                     P2PMessageThrottler* throttler) {
   switch (type) {
     case P2P_SOCKET_UDP:
-      return new P2PSocketHostUdp(message_sender, id, throttler);
+      return new P2PSocketHostUdp(message_sender, socket_id, throttler);
     case P2P_SOCKET_TCP_SERVER:
       return new P2PSocketHostTcpServer(
-          message_sender, id, P2P_SOCKET_TCP_CLIENT);
+          message_sender, socket_id, P2P_SOCKET_TCP_CLIENT);
 
     case P2P_SOCKET_STUN_TCP_SERVER:
       return new P2PSocketHostTcpServer(
-          message_sender, id, P2P_SOCKET_STUN_TCP_CLIENT);
+          message_sender, socket_id, P2P_SOCKET_STUN_TCP_CLIENT);
 
     case P2P_SOCKET_TCP_CLIENT:
     case P2P_SOCKET_SSLTCP_CLIENT:
     case P2P_SOCKET_TLS_CLIENT:
-      return new P2PSocketHostTcp(message_sender, id, type, url_context);
+      return new P2PSocketHostTcp(message_sender, socket_id, type, url_context);
 
     case P2P_SOCKET_STUN_TCP_CLIENT:
     case P2P_SOCKET_STUN_SSLTCP_CLIENT:
     case P2P_SOCKET_STUN_TLS_CLIENT:
-      return new P2PSocketHostStunTcp(message_sender, id, type, url_context);
+      return new P2PSocketHostStunTcp(
+          message_sender, socket_id, type, url_context);
   }
 
   NOTREACHED();
   return NULL;
 }
 
+void P2PSocketHost::StartRtpDump(
+    bool incoming,
+    bool outgoing,
+    const RenderProcessHost::WebRtcRtpPacketCallback& packet_callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!packet_callback.is_null());
+  DCHECK(incoming || outgoing);
+
+  if (incoming)
+    dump_incoming_rtp_packet_ = true;
+
+  if (outgoing)
+    dump_outgoing_rtp_packet_ = true;
+
+  packet_dump_callback_ = packet_callback;
+}
+
+void P2PSocketHost::StopRtpDump(bool incoming, bool outgoing) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(incoming || outgoing);
+
+  if (incoming)
+    dump_incoming_rtp_packet_ = false;
+
+  if (outgoing)
+    dump_outgoing_rtp_packet_ = false;
+
+  if (!dump_incoming_rtp_packet_ && !dump_outgoing_rtp_packet_)
+    packet_dump_callback_.Reset();
+}
+
+void P2PSocketHost::DumpRtpPacket(const char* packet,
+                                  size_t length,
+                                  bool incoming) {
+  if (IsDtlsPacket(packet, length) || IsRtcpPacket(packet))
+    return;
+
+  int rtp_packet_pos = 0;
+  int rtp_packet_length = length;
+  if (!packet_processing_helpers::GetRtpPacketStartPositionAndLength(
+          packet, length, &rtp_packet_pos, &rtp_packet_length))
+    return;
+
+  packet += rtp_packet_pos;
+
+  size_t header_length = 0;
+  bool valid = ValidateRtpHeader(packet, rtp_packet_length, &header_length);
+  if (!valid) {
+    DCHECK(false);
+    return;
+  }
+
+  scoped_ptr<uint8[]> header_buffer(new uint8[header_length]);
+  memcpy(header_buffer.get(), packet, header_length);
+
+  // Posts to the IO thread as the data members should be accessed on the IO
+  // thread only.
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&P2PSocketHost::DumpRtpPacketOnIOThread,
+                                     weak_ptr_factory_.GetWeakPtr(),
+                                     Passed(&header_buffer),
+                                     header_length,
+                                     rtp_packet_length,
+                                     incoming));
+}
+
+void P2PSocketHost::DumpRtpPacketOnIOThread(scoped_ptr<uint8[]> packet_header,
+                                            size_t header_length,
+                                            size_t packet_length,
+                                            bool incoming) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if ((incoming && !dump_incoming_rtp_packet_) ||
+      (!incoming && !dump_outgoing_rtp_packet_) ||
+      packet_dump_callback_.is_null()) {
+    return;
+  }
+
+  // |packet_dump_callback_| must be called on the UI thread.
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(packet_dump_callback_,
+                                     packet_header.get(),
+                                     header_length,
+                                     packet_length,
+                                     incoming));
+}
+
 }  // namespace content