ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 1 | /* |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 2 | * Copyright 2020 The WebRTC project authors. All Rights Reserved. |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 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 | |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 11 | #ifndef PC_SCTP_DATA_CHANNEL_H_ |
| 12 | #define PC_SCTP_DATA_CHANNEL_H_ |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 13 | |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 14 | #include <stdint.h> |
| 15 | |
Steve Anton | 944c755 | 2018-12-13 22:19:10 | [diff] [blame] | 16 | #include <memory> |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 17 | #include <set> |
| 18 | #include <string> |
| 19 | |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 20 | #include "absl/types/optional.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 21 | #include "api/data_channel_interface.h" |
Harald Alvestrand | fd5ae7f | 2020-05-16 06:37:49 | [diff] [blame] | 22 | #include "api/priority.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 23 | #include "api/rtc_error.h" |
Mirko Bonadei | d970807 | 2019-01-25 19:26:48 | [diff] [blame] | 24 | #include "api/scoped_refptr.h" |
Tommi | 8efaec6 | 2023-03-21 17:45:24 | [diff] [blame] | 25 | #include "api/sequence_checker.h" |
Tommi | a50a81a | 2023-04-11 15:32:34 | [diff] [blame] | 26 | #include "api/task_queue/pending_task_safety_flag.h" |
Niels Möller | 2a70703 | 2020-06-16 14:39:13 | [diff] [blame] | 27 | #include "api/transport/data_channel_transport_interface.h" |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 28 | #include "pc/data_channel_utils.h" |
Tommi | 492296c | 2023-03-12 15:59:25 | [diff] [blame] | 29 | #include "pc/sctp_utils.h" |
| 30 | #include "rtc_base/containers/flat_set.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 31 | #include "rtc_base/copy_on_write_buffer.h" |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 32 | #include "rtc_base/ssl_stream_adapter.h" // For SSLRole |
Tommi | 8efaec6 | 2023-03-21 17:45:24 | [diff] [blame] | 33 | #include "rtc_base/system/no_unique_address.h" |
Harald Alvestrand | 5761e7b | 2021-01-29 14:45:08 | [diff] [blame] | 34 | #include "rtc_base/thread.h" |
| 35 | #include "rtc_base/thread_annotations.h" |
Tommi | 1c0d91f | 2023-03-02 14:42:06 | [diff] [blame] | 36 | #include "rtc_base/weak_ptr.h" |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 37 | |
| 38 | namespace webrtc { |
| 39 | |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 40 | class SctpDataChannel; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 41 | |
Tommi | 55f7280 | 2023-03-27 10:39:33 | [diff] [blame] | 42 | // Interface that acts as a bridge from the data channel to the transport. |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 43 | // All methods in this interface need to be invoked on the network thread. |
Harald Alvestrand | 9e5aeb9 | 2022-05-11 09:35:36 | [diff] [blame] | 44 | class SctpDataChannelControllerInterface { |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 45 | public: |
| 46 | // Sends the data to the transport. |
Tommi | 1fabbac | 2023-03-21 13:48:51 | [diff] [blame] | 47 | virtual RTCError SendData(StreamId sid, |
| 48 | const SendDataParams& params, |
| 49 | const rtc::CopyOnWriteBuffer& payload) = 0; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 50 | // Adds the data channel SID to the transport for SCTP. |
Tommi | 4c84222 | 2023-03-21 10:35:24 | [diff] [blame] | 51 | virtual void AddSctpDataStream(StreamId sid) = 0; |
Taylor Brandstetter | cdd05f0 | 2018-05-31 20:23:32 | [diff] [blame] | 52 | // Begins the closing procedure by sending an outgoing stream reset. Still |
| 53 | // need to wait for callbacks to tell when this completes. |
Tommi | 4c84222 | 2023-03-21 10:35:24 | [diff] [blame] | 54 | virtual void RemoveSctpDataStream(StreamId sid) = 0; |
Tommi | d2afbaf | 2023-03-02 09:51:16 | [diff] [blame] | 55 | // Notifies the controller of state changes. |
| 56 | virtual void OnChannelStateChanged(SctpDataChannel* data_channel, |
| 57 | DataChannelInterface::DataState state) = 0; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 58 | |
| 59 | protected: |
Harald Alvestrand | 9e5aeb9 | 2022-05-11 09:35:36 | [diff] [blame] | 60 | virtual ~SctpDataChannelControllerInterface() {} |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 61 | }; |
| 62 | |
| 63 | struct InternalDataChannelInit : public DataChannelInit { |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 64 | enum OpenHandshakeRole { kOpener, kAcker, kNone }; |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 65 | // The default role is kOpener because the default `negotiated` is false. |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 66 | InternalDataChannelInit() : open_handshake_role(kOpener) {} |
Harald Alvestrand | f3736ed | 2019-04-08 11:09:30 | [diff] [blame] | 67 | explicit InternalDataChannelInit(const DataChannelInit& base); |
Tommi | c2429a0 | 2023-03-03 10:28:23 | [diff] [blame] | 68 | |
| 69 | // Does basic validation to determine if a data channel instance can be |
| 70 | // constructed using the configuration. |
| 71 | bool IsValid() const; |
| 72 | |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 73 | OpenHandshakeRole open_handshake_role; |
Tommi | 335d084 | 2023-03-25 09:56:18 | [diff] [blame] | 74 | // Optional fallback or backup flag from PC that's used for non-prenegotiated |
| 75 | // stream ids in situations where we cannot determine the SSL role from the |
| 76 | // transport for purposes of generating a stream ID. |
| 77 | // See: https://www.rfc-editor.org/rfc/rfc8832.html#name-protocol-overview |
| 78 | absl::optional<rtc::SSLRole> fallback_ssl_role; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 79 | }; |
| 80 | |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 81 | // Helper class to allocate unique IDs for SCTP DataChannels. |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 82 | class SctpSidAllocator { |
| 83 | public: |
Tommi | e08f9a9 | 2023-03-28 08:09:40 | [diff] [blame] | 84 | SctpSidAllocator() = default; |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 85 | // Gets the first unused odd/even id based on the DTLS role. If `role` is |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 86 | // SSL_CLIENT, the allocated id starts from 0 and takes even numbers; |
| 87 | // otherwise, the id starts from 1 and takes odd numbers. |
Tommi | 8efaec6 | 2023-03-21 17:45:24 | [diff] [blame] | 88 | // If a `StreamId` cannot be allocated, `StreamId::HasValue()` will be false. |
| 89 | StreamId AllocateSid(rtc::SSLRole role); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 90 | |
| 91 | // Attempts to reserve a specific sid. Returns false if it's unavailable. |
Tommi | 8efaec6 | 2023-03-21 17:45:24 | [diff] [blame] | 92 | bool ReserveSid(StreamId sid); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 93 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 94 | // Indicates that `sid` isn't in use any more, and is thus available again. |
Tommi | 8efaec6 | 2023-03-21 17:45:24 | [diff] [blame] | 95 | void ReleaseSid(StreamId sid); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 96 | |
| 97 | private: |
Tommi | 8efaec6 | 2023-03-21 17:45:24 | [diff] [blame] | 98 | flat_set<StreamId> used_sids_ RTC_GUARDED_BY(&sequence_checker_); |
Tommi | e08f9a9 | 2023-03-28 08:09:40 | [diff] [blame] | 99 | RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_{ |
| 100 | SequenceChecker::kDetached}; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 101 | }; |
| 102 | |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 103 | // SctpDataChannel is an implementation of the DataChannelInterface based on |
| 104 | // SctpTransport. It provides an implementation of unreliable or |
Tommi | 00264ca | 2023-03-14 12:21:06 | [diff] [blame] | 105 | // reliable data channels. |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 106 | |
| 107 | // DataChannel states: |
| 108 | // kConnecting: The channel has been created the transport might not yet be |
| 109 | // ready. |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 110 | // kOpen: The open handshake has been performed (if relevant) and the data |
| 111 | // channel is able to send messages. |
| 112 | // kClosing: DataChannelInterface::Close has been called, or the remote side |
| 113 | // initiated the closing procedure, but the closing procedure has not |
| 114 | // yet finished. |
| 115 | // kClosed: The closing handshake is finished (possibly initiated from this, |
| 116 | // side, possibly from the peer). |
Taylor Brandstetter | cdd05f0 | 2018-05-31 20:23:32 | [diff] [blame] | 117 | // |
| 118 | // How the closing procedure works for SCTP: |
| 119 | // 1. Alice calls Close(), state changes to kClosing. |
| 120 | // 2. Alice finishes sending any queued data. |
| 121 | // 3. Alice calls RemoveSctpDataStream, sends outgoing stream reset. |
| 122 | // 4. Bob receives incoming stream reset; OnClosingProcedureStartedRemotely |
| 123 | // called. |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 124 | // 5. Bob sends outgoing stream reset. |
| 125 | // 6. Alice receives incoming reset, Bob receives acknowledgement. Both receive |
| 126 | // OnClosingProcedureComplete callback and transition to kClosed. |
Tommi | 00264ca | 2023-03-14 12:21:06 | [diff] [blame] | 127 | class SctpDataChannel : public DataChannelInterface { |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 128 | public: |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 129 | static rtc::scoped_refptr<SctpDataChannel> Create( |
Tommi | 1c0d91f | 2023-03-02 14:42:06 | [diff] [blame] | 130 | rtc::WeakPtr<SctpDataChannelControllerInterface> controller, |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 131 | const std::string& label, |
Tommi | e9aa867 | 2023-03-20 13:43:09 | [diff] [blame] | 132 | bool connected_to_transport, |
Tomas Gunnarsson | 7d3cfbf | 2020-06-15 11:47:42 | [diff] [blame] | 133 | const InternalDataChannelInit& config, |
| 134 | rtc::Thread* signaling_thread, |
| 135 | rtc::Thread* network_thread); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 136 | |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 137 | // Instantiates an API proxy for a SctpDataChannel instance that will be |
| 138 | // handed out to external callers. |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 139 | // The `signaling_safety` flag is used for the ObserverAdapter callback proxy |
| 140 | // which delivers callbacks on the signaling thread but must not deliver such |
| 141 | // callbacks after the peerconnection has been closed. The data controller |
| 142 | // will update the flag when closed, which will cancel any pending event |
| 143 | // notifications. |
Tomas Gunnarsson | 6476d0b | 2020-06-16 16:39:50 | [diff] [blame] | 144 | static rtc::scoped_refptr<DataChannelInterface> CreateProxy( |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 145 | rtc::scoped_refptr<SctpDataChannel> channel, |
| 146 | rtc::scoped_refptr<PendingTaskSafetyFlag> signaling_safety); |
Bjorn Mellem | 175aa2e | 2018-11-08 19:23:22 | [diff] [blame] | 147 | |
Tomas Gunnarsson | 7d3cfbf | 2020-06-15 11:47:42 | [diff] [blame] | 148 | void RegisterObserver(DataChannelObserver* observer) override; |
| 149 | void UnregisterObserver() override; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 150 | |
Tommi | 492296c | 2023-03-12 15:59:25 | [diff] [blame] | 151 | std::string label() const override; |
Tomas Gunnarsson | 7d3cfbf | 2020-06-15 11:47:42 | [diff] [blame] | 152 | bool reliable() const override; |
Tommi | 492296c | 2023-03-12 15:59:25 | [diff] [blame] | 153 | bool ordered() const override; |
Tomas Gunnarsson | 7d3cfbf | 2020-06-15 11:47:42 | [diff] [blame] | 154 | |
Tommi | 492296c | 2023-03-12 15:59:25 | [diff] [blame] | 155 | // Backwards compatible accessors |
| 156 | uint16_t maxRetransmitTime() const override; |
| 157 | uint16_t maxRetransmits() const override; |
| 158 | |
| 159 | absl::optional<int> maxPacketLifeTime() const override; |
| 160 | absl::optional<int> maxRetransmitsOpt() const override; |
| 161 | std::string protocol() const override; |
| 162 | bool negotiated() const override; |
| 163 | int id() const override; |
| 164 | Priority priority() const override; |
Tomas Gunnarsson | 7d3cfbf | 2020-06-15 11:47:42 | [diff] [blame] | 165 | |
| 166 | uint64_t buffered_amount() const override; |
| 167 | void Close() override; |
| 168 | DataState state() const override; |
| 169 | RTCError error() const override; |
| 170 | uint32_t messages_sent() const override; |
| 171 | uint64_t bytes_sent() const override; |
| 172 | uint32_t messages_received() const override; |
| 173 | uint64_t bytes_received() const override; |
| 174 | bool Send(const DataBuffer& buffer) override; |
Tommi | a50a81a | 2023-04-11 15:32:34 | [diff] [blame] | 175 | void SendAsync(DataBuffer buffer, |
| 176 | absl::AnyInvocable<void(RTCError) &&> on_complete) override; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 177 | |
Harald Alvestrand | 1f928d3 | 2019-03-28 10:29:38 | [diff] [blame] | 178 | // Close immediately, ignoring any queued data or closing procedure. |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 179 | // This is called when the underlying SctpTransport is being destroyed. |
Harald Alvestrand | 1f928d3 | 2019-03-28 10:29:38 | [diff] [blame] | 180 | // It is also called by the PeerConnection if SCTP ID assignment fails. |
Harald Alvestrand | dfbfb46 | 2019-12-08 04:55:43 | [diff] [blame] | 181 | void CloseAbruptlyWithError(RTCError error); |
| 182 | // Specializations of CloseAbruptlyWithError |
| 183 | void CloseAbruptlyWithDataChannelFailure(const std::string& message); |
Harald Alvestrand | 1f928d3 | 2019-03-28 10:29:38 | [diff] [blame] | 184 | |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 185 | // Called when the SctpTransport's ready to use. That can happen when we've |
| 186 | // finished negotiation, or if the channel was created after negotiation has |
| 187 | // already finished. |
Tommi | e9aa867 | 2023-03-20 13:43:09 | [diff] [blame] | 188 | void OnTransportReady(); |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 189 | |
Tommi | 4e1c957 | 2023-03-15 11:36:20 | [diff] [blame] | 190 | void OnDataReceived(DataMessageType type, |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 191 | const rtc::CopyOnWriteBuffer& payload); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 192 | |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 193 | // Sets the SCTP sid and adds to transport layer if not set yet. Should only |
| 194 | // be called once. |
Tommi | 1158bde | 2023-03-30 10:01:56 | [diff] [blame] | 195 | void SetSctpSid_n(StreamId sid); |
Tommi | 00264ca | 2023-03-14 12:21:06 | [diff] [blame] | 196 | |
Taylor Brandstetter | cdd05f0 | 2018-05-31 20:23:32 | [diff] [blame] | 197 | // The remote side started the closing procedure by resetting its outgoing |
| 198 | // stream (our incoming stream). Sets state to kClosing. |
Tommi | 00264ca | 2023-03-14 12:21:06 | [diff] [blame] | 199 | void OnClosingProcedureStartedRemotely(); |
Taylor Brandstetter | cdd05f0 | 2018-05-31 20:23:32 | [diff] [blame] | 200 | // The closing procedure is complete; both incoming and outgoing stream |
| 201 | // resets are done and the channel can transition to kClosed. Called |
| 202 | // asynchronously after RemoveSctpDataStream. |
Tommi | 51edb56 | 2023-03-14 08:23:51 | [diff] [blame] | 203 | void OnClosingProcedureComplete(); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 204 | // Called when the transport channel is created. |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 205 | void OnTransportChannelCreated(); |
Harald Alvestrand | 408cb4b | 2019-11-16 11:09:08 | [diff] [blame] | 206 | // Called when the transport channel is unusable. |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 207 | // This method makes sure the DataChannel is disconnected and changes state |
| 208 | // to kClosed. |
Florent Castelli | dcb9ffc | 2021-06-29 12:58:23 | [diff] [blame] | 209 | void OnTransportChannelClosed(RTCError error); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 210 | |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 211 | DataChannelStats GetStats() const; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 212 | |
Tommi | 5654898 | 2023-03-27 16:07:34 | [diff] [blame] | 213 | // Returns a unique identifier that's guaranteed to always be available, |
| 214 | // doesn't change throughout SctpDataChannel's lifetime and is used for |
| 215 | // stats purposes (see also `GetStats()`). |
| 216 | int internal_id() const { return internal_id_; } |
| 217 | |
Tommi | 1158bde | 2023-03-30 10:01:56 | [diff] [blame] | 218 | StreamId sid_n() const { |
| 219 | RTC_DCHECK_RUN_ON(network_thread_); |
| 220 | return id_n_; |
| 221 | } |
Tommi | 492296c | 2023-03-12 15:59:25 | [diff] [blame] | 222 | |
Harald Alvestrand | 928e7a3 | 2019-07-31 11:16:45 | [diff] [blame] | 223 | // Reset the allocator for internal ID values for testing, so that |
| 224 | // the internal IDs generated are predictable. Test only. |
| 225 | static void ResetInternalIdAllocatorForTesting(int new_value); |
| 226 | |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 227 | protected: |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 228 | SctpDataChannel(const InternalDataChannelInit& config, |
Tommi | 1c0d91f | 2023-03-02 14:42:06 | [diff] [blame] | 229 | rtc::WeakPtr<SctpDataChannelControllerInterface> controller, |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 230 | const std::string& label, |
Tommi | e9aa867 | 2023-03-20 13:43:09 | [diff] [blame] | 231 | bool connected_to_transport, |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 232 | rtc::Thread* signaling_thread, |
| 233 | rtc::Thread* network_thread); |
| 234 | ~SctpDataChannel() override; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 235 | |
| 236 | private: |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 237 | class ObserverAdapter; |
| 238 | |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 239 | // The OPEN(_ACK) signaling state. |
| 240 | enum HandshakeState { |
| 241 | kHandshakeInit, |
| 242 | kHandshakeShouldSendOpen, |
| 243 | kHandshakeShouldSendAck, |
| 244 | kHandshakeWaitingForAck, |
| 245 | kHandshakeReady |
| 246 | }; |
| 247 | |
Tommi | a50a81a | 2023-04-11 15:32:34 | [diff] [blame] | 248 | RTCError SendImpl(DataBuffer buffer) RTC_RUN_ON(network_thread_); |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 249 | void UpdateState() RTC_RUN_ON(network_thread_); |
| 250 | void SetState(DataState state) RTC_RUN_ON(network_thread_); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 251 | |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 252 | void DeliverQueuedReceivedData() RTC_RUN_ON(network_thread_); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 253 | |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 254 | void SendQueuedDataMessages() RTC_RUN_ON(network_thread_); |
Tommi | a50a81a | 2023-04-11 15:32:34 | [diff] [blame] | 255 | RTCError SendDataMessage(const DataBuffer& buffer, bool queue_if_blocked) |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 256 | RTC_RUN_ON(network_thread_); |
| 257 | bool QueueSendDataMessage(const DataBuffer& buffer) |
| 258 | RTC_RUN_ON(network_thread_); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 259 | |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 260 | void SendQueuedControlMessages() RTC_RUN_ON(network_thread_); |
| 261 | bool SendControlMessage(const rtc::CopyOnWriteBuffer& buffer) |
| 262 | RTC_RUN_ON(network_thread_); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 263 | |
Tommi | a50a81a | 2023-04-11 15:32:34 | [diff] [blame] | 264 | bool connected_to_transport() const RTC_RUN_ON(network_thread_) { |
| 265 | return network_safety_->alive(); |
| 266 | } |
| 267 | |
Tomas Gunnarsson | 7d3cfbf | 2020-06-15 11:47:42 | [diff] [blame] | 268 | rtc::Thread* const signaling_thread_; |
| 269 | rtc::Thread* const network_thread_; |
Tommi | 1158bde | 2023-03-30 10:01:56 | [diff] [blame] | 270 | StreamId id_n_ RTC_GUARDED_BY(network_thread_); |
Harald Alvestrand | 928e7a3 | 2019-07-31 11:16:45 | [diff] [blame] | 271 | const int internal_id_; |
Tomas Gunnarsson | 0ca13d9 | 2020-06-10 10:17:50 | [diff] [blame] | 272 | const std::string label_; |
Tommi | 492296c | 2023-03-12 15:59:25 | [diff] [blame] | 273 | const std::string protocol_; |
| 274 | const absl::optional<int> max_retransmit_time_; |
| 275 | const absl::optional<int> max_retransmits_; |
| 276 | const absl::optional<Priority> priority_; |
| 277 | const bool negotiated_; |
| 278 | const bool ordered_; |
| 279 | |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 280 | DataChannelObserver* observer_ RTC_GUARDED_BY(network_thread_) = nullptr; |
| 281 | std::unique_ptr<ObserverAdapter> observer_adapter_; |
| 282 | DataState state_ RTC_GUARDED_BY(network_thread_) = kConnecting; |
| 283 | RTCError error_ RTC_GUARDED_BY(network_thread_); |
| 284 | uint32_t messages_sent_ RTC_GUARDED_BY(network_thread_) = 0; |
| 285 | uint64_t bytes_sent_ RTC_GUARDED_BY(network_thread_) = 0; |
| 286 | uint32_t messages_received_ RTC_GUARDED_BY(network_thread_) = 0; |
| 287 | uint64_t bytes_received_ RTC_GUARDED_BY(network_thread_) = 0; |
Tommi | 1c0d91f | 2023-03-02 14:42:06 | [diff] [blame] | 288 | rtc::WeakPtr<SctpDataChannelControllerInterface> controller_ |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 289 | RTC_GUARDED_BY(network_thread_); |
| 290 | HandshakeState handshake_state_ RTC_GUARDED_BY(network_thread_) = |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 291 | kHandshakeInit; |
Taylor Brandstetter | cdd05f0 | 2018-05-31 20:23:32 | [diff] [blame] | 292 | // Did we already start the graceful SCTP closing procedure? |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 293 | bool started_closing_procedure_ RTC_GUARDED_BY(network_thread_) = false; |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 294 | // Control messages that always have to get sent out before any queued |
| 295 | // data. |
Tommi | f9e13f8 | 2023-04-06 19:21:45 | [diff] [blame] | 296 | PacketQueue queued_control_data_ RTC_GUARDED_BY(network_thread_); |
| 297 | PacketQueue queued_received_data_ RTC_GUARDED_BY(network_thread_); |
| 298 | PacketQueue queued_send_data_ RTC_GUARDED_BY(network_thread_); |
Tommi | a50a81a | 2023-04-11 15:32:34 | [diff] [blame] | 299 | rtc::scoped_refptr<PendingTaskSafetyFlag> network_safety_ = |
| 300 | PendingTaskSafetyFlag::CreateDetachedInactive(); |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 301 | }; |
| 302 | |
ossu | 7bb87ee | 2017-01-23 12:56:25 | [diff] [blame] | 303 | } // namespace webrtc |
| 304 | |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 305 | #endif // PC_SCTP_DATA_CHANNEL_H_ |