rhubarb-lip-sync/rhubarb/lib/webrtc-8d2248ff/webrtc/p2p/base/fakeportallocator.h

240 lines
8.0 KiB
C++

/*
* 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 WEBRTC_P2P_BASE_FAKEPORTALLOCATOR_H_
#define WEBRTC_P2P_BASE_FAKEPORTALLOCATOR_H_
#include <memory>
#include <string>
#include <vector>
#include "webrtc/base/nethelpers.h"
#include "webrtc/p2p/base/basicpacketsocketfactory.h"
#include "webrtc/p2p/base/portallocator.h"
#include "webrtc/p2p/base/udpport.h"
namespace rtc {
class SocketFactory;
class Thread;
}
namespace cricket {
class TestUDPPort : public UDPPort {
public:
static TestUDPPort* Create(rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
uint16_t min_port,
uint16_t max_port,
const std::string& username,
const std::string& password,
const std::string& origin,
bool emit_localhost_for_anyaddress) {
TestUDPPort* port = new TestUDPPort(thread, factory, network, ip, min_port,
max_port, username, password, origin,
emit_localhost_for_anyaddress);
if (!port->Init()) {
delete port;
port = nullptr;
}
return port;
}
void SendBindingResponse(StunMessage* request,
const rtc::SocketAddress& addr) override {
UDPPort::SendBindingResponse(request, addr);
sent_binding_response_ = true;
}
bool sent_binding_response() { return sent_binding_response_; }
void set_sent_binding_response(bool response) {
sent_binding_response_ = response;
}
protected:
TestUDPPort(rtc::Thread* thread,
rtc::PacketSocketFactory* factory,
rtc::Network* network,
const rtc::IPAddress& ip,
uint16_t min_port,
uint16_t max_port,
const std::string& username,
const std::string& password,
const std::string& origin,
bool emit_localhost_for_anyaddress)
: UDPPort(thread,
factory,
network,
ip,
min_port,
max_port,
username,
password,
origin,
emit_localhost_for_anyaddress) {}
bool sent_binding_response_ = false;
};
// 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* worker_thread,
rtc::PacketSocketFactory* factory,
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()),
worker_thread_(worker_thread),
factory_(factory),
ipv4_network_("network",
"unittest",
rtc::IPAddress(INADDR_LOOPBACK),
32),
ipv6_network_("network",
"unittest",
rtc::IPAddress(in6addr_loopback),
64),
port_(),
running_(false),
port_config_count_(0),
stun_servers_(allocator->stun_servers()),
turn_servers_(allocator->turn_servers()) {
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(worker_thread_, factory_, &network,
network.GetBestIP(), 0, 0, username(),
password(), std::string(), false));
AddPort(port_.get());
}
++port_config_count_;
running_ = true;
}
void StopGettingPorts() override { running_ = false; }
bool IsGettingPorts() override { return running_; }
void ClearGettingPorts() override {}
std::vector<PortInterface*> ReadyPorts() const override {
return ready_ports_;
}
std::vector<Candidate> ReadyCandidates() const override {
return candidates_;
}
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);
}
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);
}
rtc::Thread* worker_thread_;
rtc::PacketSocketFactory* factory_;
rtc::Network ipv4_network_;
rtc::Network ipv6_network_;
std::unique_ptr<cricket::Port> port_;
bool running_;
int port_config_count_;
std::vector<Candidate> candidates_;
std::vector<PortInterface*> ready_ports_;
bool allocation_done_ = false;
ServerAddresses stun_servers_;
std::vector<RelayServerConfig> turn_servers_;
uint32_t candidate_filter_ = CF_ALL;
int transport_info_update_count_ = 0;
};
class FakePortAllocator : public cricket::PortAllocator {
public:
FakePortAllocator(rtc::Thread* worker_thread,
rtc::PacketSocketFactory* factory)
: worker_thread_(worker_thread), factory_(factory) {
if (factory_ == NULL) {
owned_factory_.reset(new rtc::BasicPacketSocketFactory(worker_thread_));
factory_ = owned_factory_.get();
}
}
void SetNetworkIgnoreMask(int network_ignore_mask) override {}
cricket::PortAllocatorSession* CreateSessionInternal(
const std::string& content_name,
int component,
const std::string& ice_ufrag,
const std::string& ice_pwd) override {
return new FakePortAllocatorSession(this, worker_thread_, factory_,
content_name, component, ice_ufrag,
ice_pwd);
}
private:
rtc::Thread* worker_thread_;
rtc::PacketSocketFactory* factory_;
std::unique_ptr<rtc::BasicPacketSocketFactory> owned_factory_;
};
} // namespace cricket
#endif // WEBRTC_P2P_BASE_FAKEPORTALLOCATOR_H_