Support port range for IPC P2P UDP sockets.

content/browser/renderer_host/p2p/socket_host_udp.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_udp.h"
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/p2p/socket_host_throttler.h"
 #include "content/common/p2p_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
 #include "ipc/ipc_sender.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "third_party/webrtc/media/base/rtputils.h"
@@ skipping 61 matching lines @@
       id(id) {
   memcpy(data->data(), &content[0], size);
 }
 
 P2PSocketHostUdp::PendingPacket::PendingPacket(const PendingPacket& other) =
     default;
 
 P2PSocketHostUdp::PendingPacket::~PendingPacket() {
 }
 
+P2PSocketHostUdp::P2PSocketHostUdp(
+    IPC::Sender* message_sender,
+    int socket_id,
+    P2PMessageThrottler* throttler,
+    const DatagramServerSocketFactory& socket_factory)
+    : P2PSocketHost(message_sender, socket_id, P2PSocketHost::UDP),
+      socket_(socket_factory.Run()),
+      send_pending_(false),
+      last_dscp_(net::DSCP_CS0),
+      throttler_(throttler),
+      send_buffer_size_(0),
+      socket_factory_(socket_factory) {}
+
 P2PSocketHostUdp::P2PSocketHostUdp(IPC::Sender* message_sender,
                                    int socket_id,
                                    P2PMessageThrottler* throttler)
-    : P2PSocketHost(message_sender, socket_id, P2PSocketHost::UDP),
-      send_pending_(false),
-      last_dscp_(net::DSCP_CS0),
-      throttler_(throttler),
-      send_buffer_size_(0) {
-  net::UDPServerSocket* socket = new net::UDPServerSocket(
-      GetContentClient()->browser()->GetNetLog(), net::NetLog::Source());
-#if defined(OS_WIN)
-  socket->UseNonBlockingIO();
-#endif
-  socket_.reset(socket);
-}
+    : P2PSocketHostUdp(message_sender,
+                       socket_id,
+                       throttler,
+                       base::Bind(&P2PSocketHostUdp::DefaultSocketFactory)) {}
 
 P2PSocketHostUdp::~P2PSocketHostUdp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
 void P2PSocketHostUdp::SetSendBufferSize() {
   unsigned int send_buffer_size = 0;
 
   base::StringToUint(
       base::FieldTrialList::FindFullName("WebRTC-SystemUDPSendSocketSize"),
       &send_buffer_size);
 
   if (send_buffer_size > 0) {
     if (!SetOption(P2P_SOCKET_OPT_SNDBUF, send_buffer_size)) {
       LOG(WARNING) << "Failed to set socket send buffer size to "
                    << send_buffer_size;
     } else {
       send_buffer_size_ = send_buffer_size;
     }
   }
 }
 
 bool P2PSocketHostUdp::Init(const net::IPEndPoint& local_address,
+                            uint16_t min_port,
+                            uint16_t max_port,
                             const P2PHostAndIPEndPoint& remote_address) {
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
+  DCHECK(local_address.port() == 0 || (min_port == 0 && max_port == 0));

[tommi (sloooow) - chröme, 2016/07/11 17:54:59]

what if e.g. local_address.port() != 0 but the policy is also specified?

[Guido Urdaneta, 2016/07/12 10:15:00]

The original PS was not treating the range as policy, but as an alternative way
to specify the port.
The new PS treats the range as policy. 

 
-  int result = socket_->Listen(local_address);
+  int result = -1;
+  if (min_port == 0) {

[tommi (sloooow) - chröme, 2016/07/11 17:54:59]

maybe this should be:

if (min_port == 0 || local_address.port() != 0) {

But even so, we probably need an extra, nested, check:

  if (local_address.port() < min_port || local_address.port() > max_port) {
    result = -1;  // or some appropriate error value.
  } else {
    result = socket_.Listen(...);
  }

[Guido Urdaneta, 2016/07/12 10:15:00]

Done.

+    result = socket_->Listen(local_address);
+  } else {
+    for (unsigned port = min_port; port <= max_port && result < 0; ++port) {
+      result = socket_->Listen(net::IPEndPoint(local_address.address(), port));

[tommi (sloooow) - chröme, 2016/07/11 17:54:59]

otherwise, here we ignore local_address.port() if it's not 0 and could
potentially bind it to the wrong port.

[Guido Urdaneta, 2016/07/12 10:15:00]

Done.

+      if (result < 0 && port != max_port)
+        socket_ = socket_factory_.Run();
+    }
+  }
   if (result < 0) {
-    LOG(ERROR) << "bind() to " << local_address.ToString()
+    LOG(ERROR) << "bind() to " << local_address.address().ToString()
+               << (min_port == 0
+                       ? base::StringPrintf(":%d", local_address.port())
+                       : base::StringPrintf(", port range [%d-%d]", min_port,
+                                            max_port))
                << " failed: " << result;
     OnError();
     return false;
   }
 
   // Setting recv socket buffer size.
   if (socket_->SetReceiveBufferSize(kRecvSocketBufferSize) != net::OK) {
     LOG(WARNING) << "Failed to set socket receive buffer size to "
                  << kRecvSocketBufferSize;
   }
@@ skipping 243 matching lines @@
       return socket_->SetSendBufferSize(value) == net::OK;
     case P2P_SOCKET_OPT_DSCP:
       return (net::OK == socket_->SetDiffServCodePoint(
           static_cast<net::DiffServCodePoint>(value))) ? true : false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
+// static
+std::unique_ptr<net::DatagramServerSocket>
+P2PSocketHostUdp::DefaultSocketFactory() {
+  net::UDPServerSocket* socket = new net::UDPServerSocket(
+      GetContentClient()->browser()->GetNetLog(), net::NetLog::Source());
+#if defined(OS_WIN)
+  socket->UseNonBlockingIO();
+#endif
+
+  return base::WrapUnique(socket);
+}
+
 }  // namespace content