Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2017 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 11 | #ifndef PC_JSEP_TRANSPORT_CONTROLLER_H_ |
| 12 | #define PC_JSEP_TRANSPORT_CONTROLLER_H_ |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 13 | |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 14 | #include <stdint.h> |
| 15 | |
| 16 | #include <functional> |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 17 | #include <map> |
| 18 | #include <memory> |
| 19 | #include <string> |
| 20 | #include <utility> |
| 21 | #include <vector> |
| 22 | |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 23 | #include "absl/types/optional.h" |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 24 | #include "api/async_dns_resolver.h" |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 25 | #include "api/candidate.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 26 | #include "api/crypto/crypto_options.h" |
Qingsi Wang | 25ec888 | 2019-11-15 20:33:05 | [diff] [blame] | 27 | #include "api/ice_transport_factory.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 28 | #include "api/ice_transport_interface.h" |
| 29 | #include "api/jsep.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 30 | #include "api/peer_connection_interface.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 31 | #include "api/rtc_error.h" |
Danil Chapovalov | 83bbe91 | 2019-08-07 10:24:53 | [diff] [blame] | 32 | #include "api/rtc_event_log/rtc_event_log.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 33 | #include "api/scoped_refptr.h" |
Harald Alvestrand | de22ab2 | 2021-06-17 10:45:33 | [diff] [blame] | 34 | #include "api/sequence_checker.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 35 | #include "api/transport/data_channel_transport_interface.h" |
| 36 | #include "api/transport/sctp_transport_factory_interface.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 37 | #include "media/sctp/sctp_transport_internal.h" |
| 38 | #include "p2p/base/dtls_transport.h" |
Qingsi Wang | 25ec888 | 2019-11-15 20:33:05 | [diff] [blame] | 39 | #include "p2p/base/dtls_transport_factory.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 40 | #include "p2p/base/dtls_transport_internal.h" |
| 41 | #include "p2p/base/ice_transport_internal.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 42 | #include "p2p/base/p2p_transport_channel.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 43 | #include "p2p/base/packet_transport_internal.h" |
| 44 | #include "p2p/base/port.h" |
| 45 | #include "p2p/base/port_allocator.h" |
| 46 | #include "p2p/base/transport_description.h" |
| 47 | #include "p2p/base/transport_info.h" |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 48 | #include "pc/channel.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 49 | #include "pc/dtls_srtp_transport.h" |
| 50 | #include "pc/dtls_transport.h" |
| 51 | #include "pc/jsep_transport.h" |
Harald Alvestrand | 9dea393 | 2021-06-10 06:03:06 | [diff] [blame] | 52 | #include "pc/jsep_transport_collection.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 53 | #include "pc/rtp_transport.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 54 | #include "pc/rtp_transport_internal.h" |
| 55 | #include "pc/sctp_transport.h" |
| 56 | #include "pc/session_description.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 57 | #include "pc/srtp_transport.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 58 | #include "pc/transport_stats.h" |
Mirko Bonadei | 3d25935 | 2020-10-23 10:04:40 | [diff] [blame] | 59 | #include "rtc_base/callback_list.h" |
Harald Alvestrand | de22ab2 | 2021-06-17 10:45:33 | [diff] [blame] | 60 | #include "rtc_base/checks.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 61 | #include "rtc_base/constructor_magic.h" |
| 62 | #include "rtc_base/copy_on_write_buffer.h" |
| 63 | #include "rtc_base/helpers.h" |
| 64 | #include "rtc_base/ref_counted_object.h" |
| 65 | #include "rtc_base/rtc_certificate.h" |
| 66 | #include "rtc_base/ssl_certificate.h" |
| 67 | #include "rtc_base/ssl_stream_adapter.h" |
Artem Titov | e41c433 | 2018-07-25 13:04:28 | [diff] [blame] | 68 | #include "rtc_base/third_party/sigslot/sigslot.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 69 | #include "rtc_base/thread.h" |
| 70 | #include "rtc_base/thread_annotations.h" |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 71 | |
| 72 | namespace rtc { |
| 73 | class Thread; |
| 74 | class PacketTransportInternal; |
| 75 | } // namespace rtc |
| 76 | |
| 77 | namespace webrtc { |
| 78 | |
Steve Anton | d25828a | 2018-08-31 20:06:05 | [diff] [blame] | 79 | class JsepTransportController : public sigslot::has_slots<> { |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 80 | public: |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 81 | // Used when the RtpTransport/DtlsTransport of the m= section is changed |
| 82 | // because the section is rejected or BUNDLE is enabled. |
| 83 | class Observer { |
| 84 | public: |
| 85 | virtual ~Observer() {} |
| 86 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 87 | // Returns true if media associated with `mid` was successfully set up to be |
| 88 | // demultiplexed on `rtp_transport`. Could return false if two bundled m= |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 89 | // sections use the same SSRC, for example. |
Bjorn A Mellem | b689af4 | 2019-08-21 17:44:59 | [diff] [blame] | 90 | // |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 91 | // If a data channel transport must be negotiated, `data_channel_transport` |
| 92 | // and `negotiation_state` indicate negotiation status. If |
| 93 | // `data_channel_transport` is null, the data channel transport should not |
Bjorn A Mellem | b689af4 | 2019-08-21 17:44:59 | [diff] [blame] | 94 | // be used. Otherwise, the value is a pointer to the transport to be used |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 95 | // for data channels on `mid`, if any. |
Bjorn A Mellem | b689af4 | 2019-08-21 17:44:59 | [diff] [blame] | 96 | // |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 97 | // The observer should not send data on `data_channel_transport` until |
| 98 | // `negotiation_state` is provisional or final. It should not delete |
| 99 | // `data_channel_transport` or any fallback transport until |
| 100 | // `negotiation_state` is final. |
Taylor Brandstetter | cbaa254 | 2018-04-16 23:42:14 | [diff] [blame] | 101 | virtual bool OnTransportChanged( |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 102 | const std::string& mid, |
Taylor Brandstetter | cbaa254 | 2018-04-16 23:42:14 | [diff] [blame] | 103 | RtpTransportInternal* rtp_transport, |
Harald Alvestrand | c85328f | 2019-02-28 06:51:00 | [diff] [blame] | 104 | rtc::scoped_refptr<DtlsTransport> dtls_transport, |
Bjorn A Mellem | bc3eebc | 2019-09-23 21:53:54 | [diff] [blame] | 105 | DataChannelTransportInterface* data_channel_transport) = 0; |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 106 | }; |
| 107 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 108 | struct Config { |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 109 | // If `redetermine_role_on_ice_restart` is true, ICE role is redetermined |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 110 | // upon setting a local transport description that indicates an ICE |
| 111 | // restart. |
| 112 | bool redetermine_role_on_ice_restart = true; |
| 113 | rtc::SSLProtocolVersion ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12; |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 114 | // `crypto_options` is used to determine if created DTLS transports |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 115 | // negotiate GCM crypto suites or not. |
Benjamin Wright | a54daf1 | 2018-10-11 22:33:17 | [diff] [blame] | 116 | webrtc::CryptoOptions crypto_options; |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 117 | PeerConnectionInterface::BundlePolicy bundle_policy = |
| 118 | PeerConnectionInterface::kBundlePolicyBalanced; |
| 119 | PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy = |
| 120 | PeerConnectionInterface::kRtcpMuxPolicyRequire; |
| 121 | bool disable_encryption = false; |
| 122 | bool enable_external_auth = false; |
| 123 | // Used to inject the ICE/DTLS transports created externally. |
Qingsi Wang | 25ec888 | 2019-11-15 20:33:05 | [diff] [blame] | 124 | webrtc::IceTransportFactory* ice_transport_factory = nullptr; |
| 125 | cricket::DtlsTransportFactory* dtls_transport_factory = nullptr; |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 126 | Observer* transport_observer = nullptr; |
Sebastian Jansson | 1b83a9e | 2019-09-18 16:22:12 | [diff] [blame] | 127 | // Must be provided and valid for the lifetime of the |
| 128 | // JsepTransportController instance. |
| 129 | std::function<void(const rtc::CopyOnWriteBuffer& packet, |
| 130 | int64_t packet_time_us)> |
| 131 | rtcp_handler; |
Harald Alvestrand | 133c052 | 2021-01-29 14:27:12 | [diff] [blame] | 132 | // Initial value for whether DtlsTransport reset causes a reset |
| 133 | // of SRTP parameters. |
Zhi Huang | b57e169 | 2018-06-12 18:41:11 | [diff] [blame] | 134 | bool active_reset_srtp_params = false; |
Qingsi Wang | 7685e86 | 2018-06-12 03:15:46 | [diff] [blame] | 135 | RtcEventLog* event_log = nullptr; |
Anton Sukhanov | 7940da0 | 2018-10-10 17:34:49 | [diff] [blame] | 136 | |
Bjorn A Mellem | bc3eebc | 2019-09-23 21:53:54 | [diff] [blame] | 137 | // Factory for SCTP transports. |
Per Kjellander | 2bca008 | 2020-08-28 07:15:15 | [diff] [blame] | 138 | SctpTransportFactoryInterface* sctp_factory = nullptr; |
Lahiru Ginnaliya Gamathige | 70f9e24 | 2021-01-28 07:32:46 | [diff] [blame] | 139 | std::function<void(const rtc::SSLHandshakeError)> on_dtls_handshake_error_; |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 140 | }; |
| 141 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 142 | // The ICE related events are fired on the `network_thread`. |
| 143 | // All the transport related methods are called on the `network_thread` |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 144 | // and destruction of the JsepTransportController must occur on the |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 145 | // `network_thread`. |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 146 | JsepTransportController( |
| 147 | rtc::Thread* network_thread, |
| 148 | cricket::PortAllocator* port_allocator, |
| 149 | AsyncDnsResolverFactoryInterface* async_dns_resolver_factory, |
| 150 | Config config); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 151 | virtual ~JsepTransportController(); |
| 152 | |
| 153 | // The main method to be called; applies a description at the transport |
| 154 | // level, creating/destroying transport objects as needed and updating their |
| 155 | // properties. This includes RTP, DTLS, and ICE (but not SCTP). At least not |
| 156 | // yet? May make sense to in the future. |
| 157 | RTCError SetLocalDescription(SdpType type, |
| 158 | const cricket::SessionDescription* description); |
| 159 | |
| 160 | RTCError SetRemoteDescription(SdpType type, |
| 161 | const cricket::SessionDescription* description); |
| 162 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 163 | // Get transports to be used for the provided `mid`. If bundling is enabled, |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 164 | // calling GetRtpTransport for multiple MIDs may yield the same object. |
| 165 | RtpTransportInternal* GetRtpTransport(const std::string& mid) const; |
Harald Alvestrand | ad88c88 | 2018-11-28 15:47:46 | [diff] [blame] | 166 | cricket::DtlsTransportInternal* GetDtlsTransport(const std::string& mid); |
| 167 | const cricket::DtlsTransportInternal* GetRtcpDtlsTransport( |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 168 | const std::string& mid) const; |
Harald Alvestrand | ad88c88 | 2018-11-28 15:47:46 | [diff] [blame] | 169 | // Gets the externally sharable version of the DtlsTransport. |
Harald Alvestrand | 4a7b3ac | 2019-01-17 09:39:40 | [diff] [blame] | 170 | rtc::scoped_refptr<webrtc::DtlsTransport> LookupDtlsTransportByMid( |
Harald Alvestrand | ad88c88 | 2018-11-28 15:47:46 | [diff] [blame] | 171 | const std::string& mid); |
Bjorn A Mellem | bc3eebc | 2019-09-23 21:53:54 | [diff] [blame] | 172 | rtc::scoped_refptr<SctpTransport> GetSctpTransport( |
| 173 | const std::string& mid) const; |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 174 | |
Bjorn A Mellem | b689af4 | 2019-08-21 17:44:59 | [diff] [blame] | 175 | DataChannelTransportInterface* GetDataChannelTransport( |
Anton Sukhanov | 316f3ac | 2019-05-23 22:50:38 | [diff] [blame] | 176 | const std::string& mid) const; |
| 177 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 178 | /********************* |
| 179 | * ICE-related methods |
| 180 | ********************/ |
| 181 | // This method is public to allow PeerConnection to update it from |
| 182 | // SetConfiguration. |
| 183 | void SetIceConfig(const cricket::IceConfig& config); |
| 184 | // Set the "needs-ice-restart" flag as described in JSEP. After the flag is |
| 185 | // set, offers should generate new ufrags/passwords until an ICE restart |
| 186 | // occurs. |
| 187 | void SetNeedsIceRestartFlag(); |
| 188 | // Returns true if the ICE restart flag above was set, and no ICE restart has |
| 189 | // occurred yet for this transport (by applying a local description with |
| 190 | // changed ufrag/password). If the transport has been deleted as a result of |
| 191 | // bundling, returns false. |
| 192 | bool NeedsIceRestart(const std::string& mid) const; |
| 193 | // Start gathering candidates for any new transports, or transports doing an |
| 194 | // ICE restart. |
| 195 | void MaybeStartGathering(); |
| 196 | RTCError AddRemoteCandidates( |
| 197 | const std::string& mid, |
| 198 | const std::vector<cricket::Candidate>& candidates); |
| 199 | RTCError RemoveRemoteCandidates( |
| 200 | const std::vector<cricket::Candidate>& candidates); |
| 201 | |
| 202 | /********************** |
| 203 | * DTLS-related methods |
| 204 | *********************/ |
| 205 | // Specifies the identity to use in this session. |
| 206 | // Can only be called once. |
| 207 | bool SetLocalCertificate( |
| 208 | const rtc::scoped_refptr<rtc::RTCCertificate>& certificate); |
| 209 | rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate( |
| 210 | const std::string& mid) const; |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 211 | // Caller owns returned certificate chain. This method mainly exists for |
| 212 | // stats reporting. |
| 213 | std::unique_ptr<rtc::SSLCertChain> GetRemoteSSLCertChain( |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 214 | const std::string& mid) const; |
| 215 | // Get negotiated role, if one has been negotiated. |
Danil Chapovalov | 66cadcc | 2018-06-19 14:47:43 | [diff] [blame] | 216 | absl::optional<rtc::SSLRole> GetDtlsRole(const std::string& mid) const; |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 217 | |
| 218 | // TODO(deadbeef): GetStats isn't const because all the way down to |
| 219 | // OpenSSLStreamAdapter, GetSslCipherSuite and GetDtlsSrtpCryptoSuite are not |
| 220 | // const. Fix this. |
| 221 | bool GetStats(const std::string& mid, cricket::TransportStats* stats); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 222 | |
Zhi Huang | e830e68 | 2018-03-30 17:48:35 | [diff] [blame] | 223 | bool initial_offerer() const { return initial_offerer_ && *initial_offerer_; } |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 224 | |
Zhi Huang | b57e169 | 2018-06-12 18:41:11 | [diff] [blame] | 225 | void SetActiveResetSrtpParams(bool active_reset_srtp_params); |
| 226 | |
Taylor Brandstetter | 8591eff | 2021-08-11 21:56:38 | [diff] [blame] | 227 | RTCError RollbackTransports(); |
Eldar Rello | 5ab79e6 | 2019-10-09 15:29:44 | [diff] [blame] | 228 | |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 229 | // F: void(const std::string&, const std::vector<cricket::Candidate>&) |
| 230 | template <typename F> |
| 231 | void SubscribeIceCandidateGathered(F&& callback) { |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 232 | RTC_DCHECK_RUN_ON(network_thread_); |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 233 | signal_ice_candidates_gathered_.AddReceiver(std::forward<F>(callback)); |
| 234 | } |
| 235 | |
| 236 | // F: void(cricket::IceConnectionState) |
| 237 | template <typename F> |
| 238 | void SubscribeIceConnectionState(F&& callback) { |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 239 | RTC_DCHECK_RUN_ON(network_thread_); |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 240 | signal_ice_connection_state_.AddReceiver(std::forward<F>(callback)); |
| 241 | } |
| 242 | |
| 243 | // F: void(PeerConnectionInterface::PeerConnectionState) |
| 244 | template <typename F> |
| 245 | void SubscribeConnectionState(F&& callback) { |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 246 | RTC_DCHECK_RUN_ON(network_thread_); |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 247 | signal_connection_state_.AddReceiver(std::forward<F>(callback)); |
| 248 | } |
| 249 | |
| 250 | // F: void(PeerConnectionInterface::IceConnectionState) |
| 251 | template <typename F> |
| 252 | void SubscribeStandardizedIceConnectionState(F&& callback) { |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 253 | RTC_DCHECK_RUN_ON(network_thread_); |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 254 | signal_standardized_ice_connection_state_.AddReceiver( |
| 255 | std::forward<F>(callback)); |
| 256 | } |
| 257 | |
| 258 | // F: void(cricket::IceGatheringState) |
| 259 | template <typename F> |
| 260 | void SubscribeIceGatheringState(F&& callback) { |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 261 | RTC_DCHECK_RUN_ON(network_thread_); |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 262 | signal_ice_gathering_state_.AddReceiver(std::forward<F>(callback)); |
| 263 | } |
| 264 | |
| 265 | // F: void(const cricket::IceCandidateErrorEvent&) |
| 266 | template <typename F> |
| 267 | void SubscribeIceCandidateError(F&& callback) { |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 268 | RTC_DCHECK_RUN_ON(network_thread_); |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 269 | signal_ice_candidate_error_.AddReceiver(std::forward<F>(callback)); |
| 270 | } |
| 271 | |
| 272 | // F: void(const std::vector<cricket::Candidate>&) |
| 273 | template <typename F> |
| 274 | void SubscribeIceCandidatesRemoved(F&& callback) { |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 275 | RTC_DCHECK_RUN_ON(network_thread_); |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 276 | signal_ice_candidates_removed_.AddReceiver(std::forward<F>(callback)); |
| 277 | } |
| 278 | |
| 279 | // F: void(const cricket::CandidatePairChangeEvent&) |
| 280 | template <typename F> |
| 281 | void SubscribeIceCandidatePairChanged(F&& callback) { |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 282 | RTC_DCHECK_RUN_ON(network_thread_); |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 283 | signal_ice_candidate_pair_changed_.AddReceiver(std::forward<F>(callback)); |
| 284 | } |
| 285 | |
| 286 | private: |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 287 | // All of these callbacks are fired on the network thread. |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 288 | |
| 289 | // If any transport failed => failed, |
| 290 | // Else if all completed => completed, |
| 291 | // Else if all connected => connected, |
| 292 | // Else => connecting |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 293 | CallbackList<cricket::IceConnectionState> signal_ice_connection_state_ |
| 294 | RTC_GUARDED_BY(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 295 | |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 296 | CallbackList<PeerConnectionInterface::PeerConnectionState> |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 297 | signal_connection_state_ RTC_GUARDED_BY(network_thread_); |
Lahiru Ginnaliya Gamathige | e99c68d | 2020-09-30 21:33:45 | [diff] [blame] | 298 | |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 299 | CallbackList<PeerConnectionInterface::IceConnectionState> |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 300 | signal_standardized_ice_connection_state_ RTC_GUARDED_BY(network_thread_); |
Jonas Olsson | 635474e | 2018-10-18 13:58:17 | [diff] [blame] | 301 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 302 | // If all transports done gathering => complete, |
| 303 | // Else if any are gathering => gathering, |
| 304 | // Else => new |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 305 | CallbackList<cricket::IceGatheringState> signal_ice_gathering_state_ |
| 306 | RTC_GUARDED_BY(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 307 | |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 308 | // [mid, candidates] |
| 309 | CallbackList<const std::string&, const std::vector<cricket::Candidate>&> |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 310 | signal_ice_candidates_gathered_ RTC_GUARDED_BY(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 311 | |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 312 | CallbackList<const cricket::IceCandidateErrorEvent&> |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 313 | signal_ice_candidate_error_ RTC_GUARDED_BY(network_thread_); |
Eldar Rello | da13ea2 | 2019-06-01 09:23:43 | [diff] [blame] | 314 | |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 315 | CallbackList<const std::vector<cricket::Candidate>&> |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 316 | signal_ice_candidates_removed_ RTC_GUARDED_BY(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 317 | |
Lahiru Ginnaliya Gamathige | 5eb527c | 2021-01-19 07:32:22 | [diff] [blame] | 318 | CallbackList<const cricket::CandidatePairChangeEvent&> |
Tommi | c3257d0 | 2021-02-10 17:40:08 | [diff] [blame] | 319 | signal_ice_candidate_pair_changed_ RTC_GUARDED_BY(network_thread_); |
Alex Drake | 00c7ecf | 2019-08-06 17:54:47 | [diff] [blame] | 320 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 321 | RTCError ApplyDescription_n(bool local, |
| 322 | SdpType type, |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 323 | const cricket::SessionDescription* description) |
| 324 | RTC_RUN_ON(network_thread_); |
Henrik Boström | f8187e0 | 2021-04-26 19:04:26 | [diff] [blame] | 325 | RTCError ValidateAndMaybeUpdateBundleGroups( |
Zhi Huang | d2248f8 | 2018-04-10 21:41:03 | [diff] [blame] | 326 | bool local, |
| 327 | SdpType type, |
| 328 | const cricket::SessionDescription* description); |
Zhi Huang | e830e68 | 2018-03-30 17:48:35 | [diff] [blame] | 329 | RTCError ValidateContent(const cricket::ContentInfo& content_info); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 330 | |
Harald Alvestrand | 11b92cf | 2021-06-17 14:03:09 | [diff] [blame] | 331 | void HandleRejectedContent(const cricket::ContentInfo& content_info) |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 332 | RTC_RUN_ON(network_thread_); |
Henrik Boström | f8187e0 | 2021-04-26 19:04:26 | [diff] [blame] | 333 | bool HandleBundledContent(const cricket::ContentInfo& content_info, |
| 334 | const cricket::ContentGroup& bundle_group) |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 335 | RTC_RUN_ON(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 336 | |
| 337 | cricket::JsepTransportDescription CreateJsepTransportDescription( |
Harald Alvestrand | 1716d39 | 2019-06-03 18:35:45 | [diff] [blame] | 338 | const cricket::ContentInfo& content_info, |
| 339 | const cricket::TransportInfo& transport_info, |
Zhi Huang | e830e68 | 2018-03-30 17:48:35 | [diff] [blame] | 340 | const std::vector<int>& encrypted_extension_ids, |
Niels Möller | dc80aaf | 2020-06-18 08:10:17 | [diff] [blame] | 341 | int rtp_abs_sendtime_extn_id); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 342 | |
Henrik Boström | f8187e0 | 2021-04-26 19:04:26 | [diff] [blame] | 343 | std::map<const cricket::ContentGroup*, std::vector<int>> |
| 344 | MergeEncryptedHeaderExtensionIdsForBundles( |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 345 | const cricket::SessionDescription* description); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 346 | std::vector<int> GetEncryptedHeaderExtensionIds( |
| 347 | const cricket::ContentInfo& content_info); |
| 348 | |
Zhi Huang | e830e68 | 2018-03-30 17:48:35 | [diff] [blame] | 349 | int GetRtpAbsSendTimeHeaderExtensionId( |
| 350 | const cricket::ContentInfo& content_info); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 351 | |
Zhi Huang | e830e68 | 2018-03-30 17:48:35 | [diff] [blame] | 352 | // This method takes the BUNDLE group into account. If the JsepTransport is |
| 353 | // destroyed because of BUNDLE, it would return the transport which other |
| 354 | // transports are bundled on (In current implementation, it is the first |
| 355 | // content in the BUNDLE group). |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 356 | const cricket::JsepTransport* GetJsepTransportForMid( |
Tomas Gunnarsson | 92eebef | 2021-02-10 12:05:44 | [diff] [blame] | 357 | const std::string& mid) const RTC_RUN_ON(network_thread_); |
| 358 | cricket::JsepTransport* GetJsepTransportForMid(const std::string& mid) |
| 359 | RTC_RUN_ON(network_thread_); |
Zhi Huang | e830e68 | 2018-03-30 17:48:35 | [diff] [blame] | 360 | |
| 361 | // Get the JsepTransport without considering the BUNDLE group. Return nullptr |
| 362 | // if the JsepTransport is destroyed. |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 363 | const cricket::JsepTransport* GetJsepTransportByName( |
Tomas Gunnarsson | 20f7456 | 2021-02-04 09:22:50 | [diff] [blame] | 364 | const std::string& transport_name) const RTC_RUN_ON(network_thread_); |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 365 | cricket::JsepTransport* GetJsepTransportByName( |
Tomas Gunnarsson | 20f7456 | 2021-02-04 09:22:50 | [diff] [blame] | 366 | const std::string& transport_name) RTC_RUN_ON(network_thread_); |
Zhi Huang | e830e68 | 2018-03-30 17:48:35 | [diff] [blame] | 367 | |
Anton Sukhanov | 7940da0 | 2018-10-10 17:34:49 | [diff] [blame] | 368 | // Creates jsep transport. Noop if transport is already created. |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 369 | // Transport is created either during SetLocalDescription (`local` == true) or |
| 370 | // during SetRemoteDescription (`local` == false). Passing `local` helps to |
Anton Sukhanov | 7940da0 | 2018-10-10 17:34:49 | [diff] [blame] | 371 | // differentiate initiator (caller) from answerer (callee). |
Piotr (Peter) Slatala | 105ded3 | 2019-02-27 22:26:15 | [diff] [blame] | 372 | RTCError MaybeCreateJsepTransport( |
| 373 | bool local, |
| 374 | const cricket::ContentInfo& content_info, |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 375 | const cricket::SessionDescription& description) |
| 376 | RTC_RUN_ON(network_thread_); |
Piotr (Peter) Slatala | 47dfdca | 2018-11-16 22:13:58 | [diff] [blame] | 377 | |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 378 | void DestroyAllJsepTransports_n() RTC_RUN_ON(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 379 | |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 380 | void SetIceRole_n(cricket::IceRole ice_role) RTC_RUN_ON(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 381 | |
| 382 | cricket::IceRole DetermineIceRole( |
Zhi Huang | 365381f | 2018-04-13 23:44:34 | [diff] [blame] | 383 | cricket::JsepTransport* jsep_transport, |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 384 | const cricket::TransportInfo& transport_info, |
| 385 | SdpType type, |
| 386 | bool local); |
| 387 | |
| 388 | std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport( |
Anton Sukhanov | ac6c096 | 2019-07-10 22:44:56 | [diff] [blame] | 389 | const cricket::ContentInfo& content_info, |
Niels Möller | 2a70703 | 2020-06-16 14:39:13 | [diff] [blame] | 390 | cricket::IceTransportInternal* ice); |
Qingsi Wang | 25ec888 | 2019-11-15 20:33:05 | [diff] [blame] | 391 | rtc::scoped_refptr<webrtc::IceTransportInterface> CreateIceTransport( |
| 392 | const std::string& transport_name, |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 393 | bool rtcp); |
| 394 | |
| 395 | std::unique_ptr<webrtc::RtpTransport> CreateUnencryptedRtpTransport( |
| 396 | const std::string& transport_name, |
| 397 | rtc::PacketTransportInternal* rtp_packet_transport, |
| 398 | rtc::PacketTransportInternal* rtcp_packet_transport); |
| 399 | std::unique_ptr<webrtc::SrtpTransport> CreateSdesTransport( |
| 400 | const std::string& transport_name, |
Zhi Huang | e830e68 | 2018-03-30 17:48:35 | [diff] [blame] | 401 | cricket::DtlsTransportInternal* rtp_dtls_transport, |
| 402 | cricket::DtlsTransportInternal* rtcp_dtls_transport); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 403 | std::unique_ptr<webrtc::DtlsSrtpTransport> CreateDtlsSrtpTransport( |
| 404 | const std::string& transport_name, |
| 405 | cricket::DtlsTransportInternal* rtp_dtls_transport, |
| 406 | cricket::DtlsTransportInternal* rtcp_dtls_transport); |
| 407 | |
| 408 | // Collect all the DtlsTransports, including RTP and RTCP, from the |
Taylor Brandstetter | 8591eff | 2021-08-11 21:56:38 | [diff] [blame] | 409 | // JsepTransports, including those not mapped to a MID because they are being |
| 410 | // kept alive in case of rollback. |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 411 | std::vector<cricket::DtlsTransportInternal*> GetDtlsTransports(); |
Taylor Brandstetter | 8591eff | 2021-08-11 21:56:38 | [diff] [blame] | 412 | // Same as the above, but doesn't include rollback transports. |
| 413 | // JsepTransportController can iterate all the DtlsTransports and update the |
| 414 | // aggregate states. |
| 415 | std::vector<cricket::DtlsTransportInternal*> GetActiveDtlsTransports(); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 416 | |
| 417 | // Handlers for signals from Transport. |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 418 | void OnTransportWritableState_n(rtc::PacketTransportInternal* transport) |
| 419 | RTC_RUN_ON(network_thread_); |
| 420 | void OnTransportReceivingState_n(rtc::PacketTransportInternal* transport) |
| 421 | RTC_RUN_ON(network_thread_); |
| 422 | void OnTransportGatheringState_n(cricket::IceTransportInternal* transport) |
| 423 | RTC_RUN_ON(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 424 | void OnTransportCandidateGathered_n(cricket::IceTransportInternal* transport, |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 425 | const cricket::Candidate& candidate) |
| 426 | RTC_RUN_ON(network_thread_); |
| 427 | void OnTransportCandidateError_n(cricket::IceTransportInternal* transport, |
| 428 | const cricket::IceCandidateErrorEvent& event) |
| 429 | RTC_RUN_ON(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 430 | void OnTransportCandidatesRemoved_n(cricket::IceTransportInternal* transport, |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 431 | const cricket::Candidates& candidates) |
| 432 | RTC_RUN_ON(network_thread_); |
| 433 | void OnTransportRoleConflict_n(cricket::IceTransportInternal* transport) |
| 434 | RTC_RUN_ON(network_thread_); |
| 435 | void OnTransportStateChanged_n(cricket::IceTransportInternal* transport) |
| 436 | RTC_RUN_ON(network_thread_); |
Alex Drake | 00c7ecf | 2019-08-06 17:54:47 | [diff] [blame] | 437 | void OnTransportCandidatePairChanged_n( |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 438 | const cricket::CandidatePairChangeEvent& event) |
| 439 | RTC_RUN_ON(network_thread_); |
| 440 | void UpdateAggregateStates_n() RTC_RUN_ON(network_thread_); |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 441 | |
Sebastian Jansson | 1b83a9e | 2019-09-18 16:22:12 | [diff] [blame] | 442 | void OnRtcpPacketReceived_n(rtc::CopyOnWriteBuffer* packet, |
Niels Möller | 5cf0ef0 | 2021-01-18 13:00:36 | [diff] [blame] | 443 | int64_t packet_time_us) |
| 444 | RTC_RUN_ON(network_thread_); |
Sebastian Jansson | 1b83a9e | 2019-09-18 16:22:12 | [diff] [blame] | 445 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 446 | void OnDtlsHandshakeError(rtc::SSLHandshakeError error); |
| 447 | |
Harald Alvestrand | 9dea393 | 2021-06-10 06:03:06 | [diff] [blame] | 448 | bool OnTransportChanged(const std::string& mid, |
| 449 | cricket::JsepTransport* transport); |
| 450 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 451 | rtc::Thread* const network_thread_ = nullptr; |
| 452 | cricket::PortAllocator* const port_allocator_ = nullptr; |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 453 | AsyncDnsResolverFactoryInterface* const async_dns_resolver_factory_ = nullptr; |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 454 | |
Harald Alvestrand | 9dea393 | 2021-06-10 06:03:06 | [diff] [blame] | 455 | JsepTransportCollection transports_ RTC_GUARDED_BY(network_thread_); |
Jonas Olsson | 635474e | 2018-10-18 13:58:17 | [diff] [blame] | 456 | // Aggregate states for Transports. |
Alex Loiko | 9289eda | 2018-11-23 16:18:59 | [diff] [blame] | 457 | // standardized_ice_connection_state_ is intended to replace |
| 458 | // ice_connection_state, see bugs.webrtc.org/9308 |
| 459 | cricket::IceConnectionState ice_connection_state_ = |
| 460 | cricket::kIceConnectionConnecting; |
| 461 | PeerConnectionInterface::IceConnectionState |
| 462 | standardized_ice_connection_state_ = |
| 463 | PeerConnectionInterface::kIceConnectionNew; |
Jonas Olsson | 635474e | 2018-10-18 13:58:17 | [diff] [blame] | 464 | PeerConnectionInterface::PeerConnectionState combined_connection_state_ = |
| 465 | PeerConnectionInterface::PeerConnectionState::kNew; |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 466 | cricket::IceGatheringState ice_gathering_state_ = cricket::kIceGatheringNew; |
| 467 | |
Harald Alvestrand | 133c052 | 2021-01-29 14:27:12 | [diff] [blame] | 468 | const Config config_; |
| 469 | bool active_reset_srtp_params_ RTC_GUARDED_BY(network_thread_); |
Piotr (Peter) Slatala | b1ae10b | 2019-03-01 19:14:05 | [diff] [blame] | 470 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 471 | const cricket::SessionDescription* local_desc_ = nullptr; |
| 472 | const cricket::SessionDescription* remote_desc_ = nullptr; |
Danil Chapovalov | 66cadcc | 2018-06-19 14:47:43 | [diff] [blame] | 473 | absl::optional<bool> initial_offerer_; |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 474 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 475 | cricket::IceConfig ice_config_; |
| 476 | cricket::IceRole ice_role_ = cricket::ICEROLE_CONTROLLING; |
| 477 | uint64_t ice_tiebreaker_ = rtc::CreateRandomId64(); |
| 478 | rtc::scoped_refptr<rtc::RTCCertificate> certificate_; |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 479 | |
Harald Alvestrand | 9f9bf38 | 2021-06-08 04:12:37 | [diff] [blame] | 480 | BundleManager bundles_; |
| 481 | |
Zhi Huang | e818b6e | 2018-02-22 23:26:27 | [diff] [blame] | 482 | RTC_DISALLOW_COPY_AND_ASSIGN(JsepTransportController); |
| 483 | }; |
| 484 | |
| 485 | } // namespace webrtc |
| 486 | |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 487 | #endif // PC_JSEP_TRANSPORT_CONTROLLER_H_ |