mediasoup 3.19.19 → 3.19.21

package/worker/include/RTC/SCTP/association/{AssociationDeferredListener.hpp → AssociationListenerDeferrer.hpp}

@@ -1,5 +1,5 @@
-#ifndef MS_RTC_SCTP_ASSOCIATION_DEFERRED_LISTENER_HPP
-#define MS_RTC_SCTP_ASSOCIATION_DEFERRED_LISTENER_HPP
+#ifndef MS_RTC_SCTP_ASSOCIATION_LISTENER_DEFERRED_HPP
+#define MS_RTC_SCTP_ASSOCIATION_LISTENER_DEFERRED_HPP
 
 #include "common.hpp"
 #include "RTC/SCTP/public/AssociationListener.hpp"
@@ -15,18 +15,18 @@ namespace RTC
 {
 	namespace SCTP
 	{
-		class AssociationDeferredListener : public AssociationListener
+		class AssociationListenerDeferrer : public AssociationListener
 		{
 		public:
-			class ScopedDeferred
+			class ScopedDeferrer
 			{
 			public:
-				explicit ScopedDeferred(AssociationDeferredListener& deferredListener);
+				explicit ScopedDeferrer(AssociationListenerDeferrer& listenerDeferrer);
 
-				~ScopedDeferred();
+				~ScopedDeferrer();
 
 			private:
-				AssociationDeferredListener& deferredListener;
+				AssociationListenerDeferrer& listenerDeferrer;
 			};
 
 		private:
@@ -49,7 +49,7 @@ namespace RTC
 			using Callback = std::function<void(CallbackData, AssociationListener*)>;
 
 		public:
-			explicit AssociationDeferredListener(AssociationListener* innerListener);
+			explicit AssociationListenerDeferrer(AssociationListener* innerListener);
 
 		private:
 			void SetReady();
@@ -85,6 +85,8 @@ namespace RTC
 
 			void OnAssociationTotalBufferedAmountLow() override;
 
+			bool OnAssociationIsTransportReadyForSctp() override;
+
 		private:
 			AssociationListener* innerListener;
 			bool ready{ false };

package/worker/include/RTC/SCTP/association/HeartbeatHandler.hpp

@@ -0,0 +1,77 @@
+#ifndef MS_RTC_SCTP_HEARTBEAT_HANDLER_HPP
+#define MS_RTC_SCTP_HEARTBEAT_HANDLER_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/association/TCBContext.hpp"
+#include "RTC/SCTP/packet/chunks/HeartbeatAckChunk.hpp"
+#include "RTC/SCTP/packet/chunks/HeartbeatRequestChunk.hpp"
+#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/SctpOptions.hpp"
+#include "handles/BackoffTimerHandle.hpp"
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * HeartbeatHandler handles all logic around sending heartbeats and receiving
+		 * the responses, as well as receiving incoming heartbeat requests.
+		 *
+		 * Heartbeats are sent on idle connections to ensure that the connection is
+		 * still healthy and to measure the RTT. If a number of heartbeats time out,
+		 * the connection will eventually be closed.
+		 */
+		class HeartbeatHandler : public BackoffTimerHandle::Listener
+		{
+		public:
+			HeartbeatHandler(
+			  AssociationListener& associationListener,
+			  const SctpOptions& sctpOptions,
+			  TCBContext* tcbContext);
+
+			~HeartbeatHandler() override;
+
+		public:
+			/**
+			 * Called when the heartbeat interval timer should be restarted. This is
+			 * generally done every time data is sent, which makes the timer expire
+			 * when the connection is idle.
+			 */
+			void RestartTimer();
+
+			/**
+			 * Called on received HEARTBEAT_REQUEST Chunk.
+			 */
+			void HandleReceivedHeartbeatRequestChunk(
+			  const HeartbeatRequestChunk* receivedHeartbeatRequestChunk);
+
+			/**
+			 * Called on received HEARTBEAT_ACK Chunk.
+			 */
+			void HandleReceivedHeartbeatAckChunk(const HeartbeatAckChunk* receivedHeartbeatAckChunk);
+
+		private:
+			void OnIntervalTimer(uint64_t& baseTimeoutMs, bool& stop);
+
+			void OnTimeoutTimer(uint64_t& baseTimeoutMs, bool& stop);
+
+			/* Pure virtual methods inherited from BackoffTimerHandle::Listener. */
+		public:
+			void OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+
+		private:
+			AssociationListener& associationListener;
+			const SctpOptions sctpOptions;
+			TCBContext* tcbContext{ nullptr };
+			// The time for a connection to be idle before a heartbeat is sent.
+			const uint64_t intervalDurationMs{ 0 };
+			// Adding RTT to the duration will add some jitter, which is good in
+			// production, but less good in unit tests, which is why it can be disabled.
+			const bool intervalDurationShouldIncludeRtt{ false };
+			const std::unique_ptr<BackoffTimerHandle> intervalTimer;
+			const std::unique_ptr<BackoffTimerHandle> timeoutTimer;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/association/NegotiatedCapabilities.hpp

@@ -29,12 +29,12 @@ namespace RTC
 			/**
 			 * Negotiated maximum number of outbound streams (OS).
 			 */
-			uint16_t maxOutboundStreams{ 0 };
+			uint16_t negotiatedMaxOutboundStreams{ 0 };
 
 			/**
 			 * Negotiated maximum number of inbound streams (MIS).
 			 */
-			uint16_t maxInboundStreams{ 0 };
+			uint16_t negotiatedMaxInboundStreams{ 0 };
 
 			/**
 			 * Partial Reliability Extension.

package/worker/include/RTC/SCTP/association/PacketSender.hpp

@@ -23,7 +23,7 @@ namespace RTC
 			};
 
 		public:
-			PacketSender(Listener& listener, AssociationListener& associationListener);
+			PacketSender(Listener* listener, AssociationListener& associationListener);
 
 			~PacketSender();
 
@@ -42,7 +42,7 @@ namespace RTC
 			bool SendPacket(Packet* packet, bool writeChecksum = true);
 
 		private:
-			Listener& listener;
+			Listener* listener;
 			AssociationListener& associationListener;
 		};
 	} // namespace SCTP

package/worker/include/RTC/SCTP/association/StateCookie.hpp

@@ -79,8 +79,8 @@ namespace RTC
 				uint8_t bitA : 1;
 #endif
 				uint16_t magic2;
-				uint16_t maxOutboundStreams;
-				uint16_t maxInboundStreams;
+				uint16_t negotiatedMaxOutboundStreams;
+				uint16_t negotiatedMaxInboundStreams;
 			};
 
 		public:

package/worker/include/RTC/SCTP/association/StreamResetHandler.hpp

@@ -0,0 +1,272 @@
+#ifndef MS_RTC_SCTP_STREAM_RESET_HANDLER_HPP
+#define MS_RTC_SCTP_STREAM_RESET_HANDLER_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/association/TCBContext.hpp"
+#include "RTC/SCTP/common/UnwrappedSequenceNumber.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/packet/chunks/ReConfigChunk.hpp"
+#include "RTC/SCTP/packet/parameters/IncomingSsnResetRequestParameter.hpp"
+#include "RTC/SCTP/packet/parameters/OutgoingSsnResetRequestParameter.hpp"
+#include "RTC/SCTP/packet/parameters/ReconfigurationResponseParameter.hpp"
+#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "handles/BackoffTimerHandle.hpp"
+#include <span>
+#include <vector>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * StreamResetHandler handles sending outgoing stream reset requests (to
+		 * close an SCTP stream, which translates to closing a data channel in
+		 * WebRTC).
+		 *
+		 * It also handles incoming "outgoing stream reset requests", when the peer
+		 * wants to close its streams.
+		 *
+		 * Resetting streams is an asynchronous operation where the client will
+		 * request a request a stream to be reset, but then it might not be
+		 * performed exactly at this point. First, the sender might need to discard
+		 * all messages that have been enqueued for this stream, or it may select to
+		 * wait until all have been sent. At least, it must wait for the currently
+		 * sending fragmented message to be fully sent, because a stream can't be
+		 * reset while having received half a message. In the stream reset request,
+		 * the "sender's last assigned TSN" is provided, which is simply the TSN for
+		 * which the receiver should've received all messages before this value,
+		 * before the stream can be reset. Since fragments can get lost or sent
+		 * out-of-order, the receiver of a request may not have received all the
+		 * data just yet, and then it will respond to the sender: "In progress". In
+		 * other words, try again. The sender will then need to start a timer and
+		 * try the very same request again (but with a new sequence number) until
+		 * the receiver successfully performs the operation.
+		 *
+		 * All this can take some time, and may be driven by timers, so the client
+		 * will ultimately be notified using callbacks.
+		 *
+		 * In this implementation, when a stream is reset, the queued but
+		 * not-yet-sent messages will be discarded, but that may change in the future.
+		 * RFC8831 allows both behaviors.
+		 */
+		class StreamResetHandler : public TCBContext, public BackoffTimerHandle::Listener
+		{
+		private:
+			enum class ReqSeqNbrValidationResult : uint8_t
+			{
+				VALID,
+				RETRANSMISSION,
+				BAD_SEQUENCE_NUMBER,
+			};
+
+			/**
+			 * Represents a stream request operation. There can only be one ongoing at
+			 * any time, and a sent request may either succeed, fail or result in the
+			 * receiver signaling that it can't process it right now, and then it will
+			 * be retried.
+			 */
+			class CurrentRequest
+			{
+			public:
+				CurrentRequest(uint32_t senderLastAssignedTsn, std::vector<uint16_t> streamIds)
+				  : reqSeqNbr(std::nullopt),
+				    senderLastAssignedTsn(senderLastAssignedTsn),
+				    streamIds(std::move(streamIds))
+				{
+				}
+
+				/**
+				 * Returns the current request sequence number, if this request has been
+				 * sent (check `HasBeenFirst()` first). Will return 0 if the request is
+				 * just prepared (or scheduled for retransmission) but not yet sent.
+				 */
+				uint32_t GetReqSeqNbr() const
+				{
+					return this->reqSeqNbr.value_or(0);
+				}
+
+				/**
+				 * The sender's last assigned TSN, from the retransmission queue. The
+				 * receiver uses this to know when all data up to this TSN has been
+				 * received, to know when to safely reset the stream.
+				 */
+				uint32_t GetSenderLastAssignedTsn() const
+				{
+					return senderLastAssignedTsn;
+				}
+
+				/**
+				 * The streams that are to be reset.
+				 */
+				const std::vector<uint16_t>& GetStreamIds() const
+				{
+					return this->streamIds;
+				}
+
+				/**
+				 * If this request has been sent yet. If not, then it's either because
+				 * it has only been prepared and not yet sent, or because the received
+				 * couldn't apply the request, and then the exact same request will be
+				 * retried, but with a new sequence number.
+				 */
+				bool HasBeenSent() const
+				{
+					return this->reqSeqNbr.has_value();
+				}
+
+				/**
+				 * If the receiver can't apply the request yet (and answered "In
+				 * Progress"), this will be called to prepare the request to be
+				 * retransmitted at a later time.
+				 */
+				void PrepareRetransmission()
+				{
+					this->reqSeqNbr = std::nullopt;
+				}
+
+				/**
+				 * If the request hasn't been sent yet, this assigns it a request
+				 * number.
+				 */
+				void PrepareToSend(uint32_t newReqSeqNbr)
+				{
+					this->reqSeqNbr = newReqSeqNbr;
+				}
+
+				void SetDeferred(bool isDeferred)
+				{
+					this->isDeferred = isDeferred;
+				}
+
+				bool IsDeferred() const
+				{
+					return this->isDeferred;
+				}
+
+			private:
+				// If this is set, this request has been sent. If it's not set, the
+				// request has been prepared, but has not yet been sent. This is
+				// typically used when the peer responded "in progress" and the same
+				// request (but a different request number) must be sent again.
+				std::optional<uint32_t> reqSeqNbr{ 0 };
+				// The sender's (that's us) last assigned TSN, from the retransmission
+				// queue.
+				uint32_t senderLastAssignedTsn{ 0 };
+				// The streams that are to be reset in this request.
+				std::vector<uint16_t> streamIds;
+				// If the request is deferred (received "In Progress"), the next timeout
+				// should not be treated as a timeout.
+				bool isDeferred{ false };
+			};
+
+		private:
+			using UnwrappedReConfigRequestSn = UnwrappedSequenceNumber<uint32_t>;
+
+		public:
+			StreamResetHandler(
+			  AssociationListener& associationListener, TCBContext* tcbContext
+			  // TODO: SCTP: Implement
+			  // DataTracker* dataTracker,
+			  // ReassemblyQueue* reassemblyQueue,
+			  // RetransmissionQueue* retransmissionQueue
+			);
+
+			~StreamResetHandler() override;
+
+		public:
+			/**
+			 * Initiates reset of the provided streams. While there can only be one
+			 * ongoing stream reset request at any time, this method can be called at
+			 * any time and also multiple times. It will enqueue requests that can't
+			 * be directly fulfilled, and will asynchronously process them when any
+			 * ongoing request has completed.
+			 */
+			void ResetStreams(std::span<const uint16_t> outgoingStreamIds);
+
+			/**
+			 * Called when handling and incoming RE-CONFIG chunk. Processes a stream
+			 * reconfiguration chunk and may send a RE-CONFIG back to the peer with
+			 * either 1 or 2 responses.
+			 */
+			void HandleReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk);
+
+		private:
+			/**
+			 * Called to validate a received RE-CONFIG chunk.
+			 */
+			bool ValidateReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk);
+
+			/**
+			 * Creates a Reset Streams request that must be sent if returned. Will
+			 * start the reconfig timer. Will return `nullptr` if there is no need
+			 * to create a request (no streams to reset) or if there already is an
+			 * ongoing stream reset request that hasn't completed yet.
+			 */
+			ReConfigChunk* CreateStreamResetRequest();
+
+			/**
+			 * Creates the actual RE-CONFIG chunk. A request (which set
+			 * `currentRequest`) must have been created prior.
+			 */
+			ReConfigChunk* CreateReconfigChunk();
+
+			/**
+			 * Called to validate the `reqSeqNbr`, that it's the next in sequence.
+			 */
+			ReqSeqNbrValidationResult ValidateReqSeqNbr(UnwrappedReConfigRequestSn reqSeqNbr);
+
+			/**
+			 * Called when this Association receives an outgoing stream reset request.
+			 * It might either be performed straight away, or have to be deferred, and
+			 * the result of that will be put in `responses`.
+			 */
+			void HandleReceivedOutgoingSsnResetRequestParameter(
+			  const OutgoingSsnResetRequestParameter* receivedOutgoingSsnResetRequestParameter,
+			  ReConfigChunk* reConfigChunk);
+
+			/**
+			 * Called when this Association receives an incoming stream reset request.
+			 * This isn't really supported, but a successful response is put in
+			 * `responses`.
+			 */
+			void HandleReceivedIncomingSsnResetRequestParameter(
+			  const IncomingSsnResetRequestParameter* receivedIncomingSsnResetRequestParameter,
+			  ReConfigChunk* reConfigChunk);
+
+			/**
+			 * Called when receiving a response to an outgoing stream reset request.
+			 * It will either commit the stream resetting, if the operation was
+			 * successful, or will schedule a retry if it was deferred. And if it
+			 * failed, the operation will be rolled back.
+			 */
+			void HandleReceivedReconfigurationResponseParameter(
+			  const ReconfigurationResponseParameter* receivedReconfigurationResponseParameter);
+
+			void OnReConfigTimer(uint64_t& baseTimeoutMs, bool& stop);
+
+			/* Pure virtual methods inherited from BackoffTimerHandle::Listener. */
+		public:
+			void OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+
+		private:
+			AssociationListener& associationListener;
+			TCBContext* tcbContext{ nullptr };
+			// TODO: SCTP: Implement
+			// DataTracker* dataTracker{ nullptr };,
+			// ReassemblyQueue* reassemblyQueue{ nullptr };,
+			// RetransmissionQueue* retransmissionQueue{ nullptr };
+			UnwrappedReConfigRequestSn::Unwrapper incomingReConfigRequestSnUnwrapper;
+			const std::unique_ptr<BackoffTimerHandle> reConfigTimer;
+			// The next sequence number for outgoing stream requests.
+			uint32_t nextOutgoingReqSeqNbr{ 0 };
+			// The current stream request operation.
+			std::optional<CurrentRequest> currentRequest;
+			// For incoming requests. Last processed request sequence number.
+			UnwrappedReConfigRequestSn lastProcessedReqSeqNbr;
+			// The result from last processed incoming request.
+			ReconfigurationResponseParameter::Result lastProcessedReqResult;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/association/TCBContext.hpp

@@ -0,0 +1,67 @@
+#ifndef MS_RTC_SCTP_TCB_CONTEXT_HPP
+#define MS_RTC_SCTP_TCB_CONTEXT_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include <string_view>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		class TCBContext
+		{
+		public:
+			virtual ~TCBContext() = default;
+
+			/**
+			 * Indicates if the SCTP Association has been established.
+			 */
+			virtual bool IsAssociationEstablished() const = 0;
+
+			/**
+			 * The value of the Initiate Tag field the peer put in its INIT or
+			 * INIT_ACK Chunk.
+			 */
+			virtual uint32_t GetLocalInitialTsn() const = 0;
+
+			/**
+			 * The value of the Initial TSN field the peer put in its INIT or
+			 * INIT_ACK Chunk.
+			 */
+			virtual uint32_t GetRemoteInitialTsn() const = 0;
+
+			/**
+			 * To be called when a RTT has been measured, to update the RTO value.
+			 */
+			virtual void ObserveRtt(uint64_t rtt) = 0;
+
+			/**
+			 * Returns the Retransmission Timeout (RTO) value.
+			 */
+			virtual uint64_t GetCurrentRtoMs() const = 0;
+
+			/**
+			 * Increments the transmission error counter, given a human readable
+			 * reason.
+			 */
+			virtual bool IncrementTxErrorCounter(std::string_view reason) = 0;
+
+			/**
+			 * Clears the transmission error counter.
+			 */
+			virtual void ClearTxErrorCounter() = 0;
+
+			/**
+			 * Returns true if there have been too many retransmission errors.
+			 */
+			virtual bool HasTooManyTxErrors() const = 0;
+
+			virtual std::unique_ptr<Packet> CreatePacket() const = 0;
+
+			virtual void Send(Packet* packet) = 0;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/association/TransmissionControlBlock.hpp

@@ -2,14 +2,17 @@
 #define MS_RTC_SCTP_TRANSMISSION_CONTROL_BLOCK_HPP
 
 #include "common.hpp"
+#include "RTC/SCTP/association/HeartbeatHandler.hpp"
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "RTC/SCTP/association/PacketSender.hpp"
+#include "RTC/SCTP/association/TCBContext.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
 #include "RTC/SCTP/public/AssociationListener.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
 #include "RTC/SCTP/tx/RetransmissionErrorCounter.hpp"
 #include "RTC/SCTP/tx/RetransmissionTimeout.hpp"
 #include "handles/BackoffTimerHandle.hpp"
+#include <string_view>
 #include <vector>
 
 namespace RTC
@@ -22,7 +25,7 @@ namespace RTC
 		 *
 		 * @see https://datatracker.ietf.org/doc/html/rfc9260#section-14
 		 */
-		class TransmissionControlBlock : public BackoffTimerHandle::Listener
+		class TransmissionControlBlock : public TCBContext, public BackoffTimerHandle::Listener
 		{
 		public:
 			TransmissionControlBlock(
@@ -35,13 +38,23 @@ namespace RTC
 			  uint32_t remoteInitialTsn,
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
-			  const NegotiatedCapabilities& negotiatedCapabilities);
+			  const NegotiatedCapabilities& negotiatedCapabilities,
+			  std::function<bool()> isAssociationEstablished);
 
 			~TransmissionControlBlock() override;
 
 		public:
 			void Dump(int indentation = 0) const;
 
+			/**
+			 * @remarks
+			 * - Implements TCBContext interface.
+			 */
+			bool IsAssociationEstablished() const override
+			{
+				return this->isAssociationEstablished();
+			}
+
 			/**
 			 * The value of the Initiate Tag field we put in our INIT or INIT_ACK
 			 * Chunk. Packets sent by the remote peer must include this value in
@@ -65,8 +78,11 @@ namespace RTC
 			/**
 			 * The value of the Initial TSN field we put in our INIT or INIT_ACK
 			 * Chunk.
+			 *
+			 * @remarks
+			 * - Implements TCBContext interface.
 			 */
-			uint32_t GetLocalInitialTsn() const
+			uint32_t GetLocalInitialTsn() const override
 			{
 				return this->localInitialTsn;
 			}
@@ -74,8 +90,11 @@ namespace RTC
 			/**
 			 * The value of the Initial TSN field the peer put in its INIT or
 			 * INIT_ACK Chunk.
+			 *
+			 * @remarks
+			 * - Implements TCBContext interface.
 			 */
-			uint32_t GetRemoteInitialTsn() const
+			uint32_t GetRemoteInitialTsn() const override
 			{
 				return this->remoteInitialTsn;
 			}
@@ -105,9 +124,17 @@ namespace RTC
 				return this->negotiatedCapabilities;
 			}
 
-			void ObserveRtt(uint64_t rtt);
+			/**
+			 * @remarks
+			 * - Implements TCBContext interface.
+			 */
+			void ObserveRtt(uint64_t rtt) override;
 
-			uint64_t GetCurrentRtoMs() const
+			/**
+			 * @remarks
+			 * - Implements TCBContext interface.
+			 */
+			uint64_t GetCurrentRtoMs() const override
 			{
 				return this->rto.GetRtoMs();
 			}
@@ -117,10 +144,25 @@ namespace RTC
 				return this->rto.GetSrttMs();
 			}
 
-			std::unique_ptr<Packet> CreatePacket() const;
+			/**
+			 * @remarks
+			 * - Implements TCBContext interface.
+			 */
+			std::unique_ptr<Packet> CreatePacket() const override;
 
 			std::unique_ptr<Packet> CreatePacketWithVerificationTag(uint32_t verificationTag) const;
 
+			/**
+			 * @remarks
+			 * - Implements TCBContext interface.
+			 */
+			void Send(Packet* packet) override;
+
+			HeartbeatHandler& GetHeartbeatHandler()
+			{
+				return this->heartbeatHandler;
+			}
+
 			void SetRemoteStateCookie(std::vector<uint8_t> remoteStateCookie);
 
 			void ClearRemoteStateCookie();
@@ -132,9 +174,34 @@ namespace RTC
 
 			void MaySendSackChunk();
 
-		private:
-			void Send(Packet* packet);
+			/**
+			 * @remarks
+			 * - Implements TCBContext interface.
+			 */
+			bool IncrementTxErrorCounter(std::string_view reason) override
+			{
+				return this->txErrorCounter.Increment(reason);
+			}
+
+			/**
+			 * @remarks
+			 * - Implements TCBContext interface.
+			 */
+			void ClearTxErrorCounter() override
+			{
+				return this->txErrorCounter.Clear();
+			}
+
+			/**
+			 * @remarks
+			 * - Implements TCBContext interface.
+			 */
+			bool HasTooManyTxErrors() const override
+			{
+				return this->txErrorCounter.IsExhausted();
+			}
 
+		private:
 			void OnT3RtxTimer(uint64_t& baseTimeoutMs, bool& stop);
 
 			void OnDelayedAckTimer(uint64_t& baseTimeoutMs, bool& stop);
@@ -155,16 +222,19 @@ namespace RTC
 			// Nonce, used to detect reconnections.
 			uint64_t tieTag{ 0 };
 			NegotiatedCapabilities negotiatedCapabilities;
-			// data retransmission timer).
+			std::function<bool()> isAssociationEstablished;
+			// The data retransmission timer.
 			const std::unique_ptr<BackoffTimerHandle> t3RtxTimer;
 			// Delayed ack timer, which triggers when acks should be sent (when
 			// delayed).
 			const std::unique_ptr<BackoffTimerHandle> delayedAckTimer;
 			RetransmissionTimeout rto;
 			RetransmissionErrorCounter txErrorCounter;
+			HeartbeatHandler heartbeatHandler;
 			// Rate limiting of FORWARD_TSN. Next can be sent at or after this
 			// timestamp.
-			uint64_t limitForwardTsnUntilMs{ 0 };
+			// TODO: SCTP: Uncomment.
+			// uint64_t limitForwardTsnUntilMs{ 0 };
 			// Only valid when state is State::COOKIE_ECHOED. In this state, the
 			// Association must wait for COOKIE_ACK to continue sending any packets (not
 			// including a COOKIE_ECHO). So if this state cookie is present, the