Adding PortAllocator option to support cases where sockets can't be bound.

webrtc/base/firewallsocketserver.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/firewallsocketserver.h"
 
 #include <algorithm>
 
 #include "webrtc/base/asyncsocket.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 
 namespace rtc {
 
 class FirewallSocket : public AsyncSocketAdapter {
  public:
   FirewallSocket(FirewallSocketServer* server, AsyncSocket* socket, int type)
     : AsyncSocketAdapter(socket), server_(server), type_(type) {
   }
 
+  int Bind(const SocketAddress& addr) override {
+    if (!server_->CanBindToIp(addr.ipaddr())) {
+      SetError(EINVAL);
+      return SOCKET_ERROR;
+    }
+    return AsyncSocketAdapter::Bind(addr);
+  }
+
   int Connect(const SocketAddress& addr) override {
     if (type_ == SOCK_STREAM) {
       if (!server_->Check(FP_TCP, GetLocalAddress(), addr)) {
         LOG(LS_VERBOSE) << "FirewallSocket outbound TCP connection from "
                         << GetLocalAddress().ToSensitiveString() << " to "
                         << addr.ToSensitiveString() << " denied";
         // TODO: Handle this asynchronously.
         SetError(EHOSTUNREACH);
         return SOCKET_ERROR;
       }
@@ skipping 132 matching lines @@
       continue;
     if ((r.dst.ipaddr() != dst.ipaddr()) && !r.dst.IsNil())
       continue;
     if ((r.dst.port() != dst.port()) && (r.dst.port() != 0))
       continue;
     return r.allow;
   }
   return true;
 }
 
+void FirewallSocketServer::SetInvalidBindIps(
+    const std::vector<rtc::IPAddress>& invalid_bind_ips) {
+  invalid_bind_ips_ = invalid_bind_ips;
+}
+
+bool FirewallSocketServer::CanBindToIp(const rtc::IPAddress& ip) {
+  return std::find(invalid_bind_ips_.begin(), invalid_bind_ips_.end(), ip) ==
+         invalid_bind_ips_.end();
+}
+
 Socket* FirewallSocketServer::CreateSocket(int type) {
   return CreateSocket(AF_INET, type);
 }
 
 Socket* FirewallSocketServer::CreateSocket(int family, int type) {
   return WrapSocket(server_->CreateAsyncSocket(family, type), type);
 }
 
 AsyncSocket* FirewallSocketServer::CreateAsyncSocket(int type) {
   return CreateAsyncSocket(AF_INET, type);
@@ skipping 55 matching lines @@
 
 void FirewallManager::ClearRules() {
   CritScope scope(&crit_);
   for (std::vector<FirewallSocketServer*>::const_iterator it =
       servers_.begin(); it != servers_.end(); ++it) {
     (*it)->ClearRules();
   }
 }
 
 }  // namespace rtc