| /* |
| * 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 <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "webrtc/p2p/base/candidatepairinterface.h" |
| #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; |
| |
| namespace { |
| struct PacketMessageData : public rtc::MessageData { |
| PacketMessageData(const char* data, size_t len) : packet(data, len) {} |
| rtc::Buffer packet; |
| }; |
| } // namespace |
| |
| // 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(const std::string& name, int component) |
| : TransportChannelImpl(name, component), |
| 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; } |
| |
| 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); } |
| |
| // Simulates the two transport channels connecting to each other. |
| // If |asymmetric| is true this method only affects this FakeTransportChannel. |
| // If false, it affects |dest| as well. |
| void SetDestination(FakeTransportChannel* dest, bool asymmetric = false) { |
| if (state_ == STATE_CONNECTING && dest) { |
| // This simulates the delivery of candidates. |
| dest_ = dest; |
| if (local_cert_ && dest_->local_cert_) { |
| do_dtls_ = true; |
| NegotiateSrtpCiphers(); |
| } |
| state_ = STATE_CONNECTED; |
| set_writable(true); |
| if (!asymmetric) { |
| dest->SetDestination(this, 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; |
| 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); |
| } |
| rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis()); |
| SignalSentPacket(this, sent_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); |
| } |
| |
| void RemoveRemoteCandidate(const Candidate& candidate) override {} |
| |
| 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) override { |
| local_cert_ = certificate; |
| return true; |
| } |
| |
| void SetRemoteSSLCertificate(rtc::FakeSSLCertificate* cert) { |
| remote_cert_ = cert; |
| } |
| |
| bool IsDtlsActive() const override { return do_dtls_; } |
| |
| bool SetSrtpCryptoSuites(const std::vector<int>& ciphers) override { |
| srtp_ciphers_ = ciphers; |
| return true; |
| } |
| |
| bool GetSrtpCryptoSuite(int* crypto_suite) override { |
| if (chosen_crypto_suite_ != rtc::SRTP_INVALID_CRYPTO_SUITE) { |
| *crypto_suite = chosen_crypto_suite_; |
| return true; |
| } |
| return false; |
| } |
| |
| bool GetSslCipherSuite(int* cipher_suite) override { return false; } |
| |
| rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const override { |
| return local_cert_; |
| } |
| |
| std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate() |
| const override { |
| return remote_cert_ ? std::unique_ptr<rtc::SSLCertificate>( |
| remote_cert_->GetReference()) |
| : nullptr; |
| } |
| |
| 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_crypto_suite_ != rtc::SRTP_INVALID_CRYPTO_SUITE) { |
| memset(result, 0xff, result_len); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| 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: |
| void NegotiateSrtpCiphers() { |
| for (std::vector<int>::const_iterator it1 = srtp_ciphers_.begin(); |
| it1 != srtp_ciphers_.end(); ++it1) { |
| for (std::vector<int>::const_iterator it2 = dest_->srtp_ciphers_.begin(); |
| it2 != dest_->srtp_ciphers_.end(); ++it2) { |
| if (*it1 == *it2) { |
| chosen_crypto_suite_ = *it1; |
| return; |
| } |
| } |
| } |
| } |
| |
| enum State { STATE_INIT, STATE_CONNECTING, STATE_CONNECTED }; |
| 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<int> srtp_ciphers_; |
| int chosen_crypto_suite_ = rtc::SRTP_INVALID_CRYPTO_SUITE; |
| 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_12; |
| 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; } |
| |
| // If |asymmetric| is true, only set the destination for this transport, and |
| // not |dest|. |
| void SetDestination(FakeTransport* dest, bool asymmetric = false) { |
| dest_ = dest; |
| for (const auto& kv : channels_) { |
| kv.second->SetLocalCertificate(certificate_); |
| SetChannelDestination(kv.first, kv.second, asymmetric); |
| } |
| } |
| |
| 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; |
| using Transport::VerifyCertificateFingerprint; |
| using Transport::NegotiateRole; |
| |
| protected: |
| TransportChannelImpl* CreateTransportChannel(int component) override { |
| if (channels_.find(component) != channels_.end()) { |
| return nullptr; |
| } |
| FakeTransportChannel* channel = new FakeTransportChannel(name(), component); |
| channel->set_ssl_max_protocol_version(ssl_max_version_); |
| channel->SetAsync(async_); |
| SetChannelDestination(component, channel, false); |
| 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, |
| bool asymmetric) { |
| FakeTransportChannel* dest_channel = nullptr; |
| if (dest_) { |
| dest_channel = dest_->GetFakeChannel(component); |
| if (dest_channel && !asymmetric) { |
| dest_channel->SetLocalCertificate(dest_->certificate_); |
| } |
| } |
| channel->SetDestination(dest_channel, asymmetric); |
| } |
| |
| // 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_12; |
| }; |
| |
| // Fake candidate pair class, which can be passed to BaseChannel for testing |
| // purposes. |
| class FakeCandidatePair : public CandidatePairInterface { |
| public: |
| FakeCandidatePair(const Candidate& local_candidate, |
| const Candidate& remote_candidate) |
| : local_candidate_(local_candidate), |
| remote_candidate_(remote_candidate) {} |
| const Candidate& local_candidate() const override { return local_candidate_; } |
| const Candidate& remote_candidate() const override { |
| return remote_candidate_; |
| } |
| |
| private: |
| Candidate local_candidate_; |
| Candidate remote_candidate_; |
| }; |
| |
| // 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_n(const std::string& transport_name) { |
| return static_cast<FakeTransport*>( |
| TransportController::GetTransport_n(transport_name)); |
| } |
| |
| void Connect(FakeTransportController* dest) { |
| network_thread()->Invoke<void>( |
| rtc::Bind(&FakeTransportController::Connect_n, this, dest)); |
| } |
| |
| TransportChannel* CreateTransportChannel_n(const std::string& transport_name, |
| int component) override { |
| if (fail_create_channel_) { |
| return nullptr; |
| } |
| return TransportController::CreateTransportChannel_n(transport_name, |
| component); |
| } |
| |
| FakeCandidatePair* CreateFakeCandidatePair( |
| const rtc::SocketAddress& local_address, |
| int16_t local_network_id, |
| const rtc::SocketAddress& remote_address, |
| int16_t remote_network_id) { |
| Candidate local_candidate(0, "udp", local_address, 0u, "", "", "local", 0, |
| "foundation", local_network_id, 0); |
| Candidate remote_candidate(0, "udp", remote_address, 0u, "", "", "local", 0, |
| "foundation", remote_network_id, 0); |
| return new FakeCandidatePair(local_candidate, remote_candidate); |
| } |
| |
| void set_fail_channel_creation(bool fail_channel_creation) { |
| fail_create_channel_ = fail_channel_creation; |
| } |
| |
| protected: |
| Transport* CreateTransport_n(const std::string& transport_name) override { |
| return new FakeTransport(transport_name); |
| } |
| |
| void Connect_n(FakeTransportController* dest) { |
| // Simulate the exchange of candidates. |
| ConnectChannels_n(); |
| dest->ConnectChannels_n(); |
| for (auto& kv : transports()) { |
| FakeTransport* transport = static_cast<FakeTransport*>(kv.second); |
| transport->SetDestination(dest->GetTransport_n(kv.first)); |
| } |
| } |
| |
| void ConnectChannels_n() { |
| TransportDescription faketransport_desc( |
| std::vector<std::string>(), |
| rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH), |
| rtc::CreateRandomString(cricket::ICE_PWD_LENGTH), cricket::ICEMODE_FULL, |
| cricket::CONNECTIONROLE_NONE, nullptr); |
| for (auto& kv : transports()) { |
| FakeTransport* transport = static_cast<FakeTransport*>(kv.second); |
| // Set local transport description for FakeTransport before connecting. |
| // Otherwise, the RTC_CHECK in Transport.ConnectChannel will fail. |
| if (!transport->local_description()) { |
| transport->SetLocalTransportDescription(faketransport_desc, |
| cricket::CA_OFFER, nullptr); |
| } |
| transport->ConnectChannels(); |
| transport->MaybeStartGathering(); |
| } |
| } |
| |
| private: |
| bool fail_create_channel_; |
| }; |
| |
| } // namespace cricket |
| |
| #endif // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_ |