mediasoup 3.20.2 → 3.20.4

package/npm-scripts.mjs

@@ -232,6 +232,12 @@ async function run() {
 			break;
 		}
 
+		case 'publish:dry-run': {
+			publishDryRun();
+
+			break;
+		}
+
 		case 'release:check': {
 			await checkRelease();
 
@@ -511,6 +517,23 @@ function installNodeDeps() {
 	executeCmd('npm audit --prefix worker/scripts');
 }
 
+function publishDryRun() {
+	logInfo('publishDryRun()');
+
+	// NOTE: We use `npm pack --dry-run` rather than `npm publish --dry-run`
+	// because the latter contacts the registry and fails with "You cannot
+	// publish over the previously published versions" whenever the version in
+	// package.json is already published (which is the usual state between
+	// releases), making it useless in CI.
+	//
+	// `npm pack --dry-run` still runs the `prepare` script (flatbuffers
+	// generation and TypeScript build) and assembles the tarball exactly as a
+	// real publish would, reporting its contents without writing any file or
+	// contacting the registry. Useful to validate the `files` list in
+	// package.json and that the package builds before tagging a release.
+	executeCmd('npm pack --dry-run');
+}
+
 async function checkRelease() {
 	logInfo('checkRelease()');
 
@@ -522,6 +545,9 @@ async function checkRelease() {
 	lintWorker();
 	testNode();
 	testWorker();
+	// Validate packaging (the `files` list in package.json) before the
+	// irreversible release steps (git push, GitHub release, npm publish).
+	publishDryRun();
 }
 
 async function release() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.20.2",
+	"version": "3.20.4",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -96,6 +96,7 @@
 		"test:worker": "node npm-scripts.mjs test:worker",
 		"coverage": "node npm-scripts.mjs coverage:node",
 		"coverage:node": "node npm-scripts.mjs coverage:node",
+		"publish:dry-run": "node npm-scripts.mjs publish:dry-run",
 		"release:check": "node npm-scripts.mjs release:check",
 		"release": "node npm-scripts.mjs release"
 	},
@@ -121,8 +122,8 @@
 		"globals": "^17.6.0",
 		"ini": "^6.0.0",
 		"jest": "^30.4.2",
-		"knip": "^6.15.0",
-		"marked": "^18.0.4",
+		"knip": "^6.16.1",
+		"marked": "^18.0.5",
 		"open-cli": "^9.0.0",
 		"pick-port": "^2.2.0",
 		"prettier": "^3.8.3",

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

@@ -53,7 +53,8 @@ namespace RTC
 		 */
 		class Association : public AssociationInterface,
 		                    public PacketSender::Listener,
-		                    public BackoffTimerHandleInterface::Listener
+		                    public BackoffTimerHandleInterface::Listener,
+		                    public TransmissionControlBlockContextInterface::Listener
 		{
 		public:
 			/**
@@ -172,7 +173,13 @@ namespace RTC
 			  const SctpOptions& sctpOptions,
 			  AssociationListenerInterface* listener,
 			  SharedInterface* shared,
-			  bool isDataChannel);
+			  bool isDataChannel,
+			  // Whether `MayConnect()` should be called when SCTP data is received.
+			  // This is always true in production (the association auto-initiates the
+			  // connection as soon as the transport is ready or data arrives). It's
+			  // only set to false in tests that need a purely passive peer to mimic
+			  // dcsctp's asymmetric handshake.
+			  bool mayConnectOnReceivedSctpData);
 
 			~Association() override;
 
@@ -494,6 +501,10 @@ namespace RTC
 			void OnBackoffTimer(
 			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
+			/* Pure virtual methods inherited from TransmissionControlBlockContextInterface::Listener. */
+		public:
+			void OnTransmissionControlBlockTooManyTxErrors() override;
+
 		private:
 			// SCTP options given in the constructor.
 			SctpOptions sctpOptions;
@@ -526,6 +537,9 @@ namespace RTC
 			const size_t maxPacketLength;
 			// Whether this is DataChannel based SCTP.
 			bool isDataChannel;
+			// Whether `MayConnect()` should be called when SCTP data is received.
+			// See the constructor for details.
+			bool mayConnectOnReceivedSctpData;
 		};
 	} // namespace SCTP
 } // namespace RTC

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

@@ -3,10 +3,10 @@
 
 #include "common.hpp"
 #include "handles/BackoffTimerHandleInterface.hpp"
+#include "RTC/SCTP/association/AssociationListenerDeferrer.hpp"
 #include "RTC/SCTP/association/TransmissionControlBlockContextInterface.hpp"
 #include "RTC/SCTP/packet/chunks/HeartbeatAckChunk.hpp"
 #include "RTC/SCTP/packet/chunks/HeartbeatRequestChunk.hpp"
-#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
 #include "SharedInterface.hpp"
 
@@ -26,7 +26,7 @@ namespace RTC
 		{
 		public:
 			HeartbeatHandler(
-			  AssociationListenerInterface& associationListener,
+			  AssociationListenerDeferrer& associationListenerDeferrer,
 			  const SctpOptions& sctpOptions,
 			  SharedInterface* shared,
 			  TransmissionControlBlockContextInterface* tcbContext);
@@ -63,7 +63,7 @@ namespace RTC
 			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
-			AssociationListenerInterface& associationListener;
+			AssociationListenerDeferrer& associationListenerDeferrer;
 			const SctpOptions sctpOptions;
 			SharedInterface* shared;
 			TransmissionControlBlockContextInterface* tcbContext;

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

@@ -4,13 +4,13 @@
 #include "common.hpp"
 #include "Utils/UnwrappedSequenceNumber.hpp"
 #include "handles/BackoffTimerHandleInterface.hpp"
+#include "RTC/SCTP/association/AssociationListenerDeferrer.hpp"
 #include "RTC/SCTP/association/TransmissionControlBlockContextInterface.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/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/rx/DataTracker.hpp"
 #include "RTC/SCTP/rx/ReassemblyQueue.hpp"
 #include "RTC/SCTP/tx/RetransmissionQueue.hpp"
@@ -168,7 +168,7 @@ namespace RTC
 
 		public:
 			StreamResetHandler(
-			  AssociationListenerInterface& associationListener,
+			  AssociationListenerDeferrer& associationListenerDeferrer,
 			  SharedInterface* shared,
 			  TransmissionControlBlockContextInterface* tcbContext,
 			  DataTracker* dataTracker,
@@ -263,7 +263,7 @@ namespace RTC
 			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
-			AssociationListenerInterface& associationListener;
+			AssociationListenerDeferrer& associationListenerDeferrer;
 			SharedInterface* shared;
 			TransmissionControlBlockContextInterface* tcbContext;
 			DataTracker* dataTracker;

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

@@ -3,13 +3,13 @@
 
 #include "common.hpp"
 #include "handles/BackoffTimerHandleInterface.hpp"
+#include "RTC/SCTP/association/AssociationListenerDeferrer.hpp"
 #include "RTC/SCTP/association/HeartbeatHandler.hpp"
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "RTC/SCTP/association/PacketSender.hpp"
 #include "RTC/SCTP/association/StreamResetHandler.hpp"
 #include "RTC/SCTP/association/TransmissionControlBlockContextInterface.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
-#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
 #include "RTC/SCTP/rx/DataTracker.hpp"
 #include "RTC/SCTP/rx/ReassemblyQueue.hpp"
@@ -37,7 +37,8 @@ namespace RTC
 		{
 		public:
 			TransmissionControlBlock(
-			  AssociationListenerInterface& associationListener,
+			  TransmissionControlBlockContextInterface::Listener* listener,
+			  AssociationListenerDeferrer& associationListenerDeferrer,
 			  const SctpOptions& sctpOptions,
 			  SharedInterface* shared,
 			  SendQueueInterface& sendQueue,
@@ -250,7 +251,20 @@ namespace RTC
 			 */
 			bool IncrementTxErrorCounter(std::string_view reason) override
 			{
-				return this->txErrorCounter.Increment(reason);
+				const bool withinLimit = this->txErrorCounter.Increment(reason);
+
+				if (!withinLimit)
+				{
+					// NOTE: This closes (and destroys) this TCB synchronously. It's safe to
+					// do so from within a timer handler because the handler sets the
+					// BackoffTimerHandle `stop` flag and doesn't touch any member
+					// afterwards, so the (now destroyed) firing timer won't be accessed.
+					this->listener->OnTransmissionControlBlockTooManyTxErrors();
+				}
+
+				// NOTE: `withinLimit` is a local, so this is safe even if `this` was
+				// destroyed above.
+				return withinLimit;
 			}
 
 			/**
@@ -288,7 +302,8 @@ namespace RTC
 			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
-			AssociationListenerInterface& associationListener;
+			TransmissionControlBlockContextInterface::Listener* listener;
+			AssociationListenerDeferrer& associationListenerDeferrer;
 			const SctpOptions sctpOptions;
 			SharedInterface* shared;
 			PacketSender& packetSender;

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

@@ -11,6 +11,23 @@ namespace RTC
 	{
 		class TransmissionControlBlockContextInterface
 		{
+		public:
+			class Listener
+			{
+			public:
+				virtual ~Listener() = default;
+
+			public:
+				/**
+				 * Called when the transmission error counter has exceeded its limit and
+				 * the association must therefore be closed.
+				 *
+				 * @remarks
+				 * - It mirrors dcsctp's `CloseConnectionBecauseOfTooManyTransmissionErrors()`.
+				 */
+				virtual void OnTransmissionControlBlockTooManyTxErrors() = 0;
+			};
+
 		public:
 			virtual ~TransmissionControlBlockContextInterface() = default;
 
@@ -44,8 +61,8 @@ namespace RTC
 
 			/**
 			 * Increments the transmission error counter, given a human readable
-			 * reason. Returns `true` if the maximum error count has been reached,
-			 * `false` will be returned.
+			 * reason. Returns `false` if the maximum error count has been reached,
+			 * `true` otherwise.
 			 */
 			virtual bool IncrementTxErrorCounter(std::string_view reason) = 0;
 

package/worker/include/RTC/SCTP/public/SctpTypes.hpp

@@ -331,6 +331,8 @@ namespace RTC
 					{
 						return "ERROR_SHUTTING_DOWN";
 					}
+
+						NO_DEFAULT_GCC();
 				}
 			}
 

package/worker/include/RTC/SCTP/rx/ReassemblyQueue.hpp

@@ -178,6 +178,13 @@ namespace RTC
 			  ReassemblyStreamsInterface::OnAssembledMessage onAssembledMessage,
 			  bool useMessageInterleaving);
 
+			/**
+			 * Treat Forward-TSN message as payload. size is calculated based on wire
+			 * size rather than used memory size: 32bit for TSN + 16+16 bits for each
+			 * skipped stream entry.
+			 */
+			size_t ForwardTsnCost(size_t numStreams);
+
 			void AddReassembledMessage(std::span<const Types::UnwrappedTsn> tsns, Message message);
 
 			void AssertIsConsistent() const;

package/worker/include/RTC/SCTP/tx/RetransmissionErrorCounter.hpp

@@ -18,7 +18,7 @@ namespace RTC
 		class RetransmissionErrorCounter
 		{
 		public:
-			RetransmissionErrorCounter(const SctpOptions& sctpOptions);
+			explicit RetransmissionErrorCounter(const SctpOptions& sctpOptions);
 
 			~RetransmissionErrorCounter();
 
@@ -26,14 +26,13 @@ namespace RTC
 			void Dump(int indentation = 0) const;
 
 			/**
-			 * Increments the retransmission timer. Returns `true` if the maximum
-			 * error count has been reached, `false` will be returned.
+			 * Increments the retransmission timer. Returns `false` if the maximum
+			 * error count has been reached, `true` otherwise.
 			 */
 			bool Increment(std::string_view reason);
 
 			/**
 			 * Whether maximum error count has been reached.
-			 * @return [description]
 			 */
 			bool IsExhausted() const
 			{

package/worker/meson.build

@@ -494,9 +494,12 @@ test_sources = [
   'test/src/RTC/RTCP/TestPacket.cpp',
   'test/src/RTC/RTCP/TestXr.cpp',
   'test/src/RTC/SCTP/sctpCommon.cpp',
+  'test/src/RTC/SCTP/association/TestAssociation.cpp',
   'test/src/RTC/SCTP/association/TestHeartbeatHandler.cpp',
   'test/src/RTC/SCTP/association/TestNegotiatedCapabilities.cpp',
+  'test/src/RTC/SCTP/association/TestPacketSender.cpp',
   'test/src/RTC/SCTP/association/TestStateCookie.cpp',
+  'test/src/RTC/SCTP/association/TestStreamResetHandler.cpp',
   'test/src/RTC/SCTP/association/TestTransmissionControlBlock.cpp',
   'test/src/RTC/SCTP/rx/TestDataTracker.cpp',
   'test/src/RTC/SCTP/rx/TestInterleavedReassemblyStreams.cpp',

package/worker/mocks/include/RTC/SCTP/association/MockAssociationListener.hpp

@@ -21,7 +21,7 @@ namespace mocks
 				{
 					this->sentPackets.emplace_back(data, data + len);
 
-					return true;
+					return this->sendDataResult;
 				}
 
 				void OnAssociationConnecting() override
@@ -75,20 +75,35 @@ namespace mocks
 					this->receivedMessages.emplace_back(std::move(message));
 				}
 
-				void OnAssociationStreamsResetPerformed(std::span<const uint16_t> /*outboundStreamIds*/) override
+				void OnAssociationStreamsResetPerformed(std::span<const uint16_t> outboundStreamIds) override
 				{
-					// TODO: Do something here for tests.
+					++this->onStreamsResetPerformedCalls;
+
+					for (const auto streamId : outboundStreamIds)
+					{
+						this->streamsResetPerformed.insert(streamId);
+					}
 				}
 
 				void OnAssociationStreamsResetFailed(
-				  std::span<const uint16_t> /*outboundStreamIds*/, std::string_view /*errorMessage*/) override
+				  std::span<const uint16_t> outboundStreamIds, std::string_view /*errorMessage*/) override
 				{
-					// TODO: Do something here for tests.
+					++this->onStreamsResetFailedCalls;
+
+					for (const auto streamId : outboundStreamIds)
+					{
+						this->streamsResetFailed.insert(streamId);
+					}
 				}
 
-				void OnAssociationInboundStreamsReset(std::span<const uint16_t> /*inboundStreamIds*/) override
+				void OnAssociationInboundStreamsReset(std::span<const uint16_t> inboundStreamIds) override
 				{
-					// TODO: Do something here for tests.
+					++this->onInboundStreamsResetCalls;
+
+					for (const auto streamId : inboundStreamIds)
+					{
+						this->inboundStreamsReset.insert(streamId);
+					}
 				}
 
 				void OnAssociationStreamBufferedAmountLow(uint16_t streamId) override
@@ -208,6 +223,45 @@ namespace mocks
 					return this->onTotalBufferedAmountLowCalls;
 				}
 
+				size_t CountOnStreamsResetPerformedCalls() const
+				{
+					return this->onStreamsResetPerformedCalls;
+				}
+
+				bool HasStreamsResetPerformedForStreamId(uint16_t streamId) const
+				{
+					return this->streamsResetPerformed.contains(streamId);
+				}
+
+				size_t CountOnStreamsResetFailedCalls() const
+				{
+					return this->onStreamsResetFailedCalls;
+				}
+
+				bool HasStreamsResetFailedForStreamId(uint16_t streamId) const
+				{
+					return this->streamsResetFailed.contains(streamId);
+				}
+
+				size_t CountOnInboundStreamsResetCalls() const
+				{
+					return this->onInboundStreamsResetCalls;
+				}
+
+				bool HasInboundStreamsResetForStreamId(uint16_t streamId) const
+				{
+					return this->inboundStreamsReset.contains(streamId);
+				}
+
+				/**
+				 * Sets the value that `OnAssociationSendData()` will return, allowing
+				 * tests to simulate a failed send.
+				 */
+				void SetSendDataResult(bool sendDataResult)
+				{
+					this->sendDataResult = sendDataResult;
+				}
+
 				bool HasSentPackets() const
 				{
 					return !this->sentPackets.empty();
@@ -293,6 +347,13 @@ namespace mocks
 				std::string erroredErrorMessage;
 				std::map<uint16_t /*streamId*/, size_t /*count*/> onStreamBufferedAmountLowCalls;
 				size_t onTotalBufferedAmountLowCalls{ 0 };
+				size_t onStreamsResetPerformedCalls{ 0 };
+				std::set<uint16_t /*streamId*/> streamsResetPerformed;
+				size_t onStreamsResetFailedCalls{ 0 };
+				std::set<uint16_t /*streamId*/> streamsResetFailed;
+				size_t onInboundStreamsResetCalls{ 0 };
+				std::set<uint16_t /*streamId*/> inboundStreamsReset;
+				bool sendDataResult{ true };
 				std::deque<std::vector<uint8_t>> sentPackets;
 				std::deque<::RTC::SCTP::Message> receivedMessages;
 				bool transportReady{ true };

package/worker/mocks/include/handles/MockBackoffTimerHandle.hpp

@@ -36,14 +36,20 @@ namespace mocks
 
 		void Start() override
 		{
-			this->running     = true;
-			this->expiresAtMs = this->getTimeMs() + ComputeNextTimeoutMs();
+			this->running = true;
+			// NOTE: Reset the expiration count, just like the real BackoffTimerHandle
+			// does, so that the backoff starts over from the base timeout.
+			this->expirationCount = 0;
+			this->expiresAtMs     = this->getTimeMs() + ComputeNextTimeoutMs();
 		}
 
 		void Stop() override
 		{
-			this->running     = false;
-			this->expiresAtMs = std::numeric_limits<uint64_t>::max();
+			this->running = false;
+			// NOTE: Reset the expiration count, just like the real BackoffTimerHandle
+			// does.
+			this->expirationCount = 0;
+			this->expiresAtMs     = std::numeric_limits<uint64_t>::max();
 		}
 
 		/**

package/worker/mocks/src/handles/MockBackoffTimerHandle.cpp

@@ -123,5 +123,12 @@ namespace mocks
 		{
 			this->expiresAtMs = this->getTimeMs() + ComputeNextTimeoutMs();
 		}
+		// Once the timer is no longer running (e.g. max restarts reached), the real
+		// BackoffTimerHandle doesn't restart the underlying timer, so it won't fire
+		// again. Mirror that here so a stopped timer doesn't keep expiring.
+		else
+		{
+			this->expiresAtMs = std::numeric_limits<uint64_t>::max();
+		}
 	}
 } // namespace mocks

package/worker/src/RTC/SCTP/association/Association.cpp

@@ -40,7 +40,8 @@ namespace RTC
 		  const SctpOptions& sctpOptions,
 		  AssociationListenerInterface* listener,
 		  SharedInterface* shared,
-		  bool isDataChannel)
+		  bool isDataChannel,
+		  bool mayConnectOnReceivedSctpData)
 		  : sctpOptions(sctpOptions),
 		    // Our `listener` member is a `AssociationListenerDeferrer` which takes
 		    // `listener` argument as constructor argument.
@@ -78,7 +79,8 @@ namespace RTC
 		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
 		        .maxRestarts         = sctpOptions.maxRetransmissions })),
 		    maxPacketLength(Utils::Byte::PadDownTo4Bytes(this->sctpOptions.mtu)),
-		    isDataChannel(isDataChannel)
+		    isDataChannel(isDataChannel),
+		    mayConnectOnReceivedSctpData(mayConnectOnReceivedSctpData)
 		{
 			MS_TRACE();
 		}
@@ -542,7 +544,13 @@ namespace RTC
 
 			// If we are received SCTP data from the remote peer it means that we may
 			// initiate the SCTP association (if not already connected).
-			MayConnect();
+			//
+			// NOTE: This is disabled in tests that need a purely passive peer to
+			// mimic dcsctp's asymmetric handshake.
+			if (this->mayConnectOnReceivedSctpData)
+			{
+				MayConnect();
+			}
 
 			// NOTE: It's important to create the deferrer here, otherwise it may
 			// happen that MayConnect() ends calling to Connect() so we end with two
@@ -749,6 +757,7 @@ namespace RTC
 			MS_TRACE();
 
 			this->tcb = std::make_unique<TransmissionControlBlock>(
+			  this,
 			  this->associationListenerDeferrer,
 			  this->sctpOptions,
 			  this->shared,
@@ -2425,6 +2434,15 @@ namespace RTC
 		{
 			MS_TRACE();
 
+			const auto maxRestarts = this->t1InitTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->t1InitTimer->GetLabel().c_str(),
+			  this->t1InitTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			AssertState(State::COOKIE_WAIT);
@@ -2445,6 +2463,15 @@ namespace RTC
 		{
 			MS_TRACE();
 
+			const auto maxRestarts = this->t1CookieTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->t1CookieTimer->GetLabel().c_str(),
+			  this->t1CookieTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			AssertState(State::COOKIE_ECHOED);
@@ -2467,6 +2494,15 @@ namespace RTC
 		{
 			MS_TRACE();
 
+			const auto maxRestarts = this->t2ShutdownTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->t2ShutdownTimer->GetLabel().c_str(),
+			  this->t2ShutdownTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			AssertState(State::SHUTDOWN_SENT, State::SHUTDOWN_ACK_SENT);
 			AssertHasTcb();
 
@@ -2811,15 +2847,6 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			const auto maxRestarts = backoffTimer->GetMaxRestarts();
-
-			MS_DEBUG_TAG(
-			  sctp,
-			  "%s timer has expired [expìrations:%zu/%s]",
-			  backoffTimer->GetLabel().c_str(),
-			  backoffTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
-
 			if (backoffTimer == this->t1InitTimer.get())
 			{
 				OnT1InitTimer(baseTimeoutMs, stop);
@@ -2833,5 +2860,18 @@ namespace RTC
 				OnT2ShutdownTimer(baseTimeoutMs, stop);
 			}
 		}
+
+		void Association::OnTransmissionControlBlockTooManyTxErrors()
+		{
+			MS_TRACE();
+
+			// NOTE: This is invoked from within a TCB timer handler (t3-rtx, heartbeat
+			// or RE-CONFIG timeout). `InternalClose()` destroys the TCB synchronously,
+			// which is safe because the calling timer handler sets the BackoffTimerHandle
+			// `stop` flag and doesn't touch any member afterwards. `InternalClose()` does
+			// not establish its own deferrer scope, so it relies on the active one set up
+			// by the timer handler.
+			InternalClose(Types::ErrorKind::TOO_MANY_RETRIES, "too many transmission errors");
+		}
 	} // namespace SCTP
 } // namespace RTC