Support port range for IPC P2P UDP sockets.

content/browser/renderer_host/p2p/socket_dispatcher_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_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
+#include "content/browser/bad_message.h"
 #include "content/browser/renderer_host/p2p/socket_host.h"
 #include "content/common/p2p_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_context.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/dns/single_request_host_resolver.h"
@@ skipping 209 matching lines @@
                                                int32_t request_id) {
   DnsRequest* request = new DnsRequest(request_id,
                                        resource_context_->GetHostResolver());
   dns_requests_.insert(request);
   request->Resolve(host_name, base::Bind(
       &P2PSocketDispatcherHost::OnAddressResolved,
       base::Unretained(this), request));
 }
 
 void P2PSocketDispatcherHost::OnCreateSocket(
-    P2PSocketType type, int socket_id,
+    P2PSocketType type,
+    int socket_id,
     const net::IPEndPoint& local_address,
+    const P2PPortRange& port_range,
     const P2PHostAndIPEndPoint& remote_address) {
+  if (port_range.min_port < port_range.max_port ||
+      (port_range.min_port == 0 && port_range.max_port != 0)) {
+    bad_message::ReceivedBadMessage(this, bad_message::SDH_INVALID_PORT_RANGE);
+    return;
+  }
+
   if (LookupSocket(socket_id)) {
     LOG(ERROR) << "Received P2PHostMsg_CreateSocket for socket "
         "that already exists.";
     return;
   }
 
   std::unique_ptr<P2PSocketHost> socket(P2PSocketHost::Create(
       this, socket_id, type, url_context_.get(), &throttler_));
 
   if (!socket) {
     Send(new P2PMsg_OnError(socket_id));
     return;
   }
 
-  if (socket->Init(local_address, remote_address)) {
+  if (socket->Init(local_address, port_range.min_port, port_range.max_port,
+                   remote_address)) {
     sockets_[socket_id] = socket.release();
 
     if (dump_incoming_rtp_packet_ || dump_outgoing_rtp_packet_) {
       sockets_[socket_id]->StartRtpDump(dump_incoming_rtp_packet_,
                                         dump_outgoing_rtp_packet_,
                                         packet_callback_);
     }
   }
 }
 
@@ skipping 136 matching lines @@
 
     if (!dump_incoming_rtp_packet_ && !dump_outgoing_rtp_packet_)
       packet_callback_.Reset();
 
     for (SocketsMap::iterator it = sockets_.begin(); it != sockets_.end(); ++it)
       it->second->StopRtpDump(incoming, outgoing);
   }
 }
 
 }  // namespace content