Support port range for IPC P2P UDP sockets.

content/renderer/p2p/ipc_socket_factory.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/renderer/p2p/ipc_socket_factory.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 75 matching lines @@
     InFlightPacketRecord(uint64_t packet_id, size_t packet_size)
         : packet_id(packet_id), packet_size(packet_size) {}
 
     uint64_t packet_id;
     size_t packet_size;
   };
 
   typedef std::list<InFlightPacketRecord> InFlightPacketList;
 
   // Always takes ownership of client even if initialization fails.
-  bool Init(P2PSocketType type, P2PSocketClientImpl* client,
+  bool Init(P2PSocketType type,
+            P2PSocketClientImpl* client,
             const rtc::SocketAddress& local_address,
+            uint16_t min_port,
+            uint16_t max_port,
             const rtc::SocketAddress& remote_address);
 
   // rtc::AsyncPacketSocket interface.
   rtc::SocketAddress GetLocalAddress() const override;
   rtc::SocketAddress GetRemoteAddress() const override;
   int Send(const void* pv,
            size_t cb,
            const rtc::PacketOptions& options) override;
   int SendTo(const void* pv,
              size_t cb,
@@ skipping 177 matching lines @@
       &send_buffer_size);
 
   if (send_buffer_size > 0) {
     send_bytes_available_ = send_buffer_size;
   }
 }
 
 bool IpcPacketSocket::Init(P2PSocketType type,
                            P2PSocketClientImpl* client,
                            const rtc::SocketAddress& local_address,
+                           uint16_t min_port,
+                           uint16_t max_port,
                            const rtc::SocketAddress& remote_address) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK_EQ(state_, IS_UNINITIALIZED);
 
   type_ = type;
   client_ = client;
   local_address_ = local_address;
   remote_address_ = remote_address;
   state_ = IS_OPENING;
 
@@ skipping 20 matching lines @@
         return false;
       }
     }
   }
 
   // We need to send both resolved and unresolved address in Init. Unresolved
   // address will be used in case of TLS for certificate hostname matching.
   // Certificate will be tied to domain name not to IP address.
   P2PHostAndIPEndPoint remote_info(remote_address.hostname(), remote_endpoint);
 
-  client->Init(type, local_endpoint, remote_info, this);
+  client->Init(type, local_endpoint, min_port, max_port, remote_info, this);
 
   return true;
 }
 
 void IpcPacketSocket::InitAcceptedTcp(
     P2PSocketClient* client,
     const rtc::SocketAddress& local_address,
     const rtc::SocketAddress& remote_address) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK_EQ(state_, IS_UNINITIALIZED);
@@ skipping 390 matching lines @@
     : socket_dispatcher_(socket_dispatcher) {
 }
 
 IpcPacketSocketFactory::~IpcPacketSocketFactory() {
 }
 
 rtc::AsyncPacketSocket* IpcPacketSocketFactory::CreateUdpSocket(
     const rtc::SocketAddress& local_address,
     uint16_t min_port,
     uint16_t max_port) {
-  rtc::SocketAddress crome_address;
   P2PSocketClientImpl* socket_client =
       new P2PSocketClientImpl(socket_dispatcher_);
   std::unique_ptr<IpcPacketSocket> socket(new IpcPacketSocket());
-  // TODO(sergeyu): Respect local_address and port limits here (need
-  // to pass them over IPC channel to the browser).
-  if (!socket->Init(P2P_SOCKET_UDP, socket_client,
-                    local_address, rtc::SocketAddress())) {
-    return NULL;
+  if (!socket->Init(P2P_SOCKET_UDP, socket_client, local_address, min_port,
+                    max_port, rtc::SocketAddress())) {
+    return nullptr;
   }
   return socket.release();
 }
 
 rtc::AsyncPacketSocket* IpcPacketSocketFactory::CreateServerTcpSocket(
     const rtc::SocketAddress& local_address,
     uint16_t min_port,
     uint16_t max_port,
     int opts) {
   // TODO(sergeyu): Implement SSL support.
   if (opts & rtc::PacketSocketFactory::OPT_SSLTCP)
     return NULL;
 
   P2PSocketType type = (opts & rtc::PacketSocketFactory::OPT_STUN) ?
       P2P_SOCKET_STUN_TCP_SERVER : P2P_SOCKET_TCP_SERVER;
   P2PSocketClientImpl* socket_client =
       new P2PSocketClientImpl(socket_dispatcher_);
   std::unique_ptr<IpcPacketSocket> socket(new IpcPacketSocket());
-  if (!socket->Init(type, socket_client, local_address,
+  if (!socket->Init(type, socket_client, local_address, min_port, max_port,
                     rtc::SocketAddress())) {
     return NULL;
   }
   return socket.release();
 }
 
 rtc::AsyncPacketSocket* IpcPacketSocketFactory::CreateClientTcpSocket(
     const rtc::SocketAddress& local_address,
     const rtc::SocketAddress& remote_address,
     const rtc::ProxyInfo& proxy_info,
     const std::string& user_agent, int opts) {
   P2PSocketType type;
   if (opts & rtc::PacketSocketFactory::OPT_SSLTCP) {
     type = (opts & rtc::PacketSocketFactory::OPT_STUN) ?
         P2P_SOCKET_STUN_SSLTCP_CLIENT : P2P_SOCKET_SSLTCP_CLIENT;
   } else if (opts & rtc::PacketSocketFactory::OPT_TLS) {
     type = (opts & rtc::PacketSocketFactory::OPT_STUN) ?
         P2P_SOCKET_STUN_TLS_CLIENT : P2P_SOCKET_TLS_CLIENT;
   } else {
     type = (opts & rtc::PacketSocketFactory::OPT_STUN) ?
         P2P_SOCKET_STUN_TCP_CLIENT : P2P_SOCKET_TCP_CLIENT;
   }
   P2PSocketClientImpl* socket_client =
       new P2PSocketClientImpl(socket_dispatcher_);
   std::unique_ptr<IpcPacketSocket> socket(new IpcPacketSocket());
-  if (!socket->Init(type, socket_client, local_address, remote_address))
+  if (!socket->Init(type, socket_client, local_address, 0, 0, remote_address))
     return NULL;
   return socket.release();
 }
 
 rtc::AsyncResolverInterface*
 IpcPacketSocketFactory::CreateAsyncResolver() {
   std::unique_ptr<AsyncAddressResolverImpl> resolver(
       new AsyncAddressResolverImpl(socket_dispatcher_));
   return resolver.release();
 }
 
 }  // namespace content