mediasoup 3.20.3 → 3.20.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.20.3",
+	"version": "3.20.4",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -122,7 +122,7 @@
 		"globals": "^17.6.0",
 		"ini": "^6.0.0",
 		"jest": "^30.4.2",
-		"knip": "^6.15.0",
+		"knip": "^6.16.1",
 		"marked": "^18.0.5",
 		"open-cli": "^9.0.0",
 		"pick-port": "^2.2.0",

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/TransmissionControlBlock.hpp

@@ -37,6 +37,7 @@ namespace RTC
 		{
 		public:
 			TransmissionControlBlock(
+			  TransmissionControlBlockContextInterface::Listener* listener,
 			  AssociationListenerDeferrer& associationListenerDeferrer,
 			  const SctpOptions& sctpOptions,
 			  SharedInterface* shared,
@@ -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,6 +302,7 @@ namespace RTC
 			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
+			TransmissionControlBlockContextInterface::Listener* listener;
 			AssociationListenerDeferrer& associationListenerDeferrer;
 			const SctpOptions sctpOptions;
 			SharedInterface* shared;

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

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

@@ -34,7 +34,7 @@ namespace RTC
 		        .listener            = this,
 		        .label               = "sctp-heartbeat-interval",
 		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
-		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::FIXED,
 		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
 		        .maxRestarts         = std::nullopt })),
 		    timeoutTimer(this->shared->CreateBackoffTimer(
@@ -42,7 +42,7 @@ namespace RTC
 		        .listener            = this,
 		        .label               = "sctp-heartbeat-timeout",
 		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
-		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::FIXED,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
 		        .maxBackoffTimeoutMs = std::nullopt,
 		        .maxRestarts         = 0 }))
 		{
@@ -180,6 +180,18 @@ namespace RTC
 		{
 			MS_TRACE();
 
+#if MS_LOG_DEV_LEVEL == 3
+			const auto maxRestarts = this->intervalTimer->GetMaxRestarts();
+#endif
+
+			// NOTE: This timer expires periodically on idle connections (forever), so
+			// it's logged at dev level to avoid being noisy.
+			MS_DEBUG_DEV(
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->intervalTimer->GetLabel().c_str(),
+			  this->intervalTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			// This is a top-level timer entry point (invoked by libuv outside any other
 			// SCTP API call), so it must establish the deferrer scope itself, just like
 			// Association does in its own timer handlers.
@@ -215,10 +227,19 @@ namespace RTC
 			this->tcbContext->SendPacket(packet.get());
 		}
 
-		void HeartbeatHandler::OnTimeoutTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		void HeartbeatHandler::OnTimeoutTimer(uint64_t& /*baseTimeoutMs*/, bool& stop)
 		{
 			MS_TRACE();
 
+			const auto maxRestarts = this->timeoutTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->timeoutTimer->GetLabel().c_str(),
+			  this->timeoutTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			// This is a top-level timer entry point (invoked by libuv outside any other
 			// SCTP API call), so it must establish the deferrer scope itself, just like
 			// Association does in its own timer handlers.
@@ -228,7 +249,15 @@ namespace RTC
 			// the interval timer expires.
 			MS_ASSERT(!this->timeoutTimer->IsRunning(), "timeout timer shouldn't be running");
 
-			this->tcbContext->IncrementTxErrorCounter("hearbeat timeout");
+			if (!this->tcbContext->IncrementTxErrorCounter("hearbeat timeout"))
+			{
+				// `IncrementTxErrorCounter()` has closed (and destroyed) the TCB (and
+				// hence this HeartbeatHandler and its timers). Signal the firing timer to
+				// stop and don't touch any member afterwards.
+				stop = true;
+
+				return;
+			}
 		}
 
 		void HeartbeatHandler::OnBackoffTimer(
@@ -236,15 +265,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->intervalTimer.get())
 			{
 				OnIntervalTimer(baseTimeoutMs, stop);

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

@@ -465,10 +465,19 @@ namespace RTC
 			}
 		}
 
-		void StreamResetHandler::OnReConfigTimer(uint64_t& baseTimeoutMs, bool& /*stop*/)
+		void StreamResetHandler::OnReConfigTimer(uint64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 
+			const auto maxRestarts = this->reConfigTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->reConfigTimer->GetLabel().c_str(),
+			  this->reConfigTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			// This is a top-level timer entry point (invoked by libuv outside any other
 			// SCTP API call), so it must establish the deferrer scope itself, just like
 			// Association does in its own timer handlers.
@@ -486,7 +495,11 @@ namespace RTC
 				// response.
 				else if (!this->tcbContext->IncrementTxErrorCounter("RECONFIG timeout"))
 				{
-					// Timed out. The connection will close after processing the timers.
+					// `IncrementTxErrorCounter()` has closed (and destroyed) the TCB (and
+					// hence this StreamResetHandler and its timer). Signal the firing timer
+					// to stop and don't touch any member afterwards.
+					stop = true;
+
 					return;
 				}
 			}
@@ -511,15 +524,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->reConfigTimer.get())
 			{
 				OnReConfigTimer(baseTimeoutMs, stop);