Thanks to visit codestin.com
Credit goes to webrtc.googlesource.com

Google Git
Sign in
webrtc / src / refs/heads/lkgr / . / pc / jsep_transport_controller.h
blob: 72fc7aa59abb567320fdcfc37ae52062f655c864 [file] [log] [blame]
Zhi Huange818b6e2018-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 Anton10542f22019-01-11 17:11:00[diff] [blame]11#ifndef PC_JSEP_TRANSPORT_CONTROLLER_H_
12#define PC_JSEP_TRANSPORT_CONTROLLER_H_
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]13
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]14#include <stdint.h>
15
16#include <functional>
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]17#include <map>
18#include <memory>
Florent Castelli8037fc62024-08-29 13:00:40[diff] [blame]19#include <optional>
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]20#include <string>
21#include <utility>
22#include <vector>
23
Per Ke1e94ad2023-03-30 14:53:59[diff] [blame]24#include "absl/functional/any_invocable.h"
Harald Alvestrandc17ca012024-09-03 11:20:36[diff] [blame]25#include "absl/strings/string_view.h"
Harald Alvestrand0ccfbd22021-04-08 07:25:04[diff] [blame]26#include "api/async_dns_resolver.h"
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]27#include "api/candidate.h"
Steve Anton10542f22019-01-11 17:11:00[diff] [blame]28#include "api/crypto/crypto_options.h"
Victor Boiviecd54fd82024-02-28 11:16:15[diff] [blame]29#include "api/environment/environment.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]30#include "api/ice_transport_interface.h"
31#include "api/jsep.h"
Giovanni Ortuño Urquidie2cfc362025-06-13 21:23:36[diff] [blame]32#include "api/local_network_access_permission.h"
Steve Anton10542f22019-01-11 17:11:00[diff] [blame]33#include "api/peer_connection_interface.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]34#include "api/rtc_error.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]35#include "api/scoped_refptr.h"
Harald Alvestrandde22ab22021-06-17 10:45:33[diff] [blame]36#include "api/sequence_checker.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]37#include "api/transport/data_channel_transport_interface.h"
Per K12103ce2025-11-12 16:04:49[diff] [blame]38#include "api/transport/ecn_marking.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]39#include "api/transport/sctp_transport_factory_interface.h"
Per K12103ce2025-11-12 16:04:49[diff] [blame]40#include "api/units/timestamp.h"
Harald Alvestrandc17ca012024-09-03 11:20:36[diff] [blame]41#include "call/payload_type.h"
42#include "call/payload_type_picker.h"
43#include "media/base/codec.h"
44#include "modules/rtp_rtcp/source/rtp_packet_received.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]45#include "p2p/base/ice_transport_internal.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]46#include "p2p/base/packet_transport_internal.h"
47#include "p2p/base/port.h"
48#include "p2p/base/port_allocator.h"
49#include "p2p/base/transport_description.h"
50#include "p2p/base/transport_info.h"
Philipp Hancke740d7262024-12-09 05:26:34[diff] [blame]51#include "p2p/dtls/dtls_transport_factory.h"
52#include "p2p/dtls/dtls_transport_internal.h"
Steve Anton10542f22019-01-11 17:11:00[diff] [blame]53#include "pc/dtls_srtp_transport.h"
54#include "pc/dtls_transport.h"
55#include "pc/jsep_transport.h"
Harald Alvestrand9dea3932021-06-10 06:03:06[diff] [blame]56#include "pc/jsep_transport_collection.h"
Steve Anton10542f22019-01-11 17:11:00[diff] [blame]57#include "pc/rtp_transport.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]58#include "pc/rtp_transport_internal.h"
59#include "pc/sctp_transport.h"
60#include "pc/session_description.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]61#include "pc/transport_stats.h"
Mirko Bonadei3d259352020-10-23 10:04:40[diff] [blame]62#include "rtc_base/callback_list.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]63#include "rtc_base/copy_on_write_buffer.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]64#include "rtc_base/rtc_certificate.h"
65#include "rtc_base/ssl_certificate.h"
66#include "rtc_base/ssl_stream_adapter.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08[diff] [blame]67#include "rtc_base/thread.h"
68#include "rtc_base/thread_annotations.h"
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]69
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]70namespace webrtc {
71
Harald Alvestrand660b3fa92025-10-16 10:12:25[diff] [blame]72class JsepTransportController : public PayloadTypeSuggester {
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]73 public:
Zhi Huang365381f2018-04-13 23:44:34[diff] [blame]74 // Used when the RtpTransport/DtlsTransport of the m= section is changed
75 // because the section is rejected or BUNDLE is enabled.
76 class Observer {
77 public:
78 virtual ~Observer() {}
79
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]80 // Returns true if media associated with `mid` was successfully set up to be
81 // demultiplexed on `rtp_transport`. Could return false if two bundled m=
Zhi Huang365381f2018-04-13 23:44:34[diff] [blame]82 // sections use the same SSRC, for example.
Bjorn A Mellemb689af42019-08-21 17:44:59[diff] [blame]83 //
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]84 // If a data channel transport must be negotiated, `data_channel_transport`
85 // and `negotiation_state` indicate negotiation status. If
86 // `data_channel_transport` is null, the data channel transport should not
Bjorn A Mellemb689af42019-08-21 17:44:59[diff] [blame]87 // be used. Otherwise, the value is a pointer to the transport to be used
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]88 // for data channels on `mid`, if any.
Bjorn A Mellemb689af42019-08-21 17:44:59[diff] [blame]89 //
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]90 // The observer should not send data on `data_channel_transport` until
91 // `negotiation_state` is provisional or final. It should not delete
92 // `data_channel_transport` or any fallback transport until
93 // `negotiation_state` is final.
Taylor Brandstettercbaa2542018-04-16 23:42:14[diff] [blame]94 virtual bool OnTransportChanged(
Zhi Huang365381f2018-04-13 23:44:34[diff] [blame]95 const std::string& mid,
Taylor Brandstettercbaa2542018-04-16 23:42:14[diff] [blame]96 RtpTransportInternal* rtp_transport,
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]97 scoped_refptr<DtlsTransport> dtls_transport,
Bjorn A Mellembc3eebc2019-09-23 21:53:54[diff] [blame]98 DataChannelTransportInterface* data_channel_transport) = 0;
Zhi Huang365381f2018-04-13 23:44:34[diff] [blame]99 };
100
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]101 struct Config {
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]102 // If `redetermine_role_on_ice_restart` is true, ICE role is redetermined
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]103 // upon setting a local transport description that indicates an ICE
104 // restart.
105 bool redetermine_role_on_ice_restart = true;
Evan Shrubsoleeb835d02025-03-12 09:41:06[diff] [blame]106 SSLProtocolVersion ssl_max_version = SSL_PROTOCOL_DTLS_12;
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]107 // `crypto_options` is used to determine if created DTLS transports
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]108 // negotiate GCM crypto suites or not.
Harald Alvestranda6544372023-11-13 09:33:56[diff] [blame]109 CryptoOptions crypto_options;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]110 PeerConnectionInterface::BundlePolicy bundle_policy =
111 PeerConnectionInterface::kBundlePolicyBalanced;
112 PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy =
113 PeerConnectionInterface::kRtcpMuxPolicyRequire;
114 bool disable_encryption = false;
115 bool enable_external_auth = false;
116 // Used to inject the ICE/DTLS transports created externally.
Harald Alvestranda6544372023-11-13 09:33:56[diff] [blame]117 IceTransportFactory* ice_transport_factory = nullptr;
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]118 DtlsTransportFactory* dtls_transport_factory = nullptr;
Zhi Huang365381f2018-04-13 23:44:34[diff] [blame]119 Observer* transport_observer = nullptr;
Sebastian Jansson1b83a9e2019-09-18 16:22:12[diff] [blame]120 // Must be provided and valid for the lifetime of the
121 // JsepTransportController instance.
Per K12103ce2025-11-12 16:04:49[diff] [blame]122 absl::AnyInvocable<void(const CopyOnWriteBuffer& packet,
Per Ke1e94ad2023-03-30 14:53:59[diff] [blame]123 int64_t packet_time_us) const>
Sebastian Jansson1b83a9e2019-09-18 16:22:12[diff] [blame]124 rtcp_handler;
Per Ke1e94ad2023-03-30 14:53:59[diff] [blame]125 absl::AnyInvocable<void(const RtpPacketReceived& parsed_packet) const>
126 un_demuxable_packet_handler;
Harald Alvestrand133c0522021-01-29 14:27:12[diff] [blame]127 // Initial value for whether DtlsTransport reset causes a reset
128 // of SRTP parameters.
Zhi Huangb57e1692018-06-12 18:41:11[diff] [blame]129 bool active_reset_srtp_params = false;
Anton Sukhanov7940da02018-10-10 17:34:49[diff] [blame]130
Bjorn A Mellembc3eebc2019-09-23 21:53:54[diff] [blame]131 // Factory for SCTP transports.
Per Kjellander2bca0082020-08-28 07:15:15[diff] [blame]132 SctpTransportFactoryInterface* sctp_factory = nullptr;
Per K12103ce2025-11-12 16:04:49[diff] [blame]133 std::function<void(SSLHandshakeError)> on_dtls_handshake_error_;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]134 };
135
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]136 // The ICE related events are fired on the `network_thread`.
137 // All the transport related methods are called on the `network_thread`
Tommic3257d02021-02-10 17:40:08[diff] [blame]138 // and destruction of the JsepTransportController must occur on the
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]139 // `network_thread`.
Harald Alvestrand0ccfbd22021-04-08 07:25:04[diff] [blame]140 JsepTransportController(
Victor Boiviecd54fd82024-02-28 11:16:15[diff] [blame]141 const Environment& env,
Evan Shrubsole6a9a1ae2025-03-21 12:54:15[diff] [blame]142 Thread* network_thread,
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]143 PortAllocator* port_allocator,
Harald Alvestrand0ccfbd22021-04-08 07:25:04[diff] [blame]144 AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
Giovanni Ortuño Urquidie2cfc362025-06-13 21:23:36[diff] [blame]145 LocalNetworkAccessPermissionFactoryInterface* lna_permission_factory,
Harald Alvestrand53086522024-08-25 16:43:08[diff] [blame]146 PayloadTypePicker& payload_type_picker,
Harald Alvestrand0ccfbd22021-04-08 07:25:04[diff] [blame]147 Config config);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]148 virtual ~JsepTransportController();
149
Byoungchan Leec065e732022-01-18 00:35:48[diff] [blame]150 JsepTransportController(const JsepTransportController&) = delete;
151 JsepTransportController& operator=(const JsepTransportController&) = delete;
152
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]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.
Tommic5605202024-01-11 21:15:27[diff] [blame]157 //
158 // `local_desc` must always be valid. If a remote description has previously
159 // been set via a call to `SetRemoteDescription()` then `remote_desc` should
160 // point to that description object in order to keep the current local and
161 // remote session descriptions in sync.
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]162 RTCError SetLocalDescription(SdpType type,
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]163 const SessionDescription* local_desc,
164 const SessionDescription* remote_desc);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]165
Tommic5605202024-01-11 21:15:27[diff] [blame]166 // Call to apply a remote description (See `SetLocalDescription()` for local).
167 //
168 // `remote_desc` must always be valid. If a local description has previously
169 // been set via a call to `SetLocalDescription()` then `local_desc` should
170 // point to that description object in order to keep the current local and
171 // remote session descriptions in sync.
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]172 RTCError SetRemoteDescription(SdpType type,
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]173 const SessionDescription* local_desc,
174 const SessionDescription* remote_desc);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]175
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]176 // Get transports to be used for the provided `mid`. If bundling is enabled,
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]177 // calling GetRtpTransport for multiple MIDs may yield the same object.
Harald Alvestrand8f429922022-05-04 10:32:30[diff] [blame]178 RtpTransportInternal* GetRtpTransport(absl::string_view mid) const;
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]179 DtlsTransportInternal* GetDtlsTransport(const std::string& mid);
180 const DtlsTransportInternal* GetRtcpDtlsTransport(
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]181 const std::string& mid) const;
Harald Alvestrandad88c882018-11-28 15:47:46[diff] [blame]182 // Gets the externally sharable version of the DtlsTransport.
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]183 scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(const std::string& mid);
184 scoped_refptr<SctpTransport> GetSctpTransport(const std::string& mid) const;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]185
Bjorn A Mellemb689af42019-08-21 17:44:59[diff] [blame]186 DataChannelTransportInterface* GetDataChannelTransport(
Anton Sukhanov316f3ac2019-05-23 22:50:38[diff] [blame]187 const std::string& mid) const;
188
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]189 /*********************
190 * ICE-related methods
191 ********************/
192 // This method is public to allow PeerConnection to update it from
193 // SetConfiguration.
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]194 void SetIceConfig(const IceConfig& config);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]195 // Set the "needs-ice-restart" flag as described in JSEP. After the flag is
196 // set, offers should generate new ufrags/passwords until an ICE restart
197 // occurs.
198 void SetNeedsIceRestartFlag();
199 // Returns true if the ICE restart flag above was set, and no ICE restart has
200 // occurred yet for this transport (by applying a local description with
201 // changed ufrag/password). If the transport has been deleted as a result of
202 // bundling, returns false.
203 bool NeedsIceRestart(const std::string& mid) const;
204 // Start gathering candidates for any new transports, or transports doing an
205 // ICE restart.
206 void MaybeStartGathering();
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]207 RTCError AddRemoteCandidates(const std::string& mid,
208 const std::vector<Candidate>& candidates);
Tommi4fad2612025-07-06 10:01:57[diff] [blame]209 bool RemoveRemoteCandidate(const IceCandidate* candidate);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]210
211 /**********************
212 * DTLS-related methods
213 *********************/
214 // Specifies the identity to use in this session.
215 // Can only be called once.
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]216 bool SetLocalCertificate(const scoped_refptr<RTCCertificate>& certificate);
217 scoped_refptr<RTCCertificate> GetLocalCertificate(
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]218 const std::string& mid) const;
Taylor Brandstetterc3928662018-02-23 21:04:51[diff] [blame]219 // Caller owns returned certificate chain. This method mainly exists for
220 // stats reporting.
Evan Shrubsoledaf96cf2025-03-31 12:34:02[diff] [blame]221 std::unique_ptr<SSLCertChain> GetRemoteSSLCertChain(
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]222 const std::string& mid) const;
223 // Get negotiated role, if one has been negotiated.
Evan Shrubsoleeb835d02025-03-12 09:41:06[diff] [blame]224 std::optional<SSLRole> GetDtlsRole(const std::string& mid) const;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]225
Harald Alvestrand84ce5452024-08-26 16:02:11[diff] [blame]226 // Suggest a payload type for a given codec on a given media section.
227 // Media section is indicated by MID.
228 // The function will either return a PT already in use on the connection
229 // or a newly suggested one.
230 RTCErrorOr<PayloadType> SuggestPayloadType(const std::string& mid,
Evan Shrubsole0b212e32025-04-07 13:43:01[diff] [blame]231 Codec codec) override;
Harald Alvestranddc56a362024-09-07 20:38:29[diff] [blame]232 RTCError AddLocalMapping(const std::string& mid,
233 PayloadType payload_type,
Evan Shrubsole0b212e32025-04-07 13:43:01[diff] [blame]234 const Codec& codec) override;
Harald Alvestrand81fb1de2025-03-31 09:38:11[diff] [blame]235 const PayloadTypePicker& PayloadTypePickerForTesting() const {
236 return payload_type_picker_;
237 }
Harald Alvestrand84ce5452024-08-26 16:02:11[diff] [blame]238
Evan Shrubsole3c825f12025-04-04 14:07:27[diff] [blame]239 bool GetStats(const std::string& mid, TransportStats* stats) const;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]240
Zhi Huange830e682018-03-30 17:48:35[diff] [blame]241 bool initial_offerer() const { return initial_offerer_ && *initial_offerer_; }
Zhi Huang365381f2018-04-13 23:44:34[diff] [blame]242
Zhi Huangb57e1692018-06-12 18:41:11[diff] [blame]243 void SetActiveResetSrtpParams(bool active_reset_srtp_params);
244
Taylor Brandstetter8591eff2021-08-11 21:56:38[diff] [blame]245 RTCError RollbackTransports();
Eldar Rello5ab79e62019-10-09 15:29:44[diff] [blame]246
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]247 // F: void(const std::string&, const std::vector<webrtc::Candidate>&)
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]248 template <typename F>
249 void SubscribeIceCandidateGathered(F&& callback) {
Tommic3257d02021-02-10 17:40:08[diff] [blame]250 RTC_DCHECK_RUN_ON(network_thread_);
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]251 signal_ice_candidates_gathered_.AddReceiver(std::forward<F>(callback));
252 }
253
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]254 // F: void(webrtc::IceConnectionState)
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]255 template <typename F>
256 void SubscribeIceConnectionState(F&& callback) {
Tommic3257d02021-02-10 17:40:08[diff] [blame]257 RTC_DCHECK_RUN_ON(network_thread_);
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]258 signal_ice_connection_state_.AddReceiver(std::forward<F>(callback));
259 }
260
261 // F: void(PeerConnectionInterface::PeerConnectionState)
262 template <typename F>
263 void SubscribeConnectionState(F&& callback) {
Tommic3257d02021-02-10 17:40:08[diff] [blame]264 RTC_DCHECK_RUN_ON(network_thread_);
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]265 signal_connection_state_.AddReceiver(std::forward<F>(callback));
266 }
267
268 // F: void(PeerConnectionInterface::IceConnectionState)
269 template <typename F>
270 void SubscribeStandardizedIceConnectionState(F&& callback) {
Tommic3257d02021-02-10 17:40:08[diff] [blame]271 RTC_DCHECK_RUN_ON(network_thread_);
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]272 signal_standardized_ice_connection_state_.AddReceiver(
273 std::forward<F>(callback));
274 }
275
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]276 // F: void(webrtc::IceGatheringState)
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]277 template <typename F>
278 void SubscribeIceGatheringState(F&& callback) {
Tommic3257d02021-02-10 17:40:08[diff] [blame]279 RTC_DCHECK_RUN_ON(network_thread_);
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]280 signal_ice_gathering_state_.AddReceiver(std::forward<F>(callback));
281 }
282
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]283 // F: void(const webrtc::IceCandidateErrorEvent&)
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]284 template <typename F>
285 void SubscribeIceCandidateError(F&& callback) {
Tommic3257d02021-02-10 17:40:08[diff] [blame]286 RTC_DCHECK_RUN_ON(network_thread_);
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]287 signal_ice_candidate_error_.AddReceiver(std::forward<F>(callback));
288 }
289
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]290 // F: void(const std::vector<webrtc::Candidate>&)
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]291 template <typename F>
292 void SubscribeIceCandidatesRemoved(F&& callback) {
Tommic3257d02021-02-10 17:40:08[diff] [blame]293 RTC_DCHECK_RUN_ON(network_thread_);
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]294 signal_ice_candidates_removed_.AddReceiver(std::forward<F>(callback));
295 }
296
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]297 // F: void(const webrtc::CandidatePairChangeEvent&)
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]298 template <typename F>
299 void SubscribeIceCandidatePairChanged(F&& callback) {
Tommic3257d02021-02-10 17:40:08[diff] [blame]300 RTC_DCHECK_RUN_ON(network_thread_);
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]301 signal_ice_candidate_pair_changed_.AddReceiver(std::forward<F>(callback));
302 }
303
304 private:
Tommic3257d02021-02-10 17:40:08[diff] [blame]305 // All of these callbacks are fired on the network thread.
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]306
307 // If any transport failed => failed,
308 // Else if all completed => completed,
309 // Else if all connected => connected,
310 // Else => connecting
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]311 CallbackList<IceConnectionState> signal_ice_connection_state_
Tommic3257d02021-02-10 17:40:08[diff] [blame]312 RTC_GUARDED_BY(network_thread_);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]313
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]314 CallbackList<PeerConnectionInterface::PeerConnectionState>
Tommic3257d02021-02-10 17:40:08[diff] [blame]315 signal_connection_state_ RTC_GUARDED_BY(network_thread_);
Lahiru Ginnaliya Gamathigee99c68d2020-09-30 21:33:45[diff] [blame]316
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]317 CallbackList<PeerConnectionInterface::IceConnectionState>
Tommic3257d02021-02-10 17:40:08[diff] [blame]318 signal_standardized_ice_connection_state_ RTC_GUARDED_BY(network_thread_);
Jonas Olsson635474e2018-10-18 13:58:17[diff] [blame]319
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]320 // If all transports done gathering => complete,
321 // Else if any are gathering => gathering,
322 // Else => new
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]323 CallbackList<IceGatheringState> signal_ice_gathering_state_
Tommic3257d02021-02-10 17:40:08[diff] [blame]324 RTC_GUARDED_BY(network_thread_);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]325
Lahiru Ginnaliya Gamathige5eb527c2021-01-19 07:32:22[diff] [blame]326 // [mid, candidates]
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]327 CallbackList<const std::string&, const std::vector<Candidate>&>
Tommic3257d02021-02-10 17:40:08[diff] [blame]328 signal_ice_candidates_gathered_ RTC_GUARDED_BY(network_thread_);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]329
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]330 CallbackList<const IceCandidateErrorEvent&> signal_ice_candidate_error_
331 RTC_GUARDED_BY(network_thread_);
Eldar Relloda13ea22019-06-01 09:23:43[diff] [blame]332
Tommiefc58a52025-07-23 09:04:38[diff] [blame]333 CallbackList<IceTransportInternal*, const std::vector<Candidate>&>
334 signal_ice_candidates_removed_ RTC_GUARDED_BY(network_thread_);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]335
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]336 CallbackList<const CandidatePairChangeEvent&>
Tommic3257d02021-02-10 17:40:08[diff] [blame]337 signal_ice_candidate_pair_changed_ RTC_GUARDED_BY(network_thread_);
Alex Drake00c7ecf2019-08-06 17:54:47[diff] [blame]338
Tommic5605202024-01-11 21:15:27[diff] [blame]339 // Called from SetLocalDescription and SetRemoteDescription.
340 // When `local` is true, local_desc must be valid. Similarly when
341 // `local` is false, remote_desc must be valid. The description counterpart
342 // to the one that's being applied, may be nullptr but when it's supplied
343 // the counterpart description's content groups will be kept up to date for
344 // `type == SdpType::kAnswer`.
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]345 RTCError ApplyDescription_n(bool local,
346 SdpType type,
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]347 const SessionDescription* local_desc,
348 const SessionDescription* remote_desc)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]349 RTC_RUN_ON(network_thread_);
Henrik Boströmf8187e02021-04-26 19:04:26[diff] [blame]350 RTCError ValidateAndMaybeUpdateBundleGroups(
Zhi Huangd2248f82018-04-10 21:41:03[diff] [blame]351 bool local,
352 SdpType type,
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]353 const SessionDescription* local_desc,
354 const SessionDescription* remote_desc) RTC_RUN_ON(network_thread_);
355 RTCError ValidateContent(const ContentInfo& content_info);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]356
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]357 void HandleRejectedContent(const ContentInfo& content_info)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]358 RTC_RUN_ON(network_thread_);
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]359 bool HandleBundledContent(const ContentInfo& content_info,
360 const ContentGroup& bundle_group)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]361 RTC_RUN_ON(network_thread_);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]362
Evan Shrubsole3c825f12025-04-04 14:07:27[diff] [blame]363 JsepTransportDescription CreateJsepTransportDescription(
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]364 const ContentInfo& content_info,
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]365 const TransportInfo& transport_info,
Zhi Huange830e682018-03-30 17:48:35[diff] [blame]366 const std::vector<int>& encrypted_extension_ids,
Niels Möllerdc80aaf2020-06-18 08:10:17[diff] [blame]367 int rtp_abs_sendtime_extn_id);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]368
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]369 std::map<const ContentGroup*, std::vector<int>>
Henrik Boströmf8187e02021-04-26 19:04:26[diff] [blame]370 MergeEncryptedHeaderExtensionIdsForBundles(
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]371 const SessionDescription* description);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]372 std::vector<int> GetEncryptedHeaderExtensionIds(
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]373 const ContentInfo& content_info);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]374
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]375 int GetRtpAbsSendTimeHeaderExtensionId(const ContentInfo& content_info);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]376
Zhi Huange830e682018-03-30 17:48:35[diff] [blame]377 // This method takes the BUNDLE group into account. If the JsepTransport is
378 // destroyed because of BUNDLE, it would return the transport which other
379 // transports are bundled on (In current implementation, it is the first
380 // content in the BUNDLE group).
Evan Shrubsole3c825f12025-04-04 14:07:27[diff] [blame]381 const JsepTransport* GetJsepTransportForMid(const std::string& mid) const
Tomas Gunnarsson92eebef2021-02-10 12:05:44[diff] [blame]382 RTC_RUN_ON(network_thread_);
Evan Shrubsole3c825f12025-04-04 14:07:27[diff] [blame]383 JsepTransport* GetJsepTransportForMid(const std::string& mid)
384 RTC_RUN_ON(network_thread_);
385 const JsepTransport* GetJsepTransportForMid(absl::string_view mid) const
386 RTC_RUN_ON(network_thread_);
387 JsepTransport* GetJsepTransportForMid(absl::string_view mid)
Harald Alvestrand8f429922022-05-04 10:32:30[diff] [blame]388 RTC_RUN_ON(network_thread_);
Zhi Huange830e682018-03-30 17:48:35[diff] [blame]389
390 // Get the JsepTransport without considering the BUNDLE group. Return nullptr
391 // if the JsepTransport is destroyed.
Evan Shrubsole3c825f12025-04-04 14:07:27[diff] [blame]392 const JsepTransport* GetJsepTransportByName(
Tomas Gunnarsson20f74562021-02-04 09:22:50[diff] [blame]393 const std::string& transport_name) const RTC_RUN_ON(network_thread_);
Evan Shrubsole3c825f12025-04-04 14:07:27[diff] [blame]394 JsepTransport* GetJsepTransportByName(const std::string& transport_name)
395 RTC_RUN_ON(network_thread_);
Zhi Huange830e682018-03-30 17:48:35[diff] [blame]396
Anton Sukhanov7940da02018-10-10 17:34:49[diff] [blame]397 // Creates jsep transport. Noop if transport is already created.
Artem Titov880fa812021-07-30 20:30:23[diff] [blame]398 // Transport is created either during SetLocalDescription (`local` == true) or
399 // during SetRemoteDescription (`local` == false). Passing `local` helps to
Anton Sukhanov7940da02018-10-10 17:34:49[diff] [blame]400 // differentiate initiator (caller) from answerer (callee).
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]401 RTCError MaybeCreateJsepTransport(bool local,
402 const ContentInfo& content_info,
403 const SessionDescription& description)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]404 RTC_RUN_ON(network_thread_);
Piotr (Peter) Slatala47dfdca2018-11-16 22:13:58[diff] [blame]405
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]406 void DestroyAllJsepTransports_n() RTC_RUN_ON(network_thread_);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]407
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]408 void SetIceRole_n(IceRole ice_role) RTC_RUN_ON(network_thread_);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]409
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]410 IceRole DetermineIceRole(JsepTransport* jsep_transport,
411 const TransportInfo& transport_info,
412 SdpType type,
413 bool local);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]414
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]415 std::unique_ptr<DtlsTransportInternal> CreateDtlsTransport(
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]416 const ContentInfo& content_info,
417 IceTransportInternal* ice);
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]418 scoped_refptr<IceTransportInterface> CreateIceTransport(
Qingsi Wang25ec8882019-11-15 20:33:05[diff] [blame]419 const std::string& transport_name,
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]420 bool rtcp);
421
Harald Alvestranda6544372023-11-13 09:33:56[diff] [blame]422 std::unique_ptr<RtpTransport> CreateUnencryptedRtpTransport(
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]423 const std::string& transport_name,
Evan Shrubsole8f7678f2025-04-01 14:23:55[diff] [blame]424 PacketTransportInternal* rtp_packet_transport,
425 PacketTransportInternal* rtcp_packet_transport);
Harald Alvestranda6544372023-11-13 09:33:56[diff] [blame]426 std::unique_ptr<DtlsSrtpTransport> CreateDtlsSrtpTransport(
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]427 const std::string& transport_name,
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]428 DtlsTransportInternal* rtp_dtls_transport,
429 DtlsTransportInternal* rtcp_dtls_transport);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]430
431 // Collect all the DtlsTransports, including RTP and RTCP, from the
Taylor Brandstetter8591eff2021-08-11 21:56:38[diff] [blame]432 // JsepTransports, including those not mapped to a MID because they are being
433 // kept alive in case of rollback.
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]434 std::vector<DtlsTransportInternal*> GetDtlsTransports();
Taylor Brandstetter8591eff2021-08-11 21:56:38[diff] [blame]435 // Same as the above, but doesn't include rollback transports.
436 // JsepTransportController can iterate all the DtlsTransports and update the
437 // aggregate states.
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]438 std::vector<DtlsTransportInternal*> GetActiveDtlsTransports();
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]439
440 // Handlers for signals from Transport.
Evan Shrubsole8f7678f2025-04-01 14:23:55[diff] [blame]441 void OnTransportWritableState_n(PacketTransportInternal* transport)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]442 RTC_RUN_ON(network_thread_);
Evan Shrubsole8f7678f2025-04-01 14:23:55[diff] [blame]443 void OnTransportReceivingState_n(PacketTransportInternal* transport)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]444 RTC_RUN_ON(network_thread_);
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]445 void OnTransportGatheringState_n(IceTransportInternal* transport)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]446 RTC_RUN_ON(network_thread_);
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]447 void OnTransportCandidateGathered_n(IceTransportInternal* transport,
448 const Candidate& candidate)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]449 RTC_RUN_ON(network_thread_);
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]450 void OnTransportCandidateError_n(IceTransportInternal* transport,
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]451 const IceCandidateErrorEvent& event)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]452 RTC_RUN_ON(network_thread_);
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]453 void OnTransportCandidatesRemoved_n(IceTransportInternal* transport,
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]454 const Candidates& candidates)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]455 RTC_RUN_ON(network_thread_);
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]456 void OnTransportRoleConflict_n(IceTransportInternal* transport)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]457 RTC_RUN_ON(network_thread_);
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]458 void OnTransportStateChanged_n(IceTransportInternal* transport)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]459 RTC_RUN_ON(network_thread_);
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]460 void OnTransportCandidatePairChanged_n(const CandidatePairChangeEvent& event)
Niels Möller5cf0ef02021-01-18 13:00:36[diff] [blame]461 RTC_RUN_ON(network_thread_);
462 void UpdateAggregateStates_n() RTC_RUN_ON(network_thread_);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]463
Per K12103ce2025-11-12 16:04:49[diff] [blame]464 void OnRtcpPacketReceived_n(CopyOnWriteBuffer packet,
465 std::optional<Timestamp> arrival_time,
466 EcnMarking ecn) RTC_RUN_ON(network_thread_);
Harald Alvestranda6544372023-11-13 09:33:56[diff] [blame]467 void OnUnDemuxableRtpPacketReceived_n(const RtpPacketReceived& packet)
Per Ke1e94ad2023-03-30 14:53:59[diff] [blame]468 RTC_RUN_ON(network_thread_);
Sebastian Jansson1b83a9e2019-09-18 16:22:12[diff] [blame]469
Evan Shrubsoleeb835d02025-03-12 09:41:06[diff] [blame]470 void OnDtlsHandshakeError(SSLHandshakeError error);
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]471
Evan Shrubsole3c825f12025-04-04 14:07:27[diff] [blame]472 bool OnTransportChanged(const std::string& mid, JsepTransport* transport);
Harald Alvestrand9dea3932021-06-10 06:03:06[diff] [blame]473
Victor Boiviecd54fd82024-02-28 11:16:15[diff] [blame]474 const Environment env_;
Evan Shrubsole6a9a1ae2025-03-21 12:54:15[diff] [blame]475 Thread* const network_thread_ = nullptr;
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]476 PortAllocator* const port_allocator_ = nullptr;
Harald Alvestrand0ccfbd22021-04-08 07:25:04[diff] [blame]477 AsyncDnsResolverFactoryInterface* const async_dns_resolver_factory_ = nullptr;
Giovanni Ortuño Urquidie2cfc362025-06-13 21:23:36[diff] [blame]478 LocalNetworkAccessPermissionFactoryInterface* const lna_permission_factory_ =
479 nullptr;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]480
Harald Alvestrand9dea3932021-06-10 06:03:06[diff] [blame]481 JsepTransportCollection transports_ RTC_GUARDED_BY(network_thread_);
Jonas Olsson635474e2018-10-18 13:58:17[diff] [blame]482 // Aggregate states for Transports.
Alex Loiko9289eda2018-11-23 16:18:59[diff] [blame]483 // standardized_ice_connection_state_ is intended to replace
484 // ice_connection_state, see bugs.webrtc.org/9308
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]485 IceConnectionState ice_connection_state_ = kIceConnectionConnecting;
Alex Loiko9289eda2018-11-23 16:18:59[diff] [blame]486 PeerConnectionInterface::IceConnectionState
487 standardized_ice_connection_state_ =
488 PeerConnectionInterface::kIceConnectionNew;
Jonas Olsson635474e2018-10-18 13:58:17[diff] [blame]489 PeerConnectionInterface::PeerConnectionState combined_connection_state_ =
490 PeerConnectionInterface::PeerConnectionState::kNew;
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]491 IceGatheringState ice_gathering_state_ = kIceGatheringNew;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]492
Harald Alvestrand133c0522021-01-29 14:27:12[diff] [blame]493 const Config config_;
494 bool active_reset_srtp_params_ RTC_GUARDED_BY(network_thread_);
Piotr (Peter) Slatalab1ae10b2019-03-01 19:14:05[diff] [blame]495
Florent Castelli8037fc62024-08-29 13:00:40[diff] [blame]496 std::optional<bool> initial_offerer_;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]497
Evan Shrubsole080cdac2025-03-20 09:34:48[diff] [blame]498 IceConfig ice_config_;
Evan Shrubsole945e5172025-04-08 14:11:45[diff] [blame]499 IceRole ice_role_ = ICEROLE_CONTROLLING;
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]500 scoped_refptr<RTCCertificate> certificate_;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]501
Harald Alvestrand9f9bf382021-06-08 04:12:37[diff] [blame]502 BundleManager bundles_;
Harald Alvestrand53086522024-08-25 16:43:08[diff] [blame]503 // Reference to the SdpOfferAnswerHandler's payload type picker.
504 PayloadTypePicker& payload_type_picker_;
Zhi Huange818b6e2018-02-22 23:26:27[diff] [blame]505};
506
507} // namespace webrtc
508
Steve Anton10542f22019-01-11 17:11:00[diff] [blame]509#endif // PC_JSEP_TRANSPORT_CONTROLLER_H_