Use continual gathering to restore backup connections

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 120 matching lines @@
     const std::string& content_name,
     int component,
     const std::string& ice_ufrag,
     const std::string& ice_pwd)
     : PortAllocatorSession(content_name, component,
                            ice_ufrag, ice_pwd, allocator->flags()),
       allocator_(allocator), network_thread_(NULL),
       socket_factory_(allocator->socket_factory()),
       allocation_started_(false),
       network_manager_started_(false),
-      running_(false),
       allocation_sequences_created_(false) {
   allocator_->network_manager()->SignalNetworksChanged.connect(
       this, &BasicPortAllocatorSession::OnNetworksChanged);
   allocator_->network_manager()->StartUpdating();
 }
 
 BasicPortAllocatorSession::~BasicPortAllocatorSession() {
   allocator_->network_manager()->StopUpdating();
   if (network_thread_ != NULL)
     network_thread_->Clear(this);
@@ skipping 39 matching lines @@
 }
 
 void BasicPortAllocatorSession::StartGettingPorts() {
   network_thread_ = rtc::Thread::Current();
   if (!socket_factory_) {
     owned_socket_factory_.reset(
         new rtc::BasicPacketSocketFactory(network_thread_));
     socket_factory_ = owned_socket_factory_.get();
   }
 
-  running_ = true;
+  running_ = STATE_RUNNING;

[Taylor Brandstetter, 2016/06/21 23:36:12]

Should be "state_ = STATE_RUNNING"? Also can "running_" be removed, if state_ is
being used instead?

   network_thread_->Post(RTC_FROM_HERE, this, MSG_CONFIG_START);
 }
 
 void BasicPortAllocatorSession::StopGettingPorts() {
   ASSERT(rtc::Thread::Current() == network_thread_);
-  running_ = false;
+  state_ = STATE_STOPPED;
   network_thread_->Post(RTC_FROM_HERE, this, MSG_CONFIG_STOP);
   ClearGettingPorts();
 }
 
 void BasicPortAllocatorSession::ClearGettingPorts() {
+  state_ = STATE_CLEARED;
   network_thread_->Clear(this, MSG_ALLOCATE);
   for (uint32_t i = 0; i < sequences_.size(); ++i)
     sequences_[i]->Stop();
 }
 
+std::vector<rtc::Network*> BasicPortAllocatorSession::GetFailedNetworks() {
+  rtc::NetworkManager::NetworkList networks = GetNetworks();
+
+  // Whether a network has at least one connection, keyed by interface name.
+  // So if an adapter interface has both IPv4 and IPv6 networks, they will
+  // be considered as one network.
+  std::map<std::string, bool> network_has_connection;
+  for (const PortData& data : ports_) {
+    PortInterface* port = data.port();
+    if (!port->connections().empty()) {
+      network_has_connection[port->Network()->name()] = true;
+    }
+  }
+
+  networks.erase(
+      std::remove_if(networks.begin(), networks.end(),
+                     [network_has_connection](rtc::Network* network) {
+                       // If a network does not have any connection, it is
+                       // considered failed.
+                       return network_has_connection[network->name()];
+                     }),
+      networks.end());
+  return networks;
+}
+
+void BasicPortAllocatorSession::RegatherOnFailedNetworks() {
+  // Find the list of networks that have no connection.
+  rtc::NetworkManager::NetworkList networks = GetFailedNetworks();
+  if (networks.empty()) {
+    return;
+  }
+
+  // Inactivate sequences whose networks are in failed |networks|,
+  // so that they won't be considered as duplicates when the session
+  // regathers ports and candidates.
+  for (AllocationSequence* sequence : sequences_) {
+    if (!sequence->network_inactive() &&
+        std::find(networks->begin(), networks->end(), sequence->network()) !=
+            networks->end()) {
+      sequence->set_network_inactive(true);
+      // Close ports and signal candidate removals.
+      sequence->ClosePorts();
+    }
+  }
+
+  StartGettingPorts();
+}
+
 std::vector<PortInterface*> BasicPortAllocatorSession::ReadyPorts() const {
   std::vector<PortInterface*> ret;
   for (const PortData& port : ports_) {
     if (port.has_pairable_candidate() && !port.error()) {
       ret.push_back(port.port());
     }
   }
   return ret;
 }
 
 std::vector<Candidate> BasicPortAllocatorSession::ReadyCandidates() const {
   std::vector<Candidate> candidates;
   for (const PortData& data : ports_) {
     for (const Candidate& candidate : data.port()->Candidates()) {
       if (!CheckCandidateFilter(candidate)) {
         continue;
       }
       ProtocolType pvalue;
       if (!StringToProto(candidate.protocol().c_str(), &pvalue) ||
           !data.sequence()->ProtocolEnabled(pvalue)) {
         continue;
       }
       candidates.push_back(SanitizeRelatedAddress(candidate));
     }
   }
   return candidates;
 }
 
+std::vector<Candidate> BasicPortAllocatorSession::ReadyCandidates(
+    PortInterface* port) const {
+  std::vector<Candidate> candidates;
+  for (const Candidate& candidate : port->Candidates()) {
+    if (!CheckCandidateFilter(candidate)) {
+      continue;
+    }
+    candidates.push_back(SanitizeRelatedAddress(candidate));
+  }
+  return candidates;
+}
+
 Candidate BasicPortAllocatorSession::SanitizeRelatedAddress(
     const Candidate& c) const {
   Candidate copy = c;
   // If adapter enumeration is disabled or host candidates are disabled,
   // clear the raddr of STUN candidates to avoid local address leakage.
   bool filter_stun_related_address =
       ((flags() & PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION) &&
        (flags() & PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE)) ||
       !(candidate_filter_ & CF_HOST);
   // If the candidate filter doesn't allow reflexive addresses, empty TURN raddr
@@ skipping 128 matching lines @@
   network_thread_->Post(RTC_FROM_HERE, this, MSG_ALLOCATE);
 }
 
 void BasicPortAllocatorSession::OnAllocate() {
   if (network_manager_started_)
     DoAllocate();
 
   allocation_started_ = true;
 }
 
-void BasicPortAllocatorSession::GetNetworks(
-    std::vector<rtc::Network*>* networks) {
-  networks->clear();
+std::vector<rtc::Network*> BasicPortAllocatorSession::GetNetworks() const {
+  std::vector<rtc::Network*> networks;
   rtc::NetworkManager* network_manager = allocator_->network_manager();
   ASSERT(network_manager != nullptr);
   // If the network permission state is BLOCKED, we just act as if the flag has
   // been passed in.
   if (network_manager->enumeration_permission() ==
       rtc::NetworkManager::ENUMERATION_BLOCKED) {
     set_flags(flags() | PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION);
   }
   // If the adapter enumeration is disabled, we'll just bind to any address
   // instead of specific NIC. This is to ensure the same routing for http
   // traffic by OS is also used here to avoid any local or public IP leakage
   // during stun process.
   if (flags() & PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION) {
-    network_manager->GetAnyAddressNetworks(networks);
+    network_manager->GetAnyAddressNetworks(&networks);
   } else {
-    network_manager->GetNetworks(networks);
+    network_manager->GetNetworks(&networks);
   }
   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());
   }
+  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 done_signal_needed = false;
-  std::vector<rtc::Network*> networks;
-  GetNetworks(&networks);
+  std::vector<rtc::Network*> networks = GetNetworks();
 
   if (networks.empty()) {
     LOG(LS_WARNING) << "Machine has no networks; no ports will be allocated";
     done_signal_needed = true;
   } else {
     for (uint32_t i = 0; i < networks.size(); ++i) {
       PortConfiguration* config = NULL;
       if (configs_.size() > 0)
         config = configs_.back();
 
@@ skipping 27 matching lines @@
 
       AllocationSequence* sequence =
           new AllocationSequence(this, networks[i], config, sequence_flags);
       if (!sequence->Init()) {
         delete sequence;
         continue;
       }
       done_signal_needed = true;
       sequence->SignalPortAllocationComplete.connect(
           this, &BasicPortAllocatorSession::OnPortAllocationComplete);
-      if (running_)
+      // TODO(honghaiz): Move this check at the beginning of the method. I do
+      // not see the point of creating a sequence without starting it. Will
+      // do this in a separate CL.
+      if (CanGetPorts()) {
         sequence->Start();
+      }
       sequences_.push_back(sequence);
     }
   }
   if (done_signal_needed) {
     network_thread_->Post(RTC_FROM_HERE, this, MSG_SEQUENCEOBJECTS_CREATED);
   }
 }
 
 void BasicPortAllocatorSession::OnNetworksChanged() {
-  std::vector<rtc::Network*> networks;
-  GetNetworks(&networks);
+  std::vector<rtc::Network*> networks = GetNetworks();
   for (AllocationSequence* sequence : sequences_) {
     // Remove the network from the allocation sequence if it is not in
     // |networks|.
-    if (!sequence->network_removed() &&
+    if (!sequence->network_inactive() &&
         std::find(networks.begin(), networks.end(), sequence->network()) ==
             networks.end()) {
-      sequence->OnNetworkRemoved();
+      sequence->OnNetworkInactivated();
     }
   }
 
   network_manager_started_ = true;
   if (allocation_started_)
     DoAllocate();
 }
 
 void BasicPortAllocatorSession::DisableEquivalentPhases(
     rtc::Network* network,
@@ skipping 19 matching lines @@
   if (allocator_->proxy().type != rtc::PROXY_NONE)
     port->set_proxy(allocator_->user_agent(), allocator_->proxy());
   port->set_send_retransmit_count_attribute(
       (flags() & PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE) != 0);
 
   PortData data(port, seq);
   ports_.push_back(data);
 
   port->SignalCandidateReady.connect(
       this, &BasicPortAllocatorSession::OnCandidateReady);
+  port->SignalCandidatesRemoved.connect(
+      this, &BasicPortAllocatorSession::OnCandidatesRemoved);
   port->SignalPortComplete.connect(this,
       &BasicPortAllocatorSession::OnPortComplete);
   port->SignalDestroyed.connect(this,
       &BasicPortAllocatorSession::OnPortDestroyed);
   port->SignalPortError.connect(
       this, &BasicPortAllocatorSession::OnPortError);
   LOG_J(LS_INFO, port) << "Added port to allocator";
 
   if (prepare_address)
     port->PrepareAddress();
@@ skipping 37 matching lines @@
   // usable candidate from the port, or simply because the port is bound to the
   // any address and therefore has no host candidate. This will trigger the port
   // to start creating candidate pairs (connections) and issue connectivity
   // checks.
   if (CandidatePairable(c, port)) {
     data->set_has_pairable_candidate(true);
     SignalPortReady(this, port);
   }
 }
 
+void BasicPortAllocatorSession::OnCandidatesRemoved(
+    Port* port,
+    const std::vector<Candidate>& candidates) {
+  ASSERT(rtc::Thread::Current() == network_thread_);
+  PortData* data = FindPort(port);
+  ASSERT(data != NULL);
+
+  std::vector<Candidate> filtered_candidates;
+  for (Candidate c : candidates) {
+    ProtocolType pvalue;
+    bool candidate_protocol_enabled =
+        StringToProto(c.protocol().c_str(), &pvalue) &&
+        data->sequence()->ProtocolEnabled(pvalue);
+    if (candidate_protocol_enabled && CheckCandidateFilter(c)) {
+      filtered_candidates.push_back(SanitizeRelatedAddress(c));
+    }
+  }
+  if (!filtered_candidates.empty()) {
+    SignalCandidatesRemoved(this, filtered_candidates);
+  }
+}
+
 void BasicPortAllocatorSession::OnPortComplete(Port* port) {
   ASSERT(rtc::Thread::Current() == network_thread_);
   PortData* data = FindPort(port);
   ASSERT(data != NULL);
 
   // Ignore any late signals.
   if (data->complete() || data->error()) {
     return;
   }
 
@@ skipping 172 matching lines @@
     // are next available options to setup a communication channel.
   }
   return true;
 }
 
 void AllocationSequence::Clear() {
   udp_port_ = NULL;
   turn_ports_.clear();
 }
 
-void AllocationSequence::OnNetworkRemoved() {
+void AllocationSequence::OnNetworkInactivated() {
   // Stop the allocation sequence if its network is gone.
+  network_inactive_ = true;

[Taylor Brandstetter, 2016/06/21 23:36:12]

nit: Would be better to store this bool as "network_active_"

   Stop();
-  network_removed_ = true;
 }
 
 AllocationSequence::~AllocationSequence() {
   session_->network_thread()->Clear(this);
 }
 
 void AllocationSequence::DisableEquivalentPhases(rtc::Network* network,
     PortConfiguration* config, uint32_t* flags) {
-  if (network_removed_) {
-    // If the network of this allocation sequence has ever gone away,
+  if (network_inactive_) {
+    // If the network of this allocation sequence has ever become inactive,
     // it won't be equivalent to the new network.
     return;
   }
 
   if (!((network == network_) && (ip_ == network->GetBestIP()))) {
     // Different network setup; nothing is equivalent.
     return;
   }
 
   // Else turn off the stuff that we've already got covered.
@@ skipping 24 matching lines @@
 }
 
 void AllocationSequence::Stop() {
   // If the port is completed, don't set it to stopped.
   if (state_ == kRunning) {
     state_ = kStopped;
     session_->network_thread()->Clear(this, MSG_ALLOCATION_PHASE);
   }
 }
 
+void AllocationSequence::ClosePorts() {
+  if (udp_port_) {
+    udp_port_->CloseAndSignalCandidateRemovals();
+  }
+  for (Port& port : turn_ports_) {
+    port.CloseAndSignalCandidateRemovals();
+  }
+}
+
 void AllocationSequence::OnMessage(rtc::Message* msg) {
   ASSERT(rtc::Thread::Current() == session_->network_thread());
   ASSERT(msg->message_id == MSG_ALLOCATION_PHASE);
 
   const char* const PHASE_NAMES[kNumPhases] = {
     "Udp", "Relay", "Tcp", "SslTcp"
   };
 
   // Perform all of the phases in the current step.
   LOG_J(LS_INFO, network_) << "Allocation Phase="
@@ skipping 371 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