/* * Copyright 2015 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_TRANSPORTCONTROLLER_H_ #define WEBRTC_P2P_BASE_TRANSPORTCONTROLLER_H_ #include #include #include #include #include "webrtc/base/asyncinvoker.h" #include "webrtc/base/sigslot.h" #include "webrtc/base/sslstreamadapter.h" #include "webrtc/p2p/base/candidate.h" #include "webrtc/p2p/base/transport.h" namespace rtc { class Thread; } namespace cricket { class TransportController : public sigslot::has_slots<>, public rtc::MessageHandler { public: TransportController(rtc::Thread* signaling_thread, rtc::Thread* network_thread, PortAllocator* port_allocator); virtual ~TransportController(); rtc::Thread* signaling_thread() const { return signaling_thread_; } rtc::Thread* network_thread() const { return network_thread_; } PortAllocator* port_allocator() const { return port_allocator_; } // Can only be set before transports are created. // TODO(deadbeef): Make this an argument to the constructor once BaseSession // and WebRtcSession are combined bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version); void SetIceConfig(const IceConfig& config); void SetIceRole(IceRole ice_role); bool GetSslRole(const std::string& transport_name, rtc::SSLRole* role); // Specifies the identity to use in this session. // Can only be called once. bool SetLocalCertificate( const rtc::scoped_refptr& certificate); bool GetLocalCertificate( const std::string& transport_name, rtc::scoped_refptr* certificate); // Caller owns returned certificate std::unique_ptr GetRemoteSSLCertificate( const std::string& transport_name); bool SetLocalTransportDescription(const std::string& transport_name, const TransportDescription& tdesc, ContentAction action, std::string* err); bool SetRemoteTransportDescription(const std::string& transport_name, const TransportDescription& tdesc, ContentAction action, std::string* err); // Start gathering candidates for any new transports, or transports doing an // ICE restart. void MaybeStartGathering(); bool AddRemoteCandidates(const std::string& transport_name, const Candidates& candidates, std::string* err); bool RemoveRemoteCandidates(const Candidates& candidates, std::string* err); bool ReadyForRemoteCandidates(const std::string& transport_name); bool GetStats(const std::string& transport_name, TransportStats* stats); // Creates a channel if it doesn't exist. Otherwise, increments a reference // count and returns an existing channel. virtual TransportChannel* CreateTransportChannel_n( const std::string& transport_name, int component); // Decrements a channel's reference count, and destroys the channel if // nothing is referencing it. virtual void DestroyTransportChannel_n(const std::string& transport_name, int component); void use_quic() { quic_ = true; } bool quic() const { return quic_; } // All of these signals are fired on the signalling thread. // If any transport failed => failed, // Else if all completed => completed, // Else if all connected => connected, // Else => connecting sigslot::signal1 SignalConnectionState; // Receiving if any transport is receiving sigslot::signal1 SignalReceiving; // If all transports done gathering => complete, // Else if any are gathering => gathering, // Else => new sigslot::signal1 SignalGatheringState; // (transport_name, candidates) sigslot::signal2 SignalCandidatesGathered; sigslot::signal1 SignalCandidatesRemoved; // for unit test const rtc::scoped_refptr& certificate_for_testing(); protected: // Protected and virtual so we can override it in unit tests. virtual Transport* CreateTransport_n(const std::string& transport_name); // For unit tests const std::map& transports() { return transports_; } Transport* GetTransport_n(const std::string& transport_name); private: void OnMessage(rtc::Message* pmsg) override; // It's the Transport that's currently responsible for creating/destroying // channels, but the TransportController keeps track of how many external // objects (BaseChannels) reference each channel. struct RefCountedChannel { RefCountedChannel() : impl_(nullptr), ref_(0) {} explicit RefCountedChannel(TransportChannelImpl* impl) : impl_(impl), ref_(0) {} void AddRef() { ++ref_; } void DecRef() { ASSERT(ref_ > 0); --ref_; } int ref() const { return ref_; } TransportChannelImpl* get() const { return impl_; } TransportChannelImpl* operator->() const { return impl_; } private: TransportChannelImpl* impl_; int ref_; }; std::vector::iterator FindChannel_n( const std::string& transport_name, int component); Transport* GetOrCreateTransport_n(const std::string& transport_name); void DestroyTransport_n(const std::string& transport_name); void DestroyAllTransports_n(); bool SetSslMaxProtocolVersion_n(rtc::SSLProtocolVersion version); void SetIceConfig_n(const IceConfig& config); void SetIceRole_n(IceRole ice_role); bool GetSslRole_n(const std::string& transport_name, rtc::SSLRole* role); bool SetLocalCertificate_n( const rtc::scoped_refptr& certificate); bool GetLocalCertificate_n( const std::string& transport_name, rtc::scoped_refptr* certificate); std::unique_ptr GetRemoteSSLCertificate_n( const std::string& transport_name); bool SetLocalTransportDescription_n(const std::string& transport_name, const TransportDescription& tdesc, ContentAction action, std::string* err); bool SetRemoteTransportDescription_n(const std::string& transport_name, const TransportDescription& tdesc, ContentAction action, std::string* err); void MaybeStartGathering_n(); bool AddRemoteCandidates_n(const std::string& transport_name, const Candidates& candidates, std::string* err); bool RemoveRemoteCandidates_n(const Candidates& candidates, std::string* err); bool ReadyForRemoteCandidates_n(const std::string& transport_name); bool GetStats_n(const std::string& transport_name, TransportStats* stats); // Handlers for signals from Transport. void OnChannelWritableState_n(TransportChannel* channel); void OnChannelReceivingState_n(TransportChannel* channel); void OnChannelGatheringState_n(TransportChannelImpl* channel); void OnChannelCandidateGathered_n(TransportChannelImpl* channel, const Candidate& candidate); void OnChannelCandidatesRemoved(const Candidates& candidates); void OnChannelCandidatesRemoved_n(TransportChannelImpl* channel, const Candidates& candidates); void OnChannelRoleConflict_n(TransportChannelImpl* channel); void OnChannelStateChanged_n(TransportChannelImpl* channel); void UpdateAggregateStates_n(); rtc::Thread* const signaling_thread_ = nullptr; rtc::Thread* const network_thread_ = nullptr; typedef std::map TransportMap; TransportMap transports_; std::vector channels_; PortAllocator* const port_allocator_ = nullptr; rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12; // Aggregate state for TransportChannelImpls. IceConnectionState connection_state_ = kIceConnectionConnecting; bool receiving_ = false; IceGatheringState gathering_state_ = kIceGatheringNew; // TODO(deadbeef): Move the fields below down to the transports themselves IceConfig ice_config_; IceRole ice_role_ = ICEROLE_CONTROLLING; uint64_t ice_tiebreaker_ = rtc::CreateRandomId64(); rtc::scoped_refptr certificate_; rtc::AsyncInvoker invoker_; // True if QUIC is used instead of DTLS. bool quic_ = false; }; } // namespace cricket #endif // WEBRTC_P2P_BASE_TRANSPORTCONTROLLER_H_