Relanding: Move "max IPv6 networks" logic to BasicPortAllocator, and fix sorting.

webrtc/p2p/client/basicportallocator.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.
  */
 
@@ skipping 570 matching lines @@
   } else {
     network_manager->GetNetworks(&networks);
     // If network enumeration fails, use the ANY address as a fallback, so we
     // can at least try gathering candidates using the default route chosen by
     // the OS. Or, if the PORTALLOCATOR_ENABLE_ANY_ADDRESS_PORTS flag is
     // set, we'll use ANY address candidates either way.
     if (networks.empty() || flags() & PORTALLOCATOR_ENABLE_ANY_ADDRESS_PORTS) {
       network_manager->GetAnyAddressNetworks(&networks);
     }
   }
+  // Do some more filtering, depending on the network ignore mask and "disable
+  // costly networks" flag.
   networks.erase(std::remove_if(networks.begin(), networks.end(),
                                 [this](rtc::Network* network) {
                                   return allocator_->network_ignore_mask() &
                                          network->type();
                                 }),
                  networks.end());
-
   if (flags() & PORTALLOCATOR_DISABLE_COSTLY_NETWORKS) {
     uint16_t lowest_cost = rtc::kNetworkCostMax;
     for (rtc::Network* network : networks) {
       lowest_cost = std::min<uint16_t>(lowest_cost, network->GetCost());
     }
     networks.erase(std::remove_if(networks.begin(), networks.end(),
                                   [lowest_cost](rtc::Network* network) {
                                     return network->GetCost() >
                                            lowest_cost + rtc::kNetworkCostLow;
                                   }),
                    networks.end());
   }
+  // Lastly, if we have a limit for the number of IPv6 network interfaces (by
+  // default, it's 5), remove networks to ensure that limit is satisfied.
+  //
+  // TODO(deadbeef): Instead of just taking the first N arbitrary IPv6
+  // networks, we could try to choose a set that's "most likely to work". It's
+  // hard to define what that means though; it's not just "lowest cost".
+  // Alternatively, we could just focus on making our ICE pinging logic smarter
+  // such that this filtering isn't necessary in the first place.
+  int ipv6_networks = 0;
+  for (auto it = networks.begin(); it != networks.end();) {
+    if ((*it)->prefix().family() == AF_INET6) {
+      if (ipv6_networks >= allocator_->max_ipv6_networks()) {
+        it = networks.erase(it);
+        continue;
+      } else {
+        ++ipv6_networks;
+      }
+    }
+    ++it;
+  }
   return networks;
 }
 
 // For each network, see if we have a sequence that covers it already.  If not,
 // create a new sequence to create the appropriate ports.
 void BasicPortAllocatorSession::DoAllocate(bool disable_equivalent) {
   bool done_signal_needed = false;
   std::vector<rtc::Network*> networks = GetNetworks();
   if (networks.empty()) {
     LOG(LS_WARNING) << "Machine has no networks; no ports will be allocated";
@@ skipping 938 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket