p2p/base/fake_port_allocator.h - src - Git at Google

 /*
  *  Copyright 2010 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.
  */

 #ifndef P2P_BASE_FAKE_PORT_ALLOCATOR_H_
 #define P2P_BASE_FAKE_PORT_ALLOCATOR_H_

 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>

 #include "absl/memory/memory.h"
 #include "absl/strings/string_view.h"
 #include "p2p/base/basic_packet_socket_factory.h"
 #include "p2p/base/port_allocator.h"
 #include "p2p/base/udp_port.h"
 #include "rtc_base/memory/always_valid_pointer.h"
 #include "rtc_base/net_helpers.h"
 #include "rtc_base/net_test_helpers.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "rtc_base/thread.h"

 namespace rtc {
 class SocketFactory;
 }

 namespace cricket {

 class TestUDPPort : public UDPPort {
  public:
   static TestUDPPort* Create(const PortParametersRef& args,
                              uint16_t min_port,
                              uint16_t max_port,
                              bool emit_localhost_for_anyaddress) {
     TestUDPPort* port = new TestUDPPort(args, min_port, max_port,
                                         emit_localhost_for_anyaddress);
     if (!port->Init()) {
       delete port;
       port = nullptr;
     }
     return port;
   }

   static std::unique_ptr<TestUDPPort> Create(
       const PortParametersRef& args,
       rtc::AsyncPacketSocket* socket,
       bool emit_localhost_for_anyaddress) {
     auto port = absl::WrapUnique(
         new TestUDPPort(args, socket, emit_localhost_for_anyaddress));
     if (!port->Init()) {
       return nullptr;
     }
     return port;
   }

  protected:
   TestUDPPort(const PortParametersRef& args,
               uint16_t min_port,
               uint16_t max_port,
               bool emit_localhost_for_anyaddress)
       : UDPPort(args,
                 webrtc::IceCandidateType::kHost,
                 min_port,
                 max_port,
                 emit_localhost_for_anyaddress) {}

   TestUDPPort(const PortParametersRef& args,
               rtc::AsyncPacketSocket* socket,
               bool emit_localhost_for_anyaddress)
       : UDPPort(args,
                 webrtc::IceCandidateType::kHost,
                 socket,
                 emit_localhost_for_anyaddress) {}
 };

 // A FakePortAllocatorSession can be used with either a real or fake socket
 // factory. It gathers a single loopback port, using IPv6 if available and
 // not disabled.
 class FakePortAllocatorSession : public PortAllocatorSession {
  public:
   FakePortAllocatorSession(PortAllocator* allocator,
                            rtc::Thread* network_thread,
                            rtc::PacketSocketFactory* factory,
                            absl::string_view content_name,
                            int component,
                            absl::string_view ice_ufrag,
                            absl::string_view ice_pwd,
                            const webrtc::FieldTrialsView* field_trials)
       : PortAllocatorSession(content_name,
                              component,
                              ice_ufrag,
                              ice_pwd,
                              allocator->flags()),
         allocator_(allocator),
         network_thread_(network_thread),
         factory_(factory),
         ipv4_network_("network",
                       "unittest",
                       rtc::IPAddress(INADDR_LOOPBACK),
                       32),
         ipv6_network_("network",
                       "unittest",
                       rtc::IPAddress(in6addr_loopback),
                       64),
         port_(),
         port_config_count_(0),
         stun_servers_(allocator->stun_servers()),
         turn_servers_(allocator->turn_servers()),
         field_trials_(field_trials) {
     ipv4_network_.AddIP(rtc::IPAddress(INADDR_LOOPBACK));
     ipv6_network_.AddIP(rtc::IPAddress(in6addr_loopback));
   }

   void SetCandidateFilter(uint32_t filter) override {
     candidate_filter_ = filter;
   }

   void StartGettingPorts() override {
     if (!port_) {
       rtc::Network& network =
           (rtc::HasIPv6Enabled() && (flags() & PORTALLOCATOR_ENABLE_IPV6))
               ? ipv6_network_
               : ipv4_network_;
       port_.reset(TestUDPPort::Create({.network_thread = network_thread_,
                                        .socket_factory = factory_,
                                        .network = &network,
                                        .ice_username_fragment = username(),
                                        .ice_password = password(),
                                        .field_trials = field_trials_},
                                       0, 0, false));
       RTC_DCHECK(port_);
       port_->SetIceTiebreaker(allocator_->ice_tiebreaker());
       port_->SubscribePortDestroyed(
           [this](PortInterface* port) { OnPortDestroyed(port); });
       AddPort(port_.get());
     }
     ++port_config_count_;
     running_ = true;
   }

   void StopGettingPorts() override { running_ = false; }
   bool IsGettingPorts() override { return running_; }
   void ClearGettingPorts() override { is_cleared = true; }
   bool IsCleared() const override { return is_cleared; }

   void RegatherOnFailedNetworks() override {
     SignalIceRegathering(this, IceRegatheringReason::NETWORK_FAILURE);
   }

   std::vector<PortInterface*> ReadyPorts() const override {
     return ready_ports_;
   }
   std::vector<Candidate> ReadyCandidates() const override {
     return candidates_;
   }
   void PruneAllPorts() override { port_->Prune(); }
   bool CandidatesAllocationDone() const override { return allocation_done_; }

   int port_config_count() { return port_config_count_; }

   const ServerAddresses& stun_servers() const { return stun_servers_; }

   const std::vector<RelayServerConfig>& turn_servers() const {
     return turn_servers_;
   }

   uint32_t candidate_filter() const { return candidate_filter_; }

   int transport_info_update_count() const {
     return transport_info_update_count_;
   }

  protected:
   void UpdateIceParametersInternal() override {
     // Since this class is a fake and this method only is overridden for tests,
     // we don't need to actually update the transport info.
     ++transport_info_update_count_;
   }

  private:
   void AddPort(cricket::Port* port) {
     port->set_component(component());
     port->set_generation(generation());
     port->SignalPortComplete.connect(this,
                                      &FakePortAllocatorSession::OnPortComplete);
     port->PrepareAddress();
     ready_ports_.push_back(port);
     SignalPortReady(this, port);
     port->KeepAliveUntilPruned();
   }
   void OnPortComplete(cricket::Port* port) {
     const std::vector<Candidate>& candidates = port->Candidates();
     candidates_.insert(candidates_.end(), candidates.begin(), candidates.end());
     SignalCandidatesReady(this, candidates);

     allocation_done_ = true;
     SignalCandidatesAllocationDone(this);
   }
   void OnPortDestroyed(cricket::PortInterface* port) {
     // Don't want to double-delete port if it deletes itself.
     port_.release();
   }

   PortAllocator* allocator_;
   rtc::Thread* network_thread_;
   rtc::PacketSocketFactory* factory_;
   rtc::Network ipv4_network_;
   rtc::Network ipv6_network_;
   std::unique_ptr<cricket::Port> port_;
   int port_config_count_;
   std::vector<Candidate> candidates_;
   std::vector<PortInterface*> ready_ports_;
   bool allocation_done_ = false;
   bool is_cleared = false;
   ServerAddresses stun_servers_;
   std::vector<RelayServerConfig> turn_servers_;
   uint32_t candidate_filter_ = CF_ALL;
   int transport_info_update_count_ = 0;
   bool running_ = false;
   const webrtc::FieldTrialsView* field_trials_;
 };

 class FakePortAllocator : public cricket::PortAllocator {
  public:
   FakePortAllocator(rtc::Thread* network_thread,
                     rtc::PacketSocketFactory* factory,
                     webrtc::FieldTrialsView* field_trials)
       : FakePortAllocator(network_thread, factory, nullptr, field_trials) {}

   FakePortAllocator(rtc::Thread* network_thread,
                     std::unique_ptr<rtc::PacketSocketFactory> factory,
                     webrtc::FieldTrialsView* field_trials)
       : FakePortAllocator(network_thread,
                           nullptr,
                           std::move(factory),
                           field_trials) {}

   void SetNetworkIgnoreMask(int network_ignore_mask) override {}

   cricket::PortAllocatorSession* CreateSessionInternal(
       absl::string_view content_name,
       int component,
       absl::string_view ice_ufrag,
       absl::string_view ice_pwd) override {
     return new FakePortAllocatorSession(
         this, network_thread_, factory_.get(), std::string(content_name),
         component, std::string(ice_ufrag), std::string(ice_pwd), field_trials_);
   }

   bool initialized() const { return initialized_; }

   // For testing: Manipulate MdnsObfuscationEnabled()
   bool MdnsObfuscationEnabled() const override {
     return mdns_obfuscation_enabled_;
   }
   void SetMdnsObfuscationEnabledForTesting(bool enabled) {
     mdns_obfuscation_enabled_ = enabled;
   }

  private:
   FakePortAllocator(rtc::Thread* network_thread,
                     rtc::PacketSocketFactory* factory,
                     std::unique_ptr<rtc::PacketSocketFactory> owned_factory,
                     webrtc::FieldTrialsView* field_trials)
       : network_thread_(network_thread),
         factory_(std::move(owned_factory), factory),
         field_trials_(field_trials) {
     if (network_thread_ == nullptr) {
       network_thread_ = rtc::Thread::Current();
       Initialize();
       return;
     }
     SendTask(network_thread_, [this] { Initialize(); });
   }

   rtc::Thread* network_thread_;
   const webrtc::AlwaysValidPointerNoDefault<rtc::PacketSocketFactory> factory_;
   const webrtc::FieldTrialsView* field_trials_;
   bool mdns_obfuscation_enabled_ = false;
 };

 }  // namespace cricket

 #endif  // P2P_BASE_FAKE_PORT_ALLOCATOR_H_
	/*
	* Copyright 2010 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.
	*/

	#ifndef P2P_BASE_FAKE_PORT_ALLOCATOR_H_
	#define P2P_BASE_FAKE_PORT_ALLOCATOR_H_

	#include <memory>
	#include <string>
	#include <utility>
	#include <vector>

	#include "absl/memory/memory.h"
	#include "absl/strings/string_view.h"
	#include "p2p/base/basic_packet_socket_factory.h"
	#include "p2p/base/port_allocator.h"
	#include "p2p/base/udp_port.h"
	#include "rtc_base/memory/always_valid_pointer.h"
	#include "rtc_base/net_helpers.h"
	#include "rtc_base/net_test_helpers.h"
	#include "rtc_base/task_queue_for_test.h"
	#include "rtc_base/thread.h"

	namespace rtc {
	class SocketFactory;
	}

	namespace cricket {

	class TestUDPPort : public UDPPort {
	public:
	static TestUDPPort* Create(const PortParametersRef& args,
	uint16_t min_port,
	uint16_t max_port,
	bool emit_localhost_for_anyaddress) {
	TestUDPPort* port = new TestUDPPort(args, min_port, max_port,
	emit_localhost_for_anyaddress);
	if (!port->Init()) {
	delete port;
	port = nullptr;
	}
	return port;
	}

	static std::unique_ptr<TestUDPPort> Create(
	const PortParametersRef& args,
	rtc::AsyncPacketSocket* socket,
	bool emit_localhost_for_anyaddress) {
	auto port = absl::WrapUnique(
	new TestUDPPort(args, socket, emit_localhost_for_anyaddress));
	if (!port->Init()) {
	return nullptr;
	}
	return port;
	}

	protected:
	TestUDPPort(const PortParametersRef& args,
	uint16_t min_port,
	uint16_t max_port,
	bool emit_localhost_for_anyaddress)
	: UDPPort(args,
	webrtc::IceCandidateType::kHost,
	min_port,
	max_port,
	emit_localhost_for_anyaddress) {}

	TestUDPPort(const PortParametersRef& args,
	rtc::AsyncPacketSocket* socket,
	bool emit_localhost_for_anyaddress)
	: UDPPort(args,
	webrtc::IceCandidateType::kHost,
	socket,
	emit_localhost_for_anyaddress) {}
	};

	// A FakePortAllocatorSession can be used with either a real or fake socket
	// factory. It gathers a single loopback port, using IPv6 if available and
	// not disabled.
	class FakePortAllocatorSession : public PortAllocatorSession {
	public:
	FakePortAllocatorSession(PortAllocator* allocator,
	rtc::Thread* network_thread,
	rtc::PacketSocketFactory* factory,
	absl::string_view content_name,
	int component,
	absl::string_view ice_ufrag,
	absl::string_view ice_pwd,
	const webrtc::FieldTrialsView* field_trials)
	: PortAllocatorSession(content_name,
	component,
	ice_ufrag,
	ice_pwd,
	allocator->flags()),
	allocator_(allocator),
	network_thread_(network_thread),
	factory_(factory),
	ipv4_network_("network",
	"unittest",
	rtc::IPAddress(INADDR_LOOPBACK),
	32),
	ipv6_network_("network",
	"unittest",
	rtc::IPAddress(in6addr_loopback),
	64),
	port_(),
	port_config_count_(0),
	stun_servers_(allocator->stun_servers()),
	turn_servers_(allocator->turn_servers()),
	field_trials_(field_trials) {
	ipv4_network_.AddIP(rtc::IPAddress(INADDR_LOOPBACK));
	ipv6_network_.AddIP(rtc::IPAddress(in6addr_loopback));
	}

	void SetCandidateFilter(uint32_t filter) override {
	candidate_filter_ = filter;
	}

	void StartGettingPorts() override {
	if (!port_) {
	rtc::Network& network =
	(rtc::HasIPv6Enabled() && (flags() & PORTALLOCATOR_ENABLE_IPV6))
	? ipv6_network_
	: ipv4_network_;
	port_.reset(TestUDPPort::Create({.network_thread = network_thread_,
	.socket_factory = factory_,
	.network = &network,
	.ice_username_fragment = username(),
	.ice_password = password(),
	.field_trials = field_trials_},
	0, 0, false));
	RTC_DCHECK(port_);
	port_->SetIceTiebreaker(allocator_->ice_tiebreaker());
	port_->SubscribePortDestroyed(
	[this](PortInterface* port) { OnPortDestroyed(port); });
	AddPort(port_.get());
	}
	++port_config_count_;
	running_ = true;
	}

	void StopGettingPorts() override { running_ = false; }
	bool IsGettingPorts() override { return running_; }
	void ClearGettingPorts() override { is_cleared = true; }
	bool IsCleared() const override { return is_cleared; }

	void RegatherOnFailedNetworks() override {
	SignalIceRegathering(this, IceRegatheringReason::NETWORK_FAILURE);
	}

	std::vector<PortInterface*> ReadyPorts() const override {
	return ready_ports_;
	}
	std::vector<Candidate> ReadyCandidates() const override {
	return candidates_;
	}
	void PruneAllPorts() override { port_->Prune(); }
	bool CandidatesAllocationDone() const override { return allocation_done_; }

	int port_config_count() { return port_config_count_; }

	const ServerAddresses& stun_servers() const { return stun_servers_; }

	const std::vector<RelayServerConfig>& turn_servers() const {
	return turn_servers_;
	}

	uint32_t candidate_filter() const { return candidate_filter_; }

	int transport_info_update_count() const {
	return transport_info_update_count_;
	}

	protected:
	void UpdateIceParametersInternal() override {
	// Since this class is a fake and this method only is overridden for tests,
	// we don't need to actually update the transport info.
	++transport_info_update_count_;
	}

	private:
	void AddPort(cricket::Port* port) {
	port->set_component(component());
	port->set_generation(generation());
	port->SignalPortComplete.connect(this,
	&FakePortAllocatorSession::OnPortComplete);
	port->PrepareAddress();
	ready_ports_.push_back(port);
	SignalPortReady(this, port);
	port->KeepAliveUntilPruned();
	}
	void OnPortComplete(cricket::Port* port) {
	const std::vector<Candidate>& candidates = port->Candidates();
	candidates_.insert(candidates_.end(), candidates.begin(), candidates.end());
	SignalCandidatesReady(this, candidates);

	allocation_done_ = true;
	SignalCandidatesAllocationDone(this);
	}
	void OnPortDestroyed(cricket::PortInterface* port) {
	// Don't want to double-delete port if it deletes itself.
	port_.release();
	}

	PortAllocator* allocator_;
	rtc::Thread* network_thread_;
	rtc::PacketSocketFactory* factory_;
	rtc::Network ipv4_network_;
	rtc::Network ipv6_network_;
	std::unique_ptr<cricket::Port> port_;
	int port_config_count_;
	std::vector<Candidate> candidates_;
	std::vector<PortInterface*> ready_ports_;
	bool allocation_done_ = false;
	bool is_cleared = false;
	ServerAddresses stun_servers_;
	std::vector<RelayServerConfig> turn_servers_;
	uint32_t candidate_filter_ = CF_ALL;
	int transport_info_update_count_ = 0;
	bool running_ = false;
	const webrtc::FieldTrialsView* field_trials_;
	};

	class FakePortAllocator : public cricket::PortAllocator {
	public:
	FakePortAllocator(rtc::Thread* network_thread,
	rtc::PacketSocketFactory* factory,
	webrtc::FieldTrialsView* field_trials)
	: FakePortAllocator(network_thread, factory, nullptr, field_trials) {}

	FakePortAllocator(rtc::Thread* network_thread,
	std::unique_ptr<rtc::PacketSocketFactory> factory,
	webrtc::FieldTrialsView* field_trials)
	: FakePortAllocator(network_thread,
	nullptr,
	std::move(factory),
	field_trials) {}

	void SetNetworkIgnoreMask(int network_ignore_mask) override {}

	cricket::PortAllocatorSession* CreateSessionInternal(
	absl::string_view content_name,
	int component,
	absl::string_view ice_ufrag,
	absl::string_view ice_pwd) override {
	return new FakePortAllocatorSession(
	this, network_thread_, factory_.get(), std::string(content_name),
	component, std::string(ice_ufrag), std::string(ice_pwd), field_trials_);
	}

	bool initialized() const { return initialized_; }

	// For testing: Manipulate MdnsObfuscationEnabled()
	bool MdnsObfuscationEnabled() const override {
	return mdns_obfuscation_enabled_;
	}
	void SetMdnsObfuscationEnabledForTesting(bool enabled) {
	mdns_obfuscation_enabled_ = enabled;
	}

	private:
	FakePortAllocator(rtc::Thread* network_thread,
	rtc::PacketSocketFactory* factory,
	std::unique_ptr<rtc::PacketSocketFactory> owned_factory,
	webrtc::FieldTrialsView* field_trials)
	: network_thread_(network_thread),
	factory_(std::move(owned_factory), factory),
	field_trials_(field_trials) {
	if (network_thread_ == nullptr) {
	network_thread_ = rtc::Thread::Current();
	Initialize();
	return;
	}
	SendTask(network_thread_, [this] { Initialize(); });
	}

	rtc::Thread* network_thread_;
	const webrtc::AlwaysValidPointerNoDefault<rtc::PacketSocketFactory> factory_;
	const webrtc::FieldTrialsView* field_trials_;
	bool mdns_obfuscation_enabled_ = false;
	};

	} // namespace cricket

	#endif // P2P_BASE_FAKE_PORT_ALLOCATOR_H_