blob: 7d8e3d77e86b9d8fc41d63a4249b525304013e82 [file] [log] [blame]
/*
* Copyright 2009 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_FAKETRANSPORTCONTROLLER_H_
#define WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_
#include <map>
#include <string>
#include <vector>
#include "webrtc/p2p/base/transport.h"
#include "webrtc/p2p/base/transportchannel.h"
#include "webrtc/p2p/base/transportcontroller.h"
#include "webrtc/p2p/base/transportchannelimpl.h"
#include "webrtc/base/bind.h"
#include "webrtc/base/buffer.h"
#include "webrtc/base/fakesslidentity.h"
#include "webrtc/base/messagequeue.h"
#include "webrtc/base/sigslot.h"
#include "webrtc/base/sslfingerprint.h"
#include "webrtc/base/thread.h"
namespace cricket {
class FakeTransport;
struct PacketMessageData : public rtc::MessageData {
PacketMessageData(const char* data, size_t len) : packet(data, len) {}
rtc::Buffer packet;
};
// Fake transport channel class, which can be passed to anything that needs a
// transport channel. Can be informed of another FakeTransportChannel via
// SetDestination.
// TODO(hbos): Move implementation to .cc file, this and other classes in file.
class FakeTransportChannel : public TransportChannelImpl,
public rtc::MessageHandler {
public:
explicit FakeTransportChannel(Transport* transport,
const std::string& name,
int component)
: TransportChannelImpl(name, component),
transport_(transport),
dtls_fingerprint_("", nullptr, 0) {}
~FakeTransportChannel() { Reset(); }
uint64_t IceTiebreaker() const { return tiebreaker_; }
IceMode remote_ice_mode() const { return remote_ice_mode_; }
const std::string& ice_ufrag() const { return ice_ufrag_; }
const std::string& ice_pwd() const { return ice_pwd_; }
const std::string& remote_ice_ufrag() const { return remote_ice_ufrag_; }
const std::string& remote_ice_pwd() const { return remote_ice_pwd_; }
const rtc::SSLFingerprint& dtls_fingerprint() const {
return dtls_fingerprint_;
}
// If async, will send packets by "Post"-ing to message queue instead of
// synchronously "Send"-ing.
void SetAsync(bool async) { async_ = async; }
Transport* GetTransport() override { return transport_; }
TransportChannelState GetState() const override {
if (connection_count_ == 0) {
return had_connection_ ? TransportChannelState::STATE_FAILED
: TransportChannelState::STATE_INIT;
}
if (connection_count_ == 1) {
return TransportChannelState::STATE_COMPLETED;
}
return TransportChannelState::STATE_CONNECTING;
}
void SetIceRole(IceRole role) override { role_ = role; }
IceRole GetIceRole() const override { return role_; }
void SetIceTiebreaker(uint64_t tiebreaker) override {
tiebreaker_ = tiebreaker;
}
void SetIceCredentials(const std::string& ice_ufrag,
const std::string& ice_pwd) override {
ice_ufrag_ = ice_ufrag;
ice_pwd_ = ice_pwd;
}
void SetRemoteIceCredentials(const std::string& ice_ufrag,
const std::string& ice_pwd) override {
remote_ice_ufrag_ = ice_ufrag;
remote_ice_pwd_ = ice_pwd;
}
void SetRemoteIceMode(IceMode mode) override { remote_ice_mode_ = mode; }
bool SetRemoteFingerprint(const std::string& alg,
const uint8_t* digest,
size_t digest_len) override {
dtls_fingerprint_ = rtc::SSLFingerprint(alg, digest, digest_len);
return true;
}
bool SetSslRole(rtc::SSLRole role) override {
ssl_role_ = role;
return true;
}
bool GetSslRole(rtc::SSLRole* role) const override {
*role = ssl_role_;
return true;
}
void Connect() override {
if (state_ == STATE_INIT) {
state_ = STATE_CONNECTING;
}
}
void MaybeStartGathering() override {
if (gathering_state_ == kIceGatheringNew) {
gathering_state_ = kIceGatheringGathering;
SignalGatheringState(this);
}
}
IceGatheringState gathering_state() const override {
return gathering_state_;
}
void Reset() {
if (state_ != STATE_INIT) {
state_ = STATE_INIT;
if (dest_) {
dest_->state_ = STATE_INIT;
dest_->dest_ = nullptr;
dest_ = nullptr;
}
}
}
void SetWritable(bool writable) { set_writable(writable); }
void SetDestination(FakeTransportChannel* dest) {
if (state_ == STATE_CONNECTING && dest) {
// This simulates the delivery of candidates.
dest_ = dest;
dest_->dest_ = this;
if (local_cert_ && dest_->local_cert_) {
do_dtls_ = true;
dest_->do_dtls_ = true;
NegotiateSrtpCiphers();
}
state_ = STATE_CONNECTED;
dest_->state_ = STATE_CONNECTED;
set_writable(true);
dest_->set_writable(true);
} else if (state_ == STATE_CONNECTED && !dest) {
// Simulates loss of connectivity, by asymmetrically forgetting dest_.
dest_ = nullptr;
state_ = STATE_CONNECTING;
set_writable(false);
}
}
void SetConnectionCount(size_t connection_count) {
size_t old_connection_count = connection_count_;
connection_count_ = connection_count;
if (connection_count)
had_connection_ = true;
if (connection_count_ < old_connection_count)
SignalConnectionRemoved(this);
}
void SetCandidatesGatheringComplete() {
if (gathering_state_ != kIceGatheringComplete) {
gathering_state_ = kIceGatheringComplete;
SignalGatheringState(this);
}
}
void SetReceiving(bool receiving) { set_receiving(receiving); }
void SetIceConfig(const IceConfig& config) override {
receiving_timeout_ = config.receiving_timeout_ms;
gather_continually_ = config.gather_continually;
}
int receiving_timeout() const { return receiving_timeout_; }
bool gather_continually() const { return gather_continually_; }
int SendPacket(const char* data,
size_t len,
const rtc::PacketOptions& options,
int flags) override {
if (state_ != STATE_CONNECTED) {
return -1;
}
if (flags != PF_SRTP_BYPASS && flags != 0) {
return -1;
}
PacketMessageData* packet = new PacketMessageData(data, len);
if (async_) {
rtc::Thread::Current()->Post(this, 0, packet);
} else {
rtc::Thread::Current()->Send(this, 0, packet);
}
return static_cast<int>(len);
}
int SetOption(rtc::Socket::Option opt, int value) override { return true; }
bool GetOption(rtc::Socket::Option opt, int* value) override { return true; }
int GetError() override { return 0; }
void AddRemoteCandidate(const Candidate& candidate) override {
remote_candidates_.push_back(candidate);
}
const Candidates& remote_candidates() const { return remote_candidates_; }
void OnMessage(rtc::Message* msg) override {
PacketMessageData* data = static_cast<PacketMessageData*>(msg->pdata);
dest_->SignalReadPacket(dest_, data->packet.data<char>(),
data->packet.size(), rtc::CreatePacketTime(0), 0);
delete data;
}
bool SetLocalCertificate(
const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
local_cert_ = certificate;
return true;
}
void SetRemoteSSLCertificate(rtc::FakeSSLCertificate* cert) {
remote_cert_ = cert;
}
bool IsDtlsActive() const override { return do_dtls_; }
bool SetSrtpCiphers(const std::vector<std::string>& ciphers) override {
srtp_ciphers_ = ciphers;
return true;
}
bool GetSrtpCryptoSuite(std::string* cipher) override {
if (!chosen_srtp_cipher_.empty()) {
*cipher = chosen_srtp_cipher_;
return true;
}
return false;
}
bool GetSslCipherSuite(int* cipher) override { return false; }
rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const {
return local_cert_;
}
bool GetRemoteSSLCertificate(rtc::SSLCertificate** cert) const override {
if (!remote_cert_)
return false;
*cert = remote_cert_->GetReference();
return true;
}
bool ExportKeyingMaterial(const std::string& label,
const uint8_t* context,
size_t context_len,
bool use_context,
uint8_t* result,
size_t result_len) override {
if (!chosen_srtp_cipher_.empty()) {
memset(result, 0xff, result_len);
return true;
}
return false;
}
void NegotiateSrtpCiphers() {
for (std::vector<std::string>::const_iterator it1 = srtp_ciphers_.begin();
it1 != srtp_ciphers_.end(); ++it1) {
for (std::vector<std::string>::const_iterator it2 =
dest_->srtp_ciphers_.begin();
it2 != dest_->srtp_ciphers_.end(); ++it2) {
if (*it1 == *it2) {
chosen_srtp_cipher_ = *it1;
dest_->chosen_srtp_cipher_ = *it2;
return;
}
}
}
}
bool GetStats(ConnectionInfos* infos) override {
ConnectionInfo info;
infos->clear();
infos->push_back(info);
return true;
}
void set_ssl_max_protocol_version(rtc::SSLProtocolVersion version) {
ssl_max_version_ = version;
}
rtc::SSLProtocolVersion ssl_max_protocol_version() const {
return ssl_max_version_;
}
private:
enum State { STATE_INIT, STATE_CONNECTING, STATE_CONNECTED };
Transport* transport_;
FakeTransportChannel* dest_ = nullptr;
State state_ = STATE_INIT;
bool async_ = false;
Candidates remote_candidates_;
rtc::scoped_refptr<rtc::RTCCertificate> local_cert_;
rtc::FakeSSLCertificate* remote_cert_ = nullptr;
bool do_dtls_ = false;
std::vector<std::string> srtp_ciphers_;
std::string chosen_srtp_cipher_;
int receiving_timeout_ = -1;
bool gather_continually_ = false;
IceRole role_ = ICEROLE_UNKNOWN;
uint64_t tiebreaker_ = 0;
std::string ice_ufrag_;
std::string ice_pwd_;
std::string remote_ice_ufrag_;
std::string remote_ice_pwd_;
IceMode remote_ice_mode_ = ICEMODE_FULL;
rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_10;
rtc::SSLFingerprint dtls_fingerprint_;
rtc::SSLRole ssl_role_ = rtc::SSL_CLIENT;
size_t connection_count_ = 0;
IceGatheringState gathering_state_ = kIceGatheringNew;
bool had_connection_ = false;
};
// Fake transport class, which can be passed to anything that needs a Transport.
// Can be informed of another FakeTransport via SetDestination (low-tech way
// of doing candidates)
class FakeTransport : public Transport {
public:
typedef std::map<int, FakeTransportChannel*> ChannelMap;
explicit FakeTransport(const std::string& name) : Transport(name, nullptr) {}
// Note that we only have a constructor with the allocator parameter so it can
// be wrapped by a DtlsTransport.
FakeTransport(const std::string& name, PortAllocator* allocator)
: Transport(name, nullptr) {}
~FakeTransport() { DestroyAllChannels(); }
const ChannelMap& channels() const { return channels_; }
// If async, will send packets by "Post"-ing to message queue instead of
// synchronously "Send"-ing.
void SetAsync(bool async) { async_ = async; }
void SetDestination(FakeTransport* dest) {
dest_ = dest;
for (const auto& kv : channels_) {
kv.second->SetLocalCertificate(certificate_);
SetChannelDestination(kv.first, kv.second);
}
}
void SetWritable(bool writable) {
for (const auto& kv : channels_) {
kv.second->SetWritable(writable);
}
}
void SetLocalCertificate(
const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override {
certificate_ = certificate;
}
bool GetLocalCertificate(
rtc::scoped_refptr<rtc::RTCCertificate>* certificate) override {
if (!certificate_)
return false;
*certificate = certificate_;
return true;
}
bool GetSslRole(rtc::SSLRole* role) const override {
if (channels_.empty()) {
return false;
}
return channels_.begin()->second->GetSslRole(role);
}
bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version) override {
ssl_max_version_ = version;
for (const auto& kv : channels_) {
kv.second->set_ssl_max_protocol_version(ssl_max_version_);
}
return true;
}
rtc::SSLProtocolVersion ssl_max_protocol_version() const {
return ssl_max_version_;
}
using Transport::local_description;
using Transport::remote_description;
protected:
TransportChannelImpl* CreateTransportChannel(int component) override {
if (channels_.find(component) != channels_.end()) {
return nullptr;
}
FakeTransportChannel* channel =
new FakeTransportChannel(this, name(), component);
channel->set_ssl_max_protocol_version(ssl_max_version_);
channel->SetAsync(async_);
SetChannelDestination(component, channel);
channels_[component] = channel;
return channel;
}
void DestroyTransportChannel(TransportChannelImpl* channel) override {
channels_.erase(channel->component());
delete channel;
}
private:
FakeTransportChannel* GetFakeChannel(int component) {
auto it = channels_.find(component);
return (it != channels_.end()) ? it->second : nullptr;
}
void SetChannelDestination(int component, FakeTransportChannel* channel) {
FakeTransportChannel* dest_channel = nullptr;
if (dest_) {
dest_channel = dest_->GetFakeChannel(component);
if (dest_channel) {
dest_channel->SetLocalCertificate(dest_->certificate_);
}
}
channel->SetDestination(dest_channel);
}
// Note, this is distinct from the Channel map owned by Transport.
// This map just tracks the FakeTransportChannels created by this class.
// It's mainly needed so that we can access a FakeTransportChannel directly,
// even if wrapped by a DtlsTransportChannelWrapper.
ChannelMap channels_;
FakeTransport* dest_ = nullptr;
bool async_ = false;
rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_10;
};
// Fake TransportController class, which can be passed into a BaseChannel object
// for test purposes. Can be connected to other FakeTransportControllers via
// Connect().
//
// This fake is unusual in that for the most part, it's implemented with the
// real TransportController code, but with fake TransportChannels underneath.
class FakeTransportController : public TransportController {
public:
FakeTransportController()
: TransportController(rtc::Thread::Current(),
rtc::Thread::Current(),
nullptr),
fail_create_channel_(false) {}
explicit FakeTransportController(IceRole role)
: TransportController(rtc::Thread::Current(),
rtc::Thread::Current(),
nullptr),
fail_create_channel_(false) {
SetIceRole(role);
}
explicit FakeTransportController(rtc::Thread* worker_thread)
: TransportController(rtc::Thread::Current(), worker_thread, nullptr),
fail_create_channel_(false) {}
FakeTransportController(rtc::Thread* worker_thread, IceRole role)
: TransportController(rtc::Thread::Current(), worker_thread, nullptr),
fail_create_channel_(false) {
SetIceRole(role);
}
FakeTransport* GetTransport_w(const std::string& transport_name) {
return static_cast<FakeTransport*>(
TransportController::GetTransport_w(transport_name));
}
void Connect(FakeTransportController* dest) {
worker_thread()->Invoke<void>(
rtc::Bind(&FakeTransportController::Connect_w, this, dest));
}
TransportChannel* CreateTransportChannel_w(const std::string& transport_name,
int component) override {
if (fail_create_channel_) {
return nullptr;
}
return TransportController::CreateTransportChannel_w(transport_name,
component);
}
void set_fail_channel_creation(bool fail_channel_creation) {
fail_create_channel_ = fail_channel_creation;
}
protected:
Transport* CreateTransport_w(const std::string& transport_name) override {
return new FakeTransport(transport_name);
}
void Connect_w(FakeTransportController* dest) {
// Simulate the exchange of candidates.
ConnectChannels_w();
dest->ConnectChannels_w();
for (auto& kv : transports()) {
FakeTransport* transport = static_cast<FakeTransport*>(kv.second);
transport->SetDestination(dest->GetTransport_w(kv.first));
}
}
void ConnectChannels_w() {
for (auto& kv : transports()) {
FakeTransport* transport = static_cast<FakeTransport*>(kv.second);
transport->ConnectChannels();
transport->MaybeStartGathering();
}
}
private:
bool fail_create_channel_;
};
} // namespace cricket
#endif // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_